2021.03.19

Author: seono

python/gold2/1655.py

@@ -1,10 +1,24 @@
 import sys
-import bisect
+import heapq
 input = sys.stdin.readline
+output = sys.stdout.write
 
 N = int(input())
-arr = []
+left,right = [],[]
+
+ans = []
 for i in range(N):
     n = int(input())
-    idx = bisect.insort(arr,n)
-    print(arr[int(i/2)])
+    if len(left)==len(right):
+        heapq.heappush(left,-n)
+    else:
+        heapq.heappush(right,n)
+    
+    if right and -left[0]>right[0]:
+        l_v = -heapq.heappop(left)
+        r_v = heapq.heappop(right)
+        heapq.heappush(left,-r_v)
+        heapq.heappush(right,l_v)
+    ans.append(-left[0])
+
+output("%s"%'\n'.join(map(str,ans)))

python/gold2/7453.py

@@ -1,25 +1,19 @@
 import sys
-import bisect
 input = sys.stdin.readline
 
 N = int(input())
-a,b,c,d = [0 for _ in range(N)],[0 for _ in range(N)],[0 for _ in range(N)],[0 for _ in range(N)]
+a,b,c,d = [0]*N,[0]*N,[0]*N,[0]*N
 for i in range(N):
     a[i],b[i],c[i],d[i] = map(int, input().split())
-result = 0
+
 ab = []
-cd = []
-for i in a:
-    for j in b:
-        ab.append(i+j)
-for i in c:
-    for j in d:
-        cd.append(i+j)
-ab.sort()
-cd.sort()
-p = ab[0]
-r = N*N
-for ab_ in ab:
-    l,r = bisect.bisect_left(cd,-ab_), bisect.bisect_right(cd,-ab_)
-    result+=r-l
-print(result)
+cd = {}
+for i in range(N):
+    for j in range(N):
+        ab.append(a[i]+b[j])
+        _cd = c[i]+d[i]
+        cd[_cd] = cd.get(_cd,0)+1
+ans = 0
+for num in ab:
+    ans+=cd.get(-num,0)
+print(ans)

python/gold3/11054.py

@@ -0,0 +1,35 @@
+import sys
+input = sys.stdin.readline
+
+N = int(input())
+arr = list(map(int,input().split(' ')))
+
+def getDownArrToRight(idx):
+    p = [arr[idx]]
+    for num in arr[idx+1:]:
+        if num < p[-1]:
+            p.append(num)
+        else:
+            l = len(p)-1
+            while l>-1 and num>=p[l]:
+                l-=1
+            p[l+1]=num
+    return len(p)
+
+def getDownArrToLeft(idx):
+    p = [arr[idx]]
+    for num in reversed(arr[:idx]):
+        if num < p[-1]:
+            p.append(num)
+        else:
+            l = len(p)-1
+            while l>-1 and num>=p[l]:
+                l-=1
+            p[l+1]=num
+    return len(p)
+def sol(num): return getDownArrToLeft(num)+getDownArrToRight(num)-1
+ans = 0
+for i in range(N):
+    if sol(i)>ans:
+        ans=sol(i)
+print(ans)

python/gold3/11066.py

@@ -0,0 +1,30 @@
+import sys
+input = sys.stdin.readline
+
+T = int(input())
+
+
+def sol(st,ed):
+    if dp_arr[st][ed]!=-1:return dp_arr[st][ed]
+    if st==ed:
+        return arr[st]
+    ret = 1e9
+    sum = preSum[ed+1]-preSum[st]
+    for i in range(st,ed):
+        ret = min(sol(st,i)+sol(i+1,ed)+sum,ret)
+    dp_arr[st][ed] = ret
+    return ret
+
+
+while T:
+    T-=1
+    K = int(input())
+    arr = list(map(int,input().split()))
+    preSum = [0]*(K+1)
+    for i in range(1,K+1):
+        preSum[i] = preSum[i-1]+arr[i-1]
+    dp_arr = [[-1]*501 for _ in range(501)]
+    ans = 1e9
+    for i in range(K):
+        ans = min(sol(0,i)+sol(i+1,K-1),ans)
+    print(ans)

python/gold3/14890.py

@@ -0,0 +1,41 @@
+import sys
+input = sys.stdin.readline
+
+N, L = map(int,input().split(' '))
+
+def checkPossible(line):
+    st = line[0]
+    i = 1
+    flag = 1
+    while i<N:
+        num = line[i]
+        i+=1
+        if num==st: 
+            flag+=1
+            continue
+        if abs(num-st)>1: return False
+        if num>st:
+            if flag<L: return False
+            flag = 1
+            st = num
+            continue
+        temp = L-1
+        #L-1개가 같은 높이여야 한다
+        while temp:
+            if i>=N: return False
+            if line[i]!=num: return False
+            temp-=1
+            i+=1
+        flag = 0
+        st = num
+    return True
+
+
+
+arr = [list(map(int,input().split(' '))) for i in range(N)]
+ans = 0
+for i in range(N):
+    ans+=checkPossible(arr[i])
+for i in range(N):
+    ans+=checkPossible([arr[j][i] for j in range(N)])
+print(ans)

python/gold3/1937.py

