├── Comp  - 04
    ├── dquery.cpp
    ├── kquery.cpp
    ├── notes.md
    └── segment_trees_lazy.cpp
├── Comp - 01
    ├── a.exe
    ├── birthday_paradox.cpp
    ├── fast_power.cpp
    ├── fast_power_bitmask.cpp
    ├── playing_with_bits.cpp
    └── uniq_2.cpp
├── Comp - 02
    ├── holi_graphs.cpp
    └── ternary_search_codeforces_427_e.cpp
├── Comp - 03
    ├── a.exe
    ├── aggresive_cows.cpp
    ├── lower_bound.cpp
    ├── readme.md
    ├── segment_trees.cpp
    └── square_root.cpp
└── Comp - 05 Persistent Trees , Mos
    ├── dquery_persistent.cpp
    ├── mkhthnum_persistent.cpp
    ├── mosintro.cpp
    └── persistent_segtree.cpp


/Comp  - 04/dquery.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #include<cmath>
 3 | using namespace std;
 4 | #define ll long long
 5 | ll seg[2000000],arr[2000000],pos[2000000],ans[2000000];
 6 | vector<pair<ll,ll> > vec[2000000];
 7 | void update(ll st,ll l,ll r,ll in,ll v)
 8 | {
 9 | 	if(l==r)
10 | 	{
11 | 		seg[st]+=v;
12 | 		return;
13 | 	}
14 | 	ll mid=(l+r)/2;
15 | 	if(in<=mid)
16 | 	{
17 | 		update(st*2+1,l,mid,in,v);
18 | 	}
19 | 	else
20 | 	{
21 | 		update(st*2+2,mid+1,r,in,v);
22 | 	}
23 | 	seg[st]=seg[st*2+1]+seg[st*2+2];
24 | }
25 | ll query(ll st,ll l,ll r,ll ql,ll qr)
26 | {
27 | 	if(l>qr||r<ql)
28 | 	{
29 | 		return 0;
30 | 	}
31 | 	if(l>=ql&&r<=qr)
32 | 	{
33 | 		return seg[st];
34 | 	}
35 | 	ll mid=(l+r)/2;
36 | 	return query(st*2+1,l,mid,ql,qr)+query(st*2+2,mid+1,r,ql,qr);
37 | }
38 | int main()
39 | {
40 | 	ll n;
41 | 	cin>>n;
42 | 	for(int i=0;i<n;i++)
43 | 	{
44 | 		cin>>arr[i];
45 | 	}
46 | 	ll q;
47 | 	cin>>q;
48 | 	for(int i=0;i<q;i++)
49 | 	{
50 | 		ll l,r;
51 | 		cin>>l>>r;
52 | 		l--;
53 | 		r--;
54 | 		vec[r].push_back(make_pair(l,i));
55 | 	}
56 | 	memset(pos,-1,sizeof(pos));
57 | 	for(int i=0;i<n;i++)
58 | 	{
59 | 		if(pos[arr[i]]!=-1)
60 | 		{
61 | 			update(0,0,n-1,pos[arr[i]],-1);
62 | 		}
63 | 		update(0,0,n-1,i,1);
64 | 		pos[arr[i]]=i;
65 | 		for(int j=0;j<vec[i].size();j++)
66 | 		{
67 | 			ans[vec[i][j].second]=query(0,0,n-1,vec[i][j].first,i);
68 | 		}
69 | 	}
70 | 	for(int i=0;i<q;i++)
71 | 		cout<<ans[i]<<"\n";
72 | 
73 | 	return 0;
74 | }


--------------------------------------------------------------------------------
/Comp  - 04/kquery.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/coding-blocks-archives/competitive-classroom-june-2018/8ab66a42dd513c28444db26acb7e945c3458f19f/Comp  - 04/kquery.cpp


--------------------------------------------------------------------------------
/Comp  - 04/notes.md:
--------------------------------------------------------------------------------
 1 | - Lazy Propagation
 2 | - Matrix Queries-I (HB)
 3 | - Counting Zeroes(COUNZ)
 4 | - HORRIBLE(Spoj)
 5 | - BRCKTS
 6 | - GSS4(Spoj) - Square Root Query
 7 | - MOD(M) Query - 250D Child and Sequence
 8 | 	a%m
 9 | 	a = km  + r  where r < m
10 | 		r = 2r/2 = <=(m+r)/2 <= (km+r)/2 <= a/2
11 | 
12 | - DQUERY
13 | - Spoj
14 | - KQUERY (2 approcahes)
15 | 
16 | 


