2016中国大学生程序设计竞赛 网络选拔赛 I This world need more Zhu

This world need more Zhu

Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 262    Accepted Submission(s): 49

Problem Description

As we all know, Zhu is the most powerful man. He has the infinite power to protest the world. We need more men like Zhu!

In Duoladuo, this place is like a tree. There are n vertices and n−1 edges. And the root is 1. Each vertex can reached by any other vertices. Each vertex has a people with value Ai named Zhu's believer.

Liao is a curious baby, he has m questions to ask Zhu. But now Zhu is busy, he wants you to help him answer Liao's questions.

Liao's question will be like "u v k".

That means Liao want to know the answer from following code:

ans = 0; cnt = 0;

for x in the shortest path from u to v {

cnt++;
    
    if(cnt mod k == 0) ans = max(ans,a[x]);

}

print(ans).

Please read the hints for more details.

 

Input

In the first line contains a single positive integer T, indicating number of test case.

In the second line there are two numbers n, m. n is the size of Duoladuo, m is the number of Liao's questions.

The next line contains n integers A1,A2,...An, means the value of ith vertex.

In the next n−1 line contains tow numbers u, v. It means there is an edge between vertex u and vertex v.

The next m lines will be the Liao's question:

u v k

1≤T≤10,1≤n≤100000,1≤m≤100000,1≤u,v≤n,1≤k, Ai≤1000000000.

 

Output

For each case, output Case #i: (i is the number of the test case, from 1 to T).

Then, you need to output the answer for every Liao's questions.

 

Sample Input

1
5 5
1 2 4 1 2
1 2
2 3
3 4
4 5
1 1 1
1 3 2
1 3 100
1 5 2
1 3 1

 

Sample Output

Case #1:
1
2
0
2
4

Hint

In query 1,there are only one vertex in the path,so the answer is 1.

In query 2,there are three vertices in the path.But only the vertex 2 mod 2 equals to 0.

In query 3,there are three vertices in the path.But no vertices mod 100 equal to 0.

In query 4,there are five vertices in the path.There are two vertices mod 2 equal to 0.So the answer is max(a[2],a[4]) = 2.

In query 5,there are three vertices in the path.And all the vertices mod 1 equal to 0. So the answer is a[3] = 4.

 

Author

UESTC

题意：
    给出一棵树，每次询问从u，v，k，代表如果从u到v的路径上的节点从一开始编号的话，编号为k的倍数的节点的权值最大值是多少？

　　

题解：
    分k的大小进行讨论
    1、当k大于sqrt(n)时，可以进行暴力。
        可以知道对于任意一次路径，如果可以O(1)寻找到k步之后的节点的话，不会超过sqrt（n）的节点需要统计。
        总复杂度O（sqrt（n））。
        O（1）寻找k步之后的节点，我的做法需要离线。
        u到lca（u，v）再到v的过程可以看作u到lca（u，v），v到lca（u，v）两部分。
        如果对u，v进行修正（往上跳到第一个选取的节点O（logn）或者O（1）），可以认为两部分的询问都是在一条链上进行的。
        所以在使用人工栈进行dfs的话，可以O（1）在栈中找到往上k步的节点。

    2、当k小于sqrt（n），对于每种k都可以单独处理出所有询问答案。
        用类似tarjan求lca的方法，每次对于每种k先O（n）预处理出所有点向上跳K步的父亲。
        事实上，某个节点向上k步的父亲就是在dfs序中在在其左侧最近的深度恰好比起高k的节点。

        然后进行类似tarjan的过程，只不过每次做并查集时与向上跳K步的父亲merge。
        并且在做路径压缩时顺便记录下当前路径的最大值，并且路径压缩到lca为止。
        当然，需要预先处理出所有询问u，v的lca。
        每次对于某种K，复杂度O（n）

