描述

給定一個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;
}