单源最短路算法 Dijstra Bellman-Ford

SDUT oj  2143

以此题为例
看一下DJ算法

先讲一下什么叫松弛。。
比方说1到4是可直达的，边权是6；
但发现从1到3 再到4这条路的权更小为5；那么更新1到4的权值为5；大体就是这个意思

#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
int t[105][105];//存点，存线
int dis[105];记录单源到各个点的最小权值
int vis[105];标记是否已经走过这个点
void DJ(int n)
{
    memset(vis,0,sizeof(vis));
    for(int i=1; i<=n; i++)//先用dis存从源头开始的所能到达的地方的权值
    {
        dis[i]=t[1][i];//此题目是将1作为源头
    }
    vis[1]=1;//标记走过
    int ans=0;//算总权值（单元出发走遍全图）
    for(int i=2; i<=n; i++)//源头开始，只要再找n-1个点就可以
    {
        int pos=i;//记录与当前点连接的是最小权的点
        int M=INF;//标记最小权
        for(int j=1; j<=n; j++)
        {
            if(!vis[j]&&M>dis[j])//点没走过且为更小权，则更新
            {
                M=dis[j];
                pos=j;
            }
        }
        if(M==INF)//如果发现权值没有更新，说明不是连通图
        return -1;
       vis[pos]=1;//标记走过
        ans+=M;//加上这个权值
        for(int j=1; j<=n; j++)//更关键的松弛操作
        {
            if(!vis[j])//前提是没走过的点
            {
                if(dis[j]>(M+t[pos][j]))
                {
                    dis[j]=M+t[pos][j];
                }
            }
        }
    }
}
int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        for(int i=0; i<=n; i++)//我觉得只要是最短路的题目，都要给图一个初始化
            for(int j=0; j<=n; j++)
                t[i][j]=(i==j?0:INF);
        while(m--)
        {
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);//存点，存线
            if(t[u][v]>w)
                t[v][u]=t[u][v]=w;//无向图
        }
        DJ(n);
        printf("%d\n",dis[n]);
    }
}

SDUT 2894

以此题为例讲一下BellmanFrod(程序部分借鉴了别的博主)

对于这个算法，比较好的地方就是可以解决像这个数据量特大的题目，开不了那么大的二维数组的

#include <stdio.h>
#define INF 0x3f3f3f3f
int dis[500004];//记录从源头到某点的最小权
int u[4000004]起点, v[4000004]终点, w[4000004]边权;
int main()
{
    int n, m, i, k, s, e, flag, t;
    while(scanf("%d %d", &n, &m) != EOF)
    {
        int x, y, z;
        t = 1;
        for(i = 1; i <= m; i++)
        {
            scanf("%d %d %d", &x, &y, &z);//此题为无向图，所以连接的两点间会有两个“边”；
            u[t] = x, v[t] = y, w[t] = z;
            t++;
            u[t] = y, v[t] = x, w[t] = z;
            t++;
        }
        scanf("%d %d", &s, &e);//输入起点和终点，bellmanford可以去求任意两点间的最短路

        for(i = 1; i <= n; i++)//对于图的预处理，和DJ算法的不用点，BF是要起点为0 其余为INF；
            dis[i] = INF;
        dis[s] = 0;
        for(k = 0; k < n-1; k++)//算法主要内容
        {
            x= 0;
            for(i = 1; i <= m*2; i++)//因为是无向图，所以边数*2；
            {
                if(dis[v[i]] > dis[u[i]] + w[i])//松弛，
                {
                    dis[v[i]] = dis[u[i]] + w[i];
                    x = 1;
                }
            }
            if(x == 0)
                break;
        }
        flag = 0;
        for(i = 1; i <= m; i++)//判断是否有负边权
        {
            if(dis[v[i]] > dis[u[i]] + w[i])//经过松弛后，如果仍然比加上某边权还小，那么一定存在负边权
                flag = 1;
        }
        if(flag)
            printf("NO PATH\n");
        else
            printf("%d\n", dis[e]);
    }
    return 0;
}