[LCT维护最小生成树 || CDQ分治 || 线段树 并查集 dfs树] Codeforces 603E #334 (Div. 1) E. Pastoral Oddities

这是个好题啊 这种数据结构题和dfs树有什么关系呢 唯一的关系就是

一个联通块当且仅当有偶数个点时能满足存在边集的一个子集每个点度数为奇数

或者更一般的结论 当一个联通块中每个点的度数奇偶性要求之和是偶数 那么存在

然后我们就转化为一些边使得每个联通块为偶数

这个出题人的标算我没看懂啊 LCT在线维护最小生成树？

http://codeforces.com/blog/entry/21885

这里要维护每个联通块的节点数 我们在LCT上在开一个东西记录下 然后在更改虚父亲的时候维护

#include<cstdio>  
#include<cstdlib>  
#include<cstring>  
#include<set>  
#include<algorithm>  
using namespace std;  
typedef pair<int,int> abcd;  
  
inline char nc(){  
  static char buf[100000],*p1=buf,*p2=buf;  
  if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }  
  return *p1++;  
}  
  
inline void read(int &x){  
  char c=nc(),b=1;  
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;  
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;  
}  

const int N=400005;

struct Splay{  
  struct node{  
    int size,idx,rev;  int w,sum;
    int val,maximum;  
    node *p,*ch[2],*fat,*mpos;  
    inline void setc(node *c,int d) { ch[d]=c; c->p=this; }  
    inline bool dir() { return p->ch[1]==this; }  
    inline void update() {
      sum=ch[0]->sum+ch[1]->sum+w;
      size=ch[0]->size+ch[1]->size+1;  
      maximum=val; mpos=this;  
      if (ch[0]->maximum>maximum)  
	maximum=ch[0]->maximum,mpos=ch[0]->mpos;  
      if (ch[1]->maximum>maximum)  
	maximum=ch[1]->maximum,mpos=ch[1]->mpos;  
    }  
    inline void reverse() { rev^=1; swap(ch[0],ch[1]); }  
    inline void pushdown(node *null){  
      if (rev){  
	if (ch[0]!=null) ch[0]->reverse();  
	if (ch[1]!=null) ch[1]->reverse();  
	rev=0;  
      }  
    }  
  }*null,Mem[N];  
  Splay() { null=Mem; null->p=null->ch[0]=null->ch[1]=null->fat=null; null->size=0; null->maximum=-(1<<30)-(1<<29); null->mpos=null; }  
  inline void rot(node *x){  
    if (x==null || x->p==null) return ;  
    bool d=x->dir(); node *p=x->p;  
    if (p->p!=null) p->p->setc(x,p->dir()); else x->p=null;  
    p->setc(x->ch[d^1],d); x->setc(p,d^1); p->update(); x->update(); swap(x->fat,p->fat);  
  }  
  node *sta[N];  
  inline void splay(node *x){  
    int pnt=0; node *y=x;  
    while (y!=null) sta[++pnt]=y,y=y->p;  
    for (int i=pnt;i;i--) sta[i]->pushdown(null);  
    while (x->p!=null)  
      if (x->p->p==null)  
	rot(x);  
      else  
	x->dir()==x->p->dir()?(rot(x->p),rot(x)):(rot(x),rot(x));  
  }  
  inline node *Access(node *x){  
    node *y=null;  
    while (x!=null){  
      splay(x);  
      x->ch[1]->p=null; x->ch[1]->fat=x; x->w+=x->ch[1]->sum;
      x->setc(y,1); y->fat=null; x->w-=y->sum;
      x->update();  
      y=x; x=x->fat;  
    }  
    return y;  
  }  
  inline void Link(node *x,node *y){  
    if (Jud(x,y)) return;  
    Access(x)->reverse(); splay(x);
    Access(y)->reverse(); splay(y);
    x->fat=y; y->w+=x->sum; y->sum+=x->sum; 
    Access(x);  
  }  
  inline void Cut(node *x){  
    Access(x); splay(x);  
    x->ch[0]->p=null; x->ch[0]=null;
    x->update();  
  }  
  inline void Cut(node *x,node *y){  
    Access(x)->reverse(); Cut(y);  
  }  
  inline node *Root(node *x){  
    Access(x); splay(x);  
    node *y=x; while (y->ch[0]!=null) y->pushdown(null),y=y->ch[0];  
    return y;  
  }  
  inline bool Jud(node *x,node *y){  
    return Root(x)==Root(y);  
  }  
  inline int Query(node *x,node *y){  
    Access(x)->reverse();  
    return Access(y)->maximum;  
  }  
  inline node *Road(node *x,node *y){  
    Access(x)->reverse();  
    return Access(y)->mpos;  
  }
  inline int Size(node *x){
    Access(x); splay(x);
    return x->sum;
  }
}LCT;  

