洛谷P3379lca,HDU2586,洛谷P1967货车运输,倍增lca,树上倍增

倍增lca板子洛谷P3379

 #include<cstdio>
 struct E
 {
     int to,next;
 }e[];
 int f1[],anc[][],log2n,deep[],n,m,s,ne;
 bool vis[];
 void dfs(int x,int fa)
 {
     int i,k;
     vis[x]=;
     anc[x][]=fa;
     deep[x]=deep[fa]+;
     for(i=;i<=log2n;i++)
         anc[x][i]=anc[anc[x][i-]][i-];
     for(k=f1[x];k!=;k=e[k].next)
         if(!vis[e[k].to])
             dfs(e[k].to,x);
 }
 int lca(int x,int y)
 {
     int t,i;
     if(deep[x]<deep[y]){t=x;x=y;y=t;}
     for(t=deep[x]-deep[y],i=;t>;t>>=,i++)
         if(t&)    x=anc[x][i];
     if(x==y)    return x;
     for(i=log2n;i>=;i--)
         if(anc[x][i]!=anc[y][i])
         {
             x=anc[x][i];
             y=anc[y][i];
         }
     return anc[x][];
 }
 int main()
 {
     int i,x,y,a,b;
     scanf("%d%d%d",&n,&m,&s);
     while((<<(log2n+))<=n)    log2n++;
     for(i=;i<n;i++)
     {
         scanf("%d%d",&x,&y);
         e[++ne].to=y;
         e[ne].next=f1[x];
         f1[x]=ne;
         e[++ne].to=x;
         e[ne].next=f1[y];
         f1[y]=ne;
     }
     dfs(s,);
     while(m--)
     {
         scanf("%d%d",&a,&b);
         printf("%d\n",lca(a,b));
     }
     return ;
 }

How far away ？ HDU - 2586（求树上两点距离）

方法就是求出dis[i]表示i到根节点的距离，那么两点a,b距离就是$dis[a]+dis[b]-2*dis[lca(a,b)]$

错误笔记：

1.20行写成anc[x][i]=anc[fa][i-1];

2.遗漏18行

 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 using namespace std;
 typedef long long LL;
 struct Edge
 {
     LL to,d,nxt;
 }e[];
 LL T,n,m,ne;
 LL f1[],deep[],anc[][],log2n;
 LL dis[];
 void dfs(LL x,LL fa)
 {
     LL i,k;
     anc[x][]=fa;
     deep[x]=deep[fa]+;
     for(i=;i<=log2n;i++)
         anc[x][i]=anc[anc[x][i-]][i-];
     for(k=f1[x];k!=;k=e[k].nxt)
         if(e[k].to!=fa)
         {
             dis[e[k].to]=dis[x]+e[k].d;
             dfs(e[k].to,x);
         }
 }
 LL lca(LL x,LL y)
 {
     LL t,i;
     if(deep[x]<deep[y])    swap(x,y);
     for(t=deep[x]-deep[y],i=;t>;t>>=,i++)
         if(t&)    x=anc[x][i];
     if(x==y)    return x;
     for(i=log2n;i>=;i--)
         if(anc[x][i]!=anc[y][i])
         {
             x=anc[x][i];
             y=anc[y][i];
         }
     return anc[x][];
 }
 int main()
 {
     LL i,a,b,w,t;
     scanf("%lld",&T);
     while(T--)
     {
         ne=;
         memset(f1,,sizeof(f1));
         scanf("%lld%lld",&n,&m);
         log2n=log2(n);
         for(i=;i<n;i++)
         {
             scanf("%lld%lld%lld",&a,&b,&w);
             e[++ne].to=b;
             e[ne].nxt=f1[a];
             e[ne].d=w;
             f1[a]=ne;
             e[++ne].to=a;
             e[ne].nxt=f1[b];
             e[ne].d=w;
             f1[b]=ne;
         }
         dfs(,);
         for(i=;i<=m;i++)
         {
             scanf("%lld%lld",&a,&b);
             t=lca(a,b);
             printf("%lld\n",dis[a]-dis[t]+dis[b]-dis[t]);
         }
     }
     return ;
 }

洛谷 P1967 货车运输（求图中给定两点间的所有路径中，最短边最长的一条路径的最短边）

首先，可以直接取原图的最大生成树，只在这之上查询答案。

