ADDED   SRM/541-U/1A.cpp
Index: SRM/541-U/1A.cpp
==================================================================
--- SRM/541-U/1A.cpp
+++ SRM/541-U/1A.cpp
@@ -0,0 +1,185 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class AntsMeet { public:
+	int countAnts(vector <int> x, vector <int> y, string direction)
+	{
+		const int N = x.size();
+
+		map< int, vector< pair<int,int> > > bye;
+		for(int i=0; i<N; ++i)
+			for(int j=i+1; j<N; ++j) {
+				int t;
+				if( meet(x[i], y[i], direction[i], x[j], y[j], direction[j], &t) )
+					bye[t].push_back(make_pair(i,j));
+			}
+
+		set<int> dead;
+		for(map<int, vector< pair<int,int> > >::iterator it=bye.begin(); it!=bye.end(); ++it) {
+			set<int> die;
+			vector< pair<int,int> >& events = it->second;
+			for(int i=0; i<events.size(); ++i) {
+				int a = events[i].first;
+				int b = events[i].second;
+				if( dead.count(a)==0 && dead.count(b)==0 ) {
+					die.insert(a);
+					die.insert(b);
+//					dead.insert(a);
+	//				dead.insert(b);
+				}
+			}
+			dead.insert(die.begin(), die.end());
+		}
+
+		return N - dead.size();
+	}
+
+	bool meet(int x, int y, char d, int X, int Y, int D, int* t)
+	{
+		if( d == D )
+			return false;
+		int dx = dx_of(d);
+		int dy = dy_of(d);
+		int DX = dx_of(D);
+		int DY = dy_of(D);
+
+		int tx;
+		if( !meet(x, dx, X, DX, &tx) )
+			return false;
+		int ty;
+		if( !meet(y, dy, Y, DY, &ty) )
+			return false;
+		*t = (tx==-1 ? ty : tx);
+		return (tx==ty || tx==-1 || ty==-1);
+	}
+
+	bool meet(int x, int dx, int X, int DX, int* t)
+	{
+		if( x==X && dx==DX ) {
+			*t = -1;
+			return true;
+		} else if( dx==DX ) {
+			return false;
+		} else {
+			*t = (x-X)*2 / (DX-dx);
+			return ( *t >= 0 );
+		}
+	}
+
+	int dx_of(char d)
+	{
+		if(d=='E') return +1;
+		if(d=='W') return -1;
+		return 0;
+	}
+
+	int dy_of(char d)
+	{
+		if(d=='N') return +1;
+		if(d=='S') return -1;
+		return 0;
+	}
+};
+
+// BEGIN CUT HERE
+#include <ctime>
+double start_time; string timer()
+ { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
+template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
+ { os << "{ ";
+   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
+   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
+void verify_case(const int& Expected, const int& Received) {
+ bool ok = (Expected == Received);
+ if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
+ cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
+#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
+#define END	 verify_case(_, AntsMeet().countAnts(x, y, direction));}
+int main(){
+
+CASE(0)
+	int x_[] = {0,10,20,30};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,10,20,30};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	string direction = "NWNE"; 
+	int _ = 2; 
+END
+CASE(1)
+	int x_[] = {-10,0,0,10};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,-10,10,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	string direction = "NEWS"; 
+	int _ = 0; 
+END
+CASE(2)
+	int x_[] = {-1,-1,-1,0,0,0,1,1,1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-1,0,1,-1,0,1,-1,0,1};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	string direction = "ESEWNNEWW"; 
+	int _ = 4; 
+END
+CASE(3)
+	int x_[] = {4,7,6,2,6,5,7,7,8,4,7,8,8,8,5,4,8,9,1,5,9,3,4,0,0,1,0,7,2,6,9,6,3,0,5,5,1,2,0,4,9,7,7,1,8,1,9,2,7,3};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {2,3,0,6,8,4,9,0,5,0,2,4,3,8,1,5,0,7,3,7,0,9,8,1,9,4,7,8,1,1,6,6,6,2,8,5,1,9,0,1,1,1,7,0,2,5,4,7,5,3};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	string direction = "SSNWSWSENSWSESWEWSWSENWNNNESWSWSWWSSWEEWWNWWWNWENN" ; 
+	int _ = 25; 
+END
+CASE(4)
+	int x_[] = {478,-664,759,434,-405,513,565,-396,311,-174,56,993,251,-341,993,-112,242,129,383,513,-78,-341,-148,129,423
+,493,434,-405,478,-148,929,251,56,242,929,-78,423,-664,802,251,759,383,-112,-591,-591,-248,660,660,735,493};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-186,98,948,795,289,-678,948,-170,-195,290,-354,-424,289,-157,-166,150,706,-678,684,-294,-234,36,36,-294,-216
+,-234,427,945,265,-157,265,715,275,715,-186,337,798,-170,427,706,754,961,286,-216,798,286,961,684,-424,337};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	string direction = "WNSNNSSWWWEENWESNSWSWSEWWEWEWWWNWESNSSNNSNNWWWNESE"; 
+	int _ = 44; 
+END
+CASE(5)
+	int x_[] = {0, 1, 0,  10,  9, 11};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0, 1, 2,   10, 11, 11};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	string direction = "NWSNES"; 
+	int _ = 0; 
+END
+/*
+CASE(6)
+	int x_[] = ;
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = ;
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	string direction = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/541-U/1B.cpp
Index: SRM/541-U/1B.cpp
==================================================================
--- SRM/541-U/1B.cpp
+++ SRM/541-U/1B.cpp
@@ -0,0 +1,169 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int MODVAL = 1000000007;
+
+class AkariDaisukiDiv1 { public:
+	int countF(string W, string A, string D, string S, string F, int k)
+	{
+		string X = S;
+
+		while(k>0 && X.size()<=F.size()) {
+			X = W + X + A + X + D;
+			--k;
+		}
+
+		int Usushio = naive(X, F, 0, X.size());
+		if( k == 0 )
+			return Usushio;
+
+		string WW = "", DD="";
+		for(int n=0,a,b,c; n<k; ++n) {
+			if( n <= 50 ) {
+				b = naive(X+DD+A+WW+X, F, X.size()+DD.size()-F.size()+1, X.size()+DD.size()+A.size());
+				WW += W;
+				DD += D;
+				a = naive(WW+X, F, 0, W.size());
+				c = naive(X+DD, F, X.size()+DD.size()-D.size()-F.size()+1, X.size()+DD.size());
+			}
+			Usushio = (Usushio*2 + a+b+c) % MODVAL;
+		}
+		return Usushio;
+	}
+
+	int naive(const string& X, const string& F, int S, int E)
+	{
+		int cnt = 0;
+		for(int i=0; i+F.size()<=X.size(); ++i)
+			if( S<=i && i<E )
+				if( equal(X.begin()+i, X.begin()+i+F.size(), F.begin()) )
+					++cnt;
+		return cnt;
+	}
+};
+
+// BEGIN CUT HERE
+#include <ctime>
+double start_time; string timer()
+ { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
+template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
+ { os << "{ ";
+   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
+   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
+void verify_case(const int& Expected, const int& Received) {
+ bool ok = (Expected == Received);
+ if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
+ cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
+#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
+#define END	 verify_case(_, AkariDaisukiDiv1().countF(Waai, Akari, Daisuki, S, F, k));}
+int main(){
+
+CASE(0)
+	string Waai = "a"; 
+	string Akari = "b"; 
+	string Daisuki = "c"; 
+	string S = "x"; 
+	string F = "axb"; 
+	int k = 2; 
+	int _ = 2; 
+END
+CASE(1)
+	string Waai = "a"; 
+	string Akari = "b"; 
+	string Daisuki = "c"; 
+	string S = "x"; 
+	string F = "abcdefghij"; 
+	int k = 1; 
+	int _ = 0; 
+END
+CASE(2)
+	string Waai = "a"; 
+	string Akari = "a"; 
+	string Daisuki = "a"; 
+	string S = "b"; 
+	string F = "aba"; 
+	int k = 2; 
+	int _ = 4; 
+END
+CASE(3)
+	string Waai = "a"; 
+	string Akari = "b"; 
+	string Daisuki = "c"; 
+	string S = "d"; 
+	string F = "baadbdcbadbdccccbaaaadbdcbadbdccbaadbdcba"; 
+	int k = 58; 
+	int _ = 191690599; 
+END
+CASE(4)
+	string Waai = "a"; 
+	string Akari = "x"; 
+	string Daisuki = "y"; 
+	string S = "b"; 
+	string F = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"; 
+	int k = 49; 
+	int _ = 1; 
+END
+CASE(5)
+	string Waai = "waai"; 
+	string Akari = "akari"; 
+	string Daisuki = "daisuki"; 
+	string S = "usushio"; 
+	string F = "id"; 
+	int k = 10000000; 
+	int _ = 127859200; 
+END
+CASE(6)
+	string Waai = "vfsebgjfyfgerkqlr"; 
+	string Akari = "ezbiwls"; 
+	string Daisuki = "kjerx"; 
+	string S = "jbmjvaawoxycfndukrjfg"; 
+	string F = "bgjfyfgerkqlrvfsebgjfyfgerkqlrvfsebgjfyfgerkqlrvfs"; 
+	int k = 1575724; 
+	int _ = 483599313; 
+END
+/*
+CASE(7)
+	string Waai = ; 
+	string Akari = ; 
+	string Daisuki = ; 
+	string S = ; 
+	string F = ; 
+	int k = ; 
+	int _ = ; 
+END
+CASE(8)
+	string Waai = ; 
+	string Akari = ; 
+	string Daisuki = ; 
+	string S = ; 
+	string F = ; 
+	int k = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

DELETED SRM/TCO12-1/1A.cpp
Index: SRM/TCO12-1/1A.cpp
==================================================================
--- SRM/TCO12-1/1A.cpp
+++ SRM/TCO12-1/1A.cpp
@@ -1,118 +0,0 @@
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-#include <vector>
-#include <string>
-#include <map>
-#include <set>
-#include <algorithm>
-#include <numeric>
-#include <iterator>
-#include <functional>
-#include <complex>
-#include <queue>
-#include <stack>
-#include <cmath>
-#include <cassert>
-#include <cstring>
-#ifdef __GNUC__
-#include <ext/hash_map>
-#define unordered_map __gnu_cxx::hash_map
-#else
-#include <unordered_map>
-#endif
-using namespace std;
-typedef long long LL;
-typedef complex<double> CMP;
-
-class EllysJuice { public:
-	vector <string> getWinners(vector <string> players)
-	{
-		set<string> winners;
-
-		sort(players.begin(), players.end());
-		do
-			winners.insert( play(players) );
-		while( next_permutation(players.begin(), players.end()) );
-
-		winners.erase("");
-		return vector<string>(winners.begin(), winners.end());
-	}
-
-	string play(const vector<string>& p)
-	{
-		int juice[2] = {65536, 65536};
-		map<string, int> total;
-		for(int i=0; i<p.size(); ++i)
-			total[p[i]] += (juice[i%2]/=2);
-
-		string best_name;
-		int best = 0;
-		bool tie = false;
-		for(map<string, int>::iterator it=total.begin(); it!=total.end(); ++it)
-			if( it->second > best ) {
-				best_name = it->first;
-				best = it->second;
-				tie = false;
-			}
-			else if( it->second == best )
-				tie = true;
-		return tie ? "" : best_name;
-	}
-};
-
-// BEGIN CUT HERE
-#include <ctime>
-double start_time; string timer()
- { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
-template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
- { os << "{ ";
-   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
-   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
-void verify_case(const vector <string>& Expected, const vector <string>& Received) {
- bool ok = (Expected == Received);
- if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
- cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
-#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
-#define END	 verify_case(_, EllysJuice().getWinners(players));}
-int main(){
-
-CASE(0)
-	string players_[] = { "elly", "kriss", "stancho", "elly", "stancho" };
-	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
-	string __[] = {"elly", "stancho" };
-	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
-END
-CASE(1)
-	string players_[] = {"torb", "elly", "stancho", "kriss"};
-	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
-	vector <string> _; 
-END
-CASE(2)
-	string players_[] = {"elly", "elly", "elly", "elly", "elly"};
-	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
-	string __[] = {"elly" };
-	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
-END
-CASE(3)
-	string players_[] = { "ariadne", "elly", "ariadne", "stancho", "stancho", "kriss", "stancho", "elly" };
-	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
-	string __[] = {"ariadne", "elly", "stancho" };
-	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
-END
-CASE(4)
-	string players_[] = {"b","b","a","a"};
-	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
-    string __[] = {"a","b"};
-	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
-END
-/*
-CASE(5)
-	string players_[] = ;
-	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
-	string __[] = ;
-	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
-END
-*/
-}
-// END CUT HERE

