Dalam graf berwajaran terarah, cari laluan terpendek yang mengandungi tepat k tepi.

Dalam graf berwajaran yang diselaraskan, masalah mencari laluan terpendek dengan tepat tepi k melibatkan penentuan laluan dengan berat terkecil semasa menavigasi tepat k tepi. Ini akan dicapai dengan menggunakan strategi pengaturcaraan dinamik, seperti menggunakan rangka kerja 3D untuk menyimpan pemberat minimum dalam semua cara yang boleh difikirkan. Pengiraan diulang pada bucu dan tepi, melaraskan berat minimum pada setiap langkah. Dengan mempertimbangkan semua cara yang mungkin untuk mempunyai tepi k yang tepat, pengiraan boleh membezakan cara yang paling terhad untuk mempunyai tepi k dalam graf.

Kaedah penggunaan

• Kaedah rekursif naif

• Algoritma Dijkstra dengan kekangan tepi

Kaedah rekursif naif

Kaedah rekursif naif boleh menjadi strategi penting dan jelas untuk penyelesaian masalah, yang terdiri daripada menguraikan masalah kompleks kepada sub-masalah yang lebih kecil dan menyelesaikannya secara rekursif. Dalam pendekatan ini, kerja memanggil dirinya beberapa kali untuk meneroka submasalah sehingga kes asas dicapai. Walau bagaimanapun, ia boleh membazir untuk masalah yang lebih besar kerana pengiraan dua kali dan meliputi submasalah. Ia memerlukan kaedah pengoptimuman seperti memori atau pengaturcaraan tenaga. Kaedah rekursif mudah tertipu mudah diperoleh dan dilaksanakan, tetapi mungkin mengalami kerumitan masa eksponen. Ia sering digunakan untuk menyelesaikan masalah berskala kecil atau sebagai titik permulaan untuk pengiraan yang lebih optimum.

Algoritma

• Mewakili laluan terpendek yang berfungsi (graf, u, v, k) yang mengambil sebagai input graf, bucu sumber u, bucu sasaran v dan bilangan tepi k.

• Semak situasi asas:

• a. Kembalikan jika k dan u pulang modal dengan v (kerana tiada tepi dibenarkan dalam kes ini).

• Yang kedua. Jika k ialah 1 dan terdapat tepi antara u dan v dalam graf, beratnya dikembalikan.

• c Jika k kurang daripada atau sama dengan 0, kembalikan tanpa sempadan (kerana tepi negatif atau sifar tidak dibenarkan).

• Mulakan pembolehubah tak terhingga untuk menyimpan jarak laluan terpendek.

• Graf harus berulang ke atas semua bucu seperti berikut:

• a. Jika anda dan saya tidak menyamai anda atau v, maka wujud kelebihan daripada anda kepada saya:

• Panggil shortestPath secara rekursif, dengan i ialah bucu sumber moden, v ialah bucu sasaran dan k−1 ialah bilangan tepi yang tinggal.

• Jika hasil yang dikembalikan tidak terhingga, res dinaik taraf kepada nilai minimum res dan berat tepi semasa dan hasil rekursif.

• Kembalikan nilai res sebagai cara paling terhad untuk mengasingkan tepi k dengan tepat.

Contoh

#include <iostream>
#include <climits>

#define V 4
#define INF INT_MAX

int shortestPathWithKEdges(int graph[][V], int source, int destination, int k) {
    // Base cases
    if (k == 0 && source == destination)
        return 0;
    if (k == 1 && graph[source][destination] != INF)
        return graph[source][destination];
    if (k <= 0)
        return INF;

    // Initialize result
    int shortestPathDistance = INF;

    // Explore all adjacent vertices of the source vertex
    for (int i = 0; i < V; i++) {
        if (graph[source][i] != INF && source != i && destination != i) {
            int recursiveDistance = shortestPathWithKEdges(graph, i, destination, k - 1);
            if (recursiveDistance != INF)
                shortestPathDistance = std::min(shortestPathDistance, graph[source][i] + recursiveDistance);
        }
    }

    return shortestPathDistance;
}

int main() {
    int graph[V][V] = {
        {0, 10, 3, 2},
        {INF, 0, INF, 7},
        {INF, INF, 0, 6},
        {INF, INF, INF, 0}
    };
    int source = 0, destination = 3, k = 2;
    std::cout << "Weight of the shortest path is " << shortestPathWithKEdges(graph, source, destination, k) << std::endl;
    return 0;
}

Output

Weight of the shortest path is 9

Algoritma Dijkstra dengan kekangan tepi

