TZOJ 7331: 旅游 广搜+深搜

描述

 

 

给定一个n*m的地图，每个方格可以取：

(1)“*”：表示一个景点；

(2)“#”: 表示墙壁，不可经过；

(3)“.”: 表示通道，可以经过；

现在你从左上角(0, 0)出发，需要走遍每个景点，且回到起点，问最少需要几步。

 

 

输入

 

 

第一行为n和m，表示地图的行数和列数(1<=n, m<=10)。

接下来有n行，每行m个字符（仅含*, #和.）。

其中*的个数不超过10个。

 

 

输出

 

 

如果从左上角(0, 0)出发，能够走遍每个景点且回到起点，则输出最少步数；

否则输出Impossible

 

 

样例输入

 

4 7
.....*.
...#...
.*.#.*.
.......

样例输出

 

16

思路：

提前将起点加入jd数组，在输入地图的时候如果有景点*，那么就存入到jd数组中，然后初始化地图g为较大的数，循环地图中的k个景点，此时让一个变量

f为1，在循环k个景点过程中，我们要找到每个景点之间的最短路并建图，所以i：1->k，j：i->k，如果i，j相同那么就是相同景点，g[i][j] = g[j][i] = 0；否则不同景点的情况我们要判断，用step来接收bfs返回的值，bfs返回的不是-1证明i到j之间是走得通的，如果是-1那么就证明有景点无法访问，f=0；

当我们执行完了k个点的bfs最终得到了各个点之间的最短路后，我们要从起点出发dfs，每走完k个景点，就要去判断当前路径步数是否最小，在多次搜索里找到最小值最后输出即可

#include <bits/stdc++.h>
using namespace std;
struct node{
    int x,y,step;
};
node q[105];
int nex[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};
int vis[15][15],g[15][15];
int jd[105][2];
char a[15][15];
int book[105];
int n,m,k,ans,sum,f=1;
int bfs(int sx,int sy,int ex,int ey)
{
    int f=0,head=1,tail=1;
    memset(vis,0,sizeof(vis));
    q[tail].x = sx;
    q[tail].y = sy;
    q[tail].step = 0;
    vis[sx][sy] = 1;
    tail++;
    while(head<tail)
    {
        for(int i=0;i<4;i++)
        {
            int tx = nex[i][0] + q[head].x;
            int ty = nex[i][1] + q[head].y;
            if(tx<1||tx>n||ty<1||ty>m)continue;
            if(vis[tx][ty]==0&&a[tx][ty]!='#')
            {
                q[tail].x = tx;
                q[tail].y = ty;
                q[tail].step = q[head].step+1;
                tail++;
                vis[tx][ty] = 1;
            }
            if(tx==ex&&ty==ey)
            {
                return q[tail-1].step;
            }
        }
        head++;
    }
    return -1;
}
void dfs(int x,int l)
{
    if(l==k){
        ans = min(sum+g[x][1],ans);
        return;
    }
    for(int i=1;i<=k;i++)
    {
        if(book[i]!=1)
        {
            book[i] = 1;
            sum+=g[x][i];
            l++;
            dfs(i,l);
            l--;
            book[i] = 0;
            sum-=g[x][i];
        }
    }
}
int main()
{
    cin>>n>>m;
    k = 1;
    jd[k][0] = 1;
    jd[k][1] = 1;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            cin>>a[i][j];
            if(a[i][j]=='*'){
                jd[++k][0] = i;
                jd[k][1] = j;
            }
        }
    memset(g,127,sizeof(g));
    for(int i=1;i<=k;i++)
    {
        int x = jd[i][0];
        int y = jd[i][1];
        for(int j=i;j<=k;j++)
        {
            int ex = jd[j][0],ey = jd[j][1];
            if(j==i)g[i][j] = g[j][i] = 0;
            else {
                int step = bfs(x,y,ex,ey);
                if(step!=-1)g[i][j] = g[j][i] = min(step,g[i][j]);
                else {
                    f = 0; 
                    //printf("%d到%d的距离为%d f为0\n",i,j,g[i][j]);
                }
            }
            //printf("%d到%d的距离为%d\n",i,j,g[i][j]);
        }
    }
    if(f==0){
        cout<<"Impossible";
        return 0;
    }
    book[1] = 1;
    ans = 9999;
    dfs(1,1);
    if(ans!=9999)
    cout<<ans;
    else cout<<"Impossible"<<ans;
    return 0;
}