C++博客-Uriel's Corner-文章分类-图论

[LeetCode]2642. Design Graph With Shortest Path Calculator (Hard) Python-2023.11.11

Uriel — Sat, 11 Nov 2023 15:22:00 GMT

求有向图两节点间的最短路，需要支持增加边和多次询问，Dijkstra

1 #2642
2 #Runtime: 566 ms
3 #Memory: 17.3 MB
4
5 class Graph(object):
6
7     def __init__(self, n, edges):
8         """
9         :type n: int
10         :type edges: List[List[int]]
11         """
12         self.adj = [[] for _ in xrange(n)]
13         for e in edges:
14             self.adj[e[0]].append((e[1], e[2]))
15
16
17     def addEdge(self, edge):
18         """
19         :type edge: List[int]
20         :rtype: None
21         """
22         self.adj[edge[0]].append((edge[1], edge[2]))
23
24
25     def shortestPath(self, node1, node2):
26         """
27         :type node1: int
28         :type node2: int
29         :rtype: int
30         """
31         return self.dijkstra(node1, node2)
32
33
34     def dijkstra(self, st, ed):
35         n = len(self.adj)
36         dis = [float('inf')] * n
37         dis[st] = 0
38         q = [(0, st)]
39         while q:
40             cur_cost, cur_node = heapq.heappop(q)
41             if cur_cost > dis[cur_node]:
42                 continue
43             if cur_node == ed:
44                 return cur_cost
45             for e in self.adj[cur_node]:
46                 node, l = e
47                 tp_cost = l + dis[cur_node]
48                 if dis[node] > tp_cost:
49                     dis[node] = tp_cost
50                     heapq.heappush(q, (tp_cost, node))
51         return -1 if dis[ed] == float('inf') else dis[ed]
52
53
54
55 # Your Graph object will be instantiated and called as such:
56 # obj = Graph(n, edges)
57 # obj.addEdge(edge)
58 # param_2 = obj.shortestPath(node1,node2)

Uriel 2023-11-11 23:22 发表评论

[LeetCode]2050. Parallel Courses III (Hard) Python-2023.10.18

Uriel — Wed, 18 Oct 2023 13:57:00 GMT

有一系列课程，每个课程有一些先修课，修每门课需要时间time[i]，问最少多长时间能修完所有课，拓扑排序

1 #2050
2
3 #Runtime: 1240 ms (Beats 72.73%)
4 #Memory: 43.6 MB (Beats 31.82%)
5
6 class Solution(object):
7     def minimumTime(self, n, relations, time):
8         """
9         :type n: int
10         :type relations: List[List[int]]
11         :type time: List[int]
12         :rtype: int
13         """
14         adj = defaultdict(list)
15         ind = [0] * n
16         time_cost = [0] * n
17         for x, y in relations:
18             adj[x - 1].append(y - 1)
19             ind[y - 1] += 1
20         q = deque([])
21         for x in range(n):
22             if ind[x] == 0:
23                 q.append(x)
24                 time_cost[x] = time[x]
25         while len(q):
26             x = q.popleft()
27             for y in adj[x]:
28                 time_cost[y] = max(time_cost[x] + time[y], time_cost[y])
29                 ind[y] -= 1
30                 if ind[y] == 0:
31                     q.append(y)
32         return max(time_cost)

Uriel 2023-10-18 21:57 发表评论

[LeetCode]1631. Path With Minimum Effort (Medium) Python-2023.09.16

Uriel — Sat, 16 Sep 2023 11:42:00 GMT

给出一个2D的grid，求从左上角到右下角的最短路（总路长定义为max（所有相邻节点的差））

1 #1631
2 #Runtime: 673 ms (Beats 64.49%)
3 #Memory: 16.1 MB (Beats 32.71%)
4
5 class Solution(object):
6     def minimumEffortPath(self, heights):
7         """
8         :type heights: List[List[int]]
9         :rtype: int
10         """
11         hq = [(0, (0, 0))]
12         vis = {(0, 0) : 0}
13         d = [[0, 1], [0, -1], [1, 0], [-1, 0]]
14         target = (len(heights) - 1, len(heights[0]) - 1)
15         while hq:
16             cst, node = heapq.heappop(hq)
17             if node == target:
18                 break
19             x, y = node
20             for t in d:
21                 tx, ty = x + t[0], y + t[1]
22                 if 0 <= tx < len(heights) and 0 <= ty < len(heights[0]):
23                     tp_cst = max(cst, abs(heights[x][y] - heights[tx][ty]))
24                     if (tx, ty) not in vis or ((tx, ty) in vis and tp_cst < vis[(tx, ty)]):
25                         vis[(tx, ty)] = tp_cst
26                         heapq.heappush(hq, (tp_cst, (tx, ty)))
27         return vis[target]

Uriel 2023-09-16 19:42 发表评论

[LeetCode]1584. Min Cost to Connect All Points (Medium) Python3-2023.09.15

Uriel — Fri, 15 Sep 2023 06:54:00 GMT

最小生成树，Prim

1 #1584
2 #Runtime: 7443 ms (Beats 5.2%)
3 #Memory: 133.3 MB (Beats 51.97%)
4
5 class Solution(object):
6     def minCostConnectPoints(self, points):
7         """
8         :type points: List[List[int]]
9         :rtype: int
10         """
11         def Distance(p1, p2):
12             return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
13
14
15         n = len(points)
16         mp = defaultdict(list)
17         for i in range(n):
18             for j in range(i + 1, n):
19                 d = Distance(points[i], points[j])
20                 mp[i].append((d, j))
21                 mp[j].append((d, i))
22         vis = [0] * n
23         hp = mp[0]
24         vis[0] = 1
25         ans = 0
26         heapq.heapify(hp)
27         while hp:
28             d, i = heapq.heappop(hp)
29             if not vis[i]:
30                 vis[i] = 1
31                 ans += d
32                 for j in mp[i]:
33                     heapq.heappush(hp, j)
34         return ans

Uriel 2023-09-15 14:54 发表评论

