图论 算法

源：表示起点，汇表示终点

单源表示一个起点，到各个点的最短路径

多源汇最短路表示有m个样例求不同样例里不同起点，终点的最短路径

在这里n表示图的节点数，m表示图的边数

朴素dijkstra算法用于所有边权都是正数的稠密图

堆优化的dijkstra算法则用于所有边权都是正数的稀疏图

存在负权边，用spfa，若题目限制了节点的数量，则用bellman-ford算法。

多元汇最短路则用 floyd算法。

 

 1.稠密图用邻接矩阵来存，g[N][N]也就是二维数组

2.用一个一维int dist[N]数组来存起点到各个边的距离

3.再用一个一维bool st[N]数组来标记这个距离是否是起点到这个点的距离是最短的。

这道题有重边和自环

重边是两个节点之间可能有多条边，由于这里求的是最短路径，所以只用取最小的边。

自环对这道题没什么影响，

步骤：1.先将数组里面每个边的距离初始化维无穷   （0x3f表示无穷大）有些节点没有边所以定义为无穷大。

2.再进行赋值操作，重边的话就比较那个边较小。

3.把dist数组的距离初始化为无穷，起点的距离初始化为0；

4.因为有n个点所以要进行n次迭代。

 5.然后遍历数组找出距离最近的点，将他标记

6.for循环依次更新每个点的距离

7.最后特判一下是否为无穷

#include <iostream>
#include <cstring>
using namespace std;
const int N=510;
int g[N][N];
int dist[N];
bool st[N];
int n,m;
int dij(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<n;i++){
        int t=-1;
        for(int j=1;j<=n;j++){
            if(!st[j]&&(t==-1||dist[t]>dist[j])){
                t=j;
            }
        }
        st[t]=true;
    for(int j=1;j<=n;j++){
        dist[j]=min(dist[j],dist[t]+g[t][j]);
    }
        
    }
    if(dist[n]==0x3f3f3f3f)return -1;
    return dist[n];
    
}
int main(){
    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);
    }
    int t=dij();
    cout<<t;
    return 0;
}

堆优化的dijkstra算法

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 1e6 + 10;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    cout << dijkstra() << endl;

    return 0;
}

spfa算法不准有负环

因为可能沿着负环循环n次，变成无穷大