├── Additional Problems
    └── Chess Tournament.cpp
├── Dynamic Programming
    ├── Array Description.cpp
    ├── Book Shop.cpp
    ├── Coin Combinations I.cpp
    ├── Coin Combinations II.cpp
    ├── Counting Towers.cpp
    ├── Dice Combinations.cpp
    ├── Edit Distance.cpp
    ├── Elevator Rides.cpp
    ├── Grid Paths.cpp
    ├── Increasing Subsequence.cpp
    ├── Minimizing Coins.cpp
    ├── Money Sums.cpp
    ├── Projects.cpp
    ├── Rectangle Cutting.cpp
    ├── Removal Game.cpp
    ├── Removing Digits.cpp
    └── Two Sets II.cpp
├── Graph Algorithms
    ├── Building Roads.cpp
    ├── Building Teams.cpp
    ├── Counting Rooms.cpp
    ├── Course Schedule.cpp
    ├── Cycle Finding.cpp
    ├── Flight Discount.cpp
    ├── Flight Routes.cpp
    ├── Game Routes.cpp
    ├── High Score.cpp
    ├── Labyrinth.cpp
    ├── Longest Flight Route.cpp
    ├── Message Route.cpp
    ├── Monsters.cpp
    ├── Round Trip II.cpp
    ├── Round Trip.cpp
    ├── Shortest Routes I.cpp
    └── Shortest Routes II.cpp
├── Introductory Problems
    ├── Apple Division.cpp
    ├── Bit Strings.cpp
    ├── Chessboard and Queens.cpp
    ├── Coin Piles.cpp
    ├── Creating Strings.cpp
    ├── Digit Queries.cpp
    ├── Gray Code.cpp
    ├── Grid Paths.cpp
    ├── Increasing Array.cpp
    ├── Missing Number.cpp
    ├── Number Spiral.cpp
    ├── Palindrome Reorder.cpp
    ├── Permutations.cpp
    ├── Repetitions.cpp
    ├── Tower of Hanoi.cpp
    ├── Trailing Zeros.cpp
    ├── Two Knights.cpp
    ├── Two Sets.cpp
    └── Weird Algorithm.cpp
├── Mathematics
    ├── Binomial Coefficients.cpp
    ├── Bracket Sequences I.cpp
    ├── Bracket Sequences II.cpp
    ├── Candy Lottery.cpp
    ├── Christmas Party.cpp
    ├── Common Divisors.cpp
    ├── Counting Coprime Pairs.cpp
    ├── Counting Divisors.cpp
    ├── Counting Necklaces.cpp
    ├── Creating Strings II.cpp
    ├── Dice Probability.cpp
    ├── Distributing Apples.cpp
    ├── Divisor Analysis.cpp
    ├── Exponentiation II.cpp
    ├── Exponentiation.cpp
    ├── Fibonacci Numbers.cpp
    ├── Graph Paths I.cpp
    ├── Graph Paths II.cpp
    ├── Grundy's Game.cpp
    ├── Inversion Probability.cpp
    ├── Josephus Queries.cpp
    ├── Moving Robots.cpp
    ├── Nim Game I.cpp
    ├── Nim Game II.cpp
    ├── Prime Multiples.cpp
    ├── Stair Game.cpp
    ├── Stick Game.cpp
    ├── Sum of Divisors.cpp
    └── Throwing Dice.cpp
├── Range Queries
    ├── Forest Queries.cpp
    ├── Hotel Queries.cpp
    ├── List Removals.cpp
    ├── Range Minimum Queries I.cpp
    ├── Range Minimum Queries II.cpp
    ├── Range Sum Queries I.cpp
    ├── Range Sum Queries II.cpp
    ├── Range Update Queries.cpp
    └── Range Xor Queries.cpp
├── Sorting and Searching
    ├── Apartments.cpp
    ├── Array Division.cpp
    ├── Collecting Numbers II.cpp
    ├── Collecting Numbers.cpp
    ├── Concert Tickets.cpp
    ├── Distinct Numbers.cpp
    ├── Factory Machines.cpp
    ├── Ferris Wheel.cpp
    ├── Josephus Problem I.cpp
    ├── Josephus Problem II.cpp
    ├── Maximum Subarray Sum II.cpp
    ├── Maximum Subarray Sum.cpp
    ├── Missing Coin Sum.cpp
    ├── Movie Festival II.cpp
    ├── Movie Festival.cpp
    ├── Nearest Smaller Values.cpp
    ├── Nested Ranges Check.cpp
    ├── Nested Ranges Count.cpp
    ├── Playlist.cpp
    ├── Reading Books.cpp
    ├── Restaurant Customers.cpp
    ├── Room Allocation.cpp
    ├── Sliding Cost.cpp
    ├── Sliding Median.cpp
    ├── Stick Lengths.cpp
    ├── Subarray Distinct Values.cpp
    ├── Subarray Divisibility.cpp
    ├── Subarray Sums I.cpp
    ├── Subarray Sums II.cpp
    ├── Sum of Four Values.cpp
    ├── Sum of Three Values.cpp
    ├── Sum of Two Values.cpp
    ├── Tasks and Deadlines.cpp
    ├── Towers.cpp
    └── Traffic Lights.cpp
├── String Algorithms
    ├── Finding Borders.cpp
    ├── Finding Periods.cpp
    └── String Matching.cpp
└── Tree Algorithms
    ├── Company Queries I.cpp
    ├── Company Queries II.cpp
    ├── Distance Queries.cpp
    ├── Subordinates.cpp
    ├── Subtree Queries.cpp
    ├── Tree Diameter.cpp
    ├── Tree Distances I.cpp
    ├── Tree Distances II.cpp
    └── Tree Matching.cpp


/Additional Problems/Chess Tournament.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll x[n];
40 |     ll flag=0,sum=0;
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>x[i];
44 |         sum+=x[i];
45 |         if(x[i]>=n) flag=1;
46 |     }
47 |     if(flag==1 || sum%2==1 || sum>(n*(n-1)) ) cout<<"IMPOSSIBLE";
48 |     else
49 |     {
50 |         priority_queue<pll> pq;
51 |         //cout<<sum/2<<"\n";
52 |         for(int i=0;i<n;i++)
53 |         {
54 |             if(x[i]!=0)
55 |             {
56 |                 pq.push(MP(x[i],i));
57 |             }
58 |         }
59 |         ll flag=0;
60 |         vector<pll> ans;
61 |         while(!pq.empty())
62 |         {
63 |             pll p=pq.top();
64 |             pq.pop();
65 |             vector<pll> v;
66 |             while(p.F>0 && !pq.empty())
67 |             {
68 |                 p.F--;
69 |                 pll q=pq.top();
70 |                 pq.pop();
71 |                 v.PB(MP(q.F-1,q.S));
72 |                 ans.PB(MP(p.S+1,q.S+1));
73 |                 //cout<<p.S+1<<" "<<q.S+1<<"\n";
74 |             }
75 |             if(p.F>0)
76 |             {
77 |                 flag=1;
78 |                 break;
79 |             }
80 |             for(int i=0;i<v.size();i++)
81 |             {
82 |                 pq.push(MP(v[i].F,v[i].S));
83 |             }
84 |         }
85 |         if(flag==1) cout<<"IMPOSSIBLE";
86 |         else
87 |         {
88 |             cout<<sum/2<<"\n";
89 |             for(int i=0;i<ans.size();i++)
90 |             {
91 |                 cout<<ans[i].F<<" "<<ans[i].S<<"\n";
92 |             }
93 |         }
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Array Description.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,m;
38 |     cin>>n>>m;
39 |     vector<int> x(n+1);
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>x[i];
43 |     }
44 |     vector<vector<int> > dp(n+1,vector<int> (m+1,0));
45 |     for(int i=0;i<n;i++)
46 |     {
47 |         if(i==0)
48 |         {
49 |             if(x[i]==0)
50 |             {
51 |                 for(int j=1;j<=m;j++)
52 |                 {
53 |                     dp[0][j]=1;
54 |                 }
55 |             }
56 |             else
57 |             {
58 |                 dp[0][x[i]]=1;
59 |             }
60 |         }
61 |         else
62 |         {
63 |             if(x[i]==0)
64 |             {
65 |                 for(int j=1;j<=m;j++)
66 |                 {
67 |                     dp[i][j]=dp[i-1][j];
68 |                     if(j-1>=1) dp[i][j]=(dp[i][j]+dp[i-1][j-1])%MOD;
69 |                     if(j+1<=m) dp[i][j]=(dp[i][j]+dp[i-1][j+1])%MOD;
70 |                 }
71 |             }
72 |             else
73 |             {
74 |                 int j=x[i];
75 |                 dp[i][j]=dp[i-1][j];
76 |                 if(j-1>=1) dp[i][j]=(dp[i][j]+dp[i-1][j-1])%MOD;
77 |                 if(j+1<=m) dp[i][j]=(dp[i][j]+dp[i-1][j+1])%MOD;
78 |             }
79 |         }
80 |     }
81 |     ll ans=0;
82 |     for(int i=1;i<=m;i++)
83 |     {
84 |         ans+=dp[n-1][i];
85 |         ans%=MOD;
86 |     }
87 |     cout<<ans<<"\n";
88 | }
89 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Book Shop.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     vector<int> h(n+1),s(n+1);
40 |     for(int i=1;i<=n;i++)
41 |     {
42 |         cin>>h[i];
43 |     }
44 |     for(int i=1;i<=n;i++)
45 |     {
46 |         cin>>s[i];
47 |     }
48 |     vector<vector<int> > dp(n+1,vector<int> (x+1,0));
49 |     for(int i=1;i<=n;i++)
50 |     {
51 |         for(int j=0;j<=x;j++)
52 |         {
53 |             dp[i][j]=max(dp[i][j],dp[i-1][j]);
54 |             if(j-h[i]>=0)
55 |             {
56 |                 dp[i][j]=max(dp[i][j],dp[i-1][j-h[i]]+s[i]);
57 |             }
58 |         }
59 |     }
60 |     cout<<dp[n][x];
61 | }
62 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Coin Combinations I.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll c[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>c[i];
43 |     }
44 |     ll dp[x+1]={};
45 |     dp[0]=1;
46 |     for(int i=1;i<=x;i++)
47 |     {
48 |         for(int j=0;j<n;j++)
49 |         {
50 |             if(i-c[j]>=0)
51 |             {
52 |                 dp[i]+=dp[i-c[j]];
53 |                 dp[i]%=MOD;
54 |             }
55 |         }
56 |     }
57 |     cout<<dp[x];
58 | }
59 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Coin Combinations II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     vector<int> c(n+1);
40 |     for(int i=1;i<=n;i++)
41 |     {
42 |         cin>>c[i];
43 |     }
44 |     vector<vector<int> > dp(n+1, vector<int> (x+1,0));
45 |     dp[0][0]=1;
46 |     for(int i=1;i<=n;i++)
47 |     {
48 |         for(int j=0;j<=x;j++)
49 |         {
50 |             dp[i][j]=dp[i-1][j];
51 |             if(j-c[i]>=0)
52 |             {
53 |                 dp[i][j]+=dp[i][j-c[i]];
54 |                 dp[i][j]%=MOD;
55 |             }
56 |         }
57 |     }
58 |     cout<<dp[n][x];
59 | }
60 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Counting Towers.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll dp[1000001][2];
38 |     dp[1][0]=dp[1][1]=1;
39 |     for(int i=2;i<1000001;i++)
40 |     {
41 |         dp[i][0]=(4*dp[i-1][0]+dp[i-1][1])%MOD;
42 |         dp[i][1]=(dp[i-1][0]+2*dp[i-1][1])%MOD;
43 |     }
44 |     ll t;
45 |     cin>>t;
46 |     for(int i=0;i<t;i++)
47 |     {
48 |         ll n;
49 |         cin>>n;
50 |         cout<<(dp[n][0]+dp[n][1])%MOD<<"\n";
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Dice Combinations.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll dp[n+1]={};
40 |     dp[0]=1;
41 |     for(int i=1;i<=n;i++)
42 |     {
43 |         for(int j=1;j<=6;j++)
44 |         {
45 |             if((i-j)>=0) 
46 |             {
47 |                 dp[i]+=dp[i-j];
48 |                 dp[i]%=MOD;
49 |             }
50 |         }
51 |     }
52 |     cout<<dp[n];
53 | }
54 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Edit Distance.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     string a,b;
38 |     cin>>a>>b;
39 |     ll n=a.size(),m=b.size();
40 |     vector<vector<int> > dp(n+1,vector<int> (m+1,1e10));
41 |     dp[0][0]=0;
42 |     for(int i=0;i<=n;i++)
43 |     {
44 |         for(int j=0;j<=m;j++)
45 |         {
46 |             if(i!=0)
47 |             {
48 |                 dp[i][j]=min(dp[i][j],dp[i-1][j]+1);
49 |             }
50 |             if(j!=0)
51 |             {
52 |                 dp[i][j]=min(dp[i][j],dp[i][j-1]+1);
53 |             }
54 |             if(i!=0 && j!=0)
55 |             {
56 |                 if(a[i-1]==b[j-1])
57 |                 {
58 |                     dp[i][j]=min(dp[i][j],dp[i-1][j-1]);
59 |                 }
60 |                 else
61 |                 {
62 |                     dp[i][j]=min(dp[i][j],dp[i-1][j-1]+1);
63 |                 }
64 |             }
65 |         }
66 |     }
67 |     cout<<dp[n][m];
68 | }
69 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Elevator Rides.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll w[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>w[i];
43 |     }
44 |     vector<pll> dp(1<<n);
45 |     dp[0]={1,0};
46 |     for(int i=1;i<(1<<n);i++)
47 |     {
48 |         dp[i]={n+1,0};
49 |         for(int j=0;j<n;j++)
50 |         {
51 |             if((i&(1<<j))!=0)
52 |             {
53 |                 pll temp=dp[i^(1<<j)];
54 |                 if(temp.S+w[j]<=x)
55 |                 {
56 |                     temp.S+=w[j];
57 |                 }
58 |                 else
59 |                 {
60 |                     temp.F++;
61 |                     temp.S=w[j];
62 |                 }
63 |                 dp[i]=min(dp[i],temp);
64 |             }
65 |         }
66 |     }
67 |     cout<<dp[(1<<n)-1].F;
68 | }
69 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Grid Paths.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     char c[n][n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         for(int j=0;j<n;j++)
43 |         {
44 |             cin>>c[i][j];
45 |         }
46 |     }
47 |     ll dp[n][n]={};
48 |     dp[0][0]=1;
49 |     for(int i=0;i<n;i++)
50 |     {
51 |         for(int j=0;j<n;j++)
52 |         {
53 |             if(c[i][j]=='.')
54 |             {
55 |                 if(i>0)
56 |                 {
57 |                     dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
58 |                 }
59 |                 if(j>0)
60 |                 {
61 |                     dp[i][j]=(dp[i][j]+dp[i][j-1])%MOD;
62 |                 }
63 |             }
64 |         }
65 |     }
66 |     if(c[0][0]=='*') cout<<"0";
67 |     else cout<<dp[n-1][n-1];
68 | }
69 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Increasing Subsequence.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     vll x(n);
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>x[i];
43 |     }
44 |     vll dp;
45 |     for(int i=0;i<n;i++)
46 |     {
47 |         auto it=lower_bound(dp.begin(),dp.end(),x[i]);
48 |         if(it==dp.end())
49 |         {
50 |             dp.PB(x[i]);
51 |         }
52 |         else
53 |         {
54 |             (*it)=x[i];
55 |         }
56 |     }
57 |     cout<<dp.size();
58 | }
59 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Minimizing Coins.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll c[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>c[i];
43 |     }
44 |     ll dp[x+1];
45 |     for(int i=1;i<=x;i++)
46 |     {
47 |         dp[i]=1e10;
48 |     }
49 |     dp[0]=0;
50 |     for(int i=1;i<=x;i++)
51 |     {
52 |         for(int j=0;j<n;j++)
53 |         {
54 |             if( (i-c[j]) >=0 )
55 |             {
56 |                 dp[i]=min(dp[i],dp[i-c[j]]+1);
57 |             }
58 |         }
59 |     }
60 |     if(dp[x]==1e10) cout<<"-1";
61 |     else cout<<dp[x];
62 | }
63 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Money Sums.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     vector<int> x(n+1);
40 |     for(int i=1;i<=n;i++)
41 |     {
42 |         cin>>x[i];
43 |     }
44 |     ll mx=1e5;
45 |     vector<vector<bool> > dp(n+1,vector<bool> (mx+1,false));
46 |     dp[0][0]=true;
47 |     for(int i=1;i<=n;i++)
48 |     {
49 |         for(int j=0;j<=mx;j++)
50 |         {
51 |             dp[i][j]=dp[i-1][j];
52 |             if(j-x[i]>=0 && dp[i-1][j-x[i]]==true)
53 |             {
54 |                 dp[i][j]=true;
55 |             }
56 |         }
57 |     }
58 |     vector<int> ans;
59 |     for(int i=1;i<=mx;i++)
60 |     {
61 |         if(dp[n][i]==true) ans.PB(i);
62 |     }
63 |     cout<<ans.size()<<"\n";
64 |     for(int i=0;i<ans.size();i++)
65 |     {
66 |         cout<<ans[i]<<" ";
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Projects.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll a[n],b[n],p[n];
40 |     map<ll,ll> pnt;
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>a[i]>>b[i]>>p[i];
44 |         b[i]++;
45 |         pnt[a[i]]=0;
46 |         pnt[b[i]]=0;
47 |     }
48 |     ll cnt=0;
49 |     for(auto&it:pnt)
50 |     {
51 |         it.S=cnt;
52 |         cnt++;
53 |     }
54 |     vector<vector<pll> > v(cnt);
55 |     for(int i=0;i<n;i++)
56 |     {
57 |         v[pnt[b[i]]].PB({pnt[a[i]],p[i]});
58 |     }
59 |     vll dp(cnt,0);
60 |     for(int i=0;i<cnt;i++)
61 |     {
62 |         if(i>0)
63 |         {
64 |             dp[i]=dp[i-1];
65 |         }
66 |         for(auto it:v[i])
67 |         {
68 |             dp[i]=max(dp[i],dp[it.F]+it.S);
69 |         }
70 |     }
71 |     cout<<dp[cnt-1];
72 | }
73 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Rectangle Cutting.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll a,b;
38 |     cin>>a>>b;
39 |     vector<vector<int> > dp(a+1,vector<int> (b+1,0));
40 |     for(int i=1;i<=a;i++)
41 |     {
42 |         for(int j=1;j<=b;j++)
43 |         {
44 |             if(i==j)
45 |             {
46 |                 dp[i][j]=0;
47 |             }
48 |             else
49 |             {
50 |                 dp[i][j]=1e9;
51 |                 for(int k=1;k<i;k++)
52 |                 {
53 |                     dp[i][j]=min(dp[i][j],dp[i-k][j]+dp[k][j]+1);
54 |                 }
55 |                 for(int k=1;k<j;k++)
56 |                 {
57 |                     dp[i][j]=min(dp[i][j],dp[i][j-k]+dp[i][k]+1);
58 |                 }
59 |             }
60 |         }
61 |     }
62 |     cout<<dp[a][b];
63 | }
64 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Removal Game.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     vll x(n+1);
40 |     ll sum=0;
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>x[i];
44 |         sum+=x[i];
45 |     }
46 |     vector<vll> dp(n,vll (n,0));
47 |     for(int i=n-1;i>=0;i--)
48 |     {
49 |         for(int j=i;j<n;j++)
50 |         {
51 |             if(i==j)
52 |             {
53 |                 dp[i][j]=x[i];
54 |             }
55 |             else
56 |             {
57 |                 dp[i][j]=max(x[i]-dp[i+1][j],x[j]-dp[i][j-1]);
58 |             }
59 |         }
60 |     }
61 |     cout<<(dp[0][n-1]+sum)/2;
62 | }
63 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Removing Digits.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll dp[n+1];
40 |     for(int i=1;i<=n;i++)
41 |     {
42 |         dp[i]=1e9;
43 |     }
44 |     dp[0]=0;
45 |     for(int i=1;i<=n;i++)
46 |     {
47 |         string s=to_string(i);
48 |         for(int j=0;j<s.size();j++)
49 |         {
50 |             dp[i]=min(dp[i],dp[i-(s[j]-'0')]+1);
51 |         }
52 |     }
53 |     cout<<dp[n];
54 | }
55 | 


