ADDED   SRM/581-U/1A.cpp
Index: SRM/581-U/1A.cpp
==================================================================
--- SRM/581-U/1A.cpp
+++ SRM/581-U/1A.cpp
@@ -0,0 +1,140 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef long double LD;
+typedef complex<double> CMP;
+
+class SurveillanceSystem { public:
+	string getContainerInfo(string containers, vector <int> reports, int L)
+	{
+		const int N = containers.size();
+
+		map< int, vector<int> > seen_to_pos;
+		for(int s=0; s+L<=N; ++s)
+			seen_to_pos[count(containers.begin()+s, containers.begin()+s+L, 'X')].push_back(s);
+
+		map<int,int> seen_to_cnt;
+		for(int i=0; i<reports.size(); ++i)
+			seen_to_cnt[reports[i]]++;
+
+		string result(N, '-');
+		for(map<int,int>::iterator it=seen_to_cnt.begin(); it!=seen_to_cnt.end(); ++it)
+		{
+			int s = it->first;
+			int c = it->second;
+			vector<int>& p = seen_to_pos[s];
+			mask(N, L, p, c, result);
+		}
+		return result;
+	}
+
+	// May/must choose |K| ranges out of |p|. Update |result|.
+	void mask(int N, int L, vector<int>& p, int K, string& result)
+	{
+		assert(K > 0);
+		sort(p.begin(), p.end());
+
+		// Any range can be watched.
+		for(int i=0; i<p.size(); ++i) {
+			for(int x=p[i]; x<p[i]+L; ++x)
+				if(result[x] == '-')
+					result[x] = '?';
+		}
+
+		// Do "always" check.
+		for(int x=0; x<N; ++x) {
+			int cover = 0;
+			for(int i=0; i<p.size(); ++i)
+				if(p[i]<=x && x<p[i]+L)
+					++cover;
+			// If |x| is covered by some range but avoiding them leaves <K...
+			if(cover && (p.size()-cover) < K)
+				result[x] = '+';
+		}
+	}
+};
+
+// 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 string& Expected, const 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(_, SurveillanceSystem().getContainerInfo(containers, reports, L));}
+int main(){
+
+CASE(0)
+	string containers = "-X--XX"; 
+	int reports_[] = {1, 2};
+	  vector <int> reports(reports_, reports_+sizeof(reports_)/sizeof(*reports_)); 
+	int L = 3; 
+	string _ = "??++++"; 
+END
+CASE(1)
+	string containers = "-XXXXX-"; 
+	int reports_[] = {2};
+	  vector <int> reports(reports_, reports_+sizeof(reports_)/sizeof(*reports_)); 
+	int L = 3; 
+	string _ = "???-???"; 
+END
+CASE(2)
+	string containers = "------X-XX-"; 
+	int reports_[] = {3, 0, 2, 0};
+	  vector <int> reports(reports_, reports_+sizeof(reports_)/sizeof(*reports_)); 
+	int L = 5; 
+	string _ = "++++++++++?"; 
+END
+CASE(3)
+	string containers = "-XXXXX---X--"; 
+	int reports_[] = {2, 1, 0, 1};
+	  vector <int> reports(reports_, reports_+sizeof(reports_)/sizeof(*reports_)); 
+	int L = 3; 
+	string _ = "???-??++++??"; 
+END
+CASE(4)
+	string containers = "-XX--X-XX-X-X--X---XX-X---XXXX-----X"; 
+	int reports_[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
+	  vector <int> reports(reports_, reports_+sizeof(reports_)/sizeof(*reports_)); 
+	int L = 7; 
+	string _ = "???++++?++++++++++++++++++++??????--"; 
+END
+/*
+CASE(5)
+	string containers = ; 
+	int reports_[] = ;
+	  vector <int> reports(reports_, reports_+sizeof(reports_)/sizeof(*reports_)); 
+	int L = ; 
+	string _ = ; 
+END
+CASE(6)
+	string containers = ; 
+	int reports_[] = ;
+	  vector <int> reports(reports_, reports_+sizeof(reports_)/sizeof(*reports_)); 
+	int L = ; 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/581-U/1B.cpp
Index: SRM/581-U/1B.cpp
==================================================================
--- SRM/581-U/1B.cpp
+++ SRM/581-U/1B.cpp
@@ -0,0 +1,145 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef long double LD;
+typedef complex<double> CMP;
+
+class TreeUnion { public:
+	double expectedCycles(vector <string> tree1, vector <string> tree2, int K)
+	{
+		vector<int> t1, t2;
+		{
+			stringstream sin(accumulate(tree1.begin(), tree1.end(), string()));
+			for(int v; sin>>v; ) t1.push_back(v);
+		}
+		{
+			stringstream sin(accumulate(tree2.begin(), tree2.end(), string()));
+			for(int v; sin>>v; ) t2.push_back(v);
+		}
+
+		int N = t1.size() + 1;
+		vector<vector<int> > d1 = make_d(t1, N);
+		vector<vector<int> > d2 = make_d(t2, N);
+
+		map<int, int> len_to_cnt_2;
+		for(int u=0; u<N; ++u)
+		for(int v=u+1; v<N; ++v)
+			len_to_cnt_2[d2[u][v]] += 2;
+		int total = N * (N-1);
+
+		double e = 0.0;
+		for(int u=0; u<N; ++u)
+		for(int v=u+1; v<N; ++v)
+		{
+			e += (double)len_to_cnt_2[K - 2 - d1[u][v]] / total;
+		}
+		return e;
+	}
+
+	vector<vector<int> > make_d(const vector<int>& x, int N)
+	{
+		vector<vector<int> > d(N, vector<int>(N, 0x3fffffff));
+		for(int i=0; i<N; ++i) d[i][i] = 0;
+		for(int i=0; i<x.size(); ++i) {
+			d[i+1][x[i]] = 1;
+			d[x[i]][i+1] = 1;
+		}
+		for(int k=0; k<N; ++k)
+		for(int i=0; i<N; ++i)
+		for(int j=0; j<N; ++j)
+			d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
+		return d;
+	}
+};
+
+// 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 double& Expected, const double& Received) {
+ bool ok = (abs(Expected - Received) < 1e-9);
+ 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(_, TreeUnion().expectedCycles(tree1, tree2, K));}
+int main(){
+
+CASE(0)
+	string tree1_[] = {"0"};
+	  vector <string> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	string tree2_[] = {"0"};
+	  vector <string> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	int K = 4; 
+	double _ = 1.0; 
+END
+CASE(1)
+	string tree1_[] = {"0 1"};
+	  vector <string> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	string tree2_[] = {"0 1"};
+	  vector <string> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	int K = 4; 
+	double _ = 1.3333333333333333; 
+END
+CASE(2)
+	string tree1_[] = {"0 1"};
+	  vector <string> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	string tree2_[] = {"0 1"};
+	  vector <string> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	int K = 6; 
+	double _ = 0.3333333333333333; 
+END
+CASE(3)
+	string tree1_[] = {"0 ", "1 1 1"};
+	  vector <string> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	string tree2_[] = {"0 1 0 ", "1"};
+	  vector <string> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	int K = 5; 
+	double _ = 4.0; 
+END
+CASE(4)
+	string tree1_[] = {"0 1 2 0 1 2 0 1 2 5 6 1", "0 11", " 4"};
+	  vector <string> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	string tree2_[] = {"0 1 1 0 2 3 4 3 4 6 6", " 10 12 12"};
+	  vector <string> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	int K = 7; 
+	double _ = 13.314285714285713; 
+END
+/*
+CASE(5)
+	string tree1_[] = ;
+	  vector <string> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	string tree2_[] = ;
+	  vector <string> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	int K = ; 
+	double _ = ; 
+END
+CASE(6)
+	string tree1_[] = ;
+	  vector <string> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	string tree2_[] = ;
+	  vector <string> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	int K = ; 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/581-U/1C.cpp
Index: SRM/581-U/1C.cpp
==================================================================
--- SRM/581-U/1C.cpp
+++ SRM/581-U/1C.cpp
@@ -0,0 +1,176 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef long double LD;
+typedef complex<double> CMP;
+
+static const int INF = 0x1fffffff;
+
+int bitcnt(int x)
+{
+	int c = 0;
+	for(; x; x>>=1)
+		c += x&1;
+	return c;
+}
+
+class YetAnotherBoardGame { public:
+	int g_best;
+	int minimumMoves(vector <string> board)
+	{
+		int H = board.size();
+		int W = board[0].size();
+		vector<int> b(H);
+		for(int y=0; y<H; ++y)
+			for(int x=0; x<W; ++x)
+				b[y] |= (board[y][x]=='W')<<x;
+		b.push_back(0); // sentinel
+
+		g_best = INF;
+		for(int type=1; type<=2; ++type)
+			for(int mask=0; mask<(1<<W); ++mask)
+			{
+				int cur = b[0];
+				int next = b[1];
+				flip(cur, next, mask, type, W);
+				do_try(cur, next, b, 1, H, W, (type==1 ? mask : 0), (type==2 ? mask : 0), bitcnt(mask));
+			}
+		return g_best==INF ? -1 : g_best;
+	}
+
+	void flip(int& cur, int& next, int mask, int type, int W)
+	{
+		int pat = (type==1 ? 5 : 7);
+		for(int f=0; (1<<f)<=mask; ++f)
+			if((1<<f) & mask)
+				cur ^= (pat<<f>>1)&((1<<W)-1);
+		next ^= mask;
+	}
+
+	void do_try(int prev, int cur, const vector<int>& b, int y, int H, int W, int must_t1, int must_t2, int acc)
+	{
+		if(y==H) {
+			int score = (prev==0 ? 0 : INF) + acc;
+			g_best = min(g_best, score);
+			return;
+		}
+
+		int mask = prev;
+		int score = bitcnt(mask) + acc;
+		if(score >= g_best)
+			return;
+
+		if(!(mask&must_t2)) { // try type 1
+			int curr = cur;
+			int next = b[y+1];
+			flip(curr, next, mask, 1, W);
+			do_try(curr, next, b, y+1, H, W, must_t1|mask, must_t2, score);
+		}
+		if(!(mask&must_t1)) { // try type 2
+			int curr = cur;
+			int next = b[y+1];
+			flip(curr, next, mask, 2, W);
+			do_try(curr, next, b, y+1, H, W, must_t1, must_t2|mask, score);
+		}
+	}
+};
+
+// 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(_, YetAnotherBoardGame().minimumMoves(board));}
+int main(){
+
+CASE(0)
+	string board_[] = {"BBBBBBBBB",
+ "BBWBBBBBB",
+ "BWWWBBBBB",
+ "BBWBBBWBB",
+ "BBBBBWBWB",
+ "BBBBBBWBB"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 2; 
+END
+CASE(1)
+	string board_[] = {"BBW",
+ "WWW",
+ "BWW"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 2; 
+END
+CASE(2)
+	string board_[] = {"WBW",
+ "BBW",
+ "WBW"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 4; 
+END
+CASE(3)
+	string board_[] = {"BBBB",
+ "WBWB",
+ "BBBB",
+ "BBBB"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = -1; 
+END
+CASE(4)
+	string board_[] = {"WWWWWBW",
+ "WBWBWBW",
+ "BBWBBWW"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 7; 
+END
+CASE(5)
+	string board_[] = {"WWWWWWWWWW",
+ "WWWWWWWWWW",
+ "WWWWWWWWWW",
+ "WWWWWWWWWW",
+ "WWWWWWWWWW",
+ "WWWWWWWWWW",
+ "WWWWWWWWWW",
+ "WWWWWWWWWW",
+ "WWWWWWWWWW",
+ "WWWWWWWWWW"}
+;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 30; 
+END
+/*
+CASE(6)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = ; 
+END
+CASE(7)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE