Floyd + 矩阵快速幂 + 离散化 - Cow Relays - POJ 3613

Floyd + 矩阵快速幂 + 离散化 - Cow Relays - POJ 3613

题意：

给定一张由T条边构成的无向图，点的编号为1~1000之间的整数。

求从起点S到终点E恰好经过N条边（可以重复经过）的最短路。

注意: 数据保证一定有解。

输入格式

第1行：包含四个整数N，T，S，E。

第2…T+1行：每行包含三个整数，描述一条边的边长以及构成边的两个点的编号。

输出格式

输出一个整数，表示最短路的长度。

数据范围

$2\le T\le 100,2\le N\le 10^6$

输入样例：

2 6 6 4
11 4 6
4 4 8
8 4 9
6 6 8
2 6 9
3 8 9

输出样例：

10

---

分析：

$我们改变一下floyd算法中的d数组的含义：$

$d[k][i][j]：表示从i到j，且经过恰好k条边的最短距离。$

$假设k=a+b，即k条边分为两部分，前一部分为a条边，后一部分为b条边，第a+1个点设为点s。$

$则d[k][i][j]=min(d[k][i][j],d[a][i][s]+d[b][s][j])。$

$若我们每次增加1条边计算最短路径，最多10^6条边，每次floyd要O(n^3)，会超时。$

$但是由于最短路的性质：一分为二，两相互独立，分别计算最短路再相加。$

$故我们可以类比到矩阵乘法中倍增的思想，利用矩阵快速幂来计算lo{g}_{2}m次即可。$

$时间复杂度降到O(n^{3}lo{g}_{2}m)。$

$这就告诉我们，floyd算法可以扩展求经过恰好k条边的最短路，时间复杂度是O(n^{3}lo{g}_{2}m)。$

问题：如何逐次增加边的数量来更新最短路？

$我们用二维数组res来保存经过恰好k条边的任意两点间的最短距离。$

$初始化res为inf，res[i][i]=0，表示恰好经过0条边的任意两点间的最短距离。$

$接着我们用输入的邻接矩阵更新res数组，借鉴快速幂倍增的思想来更新k次即可。$

注意：

$初始化邻接矩阵g时，不能初始化g[i][i]=0，因为这表示存在边权为0的自环，事实上是没有的。$

代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<map>

using namespace std;

const int N=110;

int n,m,k,S,E;
int g[N][N];
int res[N][N];
map<int,int> M;

void mul(int a[][N],int b[][N])
{
    int c[N][N];
    memset(c,0x3f,sizeof c);
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                c[i][j]=min(c[i][j],a[i][k]+b[k][j]);
    memcpy(a,c,sizeof c);
}

void quick_pow()
{
    memset(res,0x3f,sizeof res);
    for(int i=1;i<=n;i++) res[i][i]=0;  //初始经过0条边
    
    while(k)
    {
        if(k&1) mul(res,g);
        mul(g,g);
        k>>=1;
    }
}

int main()
{
    cin>>k>>m>>S>>E;
    
    M[S]=++n,M[E]=++n;
    S=M[S],E=M[E];
    
    memset(g,0x3f,sizeof g);  //g的含义是经过一条边的距离，故不能初始化g[i][i]=0，因为不存在权为0的自环
    int a,b,c;
    while(m--)
    {
        cin>>c>>a>>b;
        if(!M.count(a)) M[a]=++n;
        if(!M.count(b)) M[b]=++n;
        a=M[a],b=M[b];
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    
    quick_pow();
    
    cout<<res[S][E]<<endl;
    
    return 0;
}