--------------------------------------------------------------------------------
/Comp  - 04/segment_trees_lazy.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | 
  4 | int lazy[100] = {0};
  5 | 
  6 | void buildTree(int *a,int *tree,int s,int e,int index){
  7 | 	//Base Case
  8 | 	if(s>e){
  9 | 		return;
 10 | 	}
 11 | 	if(s==e){
 12 | 		tree[index] = a[s];
 13 | 		return;
 14 | 	}
 15 | 	//Rec Case
 16 | 	int mid = (s+e)/2;
 17 | 	buildTree(a,tree,s,mid,2*index);
 18 | 	buildTree(a,tree,mid+1,e,2*index+1);
 19 | 	tree[index] = min(tree[2*index],tree[2*index + 1]);
 20 | 	return;
 21 | }
 22 | 
 23 | int query(int *tree,int index,int s,int e,int qs,int qe){
 24 | 	//No Overlap
 25 | 	if(qs>e || qe<s){
 26 | 		return INT_MAX;
 27 | 	}
 28 | 	else if(s>=qs && e<=qe){
 29 | 		return tree[index];
 30 | 	}
 31 | 	else{
 32 | 		int mid = (s+e)/2;
 33 | 		int left = query(tree,2*index,s,mid,qs,qe);
 34 | 		int right = query(tree,2*index+1,mid+1,e,qs,qe);
 35 | 		return min(left,right);
 36 | 	}
 37 | }
 38 | //Query Lazy
 39 | int queryLazy(int *tree,int index,int s,int e,int qs,int qe){
 40 | 	//Resolve all lazy values
 41 | 	//First Resolve the Lazy Value
 42 | 	if(lazy[index]!=0){
 43 | 		tree[index] += lazy[index];
 44 | 		if(s!=e){
 45 | 			lazy[2*index] += lazy[index];
 46 | 			lazy[2*index+1] += lazy[index];
 47 | 		}
 48 | 		lazy[index] = 0;
 49 | 	}
 50 | 
 51 | 	//No Overlap
 52 | 	if(qs>e || qe<s){
 53 | 		return INT_MAX;
 54 | 	}
 55 | 	else if(s>=qs && e<=qe){
 56 | 		return tree[index];
 57 | 	}
 58 | 	else{
 59 | 		int mid = (s+e)/2;
 60 | 		int left = queryLazy(tree,2*index,s,mid,qs,qe);
 61 | 		int right = queryLazy(tree,2*index+1,mid+1,e,qs,qe);
 62 | 		return min(left,right);
 63 | 	}
 64 | }
 65 | //Update - Point Update Vs Range Update
 66 | void update(int *tree,int index,int i,int increment,int s,int e){
 67 | 	//Out of bounds
 68 | 	if(i>e || i<s){
 69 | 		return;
 70 | 	}
 71 | 	//Leaf Node- Always Update (one leaf node of this type)
 72 | 	if(s==e){
 73 | 		tree[index] += increment;
 74 | 		return;
 75 | 	}
 76 | 	else{
 77 | 		//call both sides
 78 | 		int mid  = (s+e)/2;	
 79 | 		update(tree,2*index,i,increment,s,mid);
 80 | 		update(tree,2*index+1,i,increment,mid+1,e);
 81 | 		tree[index]  = min(tree[2*index],tree[2*index+1]);
 82 | 	}
 83 | 	return;
 84 | }
 85 | 
 86 | //Homework
 87 | void rangeUpdate(int *tree,int index,int i,int j,int inc,int s,int e){
 88 | 	//No Overlap
 89 | 	if(s>j||e<i){
 90 | 		return;
 91 | 	}
 92 | 	if(s==e){
 93 | 		tree[index] += inc;
 94 | 		return;
 95 | 	}
 96 | 	int mid = (s+e)/2;
 97 | 	rangeUpdate(tree,2*index,i,j,inc,s,mid);
 98 | 	rangeUpdate(tree,2*index+1,i,j,inc,mid+1,e);
 99 | 	tree[index] = min(tree[2*index],tree[2*index+1]);
100 | }
101 | 
102 | void rangeUpdateLazy(int *tree,int index,int i,int j,int inc,int s,int e){
103 | 	//First Resolve the Lazy Value
104 | 	if(lazy[index]!=0){
105 | 		tree[index] += lazy[index];
106 | 		if(s!=e){
107 | 			lazy[2*index] += lazy[index];
108 | 			lazy[2*index+1] += lazy[index];
109 | 		}
110 | 		lazy[index] = 0;
111 | 	}
112 | 
113 | 	//No Overlap
114 | 	if(s>j||e<i){
115 | 		return;
116 | 	}
117 | 	if(s==e){
118 | 		tree[index] += inc;
119 | 		return;
120 | 	}
121 | 	//Complete Overlap
122 | 	if(s>=i&&j<=e){
123 | 		tree[index] += inc;
124 | 		if(s!=e){
125 | 			lazy[2*index] += inc;
126 | 			lazy[2*index+1] += inc;
127 | 		}
128 | 		return;
129 | 	}
130 | 	int mid = (s+e)/2;
131 | 	rangeUpdate(tree,2*index,i,j,inc,s,mid);
132 | 	rangeUpdate(tree,2*index+1,i,j,inc,mid+1,e);
133 | 	tree[index] = min(tree[2*index],tree[2*index+1]);
134 | }
135 | 
136 | 
137 | 
138 | int main(){
139 | 	int a[] = {1,3,2,7,5};
140 | 	int n = 5;
141 | 	int *tree = new int[4*n+1];
142 | 	buildTree(a,tree,0,n-1,1);
143 | 
144 | 	/*for(int i=1;i<10;i++){
145 | 		cout<<tree[i]<<" ";
146 | 	}*/
147 | 
148 | 	//update(tree,1,0,10,0,n-1);
149 | 	//update(tree,1,1,10,0,n-1);
150 | 	rangeUpdate(tree,1,1,3,5,0,n-1);
151 | 
152 | 	int q;
153 | 	cin>>q;
154 | 
155 | 	while(q--){
156 | 		int qs,qe;
157 | 		cin>>qs>>qe;
158 | 		cout<<query(tree,1,0,n-1,qs,qe)<<endl;
159 | 
160 | 	}
161 | 
162 | 
163 | 	return 0;
164 | }


