luogu1525 关押罪犯

题目描述

S 城现有两座监狱，一共关押着N 名罪犯，编号分别为1~N。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为c 的冲突事件。

每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到S 城Z 市长那里。公务繁忙的Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。

在详细考察了N 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。

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

输入输出格式

输入格式：
输入文件的每行中两个数之间用一个空格隔开。第一行为两个正整数N 和M，分别表示罪犯的数目以及存在仇恨的罪犯对数。接下来的M 行每行为三个正整数aj，bj，cj，表示aj 号和bj 号罪犯之间存在仇恨，其怨气值为cj。数据保证1 < aj= < =bj < =N ，0 < cj≤ 1,000,000,000，且每对罪犯组合只出现一次。

输出格式：
共1 行，为Z 市长看到的那个冲突事件的影响力。如果本年内监狱中未发生任何冲突事件，请输出0。

输入输出样例

输入样例#1：
4 6
1 4 2534
2 3 3512
1 2 28351
1 3 6618
2 4 1805
3 4 12884

输出样例#1：
3512

分析：
解法一：
二分题——好想不好写
（这就给我们一个启示，一旦遇到使最小值最大或最大值最小，就考虑二分）
我们二分一下编号（哪条边会作为最大边）
那么困难就在于如何判定，
若mid合法，则同一个监狱里的所有冲突值都要小于等于mid
这就等价于：所有冲突值大于k的两个犯人必须被关押在不同的监狱
我们把冲突值从大到下排序并进行添加，
若当前冲突值 >v[mid]，那么这两个犯人一定会分到不同监狱，
如果不可避免会发生冲突，则该方案不合法，将范围扩大，
判定的时候dfs即可

一直RE，注意数组大小

这里写代码片
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N=20010;
int n,m;
struct node{
    int x,y,v,nxt;
};
node way[200010];  //双向加边，注意数组大小 
int st[N],tot=0;
int p[N],flag,a[100010];   //a的范围和m一样 

void add(int u,int w,int z)
{
    tot++;
    way[tot].x=u;way[tot].y=w;way[tot].v=z;way[tot].nxt=st[u];st[u]=tot;
    tot++;
    way[tot].x=w;way[tot].y=u;way[tot].v=z;way[tot].nxt=st[w];st[w]=tot;
}

void dfs(int now,int jh,int mid)  //now,集合 
{
    if (flag==0) return;
    p[now]=jh;  //属于哪个集合  贪心分配 
    for (int i=st[now];i;i=way[i].nxt)
    {
        if (way[i].v>mid)
        {
            if (p[way[i].y]==-1) {
                dfs(way[i].y,1-jh,mid);
            }
            else if (p[way[i].y]==p[now]){
                flag=0;  //不可避免的冲突 
                return;
            }
        }
    }
}

int pd(int mid)
{
    memset(p,-1,sizeof(p));
    flag=1;
    for (int i=1;i<=n;i++)
        if (p[i]==-1)
            dfs(i,0,a[mid]);   //a[mid]  这里mid只是一个位置 
    return flag;
}

void doit()
{
    int l=0;
    int r=m;
    while (l<r)   //这里二分的是哪一条边是最大边 
    {
        int mid=(l+r)>>1;
        if (pd(mid))
           r=mid;
        else l=mid+1;
    }
    printf("%d",a[l]);   //a[l]
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        int u,w,z;
        scanf("%d%d%d",&u,&w,&z);
        add(u,w,z);
        a[i]=z;
    }
    sort(a+1,a+1+m);
    doit();
    return 0;
}

解法二：
并查集——不好想好写
把点分成两部：1~n 是友部，n+1~2*n是敌部，
友部和敌部之间互不相容，每个部中是可以相容的（冲突值不大）
把边从大到小排序并添加，
利用并查集判定每条边的两个端点分别在哪个部里，
只要能够分到不同部里，就这样贪心的分下去
注意，如果两个端点确定要分在不同的地方，那在union的时候
该点的祖先就union到对方的敌人那里

for (int i=1;i<=m;i++)
    {
        int u=way[i].x;
        int w=way[i].y;
        int r1=find(u);
        int r2=find(w);
        if (r1==r2)
        {
            printf("%d",way[i].v);  //不可避免的冲突 
            return;   
        }
        f[r1]=find(w+n);  //默认每一个点和ta+n的点为敌人（不能在一个集合中） 
        f[r2]=find(u+n);  //敌人的敌人就是朋友 
        //注意这里修改的是r1，r2，毕竟只有修改并查集的标志节点才能把集合合并 
    }

我这个zz一直wa，后来才发现是并查集中的find写挂了

我这个zz在 return f[a]; 前加了一个else
就这样wa挺了

这里写代码片
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm> 

using namespace std;

const int N=20010;
int n,m;
struct node{
    int x,y,v;
};
node way[100010];
int f[N<<1];

int cmp(const node &a,const node &b)
{
    return a.v>b.v;  //降序排列，让权值大的一对分到不同的集合 
}

int find(int a)
{
    if (f[a]!=a) f[a]=find(f[a]);
    return f[a];
}

void doit()
{
    int ans=0;
    for (int i=1;i<=m;i++)
    {
        int u=way[i].x;
        int w=way[i].y;
        int r1=find(u);
        int r2=find(w);
        if (r1==r2)
        {
            printf("%d",way[i].v);  //不可避免的冲突 
            return;   
        }
        f[r1]=find(w+n);  //默认每一个点和ta+n的点为敌人（不能在一个集合中） 
        f[r2]=find(u+n);  //敌人的敌人就是朋友 
        //注意这里修改的是r1，r2，毕竟只有修改并查集的标志节点才能把集合合并 
    }
    printf("0");
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
        scanf("%d%d%d",&way[i].x,&way[i].y,&way[i].v);
    sort(way+1,way+1+m,cmp);
    for (int i=1;i<=n*2;i++) f[i]=i;  //两个集合
    //友方1~n,敌方n+1~2*n 
    doit();
    return 0;
}