first commit

spoj_cpp_clean/ABA12A/ABA12A-13.cpp

@@ -0,0 +1,20 @@
+#include <algorithm>
+#include <vector>
+#include <string>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+using namespace std;
+typedef long long i64;
+
+int main(){
+	int T; scanf("%d", &T);	
+	for(int t=0; t < T; ++t){
+		i64 a, b; scanf("%lld %lld", &a, &b);
+		printf("%lld\n",b);
+	}
+	return 0;	
+}

spoj_cpp_clean/ABA12C/ABA12C-13.cpp

@@ -0,0 +1,54 @@
+#include <algorithm>
+#include <vector>
+#include <string>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+using namespace std;
+typedef long long i64;
+const int INF=0x3f3f3f3f;
+
+int memo[105][105][105];
+bool mark[105][105][105];
+
+int f(vector <int> &v, int n, int i, int j, int w){
+	if(i >= (int)v.size()){
+		if(j <= n && w == 0)return 0;
+		else return INF;
+	}
+
+	int &best = memo[i][j][w];
+	if(mark[i][j][w])return best;
+	mark[i][j][w] = true;
+
+	best = f(v,n,i+1,j,w);
+	if(v[i] != -1){
+		for(int next=1; next + j <= n; ++next){
+			int nextW = w - (next * (i+1));
+			if(nextW >= 0)
+				best = min(best, f(v,n,i+1,next+j,nextW) + (next*v[i]));
+		}
+	}
+
+	return best;
+}
+
+int main(){
+	//freopen("data.in", "r", stdin);
+	int T; scanf("%d", &T);	
+	for(int t=0; t < T; ++t){
+		int n, k; scanf("%d %d", &n, &k);
+		vector <int> v(k);
+		for(int i=0; i<k; ++i)
+			scanf("%d", &v[i]);
+		memset(mark, false, sizeof(mark));
+		
+		int res = f(v, n, 0, 0, k);
+		if(res >= INF)res = -1;
+		printf("%d\n",res);
+	}
+	return 0;	
+}

spoj_cpp_clean/ABA12C/ABA12C-8.cpp

@@ -0,0 +1,157 @@
+/***************************************************
+ * Problem Name : ABA12C - Buying Apples!.cpp
+ * Problem Link : https://www.spoj.com/problems/ABA12C/
+ * OJ           : Spoj
+ * Verdict      : AC
+ * Date         : 2020-02-19
+ * Problem Type : DP
+ * Author Name  : Saikat Sharma
+ * University   : CSE, MBSTU
+ ***************************************************/
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#include <climits>
+#include <cstring>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <queue>
+#include <list>
+#include <unordered_map>
+#include <unordered_set>
+#include <cstdlib>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <cassert>
+#include <map>
+#include <set>
+#include <cassert>
+#include <iomanip>
+#include <random>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+typedef long long ll;
+typedef unsigned long long ull;
+
+#define __FastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
+#define __FileRead freopen ("input.txt", "r", stdin)
+#define __FileWrite freopen ("output.txt", "w", stdout)
+#define SET(a,v) memset(a,v,sizeof(a))
+#define SZ(v) (int)v.size()
+#define pii pair<int,int>
+#define pil pair <int, ll>
+#define pli pair <ll, int>
+#define pll pair <ll, ll>
+#define debug cout <<"######\n"
+#define debug1(x) cout <<"### " << x << " ###\n"
+#define debug2(x,y) cout <<"# " << x <<" : "<< y <<" #\n"
+#define nl cout << "\n";
+#define sp cout << " ";
+#define sl(n) scanf("%lld", &n)
+#define sf(n) scanf("%lf", &n)
+#define si(n) scanf("%d", &n)
+#define ss(n) scanf("%s", n)
+#define pf(n) scanf("%d", n)
+#define pfl(n) scanf("%lld", n)
+#define all(v) v.begin(), v.end()
+#define rall(v) v.begin(), v.end()
+#define srt(v) sort(v.begin(), v.end())
+#define r_srt(v) sort(v.rbegin(), v.rend())
+#define rev(v) reverse(v.begin(), v.end())
+#define Sqr(x) ((x)*(x))
+#define Mod(x, m) ((((x) % (m)) + (m)) % (m))
+#define max3(a, b, c) max(a, max(b, c))
+#define min3(a, b, c) min(a, min(b, c))
+#define pb push_back
+#define mk make_pair
+#define MAX 100005
+#define INF 1000000009
+#define MOD 1000000007
+
+template<class T>
+using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
+template<typename T>
+using ordered_set  = tree<T, null_type, less<T>, rb_tree_tag,
+      tree_order_statistics_node_update>;
+
+template <typename T> string toString ( T Number ) {
+    stringstream ss;
+    ss << Number;
+    return ss.str();
+}
+template<typename T> int toInt (T str) {
+    stringstream ss;
+    ss << str;
+    int num;
+    ss >> num;
+    return num;
+}
+ll lcm (ll a, ll b) {
+    return a * b / __gcd (a, b);
+}
+/************************************ Code Start Here ******************************************************/
+const int MAX_N = 105;
+
+int n, k;
+ll ar[MAX_N];
+ll dp[MAX_N][MAX_N][MAX_N];
+
+ll fun (int pos, int kinche, int koto) {
+    if (pos > k) {
+        if (koto == k) {
+            return 0LL;
+
+        } else {
+            return INF;
+        }
+    }
+
+    ll &res = dp[pos][kinche][koto];
+
+    if (res != -1) return res;
+
+    ll res1 = INF, res2 = INF;
+
+    if (ar[pos] != -1) {
+        if (kinche < n && koto + pos <= k) {
+            res1 = ar[pos] + fun (pos, kinche + 1, koto + pos);
+        }
+    }
+
+    res2 = fun (pos + 1, kinche, koto);
+    return res = min (res1, res2);
+}
+
+int main () {
+    __FastIO;
+    //~ cout << setprecision (10);
+    //~ cout << fixed;
+    int tc;
+    cin >> tc;
+
+    while (tc--) {
+        cin >> n >> k;
+
+        for (int i = 1; i <= k; i++) {
+            cin >> ar[i];
+        }
+
+        SET (dp, -1);
+        ll res = fun (1, 0, 0);
+
+        if (res == INF) {
+            cout << -1 << "\n";
+
+        } else {
+            cout << res << "\n";
+        }
+    }
+
+    return 0;
+}

spoj_cpp_clean/ABA12D/ABA12D-13.cpp

@@ -0,0 +1,28 @@
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <queue>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+using namespace std;
+typedef long long i64;
+
+int v[] = {2, 4, 9, 16, 25, 64, 289, 729, 1681, 2401, 3481, 4096, 5041, 7921, 10201, 15625, 17161, 27889, 28561, 29929, 65536, 83521, 85849, 146689, 262144, 279841, 458329, 491401, 531441, 552049, 579121, 597529, 683929, 703921, 707281, 734449, 829921};
+
+int main(){
+	//freopen("data.in", "r", stdin);
+	int T; scanf("%d", &T);
+	for(int t=0; t<T; ++t){
+		int a, b; scanf("%d %d", &a, &b);
+		int n = (sizeof(v)/sizeof(int));
+		int res = 0;
+		for(int i=0; i<n; ++i)
+			if(v[i] >= a && v[i] <= b)++res;
+		printf("%d\n",res);
+	}
+	return 0;
+}

spoj_cpp_clean/ABA12E/ABA12E-13.cpp

@@ -0,0 +1,59 @@
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <queue>
+#include <map>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+using namespace std;
+typedef long long i64;
+
+
+
+//calculate how many sums are below sum
+int g(vector <i64> &v, int n, i64 sum){
+	int res = 0;
+	for(int i=1; i<n; ++i){
+		int low = i, high = n, mid;
+		while(low < high){
+			int mid = (low + high)/2;
+			if(v[mid] - v[i-1] <= sum)low = mid+1;
+			else high = mid;
+		}
+		res += low-i;
+	}
+	return res;
+}
+
+//estimate the sum that will be the kth
+i64 f(vector <i64> &v, int n, int k){
+	i64 low = 1LL, high = v[n-1], mid;
+	//printf("DEBUG: %lld\n",high);
+	while(low < high){
+		mid = (low + high)/2LL;
+		//printf("DEBUG: low=%lld mid=%lld high=%lld\n", low,mid,high);
+		int w = g(v,n, mid);
+		//printf("DEBUG: w=%d\n",w);
+		if(w < k)low = mid+1;
+		else high = mid;
+	}
+	return low;
+}
+
+int main(){
+	//freopen("data_large.in", "r", stdin);
+	int n, k; scanf("%d %d", &n, &k);
+	vector <i64> v(n+1);
+	i64 high = 0LL;
+	for(int i=1; i<=n; ++i){
+		scanf("%lld", &v[i]);
+		v[i] += v[i-1];
+	}
+	i64 res = f(v, n+1, k);
+	printf("%lld\n",res);
+	return 0;
+}

spoj_cpp_clean/ABCDEF/ABCDEF-9.cpp

@@ -0,0 +1,51 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <utility>
+ 
+using namespace std;
+ 
+int main() 
+{
+	int n;
+	cin >> n;
+	int a[n];
+	vector<int> v1, v2;
+	for(int i = 0; i < n; i++)
+		cin >> a[i];
+	for(int i = 0; i < n; i++)
+		for(int j = 0; j < n; j++)
+			for(int k = 0; k < n; k++)
+				v1.push_back(a[i]*a[j]+a[k]);
+				
+	for(int i = 0; i < n; i++)
+		for(int j = 0; j < n; j++)
+			for(int k = 0; k < n; k++) {
+				if(a[i])
+					v2.push_back(a[i]*(a[j]+a[k]));
+			}
+	
+	sort(v1.begin(), v1.end());
+	sort(v2.begin(), v2.end());
+	
+	long long count = 0;
+	pair<vector<int>::iterator, vector<int>::iterator> bounds;
+	for(vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
+		bounds = equal_range(v2.begin(), v2.end(), *it);
+		count += bounds.second-bounds.first;
+	}
+	cout << count << endl;
+  
+  return 0;
+}

spoj_cpp_clean/ABCPATH/ABCPATH-13.cpp

@@ -0,0 +1,67 @@
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <queue>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+using namespace std;
+typedef long long i64;
+
+char grid[60][60];
+bool mark[60][60];
+
+struct state_t{
+	int i, j, k;
+	char x;
+	state_t(int _i, int _j, int _k, char _x):
+	i(_i), j(_j),k(_k), x(_x){}
+};
+
+int movi[8] = {-1,-1,-1,0,0,1,1,1};
+int movj[8] = {-1,0,1,-1,1,-1,0,1};
+
+int f(int i, int j, int w, int h){
+	memset(mark, false, sizeof(mark));
+	queue <state_t> q;
+	q.push(state_t(i,j,1,'A'));
+	mark[i][j] = true;
+	int best = 1;
+	while(!q.empty()){
+		state_t st = q.front(); q.pop();
+		best = max(best, st.k);
+		if(st.x < 'Z'){
+			for(int s=0; s<8; ++s){
+				int ni = st.i + movi[s], nj = st.j+movj[s];
+				if(ni >= 0 && ni < h && nj >= 0 && nj < w && !mark[ni][nj] && grid[ni][nj] == st.x + 1){
+					q.push(state_t(ni,nj,st.k+1,st.x+1));
+					mark[ni][nj] = true;
+				}
+			}
+		}
+	}
+	return best;
+}
+
+int main(){
+	//freopen("data.in", "r", stdin);
+	int w, h, t=1; 
+	while(scanf("%d %d", &h, &w)==2 && (w || h)){
+		//printf("%d %d\n",h,w);
+		for(int i=0; i<h; ++i)
+			scanf("%s", &grid[i]);
+		int best = 0;
+		for(int i=0; i<h; ++i){
+			for(int j=0; j<w; ++j){
+				if(grid[i][j] == 'A'){
+					best = max(best, f(i,j, w, h));
+				}
+			}
+		}
+		printf("Case %d: %d\n",t++, best);
+	}
+	return 0;	
+}

spoj_cpp_clean/ABCPATH/ABCPATH-16.cpp