[LeetCode]1489. Find Critical and Pseudo-Critical Edges in Minimum Spanning Tree (Hard) Python-2023.08.19

Uriel — Sun, 20 Aug 2023 02:56:00 GMT

找出无向图最小生成树的关键边和伪关键边

定义：

An MST edge whose deletion from the graph would cause the MST weight to increase is called a critical edge. On the other hand, a pseudo-critical edge is that which can appear in some MSTs but not all.

并查集求MST+枚举边，思路参考->https://leetcode.com/problems/find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree/solutions/3929349/detailed-video-solution-java-c-python/

1 #1489
2 #Runtime: 2134 ms (Beats 50%)
3 #Memory: 13.4 MB (Beats 100%)
4
5 class UnionFind:
6     def __init__(self, n):
7         self.pa = list(range(n))
8
9
10     def find(self, x):
11         if self.pa[x] != x:
12             self.pa[x] = self.find(self.pa[x])
13         return self.pa[x]
14
15
16     def union(self, x, y):
17         px, py = self.find(x), self.find(y)
18         self.pa[px] = py
19
20
21 class Solution(object):
22     def findCriticalAndPseudoCriticalEdges(self, n, edges):
23         """
24         :type n: int
25         :type edges: List[List[int]]
26         :rtype: List[List[int]]
27         """
28         def find_MST(block, e):
29             uf = UnionFind(n)
30             wt = 0
31             if e != -1:
32                 wt += edges[e][2]
33                 uf.union(edges[e][0], edges[e][1])
34             for i in range(len(edges)):
35                 if i == block:
36                     continue
37                 if uf.find(edges[i][0]) == uf.find(edges[i][1]):
38                     continue
39                 uf.union(edges[i][0], edges[i][1])
40                 wt += edges[i][2]
41             for i in range(n):
42                 if uf.find(i) != uf.find(0):
43                     return float('inf')
44             return wt
45
46         c = []
47         pc = []
48         for i, e in enumerate(edges):
49             e.append(i)
50         edges.sort(key=lambda x: x[2])
51         mst = find_MST(-1, -1)
52         for i, e in enumerate(edges):
53             if mst < find_MST(i, -1):
54                 c.append(e[3])
55             elif mst == find_MST(-1, i):
56                 pc.append(e[3])
57         return [c, pc]

Uriel 2023-08-20 10:56 发表评论

[LeetCode]207. Course Schedule (Medium) Python-2023.07.13

Uriel — Thu, 13 Jul 2023 08:25:00 GMT

一共

numCourses门课，

prerequisites中的每个pair [a, b]表示a的先修课是b，问是否有可能修完所有课
BFS+拓扑排序思想

1 #207
2 #Runtime: 74 ms (Beats 75.97%)
3 #Memory: 14.5 MB (Beats 97.82%)
4
5 class Solution(object):
6     def canFinish(self, numCourses, prerequisites):
7         """
8         :type numCourses: int
9         :type prerequisites: List[List[int]]
10         :rtype: bool
11         """
12         ind = [0] * numCourses
13         adj = [[] for _ in range(numCourses)]
14         for i in range(len(prerequisites)):
15             a, b = prerequisites[i]
16             adj[b].append(a)
17             ind[a] += 1
18         q = deque()
19         for i in range(numCourses):
20             if not ind[i]:
21                 q.append(i)
22         ans = []
23         while q:
24             node = q.popleft()
25             ans.append(node)
26             for i in adj[node]:
27                 ind[i] -= 1
28                 if ind[i] == 0:
29                     q.append(i)
30         return len(ans) == numCourses

Uriel 2023-07-13 16:25 发表评论

[LeetCode]1514. Path with Maximum Probability (Medium) Python-2023.06.28

Uriel — Wed, 28 Jun 2023 13:42:00 GMT

给出一个无向图，每条边有一个概率值，问从从start节点到end节点的所有path中概率值最大为多少（概率值为连乘关系）

1 #1514
2 #Runtime: 590 ms (Beats 94.20%)
3 #Memory: 26.2 MB (Beats 97.10%)
4
5 class Solution(object):
6     def kSmallestPairs(self, nums1, nums2, k):
7         """
8         :type nums1: List[int]
9         :type nums2: List[int]
10         :type k: int
11         :rtype: List[List[int]]
12         """
13         fg = set()
14         ans = []
15         hp = []
16         for i in range(min(len(nums1), k)):
17             heapq.heappush(hp, (nums1[i] + nums2[0], nums1[i], nums2[0], 0))
18         while k and hp:
19             _, i, j, idx = heapq.heappop(hp)
20             ans.append([i, j])
21             if idx < len(nums2) - 1:
22                 heapq.heappush(hp, (i + nums2[idx + 1], i, nums2[idx + 1], idx + 1))
23             k -= 1
24         return ans

Uriel 2023-06-28 21:42 发表评论

[LeetCode]934. Shortest Bridge (Medium) Python-2023.05.21

Uriel — Sun, 21 May 2023 14:14:00 GMT

给出0-1二维数组，1组成两个不连通区域，为至少将几个0改为1可以让两个区域联通
BFS，先从任意1开始BFS记录所有boundary cell，然后从boundary cell开始BFS，每次处理完queue中所有元素step+1，知道搜到另一个区域