--------------------------------------------------------------------------------
/Comp - 01/a.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/coding-blocks-archives/competitive-classroom-june-2018/8ab66a42dd513c28444db26acb7e945c3458f19f/Comp - 01/a.exe


--------------------------------------------------------------------------------
/Comp - 01/birthday_paradox.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | 
 5 | 
 6 | int main(){
 7 | 
 8 | 	int no_of_people = 1;
 9 | 	int num = 365;
10 | 	float denom = 365.0;
11 | 
12 | 	float p;
13 | 	cin>>p;
14 | 	float prob =1.0;
15 | 	
16 | 	while(prob>=(1-p)){
17 | 		no_of_people++;
18 | 		num = num -1;
19 | 		prob = prob*(num/denom);
20 | 		cout<<"People "<<no_of_people<<" Prob : "<<prob<<endl;
21 | 	}
22 | 
23 | 	return 0;
24 | }


--------------------------------------------------------------------------------
/Comp - 01/fast_power.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int fastPower(int a,int b){
 5 | 	//Base Case
 6 | 	if(b==0){
 7 | 		return 1;
 8 | 	}
 9 | 	//Rec Case
10 | 	int smallAns = fastPower(a,b/2);
11 | 	smallAns *= smallAns;
12 | 
13 | 	if(b&1){
14 | 		return a*smallAns;
15 | 	}
16 | 	return smallAns;
17 | }
18 | 
19 | //Bitmasking Iterative Approach
20 | int fastPowerIterative(int a,int n){
21 | 
22 | 	int res=1;
23 | 	while(n){
24 | 		if(n&1){
25 | 			res = res*a;
26 | 		}
27 | 		n = n>>1;
28 | 		a *= a;
29 | 	}
30 | 	return res;
31 | 
32 | }
33 | int main(){
34 | 	int a=5,b=3;
35 | 	cout<<fastPowerIterative(a,b)<<endl;
36 | 
37 | }


--------------------------------------------------------------------------------
/Comp - 01/fast_power_bitmask.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int fastPower(int a,int b){
 5 | 	//Base Case
 6 | 	if(b==0){
 7 | 		return 1;
 8 | 	}
 9 | 	//Rec Case
10 | 	int smallAns = fastPower(a,b/2);
11 | 	smallAns *= smallAns;
12 | 
13 | 	if(b&1){
14 | 		return a*smallAns;
15 | 	}
16 | 	return smallAns;
17 | }
18 | 
19 | //Bitmasking Iterative Approach
20 | int fastPowerIterative(int a,int n){
21 | 
22 | 	int res=1;
23 | 	while(n){
24 | 		if(n&1){
25 | 			res = res*a;
26 | 		}
27 | 		n = n>>1;
28 | 		a *= a;
29 | 	}
30 | 	return res;
31 | 
32 | }
33 | int main(){
34 | 	int a=5,b=3;
35 | 	cout<<fastPowerIterative(a,b)<<endl;
36 | 
37 | }


--------------------------------------------------------------------------------
/Comp - 01/playing_with_bits.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | using namespace std;
 4 | 
 5 | int checkLastBit(int n){
 6 | 	return n&1;
 7 | }
 8 | 
 9 | void setIthBit(int &n,int j){
10 | 	n = n|(1<<j);
11 | }
12 | bool checkIthBit(int n,int j){
13 | 	return n&(1<<j);
14 | }
15 | //Complexity O(LogN)
16 | int countBits(int n){
17 | 	int count = 0;
18 | 	
19 | 	for(;n>0;n=n>>1){
20 | 		count += (n&1);
21 | 	}
22 | 
23 | 	return count;
24 | }
25 | //Hack - (n&(n-1)) Hack
26 | //O(No of Set Bits <=Log(N))
27 | int countBitsFast(int n){
28 | 
29 | 	int count=0;
30 | 	while(n){
31 | 		count++;
32 | 		//Removes last set bit from n
33 | 		n = n&(n-1);
34 | 	}
35 | 	return count;
36 | }
37 | //Subset/Subsequence Generation N<=20
38 | 
39 | void filterChars(char *a,int n){
40 | 
41 | 	int j=0;
42 | 
43 | 	while(n>0){
44 | 		int last_bit = (n&1);
45 | 		if(last_bit){
46 | 			cout<<a[j];
47 | 		}
48 | 		j++;
49 | 		n = n>>1;
50 | 	}
51 | 	cout<<endl;
52 | }
53 | 
54 | // Subset Sum - Dynamic Programming ...Later classes.
55 | 
56 | //German Lotto - Problem 
57 | 
58 | 
59 | 
60 | int main(){
61 | 
62 | 	char a[100];
63 | 	cin>>a;
64 | 	int len = strlen(a);
65 | 
66 | 	for(int i=0;i<(1<<len);i++){
67 | 		filterChars(a,i);
68 | 	}
69 | 
70 | 	return 0;
71 | }


