hdu4912 LCA(ST)+???+贪心

2014 Multi-University Training Contest 5 B - Paths on the tree

题意：

一个n个点的无向树

给你m个路径u,v：路径就是从u走到v的最短路经过的所有点

现在要选尽量多的路径，使得路径不会有交点

思路：

贪心：lca深度大的先选

每次选要判是否能走（路径上的点是否被标记过）

选了之后将整条路径向上暴力vis标记，这样T了

因为可能有极限数据：前1条路径是uv深度小，lca深度小

后R条路径是uv深度大但lca深度很低很低的多条路径，

这样最坏每条要O（n）判是否能走

正解是

贪心还是贪心

但是选了之后将lca以下的子树全部标记，由于排序过，不会漏解

这样的话，选之前判u v lca是否被标记就好了

g++ 694ms

难度0.85

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
#define ll long long
const int maxn=100005;
int head[maxn];
int to[maxn*2];
int nxt[maxn*2];
queue<int>qq;

int cnt=0;

int dep[2*maxn];//序的深度 
int vs[2*maxn];//序对应的点下标 
int id[maxn];//点对应的首次出现序下标 
bool vis[2*maxn];
int fa[maxn];

int dp[2*maxn][20];//ST 第i个序下标 数2^j个的最小的dep 的序下标  

int idx=0;//时间戳 

inline ll read()
{
	ll x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
void add(int u,int v)
{
	cnt++;
	nxt[cnt]=head[u];
	head[u]=cnt;
	to[cnt]=v;
}
void dfs(int u,int p,int d)
{
	fa[u]=p;
	vis[u]=1;
	id[u]=++idx;
	vs[idx]=u;
	dep[idx]=d;
	for(int i=head[u];i!=-1;i=nxt[i])
	{
		int v=to[i];
		if(!vis[v])
		{
			dfs(v,u,d+1);
			vs[++idx]=u;
			dep[idx]=d;
		}
	}
}

void ST(int n)//这里的n是序上限，大概2*点-1 
{
	for(int i=0;i<=n;i++)
		dp[i][0]=i;
	for(int j=1;(1<<j)<=n;j++)
	{
		for(int i=1;i+(1<<j)-1<=n;i++)//dpij->min[i,i+2^j-1]
		{
			int x=dp[i][j-1];int y=dp[i+(1<<(j-1))][j-1];
			if(dep[x]<dep[y])dp[i][j]=x;
			else dp[i][j]=y;
		}
	}
}
int RMQ(int l,int r)
{
	int k=(int)(log10((double)(r-l+1))/log10(2.0));
	int x=dp[l][k];int y=dp[r-(1<<k)+1][k];
	if(dep[x]<dep[y])return x;
	else return y;
} 
int LCA(int x,int y)//返回点下标 
{
	int l=id[x];int r=id[y];
	if(l>r)swap(l,r);
	int pos=RMQ(l,r);
	return vs[pos];	
}
struct path
{
	int u,v,lca;
	path() {};
	path(int u,int v,int lca):u(u),v(v),lca(lca) {};
	bool operator <(const path&a)const
	{
		return dep[id[a.lca]]<dep[id[lca]];
	}
} q[2*maxn];


bool check(int u,int v,int lca)
{
	if(vis[lca])return false;
	if(vis[u])return false;
	if(vis[v])return false;
	return true;
}
void update(int u,int v,int lca)//TLE
{
	while(u!=lca)
	{
		vis[u]=1;
		u=fa[u];
	}
	while(v!=lca)
	{
		vis[v]=1;
		v=fa[v];
	}
	vis[lca]=1;
//	printf("%d %d %d\n",vis[1],vis[2],vis[3]);
}
void bfs(int root) {  
    vis[root] = 1;  
    while (!qq.empty())  qq.pop();  
    qq.push(root);  
    while (!qq.empty()) {  
        int u = qq.front();  
        qq.pop();  
        for (int i = head[u]; i!=-1; i =nxt[i]) {  
            int v = to[i];  
            if (v == fa[u] || vis[v])  continue;  
            vis[v] = 1;  
            qq.push(v);  
        }  
    }  
}  
int main()
{
	int n,m;int u,v;
	while(~scanf("%d %d",&n,&m))
	{
		memset(head,-1,sizeof(head));
		idx=0;
		cnt=0;vis[n]=0;
		for(int i=1;i<=n-1;i++)
		{
			scanf("%d %d",&u,&v);
			vis[i]=0;
		//	u=read();	//	v=read();
			add(u,v);	add(v,u);
		}
		dfs(1,100001,1);
		ST(2*n);
		for(int i=1;i<=m;i++)
		{
			scanf("%d %d",&u,&v);
		//	u=read();	//	v=read();
			q[i]=path(u,v,LCA(u,v));
		}
		memset(vis,0,sizeof(vis));
		sort(q+1,q+1+m);int ans=0;
		
	//	for(int i=1;i<=m;i++)
	//		printf("%d %d %d\n",q[i].u,q[i].v,q[i].lca);
		
		for(int i=1; i<=m; i++)
			if(check(q[i].u,q[i].v,q[i].lca)==true)
				ans++,bfs(q[i].lca);
				//update(q[i].u,q[i].v,q[i].lca);
		printf("%d\n",ans);
	}

}