HDU 3790 最短路径问题(SPFA || Dijkstra )

题目链接

题意 : 中文题不详述。

思路 :无论是SPFA还是Dijkstra都在更新最短路的那个地方直接将花费更新了就行,还有别忘了判重边,话说因为忘了判重边WA了一次。

 1 //3790
 2 #include <iostream>
 3 #include <cstdio>
 4 #include <cstring>
 5 #include <algorithm>
 6 #include <queue>
 7 const int INF = 1 << 28 ;
 8
 9 using namespace std;
10
11 int n, m,s,t;
12 int cost[1100][1100] ,mapp[1100][1010];
13 int dist[1100],cost1[1100] ;
14 int vis[1100] ;
15
16 void spfa(int src)
17 {
18     queue<int> Q ;
19     memset(vis,0,sizeof(vis)) ;
20     for(int i = 1 ; i <= n ; i++)
21     {
22         dist[i] = INF ;
23         cost1[i] = INF ;
24     }
25     dist[src] = 0 ;
26     vis[src] = 1 ;
27     cost1[src] = 0;
28     Q.push(src) ;
29     while(!Q.empty())
30     {
31         int u = Q.front() ;
32         Q.pop() ;
33         vis[u] = 0;
34         for(int i = 1 ; i <= n ; i++)
35         {
36
37             if(dist[i] > dist[u] + mapp[u][i])
38             {
39                 dist[i] = dist[u] + mapp[u][i] ;
40                 cost1[i] = cost1[u] + cost[u][i] ;
41                 if(!vis[i])
42                 {
43                     vis[i] = 1 ;
44                     Q.push(i) ;
45                 }
46             }
47             else if(dist[i] == dist[u]+mapp[u][i])
48             {
49                 if(cost1[i] > cost1[u] + cost[u][i])
50                 {
51                     cost1[i]=cost1[u] + cost[u][i];
52                     if(!vis[i])
53                     {
54                         vis[i] = 1 ;
55                         Q.push(i) ;
56                     }
57                 }
58
59             }
60         }
61     }
62 }
63 void Init()
64 {
65     for(int i = 1 ; i <= n ; i++)
66         for(int j = 1 ; j <= n ; j++)
67         {
68             if(i == j) mapp[i][j] = cost[i][j] = 0 ;
69             else mapp[i][j] = cost[i][j] = INF ;
70         }
71 }
72 int main()
73 {
74     //
75     while(cin >> n >> m)
76     {
77         if(n == 0 && m == 0) break ;
78         int a, b , d , p ;
79         Init() ;
80         for(int i = 0 ; i < m ; i++)
81         {
82             cin >> a >> b >> d >> p ;
83             if(mapp[a][b] > d)
84             {
85                 mapp[a][b] = mapp[b][a] = d ;
86                 cost[a][b] = cost[b][a] = p ;
87             }
88             else if(mapp[a][b] == d&&cost[a][b] > p)
89                 cost[a][b] = cost[b][a] = p ;
90         }
91         cin >> s >> t ;
92         spfa(s) ;
93         printf("%d %d\n",dist[t],cost1[t]) ;
94     }
95     return 0;
96 }

会神的Dijkstra

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 #define maxn 1001
 5 using namespace std;
 6 const int inf=1<<28;
 7
 8 int g[maxn][maxn];
 9 int cost[maxn][maxn];
10 int n,m,a,b,d,p,s,e;
11 bool vis[maxn];
12 int dis[maxn],c[maxn];
13
14 void inti()
15 {
16     for(int i=1; i<=n; i++)
17     {
18         for(int j=1; j<=n; j++)
19         {
20             if(i==j)
21             {
22                 g[i][j]=0;
23                 cost[i][j]=0;
24             }
25             else
26             {
27                 g[i][j]=inf;
28                 cost[i][j]=inf;
29             }
30         }
31     }
32 }
33
34 void dijkstra(int str)
35 {
36     memset(vis,false,sizeof(vis));
37     for(int i=1; i<=n; i++)
38     {
39         dis[i]=g[str][i];
40         c[i]=cost[str][i];
41     }
42     dis[str]=0;
43     c[str]=0; vis[str]=true;
44     for(int i=1; i<n; i++)
45     {
46         int m=inf,x;
47         for(int y=1; y<=n; y++)  if(!vis[y]&&dis[y]<m) m=dis[x=y];
48         vis[x]=true;
49         for(int y=1; y<=n; y++)
50         {
51             if(!vis[y]&&g[x][y]!=inf)
52             {
53                 if(dis[y]>dis[x]+g[x][y])
54                 {
55                     dis[y]=dis[x]+g[x][y];
56                     c[y]=c[x]+cost[x][y];
57                 }
58                 else if(dis[y]==dis[x]+g[x][y])
59                 {
60                     if(c[y]>c[x]+cost[x][y])
61                         c[y]=c[x]+cost[x][y];
62                 }
63             }
64         }
65     }
66 }
67 int main()
68 {
69     while(scanf("%d%d",&n,&m)!=EOF)
70     {
71         if(n==0&&m==0) break;
72         inti();
73         for(int i=0; i<m; i++)
74         {
75             scanf("%d%d%d%d",&a,&b,&d,&p);
76             if(d<g[a][b])
77             {
78                 g[a][b]=g[b][a]=d;
79                 cost[a][b]=cost[b][a]=p;
80             }
81
82         }
83         scanf("%d%d",&s,&e);
84         dijkstra(s);
85         printf("%d %d\n",dis[e],c[e]);
86     }
87     return 0;
88 }

