3669: [Noi2014]魔法森林
Time Limit: 30 Sec Memory Limit: 512 MBSubmit: 3462 Solved: 2216
[ 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
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
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
解题思路：终于搞懂啦！LCT强无敌！感谢博客 https://blog.csdn.net/Maxwei_wzj/article/details/72513910
如果只有一种守护精灵，那么直接做个最小生成树或者跑个类似SPFA的BFS即可。
如果是两种则
首先对于所有边按aiai从小到大排序，然后逐个添加边，每添加一条边之前，检查边的两个端点是否已经连通，如果没有连通就直接连接这一条边，否则，询问已经构建好的树中的这两个端点之间的路径上的最大bibi，如果这个最大值要比要添加的边的bibi大，那么就去掉原来的边而把新边加入，否则不动。添加完边之后，检查点11和点NN是否连通，如果连通，那么就用这两个点之间路径上最大的bibi加上刚添加的边的aiai来更新答案即可。显然，当要添加的边的aiai已经比已知答案更大，就直接退出，据悉，这个剪枝能省不少时间。
以上的方法是可实现的，关键在于三个点：一是判断两点之间的连通性，二是边的删除和插入，三是询问路径上的边权最大值。那么我们就可以用LCT来维护了，因为LCT直接维护边权十分麻烦，所以我们可以把边化为点，点权为原来的边权，连接原来的两个端点，原来的点的点权均为0，这样就可以得到一个等价的图。
再次保证我的LCT模板是对的……
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
typedef long long int ll;
const int MAXN = 300095;
struct edge
{
int x, y, a, b;
} e[MAXN];
bool cmp(edge a, edge b)
{
return a.a < b.a;
}
int Q[MAXN]; //Splay用栈
int ch[MAXN][2]; //树节点
int fa[MAXN]; //节点的父亲
int mx[MAXN]; //最大值
int mxid[MAXN]; //最大值所在的编号
int A[MAXN]; //每一个节点的值
int rev[MAXN]; //翻转标记，维护Splay用
//判断是否是某个Splay的根节点，旋转用
bool isroot(int rt)
{
return ch[fa[rt]][0] != rt && ch[fa[rt]][1] != rt;
}
bool get(int x) { return ch[fa[x]][1] == x; }
//上传函数，维护节点信息
void pushup(int rt)
{
int l = ch[rt][0];
int r = ch[rt][1];
//维护最大值，和最大值所在的边的序号（因为把边变为点，所以点的序号就是边的序号）
if (A[rt] > mx[l] && A[rt] > mx[r])
mx[rt] = A[rt], mxid[rt] = rt;
else if (mx[l] > mx[r])
mx[rt] = mx[l], mxid[rt] = mxid[l];
else
mx[rt] = mx[r], mxid[rt] = mxid[r];
}
//下推函数
void pushdown(int x)
{
if (rev[x])
{
rev[ch[x][0]] ^= 1;
rev[ch[x][1]] ^= 1;
rev[x] ^= 1;
swap(ch[x][0], ch[x][1]);
}
}
//Splay旋转函数，通常无需修改
void Rotate(int x)
{
int old = fa[x], oldf = fa[old], op = get(x);
if (!isroot(old))
ch[oldf][ch[oldf][1] == old] = x; //这一条一定要放在改变父子关系之前！在纯Splay中是放在后面的，因为直接看oldf是否为0可知old是否为根。
ch[old][op] = ch[x][op ^ 1];
fa[ch[x][op ^ 1]] = old; //但这里使用isroot，改变之后就不能判断了！
ch[x][op ^ 1] = old;
fa[old] = x;
fa[x] = oldf;
pushup(old);
pushup(x);
}
//Splay函数，将rt变为某棵Splay树的根节点，通常无需修改
void Splay(int x)
{
int tp = 1;
Q[1] = x;
for (int i = x; !isroot(i); i = fa[i])
Q[++tp] = fa[i]; //对于LCT的判断是否是根节点，需要使用isroot，在纯Splay中使用的是fa，不要搞混！
for (int i = tp; i; i--)
pushdown(Q[i]);
for (int FA; !isroot(x); Rotate(x))
{
FA = fa[x];
if (!isroot(FA))
Rotate(get(x) == get(FA) ? FA : x);
}
}
//打通x到整个LCT的根的路径，即fa和ch都是正确的
void Access(int x)
{
int t = 0;
while (x)
{
Splay(x);
ch[x][1] = t;
pushup(x);
t = x;
x = fa[x];
}
}
//把x变为整个LCT的根，先打通路径，然后把他变为他的Splay的根即可。
void Makeroot(int x)
{
Access(x);
Splay(x);
rev[x] ^= 1;
}
//链接函数，先把x变为整个LCT的根（这时x才没有父亲，所以不能用Splay），然后再设置一个父亲即可
void Link(int x, int y)
{
Makeroot(x);
fa[x] = y;
}
//剪断函数，根据Splay原理，可以把x变为y的左节点，然后删除即可
void Cut(int x, int y)
{
Makeroot(x);
Access(y);
Splay(y);
if (ch[y][0] == x)
fa[x] = ch[y][0] = 0;
}
//分割函数，即把x到y这条路径变为一颗Splay树，从而把区间查询变为树上节点查询（Splay原理）
void split(int x, int y)
{
Makeroot(y);
Access(x);
Splay(x);
}
int find_root(int x)
{
int now = x;
while (ch[now][0])
now = ch[now][0];
return now;
}
//查询x到y之间是否已经有路径，直接查询所在的LCT的根是否相等即可
int isconnected(int x, int y)
{
int rx, ry;
Access(x);
Splay(x);
rx = find_root(x);
Access(y);
Splay(y);
ry = find_root(y);
return rx == ry;
}
void query(int x, int y, int &b, int &id)
{
split(x, y);
b = mx[x];
id = mxid[x];
}
int main()
{
int N, M;
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++)
scanf("%d%d%d%d", &e[i].x, &e[i].y, &e[i].a, &e[i].b);
int ans = 0x3f3f3f3f;
sort(e + 1, e + M + 1, cmp);
for (int i = 1; i <= N + M; i++)//把边拆成点
{
mx[i] = A[i] = 0;
mxid[i] = i;
if (i > N)
mx[i] = A[i] = e[i - N].b;
}
for (int i = 1; i <= M; i++)
{
int b, id;
int x = e[i].x;
int y = e[i].y;
if (isconnected(x, y))
{
query(x, y, b, id);
if (b > e[i].b)
{
Cut(id, e[id - N].x);//相当于把边删除
Cut(id, e[id - N].y);
Link(N + i, x);//相当于加边
Link(N + i, y);
}
}
else
{
Link(N + i, x);
Link(N + i, y);
}
if (isconnected(1, N))
{
query(1, N, b, id);
ans = min(ans, e[i].a + b);
}
//剪枝
if (e[i].a > ans)
break;
}
if (ans == 0x3f3f3f3f)
printf("-1");
else
printf("%d\n", ans);
return 0;
}