@@ -0,0 +1,51 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+char a[51][51];
+int dp[51][51]={};
+
+int h,w;
+int dr[8] = {-1,-1,-1,0,0,1,1,1,};
+int dc[8] = {-1,1,0,-1,1,-1,1,0};
+
+int dfs(int r, int c){
+    if(dp[r][c]!=0)   return dp[r][c];
+    for(int i=0;i<8;i++){
+        if(r+dr[i]<0||c+dc[i]<0||r+dr[i]>=h||c+dc[i]>=w)   continue;
+        if((int)(a[r+dr[i]][c+dc[i]]-a[r][c])==1)  dp[r][c]=max(dp[r][c], 1+dfs(r+dr[i],c+dc[i]));
+    }
+    return dp[r][c];
+}
+
+int main(){
+    int t=1,ans=0,base=0;
+    cin>>h>>w;
+    while(h!=0&&w!=0){
+        base=0;
+        ans=0;
+        memset(dp,0,sizeof(dp));
+        for(int i=0;i<h;i++){
+            for(int j=0;j<w;j++){
+                cin>>a[i][j];
+            }
+        }
+        for(int i=0;i<h;i++){
+            for(int j=0;j<w;j++){
+                if(a[i][j]=='A'){
+                    base=1;
+                    ans=max(ans,dfs(i,j));
+                }
+            }
+        }
+        cout<<"Case "<<t++<<": "<<ans+base<<endl;
+        /*
+        for(int i=0;i<h;i++){
+            for(int j=0;j<w;j++){
+                cout<<dp[i][j]<<" ";
+            }
+            cout<<endl;
+        }*/
+        cin>>h>>w;
+    }
+}

spoj_cpp_clean/ABSP1/ABSP1-3.cpp

@@ -0,0 +1,47 @@
+#include<stdio.h>
+#include<iostream>
+#include<cmath>
+#include<algorithm>
+#include<cstring>
+#include<map>
+#include<set>
+#include<vector>
+#include<utility>
+#include<math.h>
+
+#define sd(x) scanf("%d",&x);
+#define sd2(x,y) scanf("%d %d",&x,&y);
+#define sd3(x,y,z) scanf("%d %d %d",&x,&y,&z);
+#define sull(x) scanf("%ull",&x);
+#define print(x) printf("%d\n",x);
+#define print2(x,y) printf("%d %d\n",x,y);
+#define print3(x,y,z) printf("%d %d %d\n",x,y,z);
+#define printull(x) printf("%ull\n",x);
+
+using namespace std;
+
+int main(){
+	int t, n, fact;
+	long long nums[10000], sum[10000], total;
+	sd(t);
+	while(t--){
+		sd(n);
+		if(n == 0 or n == 1){
+			printf("0\n");
+			continue;
+		}
+		for(int i = 0; i < n; i++){
+			scanf("%lld",&nums[i]);
+		}
+		sum[n-1] = nums[n-1];
+		for(int i = n-2; i >= 0; i--){
+			sum[i] = sum[i+1] + nums[i];
+		}
+		total = 0;
+		for(int i = 0; i < n-1; i++){
+			total += abs((n-i-1)*nums[i] - sum[i+1]);
+		}
+		printf("%lld\n",total);
+	}
+	return 0;
+}

spoj_cpp_clean/ABSYS/ABSYS-11.cpp

@@ -0,0 +1,71 @@
+/*
+ * Written by Nitin Kumar Maharana
+ * nitin.maharana@gmail.com
+ */
+
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+bool isNumber(char *str)
+{
+	bool flag = true;
+
+	for(int i = 0; str[i] != '\0'; i++)
+	{
+		if(str[i] < '0' || str[i] > '9')
+		{
+			flag = false;
+			break;
+		}
+	}
+
+	return flag;
+}
+
+int toNumber(char *str)
+{
+	int number;
+
+	number = 0;
+
+	for(int i = 0; str[i] != '\0'; i++)
+		number = (number * 10) + (str[i] - '0');
+
+	return number;
+}
+
+int main(void)
+{
+	int t;
+	char number1[30], number2[30], sum[30];
+	int n1, n2, summ;
+	char plus, equal;
+
+	cin >> t;
+
+	while(t--)
+	{
+		cin >> number1 >> plus >> number2 >> equal >> sum;
+
+		n1 = n2 = summ = -1;
+
+		if(isNumber(number1))
+			n1 = toNumber(number1);
+
+		if(isNumber(number2))
+			n2 = toNumber(number2);
+
+		if(isNumber(sum))
+			summ = toNumber(sum);
+
+		n1 = (n1 == -1) ? (summ - n2) : n1;
+		n2 = (n2 == -1) ? (summ - n1) : n2;
+		summ = (summ == -1) ? (n1 + n2) : summ;
+
+		cout << n1 << " + " << n2 << " = " << summ << endl;
+	}
+
+	return 0;
+}

spoj_cpp_clean/ABSYS/ABSYS-16.cpp

@@ -0,0 +1,40 @@
+#include<bits/stdc++.h>
+#define ll long long
+
+using namespace std;
+
+void solve(){
+    vector<string> s(5);
+    for(ll i=0;i<5;i++) cin>>s[i];
+    if(s[0].find("machula")!=string::npos){
+        ll x = stoi(s[2]);
+        ll y = stoi(s[4]);
+        cout<<y-x<<" ";
+        for(ll i=1;i<5;i++)
+            cout<<s[i]<<" ";
+        cout<<endl;
+    }
+    if(s[2].find("machula")!=string::npos){
+        ll x = stoi(s[0]);
+        ll y = stoi(s[4]);
+        cout<<s[0]<<" "<<s[1]<<" "<<y-x<<" ";
+        for(ll i=3;i<5;i++)
+            cout<<s[i]<<" ";
+        cout<<endl;
+    }
+    if(s[4].find("machula")!=string::npos){
+        ll x = stoi(s[0]);
+        ll y = stoi(s[2]);
+        for(ll i=0;i<4;i++)
+            cout<<s[i]<<" ";
+        cout<<y+x<<endl;
+    }
+}
+
+int main(){
+    ll t;
+    cin>>t;
+    while(t--)
+        solve();
+    return 0;
+}

spoj_cpp_clean/ABSYS/ABSYS-5.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <cstdio>
+#include <string>
+#include <cstring>
+#include <cstdlib>
+
+using namespace std;
+
+int main()
+{
+    int test,num1,num2,num3,i;
+    char str1[100],str2[100],str3[100],op1[2],op2[2];
+    cin>>test;
+    while(test--)
+    {
+        cin>>str1>>op1>>str2>>op2>>str3;
+        if(strchr(str1,'m')!=NULL)
+        {
+            num2=atoi(str2);
+            num3=atoi(str3);
+            num1=num3-num2;
+        }
+        else if(strchr(str2,'m')!=NULL)
+        {
+            num1=atoi(str1);
+            num3=atoi(str3);
+            num2=num3-num1;
+        }
+        else
+        {
+            num1=atoi(str1);
+            num2=atoi(str2);
+            num3=num1+num2;
+        }
+        cout<<num1<<" + "<<num2<<" = "<<num3<<endl;
+    }
+    return 0;
+}

spoj_cpp_clean/ABSYS/ABSYS-7.cpp

@@ -0,0 +1,102 @@
+#include <cmath>
+#include <cctype>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+#include <algorithm>
+ 
+#define MOD 1000000007LL
+#define LL long long
+#define ULL unsigned long long
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#define MIN(a,b) ((a)<(b)?(a):(b))
+#define ABS(x)   ((x)<0?-(x):(x))
+#define si(n) scanf("%d",&n)
+#define sf(n) scanf("%f",&n)
+#define sl(n) scanf("%lld",&n)
+#define slu(n) scanf("%llu",&n)
+#define sd(n) scanf("%lf",&n)
+#define ss(n) scanf("%s",n)
+#define pnl printf("\n")//print new line
+#define REP(n) for(int i=0;i<(n);i++)//repeat n times
+#define FOR(a,b) for(int i=(a);i<(b);i++)//end not included
+#define FORR(n) for(int i=(n);i>=0;i--)//reverse for
+ 
+using namespace std;
+ 
+int main()
+{
+    int t=1;
+    scanf("%d",&t);
+    while(t--)
+    {
+        char c;
+        int f1=0,f2=0,f3=0;
+        int n1=0,n2=0,n3=0;
+        int p=0;
+        scanf("\n%c",&c);
+        while(c!='\n')
+        {
+            if(p==0)
+            {
+                if(c>=48 && c<=57)
+                {
+                    n1=n1*10 + (c-48);
+                }
+                else
+                {
+                    p++;
+                    if(c=='m')
+                        f1=1;
+                    while(c!='+')
+                        scanf("%c",&c);
+                    scanf("%c",&c);
+                }
+            }
+            else if(p==1)
+            {
+                if(c>=48 && c<=57)
+                {
+                    n2=n2*10 + (c-48);
+                }
+                else
+                {
+                    p++;
+                    if(c=='m')
+                        f2=1;
+                    while(c!='=')
+                        scanf("%c",&c);
+                    scanf("%c",&c);
+                }
+            }
+            else if(p==2)
+            {
+                if(c>=48 && c<=57)
+                {
+                    n3=n3*10 + (c-48);
+                }
+                else
+                {
+                    p++;
+                    if(c=='m')
+                        f3=1;
+                }
+            }
+            scanf("%c",&c);
+        }
+        if(f1==1)
+        {
+            printf("%d + %d = %d\n",(n3-n2),n2,n3);
+        }
+        else if(f2==1)
+        {
+            printf("%d + %d = %d\n",n1,(n3-n1),n3);
+        }
+        else if(f3==1)
+        {
+            printf("%d + %d = %d\n",n1,n2,(n1+n2));
+        }
+    }
+	return 0;
+} 

spoj_cpp_clean/ABSYS/ABSYS-9.cpp

@@ -0,0 +1,118 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include <stdio.h>
+#include <string>
+#include <ctype.h>
+ 
+#define gc() getchar_unlocked()
+ 
+using namespace std;
+ 
+inline int first()
+{
+	string A;
+	char c;
+ 
+	c = gc();
+	while(isspace(c))
+		c = gc();
+ 
+	while(c!=' ')
+	{
+		if(isalpha(c))
+		{
+			while(c!=' ')
+				c = gc();
+			return -1;
+		}
+		A.push_back(c);
+		c = gc();
+	}
+ 
+	return stoi(A);
+}
+ 
+inline int second()
+{
+	string A;
+	char c;
+ 
+	gc();
+	gc();
+	c = gc();
+ 
+	while(c!=' ')
+	{
+		if(isalpha(c))
+		{
+			while(c!=' ')
+				c = gc();
+			return -1;
+		}
+		A.push_back(c);
+		c = gc();
+	}
+ 
+	return stoi(A);
+}
+ 
+inline int third()
+{
+	string A;
+	char c;
+ 
+	gc();
+	gc();
+	c = gc();
+ 
+	while(c!='\n' && c!=EOF)
+	{
+		if(isalpha(c))
+		{
+			while(c!='\n' && c!=EOF)
+				c = gc();
+			return -1;
+		}
+		A.push_back(c);
+		c = gc();
+	}
+ 
+	return stoi(A);
+}
+ 
+int main()
+{
+	int T;
+	int f, s, t;
+ 
+	//freopen("input.txt","r",stdin);
+ 
+	scanf("%d", &T);
+ 
+	while(T--)
+	{
+		f = first();
+		s = second();
+		t = third();
+ 
+		if(f == -1)
+			f = t - s;
+		if(s == -1)
+			s = t - f;
+		if(t == -1)
+			t = f + s;
+ 
+		printf("%d + %d = %d\n", f, s, t);
+	}
+ 
+	return 0;
+} 

spoj_cpp_clean/ACMAKER/ACMAKER-3.cpp

@@ -0,0 +1,93 @@
+#include<stdio.h>
+#include<iostream>
+#include<cmath>
+#include<algorithm>
+#include<cstring>
+#include<map>
+#include<set>
+#include<vector>
+#include<utility>
+#include<math.h>
+#include<sstream>
+
+#define sd(x) scanf("%d",&x);
+#define sd2(x,y) scanf("%d %d",&x,&y);
+#define sd3(x,y,z) scanf("%d %d %d",&x,&y,&z);
+#define sull(x) scanf("%ull",&x);
+#define print(x) printf("%d\n",x);
+#define print2(x,y) printf("%d %d\n",x,y);
+#define print3(x,y,z) printf("%d %d %d\n",x,y,z);
+#define printull(x) printf("%ull\n",x);
+
+using namespace std;
+
+// Uglyyyyyyyyyyyy
+
+int main(){
+	int n, i, j, k, dp[151][151], count[151][151], w;
+	count[0][0] = 1;
+	for(i = 1; i <= 150; i++)
+		count[0][i] = 0;
+	for(i = 1; i <= 150; i++)
+		count[i][0] = 1;
+	string input, acronym, up_acronym, word;
+	set<string> insig;
+	vector<string> words;
+	sd(n);
+	while(n != 0){
+		insig.clear();
+		for(i = 0; i < n; i++){
+			cin>>word;
+			insig.insert(word);
+		}
+		getline(cin,input);
+		while(getline(cin,input) and input != "LAST CASE"){
+			words.clear();
+			stringstream ss;
+			
+			ss<<input;
+			ss>>up_acronym;
+			acronym = "";
+			for(i = 0; i < up_acronym.length(); i++) acronym += tolower(up_acronym[i]);
+			
+			
+			while(ss>>word){
+				if(insig.find(word) == insig.end()){
+					words.push_back(word);
+				}
+			}
+			
+			int l1 = words.size(), l2 = acronym.length()	;
+			
+			for(i = 0; i <= l1; i++) 
+				for(j = 0; j <= l2; j++) 
+					dp[i][j] = 0;
+			
+			dp[0][0] = 1;
+			
+			for(i = 0; i < l1; i++){
+				for(j = 1; j <= l2; j++){
+					for(k = 1; k <= l2 - j + 1; k++){
+					
+						for(int p = 1; p <= words[i].length(); p++){
+							for(int q = 1; q <= k; q++){
+								count[p][q] = count[p-1][q];
+								if(words[i][p-1] == acronym[j+q-2]) count[p][q] += count[p-1][q-1];
+							}
+						}
+						w = count[words[i].length()][k];
+						dp[i+1][j+k-1] += w * dp[i][j-1];
+					}
+				}
+			}
+			if(dp[l1][l2]){
+				cout<<up_acronym<<" can be formed in "<<dp[l1][l2]<<" ways"<<endl;
+			}
+			else{
+				cout<<up_acronym<<" is not a valid abbreviation"<<endl;
+			}
+		}
+		sd(n);
+	}
+	return 0;
+}