1 #934
2 #Runtime: 302 ms (Beats 92.21%)
3 #Memory: 13.9 MB (Beats 96.10%)
4
5 class Solution(object):
6     def shortestBridge(self, grid):
7         """
8         :type grid: List[List[int]]
9         :rtype: int
10         """
11         d = [[-1, 0], [1, 0], [0, 1], [0, -1]]
12         x, y = next((x, y) for x in range(len(grid)) for y in range(len(grid[0])) if grid[x][y] == 1)
13         q = deque([(x, y)])
14         boundary = set()
15         while q:
16             x, y = q.popleft()
17             grid[x][y] = -1
18             for i, j in d:
19                 tx = x + i
20                 ty = y + j
21                 if 0 <= tx < len(grid) and 0 <= ty < len(grid[0]) and grid[tx][ty] != -1:
22                     if grid[tx][ty] == 1:
23                         grid[tx][ty] = -1
24                         q.append((tx, ty))
25                     else:
26                         boundary.add((x, y))
27
28         step = 0
29         q = deque(boundary)
30         while q:
31             sz = len(q)
32             while sz > 0:
33                 sz -= 1
34                 x, y = q.popleft()
35                 grid[x][y] = -1
36                 for i, j in d:
37                     tx = x + i
38                     ty = y + j
39                     if 0 <= tx < len(grid) and 0 <= ty < len(grid[0]) and grid[tx][ty] != -1:
40                         if grid[tx][ty] == 1:
41                             return step
42                         else:
43                             grid[tx][ty] = -1
44                             q.append((tx, ty))
45             step += 1
46         return -1
47

Uriel 2023-05-21 22:14 发表评论

[LeetCode]399. Evaluate Division (Medium) Python-2023.05.20

Uriel — Sat, 20 May 2023 10:27:00 GMT

给出一堆equations和values，其中的值代表A_i/B_i=values_i，给出一堆问询，输出每个queries_i_1/queries_i_2的值

思路一：建图，BFS
思路二：并查集，写法参考了Discussion

1 #399
2 #Runtime: 25 ms (Beats 11.39%)
3 #Memory: 13.4 MB (Beats 73.42%)
4
5 class Solution(object):
6     def calcEquation(self, equations, values, queries):
7         """
8         :type equations: List[List[str]]
9         :type values: List[float]
10         :type queries: List[List[str]]
11         :rtype: List[float]
12         """
13         equ = {}
14
15         def find(x):
16             p, v = equ.setdefault(x, (x, 1))
17             if x != p:
18                 r, w = find(p)
19                 equ[x] = (r, w * v)
20             return equ[x]
21
22         def union(x, y, v):
23             px, pv = find(x)
24             py, pw = find(y)
25             if not v:
26                 if px == py:
27                     return pv / pw
28                 else:
29                     return -1
30             if px != py:
31                 equ[px] = (py, pw / pv * v)
32
33         for (x, y), v in zip(equations, values):
34             union(x, y ,v)
35         ans = []
36         for x, y in queries:
37             if x in equ and y in equ:
38                 ans.append(union(x, y, 0))
39             else:
40                 ans.append(-1)
41         return ans
42

Uriel 2023-05-20 18:27 发表评论

[LeetCode]785. Is Graph Bipartite? (Medium) Python-2023.05.19

Uriel — Fri, 19 May 2023 12:26:00 GMT

给出一个无向图的边集，问是否是二分图，并查集基本应用

1 #785
2 #Runtime: 160 ms (Beats 23.18%)
3 #Memory: 13.6 MB (Beats 95%)
4
5 class Solution(object):
6     def isBipartite(self, graph):
7         """
8         :type graph: List[List[int]]
9         :rtype: bool
10         """
11         parent = [i for i in range(len(graph))]
12
13         def find(x):
14             if parent[x] != x:
15                 parent[x] = find(parent[x])
16             return parent[x]
17
18         def union(x, y):
19             fa, fb = find(x), find(y)
20             parent[fb] = fa
21
22         for i in range(len(graph)):
23             for j in range(len(graph[i])):
24                 pi, pj = find(i), find(graph[i][j])
25                 if pi == pj:
26                     return False
27                 union(graph[i][0], graph[i][j])
28
29         return True

Uriel 2023-05-19 20:26 发表评论

[LeetCode]1557. Minimum Number of Vertices to Reach All Nodes (Medium) Python-2023.05.18

Uriel — Thu, 18 May 2023 11:04:00 GMT

给出一个n个节点的有向无环图，问最少可以划分为多少个group，使得每个group内的所有节点都可以从group内其他任意一个节点到达
能想到的基本就是DFS或者并查集，但Discussion一个思路很巧，如果一个节点没有指向它的边，那它肯定要作为某个独立group的一员，于是只要O(m+n)统计哪些节点没有指向它的边即可

1 #1557
2 #Runtime: 976 ms (Beats 46.57%)
3 #Memory: 54.4 MB (Beats 87.67%)
4
5 class Solution(object):
6     def findSmallestSetOfVertices(self, n, edges):
7         """
8         :type n: int
9         :type edges: List[List[int]]
10         :rtype: List[int]
11         """
12         has_input = [False] * n
13         ans = []
14         for edge in edges:
15             has_input[edge[1]] = True
16         for i, r in enumerate(has_input):
17             if not r:
18                 ans.append(i)
19         return ans

Uriel 2023-05-18 19:04 发表评论

[LeetCode]1579. Remove Max Number of Edges to Keep Graph Fully Traversable (Hard) Python-2023.04.30

Uriel — Sun, 30 Apr 2023 12:07:00 GMT

给出一个无向图，里面有三种边，1号边只能让Alice通过，2号边只能让Bob通过，3号边两人都可以走，问最多可以去掉图中几条边让两人可以走通所有节点，并查集应用
思路参考->https://leetcode.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/solutions/3468567

1 #1579
2 #Runtime: 1874 ms (Beats 35.71%)
3 #Memory: 63.1 MB (Beats 71.43%)
4
5 class UnionFind:
6     def __init__(self, n):
7         self.parent = list(range(n + 1))
8         self.cc = n
9     def union(self, a, b):
10         fa = self.find(a)
11         fb = self.find(b)
12         if fa == fb:
13             return 0
14         self.parent[fa] = fb
15         self.cc -= 1
16         return 1
17
18     def find(self, a):
19         if self.parent[a] != a:
20             self.parent[a] = self.find(self.parent[a])
21         return self.parent[a]
22
23     def judge(self):
24         return self.cc == 1
25
26 class Solution(object):
27     def maxNumEdgesToRemove(self, n, edges):
28         """
29         :type n: int
30         :type edges: List[List[int]]
31         :rtype: int
32         """
33         alice, bob = UnionFind(n), UnionFind(n)
34
35         t = 0
36         for a, u, v in edges:
37             if a == 3:
38                 t += alice.union(u, v) | bob.union(u, v)
39             if alice.judge() and bob.judge():
40                 return len(edges) - t
41
42         for a, u, v in edges:
43             if a == 1:
44                 t += alice.union(u, v)
45             elif a == 2:
46                 t += bob.union(u, v)
47             if alice.judge() and bob.judge():
48                 return len(edges) - t
49
50         if not alice.judge() or not bob.judge():
51             return -1
52
53         return len(edges) - t

