C++博客-hehexiaobai-随笔分类-图论题

poj 2672 Going from u to v or from v to u? 弱连通分量

田兵 — Sat, 11 Dec 2010 14:48:00 GMT

Going from u to v or from v to u?

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 8032		Accepted: 1892

Description

In order to make their sons brave, Jiajia and Wind take them to a big cave. The cave has n rooms, and one-way corridors connecting some rooms. Each time, Wind choose two rooms x and y, and ask one of their little sons go from one to the other. The son can either go from x to y, or from y to x. Wind promised that her tasks are all possible, but she actually doesn't know how to decide if a task is possible. To make her life easier, Jiajia decided to choose a cave in which every pair of rooms is a possible task. Given a cave, can you tell Jiajia whether Wind can randomly choose two rooms without worrying about anything?

Input

The first line contains a single integer T, the number of test cases. And followed T cases.

The first line for each case contains two integers n, m(0 < n < 1001,m < 6000), the number of rooms and corridors in the cave. The next m lines each contains two integers u and v, indicating that there is a corridor connecting room u and room v directly.

Output

The output should contain T lines. Write 'Yes' if the cave has the property stated above, or 'No' otherwise.

Sample Input

Sample Output

Yes

题目：给定一个图，问你是否对于任意的定点对x,y，能找到一条从x到y 或从y到x的路径，（满足一条即可）；

类型：弱连通分量。

解法：

这题花了很长时间，至少花了两个小时，到后来都想吐了，这让我更恶心到了两遍dfs求强连通分量的复杂。还好做出来了，虽然800+ms，还是挺爽的。

n： 1000，  m： 6000

原来什么都没想就开始做，每次spfa(x,y)，尝试从x找到一条道y的路径，果断TLE。其实肯定TLE，不知道当时怎么想的。

这题先求强连通分量，缩点，形成一棵新的树，这样主要是为了利用一些性质。若图是弱连通的，缩点后的树必须满足一下性质：

1，形成的是一棵树：这是必须的。否则从一棵树的点到另一棵树无法到达。

2，这棵树有且仅有一个点的入度是0, 如果有多个的话那么这些入度为0的点是不可以互相到达的。

3, 从这个入度为0的点进行dfs，找到的是一条链，就是不会有分叉，如果有的话，则两个分叉的点互相不可达。

（这点其实我不明白，应该是找条最长链的）

代码超级乱：


