染色+最小生成树

有一矩形区域的城市中建筑了若干建筑物，如果某两个单元格有一个点相联系，则它们属于同一座建筑物。现在想在这些建筑物之间搭建一些桥梁，其中桥梁只能沿着矩形的方格的边沿搭建，如下图城市1有5栋建筑物，可以搭建4座桥将建筑物联系起来。城市2有两座建筑物，但不能搭建桥梁将它们连接。城市3只有一座建筑物，城市4有3座建筑物，可以搭建一座桥梁联系两栋建筑物，但不能与第三座建筑物联系在一起。

分析：染色，暴力连点，最小生成树

四层循环来暴力连点，，，真没想到，数组开小了，RL了一排

#include <iostream>
#include <queue>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
#define INF 1e7
#define maxn 1000005
int n , m ;
char mp[1005][1005];
int hs[1005][1005];
int ID;

int way[8][2] = {1,0,-1,0 ,0,1,0,-1 ,1,1,1,-1 ,-1,1,-1,-1};
struct node
{ int x,y,v; };

node data[maxn];
int k ;

int fa[maxn];

int check(node c)
{
    if( c.x >= 0 && c.y >= 0 && c.x < n && c.y < m &&
       !hs[c.x][c.y] &&  mp[c.x][c.y] == '#' )
        return 1;
    return 0;
}

void bfs(int x,int y)
{
    node s;
    s.x = x;
    s.y = y;
    queue<node>Q;
    Q.push(s);
    while(!Q.empty()){
        node q = Q.front();
        Q.pop();
        hs[q.x][q.y] = ID;
        for(int i = 0 ; i < 8 ; ++i){
            node nx = q;
            nx.x += way[i][0];
            nx.y += way[i][1];
            if( check(nx) )
                Q.push(nx);
        }
    }
}

int cal_len(int i,int j,int a,int b)
{
    if( abs(a-i) < 2 )return abs(b-j)-1;
    if( abs(b-j) < 2 )return abs(a-i)-1;
    return INF;
}


void init()
{
    memset(hs,0,sizeof(hs));
    for(int i = 0 ; i < maxn ; ++i)
        fa[i] = i;
    for(int i = 0 ; i < maxn ; ++i)
        data[i].v = 0;
    ID = 0;
    k = 0;
    cin >> n >> m ;
    for(int i = 0 ; i  < n ; ++i)
        for(int j = 0 ; j  < m ; ++j)
            cin >> mp[i][j];

    for(int i = 0 ;  i < n ; ++i)
        for(int j = 0 ; j < m ; ++j){
            if( mp[i][j] == '#' && ! hs[i][j] ){
                ID++;
                bfs( i,j );
            }
        }

    for(int i = 0; i < n ; ++i)
    {
        for(int j = 0 ; j < m ; ++j)
        {
            for(int a = 0 ; a < n ; ++a)
            {
                for(int b = 0 ; b < m ; ++b)
                {
                    if( hs[i][j] && hs[a][b] && hs[i][j] != hs[a][b]
                        && !(i==a&&j==b))
                    {
                        data[k].x = hs[i][j];
                        data[k].y = hs[a][b];
                        data[k++].v = cal_len(i,j,a,b);
                    }
                }
            }
        }
    }
}

int find(int x)
{
    if(fa[x] == x )return x;
    return fa[x] = find(fa[x]);
}

int cmp(node a,node b)
{
    return a.v < b.v;
}

void kruskal()
{
    int ans = 0;
    int cnt = 0;
    sort( data,data+k,cmp );
    for(int i = 0 ; i < k ; ++i)
    {
        if( data[i].v == INF )break;
        node e = data[i];
        int x = find(e.x);
        int y = find(e.y);
        if( x != y )
        {
            cnt++;
            fa[x] = y;
            ans += data[i].v;
        }
    }
    cout << ID << endl;
    cout << cnt  <<  " " << ans << endl;
}

int main()
{
    init();
    kruskal();
}