SPOJ 375. Query on a tree （树链剖分）

Query on a tree

Time Limit: 5000ms

Memory Limit: 262144KB

 

This problem will be judged on SPOJ. Original ID: QTREE
64-bit integer IO format: %lld      Java class name: Main

Prev Submit Status Statistics Discuss Next

Font Size: + -

Type:  
None

Graph Theory

2-SAT

Articulation/Bridge/Biconnected Component

Cycles/Topological Sorting/Strongly Connected Component

Shortest Path

Bellman Ford

Dijkstra/Floyd Warshall

Euler Trail/Circuit

Heavy-Light Decomposition

Minimum Spanning Tree

Stable Marriage Problem

Trees

Directed Minimum Spanning Tree

Flow/Matching

Graph Matching

Bipartite Matching

Hopcroft–Karp Bipartite Matching

Weighted Bipartite Matching/Hungarian Algorithm

Flow

Max Flow/Min Cut

Min Cost Max Flow

DFS-like

Backtracking with Pruning/Branch and Bound

Basic Recursion

IDA* Search

Parsing/Grammar

Breadth First Search/Depth First Search

Advanced Search Techniques

Binary Search/Bisection

Ternary Search

Geometry

Basic Geometry

Computational Geometry

Convex Hull

Pick's Theorem

Game Theory

Green Hackenbush/Colon Principle/Fusion Principle

Nim

Sprague-Grundy Number

Matrix

Gaussian Elimination

Matrix Exponentiation

Data Structures

Basic Data Structures

Binary Indexed Tree

Binary Search Tree

Hashing

Orthogonal Range Search

Range Minimum Query/Lowest Common Ancestor

Segment Tree/Interval Tree

Trie Tree

Sorting

Disjoint Set

String

Aho Corasick

Knuth-Morris-Pratt

Suffix Array/Suffix Tree

Math

Basic Math

Big Integer Arithmetic

Number Theory

Chinese Remainder Theorem

Extended Euclid

Inclusion/Exclusion

Modular Arithmetic

Combinatorics

Group Theory/Burnside's lemma

Counting

Probability/Expected Value

Others

Tricky

Hardest

Unusual

Brute Force

Implementation

Constructive Algorithms

Two Pointer

Bitmask

Beginner

Discrete Logarithm/Shank's Baby-step Giant-step Algorithm

Greedy

Divide and Conquer

Dynamic Programming

Tag it!

You are given a tree (an acyclic undirected connected graph) with N nodes, and edges numbered 1, 2, 3...N-1.

We will ask you to perfrom some instructions of the following form:

• CHANGE i ti : change the cost of the i-th edge to ti
  or
• QUERY a b : ask for the maximum edge cost on the path from node a to node b

Input

The first line of input contains an integer t, the number of test cases (t <= 20). t test cases follow.

For each test case:

• In the first line there is an integer N (N <= 10000),
• In the next N-1 lines, the i-th line describes the i-th edge: a line with three integers a b c denotes an edge between a, b of cost c (c <= 1000000),
• The next lines contain instructions "CHANGE i ti" or "QUERY a b",
• The end of each test case is signified by the string "DONE".

There is one blank line between successive tests.

Output

For each "QUERY" operation, write one integer representing its result.

Example

Input:
1

3
1 2 1
2 3 2
QUERY 1 2
CHANGE 1 3
QUERY 1 2
DONE

Output:
1
3

 #include<iostream>
 #include<stdio.h>
 #include<cstdlib>
 #include<cstring>
 using namespace std;
 const int maxn = 1e4+;

 struct node
 {
     int l,r,Max;
 }f[maxn*];

 struct Edge
 {
     int to,next;
 }edge[maxn*];

 int e[maxn][];
 int p[maxn];
 int top[maxn];
 int siz[maxn];
 int son[maxn];
 int deep[maxn];
 int father[maxn];
 int head[maxn];
 int num[maxn];
 int cont,pos;

 void init()
 {
     cont = ;
     pos = ;
     memset(head,-,sizeof(head));
     memset(son,-,sizeof(son));
 }
 void add(int n1,int n2)
 {
     edge[cont].to=n2;// 指向谁
     edge[cont].next=head[n1];
     head[n1]=cont;
     cont++;
 }

 void dfs1(int u,int pre,int d)/**fa deep,num,son**/
 {
     deep[u]=d;
     father[u]=pre;
     num[u]=;
     for(int i=head[u];i!=-;i=edge[i].next)
     {
         int v = edge[i].to;
         if(v!=pre)
         {
             dfs1(v,u,d+);
             num[u]=num[u]+num[v];
             if(son[u]==- || num[v]>num[son[u]])
             son[u]=v;
         }
     }
 }

 void getops(int u,int sp)
 {
     top[u]=sp;
     if(son[u]!=-)
     {
         p[u]=++pos;
         getops(son[u],sp);
     }
     else
     {
         p[u]=++pos;
         return;
     }
     for(int i=head[u];i!=-;i=edge[i].next)
     {
         int v = edge[i].to;
         if(v!=son[u] && v!=father[u])
         getops(v,v);
     }
 }
 void build(int l,int r,int n)
 {
     f[n].l=l;
     f[n].r=r;
     f[n].Max=;
     if(l==r)return;
     int mid=(l+r)/;
     build(l,mid,n*);
     build(mid+,r,n*+);
 }
 int query(int l,int r,int n)
 {
     int mid=(f[n].l+f[n].r)/;
     int ans1,ans2;
     if(f[n].l==l && f[n].r==r) return f[n].Max;
     if(mid>=r) return query(l,r,n*);
     else if(mid<l) return query(l,r,n*+);
     else
     {
         ans1=query(l,mid,n*);
         ans2=query(mid+,r,n*+);
         if(ans1<ans2) ans1=ans2;
     }
     return ans1;
 }
 void update(int x,int num1,int n)
 {
     int mid=(f[n].l+f[n].r)/;
     if(f[n].l == x && f[n].r == x)
     {
         f[n].Max=num1;
         return;
     }
     if(mid>=x) update(x,num1,n*);
     else update(x,num1,n*+);
     f[n].Max = f[n*].Max>f[n*+].Max? f[n*].Max:f[n*+].Max;
 }
 int find(int u,int v)
 {
     int f1 = top[u],f2 = top[v];
     int MAX=;
     while(f1!=f2)
     {
        if(deep[f1]<deep[f2])
        {
            swap(f1,f2);
            swap(u,v);
        }
        MAX=max(MAX,query(p[f1],p[u],));
        u=father[f1];
        f1=top[u];
     }
     if(u==v)return MAX;
     if(deep[u]>deep[v])swap(u,v);
     return max(MAX,query(p[son[u]],p[v],));
 }
 int main()
 {
     int T,n,l,r,x,num1;
     char a[];
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d",&n);
         init();
         for(int i=;i<n;i++)
         {
             scanf("%d%d%d",&e[i][],&e[i][],&e[i][]);
             add(e[i][],e[i][]);
             add(e[i][],e[i][]);
         }
         dfs1(,,);
         getops(,);
         build(,pos,);
         for(int i=;i<n;i++)
         {
             if(deep[e[i][]]>deep[e[i][]]) swap(e[i][],e[i][]);
             update(p[e[i][]],e[i][],);
         }
         while(scanf("%s",a)>)
         {
             if(a[]=='D')break;
             if(a[]=='Q')
             {
                 scanf("%d%d",&l,&r);
                 printf("%d\n",find(l,r));
             }
             else if(a[]=='C')
             {
                 scanf("%d%d",&x,&num1);
                 update(p[e[x][]],num1,);
             }
         }
     }
     return ;
 }