├── Dynamic Programming
    ├── Book Shop.cpp
    ├── Coin Combinations I.cpp
    ├── Coin Combinations II.cpp
    ├── Dice Combinations.cpp
    ├── Grid Paths.cpp
    ├── Minimizing Coins.cpp
    ├── Money Sums.cpp
    └── Removing Digits.cpp
├── Graph Algorithms
    ├── Building Roads.cpp
    ├── Building Teams.cpp
    ├── Counting Rooms.cpp
    ├── Course Schedule.cpp
    ├── Labyrinth.cpp
    ├── Message Route.cpp
    ├── Road Construction.cpp
    ├── Road Reparation.cpp
    ├── Round Trip.cpp
    ├── Shortest Routes I.cpp
    └── Shortest Routes II.cpp
├── Mathematics
    ├── Binomial Coefficients.cpp
    ├── Bracket Sequences I.cpp
    ├── Christmas Party.cpp
    ├── Common Divisors.cpp
    ├── Counting Coprime Pairs.cpp
    ├── Counting Divisors.cpp
    ├── Creating Strings II.cpp
    ├── Distributing Apples.cpp
    ├── Exponentiation II.cpp
    ├── Exponentiation.cpp
    ├── Prime Multiples.cpp
    └── Sum of Divisors.cpp
├── Range Queries
    ├── Dynamic Range Minimum Queries.cpp
    ├── Dynamic Range Sum Queries.cpp
    ├── Forest Queries.cpp
    ├── Hotel Queries.cpp
    ├── List Removals.cpp
    ├── Pizzeria Queries.cpp
    ├── Prefix Sum Queries.cpp
    ├── Range Update Queries.cpp
    ├── Range Xor Queries.cpp
    ├── Salary Queries.cpp
    ├── Static Range Minimum Queries.cpp
    └── Static Range Sum Queries.cpp
└── Tree Algorithms
    ├── Company Queries I.cpp
    ├── Company Queries II.cpp
    ├── Counting Paths.cpp
    ├── Distance Queries.cpp
    ├── Distinct Colors.cpp
    ├── Finding a Centroid.cpp
    ├── Fixed-Length Paths I.cpp
    ├── Fixed-Length Paths II.cpp
    ├── Path Queries II.cpp
    ├── Path Queries.cpp
    ├── Subordinates.cpp
    ├── Subtree Queries.cpp
    ├── Tree Diameter.cpp
    ├── Tree Distances I.cpp
    ├── Tree Distances II.cpp
    └── Tree Matching.cpp


/Dynamic Programming/Book Shop.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | int price[1001];
19 | int pages[1001];
20 | int dp[1001][100001];
21 |  
22 | int main()
23 | {
24 | 	int n , x;
25 | 	
26 | 	cin>>n>>x;
27 | 	REP(i , n) cin>>price[i];
28 | 	REP(i , n) cin>>pages[i] , dp[i][0] = 0;
29 | 	
30 | 	memset(dp , INF , sizeof dp);
31 | 	
32 | 	for(int i=1;i<=n;i++)
33 | 	{
34 | 		for(int j=1;j<=x;j++)
35 | 		{
36 | 			dp[i][j] = dp[i-1][j];
37 | 			
38 | 			if(j >= price[i])
39 | 			dp[i][j] = max(dp[i][j] , dp[i-1][j-price[i]] + pages[i]);
40 | 		}
41 | 	}
42 | 	
43 | 	int res = 0;
44 | 	REP(i , n) res = max(res , dp[i][x]);
45 | 	
46 | 	cout<<res;
47 | }
48 |  
49 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Coin Combinations I.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | lli dp[1000001];
19 | int c[101];
20 | int main()
21 | {
22 | 	int n , x;
23 | 	cin>>n>>x;
24 | 	REP(i , n) cin>>c[i];
25 | 	
26 | 	dp[0] = 1;
27 | 	
28 | 	REP(i , x)
29 | 	{
30 | 		for(int j=1;j<=n;j++)
31 | 		if(c[j] <= i) dp[i] += dp[i - c[j]] , dp[i] %= mod;
32 | 	}
33 | 	
34 | 	cout<<dp[x];
35 | }
36 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Coin Combinations II.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | lli dp[1000001];
19 | int c[101];
20 | int main()
21 | {
22 | 	int n , x;
23 | 	cin>>n>>x;
24 | 	REP(i , n) cin>>c[i];
25 | 	
26 | 	dp[0] = 1;
27 | 	
28 | 	REP(i , n)
29 | 	{
30 | 		for(int j=c[i];j<=x;j++)
31 | 		dp[j] += dp[j - c[i]] , dp[j] %= mod;
32 | 	}
33 | 	
34 | 	cout<<dp[x];
35 | }
36 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Dice Combinations.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | lli dp[1000001];
19 | int c[7];
20 | int main()
21 | {
22 | 	int n;
23 | 	cin>>n;
24 | 	REP(i , 6) c[i] = i;
25 | 	
26 | 	dp[0] = 1;
27 | 	
28 | 	REP(i , n)
29 | 	{
30 | 		for(int j=1;j<=6;j++)
31 | 		if(c[j] <= i) dp[i] += dp[i - c[j]] , dp[i] %= mod;
32 | 	}
33 | 	
34 | 	cout<<dp[n];
35 | }
36 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Grid Paths.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | char ar[1001][1001];
19 | lli dp[1001][1001];
20 |  
21 | int main()
22 | {
23 | 	int n;
24 | 	cin>>n;
25 | 	REP(i , n) REP(j , n) cin>>ar[i][j];
26 | 	
27 | 	if(ar[1][1] != '*')
28 | 	dp[1][1] = 1;
29 | 	
30 | 	REP(i , n)
31 | 	{
32 | 		REP(j , n)
33 | 		{
34 | 			if(ar[i][j] == '*') continue;
35 | 			
36 | 			if(i > 1) dp[i][j] = (dp[i][j] + dp[i-1][j]) % mod;
37 | 			if(j > 1) dp[i][j] = (dp[i][j] + dp[i][j-1]) % mod;
38 | 		}
39 | 	}
40 | 	
41 | 	cout<<dp[n][n];
42 | }
43 |  
44 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Minimizing Coins.cpp:
--------------------------------------------------------------------------------
 1 | //link to video solution : https://www.youtube.com/watch?v=m5uSidurbZ8&list=PL2q4fbVm1Ik7MOM34WOYlx_2hrsn-PQwa&index=1
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | int coins[101];
21 | int dp[1000001];
22 | int main()
23 | {
24 | 	int n , x;
25 | 	cin>>n>>x;
26 | 	
27 | 	REP(i , n) cin>>coins[i];
28 | 	
29 | 	REP(i , x) dp[i] = INF;
30 | 	
31 | 	for(int i=1;i<=x;i++)
32 | 	{
33 | 		for(int j=1;j<=n;j++)
34 | 		if(i - coins[j] >= 0)
35 | 		dp[i] = min(dp[i] , dp[ i - coins[j] ] + 1);
36 | 	}
37 | 	
38 | 	if(dp[x] == INF) dp[x] = -1;
39 | 	
40 | 	cout<<dp[x];
41 | }
42 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Money Sums.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=rRhWyZXmEcQ&list=PL2q4fbVm1Ik7MOM34WOYlx_2hrsn-PQwa&index=2
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define ll long long int
 5 | using namespace std;
 6 |  
 7 | int dp[100001];
 8 | int main(){
 9 | 	int ar[101] , n;
10 | 	vector<int> result;
11 | 	dp[0] = 1;
12 | 	
13 | 	cin>>n;
14 | 	for(int i=1;i<=n;i++) cin>>ar[i];
15 | 	
16 | 	for(int i=1;i<=n;i++){
17 | 		int d = ar[i];
18 | 		
19 | 		for(int j=100000;j-d>=0;j--)
20 | 		if(dp[j-d] == 1) dp[j] = 1;
21 | 	}
22 | 	
23 | 	for(int i=1;i<=100000;i++) if(dp[i] == 1 ) result.push_back(i);
24 | 	
25 | 	cout<<result.size()<<endl;
26 | 	for(int sum : result) cout<<sum<<" ";
27 | }
28 |  
29 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Removing Digits.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | int dp[1000001];
19 | int main()
20 | {
21 | 	int n;
22 | 	cin>>n;
23 | 	
24 | 	REP(i , 10) dp[i-1] = 1;
25 | 	
26 | 	for(int i=10;i<=n;i++) dp[i] = INF;
27 | 	
28 | 	for(int i=10;i<=n;i++)
29 | 	{
30 | 		int temp = i;
31 | 		
32 | 		while(temp)
33 | 		{
34 | 			int d = temp % 10;
35 | 			temp /= 10;
36 | 			
37 | 			if(d == 0) continue;
38 | 			
39 | 			dp[i] = min(dp[i] , dp[i - d] + 1);
40 | 		}
41 | 	}
42 | 	
43 | 	cout<<dp[n];
44 | }
45 |  
46 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Building Roads.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=9u0WUGL8OS8&list=PL2q4fbVm1Ik4vJBWX1vgYbjIrfJdIfKgN&index=2
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | vi ar[100001];
21 | bool vis[100001];
22 |  
23 | void dfs(int node){
24 | 	vis[node] = 1;
25 | 	
26 | 	for(int child : ar[node])
27 | 	if(vis[child] == 0) dfs(child);
28 | }
29 |  
30 | int main()
31 | {
32 | 	int n , m , a , b;
33 | 	
34 | 	vi res;
35 | 	
36 | 	cin>>n>>m;
37 | 	REP(i , m) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
38 | 	
39 | 	REP(i , n)
40 | 	if(vis[i] == 0)
41 | 	dfs(i) , res.pb(i);
42 | 	
43 | 	cout<<res.size()-1<<endl;
44 | 	for(int i=1;i<res.size();i++)
45 | 	cout<<res[i-1]<<" "<<res[i]<<endl;
46 | }
47 |  
48 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Building Teams.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=3gEw2bcQY78&list=PL2q4fbVm1Ik4vJBWX1vgYbjIrfJdIfKgN&index=5
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | vi ar[100001];
21 | bool vis[100001];
22 | int color[100001];
23 |  
24 | bool dfs(int node , int c){
25 | 	vis[node] = true;
26 | 	color[node] = c;
27 | 	
28 | 	for(int v : ar[node])
29 | 	{
30 | 		if(vis[v] == false){
31 | 			bool res = dfs(v , c ^ 1);
32 | 			if(res == false) return false;
33 | 		}
34 | 		else{
35 | 			if(color[node] == color[v]) return false;
36 | 		}
37 | 	}
38 | 	
39 | 	return true;
40 | }
41 |  
42 | int main()
43 | {
44 | 	int a , b , n , m;
45 | 	cin>>n>>m;
46 | 	
47 | 	REP(i , m) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
48 | 	
49 | 	bool flag = true;
50 | 	
51 | 	REP(i , n)
52 | 	if(vis[i] == false)
53 | 	{
54 | 		flag = dfs(i , 0);
55 | 		if(flag == false) break;
56 | 	}
57 | 	
58 | 	if(!flag) cout<<"IMPOSSIBLE";
59 | 	else
60 | 	REP(i , n) cout<<color[i] + 1<<" ";
61 | }
62 |  
63 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Counting Rooms.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=QrZAee1PZBE&list=PL2q4fbVm1Ik4vJBWX1vgYbjIrfJdIfKgN&index=1
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 |  
19 | using namespace std;
20 | char ar[1001][1001];
21 | bool vis[1001][1001];
22 | int N , M;
23 |  
24 | bool isValid(int x , int y)
25 | {
26 | 	if(x < 1 || x > N || y < 1 || y > M) return false;
27 | 	
28 | 	if(vis[x][y] == true || ar[x][y] == '#') return false;
29 | 	
30 | 	return true;
31 | }
32 |  
33 | void dfs(int x , int y)
34 | {
35 | 	vis[x][y] = true;
36 | 	
37 | 	if(isValid(x-1 , y))
38 | 	dfs(x-1 , y);
39 | 	
40 | 	if(isValid(x , y + 1))
41 | 	dfs(x , y + 1);
42 | 	
43 | 	if(isValid(x + 1 , y))
44 | 	dfs(x + 1 , y);
45 | 	
46 | 	if(isValid(x , y-1))
47 | 	dfs(x , y - 1);
48 | }
49 |  
50 | int main()
51 | {
52 | 	cin>>N>>M;
53 | 	
54 | 	for(int i=1;i<=N;i++)
55 | 	{
56 | 		for(int j=1;j<=M;j++)
57 | 		cin>>ar[i][j];
58 | 	}
59 | 	
60 | 	int cnt = 0;
61 | 	
62 | 	for(int i=1;i<=N;i++)
63 | 	{
64 | 		for(int j=1;j<=M;j++)
65 | 		if(ar[i][j] == '.' && vis[i][j] == false)
66 | 		dfs(i , j) , cnt++;
67 | 	}
68 | 	
69 | 	cout<<cnt;
70 | }
71 |  
72 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Course Schedule.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=eeZxxor8el4&list=PL2q4fbVm1Ik4vJBWX1vgYbjIrfJdIfKgN&index=8
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define ll long long int
 5 | using namespace std;
 6 |  
 7 | int in_degree[100001];
 8 | vector<int> ar[100001];
 9 |  
