[JZOJ5394]【NOIP2017提高A组模拟10.5】Ping

Description

给出一棵树，并给出一些点对，要求你删掉最少的点，使得这些点对间不连通，
（自己连自己删掉也不连通）

求出删点数以及任意一种删除方案。

Solution

先考虑如果这是一条链

点对可以看成区间
就是每一个区间中都至少选择一个点

考虑贪心
区间按右端点排序，左到右扫，碰到了一个右端点，如果对应的左端点之间已经有选的了就不管，否则一定选这个点。

因为排序后尽量选右边的点，可以让尽量多的区间覆盖点，同时又保证每个区间都有。
证明显然。

考虑树上的情况。

其实是一样的，按照DFS序从后向前，把点对询问挂在LCA上，如果扫到了LCA这个点对还没有被删掉，那就必须选LCA

证明同理。
现在只需要维护路径上是否存在选择的点。

拆成x到LCA，LCA到Y的路径。

可以链剖维护。

实际上并不需要。
可以欧拉序+树状数组。

欧拉序就是DFS序的括号序版。
在一个点进的加，出的减。
一个点到根的路径的情况就是这个点进的位置的前缀和。

树状数组维护即可。

Code

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <cstdlib>
#include <vector>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define N 100005
using namespace std;
int dep[N],f[N][20],n,m,dfn[N],in[N],out[N],dn,dl,dt[2*N],fs[N],nt[2*N],a[N][2],le[N],c[2*N],sa[N];
vector<int> a1[N];
void dfs(int k,int ft)
{
    dep[k]=dep[ft]+1;
    dfn[++dn]=k;
    f[k][0]=ft;
    in[k]=++dl;
    for(int i=fs[k];i;i=nt[i])
    {
        int p=dt[i];
        if(p!=ft) dfs(p,k);
    }
    out[k]=++dl;
}
void link(int x,int y)
{
    nt[++m]=fs[x];
    dt[fs[x]=m]=y;
}
int lowbit(int k) 
{
    return k&(-k);
}
void put(int k,int v)
{
    while(k<=2*n) c[k]+=v,k+=lowbit(k);
}
int get(int k)
{
    int s=0;
    while(k) s+=c[k],k-=lowbit(k);
    return s;
}
int lca(int x,int y)
{
    if(dep[x]>dep[y]) swap(x,y);
    int j=19;
    while(dep[x]<dep[y])
    {   
        while(j&&dep[f[y][j]]<dep[x]) j--;
        y=f[y][j];
    }
    j=19;
    while(x!=y)
    {
        while(j&&f[x][j]==f[y][j]) j--;
        x=f[x][j],y=f[y][j];
    }
    return x;
}
int main()
{
    cin>>n>>m;
    m=0;
    fo(i,1,n-1)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        link(x,y);
        link(y,x);
    }
    dfs(1,0);
    cin>>m;
    fo(j,1,19)
        fo(i,1,n) f[i][j]=f[f[i][j-1]][j-1];
    fo(i,1,m)
    {
        int p;
        scanf("%d%d",&a[i][0],&a[i][1]);
        p=lca(a[i][0],a[i][1]);
        a1[p].push_back(i);
        le[p]++;
    }
    int ans=0;
    fod(i,n,1) 
    {
        int k=dfn[i];
        fo(j,0,le[k]-1)
        {
            int x=a[a1[k][j]][0],y=a[a1[k][j]][1];
            if(get(in[x])-2*get(in[f[k][0]])+get(in[y])==0) 
            {
                sa[++ans]=k;
                put(in[k],1);
                put(out[k],-1);
            }
        }
    }
    printf("%d\n",ans);
    fo(i,1,ans) printf("%d ",sa[i]);
}