20180717 F-Moving On

The 2018 ACM-ICPC Chinese Collegiate Programming Contest

#include <iostream>
#include<algorithm>
using namespace std;

/*

算法是Floyd，按危险值从小到大排序城市编号(间接排序)，然后用的dp[][][]记录最短路。

dp[k][i][j]表示 添加(第1~k小的危险值的城市后)的 i->j 最短路。(其实就是Floyd三维未降维的版本)

然后针对每个询问找到它的最大k 的最短路图。
*/

/*

Floyd是一种动态规划的算法，核心是，注意k一定是最外层，不然会漏掉一些情况

这是其二维的简化版本，本题要用到原来的三维版本，并有了一些巧妙的地方。

    for(k=1;k<=n;k++)
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++) {
                if(d[i][k]+d[k][j]<d[i][j]) {
                    d[i][j]=d[i][k]+d[k][j];
                }
            }

*/

/*

最后寻找答案的思想是在不超过危险值的情况下选择最大的K，应为由

p[k][i][j]=min(dp[k-1][i][j],dp[k-1][i][id[k]]+dp[k-1][id[k]][j]);可知其遍历玩后遵循贪心原则

k越大，其解会越优(？)

所以需要对危险度按从小到大对储存下标的id数组进行排序（这里是间接排序）

第一次知道sort函数可以通过cmp用下标比较其他数组的值而对另一个数组排序

（或许可以用结构体或二维数组直接对其直接排序？）

*/

/*

danger[i]是城市[i]的危险值

id[i]是编号为i的城市

排序后danger[id[i]]即表示危险值第i小的城市的具体危险值

这里发现不用memset函数重置每次的dp数组也能过，有点神奇，不知道为啥

 

*/
int dp[210][210][210];
int danger[210];
int id[210];
const int INF=0x3f3f3f3f;

bool cmp(int x,int y)
{
    return danger[x]<danger[y];
}

int main()
{
    int t,n,q,u,v,w;
    scanf("%d",&t);
    for(int ca=1; ca<=t; ca++)
    {
        memset(dp,INF,sizeof(dp));
        scanf("%d %d",&n,&q);
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&danger[i]);
            id[i]=i;
        }
        sort(id+1,id+1+n,cmp);

        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                scanf("%d",&dp[0][i][j]);
        for(int k=1; k<=n; k++)
            for(int i=1; i<=n; i++)
                for(int j=1; j<=n; j++)
                    dp[k][i][j]=min(dp[k-1][i][j],dp[k-1][i][id[k]]+dp[k-1][id[k]][j]);
        printf("Case #%d:\n",ca);
        for(int i=1; i<=q; i++)
        {
            scanf("%d %d %d",&u,&v,&w);
            int k=0;
            for(int i=1; i<=n; ++i)
                if(danger[id[i]]<=w)
                    k=i;
            printf("%d\n",dp[k][u][v]);

        }

    }
    return 0;
}