文心一言 VS 讯飞星火 VS chatgpt （319）-- 算法导论22.3 11题

package main

import(
"fmt"
)

typeGraphstruct{
    vertices int
    adjList  map[int][]int
    visited  map[int]bool
}

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

func (g *Graph)AddEdge(from, to int){
    g.adjList[from]=append(g.adjList[from], to)
}

func (g *Graph) DFS(start int){
    g.visited[start]=true
    fmt.Println("Visited:", start)

// 假设这里是检查“唯一结点”逻辑的地方
// 但在这个示例中，我们仅打印访问的结点

for _, neighbor :=range g.adjList[start]{
if!g.visited[neighbor]{
            g.DFS(neighbor)
}
}
}

func main(){
    g :=NewGraph(4)
    g.AddEdge(0,1)
    g.AddEdge(1,2)
    g.AddEdge(2,0)// 形成一个环
    g.AddEdge(3,3)// 自环，可能表示某种特殊情况

// 假设从结点2开始DFS，并且假设在某种条件下，
// 当DFS到达结点3时，它成为“唯一”结点（尽管这在实际中不常见）
    g.DFS(2)// 输出将显示DFS的遍历顺序

// 注意：这里的“唯一结点”是假设性的，实际中需要具体条件来定义
}

package main

import"fmt"

typeGraphstruct{
    vertices int
    adjList  [][]int
}

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

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

func (g *Graph)DFSUtil(v, visited int){
    visited =1
    fmt.Printf("%d ", v)

for _, i :=range g.adjList[v]{
if visited ==0{
            g.DFSUtil(i, visited)
}
}
}

func (g *Graph) DFS(v int){
    visited :=make([]int, g.vertices)
    g.DFSUtil(v, visited)
}

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

    fmt.Println("Depth First Traversal (starting from vertex 2):")
    g.DFS(2)
}

package main

import"fmt"

// 定义图的结点
typeNodestruct{
    id       int
    adjacent []*Node
}

// 深度优先搜索函数
func DFS(node *Node, visited map[*Node]bool){
    visited[node]=true
    fmt.Println("Visited node:", node.id)

// 遍历相邻结点
for _, adj :=range node.adjacent {
if!visited[adj]{
            DFS(adj, visited)
}
}
}

func main(){
// 创建一个只有一个结点的图
    nodeU :=&Node{id:1}

// 创建一个空的访问记录
    visited :=make(map[*Node]bool)

// 执行深度优先搜索
    DFS(nodeU, visited)
}

package main
import"fmt"
// Graph represents an adjacency list graph
typeGraphstruct{
    vertices map[int][]int
}
// NewGraph initializes a new graph
func NewGraph()*Graph{
return&Graph{
        vertices:make(map[int][]int),
}
}
// AddEdge adds an edge to the graph
func (g *Graph)AddEdge(from, to int){
    g.vertices[from]=append(g.vertices[from], to)
}
// DFS performs a depth-first search on the graph
func (g *Graph) DFS(v int, visited map[int]bool){
    visited[v]=true
    fmt.Println("Visited:", v)
for _, u :=range g.vertices[v]{
if!visited[u]{
            g.DFS(u, visited)
}
}
}
func main(){
    g :=NewGraph()
// Example graph with edges
    g.AddEdge(1,2)
    g.AddEdge(2,3)
    g.AddEdge(3,4)
    g.AddEdge(4,1)// This edge makes node 1 have an incoming edge
    visited :=make(map[int]bool)
// Start DFS from node 1, assuming it's the node we want to be unique
    g.DFS(1, visited)
}

package main

import(
"fmt"
)

// Graph is a simple representation of a directed graph using adjacency list.
typeGraphstruct{
    adjList map[int][]int
}

// NewGraph creates a new directed graph.
func NewGraph()*Graph{
return&Graph{adjList:make(map[int][]int)}
}

// AddEdge adds a directed edge from src to dest.
func (g *Graph)AddEdge(src, dest int){
    g.adjList[src]=append(g.adjList[src], dest)
}

