bzoj2753

第一问dfs不说

第二问很容易让人想到最小树形图，但是我不会，而且时间复杂度也不允许

还有什么不同的方法呢？

首先想到的是prim的思想，设根节点已经确定，其他点未确定

我们就不断从已确定的点延伸，找到到未确定点中高度最高的那个点的最短边距（如果有多个高度相同的点，肯定选边距最短的）

将边距加入ans，并将这个点标为确定，重复上述，知道所有点都确定即可。

这样的算法没有问题，但是复杂度好像仍然不能AC

我们想，既然我们能用类似prim的思想，为什么不用Kruska呢？

Kruskal的问题在于，这个算法是不涉及到边的方向，用这个不能选出符合条件的解

考虑之前我们用类似prim的思想解题的时候，是以点的高度为第一关键字，然后再以距离为第二关键字

在Kruskal对边排序的时候，我们是不是也可以考虑以点的高度为第一关键字，然后以距离为第二关键字排序呢？

就是这样，我们以边的终点高度为第一关键字降序，长度为第二关键字升序排序

然后按最小生成树的方法做就行了。

结果竟然TLE了，仔细对照一下别人的程序发现一直以来我的并查集写的是有问题的

我原来getfather是这么写的

function getf(x:longint):longint;

begin

while fa[x]<>x do x:=fa[x];

exit(x);

end;

而实际上多次调用这个函数，显然会进行很多冗余的运算

而正确的写法应该是

function getf(x:longint):longint;

begin

if fa[x]<>x then fa[x]:=getf(fa[x]);

exit(fa[x]);

end;

这应该才是并查集所谓反阿克曼函数的时间复杂度吧

亡羊补牢，为时不晚；

 type node=record
        x,c,y,next:longint;
      end;

 var a:array[..] of node;
     fa,p,q,h:array[..] of longint;
     v:array[..] of boolean;
     len,x,y,z,n,m,i,j,k1,k2,t:longint;
     ans,e:int64;

 procedure swap(var a,b:node);
   var c:node;
   begin
     c:=a;
     a:=b;
     b:=c;
   end;

 function getf(x:longint):longint;
   begin
     if fa[x]<>x then fa[x]:=getf(fa[x]); //唉
     exit(fa[x]);
   end;

 procedure add(x,y,z:longint);
   begin
     inc(len);
     a[len].y:=y;
     a[len].c:=z;
     a[len].x:=x;
     a[len].next:=p[x];
     p[x]:=len;
   end;

 procedure bfs;
   var i,f,x,y:longint;
   begin
     t:=;
     q[]:=;
     v[]:=true;
     f:=;
     while f<=t do
     begin
       x:=q[f];
       i:=p[x];
       while i<>- do
       begin
         y:=a[i].y;
         if not v[y] then
         begin
           v[y]:=true;
           inc(t);
           q[t]:=y;
         end;
         i:=a[i].next;
       end;
       inc(f);
     end;
   end;

 procedure sort(l,r:longint);
   var i,j,x,y,z:longint;
   begin
     i:=l;
     j:=r;
     x:=a[(l+r) shr ].c;
     y:=a[(l+r) shr ].y;
     repeat
       while (h[a[i].y]>h[y]) or (h[a[i].y]=h[y]) and (a[i].c<x) do inc(i);
       while (h[y]>h[a[j].y]) or (h[a[j].y]=h[y]) and (x<a[j].c) do dec(j);
       if not(i>j) then
       begin
         swap(a[i],a[j]);
         inc(i);
         j:=j-;
       end;
     until i>j;
     if l<j then sort(l,j);
     if i<r then sort(i,r);
   end;

 begin
   fillchar(p,sizeof(p),);
   readln(n,m);
   len:=;
   for i:= to n do
     read(h[i]);
   for i:= to m do
   begin
     readln(x,y,z);
     if h[x]>h[y] then add(x,y,z)
     else begin
       add(y,x,z);
       if h[x]=h[y] then add(x,y,z);
     end;
   end;
   bfs;
   sort(,len);
   for i:= to n do
     fa[i]:=i;
   i:=;
   j:=;
   for j:= to len do
   begin
     if not(v[a[j].x] and v[a[j].y]) then continue;  //首先必须是能访问到的点
     k1:=getf(a[j].x);
     k2:=getf(a[j].y);
     if k1<>k2 then
     begin
       fa[k2]:=k1;
       e:=a[j].c;
       ans:=ans+e;
       inc(i);
     end;
   end;
   writeln(t,' ',ans);
 end.