文心一言 VS 讯飞星火 VS chatgpt （322）-- 算法导论22.4 3题

三、给出一个算法来判断给定无向图是否包含一个环路。算法运行时间应该在数量级，且与无关。如果要写代码，请用go语言。

文心一言：

要实现一个时间复杂度为 且与 无关的算法来判断无向图是否含有环路，首先需要明确的是，在一般无向图中，这种严格的时间复杂度要求（完全独立于 ）实际上是很难实现的，因为即使是最快的图遍历算法（如深度优先搜索 DFS 或广度优先搜索 BFS）也会受到图中边数的影响。

然而，如果图的表示方式或问题背景有特定限制（例如，图是连通的，或者边数 相对于顶点数 来说非常小，以至于可以忽略不计），我们可以尝试优化搜索过程。但标准的无向图环路检测算法（如基于 DFS 的方法）通常具有

不过，如果我们考虑一个特定的图结构，即并查集（Union-Find）在某些情况下可以用于检测图中的环（尽管这通常用于检测有向图中的环，特别是涉及强连通分量时），但在无向图中，我们可以利用它来检测一个特殊的图——森林（即无环无向图）的有效性。然而，直接检测环并不是并查集的主要用途，且直接应用于无向图环路检测时，其效率并不满足 且与

尽管如此，我们可以提出一个简化的、理想化的解决方案，它并不严格满足 且与

登录后复制

package main

import (
    "fmt"
)

type Graph struct {
    vertices map[int][]int
    visited  map[int]bool
    onStack  map[int]bool
}

func NewGraph() *Graph {
    return &Graph{
        vertices: make(map[int][]int),
        visited:  make(map[int]bool),
        onStack:  make(map[int]bool),
    }
}

func (g *Graph) AddEdge(from, to int) {
    g.vertices[from] = append(g.vertices[from], to)
    // 由于是无向图，所以也要添加反向边
    g.vertices[to] = append(g.vertices[to], from)
}

func (g *Graph) hasCycleUtil(v int, parent int) bool {
    // 标记当前节点为已访问并加入栈
    g.visited[v] = true
    g.onStack[v] = true

    // 递归检查所有邻接点
    for _, neighbour := range g.vertices[v] {
        // 如果邻接点未访问，则递归检查
        if !g.visited[neighbour] {
            if g.hasCycleUtil(neighbour, v) {
                return true
            }
        } else if g.onStack[neighbour] && neighbour != parent {
            // 如果邻接点在栈中，并且不是当前节点的父节点，则存在环
            return true
        }
    }

    // 标记当前节点为不在栈中
    g.onStack[v] = false
    return false
}

func (g *Graph) HasCycle() bool {
    // 遍历所有未访问的顶点
    for v := range g.vertices {
        if !g.visited[v] {
            if g.hasCycleUtil(v, -1) {
                return true
            }
        }
    }
    return false
}

func main() {
    g := NewGraph()
    g.AddEdge(1, 2)
    g.AddEdge(2, 3)
    g.AddEdge(3, 1) // 添加一个环
    g.AddEdge(4, 5)

    fmt.Println("Graph has cycle:", g.HasCycle()) // 输出：true
}

• 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.
• 69.
• 70.

上述代码实现了基于 DFS 的无向图环路检测算法，其时间复杂度为 ，但请注意，这仍然是目前在一般无向图中检测环路的最有效方法之一。对于严格

讯飞星火：

我们可以使用深度优先搜索（DFS）算法来判断一个无向图是否包含环路。在遍历过程中，如果我们遇到一个已经在当前路径中的节点，那么就说明存在环路。以下是Go语言实现的代码：

登录后复制

package main

import "fmt"

type Graph struct {
	V   int
	adj [][]int
}

func NewGraph(V int) *Graph {
	g := &Graph{V: V, adj: make([][]int, V)}
	for i := range g.adj {
		g.adj[i] = make([]int, 0)
	}
	return g
}

func (g *Graph) AddEdge(v, w int) {
	g.adj[v] = append(g.adj[v], w)
	g.adj[w] = append(g.adj[w], v) // 因为是无向图，所以两边都要添加
}

