【HDOJ】1385 Minimum Transport Cost

Floyd。注意字典序!!!


 1 #include <stdio.h>
2 #include <string.h>
3
4 #define MAXNUM 55
5 #define INF 0x1fffffff
6
7 int cost[MAXNUM][MAXNUM];
8 int path[MAXNUM][MAXNUM];
9 int taxes[MAXNUM];
10 int que[MAXNUM];
11 int n;
12
13 void floyd(int n) {
14 int i, j, k, tmp;
15
16 for (i=1; i<=n; ++i)
17 for (j=1; j<=n; ++j)
18 path[i][j] = j;
19
20 for (k=1; k<=n; ++k) {
21 for (i=1; i<=n; ++i) {
22 for (j=1; j<=n; ++j) {
23 tmp = cost[i][k]+cost[k][j]+taxes[k];
24 if (cost[i][j] > tmp) {
25 cost[i][j] = tmp;
26 path[i][j] = path[i][k];
27 } else if (cost[i][j] == tmp) {
28 if (path[i][j] > path[i][k])
29 path[i][j] = path[i][k];
30 }
31 }
32 }
33 }
34 }
35
36 void output(int a, int b) {
37 int front, rear;
38 int x = a;
39 front = rear = 0;
40
41 //que[rear++] = a;
42 while (path[x][b] != b) {
43 que[rear++] = path[x][b];
44 x = path[x][b];
45 }
46 if (a != b)
47 que[rear++] = b;
48
49 printf("From %d to %d :\n", a, b);
50 printf("Path: %d", a);
51 while (front < rear)
52 printf("-->%d", que[front++]);
53 printf("\nTotal cost : %d\n\n", cost[a][b]);
54 }
55
56 int main() {
57 int a, b;
58 int i, j;
59
60 while (scanf("%d", &n)!=EOF && n) {
61 for (i=1; i<=n; ++i)
62 for (j=1; j<=n; ++j) {
63 scanf("%d", &cost[i][j]);
64 if (cost[i][j] < 0)
65 cost[i][j] = INF;
66 }
67 for (i=1; i<=n; ++i)
68 scanf("%d", &taxes[i]);
69 floyd(n);
70 while (1) {
71 scanf("%d %d", &a, &b);
72 if (a==-1 && b==-1)
73 break;
74 output(a, b);
75 }
76 }
77
78 return 0;
79 }

时间: 2024-12-25 08:15:20

【HDOJ】1385 Minimum Transport Cost的相关文章

HDOJ 1385 Minimum Transport Cost

Minimum Transport Cost Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7007    Accepted Submission(s): 1791 Problem Description These are N cities in Spring country. Between each pair of cities

HDU 1385 Minimum Transport Cost 最短路径题解

本题就是使用Floyd算法求所有路径的最短路径,并且需要保存路径,而且更进一步需要按照字典顺序输出结果. 还是有一定难度的. Floyd有一种很巧妙的记录数据的方法,大多都是使用这个方法记录数据的. 不过其实本题数据不是很大,一般太大的数据也无法使用Floyd,因为效率是O(N^3). 所以其实也可以使用一般的Floyd算法,然后增加个三维数组记录数据.下面就是这种做法,0ms过了. #include <stdio.h> #include <vector> using std::v

HDU 1385 Minimum Transport Cost(Floyd 最短路 打印路径)

HDU 1385 大意: 有N个城市,然后直接给出这些城市之间的邻接矩阵,矩阵中-1代表那两个城市无道路相连,其他值代表路径长度. 如果一辆汽车经过某个城市,必须要交一定的钱(可能是过路费). 现在要从a城到b城,花费为路径长度之和,再加上除起点与终点外所有城市的过路费之和. 求最小花费,如果有多条路经符合,则输出字典序最小的路径. 思路: Floyd求最短路,打印路径即可. 1 /*--------------------------------------------------------

hdu 1385 Minimum Transport Cost (Floyd + 字典序打印路径)

Minimum Transport Cost Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7822    Accepted Submission(s): 2028 Problem Description These are N cities in Spring country. Between each pair of cities

HDU 1385 Minimum Transport Cost (字典序打印最短路)

题意  给你一个无向图的邻接矩阵  和途径每个点需要的额外花费首尾没有额外花费  求图中某两点之间的最短路并打印字典序最小路径 要求多组点之间的就用floyd咯  打印路径也比较方便  nex[i][j]表示从i点到j点最短路的第一个途经点  那么如果路径中加入一个节点k后 nex[i][j]应该更新为nex[i][k]  因为要途径k了 #include<cstdio> #include<cstring> using namespace std; const int N = 10

HDU - 1385 Minimum Transport Cost(floyd+字典序)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1385 题意:给出一个邻接矩阵(对应位置的值代表两个顶点之间的花费),并且到达另外一个位置还要加上那个位置对应的额外花费. 然后求出最少的花费和起点到终点的路径(如果两条路径花费一样,求出字典序最小的) 求任意两点间的最小花费,一般都采用Floyd.Floyd就是一个简单的dp思想,在用Floyd的时候记录一下路径就可以了. 这里要求字典序,可以在路径相等的时候再次进行判断一下,取小的顺序. 1 #i

hdu 1385 Minimum Transport Cost

BFS注意字典序的问题.WA了好多发. #include<stdio.h> #include<math.h> #include<string.h> #include<vector> #include<algorithm> using namespace std; const int maxn = 70; int n, cost[maxn][maxn],bb[maxn], ji[maxn]; struct abc{ int node, fei; i

【HDOJ】3473 Minimum Sum

划分树解.主席树解MLE. 1 /* 3473 */ 2 #include <iostream> 3 #include <sstream> 4 #include <string> 5 #include <map> 6 #include <queue> 7 #include <set> 8 #include <stack> 9 #include <vector> 10 #include <deque>

HDU - 1385 Minimum Transport Cost(最短路+最小字典序路径)

题目大意:有N个村庄.过村庄时需要交一定的费用.现在问从村庄A,要运一批货物到村庄B,怎样走才能使费用达到最小,起始和终点都不用缴费 解题思路:这题借鉴了别人的思路,用字符串存储路径. 其实不用字符串也是可以处理的 #include <cstdio> #include <cstring> #include <queue> using namespace std; #define N 105 #define INF 0x3f3f3f3f struct Node { cha