int n,m;
int odd;
int us[N],vs[N],ws[N];

Splay::node *pos[1200005];  
  
inline void Init(){  
  for (int i=1;i<=n+m;i++){  
    pos[i]=LCT.Mem+i;   
    pos[i]->p=pos[i]->ch[0]=pos[i]->ch[1]=pos[i]->fat=LCT.null;   
    pos[i]->val=pos[i]->maximum=-1<<30; pos[i]->mpos=pos[i];  
    pos[i]->idx=i; pos[i]->size=1;
    if (i<=n) pos[i]->w=pos[i]->sum=1;
  }  
}

struct edge{
  int w,idx;
  edge(int w=0,int idx=0):w(w),idx(idx) { }
  bool operator < (const edge &B) const{
    return w==B.w?idx<B.idx:w>B.w;
  }
};
set<edge> Set;

inline int Dedge(int idx){
  int iu=us[idx],iv=vs[idx];
  LCT.Cut(pos[n+idx],pos[iu]);
  LCT.Cut(pos[n+idx],pos[iv]);
  if ((LCT.Size(pos[iu])&1) && (LCT.Size(pos[iv])&1)) odd+=2;
  return !(LCT.Size(pos[iu])&1);
}

inline void Aedge(int idx){
  int iu=us[idx],iv=vs[idx];
  if ((LCT.Size(pos[iu])&1) && (LCT.Size(pos[iv])&1)) odd-=2;
  LCT.Link(pos[n+idx],pos[iu]);
  LCT.Link(pos[n+idx],pos[iv]);
}

int main(){
  int iu,iv;
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(n); read(m);
  Init(); odd=n;
  for (int i=1;i<=m;i++){
    read(us[i]),read(vs[i]),read(ws[i]); pos[i+n]->val=pos[i+n]->maximum=ws[i];
    iu=us[i]; iv=vs[i];  
    if (LCT.Jud(pos[iu],pos[iv])){
      Splay::node *road=LCT.Road(pos[iu],pos[iv]);  
      if (road->val>ws[i]){  
	Dedge(road->idx-n);
	Aedge(i);
	Set.erase(Set.find(edge(ws[road->idx-n],road->idx-n)));
	Set.insert(edge(ws[i],i));
      }
    }else{
      Aedge(i);
      Set.insert(edge(ws[i],i));
    }
    if (odd){ printf("-1\n"); continue; }
    while (Dedge(Set.begin()->idx))
      Set.erase(Set.begin());
    Aedge(Set.begin()->idx);
    printf("%d\n",Set.begin()->w);
  }
  return 0;
}

不过后来补充的题解中的两个离线做法很妙啊

 http://codeforces.com/blog/entry/21914

首先是CDQ分治

考虑这样一个子问题 "Find all answers from time l to time r, given that these answers lie in the interval [lo, hi]."

我们通过可持久化并查集维护 每做到这样一个子问题那么 所有时间小于l权值小于lo的边已经被加入 然后我们再求出ans[mid]分治就行了

题解里的图很好啊

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#define F first
#define S second
using namespace std;
typedef pair<int,int> abcd;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
  return *p1++;
}

inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const int N=300005;

int odd;

int fat[N],size[N];
int pnt; abcd lst[N]; int cnt[N];
inline void init(int n){
  for (int i=1;i<=n;i++) fat[i]=i,size[i]=1;
}
inline int Fat(int u){
  return u==fat[u]?u:Fat(fat[u]);
}
inline bool Merge(int x,int y){
  x=Fat(x); y=Fat(y); if (x==y) return 0;
  if ((size[x]&1) && (size[y]&1)) cnt[++pnt]=2; else cnt[++pnt]=0; odd-=cnt[pnt];
  if (size[x]>size[y]) swap(x,y);
  lst[++pnt]=abcd(x,y);
  fat[x]=y; size[y]+=size[x];  
}
inline void Back(int t){
  while (pnt>t){
    odd+=cnt[pnt];
    fat[lst[pnt].F]=lst[pnt].F;
    size[lst[pnt].S]-=size[lst[pnt].F];
    pnt--;
  }
}

int n,m;
int us[N],vs[N],ws[N];
abcd ed[N]; int rnk[N];

int ans[N];