总复杂度O（m sqrt（n）。

　　

 const int N = , SQRTN = , M = ;
 int n, m;
 int value[N];
 int depth[N], father[N], dfsList[N];
 vector<int> force[N];

 struct AdjacencyList {
     int head[N], son[N * ], nex[N * ], tot;

     inline void init(int n = N) {
         for(int i = ; i < n; ++i) head[i] = -;
         tot = ;
     }

     inline void addEdge(int u, int v) {
         son[tot] = v, nex[tot] = head[u];
         head[u] = tot++;
     }

     int que[N], len, size[N], pos[N];
     bool visit[N];
     inline void build(int n, int depth[], int fa[], int dfs[]) {
         for(int i = ; i < n; ++i) visit[i] = false, size[i] = ;
         len = , que[] = , fa[] = -, depth[] = , visit[] = true;
         for(int hed = ; hed < len; ++hed) {
             int u = que[hed];
             for(int v, tab = head[u]; tab != -; tab = nex[tab])
                 if(visit[v = son[tab]] == false) {
                     visit[v] = true, fa[v] = u, depth[v] = depth[u] + ;
                     que[len++] = v;
                 }
         }

         for(int i = len - ; i >= ; --i) {
             ++size[i];
             if(fa[i] != -) size[fa[i]] += size[i];
         }
         dfs[] = , pos[] = ;
         for(int i = ; i < len; ++i) {
             int u = que[i];
             for(int cnt = , tab = head[u], v; tab != -; tab = nex[tab])
                 if((v = son[tab]) != fa[u]) {
                     pos[v] = pos[u] + cnt + ;
                     dfs[pos[v]] = v;
                     cnt += size[v];
                 }
         }
     }
 } edge;

 struct ST {
     int fa[N][M], *depth;

     inline void init(int n, int father[], int tdepth[]) {
         depth = tdepth;
         for(int i = ; i < n; ++i) fa[i][] = father[i];
         for(int dep = ; dep < M; ++dep)
             for(int i = ; i < n; ++i)
                 if(fa[i][dep - ] != -)
                     fa[i][dep] = fa[fa[i][dep - ]][dep - ];
                 else fa[i][dep] = -;
     }

     inline int getLca(int u, int v) {
         if(depth[u] < depth[v]) swap(u, v);
         for(int dep = M - ; dep >= ; --dep)
             if(fa[u][dep] != - && depth[fa[u][dep]] >= depth[v])
                 u = fa[u][dep];
         if(u == v) return u;
         for(int dep = M - ; dep >= ; --dep)
             if(fa[u][dep] != - && fa[u][dep] != fa[v][dep])
                 u = fa[u][dep], v = fa[v][dep];
         return fa[u][];
     }

     inline int getFather(int u, int step) {
         for(int dep = M - ; dep >= ; --dep)
             if(fa[u][dep] != - && ( << dep) <= step)
                 u = fa[u][dep], step -= ( << dep);
         return u;
     }
 } st;

 struct Query {
     int u, v, k, lca, ans, id;

     inline void read() {
         scanf("%d%d%d", &u, &v, &k);
         --u, --v;
         lca = st.getLca(u, v), ans = ;
     }

     inline void upd(int x) {
         if(ans < x) ans = x;
     }

     inline void fix(int &u, int lca, int jump, int depth[]) {
         if(depth[u] - depth[lca] >= jump) {
             u = st.getFather(u, jump);
             upd(value[u]);
         } else u = lca;
     }

     inline void fix(int depth[]) {
         if((depth[u] - depth[lca] + ) % k == ) upd(value[lca]);
         fix(v, lca, (depth[u] + depth[v] - depth[lca] *  + ) % k, depth);
         fix(u, lca, k - , depth);
     }

     inline operator <(const Query &t) const  {
         return k < t.k;
     }
 } query[N];

 struct SolutionForLessThanSqrtN {
     int jump[N], cnt[N], que[N], top;
     int f[N], g[N];
     vector<int> wait[N];

     inline void init(int n, int value[], int depth[], int dfs[], int k) {
         for(int i = ; i < n; ++i) wait[i].clear();
         for(int i = ; i < n; ++i) f[i] = i, g[i] = value[i];

         top = -;
         for(int i = ; i < n; ++i) cnt[i] = -;
         for(int i = ; i < n; ++i) {
             int u = dfs[i];
             while(top >=  && depth[u] != depth[que[top - ]] + ) --top;
             que[++top] = u;
             if(depth[u] < k) jump[u] = -;
             else jump[u] = cnt[depth[u] - k];
             cnt[depth[u]] = u;
         }
     }

     inline void add(int idx) {
         wait[query[idx].lca].pub(idx);
     }

     inline int expose(int x, int lim = -, int *depth = NULL) {
         if(x == lim) return ;
         if(x == f[x]) return g[x];
         if(depth != NULL && depth[f[x]] <= depth[lim]) return g[x];
         int t = f[x];
         expose(f[x], lim, depth);
         f[x] = f[t], g[x] = max(g[x], g[t]);
         return g[x];
     }

     inline void merge(int u, int v) {
         expose(u), expose(v);
         f[f[u]] = f[v];
     }

     inline void solve(int n, int dfs[], int depth[]) {
         for(int i = n - ; i >= ; --i) {
             int u = dfs[i];
             foreach(idx, wait[u]) {
                 int i = *idx;
                 query[i].upd(expose(query[i].u, query[i].lca, depth));
                 query[i].upd(expose(query[i].v, query[i].lca, depth));
             }
             if(jump[u] != -) merge(u, jump[u]);
         }
     }
 } solver;

 inline bool cmpByIndex(const Query &a, const Query &b) {
     return a.id < b.id;
 }

 int myStack[N], top;

 inline void updata(int x, int g, int q, int depth[]) {
     while(x >= query[q].k && depth[myStack[x - query[q].k]] > depth[g]) {
         x -= query[q].k;
         query[q].upd(value[myStack[x]]);
     }
 }

 inline void solve() {
     for(int i = ; i < m; ++i) query[i].fix(depth);
     for(int i = ; i < n; ++i) force[i].clear();
     sort(query, query + m);

     int limit = floor(sqrt(n));
     for(int i = , j; i < m; i = j + )
         if(query[i].k <= limit) {
             for(j = i; j < m -  && query[j + ].k == query[i].k; ++j);
             solver.init(n, value, depth, dfsList, query[i].k);
             for(int k = i; k <= j; ++k) solver.add(k);
             solver.solve(n, dfsList, depth);
         } else force[query[i].u].pub(i), force[query[i].v].pub(i), j = i;

     top = -;
     for(int i = ; i < n; ++i) {
         int x = dfsList[i];
         while(top >=  && depth[x] != depth[myStack[top]] + ) --top;
         myStack[++top] = x;
         foreach(q, force[x])
             updata(top, query[*q].lca, *q, depth);
     }

     sort(query, query + m, cmpByIndex);
     for(int i = ; i < m; ++i) printf("%d\n", query[i].ans);
 }

 int main() {
     int testCase;
     scanf("%d", &testCase);
     for(int testIndex = ; testIndex <= testCase; ++testIndex) {
         scanf("%d%d", &n, &m);
         edge.init();
         for(int i = ; i < n; ++i) scanf("%d", &value[i]);
         for(int i = , v, u; i < n - ; ++i) {
             scanf("%d%d", &u, &v);
             --u, --v;
             edge.addEdge(u, v), edge.addEdge(v, u);
         }
         edge.build(n, depth, father, dfsList);
         st.init(n, father, depth);
         for(int i = ; i < m; ++i) query[i].id = i, query[i].read();
         printf("Case #%d:\n", testIndex);
         solve();
     }
     return ;
 }