POJ 3613 Cow Relays Floyd+快速幂加速

题目大意：求从S到T 恰好经过k条边的最短路。(2<=k<=1000000)

解题思路：最开始看到题目以为是K短路，不过看到K的数量级就明显不适合了。

根据题意,既有最短路,k这么大,时间限制还是1s,便想到去优化。

然后看到点数为1000，而边数最多只有100，先进行一步离散化，不过复杂度还是不够，然后就开始考虑这道题的特殊性了。

K最多为1000,000，而边数只有一百，可以预见中间有许多状态是重复出现的，甚至有可能在一个环中不停地走。

于是考虑把中间重复的计算给优化一下。便想到了快速幂优化和ST算法。（这两个都是能基于重复的状态进行优化）

而便于重复状态的记录的话,用矩阵来存储状态是再合适不过的了,由此想到最短路用Floyd来求。

先简述一下快速幂优化的思想:

如果想求K^a, 假设a=43.  我们把a转化为二进制便是 101011

接下来表示时我们把指数都用二进制表示,原式便是求 K^(101011) ,

=K^(1<<0) + K^(1<<1) + K^(1<<3) +K^(1<<5) , 

而K^(1<<1)= (K^(1<<0))^2 , K^(1<<2)= (K^(1<<1))^2 , K^(1<<3)= (K^(1<<2))^2 ,K^(1<<4)= (K^(1<<3))^2 ,K^(1<<5)= (K^(1<<4))^2 ....

也就是说每一位都可以由上一位的平方得到,原来的指数级运算便成了加法运算..

而只要是1e9级以内的指数运算我们都可以在32次运算内完成....( 很强大... ) (  当然...不要给我说数据溢出什么的...那种题一般要取余,取余方法自己找快速幂看 )

再回到这题,用Floyd算法的话,

假设从a到b经过恰好经过 (1<<i) 条路的最短路是len[a][b][ 1<<i ]=min(len[ a ][ c ][ 1<<(i-1) ] + len(len[ c ][ b ][ 1<<(i-1) ]

哪怕是经过101011条路径的最短路我们也都可以像上面的优化一样依次求出。

具体实现看代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define FOR(i,l,r) for(int i=(l);i<=(r);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define N 1010
#define INF 1e9
#define min(a,b) (a<b?a:b)

int map[2][N][N];
int ans[2][N][N];
int f[N];
bool flag[N];
void floyd(int num,int cur,int pre)
{
    REP(i,num)
        REP(j,num)
            map[cur][f[i]][f[j]]=INF;
    REP(k,num)
        REP(i,num)
            REP(j,num)
                map[cur][f[i]][f[j]]=min(map[cur][f[i]][f[j]],map[pre][f[i]][f[k]]+map[pre][f[k]][f[j]]);
}

int main()
{
    int n,m,start,end;
    int u,v,c;
    while(cin>>n>>m>>start>>end)
    {
        memset(flag,0,sizeof(flag));
        FOR(i,1,1000)
            FOR(j,1,1000)
                map[0][i][j]=INF; //初始化
        int num=0;
        while(m--)
        {
            scanf("%d%d%d",&c,&u,&v);
            map[0][u][v]=map[0][v][u]=c;
            if(!flag[u]) f[num++]=u,flag[u]=1; //离散化
            if(!flag[v]) f[num++]=v,flag[v]=1; //离散化
        }
        REP(i,num)
        {
            REP(j,num)
            ans[0][f[i]][f[j]]=INF;
            ans[0][f[i]][f[i]]=0;   //初始化
        }
        int cur=0,pre=1;
        int temp1=0,temp2=1;   
        //temp1是当前状态,temp2是之前的状态
        //因为map[1<<i][a][b] 只与 map[1<<(i-1)][x][y] 有关
        //所以这两个数组能循环利用
        //没必要开32位,开两位足以,是一种空间上的优化
        while(n)
        {
            temp1^=1,temp2^=1;
            floyd(num,temp1,temp2);//i从0开始,在进行第i次while()循环时,求出从a到b恰好经过(1<<i)条边的最短路是多少
            if(n&1) //如果当前位为1才进行计算,把ans进行更新
            {
                cur^=1,pre^=1;//和temp1,temp2的效果是一样的
                REP(i,num)
                    REP(j,num)
                        ans[cur][f[i]][f[j]]=INF;//只用对离散化后的点初始化
                REP(k,num)
                    REP(i,num)
                        REP(j,num)
                            ans[cur][f[i]][f[j]]=min(ans[cur][f[i]][f[j]],ans[pre][f[i]][f[k]]+map[temp2][f[k]][f[j]]);
                            //在离散化后的点中进行Floyd
            }
            n>>=1;
        }
        cout<<ans[cur][start][end]<<endl;
    }
    return 0;
}