func (g *Graph) isCyclicUtil(v int, visited []bool, parent int) bool {
	visited[v] = true
	for _, i := range g.adj[v] {
		if !visited[i] {
			if g.isCyclicUtil(i, visited, v) {
				return true
			}
		} else if i != parent {
			return true
		}
	}
	return false
}

func (g *Graph) IsCyclic() bool {
	visited := make([]bool, g.V)
	for i := 0; i < g.V; i++ {
		if !visited[i] && g.isCyclicUtil(i, visited, -1) {
			return true
		}
	}
	return false
}

func main() {
	g := NewGraph(5)
	g.AddEdge(0, 1)
	g.AddEdge(1, 2)
	g.AddEdge(2, 3)
	g.AddEdge(3, 4)
	g.AddEdge(4, 0)

	if g.IsCyclic() {
		fmt.Println("图中存在环路")
	} else {
		fmt.Println("图中不存在环路")
	}
}

• 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.

在这个代码中，我们首先定义了一个Graph结构体，用于表示无向图。然后，我们实现了NewGraph函数来创建一个新的图，AddEdge函数用于添加边，以及IsCyclic函数来判断图中是否存在环路。isCyclicUtil是一个辅助函数，用于递归地进行深度优先搜索。最后，在main函数中，我们创建了一个示例图并测试了IsCyclic函数。

360智脑：

要在时间内检测无向图中的环，我们可以使用深度优先搜索（DFS）并记录每个节点的状态。由于我们希望算法的复杂度与边的数量无关，这意味着我们不能直接检查每条边。相反，我们将依赖于DFS遍历过程中发现的节点和它们的状态。

以下是一个Go语言实现的算法：

登录后复制

package main

import "fmt"

type Graph struct {
	vertices int
	edges    [][]int
}

func NewGraph(vertices int) *Graph {
	return &Graph{
		vertices: vertices,
		edges:    make([][]int, vertices),
	}
}

func (g *Graph) AddEdge(u, v int) {
	g.edges[u] = append(g.edges[u], v)
	g.edges[v] = append(g.edges[v], u) // For undirected graph
}

func hasCycle(g *Graph) bool {
	// Initialize visited array with all false values
	visited := make([]bool, g.vertices)

	// Call the recursive helper function to detect cycle in different DFS trees
	for i := 0; i < g.vertices; i++ {
		if !visited[i] && dfs(g, i, -1, visited) {
			return true
		}
	}
	return false
}

func dfs(g *Graph, vertex, parent int, visited []bool) bool {
	visited[vertex] = true

	// Visit all the adjacent vertices
	for _, adjVertex := range g.edges[vertex] {
		// If an adjacent vertex is not visited, then recur for that vertex
		if !visited[adjVertex] {
			if dfs(g, adjVertex, vertex, visited) {
				return true
			}
		} else if adjVertex != parent {
			// If an adjacent vertex is visited and not parent of current vertex, then there is a cycle
			return true
		}
	}
	return false
}

func main() {
	g := NewGraph(5)
	g.AddEdge(1, 0)
	g.AddEdge(0, 2)
	g.AddEdge(2, 1)
	g.AddEdge(0, 3)
	g.AddEdge(3, 4)

	fmt.Println("Graph contains cycle:", hasCycle(g)) // Output: Graph contains cycle: true
}

• 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.

这个算法的时间复杂度是，因为我们遍历了所有的顶点和边。但是，如果我们假设图是稠密的，即，那么可以简化为。然而，如果图是稀疏的，即，那么这个算法的时间复杂度仍然是。

请注意，这个算法的前提是图是连通的，如果不是连通的，我们需要对每个未访问的节点都调用一次DFS。

智谱清言：

为了判断一个无向图是否包含环路，可以使用深度优先搜索（DFS）算法。以下是使用Go语言实现的算法，该算法的运行时间复杂度为，因为它遍历每个顶点一次，而不依赖于边的数量。

登录后复制

