集训day15 t1 poj3728

【问题描述】

有一颗n个节点的树

每个节点上都有许多奸商在卖东西，第i个奸商的理想价格为vi，即他会以vi的价格购买或卖出一件东西

有m个人希望从树上的某个点走到另一个点，问你在只进行一次买卖（每次仅限一个商品）的情况下，每个人最多能赚多少钱

【输入】

输入第一行是一个整数 n，表示树上的点数。

接下来n个正整数，表示每个奸商的理想价格。

接下来n-1行，每行两个整数x，y，表示第x点和第y点有一条边。

接下来一个整数m，表示下来有m个询问。

接下来有m行，每行两个整数x和y，表示某个人要从第x点出发到第y点。

【输出】

输出包括m行。

每行对应一个询问，一个整数，表示此人最多能赚到多少钱。

【输入输出样例1】

10 3 4 1 2 7 6 1 5 3 9 1 2 1 9 3 1 9 7 5 9 6 9 8 7 4 7 10 7 3 5 6 8 10 2 4

3 8 1

【数据范围】

对于前40%数据 n<=1000， m<=1000

对于100%数据 n<=250000 ，m<=10000

t1
离线lca+dp思想

先说一说题外话，我后来看我自己的代码时，我看了差不多半天，也没有看懂。

最后总算是理解了代码的思想。

我们假设一个中间节点z
一件商品，假设u和v的lca是z
那么对于一次买卖，有三种情况：
一件商品，我们在u,f之间买卖了，在u,f之间买了，在f,v之间卖了，在f,v之间买卖了
接着我们想，对于三种情况，基于贪心的思想，必然是这样几种情况：
1.在u,f间价格最小的地方买入，在u,f间价格最大的地方卖出，
2.在u,f间价格最小的地方买入，在f,v间价格最大的地方卖出
3.在f,v间价格最小的地方买入，在f,v间价格最大的地方卖出
也就是说，我们要维护4个量：
u,f间的最大和最小值，f,v间的最大和最小值
从u到f 我们称为up， 从f到v我们称为down，而从u到f买然后在f到v卖就是求u到f的最小值和f到v的最大值

先求出u，v的最近公共祖先f
再求出u到f再到v的最大利润值maxval
这个maxval有三种情况
1.可能是u到f的利润最大值
2.可能是f到v的利润最大值
3.可能是f到v的最大w[i] - u到f的最小w[i]
这样就是说，我们需要4个变量才能得到最终的利润最大值
up[u]表示u到f的利润最大值
down[v]表示f到v的利润最大值
maxw[u]表示u到f的最大w[i]
minw[u]表示u到f的最小w[i]

首先，我们可以知道的是，原来我们暴力写肯定就是先求出LCA，然后再从u和v到lca更新重新更新

所以我们的优化思路是在求LCA的同时对4个值进行更新

那么我接下来就要解决这个问题了，我们显然可以用到一些DP的思想，

我们上面已经开了4个数组

up[u]表示u到f的利润最大值
down[v]表示f到v的利润最大值
maxw[u]表示u到f的最大w[i]
minw[u]表示u到f的最小w[i]

然后我们在利用并查集路径压缩的同时更新这些值，现在我们要解决的是，如何能按照求lca的次序，同时回答询问

这就是说我们要给询问排一个序号，按照求lca得顺序完成询问，然后通过序号，把答案确定在答案数组的正确位置。

对于每个点， 我们进行dfs的时候，查看与其相关的询问，

假设当前点是u， 询问的点是v， u和v的LCA是f，如果v已经dfs过了，说明v在并查集中的祖先就是u,v的LCA  f点，

将该询问加入到f的相关集合中，等f所有的子节点都处理过后再去处理f， 就可以发现，一切都是顺其自然了

在这些处理过程中，up和down以及u,v到f的最大值最小值  都可以在并查集求压缩路径的过程中更新。

同时我们注意到，

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn = ;
 const int maxm = ;
 struct kkk {
     int net, y, id;
 }ef[maxn << ], es[maxn << ], et[maxn << ];
 int linf[maxn], lenf = ;
 int lins[maxn], lens = ;
 int lint[maxn], lent = ;
 int n, m, w[maxn];
 int fa[maxn], u[maxm], v[maxm];
 int up[maxn], down[maxn];
 int maxw[maxn], minw[maxn];
 int ans[maxn];
 int vis[maxn];

 inline int read() {
     int x = , y = ;
     char ch = getchar();
     while(!isdigit(ch)) {
         if(ch == '-') y = -;
         ch = getchar();
     }
     while(isdigit(ch)) {
         x = (x << ) + (x << ) + ch - '';
         ch = getchar();
     }
     return x * y;
 }

 inline void insert_f(int xx, int yy, int id) {
     ef[++lenf].net = linf[xx];
     ef[lenf].id = id;
     ef[lenf].y = yy;
     linf[xx] = lenf;
 }

 inline void insert_s(int xx, int yy, int id) {
     es[++lens].id = id;
     es[lens].net = lins[xx];
     es[lens].y = yy;
     lins[xx] = lens;
 }

 inline void insert_t(int xx, int yy, int id) {
     et[++lent].id = id;
     et[lent].net = lint[xx];
     et[lent].y = yy;
     lint[xx] = lent;
 }

 inline int getfather(int x) {
     if(x == fa[x]) return x;
     int f = fa[x];
     fa[x] = getfather(fa[x]);
     up[x] = max(max(up[x], up[f]), maxw[f] - minw[x]);
     down[x] = max(max(down[x], down[f]), maxw[x] - minw[f]);
     maxw[x] = max(maxw[x], maxw[f]);
     minw[x] = min(minw[x], minw[f]);
     return fa[x];
 }

 inline void LCA(int x) {//x表示的是公共祖先
     vis[x] = ;
     fa[x] = x;
     for(int i = lins[x]; i; i = es[i].net) {
         int to = es[i].y, id = es[i].id;
         if(!vis[to]) continue;
         int dad = getfather(to);
         insert_t(dad, x, id);
     }
     for(int i = linf[x]; i; i = ef[i].net) {
         int to = ef[i].y;
         if(vis[to]) continue;
         LCA(to);
         fa[to] = x;//把to的父亲标记为他的父亲
     }
     for(int i = lint[x]; i; i = et[i].net) {//在父亲节点x处理所有的关于他的子节点的询问
         int id = et[i].id;
         getfather(u[id]);
         getfather(v[id]);
         ans[id] = max(max(up[u[id]], down[v[id]]), maxw[v[id]] - minw[u[id]]);
     }
 }

 int main() {
 //    freopen("gift.in", "r", stdin);
 //    freopen("gift.out", "w", stdout);
     n = read();
     for(int i = ; i <= n; ++i) {
         w[i] = read();
         up[i] = down[i] = ;
         maxw[i] = minw[i] = w[i];
     }
     for(int i = ; i < n; ++i) {
         int x, y;
         x = read(), y = read();
         insert_f(x, y, i);
         insert_f(y, x, i);
     }
     m = read();
     for(int i = ; i <= m; ++i) {
         u[i] = read(), v[i] = read();
         insert_s(u[i], v[i], i);
         insert_s(v[i], u[i], i);
     }
     LCA();
     for(int i = ; i <= m; ++i) {
         if(ans[i] < ) cout <<  << '\n';
         else cout << ans[i] << '\n';
     }
 //    fclose(stdin);
 //    fclose(stdout);
     return ;
 }

但是此代码并不能A掉Poj原题，因为，数据范围不一样