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

最新推荐文章于 2024-11-14 21:21:03 发布
最新推荐文章于 2024-11-14 21:21:03 发布
阅读量3.5k 收藏 11
点赞数 39
分类专栏： 文心一言vschatgpt 文章标签： 算法 chatgpt 文心一言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48502062/article/details/140301065
版权

三、有向图 G = ( V , E ) G=(V,E) G=(V,E) 的转置是图 G T = ( V , E T ) G^{T} =(V,E^{T}) GT=(V,ET)，这里 E T = { ( v , u ) ∈ V × V E^{T} =\{(v,u)∈ V \times V ET={(v,u)∈V×V:(u,v)∈ E}$因此，图 G T G^{T} GT 就是将有向图 G G G中所有边的方向反过来而形成的图。对于邻接链表和邻接矩阵两种表示，请给出从图 G G G计算出 G T G^{T} GT的有效算法，并分析算法的运行时间。如果要写代码，请用go语言。

文心一言：

为了从有向图 G G G 计算出其转置图 G T G^T GT，我们可以分别针对邻接链表和邻接矩阵两种表示形式来设计算法。下面我将分别给出这两种方法的描述以及相应的 Go 语言代码实现。

1. 邻接链表表示

在邻接链表中，每个节点维护一个链表，链表中的每个节点表示从当前节点出发可以到达的节点。为了得到转置图，我们需要遍历原图的所有边，并将每条边的方向反转，即对于边 ( u , v ) (u, v) (u,v)，我们在 G T G^T GT 中添加边 ( v , u ) (v, u) (v,u)。

算法步骤：

  1. 初始化 G T G^T GT 的邻接链表表示。
  2. 遍历 G G G 的每一条边 ( u , v ) (u, v) (u,v)。
  3. 在 G T G^T GT 中，将 v v v 添加到 u u u 的链表中（如果 u u u 的链表不存在，则先创建）。

Go 代码实现：

package main

import "fmt"

type Graph struct {
    adjList map[int][]int
}

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

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

func (g *Graph) Transpose() *Graph {
    transposed := NewGraph()
    for from, tos := range g.adjList {
        for _, to := range tos {
            transposed.AddEdge(to, from)
        }
    }
    return transposed
}

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

    gt := g.Transpose()
    fmt.Println("Transposed Graph:")
    for from, tos := range gt.adjList {
        fmt.Printf("%d -> %v\n", from, tos)
    }
}

时间复杂度： O ( V + E ) O(V+E) O(V+E)，其中 V V V 是节点数， E E E 是边数。因为我们需要遍历每条边并可能更新每个节点的链表。

2. 邻接矩阵表示

在邻接矩阵中，矩阵的每个元素 A [ i ] [ j ] A[i][j] A[i][j] 表示从节点 i i i 到节点 j j j 是否存在边。为了得到转置图，我们只需将矩阵转置即可。

算法步骤：

  1. 初始化 G T G^T GT 的邻接矩阵，大小与 G G G 相同。
  2. 遍历 G G G 的邻接矩阵的每一个元素 A [ i ] [ j ] A[i][j] A[i][j]。
  3. 如果 A [ i ] [ j ] A[i][j] A[i][j] 非零（或根据图的类型，可能有其他表示方式），则将 G T G^T GT 的邻接矩阵中 A T [ j ] [ i ] A^T[j][i] AT[j][i] 设置为相同的值。

Go 代码实现：

package main

import "fmt"

type MatrixGraph struct {
    matrix [][]int
    size   int
}

func NewMatrixGraph(size int) *MatrixGraph {
    return &MatrixGraph{matrix: make([][]int, size), size: size}
}

func (mg *MatrixGraph) AddEdge(from, to int) {
    mg.matrix[from][to] = 1
}

func (mg *MatrixGraph) Transpose() *MatrixGraph {
    transposed := NewMatrixGraph(mg.size)
    for i := 0; i < mg.size; i++ {
        for j := 0; j < mg.size; j++ {
            transposed.matrix[j][i] = mg.matrix[i][j]
        }
    }
    return transposed
}

func main() {
    mg := NewMatrixGraph(3)
    mg.AddEdge(0, 1)
    mg.AddEdge(0, 2)
    mg.AddEdge(1, 2)
    mg.AddEdge(2, 0)

    mgt := mg.Transpose()
    fmt.Println("Transposed Matrix Graph:")
    for _, row := range mgt.matrix {
        fmt.Println(row)
    }
}

**

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火：

首先，我们来分析邻接链表和邻接矩阵两种表示方法。

  1. 邻接链表表示法：
    在邻接链表中，每个顶点都有一个链表，链表中的每个元素表示与该顶点相邻的顶点。为了计算转置图 G T G^T GT，我们需要遍历原图 G G G的所有顶点，然后遍历每个顶点的链表，将链表中的顶点添加到新链表中，表示转置后的边。

  2. 邻接矩阵表示法：
    在邻接矩阵中，矩阵的每个元素表示两个顶点之间是否存在边。为了计算转置图 G T G^T GT，我们需要将原矩阵进行转置操作，即将矩阵的行和列互换。

接下来，我们给出两种表示法的算法实现：

  1. 邻接链表表示法：
func transposeGraph(graph []map[int]struct{}) map[int]map[int]struct{} {
    transposedGraph := make(map[int]map[int]struct{})
    for u, neighbors := range graph {
        transposedNeighbors := make(map[int]struct{})
        for v := range neighbors {
            transposedNeighbors[v] = struct{}{}
        }
        transposedGraph[u] = transposedNeighbors
    }
    return transposedGraph
}
  1. 邻接矩阵表示法：
func transposeMatrix(matrix [][]bool) [][]bool {
    rows := len(matrix)
    cols := len(matrix[0])
    transposedMatrix := make([][]bool, cols)
    for i := range transposedMatrix {
        transposedMatrix[i] = make([]bool, rows)
        for j := range transposedMatrix[i] {
            transposedMatrix[i][j] = matrix[j][i]
        }
    }
    return transposedMatrix
}

运行时间分析：

  1. 邻接链表表示法的时间复杂度为O(E)，其中E为原图中的边数。因为我们需要遍历所有顶点的链表。
  2. 邻接矩阵表示法的时间复杂度为O(V^2)，其中V为原图中的顶点数。因为我们需要遍历整个矩阵并进行转置操作。

360智脑：

邻接链表表示法

在邻接链表表示法中，我们可以直接遍历原图 G G G的每个节点的邻接链表，然后将每条边的方向反转后添加到新图 G T G^{T} GT的对应节点上。以下是用Go语言实现的代码：

type Graph struct {
    Vertices []*Node
}

type Node struct {
    Value int
    Adjacent []*Node
}

func (g *Graph) Transpose() *Graph {
    transposed := &Graph{make([]*Node, len(g.Vertices))}
    for i, node := range g.Vertices {
        transposed.Vertices[i] = &Node{node.Value, make([]*Node, 0)}
    }
    for _, node := range g.Vertices {
        for _, neighbor := range node.Adjacent {
            // Add edge from neighbor to current node in the transposed graph
            transposed.Vertices[neighbor.Value].Adjacent = append(transposed.Vertices[neighbor.Value].Adjacent, node)
        }
    }
    return transposed
}

该算法的运行时间是 O ( ∣ V ∣ + ∣ E ∣ ) O(|V| + |E|) O(∣V∣+∣E∣)，其中 ∣ V ∣ |V| ∣V∣是图中顶点的数量， ∣ E ∣ |E| ∣E∣是图中边的数量。这是因为我们需要遍历每个节点和每条边一次。

邻接矩阵表示法

在邻接矩阵表示法中，我们可以通过交换矩阵的行和列来得到转置图。以下是用Go语言实现的代码：

type MatrixGraph struct {
    Matrix [][]bool
}

func (m *MatrixGraph) Transpose() *MatrixGraph {
    n := len(m.Matrix)
    transposed := make([][]bool, n)
    for i := range transposed {
        transposed[i] = make([]bool, n)
    }
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            transposed[j][i] = m.Matrix[i][j]
        }
    }
    return &MatrixGraph{transposed}
}

