棋盘上的守卫

在一个n*m的棋盘上要放置若干个守卫。对于n行来说，每行必须恰好放置一个横向守卫；同理对于m列来说，每列

必须恰好放置一个纵向守卫。每个位置放置守卫的代价是不一样的，且每个位置最多只能放置一个守卫，一个守卫

不能同时兼顾行列的防御。请计算控制整个棋盘的最小代价。

Input

第一行包含两个正整数n,m(2<=n,m<=100000,n*m<=100000)，分别表示棋盘的行数与列数。

接下来n行，每行m个正整数

其中第i行第j列的数w[i][j](1<=w[i][j]<=10^9)表示在第i行第j列放置守卫的代价。

Output

输出一行一个整数，即占领棋盘的最小代价。

Sample Input

3 4
1 3 10 8
2 1 9 2
6 7 4 6

Sample Output

19

HINT
在(1,1),(2,2),(3,1)放置横向守卫，在(2,1),(1,2),(3,3),(2,4)放置纵向守卫。

思路：

          主要就是标记你选择一个数字的行和列，

代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>


using namespace std;

typedef long long ll;
int n,m,x;
ll ans;
int cnt;
int f[200010],vis[200010];

struct E
{
    int u,v,k;
    E(){};
    E(int u,int v,int k):u(u),v(v),k(k){};
}e[200010];

bool cmp(E n, E m)
{
    return n.k<m.k;
}

int find(int x)
{
   return f[x]==x?x:f[x]=find(f[x]);
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=1;i<=n*m;i++)
        {
            f[i] = i;
            vis[i] =0;
        }
        cnt = ans = 0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                scanf("%d",&x);
                e[++cnt] = E(i,j+n,x);
            }
        }
        sort(e+1,e+1+cnt,cmp);
        for(int i=1;i<=n*m;i++)
        {
            int fx = find(f[e[i].u]);
            int fy = find(f[e[i].v]);
            if(vis[fx] && vis[fy])
            {
                continue;
            }
            if(fy!=fx)
            {
                vis[fx]|=vis[fy];
                f[fy] = fx;
            }
            else
              vis[fx] = 1;
            ans+=e[i].k;
        }
        printf("%lld\n",ans);
    }
    return 0;
}

转载于:https://www.cnblogs.com/new-zjw/p/8540955.html