Paths(树上的贪心）

当数据为一条链的时候
很显然可以用类似于看电视的贪心按尾排序
可以把这个引申到树上

---

首先，去每个路径的收益为一，这与看电视相似
我们应该自己创造一个顺序
使取了这个点之后，满足一段区间具有最优解

我们按照路径两端点LCA的deep由深到浅排序

当我们取了i这个点之后，满足i的子树不再会被取到
由于之后路径的lca的deep会大于或小于当前i的lca的deep
这里分三种情况：
1.下一个点的lca就是i的lca，那么取i或取j都是一样的（在成立的情况下）
2.下一个点的lca与i的lca不同，但深度相同，说明这是两个独立的树，互不影响
3.下一个点的lca与i的lca不同，且深度不同，那么若下一个路径包含i这个路径，显然选i更优，若下一个路径不包含i这个路径，那也选就好了

---

代码实现：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
#define FOR(i,x,y) for(int i=(x);i<=(y);i++)
#define DOR(i,x,y) for(int i=(x);i>=(y);i--)
#define SFOR(i,x,y) for(unsigned int i=(x);i<(y);i++)
#define pb push_back
#define M 100005
#define S 20 
int n,m;
vector<int>edge[M];
int fa[S][M],dep[M];
bool mark[M];
struct node{
    int l,r,lca;
    bool operator <(const node &s)const{
        return dep[lca]>dep[s.lca];
    }
}A[M];
void dfs(int x,int f){
    fa[0][x]=f;
    dep[x]=dep[f]+1;
    SFOR(i,0,edge[x].size()){
        int y=edge[x][i];
        if(f==y)continue;
        dfs(y,x);
    }
}
void up(int &x,int step){
    FOR(i,0,S-1)if(step&(1<<i))x=fa[i][x];
}
int LCA(int x,int y){
    if(dep[x]>dep[y])swap(x,y);
    up(y,dep[y]-dep[x]);
    if(x==y)return x;
    DOR(i,S-1,0){
        if(fa[i][x]!=fa[i][y]){
            x=fa[i][x];
            y=fa[i][y];
        }
    }
    return fa[0][x];
}
void Mark(int x){
    mark[x]=1;
    SFOR(i,0,edge[x].size()){
        int y=edge[x][i];
        if(y==fa[0][x])continue;
        if(!mark[y])Mark(y);
    }
}
int main(){
    scanf("%d%d",&n,&m);
    FOR(i,1,n-1){
        int x,y;
        scanf("%d %d",&x,&y);
        edge[x].pb(y);
        edge[y].pb(x);
    }
    dfs(1,0);
    FOR(i,1,S-1)FOR(j,1,n)fa[i][j]=fa[i-1][fa[i-1][j]];
    FOR(i,1,m){
        scanf("%d %d",&A[i].l,&A[i].r);
        A[i].lca=LCA(A[i].l,A[i].r);
    }
    int ans=0;
    sort(A+1,A+m+1);
    FOR(i,1,m){
        if(mark[A[i].l]||mark[A[i].r])continue;
        Mark(A[i].lca);
        ans++;
    }
    printf("%d\n",ans);
    return 0;
}

复杂度$O(nlogn)$//排序及求每个路径的lca