2021.02.02

Author: seono

python/plat3/10254.py

@@ -0,0 +1,61 @@
+import sys
+import math
+input = sys.stdin.readline
+
+T = int(input())
+def ccw(p1,p2,p3):
+    def getD(p1,p2):
+        return p2[0] - p1[0], p2[1] - p1[1]
+    v,u = getD(p1,p2), getD(p2,p3)
+    if v[0] * u[1] > v[1] * u[0]: return True
+    return False
+
+def dist(p1,p2):
+    return math.pow(p1[0]-p2[0],2)+math.pow(p1[1]-p2[1],2)
+
+def convex(p):
+    convex = []
+    for p3 in p:
+        while len(convex)>=2:
+            p1,p2 = convex[-2],convex[-1]
+            if ccw(p1,p2,p3):break
+            convex.pop()
+        convex.append(p3)
+    return convex
+
+def rotating_calipers(arr):
+    ret = 0
+    ans = None
+    l = len(arr)-1
+    j = 1
+    for i in range(l):
+        ni = (i+1)%l
+        while True:
+            nj = (j+1)%l
+            vx = arr[ni][0] - arr[i][0]
+            vy = arr[ni][1] - arr[i][1]
+
+            ux = arr[nj][0] - arr[j][0]
+            uy = arr[nj][1] - arr[j][1]
+
+            tmp = (0,0)
+
+            if ccw(tmp,(vx,vy),(ux,uy)):
+                j = nj
+            else:break
+        tmp = dist(arr[i],arr[j])
+        if tmp>ret:
+            ans = arr[i]+arr[j]
+            ret = tmp
+    return ans
+while T:
+    T-=1
+    C = int(input())
+    arr = [list(map(int,input().split())) for _ in range(C)]
+
+    arr.sort(key=lambda x:(x[0],x[1]))
+    convex_hull = convex(arr)
+    arr.reverse()
+    tmp = convex(arr)
+    convex_hull.extend(tmp[1:])
+    print(' '.join(map(str,rotating_calipers(convex_hull))))

python/plat3/11281.py

