BZOJ 3669 [Noi2014]魔法森林

原创于 2018-09-07 16:20:53 发布 · 184 阅读

0 ·

CC 4.0 BY-SA版权

LCT 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一种利用链剖树(LCT)优化算法解决特定类型图论问题的方法。通过对边权转化为点权，按边的属性排序，并使用LCT维护连通性和边权，实现对最优解的高效求解。文章详细阐述了算法步骤，包括如何判断新加入边的影响，以及如何通过删除或保留边来保持最优解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接

https://www.lydsy.com/JudgeOnline/problem.php?id=3669

题解

将一个a-b，权值为c的边看成a-e-b，其中a,b权值为0，e的权值为c，这样就把边权变成了点权。

首先将所有边按照 $A_i$ 排序，用LCT维护点和边的连通情况，边权为 $B_i$ 。

考虑新加入一条从 $x$ 到 $y$ ，权值为 $a_i,b_i$ 的边。显然，如果这条边对 $1$ 到 $n$ 的答案有影响，那么答案就可以对 $a_i+\max(1\rightarrow n的B_i)$ 取 $\min$ 。如果这条边对答案没有影响，那么答案必定已经 $\leq$ 前述式子，对前述式子更新不会对答案有任何影响（ $a_i$ 不是最小的， $+$ 号后面值的是相同的）。

如果 $x$ 与 $y$ 不连通，那么加入这条边不会对答案产生不利的影响。

如果

x

$x$ 与

y y $y$ 连通，这个时候分两种情况考虑。

若

x

$x$ 到

y y $y$ 的

B_{i}

$B_i$ 最大值

≤bi ≤ b i $\leq b_i$ ，加入这条边必定不会使

1 1 $1$ 到

n

$n$ 的边权最大值变小，因此选择不加入。

若 $x$ 到 $y$ 的 $B_i$ 最大值 $>b_i$ ，此时删去 $x$ 到 $y$ 中边权最大的一个，必定不会使 $1$ 到 $n$ 的边权最大值变大，因此可以这样操作。

可以证明，通过上述操作，得出的解一定是最优的。

代码

#include <cstdio>
#include <algorithm>

int read()
{
  int x=0,f=1;
  char ch=getchar();
  while((ch<'0')||(ch>'9'))
    {
      if(ch=='-')
        {
          f=-f;
        }
      ch=getchar();
    }
  while((ch>='0')&&(ch<='9'))
    {
      x=x*10+ch-'0';
      ch=getchar();
    }
  return x*f;
}

const int maxn=50000;
const int maxm=100000;
const int maxk=maxn+maxm;
const int inf=0x3f3f3f3f;

struct node
{
  node *son[2],*fa,*pos;
  int self,val,rev;
};

node tree[maxk+10];

namespace lct
{
  int isroot(node *x)
  {
    if(x->fa==NULL)
      {
        return 1;
      }
    return !((x->fa->son[0]==x)||(x->fa->son[1]==x));
  }

  int t(node *x)
  {
    return x->fa->son[1]==x;
  }

  int pushdown(node *x)
  {
    if(x->rev)
      {
        x->rev=0;
        std::swap(x->son[0],x->son[1]);
        if(x->son[0]!=NULL)
          {
            x->son[0]->rev^=1;
          }
        if(x->son[1]!=NULL)
          {
            x->son[1]->rev^=1;
          }
      }
    return 0;
  }

  int updata(node *x)
  {
    int l=(x->son[0]==NULL)?0:x->son[0]->val,r=(x->son[1]==NULL)?0:x->son[1]->val;
    x->val=std::max(x->self,std::max(l,r));
    x->pos=(x->self>=std::max(l,r))?x:((l>r)?x->son[0]->pos:x->son[1]->pos);
    return 0;
  }

  int rotate(node *x)
  {
    node *f=x->fa;
    pushdown(f);
    pushdown(x);
    int k=t(x);
    if(!isroot(f))
      {
        f->fa->son[t(f)]=x;
      }
    x->fa=f->fa;
    f->fa=x;
    if(x->son[k^1]!=NULL)
      {
        x->son[k^1]->fa=f;
      }
    f->son[k]=x->son[k^1];
    x->son[k^1]=f;
    updata(x);
    updata(f);
    return 0;
  }