Uriel 2023-04-30 20:07 发表评论

[LeetCode]1697. Checking Existence of Edge Length Limited Paths (Hard) Python-2023.04.29

Uriel — Sat, 29 Apr 2023 14:15:00 GMT

给出一个无向图最多100000个节点，每条边给出相应的距离，有最多100000次询问，每次询问x和y节点之间是否存在一条路，路上所有边的距离都小于（不包含等于）limit。并查集的应用，在合并和查找时增加对dis的维护和判断

1 #1697
2 #Runtime: 1668 ms (Beats 100%)
3 #Memory: 59.9 MB (Beats 100%)
4
5 class Solution(object):
6     def distanceLimitedPathsExist(self, n, edgeList, queries):
7         """
8         :type n: int
9         :type edgeList: List[List[int]]
10         :type queries: List[List[int]]
11         :rtype: List[bool]
12         """
13         parent = [i for i in range(n)]
14         rank = [i for i in range(n)]
15         def find(x, limit):
16             while x != parent[x]:
17                 if dis[x] >= limit:
18                     break
19                 x = parent[x]
20             return x
21
22         def union(x, y, d):
23             fa = find(x, float('inf'))
24             fb = find(y, float('inf'))
25             if fa != fb:
26                 if rank[fa] < rank[fb]:
27                     parent[fa] = fb
28                     dis[fa] = d
29                 else:
30                     parent[fb] = fa
31                     dis[fb] = d
32                     if rank[fa] == rank[fb]:
33                         rank[fa] += 1
34
35         def judge(x, y, limit):
36             return find(x, limit) == find(y, limit)
37
38         dis = [0 for _ in range(n)]
39         edgeList.sort(key=lambda x: x[2])
40         for ed in edgeList:
41             union(ed[0], ed[1], ed[2])
42         ans = []
43         for q in queries:
44             ans.append(judge(q[0], q[1], q[2]))
45         return ans

Uriel 2023-04-29 22:15 发表评论

[LeetCode]1857. Largest Color Value in a Directed Graph (Hard) Python-2023.04.09

Uriel — Sun, 09 Apr 2023 10:28:00 GMT

给定一个有向图，和其中每个节点的颜色，问其中的所有path中经过同色最多的节点的个数，DFS划水过了
*有部分参考->https://leetcode.com/problems/largest-color-value-in-a-directed-graph/solutions/3396323/

1 #1857
2 #Runtime: 3256 ms (Beats 12.50%)
3 #Memory: 202.1 MB (Beats 12.50%)
4
5 class Solution(object):
6     def largestPathValue(self, colors, edges):
7         """
8         :type colors: str
9         :type edges: List[List[int]]
10         :rtype: int
11         """
12         graph = defaultdict(list)
13         for x, y in edges:
14             graph[x].append(y)
15         vis = set()
16         path = set()
17         ans = 0
18         n = len(colors)
19         self.has_circle = False
20         cnt = [[0] * 26 for _ in range(n)]
21         def DFS(x):
22             if x in path:
23                 self.has_circle = True
24             if x in vis:
25                 return 0
26             vis.add(x)
27             path.add(x)
28             idx = ord(colors[x]) - ord('a')
29             cnt[x][idx] = 1
30             for y in graph[x]:
31                 DFS(y)
32                 if self.has_circle == True:
33                     return float('inf')
34                 for ch in range(26):
35                     cnt[x][ch] = max(cnt[x][ch], (1 if ch == idx else 0) + cnt[y][ch])
36             path.remove(x)
37             return max(cnt[x])
38
39         for i in range(n):
40             ans = max(ans, DFS(i))
41         return -1 if ans == float('inf') else ans

Uriel 2023-04-09 18:28 发表评论

[LeetCode]133. Clone Graph (Medium) Python-2023.04.08

Uriel — Sat, 08 Apr 2023 10:48:00 GMT

克隆一个无向图，可能有环，直接DFS

1 #133
2 #Runtime: 41 ms (Beats 39.30%)
3 #Memory: 13.8 MB (Beats 37.71%)
4
5 """
6 # Definition for a Node.
7 class Node(object):
8     def __init__(self, val = 0, neighbors = None):
9         self.val = val
10         self.neighbors = neighbors if neighbors is not None else []
11 """
12
13 class Solution(object):
14     def cloneGraph(self, node):
15         """
16         :type node: Node
17         :rtype: Node
18         """
19         def DFS(node, cloned_graph):
20             if node not in cloned_graph:
21                 cloned_graph[node] = Node(node.val)
22                 for nr in node.neighbors:
23                     cloned_graph[node].neighbors.append(DFS(nr, cloned_graph))
24             return cloned_graph[node]
25         if node == None:
26             return None
27         return DFS(node, {})

Uriel 2023-04-08 18:48 发表评论

[LeetCode]2360. Longest Cycle in a Graph (Hard) Python-2023.03.26

Uriel — Sun, 26 Mar 2023 10:35:00 GMT

给出一幅有向图，edges每一个元素edges[i]代表从节点i可以到达edges[i]（从每个节点出发最多只有一条边，edges[i]=-1代表从该点没有向外的边），问图中最大的环包含多少节点，简单DFS即可

