[NOIp2010] 关押罪犯

Description

S 城现有两座监狱，一共关押着 N 名罪犯，编号分别为1~N。

他们之间的关系自然也极不和谐。

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

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

如果两名怨气值为 c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为 c 的冲突事件。

每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到 S 城 Z 市长那里。

公务繁忙的 Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。

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

他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。

假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。那么，应如何分配罪犯，才能使 Z 市长看到的那个冲突事件的影响力最小？这个最小值是多少？

Input

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

接下来的 M 行每行为三个正整数\(a_j，b_j，c_j\)，表示\(a_j\)号和\(b_j\)号罪犯之间存在仇恨，其怨气值为\(c_j\)。

数据保证\(1 \le a_j < b_j < N,0 < c_j \le 1000000000\) 且每对罪犯组合只出现一次。

Output

输出共1行，为 Z 市长看到的那个冲突事件的影响力。

如果本年内监狱中未发生任何冲突事件，请输出0。

Sample Input

Sample Output

Hint

\(N \le 20000, M \le 100000\)

题解

这是一道最值问题，我们考虑用二分答案法来求解，由于问题的解满足单调性，所以我们最终的方案为染色算法\(+\)二分答案法

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

const int N=100000,M=500000;
int n,m,maxc,Ans;
struct node{int a,b,c;} f[M];
struct edge{int to,nx;} e[M];
int ne,hd[N],col[N];
bool flag;

void Read()
{
    int i;
    scanf("%d%d",&n,&m);
    for(i=1;i<=m;++i)
    {
        scanf("%d%d%d",&f[i].a,&f[i].b,&f[i].c);
        maxc=max(maxc,f[i].c);
    }
}

void Build(int a,int b)
{
    ++ne, e[ne]=(edge){b,hd[a]}, hd[a]=ne;
}

void Dfs(int t,int ft,int color)
{
    if(col[t])
    {
        if(col[t]!=color)flag=1;
        return;
    }
    int nt;
    col[t]=color;
    for(int i=hd[t];i!=-1;i=e[i].nx)
    {
        nt=e[i].to;
        if(nt==ft)continue;
        Dfs(e[i].to,t,3-color);
    }
}

bool ok(int mid)
{
    int i;
    for(i=1;i<=n;++i) hd[i]=-1,col[i]=0;
    for(i=1;i<=m;++i)
    {
        if(f[i].c<=mid)continue;
        Build( f[i].a , f[i].b ),Build( f[i].b , f[i].a );
    }
    flag=0;
    for(i=1;i<=n;++i)
        if(!col[i])
        {
            Dfs(i,0,1);
            if(flag) return 0;
        }
    Ans=mid; return 1;
}

void Solve()
{
    int l=0,r=maxc,mid;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(ok(mid))r=mid-1;
        else l=mid+1;
    }
    printf("%d\n",Ans);
}

int main()
{
    Read() , Solve();
    return 0;
}

其实也不比用二分答案法

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int N=100000,M=500000;
struct node{
    int a,b,c;
}f[M];
int n,m;

bool Cmp(const node &x,const node &y){return x.c>y.c;}
inline void Read(){
    register int i;
    scanf("%d%d",&n,&m);
    for(i=1;i<=m;++i)scanf("%d%d%d",&f[i].a,&f[i].b,&f[i].c);
    sort(f+1,f+m+1,Cmp);
}

struct edge{
    int to,nx;
}e[M];int ne,hd[N];
inline void Build(int x,int y){
    ++ne, e[ne]=(edge){y,hd[x]}, hd[x]=ne;
}

int col[N];
queue<int>Q;
inline int Bfs(int x,int y){
    int nw,nt,i;
    for(i=1;i<=n;++i)col[i]=0;
    col[x]=1; Q.push(x);
    while(!Q.empty()){
        nw=Q.front();
        Q.pop();
        for(i=hd[nw];i;i=e[i].nx){
            nt=e[i].to;
            if(!col[nt]){
                col[nt]=3-col[nw];
                Q.push(nt);
            }
        }
        if(col[x]==col[y])return 1;
    }
    return 0;
}

inline int Find_Two(){
    register int i;
    for(i=1;i<=m;++i){
        if(Bfs(f[i].a,f[i].b))return i;
        Build(f[i].a,f[i].b) , Build(f[i].b,f[i].a);
    }return i;
}

int main(){
    int Ans;
    Read(); Ans=Find_Two();
    if(Ans>m)puts("0");
    else printf("%d\n",f[Ans].c);
    return 0;
}