该算法的运行时间是 O ( ∣ V ∣ 2 ) O(|V|^2) O(∣V∣2)，因为在最坏的情况下，我们需要访问矩阵中的每个元素。如果图是稠密的（即 ∣ E ∣ ≈ ∣ V ∣ 2 |E| \approx |V|^2 ∣E∣≈∣V∣2），那么这个算法的时间复杂度与邻接链表表示法的算法相当。但如果图是稀疏的（即 ∣ E ∣ < < ∣ V ∣ 2 |E| << |V|^2 ∣E∣<<∣V∣2），那么邻接链表表示法的算法会更高效。

智谱清言：

在图的邻接链表表示中，每个顶点对应一个链表，链表中包含所有与该顶点相邻的顶点的信息。在邻接矩阵表示中，矩阵的行和列代表图的顶点，矩阵中的元素表示相应顶点之间的边。转置图意味着我们需要交换原图中边的方向。
下面分别给出使用邻接链表和邻接矩阵表示的有向图转置的算法，并使用Go语言实现。

邻接链表表示

算法：

  1. 创建一个新的顶点列表，复制原图的顶点。
  2. 遍历原图的每个顶点。
  3. 对于每个顶点，遍历它的邻接表。
  4. 对于邻接表中的每条边 (u, v)，在转置图中添加边 (v, u)。
    运行时间：O(V + 2E)，其中 V 是顶点数，E 是边数。遍历所有顶点一次，每个顶点处理它的邻接表，每条边被处理两次（一次在原图中，一次在转置图中）。
    Go 代码实现：