1 #2360
2 #Runtime: 1406 ms (Beats 28.57%)
3 #Memory: 135.2 MB (Beats 14.29%)
4
5 class Solution(object):
6     def longestCycle(self, edges):
7         """
8         :type edges: List[int]
9         :rtype: int
10         """
11         vis = [0] * len(edges)
12         self.ans = -1
13         self.pre = 0
14         def DFS(node, st):
15             self.pre += 1
16             vis[node] = self.pre
17             if edges[node] == -1:
18                 return
19             if not vis[edges[node]]:
20                     DFS(edges[node], st)
21             elif vis[edges[node]] > st:
22                 self.ans = max(self.ans, self.pre - vis[edges[node]] + 1)
23         for i in range(len(edges)):
24             if not vis[i]:
25                 DFS(i, self.pre)
26         return self.ans

Uriel 2023-03-26 18:35 发表评论

[LeetCode]2316. Count Unreachable Pairs of Nodes in an Undirected Graph (Medium) Python-2023.03.25

Uriel — Sat, 25 Mar 2023 09:22:00 GMT

给出一个无向图，问其中一共有多少个节点对是不连通的，用DFS出每个连通分量的节点数暴力搞过了，最后计数的部分要这么稍稍优化一下不然TLE
用并查集应该会更快

1 #2316
2 #Runtime: 2121 ms (Beats 54.5%)
3 #Memory: 114.9 MB (Beats 16.22%)
4
5 class Solution(object):
6     def countPairs(self, n, edges):
7         """
8         :type n: int
9         :type edges: List[List[int]]
10         :rtype: int
11         """
12         edge = defaultdict(list)
13         for x, y in edges:
14             edge[x].append(y)
15             edge[y].append(x)
16         vis = [0] * n
17
18         def DFS(node):
19             vis[node] = 1
20             self.tp += 1
21             for y in edge[node]:
22                 if not vis[y]:
23                     DFS(y)
24
25         ncc = []
26         ans = 0
27         for i in range(n):
28             if not vis[i]:
29                 self.tp = 0
30                 DFS(i)
31                 ncc.append(self.tp)
32         total = 0
33         for j in range(len(ncc)):
34             ans += (n - total - ncc[j]) * ncc[j]
35             total += ncc[j]
36         return ans

Uriel 2023-03-25 17:22 发表评论

[LeetCode]1466. Reorder Routes to Make All Paths Lead to the City Zero (Medium) Python-2023.03.24

Uriel — Fri, 24 Mar 2023 09:42:00 GMT

给出一颗连通的有n个节点的树，求问若将原先树中每条无向边[a,b]当作有向边，至少需要改变其中几条边的方向才能使得每个节点都可以到达节点0
建图的时候每条路建双向边，但增加一个标记来区分方向，从节点0开始DFS一遍，记录反向边的个数即可

1 #1466
2 #Runtime: 1109 ms (Beats 60%)
3 #Memory: 78.5 MB (Beats 26.15%)
4
5 class Solution(object):
6     def minReorder(self, n, connections):
7         """
8         :type n: int
9         :type connections: List[List[int]]
10         :rtype: int
11         """
12         edge = defaultdict(list)
13         for x, y in connections:
14             edge[x].append((y, 1))
15             edge[y].append((x, 0))
16         vis = [0] * n
17         self.ans = 0
18         def DFS(node):
19             vis[node] = 1
20             for y, d in edge[node]:
21                 if not vis[y]:
22                     if d:
23                         self.ans += 1
24                     DFS(y)
25         DFS(0)
26         return self.ans

Uriel 2023-03-24 17:42 发表评论

[LeetCode]1319. Number of Operations to Make Network Connected (Medium) Python-2023.03.23

Uriel — Thu, 23 Mar 2023 09:20:00 GMT

给出一幅无向图，一共n个节点，问是否可以通过改变其中的若干边使得所有节点联通
首先判断图中边数是否>n-1，不满足的话不可能联通
符合条件的话求连通分量个数ncc，输出ncc-1

1 #1319
2 #Runtime: 1542 ms (Beats 70.59%)
3 #Memory: 73.7 MB (Beats 58.82%)
4
5 class Solution(object):
6     def minScore(self, n, roads):
7         """
8         :type n: int
9         :type roads: List[List[int]]
10         :rtype: int
11         """
12         edge = defaultdict(list)
13         ans = 0
14         for x, y, w in roads:
15             edge[x].append((y, w))
16             edge[y].append((x, w))
17             ans += w
18         q = deque([1])
19         vis = [0] * (n + 1)
20         vis[1] = 1
21         while q:
22             x = q.popleft()
23             for y, w in edge[x]:
24                 if not vis[y]:
25                     q.append(y)
26                 vis[y] = 1
27                 ans = min(ans, w)
28         return ans

Uriel 2023-03-23 17:20 发表评论

[LeetCode]2492. Minimum Score of a Path Between Two Cities (Medium) Python-2023.03.22

Uriel — Wed, 22 Mar 2023 08:13:00 GMT

给出一个无向图，一共n个节点，每条边有一个distance，问从节点1到n的所有路线中单条边distance的最小值是多少
题目保证一定有一条从1到n的路，所以就整个图从节点1开始BFS一遍，更新单条路的distance最小值

1 #2492
2 #Runtime: 1542 ms (Beats 70.59%)
3 #Memory: 73.7 MB (Beats 58.82%)
4
5 class Solution(object):
6     def minScore(self, n, roads):
7         """
8         :type n: int
9         :type roads: List[List[int]]
10         :rtype: int
11         """
12         edge = defaultdict(list)
13         ans = 0
14         for x, y, w in roads:
15             edge[x].append((y, w))
16             edge[y].append((x, w))
17             ans += w
18         q = deque([1])
19         vis = [0] * (n + 1)
20         vis[1] = 1
21         while q:
22             x = q.popleft()
23             for y, w in edge[x]:
24                 if not vis[y]:
25                     q.append(y)
26                 vis[y] = 1
27                 ans = min(ans, w)
28         return ans

Uriel 2023-03-22 16:13 发表评论

[LeetCode]1129. Shortest Path with Alternating Colors (Medium) Python-2023.02.11

Uriel — Sat, 11 Feb 2023 11:17:00 GMT