--------------------------------------------------------------------------------
/Comp - 01/uniq_2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | 
 5 | int main(){
 6 | 
 7 | 	int a[] = {7,2,3,5,8,5,2,7};
 8 | 	int n = sizeof(a)/sizeof(int);
 9 | 	int res = 0;
10 | 	
11 | 	//First step - find xor of all
12 | 	for(int i=0;i<n;i++){
13 | 		res = res^a[i];
14 | 	}
15 | 	//second step find the position of last set bit from right
16 | 	int res_cpy = res;
17 | 	int pos = 0;
18 | 	
19 | 	while(!(res&1)){
20 | 		pos++;
21 | 		res = res>>1;
22 | 	}
23 | 
24 | 	//Generate the reqd mask
25 | 	int mask = 1<<pos;
26 | 
27 | 	//Filters the number having set at bit at position
28 | 	int setA = 0;
29 | 	for(int i=0;i<n;i++){
30 | 		if((a[i]&mask)>0){
31 | 			setA ^= a[i];
32 | 		}
33 | 	}
34 | 	
35 | 	int firstNo = setA;
36 | 	int secondNo = res_cpy^setA;
37 | 
38 | 	cout<<firstNo<<" and "<<secondNo<<endl;
39 | 
40 | 	return 0;
41 | }


--------------------------------------------------------------------------------
/Comp - 02/holi_graphs.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class Graph{
 5 | 	public:
 6 | 	unordered_map<int,list<pair<int,int> > > m;
 7 | 	int V;
 8 | 	Graph(int v){
 9 | 		V = v;
10 | 	}
11 | 
12 | 	void addEdge(int u,int v, int wt){
13 | 		m[u].push_back(make_pair(v,wt));
14 | 		m[v].push_back(make_pair(u,wt));
15 | 	}
16 | 	int dfsHelper(int s,bool *visited,int &ans){
17 | 		visited[s] = true;
18 | 		
19 | 		int subTreeSize = 1;
20 | 		int size = 0;
21 | 		for(auto neighbourPair:m[s]){
22 | 			
23 | 			int v = neighbourPair.first;
24 | 			int wt = neighbourPair.second;
25 | 
26 | 			if(!visited[v]){
27 | 				size = dfsHelper(v,visited,ans);
28 | 				//Later...
29 | 				ans += 2*wt*min(size,V-size);
30 | 				subTreeSize += size;
31 | 			}
32 | 		}
33 | 		return subTreeSize;
34 | 	}
35 | 
36 | 	int dfs(int s){
37 | 		int ans = 0;
38 | 		bool *visited = new bool[V+1]{0};
39 | 	 	dfsHelper(s,visited,ans);
40 | 	 	return ans;
41 | 	}
42 | };
43 | 
44 | int main(){
45 | 
46 | 	Graph g(4);
47 | 	g.addEdge(1,2,3);
48 | 	g.addEdge(2,3,2);
49 | 	g.addEdge(4,3,2);
50 | 	cout<<g.dfs(1)<<endl;
51 | 	return 0;
52 | }


--------------------------------------------------------------------------------
/Comp - 02/ternary_search_codeforces_427_e.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define ll long long
 4 | ll arr[1000000];
 5 | 	ll n,m;
 6 | 
 7 | //http://codeforces.com/problemset/problem/427/E
 8 | 
 9 | ll func(ll pos)
10 | {
11 | 	ll dis=0;
12 | 	
13 | 	for(int i=0;i<n&&arr[i]<pos;i+=m)
14 | 	{
15 | 		dis+=pos-arr[i];
16 | 	}
17 | 	for(int i=n-1;i>=0&&arr[i]>pos;i-=m)
18 | 	{
19 | 		dis+=arr[i]-pos;
20 | 	}
21 | 	return dis*2;
22 | }
23 | int main()
24 | {
25 | 	cin>>n>>m;
26 | 	for(int i=0;i<n;i++)
27 | 	{
28 | 		cin>>arr[i];
29 | 	}
30 | 	ll l=0,r=10000000ll;
31 | 	while(r-l>3)
32 | 	{
33 | 		ll mid1=l+(r-l)/3;
34 | 		ll mid2=r-(r-l)/3;
35 | 		if(func(mid1)<func(mid2))
36 | 		{
37 | 			r=mid2;
38 | 		}
39 | 		else
40 | 		{
41 | 			l=mid1;
42 | 		}
43 | 	}
44 | 	cout<<min(func(l),min(func(l+1),func(l+2)));
45 | }


--------------------------------------------------------------------------------
/Comp - 03/a.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/coding-blocks-archives/competitive-classroom-june-2018/8ab66a42dd513c28444db26acb7e945c3458f19f/Comp - 03/a.exe


