kruskal好题

题意是给你一个01矩阵，1代表陆地，0代表水域，现在要建立不相交的桥来把这些路径连在一起，填补一个0的格子的花费是1，问最少的花费是多少。

思路：把所有的1的坐标全部加入队列，然后开始bfs,中间标记水距离那个陆地的距离最短，当水遇到陆地的时候，就可以判断这两块陆地是不是可以合并了，中间把贡献加在一起就可以了。

代码：

#include<bits/stdc++.h>
using namespace std;

struct node
{
    int x, y;
    int nu;
};

const int maxn = 1010;
int m, n;
int A[maxn][maxn], B[maxn][maxn], vis[maxn][maxn], f[maxn * maxn], G[maxn][maxn];
std::queue<node>Q;
int ix[5] = { -1,1,0,0 };
int iy[5] = { 0,0,1,-1 };

inline int Find(int v)
{
    return f[v] == v ? v : f[v] = Find(f[v]);
}

inline void Union(int v, int u)
{
    int t1 = Find(v);
    int t2 = Find(u);
    f[t2] = t1;
    return;
}

inline void DFS(int x, int y, int num)
{
    B[x][y] = num;
    for (int i = 0; i < 4; i++)
    {
        if (x + ix[i] >= 0 && y + iy[i] >= 0 && x + ix[i] < n && y + iy[i] < m && A[x + ix[i]][y + iy[i]]&&(!B[x + ix[i]][y + iy[i]]) )
            DFS(x + ix[i], y + iy[i], num);
    }
    return;
}

inline int OK(int x, int y)
{
    return  Find(x) == Find(y);
}

inline int  bfs()
{
    while (!Q.empty())
        Q.pop();

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            char C;
            cin >> C;
            A[i][j] = C - '0';

            if (A[i][j] == 1)
                Q.push(node{ i,j,0 });
        }
        getchar();
    }
    memset(vis, 0, sizeof(vis));
    memset(B, 0, sizeof(B));
    memset(f, 0, sizeof(f));
    memset(G, 0, sizeof(G));
    int num = 1;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
        {
            if (A[i][j] && (!B[i][j]))
            {
                f[num] = num;
                DFS(i, j, num);
                num++;
            }
        }
    int sum = 0;
    while (!Q.empty())
    {
        node L = Q.front();
        Q.pop();
        for (int i = 0; i < 4; i++)
        {
            node LL{ L.x + ix[i],L.y + iy[i],L.nu + 1 };
            if (LL.x < 0 || LL.x >= n || LL.y < 0 || LL.y >= m || (A[L.x][L.y] && A[LL.x][LL.y]))
                continue;
            if (vis[LL.x][LL.y])
            {
                if (!OK(B[L.x][L.y], B[LL.x][LL.y]))
                {
                    Union(B[L.x][L.y], B[LL.x][LL.y]);
                    sum += G[L.x][L.y] + G[LL.x][LL.y];
                }
                continue;
            }

            if (A[L.x][L.y] == 0 && A[LL.x][LL.y] == 1 && (B[L.x][L.y] != B[LL.x][LL.y]) && (!OK(B[L.x][L.y], B[LL.x][LL.y])))
            {
                sum += L.nu;
                Union(B[L.x][L.y], B[LL.x][LL.y]);
            }
            else
            {
                G[LL.x][LL.y] = LL.nu;
                B[LL.x][LL.y] = B[L.x][L.y];
                vis[LL.x][LL.y] = 1;
                Q.push(LL);
            }
        }
    }
    return sum;
}

int main()
{
    cin >> m >> n;
    getchar();
    cout << bfs() << endl;
    return 0;
}
/*
6 3
100101
001100
000001
*/