poj 3026 Borg Maze(java bfs + prim)

package prim;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

/**问题请参考http://poj.org/problem?id=3026
 * @author rayli

 * @date:2014-7-28 下午4:07:33
 * 题意 :给定一个迷宫，在一个迷宫内，建立一颗最小生成树连接所有点
 *通过BFS找到'S'与每个’A'之间的最短路径。然后prim 建立最小生成树。
 *
 *求 任意两字母间的最短距离 时不能直接用BFS求，

1、必须先把矩阵中每一个允许通行的格看做一个结点（就是在矩阵内所有非#的格都作为图M的一个顶点），
对每一个结点i，分别用BFS求出它到其他所有结点的权值（包括其本身，为0），构造结点图M；

2、然后再加一个判断条件，从图M中抽取以字母为顶点的图，进而构造字母图N

这个判定条件就是当结点图M中的某点j为字母时，把i到j的权值再复制（不是抽离）出来，记录到字母图N的邻接矩阵中

3、剩下的就是对字母图N求最小生成树了
 */

class Node
{//结点
   public int x;//x坐标
   public int y;//y坐标
//   public int w;
}

public class BorgMaze
{
    static char map[][];
    static Node node[];
    static int r;
    static int c;
    static int num;
    int ans;
    static int cost[][];
    
    void bfs(Node n)
    {
        int dir[][] = {{0,1}, {0,-1}, {1,0}, {-1, 0}};//方向
        int t[][] = new int[r][c];
        
        //对t进行初始化为-1
        for(int i=0; i<r; i++)
            for(int j=0; j<c; j++)
                t[i][j] = -1;
        
        Queue<Node> q = new LinkedList<Node>();
        t[n.x][n.y] = 0;//对开始点进行标记
        q.add(n);//加入队列
        
        while(!q.isEmpty())
        {
            Node cur = q.remove();
            int x =0;
            int y;
            
            for(int i=0; i<num; i++)//查找始结点在数组中的位置
            {
                if(n == node[i])
                {
                    x = i;
                    break;
                }    
            }
            
            for(int j=0; j<num; j++)
            {

                if((cur.x == node[j].x) && (cur.y == node[j].y))//目前结点在数组中的位置
                {
                    y = j;
                    cost[x][y] = t[cur.x][cur.y];
                    break;
                }
            }
            
            for(int i=0; i<4; i++)//下，上，右，左
            {
                int tx = cur.x + dir[i][0];
                int ty = cur.y + dir[i][1];
                
                Node next = new Node();
                
                if(tx >= 0 && tx < r && ty >=0 && ty < c)
                    if(map[tx][ty] != '#' && t[tx][ty] < 0)
                        {
                            next.x = tx;
                            next.y = ty;
                            t[tx][ty] = t[cur.x][cur.y] + 1;
                            q.add(next);
                        }
            }
        }
    }
    
    
    void prim()
    {
//        boolean vist[][] = new boolean[r][c];
        int lowcost[] = new int[num];
        ans = 0;
        
        for(int i=1; i<num; i++)
        {
            lowcost[i] = cost[0][i];
        }
        
        for(int i=1; i<num; i++)
        {
            int minum = Integer.MAX_VALUE;
            int tmp = 0;
            
            for(int j=0; j<num; j++)
            {
                if(lowcost[j] > 0 && minum > lowcost[j])
                {
                    minum = lowcost[j];
                    tmp = j;
                }
            }
            
            if(minum != Integer.MAX_VALUE)
                ans += minum;
            
            lowcost[tmp] = 0;
            
            for(int j=0; j<num; j++)
            {
                if(cost[tmp][j] < lowcost[j])
                {
                    lowcost[j] = cost[tmp][j];
                }
            }
            
        }
    }
    
    void output()
    {
        System.out.println(ans);
    }
    
    public static void main(String args[])
    {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();//迷宫数
        
        while(n-->0)
        {
             c = cin.nextInt();//迷宫列数
             r = cin.nextInt();//行数
            
            map = new char[r][c];
            node = new Node[102];//用于存储结点A，S
            
            cin.nextLine();
            for(int i=0; i<r; i++)
                map[i] = cin.nextLine().toCharArray();
            
             BorgMaze bm = new  BorgMaze();
             num = 0;
            
             for(int i=0; i<r; i++)
                 for(int j=0; j<c; j++)
                 {
                     if(map[i][j] == 'A' || map[i][j] == 'S')
                     {
                         Node now = new Node();
                         now.x = i;
                         now.y = j;
                        
                         node[num] = now;
                         num++;
                        
                     }
                 }
            
             cost = new int[num][num];
             //对每个结点分别求出它到其他结点的距离
             for(int i=0; i<num; i++)
             {
                 bm.bfs(node[i]);
             }
            
             //求最小生成树
             bm.prim();
             bm.output();
        }
        
        cin.close();
    }
}