🥺chore

Author: hppRC

practice2/g/main.py

@@ -36,8 +36,66 @@ def make_list(n, *args, default=0): return [make_list(*args, default=default) fo
 
 sys.setrecursionlimit(1000000)
 
+class DAG:
+    def __init__(self, n, AB):
+        self.n = n
+        self.G = [[] for _ in range(n)]
+        self.revG = [[] for _ in range(n)]
+        self.AB = AB
+        for a, b in AB:
+            self.G[a].append(b)
+            self.revG[b].append(a)
+
+    def scc(self):
+        visited = [False] * self.n
+        order = []
+        for i in range(self.n):
+            if visited[i]: continue
+
+            q = deque([i])
+            visited[i] = True
+            while q:
+                v = q[-1]
+                for u in self.G[v]:
+                    if not visited[u]:
+                        q.append(u)
+                        visited[u] = True
+                        break
+                else:
+                    #全て訪問済みの時
+                    q.pop()
+                    order.append(v)
+
+        visited = [False] * self.n
+        scc = []
+        for i in order[::-1]:
+            if visited[i]: continue
+            tmp = [i]
+            visited[i] = True
+            q = deque([i])
+
+            while q:
+                v = q.pop()
+                for u in self.revG[v]:
+                    if visited[u]: continue
+                    visited[u] = True
+                    tmp.append(u)
+                    q.append(u)
+            scc.append(tmp)
+
+        return scc
+
+
+
 def main():
-    N = I()
+    N, M = LI()
+    AB = LIR(M)
+    g = DAG(N, AB)
+    scc = g.scc()
+    print(len(scc))
+    for es in scc:
+        print(len(es), *es)
+
 
 if __name__ == '__main__':
     main()

snipetts/graph.py

@@ -0,0 +1,49 @@
+class DAG:
+    def __init__(self, n, AB):
+        self.n = n
+        self.G = [[] for _ in range(n)]
+        self.revG = [[] for _ in range(n)]
+        self.AB = AB
+        for a, b in AB:
+            self.G[a].append(b)
+            self.revG[b].append(a)
+
+    def scc(self):
+        visited = [False] * self.n
+        order = []
+        for i in range(self.n):
+            if visited[i]: continue
+
+            q = deque([i])
+            visited[i] = True
+            while q:
+                v = q[-1]
+                for u in self.G[v]:
+                    if not visited[u]:
+                        q.append(u)
+                        visited[u] = True
+                        break
+                else:
+                    #全て訪問済みの時
+                    q.pop()
+                    order.append(v)
+
+        visited = [False] * self.n
+        scc = []
+        for i in order[::-1]:
+            if visited[i]: continue
+            tmp = [i]
+            visited[i] = True
+            q = deque([i])
+
+            while q:
+                v = q.pop()
+                for u in self.revG[v]:
+                    if visited[u]: continue
+                    visited[u] = True
+                    tmp.append(u)
+                    q.append(u)
+            scc.append(tmp)
+
+        return scc
+

snipetts/unionfind.py

@@ -1,29 +1,25 @@
 class UnionFind:
-    def __init__(self, n):
-        self._parent = [i for i in range(n)]
-        self._rank = [0 for _ in range(n)]
-        self._group_size = [1 for _ in range(n)]
-        self.num_of_groups = n
+    def __init__(self, N): self.N, self.group_count, self.root, self.rank = N, N, [-1] * N, [0] * N
+    def __repr__(self): return str(self.all_groups())
 
     def find(self, x):
-        vs = []
-        while self._parent[x] != x:
-            vs.append(x)
-            x = self._parent[x]
-        for v in vs: self._parent[v] = x
+        while self.root[x] >= 0: x = self.root[x]
         return x
 
     def union(self, x, y):
-        px, py = self.find(x), self.find(y)
-        if px == py: return
-        if self._rank[px] < self._rank[py]:
-            self._parent[px] = py
-            self._group_size[py] += self._group_size[px]
-        else:
-            self._parent[py] = px
-            self._group_size[px] += self._group_size[py]
-        if self._rank[px] == self._rank[py]: self._rank[py] += 1
-        self.num_of_groups -= 1
+        x, y = self.find(x), self.find(y)
+        if x == y: return
+        if self.rank[x] > self.rank[y]: x, y = y, x
+        self.root[y] += self.root[x]
+        self.root[x] = y
+        if self.rank[x] == self.rank[y]: self.rank[y] += 1
+        self.group_count -= 1
 
-    def is_same(self, x, y): return self.find(x) == self.find(y)
-    def group_size(self, x): return self._group_size[self.find(x)]
+    def same(self, x, y): return self.find(x) == self.find(y)
+    def count(self, x): return -self.root[self.find(x)]
+    def members(self, x): return [i for i in range(self.N) if self.same(x, i)]
+    def roots(self): return [i for i, x in enumerate(self.root) if x < 0]
+    def all_groups(self):
+        d = defaultdict(lambda: [])
+        for i in range(self.N): d[self.find(i)].append(i)
+        return dict(d)