Source Code

    
        
            Problem: 2762
            
            User: hehexiaobai
        
        
            Memory: 9084K
            
            Time: 891MS
        
        
            Language: C++
            
            Result: Accepted
        
    


    Source Code
    #include
    #include
    #include
    using namespace std;
    const int MAXV = 1005;
    const int MAXE = 6005;
    int adj[MAXV][MAXV];
    int adj_op[MAXV][MAXV];
    int f[MAXV];
    int sblg[MAXV];
    int m, n, cntf,nstrong;
    bool visit[MAXV];
    bool strong[MAXV][MAXV];
    int in[MAXV];
    void dfs1(int u)
    {
    visit[u] = true;
    for(int i = 1; i <= adj[u][0]; i ++)
    if(!visit[adj[u][i]])dfs1(adj[u][i]);
    f[cntf] = u;
    cntf --;
    }
    void dfs2(int u, int nstrong)
    {
    visit[u] = true;
    sblg[u] = nstrong;
    for(int i = 1; i <= adj_op[u][0]; i ++)
    if(!visit[adj_op[u][i]])dfs2(adj_op[u][i],nstrong);
    }
    bool flag ;
    void dfs(int u)
    {
    visit[u] = true;
    int c = 0;
    for(int i = 1; i <= nstrong; i ++)
    {
    if(strong[u][i])
    {
    dfs(i);
    c ++;
    }
    }
    if(c > 1)flag = false;
    }
    int main()
    {
    int t,i,j, u, v;
    scanf("%d",&t);
    while(t--)
    {
    memset(adj,0,sizeof adj);
    memset(f,0,sizeof f);
    memset(adj_op, 0, sizeof (adj_op));
    scanf("%d %d",&n, &m);
    for(i = 0; i < m; i ++)
    {
    scanf("%d %d",&u, &v);
    adj[u][0] ++;
    adj[u][adj[u][0]] = v;
    adj_op[v][0] ++;
    adj_op[v][adj_op[v][0]] = u;
    }
    memset(visit, 0, sizeof visit);
    cntf = n ;
    for(i = 1; i <= n; i ++)
    if(!visit[i]) dfs1(i);
    memset(visit, 0, sizeof visit);
    memset(sblg, 0, sizeof (sblg));
    nstrong = 0;
    for(i = 1; i <= n;i ++)
    if(!visit[f[i]])
    {
    nstrong ++ ;
    dfs2(f[i], nstrong);
    }
    if(nstrong == 1)
    {
    printf("Yes\n");
    continue;
    }
    memset(in, 0, sizeof in);
    memset(strong, 0,sizeof strong);
    for( i  = 1; i <= n; i ++)
    for(j = 1; j <= adj[i][0]; j++ )
    if(sblg[i] != sblg[adj[i][j]])
    {
    in[sblg[adj[i][j]]] = true;
    strong[sblg[i]][sblg[adj[i][j]]] = true;
    }
    int index = -1;
    for(i = 1;i <= n; i ++)
    if(in[sblg[i]] == false)
    {
    index = sblg[i];
    break;
    }
    flag = true;
    memset(visit, 0, sizeof visit);
    dfs(index);
    /*	for(i = 1; i <= nstrong; i ++,cout << endl)
    for(j = 1; j <= nstrong; j ++)
    cout << strong[i][j]<<' ';
    */
    for(i = 1; i <= nstrong;i ++)
    if(visit[i] == false)
    flag = false;
    if(flag == true)
    {
    printf("Yes\n");
    }
    else printf("No\n");
    }
    return 0;
    }

田兵 2010-12-11 22:48 发表评论

poj 1679 The Unique MST

田兵 — Sat, 11 Dec 2010 08:48:00 GMT

第一次写次小生成树，没想到

思想就是：求一次最小生成树，记录所用到的边，然后不用所有第一次用到的边尝试构成构成最小生成树。

用Kruskal先求最小生成树，结果即为min，把所用到的边记录下来（这里是记录的对应的下表），然后枚举这些边，

每次去掉一个边求一次最小生成树，结果为tmin，如果能够成最小生成树并且tmin==min，则说明最小生成树不唯一

#include //poj 1679

#include

using namespace std;

const int MAX = 101;

int n, m;

struct edge

{

int x;

int y;

int len;

}E[MAX*MAX];

int fa[MAX];

int indexEdge[MAX];

int index;

bool cmp(const edge &a, const edge &b)

{

return a.len < b.len;

}

int find(int x)

{

if(fa[x] == x)return x;

return fa[x] = find(fa[x]);

}

int Kruskal(int location) //不用location位置的边

