NOIP 关押罪犯

(prison.pas/c/cpp)
【问题描述】
　　S 城现有两座监狱，一共关押着 N 名罪犯，编号分别为 1~N。他们之间的关系自然也极
不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨
气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之
间的积怨越多。如果两名怨气值为 c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并
造成影响力为 c 的冲突事件。
每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，
然后上报到 S 城 Z 市长那里。公务繁忙的 Z 市长只会去看列表中的第一个事件的影响力，
如果影响很坏，他就会考虑撤换警察局长。
在详细考察了 N 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在
两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只
要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。那
么，应如何分配罪犯，才能使 Z 市长看到的那个冲突事件的影响力最小？这个最小值是多
少？
【输入】
输入文件名为 prison.in。输入文件的每行中两个数之间用一个空格隔开。
第一行为两个正整数 N 和 M，分别表示罪犯的数目以及存在仇恨的罪犯对数。
接下来的 M 行每行为三个正整数 aj， bj， cj，表示 aj 号和 bj 号罪犯之间存在仇恨，其怨
气值为 cj。数据保证1 ≤ a j < b j ≤ N ， 0 < c j ≤ 1,000,000,000 ，且每对罪犯组合只出现一
次。
【输出】
输出文件 prison.out 共 1 行，为 Z 市长看到的那个冲突事件的影响力。如果本年内监狱
中未发生任何冲突事件，请输出 0。
【输入输出样例】
prison.in prison.out
4 6
1 4 2534
2 3 3512
1 2 28351
1 3 6618
2 4 1805
3 4 12884
3512

【数据范围】
对于 30%的数据有 N ≤ 15。
对于 70%的数据有 N ≤ 2000， M ≤ 50000。
对于 100%的数据有 N ≤ 20000， M ≤ 100000。

分析：

　　明显的二分答案，但是写判断函数时一定要用二分图染色，我一开始想的是用vis[]数组表示，vis[i]==0时说明i犯人待分配，vis[i]==1说明i犯人分配到集合1，vis[i]==2说明i犯人分配到集合2，然后搞好几个判断，但是这样错误很明显，假设 ①与②分别分到监狱一和二，④和③分别分到监狱一和二，这时如果②和③不能分到一起，判断就会return false，但是其实可以①③一起，②④一起。。。

　　下面这个是错的：

 //错的错的错的  才20分
 1 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 typedef long long LL;
 LL N,M;
 struct node{
     LL a,b,c;
 };
 node pris[];
 LL cmp(const node &q,const node &w){
     if(q.c<w.c) return ;
     return ;
 }
 LL find(LL,LL);
 bool jud(LL);
 int main(){
     freopen("prison.in","r",stdin);
     freopen("prison.out","w",stdout);
     scanf("%lld%lld",&N,&M);
     for(LL i=;i<=M;i++)
         scanf("%lld%lld%lld",&pris[i].a,&pris[i].b,&pris[i].c);
     sort(pris+,pris+M+,cmp);
     if(jud()==true){
         cout<<;
         return ;
     }
     cout<<find(pris[].c,pris[M].c);
     return ;
 }
 LL find(LL l,LL r){
     if(r-l<=){
         if(jud(l)==true) return l;
         else return r;
     }
     LL mid=(l+r)>>;
     if(jud(mid)==true){
         find(l,mid);
     }
     else{
         find(mid+,r);
     }
 }
 bool jud(LL x){
     LL vis[];
     memset(vis,,sizeof(vis));
     for(LL i=;i<=M;i++){
         LL u=pris[i].a;
         LL v=pris[i].b;
         if(pris[i].c>x){//可能会有冲突
             if(vis[u]==&&vis[v]==){//没有确定集合
                 vis[u]=;
                 vis[v]=;
             }
             else{
                 if(vis[u]!=&&vis[v]!=&&vis[u]==vis[v]) return false;//必然爆发冲突
                 else{
                     if(vis[u]!=&&vis[v]==){
                         if(vis[u]==) vis[v]=;
                         else if(vis[u]==) vis[v]=;
                     }
                     else if(vis[u]==&&vis[v]!=){
                         if(vis[v]==) vis[u]=;
                         else if(vis[v]==) vis[u]=;
                     }
                 }
             }
         }
     }

     return true;
 }

　　正解是二分图染色，由于有20000个点，所以应该用vector，不过因为图不是太稠密，所以开to[20001][500]也能过。

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<vector>
 #include<queue>
 using namespace std;
 typedef long long LL;
 LL N,M;
 struct node{
     LL a,b,c;
 };
 node pris[];
 LL cmp(const node &q,const node &w){
     if(q.c<w.c) return ;
     return ;
 }
 LL to[][];
 LL vis[];
 LL find(LL,LL);
 bool jud(LL);
 bool color(LL);
 int main(){
     freopen("prison.in","r",stdin);
     freopen("prison.out","w",stdout);
     scanf("%lld%lld",&N,&M);
     for(LL i=;i<=M;i++)
         scanf("%lld%lld%lld",&pris[i].a,&pris[i].b,&pris[i].c);
     sort(pris+,pris+M+,cmp);
     if(jud()==true){
         cout<<;
         return ;
     }
     cout<<find(pris[].c,pris[M].c);
     return ;
 }
 LL find(LL l,LL r){
     if(r-l<=){
         if(jud(l)==true) return l;
         else return r;
     }
     LL mid=(l+r)>>;
     if(jud(mid)==true){
         find(l,mid);
     }
     else{
         find(mid+,r);
     }
 }
 bool jud(LL x){
     memset(vis,,sizeof(vis));
     memset(to,,sizeof(to));
     for(LL i=;i<=M;i++){
         LL u=pris[i].a;
         LL v=pris[i].b;
         if(pris[i].c>x){
             to[u][]++;
             to[v][]++;
             to[u][to[u][]]=v;
             to[v][to[v][]]=u;
         }
     }
     for(LL i=;i<=N;i++){
         if(vis[i]==&&to[i][]>){
             if(color(i)==false) return false;
         }
     }
     return true;
 }
 bool color(LL root){
     vis[root]=;
     static queue<LL> Q;
     while(Q.size()>) Q.pop();
     Q.push(root);
     while(Q.size()>){
         int x=Q.front();
         Q.pop();
         for(int i=;i<=to[x][];i++){
             int y=to[x][i];
             if(vis[y]==){
                 if(vis[x]==) vis[y]=;
                 else vis[y]=;
                 Q.push(y);
             }
             else if(vis[y]==vis[x]) return false;
         }
     }
     return true;
 }