给出n个节点的有向图边集，分为红色边和蓝色边，开始位于节点0，问依次经过红色蓝色边到达节点0～n-1的最短路径，若不可达，输出-1
为两个不同颜色的边集分别建立dict，color分别设为0和1，初始节点的color设为-1，从0开始BFS，走过的边把color值设为-1

1 #1129
2 #Runtime: 64 ms (Beats 75.93%)
3 #Memory: 13.6 MB (Beats 90.74%)
4
5 class Solution(object):
6     def shortestAlternatingPaths(self, n, redEdges, blueEdges):
7         """
8         :type n: int
9         :type redEdges: List[List[int]]
10         :type blueEdges: List[List[int]]
11         :rtype: List[int]
12         """
13         graph = defaultdict(list)
14         for x, y in redEdges:
15             graph[x].append((y, 0))
16         for x, y in blueEdges:
17             graph[x].append((y, 1))
18         q = deque([(0, -1)])
19         ans = [-1] * n
20         stp = 0
21         while q:
22             sz = len(q)
23             while sz > 0:
24                 sz -= 1
25                 x, fg = q.popleft()
26                 if ans[x] == -1:
27                     ans[x] = stp
28                 for i, (y, f) in enumerate(graph[x]):
29                     if y == -1 or f == fg:
30                         continue
31                     q.append((y, f))
32                     graph[x][i] = (-1, f)
33             stp += 1
34         return ans

Uriel 2023-02-11 19:17 发表评论

[LeetCode]787. Cheapest Flights Within K Stops (Medium) Python-2023.01.26

Uriel — Thu, 26 Jan 2023 08:42:00 GMT

给出一些航线和价格flights[i] = [from_i, to_i, price_i]，问从src到dst，不超过k次中转，最低开销多少，如果无法实现，输出-1
直接BFS效率还可以，Discussion有更优秀的方法，以后再刷

1 #787
2 #Runtime: 72 ms (Beats 97.24%)
3 #Memory: 15.2 MB (Beats 26.38%)
4
5 class Solution(object):
6     def findCheapestPrice(self, n, flights, src, dst, k):
7         """
8         :type n: int
9         :type flights: List[List[int]]
10         :type src: int
11         :type dst: int
12         :type k: int
13         :rtype: int
14         """
15         f = defaultdict(dict)
16         for x, y, p in flights:
17             f[x][y] = p
18         q = deque([[src, 0]])
19         min_cst = [10000000] * n
20         for j in range(k + 1):
21             len_q = len(q)
22             for _ in range(len_q):
23                 [x, cst] = q.popleft()
24                 for y in f[x]:
25                     t_cst = cst + f[x][y]
26                     if t_cst < min_cst[y]:
27                         min_cst[y] = t_cst
28                         q.append([y, t_cst])
29         if min_cst[dst] == 10000000:
30             return -1
31         return min_cst[dst]

Uriel 2023-01-26 16:42 发表评论

[LeetCode]886. Possible Bipartition (Medium) Python-2022.12.21

Uriel — Wed, 21 Dec 2022 08:18:00 GMT

给出一些id pairs，[a, b]表示a不想与b分在一组，一共n个id，问是否可以分成两个group。
并查集，对于每个id i，预处理所有不能和他一组的ids，这些ids将会被分在一组（并查集union操作），如果发现i和这些id在并查集的同一组，则输出False

1 #886
2 #Runtime: 2223 ms (Beats 5.11%)
3 #Memory: 19.1 MB (Beats 72.26%)
4
5 class UnionFind:
6     def __init__(self, n):
7         self.parent = [i for i in range(n + 1)]
8     def find(self, x):
9         i = x
10         while self.parent[x] != x:
11             x = self.parent[x]
12         self.parent[i] = x
13         return x
14     def union(self, x, y):
15         self.parent[self.find(x)] = self.find(y)
16
17
18 class Solution(object):
19     def possibleBipartition(self, n, dislikes):
20         """
21         :type n: int
22         :type dislikes: List[List[int]]
23         :rtype: bool
24         """
25         if n == 1:
26             return True
27         graph_dict = {}
28         for d in dislikes:
29             if d[0] not in graph_dict:
30                 graph_dict[d[0]] = [d[1]]
31             else:
32                 graph_dict[d[0]].append(d[1])
33             if d[1] not in graph_dict:
34                 graph_dict[d[1]] = [d[0]]
35             else:
36                 graph_dict[d[1]].append(d[0])
37         uf_set = UnionFind(n)
38         for x in graph_dict.keys():
39             for i in range(len(graph_dict[x]) - 1):
40                 uf_set.union(graph_dict[x][i], graph_dict[x][i + 1])
41             if uf_set.find(x) == uf_set.find(graph_dict[x][0]):
42                 return False
43         return True

Uriel 2022-12-21 16:18 发表评论

POJ 3613 Cow Relays---Floyd+矩阵相乘

Uriel — Mon, 02 May 2011 09:39:00 GMT

这是在DY大牛第六期专题里列出的题目之一.

话说搞ACM也2年多了, 竟然用矩阵乘法+Floyd的题目都还没有做过... 上周的组队赛遇到一道题才听说... (没有拜读matrix67的神文... 检讨下... )

