├── Algorithms
    └── Pattern Matching
    │   ├── KMP.cpp
    │   ├── Naive Method.cpp
    │   └── Rabin Karp.cpp
├── Online Judge Sloutions
    ├── Codechef
    │   ├── COOK82A.cpp
    │   ├── COOK82B.cpp
    │   └── WSITES01.cpp
    ├── Codeforces
    │   └── 794A.cpp
    ├── Hackerrank
    │   ├── Candies.cpp
    │   ├── Equal.cpp
    │   ├── Fiind The Median.cpp
    │   ├── Insertion Sort Advanced Analysis.cpp
    │   ├── Kruskal (MST) Really Special Subtree.cpp
    │   └── Sherlock and Cost.cpp
    └── Spoj
    │   ├── ADDREV.cpp
    │   ├── AIBOHP.cpp
    │   ├── FCTRL.cpp
    │   ├── FCTRL2.cpp
    │   ├── NSTEPS.cpp
    │   ├── ONP.cpp
    │   ├── PRIME1.cpp
    │   ├── TEST.cpp
    │   ├── WACHOVIA.cpp
    │   ├── WILLITST.cpp
    │   └── ZSUM.cpp
└── README.md


/Algorithms/Pattern Matching/KMP.cpp:
--------------------------------------------------------------------------------
 1 | // Time Complexity O(n+m) in all cases
 2 | 
 3 | #include<bits/stdc++.h>
 4 | using namespace std;
 5 | typedef long long int ll;
 6 | void LPS(string pattern,ll m,vector<ll>  &lps)
 7 | {
 8 | 	lps[0]=0;
 9 | 	ll j=0;
10 | 	ll i=1;
11 | 	while(i<m)
12 | 	{
13 | 		if(pattern[i]==pattern[j])
14 | 		{
15 | 			j++;
16 | 			lps[i]=j;
17 | 			i++;
18 | 		}
19 | 		else
20 | 		{
21 | 			if(j==0)
22 | 			lps[i++]=0;
23 | 			else
24 | 			j=lps[j-1];
25 | 		}
26 | 	}
27 | }
28 | void KMPsearch(string text,string pattern)
29 | {
30 | 	ll n=text.size();
31 | 	ll m=pattern.size();
32 | 	vector<ll> lps(m);
33 | 	LPS(pattern,m,lps);
34 | 	ll i=0;
35 | 	ll j=0;
36 | 	while(i<n)
37 | 	{
38 | 		if(text[i]==pattern[j])
39 | 		{
40 | 			i++;
41 | 			j++;
42 | 		}
43 | 		if(j==m)
44 | 		{
45 | 			cout<<"PATTERN FOUND AT "<<i-j<<endl;
46 | 			j=lps[j-1];
47 | 		}
48 | 		else if(text[i]!=pattern[j] && i<n)
49 | 		{
50 | 			if(j==0)
51 | 			i++;
52 | 			else
53 | 			j=lps[j-1];
54 | 		}
55 | 	}
56 | }
57 | 
58 | int main()
59 | {
60 | 	string text,pattern;
61 | 	getline(cin,text);
62 | 	getline(cin,pattern);
63 | 	KMPsearch(text,pattern);
64 | 	return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/Algorithms/Pattern Matching/Naive Method.cpp:
--------------------------------------------------------------------------------
 1 | // Complexity O(n*(m-n+1))
 2 | 
 3 | 
 4 | #include<bits/stdc++.h>
 5 | using namespace std;
 6 | typedef long long int ll;
 7 | void search(string text,string pattern)
 8 | {
 9 | 	ll m=text.size();
10 | 	ll n=pattern.size();
11 | 	for(ll i=0;i<=m-n;i++)
12 | 	{
13 | 		ll j;
14 | 		for( j=0;j<n;j++)
15 | 		{
16 | 			if(text[i+j]!=pattern[j])
17 | 			break;
18 | 		}
19 | 		if(j==n)
20 | 		cout<<"PATTERN FOUND AT "<<i<<endl;
21 | 	}
22 | }
23 | int main()
24 | {
25 | 	string text,pattern;
26 | 	cin>>text>>pattern;
27 | 	search(text,pattern);
28 | 	return 0;
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/Algorithms/Pattern Matching/Rabin Karp.cpp:
--------------------------------------------------------------------------------
 1 | // Best Case And Average Case Time Complexity O(m+n)
 2 | // Worst Case time complexity O(mn)
 3 | 
 4 | 
 5 | #include<bits/stdc++.h>
 6 | using namespace std;
 7 | typedef long long int ll;
 8 | ll power(ll x,ll y,ll p)//MODULAR EXPONENTIATION
 9 | {
10 | 	ll res=1;
11 | 	x=x%p;
12 | 	while(y>0)
13 | 	{
14 | 		if(y&1)
15 | 		res=(res*x)%p;
16 | 		y=y>>1;
17 | 		x=(x*x)%p;
18 | 	}
19 | 	return res;
20 | }
21 | void search (string text,string pattern)
22 | {
23 | 	ll m=text.size();
24 | 	ll n=pattern.size();
25 | 	ll t=0;//Hash of pattern
26 | 	ll h=0;//Hash of text
27 | 	ll q=pow(10,9);
28 | 	ll p=power(10,n-1,q);
29 | 	//cout<<p<<endl;
30 | 	for(ll i=0;i<n;i++)
31 | 	{
32 | 		t=(10*t+pattern[i])%p;
33 | 		h=(10*h+text[i])%p;
34 | 	}
35 | 	for(int i=0;i<=m-n;i++)
36 | 	{
37 | 		if(h==t)
38 | 		{
39 | 			ll j;
40 | 			for( j=0;j<n;j++)
41 | 			{
42 | 				if(text[i+j]!=pattern[j])
43 | 				break;
44 | 			}
45 | 			if(j==n)
46 | 			cout<<"PATTERN FOUND AT "<<i<<endl;
47 | 		}
48 | 		
49 | 		if(i<m-n)
50 | 		{
51 | 			h=((10*(h-text[i]*p))+text[i+n])%p;
52 | 			if(h<0)
53 | 			h+=p;
54 | 		}
55 | 	}
56 | }
57 | int main()
58 | {
59 | 	string text,pattern;
60 | 	getline(cin,text);
61 | 	getline(cin,pattern);
62 | 	search(text,pattern);
63 | 	return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Codechef/COOK82A.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	int t;
 6 | 	cin>>t;
 7 | 	while(t--)
 8 | 	{
 9 | 		map<string,int> m;
10 | 		string s;
11 | 		int n;
12 | 		for(int i=0;i<4;i++)
13 | 		{
14 | 			cin>>s>>n;
15 | 			m[s]=n;
16 | 		}
17 | 		if(m["RealMadrid"]<m["Malaga"] && m["Barcelona"]>m["Eibar"])
18 | 		cout<<"Barcelona\n";
19 | 		else 
20 | 		cout<<"RealMadrid\n";
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Codechef/COOK82B.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int ll;
 4 | map<ll,ll> m;
 5 | #define MOD 1000000007
 6 | void primeFactors(ll n)
 7 | {
 8 |     while (n%2 == 0)
 9 |     {
10 |         m[2]++;
11 |         n = n/2;
12 |     }
13 |     for (ll i = 3; i*i <= n; i = i+2)
14 |     {
15 |         while (n%i == 0)
16 |         {
17 |             m[i]++;
18 |             n = n/i;
19 |         }
20 |     }
21 |     if (n > 2)
22 |         m[n]++;
23 | }
24 | ll power(ll x, ll y, ll p)
25 | {
26 |     ll res = 1;      // Initialize result
27 |  
28 |     x = x % p;  // Update x if it is more than or 
29 |                 // equal to p
30 |  
31 |     while (y > 0)
32 |     {
33 |         // If y is odd, multiply x with result
34 |         if (y & 1)
35 |             res = (res*x) % p;
36 |  
37 |         // y must be even now
38 |         y = y>>1; // y = y/2
39 |         x = (x*x) % p;  
40 |     }
41 |     return res;
42 | }
43 | int main()
44 | {
45 | 	ll n;
46 | 	cin>>n;
47 | 	ll a[n];
48 | 	for(ll i=0;i<n;i++) cin>>a[i];
49 | 	bool ty=true;
50 | 	for(ll i=1;i<n;i++)
51 | 	{
52 | 		if(a[i]!=a[i-1]) ty=false;
53 | 	}
54 | 	if(ty) {
55 | 	cout<<"justdoit\n";
56 | 	return 0;} 
57 | 	for(ll i=0;i<n;i++)
58 | 	{
59 | 		primeFactors(a[i]);
60 | 	}
61 | 	map<ll,ll>::iterator it;
62 | 	bool flag=true;
63 | 	for(it=m.begin();it!=m.end();it++)
64 | 	{
65 | 		if(it->second%n!=0) flag=false;
66 | 	}
67 | 	if(flag)
68 | 	{
69 | 		cout<<"justdoit\n";
70 | 		return 0;
71 | 	}
72 | 	ll me=n+1;
73 | 	for(it=m.begin();it!=m.end();it++)
74 | 	{
75 | 		it->second=it->second%me;
76 | 	}
77 | 	
78 | 	ll ans=1;
79 | 	//cout<<power(3,5,2)<<endl;
80 | 	for(it=m.begin();it!=m.end();it++)
81 | 	{
82 | 		ll ff=it->first;
83 | 		ll ss=it->second;
84 | 		if(ss==0) continue;
85 | 		ll p=power(ff,me-ss,MOD);
86 | 		ans=((ans%MOD)*(p%MOD))%MOD;
87 | 		
88 | 	}
89 | 	cout<<ans<<endl;
90 | 	return 0;
91 | }
92 | 
93 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Codechef/WSITES01.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | using namespace std;
  3 | typedef long long int ll;
  4 | //#define MOD 1000000007
  5 | int main()
  6 | {
  7 | 	ios::sync_with_stdio(false);
  8 | 	cin.tie(0);
  9 | 	ll MOD=1e9+7;
 10 | 	ll n;
 11 | 	cin>>n;
 12 | 	
 13 | 	char ch;
 14 | 	string s;
 15 | 	
 16 | 	vector<string> vu;
 17 | 	vector<string> vb;
 18 | 	
 19 | 	
 20 | 	
 21 | 	for(ll i=0;i<n;i++)
 22 | 	{
 23 | 		cin>>ch>>s;
 24 | 		if(ch=='+') vu.push_back(s);
 25 | 		else vb.push_back(s);
 26 | 	}
 27 | 	
 28 | 	if(vb.size()==0)
 29 | 	{
 30 | 		cout<<0<<endl;
 31 | 		return 0;
 32 | 	}
 33 | 	if(vu.size()==0)
 34 | 	{
 35 | 		set<char> rt;
 36 | 		for(ll i=0;i<vb.size();i++)
 37 | 		{
 38 | 			string x=vb[i];
 39 | 			rt.insert(x[0]);
 40 | 		}
 41 | 		cout<<rt.size()<<endl;
 42 | 		set<char>::iterator at;
 43 | 		for(at=rt.begin();at!=rt.end();at++) cout<<*at<<endl;
 44 | 		return 0;
 45 | 	}
 46 | 	
 47 | 	sort(vu.begin(),vu.end());
 48 | 	sort(vb.begin(),vb.end());
 49 | 	
 50 | 	
 51 | 	
 52 | 	map<ll,set<ll> > m;
 53 | 	
 54 | 	ll p1=vu.size();
 55 | 	
 56 | 	for(ll i=0;i<p1;i++)
 57 | 	{
 58 | 		string x=vu[i];
 59 | 		ll p=x.size();
 60 | 		ll y=0;
 61 | 		for(ll j=0;j<p;j++)
 62 | 		{
 63 | 			ll qwer=pow((x[j]-'a'+8-1),j+4+1+1+1);
 64 | 			y+=qwer;
 65 | 			m[j].insert(y);
 66 | 			//cout<<j<<" "<<m[j].size()<<endl;
 67 | 		}
 68 | 	}
 69 | 	
 70 | 	ll p2=vb.size();
 71 | 	map<ll,ll> ans;   // this stores upto which index that string i need in final answer 
 72 | 	for(ll i=0;i<p2;i++)
 73 | 	{
 74 | 		string y=vb[i];
 75 | 		ll p=y.size();
 76 | 		ll x=0;
 77 | 		bool flag=false;
 78 | 		for(ll j=0;j<p;j++)
 79 | 		{
 80 | 			ll qwer=pow((y[j]-'a'+8-1),j+4+1+1+1);
 81 | 			x+=qwer;
 82 | 			if(m[j].find(x)==m[j].end() || m[j].size()==0) 
 83 | 			{
 84 | 				ans[i]=j;
 85 | 				flag=true;
 86 | 				break;
 87 | 			}
 88 | 		}
 89 | 		if(!flag)
 90 | 		{
 91 | 			cout<<-1<<endl;
 92 | 			return 0;
 93 | 		}
 94 | 		//cout<<y<<" "<<ans[i]<<" ";
 95 | 	}
 96 | 	//cout<<endl;
 97 | 	// cout<<p2<<endl;
 98 | 	/*for(ll i=0;i<p2;i++)   /// Prlling all the optimized blocked sites before comparing them with all other blocled sites
 99 | 	{
100 | 		string x=vb[i];
101 | 		for(ll j=0;j<=ans[i];j++)
102 | 		{
103 | 			cout<<x[j];
104 | 		}
105 | 		cout<<endl;
106 | 	}*/
107 | 	
108 | 	
109 | 	map<ll,set<ll> > ansfinal; 
110 | 	ll ret[p2]={0};                    // if in the end ret[i]=1 that means that is the final anwer after compaaring
111 | 	for(ll i=p2-1;i>=0;i--)
112 | 	{
113 | 		string x=vb[i];
114 | 		ll p=0;
115 | 		for(ll j=0;j<=ans[i];j++)
116 | 		{
117 | 			ll qwer=pow((x[j]-'a'+8-1),j+4+1+1+1);
118 | 			
119 | 			p+=qwer;
120 | 		}
121 | 		if(ansfinal[ans[i]].find(p)==ansfinal[ans[i]].end() || ansfinal[ans[i]].size()==0) 
122 | 		{
123 | 			ret[i]=1;
124 | 			p=0;
125 | 			for(ll j=0;j<=ans[i];j++)
126 | 			{ 
127 | 				ll qwer=pow((x[j]-'a'+7),j+4+1+1+1);
128 | 				p+=qwer;
129 | 				ansfinal[j].insert(p);
130 | 			}
131 | 		}
132 | 		
133 | 	}
134 | 	ll k=0;
135 | 	for(ll i=0;i<p2;i++) 
136 | 	{
137 | 		if(ret[i]) k++;
138 | 	}
139 | 	//cout<<k<<endl;
140 | 	set<string> an;
141 | 	for(ll i=0;i<p2;i++)
142 | 	{
143 | 		string h=vb[i];
144 | 		if(ret[i])
145 | 		{
146 | 			string p;
147 | 			for(ll j=0;j<=ans[i];j++)
148 | 			{
149 | 				p+=h[j];
150 | 			}
151 | 			an.insert(p);
152 | 		}
153 | 	}
154 | 	
155 | 	
156 | 	
157 | 	cout<<an.size()<<endl;
158 | 	set<string>::iterator it;
159 | 	for(it=an.begin();it!=an.end();it++) cout<<*it<<endl;
160 | 	return 0;
161 | }
162 | 
163 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Codeforces/794A.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int ll;
 4 | 
 5 | int main()
 6 | {
 7 | 	ll a,b,c;
 8 | 	cin>>a>>b>>c;
 9 | 	ll n;
10 | 	cin>>n;
11 | 	map<ll,ll> m;
12 | 	ll aa;
13 | 	for(ll i=0;i<n;i++)
14 | 	{
15 | 		cin>>aa;
16 | 		m[aa]++;
17 | 	}
18 | 	
19 | 	map<ll,ll>::iterator it;
20 | 	ll ans=0;
21 | 	
22 | 	for(it=m.begin();it!=m.end();it++)
23 | 	{
24 | 		if(it->first>b && it->first<c) ans+=it->second;
25 | 	}
26 | 	cout<<ans<<endl;
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Hackerrank/Candies.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int ll;
 4 | int main()
 5 | {
 6 |     ll n;
 7 |     cin>>n;
 8 |     ll a[n];
 9 |     for(ll i=0;i<n;i++) cin>>a[i];
10 |     ll ans[n]={0};
11 |     ans[0]=1;
12 |     for(ll i=1;i<n;i++)
13 |     {
14 |         if(a[i]>a[i-1]) ans[i]=ans[i-1]+1;
15 |         else ans[i]=1;
16 |     }
17 |     /*for(int i=0;i<n;i++) cout<<ans[i]<<" ";
18 |     cout<<endl;*/
19 |     for(ll i=n-2;i>=0;i--)
20 |     {
21 |         if(a[i]>a[i+1]) 
22 |         {
23 |             if(ans[i]>ans[i+1]) continue;
24 |             else ans[i]=ans[i+1]+1;
25 |         }
26 |         else if(a[i]<a[i+1])
27 |         {
28 |             if(ans[i]<ans[i+1]) continue;
29 |             else ans[i]=ans[i+1]-1;
30 |         }
31 |     }
32 |     /*for(int i=0;i<n;i++) cout<<ans[i]<<" ";
33 |     cout<<endl;*/
34 |     ll final=0;
35 |     for(ll i=0;i<n;i++) final+=ans[i];
36 |     cout<<final<<endl;
37 |     return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Hackerrank/Equal.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int ll;
 4 | ll calc(ll a,ll b)
 5 | {
 6 | 	ll x=a-b;
 7 | 	ll k = x/5 +(x%5)/2 + (x%5)%2 ;
 8 | 	return k;
 9 | }
10 | int main()
11 | {
12 |     ios::sync_with_stdio(false);
13 |     cin.tie(NULL);
14 | 	ll t;
15 | 	cin>>t;
16 | 	while(t--)
17 | 	{
18 | 		ll n;
19 | 		cin>>n;
20 | 		ll a[n];
21 | 		for(ll i=0;i<n;i++)
22 | 		{
23 | 			cin>>a[i];
24 | 		}
25 | 		sort(a,a+n);
26 | 		ll ans[n][6];
27 | 		
28 | 		ans[0][0]=0;
29 | 		ans[0][1]=1;
30 | 		ans[0][2]=1;
31 | 		ans[0][3]=ans[0][4]=2;
32 | 		ans[0][5]=1;
33 | 		
34 | 		for(ll i=1;i<n;i++)
35 | 		{
36 | 			for(ll j=0;j<6;j++)
37 | 			{
38 | 				ans[i][j]=calc(a[i],a[0]-j);
39 | 			}
40 | 		}
41 | 		for(ll i=0;i<6;i++)
42 | 		{
43 | 			for(ll j=1;j<n;j++)
44 | 			{
45 | 				ans[j][i]+=ans[j-1][i];
46 | 			}
47 | 		}
48 | 		ll final=1e18;
49 | 		for(ll i=0;i<6;i++)
50 | 		{
51 | 			final=min(final,ans[n-1][i]);
52 | 		}
53 | 		cout<<final<<endl;
54 | 	}
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Hackerrank/Fiind The Median.cpp:
--------------------------------------------------------------------------------
 1 | #include <cmath>
 2 | #include <cstdio>
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | 
 8 | 
 9 | int main() {
10 |    int n;
11 |     cin>>n;
12 |     int a[n];
13 |     for(int i=0;i<n;i++)
14 |         cin>>a[i];
15 |     sort(a,a+n);
16 |     cout<<a[n/2];
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Hackerrank/Insertion Sort Advanced Analysis.cpp:
--------------------------------------------------------------------------------
 1 | //Time Complexity O(nlogn)
 2 | 
 3 | #include<bits/stdc++.h>
 4 | using namespace std;
 5 | typedef long long int ll;
 6 | 
 7 | ll merge(vector<ll> &v,vector<ll> &temp,ll left,ll mid,ll right)
 8 | {
 9 | 	ll i=left;
10 | 	ll j=mid+1;
11 | 	ll k=left; // for temp array
12 | 	ll inv_count=0;
13 | 	while(i<=mid && j<=right)
14 | 	{
15 | 		if(v[i]<=v[j])
16 | 		{
17 | 			temp[k++]=v[i++];
18 | 		}
19 | 		else
20 | 		{
21 | 			temp[k++]=v[j++];
22 | 			inv_count+=mid-i+1;
23 | 		}
24 | 		
25 | 	}
26 | 	while(i<=mid)
27 | 	temp[k++]=v[i++];
28 | 	while(j<=right)
29 | 	temp[k++]=v[j++];
30 | 	for(ll p=left;p<=right;p++)
31 | 	v[p]=temp[p];
32 | 	return inv_count;
33 | }
34 | 
35 | ll mergesort(vector<ll> &v, vector<ll> &temp,ll left,ll right)
36 | {
37 | 	ll inv_count=0,mid;
38 | 	if(left<right)
39 | 	{
40 | 		mid=(left+right)/2;
41 | 		inv_count+=mergesort(v,temp,left,mid);
42 | 		inv_count+=mergesort(v,temp,mid+1,right);
43 | 		inv_count+=merge(v,temp,left,mid,right); 
44 | 		
45 | 	}
46 | 	return inv_count;
47 | }
48 | 
49 | ll count (vector<ll> &v, ll n)
50 | {
51 | 	vector<ll> temp(n);
52 | 	return mergesort(v,temp,0,n-1);
53 | }
54 | 
55 | 
56 | int main()
57 | {
58 |     ll t;
59 |     cin>>t;
60 |     while(t--){
61 | 	ll n;
62 | 	cin>>n;
63 | 	vector<ll> v(n);
64 | 	for(ll i=0;i<n;i++)
65 | 	{
66 | 		cin>>v[i];
67 | 	}
68 |         cout<<count(v,n)<<endl;}
69 | 	//for(ll i=0;i<n;i++)
70 | //	{
71 | 	//	cout<<v[i]<<" ";
72 | 	//}
73 | 	return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Hackerrank/Kruskal (MST) Really Special Subtree.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int v,e;
 4 | vector<pair<int,pair<int,int> > > ve;
 5 | vector<int> par;
 6 | vector<int> ranke;
 7 | vector<int > ans;
 8 | int find(int p)
 9 | {
10 |     while(p!=par[p])
11 |     p=par[p];
12 |     return p;
13 | }
14 | void unions(int p,int q)
15 | {
16 |     
17 |     if(ranke[p]>ranke[q])
18 |     {
19 |         par[q]=p;
20 |     }
21 |     else
22 |     {
23 |         par[p]=q;
24 |         
25 |         //rank[q]+=1;
26 |     }
27 |     if(ranke[p]==ranke[q])
28 |     {
29 |         ranke[q]++;
30 |     }
31 | }
32 | int main()
33 | {
34 |     cin>>v>>e;
35 |     ve.resize(e);
36 |     par.resize(v);
37 |     ranke.resize(v);
38 |     ans.resize(e);
39 |     for(int i=0;i<v;i++)
40 |     {
41 |         par[i]=i;
42 |         ranke[i]=0;
43 |     }
44 |     for(int i=0;i<e;i++)
45 |     {
46 |         ans[i]=0;
47 |        
48 |         cin>>ve[i].second.first;
49 |         cin>>ve[i].second.second;
50 |          cin>>ve[i].first;
51 |     }
52 |     sort(ve.begin(),ve.end());
53 |     for(int i=0;i<e;i++)
54 |     {
55 |         int p=ve[i].second.first;
56 |         int q=ve[i].second.second;
57 |         if(find(p)!=find(q))
58 |         {
59 |             unions(find(p),find(q));
60 |             ans[i]=1;
61 |         }
62 |         //for(int i=;i<v;i++)
63 |     }
64 |     int fi=0;
65 |     for(int i=0;i<e;i++)
66 |     {
67 |         if(ans[i]) fi+=ve[i].first;
68 |     }
69 |     cout<<fi<<endl;
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Hackerrank/Sherlock and Cost.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | #include<cstring>
 4 | using namespace std;
 5 | 
 6 | int b[100000];
 7 | int dp[100000][2];
 8 | 
 9 | int main()
10 | {
11 | 	int t;
12 | 	cin >> t;
13 | 	while (t--)
14 | 	{
15 | 		memset(dp, 0, sizeof(dp));
16 | 		int n;
17 | 		cin >> n;
18 | 		for (int i = 0; i < n; i++)
19 | 			cin >> b[i];
20 | 		for (int i = 1; i < n; i++)
21 | 		{
22 | 			dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + abs(b[i - 1] - 1));
23 | 			dp[i][1] = max(dp[i - 1][0] + abs(b[i] - 1), dp[i - 1][1]);
24 | 		}
25 | 		cout << max(dp[n - 1][0], dp[n - 1][1]) << endl;
26 | 	}
27 | 	return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/ADDREV.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | #include<cmath>
 4 | using namespace std;
 5 | int rev(int);
 6 | int main()
 7 | {
 8 | 	int t;
 9 | 	cin>>t;
10 | 	while(t--)
11 | 	{
12 | 		int m,n;
13 | 		int r,s;
14 | 		cin>>m>>n;
15 | 		r=rev(m);
16 | 		s=rev(n);
17 | 		cout<<rev(r+s);
18 | 		cout<<endl;
19 | 	}
20 | 	return 0;
21 | }
22 | int rev(int x)
23 | {
24 | 	int a=x;
25 | 	int re=0,count=0;
26 | 	while(a>0)
27 | 	{
28 | 		count++;
29 | 		a/=10;
30 | 	}
31 | 	int base=pow(10,count-1);
32 | 	while(x>0)
33 | 	{
34 | 		re=re+(x%10)*base;
35 | 		base/=10;
36 | 		x/=10;
37 | 	}
38 | 	return re;
39 | }
40 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/AIBOHP.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int ll;
 4 | ll lcs(string &s,string &y)
 5 | {
 6 | 	ll n=s.size();
 7 | 	ll a[n+1][n+1];
 8 | 	for(ll i=0;i<=n;i++)
 9 | 	{
10 | 		for(ll j=0;j<=n;j++)
11 | 		{
12 | 			if(i==0 || j==0)
13 | 			a[i][j]=0;
14 | 			else if(s[i-1]==y[j-1])
15 | 			a[i][j]=a[i-1][j-1]+1;
16 | 			else
17 | 			a[i][j]=max(a[i-1][j],a[i][j-1]);
18 | 		}
19 | 	}
20 | 	return a[n][n];
21 | }
22 | int main()
23 | {
24 | 	ios_base::sync_with_stdio(false);
25 | 	ll t;
26 | 	cin>>t;
27 | 	string s,y,n;
28 | 	while(t--)
29 | 	{
30 | 		cin>>s;
31 | 		ll n=s.size();
32 | 		y.resize(n);
33 | 		reverse_copy(s.begin(),s.end(),y.begin());
34 | 		cout<<n-lcs(s,y)<<endl;
35 | 	}
36 | 	return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/FCTRL.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	int t;
 6 | 	cin>>t;
 7 | 	while(t--)
 8 | 	{
 9 | 		int n;
10 | 		cin>>n;
11 | 		int h=5,count=0;
12 | 		while(h<=n)
13 | 		h*=5;
14 | 		while(h>=5)
15 | 		{
16 | 		count=count+(n/h);
17 | 		h/=5;
18 | 		}
19 | 		cout<<count<<endl;
20 | 	}
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/FCTRL2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include<string>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 | 	int t;
 7 | 	cin>>t;
 8 | 	while(t--)
 9 | 	{
10 | 	
11 | 	int n;
12 | 	cin>>n;
13 | 	int i=1;
14 | 	int a[200]={0};
15 | 	a[199]=1;
16 | 	int b[200]={0};
17 | 	b[199]=1;
18 | 	while(i<n)
19 | 	{
20 | 		for(int j=1;j<=i;j++)
21 | 		{
22 | 			int t=0;
23 | 			for(int k=199;k>=0;k--)
24 | 			{
25 | 				
26 | 						b[k]=b[k]+a[k]+t;
27 | 						t=0;
28 | 						if(b[k]>9)
29 | 						{
30 | 							t=1;
31 | 							b[k]=b[k]%10;
32 | 							
33 | 						}
34 | 			}
35 | 			
36 | 		}
37 | 		
38 | 		for(int k=0;k<200;k++)
39 | 			a[k]=b[k];
40 | 			i++;
41 | 	}
42 | 	for(i=0;i<200;i++)
43 | 	{
44 | 		if(a[i]!=0)
45 | 		break;
46 | 	}
47 | 	for(int k=i;k<200;k++)
48 | 	cout<<a[k];
49 | 	cout<<endl;
50 | }
51 | 	return 0;
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/NSTEPS.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	int t;
 6 | 	cin>>t;
 7 | 	while(t--)
 8 | 	{
 9 | 		int x,y;
10 | 		cin>>x>>y;
11 | 		if(x==y && x%2==0)
12 | 		cout<<x*2<<endl;
13 | 		else if(x==y && x%2!=0)
14 | 		cout<<2*x-1<<endl;
15 | 		else if(x-2==y && y%2==0)
16 | 		cout<<2*x-2<<endl;
17 | 		else if(x-2==y && y%2!=0)
18 | 		cout<<2*x-3<<endl;
19 | 		else
20 | 		cout<<"No Number"<<endl;
21 | 	}
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/ONP.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stack>
 3 | #include<algorithm>
 4 | using namespace std;
 5 | int main()
 6 | {
 7 | 	int t;
 8 | 	cin>>t;
 9 | 	while(t--)
10 | 	{
11 | 		 string s;
12 | 		 stack<char> p;
13 | 		 cin>>s;
14 | 		 int i=0;
15 | 		 while(s[i]!=NULL)
16 | 		 {
17 | 		 	if(s[i]=='(' || s[i]=='+' || s[i]=='-' || s[i]=='*' || s[i]=='/' || s[i]=='^')
18 | 		 	p.push(s[i]);
19 | 		 	else if(s[i]==')')
20 | 		 	{
21 | 		 		while(p.top()!='(')
22 | 		 		{
23 | 		 			cout<<p.top();
24 | 		 			p.pop();
25 | 		 		}
26 | 		 		p.pop();
27 | 		 	}
28 | 		 	else
29 | 		 	cout<<s[i];
30 | 		 	i++; 
31 | 		 }
32 | 		 cout<<endl;
33 | 	}
34 | 	return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/PRIME1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | int main()
 5 | {int t;
 6 | cin>>t;
 7 | while(t--){
 8 | 	int m,n;
 9 | 	cin>>m>>n;
10 | 	int i,j;
11 | 	
12 | 	for(i=m;i<=n;i++){
13 | 		int count=0;
14 | 		for(j=2;j*j<=i;j++)
15 | 		{   if(count==0){
16 | 		
17 | 			if(i%j==0)
18 | 			count++;}
19 | 		}
20 | 		if(count==0 && i!=1)
21 | 		cout<<i<<endl;
22 | 	}
23 | }
24 | return 0;
25 | }
26 | 	
27 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/TEST.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 |  
 3 | int main(void) {
 4 | 	int a;
 5 | 	scanf("%d\n",&a);
 6 | 	while(a!=42)
 7 | 	{
 8 | 		printf("%d\n",a);
 9 | 		scanf("%d\n",&a);
10 | 	}
11 | 	return 0;
12 | } 
13 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/WACHOVIA.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int ll;
 4 | int main()
 5 | {
 6 | 	ll t;
 7 | 	cin>>t;
 8 | 	while(t--)
 9 | 	{
10 | 		ll W,m;
11 | 		cin>>W>>m;
12 | 		ll wt[m];
13 | 		ll val[m];
14 | 		for(ll i=0;i<m;i++)
15 | 		{
16 | 			cin>>wt[i]>>val[i];
17 | 		}
18 | 		ll a[m+1][W+1];
19 | 		
20 | 		for(ll i=0;i<=m;i++)
21 | 		{
22 | 			for(ll j=0;j<=W;j++)
23 | 			{
24 | 				if(j==0 || i==0)
25 | 				a[i][j]=0;
26 | 				else if(wt[i-1]<=j)
27 | 				{
28 | 					a[i][j]=max(val[i-1]+a[i-1][j-wt[i-1]],a[i-1][j]);
29 | 				}
30 | 				else
31 | 				a[i][j]=a[i-1][j];
32 | 			}
33 | 		}
34 | 		cout<<"Hey stupid robber, you can get "<<a[m][W]<<"."<<endl;
35 | 	}
36 | 	return 0;
37 | } 
38 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/WILLITST.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 | 	long long int n;
 7 | 	cin>>n;
 8 | 	long long int j=n;
 9 | 	int flag=0;
10 | 	while(n>1)
11 | 	{
12 | 		if((n%2)!=0)
13 | 		{
14 | 			flag=1;
15 | 			
16 | 			break;
17 | 		}
18 | 		n=n/2;
19 | 	}
20 | 	if(flag || j==1)
21 | 	cout<<"NIE"<<endl;
22 | 	else
23 | 	cout<<"TAK"<<endl;
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/Online Judge Sloutions/Spoj/ZSUM.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | long long int power(long long int x,long long int y, long long int p)
 5 | {
 6 |    long long int res = 1;    
 7 |  
 8 |     x = x % p;  
 9 |  
10 |     while (y > 0)
11 |     {
12 |         
13 |         if (y & 1)
14 |             res = (res*x) % p;
15 |  
16 |        
17 |         y = y>>1; // y = y/2
18 |         x = (x*x) % p;  
19 |     }
20 |     return res;
21 | }
22 | int main()
23 | {
24 |  
25 | 	while(1){
26 | 	
27 | 	 long long int n,k;
28 | 	 cin>>n>>k;
29 | 	 if(n==0 && k==0)
30 | 	 break;
31 | 	 long long int p=power(n,k,10000007);
32 | 	  long long int q=power(n,n,10000007);
33 | 	   long long int r=power(n-1,k,10000007);
34 | 	    long long int s=power(n-1,n-1,10000007);
35 | 	   
36 | 	    cout<<((p+q+2*r+2*s)%10000007)<<endl;
37 | 	}    return 0;
38 | } 
39 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Competitive-Programming
2 | My collection of Data Structures and Algorithms implemented in C++.I feel that these algorithms and data structures are very important for ACM ICPC &amp; Google Kickstart. This repository also contains my accepted solutions of questions on various online judges.
3 | 


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