├── README.md
├── SPOJ GIRLSNBS.cpp
├── SPOJ CRDS.c
├── SPOJ BOMARBLE (Pentagonal Numbers).cpp
├── SPOJ MLK.cpp
├── SPOJ WILLITST ( Check if Number is a power of 2 ).cpp
├── SPOJ MOHIB.cpp
├── SPOJ MANGOES.cpp
├── SPOJ ACPC10A.cpp
├── SPOJ NICEBTRE.cpp
├── SPOJ ATOMS.cpp
├── SPOJ NSTEPS.cpp
├── SPOJ OHANISER.cpp
├── SPOJ ACMT.cpp
├── SPOJ AP2.cpp
├── SPOJ FAVDICE (Read the Comments).cpp
├── SPOJ CANDY.cpp
├── SPOJ MIRRORED ( As soon as Input String is two spaces break ( Check the code for implementation ) ).cpp
├── SPOJ HC.cpp
├── SPOJ UJ ( Using JAVA BigInteger ).java
├── SPOJ ADDREV.cpp
├── SPOJ BEENUMS.cpp
├── SPOJ BYTELANDIAN COINS.c
├── SPOJ MARBLES (Calculating Factorial the Maths Way).cpp
├── SPOJ FARIDA (DP).cpp
├── SPOJ PEBBLE.cpp
├── SPOJ CODERE2.cpp
├── SPOJ ABSYS.cpp
├── SPOJ DIEHARD.cpp
├── SPOJ BWIDOW.cpp
├── SPOJ KNAPSACK.cpp
├── SPOJ MMAXPER.c
├── SPOJ HPYNOS.cpp
├── SPOJ NOVICE63 (DP).cpp
├── SPOJ WPC5D.cpp
├── SPOJ PQUEUE ( Priority Queue and STL ).cpp
├── SPOJ IOIPALIN.cpp
├── SPOJ IOIPALIN.c
├── SPOJ WACHOVIA (KNAPSACK).cpp
├── SPOJ TOANDFRO.cpp
├── SPOJ AGGRCOW.cpp
├── SPOJ HOMO.cpp
├── SPOJ OFORTUNE.cpp
├── SPOJ AIBOHP.c
├── SPOJ HDEVIL.cpp
├── SPOJ BUSYMAN.cpp
├── SPOJ EDIST.c
├── SPOJ DIVFACT.cpp
├── SPOJ CODFURY ( Same as SPOJ ALIEN ).cpp
├── SPOJ PARTY SCHEDULE.cpp
├── SPOJ PT07Y.cpp
├── SPOJ HOTELS ( Variation of Kardane's Algorithm (Used to find Maximum Sum Subarray ) here modified for a maxsum ).cpp
├── SPOJ ALIEN (Modified Kadane's Algorithm) ( Here if number of steps is same then we choose the one with the lesser sum ) ( Like SPOJ HOTELS ).cpp
├── SPOJ FIBOSUM( Matrix Expo and for Fibonacci Series S(n)=F(n 2)-1 ).cpp
├── SPOJ THEATRE.cpp
├── SPOJ MECGROUP.cpp
├── SPOJ XOR MAXIMIZATION.cpp
├── SPOJ ACODE (DP with a special requirement).cpp
├── SPOJ CATM.cpp
├── SPOJ ANARC09A (Check if the expression is balanced using Stack ( here it's variation is used )).cpp
├── SPOJ MIXTURE DP O(n^3) [Only above diagonal elements required, values of rows and columns chosen smartly and all the values in between them considered].cpp
├── SPOJ ONEZERO (String Remainder Function there but not used).cpp
├── SPOJ PT07Z.cpp
├── SPOJ MCOINS ( Game Theory - Read the Comments ).cpp
├── SPOJ BUGLIFE (Bipartite Graph - Read the Comments ).cpp
├── SPOJ QUEST5 (Count Overlapping Intervals).cpp
├── SPOJ PT07X - Vertex Cover.cpp
├── SPOJ EZDIJKST (using REP(i,a,b)).cpp
├── SPOJ RPLN ( Range Minimum Query ).cpp
├── SPOJ HIGHWAYS.cpp
├── SPOJ TRVCOST.cpp
├── SPOJ COMDIV.cpp
├── SPOJ COUNTISL ( DFS in 2D Matrix ).cpp
├── SPOJ LKS.cpp
├── SPOJ EZDIJKST.cpp
├── SPOJ BRCKTS.cpp
├── SPOJ D-query (Using MO's Algorithm).cpp
├── SPOJ ABCPATH.cpp
├── SPOJ KGSS.cpp
├── SPOJ ABSP1.cpp
├── SPOJ ORDERSET(Using C++14 Features).cpp
├── SPOJ KGSS (Query Differently).cpp
├── SPOJ GONE.cpp
├── SPOJ KGSS - Simple Solution.cpp
├── SPOJ SHPATH (Dijsktra).cpp
├── SPOJ RAONE (Digit DP).cpp
├── SPOJ HAYBALE.cpp
├── SPOJ RPLD.cpp
├── SPOJ ARRAYSUB (  Find the maximum for each and every contiguous subarray of size k ).cpp
├── SPOJ LITE.cpp
├── SPOJ UPDATEIT ( Done like CHOC on CODECHEF ).cpp
├── SPOJ POTHOLE.cpp
├── SPOJ HORRIBLE.cpp
├── SPOJ GSS1.cpp
├── SPOJ LUCIFER.cpp
├── SPOJ UPDATEIT ( FAST IO Required for Segment Trees ).cpp
├── SPOJ GSS3.cpp
├── SPOJ CSTREET (MST).cpp
├── SPOJ ORDERSET (Segment Tree offline query) (Read the Comments).cpp
├── SPOJ CNTPRIME.cpp
└── SPOJ BITMAP.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # SPOJ-Solutions
2 | SPOJ solutions by anmol_varshney
3 | 
4 | Suggestions are welcome. You can mail me at anmolvarshney695@gmail.com
5 | 


--------------------------------------------------------------------------------
/SPOJ GIRLSNBS.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int g,b;
 6 | 	scanf("%d%d",&g,&b);
 7 | 	while(g!=-1&&b!=-1)
 8 | 	{
 9 | 		int ans=ceil((double)max(g,b)/(min(g,b)+1));
10 | 		printf("%d\n",ans);
11 | 		scanf("%d%d",&g,&b);
12 | 	}
13 | 	return 0;
14 | }


--------------------------------------------------------------------------------
/SPOJ CRDS.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(void) {
 4 | 	int t;
 5 | 	long long int sum=0;
 6 | 	long long int n,i;
 7 | 	scanf("%d",&t);
 8 | 	while(t--)
 9 | 	{
10 | 		sum=2;
11 | 		scanf("%lld",&n);
12 | 		sum=(n*(1+3*n))/2;
13 | 		sum=sum%1000007;
14 | 		printf("%lld\n",sum);
15 | 	}
16 | 	return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/SPOJ BOMARBLE (Pentagonal Numbers).cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 | 	int n;
 7 | 	scanf("%d",&n);
 8 | 	while(n!=0)
 9 | 	{
10 | 		n++;
11 | 		long long int ans=(n * (3 * n - 1))/2;
12 | 		printf("%lld\n",ans);
13 | 		scanf("%d",&n);
14 | 	}
15 | 	return 0;
16 | }


--------------------------------------------------------------------------------
/SPOJ MLK.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int n;
 6 | 	while(scanf("%d",&n)!=0&&n!=0)
 7 | 	{
 8 | 		long long int x,sum=0,cost=0;
 9 | 		for(int i=0;i<n;i++)
10 | 		{
11 | 			cost+=abs(sum);
12 | 			scanf("%lld",&x);
13 | 			sum+=x;
14 | 		}
15 | 		printf("%lld\n",cost);
16 | 	}
17 | 	return 0;
18 | }


--------------------------------------------------------------------------------
/SPOJ WILLITST ( Check if Number is a power of 2 ).cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int LL;
 4 | 
 5 | bool ispow2(LL x)
 6 | {
 7 | 	return ( x && (!(x&(x-1))) );
 8 | }
 9 | 
10 | int main() {
11 | 	LL x;
12 | 	scanf("%lld",&x);
13 | 	if(ispow2(x))
14 | 	printf("TAK\n");
15 | 	else
16 | 	printf("NIE\n");
17 | 	return 0;
18 | }


--------------------------------------------------------------------------------
/SPOJ MOHIB.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int t;
 6 | 	scanf("%d",&t);
 7 | 	while(t--)
 8 | 	{
 9 | 		int x,avg;
10 | 		scanf("%d%d",&x,&avg);
11 | 		long long int sum=avg*avg+avg-x*avg-x;
12 | 		long long int n=sum/(avg+1);
13 | 		long long int ans=sum-((n*(n-1))/2);
14 | 		printf("%lld\n",ans);
15 | 	}
16 | 	return 0;
17 | }


--------------------------------------------------------------------------------
/SPOJ MANGOES.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | using namespace std;
 4 | typedef long long int LL;
 5 | int main() {
 6 | 	LL t,n;
 7 | 	scanf("%lld",&t);
 8 | 	while(t--)
 9 | 	{
10 | 		scanf("%lld",&n);
11 | 		LL temp;
12 | 		if(n&1)
13 | 		temp=n/2;
14 | 		else
15 | 		temp=(n-1)/2;
16 | 		LL sum= temp*temp;
17 | 		sum=sum%n;
18 | 		printf("%lld\n",sum);
19 | 	}
20 | 	return 0;
21 | }


--------------------------------------------------------------------------------
/SPOJ ACPC10A.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int x,y,z;
 6 | 	while(true)
 7 | 	{
 8 | 		scanf("%d%d%d",&x,&y,&z);
 9 | 		if(x==0&&y==0&&z==0)break;
10 | 		if(abs(y-x)==abs(z-y))
11 | 		{
12 | 			int ans=z+(z-y);
13 | 			printf("AP %d\n",ans);
14 | 		}
15 | 		else
16 | 		{
17 | 			int ans=z*(z/y);
18 | 			printf("GP %d\n",ans);
19 | 		}
20 | 	}
21 | 	return 0;
22 | }


--------------------------------------------------------------------------------
/SPOJ NICEBTRE.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int i;
 4 | string s;
 5 | int depth()
 6 | {
 7 | 	if(s[i++]=='l')return 1;
 8 | 	else return (1+max(depth(),depth()));
 9 | }
10 | 
11 | int main() {
12 | 	ios_base::sync_with_stdio(false);
13 | 	cin.tie(NULL);
14 | 	int t;
15 | 	cin>>t;
16 | 	while(t--)
17 | 	{
18 | 		i=0;
19 | 		cin>>s;
20 | 		cout<<(depth()-1)<<endl;
21 | 	}
22 | 	return 0;
23 | }


--------------------------------------------------------------------------------
/SPOJ ATOMS.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int LL;
 4 | int main() {
 5 | 	int t;
 6 | 	scanf("%d",&t);
 7 | 	while(t--)
 8 | 	{
 9 | 		LL a,b,c;
10 | 		scanf("%lld%lld%lld",&a,&b,&c);
11 | 		if( c <= a )
12 |         {
13 |             printf("0\n");
14 |             continue;
15 |         }
16 | 		float x=log(c/a)/log(b);
17 | 		LL ans=(LL)x;
18 | 		printf("%lld\n",ans);
19 | 	}
20 | 	return 0;
21 | }


--------------------------------------------------------------------------------
/SPOJ NSTEPS.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 | 	int t;
 7 | 	scanf("%d",&t);
 8 | 	while(t--)
 9 | 	{
10 | 		int x,y;
11 | 		scanf("%d%d",&x,&y);
12 | 		if(((x-y)==0)||((x-y)==2))
13 | 		{
14 | 			if(x&1)
15 | 			{
16 | 				printf("%d\n",x+y-1);
17 | 			}
18 | 			else
19 | 			{
20 | 				printf("%d\n",x+y);
21 | 			}
22 | 		}
23 | 		else printf("No Number\n");
24 | 	}
25 | 	return 0;
26 | }


--------------------------------------------------------------------------------
/SPOJ OHANISER.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | #define MOD 1000000007
 4 | long long int ans[100000];
 5 | int main() {
 6 | 	ans[0]=1;
 7 | 	long long int add=1,n;
 8 | 	for(int i=1;i<100000;i++)
 9 | 	{
10 | 		ans[i]=((ans[i-1]<<1)+add)%MOD;
11 | 		add=(add<<1)%MOD;
12 | 	}
13 | 	int t;
14 | 	scanf("%d",&t);
15 | 	for(int i=1;i<=t;i++)
16 | 	{
17 | 		scanf("%lld",&n);
18 | 		printf("Case %d: %lld\n",i,ans[n-1]);
19 | 	}
20 | 	return 0;
21 | }


--------------------------------------------------------------------------------
/SPOJ ACMT.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int t;
 6 | 	scanf("%d",&t);
 7 | 	while(t--)
 8 | 	{
 9 | 		int x,y,min1,max1,temp,count=0;
10 | 		scanf("%d%d",&x,&y);
11 | 		min1=min(x,y);
12 | 		max1=max(x,y);
13 | 		while(min1>0&&max1>1)
14 | 		{
15 | 			min1--;
16 | 			max1-=2;
17 | 			count++;
18 | 			temp=min1;
19 | 			min1=min(min1,max1);
20 | 			max1=max(temp,max1);
21 | 		}
22 | 		printf("%d\n",count);
23 | 	}
24 | 	return 0;
25 | }


--------------------------------------------------------------------------------
/SPOJ AP2.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | using namespace std;
 4 | typedef long long int LL;
 5 | 
 6 | int main() {
 7 | 	int t;
 8 | 	scanf("%d",&t);
 9 | 	while(t--)
10 | 	{
11 | 		LL x,y,z;
12 | 		scanf("%lld%lld%lld",&x,&y,&z);
13 | 		LL n=(2*z)/(x+y);
14 | 		LL d=(y-x)/(n-5);
15 | 		LL a=x-2*d;
16 | 		printf("%lld\n",n);
17 | 		LL sum=a;
18 | 		for(LL i=0;i<n;i++)
19 | 		{
20 | 			LL ans=sum+i*d;
21 | 			printf("%lld ",ans);
22 | 		}
23 | 		printf("\n");
24 | 	}
25 | 	return 0;
26 | }


--------------------------------------------------------------------------------
/SPOJ FAVDICE (Read the Comments).cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  ( Geometrically distributed Random Variable and E(X)=1/Probability for Geometrical Distribution )
 3 | */
 4 | #include <bits/stdc++.h>
 5 | using namespace std;
 6 | 
 7 | int main() {
 8 | 	int t;
 9 | 	scanf("%d",&t);
10 | 	while(t--)
11 | 	{
12 | 		int n;
13 | 		double sum=0;
14 | 		scanf("%d",&n);
15 | 		int temp=n-1;
16 | 		for(int i=2;i<=n;i++)
17 | 		{
18 | 			sum+=n/(double)temp;
19 | 			temp--;
20 | 		}
21 | 		sum+=1;
22 | 		printf("%.2lf\n",sum);
23 | 	}
24 | 	return 0;
25 | }


--------------------------------------------------------------------------------
/SPOJ CANDY.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int n;
 6 | 	scanf("%d",&n);
 7 | 	while(n!=-1)
 8 | 	{
 9 | 		int a[n],sum=0;
10 | 		for(int i=0;i<n;i++)
11 | 		{
12 | 			scanf("%d",&a[i]);
13 | 			sum+=a[i];
14 | 		}
15 | 		int temp=sum/n;
16 | 		if(temp*n==sum)
17 | 		{
18 | 			sum=0;
19 | 			for(int i=0;i<n;i++)
20 | 			{
21 | 				if(a[i]<temp)sum+=(temp-a[i]);
22 | 			}
23 | 			printf("%d\n",sum);
24 | 		}
25 | 		else printf("-1\n");
26 | 		scanf("%d",&n);
27 | 	}
28 | 	return 0;
29 | }


--------------------------------------------------------------------------------
/SPOJ MIRRORED ( As soon as Input String is two spaces break ( Check the code for implementation ) ).cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | #include <algorithm>
 4 | using namespace std;
 5 | 
 6 | int main() {
 7 | 	string s;
 8 | 	printf("Ready\n");
 9 | 	while(getline(cin,s))
10 | 	{
11 | 		if((s[0]==' ')&&(s[1]==' '))break;
12 | 		if((s[0]=='p'&&s[1]=='q')||(s[0]=='q'&&s[1]=='p')||(s[0]=='d'&&s[1]=='b')||(s[0]=='b'&&s[1]=='d'))
13 | 		printf("Mirrored pair\n");
14 | 		else printf("Ordinary pair\n");
15 | 	}
16 | 	return 0;
17 | }


--------------------------------------------------------------------------------
/SPOJ HC.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include<cstdio>
 3 | #include<string.h>
 4 | using namespace std;
 5 | 
 6 | int main() {
 7 | 	int t;
 8 | 	scanf("%d",&t);
 9 | 	while(t--)
10 | 	{
11 | 		int count=0;
12 | 		char s1[4];
13 | 		int n;
14 | 		scanf("%d",&n);
15 | 		char ch=getchar();
16 | 		for(int i=0;i<n;i++)
17 | 		{
18 | 			scanf("%s",s1);
19 | 			if(strcmp(s1,"lxh")==0)
20 | 			count++;
21 | 		}
22 | 		if(count&1)
23 | 		{
24 | 			printf("lxh\n");
25 | 		}
26 | 		else
27 | 		{
28 | 			printf("hhb\n");
29 | 		}
30 | 	}
31 | 	return 0;
32 | }


--------------------------------------------------------------------------------
/SPOJ UJ ( Using JAVA BigInteger ).java:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | import java.math.*;
 3 | class Code
 4 | {
 5 | 	public static void main (String[] args)
 6 | 	{
 7 | 		Scanner sc=new Scanner(System.in);
 8 |         BigInteger n=sc.nextBigInteger();
 9 |         int d=sc.nextInt();
10 |         while(true)
11 |         {
12 |         	if(d==0&&n.compareTo(BigInteger.ZERO)==0)break;
13 |         	BigInteger b=n.pow(d);
14 |         	System.out.println(b);
15 |             n=sc.nextBigInteger();
16 |             d=sc.nextInt();
17 |         }
18 | 	}
19 | }


--------------------------------------------------------------------------------
/SPOJ ADDREV.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int reverse(int x)
 5 | {
 6 | 	int rever=0;
 7 | 	while(x)
 8 | 	{
 9 | 		int temp=x%10;
10 | 		rever=rever*10+temp;
11 | 		x/=10;
12 | 	}
13 | 	return rever;
14 | }
15 | int adder(int x,int y)
16 | {
17 | 	int a=reverse(x);
18 | 	int b=reverse(y);
19 | 	return(a+b);
20 | }
21 | 
22 | int main() {
23 | 	int n,x,y;
24 | 	scanf("%d",&n);
25 | 	while(n--)
26 | 	{
27 | 		scanf("%d%d",&x,&y);
28 | 		int add=adder(x,y);
29 | 		add=reverse(add);
30 | 		cout<<add<<endl;
31 | 	}
32 | 	return 0;
33 | }


--------------------------------------------------------------------------------
/SPOJ BEENUMS.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	long long int x;
 6 | 	scanf("%lld",&x);
 7 | 	while(x!=-1)
 8 | 	{
 9 | 		if(x&1)
10 | 		{
11 | 			x--;
12 | 			if(x%3==0)
13 | 			{
14 | 				x/=3;
15 | 				x=4*x+1;
16 | 				long long int s=(long long int)sqrt(x);
17 | 				if(s*s==x)
18 | 				{
19 | 					if(s&1) printf("Y\n");
20 | 					else printf("N\n");
21 | 				}
22 | 				else
23 | 				printf("N\n");
24 | 			}
25 | 			else printf("N\n");
26 | 		}
27 | 		else printf("N\n");
28 | 		scanf("%lld",&x);
29 | 	}
30 | 	return 0;
31 | }


--------------------------------------------------------------------------------
/SPOJ BYTELANDIAN COINS.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | unsigned long a[100001];
 3 | unsigned long func(unsigned long n)
 4 | {
 5 | 	if(n<12)return n;
 6 | 	else if(n>12 && n<=100000 && a[n]!=0)
 7 | 	{
 8 | 		return a[n];
 9 | 	}
10 | 	else 
11 | 	{
12 | 	 return(func(n/2)+func(n/3)+func(n/4));	
13 | 	}
14 | }
15 | 
16 | int main(void) {
17 | 	long int i;
18 | 	for(i=0;i<100001;i++)
19 | 	{
20 | 		a[i]=0;
21 | 		a[i]=func(i);
22 | 	}
23 | 	unsigned long ans,n;
24 | 	while(scanf("%lu",&n)!=EOF)
25 | 	{
26 | 		ans=func(n);
27 | 		printf("%lu\n",ans);
28 | 	}
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/SPOJ MARBLES (Calculating Factorial the Maths Way).cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include<cstdio>
 3 | using namespace std;
 4 | 
 5 | long long int C(int x,int y)
 6 | {
 7 | 	if(x==y)return 1;
 8 | 	if(y==0) return 1;
 9 | 	if(y==1) return (long long int)x;
10 | 	long long int ans=1;
11 | 	if(y>x-y)y=x-y;
12 | 	for(int i=0;i<y;i++)
13 | 	{
14 | 		ans=ans*(x-i)/(i+1);
15 | 	}
16 | 	return ans;
17 | }
18 | 
19 | int main() {
20 | 	int t,n,k;
21 | 	scanf("%d",&t);
22 | 	while(t--)
23 | 	{
24 | 		scanf("%lld%lld",&n,&k);
25 | 		printf("%lld\n",C(n-1,k-1));
26 | 	}
27 | 	return 0;
28 | }


--------------------------------------------------------------------------------
/SPOJ FARIDA (DP).cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | long long int dp[10001];
 4 | long long int a[10001];
 5 | int main() {
 6 | 	int t;
 7 | 	scanf("%d",&t);
 8 | 	for(int i=1;i<=t;i++)
 9 | 	{
10 | 		int n;
11 | 		scanf("%d",&n);
12 | 		if(n==0)
13 | 		{	
14 | 			printf("Case %d: 0\n",i);
15 | 			continue;
16 | 		}
17 | 		for(int j=0;j<n;j++)
18 | 		{
19 | 			scanf("%lld",&a[j]);
20 | 		}
21 | 		dp[0]=a[0];
22 | 		dp[1]=max(a[1],dp[0]);
23 | 		for(int j=2;j<n;j++)
24 | 		{
25 | 			dp[j]=max(a[j]+dp[j-2],dp[j-1]);
26 | 		}
27 | 		printf("Case %d: %lld\n",i,dp[n-1]);
28 | 	}
29 | 	return 0;
30 | }


--------------------------------------------------------------------------------
/SPOJ PEBBLE.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | char s[1000001];
 4 | int main() {
 5 | 	int counter=1;
 6 | 	while(scanf("%s",s)!=EOF)
 7 | 	{
 8 | 		long int count=0;
 9 | 		for(int i=0;s[i];i++)
10 | 		{
11 | 			if(count&1)
12 | 			{
13 | 				if(s[i]=='0')
14 | 				{
15 | 					count++;
16 | 				}
17 | 				else
18 | 				{
19 | 					continue;
20 | 				}
21 | 			}
22 | 			else
23 | 			{
24 | 				if(s[i]=='0')
25 | 				{
26 | 					continue;
27 | 				}
28 | 				else
29 | 				{
30 | 					count++;
31 | 				}
32 | 			}
33 | 		}
34 | 		printf("Game #%d: %ld\n",counter,count);
35 | 		counter++;
36 | 	}
37 | 	return 0;
38 | }


--------------------------------------------------------------------------------
/SPOJ CODERE2.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int t;
 6 | 	long long int i,n,ans1,max1,val;
 7 | 	scanf("%d",&t);
 8 | 	while(t--)
 9 |     {
10 |     	scanf("%lld",&n);
11 |     	map<long long int,long long int>v;
12 |     	v.clear();
13 |     	for(i=0;i<n;i++)
14 |     	{
15 |     		scanf("%lld",&val);
16 |     		v[val]++;
17 |     	}
18 |     	max1=ans1=0;
19 |     	for(typeof(v.begin()) it=v.begin();it!=v.end();it++)
20 |     	{
21 |     		if(max1<(it->second))
22 |     		{
23 |     			max1=it->second;
24 |     			ans1=it->first;
25 |     		}
26 |     	}
27 |     	printf("%lld\n",ans1);
28 |     }
29 | 	return 0;
30 | }


--------------------------------------------------------------------------------
/SPOJ ABSYS.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int t;
 6 | 	scanf("%d",&t);
 7 | 	char ch=getchar();
 8 | 	while(t--)
 9 | 	{
10 | 		int x,y,z;
11 | 		char a[200],b[2],c[200],d[2],e[200];
12 | 		scanf("%s%s%s%s%s",a,b,c,d,e);
13 | 		char ch1=getchar();
14 | 		if(strchr(a,'m')!=NULL)
15 | 		{
16 | 			 y=atoi(c);
17 | 			 z=atoi(e);
18 | 			 x=z-y;
19 | 		}
20 | 		else if(strchr(c,'m')!=NULL)
21 | 		{
22 | 			 x=atoi(a);
23 | 			 z=atoi(e);
24 | 			 y=z-x;
25 | 		}
26 | 		else if(strchr(e,'m')!=NULL)
27 | 		{
28 | 			 x=atoi(a);
29 | 			 y=atoi(c);
30 | 			 z=x+y;
31 | 		}
32 | 		printf("%d + %d = %d\n",x,y,z);
33 | 	}
34 | 	return 0;
35 | }


--------------------------------------------------------------------------------
/SPOJ DIEHARD.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | using namespace std;
 4 | typedef long long int LL;
 5 | int main() {
 6 | 	int t;
 7 | 	scanf("%d",&t);
 8 | 	while(t--)
 9 | 	{
10 | 		LL x,y;
11 | 		scanf("%lld%lld",&x,&y);
12 | 		if(x==0||y==0)
13 | 		{	
14 | 			printf("0\n");
15 | 			continue;
16 | 		}
17 | 		LL count=1;
18 | 		x+=3;
19 | 		y+=2;
20 | 		while(true)
21 | 		{
22 | 			if(x>5&&y>10)
23 | 			{
24 | 				x-=2;
25 | 				y-=8;
26 | 				count+=2;
27 | 			}
28 | 			else if(x>20&&y<=10)
29 | 			{
30 | 				x-=17;
31 | 				y+=7;
32 | 				count+=2;
33 | 			}
34 | 			else
35 | 			{
36 | 				printf("%lld\n",count);
37 | 				break;
38 | 			}
39 | 		}
40 | 	}
41 | 	return 0;
42 | }


--------------------------------------------------------------------------------
/SPOJ BWIDOW.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int t;
 6 | 	scanf("%d",&t);
 7 | 	while(t--)
 8 | 	{
 9 | 		int n,flag=0,index;
10 | 		long int max=0;
11 | 		scanf("%d",&n);
12 | 		pair < long int , long int > p[n];
13 | 		for(int i=0;i<n;i++)
14 | 		{
15 | 			scanf("%ld%ld",&p[i].first,&p[i].second);
16 | 			if(p[i].first>max)
17 | 			{
18 | 				index=i;
19 | 				max=p[i].first;
20 | 			}
21 | 		}
22 | 		for(int i=0;i<n;i++)
23 | 		{
24 | 			if(index!=i)
25 | 			{
26 | 				if(p[i].second>=max)
27 | 				{
28 | 					flag=1;
29 | 					break;
30 | 				}
31 | 			}
32 | 		}
33 | 		if(flag==0)printf("%d\n",index+1);
34 | 		else printf("-1\n");
35 | 	}
36 | 	return 0;
37 | }


--------------------------------------------------------------------------------
/SPOJ KNAPSACK.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int n,i,x,y,size,j;
 6 | 	pair<int,int>pf[2001];
 7 | 	scanf("%d%d",&size,&n);
 8 | 	for(i=0;i<n;i++)
 9 | 	{
10 | 		scanf("%d%d",&x,&y);
11 | 		pf[i]=make_pair(x,y);
12 | 	}
13 | 	int dp[n+1][size+1];
14 | 	for(i=0;i<=n;i++)
15 | 	for(j=0;j<=size;j++)
16 | 	{
17 | 		dp[i][j]=0;
18 | 	}
19 | 	for(i=1;i<=n;i++)
20 | 	{
21 | 		for(j=1;j<=size;j++)
22 | 		{
23 | 			if(pf[i-1].first<=j)
24 | 			{
25 | 				dp[i][j]=max(pf[i-1].second+dp[i-1][j-pf[i-1].first],dp[i-1][j]);
26 | 			}
27 | 			else 
28 | 			{
29 | 				dp[i][j]=dp[i-1][j];
30 | 			}
31 | 		}
32 | 	}
33 | 	int max1=dp[n][size];
34 | 	printf("%d",max1);
35 | 	return 0;
36 | }


