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

最新推荐文章于 2020-04-20 14:05:09 发布

原创最新推荐文章于 2020-04-20 14:05:09 发布 · 243 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LCA #贪心

ACM--LCA 专栏收录该内容

1 篇文章

订阅专栏

本文介绍了一种在无向树中选择尽可能多的不相交路径的问题解决方法。通过使用贪心策略，结合深度优先搜索与最低公共祖先(LCA)算法，确保所选路径之间没有交点。

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);
	}

}