树形结构升级训练 习题

时间  2019-11-20
标签 结构 升级 训练 习题 繁體版
原文   原文链接

标签（空格分隔）： 517coding solution problemnode

Task 1

对边进行树上差分。ios

考虑到一条路径\(u - v\) 能够将$c_u +=1 ,c_v +=1 ,c_{lca(u,v)}-=2 $c++

而后对整一棵树求子树和，对于每一个点的子树和，就是这个点向上那条边的答案。数组

复杂度\(O(n \ log \ n)\)spa

# include <bits/stdc++.h>
using namespace std;
const int N=1e5+10;
struct rec{ int pre,to; }a[N<<1];
int head[N],tot=1,ans[N],c[N],dep[N],g[N][22],n,m;
void adde(int u,int v)
{
    a[++tot].pre=head[u];
    a[tot].to=v;
    head[u]=tot;
}
void dfs(int u,int fa)
{
    dep[u]=dep[fa]+1; g[u][0]=fa;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue;
        dfs(v,u);
    }
}
void init()
{
    dfs(1,0);
    for (int i=1;i<=21;i++)
     for (int j=1;j<=n;j++)
      g[j][i]=g[g[j][i-1]][i-1];
}
int lca(int u,int v)
{
    if (dep[u]<dep[v]) swap(u,v);
    for (int i=21;i>=0;i--)
     if (dep[g[u][i]]>=dep[v]) u=g[u][i];
    if (u==v) return u;
    for (int i=21;i>=0;i--)
     if (g[u][i]!=g[v][i]) u=g[u][i],v=g[v][i];
    return g[u][0];
}
void dfs2(int u,int fa,int to)
{
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue;
        dfs2(v,u,i>>1);c[u]+=c[v];
    }
    ans[to]=c[u];
}
int main()
{
    scanf("%d",&n);
    for (int i=1;i<n;i++) {
        int u,v;scanf("%d%d",&u,&v);
        adde(u,v); adde(v,u);
    }
    scanf("%d",&m);
    init();
    for (int i=1;i<=m;i++) {
        int u,v;scanf("%d%d",&u,&v);
        c[u]++; c[v]++; c[lca(u,v)]-=2;
    }
    dfs2(1,0,0);
    for (int i=1;i<=n-1;i++) printf("%d ",ans[i]);
    return 0;
}

Task 2

首先将题目所给的相连的黑色点和白色点都缩成一个点。code

而后这棵树就变成黑白相间的点了。排序

那么若是对于某一点进行操做势必能够从改点为中心向外辐射，不断能够把该点为中心的连通块染成同一颜色。get

for example ， 1 0 1 0 1 第一次能够变成1 0 0 0 1 第二次能够变成 1 1 1 1 1 。string

那么对于一棵树，操做的最优的点显然是树的直径的中点附近。it

全部问题有转化为将树的直径染色使得直径变成同一颜色。

考虑若长度为奇数 ： 形如 1 0 1 ，答案就是 len/2
若长度为偶数：形如 1 0 ，答案就是len/2

复杂度是\(O(n)\)

# include <bits/stdc++.h>
using namespace std;
const int N=2e5+10;
struct rec{
    int pre,to;
}a[N<<1];
int w[N],head[N],n,m,tot,d[N],belong[N];
vector<int>E[N];
void adde(int u,int v)
{
    a[++tot].pre=head[u];
    a[tot].to=v;
    head[u]=tot;
}
void dfs1(int u,int num)
{
    belong[u]=num;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to;
        if ((belong[v]==-1) && (w[v]==0)) dfs1(v,num);
    }
}
void dfs2(int u,int num)
{
    belong[u]=num;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to;
        if ((belong[v]==-1) && (w[v]==1)) dfs2(v,num);
    }
}
void dfs3(int u,int fa,int L)
{
    d[u]=L;
    for (int i=0;i<E[u].size();i++)
     if (E[u][i]!=fa) dfs3(E[u][i],u,L+1);
}
int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&w[i]);
    for (int i=1;i<n;i++) {
        int u,v; scanf("%d%d",&u,&v);
        adde(u,v); adde(v,u);
    }
    memset(belong,-1,sizeof(belong)); int tt=0;
    for (int i=1;i<=n;i++) if ((belong[i]==-1) && (w[i]==0)) tt++,dfs1(i,tt);
    for (int i=1;i<=n;i++) if ((belong[i]==-1) && (w[i]==1)) tt++,dfs2(i,tt);
    
    for (int u=1;u<=n;u++) for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to;
        if (belong[v]!=belong[u]) E[belong[v]].push_back(belong[u]);
    }
    for (int i=1;i<=tt;i++){
        int tmp=unique(E[i].begin(),E[i].end())-E[i].begin();
        E[i].erase(E[i].begin()+tmp,E[i].end());
    }
    memset(d,0,sizeof(d)); int pt=0;
    dfs3(1,0,1);
    for (int i=1;i<=tt;i++) if (d[pt]<d[i]) pt=i;
    memset(d,0,sizeof(d)); int ans=0;
    dfs3(pt,0,1);
    for (int i=1;i<=tt;i++) if (ans<d[i]) ans=d[i];
    printf("%d\n",ans>>1);
    return 0;
}