@@ -0,0 +1,26 @@
+import sys
+input = sys.stdin.readline
+sys.setrecursionlimit(30000)
+
+N = int(input())
+arr = [list(map(int,input().split())) for _ in range(N)]
+
+d = [(0,1),(1,0),(-1,0),(0,-1)]
+
+dp_arr = [[-1]*N for _ in range(N)]
+
+def sol(y,x):
+    if dp_arr[y][x]!=-1: return dp_arr[y][x]
+    ret = 1
+    for dy,dx in d:
+        ny,nx = dy+y, dx+x
+        if ny<0 or ny>=N or nx<0 or nx>=N:continue
+        if arr[ny][nx]>arr[y][x]:
+            ret = max(sol(ny,nx)+1,ret)
+    dp_arr[y][x] = ret
+    return ret
+ans = 0
+for i in range(N):
+    for j in range(N):
+        ans=max(ans,sol(i,j))
+print(ans)

python/gold3/2836.py

@@ -13,12 +13,12 @@
 pst = arr[0][0]
 arr.append([1e9+1,1e9+1])
 for st,ed in arr:
-    if ed<=ped:continue
-    else:
+    if ed<=ped:continue # 돌아가는 거리에 포함되는 사람 제외
+    else: 
         if st>ped:
             ans+=(ped-pst)*2
             pst = st
             ped = ed
-        else:
+        else: # 태워서 돌아오는 도착 지점에 딱 뒤로 가는 손님이 있는 경우
             ped = ed
 print(ans)

python/plat2/15480.py

@@ -0,0 +1,48 @@
+import sys
+input = sys.stdin.readline
+
+N = int(input())
+adj = [[] for _ in range(N+1)]
+for _ in range(N-1):
+    a,b = map(int,input().split())
+    adj[a].append(b)
+    adj[b].append(a)
+
+depth = [0]*(N+1)
+arr = [[0]*21 for _ in range(N+1)]
+def dfs(idx):
+    st = [idx]
+    depth[idx]=1
+    while st:
+        now = st.pop()
+        for nxt in adj[now]:
+            if depth[nxt]: continue
+            arr[nxt][0]=now
+            depth[nxt]=depth[now]+1
+            st.append(nxt)
+dfs(1)
+
+for y in range(1,21):
+    for x in range(1,N+1):
+        arr[x][y] = arr[arr[x][y-1]][y-1]
+def LCA(x,y):
+    if depth[x]!=depth[y]:
+        if depth[x]>depth[y]:x,y=y,x
+        for i in range(20,-1,-1):
+            if depth[y]-depth[x]>=(1<<i):
+                y=arr[y][i]
+    if x==y: return x
+    for i in range(20,-1,-1):
+        if arr[x][i]!=arr[y][i]:
+            x = arr[x][i]
+            y = arr[y][i]
+    return arr[x][0]
+
+for _ in range(int(input())):
+    r, u, v = map(int,input().split())
+    ans = LCA(r,u)
+    tmp = LCA(u,v)
+    ans = ans if depth[ans]>=depth[tmp] else tmp
+    tmp = LCA(r,v)
+    ans = ans if depth[ans]>=depth[tmp] else tmp
+    print(ans)

python/plat3/1693.py renamed to python/plat2/1693.py

@@ -0,0 +1,68 @@
+import sys
+input = sys.stdin.readline
+
+def dfs():
+    ret = 0
+    while True:
+        prev=[-1]*(v+1)
+        visited = [False]*(v+1)
+        dist = [1e9]*(v+1)
+        dist[st]=0
+        q = [st]
+        visited[st]=True
+        while q:
+            n = q.pop()
+            visited[n]=False
+            for nx in adj[n]:
+                if cap[n][nx]>fl[n][nx] and dist[nx]>dist[n]+cdj[n][nx]:
+                    dist[nx]=dist[n]+cdj[n][nx]
+                    prev[nx]=n
+                    if not visited[nx]:
+                        q.append(nx)
+                        visited[nx]=True
+        if prev[ed]==-1:break
+        flow = 1e9
+        now = ed
+        while now!=st:
+            flow = min(flow,cap[prev[now]][now] - fl[prev[now]][now])
+            now = prev[now]
+        now = ed
+        while now!=st:
+            fl[prev[now]][now]+=1
+            fl[now][prev[now]]-=1
+            ret+=cdj[prev[now]][now]*flow
+            now = prev[now]
+    return ret
+
+while True:
+    try:
+        v, e = map(int,input().split())
+        st,ed = 0, (v<<1)-1
+        tmp = v
+        v=v<<1|1
+        cap = [[0]*v for _ in range(v)]
+        fl = [[0]*v for _ in range(v)]
+        adj = [[] for _ in range(v)]
+        cdj = [[0]*2001 for _ in range(2001)]
+        for i in range(1,tmp+1):
+            _in = (i<<1)-2
+            _out = (i<<1)-1
+            adj[_in].append(_out)
+            cap[_in][_out]=1
+        cap[0][1]=2
+        cap[ed-1][ed]=2
+        for _ in range(e):
+            a,b,c = map(int,input().split())
+            in_a = (a<<1)-2
+            out_a = (a<<1)-1
+            in_b = (b<<1)-2
+            out_b = (b<<1)-1
+            cdj[out_a][in_b]=c
+            cdj[in_b][out_a]=-c
+            adj[out_a].append(in_b)
+            adj[in_b].append(out_a)
+            cap[out_a][in_b]=1
+        print(dfs())
+    except:
+        break
+