Algoritma Dijkstra dengan kekangan tepi ialah pengiraan traversal graf yang digunakan untuk mengenal pasti laluan terpendek antara bucu sumber dan semua bucu lain pada graf. Ia mengambil kira had atau kekangan pada tepi graf, seperti pemberat tepi yang paling atau paling sedikit. Pengiraan mengekalkan garis bucu yang diperlukan dan secara berulang memilih bucu paling sedikit untuk dialih keluar. Pada ketika ini, jika laluan yang lebih pendek ditemui, ia melonggarkan bucu bersebelahan dengan meningkatkan jarak antara mereka. Penyediaan ini berterusan sehingga semua bucu telah dilawati. Algoritma Dijkstra dengan arahan tepi menjamin bahawa cara yang dipilih memenuhi kekangan tepi yang diperlukan sambil mencari cara yang paling terhad

Algoritma

• Gunakan parameter berikut untuk mencipta karya seni Dijkstra

• Graf: graf input dengan bucu dan tepi

  Sumber: permulaan puncak laluan paling terhad

  Kekangan: Had atau halangan di tepi

  Mulakan satu set bucu yang hilang dan garis permintaan untuk menyimpan bucu dan jaraknya.

• Buat gugusan pemadaman dan tetapkan pemadaman kepada penamatan untuk semua bucu kecuali bucu sumber, yang ditetapkan kepada 0.

• Susun bucu sumber ke dalam baris yang dikehendaki dengan jaraknya.

• Walaupun saluran paip permintaan tidak boleh dibersihkan, sila lakukan perkara berikut:

• Turunkan bucu dengan bilangan penyingkiran paling sedikit daripada baris gilir yang diingini.

• Jika puncak tidak lagi dilawati sekarang,

• Tandai sebagai dilawati.

• Untuk setiap bucu bersebelahan bucu moden:

• Gunakan halangan tepi untuk menentukan sama ada kelebihan boleh dipertimbangkan.

• Kira jarak yang tidak digunakan dari menyuap bucu ke bucu bersebelahan dengan mengambil kira berat tepi dan kekangan.

• Tingkatkan tatasusunan pembatas jika pembatas semasa lebih pendek daripada pembatas moden.

• Bariskan bucu bersebelahan dengan jarak yang tidak digunakan ke dalam baris yang dikehendaki.

• Selepas semua bucu dicapai, kelompok berasingan akan mengandungi jarak pendek maksimum dari bucu bekalan ke setiap bucu yang memenuhi kekangan tepi.

• Kembalikan kelompok individu sebagai hasil.

示例

#include <iostream>
#include <vector>
#include <limits>

struct Edge {
    int destination;
    int weight;
};

void dijkstra(const std::vector<std::vector<Edge>>& graph, int source, std::vector<int>& distance) {
    int numVertices = graph.size();
    std::vector<bool> visited(numVertices, false);
    distance.resize(numVertices, std::numeric_limits<int>::max());
    distance[source] = 0;

    for (int i = 0; i < numVertices - 1; ++i) {
        int minDistance = std::numeric_limits<int>::max();
        int minVertex = -1;

        for (int v = 0; v < numVertices; ++v) {
            if (!visited[v] && distance[v] < minDistance) {
                minDistance = distance[v];
                minVertex = v;
            }
        }

        if (minVertex == -1)
            break;

        visited[minVertex] = true;

        for (const auto& edge : graph[minVertex]) {
            int destination = edge.destination;
            int weight = edge.weight;

            if (!visited[destination] && distance[minVertex] != std::numeric_limits<int>::max() &&
                distance[minVertex] + weight < distance[destination]) {
                distance[destination] = distance[minVertex] + weight;
            }
        }
    }
}

int main() {
    int numVertices = 4;
    int source = 0;
    std::vector<std::vector<Edge>> graph(numVertices);

    // Add edges to the graph (destination, weight)
    graph[0] = {{1, 10}, {2, 3}};
    graph[1] = {{2, 1}, {3, 7}};
    graph[2] = {{3, 6}};

    std::vector<int> distance;
    dijkstra(graph, source, distance);

    // Print the shortest distances from the source vertex
    std::cout << "Shortest distances from vertex " << source << ":\n";
    for (int i = 0; i < numVertices; ++i) {
        std::cout << "Vertex " << i << ": " << distance[i] << '\n';
    }

    return 0;
}

输出

Shortest distances from vertex 0:
Vertex 0: 0
Vertex 1: 10
Vertex 2: 3
Vertex 3: 9

结论

本文概述了两个重要的计算，以帮助理解协调和加权图表中的大多数问题。它阐明了易受骗的递归方法和带有边缘限制的 Dijkstra 计算。轻信递归方法包括递归地研究具有精确 k 个边的所有可能的方式，以发现最有限的方式。 Dijkstra 的边命令式计算采用了所需的线和面积规则，成功地找出了图表中从供给顶点到所有不同顶点的最大受限方式。本文包含了计算的具体说明，并给出了测试代码来说明其用法.

Atas ialah kandungan terperinci Dalam graf berwajaran terarah, cari laluan terpendek yang mengandungi tepat k tepi.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!