Floyd-例题-实现-我的第一篇博客

https://www.cnblogs.com/lbssxz/p/11014911.html

这是网上看到的题目，以上是原博主的解答和题目来源（没找到别的题目来源）

题目大意:

城市交通费

【问题描述】

有 n 个城市，编号 1~n。其中 i 号城市的繁华度为 pi。省内有 m 条可以双向同行的高速

公路，编号 1~m。编号为 j 的高速公路连接编号为 aj 和 bj 两个城市，经过高速公路的费用

是 wj。若从城市 x 出发到某城市 y，除了需要缴纳高速公路费用，还要缴纳“城市建设费”

（为从 x 城市到 y 城市所经过的所有城市中繁华度的最大值，包括 x 和 y 在内）。

现提出 q 个询问，每个询问给出一组 x 和 y，你需要回答从 x 出发到 y 城市，所需要的

最低交通费（高速公路费+城市建设费）是多少。

【输入】

第一行三个整数 n,m,q。

第二行 n 个整数，表示 p1~pn。

接下来 m 行中，每行 3 个正整数，第 j 行包含 Aj，Bj，Wj。

随后 Q 行每组两个正整数 x，y 表示一组询问。

【输出】

共 Q 行，为对 Q 个问题的回答：x 城市到 y 城市的最小交通费用。

【样例输入】

5 7 2

2 5 3 3 4

1 2 3

1 3 2

2 5 3

5 3 1

5 4 1

2 4 3

3 4 4

1 4

2 3

【样例输出】

8

9

【数据范围及约定】

n≤250，m≤20000，Q≤10000，Pi≤10000，Wj≤2000，保证任意两个城市可以互相到达。

------------恢复内容结束------------

显然这是一个最短路问题，但是即便是最短路，即便确定了思路是FLOYD，仍然有很多不一样的思路。以下为我的思路和原本错误的方向——更新的对象错误。

很多最短路问题，出了模板题以外，难点就在于：

1. 如何找到“最短”--的表示方式，最短可能有多种情况，可能有多个条件，像这题有多个因素变量，是否有优先权，是否在这之前需要贪心或者先排序操作。
2. 路径的初始化问题，其他参数的初始化问题，需不需要中间变量做桥梁***
3. 有了最短路的定义，该怎么操作“更新”也是个难题。本题的难点就在于更新——不同路径繁华度最大值总是会变，每次找到一条新路都需要检查和更新。

这一环也是最容易出现问题的一环——常见问题：

• 更新的对象，找错/找漏（我一开始的问题）
• 更新的办法有问题，不全面，更新的操作不全，需要分类讨论
• 更新的时候没有考虑到连锁影响，是否需要回溯或者重来
• 更新直接操作复杂，需要找中间桥梁+中间补充操作——原博主的办法
4. 最短路只是题目中的一环，在这基础上还有别的算法需要综合使用。

对于这个问题，原博主使用的方式是贪心排序繁华度，除了繁华度，最短路的数组，另外又找了一个数组代替最终消费，然后每次都用通过排序直接对应新繁华度代替，

你会发现如果连续使用最短路，更新结果会变。因为更新是不统一的。（个人对原博主的解法还有疑问，以后再做补充）

而我的办法比较老土，就是简单的模拟，繁华度另开一个数组，每次把原来的繁华度减掉，然后加上新的繁华度，从而得到最短，这个结果是不会变的。

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <string>
 #include <limits.h>
 using namespace std;
 typedef long long ll;
 const ll INF = 0x3f3f3f3f3f3f3f3fLL;
 int a[][];
 int n=;
 const int I=0x3f3f3f3f;
 int m=;
 int q=;
 int t[];
 int p[][];//表示当前的最大繁华度
 void floy0() {
     //memset(a,0,sizeof(a));

     for(int k=; k<=n; k++) {
         for(int j=; j<=n; j++) {
             for(int i=; i<=n; i++) {
                 /*
                         int d1=max(t[i],t[j]);
                         int d2=max(t[i],t[j]);
                         d2=max(d2,t[k]);
                         a[i][j]=a[j][i]=min(a[j][i]+d1,d2+a[j][k]+a[k][i]);*/
                 //上面这个式子错误在于,不是每次都加一次繁华度.
                 //而是最后得到ij之后加一次繁华度,每次应该更新这个繁华度
                 //更新的时候一减一加
                 //或者从一开始就从繁华度最大值最小优先筛选--排序贪心一次后再做
                 //存在更新不完全???
                 int l=;
                 if(a[j][k]<I&&a[k][i]<I&&p[i][k]<I&&p[j][k]<I) {
                     if(a[i][j]<I) {
                         l=max(p[j][k],p[i][k]);
                         if(a[j][i]>((a[j][k]-p[j][k])+(a[k][i]-p[k][i])+l)) {
                             a[j][i]=(a[j][k]-p[j][k])+(a[k][i]-p[k][i])+l;
                             p[i][j]=p[j][i]=l;
                             cout<<j<<"-->"<<i<<": "<<j<<"-->"<<k<<"-->"<<i<<endl<<endl;
                         }

                     } else {
                         l=max(p[k][i],p[j][k]);
                         p[i][j]=p[j][i]=l;
                         a[i][j]=a[j][i]=(a[j][k]-p[j][k])+(a[k][i]-p[k][i])+l;
                         cout<<j<<"-->"<<i<<": "<<j<<"-->"<<k<<"-->"<<i<<endl<<endl;
                     }

                 }

                 //比较的是最短路净值所以后面那个式子里的每个减完再加

                 for(int i=; i<=n; i++) {
                     for(int j=; j<=n; j++) {
                         if(a[i][j]>=I||a[i][j]<)cout<<"!\t";
                         else cout<<a[i][j]<<"\t";
                     }
                     puts("");
                 }
                 puts("");

             }
         }

     }

 }

 int main () {

     scanf("%d%d%d",&n,&m,&q);

     memset(t,,sizeof(t));
     memset(a,I,sizeof(a));
     memset(p,I,sizeof(p));
     for(int i=; i<=n; i++) {
         scanf("%d",&t[i]);
         a[i][i]=t[i];
         p[i][i]=t[i];
     }
     while(m--) {
         int i,j,w;
         scanf("%d%d%d",&i,&j,&w);
         p[i][j]=p[j][i]=max(t[i],t[j]);
         a[i][j]=a[j][i]=w+p[i][j];

     }

     puts("");
     floy0();
     return ;
 }