(简单) FZU 2150 Fire Game ，Floyd。

　　Problem Description

　　Fat brother and Maze are playing a kind of special (hentai) game on an N*M board (N rows, M columns). At the beginning, each grid of this board is consisting of grass or just empty and then they start to fire all the grass. Firstly they choose two grids which are consisting of grass and set fire. As we all know, the fire can spread among the grass. If the grid (x, y) is firing at time t, the grid which is adjacent to this grid will fire at time t+1 which refers to the grid (x+1, y), (x-1, y), (x, y+1), (x, y-1). This process ends when no new grid get fire. If then all the grid which are consisting of grass is get fired, Fat brother and Maze will stand in the middle of the grid and playing a MORE special (hentai) game. (Maybe it’s the OOXX game which decrypted in the last problem, who knows.)

　　You can assume that the grass in the board would never burn out and the empty grid would never get fire.

　　Note that the two grids they choose can be the same.

　　这个题是要求找到放火的地方，然后能够最快烧完，刚开始想的是用BFS，首先枚举每两个点，然后BFS，10^6的复杂度，可是居然超时了，可能是用的STL，然后就想各种减枝，后来就直接用了Floyd，就是求任意两个点之间的最短距离，然后再枚举每两个点，求出最小值，居然只用了109ms，想不通居然快了10倍以上，复杂度都一样的。。。

代码如下:

#include<iostream>
#include<cstring>
#include<queue>
#include<ctime>
#include<cstdio>

using namespace std;

int map1[][];
int rem[][];
int N,M;
int minans;
int cou;
int flo[][][][];

bool judge(int ti,int tj)
{
    if(ti<=||tj<=||ti>N||tj>M)
        return ;

    return ;
}

void bfs(int si,int sj,int st)
{
    queue <int> que;
    int temp,ti,tj;

    que.push(si*+sj);
    map1[si][sj]=st;

    while(!que.empty())
    {
        temp=que.front();
        que.pop();

        ti=temp/;
        tj=temp%;

        if(judge(ti-,tj)&&map1[ti-][tj]==)
        {
            que.push((ti-)*+tj);
            map1[ti-][tj]=st;
        }
        if(judge(ti+,tj)&&map1[ti+][tj]==)
        {
            que.push((ti+)*+tj);
            map1[ti+][tj]=st;
        }
        if(judge(ti,tj-)&&map1[ti][tj-]==)
        {
            que.push(ti*+tj-);
            map1[ti][tj-]=st;
        }
        if(judge(ti,tj+)&&map1[ti][tj+]==)
        {
            que.push(ti*+tj+);
            map1[ti][tj+]=st;
        }
    }

}

void floyd()
{
    for(int i1=;i1<=N;++i1)
        for(int i2=;i2<=M;++i2)
            for(int j1=;j1<=N;++j1)
                for(int j2=;j2<=M;++j2)
                    if(i1==j1&&i2==j2)
                        flo[i1][i2][j1][j2]=;
                    else if((map1[i1][i2]>&&map1[j1][j2]>)&&((i1==j1&&(i2-j2==||i2-j2==-))||(i2==j2&&(i1-j1==||i1-j1==-))))
                        flo[i1][i2][j1][j2]=;
                    else
                        flo[i1][i2][j1][j2]=10e7;

    for(int k1=;k1<=N;++k1)
        for(int k2=;k2<=M;++k2)
            if(map1[k1][k2]>)
            for(int i1=;i1<=N;++i1)
                for(int i2=;i2<=M;++i2)
                if(map1[i1][i2]>)
                    for(int j1=;j1<=N;++j1)
                        for(int j2=;j2<=M;++j2)
                            if(map1[j1][j2]>)
                                flo[i1][i2][j1][j2]=min(flo[i1][i2][j1][j2],flo[i1][i2][k1][k2]+flo[k1][k2][j1][j2]);
}

int slove()
{
    cou=;

    memset(rem,-,sizeof(rem));
    for(int i=;i<=N;++i)
        for(int j=;j<=M;++j)
            if(map1[i][j]==)
            {
                ++cou;
                if(cou==)
                    return -;

                bfs(i,j,cou);

            }

    int temp,temp1;
    int maxn=-10e8;
    minans=10e8;
    int minn[]={10e8,10e8,10e8};

    if(cou==)
        return ;

    floyd();

    if(cou==)
    {
        for(int i1=;i1<=N;++i1)
            for(int i2=;i2<=M;++i2)
                if(map1[i1][i2]>)
            {
                maxn=-10e8;
                for(int j1=;j1<=N;++j1)
                    for(int j2=;j2<=M;++j2)
                        if(flo[i1][i2][j1][j2]<10e7&&flo[i1][i2][j1][j2]>maxn)
                        {
                            maxn=flo[i1][i2][j1][j2];
                            if(maxn>minn[map1[i1][i2]])
                                goto next1;
                        }

            next1:
                if(maxn<minn[map1[i1][i2]])
                    minn[map1[i1][i2]]=maxn;
            }

        return max(minn[],minn[]);
    }
    else
    {
        for(int i1=;i1<=N;++i1)
            for(int i2=;i2<=M;++i2)
                for(int j1=;j1<=N;++j1)
                    for(int j2=;j2<=M;++j2)
                        if(map1[i1][i2]>&&map1[j1][j2]>)
                        {
                            maxn=-10e8;
                            for(int k1=;k1<=N;++k1)
                                for(int k2=;k2<=M;++k2)
                                    if(map1[k1][k2]>)
                                        if(min(flo[i1][i2][k1][k2],flo[j1][j2][k1][k2])>maxn)
                                        {
                                            maxn=min(flo[i1][i2][k1][k2],flo[j1][j2][k1][k2]);
                                            if(maxn>minans)
                                                goto next2;
                                        }

                        next2:
                            if(maxn<minans)
                                minans=maxn;
                        }

        return minans;
    }
}

int main()
{
    ios::sync_with_stdio(false);

    int T;
    char c;
    int ans;
    cin>>T;

    for(int cas=;cas<=T;++cas)
    {
        cin>>N>>M;

        for(int i=;i<=N;++i)
            for(int j=;j<=M;++j)
            {
                cin>>c;
                if(c=='#')
                    map1[i][j]=;
                else
                    map1[i][j]=-;
            }

        ans=slove();

        cout<<"Case "<<cas<<": ";
        if(ans==-)
            cout<<-<<endl;
        else
            cout<<ans<<endl;
    }

    return ;
}