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

最新推荐文章于 2019-03-03 20:57:05 发布

原创最新推荐文章于 2019-03-03 20:57:05 发布 · 835 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dijkstra

图论专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍了如何解决在给定城市网络中找到最小成本路径的问题，包括输入格式、算法选择（Dijkstra 和 Floyd）、路径输出方式以及代码实现细节。通过实例分析，展示了算法在实际应用中的操作流程和输出结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

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

题意及分析：

做这个题挺艰辛的，还是太菜。做题太少。参考了别人的思路。

题目的意思并不是很难理解，也就不多说了。就说说主要的地方。

路径要求字典序。一种最直接的方法是，在用Dijkstra求解这道题时，在松弛操作时，如果dis[]=dis[]+edge[][],就用字符串从头到尾把路径存下来，再来比较。选出最优。

代码如下：

#include
#include
#include
#include
#include
#include
#include
#include
#define eps 1e-9
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;
int n,st,ed,num;
int edge[900][900],tax[1000],vis[1000],pre[1000],dis[1000];  //pre[]记录最短路径的上一个节点
char s[900];
void output(int k)
{
    if(k==st)
    {
        printf("%d",st);
        return;
    }
    output(pre[k]);
    printf("-->%d",k);
}
void build(int k)
{
    if(k==st)
        {
            s[num++]=char(k+'0');
            return;
        }
    build(pre[k]);
    s[num++]=char(k+'0');
}
void Dijkstra()
{
    int i,j,now;

    memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dis[st]=0;
    for(i=1;idis[now]+edge[now][j]+tax[j])
             {
                 dis[j]=dis[now]+edge[now][j]+tax[j];
                 pre[j]=now;
             }
             else if(dis[j]==dis[now]+edge[now][j]+tax[j])
             {
                 int k1=now,k2=pre[j];
                 char s1[900],s2[900];
                 num=0;
                 build(k1);  //构造字符串，存储当前路径
                 s[num++]=char(j+'0');
                 s[num]='\0';
                 //printf("%s\n",s);
                 strcpy(s1,s);
                 num=0;
                 build(k2);
                 s[num++]=char(j+'0');
                 s[num]='\0';//printf("%s\n",s);
                 strcpy(s2,s);
                 if(strcmp(s1,s2)<0)  //比较路径，如果符合要求就更新pre[]
                    pre[j]=now;
             }
        }
    }
    printf("From %d to %d :\n",st,ed);
    printf("Path: ");
    output(ed);   //递归输出路径
    printf("\n");
    printf("Total cost : %d\n\n",dis[ed]-tax[ed]);

}
int main()
{
    int i,j;

    while(scanf("%d",&n),n)
    {
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
            scanf("%d",&edge[i][j]);
        for(i=1;i<=n;i++)
            scanf("%d",&tax[i]);
        while(scanf("%d%d",&st,&ed))
        {
            if(st==-1&&ed==-1)
                break;
            if(st==ed)   //注意这里的坑点。起点终点可以是同一个。
            {
                printf("From %d to %d :\n",st,ed);
                printf("Path: %d\n",st,ed);
                printf("Total cost : %d\n\n",edge[st][ed]);
                continue;
            }
            Dijkstra();
        }
    }

    return 0;
}

另外的一种方法是Floyd。Floyd果然很厉害，想要活用需要功底吧。

path[i][j]保存的是i-->j路径上i点的下一个点的满足字典序的最优选择。

代码如下：

#include
#include
#include
#include
#include
#include
#include
#include
#define eps 1e-9
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;
int n,st,ed,num;
int edge[900][900],tax[1000],path[900][900];
void floyd()
{
    int i,j,k;

    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
        path[i][j]=j;
    for(k=1;k<=n;k++)
        for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if(edge[i][k]!=INF&&edge[k][j]!=INF)
        {
            int tmp=edge[i][k]+edge[k][j]+tax[k];
            if(edge[i][j]>tmp)
            {
                edge[i][j]=tmp;
                path[i][j]=path[i][k];  
            }
            else if(edge[i][j]==tmp)
            {
                if(path[i][j]>path[i][k])   //如果path[i][k]更小，说明更优
                    path[i][j]=path[i][k];  //更新为 最优的字典序
            }
        }
}
int main()
{
    int i,j;

    while(scanf("%d",&n),n)
    {
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
            {
                int k;
                scanf("%d",&k);
                edge[i][j]=(k==-1?INF:k);
            }
        for(i=1;i<=n;i++)
            scanf("%d",&tax[i]);
        floyd();
        while(scanf("%d%d",&st,&ed))
        {
            if(st==-1&&ed==-1)
                break;
            printf("From %d to %d :\n",st,ed);
            printf("Path: ");
            if(st==ed)
            printf("%d\n",ed);
            else
            {
                printf("%d-->",st);
                int tmp=path[st][ed];
                while(tmp!=ed)
                {
                    printf("%d-->",tmp);
                    tmp=path[tmp][ed];
                }
                printf("%d\n",ed);
            }
            printf("Total cost : %d\n\n",edge[st][ed]);
        }
    }

    return 0;
}