FZU2150,暴力广搜

题意就不解释了。

这道题目的话，如果用技巧的话，感觉有点难度，因为初始两点的选取不知道怎样选才能得到最短时间；

但是发现数据范围很小，这样的话，就可以暴力出所有的两点组合，在满足题意的情况下，选取最小的烧草时间即可。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int N = 12;
const int INF = 9999999;
int vis[N][N],n,m,cas,ans; //vis用来标记某点是否已走
char maz[N][N]; //存图
int dir[4][2] = {0,-1,-1,0,0,1,1,0};
struct node
{
    int x,y,ti;
} tmp; //x,y是这点的坐标，ti是火烧到这点的最短时间
queue<node>q;
int ok(int x,int y) //用来判断点是否越界
{
    if (x >= 0 && x < n && y >= 0 && y < m)
        return 1;
    return 0;
}
void bfs()
{
    int i,x,y;
    node f;
    while (!q.empty())
    {
        tmp = q.front();
        //这条语句很重要，队列里面最后一个元素的时间是最大烧草时间，最后保存在了tmp中
        q.pop();
        for (i = 0; i < 4; ++i)
        {
            x = tmp.x + dir[i][0];
            y = tmp.y + dir[i][1];
            if (ok(x,y) && maz[x][y] == '#' && !vis[x][y])
            {
                f.x = x;
                f.y = y;
                f.ti = tmp.ti + 1;
                vis[x][y] = 1;
                q.push(f);
            }
        }
    }
}
int is_ok() //选取两点放火，烧完之后，判断草是否已经全部烧完了
{
    int i,j;
    for (i = 0; i < n; ++i)
    {
        for (j = 0; j < m; ++j)
        {
            if (maz[i][j] == '#' && !vis[i][j])
                return 0;//说明还有草没有烧到，所以选取这两点是不满足题意的
        }
    }
    return 1;//说明所有的草都已经烧完了，选取的这两点满足题意
}
int main()
{
    int i,j,c,k,l;
    while (~scanf("%d",&cas))
    {
        for (c = 1; c <= cas; ++c)
        {
            scanf("%d%d",&n,&m);
            for (i = 0; i < n; ++i)
                scanf("%s",maz[i]);//输入图
            ans = INF;
            for (i = 0; i < n*m; ++i)//这两层for循环是用来找两个都是草的格子（暴力出所有的两两组合）
                //如果a，b满足条件入队列，和b，a入队列是等同的，所以内层for循环写成j<=i不是j<n*m，前者
                //减少了a,b和b,a重复入队列的情况（画图理解）
            {
                for (j = 0; j <= i; ++j)//之所以等于i，是因为选取的两点可能是同一点
                {
                    memset(vis,0,sizeof(vis));
                    while (!q.empty())
                        q.pop();
                    tmp.x = i / m;
                    tmp.y = i % m;
                    tmp.ti = 0;
                    vis[tmp.x][tmp.y] = 1;
                    if (maz[tmp.x][tmp.y] == '.')
                        continue;
                    q.push(tmp);
                    tmp.x = j / m;
                    tmp.y = j % m;
                    tmp.ti = 0;
                    vis[tmp.x][tmp.y] = 1;
                    if (maz[tmp.x][tmp.y] == '.')
                        continue;
                    q.push(tmp);
                    bfs();//从这两点开始烧
                    if (is_ok())
                        ans = min(ans,tmp.ti);//tmp是全局变量，且在bfs里面等于q.front()
                    //min()里面为什么是tmp.ti？首先很容易想到，在bfs里面由于刚开始入队列的两个点的时间都是
                    //0，且它们俩都在队列的最前面，所以由它们第一次拓展到的点时间是相同的，同理，这样
                    //下去，队列的最后一个点的时间一定是最大的（也就是最大烧草的时间）
                }
            }
            if (ans == INF)
                ans = -1;
            printf("Case %d: %d\n",c,ans);
        }
    }
    return 0;
}