为了得到书法大家的真传,小E同学下定决心去拜访住在魔法森林中的隐士。魔法森林可以被看成一个包含个N节点M条边的无向图,节点标号为1..N,边标号为1..M。初始时小E同学在号节点1,隐士则住在号节点N。小E需要通过这一片魔法森林,才能够拜访到隐士。
魔法森林中居住了一些妖怪。每当有人经过一条边的时候,这条边上的妖怪就会对其发起攻击。幸运的是,在号节点住着两种守护精灵:A型守护精灵与B型守护精灵。小E可以借助它们的力量,达到自己的目的。
只要小E带上足够多的守护精灵,妖怪们就不会发起攻击了。具体来说,无向图中的每一条边Ei包含两个权值Ai与Bi。若身上携带的A型守护精灵个数不少于Ai,且B型守护精灵个数不少于Bi,这条边上的妖怪就不会对通过这条边的人发起攻击。当且仅当通过这片魔法森林的过程中没有任意一条边的妖怪向小E发起攻击,他才能成功找到隐士。
由于携带守护精灵是一件非常麻烦的事,小E想要知道,要能够成功拜访到隐士,最少需要携带守护精灵的总个数。守护精灵的总个数为A型守护精灵的个数与B型守护精灵的个数之和。
这道题可以算是一道LCT的经典题目。我们从简单开始考虑,如果只有一维,我们就可以用最小生成树解决。那二维的基本思想其实也没多大变化,我们先按第一维排序一下,使第一维影响消去,那第二维用LCT维护之。不断加边,如果当前两点已联通,则找出当前两点之间的最大值,如果比当前的b值要大,则删掉之前联通两点之间的边,加上当前的边,否则就不管当前的边。那这道题就解决了。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
using namespace std;
struct node
{
int f,sd,son[2];
bool lazy;
node(){f=son[0]=son[1]=0;lazy=false;}
}tr[201000];
int a[201000];
void update(int x)
{
int lc=tr[x].son[0],rc=tr[x].son[1];
tr[x].sd=x;
if(a[tr[lc].sd]>a[tr[x].sd])tr[x].sd=tr[lc].sd;
if(a[tr[rc].sd]>a[tr[x].sd])tr[x].sd=tr[rc].sd;
}
void reverse(int x)
{
tr[x].lazy=false;
swap(tr[x].son[0],tr[x].son[1]);
int lc=tr[x].son[0],rc=tr[x].son[1];
tr[lc].lazy=1-tr[lc].lazy;
tr[rc].lazy=1-tr[rc].lazy;
}
void rotate(int x,int w)
{
int f=tr[x].f,ff=tr[f].f;
int R,r;
R=f,r=tr[x].son[w];
tr[R].son[1-w]=r;
if(r!=0)tr[r].f=R;
R=ff,r=x;
if(tr[R].son[0]==f)tr[R].son[0]=r;
if(tr[R].son[1]==f)tr[R].son[1]=r;
tr[r].f=R;
R=x,r=f;
tr[R].son[w]=r;
tr[r].f=R;
update(f);update(x);
}
int tmp[201000];
void splay(int x,int rt)
{
int s=x,ss=0;
while(tr[s].f!=rt && (tr[tr[s].f].son[0]==s || tr[tr[s].f].son[1]==s))
{
tmp[++ss]=s;
s=tr[s].f;
}
tmp[++ss]=s;
while(ss)
{
s=tmp[ss--];
if(tr[s].lazy==true)reverse(s);
}
while(tr[x].f!=rt && (tr[tr[x].f].son[0]==x || tr[tr[x].f].son[1]==x))
{
int f=tr[x].f,ff=tr[f].f;
if(ff==rt || (tr[ff].son[0]!=f && tr[ff].son[1]!=f))
{
if(tr[f].son[0]==x)rotate(x,1);
else rotate(x,0);
}
else
{
if(tr[f].son[0]==x && tr[ff].son[0]==f)rotate(f,1),rotate(x,1);
if(tr[f].son[1]==x && tr[ff].son[1]==f)rotate(f,0),rotate(x,0);
if(tr[f].son[0]==x && tr[ff].son[1]==f)rotate(x,1),rotate(x,0);
if(tr[f].son[1]==x && tr[ff].son[0]==f)rotate(x,0),rotate(x,1);
}
}
}
void access(int x)
{
int y=0;
while(x)
{
splay(x,0);
tr[x].son[1]=y;
if(y!=0)tr[y].f=x;
y=x;x=tr[x].f;
}
}
void makeroot(int x)
{
access(x);splay(x,0);
tr[x].lazy=1-tr[x].lazy;
}
void Link(int x,int y)
{
makeroot(x);
tr[x].f=y;
access(x);
}
void Cut(int x,int y)
{
makeroot(x);
access(y);splay(y,0);
tr[tr[y].son[0]].f=0;tr[y].son[0]=0;
update(y);
}
int solve(int x,int y)
{
makeroot(x);
access(y);splay(y,0);
update(y);
return tr[y].sd;
}
int fa[51000];
int findfa(int x)
{
if(fa[x]==x)return x;
else
{
fa[x]=findfa(fa[x]);
return fa[x];
}
}
struct edge
{
int x,y,w1,w2;
}e[110000];
bool cmp(edge a,edge b)
{
if(a.w1>b.w1)return false;
if(a.w1<b.w1)return true;
return 0;
}
int main()
{
int n,m,ans=999999999;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)fa[i]=i;
for(int i=1;i<=m;i++)scanf("%d%d%d%d",&e[i].x,&e[i].y,&e[i].w1,&e[i].w2);
sort(e+1,e+m+1,cmp);
for(int i=1;i<=m;i++)
{
int x=e[i].x,y=e[i].y;
int fx=findfa(x),fy=findfa(y);
if(fx==fy)
{
int wy=solve(x,y);
if(a[wy]<=e[i].w2)continue;
Cut(wy,e[wy-n].x);
Cut(wy,e[wy-n].y);
}
else fa[fx]=fy;
a[n+i]=e[i].w2;tr[n+i].sd=n+i;
Link(x,n+i);Link(y,n+i);
if(findfa(1)==findfa(n))ans=min(ans,e[i].w1+a[solve(1,n)]);
}
if(ans==999999999)printf("-1\n");
else printf("%d\n",ans);
return 0;
}