Dijkstra算法and Floyd算法 HDU 1874 畅通工程续

Dijkstra算法描述起来比较容易：它是求单源最短路径的，也就是求某一个点到其他各个点的最短路径，大体思想和prim算法差不多，有个数组dis，用来保存源点到其它各个点的距离，刚开始很好办，只需要把邻接矩阵里面它到其它点的距离复制过来就行了。剩下的步骤就是找到一个源点到其他点最小的距离，将它加入到已经确定下来的最短距离中，接着更新其他点到源点的距离，因为确定了一些点的最近距离之后，那么到其它未确定的点的距离可能会变小，所以更新一下。

理论完了 就要实践：http://acm.hdu.edu.cn/showproblem.php?pid=1874

AC代码：

#include<iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 204;
const int INFINITY = 999999999;
int Map[N][N];
void init(int n)
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            Map[i][j] = INFINITY;
}
//v0代表源点，n是总数，dis数组表示到其他点的距离
void dijkstra(int v0, int n, int dis[])
{
    //标记是否已经找到最短距离
    bool Final[n];
    memset(Final, false, sizeof(Final));
    for (int i = 0; i < n; i++)
        dis[i] = Map[v0][i];
    dis[v0] = 0;
    //源点已经找到
    Final[v0] = true;
    int min_dis;
    for (int i = 1; i < n; i++)
    {
        min_dis = INFINITY;//找剩下的所有点中最小的一个
        int k = 0;
        for (int j = 0; j < n; j++)
        {
            if (!Final[j] && dis[j] < min_dis)
            {
                min_dis = dis[j];
                k = j;
            }
        }
        //如果最小的存在，就将它标记已经找到最短距离
        if (min_dis < INFINITY)
            Final[k] = true;
        else
            break;//如果找不到最小的，就是不连通图
        for (int j = 0; j < n; j++)//更新其他点到它的距离
        {
            if (!Final[j] && min_dis + Map[k][j] < dis[j])
            {
                dis[j] = min_dis + Map[k][j];
            }
        }
    }
}
int main()
{
    int n, m;
    while (~scanf("%d %d", &n, &m))
    {
        init(n);
        int a, b, x;
        for (int i = 0; i < m; i++)
        {
            scanf("%d %d %d", &a, &b, &x);
            //两个城市之间的道路可能有多条，取最小的那条
            if (Map[a][b] > x)
                Map[a][b] = Map[b][a] = x;
        }
        int s, e;
        scanf("%d %d", &s, &e);
        int ans[n];
        dijkstra(s, n, ans);
        if (ans[e] < INFINITY)
            printf("%d
", ans[e]);
        else
            puts("-1");
    }


    return 0;
}

 如果求任意两点之间的最短距离的话，Dijkstra的时间复杂度是O（n^3），用Floyd的话也是O（n^3），但是代码更简洁，更稠密的图实际运行效率更快。它的主要思路就是：因为求任意两点之间的最短距离，那么它得用一个二维数组来实现，其实这个二位数组就可以用邻接矩阵来表示，刚开始是一个点到另外一个点的直接距离，直接距离就是指不经过第三个点可以的距离，算法的整个精髓就是，求点v->w的最短距离，用另外一个点来作为中间点，求v->u>w的距离，如果后者的距离小于前者的距离，就更新v->w的距离。代码一共三层for循环，第一层的意思就是除了这行这列的之外的任意两点之间的距离 通过这个点来作为中间点，一共n个点，所以循环n次，二三两层for循环是从第二个for循环里的点到第三个for循环里的点与通过中间点就行比较。核心代码如下：

void Floyd(int n)
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            for (int k = 0; k < n; k++)
                if (Map[j][i] + Map[i][k] < Map[j][k])
                    Map[j][k] = Map[j][i] + Map[i][k];
}

还是这个题，附AC代码：

#include<iostream>
#include <cstdio>
using namespace std;
const int N = 203;
const int INFINITY = 999999999;
int Map[N][N];
void init(int n)
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (i != j)
                Map[i][j] = INFINITY;
}
void Floyd(int n)
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            for (int k = 0; k < n; k++)
                if (Map[j][i] + Map[i][k] < Map[j][k])
                    Map[j][k] = Map[j][i] + Map[i][k];
}
int main()
{
    int n, m;
    while (~scanf("%d %d", &n, &m))
    {
        init(n);
        int a, b, x;
        for (int i = 0; i < m; i++)
        {
            scanf("%d %d %d", &a, &b, &x);
            if (Map[a][b] > x)
            {
                Map[a][b] = Map[b][a] = x;
            }
        }
        Floyd(n);
        int s, e;
        scanf("%d %d", &s, &e);
        if (Map[s][e] < INFINITY)
            printf("%d
", Map[s][e]);
        else
            puts("-1");
    }

    return 0;
}