@@ -0,0 +1,64 @@
+import sys
+input = sys.stdin.readline
+sys.setrecursionlimit(100000)
+
+N, M = map(int,input().split())
+dfsn = [0]*(N<<1|1)
+cnt = 0
+SN = 0
+st = []
+sccNum = [0]*(N<<1|1)
+finished = [False]*(N<<1|1)
+scc_arr = []
+def scc(curr):
+    global cnt, SN
+    dfsn[curr] = cnt+1
+    cnt+=1
+    st.append(curr)
+    result = dfsn[curr]
+    for nx in adj[curr]:
+        if dfsn[nx]==0:result = min(result,scc(nx))
+        elif not finished[nx]: result = min(result,dfsn[nx])
+    
+    if result==dfsn[curr]:
+        curSCC = []
+        while True:
+            t = st.pop()
+            curSCC.append(t)
+            finished[t]=True
+            sccNum[t]=SN
+            if t==curr:break
+        SN+=1
+        scc_arr.append(curSCC)
+    
+    return result
+def oppo(n):return n-1 if n%2 else n+1
+
+adj = [[] for _ in range(2*N+1)]
+for _ in range(M):
+    a,b=map(int,input().split())
+    a = -(a+1)*2 if a<0 else 2*a-1
+    b = -(b+1)*2 if b<0 else 2*b-1
+    adj[oppo(a)].append(b)
+    adj[oppo(b)].append(a)
+
+for i in range(N*2):
+    if dfsn[i]==0:scc(i)
+
+def sol():
+    #print(scc_arr)
+    for i in range(N):
+        if sccNum[i<<1] ==sccNum[i<<1|1]:
+            print(0)
+            return
+    result = [-1]*(N+1)
+    p = [(sccNum[i],i) for i in range(N*2)]
+    p.sort()
+    for num in range(N*2-1,-1,-1):
+        var = p[num][1]
+        if result[var//2] == -1:
+            result[var//2] = 0 if var%2 else 1
+    print(1)
+    print(' '.join(map(str,result[:-1])))
+    return
+sol()

python/plat3/11408.py

@@ -0,0 +1,68 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+N, M = map(int,input().split())
+S,E = 801,802
+Total_num = 803
+cap = [[0]*Total_num for _ in range(Total_num)]
+fl = [[0]*Total_num for _ in range(Total_num)]
+d = [[0]*Total_num for _ in range(Total_num)]
+adj = [[] for _ in range(Total_num*2+3)]
+for i in range(1,N+1):
+    adj[S].append(i)
+    adj[i].append(S)
+    cap[S][i]=1
+
+for i in range(1,M+1):
+    adj[i+400].append(E)
+    adj[E].append(i+400)
+    cap[i+400][E]=1
+
+for i in range(1,N+1):
+    row = list(map(int,input().split()))
+    for j in range(1,row[0]+1):
+        work, cost = row[(j<<1)-1],row[j<<1]
+        adj[i].append(work+400)
+        adj[work+400].append(i)
+        cap[i][work+400]=1
+        d[i][work+400]+=cost
+        d[work+400][i]-=cost
+    
+def sol():
+    result = 0
+    ans = 0
+    while True:
+        visited = [-1]*(Total_num)
+        dist = [1e9]*Total_num
+        chk = [False]*Total_num
+        q = deque([S])
+        dist[S]=0
+        while q:
+            n = q.popleft()
+            chk[n]=False
+            for nx in adj[n]:
+                if cap[n][nx]>fl[n][nx] and dist[nx]>dist[n]+d[n][nx]:
+                    dist[nx]=dist[n]+d[n][nx]
+                    visited[nx]=n
+                    if not chk[nx]:
+                        q.append(nx)
+                        chk[nx]=True
+        if visited[E]==-1:
+            break
+        flow = 1e9
+        now = E
+        while now!=S:
+            flow = min(flow,cap[visited[now]][now]-fl[visited[now]][now])
+            now = visited[now]
+        now = E
+        while now!=S:
+            result += d[visited[now]][now]*flow
+            fl[visited[now]][now]+=flow
+            fl[now][visited[now]]-=flow
+            now = visited[now]
+        ans+=flow
+    print(ans)
+    print(result)
+    return
+sol()

python/plat3/1289.py

@@ -0,0 +1,25 @@
+import sys
+input = sys.stdin.readline
+
+M = 1000000007
+N = int(input())
+sys.setrecursionlimit(100000)
+adj = [[] for _ in range(N+1)]
+for i in range(N-1):
+    a,b,cost = map(int,input().split())
+    adj[a].append((b,cost))
+    adj[b].append((a,cost))
+
+ans = 0
+def dp(idx, p):
+    global ans, M
+    ret = 1    
+    for nx,cost in adj[idx]:
+        if nx==p:continue
+        tmp = (dp(nx,idx)*cost)%M
+        ans=(ans+(ret*tmp)%M)%M
+        ret=(ret+tmp)%M
+    return ret
+
+dp(1,0)
+print(ans)

python/plat3/13511.py

@@ -0,0 +1,85 @@
+import sys
+input = sys.stdin.readline
+output = sys.stdout.write
+
+N = int(input())
+adj = [[] for _ in range(N+1)]
+dep = [0]*(N+1)
+arr = [[[0,0] for _ in range(21)] for _ in range(N+1)]
+for i in range(N-1):
+    a,b,c = map(int,input().split())
+    adj[a].append((b,c))
+    adj[b].append((a,c))
+
+def LCA(x,y):
+    num = 0
+    if dep[x]!=dep[y]:
+        if dep[x]>dep[y]:x,y=y,x
+        for i in range(20,-1,-1):
+            if dep[y]-dep[x] >= (1<<i):
+                num+=arr[y][i][1]
+                y=arr[y][i][0]
+    if x==y:return num
+    for i in range(20,-1,-1):
+        if arr[x][i][0]!=arr[y][i][0]:
+            num+=arr[y][i][1]+arr[x][i][1]
+            x = arr[x][i][0]
+            y = arr[y][i][0]
+    return num+arr[x][0][1]+arr[y][0][1]
+
+def LCA2(x,y,k):
+    if k==0:return x,True
+    num = 0
+    if dep[x]!=dep[y]:
+        if dep[x]>dep[y]:
+            for i in range(20,-1,-1):
+                if dep[x]-dep[y]>=(1<<i) and (1<<i)<=k:
+                    x=arr[x][i][0]
+                    k-=1<<i
+                if k==0:
+                    return x,True
+        else:
+            for i in range(20,-1,-1):
+                if dep[y]-dep[x]>=1<<i:
+                    y=arr[y][i][0]
+                    num+=1<<i
+    if x==y:
+        return num-k,False
+    for i in range(20,-1,-1):
+        if arr[x][i][0]!=arr[y][i][0] and (1<<i)<=k:
+            x = arr[x][i][0]
+            y = arr[y][i][0]
+            k-=1<<i
+            num+=1<<i
+        if k==0:
+            return x,True
+    if k==1:
+        return arr[x][0][0],True
+    return num-k+2,False
+
+def dfs():
+    st = [[1,0,0]]
+    while st:
+        n, d, p = st.pop()
+        dep[n]=d
+        d+=1
+        for i, cnt in adj[n]:
+            if i==p:continue
+            arr[i][0]=[n,cnt]
+            st.append([i,d,n])
+dfs()
+
+for y in range(1,21):
+    for x in range(1,N+1):
+        arr[x][y][0] = arr[arr[x][y-1][0]][y-1][0]
+        arr[x][y][1] += arr[arr[x][y-1][0]][y-1][1]+arr[x][y-1][1]
+M = int(input())
+for i in range(M):
+    row = list(map(int,input().split()))
+    if row[0]==1:
+        output("%d\n"%LCA(row[1],row[2]))
+    else:
+        ans,check = LCA2(row[1],row[2],row[3]-1)
+        if not check:
+            ans,check = LCA2(row[2],row[1],ans)
+        output("%d\n"%ans)

python/plat3/13544.py

@@ -0,0 +1,39 @@
+import sys
+import bisect
+input = sys.stdin.readline
+output = sys.stdout.write
+
+N = int(input())
+st = 1
+while st<N:
+    st<<=1
+tree = [[] for _ in range(st*2)]
+tmp = st
+for i,num in enumerate(list(map(int,input().split())),st):
+    tree[i]=[num]
+while tmp>1:
+    ed = tmp
+    tmp = tmp>>1
+    for i in range(tmp,ed):
+        l,r = 0,0
+        left,right = len(tree[i<<1]),len(tree[i<<1|1])
+        while l<left or r<right:
+            if r==right or l<left and tree[i<<1][l]<tree[i<<1|1][r]:
+                tree[i].append(tree[i<<1][l])
+                l+=1
+            else:
+                tree[i].append(tree[i<<1|1][r])
+                r+=1
+def query(node,ns,ne,s,e,k):
+    if ns>e or ne<s: return 0
+    if s<=ns and ne<=e:
+        return len(tree[node]) - bisect.bisect_right(tree[node],k)
+    mid = (ns+ne)>>1
+    return query(node<<1,ns,mid,s,e,k)+query(node<<1|1,mid+1,ne,s,e,k)
+M = int(input())
+ans = 0
+for i in range(M):
+    a,b,c = map(int,input().split())
+    i,j,k = a^ans,b^ans,c^ans
+    ans = query(1,1,st,i,j,k)
+    output("%d\n"%ans)

python/plat3/1514.py

@@ -0,0 +1,27 @@
+import sys
+input = sys.stdin.readline
+sys.setrecursionlimit(100000)
+N = int(input())
+num1,num2 = [0]*110,[0]*110
+for i,num in enumerate(input().strip()):
+    num1[i]=int(num)
+for i,num in enumerate(input().strip()):
+    num2[i]=int(num)
+dp_arr = [[[[[1e9]*2 for l in range(10)] for k in range(10)] for j in range(10)] for i in range(110)]
+
+
+def dp(now,x,y,z,w):
+    if now>=N: return 0
+    if dp_arr[now][x][y][z][w]!=1e9:
+        return dp_arr[now][x][y][z][w]
+    if x==num2[now]:
+        dp_arr[now][x][y][z][w]=min(dp(now+1,y,z,num1[now+3],0),dp(now+1,y,z,num1[now+3],1))
+        return dp_arr[now][x][y][z][w]
+    tmp = 1 if w else -1
+    for i in range(1,4):
+        i = i*tmp
+        dp_arr[now][x][y][z][w] = min(dp_arr[now][x][y][z][w],1+dp(now,(x+i)%10,y,z,w))
+        dp_arr[now][x][y][z][w] = min(dp_arr[now][x][y][z][w],1+dp(now,(x+i)%10,(y+i)%10,z,w))
+        dp_arr[now][x][y][z][w] = min(dp_arr[now][x][y][z][w],1+dp(now,(x+i)%10,(y+i)%10,(z+i)%10,w))
+    return dp_arr[now][x][y][z][w]
+print(min(dp(0,num1[0],num1[1],num1[2],0),dp(0,num1[0],num1[1],num1[2],1)))