package main
import "fmt"
// Graph represents an undirected graph using adjacency list representation
type Graph struct {
	vertices int
	adjList  []*Vertex
}
// Vertex represents a graph vertex
type Vertex struct {
	label int
	visited bool
	adjacent []*Vertex
}
// NewGraph creates a new graph with V vertices
func NewGraph(V int) *Graph {
	g := &Graph{
		vertices: V,
		adjList:  make([]*Vertex, V),
	}
	for i := 0; i < V; i++ {
		g.adjList[i] = &Vertex{
			label:    i,
			visited:  false,
			adjacent: []*Vertex{},
		}
	}
	return g
}
// AddEdge adds an undirected edge between two vertices
func (g *Graph) AddEdge(u, v int) {
	vertexU := g.adjList[u]
	vertexV := g.adjList[v]
	vertexU.adjacent = append(vertexU.adjacent, vertexV)
	vertexV.adjacent = append(vertexV.adjacent, vertexU)
}
// HasCycle checks if the graph has a cycle
func (g *Graph) HasCycle() bool {
	for _, vertex := range g.adjList {
		if !vertex.visited {
			if hasCycleUtil(vertex, nil) {
				return true
			}
		}
	}
	return false
}
// hasCycleUtil is a utility function to detect cycle in a graph
func hasCycleUtil(vertex *Vertex, parent *Vertex) bool {
	vertex.visited = true
	for _, adjacent := range vertex.adjacent {
		// If the adjacent vertex is not visited, then continue to do DFS
		if !adjacent.visited {
			if hasCycleUtil(adjacent, vertex) {
				return true
			}
		} else if adjacent != parent { // If an adjacent vertex is visited and is not parent of current vertex, then there is a cycle
			return true
		}
	}
	return false
}
func main() {
	// Example usage
	g := NewGraph(4)
	g.AddEdge(0, 1)
	g.AddEdge(1, 2)
	g.AddEdge(2, 3)
	g.AddEdge(3, 0) // This edge creates a cycle
	if g.HasCycle() {
		fmt.Println("Graph contains a cycle")
	} else {
		fmt.Println("Graph does not contain a cycle")
	}
}

• 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.
• 69.
• 70.
• 71.
• 72.
• 73.
• 74.

在这个代码中，Graph 结构体表示一个无向图，Vertex 结构体表示图中的一个顶点。HasCycle 方法用于检查图中是否存在环路。它遍历每个顶点，如果顶点未被访问，则调用 hasCycleUtil 方法进行深度优先搜索。hasCycleUtil 方法递归地检查每个顶点的相邻顶点，如果找到一个已经访问过的顶点且不是当前顶点的父节点，那么就存在一个环路。如果所有顶点都被访问过且没有找到环路，那么图中不存在环路。

天工：

在无向图中判断是否存在环的问题，如果要求算法的运行时间在数量级且与无关，这个要求实际上在大多数情况下是无法满足的，因为访问图中的每个节点至少需要的时间，但访问每条边至少一次是判断环路存在的必要条件，这通常需要的时间。对于稠密图，可以达到，但通常我们讨论的是稀疏图，此时更接近于，算法复杂度接近于。

然而，如果图的结构非常特殊（例如树或森林），或者使用了特殊的存储结构（如邻接矩阵，但这通常会导致空间复杂度增加），理论上可以达到接近的复杂度，但这通常不是在一般情况下成立的。

对于一般的无向图，一个常见的方法是使用深度优先搜索（DFS）来检测环路，这种方法的时间复杂度是。下面我将提供一个使用DFS的Go语言示例代码来检测无向图中的环路：

登录后复制

package main

import (
	"fmt"
)

type Graph struct {
	V   int
	adj map[int][]int
}

func NewGraph(V int) *Graph {
	g := &Graph{V: V, adj: make(map[int][]int)}
	return g
}

func (g *Graph) AddEdge(v, w int) {
	g.adj[v] = append(g.adj[v], w)
	g.adj[w] = append(g.adj[w], v) // 无向图，需要添加双向边
}

func (g *Graph) IsCyclic() bool {
	visited := make(map[int]bool)
	recStack := make(map[int]bool)

	for v := 0; v < g.V; v++ {
		if g.isCyclicUtil(v, visited, recStack) {
			return true
		}
	}
	return false
}

func (g *Graph) isCyclicUtil(v int, visited map[int]bool, recStack map[int]bool) bool {
	if _, ok := recStack[v]; ok {
		return true
	}

	if _, ok := visited[v]; !ok {
		visited[v] = true
		recStack[v] = true
		for _, w := range g.adj[v] {
			if g.isCyclicUtil(w, visited, recStack) {
				return true
			}
		}
	}
	recStack[v] = false
	return false
}