spoj_cpp_clean/ACODE/ACODE-1.cpp

@@ -0,0 +1,57 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#define MAX_SIZE 5010
+
+char *input;
+int size;
+
+unsigned long long cache[MAX_SIZE];
+
+unsigned long long rec(int i) {
+    // std::cout << "i = " << i << std::endl;
+    if (i >= size - 1) {
+        if (i == size - 1 && input[i] == '0') return -1;
+        return 0;
+    }
+    if (cache[i] != -1) return cache[i];
+
+    unsigned long long ans;
+    switch (input[i]) {
+        case '0':
+            ans = - 1;
+            break;
+        case '2':
+            if (input[i+1] > '6') {
+                ans = rec(i + 1);
+                break;
+            }
+        case '1':
+            ans = 1 + rec(i + 1) + rec(i + 2);
+            break;
+        default:
+            ans = rec(i + 1);
+            break;
+    }
+
+    return cache[i] = ans;
+}
+
+int main() {
+    size_t max_size = MAX_SIZE;
+    input = (char*) malloc(sizeof(char) * (MAX_SIZE + 1));
+
+    while (true) {
+        size = getline(&input, &max_size, stdin);
+        --size;
+        input[size] = '\0';
+        // std::cout << "'" << input << "' " << size << " size" << std::endl;
+
+        memset(cache, -1, sizeof(unsigned long long) * MAX_SIZE);
+ 
+        if (input[0] == '0') break;
+
+        std::cout << 1 + rec(0) << std::endl;
+    }
+}

spoj_cpp_clean/ACODE/ACODE-11.cpp

@@ -0,0 +1,58 @@
+/*
+ * Written by Nitin Kumar Maharana
+ * nitin.maharana@gmail.com
+ */
+
+#include <iostream>
+#include <string>
+#include <map>
+
+using namespace std;
+
+string input;
+map<int, unsigned long long> memory;
+map<int, unsigned long long>::iterator it;
+int len;
+
+unsigned long long findNumDecoding(int index)
+{
+	if(index == len || index == len-1)
+		return 1ull;
+
+	it = memory.find(index);
+
+	if(it != memory.end())
+		return (it->second);
+
+	unsigned long long result;
+
+	if(input[index] > '2' || (input[index] == '2' && input[index+1] > '6') || (index+2 < len && input[index+2] == '0'))
+		result = findNumDecoding(index+1);
+	else if(input[index+1] == '0')
+		result = findNumDecoding(index+2);
+	else
+		result = (findNumDecoding(index+1) + findNumDecoding(index+2));
+
+	memory.insert(make_pair(index, result));
+
+	return result;
+}
+
+int main(void)
+{
+	cin >> input;
+
+	while(input != "0")
+	{
+		len = input.length();
+
+		cout << findNumDecoding(0) << endl;
+
+		input.clear();
+		memory.clear();
+
+		cin >> input;
+	}
+
+	return 0;
+}

spoj_cpp_clean/ACODE/ACODE-13.cpp

@@ -0,0 +1,61 @@
+#pragma warning(disable:4018)  // signed/unsigned mistatch
+#pragma warning(disable:4244)  // w64 to int cast
+#pragma warning(disable:4267)  // big to small -- possible loss of data
+#pragma warning(disable:4786)  // long identifiers
+#pragma warning(disable:4800)  // forcing int to bool
+#pragma warning(disable:4996)  // deprecations
+#include "assert.h"
+#include "ctype.h"
+#include "float.h"
+#include "math.h"
+#include "stdio.h"
+#include "string.h"
+#include "stdlib.h"
+#include "stdarg.h"
+#include "time.h"
+#include "algorithm"
+#include "numeric"
+#include "functional"
+#include "utility"
+#include "bitset"
+#include "vector"
+#include "list"
+#include "set"
+#include "map"
+#include "queue"
+#include "stack"
+#include "string"
+#include "sstream"
+#include "iostream"
+#define all(v) (v).begin(), (v).end()
+typedef long long i64;
+template <class T> void make_unique(T& v) {sort(all(v)); v.resize(unique(all(v)) - v.begin());}
+using namespace std;
+
+i64 memo[5001];
+bool mark[5001];
+char buffer[5001];
+int n;
+
+i64 f(int k){
+	if(k >= n)return 1;
+	if(buffer[k] == '0')return 0;
+	i64 &count = memo[k];
+	if(mark[k])return count;
+	mark[k] = true;
+	count = f(k+1);
+	if((buffer[k] == '1' || buffer[k] == '2') && k+2 <= n)
+		count += f(k+2);
+	return count;
+}
+
+int main(){
+	freopen("data.in","r",stdin);
+	while(scanf("%s", buffer) == 1 && buffer[0] != '0'){
+		n = strlen(buffer);
+		memset(mark,false,sizeof(mark));
+		i64 res = f(0);
+		printf("%lld\n",res);
+	}
+	return 0;
+}

spoj_cpp_clean/ACODE/ACODE-16.cpp

@@ -0,0 +1,38 @@
+//  [amitdu6ey]
+// g++ -std=c++11 -o2 -Wall filename.cpp -o filename
+#include <bits/stdc++.h>
+#define ll long long
+
+using namespace std;
+
+void solve(string a){
+    ll n = a.length();
+    vector<ll> dp(n,0);
+    dp[0]=1;
+    
+    ll num = (a[0]-'0')*10 + (a[1]-'0');
+    if(num<=26) dp[1]=2;
+    else dp[1]=1;
+    
+    for(int i=2;i<n;i++){
+        ll y = (a[i-1]-'0')*10 + (a[i]-'0');
+        if(y<=26){
+            dp[i]=dp[i-1]+dp[i-2];
+        }
+        else{
+            dp[i]=dp[i-1];
+        }
+    }
+    cout<<dp[n-1]<<"\n";
+    return;
+}
+
+int main(){
+    while(true){
+        string x;
+        cin>>x;
+        if(x=="0")  break;
+        solve(x);
+    }
+    return 0;
+}

spoj_cpp_clean/ACODE/ACODE-19.cpp

@@ -0,0 +1,63 @@
+#include <bits/stdc++.h>
+#define endl "\n"
+#define ll long long
+#define mod 1000000007
+#define MAX 1000001
+#define PI 3.14159265
+
+using namespace std;
+
+int main()
+{
+    ios_base::sync_with_stdio(0);
+    cin.tie(0); cout.tie(0);
+
+    //ll t;cin>>t;
+    ll dp[5001];
+    char num[5001];
+    while (true) {
+        cin >> num;
+        if (num[0] == '0') {
+            return 0;
+        }
+        int l = strlen(num);
+        dp[0] = 1;
+        if (l == 1) {
+            cout << "1" << endl;
+            continue;
+        }
+        dp[1] = 1;
+        int c1, c2;
+        c2 = num[0] - '0';
+        c1 = num[1] - '0';
+        if (c1 == 0) {
+            if (c2 == 1 || c2 == 2) {
+                dp[1] = 1;
+            }
+            else {
+                dp[1] = 0;
+            }
+        }
+        else {
+            if (c2 == 1 || (c2 == 2 && c1 <= 6)) {
+                dp[1] = 2;
+            }
+            else {
+                dp[1] = 1;
+            }
+        }
+        for (int i = 2; i < l; i++) {
+            dp[i] = 0;
+            c1 = num[i] - '0';
+            c2 = num[i - 1] - '0';
+            if (c1 != 0) {
+                dp[i] += dp[i - 1];
+            }
+            if (c2 == 1 || (c2 == 2 && c1 < 7)) {
+                dp[i] += dp[i - 2];
+            }
+        }
+        cout << dp[l - 1] << endl;
+    }
+    return 0;
+}

spoj_cpp_clean/ACODE/ACODE-5.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+#include <string>
+#include <map>
+
+// Evaluate for "226210", other than that the code is self explanatory
+using namespace std;
+
+map<int, long long>dp;
+
+int main()
+{
+    string input;
+    int i,strLength;
+    cin>>input;
+
+    while(input[0]!='0')
+    {
+        strLength=input.length();
+        dp[0]=1;
+        dp[1]=1;
+        for(i=1;i<strLength;i++)
+        {
+            if(input[i]!='0')
+            {
+                if(input[i-1]!='0'&&(input[i-1]-48)*10+(input[i]-48)<=26)
+                {
+                    dp[i+1]=dp[i]+dp[i-1];
+                }
+                else
+                    dp[i+1]=dp[i];
+            }
+            else
+                dp[i+1]=dp[i-1];
+        }
+        cout<<dp[i]<<endl;
+        cin>>input;
+    }
+    return 0;
+}

spoj_cpp_clean/ACODE/ACODE-8.cpp

@@ -0,0 +1,152 @@
+/***************************************************
+ * Problem Name : ACODE - Alphacode.cpp
+ * Problem Link : https://www.spoj.com/problems/ACODE/
+ * OJ           : Spoj
+ * Verdict      : AC
+ * Date         : 2020-02-19
+ * Problem Type : DP
+ * Author Name  : Saikat Sharma
+ * University   : CSE, MBSTU
+ ***************************************************/
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#include <climits>
+#include <cstring>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <queue>
+#include <list>
+#include <unordered_map>
+#include <unordered_set>
+#include <cstdlib>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <cassert>
+#include <map>
+#include <set>
+#include <cassert>
+#include <iomanip>
+#include <random>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+typedef long long ll;
+typedef unsigned long long ull;
+
+#define __FastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
+#define __FileRead freopen ("input.txt", "r", stdin)
+#define __FileWrite freopen ("output.txt", "w", stdout)
+#define SET(a,v) memset(a,v,sizeof(a))
+#define SZ(v) (int)v.size()
+#define pii pair<int,int>
+#define pil pair <int, ll>
+#define pli pair <ll, int>
+#define pll pair <ll, ll>
+#define debug cout <<"######\n"
+#define debug1(x) cout <<"### " << x << " ###\n"
+#define debug2(x,y) cout <<"# " << x <<" : "<< y <<" #\n"
+#define nl cout << "\n";
+#define sp cout << " ";
+#define sl(n) scanf("%lld", &n)
+#define sf(n) scanf("%lf", &n)
+#define si(n) scanf("%d", &n)
+#define ss(n) scanf("%s", n)
+#define pf(n) scanf("%d", n)
+#define pfl(n) scanf("%lld", n)
+#define all(v) v.begin(), v.end()
+#define rall(v) v.begin(), v.end()
+#define srt(v) sort(v.begin(), v.end())
+#define r_srt(v) sort(v.rbegin(), v.rend())
+#define rev(v) reverse(v.begin(), v.end())
+#define Sqr(x) ((x)*(x))
+#define Mod(x, m) ((((x) % (m)) + (m)) % (m))
+#define max3(a, b, c) max(a, max(b, c))
+#define min3(a, b, c) min(a, min(b, c))
+#define pb push_back
+#define mk make_pair
+#define MAX 100005
+#define INF 1000000009
+#define MOD 1000000007
+
+template<class T>
+using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
+template<typename T>
+using ordered_set  = tree<T, null_type, less<T>, rb_tree_tag,
+      tree_order_statistics_node_update>;
+
+template <typename T> string toString ( T Number ) {
+    stringstream ss;
+    ss << Number;
+    return ss.str();
+}
+template<typename T> int toInt (T str) {
+    stringstream ss;
+    ss << str;
+    int num;
+    ss >> num;
+    return num;
+}
+ll lcm (ll a, ll b) {
+    return a * b / __gcd (a, b);
+}
+/************************************ Code Start Here ******************************************************/
+const int MAX_N = 5005;
+
+string str;
+ll dp[MAX_N][105];
+
+ll fun (int pos, int x) {
+    if (pos >= (int) str.size() ) {
+        if (x <= 26 && x > 0) return 1LL;
+        else return 0LL;
+    }
+
+    ll &res = dp[pos][x];
+
+    if (res != -1) return res;
+
+    ll res1 = 0, res2 = 0;
+
+    if (str[pos] != '0') {
+        if (pos + 1 < (int) str.size() ) {
+            if (str[pos + 1] != '0') {
+                res1 = fun (pos + 1, str[pos] - '0');
+                int val = (str[pos] - '0') * 10 + (str[pos + 1] - '0');
+
+                if (val <= 26) res2 = fun (pos + 2, val);
+
+            } else {
+                int val = (str[pos] - '0') * 10 + (str[pos + 1] - '0');
+
+                if (val <= 26) res2 = fun (pos + 2, val);
+            }
+
+        } else {
+            res1 = fun (pos + 1, str[pos] - '0');
+        }
+    }
+
+    return res = res1 + res2;
+}
+
+int main () {
+    __FastIO;
+    //~ cout << setprecision (10);
+    //~ cout << fixed;
+    while (cin >> str) {
+        if (str == "0") break;
+
+        SET (dp, -1);
+        ll res = fun (0, 0);
+        cout << res << "\n";
+    }
+
+    return 0;
+}
+//1013