Task 3

经典的树上路径交的问题。

考虑两条路径\([a,b] , [c,d]\)交的条件。

就是\(lca(a,b)\)在\([c,d]\)上或者\(lca(c,d)\)在\([a,b]\)上。

一种比较好的策略是尽量选择\(lca\)深度大的路径，这样至少不会坏。

首先，每一条路径最多对答案作出1的贡献，而后深度若是越小，那么越可能和其余路径相交。若是按照深度一次递增的状况，不会更坏。

处理的时候，若是\(u\)为$ lca$的路径是合法的话，那么其子树的其余节点必然不可能成为路径的出发点，因此直接把它的子树赋值为false便可。

这样子复杂度就是对的了，

复杂度 $ O(n  log  n) $

# include <bits/stdc++.h>
using namespace std;
const int N=1e5+10;
struct node{ int u,v,l;}p[N];
struct rec{ int pre,to;}a[N<<1];
int n,m,tot,head[N],dep[N],g[N][22];
bool vis[N];
void clear()
{
    memset(p,0,sizeof(p)); memset(a,0,sizeof(a));
    memset(head,0,sizeof(head)); memset(dep,0,sizeof(dep));
    memset(g,0,sizeof(g)); memset(vis,false,sizeof(vis));
    tot=0;
}
void adde(int u,int v)
{
    a[++tot].pre=head[u];
    a[tot].to=v;
    head[u]=tot;
}
void dfs(int u,int fa)
{
    dep[u]=dep[fa]+1; g[u][0]=fa;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue;
        dfs(v,u);
    }
}
void init()
{
    dfs(1,0);
    for (int i=1;i<=21;i++)
     for (int j=1;j<=n;j++)
      g[j][i]=g[g[j][i-1]][i-1];
}
int lca(int u,int v)
{
    if (dep[u]<dep[v]) swap(u,v);
    for (int i=21;i>=0;i--)
     if (dep[g[u][i]]>=dep[v]) u=g[u][i];
    if (u==v) return u;
    for (int i=21;i>=0;i--)
     if (g[u][i]!=g[v][i]) u=g[u][i],v=g[v][i];
    return g[u][0];
}
bool cmp(node a,node b){return dep[a.l]>dep[b.l];}
void draw(int u,int fa)
{
    vis[u]=true;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa||vis[v]) continue;
        draw(v,u);
    }
}
int main ()
{
    while (~scanf("%d%d",&n,&m)) {
        clear();
        for (int i=2;i<=n;i++) {
            int u,v; scanf("%d%d",&u,&v);
            adde(u,v); adde(v,u);
        }
        init();
        for (int i=1;i<=m;i++) {
            scanf("%d%d",&p[i].u,&p[i].v);
            p[i].l=lca(p[i].u,p[i].v);
        }
        sort(p+1,p+1+m,cmp);
        int ans=0; memset(vis,false,sizeof(vis));
        for (int i=1;i<=m;i++) {
            if (vis[p[i].u]||vis[p[i].v]) continue;
            ans++; draw(p[i].l,g[p[i].l][0]);
        }
        printf("%d\n",ans);

    }
    return 0;
}

Task 4

先将树的任意一条直径找出来，考虑树的直径必定是交于一条线段上的。
那么从直径两段往中间搜必定是中间这一段路径是惟一的。