--------------------------------------------------------------------------------
/Comp - 03/aggresive_cows.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | bool canPlace(int *stalls,int n,int cows,int dist){
 5 | 
 6 | 	int pos = stalls[0];
 7 | 	int c = 1;
 8 | 	for(int i=1;i<n;i++){
 9 | 		if(stalls[i]-pos>=dist){
10 | 			c++;
11 | 			pos = stalls[i];
12 | 			if(c==cows){
13 | 				return true;
14 | 			}
15 | 		}
16 | 	}
17 | 	return false;
18 | }
19 | 
20 | int binarySearch(int *stalls,int n,int cows){
21 | 	int s=0;
22 | 	int e = stalls[n-1]-stalls[0];
23 | 
24 | 	int ans = -1;
25 | 	while(s<=e){
26 | 		int mid = (s+e)/2;
27 | 
28 | 		if(canPlace(stalls,n,cows,mid)){
29 | 			ans = mid;
30 | 			s = mid + 1;
31 | 		}
32 | 		else{
33 | 			e = mid - 1;
34 | 		}
35 | 
36 | 
37 | 	}
38 | 	return ans;
39 | }
40 | 
41 | int main(){
42 | 	
43 | 	int stalls[] = {1,2,4,8,9};
44 | 	int cows = 3;
45 | 	cout<<binarySearch(stalls,5,cows)<<endl;
46 | 
47 | 
48 | 	return 0;
49 | }


--------------------------------------------------------------------------------
/Comp - 03/lower_bound.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int lowerBound(int *a,int n,int key){
 5 | 
 6 | 	int s = 0;
 7 | 	int e = n-1;
 8 | 
 9 | 	int ans = -1;
10 | 	while(s<=e){
11 | 		int mid = (s+e)/2;
12 | 
13 | 		if(a[mid]==key){
14 | 			ans = mid;
15 | 			e = mid -1;
16 | 		}
17 | 		else if(a[mid]<key){
18 | 			s = mid + 1;
19 | 		}
20 | 		else{
21 | 			e = mid - 1;
22 | 		}
23 | 	}
24 | 	return ans;
25 | }
26 | 
27 | int main(){
28 | 
29 | 	int a[] = {1,1,2,2,2,2,2,5,5,5,6};
30 | 	int n = sizeof(a)/sizeof(int);
31 | 
32 | 	cout<<lowerBound(a,n,2)<<endl;
33 | 
34 | 
35 | 	return 0;
36 | }


--------------------------------------------------------------------------------
/Comp - 03/readme.md:
--------------------------------------------------------------------------------
1 | - Aggresive Cows
2 | - CB Scholarship
3 | - Kth Root
4 | - Upper and Lower Bound
5 | - PRATA
6 | - Codejam18 - Bit Party(Round1B)
7 | - Segment Trees Basics(RMQ)
8 | - BRCKTS(Spoj)


