HDU 4912 Paths on the tree 贪心+lca

【题目大意】

一棵树有n个节点，给m条简单路径，问最多能选多少条两两不相交的路径。

【思路】

居然只是贪心...Orz...

按路径（u，v）的lca排序，尽量选lca深的路径就行了。

#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef __int64 LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const LL INF = 1LL<<55;
const double INFF = 1e100;
const double eps = 1e-8;
const LL mod = 10000000007LL;
const int NN = 100010;
const int MM = 400010;
/* ****************** */

struct G
{
    int v,next;
}E[NN*2];
int p[NN],T;
int deep[NN],pos[NN];
int oula[NN*2],tsp;
int rmq[NN*2][20];
int long2[NN*2];
bool vis[NN];
struct Q
{
    int lca, u, v;
    bool operator<(const Q &tt)const
    {
        return deep[lca] > deep[tt.lca];
    }
}q[NN];

void add(int u,int v)
{
    E[T].v=v;
    E[T].next=p[u];
    p[u]=T++;
}
//生成欧拉序列，计算每个节点深度，每个点首次出现的位置
//其第一个父亲，没有用-1表示
void dfs(int u,int fa,int cen)
{
    oula[++tsp]=u;
    deep[u]=cen;
    pos[u]=tsp;

    int i,v;
    for(i=p[u];i+1;i=E[i].next)
    {
        v=E[i].v;
        if(v!=fa)
        {
            dfs(v,u,cen+1);
            oula[++tsp]=u;
        }
    }
}
void init_long2(int n)
{
    int i;
    long2[1]=0;
    for(i=2;i<=n;i++)
    {
        long2[i]=long2[i-1]+(i==(i&(-i)));
    }
}
//用于lca的rmq
void init_rmq(int n)
{
    int i,j,en,len;
    int t1,t2;

    for(i=1;i<=n;i++)
        rmq[i][0]=i;

    for(j=1;j<=long2[n];j++)
    {
        en=n+1-(1<<j);
        len=1<<(j-1);
        for(i=1;i<=en;i++)
        {
            t1=oula[ rmq[i][j-1] ];
            t2=oula[ rmq[i+len][j-1] ];
            if(deep[t1]<deep[t2])
                rmq[i][j]=rmq[i][j-1];
            else
                rmq[i][j]=rmq[i+len][j-1];

           // printf("%d %d %d\n",t1,t2,rmq[i][j]);
        }
      //  puts("");
    }
}
int ask_lca(int u,int v)
{
    int st=pos[u];
    int en=pos[v];
    if(st>en)
        swap(st,en);
    int k=long2[en-st+1];
    int id1=oula[ rmq[st][k] ];
    int id2=oula[ rmq[en+1-(1<<k)][k] ];

    if(deep[id1]<deep[id2])
        return id1;
    return id2;
}
void dfs_col(int u)
{
    vis[u] = true;
    int i, v;
    for (i = p[u]; i + 1; i = E[i].next)
    {
        v = E[i].v;
        if (deep[v] == deep[u] + 1 && !vis[v])
        {
            dfs_col(v);
        }
    }
}

int main()
{
    init_long2(200001);
    int n,m,i,u,v,ans;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(p, -1, sizeof(p));
        T = 0;
        for(i=1;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            add(u,v);
            add(v,u);
        }
        tsp=0;
        dfs(1,-1,0);
        init_rmq(n+n-1);
        for(i=0;i<m;i++)
        {
            scanf("%d%d",&u, &v);
            q[i].u = u;
            q[i].v = v;
            q[i].lca = ask_lca(u, v);
        }
        sort(q, q+m);
        ans = 0;
        memset(vis, false, sizeof(vis));
        for(i = 0; i < m; i ++)
        {
            if(!vis[ q[i].u ] && !vis[ q[i].v ])
            {
                ans ++;
                dfs_col(q[i].lca);
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}