【bzoj3669】[Noi2014]魔法森林

3669: [Noi2014]魔法森林

Time Limit: 30 Sec   Memory Limit: 512 MB
Submit: 2884   Solved: 1806
[ Submit][ Status][ Discuss]

Description

为了得到书法大家的真传，小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型守护精灵的个数之和。

Input

第1行包含两个整数N,M，表示无向图共有N个节点，M条边。 接下来M行，第行包含4个正整数Xi,Yi,Ai,Bi，描述第i条无向边。其中Xi与Yi为该边两个端点的标号，Ai与Bi的含义如题所述。 注意数据中可能包含重边与自环。

Output

输出一行一个整数：如果小E可以成功拜访到隐士，输出小E最少需要携带的守护精灵的总个数；如果无论如何小E都无法拜访到隐士，输出“-1”（不含引号）。

Sample Input

【输入样例1】
4 5
1 2 19 1
2 3 8 12
2 4 12 15
1 3 17 8
3 4 1 17





【输入样例2】


3 1
1 2 1 1

Sample Output

【输出样例1】

32
【样例说明1】
如果小E走路径1→2→4，需要携带19+15=34个守护精灵；
如果小E走路径1→3→4，需要携带17+17=34个守护精灵；
如果小E走路径1→2→3→4，需要携带19+17=36个守护精灵；
如果小E走路径1→3→2→4，需要携带17+15=32个守护精灵。
综上所述，小E最少需要携带32个守护精灵。



【输出样例2】


-1
【样例说明2】
小E无法从1号节点到达3号节点，故输出-1。

HINT

2<=n<=50,000

0<=m<=100,000

1<=ai ,bi<=50,000

Source

[ Submit][ Status][ Discuss]



GG。。。。

这题一开始其实就想到了思路，但是由于不会LCT的边权维护。。还是去百度了一下

言归正传

这一题是一道痕经典的LCT维护最小生成树的题目

首先我们枚举每一个a，依次把a值为当前枚举的a的边加入图中

用LCT维护图上的以b为权值的最小生成树森林（注：LCT维护边权可以每一个边建成点，于是转变成维护点权）

这样做完一遍后查询从1到n的路径上的最大值，更新答案

就没啦。。。

但是可能有个问题：如何维护最小生成树森林呢？

我们这样考虑：

对于加入一条边，如果边的两个端点不为同一棵树内，那么直接加进去就好了；

但是如果两个端点在同一棵树内，那么我们加进去这条边势必会产生一个环，这时候我们删掉环上的最大边，即可满足最小生成树的性质

嗯大概就这样

PS.蒟蒻access里忘打maintain调了两个小时。。。

代码：

#include<cstdio>
#include<vector>
#include<queue>
#include<ctime>
#include<algorithm>
#include<cstdlib>
#include<stack>
#include<cstring>
#include<cmath>
using namespace std;

typedef long long LL;

const int INF = 2147483647;
const int maxn = 200000;

struct data{
	int u,v,a,b;
}e[maxn];

int n,m,tot,ans,p;
int pfa[maxn];
int id[maxn],val[maxn],ch[maxn][2],fa[maxn];
bool rev[maxn],flag,exist[maxn];

inline void maintain(int o)
{
	id[o] = o;
	if (val[id[o]] < val[id[ch[o][1]]]) id[o] = id[ch[o][1]];
	if (val[id[o]] < val[id[ch[o][0]]]) id[o] = id[ch[o][0]];
}

inline void rotate(int x)
{
	int o = fa[x],y = fa[o];
	pfa[x] = pfa[o]; pfa[o] = 0;
	int d = ch[o][1] == x ? 0 : 1;
	ch[o][d ^ 1] = ch[x][d]; maintain(o);
	if (ch[x][d]) fa[ch[x][d]] = o;
	ch[x][d] = o; maintain(x);
	fa[o] = x; fa[x] = y;
	if (y) ch[y][ch[y][1] == o] = x , maintain(y);
}

inline void reverse(int o)
{
	rev[o] ^= 1;
	swap(ch[o][1],ch[o][0]);
}

inline void pushdown(int o)
{
	if (rev[o])
	{
		rev[o] = 0;
		if (ch[o][1]) reverse(ch[o][1]);
		if (ch[o][0]) reverse(ch[o][0]);
	}
}

inline void pushdown_root(int x)
{
	if (fa[x]) pushdown_root(fa[x]);
	pushdown(x);
}

inline void splay(int x)
{
	pushdown_root(x);
	for (int y = fa[x]; y; rotate(x) , y = fa[x])
		if (fa[y]) rotate((ch[y][1] == x) ^ (ch[fa[y]][1] == y) ? x : y);
}

inline void access(int x)
{
	for (int u = x,v = 0; u; v = u,u = pfa[u])
	{
		splay(u);
		if (ch[u][1]) fa[ch[u][1]] = 0 , pfa[ch[u][1]] = u;
		if (v) fa[v] = u , pfa[v] = 0;
		ch[u][1] = v;
		maintain(u);
	}
}

inline void change(int u)
{
	access(u);
	splay(u);
	reverse(u);
}

inline void cut(int u,int v)
{
	change(u);
	access(v);
	splay(v);
	if (ch[v][0]) fa[ch[v][0]] = 0 , ch[v][0] = 0;
	maintain(v);
}

inline void join(int u,int v)
{
	change(v);
	pfa[v] = u;
	access(v);
}

inline int find(int u)
{
	access(u);
	splay(u);
	while (ch[u][0]) u = ch[u][0];
	return u;
}

inline int query(int u,int v)
{
	change(u);
	access(v);
	splay(v);
	return id[v];
}

inline LL getint()
{
    LL ret = 0,f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-') f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
        ret = ret * 10 + c - '0',c = getchar();
    return ret * f;
}

inline bool cmp(data a,data b)
{
	return a.a < b.a;
}

int main()
{
	n = getint(); m = getint();
	for (int i = 1; i <= m; i++) e[i] = (data){getint(),getint(),getint(),getint()};
	sort(e + 1,e + m + 1,cmp);
	ans = INF;
	tot = n;
	for (int i = 1; i <= m; i++)
	{
		int u = e[i].u,v = e[i].v,w = e[i].b;
		val[++tot] = w;
		if (u != v) 
		{
			if (find(u) != find(v))
			{
				join(u,tot); 
				join(tot,v);
			}
			else
			{
				int pos = query(u,v);
				if (val[pos] > w)
				{
					cut(pos,e[pos - n].u);
					cut(e[pos - n].v,pos);
					join(u,tot); 
					join(tot,v);
				}
			}
		}
		if (e[i].a != e[i + 1].a)
		{
			if (find(1) != find(n)) continue;
			int pos = query(1,n);
			ans = min(ans,val[pos] + e[i].a);
		}
	}
	if (ans == INF) printf("-1\n");
	else printf("%d\n",ans);
    return 0;
}