Les résultats de cette fois

Impressions de cette époque

J'aurais dû être forte, mais j'étais nerveuse au concours pour la première fois en trois semaines et j'ai fini par ne pas pouvoir démontrer mes capacités. Même si j'ai terminé le problème C en environ 7 minutes au total, je n'ai pas pu résoudre le problème D et au-delà à cause d'un bug dans ma tête (je n'ai pas vu le problème F). Il est important de revenir à la normale rapidement, mais lors d'un test important, ce sera toujours un voile blanc, donc je pense que je dois faire de mon mieux dans le concours en supposant que ce sera un voile blanc. (Si vous devenez blanc, j'apprécierais que vous me disiez quoi faire). De plus, si vous avez des capacités écrasantes (codeur bleu ou supérieur), vous pouvez certainement le résoudre, donc je pense que le seul raccourci est de vous consacrer. Post-scriptum: Immédiatement après le concours, j'ai pensé que je ne serais pas un professionnel de la compétition à vie, mais le désir de me consacrer semble prévaloir. Le tarif n'augmente pas comme prévu, mais j'aimerais continuer mes efforts jusqu'à avant les vacances d'été.

Problème A

Le problème A est plus rapide avec l'opérateur ternaire.

`A.py`


s=input()
print("Yes" if s[2]==s[3] and s[4]==s[5] else "No")

Problème B

La priorité étant supérieure de l'ordre de 500 → 5, elle est calculée comme telle.

`B.py`


x=int(input())
y=x//500
z=(x-y*500)//5
print(y*1000+z*5)

Problème C

Vous pouvez voir que la distance la plus courte est de traverser chaque maison une seule fois et toutes les maisons. En supposant que vous suivez de la première maison à la Nième maison dans l'ordre, vous pouvez voir que la distance entre la 1ère maison et la Nième maison est plus courte qu'autour du lac, qui est de K mètres autour. Par conséquent, K mètres- (la plus grande distance entre les maisons adjacentes) est la réponse que vous recherchez.

`C.py`


k,n=map(int,input().split())
a=list(map(int,input().split()))
ma=0
for i in range(n-1):
    ma=max(ma,a[i+1]-a[i])
print(k-max(ma,a[0]+k-a[n-1]))

Problème D

Puisque $ n = 10 ^ 3 $, je n'ai pas remarqué que même $ O (n ^ 2) $ passait, alors j'ai fondu l'heure. Je suis trop fou. Tout d'abord, ** L'estimation de la quantité de calcul est basique , et j'ai essayé l'exemple de cas 3 ( L'expérimentation avec des échantillons est également basique **), mais cela n'a pas fonctionné, et je l'ai confirmé après le concours * * Il y avait un motif ** que j'ai oublié de compter ... Tout d'abord, la caractéristique de ce problème est que X et Y sont connectés. De plus, si vous constatez que XY ne passe qu'une seule fois car c'est la distance la plus courte, vous pouvez penser qu'il vaut mieux classer par ** XY ou non ** lorsque (i, j) est défini. Je vais. Si vous pouvez faire ce ** changement de pensée **, vous pouvez rapidement le transformer en un problème simple. La distance la plus courte en ne passant pas par X-Y est j-i, et la distance la plus courte lors du passage est $ abs (X-i) + abs (j-Y) + 1 $ (1 est la distance la plus courte de X-Y). Essayez ceci pour tous (i, j) et c'est $ O (n ^ 2) $, et la réponse est d'enregistrer dans l'ordre laquelle des distances les plus courtes 1 à n-1 sera dans un tableau préparé séparément. Vous pouvez demander.

Ce que j'ai le plus appris sur ce problème

Si même l'échantillon ne convient pas, écrivez-le à la main et vérifiez si votre considération est correcte

n'est-ce pas.

`answerD.py`


n,x,y=map(int,input().split())
ans=[[1000000]*n for i in range(n)]
for i in range(n-1):
    for j in range(i+1,n):
        ans[i][j]=min(j-i,abs(x-1-i)+1+abs(y-1-j))
_ans=[0]*(n-1)
for i in range(n-1):
    for j in range(i+1,n):
        _ans[ans[i][j]-1]+=1
for i in range(n-1):
    print(_ans[i])

E problème

Je ne pouvais pas résoudre ce problème car j'étais impatient avec le problème D, mais ce n'était pas difficile. ** La lecture erronée de l'énoncé du problème ** était horrible et j'ai mal compris que ** je devais sélectionner une ou plusieurs pommes incolores **. De plus, le code était assez compliqué car je choisissais des pommes rouges et des pommes vertes tout en choisissant des pommes incolores en même temps. Après tout, si vous les sélectionnez en même temps, la symétrie sera perdue en fonction de laquelle des pommes rouges et des pommes vertes vous sélectionnez ** en premier **, et vous pouvez oublier de les compter. Alors, voici ** pour maintenir la symétrie **, x pommes rouges et x x pommes vertes dans l'ordre de celle qui a le plus grand goût ** quel que soit le goût des pommes incolores ** Choisissez (notez que choisir plus de x et plus de y n'est pas inclus dans les candidats x + y à manger). Après avoir fait cela, vous pouvez penser au nombre de pommes incolores à choisir et les choisir par ordre décroissant de saveur. En outre, ** les pommes incolores peuvent être échangées contre les x pommes rouges sélectionnées et les y pommes vertes **, de sorte que les pommes rouges et les pommes vertes ** ensemble ** sont moins délicieuses. Vous pouvez les ranger dans l'ordre et les remplacer par les pommes incolores dans l'ordre de la plus petite (si les pommes incolores sont moins délicieuses, vous n'avez pas besoin de les remplacer, donc le goût total des pommes est maximisé à ce moment). Aussi, au moment où je l'ai vu, je me suis souvenu d'un problème similaire et j'ai utilisé heapq, mais il semblait que je pouvais le résoudre sans utiliser heapq si j'avais une politique appropriée ([Writer solution](https: //img.atcoder]). .jp / abc160 / éditorial.pdf)). Le premier est le code de la solution qui utilise heapq et le second est le code de la solution qui n'utilise pas heapq.

`answerE.py`


import heapq
x,y,a,b,c=map(int,input().split())
def _int(x):
    return -int(x)
p=list(map(_int,input().split()))
q=list(map(_int,input().split()))
r=list(map(_int,input().split()))
heapq.heapify(p)
heapq.heapify(q)
heapq.heapify(r)

ans=[]
heapq.heapify(ans)
for i in range(x):
    _p=heapq.heappop(p)
    heapq.heappush(ans,-_p)
for i in range(y):
    _q=heapq.heappop(q)
    heapq.heappush(ans,-_q)
#ans est dans l'ordre croissant, r est dans l'ordre décroissant
for i in range(x+y):
    if len(r)==0:break
    _ans=heapq.heappop(ans)
    _r=-heapq.heappop(r)
    if _r>=_ans:
        heapq.heappush(ans,_r)
    else:
        heapq.heappush(ans,_ans)
        break
print(sum(ans))

`answerE_better.py`


x,y,a,b,c=map(int,input().split())

p=sorted(list(map(int,input().split())),reverse=True)[:x]
q=sorted(list(map(int,input().split())),reverse=True)[:y]
r=sorted(list(map(int,input().split())),reverse=True)

p.extend(q)
ans=sorted(p)

#ans est dans l'ordre croissant, r est dans l'ordre décroissant
for i in range(x+y):
    if len(r)==i or r[i]<ans[i]:
        break
    else:
        ans[i]=r[i]
print(sum(ans))

F problem

Je ne peux pas résoudre F cette fois parce que le choc que D et E n'ont pas pu résoudre est grand. Je voudrais le résoudre à une autre occasion.

Critique du concours AtCoder Débutant 160