func main() {
	g := NewGraph(5)
	g.AddEdge(1, 0)
	g.AddEdge(0, 2)
	g.AddEdge(2, 1)
	g.AddEdge(0, 3)
	g.AddEdge(3, 4)

	if g.IsCyclic() {
		fmt.Println("Graph contains cycle")
	} else {
		fmt.Println("Graph doesn't contain cycle")
	}
}

• 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.

这段代码首先定义了一个无向图结构，然后使用DFS来检测环路。在IsCyclic函数中，我们对图中的每个节点调用isCyclicUtil函数，这个函数会递归地检查每个节点的邻居，同时使用visited和recStack两个map来记录访问状态和递归调用栈，以判断是否存在环。

请注意，这段代码的时间复杂度是，这是在一般无向图上检测环路的常见复杂度。

chatgpt：

可以使用深度优先搜索（DFS）算法来判断无向图是否包含环路。以下是一个使用Go语言实现的示例代码：

登录后复制

package main

import "fmt"

type Graph struct {
    V     int
    Edges map[int][]int
}

func NewGraph(vertices int) *Graph {
    return &Graph{
        V:     vertices,
        Edges: make(map[int][]int),
    }
}

func (g *Graph) AddEdge(u, v int) {
    g.Edges[u] = append(g.Edges[u], v)
    g.Edges[v] = append(g.Edges[v], u)
}

func (g *Graph) hasCycleUtil(v, parent int, visited []bool) bool {
    visited[v] = true

    for _, i := range g.Edges[v] {
        if !visited[i] {
            if g.hasCycleUtil(i, v, visited) {
                return true
            }
        } else if i != parent {
            return true
        }
    }

    return false
}

func (g *Graph) HasCycle() bool {
    visited := make([]bool, g.V)

    for i := 0; i < g.V; i++ {
        if !visited[i] && g.hasCycleUtil(i, -1, visited) {
            return true
        }
    }

    return false
}

func main() {
    // 创建一个包含4个顶点的图，并添加边构成一个环路
    graph := NewGraph(4)
    graph.AddEdge(0, 1)
    graph.AddEdge(1, 2)
    graph.AddEdge(2, 3)
		graph.AddEdge(3, 0)

		// 检查图中是否存在环路
    if graph.HasCycle() {
        fmt.Println("图中存在环路")
    } else {
        fmt.Println("图中不存在环路")
    }
}

• 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.

这段代码使用了深度优先搜索（DFS）来遍历图中的每个节点，并检查是否有已访问过的非父节点。如果有，说明存在一个环路。该算法的时间复杂度为O(V)，与边数无关。

kimi：

要判断一个无向图是否包含一个环路，我们可以使用一种称为DFS（深度优先搜索）的算法。DFS可以在遍历图的过程中检测环路。然而，要实现一个运行时间在 ( O(V) ) 量级的算法，我们需要确保每个顶点只被访问一次，并且不通过任何形式的回溯来检测环路。

这里有一个简单的算法思路：

1. 遍历图中的每个顶点 ( v )。
2. 对于每个未访问的顶点 ( v )，执行DFS。
3. 在DFS过程中，使用一个布尔数组来标记当前路径上的顶点。
4. 如果在DFS过程中遇到一个已经在当前路径上的顶点，则存在环路。
5. 否则，如果DFS完成没有发现环路，该顶点及其所有子节点都标记为已访问。

下面是用Go语言实现的代码示例：

登录后复制

package main

import (
	"fmt"
)

// 定义图的结构
type Graph struct {
	adjacencyList map[int][]int
}

// 创建图
func NewGraph(numVertices int) *Graph {
	return &Graph{
		adjacencyList: make(map[int][]int, numVertices),
	}
}

// 添加边
func (g *Graph) AddEdge(v, w int) {
	g.adjacencyList[v] = append(g.adjacencyList[v], w)
	g.adjacencyList[w] = append(g.adjacencyList[w], v) // 因为是无向图，所以要添加双向边
}

