九度oj 1100

题目描述：

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 4
1 2
2 3
1 3
0 1

样例输出：

8
9
11

来源：

2010年上海交通大学计算机研究生机试真题

#include<stdio.h>
#include<vector>
#include<math.h>
#include<iostream>
#define true 1
#define false 0
using namespace std;
int tree[1001];
int fun(int x)
{
    if(x==0)
    {
            return 1;}
            else
            return (2*fun(x-1))%100000;
            
            }
int findroot(int x)
{
    if(tree[x]==-1)
    return x;
    else 
    return findroot(tree[x]);
}
struct A{
       int next;
       int cost;
       };
       vector<A> edge[1001];
       bool mark[1001];
       int dis[1001];
       int main()
       {
           int n,m;
           while(cin>>n>>m)
           {
                           if(n==0&&m==0)
                           {
                                         break;
                                         }
                                         for(int i=0;i<n;i++)
                                         {
                                                 edge[i].clear();
                                                 dis[i]=-1;
                                                 tree[i]=-1;
                                                 mark[i]=false;
                                                 }
                                                 for(int i=0;i<m;i++)
                                                 {
                                                         int a,b;
                                                         cin>>a>>b;
                                                         int x=findroot(a);
                                                         int y=findroot(b);
                                                         if(x!=y)
                                                         {
                                                                 tree[x]=y;
                                                                 A tmp;
                                                                 tmp.next=b;
                                                                 tmp.cost=fun(i);
                                                                 edge[a].push_back(tmp);
                                                                 tmp.next=a;
                                                                 edge[b].push_back(tmp);
                                                                 }
                                                                 }
                                                                 dis[0]=0;
                                                                 int t=n;
                                                                 bool flag=false;
                                                                 int newp,k;
                                                                 while(t--)
                                                                 {
                                                                           newp=1;
                                                                           while(newp<n)
                                                                           {
                                                                                      if(mark[newp]==true)
                                                                                      {
                                                                                                        newp++;
                                                                                                        continue;
                                                                                                        }
                                                                                                        for(int j=0;j<edge[newp].size();j++)
                                                                                                        {
                                                                                                                if(dis[edge[newp][j].next]!=-1)
                                                                                                                {
                                                                                                                   dis[newp]=(dis[edge[newp][j].next]+edge[newp][j].cost)%100000;
                                                                                                                   mark[newp]=true; 
                                                                                                                   flag=true;
                                                                                                                   break;
                                                                                                                   }
                                                                                                                   }
                                                                                                                   if(flag==true)
                                                                                                                   {
                                                                                                                                 flag=false;
                                                                                                                                 break;
                                                                                                                                 }
                                                                                                                                 else
                                                                                                                                 newp++;
                                                                                                                                 }
                                                                                                                                 }
                                                                                                                                 for(int i=1;i<n;i++)
                                                                                                                                 {
                                                                                                                                         cout<<dis[i]<<endl;
                                                                                                                                         }
                                                                                                                                         }
                                                                                                                                         }