[#1] Jin

1068.py

@@ -0,0 +1,18 @@
+n = int(input())
+parent_node_list = list(map(int,input().split()))
+removed_node = int(input())
+
+def dfs(removed_node):
+    parent_node_list[removed_node] = -2
+    for i in range(len(parent_node_list)):
+        if parent_node_list[i] == removed_node:
+            dfs(i)
+
+dfs(removed_node)
+
+cnt=0
+for i in range(len(parent_node_list)):
+    if parent_node_list[i]!=-2 and i not in parent_node_list:
+        cnt+=1
+print(cnt)
+# print(parent_node_list)

1167.py

@@ -0,0 +1,30 @@
+import sys
+input = sys.stdin.readline
+sys.setrecursionlimit(10**9)
+
+n=int(input())
+tree = [[] for _ in range(n+1)]
+for _ in range(n):
+    li = list(map(int,input().split()))
+    for i in range(1,len(li)-2,2):
+        tree[li[0]].append([li[i],li[i+1]])
+# print(tree)
+
+def dfs(node,accumulated_weight):
+    for next_node,weight in tree[node]:
+        if distance[next_node]==-1:
+            distance[next_node]=weight+accumulated_weight
+            dfs(next_node,distance[next_node])
+
+distance = [-1]*(n+1)
+distance[1]=0
+dfs(1,0)
+# print(distance)
+
+start = distance.index(max(distance))
+distance = [-1]*(n+1)
+distance[start]=0
+dfs(start,0)
+
+# print(distance)
+print(max(distance))

1761.py

@@ -0,0 +1,57 @@
+n=int(input())
+tree = [[] for _ in range(n+1)]
+for _ in range(n-1):
+    a,b,c = map(int,input().split())
+    tree[a].append([b,c])
+    tree[b].append([a,c])
+
+parent = [0]*(n+1)
+depth = [0]*(n+1)
+check = [0]*(n+1)
+
+print(tree)
+
+def dfs(node,depth):
+    check[node]=1
+    depth[node]=depth
+    for child in tree[node]:
+        if not check[child]:
+            parent[child]=node
+            dfs(child,depth+1)
+
+def find_width(a,b):
+    for n1,n2 in tree[a]:
+        if n1==b:
+            print(n2)
+            return n2
+
+def lca(a,b):
+    width=0
+    print('depth',depth[a],depth[b])
+    while depth[a]!=depth[b]:
+        if depth[a]>depth[b]:
+            a = parent[a]
+            width+=find_width(a,parent[a])
+        else:
+            b = parent[b]
+            width+=find_width(b,parent[b])
+    while a!=b:
+        a = parent[a]
+        b = parent[b]
+        print(a,b)
+        print('tree',tree)
+        print(tree[a])
+        print(tree[b])
+        print(find_width(a,parent[a]))
+        print(find_width(a,parent[a]))
+        width+=find_width(a,parent[a])
+        width+=find_width(b,parent[b])
+    return width
+
+dfs(1,0)
+print(parent,'par')
+
+n=int(input())
+for _ in range(n):
+    a,b=map(int,input().split())
+    print(lca(a,b))

1967.py

@@ -0,0 +1,29 @@
+import sys
+input = sys.stdin.readline
+sys.setrecursionlimit(10**9)
+
+n=int(input())
+tree = [[] for _ in range(n+1)]
+for i in range(n-1):
+    a,b,c = map(int,input().split())
+    tree[a].append([b,c])
+    tree[b].append([a,c])
+
+def dfs(node,accumulated_weight):
+    for next_node,weight in tree[node]:
+        if distance[next_node]==-1:
+            distance[next_node]=weight+accumulated_weight
+            dfs(next_node,distance[next_node])
+
+distance = [-1]*(n+1)
+distance[1]=0
+dfs(1,0)
+# print(distance)
+
+start = distance.index(max(distance))
+distance = [-1]*(n+1)
+distance[start]=0
+dfs(start,0)
+
+# print(distance)
+print(max(distance))

1991.py

@@ -0,0 +1,34 @@
+n=int(input())
+tree = {}
+for _ in range(n):
+    a,b,c = input().split()
+    tree[a]=[b,c]
+# print(tree)
+
+def preorder(root):
+    if root != '.':
+        print(root, end='')  # root
+        preorder(tree[root][0])  # left
+        preorder(tree[root][1])  # right
+
+
+def inorder(root):
+    if root != '.':
+        inorder(tree[root][0])  # left
+        print(root, end='')  # root
+        inorder(tree[root][1])  # right
+
+
+def postorder(root):
+    if root != '.':
+        postorder(tree[root][0])  # left
+        postorder(tree[root][1])  # right
+        print(root, end='')  # root
+
+
+preorder('A')
+print()
+inorder('A')
+print()
+postorder('A')
+

2250.py

@@ -0,0 +1,37 @@
+n=int(input())
+tree = [[] for _ in range(n+1)]
+row = [[] for _ in range(n+1)]
+is_root = [0]*(n+1)
+num = 1
+
+def inorder(root, level):
+    global num
+    if tree[root][0] != -1:
+        inorder(tree[root][0], level + 1)
+    row[level].append(num)
+    num += 1
+    if tree[root][1] != -1:
+        inorder(tree[root][1], level + 1)
+
+
+for _ in range(n):
+    node,left,right = map(int,input().split())
+    tree[node].append(left)
+    tree[node].append(right)
+    is_root[node]+=1
+    if left!=-1:
+        is_root[left]+=1
+    if right!=-1:
+        is_root[right]+=1
+
+root = is_root.index(1)
+inorder(root,1)
+
+# print(row)
+level=1
+width=0
+for i in range(len(row)):
+    if row[i] and width<max(row[i])-min(row[i])+1:
+        width=max(row[i])-min(row[i])+1
+        level=i
+print(level,width)