inline void Solve(int l,int r,int ll,int rr){
  if (l>r) return;
  int tmp=pnt;
  int mid=(l+r)>>1,nmid=-1;
  for (int i=l;i<=mid;i++) if (rnk[i]<ll) Merge(us[i],vs[i]);
  for (int i=ll;i<=rr && odd;i++)
    if (ed[i].S<=mid){
      Merge(us[ed[i].S],vs[ed[i].S]);
      if (!odd) nmid=i; 
    }
  Back(tmp);
  if (nmid==-1){
    for (int i=l;i<=mid;i++) ans[i]=-1;
    for (int i=l;i<=mid;i++) if (rnk[i]<ll) Merge(us[i],vs[i]);
    Solve(mid+1,r,ll,rr);
    Back(tmp);
    return;
  }
  ans[mid]=ed[nmid].F;
  for (int i=ll;i<nmid;i++) if (ed[i].S<l) Merge(us[ed[i].S],vs[ed[i].S]);
  Solve(l,mid-1,nmid,rr);
  Back(tmp);
  for (int i=l;i<=mid;i++) if (rnk[i]<ll) Merge(us[i],vs[i]);
  Solve(mid+1,r,ll,nmid);
  Back(tmp);
}

int main(){
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(n); read(m);
  for (int i=1;i<=m;i++)
    read(us[i]),read(vs[i]),read(ws[i]),ed[i]=abcd(ws[i],i);
  sort(ed+1,ed+m+1);
  for (int i=1;i<=m;i++) rnk[ed[i].S]=i;
  init(n); odd=n;
  Solve(1,m,1,m);
  for (int i=1;i<=m;i++)
    printf("%d\n",ans[i]);
  return 0;
}

exciting啊

我们发现一个重要结论

 if an edge i is used in the optimal solution at time j, then edge i should be present in the union-find in the time interval [i, j].

就是说如果一条边i在时间j是最优解得组成之一 那么它从诞生以来直到j就一直在最优解里面 这应该不难理解 

然后我们倒着做 如果在时刻j用了边i 我们就在i到j-1都用边i 在线段树上打标记就好了 仍然要可持久化并查集

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<vector>
#define F first
#define S second
using namespace std;
typedef pair<int,int> abcd;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
  return *p1++;
}

inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const int N=300005;

int odd;

int fat[N],size[N];
int pnt; abcd lst[N]; int cnt[N];
inline void init(int n){
  for (int i=1;i<=n;i++) fat[i]=i,size[i]=1;
}
inline int Fat(int u){
  return u==fat[u]?u:Fat(fat[u]);
}
inline bool Merge(int x,int y){
  x=Fat(x); y=Fat(y); if (x==y) return 0;
  if ((size[x]&1) && (size[y]&1)) cnt[++pnt]=2; else cnt[++pnt]=0; odd-=cnt[pnt];
  if (size[x]>size[y]) swap(x,y);
  lst[++pnt]=abcd(x,y);
  fat[x]=y; size[y]+=size[x];  
}
inline void Back(int t){
  while (pnt>t){
    odd+=cnt[pnt];
    fat[lst[pnt].F]=lst[pnt].F;
    size[lst[pnt].S]-=size[lst[pnt].F];
    pnt--;
  }
}

int n,m;
int us[N],vs[N],ws[N];
abcd ed[N]; 

int iter=1;
vector<int> opt[N<<2];

int ans[N];

inline void Modify(int x,int l,int r,int ql,int qr,int t){
  if (ql<=l && r<=qr)
    return void(opt[x].push_back(t));
  int mid=(l+r)>>1;
  if (ql<=mid) Modify(x<<1,l,mid,ql,qr,t);
  if (qr>mid) Modify(x<<1|1,mid+1,r,ql,qr,t);
}

inline void Solve(int x,int l,int r){
  int tmp=pnt,mid=(l+r)>>1;
  for (int i=0;i<(int)opt[x].size();i++)
    Merge(us[opt[x][i]],vs[opt[x][i]]);
  if (l!=r){
    Solve(x<<1|1,mid+1,r);
    Solve(x<<1,l,mid);
  }else{
    for (;iter<=m && odd;iter++){
      int e=ed[iter].S;
      if (e>l) continue;
      Merge(us[e],vs[e]);
      if (e<l) Modify(1,1,m,e,l-1,e);
    }
    ans[l]=odd?-1:ed[iter-1].F;
  }
  Back(tmp);
}

int main(){
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(n); read(m);
  for (int i=1;i<=m;i++)
    read(us[i]),read(vs[i]),read(ws[i]),ed[i]=abcd(ws[i],i);
  sort(ed+1,ed+m+1);
  init(n); odd=n;
  Solve(1,1,m);
  for (int i=1;i<=m;i++)
    printf("%d\n",ans[i]);
  return 0;
}