  int splay_root(node *x)
  {
    while(!isroot(x))
      {
        node *f=x->fa;
        if(isroot(f))
          {
            rotate(x);
          }
        else if(t(f)==t(x))
          {
            rotate(f);
            rotate(x);
          }
        else
          {
            rotate(x);
            rotate(x);
          }
      }
    pushdown(x);
    return 0;
  }

  int access(node *x)
  {
    node *y=NULL;
    while(x!=NULL)
      {
        splay_root(x);
        x->son[1]=y;
        if(y!=NULL)
          {
            y->fa=x;
          }
        updata(x);
        y=x;
        x=y->fa;
      }
    return 0;
  }

  int makeroot(node *x)
  {
    access(x);
    splay_root(x);
    x->rev^=1;
    return 0;
  }

  int link(node *x,node *y)
  {
    makeroot(x);
    x->fa=y;
    return 0;
  }

  int cut(node *x,node *y)
  {
    makeroot(x);
    access(y);
    splay_root(y);
    y->son[0]=x->fa=NULL;
    updata(y);
    return 0;
  }

  node* find(node *x)
  {
    access(x);
    splay_root(x);
    while(x->son[0]!=NULL)
      {
        x=x->son[0];
        pushdown(x);
      }
    return x;
  }

  int check(node *x,node *y)
  {
    return find(x)==find(y);
  }

  node* getmax(node *x)
  {
    splay_root(x);
    int v=x->val;
    while(x!=NULL)
      {
        if(x->self==v)
          {
            return x;
          }
        if((x->son[0]!=NULL)&&(x->son[0]->val==v))
          {
            x=x->son[0];
          }
        else
          {
            x=x->son[1];
          }
        pushdown(x);
      }
    return 0;
  }

  node* getpn(node *x,int op)
  {
    splay_root(x);
    x=x->son[op];
    pushdown(x);
    while(x->son[op^1]!=NULL)
      {
        x=x->son[op^1];
        pushdown(x);
      }
    return x;
  }

  int check_link(node *x,node *y,node *e)
  {
    if(check(x,y))
      {
        makeroot(x);
        access(y);
        splay_root(y);
        if(y->val>e->self)
          {
            node *d=y->pos;
            node *p=getpn(d,0),*q=getpn(d,1);
            cut(d,p);
            cut(d,q);
          }
        else
          {
            return 0;
          }
      }
    link(e,x);
    link(e,y);
    return 0;
  }

  int getmax(node *x,node *y)
  {
    makeroot(x);
    access(y);
    splay_root(y);
    return y->val;
  }
}

struct edge
{
  int x,y,a,b;

  bool operator <(const edge &other) const
  {
    if(a==other.a)
      {
        return b<other.b;
      }
    return a<other.a;
  }
};

edge e[maxm+10];
int n,m;

int main()
{
  n=read();
  m=read();
  for(int i=1; i<=m; ++i)
    {
      e[i].x=read();
      e[i].y=read();
      e[i].a=read();
      e[i].b=read();
    }
  std::sort(e+1,e+m+1);
  for(int i=1; i<=n; ++i)
    {
      tree[i].son[0]=tree[i].son[1]=tree[i].fa=NULL;
      tree[i].self=tree[i].val=tree[i].rev=0;
    }
  int ans=inf;
  node *start=&tree[1],*end=&tree[n];
  for(int i=1; i<=m; ++i)
    {
      tree[i+n].son[0]=tree[i+n].son[1]=tree[i+n].fa=NULL;
      tree[i+n].self=tree[i+n].val=e[i].b;
      tree[i+n].rev=0;
      node *l=&tree[e[i].x],*r=&tree[e[i].y],*ed=&tree[i+n];
      lct::check_link(l,r,ed);
      if(lct::check(start,end))
        {
          ans=std::min(ans,e[i].a+lct::getmax(start,end));
        }
    }
  printf("%d\n",(ans==inf)?-1:ans);
  return 0;
}