[校内训练20_05_30]ABC

1.一棵树，边权为1，每次给两个点a，b，d1，d2，找到任意一个到a距离为d1，到b距离为d2的点。

大力分类讨论即可。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1E6+5;
int n,q;
int TI,dfn[maxn],low[maxn],back[maxn],maxd[maxn];
int minn[maxn*4],maxx[maxn*4];
int ans[maxn];
inline int read()
{
    char ch=getchar();
    while(!isdigit(ch))ch=getchar();
    int s=ch-'0';ch=getchar();
    while(isdigit(ch)){s=s*10+ch-'0';ch=getchar();}
    return s;
}
int G[55];
inline void write(int x)
{
    if(x<0)putchar('-'),x=-x;
    int g=0;
    do{G[++g]=x%10;x/=10;}while(x);
    for(int i=g;i>=1;--i)putchar('0'+G[i]);putchar('\n');
}
int size,head[maxn];
int dep[maxn],fa[maxn][21];
struct edge
{
    int to,next;
}E[maxn*2];
inline void add(int u,int v)
{
    E[++size].to=v;
    E[size].next=head[u];
    head[u]=size;
}
void dfs(int u,int F,int d)
{
    low[u]=dfn[u]=++TI;
    back[TI]=u;
    dep[u]=d;
    fa[u][0]=F;
    for(int i=1;i<21;++i)
        fa[u][i]=fa[fa[u][i-1]][i-1];
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F)
            continue;
        dfs(v,u,d+1);
        low[u]=low[v];
        maxd[u]=max(maxd[u],maxd[v]+1);
    }
}
inline int lca(int x,int y)
{
    if(dep[x]<dep[y])
        swap(x,y);
    int d=dep[x]-dep[y];
    for(int i=0;i<21;++i)
        if(d&(1<<i))
            x=fa[x][i];
    if(x==y)
        return x;
    for(int i=20;i>=0;--i)
        if(fa[x][i]!=fa[y][i])
            x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
inline int jump(int x,int d)
{
    for(int i=0;i<21;++i)
        if(d&(1<<i))
            x=fa[x][i];
    return x;
}
inline int dis(int x,int y)
{
    return dep[x]+dep[y]-2*dep[lca(x,y)];
}
void build(int l,int r,int num)
{
    if(l==r)
    {
        minn[num]=maxx[num]=dep[back[l]];
        return;
    }
    int mid=(l+r)>>1;
    build(l,mid,num<<1),build(mid+1,r,num<<1|1);
    minn[num]=min(minn[num<<1],minn[num<<1|1]);
    maxx[num]=max(maxx[num<<1],maxx[num<<1|1]);
}
void ask(int L,int R,int l,int r,int x,int num,int&ans)
{
    if(r<L||R<l||L>R)
        return;
    if(ans!=-1)
        return;
    int mid=(l+r)>>1;
    if(x<minn[num]||maxx[num]<x)
        return;
    if(L<=l&&r<=R)
    {
        if(l==r)
        {
            ans=back[l];
            return;
        }
        if(minn[num<<1]<=x&&x<=maxx[num<<1])
            ask(L,R,l,mid,x,num<<1,ans);
        else if(minn[num<<1|1]<=x&&x<=maxx[num<<1|1])
            ask(L,R,mid+1,r,x,num<<1|1,ans);
    }
    else
    {
        ask(L,R,l,mid,x,num<<1,ans);
        ask(L,R,mid+1,r,x,num<<1|1,ans);
    }
}
inline int get(int u,int d)
{
    int ans=-1;
    ask(dfn[u],low[u],1,n,dep[u]+d,1,ans);
    return ans;
}
struct query
{
    int d,id;
};
vector<query>Q[maxn];
void dfs2(int u,int F,int pos,int P,int p)
{
    if(u!=1)
    {
        int len=dep[u]-dep[pos];
        int g=jump(u,len-1);
        for(int i=0;i<Q[u].size();++i)
        {
            int d=Q[u][i].d,id=Q[u][i].id;
            if(d<=len)
                ans[id]=jump(u,d);
            else if(P!=0)
            {
                ask(dfn[P],low[P],1,n,dep[pos]+d-len,1,ans[id]);
            }
        }
    }
    int pos1=0,pos2=0,d1=0,d2=0;
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F)
            continue;
        int d=1+maxd[v];
        if(d>d1)
        {
            d2=d1,pos2=pos1;
            d1=d,pos1=v;
        }
        else if(d>d2)
            d2=d,pos2=v;
    }
    int d3=dep[u]-dep[pos]+p;
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F)
            continue;
        if(pos1==v)
        {
            if(d3>=d2)
                dfs2(v,u,pos,P,p);
            else
                dfs2(v,u,u,pos2,d2);
        }
        else
        {
            if(d3>=d1)
                dfs2(v,u,pos,P,p);
            else
                dfs2(v,u,u,pos1,d1);
        }
    }
}
inline void solveUp()
{
    int pos1=0,pos2=0,d1=0,d2=0;
    for(int i=head[1];i;i=E[i].next)
    {
        int v=E[i].to;
        int d=1+maxd[v];
        if(d>d1)
        {
            d2=d1,pos2=pos1;
            d1=d,pos1=v;
        }
        else if(d>d2)
            d2=d,pos2=v;
    }
    for(int i=head[1];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==pos1)
            dfs2(v,1,1,pos2,d2);
        else
            dfs2(v,1,1,pos1,d1);
    }
}
int main()
{
    freopen("hunting.in","r",stdin);
    freopen("hunting.out","w",stdout);
    ios::sync_with_stdio(false);
    n=read(),q=read();
    for(int i=2;i<=n;++i)
    {
        int x=read(),y=read();
        add(x,y);
        add(y,x);
    }
    dfs(1,1,0);
    build(1,n,1);
    for(int i=1;i<=q;++i)
    {
        ans[i]=-1;
        int u=read(),d1=read(),v=read(),d2=read();
        int w=lca(u,v);
        int d=dep[u]+dep[v]-2*dep[w];
        int x=d1-d2+d;
        if(d1+d2<d||x<0||(x&1)||x>d*2)
            continue;
        x/=2;
        int up=dep[u]-dep[w];
        if(u==v)
        {
            if(d1!=d2)
                continue;
            if(d1==0)
            {
                ans[i]=u;
                continue;
            }
            ask(dfn[u],low[u],1,n,dep[u]+d1,1,ans[i]);
            if(u!=1)
                Q[u].push_back((query){d1,i});
        }
        else if(x==0)
        {
            if(d1==0)
            {
                ans[i]=u;
                continue;
            }
            if(dfn[v]<=dfn[u]&&low[u]<=low[v])
                ask(dfn[u],low[u],1,n,dep[u]+d1,1,ans[i]);
            else if(dfn[u]<=dfn[v]&&low[v]<=low[u])
            {
                int g=jump(v,dep[v]-dep[u]-1);
                ask(dfn[u],dfn[g]-1,1,n,dep[u]+d1,1,ans[i]);
                ask(low[g]+1,low[u],1,n,dep[u]+d1,1,ans[i]);
                if(u!=1&&dfn[u]<=dfn[v]&&low[v]<=low[u])
                    Q[u].push_back((query){d1,i});
            }
            else
                ask(dfn[u],low[u],1,n,dep[u]+d1,1,ans[i]);
        }
        else if(x==d)
        {
            if(d2==0)
            {
                ans[i]=v;
                continue;
            }
            if(dfn[u]<=dfn[v]&&low[v]<=low[u])
                ask(dfn[v],low[v],1,n,dep[v]+d2,1,ans[i]);
            else if(dfn[v]<=dfn[u]&&low[u]<=low[v])
            {
                int g=jump(u,dep[u]-dep[v]-1);
                ask(dfn[v],dfn[g]-1,1,n,dep[v]+d2,1,ans[i]);
                ask(low[g]+1,low[v],1,n,dep[v]+d2,1,ans[i]);
                if(v!=1&&dfn[v]<=dfn[u]&&low[u]<=low[v])
                    Q[v].push_back((query){d2,i});
            }
            else
                ask(dfn[v],low[v],1,n,dep[v]+d2,1,ans[i]);
        }
        else if(x==up)
        {
            int g1=jump(u,dep[u]-dep[w]-1);
            int g2=jump(v,dep[v]-dep[w]-1);
            int l1=dfn[g1],r1=low[g1];
            int l2=dfn[g2],r2=low[g2];
            if(l1>l2)
                swap(l1,l2),swap(r1,r2);
            if(w==u)
            {
                ask(dfn[w],dfn[g2]-1,1,n,dep[w]+d1-x,1,ans[i]);
                ask(low[g2]+1,low[w],1,n,dep[w]+d1-x,1,ans[i]);
            }
            else if(w==v)
            {
                ask(dfn[w],dfn[g1]-1,1,n,dep[w]+d1-x,1,ans[i]);
                ask(low[g1]+1,low[w],1,n,dep[w]+d1-x,1,ans[i]);
            }
            else
            {
                ask(dfn[w],l1-1,1,n,dep[w]+d1-x,1,ans[i]);
                ask(r1+1,l2-1,1,n,dep[w]+d1-x,1,ans[i]);
                ask(r2+1,low[w],1,n,dep[w]+d1-x,1,ans[i]);
            }
            if(w!=1)
                Q[w].push_back((query){d1-x,i});
        }
        else if(x<up)
        {
            int g=jump(u,x-1);
            int now=fa[g][0];
            ask(dfn[now],dfn[g]-1,1,n,dep[now]+d1-x,1,ans[i]);
            ask(low[g]+1,low[now],1,n,dep[now]+d1-x,1,ans[i]);
        }
        else
        {
            x=d-x;
            int g=jump(v,x-1);
            int now=fa[g][0];
            ask(dfn[now],dfn[g]-1,1,n,dep[now]+d2-x,1,ans[i]);
            ask(low[g]+1,low[now],1,n,dep[now]+d2-x,1,ans[i]);
        }
    }
    solveUp();
    for(int i=1;i<=q;++i)
        write(ans[i]);
    return 0;
}
/*
11 1
1 2
2 3
1 4
4 5
4 6
5 7
5 8
6 9
9 10
10 11

*/

---

2.

有一张 𝑛 个点，𝑚 条边的无向图，你想选出一个非空点集，使得仅保留这个点集中的点和两个端点都在这个点集里的边后得到的图是连通的。问合法的点集数对2取模。n<=50,一条边两个点的编号差小于等于14。

对于一个非空点集，我们计算2的联通块次方。可以发现，若联通块个数大于等于2那么对4取模就是0。

那么相当于给每一个联通块进行染色，统计总方案数，若对4取模为2，答案为1，否则为0。

---

3.问一个字符串中所有长度为m的字符串，有多少个长度为m的字符串和它相似。相似定义为两个字符串至多有1个位置上的字符不同。

相似可以变为最长公共前缀+最长公共后缀>=m-1。这相当于给出两个树，问对于一个点u，有多少个点使得dep1[lca(u,v)]+dep2[lca(u,v)]>=m-1。

树上启发式合并即可。我想不会有人能看懂，就不说了。