洛谷P1525关押罪犯
题目描述
\(S\) 城现有两座监狱，一共关押着 \(N\) 名罪犯，编号分别为 \(1-N\)。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为 \(c\) 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为 \(c\) 的冲突事件。
每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到 \(S\) 城 \(Z\) 市长那里。公务繁忙的 \(Z\) 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。
在详细考察了 \(N\) 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。
那么，应如何分配罪犯，才能使 \(Z\) 市长看到的那个冲突事件的影响力最小？这个最小值是多少？
输入格式
每行中两个数之间用一个空格隔开。第一行为两个正整数 \(N,M\)，分别表示罪犯的数目以及存在仇恨的罪犯对数。接下来的 \(M\) 行每行为三个正整数 \(a_j,b_j,c_j\)，表示 \(a_j\) 号和 \(b_j\) 号罪犯之间存在仇恨，其怨气值为 \(c_j\) 。数据保证 \(1<a_j\leq b_j\leq N\), \(0 < c_j\leq 10^9\)，且每对罪犯组合只出现一次。
输出格式
共 \(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
说明/提示
【输入输出样例说明】罪犯之间的怨气值如下面左图所示，右图所示为罪犯的分配方法，市长看到的冲突事件影响力是 \(3512\)（由 \(2\) 号和 \(3\) 号罪犯引发）。其他任何分法都不会比这个分法更优。
【数据范围】
对于 \(30%\)的数据有 \(N\leq 15\)。
对于 \(70%\) 的数据有 \(N\leq 2000,M\leq 50000\)。
对于 \(100%\) 的数据有 \(N\leq 20000,M\leq 100000\)。
思路
一开始我的思路很明确，就是二分图，因为有两个监狱，很容易想到这个方法。首先按照贪心思想排序边权，然后因为要使最大值最小，所以二分答案。如果用大于\(mid\)的边能够形成一张二分图，也就是大于\(mid\)的矛盾值都不会出现，答案也就是\(mid\)。每次存边只存大于\(mid\)的边，然后用\(bfs\)染色判断是否为二分图即可。但是我这个蒟蒻写完之后调不出来了，而且我感觉时间复杂度好像有点悬（可能是我写错了，有大佬正确的思路也是这样，但是跑得很快而且\(AC\)了）。所以我就开始想别的方法。但是想了一个多小时也没想出来，并且一点思路也没有。最后还是不甘心地点开了题解。早知道还不如调二分图。
题解大致有两种思路：1.二分+二分图，就跟我一开始的思路一样。2.并查集。我感觉这是个非常巧妙的思路。首先将边权从大到小排序。没错，是从大到小排序。这个思路是怎么样的呢，排序后按并查集合并，由于要使最大值最小，所以一旦出现一个边，连上它之后出现了环，那也就是说，你必须在这条环内选一条边作为最后答案。由于我们从大到小排序，所以刚加入的边一定是最小的，直接输出即可。而剩下的边一定都小于这条边，这条边已经比剩下的都大了，所以后面的不管怎么连都不可能再更新答案，也就证明了正确性。
代码（放弃调试二分图QWQ）
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<cstdlib>
#include<ctime>
using namespace std;
const int M=10000005;
int n,m,ans,fa[M],tot;
bool b[M];
struct ren{
int u,v,sum;
}fan[M];
int cmp(ren x,ren y){
return x.sum>y.sum;
}
int get(int x){
if(fa[x]!=x) fa[x]=get(fa[x]);
return fa[x];
}
void merge(int x,int y){
fa[get(x)]=get(y);
}
int ver[M],Next[M],head[M],h[M],hb[M],f[M];
void add(int x,int y){
ver[++tot]=y;
Next[tot]=head[x];
head[x]=tot;
}
bool flag(){
for(int j=1;j<=n;j++){
if(b[j]||head[j]==0) continue;
memset(h,0,sizeof(h));
h[1]=j;
b[j]=1;
hb[j]=1;
int head1=0,tail=1;
while(head1<tail){
head1++;
int x=h[head1];
for(int i=head[x];i;i=Next[i]){
int y=ver[i];
if(hb[y]==hb[x]){
return false;
}
else{
if(hb[x]==0){
hb[y]=1;
}
if(hb[x]==1){
hb[y]=0;
}
if(!b[y]){
b[y]=1;
h[++tail]=y;
}
}
}
}
}
return true;
}//以上是bfs染色判断二分图（其实不用，第二份代码可以巧妙优化）
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
scanf("%d%d%d",&fan[i].u,&fan[i].v,&fan[i].sum);
}
for(int i=1;i<=m;i++){
add(fan[i].u,fan[i].v);
add(fan[i].v,fan[i].u);//为判断二分图存边
}
if(flag()){
printf("0\n");
return 0;
}
for(int i=1;i<=n;i++){
fa[i]=i;
}
sort(fan+1,fan+1+m,cmp);
for(int i=1;i<=m;i++){
int x=get(fan[i].u);
int y=get(fan[i].v);
if(x==y){
printf("%d\n",fan[i].sum);
return 0;
}//若有环出现，直接输出，一定是最优的满足条件的答案
if(!f[x]) f[x]=y;
else merge(f[x],y);
if(!f[y]) f[y]=x;
else merge(f[y],x);//并查集，合并敌人
}
return 0;
}
发现还是打了好长的一个二分图代码，但是其实根本不用。因为我们是从大到小排序的，而数组默认为\(0\)，所以我们可以在循环的时候不循环到\(m\)，而是到\(m+1\)，这样如果前面的罪犯没有任何冲突，\(0\)和\(0\)肯定在一个集合里而且会形成一个环，所以会输出\(0\)，这样就不用再\(bfs\)染色特判一开始的情况了，可以大大减少代码量。
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<cstdlib>
#include<ctime>
using namespace std;
const int M=10000005;
int n,m,ans,fa[M],tot,f[M];
bool b[M];
struct ren{
int u,v,sum;
}fan[M];
int cmp(ren x,ren y){
return x.sum>y.sum;
}
int get(int x){
if(fa[x]!=x) fa[x]=get(fa[x]);
return fa[x];
}
void merge(int x,int y){
fa[get(x)]=get(y);
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
scanf("%d%d%d",&fan[i].u,&fan[i].v,&fan[i].sum);
}
for(int i=1;i<=n;i++){
fa[i]=i;
}
sort(fan+1,fan+1+m,cmp);
for(int i=1;i<=m+1;i++){//循环到m+1
int x=get(fan[i].u);
int y=get(fan[i].v);
if(x==y){
printf("%d\n",fan[i].sum);
return 0;
}
if(!f[x]) f[x]=y;
else merge(f[x],y);
if(!f[y]) f[y]=x;
else merge(f[y],x);
}
return 0;
}