spoj_cpp_clean/ACODE/ACODE-9.cpp

@@ -0,0 +1,77 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include <stdio.h>
+#include <string.h>
+ 
+char str[50000];
+unsigned long long DP[50000];
+ 
+bool init()
+{
+	scanf("%s", str);
+ 
+	if(strcmp(str, "0")==0)
+		return 0;
+ 
+	memset(DP, 0, sizeof(DP));
+ 
+	return 1;
+}
+ 
+ 
+inline bool valid(int i, int j)
+{
+	if(i==j)
+	{
+		if(str[i]=='0')
+			return 0;
+		return 1;
+	}
+ 
+	if(str[i]=='0')
+		return 0;
+ 
+	if((str[i]-'0')*10 + (str[j]-'0') <=26)
+		return 1;
+ 
+	return 0;
+}
+ 
+int main()
+{
+	int i;
+ 
+	//freopen("input.txt","r",stdin);
+ 
+	while(init())
+	{
+		DP[0]=1;
+		
+		if(valid(1, 1))
+			DP[1]+=DP[0];
+		if(valid(0, 1))
+			DP[1]++;
+ 
+		for(i=2; i<strlen(str); i++)
+		{
+			if(valid(i, i))
+				DP[i]+=DP[i-1];
+			if(valid(i-1, i))
+				DP[i]+=DP[i-2];
+		}
+ 
+		printf("%lld\n", DP[strlen(str)-1]);
+	}
+ 
+ 
+	return 0;
+} 

spoj_cpp_clean/ACP10D/ACP10D-13.cpp

@@ -0,0 +1,62 @@
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <queue>
+#include <map>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+using namespace std;
+typedef long long i64;
+const int INF = 0x3f3f3f3f;
+
+int costs[100002][3];
+int memo[100002][3];
+bool mark[100002][3];
+
+int f(int n, int i, int j){
+	if(i == n-1 && j == 1)return costs[i][j];
+	int &best = memo[i][j];
+	if(mark[i][j])return best;
+	mark[i][j] = true;
+	best = INF;
+
+	//trans
+	if(j == 0){
+		best = min (best, f(n,i,j+1) + costs[i][j]);
+		if(i+1 < n){
+			best = min(best, f(n, i+1, j) + costs[i][j]);
+			best = min(best, f(n, i+1, j+1) + costs[i][j]);
+		}
+	}else if(j == 1){
+		best = min(best, f(n,i,j+1) + costs[i][j]);
+		if(i+1 < n){
+			best = min(best, f(n, i+1, j-1) + costs[i][j]);
+			best = min(best, f(n, i+1, j) + costs[i][j]);
+			best = min(best, f(n, i+1, j+1) + costs[i][j]);
+		}
+	}else{
+		if(i+1 < n){
+			best = min(best, f(n, i+1, j-1)+ costs[i][j]);
+			best = min(best, f(n, i+1, j) + costs[i][j]);
+		}
+	}
+	return best;
+}
+
+int main(){
+	//freopen("data.in", "r", stdin);
+	int n;
+	for(int k=1; scanf("%d", &n)==1 && n; ++k){
+		for(int i=0; i<n; ++i){
+			scanf("%d %d %d", &costs[i][0], &costs[i][1], &costs[i][2]);
+		}
+		memset(mark, false, sizeof(mark));
+		int res = f(n, 0, 1);
+		printf("%d. %d\n",k,res);
+	}
+	return 0;
+}

spoj_cpp_clean/ACPC10A/ACPC10A-11.cpp

@@ -0,0 +1,27 @@
+/*
+ * Written by Nitin Kumar Maharana
+ * nitin.maharana@gmail.com
+ */
+
+#include <iostream>
+
+using namespace std;
+
+int main(void)
+{
+	int a1, a2, a3;
+
+	cin >> a1 >> a2 >> a3;
+
+	while(a1 != 0 || a2 != 0 || a3 != 0)
+	{
+		if((a3 - a2) == (a2 - a1))
+			cout << "AP " << (a3 + (a2-a1)) << endl;
+		else
+			cout << "GP " << (a3 * (a2/a1)) << endl;
+
+		cin >> a1 >> a2 >> a3;		
+	}
+
+	return 0;
+}

spoj_cpp_clean/ACPC10A/ACPC10A-13.cpp

@@ -0,0 +1,48 @@
+#pragma warning(disable:4018)  // signed/unsigned mistatch
+#pragma warning(disable:4244)  // w64 to int cast
+#pragma warning(disable:4267)  // big to small -- possible loss of data
+#pragma warning(disable:4786)  // long identifiers
+#pragma warning(disable:4800)  // forcing int to bool
+#pragma warning(disable:4996)  // deprecations
+#include "assert.h"
+#include "ctype.h"
+#include "float.h"
+#include "math.h"
+#include "stdio.h"
+#include "string.h"
+#include "stdlib.h"
+#include "stdarg.h"
+#include "time.h"
+#include "algorithm"
+#include "numeric"
+#include "functional"
+#include "utility"
+#include "bitset"
+#include "vector"
+#include "list"
+#include "set"
+#include "map"
+#include "queue"
+#include "stack"
+#include "string"
+#include "sstream"
+#include "iostream"
+#define all(v) (v).begin(), (v).end()
+typedef long long i64;
+template <class T> void make_unique(T& v) {sort(all(v)); v.resize(unique(all(v)) - v.begin());}
+using namespace std;
+
+int main(){
+	freopen("data.in","r",stdin);
+	int a, b, c;
+	while(scanf("%d %d %d", &a, &b, &c)==3 &&(a||b||c)){
+		int rate = b - a;
+		if(b + rate == c){
+			printf("AP %d\n", c+rate);
+		}else{
+			rate = b/a;
+			printf("GP %d\n",c*rate);
+		}
+	}
+	return 0;
+}

spoj_cpp_clean/ACPC10A/ACPC10A-16.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include<stdio.h>
+#include<math.h>
+#define ld long double
+#define m 100000007
+using namespace std;
+void check(ld a1,ld a2,ld a3){
+    if(2*a2==(a1+a3)&&(a1!=0)&&(a2!=0)&&(a3!=0))
+    cout<<"AP"<<" "<<a3+(a3-a2)<<endl;
+    else if(a2==sqrt(a1*a3)&&(a1!=0)&&(a2!=0)&&(a3!=0))
+    cout<<"GP"<<" "<<a3*(a3/a2)<<endl;
+}
+ 
+int main() {
+	ld a1,a2,a3;
+	cin>>a1>>a2>>a3;
+	while(a1!=0 || a2!=0 || a3!=0){
+	   check(a1,a2,a3);
+	   cin>>a1>>a2>>a3;
+	}
+	
+	return 0;

spoj_cpp_clean/ACPC10A/ACPC10A-19.cpp

@@ -0,0 +1,83 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define endl "\n"
+#define MAX 100001
+#define mod 1000000007
+using namespace std;
+
+int main()
+{
+    ios_base::sync_with_stdio(0);
+    cin.tie(0);
+    cout.tie(0);
+    while(true){
+        int x,y,z;
+        cin>>x>>y>>z;
+        if(x==0 && y==0 && z==0){
+            break;
+        }
+        else{
+        	cout<<endl;
+        }
+
+        int d, r;
+        ll next;
+
+        if((y-x)==(z-y)){
+            // case of AP
+            d = y-x;
+            next = z + d;
+            cout<<"AP "<<next;
+            continue;
+        }
+        else{
+            // case of GP
+            if(x>0 && y>0){
+                if(y<x)//decreasing
+                {
+                    r = (x/y);
+                    next = (z/r);
+                }
+                else  // increasing
+                {
+                    r = (y/x);
+                    next = z*r;
+                }
+            }
+            else if(x<0 && y<0){ // negative numbers
+                if(y<x){  //increasing in negative numbers
+                    r = (y/x);
+                    next = z*r;
+                }
+                else{    // decreasing in negative numbers
+                    r = (x/y);
+                    next = (z/r);
+                }
+            }
+            else{
+                if(x<0){
+                    if(x<z){
+                        r = x/y;
+                        next = z/r;
+                    }
+                    else{
+                        r = y/x;
+                        next = z*r;
+                    }
+                }
+                else{
+                    if(x<z){
+                        r = y/x;
+                        next = z*r;
+                    }
+                    else{
+                        r = y/z;
+                        next = z/r;
+                    }
+                }
+            }
+            cout<<"GP "<<next;
+        }
+    }
+    return 0;
+}

spoj_cpp_clean/ACPC10A/ACPC10A-5.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+    int a,b,c,d;
+    cin>>a>>b>>c;
+    while(a!=0||b!=0||c!=0)
+    {
+        d=b-a;
+        if(d==(c-b))
+        {
+            cout<<"AP "<<(c+d)<<endl;
+        }
+        else
+        {
+            d=b/a;
+            cout<<"GP "<<(c*d)<<endl;
+        }
+        cin>>a>>b>>c;
+    }
+    return 0;
+}

spoj_cpp_clean/ACPC10A/ACPC10A-9.cpp

@@ -0,0 +1,38 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include<stdio.h>
+
+int main()
+{ 
+  int l,m,n;
+  
+  scanf("%d",&l);
+  scanf("%d",&m);
+  scanf("%d",&n);
+  
+  while(1)
+  {
+    if(m==0&&n==0&&l==0)
+     break;
+     
+    else if((2*m)==(n+l)) 
+      printf("AP  %d\n",(n+(m-l)));
+   
+    else
+      printf("GP  %d\n",(n*(m/l)));
+      
+    scanf("%d",&l);
+    scanf("%d",&m);
+    scanf("%d",&n);
+  } 
+  return 0;
+} 

spoj_cpp_clean/ACPC10D/ACPC10D-9.cpp

