Berbagi teknologi

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

4. Diberikan banyak gambar$G=(Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V,Bahasa\; Inggris)$daftar tertaut ketetanggaan (multigraf adalah grafik yang memungkinkan tepi berulang dan tepi perulangan sendiri), harap beri waktu$HAI(Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V+Bahasa\; Inggris)$algoritma, digunakan untuk menghitung grafik tidak berarah "ekuivalen" dari grafik$G^{{}^{\prime }}=(Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V,{Bahasa\; Inggris}^{{}^{\prime }})$ diwakili oleh daftar tertaut kedekatan.Di Sini${Bahasa\; Inggris}^{{}^{\prime }}$Boleh jadi$Bahasa\; Inggris$ Tepi yang berlebihan ke dalam dan tepi yang tersisa setelah menghapus tepi yang melingkari sendiri. Menghapus tepi yang tersisa mengacu pada mengganti beberapa tepi antara dua node dengan satu tepi. Jika Anda ingin menulis kode, silakan gunakan bahasa go.

Kata-kata Wen Xin:

Representasi daftar tertaut kedekatan

Dalam representasi daftar tertaut ketetanggaan, setiap simpul $kita$ Ada daftar tertaut, dan setiap node dalam daftar tertaut mewakili seorang budak$kita$ Tepi awal.untuk menghitung$G^T$, kita perlu melintasi $G$ untuk setiap sisi , dan membalikkan arah tepi, tambahkan$G^T$ dalam daftar tertaut yang sesuai.

Jalankan implementasi bahasa：

package main

import (
    "fmt"
)

// Graph 使用邻接链表表示
type Graph struct {
    vertices int
    adjList  map[int][]int
}

// NewGraph 创建一个新的图
func NewGraph(vertices int) *Graph {
    return &Graph{
        vertices: vertices,
        adjList:  make(map[int][]int),
    }
}

// AddEdge 添加一条边到图中
func (g *Graph) AddEdge(u, v int) {
    g.adjList[u] = append(g.adjList[u], v)
}

// Transpose 计算图的转置
func (g *Graph) Transpose() *Graph {
    gT := NewGraph(g.vertices)
    for u, adj := range g.adjList {
        for _, v := range adj {
            gT.AddEdge(v, u) // 反转边的方向
        }
    }
    return gT
}

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)

    gT := g.Transpose()

    fmt.Println("Original Graph:")
    for u, adj := range g.adjList {
        fmt.Printf("%d -> %vn", u, adj)
    }

    fmt.Println("nTransposed Graph:")
    for u, adj := range gT.adjList {
        fmt.Printf("%d -> %vn", u, adj)
    }
}
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

kompleksitas waktu：

• Kompleksitas waktu untuk melintasi setiap sisi adalah $HAI(Bahasa\; Inggris)$,di dalam $Bahasa\; Inggris$ adalah jumlah tepinya.
• Untuk setiap sisi, kami melakukan operasi waktu konstan (menambahkan ke daftar kedekatan grafik lain).
• Oleh karena itu, kompleksitas waktu totalnya adalah $HAI(Bahasa\; Inggris)$。

Representasi matriks ketetanggaan

Dalam representasi matriks ketetanggaan, kami menggunakan array dua dimensi untuk menyimpan informasi tepi, di mana matrix[u][v] Menunjukkan apakah ada garis dari$kamkamkamkamkamkamu$ tiba$kita$ samping.untuk menghitung$G^T$, kita menelusuri segitiga atas (atau segitiga bawah, bergantung pada kebiasaan representasi matriks Anda) dari matriks dan membalik arah tepinya, yaitu, matrix[u][v] Nilainya ditetapkan kematrixT[v][u]。

Jalankan implementasi bahasa(Versi yang disederhanakan, hanya mempertimbangkan keberadaan dan tidak mempertimbangkan bobot tepi):

// 假设使用二维布尔切片表示邻接矩阵
type GraphMatrix [][]bool

// Transpose 计算图的转置
func (g GraphMatrix) Transpose() GraphMatrix {
    n := len(g)
    gT := make(GraphMatrix, n)
    for i := range gT {
        gT[i] = make([]bool, n)
    }

    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            gT[j][i] = g[i][j] // 反转边的方向
        }
    }
    return gT
}