--------------------------------------------------------------------------------
/Dynamic Programming/Two Sets II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll tot=(n*(n+1))/2;
40 |     if(tot%2==1)
41 |     {
42 |         cout<<"0";
43 |         return 0;
44 |     }
45 |     tot/=2;
46 |     vector<vector<int> > dp(n+1,vector<int> (tot+1,0));
47 |     dp[0][0]=1;
48 |     for(int i=1;i<=n;i++)
49 |     {
50 |         for(int j=0;j<=tot;j++)
51 |         {
52 |             dp[i][j]=dp[i-1][j];
53 |             if(j-i>=0)
54 |             {
55 |                 dp[i][j]=(dp[i][j]+dp[i-1][j-i])%MOD;
56 |             }
57 |         }
58 |     }
59 |     cout<<(dp[n][tot]*inverse(2))%MOD;
60 | }
61 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Building Roads.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | vll AdjList[100005];
32 | ll dfs_num[100005];
33 | 
34 | void dfs(int u) {
35 |     dfs_num[u] = 1;
36 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
37 |         ll v = AdjList[u][j];
38 |         if (dfs_num[v] == 0)
39 |             dfs(v);
40 |     }
41 | }
42 | 
43 | int main()
44 | {
45 |     ios::sync_with_stdio(0);
46 |     cin.tie(0);
47 |     cout.tie(0);
48 |     ll n,m,u,v;
49 |     cin>>n>>m;
50 |     for(int i=0;i<m;i++)
51 |     {
52 |         cin>>u>>v;
53 |         u--;
54 |         v--;
55 |         AdjList[u].PB(v);
56 |         AdjList[v].PB(u);
57 |     }
58 |     for(int i=0;i<n;i++)
59 |     {
60 |         dfs_num[i]=0;
61 |     }
62 |     dfs(0);
63 |     vll ans;
64 |     for(int i=1;i<n;i++)
65 |     {
66 |         if(dfs_num[i]==0)
67 |         {
68 |             dfs(i);
69 |             ans.PB(i+1);
70 |         }
71 |     }
72 |     cout<<ans.size()<<"\n";
73 |     for(int i=0;i<ans.size();i++)
74 |     {
75 |         cout<<1<<" "<<ans[i]<<"\n";
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Building Teams.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | vll AdjList[100005];
32 | ll INF=1e10;
33 | int main()
34 | {
35 |     ios::sync_with_stdio(0);
36 |     cin.tie(0);
37 |     cout.tie(0);
38 |     ll n,m,a,b;
39 |     cin>>n>>m;
40 |     for(int i=0;i<m;i++)
41 |     {
42 |         cin>>a>>b;
43 |         a--;
44 |         b--;
45 |         AdjList[a].PB(b);
46 |         AdjList[b].PB(a);
47 |     }
48 |     vll d(n, INF); 
49 |     vll ans(n,0);
50 |     ll flag=0;
51 |     for(int i=0;i<n;i++)
52 |     {
53 |         if(d[i]==INF)
54 |         {
55 |             d[i] = 0;
56 |             ans[i]=0;
57 |             queue<ll> q; 
58 |             q.push(i);
59 |             while (!q.empty())
60 |             {
61 |                 ll u = q.front(); q.pop(); // queue: layer by layer!
62 |                 for (int j = 0; j < (int)AdjList[u].size(); j++)
63 |                 {
64 |                     ll v = AdjList[u][j]; // for each neighbor of u
65 |                     if (d[v] == INF)
66 |                     {
67 |                         d[v] = d[u] + 1;
68 |                         ans[v]=d[v]%2;
69 |                         q.push(v);
70 |                     }
71 |                     else if((abs(d[v]-d[u]))%2==0)
72 |                     {
73 |                         flag=1;
74 |                     }
75 |                 }
76 |             }
77 |         }
78 |     }
79 |     if(flag==1)
80 |     {
81 |         cout<<"IMPOSSIBLE";
82 |         return 0;
83 |     }
84 |     for(int i=0;i<n;i++)
85 |     {
86 |         cout<<ans[i]+1<<" ";
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Counting Rooms.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int dr[] = {1,-1,0,0};
33 | int dc[] = {0,0,1,-1};
34 | char c[1005][1005];
35 | ll n,m,vis[1005][1005];
36 | 
37 | void dfs(ll i,ll j)
38 | {
39 |     vis[i][j]=1;
40 |     for(int k=0;k<4;k++)
41 |     {
42 |         ll u=i+dr[k],v=j+dc[k];
43 |         if(u>=0 && u<n && v>=0 && v<m && vis[u][v]==0 && c[u][v]=='.')
44 |         {
45 |             dfs(u,v);
46 |         }
47 |     }
48 | }
49 | int main()
50 | {
51 |     ios::sync_with_stdio(0);
52 |     cin.tie(0);
53 |     cout.tie(0);
54 |     cin>>n>>m;
55 |     for(int i=0;i<n;i++)
56 |     {
57 |         for(int j=0;j<m;j++)
58 |         {
59 |             cin>>c[i][j];
60 |             vis[i][j]=0;
61 |         }
62 |     }
63 |     ll ans=0;
64 |     for(int i=0;i<n;i++)
65 |     {
66 |         for(int j=0;j<m;j++)
67 |         {
68 |             if(vis[i][j]==0 && c[i][j]=='.')
69 |             {
70 |                 dfs(i,j);
71 |                 ans++;
72 |             }
73 |         }
74 |     }
75 |     cout<<ans;
76 | }
77 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Course Schedule.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | vll AdjList[100005];
32 | ll dfs_num[100005],cycle;
33 | vll ts;
34 | 
35 | void graphCheck(int u) { // DFS for checking graph edge properties
36 |     dfs_num[u] = 2; // color u as EXPLORED instead of VISITED
37 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
38 |         ll v = AdjList[u][j];
39 |         if (dfs_num[v] == 0) { // Tree Edge, EXPLORED->UNVISITED
40 |             graphCheck(v);
41 |         }
42 |         else if (dfs_num[v] == 2) { // EXPLORED->EXPLORED
43 |             cycle=1;
44 |             return;
45 |         }
46 |     }
47 |     ts.PB(u);
48 |     dfs_num[u] = 1; // after recursion, color u as VISITED (DONE)
49 | }
50 | 
51 | int main()
52 | {
53 |     ios::sync_with_stdio(0);
54 |     cin.tie(0);
55 |     cout.tie(0);
56 |     ll n,m,a,b;
57 |     cin>>n>>m;
58 |     for(int i=0;i<m;i++)
59 |     {
60 |         cin>>a>>b;
61 |         a--; b--;
62 |         AdjList[a].PB(b);
63 |     }
64 |     cycle=0;
65 |     for(int i=0;i<n;i++)
66 |     {
67 |         dfs_num[i]=0;
68 |     }
69 |     for(int i=0;i<n;i++)
70 |     {
71 |         if(dfs_num[i]==0)
72 |         {
73 |             graphCheck(i);
74 |         }
75 |     }
76 |     if(cycle) cout<<"IMPOSSIBLE";
77 |     else
78 |     {
79 |         reverse(ts.begin(),ts.end());
80 |         for(int i=0;i<ts.size();i++)
81 |         {
82 |             cout<<ts[i]+1<<" ";
83 |         }
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Cycle Finding.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | ll INF=1e16;
32 |  
33 | int main()
34 | {
35 |     ios::sync_with_stdio(0);
36 |     cin.tie(0);
37 |     cout.tie(0);
38 |     ll n,m,a,b,c;
39 |     cin>>n>>m;
40 |     vector<pair<pll,ll> > edge;
41 |     for(int i=0;i<m;i++)
42 |     {
43 |         cin>>a>>b>>c;
44 |         a--; b--;
45 |         edge.PB({{a,b},c});
46 |     }
47 |     vll dist(n, INF);
48 |     vll parent(n,-1);
49 |     dist[0] = 0;
50 |     for (int i = 0; i < n - 1; i++) // relax all E edges V-1 times
51 |         for(int j=0;j<edge.size();j++)
52 |         {
53 |             ll a=edge[j].F.F,b=edge[j].F.S,c=edge[j].S; // record SP spanning here if needed
54 |             if(dist[b] > dist[a] + c)
55 |             {
56 |                 dist[b] = dist[a] + c; // relax
57 |                 parent[b]=a;
58 |             }
59 |         }
60 |     ll st=-1;
61 |     for(int j=0;j<edge.size();j++)
62 |     {
63 |         ll a=edge[j].F.F,b=edge[j].F.S,c=edge[j].S; // record SP spanning here if needed
64 |         if(dist[b] > dist[a] + c)
65 |         {
66 |             dist[b] = dist[a] + c; // relax
67 |             parent[b]=a;
68 |             st=b;
69 |         }
70 |     }
71 |     if(st==-1)
72 |     {
73 |         cout<<"NO";
74 |         return 0;
75 |     }
76 |     cout<<"YES\n";
77 |     for(int i=0;i<n;i++)
78 |     {
79 |         st=parent[st];
80 |     }
81 |     vll ans;
82 |     ll temp=st;
83 |     ans.PB(temp); 
84 |     while(parent[temp]!=st)
85 |     {
86 |         temp=parent[temp];
87 |         ans.PB(temp);
88 |     }
89 |     ans.PB(st);
90 |     reverse(ans.begin(),ans.end());
91 |     for(int i=0;i<ans.size();i++)
92 |     {
93 |         cout<<ans[i]+1<<" ";
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Flight Routes.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vector<pll> AdjList[100005];
33 | 
34 | int main()
35 | {
36 |     ios::sync_with_stdio(0);
37 |     cin.tie(0);
38 |     cout.tie(0);
39 |     ll n,m,k,a,b,c;
40 |     cin>>n>>m>>k;
41 |     for(int i=0;i<m;i++)
42 |     {
43 |         cin>>a>>b>>c;
44 |         a--; b--;
45 |         AdjList[a].PB({b,c});
46 |     }
47 |     vll ans;
48 |     ll cnt=0;
49 |     vll dist(n, 0); 
50 |     priority_queue< pair<ll,ll>, vector<pair<ll,ll> >, greater<pair<ll,ll> > > pq; 
51 |     pq.push(make_pair(0, 0));
52 |     while (!pq.empty())
53 |     {
54 |         pair<ll,ll> front = pq.top(); pq.pop(); 
55 |         ll d = front.first, u = front.second;
56 |         if (dist[u]>k) continue;
57 |         if(u==n-1)
58 |         {
59 |             cnt++;
60 |             ans.PB(d);
61 |             if(cnt==k) break;
62 |         }
63 |         dist[u]++;
64 |         for (int j = 0; j < (int)AdjList[u].size(); j++)
65 |         {
66 |             pair<ll,ll> v = AdjList[u][j];
67 |             if(dist[v.first]>k) continue;
68 |             pq.push(make_pair(d+v.second, v.first));
69 |         }
70 |     }
71 |     for(int i=0;i<ans.size();i++)
72 |     {
73 |         cout<<ans[i]<<" ";
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Game Routes.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | vll AdjList[100005],ts;
32 | ll dfs_num[100005],dp[100005];
33 | 
34 | void dfs(int u) {
35 |     dfs_num[u] = 1;
36 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
37 |         ll v = AdjList[u][j];
38 |         if (dfs_num[v] == 0)
39 |             dfs(v);
40 |     }
41 |     ts.PB(u);
42 | }
43 | int main()
44 | {
45 |     ios::sync_with_stdio(0);
46 |     cin.tie(0);
47 |     cout.tie(0);
48 |     ll n,m,a,b;
49 |     cin>>n>>m;
50 |     for(int i=0;i<m;i++)
51 |     {
52 |         cin>>a>>b;
53 |         a--; b--;
54 |         AdjList[a].PB(b);
55 |     }
56 |     for(int i=0;i<n;i++)
57 |     {
58 |         dfs_num[i]=0;
59 |         dp[i]=0;
60 |     }
61 |     for(int i=0;i<n;i++)
62 |     {
63 |         if(dfs_num[i]==0)
64 |         {
65 |             dfs(i);
66 |         }
67 |     }
68 |     reverse(ts.begin(),ts.end());
69 |     dp[0]=1;
70 |     for(int i=0;i<ts.size();i++)
71 |     {
72 |         ll u=ts[i];
73 |         for(int j=0;j<AdjList[u].size();j++)
74 |         {
75 |             ll v=AdjList[u][j];
76 |             dp[v]+=dp[u];
77 |             dp[v]%=MOD;
78 |         }
79 |     }
80 |     cout<<dp[n-1];
81 | }
82 | 


--------------------------------------------------------------------------------
/Graph Algorithms/High Score.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | ll INF=1e15;
32 | vector<pll> AdjList[5005];
33 | ll dfs_num[5005];
34 | 
35 | void dfs(int u) {
36 |     dfs_num[u] = 1;
37 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
38 |         pll v = AdjList[u][j];
39 |         if (dfs_num[v.F] == 0)
40 |             dfs(v.F);
41 |     }
42 | }
43 | int main()
44 | {
45 |     ios::sync_with_stdio(0);
46 |     cin.tie(0);
47 |     cout.tie(0);
48 |     ll n,m,a,b,x;
49 |     cin>>n>>m;
50 |     for(int i=0;i<m;i++)
51 |     {
52 |         cin>>a>>b>>x;
53 |         a--; b--;
54 |         AdjList[a].PB({b,-x});
55 |     }
56 |     vll dist(n, INF); dist[0] = 0;
57 |     for (int i = 0; i < n - 1; i++) // relax all E edges V-1 times
58 |         for (int u = 0; u < n; u++) // these two loops = O(E), overall O(VE)
59 |             for (int j = 0; j < (int)AdjList[u].size(); j++) {
60 |                 pair<ll,ll> v = AdjList[u][j]; // record SP spanning here if needed
61 |                 if(dist[u]!=INF) dist[v.first] = min(dist[v.first], dist[u] + v.second); // relax
62 |             }
63 |     vll check;
64 |     bool hasNegativeCycle = false;
65 |     for (int u = 0; u < n; u++) // one more pass to check
66 |         for (int j = 0; j < (int)AdjList[u].size(); j++) {
67 |             pair<ll,ll> v = AdjList[u][j];
68 |             if (dist[v.first] > dist[u] + v.second && dist[u]!=INF) // if this is still possible
69 |             {
70 |                 hasNegativeCycle = true; // then negative cycle exists!
71 |                 check.PB(v.first);
72 |             }
73 |         }
74 |     for(int i=0;i<n;i++)
75 |     {
76 |         dfs_num[i]=0;
77 |     }
78 |     for(int i=0;i<check.size();i++)
79 |     {
80 |         if(!dfs_num[check[i]])
81 |         {
82 |             dfs(check[i]);
83 |         }
84 |     }
85 |     if(dfs_num[n-1]) cout<<"-1";
86 |     else cout<<-dist[n-1];
87 | }
88 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Longest Flight Route.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | #include <ext/pb_ds/assoc_container.hpp>
  4 | #include <ext/pb_ds/tree_policy.hpp>
  5 | using namespace __gnu_pbds;
  6 | #define ll long long
  7 | #define vll vector<ll>
  8 | #define ld long double
  9 | #define pll pair<ll,ll>
 10 | #define PB push_back
 11 | #define MP make_pair
 12 | #define F first
 13 | #define S second
 14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
 15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
 16 | #define ook order_of_key
 17 | #define fbo find_by_order
 18 | const int MOD=1000000007;
 19 | long long int inverse(long long int i){
 20 |     if(i==1) return 1;
 21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
 22 | }
 23 | ll POW(ll a,ll b)
 24 | {
 25 |     if(b==0) return 1;
 26 |     if(b==1) return a%MOD;
 27 |     ll temp=POW(a,b/2);
 28 |     if(b%2==0) return (temp*temp)%MOD;
 29 |     else return (((temp*temp)%MOD)*a)%MOD;
 30 | }
 31 | vll AdjList[100005],ts;
 32 | ll dfs_num[100005],dp[100005],p[100005];
 33 | 
 34 | void dfs(int u) {
 35 |     dfs_num[u] = 1;
 36 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
 37 |         ll v = AdjList[u][j];
 38 |         if (dfs_num[v] == 0)
 39 |         {
 40 |             dfs(v);
 41 |         }
 42 |     }
 43 |     ts.PB(u);
 44 | }
 45 | int main()
 46 | {
 47 |     ios::sync_with_stdio(0);
 48 |     cin.tie(0);
 49 |     cout.tie(0);
 50 |     ll n,m,a,b;
 51 |     cin>>n>>m;
 52 |     for(int i=0;i<m;i++)
 53 |     {
 54 |         cin>>a>>b;
 55 |         a--; b--;
 56 |         AdjList[a].PB(b);
 57 |     }
 58 |     for(int i=0;i<n;i++)
 59 |     {
 60 |         dfs_num[i]=0;
 61 |         dp[i]=1;
 62 |         p[i]=-1;
 63 |     }
 64 |     dfs(0);
 65 |     if(!dfs_num[n-1]) cout<<"IMPOSSIBLE";
 66 |     else
 67 |     {
 68 |         reverse(ts.begin(),ts.end());
 69 |         for(int i=0;i<ts.size();i++)
 70 |         {
 71 |             if(ts[i]==n-1) break;
 72 |             if(ts[i]==0) dp[i]=1;
 73 |             ll u=ts[i];
 74 |             for(int j=0;j<AdjList[u].size();j++)
 75 |             {
 76 |                 ll v = AdjList[u][j];
 77 |                 if(dp[v]<dp[u]+1)
 78 |                 {
 79 |                     dp[v]=dp[u]+1;
 80 |                     p[v]=u;
 81 |                 }
 82 |             }
 83 |         }
 84 |         vll ans;
 85 |         ll temp=n-1;
 86 |         ans.PB(temp);;
 87 |         while(p[temp]!=0)
 88 |         {
 89 |             temp=p[temp];
 90 |             ans.PB(temp);
 91 |         }
 92 |         ans.PB(0);
 93 |         reverse(ans.begin(),ans.end());
 94 |         cout<<ans.size()<<"\n";
 95 |         for(int i=0;i<ans.size();i++)
 96 |         {
 97 |             cout<<ans[i]+1<<" ";
 98 |         }
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Message Route.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | vll AdjList[100005];
32 | ll INF=1e10;
33 | int main()
34 | {
35 |     ios::sync_with_stdio(0);
36 |     cin.tie(0);
37 |     cout.tie(0);
38 |     ll n,m,a,b;
39 |     cin>>n>>m;
40 |     for(int i=0;i<m;i++)
41 |     {
42 |         cin>>a>>b;
43 |         a--;
44 |         b--;
45 |         AdjList[a].PB(b);
46 |         AdjList[b].PB(a);
47 |     }
48 |     vll d(n, INF); 
49 |     vll p(n,-1);
50 |     d[0] = 0;
51 |     queue<ll> q; 
52 |     q.push(0);
53 |     while (!q.empty())
54 |     {
55 |         ll u = q.front(); q.pop(); // queue: layer by layer!
56 |         for (int j = 0; j < (int)AdjList[u].size(); j++)
57 |         {
58 |             ll v = AdjList[u][j]; // for each neighbor of u
59 |             if (d[v] == INF)
60 |             {
61 |                 d[v] = d[u] + 1;
62 |                 p[v]=u;
63 |                 q.push(v);
64 |             }
65 |         }
66 |     }
67 |     if(p[n-1]==-1)
68 |     {
69 |         cout<<"IMPOSSIBLE";
70 |         return 0;
71 |     }
72 |     vll ans;
73 |     ll u=n-1;
74 |     while(u!=0)
75 |     {
76 |         ans.PB(u);
77 |         u=p[u];
78 |     }
79 |     cout<<ans.size()+1<<"\n1 ";
80 |     for(int i=ans.size()-1;i>=0;i--)
81 |     {
82 |         cout<<ans[i]+1<<" ";
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Round Trip II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | vll AdjList[100005];
32 | ll dfs_num[100005], dfs_parent[100005];
33 | vll ans;
34 | 
35 | void graphCheck(int u) { // DFS for checking graph edge properties
36 |     dfs_num[u] = 2; // color u as EXPLORED instead of VISITED
37 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
38 |         ll v = AdjList[u][j];
39 |         if (dfs_num[v] == 0) { // Tree Edge, EXPLORED->UNVISITED
40 |             dfs_parent[v] = u; // parent of this children is me
41 |             graphCheck(v);
42 |         }
43 |         else if (dfs_num[v] == 2) { // EXPLORED->EXPLORED
44 |             ans.clear();
45 |             ll temp=u;
46 |             ans.PB(u+1);
47 |             while(temp!=v)
48 |             {
49 |                 temp=dfs_parent[temp];
50 |                 ans.PB(temp+1);
51 |             }
52 |             ans.PB(u+1);
53 |             reverse(ans.begin(),ans.end());
54 |             if(ans.size()>=3)
55 |             {
56 |                 cout<<ans.size()<<"\n";
57 |                 for(int i=0;i<ans.size();i++)
58 |                 {
59 |                     cout<<ans[i]<<" ";
60 |                 }
61 |                 exit(0);
62 |             }
63 |         }
64 |     }
65 |     dfs_num[u] = 1; // after recursion, color u as VISITED (DONE)
66 | }
67 | int main()
68 | {
69 |     ios::sync_with_stdio(0);
70 |     cin.tie(0);
71 |     cout.tie(0);
72 |     ll n,m,a,b;
73 |     cin>>n>>m;
74 |     for(int i=0;i<m;i++)
75 |     {
76 |         cin>>a>>b;
77 |         a--; b--;
78 |         AdjList[a].PB(b);
79 |     }
80 |     for(int i=0;i<n;i++)
81 |     {
82 |         dfs_num[i]=0;
83 |         dfs_parent[i]=-1;
84 |     }
85 |     for(int i=0;i<n;i++)
86 |     {
87 |         if(dfs_num[i]==0)
88 |         {
89 |             graphCheck(i);
90 |         }
91 |     }
92 |     cout<<"IMPOSSIBLE";
93 | }
94 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Shortest Routes I.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll INF=1e15;
33 | 
34 | int main()
35 | {
36 |     ios::sync_with_stdio(0);
37 |     cin.tie(0);
38 |     cout.tie(0);
39 |     ll n,m,a,b,c;
40 |     cin>>n>>m;
41 |     vector<pll> AdjList[n];
42 |     for(int i=0;i<m;i++)
43 |     {
44 |         cin>>a>>b>>c;
45 |         a--; b--;
46 |         AdjList[a].PB({b,c});
47 |     }
48 |     vll dist(n, INF); 
49 |     dist[0] = 0;
50 |     priority_queue< pair<ll,ll>, vector<pair<ll,ll> >, greater<pair<ll,ll> > > pq; pq.push(make_pair(0, 0));
51 |     while (!pq.empty())
52 |     {
53 |         pair<ll,ll> front = pq.top(); pq.pop(); // greedy: get shortest unvisited vertex
54 |         int d = front.first, u = front.second;
55 |         if (d > dist[u]) continue;
56 |         for (int j = 0; j < (int)AdjList[u].size(); j++)
57 |         {
58 |             pair<ll,ll> v = AdjList[u][j];
59 |             if (dist[u] + v.second < dist[v.first])
60 |             {
61 |                 dist[v.first] = dist[u] + v.second; // relax operation
62 |                 pq.push(make_pair(dist[v.first], v.first));
63 |             }
64 |         }
65 |     }
66 |     for(int i=0;i<n;i++)
67 |     {
68 |         cout<<dist[i]<<" ";
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/Graph Algorithms/Shortest Routes II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll INF=1e15;
33 | 
34 | int main()
35 | {
36 |     ios::sync_with_stdio(0);
37 |     cin.tie(0);
38 |     cout.tie(0);
39 |     ll n,m,q,a,b,c;
40 |     cin>>n>>m>>q;
41 |     vector<vll> AdjMat(n,vll (n,INF));
42 |     for(int i=0;i<m;i++)
43 |     {
44 |         cin>>a>>b>>c;
45 |         a--; b--;
46 |         AdjMat[a][b]=min(AdjMat[a][b],c);
47 |         AdjMat[b][a]=min(AdjMat[b][a],c);
48 |     }
49 |     for (int k = 0; k < n; k++) // remember that loop order is k->i->j
50 |         for (int i = 0; i < n; i++)
51 |             for (int j = 0; j < n; j++)
52 |                 AdjMat[i][j] = min(AdjMat[i][j], AdjMat[i][k] + AdjMat[k][j]);
53 |     for(int i=0;i<q;i++)
54 |     {
55 |         cin>>a>>b;
56 |         a--; b--;
57 |         if(a==b) cout<<"0\n";
58 |         else if(AdjMat[a][b]==INF) cout<<"-1\n";
59 |         else cout<<AdjMat[a][b]<<"\n";   
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/Introductory Problems/Apple Division.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll p[n],sum=0;
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>p[i];
43 |         sum+=p[i];
44 |     }
45 |     ll ans=LLONG_MAX;
46 |     for(ll i=0;i<(1ll<<n);i++)
47 |     {
48 |         ll sum1=0;
49 |         for(ll j=0;j<n;j++)
50 |         {
51 |             if((i&(1ll<<j))!=0)
52 |             {
53 |                 sum1+=p[j];
54 |             }
55 |         }
56 |         ans=min(ans,abs(sum-2*sum1));
57 |     }
58 |     cout<<ans;
59 | }
60 | 


--------------------------------------------------------------------------------
/Introductory Problems/Bit Strings.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     cout<<POW(2,n);
40 | }
41 | 


--------------------------------------------------------------------------------
/Introductory Problems/Chessboard and Queens.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | //#define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | char ch[8][8];
33 | ll ans=0;
34 | ll ld[15],rd[15],row[8];
35 | 
36 | void f(ll j)
37 | {
38 |     if(j==8) 
39 |     {
40 |         ans++;
41 |         return;
42 |     }
43 |     for(int i=0;i<8;i++)
44 |     {
45 |         if(ch[i][j]=='.' && ld[i-j+7]==0 && rd[i+j]==0 && row[i]==0)
46 |         {
47 |             ld[i-j+7]=1;
48 |             rd[i+j]=1;
49 |             row[i]=1;
50 |             f(j+1);
51 |             ld[i-j+7]=0;
52 |             rd[i+j]=0;
53 |             row[i]=0;
54 |         }
55 |     }
56 | }
57 | 
58 | int main()
59 | {
60 |     ios::sync_with_stdio(0);
61 |     cin.tie(0);
62 |     cout.tie(0);
63 |     for(int i=0;i<8;i++)
64 |     {
65 |         for(int j=0;j<8;j++)
66 |         {
67 |             cin>>ch[i][j];
68 |         }
69 |     }
70 |     f(0);
71 |     cout<<ans;
72 | }
73 | 


--------------------------------------------------------------------------------
/Introductory Problems/Coin Piles.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll t;
38 |     cin>>t;
39 |     for(int i=0;i<t;i++)
40 |     {
41 |         ll a,b;
42 |         cin>>a>>b;
43 |         if((a+b)%3!=0 || 2*a<b || 2*b<a) cout<<"NO";
44 |         else cout<<"YES";
45 |         cout<<"\n";
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/Introductory Problems/Creating Strings.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     string s;
38 |     cin>>s;
39 |     vll v;
40 |     for(int i=0;i<s.size();i++)
41 |     {
42 |         v.PB(s[i]-'a');
43 |     }
44 |     sort(v.begin(),v.end());
45 |     vector<string> ans;
46 |     do
47 |     {
48 |         string temp;
49 |         for(int i=0;i<v.size();i++)
50 |         {
51 |             temp.PB((char)(v[i]+'a'));
52 |         }
53 |         ans.PB(temp);
54 |     }
55 |     while(next_permutation(v.begin(),v.end()));
56 |     cout<<ans.size()<<"\n";
57 |     for(int i=0;i<ans.size();i++)
58 |     {
59 |         cout<<ans[i]<<"\n";
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/Introductory Problems/Digit Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll dp[19];
38 |     for(ll i=1;i<=18;i++)
39 |     {
40 |         dp[i]=9ll*pow(10ll,i-1)*i;
41 |     }
42 |     ll pre[19];
43 |     pre[0]=0;
44 |     for(int i=1;i<19;i++)
45 |     {
46 |         pre[i]=pre[i-1]+dp[i];
47 |     }
48 |     ll q;
49 |     cin>>q;
50 |     for(int i=0;i<q;i++)
51 |     {
52 |         ll k;
53 |         cin>>k;
54 |         ll it=lower_bound(pre,pre+18,k)-pre;
55 |         it--;
56 |         ll rem=k-pre[it],digits=it+1;
57 |         ll num=(ll)pow(10ll,it)-1ll+(rem+digits-1ll)/digits-1ll;
58 |         rem=rem%digits;
59 |         if(rem==0) rem=digits;
60 |         rem=(digits+1ll)-rem;
61 |         ll c=0,temp=num+1ll;
62 |         while(temp!=0)
63 |         {
64 |             c++;
65 |             if(c==rem)
66 |             {
67 |                 cout<<temp%10;
68 |                 break;
69 |             }
70 |             temp/=10;
71 |         }
72 |         cout<<"\n";
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/Introductory Problems/Gray Code.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     for(ll i=0;i<(1ll<<n);i++)
40 |     {
41 |         ll val=i^(i>>1);  
42 |         for(ll j=n-1;j>=0;j--)
43 |         {
44 |             if((val&(1ll<<j))!=0)
45 |             {
46 |                 cout<<1;
47 |             }
48 |             else cout<<0;
49 |         }
50 |         cout<<"\n";
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Introductory Problems/Increasing Array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll x[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>x[i];
43 |     }
44 |     ll ans=0;
45 |     for(int i=1;i<n;i++)
46 |     {
47 |         ans+=max(x[i],x[i-1])-x[i];
48 |         x[i]=max(x[i],x[i-1]);
49 |     }
50 |     cout<<ans;
51 | }
52 | 


--------------------------------------------------------------------------------
/Introductory Problems/Missing Number.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll cnt[n+1]={};
40 |     for(int i=0;i<n-1;i++)
41 |     {
42 |         ll x;
43 |         cin>>x;
44 |         cnt[x]++;
45 |     }
46 |     for(int i=1;i<=n;i++)
47 |     {
48 |         if(cnt[i]==0)
49 |         {
50 |             cout<<i;
51 |             return 0;
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/Introductory Problems/Number Spiral.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll t;
38 |     cin>>t;
39 |     for(int i=0;i<t;i++)
40 |     {
41 |         ll y,x;
42 |         cin>>y>>x;
43 |         if(x<y)
44 |         {
45 |             if(y%2==0) cout<<y*y-x+1;
46 |             else cout<<(y-1)*(y-1)+x;
47 |         }
48 |         else
49 |         {
50 |             if(x%2==1) cout<<x*x-y+1;
51 |             else cout<<(x-1)*(x-1)+y;
52 |         }
53 |         cout<<"\n";
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/Introductory Problems/Palindrome Reorder.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | #include <ext/pb_ds/assoc_container.hpp>
  4 | #include <ext/pb_ds/tree_policy.hpp>
  5 | using namespace __gnu_pbds;
  6 | #define ll long long
  7 | #define vll vector<ll>
  8 | #define ld long double
  9 | #define pll pair<ll,ll>
 10 | #define PB push_back
 11 | #define MP make_pair
 12 | #define F first
 13 | #define S second
 14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
 15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
 16 | #define ook order_of_key
 17 | #define fbo find_by_order
 18 | const int MOD=1000000007; //998244353
 19 | long long int inverse(long long int i){
 20 |     if(i==1) return 1;
 21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
 22 | }
 23 | ll POW(ll a,ll b)
 24 | {
 25 |     if(b==0) return 1;
 26 |     if(b==1) return a%MOD;
 27 |     ll temp=POW(a,b/2);
 28 |     if(b%2==0) return (temp*temp)%MOD;
 29 |     else return (((temp*temp)%MOD)*a)%MOD;
 30 | }
 31 | 
 32 | int main()
 33 | {
 34 |     ios::sync_with_stdio(0);
 35 |     cin.tie(0);
 36 |     cout.tie(0);
 37 |     string s;
 38 |     cin>>s;
 39 |     ll cnt[26]={},n=s.size();
 40 |     for(int i=0;i<s.size();i++)
 41 |     {
 42 |         cnt[s[i]-'A']++;
 43 |     }
 44 |     if(n%2==0)
 45 |     {
 46 |         ll flag=0;
 47 |         for(int i=0;i<26;i++)
 48 |         {
 49 |             if(cnt[i]%2!=0) flag=1;
 50 |         }
 51 |         if(flag==1) cout<<"NO SOLUTION";
 52 |         else
 53 |         {
 54 |             for(int i=0;i<26;i++)
 55 |             {
 56 |                 for(int j=0;j<cnt[i]/2;j++)
 57 |                 {
 58 |                     cout<<(char)(i+'A');
 59 |                 }
 60 |             }
 61 |             for(int i=25;i>=0;i--)
 62 |             {
 63 |                 for(int j=0;j<cnt[i]/2;j++)
 64 |                 {
 65 |                     cout<<(char)(i+'A');
 66 |                 }
 67 |             }
 68 |         }
 69 |     }
 70 |     else
 71 |     {
 72 |         ll flag=0;
 73 |         char och;
 74 |         for(int i=0;i<26;i++)
 75 |         {
 76 |             if(cnt[i]%2!=0) 
 77 |             {
 78 |                 flag++;
 79 |                 och=i;
 80 |             }
 81 |         }
 82 |         if(flag>=2) cout<<"NO SOLUTION";
 83 |         else
 84 |         {
 85 |             for(int i=0;i<26;i++)
 86 |             {
 87 |                 for(int j=0;j<cnt[i]/2;j++)
 88 |                 {
 89 |                     cout<<(char)(i+'A');
 90 |                 }
 91 |             }
 92 |             cout<<(char)(och+'A');
 93 |             for(int i=25;i>=0;i--)
 94 |             {
 95 |                 for(int j=0;j<cnt[i]/2;j++)
 96 |                 {
 97 |                     cout<<(char)(i+'A');
 98 |                 }
 99 |             }
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/Introductory Problems/Permutations.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     if(n==1) cout<<1;
40 |     else if(n==2 || n==3) cout<<"NO SOLUTION";
41 |     else
42 |     {
43 |         for(int i=0;i<n/2;i++)
44 |         {
45 |             cout<<2*(i+1)<<" ";
46 |         }
47 |         for(int i=0;i<(n+1)/2;i++)
48 |         {
49 |             cout<<2*i+1<<" ";
50 |         }
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Introductory Problems/Repetitions.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     string s;
38 |     cin>>s;
39 |     char ch=s[0];
40 |     ll ans=1,c=1;
41 |     for(int i=1;i<s.size();i++)
42 |     {
43 |         if(s[i]!=ch)
44 |         {
45 |             ans=max(ans,c);
46 |             ch=s[i];
47 |             c=1;
48 |         }
49 |         else
50 |         {
51 |             c++;
52 |         }
53 |     }
54 |     ans=max(ans,c);
55 |     cout<<ans;
56 | }
57 | 


--------------------------------------------------------------------------------
/Introductory Problems/Tower of Hanoi.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | void f(ll a,ll b,ll c,ll n)
33 | {
34 |     if(n==0) return;
35 |     f(a,c,b,n-1);
36 |     cout<<a<<" "<<c<<"\n";
37 |     f(b,a,c,n-1);
38 | }
39 | 
40 | int main()
41 | {
42 |     ios::sync_with_stdio(0);
43 |     cin.tie(0);
44 |     cout.tie(0);
45 |     ll n;
46 |     cin>>n;
47 |     cout<<pow(2ll,n)-1<<"\n";
48 |     f(1,2,3,n);
49 | }
50 | 


--------------------------------------------------------------------------------
/Introductory Problems/Trailing Zeros.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll ans=0;
40 |     while(n!=0)
41 |     {
42 |         n/=5;
43 |         ans+=n;
44 |     }
45 |     cout<<ans;
46 | }
47 | 


--------------------------------------------------------------------------------
/Introductory Problems/Two Knights.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     for(ll i=1;i<=n;i++)
40 |     {
41 |         cout<<(i*i*(i*i-1))/2 - 4*(i-1)*(i-2)<<"\n";
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Introductory Problems/Two Sets.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     if(n%4==1 || n%4==2) cout<<"NO";
40 |     else
41 |     {
42 |         cout<<"YES\n";
43 |         ll sum=(n*(n+1))/4;
44 |         vll v1,v2;
45 |         for(int i=n;i>=1;i--)
46 |         {
47 |             if(sum>=i)
48 |             {
49 |                 sum-=i;
50 |                 v1.PB(i);
51 |             }
52 |             else v2.PB(i);
53 |         }
54 |         cout<<v1.size()<<"\n";
55 |         for(int i=0;i<v1.size();i++)
56 |         {
57 |             cout<<v1[i]<<" ";
58 |         }
59 |         cout<<"\n"<<v2.size()<<"\n";
60 |         for(int i=0;i<v2.size();i++)
61 |         {
62 |             cout<<v2[i]<<" ";
63 |         }
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/Introductory Problems/Weird Algorithm.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     while(n!=1)
40 |     {
41 |         cout<<n<<" ";
42 |         if(n%2==0) n/=2;
43 |         else n=3*n+1;
44 |     }
45 |     cout<<"1 ";
46 | }


--------------------------------------------------------------------------------
/Mathematics/Binomial Coefficients.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll fact[1000001];
38 |     fact[0]=1;
39 |     fact[1]=1;
40 |     for(int i=2;i<=1000000;i++)
41 |     {
42 |         fact[i]=(fact[i-1]*i)%MOD;
43 |     }
44 |     ll n,a,b;
45 |     cin>>n;
46 |     for(int i=0;i<n;i++)
47 |     {
48 |         cin>>a>>b;
49 |         ll ans=(fact[a]*inverse(fact[b]))%MOD;
50 |         ans*=inverse(fact[a-b]);
51 |         ans%=MOD;
52 |         cout<<ans<<"\n";
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/Mathematics/Bracket Sequences I.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     if(n%2==1) 
40 |     {
41 |         cout<<0;
42 |         return 0;
43 |     }
44 |     n/=2;
45 |     ll fact[2*n+1];
46 |     fact[0]=1;
47 |     for(ll i=1;i<=2*n;i++)
48 |     {
49 |         fact[i]=(fact[i-1]*i)%MOD;
50 |     }
51 |     ll ans=(fact[2*n]*inverse(fact[n]))%MOD;
52 |     ans*=(inverse(fact[n])*inverse(n+1))%MOD;
53 |     ans%=MOD;
54 |     cout<<ans;
55 | }
56 | 


--------------------------------------------------------------------------------
/Mathematics/Bracket Sequences II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     if(n%2==1)
40 |     {
41 |         cout<<0;
42 |         return 0;
43 |     }
44 |     n/=2;
45 |     string s;
46 |     cin>>s;
47 |     ll k=0,o=0;
48 |     for(int i=0;i<s.size();i++)
49 |     {
50 |         if(s[i]=='(') 
51 |         {
52 |             k++;
53 |             o++;
54 |         }
55 |         else k--;
56 |         if(k<0)
57 |         {
58 |             cout<<0;
59 |             return 0;
60 |         }
61 |     }
62 |     n-=o;
63 |     if(k<0 || n<0 || 2*n+k<n)
64 |     {
65 |         cout<<0;
66 |         return 0;
67 |     }
68 |     ll fact[2*n+k+1];
69 |     fact[0]=1;
70 |     for(int i=1;i<=2*n+k;i++)
71 |     {
72 |         fact[i]=(fact[i-1]*i)%MOD;
73 |     }
74 |     ll ans=(fact[2*n+k]*inverse(fact[n]))%MOD;
75 |     ans*=inverse(fact[n+k]);
76 |     ans%=MOD;
77 |     ans*=((k+1)*inverse(n+k+1))%MOD;
78 |     ans%=MOD;
79 |     cout<<ans;
80 | }
81 | 


--------------------------------------------------------------------------------
/Mathematics/Candy Lottery.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,k;
38 |     cin>>n>>k;
39 |     ld ans=0;
40 |     for(int i=1;i<=k;i++)
41 |     {
42 |         ld add=1,sub=1;
43 |         for(int j=1;j<=n;j++)
44 |         {
45 |             add*=(ld)i/(ld)k;
46 |             sub*=(ld)(i-1)/(ld)k;
47 |         }
48 |         ans+=(ld)(i)*(ld)(add-sub);
49 |     }
50 |     ans*=1e6;
51 |     ans=llround(ans);
52 |     ans/=1e6;
53 |     cout<<fixed<<setprecision(6)<<ans;
54 | }
55 | 


--------------------------------------------------------------------------------
/Mathematics/Christmas Party.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll d[n+1];
40 |     d[1]=0;
41 |     d[2]=1;
42 |     for(ll i=3;i<=n;i++)
43 |     {
44 |         d[i]=(((d[i-1]+d[i-2])%MOD)*(i-1))%MOD;
45 |     }
46 |     cout<<d[n];
47 | }
48 | 


--------------------------------------------------------------------------------
/Mathematics/Common Divisors.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll x[n];
40 |     ll cnt[1000001]={};
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>x[i];
44 |         cnt[x[i]]++;
45 |     }
46 |     for(int i=1000000;i>=1;i--)
47 |     {
48 |         ll d=0;
49 |         for(int j=i;j<=1000000;j+=i) d+=cnt[j];
50 |         if(d>=2)
51 |         {
52 |             cout<<i;
53 |             return 0;
54 |         }
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/Mathematics/Counting Coprime Pairs.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll lpf[1000001],mobius[1000001];
33 | 
34 | void least_prime_factor()
35 | {
36 |     for(int i=2;i<1000001;i++)
37 |     {
38 |         if(!lpf[i])
39 |         {
40 |             for(int j=i;j<1000001;j+=i)
41 |             {
42 |                 if(!lpf[j]) lpf[j]=i;
43 |             }
44 |         }
45 |     }
46 | }
47 |  
48 | void Mobius()
49 | {
50 |     for(int i=1;i<1000001;i++) 
51 |     {
52 |         if(i==1) mobius[i]=1;
53 |         else 
54 |         {
55 |             if(lpf[i/lpf[i]]==lpf[i]) mobius[i]=0;
56 |             else mobius[i]=-1*mobius[i/lpf[i]];
57 |         }
58 |     }
59 | }
60 | 
61 | int main()
62 | {
63 |     ios::sync_with_stdio(0);
64 |     cin.tie(0);
65 |     cout.tie(0);
66 |     ll n;
67 |     cin>>n;
68 |     ll x[n],cnt[1000001]={};
69 |     for(int i=0;i<n;i++)
70 |     {
71 |         cin>>x[i];
72 |         cnt[x[i]]++;
73 |     }
74 |     least_prime_factor();
75 |     Mobius();
76 |     ll ans=0;
77 |     for(int i=1;i<1000001;i++)
78 |     {
79 |         if(mobius[i]==0) continue;
80 |         ll d=0;
81 |         for(int j=i;j<1000001;j+=i)
82 |         {
83 |             d+=cnt[j];
84 |         }
85 |         ans+=(d*(d-1))/2*mobius[i];
86 |     }
87 |     cout<<ans;
88 | }
89 | 


--------------------------------------------------------------------------------
/Mathematics/Counting Divisors.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll d[1000005]={};
38 |     for(int i=1;i<1000005;i++)
39 |     {
40 |         for(int j=i;j<1000005;j+=i)
41 |         {
42 |             d[j]++;
43 |         }
44 |     }
45 |     ll n,x;
46 |     cin>>n;
47 |     for(int i=0;i<n;i++)
48 |     {
49 |         cin>>x;
50 |         cout<<d[x]<<"\n";
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Mathematics/Counting Necklaces.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,m;
38 |     cin>>n>>m;
39 |     ll ans=0;
40 |     for(ll i=0;i<n;i++)
41 |     {
42 |         ll temp=POW(m,__gcd(i,n));
43 |         temp*=inverse(n);
44 |         temp%=MOD;
45 |         ans+=temp;
46 |         ans%=MOD;
47 |     }
48 |     cout<<ans;
49 | }
50 | 


--------------------------------------------------------------------------------
/Mathematics/Creating Strings II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll fact[1000001];
38 |     fact[0]=1;
39 |     fact[1]=1;
40 |     for(int i=2;i<=1000000;i++)
41 |     {
42 |         fact[i]=(fact[i-1]*i)%MOD;
43 |     }
44 |     string s;
45 |     cin>>s;
46 |     ll n=s.size();
47 |     ll cnt[26]={};
48 |     for(int i=0;i<n;i++)
49 |     {
50 |         cnt[s[i]-'a']++;
51 |     }
52 |     ll tot=fact[n];
53 |     for(int i=0;i<26;i++)
54 |     {
55 |         tot*=inverse(fact[cnt[i]]);
56 |         tot%=MOD;
57 |     }
58 |     cout<<tot;
59 | }
60 | 


--------------------------------------------------------------------------------
/Mathematics/Dice Probability.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,a,b;
38 |     cin>>n>>a>>b;
39 |     vector<vector<ld> > dp(n+1,vector<ld> (6*n+1,0));
40 |     dp[0][0]=1.0;
41 |     for(int i=1;i<=n;i++)
42 |     {
43 |         for(int j=1;j<=6*n;j++)
44 |         {
45 |             for(int k=1;k<=6;k++)
46 |             {
47 |                 if(j-k>=0)
48 |                 {
49 |                     dp[i][j]+=dp[i-1][j-k];
50 |                 }
51 |             }
52 |             dp[i][j]=dp[i][j]/6;
53 |         }
54 |     }
55 |     ld ans=0;
56 |     for(int i=a;i<=b;i++)
57 |     {
58 |         ans+=dp[n][i];
59 |     }
60 |     ans*=1e6;
61 |     ans=llround(ans);
62 |     ans/=1e6;
63 |     cout<<fixed<<setprecision(6)<<ans;
64 | }
65 | 


--------------------------------------------------------------------------------
/Mathematics/Distributing Apples.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll fact[2000001];
38 |     fact[0]=1;
39 |     fact[1]=1;
40 |     for(int i=2;i<=2000000;i++)
41 |     {
42 |         fact[i]=(fact[i-1]*i)%MOD;
43 |     }
44 |     ll n,m;
45 |     cin>>n>>m;
46 |     ll ans=(fact[m+n-1]*inverse(fact[n-1]))%MOD;
47 |     ans*=inverse(fact[m]);
48 |     ans%=MOD;
49 |     cout<<ans;
50 | }
51 | 


--------------------------------------------------------------------------------
/Mathematics/Divisor Analysis.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | const int MOD1=1000000006;
20 | long long int inverse(long long int i, long long int mod){
21 |     if(i==1) return 1;
22 |     return (mod - ((mod/i)*inverse(mod%i,mod))%mod+mod)%mod;
23 | }
24 | ll POW(ll a,ll b)
25 | {
26 |     if(b==0) return 1;
27 |     if(b==1) return a%MOD;
28 |     ll temp=POW(a,b/2);
29 |     if(b%2==0) return (temp*temp)%MOD;
30 |     else return (((temp*temp)%MOD)*a)%MOD;
31 | }
32 | 
33 | int main()
34 | {
35 |     ios::sync_with_stdio(0);
36 |     cin.tie(0);
37 |     cout.tie(0);
38 |     ll n;
39 |     cin>>n;
40 |     ll x[n],k[n];
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>x[i]>>k[i];
44 |     }
45 |     ll num=1;
46 |     for(int i=0;i<n;i++)
47 |     {
48 |         num*=(k[i]+1)%MOD;
49 |         num%=MOD;
50 |     }
51 |     ll sum=1;
52 |     for(int i=0;i<n;i++)
53 |     {
54 |         ll temp=(POW(x[i],k[i]+1)+MOD-1)%MOD;
55 |         temp*=inverse(x[i]-1,MOD);
56 |         temp%=MOD;
57 |         sum*=temp;
58 |         sum%=MOD;
59 |     }
60 |     ll prod,num1=1;
61 |     ll flag=0;
62 |     for(int i=0;i<n;i++)
63 |     {
64 |         if(k[i]%2==1 && flag==0)
65 |         {
66 |             num1*=((k[i]+1)/2);
67 |             num1%=MOD1;
68 |             flag=1;
69 |         }
70 |         else
71 |         {
72 |             num1*=(k[i]+1)%MOD1;
73 |             num1%=MOD1;
74 |         }
75 |     }
76 |     if(flag==0)
77 |     {
78 |         for(int i=0;i<n;i++)
79 |         {
80 |             k[i]/=2;
81 |         }
82 |     }
83 |     ll number=1;
84 |     for(int i=0;i<n;i++)
85 |     {
86 |         number*=POW(x[i],k[i]);
87 |         number%=MOD;
88 |     }
89 |     prod=POW(number,num1);
90 |     cout<<num<<" "<<sum<<" "<<prod;
91 | }
92 | 


--------------------------------------------------------------------------------
/Mathematics/Exponentiation II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b, ll mod)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%mod;
27 |     ll temp=POW(a,b/2,mod);
28 |     if(b%2==0) return (temp*temp)%mod;
29 |     else return (((temp*temp)%mod)*a)%mod;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,a,b,c;
38 |     cin>>n;
39 |     for(int i=0;i<n;i++)
40 |     {
41 |         cin>>a>>b>>c;
42 |         ll pw=POW(b,c,MOD-1);
43 |         cout<<POW(a,pw,MOD)<<"\n";
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/Mathematics/Exponentiation.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,a,b;
38 |     cin>>n;
39 |     for(int i=0;i<n;i++)
40 |     {
41 |         cin>>a>>b;
42 |         cout<<POW(a,b)<<"\n";
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/Mathematics/Fibonacci Numbers.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | map<ll,ll> f;
32 | 
33 | ll fib(ll n)
34 | {
35 |     if(f.count(n)) return f[n];
36 |     if(n==0) return 0;
37 |     if(n==1 || n==2) return 1;
38 |     if(n%2==0)
39 |     {
40 |         ll k=n/2;
41 |         ll ret1=fib(k-1),ret2=fib(k);
42 |         return f[n]=((((2ll*ret1)%MOD+ret2)%MOD)*ret2)%MOD;
43 |     }
44 |     else
45 |     {
46 |         ll k=(n+1)/2;
47 |         ll ret1=fib(k-1),ret2=fib(k);
48 |         return f[n]=( (ret1*ret1)%MOD + (ret2*ret2)%MOD)%MOD;
49 |     }
50 | }
51 | int main()
52 | {
53 |     ios::sync_with_stdio(0);
54 |     cin.tie(0);
55 |     cout.tie(0);
56 |     ll n;
57 |     cin>>n;
58 |     cout<<fib(n);
59 | }
60 | 


--------------------------------------------------------------------------------
/Mathematics/Graph Paths I.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll n;
33 | 
34 | vector<vll> mul(vector<vll> x, vector<vll> y) {
35 |     vector<vll> r(n, vll(n));
36 |     for (int j = 0; j < n; j++)
37 |     {
38 |         for (int k = 0; k < n; k++) 
39 |         {
40 |             for (int l = 0; l < n; l++)
41 |             {
42 |                 r[j][k] = (r[j][k]+(x[j][l]*y[l][k])%MOD)%MOD;
43 |             }
44 |         }
45 |     }
46 |     return r;
47 | }
48 | 
49 | vector<vll> modpow(vector<vll> x, ll pw) 
50 | {
51 |     if (pw == 0)
52 |     {
53 |         vector<vll> r(n, vll(n));
54 |         for (int i = 0; i < n; i++) r[i][i] = 1;
55 |         return r;
56 |     }
57 |     vector<vll> u = modpow(x, pw/2);
58 |     u = mul(u, u);
59 |     if (pw%2==1) u = mul(u, x);
60 |     return u;
61 | }
62 | 
63 | int main()
64 | {
65 |     ios::sync_with_stdio(0);
66 |     cin.tie(0);
67 |     cout.tie(0);
68 |     ll m,k,a,b;
69 |     cin>>n>>m>>k;
70 |     vector<vll> v(n,vll (n,0));
71 |     for(int i=0;i<m;i++)
72 |     {
73 |         cin>>a>>b;
74 |         a--; b--;
75 |         v[a][b]++;
76 |     }
77 |     cout<<modpow(v,k)[0][n-1];
78 | }
79 | 


--------------------------------------------------------------------------------
/Mathematics/Graph Paths II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll INF=4e18;
33 | ll n;
34 | 
35 | vector<vll> mul(vector<vll> x, vector<vll> y) {
36 |     vector<vll> r(n, vll(n,INF));
37 |     for (int j = 0; j < n; j++)
38 |     {
39 |         for (int k = 0; k < n; k++) 
40 |         {
41 |             for (int l = 0; l < n; l++)
42 |             {
43 |                 r[j][k] = min(r[j][k],x[j][l]+y[l][k]);
44 |             }
45 |         }
46 |     }
47 |     return r;
48 | }
49 | 
50 | vector<vll> modpow(vector<vll> x, ll pw) 
51 | {
52 |     if (pw == 1)
53 |     {
54 |         return x;
55 |     }
56 |     vector<vll> u = modpow(x, pw/2);
57 |     u = mul(u, u);
58 |     if (pw%2==1) u = mul(u, x);
59 |     return u;
60 | }
61 | int main()
62 | {
63 |     ios::sync_with_stdio(0);
64 |     cin.tie(0);
65 |     cout.tie(0);
66 |     ll m,k,a,b,c;
67 |     cin>>n>>m>>k;
68 |     vector<vll> v(n,vll(n,INF));
69 |     for(int i=0;i<m;i++)
70 |     {
71 |         cin>>a>>b>>c;
72 |         a--; b--;
73 |         v[a][b]=min(v[a][b],c);
74 |     }
75 |     ll ans=modpow(v,k)[0][n-1];
76 |     if(ans==INF) cout<<"-1";
77 |     else cout<<ans;
78 | }
79 | 


--------------------------------------------------------------------------------
/Mathematics/Grundy's Game.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | ll mex(vll v)
33 | {
34 |     set<ll> s;
35 |     for(int i=0;i<v.size();i++)
36 |     {
37 |         s.insert(v[i]);
38 |     }
39 |     for(int i=0;i<1000001;i++)
40 |     {
41 |         if(s.count(i)==0) return i;
42 |     }
43 | }
44 |  
45 | int main()
46 | {
47 |     ios::sync_with_stdio(0);
48 |     cin.tie(0);
49 |     cout.tie(0);
50 |     ll limit=2000;
51 |     ll dp[limit];
52 |     dp[0]=dp[1]=dp[2]=0;
53 |     for(int i=3;i<limit;i++)
54 |     {
55 |         vll v;
56 |         for(int j=1;2*j<i;j++)
57 |         {
58 |             v.PB(dp[j]^dp[i-j]);
59 |         }
60 |         dp[i]=mex(v);
61 |     }
62 |     ll t;
63 |     cin>>t;
64 |     for(int i=0;i<t;i++)
65 |     {
66 |         ll n;
67 |         cin>>n;
68 |         if(n>=limit) cout<<"first";
69 |         else if(dp[n]==0) cout<<"second";
70 |         else cout<<"first";
71 |         cout<<"\n";
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/Mathematics/Inversion Probability.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll a[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>a[i];
43 |     }
44 |     ld ans=0;
45 |     for(int i=0;i<n;i++)
46 |     {
47 |         for(int j=0;j<i;j++)
48 |         {
49 |             ll k;
50 |             if(a[j]<=a[i])
51 |             {
52 |                 k=(a[j]*(a[j]-1))/2;
53 |             }
54 |             else
55 |             {
56 |                 k=(a[i]*(a[i]-1))/2 + (a[j]-a[i])*a[i];
57 |             }
58 |             ans+=(ld)k/(ld)(a[j]*a[i]);
59 |         }
60 |     }
61 |     cout<<fixed<<setprecision(6)<<ans;
62 | }
63 | 


--------------------------------------------------------------------------------
/Mathematics/Josephus Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll f(ll n,ll k)
33 | {
34 |     if(n==1) return 1;
35 |     if(k<=(n+1)/2) 
36 |     {
37 |         if(2*k>n) return (2*k)%n;
38 |         else return 2*k;
39 |     }
40 |     ll temp=f(n/2,k-(n+1)/2);
41 |     if(n%2==1) return 2*temp+1;
42 |     return 2*temp-1;
43 | }
44 | 
45 | int main()
46 | {
47 |     ios::sync_with_stdio(0);
48 |     cin.tie(0);
49 |     cout.tie(0);
50 |     ll q;
51 |     cin>>q;
52 |     for(int i=0;i<q;i++)
53 |     {
54 |         ll n,k;
55 |         cin>>n>>k;
56 |         cout<<f(n,k)<<"\n";
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/Mathematics/Nim Game I.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll t,n;
38 |     cin>>t;
39 |     for(int i=0;i<t;i++)
40 |     {
41 |         cin>>n;
42 |         ll x[n];
43 |         ll xr=0;
44 |         for(int i=0;i<n;i++)
45 |         {
46 |             cin>>x[i];
47 |             xr^=x[i];
48 |         }
49 |         if(xr!=0) cout<<"first";
50 |         else cout<<"second";
51 |         cout<<"\n";
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/Mathematics/Nim Game II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll t,n;
38 |     cin>>t;
39 |     for(int i=0;i<t;i++)
40 |     {
41 |         cin>>n;
42 |         ll x[n];
43 |         ll xr=0;
44 |         for(int i=0;i<n;i++)
45 |         {
46 |             cin>>x[i];
47 |             x[i]%=4;
48 |             xr^=x[i];
49 |         }
50 |         if(xr!=0) cout<<"first";
51 |         else cout<<"second";
52 |         cout<<"\n";
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/Mathematics/Prime Multiples.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,k;
38 |     cin>>n>>k;
39 |     ll a[k];
40 |     for(int i=0;i<k;i++)
41 |     {
42 |         cin>>a[i];
43 |     }
44 |     ll ans=0;
45 |     for(int i=0;i<(1ll<<k);i++)
46 |     {
47 |         vll v;
48 |         for(int j=0;j<k;j++)
49 |         {
50 |             if((i&(1<<j))!=0)
51 |             {
52 |                 v.PB(a[j]);
53 |             }
54 |         }
55 |         ll prod=1;
56 |         for(int j=0;j<v.size();j++)
57 |         {
58 |             if(prod>n/v[j])
59 |             {
60 |                 prod=n+1;
61 |                 break;
62 |             }
63 |             prod*=v[j];
64 |         }
65 |         if(v.size()%2==0) ans-=n/prod;
66 |         else ans+=n/prod;
67 |     }
68 |     ans+=n;
69 |     cout<<ans;
70 | }
71 | 


--------------------------------------------------------------------------------
/Mathematics/Stair Game.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll t,n;
38 |     cin>>t;
39 |     for(int i=0;i<t;i++)
40 |     {
41 |         cin>>n;
42 |         ll a[n];
43 |         ll xr=0;
44 |         for(int i=0;i<n;i++)
45 |         {
46 |             cin>>a[i];
47 |             if(i%2)
48 |             {
49 |                 xr^=a[i];
50 |             }
51 |         }
52 |         if(xr) cout<<"first";
53 |         else cout<<"second";
54 |         cout<<"\n";
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/Mathematics/Stick Game.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,k;
38 |     cin>>n>>k;
39 |     ll p[k];
40 |     for(int i=0;i<k;i++)
41 |     {
42 |         cin>>p[i];
43 |     }
44 |     ll dp[n+1]={};
45 |     dp[0]=0;
46 |     for(int i=1;i<=n;i++)
47 |     {
48 |         for(int j=0;j<k;j++)
49 |         {
50 |             if(i-p[j]>=0 && dp[i-p[j]]==0)
51 |             {
52 |                 dp[i]=1;
53 |             }
54 |         }
55 |     }
56 |     for(int i=1;i<=n;i++)
57 |     {
58 |         if(dp[i]==1) cout<<"W";
59 |         else cout<<"L";
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/Mathematics/Sum of Divisors.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll ans=0;
40 |     for(ll i=1;i*i<=n;i++)
41 |     {
42 |         ans+=((n/i)*i)%MOD;
43 |         ans%=MOD;
44 |     }
45 |     ll l=(ll)sqrt(n);
46 |     for(ll i=sqrt(n);i>=1;i--)
47 |     {
48 |         ll r=n/i;
49 |         ll sum=0;
50 |         sum+=((((r%MOD)*((r+1)%MOD))%MOD)*inverse(2))%MOD;
51 |         sum%=MOD;
52 |         sum-=((((l%MOD)*((l+1)%MOD))%MOD)*inverse(2))%MOD;
53 |         sum=(sum+MOD)%MOD;
54 |         sum=(sum*i)%MOD;
55 |         l=r;
56 |         ans=(ans+sum)%MOD;
57 |         //cout<<sum<<" ";
58 |     }
59 |     cout<<ans;
60 | }
61 | 


--------------------------------------------------------------------------------
/Mathematics/Throwing Dice.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vector<vll> mul(vector<vll> x, vector<vll> y) {
33 |     vector<vll> r(6, vll(6));
34 |     for (int j = 0; j < 6; j++)
35 |     {
36 |         for (int k = 0; k < 6; k++) 
37 |         {
38 |             for (int l = 0; l < 6; l++)
39 |             {
40 |                 r[j][k] = (r[j][k]+(x[j][l]*y[l][k])%MOD)%MOD;
41 |             }
42 |         }
43 |     }
44 |     return r;
45 | }
46 | 
47 | vector<vll> modpow(vector<vll> x, ll n) 
48 | {
49 |     if (n == 0)
50 |     {
51 |         vector<vll> r(6, vll(6));
52 |         for (int i = 0; i < 6; i++) r[i][i] = 1;
53 |         return r;
54 |     }
55 |     vector<vll> u = modpow(x, n/2);
56 |     u = mul(u, u);
57 |     if (n%2==1) u = mul(u, x);
58 |     return u;
59 | }
60 | 
61 | int main()
62 | {
63 |     ios::sync_with_stdio(0);
64 |     cin.tie(0);
65 |     cout.tie(0);
66 |     ll n;
67 |     cin>>n;
68 |     vector<vll> a(6,vll(6));
69 |     for(int i=0;i<5;i++)
70 |     {
71 |         a[i][i+1]=1;
72 |     }
73 |     for(int i=0;i<6;i++)
74 |     {
75 |         a[5][i]=1;
76 |     }
77 |     vector<vll> ans=modpow(a,n);
78 |     cout<<ans[5][5];
79 | }
80 | 


--------------------------------------------------------------------------------
/Range Queries/Forest Queries.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,q,y1,x1,y2,x2;
38 |     cin>>n>>q;
39 |     char c[n][n];
40 |     ll t[n][n]={};
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         for(int j=0;j<n;j++)
44 |         {
45 |             cin>>c[i][j];
46 |             if(c[i][j]=='*') t[i][j]=1;
47 |         }
48 |     }
49 |     vector<vll> dp(n+1,vll(n+1,0));
50 |     for(int i=1;i<=n;i++)
51 |     {
52 |         for(int j=1;j<=n;j++)
53 |         {
54 |             dp[i][j]=dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]+t[i-1][j-1];
55 |         }
56 |     }
57 |     for(int i=0;i<q;i++)
58 |     {
59 |         cin>>x1>>y1>>x2>>y2;
60 |         x1--;
61 |         y1--;
62 |         cout<<dp[x2][y2]-dp[x2][y1]-dp[x1][y2]+dp[x1][y1]<<"\n";
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Apartments.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,m,k;
38 |     cin>>n>>m>>k;
39 |     ll a[n],b[m];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>a[i];
43 |     }
44 |     for(int i=0;i<m;i++)
45 |     {
46 |         cin>>b[i];
47 |     }
48 |     sort(a,a+n);
49 |     sort(b,b+m);
50 |     ll ans=0,i=0,j=0;
51 |     while(i<n && j<m)
52 |     {
53 |         if(abs(a[i]-b[j])<=k)
54 |         {
55 |             i++;
56 |             j++;
57 |             ans++;
58 |         }
59 |         else if(a[i]-b[j]>k)
60 |         {
61 |             j++;
62 |         }
63 |         else i++;
64 |     }
65 |     cout<<ans;
66 | }
67 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Array Division.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll n,k;
33 | ll x[200005];
34 | 
35 | bool check(ll s)
36 | {
37 |     ll sum=0,c=0;
38 |     for(int i=0;i<n;i++)
39 |     {
40 |         if(x[i]>s) return false;
41 |         if(sum+x[i]>s)
42 |         {
43 |             c++;
44 |             sum=0;
45 |         }
46 |         sum+=x[i];
47 |     }
48 |     if(sum>0) c++;
49 |     if(c<=k) return true;
50 |     return false;
51 | }
52 | 
53 | int main()
54 | {
55 |     ios::sync_with_stdio(0);
56 |     cin.tie(0);
57 |     cout.tie(0);
58 |     cin>>n>>k;
59 |     for(int i=0;i<n;i++)
60 |     {
61 |         cin>>x[i];
62 |     }
63 |     ll l=0,h=1e18;
64 |     while(h>l)
65 |     {
66 |         ll m=(l+h)/2;
67 |         if(check(m))
68 |         {
69 |             h=m;
70 |         }
71 |         else 
72 |         {
73 |             l=m+1;
74 |         }
75 |     }
76 |     cout<<l;
77 | }
78 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Collecting Numbers II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,m;
38 |     cin>>n>>m;
39 |     ll x[n+1];
40 |     ll index[n+2];
41 |     for(int i=1;i<=n;i++)
42 |     {
43 |         cin>>x[i];
44 |         index[x[i]]=i;
45 |     }
46 |     index[0]=0;
47 |     index[n+1]=n+1;
48 |     ll ans=1;
49 |     for(int i=1;i<=n-1;i++)
50 |     {
51 |         if(index[i]>index[i+1]) ans++;
52 |     }
53 |     for(int i=0;i<m;i++)
54 |     {
55 |         ll a,b;
56 |         cin>>a>>b;
57 |         ll v1=x[a],v2=x[b];
58 |         swap(x[a],x[b]);
59 |         if(index[v1-1]<=index[v1] && index[v1-1]>b) ans++;
60 | 		if(index[v1-1]>index[v1] && index[v1-1]<=b) ans--;
61 | 		if(index[v1]<=index[v1+1] && b>index[v1+1]) ans++;
62 | 		if(index[v1]>index[v1+1] && b<=index[v1+1]) ans--;		
63 | 		index[v1]=b;
64 | 		if(index[v2-1]<=index[v2] && index[v2-1]>a) ans++;
65 | 		if(index[v2-1]>index[v2] && index[v2-1]<=a) ans--;
66 | 		if(index[v2]<=index[v2+1] && a>index[v2+1]) ans++;
67 | 		if(index[v2]>index[v2+1] && a<=index[v2+1]) ans--;	
68 | 		index[v2]=a;
69 | 		cout<<ans<<"\n";
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Collecting Numbers.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll x[n];
40 |     ll index[n+1];
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>x[i];
44 |         index[x[i]]=i;
45 |     }
46 |     ll answer=1;
47 |     for(int i=1;i<=n-1;i++)
48 |     {
49 |         if(index[i]>index[i+1]) answer++;
50 |     }
51 |     cout<<answer;
52 | }
53 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Concert Tickets.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,m;
38 |     cin>>n>>m;
39 |     ll h[n],p[m];
40 |     multiset<ll> s;
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>h[i];
44 |         s.insert(h[i]);
45 |     }
46 |     for(int i=0;i<m;i++)
47 |     {
48 |         cin>>p[i];
49 |         auto it=s.upper_bound(p[i]);
50 |         if(it==s.begin()) cout<<"-1";
51 |         else 
52 |         {
53 |             it--;
54 |             cout<<(*it);
55 |             s.erase(it);
56 |         }
57 |         cout<<"\n";
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Distinct Numbers.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll x[n];
40 |     set<ll> s;
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>x[i];
44 |         s.insert(x[i]);
45 |     }
46 |     cout<<s.size();
47 | }
48 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Factory Machines.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll n,t;
33 | ll k[200005];
34 | ll func(ll m)
35 | {
36 |     ll ans=0;
37 |     for(int i=0;i<n;i++)
38 |     {
39 |         ans+=m/k[i];
40 |         if(ans>t)
41 |         {
42 |             return LLONG_MAX;
43 |         }
44 |     }
45 |     return ans;
46 | }
47 | 
48 | int main()
49 | {
50 |     ios::sync_with_stdio(0);
51 |     cin.tie(0);
52 |     cout.tie(0);
53 |     cin>>n>>t;
54 |     for(int i=0;i<n;i++)
55 |     {
56 |         cin>>k[i];
57 |     }
58 |     ll l=0,h=1e18;
59 |     while(h>l)
60 |     {
61 |         ll m=(l+h)/2;
62 |         if(func(m)<t)
63 |         {
64 |             l=m+1;
65 |         }
66 |         else
67 |         {
68 |             h=m;
69 |         }
70 |     }
71 |     cout<<l;
72 | }
73 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Ferris Wheel.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll p[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>p[i];
43 |     }
44 |     sort(p,p+n);
45 |     ll i=0,j=n-1,ans=0;
46 |     while(j>=i)
47 |     {
48 |         if(p[i]+p[j]<=x)
49 |         {
50 |             i++;
51 |             j--;
52 |             ans++;
53 |         }
54 |         else
55 |         {
56 |             j--;
57 |             ans++;
58 |         }
59 |     }
60 |     cout<<ans;
61 | }
62 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Josephus Problem I.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     queue<ll> q;
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         q.push(i+1);
43 |     }
44 |     for(int i=0;i<n;i++)
45 |     {
46 |         ll k=q.front();
47 |         q.pop();
48 |         q.push(k);
49 |         cout<<q.front()<<" ";
50 |         q.pop();
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Josephus Problem II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,k;
38 |     cin>>n>>k;
39 |     osetll os;
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         os.insert(i+1);
43 |     }
44 |     ll ind=k%n;
45 |     for(int i=n-1;i>=0;i--)
46 |     {
47 |         auto it=os.fbo(ind);
48 |         cout<<(*it)<<" ";
49 |         os.erase(it);
50 |         if(i!=0) ind=(ind%i+k)%i;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Maximum Subarray Sum II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | ll INF=1e18;
33 | 
34 | int main()
35 | {
36 |     ios::sync_with_stdio(0);
37 |     cin.tie(0);
38 |     cout.tie(0);
39 |     ll n,a,b;
40 |     cin>>n>>a>>b;
41 |     ll x[n],pre[n+1];
42 |     pre[0]=0;
43 |     for(int i=0;i<n;i++)
44 |     {
45 |         cin>>x[i];
46 |         pre[i+1]=pre[i]+x[i];
47 |     }
48 |     multiset<ll> ms;
49 |     ll ans=-INF;
50 |     for(int i=a;i<=n;i++)
51 |     {
52 |         if(i>b)
53 |         {
54 |             ms.erase(ms.find(pre[i-b-1]));
55 |         }
56 |         ms.insert(pre[i-a]);
57 |         ans=max(ans,pre[i]-(*ms.begin()));
58 |     }
59 |     cout<<ans;
60 | }
61 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Maximum Subarray Sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll x[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>x[i];
43 |     }
44 |     ll ans=x[0],sum=x[0];
45 |     for(int i=1;i<n;i++)
46 |     {
47 |         sum=max(sum+x[i],x[i]);
48 |         ans=max(ans,sum);
49 |     }
50 |     cout<<ans;
51 | }
52 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Missing Coin Sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll x[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>x[i];
43 |     }
44 |     sort(x,x+n);
45 |     ll c=1;
46 |     for(int i=0;i<n;i++)
47 |     {
48 |         if(c<x[i])
49 |         {
50 |             cout<<c;
51 |             return 0;
52 |         }
53 |         c+=x[i];
54 |     }
55 |     cout<<c;
56 | }
57 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Movie Festival II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,k;
38 |     cin>>n>>k;
39 |     vector<pll> v(n);
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>v[i].S>>v[i].F;
43 |     }
44 |     sort(v.begin(),v.end());
45 |     multiset<ll> ms;
46 |     for(int i=0;i<k;i++)
47 |     {
48 |         ms.insert(0);
49 |     }
50 |     ll ans=0;
51 |     for(int i=0;i<n;i++)
52 |     {
53 |         auto it=ms.upper_bound(v[i].S);
54 |         if(it!=ms.begin())
55 |         {
56 |             it--;
57 |             ms.erase(it);
58 |             ms.insert(v[i].F);
59 |             ans++;
60 |         }
61 |     }
62 |     cout<<ans;
63 | }
64 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Movie Festival.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     vector<pll> v;
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         ll x,y;
43 |         cin>>x>>y;
44 |         v.PB({y,x});
45 |     }
46 |     sort(v.begin(),v.end());
47 |     ll ans=0,end=0;
48 |     for(int i=0;i<n;i++)
49 |     {
50 |         if(v[i].S>=end)
51 |         {
52 |             end=v[i].F;
53 |             ans++;
54 |         }
55 |     }
56 |     cout<<ans;
57 | }
58 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Nearest Smaller Values.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll x[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>x[i];
43 |     }
44 |     stack<pll> s;
45 |     for(int i=0;i<n;i++)
46 |     {
47 |         while(!s.empty() && s.top().F>=x[i])
48 |         {
49 |             s.pop();
50 |         }
51 |         if(s.empty()) cout<<0;
52 |         else cout<<s.top().S;
53 |         cout<<" ";
54 |         s.push({x[i],i+1});
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Nested Ranges Check.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetpll tree<pll, null_type, less<pll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     vector<pair<pll,ll> > v(n);
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>v[i].F.F>>v[i].F.S;
43 |         v[i].F.S*=-1;
44 |         v[i].S=i;
45 |     }
46 |     sort(v.begin(),v.end());
47 |     osetpll os1,os2;
48 |     ll j=n-1;
49 |     ll ans1[n],ans2[n];
50 |     for(int i=0;i<n;i++)
51 |     {
52 |         ans1[v[j].S]=os2.ook({-v[j].F.S+1,-1});
53 |         ans2[v[i].S]=i-os1.ook({-v[i].F.S,-1});
54 |         os1.insert({-v[i].F.S,i});
55 |         os2.insert({-v[j].F.S,i});
56 |         j--;
57 |     }
58 |     for(int i=0;i<n;i++)
59 |     {
60 |         cout<<min(ans1[i],1ll)<<" ";
61 |     }
62 |     cout<<"\n";
63 |     for(int i=0;i<n;i++)
64 |     {
65 |         cout<<min(ans2[i],1ll)<<" ";
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Nested Ranges Count.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetpll tree<pll, null_type, less<pll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     vector<pair<pll,ll> > v(n);
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>v[i].F.F>>v[i].F.S;
43 |         v[i].F.S*=-1;
44 |         v[i].S=i;
45 |     }
46 |     sort(v.begin(),v.end());
47 |     osetpll os1,os2;
48 |     ll j=n-1;
49 |     ll ans1[n],ans2[n];
50 |     for(int i=0;i<n;i++)
51 |     {
52 |         ans1[v[j].S]=os2.ook({-v[j].F.S+1,-1});
53 |         ans2[v[i].S]=i-os1.ook({-v[i].F.S,-1});
54 |         os1.insert({-v[i].F.S,i});
55 |         os2.insert({-v[j].F.S,i});
56 |         j--;
57 |     }
58 |     for(int i=0;i<n;i++)
59 |     {
60 |         cout<<ans1[i]<<" ";
61 |     }
62 |     cout<<"\n";
63 |     for(int i=0;i<n;i++)
64 |     {
65 |         cout<<ans2[i]<<" ";
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Playlist.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll k[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>k[i];
43 |     }
44 |     map<ll,ll> mp;
45 |     ll i=0,j=0,c=0,ans=0;
46 |     while(j<n)
47 |     {
48 |         if(mp[k[j]]==0)
49 |         {
50 |             mp[k[j]]++;
51 |             c++;
52 |             ans=max(ans,c);
53 |             j++;
54 |         }
55 |         else
56 |         {
57 |             c--;
58 |             mp[k[i]]--;
59 |             i++;
60 |         }
61 |     }
62 |     cout<<ans;
63 | }
64 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Reading Books.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll t[n],sum=0,mx=0;
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>t[i];
43 |         sum+=t[i];
44 |         mx=max(mx,t[i]);
45 |     }
46 |     cout<<max(2*mx,sum);
47 | }
48 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Restaurant Customers.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     map<ll,ll> mp;
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         ll a,b;
43 |         cin>>a>>b;
44 |         b++;
45 |         mp[a]++;
46 |         mp[b]--;
47 |     }
48 |     ll c=0,ans=0;
49 |     for(auto it:mp)
50 |     {
51 |         c+=mp[it.F];
52 |         ans=max(ans,c);
53 |     }
54 |     cout<<ans;
55 | }
56 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Room Allocation.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     vector<pair<pll,ll> > v(n);
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>v[i].F.F>>v[i].F.S;
43 |         v[i].S=i;
44 |     }
45 |     sort(v.begin(),v.end());
46 |     priority_queue<pll> pq;
47 |     ll ans[n],c=0;
48 |     for(int i=0;i<n;i++)
49 |     {
50 |         if(pq.empty())
51 |         {
52 |             c++;
53 |             pq.push({-v[i].F.S,c});
54 |             ans[v[i].S]=c;
55 |         }
56 |         else
57 |         {
58 |             pll p=pq.top();
59 |             if(-p.F<v[i].F.F)
60 |             {
61 |                 pq.pop();
62 |                 pq.push({-v[i].F.S,p.S});
63 |                 ans[v[i].S]=p.S;
64 |             }
65 |             else
66 |             {
67 |                 c++;
68 |                 pq.push({-v[i].F.S,c});
69 |                 ans[v[i].S]=c;
70 |             }
71 |         }
72 |     }
73 |     cout<<pq.size()<<"\n";
74 |     for(int i=0;i<n;i++)
75 |     {
76 |         cout<<ans[i]<<" ";
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Sliding Cost.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less_equal<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007;
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 |  
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,k;
38 |     cin>>n>>k;
39 |     ll a[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>a[i];
43 |     }
44 |     oset s;
45 |     for(int i=0;i<k;i++)
46 |     {
47 |         s.insert(a[i]);
48 |     }
49 |     ll temp=*s.fbo((k-1)/2 );
50 |     ll sum=0;
51 |     for(int i=0;i<k;i++)
52 |     {
53 |         sum+=abs(a[i]-temp);
54 |     }
55 |     cout<<sum<<" ";
56 |     for(int i=0;i<n-k;i++)
57 |     {
58 |         s.erase(s.fbo(s.ook(a[i])));
59 |         s.insert(a[i+k]);
60 |         ll m=*s.fbo( (k-1)/2 );
61 |         //cout<<m<<" ";
62 |         sum+=abs(m-a[i+k])-abs(temp-a[i]);
63 |         if(k%2==0) sum-=m-temp;
64 |         temp=m;
65 |         cout<<sum<<" ";
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Sliding Median.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | #define ll long long
  4 | #define vll vector<ll>
  5 | #define ld long double
  6 | #define pll pair<ll,ll>
  7 | #define PB push_back
  8 | #define MP make_pair
  9 | #define F first
 10 | #define S second
 11 | const int MOD=1000000007;
 12 | long long int inverse(long long int i){
 13 |     if(i==1) return 1;
 14 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
 15 | }
 16 | ll POW(ll a,ll b)
 17 | {
 18 |     if(b==0) return 1;
 19 |     if(b==1) return a%MOD;
 20 |     ll temp=POW(a,b/2);
 21 |     if(b%2==0) return (temp*temp)%MOD;
 22 |     else return (((temp*temp)%MOD)*a)%MOD;
 23 | }
 24 |  
 25 | int main()
 26 | {
 27 |     ios::sync_with_stdio(0);
 28 |     cin.tie(0);
 29 |     cout.tie(0);
 30 |     ll n,k;
 31 |     cin>>n>>k;
 32 |     ll x[n];
 33 |     vector<pll> v;
 34 |     for(ll i=0;i<n;i++)
 35 |     {
 36 |         cin>>x[i];
 37 |         if(i<k)
 38 |         {
 39 |             v.PB(MP(x[i],i));
 40 |         }
 41 |     }
 42 |     if(k==1)
 43 |     {
 44 |         for(int i=0;i<n;i++) cout<<x[i]<<" ";
 45 |         return 0;
 46 |     }
 47 |     if(k==2)
 48 |     {
 49 |         for(int i=0;i<n-1;i++)
 50 |         {
 51 |             cout<<min(x[i],x[i+1])<<" ";
 52 |         }
 53 |         return 0;
 54 |     }
 55 |     sort(v.begin(),v.begin()+k);
 56 |     set<pll> s,l;
 57 |     for(int i=0;i<((k-1)/2);i++)
 58 |     {
 59 |         s.insert(MP(v[i].F,v[i].S));
 60 |     }
 61 |     for(int i=(k-1)/2;i<k;i++)
 62 |     {
 63 |         l.insert(MP(v[i].F,v[i].S));
 64 |     }
 65 |     cout<<(*l.begin()).F<<" ";
 66 |     for(ll i=0;i<n-k;i++)
 67 |     {
 68 |         if(s.count(MP(x[i],i))==1)
 69 |         {
 70 |             s.erase(MP(x[i],i)); //cout<<"yo";
 71 |             if(x[i+k]>=((*l.begin()).F))
 72 |             {
 73 |                 ll temp=(*l.begin()).S;
 74 |                 l.erase(MP(x[temp],temp));
 75 |                 l.insert(MP(x[i+k],i+k));
 76 |                 s.insert(MP(x[temp],temp));
 77 |             }
 78 |             else
 79 |             {
 80 |                 s.insert(MP(x[i+k],i+k));
 81 |             }
 82 |         }
 83 |         else
 84 |         {
 85 |             l.erase(MP(x[i],i));
 86 |             set<pll>::iterator it=s.end();
 87 |             it--;
 88 |             pll p=(*it);
 89 |             if(x[i+k]<p.F )
 90 |             {
 91 |                 ll temp=p.S;  //cout<<p.F<<" "<<p.S<<" ";
 92 |                 s.erase(MP(x[temp],temp));
 93 |                 s.insert(MP(x[i+k],i+k));
 94 |                 l.insert(MP(x[temp],temp));
 95 |             }
 96 |             else
 97 |             {
 98 |                 l.insert(MP(x[i+k],i+k));
 99 |             }
100 |         }
101 |         cout<<(*l.begin()).F<<" ";
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Stick Lengths.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll p[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>p[i];
43 |     }
44 |     sort(p,p+n);
45 |     ll ans=0,mid=p[(n-1)/2];
46 |     for(int i=0;i<n;i++)
47 |     {
48 |         ans+=abs(p[i]-mid);
49 |     }
50 |     cout<<ans;
51 | }
52 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Subarray Distinct Values.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,k;
38 |     cin>>n>>k;
39 |     ll x[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>x[i];
43 |     }
44 |     map<ll,ll> mp;
45 |     ll l=0,r=0,c=0,ans=0;
46 |     while(l<n)
47 |     {
48 |         while(r<n && c+(mp[x[r]]==0)<=k)
49 |         {
50 |             c+=(mp[x[r]]==0);
51 |             mp[x[r]]++;
52 |             r++;
53 |         }
54 |         ans+=r-l;
55 |         mp[x[l]]--;
56 |         c-=(mp[x[l]]==0);
57 |         l++;
58 |     }
59 |     cout<<ans;
60 | }
61 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Subarray Divisibility.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll a[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>a[i];
43 |         a[i]%=n;
44 |     }
45 |     ll ans=0,sum=0;
46 |     map<ll,ll> mp;
47 |     mp[0]=1;
48 |     for(int i=0;i<n;i++)
49 |     {
50 |         sum+=a[i];
51 |         sum=(sum+n)%n;
52 |         ans+=mp[sum];
53 |         mp[sum]++;
54 |     }
55 |     cout<<ans;
56 | }
57 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Subarray Sums I.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll a[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>a[i];
43 |     }
44 |     ll sum=0,ans=0,i=0,j=0;
45 |     while(j<=n)
46 |     {
47 |         if(sum<x) 
48 |         {
49 |             if(j<n) sum+=a[j];
50 |             j++;
51 |         }
52 |         else if(sum>x)
53 |         {
54 |             if(i<n) sum-=a[i];
55 |             i++;
56 |         }
57 |         else if(sum==x)
58 |         {
59 |             ans++;
60 |             if(i<n) sum-=a[i];
61 |             i++;
62 |         }
63 |     }
64 |     cout<<ans;
65 | }
66 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Subarray Sums II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll a[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>a[i];
43 |     }
44 |     ll ans=0,sum=0;
45 |     map<ll,ll> mp;
46 |     mp[0]=1;
47 |     for(int i=0;i<n;i++)
48 |     {
49 |         sum+=a[i];
50 |         ans+=mp[sum-x];
51 |         mp[sum]++;
52 |     }
53 |     cout<<ans;
54 | }
55 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Sum of Four Values.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll a[n];
40 |     set<ll> s;
41 |     map<ll,pll> mp;
42 |     for(int i=0;i<n;i++)
43 |     {
44 |         cin>>a[i];
45 |     }
46 |     for(int i=0;i<n;i++)
47 |     {
48 |         for(int j=i+1;j<n;j++)
49 |         {
50 |             s.insert(a[i]+a[j]);    
51 |             mp[a[i]+a[j]]={i,j};
52 |         }
53 |     }
54 |     for(int i=0;i<n;i++)
55 |     {
56 |         for(int j=i+1;j<n;j++)
57 |         {
58 |             ll rem=x-a[i]-a[j];
59 |             if(s.count(rem)==1)
60 |             {
61 |                 if(mp[rem].F!=i && mp[rem].S!=i && mp[rem].F!=j && mp[rem].S!=j)
62 |                 {
63 |                     cout<<i+1<<" "<<j+1<<" "<<mp[rem].F+1<<" "<<mp[rem].S+1;
64 |                     return 0;
65 |                 }
66 |             }
67 |         }
68 |     }
69 |     cout<<"IMPOSSIBLE";
70 | }
71 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Sum of Three Values.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll a[n];
40 |     set<ll> s;
41 |     map<ll,ll> mp;
42 |     for(int i=0;i<n;i++)
43 |     {
44 |         cin>>a[i];
45 |         s.insert(a[i]);
46 |         mp[a[i]]=i;
47 |     }
48 |     for(int i=0;i<n;i++)
49 |     {
50 |         for(int j=i+1;j<n;j++)
51 |         {
52 |             ll rem=x-a[i]-a[j];
53 |             if(s.count(rem)==1)
54 |             {
55 |                 ll id=mp[rem];
56 |                 if(id!=i && id!=j)
57 |                 {
58 |                     cout<<i+1<<" "<<j+1<<" "<<id+1;
59 |                     return 0;
60 |                 }
61 |             }
62 |         }
63 |     }
64 |     cout<<"IMPOSSIBLE";
65 | }
66 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Sum of Two Values.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n,x;
38 |     cin>>n>>x;
39 |     ll a[n];
40 |     vector<pll> v;
41 |     for(int i=0;i<n;i++)
42 |     {
43 |         cin>>a[i];
44 |         v.PB({a[i],i+1});
45 |     }
46 |     sort(v.begin(),v.end());
47 |     for(int i=0;i<n;i++)
48 |     {
49 |         pll f={x-v[i].F,0};
50 |         ll ind=lower_bound(v.begin(),v.end(),f)-v.begin();
51 |         if(ind<v.size() && ind!=i && v[ind].F+v[i].F==x)
52 |         {
53 |             cout<<v[i].S<<" "<<v[ind].S;
54 |             return 0;
55 |         }
56 |     }
57 |     cout<<"IMPOSSIBLE";
58 | }
59 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Tasks and Deadlines.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     vector<pll> v(n);
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>v[i].F>>v[i].S;
43 |     }
44 |     sort(v.begin(),v.end());
45 |     ll ans=0,c=0;
46 |     for(int i=0;i<n;i++)
47 |     {
48 |         c+=v[i].F;
49 |         ans+=v[i].S-c;
50 |     }
51 |     cout<<ans;
52 | }
53 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Towers.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll n;
38 |     cin>>n;
39 |     ll k[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>k[i];
43 |     }
44 |     multiset<ll> ms;
45 |     for(int i=0;i<n;i++)
46 |     {
47 |         auto it=ms.upper_bound(k[i]);
48 |         if(it==ms.end())
49 |         {
50 |             ms.insert(k[i]);
51 |         }
52 |         else
53 |         {
54 |             ms.erase(it);
55 |             ms.insert(k[i]);
56 |         }
57 |     }
58 |     cout<<ms.size();
59 | }
60 | 


