+
+using namespace std;
+
+const int maxN = 600;
+const int inf = 1000000000;
+int g[maxN][maxN], d[maxN][maxN];
+int n;
+
+long long gcd(long long a, long long b) {
+ if (a == 0 || b == 0) {
+ return a + b;
+ }
+ if (a > b) {
+ return gcd(a % b, b);
+ } else {
+ return gcd(b % a, a);
+ }
+}
+
+int main() {
+ scanf(""%d"", &n);
+ for (int i = 0; i < n; ++i) {
+ for (int j = 0; j < n; ++j) {
+ scanf(""%d"", &g[i][j]);
+ }
+ }
+
+ for (int i = 1; i <= n; ++i) {
+ for (int j = 0; j < n; ++j) {
+ int best = inf;
+ for (int k = 0; k < n; ++k) {
+ if (j != k) {
+ best = min(best, d[i - 1][k] + g[k][j]);
+ }
+ }
+ d[i][j] = best;
+ }
+ }
+
+ long long p = inf, q = 1;
+ for (int i = 0; i < n; ++i) {
+ long long a = 0, b = 1;
+ for (int j = 0; j < n; ++j) {
+ long long c = d[n][i] - d[j][i];
+ long long d = n - j;
+
+ if (c * b > a * d) {
+ a = c;
+ b = d;
+ }
+ }
+
+ if (a * q < b * p) {
+ p = a;
+ q = b;
+ }
+ }
+
+ long long d = gcd(p, q);
+ p /= d;
+ q /= d;
+
+ cout << p << ""/"" << q << endl;
+
+ return 0;
+}
+```
+",not-set,2016-04-24T02:02:15,2016-07-23T14:03:54,C++
+21,1667,matrix-tracing,Matrix Tracing,"A word from the English dictionary is taken and arranged as a matrix. e.g. ""MATHEMATICS""
+
+MATHE
+ATHEM
+THEMA
+HEMAT
+EMATI
+MATIC
+ATICS
+
+There are many ways to trace this matrix in a way that helps you construct this word. You start tracing the matrix from the top-left position and at each iteration, you either move RIGHT or DOWN, and ultimately reach the bottom-right of the matrix. It is assured that any such tracing generates the same word. How many such tracings can be possible for a given
+word of length m+n-1 written as a matrix of size m * n?
+
+**Input Format**
+The first line of input contains an integer T. T test cases follow.
+Each test case contains 2 space separated integers m & n (in a new line) indicating that the matrix has m rows and each row has n characters.
+
+**Constraints**
+1 <= T <= 103
+1 ≤ m,n ≤ 106
+
+**Output Format**
+Print the number of ways (S) the word can be traced as explained in the problem statement.
+If the number is larger than 109 +7,
+print `S mod (10^9 + 7)` for each testcase (in a new line).
+
+**Sample Input**
+
+ 1
+ 2 3
+
+**Sample Output**
+
+ 3
+
+**Explanation**
+Let's consider a word AWAY written as the matrix
+
+ AWA
+ WAY
+
+Here, the word AWAY can be traced in 3 different ways, traversing either RIGHT or DOWN.
+
+ AWA
+ Y
+
+ AW
+ AY
+
+ A
+ WAY
+
+Hence the answer is 3.
+
+**Timelimit**
+Time limit for this challenge is given [here](https://www.hackerrank.com/environment)",code,How many ways can you trace a given matrix? - 30 Points,ai,2014-01-14T08:25:46,2022-09-02T09:54:13,"#
+# Complete the 'solve' function below.
+#
+# The function is expected to return an INTEGER.
+# The function accepts following parameters:
+# 1. INTEGER n
+# 2. INTEGER m
+#
+
+def solve(n, m):
+ # Write your code here
+
+","#!/bin/python3
+
+import math
+import os
+import random
+import re
+import sys
+
+","if __name__ == '__main__':
+ fptr = open(os.environ['OUTPUT_PATH'], 'w')
+
+ t = int(input().strip())
+
+ for t_itr in range(t):
+ first_multiple_input = input().rstrip().split()
+
+ n = int(first_multiple_input[0])
+
+ m = int(first_multiple_input[1])
+
+ result = solve(n, m)
+
+ fptr.write(str(result) + '\n')
+
+ fptr.close()
+","A word from the English dictionary is taken and arranged as a matrix. e.g. ""MATHEMATICS""
+
+ MATHE
+ ATHEM
+ THEMA
+ HEMAT
+ EMATI
+ MATIC
+ ATICS
+
+There are many ways to trace this matrix in a way that helps you construct this word. You start tracing the matrix from the top-left position and at each iteration, you either move RIGHT or DOWN, and ultimately reach the bottom-right of the matrix. It is assured that any such tracing generates the same word. How many such tracings can be possible for a given
+word of length m+n-1 written as a matrix of size m * n?
+
+**Input Format**
+The first line of input contains an integer T. T test cases follow.
+Each test case contains 2 space separated integers m & n (in a new line) indicating that the matrix has m rows and each row has n characters.
+
+**Constraints**
+1 <= T <= 103
+1 ≤ m,n ≤ 106
+
+**Output Format**
+Print the number of ways (S) the word can be traced as explained in the problem statement.
+If the number is larger than 109 +7,
+print `S mod (10^9 + 7)` for each testcase (in a new line).
+
+**Sample Input**
+
+ 1
+ 2 3
+
+**Sample Output**
+
+ 3
+
+**Explanation**
+Let's consider a word AWAY written as the matrix
+
+ AWA
+ WAY
+
+Here, the word AWAY can be traced in 3 different ways, traversing either RIGHT or DOWN.
+
+ AWA
+ Y
+
+ AW
+ AY
+
+ A
+ WAY
+
+Hence the answer is 3.
+
+**Timelimit**
+Time limit for this challenge is given [here](https://www.hackerrank.com/environment)",0.5637583892617449,"[""c"",""clojure"",""cpp"",""cpp14"",""cpp20"",""csharp"",""erlang"",""go"",""haskell"",""java"",""java8"",""java15"",""javascript"",""julia"",""kotlin"",""lua"",""objectivec"",""perl"",""php"",""pypy3"",""python3"",""ruby"",""rust"",""scala"",""swift"",""typescript"",""r""]", , , , ,Hard,Matrix Tracing : Codesprint 5 Editorial ,"Matrix Tracing
+
+Difficulty Level : Easy-Medium Required Knowledge : Combinatorics, Counting, Inverse modulo operation Problem Setter : Dheeraj Problem Tester : Abhiranjan
+
+Approach
+
+Firstly we note that we are given a grid, and only possible ways to reach from top left to bottom right is a DOWN move and RIGHT move.
+
+So from m+n-2 total moves we choose m-1 down moves. Hence total ways comes out to be m+n-2 Cm-1 .
+
+Another way to look at is m+n-2 total moves where m-1 are of one type and n-1 are of another type
+
+Hence total number of move is: (m+n-2)!/(m-1)!(n-1)!
+
+As we have to print ans mod 109 +7, answer should go as
+
+moves = (m+n-2)! / (m-1)! (n-1)! % (10^9+7)
+ = (m+n-2)! * (m-1)!^(-1) * (n-1)!^(-1) % (10^9+7)
+For this we need to separately calculate Numerator and Denominator using modular and inverse modular operation.
+
+Factorial
+
+(a*b) mod m = ((a mod m)*(b mod m)) mod m
+to calculate factorial as
+
+fact(0) = 1
+fact(n) = fact(n-1)*n % (10^9+7)
+Inverse
+
+a^(p-1) == 1 mod p
+
+where p is prime
+ gcd(a, p) != 1
+Multiplying both sides by a^(-1), we get
+
+a^(p-1) * a^(-1) == a^(-1) mod p
+a^(p-2) == a^(-1) mod p
+a^(-1) == a^(p-2) mod p
+Larger Powers
+
+ 1 , m == 0
+a^m = (b*b) % p , even m
+ (b*b*a) % p , odd m
+
+where
+ b = a^floor(m/2)
+In this way we can calculate a^m in log(m) steps.
+
+Final Solution
+
+So, we can rewrite our above equation as
+
+ moves = (m+n-2)! * (m-1)!^(-1) * (n-1)!^(-1) % (10^9+7)
+ = (m+n-2)! * (m-1)!^(p-2) * (n-1)!^(p-2) % (10^9+7)
+Setter's Solution
+
+#!/usr/bin/py
+mod = 10**9 + 7
+
+def getfactmod(b):
+ val = 1
+ for i in range(1,b):
+ val =((val%mod)*((i+1)%mod))%mod
+ return val
+
+def getpowermod(a,b):
+ if b==0:
+ return 1
+ if b == 1:
+ return a
+ temp = getpowermod(a,b/2)
+ if b%2==0:
+ return ((temp%mod)**2)%mod
+ else:
+ return (a*((temp%mod)**2))%mod
+
+def inversemod(a):
+ return getpowermod(a,mod-2)
+
+if __name__ == '__main__':
+ t = input()
+ assert 1 <= t <= 10**3
+ for _ in range(t):
+ a,b = map(int, raw_input().strip().split(' '))
+ assert 1 <= a <= 10**6
+ assert 1 <= b <= 10**6
+ denominator = 1
+ numerator = 1
+ for i in range(1, a+b-1):
+ numerator = ((numerator%mod)*(i%mod))%mod
+ for i in range(1, a):
+ denominator = ((denominator%mod)*(i%mod))%mod
+ for i in range(1, b):
+ denominator = ((denominator%mod)*(i%mod))%mod
+ answer = ((numerator%mod)*(inversemod(denominator)%mod))%mod
+ print answer
+Tester's Solution
+
+#include <bits/stdc++.h>
+using namespace std;
+
+const int sz = 2e6;
+const long long mod = 1e9+7;
+
+long long fact[sz];
+
+long long _pow(int a, int b) {
+ if(b == 0)
+ return 1ll;
+ long long ret = _pow(a, b/2);
+ ret = (ret*ret) % mod;
+ ret = (ret+mod)% mod;
+ if(b%2 == 1)
+ ret = (ret*a) % mod;
+ ret = (ret+mod)% mod;
+ assert(ret >= 0);
+ assert(ret < mod);
+ return ret;
+}
+
+long long inv(int a) {
+ a%= mod;
+ a = (a+mod)%mod;
+ return _pow(a, mod-2);
+}
+
+int main()
+{
+ fact[0] = 1;
+ for(int i = (int)1; i <= (int)sz-1; ++i) {
+ fact[i] = (fact[i-1]*i) % mod;
+ }
+ int test;
+ scanf(""%d"", &test);
+ assert(test >= 1);
+ assert(test <= 1e3);
+ while(test--) {
+ int n, m;
+ cin >> n >> m;
+ assert(1 <= n); assert(n <= 1e6);
+ assert(1 <= m); assert(m <= 1e6);
+ n--; m--;
+ long long ans = fact[n+m];
+ ans = (ans*inv(fact[n])) % mod;
+ ans = (ans + mod) % mod;
+ ans = (ans*inv(fact[m])) % mod;
+ ans = (ans + mod) % mod;
+ assert(ans >= 0);
+ assert( ans < mod);
+ cout << ans << ""\n"";
+ }
+
+ return 0;
+}
+3
+1 ≤ m,n ≤ 106
+
+**Output Format**
+Print the number of ways (S) the word can be traced as explained in the problem statement.
+If the number is larger than 109 +7,
+print `S mod (10^9 + 7)` for each testcase (in a new line).
+
+**Sample Input**
+
+ 1
+ 2 3
+
+**Sample Output**
+
+ 3
+
+**Explanation**
+Let's consider a word AWAY written as the matrix
+
+ AWA
+ WAY
+
+Here, the word AWAY can be traced in 3 different ways, traversing either RIGHT or DOWN.
+
+ AWA
+ Y
+
+ AW
+ AY
+
+ A
+ WAY
+
+Hence the answer is 3.
+
+**Timelimit**
+Time limit for this challenge is given [here](https://www.hackerrank.com/environment)",code,How many ways can you trace a given matrix? - 30 Points,ai,2014-01-14T08:25:46,2022-09-02T09:54:13,"#
+# Complete the 'solve' function below.
+#
+# The function is expected to return an INTEGER.
+# The function accepts following parameters:
+# 1. INTEGER n
+# 2. INTEGER m
+#
+
+def solve(n, m):
+ # Write your code here
+
+","#!/bin/python3
+
+import math
+import os
+import random
+import re
+import sys
+
+","if __name__ == '__main__':
+ fptr = open(os.environ['OUTPUT_PATH'], 'w')
+
+ t = int(input().strip())
+
+ for t_itr in range(t):
+ first_multiple_input = input().rstrip().split()
+
+ n = int(first_multiple_input[0])
+
+ m = int(first_multiple_input[1])
+
+ result = solve(n, m)
+
+ fptr.write(str(result) + '\n')
+
+ fptr.close()
+","A word from the English dictionary is taken and arranged as a matrix. e.g. ""MATHEMATICS""
+
+ MATHE
+ ATHEM
+ THEMA
+ HEMAT
+ EMATI
+ MATIC
+ ATICS
+
+There are many ways to trace this matrix in a way that helps you construct this word. You start tracing the matrix from the top-left position and at each iteration, you either move RIGHT or DOWN, and ultimately reach the bottom-right of the matrix. It is assured that any such tracing generates the same word. How many such tracings can be possible for a given
+word of length m+n-1 written as a matrix of size m * n?
+
+**Input Format**
+The first line of input contains an integer T. T test cases follow.
+Each test case contains 2 space separated integers m & n (in a new line) indicating that the matrix has m rows and each row has n characters.
+
+**Constraints**
+1 <= T <= 103
+1 ≤ m,n ≤ 106
+
+**Output Format**
+Print the number of ways (S) the word can be traced as explained in the problem statement.
+If the number is larger than 109 +7,
+print `S mod (10^9 + 7)` for each testcase (in a new line).
+
+**Sample Input**
+
+ 1
+ 2 3
+
+**Sample Output**
+
+ 3
+
+**Explanation**
+Let's consider a word AWAY written as the matrix
+
+ AWA
+ WAY
+
+Here, the word AWAY can be traced in 3 different ways, traversing either RIGHT or DOWN.
+
+ AWA
+ Y
+
+ AW
+ AY
+
+ A
+ WAY
+
+Hence the answer is 3.
+
+**Timelimit**
+Time limit for this challenge is given [here](https://www.hackerrank.com/environment)",0.5637583892617449,"[""c"",""clojure"",""cpp"",""cpp14"",""cpp20"",""csharp"",""erlang"",""go"",""haskell"",""java"",""java8"",""java15"",""javascript"",""julia"",""kotlin"",""lua"",""objectivec"",""perl"",""php"",""pypy3"",""python3"",""ruby"",""rust"",""scala"",""swift"",""typescript"",""r""]", , , , ,Hard,Matrix Tracing : Codesprint 5 Editorial ,"Matrix Tracing
+
+Difficulty Level : Easy-Medium Required Knowledge : Combinatorics, Counting, Inverse modulo operation Problem Setter : Dheeraj Problem Tester : Abhiranjan
+
+Approach
+
+Firstly we note that we are given a grid, and only possible ways to reach from top left to bottom right is a DOWN move and RIGHT move.
+
+So from m+n-2 total moves we choose m-1 down moves. Hence total ways comes out to be m+n-2 Cm-1 .
+
+Another way to look at is m+n-2 total moves where m-1 are of one type and n-1 are of another type
+
+Hence total number of move is: (m+n-2)!/(m-1)!(n-1)!
+
+As we have to print ans mod 109 +7, answer should go as
+
+moves = (m+n-2)! / (m-1)! (n-1)! % (10^9+7)
+ = (m+n-2)! * (m-1)!^(-1) * (n-1)!^(-1) % (10^9+7)
+For this we need to separately calculate Numerator and Denominator using modular and inverse modular operation.
+
+Factorial
+
+(a*b) mod m = ((a mod m)*(b mod m)) mod m
+to calculate factorial as
+
+fact(0) = 1
+fact(n) = fact(n-1)*n % (10^9+7)
+Inverse
+
+a^(p-1) == 1 mod p
+
+where p is prime
+ gcd(a, p) != 1
+Multiplying both sides by a^(-1), we get
+
+a^(p-1) * a^(-1) == a^(-1) mod p
+a^(p-2) == a^(-1) mod p
+a^(-1) == a^(p-2) mod p
+Larger Powers
+
+ 1 , m == 0
+a^m = (b*b) % p , even m
+ (b*b*a) % p , odd m
+
+where
+ b = a^floor(m/2)
+In this way we can calculate a^m in log(m) steps.
+
+Final Solution
+
+So, we can rewrite our above equation as
+
+ moves = (m+n-2)! * (m-1)!^(-1) * (n-1)!^(-1) % (10^9+7)
+ = (m+n-2)! * (m-1)!^(p-2) * (n-1)!^(p-2) % (10^9+7)
+Setter's Solution
+
+#!/usr/bin/py
+mod = 10**9 + 7
+
+def getfactmod(b):
+ val = 1
+ for i in range(1,b):
+ val =((val%mod)*((i+1)%mod))%mod
+ return val
+
+def getpowermod(a,b):
+ if b==0:
+ return 1
+ if b == 1:
+ return a
+ temp = getpowermod(a,b/2)
+ if b%2==0:
+ return ((temp%mod)**2)%mod
+ else:
+ return (a*((temp%mod)**2))%mod
+
+def inversemod(a):
+ return getpowermod(a,mod-2)
+
+if __name__ == '__main__':
+ t = input()
+ assert 1 <= t <= 10**3
+ for _ in range(t):
+ a,b = map(int, raw_input().strip().split(' '))
+ assert 1 <= a <= 10**6
+ assert 1 <= b <= 10**6
+ denominator = 1
+ numerator = 1
+ for i in range(1, a+b-1):
+ numerator = ((numerator%mod)*(i%mod))%mod
+ for i in range(1, a):
+ denominator = ((denominator%mod)*(i%mod))%mod
+ for i in range(1, b):
+ denominator = ((denominator%mod)*(i%mod))%mod
+ answer = ((numerator%mod)*(inversemod(denominator)%mod))%mod
+ print answer
+Tester's Solution
+
+#include <bits/stdc++.h>
+using namespace std;
+
+const int sz = 2e6;
+const long long mod = 1e9+7;
+
+long long fact[sz];
+
+long long _pow(int a, int b) {
+ if(b == 0)
+ return 1ll;
+ long long ret = _pow(a, b/2);
+ ret = (ret*ret) % mod;
+ ret = (ret+mod)% mod;
+ if(b%2 == 1)
+ ret = (ret*a) % mod;
+ ret = (ret+mod)% mod;
+ assert(ret >= 0);
+ assert(ret < mod);
+ return ret;
+}
+
+long long inv(int a) {
+ a%= mod;
+ a = (a+mod)%mod;
+ return _pow(a, mod-2);
+}
+
+int main()
+{
+ fact[0] = 1;
+ for(int i = (int)1; i <= (int)sz-1; ++i) {
+ fact[i] = (fact[i-1]*i) % mod;
+ }
+ int test;
+ scanf(""%d"", &test);
+ assert(test >= 1);
+ assert(test <= 1e3);
+ while(test--) {
+ int n, m;
+ cin >> n >> m;
+ assert(1 <= n); assert(n <= 1e6);
+ assert(1 <= m); assert(m <= 1e6);
+ n--; m--;
+ long long ans = fact[n+m];
+ ans = (ans*inv(fact[n])) % mod;
+ ans = (ans + mod) % mod;
+ ans = (ans*inv(fact[m])) % mod;
+ ans = (ans + mod) % mod;
+ assert(ans >= 0);
+ assert( ans < mod);
+ cout << ans << ""\n"";
+ }
+
+ return 0;
+}
+
+using namespace std;
+
+const int sz = 2e6;
+const long long mod = 1e9+7;
+
+long long fact[sz];
+
+long long _pow(int a, int b) {
+ if(b == 0)
+ return 1ll;
+ long long ret = _pow(a, b/2);
+ ret = (ret*ret) % mod;
+ ret = (ret+mod)% mod;
+ if(b%2 == 1)
+ ret = (ret*a) % mod;
+ ret = (ret+mod)% mod;
+ assert(ret >= 0);
+ assert(ret < mod);
+ return ret;
+}
+
+long long inv(int a) {
+ a%= mod;
+ a = (a+mod)%mod;
+ return _pow(a, mod-2);
+}
+
+int main()
+{
+ fact[0] = 1;
+ for(int i = (int)1; i <= (int)sz-1; ++i) {
+ fact[i] = (fact[i-1]*i) % mod;
+ }
+ int test;
+ scanf(""%d"", &test);
+ assert(test >= 1);
+ assert(test <= 1e3);
+ while(test--) {
+ int n, m;
+ cin >> n >> m;
+ assert(1 <= n); assert(n <= 1e6);
+ assert(1 <= m); assert(m <= 1e6);
+ n--; m--;
+ long long ans = fact[n+m];
+ ans = (ans*inv(fact[n])) % mod;
+ ans = (ans + mod) % mod;
+ ans = (ans*inv(fact[m])) % mod;
+ ans = (ans + mod) % mod;
+ assert(ans >= 0);
+ assert( ans < mod);
+ cout << ans << ""\n"";
+ }
+
+ return 0;
+}
+
+```
+",not-set,2016-04-24T02:02:15,2016-07-23T16:33:25,C++
+23,959,recalling-early-days-gp-with-trees,Recalling Early Days GP with Trees,"[Chinese Version](https://hr-testcases.s3.amazonaws.com/959/959-chinese.md)th line describes the ith edge: a line with two integers a b separated by a single space denotes an edge between a, b.
+The next line contains 2 space separated integers (U and Q respectively) representing the number of Update and Query operations to follow.
+U lines follow. Each of the next U lines contains 3 space separated integers (i,j, and X respectively).
+Each of the next Q lines contains 2 space separated integers, i and j respectively.
+
+**Output Format**
+It contains exactly Q lines and each line containing the answer of the ith query.
+
+**Constraints**
+
+2 <= N <= 100000
+2 <= R <= 109
+1 <= U <= 100000
+1 <= Q <= 100000
+1 <= X <= 10
+1 <= a, b, i, j <= N
+
+**Sample Input**
+
+ 6 2
+ 1 2
+ 1 4
+ 2 6
+ 4 5
+ 4 3
+ 2 2
+ 1 6 3
+ 5 3 5
+ 6 4
+ 5 1
+
+**Sample Output**
+
+ 31
+ 18
+
+**Explanation**
+
+The node values after the first updation becomes :
+
+ 3 6 0 0 0 12
+
+The node values after second updation becomes :
+
+ 3 6 20 10 5 12
+
+Answer to Query #1: 12 + 6 + 3 + 10 = 31
+Answer to Query #2: 5 + 10 +3 = 18 ",code,Answer the queries performed on trees.,ai,2013-09-25T18:56:57,2022-08-31T08:33:17,,,,"[Chinese Version](https://hr-testcases.s3.amazonaws.com/959/959-chinese.md)th line describes the ith edge: a line with two integers a b separated by a single space denotes an edge between a, b.
+The next line contains 2 space separated integers (U and Q respectively) representing the number of Update and Query operations to follow.
+U lines follow. Each of the next U lines contains 3 space separated integers (i,j, and X respectively).
+Each of the next Q lines contains 2 space separated integers, i and j respectively.
+
+**Output Format**
+It contains exactly Q lines and each line containing the answer of the ith query.
+
+**Constraints**
+
+2 <= N <= 100000
+2 <= R <= 109
+1 <= U <= 100000
+1 <= Q <= 100000
+1 <= X <= 10
+1 <= a, b, i, j <= N
+
+**Sample Input**
+
+ 6 2
+ 1 2
+ 1 4
+ 2 6
+ 4 5
+ 4 3
+ 2 2
+ 1 6 3
+ 5 3 5
+ 6 4
+ 5 1
+
+**Sample Output**
+
+ 31
+ 18
+
+**Explanation**
+
+The node values after the first updation becomes :
+
+ 3 6 0 0 0 12
+
+The node values after second updation becomes :
+
+ 3 6 20 10 5 12
+
+Answer to Query #1: 12 + 6 + 3 + 10 = 31
+Answer to Query #2: 5 + 10 +3 = 18 ",0.4090909090909091,"[""ada"",""bash"",""c"",""clojure"",""coffeescript"",""cpp"",""cpp14"",""cpp20"",""csharp"",""d"",""elixir"",""erlang"",""fortran"",""fsharp"",""go"",""groovy"",""haskell"",""java"",""java8"",""java15"",""javascript"",""julia"",""kotlin"",""lolcode"",""lua"",""objectivec"",""ocaml"",""octave"",""pascal"",""perl"",""php"",""pypy3"",""python3"",""r"",""racket"",""ruby"",""rust"",""sbcl"",""scala"",""smalltalk"",""swift"",""tcl"",""typescript"",""visualbasic"",""whitespace""]",,,,,Hard,Recalling Early Days with GP Trees : 101 Hack January Editorial,"Recalling Early Days with GP Trees
+
+Difficulty Level : Medium-Hard Problem Setter : Devendra Agarwal Problem Tester : Wanbo
+
+Approach
+
+Observations
+
+
+The Number 100711433 is a prime number , so that we can find its inverse (except when R is not a multiple of 100711433)
You need to first tackle all the Updates and then all the Queries.
+
+Choose any node as root of the tree.
+
+Make 2 arrays Dist_DFSL[] and Dist_DFSR[] for the Tree.
+
+Update Method
+
+i j St
+
+Let anc be the ancestor node of node i and node j.
+
+Add value St in Dist_DFSL[i]
+
+Add -St*power(R,d1+1) in Dist_DFSL[Parent[anc]] where d1 denotes the total number of edges between node i and node anc and power(a,b) denotes a^b mod 100711433
+
+Add -St*power(R,d1) in Dist_DFSR[anc] where d1 denotes the total number of edges between node i and node anc and power(a,b) denotes a^b mod 100711433
+
+Add St*power(R,d1+d2) in Dist_DFSR[j] where d2 represent the total edges in path from ancestor to j.
+
+d1 and d2 can be calculated by precalculating the depth of each node from root.
+
+d1=depth[i]-depth[anc]
+
+d2=depth[j]-depth[anc]
+
+After all Update Queries, we need the final values at each node and to do so ,we run a DFS on the Tree and do the following:
+
+Dist_DFSL[parent]=(Dist_DFSL[parent]+Dist_DFSL[child]*R)%mod
+
+Dist_DFSR[parent]=(Dist_DFSR[parent]+Dist_DFSR[child]*R_inverse)%mod
+
+Note :: R_Inverse * R = 1 mod (100711433)
+
+Now value at each Node is :
+
+Sum[Node]=Dist_DFSL[Node]+ Dist_DFSR[NOde]
+
+Now, Run a BFS(or DFS) on the graph and store the sum to each Node from the root in Sum[] array.
+
+Answering the Query
+
+i j
+
+Answer= Sum[i] + Sum[j] - Sum[anc] - Sum[Parent[anc]]
+
+NOTE :Precaution in Calculating R_inv and solving the problem when R is multiple of 100711433
+
+Time Complexity: O( (U+Q) log N) //computing lca part otherwise everything in O(1) time.
+
+Setter's Solution
+
+//Author : Devendra Agarwal
+#include<stdio.h>
+#include<algorithm>
+#include<iostream>
+#include<vector>
+#include<string.h>
+using namespace std;
+
+#define MaxN 100001 //Maximum Nodes
+
+typedef long long int ll;
+
+int N,R,level[MaxN],Parent[MaxN],Dist_DFSL[MaxN],Dist_DFSR[MaxN],Root[MaxN][17],Store_Power_R[MaxN],store[MaxN],mod=100711433,R_inv,Sum[MaxN],Queue[MaxN];
+
+vector<int> Graph[MaxN]; //to store graph
+
+
+/* To calculate the inverse of a number in multiplicative modulo b*/
+int inverse(int a,int b) //b>a
+{
+ int Remainder,p0=0,p1=1,pcurr=1,q,m=b;
+ while(a!=0)
+ {
+ Remainder=b%a;
+ q=b/a;
+ if(Remainder!=0)
+ {
+ pcurr=p0-((ll)p1*(ll)q)%m;
+ if(pcurr<0)
+ pcurr+=m;
+ p0=p1;
+ p1=pcurr;
+ }
+ b=a;
+ a=Remainder;
+ }
+ return pcurr;
+}
+
+/*Storing the Parent and height using DFS*/
+void DFS(int root)
+{
+ for(vector<int> ::iterator it=Graph[root].begin();it!=Graph[root].end();it++){
+ if((*it)!=Parent[root]){ //not visiting more than once
+ level[(*it)]=level[root]+1;
+ Parent[(*it)]=root;
+ DFS((*it));
+ }
+ }
+ return;
+}
+/*Calculating Data necessary for calculating ancestor and some pre-processing for quicker implementation*/
+void process()
+{
+ memset(Root,-1,sizeof(Root));
+ for(int i=1;i<=N;i++) Root[i][0]=Parent[i];
+ for(int i=1;(1<<i) <= N; i++)
+ for(int j=1;j<=N;j++)
+ if(Root[j][i-1]!=-1)
+ Root[j][i]=Root[Root[j][i-1]][i-1];
+
+ store[0]=0;
+ store[1]=0;
+ int cmp=2;
+ for(int i=2;i<=N;i++){
+ if(cmp>i) store[i]=store[i-1];
+ else{
+ store[i]=store[i-1]+1;
+ cmp<<=1;
+ }
+ }
+ Store_Power_R[0]=1;
+ for(int i=1;i<=N;i++)
+ Store_Power_R[i]=((ll)Store_Power_R[i-1]*(ll)R)%mod;
+}
+/*Returns the lca of two nodes, same implementation as was used in topcoder tutorials*/
+int lca(int p,int q) //Fnds the LCA of 2 nodes
+{
+ int temp;
+
+ if(level[p]>level[q]){
+ temp=p;p=q;q=temp;
+ }
+
+ //level[q]>=level[p]
+ int steps=store[level[q]];
+ for(int i=steps;i>=0;i--)
+ if(level[q]-(1<<i) >= level[p])
+ q=Root[q][i];
+
+ if(p==q) return p;
+ for(int i=steps;i>=0;i--)
+ if(Root[p][i]!=Root[q][i])
+ p=Root[p][i],q=Root[q][i];
+ return Parent[p];
+}
+/*This Find the Dist_DFSL and Dist_DFSR after all update queries*/
+void DFS_new(int root)
+{
+ for(vector<int> ::iterator it=Graph[root].begin();it!=Graph[root].end();it++){
+ if((*it)!=Parent[root]){ //not visiting more than once
+ DFS_new((*it));
+ Dist_DFSL[root]=(Dist_DFSL[root]+((ll)Dist_DFSL[*it]*(ll)R)%mod)%mod; //Updating root from children
+ Dist_DFSR[root]=(Dist_DFSR[root]+((ll)Dist_DFSR[*it]*(ll)R_inv)%mod)%mod; //Updating root from children
+ }
+ }
+}
+/*This find the Sum[] array*/
+void BFS(int root)
+{
+ Queue[0]=root;
+ int st=0,end=1,node;
+ while(st<end){
+ node=Queue[st];
+ st++;
+ for(vector<int>::iterator it=Graph[node].begin();it!=Graph[node].end();it++){
+ if((*it)!=Parent[node]){
+ Sum[(*it)]=(Sum[(*it)]+Sum[node])%mod;
+ Queue[end]=(*it);
+ end++;
+ }
+ }
+ }
+}
+int main()
+{
+ int x,y,U,Q,anc,ans,St;
+ scanf(""%d%d"",&N,&R);
+ if(R%mod!=0) //Checking the tricky case
+ R_inv=inverse(R,mod);
+ else
+ R_inv=0;
+
+ for(int i=1;i<N;i++){
+ scanf(""%d%d"",&x,&y);
+ Graph[x].push_back(y);
+ Graph[y].push_back(x);
+ }
+
+ level[1]=0;
+ Parent[1]=0;
+ DFS(1);
+ process();
+
+ memset(Dist_DFSL,0,sizeof(Dist_DFSL));
+ memset(Dist_DFSR,0,sizeof(Dist_DFSR));
+ memset(Sum,0,sizeof(Sum));
+
+ scanf(""%d%d"",&U,&Q);
+ while(U--){
+ scanf(""%d%d%d"",&x,&y,&St);
+ anc=lca(x,y);
+ Dist_DFSL[x]=(Dist_DFSL[x]+St)%mod;
+ Dist_DFSL[Parent[anc]]=(Dist_DFSL[Parent[anc]]-((ll)St*(ll)Store_Power_R[level[x]-level[anc]+1])%mod)%mod;
+ Dist_DFSR[y]=(Dist_DFSR[y]+((ll)St*(ll)Store_Power_R[level[y]+level[x]-2*level[anc]])%mod)%mod;
+ Dist_DFSR[anc]=(Dist_DFSR[anc]-((ll)St*(ll)Store_Power_R[level[x]-level[anc]])%mod)%mod;
+ }
+
+ Dist_DFSL[0]=Dist_DFSR[0]=0;
+
+ DFS_new(1);
+
+ if(R%mod!=0) //Check for the tricky test case
+ for(int i=1;i<=N;i++) Sum[i]=(Dist_DFSL[i]+Dist_DFSR[i])%mod;
+ else
+ for(int i=1;i<=N;i++) Sum[i]=Dist_DFSL[i];
+
+ BFS(1);
+
+ while(Q--){
+ scanf(""%d%d"",&x,&y);
+ anc=lca(x,y);
+ ans=(Sum[x]+Sum[y]-Sum[anc]-Sum[Parent[anc]])%mod;
+ printf(""%d\n"",(ans+ mod)%mod);
+ }
+
+ return 0;
+}
+Tester's Solution
+
+#include <map>
+#include <set>
+#include <list>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <vector>
+#include <ctime>
+#include <cmath>
+#include <cstdio>
+#include <string>
+#include <cstring>
+#include <cassert>
+#include <numeric>
+#include <iomanip>
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+typedef long long LL;
+typedef pair<int, int> PII;
+typedef pair<LL, LL> PLL;
+typedef vector<int> VI;
+typedef vector<LL> VL;
+typedef vector<PII> VPII;
+typedef vector<PLL> VPLL;
+#define MM(a,x) memset(a,x,sizeof(a));
+#define ALL(x) (x).begin(), (x).end()
+#define P(x) cerr<<""[""#x<<"" = ""<<(x)<<""]\n""
+#define PP(x,i) cerr<<""[""#x<<i<<"" = ""<<x[i]<<""]\n""
+#define P2(x,y) cerr<<""[""#x"" = ""<<(x)<<"", ""#y"" = ""<<(y)<<""]\n""
+#define TM(a,b) cerr<<""[""#a"" -> ""#b"": ""<<1e3*(b-a)/CLOCKS_PER_SEC<<""ms]\n"";
+#define FOR(it,v) for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
+#define rep(i, n) for(int i = 0; i < n; i++)
+#define UN(v) sort(ALL(v)), v.resize(unique(ALL(v))-v.begin())
+#define mp make_pair
+#define pb push_back
+#define x first
+#define y second
+struct _ {_() {ios_base::sync_with_stdio(0);}} _;
+template<class T> void PV(T a, T b) {while(a != b)cout << *a++, cout << (a != b ? "" "" : ""\n"");}
+template<class T> inline bool chmin(T &a, T b) {return a > b ? a = b, 1 : 0;}
+template<class T> inline bool chmax(T &a, T b) {return a < b ? a = b, 1 : 0;}
+template<class T> string tostring(T x, int len = 0) {stringstream ss; ss << x; string r = ss.str(); if(r.length() < len) r = string(len - r.length(), '0') + r; return r;}
+template<class T> void convert(string x, T& r) {stringstream ss(x); ss >> r;}
+template<class A, class B> ostream& operator<<(ostream &o, pair<A, B> t) {o << ""("" << t.x << "", "" << t.y << "")""; return o;}
+const int inf = 0x3f3f3f3f;
+const int mod = 100711433;
+const int N = 111111;
+
+const int V = 111111;
+vector<int> g[V];
+vector<int> chain[V];
+int father[V], heavy[V];
+int depth[V], size[V];
+int chainID[V], top[V];
+int tL[V], tR[V];
+int w[V];
+
+void DFS(int u) {
+ size[u] = 1;
+ for(int i = 0; i < g[u].size(); i++) {
+ int v = g[u][i];
+ if(v == father[u]) continue;
+ father[v] = u;
+ depth[v] = depth[u] + 1;
+ DFS(v);
+ size[u] += size[v];
+ if(heavy[u] == -1 || size[v] > size[heavy[u]]) heavy[u] = v;
+ }
+}
+
+void HLD_DFS(int n) {
+ MM(heavy, -1);
+ MM(father, -1);
+ MM(depth, 0);
+ DFS(0);
+ int id = 0;
+ for(int i = 0; i < n; i++) {
+ if(father[i] == -1 || heavy[father[i]] != i) {
+ for(int k = i; k != -1; k = heavy[k]) {
+ chainID[k] = id;
+ chain[id].push_back(k);
+ top[k] = i;
+ }
+ id++;
+ }
+ }
+
+ for(int i = 0; i < id; i++) {
+ tL[i] = i > 0 ? tR[i - 1] + 1 : 1;
+ tR[i] = tL[i] + chain[i].size() - 1;
+ for(int j = 0; j < chain[i].size(); j++) {
+ w[chain[i][j]] = tL[i] + j;
+ }
+ }
+}
+
+int LCA(int u, int v) {
+ while(chainID[u] != chainID[v]) {
+ if(depth[top[u]] > depth[top[v]]) swap(u, v);
+ v = father[top[v]];
+ }
+ return depth[u] < depth[v] ? u : v;
+}
+
+
+LL exp(LL x, LL n, LL m = ~0ULL >> 1) {
+ x %= m;
+ LL r = 1 % m;
+ while(n) {
+ if(n & 1) r = r * x % m;
+ x = x * x % m, n >>= 1;
+ }
+ return r;
+}
+
+LL inv(int x) {
+ return exp(x, mod - 2, mod);
+}
+
+int n, R;
+int iR;
+LL q[N];
+LL iq[N];
+
+void ADD(int u, int v, int s, int r) {
+ /*
+ if(depth[u] > depth[v]) {
+ int ns;
+ while(chain[u] != chain[v]) {
+ int len = top[u] - u + 1;
+ ns = s * q[top[u] - u + 1] % mod;
+ add(w[top[u]], w[u], ns * R % mod, iR);
+ u = top[u] + 1;
+ }
+ add(w[v], w[u], ns * R % mod , iR);
+ } else {
+ int ns;
+ swap(u, v);
+ VPII vp;
+ while(chain[u] != chain[v]) {
+ int len = top[u] - u + 1;
+ ns = s * q[top[u] - u + 1] % mod;
+ vp.pb(mp(top[u], w[u]));
+ u = top[u] + 1;
+ }
+ add(w[v], w[u], ns * R % mod , iR);
+ }
+ */
+}
+
+LL d[N];
+
+int main() {
+ cin >> n >> R;
+ for(int i = 0; i < n - 1; i++) {
+ int u, v;
+ cin >> u >> v;
+ u--, v--;
+ g[u].pb(v);
+ g[v].pb(u);
+ }
+
+ HLD_DFS(n);
+
+ int U, Q;
+ cin >> U >> Q;
+
+ iR = inv(R);
+ iq[0] = q[0] = 1;
+ for(int i = 1; i < N; i++) q[i] = q[i - 1] * R % mod;
+ for(int i = 1; i < N; i++) iq[i] = iq[i - 1] * iR % mod;
+
+ while(U--) {
+ int u, v, s;
+ cin >> u >> v >> s;
+ u--, v--;
+ int x = LCA(u, v);
+ int t = depth[u] - depth[x];
+ vector<int> left, right;
+ while(u != x) {
+ left.pb(u);
+ u = father[u];
+ }
+ left.pb(x);
+ while(v != x) {
+ right.pb(v);
+ v = father[v];
+ }
+ reverse(ALL(right));
+ for(int i = 0; i < right.size(); i++) left.pb(right[i]);
+
+ for(int i = 0; i < left.size(); i++) {
+ d[left[i]] += s;
+ s = (LL) s * R % mod;
+ }
+ /* ADD(u, x, s, R);
+ ADD(x, v, s * q[t] % mod, R);
+ ADD(x, x, -s * q[t] % mod, 1);*/
+ }
+
+ while(Q--) {
+ int u, v;
+ cin >> u >> v;
+ u--, v--;
+ int x = LCA(u, v);
+// LL r = SUM(u) + SUM(v) - 2 * SUM(father[x]);
+// r = (r % mod + mod) % mod;
+ LL r = 0;
+ while(u != x) {
+ r += d[u];
+ u = father[u];
+ }
+ r += d[x];
+ while(v != x) {
+ r += d[v];
+ v = father[v];
+ }
+ r = (r % mod + mod) % mod;
+ cout << r << endl;
+ }
+ return 0;
+}
+
+ #include
+ #include
+ #include
+ #include
+ using namespace std;
+
+ #define MaxN 100001 //Maximum Nodes
+
+ typedef long long int ll;
+
+ int N,R,level[MaxN],Parent[MaxN],Dist_DFSL[MaxN],Dist_DFSR[MaxN],Root[MaxN][17],Store_Power_R[MaxN],store[MaxN],mod=100711433,R_inv,Sum[MaxN],Queue[MaxN];
+
+ vector Graph[MaxN]; //to store graph
+
+
+ /* To calculate the inverse of a number in multiplicative modulo b*/
+ int inverse(int a,int b) //b>a
+ {
+ int Remainder,p0=0,p1=1,pcurr=1,q,m=b;
+ while(a!=0)
+ {
+ Remainder=b%a;
+ q=b/a;
+ if(Remainder!=0)
+ {
+ pcurr=p0-((ll)p1*(ll)q)%m;
+ if(pcurr<0)
+ pcurr+=m;
+ p0=p1;
+ p1=pcurr;
+ }
+ b=a;
+ a=Remainder;
+ }
+ return pcurr;
+ }
+
+ /*Storing the Parent and height using DFS*/
+ void DFS(int root)
+ {
+ for(vector ::iterator it=Graph[root].begin();it!=Graph[root].end();it++){
+ if((*it)!=Parent[root]){ //not visiting more than once
+ level[(*it)]=level[root]+1;
+ Parent[(*it)]=root;
+ DFS((*it));
+ }
+ }
+ return;
+ }
+ /*Calculating Data necessary for calculating ancestor and some pre-processing for quicker implementation*/
+ void process()
+ {
+ memset(Root,-1,sizeof(Root));
+ for(int i=1;i<=N;i++) Root[i][0]=Parent[i];
+ for(int i=1;(1<i) store[i]=store[i-1];
+ else{
+ store[i]=store[i-1]+1;
+ cmp<<=1;
+ }
+ }
+ Store_Power_R[0]=1;
+ for(int i=1;i<=N;i++)
+ Store_Power_R[i]=((ll)Store_Power_R[i-1]*(ll)R)%mod;
+ }
+ /*Returns the lca of two nodes, same implementation as was used in topcoder tutorials*/
+ int lca(int p,int q) //Fnds the LCA of 2 nodes
+ {
+ int temp;
+
+ if(level[p]>level[q]){
+ temp=p;p=q;q=temp;
+ }
+
+ //level[q]>=level[p]
+ int steps=store[level[q]];
+ for(int i=steps;i>=0;i--)
+ if(level[q]-(1<= level[p])
+ q=Root[q][i];
+
+ if(p==q) return p;
+ for(int i=steps;i>=0;i--)
+ if(Root[p][i]!=Root[q][i])
+ p=Root[p][i],q=Root[q][i];
+ return Parent[p];
+ }
+ /*This Find the Dist_DFSL and Dist_DFSR after all update queries*/
+ void DFS_new(int root)
+ {
+ for(vector ::iterator it=Graph[root].begin();it!=Graph[root].end();it++){
+ if((*it)!=Parent[root]){ //not visiting more than once
+ DFS_new((*it));
+ Dist_DFSL[root]=(Dist_DFSL[root]+((ll)Dist_DFSL[*it]*(ll)R)%mod)%mod; //Updating root from children
+ Dist_DFSR[root]=(Dist_DFSR[root]+((ll)Dist_DFSR[*it]*(ll)R_inv)%mod)%mod; //Updating root from children
+ }
+ }
+ }
+ /*This find the Sum[] array*/
+ void BFS(int root)
+ {
+ Queue[0]=root;
+ int st=0,end=1,node;
+ while(st::iterator it=Graph[node].begin();it!=Graph[node].end();it++){
+ if((*it)!=Parent[node]){
+ Sum[(*it)]=(Sum[(*it)]+Sum[node])%mod;
+ Queue[end]=(*it);
+ end++;
+ }
+ }
+ }
+ }
+ int main()
+ {
+ int x,y,U,Q,anc,ans,St;
+ scanf(""%d%d"",&N,&R);
+ if(R%mod!=0) //Checking the tricky case
+ R_inv=inverse(R,mod);
+ else
+ R_inv=0;
+
+ for(int i=1;ith line describes the ith edge: a line with two integers a b separated by a single space denotes an edge between a, b.
+The next line contains 2 space separated integers (U and Q respectively) representing the number of Update and Query operations to follow.
+U lines follow. Each of the next U lines contains 3 space separated integers (i,j, and X respectively).
+Each of the next Q lines contains 2 space separated integers, i and j respectively.
+
+**Output Format**
+It contains exactly Q lines and each line containing the answer of the ith query.
+
+**Constraints**
+
+2 <= N <= 100000
+2 <= R <= 109
+1 <= U <= 100000
+1 <= Q <= 100000
+1 <= X <= 10
+1 <= a, b, i, j <= N
+
+**Sample Input**
+
+ 6 2
+ 1 2
+ 1 4
+ 2 6
+ 4 5
+ 4 3
+ 2 2
+ 1 6 3
+ 5 3 5
+ 6 4
+ 5 1
+
+**Sample Output**
+
+ 31
+ 18
+
+**Explanation**
+
+The node values after the first updation becomes :
+
+ 3 6 0 0 0 12
+
+The node values after second updation becomes :
+
+ 3 6 20 10 5 12
+
+Answer to Query #1: 12 + 6 + 3 + 10 = 31
+Answer to Query #2: 5 + 10 +3 = 18 ",code,Answer the queries performed on trees.,ai,2013-09-25T18:56:57,2022-08-31T08:33:17,,,,"[Chinese Version](https://hr-testcases.s3.amazonaws.com/959/959-chinese.md)th line describes the ith edge: a line with two integers a b separated by a single space denotes an edge between a, b.
+The next line contains 2 space separated integers (U and Q respectively) representing the number of Update and Query operations to follow.
+U lines follow. Each of the next U lines contains 3 space separated integers (i,j, and X respectively).
+Each of the next Q lines contains 2 space separated integers, i and j respectively.
+
+**Output Format**
+It contains exactly Q lines and each line containing the answer of the ith query.
+
+**Constraints**
+
+2 <= N <= 100000
+2 <= R <= 109
+1 <= U <= 100000
+1 <= Q <= 100000
+1 <= X <= 10
+1 <= a, b, i, j <= N
+
+**Sample Input**
+
+ 6 2
+ 1 2
+ 1 4
+ 2 6
+ 4 5
+ 4 3
+ 2 2
+ 1 6 3
+ 5 3 5
+ 6 4
+ 5 1
+
+**Sample Output**
+
+ 31
+ 18
+
+**Explanation**
+
+The node values after the first updation becomes :
+
+ 3 6 0 0 0 12
+
+The node values after second updation becomes :
+
+ 3 6 20 10 5 12
+
+Answer to Query #1: 12 + 6 + 3 + 10 = 31
+Answer to Query #2: 5 + 10 +3 = 18 ",0.4090909090909091,"[""ada"",""bash"",""c"",""clojure"",""coffeescript"",""cpp"",""cpp14"",""cpp20"",""csharp"",""d"",""elixir"",""erlang"",""fortran"",""fsharp"",""go"",""groovy"",""haskell"",""java"",""java8"",""java15"",""javascript"",""julia"",""kotlin"",""lolcode"",""lua"",""objectivec"",""ocaml"",""octave"",""pascal"",""perl"",""php"",""pypy3"",""python3"",""r"",""racket"",""ruby"",""rust"",""sbcl"",""scala"",""smalltalk"",""swift"",""tcl"",""typescript"",""visualbasic"",""whitespace""]",,,,,Hard,Recalling Early Days with GP Trees : 101 Hack January Editorial,"Recalling Early Days with GP Trees
+
+Difficulty Level : Medium-Hard Problem Setter : Devendra Agarwal Problem Tester : Wanbo
+
+Approach
+
+Observations
+
+
+The Number 100711433 is a prime number , so that we can find its inverse (except when R is not a multiple of 100711433)
You need to first tackle all the Updates and then all the Queries.
+
+Choose any node as root of the tree.
+
+Make 2 arrays Dist_DFSL[] and Dist_DFSR[] for the Tree.
+
+Update Method
+
+i j St
+
+Let anc be the ancestor node of node i and node j.
+
+Add value St in Dist_DFSL[i]
+
+Add -St*power(R,d1+1) in Dist_DFSL[Parent[anc]] where d1 denotes the total number of edges between node i and node anc and power(a,b) denotes a^b mod 100711433
+
+Add -St*power(R,d1) in Dist_DFSR[anc] where d1 denotes the total number of edges between node i and node anc and power(a,b) denotes a^b mod 100711433
+
+Add St*power(R,d1+d2) in Dist_DFSR[j] where d2 represent the total edges in path from ancestor to j.
+
+d1 and d2 can be calculated by precalculating the depth of each node from root.
+
+d1=depth[i]-depth[anc]
+
+d2=depth[j]-depth[anc]
+
+After all Update Queries, we need the final values at each node and to do so ,we run a DFS on the Tree and do the following:
+
+Dist_DFSL[parent]=(Dist_DFSL[parent]+Dist_DFSL[child]*R)%mod
+
+Dist_DFSR[parent]=(Dist_DFSR[parent]+Dist_DFSR[child]*R_inverse)%mod
+
+Note :: R_Inverse * R = 1 mod (100711433)
+
+Now value at each Node is :
+
+Sum[Node]=Dist_DFSL[Node]+ Dist_DFSR[NOde]
+
+Now, Run a BFS(or DFS) on the graph and store the sum to each Node from the root in Sum[] array.
+
+Answering the Query
+
+i j
+
+Answer= Sum[i] + Sum[j] - Sum[anc] - Sum[Parent[anc]]
+
+NOTE :Precaution in Calculating R_inv and solving the problem when R is multiple of 100711433
+
+Time Complexity: O( (U+Q) log N) //computing lca part otherwise everything in O(1) time.
+
+Setter's Solution
+
+//Author : Devendra Agarwal
+#include<stdio.h>
+#include<algorithm>
+#include<iostream>
+#include<vector>
+#include<string.h>
+using namespace std;
+
+#define MaxN 100001 //Maximum Nodes
+
+typedef long long int ll;
+
+int N,R,level[MaxN],Parent[MaxN],Dist_DFSL[MaxN],Dist_DFSR[MaxN],Root[MaxN][17],Store_Power_R[MaxN],store[MaxN],mod=100711433,R_inv,Sum[MaxN],Queue[MaxN];
+
+vector<int> Graph[MaxN]; //to store graph
+
+
+/* To calculate the inverse of a number in multiplicative modulo b*/
+int inverse(int a,int b) //b>a
+{
+ int Remainder,p0=0,p1=1,pcurr=1,q,m=b;
+ while(a!=0)
+ {
+ Remainder=b%a;
+ q=b/a;
+ if(Remainder!=0)
+ {
+ pcurr=p0-((ll)p1*(ll)q)%m;
+ if(pcurr<0)
+ pcurr+=m;
+ p0=p1;
+ p1=pcurr;
+ }
+ b=a;
+ a=Remainder;
+ }
+ return pcurr;
+}
+
+/*Storing the Parent and height using DFS*/
+void DFS(int root)
+{
+ for(vector<int> ::iterator it=Graph[root].begin();it!=Graph[root].end();it++){
+ if((*it)!=Parent[root]){ //not visiting more than once
+ level[(*it)]=level[root]+1;
+ Parent[(*it)]=root;
+ DFS((*it));
+ }
+ }
+ return;
+}
+/*Calculating Data necessary for calculating ancestor and some pre-processing for quicker implementation*/
+void process()
+{
+ memset(Root,-1,sizeof(Root));
+ for(int i=1;i<=N;i++) Root[i][0]=Parent[i];
+ for(int i=1;(1<<i) <= N; i++)
+ for(int j=1;j<=N;j++)
+ if(Root[j][i-1]!=-1)
+ Root[j][i]=Root[Root[j][i-1]][i-1];
+
+ store[0]=0;
+ store[1]=0;
+ int cmp=2;
+ for(int i=2;i<=N;i++){
+ if(cmp>i) store[i]=store[i-1];
+ else{
+ store[i]=store[i-1]+1;
+ cmp<<=1;
+ }
+ }
+ Store_Power_R[0]=1;
+ for(int i=1;i<=N;i++)
+ Store_Power_R[i]=((ll)Store_Power_R[i-1]*(ll)R)%mod;
+}
+/*Returns the lca of two nodes, same implementation as was used in topcoder tutorials*/
+int lca(int p,int q) //Fnds the LCA of 2 nodes
+{
+ int temp;
+
+ if(level[p]>level[q]){
+ temp=p;p=q;q=temp;
+ }
+
+ //level[q]>=level[p]
+ int steps=store[level[q]];
+ for(int i=steps;i>=0;i--)
+ if(level[q]-(1<<i) >= level[p])
+ q=Root[q][i];
+
+ if(p==q) return p;
+ for(int i=steps;i>=0;i--)
+ if(Root[p][i]!=Root[q][i])
+ p=Root[p][i],q=Root[q][i];
+ return Parent[p];
+}
+/*This Find the Dist_DFSL and Dist_DFSR after all update queries*/
+void DFS_new(int root)
+{
+ for(vector<int> ::iterator it=Graph[root].begin();it!=Graph[root].end();it++){
+ if((*it)!=Parent[root]){ //not visiting more than once
+ DFS_new((*it));
+ Dist_DFSL[root]=(Dist_DFSL[root]+((ll)Dist_DFSL[*it]*(ll)R)%mod)%mod; //Updating root from children
+ Dist_DFSR[root]=(Dist_DFSR[root]+((ll)Dist_DFSR[*it]*(ll)R_inv)%mod)%mod; //Updating root from children
+ }
+ }
+}
+/*This find the Sum[] array*/
+void BFS(int root)
+{
+ Queue[0]=root;
+ int st=0,end=1,node;
+ while(st<end){
+ node=Queue[st];
+ st++;
+ for(vector<int>::iterator it=Graph[node].begin();it!=Graph[node].end();it++){
+ if((*it)!=Parent[node]){
+ Sum[(*it)]=(Sum[(*it)]+Sum[node])%mod;
+ Queue[end]=(*it);
+ end++;
+ }
+ }
+ }
+}
+int main()
+{
+ int x,y,U,Q,anc,ans,St;
+ scanf(""%d%d"",&N,&R);
+ if(R%mod!=0) //Checking the tricky case
+ R_inv=inverse(R,mod);
+ else
+ R_inv=0;
+
+ for(int i=1;i<N;i++){
+ scanf(""%d%d"",&x,&y);
+ Graph[x].push_back(y);
+ Graph[y].push_back(x);
+ }
+
+ level[1]=0;
+ Parent[1]=0;
+ DFS(1);
+ process();
+
+ memset(Dist_DFSL,0,sizeof(Dist_DFSL));
+ memset(Dist_DFSR,0,sizeof(Dist_DFSR));
+ memset(Sum,0,sizeof(Sum));
+
+ scanf(""%d%d"",&U,&Q);
+ while(U--){
+ scanf(""%d%d%d"",&x,&y,&St);
+ anc=lca(x,y);
+ Dist_DFSL[x]=(Dist_DFSL[x]+St)%mod;
+ Dist_DFSL[Parent[anc]]=(Dist_DFSL[Parent[anc]]-((ll)St*(ll)Store_Power_R[level[x]-level[anc]+1])%mod)%mod;
+ Dist_DFSR[y]=(Dist_DFSR[y]+((ll)St*(ll)Store_Power_R[level[y]+level[x]-2*level[anc]])%mod)%mod;
+ Dist_DFSR[anc]=(Dist_DFSR[anc]-((ll)St*(ll)Store_Power_R[level[x]-level[anc]])%mod)%mod;
+ }
+
+ Dist_DFSL[0]=Dist_DFSR[0]=0;
+
+ DFS_new(1);
+
+ if(R%mod!=0) //Check for the tricky test case
+ for(int i=1;i<=N;i++) Sum[i]=(Dist_DFSL[i]+Dist_DFSR[i])%mod;
+ else
+ for(int i=1;i<=N;i++) Sum[i]=Dist_DFSL[i];
+
+ BFS(1);
+
+ while(Q--){
+ scanf(""%d%d"",&x,&y);
+ anc=lca(x,y);
+ ans=(Sum[x]+Sum[y]-Sum[anc]-Sum[Parent[anc]])%mod;
+ printf(""%d\n"",(ans+ mod)%mod);
+ }
+
+ return 0;
+}
+Tester's Solution
+
+#include <map>
+#include <set>
+#include <list>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <vector>
+#include <ctime>
+#include <cmath>
+#include <cstdio>
+#include <string>
+#include <cstring>
+#include <cassert>
+#include <numeric>
+#include <iomanip>
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+typedef long long LL;
+typedef pair<int, int> PII;
+typedef pair<LL, LL> PLL;
+typedef vector<int> VI;
+typedef vector<LL> VL;
+typedef vector<PII> VPII;
+typedef vector<PLL> VPLL;
+#define MM(a,x) memset(a,x,sizeof(a));
+#define ALL(x) (x).begin(), (x).end()
+#define P(x) cerr<<""[""#x<<"" = ""<<(x)<<""]\n""
+#define PP(x,i) cerr<<""[""#x<<i<<"" = ""<<x[i]<<""]\n""
+#define P2(x,y) cerr<<""[""#x"" = ""<<(x)<<"", ""#y"" = ""<<(y)<<""]\n""
+#define TM(a,b) cerr<<""[""#a"" -> ""#b"": ""<<1e3*(b-a)/CLOCKS_PER_SEC<<""ms]\n"";
+#define FOR(it,v) for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
+#define rep(i, n) for(int i = 0; i < n; i++)
+#define UN(v) sort(ALL(v)), v.resize(unique(ALL(v))-v.begin())
+#define mp make_pair
+#define pb push_back
+#define x first
+#define y second
+struct _ {_() {ios_base::sync_with_stdio(0);}} _;
+template<class T> void PV(T a, T b) {while(a != b)cout << *a++, cout << (a != b ? "" "" : ""\n"");}
+template<class T> inline bool chmin(T &a, T b) {return a > b ? a = b, 1 : 0;}
+template<class T> inline bool chmax(T &a, T b) {return a < b ? a = b, 1 : 0;}
+template<class T> string tostring(T x, int len = 0) {stringstream ss; ss << x; string r = ss.str(); if(r.length() < len) r = string(len - r.length(), '0') + r; return r;}
+template<class T> void convert(string x, T& r) {stringstream ss(x); ss >> r;}
+template<class A, class B> ostream& operator<<(ostream &o, pair<A, B> t) {o << ""("" << t.x << "", "" << t.y << "")""; return o;}
+const int inf = 0x3f3f3f3f;
+const int mod = 100711433;
+const int N = 111111;
+
+const int V = 111111;
+vector<int> g[V];
+vector<int> chain[V];
+int father[V], heavy[V];
+int depth[V], size[V];
+int chainID[V], top[V];
+int tL[V], tR[V];
+int w[V];
+
+void DFS(int u) {
+ size[u] = 1;
+ for(int i = 0; i < g[u].size(); i++) {
+ int v = g[u][i];
+ if(v == father[u]) continue;
+ father[v] = u;
+ depth[v] = depth[u] + 1;
+ DFS(v);
+ size[u] += size[v];
+ if(heavy[u] == -1 || size[v] > size[heavy[u]]) heavy[u] = v;
+ }
+}
+
+void HLD_DFS(int n) {
+ MM(heavy, -1);
+ MM(father, -1);
+ MM(depth, 0);
+ DFS(0);
+ int id = 0;
+ for(int i = 0; i < n; i++) {
+ if(father[i] == -1 || heavy[father[i]] != i) {
+ for(int k = i; k != -1; k = heavy[k]) {
+ chainID[k] = id;
+ chain[id].push_back(k);
+ top[k] = i;
+ }
+ id++;
+ }
+ }
+
+ for(int i = 0; i < id; i++) {
+ tL[i] = i > 0 ? tR[i - 1] + 1 : 1;
+ tR[i] = tL[i] + chain[i].size() - 1;
+ for(int j = 0; j < chain[i].size(); j++) {
+ w[chain[i][j]] = tL[i] + j;
+ }
+ }
+}
+
+int LCA(int u, int v) {
+ while(chainID[u] != chainID[v]) {
+ if(depth[top[u]] > depth[top[v]]) swap(u, v);
+ v = father[top[v]];
+ }
+ return depth[u] < depth[v] ? u : v;
+}
+
+
+LL exp(LL x, LL n, LL m = ~0ULL >> 1) {
+ x %= m;
+ LL r = 1 % m;
+ while(n) {
+ if(n & 1) r = r * x % m;
+ x = x * x % m, n >>= 1;
+ }
+ return r;
+}
+
+LL inv(int x) {
+ return exp(x, mod - 2, mod);
+}
+
+int n, R;
+int iR;
+LL q[N];
+LL iq[N];
+
+void ADD(int u, int v, int s, int r) {
+ /*
+ if(depth[u] > depth[v]) {
+ int ns;
+ while(chain[u] != chain[v]) {
+ int len = top[u] - u + 1;
+ ns = s * q[top[u] - u + 1] % mod;
+ add(w[top[u]], w[u], ns * R % mod, iR);
+ u = top[u] + 1;
+ }
+ add(w[v], w[u], ns * R % mod , iR);
+ } else {
+ int ns;
+ swap(u, v);
+ VPII vp;
+ while(chain[u] != chain[v]) {
+ int len = top[u] - u + 1;
+ ns = s * q[top[u] - u + 1] % mod;
+ vp.pb(mp(top[u], w[u]));
+ u = top[u] + 1;
+ }
+ add(w[v], w[u], ns * R % mod , iR);
+ }
+ */
+}
+
+LL d[N];
+
+int main() {
+ cin >> n >> R;
+ for(int i = 0; i < n - 1; i++) {
+ int u, v;
+ cin >> u >> v;
+ u--, v--;
+ g[u].pb(v);
+ g[v].pb(u);
+ }
+
+ HLD_DFS(n);
+
+ int U, Q;
+ cin >> U >> Q;
+
+ iR = inv(R);
+ iq[0] = q[0] = 1;
+ for(int i = 1; i < N; i++) q[i] = q[i - 1] * R % mod;
+ for(int i = 1; i < N; i++) iq[i] = iq[i - 1] * iR % mod;
+
+ while(U--) {
+ int u, v, s;
+ cin >> u >> v >> s;
+ u--, v--;
+ int x = LCA(u, v);
+ int t = depth[u] - depth[x];
+ vector<int> left, right;
+ while(u != x) {
+ left.pb(u);
+ u = father[u];
+ }
+ left.pb(x);
+ while(v != x) {
+ right.pb(v);
+ v = father[v];
+ }
+ reverse(ALL(right));
+ for(int i = 0; i < right.size(); i++) left.pb(right[i]);
+
+ for(int i = 0; i < left.size(); i++) {
+ d[left[i]] += s;
+ s = (LL) s * R % mod;
+ }
+ /* ADD(u, x, s, R);
+ ADD(x, v, s * q[t] % mod, R);
+ ADD(x, x, -s * q[t] % mod, 1);*/
+ }
+
+ while(Q--) {
+ int u, v;
+ cin >> u >> v;
+ u--, v--;
+ int x = LCA(u, v);
+// LL r = SUM(u) + SUM(v) - 2 * SUM(father[x]);
+// r = (r % mod + mod) % mod;
+ LL r = 0;
+ while(u != x) {
+ r += d[u];
+ u = father[u];
+ }
+ r += d[x];
+ while(v != x) {
+ r += d[v];
+ v = father[v];
+ }
+ r = (r % mod + mod) % mod;
+ cout << r << endl;
+ }
+ return 0;
+}
+
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include