// 注意：这里没有完整的GraphMatrix类型实现，因为示例仅关注Transpose函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

kompleksitas waktu：

• Diperlukan iterasi pada setiap elemen matriks $HAI({Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V}^2)$ waktu, di antaranya$Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V$ adalah jumlah simpul.
• Oleh karena itu, kompleksitas waktu totalnya adalah $HAI({Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V}^2)$ . Ini mungkin bukan cara yang paling efisien ketika jumlah simpul jauh lebih besar daripada jumlah sisi.

iFlytek Percikan:

Untuk graf berarah yang diwakili oleh daftar ketetanggaan, kita dapat menambahkan simpul-simpul yang berdekatan dari setiap simpul ke daftar ketetanggaan dari simpul yang ditransposisi dari graf baru dengan menelusuri daftar ketetanggaan setiap simpul. Langkah-langkah spesifiknya adalah sebagai berikut:

1. Buat daftar kedekatan baru $G^T$, diinisialisasi menjadi kosong.
2. Lintasi gambar aslinya $G$ setiap simpul dari$kita$。
3. Melintasi simpul $kita$ daftar tertaut ketetanggaan, setiap simpul yang berdekatan$kamkamkamkamkamkamu$ Tambahkan ke gambar baru$G^T$ simpul tengah$kita$ dalam daftar tertaut kedekatan.
4. Kembali ke gambar baru $G^T$。

Analisis kompleksitas waktu: diperlukan melintasi setiap titik pada grafik asli $HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V|)$ Waktu yang diperlukan untuk melintasi daftar ketetanggaan setiap simpul adalah$HAI(|Bahasa\; Inggris|)$ waktu, jadi kompleksitas waktu totalnya adalah$HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V|+|Bahasa\; Inggris|)$。

Untuk graf berarah yang diwakili oleh matriks ketetanggaan, kita dapat memperoleh matriks ketetanggaan dari graf baru dengan melakukan transposisi matriks ketetanggaan dari graf aslinya. Langkah-langkah spesifiknya adalah sebagai berikut:

1. Buat yang baru dengan ukuran $|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V|\times |Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V|$ matriks$G^T$, diinisialisasi ke matriks yang semuanya nol.
2. Lintasi matriks ketetanggaan gambar asli $G$,Akan $G[Saya][J]$ Nilainya ditetapkan ke$G^T[J][Saya]$。
3. Mengembalikan matriks ketetanggaan dari grafik baru $G^T$。

Analisis kompleksitas waktu: diperlukan melintasi matriks ketetanggaan dari grafik asli $HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2)$ waktu, jadi kompleksitas waktu totalnya adalah$HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2)$。

Berikut ini adalah kode yang diimplementasikan dalam bahasa Go:

// 邻接链表表示的有向图转置
func transposeAdjList(G map[int][]int) map[int][]int {
    GT := make(map[int][]int)
    for v, neighbors := range G {
        for _, u := range neighbors {
            GT[u] = append(GT[u], v)
        }
    }
    return GT
}

// 邻接矩阵表示的有向图转置
func transposeAdjMatrix(G [][]int) [][]int {
    n := len(G)
    GT := make([][]int, n)
    for i := range GT {
        GT[i] = make([]int, n)
    }
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            GT[j][i] = G[i][j]
        }
    }
    return GT
}
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

360 Otak Cerdas:

Representasi daftar tertaut kedekatan

Dalam representasi daftar tertaut ketetanggaan, kita dapat langsung menelusuri gambar aslinya$G$Daftar ketetanggaan setiap node kemudian ditambahkan ke grafik baru setelah membalikkan arah setiap sisi.$G^T$pada node yang sesuai.

Implementasi kode bahasa 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 _, adj := range node.Adjacent {
            // 将边反向添加到转置图中
            transposed.Vertices[adj.Value].Adjacent = append(transposed.Vertices[adj.Value].Adjacent, transposed.Vertices[node.Value])
        }
    }
    return transposed
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Analisis kompleksitas waktu:

• Lintasi setiap node pada grafik asli:$HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V|)$
• Lintasi daftar kedekatan setiap node:$HAI(|Bahasa\; Inggris|)$