@@ -0,0 +1,89 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include<stdio.h>
+#include<limits.h>
+#define MAX 1000005
+typedef long long int LL;
+LL dp[MAX][4];
+LL arr[MAX][4];
+LL N,M;
+FILE* out;
+bool inbounds(int i,int j)
+{
+    if(i>=0 && i<=N && j>=0 && j<=M)
+    return true;
+    return false;
+}
+LL min(LL a,LL b)
+{
+    if(a>b)
+    return b;
+    return a;
+}
+void solve(int index)
+{
+    for(int i=0;i<N;i++){
+        for(int j=0;j<3;j++){
+            dp[i][j]=INT_MAX;
+        }
+    }
+    for(int i=0;i<3;i++) dp[0][i]=arr[0][i];
+ 
+   dp[1][0]=arr[0][1]+arr[1][0];
+   dp[1][1]=min((arr[0][1]+arr[1][1]),(arr[0][1]+arr[0][2]+arr[1][1]));
+   dp[1][2]=min((arr[0][1]+arr[1][2]),(arr[0][1]+arr[0][2]+arr[1][2]));
+ 
+    for(int i=1;i<N;i++){
+        for(int j=0;j<3;j++){
+            if(j==0){
+                dp[i][j+1]=min(dp[i][j+1],dp[i][j]+arr[i][j+1]);
+                dp[i+1][j+1]=min(dp[i+1][j+1],dp[i][j]+arr[i+1][j+1]);
+                dp[i+1][j]=min(dp[i+1][j],dp[i][j]+arr[i+1][j]);
+            }
+            else if(j==1){
+                dp[i+1][j-1]=min(dp[i+1][j-1],dp[i][j]+arr[i+1][j-1]);
+                dp[i+1][j]=min(dp[i+1][j],dp[i][j]+arr[i+1][j]);
+                dp[i+1][j+1]=min(dp[i+1][j+1],dp[i][j]+arr[i+1][j+1]);
+                dp[i][j+1]=min(dp[i][j+1],dp[i][j]+arr[i][j+1]);
+            }
+            else{
+                dp[i+1][j-1]=min(dp[i+1][j-1],dp[i][j]+arr[i+1][j-1]);
+                dp[i+1][j]=min(dp[i+1][j],dp[i][j]+arr[i+1][j]);
+            }
+        }
+    }
+    /*for(int i=0;i<N;i++){
+        for(int j=0;j<3;j++){
+            printf("%llu ",dp[i][j]);
+        }
+        printf("\n");
+    }*/
+    printf("%d. %lld\n",index,dp[N-1][1]);
+}
+int main()
+{
+    //FILE *fp=fopen("tri.in","r");
+    FILE *fp=stdin;
+    int index=1;
+   // out=fopen("out.txt","w");
+    fscanf(fp,"%lld",&N);
+    while(N!=0){
+        for(int i=0;i<N;i++){
+            for(int j=0;j<3;j++)
+            fscanf(fp,"%lld",&arr[i][j]);
+        }
+        solve(index);
+        index++;
+        fscanf(fp,"%lld",&N);
+    }
+    return 0;
+} 

spoj_cpp_clean/ACQUIRE/ACQUIRE-14.cpp