原因是，在kruskal生成最大生成树的过程中，是按边权从大到小取边。在判断某条边取不取时，只有两点已经连通，才会不取边，否则一定会取。而如果在判断是否取一条(a,b,w)的边时，a和b已经连通，那么使得a和b连通的路径上任意一条边的权值都一定大于等于w（由于它们都在当前边之前取），也就是使得a和b连通的路径上的最小边权大于等于w。那么对于某两点间路径，如果需要过a到b的路径，那么选择(a,b,w)的路径一定不会比选择使得a和b连通的原来路径更好。

那么，这道题和前面一道就类似了，不过由于最大最小值不满足区间加和，不能简单的像那一道一样用前缀和。正确的方法类似倍增lca求2^i级祖先的过程。

设minn[i][j]表示点i到其2^j级祖先的路径上的最小边权。那么$minn[i][j]=min(minn[i][j-1],minn[anc[i][j-1]][j-1])$。当然，minn[i][0]就是其到父亲的边的边权。这个数组在倍增lca的dfs中可以预处理出来。

在查询的时候，就用倍增lca的查询，但是对于节点向上跳的操作，进行之前应当先把将要跳过的这段路径的最小边权更新到已知的最小边权之上。

错误记录（本地）：

1.47、48行打反

2.35行写成anc[e[k].to]=fa

3.缺少87行

4.缺少66行

 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 using namespace std;
 struct E1
 {
     int a,b,w;
     friend bool operator<(const E1& a,const E1& b)
     {
         return a.w>b.w;
     }
 }e1[];
 struct Edge
 {
     int to,d,nxt;
 }e[];
 int fa[],q,n,m,ne,f1[],anc[][],log2n,minn[][],deep[];
 int find(int x)
 {
     return fa[x]==x?x:fa[x]=find(fa[x]);
 }
 void dfs(int x,int fa)
 {
     int i,k;
     for(i=;i<=log2n;i++)
     {
         anc[x][i]=anc[anc[x][i-]][i-];
         minn[x][i]=min(minn[x][i-],minn[anc[x][i-]][i-]);
     }
     for(k=f1[x];k!=;k=e[k].nxt)
         if(e[k].to!=fa)
         {
             deep[e[k].to]=deep[x]+;
             anc[e[k].to][]=x;
             minn[e[k].to][]=e[k].d;
             dfs(e[k].to,x);
         }
 }
 int get(int x,int y)
 {
     int t,ans=0x3f3f3f3f,i;
     if(deep[x]<deep[y])    swap(x,y);
     for(t=deep[x]-deep[y],i=;t>;t>>=,i++)
         if(t&)
         {
             ans=min(ans,minn[x][i]);
             x=anc[x][i];
         }
     if(x==y)    return ans;
     for(i=log2n;i>=;i--)
         if(anc[x][i]!=anc[y][i])
         {
             ans=min(ans,minn[x][i]);
             ans=min(ans,minn[y][i]);
             x=anc[x][i];
             y=anc[y][i];
         }
     return min(ans,min(minn[x][],minn[y][]));
 }
 int main()
 {
     int i,t1,t2,a,b;
     scanf("%d%d",&n,&m);
     log2n=log2(n);
     memset(minn,0x3f,sizeof(minn));
     for(i=;i<=m;i++)
         scanf("%d%d%d",&e1[i].a,&e1[i].b,&e1[i].w);
     sort(e1+,e1+m+);
     for(i=;i<=n;i++)
         fa[i]=i;
     for(i=;i<=m;i++)
     {
         t1=find(e1[i].a);
         t2=find(e1[i].b);
         if(t1==t2)    continue;
         e[++ne].to=e1[i].b;
         e[ne].nxt=f1[e1[i].a];
         e[ne].d=e1[i].w;
         f1[e1[i].a]=ne;
         e[++ne].to=e1[i].a;
         e[ne].nxt=f1[e1[i].b];
         e[ne].d=e1[i].w;
         f1[e1[i].b]=ne;
         fa[t1]=t2;
     }
     dfs(,);
     scanf("%d",&q);
     while(q--)
     {
         scanf("%d%d",&a,&b);
         if(a>n||b>n||find(a)!=find(b))
         {
             printf("-1\n");
             continue;
         }
         printf("%d\n",get(a,b));
     }
     return ;
 }