--------------------------------------------------------------------------------
/Comp - 03/segment_trees.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | 
  4 | int lazy[100] = {0};
  5 | 
  6 | void buildTree(int *a,int *tree,int s,int e,int index){
  7 | 	//Base Case
  8 | 	if(s>e){
  9 | 		return;
 10 | 	}
 11 | 	if(s==e){
 12 | 		tree[index] = a[s];
 13 | 		return;
 14 | 	}
 15 | 	//Rec Case
 16 | 	int mid = (s+e)/2;
 17 | 	buildTree(a,tree,s,mid,2*index);
 18 | 	buildTree(a,tree,mid+1,e,2*index+1);
 19 | 	tree[index] = min(tree[2*index],tree[2*index + 1]);
 20 | 	return;
 21 | }
 22 | 
 23 | int query(int *tree,int index,int s,int e,int qs,int qe){
 24 | 	//No Overlap
 25 | 	if(qs>e || qe<s){
 26 | 		return INT_MAX;
 27 | 	}
 28 | 	else if(s>=qs && e<=qe){
 29 | 		return tree[index];
 30 | 	}
 31 | 	else{
 32 | 		int mid = (s+e)/2;
 33 | 		int left = query(tree,2*index,s,mid,qs,qe);
 34 | 		int right = query(tree,2*index+1,mid+1,e,qs,qe);
 35 | 		return min(left,right);
 36 | 	}
 37 | }
 38 | //Query Lazy
 39 | int queryLazy(int *tree,int index,int s,int e,int qs,int qe){
 40 | 	//Resolve all lazy values
 41 | 	//First Resolve the Lazy Value
 42 | 	if(lazy[index]!=0){
 43 | 		tree[index] += lazy[index];
 44 | 		if(s!=e){
 45 | 			lazy[2*index] += lazy[index];
 46 | 			lazy[2*index+1] += lazy[index];
 47 | 		}
 48 | 		lazy[index] = 0;
 49 | 	}
 50 | 
 51 | 	//No Overlap
 52 | 	if(qs>e || qe<s){
 53 | 		return INT_MAX;
 54 | 	}
 55 | 	else if(s>=qs && e<=qe){
 56 | 		return tree[index];
 57 | 	}
 58 | 	else{
 59 | 		int mid = (s+e)/2;
 60 | 		int left = queryLazy(tree,2*index,s,mid,qs,qe);
 61 | 		int right = queryLazy(tree,2*index+1,mid+1,e,qs,qe);
 62 | 		return min(left,right);
 63 | 	}
 64 | }
 65 | //Update - Point Update Vs Range Update
 66 | void update(int *tree,int index,int i,int increment,int s,int e){
 67 | 	//Out of bounds
 68 | 	if(i>e || i<s){
 69 | 		return;
 70 | 	}
 71 | 	//Leaf Node- Always Update (one leaf node of this type)
 72 | 	if(s==e){
 73 | 		tree[index] += increment;
 74 | 		return;
 75 | 	}
 76 | 	else{
 77 | 		//call both sides
 78 | 		int mid  = (s+e)/2;	
 79 | 		update(tree,2*index,i,increment,s,mid);
 80 | 		update(tree,2*index+1,i,increment,mid+1,e);
 81 | 		tree[index]  = min(tree[2*index],tree[2*index+1]);
 82 | 	}
 83 | 	return;
 84 | }
 85 | 
 86 | //Homework
 87 | void rangeUpdate(int *tree,int index,int i,int j,int inc,int s,int e){
 88 | 	//No Overlap
 89 | 	if(s>j||e<i){
 90 | 		return;
 91 | 	}
 92 | 	if(s==e){
 93 | 		tree[index] += inc;
 94 | 		return;
 95 | 	}
 96 | 	int mid = (s+e)/2;
 97 | 	rangeUpdate(tree,2*index,i,j,inc,s,mid);
 98 | 	rangeUpdate(tree,2*index+1,i,j,inc,mid+1,e);
 99 | 	tree[index] = min(tree[2*index],tree[2*index+1]);
100 | }
101 | 
102 | void rangeUpdateLazy(int *tree,int index,int i,int j,int inc,int s,int e){
103 | 	//First Resolve the Lazy Value
104 | 	if(lazy[index]!=0){
105 | 		tree[index] += lazy[index];
106 | 		if(s!=e){
107 | 			lazy[2*index] += lazy[index];
108 | 			lazy[2*index+1] += lazy[index];
109 | 		}
110 | 		lazy[index] = 0;
111 | 	}
112 | 
113 | 	//No Overlap
114 | 	if(s>j||e<i){
115 | 		return;
116 | 	}
117 | 	if(s==e){
118 | 		tree[index] += inc;
119 | 		return;
120 | 	}
121 | 	//Complete Overlap
122 | 	if(s>=i&&j<=e){
123 | 		tree[index] += inc;
124 | 		if(s!=e){
125 | 			lazy[2*index] += inc;
126 | 			lazy[2*index+1] += inc;
127 | 		}
128 | 		return;
129 | 	}
130 | 	int mid = (s+e)/2;
131 | 	rangeUpdate(tree,2*index,i,j,inc,s,mid);
132 | 	rangeUpdate(tree,2*index+1,i,j,inc,mid+1,e);
133 | 	tree[index] = min(tree[2*index],tree[2*index+1]);
134 | }
135 | 
136 | 
137 | 
138 | int main(){
139 | 	int a[] = {1,3,2,7,5};
140 | 	int n = 5;
141 | 	int *tree = new int[4*n+1];
142 | 	buildTree(a,tree,0,n-1,1);
143 | 
144 | 	/*for(int i=1;i<10;i++){
145 | 		cout<<tree[i]<<" ";
146 | 	}*/
147 | 
148 | 	//update(tree,1,0,10,0,n-1);
149 | 	//update(tree,1,1,10,0,n-1);
150 | 	rangeUpdate(tree,1,1,3,5,0,n-1);
151 | 
152 | 	int q;
153 | 	cin>>q;
154 | 
155 | 	while(q--){
156 | 		int qs,qe;
157 | 		cin>>qs>>qe;
158 | 		cout<<query(tree,1,0,n-1,qs,qe)<<endl;
159 | 
160 | 	}
161 | 
162 | 
163 | 	return 0;
164 | }


--------------------------------------------------------------------------------
/Comp - 03/square_root.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | float squareRoot(int n,int p){
 5 | 
 6 | 	int s = 0;
 7 | 	int e = n;
 8 | 
 9 | 	float ans = 0;
10 | 	while(s<=e){
11 | 		int mid = (s+e)/2;
12 | 
13 | 		if(mid*mid==n){
14 | 			return mid;
15 | 		}
16 | 		if(mid*mid<n){
17 | 			ans = mid;
18 | 			s = mid + 1;
19 | 		}
20 | 		else{
21 | 			e = mid - 1;
22 | 		}
23 | 	}
24 | 
25 | 	float inc = 0.1;
26 | 	for(int place=0;place<p;place++){
27 | 
28 | 		while(ans*ans <=n){
29 | 			ans += inc;
30 | 		}
31 | 		ans = ans - inc;
32 | 		inc = inc/10;
33 | 	}
34 | 
35 | 	return ans;
36 | }
37 | 
38 | int main(){
39 | 
40 | 	int n;
41 | 	cin>>n;
42 | 	int p;
43 | 	cin>>p;
44 | 
45 | 	cout<<squareRoot(n,p)<<endl;
46 | 
47 | 	return 0;
48 | }