--------------------------------------------------------------------------------
/SPOJ MMAXPER.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | int max(int a,int b)
 3 | {
 4 | 	return(a>=b?a:b);
 5 | }
 6 | int abs1(int x)
 7 | {
 8 | 	if(x<0)return ((-1)*x);
 9 | 	else return x;
10 | }
11 | int a[1000][2],dp[1000][2];
12 | int main(void) {
13 | 	int n,i;
14 | 	scanf("%d",&n);
15 | 	for(i=0;i<n;i++)
16 | 	{
17 | 		scanf("%d%d",&a[i][0],&a[i][1]);
18 | 		if(i==0)
19 | 		{
20 | 			dp[i][0]=a[i][0];
21 | 			dp[i][1]=a[i][1];
22 | 		}
23 | 		else
24 | 		{
25 | 			dp[i][0]=max(dp[i-1][0]+abs1(a[i][1]-a[i-1][1])+a[i][0],dp[i-1][1]+abs1(a[i][1]-a[i-1][0])+a[i][0]);
26 | 			dp[i][1]=max(dp[i-1][0]+abs1(a[i-1][1]-a[i][0])+a[i][1],dp[i-1][1]+abs1(a[i][0]-a[i-1][0])+a[i][1]);
27 | 		}
28 | 		
29 | 	}
30 | 	printf("%d\n",max(dp[n-1][0],dp[n-1][1]));
31 | 	return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/SPOJ HPYNOS.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstdio>
 3 | #include<map>
 4 | using namespace std;
 5 | unsigned long long int count=0;
 6 | bool check(unsigned long long int x)
 7 | {
 8 | 	if(x==1)return true;
 9 | 	map<unsigned long long int,int> m;
10 | 	unsigned long long int temp=x;
11 | 	unsigned long long int sum=0;
12 | 	while(sum!=1)
13 | 	{
14 | 		sum=0;
15 | 		while(temp)
16 | 		{
17 | 			sum=sum+((temp%10)*(temp%10));
18 | 			temp/=10;
19 | 		}
20 | 		temp=sum;
21 | 		if(m[sum]==1)
22 | 		{
23 | 			return false;
24 | 		}
25 | 		m[sum]=1;
26 | 		count++;
27 | 	}
28 | 	return true;
29 | }
30 | int main() {
31 | 	long long int n;
32 | 	scanf("%lld",&n);
33 | 	if(check(n))
34 | 	printf("%lld\n",count);
35 | 	else
36 | 	printf("-1\n");
37 | 	return 0;
38 | }


--------------------------------------------------------------------------------
/SPOJ NOVICE63 (DP).cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | long long int nCr[66][33];
 4 | 
 5 | long long int C( long long int x, long long int y)
 6 | {
 7 | 	if(x==y)return 1;
 8 | 	if(y==0) return 1;
 9 | 	if(y==1) return (long long int)x;
10 | 	if(nCr[x][y]) return nCr[x][y];
11 | 	return nCr[x][y]=C(x-1,y)+C(x-1,y-1);
12 | }
13 | int main() {
14 | 	long long int dp[70];
15 | 	dp[0]=0;
16 | 	dp[1]=1;
17 | 	dp[2]=1;
18 | 	for(long long int i=3;i<=69;i++)
19 | 	{
20 | 		if(i&1)
21 | 		{
22 | 			dp[i]=dp[i-1];
23 | 		}
24 | 		else
25 | 		{
26 | 			dp[i]=dp[i-1]+C(i-1,i/2);
27 | 		}
28 | 	}
29 | 	long long int n;
30 | 	int t;
31 | 	scanf("%d",&t);
32 | 	while(t--)
33 | 	{
34 | 		scanf("%lld",&n);
35 | 		printf("%lld\n",dp[(int)(log2(n))]);
36 | 	}
37 | 	return 0;
38 | }


--------------------------------------------------------------------------------
/SPOJ WPC5D.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int LL;
 4 | const LL M=1000000007;
 5 | 
 6 | LL power(LL a, LL b) {
 7 | 	LL x = 1, y = a;
 8 |     while(b > 0) {
 9 |         if(b%2 == 1) {
10 |             x=(x*y);
11 |             if(x>M) x%=M;
12 |         }
13 |         y = (y*y);
14 |         if(y>M) y%=M;
15 |         b /= 2;
16 |     }
17 |     return x;
18 | }
19 | 
20 | 
21 | int main() {
22 | 	int t;
23 | 	scanf("%d",&t);
24 | 	while(t--)
25 | 	{
26 | 		LL temp=1,temp1=1,n,k;
27 | 		scanf("%lld%lld",&n,&k);
28 | 		temp=power(k,n-1);
29 | 		temp1=power(k-2,n-1);
30 | 		LL a=(temp+temp1)%M;
31 | 		LL d=(k-1)%M;
32 | 		a=(a*d)%M;
33 | 		LL b=power(2,M-2);
34 | 		LL ans=a*b;
35 | 		ans%=M;
36 | 		printf("%lld\n",ans);
37 | 	}
38 | 	return 0;
39 | }


--------------------------------------------------------------------------------
/SPOJ PQUEUE ( Priority Queue and STL ).cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int t,x,time;
 6 | 	scanf("%d",&t);
 7 | 	while(t--)
 8 | 	{
 9 | 		time=0;
10 | 		queue< pair<int,int> > q;
11 | 		priority_queue <int> pq; 
12 | 		int n,m;
13 | 		scanf("%d%d",&n,&m);
14 | 		for(int i=0;i<n;i++)
15 | 		{
16 | 			scanf("%d",&x);
17 | 			q.push(make_pair(x,i));
18 | 			pq.push(x);
19 | 		}
20 | 		while(!q.empty())
21 | 		{
22 | 			int first=q.front().first;
23 | 			int second=q.front().second;
24 | 			q.pop();
25 | 			if(first!=pq.top())
26 | 			{
27 | 				q.push(make_pair(first,second));
28 | 			}
29 | 			else
30 | 			{
31 | 				time++;
32 | 				pq.pop();
33 | 				if(second==m)break;
34 | 			}
35 | 		}
36 | 		printf("%d\n",time);
37 | 	}
38 | 	return 0;
39 | }


--------------------------------------------------------------------------------
/SPOJ IOIPALIN.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | #include<string.h>
 4 |  
 5 | int max(int a, int b)
 6 | {
 7 |     return (a > b)? a : b;
 8 | }
 9 |   
10 | int main()
11 | {
12 |   char X[5005],Y[5005];
13 |   int n;
14 |   char ch;
15 |   int dp[5001][5001];
16 |   scanf("%d",&n);
17 |   scanf("%s",X);
18 |   int i, j;
19 |   for(i=0;i<n;i++)
20 | 	Y[i]=X[n-i-1];
21 | 
22 |    for (i=0; i<=n; i++)
23 |    {
24 |      for (j=0; j<=n; j++)
25 |      {
26 |      	if(i==0||j==0)dp[j][1]=0;
27 |   
28 |        else if (X[i-1] == Y[j-1])
29 |          dp[j][1] = dp[j-1][0] + 1;
30 |   
31 |        else
32 |          dp[j][1] = max(dp[j][0], dp[j-1][1]);
33 |      }
34 |      for(j=0;j<=n;j++)
35 |      {
36 |      	dp[j][0]=dp[j][1];
37 |      }
38 |    }
39 |    printf("%d\n",n-dp[n][0]);
40 |   return 0;
41 | }


--------------------------------------------------------------------------------
/SPOJ IOIPALIN.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | #include<string.h>
 4 |  
 5 | int max(int a, int b)
 6 | {
 7 |     return (a > b)? a : b;
 8 | }
 9 |   
10 | int main()
11 | {
12 |   char X[5005],Y[5005];
13 |   int n;
14 |   char ch;
15 |   int dp[5001][2];
16 |   scanf("%d",&n);
17 |   ch=getchar();
18 |   scanf("%s",X);
19 |   int i, j;
20 |   for(i=0;i<n;i++)
21 | 	Y[i]=X[n-i-1];
22 | 
23 |    for (i=0; i<=n; i++)
24 |    {
25 |      for (j=0; j<=n; j++)
26 |      {
27 |      	if(i==0||j==0)dp[j][1]=0;
28 |   
29 |        else if (X[i-1] == Y[j-1])
30 |          dp[j][1] = dp[j-1][0] + 1;
31 |   
32 |        else
33 |          dp[j][1] = max(dp[j][0], dp[j-1][1]);
34 |      }
35 |      for(j=0;j<=n;j++)
36 |      {
37 |      	dp[j][0]=dp[j][1];
38 |      }
39 |    }
40 |    printf("%d\n",n-dp[n][0]);
41 |   return 0;
42 | }


--------------------------------------------------------------------------------
/SPOJ WACHOVIA (KNAPSACK).cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | pair<int,int>pf[51];
 4 | int main() {
 5 | 	int n,i,x,y,size,j,t;
 6 | 	scanf("%d",&t);
 7 | 	while(t--)
 8 | 	{
 9 | 		scanf("%d%d",&size,&n);
10 | 		for(i=0;i<n;i++)
11 | 		{
12 | 			scanf("%d%d",&x,&y);
13 | 			pf[i]=make_pair(x,y);
14 | 		}
15 | 		int dp[n+1][size+1];
16 | 		for(i=0;i<=n;i++)
17 | 		for(j=0;j<=size;j++)
18 | 		{
19 | 			dp[i][j]=0;
20 | 		}
21 | 		for(i=1;i<=n;i++)
22 | 		{
23 | 			for(j=1;j<=size;j++)
24 | 			{
25 | 				if(pf[i-1].first<=j)
26 | 				{
27 | 					dp[i][j]=max(pf[i-1].second+dp[i-1][j-pf[i-1].first],dp[i-1][j]);
28 | 				}
29 | 				else 
30 | 				{
31 | 					dp[i][j]=dp[i-1][j];
32 | 				}
33 | 			}
34 | 		}
35 | 		int max1=dp[n][size];
36 | 		printf("Hey stupid robber, you can get %d.\n",max1);
37 | 	}
38 | 	return 0;
39 | }


--------------------------------------------------------------------------------
/SPOJ TOANDFRO.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	ios_base::sync_with_stdio(false);
 6 | 	cin.tie(NULL);
 7 | 	int n;
 8 | 	cin>>n;
 9 | 	while(n)
10 | 	{
11 | 		char org[300];
12 | 		cin>>org;
13 | 		char s[(int)((strlen(org)/n))][n];
14 | 		int j=0,flag=0;
15 | 		for(int i=0;i<strlen(org);j++)
16 | 		{
17 | 			int k=i,count=0;
18 | 			while(count<n)
19 | 			{
20 | 				if(flag==0)
21 | 				{
22 | 					s[j][count]=org[i];
23 | 					i++;
24 | 					count++;
25 | 				}
26 | 				else
27 | 				{
28 | 					s[j][count]=org[k+n-count-1];
29 | 					i++;
30 | 					count++;
31 | 				}
32 | 			}
33 | 			flag^=1;
34 | 		}
35 | 		for(int i=0;i<n;i++)
36 | 		{
37 | 			for(int j=0;j<(int)((strlen(org)/n));j++)
38 | 			{
39 | 				cout<<s[j][i];
40 | 			}
41 | 		}
42 | 		cout<<endl;
43 | 		cin>>n;
44 | 	}
45 | 	return 0;
46 | }


--------------------------------------------------------------------------------
/SPOJ AGGRCOW.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | long long int a[100001];
 4 | int n,c;
 5 | int place(int x)
 6 | {
 7 | 	int cowsplaced=1;
 8 | 	long long int pos=a[0];
 9 | 	for(int i=1;i<n;i++)
10 | 	{
11 | 		if(a[i]-pos>=x){cowsplaced++;pos=a[i];}
12 | 		if(cowsplaced==c)return 1;
13 | 	}
14 | 	return 0;
15 | }
16 | int bsearch()
17 | {
18 | 	long long int start=0,mid;
19 | 	long long int end=a[n-1];
20 | 	while(start<end)
21 | 	{
22 | 		mid=(start+end)/2;
23 | 		if(place(mid)==0)end=mid;
24 | 		else start=mid+1;
25 | 	}
26 | 	return start-1;
27 | }
28 | int main() {
29 | 	ios_base::sync_with_stdio(false);
30 | 	cin.tie(NULL);
31 | 	int t,i;
32 | 	cin>>t;
33 | 	while(t--)
34 | 	{
35 | 		cin>>n>>c;
36 | 		for(i=0;i<n;i++)
37 | 		{
38 | 			cin>>a[i];
39 | 		}
40 | 		sort(a,a+n);
41 | 		cout<<bsearch()<<endl;
42 | 	}
43 | 	return 0;
44 | }


--------------------------------------------------------------------------------
/SPOJ HOMO.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | #include <algorithm>
 4 | #include <string.h>
 5 | #include <map>
 6 | using namespace std;
 7 | 
 8 | int main() {
 9 | 	int t,homo=0,hetero=0;
10 | 	char s[7];
11 | 	long long int x;
12 | 	map<long long int,int> m;
13 | 	scanf("%d",&t);
14 | 	while(t--)
15 | 	{
16 | 		scanf("%s%lld",s,&x);
17 | 		if(strcmp(s,"insert")==0)
18 | 		{
19 | 			m[x]++;
20 | 			if(m[x]==2)
21 | 			homo++;
22 | 			else if(m[x]==1)
23 | 			hetero++;
24 | 		}
25 | 		else
26 | 		{
27 | 			if(m[x]>0)
28 | 			{
29 | 				m[x]--;
30 | 				if(m[x]==1)
31 | 				homo--;
32 | 				else if(m[x]==0)
33 | 				hetero--;
34 | 			}
35 | 		}
36 | 		if(homo>=1&&hetero>=2)
37 | 		printf("both\n");
38 | 		else if(homo>=1)
39 | 		printf("homo\n");
40 | 		else if(hetero>=2)
41 | 		printf("hetero\n");
42 | 		else printf("neither\n");
43 | 	}
44 | 	return 0;
45 | }


--------------------------------------------------------------------------------
/SPOJ OFORTUNE.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int t;
 6 | 	scanf("%d",&t);
 7 | 	while(t--)
 8 | 	{
 9 | 		int initial,y,m,sum=0;
10 | 		scanf("%d%d%d",&initial,&y,&m);
11 | 		for(int i=0;i<m;i++)
12 | 		{
13 | 			int mode,charge;
14 | 			double rate;
15 | 			scanf("%d%lf%d",&mode,&rate,&charge);
16 | 			if(mode==0)
17 | 			{
18 | 				int interest=0;
19 | 				int amount=initial;
20 | 				for(int j=0;j<y;j++)
21 | 				{
22 | 					interest+=amount*rate;
23 | 					amount-=charge;
24 | 				}
25 | 				amount+=interest;
26 | 				sum=sum>amount?sum:amount;
27 | 			}
28 | 			else
29 | 			{
30 | 				int amount=initial;
31 | 				for(int j=0;j<y;j++)
32 | 				{
33 | 					int interest=amount*rate;
34 | 					amount=amount+interest-charge;
35 | 				}
36 | 				sum=sum>amount?sum:amount;
37 | 			}
38 | 		}
39 | 		printf("%d\n",sum);
40 | 	}
41 | 	return 0;
42 | }


--------------------------------------------------------------------------------
/SPOJ AIBOHP.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | #include<string.h>
 4 | char X[5005],Y[5005];
 5 | int dp[5001][2]; 
 6 | 
 7 | int max(int a, int b)
 8 | {
 9 |     return (a > b)? a : b;
10 | }
11 |  
12 | int main()
13 | {
14 |   int t;
15 |   char ch;
16 |   scanf("%d",&t);
17 |   ch=getchar();
18 |   while(t--)
19 |   {
20 | 	  scanf("%s",X);
21 | 	  int i,j,n=strlen(X);
22 | 	  for(i=0;i<n;i++)
23 | 		Y[i]=X[n-i-1];
24 | 	
25 | 	   for (i=0; i<=n; i++)
26 | 	   {
27 | 	     for (j=0; j<=n; j++)
28 | 	     {
29 | 	     	if(i==0||j==0)dp[j][1]=0;
30 | 	  
31 | 	       else if (X[i-1] == Y[j-1])
32 | 	         dp[j][1] = dp[j-1][0] + 1;
33 | 	  
34 | 	       else
35 | 	         dp[j][1] = max(dp[j][0], dp[j-1][1]);
36 | 	     }
37 | 	     for(j=0;j<=n;j++)
38 | 	     {
39 | 	     	dp[j][0]=dp[j][1];
40 | 	     }
41 | 	   }
42 | 	   printf("%d\n",n-dp[n][0]);
43 |   }
44 |   return 0;
45 | }


--------------------------------------------------------------------------------
/SPOJ HDEVIL.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int LL;
 4 | 
 5 | bool isperfect(LL x)
 6 | {
 7 | 	LL y=sqrt(x);
 8 | 	return ( y*y==x );
 9 | }
10 | 
11 | bool isfibo(LL x)
12 | {
13 | 	return isperfect(5*x*x+4)||isperfect(5*x*x-4);
14 | }
15 | int main() {
16 | 	int t,counter=1;
17 | 	scanf("%d",&t);
18 | 	while(t--)
19 | 	{
20 | 		LL n,m,sum1=1,sum=1;
21 | 		scanf("%lld%lld",&n,&m);
22 | 		for(LL i=2;i*i<=n;i++)
23 | 		{
24 | 			if(n%i==0)
25 | 			{
26 | 				if((n/i)==i)
27 | 				sum+=i;
28 | 				else sum+=i+(n/i);
29 | 			}
30 | 		}
31 | 		sum=sum%m;
32 | 		for(LL i=2;i*i<=sum;i++)
33 | 		{
34 | 			if(sum%i==0)
35 | 			{
36 | 				if((sum/i)==i)
37 | 				sum1++;
38 | 				else sum1+=2;
39 | 			}
40 | 		}
41 | 		if(isfibo(sum1))
42 | 		printf("Case #%d : YES.\n",counter);
43 | 		else
44 | 		printf("Case #%d : NO.\n",counter);
45 | 		counter++;
46 | 	}
47 | 	return 0;
48 | }


--------------------------------------------------------------------------------
/SPOJ BUSYMAN.cpp:
--------------------------------------------------------------------------------
 1 | //#include <bits/stdc++.h>
 2 | #include<iostream>
 3 | #include<vector>
 4 | #include<queue>
 5 | #include<algorithm>
 6 | #include<map>
 7 | #include<stack>
 8 | #include<stdio.h>
 9 | #include<math.h>
10 | #include<string>
11 | #include<stdlib.h>
12 | using namespace std;
13 |  
14 | int main() {
15 | 	int t,n,i,x,y,count,flag;
16 | 	scanf("%d",&t);
17 | 	while(t--)
18 | 	{
19 | 		flag=0;
20 | 	    count=1;
21 | 		scanf("%d",&n);
22 | 		pair < int ,int > v[n];
23 | 		for(i=0;i<n;i++)
24 | 		{
25 | 			scanf("%d%d",&x,&y);
26 | 			v[i]=make_pair(x,y);
27 | 		}
28 | 		sort(v,v+n);
29 | 		x=v[0].first;
30 | 		y=v[0].second;
31 | 		for(i=1;i<n;i++)
32 | 		{
33 | 			if(v[i].first<y) 
34 | 			{
35 | 				//x=v[i].first;
36 | 				if(v[i].second<=y){y=v[i].second;}
37 | 			}
38 | 			else 
39 | 			{
40 | 				count++;
41 | 				x=v[i].first;
42 | 				y=v[i].second;
43 | 			}
44 | 		}
45 | 		printf("%d\n",count);
46 | 	}
47 | 	return 0;
48 | } 


--------------------------------------------------------------------------------
/SPOJ EDIST.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include<string.h>
 3 | int min(int len1,int len2,int len3)
 4 | {
 5 | 	return (len1<len2?(len1<len3?len1:len3):(len2<len3?len2:len3));
 6 | }
 7 | char ch,str1[2001],str2[2001];
 8 | int dp[2001][2001];
 9 | int main(void) {
10 | 	int t;
11 | 	
12 | 	scanf("%d",&t);
13 | 	int i,j,len1,len2,len3;
14 | 	ch=getchar();
15 | 	while(t--){
16 |     scanf("%s",str1);
17 | 	scanf("%s",str2);
18 | 	int m=strlen(str1);
19 | 	int n=strlen(str2);
20 | 	//int dp[m+1][n+1];
21 | 	for(i=0;i<=m;i++)
22 | 	{
23 | 		dp[i][0]=i;
24 | 	}
25 | 	for(i=0;i<=n;i++)
26 | 	{
27 | 		dp[0][i]=i;
28 | 	}
29 | 	for(i=1;i<=m;i++)
30 | 	{
31 | 		for(j=1;j<=n;j++)
32 | 		{
33 | 			len1=(str1[i-1]==str2[j-1]?0:1)+dp[i-1][j-1];
34 | 			len2=dp[i][j-1]+1;
35 | 			len3=dp[i-1][j]+1;
36 | 			//printf("%d\t%d\t%d\t%d\n",len1,len2,len3,min(len1,len2,len3));
37 | 			dp[i][j]=min(len1,len2,len3);
38 | 		}
39 | 	}
40 | 	printf("%d\n",dp[m][n]);
41 | 	}	
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/SPOJ DIVFACT.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const long long int mod=1000000000+7;
 4 | bool primes[50001];
 5 | int prime[50001];
 6 | int counter=0;
 7 | void sieve()
 8 | {
 9 | 	memset(primes,false,sizeof(primes));
10 | 	for(int i=2;i<50001;i++)
11 | 	{
12 | 		if(!primes[i])
13 | 		{
14 | 			prime[counter++]=i;
15 | 			for(int j=i;j<50001;j+=i)
16 | 			primes[j]=true;
17 | 		}
18 | 	}
19 | }
20 | 
21 | int power(int x,int y)
22 | {
23 | 	int count=0;
24 | 	long long int z=y;
25 | 	while(x>=z)
26 | 	{
27 | 		count+=(x/z);
28 | 		z*=(long long int)y;
29 | 	}
30 | 	return count;
31 | }
32 | 
33 | int main() {
34 | 	int t,n;
35 | 	sieve();
36 | 	scanf("%d",&t);
37 | 	while(t--)
38 | 	{
39 | 		scanf("%d",&n);
40 | 		long long int ans=1;
41 | 		for(int i=0;i<counter;i++)
42 | 		{
43 | 			int powers=power(n,prime[i]);
44 | 			if(powers==0)break;
45 | 			ans=(ans*((long long int)(powers+1)))%mod;
46 | 		}
47 | 		ans=ans%mod;
48 | 		printf("%lld\n",ans);
49 | 	}
50 | 	return 0;
51 | }


--------------------------------------------------------------------------------
/SPOJ CODFURY ( Same as SPOJ ALIEN ).cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <algorithm>
 3 | #include <cstdio>
 4 | using namespace std;
 5 | typedef long long int ll;
 6 | int a[50001];
 7 | int main() {
 8 | 	int t;
 9 | 	scanf("%d",&t);
10 | 	while(t--)
11 | 	{
12 | 		int n,p=0,steps=0,minsteps=0;
13 | 		ll b,sum=0,minpeople=1000001;
14 | 		scanf("%d%lld",&n,&b);
15 | 		for(int i=0;i<n;i++)
16 | 		{
17 | 			scanf("%d",&a[i]);
18 | 		}
19 | 		for(int i=0;i<n;i++)
20 | 		{
21 | 			if(sum+a[i]<=b)
22 | 			{
23 | 				sum+=a[i];
24 | 				steps++;
25 | 			}
26 | 			else
27 | 			{
28 | 				sum+=a[i];
29 | 				steps++;
30 | 				while(sum>b)
31 | 				{
32 | 					sum-=a[p];
33 | 					steps--;
34 | 					p++;
35 | 				}
36 | 			}
37 | 			if(minsteps<steps)
38 | 			{
39 | 				minsteps=steps;
40 | 				minpeople=sum;
41 | 			}
42 | 			else if(minsteps==steps)
43 | 			{
44 | 				if(minpeople>sum)
45 | 				{
46 | 					minpeople=sum;
47 | 				}
48 | 			}
49 | 		}
50 | 		printf("%lld %d\n",minpeople,minsteps);
51 | 	}
52 | 	return 0;
53 | }


--------------------------------------------------------------------------------
/SPOJ PARTY SCHEDULE.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 | 	int n,i,x,y,pb,j;
 6 | 	pair<int,int>pf[101];
 7 | 	
 8 | 	while(1)
 9 | 	{
10 | 	scanf("%d%d",&pb,&n);
11 | 	if(pb==0&&n==0)break;
12 | 	
13 | 	for(i=0;i<n;i++)
14 | 	{
15 | 		scanf("%d%d",&x,&y);
16 | 		pf[i]=make_pair(x,y);
17 | 	}
18 | 	int dp[n+1][pb+1];
19 | 	for(i=0;i<=n;i++)
20 | 	for(j=0;j<=pb;j++)
21 | 	{
22 | 		dp[i][j]=0;
23 | 	}
24 | 	for(i=0;i<=n;i++)
25 | 	{
26 | 		dp[i][0]=0;
27 | 	}
28 | 	for(i=0;i<=pb;i++)
29 | 	{
30 | 		dp[0][i]=0;
31 | 	}
32 | 	for(i=1;i<=n;i++)
33 | 	{
34 | 		for(j=1;j<=pb;j++)
35 | 		{
36 | 			if(pf[i-1].first<=j)
37 | 			{
38 | 				dp[i][j]=max(pf[i-1].second+dp[i-1][j-pf[i-1].first],dp[i-1][j]);
39 | 			}
40 | 			else 
41 | 			{
42 | 				dp[i][j]=dp[i-1][j];
43 | 			}
44 | 		}
45 | 	}
46 | 	int maxfun=dp[n][pb];
47 | 	int minmoney=0;
48 | 	for(i=0;i<=pb;i++)
49 | 	{
50 | 		if(dp[n][i]==maxfun)
51 | 		{
52 | 			minmoney=i;
53 | 			break;
54 | 		}
55 | 	}
56 | 	printf("%d %d\n",minmoney,maxfun);
57 | 	}
58 | 	return 0;
59 | }


--------------------------------------------------------------------------------
/SPOJ PT07Y.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #include<cstdio>
 3 | #include<algorithm>
 4 | using namespace std;
 5 | 
 6 | typedef long long int LL;
 7 | 
 8 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 9 | #define REP(p,a,b) for(int p=a;p<=b;p++)
10 | #define mod 1000000007
11 | 
12 | list<int> adj[100010];
13 | set<int> visited;
14 | 
15 | 	void DFS(int v)
16 | 	{
17 | 		visited.insert(v);
18 | 		set<int>::iterator s;
19 | 		iter(it,adj[v])
20 | 		{
21 | 			
22 | 			s=visited.find(*it);
23 | 			if(s==visited.end())
24 | 			{
25 | 				DFS(*it);
26 | 			}
27 | 		}
28 | 	}
29 | 	
30 | 	
31 | int main() {
32 | 	
33 | 		int v,e,i,a,b;
34 | 		scanf("%d%d",&v,&e);
35 | 		int flag=0;
36 | 		REP(i,0,e-1)
37 | 		{
38 | 			scanf("%d%d",&a,&b);
39 | 			adj[a].push_back(b);
40 | 			adj[b].push_back(a);
41 | 		}
42 | 		if(e!=v-1)
43 | 		{
44 | 			printf("NO\n");
45 | 		}
46 | 		else flag=1;
47 | 		DFS(1);
48 | 		if(visited.size()==v&&flag==1)
49 | 		{
50 | 			cout<<"YES"<<endl;
51 | 		}
52 | 		else if(flag==1) 
53 | 		{
54 | 			cout<<"NO"<<endl;
55 | 		}
56 | 	
57 | 	return 0;
58 | }