10 | void printOrder(int n){
11 | 	
12 | 	queue<int> q;
13 | 	vector<int> res;
14 | 	
15 | 	for(int i=1;i<=n;i++)
16 | 	if(in_degree[i] == 0) q.push(i);
17 | 	
18 | 	while(!q.empty()){
19 | 		int node = q.front();
20 | 		q.pop();
21 | 		res.push_back(node);
22 | 		
23 | 		for(int v : ar[node]){
24 | 			in_degree[v]--;
25 | 			if(in_degree[v] == 0) q.push(v);
26 | 		}
27 | 	}
28 | 	
29 | 	if(res.size() == n){
30 | 		for(int node : res) cout<<node<<" ";
31 | 	}
32 | 	else{
33 | 		cout<<"IMPOSSIBLE";
34 | 	}
35 | }
36 |  
37 | int main(){
38 | 	int a , b , n , m;
39 | 	
40 | 	cin>>n>>m;
41 | 	
42 | 	for(int i=1;i<=m;i++) cin>>a>>b , ar[a].push_back(b) , in_degree[b]++;
43 | 	
44 | 	printOrder(n);
45 | }
46 |  
47 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Labyrinth.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=5pSMCfNR08U&list=PL2q4fbVm1Ik4vJBWX1vgYbjIrfJdIfKgN&index=4
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | char ar[1001][1001];
21 | char br[1001][1001];
22 | bool vis[1001][1001];
23 | int n , m;
24 | vector<char> path;
25 |  
26 | bool isValid(int x , int y){
27 | 	
28 | 	if(x < 1 || x > n || y < 1 || y > m) return false;
29 | 	
30 | 	if(ar[x][y] == '#' || vis[x][y] == true) return false;
31 | 	
32 | 	return true;
33 | }
34 |  
35 | bool bfs(int x , int y)
36 | {
37 | 	queue<pair<int,int> > q;
38 | 	q.push({x , y});
39 | 	vis[x][y] = true;
40 | 	
41 | 	while(!q.empty()){
42 | 		int a = q.front().first;
43 | 		int b = q.front().second;
44 | 		q.pop();
45 | 		
46 | 		if(ar[a][b] == 'B'){
47 | 			while(1){
48 | 				path.push_back(br[a][b]);
49 | 			
50 | 				if(path.back() == 'L') b++;
51 | 				if(path.back() == 'R') b--;
52 | 				if(path.back() == 'U') a++;
53 | 				if(path.back() == 'D') a--;
54 | 				
55 | 				if(a == x && b == y)
56 | 				break;
57 | 			}
58 | 			return true;
59 | 		}
60 | 		
61 | 		//left
62 | 		if(isValid(a , b - 1)) br[a][b-1] = 'L' , q.push({a , b-1}) , vis[a][b-1] = true;
63 | 		
64 | 		//right
65 | 		if(isValid(a , b + 1)) br[a][b+1] = 'R' , q.push({a , b+1}) , vis[a][b+1] = true;
66 | 		
67 | 		//up
68 | 		if(isValid(a - 1, b)) br[a - 1][b] = 'U' , q.push({a - 1 , b}) , vis[a-1][b] = true;
69 | 		
70 | 		//down
71 | 		if(isValid(a + 1, b)) br[a + 1][b] = 'D' , q.push({a + 1 , b}) , vis[a+1][b] = true;
72 | 		
73 | 	}
74 | 	
75 | 	return false;
76 | }
77 |  
78 | int main()
79 | {
80 | 	cin>>n>>m;
81 | 	int x;
82 | 	int y;
83 | 	
84 | 	REP(i , n) REP(j , m){
85 | 		cin>>ar[i][j];
86 | 		if(ar[i][j] == 'A') x = i , y = j;
87 | 	}
88 | 	
89 | 	if(bfs(x , y) == true){
90 | 		cout<<"YES"<<endl<<path.size()<<endl;
91 | 		while(path.size() > 0) cout<<path.back() , path.pop_back();
92 | 	}
93 | 	else{
94 | 		cout<<"NO";
95 | 	}
96 | }
97 |  
98 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Message Route.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=9I1LBFPW0iE&list=PL2q4fbVm1Ik4vJBWX1vgYbjIrfJdIfKgN&index=3
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | vector<int> ar[100001];
21 | int dist[100001];
22 | int par[100001];
23 | bool vis[100001];
24 |  
25 | int n , m;
26 |  
27 | bool bfs(){
28 | 	queue<int> q;
29 | 	dist[1] = 1;
30 | 	vis[1] = 1;
31 | 	q.push(1);
32 | 	
33 | 	while(!q.empty()){
34 | 		int node = q.front();
35 | 		q.pop();
36 | 		
37 | 		if(node == n) return true;
38 | 		
39 | 		for(int u : ar[node])
40 | 		if(vis[u] == false){
41 | 			dist[u] = dist[node] + 1;
42 | 			vis[u] = true;
43 | 			par[u] = node;
44 | 			q.push(u);
45 | 		}
46 | 	}
47 | 	
48 | 	return false;
49 | }
50 |  
51 | int main()
52 | {
53 | 	int a , b;
54 | 	
55 | 	cin>>n>>m;
56 | 	
57 | 	REP(i , m) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
58 | 	
59 | 	if(bfs()){
60 | 		cout<<dist[n]<<endl;
61 | 		
62 | 		int path = n;
63 | 		vector<int> res;
64 | 		while(path != 0) res.pb(path) , path = par[path];
65 | 		
66 | 		reverse(res.begin() , res.end());
67 | 		for(int node : res) cout<<node<<" ";
68 | 	}
69 | 	else cout<<"IMPOSSIBLE";
70 | }
71 |  
72 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Road Construction.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=Cwv0W02J0Q0&list=PL2q4fbVm1Ik4vJBWX1vgYbjIrfJdIfKgN&index=6
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | const int N = 200001;
21 |  
22 | int _rank[N];
23 | int par[N];
24 |  
25 | int find(int a){
26 | 	if(par[a] == -1) return a;
27 | 	
28 | 	return par[a] = find(par[a]);
29 | }
30 |  
31 | int merge(int a , int b){
32 | 	
33 | 	a = find(a);
34 | 	b = find(b);
35 | 	
36 | 	if(_rank[a] < _rank[b]) swap(a , b);
37 | 	
38 | 	par[b] = a;
39 | 	_rank[a] += _rank[b];
40 | 	
41 | 	return _rank[a];
42 | }
43 |  
44 | int main()
45 | {
46 | 	int n , a , b , m;
47 | 	
48 | 	cin>>n>>m;
49 | 	for(int i=1;i<=n;i++) _rank[i] = 1 , par[i] = -1;
50 | 	
51 | 	int cc = n;
52 | 	int mx = 1;
53 | 	
54 | 	while(m--){
55 | 		cin>>a>>b;
56 | 		
57 | 		if(find(a) != find(b)) mx = max(mx , merge(a , b)) , cc--;
58 | 		
59 | 		cout<<cc<<" "<<mx<<endl;
60 | 	}
61 | }
62 |  
63 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Road Reparation.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=BDbXyrvwn1g&list=PL2q4fbVm1Ik4vJBWX1vgYbjIrfJdIfKgN&index=7
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define ll long long int
 5 | using namespace std;
 6 |  
 7 | struct Edge{
 8 | 	int a;
 9 | 	int b;
10 | 	ll weight;
11 | };
12 |  
13 | vector<Edge> edgeList;
14 | int _par[200001];
15 |  
16 | bool comp(Edge a , Edge b){
17 | 	return a.weight < b.weight;
18 | }
19 |  
20 | int find(int a){
21 | 	if(_par[a] == -1) return a;
22 | 	
23 | 	return _par[a] = find(_par[a]);
24 | }
25 |  
26 | bool merge(int a , int b){
27 | 	a = find(a);
28 | 	b = find(b);
29 | 	
30 | 	if(a == b) return false;
31 | 	
32 | 	_par[a] = b;
33 | 	return true;
34 | }
35 |  
36 | int main(){
37 | 	int n , m;
38 | 	ll res = 0;
39 | 	int addedEdgeCount = 0;
40 | 	Edge temp;
41 | 	
42 | 	cin>>n>>m;
43 | 	
44 | 	for(int i=1;i<=n;i++) _par[i] = -1;
45 | 	
46 | 	for(int i=1;i<=m;i++) cin>>temp.a>>temp.b>>temp.weight , edgeList.push_back(temp);
47 | 	
48 | 	sort(edgeList.begin() , edgeList.end() , comp);
49 | 	
50 | 	for(Edge e : edgeList){
51 | 		if(merge(e.a , e.b)) res += e.weight , addedEdgeCount++;
52 | 	}
53 | 	
54 | 	if(addedEdgeCount == n-1)
55 | 	cout<<res;
56 | 	else
57 | 	cout<<"IMPOSSIBLE";
58 | }
59 |  
60 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Round Trip.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | vi ar[100001];
19 | vi temp , res;
20 | bool vis[100001];
21 |  
22 | bool dfs(int node ,int par){
23 | 	vis[node] = true;
24 | 	temp.push_back(node);
25 | 	
26 | 	for(int v : ar[node])
27 | 	if(vis[v] == false){
28 | 		if(dfs(v , node) == true) return true;
29 | 	}
30 | 	else
31 | 	if(par != v){
32 | 		temp.push_back(v);
33 | 		return true;
34 | 	}
35 | 	
36 | 	temp.pop_back();
37 | 	return false;
38 | }
39 |  
40 | int main()
41 | {
42 | 	int n , m , a , b;
43 | 	cin>>n>>m;
44 | 	
45 | 	bool flag = false;
46 | 	
47 | 	REP(i , m) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
48 | 	
49 | 	REP(i , n)
50 | 	if(vis[i] == false)
51 | 	{
52 | 		flag = dfs(i , -1);
53 | 		
54 | 		if(flag == true) break;
55 | 	}
56 | 	
57 | 	if(flag == false) cout<<"IMPOSSIBLE";
58 | 	else
59 | 	{
60 | 		int src = temp.back();
61 | 		res.pb(temp.back());
62 | 		temp.pop_back();
63 | 		
64 | 		
65 | 		while(1){
66 | 			res.pb(temp.back());
67 | 			
68 | 			if(temp.back() == src) break;
69 | 			
70 | 			temp.pop_back();
71 | 		}
72 | 		
73 | 		//printing
74 | 		cout<<res.size()<<endl;
75 | 		for(int node : res) cout<<node<<" ";
76 | 	}
77 | 	
78 | }
79 |  
80 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Shortest Routes I.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define ll long long
 4 |  
 5 | const int N = 2e5;
 6 | const ll INF = 1e18;
 7 | vector<pair<ll,ll> > adj[N+1];
 8 | ll dist[N+1];
 9 |  
10 | void dijkstra(int n , int src){
11 | 	for(int i=1;i<=n;i++) dist[i] = INF;
12 |  
13 | 	//preprocessing
14 | 	priority_queue< pair<ll,ll> , vector<pair<ll,ll> > , greater<pair<ll,ll> > > pq;
15 | 	dist[src] = 0;
16 | 	pq.push({0 , src});
17 |  
18 | 	//processing
19 | 	while(pq.empty() == false){
20 | 		int node = pq.top().second;
21 | 		ll d = pq.top().first;
22 | 		pq.pop();
23 | 		
24 | 		if(dist[node] < d) continue;
25 |  
26 | 		for(pair<ll,ll> edge : adj[node]){
27 | 			int v = edge.first;
28 | 			ll w = edge.second;
29 |  
30 | 			if(dist[v] > d + w){
31 | 				dist[v] = d + w;
32 | 				pq.push({dist[v] , v});
33 | 			}
34 | 		}
35 |  
36 | 	}
37 | 	
38 | }
39 |  
40 | int main(){
41 | 	int n , m , src;
42 | 	ll a , b , w;
43 | 	
44 | 	ios_base::sync_with_stdio(false);
45 | 	cin.tie(0);
46 | 	cout.tie(0);
47 |  
48 | 	cin>>n>>m , src = 1;
49 |  
50 | 	for(int i=0;i<m;i++){
51 | 		cin>>a>>b>>w;
52 | 		adj[a].push_back({b , w});
53 | 	}
54 |  
55 | 	dijkstra(n , src);
56 |  
57 | 	for(int i=1;i<=n;i++) cout<<dist[i]<<" ";
58 | }
59 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Shortest Routes II.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 |  
 5 | const ll INF = 1e15;
 6 | const int N = 500;
 7 | ll dist[N+1][N+1];
 8 |  
 9 | int main(){
10 | 	int n , m , q , a , b , c;
11 | 	
12 | 	cin>>n>>m>>q;
13 | 	for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) i == j ? dist[i][j] = 0 : dist[i][j] = INF;
14 | 	
15 | 	for(int i=1;i<=m;i++) {
16 | 		cin>>a>>b>>c;
17 | 		if(dist[a][b] > c) dist[a][b] = c , dist[b][a] = c;
18 | 	}
19 | 	
20 | 	for(int k=1;k<=n;k++){
21 | 		for(int i=1;i<=n;i++){
22 | 			for(int j=1;j<=n;j++) dist[i][j] = min(dist[i][j] , dist[i][k] + dist[k][j]);
23 | 		}
24 | 	}
25 | 	
26 | 	while(q--){
27 | 		cin>>a>>b;
28 | 		cout<<(dist[a][b] != INF ? dist[a][b] : -1)<<endl;
29 | 	}
30 | }
31 |  
32 | 


