fix asdfsda

boj/boj_3584.py

@@ -8,61 +8,57 @@
 setrecursionlimit(10**5)
 input = stdin.readline
 
-n = int(input())
-
-a = [[] for _ in range(n+1)]
-parent = [[0] * (MAX+1) for _ in range(n+1)]
-d = [0] * (n+1)
-dis = [0] * (n+1)
-v = [0] * (n+1)
-
-for _ in range(n-1):
-    p, q, c = map(int, input().split())
-    a[p].append((q, c))
-    a[q].append((p, c))
-
-
-def dfs(cur, depth, distance):
-    if v[cur]:
+for ____ in range(int(input())):
+    n = int(input())
+
+    a = [[] for _ in range(n+1)]
+    v = [0] * (n+1)
+
+    parent = [[[0, maxsize, -maxsize]
+               for __ in range(MAX+1)] for _ in range(n+1)]
+    d = [0] * (n+1)
+
+    for _ in range(n-1):
+        p, q = map(int, input().split())
+        v[q] = 1
+        a[p].append(q)
+
+    p = 0
+    for i in range(1, n+1):
+        if v[i] == 0:
+            p = i
+            break
+
+    def dfs(cur, depth):
+        for next in a[cur]:
+            if d[next]:
+                continue
+            parent[next][0][0] = cur
+            d[next] = depth + 1
+            dfs(next, depth+1)
         return
 
-    for next, next_cost in a[cur]:
-        if d[next] != 0:
-            continue
-        parent[next][0] = cur
-        dis[next] = distance + next_cost
-        d[next] = depth+1
-        dfs(next, depth+1, dis[next])
-    return
-
-
-dfs(1, 1, 0)
-
-
-for i in range(1, MAX):
-    for j in range(1, n+1):
-        parent[j][i] = parent[parent[j][i-1]][i-1]
-
-cache = {}
-
-
-def solve(l, r):
-    if d[l] > d[r]:
-        l, r = r, l
-    for i in range(MAX, -1, -1):
-        if d[r] - d[l] >= (1 << i):
-            r = parent[r][i]
-    if l == r:
-        return l
-    for i in range(MAX, -1, -1):
-        if parent[l][i] != parent[r][i]:
-            l = parent[l][i]
-            r = parent[r][i]
-    return parent[l][0]
-
+    d[p] = 0
+    dfs(p, 0)
+
+    for i in range(1, MAX):
+        for j in range(1, n+1):
+            parent[j][i][0] = parent[parent[j][i-1][0]][i-1][0]
+
+    def solve(l, r):
+        if d[l] > d[r]:
+            l, r = r, l
+        for i in range(MAX, -1, -1):
+            if d[r] - d[l] >= (1 << i):
+                left = parent[r][i][1]
+                r = parent[r][i][0]
+        if l == r:
+            return l
+        for i in range(MAX, -1, -1):
+            if parent[l][i][0] != parent[r][i][0]:
+                l = parent[l][i][0]
+                r = parent[r][i][0]
+        return parent[l][0][0]
 
-m = int(input())
-for _ in range(m):
     p, q = map(int, input().split())
-    ancestor = solve(p, q)
-    print(dis[p] + dis[q] - dis[ancestor] * 2)
+    print(solve(p, q))

main.cpp

@@ -3,8 +3,8 @@
 typedef long long ll;
 
 #define FAST ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
-#define PII pair<int,int>
-#define PIII pair<PII,int>
+#define PII PII<int,int>
+#define PIII PII<PII,int>
 #define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a))
 #define FORN(a, b, c) for (int(a) = (b); (a) <= (c); ++(a))
 #define FORD(a, b, c) for (int(a) = (b); (a) >= (c); --(a))
@@ -17,7 +17,7 @@ typedef long long ll;
 #define RESET(a, b) memset(a, b, sizeof(a))
 #define fi first
 #define se second
-#define mp make_pair
+#define mp make_PII
 #define pb push_back
 #define ALL(v) v.begin(), v.end()
 #define ALLA(arr, sz) arr, arr + sz
@@ -35,34 +35,65 @@ typedef long long ll;
 
 using namespace std;
 
-int n;
-int d[10] = {6,2,5,5,4,5,6,3,7,6};
+int h=1;
+vector<PII> seg;
+vector<vector<int>> adj;
+int depth[100005];
+int idx[100005];
+int cnt = 1;
 