HDU 3790 最短路径问题(SPFA || Dijkstra )

时间: 2024-10-25 20:51:31

HDU 3790 最短路径问题(SPFA || Dijkstra )的相关文章

hdu 3790 最短路径问题(dijkstra)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3790 Problem Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Input 输入n,m,点的编号是1~n,然后是m行,每行4个数 a,b,d,p,表示a和b之间有一条边,且其长度为d,花费为p.最后一行是两个数 s,t;起点s,终点.n和m为0时输入结束. (1<n<

#HDU 3790 最短路径问题 【Dijkstra入门题】

题目: 最短路径问题 Time Limit: 2000/1000 MS (Java/Others)????Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 19767????Accepted Submission(s): 5880 Problem Description 给你n个点.m条无向边,每条边都有长度d和花费p.给你起点s终点t,要求输出起点到终点的最短距离及其花费,假设最短距离有多条路线,则输出花费最少的. ?

HDU 3790 最短路径问题【Dijkstra】

题意:给出n个点,m条边,每条边的长度d和花费p,给出起点和终点的最短距离和花费,求最短距离,如果有多个最短距离,输出花费最少的 在用dijkstra求最短距离的时候,再用一个f[]数组保存下最少花费就可以了 这道题wa了好多次 因为 建立图的时候没有考虑到重边, 还有在建图的时候,如果遇到w[a][b]相等的情况,就应该将其对应的花费更新成更小的了 还有 在写dijkstra函数的时候,把终点带进去当做了点的个数 这样不对 因为假如给出的起点,终点分别是st,en 那么如果只计算到en点的话,

HDU 3790 最短路径问题(Dijkstra 迪杰斯特法最短路径算法)

Problem Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Input 输入n,m,点的编号是1~n,然后是m行,每行4个数 a,b,d,p,表示a和b之间有一条边,且其长度为d,花费为p.最后一行是两个数 s,t;起点s,终点.n和m为0时输入结束.(1<n<=1000, 0<m<100000, s != t) Output 输出 一行有两个数, 最短

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.最后一行是

hdu 3790 最短路径问题(双重权值,dijkstra算法)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3790 题目大意:题意明了,输出最短路径及其花费. 需要注意的几点:(1)当最短路径相同时,输出最小花费!!! (2)更新路径的时候要注意更新花费. 1 #include <iostream> 2 #include <cstdio> 3 using namespace std; 4 const int INF=9999999; 5 int map[1010][1010],Min,n,co

hdu 3790 最短路径问题(两个限制条件的最短路)

http://acm.hdu.edu.cn/showproblem.php?pid=3790 有两个条件:距离和花费.首先要求距离最短,距离相等的条件下花费最小. dijkstra,只是在判断条件时多考虑了花费. 注意重边. #include <stdio.h> #include <algorithm> #include <set> #include <map> #include <vector> #include <math.h>

【最短路+最小费用】hdu 3790 最短路径问题

Source : hdu 3790 最短路径问题 http://acm.hdu.edu.cn/showproblem.php?pid=3790 Problem Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Input 输入n,m,点的编号是1~n,然后是m行,每行4个数 a,b,d,p,表示a和b之间有一条边,且其长度为d,花费为p.最后一行是两个数 s,t;起点s,终

HDU - 3790 最短路径问题(Dijkstra+优先队列优化)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3790 题意:中文题(边被赋予两种属性,一种是路径,一种是花费),然后略.(逃...... 今天看了卿学姐的视频,初尝SPFA和Dijkstra. 一个是用队列优化,一个是用优先队列优化.这道题目用这两种方法都可以. dijkstra算法思想(贪心):从距离起点最近的点开始,从这个点遍历一遍它周围的点,进行松弛操作,直到最终点. 整个的算法思想就是贪心,每次都给它形成最短路. 这道题目值得注意的是预处