POJ 3026

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <queue>
#include <cstring>
#include <cstdio>
#include <map>
#include <assert.h>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXSIZE = 110;
char road[MAXSIZE][MAXSIZE];
int dis[MAXSIZE];
int flag[MAXSIZE];
struct Node {
    int x, y, t;

    Node(int x, int y) : x(x), y(y), t(INF) {}
    Node(){}

    bool operator<(Node const &node) const {
        if (x == node.x)
            return y < node.y;
        return x < node.x;
    }
};

int visit[MAXSIZE][MAXSIZE];
int grap[MAXSIZE][MAXSIZE];
int dir[4][2] = {{0,  1},
                 {0,  -1},
                 {1,  0},
                 {-1, 0}};
map<Node, int> M;
int cnt = 0;

void bfs(Node node) {
    memset(visit, 0, sizeof(visit));
    queue<Node> Q;
    node.t = 0;
    Q.push(node);
    visit[node.x][node.y] = 1;
    int ix = M[node];
    while (!Q.empty()) {
        Node temp = Q.front();
        Q.pop();
        for (int i = 0; i < 4; ++i) {
            int xx = temp.x + dir[i][0];
            int yy = temp.y + dir[i][1];
            int t = temp.t + 1;
            if (!visit[xx][yy] && road[xx][yy] != '#') {
                visit[xx][yy] = 1;
                Node node1(xx, yy);
                node1.t = t;
                Q.push(node1);
                if (M.count(node1)!=0){
                    grap[ix][M[node1]] = node1.t;
                }
            }
        }
    }
}

int prim() {
    int ans = 0;
    memset(dis, INF, sizeof(dis));
    memset(flag, 0, sizeof(flag));
    dis[0] = 0;
    for (int i = 0; i < cnt; ++i) {
        int minv = INF, u = -1;
        for (int j = 0; j < cnt; ++j) {
            if (!flag[j]&&minv>dis[j])
                minv = dis[u=j];
        }
        flag[u] = 1;
        ans += minv;
        for (int k = 0; k < cnt; ++k) {
            if (!flag[k]&&dis[k]>grap[u][k])
                dis[k] = grap[u][k];
        }
    }
    return ans;
}

int m, n;

int main() {
    freopen("../in.txt", "r", stdin);
    int testcase;
    cin >> testcase;
    while (testcase--) {
        M.clear();
        memset(grap, INF, sizeof(grap));
        cin >> n >> m;
        while (getchar() != '\n');
        for (int i = 0; i < m; ++i) {
            gets(road[i]);
        }
        cnt = 0;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (road[i][j] == 'A' || road[i][j] == 'S') {
                    M[Node(i, j)] = cnt++;
                }
            }
        }
        map<Node, int>::iterator it = M.begin();
        it = M.begin();
        for (; it != M.end(); it++){
            bfs(it->first);
        }
        cout << prim() << endl;
    }
}