Benötigte Zeit

Impressionen

Ich habe in den letzten drei Wochen im Ausland studiert und war faul, Spiele zu spielen, ohne Konkurrenz zu spielen. Ich möchte mein Engagement wieder aufnehmen. Ich habe einen grundlegenden Fehler im D-Problem gemacht und bin verwelkt. Ich konnte sehen, dass ich mich in letzter Zeit nicht hingegeben habe ...

Problem A

Seien Sie vorsichtig, denn was Sie wollen, ist Leistung

`answerA.py`


r=int(input())
g=int(input())
print(g*2-r)

B-Problem

Sie sollten es gierig von vorne bewerten.

`answerB.py`


n=int(input())
k=int(input())
x=1
for i in range(n):
    x=min(x+k,2*x)
print(x)

C-Problem

Ich wollte die Wörterbuchreihenfolge gut verwenden, aber ich bin froh, dass ich es getan habe, ohne zu genau darüber zu sein. Die Nummer des Buchstabens S entspricht dem allerersten Buchstaben von T.|S|-|T|+Es gibt einen Weg, und wir werden prüfen, ob ein solches S tatsächlich für jeden von ihnen existiert. Außerdem möchte ich an die kleinste in lexikalischer Reihenfolge denken.?Ersetzen Sie die unbestätigte durch eine. Wenn Sie dies der Reihe nach versuchen und schließlich diejenige mit der kleinsten Wörterbuchreihenfolge unter den Kandidaten ausgeben, können Sie die Antwort ausgeben, die dem Thema entspricht.

`answerC.py`


s=input()
l=len(s)
t=input()
k=len(t)
cand=[]
for i in range(l-k+1):
    new=""
    for j in range(l):
        if i<=j<i+k:
            if s[j]=="?":
                new+=t[j-i]
            else:
                if s[j]==t[j-i]:
                    new+=t[j-i]
                else:
                    break
        else:
            if s[j]=="?":
                new+="a"
            else:
                new+=s[j]
    if len(new)==l:
        cand.append(new)
cand.sort()
if len(cand)==0:
    print("UNRESTORABLE")
else:
    print(cand[0])

D Problem

Es ist schwer zu überlegen und schwer umzusetzen, aber es fühlt sich wie ein blaues Problem an. Zunächst einmal bleiben Sie bei diesem Problem **, wenn Sie die Geschwindigkeit richtig einstellen, im Tempolimit ** stecken, sodass Sie sehen können, dass Sie die Geschwindigkeit in der richtigen Reihenfolge festlegen müssen. Wenn es Abschnitte mit unterschiedlichen Geschwindigkeiten gibt **, können Sie die Geschwindigkeit in allen Abschnitten einstellen, während Sie die Geschwindigkeitsbegrenzung eines Abschnitts einhalten, wenn Sie die Geschwindigkeit innerhalb dieses Abschnitts in der Reihenfolge des Abschnitts mit der niedrigsten Geschwindigkeit ** festlegen (Umgekehrt gibt es Fälle, in denen das Tempolimit nicht eingehalten wird, wenn Sie sich für einen Abschnitt entscheiden, der nicht der Mindestgeschwindigkeit entspricht.) Betrachten Sie hier zunächst die Geschwindigkeit innerhalb des Abschnitts **, was mit der ersten und letzten Geschwindigkeit des Abschnitts ** geschehen wird. Wenn man bedenkt, wie viele Sekunden die Geschwindigkeit von dem anderen Abschnitt entfernt ist, in dem die Geschwindigkeit festgelegt ist, ** beträgt die maximale Geschwindigkeit beim Übergang vom festen Abschnitt zu dem Abschnitt, an den Sie denken Sie können nach ** fragen, was passieren wird. Diese Berechnung wird für den Abschnitt durchgeführt, in dem jede Geschwindigkeit festgelegt ist, und ** die Mindestgeschwindigkeit ist die Antwort **. Es ist auch wichtig zu beachten, dass für benachbarte Abschnitte die letzte Geschwindigkeit des vorherigen Abschnitts gleich der ersten Geschwindigkeit des nächsten Abschnitts ist. Durch Ausführen der obigen Berechnung konnten wir herausfinden, wie hoch die erste und die letzte Geschwindigkeit jedes Abschnitts sein würden, aber ** wir müssen die Geschwindigkeit innerhalb dieses Abschnitts so weit wie möglich erhöhen **. Was ist die Höchstgeschwindigkeit in diesem Abschnitt? Dann mit der folgenden Formel? Infolgedessen kann wie viel Entfernung bis zu diesem Abschnitt zurückgelegt werden. Der maximale Abstand kann durch Hinzufügen für alle Abschnitte erhalten werden.