--------------------------------------------------------------------------------
/Sorting and Searching/Traffic Lights.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | int main()
33 | {
34 |     ios::sync_with_stdio(0);
35 |     cin.tie(0);
36 |     cout.tie(0);
37 |     ll x,n;
38 |     cin>>x>>n;
39 |     ll p[n];
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         cin>>p[i];
43 |     }
44 |     set<ll> pos;
45 |     multiset<ll> gaps;
46 |     pos.insert(0);
47 |     pos.insert(x);
48 |     gaps.insert(x);
49 |     for(int i=0;i<n;i++)
50 |     {
51 |         auto it=pos.upper_bound(p[i]);
52 |         auto it1=it;
53 |         it1--;
54 |         gaps.erase(gaps.find((*it)-(*it1)));
55 |         gaps.insert(p[i]-(*it1));
56 |         gaps.insert((*it)-p[i]);
57 |         pos.insert(p[i]);
58 |         auto it2=gaps.end();
59 |         it2--;
60 |         cout<<(*it2)<<" ";
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/String Algorithms/Finding Borders.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vector<int> prefix_function(string s) {
33 |     int n = (int)s.length();
34 |     vector<int> pi(n);
35 |     for (int i = 1; i < n; i++) {
36 |         int j = pi[i-1];
37 |         while (j > 0 && s[i] != s[j])
38 |             j = pi[j-1];
39 |         if (s[i] == s[j])
40 |             j++;
41 |         pi[i] = j;
42 |     }
43 |     return pi;
44 | }
45 | 
46 | int main()
47 | {
48 |     ios::sync_with_stdio(0);
49 |     cin.tie(0);
50 |     cout.tie(0);
51 |     string s;
52 |     cin>>s;
53 |     ll n=s.size();
54 |     vector<int> pi=prefix_function(s);
55 |     ll k=n-1;
56 |     vll ans;
57 |     while(1)
58 |     {
59 |         if(pi[k]==0) break;
60 |         ans.PB(pi[k]);
61 |         k=pi[k]-1;
62 |     }
63 |     sort(ans.begin(),ans.end());
64 |     for(int i=0;i<ans.size();i++)
65 |     {
66 |         cout<<ans[i]<<" ";
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/String Algorithms/Finding Periods.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vector<int> z_function(string s) {
33 |     int n = (int) s.length();
34 |     vector<int> z(n);
35 |     for (int i = 1, l = 0, r = 0; i < n; ++i) {
36 |         if (i <= r)
37 |             z[i] = min (r - i + 1, z[i - l]);
38 |         while (i + z[i] < n && s[z[i]] == s[i + z[i]])
39 |             ++z[i];
40 |         if (i + z[i] - 1 > r)
41 |             l = i, r = i + z[i] - 1;
42 |     }
43 |     return z;
44 | }
45 | 
46 | int main()
47 | {
48 |     ios::sync_with_stdio(0);
49 |     cin.tie(0);
50 |     cout.tie(0);
51 |     string s;
52 |     cin>>s;
53 |     ll n=s.size();
54 |     vector<int> z=z_function(s);
55 |     for(int i=0;i<n;i++)
56 |     {
57 |         if(i+z[i]==n) cout<<i<<" ";
58 |     }
59 |     cout<<n;
60 | }
61 | 


--------------------------------------------------------------------------------
/String Algorithms/String Matching.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vector<int> prefix_function(string s) {
33 |     int n = (int)s.length();
34 |     vector<int> pi(n);
35 |     for (int i = 1; i < n; i++) {
36 |         int j = pi[i-1];
37 |         while (j > 0 && s[i] != s[j])
38 |             j = pi[j-1];
39 |         if (s[i] == s[j])
40 |             j++;
41 |         pi[i] = j;
42 |     }
43 |     return pi;
44 | }
45 | 
46 | int main()
47 | {
48 |     ios::sync_with_stdio(0);
49 |     cin.tie(0);
50 |     cout.tie(0);
51 |     string t,s;
52 |     cin>>t>>s;
53 |     string join=s+'#'+t;
54 |     vector<int> pi=prefix_function(join);
55 |     ll n=s.size(),m=t.size(),ans=0;
56 |     for(int i=n+1;i<n+m+1;i++)
57 |     {
58 |         if(pi[i]==n) ans++;
59 |     }
60 |     cout<<ans;
61 | }
62 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Company Queries I.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vll AdjList[200005];
33 | ll dp[200005][20],dfs_num[200005];
34 | 
35 | void bl(ll u,ll p)
36 | {
37 |     dfs_num[u]=1;
38 |     dp[u][0]=p;
39 |     for(int i=1;i<20;i++)
40 |     {
41 |         if(dp[u][i-1]==-1)
42 |         {
43 |             dp[u][i]=-1;
44 |         }
45 |         else
46 |         {
47 |             dp[u][i]=dp[dp[u][i-1]][i-1];
48 |         }
49 |     }
50 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
51 |         ll v = AdjList[u][j];
52 |         if (dfs_num[v] == 0)
53 |             bl(v,u);
54 |     }
55 | }
56 | 
57 | ll query(ll x,ll k)
58 | {
59 |     if(x==-1 || k==0) return x;
60 |     for(int i=19;i>=0;i--)
61 |     {
62 |         if(k>=(1ll<<i))
63 |         {
64 |             return query(dp[x][i],k-(1ll<<i));
65 |         }
66 |     }
67 | }
68 | 
69 | int main()
70 | {
71 |     ios::sync_with_stdio(0);
72 |     cin.tie(0);
73 |     cout.tie(0);
74 |     ll n,q;
75 |     cin>>n>>q;
76 |     for(int i=1;i<n;i++)
77 |     {
78 |         ll x;
79 |         cin>>x;
80 |         x--;
81 |         AdjList[i].PB(x);
82 |         AdjList[x].PB(i);
83 |     }
84 |     bl(0,-1);
85 |     for(int i=0;i<q;i++)
86 |     {
87 |         ll x,k;
88 |         cin>>x>>k;
89 |         x--;
90 |         ll ans=query(x,k);
91 |         if(ans!=-1) ans+=1;
92 |         cout<<ans<<"\n";
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Subordinates.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vll AdjList[200005];
33 | ll dfs_num[200005],dp[200005];
34 | 
35 | void dfs(int u) {
36 |     dfs_num[u] = 1;
37 |     dp[u]=1;
38 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
39 |         ll v = AdjList[u][j];
40 |         if (dfs_num[v] == 0)
41 |         {
42 |             dfs(v);
43 |             dp[u]+=dp[v];
44 |         }
45 |     }
46 | }
47 | 
48 | int main()
49 | {
50 |     ios::sync_with_stdio(0);
51 |     cin.tie(0);
52 |     cout.tie(0);
53 |     ll n;
54 |     cin>>n;
55 |     for(int i=1;i<n;i++)
56 |     {
57 |         ll x;
58 |         cin>>x;
59 |         x--;
60 |         AdjList[i].PB(x);
61 |         AdjList[x].PB(i);
62 |     }
63 |     for(int i=0;i<n;i++)
64 |     {
65 |         dfs_num[i]=0;
66 |         dp[i]=0;
67 |     }
68 |     dfs(0);
69 |     for(int i=0;i<n;i++)
70 |     {
71 |         cout<<dp[i]-1<<" ";
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Tree Diameter.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | #include <ext/pb_ds/assoc_container.hpp>
  4 | #include <ext/pb_ds/tree_policy.hpp>
  5 | using namespace __gnu_pbds;
  6 | #define ll long long
  7 | #define vll vector<ll>
  8 | #define ld long double
  9 | #define pll pair<ll,ll>
 10 | #define PB push_back
 11 | #define MP make_pair
 12 | #define F first
 13 | #define S second
 14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
 15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
 16 | #define ook order_of_key
 17 | #define fbo find_by_order
 18 | const int MOD=1000000007; //998244353
 19 | long long int inverse(long long int i){
 20 |     if(i==1) return 1;
 21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
 22 | }
 23 | ll POW(ll a,ll b)
 24 | {
 25 |     if(b==0) return 1;
 26 |     if(b==1) return a%MOD;
 27 |     ll temp=POW(a,b/2);
 28 |     if(b%2==0) return (temp*temp)%MOD;
 29 |     else return (((temp*temp)%MOD)*a)%MOD;
 30 | }
 31 | 
 32 | ll INF=1e18;
 33 | 
 34 | int main()
 35 | {
 36 |     ios::sync_with_stdio(0);
 37 |     cin.tie(0);
 38 |     cout.tie(0);
 39 |     ll n;
 40 |     cin>>n;
 41 |     vll AdjList[n];
 42 |     for(int i=0;i<n-1;i++)
 43 |     {
 44 |         ll a,b;
 45 |         cin>>a>>b;
 46 |         a--; b--;
 47 |         AdjList[a].PB(b);
 48 |         AdjList[b].PB(a);
 49 |     }
 50 |     vll d(n, INF);
 51 |     d[0] = 0;
 52 |     queue<ll> q;
 53 |     q.push(0);
 54 |     while (!q.empty())
 55 |     {
 56 |         ll u = q.front(); q.pop(); // queue: layer by layer!
 57 |         for (int j = 0; j < (int)AdjList[u].size(); j++)
 58 |         {
 59 |             ll v = AdjList[u][j]; // for each neighbor of u
 60 |             if (d[v] == INF)
 61 |             {
 62 |                 d[v] = d[u] + 1;
 63 |                 q.push(v);
 64 |             }
 65 |         }
 66 |     }
 67 |     ll j=0,mx=0;
 68 |     for(int i=0;i<n;i++)
 69 |     {
 70 |         if(d[i]>mx)
 71 |         {
 72 |             mx=d[i];
 73 |             j=i;
 74 |         }
 75 |     }
 76 |     
 77 |     vll d1(n, INF);
 78 |     d1[j] = 0;
 79 |     q.push(j);
 80 |     while (!q.empty())
 81 |     {
 82 |         ll u = q.front(); q.pop(); // queue: layer by layer!
 83 |         for (int j = 0; j < (int)AdjList[u].size(); j++)
 84 |         {
 85 |             ll v = AdjList[u][j]; // for each neighbor of u
 86 |             if (d1[v] == INF)
 87 |             {
 88 |                 d1[v] = d1[u] + 1;
 89 |                 q.push(v);
 90 |             }
 91 |         }
 92 |     }
 93 |     ll ans=0;
 94 |     for(int i=0;i<n;i++)
 95 |     {
 96 |         ans=max(ans,d1[i]);
 97 |     }
 98 |     cout<<ans;
 99 | }
100 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Tree Distances II.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vll AdjList[200005];
33 | ll n,dfs_num[200005],dp[200005],ans[200005];
34 | 
35 | void dfs(int u, int d) {
36 |     ans[0]+=d;
37 |     dfs_num[u] = 1;
38 |     dp[u]=1;
39 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
40 |         ll v = AdjList[u][j];
41 |         if (dfs_num[v] == 0)
42 |         {
43 |             dfs(v,d+1);
44 |             dp[u]+=dp[v];
45 |         }
46 |     }
47 | }
48 | 
49 | void dfs1(int u) {
50 |     dfs_num[u] = 1;
51 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
52 |         ll v = AdjList[u][j];
53 |         if (dfs_num[v] == 0)
54 |         {
55 |             ans[v]=ans[u]+n-2*dp[v];
56 |             dfs1(v);
57 |         }
58 |     }
59 | }
60 | 
61 | int main()
62 | {
63 |     ios::sync_with_stdio(0);
64 |     cin.tie(0);
65 |     cout.tie(0);
66 |     cin>>n;
67 |     for(int i=0;i<n-1;i++)
68 |     {
69 |         ll a,b;
70 |         cin>>a>>b;
71 |         a--; b--;
72 |         AdjList[a].PB(b);
73 |         AdjList[b].PB(a);
74 |     }
75 |     dfs(0,0);
76 |     for(int i=0;i<n;i++)
77 |     {
78 |         dfs_num[i]=0;
79 |     }
80 |     dfs1(0);
81 |     for(int i=0;i<n;i++)
82 |     {
83 |         cout<<ans[i]<<" ";
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/Tree Algorithms/Tree Matching.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #include <ext/pb_ds/assoc_container.hpp>
 4 | #include <ext/pb_ds/tree_policy.hpp>
 5 | using namespace __gnu_pbds;
 6 | #define ll long long
 7 | #define vll vector<ll>
 8 | #define ld long double
 9 | #define pll pair<ll,ll>
10 | #define PB push_back
11 | #define MP make_pair
12 | #define F first
13 | #define S second
14 | #define oset tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
15 | #define osetll tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
16 | #define ook order_of_key
17 | #define fbo find_by_order
18 | const int MOD=1000000007; //998244353
19 | long long int inverse(long long int i){
20 |     if(i==1) return 1;
21 |     return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
22 | }
23 | ll POW(ll a,ll b)
24 | {
25 |     if(b==0) return 1;
26 |     if(b==1) return a%MOD;
27 |     ll temp=POW(a,b/2);
28 |     if(b%2==0) return (temp*temp)%MOD;
29 |     else return (((temp*temp)%MOD)*a)%MOD;
30 | }
31 | 
32 | vll AdjList[200005];
33 | ll dfs_num[200005],dp[200005],ans;
34 | 
35 | void dfs(int u) {
36 |     dfs_num[u] = 1;
37 |     for (int j = 0; j < (int)AdjList[u].size(); j++) {
38 |         ll v = AdjList[u][j];
39 |         if (dfs_num[v] == 0)
40 |         {
41 |             dfs(v);
42 |             if(dp[u]==0 && dp[v]==0)
43 |             {
44 |                 dp[u]=1;
45 |                 dp[v]=1;
46 |                 ans++;
47 |             }
48 |         }
49 |     }
50 | }
51 | 
52 | int main()
53 | {
54 |     ios::sync_with_stdio(0);
55 |     cin.tie(0);
56 |     cout.tie(0);
57 |     ll n;
58 |     cin>>n;
59 |     for(int i=0;i<n-1;i++)
60 |     {
61 |         ll a,b;
62 |         cin>>a>>b;
63 |         a--; b--;
64 |         AdjList[a].PB(b);
65 |         AdjList[b].PB(a);
66 |     }
67 |     for(int i=0;i<n;i++)
68 |     {
69 |         dfs_num[i]=0;
70 |         dp[i]=0;
71 |     }
72 |     ans=0;
73 |     dfs(0);
74 |     cout<<ans;
75 | }
76 | 


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