BZOJ 3669: [Noi2014]魔法森林

题目

BZOJ 3669: [Noi2014]魔法森林

题解

感觉收获就是get了一种除了Kruskal和prim之外的最小生成树算法。

理论复杂度貌似是mlogn,不过常数巨大堪比一个log（此句话引用自某论文）。

陈年老题谁都会做，我没做出来qwq。边权按a排序之后做b的最小生成树。对于一条连接(u,v)的边，如果uv不连通那么连起来，否则找u->v最大的边权，然后切掉，把当前边加进去，当1，n联通的时候可以更新答案（我tm还zz的写成了弄出来一棵生成树的时候才有答案，好像也有很多人和我一样（雾））。边权不好维护，把边抽象成点，用点权维护。

然后就是splay维护最大值和最大值出现位置了。easy。感觉lct的板子总是哪里要打错然后调很久233,。不过调的越来越熟练了。自己发明了一套成体系的调试方法，对于指针党简直是太棒了。

代码

//QWsin
#include<map>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int maxn=200000+10;
const int maxm=100000+10;

map<int,int>id;

int n,m;
struct Edge
{
int u,v,a,b;
inline void input(){scanf("%d%d%d%d",&u,&v,&a,&b);}
inline bool operator < (const Edge &rhs)const{
return a<rhs.a||(a==rhs.a&&b<rhs.b);
}
} e[maxm];

struct Node
{
int v,pos,mx,posx,rev;
Node *ch[2],*fa;
Node(){v=pos=mx=posx=rev=0;ch[0]=ch[1]=fa=NULL;}
Node(int v,int pos):v(v),pos(pos){mx=v,posx=pos;rev=0;ch[0]=ch[1]=fa=NULL;}
inline void push(){
if(rev){
swap(ch[0],ch[1]);
if(ch[0]) ch[0]->rev^=1;
if(ch[1]) ch[1]->rev^=1;
rev=0;
}
}
inline void up()
{
mx=v,posx=pos;
if(ch[0] && ch[0]->mx > mx) mx=ch[0]->mx,posx=ch[0]->posx;
if(ch[1] && ch[1]->mx > mx) mx=ch[1]->mx,posx=ch[1]->posx;
};

inline void out(){
if(!this) {puts("NULL");return ;}
printf("%d:\n",id[(int)this]);
printf("    ch[0]=%d\n",id[(int)ch[0]]);
printf("    ch[1]=%d\n",id[(int)ch[1]]);
printf("    fa=%d\n",id[(int)fa]);
printf("    val=%d\n",v);
printf("    mx=%d\n",mx);
printf("    posx=%d\n",posx);
puts("\n");
}
}*tmp[maxn];

struct LinkCutTree
{

Node *node[maxn];
inline void init()
{
id[0]=0;
for(int i=1; i<=n; ++i) node[i]=new Node(),id[(int)node[i]]=i;
for(int i=1; i<=m; ++i) node[n+i]=new Node(e[i].b,i),id[(int)node[n+i]]=n+i;
}

inline int pd(Node* p){return p->fa->ch[1]==p;}
inline int is_root(Node* p){return (!(p->fa))||(p->fa->ch[0]!=p&&p->fa->ch[1]!=p);}
inline void rotate(Node* p)
{
int c=pd(p)^1;
Node *t=p->fa;
t->ch[c^1]=p->ch[c];
if(p->ch[c]) p->ch[c]->fa=t;
p->fa=t->fa;
if(!is_root(t)) p->fa->ch[pd(t)]=p;
t->fa=p;p->ch[c]=t;t->up();p->up();
//      p->out();
}

inline void splay(Node *p)
{
int top=0;
for(Node* t=p;; t=t->fa)
{
tmp[++top]=t;
if(is_root(t)) break;
}
for(; top>=1; --top) tmp[top]->push();
for(; !is_root(p); rotate(p))
if(!is_root(p->fa)) rotate(pd(p)==pd(p->fa) ? p->fa:p);
}

inline void access(Node* p)
{
//      p->out();
for(Node* pre=NULL; p ; pre=p,p=p->fa){
splay(p),p->ch[1]=pre,p->up();
//          pre->out();p->out();
}
}

inline void make_root(Node* p){access(p);splay(p);p->rev=1;}
inline void link(Node* a,Node *b){
//      a->out();b->out();
make_root(a);a->fa=b;
//      a->out();b->out();
}

inline void cut(Node* a,Node *b){
make_root(a);access(b);splay(b);
a->fa=b->ch[1]=NULL;b->up();
}

inline void link(int i){
link(node[e[i].u],node[n+i]);
link(node[n+i],node[e[i].v]);
}

inline void cut(int i){
cut(node[e[i].u],node[i+n]);
cut(node[i+n],node[e[i].v]);
}

inline int getmx(int u,int v,int &id) //u->v路径最大值
{
make_root(node[v]);
access(node[u]);
splay(node[u]);
id=node[u]->posx;
return node[u]->mx;
}

//在u->v路径上找到最大的决定要不要换
inline void find_mx(int i)
{
int id,val=getmx(e[i].u,e[i].v,id);
if(val > e[i].b){cut(id);link(i);}
}
} lct;

inline void init_data()
{
cin>>n>>m;
for(int i=1; i<=m; ++i) e[i].input();
sort(e+1,e+m+1);
}

int p[maxn];
int findset(int x){return p[x]==x?x:p[x]=findset(p[x]);}

inline void solve()
{
for(int i=1; i<=n; ++i) p[i]=i;
lct.init();

int ans=1<<30,cnt=n,bin;
for(int i=1; i<=m; ++i)
{
if(e[i].a > ans) break;
int u=e[i].u,v=e[i].v;
u=findset(u);
v=findset(v);
if(u!=v){lct.link(i); p[u]=v; --cnt;}
else  lct.find_mx(i);
if(findset(1)==findset(n))
ans=min(ans,e[i].a+lct.getmx(1,n,bin));
}
if(findset(1)!=findset(n)) puts("-1");
else cout<<ans<<endl;
}

int main()
{
init_data();
solve();
return 0;
}