package main
import (
	"fmt"
)
type Edge struct {
	To int
}
type Graph struct {
	Vertices []int
	Edges    []*Edge
}
func (g *Graph) AddEdge(from, to int) {
	g.Edges = append(g.Edges, &Edge{To: to})
}
func TransposeGraph(g *Graph) *Graph {
	transposed := &Graph{Vertices: make([]int, len(g.Vertices))}
	for _, v := range g.Vertices {
		transposed.AddEdge(v, g.Vertices...)
	}
	return transposed
}
func main() {
	g := &Graph{
		Vertices: []int{0, 1, 2, 3},
		Edges:    []*Edge{},
	}
	g.AddEdge(0, 1)
	g.AddEdge(0, 2)
	g.AddEdge(1, 2)
	g.AddEdge(2, 3)
	transposed := TransposeGraph(g)
	fmt.Println("Transposed Graph Edges:")
	for _, edge := range transposed.Edges {
		fmt.Printf("(%d, %d)\n", edge.To, edge.From)
	}
}

邻接矩阵表示

算法：

  1. 创建一个新的顶点列表，复制原图的顶点。
  2. 遍历原图的邻接矩阵。
  3. 对于矩阵中的每个元素，如果 A[u][v] 为 1（表示存在从 u 到 v 的边），在转置图中设置 A[v][u] 为 1。
    运行时间：O(V^2)，其中 V 是顶点数。遍历整个邻接矩阵。
    Go 代码实现：
package main
import (
	"fmt"
)
func TransposeGraph(A [][]int) [][]int {
	V := len(A)
	transposed := make([][]int, V)
	for i := range transposed {
		transposed[i] = make([]int, V)
	}
	for i := 0; i < V; i++ {
		for j := 0; j < V; j++ {
			if A[i][j] == 1 {
				transposed[j][i] = 1
			}
		}
	}
	return transposed
}
func main() {
	A := [][]int{
		{0, 1, 1},
		{1, 0, 1},
		{1, 1, 0},
	}
	transposed := TransposeGraph(A)
	fmt.Println("Transposed Graph:")
	for _, row := range transposed {
		fmt.Println(row)
	}
}

上述代码展示了如何使用 Go 语言实现有向图的转置，

天工：

为了计算有向图 G G G 的转置 G T G^{T} GT，我们可以分别针对邻接链表和邻接矩阵两种表示方式设计算法。

邻接链表表示

算法描述
  1. 遍历图 G G G 的邻接链表。
  2. 对于每条边 ( u , v ) (u, v) (u,v)，将其添加到 G T G^{T} GT 的邻接链表中，但方向相反，即作为顶点 v v v 的邻接边。
  3. 重复步骤2直到所有边都被处理。
运行时间分析

假设图 G G G 有 n n n 个顶点和 m m m 条边，那么这个算法的时间复杂度是 O ( n + m ) O(n + m) O(n+m)，因为我们需要遍历所有的边一次。空间复杂度也是 O ( n + m ) O(n + m) O(n+m)，因为我们创建了一个新的邻接链表来存储转置图。

Go语言实现
type Graph struct {
	vertices []*Vertex
}

type Vertex struct {
	id       int
	adjacent []*Vertex
}

func transposeGraph(g *Graph) *Graph {
	t := &Graph{make([]*Vertex, len(g.vertices))}
	for i, v := range g.vertices {
		t.vertices[i] = &Vertex{id: v.id}
	}
	for _, v := range g.vertices {
		for _, neighbor := range v.adjacent {
			t.vertices[neighbor.id].adjacent = append(t.vertices[neighbor.id].adjacent, t.vertices[v.id])
		}
	}
	return t
}

邻接矩阵表示

算法描述
  1. 遍历图 G G G 的邻接矩阵。
  2. 对于每个元素 ( i , j ) (i, j) (i,j)，如果 G [ i ] [ j ] G[i][j] G[i][j] 为真（表示有一条从 i i i 到 j j j 的边），则在 G T G^{T} GT 的邻接矩阵中设置 G T [ j ] [ i ] G^{T}[j][i] GT[j][i] 为真。
  3. 重复步骤2直到所有元素都被处理。
运行时间分析