DELETED SRM/TCO12-1/1B.cpp
Index: SRM/TCO12-1/1B.cpp
==================================================================
--- SRM/TCO12-1/1B.cpp
+++ SRM/TCO12-1/1B.cpp
@@ -1,103 +0,0 @@
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-#include <vector>
-#include <string>
-#include <map>
-#include <set>
-#include <algorithm>
-#include <numeric>
-#include <iterator>
-#include <functional>
-#include <complex>
-#include <queue>
-#include <stack>
-#include <cmath>
-#include <cassert>
-#include <cstring>
-#ifdef __GNUC__
-#include <ext/hash_map>
-#define unordered_map __gnu_cxx::hash_map
-#else
-#include <unordered_map>
-#endif
-using namespace std;
-typedef long long LL;
-typedef complex<double> CMP;
-
-class EllysFractions { public:
-	long long getCount(int N)
-	{
-		LL total = 0;
-		for(int k=2; k<=N; ++k)
-			total += getExact(k);
-		return total;
-	}
-
-	LL getExact(int N)
-	{
-		int np = 0;
-		for(int p=2; p<=N; ++p)
-			if(is_prime(p))
-				++np;
-		LL v = 1;
-		for(int i=0; i<np; ++i)
-			v *= 2;
-		return v/2;
-	}
-
-	bool is_prime(int n)
-	{
-		for(int k=2; k<n; ++k)
-			if(n%k == 0)
-				return false;
-		return true;
-	}
-};
-
-// BEGIN CUT HERE
-#include <ctime>
-double start_time; string timer()
- { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
-template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
- { os << "{ ";
-   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
-   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
-void verify_case(const long long& Expected, const long long& Received) {
- bool ok = (Expected == Received);
- if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
- cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
-#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
-#define END	 verify_case(_, EllysFractions().getCount(N));}
-int main(){
-
-CASE(0)
-	int N = 1; 
-	long long _ = 0LL; 
-END
-CASE(1)
-	int N = 2; 
-	long long _ = 1LL; 
-END
-CASE(2)
-	int N = 3; 
-	long long _ = 3LL; 
-END
-CASE(3)
-	int N = 5; 
-	long long _ = 9LL; 
-END
-CASE(4)
-	int N = 100; 
-	long long _ = 177431885LL; 
-END
-CASE(5)
-	int N = 250; 
-	long long _ = -1LL; 
-END
-CASE(6)
-	int N = 4; 
-	long long _ = 5LL; 
-END
-}
-// END CUT HERE

DELETED SRM/TCO12-1/1C.cpp
Index: SRM/TCO12-1/1C.cpp
==================================================================
--- SRM/TCO12-1/1C.cpp
+++ SRM/TCO12-1/1C.cpp
@@ -1,273 +0,0 @@
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-#include <vector>
-#include <string>
-#include <map>
-#include <set>
-#include <algorithm>
-#include <numeric>
-#include <iterator>
-#include <functional>
-#include <complex>
-#include <queue>
-#include <stack>
-#include <cmath>
-#include <cassert>
-#include <cstring>
-#ifdef __GNUC__
-#include <ext/hash_map>
-#define unordered_map __gnu_cxx::hash_map
-#else
-#include <unordered_map>
-#endif
-using namespace std;
-typedef long long LL;
-typedef complex<double> CMP;
-
-struct UnionFind
-{
-	vector<int> uf, sz;
-	int nc;
-
-	UnionFind(int N): uf(N), sz(N,1), nc(N)
-		{ for(int i=0; i<N; ++i) uf[i] = i; }
-	int size()
-		{ return nc; }
-	int Find(int a)
-		{ return uf[a]==a ? a : uf[a]=Find(uf[a]); }
-	bool Union(int a, int b)
-		{
-			a = Find(a);
-			b = Find(b);
-			if( a != b )
-			{
-				if( sz[a] >= sz[b] ) swap(a, b);
-				uf[a] = b;
-				sz[b] += sz[a];
-				--nc;
-			}
-			return (a!=b);
-		}
-};
-
-class EllysLights { public:
-	int getMinimum(string initial, vector <string> switches)
-	{
-		int N = switches.size();
-		UnionFind uf(N*2+2);
-		#define TR 0
-		#define FL 1
-		#define POS(x) ((x)+2)
-		#define NEG(x) ((x)+N+2)
-
-		for(int i=0; i<initial.size(); ++i)
-		{
-			vector<int> sw;
-			for(int k=0; k<N; ++k)
-				if( switches[k][i]=='Y' )
-					sw.push_back(k);
-
-			if(initial[i] == 'Y')
-				if(sw.size() == 0)
-				{
-					return -1;
-				}
-				else if(sw.size() == 1)
-				{
-					uf.Union(POS(sw[0]), TR);
-					uf.Union(NEG(sw[0]), FL);
-				}
-				else
-				{
-					uf.Union(POS(sw[0]), NEG(sw[1]));
-					uf.Union(NEG(sw[0]), POS(sw[1]));
-				}
-			else
-				if(sw.size() == 0)
-				{
-				}
-				else if(sw.size() == 1)
-				{
-					uf.Union(POS(sw[0]), FL);
-					uf.Union(NEG(sw[0]), TR);
-				}
-				else
-				{
-					uf.Union(POS(sw[0]), POS(sw[1]));
-					uf.Union(NEG(sw[0]), NEG(sw[1]));
-				}
-		}
-
-		if( uf.Find(TR) == uf.Find(FL) )
-			return -1;
-		for(int k=0; k<N; ++k)
-			if( uf.Find(POS(k)) == uf.Find(NEG(k)) )
-				return -1;
-
-		int minSwitch = 0;
-		set<int> done;
-		for(int k=0; k<N; ++k)
-			if( !done.count(k) )
-			{
-				vector<int> pos(1, k);
-				vector<int> neg;
-				for(int j=k+1; j<N; ++j)
-					if( !done.count(j) )
-						if( uf.Find(POS(k)) == uf.Find(POS(j)) ) {
-							pos.push_back(j);
-							done.insert(j);
-						} else if( uf.Find(POS(k)) == uf.Find(NEG(j)) ) {
-							neg.push_back(j);
-							done.insert(j);
-						}
-				if( uf.Find(POS(k)) == uf.Find(TR) ) {
-					minSwitch += pos.size();
-				}
-				else if( uf.Find(POS(k)) == uf.Find(FL) ) {
-					minSwitch += neg.size();
-				}
-				else {
-					minSwitch += min(pos.size(), neg.size());
-				}
-			}
-		return minSwitch;
-	}
-};
-
-// BEGIN CUT HERE
-#include <ctime>
-double start_time; string timer()
- { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
-template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
- { os << "{ ";
-   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
-   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
-void verify_case(const int& Expected, const int& Received) {
- bool ok = (Expected == Received);
- if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
- cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
-#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
-#define END	 verify_case(_, EllysLights().getMinimum(initial, switches));}
-int main(){
-
-CASE(0)
-	string initial = "YNYNNN"; 
-	string switches_[] = {"YNNYNY", "NYYYNN", "YNYNYN", "NNNNYN", "NYNNNY"};
-	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
-	int _ = 2; 
-END
-CASE(1)
-	string initial = "YNYNYN"; 
-	string switches_[] = {"NNNNNN", "YYYYYY", "NYNNNN", "NNNYNN", "NNNNNY"};
-	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
-	int _ = 4; 
-END
-CASE(2)
-	string initial = "YYN"; 
-	string switches_[] = {"YNY", "NYN"};
-	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
-	int _ = -1; 
-END
-CASE(3)
-	string initial = "NNYNYNYYYNNYYYYN"; 
-	string switches_[] = {"NYNYNYNYNYNYNYNY",
- "YNYNYNYNYNYNYNYN",
- "NNNNNNNNNNNNNNNN",
- "YNNNNNNNNNNNNNNN",
- "NYNNNNNNNNNNNNNN",
- "NNYNNNNNNNNNNNNN",
- "NNNYNNNNNNNNNNNN",
- "NNNNYNNNNNNNNNNN",
- "NNNNNYNNNNNNNNNN",
- "NNNNNNYNNNNNNNNN",
- "NNNNNNNYNNNNNNNN",
- "NNNNNNNNYNNNNNNN",
- "NNNNNNNNNYNNNNNN",
- "NNNNNNNNNNYNNNNN",
- "NNNNNNNNNNNYNNNN",
- "NNNNNNNNNNNNYNNN",
- "NNNNNNNNNNNNNYNN",
- "NNNNNNNNNNNNNNYN",
- "NNNNNNNNNNNNNNNY"};
-	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
-	int _ = 6; 
-END
-CASE(4)
-	string initial = "NYNYNYYYNNYYYNNYNNYYYYYNNYNYYYY"; 
-	string switches_[] = {"NNNNNNNNNNNNNNNNNNYNNNNNNNNNNNN",
- "NNNNNNNNYNNNYNNNNYYNYNNNNYNNNNN",
- "NNNNNNNNNYNNNNNNNNNNNNYNNNNNNNN",
- "NNNNNYNNNNNNNNNNNNNNNNNNNNNNNNN",
- "NYNNNNNNNNNNNNYNNNNNNNNNNNNNNNN",
- "NNNNNNNNNNNNNYYNNNNNNNNNNNNNNNY",
- "NNNNNNYNNNNNNNNNNNNYNNNNNYNNNNN",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
- "YNNNNNNNNNNNNNNNNNNYNNNNNNNNNNN",
- "NNNYNNNNNNNNNNNNNNNNNNNYYNNNNNN",
- "NYNNNNNNNNNNYNNNNNNNNNNNNNNNYNN",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
- "NNNNNYNNNNNNNNNNNNNNNNNNNNNNNNY",
- "NNNNNNNNNNYNNNNNNNNNYYYNNNNNNNN",
- "NNNYNNNNNNNNNNNNNNNNNNNNNNNYNNN",
- "NNNNNNNNYNNNNNNNNNNNNNNNYNNNNNN",
- "YNNNYNNNNNNNNNNNNNNNNNNNNNNYNNN",
- "NNNNNNNNNNYNNNNNNNNNNNNNNNNNNNN",
- "NNNNYNNYNNNNNNNNNNNNNNNNNNNNNNN",
- "NNNNNNNYNNNYNNNYNNNNNNNNNNNNNYN"};
-	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
-	int _ = 7; 
-END
-CASE(5)
-	string initial = "NYNYYNYNYYYYNNYNYNNYYNNNNNYNYNNNNNYNNNYN"; 
-	string switches_[] = {"NNNNNNNNNNNNNNNNNNNYNNNNNNNNNNNNNNNYNNNN",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNYNNNNNNNNNNNNN",
- "NNNNNNNNNYNNNNYNNYNNNNNNNNNNNNNNNNNNNNNN",
- "NNNNNNNNNNNNNNNNNNNYNNNNYNNNNNNNYNNNNNNN",
- "NNNNNYNNNNNNNNNNNNNNNNNYNNNNNNNNNNNNNNNN",
- "NNNNNNNNNNNNNNNNNNYNNNNNNNNYNNNYNNNNNYNN",
- "NNNNNNNNNNYNNNNNNNNNNNNNNYNNNNNYNNYNNNNN",
- "NNNNNYNNYNNYNNNNNNNNNNNNNNNNNNNNNYNNNNNN",
- "YNNNYNNNNNNNNNNNNNYNNNYNNYNNNNNNNYNNNNNN",
- "NNNNNNNNNYYNNNNNNNNNNNNYNNNNYNNNNNNNNNNN",
- "NNNNNNNNNNNYNYNNNNNNNNNNNNNNNNNNNNNNNNNY",
- "NNNNNNNNNNNNYNNNNNNNNNNNYNNNNNNNNNNNNNNN",
- "NNNNNNNNNNNNNNNNNNNNNNYNNNNNNNNNNNNNNNNN",
- "NNNYNNNNNNNNNNNNNNNNNYNNNNNNNNNNYNNNNNNN",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
- "NNNNNNNNNNNNNNYNNYNNNNNNNNNNNNNNNNNNNNNN",
- "NNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYYNNY",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYNNNNNNNNN",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
- "NNNNNNNYNNNNNYNYNNNNNNNNNNNNNNNNNNNNNNNN",
- "NNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYNNNNN",
- "NYNNNNNNNNNNNNNNNNNNNNNNNNNNNYNNNNNNNNNN",
- "NNNNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
- "NYNNNNYNNNNNNNNNNNNNNNNNNNNYNNNNNNNNNNNN",
- "NNNNNNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYNN",
- "NNNNNNNNNNNNYNNYYNNNNNNNNNNNNNNNNNNNNNNN",
- "NNNNNNNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
- "NNNYNNNNNNNNNNNNNNNNYYNNNNNNNNNNNNNNNNNN",
- "NNNNNNNNYNNNNNNNNNNNNNNNNNNNYNYNNNNNNNNN",
- "NNNNNNNNNNNNNNNNNNNNNNNNNNYNNYNNNNNNYNNN"};
-	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
-	int _ = -1; 
-END
-/*
-CASE(6)
-	string initial = ; 
-	string switches_[] = ;
-	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
-	int _ = ; 
-END
-CASE(7)
-	string initial = ; 
-	string switches_[] = ;
-	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
-	int _ = ; 
-END
-*/
-}
-// END CUT HERE

ADDED   SRM/TCO12-1A/1A.cpp
Index: SRM/TCO12-1A/1A.cpp
==================================================================
--- SRM/TCO12-1A/1A.cpp
+++ SRM/TCO12-1A/1A.cpp
@@ -0,0 +1,118 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class EllysJuice { public:
+	vector <string> getWinners(vector <string> players)
+	{
+		set<string> winners;
+
+		sort(players.begin(), players.end());
+		do
+			winners.insert( play(players) );
+		while( next_permutation(players.begin(), players.end()) );
+
+		winners.erase("");
+		return vector<string>(winners.begin(), winners.end());
+	}
+
+	string play(const vector<string>& p)
+	{
+		int juice[2] = {65536, 65536};
+		map<string, int> total;
+		for(int i=0; i<p.size(); ++i)
+			total[p[i]] += (juice[i%2]/=2);
+
+		string best_name;
+		int best = 0;
+		bool tie = false;
+		for(map<string, int>::iterator it=total.begin(); it!=total.end(); ++it)
+			if( it->second > best ) {
+				best_name = it->first;
+				best = it->second;
+				tie = false;
+			}
+			else if( it->second == best )
+				tie = true;
+		return tie ? "" : best_name;
+	}
+};
+
+// BEGIN CUT HERE
+#include <ctime>
+double start_time; string timer()
+ { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
+template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
+ { os << "{ ";
+   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
+   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
+void verify_case(const vector <string>& Expected, const vector <string>& Received) {
+ bool ok = (Expected == Received);
+ if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
+ cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
+#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
+#define END	 verify_case(_, EllysJuice().getWinners(players));}
+int main(){
+
+CASE(0)
+	string players_[] = { "elly", "kriss", "stancho", "elly", "stancho" };
+	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
+	string __[] = {"elly", "stancho" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	string players_[] = {"torb", "elly", "stancho", "kriss"};
+	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
+	vector <string> _; 
+END
+CASE(2)
+	string players_[] = {"elly", "elly", "elly", "elly", "elly"};
+	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
+	string __[] = {"elly" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	string players_[] = { "ariadne", "elly", "ariadne", "stancho", "stancho", "kriss", "stancho", "elly" };
+	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
+	string __[] = {"ariadne", "elly", "stancho" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	string players_[] = {"b","b","a","a"};
+	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
+    string __[] = {"a","b"};
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(5)
+	string players_[] = ;
+	  vector <string> players(players_, players_+sizeof(players_)/sizeof(*players_)); 
+	string __[] = ;
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/TCO12-1A/1B.cpp
Index: SRM/TCO12-1A/1B.cpp
==================================================================
--- SRM/TCO12-1A/1B.cpp
+++ SRM/TCO12-1A/1B.cpp
@@ -0,0 +1,103 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class EllysFractions { public:
+	long long getCount(int N)
+	{
+		LL total = 0;
+		for(int k=2; k<=N; ++k)
+			total += getExact(k);
+		return total;
+	}
+
+	LL getExact(int N)
+	{
+		int np = 0;
+		for(int p=2; p<=N; ++p)
+			if(is_prime(p))
+				++np;
+		LL v = 1;
+		for(int i=0; i<np; ++i)
+			v *= 2;
+		return v/2;
+	}
+
+	bool is_prime(int n)
+	{
+		for(int k=2; k<n; ++k)
+			if(n%k == 0)
+				return false;
+		return true;
+	}
+};
+
+// BEGIN CUT HERE
+#include <ctime>
+double start_time; string timer()
+ { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
+template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
+ { os << "{ ";
+   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
+   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
+void verify_case(const long long& Expected, const long long& Received) {
+ bool ok = (Expected == Received);
+ if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
+ cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
+#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
+#define END	 verify_case(_, EllysFractions().getCount(N));}
+int main(){
+
+CASE(0)
+	int N = 1; 
+	long long _ = 0LL; 
+END
+CASE(1)
+	int N = 2; 
+	long long _ = 1LL; 
+END
+CASE(2)
+	int N = 3; 
+	long long _ = 3LL; 
+END
+CASE(3)
+	int N = 5; 
+	long long _ = 9LL; 
+END
+CASE(4)
+	int N = 100; 
+	long long _ = 177431885LL; 
+END
+CASE(5)
+	int N = 250; 
+	long long _ = -1LL; 
+END
+CASE(6)
+	int N = 4; 
+	long long _ = 5LL; 
+END
+}
+// END CUT HERE

ADDED   SRM/TCO12-1A/1C.cpp
Index: SRM/TCO12-1A/1C.cpp
==================================================================
--- SRM/TCO12-1A/1C.cpp
+++ SRM/TCO12-1A/1C.cpp
@@ -0,0 +1,273 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+struct UnionFind
+{
+	vector<int> uf, sz;
+	int nc;
+
+	UnionFind(int N): uf(N), sz(N,1), nc(N)
+		{ for(int i=0; i<N; ++i) uf[i] = i; }
+	int size()
+		{ return nc; }
+	int Find(int a)
+		{ return uf[a]==a ? a : uf[a]=Find(uf[a]); }
+	bool Union(int a, int b)
+		{
+			a = Find(a);
+			b = Find(b);
+			if( a != b )
+			{
+				if( sz[a] >= sz[b] ) swap(a, b);
+				uf[a] = b;
+				sz[b] += sz[a];
+				--nc;
+			}
+			return (a!=b);
+		}
+};
+
+class EllysLights { public:
+	int getMinimum(string initial, vector <string> switches)
+	{
+		int N = switches.size();
+		UnionFind uf(N*2+2);
+		#define TR 0
+		#define FL 1
+		#define POS(x) ((x)+2)
+		#define NEG(x) ((x)+N+2)
+
+		for(int i=0; i<initial.size(); ++i)
+		{
+			vector<int> sw;
+			for(int k=0; k<N; ++k)
+				if( switches[k][i]=='Y' )
+					sw.push_back(k);
+
+			if(initial[i] == 'Y')
+				if(sw.size() == 0)
+				{
+					return -1;
+				}
+				else if(sw.size() == 1)
+				{
+					uf.Union(POS(sw[0]), TR);
+					uf.Union(NEG(sw[0]), FL);
+				}
+				else
+				{
+					uf.Union(POS(sw[0]), NEG(sw[1]));
+					uf.Union(NEG(sw[0]), POS(sw[1]));
+				}
+			else
+				if(sw.size() == 0)
+				{
+				}
+				else if(sw.size() == 1)
+				{
+					uf.Union(POS(sw[0]), FL);
+					uf.Union(NEG(sw[0]), TR);
+				}
+				else
+				{
+					uf.Union(POS(sw[0]), POS(sw[1]));
+					uf.Union(NEG(sw[0]), NEG(sw[1]));
+				}
+		}
+
+		if( uf.Find(TR) == uf.Find(FL) )
+			return -1;
+		for(int k=0; k<N; ++k)
+			if( uf.Find(POS(k)) == uf.Find(NEG(k)) )
+				return -1;
+
+		int minSwitch = 0;
+		set<int> done;
+		for(int k=0; k<N; ++k)
+			if( !done.count(k) )
+			{
+				vector<int> pos(1, k);
+				vector<int> neg;
+				for(int j=k+1; j<N; ++j)
+					if( !done.count(j) )
+						if( uf.Find(POS(k)) == uf.Find(POS(j)) ) {
+							pos.push_back(j);
+							done.insert(j);
+						} else if( uf.Find(POS(k)) == uf.Find(NEG(j)) ) {
+							neg.push_back(j);
+							done.insert(j);
+						}
+				if( uf.Find(POS(k)) == uf.Find(TR) ) {
+					minSwitch += pos.size();
+				}
+				else if( uf.Find(POS(k)) == uf.Find(FL) ) {
+					minSwitch += neg.size();
+				}
+				else {
+					minSwitch += min(pos.size(), neg.size());
+				}
+			}
+		return minSwitch;
+	}
+};
+
+// BEGIN CUT HERE
+#include <ctime>
+double start_time; string timer()
+ { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
+template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
+ { os << "{ ";
+   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
+   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
+void verify_case(const int& Expected, const int& Received) {
+ bool ok = (Expected == Received);
+ if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
+ cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
+#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
+#define END	 verify_case(_, EllysLights().getMinimum(initial, switches));}
+int main(){
+
+CASE(0)
+	string initial = "YNYNNN"; 
+	string switches_[] = {"YNNYNY", "NYYYNN", "YNYNYN", "NNNNYN", "NYNNNY"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	int _ = 2; 
+END
+CASE(1)
+	string initial = "YNYNYN"; 
+	string switches_[] = {"NNNNNN", "YYYYYY", "NYNNNN", "NNNYNN", "NNNNNY"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	int _ = 4; 
+END
+CASE(2)
+	string initial = "YYN"; 
+	string switches_[] = {"YNY", "NYN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	int _ = -1; 
+END
+CASE(3)
+	string initial = "NNYNYNYYYNNYYYYN"; 
+	string switches_[] = {"NYNYNYNYNYNYNYNY",
+ "YNYNYNYNYNYNYNYN",
+ "NNNNNNNNNNNNNNNN",
+ "YNNNNNNNNNNNNNNN",
+ "NYNNNNNNNNNNNNNN",
+ "NNYNNNNNNNNNNNNN",
+ "NNNYNNNNNNNNNNNN",
+ "NNNNYNNNNNNNNNNN",
+ "NNNNNYNNNNNNNNNN",
+ "NNNNNNYNNNNNNNNN",
+ "NNNNNNNYNNNNNNNN",
+ "NNNNNNNNYNNNNNNN",
+ "NNNNNNNNNYNNNNNN",
+ "NNNNNNNNNNYNNNNN",
+ "NNNNNNNNNNNYNNNN",
+ "NNNNNNNNNNNNYNNN",
+ "NNNNNNNNNNNNNYNN",
+ "NNNNNNNNNNNNNNYN",
+ "NNNNNNNNNNNNNNNY"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	int _ = 6; 
+END
+CASE(4)
+	string initial = "NYNYNYYYNNYYYNNYNNYYYYYNNYNYYYY"; 
+	string switches_[] = {"NNNNNNNNNNNNNNNNNNYNNNNNNNNNNNN",
+ "NNNNNNNNYNNNYNNNNYYNYNNNNYNNNNN",
+ "NNNNNNNNNYNNNNNNNNNNNNYNNNNNNNN",
+ "NNNNNYNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NYNNNNNNNNNNNNYNNNNNNNNNNNNNNNN",
+ "NNNNNNNNNNNNNYYNNNNNNNNNNNNNNNY",
+ "NNNNNNYNNNNNNNNNNNNYNNNNNYNNNNN",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "YNNNNNNNNNNNNNNNNNNYNNNNNNNNNNN",
+ "NNNYNNNNNNNNNNNNNNNNNNNYYNNNNNN",
+ "NYNNNNNNNNNNYNNNNNNNNNNNNNNNYNN",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNNNYNNNNNNNNNNNNNNNNNNNNNNNNY",
+ "NNNNNNNNNNYNNNNNNNNNYYYNNNNNNNN",
+ "NNNYNNNNNNNNNNNNNNNNNNNNNNNYNNN",
+ "NNNNNNNNYNNNNNNNNNNNNNNNYNNNNNN",
+ "YNNNYNNNNNNNNNNNNNNNNNNNNNNYNNN",
+ "NNNNNNNNNNYNNNNNNNNNNNNNNNNNNNN",
+ "NNNNYNNYNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNNNNNYNNNYNNNYNNNNNNNNNNNNNYN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	int _ = 7; 
+END
+CASE(5)
+	string initial = "NYNYYNYNYYYYNNYNYNNYYNNNNNYNYNNNNNYNNNYN"; 
+	string switches_[] = {"NNNNNNNNNNNNNNNNNNNYNNNNNNNNNNNNNNNYNNNN",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNYNNNNNNNNNNNNN",
+ "NNNNNNNNNYNNNNYNNYNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNNNNNNNNNNNNNNNNNYNNNNYNNNNNNNYNNNNNNN",
+ "NNNNNYNNNNNNNNNNNNNNNNNYNNNNNNNNNNNNNNNN",
+ "NNNNNNNNNNNNNNNNNNYNNNNNNNNYNNNYNNNNNYNN",
+ "NNNNNNNNNNYNNNNNNNNNNNNNNYNNNNNYNNYNNNNN",
+ "NNNNNYNNYNNYNNNNNNNNNNNNNNNNNNNNNYNNNNNN",
+ "YNNNYNNNNNNNNNNNNNYNNNYNNYNNNNNNNYNNNNNN",
+ "NNNNNNNNNYYNNNNNNNNNNNNYNNNNYNNNNNNNNNNN",
+ "NNNNNNNNNNNYNYNNNNNNNNNNNNNNNNNNNNNNNNNY",
+ "NNNNNNNNNNNNYNNNNNNNNNNNYNNNNNNNNNNNNNNN",
+ "NNNNNNNNNNNNNNNNNNNNNNYNNNNNNNNNNNNNNNNN",
+ "NNNYNNNNNNNNNNNNNNNNNYNNNNNNNNNNYNNNNNNN",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNNNNNNNNNNNNYNNYNNNNNNNNNNNNNNNNNNNNNN",
+ "NNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYYNNY",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYNNNNNNNNN",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNNNNNYNNNNNYNYNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYNNNNN",
+ "NYNNNNNNNNNNNNNNNNNNNNNNNNNNNYNNNNNNNNNN",
+ "NNNNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NYNNNNYNNNNNNNNNNNNNNNNNNNNYNNNNNNNNNNNN",
+ "NNNNNNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYNN",
+ "NNNNNNNNNNNNYNNYYNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNNNNNYNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN",
+ "NNNYNNNNNNNNNNNNNNNNYYNNNNNNNNNNNNNNNNNN",
+ "NNNNNNNNYNNNNNNNNNNNNNNNNNNNYNYNNNNNNNNN",
+ "NNNNNNNNNNNNNNNNNNNNNNNNNNYNNYNNNNNNYNNN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	int _ = -1; 
+END
+/*
+CASE(6)
+	string initial = ; 
+	string switches_[] = ;
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	int _ = ; 
+END
+CASE(7)
+	string initial = ; 
+	string switches_[] = ;
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/TCO12-2A-U/1A.cpp
Index: SRM/TCO12-2A-U/1A.cpp
==================================================================
--- SRM/TCO12-2A-U/1A.cpp
+++ SRM/TCO12-2A-U/1A.cpp
@@ -0,0 +1,178 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+
+bool augment( graph& G, int v, vector<vert>& matchTo, bool visited[] )
+{
+	for(int i=0; i<G[v].size(); ++i) {
+		vert u = G[v][i];
+		if( visited[u] ) continue;
+		visited[u] = true;
+
+		if( matchTo[u]<0 || augment(G, matchTo[u], matchTo, visited) )
+			{ matchTo[v]=u, matchTo[u]=v; return true; }
+	}
+	return false;
+}
+
+template<int NV>
+int biMatch( graph& G, int L ) 
+{
+	vector<vert> matchTo(G.size(), -1);
+	int ans = 0;
+	for(vert v=0; v<L; ++v) {
+		bool visited[NV] = {};
+		if( augment(G, v, matchTo, visited) )
+			++ans;
+	}
+	return ans;
+}
+
+class SwitchesAndLamps { public:
+	int theMin(vector <string> switches, vector <string> lamps)
+	{
+		const int N = switches[0].size();
+		const int E = switches.size();
+
+		vector< vector<bool> > uneq(N, vector<bool>(N));
+
+		vector<LL> id(N, 1);
+		for(int e=0; e<E; ++e) {
+			for(int s=0; s<N; ++s) {
+				id[s] = id[s]*2 + (switches[e][s]=='Y' ? 0 : 1);
+				for(int l=0; l<N; ++l) {
+					if( switches[e][s] != lamps[e][l] )
+						uneq[s][l] = true;
+				}
+			}
+		}
+
+		graph G(N*2);
+		for(int s=0; s<N; ++s)
+			for(int l=0; l<N; ++l)
+				if( !uneq[s][l] )
+					G[s].push_back(N+l);
+		if( N > biMatch<100>(G, N) )
+			return -1;
+
+		map<LL, int> sizes;
+		int maxSize = 1;
+		for(int s=0; s<N; ++s)
+			maxSize = max(maxSize, ++sizes[id[s]]);
+		return calcNeed(maxSize);
+	}
+
+	int calcNeed(int maxSize)
+	{
+		if( maxSize<=1 )
+			return 0;
+		return 1 + calcNeed((maxSize+1)/2);
+	}
+};
+
+// BEGIN CUT HERE
+#include <ctime>
+double start_time; string timer()
+ { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
+template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
+ { os << "{ ";
+   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
+   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
+void verify_case(const int& Expected, const int& Received) {
+ bool ok = (Expected == Received);
+ if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
+ cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
+#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
+#define END	 verify_case(_, SwitchesAndLamps().theMin(switches, lamps));}
+int main(){
+
+CASE(0)
+	string switches_[] = {"NYNN", "NNYN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	string lamps_[] = {"NNNY", "NNYN"};
+	  vector <string> lamps(lamps_, lamps_+sizeof(lamps_)/sizeof(*lamps_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string switches_[] = {"YYN", "YNY", "YYN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	string lamps_[] = {"YNY", "NYY", "YNY"};
+	  vector <string> lamps(lamps_, lamps_+sizeof(lamps_)/sizeof(*lamps_)); 
+	int _ = 0; 
+END
+CASE(2)
+	string switches_[] = {"NYYYNYNNYYYNYNNNNY",
+	                      "NYYYNYNNYYYNYNNNNY"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	string lamps_[] =    {"YYYNNNYNNYNYNYNYNY",
+		                  "YYYNNNYNNYNYYNNYNY"};
+	  vector <string> lamps(lamps_, lamps_+sizeof(lamps_)/sizeof(*lamps_)); 
+	int _ = -1; 
+END
+CASE(3)
+	string switches_[] = {"YYNNN", "NNYYN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	string lamps_[] =    {"NYNNY", "NNNYY"};
+	  vector <string> lamps(lamps_, lamps_+sizeof(lamps_)/sizeof(*lamps_)); 
+	int _ = -1; 
+END
+CASE(4)
+	string switches_[] = {"YNNYNNYNYY", "NYNNYNYNYN", "YNYNYYYYYN", "NNYYNYNYNN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	string lamps_[] = {"NYYNYNNYNY", "NYYYNNYNNN", "YYYYNYNNYY", "YNNNNYNYYN"};
+	  vector <string> lamps(lamps_, lamps_+sizeof(lamps_)/sizeof(*lamps_)); 
+	int _ = 2; 
+END
+CASE(5)
+string switches_[] = {"YYNNN", "YNNNN", "NYNNN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+string lamps_[] = {"YYNNN", "YNNNN", "NNYNN"};
+	  vector <string> lamps(lamps_, lamps_+sizeof(lamps_)/sizeof(*lamps_)); 
+	int _ = -1; 
+END
+CASE(6)
+string switches_[] = {"YYNNN", "YNNNN", "NYNNN"};
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+string lamps_[] = {"YYNNN", "YNNNN", "YNNNN"};
+	  vector <string> lamps(lamps_, lamps_+sizeof(lamps_)/sizeof(*lamps_)); 
+	int _ = -1; 
+END
+/*
+CASE(6)
+	string switches_[] = ;
+	  vector <string> switches(switches_, switches_+sizeof(switches_)/sizeof(*switches_)); 
+	string lamps_[] = ;
+	  vector <string> lamps(lamps_, lamps_+sizeof(lamps_)/sizeof(*lamps_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/TCO12-2A-U/1B.cpp
Index: SRM/TCO12-2A-U/1B.cpp
==================================================================
--- SRM/TCO12-2A-U/1B.cpp
+++ SRM/TCO12-2A-U/1B.cpp
@@ -0,0 +1,142 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename T>
+struct DP3
+{
+	int N1, N2, N3;
+	vector<T> data;
+	DP3(int N1, int N2, int N3, const T& t = T())
+		: N1(N1), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2, int i3)
+		{ return data[ ((i1*N2)+i2)*N3+i3 ]; }
+	void swap(DP3& rhs)
+		{ data.swap(rhs.data); }
+};
+
+class CucumberWatering { public:
+	long long theMin(vector <int> x, int K)
+	{
+		const int N = x.size();
+
+		vector<pair<LL,int> > pts;
+		for(int i=0; i<N; ++i)
+			pts.push_back(make_pair(x[i], i));
+		sort(pts.begin(), pts.end());
+
+		DP3<LL> dp(N, K+1, N, -12345678987654321LL);
+		dp(0, 0, 0) = dp(0, 1, 0) = 0;
+		for(int i=1; i<N; ++i)
+			for(int warpUsed=0; warpUsed<=K; ++warpUsed) {
+				for(int lastWarpPt=0; lastWarpPt<i; ++lastWarpPt)
+					dp(i,warpUsed,lastWarpPt) = dp(i-1,warpUsed,lastWarpPt);
+
+				LL maxGain = 0;
+				if( warpUsed > 1 )
+					for(int p=0; p<i; ++p) {
+						LL gain = 0;
+						LL P = pts[p].first;
+						LL Q = pts[i].first;
+						for(int k=1; k<N; ++k) {
+							LL X = min(x[k-1], x[k]);
+							LL Y = max(x[k-1], x[k]);
+							gain += max(0LL, (Y-X) - (abs(X-P) + abs(Y-Q)));
+						}
+						maxGain = max(maxGain, dp(i,warpUsed-1,p) + gain);
+					}
+				dp(i,warpUsed,i) = maxGain;
+			}
+
+		LL naive = 0;
+		for(int i=1; i<N; ++i)
+			naive += abs(LL(x[i-1]) - LL(x[i]));
+
+		LL maxGain = 0;
+		for(int w=0; w<=K; ++w)
+			for(int p=0; p<N; ++p)
+				maxGain = max(maxGain, dp(N-1,w,p));
+
+		return naive - maxGain;
+	}
+};
+
+// BEGIN CUT HERE
+#include <ctime>
+double start_time; string timer()
+ { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
+template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
+ { os << "{ ";
+   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
+   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
+void verify_case(const long long& Expected, const long long& Received) {
+ bool ok = (Expected == Received);
+ if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
+ cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
+#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
+#define END	 verify_case(_, CucumberWatering().theMin(x, K));}
+int main(){
+
+CASE(0)
+	int x_[] = {0, 6, 8, 2};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int K = 2; 
+	long long _ = 6LL; 
+END
+CASE(1)
+	int x_[] = {-1000000000, 1000000000, 0};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int K = 1; 
+	long long _ = 3000000000LL; 
+END
+CASE(2)
+	int x_[] = {58, 2012};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int K = 50; 
+	long long _ = 0LL; 
+END
+CASE(3)
+	int x_[] = {9, -3, 14, 6, 5, -9, 32, 7, -5, 26, 2, 11};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int K = 3; 
+	long long _ = 58LL; 
+END
+/*
+CASE(4)
+	int x_[] = ;
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int K = ; 
+	long long _ = LL; 
+END
+CASE(5)
+	int x_[] = ;
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int K = ; 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE