题目描述
在本问题中，有根树指满足以下条件的 有向 图。该树只有一个根节点，所有其他节点都是该根节点的后继。该树除了根节点之外的每一个节点都有且只有一个父节点，而根节点没有父节点。
输入一个有向图，该图由一个有着 n 个节点（节点值不重复，从 1 到 n）的树及一条附加的有向边构成。附加的边包含在 1 到 n 中的两个不同顶点间，这条附加的边不属于树中已存在的边。
结果图是一个以边组成的二维数组 edges 。 每个元素是一对 [ui, vi]，用以表示 有向 图中连接顶点 ui 和顶点 vi 的边，其中 ui 是 vi 的一个父节点。
返回一条能删除的边，使得剩下的图是有 n 个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。
示例 1：
输入：edges = [[1,2],[1,3],[2,3]]
输出：[2,3]
示例 2：
输入：edges = [[1,2],[2,3],[3,4],[4,1],[1,5]]
输出：[4,1]
提示：
n == edges.length3 <= n <= 1000edges[i].length == 21 <= ui, vi <= n
解法
方法一：并查集
根据题目描述，对于一棵有根树，根节点的入度为 \(0\)，其余节点的入度为 \(1\)。在向树中添加一条边之后，可能会出现以下三种情况：
-
添加的边指向了非根节点，该节点的入度变为 \(2\)，此时图中不存在有向环；
-
添加的边指向了非根节点，该节点的入度变为 \(2\)，此时图中存在有向环；
-
添加的边指向了根节点，根节点的入度变为 \(1\)，此时图中存在有向环，但不存在入度为 \(2\) 的节点。
因此，我们首先计算每个节点的入度，如果存在入度为 \(2\) 的节点，我们定位到该节点对应的两条边，分别记为 \(\textit{dup}[0]\) 和 \(\textit{dup}[1]\)。如果在删除 \(\textit{dup}[1]\) 之后，剩余的边无法形成树，则说明 \(\textit{dup}[0]\) 是需要删除的边；否则 \(\textit{dup}[1]\) 是需要删除的边。
如果不存在入度为 \(2\) 的节点，我们遍历数组 \(\textit{edges}\)，对于每条边 \((u, v)\)，我们使用并查集维护节点之间的连通性。如果 \(u\) 和 \(v\) 已经连通，说明图中存在有向环，此时当前边即为需要删除的边。
时间复杂度 \(O(n \log n)\)，空间复杂度 \(O(n)\)。其中 \(n\) 为边的数量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 | class Solution:
def findRedundantDirectedConnection(self, edges: List[List[int]]) -> List[int]:
def find(x: int) -> int:
if p[x] != x:
p[x] = find(p[x])
return p[x]
n = len(edges)
ind = [0] * n
for _, v in edges:
ind[v - 1] += 1
dup = [i for i, (_, v) in enumerate(edges) if ind[v - 1] == 2]
p = list(range(n))
if dup:
for i, (u, v) in enumerate(edges):
if i == dup[1]:
continue
pu, pv = find(u - 1), find(v - 1)
if pu == pv:
return edges[dup[0]]
p[pu] = pv
return edges[dup[1]]
for i, (u, v) in enumerate(edges):
pu, pv = find(u - 1), find(v - 1)
if pu == pv:
return edges[i]
p[pu] = pv
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48 | class Solution {
private int[] p;
public int[] findRedundantDirectedConnection(int[][] edges) {
int n = edges.length;
int[] ind = new int[n];
for (var e : edges) {
++ind[e[1] - 1];
}
List<Integer> dup = new ArrayList<>();
p = new int[n];
for (int i = 0; i < n; ++i) {
if (ind[edges[i][1] - 1] == 2) {
dup.add(i);
}
p[i] = i;
}
if (!dup.isEmpty()) {
for (int i = 0; i < n; ++i) {
if (i == dup.get(1)) {
continue;
}
int pu = find(edges[i][0] - 1);
int pv = find(edges[i][1] - 1);
if (pu == pv) {
return edges[dup.get(0)];
}
p[pu] = pv;
}
return edges[dup.get(1)];
}
for (int i = 0;; ++i) {
int pu = find(edges[i][0] - 1);
int pv = find(edges[i][1] - 1);
if (pu == pv) {
return edges[i];
}
p[pu] = pv;
}
}
private int find(int x) {
if (p[x] != x) {
p[x] = find(p[x]);
}
return p[x];
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43 | class Solution {
public:
vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
int n = edges.size();
vector<int> ind(n);
for (const auto& e : edges) {
++ind[e[1] - 1];
}
vector<int> dup;
for (int i = 0; i < n; ++i) {
if (ind[edges[i][1] - 1] == 2) {
dup.push_back(i);
}
}
vector<int> p(n);
iota(p.begin(), p.end(), 0);
function<int(int)> find = [&](int x) {
return x == p[x] ? x : p[x] = find(p[x]);
};
if (!dup.empty()) {
for (int i = 0; i < n; ++i) {
if (i == dup[1]) {
continue;
}
int pu = find(edges[i][0] - 1);
int pv = find(edges[i][1] - 1);
if (pu == pv) {
return edges[dup[0]];
}
p[pu] = pv;
}
return edges[dup[1]];
}
for (int i = 0;; ++i) {
int pu = find(edges[i][0] - 1);
int pv = find(edges[i][1] - 1);
if (pu == pv) {
return edges[i];
}
p[pu] = pv;
}
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 | func findRedundantDirectedConnection(edges [][]int) []int {
n := len(edges)
ind := make([]int, n)
for _, e := range edges {
ind[e[1]-1]++
}
dup := []int{}
for i, e := range edges {
if ind[e[1]-1] == 2 {
dup = append(dup, i)
}
}
p := make([]int, n)
for i := range p {
p[i] = i
}
var find func(int) int
find = func(x int) int {
if p[x] != x {
p[x] = find(p[x])
}
return p[x]
}
if len(dup) > 0 {
for i, e := range edges {
if i == dup[1] {
continue
}
pu, pv := find(e[0]-1), find(e[1]-1)
if pu == pv {
return edges[dup[0]]
}
p[pu] = pv
}
return edges[dup[1]]
}
for _, e := range edges {
pu, pv := find(e[0]-1), find(e[1]-1)
if pu == pv {
return e
}
p[pu] = pv
}
return nil
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40 | function findRedundantDirectedConnection(edges: number[][]): number[] {
const n = edges.length;
const ind: number[] = Array(n).fill(0);
for (const [_, v] of edges) {
++ind[v - 1];
}
const dup: number[] = [];
for (let i = 0; i < n; ++i) {
if (ind[edges[i][1] - 1] === 2) {
dup.push(i);
}
}
const p: number[] = Array.from({ length: n }, (_, i) => i);
const find = (x: number): number => {
if (p[x] !== x) {
p[x] = find(p[x]);
}
return p[x];
};
if (dup.length) {
for (let i = 0; i < n; ++i) {
if (i === dup[1]) {
continue;
}
const [pu, pv] = [find(edges[i][0] - 1), find(edges[i][1] - 1)];
if (pu === pv) {
return edges[dup[0]];
}
p[pu] = pv;
}
return edges[dup[1]];
}
for (let i = 0; ; ++i) {
const [pu, pv] = [find(edges[i][0] - 1), find(edges[i][1] - 1)];
if (pu === pv) {
return edges[i];
}
p[pu] = pv;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44 | /**
* @param {number[][]} edges
* @return {number[]}
*/
var findRedundantDirectedConnection = function (edges) {
const n = edges.length;
const ind = Array(n).fill(0);
for (const [_, v] of edges) {
++ind[v - 1];
}
const dup = [];
for (let i = 0; i < n; ++i) {
if (ind[edges[i][1] - 1] === 2) {
dup.push(i);
}
}
const p = Array.from({ length: n }, (_, i) => i);
const find = x => {
if (p[x] !== x) {
p[x] = find(p[x]);
}
return p[x];
};
if (dup.length) {
for (let i = 0; i < n; ++i) {
if (i === dup[1]) {
continue;
}
const [pu, pv] = [find(edges[i][0] - 1), find(edges[i][1] - 1)];
if (pu === pv) {
return edges[dup[0]];
}
p[pu] = pv;
}
return edges[dup[1]];
}
for (let i = 0; ; ++i) {
const [pu, pv] = [find(edges[i][0] - 1), find(edges[i][1] - 1)];
if (pu === pv) {
return edges[i];
}
p[pu] = pv;
}
};
|
方法二：并查集（模板做法）
这里给出一个并查集的模板做法，供大家参考。
时间复杂度 \(O(n \alpha(n))\)，空间复杂度 \(O(n)\)。其中 \(n\) 为边的数量，而 \(\alpha(n)\) 是阿克曼函数的反函数，可以认为是一个很小的常数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43 | class UnionFind:
__slots__ = "p", "size"
def __init__(self, n: int):
self.p: List[int] = list(range(n))
self.size: List[int] = [1] * n
def find(self, x: int) -> int:
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, a: int, b: int) -> bool:
pa, pb = self.find(a), self.find(b)
if pa == pb:
return False
if self.size[pa] > self.size[pb]:
self.p[pb] = pa
self.size[pa] += self.size[pb]
else:
self.p[pa] = pb
self.size[pb] += self.size[pa]
return True
class Solution:
def findRedundantDirectedConnection(self, edges: List[List[int]]) -> List[int]:
n = len(edges)
ind = [0] * n
for _, v in edges:
ind[v - 1] += 1
dup = [i for i, (_, v) in enumerate(edges) if ind[v - 1] == 2]
uf = UnionFind(n)
if dup:
for i, (u, v) in enumerate(edges):
if i == dup[1]:
continue
if not uf.union(u - 1, v - 1):
return edges[dup[0]]
return edges[dup[1]]
for i, (u, v) in enumerate(edges):
if not uf.union(u - 1, v - 1):
return edges[i]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68 | class UnionFind {
private final int[] p;
private final int[] size;
public UnionFind(int n) {
p = new int[n];
size = new int[n];
for (int i = 0; i < n; ++i) {
p[i] = i;
size[i] = 1;
}
}
public int find(int x) {
if (p[x] != x) {
p[x] = find(p[x]);
}
return p[x];
}
public boolean union(int a, int b) {
int pa = find(a), pb = find(b);
if (pa == pb) {
return false;
}
if (size[pa] > size[pb]) {
p[pb] = pa;
size[pa] += size[pb];
} else {
p[pa] = pb;
size[pb] += size[pa];
}
return true;
}
}
class Solution {
public int[] findRedundantDirectedConnection(int[][] edges) {
int n = edges.length;
int[] ind = new int[n];
for (var e : edges) {
++ind[e[1] - 1];
}
List<Integer> dup = new ArrayList<>();
for (int i = 0; i < n; ++i) {
if (ind[edges[i][1] - 1] == 2) {
dup.add(i);
}
}
UnionFind uf = new UnionFind(n);
if (!dup.isEmpty()) {
for (int i = 0; i < n; ++i) {
if (i == dup.get(1)) {
continue;
}
if (!uf.union(edges[i][0] - 1, edges[i][1] - 1)) {
return edges[dup.get(0)];
}
}
return edges[dup.get(1)];
}
for (int i = 0;; ++i) {
if (!uf.union(edges[i][0] - 1, edges[i][1] - 1)) {
return edges[i];
}
}
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67 | class UnionFind {
public:
UnionFind(int n) {
p = vector<int>(n);
size = vector<int>(n, 1);
iota(p.begin(), p.end(), 0);
}
bool unite(int a, int b) {
int pa = find(a), pb = find(b);
if (pa == pb) {
return false;
}
if (size[pa] > size[pb]) {
p[pb] = pa;
size[pa] += size[pb];
} else {
p[pa] = pb;
size[pb] += size[pa];
}
return true;
}
int find(int x) {
if (p[x] != x) {
p[x] = find(p[x]);
}
return p[x];
}
private:
vector<int> p, size;
};
class Solution {
public:
vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
int n = edges.size();
vector<int> ind(n);
for (const auto& e : edges) {
++ind[e[1] - 1];
}
vector<int> dup;
for (int i = 0; i < n; ++i) {
if (ind[edges[i][1] - 1] == 2) {
dup.push_back(i);
}
}
UnionFind uf(n);
if (!dup.empty()) {
for (int i = 0; i < n; ++i) {
if (i == dup[1]) {
continue;
}
if (!uf.unite(edges[i][0] - 1, edges[i][1] - 1)) {
return edges[dup[0]];
}
}
return edges[dup[1]];
}
for (int i = 0;; ++i) {
if (!uf.unite(edges[i][0] - 1, edges[i][1] - 1)) {
return edges[i];
}
}
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67 | type unionFind struct {
p, size []int
}
func newUnionFind(n int) *unionFind {
p := make([]int, n)
size := make([]int, n)
for i := range p {
p[i] = i
size[i] = 1
}
return &unionFind{p, size}
}
func (uf *unionFind) find(x int) int {
if uf.p[x] != x {
uf.p[x] = uf.find(uf.p[x])
}
return uf.p[x]
}
func (uf *unionFind) union(a, b int) bool {
pa, pb := uf.find(a), uf.find(b)
if pa == pb {
return false
}
if uf.size[pa] > uf.size[pb] {
uf.p[pb] = pa
uf.size[pa] += uf.size[pb]
} else {
uf.p[pa] = pb
uf.size[pb] += uf.size[pa]
}
return true
}
func findRedundantDirectedConnection(edges [][]int) []int {
n := len(edges)
ind := make([]int, n)
for _, e := range edges {
ind[e[1]-1]++
}
dup := []int{}
for i, e := range edges {
if ind[e[1]-1] == 2 {
dup = append(dup, i)
}
}
uf := newUnionFind(n)
if len(dup) > 0 {
for i, e := range edges {
if i == dup[1] {
continue
}
if !uf.union(e[0]-1, e[1]-1) {
return edges[dup[0]]
}
}
return edges[dup[1]]
}
for _, e := range edges {
if !uf.union(e[0]-1, e[1]-1) {
return e
}
}
return nil
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61 | class UnionFind {
p: number[];
size: number[];
constructor(n: number) {
this.p = Array.from({ length: n }, (_, i) => i);
this.size = Array(n).fill(1);
}
find(x: number): number {
if (this.p[x] !== x) {
this.p[x] = this.find(this.p[x]);
}
return this.p[x];
}
union(a: number, b: number): boolean {
const [pa, pb] = [this.find(a), this.find(b)];
if (pa === pb) {
return false;
}
if (this.size[pa] > this.size[pb]) {
this.p[pb] = pa;
this.size[pa] += this.size[pb];
} else {
this.p[pa] = pb;
this.size[pb] += this.size[pa];
}
return true;
}
}
function findRedundantDirectedConnection(edges: number[][]): number[] {
const n = edges.length;
const ind: number[] = Array(n).fill(0);
for (const [_, v] of edges) {
++ind[v - 1];
}
const dup: number[] = [];
for (let i = 0; i < n; ++i) {
if (ind[edges[i][1] - 1] === 2) {
dup.push(i);
}
}
const uf = new UnionFind(n);
if (dup.length) {
for (let i = 0; i < n; ++i) {
if (i === dup[1]) {
continue;
}
if (!uf.union(edges[i][0] - 1, edges[i][1] - 1)) {
return edges[dup[0]];
}
}
return edges[dup[1]];
}
for (let i = 0; ; ++i) {
if (!uf.union(edges[i][0] - 1, edges[i][1] - 1)) {
return edges[i];
}
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64 | class UnionFind {
constructor(n) {
this.p = Array.from({ length: n }, (_, i) => i);
this.size = Array(n).fill(1);
}
find(x) {
if (this.p[x] !== x) {
this.p[x] = this.find(this.p[x]);
}
return this.p[x];
}
union(a, b) {
const pa = this.find(a);
const pb = this.find(b);
if (pa === pb) {
return false;
}
if (this.size[pa] > this.size[pb]) {
this.p[pb] = pa;
this.size[pa] += this.size[pb];
} else {
this.p[pa] = pb;
this.size[pb] += this.size[pa];
}
return true;
}
}
/**
* @param {number[][]} edges
* @return {number[]}
*/
var findRedundantDirectedConnection = function (edges) {
const n = edges.length;
const ind = Array(n).fill(0);
for (const [_, v] of edges) {
++ind[v - 1];
}
const dup = [];
for (let i = 0; i < n; ++i) {
if (ind[edges[i][1] - 1] === 2) {
dup.push(i);
}
}
const uf = new UnionFind(n);
if (dup.length) {
for (let i = 0; i < n; ++i) {
if (i === dup[1]) {
continue;
}
if (!uf.union(edges[i][0] - 1, edges[i][1] - 1)) {
return edges[dup[0]];
}
}
return edges[dup[1]];
}
for (let i = 0; ; ++i) {
if (!uf.union(edges[i][0] - 1, edges[i][1] - 1)) {
return edges[i];
}
}
};
|