poj1125——Stockbroker Grapevine

题目大意：有n个股票经纪人，他们之间互相传递消息，且耗时不同，问从哪个人开始传递消息，最终所有人都收到消息的最短耗时，如果不能让所有人都收到消息，则输出disjoint

输入：（可以有很多case，输入以0结束）

           n（1~100）

           第i个人的联系人个数  第1个联系人的号码  耗时  第2个联系人的号码  耗时 ...（联系人个数0~n-1  耗时1~10）

           0

输出：起始人号码  最短耗时时长（对每一个数据集输出一行答案）

分析：dijstra枚举或者多源最短路floyd或者bellman或者spfa求出每人作为起始点传递消息所需的传播时间，由于可在同一时间传播，所以传播时间一定是源点到每个联系人的最短路径中的最远距离，然后枚举源点，找出所有最远距离中的最小值即可

代码：

方法一：floyd。

#include <cstdio>  
#include <cstring>  
#include <algorithm>  
#include <iostream>  
  
using namespace std;  
  
int n;  
int edges[105][105];  
int main() {  
    while (~scanf("%d", &n) && n) {  
        memset(edges, 0x3f, sizeof(edges));  
        int t, a, b;  
        for (int i = 1; i <= n; i++) {  
            scanf("%d", &t);  
            for (int j = 1; j <= t; j++) {  
                scanf("%d %d", &a, &b);  
                edges[i][a] = b;  
            }  
            edges[i][i] = 0;
        }  
        for (int k = 1; k <= n; k++)  
            for (int i = 1; i <= n; i++)  
                for (int j = 1; j <= n; j++)  
                    edges[i][j] = min(edges[i][j], edges[i][k] + edges[k][j]);  
        int ans = 0x3f3f3f3f;  
        int idx = 0;  
        for (int i = 1; i <= n; i++) {  
            int dist = 0;  
            for (int j = 1; j <= n; j++)  
                dist = max(dist, edges[i][j]);  
            if (dist < ans) {  
                ans = dist;  
                idx = i;  
            }  
        }  
        if (ans == 0x3f3f3f3f)  
            printf("disjoint\n");  
        else printf("%d %d\n", idx, ans);  
    }  
    return 0;  
} 

方法二：dijkstra。

#include <algorithm>  
#include <cstring>  
#include <cstdio>  
using namespace std;  
const int maxn=105;  
const int inf=0x5fffffff;  
int Map[maxn][maxn],dist[maxn],p[maxn];  
int n,m;  
void initial_map()  //初始化图，用邻接矩阵建图,空间复杂度为O(n^2)  
{  
    for(int i=1;i<=n;i++){  
        for(int j=1;j<=n;j++){  
            if(i==j)    Map[i][j]=0;  
            else        Map[i][j]=inf;  
        }  
    }  
    for(int i=1;i<=n;i++){  
        int t,v,w;  
        scanf("%d",&t);  
        while(t--){  
            scanf("%d%d",&v,&w);  
            Map[i][v]=w;  
        }  
    }  
}  
void Dijkstra(int s)  //以s为源点的单源最短路  
{  
    memset(p,0,sizeof(p));  
    for(int i=1;i<=n;i++){  
       dist[i]=Map[s][i];  
    }  
    dist[s]=0;  
    p[s]=1;  
    int i,j,k,Min;  
    for(i=1;i<=n-1;i++){  
        Min=inf,k=s;  
        for(j=1;j<=n;j++){  
            if(!p[j]&&Min>dist[j]){  //我艹，把符号写反了，3wa  
                Min=dist[j];  
                k=j;  
            }  
        }  
        if(k==s)    return; 
        p[k]=1;  
        for(j=1;j<=n;j++){    //松弛操作，更新  
            if(!p[j]&&Map[k][j]!=inf&&dist[j]>dist[k]+Map[k][j]){  
                dist[j]=dist[k]+Map[k][j];  
            }  
        }  
    }  
}  
int main()  
{  
    //freopen("in.txt","r",stdin);  
    while(scanf("%d",&n)==1){  
        if(n==0)    break;  
        initial_map();  
        int maxLength=-inf,minTrans=inf,fastTrans=1;  
        for(int i=1;i<=n;i++){  
            maxLength=0;  
            Dijkstra(i);  //以每个节点为源点的单源最短路  
            for(int j=1;j<=n;j++){  
               if(dist[j]>maxLength){  
                    maxLength=dist[j];  
               }  
            }  
            if(maxLength<minTrans){  
                fastTrans=i;  
                minTrans=maxLength;  
            }  
        }  
        if(minTrans==inf){   //不可以达到  
            printf("disjoint\n");  
        }else{  
            printf("%d %d\n",fastTrans,minTrans);  
        }  
    }  
    return 0;  
}

方法三：bellman-ford。转载自http://blog.csdn.net/became_a_wolf/article/details/47777241

 

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cstring>  
4. #include<cmath>  
5. #define INF 10000000  
6.   
7. using namespace std;  
8.   
9. struct node  
10. {  
11.     int u,v,w;  
12. }edge[2000];  
13. int n,num;  
14. int low[2000];  
15. int path[2000];  
16. int Bellman(int u0)  
17. {  
18.     for(int i=0;i<=n;i++)  
19.         low[i]=INF;  
20.     low[u0]=0;  
21.     for(int i=0;i<n-1;i++)  
22.     {  
23.         int flag=0;  
24.         for(int j=0;j<num;j++)     
25.         {  
26.         if(low[edge[j].u]!=INF && edge[j].w+low[edge[j].u]<low[edge[j].v])  
27.             {low[edge[j].v]=edge[j].w+low[edge[j].u];  
28.               flag=1;  
29.             }  
30.         }  
31.         if(flag==0)  
32.             break;  
33.     }  
34.     int Max=-1;  
35.     for(int i=1;i<=n;i++)  
36.     if(Max<low[i])  
37.     Max=low[i];  
38.     return Max;  
39. }  
40. int main()  
41. {  
42.     while(~scanf("%d",&n))  
43.     {  
44.         if(n==0)  
45.             break;  
46.         num=0;  
47.         for(int i=1;i<=n;i++)  //从1开始  
48.         {  
49.             int m;  
50.             scanf("%d",&m);  
51.             for(int j=1;j<=m;j++)  
52.             {  
53.                 int x,t;  
54.                 scanf("%d%d",&x,&t);  
55.                 edge[num].u=i;  
56.                 edge[num].v=x;  
57.                 edge[num++].w=t;  
58.             }  
59.         }  
60.   
61.         int Min=INF,biao=-1;  
62.         for(int i=1;i<=n;i++)  
63.         {  
64.             int k=Bellman(i);  
65.             if(Min>k)  
66.             {Min=k;  
67.              biao=i;  
68.             }  
69.         }  
70.         if(biao==-1)  
71.             printf("disjoint\n");  
72.         else  
73.             printf("%d %d\n",biao,Min);  
74.     }  
75. }

方法四：spfa。转载自http://blog.csdn.net/acblacktea/article/details/50494069