设直径是\([s,t]\)，把这个直径拉出来，左侧是\(s\)，右侧是\(t\);

  • 先以\(s\)为根，而后跑整一棵树，求出子树最长链和它的条数.
  • 从\(t\)开始向左遍历整个直径，找到最左侧的一个点\(v\)使得其右侧相邻的一条边不是必经边(即便得当前点的右侧最长链条数不发生变化)
  • 而后以\(t\)为根，而后跑整一棵树，求出子树最长链和它的条数.
  • 从\(s\)开始向右遍历整个直径，找到最右侧的一个点\(u\)使得其左侧相邻的一条边不是必经边(即便得当前点的左侧最长链条数不发生变化)
  • 链\([u,v]\)中全部的边都是必经边。

上述过程显然是一个线性过程，复杂度是\(O(n)\)

# include <cstdio>
# include <iostream>
# include <cstring>
# define int long long
using namespace std;
const int N=2e5+10;
struct rec{ int pre,to,w;}a[N<<1];
int n,tot;
int d[N],head[N],tim[N],f[N],path[N],pre[N];
void adde(int u,int v,int w)
{
    a[++tot].pre=head[u];
    a[tot].to=v;
    a[tot].w=w;
    head[u]=tot;
}
void dfs1(int u,int fa,int L)
{
    d[u]=L;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue;
        dfs1(v,u,L+a[i].w);
    }
}
void dfs2(int u,int fa,int L)
{
    d[u]=L;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue;
        pre[v]=u; dfs2(v,u,L+a[i].w);
    }
}
void dfs3(int u,int fa)
{
    int cnt=0,mx=0; bool leaf=1;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue; leaf=0;
        dfs3(v,u);
        if (f[v]+a[i].w>mx) mx=f[v]+a[i].w,cnt=tim[v];
        else if (f[v]+a[i].w==mx) cnt+=tim[v];
    }
    if (leaf) f[u]=0,tim[u]=1;
    else f[u]=mx,tim[u]=cnt;
}
signed main()
{
    scanf("%lld",&n);
    for (int i=1;i<n;i++) {
        int u,v,w; scanf("%lld%lld%lld",&u,&v,&w);
        adde(u,v,w); adde(v,u,w);
    }
    memset(d,0,sizeof(d));
    dfs1(1,0,0); int s=0;
    for (int i=1;i<=n;i++) if (d[i]>d[s]) s=i;
    memset(d,0,sizeof(d));
    dfs2(s,0,0); int t=0; pre[s]=-1;
    for (int i=1;i<=n;i++) if (d[i]>d[t]) t=i;
    printf("%lld\n",d[t]);
    int u=t,v; while (pre[u]!=-1) path[++path[0]]=u,u=pre[u]; path[++path[0]]=u;
    for (int i=1;i<=path[0]/2;i++) swap(path[i],path[path[0]-i+1]);
    memset(f,0,sizeof(f)); memset(tim,0,sizeof(tim)); dfs3(s,0);
    v=path[0];
    for (int i=path[0]-1;i>=1;i--)
     if (tim[path[i]]-tim[path[i+1]]>0) v=i;
    memset(f,0,sizeof(f)); memset(tim,0,sizeof(tim)); dfs3(t,0);
    u=1;
    for (int i=2;i<=path[0];i++)
     if (tim[path[i]]-tim[path[i-1]]>0) u=i;
    printf("%lld\n",v-u);
    return 0;
}

Task 5

按照上述作法添加一次叶子，直径最多只可能增长1。

咱们只须要维护当前树的直径(的两个端点)就能够了。

设以前的端点是\(A,B\)当前新加入一个叶子\(x\) ，

  • 若\(dist(x,A) > Now\) : $Now = dist(x,A),B=x $
  • 若\(dist(x,B) > Now\) : $Now = dist(x,B),A=x $

离线处理搞搞\(lca\)就能够了。

复杂度是\(O((2q+4) \ log \ (2q+4))\)

