प्रौद्योगिकी साझेदारी

Wen Xin Yi Yan VS iFlytek Spark VS chatgpt (300) -- एल्गोरिदमस्य परिचयः 22.1 4 प्रश्नाः

2024-07-12

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

4. बहुचित्रं दत्तम् जी = ( वि , ई ) ग=(वि,ई) .जी=(वि,ई)adjacency linked list (मल्टीग्राफः एकः आलेखः अस्ति यः पुनरावृत्तिधाराः स्वयमेव लूपिंगधाराः च अनुमन्यन्ते), कृपया इत्यस्य समयं ददातु ओ ( वि + ई ) ओ(व+ई) .ओ(वि+ई)algorithm, आलेखस्य "समतुल्य" अनिर्देशितलेखस्य गणनाय उपयुज्यते G ′ = ( वि , ई ′ ) G^{'}=(V,E^{'})जी′=(वि,ई′) समीपतालिङ्कितसूचया प्रतिनिधित्वं भवति ।अत्र ई ′ ई^{'}ई′भविष्यति ईईई स्व-पाश-धाराः लोपयित्वा अन्तः अनावश्यक-धाराः शेष-धाराः च । शेषधाराणां निष्कासनं द्वयोः नोडयोः मध्ये बहुविधधारानाम् एकेन धारेन प्रतिस्थापनं निर्दिशति । यदि भवान् कोडं लिखितुम् इच्छति तर्हि कृपया go language इत्यस्य उपयोगं कुर्वन्तु ।

वेन् शीन् इत्यस्य वचनम् : १.

समीपता लिङ्क्ड् सूची प्रतिनिधित्वम्

समीपता लिङ्क्ड् सूचीप्रतिपादने प्रत्येकं शिखरम् विववि तत्र लिङ्क्ड् सूची अस्ति, लिङ्क्ड् सूचीयां प्रत्येकं नोड् एकं दासं प्रतिनिधियति विववि प्रारम्भिक धार।गणनाय क्रमेण GTG^Tजीटी, अस्माकं भ्रमणस्य आवश्यकता अस्ति जी.जीजी for each edge of , तथा धारस्य दिशां विपर्यय्य, योजयन्तु GTG^Tजीटी तत्सम्बद्धे लिङ्क् कृतसूचौ ।

भाषा कार्यान्वयनम् गच्छतु：

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

कालजटिलता：

  • प्रत्येकं धारं भ्रमितुं कालजटिलता अस्ति ओ ( ई ) ओ(ई) .ओ(ई),इत्यस्मिन्‌ ईईई इति धारसङ्ख्या ।
  • प्रत्येकस्य धारस्य कृते वयं नित्यसमयस्य क्रियाम् (अन्यस्य आलेखस्य समीपतासूचौ योजयित्वा) कुर्मः ।
  • अतः कुलकालजटिलता अस्ति ओ ( ई ) ओ(ई) .ओ(ई)。

समीपता मैट्रिक्स प्रतिनिधित्व

adjacency matrix representation इत्यस्मिन् वयं edge information इत्यस्य संग्रहणार्थं द्वि-आयामी सरणीं उपयुञ्ज्महे, यत्र matrix[u][v] तः रेखा अस्ति वा इति सूचयति उउउ आगच्छति विववि पृष्ठभाग।गणनाय क्रमेण GTG^Tजीटी, वयं मैट्रिक्सस्य उपरितनत्रिकोणं (अथवा अधः त्रिकोणं, भवतः आकृतिप्रतिपादन-अभ्यासानां आधारेण) पारं कुर्मः तथा च किनारेनां दिशां विपर्ययामः अर्थात् matrix[u][v] मूल्यं नियुक्तं भवतिmatrixT[v][u]。

भाषा कार्यान्वयनम् गच्छतु(सरलीकृतं संस्करणं, केवलं अस्तित्वं विचारयति तथा च धारभारं न विचारयति):

// 假设使用二维布尔切片表示邻接矩阵
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

कालजटिलता：

  • आकृतिः प्रत्येकं तत्त्वस्य उपरि पुनरावृत्तिः आवश्यकी भवति ओ ( वि २ ) ओ(वि^२) ९.ओ(वि2) कालः, येषु वि.विवि इति शिखरसङ्ख्या ।
  • अतः कुलकालजटिलता अस्ति ओ ( वि २ ) ओ(वि^२) ९.ओ(वि2) . यदा शिखरसङ्ख्या धारसङ्ख्यायाः अपेक्षया बहु अधिका भवति तदा एतत् सर्वाधिकं कार्यक्षमं न भवेत् ।

अत्र चित्रविवरणं सम्मिलितं कुर्वन्तु

अत्र चित्रविवरणं सम्मिलितं कुर्वन्तु

अत्र चित्रविवरणं सम्मिलितं कुर्वन्तु

अत्र चित्रविवरणं सम्मिलितं कुर्वन्तु

iFlytek स्पार्कः : १.

समीपतासूचिकाद्वारा प्रतिनिधितस्य निर्देशितस्य आलेखस्य कृते वयं प्रत्येकस्य शिखरस्य समीपस्थशिखरस्य समीपतासूचीं भ्रमित्वा नूतनलेखस्य स्थानान्तरितशिखरस्य समीपतासूचौ योजयितुं शक्नुमः विशिष्टानि पदानि निम्नलिखितरूपेण सन्ति ।

  1. नूतनं समीपतासूचीं रचयन्तु GTG^{T} ९.जीटी, रिक्तं इति आरम्भः कृतः ।
  2. मूलप्रतिबिम्बं भ्रमन्तु जी.जीजी प्रत्येकं शिखरं of विववि。
  3. शिखरं पारं कुरुत विववि adjacency linked list, प्रत्येकं समीपस्थं शिखरम् उउउ नूतनप्रतिबिम्बे योजयतु GTG^{T} ९.जीटी मध्यशिखरः विववि समीपतालिङ्कितसूचौ ।
  4. नूतनचित्रं प्रति प्रत्यागच्छन्तु GTG^{T} ९.जीटी。

समयजटिलताविश्लेषणम् : मूललेखस्य प्रत्येकं शिखरं भ्रमितुं आवश्यकम् ओ ( ∣ वि ∣ ) ओ(|व|) .ओ(∣वि∣) प्रत्येकस्य शिखरस्य समीपतासूचीं भ्रमितुं आवश्यकः समयः अस्ति ओ ( ∣ ई ∣ ) ओ(|ई|)ओ(∣ई∣) समयः, अतः कुलकालजटिलता अस्ति ओ ( ∣ वि ∣ + ∣ ई ∣ ) ओ(|व| + |ई|)ओ(∣वि∣+∣ई∣)。

समीपतामात्रिकायाः ​​प्रतिनिधित्वेन निर्देशितस्य आलेखस्य कृते मूललेखस्य समीपतामात्रिकायाः ​​स्थानान्तरणं कृत्वा नूतनस्य आलेखस्य समीपतामात्रिकां प्राप्तुं शक्नुमः विशिष्टानि पदानि निम्नलिखितरूपेण सन्ति ।

  1. आकारयुक्तं नूतनं रचयन्तु ∣ वि ∣ × ∣ व ∣ |वि| काल |वि|∣वि∣×∣वि∣ आकृतिः GTG^{T} ९.जीटी, सर्वशून्यमात्रिकायाः ​​आरम्भः कृतः ।
  2. मूलबिम्बस्य समीपतामात्रिकां भ्रमन्तु जी.जीजी,भविष्यति ग [ इ ] [ ज ] ग[इ][ज] ।जी[अहम्‌][झ] मूल्यं नियुक्तं भवति GT [ j ] [ i ] ग^{T}[ज][इ] ।जीटी[झ][अहम्‌]。
  3. नूतनस्य आलेखस्य समीपतामात्रिकां प्रत्यागच्छति GTG^{T} ९.जीटी。

समयजटिलताविश्लेषणम् : मूललेखस्य समीपतामात्रिकायाः ​​भ्रमणस्य आवश्यकता भवति हे ( ∣ वि ∣ २ ) ओ(|V|^2) .ओ(∣वि∣2) समयः, अतः कुलकालजटिलता अस्ति हे ( ∣ वि ∣ २ ) ओ(|V|^2) .ओ(∣वि∣2)。

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

३६० बुद्धिमान् मस्तिष्कः : १.

समीपता लिङ्क्ड् सूची प्रतिनिधित्वम्

adjacency linked list representation इत्यस्मिन् वयं प्रत्यक्षतया मूलप्रतिबिम्बं भ्रमितुं शक्नुमः जी.जीजीततः प्रत्येकस्य नोडस्य समीपतासूची प्रत्येकस्य धारस्य दिशां विपर्यय्य नूतने आलेखे योज्यते । GTG^{T} ९.जीटीतत्सम्बद्धे नोडस्य उपरि ।

गो भाषासङ्केत कार्यान्वयनम् : १.
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
कालजटिलताविश्लेषणम् : १.
  • मूललेखे प्रत्येकं नोडं पारं कुर्वन्तु: ओ ( ∣ वि ∣ ) ओ(|व|) .ओ(∣वि∣)
  • प्रत्येकस्य नोड् इत्यस्य समीपतासूचीं भ्रमन्तु : ओ ( ∣ ई ∣ ) ओ(|ई|)ओ(∣ई∣)

अतः कुलकालजटिलता अस्ति ओ ( ∣ वि ∣ + ∣ ई ∣ ) ओ(|व| + |ई|)ओ(∣वि∣+∣ई∣)。

समीपता आकृति संकेतन

adjacency matrix notation इत्यस्मिन् वयं नूतनं adjacency matrix निर्मातुं शक्नुमः ततः मूलप्रतिबिम्बं पारयितुं शक्नुमः जी.जीजीadjacency matrix, matrix इत्यस्मिन् प्रत्येकं तत्त्वम् ( इ , ज ) (इ, ज) .(अहम्‌,झ)नूतनमात्रिकायाः ​​नियुक्तः ( ज , इ ) (ज, इ) .(झ,अहम्‌)स्थितिः, एवं धारस्य व्यावृत्तिः समाप्तः ।

गो भाषासङ्केत कार्यान्वयनम् : १.
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
कालजटिलताविश्लेषणम् : १.
  • एकं नूतनं समीपतामात्रिकं रचयन्तु: हे ( ∣ वि ∣ २ ) ओ(|V|^2) .ओ(∣वि∣2)
  • मूलबिम्बस्य समीपतामात्रिकां पारं कुर्वन्तु: हे ( ∣ वि ∣ २ ) ओ(|V|^2) .ओ(∣वि∣2)

अतः कुलकालजटिलता अस्ति हे ( ∣ वि ∣ २ ) ओ(|V|^2) .ओ(∣वि∣2)。

सारांशं कुरुत

समीपता लिङ्क्ड् सूचीप्रतिपादनस्य कृते, ट्रांसपोज एल्गोरिदम् इत्यस्य समयजटिलता अस्ति ओ ( ∣ वि ∣ + ∣ ई ∣ ) ओ(|व| + |ई|)ओ(∣वि∣+∣ई∣), तथा च समीपतामात्रिकप्रतिपादनस्य कृते, ट्रांसपोज-एल्गोरिदमस्य समयजटिलता अस्ति हे ( ∣ वि ∣ २ ) ओ(|V|^2) .ओ(∣वि∣2) .व्यावहारिकप्रयोगेषु यदि आलेखः तुल्यकालिकरूपेण विरलः भवति (अर्थात् । ∣ ई ∣ |ई|∣ई∣अपेक्षया बहु लघुतरम् ∣ वि ∣ २ |व|^२∣वि∣2 ), समीपतालिङ्कितसूचीप्रतिपादनस्य उपयोगः अधिकं कार्यक्षमः भविष्यति ।यदि आलेखः सघनः (अर्थात्। ∣ ई ∣ |ई|∣ई∣समीपः ∣ वि ∣ २ |व|^२∣वि∣2), तर्हि समीपतामात्रिकप्रतिपादनं अधिकं उपयुक्तं भवेत् ।

प्रज्ञा वर्णक्रम स्पष्ट शब्द : १.

आलेखप्रतिपादने, समीपतालिङ्क्ड् सूचीः, समीपतामात्रिका च द्वौ अपि सामान्यतया प्रयुक्तौ पद्धतौ स्तः । अनिर्देशित-निर्देशित-आलेखानां प्रतिनिधित्वार्थं समीपता-लिङ्क्-सूचीनां उपयोगः भवति, यदा तु समीपता-मात्रिकाणां उपयोगः प्रायः अनिर्देशित-आलेखानां प्रतिनिधित्वार्थं भवति । निर्देशितस्य आलेखस्य स्थानान्तरणार्थं वयं समीपतालिङ्कितसूचौ, समीपतामात्रिकायां च पृथक् कार्यं कर्तुं शक्नुमः ।

समीपता लिङ्क्ड् सूचीयाः स्थानान्तरणं कुर्वन्तु

समीपतालिङ्कितसूचया प्रतिनिधितस्य निर्देशितस्य आलेखस्य कृते मूललेखस्य प्रत्येकं शिखरं भ्रमित्वा मूललेखस्य बहिर्गच्छन्तीनां किनारेषु आगच्छन्तीषु किनारेषु परिवर्तनं कृत्वा आलेखस्य स्थानान्तरणं प्राप्तुं शक्यते

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

समीपता आकृति का स्थानान्तरण

समीपतामात्रिकायाः ​​प्रतिनिधित्वेन निर्देशितस्य आलेखस्य कृते मूललेखस्य प्रत्येकं पङ्क्तिं नूतनलेखस्य तत्सम्बद्धस्तम्भे परिणमयित्वा आलेखस्य स्थानान्तरणं कर्तुं शक्यते

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

एल्गोरिदम चलने समय विश्लेषण

  1. समीपतालिङ्कितसूचिकायाः ​​स्थानान्तरणार्थं एल्गोरिदमस्य समयजटिलता O(E) भवति, यत्र E आलेखे धारसङ्ख्या अस्ति । यतो हि प्रत्येकं धारं एकवारं भ्रमितव्यम् ।

  2. समीपतामात्रिकायाः ​​स्थानान्तरणार्थं एल्गोरिदमस्य समयजटिलता O(V^2) भवति, यत्र V आलेखे शिखरसङ्ख्या अस्ति । यतो हि प्रत्येकं आकृतितत्त्वं एकवारं भ्रमितुं आवश्यकं भवति, तथा च आकृतिः V×V भवति ।
    एते अल्गोरिदम् सर्वे कार्यकुशलाः, चालिताः च सन्ति

तिआङ्गोङ्गः : १.

निर्देशितं आलेखं गणयितुं एल्गोरिदम् कार्यान्वितुं जी.जीजी transposition of GTG^{T} ९.जीटी , वयं क्रमशः adjacency linked list तथा ​​adjacency matrix इत्येतयोः प्रतिनिधित्वद्वयं संसाधितुं शक्नुमः । अधः अहं क्रमशः एतयोः प्रकरणयोः एल्गोरिदम्स् वर्णयिष्यामि तथा च Go भाषायां कोड् उदाहरणानि प्रदास्यामि ।

समीपता लिङ्क्ड् सूची प्रतिनिधित्वम्

एल्गोरिदम-पदार्थाः : १.
  1. नूतनं समीपतासूचीं रचयन्तु newAdjList स्थानान्तरितलेखस्य संग्रहणार्थं प्रयुक्तम् ।
  2. मूलप्रतिबिम्बस्य समीपतालिङ्कितसूचीं भ्रमन्तु adjList。
  3. प्रत्येकं धारस्य कृते (u, v), योजयतु newAdjList[v] मध्यं।
  4. नूतनं समीपतासूचीं प्रत्यागच्छति newAdjList。
गो भाषासङ्केत उदाहरणम् : १.
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
रन टाइम विश्लेषण : १.

अस्य अल्गोरिदमस्य चालनसमयः O(|V| + |E|) अस्ति, यत्र |V| इति शिखरसङ्ख्या अस्ति तथा च |E|. यतो हि अस्माभिः सर्वाणि शिखराणि धाराणि च एकवारं भ्रमितव्यानि ।

समीपता आकृति संकेतन

एल्गोरिदम-पदार्थाः : १.
  1. नूतनं समीपतामात्रिकां रचयन्तु newAdjMatrix स्थानान्तरितलेखस्य संग्रहणार्थं प्रयुक्तम् ।
  2. मूलबिम्बस्य समीपतामात्रिकां भ्रमन्तु adjMatrix。
  3. प्रत्येकं तत्त्वस्य कृते adjMatrix[i][j], तस्य नियुक्तिः newAdjMatrix[j][i]。
  4. नूतनं समीपतामात्रिकां प्रत्यागच्छति newAdjMatrix。
गो भाषासङ्केत उदाहरणम् : १.
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
रन टाइम विश्लेषण : १.

अस्य अल्गोरिदमस्य चालनसमयः O(|V|^2) अस्ति, यत्र |V| इति शिखरसङ्ख्या अस्ति । यतो हि अस्माभिः सम्पूर्णं समीपतामात्रिकं भ्रमितव्यं, समीपतामात्रिकायाः ​​आकारः च |V|.

उपर्युक्तं कोड उदाहरणं केवलं एल्गोरिदम् इत्यस्य मूलभागः अस्ति वास्तविक-अनुप्रयोगेषु अन्यकार्यं यथा त्रुटि-नियन्त्रणं, निवेशः, निर्गमः च योजयितुं आवश्यकाः भवितुम् अर्हन्ति । तदतिरिक्तं कोडस्य सरलीकरणाय कल्प्यते यत् आलेखे पुनरावृत्तिधाराः नास्ति तथा च शिखरसङ्ख्याः 0 तः आरभ्य क्रमेण संख्याकृताः सन्ति

chatgpt: ९.

निम्नलिखितम् एकः एल्गोरिदम् अस्ति यः आलेख G तः G^T गणयितुं Go भाषायां लिखितः अस्ति, तदनुरूपं समीपता लिङ्क् कृतसूची तथा समीपता मैट्रिक्स प्रतिनिधित्वविधयः अपि दत्ताः सन्ति:

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

अस्य अल्गोरिदमस्य समयजटिलता O(V + E) अस्ति, यत्र V शिखरसङ्ख्या, E च धारसङ्ख्या । स्थानान्तरितलेखस्य निर्माणप्रक्रियायां मूललेखस्य सर्वान् किनारेन् भ्रमित्वा विपर्यस्तरूपेण स्थानान्तरितलेखे योजयितुं आवश्यकं भवति, अतः कुलसमयजटिलता शिखरस्य धारयोः च संख्यायाः आनुपातिकं भवति

किमिः ९.

निर्देशित-लेखानां स्थानान्तरित-आलेखाः मुख्यतया द्वयोः आँकडा-संरचनयोः प्रतिनिधित्वं कर्तुं शक्यन्ते: समीपता-लिङ्क्-सूचिकाः, समीपता-मात्रिकाः च । अधः अहं क्रमशः एतयोः प्रकरणयोः एल्गोरिदम्स् परिचययिष्यामि तथा च Go भाषायां नमूनासङ्केतं प्रदास्यामि ।

समीपता लिङ्क्ड् सूची प्रतिनिधित्वम्

समीपता लिङ्क्ड् सूचीद्वारा प्रतिनिधितस्य आलेखस्य कृते वयं प्रत्येकस्य शिखरस्य समीपतासूचीं भ्रमित्वा ततः प्रत्येकस्मिन् समीपताबिन्दौ विपरीतधारं योजयित्वा आलेखं स्थानान्तरयितुं शक्नुमः अस्याः पद्धतेः कालजटिलता O(V + E) भवति, यत्र V शिखरसङ्ख्या, E च धारसङ्ख्या ।

गो भाषा नमूनासङ्केतः : १.
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

समीपता मैट्रिक्स प्रतिनिधित्व

adjacency matrix द्वारा प्रतिनिधितस्य graph कृते वयं matrix इत्यस्य पङ्क्तयः स्तम्भान् च स्वैप् कृत्वा transpose इत्येतत् कार्यान्वितुं शक्नुमः । अस्य पद्धतेः कालजटिलता O(V^2) अस्ति ।

गो भाषा नमूनासङ्केतः : १.
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

एल्गोरिदम का विश्लेषण

  • समीपता सूची : एल्गोरिदम् प्रत्येकस्य शिखरस्य समीपतासूचीं भ्रमितुं आवश्यकं भवति, प्रत्येकस्य धारस्य कृते समीपस्थस्य बिन्दुस्य समीपतासूचौ विपरीतधारं योजयितुं आवश्यकम् यदि प्रतिवेशिनः सूचीयाः औसतदीर्घता k भवति तर्हि एल्गोरिदमस्य समयजटिलता O(V + E * k) भवति । दुर्भाग्यपूर्णे सति k V इत्यस्य समीपे भवितुम् अर्हति, समयजटिलता च O(V^2) इत्यस्य समीपे भवति । उत्तमसन्दर्भे k 1 इत्यस्य समीपे भवति तथा च समयजटिलता O(E) इत्यस्य समीपे भवति ।
  • समीपतामात्रिका : एल्गोरिदम् इत्यनेन मैट्रिक्सस्य प्रत्येकं तत्त्वं गत्वा पङ्क्तयः स्तम्भाः च स्वैप् कर्तुं आवश्यकम् अस्ति । यतः आकृतिः VxV अस्ति, तस्मात् समयजटिलता O(V^2) अस्ति ।

व्यावहारिकप्रयोगेषु कः एल्गोरिदम् चयनं कर्तव्यः इति आलेखस्य विरलतायाः उपलब्धस्मृतेः च उपरि निर्भरं भवति । विरल आलेखानां कृते, समीपतालिङ्कितसूचिकाः अधिकं स्मृतिकुशलाः भवितुम् अर्हन्ति;

हुन्युआन् : १.

निर्देशितं आलेखं गणयितुं जी = ( वि , ई ) ग=(वि,ई) .जी=(वि,ई) transposition of GT = ( V , ET ) G^T=(V,E^T) 1 .जीटी=(वि,ईटी), वयं क्रमशः adjacency linked list तथा ​​adjacency matrix इत्येतयोः प्रतिनिधित्वविधयोः कृते तदनुरूपं एल्गोरिदम् दातुं शक्नुमः, तथा च तेषां चालनसमयस्य विश्लेषणं कर्तुं शक्नुमः ।

समीपता लिङ्क्ड् सूची प्रतिनिधित्वम्

एल्गोरिदम वर्णन
  1. स्थानान्तरितस्य आलेखस्य किनारेषु संग्रहणार्थं रिक्तं समीपतासूचीं आरभत ।
  2. मूलप्रतिबिम्बं भ्रमन्तु जी.जीजी सर्वेषां नोडानां ।
  3. प्रत्येकं नोडस्य कृते उउउ, तस्य समीपस्थतासूचौ सर्वाणि समीपस्थानि नोड्-अवलोकयति विववि。
  4. तः नूतनं समीपतासूचीं योजयन्तु विववि आगच्छति उउउ पृष्ठभाग।
  5. भ्रमणं सम्पन्नं कृत्वा नूतना समीपतालिङ्किता सूची स्थानान्तरितलेखः भवति GTG^Tजीटी。
समय विश्लेषणं चालयन्तु
  • कालजटिलता : १. ओ ( ∣ ई ∣ ) ओ(|ई|)ओ(∣ई∣),इत्यस्मिन्‌ ∣ ई ∣ |ई|∣ई∣ मूलबिम्बस्य पार्श्वसङ्ख्या इति । यतः अस्माभिः प्रत्येकं धारं द्विवारं (एकवारं पठितुं एकवारं च लिखितुं) भ्रमितव्यम् ।

समीपता आकृति संकेतन

एल्गोरिदम वर्णन
  1. स्थानान्तरितस्य आलेखस्य किनारेषु संग्रहणार्थं मूललेखस्य समानप्रमाणस्य समीपतामात्रिकायाः ​​आरम्भं कुर्वन्तु ।
  2. मूलप्रतिबिम्बं भ्रमन्तु जी.जीजी समीपतामात्रिका।
  3. आकृतौ प्रत्येकं शून्यरहिततत्त्वस्य कृते (अर्थात् धारः अस्ति ( उ , व ) (उ, व) २.(उ,वि)), स्थानान्तरितलेखस्य समीपतामात्रिकायां तदनुरूपस्थानं ( व , उ ) (व, उ) ९.(वि,उ) शून्यरहिततत्त्वे सेट् कुर्वन्तु ।
  4. भ्रमणं सम्पन्नं कृत्वा नूतनं समीपतामात्रिका स्थानान्तरितलेखः भवति GTG^Tजीटी。
समय विश्लेषणं चालयन्तु
  • कालजटिलता : १. हे ( ∣ वि ∣ २ ) ओ(|V|^2) .ओ(∣वि∣2),इत्यस्मिन्‌ ∣ वि ∣ |व|∣वि∣ मूललेखे नोडसङ्ख्या अस्ति । यतः अस्माभिः सम्पूर्णं समीपतामात्रिकां भ्रमितव्यम् ।

गो भाषा कार्यान्वयनम् (समीपस्थं लिङ्क् कृतसूचीप्रतिनिधित्वं) २.

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

अस्मिन् कोड् मध्ये वयं a इति परिभाषयामः Edge धाराणां प्रतिनिधित्वं कर्तुं संरचना, and aAdjacencyList समीपतालिङ्कितसूचीं प्रतिनिधितुं संरचना ।TransposeGraph कार्यं स्वीकुर्वति कAdjacencyList type parameter तथा च तस्य transposed graph इत्यस्य adjacency linked list representation प्रेषयति ।अस्तिmain function, वयं उदाहरणं graph रचयामः, तस्य transposed graph इत्यस्य गणनां कृत्वा मुद्रयामः ।

व्यक्तिगत प्रोफाइल

सः ३० वर्षाणाम् अधिकं कालात् प्रौद्योगिक्याः शोधकार्यं कर्तुं समर्पितः अस्ति, तथा च जावा, लिनक्स, जावास्क्रिप्ट्, php, css इत्यादिषु विविधभाषासु प्रवीणः अस्ति, मुक्तस्रोतक्षेत्रे सः बहु योगदानं कृतवान् अस्ति विकासक दस्तावेजीकरणस्थानकं भविष्ये सन्दर्भार्थं प्रौद्योगिकीविकासे केचन विषयाः साझां कर्तुं सर्वे तत् पश्यन्तु

मम सम्पर्कसूचना

मेल