这个算法的时间复杂度是 O ( n 2 ) O(n^2) O(n2)，其中 n n n 是顶点的数量，因为我们需要遍历整个邻接矩阵。空间复杂度也是 O ( n 2 ) O(n^2) O(n2)，因为我们创建了一个新的邻接矩阵来存储转置图。

Go语言实现
type MatrixGraph struct {
	matrix [][]bool
}

func transposeMatrixGraph(g *MatrixGraph) *MatrixGraph {
	n := len(g.matrix)
	t := &MatrixGraph{make([][]bool, n)}
	for i := range t.matrix {
		t.matrix[i] = make([]bool, n)
	}
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if g.matrix[i][j] {
				t.matrix[j][i] = true
			}
		}
	}
	return t
}

在这两个实现中，我们都创建了一个新的图或矩阵来存储转置图的结果。如果我们不想使用额外的空间，我们可以考虑在原始图或矩阵上直接修改，但这可能会影响到原始数据的完整性。

灵小智：

对于邻接链表表示的有向图 G = ( V , E ) G=(V,E) G=(V,E)，可以按照以下步骤计算出转置图 G T = ( V , E T ) G^T=(V,E^T) GT=(V,ET)的邻接链表表示：

  1. 初始化一个新的空邻接链表表示的转置图 G T G^T GT。

  2. 对于有向图 G G G中的每个顶点 v ∈ V v\in V v∈V，遍历其邻接点列表中的每个邻接点 u u u。

  3. 对于每个邻接点 u u u，将边 ( u , v ) (u,v) (u,v)添加到 G T G^T GT的邻接链表中，即将 u u u加入到 v v v的邻接点列表中。

下面是用Go语言实现上述算法的代码示例：

package main

import "fmt"

// 定义有向图的顶点结构
type Vertex struct {
    value int
    next *Vertex
}

// 定义有向图的邻接链表结构
type Graph struct {
    V int
    Adj []*Vertex
}

// 函数实现有向图的转置操作
func transposeGraph(g *Graph) *Graph {
    transposed := &Graph{V: g.V, Adj: make([]*Vertex, g.V)}

    for u := 0; u < g.V; u++ {
        for v := g.Adj[u]; v != nil; v = v.next {
            transposed.Adj[v.value] = &Vertex{value: u, next: transposed.Adj[v.value]}
        }
    }

    return transposed
}

func main() {
    // 举例一个有向图的邻接链表表示
    V := 4
    adj := make([]*Vertex, V)
    adj[0] = &Vertex{value: 1, next: &Vertex{value: 2, next: nil}}
    adj[1] = &Vertex{value: 2, next: nil}
    adj[2] = &Vertex{value: 0, next: &Vertex{value: 3, next: nil}}
    adj[3] = nil

    g := &Graph{V: V, Adj: adj}

    // 计算有向图的转置图
    transposed := transposeGraph(g)

    // 输出转置图的邻接链表表示
    for i := 0; i < transposed.V; i++ {
        fmt.Printf("顶点 %d 的邻接点: ", i)
        for v := transposed.Adj[i]; v != nil; v = v.next {
            fmt.Printf("%d ", v.value)
        }
        fmt.Println()
    }
}

该算法的运行时间为 O ( V + E ) O(V+E) O(V+E)，其中 V V V为顶点数， E E E为边数。

chatgpt：

以下是使用邻接链表表示的图 G G G计算出 G T G^{T} GT的有效算法，并给出了相应的Go语言代码示例。

算法步骤：

  1. 创建一个空的图 G T G^{T} GT
  2. 遍历原图 G G G中的每个顶点 v v v，对于每个顶点 v v v，执行以下操作：
    • 如果 v v v在邻接链表中不存在，则将其加入邻接链表中
    • 遍历与顶点 v v v相关联的边 ( v , u ) (v, u) (v,u)，其中 u u u为目标顶点。对于每条边 ( v , u ) (v, u) (v,u)，将其反向添加到对应的邻接链表中：即将边 ( u , v ) (u, v) (u,v)添加到图 G T G^{T} GT的邻接链表中

代码示例（Go语言）：

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

type Graph struct {
    vertices []*Node
}

func NewGraph() *Graph {
    return &Graph{}
}

func (g *Graph) addEdge(src, dest int) {
    newNode := &Node{value: dest, next: nil}
    if g.vertices[src] == nil {
        g.vertices[src] = newNode
    } else {
        curr := g.vertices[src]
        for curr.next != nil {
            curr = curr.next
        }
        curr.next = newNode
    }
}