# include <bits/stdc++.h>
using namespace std;
const int N=1e6+1000;
struct rec{ int pre,to;}a[N<<1];
int head[N],q[N],n,tot,dep[N],g[N][22];
void adde(int u,int v)
{
    a[++tot].pre=head[u];
    a[tot].to=v;
    head[u]=tot;
}
void dfs(int u,int fa)
{
    g[u][0]=fa; dep[u]=dep[fa]+1;
    for (int i=head[u];i;i=a[i].pre) {
        int v=a[i].to; if (v==fa) continue;
        dfs(v,u);
    }
}
void init()
{
    dfs(1,0);
    for (int i=1;i<=21;i++)
     for (int j=1;j<=n;j++)
      g[j][i]=g[g[j][i-1]][i-1];
}
int lca(int u,int v)
{
    if (dep[u]<dep[v]) swap(u,v);
    for (int i=21;i>=0;i--)
     if (dep[g[u][i]]>=dep[v]) u=g[u][i];
    if (u==v) return u;
    for (int i=21;i>=0;i--)
     if (g[u][i]!=g[v][i]) u=g[u][i],v=g[v][i];
    return g[u][0];
}
int dist(int x,int y)
{
    int l=lca(x,y);
    return (dep[x]-dep[1]+dep[y]-dep[1])-2*(dep[l]-1);
}
int main()
{
    //freopen("1.in","r",stdin);
    int Q; scanf("%d",&Q);
    n=4; adde(1,2); adde(2,1); adde(1,3); adde(3,1); adde(1,4); adde(4,1);
    for (int i=1;i<=Q;i++) {
        scanf("%d",&q[i]);
        adde(n+1,q[i]); adde(q[i],n+1);
        adde(n+2,q[i]); adde(q[i],n+2);
        n+=2;
    }
    init();
    int now=2,A=2,B=4,m=4;
    for (int i=1;i<=Q;i++) {
        int u=q[i],v=++m;
        int d1=dist(v,A),d2=dist(v,B);
        if (d1>now) now=d1,B=v;
        else if (d2>now) now=d2,A=v;
        v=++m;
        d1=dist(v,A),d2=dist(v,B);
        if (d1>now) now=d1,B=v;
        else if (d2>now) now=d2,A=v;
        printf("%d\n",now);
    }
    return 0;
}

Task 6

第一问就是裸的最大生成树，边权排序跑kruskal就能够了。

第二问求一棵树上知足对于路径\([u,v]\)上两个编号为\(i,j\)的点，在知足\(i>j\)的条件下，最大化\(c_i - c_j\) 的值。

考虑到编号对答案的限制，因此咱们不妨考虑用倍增来完成限制。

能够首先用5个倍增数组，分别表示"\(u\)向上跳\(2^j\)的节点是谁","\(u\)向上跳\(2^j\)的合法最大值"，"\(u\)向上跳\(2^j\)的合法最小值"，"\(u\)向上跳\(2^j\)的合法最大极差（祖先-孙子）"，"\(u\)向上跳\(2^j\)的合法最大极差（孙子-祖先）"

最后答案必定是由\([u,lca]\) , \([v,lca]\),跨\(lca\)三个部分组成的，拼凑一下便可。