-int cal(int val) {
-    return d[val/10] + d[val % 10];
+void update(int i, int val, int u) {
+	i += h-1;
+	seg[i] = { val, u};
+	while (i>1) {
+		i /= 2;
+		seg[i] = min(seg[i * 2], seg[i * 2 + 1]);
+	}
+}
+PII query(int l, int r, int nodeNum, int nodeL, int nodeR) {
+	if (l <= nodeL&& nodeR <= r) return seg[nodeNum];
+	else if (r < nodeL || nodeR < l) return{ INF,INF };
+	int mid = (nodeL + nodeR) / 2;
+	return min(query(l, r, nodeNum * 2, nodeL, mid), query(l, r, nodeNum * 2 + 1, mid + 1, nodeR));
+}
+void dfs(int u, int d) {
+	depth[u] = d;
+	idx[u] = cnt;
+	update(cnt++, d, u);
+	for (auto v : adj[u]) {
+		if (depth[v] == -1){
+			dfs(v, d + 1);
+			update(cnt++, d, u);
+		}
+	}
 }
 
 int solve() {
-    cin>>n;
-
-    for (int i=0;i<MAX;i++) {
-        for (int j=0;j<=i;j++) {
-            int res = 4;
-            res += cal(i);
-            res += cal(j);
-            res += cal(i - j);
-            if (res == n) {
-                cout<<j/10<<j%10<<'+'<<(i-j)/10<<(i-j)%10<<'='<<i/10<<i%10<<'\n';
-                return 0;
-            }
-        }
-    }
-    cout<<"impossible\n";
+    int n;
+	scanf("%d", &n);
+	adj.resize(n +1);
+	for (int i = 0; i < n-1; i++) {
+		int a, b;
+		scanf("%d %d", &a, &b);
+		adj[a].push_back(b);
+		adj[b].push_back(a);
+	}
+	memset(depth, -1, sizeof(depth));
+	while (h < 2 * n) h <<= 1;
+	seg.resize(h * 2, { INF,0 });
+	dfs(1, 0);
+	int m;
+	scanf("%d", &m);
+	for (int q = 0; q < m; q++) {
+		int a, b;
+		scanf("%d %d", &a, &b);
+		printf("%d\n", query(min(idx[a],idx[b]), max(idx[a],idx[b]), 1, 1, h).second);
+	}
     return 0;
 }
 
 int main() {
-    FAST;
+    // FAST;
     solve();
     return 0;
 }

main.py

@@ -3,29 +3,66 @@
 from collections import deque
 import random
 
-MAX = 27
+MAX = 17
 MOD = 1000000007
 setrecursionlimit(10**5)
 input = stdin.readline
 
 n = int(input())
-a = []
-for _ in range(n):
+
+a = [[] for _ in range(n+1)]
+parent = [[0] * (MAX+1) for _ in range(n+1)]
+d = [0] * (n+1)
+dis = [0] * (n+1)
+v = [0] * (n+1)
+
+for _ in range(n-1):
+    p, q, c = map(int, input().split())
+    a[p].append((q, c))
+    a[q].append((p, c))
+
+
+def dfs(cur, depth, distance):
+    if v[cur]:
+        return
+
+    for next, next_cost in a[cur]:
+        if d[next] != 0:
+            continue
+        parent[next][0] = cur
+        dis[next] = distance + next_cost
+        d[next] = depth+1
+        dfs(next, depth+1, dis[next])
+    return
+
+
+dfs(1, 1, 0)
+
+
+for i in range(1, MAX):
+    for j in range(1, n+1):
+        parent[j][i] = parent[parent[j][i-1]][i-1]
+
+cache = {}
+
+
+def solve(l, r):
+    if d[l] > d[r]:
+        l, r = r, l
+    for i in range(MAX, -1, -1):
+        if d[r] - d[l] >= (1 << i):
+            r = parent[r][i]
+    if l == r:
+        return l
+    for i in range(MAX, -1, -1):
+        if parent[l][i] != parent[r][i]:
+            l = parent[l][i]
+            r = parent[r][i]
+    return parent[l][0]
+
+
+m = int(input())
+for _ in range(m):
     p, q = map(int, input().split())
-    if p < q:
-        a.append([p, q])
-    else:
-        a.append([q, p])
-a.sort(key=lambda x: x[1])
-d = int(input())
-
-pq = []
-res = 0
-for item in a:
-    if item[1] - item[0] > d:
-        continue
-    while pq and item[1] - d > pq[0][0]:
-        heappop(pq)
-    heappush(pq, item)
-    res = max(res, len(pq))
-print(res)
+    ancestor = solve(p, q)
+    print(dis[p] + dis[q] - dis[ancestor] * 2)

study/test.py

@@ -1,57 +1,19 @@
-from sys import stdin, setrecursionlimit, maxsize
-from collections import deque
-from heapq import *
-from math import sqrt, gcd
+N = 1000
+MAX = 100000
 
+print(N)
+a = [[MAX] * N for _ in range(N)]
+for i in a:
+    print(*i)
 
-input = stdin.readline
-setrecursionlimit(10**6)
+rc = [[1, 2], [1, 3], [1, 5]]
 
-s = input().strip()
-sl = len(s)
-
-end = -1
-l = 0
-def next(cidx, l, cur):
-    if cur==9 and l==1 and sl>=cidx+3:
-        if cur+1==int(s[cidx+1:cidx+3]):
-            return (cidx+1,2,cur+1)
-    if cur==99 and l==2 and sl>=cidx+5:
-        if cur+1==int(s[cidx+2:cidx+5]):
-            return (cidx+2, 3, cur+1)
-
-    if cur+1==int(s[cidx+l:cidx+2*l]) and sl>=cidx+l*2:
-        return (cidx+l, l, cur+1)
-    return (-1, -1, cur)
-
-res = 0
-for i in range(1,1000):
-    try:
-        # print(i, int(s[0:len(str(i))]))
-        if i!=int(s[0:len(str(i))]):
-            continue
-        start = i
-        cidx, l, cur = next(0,len(str(i)),i)
-        # print(cidx, l, cur)
-        if cidx != -1:
-            while 1:
-        # print(cidx, l, cur)
-                try:
-                    cidx, l, cur = next(cidx, l, cur)
-                except:
-                    break
-            if cidx+l==sl:
-                start = i
-                end = cur
-                res = 1
-    except:
-        if res:
-            break
-        continue
-    if res:
-        break
-
-if end==-1:
-    print(start, start)
-else:
-    print(start, end)
+# print(len(rc))
+# for i in rc:
+#     print(*rc)
+# print(23)
+# for i in range(1, N+1):
+#     for j in range(1, N+1):
+#         if i == j and (i == 1 or j == N):
+#             continue
+#         print(i, j)