func (g *Graph) transpose() *Graph {
    transposedGraph := NewGraph()
  
    for i := range g.vertices {
        transposedGraph.vertices = append(transposedGraph.vertices, nil)
    }

    for i := range g.vertices {
        curr := g.vertices[i]
        for curr != nil {
            transposedGraph.addEdge(curr.value, i)
            curr = curr.next
        }
    }
  
    return transposedGraph
}

func main() {
    graph := NewGraph()
    verticesCount := 5
  
    for i := 0; i < verticesCount; i++ {
        graph.vertices = append(graph.vertices, nil)
    }

    // 添加边
    graph.addEdge(0, 1)
    graph.addEdge(0, 2)
    graph.addEdge(1, 3)
    graph.addEdge(2, 3)
    graph.addEdge(3, 4)

    fmt.Println("原图 G:")
    
	  for i, vertex := range graph.vertices {
        curr := vertex
        for curr != nil {
            fmt.Printf("%d -> %d\n", i, curr.value)
            curr = curr.next
        }
	  }

	  transposedGraph := graph.transpose()

	  fmt.Println("\n转置图 G^T:")

	  for i, vertex := range transposedGraph.vertices {
		    curr := vertex
		    for curr != nil {
			      fmt.Printf("%d -> %d\n", i, curr.value)
			      curr = curr.next
		    }
	  }
}

该算法的运行时间取决于顶点数和边数。假设有 n n n个顶点和 m m m条边，则构建邻接链表的时间复杂度为 O ( m ) O(m) O(m)，转置操作需要遍历整个邻接链表，时间复杂度为 O ( n + m ) O(n+m) O(n+m)。因此，总体运行时间复杂度为 O ( n + m ) O(n+m) O(n+m)。

注意：这只是一种实现方式，具体的算法细节和实现可能因应用场景和数据结构的不同而有所调整。

kimi：

首先，我们来分析两种图的表示方法：邻接链表和邻接矩阵，以及如何从图 ( G ) 计算出其转置图 ( G^T )。

邻接链表表示

邻接链表通常使用一个数组来表示，数组的每个元素是一个链表，链表中的每个节点代表一个邻接点和边的权重（如果有的话）。对于有向图 ( G )，如果 ( u ) 到 ( v ) 有一条边，那么在 ( u ) 的链表中会有一个指向 ( v ) 的节点。

算法步骤：

  1. 初始化一个新的邻接链表，其大小与 ( G ) 相同。
  2. 遍历原始图 ( G ) 的每个顶点 ( u )。
  3. 对于 ( u ) 的每个邻接点 ( v )，将 ( v ) 添加到 ( G^T ) 中 ( u ) 的链表中。
  4. 完成所有顶点的遍历后，( G^T ) 的邻接链表就构建好了。

时间复杂度：

  • 假设 ( G ) 有 ( n ) 个顶点和 ( m ) 条边。
  • 每个顶点的邻接链表遍历时间复杂度为 ( O(\text{deg}(u)) )，其中 ( \text{deg}(u) ) 是顶点 ( u ) 的度。
  • 总的时间复杂度为 ( O(m) )，因为每个边只被访问一次。

邻接矩阵表示

邻接矩阵是一个 ( n \times n ) 的矩阵，其中 ( n ) 是顶点的数量。如果 ( G ) 中 ( u ) 到 ( v ) 有边，则矩阵中的 ( G[u][v] ) 为 1（或边的权重），否则为 0。

算法步骤：

  1. 初始化一个与 ( G ) 同样大小的矩阵 ( G^T )，并将所有元素设置为 0。
  2. 遍历 ( G ) 的邻接矩阵，对于每个非零元素 ( G[u][v] )：
    • 将 ( G^T[v][u] ) 设置为 ( G[u][v] )。
  3. 完成所有元素的遍历后，( G^T ) 的邻接矩阵就构建好了。

时间复杂度：

  • 由于矩阵是 ( n \times n )，总的时间复杂度是 ( O(n^2) )。

Go 语言实现

以下是使用 Go 语言实现的邻接链表和邻接矩阵转置的示例代码：

package main

import "fmt"

// 邻接链表的节点
type AdjListNode struct {
    vertex int
    next   *AdjListNode
}

// 邻接链表的图
type GraphAdjList struct {
    adjList []*AdjListNode
    V       int // 顶点的数量
}

// 添加边
func (g *GraphAdjList) addEdge(v, w int) {
    newEdge := &AdjListNode{vertex: w, next: g.adjList[v]}
    g.adjList[v] = newEdge
}

// 计算转置图的邻接链表
func (g *GraphAdjList) transpose() *GraphAdjList {
    gT := &GraphAdjList{V: g.V, adjList: make([]*AdjListNode, g.V)}
    for v := 0; v < g.V; v++ {
        for adj := g.adjList[v]; adj != nil; adj = adj.next {
            gT.addEdge(adj.vertex, v)
        }
    }
    return gT
}