Oleh karena itu, kompleksitas waktu totalnya adalah $HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V|+|Bahasa\; Inggris|)$。

Notasi matriks ketetanggaan

Dalam notasi matriks ketetanggaan, kita dapat membuat matriks ketetanggaan baru dan kemudian melintasi gambar aslinya$G$matriks ketetanggaan, setiap elemen dalam matriks$(Saya,J)$ditugaskan ke matriks baru$(J,Saya)$posisi, sehingga menyelesaikan inversi tepi.

Implementasi kode bahasa Go:

type MatrixGraph struct {
    Matrix [][]bool // 存储邻接矩阵
}

func (mg *MatrixGraph) Transpose() *MatrixGraph {
    transposed := &MatrixGraph{make([][]bool, len(mg.Matrix))}
    for i := range mg.Matrix {
        transposed.Matrix[i] = make([]bool, len(mg.Matrix))
        for j := range mg.Matrix[i] {
            // 将边反向赋值到转置矩阵中
            transposed.Matrix[i][j] = mg.Matrix[j][i]
        }
    }
    return transposed
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Analisis kompleksitas waktu:

• Buat matriks ketetanggaan baru:$HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2)$
• Lintasi matriks ketetanggaan gambar asli:$HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2)$

Oleh karena itu, kompleksitas waktu totalnya adalah $HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2)$。

Meringkaskan

Untuk representasi daftar tertaut ketetanggaan, kompleksitas waktu dari algoritma transpos adalah $HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V|+|Bahasa\; Inggris|)$, dan untuk representasi matriks ketetanggaan, kompleksitas waktu dari algoritma transpos adalah $HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2)$ .Dalam penerapan praktis, jika grafiknya relatif jarang (mis.$|Bahasa\; Inggris|$jauh lebih kecil dari$|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2$ ), akan lebih efisien jika menggunakan representasi daftar tertaut ketetanggaan.Jika grafiknya padat (mis.$|Bahasa\; Inggris|$di dekat$|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2$), maka representasi matriks ketetanggaan mungkin lebih tepat.

Spektrum hikmah kata-kata yang jelas:

Dalam representasi grafik, daftar tertaut ketetanggaan dan matriks ketetanggaan merupakan metode yang umum digunakan. Daftar tertaut ketetanggaan digunakan untuk merepresentasikan graf tidak berarah dan berarah, sedangkan matriks ketetanggaan biasanya digunakan untuk merepresentasikan graf tidak berarah. Untuk transpos graf berarah, kita dapat mengoperasikan daftar tertaut ketetanggaan dan matriks ketetanggaan secara terpisah.

Ubah urutan daftar tertaut kedekatan

Untuk graf berarah yang diwakili oleh daftar tertaut ketetanggaan, transposisi graf dapat dilakukan dengan melintasi setiap titik pada graf asli dan memodifikasi sisi keluar dari graf asli menjadi sisi masuk.

package main
import (
	"fmt"
)
// 定义图的顶点结构
type Vertex struct {
	Name   string
	Edges  []*Vertex
	Visited bool
}
// 计算图的转置
func Transpose(g *Vertex) {
	for _, v := range g.Edges {
		// 遍历顶点v的所有出边
		for _, w := range v.Edges {
			// 在原图中查找顶点w指向顶点v的边，并反转
			for i, e := range w.Edges {
				if e == v {
					w.Edges[i] = v
					break
				}
			}
		}
	}
}
func main() {
	// 创建顶点
	a := &Vertex{Name: "A"}
	b := &Vertex{Name: "B"}
	c := &Vertex{Name: "C"}
	// 建立有向图关系
	a.Edges = []*Vertex{b, c}
	b.Edges = []*Vertex{a}
	c.Edges = []*Vertex{a}
	// 打印原图
	fmt.Println("原图：")
	PrintGraph(a)
	// 计算转置图
	Transpose(a)
	// 打印转置图
	fmt.Println("转置图：")
	PrintGraph(a)
}
// PrintGraph 用于打印图的邻接链表表示
func PrintGraph(g *Vertex) {
	g.Visited = true
	for _, v := range g.Edges {
		if !v.Visited {
			fmt.Println(g.Name, "->", v.Name)
			PrintGraph(v)
		}
	}
}
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

