图论 最短路专辑

先上总结构图

1 首先来看Dijkstra

#include <iostream>
#include <algorithm>
#include <memory.h>


using namespace std;

const int N = 550;
int n , m ;
int g[N][N];
int dist[N];
bool st[N];


int dijkstra()
{
   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;      //更换为更小的dist
       }
       
       st[t] = true;
       
       //用t来更新其他点的dist
       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(){
    scanf("%d %d",&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 = dijkstra();
    
    cout<< t << endl;
    
    
    
    return 0;
}
*/
int main()
{
    scanf("%d%d", &n, &m);

    memset(g, 0x3f, sizeof g);
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);

        g[a][b] = min(g[a][b], c);
    }

    printf("%d
", dijkstra());

    return 0;
}

2 bellman_ford

 优势在于 可以求出使用K次边的情况下的最短路径 

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

using namespace std;


const int N = 510; 
const int M = 10010;

int n,m,k;
int dist[N],backup[N];

struct Edge{
    int a, b,w;
}edges[M];

int bellman_ford()
{
    memset(dist,0x3f,sizeof(dist));
    dist[1] = 0; 
    
    for(int i = 0; i < k;i ++){
        memcpy(backup,dist,sizeof(backup));
        for(int j = 0; j < m;j++){
            int a = edges[j].a,b= edges[j].b,w = edges[j].w;
            dist[b] = min(dist[b],backup[a]+w);
        }
    }
    
    //更新过程中 无穷可能会减少或者一部分 所以未必就一定等于 0x3f3f3f3f
    if(dist[n] > 0x3f3f3f/2) return -1;
    
    return dist[n];
}




int main()
{
    scanf("%d%d%d",&n,&m,&k);
    
    for(int i = 0; i < m;i++){
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        edges[i] = {a,b,w};
    }
    
    int t = bellman_ford();
    
    if(t == -1) printf("impossible");
    else printf("%d
",t);
    
    return 0;
}

3 Floyd

两点之间的最短路肯定是引进了第三方点的路线比现在的更短。

所以 三个循环得到最短路径  次序不能颠倒 K是第三方点 只有尝试过其他 ij后，才能确定当前K点路径是最小值 才能进行以后点的遍历

#include <iostream>
#include <algorithm>

using namespace std;


const int N = 200;

int n,m,q;
int d[N][N];
int INF = 1e9;


void floyd(){
    for(int k = 1;k <=n;k++)
        for(int i = 1;i<=n;i++)
            for(int j = 1;j <= n;j++)
                d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
                
}



int main()
{
   scanf("%d%d%d",&n,&m,&q);
   
   for(int i = 0; i <= n;i++){
        for(int j = 0; j <=n;j++){
            if(i == j) d[i][j] = 0;
            else d[i][j] = INF;
        }       
   }
    
    while(m--){
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        
        d[a][b] = min(d[a][b],w);
    }
        
    floyd();
    
    while(q--){
        int a,b;
        scanf("%d%d",&a,&b);
        if(d[a][b] > INF/2) printf("impossible
");
        else printf("%d
",d[a][b]);
        
    }
    
    return 0;
}

4 spfa

#include <iostream>
#include <string>


using namespace std;

//更新过谁 再拿谁去更新别人

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

using namespace std;

const int N = 100010;

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 spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        int t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    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);
    }

    int t = spfa();

    if (t == 0x3f3f3f3f) puts("impossible");
    else printf("%d
", t);

    return 0;
}