hdu2544 最短路径

*/-->

pre.src {background-color: Black; color: White;}

pre.src {background-color: Black; color: White;}

pre.src {background-color: Black; color: White;}

hdu2544 最短路径

http://acm.hdu.edu.cn/status.php

错误 1:inf 开太小
错误 2:spfa 最后忘记了 inQue[u] = 0;
错误 3:spfa

for (int i = 1; i <= n; i++) {
   while (g[i].size()) {
     g[i].pop_back();
   }
}
/* CreateTime: 2015-04-07 10:53:26 */

#include <cstdio>

int n;
int m;
int g[105][105];
const int inf = 0x3fffffff;
int dis[105];
int v[105];

int min(int a, int b) { if (a < b) return a; return b; }

void dij() {
    for (int i = 1; i <= n; i++) {
        dis[i] = inf;
        v[i] = 0;
    }
    dis[1] = 0;

    for (int i = 1; i <= n; i++) {
        int mark = -1;
        int mindir = inf;

        for (int j = 1; j <= n; j++) {
            if (!v[j] && dis[j] < mindir) {
                mark = j;
                mindir = dis[j];
            }
        }
        v[mark] = 1;
        for (int j = 1; j <= n; j++) {
            if (!v[j]) {
                dis[j] = min(dis[j], g[mark][j]+dis[mark]);
            }
        }
    }
}

int main(void) {
    while (scanf("%d%d", &n, &m) && n && m) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                g[i][j] = inf;
            }
        }
        for (int i = 1; i <= m; i++) {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            g[a][b] = g[b][a] = c;
        }
        dij();
        printf("%d\n", dis[n]);
    }

    return 0;
}
/* CreateTime: 2015-04-07 11:06:58 */

#include <cstdio>
#include <vector>
#include <queue>

using namespace std;

int n;
int m;
queue<int> que;
vector<pair<int, int> > g[105];
int dis[105];
const int inf = 0x3fffffff;
int inQue[105];

void spfa() {
    for (int i = 1; i <= n; i++) {
        dis[i] = inf;
    }

    while (!que.empty()) {
        que.pop();
    }

    que.push(1);
    inQue[1] = 1;
    dis[1] = 0;
    while (!que.empty()) {
        int u = que.front();
        que.pop();

        int num = g[u].size();
        for (int t = 0; t < num; t++) {
            int i = u;
            int j = g[u][t].first;
            int w = g[u][t].second;

            if (dis[i] + w < dis[j]) {
                dis[j] = dis[i] + w;
                if (!inQue[j]) {
                    inQue[j] = 1;
                    que.push(j);
                }
            }
        }
        inQue[u] = 0;
    }
}

int main(void) {
    while (scanf("%d%d", &n, &m) && n && m) {
        for (int i = 1; i <= n; i++) {
            while (g[i].size()) {
                g[i].pop_back();
            }
        }
        for (int i = 0; i < m; i++) {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            g[a].push_back(make_pair(b, c));
            g[b].push_back(make_pair(a, c));
        }
        spfa();
        printf("%d\n", dis[n]);
    }

    return 0;
}
/* CreateTime: 2015-04-07  11:43:01 */

#include <cstdio>

int g[105][105];

int n;
int m;

#define inf 0x3fffffff

int min(int a, int b) { if(a < b) return a; return b; }

void floy() {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            g[i][j] = inf;
        }
    }

    for (int i = 1; i <= m; i++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = g[b][a] = c;
    }

    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (g[i][k] < inf && g[k][j] < inf) {
                    g[i][j] = min(g[i][j], g[i][k]+g[k][j]);
                }
            }
        }
    }
}

int main(void) {
    while (scanf("%d%d", &n, &m) && n && m) {
        floy();
        printf("%d\n", g[1][n]);
    }

    return 0;
}
时间: 2024-10-23 12:40:47

hdu2544 最短路径的相关文章

Hdu2544 最短路径 四种方法