// 邻接矩阵的图
type GraphAdjMatrix struct {
    matrix [][]int
    V      int // 顶点的数量
}

// 计算转置图的邻接矩阵
func (g *GraphAdjMatrix) transpose() *GraphAdjMatrix {
    gT := &GraphAdjMatrix{V: g.V, matrix: make([][]int, g.V)}
    for i := 0; i < g.V; i++ {
        gT.matrix[i] = make([]int, g.V)
        for j := 0; j < g.V; j++ {
            gT.matrix[i][j] = g.matrix[j][i]
        }
    }
    return gT
}

func main() {
    // 示例：使用邻接链表和邻接矩阵构建图并计算其转置
    // 这里省略了图的构建过程，直接展示转置操作
    // ...
}

请注意，上述代码只是一个简单的示例，实际应用中可能需要更多的功能，例如图的构建、边的权重处理等。

混元：

为了计算有向图 G = ( V , E ) G=(V,E) G=(V,E) 的转置 G T = ( V , E T ) G^T=(V,E^T) GT=(V,ET)，我们可以分别针对邻接链表和邻接矩阵两种表示方法给出相应的算法，并分析它们的运行时间。

邻接链表表示法

算法描述
  1. 初始化一个空的邻接链表来存储转置图的边。
  2. 遍历原图 G G G 的每个节点 u u u。
  3. 对于节点 u u u 的每个邻接节点 v v v，在转置图中添加一条从 v v v 到 u u u 的边。
  4. 返回转置图的邻接链表表示。
Go 语言实现
type AdjacencyList struct {
    V int
    Adj [][]int
}

func TransposeAdjacencyList(graph AdjacencyList) AdjacencyList {
    V := graph.V
    transposed := make([][]int, V)
    
    for u := 0; u < V; u++ {
        for _, v := range graph.Adj[u] {
            transposed[v] = append(transposed[v], u)
        }
    }
    
    return AdjacencyList{V: V, Adj: transposed}
}
运行时间分析
  • 时间复杂度： O ( ∣ E ∣ ) O(|E|) O(∣E∣)，其中 ∣ E ∣ |E| ∣E∣ 是原图的边数。因为我们需要遍历每条边来构建转置图。

邻接矩阵表示法

算法描述
  1. 初始化一个与原图 G G G 大小相同的邻接矩阵来存储转置图的边。
  2. 遍历原图 G G G 的每个节点对 ( u , v ) (u, v) (u,v)。
  3. 如果 ( u , v ) (u, v) (u,v) 在原图中存在边，则在转置图的邻接矩阵中将 ( v , u ) (v, u) (v,u) 的对应位置设为边的权重（通常为1）。
  4. 返回转置图的邻接矩阵表示。
Go 语言实现
type AdjacencyMatrix struct {
    V int
    Mat [][]int
}

func TransposeAdjacencyMatrix(graph AdjacencyMatrix) AdjacencyMatrix {
    V := graph.V
    transposed := make([][]int, V)
    for i := range transposed {
        transposed[i] = make([]int, V)
    }
    
    for u := 0; u < V; u++ {
        for v := 0; v < V; v++ {
            if graph.Mat[u][v] != 0 {
                transposed[v][u] = graph.Mat[u][v]
            }
        }
    }
    
    return AdjacencyMatrix{V: V, Mat: transposed}
}
运行时间分析
  • 时间复杂度： O ( ∣ V ∣ 2 ) O(|V|^2) O(∣V∣2)，其中 ∣ V ∣ |V| ∣V∣ 是原图的节点数。因为我们需要遍历矩阵中的每个元素来构建转置图。

在实际应用中，如果图的边数远小于节点数的平方，那么使用邻接链表表示法会更高效；反之，如果图的边数接近或超过节点数的平方，邻接矩阵表示法可能更合适。

