Codeup墓地-1956

Codeup墓地-1956
src:http://codeup.cn/problem.php?id=1956
1956: 最短路径
时间限制: 1 Sec 内存限制: 32 MB
题目描述
N个城市，标号从0到N-1，M条道路，第K条道路（K从0开始）的长度为2^K，求编号为0的城市到其他城市的最短距离。

输入
第一行两个正整数N（2<=N<=100）M(M<=500),表示有N个城市，M条道路，
接下来M行两个整数，表示相连的两个城市的编号。

输出
N-1行，表示0号城市到其他城市的最短路，如果无法到达，输出-1，数值太大的以MOD 100000 的结果输出。

样例输入
4 3
0 1
1 2
2 0
样例输出
1
3
-1

//N个城市，标号从0到N-1，M条道路，第K条道路（K从0开始）的长度为2^K，求编号为0的城市到其他城市的最短距离。
//大数版的迪杰斯特拉做法
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define M 100000
#define INF 1999999
class Node{
public:
    int dn[505];
    void init( int );
    bool operator< ( const Node& );
    bool operator== ( const Node& );
    Node operator+ ( const Node& );
    Node operator+ ( int );
};
void Node::init ( int flag ){
    for ( int i = 500; i >= 0; i-- )
        dn[i] = flag ? INF : 0;
}
bool Node::operator< ( const Node& x ){
    for ( int i = 500; i >= 1; i-- )
        if ( dn[i] < x.dn[i] ) return true;
        else if ( dn[i] > x.dn[i] ) return false;
    return false;
}
bool Node::operator== ( const Node& x ){
    for ( int i = 500; i >= 1; i-- )
        if ( dn[i] != x.dn[i] ) return false;
    return true;
}
Node Node::operator+ ( const Node& x ){
    Node ret;
    for ( int i = 500; i >= 1; i-- )
        ret.dn[i] = dn[i] + x.dn[i];
    return ret;
}
Node Node::operator+ ( int x ){
    Node ret = *this;
    ret.dn[x]++;
    return ret;
}
int map[110][110], vis[110];
Node d[110], MM;
void Dijkstra ( int n ){
    Node tmp;
    int i, j, k;
    for ( i = 1; i <= n; i++ )
        d[i].init(1), vis[i] = 0;
    d[1].init(0);
    for ( i = 1; i <= n; i++ ){
        for(tmp = MM, j = 1; j <= n; j++ )
            if ( !vis[j] && d[j] < tmp )
                tmp = d[k=j];
        if ( tmp == MM ) break;
        vis[k] = 1;
        for ( j = 1; j <= n; j++ )
        {
            if (vis[j] || map[k][j] == INF) continue;
            tmp = d[k] + map[k][j];
            if ( tmp < d[j] ) d[j] = tmp;
        }
    }
}
int mod_exp ( long long a, long long b ){
    long long ret = 1;
    while ( b > 0 ){
        if ( b & 1 )
            ret = ( ret * a ) % M;
        b >>= 1;
        a = ( a * a ) % M;
    }
    return ret;
}
int cal ( const Node& x ){
    int sum = 0;
    for ( int i = 1; i <= 500; i++ ){
        if ( x.dn[i] == 0 ) continue;
        sum += x.dn[i] % M * mod_exp(2,i-1);
        sum %= M;
    }
    return sum;
}
int main(){
    MM.init(1);
    int n, m, a, b, i, j;
    while ( scanf("%d%d",&n,&m) != EOF ){
        for ( i = 1; i <= n; i++ )
            for (j = 1; j <= n; j++ )
                map[i][j] = (i==j) ? 0 : INF;
        for ( i = 1; i <= m; i++ ){
            scanf("%d%d",&a,&b);
            a++; b++; //注意将边+1，点+1.当然不这么处理也可以··
            map[a][b] = map[b][a] = i;
        }
        Dijkstra ( n );
        for ( i = 2; i <= n; i++ ){
            if (d[i] == MM) printf("-1\n");
            else printf("%d\n",cal(d[i]));
        }
    }
    return 0;
}

//并查集做法
//由于第i条边的权值w[i] = 2^i，那么前i-1条边的权值之和为w[0]+w[1]+·+w[i-1] =（2^i）-1
//也就是说前i-1条边的权值之和小于第i条边。
//根据这一性质，当添加第i条边（a，b）时：若a，b未连通，则a，b间的最短路径为w[i]；若a，b已经连通，则a，b之间的最短路径保持不变。
#include<bits/stdc++.h>
using namespace std;
const int maxn=105;
int p[maxn],sz[maxn],d[maxn][maxn],n;
void init(){
    for(int i=0;i<n;i++){
        p[i]=i;sz[i]=1;d[i][i]=0;
    }
}
int find(int x){
    while(x!=p[x]){
        p[x]=p[p[x]];
        x=p[x];
    }
    return x;
}
void union_p(int x,int y){
    int xf=find(x);int yf=find(y);
    if(xf==yf)return;
    if(sz[xf]<sz[yf]){p[xf]=yf;sz[yf]+=sz[xf];}
    else {p[yf]=xf;sz[xf]+=sz[yf];}
}
int mod(int a,int b){
    int ret=1;
    while(b--)ret=(ret*a)%100000;
    return ret;
}

int main(){
    int m,dist;
    while(scanf("%d%d",&n,&m)!=EOF){
        init();
        for(int i=0;i<m;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            int xf=find(x),yf=find(y);
            if(xf==yf)continue;
            dist=mod(2,i);
            for(int j=0;j<n;j++){
                if(xf!=find(j))continue;
                for(int k=0;k<n;k++){
                    if(yf!=find(k))continue;
                    d[j][k]=d[k][j]=(d[j][x]+dist+d[y][k])%100000;
                }
            }
            union_p(x,y);
        }
        int f0=find(0);
        for(int i=1;i<n;i++){
            if(find(i)!=f0)printf("-1\n");
            else printf("%d\n",d[0][i]);
        }
    }
    return 0;
}