Light OJ 1174 - Commandos （Floyd）

传送门：http://lightoj.com/volume_showproblem.php?problem=1174

题目大意：一个突击小队从敌人的总部的某个地方开始放炸弹，敌人的总部的各个建筑都是连通的，炸弹有无限个，小队里的队员有无限个，全部队员从起点一起出发，各自可以选择自己的要放置炸弹的路径，每个地方放一个炸弹，每个队员从一个地方移动到一个地方的时间为一个时间单位，问到某个终点的最短时间。

解题思路：通过Floyd求出dist[起点][某个地方i]和dist[某个地方i][终点]，通过把二者相加的最大值就是答案。

证明：从起点到终点的路上，有一个中转的地方，先要进去这个地方然后再出来，所以就是dist[start][inner]+dist[inner][end]。

Code：

/*   W          w           w        mm          mm             222222222       7777777777777    */
/*    W        w w         w        m  m        m  m          222        22              7777    */
/*    w        w w         w        m  m        m  m                     22              777     */
/*     w      w   w       w        m    m      m    m                    22              77      */
/*     w      w    w      w        m    m      m    m                 222                77      */
/*      w    w      w    w        m      m    m      m              222                  77      */
/*      w    w      w    w        m      m    m      m            222                    77      */
/*       w  w        w  w        m        m  m        m         222                      77      */
/*       w  w        w  w        m        m  m        m      222                         77      */
/*        ww          ww        m          mm          m     222222222222222             77      */

//#pragma comment(linker, "/STACK:102400000,102400000")
//C++
//int size = 256 << 20; // 256MB
//char *p = (char*)malloc(size) + size;
//__asm__("movl %0, %%esp\n" :: "r"(p));
//G++
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<ctime>
#include<deque>
#include<cmath>
#include<vector>
#include<string>
#include<cctype>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<sstream>
#include<iostream>
#include<algorithm>
#define REP(i,s,t) for(int i=(s);i<=(t);i++)
#define REP2(i,t,s) for(int i=(t);i>=s;i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned long ul;

const int MAXN=105;
int T;
int n,R;
int S,D;
struct FUCK
{
    int n;
    int d[MAXN][MAXN];
    void init(int n)
    {
        this->n=n;
        memset(d,-1,sizeof(d));
        REP(i,0,n-1)
        {
            d[i][i]=0;
        }
    }
    void addedge(int u,int v)
    {
        d[u][v]=d[v][u]=1;
    }
    void floyd()
    {
        REP(k,0,n-1)
        {
            REP(i,0,n-1)
            {
                REP(j,0,n-1)
                {
                    if(d[i][k]!=-1&&d[k][j]!=-1)
                    {
                        if(d[i][j]==-1)
                        {
                            d[i][j]=d[i][k]+d[k][j];
                        }
                        else
                        {
                            d[i][j]=min(d[i][k]+d[k][j],d[i][j]);
                        }
                    }
                }
            }
        }
    }
    int solve()
    {
        int res=0;
        floyd();
        REP(i,0,n-1)
        {
            if(d[S][i]!=-1&&d[i][D]!=-1)
            {
                res=max(res,d[S][i]+d[i][D]);
            }
        }
        return res;
    }
    void debug()
    {
        REP(i,0,n-1)
        {
            REP(j,0,n-1)
            {
                printf("d[%d][%d]=%d\n",i,j,d[i][j]);
            }
        }
    }
}solver;
int main()
{
  #ifdef ONLINE_JUDGE
  #else
    freopen("test.in","r",stdin);
  #endif
  int ca=1;
  scanf("%d",&T);
  while(T--)
  {
    scanf("%d%d",&n,&R);
    solver.init(n);
    REP(i,1,R)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        solver.addedge(u,v);
    }
    scanf("%d%d",&S,&D);
    int ans=solver.solve();
    printf("Case %d: %d\n",ca++,ans);
    //solver.debug();
  }
  return 0;
}