{

int ans = 0;

int tx, ty;

int cnt = 0;

if (location == -1)index = 0;//location == -1 第一次求最小生成树，indexEdge[index]纪录第index用到的边的下标

for(int k = 1; k <= n; k ++)fa[k] = k;

for(int i = 0; i < m; i ++)

{

if(i == location)continue;

tx = find(E[i].x);

ty = find(E[i].y);

if(tx != ty)

{

fa[tx] = ty;

ans += E[i].len;

cnt ++;

if(location == -1)//第一次最小生成树的时候把location置为-1

{

indexEdge[index] = i;

index ++;

}

if(cnt == n - 1)break;

}

if(cnt == n - 1)return ans;

return -1;

}

int main()

{

int t, i;

scanf("%d",&t);

while(t --)

{

memset(E, 0, sizeof E);

memset(indexEdge, 0, sizeof indexEdge);

scanf("%d %d",&n, &m);

for(i = 0; i < m; i ++)

scanf("%d %d %d",&E[i].x, & E[i].y , & E[i].len);

sort(E, E + m, cmp);

int min = Kruskal(-1);

int tmin = (1<<20), temp;

//cout << index << endl;

for(i = 0; i < index; i ++)

{

   //cout <   temp = Kruskal(indexEdge[i]);
   if(temp != -1 && temp < tmin)
   tmin = temp;
   }

   if(tmin == min)
   printf("Not Unique!\n");
   else printf("%d\n",min);
   }

   return 0;
}

田兵 2010-12-11 16:48 发表评论

AOJ 236 Cow Picnic , poj 3256

田兵 — Mon, 30 Aug 2010 07:49:00 GMT

Cow Picnic

Time Limit: 2000 ms   Memory Limit: 64 MB
Total Submission: 1   Accepted: 1

Description

The cows are having a picnic! Each of Farmer John's K (1 ≤ K ≤ 100) cows is grazing in one of N (1 ≤ N ≤ 1,000) pastures, conveniently numbered 1...N. The pastures are connected by M (1 ≤ M ≤ 10,000) one-way paths (no path connects a pasture to itself).

The cows want to gather in the same pasture for their picnic, but (because of the one-way paths) some cows may only be able to get to some pastures. Help the cows out by figuring out how many pastures are reachable by all cows, and hence are possible picnic locations.

Input

Line 1: Three space-separated integers, respectively: K, N, and M
Lines 2..K+1: Line i+1 contains a single integer (1..N) which is the number of the pasture in which cow i is grazing.
Lines K+2..M+K+1: Each line contains two space-separated integers, respectively A and B (both 1..N and A != B), representing a one-way path from pasture A to pasture B.

Output

Line 1: The single integer that is the number of pastures that are reachable by all cows via the one-way paths.

Sample Input

2 4 4
2
3
1 2
1 4
2 3
3 4

Sample Output

2[EOL][EOF]

Hint

The cows can meet in pastures 3 or 4.

Source

USACO 2006 December Silver

从每个牛开始求一次单源最短路径，假设起点是X，如果从X能到i (di[i]!=INF) ，cnt[i]++，用来统计能到达 i 点的牛的数量。

结果就是满足cnt[i]==K的数量，即i点所有的牛都可以到达。

用spfa求，spfa在这里不是求最段路径，只要到了就行，不需要是最短的，因此会更快一点。

#include<iostream>
#include<time.h>
#include<vector>
#include<queue>
using namespace std;
const int MAX=1001,INF=0x0fffffff;
vector<int> mp[MAX];
int d[MAX], cnt[MAX];
int K,N,M;
int stay[101];
void spfa(int x)
{
     for(int i=1; i<=N; i++)
             d[i]=INF;
     queue<int>q;
     q.push(x);
     d[x]=0;
     while(q.size())
     {

          int u=q.front(); q.pop();
          for(int i=0; i<mp[u].size(); i++)
          {
                  if(d[mp[u][i]]==INF)
                  {
                       d[mp[u][i]]=d[u]+1;
                       q.push(mp[u][i]);
                  }
          }

     }
}

int main()
{
    cin>>K>>N>>M;

    for(int i=1; i<=K; i++)
            cin>>stay[i];

    for(int i=1,s,t; i<=M; i++)
            {
                     cin>>s>>t;
                     mp[s].push_back(t);
            }

    for(int i=1; i<=K; i++)
    {
       spfa(stay[i]);
       for(int i=1; i<=N; i++)
               if(d[i]!=INF)cnt[i]++;
    }

    int ans=0;

    for(int i=1; i<=N; i++)
            if(cnt[i]==K)ans++;

    cout<<ans<<endl;
    system("pause");
    return 0;
}

田兵 2010-08-30 15:49 发表评论

poj 1274 The Perfect Stall

田兵 — Mon, 30 Aug 2010 02:09:00 GMT

二分图的最大匹配，加一个源点，这个源点到左边所有顶点加一条边，权值为1. 。同理，加一个终点，所有右边的定点到这个终点有条边，权值为1. 这样二分图的最大匹配就转换成了最大流问题。

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int MAX=405;
int cap[MAX][MAX]={0};
int flow[MAX][MAX]={0};
int pre[MAX],m[MAX];
int N, M,S,T;
const int INF=10000000;

int bfs(int s)
{
    memset(m,0,sizeof m);
    memset(pre,0,sizeof pre);
    queue<int> q;
    q.push(s);
    m[s]=INF;
    while(!q.empty())
    {
            int u=q.front(); q.pop();
            for(int v=0; v<=N+M+1; v++)
                    if(!m[v]&&cap[u][v]>flow[u][v])
                    {
                         pre[v]=u;
                         m[v]= m[u]>cap[u][v]-flow[u][v]?cap[u][v]-flow[u][v]:m[u];
                         q.push(v);
                    }
    }

   if(m[T]==0)return 0;

   for(int u=T; u!=S ; u=pre[u])
   {
           flow[pre[u]][u]+=m[T];
           flow[u][pre[u]]-=m[T];
   }
   return m[T];
}

int main()
{

    while(cin>>N>>M)
    {    memset(cap,0,sizeof cap);
         memset(flow,0,sizeof flow);
         for(int i=1; i<=N; i++)
         {
            int c,e;
            cin>>c;
            for(int j=1; j<=c; j++)
                   {
                         cin>>e;
                         e=e+N;
                         cap[i][e]=1;
                   }
         }
         S=0;
         T=N+M+1;
         for(int i=1; i<=N; i++)
            cap[0][i]=1;

         for(int i=1; i<=M; i++)
            cap[N+i][T]=1;

         int ans=0;
         while(1)
         {
            int temp=bfs(S);
            if(temp==0)break;
            else ans+=temp;
         }

         cout<<ans<<endl;
    }
    system("pause");
    return 0;
}

田兵 2010-08-30 10:09 发表评论

poj 1273 Drainage Ditches

田兵 — Wed, 25 Aug 2010 07:30:00 GMT

         赤裸裸的最大流问题，也是我写第一个最大流，是入门的好题。

         发现看代码有时候比看书更容易懂，看最大流已经看了好几天书了，都是晕乎乎的，参考了一下别人的代码，似乎有些了解了。

      Ford-Fulkerson方法的增广路算法
      每次用dfs寻找可增广路径，该路径上的所有边的容量均要是正数，如果找到就取该路径上所有容量的最小值作为增加的流。如果不存在则说明已经是最大流，结束。

下面这两个程序在hdu有点小问题，第三个是在两个OJ上都可以的。

#include<iostream>
using namespace std;
int map[250][250];
int pre[250];
bool visit[250];
int m,n,minflow;
const int INF=0x7fffffff/1000;

int dfs(int v)
{
    visit[v]=true;
    if(v==n)return 1;
    for(int i=1; i<=n; i++)
            if(map[v][i]>0&&!visit[i])
              {
                  pre[i]=v;
                  minflow=minflow>map[v][i]?map[v][i]:minflow;
                  if(dfs(i))return true;
              }
    return 0;
}

int maxflow()
{
    int maxf=0;
    while(1)
    {
           memset(pre,0,sizeof pre);
           minflow=INF;
           memset(visit,0,sizeof visit);
           pre[1]=-1;
           if(dfs(1))
           {

                     int inc=minflow;
                     int t=n;
                     while(pre[t]!=-1)
                     {
                          int qq=pre[t];
                          map[qq][t]-=inc;
                          map[t][qq]+=inc;
                          t=qq;
                     }
                     maxf+=inc;
           }
           else break;
    }
    return maxf;
}

int main()
{
    while(cin>>m>>n)
    {
       int s,t,c;
       memset(map,0,sizeof map);
       while(m--)
       {
                cin>>s>>t>>c;
                map[s][t]+=c;
       }
       cout<<maxflow()<<endl;
    }

   system("pause");
   return 0;
}

用BFS的Edmonds-Karp算法

#include<iostream>
#include<queue>
using namespace std;
int map[250][250];
int pre[250];
bool visit[250];
int m,n,minflow;
const int INF=0x7fffffff/1000;

int bfs(int s)
{
    queue<int> Q;
    Q.push(s);
    visit[s]=true;
    while(Q.size())
    {
         int v=Q.front(); Q.pop();
         if(v==n)return true ;
         for(int i=1; i<=n; i++)
                 if(!visit[i]&&map[v][i]>0&&!visit[n])
                 {
                     pre[i]=v;
                     visit[i]=true;
                     minflow=minflow>map[v][i]?map[v][i]:minflow;
                     Q.push(i);
                 }

    }
    return false;
}

int maxflow()
{
    int maxf=0;
    while(1)
    {
           memset(pre,0,sizeof pre);
           minflow=INF;
           memset(visit,0,sizeof visit);
           pre[1]=-1;
           if(bfs(1))
           {
                     int inc=minflow;
                     int t=n;
                     while(pre[t]!=-1)
                     {
                          int qq=pre[t];
                          map[qq][t]-=inc;
                          map[t][qq]+=inc;
                          t=qq;
                     }
                     maxf+=inc;
           }
           else break;
    }
    return maxf;
}

int main()
{
    while(cin>>m>>n)
    {
       int s,t,c;
       memset(map,0,sizeof map);
       while(m--)
       {
                cin>>s>>t>>c;
                map[s][t]+=c;
       }
       cout<<maxflow()<<endl;
    }

   system("pause");
   return 0;
}

问题或许就出现在取最小值的问题上，不过我认为前两种每次取的可能不是最小的，但应该是没错的。
最多多dfs或bfs几次。

#include<iostream>
#include<string.h>
using namespace std;
int map[250][250];
int pre[250],q[250];
bool visit[250];
int m,n;
const int INF=0x7fffffff;

bool dfs(int v)
{
    visit[v]=true;
    if(v==n)return true;
    for(int i=1; i<=n; i++)
            if(map[v][i]>0&&!visit[i])
              {
                  pre[i]=v;
                  q[i]=q[v]>map[v][i]?map[v][i]:q[v];
                  if(dfs(i))return true;
              }
    return 0;
}

int maxflow()
{
    int maxf=0;
    while(1)
    {
           memset(pre,0,sizeof pre);
           memset(q,0,sizeof q);
           //for(int i=1; i<=n; i++)
                   q[1]=INF;
           memset(visit,0,sizeof visit);
           pre[1]=-1;
           if(dfs(1))
           {

                     int inc=q[n];
                     int t=n;
                     while(pre[t]!=-1)
                     {
                          int qq=pre[t];
                          map[qq][t]-=inc;
                          map[t][qq]+=inc;
                          t=qq;
                     }
                     maxf+=inc;
           }
           else break;
    }
    return maxf;
}

int main()
{
    while(cin>>m>>n)
    {
       int s,t,c;
       memset(map,0,sizeof map);
       while(m--)
       {
                cin>>s>>t>>c;
                map[s][t]+=c;
       }
       cout<<maxflow()<<endl;
    }

   system("pause");
   return 0;
}

田兵 2010-08-25 15:30 发表评论

poj 3268 Silver Cow Party 【两次dijstra】

田兵 — Thu, 19 Aug 2010 01:38:00 GMT
题意：
             就是从各点到X的最短距离及从X到各点的最短距离和的最大值。

第一利用dijstra求出从X到各点的最短距离。

然后所有的边反向，再进行一次dijstra求X到各点的最短路径。

第二次求出的最短路径也就是各点到X的最短路径，因为边已经反向，对于第二次从X到各点的最短路径正是
原图从各点到X的最短路径。

#include<iostream>
#include<queue>
using namespace std;
const int INF=0x7fffffff/100;
int map[1001][1001]={0};
int d[1001]={0},N,M,X;
int dd[1001]={0};
bool f[1001];
void dijstra()
{
     for(int i=1; i<=N; i++)
             d[i]=INF;
     d[X]=0;
     memset(f,0,sizeof f);
     for(int i=1; i<=N; i++)
     {
             int min=INF,u=0;
             for(int j=1; j<=N; j++)
                     if(d[j]<min&&!f[j])
                     {
                                 min=d[j];
                                 u=j;
                     }
             f[u]=true;
             for(int j=1; j<=N; j++)
             {
                     if(d[u]+map[u][j]<d[j])
                        d[j]=d[u]+map[u][j];
             }
     }

}

void traverse()
{
     int temp;
     for(int i=1; i<=N; i++)
     for(int j=1; j<i; j++)
     {
             temp = map[i][j];
             map[i][j]=map[j][i];
             map[j][i]=temp;
     }
}

int main()
{

    cin>>N>>M>>X;

    for(int i=1; i<=N; i++)
    for(int j=1; j<=N; j++)
            map[i][j]=INF;
    for(int i=1,s,t,value; i<=M; i++)
    {
          cin>>s>>t>>value;
          map[s][t]=value;
    }

    dijstra();
    for(int i=1; i<=N; i++)
             dd[i]=d[i];

    traverse();
    dijstra();
    int max=0;
    for(int i=1; i<=N; i++)
            if(d[i]+dd[i]>max)max=d[i]+dd[i];

    cout<<max<<endl;

    system("pause");
    return 0;
}

田兵 2010-08-19 09:38 发表评论

AOJ--The Max Weight--Floyd Folyd算法变形，把求最短路径的和改为求最大载重量的问题

田兵 — Sat, 29 May 2010 14:03:00 GMT

The Max Weight

Time Limit: 1000 ms   Memory Limit: 64 MB
Total Submission: 36   Accepted: 4

Description

There a lot of bridges connect different positions in Venice,but they can't carry too much weigh,so each of them has a limit which can be described as an interger.A man wants to carry some goods from positon 1 to n.Help him find how much can he carry.

Input

There are T cases.
For each case,the number of positions ( 1 < = n < = 100) and number m of bridges are exhibited on the first line.The following m lines contain triples of integers specifying start and end positions of the bridge and the maximum allowed weight, which is positive and not larger than 1000000. There will be at most one bridge between each pair of crossings.

Output

The output for every scenario begins with a line containing "Case #i:", where i is the number of the scenario starting at 1. Then print a single line containing the maximum allowed weight that the man can transport. Terminate the output for the scenario with a blank line.

Sampel Input

1
3 3
1 2 3
1 3 4
2 3 5

Sample Output

Case #1:[EOL]
4[EOF]

题意：
n个点，有些点间有桥，桥上有最大承重量，问你从1到n可以最大携带的物品的重量。
题解：
Folyd算法变形，把求最短路径的和改为求最大载重量的问题，关键是dis[i][j]=dis[i][j]>dis[i][k]+dis[k][j]?dis[i][j]>dis[i][k]+dis[k][j]?:dis[i][j];换成dis[i][j]=max(dis[i][j],min(dis[i][k],dis[k][j]));

1#include<iostream>
2#include<cmath>
3#include<string.h>
4using namespace std;
5long long dis[105][105];
6
8void Floyd(int n)
9{
10     for(int k=1; k<=n; k++)
11     for(int i=1; i<=n; i++)
12     for(int j=1; j<=n; j++)
13     {
14       if(i!=k&&j!=k&&dis[i][k]&&dis[k][j])
15         dis[i][j]=max(dis[i][j],min(dis[i][k],dis[k][j]));
16     }
17}
18
19int main()
20{
21    int t,i,j,m,n;
22    cin>>t;
23    for(int k=1; k<=t; k++)
24    {
25      cin>>n>>m;
26      memset(dis,0,sizeof (dis));
27      i=1;
28      for(int s,e,w; i<=m; i++)
29      {
30        cin>>s>>e>>w;
31        dis[s][e]=dis[e][s]=w;
32      }
33
34      Floyd(n);
35
36     cout<<"Case #"<<k<<':'<<endl<<dis[1][n]<<endl<<endl;
37    }
38    return 0;
39}

田兵 2010-05-29 22:03 发表评论

USACO--AOJ Bessie Come Home --Floyd算法

田兵 — Sun, 23 May 2010 12:03:00 GMT

Bessie Come Home

Time Limit:JAVA/Others2000/1000MS Memory Limit:JAVA/Others131072/65536KB
Total Submit:6 Accepted:2

Description
It's dinner time, and the cows are out in their separate pastures. Farmer John rings the bell so they will start walking to the barn. Your job is to figure out which one cow gets to the barn first (the supplied test data will always have exactly one fastest cow).

Between milkings, each cow is located in her own pasture, though some pastures have no cows in them. Each pasture is connected by a path to one or more other pastures (potentially including itself). Sometimes, two (potentially self-same) pastures are connected by more than one path. One or more of the pastures has a path to the barn. Thus, all cows have a path to the barn and they always know the shortest path. Of course, cows can go either direction on a path and they all walk at the same speed.

The pastures are labeled `a'..`z' and `A'..`Y'. One cow is in each pasture labeled with a capital letter. No cow is in a pasture labeled with a lower case letter. The barn's label is `Z'; no cows are in the barn, though.

Input

Line 1: Integer P (1 <= P <= 10000) the number of paths that interconnect the pastures (and the barn)

Line 2..P+1: Space separated, two letters and an integer: the names of the interconnected pastures/barn and the distance between them (1 <= distance <= 1000)

Output
A single line containing two items: the capital letter name of the pasture of the cow that arrives first back at the barn, the length of the path followed by that cow.

Sample Input

5 A d 6 B d 3 C e 9 d Z 8 e Z 3

Sample Output

B 11

1Floyd 算法：http://icpc.ahu.edu.cn:8080/AOJ/   做的第一个图论题
2图的最短路径问题，到‘Z’的最短路径；
3Floyd算法大概知道怎么用了，好像是动态规划实现的，不知道为什么这样是对的
4O（N^3）求解最短路径问题，数据范围超过400可能就危险了
5#include<iostream>
6#include<string.h>
7using namespace std;
8int dis[53][53];
9const int INF=10000000;
10void Floyd(int n)
11{
12     for(int k=1; k<=n; k++)
13     for(int i=1; i<=n; i++)
14     for(int j=1; j<=n; j++)
15      if(i!=k&&k!=j&&i!=j&&dis[i][k]+dis[k][j]<dis[i][j])
16      dis[i][j]=dis[i][k]+dis[k][j];
17
18}
19
20
21int main()
22{
23    int p,i,j,k,d,n1,n2;
24    cin>>p;
25    memset(dis,0,sizeof (dis));
26    for(i=1; i<=52; i++)
27    for(j=1; j<=52; j++)
28    dis[i][j]=INF;
29
30    for(i=1; i<=p; i++)
31    {
32       char v1,v2;
33       cin>>v1>>v2>>d;
34       if(v1==v2)continue;
35       n1=(v1>='a'?v1-'a'+1:v1-'A'+26+1);
36       n2=(v2>='a'?v2-'a'+1:v2-'A'+26+1);
37       if(d<dis[n1][n2])dis[n1][n2]=dis[n2][n1]=d;
38    }
39
40    Floyd(52);
41
42    int min=INF+100;
43    char c;
44    for(i=27; i<=51; i++) //大写字母到Z
45    {
46       if(dis[i][52]<min){min=dis[i][52];c=i; }
47    }
48    cout<<char(c-27+'A')<<' '<<min<<endl;
49    //system("pause");
50    return 0;
51}
52

田兵 2010-05-23 20:03 发表评论

Problem: 2762		User: hehexiaobai
Memory: 9084K		Time: 891MS
Language: C++		Result: Accepted

Line 1:	Integer P (1 <= P <= 10000) the number of paths that interconnect the pastures (and the barn)
Line 2..P+1:	Space separated, two letters and an integer: the names of the interconnected pastures/barn and the distance between them (1 <= distance <= 1000)