[SCOI2013]摩托车交易 kruskal重构树(最大生成树) 倍增

～～～题面～～～

题解：

　　这题想法简单，，，写起来真的是失智，找了几个小时的错误结果是inf没开到LL范围。。。。

　　首先我们需要找到任意两点之间能够携带黄金的上限值，因为是在经过的道路权值中取min，我们要使得这个min值最大，就应该要在最大生成树上寻找正确的边。求出最大生成树后我们需要在上面倍增寻找权值最小的边，这条边的权值即为携带黄金的上限值。

　　于是你可以写最大生成树也可以写kruskal重构树，这里我写的是kruskal重构树，这样以来，因为kruskal重构树的性质，我们只需要寻找对应2个节点的lca，这个lca的点权即为我们要找的值。

　　但是注意到题中有一些点可以被列车连通，因为在这些被联通的点之间移动不会带来任何限制，因此我们可以把这些有列车的节点看做一个点（缩点）

　　然后注意到题目要求的仅仅是每个卖黄金的地方卖出的黄金数，而且在任意地方买卖的黄金并没有任何其他限制（如价格之类的），因此我们可以每到一个地方就买光所有黄金，然后如果带不到下一个地方去，我们就当我们之前没买过，对道路的上限取min即可。如果最后黄金有剩余，我们也可以直接当做我们没买过。

　　于是这题就做完了。

 #include<bits/stdc++.h>
 using namespace std;
 #define R register int
 #define AC 501000
 #define ac 1001000
 #define LL long long
 #define inf 1000000000000000LL//!!!!!!!!!!!!!!!!!!!!!
 /*因为只需要关心卖出了多少，所以遇到买入的就能买就买，如果要丢弃就当我没买过，
 如果有剩余也当我没买过，然后有列车的点可以相互到达，所以就缩点缩起来，然后有路上有负载上限，
 所以就跑最大生成树(重构树)，然后倍增查最大上限是多少，把剩余黄金对上限取min即可。*/

 int n, m, q, cnt, who;
 LL have;
 int Head[ac], date[ac], Next[ac], tot;
 int father[AC], vis[AC], belong[AC], dep[ac];
 LL f[ac][], power[ac];//点权or边权(叶节点就是点权，不然就是边权)

 struct road{
     int x, y;LL dis;
 }way[ac];

 inline bool cmp(road a, road b){
     return a.dis > b.dis;
 }

 inline int read()
 {
     int x = ;char c = getchar(); bool z = false;
     while(c > '' || c < '') {
         if(c == '-') z = true;
         c = getchar();
     }
     while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
     if(!z) return x;
     else return -x;
 }

 inline int find(int x){
     if(father[x] == x) return x;
     else return father[x] = find(father[x]);
 }

 inline void add(int f, int w){
     date[++tot] = w, Next[tot] = Head[f], Head[f] = tot, father[w] = f;
     //printf("%d ---> %d : %d\n", f, w, power[cnt]);
 }

 inline void upmin(LL &a, LL b){
     if(b < a) a = b;
 }

 void kruskal()//重构树
 {
     int b =  * n;
     for(R i = ; i <= b; i ++) father[i] = i;
     for(R i = ; i <= m; i ++)
     {
         int fx, fy;
         fx = find(belong[way[i].x]), fy = find(belong[way[i].y]);
         if(fx == fy) continue;
         power[++cnt] = way[i].dis;
         //printf("%d %d %d\n", way[i].x, way[i].y, way[i].dis);
         add(cnt, fx), add(cnt, fy);
     }
     power[cnt + ] = inf, dep[cnt] = , f[cnt][] = cnt;
 }

 void dfs(int x)//倍增
 {
     int now;
 //    printf("!!!%d\n", power[x]);
     for(R i = ; i <= ; i ++)
         f[x][i] = f[f[x][i - ]][i - ];
     for(R i = Head[x]; i; i = Next[i])
         now = date[i], f[now][] = x, dep[now] = dep[x] + , dfs(now);
 }

 int lca(int x, int y)//要先倍增找到最小上限
 {
     if(dep[x] < dep[y]) swap(x, y);
     for(R i = ; i >= ; i --)
         if(dep[f[x][i]] >= dep[y]) x = f[x][i];
     for(R i = ; i >= ; i --)
         if(f[x][i] != f[y][i])
             x = f[x][i], y = f[y][i];
     if(x != y) return power[f[x][]];
     else return power[x];
 }

 void go(int f, int w)
 {
     LL lim = (belong[f] == belong[w]) ? inf : lca(belong[f], belong[w]);
     /*if(find(belong[f]) != find(belong[w]))
     {
         for(R i = w; i <= n; i ++) printf("0\n");
         exit(0);
     }*/
     upmin(have, lim);
     if(power[w] > ) have += power[w];
     else
     {
         if(have > - power[w])
             have += power[w], printf("%lld\n", -power[w]);
         else printf("%lld\n", have), have = ;
     }
 }

 void pre()
 {
     n = cnt = read(), m = read(), q = read();
     for(R i = ; i <= n; i ++) vis[i] = read(), belong[i] = i;//读入每个城市的访问顺序
     for(R i = ; i <= n; i ++) power[i] = read();//读入每个城市的订单
     for(R i = ; i <= m; i ++)//读入边
         way[i].x = read(), way[i].y = read(), way[i].dis = read();
     for(R i = ; i <= q; i ++)//读入有列车的城市
     {
         int a = read();
         if(!who) who = a;
         belong[a] = who;
     }
     sort(way + , way + m + , cmp);
 }

 void work()
 {
     if(power[vis[]] > ) have = power[vis[]];
     else printf("0\n");
     for(R i = ; i < n; i ++) go(vis[i], vis[i + ]);
 }

 int main()
 {
 //    freopen("in.in", "r", stdin);
     pre();
     kruskal();
     dfs(cnt);
     work();
 //    fclose(stdin);
     return ;
 }