--------------------------------------------------------------------------------
/Comp - 05 Persistent Trees , Mos/dquery_persistent.cpp:
--------------------------------------------------------------------------------
 1 | //dquery
 2 | #include<bits/stdc++.h>
 3 | using namespace std;
 4 | #define ll int
 5 | ll arr[300002],pre[2000001],seg[50000000],newindex=0,L[50000000],R[50000000],root[300002],coun[300002];
 6 | 
 7 | void build(ll id,ll l,ll r)
 8 | {
 9 | 
10 | 	if(l==r)
11 | 	{
12 | 		
13 | 		return;
14 | 	}
15 | 	ll mid=(l+r)/2;
16 | 	L[id]=newindex++;
17 | 	R[id]=newindex++;
18 | 	build(L[id],l,mid);
19 | 	build(R[id],mid+1,r);
20 | }
21 | ll update(ll st,ll in,ll u,ll l,ll r)
22 | {
23 | 	
24 | 	ll id=newindex++;
25 | 	if(l==r)
26 | 	{
27 | 		seg[id]=coun[l]+=u;
28 | 		return id;
29 | 	}
30 | 	L[id]=L[st];
31 | 	R[id]=R[st];
32 | 	ll mid=(l+r)/2;
33 | 	if(in<=mid)
34 | 	{
35 | 		L[id]=update(L[id],in,u,l,mid);
36 | 		seg[id]=seg[L[id]]+seg[R[id]];
37 | 	}
38 | 	else
39 | 	{
40 | 		R[id]=update(R[id],in,u,mid+1,r);
41 | 		seg[id]=seg[L[id]]+seg[R[id]];	
42 | 	}
43 | 	return id;
44 | }
45 | ll query(ll st,ll ql,ll qr,ll l,ll r)
46 | {
47 | 	if(l>qr||r<ql)
48 | 	{
49 | 		return 0;
50 | 	}
51 | 	if(l>=ql&&r<=qr)
52 | 	{
53 | 		return seg[st];
54 | 	}
55 | 	ll mid=(l+r)/2;
56 | 	return query(L[st],ql,qr,l,mid)+query(R[st],ql,qr,mid+1,r);
57 | }
58 | int main()
59 | {
60 | 	ll n,q;
61 | 	scanf("%d",&n);
62 | 	memset(pre,-1,sizeof(pre));
63 | 	build(0,0,n-1);
64 | 	for(int i=0;i<n;i++)
65 | 	{
66 | 		scanf("%d",&arr[i]);
67 | 		ll temp=0;
68 | 		if(i>0)
69 | 			temp=root[i-1];
70 | 		if(pre[arr[i]]!=-1)
71 | 		{
72 | 			temp=update(temp,pre[arr[i]],-1,0,n-1);
73 | 		}
74 | 		root[i]=update(temp,i,1,0,n-1);
75 | 		
76 | 		
77 | 		pre[arr[i]]=i;
78 | 	}
79 | 	scanf("%d",&q);
80 | 	for(int i=0;i<q;i++)
81 | 	{
82 | 		ll l,r;
83 | 		scanf("%d%d",&l,&r);
84 | 		l--;
85 | 		r--;
86 | 		printf("%d\n",query(root[r],l,r,0,n-1));	
87 | 	}
88 | }


--------------------------------------------------------------------------------
/Comp - 05 Persistent Trees , Mos/mkhthnum_persistent.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define ll long long
 4 | ll arr[2000000],root[2000000],L[2000000],R[2000000],seg[2000000],newindex;
 5 | vector<pair<ll,ll> > vec;
 6 | void build(ll l,ll r,ll id)
 7 | {
 8 | 	
 9 | 	if(l==r)
10 | 	{
11 | 		return;
12 | 	}
13 | 	ll mid=(l+r)/2;
14 | 	L[id]=newindex++;
15 | 	R[id]=newindex++;
16 | 	build(l,mid,L[id]);
17 | 	build(mid+1,r,R[id]);
18 | }
19 | ll update(ll st,ll l,ll r,ll in)
20 | {
21 | 	ll id=newindex++;
22 | 	
23 | 		if(l==r)
24 | 		{
25 | 			seg[id]=seg[st]+1;
26 | 			return id;
27 | 		}
28 | 		L[id]=L[st];
29 | 		R[id]=R[st];
30 | 		ll mid=(l+r)/2;
31 | 		if(in<=mid)
32 | 		{
33 | 			L[id]=update(L[st],l,mid,in);
34 | 		}
35 | 		else
36 | 		{
37 | 			R[id]=update(R[st],mid+1,r,in);
38 | 		}
39 | 		seg[id]=seg[L[id]]+seg[R[id]];
40 | 		return id;
41 | 	
42 | }
43 | ll query(ll l,ll r,ll rid,ll lid,ll k)
44 | {
45 | 	if(l==r)
46 | 	{
47 | 		return vec[l].first;
48 | 	}
49 | 	ll lcount=seg[L[rid]]-seg[L[lid]];
50 | 	ll mid=(l+r)/2;
51 | 	if(lcount<k)
52 | 	{
53 | 		return query(mid+1,r,R[rid],R[lid],k-lcount);
54 | 	}
55 | 	else
56 | 	{
57 | 		return query(l,mid,L[rid],L[lid],k);
58 | 	}
59 | }
60 | int main()
61 | {
62 | 	ios::sync_with_stdio(0);
63 | 	ll n,q;
64 | 	cin>>n>>q;
65 | 	build(0,n-1,0);
66 | 	for(int i=0;i<n;i++)
67 | 	{
68 | 		ll a;
69 | 		cin>>a;
70 | 		//arr[i]=a;
71 | 		vec.push_back(make_pair(a,i));
72 | 	}
73 | 	sort(vec.begin(),vec.end());
74 | 	for(int i=0;i<n;i++)
75 | 	{
76 | 		arr[vec[i].second]=i;
77 | 	}
78 | 	for(int i=0;i<n;i++)
79 | 	{
80 | 		
81 | 		if(i>0)
82 | 		root[i]=update(root[i-1],0,n-1,arr[i]);
83 | 		else
84 | 		root[i]=update(0,0,n-1,arr[i]);
85 | 	}
86 | 	for(int i=0;i<q;i++)
87 | 	{
88 | 		ll l,r,k;
89 | 		cin>>l>>r>>k;
90 | 		l--;
91 | 		r--;
92 | 		if(l>0)
93 | 		cout<<query(0,n-1,root[r],root[l-1],k)<<"\n";
94 | 		else
95 | 		cout<<query(0,n-1,root[r],0,k)<<"\n";
96 | 		
97 | 	}
98 | }