--------------------------------------------------------------------------------
/SPOJ HOTELS ( Variation of Kardane's Algorithm (Used to find Maximum Sum Subarray ) here modified for a maxsum ).cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int ll;
 4 | int a[300002];
 5 | int main() {
 6 | 		long long int maxsum=0,currentmax=0,m;
 7 | 		int left=0,right=0,maxleft=0,maxright=0,n,j=0;
 8 | 		scanf("%d%lld",&n,&m);
 9 | 		for(int i=0;i<n;i++)
10 | 		{
11 | 			scanf("%d",&a[i]);
12 | 		}
13 | 		for(int i=0;i<n;i++)
14 | 		{
15 | 			if(currentmax+(ll)(a[i])<m)
16 | 			currentmax+=a[i];
17 | 			else if(currentmax+(ll)(a[i])==m)
18 | 			{
19 | 				maxsum=currentmax+(ll)(a[i]);
20 | 				break;
21 | 			}
22 | 			else
23 | 			{
24 | 				ll temp=currentmax;
25 | 				while(temp+a[i]>m)
26 | 				{
27 | 					currentmax-=(ll)a[j];
28 | 					temp=currentmax;
29 | 					if(currentmax+(ll)a[i]<m)
30 | 					currentmax+=(ll)a[i];
31 | 					else if(currentmax+a[i]==m)
32 | 					{
33 | 						maxsum=currentmax+(ll)a[i];
34 | 						break;
35 | 					}
36 | 					j++;
37 | 				}
38 | 			}
39 | 			maxsum=max(maxsum,currentmax);
40 | 		}
41 | 		printf("%lld\n",maxsum);
42 | 	return 0;
43 | }


--------------------------------------------------------------------------------
/SPOJ ALIEN (Modified Kadane's Algorithm) ( Here if number of steps is same then we choose the one with the lesser sum ) ( Like SPOJ HOTELS ).cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <algorithm>
 3 | #include <cstdio>
 4 | using namespace std;
 5 | typedef long long int ll;
 6 | int a[100001];
 7 | int main() {
 8 | 	int t;
 9 | 	scanf("%d",&t);
10 | 	while(t--)
11 | 	{
12 | 		int n,p=0,steps=0,minsteps=0;
13 | 		ll b,sum=0,minpeople=10000001;
14 | 		scanf("%d%lld",&n,&b);
15 | 		for(int i=0;i<n;i++)
16 | 		{
17 | 			scanf("%d",&a[i]);
18 | 		}
19 | 		for(int i=0;i<n;i++)
20 | 		{
21 | 			if(sum+a[i]<=b)
22 | 			{
23 | 				sum+=a[i];
24 | 				steps++;
25 | 			}
26 | 			else
27 | 			{
28 | 				sum+=a[i];
29 | 				steps++;
30 | 				while(sum>b)
31 | 				{
32 | 					sum-=a[p];
33 | 					steps--;
34 | 					p++;
35 | 				}
36 | 			}
37 | 			if(minsteps<steps)
38 | 			{
39 | 				minsteps=steps;
40 | 				minpeople=sum;
41 | 			}
42 | 			else if(minsteps==steps)
43 | 			{
44 | 				if(minpeople>sum)
45 | 				{
46 | 					minpeople=sum;
47 | 				}
48 | 			}
49 | 		}
50 | 		printf("%lld %d\n",minpeople,minsteps);
51 | 	}
52 | 	return 0;
53 | }


--------------------------------------------------------------------------------
/SPOJ FIBOSUM( Matrix Expo and for Fibonacci Series S(n)=F(n 2)-1 ).cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long int LL;
 4 | const long long int mod=1000000007;
 5 | LL A[2][2]={{1,1},{1,0}};
 6 | void matrix_multiply(LL T[2][2],LL A[2][2])
 7 | {
 8 | 	LL result[2][2];
 9 | 	for(int i=0;i<2;i++)
10 | 	{
11 | 		for(int j=0;j<2;j++)
12 | 		{
13 | 			result[i][j]=0;
14 | 			for(int k=0;k<2;k++)
15 | 			{
16 | 				result[i][j]=(result[i][j]+(T[i][k]*A[k][j])%mod)%mod;
17 | 			}
18 | 		}
19 | 	}
20 | 	for(int i=0;i<2;i++)
21 | 	{
22 | 		for(int j=0;j<2;j++)
23 | 		{
24 | 			T[i][j]=result[i][j];
25 | 		}
26 | 	}
27 | }
28 | void matrix_power(LL T[2][2],LL exponent)
29 | {
30 | 	if(exponent==0||exponent==1)
31 | 	return;
32 | 	matrix_power(T,exponent>>1);
33 | 	matrix_multiply(T,T);
34 | 	if(exponent&1)
35 | 	matrix_multiply(T,A);
36 | }
37 | LL result(LL n)
38 | {
39 | 	LL T[2][2]={{1,1},{1,0}};
40 | 	matrix_power(T,n);
41 | 	LL ans=(T[0][1]);
42 | 	ans=(ans-1+mod)%mod;
43 | 	return ans;
44 | }
45 | int main() {
46 | 	int t;
47 | 	scanf("%d",&t);
48 | 	while(t--)
49 | 	{
50 | 		LL n,m,ans;
51 | 		scanf("%lld%lld",&n,&m);
52 | 		ans=(result(m+2)-result(n+1)+mod)%mod;
53 | 		printf("%lld\n",ans);
54 | 		
55 | 	}
56 | 	return 0;
57 | }


--------------------------------------------------------------------------------
/SPOJ THEATRE.cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | 
 3 | /*INCLUDE_HEADERS*/
 4 | #include<stdio.h>
 5 | #include<string.h>
 6 | #include <vector>
 7 | #include <list>
 8 | #include <map>
 9 | #include <set>
10 | #include <queue>
11 | #include <deque>
12 | #include <stack>
13 | #include <bitset>
14 | #include <algorithm>
15 | #include <functional>
16 | #include <numeric>
17 | #include <utility>
18 | #include <sstream>
19 | #include <iostream>
20 | #include <iomanip>
21 | #include <cstdio>
22 | #include <cmath>
23 | #include <cstdlib>
24 | #include <ctime>
25 | /*END HEADERS*/
26 | using namespace std;
27 | #define mod 1000000007
28 | typedef long long int lld;
29 | lld a[100001];
30 | int main() {
31 | 	stack<lld> s;
32 | 	lld x,ans=1;
33 | 	s.push(0);
34 | 	int n;
35 | 	scanf("%d",&n);
36 | 	for(int i=0;i<n;i++)
37 | 	{
38 | 		scanf("%lld",&a[i]);
39 | 	}
40 | 	for(int i=n-1;i>=0;i--)
41 | 	{
42 | 		if(a[i]>s.top())
43 | 		{
44 | 			while(!s.empty()&&a[i]>s.top())s.pop();
45 | 			if(s.empty())
46 | 			s.push(a[i]);
47 | 			else
48 | 			{
49 | 				ans=(ans*s.top())%mod;
50 | 				s.push(a[i]);
51 | 			}
52 | 		}
53 | 		else
54 | 		{
55 | 			ans=(ans*s.top())%mod;
56 | 			s.push(a[i]);
57 | 		}
58 | 	}
59 | 	ans=ans%mod;
60 | 	printf("%lld\n",ans);
61 | 	return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/SPOJ MECGROUP.cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | 
 3 | /*INCLUDE_HEADERS*/
 4 | #include<stdio.h>
 5 | #include<string.h>
 6 | #include <vector>
 7 | #include <list>
 8 | #include <map>
 9 | #include <set>
10 | #include <queue>
11 | #include <deque>
12 | #include <stack>
13 | #include <bitset>
14 | #include <algorithm>
15 | #include <functional>
16 | #include <numeric>
17 | #include <utility>
18 | #include <sstream>
19 | #include <iostream>
20 | #include <iomanip>
21 | #include <cstdio>
22 | #include <cmath>
23 | #include <cstdlib>
24 | #include <ctime>
25 | /*END HEADERS*/
26 | using namespace std;
27 | 
28 | typedef long long int lld;
29 | 
30 | lld C[61][61]={0};
31 | lld generate(int n,int r)
32 | {
33 | 	if(r > n){ C[n][r]=0; return 0; }
34 | 	if (n == r){ C[n][n]=1; return 1; }
35 | 	if (r == 0){ C[n][0]=1; return 1; }
36 | 	if (r == 1){ C[n][1]=n; return n; }
37 | 	if(C[n][r]) return C[n][r];
38 | 	C[n][r]=generate(n-1,r-1)+generate(n-1,r);
39 | 	return C[n][r];
40 | }
41 | int main() {
42 | 	int t,b,g,te;
43 | 	scanf("%d",&te);
44 | 	while(te--)
45 | 	{
46 | 		scanf("%d%d%d",&b,&g,&t);
47 | 		lld sum=0;
48 | 		for(int i=4;i<=(t-1);i++)
49 | 		{
50 | 			sum=sum+(generate(b,i)*generate(g,t-i));
51 | 		}
52 | 		printf("%lld\n",sum);
53 | 	}
54 | 	return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/SPOJ XOR MAXIMIZATION.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | {
 7 |     int n;
 8 |     
 9 |     scanf("%d",&n);
10 |     
11 |     vector<long long> v;
12 |     long long x;
13 |     for(int i=0;i<n;i++)
14 |     {
15 |             scanf("%lld",&x);
16 |             v.push_back(x);
17 |     }
18 |     
19 |     sort(v.rbegin(),v.rend());
20 |     
21 |     long long int sig=1;
22 |     
23 |     while(sig<=v[0])
24 |     sig<<=1;
25 |     
26 |     sig>>=1;
27 |     
28 |     for(int t=0;sig>=1;sig>>=1)
29 |     {
30 |             int i=t;
31 |             
32 |             while(i<n && (v[i]&sig)==0)
33 |             i++;
34 |             
35 |             if(i>=n)
36 |             continue;
37 |             
38 |             swap(v[t],v[i]);
39 |             
40 |             for(int j=t+1;j<n;++j)
41 |             {
42 |                     if((v[j]&sig)!=0)
43 |                     v[j]=v[j]^v[t];
44 |             }
45 |             
46 |             t++;
47 |             
48 |     }
49 |     
50 |     long long int result=0;
51 |     
52 |     for(int q=0;q<n;q++)
53 |     {
54 |             if((result^v[q])>result)
55 |             result=result^v[q];
56 |     }
57 |     
58 |     printf("%lld\n",result);
59 |     
60 |     return 0;
61 | }


--------------------------------------------------------------------------------
/SPOJ ACODE (DP with a special requirement).cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | long long int dp[5010];
 4 | char s[5010];
 5 | int main() {
 6 | 	scanf("%s",s);
 7 | 	while(strcmp(s,"0"))
 8 | 	{
 9 | 		int flag=0;
10 | 		memset(dp,0,sizeof(dp));
11 | 		dp[0]=1;
12 | 		if(strlen(s)<2)
13 | 		{	
14 | 			printf("%lld\n",dp[0]);
15 | 			scanf("%s",s);
16 | 			continue;
17 | 		}
18 | 		char ss[3];
19 | 		ss[0]=s[0];
20 | 		ss[1]=s[1];
21 | 		ss[2]='\0';
22 | 		int y=atoi(ss);
23 | 		if(s[1]=='0'&&y>26)
24 | 		{
25 | 			printf("0\n");
26 | 			scanf("%s",s);
27 | 			continue;
28 | 		}
29 | 		else if(s[1]=='0')
30 | 		{
31 | 			dp[1]=1;
32 | 		}
33 | 		else 
34 | 		{
35 | 			if(y<=26&&y>9)
36 | 			dp[1]=2;
37 | 			else
38 | 			dp[1]=1;
39 | 		}
40 | 		for(int i=2;i<strlen(s);i++)
41 | 		{
42 | 			char s1[3];
43 | 			s1[0]=s[i-1];
44 | 			s1[1]=s[i];
45 | 			s1[2]='\0';
46 | 			int x=atoi(s1);
47 | 			if(s[i]=='0'&&x>26)
48 | 			{
49 | 				flag=1;
50 | 				printf("0\n");
51 | 				break;
52 | 			}
53 | 			else if(s[i]=='0')
54 | 			{
55 | 				dp[i]=dp[i-2];
56 | 			}
57 | 			else
58 | 			{
59 | 				if(x<=26&&x>9)
60 | 				{
61 | 					dp[i]=dp[i-1]+dp[i-2];
62 | 				}
63 | 				else
64 | 				{
65 | 					dp[i]=dp[i-1];
66 | 				}
67 | 			}
68 | 		}
69 | 		if(flag!=1)
70 | 		printf("%lld\n",dp[strlen(s)-1]);
71 | 		scanf("%s",s);
72 | 	}
73 | 	return 0;
74 | }


--------------------------------------------------------------------------------
/SPOJ CATM.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main() {
 4 | 	int x,y,k,a,b,c,d,e,f,dis1,dis2,dis3;
 5 | 	scanf("%d%d%d",&x,&y,&k);
 6 | 	for(int i=0;i<k;i++)
 7 | 	{
 8 | 		int flag=0;
 9 | 		scanf("%d%d%d%d%d%d",&a,&b,&c,&d,&e,&f);
10 | 		for(int j=1;j<=y;j++)
11 | 		{
12 | 			dis1=abs(a-1)+abs(b-j);
13 | 			dis2=abs(c-1)+abs(d-j);
14 | 			dis3=abs(e-1)+abs(f-j);
15 | 			if(dis1<dis2&&dis1<dis3)
16 | 			{
17 | 				flag=1;
18 | 				break;
19 | 			}
20 | 		}
21 | 		if(flag!=1)
22 | 		{
23 | 			for(int j=1;j<=x;j++)
24 | 			{
25 | 				dis1=abs(a-j)+abs(b-y);
26 | 				dis2=abs(c-j)+abs(d-y);
27 | 				dis3=abs(e-j)+abs(f-y);
28 | 				if(dis1<dis2&&dis1<dis3)
29 | 				{
30 | 					flag=1;
31 | 					break;
32 | 				}
33 | 			}
34 | 		}
35 | 		if(flag!=1)
36 | 		{
37 | 			for(int j=1;j<=y;j++)
38 | 			{
39 | 				dis1=abs(a-x)+abs(b-j);
40 | 				dis2=abs(c-x)+abs(d-j);
41 | 				dis3=abs(e-x)+abs(f-j);
42 | 				if(dis1<dis2&&dis1<dis3)
43 | 				{
44 | 					flag=1;
45 | 					break;
46 | 				}
47 | 			}
48 | 		}
49 | 		if(flag!=1)
50 | 		{
51 | 			for(int j=1;j<=x;j++)
52 | 			{
53 | 				dis1=abs(a-j)+abs(b-1);
54 | 				dis2=abs(c-j)+abs(d-1);
55 | 				dis3=abs(e-j)+abs(f-1);
56 | 				if(dis1<dis2&&dis1<dis3)
57 | 				{
58 | 					flag=1;
59 | 					break;
60 | 				}
61 | 			}
62 | 		}
63 | 		if(flag!=1)printf("NO\n");
64 | 		else printf("YES\n");
65 | 	}
66 | 	return 0;
67 | }


--------------------------------------------------------------------------------
/SPOJ ANARC09A (Check if the expression is balanced using Stack ( here it's variation is used )).cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | 
 3 | /*INCLUDE_HEADERS*/
 4 | #include<stdio.h>
 5 | #include<string.h>
 6 | #include <vector>
 7 | #include <list>
 8 | #include <map>
 9 | #include <set>
10 | #include <queue>
11 | #include <deque>
12 | #include <stack>
13 | #include <bitset>
14 | #include <algorithm>
15 | #include <functional>
16 | #include <numeric>
17 | #include <utility>
18 | #include <sstream>
19 | #include <iostream>
20 | #include <iomanip>
21 | #include <cstdio>
22 | #include <cmath>
23 | #include <cstdlib>
24 | #include <ctime>
25 | /*END HEADERS*/
26 | using namespace std;
27 | 
28 | int main() {
29 | 	ios_base::sync_with_stdio(false);
30 | 	cin.tie(NULL);
31 | 	string s;
32 | 	cin>>s;
33 | 	int counter = 1;
34 | 	while(s[0]!='-')
35 | 	{
36 | 	    int count=0;
37 | 	    printf("%d. ",counter);
38 | 	    counter++;
39 | 		stack<char> st;
40 | 		for(int i=0;i<s.size();i++)
41 |         {
42 |             if(s[i]=='{')
43 |                 st.push(s[i]);
44 |             else if (st.size()==0&&s[i]=='}')
45 |             {
46 |             	count++;
47 |             	st.push('{');
48 |             }
49 |             else
50 |             {
51 |                 st.pop();
52 |             }
53 |         }
54 |         if(st.size()!=0)
55 |         {
56 |         	count+=st.size()/2;
57 |         }
58 |         printf("%d\n",count);
59 | 		cin>>s;
60 | 	}
61 | 	return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/SPOJ MIXTURE DP O(n^3) [Only above diagonal elements required, values of rows and columns chosen smartly and all the values in between them considered].cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <list>
 3 | #include <map>
 4 | #include <set>
 5 | #include <deque>
 6 | #include <queue>
 7 | #include <stack>
 8 | #include <bitset>
 9 | #include <algorithm>
10 | #include <functional>
11 | #include <numeric>
12 | #include <utility>
13 | #include <sstream>
14 | #include <iostream>
15 | #include <iomanip>
16 | #include <cstdio>
17 | #include <cmath>
18 | #include <cstdlib>
19 | #include <ctime>
20 | #include <cstring>
21 | #include <climits>
22 | #include <stdlib.h>
23 | using namespace std;
24 | #define INF 10000000;
25 | #define REP(a,b) for(int i=a;i<=b;i++)
26 | 
27 | int color[101];
28 | int csum(int a,int b){
29 | 	int sum=0;
30 | 		for(int i=a-1;i<b;i++)
31 | 		{
32 | 			sum=(sum+color[i]);
33 | 			sum%=100;
34 | 		}
35 | 	return sum;
36 | }
37 | int main() {
38 | 	int n,l,j,k;
39 | 	while(scanf("%d",&n)!=-1)
40 | 	{
41 | 		int dp[n+1][n+1];
42 | 		REP(0,n-1)
43 | 		scanf("%d",&color[i]);
44 | 		for(j=0;j<=n;j++)
45 | 		{
46 | 			for(k=0;k<=n;k++)
47 | 			{
48 | 				dp[j][k]=INF;
49 | 			}
50 | 		}
51 | 		REP(0,n)
52 | 		dp[i][i]=0;
53 | 		for(j=1;j<n;j++)
54 | 		{
55 | 			for(k=1;k<=n-j;k++)
56 | 			{
57 | 				int m=k+j;
58 | 				for(l=k;l<m;l++)
59 | 				{
60 | 					int temp=(dp[k][l]+dp[l+1][m]+(csum(k,l)*csum(l+1,m)));
61 | 					if(temp<dp[k][m])
62 | 					{
63 | 						dp[k][m]=temp;
64 | 					}
65 | 				}
66 | 			}
67 | 		}
68 | 		printf("%d\n",dp[1][n]);
69 | 	}
70 | 	return 0;
71 | }


--------------------------------------------------------------------------------
/SPOJ ONEZERO (String Remainder Function there but not used).cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #include<cstdio>
 3 | #include<algorithm>
 4 | using namespace std;
 5 | 
 6 | typedef long long int LL;
 7 | 
 8 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 9 | #define REP(p,a,b) for(int p=a;p<=b;p++)
10 | 
11 | int stringremainder(char *s,int y)
12 | {
13 | 	int modulus=0;
14 | 	for(int i=0;i<strlen(s);i++)
15 | 	{
16 | 		int x=(int)(s[i]-'0');
17 | 		modulus=(modulus*10+x)%y;
18 | 	}
19 | 	return modulus;
20 | }
21 | 
22 | int visited[20000];
23 | struct node
24 | {
25 | 	string number;
26 | 	int modulus;
27 | };
28 | 
29 | 
30 | 	void BFS(int s)
31 | 	{
32 | 		list<struct node> q;
33 | 		node temp;
34 | 		temp.number='1';
35 | 		temp.modulus=1%s;
36 | 		visited[temp.modulus]=1;
37 | 		q.push_back(temp);
38 | 		while(!q.empty())
39 | 		{
40 | 			node temp1=q.front();
41 | 			if(temp1.modulus==0)
42 | 			{
43 | 				//printf("%s\n",temp1.number);
44 | 				cout<<temp1.number<<endl;
45 | 				break;
46 | 			}
47 | 			q.pop_front();
48 | 			visited[temp1.modulus]=1;
49 | 			node temp2,temp3;
50 | 			temp2.number=temp1.number;
51 | 			temp3.number=temp1.number;
52 | 			temp2.number+='0';
53 | 			temp3.number+='1';
54 | 			int x;
55 | 			x=(temp1.modulus*10)%s;
56 | 			temp2.modulus=x;
57 | 			if(visited[x]==0)
58 | 			q.push_back(temp2);
59 | 			x=(temp1.modulus*10+1)%s;
60 | 			temp3.modulus=x;
61 | 			if(visited[x]==0)
62 | 			q.push_back(temp3);
63 | 			
64 | 		}
65 | 	}
66 | 	
67 | 	
68 | int main() {
69 | 	int t;
70 | 	scanf("%d",&t);
71 | 	while(t--)
72 | 	{
73 | 		for(int i=0;i<20000;i++)visited[i]=0;
74 | 		int n;
75 | 		scanf("%d",&n);
76 | 		BFS(n);
77 | 	}
78 | 	return 0;
79 | }


--------------------------------------------------------------------------------
/SPOJ PT07Z.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> v[10001];
 5 | int temp=0,d=0;
 6 | int visited[10001]={0};
 7 | void bfs(int e)
 8 | {
 9 |     queue<int> q;
10 |     q.push(e);
11 |     visited[e]=1;
12 |     q.push(-1);
13 |     while(q.size()!=1)
14 |     {
15 |         temp=q.front();
16 |         q.pop();
17 |         if(temp==-1)
18 |         {
19 |             q.push(-1);
20 |         }
21 |         else
22 |         {
23 |             visited[temp]=1;
24 |             for(int i=0;i<v[temp].size();i++)
25 |             {
26 |                 if(visited[v[temp][i]]==0)
27 |                     {
28 |                         q.push(v[temp][i]);
29 |                     }
30 |             }
31 |         }
32 |     }
33 | }
34 | void bfs1(int e)
35 | {
36 |     queue<int> q1;
37 |     q1.push(e);
38 |     visited[e]=1;
39 |     q1.push(-1);
40 |     while(q1.size()!=1)
41 |     {
42 |         int temp1=q1.front();
43 |         q1.pop();
44 |         if(temp1==-1)
45 |         {
46 |             d++;
47 |             q1.push(-1);
48 |         }
49 |         else{
50 |             	visited[temp1]=1;
51 |             	for(int i=0;i<v[temp1].size();i++)
52 |             		{
53 |                 		if(visited[v[temp1][i]]==0)
54 |                 			q1.push(v[temp1][i]);
55 |         		    }
56 |         	}
57 |     }
58 | }
59 | 
60 | int main()
61 | {
62 |     int x,a,b;
63 |     scanf("%d",&x);
64 |     for(int i=0;i<x-1;i++)
65 |     {
66 |         scanf("%d%d",&a,&b);
67 |         v[a].push_back(b);
68 |         v[b].push_back(a);
69 |     }
70 |     bfs(1);
71 |     for(int i=0;i<=10000;i++)visited[i]=0;
72 |     bfs1(temp);
73 |     printf("%d\n",d);
74 |     return 0;
75 | }
76 | 


--------------------------------------------------------------------------------
/SPOJ MCOINS ( Game Theory - Read the Comments ).cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | 
 3 | /*
 4 | Game Theory - First Identify the winning states and try to build smaller bigger states from it like if ans is known for 1,2,3 try to find for 4,5 etc.
 5 | Now if any state can be reduced to a losing state(here if the player plays first and ends up on his losing state that means he wins because the he started
 6 | on the losing state for our answer but now the other plays starts from there. Fill up the array for the MAX limit and display the answer.
 7 | */
 8 | 
 9 | /*INCLUDE_HEADERS*/
10 | #include<stdio.h>
11 | #include<string.h>
12 | #include <vector>
13 | #include <list>
14 | #include <map>
15 | #include <set>
16 | #include <queue>
17 | #include <deque>
18 | #include <stack>
19 | #include <bitset>
20 | #include <algorithm>
21 | #include <functional>
22 | #include <numeric>
23 | #include <utility>
24 | #include <sstream>
25 | #include <iostream>
26 | #include <iomanip>
27 | #include <cstdio>
28 | #include <cmath>
29 | #include <cstdlib>
30 | #include <ctime>
31 | /*END HEADERS*/
32 | using namespace std;
33 | #define MAX 1000001
34 | bool ans[MAX];
35 | int main() {
36 | 	//freopen("input.txt","r",stdin);
37 | 	//freopen("output.txt","w",stdout);
38 | 	int k,l,m;
39 | 	scanf("%d%d%d",&k,&l,&m);
40 | 	ans[0]=false;
41 | 	ans[1]=true;
42 | 	for(int i=2;i<MAX;i++)
43 |     {
44 |         ans[i]=false;
45 |         if(ans[i-1]==false)ans[i]=true;
46 |         else if((i-k)>=0&&ans[i-k]==false)ans[i]=true;
47 |         else if((i-l)>=0&&ans[i-l]==false)ans[i]=true;
48 |     }
49 |     for(int i=0;i<m;i++)
50 |     {
51 |         scanf("%d",&k);
52 |         if(ans[k])printf("A");
53 |         else printf("B");
54 |     }
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/SPOJ BUGLIFE (Bipartite Graph - Read the Comments ).cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | SPOJ BUGLIFE (Bipartite Graph - All the nodes can be put into two sets and there is no connection
 3 | inside one set(only cross connection) ie "bi" and here we can say that one set is male and other
 4 | set is female and all males is connected to females only. 
 5 | */
 6 | #include <bits/stdc++.h>
 7 | #include<cstdio>
 8 | #include<algorithm>
 9 | using namespace std;
10 | 
11 | int flag=0;
12 | int k=0;
13 | vector<int> adj[2003];
14 | int color[2003];
15 | list<int> q;
16 | 
17 | int main() {
18 | 	int t;
19 | 	scanf("%d",&t);
20 | 	while(t--)
21 | 	{
22 | 		k++;
23 | 		flag=0;
24 | 		int v,e,a,b;
25 | 		scanf("%d%d",&v,&e);
26 | 		for(int i=1;i<=v;i++)
27 | 		{
28 | 			adj[i].clear();
29 | 		}
30 | 		q.clear();
31 | 		for(int i=0;i<e;i++)
32 | 		{
33 | 			scanf("%d%d",&a,&b);
34 | 			adj[a].push_back(b);
35 | 			adj[b].push_back(a);
36 | 		}
37 | 		for(int i=0;i<=2002;i++)color[i]=-1;
38 | 		for(int i=1;i<=v;i++)
39 | 		{
40 | 			if(color[i]==-1)
41 | 			{
42 | 				color[i]=1;
43 | 				q.push_back(i);
44 | 				vector<int>::iterator j;
45 | 				while(!q.empty())
46 | 				{
47 | 					int s=q.front();
48 | 					q.pop_front();
49 | 					for(j=adj[s].begin();j != adj[s].end();j++)
50 | 					{
51 | 						if(color[*j]==-1)
52 | 						{
53 | 							color[*j]=1-color[s];
54 | 							q.push_back(*j);
55 | 						}
56 | 						else if(color[*j]==color[s])
57 | 						{
58 | 							flag=1;
59 | 							break;
60 | 						}
61 | 					}
62 | 					if(flag==1)break;
63 | 				}
64 | 			}
65 | 			if(flag==1)break;
66 | 		}
67 | 		printf("Scenario #%d:\n",k);
68 | 		if(flag==1)
69 | 		{
70 | 			printf("Suspicious bugs found!\n");
71 | 		}
72 | 		else 
73 | 		{
74 | 			printf("No suspicious bugs found!\n");
75 | 		}
76 | 	}
77 | 	return 0;
78 | }


--------------------------------------------------------------------------------
/SPOJ QUEST5 (Count Overlapping Intervals).cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | /*
 3 | To count overlapping intervals, sort on the basis of upper limit of the interval. If other interval's starting value is greater than the maximum value of
 4 | upper interval then the interval lies outside and we increase count and also increase the max upper limit.
 5 | */
 6 | /*INCLUDE_HEADERS*/
 7 | #include<stdio.h>
 8 | #include<string.h>
 9 | #include <vector>
10 | #include <list>
11 | #include <map>
12 | #include <set>
13 | #include <queue>
14 | #include <deque>
15 | #include <stack>
16 | #include <bitset>
17 | #include <algorithm>
18 | #include <functional>
19 | #include <numeric>
20 | #include <utility>
21 | #include <sstream>
22 | #include <iostream>
23 | #include <iomanip>
24 | #include <cstdio>
25 | #include <cmath>
26 | #include <cstdlib>
27 | #include <ctime>
28 | /*END HEADERS*/
29 | using namespace std;
30 | typedef long long int lld;
31 | 
32 | int cmp(pair<lld,lld> a,pair<lld,lld> b)
33 | {
34 |     return a.second<b.second;
35 | }
36 | int main() {
37 | 	//freopen("input.txt","r",stdin);
38 | 	//freopen("output.txt","w",stdout);
39 | 	int t;
40 | 	scanf("%d",&t);
41 | 	while(t--)
42 |     {
43 |         int n;
44 |         lld x,y,count=0;
45 |         vector < pair < lld, lld> > v;
46 |         scanf("%d",&n);
47 |         for(int i=0;i<n;i++)
48 |         {
49 |             scanf("%lld%lld",&x,&y);
50 |             v.push_back(make_pair(x,y));
51 |         }
52 |         sort(v.begin(),v.end(),cmp);
53 |         lld max=-1;
54 |         for(int i=0;i<v.size();i++)
55 |         {
56 |             if(v[i].first>max)
57 |             {
58 |                 count++;
59 |                 max=v[i].second;
60 |             }
61 |         }
62 |         printf("%lld\n",count);
63 |     }
64 | 	return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/SPOJ PT07X - Vertex Cover.cpp:
--------------------------------------------------------------------------------
 1 | #include <vector>
 2 | #include <list>
 3 | #include <map>
 4 | #include <set>
 5 | #include <deque>
 6 | #include <queue>
 7 | #include <stack>
 8 | #include <bitset>
 9 | #include <algorithm>
10 | #include <functional>
11 | #include <numeric>
12 | #include <utility>
13 | #include <sstream>
14 | #include <iostream>
15 | #include <iomanip>
16 | #include <cstdio>
17 | #include <cmath>
18 | #include <cstdlib>
19 | #include <ctime>
20 | #include <cstring>
21 | #include <climits>
22 | #include <stdlib.h>
23 | using namespace std;
24 | #define REP(a,b) for(int i=a;i<=b;i++)
25 | #define ITER(a) for(typeof(a.begin()) it=a.begin();it!=a.end();it++)
26 | #define MAXV 100001
27 | vector<int> adj[MAXV];
28 | int dp[MAXV][2];
29 | int visited[MAXV][2]={0};
30 | int solve(int u,int taken,int parent)
31 | {
32 |     if(visited[u][taken]==1)
33 |         return dp[u][taken];
34 |     visited[u][taken]=1;
35 |     int ans=0;
36 |     ITER(adj[u])
37 |     {
38 |         if(*it!=parent)
39 |         {
40 |             if(taken==1)ans=ans+min(solve(*it,1,u),solve(*it,0,u));
41 |             else ans=ans+solve(*it,1,u);
42 |         }
43 |     }
44 |     ans=ans+taken;
45 |     dp[u][taken]=ans;
46 |     return ans;
47 | }
48 | 
49 | int main()
50 | {
51 |     int n,a,b;
52 |     while(scanf("%d",&n)==1)
53 |     {
54 |         REP(0,MAXV-1)
55 |         {
56 |             visited[i][0]=0;
57 |             visited[i][1]=0;
58 |         }
59 |         REP(0,MAXV)adj[i].clear();
60 |         for(int i=1;i<n;i++)
61 |         {
62 |             scanf("%d%d",&a,&b);
63 |             adj[a].push_back(b);
64 |             adj[b].push_back(a);
65 |         }
66 |         //int ans=1;
67 |         //if(n!=1)
68 |         int ans=min(solve(1,1,-1),solve(1,0,-1));
69 |         printf("%d\n",ans);
70 |     }
71 |     return 0;
72 | }
73 | 


--------------------------------------------------------------------------------
/SPOJ EZDIJKST (using REP(i,a,b)).cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #include<cstdio>
 3 | #include<algorithm>
 4 | using namespace std;
 5 |  
 6 | typedef long long int LL;
 7 |  
 8 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 9 | #define REP(p,a,b) for(int p=a;p<b;p++)
10 | #define mod 1000000007
11 |  
12 | struct node
13 | {
14 | 	int pre,dist;
15 | }node[100001];
16 |  
17 | struct cmp
18 | {
19 | 	bool operator()(const pair<int,int> &lhs,const pair<int,int> &rhs)
20 | 	{
21 | 		return lhs.second>rhs.second;
22 | 	}
23 | };
24 | priority_queue<pair<int,int>,vector< pair<int,int> >,cmp> q;
25 | vector<int> adj[100001];
26 | vector<int> w[100001];
27 |  
28 | void relax(int s)
29 | {
30 | 	REP(i,0,adj[s].size())
31 | 	{
32 | 		if(node[adj[s][i]].dist>(node[s].dist+w[s][i]))
33 | 		{
34 | 			node[adj[s][i]].dist=(node[s].dist+w[s][i]);
35 | 			node[adj[s][i]].pre=s;
36 | 			q.push(make_pair(adj[s][i],node[adj[s][i]].dist));
37 | 		}
38 | 	}
39 | }
40 |  
41 | void intialize(int s,int v)
42 | {
43 | 	REP(i,1,v+1)
44 | 	{
45 | 		node[i].pre=-1;
46 | 		node[i].dist=INT_MAX;
47 | 	}
48 | 	node[s].dist=0;
49 | }
50 |  
51 | void dijsktra(int s,int v)
52 | {
53 |  
54 | 	intialize(s,v);
55 | 	q.push(make_pair(s,0));
56 | 	while(!q.empty())
57 | 	{
58 | 		int one=q.top().first;
59 | 		int two=q.top().second;
60 | 		q.pop();
61 | 		relax(one);
62 | 	}
63 | }
64 |  
65 | int main() {
66 | 	ios_base::sync_with_stdio(false);
67 | 	cin.tie(NULL);
68 | 	int v,e,t,a,b,weight;
69 | 	cin>>t;
70 | 	while(t--)
71 | 	{
72 | 		cin>>v>>e;
73 | 		REP(i,0,v+1)
74 | 		{
75 | 			adj[i].clear();
76 | 			w[i].clear();
77 | 		}
78 | 		REP(i,0,e)
79 | 		{
80 | 			cin>>a>>b>>weight;
81 | 			adj[a].push_back(b);
82 | 			w[a].push_back(weight);
83 | 		}
84 | 		int s,d;
85 | 		cin>>s>>d;
86 | 		dijsktra(s,v);
87 | 		if(node[d].dist!=INT_MAX)
88 | 		cout<<node[d].dist<<endl;
89 | 		else 
90 | 		cout<<"NO"<<endl;
91 | 	}
92 | 	return 0;
93 | }
94 |  


--------------------------------------------------------------------------------
/SPOJ RPLN ( Range Minimum Query ).cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | 
 3 | /*INCLUDE_HEADERS*/
 4 | #include<stdio.h>
 5 | #include<string.h>
 6 | #include <vector>
 7 | #include <list>
 8 | #include <map>
 9 | #include <set>
10 | #include <queue>
11 | #include <deque>
12 | #include <stack>
13 | #include <bitset>
14 | #include <algorithm>
15 | #include <functional>
16 | #include <numeric>
17 | #include <utility>
18 | #include <sstream>
19 | #include <iostream>
20 | #include <iomanip>
21 | #include <cstdio>
22 | #include <cmath>
23 | #include <cstdlib>
24 | #include <ctime>
25 | /*END HEADERS*/
26 | using namespace std;
27 | #define INF 1000000001
28 | int tree[500001];
29 | int arr[500001];
30 | 
31 | void build_tree(int node,int a,int b)
32 | {
33 |     if(a==b)
34 |     {
35 |         tree[node]=arr[a];
36 |         return;
37 |     }
38 |     build_tree(node<<1,a,(a+b)>>1);
39 |     build_tree(1+(node<<1),1+((a+b)>>1),b);
40 |     tree[node]=tree[node<<1]<tree[1+(node<<1)]?tree[node<<1]:tree[1+(node<<1)];
41 | }
42 | 
43 | int query(int node,int a,int b,int i,int j)
44 | {
45 |     if(a>b||b<i||a>j) return INF;
46 |     if(a>=i&&b<=j) return tree[node];
47 |     int x=query(node<<1,a,(a+b)>>1,i,j);
48 |     int y=query(1+(node<<1),1+((a+b)>>1),b,i,j);
49 |     if(x<y) return x;
50 |     else return y;
51 | }
52 | 
53 | int main() {
54 | 	//freopen("input.txt","r",stdin);
55 | 	//freopen("output.txt","w",stdout);
56 | 	int t,n,q,x,y;
57 | 	scanf("%d",&t);
58 | 	for(int j=1;j<=t;j++)
59 |     {
60 |         memset(tree,0,sizeof(tree));
61 |         scanf("%d%d",&n,&q);
62 |         for(int i=0;i<n;i++)
63 |         {
64 |             scanf("%d",&arr[i]);
65 |         }
66 |         build_tree(1,0,n-1);
67 |         printf("Scenario #%d:\n",j);
68 |         for(int i=0;i<q;i++)
69 |         {
70 |             scanf("%d%d",&x,&y);
71 |             x--;
72 |             y--;
73 |             int ans=query(1,0,n-1,x,y);
74 |             printf("%d\n",ans);
75 |         }
76 |     }
77 | 	return 0;
78 | }
79 | 


--------------------------------------------------------------------------------
/SPOJ HIGHWAYS.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #include<cstdio>
 3 | #include<algorithm>
 4 | using namespace std;
 5 |  
 6 | typedef long long int LL;
 7 |  
 8 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 9 | #define REP(p,a,b) for(int p=a;p<=b;p++)
10 | #define mod 1000000007
11 | 
12 | struct node
13 | {
14 | 	int dist;
15 | }node[100002];
16 | 
17 | struct cmp
18 | {
19 | 	bool operator()(const pair<int,int> &lhs,const pair<int,int> &rhs)
20 | 	{
21 | 		return lhs.second>rhs.second;
22 | 	}
23 | };
24 | priority_queue < pair<int,int>, vector< pair<int,int> >,greater< pair<int,int> > > q;
25 | vector<int> adj[100002];
26 | vector<int> w[100002];
27 | 
28 | void relax(int s)
29 | {
30 | 	for(int i=0;i<adj[s].size();i++)
31 | 	{
32 | 		if(node[adj[s][i]].dist>(node[s].dist+w[s][i]))
33 | 		{
34 | 			node[adj[s][i]].dist=(node[s].dist+w[s][i]);
35 | 			//node[adj[s][i]].pre=s;
36 | 			q.push(make_pair(adj[s][i],node[adj[s][i]].dist));
37 | 		}
38 | 	}
39 | }
40 | 
41 | void intialize(int s,int v)
42 | {
43 | 	for(int i=0;i<=100001;i++)
44 | 	{
45 | 		//node[i].pre=-1;
46 | 		node[i].dist=INT_MAX;
47 | 	}
48 | 	node[s].dist=0;
49 | }
50 | 
51 | void dijsktra(int s,int v)
52 | {
53 | 	intialize(s,v);
54 | 	q.push(make_pair(s,0));
55 | 	while(!q.empty())
56 | 	{
57 | 		int one=q.top().first;
58 | 		//int two=q.top().second;
59 | 		q.pop();
60 | 		relax(one);
61 | 	}
62 | }
63 | 
64 | int main() {
65 | 	ios_base::sync_with_stdio(false);
66 | 	cin.tie(NULL);
67 | 	int v,e,t,a,s,d,b;
68 | 	int weight;
69 | 	cin>>t;
70 | 	while(t--)
71 | 	{
72 | 		cin>>v>>e>>s>>d;
73 | 		for(int i=0;i<=100001;i++)
74 | 		{
75 | 			adj[i].clear();
76 | 			w[i].clear();
77 | 		}
78 | 		for(int i=0;i<e;i++)
79 | 		{
80 | 			cin>>a>>b>>weight;
81 | 			adj[a].push_back(b);
82 | 			adj[b].push_back(a);
83 | 			w[a].push_back(weight);
84 | 			w[b].push_back(weight);
85 | 		}
86 | 		dijsktra(s,d);
87 | 		if(node[d].dist!=INT_MAX)
88 | 		cout<<node[d].dist<<endl;
89 | 		else 
90 | 		cout<<"NONE"<<endl;
91 | 	}
92 | 	return 0;
93 | }


--------------------------------------------------------------------------------
/SPOJ TRVCOST.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #include<cstdio>
 3 | #include<algorithm>
 4 | using namespace std;
 5 |  
 6 | typedef long long int LL;
 7 |  
 8 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 9 | #define REP(p,a,b) for(int p=a;p<=b;p++)
10 | #define mod 1000000007
11 | 
12 | struct node
13 | {
14 | 	int pre,dist;
15 | }node[501];
16 | 
17 | struct cmp
18 | {
19 | 	bool operator()(const pair<int,int> &lhs,const pair<int,int> &rhs)
20 | 	{
21 | 		return lhs.second>rhs.second;
22 | 	}
23 | };
24 | priority_queue<pair<int,int>,vector< pair<int,int> >,cmp> q;
25 | vector<int> adj[501];
26 | vector<int> w[501];
27 | 
28 | void relax(int s)
29 | {
30 | 	for(int i=0;i<adj[s].size();i++)
31 | 	{
32 | 		if(node[adj[s][i]].dist>(node[s].dist+w[s][i]))
33 | 		{
34 | 			node[adj[s][i]].dist=(node[s].dist+w[s][i]);
35 | 			node[adj[s][i]].pre=s;
36 | 			q.push(make_pair(adj[s][i],node[adj[s][i]].dist));
37 | 		}
38 | 	}
39 | }
40 | 
41 | void intialize(int s,int v)
42 | {
43 | 	for(int i=0;i<=v;i++)
44 | 	{
45 | 		node[i].pre=-1;
46 | 		node[i].dist=INT_MAX;
47 | 	}
48 | 	node[s].dist=0;
49 | }
50 | 
51 | void dijsktra(int s,int v)
52 | {
53 | 	intialize(s,v);
54 | 	q.push(make_pair(s,0));
55 | 	while(!q.empty())
56 | 	{
57 | 		int one=q.top().first;
58 | 		int two=q.top().second;
59 | 		q.pop();
60 | 		relax(one);
61 | 	}
62 | }
63 | 
64 | int main() {
65 | 	ios_base::sync_with_stdio(false);
66 | 	cin.tie(NULL);
67 | 	int e,t,a,b,weight;
68 | 		cin>>e;
69 | 		for(int i=0;i<=500;i++)
70 | 		{
71 | 			adj[i].clear();
72 | 			w[i].clear();
73 | 		}
74 | 		for(int i=0;i<e;i++)
75 | 		{
76 | 			cin>>a>>b>>weight;
77 | 			adj[a].push_back(b);
78 | 			adj[b].push_back(a);
79 | 			w[a].push_back(weight);
80 | 			w[b].push_back(weight);
81 | 		}
82 | 		int s,d;
83 | 		cin>>s;
84 | 		dijsktra(s,500);
85 | 		cin>>t;
86 | 		for(int i=0;i<t;i++)
87 | 		{
88 | 			cin>>d;
89 | 			if(node[d].dist!=INT_MAX)
90 | 		cout<<node[d].dist<<endl;
91 | 		else 
92 | 		cout<<"NO PATH"<<endl;
93 | 		}
94 | 		
95 | 	return 0;
96 | }


--------------------------------------------------------------------------------
/SPOJ COMDIV.cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | 
 3 | #include <stdio.h>
 4 | #include <string.h>
 5 | #include <stdlib.h>
 6 | #include <vector>
 7 | #include <list>
 8 | #include <map>
 9 | #include <set>
10 | #include <queue>
11 | #include <deque>
12 | #include <stack>
13 | #include <bitset>
14 | #include <algorithm>
15 | #include <functional>
16 | #include <numeric>
17 | #include <utility>
18 | #include <sstream>
19 | #include <iostream>
20 | #include <iomanip>
21 | #include <cstdio>
22 | #include <cmath>
23 | #include <cstdlib>
24 | #include <ctime>
25 | 
26 | using namespace std;
27 | 
28 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
29 | #define INT_MIN -2147483647
30 | #define INT_MAX 2147483647
31 | #define INF 2000000000
32 | #define INF_LL 9223372036854775807LL
33 | #define PI acos(-1.0)
34 | #define llu long long unsigned
35 | #define ll long long int
36 | #define ld long int
37 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
38 | #define REP(p,a,b) for(int p=a;p<b;p++)
39 | #define mod 1000000007
40 | #define getchar_unlocked getchar
41 | #define pb(f) push_back(f)
42 | #define pob(f) pop_back(f)
43 | #define pf(f) push_front(f)
44 | #define pof(f) pop_front(f)
45 | #define mkp(a,b) make_pair(a,b)
46 | #define fst first
47 | #define snd second
48 | #define pii pair<int,int>
49 | #define ins(a) insert(a)
50 | 
51 | int gcd(int a,int b)
52 | {
53 |     if(b>a)
54 |         return gcd(b,a);
55 |     else if(b!=0)
56 |         return gcd(b,a%b);
57 |     else return a;
58 | }
59 | 
60 | int main() {
61 |     //freopen("input.txt","r",stdin);
62 |     //freopen("output.txt","w",stdout);
63 |     //ios_base::sync_with_stdio(false);
64 |     //cin.tie(NULL);
65 |     int i,t,te,a,b,cnt;
66 |     scanf("%d",&t);
67 |     while(t--)
68 |     {
69 |         cnt=0;
70 |         scanf("%d%d",&a,&b);
71 |         te=gcd(a,b);
72 |         for(i=1;i*i<=te;i++)
73 |         {
74 |             if(te%i==0)
75 |             {
76 |                 if(i*i==te)cnt++;
77 |                 else cnt+=2;
78 |             }
79 |         }
80 |         printf("%d\n",cnt);
81 |     }
82 |     return 0;
83 | }
84 | 


--------------------------------------------------------------------------------
/SPOJ COUNTISL ( DFS in 2D Matrix ).cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | 
 3 | /*INCLUDE_HEADERS*/
 4 | #include<stdio.h>
 5 | #include<string.h>
 6 | #include <vector>
 7 | #include <list>
 8 | #include <map>
 9 | #include <set>
10 | #include <queue>
11 | #include <deque>
12 | #include <stack>
13 | #include <bitset>
14 | #include <algorithm>
15 | #include <functional>
16 | #include <numeric>
17 | #include <utility>
18 | #include <sstream>
19 | #include <iostream>
20 | #include <iomanip>
21 | #include <cstdio>
22 | #include <cmath>
23 | #include <cstdlib>
24 | #include <ctime>
25 | /*END HEADERS*/
26 | using namespace std;
27 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
28 | bool visited[201][201];
29 | char M[201][201];
30 | static int rowincrement[]={-1,-1,-1,0,0,1,1,1};
31 | static int columnincrement[]={-1,0,1,-1,1,-1,0,1};
32 | 
33 | void DFS(int row,int column,int m,int n)
34 | {
35 |     visited[row][column]=true;
36 |     for(int i=0;i<8;i++)
37 |     {
38 |         if(row+rowincrement[i]>=0&&row+rowincrement[i]<m&&column+columnincrement[i]>=0&&column+columnincrement[i]<n&&M[row+rowincrement[i]][column+columnincrement[i]]=='#'&&!visited[row+rowincrement[i]][column+columnincrement[i]])
39 |         {
40 |             DFS(row+rowincrement[i],column+columnincrement[i],m,n);
41 |         }
42 |     }
43 | }
44 | 
45 | int countislands(int m,int n)
46 | {
47 |     int result=0;
48 |     memset(visited,0,sizeof(visited[0][0])*201*201);
49 |     for(int i=0;i<m;i++)
50 |     {
51 |         for(int j=0;j<n;j++)
52 |         {
53 |             if(M[i][j]=='#'&&!visited[i][j])
54 |             {
55 |                 DFS(i,j,m,n);
56 |                 result++;
57 |             }
58 |         }
59 |     }
60 |     return result;
61 | }
62 | int main() {
63 |     //freopen("input.txt","r",stdin);
64 | 	//freopen("output.txt","w",stdout);
65 |     int t;
66 |     scanf("%d",&t);
67 |     while(t--)
68 |     {
69 |         int m,n;
70 |         scanf("%d%d",&m,&n);
71 |         char ch=getchar();
72 |         for(int i=0;i<m;i++)
73 |         {
74 |            scanf("%s",M[i]);
75 |         }
76 |         printf("%d\n",countislands(m,n));
77 |     }
78 |     return 0;
79 | }
80 | 


--------------------------------------------------------------------------------
/SPOJ LKS.cpp:
--------------------------------------------------------------------------------
 1 | /* Created by Anmol Varshney */
 2 | 
 3 | #include <stdio.h>
 4 | #include <string.h>
 5 | #include <string>
 6 | #include <vector>
 7 | #include <list>
 8 | #include <map>
 9 | #include <set>
10 | #include <queue>
11 | #include <deque>
12 | #include <stack>
13 | #include <bitset>
14 | #include <algorithm>
15 | #include <functional>
16 | #include <numeric>
17 | #include <utility>
18 | #include <sstream>
19 | #include <iostream>
20 | #include <iomanip>
21 | #include <cstdio>
22 | #include <cmath>
23 | #include <cstdlib>
24 | #include <ctime>
25 | 
26 | using namespace std;
27 | 
28 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
29 | #define INT_MIN -2147483647
30 | #define INT_MAX 2147483647
31 | #define INF_LL 9223372036854775807LL
32 | #define PI acos(-1.0)
33 | #define llu long long unsigned
34 | #define ll long long int
35 | #define ld long int
36 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
37 | #define REP(p,a,b) for(int p=a;p<b;p++)
38 | #define REPR(p,a,b) for(int p=a;p>=b;p--)
39 | #define mod 1000000007
40 | #define getchar_unlocked getchar
41 | #define pb(f) push_back(f)
42 | #define pob(f) pop_back(f)
43 | #define pf(f) push_front(f)
44 | #define pof(f) pop_front(f)
45 | #define mkp(a,b) make_pair(a,b)
46 | #define fst first
47 | #define snd second
48 | #define pii pair<int,int>
49 | #define ins(a) insert(a)
50 | #define FAST_LOG2(x) (sizeof(unsigned long)*8 - 1 - __builtin_clzl((unsigned long)(x)))
51 | #define IOS ios_base::sync_with_stdio(false)
52 | #define citi cin.tie(NULL);
53 | #define FREI(var) freopen(var,"r",stdin)
54 | #define FREO(var) freopen(var,"w",stdout)
55 | #define endl "\n"
56 | 
57 | int val[500],w[500],dp[2][2000000];
58 | 
59 | int main()
60 | {
61 |     int W,n;
62 |     scanf("%d %d",&W,&n);
63 | 
64 |     for(int i=0;i<n;i++)
65 |         scanf("%d %d",&val[i],&w[i]);
66 | 
67 |     dp[0][0]=dp[1][0]=0;
68 | 
69 |     for(int i=1;i<=n;i++)
70 |     {
71 |         for(int j=1;j<=W;j++)
72 |         {
73 |             if(w[i-1]<=j)
74 |                 dp[(i&1)][j]=max(dp[!(i&1)][j],val[i-1]+dp[!(i&1)][j-w[i-1]]);
75 |             else
76 |                 dp[(i&1)][j]=dp[!(i&1)][j];
77 |         }
78 |     }
79 |     printf("%d\n",dp[n&1][W]);
80 | 
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/SPOJ EZDIJKST.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | #include<cstdio>
  3 | #include<algorithm>
  4 | using namespace std;
  5 |  
  6 | typedef long long int LL;
  7 |  
  8 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
  9 | #define REP(p,a,b) for(int p=a;p<=b;p++)
 10 | #define mod 1000000007
 11 | 
 12 | struct node
 13 | {
 14 | 	int pre,dist;
 15 | }node[100001];
 16 | 
 17 | struct cmp
 18 | {
 19 | 	bool operator()(const pair<int,int> &lhs,const pair<int,int> &rhs)
 20 | 	{
 21 | 		return lhs.second>rhs.second;
 22 | 	}
 23 | };
 24 | priority_queue<pair<int,int>,vector< pair<int,int> >,cmp> q;
 25 | vector<int> adj[100001];
 26 | vector<int> w[100001];
 27 | 
 28 | void relax(int s)
 29 | {
 30 | 	for(int i=0;i<adj[s].size();i++)
 31 | 	{
 32 | 		if(node[adj[s][i]].dist>(node[s].dist+w[s][i]))
 33 | 		{
 34 | 			node[adj[s][i]].dist=(node[s].dist+w[s][i]);
 35 | 			node[adj[s][i]].pre=s;
 36 | 			q.push(make_pair(adj[s][i],node[adj[s][i]].dist));
 37 | 		}
 38 | 	}
 39 | }
 40 | 
 41 | void intialize(int s,int v)
 42 | {
 43 | 	for(int i=1;i<=v;i++)
 44 | 	{
 45 | 		node[i].pre=-1;
 46 | 		node[i].dist=INT_MAX;
 47 | 	}
 48 | 	node[s].dist=0;
 49 | }
 50 | 
 51 | void dijsktra(int s,int v)
 52 | {
 53 | 	
 54 | 	intialize(s,v);
 55 | 	/*for(int i=1;i<=v;i++)
 56 | 	{
 57 | 		q.push(make_pair(i,node[i].dist));
 58 | 	}*/
 59 | 	q.push(make_pair(s,0));
 60 | 	while(!q.empty())
 61 | 	{
 62 | 		int one=q.top().first;
 63 | 		int two=q.top().second;
 64 | 		q.pop();
 65 | 		relax(one);
 66 | 	}
 67 | }
 68 | 
 69 | int main() {
 70 | 	ios_base::sync_with_stdio(false);
 71 | 	cin.tie(NULL);
 72 | 	int v,e,t,a,b,weight;
 73 | 	cin>>t;
 74 | 	while(t--)
 75 | 	{
 76 | 		cin>>v>>e;
 77 | 		for(int i=0;i<=v;i++)
 78 | 		{
 79 | 			adj[i].clear();
 80 | 			w[i].clear();
 81 | 		}
 82 | 		for(int i=0;i<e;i++)
 83 | 		{
 84 | 			cin>>a>>b>>weight;
 85 | 			adj[a].push_back(b);
 86 | 			w[a].push_back(weight);
 87 | 		}
 88 | 		/*for(int i=1;i<=v;i++)
 89 | 		{
 90 | 			cout<<i<<" ";
 91 | 			for(int j=0;j<adj[i].size();j++)
 92 | 			{
 93 | 				cout<<adj[i][j]<<" "<<w[i][j]<<endl;
 94 | 			}
 95 | 			cout<<endl;
 96 | 		}*/
 97 | 		int s,d;
 98 | 		cin>>s>>d;
 99 | 		dijsktra(s,v);
100 | 		if(node[d].dist!=INT_MAX)
101 | 		cout<<node[d].dist<<endl;
102 | 		else 
103 | 		cout<<"NO"<<endl;
104 | 	}
105 | 	return 0;
106 | }


--------------------------------------------------------------------------------
/SPOJ BRCKTS.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | int const MAXN = 30009;
  4 | char s[MAXN];
  5 | int min( int a, int b)
  6 |  {
  7 |  	if(a<b)
  8 |  	return a;
  9 |  	else
 10 |  	return b;
 11 |  }
 12 | struct node
 13 | {
 14 | 	int uopen;
 15 | 	int uclose;
 16 | 	void assignleaf(char ch)
 17 | 	{
 18 | 		if(ch=='(')
 19 | 		{
 20 | 			uopen=1;
 21 | 			uclose=0;
 22 | 		}
 23 | 		else
 24 | 		{
 25 | 			uopen=0;
 26 | 			uclose=1;
 27 | 		}
 28 | 	}
 29 | 	
 30 | 	void merge(node& left,node& right)
 31 | 	{
 32 | 		int match=min(left.uopen,right.uclose);
 33 | 		uopen=left.uopen+right.uopen-match;
 34 | 		uclose=left.uclose+right.uclose-match;
 35 | 	}
 36 | 	
 37 | 	bool getvalue()
 38 | 	{
 39 | 		if(uopen==0&&uclose==0)
 40 | 		return true;
 41 | 		else return false;
 42 | 	}
 43 | };
 44 | node Node[4*MAXN];
 45 | class stree
 46 | {
 47 | 	public:
 48 | 	int N;
 49 | 	stree(int n)
 50 | 	{
 51 | 		N=n;
 52 | 		build_tree(0,n-1,1);
 53 | 	}
 54 | 	void build_tree(int begin,int end,int index)
 55 | 	{
 56 | 		if(begin==end)
 57 | 		{
 58 | 			Node[index].assignleaf(s[begin]);
 59 | 			return;
 60 | 		}
 61 | 		int mid=(begin+end)/2;
 62 | 		build_tree(begin,mid,2*index);
 63 | 		build_tree(mid+1,end,2*index+1);
 64 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 65 | 	}
 66 | 	
 67 | 	void update(int i)
 68 | 	{
 69 | 		update_tree(1,0,N-1,i);
 70 | 	}
 71 | 	void update_tree(int index,int left,int right,int i)
 72 | 	{
 73 | 		if(left==i&&right==i)
 74 | 		{
 75 | 			if(s[i]=='(')
 76 | 			{
 77 | 				s[i]=')';
 78 | 			    Node[index].assignleaf(')');
 79 | 			}
 80 | 			else 
 81 | 			{
 82 | 				s[i]='(';
 83 | 				Node[index].assignleaf('(');
 84 | 			}
 85 | 			return;
 86 | 		}
 87 | 		int mid=(left+right)/2;
 88 | 		if(i>mid)
 89 | 		{
 90 | 			update_tree(2*index+1,mid+1,right,i);
 91 | 		}
 92 | 		else if(i<=mid)
 93 | 		{
 94 | 			update_tree(2*index,left,mid,i);
 95 | 		}
 96 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 97 | 	}
 98 | 	bool getValue() 
 99 | 	{
100 | 		return Node[1].getvalue();
101 | 	}
102 | };
103 | 
104 | int main() {
105 | 	char ch;
106 | 	int i,n,m,t,ele;
107 | 	t=1;
108 | 	while(scanf("%d",&n)==1&&n>0)
109 | 	{
110 | 		ch=getchar();
111 | 		scanf("%s",s);
112 | 		stree st(n);
113 | 		printf("Test %d:\n",t++);
114 | 		scanf("%d",&m);
115 | 		for(i=0;i<m;i++)
116 | 		{
117 | 			scanf("%d",&ele);
118 | 			if(ele==0)
119 | 			{
120 | 				if(st.getValue())printf("YES\n");
121 | 				else printf("NO\n");
122 | 			}
123 | 			else
124 | 			{
125 | 				ele--;
126 | 				st.update(ele);
127 | 			}
128 | 		}
129 | 	}
130 | 	return 0;
131 | }


--------------------------------------------------------------------------------
/SPOJ D-query (Using MO's Algorithm).cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | #include<stdio.h>
  3 | #include<string.h>
  4 | #include <vector>
  5 | #include <list>
  6 | #include <map>
  7 | #include <set>
  8 | #include <queue>
  9 | #include <deque>
 10 | #include <stack>
 11 | #include <bitset>
 12 | #include <algorithm>
 13 | #include <functional>
 14 | #include <numeric>
 15 | #include <utility>
 16 | #include <sstream>
 17 | #include <iostream>
 18 | #include <iomanip>
 19 | #include <cstdio>
 20 | #include <cmath>
 21 | #include <cstdlib>
 22 | #include <ctime>
 23 | 
 24 | using namespace std;
 25 | 
 26 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 27 | #define INT_MIN -2147483647
 28 | #define INT_MAX 2147483647
 29 | #define INF 2000000000
 30 | #define INF_LL 9223372036854775807LL
 31 | #define PI acos(-1.0)
 32 | #define llu long long unsigned
 33 | #define ll long long int
 34 | #define ld long int
 35 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 36 | #define REP(p,a,b) for(int p=a;p<b;p++)
 37 | #define mod 1000000007
 38 | #define getchar_unlocked getchar
 39 | #define pb(f) push_back(f)
 40 | #define pob(f) pop_back(f)
 41 | #define pf(f) push_front(f)
 42 | #define pof(f) pop_front(f)
 43 | #define mkp(a,b) make_pair(a,b)
 44 | #define fst first
 45 | #define snd second
 46 | #define pii pair<int,int>
 47 | #define ins(a) insert(a)
 48 | #define N 30010
 49 | #define A 1000010
 50 | #define BLOCK 174
 51 | #define M 200010
 52 | 
 53 | int answer;
 54 | struct query
 55 | {
 56 |     int l,r,ind;
 57 | }Q[M];
 58 | int ans[M];
 59 | int a[N];
 60 | int cnt[A];
 61 | 
 62 | void add(int index)
 63 | {
 64 |     cnt[a[index]]++;
 65 |     if(cnt[a[index]]==1) answer++;
 66 | }
 67 | 
 68 | void remove(int index)
 69 | {
 70 |     cnt[a[index]]--;
 71 |     if(cnt[a[index]]==0) answer--;
 72 | }
 73 | 
 74 | bool cmp(query f,query s)
 75 | {
 76 |     if((f.l/BLOCK)!=(s.l/BLOCK))
 77 |         return (f.l/BLOCK)<(s.l/BLOCK);
 78 |     else
 79 |         return f.r<s.r;
 80 | }
 81 | 
 82 | int main() {
 83 |     ios_base::sync_with_stdio(false);
 84 |     int n,q;
 85 |     scanf("%d",&n);
 86 |     REP(i,0,n)
 87 |     {
 88 |         scanf("%d",&a[i]);
 89 |     }
 90 |     scanf("%d",&q);
 91 |     REP(i,0,q)
 92 |     {
 93 |         scanf("%d%d",&Q[i].l,&Q[i].r);
 94 |         Q[i].ind=i;
 95 |         Q[i].l--;
 96 |         Q[i].r--;
 97 |     }
 98 |     sort(Q,Q+q,cmp);
 99 |     int cl=0,cr=0;
100 |     REP(i,0,q)
101 |     {
102 |         int left=Q[i].l,right=Q[i].r;
103 |         while(cl<left)
104 |             remove(cl),cl++;
105 |         while(cl>left)
106 |             add(cl-1),cl--;
107 |         while(cr<=right)
108 |             add(cr),cr++;
109 |         while(cr>(right+1))
110 |             remove(cr-1),cr--;
111 |         ans[Q[i].ind]=answer;
112 |     }
113 |     REP(i,0,q)
114 |         printf("%d\n",ans[i]);
115 |     return 0;
116 | }
117 | 


--------------------------------------------------------------------------------
/SPOJ ABCPATH.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | #include <stdio.h>
  4 | #include <string.h>
  5 | #include <vector>
  6 | #include <list>
  7 | #include <map>
  8 | #include <set>
  9 | #include <queue>
 10 | #include <deque>
 11 | #include <stack>
 12 | #include <bitset>
 13 | #include <algorithm>
 14 | #include <functional>
 15 | #include <numeric>
 16 | #include <utility>
 17 | #include <sstream>
 18 | #include <iostream>
 19 | #include <iomanip>
 20 | #include <cstdio>
 21 | #include <cmath>
 22 | #include <cstdlib>
 23 | #include <ctime>
 24 | 
 25 | using namespace std;
 26 | 
 27 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 28 | #define INT_MIN -2147483647
 29 | #define INT_MAX 2147483647
 30 | #define INF 2000000000
 31 | #define INF_LL 9223372036854775807LL
 32 | #define PI acos(-1.0)
 33 | #define llu long long unsigned
 34 | #define ll long long int
 35 | #define ld long int
 36 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 37 | #define REP(p,a,b) for(int p=a;p<b;p++)
 38 | #define mod 1000000007
 39 | #define getchar_unlocked getchar
 40 | #define pb(f) push_back(f)
 41 | #define pob(f) pop_back(f)
 42 | #define pf(f) push_front(f)
 43 | #define pof(f) pop_front(f)
 44 | #define mkp(a,b) make_pair(a,b)
 45 | #define fst first
 46 | #define snd second
 47 | #define pii pair<int,int>
 48 | #define ins(a) insert(a)
 49 | 
 50 | int gcd(int a,int b)
 51 | {
 52 |     if(b>a) return gcd(b,a);
 53 |     else if(b!=0) return (b,a%b);
 54 |     else return a;
 55 | }
 56 | 
 57 | char a[51][51];
 58 | 
 59 | static int x[]={0,1,1,1,0,-1,-1,-1};
 60 | static int y[]={1,1,0,-1,-1,-1,0,1};
 61 | 
 62 | int exist[51][51];
 63 | int ans[51][51];
 64 | map< pii ,int> vis;
 65 | 
 66 | int dfs(int i,int j,int r, int c)
 67 | {
 68 |     vis[mkp(i,j)]++;
 69 |     if(exist[i][j]!=-1) return ans[i][j];
 70 |     int temp=0;
 71 |     for(int l=0;l<8;l++)
 72 |     {
 73 |         if(i+x[l]>=0 && j+y[l]>=0 && i+x[l]<r && j+y[l]<c)
 74 |         {
 75 |             if(((char)(a[i][j]+1)==a[i+x[l]][j+y[l]])&&(vis[mkp(i+x[l],j+y[l])]<8))
 76 |             {
 77 |                 temp=max(temp,dfs(i+x[l],j+y[l],r,c));
 78 |             }
 79 |         }
 80 |     }
 81 |     exist[i][j]=1;
 82 |     ans[i][j]=temp+1;
 83 |     return temp+1;
 84 | }
 85 | 
 86 | int main() {
 87 |     //freopen("input 1.in","r",stdin);
 88 |     //freopen("output.txt","w",stdout);
 89 |     ios_base::sync_with_stdio(false);
 90 |     cin.tie(NULL);
 91 |     int r,c,t=0,ans;
 92 |     while(1)
 93 |     {
 94 |         cin>>r>>c;
 95 |         if(r==0&&c==0) break;
 96 |         t++;
 97 |         memset(exist,-1,sizeof(exist[0][0])*51*51);
 98 |         vis.clear();
 99 |         REP(i,0,r)
100 |             cin>>a[i];
101 |         ans=0;
102 |         REP(i,0,r)
103 |             REP(j,0,c)
104 |                 if(a[i][j]=='A')
105 |                     ans=max(ans,dfs(i,j,r,c));
106 |         cout<<"Case "<<t<<": "<<ans<<endl;
107 |     }
108 |     return 0;
109 | }
110 | 


--------------------------------------------------------------------------------
/SPOJ KGSS.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | struct node
  4 | {
  5 | 	long long int m;
  6 | 	long long int msum;
  7 | 	
  8 | 	void assignleaf(long long int x)
  9 | 	{
 10 | 		msum=m=x;
 11 | 	}
 12 | 	
 13 | 	void merge(node& left,node& right)
 14 | 	{
 15 | 		m=max(left.m,right.m);
 16 | 		msum=max(left.msum,max(right.msum,left.m+right.m));
 17 | 	}
 18 | 	
 19 | 	long long int getvalue()
 20 | 	{
 21 | 		return(msum);
 22 | 	}
 23 | };
 24 | 
 25 | class stree
 26 | {
 27 | 	public:
 28 | 	int N;
 29 | 	node* Node;
 30 | 	stree(long long int a[],int n)
 31 | 	{
 32 | 		N=n;
 33 | 		Node=new node[getSegmentTreeSize(n)];
 34 | 		build_tree(a,0,n-1,1);
 35 | 	}
 36 | 	~stree()
 37 | 	{
 38 | 		delete[] Node;
 39 | 	}
 40 | 	void build_tree(long long int a[],int begin,int end,int index)
 41 | 	{
 42 | 		if(begin==end)
 43 | 		{
 44 | 			Node[index].assignleaf(a[begin]);
 45 | 			return;
 46 | 		}
 47 | 		int mid=(begin+end)/2;
 48 | 		build_tree(a,begin,mid,2*index);
 49 | 		build_tree(a,mid+1,end,2*index+1);
 50 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 51 | 	}
 52 | 	
 53 | 	node query(int index,int begin,int end,int left,int right)
 54 | 	{
 55 | 		if(begin>end||begin>right||end<left)
 56 | 		return ((node){0,0});
 57 | 		if(begin>=left&&end<=right)
 58 | 		{
 59 | 			return Node[index];
 60 | 		}
 61 | 		int mid=(begin+end)/2;
 62 | 		node leftchild=query(2*index,begin,mid,left,right);
 63 | 		node rightchild=query(2*index+1,mid+1,end,left,right);
 64 | 		node result;
 65 | 		result.merge(leftchild,rightchild);
 66 | 		return result;
 67 | 	}
 68 | 	void update(long long i,long long int j)
 69 | 	{
 70 | 		update_tree(1,0,N-1,i,j);
 71 | 	}
 72 | 	void update_tree(int index,int left,int right,long long int i,long long int value)
 73 | 	{
 74 | 		if(left==i&&right==i)
 75 | 		{
 76 | 			Node[index].m=value;
 77 | 			Node[index].msum=value;
 78 | 			return;
 79 | 		}
 80 | 		int mid=(left+right)/2;
 81 | 		if(i>mid)
 82 | 		update_tree(2*index+1,mid+1,right,i,value);
 83 | 		if(i<=mid)
 84 | 		update_tree(2*index,left,mid,i,value);
 85 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 86 | 	}
 87 | 	long int getSegmentTreeSize(int N) 
 88 | 	{
 89 | 		long x=(long)(ceil(log2(N)));
 90 | 		long max_size=2*(long)pow(2,x)-1;
 91 | 		return max_size;
 92 | 	}
 93 | 	long long int getValue(int lo, int hi) 
 94 | 	{
 95 | 		node result = query(1, 0, N-1, lo, hi);
 96 | 		return result.getvalue();
 97 | 	}
 98 | };
 99 | 
100 | int main() {
101 | 	ios_base::sync_with_stdio(false);
102 | 	cin.tie(NULL);
103 | 	int n,q,x,y;
104 | 	long long int x1,y1;
105 | 	char ch;
106 | 	cin>>n;
107 | 	long long int a[n];
108 | 	for(int i=0;i<n;i++)
109 | 	cin>>a[i];
110 | 	stree st(a,n);
111 | 	cin>>q;
112 | 	for(int i=0;i<q;i++)
113 | 	{
114 | 		cin>>ch;
115 | 		if(ch=='Q')
116 | 		{
117 | 			cin>>x>>y;
118 | 			cout<<st.getValue(x-1,y-1)<<endl;
119 | 		}
120 | 		else
121 | 		{
122 | 			cin>>x1>>y1;
123 | 			st.update(x1-1,y1);
124 | 		}
125 | 	}
126 | 	return 0;
127 | }


--------------------------------------------------------------------------------
/SPOJ ABSP1.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | /*INCLUDE_HEADERS*/
  4 | #include<stdio.h>
  5 | #include<string.h>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | /*END HEADERS*/
 26 | using namespace std;
 27 | /*START_MACROS*/
 28 | #define llu long long unsigned
 29 | #define lld long long int
 30 | #define ld long int
 31 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 32 | #define REP(p,a,b) for(int p=a;p<b;p++)
 33 | #define mod 1000000007
 34 | #define getchar_unlocked getchar
 35 | #define pi(c) printf("%d\n",c)
 36 | #define pwa(a,b) printf(#a,b)
 37 | #define pll(c) printf("%lld\n",c)
 38 | #define pc(c) printf("%c\n",c)
 39 | #define pf(c) printf("%f\n",c)
 40 | #define ps(x) printf("%s\n",&x)
 41 | #define pd(x) printf("%lf\n",x)
 42 | #define w(j) for(int f=0;f<j;f++)
 43 | #define si(f) scanf("%d",&f)
 44 | #define sc(f) scanf("%c",&f)
 45 | #define sll(f) scanf("%lld",&f)
 46 | #define ss(f) scanf("%s",f)
 47 | #define sf(f) scanf("%f",&f)
 48 | #define two(d) (1<<d)
 49 | #define twoL(X) (((lld)(1))<<(X))
 50 | #define ip(a,b) ((int)pow(a,b))
 51 | #define ic(a) (a-'0')
 52 | #define contain(S,X) (((S)&two(X))!=0)
 53 | #define containL(S,X) (((S)&twoL(X))!=0)
 54 | #define sof(da_type) sizeof(da_type)
 55 | /*STL DEFINITIONS*/
 56 | #define pub(f) push_back(f)
 57 | #define pob(f) pop_back(f)
 58 | #define puf(f) push_front(f)
 59 | #define pof(f) pop_front(f)
 60 | #define iv vector<int>
 61 | #define il list<int>
 62 | #define v(arg) vector<arg>
 63 | #define l(arg) list<arg>
 64 | #define ivit vector<int>::iterator
 65 | #define ilit list<int>::iterator
 66 | #define vit(arg) vector<arg>::iterator
 67 | #define lit(arg) list<arg>::iterator
 68 | #define cl() clear()
 69 | #define sz() size()
 70 | #define fd() find()
 71 | #define ft() front()
 72 | #define bk() back()
 73 | #define beg() begin()
 74 | #define ed() end()
 75 | #define asn(asrgument1,asrgument2) assign(asrgument1,asrgument2)
 76 | #define rz(size_argument) resize(size_argument)
 77 | #define mkp(a,b) make_pair(a,b)
 78 | #define fst first
 79 | #define snd second
 80 | /*END STL MACROS*/
 81 | /*END MACROS*/
 82 | lld a[10001];
 83 | int main() {
 84 | 	//freopen("input.txt","r",stdin);
 85 | 	//freopen("output.txt","w",stdout);
 86 | 	int t, n;
 87 |     scanf("%d",&t);
 88 |     while(t--)
 89 |     {
 90 |         scanf("%d",&n);
 91 |         for(int i=0;i<n;i++)
 92 |         {
 93 |            scanf("%lld",&a[i]);
 94 |         }
 95 |         lld sum = 0;
 96 |         for(int i=0;i<n;i++)
 97 |         {
 98 |            sum = sum + i*a[i] - a[i]*(n-i-1);
 99 |         }
100 |        printf("%lld\n",sum);
101 |     }
102 | 	return 0;
103 | }
104 | 


--------------------------------------------------------------------------------
/SPOJ ORDERSET(Using C++14 Features).cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | /* Commented Codes are for use in C++14 and in place of auto use typeof() */
  4 | #include<stdio.h>
  5 | #include<string.h>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | #include <ext/pb_ds/assoc_container.hpp>
 26 | #include <ext/pb_ds/detail/standard_policies.hpp>
 27 | #include <ext/pb_ds/trie_policy.hpp>
 28 | 
 29 | using namespace std;
 30 | using namespace __gnu_pbds;
 31 | 
 32 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 33 | #define INT_MIN -2147483647
 34 | #define INT_MAX 2147483647
 35 | #define INF 2000000000
 36 | #define INF_LL 9223372036854775807LL
 37 | #define PI acos(-1.0)
 38 | #define llu long long unsigned
 39 | #define ll long long int
 40 | #define ld long int
 41 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 42 | #define REP(p,a,b) for(int p=a;p<b;p++)
 43 | #define mod 1000000007
 44 | #define getchar_unlocked getchar
 45 | #define pb(f) push_back(f)
 46 | #define pob(f) pop_back(f)
 47 | #define pf(f) push_front(f)
 48 | #define pof(f) pop_front(f)
 49 | #define mkp(a,b) make_pair(a,b)
 50 | #define fst first
 51 | #define snd second
 52 | #define pii pair<int,int>
 53 | #define ins(a) insert(a)
 54 | #define ok(a) order_of_key(a)
 55 | #define fbo(a) find_by_order(a)
 56 | #define pr(a) prefix_range(a) //Returns iterators to beginning and ending of vector of prefixes matched
 57 | 
 58 | typedef tree<
 59 | int,
 60 | null_type,
 61 | less<int>, // Comparator function
 62 | rb_tree_tag,
 63 | tree_order_statistics_node_update>
 64 | ordered_set;
 65 | 
 66 | ordered_set X;
 67 | 
 68 | typedef trie<
 69 | string,
 70 | null_type,
 71 | trie_string_access_traits<>,
 72 | pat_trie_tag,
 73 | trie_prefix_search_node_update>
 74 | pref_trie;
 75 | 
 76 | pref_trie base;
 77 | 
 78 | int main() {
 79 |     //freopen("input.txt","r",stdin);
 80 | 	//freopen("output.txt","w",stdout);
 81 | 	ios_base::sync_with_stdio(false);
 82 | 	cin.tie(NULL);
 83 |     int q,ele;
 84 |     scanf("%d",&q);
 85 |     while(q--)
 86 |     {
 87 |         char temp=getchar();
 88 |         char ch=getchar();
 89 |         char enter=getchar();
 90 |         scanf("%d",&ele);
 91 |         switch(ch)
 92 |         {
 93 |             case 'I':X.ins(ele);
 94 |             break;
 95 |             case 'D':X.erase(ele);
 96 |             break;
 97 |             case 'K':
 98 |             if(ele>X.size())
 99 |                 printf("invalid\n");
100 |             else
101 |                 printf("%d\n",*X.fbo(ele-1));
102 |             break;
103 |             case 'C':printf("%d\n",X.ok(ele));
104 |             break;
105 |         }
106 |     }
107 | 	return 0;
108 | }
109 | 


--------------------------------------------------------------------------------
/SPOJ KGSS (Query Differently).cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | struct node
  4 | {
  5 | 	long long int m;
  6 | 	long long int msum;
  7 | 	
  8 | 	void assignleaf(long long int x)
  9 | 	{
 10 | 		msum=m=x;
 11 | 	}
 12 | 	
 13 | 	void merge(node& left,node& right)
 14 | 	{
 15 | 		m=max(left.m,right.m);
 16 | 		msum=max(left.msum,max(right.msum,left.m+right.m));
 17 | 	}
 18 | 	
 19 | 	long long int getvalue()
 20 | 	{
 21 | 		return(msum);
 22 | 	}
 23 | };
 24 | 
 25 | class stree
 26 | {
 27 | 	public:
 28 | 	int N;
 29 | 	node* Node;
 30 | 	stree(long long int a[],int n)
 31 | 	{
 32 | 		N=n;
 33 | 		Node=new node[getSegmentTreeSize(n)];
 34 | 		build_tree(a,0,n-1,1);
 35 | 	}
 36 | 	~stree()
 37 | 	{
 38 | 		delete[] Node;
 39 | 	}
 40 | 	void build_tree(long long int a[],int begin,int end,int index)
 41 | 	{
 42 | 		if(begin==end)
 43 | 		{
 44 | 			Node[index].assignleaf(a[begin]);
 45 | 			return;
 46 | 		}
 47 | 		int mid=(begin+end)/2;
 48 | 		build_tree(a,begin,mid,2*index);
 49 | 		build_tree(a,mid+1,end,2*index+1);
 50 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 51 | 	}
 52 | 	
 53 | 	node query(int index,int begin,int end,int left,int right)
 54 | 	{
 55 | 		//if(begin>end||begin>right||end<left)
 56 | 		//return ((node){0,0});
 57 | 		int mid=(begin+end)/2;
 58 | 		if(begin>=left&&end<=right)
 59 | 		{
 60 | 			return Node[index];
 61 | 		}
 62 | 		if(left>mid)
 63 | 		{
 64 | 			return query(2*index+1,mid+1,end,left,right);
 65 | 		}
 66 | 		if(right<=mid)
 67 | 		{
 68 | 			return query(2*index,begin,mid,left,right);
 69 | 		}
 70 | 		node leftchild=query(2*index,begin,mid,left,mid);
 71 | 		node rightchild=query(2*index+1,mid+1,end,mid+1,right);
 72 | 		node result;
 73 | 		result.merge(leftchild,rightchild);
 74 | 		return result;
 75 | 	}
 76 | 	void update(long long i,long long int j)
 77 | 	{
 78 | 		update_tree(1,0,N-1,i,j);
 79 | 	}
 80 | 	void update_tree(int index,int left,int right,long long int i,long long int value)
 81 | 	{
 82 | 		if(left==i&&right==i)
 83 | 		{
 84 | 			Node[index].m=value;
 85 | 			Node[index].msum=value;
 86 | 			return;
 87 | 		}
 88 | 		int mid=(left+right)/2;
 89 | 		if(i>mid)
 90 | 		update_tree(2*index+1,mid+1,right,i,value);
 91 | 		if(i<=mid)
 92 | 		update_tree(2*index,left,mid,i,value);
 93 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 94 | 	}
 95 | 	long int getSegmentTreeSize(int N) 
 96 | 	{
 97 | 		long x=(long)(ceil(log2(N)));
 98 | 		long max_size=2*(long)pow(2,x)-1;
 99 | 		return max_size;
100 | 	}
101 | 	long long int getValue(int lo, int hi) 
102 | 	{
103 | 		node result = query(1, 0, N-1, lo, hi);
104 | 		return result.getvalue();
105 | 	}
106 | };
107 | 
108 | int main() {
109 | 	ios_base::sync_with_stdio(false);
110 | 	cin.tie(NULL);
111 | 	int n,q,x,y;
112 | 	long long int x1,y1;
113 | 	char ch;
114 | 	cin>>n;
115 | 	long long int a[n];
116 | 	for(int i=0;i<n;i++)
117 | 	cin>>a[i];
118 | 	stree st(a,n);
119 | 	cin>>q;
120 | 	for(int i=0;i<q;i++)
121 | 	{
122 | 		cin>>ch;
123 | 		if(ch=='Q')
124 | 		{
125 | 			cin>>x>>y;
126 | 			cout<<st.getValue(x-1,y-1)<<endl;
127 | 		}
128 | 		else
129 | 		{
130 | 			cin>>x1>>y1;
131 | 			st.update(x1-1,y1);
132 | 		}
133 | 	}
134 | 	return 0;
135 | }


--------------------------------------------------------------------------------
/SPOJ GONE.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | #include <stdio.h>
  4 | #include <string.h>
  5 | #include <string>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | 
 26 | using namespace std;
 27 | 
 28 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 29 | #define INF_LL 9223372036854775807LL
 30 | #define PI acos(-1.0)
 31 | #define llu long long unsigned
 32 | #define ll long long int
 33 | #define ld long int
 34 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 35 | #define REP(p,a,b) for(int p=a;p<b;p++)
 36 | #define mod 1000000007
 37 | #define getchar_unlocked getchar
 38 | #define pb(f) push_back(f)
 39 | #define pob(f) pop_back(f)
 40 | #define pf(f) push_front(f)
 41 | #define pof(f) pop_front(f)
 42 | #define mkp(a,b) make_pair(a,b)
 43 | #define fst first
 44 | #define snd second
 45 | #define pii pair<int,int>
 46 | #define ins(a) insert(a)
 47 | 
 48 | ll gcd(ll a,ll b)
 49 | {
 50 |     if(b>a) return gcd(b,a);
 51 |     else if(b!=0) return gcd(b,a%b);
 52 |     else return a;
 53 | }
 54 | 
 55 | string to_string(ll num)
 56 | {
 57 |     stringstream ss;
 58 |     ss << num;
 59 |     return ss.str();
 60 | }
 61 | 
 62 | set<int> s;
 63 | int mark[101];
 64 | 
 65 | void foo()
 66 | {
 67 |     for(int i=2;i*i<=100;i++)
 68 |     {
 69 |         if(mark[i]==0)
 70 |         {
 71 |             for(int j=i*2;j<=100;j+=i)
 72 |                 mark[j]=1;
 73 |         }
 74 |     }
 75 |     for(int i=2;i<=100;i++)
 76 |         if(mark[i]==0)
 77 |             s.ins(i);
 78 | }
 79 | 
 80 | ll dp[10][2][70];
 81 | int n;
 82 | string y;
 83 | 
 84 | ll f(int pos,bool smaller_or_not,int sum)
 85 | {
 86 |     if(pos==n)
 87 |         return (s.find(sum)!=s.end());
 88 | 
 89 |     if(dp[pos][smaller_or_not][sum]>=0)
 90 |         return dp[pos][smaller_or_not][sum];
 91 | 
 92 |     ll res=0;
 93 | 
 94 |     REP(i,0,10)
 95 |     {
 96 |         if(smaller_or_not||(i<=(int)(y[pos]-'0')))
 97 |         {
 98 |             res+=f(pos+1,(smaller_or_not||(i<(int)(y[pos]-'0'))),sum+i);
 99 |         }
100 |     }
101 |     dp[pos][smaller_or_not][sum]=res;
102 |     return res;
103 | }
104 | 
105 | int main() {
106 |     //freopen("input.txt","r",stdin);
107 |     //freopen("output.txt","w",stdout);
108 |     ios_base::sync_with_stdio(false);
109 |     cin.tie(NULL);
110 |     int t,a,b;
111 |     ll ans;
112 |     cin>>t;
113 |     foo();
114 |     while(t--)
115 |     {
116 |         ans=0;
117 |         cin>>a>>b;
118 |         a--;
119 |         y=to_string(b);
120 |         n=y.size();
121 |         memset(dp,-1,sizeof dp);
122 |         ans=f(0,false,0);
123 |         y=to_string(a);
124 |         n=y.size();
125 |         memset(dp,-1,sizeof dp);
126 |         ans-=f(0,false,0);
127 |         cout<<ans<<endl;
128 |     }
129 |     return 0;
130 | }
131 | 


--------------------------------------------------------------------------------
/SPOJ KGSS - Simple Solution.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | struct node
  4 | {
  5 | 	long long int m;
  6 | 	long long int msum;
  7 | 	
  8 | 	void assignleaf(long long int x)
  9 | 	{
 10 | 		m=x;
 11 | 		msum=0;
 12 | 	}
 13 | 	
 14 | 	void merge(node& left,node& right)
 15 | 	{
 16 | 		if(left.m>right.m)
 17 | 		{
 18 | 			m=left.m;
 19 | 		}
 20 | 		else
 21 | 		{
 22 | 			m=right.m;
 23 | 		}
 24 | 	
 25 | 		if(m==right.m)
 26 | 		{
 27 | 			if(left.m>right.msum)
 28 | 			msum=left.m;
 29 | 			else
 30 | 			msum=right.msum;
 31 | 		}
 32 | 		else
 33 | 		{
 34 | 			if(right.m>left.msum)
 35 | 			msum=right.m;
 36 | 			else
 37 | 			msum=left.msum;
 38 | 		}
 39 | 	}
 40 | 		
 41 | 		long long int getvalue()
 42 | 		{
 43 | 			return(m+msum);
 44 | 		}
 45 | };
 46 | 
 47 | class stree
 48 | {
 49 | 	public:
 50 | 	int N;
 51 | 	node* Node;
 52 | 	stree(long long int a[],int n)
 53 | 	{
 54 | 		N=n;
 55 | 		Node=new node[getSegmentTreeSize(n)];
 56 | 		build_tree(a,0,n-1,1);
 57 | 	}
 58 | 	~stree()
 59 | 	{
 60 | 		delete[] Node;
 61 | 	}
 62 | 	void build_tree(long long int a[],int begin,int end,int index)
 63 | 	{
 64 | 		if(begin==end)
 65 | 		{
 66 | 			Node[index].assignleaf(a[begin]);
 67 | 			return;
 68 | 		}
 69 | 		int mid=(begin+end)/2;
 70 | 		build_tree(a,begin,mid,2*index);
 71 | 		build_tree(a,mid+1,end,2*index+1);
 72 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 73 | 	}
 74 | 	
 75 | 	node query(int index,int begin,int end,int left,int right)
 76 | 	{
 77 | 		if(begin>end||begin>right||end<left)
 78 | 		return ((node){0,0});
 79 | 		if(begin>=left&&end<=right)
 80 | 		{
 81 | 			return Node[index];
 82 | 		}
 83 | 		int mid=(begin+end)/2;
 84 | 		node leftchild=query(2*index,begin,mid,left,right);
 85 | 		node rightchild=query(2*index+1,mid+1,end,left,right);
 86 | 		node result;
 87 | 		result.merge(leftchild,rightchild);
 88 | 		return result;
 89 | 	}
 90 | 	void update(long long i,long long int j)
 91 | 	{
 92 | 		update_tree(1,0,N-1,i,j);
 93 | 	}
 94 | 	void update_tree(int index,int left,int right,long long int i,long long int value)
 95 | 	{
 96 | 		if(left==i&&right==i)
 97 | 		{
 98 | 			Node[index].m=value;
 99 | 			Node[index].msum=0;
100 | 			return;
101 | 		}
102 | 		int mid=(left+right)/2;
103 | 		if(i>mid)
104 | 		update_tree(2*index+1,mid+1,right,i,value);
105 | 		if(i<=mid)
106 | 		update_tree(2*index,left,mid,i,value);
107 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
108 | 	}
109 | 	long int getSegmentTreeSize(int N) 
110 | 	{
111 | 		long x=(long)(ceil(log2(N)));
112 | 		long max_size=2*(long)pow(2,x)-1;
113 | 		return max_size;
114 | 	}
115 | 	long long int getValue(int lo, int hi) 
116 | 	{
117 | 		node result = query(1, 0, N-1, lo, hi);
118 | 		return result.getvalue();
119 | 	}
120 | };
121 | 
122 | int main() {
123 | 	ios_base::sync_with_stdio(false);
124 | 	cin.tie(NULL);
125 | 	int n,q,x,y;
126 | 	long long int x1,y1;
127 | 	char ch;
128 | 	cin>>n;
129 | 	long long int a[n];
130 | 	for(int i=0;i<n;i++)
131 | 	cin>>a[i];
132 | 	stree st(a,n);
133 | 	cin>>q;
134 | 	for(int i=0;i<q;i++)
135 | 	{
136 | 		cin>>ch;
137 | 		if(ch=='Q')
138 | 		{
139 | 			cin>>x>>y;
140 | 			cout<<st.getValue(x-1,y-1)<<endl;
141 | 		}
142 | 		else
143 | 		{
144 | 			cin>>x1>>y1;
145 | 			st.update(x1-1,y1);
146 | 		}
147 | 	}
148 | 	return 0;
149 | }


--------------------------------------------------------------------------------
/SPOJ SHPATH (Dijsktra).cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | #include<stdio.h>
  4 | #include<string.h>
  5 | #include <vector>
  6 | #include <list>
  7 | #include <map>
  8 | #include <set>
  9 | #include <queue>
 10 | #include <deque>
 11 | #include <stack>
 12 | #include <bitset>
 13 | #include <algorithm>
 14 | #include <functional>
 15 | #include <numeric>
 16 | #include <utility>
 17 | #include <sstream>
 18 | #include <iostream>
 19 | #include <iomanip>
 20 | #include <cstdio>
 21 | #include <cmath>
 22 | #include <cstdlib>
 23 | #include <ctime>
 24 | 
 25 | using namespace std;
 26 | 
 27 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 28 | #define INT_MIN -2147483647
 29 | #define INT_MAX 2147483647
 30 | #define INF 2000000000
 31 | #define INF_LL 9223372036854775807LL
 32 | #define PI acos(-1.0)
 33 | #define llu long long unsigned
 34 | #define ll long long int
 35 | #define ld long int
 36 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 37 | #define REP(p,a,b) for(int p=a;p<b;p++)
 38 | #define mod 1000000007
 39 | #define getchar_unlocked getchar
 40 | #define pb(f) push_back(f)
 41 | #define pob(f) pop_back(f)
 42 | #define pf(f) push_front(f)
 43 | #define pof(f) pop_front(f)
 44 | #define mkp(a,b) make_pair(a,b)
 45 | #define fst first
 46 | #define snd second
 47 | #define pii pair<int,int>
 48 | 
 49 | 
 50 | #define maxV 100005
 51 | 
 52 | int dist[maxV];
 53 | vector<int> adj[maxV];
 54 | vector<int> w[maxV];
 55 | priority_queue< pii, vector< pii >, greater< pii > > p;
 56 | bool visited[maxV];
 57 | 
 58 | void initialize(int s,int v)
 59 | {
 60 |     memset(visited,false,sizeof(visited));
 61 |     REP(i,0,v)
 62 |         dist[i]=INT_MAX;
 63 |     dist[s]=0;
 64 | }
 65 | 
 66 | void relax(int s)
 67 | {
 68 |     REP(i,0,adj[s].size())
 69 |     {
 70 |         if(dist[adj[s][i]]>(dist[s]+w[s][i])&&!visited[adj[s][i]])
 71 |         {
 72 |             dist[adj[s][i]]=(dist[s]+w[s][i]);
 73 |             p.push(mkp(dist[adj[s][i]],adj[s][i]));
 74 |         }
 75 |     }
 76 | }
 77 | 
 78 | void dijsktra(int s)
 79 | {
 80 |     p.push(mkp(0,s));
 81 |     while(!p.empty())
 82 |     {
 83 |         int node=p.top().snd;
 84 |         p.pop();
 85 |         relax(node);
 86 |         visited[node]=true;
 87 |     }
 88 | }
 89 | 
 90 | int main() {
 91 | 	//freopen("input.txt","r",stdin);
 92 | 	//freopen("output.txt","w",stdout);
 93 | 	ios_base::sync_with_stdio(false);
 94 | 	cin.tie(NULL);
 95 | 	int t,n,k,a,b;
 96 | 	char s[20],s1[20],s2[20];
 97 | 	scanf("%d",&t);
 98 | 	while(t--)
 99 |     {
100 |         map<string,int> m;
101 |         scanf("%d",&n);
102 |         REP(i,0,n)
103 |         {
104 |             scanf("%s",s);
105 |             m.insert(mkp(s,i));
106 |             scanf("%d",&k);
107 |             REP(j,0,k)
108 |             {
109 |                 scanf("%d%d",&a,&b);
110 |                 adj[i].pb(a-1);
111 |                 w[i].pb(b);
112 |             }
113 |         }
114 |         scanf("%d",&k);
115 |         REP(i,0,k)
116 |         {
117 |             scanf("%s%s",s1,s2);
118 |             initialize(m[s1],n);
119 |             dijsktra(m[s1]);
120 |             cout<<dist[m[s2]]<<endl;
121 |         }
122 |         REP(i,0,maxV)
123 |         {
124 |             adj[i].clear();
125 |             w[i].clear();
126 |         }
127 |     }
128 | 	return 0;
129 | }
130 | 


--------------------------------------------------------------------------------
/SPOJ RAONE (Digit DP).cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | #include <stdio.h>
  4 | #include <string.h>
  5 | #include <string>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | 
 26 | using namespace std;
 27 | 
 28 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 29 | #define INF_LL 9223372036854775807LL
 30 | #define PI acos(-1.0)
 31 | #define llu long long unsigned
 32 | #define ll long long int
 33 | #define ld long int
 34 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 35 | #define REP(p,a,b) for(int p=a;p<b;p++)
 36 | #define mod 1000000007
 37 | #define getchar_unlocked getchar
 38 | #define pb(f) push_back(f)
 39 | #define pob(f) pop_back(f)
 40 | #define pf(f) push_front(f)
 41 | #define pof(f) pop_front(f)
 42 | #define mkp(a,b) make_pair(a,b)
 43 | #define fst first
 44 | #define snd second
 45 | #define pii pair<int,int>
 46 | #define ins(a) insert(a)
 47 | 
 48 | ll gcd(ll a,ll b)
 49 | {
 50 |     if(b>a) return gcd(b,a);
 51 |     else if(b!=0) return gcd(b,a%b);
 52 |     else return a;
 53 | }
 54 | 
 55 | string to_string(ll num)
 56 | {
 57 |     stringstream ss;
 58 |     ss << num;
 59 |     return ss.str();
 60 | }
 61 | 
 62 | ll dp[10][2][2][50][50];
 63 | int n;
 64 | string y;
 65 | 
 66 | ll f(int pos,bool smaller_or_not,bool nozero,int oddsum,int evensum)
 67 | {
 68 |     if(pos==n)
 69 |         return ((evensum-oddsum)==1);
 70 | 
 71 |     if(dp[pos][smaller_or_not][nozero][oddsum][evensum]>=0)
 72 |         return dp[pos][smaller_or_not][nozero][oddsum][evensum];
 73 | 
 74 |     ll res=0;
 75 |     bool newnozero;
 76 | 
 77 |     REP(i,0,10)
 78 |     {
 79 |         if(smaller_or_not||(i<=(int)(y[pos]-'0')))
 80 |         {
 81 |             newnozero=(nozero||i>0);
 82 |             if(newnozero)
 83 |             {
 84 |                 if(!((n-pos-1)&1)) res+=f(pos+1,(smaller_or_not||(i<(int)(y[pos]-'0'))),true,oddsum+i,evensum);
 85 |                 else res+=f(pos+1,(smaller_or_not||(i<(int)(y[pos]-'0'))),true,oddsum,evensum+i);
 86 |             }
 87 |             else
 88 |             {
 89 |                 res+=f(pos+1,(smaller_or_not||(i<(int)(y[pos]-'0'))),false,oddsum,evensum);
 90 |             }
 91 |         }
 92 |     }
 93 |     dp[pos][smaller_or_not][nozero][oddsum][evensum]=res;
 94 |     return res;
 95 | }
 96 | 
 97 | int main() {
 98 |     //freopen("input.txt","r",stdin);
 99 |     //freopen("output.txt","w",stdout);
100 |     ios_base::sync_with_stdio(false);
101 |     cin.tie(NULL);
102 |     int t,a,b;
103 |     ll ans;
104 |     cin>>t;
105 |     while(t--)
106 |     {
107 |         ans=0;
108 |         cin>>a>>b;
109 |         a--;
110 |         if(b>0)
111 |         {
112 |             y=to_string(b);
113 |             n=y.size();
114 |             memset(dp,-1,sizeof dp);
115 |             ans=f(0,false,false,0,0);
116 |         }
117 |         if(a>0)
118 |         {
119 |             y=to_string(a);
120 |             n=y.size();
121 |             memset(dp,-1,sizeof dp);
122 |             ans-=f(0,false,false,0,0);
123 |         }
124 |         cout<<ans<<endl;
125 |     }
126 |     return 0;
127 | }
128 | 


--------------------------------------------------------------------------------
/SPOJ HAYBALE.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | /*INCLUDE_HEADERS*/
  4 | #include<stdio.h>
  5 | #include<string.h>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | /*END HEADERS*/
 26 | using namespace std;
 27 | /*START_MACROS*/
 28 | #define N 100001
 29 | #define MAX 4*N
 30 | #define llu long long unsigned
 31 | #define lld long long int
 32 | #define ld long int
 33 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 34 | #define REP(p,a,b) for(int p=a;p<b;p++)
 35 | #define mod 1000000007
 36 | #define getchar_unlocked getchar
 37 | #define pi(c) printf("%d\n",c)
 38 | #define pwa(a,b) printf(#a,b)
 39 | #define pll(c) printf("%lld\n",c)
 40 | #define pc(c) printf("%c\n",c)
 41 | #define pf(c) printf("%f\n",c)
 42 | #define ps(x) printf("%s\n",&x)
 43 | #define pd(x) printf("%lf\n",x)
 44 | #define w(j) for(int f=0;f<j;f++)
 45 | #define si(f) scanf("%d",&f)
 46 | #define sc(f) scanf("%c",&f)
 47 | #define sll(f) scanf("%lld",&f)
 48 | #define ss(f) scanf("%s",f)
 49 | #define sf(f) scanf("%f",&f)
 50 | #define two(d) (1<<d)
 51 | #define twoL(X) (((lld)(1))<<(X))
 52 | #define ip(a,b) ((int)pow(a,b))
 53 | #define ic(a) (a-'0')
 54 | #define contain(S,X) (((S)&two(X))!=0)
 55 | #define containL(S,X) (((S)&twoL(X))!=0)
 56 | #define sof(da_type) sizeof(da_type)
 57 | /*STL DEFINITIONS*/
 58 | #define pub(f) push_back(f)
 59 | #define pob(f) pop_back(f)
 60 | #define puf(f) push_front(f)
 61 | #define pof(f) pop_front(f)
 62 | #define iv vector<int>
 63 | #define il list<int>
 64 | #define v(arg) vector<arg>
 65 | #define l(arg) list<arg>
 66 | #define ivit vector<int>::iterator
 67 | #define ilit list<int>::iterator
 68 | #define vit(arg) vector<arg>::iterator
 69 | #define lit(arg) list<arg>::iterator
 70 | #define cl() clear()
 71 | #define sz() size()
 72 | #define fd() find()
 73 | #define ft() front()
 74 | #define bk() back()
 75 | #define beg() begin()
 76 | #define ed() end()
 77 | #define asn(asrgument1,asrgument2) assign(asrgument1,asrgument2)
 78 | #define rz(size_argument) resize(size_argument)
 79 | #define mkp(a,b) make_pair(a,b)
 80 | #define fst first
 81 | #define snd second
 82 | /*END STL MACROS*/
 83 | /*END MACROS*/
 84 | 
 85 | int scan_d()    {int ip=getchar_unlocked(),ret=0,flag=1;for(;ip<'0'||ip>'9';ip=getchar_unlocked())if(ip=='-'){flag=-1;ip=getchar_unlocked();break;}for(;ip>='0'&&ip<='9';ip=getchar_unlocked())ret=ret*10+ip-'0';return flag*ret;}
 86 | void print_d(int n)     {if(n<0){n=-n;putchar('-');}int i=10;char output_buffer[10];do{output_buffer[--i]=(n%10)+'0';n/=10;}while(n);do{putchar(output_buffer[i]);}while(++i<10);}
 87 | 
 88 | int hay[10000002];
 89 | int main() {
 90 | 	//freopen("input.txt","r",stdin);
 91 | 	//freopen("output.txt","w",stdout);
 92 |     memset(hay,0,sizeof(hay));
 93 |     int n,k,i,x,y;
 94 |     n=scan_d();
 95 |     k=scan_d();
 96 |     REP(i,0,k)
 97 |     {
 98 |         x=scan_d();
 99 |         y=scan_d();
100 |         hay[x-1]++;
101 |         hay[y]--;
102 |     }
103 |     REP(i,1,n)
104 |     {
105 |         hay[i]+=hay[i-1];
106 |     }
107 |     sort(hay,hay+n);
108 |     print_d(hay[n/2]);
109 | 	return 0;
110 | }
111 | 


--------------------------------------------------------------------------------
/SPOJ RPLD.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | /*INCLUDE_HEADERS*/
  4 | #include<stdio.h>
  5 | #include<string.h>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | /*END HEADERS*/
 26 | using namespace std;
 27 | /*START_MACROS*/
 28 | #define llu long long unsigned
 29 | #define lld long long int
 30 | #define ld long int
 31 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 32 | #define REP(p,a,b) for(int p=a;p<b;p++)
 33 | #define mod 1000000007
 34 | #define getchar_unlocked getchar
 35 | #define pi(c) printf("%d\n",c)
 36 | #define pwa(a,b) printf(#a,b)
 37 | #define pll(c) printf("%lld\n",c)
 38 | #define pc(c) printf("%c\n",c)
 39 | #define pf(c) printf("%f\n",c)
 40 | #define ps(x) printf("%s\n",&x)
 41 | #define pd(x) printf("%lf\n",x)
 42 | #define w(j) for(int f=0;f<j;f++)
 43 | #define si(f) scanf("%d",&f)
 44 | #define sc(f) scanf("%c",&f)
 45 | #define sll(f) scanf("%lld",&f)
 46 | #define ss(f) scanf("%s",f)
 47 | #define sf(f) scanf("%f",&f)
 48 | #define two(d) (1<<d)
 49 | #define twoL(X) (((lld)(1))<<(X))
 50 | #define ip(a,b) ((int)pow(a,b))
 51 | #define ic(a) (a-'0')
 52 | #define contain(S,X) (((S)&two(X))!=0)
 53 | #define containL(S,X) (((S)&twoL(X))!=0)
 54 | #define sof(da_type) sizeof(da_type)
 55 | /*STL DEFINITIONS*/
 56 | #define pub(f) push_back(f)
 57 | #define pob(f) pop_back(f)
 58 | #define puf(f) push_front(f)
 59 | #define pof(f) pop_front(f)
 60 | #define iv vector<int>
 61 | #define il list<int>
 62 | #define v(arg) vector<arg>
 63 | #define l(arg) list<arg>
 64 | #define ivit vector<int>::iterator
 65 | #define ilit list<int>::iterator
 66 | #define vit(arg) vector<arg>::iterator
 67 | #define lit(arg) list<arg>::iterator
 68 | #define cl() clear()
 69 | #define sz() size()
 70 | #define fd() find()
 71 | #define ft() front()
 72 | #define bk() back()
 73 | #define beg() begin()
 74 | #define ed() end()
 75 | #define asn(asrgument1,asrgument2) assign(asrgument1,asrgument2)
 76 | #define rz(size_argument) resize(size_argument)
 77 | #define mkp(a,b) make_pair(a,b)
 78 | #define fst first
 79 | #define snd second
 80 | /*END STL MACROS*/
 81 | /*END MACROS*/
 82 | 
 83 | 
 84 | int main() {
 85 | 	freopen("input.txt","r",stdin);
 86 | 	freopen("output.txt","w",stdout);
 87 | 	int t,n,r,x,y;
 88 | 	scanf("%d",&t);
 89 | 	for(int j=1;j<=t;j++)
 90 |     {
 91 |         int flag=0;
 92 |         vector < pair <int ,int > > p;
 93 |         scanf("%d%d",&n,&r);
 94 |         REP(i,0,r)
 95 |         {
 96 |             scanf("%d%d",&x,&y);
 97 |             p.pub(mkp(x,y));
 98 |         }
 99 |         sort(p.begin(),p.end());
100 |         for(int i=0;i<p.size();i++)
101 |         {
102 |             if(p[i+1].second==p[i].second)
103 |             {
104 |                 if(p[i+1].first==p[i].first)
105 |                 {
106 |                     flag=1;
107 |                     break;
108 |                 }
109 |             }
110 |         }
111 |        if(flag)
112 |        {
113 |            printf("Scenario #%d: impossible\n",j);
114 |        }
115 |        else
116 |        {
117 |            printf("Scenario #%d: possible\n",j);
118 |        }
119 |     }
120 | 	return 0;
121 | }
122 | 


--------------------------------------------------------------------------------
/SPOJ ARRAYSUB (  Find the maximum for each and every contiguous subarray of size k ).cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | /* Created by Anmol Varshney */
  3 | 
  4 | /*INCLUDE_HEADERS*/
  5 | #include<stdio.h>
  6 | #include<string.h>
  7 | #include <vector>
  8 | #include <list>
  9 | #include <map>
 10 | #include <set>
 11 | #include <queue>
 12 | #include <deque>
 13 | #include <stack>
 14 | #include <bitset>
 15 | #include <algorithm>
 16 | #include <functional>
 17 | #include <numeric>
 18 | #include <utility>
 19 | #include <sstream>
 20 | #include <iostream>
 21 | #include <iomanip>
 22 | #include <cstdio>
 23 | #include <cmath>
 24 | #include <cstdlib>
 25 | #include <ctime>
 26 | /*END HEADERS*/
 27 | using namespace std;
 28 | /*START_MACROS*/
 29 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 30 | #define INT_MIN -999999
 31 | #define INT_MAX 999999
 32 | #define llu long long unsigned
 33 | #define lld long long int
 34 | #define ld long int
 35 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 36 | #define REP(p,a,b) for(int p=a;p<b;p++)
 37 | #define mod 1000000007
 38 | #define getchar_unlocked getchar
 39 | #define pi(c) printf("%d\n",c)
 40 | #define pwa(a,b) printf(#a,b)
 41 | #define pll(c) printf("%lld\n",c)
 42 | #define pc(c) printf("%c\n",c)
 43 | #define pf(c) printf("%f\n",c)
 44 | #define ps(x) printf("%s\n",&x)
 45 | #define pd(x) printf("%lf\n",x)
 46 | #define w(j) for(int f=0;f<j;f++)
 47 | #define si(f) scanf("%d",&f)
 48 | #define sc(f) scanf("%c",&f)
 49 | #define sll(f) scanf("%lld",&f)
 50 | #define ss(f) scanf("%s",f)
 51 | #define sf(f) scanf("%f",&f)
 52 | #define two(d) (1<<d)
 53 | #define twoL(X) (((lld)(1))<<(X))
 54 | #define ip(a,b) ((int)pow(a,b))
 55 | #define ic(a) (a-'0')
 56 | #define contain(S,X) (((S)&two(X))!=0)
 57 | #define containL(S,X) (((S)&twoL(X))!=0)
 58 | #define sof(da_type) sizeof(da_type)
 59 | /*STL DEFINITIONS*/
 60 | #define pub(f) push_back(f)
 61 | #define pob(f) pop_back(f)
 62 | #define puf(f) push_front(f)
 63 | #define pof(f) pop_front(f)
 64 | #define iv vector<int>
 65 | #define il list<int>
 66 | #define v(arg) vector<arg>
 67 | #define l(arg) list<arg>
 68 | #define ivit vector<int>::iterator
 69 | #define ilit list<int>::iterator
 70 | #define vit(arg) vector<arg>::iterator
 71 | #define lit(arg) list<arg>::iterator
 72 | #define cl() clear()
 73 | #define sz() size()
 74 | #define fd() find()
 75 | #define ft() front()
 76 | #define bk() back()
 77 | #define beg() begin()
 78 | #define ed() end()
 79 | #define asn(asrgument1,asrgument2) assign(asrgument1,asrgument2)
 80 | #define rz(size_argument) resize(size_argument)
 81 | #define mkp(a,b) make_pair(a,b)
 82 | #define fst first
 83 | #define snd second
 84 | /*END STL MACROS*/
 85 | /*END MACROS*/
 86 | 
 87 | int a[1000001];
 88 | int main() {
 89 |     //freopen("input.txt","r",stdin);
 90 | 	//freopen("output.txt","w",stdout);
 91 |     int n,k;
 92 |     si(n);
 93 |     REP(i,0,n)
 94 |     {
 95 |         si(a[i]);
 96 |     }
 97 |     si(k);
 98 |     vector<int> answer;
 99 |     deque<int> q;
100 |     REP(i,0,k)
101 |     {
102 |         while(!q.empty()&&a[i]>=a[q.back()])
103 |             q.pop_back();
104 |         q.push_back(i);
105 |     }
106 |     REP(i,k,n)
107 |     {
108 |         answer.push_back(a[q.front()]);
109 |         while(!q.empty()&&a[i]>=a[q.back()])
110 |             q.pop_back();
111 |         while(!q.empty()&&q.front()<=(i-k))
112 |             q.pop_front();
113 |         q.push_back(i);
114 |     }
115 |     if(!q.empty())answer.push_back(a[q.front()]);
116 |     for(int i=0;i<answer.size();i++)
117 |     {
118 |         printf("%d ",answer[i]);
119 |     }
120 |     return 0;
121 | }
122 | 


--------------------------------------------------------------------------------
/SPOJ LITE.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | struct node
  4 | {
  5 | 	int number;
  6 | 	int on;
  7 | 	int toggle;
  8 | 	void assignleaf()
  9 | 	{
 10 | 		number=1;
 11 | 		on=0;
 12 | 		toggle=0;
 13 | 	}
 14 | 	
 15 | 	void merge(node& left,node& right)
 16 | 	{
 17 | 		number=left.number+right.number;
 18 | 		if(left.toggle%2==0&&right.toggle%2==0)
 19 | 		on=left.on+right.on;
 20 | 		else if((left.toggle&1)&&(right.toggle&1))
 21 | 		on=left.number-left.on+right.number-right.on;
 22 | 		else if((left.toggle&1)&&right.toggle%2==0)
 23 | 		on=left.number-left.on+right.on;
 24 | 		else if((right.toggle&1)&&left.toggle%2==0)
 25 | 		on=left.on+right.number-right.on;
 26 | 		toggle=0;
 27 | 	}
 28 | 	
 29 | 	void split(node& left,node& right)
 30 | 	{
 31 | 		if(toggle&1)
 32 | 		{
 33 | 			on=number-on;
 34 | 			left.toggle+=toggle;
 35 | 			right.toggle+=toggle;
 36 | 			toggle=0;
 37 | 		}
 38 | 	}
 39 | 	
 40 | 	int getvalue()
 41 | 	{
 42 | 		if(toggle&1)return (number-on);
 43 | 		return on;
 44 | 	}
 45 | };
 46 | class stree
 47 | {
 48 | 	public:
 49 | 	int N;
 50 | 	node *Node;
 51 | 	stree(int n)
 52 | 	{
 53 | 		N=n;
 54 | 		Node=new node[getSegmentTreeSize(n)];
 55 | 		build_tree(0,n-1,1);
 56 | 	}
 57 | 	~stree()
 58 | 	{
 59 | 		delete[] Node;
 60 | 	}
 61 | 	void build_tree(int begin,int end,int index)
 62 | 	{
 63 | 		if(begin==end)
 64 | 		{
 65 | 			Node[index].assignleaf();
 66 | 			return;
 67 | 		}
 68 | 		int mid=(begin+end)/2;
 69 | 		build_tree(begin,mid,2*index);
 70 | 		build_tree(mid+1,end,2*index+1);
 71 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 72 | 	}
 73 | 	
 74 | 	node query(int index,int begin,int end,int left,int right)
 75 | 	{
 76 | 		if(begin>=left&&end<=right)
 77 | 		{
 78 | 			return Node[index];
 79 | 		}
 80 | 		int mid=(begin+end)/2;
 81 | 		if(left>mid)
 82 | 		{
 83 | 			Node[index].split(Node[2*index],Node[2*index+1]);
 84 | 			return query(2*index+1,mid+1,end,left,right);
 85 | 		}
 86 | 		if(right<=mid)
 87 | 		{
 88 | 			Node[index].split(Node[2*index],Node[2*index+1]);
 89 | 			return query(2*index,begin,mid,left,right);
 90 | 		}
 91 | 		Node[index].split(Node[2*index],Node[2*index+1]);
 92 | 		node leftchild=query(2*index,begin,mid,left,mid);
 93 | 		node rightchild=query(2*index+1,mid+1,end,mid+1,right);
 94 | 		node result;
 95 | 		result.merge(leftchild,rightchild);
 96 | 		return result;
 97 | 	}
 98 | 	void update(int i,int j)
 99 | 	{
100 | 		update_tree(1,0,N-1,i,j);
101 | 	}
102 | 	void update_tree(int index,int left,int right,int i,int j)
103 | 	{
104 | 		if(left>=i&&right<=j)
105 | 		{
106 | 			Node[index].toggle+=1;
107 | 			return;
108 | 		}
109 | 		int mid=(left+right)/2;
110 | 		Node[index].split(Node[2*index],Node[2*index+1]);
111 | 		if(i>mid)
112 | 		{
113 | 			update_tree(2*index+1,mid+1,right,i,j);
114 | 		}
115 | 		else if(j<=mid)
116 | 		{
117 | 			update_tree(2*index,left,mid,i,j);
118 | 		}
119 | 		else
120 | 		{
121 | 			update_tree(2*index,left,mid,i,mid);
122 | 			update_tree(2*index+1,mid+1,right,mid+1,j);
123 | 		}
124 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
125 | 	}
126 | 	int getSegmentTreeSize(int N) 
127 | 	{
128 | 		int size = 1;
129 | 		for (; size < N; size <<= 1);
130 | 		return size << 1;
131 | 	}
132 | 	int getValue(int lo,int hi) 
133 | 	{
134 | 		node result = query(1, 0, N-1, lo, hi);
135 | 		return result.getvalue();
136 | 	}
137 | };
138 | 
139 | int main() {
140 | 		int i,n,m,ch,p,q;
141 | 		scanf("%d%d",&n,&m);
142 | 		stree st(n);
143 | 		for(i=0;i<m;i++)
144 | 		{
145 | 			scanf("%d%d%d",&ch,&p,&q);
146 | 			if(ch==0)
147 | 			{
148 | 				st.update(p-1,q-1);
149 | 			}
150 | 			else
151 | 			{
152 | 				printf("%d\n",st.getValue(p-1,q-1));
153 | 			}
154 | 		}
155 | 	return 0;
156 | }


--------------------------------------------------------------------------------
/SPOJ UPDATEIT ( Done like CHOC on CODECHEF ).cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | /*INCLUDE_HEADERS*/
  4 | #include<stdio.h>
  5 | #include<string.h>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | /*END HEADERS*/
 26 | using namespace std;
 27 | /*START_MACROS*/
 28 | #define N 100001
 29 | #define MAX 4*N
 30 | #define llu long long unsigned
 31 | #define lld long long int
 32 | #define ld long int
 33 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 34 | #define REP(p,a,b) for(int p=a;p<b;p++)
 35 | #define mod 1000000007
 36 | #define getchar_unlocked getchar
 37 | #define pi(c) printf("%d\n",c)
 38 | #define pwa(a,b) printf(#a,b)
 39 | #define pll(c) printf("%lld\n",c)
 40 | #define pc(c) printf("%c\n",c)
 41 | #define pf(c) printf("%f\n",c)
 42 | #define ps(x) printf("%s\n",&x)
 43 | #define pd(x) printf("%lf\n",x)
 44 | #define w(j) for(int f=0;f<j;f++)
 45 | #define si(f) scanf("%d",&f)
 46 | #define sc(f) scanf("%c",&f)
 47 | #define sll(f) scanf("%lld",&f)
 48 | #define ss(f) scanf("%s",f)
 49 | #define sf(f) scanf("%f",&f)
 50 | #define two(d) (1<<d)
 51 | #define twoL(X) (((lld)(1))<<(X))
 52 | #define ip(a,b) ((int)pow(a,b))
 53 | #define ic(a) (a-'0')
 54 | #define contain(S,X) (((S)&two(X))!=0)
 55 | #define containL(S,X) (((S)&twoL(X))!=0)
 56 | #define sof(da_type) sizeof(da_type)
 57 | /*STL DEFINITIONS*/
 58 | #define pub(f) push_back(f)
 59 | #define pob(f) pop_back(f)
 60 | #define puf(f) push_front(f)
 61 | #define pof(f) pop_front(f)
 62 | #define iv vector<int>
 63 | #define il list<int>
 64 | #define v(arg) vector<arg>
 65 | #define l(arg) list<arg>
 66 | #define ivit vector<int>::iterator
 67 | #define ilit list<int>::iterator
 68 | #define vit(arg) vector<arg>::iterator
 69 | #define lit(arg) list<arg>::iterator
 70 | #define cl() clear()
 71 | #define sz() size()
 72 | #define fd() find()
 73 | #define ft() front()
 74 | #define bk() back()
 75 | #define beg() begin()
 76 | #define ed() end()
 77 | #define asn(asrgument1,asrgument2) assign(asrgument1,asrgument2)
 78 | #define rz(size_argument) resize(size_argument)
 79 | #define mkp(a,b) make_pair(a,b)
 80 | #define fst first
 81 | #define snd second
 82 | /*END STL MACROS*/
 83 | /*END MACROS*/
 84 | 
 85 | int scan_d()    {int ip=getchar_unlocked(),ret=0,flag=1;for(;ip<'0'||ip>'9';ip=getchar_unlocked())if(ip=='-'){flag=-1;ip=getchar_unlocked();break;}for(;ip>='0'&&ip<='9';ip=getchar_unlocked())ret=ret*10+ip-'0';return flag*ret;}
 86 | void print_d(int n)     {if(n<0){n=-n;putchar('-');}int i=10;char output_buffer[10];do{output_buffer[--i]=(n%10)+'0';n/=10;}while(n);do{putchar(output_buffer[i]);}while(++i<10);}
 87 | 
 88 | int main() {
 89 | 	//freopen("input.txt","r",stdin);
 90 | 	//freopen("output.txt","w",stdout);
 91 |     int n,u,i,x,y,z,t;
 92 |     while(t--)
 93 |     {
 94 |         n=scan_d();
 95 |         u=scan_d();
 96 |         int a[n+2];
 97 |         memset(a,0,sizeof(a));
 98 |         REP(i,0,u)
 99 |         {
100 |             x=scan_d();
101 |             y=scan_d();
102 |             z=scan_d();
103 |             hay[x]+=z;
104 |             hay[y+1]-=z;
105 |         }
106 |         q=scan_d();
107 |         REP(i,1,n)
108 |         {
109 |             hay[i]+=hay[i-1];
110 |         }
111 |         REP(i,0,q)
112 |         {
113 |            x=scan_d();
114 |            print_d((hay[x]));
115 |         }
116 |     }
117 | 	return 0;
118 | }
119 | 


--------------------------------------------------------------------------------
/SPOJ POTHOLE.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | #include <stdio.h>
  4 | #include <string.h>
  5 | #include <vector>
  6 | #include <list>
  7 | #include <map>
  8 | #include <set>
  9 | #include <queue>
 10 | #include <deque>
 11 | #include <stack>
 12 | #include <bitset>
 13 | #include <algorithm>
 14 | #include <functional>
 15 | #include <numeric>
 16 | #include <utility>
 17 | #include <sstream>
 18 | #include <iostream>
 19 | #include <iomanip>
 20 | #include <cstdio>
 21 | #include <cmath>
 22 | #include <cstdlib>
 23 | #include <ctime>
 24 | 
 25 | using namespace std;
 26 | 
 27 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 28 | #define INT_MIN -2147483647
 29 | #define INT_MAX 2147483647
 30 | #define INF 2000000000
 31 | #define INF_SMALL 10000
 32 | #define INF_LL 9223372036854775807LL
 33 | #define PI acos(-1.0)
 34 | #define llu long long unsigned
 35 | #define ll long long int
 36 | #define ld long int
 37 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 38 | #define REP(p,a,b) for(int p=a;p<b;p++)
 39 | #define mod 1000000007
 40 | #define getchar_unlocked getchar
 41 | #define pb(f) push_back(f)
 42 | #define pob(f) pop_back(f)
 43 | #define pf(f) push_front(f)
 44 | #define pof(f) pop_front(f)
 45 | #define mkp(a,b) make_pair(a,b)
 46 | #define fst first
 47 | #define snd second
 48 | #define pii pair<int,int>
 49 | #define ins(a) insert(a)
 50 | 
 51 | #define v 210
 52 | 
 53 | bool visited[v];
 54 | int parent[v];
 55 | vector<int> adj[v];
 56 | int rescap[v][v]; //Residual Capacity. At first these are the original Capacities
 57 | int cap[v][v];
 58 | 
 59 | void initialize()
 60 | {
 61 |     REP(i,0,v)
 62 |         REP(j,0,v)
 63 |             rescap[i][j]=0,cap[i][j]=0;
 64 |     REP(i,0,v)
 65 |         adj[i].clear();
 66 | }
 67 | 
 68 | bool BFS(int ve,int s,int t) //Mixture of both BFS and Edmonds Karp
 69 | {
 70 |     memset(visited,false,sizeof(visited));
 71 |     memset(parent,-1,sizeof(parent));
 72 |     queue<int> q;
 73 |     q.push(s);
 74 |     visited[s]=true;
 75 |     parent[s]=-1;
 76 |     while(!q.empty())
 77 |     {
 78 |         int temp=q.front();
 79 |         q.pop();
 80 |         if(temp==t)break;
 81 |         REP(i,1,ve+1) // We check every Vertex because edges keep on changing (Magnitude as well as Direction).
 82 |         {
 83 |             if(visited[i]==false && rescap[temp][i]>0)
 84 |             {
 85 |                 q.push(i);
 86 |                 parent[i]=temp;
 87 |                 visited[i]=true;
 88 |             }
 89 |         }
 90 |     }
 91 |     for(int vertex=t;vertex>-1;vertex=parent[vertex])
 92 |     {
 93 |         int temp=parent[vertex];
 94 |         rescap[temp][vertex]--;  //Add/Subtract Original Capacities. Here 1.
 95 |         rescap[vertex][temp]++;
 96 |     }
 97 |     return (visited[t]==true);
 98 | }
 99 | 
100 | int main() {
101 |     //freopen("input.txt","r",stdin);
102 |     //freopen("output.txt","w",stdout);
103 |     ios_base::sync_with_stdio(false);
104 |     int tests;
105 |     scanf("%d",&tests);
106 |     while(tests--)
107 |     {
108 |         initialize();
109 |         int ve,n,e;
110 |         scanf("%d",&ve);
111 |         REP(i,0,ve-1)
112 |         {
113 |             scanf("%d",&n);
114 |             REP(j,0,n)
115 |             {
116 |                 scanf("%d",&e);
117 |                 adj[i+1].pb(e);
118 |                 rescap[i+1][e]=((i==0||e==ve)?1:INF_SMALL); //INF_SMALL because it is to be added to original Capacities.
119 |             }
120 |         }
121 |         int cnt=0;
122 |         while(BFS(ve,1,ve))cnt++; //We have to count how many people can be sent
123 |                                   //i.e. how many times BFS can be applied.
124 |         printf("%d\n",cnt);
125 |     }
126 |     return 0;
127 | }
128 | 


--------------------------------------------------------------------------------
/SPOJ HORRIBLE.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | int const MAXN = 100000 + 5;
  4 | struct node
  5 | {
  6 | 	long long int sum;
  7 | 	long long int number;
  8 | 	long long int add;
  9 | 	void assignleaf()
 10 | 	{
 11 | 		sum=0;
 12 | 		number=1;
 13 | 		add=0;
 14 | 	}
 15 | 	
 16 | 	void merge(node& left,node& right)
 17 | 	{
 18 | 		add=0;
 19 | 		number=left.number+right.number;
 20 | 		sum=(left.add*left.number)+left.sum+(right.add*right.number)+right.sum;
 21 | 	}
 22 | 	
 23 | 	void split(node& left,node& right)
 24 | 	{
 25 | 		if(add!=0)
 26 | 		{
 27 | 			sum+=number*add;
 28 | 			left.add+=add;
 29 | 			right.add+=add;
 30 | 			add=0;
 31 | 		}
 32 | 	}
 33 | 	
 34 | 	long long int getvalue()
 35 | 	{
 36 | 		return(sum+(number*add));
 37 | 	}
 38 | };
 39 | class stree
 40 | {
 41 | 	public:
 42 | 	long long int N;
 43 | 	node *Node;
 44 | 	stree(long long int n)
 45 | 	{
 46 | 		N=n;
 47 | 		Node=new node[getSegmentTreeSize(n)];
 48 | 		build_tree(0,n-1,1);
 49 | 	}
 50 | 	void build_tree(long long int begin,long long int end,long long int index)
 51 | 	{
 52 | 		if(begin==end)
 53 | 		{
 54 | 			Node[index].assignleaf();
 55 | 			return;
 56 | 		}
 57 | 		long long int mid=(begin+end)/2;
 58 | 		build_tree(begin,mid,2*index);
 59 | 		build_tree(mid+1,end,2*index+1);
 60 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 61 | 	}
 62 | 	
 63 | 	node query(long long int index,long long int begin,long long int end,long long int left,long long int right)
 64 | 	{
 65 | 		if(begin>=left&&end<=right)
 66 | 		{
 67 | 			return Node[index];
 68 | 		}
 69 | 		long long int mid=(begin+end)/2;
 70 | 		if(left>mid)
 71 | 		{
 72 | 			Node[index].split(Node[2*index],Node[2*index+1]);
 73 | 			return query(2*index+1,mid+1,end,left,right);
 74 | 		}
 75 | 		if(right<=mid)
 76 | 		{
 77 | 			Node[index].split(Node[2*index],Node[2*index+1]);
 78 | 			return query(2*index,begin,mid,left,right);
 79 | 		}
 80 | 		Node[index].split(Node[2*index],Node[2*index+1]);
 81 | 		node leftchild=query(2*index,begin,mid,left,mid);
 82 | 		node rightchild=query(2*index+1,mid+1,end,mid+1,right);
 83 | 		node result;
 84 | 		result.merge(leftchild,rightchild);
 85 | 		return result;
 86 | 	}
 87 | 	void update(long long int i,long long int j,long long int val)
 88 | 	{
 89 | 		update_tree(1,0,N-1,i,j,val);
 90 | 	}
 91 | 	void update_tree(long long int index,long long int left,long long int right,long long int i,long long int j,long long int value)
 92 | 	{
 93 | 		if(left>=i&&right<=j)
 94 | 		{
 95 | 			Node[index].add+=value;
 96 | 			return;
 97 | 		}
 98 | 		long long int mid=(left+right)/2;
 99 | 		Node[index].split(Node[2*index],Node[2*index+1]);
100 | 		if(i>mid)
101 | 		{
102 | 			update_tree(2*index+1,mid+1,right,i,j,value);
103 | 		}
104 | 		else if(j<=mid)
105 | 		{
106 | 			update_tree(2*index,left,mid,i,j,value);
107 | 		}
108 | 		else
109 | 		{
110 | 			update_tree(2*index,left,mid,i,mid,value);
111 | 			update_tree(2*index+1,mid+1,right,mid+1,j,value);
112 | 		}
113 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
114 | 	}
115 | 	long long int getSegmentTreeSize(int N) 
116 | 	{
117 | 		long long int x=(long)(ceil(log2(N)));
118 | 		long long int max_size=2*(long)pow(2,x)-1;
119 | 		return max_size;
120 | 	}
121 | 	long long int getValue(long long int lo, long long int hi) 
122 | 	{
123 | 		node result = query(1, 0, N-1, lo, hi);
124 | 		return result.getvalue();
125 | 	}
126 | };
127 | 
128 | int main() {
129 | 	ios_base::sync_with_stdio(false);
130 | 	cin.tie(NULL);
131 | 	long long int i,n,c,t,p,q,v;
132 | 	int ch;
133 | 	cin>>t;
134 | 	while(t--)
135 | 	{
136 | 		cin>>n>>c;
137 | 		stree st(n);
138 | 		for(i=0;i<c;i++)
139 | 		{
140 | 			cin>>ch>>p>>q;
141 | 			if(ch==0)
142 | 			{
143 | 				cin>>v;
144 | 				st.update(p-1,q-1,v);
145 | 			}
146 | 			else
147 | 			{
148 | 				cout<<st.getValue(p-1,q-1)<<endl;
149 | 			}
150 | 		}
151 | 	}
152 | 	return 0;
153 | }


--------------------------------------------------------------------------------
/SPOJ GSS1.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | int const MAXN = 50000 + 5;
  4 | struct node
  5 | {
  6 | 	long long int leftsum;
  7 | 	long long int rightsum;
  8 | 	long long int rightleftsum;
  9 | 	long long int maxsum;
 10 | 	long long int sum;
 11 | 	void assignleaf(long long int x)
 12 | 	{
 13 | 		leftsum=x;
 14 | 		rightsum=x;
 15 | 		rightleftsum=x;
 16 | 		maxsum=x;
 17 | 		sum=x;
 18 | 	}
 19 | 	
 20 | 	void merge(node& left,node& right)
 21 | 	{
 22 | 		sum=left.sum+right.sum;
 23 | 		leftsum=max(left.leftsum,left.sum+right.leftsum);
 24 | 		rightsum=max(right.rightsum,right.sum+left.rightsum);
 25 | 		rightleftsum=left.rightsum+right.leftsum;
 26 | 		maxsum=max(right.maxsum,max(left.maxsum,max(sum,max(leftsum,max(rightsum,rightleftsum)))));
 27 | 	}
 28 | 	
 29 | 	/*void split(node& left,node& right)
 30 | 	{
 31 | 		if(add!=0)
 32 | 		{
 33 | 			sum+=number*add;
 34 | 			left.add+=add;
 35 | 			right.add+=add;
 36 | 			add=0;
 37 | 		}
 38 | 	}*/
 39 | 	
 40 | 	long long int getvalue()
 41 | 	{
 42 | 		return(maxsum);
 43 | 	}
 44 | };
 45 | node Node[4*MAXN];
 46 | long long int a[MAXN];
 47 | class stree
 48 | {
 49 | 	public:
 50 | 	long long int N;
 51 | 	stree(long long int arr[],long long int n)
 52 | 	{
 53 | 		N=n;
 54 | 		build_tree(arr,0,n-1,1);
 55 | 	}
 56 | 	void build_tree(long long int arr[],long long int begin,long long int end,long long int index)
 57 | 	{
 58 | 		if(begin==end)
 59 | 		{
 60 | 			Node[index].assignleaf(arr[begin]);
 61 | 			return;
 62 | 		}
 63 | 		long long int mid=(begin+end)/2;
 64 | 		build_tree(arr,begin,mid,2*index);
 65 | 		build_tree(arr,mid+1,end,2*index+1);
 66 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 67 | 	}
 68 | 	
 69 | 	node query(long long int index,long long int begin,long long int end,long long int left,long long int right)
 70 | 	{
 71 | 		if(begin>=left&&end<=right)
 72 | 		{
 73 | 			return Node[index];
 74 | 		}
 75 | 		long long int mid=(begin+end)/2;
 76 | 		if(left>mid)
 77 | 		{
 78 | 			//Node[index].split(Node[2*index],Node[2*index+1]);
 79 | 			return query(2*index+1,mid+1,end,left,right);
 80 | 		}
 81 | 		if(right<=mid)
 82 | 		{
 83 | 			//Node[index].split(Node[2*index],Node[2*index+1]);
 84 | 			return query(2*index,begin,mid,left,right);
 85 | 		}
 86 | 		//Node[index].split(Node[2*index],Node[2*index+1]);
 87 | 		node leftchild=query(2*index,begin,mid,left,mid);
 88 | 		node rightchild=query(2*index+1,mid+1,end,mid+1,right);
 89 | 		node result;
 90 | 		result.merge(leftchild,rightchild);
 91 | 		return result;
 92 | 	}
 93 | 	/*void update(long long int i,long long int j,long long int val)
 94 | 	{
 95 | 		update_tree(1,0,N-1,i,j,val);
 96 | 	}
 97 | 	void update_tree(long long int index,long long int left,long long int right,long long int i,long long int j,long long int value)
 98 | 	{
 99 | 		if(left>=i&&right<=j)
100 | 		{
101 | 			Node[index].add+=value;
102 | 			return;
103 | 		}
104 | 		long long int mid=(left+right)/2;
105 | 		Node[index].split(Node[2*index],Node[2*index+1]);
106 | 		if(i>mid)
107 | 		{
108 | 			update_tree(2*index+1,mid+1,right,i,j,value);
109 | 		}
110 | 		else if(j<=mid)
111 | 		{
112 | 			update_tree(2*index,left,mid,i,j,value);
113 | 		}
114 | 		else
115 | 		{
116 | 			update_tree(2*index,left,mid,i,mid,value);
117 | 			update_tree(2*index+1,mid+1,right,mid+1,j,value);
118 | 		}
119 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
120 | 	}*/
121 | 	long long int getValue(long long int lo, long long int hi) 
122 | 	{
123 | 		node result = query(1, 0, N-1, lo, hi);
124 | 		return result.getvalue();
125 | 	}
126 | };
127 | 
128 | int main() {
129 | 	long long int i,n,m,p,q;
130 | 		scanf("%lld",&n);
131 | 		for(i=0;i<n;i++)
132 | 		scanf("%lld",&a[i]);
133 | 		stree st(a,n);
134 | 		scanf("%lld",&m);
135 | 		for(i=0;i<m;i++)
136 | 		{
137 | 			scanf("%lld%lld",&p,&q);
138 | 			printf("%lld\n",st.getValue(p-1,q-1));
139 | 		}
140 | 	return 0;
141 | }
142 | 


--------------------------------------------------------------------------------
/SPOJ LUCIFER.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | #include <stdio.h>
  4 | #include <string.h>
  5 | #include <string>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | 
 26 | using namespace std;
 27 | 
 28 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 29 | #define INF_LL 9223372036854775807LL
 30 | #define PI acos(-1.0)
 31 | #define llu long long unsigned
 32 | #define ll long long int
 33 | #define ld long int
 34 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 35 | #define REP(p,a,b) for(int p=a;p<b;p++)
 36 | #define mod 1000000007
 37 | #define getchar_unlocked getchar
 38 | #define pb(f) push_back(f)
 39 | #define pob(f) pop_back(f)
 40 | #define pf(f) push_front(f)
 41 | #define pof(f) pop_front(f)
 42 | #define mkp(a,b) make_pair(a,b)
 43 | #define fst first
 44 | #define snd second
 45 | #define pii pair<int,int>
 46 | #define ins(a) insert(a)
 47 | 
 48 | ll gcd(ll a,ll b)
 49 | {
 50 |     if(b>a) return gcd(b,a);
 51 |     else if(b!=0) return gcd(b,a%b);
 52 |     else return a;
 53 | }
 54 | 
 55 | string to_string(ll num)
 56 | {
 57 |     stringstream ss;
 58 |     ss << num;
 59 |     return ss.str();
 60 | }
 61 | 
 62 | set<int> s;
 63 | int mark[101];
 64 | 
 65 | void foo()
 66 | {
 67 |     for(int i=2;i*i<=100;i++)
 68 |     {
 69 |         if(mark[i]==0)
 70 |         {
 71 |             for(int j=i*2;j<=100;j+=i)
 72 |                 mark[j]=1;
 73 |         }
 74 |     }
 75 |     for(int i=2;i<=100;i++)
 76 |         if(mark[i]==0)
 77 |             s.ins(i);
 78 | }
 79 | 
 80 | ll dp[10][2][2][50][50];
 81 | int n;
 82 | string y;
 83 | 
 84 | ll f(int pos,bool smaller_or_not,bool nozero,int oddsum,int evensum)
 85 | {
 86 |     if(pos==n)
 87 |         return (s.find(evensum-oddsum)!=s.end());
 88 | 
 89 |     if(dp[pos][smaller_or_not][nozero][oddsum][evensum]>=0)
 90 |         return dp[pos][smaller_or_not][nozero][oddsum][evensum];
 91 | 
 92 |     ll res=0;
 93 |     bool newnozero;
 94 | 
 95 |     REP(i,0,10)
 96 |     {
 97 |         if(smaller_or_not||(i<=(int)(y[pos]-'0')))
 98 |         {
 99 |             newnozero=(nozero||i>0);
100 |             if(newnozero)
101 |             {
102 |                 if(!((n-pos-1)&1)) res+=f(pos+1,(smaller_or_not||(i<(int)(y[pos]-'0'))),true,oddsum+i,evensum);
103 |                 else res+=f(pos+1,(smaller_or_not||(i<(int)(y[pos]-'0'))),true,oddsum,evensum+i);
104 |             }
105 |             else
106 |             {
107 |                 res+=f(pos+1,(smaller_or_not||(i<(int)(y[pos]-'0'))),false,oddsum,evensum);
108 |             }
109 |         }
110 |     }
111 |     dp[pos][smaller_or_not][nozero][oddsum][evensum]=res;
112 |     return res;
113 | }
114 | 
115 | int main() {
116 |     //freopen("input.txt","r",stdin);
117 |     //freopen("output.txt","w",stdout);
118 |     ios_base::sync_with_stdio(false);
119 |     cin.tie(NULL);
120 |     int t,a,b;
121 |     ll ans;
122 |     cin>>t;
123 |     foo();
124 |     while(t--)
125 |     {
126 |         ans=0;
127 |         cin>>a>>b;
128 |         a--;
129 |         if(b>0)
130 |         {
131 |             y=to_string(b);
132 |             n=y.size();
133 |             memset(dp,-1,sizeof dp);
134 |             ans=f(0,false,false,0,0);
135 |         }
136 |         if(a>0)
137 |         {
138 |             y=to_string(a);
139 |             n=y.size();
140 |             memset(dp,-1,sizeof dp);
141 |             ans-=f(0,false,false,0,0);
142 |         }
143 |         cout<<ans<<endl;
144 |     }
145 |     return 0;
146 | }
147 | 


--------------------------------------------------------------------------------
/SPOJ UPDATEIT ( FAST IO Required for Segment Trees ).cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | int const MAXN = 100000 + 5;
  4 | #define gc getchar_unlocked
  5 | #define pc putchar_unlocked
  6 | inline int scan()
  7 | {
  8 | 	register int c=gc();
  9 | 	int x=0;
 10 | 	for(;(c<48||c>57);c=gc());
 11 | 	for(;(c>47&&c<58);c=gc()){x= (x<<1) + (x<<3) + c-48;}
 12 | 	return x;
 13 | }	
 14 |  
 15 | inline void print(int n)
 16 | {
 17 | 	int N=n,rev,count=0;
 18 | 	rev=N;
 19 | 	if(N==0){pc('0');return;}
 20 | 	while((rev%10)==0){count++;rev/=10;}
 21 | 	rev=0;
 22 | 	while(N!=0){rev= (rev<<3)+(rev<<1)+N%10;N/=10;}
 23 | 	while(rev!=0){pc(rev%10+'0');rev/=10;}
 24 | 	while(count--){pc('0');}
 25 | 	pc('\n');
 26 | }
 27 | struct node
 28 | {
 29 | 	int sum;
 30 | 	int number;
 31 | 	int add;
 32 | 	void assignleaf()
 33 | 	{
 34 | 		sum=0;
 35 | 		number=1;
 36 | 		add=0;
 37 | 	}
 38 | 	
 39 | 	void merge(node& left,node& right)
 40 | 	{
 41 | 		add=0;
 42 | 		number=left.number+right.number;
 43 | 		sum=(left.add*left.number)+left.sum+(right.add*right.number)+right.sum;
 44 | 	}
 45 | 	
 46 | 	void split(node& left,node& right)
 47 | 	{
 48 | 		if(add!=0)
 49 | 		{
 50 | 			sum+=number*add;
 51 | 			left.add+=add;
 52 | 			right.add+=add;
 53 | 			add=0;
 54 | 		}
 55 | 	}
 56 | 	
 57 | 	int getvalue()
 58 | 	{
 59 | 		return(sum+(number*add));
 60 | 	}
 61 | };
 62 | node Node[4*MAXN];
 63 | class stree
 64 | {
 65 | 	public:
 66 | 	int N;
 67 | 	
 68 | 	stree(int n)
 69 | 	{
 70 | 		N=n;
 71 | 		build_tree(0,n-1,1);
 72 | 	}
 73 | 	void build_tree(int begin,int end,int index)
 74 | 	{
 75 | 		if(begin==end)
 76 | 		{
 77 | 			Node[index].assignleaf();
 78 | 			return;
 79 | 		}
 80 | 		int mid=(begin+end)/2;
 81 | 		build_tree(begin,mid,2*index);
 82 | 		build_tree(mid+1,end,2*index+1);
 83 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 84 | 	}
 85 | 	
 86 | 	node query(int index,int begin,int end,int left,int right)
 87 | 	{
 88 | 		if(begin>=left&&end<=right)
 89 | 		{
 90 | 			return Node[index];
 91 | 		}
 92 | 		int mid=(begin+end)/2;
 93 | 		if(left>mid)
 94 | 		{
 95 | 			Node[index].split(Node[2*index],Node[2*index+1]);
 96 | 			return query(2*index+1,mid+1,end,left,right);
 97 | 		}
 98 | 		if(right<=mid)
 99 | 		{
100 | 			Node[index].split(Node[2*index],Node[2*index+1]);
101 | 			return query(2*index,begin,mid,left,right);
102 | 		}
103 | 		Node[index].split(Node[2*index],Node[2*index+1]);
104 | 		node leftchild=query(2*index,begin,mid,left,mid);
105 | 		node rightchild=query(2*index+1,mid+1,end,mid+1,right);
106 | 		node result;
107 | 		result.merge(leftchild,rightchild);
108 | 		return result;
109 | 	}
110 | 	void update(int i,int j,int val)
111 | 	{
112 | 		update_tree(1,0,N-1,i,j,val);
113 | 	}
114 | 	void update_tree(int index,int left,int right,int i,int j,int value)
115 | 	{
116 | 		if(left>=i&&right<=j)
117 | 		{
118 | 			Node[index].add+=value;
119 | 			return;
120 | 		}
121 | 		int mid=(left+right)/2;
122 | 		Node[index].split(Node[2*index],Node[2*index+1]);
123 | 		if(i>mid)
124 | 		{
125 | 			update_tree(2*index+1,mid+1,right,i,j,value);
126 | 		}
127 | 		else if(j<=mid)
128 | 		{
129 | 			update_tree(2*index,left,mid,i,j,value);
130 | 		}
131 | 		else
132 | 		{
133 | 			update_tree(2*index,left,mid,i,mid,value);
134 | 			update_tree(2*index+1,mid+1,right,mid+1,j,value);
135 | 		}
136 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
137 | 	}
138 | 	int getValue(int lo, int hi) 
139 | 	{
140 | 		node result = query(1, 0, N-1, lo, hi);
141 | 		return result.getvalue();
142 | 	}
143 | };
144 | 
145 | int main() {
146 | 	int i,n,u,t,r,l,val,q;
147 | 	t=scan();
148 | 	while(t--)
149 | 	{
150 | 		n=scan();
151 | 		u=scan();
152 | 		stree st(n);
153 | 		for(i=0;i<u;i++)
154 | 		{
155 | 			l=scan();
156 | 			r=scan();
157 | 			val=scan();
158 | 			st.update(l,r,val);
159 | 		}
160 | 		q=scan();
161 | 		for(i=0;i<q;i++)
162 | 		{
163 | 			val=scan();
164 | 			print(st.getValue(val,val));
165 | 		}
166 | 	}
167 | 	return 0;
168 | }


--------------------------------------------------------------------------------
/SPOJ GSS3.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | int const MAXN = 50000 + 5;
  4 | struct node
  5 | {
  6 | 	long long int leftsum;
  7 | 	long long int rightsum;
  8 | 	long long int rightleftsum;
  9 | 	long long int maxsum;
 10 | 	long long int sum;
 11 | 	void assignleaf(long long int x)
 12 | 	{
 13 | 		leftsum=x;
 14 | 		rightsum=x;
 15 | 		rightleftsum=x;
 16 | 		maxsum=x;
 17 | 		sum=x;
 18 | 	}
 19 | 	
 20 | 	void merge(node& left,node& right)
 21 | 	{
 22 | 		sum=left.sum+right.sum;
 23 | 		leftsum=max(left.leftsum,left.sum+right.leftsum);
 24 | 		rightsum=max(right.rightsum,right.sum+left.rightsum);
 25 | 		rightleftsum=left.rightsum+right.leftsum;
 26 | 		maxsum=max(right.maxsum,max(left.maxsum,max(sum,max(leftsum,max(rightsum,rightleftsum)))));
 27 | 	}
 28 | 	
 29 | 	/*void split(node& left,node& right)
 30 | 	{
 31 | 		if(add!=0)
 32 | 		{
 33 | 			sum+=number*add;
 34 | 			left.add+=add;
 35 | 			right.add+=add;
 36 | 			add=0;
 37 | 		}
 38 | 	}*/
 39 | 	
 40 | 	long long int getvalue()
 41 | 	{
 42 | 		return(maxsum);
 43 | 	}
 44 | };
 45 | node Node[4*MAXN];
 46 | long long int a[MAXN];
 47 | class stree
 48 | {
 49 | 	public:
 50 | 	long long int N;
 51 | 	stree(long long int arr[],long long int n)
 52 | 	{
 53 | 		N=n;
 54 | 		build_tree(arr,0,n-1,1);
 55 | 	}
 56 | 	void build_tree(long long int arr[],long long int begin,long long int end,long long int index)
 57 | 	{
 58 | 		if(begin==end)
 59 | 		{
 60 | 			Node[index].assignleaf(arr[begin]);
 61 | 			return;
 62 | 		}
 63 | 		long long int mid=(begin+end)/2;
 64 | 		build_tree(arr,begin,mid,2*index);
 65 | 		build_tree(arr,mid+1,end,2*index+1);
 66 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
 67 | 	}
 68 | 	
 69 | 	node query(long long int index,long long int begin,long long int end,long long int left,long long int right)
 70 | 	{
 71 | 		if(begin>=left&&end<=right)
 72 | 		{
 73 | 			return Node[index];
 74 | 		}
 75 | 		long long int mid=(begin+end)/2;
 76 | 		if(left>mid)
 77 | 		{
 78 | 			//Node[index].split(Node[2*index],Node[2*index+1]);
 79 | 			return query(2*index+1,mid+1,end,left,right);
 80 | 		}
 81 | 		if(right<=mid)
 82 | 		{
 83 | 			//Node[index].split(Node[2*index],Node[2*index+1]);
 84 | 			return query(2*index,begin,mid,left,right);
 85 | 		}
 86 | 		//Node[index].split(Node[2*index],Node[2*index+1]);
 87 | 		node leftchild=query(2*index,begin,mid,left,mid);
 88 | 		node rightchild=query(2*index+1,mid+1,end,mid+1,right);
 89 | 		node result;
 90 | 		result.merge(leftchild,rightchild);
 91 | 		return result;
 92 | 	}
 93 | 	void update(long long int i,long long int j,long long int val)
 94 | 	{
 95 | 		update_tree(1,0,N-1,i,j,val);
 96 | 	}
 97 | 	void update_tree(long long int index,long long int left,long long int right,long long int i,long long int j,long long int value)
 98 | 	{
 99 | 		if(left>=i&&right<=j)
100 | 		{
101 | 			Node[index].assignleaf(value);
102 | 			return;
103 | 		}
104 | 		long long int mid=(left+right)/2;
105 | 		//Node[index].split(Node[2*index],Node[2*index+1]);
106 | 		if(i>mid)
107 | 		{
108 | 			update_tree(2*index+1,mid+1,right,i,j,value);
109 | 		}
110 | 		else if(j<=mid)
111 | 		{
112 | 			update_tree(2*index,left,mid,i,j,value);
113 | 		}
114 | 		else
115 | 		{
116 | 			update_tree(2*index,left,mid,i,mid,value);
117 | 			update_tree(2*index+1,mid+1,right,mid+1,j,value);
118 | 		}
119 | 		Node[index].merge(Node[2*index],Node[2*index+1]);
120 | 	}
121 | 	long long int getValue(long long int lo, long long int hi) 
122 | 	{
123 | 		node result = query(1, 0, N-1, lo, hi);
124 | 		return result.getvalue();
125 | 	}
126 | };
127 | 
128 | int main() {
129 | 	long long int i,n,m,p,q;
130 | 	int ch;
131 | 		scanf("%lld",&n);
132 | 		for(i=0;i<n;i++)
133 | 		scanf("%lld",&a[i]);
134 | 		stree st(a,n);
135 | 		scanf("%lld",&m);
136 | 		for(i=0;i<m;i++)
137 | 		{
138 | 			scanf("%d%lld%lld",&ch,&p,&q);
139 | 			if(ch==1)
140 | 			printf("%lld\n",st.getValue(p-1,q-1));
141 | 			else
142 | 			st.update(p-1,p-1,q);
143 | 		}
144 | 	return 0;
145 | }


--------------------------------------------------------------------------------
/SPOJ CSTREET (MST).cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | /*INCLUDE_HEADERS*/
  4 | #include<stdio.h>
  5 | #include<string.h>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | /*END HEADERS*/
 26 | using namespace std;
 27 | /*START_MACROS*/
 28 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 29 | #define INT_MIN -2147483647
 30 | #define INT_MAX 2147483647
 31 | #define INF 2000000000
 32 | #define INF_LL 9223372036854775807LL
 33 | #define PI acos(-1.0)
 34 | #define llu long long unsigned
 35 | #define lld long long int
 36 | #define ld long int
 37 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 38 | #define REP(p,a,b) for(int p=a;p<b;p++)
 39 | #define mod 1000000007
 40 | #define getchar_unlocked getchar
 41 | #define pi(c) printf("%d\n",c)
 42 | #define pwa(a,b) printf(#a,b)
 43 | #define pll(c) printf("%lld\n",c)
 44 | #define pc(c) printf("%c\n",c)
 45 | #define pf(c) printf("%f\n",c)
 46 | #define ps(x) printf("%s\n",&x)
 47 | #define pd(x) printf("%lf\n",x)
 48 | #define w(j) for(int f=0;f<j;f++)
 49 | #define si(f) scanf("%d",&f)
 50 | #define sc(f) scanf("%c",&f)
 51 | #define sll(f) scanf("%lld",&f)
 52 | #define ss(f) scanf("%s",f)
 53 | #define sf(f) scanf("%f",&f)
 54 | #define two(d) (1<<d)
 55 | #define twoL(X) (((lld)(1))<<(X))
 56 | #define ip(a,b) ((int)pow(a,b))
 57 | #define ic(a) (a-'0')
 58 | #define contain(S,X) (((S)&two(X))!=0)
 59 | #define containL(S,X) (((S)&twoL(X))!=0)
 60 | #define sof(da_type) sizeof(da_type)
 61 | /*STL DEFINITIONS*/
 62 | #define pub(f) push_back(f)
 63 | #define pob(f) pop_back(f)
 64 | #define puf(f) push_front(f)
 65 | #define pof(f) pop_front(f)
 66 | #define iv vector<int>
 67 | #define il list<int>
 68 | #define v(arg) vector<arg>
 69 | #define l(arg) list<arg>
 70 | #define ivit vector<int>::iterator
 71 | #define ilit list<int>::iterator
 72 | #define vit(arg) vector<arg>::iterator
 73 | #define lit(arg) list<arg>::iterator
 74 | #define cl() clear()
 75 | #define sz() size()
 76 | #define fd() find()
 77 | #define ft() front()
 78 | #define bk() back()
 79 | #define beg() begin()
 80 | #define ed() end()
 81 | #define asn(asrgument1,asrgument2) assign(asrgument1,asrgument2)
 82 | #define rz(size_argument) resize(size_argument)
 83 | #define mkp(a,b) make_pair(a,b)
 84 | #define fst first
 85 | #define snd second
 86 | /*END STL MACROS*/
 87 | /*END MACROS*/
 88 | 
 89 | #define edge pair <int,int>
 90 | #define maxV 1001
 91 | vector < pair <long long int,edge> > G;
 92 | 
 93 | struct subset
 94 | {
 95 |     int parent;
 96 |     int rank;
 97 | };
 98 | 
 99 | subset subsets[maxV];
100 | 
101 | void initialize(int V)
102 | {
103 |     G.clear();
104 |     REP(i,0,V+1)
105 |     {
106 |         subsets[i].parent=i;
107 |         subsets[i].rank=0;
108 |     }
109 | }
110 | 
111 | int find(int x)
112 | {
113 |     if(subsets[x].parent!=x)
114 |     {
115 |         subsets[x].parent=find(subsets[x].parent);
116 |     }
117 |     return subsets[x].parent;
118 | }
119 | 
120 | void Union(int x,int y)
121 | {
122 |     int xroot=find(x);
123 |     int yroot=find(y);
124 | 
125 |     if(subsets[xroot].rank>subsets[yroot].rank)
126 |     {
127 |         subsets[yroot].parent=xroot;
128 |     }
129 |     else if(subsets[xroot].rank<subsets[yroot].rank)
130 |     {
131 |         subsets[xroot].parent=yroot;
132 |     }
133 |     else
134 |     {
135 |         subsets[xroot].parent=yroot;
136 |         subsets[yroot].rank++;
137 |     }
138 | }
139 | 
140 | int Kruskal(int V)
141 | {
142 |     sort(G.begin(),G.end());
143 |     int e=1,i=0;
144 |     long long int cost=0;
145 |     while(e<V)
146 |     {
147 |         int xroot=find(G[i].snd.fst);
148 |         int yroot=find(G[i].snd.snd);
149 |         if(xroot!=yroot)
150 |         {
151 |             e++;
152 |             cost+=G[i].fst;
153 |             Union(xroot,yroot);
154 |         }
155 |         i++;
156 |     }
157 |     return cost;
158 | }
159 | 
160 | int main() {
161 |     //freopen("input.txt","r",stdin);
162 | 	//freopen("output.txt","w",stdout);
163 |     int t,v,e,a,b;
164 |     long long int w,p;
165 |     scanf("%d",&t);
166 |     while(t--)
167 |     {
168 | 	    scanf("%lld%d%d",&p,&v,&e);
169 | 	    initialize(v);
170 | 	    REP(i,0,e)
171 | 	    {
172 | 	        scanf("%d%d%d",&a,&b,&w);
173 | 	        G.push_back(pair<int,edge>(w*p,mkp(a,b)));
174 | 	    }
175 | 	    long long int ans=Kruskal(v);
176 | 	    printf("%lld\n",ans);
177 |     }
178 | 	return 0;
179 | }
180 | 


--------------------------------------------------------------------------------
/SPOJ ORDERSET (Segment Tree offline query) (Read the Comments).cpp:
--------------------------------------------------------------------------------
  1 | /*SPOJ ORDERSET (Segment Tree offline query) (Map gives only one key to an element, 
  2 | if assigned key multiple times last key is the final key)(Coordinate Compression using Maps, 
  3 | Count number of elements lesser than a given number is done by querying the Segment Tree in a normal way
  4 | ( because segment tree stores the number of elements and they are sorted also)
  5 | Kth smallest element is found by binary searching the Segment tree (values to be searched made half every
  6 | time ) it searches the segment till it finds the segment which is completely filled and 
  7 | has the same length as the value we are searching for, value being updated every time)*/
  8 | #include <bits/stdc++.h>
  9 | #include<cstdio>
 10 | using namespace std;
 11 | #define gc getchar_unlocked
 12 | #define inp(a) scanint(a)
 13 | #define MAXN 200005
 14 | #define REP(i,a,b) for(int i=a;i<b;i++)
 15 | void scanint(int &x)
 16 | {
 17 |     register int c = gc(),mul=1;
 18 |     x = 0;
 19 |     for(;!( (c>=48 && c<=57) || c=='-' );c = gc());
 20 |     if(c=='-')
 21 |         mul=-1,c=gc();
 22 |     for(;c>47 && c<58;c = gc())
 23 |         {x = (x<<1) + (x<<3) + c - 48;}
 24 |     x=x*mul;
 25 | }
 26 | struct node
 27 | {
 28 | 	 int number;
 29 | 	void assignleaf()
 30 | 	{
 31 | 		number=0;
 32 | 	}
 33 | 
 34 | 	void merge(node& left,node& right)
 35 | 	{
 36 | 		number=left.number+right.number;
 37 | 	}
 38 |     int getvalue()
 39 |     {
 40 |         return(number);
 41 |     }
 42 | }Node[4*MAXN];
 43 | int x[MAXN],num[MAXN];
 44 | map<int,int> m;
 45 | char op[MAXN][2];
 46 | class stree
 47 | {
 48 | 	public:
 49 | 	int N;
 50 | 	stree(int n)
 51 | 	{
 52 | 		N=n;
 53 | 		build_tree(0,n-1,1);
 54 | 	}
 55 | 	void build_tree(int begin,int end,int index)
 56 | 	{
 57 | 		if(begin==end)
 58 | 		{
 59 | 			Node[index].assignleaf();
 60 | 			return;
 61 | 		}
 62 | 		int mid=(begin+end)>>1;
 63 | 		build_tree(begin,mid,index<<1);
 64 | 		build_tree(mid+1,end,(index<<1)+1);
 65 | 		Node[index].merge(Node[index<<1],Node[(index<<1)+1]);
 66 | 	}
 67 | 
 68 | 	node query(int index,int begin,int end,int left,int right)
 69 | 	{
 70 | 		if(begin>end||begin>right||end<left)
 71 | 		return ((node){0});
 72 | 		if(begin>=left&&end<=right)
 73 | 		{
 74 | 			return Node[index];
 75 | 		}
 76 | 		int mid=(begin+end)>>1;
 77 | 		node leftchild=query(index<<1,begin,mid,left,right);
 78 | 		node rightchild=query((index<<1)+1,mid+1,end,left,right);
 79 | 		node result;
 80 | 		result.merge(leftchild,rightchild);
 81 | 		return result;
 82 | 	}
 83 | 	int search(int index,int i,int j,int val)
 84 | 	{
 85 | 	    if(Node[index].number<val)
 86 |         {
 87 |             return -1;
 88 |         }
 89 |         if(((j-i+1)==val))
 90 |         {
 91 |             return j;
 92 |         }
 93 |         int mid=(i+j)>>1;
 94 |         int left=Node[index<<1].number;
 95 |         int right=Node[(index<<1)+1].number;
 96 |         if(left>=val)
 97 |             return search((index<<1),i,mid,val);
 98 |         else
 99 |             return search((index<<1)+1,mid+1,j,val-left);
100 | 	}
101 | 	void update(int i,int j,int val)
102 | 	{
103 | 		update_tree(1,0,N-1,i,j,val);
104 | 	}
105 | 	void update_tree(int index,int left,int right, int i,int j,int val)
106 | 	{
107 | 		if(left>j||right<i||left>right)
108 | 		return;
109 | 		if(left>=i&&right<=j)
110 | 		{
111 | 			Node[index].number=val;
112 | 			return;
113 | 		}
114 | 		int mid=(left+right)>>1;
115 | 		update_tree(index<<1,left,mid,i,j,val);
116 | 		update_tree((index<<1)+1,mid+1,right,i,j,val);
117 | 		Node[index].merge(Node[index<<1],Node[(index<<1)+1]);
118 | 	}
119 | 	 int getValue(int lo, int hi)
120 | 	{
121 | 		node result = query(1, 0, N-1, lo, hi);
122 | 		return result.number;
123 | 	}
124 | };
125 | 
126 | int main() {
127 | 	int q,i;
128 | 	inp(q);
129 | 	for(i=0;i<q;i++)
130 | 	{
131 | 	    scanf("%s",op[i]);
132 | 	    inp(x[i]);
133 | 	    num[i]=x[i];
134 | 	}
135 | 	sort(num,num+q);
136 | 	for(i=0;i<q;i++)
137 | 	{
138 | 	    m[num[i]]=i;
139 | 	}
140 | 	stree st(q);
141 | 	for(i=0;i<q;i++)
142 | 	{
143 | 	    int nodeindex=m[x[i]];
144 | 	    switch(op[i][0])
145 | 	    {
146 | 	        case 'I':st.update(nodeindex,nodeindex,1);
147 | 	        break;
148 | 	        case 'D':st.update(nodeindex,nodeindex,0);
149 | 	        break;
150 | 	        case 'K':
151 | 	        if((x[i]<=0||Node[1].number<x[i]))
152 | 	        	printf("invalid\n");
153 | 	        else
154 |                 printf("%d\n",num[st.search(1,0,q-1,x[i])]);
155 |             break;
156 |             case 'C':
157 |                 if(nodeindex==0)
158 |                 	printf("0\n");
159 |                 else 
160 |                 	printf("%d\n",st.getValue(0,nodeindex-1));
161 |                 break;
162 | 	    }
163 | 	}
164 | 	cout<<endl;
165 | 	return 0;
166 | }
167 | 


--------------------------------------------------------------------------------
/SPOJ CNTPRIME.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | /*INCLUDE_HEADERS*/
  4 | #include<stdio.h>
  5 | #include<string.h>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <map>
  9 | #include <set>
 10 | #include <queue>
 11 | #include <deque>
 12 | #include <stack>
 13 | #include <bitset>
 14 | #include <algorithm>
 15 | #include <functional>
 16 | #include <numeric>
 17 | #include <utility>
 18 | #include <sstream>
 19 | #include <iostream>
 20 | #include <iomanip>
 21 | #include <cstdio>
 22 | #include <cmath>
 23 | #include <cstdlib>
 24 | #include <ctime>
 25 | /*END HEADERS*/
 26 | using namespace std;
 27 | /*START_MACROS*/
 28 | #define llu long long unsigned
 29 | #define lld long long int
 30 | #define ld long int
 31 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 32 | #define REP(p,a,b) for(int p=a;p<b;p++)
 33 | #define mod 1000000007
 34 | #define getchar_unlocked getchar
 35 | #define pi(c) printf("%d\n",c)
 36 | #define pwa(a,b) printf(#a,b)
 37 | #define pll(c) printf("%lld\n",c)
 38 | #define pc(c) printf("%c\n",c)
 39 | #define pf(c) printf("%f\n",c)
 40 | #define ps(x) printf("%s\n",&x)
 41 | #define pd(x) printf("%lf\n",x)
 42 | #define w(j) for(int f=0;f<j;f++)
 43 | #define si(f) scanf("%d",&f)
 44 | #define sc(f) scanf("%c",&f)
 45 | #define sll(f) scanf("%lld",&f)
 46 | #define ss(f) scanf("%s",f)
 47 | #define sf(f) scanf("%f",&f)
 48 | #define two(d) (1<<d)
 49 | #define twoL(X) (((lld)(1))<<(X))
 50 | #define ip(a,b) ((int)pow(a,b))
 51 | #define ic(a) (a-'0')
 52 | #define contain(S,X) (((S)&two(X))!=0)
 53 | #define containL(S,X) (((S)&twoL(X))!=0)
 54 | #define sof(da_type) sizeof(da_type)
 55 | /*STL DEFINITIONS*/
 56 | #define pub(f) push_back(f)
 57 | #define pob(f) pop_back(f)
 58 | #define puf(f) push_front(f)
 59 | #define pof(f) pop_front(f)
 60 | #define iv vector<int>
 61 | #define il list<int>
 62 | #define v(arg) vector<arg>
 63 | #define l(arg) list<arg>
 64 | #define ivit vector<int>::iterator
 65 | #define ilit list<int>::iterator
 66 | #define vit(arg) vector<arg>::iterator
 67 | #define lit(arg) list<arg>::iterator
 68 | #define cl() clear()
 69 | #define sz() size()
 70 | #define fd() find()
 71 | #define ft() front()
 72 | #define bk() back()
 73 | #define beg() begin()
 74 | #define ed() end()
 75 | #define asn(asrgument1,asrgument2) assign(asrgument1,asrgument2)
 76 | #define rz(size_argument) resize(size_argument)
 77 | #define mkp(a,b) make_pair(a,b)
 78 | #define fst first
 79 | #define snd second
 80 | /*END STL MACROS*/
 81 | /*END MACROS*/
 82 | 
 83 | int seg[100001];
 84 | int lazy[100001];
 85 | int arr[100001];
 86 | static int check[1000001];
 87 | void generate()
 88 | {
 89 | 	int i,j;
 90 | 	for(i=0;i<1000001;i++)
 91 | 	check[i]=1;
 92 | 	for(i=2;i*i<1000001;i++)
 93 | 	{
 94 | 		if(check[i]==1)
 95 | 		{
 96 | 			for(j=i*2;j<1000001;j+=i)
 97 | 			{
 98 | 				check[j]=0;
 99 | 			}
100 | 		}
101 | 	}
102 | }
103 | 
104 | void build_tree(int node,int beg,int end)
105 | {
106 |     if(beg>end) return;
107 |     if(beg==end)
108 |     {
109 |         if(check[arr[beg]]==1)
110 |             seg[node]=1;
111 |         else seg[node]=0;
112 |         return;
113 |     }
114 |     build_tree(node*2,beg,(beg+end)/2);
115 |     build_tree(1+2*node,(beg+end)/2 + 1,end);
116 |     seg[node]=seg[node*2]+seg[1+2*node];
117 | }
118 | 
119 | void update_tree(int node,int a,int b,int start,int end,int val)
120 | {
121 |     if(lazy[node]!=0)
122 |     {
123 |         if(check[lazy[node]]==1)
124 |         {
125 |             seg[node]=(b-a+1);
126 |             if(a!=b)
127 |             {
128 |                 lazy[node*2]=lazy[node];
129 |                 lazy[1+2*node]=lazy[node];
130 |             }
131 |         }
132 |         else
133 |         {
134 |             seg[node]=0;
135 |             if(a!=b)
136 |             {
137 |                 lazy[node*2]=lazy[node];
138 |                 lazy[1+2*node]=lazy[node];
139 |             }
140 |         }
141 |         lazy[node]=0;
142 |     }
143 |     if(a>b||a>end||b<start) return;
144 | 
145 |     if(a>=start&&b<=end)
146 |     {
147 |         if(check[val]==1)
148 |         {
149 |            seg[node]=(b-a+1);
150 |            if(a!=b)
151 |            {
152 |                lazy[node*2]=val;
153 |                lazy[1+2*node]=val;
154 |            }
155 |         }
156 |         else
157 |         {
158 |             seg[node]=0;
159 |             if(a!=b)
160 |             {
161 |                lazy[node*2]=val;
162 |                lazy[1+2*node]=val;
163 |             }
164 |         }
165 |      return;
166 |     }
167 |     update_tree(node*2,a,(a+b)/2,start,end,val);
168 |     update_tree(1+2*node,1+(a+b)/2,b,start,end,val);
169 |     seg[node]=seg[2*node]+seg[1+2*node];
170 | }
171 | 
172 | int query_tree(int node,int a,int b,int begin,int end)
173 | {
174 |     if(lazy[node]!=0)
175 |     {
176 |         if(check[lazy[node]]==1)
177 |         {
178 |             seg[node]=(b-a+1);
179 |             if(a!=b)
180 |             {
181 |                 lazy[node*2]=lazy[node];
182 |                 lazy[1+2*node]=lazy[node];
183 |             }
184 |         }
185 |         else
186 |         {
187 |             seg[node]=0;
188 |             if(a!=b)
189 |             {
190 |                 lazy[node*2]=lazy[node];
191 |                 lazy[1+2*node]=lazy[node];
192 |             }
193 |         }
194 |         lazy[node]=0;
195 |     }
196 | 
197 |     if(a>b||a>end||b<begin) return 0;
198 |     if(a>=begin&&b<=end) return seg[node];
199 |     int x=query_tree(node*2,a,(a+b)/2,begin,end);
200 |     int y=query_tree(1+2*node,1+(a+b)/2,b,begin,end);
201 |     return (x+y);
202 | }
203 | 
204 | int main() {
205 | 	//freopen("input.txt","r",stdin);
206 | 	//freopen("output.txt","w",stdout);
207 | 	int t,n,q,i,x,y,z,w;
208 | 	scanf("%d",&t);
209 | 	generate();
210 | 	for(int count1=1;count1<=t;count1++)
211 | 	{
212 | 	    memset(lazy,0,sizeof(lazy));
213 | 	    memset(seg,0,sizeof(seg));
214 |         scanf("%d%d",&n,&q);
215 |         for(i=0;i<n;i++)
216 |         {
217 |             scanf("%d",&arr[i]);
218 |         }
219 |         build_tree(1,0,n-1);
220 |         printf("Case %d:\n",count1);
221 |         for(i=0;i<q;i++)
222 |         {
223 |             scanf("%d",&x);
224 |             if(x==0)
225 |             {
226 |                 scanf("%d%d%d",&y,&z,&w);
227 |                 y--;
228 |                 z--;
229 |                 update_tree(1,0,n-1,y,z,w);
230 |             }
231 |             else
232 |             {
233 |                 scanf("%d%d",&y,&z);
234 |                 y--;
235 |                 z--;
236 |                 int ans=query_tree(1,0,n-1,y,z);
237 |                 printf("%d\n",ans);
238 |             }
239 |         }
240 |     }
241 | 	return 0;
242 | }
243 | 


--------------------------------------------------------------------------------
/SPOJ BITMAP.cpp:
--------------------------------------------------------------------------------
  1 | /* Created by Anmol Varshney */
  2 | 
  3 | #include <stdio.h>
  4 | #include <string.h>
  5 | //#include <unordered_map>
  6 | //#include <unordered_set>
  7 | #include <string>
  8 | #include <vector>
  9 | #include <list>
 10 | #include <map>
 11 | #include <set>
 12 | #include <queue>
 13 | #include <deque>
 14 | #include <stack>
 15 | #include <bitset>
 16 | #include <algorithm>
 17 | #include <functional>
 18 | #include <numeric>
 19 | #include <utility>
 20 | #include <sstream>
 21 | #include <iostream>
 22 | #include <iomanip>
 23 | #include <cstdio>
 24 | #include <cmath>
 25 | #include <cstdlib>
 26 | #include <ctime>
 27 | 
 28 | using namespace std;
 29 | 
 30 | #define ARRAY_SIZE(arr) sizeof(arr)/sizeof(arr[0])
 31 | #define INT_MIN -2147483647
 32 | #define INT_MAX 2147483647
 33 | #define INF_LL 9223372036854775807LL
 34 | #define PI acos(-1.0)
 35 | #define llu long long unsigned
 36 | #define ll long long int
 37 | #define ld long int
 38 | #define iter(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
 39 | #define REP(p,a,b) for(int p=a;p<b;p++)
 40 | #define REPR(p,a,b) for(int p=a;p>=b;p--)
 41 | #define mod 1000000007
 42 | #define getchar_unlocked getchar
 43 | #define pb(f) push_back(f)
 44 | #define pob(f) pop_back(f)
 45 | #define pf(f) push_front(f)
 46 | #define pof(f) pop_front(f)
 47 | #define mkp(a,b) make_pair(a,b)
 48 | #define fst first
 49 | #define snd second
 50 | #define pii pair<int,int>
 51 | #define ins(a) insert(a)
 52 | #define CLR(x) memset(x,0,sizeof(x))
 53 | #define FAST_LOG2(x) (sizeof(unsigned long)*8 - 1 - __builtin_clzl((unsigned long)(x)))
 54 | #define IOS ios_base::sync_with_stdio(false)
 55 | #define citi cin.tie(NULL);
 56 | #define FREI(var) freopen(var,"r",stdin)
 57 | #define FREO(var) freopen(var,"w",stdout)
 58 | #define endl "\n"
 59 | 
 60 | /*ll C[101][101]; //Either C[n][r] (for First) or C[2][r] (for Second)
 61 | 
 62 | ll nCr(ll n,ll r)
 63 | {
 64 |     int mn=min(n-r,r);
 65 | 
 66 |     if(mn==0) return 1LL;
 67 |     if(mn==1) return n;
 68 | 
 69 |     if(C[n][mn]) return C[n][mn];
 70 | 
 71 |     C[n][r]=nCr(n-1,mn)+nCr(n-1,mn-1);
 72 | 
 73 |     return C[n][r];
 74 | }
 75 | 
 76 | ll nCr(ll n,ll r)
 77 | {
 78 |     C[0][0]=C[0][1]=1;
 79 |     for(ll i=2;i<=n;i++)
 80 |     {
 81 |         C[1][0]=1;
 82 |         C[1][i]=1;
 83 |         for(ll j=1;j<i;j++)
 84 |             C[1][j]=C[0][j]+C[0][j-1];
 85 |         for(ll j=0;j<=i;j++)
 86 |             C[0][j]=C[1][j];
 87 |     }
 88 |     return C[1][r];
 89 | }
 90 | 
 91 | ll fast_pow(ll a,ll b,ll M)
 92 | {
 93 |     ll res = 1;
 94 |     while ( b > 0 )
 95 |     {
 96 |         if ( b&1 ) res = (res*a)%M;
 97 |         a = (a*a)%M;
 98 |         b >>= 1;
 99 |     }
100 |     return res;
101 | }
102 | 
103 | ll FermatInverseModulo(ll b,ll modulo) // modulo is a prime number
104 | {
105 |     return (fast_pow(b,modulo-2,modulo));
106 | }
107 | 
108 | void ExtendedEuclid(ll a,ll b,ll &x,ll &y) //Used for Diophantine Equations, Let g=gcd(a,b)
109 | {                                          //If (X',Y') is solution for (a/g)X'+(b/g)Y'=1
110 |     if(!b)                                 //Let X=(c/g)*X'
111 |     {                                      //Let Y=(c/g)*Y'
112 |         x=1;                               //Solution to ax+by=c where gcd(a,b) divides c is
113 |         y=0;                               //x=X'+(b/g)t , y=Y'-(a/g)*t where t is any integer
114 |         return;
115 |     }
116 |     ExtendedEuclid(b,a%b,x,y);
117 |     ll temp=x;
118 |     x=y;
119 |     y=temp-(a/b)*y;
120 | }
121 | 
122 | int InverseModuloEE(ll a,ll modulo)
123 | {
124 |     ll x,y;
125 |     ExtendedEuclid(a,modulo,x,y);
126 |     if(x<0) x+=modulo;
127 |     return x;
128 | }
129 | 
130 | ll ChineseMinX(ll num[],ll rem[],int n) //Elements in num[] should be pairwise relatively prime
131 | {                                       //Otherwise solution exists only if
132 |     ll product=1;                       //rem[i] is equivalent to rem[j] mod gcd(num[i],num[j])
133 |                                         //In this case solutions are unique % lcm(num[0],num[1],...)
134 |     REP(i,0,n)
135 |         product*=num[i];
136 | 
137 |     ll res=0;
138 | 
139 |     REP(i,0,n)
140 |     {
141 |         ll p=product/num[i];
142 |         res+=(rem[i]*InverseModuloEE(p,num[i])*p);
143 |     }
144 | 
145 |     return (res%product); // All numbers are of the form res%product + k*(product)
146 | }
147 | 
148 | string to_string(int num)
149 | {
150 |     stringstream ss;
151 |     ss << num;
152 |     return ss.str();
153 | }
154 | 
155 | int gcd(int a,int b)
156 | {
157 |     if(b>a) return gcd(b,a);
158 |     else if(b!=0) return gcd(b,a%b);
159 |     else return a;
160 | } */
161 | 
162 | string arr[182];
163 | int a[182][182];
164 | queue< pair<int,int> >q;
165 | 
166 | bool isValid(int x,int y,int R,int C)
167 | {
168 |     return (x>=0&&y>=0&&x<R&&y<C);
169 | }
170 | 
171 | void solve(int R,int C)
172 | {
173 |     memset(a,-1,sizeof a);
174 |     for(int i=0;i<R;i++)
175 |     {
176 |         for(int j=0;j<C;j++)
177 |         {
178 |             if(arr[i][j]=='1')
179 |             {
180 |                 q.push(make_pair(i,j));
181 |                 a[i][j]=0;
182 |             }
183 |         }
184 |     }
185 | 
186 |     int time=1;
187 | 
188 |     while(!q.empty())
189 |     {
190 |         int size=q.size();
191 |         while(size--)
192 |         {
193 |             pair<int,int> p=q.front();
194 |             q.pop();
195 |             if(isValid(p.first-1,p.second,R,C)&&a[p.first-1][p.second]==-1)
196 |             {
197 |                 q.push(make_pair(p.first-1,p.second));
198 |                 a[p.first-1][p.second]=time;
199 |             }
200 |             if(isValid(p.first+1,p.second,R,C)&&a[p.first+1][p.second]==-1)
201 |             {
202 |                 q.push(make_pair(p.first+1,p.second));
203 |                 a[p.first+1][p.second]=time;
204 |             }
205 |             if(isValid(p.first,p.second-1,R,C)&&a[p.first][p.second-1]==-1)
206 |             {
207 |                 q.push(make_pair(p.first,p.second-1));
208 |                 a[p.first][p.second-1]=time;
209 |             }
210 |             if(isValid(p.first,p.second+1,R,C)&&a[p.first][p.second+1]==-1)
211 |             {
212 |                 q.push(make_pair(p.first,p.second+1));
213 |                 a[p.first][p.second+1]=time;
214 |             }
215 |         }
216 |         time++;
217 |     }
218 | }
219 | 
220 | int main()
221 | {
222 |     //FREI("input.txt");
223 |     //FREO("output.txt");
224 |     IOS;
225 |     citi;
226 |     int t,n,m;
227 |     cin>>t;
228 |     while(t--)
229 |     {
230 |         cin>>n>>m;
231 |         REP(i,0,n)
232 |             cin>>arr[i];
233 |         solve(n,m);
234 |         REP(i,0,n)
235 |         {
236 |             REP(j,0,m)
237 |                 cout<<a[i][j]<<" ";
238 |             cout<<endl;
239 |         }
240 | 
241 |     }
242 |     return 0;
243 | }
244 | 


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