@@ -0,0 +1,112 @@
+// #pragma GCC optimize("Ofast,unroll-loops")
+// #pragma GCC target("avx,avx2,fma")
+
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+#define ull unsigned long long
+#define dd double
+#define ld long double
+#define sl(n) scanf("%lld", &n)
+#define si(n) scanf("%d", &n)
+#define sd(n) scanf("%lf", &n)
+#define pll pair <ll, ll>
+#define pii pair <int, int>
+#define mp make_pair
+#define pb push_back
+#define all(v) v.begin(), v.end()
+#define inf (1LL << 62)
+#define loop(i, start, stop, inc) for(ll i = start; i <= stop; i += inc)
+#define for1(i, stop) for(ll i = 1; i <= stop; ++i)
+#define for0(i, stop) for(ll i = 0; i < stop; ++i)
+#define rep1(i, start) for(ll i = start; i >= 1; --i)
+#define rep0(i, start) for(ll i = (start-1); i >= 0; --i)
+#define ms(n, i) memset(n, i, sizeof(n))
+#define casep(n) printf("Case %lld:", ++n)
+#define pn printf("\n")
+#define pf printf
+#define EL '\n'
+#define fastio std::ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
+
+const ll sz = 5e4 + 10;
+
+pii ara[sz], lst[sz];
+ll pnt[sz], dp[sz];
+
+struct Line {
+    ll m, c;
+} tree[4*sz];
+
+bool exist[4*sz];
+
+inline ll f(Line &line, ll x) {
+    return line.m*x + line.c;
+}
+
+void add(ll lo, ll hi, Line line, ll node)
+{
+    exist[node] = 1;
+
+    if(lo == hi) {
+        if(f(line, pnt[lo]) < f(tree[node], pnt[lo]))
+            tree[node] = line;
+        return;
+    }
+
+    ll mid = lo+hi >> 1;
+
+    bool l = f(line, pnt[lo]) < f(tree[node], pnt[lo]);
+    bool m = f(line, pnt[mid]) < f(tree[node], pnt[mid]);
+
+    if(m) swap(tree[node], line);
+
+    if(l != m) add(lo, mid, line, node<<1);
+    else add(mid +1, hi, line, node<<1|1);
+}
+
+ll query(ll lo, ll hi, ll idx, ll node)
+{
+    if(lo == hi)
+        return f(tree[node], pnt[idx]);
+
+    ll mid = lo+hi >> 1, ret = f(tree[node], pnt[idx]);
+
+    if(idx <= mid && exist[node<<1]) ret = min(ret, query(lo, mid, idx, node<<1));
+    else if(idx > mid && exist[node<<1|1]) ret = min(ret, query(mid+1, hi, idx, node<<1|1));
+
+    return ret;
+}
+
+int main()
+{
+    ll n;
+    cin >> n;
+
+    for1(i, n) {
+        si(ara[i].first), si(ara[i].second);
+    }
+    sort(ara+1, ara+n+1);
+
+    ll mxw = 0, idx = 0;
+    rep1(i, n) {
+        if(ara[i].second > mxw)
+            lst[++idx] = ara[i];
+
+        mxw = max(mxw, (ll)ara[i].second);
+    }
+    reverse(lst+1, lst+idx+1);
+
+    for1(i, idx) pnt[i] = lst[i].first;
+    for0(i, 4*sz) tree[i] = {0, inf};
+
+    for1(i, idx) {
+
+        add(1, idx, {lst[i].second, dp[i-1]}, 1);
+
+        dp[i] = query(1, idx, i, 1);
+    }
+
+    cout << dp[idx] << EL;
+
+    return 0;

spoj_cpp_clean/ACTIV/ACTIV-14.cpp

@@ -0,0 +1,83 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+#define mod 100000000
+
+ll dp[100009];
+
+struct node {
+    ll l, r;
+} ara[100009];
+
+bool operator <(node a, node b)
+
+{
+    if(a.l != b.l)
+        return a.l < b.l;
+    return a.r < b.r;
+}
+
+ll n;
+
+ll solve(ll i)
+
+{
+    if(i > n)
+        return 0;
+
+    if(dp[i] != -1)
+        return dp[i];
+
+    ll ret = solve(i + 1) % mod;
+    node tmp = ara[i];
+    ll pos = n + 1, lo = i + 1, hi = n;
+
+    while(lo <= hi) {
+        ll mid = (lo + hi) / 2;
+
+        if(ara[mid].l < ara[i].r)
+            lo = mid + 1;
+        else {
+            pos = mid;
+            hi = mid - 1;
+        }
+    }
+
+    //cout << ara[i].r << "  " << ara[pos].r << endl;
+    ret = (ret + 1 + solve(pos)) % mod;
+
+    return dp[i] = ret;
+}
+
+int main()
+
+{
+    while(scanf("%lld", &n) && n != -1) {
+
+        memset(dp, -1, sizeof(dp));
+
+        for(ll i = 1; i <= n; i++)
+            scanf("%lld %lld", &ara[i].l, &ara[i].r);
+
+        sort(ara + 1, ara + n + 1);
+
+        ll ans = solve(1);
+
+        ll num = ans, cnt = 0;
+        if(num == 0)
+            cnt++;
+        while(num != 0) {
+            num /= 10;
+            cnt++;
+        }
+
+        ll rem = 8 - cnt;
+        for(ll i = 1; i <= rem; i++)
+            printf("0");
+
+        printf("%lld\n", ans);
+    }
+
+    return 0;
+}

spoj_cpp_clean/ADABRANC/ADABRANC-14.cpp

@@ -0,0 +1,96 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+#define pb push_back
+
+struct node {
+    ll a, b, c;
+    node(ll _a, ll _b, ll _c) {
+        a = _a;
+        b = _b;
+        c = _c;
+    }
+};
+
+bool operator <(node a, node b) {
+    return a.c > b.c;
+}
+vector <node> edge;
+
+struct quer {
+    ll a, w, i;
+    quer(ll _a, ll _w, ll _i) {
+        a = _a;
+        w = _w;
+        i = _i;
+    }
+};
+
+bool operator <(quer a, quer b) {
+    return a.w > b.w;
+}
+
+vector <quer> qry;
+
+ll ans[300009], par[200009], sz[200009];
+
+ll findr(ll u)
+
+{
+    if(par[u] == u)
+        return u;
+    return par[u] = findr(par[u]);
+}
+
+int main()
+
+{
+    ll n, m, q;
+    cin >> n >> m >> q;
+
+    for(ll i = 0; i < n; i++) {
+        par[i] = i;
+        sz[i] = 1;
+    }
+
+    for(ll i = 1; i <= m; i++) {
+        ll a, b, c;
+        scanf("%lld %lld %lld", &a, &b, &c);
+        edge.push_back( node(a, b, c) );
+    }
+
+    sort(edge.begin(), edge.end());
+
+    for(ll i = 1; i <= q; i++) {
+        ll a, c;
+        scanf("%lld %lld", &a, &c, &i);
+        qry.pb( quer(a, c, i) );
+    }
+    sort(qry.begin(), qry.end());
+
+    ll j = 0;
+    for(ll i = 0; i < q; i++) {
+
+        for(; j < edge.size(); j++) {
+            if(edge[j].c < qry[i].w)
+                break;
+
+            ll u = findr(edge[j].a);
+            ll v = findr(edge[j].b);
+
+            if(u == v)
+                continue;
+
+            par[v] = u;
+            sz[u] += sz[v];
+        }
+
+        ans[ qry[i].i ] = sz[ findr(qry[i].a) ];
+    }
+
+    for(ll i = 1; i <= q; i++)
+        printf("%lld\n", ans[i]);
+
+    return 0;
+}

spoj_cpp_clean/ADACOINS/ADACOINS-14.cpp

@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+
+bitset <100009> posSum;
+ll cumsum[100009];
+
+int main()
+
+{
+    ll n, q;
+    cin >> n >> q;
+
+    posSum[0] = 1;
+    for(ll i = 1; i <= n; i++) {
+        ll in;
+        scanf("%lld", &in);
+        posSum |= (posSum << in);
+    }
+
+    for(ll i = 1; i <= 100000; i++)
+        cumsum[i] = posSum[i] + cumsum[i - 1];
+
+    for(ll i = 1; i <= q; i++) {
+        ll l, r;
+        scanf("%lld %lld", &l, &r);
+        printf("%lld\n", cumsum[r] - cumsum[l - 1]);
+    }
+
+    return 0;
+}

spoj_cpp_clean/ADACYCLE/ADACYCLE-14.cpp

@@ -0,0 +1,94 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll int
+#define pii pair <int, int>
+const int inf = 1e9;
+ll mat[2009][2009];
+vector <ll> g[2009];
+vector <pii> newinp[2009];
+ll dist[2009], ans[2009];
+
+struct node {
+    ll u, c;
+};
+
+bool operator <(node a, node b)
+
+{
+    return a.c > b.c;
+}
+
+int main()
+
+{
+    ll n;
+    scanf("%d", &n);
+    for(ll i = 1; i <= n; i++) {
+        for(ll j = 1; j <= n; j++) {
+            scanf("%d", &mat[i][j]);
+            if(mat[i][j]) {
+                newinp[i].push_back(pii(i, j));
+                newinp[j].push_back(pii(i, j));
+                g[i].push_back(j);
+            }
+        }
+    }
+
+    for(ll i = 1; i <= n; i++) {
+        if(mat[i][i]) {
+            ans[i] = 1;
+            continue;
+        }
+
+        for(ll j = 0; j <= 2005; j++)
+            dist[j] = inf;
+
+        for(ll j = 0; j < newinp[i].size(); j++) {
+            ll u = newinp[i][j].first, v = newinp[i][j].second;
+            if(u == i)
+                g[2001].push_back(v);
+            else
+                g[u].push_back(2001);
+        }
+
+        priority_queue <node> pq;
+        pq.push({i, 0});
+        dist[i] = 0;
+        while(!pq.empty()) {
+            node u = pq.top();
+            pq.pop();
+
+            if(dist[u.u] != u.c)
+                continue;
+            for(ll v: g[u.u]) {
+                if(1 + u.c < dist[v]) {
+                    dist[v] = 1 + u.c;
+                    pq.push({v, dist[v]});
+                }
+            }
+        }
+        if(dist[2001] != inf)
+            ans[i] = dist[2001];
+
+        g[2001].clear();
+        for(ll j = 0; j < newinp[i].size(); j++) {
+            ll u = newinp[i][j].first, v = newinp[i][j].second;
+            if(u != i) {
+                ll last = g[u].size() - 1;
+                while(g[u][last] == 2001 && last >= 0) {
+                    g[u].pop_back();
+                    last--;
+                }
+            }
+        }
+    }
+
+    for(ll i = 1; i <= n; i++) {
+        if(ans[i] > 0)
+            printf("%d\n", ans[i]);
+        else
+            printf("NO WAY\n");
+    }
+
+    return 0;

spoj_cpp_clean/ADADUNG/ADADUNG-9.cpp

@@ -0,0 +1,59 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include <iostream>
+#include <cstring>
+
+#define ll long long
+#define MAXN 10000007
+using namespace std;
+
+const ll MOD = 1000000007;
+ll memo[MAXN];
+
+ll derangement(ll num)
+{
+	if (num <= 1)
+		return 0;
+
+	if (num == 2)
+		return 1LL;
+
+	if (memo[num])
+		return memo[num];
+
+	ll temp = derangement(num - 1) + derangement(num - 2);
+
+	temp %= MOD;
+
+	memo[num] = (num - 1) * temp;
+	memo[num] %= MOD;
+
+	return memo[num];
+}
+
+int main()
+{
+//	freopen("input.txt", "r", stdin);
+	ios::sync_with_stdio(0);
+
+	int T, N;
+
+	cin >> T;
+
+	while (T--)
+	{
+		cin >> N;
+		cout << derangement(N) << "\n";
+	}
+
+	return 0;
+}

spoj_cpp_clean/ADAFIELD/ADAFIELD-14.cpp

@@ -0,0 +1,66 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+
+int main()
+
+{
+    ll t;
+    cin >> t;
+    while(t--) {
+        ll n, m, q, line, state, px, py, nx, ny, mx, mxd, mxx;
+        scanf("%lld %lld %lld", &n, &m, &q);
+        set <ll> x, y;
+        multiset <ll> dif, difx;
+
+        set <ll> :: iterator it1, it2;
+        multiset <ll> :: iterator it3;
+
+        x.insert(0), x.insert(n);
+        y.insert(0), y.insert(m);
+        dif.insert(m);
+        difx.insert(n);
+
+        for(ll i = 1; i <= q; i++) {
+            scanf("%lld %lld", &state, &line);
+            if(state == 0) {
+                if( x.find(line) == x.end()) {
+
+                    it3 = x.lower_bound(line);
+                    px = *(--it3);
+
+                    it3 = x.upper_bound(line);
+                    nx = *it3;
+
+                    difx.erase( difx.find(nx - px) );
+                    difx.insert(line - px);
+                    difx.insert(nx - line);
+                    x.insert(line);
+                }
+            }
+            else if(y.find(line) == y.end()) {
+
+                it3 = y.lower_bound(line);
+                py = *(--it3);
+
+                it3 = y.upper_bound(line);
+                ny = *it3;
+
+                //cout << ny << "  " << py << "  " << line << endl;
+                dif.erase( dif.find(ny - py) );
+                dif.insert(line - py);
+                dif.insert(ny - line);
+                y.insert(line);
+            }
+
+            mxd = *(--dif.end());
+            mxx = *(--difx.end());
+            mx = mxd * mxx;
+
+            printf("%lld\n", mx);
+        }
+    }
+
+    return 0;
+}

spoj_cpp_clean/ADAGAME/ADAGAME-14.cpp

@@ -0,0 +1,117 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+
+ll dp[10009][105][2], n, mv;
+
+ll solve(ll num, ll mov, ll state)
+
+{
+    if(mov > mv) {
+        if(num > n) {
+            if(state == 0)
+                return 1;
+            else
+                return 0;
+        }
+        else {
+            if(state == 0)
+                return 0;
+            else
+                return 1;
+        }
+    }
+
+    ll &ret = dp[num][mov][state];
+    if(ret != -1)
+        return ret;
+
+    ll rt = 0;
+    if(num > 999) {
+        if(num % 10 != 9)
+            rt |= !solve(num + 1, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 9, mov + 1, state ^ 1);
+
+        if(num % 100 < 90)
+            rt |= !solve(num + 10, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 90, mov + 1, state ^ 1);
+
+        if(num % 1000 < 900)
+            rt |= !solve(num + 100, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 900, mov + 1, state ^ 1);
+
+        if(num % 10000 < 9000)
+            rt |= !solve(num + 1000, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 9000, mov + 1, state ^ 1);
+    }
+    else if(num > 99) {
+        if(num % 10 != 9)
+            rt |= !solve(num + 1, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 9, mov + 1, state ^ 1);
+
+        if(num % 100 < 90)
+            rt |= !solve(num + 10, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 90, mov + 1, state ^ 1);
+
+        if(num % 1000 < 900)
+            rt |= !solve(num + 100, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 900, mov + 1, state ^ 1);
+
+        rt |= !solve(num + 1000, mov + 1, state ^ 1);
+    }
+
+    else if(num > 9) {
+        if(num % 10 != 9)
+            rt |= !solve(num + 1, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 9, mov + 1, state ^ 1);
+
+        if(num % 100 < 90)
+            rt |= !solve(num + 10, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 90, mov + 1, state ^ 1);
+
+        rt |= !solve(num + 100, mov + 1, state ^ 1);
+        rt |= !solve(num + 1000, mov + 1, state ^ 1);
+    }
+
+    else {
+        if(num % 10 != 9)
+            rt |= !solve(num + 1, mov + 1, state ^ 1);
+        else
+            rt |= !solve(num - 9, mov + 1, state ^ 1);
+
+        rt |= !solve(num + 10, mov + 1, state ^ 1);
+        rt |= !solve(num + 100, mov + 1, state ^ 1);
+        rt |= !solve(num + 1000, mov + 1, state ^ 1);
+    }
+
+    //cout << num << "  " << rt << "  " << state << endl;
+    return ret = rt;
+}
+
+int main()
+
+{
+    ll t;
+    cin >> t;
+    while(t--) {
+        memset(dp, -1, sizeof(dp));
+        scanf("%lld %lld", &n, &mv);
+
+        if( solve(n, 1, 0) == 1)
+            printf("Ada\n");
+        else
+            printf("Vinit\n");
+    }
+
+    return 0;
+}

spoj_cpp_clean/ADAGAME/ADAGAME-9.cpp

@@ -0,0 +1,111 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include <stdio.h>
+#include <string.h>
+ 
+#define gc() getchar()
+using namespace std;
+ 
+short a, b, c, d;
+int memo[10][10][10][10][107];	//0 = ada wins
+int N;
+ 
+inline void init()
+{
+	a = gc() - '0';
+	b = gc() - '0';
+	c = gc() - '0';
+	d = gc() - '0';
+ 
+	scanf("%d\n", &N);
+ 
+	memset(memo, -1, sizeof(memo));
+}
+ 
+inline int inc(int num)
+{
+	if (num != 9)
+		return num + 1;
+ 
+	return 0;
+}
+ 
+bool solve(int aa, int bb, int cc, int dd, int n, bool player) //0 = ada, 1 = vinit
+{
+	if (memo[aa][bb][cc][dd][n] != -1)
+		return memo[aa][bb][cc][dd][n];
+ 
+	if (!n)
+	{
+		if (aa * 1000 + bb * 100 + cc * 10 + d > a * 1000 + b * 100 + c * 10 + d)
+		{
+			memo[aa][bb][cc][dd][0] = 0;
+			return 0;
+		}
+ 
+		else
+		{
+			memo[aa][bb][cc][dd][0] = 1;
+			return 1;
+		}
+	}
+ 
+	if (!player) // an pezei o ada
+	{
+		if (!solve(inc(aa), bb, cc, dd, n - 1, !player) || !solve(aa, inc(bb), cc, dd, n - 1, !player) || !solve(aa, bb, inc(cc), dd, n - 1, !player) || !solve(aa, bb, cc, inc(dd), n - 1, !player))
+		{
+			memo[aa][bb][cc][dd][n] = 0;
+			return 0;
+		}
+ 
+		else
+		{
+			memo[aa][bb][cc][dd][n] = 1;
+			return 1;
+		}
+	}
+ 
+	else	//an pezei o vinit
+	{
+		if (solve(inc(aa), bb, cc, dd, n - 1, !player) || solve(aa, inc(bb), cc, dd, n - 1, !player) || solve(aa, bb, inc(cc), dd, n - 1, !player) || solve(aa, bb, cc, inc(dd), n - 1, !player))
+		{
+			memo[aa][bb][cc][dd][n] = 1;
+			return 1;
+		}
+ 
+		else
+		{
+			memo[aa][bb][cc][dd][n] = 0;
+			return 0;
+		}
+	}
+}
+ 
+int main()
+{
+	int T;
+ 
+//	freopen("input.txt", "r", stdin);
+ 
+	scanf("%d\n", &T);
+ 
+	while (T--)
+	{
+		init();
+		if (!solve(a, b, c, d, N, 0))
+			printf("Ada\n");
+		else
+			printf("Vinit\n");
+	}
+ 
+	return 0;
+} 

spoj_cpp_clean/ADAGAME2/ADAGAME2-9.cpp

@@ -0,0 +1,107 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include <stdio.h>
+#include <ctype.h>
+ 
+#define gc() getchar_unlocked()
+#define MAXN 100000
+#define MAXM 30
+using namespace std;
+ 
+int N, M;
+int DP[MAXN + 7];
+int steps[MAXM + 7];
+ 
+inline int FAST_IO()
+{
+	char ch;
+	int val = 0;
+	ch = gc();
+	while (isspace(ch) && ch != EOF)
+		ch = gc();
+	val = 0;
+	while (isdigit(ch))
+	{
+		val = (val * 10) + (ch - '0');
+		ch = gc();
+	}
+	return val;
+}
+ 
+inline void init()
+{
+	int i;
+ 
+	N = FAST_IO();
+	M = FAST_IO();
+ 
+	for (i = 0; i < M; i++)
+		steps[i] = FAST_IO();
+}
+ 
+inline int grundy(int pos)
+{
+	int i;
+	bool a[50] = { 0 };
+ 
+	for (i = 0; i < M; i++)
+		if (steps[i] <= pos)
+			a[DP[pos - steps[i]]] = 1;
+ 
+	for (i = 0; i < 50; i++)
+		if (!a[i])
+			return i;
+ 
+	return 0;
+}
+ 
+inline void calc_dp()
+{
+	int i;
+ 
+	for (i = 1; i <= MAXN; i++)
+		DP[i] = grundy(i);
+}
+ 
+inline bool solve()
+{
+	int num, rval = 0;
+ 
+	while (N--)
+	{
+		num = FAST_IO();
+		rval ^= DP[num];
+	}
+ 
+	return rval;
+}
+ 
+int main()
+{
+	int T;
+ 
+//	freopen("input.txt", "r", stdin);
+ 
+	T = FAST_IO();
+ 
+	while (T--)
+	{
+		init();
+		calc_dp();
+		if (!solve())
+			printf("Vinit\n");
+		else
+			printf("Ada\n");
+	}
+ 
+	return 0;
+} 

spoj_cpp_clean/ADAINDEX/ADAINDEX-9.cpp

@@ -0,0 +1,136 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <ctype.h>
+ 
+#define gc() getchar()
+using namespace std;
+ 
+struct ver
+{
+	int words;
+	int prefixes;
+	struct ver **edges;
+};
+ 
+void initialize(ver **vertex)
+{
+	int i;
+ 
+	(*vertex) = (struct ver*)malloc(sizeof(struct ver));
+	(*vertex)->words = 0;
+	(*vertex)->prefixes = 0;
+	(*vertex)->edges = (struct ver**)malloc(sizeof(ver) * 26);
+ 
+	for (i = 0; i<26; i++)
+		(*vertex)->edges[i] = NULL;
+}
+ 
+void addword(ver **vertex, string &word, int pos = 0)
+{
+	if (pos == word.size())
+	{
+		(*vertex)->words++;
+		(*vertex)->prefixes++;
+		return;
+	}
+ 
+	char k = word[pos];
+ 
+	(*vertex)->prefixes++;
+	if ((*vertex)->edges[k - 'a'] == NULL)
+		initialize(&(*vertex)->edges[k - 'a']);
+ 
+	addword(&(*vertex)->edges[k - 'a'], word, pos + 1);
+}
+ 
+int countwords(ver *vertex, string &word, int pos = 0)
+{
+	if (pos == word.size())
+		return vertex->words;
+ 
+	char k = word[pos];
+ 
+	if (vertex->edges[k - 'a'] == NULL)
+		return 0;
+ 
+	return countwords(vertex->edges[k - 'a'], word, pos + 1);
+}
+ 
+int countprefixes(ver *vertex, string &word, int pos = 0)
+{
+	if (pos == word.size())
+		return vertex->prefixes;
+ 
+	char k = word[pos];
+ 
+	if (vertex->edges[k - 'a'] == NULL)
+		return 0;
+ 
+	return countprefixes(vertex->edges[k - 'a'], word, pos + 1);
+}
+ 
+inline void next_string(string &A)
+{
+	A.clear();
+ 
+	char c = gc();
+ 
+	while (isspace(c))
+		c = gc();
+ 
+	while (!isspace(c) && c != EOF)
+	{
+		A.push_back(c);
+		c = gc();
+	}
+}
+ 
+struct ver *trie;
+int N, Q;
+ 
+inline void init()
+{
+	string S;
+ 
+	scanf("%d %d", &N, &Q);
+ 
+	initialize(&trie);
+ 
+	while (N--)
+	{
+		next_string(S);
+		addword(&trie, S);
+	}
+}
+ 
+inline int query()
+{
+	string S;
+ 
+	next_string(S);
+	return countprefixes(trie, S);
+}
+ 
+int main()
+{
+//	freopen("input.txt", "r", stdin);
+ 
+	init();
+ 
+	while (Q--)
+		printf("%d\n", query());
+ 
+	return 0;
+} 

spoj_cpp_clean/ADAMATCH/ADAMATCH-14.cpp

@@ -0,0 +1,165 @@
+// #pragma GCC optimize("Ofast,unroll-loops")
+// #pragma GCC target("avx,avx2,fma")
+
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+#define ull unsigned long long
+#define dd double
+#define ld long double
+#define sl(n) scanf("%lld", &n)
+#define si(n) scanf("%d", &n)
+#define sd(n) scanf("%lf", &n)
+#define pll pair <ll, ll>
+#define pii pair <int, int>
+#define mp make_pair
+#define pb push_back
+#define all(v) v.begin(), v.end()
+#define inf (1LL << 62)
+#define loop(i, start, stop, inc) for(ll i = start; i <= stop; i += inc)
+#define for1(i, stop) for(ll i = 1; i <= stop; ++i)
+#define for0(i, stop) for(ll i = 0; i < stop; ++i)
+#define rep1(i, start) for(ll i = start; i >= 1; --i)
+#define rep0(i, start) for(ll i = (start-1); i >= 0; --i)
+#define ms(n, i) memset(n, i, sizeof(n))
+#define casep(n) printf("Case %lld:", ++n)
+#define pn printf("\n")
+#define pf printf
+#define EL '\n'
+#define fastio std::ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
+
+/***
+   * Multiply (7x^2 + 8x^1 + 9x^0) with (6x^1 + 5x^0)
+   * ans = 42x^3 + 83x^2 + 94x^1 + 45x^0
+   * A = {9, 8, 7}
+   * B = {5, 6}
+   * V = multiply(A,B)
+   * V = {45, 94, 83, 42}
+***/
+
+/*** Tricks
+   * Use vector < bool > if you need to check only the status of the sum
+   * Use bigmod if the power is over same polynomial && power is big
+   * Use long double if you need more precision
+   * Use long long for overflow
+***/
+typedef vector <int> vi;
+const double PI = 2.0 * acos(0.0);
+using cd = complex<double>;
+
+void fft(vector<cd> & a, bool invert = 0)
+
+{
+    int n = a.size();
+
+    for (int i = 1, j = 0; i < n; i++) {
+        int bit = n >> 1;
+        for (; j & bit; bit >>= 1)
+            j ^= bit;
+        j ^= bit;
+
+        if (i < j)
+            swap(a[i], a[j]);
+    }
+
+    for (int len = 2; len <= n; len <<= 1) {
+        double ang = 2 * PI / len * (invert ? -1 : 1);
+        cd wlen(cos(ang), sin(ang));
+        for (int i = 0; i < n; i += len) {
+            cd w(1);
+            for (int j = 0; j < len / 2; j++) {
+                cd u = a[i+j], v = a[i+j+len/2] * w;
+                a[i+j] = u + v;
+                a[i+j+len/2] = u - v;
+                w *= wlen;
+            }
+        }
+    }
+
+    if (invert) {
+        for (cd & x : a)
+            x /= n;
+    }
+}
+
+void ifft(vector <cd> & p)
+
+{
+    fft(p, 1);
+}
+
+vi multiply(vi const& a, vi const& b)
+{
+
+    vector<cd> fa(a.begin(), a.end()), fb(b.begin(), b.end());
+    int n = 1;
+    while (n < a.size() + b.size())
+        n <<= 1;
+    fa.resize(n);
+    fb.resize(n);
+
+    fft(fa);
+    fft(fb);
+    for (int i = 0; i < n; i++)
+        fa[i] *= fb[i];
+    ifft(fa);
+
+    vi result(n);
+    for (int i = 0; i < n; i++)
+        result[i] = round(fa[i].real());
+
+    return result;
+}
+
+const ll sz = 5e5 + 10, offset = 5e5;
+char s[sz], r[sz];
+
+vi num1[4], num2[4], res[4];
+
+int main()
+{
+    scanf("%s %s", s, r);
+
+    ll len1 = strlen(s), len2 = strlen(r);
+
+    for0(i, 4)
+        num1[i].resize(len1+1,0), num2[i].resize(len2+1+offset,0);
+
+    for(ll i = 0; s[i] != '\0'; i++) {
+        if(s[i] == 'A')
+            num1[0][i]++;
+        else if(s[i] == 'C')
+            num1[1][i]++;
+        else if(s[i] == 'T')
+            num1[2][i]++;
+        else
+            num1[3][i]++;
+    }
+
+    for(ll i = 0; r[i] != '\0'; i++) {
+
+        if(r[i] == 'A')
+            num2[0][-i + offset]++;
+        else if(r[i] == 'C')
+            num2[1][-i + offset]++;
+        else if(r[i] == 'T')
+            num2[2][-i + offset]++;
+        else
+            num2[3][-i + offset]++;
+    }
+
+    for0(i, 4) res[i] = multiply(num1[i], num2[i]);
+
+    ll ans = inf;
+    for(ll i = 0; i <= len1 - len2; i++) {
+        ll match = 0;
+        for0(j, 4) match += res[j][i+offset];
+
+        ans = min(ans, len2-match);
+    }
+
+    cout << ans << EL;
+
+    return 0;
+}

spoj_cpp_clean/ADAMOLD/ADAMOLD-14.cpp

@@ -0,0 +1,62 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+const ll inf = 1e18;
+
+ll n, k, ara[5009];
+
+ll xorcs[5009][5009], xorsum[5009][5009], dp[5009][5009];
+
+void solve(ll lo, ll hi, ll left, ll right, ll part)
+
+{
+    if(lo > hi) return;
+    ll mid = (lo + hi) / 2;
+
+    dp[mid][part] = inf;
+    ll indx;
+    for(ll i = left; i <= right && i <= mid; i++) {
+
+        ll c = dp[i - 1][part - 1] + xorsum[i][mid];
+        if(c < dp[mid][part]) {
+            dp[mid][part] = c;
+            indx = i;
+        }
+    }
+
+    solve(lo, mid - 1, left, indx, part);
+    solve(mid + 1, hi, indx, right, part);
+}
+
+int main()
+
+{
+    scanf("%lld %lld", &n, &k);
+    k++;
+    for(ll i = 1; i <= n; i++) scanf("%lld", &ara[i]);
+
+    for(ll i = 1; i <= n; i++) {
+        for(ll j = i + 1; j <= n; j++)
+            xorcs[i][j] = (ara[i] ^ ara[j]) + xorcs[i][j - 1];
+    }
+
+    for(ll i = 1; i <= n; i++) {
+        ll sum = 0;
+        for(ll j = i - 1; j >= 1; j--) {
+            sum += xorcs[j][i];
+            xorsum[j][i] = sum;
+        }
+    }
+
+    for(ll i = 0; i <= 5002; i++) {
+            dp[i][0] = inf;
+    }
+    dp[0][0] = 0;
+
+    for(ll i = 1; i <= k; i++)
+        solve(1, n, 1, n, i);
+
+    cout << dp[n][k] << endl;
+
+    return 0;

spoj_cpp_clean/ADAORANG/ADAORANG-14.cpp

@@ -0,0 +1,100 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define ll int
+#define pb push_back
+ll col[450009], fst[450009], start[450009], nodeOf[450009], tme[1000009], lca[3000009];
+vector <ll> graph[450009];
+ll TM = 1, indx = 0;
+
+bitset <255> cl[450009];
+
+void dfs(ll u, ll p)
+
+{
+    start[u] = TM;
+    nodeOf[TM] = u;
+    TM++;
+    tme[indx] = start[u];
+    fst[u] = indx;
+    indx++;
+
+    cl[u][ col[u] ] = 1;
+    for(ll i = 0; i < graph[u].size(); i++) {
+
+        if(graph[u][i] != p) {
+            dfs( graph[u][i] , u);
+            tme[indx++] = start[u];
+            cl[u] |= cl[ graph[u][i] ];
+        }
+    }
+}
+
+void build(ll lo, ll hi, ll node)
+
+{
+    if(lo == hi) {
+        lca[node] = tme[lo];
+        return;
+    }
+
+    ll mid = (lo + hi) / 2;
+    build(lo, mid, 2 * node);
+    build(mid + 1, hi, 2 * node + 1);
+    lca[node] = min(lca[2 * node], lca[2 * node + 1]);
+}
+
+ll query(ll lo, ll hi, ll left, ll right, ll node)
+
+{
+    if(lo > right || hi < left)
+        return 1e18;
+    if(lo >= left && hi <= right)
+        return lca[node];
+
+    ll mid = (lo + hi) / 2;
+    ll p1 = query(lo, mid, left, right, 2 * node);
+    ll p2 = query(mid + 1, hi, left, right, 2 * node + 1);
+
+    return min(p1, p2);
+}
+
+int main()
+
+{
+    ll t, n, q, root, u, v, l, r;
+    cin >> t;
+    while(t--) {
+       scanf("%d %d %d", &n, &q, &root);
+       for(ll i = 0; i < n; i++)
+            scanf("%d", &col[i]);
+
+       for(ll i = 1; i < n; i++) {
+            scanf("%d %d", &u, &v);
+            graph[u].pb(v);
+            graph[v].pb(u);
+        }
+
+        dfs(root, -1);
+        build(0, indx - 1, 1);
+        //cout << 5;
+        for(ll i = 1; i <= q; i++) {
+            scanf("%d %d", &l, &r);
+            //cout << fst[l] << "  " <<fst[r] << endl;
+            if(fst[l] > fst[r])
+                swap(l, r);
+            ll lc = query(0, indx - 1, fst[l], fst[r], 1);
+            //cout << cl[4].count() << endl;
+            printf("%d\n", cl[ nodeOf[lc] ].count());
+        }
+
+        for(ll i = 0; i < n; i++) {
+            graph[i].clear();
+            cl[i].reset();
+        }
+        TM = 1;
+        indx = 0;
+    }
+
+    return 0;
+}

spoj_cpp_clean/ADAORANG/ADAORANG-8.cpp

@@ -0,0 +1,196 @@
+/***************************************************
+ * Problem Name : ADAORANG - Ada and Orange Tree.cpp
+ * Problem Link : https://www.spoj.com/problems/ADAORANG/
+ * OJ           : Spoj
+ * Verdict      : AC
+ * Date         : 2019-09-19
+ * Problem Type : LCA, Bitset
+ * Author Name  : Saikat Sharma
+ * University   : CSE, MBSTU
+ ***************************************************/
+#include <iostream>
+#include <cstdio>
+#include <cmath>
+#include <algorithm>
+#include <climits>
+#include <cstring>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <queue>
+#include <list>
+#include <unordered_map>
+#include <unordered_set>
+#include <cstdlib>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <cassert>
+#include <map>
+#include <set>
+#include <cassert>
+#include <iomanip>
+#include <random>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+using namespace std;
+using namespace __gnu_pbds;
+typedef long long ll;
+typedef unsigned long long ull;
+
+#define __FastIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
+#define __FileRead freopen ("input.txt", "r", stdin)
+#define __FileWrite freopen ("output.txt", "w", stdout)
+#define SET(a,v) memset(a,v,sizeof(a))
+#define SZ(v) (int)v.size()
+#define pii pair<int,int>
+#define pil pair <int, ll>
+#define pli pair <ll, int>
+#define pll pair <ll, ll>
+#define debug cout <<"######\n"
+#define debug1(x) cout <<"### " << x << " ###\n"
+#define debug2(x,y) cout <<"# " << x <<" : "<< y <<" #\n"
+#define nl cout << "\n";
+#define sp cout << " ";
+#define sl(n) scanf("%lld", &n)
+#define sf(n) scanf("%lf", &n)
+#define si(n) scanf("%d", &n)
+#define ss(n) scanf("%s", n)
+#define pf(n) scanf("%d", n)
+#define pfl(n) scanf("%lld", n)
+#define all(v) v.begin(), v.end()
+#define rall(v) v.begin(), v.end()
+#define srt(v) sort(v.begin(), v.end())
+#define r_srt(v) sort(v.rbegin(), v.rend())
+#define rev(v) reverse(v.begin(), v.end())
+#define Sqr(x) ((x)*(x))
+#define Mod(x, m) ((((x) % (m)) + (m)) % (m))
+#define max3(a, b, c) max(a, max(b, c))
+#define min3(a, b, c) min(a, min(b, c))
+#define pb push_back
+#define mk make_pair
+#define MAX 450010
+#define INF 1000000009
+#define MOD 1000000007
+
+template<class T>
+using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
+template<typename T>
+using ordered_set  = tree<T, null_type, less<T>, rb_tree_tag,
+      tree_order_statistics_node_update>;
+
+template <typename T> string toString ( T Number ) {
+    stringstream ss;
+    ss << Number;
+    return ss.str();
+}
+template<typename T> int toInt (T str) {
+    stringstream ss;
+    ss << str;
+    int num;
+    ss >> num;
+    return num;
+}
+/************************************ Code Start Here ******************************************************/
+vector<vector<int> >adj;
+bitset<251> ans[MAX];
+int par[MAX], ar[MAX];
+int table[MAX][20];
+int level[MAX];
+void dfs (int u, int p) {
+    for (int v : adj[u]) {
+        if (v == p) continue;
+
+        par[v] = u;
+        level[v] = level[u] + 1;
+        dfs (v, u);
+        ans[u] |= ans[v];
+    }
+}
+void build (int n) {
+    for (int i = 1; i <= n; i++) {
+        table[i][0] = par[i];
+    }
+
+    for (int j = 1; (1 << j) < n; j++) {
+        for (int i = 1; i <= n; i++) {
+            if (table[i][j - 1] != -1) {
+                table[i][j] = table[table[i][j - 1]][j - 1];
+            }
+        }
+    }
+}
+int query (int u, int v) {
+    if (level[u] < level[v]) swap (u, v);
+
+    int k = log2 (level[u]);
+
+    for (int i = k; i >= 0; i--) {
+        if ( (level[u] - (1 << i) ) >= level[v]) {
+            u = table[u][i];
+        }
+    }
+
+    if (u == v) return u;
+
+    for (int i = k; i >= 0; i--) {
+        if (table[u][i] != -1 && table[u][i] != table[v][i]) {
+            u = table[u][i];
+            v = table[v][i];
+        }
+    }
+
+    return par[u];
+}
+
+int main () {
+    __FastIO;
+    //~ cout << setprecision (10);
+    //~ cout << fixed;
+    int tc, n, q, r;
+    cin >> tc;
+
+    while (tc--) {
+        cin >> n >> q >> r;
+        r++;
+        adj.resize (n + 1);
+
+        for (int i = 0; i <= n; i++) {
+            ans[i].reset();
+        }
+
+        for (int i = 1; i <= n; i++) {
+            cin >> ar[i];
+            ans[i][ar[i]] = 1;
+        }
+
+        for (int i = 1; i < n; i++) {
+            int u, v;
+            cin >> u >> v;
+            u++, v++;
+            adj[u].pb (v);
+            adj[v].pb (u);
+        }
+
+        par[r] = -1;
+        level[r] = 0;
+        SET (table, -1);
+        dfs (r, -1);
+        build (n);
+
+        while (q--) {
+            int u, v;
+            cin >> u >> v;
+            u++, v++;
+            int nod = query (u, v);
+            cout << ans[nod].count() << "\n";
+        }
+
+        for (int i = 0; i <= n; i++) {
+            adj[i].clear();
+        }
+    }
+
+    return 0;
+}

spoj_cpp_clean/ADAPLANT/ADAPLANT-20.cpp

@@ -0,0 +1,101 @@
+/**
+ *  Author  : Mr_Sohel
+ *  Task    :
+ *  Algo    : Multiset + Sliding Window
+**/
+#include <bits/stdc++.h>
+
+#define endl          '\n'
+#define sqr(x)        (x) * (x)
+#define gcd(x,y)      __gcd(x,y)
+#define lcm(x,y)      ((x/gcd(x,y)) * y)
+#define pb            push_back
+#define pf            push_front
+#define mk            make_pair
+#define fi            first
+#define se            second
+#define sz(x)         (int)x.size()
+#define all(x)        (x).begin(),(x).end()
+#define rall(x)       (x).rbegin(),(x).rend()
+#define prec(x)       fixed<<setprecision(x)
+#define min3(a,b,c)   min(a,min(b,c))
+#define max3(a,b,c)   max(a,max(b,c))
+#define min4(a,b,c,d) min(a,min(b,min(c,d)))
+#define max4(a,b,c,d) max(a,max(b,max(c,d)))
+#define unsyncIO      ios_base::sync_with_stdio(false); cin.tie(nullptr)
+
+using namespace std;
+
+using ll = long long;
+using db = double;
+using ld = long double;
+using ull = unsigned long long;
+using pii = pair<int, int>;
+using pll = pair<ll, ll>;
+
+const ld PI = acos((ld) - 1);
+const int MOD = 1e9 + 7;
+const ll INF = 2e18 + 1;
+const ld EPS = 1e-9;
+const int MX = 1e5 + 2;
+
+#ifdef LOCAL
+#define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
+template < typename Arg1 >
+void __f(const char* name, Arg1&& arg1) {
+	cerr << name << " = " << arg1 << endl;
+}
+template < typename Arg1, typename... Args>
+void __f(const char* names, Arg1&& arg1, Args&&... args) {
+	const char* comma = strchr(names + 1, ',');
+	cerr.write(names, comma - names) << " = " << arg1 << " | ";
+	__f(comma + 1, args...);
+}
+#else
+#define debug(...)
+#endif
+
+int a[MX];
+
+int main() {
+
+#ifdef LOCAL
+	clock_t tStart = clock();
+	freopen("in.txt", "r", stdin);
+	freopen("out.txt", "w", stdout);
+#endif
+	unsyncIO;
+	int t; cin >> t;
+	while (t--) {
+		int n, k;
+		cin >> n >> k;
+		for (int i = 0; i < n; i++) cin >> a[i];
+		int i = 0, j = k + 1, ans = 0;
+		multiset<int> mp; // i wil try with multimap later
+		for (i = 0; i <= j and i < n; i++) {
+			mp.insert(a[i]);
+		}
+		i = 0;
+		auto f = mp.begin(), l = --mp.end();
+		// l--;
+		ans = max(ans, *l - *f);
+		while (j < n) {
+			f = mp.begin(), l = --mp.end();
+			ans = max(ans, (*l - *f));
+			/*for (auto in : mp) {
+				cout << in << " ";
+			}
+			cout << "ans = " << ans << endl;*/
+			auto x = mp.find(a[i]);
+			mp.erase(x);
+			j++;
+			i++;
+			mp.insert(a[j]);
+		}
+		cout << ans << endl;
+	}
+#ifdef LOCAL
+	cerr << "\nRuntime: " << (ld) (clock() - tStart) / CLOCKS_PER_SEC << " Seconds" << endl;
+#endif
+	return 0;
+}

spoj_cpp_clean/ADAPLUS/ADAPLUS-9.cpp

@@ -0,0 +1,119 @@
+/*
+****************************************************************
+****************************************************************
+-> Coded by Stavros Chryselis				   
+-> Visit my github for more solved problems over multiple sites 
+-> https://github.com/StavrosChryselis			  
+-> Feel free to email me at stavrikios@gmail.com	
+****************************************************************
+****************************************************************
+*/
+
+#include <stdio.h>
+#include <ctype.h>
+#include <algorithm>
+#include <string.h>
+ 
+#define gc() getchar()
+#define MAXN 2048
+using namespace std;
+ 
+inline char next_char()
+{
+	char c = gc();
+ 
+	while (isspace(c))
+		c = gc();
+ 
+	return c;
+}
+ 
+char board[MAXN][MAXN];
+int maxleft[MAXN][MAXN];
+int maxright[MAXN][MAXN];
+int maxup[MAXN][MAXN];
+int maxdown[MAXN][MAXN];
+ 
+int N;
+ 
+inline void init()
+{
+	int i, j;
+ 
+	scanf("%d", &N);
+ 
+	for (i = 1; i <= N; i++)
+		for (j = 1; j <= N; j++)
+			board[i][j] = next_char();
+ 
+	memset(maxleft, 0, sizeof(maxleft));
+	memset(maxright, 0, sizeof(maxright));
+	memset(maxdown, 0, sizeof(maxdown));
+	memset(maxup, 0, sizeof(maxup));
+ 
+	for (i = 1; i <= N; i++)
+		for (j = 1; j <= N; j++)
+		{
+			if (board[i][j] == '#')
+				maxleft[i][j] = maxleft[i][j - 1] + 1;
+			else
+				maxleft[i][j] = 0;
+		}
+ 
+	for (i = 1; i <= N; i++)
+		for (j = N; j >= 1; j--)
+		{
+			if (board[i][j] == '#')
+				maxright[i][j] = maxright[i][j + 1] + 1;
+			else
+				maxright[i][j] = 0;
+		}
+ 
+	for (j = 1; j <= N; j++)
+		for (i = 1; i <= N; i++)
+		{
+			if (board[i][j] == '#')
+				maxup[i][j] = maxup[i - 1][j] + 1;
+			else
+				maxup[i][j] = 0;
+		}
+ 
+	for (j = 1; j <= N; j++)
+		for (i = N; i >= 1; i--)
+		{
+			if (board[i][j] == '#')
+				maxdown[i][j] = maxdown[i + 1][j] + 1;
+			else
+				maxdown[i][j] = 0;
+		}
+}
+ 
+inline int solve()
+{
+	int ans = 0;
+	int i, j;
+ 
+	for (i = 1; i <= N; i++)
+		for (j = 1; j <= N; j++)
+			if(board[i][j] == '#')
+				ans = max(ans, 1 + min(min(maxleft[i][j - 1], maxright[i][j + 1]), min(maxup[i - 1][j], maxdown[i + 1][j])));
+ 
+	return ans;
+}
+ 
+int main()
+{
+	int T;
+ 
+//	freopen("input.txt", "r", stdin);
+ 
+	scanf("%d", &T);
+ 
+	while (T--)
+	{
+		init();
+		printf("%d\n", solve());
+	}
+ 
+	return 0;
+} 

spoj_cpp_clean/ADAQUEUE/ADAQUEUE-20.cpp

@@ -0,0 +1,91 @@
+/**
+ *	Author:  Sohel Rana
+ *	Date:    2022-05-25 21:07:34
+ *	Task:    G_-_Ada_and_Queue 
+**/
+#include <bits/stdc++.h>
+#define endl		'\n'
+#define sqr(x)		(x) * (x)
+#define gcd(x,y)	__gcd(x, y)
+#define lcm(x,y)	((x/gcd(x,y)) * y)
+#define pf(x)		push_front(x)
+#define pb(x)		push_back(x)
+#define eb(x)		emplace_back(x)
+#define all(x)		(x).begin(), (x).end()
+#define rall(x)		(x).rbegin(), (x).rend()
+#define sz(x)		(int)x.size()
+#define prec(x) 	fixed<<setprecision(x)
+#define debug(x)	cerr<<#x<<" = "<<(x)<< endl
+#define debug2(x,y)	cerr<<#x<<" = "<<(x)<<","<<#y<<" = "<<(y)<< endl
+#define unsyncIO	ios_base::sync_with_stdio(false); cin.tie(nullptr)
+
+using ll = long long;
+using db = double;
+using ld = long double;
+using ull = unsigned long long;
+
+const ld pi = acos((ld)-1);
+const int mod = 1e9+7;
+const ll inf = 1e18;
+const ld eps = 1e-9;
+const int mx = 1e5;
+
+using namespace std;
+
+
+int main() 
+{
+    //freopen("in.txt", "r", stdin);
+    //freopen("out.txt", "w", stdout);
+    unsyncIO;
+    deque<int> q;
+    int flag = 0;
+    int t;
+    cin >> t;
+    while (t--) {
+        string s;
+        int item;
+        cin >> s;
+        if (s == "toFront"){
+            cin >> item;
+            if (flag % 2 == 1) {
+                q.push_back(item);
+            } else
+                q.push_front(item);
+        } else if (s == "push_back") {
+            cin >> item;
+            if (flag % 2 == 1) {
+                q.push_front(item);
+            } else
+                q.push_back(item);
+        } else if (s == "front") {
+            if (q.empty()){
+                cout << "No job for Ada?" << endl;
+            } else {
+                if (flag % 2 == 1) {
+                    cout << q.back() << endl;
+                    q.pop_back();
+                } else {
+                    cout << q.front()<<endl;
+                    q.pop_front();
+                }
+            }  
+        } else if (s == "back") {
+            if (q.empty()) {
+                cout << "No job for Ada?" << endl;
+            } else {
+                if (flag % 2 == 1) {
+                    cout << q.front() << endl;
+                    q.pop_front();
+                } else {
+                    cout << q.back() << endl;
+                    q.pop_back();
+                }
+            }
+        } else if (s == "reverse") {
+            flag++;
+        }
+        
+    }
+    return 0;
+}