├── 2 - SAT with solution .cpp
├── Aho Corasick.cpp
├── Articulartion Points .cpp
├── Articulation Bridge .cpp
├── BIT - Binary Indexed Tree(All variant , Sum+Xor).cpp
├── BIT- Binary Indexed Tree - 2D ( All Variant , sum+xor).cpp
├── Bellman Ford .cpp
├── Bi-connected Components.cpp
├── Big Integer.cpp
├── Binary Lifting (Sum Query between two vertex of a tree) .cpp
├── Centroid Decomposition .cpp
├── Cycle Printing in Directed Graph .cpp
├── DSU Modified(DSU+Ordered Set).cpp
├── DSU On Tree (nlogn) .cpp
├── DSU On Tree O(n log^2 n) .cpp
├── Dijkstra .cpp
├── Dynamic Programming Road Map
    ├── CSES DP.PNG
    ├── GFG Recursion and Backtracking.PNG
    ├── README.md
    ├── Shafayat blog.PNG
    ├── hackearth dp.PNG
    └── leetcode dp.PNG
├── EULER TOURS On Tree  ( All variant).cpp
├── Euler Path_Circuit.cpp
├── Euler Tour Improved (FOR USE).cpp
├── FLOW1 - Max Flow (Ford-Fulkerson) O(E * max flow).cpp
├── FLOW2 - Max Flow (Edmonds-Karp) O(V * E^2).cpp
├── FLOW3 - Max Flow (for general use) (Dinic's algorithm) O(V^2 * E).cpp
├── FLOW4 - Minimum Cut.cpp
├── FLOW5 - Maximum Bipartite Matching HopcroftKarp.cpp
├── FLOW6 - Minimum Cost Maximum Flow (MCMF).cpp
├── FLOW7 - Minimum Cost Maximum Flow With Negative Cycle(MCMF).cpp
├── FLOW8 - Weighted Maximum Bipartite Matching (Hungarian algorithm).cpp
├── FLOW9 - Minimum Vertex Cover\Maximum Independent Set in Bipartite Graph (hopcroft-karp).cpp
├── GP Hash .cpp
├── Game Theory ( MEX , Sprague-Grundy Number Calculation).cpp
├── Gaussian Elimination.cpp
├── Heavy Light Decomposition ( Edge Update MINIMUM Query).cpp
├── Heavy Light Decomposition ( Sum Update Query on Vertex ).cpp
├── Heavy Light Decomposition (Sum Update Query on Edges ).cpp
├── Heavy Light Decomposition (Vertex Maximum Query with Single update).cpp
├── Inclusion Exclusion .cpp
├── Johnson’s algorithm for All-pairs shortest paths.cpp
├── LCA in O(1).cpp
├── LCA with Binary lifting.cpp
├── Longest Path In A DAG O(V+E).cpp
├── MO's Algorithm (K-th Minimum in Range).cpp
├── MST Krushkal .cpp
├── MST Prims .cpp
├── Matrix Exponentiation .cpp
├── Merge Sort Tree (k-th minimum in range) .cpp
├── Mobius Function.cpp
├── Monotonic Stack.cpp
├── Negative Cycle Printing .cpp
├── Order Multiset Template.cpp
├── Persistent Segment Tree (k-th minimum in range).cpp
├── Pollard Rho ( probabilistic Factorization) Algorithm.cpp
├── Prime Factorization .cpp
├── README.md
├── Segment Tree With Lazy Propagation.cpp
├── Shortest Path In A DAG O(V+E) .cpp
├── Sliding Window (Fixed,Variable Length Window Template).cpp
├── Strongly Connected Components to DAG.cpp
├── Suffix Array.cpp
├── Topological Sorting .cpp
├── Trie .cpp
├── Trie Xor (Min - Max).cpp
├── Why Dijkstra Fails For Negative Edges.md
├── XOR Basis.cpp
├── Z Function.cpp
├── zzzzzzz Me.png
└── zzzzzzzz Batarang.png


/2 - SAT with solution .cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | // 2- SAT
  3 | // a = a and -a = a+n edge; // here n being the number of variable 
  4 | 
  5 | const int N = 1e5;
  6 | vector<int>graph[N];
  7 | vector<int>Rgraph[N];
  8 | vector<int>forder;
  9 | bool vis1[N];
 10 | bool vis2[N];
 11 | int SCC[N];
 12 | vector<bool>assignment(N , false);
 13 |  
 14 | void addedge(int a,int b)
 15 | {
 16 |         graph[a].push_back(b);
 17 | }
 18 | void addRedge(int a,int b)
 19 | {
 20 |         Rgraph[b].push_back(a);
 21 | }
 22 |  
 23 | void dfs1(int s)
 24 | {
 25 |         vis1[s] = true;
 26 |         for(auto child:graph[s])
 27 |         {
 28 |                 if(vis1[child])
 29 |                 {
 30 |                         continue;
 31 |                 }
 32 |                 dfs1(child);
 33 |         }
 34 |         forder.push_back(s);
 35 | }
 36 |  
 37 | void dfs2(int s,int sccno)
 38 | {
 39 |         vis2[s] = true;
 40 |         SCC[s] = sccno;
 41 |         for(auto child : Rgraph[s])
 42 |         {
 43 |                 if(vis2[child])
 44 |                 {
 45 |                         continue;
 46 |                 }
 47 |                 dfs2(child,sccno);
 48 |         }
 49 | }
 50 |  
 51 |  
 52 | int32_t main()
 53 | {
 54 |         ios::sync_with_stdio(0);
 55 |         cin.tie(0);
 56 |  
 57 |         int n ;// number of variable
 58 |         cin>>n;
 59 |         int m; // number of clause
 60 |         cin>>m;
 61 |  
 62 |         int a[m]; // first element of clause
 63 |         int b[m]; // second element of clause
 64 |  
 65 |         for(int i=0;i<m;i++)
 66 |         {
 67 |                 cin>>a[i];
 68 |         }
 69 |         for(int i=0;i<m;i++)
 70 |         {
 71 |                 cin>>b[i];
 72 |         }
 73 |  
 74 |         for(int i=0;i<m;i++)
 75 |         {
 76 |                 if(a[i]>0 && b[i]> 0) // (a v b) = (-a -> b)^(-b -> a)
 77 |                 {
 78 |                         addedge(a[i]+n , b[i]); // (-a -> b)
 79 |                         addRedge(a[i]+n , b[i]);
 80 |                         addedge(b[i]+n , a[i]); //(-b -> a)
 81 |                         addRedge(b[i]+n , a[i]);
 82 |  
 83 |                 }
 84 |                 else if(a[i]>0 && b[i]<0) // (a v -b) = (-a -> -b)^(b -> a)
 85 |                 {
 86 |                         addedge(a[i]+n , n-b[i]); // (-a -> -b)
 87 |                         addRedge(a[i]+n , n-b[i]);
 88 |                         addedge(-b[i], a[i]); // (b -> a)
 89 |                         addRedge(-b[i] , a[i]);
 90 |                 }
 91 |                 else if(a[i]<0 && b[i]>0) // (-a v b) = (a -> b)^(-b -> -a)
 92 |                 {
 93 |                         addedge(-a[i] , b[i]); // (a -> b)
 94 |                         addRedge(-a[i] , b[i]);
 95 |                         addedge(b[i]+n, n-a[i]); // (-b -> -a)
 96 |                         addRedge(b[i]+n , n-a[i]);
 97 |                 }
 98 |                 else   //(-a v -b) = (a -> -b)^(b -> -a)
 99 |                 {
100 |                         addedge(-a[i] , n-b[i]); // (a -> -b)
101 |                         addRedge(-a[i] , n-b[i]);
102 |                         addedge(-b[i] , n-a[i]); // (b -> -a)
103 |                         addRedge(-b[i] , n-a[i]);
104 |                 }
105 |         }
106 |  
107 |         for(int i=1;i<=2*n;i++)
108 |         {
109 |                 if(vis1[i]==false)
110 |                 {
111 |                         dfs1(i);
112 |                 }
113 |         }
114 |  
115 |         reverse(forder.begin(),forder.end());
116 |         int cnt=0;
117 |         for(auto x : forder)
118 |         {
119 |                 if(vis2[x]==false)
120 |                 {
121 |                         cnt++;
122 |                         dfs2(x,cnt);
123 |                 }
124 |         }
125 |  
126 |  
127 |         bool ans = true;
128 |  
129 |  
130 |         for(int i=1;i<=n;i++)
131 |         {
132 |  
133 |                 if(SCC[i]==SCC[i+n])
134 |                 {
135 |                         ans = false;
136 |                 }
137 |                 assignment[i] = SCC[i+n]<SCC[i]; // ( -x -> x) hole x = true  else (x -> -x) hole x = false [for testing build a truth table]
138 |         }
139 |  
140 |  
141 |  
142 |         if(ans==false)
143 |         {
144 |                 cout<<"The given expression is NOT satisfiable."<<endl;
145 |                 return 0;
146 |         }
147 |  
148 |  
149 |         cout<<("The given expression is satisfiable.")<<endl;
150 |  
151 |  
152 |         cout<<"The solution: "<<endl;
153 |         for(int i=1;i<=n;i++)
154 |         {
155 |                 cout<<assignment[i]<<" ";
156 |         }
157 |         cout<<endl;
158 |  
159 |  
160 |  
161 |  
162 |  
163 |         return 0;
164 |  
165 |  
166 |  
167 |  
168 |  
169 |  
170 | }
171 |  
172 | /*
173 |  
174 | 5 7
175 | 1 -2 -1 3 -3 -4 -3
176 | 2 3 -2 4 5 -5 4
177 |  
178 | output : The given expression is satisfiable
179 |  
180 | The solution:
181 | 1 0 0 1 0
182 |  
183 |  
184 | 2 4
185 | 1 -1 1 -1
186 | 2 2 -2 -2
187 |  
188 | output : The given expression is NOT satisfiable
189 |  
190 | */
191 |  
192 |  
193 | 


--------------------------------------------------------------------------------
/Aho Corasick.cpp:
--------------------------------------------------------------------------------
  1 | // Motto : longest suffix that ends at i which is also a prefix
  2 | =============================================================== Aho Corasic =============================================
  3 | 
  4 | 
  5 | // 1.Finding The occarance of all pattern in a text in O(text.size()) time.
  6 | 
  7 | 
  8 | const int ALPH = 52;
  9 | const int N = 5e5;
 10 | map<char,int>node[N];  // it is equal to [[  int node[N][ALPH]  ]]; Trie er moto
 11 | const int root = 0;
 12 | int avail = 0;
 13 | 
 14 | //Suffix Link or Failure Link
 15 | int fail[N];
 16 | int nxtWord[N];
 17 | int wordId[N];
 18 | 
 19 | 
 20 | void ini()
 21 | {
 22 |         for(int i=0;i<=avail;i++)
 23 |         {
 24 |                 node[i].clear();
 25 |         }
 26 |         avail = 0;
 27 | }
 28 | 
 29 | int insertTrie(const string &s , int idx)
 30 | {
 31 |         int cur = root;
 32 |         for(int i=0;i<s.size();i++)
 33 |         {
 34 |                 if(node[cur][s[i]]==0)
 35 |                 {
 36 |                         avail++;
 37 |                         node[cur][s[i]] = avail;
 38 |                         fail[avail] = 0;
 39 |                         nxtWord[avail] = 0;
 40 |                         wordId[avail] = -1;
 41 | 
 42 |                 }
 43 |                 cur = node[cur][s[i]];
 44 |         }
 45 |         if(wordId[cur]==-1)
 46 |         {
 47 |                 wordId[cur] = idx;
 48 |         }
 49 |         return wordId[cur];
 50 | }
 51 | 
 52 | 
 53 | void computeFailureLinkBFS() // OR suffix link
 54 | {
 55 |         queue<int>q;
 56 |         for(auto x : node[root])
 57 |         {
 58 |                 q.push(x.second); // root er child node er No.
 59 |         }
 60 |         while(!q.empty())
 61 |         {
 62 |                 int u = q.front();
 63 |                 q.pop();
 64 |                 for(auto [ch , v] : node[u]) // v = child node . ch = transition character
 65 |                 {
 66 |                         int f = fail[u]; // parent er fail link e gelam : jate sekan theke check korbo node ch e Transition hoy naki
 67 | 
 68 |                         while(node[f][ch]==0 && f!=0) // jotokkon porjonto f No. node theke ch Transition exit's na kore totokkon failure link e jump kortei thakbo . f = 0 hoyegele off
 69 |                         {
 70 |                                 f = fail[f];
 71 |                         }
 72 | 
 73 |                         fail[v] = node[f][ch]; // jodi node[f][ch] ch na thake tahole auto f =  0 zero assign(ie. root ) map er karone
 74 | 
 75 |                         if(wordId[fail[v]] !=-1)
 76 |                         {
 77 |                                 nxtWord[v] = fail[v];
 78 |                         }
 79 |                         else
 80 |                         {
 81 |                                 nxtWord[v] = nxtWord[fail[v]];
 82 |                         }
 83 | 
 84 |                         q.push(v);
 85 | 
 86 |                 }
 87 |         }
 88 | }
 89 | 
 90 | 
 91 | vector<vector<int>> match(const string &text , int q)
 92 | {
 93 |         vector<vector<int>> ret(q);
 94 | 
 95 |         int cur = root;
 96 | 
 97 |         for(int i=0;i<text.size();i++)
 98 |         {
 99 |                 while(node[cur][text[i]]==0 && cur!=0)
100 |                 {
101 |                         cur = fail[cur];
102 |                 }
103 |                 cur = node[cur][text[i]];
104 | 
105 |                 int u = cur;
106 | 
107 |                 while(u!=0)
108 |                 {
109 |                         if(wordId[u]!=-1)
110 |                         {
111 |                                 ret[wordId[u]].push_back(i);
112 |                         }
113 |                         u = nxtWord[u];
114 |                 }
115 |         }
116 |         return ret;
117 | }
118 | 
119 | 
120 | int32_t main()
121 | {
122 |         ios::sync_with_stdio(0);
123 |         cin.tie(0);
124 | 
125 |         int t;
126 |         cin>>t;
127 | 
128 |         while(t--)
129 |         {
130 |                 ini();
131 |                 string text;
132 |                 cin>>text;
133 |                 int n;
134 |                 cin>>n;
135 |                 vector<int>id;
136 |                 for(int i=0;i<n;i++)
137 |                 {
138 |                         string s;
139 |                         cin>>s;
140 |                         id.push_back(insertTrie(s,i));
141 |                 }
142 |                 computeFailureLinkBFS();
143 | 
144 |                 auto matching = match(text,n);
145 | 
146 |                 for(int i=0;i<n;i++)
147 |                 {
148 |                         cout<<"yn"[matching[id[i]].empty()]<<endl;   //matching[id[i]] id[i] erokom likte hobe . etar modde all occarance pawa jabe
149 |                 }
150 |         }
151 | 
152 |         return 0;
153 | 
154 | 
155 | 
156 | }
157 | 


--------------------------------------------------------------------------------
/Articulartion Points .cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | const int N = 1e5;
 3 | vector<int>graph[N];
 4 | bool vis[N];
 5 | vector<int>parent(N,-1);
 6 | int dis[N];
 7 | int low[N];
 8 | set<int>AP;
 9 | 
10 | void dfs(int s , int time = 0)
11 | {
12 |         time++;
13 |         vis[s] = true;
14 |         dis[s] = low[s] = time;
15 |         int childno = 0;
16 |         for(auto child : graph[s])
17 |         {
18 |                 if(parent[s]==child)
19 |                 {
20 |                         continue;
21 |                 }
22 |                 if(vis[child])
23 |                 {
24 |                         low[s] = min(low[s],dis[child]);
25 |                         continue;
26 |                 }
27 |                 childno++;
28 |                 parent[child] = s;
29 |                 dfs(child, time);
30 |                 low[s] = min(low[s],low[child]);
31 | 
32 |                 if(parent[s]!=-1 && dis[s]<=low[child]) // make sure s is not the root
33 |                 {
34 |                         AP.insert(s);
35 |                 }
36 |         }
37 |         if(s==0 && childno>1) // handling the root case
38 |         {
39 |                 AP.insert(s);
40 |         }
41 | 
42 |         return;
43 | }
44 | 
45 | 
46 | int32_t main()
47 | {
48 |         ios::sync_with_stdio(0);
49 |         cin.tie(0);
50 |         int n,m;
51 |         cin>>n>>m;
52 |         for(int i=0;i<m;i++)
53 |         {
54 |                 int x,y;
55 |                 cin>>x>>y;
56 |                 graph[x].push_back(y);
57 |                 graph[y].push_back(x);
58 |         }
59 |         dfs(0);
60 |         for(auto x : AP)
61 |         {
62 |                 cout<<x<<" ";
63 |         }
64 |         cout<<endl;
65 | 
66 |         return 0;
67 | 
68 | 
69 | 
70 | 
71 | 
72 | 
73 | }
74 | 


--------------------------------------------------------------------------------
/Articulation Bridge .cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | const int N = 1e5;
 3 | vector<int>graph[N];
 4 | bool vis[N];
 5 | vector<int>parent(N,-1);
 6 | int dis[N];
 7 | int low[N];
 8 | set<pair<int,int>>bridge;
 9 | 
10 | void dfs(int s , int time = 0)
11 | {
12 |         time++;
13 |         vis[s] = true;
14 |         dis[s] = low[s] = time;
15 |         for(auto child : graph[s])
16 |         {
17 |                 if(parent[s]==child)
18 |                 {
19 |                         continue;
20 |                 }
21 |                 if(vis[child])
22 |                 {
23 |                         low[s] = min(low[s],dis[child]); // backedge checking
24 |                         continue;
25 |                 }
26 |                 parent[child] = s;
27 |                 dfs(child, time);
28 |                 low[s] = min(low[s],low[child]);
29 | 
30 |                 if(dis[s]<low[child]) // make sure s is not the root
31 |                 {
32 |                         bridge.insert({s,child});
33 |                 }
34 |         }
35 | 
36 |         return;
37 | }
38 | 
39 | 
40 | int32_t main()
41 | {
42 |         ios::sync_with_stdio(0);
43 |         cin.tie(0);
44 |         int n,m;
45 |         cin>>n>>m;
46 |         for(int i=0;i<m;i++)
47 |         {
48 |                 int x,y;
49 |                 cin>>x>>y;
50 |                 graph[x].push_back(y);
51 |                 graph[y].push_back(x);
52 |         }
53 |         for(int i=0;i<n;i++)
54 |         {
55 |                 if(!vis[i])
56 |                 {
57 |                         dfs(i);
58 |                 }
59 |         }
60 |         for(auto x : bridge)
61 |         {
62 |                 cout<<x.first<<" "<<x.second<<endl;
63 |         }
64 |         cout<<endl;
65 | 
66 |         return 0;
67 | 
68 | 
69 | 
70 | 
71 | 
72 | 
73 | }
74 | 


--------------------------------------------------------------------------------
/BIT - Binary Indexed Tree(All variant , Sum+Xor).cpp:
--------------------------------------------------------------------------------
  1 | =============================== 1D BIT ===========
  2 | 
  3 | ===================== 1.Point update - Range Query(sum)========
  4 | 
  5 | 
  6 | const int N = 2e5+100;
  7 | int BIT[N];
  8 | int n;
  9 | 
 10 | void update(int x,int val)
 11 | {
 12 |         for(; x<=n ; x+= (x&-x))
 13 |         {
 14 |                 BIT[x]+=val;
 15 |         }
 16 |         return;
 17 | }
 18 | 
 19 | int query(int x)
 20 | {
 21 |         int sum = 0;
 22 |         for(;  x>0 ;  x-=(x&-x))
 23 |         {
 24 |                 sum+= BIT[x];
 25 |         }
 26 |         return sum;
 27 | }
 28 | 
 29 | int32_t main()
 30 | {
 31 |         ios::sync_with_stdio(0);
 32 |         cin.tie(0);
 33 | 
 34 | 
 35 |         int q;
 36 |         cin>>n>>q;
 37 |         for(int i=1;i<=n;i++) // BIT should be 1 based index
 38 |         {
 39 |                 int a;
 40 |                 cin>>a;
 41 |                 update(i,a);
 42 |         }
 43 | 
 44 |         while(q--)
 45 |         {
 46 |                 int a;
 47 |                 cin>>a;
 48 |                 if(a==1)
 49 |                 {
 50 |                         int b,c;
 51 |                         cin>>b>>c;
 52 |                         int val = query(b)-query(b-1);
 53 |                         update(b,-val);
 54 |                         update(b,c); //point update
 55 |                 }
 56 |                 else
 57 |                 {
 58 |                         int l,r;
 59 |                         cin>>l>>r;
 60 | 
 61 |                         cout<<query(r)-query(l-1)<<endl;  //Range Query
 62 |                 }
 63 |         }
 64 | 
 65 |         return 0;
 66 | 
 67 | 
 68 | }
 69 | 
 70 | ====================================================
 71 | 
 72 | ======================  2.Range Update - point Query(sum) ==========
 73 | 
 74 | //Intermediary
 75 | //Young kid on the block
 76 | //AIAsif try's Continuing the journey
 77 | #include<bits/stdc++.h>
 78 | #include <ext/pb_ds/assoc_container.hpp>
 79 | #include <ext/pb_ds/tree_policy.hpp>
 80 | using namespace std;
 81 | using namespace __gnu_pbds;
 82 | #define endl "\n"
 83 | #define int long long int
 84 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
 85 | 
 86 | const int N = 2e5+10;
 87 | int BIT[N];
 88 | 
 89 | void update(int x,int num)
 90 | {
 91 |         for(; x<N ; x+=(x&-x))
 92 |         {
 93 |                 BIT[x]+=num;
 94 |         }
 95 | }
 96 | 
 97 | void Update(int l,int r,int num)
 98 | {
 99 |         update(l,num);
100 |         update(r+1,-num);
101 | }
102 | 
103 | int PointQuery(int x) // 1 based
104 | {
105 |         int ans = 0;
106 |         for(; x>0 ; x-=(x&-x))
107 |         {
108 |                 ans += BIT[x];
109 |         }
110 |         return ans;
111 | }
112 | 
113 | int32_t main()
114 | {
115 |         ios::sync_with_stdio(0);
116 |         cin.tie(0);
117 | 
118 |         int n;
119 |         cin>>n;
120 |         for(int i=1;i<=n;i++)
121 |         {
122 |                 int a;
123 |                 cin>>a;
124 |                 Update(i,i,a);
125 |         }
126 | 
127 |         int q;
128 |         cin>>q;
129 | 
130 |         while(q--)
131 |         {
132 |                 int a;
133 |                 cin>>a;
134 |                 if(a==1)
135 |                 {
136 |                         int l,r,val;
137 |                         cin>>l>>r>>val;
138 |                         Update(l,r,val);
139 |                 }
140 |                 else 
141 |                 {
142 |                         int pos; // 1 based
143 |                         cin>>pos;
144 |                         cout<<PointQuery(pos)<<endl;
145 |                 }
146 |         }
147 | 
148 |         return 0;
149 | 
150 | 
151 | }
152 | 
153 | I/O
154 | 
155 | 5
156 | 0 0 0 0 0
157 | 4
158 | 1 3 5 2
159 | 2 5
160 | 1 1 4 4
161 | 2 4
162 | 
163 | O/P
164 | 2
165 | 6
166 | 
167 | ======================================================================
168 | 
169 | ========================3.Range Update - Range Query(sum) ================
170 | 
171 | //Intermediary
172 | //Young kid on the block
173 | //AIAsif try's Continuing the journey
174 | #include<bits/stdc++.h>
175 | #include <ext/pb_ds/assoc_container.hpp>
176 | #include <ext/pb_ds/tree_policy.hpp>
177 | using namespace std;
178 | using namespace __gnu_pbds;
179 | #define endl "\n"
180 | #define int long long int
181 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
182 | 
183 | const int N = 2e5+100;
184 | int BIT1[N];
185 | int BIT2[N];
186 | 
187 | void update(int BIT[] , int x , int num)
188 | {
189 |         for(;x<N; x += (x&-x))
190 |         {
191 |                 BIT[x] += num;
192 |         }
193 | }
194 | 
195 | void RangeUpdate(int l,int r,int num) // You have to use this method : cant use these above
196 | {
197 |         update(BIT1 , l , num);
198 |         update(BIT1, r+1, -num);
199 |         update(BIT2 , l , num*(l-1));
200 |         update(BIT2,r+1,-num*r);
201 | }
202 | 
203 | int query(int BIT[] ,int x)
204 | {
205 |         int sum = 0;
206 |         for(;x>0;x-=(x&-x))
207 |         {
208 |                 sum += BIT[x];
209 |         }
210 |         return sum;
211 | }
212 | 
213 | int PrefixSum(int i)
214 | {
215 |         return query(BIT1,i)*i-query(BIT2 , i); // For explainantion check cp algo
216 | }
217 | 
218 | int RangeQuery(int l,int r) // You have to use this method : cant use other above
219 | {
220 |         return PrefixSum(r)-PrefixSum(l-1);
221 | }
222 | 
223 | 
224 | 
225 | int32_t main()
226 | {
227 |         ios::sync_with_stdio(0);
228 |         cin.tie(0);
229 | 
230 |         int n;
231 |         cin>>n;
232 |         for(int i=1;i<=n;i++)
233 |         {
234 |                 int a;
235 |                 cin>>a;
236 |                 RangeUpdate(i,i,a);
237 |         }
238 | 
239 |         int q;
240 |         cin>>q;
241 |         while(q--)
242 |         {
243 |                 int a;
244 |                 cin>>a;
245 |                 if(a==1)
246 |                 {
247 |                         int l,r,val;
248 |                         cin>>l>>r>>val;
249 |                         RangeUpdate(l,r,val);
250 |                 }
251 |                 else 
252 |                 {
253 |                         int l,r;
254 |                         cin>>l>>r;
255 |                         cout<<RangeQuery(l,r)<<endl;
256 |                 }
257 |         }
258 | 
259 | 
260 | }
261 | 
262 | I/O
263 | 
264 | 7
265 | 1 2 3 4 5 6 7
266 | 4
267 | 1 3 5 2
268 | 2 2 4
269 | 1 2 6 1
270 | 2 3 6
271 | 
272 | O/P
273 | 
274 | 13
275 | 28
276 | 
277 | ====================================================================
278 | 
279 | ============== Range Update - Range Query (xor) ==============
280 | 
281 | //Intermediary
282 | //Young kid on the block
283 | //AIAsif try's Continuing the journey
284 | #include<bits/stdc++.h>
285 | #include <ext/pb_ds/assoc_container.hpp>
286 | #include <ext/pb_ds/tree_policy.hpp>
287 | using namespace std;
288 | using namespace __gnu_pbds;
289 | #define endl "\n"
290 | #define int long long int
291 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
292 | 
293 | 
294 | const int N = 2e5+100;
295 | int BIT1[N];
296 | int BIT2[N];
297 | 
298 | void update(int BIT[] , int x , int num)
299 | {
300 |         for(;x<N; x += (x&-x))
301 |         {
302 |                 BIT[x] ^= num;
303 |         }
304 | }
305 | 
306 | void RangeUpdate(int l,int r,int num) // You have to use this method : cant use these above
307 | {
308 |         update(BIT1 , l ,  num);
309 |         update(BIT1 , r+1, num);
310 |         update(BIT2 , l ,  num*((l-1)&1) ); //While modifing Range Sum Query BIT :  num*(l-1) means num appears (l-1) times . So for Range Xor Query if (l-1) is even then xor = 0 . if (l-1) is odd then xor = num
311 |         update(BIT2 , r+1, num*(r&1)); //While modifing Range Sum Query BIT :  num*r means num appears r times . So for Range Xor Query if r is even then xor = 0 . if r is odd then xor = num
312 | }
313 | 
314 | int query(int BIT[] ,int x)
315 | {
316 |         int sum = 0;
317 |         for(;x>0;x-=(x&-x))
318 |         {
319 |                 sum ^= BIT[x];
320 |         }
321 |         return sum;
322 | }
323 | 
324 | int PrefixXor(int i)
325 | {
326 |         return query(BIT1,i)*(i&1)^query(BIT2 , i);  //In Range Sum Query BIT . query(BIT1,i)*i meant query(BIT1,i) appeared i times . So for Range Xor BIT we just need to check whether i is odd or even like before
327 | }
328 | 
329 | int RangeQuery(int l,int r) // You have to use this method : cant use other above
330 | {
331 |         return PrefixXor(r)^PrefixXor(l-1);
332 | }
333 | 
334 | 
335 | 
336 | int32_t main()
337 | {
338 |         ios::sync_with_stdio(0);
339 |         cin.tie(0);
340 | 
341 |         int n;
342 |         cin>>n;
343 |         for(int i=1;i<=n;i++)
344 |         {
345 |                 int a;
346 |                 cin>>a;
347 |                 RangeUpdate(i,i,a);
348 |         }
349 | 
350 |         int q;
351 |         cin>>q;
352 |         while(q--)
353 |         {
354 |                 int a;
355 |                 cin>>a;
356 |                 if(a==1)
357 |                 {
358 |                         int l,r,val;
359 |                         cin>>l>>r>>val;
360 |                         RangeUpdate(l,r,val);
361 |                 }
362 |                 else 
363 |                 {
364 |                         int l,r;
365 |                         cin>>l>>r;
366 |                         cout<<RangeQuery(l,r)<<endl;
367 |                 }
368 |         }
369 | 
370 | 
371 | }
372 | 
373 | I/O
374 | 7
375 | 1 2 3 4 5 6 7
376 | 4
377 | 1 3 5 2
378 | 2 2 4
379 | 1 2 6 1
380 | 2 3 6
381 | 
382 | O/P
383 | 5
384 | 6
385 | 
386 | =================================================
387 | 
388 | 
389 | 
390 | 


--------------------------------------------------------------------------------
/Bellman Ford .cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | int inf = 1e18;
 3 | 
 4 | struct edge
 5 | {
 6 |         int x;
 7 |         int y;
 8 |         int w;
 9 | };
10 | 
11 | 
12 | int32_t main()
13 | {
14 |         ios::sync_with_stdio(0);
15 |         cin.tie(0);
16 |         int n,m;
17 |         cin>>n>>m;
18 |         vector<edge>edges;
19 | 
20 |         for(int i=0;i<m;i++)
21 |         {
22 |                 int x,y,w;
23 |                 cin>>x>>y>>w;
24 |                 edges.push_back({x,y,w});
25 |         }
26 | 
27 |         vector<int>dis(n+1,inf);
28 | 
29 |         dis[0] = 0;
30 |         dis[1] = 0; // distant of source is 0 . very important
31 | 
32 |         vector<int>par(n+4,-1);
33 | 
34 |         bool neg_cycle = false;
35 | 
36 |         for(int i=0;i<n;i++)
37 |         {
38 |                 for(int j=0;j<m;j++)
39 |                 {
40 |                         int u = edges[j].x;
41 |                         int v = edges[j].y;
42 |                         int w = edges[j].w;
43 |                         if(dis[u]<inf)
44 |                         {
45 |                                 if( dis[u]+w < dis[v])
46 |                                 {
47 |                                         if(i==n-1)
48 |                                         {
49 |                                                 neg_cycle = true;
50 |                                         }
51 |                                         dis[v] = min(dis[v] , dis[u]+w);
52 |                                         par[v] = u;
53 |                                 }
54 | 
55 |                         }
56 |                 }
57 |         }
58 | 
59 | 
60 | //        vector<int>path;
61 | //
62 | //        int v = n;
63 | //
64 | //        while(v!=-1) // path printing
65 | //        {
66 | //                path.push_back(v);
67 | //                v = par[v];
68 | //        }
69 | //
70 | //        reverse(path.begin() , path.end());
71 | //
72 | //        for(auto x : path)
73 | //        {
74 | //                cout<<x<<" ";
75 | //        }
76 | //        cout<<endl;
77 | 
78 |         if(neg_cycle)
79 |         {
80 |                 cout<<"Neg cycle is present"<<endl;
81 |         }
82 |         else
83 |         {
84 |                 cout<<"No neg cycle"<<endl;
85 |         }
86 | 
87 |         return 0;
88 | 
89 | 
90 | 
91 | }
92 | 


--------------------------------------------------------------------------------
/Bi-connected Components.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | const int N = 10000;
  3 | vector<int>graph[N];
  4 | int low[N];
  5 | int dis[N];
  6 | vector<int>par(N,-1);
  7 | bool vis[N];
  8 | vector<pair<int,int>>p[N];
  9 | int no = 1;
 10 | 
 11 | void dfs(int s, stack<pair<int,int>> &st , int time)
 12 | {
 13 |         time++;
 14 |         vis[s] = true;
 15 |         low[s] = dis[s] = time;
 16 |         int childno = 0;
 17 |         for(auto child : graph[s])
 18 |         {
 19 |                 if(par[s]==child)
 20 |                 {
 21 |                         continue;
 22 |                 }
 23 |                 if(vis[child])
 24 |                 {
 25 |                         low[s] = min(low[s] , dis[child]);
 26 |                         if(dis[child]<dis[s])
 27 |                         {
 28 |                                 st.push({s,child});
 29 |                         }
 30 |                         continue;
 31 |                 }
 32 |                 par[child] = s;
 33 |                 childno++;
 34 | 
 35 |                 st.push({s,child});
 36 | 
 37 |                 dfs(child,st,time);
 38 |                 low[s] = min(low[s] , low[child]);
 39 | 
 40 | 
 41 |                 if((par[s]==-1 && childno>1) || (par[s]!=-1 && dis[s]<=low[child]) )
 42 |                 {
 43 |                         while(st.top().first!=s || st.top().second!= child)
 44 |                         {
 45 |                                 p[no].push_back({st.top().first ,st.top().second });
 46 |                                 st.pop();
 47 |                         }
 48 |                         p[no].push_back({st.top().first ,st.top().second });
 49 |                         st.pop();
 50 |                         no++;
 51 |                 }
 52 |         }
 53 | }
 54 | 
 55 | 
 56 | int32_t main()
 57 | {
 58 |         ios::sync_with_stdio(0);
 59 |         cin.tie(0);
 60 |         int n,m;
 61 |         cin>>n>>m;
 62 |         for(int i=0;i<m;i++)
 63 |         {
 64 |                 int x,y;
 65 |                 cin>>x>>y;
 66 |                 graph[x].push_back(y);
 67 |                 graph[y].push_back(x);
 68 |         }
 69 |         stack<pair<int,int>>st;
 70 |         for(int i=0;i<n;i++)
 71 |         {
 72 |                 if(vis[i]==false)
 73 |                 {
 74 |                         dfs(i,st,0);
 75 |                 }
 76 |                 bool flag = false;
 77 |                 while(!st.empty())
 78 |                 {
 79 |                         flag = true;
 80 |                         p[no].push_back({st.top().first ,st.top().second });
 81 |                         st.pop();
 82 |                 }
 83 |                 if(flag)
 84 |                 {
 85 |                         no++;
 86 |                 }
 87 |         }
 88 | 
 89 |         cout<<"-------------"<<endl;
 90 |         for(int i=1;i<N;i++)
 91 |         {
 92 |                 if(p[i].size()==0)
 93 |                 {
 94 |                         break;
 95 |                 }
 96 |                 cout<<"BCC NO: "<<i<<":"<<endl;
 97 |                 for(int j=0;j<p[i].size();j++)
 98 |                 {
 99 |                         cout<<p[i][j].first<<"-"<<p[i][j].second<<" ";
100 |                 }
101 |                 cout<<endl;
102 |         }
103 | 
104 | 
105 | 
106 |         return 0;
107 | 
108 | 
109 | }
110 | 
111 | /*
112 | geeksforgeeks
113 | 12 28
114 | 0 1
115 | 1 0
116 | 1 2
117 | 2 1
118 | 1 3
119 | 3 1
120 | 2 3
121 | 3 2
122 | 2 4
123 | 4 2
124 | 3 4
125 | 4 3
126 | 1 5
127 | 5 1
128 | 0 6
129 | 6 0
130 | 5 6
131 | 6 5
132 | 5 7
133 | 7 5
134 | 5 8
135 | 8 5
136 | 7 8
137 | 8 7
138 | 8 9
139 | 9 8
140 | 10 11
141 | 11 10
142 | */
143 | 
144 | /* hackerearth
145 | 6 6
146 | 0 3
147 | 3 2
148 | 2 5
149 | 2 4
150 | 5 4
151 | 1 4
152 | 
153 | */
154 | 


--------------------------------------------------------------------------------
/Binary Lifting (Sum Query between two vertex of a tree) .cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | //Using binary lifting find sum of value from vertex U to V in a tree
  4 | 
  5 | //NO updates
  6 | 
  7 | 
  8 | 
  9 | const int N = 1e5+10;
 10 | vector<pair<int,int>>graph[N];
 11 | bool vis[N];
 12 | const int L = log2(N);
 13 | int up[N][L+1];
 14 | int sum[N];
 15 | int din[N];
 16 | int dout[N];
 17 | int tin;
 18 | int tout;
 19 | 
 20 | void dfs(int s,int par)
 21 | {
 22 |         vis[s] = true;
 23 |         up[s][0] = par;
 24 | 
 25 |         din[s] = tin++;
 26 |         for(int i=1;i<=L;i++)
 27 |         {
 28 |                 up[s][i] = up[ up[s][i-1] ][i-1];
 29 |         }
 30 | 
 31 |         for(auto child : graph[s])
 32 |         {
 33 |                 if(vis[child.first])
 34 |                 {
 35 |                         continue;
 36 |                 }
 37 | 
 38 |                 sum[child.first] = sum[s] + child.second; // here storing prefix sum
 39 | 
 40 |                 dfs(child.first,s);
 41 |         }
 42 |         dout[s] = tout++;
 43 | }
 44 | 
 45 | bool is_ancestor(int u,int v)
 46 | {
 47 |         if(din[u]<=din[v] && dout[u]>=dout[v])
 48 |         {
 49 |                 return true;
 50 |         }
 51 |         return false;
 52 | }
 53 | 
 54 | int lca(int u,int v)
 55 | {
 56 |         if(is_ancestor(u,v))
 57 |         {
 58 |                 return u;
 59 |         }
 60 |         if(is_ancestor(v,u))
 61 |         {
 62 |                 return v;
 63 |         }
 64 |         for(int i=L;i>=0;i--)
 65 |         {
 66 |                 if(!is_ancestor(up[u][i] , v))
 67 |                 {
 68 |                         u = up[u][i];
 69 |                 }
 70 |         }
 71 |         return up[u][0];
 72 | }
 73 | 
 74 | 
 75 | int32_t main()
 76 | {
 77 |         ios::sync_with_stdio(0);
 78 |         cin.tie(0);
 79 |         int n;
 80 |         cin>>n;
 81 |         for(int i=0;i<n-1;i++)
 82 |         {
 83 |                 int x,y,w;
 84 |                 cin>>x>>y>>w;
 85 |                 graph[x].push_back({y,w});
 86 |                 graph[y].push_back({x,w});
 87 |         }
 88 | 
 89 |         dfs(1,1);
 90 | 
 91 |         int q;
 92 |         cin>>q;
 93 |         while(q--)
 94 |         {
 95 |                 int u,v;
 96 |                 cin>>u>>v;
 97 | 
 98 |                 int l = lca(u,v);
 99 | 
100 |                 if(l==u || l==v)
101 |                 {
102 |                         cout<<abs(sum[u]-sum[v])<<endl;
103 |                 }
104 |                 else
105 |                 {
106 |                         cout<<abs(sum[l]-sum[u])+abs(sum[v]-sum[l])<<endl;
107 |                 }
108 |         }
109 | 
110 | 
111 |         return 0;
112 | 
113 | 
114 | 
115 | 
116 | }
117 | 
118 | 
119 | 
120 | /*
121 | 13
122 | 1 2 2
123 | 1 4 7
124 | 2 3 8
125 | 3 8 9
126 | 3 7 7
127 | 7 9 6
128 | 7 10 5
129 | 4 6 10
130 | 4 5 9
131 | 5 11 11
132 | 11 12 3
133 | 11 13 12
134 | 5
135 | 9 11
136 | 11 6
137 | 2 3
138 | 9 10
139 | 8 5
140 | 
141 | 
142 | o/p
143 | 
144 | 50
145 | 30
146 | 8
147 | 11
148 | 35
149 | 
150 | */
151 | 


--------------------------------------------------------------------------------
/Cycle Printing in Directed Graph .cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | // Printing cycle in a directed graph
  4 | 
  5 | // Round trip 1 was on undirected graph , but here round trip 2 is on directed graph so normal dfs visit one time wont work
  6 | // visited but not returned , thats our target
  7 | 
  8 | const int N = 1e5+100;
  9 | int vis[N];
 10 | vector<int>graph[N];
 11 | int Time[N];
 12 | bool ok;
 13 | bool flag;
 14 | vector<int>ans;
 15 | int parent[N];
 16 | int start,finish;
 17 | 
 18 | void dfs(int s,int tim)
 19 | {
 20 |         vis[s] = 1;
 21 |         Time[s] = tim++;
 22 |         for(auto child: graph[s])
 23 |         {
 24 |                 if(vis[child]==0 )
 25 |                 {
 26 |                         parent[child] = s;
 27 |                         dfs(child,tim);
 28 |                         if(ok)
 29 |                         {
 30 |                                 return;
 31 |                         }
 32 |                 }
 33 |                 if(vis[child]==1)
 34 |                 {
 35 | 
 36 |                         start = s;
 37 |                         finish = child;
 38 |                         ok = true;
 39 |                         flag = true;
 40 |                         return;
 41 |                 }
 42 | 
 43 |         }
 44 | 
 45 |         vis[s] = 2;
 46 | 
 47 | 
 48 | }
 49 | 
 50 | int32_t main()
 51 | {
 52 |         ios::sync_with_stdio(0);
 53 |         cin.tie(0);
 54 |         int n,m;
 55 |         cin>>n>>m;
 56 | 
 57 |         for(int i=0;i<m;i++)
 58 |         {
 59 |                 int x,y;
 60 |                 cin>>x>>y;
 61 |                 graph[x].push_back(y);
 62 |         }
 63 | 
 64 | 
 65 |         for(int i=1;i<=n;i++)
 66 |         {
 67 |                 if(vis[i]==false)
 68 |                 {
 69 |                         dfs(i,0);
 70 |                         if(flag)
 71 |                         {
 72 |                                 break;
 73 |                         }
 74 |                 }
 75 |         }
 76 | 
 77 | 
 78 |         if(flag)
 79 |         {
 80 | 
 81 |                 ans.push_back(finish);
 82 | 
 83 |                 while(finish!=start)
 84 |                 {
 85 |                         ans.push_back(start);
 86 |                         start = parent[start];
 87 |                 }
 88 | 
 89 |                 ans.push_back(finish);
 90 | 
 91 |                 reverse(ans.begin(),ans.end());
 92 | 
 93 | 
 94 |                cout<<ans.size()<<endl;
 95 | 
 96 |                for(auto x : ans)
 97 |                {
 98 |                        cout<<x<<" ";
 99 |                }
100 |                cout<<endl;
101 | 
102 |                return 0;
103 | 
104 | 
105 |         }
106 | 
107 | 
108 | 
109 |         cout<<"IMPOSSIBLE"<<endl;
110 | 
111 |         return 0;
112 | 
113 | 
114 | 
115 | 
116 | 
117 | }
118 | 


--------------------------------------------------------------------------------
/DSU Modified(DSU+Ordered Set).cpp:
--------------------------------------------------------------------------------
  1 | //Intermediary
  2 | //Young kid on the block
  3 | //AIAsif try's Continuing the journey
  4 | #include<bits/stdc++.h>
  5 | #include <ext/pb_ds/assoc_container.hpp>
  6 | #include <ext/pb_ds/tree_policy.hpp>
  7 | using namespace std;
  8 | using namespace __gnu_pbds;
  9 | #define endl "\n"
 10 | #define int long long int
 11 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
 12 | 
 13 | //https://codeforces.com/gym/102625/problem/G
 14 | 
 15 | 
 16 | //Modified dsu
 17 | //dsu + ordered set
 18 | //    [ u -- v  edge]  lets say I want to get the size of [left part of u in the component tree and right part of v in the same component tree] 
 19 | 
 20 | 
 21 | const int N = 2e5+100;
 22 | vector<int>graph[N];
 23 | int in[N];
 24 | int out[N];
 25 | int tim;
 26 | 
 27 | void dfs(int s , int p)
 28 | {
 29 |         in[s] = tim++;
 30 | 
 31 |         for(auto child : graph[s])
 32 |         {
 33 |                 if(child==p)
 34 |                 {
 35 |                         continue;
 36 |                 }
 37 |                 dfs(child,s);
 38 |         }
 39 | 
 40 |         out[s] = tim;
 41 | }
 42 | 
 43 | 
 44 | int parent[N];
 45 | ordered_set sz[N];
 46 | 
 47 | void make(int v)
 48 | {
 49 |         parent[v] = v;
 50 |         sz[v].insert(in[v]);
 51 | }
 52 | 
 53 | int Find(int v)
 54 | {
 55 |         if(v==parent[v])
 56 |         {
 57 |                 return v;
 58 |         }
 59 | 
 60 |         return parent[v] = Find(parent[v]);
 61 | }
 62 | 
 63 | void Union(int a,int b)
 64 | {
 65 |         a = Find(a);
 66 |         b = Find(b);
 67 | 
 68 |         if(a!=b)
 69 |         {
 70 |                 if(sz[a].size()<sz[b].size())
 71 |                 {
 72 |                         swap(a,b);
 73 |                 }
 74 | 
 75 |                 for(auto x : sz[b])
 76 |                 {
 77 |                         sz[a].insert(x);
 78 |                 }
 79 | 
 80 |                 parent[b] = a;
 81 |         }
 82 | }
 83 | 
 84 | 
 85 | pair<int,int> left_right_size(int u,int v)
 86 | {
 87 |         bool flag = false;
 88 |         if(in[u]>in[v]) 
 89 |         {
 90 |                 flag = true;
 91 |                 swap(u,v);
 92 |         } // u age dukbe
 93 | 
 94 |         u = Find(u);
 95 | 
 96 |         int a = sz[u].order_of_key(out[v]) - sz[u].order_of_key(in[v]);  // This represent same component e v er subtree size . ba right part er size 
 97 |         int b = sz[u].size()-a ; // this represent the component size of u or left part 
 98 | 
 99 |         if(flag)
100 |         {
101 |                 return {b,a}; // b hocche u er diker size and a hocche v er diker size 
102 |         }
103 |         else 
104 |         {
105 |                 return {a,b}; // a hocce u er diker size and b hocce v er diker size 
106 |         }
107 | 
108 | }
109 | 
110 | 
111 | int32_t main()
112 | {
113 |         ios::sync_with_stdio(0);
114 |         cin.tie(0);
115 | 
116 |         int n;
117 |         cin>>n;
118 | 
119 |         vector<array<int,4>>edges;
120 | 
121 |         set<int>s;
122 | 
123 |         for(int i=1;i<n;i++)
124 |         {
125 |                 int x,y,w;
126 |                 cin>>x>>y>>w;
127 |                 edges.push_back({i,x,y,w});
128 |                 graph[x].push_back(y);
129 |                 graph[y].push_back(x);
130 | 
131 |                 s.insert(w);
132 |         }
133 | 
134 |         dfs(1,0);
135 | 
136 |         sort(edges.begin() , edges.end() , [&](auto a, auto b){return a[3]<b[3]; });
137 | 
138 |         for(int i=1;i<=n;i++)
139 |         {
140 |                 make(i);
141 |         }
142 | 
143 |         int l = 0;
144 | 
145 |         int mx = 0;
146 |         
147 |         vector<int>ans(n+1);
148 | 
149 |         for(auto w : s)
150 |         {
151 |                 int r = l;
152 | 
153 |                 while(r+1<edges.size()  && edges[r+1][3] == w)
154 |                 {
155 |                         r++;
156 |                 }
157 | 
158 |                 for(int i = l; i<= r ; i++)
159 |                 {
160 |                         Union(edges[i][1] , edges[i][2]);
161 |                 }
162 | 
163 |                 for(int i=l;i<=r;i++)
164 |                 {
165 |                         auto take = left_right_size(edges[i][1] , edges[i][2]);
166 | 
167 |                         int temp = take.first * 2LL * take.second;
168 | 
169 |                         mx = max(temp,mx);
170 | 
171 |                         ans[edges[i][0]] = temp;  // edges[i][0] represent id no 
172 |                 }
173 | 
174 |                 l = r+1;
175 |         }
176 | 
177 | 
178 |         vector<int>res;
179 | 
180 |         for(int i=1;i<n;i++)
181 |         {
182 |                 if(mx == ans[i])
183 |                 {
184 |                         res.push_back(i);
185 |                 }
186 |         }
187 | 
188 |         cout<<mx<<" "<<res.size()<<endl;
189 | 
190 |         for(auto x : res)
191 |         {
192 |                 cout<<x<<" ";
193 |         }
194 |         cout<<endl;
195 | 
196 | 
197 |         return 0;
198 | 
199 | 
200 | 
201 | 
202 | 
203 | 
204 | }
205 | 


--------------------------------------------------------------------------------
/Dijkstra .cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | const int N = 1e5+10;
 3 | vector<pair<int,int>>graph[N];
 4 | const int inf = 1e18;
 5 | bool vis[N];
 6 | int dist[N];
 7 | 
 8 | 
 9 | void dijkstra(int ss)
10 | {
11 |         dist[ss] = 0;
12 |         priority_queue<pair<int,int> , vector<pair<int,int>> , greater<pair<int,int>> >pq;
13 |         pq.push({0,ss});
14 | 
15 |         while(!pq.empty())
16 |         {
17 | 
18 |                 int father = pq.top().second;
19 | 
20 |                  pq.pop();
21 | 
22 | 
23 |                 //This line is very important for time saving
24 |                 if(vis[father])
25 |                 {
26 | 
27 |                         continue;
28 |                 }
29 | 
30 |                 vis[father] = true;
31 | 
32 | 
33 |                 for(auto child : graph[father])
34 |                 {
35 |                         int v = child.first;
36 |                         int vw = child.second;
37 |                         if(vis[v])
38 |                         {
39 |                                 continue;
40 |                         }
41 |                         if(dist[v]>dist[father]+vw)
42 |                         {
43 |                                 dist[v] = dist[father]+vw;
44 |                                 pq.push({dist[v] , v});
45 |                         }
46 |                 }
47 |         }
48 | 
49 | 
50 | }
51 | 
52 | int32_t main()
53 | {
54 |         ios::sync_with_stdio(0);
55 |         cin.tie(0);
56 |         int n,m;
57 |         cin>>n>>m;
58 | 
59 |         for(int i=0;i<m;i++)
60 |         {
61 |                 int x,y,w;
62 |                 cin>>x>>y>>w;
63 |                 graph[x].push_back({y,w});
64 |         }
65 |         for(int i=0;i<N;i++)
66 |         {
67 |                 dist[i] = inf;
68 |         }
69 | 
70 |         dijkstra(1);
71 | 
72 |         for(int i=1;i<=n;i++)
73 |         {
74 |                 cout<<dist[i]<<" ";
75 |         }
76 |         cout<<endl;
77 | 
78 |         return 0;
79 | 
80 | 
81 | 
82 | 
83 | }
84 | 


--------------------------------------------------------------------------------
/Dynamic Programming Road Map/CSES DP.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ArfatulAsif/Competitive-programming/2461dfe21a6b2cb81d9468e7a52685a904862807/Dynamic Programming Road Map/CSES DP.PNG


--------------------------------------------------------------------------------
/Dynamic Programming Road Map/GFG Recursion and Backtracking.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ArfatulAsif/Competitive-programming/2461dfe21a6b2cb81d9468e7a52685a904862807/Dynamic Programming Road Map/GFG Recursion and Backtracking.PNG


--------------------------------------------------------------------------------
/Dynamic Programming Road Map/README.md:
--------------------------------------------------------------------------------
  1 | # Dynamic Programming Road Map
  2 | While I was surfing all over the internet on how to learn Dynamic Programming , I was quite confused . Eventually I did learn how dynamic programming works .
  3 | ```c
  4 | Yes I am gonna use the line "how dynamic programming works" 
  5 | You can never stop learning different dp technique as it is the hardest topic of all CP techniques
  6 | It takes years to master .
  7 | ```
  8 | Here , I have described a road map which I took in learning Dynamic Programming . I think this is a very good way to get into the world of dp . 
  9 | 
 10 | 
 11 | <h3> Step - 01 : Watch Abdul Bari Sir's Video on Recursion  </h3>
 12 | It is very important to have a clear idea on how different types of recursion works . And also one should have clear idea on stack memory
 13 | and how it is accessed and cleared through recursive process . You should watch BARI sir's video on recursion available on Youtube For this .</br>
 14 | 
 15 | Here is a Question for You. what happens and most importantly why happens in the following 2 codes? .
 16 | 
 17 | ```c
 18 | void print()
 19 | {
 20 |     char ch;
 21 |     cin>>ch;
 22 |     cout<<ch;
 23 |     print();
 24 | }  
 25 | ```
 26 | 
 27 | ```c
 28 | void print()
 29 | {
 30 |     char ch;
 31 |     cin>>ch;
 32 |     print();
 33 |     cout<<ch;
 34 | } 
 35 | ```
 36 | Did you learned any thing about stack memory by answering these questions ? If not then watch BARI sir's videos again .</br>
 37 | 
 38 | *You should spend atmost 2 days in this step* 
 39 |     
 40 | 
 41 | 
 42 | <h1></h1>
 43 | <h1></h1>
 44 | <h3> Step - 02 : Do 50 Easy and Medium problems on Recursion and Backtracking from GeeksForGeeks </h3>
 45 | Go to GFG and then go to topic wise practice and select topic Recursion and Backtracking .
 46 | 
 47 | <img src = "GFG Recursion and Backtracking.PNG">
 48 | Select sort by  difficulty and solve atleast 50 problems.
 49 | 
 50 | ```c
 51 | After solving them You must have an Excellent Idea on how Recursion and Stack memory works as well as Backtracking.
 52 | ```
 53 | 
 54 | </br>
 55 | 
 56 | *You should spend atmost 1 week in this step*
 57 | 
 58 | <h1></h1>
 59 | <h1></h1>
 60 | <h1></h1>
 61 | <h3> Step - 03 : Do some Text Book Works </h3>
 62 | It is time to get yourself familiarize with DP . You know , basic definations , why dp? How dp? etc . 
 63 | You should read some blogs and articles on DP  and try to get an image on dp . 
 64 | Now You should code some of the most common and well known dp problems .
 65 | 
 66 | ```c
 67 | 1. Coin change.
 68 | 2. LIS
 69 | 3. LCS
 70 | 4. Knapsack
 71 | 5. etc....
 72 | ```
 73 | 
 74 | Remember You are not learning dp through them , Just getting yourself ready .
 75 | If you are from Bangladesh , I also recommand that you follow shafayat's blog in this step.
 76 | 
 77 | <img src = "Shafayat blog.PNG">
 78 | 
 79 | *I don't really know the time laps in this step , take as long as you need.*
 80 | 
 81 | <h1></h1>
 82 | <h1></h1>
 83 | 
 84 | <h3> Step - 04 : Solving From Atcoder Educational DP Contest .</h3>
 85 | 
 86 | ```c
 87 | https://atcoder.jp/contests/dp
 88 | ```
 89 | 
 90 | Almost all recent CP coders I know had started  their dp jouney from this library. 
 91 | You should solve as many as you can . If you get stuck , watch a video of Errichto From the link where he
 92 | has explained solution of all the problems.
 93 | 
 94 | ```c
 95 | https://www.youtube.com/watch?v=FAQxdm0bTaw
 96 | ```
 97 | Now you should turn to CSES dp section . And try to solve as many as you can . If you get stuck , don't waste much time , watch the solution and move on.
 98 | <img src = "CSES DP.PNG">
 99 | 
100 | ```c
101 | After this step you should have abstruct idea on how dp works . It is time to catagorize your approach 
102 | on solving traditional dp problems . Move on to next step .
103 | ```
104 | </br>
105 | 
106 | *You should spend 2 weeks in this step.*
107 | 
108 | <h1></h1>
109 | <h1></h1>
110 | 
111 | <h3> Step - 05 : Catagorizing your approach on solving traditional dp problems </h3>
112 |  Follow the link . You will reach a leetcode article . Follow every details of it blindly , trust me ...
113 |  
114 |   ```c
115 |   https://leetcode.com/discuss/general-discussion/458695/dynamic-programming-patterns#Merging-Intervals
116 |   ```
117 |   
118 |   <img src = "leetcode dp.PNG">
119 | 
120 | ```c
121 | Follow it blindly , every last details of it . Trust Me 
122 | ```
123 | 
124 | Remember to focus on Recursive process rather than iterative . Cause that way you would be able to transform a problem into recursive relation and then apply memoization . After a while you will realize that recursive process is much easier than iterative(Or may be).
125 | 
126 | </br>
127 | 
128 | 
129 | *You should spend around 2 weeks in this step*
130 | 
131 | 
132 | <h1></h1>
133 | <h1></h1>
134 | 
135 | <h3>Step -06 : Time to do Your own research and defining your own approch on various dp problems </h3>
136 | You should start solving dp problems from codeforces . Remember one thing , most of the problems under 1700 rated can be solved 
137 | using greedy even though they might have dp as tag .</br> So don't try dp on them .(or try , I think its quite your own decision )
138 | The reason I said so is because , you have recently learned dp and you will try dp apprach even on basic greedy problems and make it 
139 | much difficult. However this should pass away over time and maturity.
140 | </br>
141 | </br>
142 | 
143 | 
144 | *I don't know the time laps in this step , take as long as you need*
145 | 
146 | 
147 | <h1></h1>
148 | <h1></h1>
149 | <h3> Step -07 : Learn Bitmask dp </h3>
150 | 
151 | Although it is a quite advanced technique . But I think You should learn it right away . Allmost all the problems which has
152 | n<20 as constrain is bitmask dp . 
153 | I thought the following article was very helpful.
154 | 
155 | ```c
156 | https://www.hackerearth.com/practice/algorithms/dynamic-programming/bit-masking/tutorial/
157 | ```
158 | <img src = "hackearth dp.PNG">
159 | 
160 | <h1></h1>
161 | <h1></h1>
162 | <h1></h1>
163 | <h1></h1>
164 | <h1></h1>
165 | 
166 | <h2>Step - 08 : The Most Important Step .</h2>
167 | I am by no means expert on dp , Far from it actully .</br>
168 | But I do know How it works while my journey through this road map . I can only hope that my writting was helpful to you 
169 | ..
170 | If it was even a little bit helpful . 
171 | 
172 | ```c
173 | Please consider loggin in to your github and giving me a Star on my Competitive-Programming Repository. 
174 | ```
175 | 
176 | Take care BYE .
177 | 
178 | 
179 | 
180 | 
181 | 


--------------------------------------------------------------------------------
/Dynamic Programming Road Map/Shafayat blog.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ArfatulAsif/Competitive-programming/2461dfe21a6b2cb81d9468e7a52685a904862807/Dynamic Programming Road Map/Shafayat blog.PNG


--------------------------------------------------------------------------------
/Dynamic Programming Road Map/hackearth dp.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ArfatulAsif/Competitive-programming/2461dfe21a6b2cb81d9468e7a52685a904862807/Dynamic Programming Road Map/hackearth dp.PNG


--------------------------------------------------------------------------------
/Dynamic Programming Road Map/leetcode dp.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ArfatulAsif/Competitive-programming/2461dfe21a6b2cb81d9468e7a52685a904862807/Dynamic Programming Road Map/leetcode dp.PNG


--------------------------------------------------------------------------------
/Euler Path_Circuit.cpp:
--------------------------------------------------------------------------------
  1 | Euler Path/Circuit : Visit all edges excatly once.
  2 | 
  3 | Hamilton Path/Circuit: Visit all vertex excatly once.
  4 | 
  5 | [Finding hamilton path/circuit is an NP - Complete problem]
  6 | 
  7 | Euler Path/Circuit Undirected:
  8 | 1.Euler Circuit: All vertices must have an even degree. 
  9 | 2.Euler Path: Exactly two vertices must have an odd degree (the path starts at one and ends at the other).
 10 | 
 11 | 
 12 | Euler Path/Circuit Directed:
 13 | 1. Euler Circuit: The graph must be strongly connected, and for every vertex, the in-degree must equal the out-degree.
 14 | 
 15 | 2. Euler Path: The graph must be connected, Exactly one vertex must have out-degree - in-degree = 1 and exactly one vertex must have in-degree - out-degree = 1. All other vertices must have in-degree = out-degree.
 16 | 
 17 | 
 18 | 
 19 | 
 20 | Hierholzer's algorithm For Undirected:
 21 | 
 22 | 
 23 | // https://www.youtube.com/watch?v=8MpoO2zA2l4  [This video is for directed. But just remember that, instead of removing outdegree by 1, we will remove an edge. See the implementation of how we remove an edge.
 24 | // Hierholzer's algorithm
 25 | // Euler path/circuit in a undirected graph
 26 | 
 27 | 
 28 | 
 29 | 	
 30 | // https://cses.fi/problemset/task/1691
 31 | 	
 32 | const int N = 2e5+100;
 33 | set<int>graph[N];
 34 | int degree[N];
 35 | vector<int>path;
 36 | bool vis[N];
 37 | 
 38 | void modified_dfs(int s)
 39 | {
 40 | 
 41 | 	while(!graph[s].empty()) // this is just to make sure if out[s], or out_degree of s becomes 0, we add it to path[] or solution, like stated in the heirhozler algoritm.
 42 | 	{
 43 | 		int v = *graph[s].begin();  // For undirected graph, we consider each edge as an out_edge, so we remove it from count, so that we can get out[s] = 0 and add s to path
 44 | 
 45 | 		graph[s].erase(v);  // this is removing [s - v] edge from count
 46 | 		graph[v].erase(s);  // this is removing [s - v] edge from count
 47 | 
 48 | 		modified_dfs(v);
 49 | 	}
 50 | 
 51 | 	path.push_back(s);
 52 | 
 53 | 
 54 | }
 55 |       
 56 | int32_t main()
 57 | {
 58 |         ios::sync_with_stdio(0);
 59 |         cin.tie(0);
 60 | 
 61 |         int n,m;
 62 |         cin>>n>>m;
 63 | 
 64 |         for(int i=0;i<m;i++)
 65 |         {
 66 |         	int a,b;
 67 |         	cin>>a>>b;
 68 |         	graph[a].insert(b);
 69 |         	graph[b].insert(a);
 70 |         	degree[a]++;
 71 |         	degree[b]++;
 72 |         }
 73 | 
 74 |         bool ok = true;
 75 | 
 76 |         for(int i=1;i<=n;i++)
 77 |         {
 78 |         	if(degree[i]%2!=0)
 79 |         	{
 80 |         		ok = false;
 81 |         		break;
 82 |         	}
 83 |         }
 84 | 
 85 |         if(!ok)
 86 |         {
 87 |         	cout<<"IMPOSSIBLE"<<endl;
 88 |         	return 0;
 89 |         }
 90 | 
 91 | 
 92 |         
 93 |         modified_dfs(1); // As we ensured it is euler circuit, that means if it starts from 1, it will end at 1.
 94 | 
 95 |         // For euler path, we need to find start_vertex and end_vertex (two vertex with odd degree)
 96 | 
 97 |         if(path.size()!= m+1)
 98 |         {
 99 |         	cout<<"IMPOSSIBLE"<<endl;
100 |         	return 0;
101 |         }
102 | 
103 |         reverse(path.begin(),path.end());
104 | 
105 |         for(auto x : path)
106 |         {
107 |         	cout<<x<<" ";
108 |         }
109 |         cout<<endl;
110 | 
111 | 
112 | 
113 | 
114 | 
115 | }
116 | 
117 | 
118 | 
119 | 
120 | Hierholzer's algorithm For Directed:
121 | 
122 |  
123 | // https://www.youtube.com/watch?v=8MpoO2zA2l4
124 | // Hierholzer's algorithm
125 | // Euler path in a directed graph
126 | 
127 | 
128 | https://cses.fi/problemset/task/1693/
129 | 
130 | const int N = 2e5+100;
131 | vector<int>graph[N];
132 | int in[N];
133 | int out[N];
134 | vector<int>path;
135 | bool vis[N];
136 |  
137 | void modified_dfs(int s)
138 | {
139 |  
140 | 	while(!graph[s].empty()) // this is just to make sure if out[s], or out_degree of s becomes 0, we add it to path[] or solution, like stated in the heirhozler algoritm
141 | 	{
142 | 		int v = graph[s].back();
143 | 		graph[s].pop_back();
144 | 		modified_dfs(v);
145 | 	}
146 |  
147 | 	path.push_back(s);
148 |  
149 |  
150 | }
151 |       
152 | int32_t main()
153 | {
154 |         ios::sync_with_stdio(0);
155 |         cin.tie(0);
156 |  
157 |         int n,m;
158 |         cin>>n>>m;
159 |  
160 |         for(int i=0;i<m;i++)
161 |         {
162 |         	int a,b;
163 |         	cin>>a>>b;
164 |         	graph[a].push_back(b);
165 |         	out[a]++;
166 |         	in[b]++;
167 |         }
168 |  
169 |         bool ok = true;
170 |  
171 |         for(int i=2;i<n;i++)
172 |         {
173 |         	if(in[i]!=out[i])
174 |         	{
175 |         		ok = false;
176 |         		break;
177 |         	}
178 |         }
179 |  
180 |         if(!ok)
181 |         {
182 |         	cout<<"IMPOSSIBLE"<<endl;
183 |         	return 0;
184 |         }
185 |  
186 |  
187 |         if((out[1]-in[1]) != 1 && (in[n]-out[n]) != 1) // For 1, out - in = 1 and For n, in - out = 1. This will ensure that euler path will exits that starts at 1 and ends n. Note: If euler circuit exists, this means that it will stats and ends at the same node, so it is not going to work for 1 to n.
188 |         {
189 |         	cout<<"IMPOSSIBLE"<<endl;
190 |         	return 0;
191 |         }
192 |  
193 |         modified_dfs(1);
194 |  
195 |         if(path.size()!= m+1)
196 |         {
197 |         	cout<<"IMPOSSIBLE"<<endl;
198 |         	return 0;
199 |         }
200 |  
201 |         reverse(path.begin(),path.end());
202 |  
203 |         for(auto x : path)
204 |         {
205 |         	cout<<x<<" ";
206 |         }
207 |         cout<<endl;
208 |  
209 | }
210 | 


--------------------------------------------------------------------------------
/Euler Tour Improved (FOR USE).cpp:
--------------------------------------------------------------------------------
  1 | https://codeforces.com/gym/102625/problem/H
  2 | 
  3 | //Intermediary
  4 | //Young kid on the block
  5 | //AIAsif try's Continuing the journey
  6 | #include<bits/stdc++.h>
  7 | #include <ext/pb_ds/assoc_container.hpp>
  8 | #include <ext/pb_ds/tree_policy.hpp>
  9 | using namespace std;
 10 | using namespace __gnu_pbds;
 11 | #define endl "\n"
 12 | #define int long long int
 13 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
 14 | 
 15 | const int N = 1e5+100;
 16 | vector<int>graph[N];
 17 | bool vis[N];
 18 | int vis_time_vertex[N];
 19 | int in[N];
 20 | int out[N];
 21 | int tim;
 22 | 
 23 | void dfs(int s)
 24 | {
 25 |         vis[s] = true;
 26 |         in[s] = ++tim;
 27 |         vis_time_vertex[tim] = s; // ET array  [Instead for 2*n , IT runs for O(n) time]
 28 |         
 29 |         for(auto child : graph[s])
 30 |         {
 31 |                 if(vis[child])
 32 |                 {
 33 |                         continue;
 34 |                 }
 35 |                 dfs(child);
 36 |         }
 37 |         out[s] = tim;
 38 | }
 39 | 
 40 | 
 41 | int Tree[4*N];
 42 | 
 43 | void update(int node ,int lo ,int hi ,int pos ,int val)
 44 | {
 45 |         if(lo==hi)
 46 |         {
 47 |                 Tree[node] = val;
 48 |                 return;
 49 |         }
 50 | 
 51 |         int mid = (lo+hi)>>1;
 52 | 
 53 |         if(pos<=mid)
 54 |         {
 55 |                 update(node*2 , lo, mid , pos,val);
 56 |         }
 57 |         else 
 58 |         {
 59 |                 update(node*2+1 , mid+1 , hi , pos ,val);
 60 |         }
 61 | 
 62 |         Tree[node] = max(Tree[node*2] , Tree[node*2+1]);
 63 | }
 64 | 
 65 | 
 66 | int query(int node, int lo ,int hi,int i,int j)
 67 | {
 68 |         if(hi<i || lo>j)
 69 |         {
 70 |                 return -1;
 71 |         }
 72 |         
 73 |         if(lo>=i && hi <= j)
 74 |         {
 75 |                 return Tree[node];
 76 |         }
 77 | 
 78 |         int mid = (lo+hi)>>1;
 79 |         int x = query(node*2 , lo , mid , i , j);
 80 |         int y = query(node*2+1 , mid+1 , hi, i, j);
 81 | 
 82 |         return max(x,y);
 83 | }
 84 | 
 85 | int32_t main()
 86 | {
 87 |         ios::sync_with_stdio(0);
 88 |         cin.tie(0);
 89 | 
 90 |         int n,q;
 91 |         cin>>n>>q;
 92 |         vector<int>v;
 93 | 
 94 |         for(int i=0;i<n;i++)
 95 |         {
 96 |                 int a;
 97 |                 cin>>a;
 98 |                 v.push_back(a);
 99 |         }
100 | 
101 |         for(int i=0;i<n-1;i++)
102 |         {
103 |                 int x,y;
104 |                 cin>>x>>y;
105 |                 graph[x].push_back(y);
106 |                 graph[y].push_back(x);
107 |         }
108 | 
109 | 
110 |         dfs(1);
111 | 
112 |         for(int i=1;i<=n;i++)
113 |         {
114 |                 update(1,1,n,i , v[vis_time_vertex[i]-1]);
115 |         }
116 | 
117 |         while(q--)
118 |         {
119 |                 int tt;
120 |                 cin>>tt;
121 |                 int node1;
122 |                 cin>>node1;
123 |                 vector<pair<int,int>>p;
124 | 
125 |                 bool flag = false;
126 | 
127 |                 for(int i=0;i<tt-1;i++)
128 |                 {
129 |                         int v;
130 |                         cin>>v;
131 | 
132 |                         if(in[v]<in[node1] && out[v] >= out[node1])
133 |                         {
134 |                                 flag = true;
135 |                         }
136 | 
137 |                         if(in[v]>in[node1]  && out[v] <= out[node1] )
138 |                         {
139 |                                  p.push_back({in[v] , out[v]});
140 |                         }
141 |                 }
142 | 
143 |                 if(flag)
144 |                 {
145 |                         cout<<-1<<endl;
146 |                         continue;
147 |                 }
148 | 
149 |                 sort(p.begin() , p.end());
150 |                 int mx = -1;
151 | 
152 |                 int cur = in[node1];
153 | 
154 |                 for(int i=0;i<p.size();i++)
155 |                 {
156 |                         mx = max(mx , query(1,1,n, cur+1 ,p[i].first-1));
157 |                         
158 |                         cur = max(cur,p[i].second);
159 |                 }
160 | 
161 |                 mx = max(mx , query(1,1,n,cur+1 , out[node1]));
162 | 
163 | 
164 |                 cout<<mx<<endl;
165 | 
166 |                 
167 |         }
168 | 
169 | 
170 | 
171 | }
172 | 


--------------------------------------------------------------------------------
/FLOW1 - Max Flow (Ford-Fulkerson) O(E * max flow).cpp:
--------------------------------------------------------------------------------
  1 | // Ford-Fulkerson:
  2 | // Single source, single sink
  3 | // Requires integer capacities
  4 | // O (E * max flow)
  5 | // This is not feasible, as the value of the max flow can be very large, such as 1e18.
  6 | 
  7 | // For understanding the complexity checkout the: Max Flow (Edmonds-Karp) O(V * E^2).cpp
  8 | 
  9 | 
 10 | 
 11 | // Algorithm : In each iteration Find an augmenting path using DFS, then do flow augmentation through its edges.  [Flow augmentation = reduce forward edges residual capacity, increase reverse edges residual capacity]
 12 | 
 13 | const int N = 1000;
 14 | 
 15 | struct edge
 16 | {
 17 | 	int v; 			// to
 18 | 	int rev; 		//Reverse edge index in graph[v]
 19 | 	int residual_capacity;  // Residual capacity of the edge
 20 | 	int edge_id;            // Edge ID (optional, if needed)
 21 | };
 22 | 
 23 | vector<edge>graph[N];
 24 | 
 25 | // This is for directed, for undirected make sure to include edges in both direction  addEdge(u,v,c) and addEdge(v,u,c).
 26 | void addEdge(int u, int v, int capacity, int id = -1)
 27 | {
 28 | 	graph[u].push_back({v, (int)graph[v].size(), capacity, id});
 29 | 	graph[v].push_back({u, (int)graph[u].size()-1, 0, -id});
 30 | }
 31 | 
 32 | 
 33 | int dfs(int u, int sink, int flow, vector<bool> &visited)
 34 | {
 35 | 	if(u == sink)
 36 | 	{
 37 | 		return flow;
 38 | 	}
 39 | 
 40 | 	visited[u] = true;
 41 | 
 42 | 	for(auto &[v, rev, residual_capacity, id] : graph[u])
 43 | 	{
 44 | 		if(visited[v] || residual_capacity == 0)
 45 | 		{
 46 | 			continue;
 47 | 		}
 48 | 
 49 | 		int pathFlow = min(flow, residual_capacity);
 50 | 		int pushedFlow = dfs(v, sink, pathFlow, visited);
 51 | 
 52 | 		if(pushedFlow > 0)
 53 | 		{
 54 | 			residual_capacity -= pushedFlow;
 55 | 			graph[v][rev].residual_capacity += pushedFlow;
 56 | 
 57 | 			return pushedFlow; // we need to find only one augmenting path, so we return after any children who is giving pushFlow > 0
 58 | 		}
 59 | 
 60 | 	}
 61 | 
 62 | 	return 0; // no augmenting path found
 63 | }
 64 | 
 65 | 
 66 | int FordFulkerson(int source ,int sink)
 67 | {
 68 | 	int maxFlow = 0;
 69 | 	vector<bool>visited(N,false);
 70 | 
 71 | 	while(true)
 72 | 	{
 73 | 		fill(visited.begin(),visited.end(),false);
 74 | 
 75 | 		int flow = dfs(source, sink, INT_MAX, visited);
 76 | 
 77 | 		if(flow == 0) // no augmenting path found
 78 | 		{
 79 | 			break; 
 80 | 		}
 81 | 
 82 | 		maxFlow += flow;
 83 | 	}
 84 | 
 85 | 	return maxFlow;
 86 | }
 87 | 
 88 | 
 89 | int32_t main()
 90 | {
 91 |         ios::sync_with_stdio(0);
 92 |         cin.tie(0);
 93 | 
 94 |         int n,m;
 95 |         cin>>n>>m;
 96 | 
 97 |         for(int i=0;i<m;i++)
 98 |         {
 99 |         	int u,v,c;
100 |         	cin>>u>>v>>c;
101 |         	addEdge(u,v,c);
102 |         }
103 | 
104 |         cout<<FordFulkerson(1,n)<<endl;
105 | 
106 | }
107 | 
108 | // https://cses.fi/problemset/task/1694/
109 | 


--------------------------------------------------------------------------------
/FLOW2 - Max Flow (Edmonds-Karp) O(V * E^2).cpp:
--------------------------------------------------------------------------------
  1 | // This is essentailly Ford-Fulkerson Using BFS
  2 | 
  3 | // In just Ford-Fulkerson with DFS, the time complexity is O(E * max_flow), because DFS is not guaranteed to find the shortest augmenting path. 
  4 | // It could take a very long path through the network, reducing residual flow very slowly. 
  5 | // For instance, if DFS always explores the deepest possible path (even if that path is long or inefficient), the number of iterations could become very large.
  6 | // That's why the total number of augmenting paths to grow significantly, and is not proportional to O(E). In worse case it is proportional to O(max flow).
  7 | // So time complexity becomes, (number of augmenting paths * complexity in each DFS) = O( max flow * (V+E)), how ever normally E is dominant, so O( max_flow * E) = O(E*max_flow) 
  8 | 
  9 | 
 10 | // In Ford-Fulkerson with BFS or Edmonds-Karp algorithm, the time complexity is O(V * E^2).
 11 | // Because BFS guarantees that we always find a "short" augmenting path with respect to the number of edges, which leads to a more efficient increase in flow.
 12 | // So number of augmenting path becomes proportional to O(E).
 13 | // So time complexity becomes, (number of augmenting paths * complexity in each BFS) = O( E * (V+E)) = O( EV + E^2), as normally E is dominant, this is considered O(V*E^2)
 14 | 
 15 | 
 16 | const int N = 1000;
 17 | 
 18 | struct edge
 19 | {
 20 | 	int v; 			// to
 21 | 	int rev; 		//Reverse edge index in graph[v]
 22 | 	int residual_capacity;  // Residual capacity of the edge
 23 | 	int edge_id;            // Edge ID (optional, if needed)
 24 | };
 25 | 
 26 | vector<edge>graph[N];
 27 | 
 28 | 
 29 | // This is for directed, for undirected make sure to include edges in both direction  addEdge(u,v,c) and addEdge(v,u,c).
 30 | void addEdge(int u, int v, int capacity, int id = -1)
 31 | {
 32 | 	graph[u].push_back({v, (int)graph[v].size(), capacity, id});
 33 | 	graph[v].push_back({u, (int)graph[u].size()-1, 0, -id});
 34 | }
 35 | 
 36 | int bfs(int source, int sink, vector<pair<int,int>> &parent)
 37 | {
 38 | 	for(int i=0;i<N;i++)
 39 | 	{
 40 | 		parent[i] = {-1, -1};
 41 | 	}
 42 | 
 43 | 	vector<bool>visited(N, false);
 44 | 
 45 | 	visited[source] = true;
 46 | 	queue<int>q;
 47 | 	q.push(source);
 48 | 
 49 | 	int flow = INT_MAX;
 50 | 
 51 | 	while(!q.empty())
 52 | 	{
 53 | 		int u = q.front();
 54 | 		q.pop();
 55 | 
 56 | 		for(auto &[v, rev, residual_capacity, id] : graph[u])
 57 | 		{
 58 | 			if(visited[v] || residual_capacity == 0)
 59 | 			{
 60 | 				continue;
 61 | 			}
 62 | 
 63 | 			flow = min(flow, residual_capacity);
 64 | 
 65 | 			parent[v] = {u,rev};  // rev contains index of u in graph[v]
 66 | 			
 67 | 			visited[v] = true;
 68 | 
 69 | 			if(v == sink)
 70 | 			{
 71 | 				return flow;
 72 | 			}
 73 | 
 74 | 			q.push(v);
 75 | 
 76 | 
 77 | 
 78 | 		}
 79 | 	}
 80 | 
 81 | 	return 0; // no augmenting path
 82 | }
 83 | 
 84 | 
 85 | int Edmonds_Karp(int source, int sink)
 86 | {
 87 | 	int max_flow = 0;
 88 | 
 89 | 	vector<pair<int,int>>parent(N, {-1,-1});  // parent[v] = {u, rev}, where rev contains index of u in graph[v]
 90 | 
 91 | 	while(true)
 92 | 	{
 93 | 		int flow = bfs(source, sink, parent);
 94 | 
 95 | 		if(flow == 0)
 96 | 		{
 97 | 			break;
 98 | 		}
 99 | 
100 | 		max_flow += flow;
101 | 
102 | 		int v = sink;
103 | 
104 | 		while(v != source)
105 | 		{
106 | 			int u = parent[v].first;
107 | 			int rev = parent[v].second;
108 | 
109 | 			graph[v][rev].residual_capacity += flow;
110 | 			graph[u][graph[v][rev].rev].residual_capacity -= flow;
111 | 
112 | 			v = parent[v].first;
113 | 		}
114 | 	}
115 | 
116 | 	return max_flow;	
117 | }
118 | 
119 | 
120 |       
121 | int32_t main()
122 | {
123 |         ios::sync_with_stdio(0);
124 |         cin.tie(0);
125 | 
126 |         int n,m;
127 |         cin>>n>>m;
128 | 
129 |         for(int i=0;i<m;i++)
130 |         {
131 |         	int u,v,w;
132 |         	cin>>u>>v>>w;
133 | 
134 |         	addEdge(u,v,w);
135 |         }
136 | 
137 |         cout<<Edmonds_Karp(1,n)<<endl;
138 | 
139 | }
140 | // https://cses.fi/problemset/task/1694/
141 | 


--------------------------------------------------------------------------------
/FLOW3 - Max Flow (for general use) (Dinic's algorithm) O(V^2 * E).cpp:
--------------------------------------------------------------------------------
  1 | // Use this code for finding max flow
  2 | // The time complexity is O(V^2 * E). Which is most practicall, as normally number of vertices V are less than edges.
  3 | 
  4 | // Using a BFS to build a level graph, then iterate over it multiple times using DFS. and repeat it (one BFS, multiple DFS).
  5 | // Level Graphs and Blocking Flows: By focusing only on augmenting paths in the current level graph , Dinic minimizes redundant or unnecessary path exploration. This reduces the total number of augmentations compared to Edmonds-Karp, which may repeatedly explore longer paths.
  6 | // Once a blocking flow is found, it saturates (residual capacity = 0) multiple paths simultaneously, reducing future work.
  7 | // That's why it is more efficient than Edmonds-Karp.
  8 | 
  9 | 
 10 | const int N = 1000;
 11 | 
 12 | struct edge
 13 | {
 14 | 	int v;                  // to
 15 | 	int rev;                // Reverse edge index in graph[v]
 16 | 	int residual_capacity;  // Residual capacity of the edge
 17 | 	int edge_id;            // Edge ID (optional, if needed)
 18 | };
 19 | 
 20 | vector<edge> graph[N];
 21 | int level[N];
 22 | int done[N]; //  done[u] array is to keep track of which edges have already been tried for a given node during a DFS call. This ensures that we don't revisit the same edges unnecessarily and speeds up the process.
 23 | 
 24 | 
 25 | // This is for directed, for undirected make sure to include edges in both direction  addEdge(u,v,c) and addEdge(v,u,c).
 26 | void addEdge(int u, int v, int capacity, int id = -1)
 27 | {
 28 | 	graph[u].push_back({v, (int)graph[v].size(), capacity, id});
 29 | 	graph[v].push_back({u, (int)graph[u].size()-1, 0, -id});
 30 | }
 31 | 
 32 | 
 33 | // BFS to build Level Graph
 34 | bool bfs(int source, int sink)
 35 | {
 36 | 	fill(level, level+N, -1);
 37 | 	level[source] = 0;
 38 | 	queue<int>q;
 39 | 	q.push(source);
 40 | 
 41 | 	while(!q.empty())
 42 | 	{
 43 | 		int u = q.front();
 44 | 		q.pop();
 45 | 
 46 | 		for(auto &[v, rev, residual_capacity, id]: graph[u])
 47 | 		{
 48 | 			if(level[v] != -1 || residual_capacity == 0)
 49 | 			{
 50 | 				continue;
 51 | 			}
 52 | 
 53 | 			level[v] = level[u] + 1;
 54 | 			q.push(v);
 55 | 		}
 56 | 	}
 57 | 
 58 | 	return level[sink] != -1;  // sink is reachable = true
 59 | }
 60 | 
 61 | 
 62 | 
 63 | // DFS to send flow along augmenting paths
 64 | int dfs(int u, int sink, int flow)
 65 | {
 66 | 	if(u == sink)
 67 | 	{
 68 | 		return flow;
 69 | 	}
 70 | 
 71 | 	for(; done[u] < graph[u].size(); done[u]++)
 72 | 	{
 73 | 		auto &[v, rev, residual_capacity, id] = graph[u][done[u]];
 74 | 
 75 | 		if(level[v] == level[u]+1 && residual_capacity > 0) // only traversing trough level graph
 76 | 		{
 77 | 			int pathFlow = min(flow, residual_capacity);
 78 | 			int pushedFlow = dfs(v, sink, pathFlow);
 79 | 
 80 | 			if(pushedFlow > 0)
 81 | 			{
 82 | 				residual_capacity -= pushedFlow;
 83 | 				graph[v][rev].residual_capacity += pushedFlow;
 84 | 
 85 | 				return pushedFlow;
 86 | 			}
 87 | 		}
 88 | 	}
 89 | 
 90 | 	return 0;
 91 | }
 92 | 
 93 | 
 94 | int Dinic(int source, int sink)
 95 | {
 96 | 	int max_flow = 0;
 97 | 
 98 | 	while(bfs(source, sink)) // build the level graph
 99 | 	{
100 | 		fill(done, done+N, 0);
101 | 
102 | 		while(true)  // traverse on the same level graph multiple time, which is efficiant than Edmonds-Karp. As we are blocking multiple edges(residual_capacity = 0) using the same level graph.
103 | 		{
104 | 			int flow = dfs(source, sink, inf);
105 | 
106 | 			if(flow == 0)
107 | 			{
108 | 				break;
109 | 			}
110 | 
111 | 			max_flow += flow;
112 | 		}
113 | 
114 | 	}
115 | 
116 | 	return max_flow;
117 | }
118 | 
119 |       
120 | int32_t main()
121 | {
122 |         ios::sync_with_stdio(0);
123 |         cin.tie(0);
124 | 
125 |         int n,m;
126 |         cin>>n>>m;
127 |         for(int i=0;i<m;i++)
128 |         {
129 |         	int u,v,c;
130 |         	cin>>u>>v>>c;
131 |         	addEdge(u,v,c);
132 |         }
133 | 
134 |         cout<<Dinic(1,n)<<endl;
135 | 
136 | }
137 | 


--------------------------------------------------------------------------------
/FLOW4 - Minimum Cut.cpp:
--------------------------------------------------------------------------------
  1 | // Dinic + Additional BFS to Find Minimum Cut edges
  2 | 
  3 | const int N = 1000;
  4 | 
  5 | struct edge
  6 | {
  7 | 	int v;                  // to
  8 | 	int rev;                // Reverse edge index in graph[v]
  9 | 	int residual_capacity;  // Residual capacity of the edge
 10 | 	int edge_id;            // Edge ID (optional, if needed)
 11 | };
 12 | 
 13 | vector<edge> graph[N];
 14 | int level[N];
 15 | int done[N]; //  done[u] array is to keep track of which edges have already been tried for a given node during a DFS call. This ensures that we don't revisit the same edges unnecessarily and speeds up the process.
 16 | 
 17 | 
 18 | // This is for directed, for undirected make sure to include edges in both direction  addEdge(u,v,c) and addEdge(v,u,c).
 19 | void addEdge(int u, int v, int capacity, int id = -1)
 20 | {
 21 | 	graph[u].push_back({v, (int)graph[v].size(), capacity, id});
 22 | 	graph[v].push_back({u, (int)graph[u].size()-1, 0, -id});
 23 | }
 24 | 
 25 | 
 26 | // BFS to build Level Graph
 27 | bool bfs(int source, int sink)
 28 | {
 29 | 	fill(level, level+N, -1);
 30 | 	level[source] = 0;
 31 | 	queue<int>q;
 32 | 	q.push(source);
 33 | 
 34 | 	while(!q.empty())
 35 | 	{
 36 | 		int u = q.front();
 37 | 		q.pop();
 38 | 
 39 | 		for(auto &[v, rev, residual_capacity, id]: graph[u])
 40 | 		{
 41 | 			if(level[v] != -1 || residual_capacity == 0)
 42 | 			{
 43 | 				continue;
 44 | 			}
 45 | 
 46 | 			level[v] = level[u] + 1;
 47 | 			q.push(v);
 48 | 		}
 49 | 	}
 50 | 
 51 | 	return level[sink] != -1;  // sink is reachable = true
 52 | }
 53 | 
 54 | 
 55 | // DFS to send flow along augmenting paths
 56 | int dfs(int u, int sink, int flow)
 57 | {
 58 | 	if(u == sink)
 59 | 	{
 60 | 		return flow;
 61 | 	}
 62 | 
 63 | 	for(; done[u] < graph[u].size(); done[u]++)
 64 | 	{
 65 | 		auto &[v, rev, residual_capacity, id] = graph[u][done[u]];
 66 | 
 67 | 		if(level[v] == level[u]+1 && residual_capacity > 0) // only traversing trough level graph
 68 | 		{
 69 | 			int pathFlow = min(flow, residual_capacity);
 70 | 			int pushedFlow = dfs(v, sink, pathFlow);
 71 | 
 72 | 			if(pushedFlow > 0)
 73 | 			{
 74 | 				residual_capacity -= pushedFlow;
 75 | 				graph[v][rev].residual_capacity += pushedFlow;
 76 | 
 77 | 				return pushedFlow;
 78 | 			}
 79 | 		}
 80 | 	}
 81 | 
 82 | 	return 0;
 83 | }
 84 | 
 85 | 
 86 | int Dinic(int source, int sink)
 87 | {
 88 | 	int max_flow = 0;
 89 | 
 90 | 	while(bfs(source, sink)) // build the level graph
 91 | 	{
 92 | 		fill(done, done+N, 0);
 93 | 
 94 | 		while(true)  // traverse on the same level graph multiple time, which is efficiant than Edmonds-Karp. As we are blocking multiple edges(residual_capacity = 0) using the same level graph.
 95 | 		{
 96 | 			int flow = dfs(source, sink, inf);
 97 | 
 98 | 			if(flow == 0)
 99 | 			{
100 | 				break;
101 | 			}
102 | 
103 | 			max_flow += flow;
104 | 		}
105 | 
106 | 	}
107 | 
108 | 	return max_flow;
109 | }
110 | 
111 | 
112 | 
113 | // For minimum cut, edges on minimum cut will have residual capacity = 0.
114 | // So if we run a BFS from source and reach vertices through edges that still have residual capacity > 0. We will eventually stop after finding residual capacity = 0 edges.
115 | // Now visited ones are Vs and unvisited once are Vt in a minimum cut X = (Vs, Vt), where Vs includes source and Vt includes sink.
116 | 
117 | 
118 | // Finds all reachable nodes from the source in the residual graph after dinic is called
119 | void FindReachable_BFS(int source, vector<bool> &visited)
120 | {
121 | 	queue<int>q;
122 | 	q.push(source);
123 | 	visited[source] = true;
124 | 
125 | 	while(!q.empty())
126 | 	{
127 | 		int u = q.front();
128 | 		q.pop();
129 | 
130 | 		for(auto &[v, rev, residual_capacity, id]: graph[u])
131 | 		{
132 | 			if(visited[v] == true || residual_capacity == 0)
133 | 			{
134 | 				continue;
135 | 			}
136 | 
137 | 			visited[v] = true;
138 | 			q.push(v);
139 | 		}
140 | 	}
141 | }
142 | 
143 | vector<pair<int,int>> FindMinCut(int source, int sink)
144 | {
145 | 	vector<bool> visited(N, false);
146 | 
147 | 	FindReachable_BFS(source, visited);
148 | 
149 | 	vector<pair<int,int>> Edges;
150 | 
151 | 	for(int u=1; u < N; u++)
152 | 	{
153 | 		if(visited[u])
154 | 		{
155 | 			for(auto &[v, rev, residual_capacity, id]: graph[u])
156 | 			{
157 | 				if(visited[v] == false && residual_capacity == 0)
158 | 				{
159 | 					Edges.push_back({u,v});
160 | 				}
161 | 			}
162 | 		}
163 | 	}
164 | 
165 | 	return Edges;
166 | }
167 | 
168 | 
169 |       
170 | int32_t main()
171 | {
172 |         ios::sync_with_stdio(0);
173 |         cin.tie(0);
174 | 
175 |         int n,m;
176 |         cin>>n>>m;
177 | 
178 |         map<pair<int,int>, bool> mp;
179 | 
180 |         for(int i=0;i<m;i++)
181 |         {
182 |         	int u,v;
183 |         	cin>>u>>v;
184 | 
185 |         	mp[{u,v}] = true;
186 | 
187 |         	addEdge(u,v,1);
188 |         	addEdge(v,u,1);  // the problem is for undirected
189 |         }
190 | 
191 |         cout<<Dinic(1,n)<<endl;
192 | 
193 |         vector<pair<int,int>> Cut_edges = FindMinCut(1, n); 
194 | 
195 |         
196 |         set<pair<int,int>>ans; // Since this is a undirected flow network, we need to remove all the duplicates , and only consider edges like input
197 | 
198 |         for(auto x : Cut_edges)
199 |         {
200 |         	if(mp[{x.first, x.second}])
201 |         	{
202 |         		ans.insert({x.first, x.second});
203 |         	}
204 |         	else 
205 |         	{
206 |         		ans.insert({x.second, x.first});
207 |         	}
208 |         }
209 | 
210 | 
211 |         for(auto x : ans)
212 |         {
213 |         	cout<<x.first<<" "<<x.second<<endl;
214 |         }
215 | 
216 | 
217 | }
218 | 
219 | // https://cses.fi/problemset/task/1695/
220 | 


--------------------------------------------------------------------------------
/FLOW5 - Maximum Bipartite Matching HopcroftKarp.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 |     
  3 | // It has time complexity of O(E*√V). Which is extremely fast
  4 | // Recommended for regular use
  5 | // Here is the resource for Hopcroft-Karp:  https://brilliant.org/wiki/hopcroft-karp/
  6 | // By the was I did not understand how this algo works, I just use this template directly [21-12-2024]
  7 | 
  8 | 	
  9 | const int N = 3e5 + 9;
 10 | 
 11 | struct HopcroftKarp
 12 | {
 13 |         int left_size, right_size;
 14 |         vector<int> left_i_is_connected_to_right;
 15 |         vector<int> right_i_is_connected_to_left;
 16 |         vector<int> level;
 17 |         vector<vector<int>> graph;
 18 | 
 19 |         HopcroftKarp(int _n, int _m)
 20 |         {
 21 |                 left_size = _n;
 22 |                 right_size = _m;
 23 |                 int p = _n + _m + 1;
 24 |                 graph.resize(p);
 25 |                 left_i_is_connected_to_right.resize(p, 0);
 26 |                 right_i_is_connected_to_left.resize(p, 0);
 27 |                 level.resize(p, 0);
 28 |         }
 29 | 
 30 |         void addEdge(int u, int v)
 31 |         {
 32 |                 graph[u].push_back(v + left_size); // right vertex is increased by left_size here..
 33 |         }
 34 | 
 35 |         bool bfs()
 36 |         {
 37 |                 queue<int> q;
 38 | 
 39 |                 for (int u = 1; u <= left_size; u++)
 40 |                 {
 41 |                         if (!left_i_is_connected_to_right[u])
 42 |                         {
 43 |                                 level[u] = 0;
 44 |                                 q.push(u);
 45 |                         }
 46 |                         else
 47 |                         {
 48 |                                 level[u] = inf;
 49 |                         }
 50 |                 }
 51 | 
 52 |                 level[0] = inf;
 53 | 
 54 |                 while (!q.empty())
 55 |                 {
 56 |                         int u = q.front();
 57 |                         q.pop();
 58 | 
 59 |                         for (auto v : graph[u])
 60 |                         {
 61 |                                 if (level[right_i_is_connected_to_left[v]] == inf)
 62 |                                 {
 63 |                                         level[right_i_is_connected_to_left[v]] = level[u] + 1;
 64 |                                         q.push(right_i_is_connected_to_left[v]);
 65 |                                 }
 66 |                         }
 67 |                 }
 68 | 
 69 |                 return level[0] != inf;
 70 |         }
 71 | 
 72 |         bool dfs(int u)
 73 |         {
 74 |                 if (!u)
 75 |                 {
 76 |                         return true;
 77 |                 }
 78 | 
 79 |                 for (auto v : graph[u])
 80 |                 {
 81 |                         if (level[right_i_is_connected_to_left[v]] == level[u] + 1 && dfs(right_i_is_connected_to_left[v]))
 82 |                         {
 83 |                                 left_i_is_connected_to_right[u] = v;
 84 |                                 right_i_is_connected_to_left[v] = u;
 85 |                                 return true;
 86 |                         }
 87 |                 }
 88 | 
 89 |                 level[u] = inf;
 90 | 
 91 |                 return false;
 92 |         }
 93 | 
 94 |         int MaximumBipartiteMatching()
 95 |         {
 96 |                 int ans = 0;
 97 | 
 98 |                 while (bfs())
 99 |                 {
100 |                         for (int u = 1; u <= left_size; u++)
101 |                         {
102 |                                 if (!left_i_is_connected_to_right[u] && dfs(u))
103 |                                 {
104 |                                         ans++;
105 |                                 }
106 |                         }
107 |                 }
108 | 
109 |                 return ans;
110 |         }
111 | 
112 |         vector<pair<int, int>> GetMatchingEdges()
113 |         {
114 |                 vector<pair<int, int>> matching;
115 | 
116 |                 for (int u = 1; u <= left_size; u++)
117 |                 {
118 |                         if (left_i_is_connected_to_right[u])
119 |                         {
120 |                                 matching.push_back({u, left_i_is_connected_to_right[u] - left_size}); // subtract left_size to get original right-side vertex
121 |                         }
122 |                 }
123 | 
124 |                 return matching;
125 |         }
126 | };
127 | 
128 | 
129 | 
130 | int32_t main()
131 | {
132 |         ios::sync_with_stdio(0);
133 |         cin.tie(0);
134 | 
135 |         int left_size, right_size, edges;
136 | 
137 |         cin >> left_size >> right_size >> edges;
138 | 
139 |         HopcroftKarp HK(left_size, right_size);
140 | 
141 |         for (int i = 0; i < edges; i++)
142 |         {
143 |                 int u, v;
144 |                 cin >> u >> v;
145 | 
146 |                 HK.addEdge(u, v);
147 |         }
148 | 
149 |         cout << HK.MaximumBipartiteMatching() << endl;
150 | 
151 |         vector<pair<int, int>> matching = HK.GetMatchingEdges();
152 | 
153 |         for (auto x : matching)
154 |         {
155 |                 cout << x.first << " " << x.second << endl;
156 |         }
157 | 
158 |         return 0;
159 | }
160 | 
161 | //  https://cses.fi/problemset/task/1696/
162 | 


--------------------------------------------------------------------------------
/FLOW6 - Minimum Cost Maximum Flow (MCMF).cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | // This is similar to maximum flow algorithms.
  3 | // In maximum flow algorithms, in each iteration, we used to find an augmenting path using DFS/BFS and then perform flow augmentation through its edges
  4 | 
  5 | // But in Minimum cost maximum flow algorithm,
  6 | // In each iteration, instead of finding just an augmenting path, we will find minimum cost augmenting path.  [minimum cost augmenting path = cost of sending each unit of flow through this path is minimum among all the remaining augmenting paths]
  7 | 
  8 | // So, for MCMF, in each iteration, we will use Dijkstra to find minimum cost augmenting path, then do flow augmentation through it's edges.
  9 | // And that's it.
 10 | 
 11 | 
 12 | 
 13 | 
 14 | // Adjusting Dijkstra to accomodate negative edges:
 15 | // For max flow algorithms we consider edges in reverse to undo flow if needed. In this case, we are gonna have to undo the cost too. That's why for reverse edge, cost is negative "graph[v].push_back({u, (int)graph[u].size()-1, 0, -cost, -id});"
 16 | // Also, for some problems cost of edges might be given negative in the input.
 17 | // As we know dijkstra algorithm does not works for negative edges, we need to make adjustment to the edge weight's so that they become non-negative. 
 18 | // We shall use the same techniques that is used in johnson's algorithm for all pair shortest path in O(V^2 log V + VE)  [https://github.com/ArfatulAsif/Competitive-programming/blob/main/Johnson%E2%80%99s%20algorithm%20for%20All-pairs%20shortest%20paths.cpp]
 19 | // Using a bellman-ford to shift edges , new weight = w(u, v) + h[u] - h[v]. in this case u = source
 20 | // Here the potential function h[] is used to "normalize" the graph by shifting the edge weights in such a way that all edges have non-negative weights.
 21 | // Then perform Repeated Dijkstra
 22 | // After each Dijkstra retrieve distance(u,v) = dijkstra(u, v) + h[v] - h[u]. u = source.
 23 | // Here distance(source,sink) = minimum cost of sending 1 unit of flow from source to sink
 24 | // Then update the potential function h[]. And repeat Dijkstra untill no augmenting path found/target_flow achieved.
 25 | 
 26 | 
 27 | 
 28 | 
 29 | 
 30 | 
 31 | 
 32 | // Property of this code:
 33 | // Works for both directed, undirected and with negative cost (in the input) too.
 34 | // Complexity: O(min(E^2 *V log V, E logV * flow))
 35 | // This code does not works if there is a negative cycle in the input.  [that's why It Normally does not work for Maximum Cost maximum Flow, as taking -cost with edges might form negative cycles]
 36 | 
 37 | 
 38 | 
 39 | 
 40 | const int N = 1000;
 41 | 
 42 | struct MCMF
 43 | {
 44 | 
 45 | 	struct edge
 46 | 	{
 47 | 		int v; 			// to
 48 | 		int rev; 		//Reverse edge index in graph[v]
 49 | 		int residual_capacity;  // Residual capacity of the edge
 50 | 		int cost;               // Cost per unit of flow through the edge
 51 | 		int edge_id;            // Edge ID (optional, if needed)
 52 | 	};
 53 | 
 54 | 	vector<edge>graph[N];
 55 | 
 56 | 	int n;
 57 | 	int source, sink;
 58 | 
 59 | 	vector<int> dist;
 60 | 	vector<int>h; // potential array
 61 | 
 62 | 	vector<pair<int,int>> parent; //  parent[v] = {u, rev} = {parent node u, parent node u's index in graph[v]}
 63 | 
 64 | 
 65 | 	MCMF(int _n)
 66 | 	{
 67 | 		n = _n+1;
 68 | 	}
 69 | 
 70 | 	// This is for directed, for undirected make sure to include edges in both direction  addEdge(u,v) and addEdge(v,u).
 71 | 	void addEdge(int u, int v, int capacity, int cost, int id = -1)
 72 | 	{
 73 | 		graph[u].push_back({v, (int)graph[v].size(), capacity, cost, id});
 74 | 		graph[v].push_back({u, (int)graph[u].size()-1, 0, -cost, -id});
 75 | 	}
 76 | 
 77 | 
 78 | 	bool BellmanFord()
 79 | 	{
 80 | 		dist.assign(n, inf);
 81 | 		dist[source] = 0;
 82 | 		vector<pair<int,edge>>AllEdges; // {u, edge(v,rev, residual_capacity, cost, id)}
 83 | 
 84 | 		for(int i=0;i<n;i++)  // vertex,  i < n because we already increased n by 1.
 85 | 		{
 86 | 			for(auto &e: graph[i])
 87 | 			{
 88 | 				AllEdges.push_back({i, e}); 
 89 | 			}
 90 | 		}
 91 | 
 92 | 		bool flag = true;
 93 | 
 94 | 		for(int i=0;i<n-1; i++) // number of vertices, for zero based graph, i < n
 95 | 		{
 96 | 			flag = false;
 97 | 
 98 | 			for(auto &e: AllEdges)
 99 | 			{
100 | 				int u = e.first;
101 | 				auto &[v, rev, residual_capacity, cost, id] = e.second;
102 | 
103 | 				if(dist[v] > dist[u]+cost && residual_capacity>0)
104 | 				{
105 | 					dist[v] = dist[u]+cost;
106 | 					flag = true;
107 | 				}
108 | 
109 | 			}
110 | 
111 | 			if(flag == false)
112 | 			{
113 | 				break;
114 | 			}
115 | 		}
116 | 
117 | 		for(auto &e: AllEdges)
118 | 		{
119 | 			int u = e.first;
120 | 			auto &[v, rev, residual_capacity, cost, id] = e.second;
121 | 
122 | 			if(dist[v] > dist[u]+cost && residual_capacity>0)
123 | 			{
124 | 				dist[v] = dist[u]+cost;
125 | 
126 | 				return false; // neg cycle exists
127 | 			}
128 | 
129 | 		}
130 | 
131 | 		for(int i=0;i<n;i++)
132 | 		{
133 | 			if(dist[i] < inf)
134 | 			{
135 | 				h[i] = dist[i]; // taking the initial potential function
136 | 			}
137 | 		}
138 | 
139 | 
140 | 		return dist[sink] != inf; // reachable
141 | 	}
142 | 
143 | 	// Use Dijkstra to find minimum cost augmenting path
144 | 	bool Dijkstra()
145 | 	{
146 | 		parent.assign(n, {-1,-1});
147 | 		dist.assign(n, inf);
148 | 
149 | 		priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;
150 | 
151 | 		dist[source] = 0;
152 | 
153 | 		pq.push({0, source});
154 | 
155 | 		while(!pq.empty())
156 | 		{
157 | 			int u = pq.top().second;
158 | 			int u_cost = pq.top().first;  // cost of 1 unit of flow from source to u
159 | 			pq.pop();
160 | 
161 | 			if(u_cost != dist[u])
162 | 			{
163 | 				continue;
164 | 			}
165 | 
166 | 			for(auto &[v, rev, residual_capacity, cost, id]: graph[u])
167 | 			{
168 | 				int adjusted_weight = cost + h[u] - h[v];  // this is always non_negative, even if h[u] or h[v] is negative.
169 | 
170 | 				if(dist[v] > dist[u]+adjusted_weight && residual_capacity > 0)
171 | 				{
172 | 					dist[v] = dist[u]+adjusted_weight;
173 | 					parent[v] = {u, rev}; // {u, position of u in graph[v]}
174 | 					pq.push({dist[v], v});
175 | 				}
176 | 			}
177 | 		}
178 | 
179 | 		for(int i=0;i<n;i++)
180 | 		{
181 | 			if(dist[i] < inf)
182 | 			{
183 | 				dist[i] += h[i]-h[source]; // retriving the true distance = dijkstra[u,v] + h[v] - h[u]
184 | 			}
185 | 		}
186 | 
187 | 		for(int i=0;i<n;i++)
188 | 		{
189 | 			if(dist[i] < inf)
190 | 			{
191 | 				h[i] = dist[i]; // setting new potential value, as after using each augmenting path, some edges residual_capacity could becomes 0, and we might not be able to use these
192 | 				// that's why we need new potential values
193 | 			}
194 | 		}
195 | 
196 | 		return dist[sink] != inf; // sink is reachable, which means in this iteration augmenting path is found. Not reachable means no more augmenting path remains.
197 | 	}
198 | 
199 | 	// Solve the Min-Cost Max-Flow problem
200 | 	pair<int,int> MinimumCostMaximumFlow(int _source, int _sink, int target_flow = inf)
201 | 	{
202 | 		source = _source;
203 | 		sink = _sink;
204 | 
205 | 		int total_flow_sent = 0;
206 | 		int total_cost = 0;
207 | 
208 | 		h.assign(n, 0);
209 | 
210 | 		if(!BellmanFord())  // using bellman-Ford for adjusting weight to accomodate negative neg weight edges
211 | 		{
212 | 			return {inf,inf}; // Either sink is not reachable or negative cycle exists
213 | 		}
214 | 
215 | 		while( total_flow_sent < target_flow)
216 | 		{
217 | 			if(!Dijkstra()) // Use Dijkstra to find shortest augmenting path
218 | 			{
219 | 				// If no augmenting pathfound
220 | 				break;
221 | 			}
222 | 
223 | 
224 | 	                int v = sink;
225 | 	                int augmenting_path_flow = inf;
226 | 	                int cost_per_unit_of_flow_from_source_to_sink = dist[sink];
227 | 	 	         
228 | 	                while(v != source)
229 | 	                {
230 | 	                	int u = parent[v].first;
231 | 	                	int rev = parent[v].second;	
232 | 
233 | 	                	int idx_of_v_in_u = graph[v][rev].rev;
234 | 
235 | 	                	int residual_capacity = graph[u][idx_of_v_in_u].residual_capacity;
236 | 	                	
237 | 	                	augmenting_path_flow = min(augmenting_path_flow, residual_capacity);
238 | 	 
239 | 	                        v = parent[v].first;
240 | 	                        
241 | 	                }
242 | 	                            
243 | 	 	                	 
244 | 	 		//adjust the residual capacity 
245 | 
246 | 	                v = sink;	                
247 | 	                while(v != source)
248 | 	                {
249 | 	                	int u = parent[v].first;
250 | 	                	int rev = parent[v].second;	
251 | 
252 | 	                	int idx_of_v_in_u = graph[v][rev].rev;
253 | 
254 | 	                	graph[u][idx_of_v_in_u].residual_capacity -= augmenting_path_flow;
255 | 	                	graph[v][rev].residual_capacity += augmenting_path_flow;
256 | 
257 | 	                        v = parent[v].first;
258 | 	                        
259 | 	                }
260 | 
261 | 
262 | 	                if(total_flow_sent + augmenting_path_flow >= target_flow)
263 | 	                {
264 | 	                        int take = target_flow - total_flow_sent;
265 | 	                        total_cost += (take*cost_per_unit_of_flow_from_source_to_sink);
266 | 	                        total_flow_sent = target_flow;
267 | 	                        break;
268 | 	                }
269 | 	                else 
270 | 	                {
271 | 	                        total_flow_sent += augmenting_path_flow;
272 | 
273 | 	                        total_cost += (augmenting_path_flow*cost_per_unit_of_flow_from_source_to_sink);
274 | 	                }
275 | 
276 | 		}
277 | 
278 | 
279 | 		if(total_flow_sent < target_flow)
280 | 		{
281 | 			return {inf, inf};
282 | 		}
283 | 
284 | 
285 | 		return {total_flow_sent, total_cost};
286 | 	}
287 | 
288 | 
289 | };
290 | 
291 |       
292 | 
293 | int32_t main()
294 | {
295 |         ios::sync_with_stdio(0);
296 |         cin.tie(0);
297 | 
298 |         int n,m,k;
299 |         cin>>n>>m>>k;
300 | 
301 |         MCMF mcmf(n);
302 | 
303 |         for(int i=0;i<m;i++)
304 |         {
305 |         	int u,v,c,cost;
306 |         	cin>>u>>v>>c>>cost;
307 | 
308 |         	mcmf.addEdge(u,v,c,cost);  // if undirect then add mcmf.addEdge(v,u,c,cost) too
309 |         }
310 | 
311 | 
312 | 
313 |         int ans = mcmf.MinimumCostMaximumFlow(1,n,k).second;
314 | 
315 |         if(ans == inf)
316 |         {
317 |         	cout<<-1<<endl;
318 |         }
319 |         else 
320 |         {
321 |         	cout<<ans<<endl;
322 |         }
323 | 
324 | }
325 | 
326 | // https://cses.fi/problemset/task/2121/
327 | 


--------------------------------------------------------------------------------
/FLOW7 - Minimum Cost Maximum Flow With Negative Cycle(MCMF).cpp:
--------------------------------------------------------------------------------
  1 | // Push-Relabel implementation of the cost-scaling algorithm
  2 | // Runs in O( <max_flow> * log(V * max_edge_cost)) = O( V^3 * log(V * C))
  3 | // Really fast in practice, 3e4 edges are fine.
  4 | // Operates on integers, costs are multiplied by N!!
  5 | 
  6 | 
  7 | 
  8 | 
  9 | // this is shohage vais code, I didnot understand this ... When I do I will write one.
 10 | 
 11 | #include<bits/stdc++.h>
 12 | using namespace std;
 13 | 
 14 | // source: dacin21
 15 | template<typename flow_t = int, typename cost_t = int>
 16 | struct mcSFlow {
 17 |   struct Edge {
 18 |     cost_t c;
 19 |     flow_t f;
 20 |     int to, rev;
 21 |     Edge(int _to, cost_t _c, flow_t _f, int _rev): c(_c), f(_f), to(_to), rev(_rev) {}
 22 |   };
 23 |   static constexpr cost_t INFCOST = numeric_limits<cost_t>::max() / 2;
 24 |   cost_t eps;
 25 |   int N, S, T;
 26 |   vector<vector<Edge> > G;
 27 |   vector<unsigned int> isq, cur;
 28 |   vector<flow_t> ex;
 29 |   vector<cost_t> h;
 30 |   mcSFlow(int _N, int _S, int _T): eps(0), N(_N), S(_S), T(_T), G(_N) {}
 31 |   void add_edge(int a, int b, cost_t cost, flow_t cap) {
 32 |     assert(cap >= 0);
 33 |     assert(a >= 0 && a < N && b >= 0 && b < N);
 34 |     if(a == b) {
 35 |       assert(cost >= 0);
 36 |       return;
 37 |     }
 38 |     cost *= N;
 39 |     eps = max(eps, abs(cost));
 40 |     G[a].emplace_back(b, cost, cap, G[b].size());
 41 |     G[b].emplace_back(a, -cost, 0, G[a].size() - 1);
 42 |   }
 43 |   void add_flow(Edge& e, flow_t f) {
 44 |     Edge &back = G[e.to][e.rev];
 45 |     if (!ex[e.to] && f)
 46 |       hs[h[e.to]].push_back(e.to);
 47 |     e.f -= f;
 48 |     ex[e.to] += f;
 49 |     back.f += f;
 50 |     ex[back.to] -= f;
 51 |   }
 52 |   vector<vector<int> > hs;
 53 |   vector<int> co;
 54 |   flow_t max_flow() {
 55 |     ex.assign(N, 0);
 56 |     h.assign(N, 0);
 57 |     hs.resize(2 * N);
 58 |     co.assign(2 * N, 0);
 59 |     cur.assign(N, 0);
 60 |     h[S] = N;
 61 |     ex[T] = 1;
 62 |     co[0] = N - 1;
 63 |     for(auto &e : G[S]) add_flow(e, e.f);
 64 |     if(hs[0].size())
 65 |       for (int hi = 0; hi >= 0;) {
 66 |         int u = hs[hi].back();
 67 |         hs[hi].pop_back();
 68 |         while (ex[u] > 0) { // discharge u
 69 |           if (cur[u] == G[u].size()) {
 70 |             h[u] = 1e9;
 71 |             for(unsigned int i = 0; i < G[u].size(); ++i) {
 72 |               auto &e = G[u][i];
 73 |               if (e.f && h[u] > h[e.to] + 1) {
 74 |                 h[u] = h[e.to] + 1, cur[u] = i;
 75 |               }
 76 |             }
 77 |             if (++co[h[u]], !--co[hi] && hi < N)
 78 |               for(int i = 0; i < N; ++i)
 79 |                 if (hi < h[i] && h[i] < N) {
 80 |                   --co[h[i]];
 81 |                   h[i] = N + 1;
 82 |                 }
 83 |             hi = h[u];
 84 |           } else if (G[u][cur[u]].f && h[u] == h[G[u][cur[u]].to] + 1)
 85 |             add_flow(G[u][cur[u]], min(ex[u], G[u][cur[u]].f));
 86 |           else ++cur[u];
 87 |         }
 88 |         while (hi >= 0 && hs[hi].empty()) --hi;
 89 |       }
 90 |     return -ex[S];
 91 |   }
 92 |   void push(Edge &e, flow_t amt) {
 93 |     if(e.f < amt) amt = e.f;
 94 |     e.f -= amt;
 95 |     ex[e.to] += amt;
 96 |     G[e.to][e.rev].f += amt;
 97 |     ex[G[e.to][e.rev].to] -= amt;
 98 |   }
 99 |   void relabel(int vertex) {
100 |     cost_t newHeight = -INFCOST;
101 |     for(unsigned int i = 0; i < G[vertex].size(); ++i) {
102 |       Edge const&e = G[vertex][i];
103 |       if(e.f && newHeight < h[e.to] - e.c) {
104 |         newHeight = h[e.to] - e.c;
105 |         cur[vertex] = i;
106 |       }
107 |     }
108 |     h[vertex] = newHeight - eps;
109 |   }
110 |   static constexpr int scale = 2;
111 |   pair<flow_t, cost_t> minCostMaxFlow() {
112 |     cost_t retCost = 0;
113 |     for(int i = 0; i < N; ++i)
114 |       for(Edge &e : G[i])
115 |         retCost += e.c * (e.f);
116 |     //find max-flow
117 |     flow_t retFlow = max_flow();
118 |     h.assign(N, 0);
119 |     ex.assign(N, 0);
120 |     isq.assign(N, 0);
121 |     cur.assign(N, 0);
122 |     queue<int> q;
123 |     for(; eps; eps >>= scale) {
124 |       //refine
125 |       fill(cur.begin(), cur.end(), 0);
126 |       for(int i = 0; i < N; ++i)
127 |         for(auto &e : G[i])
128 |           if(h[i] + e.c - h[e.to] < 0 && e.f) push(e, e.f);
129 |       for(int i = 0; i < N; ++i) {
130 |         if(ex[i] > 0) {
131 |           q.push(i);
132 |           isq[i] = 1;
133 |         }
134 |       }
135 |       // make flow feasible
136 |       while(!q.empty()) {
137 |         int u = q.front();
138 |         q.pop();
139 |         isq[u] = 0;
140 |         while(ex[u] > 0) {
141 |           if(cur[u] == G[u].size())
142 |             relabel(u);
143 |           for(unsigned int &i = cur[u], max_i = G[u].size(); i < max_i; ++i) {
144 |             Edge &e = G[u][i];
145 |             if(h[u] + e.c - h[e.to] < 0) {
146 |               push(e, ex[u]);
147 |               if(ex[e.to] > 0 && isq[e.to] == 0) {
148 |                 q.push(e.to);
149 |                 isq[e.to] = 1;
150 |               }
151 |               if(ex[u] == 0) break;
152 |             }
153 |           }
154 |         }
155 |       }
156 |       if(eps > 1 && eps >> scale == 0) {
157 |         eps = 1 << scale;
158 |       }
159 |     }
160 |     for(int i = 0; i < N; ++i) {
161 |       for(Edge &e : G[i]) {
162 |         retCost -= e.c * (e.f);
163 |       }
164 |     }
165 |     return make_pair(retFlow, retCost / 2 / N);
166 |   }
167 |   flow_t getFlow(Edge const &e) {
168 |     return G[e.to][e.rev].f;
169 |   }
170 | };
171 | 


--------------------------------------------------------------------------------
/FLOW8 - Weighted Maximum Bipartite Matching (Hungarian algorithm).cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | /* Hungarian Algorithm:
  3 |    - Complexity: O(V^3), optimized for both minimum and maximum cost maximum matching.
  4 |    - Minimum Cost Maximum Matching: Uses original costs. [ Also set, c[i][j] = inf]
  5 |    - Maximum Cost Maximum Matching: Negates the costs and returns the negated result. [ add_edge(u, v, -cost) and cout<<(-M.WeightedBipartiteMatching())<<endl] And [c[i][j] = 0]
  6 |    - Works for 1-indexed input. Both left and right is 1 based, no need to do v += left_size */
  7 | 
  8 | // I didn't understand the algorithm, but I can use it.
  9 | 
 10 | 
 11 | const int N = 509;
 12 | 
 13 | struct Hungarian 
 14 | {
 15 |         int c[N][N], fx[N], fy[N], d[N];
 16 | 
 17 |         int left_i_connected_to_right[N]; 
 18 |         int right_i_connected_to_left[N];
 19 | 
 20 |         int arg[N], trace[N];
 21 |         queue<int> q;
 22 |         int start, finish, n;
 23 | 
 24 |         Hungarian() {}
 25 | 
 26 |         Hungarian(int n1, int n2): n(max(n1, n2)) 
 27 |         {
 28 |                 for (int i = 1; i <= n; ++i) 
 29 |                 {
 30 |                         fy[i] = left_i_connected_to_right[i] = right_i_connected_to_left[i] = 0;
 31 |                         
 32 |                         for (int j = 1; j <= n; ++j) 
 33 |                         {
 34 |                                 c[i][j] = 0; // Set to 0 for maximum cost matching
 35 |                         }
 36 |                 }
 37 |         }
 38 | 
 39 |         void add_edge(int u, int v, int cost) 
 40 |         {
 41 |                 c[u][v] = min(c[u][v], cost);
 42 |         }
 43 | 
 44 |         inline int getC(int u, int v) 
 45 |         {
 46 |                 return c[u][v] - fx[u] - fy[v];
 47 |         }
 48 | 
 49 |         void initBFS() 
 50 |         {
 51 |                 while (!q.empty()) q.pop();
 52 |                 q.push(start);
 53 |                 
 54 |                 for (int i = 0; i <= n; ++i) trace[i] = 0;
 55 |                 
 56 |                 for (int v = 1; v <= n; ++v) 
 57 |                 {
 58 |                         d[v] = getC(start, v);
 59 |                         arg[v] = start;
 60 |                 }
 61 |                 finish = 0;
 62 |         }
 63 | 
 64 |         void findAugPath() 
 65 |         {
 66 |                 while (!q.empty()) 
 67 |                 {
 68 |                         int u = q.front();
 69 |                         q.pop();
 70 |                         for (int v = 1; v <= n; ++v) 
 71 |                         {
 72 |                                 if (!trace[v])
 73 |                                 {
 74 |                                         int w = getC(u, v);
 75 |                                         if (!w) 
 76 |                                         {
 77 |                                                 trace[v] = u;
 78 |                                                 if (!right_i_connected_to_left[v]) 
 79 |                                                 {
 80 |                                                         finish = v;
 81 |                                                         return;
 82 |                                                 }
 83 |                                                 q.push(right_i_connected_to_left[v]);
 84 |                                         }
 85 |                                         if (d[v] > w) 
 86 |                                         {
 87 |                                                 d[v] = w;
 88 |                                                 arg[v] = u;
 89 |                                         }
 90 |                                 }
 91 |                         }
 92 |                 }
 93 |         }
 94 | 
 95 |         void subX_addY() 
 96 |         {
 97 |                 int delta = inf;
 98 |                 for (int v = 1; v <= n; ++v) 
 99 |                 {
100 |                         if (!trace[v] && d[v] < delta) 
101 |                         {
102 |                                 delta = d[v];
103 |                         }
104 |                 }
105 | 
106 |                 fx[start] += delta;
107 | 
108 |                 for (int v = 1; v <= n; ++v) 
109 |                 {
110 |                         if (trace[v]) 
111 |                         {
112 |                                 int u = right_i_connected_to_left[v];
113 |                                 fy[v] -= delta;
114 |                                 fx[u] += delta;
115 |                         } 
116 |                         else 
117 |                         {
118 |                                 d[v] -= delta;
119 |                         }
120 |                 }
121 |                 for (int v = 1; v <= n; ++v) 
122 |                 {
123 |                         if (!trace[v] && !d[v]) 
124 |                         {
125 |                                 trace[v] = arg[v];
126 |                                 if (!right_i_connected_to_left[v]) 
127 |                                 {
128 |                                         finish = v;
129 |                                         return;
130 |                                 }
131 |                                 q.push(right_i_connected_to_left[v]);
132 |                         }
133 |                 }
134 |         }
135 | 
136 |         void Enlarge() 
137 |         {
138 |                 do {
139 |                         int u = trace[finish];
140 |                         int next = left_i_connected_to_right[u];
141 |                         left_i_connected_to_right[u] = finish;
142 |                         right_i_connected_to_left[finish] = u;
143 |                         finish = next;
144 |                 } while (finish);
145 |         }
146 | 
147 |         int WeightedBipartiteMatching() 
148 |         {
149 |                 for (int u = 1; u <= n; ++u) 
150 |                 {
151 |                         fx[u] = c[u][1];
152 |                         for (int v = 1; v <= n; ++v) 
153 |                         {
154 |                                 fx[u] = min(fx[u], c[u][v]);
155 |                         }
156 |                 }
157 |                 for (int v = 1; v <= n; ++v) 
158 |                 {
159 |                         fy[v] = c[1][v] - fx[1];
160 | 
161 |                         for (int u = 1; u <= n; ++u) 
162 |                         {
163 |                                 fy[v] = min(fy[v], c[u][v] - fx[u]);
164 |                         }
165 |                 }
166 |                 for (int u = 1; u <= n; ++u) 
167 |                 {
168 |                         start = u;
169 |                         initBFS();
170 |                         while (!finish) 
171 |                         {
172 |                                 findAugPath();
173 |                                 if (!finish) subX_addY();
174 |                         }
175 |                         Enlarge();
176 |                 }
177 |                 int ans = 0;
178 |                 for (int i = 1; i <= n; ++i) 
179 |                 {
180 |                         if (c[i][left_i_connected_to_right[i]] != inf) ans += c[i][left_i_connected_to_right[i]];
181 |                         else left_i_connected_to_right[i] = 0;
182 |                 }
183 |                 return ans;
184 |         }
185 | 
186 | 
187 |         vector<pair<int,int>>  FindBipartiteMatching(int left_size, int right_size)
188 |         {
189 |                 vector<pair<int,int>>matching;
190 |                 
191 |                 for(int i=1;i<=left_size;i++)
192 |                 {
193 |                         if(left_i_connected_to_right[i]!=0)
194 |                         {
195 |                                 matching.push_back({i,left_i_connected_to_right[i]});
196 |                         }
197 |                 }
198 | 
199 |                 // Or we can use below part, either one is fine.
200 |                 // for(int i=1;i<=right_size;i++)
201 |                 // {
202 |                 //      if(right_i_connected_to_left[i] != 0) 
203 |                 //      {
204 |                 //              matching.push_back({right_i_connected_to_left[i], i});
205 |                 //      }
206 |                 // }
207 | 
208 |                 return matching;
209 |         }
210 | };
211 | 
212 | 
213 | 
214 | 
215 | int32_t main()
216 | {
217 |         ios::sync_with_stdio(0);
218 |         cin.tie(0);
219 | 
220 |         int t;
221 |         cin>>t;
222 |         for(int tt=1;tt<=t;tt++)
223 |         {
224 |                 int n;
225 |                 cin>>n;
226 |                 
227 |                 int left_size, right_size;
228 | 
229 |                 left_size = right_size = n;
230 | 
231 |                 Hungarian M(left_size,right_size);
232 | 
233 |                 vector<int>v1,v2;
234 |                 for(int i=0;i<n;i++)
235 |                 {
236 |                         int a;
237 |                         cin>>a;
238 |                         v1.push_back(a);
239 |                 }
240 | 
241 |                 for(int i=0;i<n;i++)
242 |                 {
243 |                         int a;
244 |                         cin>>a;
245 |                         v2.push_back(a);
246 |                 }
247 | 
248 |                 for(int i=0;i<n;i++)
249 |                 {
250 |                         for(int j=0;j<n;j++)
251 |                         {
252 |                                 if(v1[i]>v2[j])
253 |                                 {
254 |                                         M.add_edge(i+1,j+1, -2); // -cost, so that it becomes maximum cost maximum bipartite matching . For minimum cost, dont negate
255 |                                 }
256 |                                 if(v1[i] == v2[j])
257 |                                 {
258 |                                         M.add_edge(i+1,j+1,-1);
259 |                                 }
260 |                         }
261 |                 }
262 | 
263 | 
264 |                 cout<<"Case "<<tt<<": "<<-M.WeightedBipartiteMatching()<<endl;  // maximum cost bipartite matching
265 |         }
266 | 
267 | }
268 | 
269 | // https://lightoj.com/problem/karate-competition
270 | 


--------------------------------------------------------------------------------
/FLOW9 - Minimum Vertex Cover\Maximum Independent Set in Bipartite Graph (hopcroft-karp).cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | // Complexity of this code is O(E*√V).
  3 | 
  4 | struct HopcroftKarp
  5 | {
  6 |         int left_size, right_size;
  7 |         vector<int> left_i_is_connected_to_right;
  8 |         vector<int> right_i_is_connected_to_left;
  9 |         vector<int> level;
 10 |         vector<vector<int>> graph;
 11 | 
 12 |         HopcroftKarp(int _n, int _m)
 13 |         {
 14 |                 left_size = _n;
 15 |                 right_size = _m;
 16 |                 int p = _n + _m + 1;
 17 |                 graph.resize(p);
 18 |                 left_i_is_connected_to_right.resize(p, 0);
 19 |                 right_i_is_connected_to_left.resize(p, 0);
 20 |                 level.resize(p, 0);
 21 |         }
 22 | 
 23 |         void addEdge(int u, int v)
 24 |         {
 25 |                 graph[u].push_back(v + left_size); // right vertex is increased by left_size here..
 26 |         }
 27 | 
 28 |         bool bfs()
 29 |         {
 30 |                 queue<int> q;
 31 | 
 32 |                 for (int u = 1; u <= left_size; u++)
 33 |                 {
 34 |                         if (!left_i_is_connected_to_right[u])
 35 |                         {
 36 |                                 level[u] = 0;
 37 |                                 q.push(u);
 38 |                         }
 39 |                         else
 40 |                         {
 41 |                                 level[u] = inf;
 42 |                         }
 43 |                 }
 44 | 
 45 |                 level[0] = inf;
 46 | 
 47 |                 while (!q.empty())
 48 |                 {
 49 |                         int u = q.front();
 50 |                         q.pop();
 51 | 
 52 |                         for (auto v : graph[u])
 53 |                         {
 54 |                                 if (level[right_i_is_connected_to_left[v]] == inf)
 55 |                                 {
 56 |                                         level[right_i_is_connected_to_left[v]] = level[u] + 1;
 57 |                                         q.push(right_i_is_connected_to_left[v]);
 58 |                                 }
 59 |                         }
 60 |                 }
 61 | 
 62 |                 return level[0] != inf;
 63 |         }
 64 | 
 65 |         bool dfs(int u)
 66 |         {
 67 |                 if (!u)
 68 |                 {
 69 |                         return true;
 70 |                 }
 71 | 
 72 |                 for (auto v : graph[u])
 73 |                 {
 74 |                         if (level[right_i_is_connected_to_left[v]] == level[u] + 1 && dfs(right_i_is_connected_to_left[v]))
 75 |                         {
 76 |                                 left_i_is_connected_to_right[u] = v;
 77 |                                 right_i_is_connected_to_left[v] = u;
 78 |                                 return true;
 79 |                         }
 80 |                 }
 81 | 
 82 |                 level[u] = inf;
 83 | 
 84 |                 return false;
 85 |         }
 86 | 
 87 |         int MaximumBipartiteMatching()
 88 |         {
 89 |                 int ans = 0;
 90 | 
 91 |                 while (bfs())
 92 |                 {
 93 |                         for (int u = 1; u <= left_size; u++)
 94 |                         {
 95 |                                 if (!left_i_is_connected_to_right[u] && dfs(u))
 96 |                                 {
 97 |                                         ans++;
 98 |                                 }
 99 |                         }
100 |                 }
101 | 
102 |                 return ans;
103 |         }
104 | 
105 |         vector<pair<int, int>> GetMatchingEdges()
106 |         {
107 |                 vector<pair<int, int>> matching;
108 | 
109 |                 for (int u = 1; u <= left_size; u++)
110 |                 {
111 |                         if (left_i_is_connected_to_right[u])
112 |                         {
113 |                                 matching.push_back({u, left_i_is_connected_to_right[u] - left_size}); // subtract left_size to get original right-side vertex
114 |                         }
115 |                 }
116 | 
117 |                 return matching;
118 |         }
119 | 
120 |         vector<pair<int,char>> FindMinimumVertexCover()
121 |         {
122 |         	vector<pair<int,char>> min_vertex_cover;
123 |         	vector<bool> visited_left(left_size+1);
124 |         	vector<bool> visited_right(right_size+1);
125 | 
126 |         	queue<int>q;
127 | 
128 |         	for(int i=1;i <= left_size; i++)
129 |         	{
130 |         		if(!left_i_is_connected_to_right[i]) // selecting unmatched vertices from left side. [unmatched: those vertices that are not end points of matching edges]
131 |         		{
132 |         			visited_left[i] = true;
133 |         			q.push(i);
134 |         		}
135 |         	}
136 | 
137 |         	while(!q.empty())
138 |         	{
139 |         		int left = q.front();
140 |         		q.pop();
141 | 
142 |         		for(auto v : graph[left])
143 |         		{
144 |         			if(v <= left_size) // v is not a right vertex
145 |         			{
146 |         				continue;
147 |         			}
148 | 
149 |         			int right = v - left_size;
150 | 
151 |         			// left -------unmatched_edge-------> right. 
152 |         			if(visited_right[right] == false)
153 |         			{
154 |         				visited_right[right] = true;
155 | 
156 |         				int matched_left = right_i_is_connected_to_left[right+left_size];
157 | 
158 |         				// matched_left <---------matched_edge----------right.
159 |         				if(matched_left!=0 && visited_left[matched_left] == false)
160 |         				{
161 |         					visited_left[matched_left] = true;
162 |         					q.push(matched_left);
163 |         				}
164 | 
165 |         			}
166 | 
167 |         		}
168 |         	}
169 | 
170 | 
171 |         	// Taking unmarked vertices from left
172 |         	for(int i=1;i<=left_size;i++)
173 |         	{
174 |         		if(visited_left[i]==false)
175 |         		{
176 |         			min_vertex_cover.push_back({i, 'L'});
177 |         		}
178 |         	}
179 | 
180 | 
181 |         	// Taking marked vertices from right
182 |         	for(int i=1;i<=right_size;i++)
183 |         	{
184 |         		if(visited_right[i] == true)
185 |         		{
186 |         			min_vertex_cover.push_back({i,'R'});
187 |         		}
188 |         	}
189 | 
190 |         	return min_vertex_cover;
191 |         }
192 | 
193 |         vector<pair<int,char>> FindMaximumIndependentSet()
194 |         {
195 |         	vector<pair<int,char>> max_independent_set;
196 |         	vector<bool> visited_left(left_size+1);
197 |         	vector<bool> visited_right(right_size+1);
198 | 
199 |         	queue<int>q;
200 | 
201 |         	for(int i=1;i <= left_size; i++)
202 |         	{
203 |         		if(!left_i_is_connected_to_right[i]) // selecting unmatched vertices from left side. [unmatched: those vertices that are not end points of matching edges]
204 |         		{
205 |         			visited_left[i] = true;
206 |         			q.push(i);
207 |         		}
208 |         	}
209 | 
210 |         	while(!q.empty())
211 |         	{
212 |         		int left = q.front();
213 |         		q.pop();
214 | 
215 |         		for(auto v : graph[left])
216 |         		{
217 |         			if(v <= left_size) // v is not a right vertex
218 |         			{
219 |         				continue;
220 |         			}
221 | 
222 |         			int right = v - left_size;
223 | 
224 |         			// left -------unmatched_edge-------> right. 
225 |         			if(visited_right[right] == false)
226 |         			{
227 |         				visited_right[right] = true;
228 | 
229 |         				int matched_left = right_i_is_connected_to_left[right+left_size];
230 | 
231 |         				// matched_left <---------matched_edge----------right.
232 |         				if(matched_left!=0 && visited_left[matched_left] == false)
233 |         				{
234 |         					visited_left[matched_left] = true;
235 |         					q.push(matched_left);
236 |         				}
237 | 
238 |         			}
239 | 
240 |         		}
241 |         	}
242 | 
243 | 
244 |         	//Exact opposite of Minimum Vertex Cover
245 | 
246 |         	// Taking marked vertices from left
247 |         	for(int i=1;i<=left_size;i++)
248 |         	{
249 |         		if(visited_left[i]==true)
250 |         		{
251 |         			max_independent_set.push_back({i, 'L'});
252 |         		}
253 |         	}
254 | 
255 | 
256 |         	// Taking unmarked vertices from right
257 |         	for(int i=1;i<=right_size;i++)
258 |         	{
259 |         		if(visited_right[i] == false)
260 |         		{
261 |         			max_independent_set.push_back({i,'R'});
262 |         		}
263 |         	}
264 | 
265 |         	return max_independent_set;
266 |         }
267 | };
268 | 
269 | 
270 | int32_t main()
271 | {
272 |         ios::sync_with_stdio(0);
273 |         cin.tie(0);
274 | 
275 |         int left_size, right_size, edges;
276 | 
277 |         cin>>left_size>>right_size>>edges;
278 | 
279 | 
280 |         HopcroftKarp HK(left_size,right_size);
281 | 
282 |         for(int i=0;i<edges;i++)
283 |         {
284 |         	int u,v;
285 |         	cin>>u>>v;
286 | 
287 |         	HK.addEdge(u,v);
288 | 
289 |         }
290 | 
291 | 
292 |         HK.MaximumBipartiteMatching(); // we need to call it First.......
293 | 
294 |         vector<pair<int,char>> min_vertex_cover = HK.FindMinimumVertexCover();
295 | 
296 |         for(auto x : min_vertex_cover)
297 |         {
298 |         	cout<<x.second<<" "<<x.first<<endl;
299 |         }
300 | 
301 | }
302 | 
303 | 
304 | 
305 | /*
306 | input:
307 | 5 4 9
308 | 1 1
309 | 2 1
310 | 2 2
311 | 3 2
312 | 4 1
313 | 4 3
314 | 4 4
315 | 5 3
316 | 5 4
317 | 
318 | output:
319 | L 4
320 | L 5
321 | R 1
322 | R 2
323 | */        
324 |         
325 | // Or solve this problem :https://leetcode.com/problems/maximum-students-taking-exam/description/
326 | 


--------------------------------------------------------------------------------
/GP Hash .cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | // Remember to use this only wheeen need to access large number of data , and only unordered map is useful
 3 | 
 4 | //use this hash function  , highly recommended
 5 | struct custom_hash {
 6 |     static uint64_t splitmix64(uint64_t x) {
 7 |         x += 0x9e3779b97f4a7c15;
 8 |         x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
 9 |         x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
10 |         return x ^ (x >> 31);
11 |     }
12 | 
13 |     size_t operator()(uint64_t x) const {
14 |         static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
15 |         return splitmix64(x + FIXED_RANDOM);
16 |     }
17 | }; //For long long int to long long int
18 | 
19 | 
20 | typedef gp_hash_table<int,int,custom_hash>table;
21 | 
22 | 
23 | 
24 | 
25 | 
26 | 
27 | //
28 | //struct chash {
29 | //    int operator()(pair<int,int> x) const { return x.first* 31 + x.second; }
30 | //};
31 | //gp_hash_table<pair<int,int>, int, chash> table;
32 | 
33 | 
34 | //This was for {pair to int} mapping
35 | 
36 | 
37 | int32_t main()
38 | {
39 |         ios::sync_with_stdio(0);
40 |         cin.tie(0);
41 | 
42 |        //gp_hash_table<int,int,custom_hash> m;          can do this too
43 | 
44 |         table m;
45 | 
46 | 
47 |         m[1]++;
48 |         m[2]++;
49 |         m[1]++;
50 |         m[1]++;
51 | 
52 |         cout<<m[1]<<endl; // works exactly like unordered map but wayyyyyyy faster
53 |         cout<<m[0]<<endl;
54 |         cout<<m[2]<<endl;
55 | 
56 | 
57 | 
58 | }
59 | 
60 | 
61 | 
62 | 
63 | 
64 | // NOTE: for BIT of fenwick tree , hash function need to be modified specifically , so For now just remember that , when needed just search gp_hash_table for BIT
65 | // useful : https://github.com/mochow13/competitive-programming-library/blob/master/Data%20Structures/GP%20Hash%20Table.cpp
66 | 


--------------------------------------------------------------------------------
/Game Theory ( MEX , Sprague-Grundy Number Calculation).cpp:
--------------------------------------------------------------------------------
 1 | https://lightoj.com/problem/partitioning-game
 2 | 
 3 | 
 4 | // Add some code//Intermediary
 5 | //Young kid on the block
 6 | //AIAsif try's Continuing the journey
 7 | #include<bits/stdc++.h>
 8 | #include <ext/pb_ds/assoc_container.hpp>
 9 | #include <ext/pb_ds/tree_policy.hpp>
10 | using namespace std;
11 | using namespace __gnu_pbds;
12 | #define endl "\n"
13 | #define int long long int
14 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
15 | 
16 | const int N = 1e4+100;
17 | int dp[N];
18 | int calculateMex(unordered_set<int> &s)
19 | {
20 |         int mex = 0;
21 |         while(s.find(mex)!=s.end())
22 |         {
23 |                 mex++;
24 |         }
25 |         return mex;
26 | }
27 | 
28 | int grundy(int n) //depending on the problem this function can be very different ....... Look at the light oj various Sprague-Grundy Number problems 
29 | {
30 |         if(n<3)
31 |         {
32 |                 dp[n] = 0;
33 |                 return 0;
34 |         }
35 |         if(dp[n]!=-1)
36 |         {
37 |                 return dp[n];
38 |         }
39 | 
40 |         int left = n/2;
41 | 
42 |         if(n%2==0)
43 |         {
44 |                 left--;
45 |         }
46 | 
47 |         unordered_set<int>s;
48 | 
49 |         for(int i=1;i<=left;i++)
50 |         {
51 |                 s.insert(grundy(i)^grundy(n-i));
52 |         }
53 | 
54 |         dp[n] = calculateMex(s);
55 | 
56 |         return dp[n];
57 | }
58 | 
59 | int32_t main()
60 | {
61 |         ios::sync_with_stdio(0);
62 |         cin.tie(0);
63 | 
64 |         int t;
65 |         cin>>t;
66 | 
67 |         memset(dp,-1,sizeof(dp));
68 | 
69 |         for(int tt=1;tt<=t;tt++)
70 |         {
71 |                 int n;
72 |                 cin>>n;
73 | 
74 |                 int Xor = 0;
75 | 
76 |                 for(int i=0;i<n;i++)
77 |                 {
78 |                         int a;
79 |                         cin>>a;
80 | 
81 |                         Xor ^= grundy(a);
82 |                 }
83 | 
84 |                 cout<<"Case "<<tt<<": "<<((Xor)?"Alice":"Bob")<<endl;
85 |         }
86 | 
87 |         return 0;
88 | 
89 | 
90 | }
91 | 


--------------------------------------------------------------------------------
/Gaussian Elimination.cpp:
--------------------------------------------------------------------------------
  1 | //Intermediary
  2 | //Young kid on the block
  3 | //AIAsif try's Continuing the journey
  4 | #include<bits/stdc++.h>
  5 | #include <ext/pb_ds/assoc_container.hpp>
  6 | #include <ext/pb_ds/tree_policy.hpp>
  7 | using namespace std;
  8 | using namespace __gnu_pbds;
  9 | #define endl "\n"
 10 | #define int long long int
 11 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
 12 | 
 13 | 
 14 | const double eps = 1e-9;
 15 | 
 16 | int Gauss(vector<vector<double>> a, vector<double> &ans)
 17 | {
 18 |         int n = (int)a.size(), m = (int)a[0].size() - 1;
 19 |         vector<int> pos(m, -1);
 20 |         double det = 1;
 21 |         int rank = 0;
 22 | 
 23 | 
 24 |         for (int col = 0, row = 0; col < m && row < n; ++col)
 25 |         {
 26 |                 int mx = row;
 27 |                 for (int i = row; i < n; i++)
 28 |                 {
 29 |                         if (fabs(a[i][col]) > fabs(a[mx][col]))
 30 |                         {
 31 |                                 mx = i;
 32 |                         }
 33 |                                 
 34 |                 }
 35 |                         
 36 |                 if (fabs(a[mx][col]) < eps)
 37 |                 {
 38 |                         det = 0;
 39 |                         continue;
 40 |                 }
 41 |                 for (int i = col; i <= m; i++)
 42 |                 {
 43 |                         swap(a[row][i], a[mx][i]);
 44 |                 }
 45 |                         
 46 |                 if (row != mx)
 47 |                 {
 48 |                         det = -det;
 49 |                 }
 50 |                        
 51 |                 det *= a[row][col];
 52 |                 pos[col] = row;
 53 |                 for (int i = 0; i < n; i++)
 54 |                 {
 55 |                         if (i != row && fabs(a[i][col]) > eps)
 56 |                         {
 57 |                                 double c = a[i][col] / a[row][col];
 58 |                                 for (int j = col; j <= m; j++)
 59 |                                 {
 60 |                                         a[i][j] -= a[row][j] * c;
 61 |                                 }
 62 |                                         
 63 |                         }
 64 |                 }
 65 |                 ++row;
 66 |                 ++rank;
 67 |         }
 68 |         ans.assign(m, 0);
 69 |         for (int i = 0; i < m; i++)
 70 |         {
 71 |                 if (pos[i] != -1)
 72 |                 {
 73 |                         ans[i] = a[pos[i]][m] / a[pos[i]][i];
 74 |                 }
 75 |                         
 76 |         }
 77 |         for (int i = 0; i < n; i++)
 78 |         {
 79 |                 double sum = 0;
 80 |                 for (int j = 0; j < m; j++)
 81 |                 {
 82 |                         sum += ans[j] * a[i][j];
 83 |                 }
 84 |                        
 85 |                 if (fabs(sum - a[i][m]) > eps)
 86 |                 {
 87 |                         return -1; // no solution
 88 |                 }
 89 |                         
 90 |         }
 91 |         for (int i = 0; i < m; i++)
 92 |         {
 93 |                 if (pos[i] == -1)
 94 |                 {
 95 |                         return 2; // infinte solutions
 96 |                 }
 97 |                         
 98 |         }
 99 |                 
100 |         return 1;                 // unique solution
101 | }
102 | 
103 | 
104 | 
105 | 
106 | int32_t main()
107 | {
108 |         ios::sync_with_stdio(0);
109 |         cin.tie(0);
110 | 
111 | 
112 |         int n, m;
113 |         cin >> n >> m;
114 |         
115 |         vector<vector<double>> v(n);
116 |         for (int i = 0; i < n; i++)
117 |         {
118 |                 for (int j = 0; j <= m; j++) // m-th colunm contain the value of constant
119 |                 {
120 |                         double x;
121 |                         cin >> x;
122 |                         v[i].push_back(x);
123 |                 }
124 |         }
125 |         vector<double> ans;
126 | 
127 |         int k = Gauss(v, ans);
128 | 
129 |         if (k)
130 |         {
131 |                 for (int i = 0; i < n; i++)
132 |                 {
133 |                         cout << fixed << setprecision(5) << ans[i] << ' ';
134 |                 }
135 |                         
136 |         }  
137 |         else
138 |         {
139 |                  cout << "no solution"<<endl;
140 |         }
141 |                
142 |         return 0;
143 | 
144 | 
145 | }
146 | 


--------------------------------------------------------------------------------
/Heavy Light Decomposition ( Sum Update Query on Vertex ).cpp:
--------------------------------------------------------------------------------
  1 | //Arfatul Islam Asif
  2 | 
  3 | //This supports Range update , which euler tour doesnt
  4 | 
  5 | 
  6 | //The technique is All heavy path er node gula visit hobe consecutive time eeee
  7 | //So segment tree based on visit time will provide query ans for two vertex who are on same Heavy Path
  8 | 
  9 | 
 10 | const int N = 2e5+100;
 11 | vector<int>graph[N];
 12 | int level[N];
 13 | 
 14 | 
 15 | //LCA Part
 16 | const int L = log2(N);
 17 | int lca_din[N];
 18 | int lca_dout[N];
 19 | int up[N][L+1];
 20 | int tim_lca;
 21 | 
 22 | 
 23 | 
 24 | 
 25 | //SEGMENT Tree Part
 26 | int n; // to be taken input as no of vertex
 27 | struct node
 28 | {
 29 |         int val;
 30 |         int lazy;
 31 | } Tree[4*N] ;
 32 | int ara[N];
 33 | int tin[N]; // most important array , in this array vertex on same heavy chain will have consecutive visiting time , [for vertex no it will give visiting no ] [ segment tree is built on visiting no]
 34 |             // tin[v]  = v visiting time
 35 | int tout[N];
 36 | int vis_tim_vertex[N];  // visiting time dile vertex no return korbe [for build() in segment tree ]
 37 | int nxt[N]; //for DSU part
 38 | int subtree[N];
 39 | int tim;
 40 | 
 41 | 
 42 | 
 43 | 
 44 | //LCA
 45 | 
 46 | void dfs(int s,int par,int lev)
 47 | {
 48 |         lca_din[s] = tim_lca++;
 49 |         up[s][0] = par;
 50 |         level[s] = lev;
 51 | 
 52 |         for(int i=1;i<=L;i++)
 53 |         {
 54 |                 up[s][i] = up[up[s][i-1]][i-1];
 55 |         }
 56 | 
 57 |         for(auto child: graph[s])
 58 |         {
 59 |                 if(child==par)
 60 |                 {
 61 |                         continue;
 62 |                 }
 63 |                 dfs(child,s,lev+1);
 64 |         }
 65 |         lca_dout[s] = tim_lca++;
 66 | 
 67 | }
 68 | 
 69 | bool is_ancestor(int u,int v)
 70 | {
 71 |         return (lca_din[u]<=lca_din[v] && lca_dout[u]>=lca_dout[v]);
 72 | }
 73 | 
 74 | int lca(int u,int v)
 75 | {
 76 |         if(is_ancestor(u,v))
 77 |         {
 78 |                 return u;
 79 |         }
 80 |         if(is_ancestor(v,u))
 81 |         {
 82 |                 return v;
 83 |         }
 84 | 
 85 |         for(int i=L;i>=0;i--)
 86 |         {
 87 |                 if(!is_ancestor(up[u][i] , v))
 88 |                 {
 89 |                         u = up[u][i];
 90 |                 }
 91 |         }
 92 |         return up[u][0];
 93 | }
 94 | 
 95 | 
 96 | 
 97 | 
 98 | //Heavy edge on graph[s][0]
 99 | 
100 | void dfs1(int s, int par)
101 | {
102 | 
103 |         subtree[s] = 1;
104 | 
105 |         for(auto &child : graph[s]) // & child pathate hobe
106 |         {
107 |                 if(child==par)
108 |                 {
109 |                         continue;
110 |                 }
111 | 
112 |                 dfs1(child,s);
113 | 
114 |                 subtree[s] += subtree[child];
115 | 
116 |                 if(subtree[child]>subtree[graph[s][0]])
117 |                 {
118 |                         swap(child,graph[s][0]); // &child pathate hobe for swap operation
119 |                 }
120 | 
121 |         }
122 | 
123 | }
124 | 
125 | 
126 | 
127 | 
128 | //Heavy light decomposition er DSU part
129 | void dfs_hld(int s,int par)
130 | {
131 | 
132 |         tin[s] = ++tim;
133 |         vis_tim_vertex[tim] = s;
134 | 
135 |         for(auto child : graph[s])
136 |         {
137 |                 if(child==par)
138 |                 {
139 |                         continue;
140 |                 }
141 | 
142 |                 if(child==graph[s][0])
143 |                 {
144 |                         nxt[child] = nxt[s]; // heavy child gulake ekta dsu chain he haralam , nxt[child] = chain er up most vertex return korbe
145 |                 }
146 |                 else
147 |                 {
148 |                         nxt[child] = child;
149 |                 }
150 | 
151 |                 dfs_hld(child,s);
152 | 
153 |         }
154 |         tout[s] = tim;
155 | }
156 | 
157 | 
158 | 
159 | 
160 | 
161 | 
162 | 
163 | void propagate(int node ,int lo,int hi)
164 | {
165 |         int temp = Tree[node].lazy;
166 | 
167 |         Tree[node*2].lazy += temp;
168 |         Tree[node*2+1].lazy += temp;
169 | 
170 |         int mid = (lo+hi)>>1;
171 | 
172 |         Tree[node*2].val += (mid-lo+1)*temp;  // lazy pawar sathey sathey value node e add kore dilam jate query er somoy add kora na lage
173 |         Tree[node*2+1].val += (hi-(mid+1)+1)*temp; // lazy pawar sathey sathey value node e add kore dilam jate query er somoy add kora na lage
174 | 
175 |         Tree[node].lazy = 0;
176 | }
177 | 
178 | 
179 | void build(int node,int lo,int hi) // indexing visiting time diye
180 | {
181 |         if(lo==hi)
182 |         {
183 |                 Tree[node].val = ara[vis_tim_vertex[lo]]; // lo th time e je vertex visit hobe te holo vis_tim_vertex[lo]
184 |                 return;
185 |         }
186 | 
187 |         int mid = (lo+hi)>>1;
188 | 
189 |         build(node*2,lo,mid);
190 |         build(node*2+1,mid+1,hi);
191 | 
192 |         Tree[node].val = Tree[node*2].val + Tree[node*2+1].val;
193 | }
194 | 
195 | 
196 | void update(int node,int lo,int hi,int i,int j ,int val)
197 | {
198 |         if(Tree[node].lazy>0)
199 |         {
200 |                 propagate(node,lo,hi);
201 |         }
202 |         if(hi<i || lo>j)
203 |         {
204 |                 return;
205 |         }
206 |         if(lo>=i && hi<=j)
207 |         {
208 |                 Tree[node].val += (hi-lo+1)*val;
209 |                 Tree[node].lazy += val;
210 |                 return;
211 |         }
212 | 
213 |         int mid = (lo+hi)>>1;
214 | 
215 |         update(node*2 , lo , mid , i, j,val);
216 |         update(node*2+1 , mid+1 , hi, i, j, val);
217 | 
218 |         Tree[node].val = Tree[node*2].val + Tree[node*2+1].val;
219 | 
220 | }
221 | 
222 | int query(int node,int lo,int hi,int i,int j)
223 | {
224 |         if(Tree[node].lazy>0)
225 |         {
226 |                 propagate(node,lo,hi);
227 |         }
228 |         if(hi<i || lo>j)
229 |         {
230 |                 return 0;
231 |         }
232 |         if(lo>=i && hi<=j)
233 |         {
234 |                 return Tree[node].val;
235 |         }
236 | 
237 |         int mid = (lo+hi)>>1;
238 | 
239 |         int x = query(node*2,lo,mid,i,j);
240 |         int y = query(node*2+1,mid+1,hi,i,j);
241 | 
242 |         return x+y;
243 | }
244 | 
245 | 
246 | 
247 | 
248 | 
249 | //Queries  Started
250 | 
251 | int dist(int u,int v) // given unweighted edges
252 | {
253 |         return level[u]+level[v] - 2*level[lca(u,v)];
254 | }
255 | 
256 | 
257 | 
258 | 
259 | int query_up(int l,int u) // l is ancestor of u
260 | {
261 |         int res = 0;
262 |         while(nxt[u]!=nxt[l])
263 |         {
264 |                 res += query(1,1,n, tin[nxt[u]] , tin[u]);
265 |                 u = up[nxt[u]][0]; //next heavy chain e jump
266 |         }
267 | 
268 |         res += query(1,1, n , tin[l] , tin[u]); // l included
269 | 
270 |         return res;
271 | }
272 | 
273 | int sum_query_hld(int u,int v)
274 | {
275 |         if(is_ancestor(u,v))
276 |         {
277 |                 return query_up(u,v);
278 |         }
279 |         if(is_ancestor(v,u))
280 |         {
281 |                 return query_up(v,u);
282 |         }
283 | 
284 |         int l = lca(u,v);
285 |         int x = query_up(l,u);
286 |         int y = query_up(l,v);
287 | 
288 |         return x+y - query_up(l,l); // l would be counted twice since it is vertex query
289 | }
290 | 
291 | 
292 | void update_up(int l,int u,int val) // l is ancestor of u
293 | {
294 |         while(nxt[u]!=nxt[l])
295 |         {
296 |                 update(1,1,n,tin[nxt[u]],tin[u],val);
297 |                 u = up[nxt[u]][0];
298 |         }
299 |         update(1,1,n,tin[l],tin[u],val); // including l
300 | }
301 | 
302 | void update_query_hld(int u,int v,int val) // u to v er path e thaka sob vertex er value er sathe val add
303 | {
304 |         if(is_ancestor(u,v))
305 |         {
306 |                 update_up(u,v,val);
307 |                 return;
308 |         }
309 |         if(is_ancestor(v,u))
310 |         {
311 |                 update_up(v,u,val);
312 |                 return;
313 |         }
314 |         int l = lca(u,v);
315 |         update_up(l,u,val);
316 |         update_up(l,v,val);
317 | 
318 |         update_up(l,l,-val); // l updated twice thats why ekber minus
319 | 
320 | }
321 | 
322 | 
323 | void hld()
324 | {
325 |         dfs(1,1,1); // for LCA up[1][0] = 1; for is_ancestor to work properly
326 | 
327 |         dfs1(1,0);
328 | 
329 |         dfs_hld(1,0);
330 | 
331 |         build(1,1,n);
332 | }
333 | 
334 | 
335 | 
336 | 
337 | 
338 | int32_t main()
339 | {
340 |         ios::sync_with_stdio(0);
341 |         cin.tie(0);
342 | 
343 |         cin>>n;
344 | 
345 |         for(int i=1;i<=n;i++)
346 |         {
347 |                 cin>>ara[i];
348 |         }
349 | 
350 |         for(int i=0;i<n-1;i++)
351 |         {
352 |                 int x,y;
353 |                 cin>>x>>y;
354 |                 graph[x].push_back(y);
355 |                 graph[y].push_back(x);
356 |         }
357 | 
358 |         hld();
359 | 
360 |         int q;
361 |         cin>>q;
362 | 
363 |         cout<<"Ans to the queries: "<<endl;
364 | 
365 |         while(q--)
366 |         {
367 |                 int a;
368 |                 cin>>a;
369 |                 if(a==1)
370 |                 {
371 |                         int u,v,x;
372 |                         cin>>u>>v>>x;
373 |                         update_query_hld(u,v,x);
374 |                 }
375 |                 else
376 |                 {
377 |                         int u, v;
378 |                         cin>>u>>v;
379 |                         cout<<sum_query_hld(u,v)<<endl;
380 |                 }
381 |         }
382 | 
383 |         return 0;
384 | 
385 | 
386 | 
387 | }
388 | 
389 | 
390 | /*
391 | 
392 | 12
393 | 
394 | 4 10 9 6 7 6 4 1 3 2 7 9
395 | 
396 | 1 2
397 | 1 3
398 | 3 4
399 | 3 5
400 | 4 8
401 | 4 9
402 | 2 6
403 | 2 7
404 | 7 10
405 | 7 11
406 | 10 12
407 | 
408 | 18
409 | 2 3 3
410 | 2 1 7
411 | 1 5 7 10
412 | 2 3 2
413 | 2 2 3
414 | 1 9 12 1
415 | 2 9 12
416 | 2 9 11
417 | 2 1 7
418 | 1 4 8 100
419 | 2 8 9
420 | 2 1 1
421 | 2 9 9
422 | 2 4 4
423 | 2 7 7
424 | 2 11 11
425 | 1 9 9 1
426 | 2 9 9
427 | 
428 | Ans to the queries:
429 | 9
430 | 18
431 | 53
432 | 53
433 | 95
434 | 89
435 | 51
436 | 212
437 | 15
438 | 4
439 | 107
440 | 15
441 | 7
442 | 5
443 | 
444 | 
445 | */
446 | 


--------------------------------------------------------------------------------
/Inclusion Exclusion .cpp:
--------------------------------------------------------------------------------
  1 | // excellent problem on  inclusion exclusion
  2 | // Nailed By me ,,, only only meee
  3 | 
  4 | Solution of the Problem is given below 
  5 | https://codeforces.com/contest/1295/problem/D
  6 | 
  7 | 
  8 | const int N = 1e6;
  9 | bool sieve[N];
 10 | vector<int>prime;
 11 | 
 12 | void pre()
 13 | {
 14 |         memset(sieve , true, sizeof(sieve));
 15 | 
 16 |         for(int i=2;i<N;i++)
 17 |         {
 18 |                 if(sieve[i])
 19 |                 {
 20 |                         for(int j=2;i*j<N;j++)
 21 |                         {
 22 |                                 sieve[i*j] = false;
 23 |                         }
 24 |                 }
 25 |         }
 26 |         for(int i=2;i<N;i++)
 27 |         {
 28 |                 if(sieve[i])
 29 |                 {
 30 |                         prime.push_back(i);
 31 |                 }
 32 |         }
 33 | }
 34 | 
 35 | map<int,int> fact(int n)
 36 | {
 37 |         map<int,int>m;
 38 | 
 39 |         for(int i=0;i<prime.size();i++)
 40 |         {
 41 |                 while(n%prime[i]==0)
 42 |                 {
 43 |                         m[prime[i]]++;
 44 |                         n/=prime[i];
 45 |                 }
 46 |         }
 47 |         if(n>1)
 48 |         {
 49 |                 m[n]++;
 50 |         }
 51 | 
 52 |         return m;
 53 | }
 54 | 
 55 | int32_t main()
 56 | {
 57 |         ios::sync_with_stdio(0);
 58 |         cin.tie(0);
 59 | 
 60 |         pre();
 61 | 
 62 |         int t;
 63 |         cin>>t;
 64 | 
 65 |         while(t--)
 66 |         {
 67 |                 int a,m;
 68 |                 cin>>a>>m;
 69 | 
 70 |                 int test = __gcd(a,m);
 71 | 
 72 |                 map<int,int>fact1;
 73 |                 map<int,int>fact2;
 74 | 
 75 |                 fact1 = fact(m);
 76 | 
 77 |                 fact2 = fact(test);
 78 | 
 79 |                 if(test!=1)
 80 |                 {
 81 |                         for(auto x : fact2)
 82 |                         {
 83 |                                 fact1[x.first]-=x.second;
 84 |                         }
 85 |                 }
 86 | 
 87 | 
 88 |                 vector<int>v;
 89 | 
 90 |                 for(auto x : fact1)
 91 |                 {
 92 |                         if(x.second!=0)
 93 |                         {
 94 |                                 v.push_back(x.first);
 95 |                         }
 96 |                 }
 97 | 
 98 |                 int ans = (a+m-1)/test - (a-1)/test ;
 99 | 
100 |                 for(int i=1;i<(1<<v.size()); i++)
101 |                 {
102 |                         int num = __builtin_popcountll(i);
103 | 
104 |                         int mul = 1;
105 | 
106 |                         for(int j=0;j<20;j++)
107 |                         {
108 |                                 if(i&(1<<j))
109 |                                 {
110 |                                         mul *= v[j];
111 |                                 }
112 |                         }
113 |                         if(num%2==0)
114 |                         {
115 |                                 mul *= test;
116 |                                 ans += (a+m-1)/mul - (a-1)/mul;
117 |                         }
118 |                         else
119 |                         {
120 |                                 mul *= test;
121 |                                 ans -= (a+m-1)/mul - (a-1)/mul;
122 |                         }
123 |                 }
124 | 
125 |                 cout<<ans<<endl;
126 | 
127 |         }
128 | 
129 |         return 0;
130 | 
131 | 
132 | }
133 | 


--------------------------------------------------------------------------------
/Johnson’s algorithm for All-pairs shortest paths.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | // Finding all pair shortest path using Repeated dijkstra from each vertex to all other.
  3 | // But the thing is dijkstra does not works for negative edges. So,
  4 | // Using a bellman-ford edge shifting techniques , new weight = w(u, v) + h[u] - h[v], we transform the graph in a way so that weight becomes non-negative weight.
  5 | // Here the potential function h[] is used to "normalize" the graph by shifting the edge weights in such a way that all edges have non-negative weights. 
  6 | // Finally we after performing dijkstra from each vertex u, we find distance(u,v) = dijkstra(u, v) + h[v] - h[u].
  7 | 
  8 | 
  9 | 
 10 | // Remember it does not works for graph with negative cycle.
 11 | // Time complexity O(V^2log V + VE)
 12 | 
 13 | 
 14 | const int N = 1e5+10;
 15 | 
 16 | vector<pair<int,int>> graph[N], altered_graph[N];
 17 | 
 18 | int dist[N];
 19 | int vis[N];
 20 | 
 21 | void dijkstra(int ss, int V) 
 22 | {
 23 |         for (int i = 0; i < V; i++) 
 24 |         {
 25 |                 dist[i] = inf;
 26 |                 vis[i] = false;
 27 |         }
 28 | 
 29 |         dist[ss] = 0;
 30 |         priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;
 31 |         pq.push({0, ss});
 32 | 
 33 |         while (!pq.empty()) 
 34 |         {
 35 |                 int father = pq.top().second;
 36 |                 pq.pop();
 37 | 
 38 |                 if (vis[father]) continue;
 39 |                 vis[father] = true;
 40 | 
 41 |                 for (auto child : altered_graph[father]) 
 42 |                 {
 43 |                         int v = child.first;
 44 |                         int vw = child.second;
 45 |                         if (vis[v]) continue;
 46 |                         if (dist[v] > dist[father] + vw) 
 47 |                         {
 48 |                                 dist[v] = dist[father] + vw;
 49 |                                 pq.push({dist[v], v});
 50 |                         }
 51 |                 }
 52 |         }
 53 | }
 54 | 
 55 | vector<int> bellmanFord(int V) 
 56 | {
 57 |         vector<int> dist(V, inf);
 58 |         dist[V - 1] = 0;
 59 | 
 60 |         for (int i = 0; i < V - 1; i++) 
 61 |         {
 62 |                 for (int u = 0; u < V; u++) 
 63 |                 {
 64 |                         for (auto edge : graph[u]) 
 65 |                         {
 66 |                                 int v = edge.first;
 67 |                                 int weight = edge.second;
 68 |                                 if (dist[u] != inf && dist[u] + weight < dist[v]) 
 69 |                                 {
 70 |                                         dist[v] = dist[u] + weight;
 71 |                                 }
 72 |                         }
 73 |                 }
 74 |         }
 75 | 
 76 |         for (int u = 0; u < V; u++) {
 77 |                 for (auto edge : graph[u]) {
 78 |                         int v = edge.first;
 79 |                         int weight = edge.second;
 80 |                         if (dist[u] != inf && dist[u] + weight < dist[v]) 
 81 |                         {
 82 |                                 cout << "Negative weight cycle detected!" << endl;
 83 |                                 exit(0);
 84 |                         }
 85 |                 }
 86 |         }
 87 | 
 88 |         return dist;
 89 | }
 90 | 
 91 | void johnsonAlgorithm(int V) {
 92 |         for (int i = 0; i < V; i++) 
 93 |         {
 94 |                 graph[V].push_back({i, 0});
 95 |         }
 96 | 
 97 |         vector<int> h = bellmanFord(V + 1); // The potential function h[] is used to "normalize" the graph by shifting the edge weights in such a way that all edges have non-negative weights
 98 | 
 99 |         for (int i = 0; i < V; i++) 
100 |         {
101 |                 for (auto& edge : graph[i])
102 |                  {
103 |                         int v = edge.first;
104 |                         int weight = edge.second;
105 |                         altered_graph[i].push_back({v, weight + h[i] - h[v]});
106 |                 }
107 |         }
108 | 
109 |         for (int u = 0; u < V; u++) 
110 |         {
111 |                 cout << "Shortest Distance from vertex " << u << ":"<<endl;
112 |                 dijkstra(u, V);
113 | 
114 |                 
115 | 
116 |                 for (int v = 0; v < V; v++) 
117 |                 {
118 |                         cout<<"Vertex: "<<v<<" dist: ";
119 | 
120 |                         if(dist[v]==inf)
121 |                         {
122 |                                 cout<<"INF"<<endl;
123 |                                 continue;
124 |                         }
125 |                         cout << dist[v] + h[v] - h[u] << endl;
126 |                 }
127 |                 cout << endl;
128 |         }
129 | }
130 | 
131 | int32_t main() {
132 |         ios::sync_with_stdio(0);
133 |         cin.tie(0);
134 |         
135 |         vector<vector<int>> input = {
136 |                 {0, -5, 2, 3},
137 |                 {0, 0, 4, 0},
138 |                 {0, 0, 0, 1},
139 |                 {0, 0, 0, 0}
140 |         };
141 | 
142 |         for (int i = 0; i < 4; i++) 
143 |         {
144 |                 for (int j = 0; j < 4; j++) 
145 |                 {
146 |                         if (input[i][j] != 0) 
147 |                         {
148 |                                 graph[i].push_back({j, input[i][j]});
149 |                         }
150 |                 }
151 |         }
152 | 
153 |         johnsonAlgorithm(4);
154 | 
155 |         return 0;
156 | }
157 | 


--------------------------------------------------------------------------------
/LCA in O(1).cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | // ============= Euler Tour type -  03 ========== LCA in O(1) ============
  4 | 
  5 | // ET3 = 1 2 3 2 4 6 4 7 4 2 5 2 1 8 9 8 10 8 1
  6 | 
  7 | // in this tour technique (child - father - child) is always maintained , so between 2 child , their father shall be present (not grand father though)
  8 | // So query(u,v) means :
  9 | //                u first appear in ET3 and v first appear in ET3 er moddhe jetar depth lowest setai LCA ;
 10 | //                we find this using sparse table O(1) , segment tree O(logn)
 11 | 
 12 | 
 13 | const int N = 1e5;
 14 | vector<int>graph[N];
 15 | vector<int>ET3;
 16 | vector<int>p(N,-1); //p[v] = v first appear in ET3;
 17 | bool vis[N];
 18 | int dept[N];
 19 | const int L = log2(N);
 20 | int st[N][L+1];
 21 | int Log2[N];
 22 | 
 23 | void dfs(int s)
 24 | {
 25 |         vis[s] = true;
 26 |         ET3.push_back(s);
 27 |         for(auto child: graph[s])
 28 |         {
 29 |                 if(vis[child])
 30 |                 {
 31 |                         continue;
 32 |                 }
 33 |                 dept[child] = dept[s]+1;
 34 | 
 35 |                 dfs(child);
 36 | 
 37 |                 ET3.push_back(s);
 38 |         }
 39 | }
 40 | 
 41 | void pre()
 42 | {
 43 |         Log2[0] = 0;
 44 |         Log2[1] = 0;
 45 |         Log2[2] = 1;
 46 |         for(int i=3;i<N;i++)
 47 |         {
 48 |                 Log2[i] = Log2[i/2]+1;
 49 |         }
 50 | }
 51 | 
 52 | void sparse_table()
 53 | {
 54 |         for(int i=0;i<ET3.size();i++)
 55 |         {
 56 |                 st[i][0] = ET3[i];
 57 |         }
 58 | 
 59 |         int l = Log2[ET3.size()];
 60 | 
 61 |         for(int i=1;i<=l;i++)
 62 |         {
 63 |                 for(int j=0;j+(1<<i)<=ET3.size();j++) // j+(1<<i)-1<ET3.size()
 64 |                 {
 65 |                         int a = st[j][i-1];
 66 | 
 67 |                         int b = st[j+(1<<(i-1))][i-1];
 68 | 
 69 |                         //Sort of like dp
 70 |                         //instead of storing the minimum , We are storing the Vertex with minimum detph
 71 | 
 72 |                         if(dept[a]<dept[b])
 73 |                         {
 74 |                                 st[j][i] = a;
 75 |                         }
 76 |                         else
 77 |                         {
 78 |                                 st[j][i] = b;
 79 |                         }
 80 |                 }
 81 |         }
 82 | }
 83 | 
 84 | int32_t main()
 85 | {
 86 |         ios::sync_with_stdio(0);
 87 |         cin.tie(0);
 88 | 
 89 |         pre();
 90 | 
 91 | 
 92 |         int n;
 93 |         cin>>n;
 94 |         for(int i=0;i<n-1;i++)
 95 |         {
 96 |                 int x,y;
 97 |                 cin>>x>>y;
 98 |                 graph[x].push_back(y);
 99 |                 graph[y].push_back(x);
100 |         }
101 | 
102 |         dfs(1);
103 | 
104 |         for(int i=0;i<ET3.size();i++)
105 |         {
106 |                 if(p[ET3[i]]==-1)
107 |                 {
108 |                         p[ET3[i]] = i;
109 |                 }
110 |         }
111 | 
112 |         sparse_table();
113 | 
114 | 
115 |         int q;
116 |         cin>>q;
117 | 
118 | 
119 |         cout<<"LCAs : "<<endl;
120 |         while(q--)
121 |         {
122 |                 int u,v;
123 |                 cin>>u>>v;
124 | 
125 | 
126 |                 int a = min(p[v],p[u]); // p[u] first pos of u , p[v] first pos of v in ET3;
127 |                 int b = max(p[v],p[u]);
128 | 
129 |                 int i = Log2[b-a+1];
130 | 
131 |                 int vertex1 = st[a][i];
132 |                 int vertex2 = st[b-(1<<i)+1][i];
133 | 
134 |                 if(dept[vertex1]<dept[vertex2])
135 |                 {
136 |                         cout<<vertex1<<endl;
137 |                 }
138 |                 else
139 |                 {
140 |                         cout<<vertex2<<endl;
141 |                 }
142 | 
143 | 
144 |         }
145 | 
146 | 
147 | 
148 |         return 0;
149 | 
150 | 
151 | 
152 | 
153 | }
154 | /*
155 | 
156 | 10
157 | 1 2
158 | 2 3
159 | 2 4
160 | 2 5
161 | 4 6
162 | 4 7
163 | 1 8
164 | 8 9
165 | 8 10
166 | 
167 | 6
168 | 1 8
169 | 8 7
170 | 6 7
171 | 10 9
172 | 3 4
173 | 3 5
174 | 
175 | O/P:
176 | 
177 | LCAs :
178 | 1
179 | 1
180 | 4
181 | 8
182 | 2
183 | 2
184 | 
185 | 
186 | 
187 | 
188 | */
189 | 
190 | 


--------------------------------------------------------------------------------
/LCA with Binary lifting.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | const int N = 1e5+100;
  4 | vector<int>graph[N];
  5 | bool vis[N];
  6 | int din[N];
  7 | int dout[N];
  8 | int tin = 0;
  9 | const int L = log2(N);
 10 | int up[N][L+1];
 11 | 
 12 | void dfs(int s,int par)
 13 | {
 14 |         vis[s] = true;
 15 |         din[s] = tin++;
 16 | 
 17 |         up[s][0] = par;
 18 | 
 19 |         for(int i=1;i<=L;i++)
 20 |         {
 21 |                 up[s][i] = up[ up[s][i-1] ][i-1]; // Here is the binary lifting is occuring try for this graph ( 1->2 , 2->3 , 3->4 , 4->5,5->6,6->7,7->8,8->9,9->10) then s = 10 er jonno eta draw kore buja
 22 |         }
 23 | 
 24 | 
 25 |         for(auto child : graph[s])
 26 |         {
 27 |                 if(vis[child])
 28 |                 {
 29 |                         continue;
 30 |                 }
 31 |                 dfs(child,s);
 32 |         }
 33 |         dout[s] = tin++;
 34 | }
 35 | 
 36 | bool is_ancestor(int u,int v) // u is ancestor of v
 37 | {
 38 |         if(din[u]<=din[v] && dout[u]>=dout[v])
 39 |         {
 40 |                 return true;
 41 |         }
 42 |         return false;
 43 | }
 44 | 
 45 | 
 46 | 
 47 | int lca(int u,int v)
 48 | {
 49 |         if(is_ancestor(u,v))
 50 |         {
 51 |                 return u;
 52 |         }
 53 |         if(is_ancestor(v,u))
 54 |         {
 55 |                 return v;
 56 |         }
 57 |         for(int i=L;i>=0;i--)
 58 |         {
 59 |                 if(!is_ancestor(up[u][i] ,v))  // ancestor na hole jump dissi                                [up[1][0] = 1 na hole ei part kaj korbe na]
 60 |                 {
 61 |                         u = up[u][i];
 62 |                 }
 63 |         }
 64 |         return up[u][0];
 65 | 
 66 | }
 67 | 
 68 | 
 69 | int32_t main()
 70 | {
 71 |         ios::sync_with_stdio(0);
 72 |         cin.tie(0);
 73 |         int n,m;
 74 |         cin>>n>>m;
 75 | 
 76 |         for(int i=0;i<m;i++)
 77 |         {
 78 |                 int x,y;
 79 |                 cin>>x>>y;
 80 |                 graph[x].push_back(y);
 81 |                 graph[y].push_back(x);
 82 |         }
 83 | 
 84 |         dfs(1,1); // parent of 1 should be 1 i.e. up[1][0] = 1;
 85 | 
 86 |         int q;
 87 |         cin>>q;
 88 |         while(q--)
 89 |         {
 90 |                 int u,v;
 91 |                 cin>>u>>v;
 92 |                 cout<<lca(u,v)<<endl;
 93 |         }
 94 | 
 95 | 
 96 | 
 97 | 
 98 | }
 99 | 
100 | 
101 | 
102 | 
103 | /*
104 | 7 6
105 | 1 2
106 | 1 3
107 | 2 4
108 | 2 5
109 | 3 6
110 | 3 7
111 | 5
112 | 4 5
113 | 5 6
114 | 7 2
115 | 6 7
116 | 6 3
117 | 
118 | 
119 | o/p
120 | 2
121 | 1
122 | 1
123 | 3
124 | 3
125 | 
126 | */
127 | 


--------------------------------------------------------------------------------
/Longest Path In A DAG O(V+E).cpp:
--------------------------------------------------------------------------------
  1 | =========================== LONGEST PATH IN DAG ===============
  2 | ================================================================
  3 | IT is a NP HARD For normall undirected graph
  4 | ================================================================
  5 | 
  6 | // LONGEST PATH in a undirected graph or NON DAG graph is a NP-Hard problem
  7 | // however Longest Path in a DAG is O(V+E) problem using topo sort
  8 | //using normall dijkstra in a LONgest path in a graph problem wont work , cause it is a NP HARD PROBLEM
  9 | 
 10 | // Modified dijkstra is a OK on DAG
 11 | 
 12 | // best is using topo Sort + O(V+E) approach
 13 | 
 14 | 
 15 | // LONGEST PATH IN A DAG
 16 | // Using topo sort  O(V+E) formula
 17 | 
 18 | 
 19 | const int inf = 1e18;
 20 | const int N = 1e5+100;
 21 | vector<int>graph[N];
 22 | int in[N];
 23 | vector<int>dis(N,-inf);
 24 | int parent[N];
 25 | 
 26 | int32_t main()
 27 | {
 28 |         ios::sync_with_stdio(0);
 29 |         cin.tie(0);
 30 |         int n,m;
 31 |         cin>>n>>m;
 32 |         for(int i=0;i<m;i++)
 33 |         {
 34 |                 int x,y;
 35 |                 cin>>x>>y;
 36 |                 graph[x].push_back(y);
 37 |                 in[y]++;
 38 |         }
 39 |         queue<int>q;
 40 | 
 41 |         for(int i=1;i<=n;i++)
 42 |         {
 43 |                 if(in[i]==0)
 44 |                 {
 45 |                         q.push(i);
 46 |                 }
 47 |         }
 48 |         vector<int>topo;
 49 |         while(!q.empty())
 50 |         {
 51 |                 int father = q.front();
 52 |                 topo.push_back(father);
 53 |                 q.pop();
 54 | 
 55 | 
 56 |                 for(auto child: graph[father])
 57 |                 {
 58 |                         in[child]--;
 59 |                         if(in[child]==0)
 60 |                         {
 61 |                                 q.push(child);
 62 |                         }
 63 |                 }
 64 |         }
 65 | 
 66 |         dis[1] = 0;
 67 | 
 68 |         for(auto s : topo)
 69 |         {
 70 |                 if(dis[s]!=-inf)
 71 |                 {
 72 |                         for(auto child: graph[s])
 73 |                         {
 74 |                                 if(dis[child]<dis[s]+1)
 75 |                                 {
 76 |                                         parent[child] = s;
 77 |                                         dis[child] = dis[s]+1;
 78 |                                 }
 79 |                         }
 80 |                 }
 81 |         }
 82 | 
 83 | 
 84 | 
 85 |         if(dis[n]==-inf)
 86 |         {
 87 |                 cout<<"IMPOSSIBLE"<<endl;
 88 |                 return 0;
 89 |         }
 90 | 
 91 | 
 92 | 
 93 |         int v = n;
 94 | 
 95 |         vector<int>ans;
 96 | 
 97 |         while(v!=0)
 98 |         {
 99 |                 ans.push_back(v);
100 |                 v = parent[v];
101 |         }
102 |         reverse(ans.begin(),ans.end());
103 | 
104 |         cout<<ans.size()<<endl;
105 | 
106 |         for(auto x : ans)
107 |         {
108 |                 cout<<x<<" ";
109 |         }
110 |         cout<<endl;
111 | 
112 | 
113 | }
114 | 


--------------------------------------------------------------------------------
/MO's Algorithm (K-th Minimum in Range).cpp:
--------------------------------------------------------------------------------
  1 | //all Numbers are distinct thats why ordered_set and MO's algorithm works  . Else use MergeSort Tree
  2 | 
  3 | 
  4 | //spoj mkth number soln : TLE (but should works on faster judge)
  5 | 
  6 | 
  7 | 
  8 | const int N = 1e5+10;
  9 | const int M = 5000+10;
 10 | 
 11 | int ans[M];
 12 | 
 13 | 
 14 | struct Query
 15 | {
 16 |     int l, r, k ,  idx;
 17 | 
 18 | };
 19 | 
 20 | int block;
 21 | 
 22 | bool cmp(Query a, Query b)
 23 | {
 24 |         if(a.l/block == b.l/block)
 25 |         {
 26 |                 return a.r<b.r;
 27 |         }
 28 |         return (a.l/block)<(b.l/block);
 29 | }
 30 | 
 31 | vector<Query>Q;
 32 | 
 33 | 
 34 | //All NUMBERS are different thats why this solution works using Ordered_SET
 35 | 
 36 | void results(vector<int> &v , int m)
 37 | {
 38 | 
 39 |         block = sqrt(v.size()+0.0);  // USE block = 666; way faster
 40 | 
 41 |         sort(Q.begin() , Q.end() , cmp);
 42 | 
 43 |         int currL = 0;
 44 |         int currR = 0;
 45 | 
 46 | 
 47 | 
 48 |         ordered_set S;
 49 | 
 50 |         for(int i=0;i<m;i++)
 51 |         {
 52 |                 int L = Q[i].l;
 53 |                 int R = Q[i].r;
 54 |                 int k = Q[i].k;
 55 |                 int idx = Q[i].idx;
 56 | 
 57 |                 while(currL>L)
 58 |                 {
 59 |                         S.insert(v[currL-1]);
 60 |                         currL--;
 61 |                 }
 62 |                 while(currR<=R)
 63 |                 {
 64 |                         S.insert(v[currR]);
 65 |                         currR++;
 66 |                 }
 67 | 
 68 |                 while(currL<L)
 69 |                 {
 70 |                         int a = v[currL];
 71 |                         S.erase(a);
 72 |                         currL++;
 73 |                 }
 74 | 
 75 |                 while(currR>R+1)
 76 |                 {
 77 |                         int a = v[currR-1];
 78 |                         S.erase(a);
 79 |                         currR--;
 80 |                 }
 81 | 
 82 | 
 83 |                 ans[idx] = *S.find_by_order(k-1); // 0 based bole k-1 will refer to k-th
 84 | 
 85 |         }
 86 | 
 87 | 
 88 | }
 89 | 
 90 | 
 91 | int32_t main()
 92 | {
 93 |         ios::sync_with_stdio(0);
 94 |         cin.tie(0);
 95 | 
 96 |         int n,m;
 97 |         cin>>n>>m;
 98 | 
 99 |         vector<int>v;
100 | 
101 |         for(int i=0;i<n;i++)
102 |         {
103 |                 int a;
104 |                 cin>>a;
105 |                 v.push_back(a);
106 |         }
107 | 
108 |         for(int g=0;g<m;g++)
109 |         {
110 |                 int i,j,k;
111 |                 cin>>i>>j>>k;
112 |                 Q.push_back({i-1,j-1,k,g});
113 |         }
114 | 
115 |         results(v,m);
116 | 
117 |         for(int i=0;i<m;i++)
118 |         {
119 |                 cout<<ans[i]<<endl;
120 |         }
121 | 
122 | 
123 | 
124 | 
125 | 
126 | }
127 | 


--------------------------------------------------------------------------------
/MST Krushkal .cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | const int N = 1e5;
  3 | int parent[N];
  4 | int sz[N];
  5 | vector<pair<int, pair<int,int>>>edge;
  6 | vector<pair<pair<int,int> , int>>MST;
  7 | int mstCost = 0;
  8 | 
  9 | 
 10 | void make(int v)
 11 | {
 12 |         parent[v] = v;
 13 |         sz[v] = 1;
 14 | }
 15 | 
 16 | int find(int v)
 17 | {
 18 |         if(v==parent[v])
 19 |         {
 20 |                 return v;
 21 |         }
 22 |         return parent[v] = find(parent[v]);
 23 | }
 24 | 
 25 | void Union(int a,int b)
 26 | {
 27 |         a = find(a);
 28 |         b = find(b);
 29 |         if(a!=b)
 30 |         {
 31 |                 if(sz[a]<sz[b])
 32 |                 {
 33 |                         swap(a,b);
 34 |                 }
 35 |                 parent[b] = a;
 36 |                 sz[a] += sz[b];
 37 |         }
 38 | }
 39 | 
 40 | void Krushkal()
 41 | {
 42 |         for(auto x : edge)
 43 |         {
 44 |                 int w = x.first;
 45 |                 int u = x.second.first;
 46 |                 int v = x.second.second;
 47 |                 if(find(u)!=find(v))
 48 |                 {
 49 |                         MST.push_back({{u , v} , w });
 50 |                         mstCost += w;
 51 |                         Union(u,v);
 52 |                 }
 53 |         }
 54 | }
 55 | 
 56 | 
 57 | int32_t main()
 58 | {
 59 |         ios::sync_with_stdio(0);
 60 |         cin.tie(0);
 61 |         int n,m;
 62 |         cin>>n>>m;
 63 |         for(int i=0;i<m;i++)
 64 |         {
 65 |                 int x,y,w;
 66 |                 cin>>x>>y>>w;
 67 |                 edge.push_back({w , { x , y }});
 68 |         }
 69 |         sort(edge.begin() , edge.end());
 70 |         for(int i=1;i<=n;i++) // 1 based
 71 |         {
 72 |                 make(i);
 73 |         }
 74 |         Krushkal();
 75 | 
 76 |         cout<<"----------"<<endl;
 77 |         cout<<mstCost<<endl;
 78 | 
 79 |         for(auto x : MST)
 80 |         {
 81 |                 cout<<x.first.first<<" "<<x.first.second<<" "<<x.second<<endl;
 82 |         }
 83 | 
 84 |         return 0;
 85 | 
 86 | 
 87 | 
 88 | }
 89 | 
 90 | /*
 91 | 6 9
 92 | 5 4 9
 93 | 1 4 1
 94 | 5 1 4
 95 | 4 3 5
 96 | 4 2 3
 97 | 1 2 2
 98 | 3 2 3
 99 | 3 6 8
100 | 2 6 7
101 | 
102 | */
103 | 


--------------------------------------------------------------------------------
/MST Prims .cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | const int N = 1e5;
 3 | int inf = 1e18;
 4 | vector<pair<int,int>>graph[N];
 5 | vector<int>key(N , inf);
 6 | vector<int>parent(N,-1);
 7 | int mstCost = 0;
 8 | int vis[N];
 9 | 
10 | void Prims(int s)
11 | {
12 |         priority_queue< pair<int,int> , vector<pair<int,int>> , greater<pair<int,int>> > pq;
13 |         key[s] = 0;
14 |         pq.push({0,s});
15 |         parent[s] = -1;
16 |         while(!pq.empty())
17 |         {
18 |                 int father = pq.top().second;
19 | 
20 |                 if(vis[father]==false)
21 |                 {
22 |                         mstCost += pq.top().first;
23 |                         vis[father] = true;
24 |                 }
25 | 
26 |                 pq.pop();
27 |                 for(auto child : graph[father])
28 |                 {
29 |                         if(vis[child.first])
30 |                         {
31 |                                 continue;
32 |                         }
33 |                         if(child.second < key[child.first]) // Note e leka ase why , tar por oo fresh mind a 2,1 ta mST draw kore buja jay . Try the graph attach below
34 |                         {
35 |                                 key[child.first] = child.second;
36 |                                 parent[child.first] = father;
37 |                                 pq.push({child.second , child.first});
38 |                         }
39 |                 }
40 |         }
41 |         return;
42 | }
43 | 
44 | int32_t main()
45 | {
46 |         ios::sync_with_stdio(0);
47 |         cin.tie(0);
48 |         int n,m;
49 |         cin>>n>>m;
50 |         for(int i=0;i<m;i++)
51 |         {
52 |                 int x,y,w;
53 |                 cin>>x>>y>>w;
54 |                 graph[x].push_back({y,w});
55 |                 graph[y].push_back({x,w});
56 |         }
57 |         Prims(1);
58 |         cout<<"------"<<endl;
59 |         cout<<mstCost<<endl;
60 |         for(int i=1;i<=n;i++)
61 |         {
62 |                 if(parent[i]==-1)
63 |                 {
64 |                         continue;
65 |                 }
66 |                 cout<<i<<" "<<parent[i]<<endl;
67 |         }
68 | 
69 |         return 0;
70 | 
71 | 
72 | }
73 | 
74 | 
75 | /*
76 | 4 5
77 | 1 2 2
78 | 1 3 7
79 | 2 3 6
80 | 1 4 5
81 | 4 3 1
82 | 
83 | */
84 | 


--------------------------------------------------------------------------------
/Matrix Exponentiation .cpp:
--------------------------------------------------------------------------------
 1 | // Finding the n-th term of a linear recurrance relation in logn time
 2 | 
 3 | 
 4 | vector<vector<int>>Multiply (vector<vector<int>> &one , vector<vector<int>> &two) //pass them as reference to save time
 5 | {
 6 |         vector<vector<int>>res;
 7 |         int D = one.size();
 8 |         for(int i=0;i<D;i++)
 9 |         {
10 |                 vector<int>temp;
11 |                 for(int j=0;j<D;j++)
12 |                 {
13 |                         int cnt = 0;
14 |                         for(int k=0;k<D;k++)
15 |                         {
16 |                                 cnt += one[i][k]*two[k][j];
17 |                         }
18 |                         temp.push_back(cnt);
19 |                 }
20 |                 res.push_back(temp);
21 |         }
22 |         return res;
23 | 
24 | }
25 | 
26 | 
27 | 
28 | 
29 | vector<vector<int>> Mat_Ex(vector<vector<int>> Mat , int b)  //don't pass Mat as reference
30 | {
31 |         vector<vector<int>> ans
32 |                 {
33 |                         {1,0},
34 |                         {0,1}
35 |                 }; //Identity Matrix {Adjust its dimension according to Mat
36 | 
37 |         while(b>0)
38 |         {
39 |                 if(b&1)
40 |                 {
41 |                         ans = Multiply(ans,Mat);
42 |                 }
43 |                 Mat = Multiply(Mat,Mat);
44 |                 b>>=1;
45 |         }
46 | 
47 |         return ans;
48 | 
49 | }
50 | 
51 | int32_t main()
52 | {
53 |         ios::sync_with_stdio(0);
54 |         cin.tie(0);
55 | 
56 |         // For finding nth fibbonacci
57 |         vector<vector<int>>Mat{
58 |                 {1,1},
59 |                 {1,0}
60 |                 };
61 | 
62 |         int n;
63 | 
64 |         cin>>n;   //n>2
65 | 
66 |         cout<<Mat_Ex(Mat , n-2)[0][0]<<endl;
67 | 
68 | 
69 |         return 0;
70 | 
71 | 
72 | }
73 | 


--------------------------------------------------------------------------------
/Merge Sort Tree (k-th minimum in range) .cpp:
--------------------------------------------------------------------------------
  1 | //Intermediary
  2 | //Young kid on the block
  3 | //AIAsif try's "Continuing the journey"
  4 | 
  5 | //concept is using segment tree , where each node will store indexes in sorted order : kind of like MergeSort
  6 | 
  7 | //K-th minimum in Range :
  8 | 
  9 | const int N = 1e5+10;
 10 | 
 11 | vector<int>Tree[4*N]; // each node will store (indexes) in sorted order
 12 | vector<pair<int,int>>A;
 13 | 
 14 | 
 15 | void build(int node,int lo,int hi)
 16 | {
 17 |         if(lo==hi)
 18 |         {
 19 |                 Tree[node].push_back(A[lo].second); // indexex will be stored at every node in sorted order
 20 |                 return;
 21 |         }
 22 | 
 23 |         int mid = (lo+hi)>>1;
 24 | 
 25 |         build(node*2,lo,mid);
 26 |         build(node*2+1 , mid+1,hi);
 27 | 
 28 |         merge(Tree[node*2].begin() , Tree[node*2].end() , Tree[node*2+1].begin() , Tree[node*2+1].end() , back_inserter(Tree[node])); // this merge fuction works excatly like merge in mergeSort [watch gfg]
 29 | 
 30 | 
 31 | }
 32 | 
 33 | int query(int node ,int lo,int hi,int i,int j,int k)
 34 | {
 35 |         if(lo==hi)
 36 |         {
 37 |                 return Tree[node][0];
 38 |         }
 39 |         int mid = (lo+hi)>>1;
 40 | 
 41 |         int a = lower_bound(Tree[node*2].begin() , Tree[node*2].end() , i)-Tree[node*2].begin();
 42 |         int b = upper_bound(Tree[node*2].begin() , Tree[node*2].end() , j)-Tree[node*2].begin();
 43 | 
 44 |         int M = b-a; // [i:j] range er moddhe koyta indexes ase in Tree[node*2] Tee
 45 | 
 46 |         if(M>=k)
 47 |         {
 48 |                 //Tree[node*2] tee thaka indexes er songkha greater than K hoy taile k-th minimum er index will exits here
 49 |                 return query(node*2 , lo , mid , i , j , k);
 50 |         }
 51 |         else
 52 |         {
 53 |                 //let say k = 6 and M = 4 :
 54 |                 //er ortho hocce [i:j] range er 4 ta indexes exists kore Tree[node*2] te
 55 | 
 56 |                 // baki 2 ta indexes exits here : k-M
 57 | 
 58 |                 //Keep in mind that elements at the right childs > elements at the left childs . thats why we have to pass k-M here to get k-th minimum number er index
 59 | 
 60 |                 return query(node*2+1 , mid+1 , hi , i , j , k-M);
 61 |         }
 62 | 
 63 | 
 64 | }
 65 | 
 66 | 
 67 | int32_t main()
 68 | {
 69 |         ios::sync_with_stdio(0);
 70 |         cin.tie(0);
 71 | 
 72 |         int n , q;
 73 |         cin>>n>>q;
 74 | 
 75 |         vector<int>v;
 76 |         for(int i=0;i<n;i++)
 77 |         {
 78 |                 int a;
 79 |                 cin>>a;
 80 |                 v.push_back(a);
 81 |         }
 82 | 
 83 |         for(int i=0;i<n;i++)
 84 |         {
 85 |                 A.push_back({v[i] , i}); // indexes are  0-based
 86 |         }
 87 | 
 88 |         sort(A.begin() , A.end()); // according to first element Indexes will be sorted too
 89 | 
 90 |         build(1,0,n-1);
 91 | 
 92 |         while(q--)
 93 |         {
 94 |                 int i,j,k;
 95 |                 cin>>i>>j>>k; //i,j 1-based
 96 | 
 97 |                 int kthminimumdx = query(1,0,n-1,i-1,j-1,k);  // pass 0-based
 98 | 
 99 |                 cout<<v[kthminimumdx]<<endl;
100 |         }
101 | 
102 |         return 0;
103 | 
104 | 
105 | 
106 | 
107 | 
108 | 
109 | }
110 | 


--------------------------------------------------------------------------------
/Mobius Function.cpp:
--------------------------------------------------------------------------------
  1 | // Mobius inclusion exclusion
  2 | 
  3 | // Finding the number of co-primes pairs
  4 | 
  5 | 
  6 |    
  7 | const int N = 1e6+100;
  8 | int cnt[N];
  9 | bool sieve[N];
 10 | int mobius[N];
 11 | int D[N];
 12 | int arr[N];
 13 | 
 14 | void pre()
 15 | {
 16 |         memset(sieve, true, sizeof(sieve));
 17 | 
 18 |         for(int i=2;i<N;i++)
 19 |         {
 20 |                 if(sieve[i])
 21 |                 {
 22 |                         cnt[i] = 1;
 23 | 
 24 |                         for(int j=i+i;j<N;j += i)
 25 |                         {
 26 |                                 sieve[j] = false;
 27 | 
 28 |                                 if(cnt[j] == -1)
 29 |                                 {
 30 |                                         continue;
 31 |                                 }
 32 | 
 33 |                                 cnt[j]++;
 34 | 
 35 |                                 if(j % (i*i) ==0)
 36 |                                 {
 37 |                                         cnt[j] = -1;
 38 |                                 }
 39 |                         }
 40 |                 }
 41 |         }
 42 | 
 43 |         mobius[1] = 1;
 44 |         mobius[2] = -1;
 45 | 
 46 |         for(int i=3;i<N;i++)
 47 |         {
 48 |                 if(cnt[i]==-1)
 49 |                 {
 50 |                         mobius[i] = 0;
 51 |                 }
 52 |                 else if(cnt[i]%2==0)
 53 |                 {
 54 |                         mobius[i] = 1;
 55 |                 }
 56 |                 else 
 57 |                 {
 58 |                         mobius[i] = -1;
 59 |                 }
 60 |         }
 61 | 
 62 | 
 63 | }
 64 | 
 65 | 
 66 | int32_t main()
 67 | {
 68 |         ios::sync_with_stdio(0);
 69 |         cin.tie(0);
 70 | 
 71 |         int n;
 72 |         cin>>n;
 73 | 
 74 |         vector<int>v;
 75 |         for(int i=0;i<n;i++)
 76 |         {
 77 |                 int a;
 78 |                 cin>>a;
 79 |                 v.push_back(a);
 80 |                 arr[a]++;
 81 |         }
 82 | 
 83 |         pre();
 84 | 
 85 |         for(int d = N-50; d >= 1; d--)
 86 |         {
 87 |                 int count = 0;
 88 |                 for(int i = d; i<N; i += d)
 89 |                 {
 90 |                         count += arr[i];
 91 |                 }
 92 | 
 93 |                 D[d] = count;
 94 |         }
 95 | 
 96 | 
 97 |         int ans = n*(n-1);
 98 |         ans /= 2;
 99 | 
100 |         for(int i=2;i<N;i++)
101 |         {
102 |                 ans += mobius[i]* (D[i]*(D[i]-1))/2; // Here mobius[i] works as a sign for inclusion exclusion.
103 | 
104 |                 
105 |         }
106 | 
107 |         cout<<ans<<endl;
108 | 
109 | 
110 | 
111 | }
112 | 


--------------------------------------------------------------------------------
/Monotonic Stack.cpp:
--------------------------------------------------------------------------------
  1 | https://leetcode.com/discuss/study-guide/2347639/A-comprehensive-guide-and-template-for-monotonic-stack-based-problems
  2 | 
  3 | 
  4 | https://leetcode.com/discuss/study-guide/2703748/Monotonic-stack-study-summary [For Topic Wise]
  5 | 1. Next greater / lesser problem , Previous greater / lesser problem:
  6 | 2. Construct binary tree from given array
  7 | 3. Subsequece problem[Very Important]
  8 | 5. Subarray problem [Very Very Important , counting sub array with maximum , minimum property]
  9 | 6. monotonic queue together with binary search
 10 | 7. Monotonic stack but manily compare current with top of stack then determine whether add or not current
 11 | 10. Sort subarry / remove subarry in order to make whole array ascending
 12 | 
 13 | 
 14 | ===================== 1.Next Greater =================
 15 | //Intermediary
 16 | //Young kid on the block
 17 | //AIAsif try's Continuing the journey
 18 | #include<bits/stdc++.h>
 19 | #include <ext/pb_ds/assoc_container.hpp>
 20 | #include <ext/pb_ds/tree_policy.hpp>
 21 | using namespace std;
 22 | using namespace __gnu_pbds;
 23 | #define endl "\n"
 24 | #define int long long int
 25 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
 26 | 
 27 | //Next Greater Element 
 28 | //Monotonic non-increasing stack 
 29 | 
 30 | int32_t main()
 31 | {
 32 |         ios::sync_with_stdio(0);
 33 |         cin.tie(0);
 34 | 
 35 |         int n;
 36 |         cin>>n;
 37 |         vector<int>v;
 38 | 
 39 |         for(int i=0;i<n;i++)
 40 |         {
 41 |                 int a;
 42 |                 cin>>a;
 43 |                 v.push_back(a);
 44 |         }
 45 |         vector<int>nxtGreater(n,-1); // keep the indices
 46 |         
 47 |         stack<int>s;
 48 |         
 49 |         for(int i=0;i<n;i++)
 50 |         {
 51 |                 while(!s.empty() && v[s.top()]<v[i])
 52 |                 {
 53 |                         nxtGreater[s.top()] = i;
 54 |                         s.pop();
 55 |                 }
 56 |                 s.push(i);
 57 |         }
 58 | 
 59 |         for(int i=0;i<n;i++)
 60 |         {
 61 |                 cout<<nxtGreater[i]<<" ";
 62 |         }
 63 |         cout<<endl;
 64 | 
 65 | 
 66 | 
 67 | }
 68 | 
 69 | 
 70 | 
 71 | =========================== 2. Previous Greater ==============
 72 | //Intermediary
 73 | //Young kid on the block
 74 | //AIAsif try's Continuing the journey
 75 | #include<bits/stdc++.h>
 76 | #include <ext/pb_ds/assoc_container.hpp>
 77 | #include <ext/pb_ds/tree_policy.hpp>
 78 | using namespace std;
 79 | using namespace __gnu_pbds;
 80 | #define endl "\n"
 81 | #define int long long int
 82 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
 83 | 
 84 | //Previous Greater Element
 85 | //Monotonic strickly decreasing stack
 86 | 
 87 | int32_t main()
 88 | {
 89 |         ios::sync_with_stdio(0);
 90 |         cin.tie(0);
 91 | 
 92 |         int n;
 93 |         cin>>n;
 94 |         vector<int>v;
 95 | 
 96 |         for(int i=0;i<n;i++)
 97 |         {
 98 |                 int a;
 99 |                 cin>>a;
100 |                 v.push_back(a);
101 |         }
102 | 
103 |         vector<int>prevGreater(n,-1);//keeps the indexes
104 | 
105 |         stack<int>st;
106 | 
107 |         for(int i=0;i<n;i++)
108 |         {
109 |                 while(!st.empty() && v[st.top()]<= v[i])
110 |                 {
111 |                         st.pop();
112 |                 }
113 | 
114 |                 if(!st.empty())
115 |                 {
116 |                         prevGreater[i] = st.top();
117 |                 }
118 |                 st.push(i);
119 |         }
120 | 
121 |         for(int i=0;i<n;i++)
122 |         {
123 |                 cout<<prevGreater[i]<<" ";
124 |         }
125 |         cout<<endl;
126 | 
127 | 
128 | }
129 | 
130 | 
131 | 
132 | ================================== 3. Next Smaller (strictly smaller) ==========
133 | 
134 | //Intermediary
135 | //Young kid on the block
136 | //AIAsif try's Continuing the journey
137 | #include<bits/stdc++.h>
138 | #include <ext/pb_ds/assoc_container.hpp>
139 | #include <ext/pb_ds/tree_policy.hpp>
140 | using namespace std;
141 | using namespace __gnu_pbds;
142 | #define endl "\n"
143 | #define int long long int
144 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
145 | 
146 | //Next Smaller Element
147 | //Monotonic non-decreasing stack
148 | 
149 | int32_t main()
150 | {
151 |         ios::sync_with_stdio(0);
152 |         cin.tie(0);
153 | 
154 |         int n;
155 |         cin>>n;
156 |         vector<int>v;
157 | 
158 |         for(int i=0;i<n;i++)
159 |         {
160 |                 int a;
161 |                 cin>>a;
162 |                 v.push_back(a);
163 |         }
164 | 
165 |         vector<int>nxtSmaller(n,-1); // indexes
166 | 
167 |         stack<int>st;
168 | 
169 |         for(int i=0;i<n;i++)
170 |         {
171 |                 while(!st.empty() && v[st.top()]> v[i])
172 |                 {
173 |                         
174 |                         nxtSmaller[st.top()] = i;
175 |                         st.pop();
176 |                 }
177 |                 st.push(i);
178 |         }
179 | 
180 |         for(int i=0;i<n;i++)
181 |         {
182 |                 cout<<nxtSmaller[i]<<" ";
183 |         }
184 |         cout<<endl;
185 | 
186 | }
187 | 
188 | 
189 | 
190 | 
191 | ============================= 4. Previous Smaller (strictly smaller) ========
192 | 
193 | //Intermediary
194 | //Young kid on the block
195 | //AIAsif try's Continuing the journey
196 | #include<bits/stdc++.h>
197 | #include <ext/pb_ds/assoc_container.hpp>
198 | #include <ext/pb_ds/tree_policy.hpp>
199 | using namespace std;
200 | using namespace __gnu_pbds;
201 | #define endl "\n"
202 | #define int long long int
203 | #define ordered_set tree< int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>
204 | 
205 | //Previous smaller element
206 | //Monotonic increasing stack
207 | 
208 | int32_t main()
209 | {
210 |         ios::sync_with_stdio(0);
211 |         cin.tie(0);
212 |         
213 |         int n;
214 |         cin>>n;
215 |         vector<int>v;
216 | 
217 |         for(int i=0;i<n;i++)
218 |         {
219 |                 int a;
220 |                 cin>>a;
221 |                 v.push_back(a);
222 |         }
223 | 
224 |         vector<int>prevSmaller(n,-1); //indexes
225 | 
226 |         stack<int>st;
227 |         for(int i=0;i<n;i++)
228 |         {
229 |                 while(!st.empty() && v[st.top()]>=v[i])
230 |                 {
231 |                         st.pop();
232 |                 }
233 |                 if(!st.empty())
234 |                 {
235 |                         prevSmaller[i] = st.top();
236 |                 }
237 |                 st.push(i);
238 |         }
239 | 
240 |         for(int i=0;i<n;i++)
241 |         {
242 |                 cout<<prevSmaller[i]<<" ";
243 |         }
244 |         cout<<endl;
245 | 
246 | 
247 | 
248 | }
249 | 
250 | 
251 | 
252 | 


--------------------------------------------------------------------------------
/Negative Cycle Printing .cpp:
--------------------------------------------------------------------------------
 1 | //AIA
 2 | 
 3 | //using floyed printing neg cycle
 4 | 
 5 | const int N = 2e4;
 6 | int dis[N];
 7 | int relaxtant[N]; // it is like parent[N] array
 8 | 
 9 | int32_t main()
10 | {
11 |         ios::sync_with_stdio(0);
12 |         cin.tie(0);
13 | 
14 |         int n,m;
15 |         cin>>n>>m;
16 |         vector<tuple<int,int,int>>edges;
17 | 
18 |         for(int i=0;i<m;i++)
19 |         {
20 |                 int x,y,w;
21 |                 cin>>x>>y>>w;
22 |                 edges.push_back({x,y,w});
23 |         }
24 |         int take;
25 | 
26 |         for(int i=1;i<n+1;i++)
27 |         {
28 |                 take = -1;
29 |                 for(auto &[u,v,w]:edges)
30 |                 {
31 |                         if(dis[v]>dis[u]+w)
32 |                         {
33 |                                 dis[v] = dis[u]+w;
34 |                                 take = v;
35 |                                 relaxtant[v] = u;
36 |                         }
37 |                 }
38 |         }
39 | 
40 |         if(take==-1)
41 |         {
42 |                 cout<<"NO"<<endl;
43 |                 return 0;
44 |         }
45 | 
46 |         cout<<"YES"<<endl;
47 | 
48 |         int v = relaxtant[take];
49 | 
50 | 
51 | 
52 |         //The followings is very important
53 |         for(int i=1;i<n+1;i++)
54 |         {
55 |                  v = relaxtant[v];            // if there is a negative cycle eventually v will trace back to it ,, even there exits a positive cycly it wont matter relaxtant wont trace to it
56 |                                               //it will eventually fall into the negetive cycle
57 | 
58 |         }
59 | 
60 | 
61 |         vector<int>ans;
62 | 
63 |         for(int u = v ; ; u = relaxtant[u])
64 |         {
65 |                 ans.push_back(u);
66 |                 if(u==v && ans.size()>1)
67 |                 {
68 |                         break;
69 |                 }
70 |         }
71 | 
72 |         reverse(ans.begin(),ans.end());
73 | 
74 |         for(auto x : ans)
75 |         {
76 |                 cout<<x<<" ";
77 |         }
78 |         cout<<endl;
79 | 
80 |         return 0;
81 | 
82 | }
83 | 


--------------------------------------------------------------------------------
/Order Multiset Template.cpp:
--------------------------------------------------------------------------------
  1 | ============= order multi - set template === add this to github using oop === 
  2 | 
  3 | 
  4 | 
  5 | 
  6 | //Intermediary
  7 | //Young kid on the block
  8 | //AIAsif try's Continuing the journey
  9 | #include<bits/stdc++.h>
 10 | #include <ext/pb_ds/assoc_container.hpp>
 11 | #include <ext/pb_ds/tree_policy.hpp>
 12 | using namespace std;
 13 | #define endl "\n"
 14 | #define inf 1000000000000000000
 15 | #define int long long int
 16 | 
 17 | namespace __gnu_pbds{
 18 |           typedef tree<int,
 19 |                        null_type,
 20 |                        less_equal<int>,
 21 |                        rb_tree_tag,
 22 |                        tree_order_statistics_node_update> ordered_set;
 23 | }
 24 | using namespace __gnu_pbds;
 25 | 
 26 |  
 27 | void Insert(ordered_set &s,int x){ //this function inserts one more occurrence of (x) into the set.
 28 |  
 29 |      s.insert(x);
 30 |  
 31 | }
 32 |  
 33 |  
 34 | bool Exist(ordered_set &s,int x){ //this function checks weather the value (x) exists in the set or not.
 35 |  
 36 |      if((s.upper_bound(x))==s.end()){
 37 |         return 0;
 38 |      }
 39 |      return ((*s.upper_bound(x))==x);
 40 |  
 41 | }
 42 |  
 43 |  
 44 | void Erase(ordered_set &s,int x){ //this function erases one occurrence of the value (x).
 45 |  
 46 |      if(Exist(s,x)){
 47 |         s.erase(s.upper_bound(x));
 48 |      }
 49 |  
 50 | }
 51 |  
 52 |  
 53 | int FirstIdx(ordered_set &s,int x){ //this function returns the first index of the value (x)..(0 indexing).
 54 |  
 55 |     if(!Exist(s,x)){
 56 |         return -1;
 57 |     }
 58 |     return (s.order_of_key(x));
 59 |  
 60 | }
 61 |  
 62 |  
 63 | int Value(ordered_set &s,int idx){ //this function returns the value at the index (idx)..(0 indexing).
 64 |  
 65 |    return (*s.find_by_order(idx));
 66 |  
 67 | }
 68 |  
 69 |  
 70 | int LastIdx(ordered_set &s,int x){ //this function returns the last index of the value (x)..(0 indexing).
 71 |  
 72 |     if(!Exist(s,x)){
 73 |         return -1;
 74 |     }
 75 |     if(Value(s,(int)s.size()-1)==x){
 76 |         return (int)(s.size())-1;
 77 |     }
 78 |     return FirstIdx(s,*s.lower_bound(x))-1;
 79 |  
 80 | }
 81 |  
 82 |  
 83 | int Count(ordered_set &s,int x){ //this function returns the number of occurrences of the value (x).
 84 |  
 85 |      if(!Exist(s,x)){
 86 |         return 0;
 87 |      }
 88 |      return LastIdx(s,x)-FirstIdx(s,x)+1;
 89 |  
 90 | }
 91 |  
 92 |  
 93 | void Clear(ordered_set &s){ //this function clears all the elements from the set.
 94 |  
 95 |      s.clear();
 96 |  
 97 | }
 98 |  
 99 |  
100 | int Size(ordered_set &s){ //this function returns the size of the set.
101 |  
102 |      return (int)(s.size());
103 |  
104 | }
105 | 
106 | 
107 | 
108 | 
109 | int32_t main()
110 | {
111 |         ios::sync_with_stdio(0);
112 |         cin.tie(0);
113 |         
114 |         //
115 | 
116 | 
117 | }
118 | 


--------------------------------------------------------------------------------
/Persistent Segment Tree (k-th minimum in range).cpp:
--------------------------------------------------------------------------------
  1 | //Works for non-distinct elements too [unlike mo's algo]
  2 | 
  3 | const int M = 5000+100;
  4 | const int N = 100000+100;
  5 | int arr[N];
  6 | 
  7 | struct node
  8 | {
  9 |         int val;
 10 |         node *left;
 11 |         node *right;
 12 | 
 13 |         node(node *l , node *r , int v)
 14 |         {
 15 |                 left = l;
 16 |                 right = r;
 17 |                 val = v;
 18 |         }
 19 | 
 20 | };
 21 | 
 22 | node *version[M];
 23 | 
 24 | //initially building an empty segment tree
 25 | 
 26 | void build(node *n , int lo,int hi)
 27 | {
 28 |         if(lo==hi)
 29 |         {
 30 |                 n->val = 0;
 31 |                 return;
 32 |         }
 33 |         n->left = new node(NULL,NULL,0);
 34 |         n->right = new node(NULL,NULL,0);
 35 | 
 36 |         int mid = (lo+hi)>>1;
 37 | 
 38 |         build(n->left,lo,mid);
 39 |         build(n->right,mid+1,hi);
 40 | 
 41 |         n->val = 0;
 42 | 
 43 | }
 44 | 
 45 | void update(node *prev, node *cur ,int lo,int hi,int pos,int val)
 46 | {
 47 |         if(pos>hi || pos<lo || lo>hi)
 48 |         {
 49 |                 return;
 50 |         }
 51 |         if(lo==hi)
 52 |         {
 53 |                 cur->val = prev->val;  //If elements are not distinct , we need to add previous values too : else just cur->val = 1 would works
 54 |                 cur->val += val;  
 55 | 
 56 |                 return;
 57 |         }
 58 |         int mid = (lo+hi)>>1;
 59 | 
 60 |         if(pos<=mid)
 61 |         {
 62 |                 cur->right = prev->right;
 63 |                 cur->left = new node(NULL , NULL,0);
 64 |                 update(prev->left , cur->left , lo,mid,pos,val);
 65 |         }
 66 |         else
 67 |         {
 68 |                 cur->left = prev->left;
 69 |                 cur->right = new node(NULL , NULL,0);
 70 |                 update(prev->right , cur->right , mid+1,hi,pos,val);
 71 |         }
 72 | 
 73 |         cur->val = cur->left->val + cur->right->val;
 74 | 
 75 | 
 76 | }
 77 | 
 78 | int query(node *j , node *i ,int lo,int hi,int k)
 79 | {
 80 |         if(lo==hi)
 81 |         {
 82 |                 return lo;
 83 |         }
 84 |         int M = (j->left->val) - (i->left->val);
 85 | 
 86 | 
 87 |         int mid = (lo+hi)>>1;
 88 | 
 89 | 
 90 |         if(M>=k)
 91 |         {
 92 |                 return query(j->left,i->left,lo,mid,k);
 93 |         }
 94 |         else
 95 |         {
 96 |                 return query(j->right,i->right,mid+1,hi,k-M);
 97 |         }
 98 | }
 99 | 
100 | int32_t main()
101 | {
102 |         ios::sync_with_stdio(0);
103 |         cin.tie(0);
104 |         int n,m;
105 |         cin>>n>>m;
106 | 
107 |         version[0] = new node(NULL,NULL,0);
108 | 
109 | 
110 |         build(version[0],1,n); // empty segment tree
111 | 
112 |         vector<int>v;
113 | 
114 |         for(int i=1;i<=n;i++)
115 |         {
116 |                 int a;
117 |                 cin>>a;
118 |                 arr[i] = a;
119 |                 v.push_back(a);
120 |         }
121 |         sort(v.begin(),v.end());
122 | 
123 |         for(int i=1;i<=n;i++)
124 |         {
125 |                 arr[i] = lower_bound(v.begin(),v.end(),arr[i])-v.begin() + 1; // converting all the elements to (0 < arr[i] <= n)
126 |                 //Here arr[i] = arr[i]-th element in vector v; //THis makes sure we getting the position rather than the number . This will make sure Histogram fenwick tree < N size
127 |         }
128 | 
129 |         for(int i=1;i<=n;i++)
130 |         {
131 |                 version[i] = new node(NULL,NULL,0); // this line must be here : if we allocate space for versions before here we shall get RUN TIME ERROR due to unused allocations
132 |                 update(version[i-1],version[i],1,n,arr[i],1);
133 |         }
134 | 
135 |         while(m--)
136 |         {
137 |                 int l,r,k;
138 |                 cin>>l>>r>>k;
139 | 
140 |                 int idx = query(version[r],version[l-1],1,n,k);
141 |                 
142 |                 
143 |                 //(idx - 1)-th element in vector V is the ans : [think the Fenwick tree implementation of Order statistices tree 
144 | 
145 |                 cout<<v[idx-1]<<endl;
146 | 
147 | 
148 | 
149 |         }
150 | 
151 |         return 0;
152 | 
153 | 
154 | 
155 | 
156 | }
157 | 


--------------------------------------------------------------------------------
/Pollard Rho ( probabilistic Factorization) Algorithm.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //This is an algorithm For Finding a Divisor of a Number . It is a probabilistic algorithm . 
 3 | //Using BirthDay paradox to explain the probability 
 4 | 
 5 | //And its is a good algorthm for finding a divisior of a Large Number such as N >= 1e15 [ which requres less than 1e6 moves  ]
 6 |                                             [There is a 90% plus probability that using 1e6 Random number we shall get a divisor]
 7 | 
 8 |   
 9 | int cnt = 0;
10 | int Pollard_Rho(int N)
11 | {
12 |         if(N==1)
13 |         {
14 |                 return N;
15 |         }
16 |         if(N%2==0)
17 |         {
18 |                 return 2;
19 |         }
20 | 
21 |         srand(time(NULL));
22 | 
23 |         int x = (rand()%(N-2))+2;
24 |         
25 |         int y = x;
26 | 
27 |         int d = 1;
28 | 
29 |         int c = (rand()%(N-1))+1;
30 | 
31 |         while(d==1)
32 |         {
33 |                 //Tortoise : Slow pointer
34 |                 x = (((x%N)*(x%N))%N + c)%N;
35 | 
36 |                 //Hare : Fast Pointer
37 |                 y = (((y%N)*(y%N))%N + c)%N;
38 |                 y = (((y%N)*(y%N))%N + c)%N;
39 | 
40 |                 d = __gcd( abs(x-y) , N);
41 | 
42 |                 ++cnt;
43 | 
44 |                 if(d==N)  // x mod N = y mod N . which means [ abs(x-y) = N ] eta hole Notun kore abar algorithm chalate hobe 
45 |                 {
46 |                         //Mane Pollard rho loop e pore gese
47 |                         
48 |                         //Notun iteration dorkar hobe 
49 |                         return Pollard_Rho(N);
50 |                 }
51 | 
52 | 
53 |         }
54 | 
55 |         return d;
56 | }
57 | 
58 | int32_t main()
59 | {
60 |         ios::sync_with_stdio(0);
61 |         cin.tie(0);
62 | 
63 | 
64 |         int N = 223007;
65 | 
66 |         N = N*N*N;
67 |         //cin>>N;
68 | 
69 |         int d = Pollard_Rho(N);
70 | 
71 |         cout<<"The Number : "<<N<<endl;
72 | 
73 |         cout<<"Number of Move : "<<cnt<<endl;
74 | 
75 |         cout<<"Divisor: "<<d<<endl;
76 | 
77 |         cout<<"Confirmation : "<<(N%d)<<endl;
78 | 
79 |         return 0;
80 | 
81 | 
82 | 
83 | 
84 | }
85 | 


--------------------------------------------------------------------------------
/Prime Factorization .cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //Just copy this and move on to the solution 
 3 | 
 4 | const int N = 1e6;
 5 | bool sieve[N];
 6 | int lp[N];
 7 | int k;
 8 | 
 9 | 
10 | void pre()
11 | {
12 |         for(int i=0;i<N;i++)
13 |         {
14 |                 sieve[i] = true;
15 |         }
16 |         for(int i=2;i<N;i++)
17 |         {
18 |                 if(sieve[i])
19 |                 {
20 |                         lp[i] = i;
21 |                         for(int j=i+i;j<N;j+=i)
22 |                         {
23 |                                 sieve[j] = false;
24 |                                 if(lp[j]==0)
25 |                                 {
26 |                                         lp[j] = i;
27 |                                 }
28 |                         }
29 |                 }
30 |         }
31 | }
32 | 
33 | map<int,int>fact(int n)
34 | {
35 |         map<int,int>m;
36 | 
37 |         while(n>1)
38 |         {
39 |                 int a = lp[n];
40 |                 m[a]++;
41 |                 n/=lp[n];
42 |         }
43 |         if(n>1)
44 |         {
45 |                 m[n]++;
46 |         }
47 | 
48 |         return m;
49 | 
50 | }
51 | 
52 | 
53 | int32_t main()
54 | {
55 | 
56 |         pre(); // Remember to declare this in the main function
57 | 
58 | 
59 |         int n;
60 |         cin>>n;
61 | 
62 |         map<int,int>m;
63 |         m = fact(n);
64 | 
65 |         for(auto x: m)
66 |         {
67 |                 cout<<x.first<<" "<<x.second<<endl;
68 |         }
69 | 
70 | 
71 | 
72 | 
73 | }
74 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Competitive-programming <img src="zzzzzzzz Batarang.png" width="100"></div> </div> <a href="https://www.linkedin.com/in/arfatul-islam-asif-169116279/">LinkedIn</a> </br>
 2 |                                                                                                          
 3 | In this repository I have stored some of the most used intermediate and advanced level algorithms in competitive programming .
 4 | I have written all the codes by myself  . Before that I myself have learned these algorihms from various blog's . I have written them while maintaing strong modularity , so that when I need to remember a process or an algorithms I can do so just by looking at the codes . I have also commented in the codes where it was necessary . 
 5 | 
 6 | *These codes are written in way which makes them very easy to understand for a beginner or an intermediate level coder .*<br>
 7 | 
 8 | I strongly hope that an intermediate level programmer will benefit highly from my library , as there isn't much resources available for advanced topic's . 
 9 | 
10 | I am currently in the enrichment process of my library . Hope to include almost all the algorithms used by an intermediate or an advanced level cp coder.
11 | 
12 | ```c
13 | #include<studio.h>
14 | int main()
15 | {
16 |     printf("Happy Coding");
17 |     return 0;
18 | }
19 | ```
20 |   
21 | 


--------------------------------------------------------------------------------
/Segment Tree With Lazy Propagation.cpp:
--------------------------------------------------------------------------------
  1 | //Arfatul Islam Asif
  2 | 
  3 | //Sum update Query 
  4 | 
  5 | const int N = 1e5+100;
  6 | 
  7 | struct node
  8 | {
  9 |         int val;
 10 |         int lazy;
 11 | 
 12 | } Tree[4*N];
 13 | 
 14 | int ara[N];
 15 | 
 16 | 
 17 | void propagate(int node,int lo,int hi)
 18 | {
 19 |         int temp = Tree[node].lazy;
 20 | 
 21 |         Tree[node*2].lazy += temp;
 22 |         Tree[node*2+1].lazy += temp;
 23 |         Tree[node].lazy = 0;
 24 | 
 25 |         int mid = (lo+hi)>>1;
 26 | 
 27 |         Tree[node*2].val += (mid-lo+1)*temp;  // lazy pawar sathe sathei  sob node e add  kore disi , tai query korar somoy node er Lazy add korte hobe na
 28 |         Tree[node*2+1].val +=(hi-(mid+1)+1)*temp; // // lazy pawar sathe sathei sob node e add  kore disi , tai query korar somoy node er Lazy add korte hobe na
 29 | }
 30 | 
 31 | 
 32 | void build(int node,int lo,int hi)
 33 | {
 34 |         if(lo==hi)
 35 |         {
 36 |                 Tree[node].val = ara[lo];
 37 |                 return;
 38 |         }
 39 | 
 40 |         int mid = (lo+hi)>>1;
 41 | 
 42 |         build(node*2,lo,mid);
 43 |         build(node*2+1 , mid+1,hi);
 44 | 
 45 |         Tree[node].val = Tree[node*2].val + Tree[node*2+1].val;
 46 | }
 47 | 
 48 | void update(int node,int lo,int hi,int i,int j , int val)
 49 | {
 50 |         if(Tree[node].lazy>0)
 51 |         {
 52 |                 propagate(node,lo,hi);
 53 |         }
 54 |         if(hi<i || lo>j)
 55 |         {
 56 |                 return;
 57 |         }
 58 |         if(lo>=i && hi<=j)
 59 |         {
 60 |                 Tree[node].lazy += val;
 61 |                 Tree[node].val += (hi-lo+1)*val; // ekhanei sob node e add  kore disi , tai query korar somoy node er Lazy add korte hobe na
 62 | 
 63 |                 return;
 64 |         }
 65 | 
 66 |         int mid = (lo+hi)>>1;
 67 |         update(node*2,lo,mid,i,j,val);
 68 |         update(node*2+1,mid+1,hi,i,j,val);
 69 | 
 70 |         Tree[node].val = Tree[node*2].val + Tree[node*2+1].val;
 71 | }
 72 | 
 73 | int query(int node,int lo,int hi,int i,int j)
 74 | {
 75 |         if(Tree[node].lazy>0)
 76 |         {
 77 |                 propagate(node,lo,hi);
 78 |         }
 79 |         if(hi<i || lo>j)
 80 |         {
 81 |                 return 0;
 82 |         }
 83 |         if(lo>=i && hi<=j)
 84 |         {
 85 |                 return Tree[node].val;
 86 |         }
 87 |         int mid = (lo+hi)>>1;
 88 | 
 89 |         int x = query(node*2,lo,mid,i,j);
 90 |         int y = query(node*2+1,mid+1,hi,i,j);
 91 | 
 92 |         return x+y;
 93 | 
 94 | }
 95 | 
 96 | 
 97 | int32_t main()
 98 | {
 99 |         ios::sync_with_stdio(0);
100 |         cin.tie(0);
101 | 
102 |         int n;
103 |         cin>>n;
104 |         for(int i=1;i<=n;i++)
105 |         {
106 |                 cin>>ara[i];
107 |         }
108 | 
109 |         build(1,1,n);
110 | 
111 |         int q;
112 |         cin>>q;
113 |         while(q--)
114 |         {
115 |                 int a;
116 |                 cin>>a;
117 |                 if(a==1)
118 |                 {
119 |                         int i,j,x;
120 |                         cin>>i>>j>>x;
121 |                         update(1,1,n,i,j,x);
122 |                 }
123 |                 else
124 |                 {
125 |                         int i,j;
126 |                         cin>>i>>j;
127 |                         cout<<query(1,1,n,i,j)<<endl;
128 | 
129 |                 }
130 |         }
131 | 
132 |         return 0;
133 | 
134 | 
135 | 
136 | 
137 | }
138 | 
139 | /*
140 | 
141 | 10
142 | 
143 | 1 2 3 4 5 6 7 8 9 10
144 | 
145 | 8
146 | 2 2 4
147 | 2 1 4
148 | 1 2 5 1
149 | 2 2 4
150 | 1 4 10 10
151 | 2 5 7
152 | 1 5 5 100
153 | 2 5 5
154 | 
155 | */
156 | 


--------------------------------------------------------------------------------
/Shortest Path In A DAG O(V+E) .cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | ======================SHORTEST  PATH IN A DAG ========== O(V+E)
  3 | 
  4 | 
  5 | const int inf = 1e18;
  6 | const int N = 1e5+100;
  7 | vector<pair<int,int>>graph[N];
  8 | int in[N];
  9 | vector<int>dis(N,inf);
 10 | int parent[N];
 11 | 
 12 | int32_t main()
 13 | {
 14 |         ios::sync_with_stdio(0);
 15 |         cin.tie(0);
 16 |         int n,m;
 17 |         cin>>n>>m;
 18 |         for(int i=0;i<m;i++)
 19 |         {
 20 |                 int x,y,w;
 21 |                 cin>>x>>y>>w;
 22 |                 graph[x].push_back({y,w});
 23 |                 in[y]++;
 24 |         }
 25 |         queue<int>q;
 26 | 
 27 |         for(int i=1;i<=n;i++)
 28 |         {
 29 |                 if(in[i]==0)
 30 |                 {
 31 |                         q.push(i);
 32 |                 }
 33 |         }
 34 |         vector<int>topo;
 35 |         while(!q.empty())
 36 |         {
 37 |                 int father = q.front();
 38 |                 topo.push_back(father);
 39 |                 q.pop();
 40 | 
 41 | 
 42 |                 for(auto child: graph[father])
 43 |                 {
 44 |                         in[child.first]--;
 45 |                         if(in[child.first]==0)
 46 |                         {
 47 |                                 q.push(child.first);
 48 |                         }
 49 |                 }
 50 |         }
 51 | 
 52 |         dis[1] = 0;
 53 | 
 54 |         for(auto s : topo)
 55 |         {
 56 |                 if(dis[s]!=inf)
 57 |                 {
 58 |                         for(auto child: graph[s])
 59 |                         {
 60 |                                 if(dis[child.first]>dis[s]+child.second)
 61 |                                 {
 62 |                                         parent[child.first] = s;
 63 |                                         dis[child.first] = dis[s]+child.second;
 64 |                                 }
 65 |                         }
 66 |                 }
 67 |         }
 68 | 
 69 | 
 70 | 
 71 |         if(dis[n]==inf)
 72 |         {
 73 |                 cout<<"IMPOSSIBLE"<<endl;
 74 |                 return 0;
 75 |         }
 76 | 
 77 | 
 78 | 
 79 |         int v = n;
 80 | 
 81 |         vector<int>ans;
 82 | 
 83 |         while(v!=0)
 84 |         {
 85 |                 ans.push_back(v);
 86 |                 v = parent[v];
 87 |         }
 88 |         reverse(ans.begin(),ans.end());
 89 | 
 90 | 
 91 |         cout<<"dis[n] " <<dis[n]<<endl;
 92 | 
 93 |         cout<<ans.size()<<endl;
 94 | 
 95 |         for(auto x : ans)
 96 |         {
 97 |                 cout<<x<<" ";
 98 |         }
 99 |         cout<<endl;
100 | 
101 | 
102 | }
103 | 
104 | 
105 | /*
106 | 5 5
107 | 1 2 2
108 | 2 5 2
109 | 1 3 2
110 | 3 4 2
111 | 4 5 2
112 | */
113 | 


--------------------------------------------------------------------------------
/Sliding Window (Fixed,Variable Length Window Template).cpp:
--------------------------------------------------------------------------------
  1 | https://leetcode.com/discuss/interview-question/3722472/mastering-sliding-window-technique-a-comprehensive-guide
  2 | //Use Fixed Length template from this disscuss and For variable length window . use mine
  3 | 
  4 | 
  5 | 
  6 | ======== Fixed Lenght Sliding Window ==========
  7 | 
  8 | 
  9 |         int i = 0, j = 0; // Window indices
 10 |         int sum = 0;      // Current window sum
 11 | 
 12 |         while (j < n)
 13 |         {
 14 |                 if (j - i + 1 < k)
 15 |                 {
 16 |                         // Expand the window by adding element at index j to the sum
 17 |                         sum += v[j];
 18 |                         j++;
 19 |                 }
 20 |                 else
 21 |                 {
 22 |                         // Window size is now equal to the desired window size
 23 |                         // Calculate the answer for the window
 24 |                         sum += v[j];
 25 |                         cout << sum << endl;
 26 | 
 27 |                         // Move the window by incrementing indices i and j
 28 |                         sum -= v[i];
 29 |                         i++, j++;
 30 |                 }
 31 |         }
 32 | 
 33 | 
 34 | 
 35 | 
 36 | /* You can use this template for any fixed length sliding window problem without any change 
 37 |  regardless of what i,j means  */
 38 | 
 39 | 
 40 | =============== Variable length Sliding window ============ (Most used)(Sometimes instead of two pointers)
 41 | 
 42 |          int j = 0;
 43 | 
 44 |          int ans = 0;
 45 | 
 46 |         for (int i = 0; i < n; i++)
 47 |         {
 48 | 
 49 | 		            if( clearing previous i , has effect than check condition)
 50 |                 {
 51 | 			              //calculate the ans
 52 |                 }
 53 | 
 54 | 
 55 |                 while (some target is not met or limit is not crossed)
 56 |                 {
 57 |                         j++; // increase the right pointer of the variable window
 58 | 			                  //calculate the ans
 59 |                 }
 60 | 
 61 | 
 62 |                 while or if (target is met)
 63 |                 {
 64 |                         // Calculated the ans here depending on the problem
 65 |                         j++; //while loop then j++; else for if then no j++;
 66 |                         // Calculated the ans here depending on the problem
 67 |                 }
 68 | 
 69 |                 // clear i er effect
 70 |         }
 71 | 
 72 | 
 73 | 
 74 | //Remember to keep tract of i,j and what they mean.. based on these calculate ans.
 75 | /* You don't have to think like this in the fixed length sliding window. But 
 76 | in variable length window you do have to think about i,j and what they means */
 77 | // j included rakhar atmost try kora
 78 | 
 79 | 
 80 | ===================== Variable length Sliding Window ============== Examples problem(Sub-Array Counting : excatly k property)
 81 | 
 82 | 
 83 | https://leetcode.com/problems/subarrays-with-k-different-integers/description/?envType=list&envId=p96cfcjg
 84 | 
 85 | This problem is like the problem of ICPC regional 2023 solved by me
 86 |  
 87 | class Solution
 88 | {
 89 | public:
 90 |         bool isValid(unordered_map<int, int> &mp, int k, int add)
 91 |         {
 92 |                 mp[add]++;
 93 |                 bool ok = mp.size() <= k;
 94 |                 mp[add]--;
 95 |                 if (mp[add] == 0)
 96 |                 {
 97 |                         mp.erase(add);
 98 |                 }
 99 |                 return ok;
100 |         }
101 | 
102 |         int subArrayWithAtmostK(vector<int> &nums, int k)
103 |         {
104 |                 int j = 0;
105 |                 int ans = 0;
106 |                 unordered_map<int, int> mp;
107 | 
108 |                 mp[nums[j]]++;
109 | 
110 |                 for (int i = 0; i < nums.size(); i++)
111 |                 {
112 |                         while (j + 1 < nums.size() && isValid(mp, k, nums[j + 1]))
113 |                         {
114 |                                 mp[nums[j + 1]]++;
115 |                                 j++; // j porjont neya  [j included]
116 |                         }
117 | 
118 |                         if (mp.size() <= k)
119 |                         {
120 |                                 ans += j - i + 1; // j included.
121 |                         }
122 | 
123 |                         mp[nums[i]]--;
124 |                         if (mp[nums[i]] == 0)
125 |                         {
126 |                                 mp.erase(nums[i]);
127 |                         }
128 |                 }
129 | 
130 |                 return ans;
131 |         }
132 |         int subarraysWithKDistinct(vector<int> &nums, int k)
133 |         {
134 |                 return subArrayWithAtmostK(nums, k) - subArrayWithAtmostK(nums, k - 1);
135 | 
136 |                 // Sub Array With excatly K different integers = Sub Array With AtMost K different integers - Sub Array With AtMost (K-1) different integers
137 |         }
138 | };
139 | 
140 | 
141 | ===================== Variable length Sliding Window ============== Examples problem(Sub-Array Counting : excalty k property)
142 | 
143 | https://leetcode.com/problems/count-number-of-nice-subarrays/?envType=list&envId=p96cfcjg
144 | 
145 | class Solution
146 | {
147 | public:
148 |         bool isValid(int odd, int k, int num)
149 |         {
150 |                 odd += (num & 1);
151 |                 return odd <= k;
152 |         }
153 |         int atMostK(vector<int> &nums, int k)
154 |         {
155 |                 int j = 0;
156 |                 int ans = 0;
157 |                 int odd = (nums[0] & 1);
158 |                 for (int i = 0; i < nums.size(); i++)
159 |                 {
160 |                         while (j + 1 < nums.size() && isValid(odd, k, nums[j + 1]))
161 |                         {
162 |                                 j++;
163 |                                 odd += (nums[j] & 1); // j included . which means j porjonto
164 |                         }
165 | 
166 |                         if (odd <= k)
167 |                         {
168 |                                 ans += j - i + 1; // j included
169 |                         }
170 | 
171 |                         odd -= (nums[i] & 1);
172 |                 }
173 | 
174 |                 return ans;
175 |         }
176 | 
177 |         int numberOfSubarrays(vector<int> &nums, int k)
178 |         {
179 |                 return atMostK(nums, k) - atMostK(nums, k - 1); //= Excatly k
180 |         }
181 | };
182 | 
183 | 
184 | 


--------------------------------------------------------------------------------
/Strongly Connected Components to DAG.cpp:
--------------------------------------------------------------------------------
  1 | //Arfatul Islam Asif 
  2 | //This programme can be used for both finding SCC's and converting a directed graph to DAG 
  3 | 
  4 | const int N = 1000;
  5 | vector<int>graph[N];
  6 | vector<int>Rgraph[N];
  7 | bool vis1[N];
  8 | bool vis2[N];
  9 | int group_id[N];
 10 | vector<int>forder;
 11 | 
 12 | void dfs1(int s)
 13 | {
 14 |         vis1[s] = true;
 15 |         for(auto child : graph[s])
 16 |         {
 17 |                 if(vis1[child])
 18 |                 {
 19 |                         continue;
 20 |                 }
 21 |                 dfs1(child);
 22 |         }
 23 |         forder.push_back(s);
 24 | }
 25 | void dfs2(int s , int no)
 26 | {
 27 |         vis2[s] = true;
 28 |         group_id[s] = no;
 29 |         for(auto child : Rgraph[s])
 30 |         {
 31 |                 if(vis2[child])
 32 |                 {
 33 |                         continue;
 34 |                 }
 35 |                 dfs2(child , no);
 36 |         }
 37 |         return;
 38 | }
 39 | 
 40 | 
 41 | 
 42 | 
 43 | int32_t main()
 44 | {
 45 |         ios::sync_with_stdio(0);
 46 |         cin.tie(0);
 47 |         int n,m;
 48 |         cin>>n>>m;
 49 |         for(int i=0;i<m;i++)
 50 |         {
 51 |                 int x,y;
 52 |                 cin>>x>>y;
 53 |                 graph[x].push_back(y);
 54 |                 Rgraph[y].push_back(x);
 55 |         }
 56 |         for(int i=0;i<n;i++)
 57 |         {
 58 |                 if(vis1[i]==false)
 59 |                 {
 60 |                         dfs1(i);
 61 |                 }
 62 |         }
 63 |         reverse(forder.begin() , forder.end());
 64 |         int no = 1;
 65 |         for(auto x : forder)
 66 |         {
 67 |                 if(vis2[x]==false)
 68 |                 {
 69 |                         dfs2(x , no);
 70 |                         no++;
 71 |                 }
 72 |         }
 73 |         vector<int>DAG[N];
 74 |         //SCC to DAG convertion
 75 |         for(int i=0;i<n;i++)
 76 |         {
 77 |                 for(auto child : graph[i])
 78 |                 {
 79 |                         if(group_id[i]!=group_id[child])
 80 |                         {
 81 |                                 DAG[group_id[i]].push_back(group_id[child]);
 82 |                         }
 83 |                 }
 84 |         }
 85 | 
 86 |         for(int i = 1;i<no;i++)
 87 |         {
 88 |                 cout<<i<<": ";
 89 |                 for(int j=0;j<DAG[i].size();j++) //Printing DAG's adjacency list
 90 |                 {
 91 |                         cout<<DAG[i][j]<<" ";
 92 |                 }
 93 |                 cout<<endl;
 94 |         }
 95 | 
 96 | 
 97 |         return 0;
 98 | 
 99 | 
100 | 
101 | 
102 | }
103 | 
104 | /*
105 | 7 8
106 | 0 1
107 | 1 2
108 | 2 0
109 | 2 3
110 | 3 4
111 | 4 5
112 | 5 6
113 | 6 4
114 | 
115 | 
116 | */
117 | 


--------------------------------------------------------------------------------
/Topological Sorting .cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //TOPO SORT
 3 | 
 4 | const int N = 1e5+100;
 5 | vector<int>graph[N];
 6 | bool vis[N];
 7 | int in[N];
 8 | 
 9 | int32_t main()
10 | {
11 |         ios::sync_with_stdio(0);
12 |         cin.tie(0);
13 | 
14 |         int n,m;
15 |         cin>>n>>m;
16 | 
17 |         for(int i=0;i<m;i++)
18 |         {
19 |                 int x,y;
20 |                 cin>>x>>y;
21 |                 graph[x].push_back(y);
22 |                 in[y]++;
23 |         }
24 |         queue<int>q;
25 |         for(int i=1;i<=n;i++)
26 |         {
27 |                 if(in[i]==0)
28 |                 {
29 |                     q.push(i);
30 |                 }
31 |         }
32 |         vector<int>ans;
33 |         while(!q.empty())
34 |         {
35 |                 int father = q.front();
36 |                 vis[father] = true;
37 |                 ans.push_back(father);
38 |                 q.pop();
39 |                 for(auto child : graph[father])
40 |                 {
41 |                         if(vis[child])
42 |                         {
43 |                                 continue;
44 |                         }
45 |                         in[child]--;
46 |                         if(in[child]==0)
47 |                         {
48 |                                 q.push(child);
49 |                                 vis[child] = true;
50 |                         }
51 |                 }
52 |         }
53 | 
54 | 
55 |         for(int i=1;i<=n;i++)
56 |         {
57 |                 if(vis[i]==false)
58 |                 {
59 |                         cout<<"IMPOSSIBLE"<<endl;
60 |                         return 0;
61 |                 }
62 |         }
63 | 
64 | 
65 |         for(auto x : ans)
66 |         {
67 |                 cout<<x<<" ";
68 |         }
69 |         cout<<endl;
70 | 
71 |         return 0;
72 | 
73 | 
74 | 
75 | 
76 | 
77 | 
78 | }
79 | 


--------------------------------------------------------------------------------
/Trie .cpp:
--------------------------------------------------------------------------------
  1 | // TRIE : Insert , Remove , Prefix search , String search
  2 | 
  3 | const int N = 1e6;
  4 | int node[N][26];
  5 | int root = 0;
  6 | int avail = 0;
  7 | int cnt[N];
  8 | int is_end[N];
  9 | 
 10 | void ini()
 11 | {
 12 |         root = 0;
 13 |         avail = 0;
 14 |         for(int i=0;i<26;i++)
 15 |         {
 16 |                 node[root][i] = -1;
 17 |         }
 18 | }
 19 | 
 20 | 
 21 | void Insert(string s)
 22 | {
 23 | 
 24 |         int cur = root;
 25 |         for(int i=0;i<s.size();i++)
 26 |         {
 27 |                 if(node[cur][s[i]-'a']==-1)
 28 |                 {
 29 |                         avail++;
 30 | 
 31 |                         node[cur][s[i]-'a'] = avail;
 32 | 
 33 |                         is_end[avail] = 0;
 34 | 
 35 |                         cnt[avail] = 0;
 36 | 
 37 |                         for(int j=0;j<26;j++)
 38 |                         {
 39 |                                 node[avail][j] = -1;
 40 |                         }
 41 |                 }
 42 | 
 43 |                 cur = node[cur][s[i]-'a'];
 44 | 
 45 |                 cnt[cur]++;
 46 |         }
 47 |         is_end[cur]++;
 48 | }
 49 | 
 50 | void Remove(string s)
 51 | {
 52 | 
 53 |         int cur = root;
 54 | 
 55 |         for(int i=0;i<s.size();i++)
 56 |         {
 57 | 
 58 |                 cur = node[cur][s[i]-'a'];
 59 | 
 60 |                 cnt[cur]--;
 61 |         }
 62 |         is_end[cur]--;
 63 | }
 64 | 
 65 | bool prefix(string s)
 66 | {
 67 | 
 68 |         int cur = root;
 69 |         for(int i=0;i<s.size();i++)
 70 |         {
 71 |                 if(node[cur][s[i]-'a']!=-1 && cnt[node[cur][s[i]-'a'] ]> 0)
 72 |                 {
 73 |                         cur = node[cur][s[i]-'a'];
 74 |                 }
 75 |                 else
 76 |                 {
 77 |                         return false;
 78 |                 }
 79 |         }
 80 | 
 81 |         return true;
 82 | }
 83 | 
 84 | 
 85 | bool Search(string s)
 86 | {
 87 |         int cur = root;
 88 |         for(int i=0;i<s.size();i++)
 89 |         {
 90 |                 if(node[cur][s[i]-'a']!=-1 && cnt[node[cur][s[i]-'a'] ]> 0)
 91 |                 {
 92 |                         cur = node[cur][s[i]-'a'];
 93 |                 }
 94 |                 else
 95 |                 {
 96 |                         return false;
 97 |                 }
 98 |         }
 99 | 
100 |         return (is_end[cur]>0);
101 | }
102 | 
103 | 
104 | 
105 | int32_t main()
106 | {
107 |         ios::sync_with_stdio(0);
108 |         cin.tie(0);
109 | 
110 | 
111 |         ini();
112 | 
113 |         int n;
114 |         cin>>n;
115 | 
116 |         while(n--)
117 |         {
118 |                 string s;
119 |                 cin>>s;
120 |                 Insert(s);
121 |         }
122 | 
123 |         string a;
124 |         cin>>a;
125 | 
126 |         cout<<prefix(a)<<endl;
127 |         cout<<Search(a)<<endl;
128 | 
129 |         string b;
130 | 
131 |         cin>>b;
132 | 
133 |         Remove(b);               // asuming b is present in trie
134 | 
135 |         cout<<Search(a)<<endl;
136 | 
137 |         return 0;
138 | 
139 | }
140 | 


--------------------------------------------------------------------------------
/Trie Xor (Min - Max).cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | // Maximum Xor or Minimum Xor of two numbers in an array Using trie
  3 | 
  4 | 
  5 | const int N = 5e6;
  6 | int node[N][2]; //remember trie er edge information store kore (NOT node) . [ lets say 1 --> 2 e ekti edge directed , then er information store hobe  cnt[2] Te ::::::::::: ebong 2 =  node[1][] is like 1 = parent[2] er moto in directed tree :: age amra parent diye jump kortm : Now children diye jump]
  7 | int root = 0;                 //which means Edge info is actually stored in the 2nd child : and edges er characterictistics is (2 = node[1][]) refers to (1) ---> (2) edge
  8 | int avail = 0;
  9 | int cnt[N];
 10 | 
 11 | 
 12 | void ini()
 13 | {
 14 |         root = 0;
 15 |         avail = 0;
 16 |         for(int i=0;i<N;i++)
 17 |         {
 18 |                 cnt[i] = 0;
 19 |         }
 20 |         node[root][0] = -1;
 21 |         node[root][1] = -1;
 22 | }
 23 | 
 24 | void Insert(int x)
 25 | {
 26 |         int cur = root;
 27 |         for(int i=30;i>=0;i--) // MSB must be at the top 1
 28 |         {
 29 |                 if(x &(1<<i))
 30 |                 {
 31 |                         if(node[cur][1]==-1)
 32 |                         {
 33 |                                 avail++;
 34 |                                 node[cur][1] = avail;
 35 |                                 node[avail][0] = -1;
 36 |                                 node[avail][1] = -1;
 37 |                         }
 38 |                         cur = node[cur][1];
 39 |                 }
 40 |                 else
 41 |                 {
 42 |                         if(node[cur][0]==-1)
 43 |                         {
 44 |                                 avail++;
 45 |                                 node[cur][0] = avail;
 46 |                                 node[avail][0] = -1;
 47 |                                 node[avail][1] = -1;
 48 |                         }
 49 |                         cur = node[cur][0];
 50 |                 }
 51 |                 cnt[cur]++;
 52 | 
 53 |         }
 54 | }
 55 | 
 56 | void Remove(int x)
 57 | {
 58 |         int cur = root;
 59 |         for(int i=30;i>=0;i--) // MSB must be at the top 1
 60 |         {
 61 |                 if(x &(1<<i))
 62 |                 {
 63 |                         cur = node[cur][1];
 64 |                 }
 65 |                 else
 66 |                 {
 67 |                         cur = node[cur][0];
 68 |                 }
 69 |                 cnt[cur]--;
 70 |         }
 71 | }
 72 | 
 73 | int Max_Xor(int x)
 74 | {
 75 |         int ans = 0;
 76 | 
 77 |         int cur = root;
 78 |         for(int i=30;i>=0;i--) // MSB must be at the top 1
 79 |         {
 80 |                 if(x&(1<<i))
 81 |                 {
 82 |                         if(node[cur][0]!=-1 && cnt[node[cur][0]]>0) // ei edge er info is being stored in cur = node[cur][0]
 83 |                         {
 84 |                                 ans |= (1<<i);
 85 |                                 cur = node[cur][0];
 86 |                         }
 87 |                         else
 88 |                         {
 89 |                                 cur = node[cur][1]; // alternate will always exits
 90 |                         }
 91 | 
 92 |                 }
 93 |                 else
 94 |                 {
 95 |                         if(node[cur][1]!=-1 && cnt[node[cur][1]]>0)
 96 |                         {
 97 |                                 ans |= (1<<i);
 98 |                                 cur = node[cur][1];
 99 |                         }
100 |                         else
101 |                         {
102 |                                 cur = node[cur][0];// alternate will always exits
103 |                         }
104 |                 }
105 |         }
106 | 
107 |         return ans;
108 | }
109 | 
110 | 
111 | int Min_Xor(int x)
112 | {
113 |         int cur =root;
114 |         int ans = 0;
115 | 
116 |         for(int i=30;i>=0;i--)
117 |         {
118 |                 if(x&(1<<i))
119 |                 {
120 |                         if(node[cur][1]!=-1 && cnt[node[cur][1]]>0)
121 |                         {
122 |                                 cur = node[cur][1];
123 |                         }
124 |                         else
125 |                         {
126 |                                 ans |=(1<<i);
127 |                                 cur = node[cur][0];
128 |                         }
129 |                 }
130 |                 else
131 |                 {
132 | 
133 |                         if(node[cur][0]!=-1 && cnt[node[cur][0]]>0)
134 |                         {
135 |                                 cur = node[cur][0];
136 |                         }
137 |                         else
138 |                         {
139 |                                 ans |=(1<<i);
140 |                                 cur = node[cur][1];
141 |                         }
142 |                 }
143 |         }
144 | 
145 |         return ans;
146 | }
147 | 
148 | 
149 | 
150 | int32_t main()
151 | {
152 |         ios::sync_with_stdio(0);
153 |         cin.tie(0);
154 | 
155 |         int n; // n>=2
156 |         cin>>n;
157 | 
158 |         vector<int>v;
159 | 
160 |         ini();
161 | 
162 |         //Insert(0); // IN some problem you might need to use this where you have the choice of choosing any number of element : i.e n==1 is allowed
163 | 
164 |         for(int i=0;i<n;i++)
165 |         {
166 |                 int a;
167 |                 cin>>a;
168 |                 v.push_back(a);
169 |                 Insert(a);
170 |         }
171 | 
172 |         int mx = 0;
173 | 
174 |         for(int i=0;i<n;i++)
175 |         {
176 |                 mx = max(mx, Max_Xor(v[i]));
177 |         }
178 | 
179 |         int mn = INT_MAX;
180 | 
181 |         for(int i=0;i<n;i++)
182 |         {
183 |                 Remove(v[i]); // we need to remove this else v[i]^v[i] = 0 which would be minimum [ this wont be a problem for Max finding ]
184 | 
185 |                 mn = min(mn, Min_Xor(v[i]));
186 | 
187 |                 Insert(v[i]);
188 |         }
189 | 
190 | 
191 |         cout<<"Max Xor : "<<mx<<" Min Xor : "<<mn<<endl;
192 | 
193 | 
194 |         return 0;
195 | 
196 | 
197 | 
198 | 
199 | 
200 | 
201 | 
202 | 
203 | }
204 | 


--------------------------------------------------------------------------------
/Why Dijkstra Fails For Negative Edges.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # Why dijkstra Fails for negative edges :
 3 | 
 4 | ```
 5 | https://www.youtube.com/watch?v=R3g2SSlyY_0
 6 | ```
 7 | 
 8 | # what measures that can be taken for dijkstra to works for negative edges to.
 9 | 
10 | ## If we find the minimum weight edge and add this weight to all edges, so that they become non-negative; will the dijkstra works?
11 | **Answer: NO**
12 | 
13 | Consider this graph:
14 | 
15 | ```
16 |        1              1
17 | 1 -----------> 2 ----------> 3 
18 | \                         / 
19 |  \  4                 1  /  
20 |    \                  / 
21 |      \             / 
22 |        \>   4    </  
23 | ```
24 | 
25 | Current distance from source 1, to all other is dist[2] = 1 (1 -> 2), dist[3] = 2 (1 -> 2 -> 3), dist[4] = 3 (1 -> 2 -> 3 -> 4).
26 | 
27 | **If we increase weight of all edges by a constant value, lets say 1, will the relative distance (include edges) remained same?**
28 | 
29 | ```
30 |        2              2
31 | 1 -----------> 2 ----------> 3
32 | \                         /
33 |  \  5                 2  /  
34 |    \                  /
35 |      \             /
36 |        \>   4    </  
37 | ```
38 | 
39 | Now distance from source 1, to all other is dist[2] = 2 (1 -> 2), dist[3] = 4 (1 -> 2 -> 3), dist[4] = 5 (1 -> 4).
40 | **Look dist[4] has changed its relative order**
41 | 
42 | 
43 | <br>
44 | <br>
45 | 
46 | ## Reweight each edges of the graph like w'(u, v) = w(u, v) + potential[u] – potential[v], using Bellman-Ford to eliminate negative weights, then apply Dijkstra's algorithm to find the shortest paths from source to all other vertex.
47 | 
48 | <br>
49 | **It will works: The question is where we can use it?**
50 | **Answer: Jonson's algorithm for all pair shortest path**
51 | 
52 | ## Jonson's algorithm for all pair shortest path:
53 | **Step 1: Adjust negative edges using bellman-ford.**
54 | **Step 2: Run dijkstra for each vertex to find all pair shortest path**
55 | 
56 | ```
57 | This is better than floyed-warshall O(V^3). As it's complexity is O(V2log V + VE)
58 | ```
59 | 
60 | 
61 | 
62 | # By the way, it will not work if negative cycle exists. 
63 | 
64 | 
65 | 
66 | 


--------------------------------------------------------------------------------
/XOR Basis.cpp:
--------------------------------------------------------------------------------
 1 | // Intermediary
 2 | // Young kid on the block
 3 | // AIAsif try's Continuing the journey
 4 | #include <bits/stdc++.h>
 5 | #include <ext/pb_ds/assoc_container.hpp>
 6 | #include <ext/pb_ds/tree_policy.hpp>
 7 | using namespace std;
 8 | using namespace __gnu_pbds;
 9 | #define endl "\n"
10 | #define int long long int
11 | #define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
12 | 
13 | 
14 | Basis: A set B of vectors in a vector space V is called a basis (pl.: bases) if every element of V may be written in a unique way as a finite linear combination of elements of B. The coefficients of this linear combination are referred to as components or coordinates of the vector with respect to B. The elements of a basis are called basis vectors.
15 | 
16 | class Basis
17 | {
18 |         vector<int> a;
19 | 
20 | public:
21 |         void insert(int x)
22 |         {
23 |                 for (auto &i : a)
24 |                 
25 |                         x = min(x, x ^ i); //for row echelon form get the smallest bit which is not equals to 0 means this bit is controlled by this
26 |                 if (!x)
27 |                         return;
28 |                 for (auto &i : a)
29 |                         if ((i ^ x) < i)
30 |                                 i ^= x;
31 |                 a.push_back(x);
32 |                 sort(a.begin(), a.end());
33 |         }
34 |         bool can(int x)
35 |         {
36 |                 for (auto &i : a)
37 |                         x = min(x, x ^ i);
38 |                 return !x;
39 |         }
40 |         int maxxor(int x = 0)
41 |         {
42 |                 for (auto &i : a)
43 |                         x = max(x, x ^ i);
44 |                 return x;
45 |         }
46 |         int minxor(int x = 0) // always returning zero . If you are not considering empty set then take care of it...
47 |         {
48 |                 for (auto &i : a)
49 |                         x = min(x, x ^ i);
50 |                 return x;
51 |         }
52 |         int kth(int k) //1st is 0 . which means empty set is also coounted .. if you don't want to count empty set then take care of the condition whether zero can be made using existing 
53 |         { // 1st is 0
54 |                 int sz = (int)a.size();
55 |                 if (k > (1LL << sz))
56 |                         return -1;
57 |                 k--;
58 |                 int ans = 0;
59 |                 for (int i = 0; i < sz; i++)
60 |                         if (k >> i & 1)
61 |                                 ans ^= a[i];
62 |                 return ans;
63 |         }
64 | 
65 | } t;
66 | 
67 | int32_t main()
68 | {
69 |         ios::sync_with_stdio(0);
70 |         cin.tie(0);
71 | 
72 |         int n;
73 |         cin>>n;
74 |         for(int i=0;i<n;i++)
75 |         {
76 |                 int a;
77 |                 cin>>a;
78 |                 t.insert(a);
79 |         }
80 | 
81 | 
82 |         cout<<t.maxxor()<<endl;
83 | 
84 | 
85 |         return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/Z Function.cpp:
--------------------------------------------------------------------------------
 1 | ====================================Application of Z fuction =====================
 2 | 1.Pattern search.
 3 | 2.String Compression.
 4 | 
 5 |   
 6 | 
 7 | // Longest prefix that start's at i which is also a prefix  [ tushar roy ]
 8 | 
 9 | vector<int> z_function(const string &s)
10 | {
11 |         int n = s.size();
12 |         vector<int>z(n);
13 |         int l = 0;
14 |         int r = 0;
15 |         for(int i=1;i<n;i++)
16 |         {
17 |                 if(i<r) // which means [l to r] range has already been calculated and their value are quite like the prefix ... of [0 to (r-l+1)]
18 |                 {
19 |                         z[i] = min(r-i , z[i-l]);
20 |                 }
21 |                 while(i+z[i]<n && s[z[i]]==s[i+z[i]])
22 |                 {
23 |                         z[i]++;
24 |                 }
25 |                 if(i+z[i]>r)
26 |                 {
27 |                         l = i;
28 |                         r = i+z[i];
29 |                 }
30 |         }
31 | 
32 |         return z;
33 | }
34 | 
35 | 
36 | int stringCompression(const string &s) //length of smallest string t such s = t+t+..+t ; Or s is the concatenation of one or more t;
37 | {
38 |         vector<int>z = z_function(s);
39 | 
40 |         for(int i=1;i<s.size();i++)
41 |         {
42 |                 if(s.size()%i==0 && i+z[i]==s.size())
43 |                 {
44 |                         return i;
45 |                 }
46 |         }
47 | 
48 |         return s.size();
49 | 
50 | }
51 | 
52 | 


--------------------------------------------------------------------------------
/zzzzzzz Me.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ArfatulAsif/Competitive-programming/2461dfe21a6b2cb81d9468e7a52685a904862807/zzzzzzz Me.png


--------------------------------------------------------------------------------
/zzzzzzzz Batarang.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ArfatulAsif/Competitive-programming/2461dfe21a6b2cb81d9468e7a52685a904862807/zzzzzzzz Batarang.png


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