Der erste Code ist der in Bachacon geschriebene Code, und der zweite Code ist der Code, der den überlappenden Teil des Codes geändert hat.

`answerD.py`


import heapq
n=int(input())
inf=10000000000000
#Halte den Anfang und das Ende
#Ich habe es eine Stunde lang mit demselben Gegenstand geschmolzen.
ans=[[-1,-1] for i in range(n)]
ans[-1][1]=0
ans[0][0]=0
t=list(map(int,input().split()))
v=list(map(int,input().split()))
v2=[]
for i in range(n):
    heapq.heappush(v2,(v[i],i))
for i in range(n):
    #print(ans)
    y=heapq.heappop(v2)
    #print(y[1])
    #print(ans[y[1]])
    #print(y)
    #Entscheide zuerst den Anfang
    if ans[y[1]][0]==-1:
        #print(2)
        now1=0
        ansi1=inf
        for j in range(y[1]-1,-1,-1):
            #print(ans1)
            if ans[j][1]!=-1:
                ansi1=min(ansi1,ans[j][1]+now1)
            now1+=t[j]
            if ans[j][0]!=-1:
                ansi1=min(ansi1,ans[j][0]+now1)
        now1=0
        for j in range(y[1],n):
            if ans[j][0]!=-1:
                ansi1=min(ansi1,ans[j][0]+now1)
            now1+=t[j]
            if ans[j][1]!=-1:
                ansi1=min(ansi1,ans[j][1]+now1)  
        ans[y[1]][0]=min(ansi1,y[0])
        ans[y[1]-1][1]=ans[y[1]][0]
        #print(ansi1)
    if ans[y[1]][1]==-1:
        #print(3)
        now2=0
        ansi2=inf
        for j in range(y[1],-1,-1):
            if ans[j][1]!=-1:
                ansi2=min(ansi2,ans[j][1]+now2)
            now2+=t[j]
            if ans[j][0]!=-1:
                ansi2=min(ansi2,ans[j][0]+now2)
        now2=0
        for j in range(y[1]+1,n):
            if ans[j][0]!=-1:
                ansi2=min(ansi2,ans[j][0]+now2)
            now2+=t[j]
            if ans[j][1]!=-1:
                ansi2=min(ansi2,ans[j][1]+now2)  
        ans[y[1]][1]=min(ansi2,y[0])
        ans[y[1]+1][0]=ans[y[1]][1]
        #print(ansi2)
answer=0
for i in range(n):
    h=min((t[i]+sum(ans[i]))/2,v[i])
    answer+=((h**2-ans[i][0]**2)/2)
    answer+=((h**2-ans[i][1]**2)/2)
    answer+=(h*(t[i]+sum(ans[i])-2*h))
print(answer)
#print(ans)

`answerD_better.py`


import heapq
n=int(input())
inf=10000000000000
ans=[[-1,-1] for i in range(n)]
ans[-1][1],ans[0][0]=0,0
t=list(map(int,input().split()))
v=list(map(int,input().split()))
v2=[]
for i in range(n):
    heapq.heappush(v2,(v[i],i))

def next(y,wh):
    global ans,n
    ansi=inf
    if wh:
        r1,r2=range(y[1]-1,-1,-1),range(y[1],n)
    else:
        r1,r2=range(y[1],-1,-1),range(y[1]+1,n)
    now=0
    for j in r1:
        if ans[j][1]!=-1:
            ansi=min(ansi,ans[j][1]+now)
        now+=t[j]
        if ans[j][0]!=-1:
            ansi=min(ansi,ans[j][0]+now)
    now=0
    for j in r2:
        if ans[j][0]!=-1:
            ansi=min(ansi,ans[j][0]+now)
        now+=t[j]
        if ans[j][1]!=-1:
            ansi=min(ansi,ans[j][1]+now)  
    if wh:
        ans[y[1]][0]=min(ansi,y[0])
        ans[y[1]-1][1]=ans[y[1]][0]
    else:
        ans[y[1]][1]=min(ansi,y[0])
        ans[y[1]+1][0]=ans[y[1]][1]  

for i in range(n):
    y=heapq.heappop(v2)
    if ans[y[1]][0]==-1:next(y,True)
    if ans[y[1]][1]==-1:next(y,False)
answer=0
for i in range(n):
    h=min((t[i]+sum(ans[i]))/2,v[i])
    answer+=((h**2-ans[i][0]**2)/2)
    answer+=((h**2-ans[i][1]**2)/2)
    answer+=(h*(t[i]+sum(ans[i])-2*h))
print(answer)

[PYTHON] AtCoder Beginner Contest 076 Rückblick auf frühere Fragen

Benötigte Zeit

Impressionen

Problem A

answerA.py

B-Problem

answerB.py