Merge pull request #3163 from Amaryllidaceae/master

add solutions and editorials to usaco-646 and cses-1676

Author: SansPapyrus683

solutions/cses-1676.mdx

@@ -2,17 +2,25 @@
 id: cses-1676
 source: CSES
 title: Road Construction
-author: Oscar Garries, Sofia Yang
+author: Oscar Garries, Sofia Yang, George Pong
 ---
 
-**Time Complexity:** $\mathcal{O}(N\log N)$
+## Explanation
 
-<LanguageSection>
+We can represent the problem as an undirected graph, with each of the $n$ cities being a node and each of the $m$ roads being an edge. We then have two subproblems we need to consider:
 
-<CPPSection>
+Our first subproblem is counting the number of connected components each day. We can count them using Disjoint Set Union (DSU), where each tree in the structure represents a connected component. We start off with $n$ cities and no roads between them, and thus $n$ connected components. For every road that is built, we unite the two cities the road connects. If the union is successful, then two different connected components have been joined into one, and thus the number of connected components decreases by 1.
+
+Our second subproblem is finding the size of the largest connected component each day. Conveniently, the DSU optimization union-by-size stores the size of any node's component in that tree's parent node. Furthermore, the largest component will only change if a union is successful, as otherwise the graph stays the same. If a union happens, we check if the size of the tree which was added to during uniting is a new maximum.
 
 ## Implementation
 
+**Time Complexity:** $\mathcal{O}(M \cdot \alpha(N))$
+
+<LanguageSection>
+
+<CPPSection>
+
 ```cpp
 #include <bits/stdc++.h>
 
@@ -56,9 +64,61 @@ int main () {
 
 </CPPSection>
 
-<JavaSection>
+<PySection>
+
+```python
+import sys
+input = sys.stdin.readline  # speed up input to not TLE
+
+#BeginCodeSnip{Disjoint Set Union}
+class DisjointSetUnion:
+	def __init__(self, num_nodes: int) -> None:
+		self.parent = [*range(num_nodes)]
+		self.size = [1] * num_nodes
+
+	def find_parent(self, v: int) -> int:
+		if self.parent[v] == v:
+			return v
+		self.parent[v] = self.find_parent(self.parent[v])
+		return self.parent[v]
+
+	def union(self, a: int, b: int) -> bool:
+		a = self.find_parent(a)
+		b = self.find_parent(b)
+		if a == b:
+			return False
+		if self.size[a] < self.size[b]:
+			a, b = b, a
+		self.parent[b] = a
+		self.size[a] += self.size[b]
+		return True
+
+	def connected(self, a: int, b: int) -> bool:
+		return self.find_parent(a) == self.find_parent(b)
+#EndCodeSnip
+
+n, m = map(int, input().split())
+
+cities = DisjointSetUnion(n)
+largest_size = 1
+components = n
+
+for _ in range(m):
+	a, b = map(lambda i: int(i) - 1, input().split())
+	if cities.union(a, b):
+		components -= 1
+
+	# a is the parent node when uniting in our dsu implementation
+	size_a = cities.size[cities.find_parent(a)]
+	if size_a > largest_size:
+		largest_size = size_a
+
+	print(components, largest_size)
+```
 
-## Implementation
+</PySection>
+
+<JavaSection>
 
 ```java
 import java.io.BufferedReader;

solutions/usaco-646.mdx

@@ -2,21 +2,97 @@
 id: usaco-646
 source: USACO Gold 2016 Open
 title: Closing the Farm
-author: Nathan Gong, Melody Yu
+author: Nathan Gong, Melody Yu, George Pong
 ---
 
 [Official Analysis](http://www.usaco.org/current/data/sol_closing_gold_open16.html)
 
+## Explanation
+
+We can represent the farm as an undirected graph, with each of the $n$ barns being a node, and each of the $m$ bidirectional paths being an edge. At each point in time, we want to check if the number of connected components is equal to one. Naively, this can be done with BFS or DFS. However, we would need to run this for all $n+1$ states of the barn, resulting in a TLE.
+
+We can use Disjoint Set Union (DSU) to efficiently keep track of the number of connected components after each change. However, the key part of this solution is that, as DSU can only efficiently create relationships between nodes and not destroy them, we simulate closing the barn in reverse.
+
+We start with an empty farm, and open barns in the reverse order they were closed in. For each barn we open, we unite the new barn to all its adjacent open barns, of which we will keep track of while opening. This makes the farm at each state the same as if it was being closed. While opening a barn will initially increase the number of connected components by 1, each successful union will decrease it by 1 as well. Thus, each opening of a barn will increase the number of connected components by $1 - \texttt{number of successful unions}$. Finally, our answer from each opening can be reversed once again to follow the initial order of closing the barns.
 
 ## Video Solution
 
 Note: The video solution might not be the same as other solutions. Code in C++.
+
 <Youtube id="5G1CGuTfUJk" />
 
 ## Implementation
 
+**Time Complexity:** $\mathcal{O}(V \cdot E \cdot \alpha(n)))$
+
 <LanguageSection>
 
+<PySection>
+
+```py
+#BeginCodeSnip{Disjoint Set Union}
+class DisjointSetUnion:
+	def __init__(self, num_nodes: int) -> None:
+		self.parent = [*range(num_nodes)]
+		self.size = [1] * num_nodes
+
+	def find_parent(self, v: int) -> int:
+		if self.parent[v] == v:
+			return v
+		self.parent[v] = self.find_parent(self.parent[v])
+		return self.parent[v]
+
+	def union(self, a: int, b: int) -> bool:
+		a = self.find_parent(a)
+		b = self.find_parent(b)
+		if a == b:
+			return False
+		if self.size[a] < self.size[b]:
+			a, b = b, a
+		self.parent[b] = a
+		self.size[a] += self.size[b]
+		return True
+
+	def connected(self, a: int, b: int) -> bool:
+		return self.find_parent(a) == self.find_parent(b)
+#EndCodeSnip
+
+with open('closing.in', 'r') as infile:
+	n, m = map(int, infile.readline().split())
+	graph = [[] for _ in range(n)]
+	for _ in range(m):
+		f, t = map(lambda i: int(i) - 1, infile.readline().split())
+		graph[f].append(t)
+		graph[t].append(f)
+	remove_order = [int(infile.readline()) - 1 for _ in range(n)]
+
+dsu = DisjointSetUnion(n)
+
+"""
+We simulate opening the farm in the reverse order of closing it. For each barn,
+we open it, and then connect it to any open adjacent barns, all while counting
+the number of connected components.
+"""
+
+open_barns = set()
+components = 0
+fully_connected = []
+
+for node in remove_order[::-1]:
+	components += 1
+	for adj in graph[node]:
+		if adj in open_barns:
+			if dsu.union(adj, node):
+				components -= 1
+
+	fully_connected.append('YES' if components == 1 else 'NO')
+	open_barns.add(node)
+
+print(*fully_connected[::-1], sep='\n', file=open('closing.out', 'w'))
+```
+
+</PySection>
+
 <JavaSection>
 
 ```java
@@ -50,7 +126,7 @@ public class closing {
 		UnionFind graph = new UnionFind(n);
 		boolean[] open = new boolean[n];
 		ArrayList<String> answers = new ArrayList<>();
-	
+
 		// Process closings in reverse order:
 		// Instead of closing each farm, we simulate opening farms
 		for (int i = n - 1; i >= 0; i--) {