bzoj 3669： [Noi2014]魔法森林 （LCT & kruskal）

这道题呢，

首先按照关键字a排序，然后不断地加边，用lct维护这个过程

具体实现： 先按照关键字a排序，枚举每一条边，判断两点是否已经联通（kruskal 部分）如果联通，就在两点路径间寻找最大的b， 和这条边的b值相比较，如果更大一些，就切断u，v之间的路径， 并连上这条边；

如果不联通，就让它联通（好随意啊= =

最后寻找路径之间最大的b + 当前的a，和原来的答案相比较。

剩下的用lct维护

注意联通的方式是把把边看做点, 然后连接（所以加上n）   ->link(u, i + n);  link(v, i + n);

（由于我一直不理解怎么保证当前的a一定在路径上，所以这是自己yy的证明（可能有很大的bug，勿喷）：当前的a如果不在（1，n）路径之中，但（1，n）已联通，那么最优值在之前已经被计算过，否则由于a是递增的，那么此时的a就是路径中最大的a）

下面是代码

 /**************************************************************
     Problem: 3669
     User: cminus
     Language: C++
     Result: Accepted
     Time:5104 ms
     Memory:6128 kb
 ****************************************************************/
  
 #include <cstdio>
 #include <algorithm>
 using namespace std;
 #define l(x) ch[x][0]
 #define r(x) ch[x][1]
 #define kd(x) (r(fa[x]) == x)
 #define setc(f, c, k)   (ch[fa[c] = f][k] = c)
 #define isRoot(x)   (r(fa[x]) != x && l(fa[x]) != x)
 const int N = ;
  
 struct Edge{
     int u, v, a, b;
     inline void init(){
         scanf("%d %d %d %d", &u, &v, &a, &b);
     }
     inline bool operator <(const Edge &rhs)const{
         return a < rhs.a;
     }
 }e[];
 int fa[N], ch[N][], rev[N], val[N], maxp[N], f[];
 int INF = 0x7f7f7f7f;
  
 inline void update(int x) {
     maxp[x] = x;
     if (val[maxp[x]] < val[maxp[l(x)]])  maxp[x] = maxp[l(x)];
     if (val[maxp[x]] < val[maxp[r(x)]])  maxp[x] = maxp[r(x)];
 }
  
 inline void push(int x) {
     if (rev[x] and x){
         rev[x] = ;
         if (l(x))   rev[l(x)] ^= , swap(l(l(x)), r(l(x)));
         if (r(x))   rev[r(x)] ^= , swap(l(r(x)), r(r(x)));
     }
 }
  
 inline void pushDown(int x) {
     if (! isRoot(x))    pushDown(fa[x]);
     push(x);
 }
  
 inline void rotate(int x) {
     int y = fa[x], t = kd(x);
     setc(y, ch[x][t^], t);
     if (isRoot(y)) fa[x] = fa[y];
     else setc(fa[y], x, kd(y));
     setc(x, y, t^);
     update(y); update(x);
 }
  
 inline void splay(int x){
     pushDown(x);
     while(! isRoot(x)){
         if (! isRoot(fa[x]))
             if (kd(x) == kd(fa[x]))     rotate(fa[x]);
             else    rotate(x); rotate(x);
     }
 }
  
 inline void access(int x){
     int t = ;
     while(x) {
         splay(x);
         r(x) = t; update(x);
         t = x; x = fa[x];
     }
 }
  
 inline void makeRoot(int x){
     access(x); splay(x);
     rev[x] ^= ;  swap(l(x), r(x));
 }
  
 inline void link(int u, int v) {    makeRoot(u);  fa[u] = v; }
  
 inline void cut(int u, int v){
     makeRoot(u);
     access(v); splay(v);
     fa[u] = l(v) = ;
 }
  
 inline int query(int u, int v){
     makeRoot(u);
     access(v); splay(v);
     return maxp[v];
 }
  
 int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
  
 int main(){
     int n, m;
     scanf("%d %d", &n, &m);
     int ans = INF;
     for (int i = ; i <= m; i++) e[i].init();
     for (int i = ; i <= n; i++) f[i] = i;
     sort(e + , e + m + );
     for (int i = ; i <= m; i++){
         int u = e[i].u, v = e[i].v, rt1 = find(u), rt2 = find(v);
         val[i + n] = e[i].b; maxp[i + n] = i + n;
         if (rt1 == rt2){
             int p = query(u, v);
             if (val[p] > e[i].b)   cut(u, p), cut(v, p);
             else   continue;   
         }
         else f[rt1] = rt2;
         link(u, i + n); link(v, i + n);
         if (find() == find(n)) ans = min(ans, val[query(, n)] + e[i].a);
     }
     printf("%d\n", ans == INF ? - : ans);
     return ;
 }