/**//*
POJ 3613 Cow Relays

-------Classify: Floyd+矩阵乘法
----Description: 求从S到T恰好经过K条边(可重复走)的最短路
-----------------K<=1e6, m<100(边数)
---Sample Input:

2 6 6 4----------//K m s t
11 4 6-----------//length x<->y
4 4 8
8 4 9
6 6 8
2 6 9
3 8 9

--Sample Output:

10

-----Time Limit: 1000Ms
---------Source: USACO 2007 November Gold
-------Solution: 

    By Solution Report

    01邻接矩阵A的K次方C=A^K,C[i][j]表示i点到j点正好经过K条边的路径数

          对应于这道题,对邻接图进行K次floyd之后,C[i][j]就是点i到j正好经过K条边的最短路


---------Status: AC C++ 532Ms
-----------Date: 2011.05.02
------Reference: http://hi.baidu.com/aconly/blog/item/23fb73acc1d874004b36d634.html
-----------Code: 
*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define N 1010
#define INF 0x3f3f3f3f
typedef int M[N][N];

int k, m, s, t, v;
int ans[N][N], adj[N][N], vis[N], vtx[N], dis[N][N], tp[N][N];

void floyd(M c, M a, M b) {
    int i, j, k;
    for (k = 0; k < v; ++k)
        for (i = 0; i < v; ++i)
            for (j = 0; j < v; ++j)
                if (c[vtx[i]][vtx[j]] > a[vtx[i]][vtx[k]] + b[vtx[k]][vtx[j]])
                    c[vtx[i]][vtx[j]] = a[vtx[i]][vtx[k]] + b[vtx[k]][vtx[j]];
}

void copy(M a, M b) {
    int i, j;
    for (i = 0; i < v; ++i)
        for (j = 0; j < v; ++j) {
            a[vtx[i]][vtx[j]] = b[vtx[i]][vtx[j]];
            b[vtx[i]][vtx[j]] = INF;
        }
}

void BS(int k) {
    while (k) {
        if (k & 1) {
            floyd(dis, ans, adj);
            copy(ans, dis);
        }
        floyd(tp, adj, adj);
        copy(adj, tp);
        k >>= 1;
    }
}

int main() {
    int i, j, x, y, w;
    scanf("%d %d %d %d", &k, &m, &s, &t);
    for (i = 0; i <= 1001; ++i) {
        for (j = 0; j <= 1001; ++j) {
            adj[i][j] = INF;
            tp[i][j] = INF;
            dis[i][j] = INF;
            ans[i][j] = INF;
        }
        ans[i][i] = 0;
    }
    v = 0;
    memset(vis, 0, sizeof(vis));
    for (i = 0; i < m; ++i) {
        scanf("%d %d %d", &w, &x, &y);
        if (!vis[x]) {
            vis[x] = 1;
            vtx[v++] = x;
        }
        if (!vis[y]) {
            vis[y] = 1;
            vtx[v++] = y;
        }
        if (adj[x][y] > w)
            adj[x][y] = adj[y][x] = w;
    }
    BS(k);
    printf("%d\n", ans[s][t]);
    return 0;
}

Uriel 2011-05-02 17:39 发表评论

POJ 2942 Knights of the Round Table---双连通分量 & 判二分图

Uriel — Sun, 08 Aug 2010 13:02:00 GMT

一切均参考了DY大牛的Blog，http://www.answeror.com/?s=2942
丑陋的代码就不贴了。。。

Uriel 2010-08-08 21:02 发表评论

POJ 3713 Transferring Sylla---判3-连通

Uriel — Sun, 08 Aug 2010 12:54:00 GMT

判一个无向图是不是至少3-连通
方法是枚举点，去掉一个点之后判余下的图中是否存在割点，如果都存在，则是至少3-连通，否则就不是

//Problem: 3713  User: Uriel
//Memory: 2164K  Time: 3922MS
//Language: C++  Result: Accepted
//enumration & cut vertex
//2010.08.07
#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
#define N 510

int n,m,cnt,root;
int ancestor[N];
int mark[N];
int deep[N];
int b[N][N];
int adj[N][N];
bool flag;

int DFS(int u,int fa,int t){
    mark[u]=1;
    deep[u]=ancestor[u]=t;
    int cnt=0;
    int i,v;
    for(i=b[u][0];i>=1;i--){
        v=b[u][i];
        if(mark[v]==2)continue;
        if(mark[v]==0){
            DFS(v,u,t+1);
            cnt++;
            ancestor[u]=min(ancestor[u],ancestor[v]);
            if(u==root && cnt>1 || u!=root && ancestor[v]>=deep[u])flag=1;
        }
        else if(mark[v]==1 && v!=fa){
            ancestor[u]=min(ancestor[u],deep[v]);
        }
    }
    return 0;
}

int main(){
    int x,y,i,j;
    while(scanf("%d %d",&n,&m),n|m){
        memset(adj,0,sizeof(adj));
        for(i=0;i<n;i++)b[i][0]=0;
        for(i=0;i<m;i++){
            scanf("%d %d",&x,&y);
            adj[x][y]=adj[y][x]=1;
        }
        for(i=0;i<n;i++){
            for(j=0;j<n;j++){
                if(adj[i][j])b[i][++b[i][0]]=j;
            }
        }
        flag=false;
        for(i=0;i<n;i++){
            memset(mark,0,sizeof(mark));
            memset(deep,0,sizeof(deep));
            memset(ancestor,0,sizeof(ancestor));
            mark[i]=2;
            if(i==0)root=1;
            else
                root=0;
            DFS(root,-1,1);
            for(j=0;j<n;j++){
                if(mark[j]==0){
                    flag=true;
                    break;
                }
            }
            if(flag)break;
        }
        if(flag)puts("NO");
        else
            puts("YES");
     }
     return 0;
}

Uriel 2010-08-08 20:54 发表评论

POJ 1144 Network---求无向图割点数

Uriel — Sun, 08 Aug 2010 11:46:00 GMT

赤裸裸的求割点数的题目，上模板~~
关于求割点的方法，黑书上讲得比较详细了

//Problem: 1144  User: Uriel
//Memory: 228K  Time: 16MS
//Language: C++  Result: Accepted
//Cut Vertex
//2010.08.06
#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
#define N 110

int n;
int ancestor[N];
int mark[N];
int deep[N];
int cnt[N];
int adj[N][N];

int DFS(int i,int father,int dth,int b[][N],int cut[]){
    int j,k,sons=0,count=0;
    mark[i]=1;
    deep[i]=ancestor[i]=dth;
    for(k=b[i][0];k>=1;k--){
        j=b[i][k];
        if(j!=father && mark[j]==1)ancestor[i]=min(ancestor[i],deep[j]);
        if(mark[j]==0){
            count+=DFS(j,i,dth+1,b,cut);
            sons++;
            ancestor[i]=min(ancestor[i],ancestor[j]);
            if((father==-1&&sons>1)||(father!=-1&&ancestor[j]>=deep[i]))cut[i]=1;
            //if(ancestor[j]>deep[i]) brige[i][j]=1;
        }
    }
    mark[i]=2;
    return count+cut[i];
}

int cutpoints(int a[][N],int n,int cut[]){
    int i,j,b[N][N],count=0;
    for(i=0;i<n;i++)cut[i]=b[i][0]=0;
    memset(mark,0,sizeof(mark));
    for(i=0;i<n;i++)for(j=0;j<n;j++)if(a[i][j])b[i][++b[i][0]]=j;
    for(i=0;i<n;i++)if(mark[i]==0)count+=DFS(0,-1,0,b,cut);
    return count;
}

int main(){
    int x,y;
    char c;
     while(1){
         scanf("%d",&n);
         if(!n)return 0;
         memset(adj,0,sizeof(adj));
         while(1){
             scanf("%d",&x);
             if(x==0)break;
             x--;
             while(1){
                 scanf("%d",&y);
                 y--;
                 adj[x][y]=1;adj[y][x]=1;
                 c=getchar();
                 if(c=='\n')break;
             }
         }
         printf("%d\n",cutpoints(adj,n,cnt));
     }
     return 0;
}

Uriel 2010-08-08 19:46 发表评论

POJ 1523 SPF---DFS

Uriel — Sun, 08 Aug 2010 11:42:00 GMT

求割点没什么问题，但是求去掉这个割点图被分为几个连通分支没什么思路，看了解题报告恍然大悟，DFS就行了啊~~
枚举点，去掉看暴力DFS看被分成几块，判了是否是割点的同时也知道了连通分支数

//Problem: 1523  User: Uriel
//Memory: 4136K  Time: 16MS
//Language: C++  Result: Accepted
//Version: DFS
//2010.08.07
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define N 1010
int num;
int map[N][N],arr[N];
bool vis[N];

int Loc(int k){
    int i=0;
    for(i=0;i<num;i++){
        if(arr[i]==k)break;
    }
    if(i==num){
        arr[num++]=k;
        return num-1;
    }
    return i;
}

void DFS(int x){
    vis[x]=true;
    for(int j=0;j<num;j++){
        if(!vis[j] && map[x][j])DFS(j);
    }
}

int main(){
    int g=1,x,y,a,b,l,s;
    while(scanf("%d",&x),x){
        scanf("%d",&y);
        num=0;
        a=Loc(x);b=Loc(y);
        map[a][b]=map[b][a]=1;
        while(scanf("%d",&x),x){
            scanf("%d",&y);
            a=Loc(x);b=Loc(y);
            map[a][b]=map[b][a]=1;
        }
        printf("Network #%d\n",g++);
        l=num-1;
        for(int i=0;i<num;i++){
            memset(vis,false,sizeof(vis));
            s=0;
            vis[i]=true;
            for(int j=0;j<num;j++)
                if(!vis[j]){
                    DFS(j);
                    s++;
                }
            if(s>1){
                printf("  SPF node %d leaves %d subnets\n",arr[i],s);
            }
            else
                l--;
        }
        if(l==-1)printf("  No SPF nodes\n");
        printf("\n");
        memset(map,0,sizeof(map));
    }
    return 0;
}

Uriel 2010-08-08 19:42 发表评论

POJ 3715 Blue and Red---二分图匹配

Uriel — Sun, 08 Aug 2010 11:34:00 GMT

摘要: 想到二分图，但是不知道那种贪心思想对不对以及如何优化。。参考了解题报告感谢大牛的解题报告：http://hi.baidu.com/liuzhe/blog/item/793e0c24efa6602cd407428a.html基本上照着写的，然后加了读入输出优化，效果惊人。。0MS。。暂时Rank1了。。还是头一次刷到这么前。。 //Problem: 3715 Use... 阅读全文

Uriel 2010-08-08 19:34 发表评论

POJ 2724 Purifying Machine---二分图匹配

Uriel — Mon, 02 Aug 2010 14:42:00 GMT

建图啊建图。。
思路完全膜拜AC大牛的代码http://hi.baidu.com/aekdycoin/blog/item/2dac891ea09ef9f2e1fe0b67.html....

代码如下：

//Problem: 2724  User: Uriel
//Memory: 384K  Time: 110MS
//Language: G++  Result: Accepted
//floyd+Bipartite Graph
//2010.08.02

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int n,m;
char a[1050][11];
int d[1050];
int nx,num[1050];
int f[11]={1,2,4,8,16,32,64,128,256,512,1024};
int link[1050],in[1050];

bool map(int a , int b){
    int t1=num[a],t2=num[b];
    int m=t1^t2;
    if(m && ((m&(m-1))==0))return true;
    return false;
}

bool fun(int k){
    int i;
    for(i=0;i<nx;i++){
        if(i==k)continue;
        if(map(i,k) && !in[i]){
            in[i]=1;
            if(link[i]==-1 || fun(link[i])){
                link[i]=k;
                return true;
            }
        }
    }
    return false;
}

int main(){
    while(scanf("%d%d",&n,&m)){
        if(n==0 && m==0)break;
        nx=0;
        int i,j,t;
        memset(d,0,sizeof(d));
        for(i=0;i<m;i++){
            scanf("%s",(a[i]));
            int flag=-1;
            t=0;
            for(j=0;j<n;j++){
                if(a[i][j]=='*'){
                    flag=j;
                    continue;
                }
                t+=f[j]*(a[i][j]-'0');
            }
            if(!d[t]){
                d[t]=1;
                num[nx++]=t;
            }
            if(flag!=-1 && !d[t+f[flag]]){
                d[t+f[flag]]=1;
                num[nx++]=t+f[flag];
            }
        }
        int res=0;
        memset(link,-1,sizeof(link));
        for(i=0;i<nx;i++){
            memset(in,0,sizeof(in));
            if(fun(i))res++;
        }
        printf("%d\n",nx-res/2);
    }
    return 0;
}

Uriel 2010-08-02 22:42 发表评论