力扣1579. 保证图可完全遍历

最新推荐文章于 2025-07-10 15:03:39 发布

原创最新推荐文章于 2025-07-10 15:03:39 发布 · 128 阅读

0 ·

CC 4.0 BY-SA版权

go 专栏收录该内容

35 篇文章

订阅专栏

探讨如何在确保Alice和Bob能完全遍历图的前提下，找出可删除的最大边数。利用并查集算法实现图的遍历检查，并提供具体算法实现及示例。

Alice 和 Bob 共有一个无向图，其中包含 n 个节点和 3 种类型的边：

类型 1：只能由 Alice 遍历。
类型 2：只能由 Bob 遍历。
类型 3：Alice 和 Bob 都可以遍历。
给你一个数组 edges ，其中 edges[i] = [typei, ui, vi] 表示节点 ui 和 vi 之间存在类型为 typei 的双向边。请你在保证图仍能够被 Alice和 Bob 完全遍历的前提下，找出可以删除的最大边数。如果从任何节点开始，Alice 和 Bob 都可以到达所有其他节点，则认为图是可以完全遍历的。

返回可以删除的最大边数，如果 Alice 和 Bob 无法完全遍历图，则返回 -1 。

输入：n = 4, edges = [[3,1,2],[3,2,3],[1,1,3],[1,2,4],[1,1,2],[2,3,4]]
输出：2
解释：如果删除 [1,1,2] 和 [1,1,3] 这两条边，Alice 和 Bob 仍然可以完全遍历这个图。再删除任何其他的边都无法保证图可以完全遍历。所以可以删除的最大边数是 2 。

type unionFind struct {
	parent, size []int
	setCount     int // 当前连通分量数目
}

func newUnionFind(n int) *unionFind {
	parent := make([]int, n)
	size := make([]int, n)
	for i := range parent {
		parent[i] = i
		size[i] = 1
	}
	return &unionFind{parent, size, n}
}

func (uf *unionFind) find(x int) int {
	if uf.parent[x] != x {
		uf.parent[x] = uf.find(uf.parent[x])
	}
	return uf.parent[x]
}

func (uf *unionFind) union(x, y int) bool {
	fx, fy := uf.find(x), uf.find(y)
	if fx == fy {
		return false
	}
	if uf.size[fx] < uf.size[fy] {
		fx, fy = fy, fx
	}
	uf.size[fx] += uf.size[fy]
	uf.parent[fy] = fx
	uf.setCount--
	return true
}

func (uf *unionFind) inSameSet(x, y int) bool {
	return uf.find(x) == uf.find(y)
}

func maxNumEdgesToRemove(n int, edges [][]int) int {
	ans := len(edges) //边的总数
	alice, bob := newUnionFind(n), newUnionFind(n)
	for _, e := range edges {
		x, y := e[1]-1, e[2]-1
		if e[0] == 3 && (!alice.inSameSet(x, y) || !bob.inSameSet(x, y)) { //处理公共边，存在类型为3的边，并且不在alice和bob中
			// 保留这条公共边
			alice.union(x, y)
			bob.union(x, y)
			ans--
		}
	}
	uf := [2]*unionFind{alice, bob}
	for _, e := range edges {
		if tp := e[0]; tp < 3 && uf[tp-1].union(e[1]-1, e[2]-1) {
			// 保留这条独占边
			ans--
		}
	}
	if alice.setCount > 1 || bob.setCount > 1 {
		return -1
	}
	return ans
}

func main() {
	n := 4                                                                             //节点数
	edges := [][]int{{3, 1, 2}, {3, 2, 3}, {1, 1, 3}, {1, 2, 4}, {1, 1, 2}, {2, 3, 4}} //三种类型的边, edges[i] = [typei, ui, vi] 表示节点 ui 和 vi 之间存在类型为 typei 的双向边
	ans := maxNumEdgesToRemove(n, edges)
	fmt.Println(ans)
}