bzoj 1977: [BeiJing2010组队]次小生成树

Description

小 C 最近学了很多最小生成树的算法，Prim 算法、Kurskal 算法、消圈算法等等。 正当小 C 洋洋得意之时，小 P 又来泼小 C 冷水了。小 P 说，让小 C 求出一个无向图的次小生成树，而且这个次小生成树还得是严格次小的，也就是说： 如果最小生成树选择的边集是 EM，严格次小生成树选择的边集是 ES，那么需要满足：(value(e) 表示边 e的权值)  这下小 C 蒙了，他找到了你，希望你帮他解决这个问题。

Input

第一行包含两个整数N 和M，表示无向图的点数与边数。 接下来 M行，每行 3个数x y z 表示，点 x 和点y之间有一条边，边的权值为z。

Output

包含一行，仅一个数，表示严格次小生成树的边权和。(数据保证必定存在严格次小生成树)

Sample Input

5 6
1 2 1
1 3 2
2 4 3
3 5 4
3 4 3
4 5 6

Sample Output

11

HINT

数据中无向图无自环； 50% 的数据N≤2 000 M≤3 000； 80% 的数据N≤50 000 M≤100 000； 100% 的数据N≤100 000 M≤300 000 ，边权值非负且不超过 10^9 。

先求出最小生成树。然后枚举每条不在树上的边。求出两个节点在生成树上的最长的小于枚举边长度的边..然后更新所求的变化量，使得变化量最小.枚举求边的部分可以倍增来做。

按理说是水题...可是我交了6次..每次都有不同的发现.最后才改到一直错的地方OTL给自己写代码能力跪了

#include<queue>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
struct line
{
     int s,t;
	 long long x;
     int next;
}a[1000001];
int head[500001];
int edge;
inline void add(int s,int t,long long x)
{
     a[edge].next=head[s];
     head[s]=edge;
     a[edge].s=s;
     a[edge].t=t;
     a[edge].x=x;
}
bool v[500001];
int deep[500001];
int ans[500001][22];
long long anc[500001][22];
inline void bfs(int r)
{
     int i,j;
     deep[r]=1;
     for(i=0;i<=21;i++)
          ans[r][i]=r;
     queue <int>Q;
     while(!Q.empty())
          Q.pop();
     Q.push(r);
     v[r]=true;
     while(!Q.empty())
     {
          int d=Q.front();
          Q.pop();
          for(i=head[d];i!=0;i=a[i].next)
          {
               int t=a[i].t;
               if(!v[t])
               {
                    v[t]=true;
                    Q.push(t);
                    deep[t]=deep[d]+1;
                    ans[t][0]=d;
                    anc[t][0]=a[i].x;
                    int dt;
					long long dc;
                    for(j=1;j<=21;j++)
                    {
                    	 dt=ans[t][j-1];
                    	 dc=anc[t][j-1];
                         ans[t][j]=ans[dt][j-1];
                         dc=max(dc,anc[dt][j-1]);
                         anc[t][j]=dc;
                    }
               }
          }
     }
}
long long ansx;
inline int swim(int x,int y,long long xx)
{
     while(deep[x]!=deep[y])
     {
          int i=0;
          while(deep[ans[y][i]]>deep[x])
               i++;
          if(i!=0)
               i--;
          if(anc[y][i]!=xx)
               ansx=max(ansx,anc[y][i]);
          y=ans[y][i];
     }
     return y;
}
inline long long lca(int x,int y,long long xx)
{
	 ansx=0;
     if(deep[x]>deep[y])
     {
          int t=x;
          x=y;
          y=t;
     }
     y=swim(x,y,xx);
     while(x!=y)
     {
          int i=0;
          while(ans[x][i]!=ans[y][i])
               i++;
          if(i!=0)
               i--;
          if(anc[x][i]!=xx)
               ansx=max(anc[x][i],ansx);
          if(anc[y][i]!=xx)
               ansx=max(anc[y][i],ansx);
          x=ans[x][i];
          y=ans[y][i];
     }
     return ansx;
}
int fa[100001];
inline int find(int x)
{
     if(fa[x]!=x)
          fa[x]=find(fa[x]);
     return fa[x];
}
struct save
{
     int s,t;
	 long long x;
}b[300001];
bool vis[300001];
inline bool cmp(save x,save y)
{
     if(x.x<y.x)
          return true;
     return false;
}
int main()
{
     int n,m;
     scanf("%d%d",&n,&m);
     int i;
     for(i=1;i<=m;i++)
          scanf("%d%d%lld",&b[i].s,&b[i].t,&b[i].x);
     sort(b+1,b+1+m,cmp);
     int fx,fy;
     int s=0;
     long long sum=0;
     memset(vis,false,sizeof(vis));
     for(i=1;i<=n;i++)
          fa[i]=i;
     for(i=1;i<=m;i++)
     {
          fx=find(b[i].s);
          fy=find(b[i].t);
          if(fx!=fy)
          {
               s++;
               fa[fx]=fy;
               sum+=b[i].x;
               vis[i]=true;
               edge++;
               add(b[i].s,b[i].t,b[i].x);
               edge++;
               add(b[i].t,b[i].s,b[i].x);
               if(s==n-1)
                    break;
          }
     }
     bfs(1);
     long long ans1=2100000000,t;
     for(i=1;i<=m;i++)
     {
          if(!vis[i])
          {
               t=lca(b[i].s,b[i].t,b[i].x);
               if(b[i].x!=t)
                    ans1=min(ans1,b[i].x-t);
          }
     }
     sum+=ans1;
     printf("%lld\n",sum); 
     return 0;
}