hdu1385Minimum Transport Cost(最短路变种)

题目链接:

huangjing

思路:

输出路径的最短路变种问题。。这个题目在于多组询问,那么个人觉得用floyd更加稳妥一点。还有就是在每个城市都有过路费,所以在floyd的时候更改一下松弛条件即可。。那么输出路径怎么办呢??我采用的是输出起点的后继而不是终点的前驱。。因为我们关心的是路径字典序最小,关心的是起点的后继。。。那么打印路径的时候就直接从前向后打印,这个和dijkstra的打印路径稍有不同。。。最短路的打印参见传送门

题目:

Minimum Transport Cost

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 7538    Accepted Submission(s): 1935

Problem Description

These are N cities in Spring country. Between each pair of cities there may be one transportation track or none. Now there is some cargo that should be delivered from one city to another. The transportation fee consists of two parts:

The cost of the transportation on the path between these cities, and

a certain tax which will be charged whenever any cargo passing through one city, except for the source and the destination cities.

You must write a program to find the route which has the minimum cost.

Input

First is N, number of cities. N = 0 indicates the end of input.

The data of path cost, city tax, source and destination cities are given in the input, which is of the form:

a11 a12 ... a1N

a21 a22 ... a2N

...............

aN1 aN2 ... aNN

b1 b2 ... bN

c d

e f

...

g h

where aij is the transport cost from city i to city j, aij = -1 indicates there is no direct path between city i and city j. bi represents the tax of passing through city i. And the cargo is to be delivered from city c to city d, city e to city f, ..., and
g = h = -1. You must output the sequence of cities passed by and the total cost which is of the form:

Output

From c to d :

Path: c-->c1-->......-->ck-->d

Total cost : ......

......

From e to f :

Path: e-->e1-->..........-->ek-->f

Total cost : ......

Note: if there are more minimal paths, output the lexically smallest one. Print a blank line after each test case.

Sample Input

5
0 3 22 -1 4
3 0 5 -1 -1
22 5 0 9 20
-1 -1 9 0 4
4 -1 20 4 0
5 17 8 3 1
1 3
3 5
2 4
-1 -1
0

Sample Output

From 1 to 3 :
Path: 1-->5-->4-->3
Total cost : 21

From 3 to 5 :
Path: 3-->4-->5
Total cost : 16

From 2 to 4 :
Path: 2-->1-->5-->4
Total cost : 17

Source

Asia 1996, Shanghai (Mainland China)

Recommend

Eddy   |   We have carefully selected several similar problems for you:  1142 1217 2112 2722 1598

代码:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#define INF 0x3f3f3f3f
using namespace std;

const int maxn=50+10;
int dis[maxn][maxn],path[maxn][maxn],n,cost[maxn];
int u,st,en;

void floyd()
{
    for(int k=1;k<=n;k++)
      for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
    {
        int tmp=dis[i][k]+dis[k][j]+cost[k];
        if(tmp<dis[i][j]||(tmp==dis[i][j]&&path[i][j]>path[i][k]))
        {
            dis[i][j]=tmp;
            path[i][j]=path[i][k];
        }
    }
}

void read_Graph()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
    {
        scanf("%d",&u);
        if(u==-1)
            dis[i][j]=INF;
        else
        {
            dis[i][j]=u;
            path[i][j]=j;
        }
    }
    for(int i=1;i<=n;i++)
       scanf("%d",&cost[i]);
}

void solve()
{
    while(~scanf("%d%d",&st,&en))
    {
        if(st==-1&&en==-1)  break;
        printf("From %d to %d :\n",st,en);
        printf("Path: %d",st);
        int Gery=st;
        while(Gery!=en)
        {
            printf("-->%d",path[Gery][en]);
            Gery=path[Gery][en];
        }
        printf("\nTotal cost : %d\n\n",dis[st][en]);
    }
}

int main()
{
    while(~scanf("%d",&n),n)
    {
        read_Graph();
        floyd();
        solve();
    }
    return 0;
}

hdu1385Minimum Transport Cost(最短路变种)

时间: 2024-12-16 22:39:14

hdu1385Minimum Transport Cost(最短路变种)的相关文章

HDU1385Minimum Transport Cost(两点间最短spfa+输出字典树最小的路径)

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

【堆优化Dijkstra+字典序最短路方案】HDU1385-Minimum Transport Cost

[题目大意] 给出邻接矩阵以及到达各个点需要付出的代价(起点和终点没有代价),求出从给定起点到终点的最短路,并输出字典序最小的方案. [思路] 在堆优化Dijkstra中,用pre记录前驱.如果新方案和旧方案相等,比较两个方案的字典序. [坑点] 我先求出了最短路(包括终点要付出代价),输出的时候再减去终点的代价. 有可能会给出S==T的情况--在这种情况下,最短路就是0,减去代价要变成负数了QAQ所以要特判一下.坑了好几个小时orz 1 #include<iostream> 2 #inclu

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

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

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

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

Minimum Transport Cost Floyd 输出最短路

These are N cities in Spring country. Between each pair of cities there may be one transportation track or none. Now there is some cargo that should be delivered from one city to another. The transportation fee consists of two parts: The cost of the

HD1385Minimum Transport Cost(Floyd + 输出路径)

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

HDU1385 Minimum Transport Cost

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

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