2021.01.30

Author: seono

cplus/test.cpp

@@ -1,15 +1,54 @@
-#include <iostream>
+#include <stdio.h>
+#include <vector>
+#include <queue>
+#include <cstring>
+#include <algorithm>
 using namespace std;
-
-int main(void){
-	ios::sync_with_stdio(false);
-	double n1 = 2.555;
-	double n2 = 2.565;
-
-	cout<<fixed;
-  	cout.precision(2);
-  	cout<<n1<<'\n';
-	cout<<n2<<'\n';
-
-	return 0;
+const int MAX_V = 401;
+int N, P, visit[MAX_V], c[MAX_V][MAX_V], f[MAX_V][MAX_V], parent[MAX_V];
+vector<int> adj[MAX_V];
+ 
+int maxFlow(int source, int sink) {
+    int ret = 0;
+    while (1) {
+        memset(parent, -1, sizeof(parent));
+        queue<int> q;
+        q.push(source);
+        while (!q.empty() && parent[sink]==-1){
+            int cur = q.front();
+            q.pop();
+            for (int next : adj[cur]) {
+                if (!visit[next] && c[cur][next] - f[cur][next] > 0 && parent[next] == -1) {
+                    parent[next] = cur;
+                    q.push(next);
+                }
+            }
+        }
+        if (parent[sink] == -1) break;
+        int tmpFlow = 987654321;
+        for (int i = sink; i != source; i = parent[i]) {
+            tmpFlow = min(tmpFlow, c[parent[i]][i] - f[parent[i]][i]);
+            if (i != sink && i != source) visit[i] = true;
+        }
+        for (int i = sink; i != source; i = parent[i]) {
+            f[parent[i]][i] += tmpFlow;
+            f[i][parent[i]] -= tmpFlow;
+        }
+        ret += tmpFlow;
+    }
+    return ret;
+}
+ 
+int main() {
+    scanf("%d %d", &N, &P);
+    for (int i = 0; i < P; i++) {
+        int a, b;
+        scanf("%d %d", &a, &b);
+        adj[a].push_back(b);
+        adj[b].push_back(a);
+        c[a][b] = 1;
+        c[b][a] = 1;
+    }
+    printf("%d", maxFlow(1, 2));
+    return 0;
 }

python/plat2/7616.py

@@ -5,53 +5,83 @@
 
 def dfs():
     #global st,ed,adj,cap,fl,N,K,T
-    ans = []
-    chk =  [0]*(N+1)
+    ans=0
     while True:
         visited = [-1]*(N+1)
-        q = deque([st])
+        q = [st]
         while q:
-            n = q.popleft()
+            n = q.pop()
             for nx in adj[n]:
-                if chk[nx]==0 and visited[nx]==-1 and cap[n][nx] > fl[n][nx]:
+                if visited[nx]==-1 and cap[n][nx] > fl[n][nx]:
                     q.append(nx)
                     visited[nx]=n
                     if nx==ed:break
         if visited[ed]==-1:break
 
         now = ed
-        tmp = [ed]
         while now!=st:
-            chk[now]=1
             fl[visited[now]][now]+=1
             fl[now][visited[now]]-=1
             now = visited[now]
-            tmp.append(now)
-        ans.append(tmp)
-        chk[ed]=0
+        ans+=1
+    return ans
+
+def bfs():
+    ans = []
+    while True:
+        visited = [-1]*(N+1)
+        q = deque([st])
+        while q:
+            n = q.popleft()
+            for nx in adj[n]:
+                if visited[nx]==-1 and fl[n][nx]:
+                    q.append(nx)
+                    visited[nx]=n
+                    if nx==ed:break
+        if visited[ed]==-1:break
+        now = ed
+        tmp = [ed]
+        while now!=st:
+            fl[visited[now]][now]=0
+            fl[now][visited[now]]=0
+            now=visited[now]
+            if now%2==0:
+                tmp.append(now//2+1)
+        ans.append([1]+tmp[::-1])
     print("Case %d:\n"%T)
     if len(ans)>=K:
         for row in ans[:K]:
-            print(" ".join(map(str,row[::-1])))
-            print("\n")
+            print(" ".join(map(str,row))+"\n")
         print("\n")
     else:
         print("Impossible\n\n")
 
-
 st,ed = 1,2
 T = 0
 while True:
     T+=1
     K, N = map(int,input().split())
+    tmp = N
     if K==0 and N==0:break
-    cap = [[0]*(N+1) for _ in range(N+1)]
-    fl = [[0]*(N+1) for _ in range(N+1)]
-    adj = [[] for _ in range(N+1)]
-    for i in range(1,N+1):
+    N=N<<1|1
+    cap = [[0]*(N) for _ in range(N)]
+    fl = [[0]*(N) for _ in range(N)]
+    adj = [[] for _ in range(N)]
+    for i in range(1,tmp+1):
         row = list(map(int,input().split()))
+        in_a = (i<<1)-2
+        out_a = (i<<1)-1
+        adj[in_a].append(out_a)
+        cap[in_a][out_a]=1
         for r in row:
-            cap[i][r]=1
-            cap[r][i]=1
-        adj[i]=row[::-1]
-    dfs()
+            in_b = (r<<1)-2
+            out_b = (r<<1)-1
+            adj[out_a].append(in_b)
+            adj[in_b].append(out_a)
+            cap[out_a][in_b]=1
+            adj[out_b].append(in_a)
+            adj[in_a].append(out_b)
+            cap[out_b][in_a]=1
+    dfs()
+    bfs()
+    #print(adj)

python/plat3/2316.py

@@ -0,0 +1,52 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+N, P = map(int,input().split())
+mN = N<<1|1
+arr = [[] for _ in range(mN)]
+cap = [[0]*mN for _ in range(mN)]
+fl = [[0]*mN for _ in range(mN)]
+
+def dfs(st,ed):
+    ans = 0
+    while True:
+        visited = [-1]*mN
+        q = deque([st])
+        visited[0]=0
+        while q:
+            #print(q)
+            n = q.popleft()
+            for nx in arr[n]:
+                if visited[nx]==-1 and cap[n][nx]>fl[n][nx]:
+                    q.append(nx)
+                    visited[nx]=n
+                    if nx==ed:break
+        if visited[ed]==-1:break
+        now = ed
+        while now!=st:
+            fl[visited[now]][now]+=1
+            fl[now][visited[now]]-=1
+            now = visited[now]
+        ans+=1
+    return ans
+
+for i in range(1,N+1):
+    in_a = (i<<1)-2
+    out_a = (i<<1)-1
+    arr[in_a].append(out_a)
+    cap[in_a][out_a]=1
+
+for i in range(P):
+    a,b = map(int,input().split())
+    in_a = (a<<1)-2
+    out_a = (a<<1)-1
+    in_b = (b<<1)-2
+    out_b = (b<<1)-1
+    arr[out_a].append(in_b)
+    arr[in_b].append(out_a)
+    cap[out_a][in_b]=1
+    arr[out_b].append(in_a)
+    arr[in_a].append(out_b)
+    cap[out_b][in_a]=1
+print(dfs(1,2))

python/plat3/3033.py

@@ -0,0 +1,33 @@
+import sys
+from collections import defaultdict
+input = sys.stdin.readline
+
+H = 2147483647
+def hash(x):
+    ret = 0
+    for c in st[:x]:
+        ret=(ret*256+c)%H
+    return ret
+
+def rabin(m):
+    global L
+    mul = (1<<((m-1)*8))%H
+    H_x = hash(m)
+    H_TABLE[H_x].append(0)
+    for idx in range(1,L-m+1):
+        H_x = (((H_x - st[idx-1]*mul)<<8) + st[idx+m-1])%H
+        for i in H_TABLE[H_x]:
+            if st[i:i+m]==st[idx:idx+m]:
+                return True
+        H_TABLE[H_x].append(idx)
+L = int(input())
+st = [ord(c)-ord('a') for c in input().strip()]
+l,r=1,L-1
+while l<=r:
+    H_TABLE = defaultdict(list)
+    mid = (l+r)>>1
+    if rabin(mid):
+        l = mid+1
+    else:
+        r = mid-1
+print(r)

python/plat3/9938.py

@@ -0,0 +1,32 @@
+import sys
+sys.setrecursionlimit(100000)
+input = sys.stdin.readline
+output = sys.stdout.write
+N, L = map(int,input().split())
+p = [num for num in range(L+1)]
+
+def find(idx):
+    if p[idx]!=idx:
+        p[idx]=find(p[idx])
+    return p[idx]
+
+def Union(x,y):
+    x = find(x)
+    y = find(y)
+    if x!=y:
+        p[x]=y
+
+for i in range(N):
+    a,b = map(int,input().split())
+    f_a,f_b = find(a),find(b)
+    if f_a:
+        if f_a!=f_b:
+            p[f_a]=f_b
+        else:
+            p[f_a]=0
+        output("LADICA\n")
+    elif f_b:
+        p[f_b]=0
+        output("LADICA\n")
+    else:
+        output("SMECE\n")