--------------------------------------------------------------------------------
/Mathematics/Binomial Coefficients.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 | 
 5 | const int N = 1e6;
 6 | const int mod = 1e9+7;
 7 | 
 8 | ll fact[N+1];
 9 | ll invFact[N+1];
10 | 
11 | ll power(ll a , ll n){
12 | 	ll res = 1;
13 | 	while(n){
14 | 		if(n & 1) res = (res * a) % mod;
15 | 
16 | 		n >>= 1;
17 | 		a = (a * a) % mod;
18 | 	}
19 | 	return res;
20 | }
21 | 
22 | void init(){
23 | 	fact[0] = invFact[0] = 1;
24 | 	for(int i=1;i<=N;i++)
25 | 	{
26 | 		fact[i] = (fact[i-1] * i) % mod;
27 | 		invFact[i] = power(fact[i] , mod-2);
28 | 	}
29 | }
30 | 
31 | ll C(int a , int b){
32 | 	ll res = (fact[a] * invFact[b]) % mod;
33 | 	   res = (res * invFact[a - b]) % mod;
34 | 
35 | 	return res;
36 | }
37 | 
38 | int main(){
39 | 	init();
40 | 
41 | 	int a , b , n;
42 | 
43 | 	cin>>n;
44 | 	while(n--){
45 | 		cin>>a>>b;
46 | 		cout<<C(a , b)<<"\n";
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/Mathematics/Bracket Sequences I.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 | const int mod = 1e9+7;
 5 | 
 6 | ll power(ll a , ll n){
 7 | 	ll res = 1;
 8 | 
 9 | 	while(n){
10 | 		if(n & 1) res = (res * a) % mod;
11 | 
12 | 		n >>= 1;
13 | 		a = (a * a) % mod;
14 | 	}
15 | 	return res;
16 | }
17 | 
18 | ll fact(ll n){
19 | 	ll res = 1;
20 | 
21 | 	for(int i=1;i<=n;i++) res = (res * i) % mod;
22 | 
23 | 	return res;
24 | }
25 | 
26 | ll catlan(ll n){
27 | 	ll res = (fact(2*n) * power(fact(n) , mod-2)) % mod;
28 | 
29 | 	return (res * power(fact(n + 1) , mod-2)) % mod;
30 | }
31 | 
32 | int main(){
33 | 	ll n;
34 | 	cin>>n;
35 | 
36 | 	if(n % 2) cout<<0;
37 | 	else
38 | 	cout<<catlan(n/2);
39 | }
40 | 


--------------------------------------------------------------------------------
/Mathematics/Christmas Party.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 | 
 5 | const int mod = 1e9+7;
 6 | 
 7 | int main(){
 8 | 	ll n;
 9 | 	cin>>n;
10 | 
11 | 	ll a = 0;
12 | 	ll b = 1;
13 | 
14 | 	for(int i=3;i<=n+1;i++){
15 | 		ll c = (((i-1) % mod) * ((a + b) % mod)) % mod;
16 | 		a = b;
17 | 		b = c;
18 | 	}
19 | 
20 | 	cout<<a;
21 | }
22 | 


--------------------------------------------------------------------------------
/Mathematics/Common Divisors.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | int ar[1000001];
 5 | int main(){
 6 | 	int n , x;
 7 | 	cin>>n;
 8 | 
 9 | 	for(int i=1;i<=n;i++) cin>>x , ar[x]++;
10 | 
11 | 	for(int i=1000000;i>=1;i--){
12 | 		int count = 0;
13 | 		for(int j=i;j<=1000000;j+=i)
14 | 		count+=ar[j];
15 | 
16 | 		if(count > 1){
17 | 			cout<<i;
18 | 			return 0;
19 | 		}
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/Mathematics/Counting Coprime Pairs.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 | 
 5 | ll ar[1000001];
 6 | int main(){
 7 | 	int n , x;
 8 | 	cin>>n;
 9 | 
10 | 	for(int i=1;i<=n;i++) cin>>x , ar[x]++;
11 | 
12 | 	for(int i=1;i<=1000000;i++){
13 | 		for(int j=i+i;j<=1000000;j+=i)
14 | 		ar[i] += ar[j];
15 | 	}
16 | 
17 | 	for(int i=1000000;i>=1;i--){
18 | 		ar[i] = (ar[i] * (ar[i]-1)) / 2;
19 | 		for(int j=i+i;j<=1000000;j+=i)
20 | 		ar[i] -= ar[j];
21 | 	}
22 | 
23 | 	cout<<ar[1];
24 | }
25 | 


--------------------------------------------------------------------------------
/Mathematics/Counting Divisors.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | const int N = 1000000;
 6 | int divSum[N+1];
 7 | 
 8 | void preproccess(){
 9 | 
10 | 	for(int i=1;i<=N;i++){
11 | 		for(int j=i;j<=N;j+=i)
12 | 		divSum[j]++;
13 | 	}
14 | }
15 | 
16 | int main(){
17 | 
18 | 	int n , m;
19 | 	cin>>n;
20 | 	preproccess();
21 | 	while(n--) cin>>m , cout<<divSum[m]<<endl;
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/Mathematics/Creating Strings II.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 | 
 5 | const int N = 1e6;
 6 | const int mod = 1e9+7;
 7 | 
 8 | ll fact[N+1];
 9 | ll invFact[N+1];
10 | 
11 | ll power(ll a , ll n){
12 | 	ll res = 1;
13 | 	while(n){
14 | 		if(n & 1) res = (res * a) % mod;
15 | 
16 | 		n >>= 1;
17 | 		a = (a * a) % mod;
18 | 	}
19 | 	return res;
20 | }
21 | 
22 | void init(){
23 | 	fact[0] = invFact[0] = 1;
24 | 	for(int i=1;i<=N;i++)
25 | 	{
26 | 		fact[i] = (fact[i-1] * i) % mod;
27 | 		invFact[i] = power(fact[i] , mod-2);
28 | 	}
29 | }
30 | 
31 | ll C(int a , int b){
32 | 	ll res = (fact[a] * invFact[b]) % mod;
33 | 	   res = (res * invFact[a - b]) % mod;
34 | 
35 | 	return res;
36 | }
37 | 
38 | int main(){
39 | 	init();
40 | 
41 | 	string st;
42 | 	cin>>st;
43 | 
44 | 	vector<int> f(26 , 0);
45 | 	for(char ch : st)
46 | 	f[ch-'a']++;
47 | 
48 | 	ll res = fact[st.size()];
49 | 
50 | 	for(int i=0;i<26;i++){
51 | 		res = (res * invFact[f[i]]) % mod;
52 | 	}
53 | 
54 | 	cout<<res;
55 | }
56 | 


--------------------------------------------------------------------------------
/Mathematics/Distributing Apples.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define ll long long
 4 | 
 5 | const int mod = 1e9+7;
 6 | 
 7 | ll fact(ll n){
 8 | 	ll res = 1;
 9 | 
10 | 	for(int i=1;i<=n;i++) res = (res * i) % mod;
11 | 
12 | 	return res;
13 | }
14 | 
15 | ll power(ll a , ll n){
16 | 	ll res = 1;
17 | 
18 | 	while(n){
19 | 		if(n & 1) res = (res * a) % mod;
20 | 
21 | 		n >>= 1;
22 | 		a = (a * a) % mod;
23 | 	}
24 | 
25 | 	return res;
26 | }
27 | 
28 | ll modInv(ll n){
29 | 	return power(n , mod-2);
30 | }
31 | 
32 | ll C(ll n , ll r){
33 | 	if(r > n) return 0;
34 | 
35 | 	ll res = fact(n);
36 | 	res = (res * modInv(fact(r))) % mod;
37 | 	res = (res * modInv(fact(n - r))) % mod;
38 | 
39 | 	return res;
40 | }
41 | 
42 | int main(){
43 | 	int n , m;
44 | 
45 | 	cin>>n>>m;
46 | 
47 | 	cout<<C(n + m - 1 , m);
48 | }
49 | 


--------------------------------------------------------------------------------
/Mathematics/Exponentiation II.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long
 3 | 
 4 | using namespace std;
 5 | 
 6 | const int MOD = 1e9+7;
 7 | 
 8 | ll power(ll a, ll n , int mod){
 9 | 	ll res = 1;
10 | 
11 | 	while(n){
12 | 		if(n & 1) res = (res * a) % mod;
13 | 
14 | 		n>>=1;
15 | 		a = (a * a) % mod;
16 | 	}
17 | 
18 | 	return res;
19 | }
20 | 
21 | int main(){
22 | 	int t;
23 | 	cin>>t;
24 | 
25 | 	while(t--){
26 | 		ll a , b , c;
27 | 		cin>>a>>b>>c;
28 | 		ll m = power(b , c , MOD-1);
29 | //		cout<<m<<endl;
30 | 		cout<<power(a , m , MOD)<<endl;
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/Mathematics/Exponentiation.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | const int mod = 1e9+7;
 5 | 
 6 | int main(){
 7 | 	int t;
 8 | 	cin>>t;
 9 | 
10 | 	while(t--){
11 | 		long long int a , n , res = 1;
12 | 
13 | 		cin>>a>>n;
14 | 
15 | 		while(n){
16 | 			if(n & 1) res = (res * a)%mod;
17 | 
18 | 			n >>= 1;
19 | 			a = (a * a) % mod;
20 | 		}
21 | 
22 | 		cout<<res<<endl;
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/Mathematics/Prime Multiples.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 | 
 5 | ll res;
 6 | ll ar[21];
 7 | 
 8 | ll getCount(ll mask , ll k , ll n){
 9 | 	ll sum = 0;
10 | 	int count = 0;
11 | 	ll prod = 1;
12 | 
13 | 	for(int i=0;i<k;i++)
14 | 	if(mask & (1<<i)){
15 | 		count++;
16 | 
17 | 		if(n / ar[i] < prod) return 0;
18 | 
19 | 		prod *= ar[i];
20 | 	}
21 | 	sum = n / prod;
22 | 	return count % 2 ? sum : -sum;
23 | }
24 | 
25 | int main(){
26 | 	ll n , k;
27 | 	cin>>n>>k;
28 | 
29 | 	for(int i=0;i<k;i++) cin>>ar[i];
30 | 
31 | 	ll mask = 1;
32 | 
33 | 	while(mask < (1<<k)){
34 | 		res += getCount(mask , k , n);
35 | 		mask++;
36 | 	}
37 | 
38 | 	cout<<res;
39 | }
40 | 


--------------------------------------------------------------------------------
/Mathematics/Sum of Divisors.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define ll long long int
 4 | 
 5 | const int mod = 1e9+7;
 6 | 
 7 | long long res = 0;
 8 | 
 9 | long long firstHalf(long long n){
10 | 	long long i = 1;
11 | 	while(i*i <= n){
12 | 		long long temp = ((i % mod) * ((n/i) % mod)) % mod;
13 | 		res = (res + temp) % mod;
14 | 		i++;
15 | 	}
16 | 
17 | 	return i;
18 | }
19 | 
20 | long long getSum(long long L , long long R){
21 | 	L--;
22 | 	R = ((R % mod) * ((R + 1) % mod)) / 2;
23 | 	L = ((L % mod) * ((L + 1) % mod)) / 2;
24 | 	long long res = (R - L) % mod;
25 | 	if(res < 0) res += mod;
26 | 	return res;
27 | }
28 | 
29 | int main(){
30 | 	long long n;
31 | 	cin>>n;
32 | 
33 | 	long long L = firstHalf(n);
34 | 	long long curr = n / L;
35 | 
36 | 	while(L <= n){
37 | 		long long count = n / curr - n / (curr+1);
38 | 		long long R = L + count - 1;
39 | 
40 | 		long long temp = ((curr % mod) * getSum(L , R)) % mod;
41 | 		res = (res + temp) % mod;
42 | 
43 | 		L = R + 1 , curr--;
44 | 	}
45 | 
46 | 	cout<<res;
47 | }
48 | 


--------------------------------------------------------------------------------
/Range Queries/Dynamic Range Minimum Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 2000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int N = 200001;
19 | lli ar[N];
20 | lli st[4*N];
21 |  
22 | int build(int si , int ss , int se)
23 | {
24 | 	if(ss == se) return st[si] = ar[ss];
25 | 	
26 | 	int mid = (ss + se) >> 1;
27 | 	
28 | 	return st[si] = min(build(2*si , ss , mid) , build(2*si+1 , mid+1 , se));
29 | }
30 |  
31 | void update(int si , int ss , int se , int idx , lli value)
32 | {
33 | 	if(idx > se || idx < ss) return;
34 | 	
35 | 	if(ss == se && ss == idx){
36 | 		st[si] = value;
37 | 		return;
38 | 	}
39 | 	
40 | 	int mid = (ss + se) >> 1;
41 | 	update(2*si , ss , mid , idx , value);
42 | 	update(2*si+1 , mid+1 , se , idx , value);
43 | 	st[si] = min(st[2*si] , st[2*si+1]);
44 | }
45 |  
46 | int getMin(int si , int ss , int se , int l , int r)
47 | {
48 | 	if(l > se || r < ss) return INF;
49 | 	
50 | 	if(ss >= l && se <= r) return st[si];
51 | 	
52 | 	int mid = (ss + se) >> 1;
53 | 	return min(getMin(2*si , ss , mid , l , r) , getMin(2*si+1 , mid+1 , se , l , r));
54 | }
55 |  
56 | int main()
57 | {
58 | 	int n , q , a , b;
59 | 	cin>>n>>q;
60 | 	
61 | 	REP(i , n) cin>>ar[i];
62 | 	
63 | 	build(1 , 1 , n);
64 | 	while(q--)
65 | 	{
66 | 		int code;
67 | 		cin>>code>>a>>b;
68 | 		if(code == 1) update(1 , 1 , n , a , b);
69 | 		else		  cout<<getMin(1 , 1 , n , a , b)<<endl;
70 | 	}
71 | }
72 |  
73 | 


--------------------------------------------------------------------------------
/Range Queries/Dynamic Range Sum Queries.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=r-fJF9D2Fg0&list=PL2q4fbVm1Ik7RiRG7KnHjxmblwFEGfVdR&index=5
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 2000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | const int N = 200001;
21 | lli ar[N];
22 | lli st[4*N];
23 |  
24 | lli build(int si , int ss , int se)
25 | {
26 | 	if(ss == se) return st[si] = ar[ss];
27 | 	
28 | 	int mid = (ss + se) >> 1;
29 | 	
30 | 	return st[si] = build(2*si , ss , mid) + build(2*si+1 , mid+1 , se);
31 | }
32 |  
33 | void update(int si , int ss , int se , int idx , lli value)
34 | {
35 | 	if(idx > se || idx < ss) return;
36 | 	
37 | 	if(ss == se && ss == idx){
38 | 		st[si] += value;
39 | 		return;
40 | 	}
41 | 	
42 | 	int mid = (ss + se) >> 1;
43 | 	update(2*si , ss , mid , idx , value);
44 | 	update(2*si+1 , mid+1 , se , idx , value);
45 | 	st[si] = st[2*si] + st[2*si+1];
46 | }
47 |  
48 | lli getSum(int si , int ss , int se , int l , int r)
49 | {
50 | 	if(l > se || r < ss) return 0;
51 | 	
52 | 	if(ss >= l && se <= r) return st[si];
53 | 	
54 | 	int mid = (ss + se) >> 1;
55 | 	return getSum(2*si , ss , mid , l , r) + getSum(2*si+1 , mid+1 , se , l , r);
56 | }
57 |  
58 | int main()
59 | {
60 | 	int n , q , a , b;
61 | 	cin>>n>>q;
62 | 	
63 | 	REP(i , n) cin>>ar[i];
64 | 	
65 | 	build(1 , 1 , n);
66 | 	while(q--)
67 | 	{
68 | 		int code;
69 | 		cin>>code>>a>>b;
70 | 		if(code == 1) update(1 , 1 , n , a , b - ar[a]) , ar[a] = b;
71 | 		else		  cout<<getSum(1 , 1 , n , a , b)<<endl;
72 | 	}
73 | }
74 |  
75 | 


--------------------------------------------------------------------------------
/Range Queries/Forest Queries.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=ONDFFcD6GXc&list=PL2q4fbVm1Ik7RiRG7KnHjxmblwFEGfVdR&index=3
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | const int N = 1001;
21 | lli ar[N][N];
22 |  
23 | lli getAns(int sx , int sy , int ex , int ey)
24 | {
25 | 	return ar[ex][ey] - ar[sx-1][ey] - ar[ex][sy-1] + ar[sx-1][sy-1];
26 | }
27 | int main()
28 | {
29 | 	int n , q;
30 | 	int a , b , c , d;
31 | 	char ch;
32 | 	
33 | 	cin>>n>>q;
34 | 	
35 | 	REP(i , n) REP(j , n) cin>>ch , ar[i][j] = ch =='*' , ar[i][j] += ar[i][j-1];
36 | 	REP(i , n) REP(j , n) ar[i][j] += ar[i-1][j];
37 | 	
38 | 	while(q--)
39 | 	cin>>a>>b>>c>>d , cout<<getAns(a , b , c , d)<<endl;
40 | }
41 |  
42 | 


--------------------------------------------------------------------------------
/Range Queries/Hotel Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int MAXN = 200001;
19 |  
20 | int n;
21 | int segtree[4 * MAXN], a[MAXN];
22 |  
23 | void build(int l = 1, int r = n, int node = 1) {
24 | 	if (l == r) segtree[node] = a[l];
25 | 	else {
26 | 		int mid = (l + r) / 2;
27 | 		build(l, mid, node * 2);
28 | 		build(mid + 1, r, node * 2 + 1);
29 | 		segtree[node] = max(segtree[node * 2], segtree[node * 2 + 1]);
30 | 	}
31 | }
32 |  
33 | void queryupdate(int val, int l = 1, int r = n, int node = 1) {
34 | 	if (l == r) {
35 | 		segtree[node] -= val;
36 | 		cout << l << ' ';
37 | 	} else {
38 | 		int mid = (l + r) / 2;
39 | 		if (segtree[node * 2] >= val) queryupdate(val, l, mid, node * 2);
40 | 		else queryupdate(val, mid + 1, r, node * 2 + 1);
41 |  
42 | 		segtree[node] = max(segtree[node * 2], segtree[node * 2 + 1]);
43 | 	}
44 | }
45 |  
46 | int main() {
47 | 	iostream::sync_with_stdio(false);
48 | 	cin.tie(0);
49 | 	int q;
50 | 	cin >> n >> q;
51 | 	for (int i = 1; i <= n; i++) cin >> a[i];
52 | 	build();
53 |  
54 | 	while (q--) {
55 | 		int x;
56 | 		cin >> x;
57 | 		if (segtree[1] < x) cout << "0 ";
58 | 		else queryupdate(x);
59 | 	}
60 | 	return 0;
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/Range Queries/List Removals.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int N = 200001;
19 |  
20 | int st[4*N];
21 | int ar[N];
22 | int res;
23 |  
24 | int build(int si , int ss ,int se)
25 | {
26 | 	if(ss == se) return st[si] = 1;
27 | 	
28 | 	int mid = (ss + se) / 2;
29 | 	return st[si] = build(2*si , ss , mid) + build(2*si + 1, mid + 1 , se);
30 | }
31 |  
32 | void update(int si , int ss , int se , int val)
33 | {
34 | 	if(ss == se)
35 | 	{
36 | 		res = ss;
37 | 		st[si] = 0;
38 | 		return;
39 | 	}
40 | 	
41 | 	int mid = (ss + se) / 2;
42 | 	if(st[2*si] >= val) update(2*si , ss , mid , val);
43 | 	else				update(2*si + 1 , mid + 1 , se , val - st[2*si]);
44 | 	
45 | 	st[si] = st[2*si] + st[2*si+1];
46 | }
47 |  
48 | int main()
49 | {
50 | 	int n , a;
51 | 	cin>>n;
52 | 	REP(i , n) cin>>ar[i];
53 | 	
54 | 	build(1 , 1 , n);
55 | 	
56 | 	REP(i , n)
57 | 	{
58 | 		cin>>a;
59 | 		update(1 , 1 , n , a);
60 | 		cout<<ar[res]<<" ";
61 | 	}
62 | }
63 |  
64 | 


--------------------------------------------------------------------------------
/Range Queries/Pizzeria Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 |  
 5 | const int N = 2e5;
 6 | const int INF = 1e9;
 7 | int ar[N+1];
 8 | int pre[4*N] , suff[4*N];
 9 |  
10 | void build(int si , int ss , int se){
11 | 	if(ss == se){
12 | 		pre[si] = ar[ss] - ss;
13 | 		suff[si] = ar[ss] + ss;
14 | 		return;
15 | 	}
16 | 	
17 | 	int mid = (ss + se) / 2;
18 | 	build(2*si , ss , mid);
19 | 	build(2*si + 1 , mid + 1 , se);
20 | 	pre[si] = min(pre[2*si] , pre[2*si+1]);
21 | 	suff[si] = min(suff[2*si] , suff[2*si+1]);
22 | }
23 |  
24 | void update(int si , int ss , int se , int qi , int val){
25 | 	if(ss > qi || se < qi) return;
26 | 	
27 | 	if(ss == se && ss == qi){
28 | 		ar[ss] = val;
29 | 		pre[si] = val - ss;
30 | 		suff[si] = val + ss;
31 | 		return;
32 | 	}
33 | 	
34 | 	int mid = (ss + se) / 2;
35 | 	update(2*si , ss , mid , qi , val);
36 | 	update(2*si+1 , mid+1 , se , qi , val);
37 | 	pre[si] = min(pre[2*si] , pre[2*si+1]);
38 | 	suff[si] = min(suff[2*si] , suff[2*si+1]);
39 | }
40 |  
41 | int getMin(int si , int ss , int se , int qs , int qe , int st[]){
42 | 	if(ss > qe || se < qs) return INF;
43 | 	
44 | 	if(ss>=qs && se<=qe) return st[si];
45 | 	
46 | 	int mid = (ss + se) / 2;
47 | 	
48 | 	return min(getMin(2*si , ss , mid , qs , qe , st) ,
49 | 			   getMin(2*si+1 , mid+1 , se , qs , qe , st));
50 | }
51 |  
52 | int main(){
53 | 	int n , q;
54 | 	int code , a , b;
55 | 	
56 | 	cin>>n>>q;
57 | 	for(int i=1;i<=n;i++) cin>>ar[i];
58 | 	build(1 , 1 , n);
59 | 	
60 | 	while(q--){
61 | 		cin>>code;
62 | 		if(code == 1){
63 | 			cin>>a>>b;
64 | 			update(1 , 1 , n , a , b);
65 | 		}
66 | 		else{
67 | 			cin>>a;
68 | 			int L = getMin(1 , 1 , n , 1 , a , pre) + a;
69 | 			int R = getMin(1 , 1 , n , a , n , suff) - a;
70 | 			cout<<min(L , R)<<endl;
71 | 		}
72 | 	}
73 | }
74 |  
75 | 


--------------------------------------------------------------------------------
/Range Queries/Prefix Sum Queries.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=LC4I9xaEW_Q&list=PL2q4fbVm1Ik7RiRG7KnHjxmblwFEGfVdR&index=6
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define ll long long int
 5 | using namespace std;
 6 | struct Node{
 7 | 	ll prefix;
 8 | 	ll sum;
 9 | };
10 |  
11 | const int N = 2e5;
12 | Node st[4*N];
13 | int ar[N+1];
14 |  
15 | void mergeResult(int si){
16 | 	st[si].sum = st[2*si].sum + st[2*si+1].sum;
17 | 	st[si].prefix = max(st[2*si].prefix , st[2*si].sum + st[2*si+1].prefix);
18 | }
19 |  
20 | void build(int si , int ss , int se){
21 | 	if(ss == se){
22 | 		st[si].prefix = st[si].sum = ar[ss];
23 | 		return;
24 | 	}
25 | 	
26 | 	int mid = (ss + se) / 2;
27 | 	build(2*si     , ss    , mid);
28 | 	build(2*si + 1 , mid+1 , se);
29 | 	mergeResult(si);
30 | }
31 |  
32 | void update(int si , int ss , int se , int qi , int val){
33 | 	if(qi < ss || qi > se) return;
34 | 	
35 | 	if(ss == se && ss == qi){
36 | 		st[si].sum = st[si].prefix = ar[ss] = val;
37 | 		return;
38 | 	}
39 | 	
40 | 	int mid = (ss + se) / 2;
41 | 	update(2*si , ss , mid , qi , val);
42 | 	update(2*si+1 , mid+1 , se , qi , val);
43 | 	mergeResult(si);
44 | }
45 |  
46 | Node maxProfit(int si , int ss , int se , int L ,int R){
47 | 	if(ss > R || se < L){
48 | 		Node temp;
49 | 		temp.prefix = temp.sum = 0;
50 | 		return temp;
51 | 	}
52 | 	
53 | 	if(ss >= L && se <= R) return st[si];
54 | 	
55 | 	int mid = (ss + se) / 2;
56 | 	Node l = maxProfit(2*si , ss , mid , L , R);
57 | 	Node r = maxProfit(2*si + 1 , mid + 1 , se , L , R);
58 | 	Node res;
59 | 	res.sum = l.sum + r.sum;
60 | 	res.prefix = max(l.prefix , l.sum + r.prefix);
61 | 	return res;
62 | }
63 |  
64 | int main(){
65 | 	int n , q , k , u , a , b;
66 | 	cin>>n>>q;
67 | 	
68 | 	for(int i=1;i<=n;i++) cin>>ar[i];
69 | 	build(1 , 1 , n);
70 | 	
71 | 	while(q--){
72 | 		int code;
73 | 		cin>>code;
74 | 		if(code == 1){
75 | 			cin>>k>>u;
76 | 			update(1 , 1 , n , k , u);
77 | 		}
78 | 		else{
79 | 			cin>>a>>b;
80 | 			cout<<max(0LL , maxProfit(1 , 1 , n , a , b).prefix)<<endl;
81 | 		}
82 | 	}
83 | }
84 |  
85 | 


--------------------------------------------------------------------------------
/Range Queries/Range Update Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 2000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int N = 200001;
19 | lli ar[N];
20 | lli st[4*N];
21 | lli lazy[5*N];
22 |  
23 | lli build(int si , int ss , int se)
24 | {
25 | 	if(ss == se) return st[si] = ar[ss];
26 | 	
27 | 	int mid = (ss + se) >> 1;
28 | 	
29 | 	return st[si] = build(2*si , ss , mid) + build(2*si+1 , mid+1 , se);
30 | }
31 |  
32 | void clearLazy(int si)
33 | {
34 | 	st[si] += lazy[si];
35 | 	lazy[2*si] += lazy[si];
36 | 	lazy[2*si+1] += lazy[si];
37 | 	lazy[si] = 0;
38 | }
39 |  
40 | void addLazy(int si , lli value)
41 | {
42 | 	lazy[2*si] += value;
43 | 	lazy[2*si+1] += value;
44 | }
45 |  
46 | void update(int si , int ss , int se , int l , int r , lli value)
47 | {
48 | 	clearLazy(si);
49 | 	if(l > se || r < ss) return;
50 | 	
51 | 	if(ss >= l && se <= r){
52 | 		st[si] += value;
53 | 		addLazy(si , value);
54 | 		return;
55 | 	}
56 | 	
57 | 	int mid = (ss + se) >> 1;
58 | 	update(2*si , ss , mid , l , r , value);
59 | 	update(2*si+1 , mid+1 , se , l , r , value);
60 | 	st[si] = st[2*si] + st[2*si+1];
61 | }
62 |  
63 | lli getSum(int si , int ss , int se , int l , int r)
64 | {
65 | 	clearLazy(si);
66 | 	if(l > se || r < ss) return 0;
67 | 	
68 | 	if(ss >= l && se <= r) return st[si];
69 | 	
70 | 	int mid = (ss + se) >> 1;
71 | 	return getSum(2*si , ss , mid , l , r) + getSum(2*si+1 , mid+1 , se , l , r);
72 | }
73 |  
74 | int main()
75 | {
76 | 	int n , q , a , b;
77 | 	lli dx;
78 | 	cin>>n>>q;
79 | 	
80 | 	REP(i , n) cin>>ar[i];
81 | 	
82 | 	build(1 , 1 , n);
83 | 	while(q--)
84 | 	{
85 | 		int code;
86 | 		cin>>code;
87 | 		if(code == 1) cin>>a>>b>>dx , update(1 , 1 , n , a , b , dx);
88 | 		else		  cin>>a , cout<<getSum(1 , 1 , n , a , a)<<endl;
89 | 	}
90 | }
91 |  
92 | 


--------------------------------------------------------------------------------
/Range Queries/Range Xor Queries.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=INkL6KOQTHc&list=PL2q4fbVm1Ik7RiRG7KnHjxmblwFEGfVdR&index=1
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | const int N = 200001;
21 | lli ar[N];
22 |  
23 | int main()
24 | {
25 | 	int n , q , a , b;
26 | 	cin>>n>>q;
27 | 	
28 | 	REP(i , n) cin>>ar[i] , ar[i] ^= ar[i-1];
29 | 	
30 | 	while(q--)
31 | 	{
32 | 		cin>>a>>b;
33 | 		cout<<(ar[b] ^ ar[a-1])<<endl;
34 | 	}
35 | }
36 |  
37 | 


--------------------------------------------------------------------------------
/Range Queries/Salary Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int N = 200001;
19 | const int MX = 4e5 + 5;
20 | struct Query{
21 | 	char t;
22 | 	int a;
23 | 	int b;
24 | };
25 |  
26 | int ar[N];
27 | vi val;
28 | Query q[N];
29 | lli BIT[MX];
30 |  
31 | void update(int i , lli dx){
32 | 	while(i <= MX)
33 | 	{
34 | 		BIT[i] += dx;
35 | 		i += (i & -i);
36 | 	}
37 | }
38 |  
39 | lli sum(int i)
40 | {
41 | 	lli res = 0;
42 | 	while(i > 0)
43 | 	{
44 | 		res += BIT[i];
45 | 		i -= (i & -i);
46 | 	}
47 | 	
48 | 	return res;
49 | }
50 |  
51 | int position(int x)
52 | {
53 | 	int ind = upper_bound(val.begin(), val.end(), x) - val.begin();
54 | 	
55 | 	return ind;
56 | }
57 |  
58 | int main()
59 | {
60 | 	int n , t , a , b;
61 | 	cin>>n>>t;
62 | 	REP(i , n) cin>>ar[i] , val.pb(ar[i]);
63 | 	
64 | 	REP(i , t)
65 | 	{
66 | 		cin>>q[i].t>>q[i].a>>q[i].b;
67 | 		
68 | 		if(q[i].t == '!') val.pb(q[i].b);
69 | 	}
70 | 	
71 | 	sort(val.begin() , val.end());
72 | 	val.erase(unique(val.begin() , val.end()) , val.end());
73 | 	
74 | 	
75 | 	REP(i , n) update(position(ar[i]) , 1);
76 | 	
77 | 	REP(i , t)
78 | 	{
79 | 		if(q[i].t == '?') cout<<sum(position(q[i].b)) - sum(position(q[i].a - 1))<<endl;
80 | 		else{
81 | 			update(position(ar[q[i].a]) , -1);
82 | 			ar[q[i].a] = q[i].b;
83 | 			update(position(ar[q[i].a]) , 1);
84 | 		}
85 | 	}
86 | 	
87 | }
88 |  
89 | 


--------------------------------------------------------------------------------
/Range Queries/Static Range Minimum Queries.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=0I0OTTHtxIw&list=PL2q4fbVm1Ik7RiRG7KnHjxmblwFEGfVdR&index=4
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 2000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | const int N = 200001;
21 | int ar[N];
22 | int st[4*N];
23 |  
24 | int build(int si , int ss , int se)
25 | {
26 | 	if(ss == se) return st[si] = ar[ss];
27 | 	
28 | 	int mid = (ss + se) >> 1;
29 | 	
30 | 	return st[si] = min(build(2*si , ss , mid) , build(2*si+1 , mid+1 , se));
31 | }
32 |  
33 | int getMin(int si , int ss , int se , int l , int r)
34 | {
35 | 	if(l > se || r < ss) return INF;
36 | 	
37 | 	if(ss >= l && se <= r) return st[si];
38 | 	
39 | 	int mid = (ss + se) >> 1;
40 | 	return min(getMin(2*si , ss , mid , l , r) , getMin(2*si+1 , mid+1 , se , l , r));
41 | }
42 |  
43 | int main()
44 | {
45 | 	int n , q , a , b;
46 | 	cin>>n>>q;
47 | 	
48 | 	REP(i , n) cin>>ar[i];
49 | 	
50 | 	build(1 , 1 , n);
51 | 	while(q--)
52 | 	{
53 | 		cin>>a>>b;
54 | 		cout<<getMin(1 , 1 , n , a , b)<<endl;
55 | 	}
56 | }
57 |  
58 | 


--------------------------------------------------------------------------------
/Range Queries/Static Range Sum Queries.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=n1hCcWAOjrs&list=PL2q4fbVm1Ik7RiRG7KnHjxmblwFEGfVdR&index=2
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | const int N = 200001;
21 | lli ar[N];
22 |  
23 | int main()
24 | {
25 | 	int n , q , a , b;
26 | 	cin>>n>>q;
27 | 	
28 | 	REP(i , n) cin>>ar[i] , ar[i] += ar[i-1];
29 | 	
30 | 	while(q--)
31 | 	{
32 | 		cin>>a>>b;
33 | 		cout<<ar[b] - ar[a-1]<<endl;
34 | 	}
35 | }
36 |  
37 |  
38 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Company Queries I.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int maxN = 21;
19 | vi ar[200001];
20 | int dp[200001][maxN];
21 | int n;
22 |  
23 | void preprocess()
24 | {
25 | 	for(int i=1;i<maxN;i++)
26 | 	{
27 | 		for(int j=1;j<=n;j++)
28 | 		{
29 | 			int par = dp[j][i-1];
30 | 			
31 | 			if(par == -1) continue;
32 | 			else
33 | 			dp[j][i] = dp[par][i-1];
34 | 		}
35 | 	}
36 | }
37 |  
38 | int getKthPar(int node , int k)
39 | {
40 | 	int i = 0;
41 | 	
42 | 	while(i < maxN)
43 | 	{
44 | 		if( (k & (1 << i)) && (dp[node][i] != -1))
45 | 		node = dp[node][i] , k -= (1 << i);
46 | 		
47 | 		i++;
48 | 	}
49 | 	
50 | 	if(k > 0) node = -1;
51 | 	return node;
52 | }
53 |  
54 | int main()
55 | {
56 | 	int q , a , k;
57 | 	cin>>n>>q;
58 | 	
59 | 	memset(dp , -1 , sizeof dp);
60 | 	for(int i=2;i<=n;i++) cin>>a , dp[i][0] = a;
61 | 	
62 | 	preprocess();
63 | 	
64 | 	while(q--)
65 | 	{
66 | 		cin>>a>>k;
67 | 		
68 | 		cout<<getKthPar(a , k)<<endl;
69 | 	}
70 | }
71 |  
72 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Company Queries II.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=gr4ufl8K4Lo&list=PL2q4fbVm1Ik534C0_A2JrVeXaNxgi3D3V&index=7
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | const int maxN = 21;
21 | vi ar[200001];
22 | int dp[200001][maxN];
23 | int level[200001];
24 | int n;
25 |  
26 | void dfs(int node , int lvl)
27 | {
28 | 	level[node] = lvl;
29 | 	
30 | 	for(int child : ar[node])
31 | 	dfs(child , lvl + 1);
32 | }
33 |  
34 | void preprocess()
35 | {
36 | 	for(int i=1;i<maxN;i++)
37 | 	{
38 | 		for(int j=1;j<=n;j++)
39 | 		{
40 | 			int par = dp[j][i-1];
41 | 			
42 | 			if(par == -1) continue;
43 | 			else
44 | 			dp[j][i] = dp[par][i-1];
45 | 		}
46 | 	}
47 | }
48 |  
49 | int LCA(int a , int b)
50 | {
51 | 	if(level[a] < level[b]) swap(a , b);
52 | 	
53 | 	int d = level[a] - level[b];
54 | 	
55 | 	while(d > 0)
56 | 	{
57 | 		int i = log2(d);
58 | 		a = dp[a][i];
59 | 		d -= (1 << i);
60 | 	}
61 | 	
62 | 	if(a == b) return a;
63 | 	
64 | 	for(int i=maxN-1;i>=0;i--)
65 | 	if(dp[a][i] != -1 && (dp[a][i] != dp[b][i]))
66 | 	{
67 | 		a = dp[a][i];
68 | 		b = dp[b][i];
69 | 	}
70 | 	
71 | 	return dp[a][0];
72 | }
73 |  
74 | int main()
75 | {
76 | 	int q , a , b;
77 | 	cin>>n>>q;
78 | 	
79 | 	memset(dp , -1 , sizeof dp);
80 | 	for(int i=2;i<=n;i++) cin>>a , dp[i][0] = a , ar[a].pb(i);
81 | 	
82 | 	dfs(1 , 0);
83 | 	preprocess();
84 | 	
85 | 	while(q--)
86 | 	{
87 | 		cin>>a>>b;
88 | 		
89 | 		cout<<LCA(a , b)<<endl;
90 | 	}
91 | }
92 |  
93 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Counting Paths.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | #define REP(i,n) for (int i = 1; i <= n; i++)
  3 | #define mod 1000000007
  4 | #define pb push_back
  5 | #define ff first
  6 | #define ss second
  7 | #define ii pair<int,int>
  8 | #define vi vector<int>
  9 | #define vii vector<ii>
 10 | #define lli long long int
 11 | #define INF 1000000000
 12 | #define endl '\n'
 13 | const double PI = 3.141592653589793238460;
 14 | typedef std::complex<double> Complex;
 15 | typedef std::valarray<Complex> CArray;
 16 | using namespace std;
 17 |  
 18 | const int N = 200001;
 19 | const int maxN = 21;
 20 |  
 21 | vi ar[N];
 22 | int br[N];
 23 | int in[N];
 24 | int sub[N];
 25 | int level[N];
 26 | int LCA[N][maxN];
 27 | int _t = 1;
 28 | lli res[N];
 29 |  
 30 | void dfs(int node , int par , int lvl)
 31 | {
 32 | 	br[_t] = node;
 33 | 	in[node] = _t++;
 34 | 	sub[node] = 1;
 35 | 	level[node] = lvl;
 36 | 	LCA[node][0] = par;
 37 | 	
 38 | 	for(int child : ar[node])
 39 | 	if(child != par)
 40 | 	dfs(child , node , lvl + 1) , sub[node] += sub[child];
 41 | 	
 42 | }
 43 |  
 44 | void preProcess(int n)
 45 | {
 46 | 	for(int j=1;j<maxN;j++)
 47 | 	{
 48 | 		for(int i=1;i<=n;i++)
 49 | 		if(LCA[i][j-1] != -1)
 50 | 		{
 51 | 			LCA[i][j] = LCA[LCA[i][j-1]][j-1];
 52 | 		}
 53 | 	}
 54 | }
 55 |  
 56 | int getLCA(int a, int b)
 57 | {
 58 | 	if(level[a] > level[b])
 59 | 		swap(a , b);
 60 | 		
 61 | 	int d = level[b] - level[a];
 62 | 	
 63 | 	for(int i=0; i<maxN; i++) if( (d>>i)&1 ) b = LCA[b][i];
 64 | 	
 65 | 	if(a == b)
 66 | 		return a;
 67 | 		
 68 | 	for(int i=maxN-1;i>=0;i--)
 69 | 	if(LCA[a][i] != LCA[b][i])
 70 | 		a = LCA[a][i] , b = LCA[b][i];
 71 | 	
 72 | 	return LCA[a][0];
 73 | }
 74 |  
 75 | int main()
 76 | {
 77 | 	int n , m , a , b;
 78 | 	cin>>n>>m;
 79 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
 80 | 	
 81 | 	memset(LCA , -1 , sizeof LCA);
 82 | 	dfs(1 , 0 , 0);
 83 | 	LCA[1][0] = -1;
 84 | 	preProcess(n);
 85 | 	
 86 | 	while(m--)
 87 | 	{
 88 | 		cin>>a>>b;
 89 | 		if(level[a] > level[b]) swap(a , b);
 90 | 		int lca = getLCA(a , b);
 91 | 		int lcaPar = LCA[lca][0];
 92 | 		
 93 | 		if(lca == a)
 94 | 		{
 95 | 			res[in[lcaPar]]--;
 96 | 			res[in[b]]++;
 97 | 		}
 98 | 		else
 99 | 		{
100 | 			res[in[a]]++;
101 | 			res[in[b]]++;
102 | 			res[in[lca]]--;
103 | 			res[in[lcaPar]]--;
104 | 		}
105 | 	}
106 | 	
107 | 	
108 | 	lli ans = 0;
109 | 	res[0] = 0;
110 | 	REP(i , n) res[i] += res[i-1];
111 | 	
112 | 	
113 | 	REP(i , n)
114 | 	{
115 | 		int l = in[i];
116 | 		int dx = sub[i];
117 | 		
118 | 		cout<<res[l+dx-1] - res[l - 1]<<" ";
119 | 	}
120 | }
121 |  
122 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Distance Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int maxN = 21;
19 | vi ar[200001];
20 | int dp[200001][maxN];
21 | int level[200001];
22 | int n;
23 |  
24 | void dfs(int node , int par , int lvl)
25 | {
26 | 	level[node] = lvl;
27 | 	dp[node][0] = par;
28 | 	
29 | 	for(int child : ar[node])
30 | 	if(child != par)
31 | 	dfs(child , node , lvl + 1);
32 | }
33 |  
34 | void preprocess()
35 | {
36 | 	for(int i=1;i<maxN;i++)
37 | 	{
38 | 		for(int j=1;j<=n;j++)
39 | 		{
40 | 			int par = dp[j][i-1];
41 | 			
42 | 			if(par == -1) continue;
43 | 			else
44 | 			dp[j][i] = dp[par][i-1];
45 | 		}
46 | 	}
47 | }
48 |  
49 | int LCA(int a , int b)
50 | {
51 | 	if(level[a] < level[b]) swap(a , b);
52 | 	
53 | 	int d = level[a] - level[b];
54 | 	
55 | 	while(d > 0)
56 | 	{
57 | 		int i = log2(d);
58 | 		a = dp[a][i];
59 | 		d -= (1 << i);
60 | 	}
61 | 	
62 | 	if(a == b) return a;
63 | 	
64 | 	for(int i=maxN-1;i>=0;i--)
65 | 	if(dp[a][i] != -1 && (dp[a][i] != dp[b][i]))
66 | 	{
67 | 		a = dp[a][i];
68 | 		b = dp[b][i];
69 | 	}
70 | 	
71 | 	return dp[a][0];
72 | }
73 |  
74 | int main()
75 | {
76 | 	int q , a , b;
77 | 	cin>>n>>q;
78 | 	
79 | 	memset(dp , -1 , sizeof dp);
80 | 	for(int i=2;i<=n;i++) cin>>a>>b , ar[b].pb(a) , ar[a].pb(b);
81 | 	
82 | 	dfs(1 , -1 , 0);
83 | 	preprocess();
84 | 	
85 | 	while(q--)
86 | 	{
87 | 		cin>>a>>b;
88 | 		int lca = LCA(a , b);
89 | 		cout<<level[a] + level[b] - 2*level[lca]<<endl;
90 | 	}
91 | }
92 |  
93 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Distinct Colors.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=VcXWYo7V9KA&list=PL2q4fbVm1Ik534C0_A2JrVeXaNxgi3D3V&index=3
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | int c[200002];
21 | int res[200001];
22 | vi ar[200002];
23 | set<int> *st[200001];
24 |  
25 | void dfs(int node, int par)
26 | {
27 | 	int mx = 0;
28 | 	int mxNode = -1;
29 | 	
30 | 	for(int child : ar[node])
31 | 	if(child != par)
32 | 	{
33 | 		dfs(child , node);
34 | 		if( st[child]->size() > mx )
35 | 		mx = st[child]->size() , mxNode = child;
36 | 	}
37 | 	
38 | 	if(mxNode == -1) st[node] = new set<int>();
39 | 	else			 st[node] = st[mxNode];
40 | 	
41 | 	st[node] -> insert(c[node]);
42 | 	
43 | 	for(int child : ar[node])
44 | 	if(child != par && child != mxNode)
45 | 	{
46 | 		for(int color : *st[child])
47 | 		st[node]->insert(color);
48 | 	}
49 | 	
50 | 	res[node] = st[node] -> size();
51 | }
52 |  
53 | int main()
54 | {
55 | 	int n , a , b;
56 | 	cin>>n;
57 | 	REP(i , n) cin>>c[i];
58 | 	
59 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
60 | 	
61 | 	dfs(1 , -1);
62 | 	
63 | 	REP(i , n) cout<<res[i]<<" ";
64 | }
65 |  
66 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Finding a Centroid.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=0DJwKePjweQ&list=PL2q4fbVm1Ik534C0_A2JrVeXaNxgi3D3V&index=1
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | int sub[200001];
21 | int n;
22 | vi ar[200001];
23 |  
24 | void subSize(int node ,int par)
25 | {
26 | 	sub[node] = 1;
27 | 	
28 | 	for(int child : ar[node])
29 | 	if(child != par)
30 | 	{
31 | 		subSize(child , node);
32 | 		sub[node] += sub[child];
33 | 	}
34 | }
35 |  
36 | int centroid(int node , int par)
37 | {
38 | 	for(int child : ar[node])
39 | 	if(child != par && sub[child] > n/2) return centroid(child , node);
40 | 	
41 | 	return node;
42 | }
43 |  
44 | int main()
45 | {
46 | 	int a , b;
47 | 	cin>>n;
48 | 	
49 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
50 | 	
51 | 	subSize(1 , -1);
52 | 	cout<<centroid(1 , -1);
53 | }
54 |  
55 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Fixed-Length Paths I.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int N = 200001;
19 |  
20 | int sub[N];
21 | int cnt[N];
22 | bool vis[N];
23 | vi ar[N];
24 | lli res;
25 | int n;
26 | int k;
27 | int mxHeight;
28 |  
29 | int subSize(int node , int par)
30 | {
31 | 	sub[node] = 1;
32 | 	
33 | 	for(int child : ar[node])
34 | 	if(child != par && vis[child] == false)
35 | 	sub[node] += subSize(child , node);
36 | 	
37 | 	return sub[node];
38 | }
39 |  
40 | int centroid(int node , int par , int limit)
41 | {
42 | 	for(int child : ar[node])
43 | 	if(child != par && vis[child] == false && sub[child] >= limit)
44 | 	return centroid(child , node , limit);
45 | 	
46 | 	return node;
47 | }
48 |  
49 | void update(int node , int par , bool add , int lvl = 1)
50 | {
51 | 	if(lvl > k) return;
52 | 	
53 | 	if(add)  cnt[lvl]++;
54 | 	else	 res += cnt[k - lvl];
55 | 	mxHeight = max(mxHeight , lvl);
56 | 	
57 | 	for(int child : ar[node])
58 | 	if(vis[child] == false && child != par)
59 | 	update(child , node , add , lvl + 1);
60 | }
61 |  
62 | void decompose(int node , int par)
63 | {
64 | 	int c = centroid(node , par , subSize(node , par)/2);
65 | 	vis[c] = 1;
66 | 	
67 | 	cnt[0] = 1;
68 | 	mxHeight = 0;
69 | 	for(int child : ar[c])
70 | 	if(child != par && vis[child] == false)
71 | 	{
72 | 		update(child , c , false);
73 | 		update(child , c , true);
74 | 	}
75 | 	
76 | 	REP(i , mxHeight+1) cnt[i-1] = 0;
77 | 	
78 | 	for(int child : ar[c]) if(vis[child] == false) decompose(child , -1);
79 | }
80 |  
81 | int main()
82 | {
83 | 	int a , b;
84 | 	cin>>n>>k;
85 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
86 | 	
87 | 	res = 0;
88 | 	decompose(1 , -1);
89 | 	cout<<res;
90 | }
91 |  
92 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Fixed-Length Paths II.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 |  
  4 | using ll = long long;
  5 | using db = long double; // or double, if TL is tight
  6 | using str = string; // yay python!
  7 |  
  8 | using pi = pair<int,int>;
  9 | using pl = pair<ll,ll>;
 10 | using pd = pair<db,db>;
 11 |  
 12 | using vi = vector<int>;
 13 | using vb = vector<bool>;
 14 | using vl = vector<ll>;
 15 | using vd = vector<db>;
 16 | using vs = vector<str>;
 17 | using vpi = vector<pi>;
 18 | using vpl = vector<pl>;
 19 | using vpd = vector<pd>;
 20 |  
 21 | #define tcT template<class T
 22 | #define tcTU tcT, class U
 23 | // ^ lol this makes everything look weird but I'll try it
 24 | tcT> using V = vector<T>;
 25 | tcT, size_t SZ> using AR = array<T,SZ>;
 26 | tcT> using PR = pair<T,T>;
 27 |  
 28 | // pairs
 29 | #define mp make_pair
 30 | #define f first
 31 | #define s second
 32 |  
 33 | // vectors
 34 | // oops size(x), rbegin(x), rend(x) need C++17
 35 | #define sz(x) int((x).size())
 36 | #define bg(x) begin(x)
 37 | #define all(x) bg(x), end(x)
 38 | #define rall(x) x.rbegin(), x.rend()
 39 | #define sor(x) sort(all(x))
 40 | #define rsz resize
 41 | #define ins insert
 42 | #define ft front()
 43 | #define bk back()
 44 | #define pb push_back
 45 | #define eb emplace_back
 46 | #define pf push_front
 47 | #define rtn return
 48 |  
 49 | #define lb lower_bound
 50 | #define ub upper_bound
 51 | tcT> int lwb(V<T>& a, const T& b) { return int(lb(all(a),b)-bg(a)); }
 52 |  
 53 | // loops
 54 | #define FOR(i,a,b) for (int i = (a); i < (b); ++i)
 55 | #define F0R(i,a) FOR(i,0,a)
 56 | #define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
 57 | #define R0F(i,a) ROF(i,0,a)
 58 | #define EACH(a,x) for (auto& a: x)
 59 |  
 60 | const int MOD = 1e9+7; // 998244353;
 61 | const int MX = 2e5+5;
 62 | const ll INF = 1e18; // not too close to LLONG_MAX
 63 | const db PI = acos((db)-1);
 64 | const int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1}; // for every grid problem!!
 65 | mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
 66 | template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;
 67 |  
 68 | // bitwise ops
 69 | // also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
 70 | constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
 71 | constexpr int bits(int x) { // assert(x >= 0); // make C++11 compatible until USACO updates ...
 72 | 	return x == 0 ? 0 : 31-__builtin_clz(x); } // floor(log2(x))
 73 | constexpr int p2(int x) { return 1<<x; }
 74 | constexpr int msk2(int x) { return p2(x)-1; }
 75 |  
 76 | ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
 77 | ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down
 78 |  
 79 | tcT> bool ckmin(T& a, const T& b) {
 80 | 	return b < a ? a = b, 1 : 0; } // set a = min(a,b)
 81 | tcT> bool ckmax(T& a, const T& b) {
 82 | 	return a < b ? a = b, 1 : 0; }
 83 |  
 84 | tcTU> T fstTrue(T lo, T hi, U f) {
 85 | 	hi ++; assert(lo <= hi); // assuming f is increasing
 86 | 	while (lo < hi) { // find first index such that f is true
 87 | 		T mid = lo+(hi-lo)/2;
 88 | 		f(mid) ? hi = mid : lo = mid+1;
 89 | 	}
 90 | 	return lo;
 91 | }
 92 | tcTU> T lstTrue(T lo, T hi, U f) {
 93 | 	lo --; assert(lo <= hi); // assuming f is decreasing
 94 | 	while (lo < hi) { // find first index such that f is true
 95 | 		T mid = lo+(hi-lo+1)/2;
 96 | 		f(mid) ? lo = mid : hi = mid-1;
 97 | 	}
 98 | 	return lo;
 99 | }
100 | tcT> void remDup(vector<T>& v) { // sort and remove duplicates
101 | 	sort(all(v)); v.erase(unique(all(v)),end(v)); }
102 | tcTU> void erase(T& t, const U& u) { // don't erase
103 | 	auto it = t.find(u); assert(it != end(t));
104 | 	t.erase(it); } // element that doesn't exist from (multi)set
105 |  
106 | // INPUT
107 | #define tcTUU tcT, class ...U
108 | tcT> void re(complex<T>& c);
109 | tcTU> void re(pair<T,U>& p);
110 | tcT> void re(V<T>& v);
111 | tcT, size_t SZ> void re(AR<T,SZ>& a);
112 |  
113 | tcT> void re(T& x) { cin >> x; }
114 | void re(double& d) { str t; re(t); d = stod(t); }
115 | void re(long double& d) { str t; re(t); d = stold(t); }
116 | tcTUU> void re(T& t, U&... u) { re(t); re(u...); }
117 |  
118 | tcT> void re(complex<T>& c) { T a,b; re(a,b); c = {a,b}; }
119 | tcTU> void re(pair<T,U>& p) { re(p.f,p.s); }
120 | tcT> void re(V<T>& x) { EACH(a,x) re(a); }
121 | tcT, size_t SZ> void re(AR<T,SZ>& x) { EACH(a,x) re(a); }
122 | tcT> void rv(int n, V<T>& x) { x.rsz(n); re(x); }
123 |  
124 | // TO_STRING
125 | #define ts to_string
126 | str ts(char c) { return str(1,c); }
127 | str ts(const char* s) { return (str)s; }
128 | str ts(str s) { return s; }
129 | str ts(bool b) {
130 | 	// #ifdef LOCAL
131 | 	// 	return b ? "true" : "false";
132 | 	// #else
133 | 	return ts((int)b);
134 | 	// #endif
135 | }
136 | tcT> str ts(complex<T> c) {
137 | 	stringstream ss; ss << c; return ss.str(); }
138 | str ts(V<bool> v) {
139 | 	str res = "{"; F0R(i,sz(v)) res += char('0'+v[i]);
140 | 	res += "}"; return res; }
141 | template<size_t SZ> str ts(bitset<SZ> b) {
142 | 	str res = ""; F0R(i,SZ) res += char('0'+b[i]);
143 | 	return res; }
144 | tcTU> str ts(pair<T,U> p);
145 | tcT> str ts(T v) { // containers with begin(), end()
146 | 	#ifdef LOCAL
147 | 		bool fst = 1; str res = "{";
148 | 		for (const auto& x: v) {
149 | 			if (!fst) res += ", ";
150 | 			fst = 0; res += ts(x);
151 | 		}
152 | 		res += "}"; return res;
153 | 	#else
154 | 		bool fst = 1; str res = "";
155 | 		for (const auto& x: v) {
156 | 			if (!fst) res += " ";
157 | 			fst = 0; res += ts(x);
158 | 		}
159 | 		return res;
160 |  
161 | 	#endif
162 | }
163 | tcTU> str ts(pair<T,U> p) {
164 | 	#ifdef LOCAL
165 | 		return "("+ts(p.f)+", "+ts(p.s)+")";
166 | 	#else
167 | 		return ts(p.f)+" "+ts(p.s);
168 | 	#endif
169 | }
170 |  
171 | // OUTPUT
172 | tcT> void pr(T x) { cout << ts(x); }
173 | tcTUU> void pr(const T& t, const U&... u) {
174 | 	pr(t); pr(u...); }
175 | void ps() { pr("\n"); } // print w/ spaces
176 | tcTUU> void ps(const T& t, const U&... u) {
177 | 	pr(t); if (sizeof...(u)) pr(" "); ps(u...); }
178 |  
179 | // DEBUG
180 | void DBG() { cerr << "]" << endl; }
181 | tcTUU> void DBG(const T& t, const U&... u) {
182 | 	cerr << ts(t); if (sizeof...(u)) cerr << ", ";
183 | 	DBG(u...); }
184 | #ifdef LOCAL // compile with -DLOCAL, chk -> fake assert
185 | 	#define dbg(...) cerr << "Line(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
186 | 	#define chk(...) if (!(__VA_ARGS__)) cerr << "Line(" << __LINE__ << ") -> function(" \
187 | 		 << __FUNCTION__  << ") -> CHK FAILED: (" << #__VA_ARGS__ << ")" << "\n", exit(0);
188 | #else
189 | 	#define dbg(...) 0
190 | 	#define chk(...) 0
191 | #endif
192 |  
193 | void setPrec() { cout << fixed << setprecision(15); }
194 | void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
195 |  
196 | void setIn(str s) { freopen(s.c_str(),"r",stdin); }
197 | void setOut(str s) { freopen(s.c_str(),"w",stdout); }
198 | void setIO(str s = "") {
199 | 	unsyncIO(); setPrec();
200 | 	if (sz(s)) setIn(s+".in"), setOut(s+".out"); 
201 | }
202 |  
203 | int max_len;
204 | ll mul = 1;
205 | ll ans;
206 | int N,K1,K2;
207 | vi adj[MX];
208 |  
209 | int get_prefix(const deque<int>& a, int mx) {
210 | 	if (mx < 0) return 0;
211 | 	if (mx+1 >= sz(a)) return a[0];
212 | 	return a[0]-a[mx+1];
213 | }
214 |  
215 | void comb(deque<int>& a, deque<int>& b) {
216 | 	if (sz(a) < sz(b)) swap(a,b);
217 | 	F0R(i,sz(b)-1) b[i] -= b[i+1];
218 | 	F0R(i,sz(b)) ans += (ll)b[i]*(get_prefix(a,K2-i)-get_prefix(a,K1-1-i));
219 | 	R0F(i,sz(b)-1) b[i] += b[i+1];
220 | 	F0R(i,sz(b)) a[i] += b[i];
221 | }
222 |  
223 | deque<int> dfs(int x, int p) {
224 | 	deque<int> res{1};
225 | 	EACH(y,adj[x]) if (y != p) {
226 | 		deque<int> a = dfs(y,x);
227 | 		a.push_front(a.ft);
228 | 		comb(res,a);
229 | 	}
230 | 	return res;
231 | }
232 |  
233 | int main() {
234 | 	setIO(); re(N,K1,K2);
235 | 	F0R(i,N-1) {
236 | 		int a,b; re(a,b);
237 | 		adj[a].pb(b), adj[b].pb(a);
238 | 	}
239 | 	max_len = K1-1, mul = -1;
240 | 	dfs(1,0);
241 | 	ps(ans);
242 | }
243 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Path Queries II.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | #define REP(i,n) for (int i = 1; i <= n; i++)
  3 | #define mod 1000000007
  4 | #define pb push_back
  5 | #define ff first
  6 | #define ss second
  7 | #define ii pair<int,int>
  8 | #define vi vector<int>
  9 | #define vii vector<ii>
 10 | #define lli long long int
 11 | #define INF 1000000000
 12 | #define endl '\n'
 13 | const double PI = 3.141592653589793238460;
 14 | typedef std::complex<double> Complex;
 15 | typedef std::valarray<Complex> CArray;
 16 | using namespace std;
 17 |  
 18 | const int N = 200001;
 19 | int n;
 20 |  
 21 | vi ar[N];
 22 |  
 23 | int sub[N];
 24 | int level[N];
 25 | int p[N];
 26 | int val[N];
 27 |  
 28 | //HLD
 29 | int chainHead[N];
 30 | int chainPos[N];
 31 | int nodeAtPos[N];
 32 | int chainNo = 1, ptr;
 33 |  
 34 | //st
 35 | int st[1<<19];
 36 |  
 37 | void dfs(int node , int par , int lvl)
 38 | {
 39 | 	sub[node] = 1;
 40 | 	level[node] = lvl;
 41 | 	p[node] = par;
 42 | 	
 43 | 	for(int child : ar[node])
 44 | 	if(child != par) dfs(child , node , lvl + 1);
 45 | }
 46 |  
 47 |  
 48 | //HLD
 49 | void hld(int node , int par , int head)
 50 | {
 51 | 	chainHead[node] = head;
 52 | 	
 53 | 	chainPos[node] = ++ptr;
 54 | 	nodeAtPos[ptr] = node;
 55 | 	
 56 | 	int mx = -1 , cNode = 0;
 57 | 	
 58 | 	for(int child : ar[node])
 59 | 	if(sub[child] > mx && child != par) mx = sub[child] , cNode = child;
 60 | 	
 61 | 	if(mx > 0) hld(cNode , node , head);
 62 | 	
 63 | 	for(int child : ar[node])
 64 | 	if((child != par) && (child != cNode))
 65 | 	{
 66 | 		chainNo++;
 67 | 		hld(child , node , child);
 68 | 	}
 69 | }
 70 |  
 71 | //segment tree
 72 |  
 73 | int build(int si , int ss , int se)
 74 | {
 75 | 	if(ss == se)
 76 | 	return st[si] = val[nodeAtPos[ss]];
 77 | 	
 78 | 	int mid = (ss + se) >> 1;
 79 | 	
 80 | 	return st[si] = max(build(si<<1 , ss , mid) , build((si<<1) + 1 , mid + 1 , se));
 81 | }
 82 |  
 83 | void update(int si , int ss , int se , int qi , int val)
 84 | {
 85 | 	if(ss > qi || se < qi) return;
 86 | 	
 87 | 	if(ss == qi && se == qi)
 88 | 	{
 89 | 		st[si] = val;
 90 | 		return;
 91 | 	}
 92 | 	
 93 | 	int mid = (ss + se) >> 1;
 94 | 	
 95 | 	if(qi <= mid)
 96 | 	update(si << 1 , ss , mid , qi , val);
 97 | 	else
 98 | 	update((si << 1) + 1 , mid + 1 , se , qi , val);
 99 | 	
100 | 	st[si] = max(st[si << 1] , st[(si << 1)  + 1]);
101 | }
102 |  
103 | int getMax(int si , int ss , int se , int qs , int qe)
104 | {
105 | 	if(ss > qe || se < qs) return 0;
106 | 	
107 | 	if(ss >= qs && se <= qe)
108 | 	return st[si];
109 | 	
110 | 	int mid = (ss + se) >> 1;
111 | 	int L = getMax(si << 1 , ss , mid , qs , qe);
112 | 	int R = getMax((si << 1) + 1 , mid + 1 , se , qs , qe);
113 | 	
114 | 	return max(L , R);
115 | }
116 |  
117 | int getAns(int a , int b)
118 | {
119 | 	int chainA;
120 | 	int chainB;
121 | 	int ans = 0;
122 | 	
123 | 	while(1){
124 | 		
125 | 		if(level[chainHead[a]] > level[chainHead[b]]) swap(a , b);
126 | 		chainA = chainHead[a];
127 | 		chainB = chainHead[b];
128 | 		
129 | 		if(chainA == chainB){
130 | 			if(level[a] > level[b]) swap(a , b);
131 | 			ans = max(ans , getMax(1 , 1 , n , chainPos[a] , chainPos[b]));
132 | 			break;
133 | 		}
134 | 		
135 | 		ans = max(ans , getMax(1 , 1 , n , chainPos[chainB] , chainPos[b]));
136 | 		b = p[chainB];
137 | 	}
138 | 	
139 | 	return ans;
140 | }
141 |  
142 | int main()
143 | {
144 | 	ios_base::sync_with_stdio(false);
145 | 	cin.tie(0);
146 | 	cout.tie(0);
147 | 	
148 | 	int a , b , q;
149 | 	cin>>n>>q;
150 | 	REP(i , n) cin>>val[i];
151 | 	
152 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
153 | 	memset(chainHead , -1 , sizeof chainHead);
154 | 	
155 | 	dfs(1 , -1 , 0);
156 | 	hld(1 , -1 , 1);
157 | 	
158 | 	build(1 , 1 , n);
159 | 	
160 | 	while(q--)
161 | 	{
162 | 		int code;
163 | 		cin>>code;
164 | 		
165 | 		if(code == 2)
166 | 		{
167 | 			cin>>a>>b;
168 | 			
169 | 			int ans = getAns(a , b);
170 | 			cout<<ans<<" ";
171 | 		}
172 | 		else
173 | 		{
174 | 			cin>>a>>b;
175 | 			update(1 , 1 , n , chainPos[a] , b);
176 | 		}
177 | 	}
178 | 	
179 | 	cout<<"\n";
180 | }
181 | 
182 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Path Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | const int N = 200001;
19 | const int maxN = 21;
20 |  
21 | vi ar[N];
22 | lli val[N];
23 | int in[N];
24 | int out[N];
25 | int _t = 1;
26 | int n;
27 |  
28 | lli bit[2*N];
29 |  
30 | void dfs(int node , int par)
31 | {
32 | 	in[node] = _t++;
33 | 	
34 | 	for(int child : ar[node])
35 | 	if(child != par) dfs(child , node );
36 | 	
37 | 	out[node] = _t++;
38 | }
39 |  
40 | void update(int i , lli dx){
41 | 	while(i <= 2*n)
42 | 	{
43 | 		bit[i] += dx;
44 | 		i += (i & -i);
45 | 	}
46 | }
47 |  
48 | lli sum(int i)
49 | {
50 | 	lli res = 0;
51 | 	while(i > 0)
52 | 	{
53 | 		res += bit[i];
54 | 		i -= (i & -i);
55 | 	}
56 | 	
57 | 	return res;
58 | }
59 |  
60 | int main()
61 | {
62 | 	lli m , a , b;
63 | 	cin>>n>>m;
64 | 	REP(i , n) cin>>val[i];
65 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
66 | 	
67 | 	dfs(1 , 0);
68 | 	
69 | 	REP(i , n) update(in[i] , val[i]) , update(out[i] , -val[i]);
70 | 	
71 | 	while(m--)
72 | 	{
73 | 		int code;
74 | 		cin>>code;
75 | 		
76 | 		if(code == 1)
77 | 		{
78 | 			cin>>a>>b;
79 | 			update(in[a]  , b - val[a]);
80 | 			update(out[a] , val[a] - b);
81 | 			val[a] = b;
82 | 		}
83 | 		else
84 | 		cin>>a , cout<<sum(in[a])<<endl;
85 | 	}
86 | }
87 |  
88 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Subordinates.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=fIYDlle-mlo&list=PL2q4fbVm1Ik534C0_A2JrVeXaNxgi3D3V&index=8
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | vi ar[200001];
21 | int sub[200001];
22 |  
23 | int dfs(int node)
24 | {
25 | 	sub[node] = 1;
26 | 	for(int child : ar[node])
27 | 	dfs(child) , sub[node] += sub[child];
28 | }
29 |  
30 | int main()
31 | {
32 | 	int n , a , b;
33 | 	cin>>n;
34 | 	
35 | 	for(int i=2;i<=n;i++) cin>>a , ar[a].pb(i);
36 | 	dfs(1);
37 | 	
38 | 	REP(i , n) cout<<sub[i]-1<<" ";
39 | }
40 |  
41 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Subtree Queries.cpp:
--------------------------------------------------------------------------------
  1 | //video solution link : https://www.youtube.com/watch?v=zSB4pInjIa8&list=PL2q4fbVm1Ik534C0_A2JrVeXaNxgi3D3V&index=6
  2 | 
  3 | #include<bits/stdc++.h>
  4 | #define REP(i,n) for (int i = 1; i <= n; i++)
  5 | #define mod 1000000007
  6 | #define pb push_back
  7 | #define ff first
  8 | #define ss second
  9 | #define ii pair<int,int>
 10 | #define vi vector<int>
 11 | #define vii vector<ii>
 12 | #define lli long long int
 13 | #define INF 1000000000
 14 | #define endl '\n'
 15 | const double PI = 3.141592653589793238460;
 16 | typedef std::complex<double> Complex;
 17 | typedef std::valarray<Complex> CArray;
 18 | using namespace std;
 19 |  
 20 | const int N = 200001;
 21 | vi tree[N];
 22 |  
 23 | lli ar[N];
 24 | lli temp[N];
 25 |  
 26 | lli st[2*N];
 27 |  
 28 | lli sub[N];
 29 | lli in[N];
 30 | int _timer = 0;
 31 |  
 32 | void dfs(int node, int par)
 33 | {
 34 | 	sub[node] = 1;
 35 | 	in[node] = ++_timer;
 36 | 	ar[in[node]] = temp[node];
 37 | 	
 38 | 	for(int child : tree[node])
 39 | 	if(child != par)
 40 | 	dfs(child , node) , sub[node] += sub[child];
 41 | }
 42 |  
 43 | void build(int si , int ss , int se)
 44 | {
 45 | 	
 46 | 	if(ss == se){
 47 | 		st[si] = ar[ss];
 48 | 		return;
 49 | 	}
 50 | 	
 51 | 	int mid = (ss + se) >> 1;
 52 | 	build(2*si , ss , mid);
 53 | 	build(2*si + 1 , mid+1 , se);
 54 | 	
 55 | 	st[si] = st[2*si] + st[2*si + 1];
 56 | }
 57 |  
 58 | void update(int si , int ss , int se , int qi , lli dx)
 59 | {
 60 | 	if(ss > qi || se < qi) return;
 61 | 	
 62 | 	if(ss == se)
 63 | 	{
 64 | 		st[si] += dx;
 65 | 		return;
 66 | 	}
 67 | 	
 68 | 	int mid = (ss + se) >> 1;
 69 | 	update(2*si , ss , mid , qi , dx);
 70 | 	update(2*si + 1 , mid+1 , se , qi , dx);
 71 | 	
 72 | 	st[si] = st[2*si] + st[2*si + 1];
 73 | }
 74 |  
 75 | lli getSum(int si , int ss , int se , int qs , int qe)
 76 | {
 77 | 	if(ss > qe || se < qs) return 0;
 78 | 	
 79 | 	if(ss >= qs && se <= qe)
 80 | 	return st[si];
 81 | 	
 82 | 	int mid = (ss + se) >> 1;
 83 | 	lli L = getSum(2*si , ss , mid , qs , qe);
 84 | 	lli R = getSum(2*si + 1 , mid+1 , se , qs , qe);
 85 | 	
 86 | 	return L + R;
 87 | }
 88 |  
 89 | int main()
 90 | {
 91 | 	int n , q , a , b , code;
 92 | 	cin>>n>>q;
 93 | 	
 94 | 	REP(i , n) cin>>temp[i];
 95 | 	REP(i , n-1) cin>>a>>b , tree[a].pb(b) , tree[b].pb(a);
 96 | 	
 97 | 	dfs(1 , -1);
 98 | 	build(1 , 1 , n);
 99 | 	
100 | 	while(q--)
101 | 	{
102 | 		cin>>code;
103 | 		
104 | 		if(code == 1) {
105 | 			cin>>a>>b;
106 | 			update(1 , 1 , n , in[a] , b - ar[in[a]]);
107 | 			ar[in[a]] = b;
108 | 		}
109 | 		else{
110 | 			cin>>a;
111 | 			cout<<getSum(1 , 1 , n , in[a] , in[a] + sub[a] - 1)<<endl;
112 | 		}
113 | 	}
114 | }
115 |  
116 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Tree Diameter.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=l6aA9a_x3gE&list=PL2q4fbVm1Ik534C0_A2JrVeXaNxgi3D3V&index=2
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | vi ar[200001];
21 | int f[200001];
22 | int g[200001];
23 | int d;
24 |  
25 | void dfs(int node ,int par)
26 | {
27 | 	vi childList;
28 | 	
29 | 	for(int child : ar[node])
30 | 	if(child != par)
31 | 	{
32 | 		dfs(child , node);
33 | 		f[node] = max(f[node] , f[child] + 1);
34 | 		childList.pb(f[child]);
35 | 	}
36 | 	
37 | 	d = max(d , f[node]);
38 | 	
39 | 	sort(childList.begin() , childList.end());
40 | 	if(childList.size() >= 2)
41 | 	{
42 | 		g[node] = 2 + childList[childList.size()-1] + childList[childList.size()-2];
43 | 		d = max(d , g[node]);
44 | 	}
45 | }
46 |  
47 | int main()
48 | {
49 | 	int n , a , b;
50 | 	cin>>n;
51 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
52 | 	
53 | 	dfs(1 , -1);
54 | 	
55 | 	cout<<d;
56 | }
57 |  
58 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Tree Distances I.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | vi ar[200001];
19 | int res[200001];
20 | int x , y;
21 | int mx;
22 |  
23 | void find_a(int node ,int par , int dist)
24 | {
25 | 	if(dist >= mx) mx = dist , x = node;
26 | 	
27 | 	for(int child : ar[node])
28 | 	if(child != par)
29 | 	{
30 | 		find_a(child , node , dist + 1);
31 | 	}
32 | }
33 |  
34 | void find_b(int node ,int par , int dist)
35 | {
36 | 	if(dist >= mx) mx = dist , y = node;
37 | 	res[node] = max(res[node] , dist);
38 | 	
39 | 	for(int child : ar[node])
40 | 	if(child != par)
41 | 	{
42 | 		find_b(child , node , dist + 1);
43 | 	}
44 | }
45 |  
46 | void dfs(int node , int par , int dist)
47 | {
48 | 	res[node] = max(res[node] , dist);
49 | 	
50 | 	for(int child : ar[node])
51 | 	if(child != par)
52 | 	{
53 | 		dfs(child , node , dist + 1);
54 | 	}
55 | }
56 |  
57 | int main()
58 | {
59 | 	int n , a , b;
60 | 	cin>>n;
61 | 	
62 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
63 | 	
64 | 	find_a(1 , -1 , 0);
65 | 	find_b(x , -1 , 0);
66 | 	dfs(y , -1 , 0);
67 | 	
68 | 	REP(i , n) cout<<res[i]<<" ";
69 | }
70 |  
71 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Tree Distances II.cpp:
--------------------------------------------------------------------------------
 1 | //video solution link : https://www.youtube.com/watch?v=lWCZOjUOjRc&list=PL2q4fbVm1Ik534C0_A2JrVeXaNxgi3D3V&index=4
 2 | 
 3 | #include<bits/stdc++.h>
 4 | #define REP(i,n) for (int i = 1; i <= n; i++)
 5 | #define mod 1000000007
 6 | #define pb push_back
 7 | #define ff first
 8 | #define ss second
 9 | #define ii pair<int,int>
10 | #define vi vector<int>
11 | #define vii vector<ii>
12 | #define lli long long int
13 | #define INF 1000000000
14 | #define endl '\n'
15 | const double PI = 3.141592653589793238460;
16 | typedef std::complex<double> Complex;
17 | typedef std::valarray<Complex> CArray;
18 | using namespace std;
19 |  
20 | vi ar[200001];
21 | lli res[200001];
22 | int subSize[200001];
23 | lli subDist[200001];
24 | int n;
25 |  
26 | void dfs1(int node , int par)
27 | {
28 | 	subSize[node] = 1;
29 | 	
30 | 	for(int child : ar[node])
31 | 	if(child != par)
32 | 	{
33 | 		dfs1(child , node);
34 | 		subSize[node] += subSize[child];
35 | 		
36 | 		subDist[node] += subSize[child] + subDist[child];
37 | 	}
38 | }
39 |  
40 | void dfs(int node , int par)
41 | {
42 | 	res[node] = res[par] - subSize[node] - subDist[node] + n - subSize[node] + subDist[node];
43 | 	
44 | 	for(int child : ar[node])
45 | 	if(child != par)
46 | 	dfs(child , node);
47 | }
48 |  
49 | int main()
50 | {
51 | 	int a , b;
52 | 	cin>>n;
53 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
54 | 	
55 | 	dfs1(1 , -1);
56 | 	res[1] = subDist[1];
57 | 	
58 | 	for(int child : ar[1])
59 | 	dfs(child , 1);
60 | 	
61 | 	REP(i , n) cout<<res[i]<<" ";
62 | }
63 |  
64 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Tree Matching.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define REP(i,n) for (int i = 1; i <= n; i++)
 3 | #define mod 1000000007
 4 | #define pb push_back
 5 | #define ff first
 6 | #define ss second
 7 | #define ii pair<int,int>
 8 | #define vi vector<int>
 9 | #define vii vector<ii>
10 | #define lli long long int
11 | #define INF 1000000000
12 | #define endl '\n'
13 | const double PI = 3.141592653589793238460;
14 | typedef std::complex<double> Complex;
15 | typedef std::valarray<Complex> CArray;
16 | using namespace std;
17 |  
18 | vi ar[200001];
19 | int f[200001];
20 | int g[200001];
21 |  
22 | void dfs(int node , int par)
23 | {
24 | 	int a = 0;
25 | 	
26 | 	for(int child : ar[node])
27 | 	if(child != par)
28 | 	{
29 | 		dfs(child , node);
30 | 		g[node] += max(f[child] , g[child]);
31 | 	}
32 | 	
33 | 	for(int child : ar[node])
34 | 	if(child != par)
35 | 	{
36 | 		f[node] = max(f[node] , g[node] - max(f[child] , g[child]) + g[child] + 1);
37 | 	}
38 | }
39 |  
40 | int main()
41 | {
42 | 	int n , a , b;
43 | 	cin>>n;
44 | 	REP(i , n-1) cin>>a>>b , ar[a].pb(b) , ar[b].pb(a);
45 | 	
46 | 	dfs(1 , -1);
47 | 	cout<<max(f[1] , g[1]);
48 | }
49 |  
50 | 


--------------------------------------------------------------------------------