关押罪犯 codevs 1069（整理：加权并查集？+虚点并查集+二分图染色）

go to the problem

题目描述 Description

S 城现有两座监狱，一共关押着N 名罪犯，编号分别为1~N。他们之间的关系自然也极

不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨

气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之

间的积怨越多。如果两名怨气值为c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并

造成影响力为c 的冲突事件。

每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，

然后上报到S 城Z 市长那里。公务繁忙的Z 市长只会去看列表中的第一个事件的影响力，

如果影响很坏，他就会考虑撤换警察局长。

在详细考察了N 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在

两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只

要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。那

么，应如何分配罪犯，才能使Z 市长看到的那个冲突事件的影响力最小？这个最小值是少？

输入描述 Input Description

第一行为两个正整数N 和M，分别表示罪犯的数目以及存在仇恨的罪犯对数。

接下来的M 行每行为三个正整数aj，bj，cj，表示aj 号和bj 号罪犯之间存在仇恨，其怨气值为cj。数据保证，且每对罪犯组合只出现一次。

输出描述 Output Description

共1 行，为Z 市长看到的那个冲突事件的影响力。如果本年内监狱

中未发生任何冲突事件，请输出0。

样例输入 Sample Input

4 6

1 4 2534

2 3 3512

1 2 28351

1 3 6618

2 4 1805

3 4 12884

样例输出 Sample Output

3512

数据范围及提示 Data Size & Hint

罪犯之间的怨气值如下面左图所示，右图所示为罪犯的分配方法，市长看到的冲突事件

影响力是3512（由2 号和3 号罪犯引发）。其他任何分法都不会比这个分法更优。

【数据范围】

对于30%的数据有N≤ 15。

对于70%的数据有N≤ 2000，M≤ 50000。

对于100%的数据有N≤ 20000，M≤ 100000。

1.普通并查集（设虚点）

根据题目描述，我们的第一个反应一般都是用并查集把罪犯分到两个监狱。
但是问题是并查集只能维护并判断元素是否属于一个集合，并不能直接划分出两个集合。所以我们采用设虚点的方法，虚拟出两个监狱来。
对于罪犯i，设i+n为他的虚点（双胞胎 ？？？平行时空？？？）。
先把输入的罪犯组合按照他们的仇恨值从大到小排序，每次把两个罪犯分到两个监狱，直到不能再分了为止，此时的仇恨值便是最终的答案。
由于我们并不知道这个罪犯具体被分到那个监狱，所以每次分时就把x与y+n分到一个监狱，x+n与y分到一个监狱就行了。判断时判断x与y,x+n与y+n.

代码

#include<iostream>
#include<cstdio>
#include<cstring> 
#include<algorithm>
#include<cmath>
using namespace std;

int N,M;
int fa[20050<<1];

struct maple{
    int a,b,c;
    bool operator <(const maple &a)const{
       return a.c<c;
    }
}a[100010];
int find(int x)
{
    return fa[x]==x?x:fa[x]=find(fa[x]);
}
int main()
{
    scanf("%d%d",&N,&M);
    for(int i=1;i<=2*N;++i) fa[i]=i;
    for(int i=1;i<=M;++i)
       scanf("%d%d%d",&a[i].a,&a[i].b,&a[i].c);
    sort(a+1,a+M+1);
    for(int i=1;i<=M;++i)
    {
        int x=find(a[i].a),y=find(a[i].b),X=find(a[i].a+N),Y=find(a[i].b+N);
        if(x!=y&&X!=Y)
        {
            fa[x]=Y;
            fa[y]=X;
        }   
        else 
        {
            cout<<a[i].c;
            break;
        }
    }
    if(M==1) cout<<0;
    return 0;
}

2.加权并查集 ？？？

之所以带问号是因为我也不能确定这到底是不是加权并查集，网上的代码也很少(*/ω＼*)。。。并不打算粘代码。。。

对于这个题，有些人采用了和食物链0,1,2一样的神奇做法。

设一个数组num，规定num[i]=0表示i和fa[i]在同一个监狱，1表示i和fa[i]不在同一个监狱。
每次找父亲时同时计算num[i]的值，一样的，最后num[i]为i与根节点的关系。

计算公式为 num[i]=(num[i]+num[fa[i]]+num[fa[fa[i]]]+…+num[root])%2;

int find(int x)
{
     if(fa[x]==x) return x;
     int Fa=find(fa[x]);
     num[x]=(num[x]+num[fa[x]])%2;
     return fa[x]=Fa;
}

别的思想与1一样，但是判断时要同时判断两个罪犯的根节点和他们与根节点的关系，合并时也要注意更改根节点的num值。

if(x==y&&num[a[i].a]==num[a[i].b])
{
    cout<<a[i].c;
    break;
}
else
{
    fa[x]=y;
    num[x]=(num[a[i].a]+num[a[i].b]+1)%2;
}

3.二分答案+二分图染色

对每组罪犯组合建边。
把仇恨值排序后二分答案。
只保留仇恨值大于答案的边进行二分图染色Bfs，一个点染成黑色，另一个点染成白色，如果可以完成染色，则调整右边界，如果不行，则调整左边界。

代码

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;

int N,M,a,b,c,cnt,mid;
int First[20050],Next[200010],color[200010],q[200010];
int used[20050];
struct maple{
    int f,t,d;
    bool operator <(const maple &a)const{
       return d<a.d;
    }
}Per[200010]; 

void Build(int f,int t,int d)
{
    Per[++cnt]=(maple){f,t,d};
}
bool check(int t)
{
    int head=0,tail=1;
    color[t]=1;
    q[tail]=t;
    used[t]=1;
    while(head<tail)
    {
        ++head;
        for(int i=First[q[head]];i;i=Next[i])
            if(Per[i].d>Per[mid].d)  // 大于这个仇恨值的都被分到两个监狱 
               if(!used[Per[i].t])
               {
                  q[++tail]=Per[i].t;
                  color[Per[i].t]=color[q[head]]^1; // 染成不同颜色 
                  used[Per[i].t]=1;
               }
               else if(color[Per[i].t]==color[q[head]]) return false;
    }
    return true;
}
bool ok()
{
    memset(used,0,sizeof(used));
    memset(color,0,sizeof(color));
    for(int i=1;i<=N;++i)
      if(!used[i])
          if(!check(i)) return false;
    return true;  
}
int main()
{
    scanf("%d%d",&N,&M);
    for(int i=1;i<=M;++i)
    {
        scanf("%d%d%d",&a,&b,&c);
        Build(a,b,c);
        Build(b,a,c);
    }
    sort(Per+1,Per+cnt+1);
    for(int i=1;i<=cnt;++i)
    {
        Next[i]=First[Per[i].f];
        First[Per[i].f]=i;  
    }
    int l=0,r=2*M;
    while(l+1<r)    
    {
        mid=(l+r)>>1;
        if(ok()) r=mid;
        else l=mid;
    }
    if(r!=1)cout<<Per[r].d;
    else cout<<0;
    return 0;
}

Ps：以后要不要考虑写点别的博客2333_(:з」∠)_