Problem Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗? Input 输入包括多组数据.每组数据第一行是两个整数N.M(N<=100,M<=10000),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路.N=M=0表示输入结束.接下来M行,每行包

最短路径之 Dijkstra模板

一:时间复杂度为O(V*V)的Dijkstra const int Max_v = 100 + 10; const int INF = 1<<30; int cost[Max_v][Max_v];//权值 int d[Max_v];//顶点s出发最短距离 bool used[Max_v];//以使用过的图 int V;//顶点数 int Edge;//边数 void dijkstra(int s) { fill(d,d+V,INF); fill(used,used+V,false); d[s]

ACM-最短路(SPFA,Dijkstra,Floyd)之最短路——hdu2544

***************************************转载请注明出处:http://blog.csdn.net/lttree*************************************** 最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 28761    Accepted Submissio

ACM: HDU 3790 最短路径问题-Dijkstra算法

HDU 3790 最短路径问题 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Input 输入n,m,点的编号是1~n,然后是m行,每行4个数 a,b,d,p,表示a和b之间有一条边,且其长度为d,花费为p.最后一行是

最短路径算法专题1----弗洛伊德

由于最短路径算法我认为比较重要,所以分成几个专题来慢慢细化去磨它,不能一口气吃个胖子嘛. 首先在说算法之前,先说清楚什么叫做最短路径. 题目一般会给你一张图,然后告诉你很多地方,然后告诉你各个地方之间的路程有多远,要你求出,两点间的最短距离,注意,题目给出的两点间的距离未必是最短的,可能通过第三个点转换之后达到更短.实际其实也是这样的,有时候两个地方并没有直线的道路只有曲线的绕路. 算法的思路: 1.用二维数组列出所有的距离,达到不了的用最大距离表示,如9999999 2.循环数组上面的每一个点

postgresql+postgis+pgrouting实现最短路径查询(1)---线数据的处理和建立拓扑

准备一个线shp数据,并将其导入postgres里面,postgres安装postgis和pgrouting两个插件(方法见http://www.cnblogs.com/nidaye/p/4553522.html).线数据的字段如下:注意字段的名称,省的出现不必要的麻烦. 1.ALTER TABLE beijing_line ADD COLUMN source integer; ALTER TABLE beijing_line ADD COLUMN target integer; ALTER T

算法导论——最短路径Dijkstra算法

package org.loda.graph; import org.loda.structure.IndexMinQ; import org.loda.structure.Stack; import org.loda.util.In; /** * * @ClassName: Dijkstra * @Description: Dijkstra最短路径算法--贪心算法 * @author minjun * @date 2015年5月27日 下午4:49:27 * */ public class D

最短路径(四)—Bellman-Ford的队列优化(邻接表)

上一节我们写了Bellman-Ford算法解决负权边的问题: 邻接表存储图: n个顶点,m条边. 数组实现邻接表.对每一条边进行1-m编号.用u,v,w三个数组来记录每条边的信息,即u[i],v[i],w[i]表示第i条边是从第 u[i]号顶点到v[i]号顶点且权值为w[i]. first数组的1-n号单元格分别用来存储1-n号顶点的第一条边的编号,初始的时候因为没有边加入所有都是-1.即first[u[i]]保存顶点u[i]的第一条边的编号,next[i]存储"编号为i的边"的&qu

最短路径(Floyd法)

最短路径法: 算法的主要思想是:单独一条边的路径也不一定是最佳路径. 从任意一条单边路径开始.所有两点之间的距离是边的权的和,(如果两点之间没有边相连, 则为无穷大). 对于每一对顶点 u 和 v,看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短.如果是更新它. 先把所有的结果都计算出来放在数组里面,然后根据需要输出所需要的两点之间的最短路径.用了三个循环来实现 还有一个要Mark一下的是:不如一个数组s[i][j]:那可以用这个数组来存放三个数 i,j和s[i][j]: