gym101630 Laminar Family

https://codeforces.com/gym/101630/attachments

一开始写了个假算法没了。。。然后发现假了以后没写完。

先按照路径长度排序，路径长的先染色。

问题的关键是每段区间染色前，这段区间必须只有一种颜色。

我们可以对线段树每一段区间维护一个左端点颜色，右端点颜色和颜色段数。

对于树链剖分，我们先把路径对应的区间全部存在vector里，然后按照线段树中的节点编号排序，从小到大，然后从左到右依次查询区间的情况，然后合并的时候就两个cnt相加，如果左区间右端点颜色等于右区间左端点颜色，那么相当于这个颜色多记了1个。

染色也是一样，找到染色区间就打上lazy tag，说明这段区间被完全染成一种颜色了

#include<bits/stdc++.h>
#define maxl 100010
using namespace std;
 
int n,m,cnt,nodecnt=0,ans,col1,col2;
int ehead[maxl],dep[maxl];
int tot[maxl],son[maxl],top[maxl],fa[maxl];
int idx[maxl],dy[maxl];
struct ed
{
  int to,nxt;
}e[maxl<<1];
struct node
{
  int l,r,cnt,tag;
  int lcol,rcol;
}tree[maxl<<2];
struct path
{
  int u,v,len;
}a[maxl];
typedef pair<int,int> p;
vector <p> b;
 
inline void dfs1(int u,int f)
{
  int v;
  dep[u]=dep[f]+1;fa[u]=f;tot[u]=1;
  for(int i=ehead[u];i;i=e[i].nxt)
    {
      v=e[i].to;
      if(v==f) continue;
      dfs1(v,u);
      tot[u]+=tot[v];
      if(tot[v]>tot[son[u]])
	son[u]=v;
    }
}
 
inline void dfs2(int u,int topf)
{
  int v;
  idx[u]=++nodecnt;dy[nodecnt]=u;
  top[u]=topf;
  if(!son[u])
    return;
  dfs2(son[u],topf);
  for(int i=ehead[u];i;i=e[i].nxt)
    {
      v=e[i].to;
      if(idx[v]) continue;
      dfs2(v,v);
    }
}
 
inline void build(int k,int l,int r)
{
  tree[k].l=l;tree[k].r=r;
  tree[k].cnt=1;
  tree[k].lcol=0;tree[k].rcol=0;
  if(l==r)
    return;
  int mid=(l+r)>>1;
  build(k<<1,l,mid);
  build(k<<1|1,mid+1,r);
}
 
inline int lca(int u,int v)
{
  while(top[u]!=top[v])
    {
      if(dep[top[u]]>dep[top[v]])
	u=fa[top[u]];
      else
	v=fa[top[v]];
    }
  return dep[u]<dep[v]?u:v;
}
 
inline bool cmp(const path &a,const path &b)
{
  return a.len>b.len;
}
 
inline void add(int u,int v)
{
  e[++cnt].to=v;e[cnt].nxt=ehead[u];ehead[u]=cnt;
}
 
inline void prework()
{
  scanf("%d%d",&n,&m);
  cnt=0;int u,v;
  for(int i=1;i<=n-1;i++)
    {
      scanf("%d%d",&u,&v);
      add(u,v);add(v,u);
    }
  dfs1(1,0);
  dfs2(1,1);
  build(1,1,n);
  for(int i=1;i<=m;i++)
    {
      scanf("%d%d",&a[i].u,&a[i].v);
      a[i].len=dep[a[i].u]+dep[a[i].v]-2*dep[lca(a[i].u,a[i].v)];
    }
  sort(a+1,a+1+m,cmp);
}
 
inline void gank(int k)
{
  int d=tree[k].tag;
  if(d>0 && tree[k].l!=tree[k].r)
    {
      tree[k<<1].lcol=tree[k<<1].rcol=d;
      tree[k<<1].cnt=1;tree[k<<1].tag=d;
      tree[k<<1|1].lcol=tree[k<<1|1].rcol=d;
      tree[k<<1|1].cnt=1;tree[k<<1|1].tag=d;
    }
  tree[k].tag=0;
}
 
inline void push_up(int k)
{
  tree[k].lcol=tree[k<<1].lcol;tree[k].rcol=tree[k<<1|1].rcol;
  tree[k].cnt=(tree[k<<1].cnt+tree[k<<1|1].cnt)-(tree[k<<1].rcol==tree[k<<1|1].lcol);
}
 
inline node qry(int k,int l,int r)
{
  node d1,d2,d;
  gank(k);
  if(tree[k].l==l && tree[k].r==r)
      return tree[k];
  int mid=(tree[k].l+tree[k].r)>>1;
  if(r<=mid)
    d=qry(k<<1,l,r);
  else if(l>mid)
    d=qry(k<<1|1,l,r);
  else
    {
      d1=qry(k<<1,l,mid);
      d2=qry(k<<1|1,mid+1,r);
      d.lcol=d1.lcol;d.rcol=d2.rcol;
      d.cnt=d1.cnt+d2.cnt-(d1.rcol==d2.lcol);
    }
  push_up(k);
  return d;
}
 
inline node treeqry(int x,int y)
{
  b.clear();
  node ret,d1,d2;
  ret.lcol=-1;
  while(top[x]!=top[y])
    {
      if(dep[top[x]]<dep[top[y]])
	swap(x,y);
      b.push_back(make_pair(idx[top[x]],idx[x]));
      x=fa[top[x]];
    }
  if(dep[x]>dep[y])
    swap(x,y);
  b.push_back(make_pair(idx[x],idx[y]));
  sort(b.begin(),b.end());
  for(int i=0;i<b.size();i++)
    {
      d2=qry(1,b[i].first,b[i].second);
      if(i==0)
	ret=d2;
      else
	{
	  d1=ret;
	  ret.lcol=d1.lcol;ret.rcol=d2.rcol;
	  ret.cnt=d1.cnt+d2.cnt-(d1.rcol==d2.lcol);
	}
    }
  return ret;
}
 
inline void upd(int k,int l,int r,int x)
{
  gank(k);
  if(tree[k].l==l && tree[k].r==r)
    {
      tree[k].lcol=x;tree[k].rcol=x;
      tree[k].cnt=1;tree[k].tag=x;
      return;
    }
  int mid=(tree[k].l+tree[k].r)>>1;
  if(r<=mid)
    upd(k<<1,l,r,x);
  else if(l>mid)
    upd(k<<1|1,l,r,x);
  else 
    {
      upd(k<<1,l,mid,x);
      upd(k<<1|1,mid+1,r,x);
    }
  push_up(k);
}
 
inline void treeupd(int x,int y,int i)
{
  while(top[x]!=top[y])
    {
      if(dep[top[x]]<dep[top[y]])
	swap(x,y);
      upd(1,idx[top[x]],idx[x],i);
      x=fa[top[x]];
    }
  if(dep[x]>dep[y])
    swap(x,y);
  upd(1,idx[x],idx[y],i);
}
 
inline void mainwork()
{
  ans=1;node d;
  for(int i=1;i<=m;i++)
    {
      col1=-1,col2=-1;
      d=treeqry(a[i].u,a[i].v);
      if(d.cnt>1)
	{
	  ans=0;
	  return;
	}
      treeupd(a[i].u,a[i].v,i);
    }
}
 
inline void print()
{
  if(ans)
    puts("Yes");
  else
    puts("No");
}
 
int main()
{
  //freopen("L1.in","r",stdin);
  prework();
  mainwork();
  print();
  return 0;
}
close