ADDED   SRM/589-U/1A.cpp
Index: SRM/589-U/1A.cpp
==================================================================
--- SRM/589-U/1A.cpp
+++ SRM/589-U/1A.cpp
@@ -0,0 +1,134 @@
+#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 <tuple>
+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 size(int a)
+		{ return sz[Find(a)]; }
+	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 GooseTattarrattatDiv1 { public:
+	int getmin(string S)
+	{
+		UnionFind uf(128);
+
+		map<char,int> time_for;
+		for(int i=0; i<S.size(); ++i)
+		{
+			time_for[S[i]]++;
+			uf.Union(S[i], S[S.size()-1-i]);
+		}
+
+		int total = 0;
+
+		set<char> done;
+		for(auto c : S)
+		{
+			if(done.count(c))
+				continue;
+
+			int need = 0;
+			int m = 0;
+			for(auto d : S)
+				if(uf.Find(c) == uf.Find(d)) {
+					if(done.count(d))
+						continue;
+					done.insert(d);
+					need += time_for[d];
+					m = max(m, time_for[d]);
+				}
+			total += (need - m);
+		}
+
+		return total;
+	}
+};
+
+// 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(_, GooseTattarrattatDiv1().getmin(S));}
+int main(){
+
+CASE(0)
+	string S = "geese"; 
+	int _ = 2; 
+END
+CASE(1)
+	string S = "tattarrattat"; 
+	int _ = 0; 
+END
+CASE(2)
+	string S = "xyyzzzxxx"; 
+	int _ = 2; 
+END
+CASE(3)
+	string S = "xrepayuyubctwtykrauccnquqfuqvccuaakylwlcjuyhyammag"; 
+	int _ = 11; 
+END
+CASE(4)
+	string S = "abaabb"; 
+	int _ = 3; 
+END
+/*
+CASE(5)
+	string S = ; 
+	int _ = ; 
+END
+CASE(6)
+	string S = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/589-U/1B.cpp
Index: SRM/589-U/1B.cpp
==================================================================
--- SRM/589-U/1B.cpp
+++ SRM/589-U/1B.cpp
@@ -0,0 +1,167 @@
+#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 <tuple>
+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 ) // [0,L):left, [L,?):right
+    // only left->right edges are used during computation
+{
+	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 GearsDiv1 { public:
+	int getmin(string color, vector <string> graph)
+	{
+		vector<int> r, g, b;
+		for(int i=0; i<color.size(); ++i)
+			(color[i]=='R' ? r : color[i]=='G' ? g : b).push_back(i);
+
+		int rg = calc(graph, r, g);
+		int gb = calc(graph, g, b);
+		int br = calc(graph, b, r);
+		return min(rg, min(gb, br));
+	}
+
+	int calc(const vector<string>& G, const vector<int>& A, const vector<int>& B)
+	{
+		if(A.empty() || B.empty())
+			return 0;
+
+		graph gr(A.size() + B.size());
+		for(int a=0; a<A.size(); ++a)
+		for(int b=0; b<B.size(); ++b)
+		{
+			if(G[A[a]][B[b]] == 'Y')
+				gr[a].push_back(A.size()+b);
+		}
+		return biMatch<256>(gr, A.size());
+	}
+};
+
+// 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(_, GearsDiv1().getmin(color, graph));}
+int main(){
+
+CASE(0)
+	string color = "RGB"; 
+	string graph_[] = {"NYY","YNY","YYN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string color = "RGBR"; 
+	string graph_[] = {"NNNN","NNNN","NNNN","NNNN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 0; 
+END
+CASE(2)
+	string color = "RGBR"; 
+	string graph_[] = {"NYNN","YNYN","NYNY","NNYN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 1; 
+END
+CASE(3)
+	string color = "RRRRRGRRBGRRGBBGGGBRRRGBRGRRGG"; 
+	string graph_[] = {"NNNNNYNNNYNNYNNNYNNNNNNNNYNNYY",
+ "NNNNNNNNYNNNYNYNNYNNNNYNNYNNYY",
+ "NNNNNYNNNNNNNNNNNNYNNNNNNYNNNY",
+ "NNNNNNNNNYNNYNNYYYNNNNYNNYNNNN",
+ "NNNNNNNNNYNNYNNYYYNNNNYNNNNNNN",
+ "YNYNNNYYYNNYNYYNNNNNYYNYNNYYNN",
+ "NNNNNYNNNNNNNNNYYYNNNNYNNYNNYY",
+ "NNNNNYNNNNNNNNNYNNNNNNNNNNNNYN",
+ "NYNNNYNNNYNNYNNYYYNNNNYNNYNNYY",
+ "YNNYYNNNYNNNNYYNNNYNYYNYNNNNNN",
+ "NNNNNNNNNNNNYNNYNYNNNNYNNNNNNY",
+ "NNNNNYNNNNNNYNNYYYNNNNNNNNNNYN",
+ "YYNYYNNNYNYYNYYNNNYNYNNYNNNNNN",
+ "NNNNNYNNNYNNYNNYYYNNNNYNNYNYYY",
+ "NYNNNYNNNYNNYNNYYYNNNNYNNYNNYY",
+ "NNNYYNYYYNYYNYYNNNYNYNNYYNYYNN",
+ "YNNYYNYNYNNYNYYNNNYNNNNYYNNYNN",
+ "NYNYYNYNYNYYNYYNNNNYYNNYYNYNNN",
+ "NNYNNNNNNYNNYNNYYNNNNNYNNYNNNY",
+ "NNNNNNNNNNNNNNNNNYNNNNYNNYNNNY",
+ "NNNNNYNNNYNNYNNYNYNNNNYNNNNNYY",
+ "NNNNNYNNNYNNNNNNNNNNNNYNNNNNNN",
+ "NYNYYNYNYNYNNYYNNNYYYYNYYNYNNN",
+ "NNNNNYNNNYNNYNNYYYNNNNYNNNNNNY",
+ "NNNNNNNNNNNNNNNYYYNNNNYNNYNNYY",
+ "YYYYNNYNYNNNNYYNNNYYNNNNYNYYNN",
+ "NNNNNYNNNNNNNNNYNYNNNNYNNYNNYN",
+ "NNNNNYNNNNNNNYNYYNNNNNNNNYNNYY",
+ "YYNNNNYYYNNYNYYNNNNNYNNNYNYYNN",
+ "YYYNNNYNYNYNNYYNNNYYYNNYYNNYNN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 3; 
+END
+/*
+CASE(4)
+	string color = ; 
+	string graph_[] = ;
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = ; 
+END
+CASE(5)
+	string color = ; 
+	string graph_[] = ;
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/589-U/1C-U.cpp
Index: SRM/589-U/1C-U.cpp
==================================================================
--- SRM/589-U/1C-U.cpp
+++ SRM/589-U/1C-U.cpp
@@ -0,0 +1,162 @@
+#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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class FlippingBitsDiv1 { public:
+	int getmin(vector <string> Sv, int M)
+	{
+		string S = accumulate(Sv.begin(), Sv.end(), string());
+		vector< vector<int> > Z(M);
+		for(int i=0; i<S.size(); ++i)
+			Z[i%M].push_back(S[i]-'0');
+
+		int best = S.size();
+		if(M <= 16)
+		{
+			for(int mask=0; mask<(1<<M); ++mask)
+			{
+				vector<int> target(M);
+				for(int i=0; i<M; ++i)
+					target[i] = (mask & (1<<i) ? 1 : 0);
+				best = min(best, solve1(Z, target, M));
+			}
+		}
+		else
+		{
+			int X = Z.back().size();
+			for(int mask=0; mask<(1<<X); ++mask)
+			{
+				vector<int> flip_idx;
+				for(int i=0; i<X; ++i)
+					if(mask & (1<<i))
+						flip_idx.push_back(i);
+				best = min(best, solve2(Z, flip_idx, M));
+			}
+		}
+		return best;
+	}
+
+	int solve1(const vector<vector<int>>& Z, const vector<int>& T, int M)
+	{
+		const int X = Z.front().size();
+		vector<int> nc(X+1), fc(X+1);
+		for(int y=0; y<M; ++y)
+		{
+			vector<int> ncy(X+1);
+			vector<int> fcy(X+1);
+			for(int x=0; x<X; ++x) {
+				ncy[x+1] = ncy[x] + (x>=Z[y].size() ? 0 : (Z[y][x]==T[y] ? 0 : 1));
+				fcy[x+1] = fcy[x] + (x>=Z[y].size() ? 0 : (Z[y][x]==T[y] ? 1 : 0));
+				nc[x+1] += ncy[x+1];
+				fc[x+1] += fcy[x+1];
+			}
+		}
+
+		int INF = 999999;
+		vector<vector<int>> dp(X+1, vector<int>(2));
+		enum {N, F};
+		dp[X][N] = INF;
+		dp[X][F] = -1;
+		for(int x=X-1; x>=0; --x)
+		{
+			dp[x][N] = INF;
+			dp[x][F] = INF;
+			for(int q=x+1; q<=X; ++q) {
+				dp[x][N] = min(dp[x][N], 1+dp[q][F]+(nc[q]-nc[x]));
+				dp[x][F] = min(dp[x][F], 1+dp[q][N]+(fc[q]-fc[x]));
+			}
+		}
+		return min(dp[0][N], dp[0][F]);
+	}
+
+	int solve2(const vector<vector<int>>& Z, const vector<int>& flip_idx, int M)
+	{
+		return -178116;
+	}
+};
+
+// 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(_, FlippingBitsDiv1().getmin(S, M));}
+int main(){
+
+CASE(0)
+	string S_[] = {"00111000"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int M = 1; 
+	int _ = 2; 
+END
+CASE(1)
+	string S_[] = {"101100001101"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int M = 3; 
+	int _ = 2; 
+END
+CASE(2)
+	string S_[] = {"11111111"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int M = 4; 
+	int _ = 0; 
+END
+CASE(3)
+	string S_[] = {"1101001000"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int M = 8; 
+	int _ = 1; 
+END
+CASE(4)
+	string S_[] = {"1","10","11","100","101","110"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int M = 5; 
+	int _ = 4; 
+END
+CASE(5)
+	string S_[] = {"1001011000101010001111111110111011011100110001001"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int M = 2; 
+	int _ = 16; 
+END
+	/*
+CASE(6)
+	string S_[] = ;
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int M = ; 
+	int _ = ; 
+END
+CASE(7)
+	string S_[] = ;
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int M = ; 
+	int _ = ; 
+END
+	*/
+}
+// END CUT HERE