// DFS performs a depth-first search from the given start vertex.
func (g *Graph) DFS(start int){
    visited :=make(map[int]bool)
var dfsUtil func(int)
    dfsUtil =func(vertex int){
        visited[vertex]=true
        fmt.Printf("Visited %d\n", vertex)
for _, adjVertex :=range g.adjList[vertex]{
if!visited[adjVertex]{
                dfsUtil(adjVertex)
}
}
}
    dfsUtil(start)
}

func main(){
    g :=NewGraph()
// Add edges to create a directed graph.
    g.AddEdge(1,2)
    g.AddEdge(2,3)
    g.AddEdge(3,1)
    g.AddEdge(4,1)
    g.AddEdge(5,4)

// Perform DFS from vertex 1, making it the root of the DFS tree.
    g.DFS(1)
}

package main

import"fmt"

// 定义有向图结构
typeDirectedGraphstruct{
    nodes     []string// 所有节点列表
    adjacency map[string][]string// 邻接表表示的边关系
}

// 添加边
func (g *DirectedGraph) addEdge(u, v string){
    g.adjacency[u]=append(g.adjacency[u], v)
}

// 深度优先搜索遍历
func DFS(graph *DirectedGraph, start string, visited map[string]bool){
    visited[start]=true// 标记当前节点已经访问过
    fmt.Println(start)

for _, neighbor :=range graph.adjacency[start]{
if!visited[neighbor]{
            DFS(graph, neighbor, visited)
}
}
}

func main(){
    graph :=&DirectedGraph{
        nodes:[]string{"A","B","C","D"},
        adjacency:make(map[string][]string),
}
    graph.addEdge("A","B")
    graph.addEdge("B","C")
    graph.addEdge("C","A")// 节点 A 同时有入边和出边

    visited :=make(map[string]bool)
    DFS(graph,"A", visited)
}

package main

import(
"fmt"
)

// 定义图的结构，使用邻接表表示
typeGraphstruct{
    adjacencyList map[int][]int
}

// 构造函数，初始化图
func NewGraph()*Graph{
return&Graph{
        adjacencyList:make(map[int][]int),
}
}

// 添加有向边
func (g *Graph)AddEdge(from, to int){
    g.adjacencyList[from]=append(g.adjacencyList[from], to)
}

// 深度优先搜索
func (g *Graph) DFS(start int, visited map[int]bool){
// 标记起始点为已访问
    visited[start]=true

// 访问所有邻接节点
for _, neighbor :=range g.adjacencyList[start]{
if!visited[neighbor]{
            g.DFS(neighbor, visited)
}
}
}

func main(){
// 创建图
    graph :=NewGraph()

// 添加边，构建图
    graph.AddEdge(0,1)
    graph.AddEdge(0,2)
    graph.AddEdge(1,3)
    graph.AddEdge(1,4)
    graph.AddEdge(2,5)

// 调用DFS遍历图
    visited :=make(map[int]bool)
    graph.DFS(0, visited)// 假设0是起始点

// 打印访问过的节点
for node, visited :=range visited {
if visited {
            fmt.Printf("Node %d is visited\n", node)
}
}
}

package main

import"fmt"

typeGraphstruct{
Nodesmap[int][]int// 使用map存储图，键为结点，值为相邻结点的切片
}

func (g *Graph) addEdge(from, to int){
if _, ok := g.Nodes[from];!ok {
        g.Nodes[from]=[]int{}
}
    g.Nodes[from]=append(g.Nodes[from], to)
}

func dfs(g *Graph, node int, visited map[int]bool){
    visited[node]=true
    fmt.Printf("访问结点: %d\n", node)
for _, neighbor :=range g.Nodes[node]{
if!visited[neighbor]{
            dfs(g, neighbor, visited)
}
}
}

func main(){
    g :=Graph{Nodes:make(map[int][]int)}
// 假设图的结构如下：
// 0 -> 1 -> 2
// |       |
// V       V
// 3 -/ 4 - 5
//      |
//      V
//      6
    g.addEdge(0,1)
    g.addEdge(1,2)
    g.addEdge(0,3)
    g.addEdge(3,4)
    g.addEdge(4,5)
    g.addEdge(4,6)

// 使用DFS遍历图
    visited :=make(map[int]bool)
    dfs(&g,0, visited)
}