并查集：关押罪犯

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

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

【数据范围】

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

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

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


由于不会二分图{且noip不考}，很多题解中说可以用并查集做，所以采用并查集。
此题所求的是最大怨气值的最小值。
可以qsort之后，通过二分寻找。
那么如何判断是否满足题意呢？
假设最大怨气值的最小值是第(mid)条关系。
那么从第(mid+1)条关系到第m条关系都不能满足。
可以通过一个数组记录i的敌人h[i]
如果i又有一个敌人j，就将j，h[i]归为一个集合。
在枚举从第mid+1到第m的每一条关系的时候，先判断该关系i，j是否在同一集合中
如果是，直接exit（false）；

code：

var n,m:longint;
    map:array[1..100000]of record
                           x,y,z:longint;
                           end;
    i,j,k:longint;
    x,y,z:longint;
    head,tail,mid:longint;
    father:array[1..20000]of longint;
    h:array[1..20000]of longint;

procedure qsort(x,y:longint);
          var head, tail,k,temp:longint;
          begin head:=x; tail:=y;
                k:=map[(head+tail) div 2].z;
                while head<tail do
                      begin while map[head].z<k do inc(head);
                            while k<map[tail].z do dec(tail);
                            if head<=tail
                               then begin temp:=map[head].x;
                                          map[head].x:=map[tail].x;
                                          map[tail].x:=temp;
                                          temp:=map[head].y;
                                          map[head].y:=map[tail].y;
                                          map[tail].y:=temp;
                                          temp:=map[head].z;
                                          map[head].z:=map[tail].z;
                                          map[tail].z:=temp;
                                          inc(head);
                                          dec(tail);
                                    end;
                      end;
                if x<tail then qsort(x,tail);
                if head<y then qsort(head,y);
          end;

function find(x:longint):longint;
         begin while x<>father[x] do
                     x:=father[x];
               exit(x);
         end;

procedure union(x,y:longint);
          begin father[find(x)]:=find(father[y]);
          end;

function can(x:longint):boolean;
         var i,j,k:longint;
         begin for i:=m downto x+1 do
                   begin if find(map[i].x)=find(map[i].y)
                            then exit(false);
                         if h[map[i].x]=0
                            then h[map[i].x]:=map[i].y
                            else begin if find(h[map[i].x])<>find(map[i].y)
                                          then union(h[map[i].x],map[i].y);
                                 end;
                         if h[map[i].y]=0
                            then h[map[i].y]:=map[i].x
                            else begin if find(h[map[i].y])<>find(map[i].x)
                                          then union(h[map[i].y],map[i].x);
                                 end;
                   end;
               exit(true);
         end;

begin readln(n,m);
      for i:=1 to m do
          readln(map[i].x,map[i].y,map[i].z);
      qsort(1,m);
      head:=0; tail:=m;
      if head=tail
         then begin write(0);
                    {close(input);
                     close(output);
                     }
                    halt;
              end;
      while head<tail do
            begin mid:=(head+tail)div 2;
                  for i:=1 to n do
                      father[i]:=i;
                  fillchar(h,sizeof(h),0);
                  if can(mid)
                     then tail:=mid
                     else head:=mid+1;
            end;
      if head=0
         then writeln(0)
         else writeln(map[head].z);
end.