--------------------------------------------------------------------------------
/Comp - 05 Persistent Trees , Mos/mosintro.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #define ll long long
 4 | bool cmp(pair<ll,pair<ll,ll> > p1,pair<ll,pair<ll,ll> > p2)
 5 | {
 6 | 	if(p1.first/bucket!=p2.first/bucket)
 7 | 		return p1.first/bucket<p2.first/bucket;
 8 | 	return p1.second.first<p2.second.first;
 9 | }
10 | void add(ll i)
11 | {
12 | 	sum+=arr[i];
13 | }
14 | void remove(ll i)
15 | {
16 | 	sum-=arr[i];
17 | }
18 | int main()
19 | {
20 | 	ll n,q;
21 | 	cin>>n>>q;
22 | 	for(int i=0;i<n;i++)
23 | 	{
24 | 		cin>>arr[i];
25 | 	}
26 | 	for(int i=0;i<q;i++)
27 | 	{
28 | 		ll l,r;
29 | 		cin>>l>>r;
30 | 		vec.push_back(make_pair(l,make_pair(r,i)));
31 | 	}
32 | 	sort(vec.begin(),vec.end(),cmp);
33 | 	ll l=0,r=-1;
34 | 	for(int i=0;i<vec.size();i++)
35 | 	{
36 | 		while(r<vec[i].second.first)
37 | 		{
38 | 			r++;
39 | 			add(r);
40 | 		}
41 | 		while(r>vec[i].second.first)
42 | 		{
43 | 			remove(r);
44 | 			r--;
45 | 		}
46 | 		while(l<vec[i].first)
47 | 		{
48 | 			
49 | 			remove(l);
50 | 			l++;
51 | 		}
52 | 		while(l>vec[i].first)
53 | 		{
54 | 			l--;
55 | 			add(l);
56 | 		}
57 | 			
58 | 	}
59 | }


--------------------------------------------------------------------------------
/Comp - 05 Persistent Trees , Mos/persistent_segtree.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define ll long long
 4 | ll seg[100000000],newIndex=0,arr[1000000],L[1000000],R[1000000];
 5 | ll update(ll st,ll l,ll r,ll i,ll v)
 6 | {
 7 | 	ll id=newIndex++;
 8 | 	if(l==r)
 9 | 	{
10 | 		seg[id]=v;
11 | 		return id;
12 | 	}
13 | 	ll mid=(l+r)/2;
14 | 	L[id]=L[st];
15 | 	R[id]=R[st];
16 | 	if(i<=mid)
17 | 	{
18 | 		L[id]=update(L[st],l,mid,i,v);
19 | 	}
20 | 	else
21 | 	{
22 | 		R[id]=update(R[st],mid+1,r,i,v);
23 | 	}
24 | 	seg[id]=min(seg[L[id]],seg[R[id]]);
25 | 	return id;
26 | }
27 | ll query(ll st,ll l,ll r,ll ql,ll qr)
28 | {
29 | 	if(r<ql||l>qr)
30 | 		return INT_MAX;
31 | 	if(l>=ql&&r<=qr)
32 | 		return seg[st];
33 | 	ll mid=(l+r)/2;
34 | 	return min(query(L[st],l,mid,ql,qr),query(R[st],l,r,ql,qr));
35 | }
36 | int main()
37 | {
38 | 	ll n;
39 | 	cin>>n;
40 | 	for(int i=0;i<n;i++)
41 | 		cin>>arr[i];
42 | 	build();//
43 | 	ll q;
44 | 	cin>>q;
45 | 	ll nn=build();
46 | 	while(q--)
47 | 	{
48 | 		ll i,v;
49 | 		cin>>i>>v;
50 | 		ll n1=update(nn,0,n-1,i,v);
51 | 		ll n2=update(n1,0,n-1,i,v);
52 | 		ll l,r;
53 | 		cin>>i>>l>>r;
54 | 		cout<<query(n1,0,n-1,l,r);
55 | 	}
56 | }


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