Borg Maze--POJ 3026

1、题目类型：图论、最小生成树、迷宫、Prim算法、BFS。

2、解题思路：（1）将输入转换为map[][]：'S'、'A'、'  '、'#'分别用实际意义的数值表示；并将出现的节点用结构体数组Node[]表示；（2）BFS算法搜索map[][]迷宫，获得每个节点间的距离，用arr[][]数组保存；（3）Prim算法求解最小生成树。

3、注意事项：输入不是规则的X*Y输入，包括输入x、y值时，需用cin.getline()整行整行获取;step需保存在各个queue结构体中循环，以避免step++过多；其中STL的min_element()返回的是最小值的下标地址而非最小值；Prim算法中的dis[]用于保存当前最小距离，注意实时更新。

4、实现方法:

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define Max 100000

struct TNode{
    int x,y,step;
};

TNode Node[110];
int dir[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
int n,x,y,cnt,map[51][51],arr[110][110];
bool vis[110];
//判断是否越界
bool Judge(int a,int b)
{
    if(a<0 || a>x || b<0 || b>y)
        return false;
    return true;
}

void BFS()
{
    int i,j,x,y,num;
    TNode tmp1,tmp2;
    queue<TNode> Q;
    bool flag[51][51];
    for(i=1;i<cnt;i++)
    {
        while(!Q.empty())
            Q.pop();
        memset(flag,0,sizeof(flag));
        num=0;
        tmp1=Node[i];
        tmp1.step=0;
        flag[tmp1.x][tmp1.y]=1;
        Q.push(tmp1);
        while(!Q.empty())
        {            
            tmp1=Q.front();
            Q.pop();
            x=tmp1.x;
            y=tmp1.y;
            //搜索到节点
            if(map[x][y]!=0)
            {
                num++;
                arr[i-1][map[x][y]-1]=arr[map[x][y]-1][i-1]=tmp1.step;
                //搜索到全部节点，跳出循环
                if(num==cnt)
                    break;                
            }
            //进入下一轮四个方向的搜索
            for(j=0;j<4;j++)
            {
                x=tmp1.x+dir[j][0];
                y=tmp1.y+dir[j][1];
                if(Judge(x,y) && !flag[x][y] && map[x][y]!=-1)
                {
                    tmp2.x=x;
                    tmp2.y=y;
                    tmp2.step=tmp1.step+1;
                    Q.push(tmp2);
                    flag[x][y]=true;
                }
            }
        }
    }
}

int Prim()
{
    int i,j,pos,ans=0,dis[110];
    memset(vis,0,sizeof(vis));
    
    for(i=0;i<cnt;i++)
        dis[i]=arr[0][i];
    vis[0]=1;
    
    for(i=0;i<cnt-1;i++)
    {
        //stl函数返回最小值地址下标
        pos=min_element(dis+1,dis+cnt)-dis;
        vis[pos]=1;
        ans+=dis[pos];
        dis[pos]=Max;
        //更新dis[]数组
        for(j=0;j<cnt;j++)
            if(!vis[j] && dis[j]>arr[pos][j])
                dis[j]=arr[pos][j];
    }
    return ans;
}

int main()
{
    int i,j;
    char ch[55],tmp;
    cin>>n;
    while(n--)
    {
        cin>>y>>x;
        cin.getline(ch,sizeof(ch));
        cnt=1;
        for(i=0;i<x;i++)
        {
            cin.getline(ch,sizeof(ch));
            for(j=0;j<strlen(ch);j++)
            {
                tmp=ch[j];
                switch(tmp)
                {
                case '#':
                    {
                        map[i][j]=-1;
                        break;
                    }
                case ' ':
                    {
                        map[i][j]=0;
                        break;                    
                    }
                case 'A':
                    {
                        cnt++;
                        Node[cnt].x=i;
                        Node[cnt].y=j;
                        map[i][j]=cnt;
                        break;
                    }
                case 'S':
                    {
                        map[i][j]=1;
                        Node[1].x=i;
                        Node[1].y=j;
                        break;
                    }
                }
            }
        }
        BFS();    
        cout<<Prim()<<endl;
    }
    return 1;
}