// DFS函数，检测环路
func (g *Graph) hasCycle(v int, visited []bool, path []bool) bool {
	// 标记当前顶点为已访问，并加入到路径中
	visited[v] = true
	path[v] = true

	// 遍历所有邻接顶点
	for _, neighbor := range g.adjacencyList[v] {
		if !visited[neighbor] {
			// 如果邻接顶点未访问，递归调用DFS
			if g.hasCycle(neighbor, visited, path) {
				return true
			}
		} else if path[neighbor] {
			// 如果邻接顶点已在当前路径中，说明存在环路
			return true
		}
	}

	// 移除顶点v从路径中
	path[v] = false
	return false
}

// 检测图中是否有环路
func (g *Graph) HasCycle() bool {
	visited := make([]bool, len(g.adjacencyList))
	path := make([]bool, len(g.adjacencyList))

	for v := range g.adjacencyList {
		if !visited[v] {
			if g.hasCycle(v, visited, path) {
				return true
			}
		}
	}
	return false
}

func main() {
	// 示例：创建一个图并添加边
	g := NewGraph(4)
	g.AddEdge(0, 1)
	g.AddEdge(1, 2)
	g.AddEdge(2, 3)
	g.AddEdge(3, 1) // 这是一个环路

	// 检测环路
	if g.HasCycle() {
		fmt.Println("The graph contains a cycle.")
	} else {
		fmt.Println("The graph does not contain a cycle.")
	}
}

• 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.
• 69.
• 70.
• 71.
• 72.
• 73.
• 74.
• 75.
• 76.
• 77.
• 78.

请注意，这个算法的时间复杂度是 ( O(V + E) )，而不是 ( O(V) )，因为我们需要遍历每个顶点的邻接列表。然而，如果图是稀疏的，即 ( E ) 接近 ( V )，这个算法的性能将会接近 ( O(V) )。如果需要严格达到 ( O(V) ) 的时间复杂度，可能需要更复杂的数据结构或算法，例如使用并查集（Union-Find），但这通常不适用于所有类型的图。

混元：

要判断一个无向图是否包含环路，并且要求算法的时间复杂度在数量级，我们可以使用并查集（Union-Find）数据结构。并查集是一种数据结构，它可以高效地处理一些不相交集合的合并及查询问题。

以下是使用Go语言实现的算法：

登录后复制

package main

import "fmt"

// 并查集数组
var parent []int

// 初始化并查集
func makeSet(v int) {
	parent = make([]int, v)
	for i := range parent {
		parent[i] = i
	}
}

// 查找根节点（代表元素）
func find(x int) int {
	if parent[x] != x {
		parent[x] = find(parent[x]) // 路径压缩
	}
	return parent[x]
}

// 合并两个集合
func union(x, y int) bool {
	rootX := find(x)
	rootY := find(y)
	if rootX == rootY {
		return false // 如果两个节点已经在同一个集合中，说明添加这条边会形成环
	}
	parent[rootX] = rootY // 合并集合
	return true
}

// 判断无向图是否有环
func hasCycle(edges [][]int, V int) bool {
	makeSet(V)
	for _, edge := range edges {
		if !union(edge[0], edge[1]) {
			return true // 如果合并失败，说明添加这条边会形成环
		}
	}
	return false
}

func main() {
	V := 5 // 顶点数
	edges := [][]int{
		{0, 1},
		{1, 2},
		{2, 3},
		{3, 4},
		{4, 0}, // 这条边会形成环
	}
	fmt.Println(hasCycle(edges, V)) // 输出：true
}

• 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.

在这个算法中，我们首先初始化一个并查集，然后遍历所有的边，尝试将边的两个端点进行合并。如果在合并时发现这两个端点已经属于同一个集合，那么说明添加这条边会形成环，因此返回true。如果所有边都尝试过后没有发现环，则返回false。

注意，这个算法的时间复杂度主要取决于并查集的操作，而并查集的查找和合并操作的平均时间复杂度接近，因此整个算法的时间复杂度为，其中是边的数量，是顶点的数量。由于题目要求与无关，我们可以认为在边数不是非常大的情况下，这个算法满足的时间复杂度要求。

原创作者: moonfdd 转载于: https://blog.51cto.com/moonfdd/11786245