Transpos matriks ketetanggaan

Untuk graf berarah yang diwakili oleh matriks ketetanggaan, transposisi graf dapat dilakukan dengan mengubah setiap baris dari graf asli menjadi kolom yang sesuai pada graf baru.

package main
import (
	"fmt"
)
// 计算邻接矩阵的转置
func TransposeMatrix(mat [][]int) [][]int {
	transposed := make([][]int, len(mat[0]))
	for i := range transposed {
		transposed[i] = make([]int, len(mat))
	}
	for i, row := range mat {
		for j, val := range row {
			if val == 1 {
				transposed[j][i] = 1
			}
		}
	}
	return transposed
}
func main() {
	// 创建邻接矩阵
	originalMatrix := [][]int{
		{0, 1, 1},
		{0, 0, 1},
		{1, 0, 0},
	}
	// 计算转置矩阵
	transposedMatrix := TransposeMatrix(originalMatrix)
	// 打印转置矩阵
	fmt.Println("转置矩阵：")
	for _, row := range transposedMatrix {
		fmt.Println(row)
	}
}
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

Analisis waktu berjalan algoritma

1. Untuk transposisi daftar tertaut ketetanggaan, kompleksitas waktu algoritmanya adalah O(E), dengan E adalah jumlah sisi pada grafik. Hal ini karena setiap sisi perlu dilalui satu kali.

2. Untuk transpos matriks ketetanggaan, kompleksitas waktu algoritmanya adalah O(V^2), dengan V adalah jumlah simpul pada graf. Hal ini karena setiap elemen matriks perlu dilintasi satu kali, dan ukuran matriksnya adalah V×V.
   Algoritme ini semuanya efisien dan dijalankan

Tiangong:

Untuk mengimplementasikan algoritma untuk menghitung grafik berarah $G$ transposisi dari$G^T$ , kita dapat memproses dua representasi daftar tertaut ketetanggaan dan matriks ketetanggaan. Di bawah ini saya akan menjelaskan algoritma untuk kedua kasus ini dan memberikan contoh kode dalam bahasa Go.

Representasi daftar tertaut kedekatan

Langkah-langkah algoritma:

1. Buat daftar kedekatan baru newAdjList Digunakan untuk menyimpan grafik yang dialihkan.
2. Lintasi daftar tertaut kedekatan dari gambar asli adjList。
3. untuk setiap tepi (u, v), tambahkan ke newAdjList[v] tengah.
4. Mengembalikan daftar kedekatan baru newAdjList。

Contoh kode bahasa Go:

type Graph struct {
    vertices []*Vertex
}

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

