hdu 2544 最短路 解题报告

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2544

题目意思：给出 n 个路口和 m 条路，每一条路需要 c 分钟走过。问从路口 1 到路口 n 需要的最短时间是多少。

      这题是最短路的入门题，从理解d-i--j---k（wg自创的，呵呵）到默打到修改，搞左两日终于好了，哈哈哈~~~太感动了。

     第一次错是 少了Dijkstra()函数中的 for (j = 1; j <= n; j++) 。

     第二次错是把vis[k=j]=1 写在了 if (!vis[j] && dist[j] < mini) 里面。

     好好总结自己的错误，以后应该能避免了。（做完郑多燕后，灵感翻来了，成日系实验室里对住堆恶心的实验报告兼做5成功，有种令人想死的感觉，忽略忽略）

     顺便帮大家普及下科学知识，经过我的搜罗，

   dijkstra /ˈdɛɪkstra/

      别读成 d  - i - j -k 了

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;

#define INF 100000000
const int maxn = 100 + 10;
int dist[maxn], map[maxn][maxn], vis[maxn];
int n, m;

void Init()
{
    int i, j, st, en, cost;
    for (i = 1; i <= n; i++)
        dist[i] = (i == 1 ? 0 : INF);
    memset(vis, 0, sizeof(vis));
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
            map[i][j] = INF;  // 这样也行：map[i][j] = map[j][i] = (i == j ? 0 : INF);
    }
    for (i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &st, &en, &cost);
        map[st][en] = map[en][st] = cost;   // 建立邻接矩阵
    }
}

void Dijkstra()
{
    int i, j, k, mini;
    for (i = 1; i <= n; i++)
    {
        mini = INF;
        for (j = 1; j <= n; j++)   // 这个循环是用来找出与第i个点最近的点（当然是直接有边相连）
        {
            if (!vis[j] && dist[j] < mini)
            {
                mini = dist[j];
                k = j;
            }
        }
        vis[k] = 1;     // 如果把这句放在上面的if里面，就会把有些不该被标记已经过的点置1了，实质只需要置距离i点最短的那个点
        for (j = 1; j <= n; j++)
        {
            if (dist[j] > mini + map[k][j])   // mini其实就是dist[k],mini + map[k][j]表示绕过k点走到j点的路径会不会比直接不绕过k要短
                dist[j] = mini + map[k][j];  // dist[j] = dist[k]+ map[k][j;
        }
    }
}

int main()
{
    while(scanf("%d%d", &n, &m) && (m || n))
    {
        Init();
        Dijkstra();
        printf("%d
", dist[n]);
    }
    return 0;
}

   

    邻接表 + 优先队列 + dijkstra （好强大，^_^）

    http://mindlee.net/2011/11/18/shortest-paths-algorithm/

    

#include <iostream>
#include <cstdio>
#include <cstring>
#include <climits>   // 定义各种数据类型最值得常量，如下面的INF_MAX: 2147483647
#include <queue>
using namespace std;

const int NV = 100 + 5;
const int NE = 2e4 + 5;

int n, m;

struct Dijkstra
{
    int n, size;
    int dis[NV], head[NV];
    int mark[NV];

    struct node
    {
        int v, dis;
        node() {}
        node(int V, int DIS): v(V), dis(DIS){}
        friend bool operator < (const node a, const node b)
        {
            return a.dis > b.dis;   // 结构体中，dis小的优先级高
        }
    };

    struct edge
    {
        int v, w, next;
        edge() {}
        edge(int V, int W, int NEXT): v(V), w(W), next(NEXT) {}
    }E[NE];

    inline void init(int vx)
    {
        n = vx, size = 0;
        memset(head, -1, sizeof(int)*(vx+1));
    }

    inline void insert(int u, int v, int w)
    {
        E[size] = edge(v, w, head[u]);  // E[size]. v = u, E[size].w = v, E[size].next = head[u]
        head[u] = size++;
    }

/*    void print()  // 打印每个点的邻接表
    {
        for (int i = 0; i < n; i++)
        {
            printf("%d: ", i);
            for (int j = head[i]; j != -1; j = E[j].next)
            {
                printf(" %d", E[j].v);
            }
            printf("
");
        }
    }
*/
    int dijkstra(int src, int des)   // src: 0  des: n-1
    {
        node first, next;
        priority_queue<node> Q;
        for (int i = 0; i <= n; i++)
        {
            dis[i] = INT_MAX;
            mark[i] = false;
        }
        dis[src] = 0;
        Q.push(node(src, 0));   // 把起始点入队

        while (!Q.empty())
        {
            first = Q.top();
            Q.pop();
            mark[first.v] = true;

            for (int i = head[first.v]; i != -1; i = E[i].next)
            {
                if (!mark[E[i].v])
                {
                    next = node(E[i].v, first.dis + E[i].w);
                    if (next.dis < dis[next.v])
                    {
                        dis[next.v] = next.dis;
                        Q.push(next);
                    }
                }
            }      // end for
        }     // end while
        return dis[des];
    }     // end dijkstra
}G;

int main()
{
    while (scanf("%d%d", &n, &m) != EOF && (m + n))
    {
        G.init(n);
        while (m--)
        {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            G.insert(u-1, v-1, w);
            G.insert(v-1, u-1, w);
        }
    //    G.print();
        printf("%d
", G.dijkstra(0, n-1));
    }
    return 0;
}

 Spfa + 邻接矩阵

    

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

const int INF = 1e9;
const int maxn = 100 + 5;
int dist[maxn], map[maxn][maxn];
bool mark[maxn];
int N, M;

int Spfa()
{
    for (int i = 1; i <= N; i++)
    {
        mark[i] = false;
        dist[i] = INF;
    }
    queue<int> Q;
    dist[1] = 0;
    mark[1] = true;
    Q.push(1);

    while (!Q.empty())
    {
        int first = Q.front();
        Q.pop();
        mark[first] = false;

        for (int i = 1; i <= N; i++)
        {
            if (dist[first] + map[first][i] < dist[i])
            {
                if (!mark[i])
                {
                    Q.push(i);
                    mark[i] = true;    // mark 写在dist[i] 下一行也能过
                }
                dist[i] = dist[first] + map[first][i];
                //  mark[i] = true;
            }
        }
    }
    return dist[N];
}

int main()
{
    while (scanf("%d%d", &N, &M) != EOF && (N+M))
    {
        int A, B, C;
        for (int i = 1; i <= N; i++)
        {
            map[i][i] = INF;
            for (int j = i+1; j <= N; j++)
                map[i][j] = map[j][i] = INF;    // 双向边！！！
        }
        while (M--)
        {
            scanf("%d%d%d", &A, &B, &C);
            map[A][B] = map[B][A] = C;
        }
        printf("%d
", Spfa());
    }
    return 0;
}

     顺便写写：1874

    

scanf("%d%d", &st, &en);    // st：起点  en：终点
for (int i = 0; i < n; i++)
{
dist[i] = map[st][i];     // 构建起点到其他点之间的距离，INF代表不可达
}

输出注意下即可：printf("%d ", dist[en] == INF ? -1 : dist[en]);