福大大架构师每日一题
关注
专栏目录
各家LLM大模型写作能力大比拼【GPT4、ChatGPT、ChatGLM-6B、ChatGLM-130B、文心一言、讯飞星火、Claude+】《人工智能之神经网络的前世今生和未来发展趋势》为标题
AI天才研究院
06-10 1万+
神经网络是一种类比于人类神经系统的计算模型，由多个神经元按照特定的结构和连接方式组成。神经网络的核心思想是通过模拟人类神经系统的学习和适应能力，从而实现对复杂问题的预测和处理。在神经网络中，通常会使用激活函数来计算神经元的输出值。常用的激活函数包括sigmoid函数、ReLU函数和tanh函数等。此外，神经网络还需要进行反向传播算法来优化权重和偏置值，从而提高预测的准确性。本文主要介绍了神经网络的前世今生和未来发展趋势，深入阐述了神经网络的核心原理和实现方法，并提供了实际操作的指南和示例。
文心一言 VS 讯飞星火 VS chatgpt （298）-- 算法导论22.1 2题
福大大架构师每日一题
07-08 3563
在Go语言中，表示一棵完全二叉树的邻接矩阵首先需要理解完全二叉树的性质：对于任何非叶子节点，其左子节点的索引是其索引的两倍，右子节点的索引是其索引的两倍加一（假设根节点的索引为1）。给定一个有7个节点的完全二叉树，我们可以首先手动或通过代码生成其结构，然后使用邻接矩阵来表示它。在邻接矩阵中，如果节点i与节点j之间有边，则矩阵的(i, j)位置为1（假设矩阵是无向的，所以(j, i)也会是1）。对于完全二叉树，只有父节点到子节点的连接（从根到叶子），或者我们可以考虑它是无向的，即也包括子节点到父节点的连接。
文心一言 VS 讯飞星火 VS chatgpt （297）-- 算法导论22.1 1题
福大大架构师每日一题
07-07 3314
对于有向图的邻接链表表示，每个节点通常存储为一个结构体，其中包含一个指向其所有邻接节点的链表的指针（或切片）。计算每个节点的出度非常简单，因为出度直接对应于该节点指向的邻接链表（或切片）的长度。：O(V + E)，其中V是节点数，E是边数。虽然这个复杂度看起来似乎与边的数量有关，但在实际计算过程中，我们只需遍历每个节点及其邻接链表一次，因此总体上是线性的，因为每个节点和每条边都被访问一次。
文心一言 VS 讯飞星火 VS chatgpt （301）-- 算法导论22.1 5题
福大大架构师每日一题
07-12 3256
为了计算有向图GGG的平方图G2G^2G2，我们可以采用邻接链表或邻接矩阵的方式，但在这里我将给出使用邻接链表表示的算法，因为这种方式在处理稀疏图时通常更高效。假设图GGG有nnn个顶点和mmm条边。因此，总的时间复杂度是O(n+m2)O(n + m^2)O(n+m2)，但在大多数情况下（因为图的平均度数远小于nnn），这可以近似为O(m2)O(m^2)O(m2)，特别是当图比较稠密时。下面是一个使用Go语言实现的简单版本： 请注意，上述代码没有处理重边或自环的情况。在实际应用中，你可能需要添加额外的逻辑来
文心一言 VS 讯飞星火 VS chatgpt （302）-- 算法导论22.1 6题
福大大架构师每日一题
07-14 896
要判断一个有向图是否存在一个通用汇点（universal sink），即一个结点的入度为∣V∣−1|V|-1∣V∣−1且出度为0，我们可以通过检查其邻接矩阵来实现。在邻接矩阵中，如果某个结点是通用汇点，则它对应的行（表示出边）应该全为0（因为没有出边），而对应的列（表示入边）除了对角线上的元素（通常是0，因为自环通常不计入入度）外，应该全为1（因为除了自身外，所有其他结点都指向它）。以下是使用Go语言实现的算法： 注意：如果图非常稀疏，或者你知道一些额外的信息（如边的有序列表等），那么可能可以通过优化来减少
文心一言 VS 讯飞星火 VS chatgpt （300）-- 算法导论22.1 4题
福大大架构师每日一题
07-11 821
对于邻接链表表示法，转置算法的时间复杂度为O∣V∣∣E∣O∣V∣∣E∣，而对于邻接矩阵表示法，转置算法的时间复杂度为O∣V∣2O(|V|^2)O∣V∣2。在实际应用中，如果图比较稀疏（即∣E∣|E|∣E∣远小于∣V∣2|V|^2∣V∣2），使用邻接链表表示法会更加高效。如果图比较稠密（即∣E∣|E|∣E∣接近∣V∣2|V|^2∣V∣2），则邻接矩阵表示法可能更加合适。
文心一言 VS 讯飞星火 VS chatgpt （71）-- 算法导论7.1 1题
Buoluochuixue的博客
08-05 367
对于每个括号内的表达式，可以使用递归的方法计算。知识点数组，模拟，STL（vector）思路不断更新区间片段的末尾，若出现不连续区间，则将当前区间的首尾更新至答案中，并且更新新的区间的首，详解看代码注释。参照图 7-1的方法，说明 PARTITION在数组 A=(13，19，9，5，12，8，7，4，21，2，6，11)上的操作过程。大家好，我是开车的阿Q，自动驾驶的时代已经到来，没时间解释了，快和阿Q一起上车。项目提问不多，我自己叭叭叭讲了十分钟，然后问项目里的难点，怎么发现的，怎么解决的。
文心一言、讯飞星火、chatgpt3.5简要测试.xlsx
04-29
文心一言、讯飞星火、chatgpt3.5简要测试.xlsx
《AI大模型》--Ai个人微信接入chatgpt,文心一言,讯飞星火等ai大模型.zip
03-22
人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ ...
国内外大多ChatGPT类服务的汇总评测，有内容也有图片 GPT-4,Claude+,Bard,通义千问,文心一言，讯飞星火……
05-27
6、百度的文心一言； 7、科大讯飞的讯飞星火； 最有价值附赠教程：如何分辨哪些做GPT转接服务的会是不稳定的甚至是骗子。 绝对有效，而且不光是针对GPT类服务，针对任何网上的网站类型的服务都有效。 学会之后，...
DAY63||拓扑排序精讲 |dijkstra（朴素版）精讲
2301_79865280的博客
11-14 449
某个大型软件项目的构建系统拥有 N 个文件，文件编号从 0 到 N - 1，在这些文件中，某些文件依赖于其他文件的内容，这意味着如果文件 A 依赖于文件 B，则必须在处理文件 A 之前处理文件 B （0 <= A, B <= N - 1）。请编写一个算法，用于确定文件处理的顺序。第一行输入两个正整数 N, M。表示 N 个文件之间拥有 M 条依赖关系。后续 M 行，每行两个正整数 S 和 T，表示 T 文件依赖于 S 文件。输出共一行，如果能处理成功，则输出文件顺序，用空格隔开。
java计算文本相似度算法总结
sunsiny
11-14 519
计算两个字符串之间的最小单字符编辑（插入、删除、替换）次数。这是一种衡量字符串差异性的方法，常用于拼写检查和模糊匹配。：一种基于 Jaro 相似度的改进算法，特别适用于拼写检查和模糊匹配。：计算两个字符串之间的最长公共子序列长度，常用于文本差异比较。：通过计算两个字符串的 n-gram 向量的余弦夹角来评估它们的相似度。：基于子串的字符串相似度计算方法，计算它们共有的Q-gram（长度为Q的连续子串）的数量，然后将这个数量除以两个字符串中Q-gram数量较少的那个，得到相似度的比例。
16 合并区间
weixin_47521269的博客
11-12 725
【代码】16 合并区间。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1500
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
算法每日双题精讲——滑动窗口（长度最小的子数组，无重复字符的最长子串）
A Charmer 的博客
11-11 1451
本文聚焦算法中的滑动窗口算法，通过“长度最小的子数组”和“无重复字符的最长子串”两道经典题目进行精讲。滑动窗口利用双指针界定动态窗口，在数组或字符串上滑动以求解。对于“长度最小的子数组”，初始化指针与变量，通过移动指针扩展与收缩窗口，找到满足和≥目标的最小子数组长度。“无重复字符的最长子串”则借助集合记录窗口内字符，根据字符重复性移动指针并更新最长子串长度。文章展示了滑动窗口算法在处理此类问题时的高效性与灵活性，文末还设置投票环节，引导读者思考算法关键难点，助力读者深入理解滑动窗口算法。
每日小题--买股票的最佳时机
最新发布
m0_74977981的博客
11-14 432
毋庸置疑，一定需要数组遍历结束后才能确定这么一个买入点和卖出点，所以此时想要提升算法的话就要找到一个只需要遍历一遍就能出结果的方法，即将时间复杂度控制在O(n)；遍历数组的过程中去找数组中是否存在一个低价点，并且在低价点的基础上去判断有无上升空间；即杜绝了{4，3，2，1}的情况出现，买入后无法卖出。在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。后出价最高的一天卖出，简而言之，就是找到一个比起始小，并且结尾在一个有最大差距的位置；
14 最长连续序列
weixin_47521269的博客
11-11 573
O1这个算法的时间复杂度是 O(n)，因为每个数字最多只会被处理一次，符合题目要求的时间复杂度。
动态规划---算法中的坚持仙蛊
2301_77174919的博客
11-14 387
然后再写代码，如果代码没通过就打印dp数组，看看是不是和自己预先推导的哪里不一样。如果打印出来和自己预先模拟推导是一样的，那么就是自己的递归公式、初始化或者遍历顺序有问题了。如果和自己预先模拟推导的不一样，那么就是代码实现细节有问题。
力扣－每日温度
m0_63056769的博客
11-10 229
这是我的第一个思路 虽然可以得到正确答案 但是过于暴力 已经超出了时间限制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

福大大架构师每日一题

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值