func (g *Graph) Transpose() *Graph {
    gt := &Graph{make([]*Vertex, len(g.vertices))}
    for i := range g.vertices {
        gt.vertices[i] = &Vertex{key: i}
    }
    for _, u := range g.vertices {
        for _, v := range u.adjacent {
            // Add edge (v, u) to the transpose graph.
            gt.vertices[v.key].adjacent = append(gt.vertices[v.key].adjacent, gt.vertices[u.key])
        }
    }
    return gt
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Analisis waktu berjalan:

Waktu berjalan dari algoritma ini adalah O(|V| + |E|), dimana |V| adalah jumlah simpul dan |E| adalah jumlah sisi. Ini karena kita perlu melintasi semua simpul dan tepi satu kali.

Notasi matriks ketetanggaan

Langkah-langkah algoritma:

1. Buat matriks ketetanggaan baru newAdjMatrix Digunakan untuk menyimpan grafik yang dialihkan.
2. Lintasi matriks ketetanggaan gambar asli adjMatrix。
3. untuk setiap elemen adjMatrix[i][j], tetapkan ke newAdjMatrix[j][i]。
4. Mengembalikan matriks kedekatan baru newAdjMatrix。

Contoh kode bahasa Go:

type Graph struct {
    matrix [][]bool
}

func (g *Graph) Transpose() *Graph {
    gt := &Graph{make([][]bool, len(g.matrix))}
    for i := range gt.matrix {
        gt.matrix[i] = make([]bool, len(g.matrix))
    }
    for i := range g.matrix {
        for j := range g.matrix[i] {
            // Copy the adjacency values with swapped indices.
            gt.matrix[j][i] = g.matrix[i][j]
        }
    }
    return gt
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Analisis waktu berjalan:

Waktu berjalan dari algoritma ini adalah O(|V|^2), dimana |V| adalah jumlah simpul. Hal ini karena kita perlu melintasi seluruh matriks ketetanggaan, dan ukuran matriks ketetanggaan adalah |V| x |V|.

Contoh kode di atas hanyalah bagian inti dari algoritma. Dalam aplikasi sebenarnya, fungsi lain seperti penanganan kesalahan, input dan output mungkin perlu ditambahkan. Selain itu, untuk menyederhanakan kode, diasumsikan tidak ada sisi yang berulang pada grafik dan nomor titik diberi nomor berurutan mulai dari 0.

obrolangpt：

Berikut ini adalah algoritma yang ditulis dalam bahasa Go untuk menghitung G^T dari grafik G, dan metode representasi matriks ketetanggaan dan daftar ketetanggaan yang sesuai juga diberikan:

package main

import "fmt"

// 图的节点结构体
type Node struct {
    Value int       // 节点的值
    Next  *Node     // 下一个节点指针
}

// 邻接链表表示法的图结构体
type Graph struct {
    Vertices []*Node   // 图中所有节点的数组
}

// 添加有向边到邻接链表
func (g *Graph) AddEdge(u, v int) {
    newNode := &Node{Value: v}
    if g.Vertices[u] == nil {
        g.Vertices[u] = newNode
    } else {
        curr := g.Vertices[u]
        for curr.Next != nil {
            curr = curr.Next
        }
        curr.Next = newNode
    }
}

// 输出邻接链表表示的图信息
func (g *Graph) Print() {
    for i, node := range g.Vertices {
        fmt.Printf("顶点 %d：", i)
        for node != nil {
            fmt.Printf("%d ", node.Value)
            node = node.Next
        }
        fmt.Println()
    }
}

// 获取图 G 的转置图 G^T 的邻接链表表示法
func GetTranspose(g *Graph) *Graph {
    transpose := &Graph{
        Vertices: make([]*Node, len(g.Vertices)),
    }

    for i, node := range g.Vertices {
        for node != nil {
            v := node.Value

            // 在转置图中添加反向边
            transpose.AddEdge(v, i)

            node = node.Next
        }
    }

    return transpose
}

// 输出邻接链表表示的转置图信息
func PrintTranspose(g *Graph) {
    fmt.Println("转置图 G^T：")
    g.Print()
}

// 邻接矩阵表示法的图结构体
type Matrix struct {
    Vertices [][]int   // 邻接矩阵，存储边的连接关系（0 表示无边，1 表示有边）
}

// 初始化邻接矩阵表示的图
func InitMatrix(numVertices int) *Matrix {
    matrix := &Matrix{
        Vertices: make([][]int, numVertices),
    }

    for i := range matrix.Vertices {
        matrix.Vertices[i] = make([]int, numVertices)
    }

    return matrix
}

// 添加有向边到邻接矩阵
func (m *Matrix) AddEdge(u, v int) {
    m.Vertices[u][v] = 1
}

// 获取图 G 的转置图 G^T 的邻接矩阵表示法
func GetTransposeMatrix(m *Matrix) *Matrix {
    numRows := len(m.Vertices)
    numCols := len(m.Vertices[0])

    transpose := InitMatrix(numRows)

    for i := 0; i < numRows; i++ {
        for j := 0; j < numCols; j++ {
            if m.Vertices[i][j] == 1 {
                // 在转置矩阵中添加反向边
                transpose.AddEdge(j, i)
            }
        }
    }

    return transpose
}

// 输出邻接矩阵表示的转置图信息
func PrintTransposeMatrix(m *Matrix) {
    numRows := len(m.Vertices)
    numCols := len(m.Vertices[0])

    fmt.Println("转置图 G^T：")
    for i := 0; i < numRows; i++ {
        fmt.Printf("顶点 %d：", i)
        for j := 0; j < numCols; j++ {
            if m.Vertices[i][j] == 1 {
                fmt.Printf("%d ", j)
            }
        }
        fmt.Println()
    }
}

func main() {
    // 邻接链表表示的有向图 G
    g := &Graph{
        Vertices: make([]*Node, 4),
    }

    g.AddEdge(0, 1)
    g.AddEdge(1, 2)
    g.AddEdge(2, 3)
    g.AddEdge(3, 1)

    // 输出原始图 G 的邻接链表表示法
    fmt.Println("原始图 G：")
    g.Print()

    // 获取转置图 G^T 的邻接链表表示法并输出
    transpose := GetTranspose(g)
    PrintTranspose(transpose)

    
	// 邻接矩阵表示的有向图 G
	m := InitMatrix(4)

	m.AddEdge(0, 1)
	m.AddEdge(1, 2)
	m.AddEdge(2, 3)
	m.AddEdge(3, 1)

	// 输出原始图 G 的邻接矩阵表示法
	fmt.Println("原始图 G：")
	for _, row := range m.Vertices {
		fmt.Println(row)
	}

	// 获取转置图 G^T 的邻接矩阵表示法并输出
	transposeMatrix := GetTransposeMatrix(m)
	PrintTransposeMatrix(transposeMatrix)
}
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

Kompleksitas waktu dari algoritma ini adalah O(V + E), dimana V adalah jumlah simpul dan E adalah jumlah sisi. Proses pembuatan graf yang ditransposisi memerlukan penelusuran semua sisi dari graf asli dan menambahkannya ke graf yang ditransposisi secara terbalik, sehingga total kompleksitas waktu sebanding dengan jumlah simpul dan sisi.

kimi：

Grafik transposisi dari grafik berarah dapat diwakili oleh dua struktur data utama: daftar tertaut ketetanggaan dan matriks ketetanggaan. Di bawah ini saya akan memperkenalkan algoritma dalam dua kasus ini dan memberikan contoh kode dalam bahasa Go.

Representasi daftar tertaut kedekatan

Untuk graf yang diwakili oleh daftar ketetanggaan tertaut, kita dapat melakukan transposisi graf tersebut dengan melintasi daftar ketetanggaan setiap titik dan kemudian menambahkan sisi terbalik ke setiap titik ketetanggaan. Kompleksitas waktu dari metode ini adalah O(V + E), dimana V adalah jumlah simpul dan E adalah jumlah sisi.

Kode contoh bahasa Go:

type Vertex struct {
    Value int
    Adj []Vertex
}

func transposeGraph(graph []Vertex) []Vertex {
    transposed := make([]Vertex, len(graph))
    for _, v := range graph {
        for _, adjV := range v.Adj {
            // 为邻接点添加反向边
            found := false
            for _, tV := range transposed[adjV.Value].Adj {
                if tV.Value == v.Value {
                    found = true
                    break
                }
            }
            if !found {
                transposed[adjV.Value].Adj = append(transposed[adjV.Value].Adj, v)
            }
        }
    }
    return transposed
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Representasi matriks ketetanggaan

Untuk graf yang diwakili oleh matriks ketetanggaan, kita dapat menerapkan transpos dengan menukar baris dan kolom matriks. Kompleksitas waktu metode ini adalah O(V^2).

Kode contoh bahasa Go:

func transposeMatrix(matrix [][]int) [][]int {
    n := len(matrix)
    transposed := make([][]int, n)
    for i := 0; i < n; i++ {
        transposed[i] = make([]int, n)
        for j := 0; j < n; j++ {
            transposed[i][j] = matrix[j][i]
        }
    }
    return transposed
}
1
2
3
4
5
6
7
8
9
10
11

Analisis Algoritma

• daftar kedekatan : Algoritme perlu melintasi daftar ketetanggaan setiap titik, dan untuk setiap sisi, sisi sebaliknya perlu ditambahkan ke daftar ketetanggaan dari titik yang berdekatan. Jika panjang rata-rata daftar tetangga adalah k, kompleksitas waktu dari algoritma tersebut adalah O(V + E * k). Dalam kasus terburuk, k bisa mendekati V, dan kompleksitas waktu mendekati O(V^2). Dalam kasus terbaik, k mendekati 1 dan kompleksitas waktu mendekati O(E).
• matriks ketetanggaan : Algoritme perlu menelusuri setiap elemen matriks dan menukar baris dan kolom. Karena matriksnya adalah VxV, kompleksitas waktunya adalah O(V^2).

Dalam aplikasi praktis, algoritma mana yang dipilih bergantung pada ketersebaran grafik dan memori yang tersedia. Untuk graf renggang, daftar tertaut ketetanggaan mungkin lebih hemat memori; untuk graf padat, matriks ketetanggaan mungkin lebih efisien.

Hunyuan:

Untuk menghitung grafik berarah $G=(Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V,Bahasa\; Inggris)$ transposisi dari$G^T=(Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V,{Bahasa\; Inggris}^T)$, kita dapat memberikan algoritme yang sesuai untuk dua metode representasi masing-masing daftar tertaut ketetanggaan dan matriks ketetanggaan, dan menganalisis waktu berjalannya.

Representasi daftar tertaut kedekatan

Deskripsi Algoritma

1. Inisialisasi daftar kedekatan yang kosong untuk menyimpan tepi grafik yang dialihkan.
2. Lintasi gambar aslinya $G$ dari semua node.
3. untuk setiap node $kamkamkamkamkamkamu$, lintasi semua node tetangga dalam daftar kedekatannya $kita$。
4. Tambahkan daftar kedekatan baru dari $kita$ tiba$kamkamkamkamkamkamu$ samping.
5. Setelah menyelesaikan traversal, daftar tertaut kedekatan yang baru adalah grafik yang dialihkan $G^T$。

Jalankan analisis waktu

• kompleksitas waktu:$HAI(|Bahasa\; Inggris|)$,di dalam $|Bahasa\; Inggris|$ adalah jumlah sisi bayangan asal. Karena kita perlu melintasi setiap sisi dua kali (sekali untuk membaca dan sekali untuk menulis).

Notasi matriks ketetanggaan

Deskripsi Algoritma

1. Inisialisasi matriks ketetanggaan dengan ukuran yang sama dengan grafik asli untuk menyimpan tepi grafik yang ditransposisi.
2. Lintasi gambar aslinya $G$ matriks ketetanggaan.
3. Untuk setiap elemen bukan nol dalam matriks (yaitu terdapat sisi $(kamkamkamkamkamkamu,kita)$), posisi yang sesuai dalam matriks ketetanggaan dari grafik yang ditransposisikan $(kita,kamkamkamkamkamkamu)$ Setel ke elemen bukan nol.
4. Setelah traversal selesai, matriks ketetanggaan yang baru adalah graf yang ditransposisikan $G^T$。

Jalankan analisis waktu

• kompleksitas waktu:$HAI(|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V{|}^2)$,di dalam $|Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; Bahasa\; Indonesia:\; V|$ adalah jumlah node pada grafik asli. Karena kita perlu melintasi seluruh matriks ketetanggaan.

Implementasi bahasa Go (representasi daftar tertaut yang berdekatan)

type Edge struct {
    dest int
}

type AdjacencyList struct {
    edges map[int][]Edge
}

func TransposeGraph(graph AdjacencyList) AdjacencyList {
    transposed := AdjacencyList{edges: make(map[int][]Edge)}
    for u, neighbors := range graph.edges {
        for _, edge := range neighbors {
            v := edge.dest
            transposed.edges[v] = append(transposed.edges[v], Edge{dest: u})
        }
    }
    return transposed
}

func main() {
    // 示例图的邻接链表表示
    graph := AdjacencyList{edges: map[int][]Edge{
        0: {{dest: 1}},
        1: {{dest: 2}},
        2: {{dest: 0}},
    }}

    // 计算转置图
    transposedGraph := TransposeGraph(graph)

    // 打印转置图的邻接链表
    for u, neighbors := range transposedGraph.edges {
        fmt.Printf("Node %d -> Nodes: ", u)
        for _, edge := range neighbors {
            fmt.Printf("%d ", edge.dest)
        }
        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

Dalam kode ini, kami mendefinisikan a Edge struktur untuk mewakili tepi, dan aAdjacencyList Struktur untuk mewakili daftar tertaut kedekatan.TransposeGraph Fungsi menerima aAdjacencyList ketik parameter dan mengembalikan representasi daftar tertaut kedekatan dari grafik yang dialihkan.adamain fungsi, kita membuat contoh grafik, menghitung dan mencetak grafik transposisinya.