复杂度是\(O(n \ log \ n)\)

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>
#include<algorithm>
#include<stack>
#define N 60000
std::queue<int>q; 
struct aa{
    int p,next;
}da[N*3];
struct noz{
    int x,y,len;
}line[N*2];
int fa[N],dd,tou[N],mx[N][21],mi[N][21],fm[N][21],dp[N][21],dp2[N][21];
int n,b[N],m,dep[N];
bool vis[N];
int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
void add(int x,int y){
    da[++dd].p=y;da[dd].next=tou[x];tou[x]=dd;
    da[++dd].p=x;da[dd].next=tou[y];tou[y]=dd;
}
void bfs(){
    q.push(1);
    vis[1]=1;
    dep[1]=1;
    while (!q.empty()){
        int u=q.front();q.pop();
        for (int i=tou[u];i;i=da[i].next){
            int v=da[i].p;
            if (!vis[v]){
                dep[v]=dep[u]+1;
                q.push(v),vis[v]=1;
                fm[v][0]=u;
                mx[v][0]=std::max(b[v],b[u]);
                mi[v][0]=std::min(b[v],b[u]);
                dp[v][0]=b[u]-b[v];
                dp2[v][0]=b[v]-b[u];
            }
        }
        for (int i=1;i<=20;i++){
            fm[u][i]=fm[fm[u][i-1]][i-1];
            if (!fm[u][i])break;
            mx[u][i]=std::max(mx[u][i-1],mx[fm[u][i-1]][i-1]);
            mi[u][i]=std::min(mi[u][i-1],mi[fm[u][i-1]][i-1]);
            dp[u][i]=std::max(dp[u][i-1],mx[fm[u][i-1]][i-1]-mi[u][i-1]);
            dp[u][i]=std::max(dp[u][i],dp[fm[u][i-1]][i-1]);
            dp2[u][i]=std::max(dp2[u][i-1],mx[u][i-1]-mi[fm[u][i-1]][i-1]);
            dp2[u][i]=std::max(dp2[u][i],dp2[fm[u][i-1]][i-1]);
        }
    }
}
int lca(int x,int y){
    if (dep[x]<dep[y])std::swap(x,y);
    for (int i=20;i>=0;i--)
      if (dep[x]-dep[y]>=1<<i)x=fm[x][i];
    if (x==y)return x;
    for (int i=20;i>=0;i--)
      if (fm[x][i]!=fm[y][i]){
        x=fm[x][i];
        y=fm[y][i];
      }
    if (x==y)return x;
    else return fm[x][0];
}
int getMAX(int x,int goal){
    int ma=0;
    for (int i=20;i>=0;i--)
      if (dep[x]-dep[goal]>=1<<i){
        ma=std::max(ma,mx[x][i]);
        x=fm[x][i];
      }
    return ma;
} 
int  getMIN(int x,int goal){
    int ma=0x5f5f5f5f;
    for (int i=20;i>=0;i--)
      if (dep[x]-dep[goal]>=1<<i){
        ma=std::min(ma,mi[x][i]);
        x=fm[x][i];
      }
    return ma;
}
int opre1(int x,int goal){
    int ma=0x5f5f5f5f;
    int num=0;
    for (int i=20;i>=0;i--)
     if (dep[x]-dep[goal]>=1<<i){
        num=std::max(num,dp[x][i]);
        num=std::max(num,mx[x][i]-ma);
        ma=std::min(ma,mi[x][i]);
        x=fm[x][i];
    }
    return num;
}
int opre2(int x,int goal){
    int ma=-0x5f5f5f5f;
    int num=0;
    for (int i=20;i>=0;i--)
     if (dep[x]-dep[goal]>=1<<i){
        num=std::max(num,dp2[x][i]);
        num=std::max(num,ma-mi[x][i]);
        ma=std::max(ma,mx[x][i]);
        x=fm[x][i];
    }
    return num;
}
bool cmp(noz a,noz b){return a.len>b.len;}
int main(){
    while (scanf("%d",&n)!=EOF){
        dd=0;
        memset(tou,0,sizeof(tou));
        memset(vis,0,sizeof(vis));
        memset(dep,0,sizeof(dep));
        for (int i=1;i<=n;i++)fa[i]=i;
        for (int i=1;i<=n;i++)
          for (int j=0;j<=20;j++)
            mx[i][j]=dp[i][j]=dp2[i][j]=fm[i][j]=0,mi[i][j]=0x5f5f5f5f;
        for (int i=1;i<=n;i++)scanf("%d",&b[i]); 
        scanf("%d",&m);
        for (int i=1;i<=m;i++)scanf("%d%d%d",&line[i].x,&line[i].y,&line[i].len);
        std::sort(line+1,line+1+m,cmp);
        int tot=0;int sum=0;
        for (int i=1;i<=m;i++){
            int fx=find(line[i].x);
            int fy=find(line[i].y);
            if (fx!=fy){
                fa[fx]=fy;
                ++tot;
                sum+=line[i].len;
                add(line[i].x,line[i].y);
                if (tot==n-1)break;
            }
        }
        printf("%d\n",sum);
        bfs();
        int q;
        scanf("%d",&q);
        for (int i=1;i<=q;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            int LCA=lca(x,y);
            int x1=opre1(x,LCA);
            int x2=opre2(y,LCA);
            printf("%d\n",std::max(std::max(x1,x2),getMAX(y,LCA)-getMIN(x,LCA)));
        }
    }
    return 0;
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程