ADDED   CheckList.pptx
Index: CheckList.pptx
==================================================================
--- CheckList.pptx
+++ CheckList.pptx
cannot compute difference between binary files

ADDED   SRM/144/1A.cpp
Index: SRM/144/1A.cpp
==================================================================
--- SRM/144/1A.cpp
+++ SRM/144/1A.cpp
@@ -0,0 +1,26 @@
+#include <vector>
+#include <string>
+using namespace std;
+
+struct BinaryCode
+{
+	vector<string> decode( string message )
+	{
+		vector<string> ans;
+		ans.push_back( decode(0, message) );
+		ans.push_back( decode(1, message) );
+		return ans;
+	}
+
+	string decode(int c, string Q)
+	{
+		string P; P += char('0'+c);
+		for(int i=0; i<Q.size()-1; ++i)
+			if( '0' <= Q[i]-c && Q[i]-c<='1' )
+				P += char(Q[i]-c),
+				c = P[P.size()-2]-'0' + P[P.size()-1]-'0';
+			else
+				return "NONE";
+		return c==Q[Q.size()-1]-'0' ? P : "NONE";
+	}
+};

ADDED   SRM/144/1B.cpp
Index: SRM/144/1B.cpp
==================================================================
--- SRM/144/1B.cpp
+++ SRM/144/1B.cpp
@@ -0,0 +1,44 @@
+#include <vector>
+#include <string>
+#include <sstream>
+#include <utility>
+#include <algorithm>
+using namespace std;
+
+struct Lottery
+{
+	vector<string> sortByOdds(vector<string> rules)
+	{
+		vector< pair<long long, string> > lots;
+		for(int i=0; i<rules.size(); ++i)
+		{
+			stringstream sin(rules[i]);
+			string name;
+			int  ch, bl;
+			char so, un;
+			getline(sin, name, ':') >> ch >> bl >> so >> un;
+
+			lots.push_back( make_pair(numChoice(ch,bl,so=='T',un=='T'), name) );
+		}
+		sort( lots.begin(), lots.end() );
+
+		vector<string> ans;
+		for(int i=0; i<lots.size(); ++i)
+			ans.push_back( lots[i].second );
+		return ans;
+	}
+
+	long long numChoice(long long ch, long long bl, bool so, bool un)
+	{
+		// Note: so && !un
+		//   3 out of 5  ===
+		//      +|++++[5][5][5], +|+++[4]+[5][5], +|+++[4][4]+[5], ...
+		//   === 3+5-1 C 3
+		long long a = 1;
+		if(so)
+			for(long long i=1; i<=bl; ++i) a = a*(ch-i+(un?1:bl))/i;
+		else
+			while(bl--) a *= (un ? ch-- : ch);
+		return a;
+	}
+};

ADDED   SRM/144/1C.cpp
Index: SRM/144/1C.cpp
==================================================================
--- SRM/144/1C.cpp
+++ SRM/144/1C.cpp
@@ -0,0 +1,73 @@
+#include <vector>
+#include <string>
+#include <sstream>
+#include <set>
+#include <map>
+using namespace std;
+
+struct PenLift
+{
+	typedef pair<int, int>           point;
+	typedef map< point, set<point> > graph;
+
+	int numTimes( vector<string> segments, int n )
+	{
+		// Determine All Significant Coordinates
+		set<int> xs, ys;
+		for(int i=0; i<segments.size(); ++i)
+		{
+			stringstream sin(segments[i]);
+			int x1, y1, x2, y2; sin >> x1 >> y1 >> x2 >> y2;
+			xs.insert(x1);
+			xs.insert(x2);
+			ys.insert(y1);
+			ys.insert(y2);
+		}
+
+		// Construct the graph, separated by all significant coordinates
+		graph G;
+		for(int i=0; i<segments.size(); ++i)
+		{
+			stringstream sin(segments[i]);
+			int x1, y1, x2, y2; sin >> x1 >> y1 >> x2 >> y2;
+			if( x1 == x2 )
+			{
+				set<int>::iterator it = ys.lower_bound(min(y1,y2));
+				set<int>::iterator ed = ys.upper_bound(max(y1,y2));
+				for(set<int>::iterator pv=it++; it!=ed; ++it,++pv)
+					G[point(x1,*pv)].insert(point(x1,*it)),
+					G[point(x1,*it)].insert(point(x1,*pv));
+			}
+			else
+			{
+				set<int>::iterator it = xs.lower_bound(min(x1,x2));
+				set<int>::iterator ed = xs.upper_bound(max(x1,x2));
+				for(set<int>::iterator pv=it++; it!=ed; ++it,++pv)
+					G[point(*pv,y1)].insert(point(*it,y1)),
+					G[point(*it,y1)].insert(point(*pv,y1));
+			}
+		}
+
+		// count the number of odd vertices (/2) per connected components
+		set<point> vis;
+
+		int cnt = 0;
+		for(graph::iterator s=G.begin(); s!=G.end(); ++s)
+			if( !vis.count(s->first) )
+				cnt += max(1, numOdd(s->first, G, vis, n)/2);
+		return cnt - 1; // first touch do not require a pen-lift
+	}
+
+	// simple dfs
+	int numOdd( point p, graph& G, set<point>& vis, int n )
+	{
+		if( vis.count(p) )
+			return 0;
+		vis.insert(p);
+
+		int cnt = G[p].size()*n % 2; // if odd degree then 1 else 0
+		for(set<point>::iterator it=G[p].begin(); it!=G[p].end(); ++it)
+			cnt += numOdd(*it, G, vis, n);
+		return cnt;
+	}
+};

ADDED   SRM/145/1A.cpp
Index: SRM/145/1A.cpp
==================================================================
--- SRM/145/1A.cpp
+++ SRM/145/1A.cpp
@@ -0,0 +1,27 @@
+#include <vector>
+#include <numeric>
+#include <algorithm>
+#include <utility>
+using namespace std;
+
+struct Bonuses
+{
+	vector<int> getDivision(vector<int> points)
+	{
+		int sum = accumulate(points.begin(), points.end(), 0);
+
+		int left = 100;
+		vector<int> ans(points.size());
+		for(int i=0; i<points.size(); ++i)
+			left -= (ans[i] = points[i]*100/sum);
+
+		vector< pair<int,int> > poid(points.size());
+		for(int i=0; i<points.size(); ++i)
+			poid[i] = make_pair( -points[i], i );
+		sort(poid.begin(), poid.end());
+
+		for(int i=0; left--; ++i)
+			ans[poid[i].second]++;
+		return ans;
+	}
+};

ADDED   SRM/145/1B.cpp
Index: SRM/145/1B.cpp
==================================================================
--- SRM/145/1B.cpp
+++ SRM/145/1B.cpp
@@ -0,0 +1,59 @@
+#include <vector>
+#include <string>
+#include <sstream>
+#include <cstdlib>
+using namespace std;
+
+struct VendingMachine
+{
+	int motorUse(vector<string> prices, vector<string> purchases)
+	{
+		vector<int>           sum;
+		vector< vector<int> > pri(prices.size());
+		for(int i=0; i<prices.size(); ++i)
+		{
+			stringstream sin(prices[i]);
+			for(int j=0,n; sin>>n; ++j)
+				{if(j>=sum.size())sum.push_back(0); sum[j]+=n; pri[i].push_back(n);}
+		}
+		int M = pri[0].size();
+
+		int mot = 0;
+		int pc=0, pt=-5;
+		for(int i=0; i<purchases.size(); ++i)
+		{
+			stringstream sin(purchases[i]);
+			string a; getline(sin,a,',');
+			string b; getline(sin,b,':');
+			string c; getline(sin,c);
+			int sh = atoi(a.c_str());
+			int cl = atoi(b.c_str());
+			int  t = atoi(c.c_str());
+
+			if( pri[sh][cl] == 0 )
+				return -1;
+
+			if( t-pt >= 5 )
+			{
+				// rotate
+				int hc = max_element(sum.begin(), sum.end()) - sum.begin();
+				mot += min( abs(hc-pc), M-abs(hc-pc) );
+				pc = hc;
+			}
+
+			// buy
+			sum[cl]    -= pri[sh][cl];
+			pri[sh][cl] = 0;
+			mot += min( abs(cl-pc), M-abs(cl-pc) );
+			pc = cl;
+			pt = t;
+		}
+
+		// rotate
+		int hc = max_element(sum.begin(), sum.end()) - sum.begin();
+		mot += min( abs(hc-pc), M-abs(hc-pc) );
+		pc = hc;
+
+		return mot;
+	}
+};

ADDED   SRM/145/1C.cpp
Index: SRM/145/1C.cpp
==================================================================
--- SRM/145/1C.cpp
+++ SRM/145/1C.cpp
@@ -0,0 +1,46 @@
+#include <vector>
+using namespace std;
+
+struct HillHike
+{
+	long long numPaths(int distance, int maxHeight, vector<int> landmarks)
+	{
+		// reached-maxHeight?, #reached-landmarks, current-height
+		long long buf1[2][51][51]={0}, buf2[2][51][51], (*dp)[51][51]=buf1;
+		dp[0][0][0] = 1;
+
+		for(int d=1; d<=distance; ++d)
+		{
+			long long (*dp2)[51][51] = (dp==buf1 ? buf2 : buf1);
+			memset(dp2, 0, sizeof(long long)*2*51*51);
+
+			for(int rm=0; rm<=1; ++rm)
+				for(int rl=0; rl<=landmarks.size(); ++rl)
+					for(int ch=0; ch<=maxHeight; ++ch)
+					{
+						if(ch>1 || d==distance && ch>0)
+						{
+							dp2[rm]
+							   [rl<landmarks.size() && landmarks[rl]==ch-1 ? rl+1 : rl]
+							   [ch-1] += dp[rm][rl][ch];
+						}
+						if(ch>0 || d==distance)
+						{
+							dp2[rm]
+							   [rl<landmarks.size() && landmarks[rl]==ch ? rl+1 : rl]
+							   [ch] += dp[rm][rl][ch];
+						}
+						if( ch<maxHeight )
+						{
+							dp2[ch+1==maxHeight ? 1 : rm]
+							   [rl<landmarks.size() && landmarks[rl]==ch+1 ? rl+1 : rl]
+							   [ch+1] += dp[rm][rl][ch];
+						}
+					}
+
+			dp = dp2;
+		}
+
+		return dp[1][landmarks.size()][0];
+	}
+};

ADDED   SRM/146/1A.cpp
Index: SRM/146/1A.cpp
==================================================================
--- SRM/146/1A.cpp
+++ SRM/146/1A.cpp
@@ -0,0 +1,14 @@
+using namespace std;
+
+struct RectangularGrid
+{
+	long long countRectangles(int width, int height)
+	{
+		long long w = width+1;
+		long long h = height+1;
+		long long s = w*(w-1)/2*h*(h-1)/2;
+		for(long long x=1; x<w && x<h; ++x)
+			s -= (w-x)*(h-x);
+		return s;
+	}
+};

ADDED   SRM/146/1B.cpp
Index: SRM/146/1B.cpp
==================================================================
--- SRM/146/1B.cpp
+++ SRM/146/1B.cpp
@@ -0,0 +1,52 @@
+#include <vector>
+#include <string>
+#include <set>
+#include <algorithm>
+#include <iterator>
+using namespace std;
+
+struct Masterbrain
+{
+	int possibleSecrets(vector<string> guesses, vector<string> results)
+	{
+		int N = guesses.size();
+		int cnt = 0;
+		for(int n=0; n<7*7*7*7; ++n)
+		{
+			int x[] = {n/7/7/7%7+1,n/7/7%7+1,n/7%7+1,n%7+1};
+
+			bool possible = false;
+			for(int lie=0; lie<N && !possible; ++lie)
+			{
+				bool possible_by_the_lie = true;
+				for(int i=0; i<N && possible_by_the_lie; ++i)
+				{
+					int g[] = {guesses[i][0]-'0',guesses[i][1]-'0',guesses[i][2]-'0',guesses[i][3]-'0'};
+					int b = results[i][0]-'0';
+					int w = results[i][3]-'0';
+
+					if( (i==lie) == match(x,g,b,w) )
+						possible_by_the_lie = false;
+				}
+				possible |= possible_by_the_lie;
+			}
+			if( possible )
+				++cnt;
+		}
+		return cnt;
+	}
+
+	bool match(int x[], int g[], int b, int w)
+	{
+		int true_b = 0;
+		multiset<int> xs, gs;
+		for(int i=0; i<4; ++i)
+			if( g[i] == x[i] )
+				true_b++;
+			else
+				xs.insert(x[i]), gs.insert(g[i]);
+		vector<int> p;
+		set_intersection(xs.begin(), xs.end(), gs.begin(), gs.end(), back_inserter(p));
+		return true_b==b && w==p.size();
+	}
+};

ADDED   SRM/146/1C.cpp
Index: SRM/146/1C.cpp
==================================================================
--- SRM/146/1C.cpp
+++ SRM/146/1C.cpp
@@ -0,0 +1,64 @@
+#include <string>
+#include <queue>
+#include <algorithm>
+using namespace std;
+
+struct Roundabout
+{
+	int clearUpTime(string north, string east, string south, string west)
+	{
+		char        M[4] = {'N', 'E', 'S', 'W'};
+		string      C[4] = {north, east, south, west};
+		char        R[4] = {'-', '-', '-', '-'};
+		queue<char> Q[4];
+
+		int N = 0;
+		for(int i=0; i<4; ++i)
+			for(int j=0; j<C[i].size(); ++j)
+				if( C[i][j] != '-' )
+					++N;
+
+		int t = 0;
+		for( ;; ++t )
+		{
+			// leave
+			for(int i=0; i<4; ++i)
+				if( R[i] == M[i] )
+					R[i] = M[i]-'A'+'a', --N; // put ghosts
+			if( !N )
+				return t;
+
+			// rotate
+			rotate( R+0, R+1, R+4 );
+
+			// enter
+			if( !Q[0].empty() && !Q[1].empty() && !Q[2].empty() && !Q[3].empty() )
+			{
+				if( R[0]=='-' )
+					R[0] = Q[0].front(), Q[0].pop();
+			}
+			else
+			{
+				bool Go[] = {
+					R[0]=='-' && Q[1].empty(),
+					R[1]=='-' && Q[2].empty(),
+					R[2]=='-' && Q[3].empty(),
+					R[3]=='-' && Q[0].empty(),
+				};
+				for(int i=0; i<4; ++i)
+					if( Go[i] && !Q[i].empty() )
+						R[i] = Q[i].front(), Q[i].pop();
+			}
+
+			// clear ghost
+			for(int i=0; i<4; ++i)
+				if( 'a'<=R[i] && R[i]<='z' )
+					R[i] = '-';
+
+			// queue
+			for(int i=0; i<4; ++i)
+				if( t < C[i].size() && C[i][t]!='-' )
+					Q[i].push( C[i][t] );
+		}
+	}
+};

ADDED   SRM/245/1A.cpp
Index: SRM/245/1A.cpp
==================================================================
--- SRM/245/1A.cpp
+++ SRM/245/1A.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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+double f(int a, int n)
+{
+	double x = 1;
+	while( n --> 0 )
+		x *= a--;
+	return x;
+}
+double f(int a)
+{
+	return f(a, a);
+}
+double C(int n, int k)
+{
+	return f(n,k) / f(k,k);
+}
+
+class Flush
+{
+public:
+	double size(vector <int> suits, int number) 
+	{
+		double all = f(accumulate(suits.begin(), suits.end(), 0), number);
+
+		double ans = 0;
+		for(int i1=0; i1<=number && i1<=suits[0]; ++i1)
+		for(int i2=0; i1+i2<=number && i2<=suits[1]; ++i2)
+		for(int i3=0; i1+i2+i3<=number && i3<=suits[2]; ++i3)
+		{
+			int i4 = number - i1 - i2 - i3;
+			if( i4 <= suits[3] ) {
+				double nf = max(max(i1,i2),max(i3,i4));
+				double n = C(number, i1) * C(number-i1, i2) * C(number-i1-i2, i3)
+					* f(suits[0],i1) * f(suits[1],i2) * f(suits[2],i3) * f(suits[3],i4);
+				ans += nf * n/all;
+			}
+		}
+		return ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int suits_[] = {2,2,2,2};
+	  vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_)); 
+	int number = 2; 
+	double RetVal = 1.1428571428571428; 
+	return verify_case(RetVal, Flush().size(suits, number)); }
+int Test_(Case_<1>) {
+	int suits_[] = {1,4,7,10};
+	  vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_)); 
+	int number = 22; 
+	double RetVal = 10.0; 
+	return verify_case(RetVal, Flush().size(suits, number)); }
+int Test_(Case_<2>) {
+	int suits_[] = {13, 13, 13, 13};
+	  vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_)); 
+	int number = 49; 
+	double RetVal = 13.0; 
+	return verify_case(RetVal, Flush().size(suits, number)); }
+int Test_(Case_<3>) {
+	int suits_[] = {13, 13, 13, 13};
+	  vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_)); 
+	int number = 26; 
+	double RetVal = 8.351195960938014; 
+	return verify_case(RetVal, Flush().size(suits, number)); }
+int Test_(Case_<4>) {
+	int suits_[] = {13,13,13,13};
+	  vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_)); 
+	int number = 0; 
+	double RetVal = 0.0; 
+	return verify_case(RetVal, Flush().size(suits, number)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/245/1B.cpp
Index: SRM/245/1B.cpp
==================================================================
--- SRM/245/1B.cpp
+++ SRM/245/1B.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class BikeLock
+{
+public:
+	map<pair<int,string>,int> memo;
+	int minTurns(string current, string desired) 
+	{
+		current += "__";
+		return rec(0, current.size()-2, current, desired);
+	}
+
+	int rec(int i, int N, string& s, const string& d)
+	{
+		if( i == N )
+			return 0;
+		if( s[i] == d[i] )
+			return rec(i+1, N, s, d);
+		pair<int,string> key( i, s.substr(i,3) );
+		if( memo.count(key) )
+			return memo[key];
+		memo[key] = 9999;
+
+		int ans = 9999;
+		for(int w=1; w<=3; ++w)
+			for(int r=-3; r<=3; ++r) if(r)
+			{
+				for(int j=0; j<w; ++j)
+					s[i+j] = (s[i+j]-'0'+10+r)%10+'0';
+				ans = min(ans, 1 + rec(i, N, s, d));
+				for(int j=0; j<w; ++j)
+					s[i+j] = (s[i+j]-'0'+10-r)%10+'0';
+			}
+		return memo[key] = ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string current = "555"; 
+	string desired = "464"; 
+	int RetVal = 2; 
+	return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
+int Test_(Case_<1>) {
+	string current = "1234"; 
+	string desired = "3456"; 
+	int RetVal = 2; 
+	return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
+int Test_(Case_<2>) {
+	string current = "06012005"; 
+	string desired = "06012005"; 
+	int RetVal = 0; 
+	return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
+int Test_(Case_<3>) {
+	string current = "123456789"; 
+	string desired = "567412490"; 
+	int RetVal = 5; 
+	return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
+int Test_(Case_<4>) {
+	string current = "23887547676234543215443276347856987698648735634265"; 
+	string desired = "14327805497625497814327632146531429785698765309822"; 
+	int RetVal = 34; 
+	return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/245/1C.cpp
Index: SRM/245/1C.cpp
==================================================================
--- SRM/245/1C.cpp
+++ SRM/245/1C.cpp
@@ -0,0 +1,160 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+int N;
+vector<int> A;
+
+typedef int vert;
+typedef int cost;
+typedef pair<cost,vert> edge;
+typedef vector<edge>    edges;
+
+vector<int> dijkstra_like( vert S, int T, int I )
+{
+	set<int> ans;
+	for(int i=1; i<=I; ++i) ans.insert(i);
+
+	priority_queue< edge, edges, greater<edge> > Q;
+	Q.push( edge(0, S) );
+
+//	set<vert> vis;
+	vector<bool> vis(1<<24);
+
+	while( !Q.empty() )
+	{
+		edge ce=Q.top(); Q.pop();
+
+		int  t = ce.first;
+		vert v = ce.second;
+		if( vis[v] )
+			continue;
+		vis[v]=true;
+
+		int sw = v&511;
+		int a[] = {(v>>9)&31, (v>>14)&31, (v>>19)&31};
+
+		ans.erase(sw);
+		for(int i=0; i<(1<<N+1); ++i)
+		{
+			int sw2 = sw;
+			int a2[] = {a[0], a[1], a[2]};
+
+			int nzMin = 9999;
+			for(int j=0; j<N; ++j) {
+				if( (i&(1<<j)) )
+					a2[j] = A[j]-a2[j];
+				if( a2[j] )
+					nzMin = min(nzMin, a2[j]);
+			}
+			if( (i&(1<<N)) ) sw2 = 0;
+			if( nzMin==9999 ) continue;
+			if( t+nzMin > T )
+				continue;
+			for(int j=0; j<N; ++j)
+				if( a2[j] )
+					a2[j] -= nzMin;
+			sw2 += nzMin;
+			vert u = sw2 | (a2[0]<<9) | (a2[1]<<14) | (a2[2]<<19);
+			if( !vis[u] ) {
+				Q.push( edge(t+nzMin,u) );
+			}
+		}
+	}
+	return vector<int>(ans.begin(), ans.end());
+}
+
+class SandTimers
+{
+public:
+	vector <int> badIntervals(vector <int> timers, int maxInterval, int maxTime) 
+	{
+		N = timers.size();
+		A = timers;
+		return dijkstra_like( vert(), maxTime, maxInterval );
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int timers_[] = { 5, 7 };
+	  vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_)); 
+	int maxInterval = 10; 
+	int maxTime = 10; 
+	int RetVal_[] = {1, 6, 8 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
+int Test_(Case_<1>) {
+	int timers_[] = { 2, 10, 20 };
+	  vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_)); 
+	int maxInterval = 30; 
+	int maxTime = 40; 
+	int RetVal_[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
+int Test_(Case_<2>) {
+	int timers_[] = { 2, 5, 9 };
+	  vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_)); 
+	int maxInterval = 360; 
+	int maxTime = 360; 
+	vector <int> RetVal; 
+	return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
+int Test_(Case_<3>) {
+	int timers_[] = { 4 };
+	  vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_)); 
+	int maxInterval = 23; 
+	int maxTime = 47; 
+	int RetVal_[] = {1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 18, 19, 21, 22, 23 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
+int Test_(Case_<4>) {
+	int timers_[] = { 20, 13 };
+	  vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_)); 
+	int maxInterval = 30; 
+	int maxTime = 30; 
+	int RetVal_[] = {1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 28, 29, 30 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
+int Test_(Case_<5>) {
+	int timers_[] = { 20, 17, 13 };
+	  vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_)); 
+	int maxInterval = 25; 
+	int maxTime = 30; 
+	int RetVal_[] = {18, 19 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
+int Test_(Case_<6>) {
+	int timers_[] = { 20, 20, 19 };
+	  vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_)); 
+	int maxInterval = 360; 
+	int maxTime = 360; 
+	vector <int> RetVal; 
+	return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/264/1A.cpp
Index: SRM/264/1A.cpp
==================================================================
--- SRM/264/1A.cpp
+++ SRM/264/1A.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class DivisibilityRules
+{
+public:
+	int similar(int numerationBase, int divisor) 
+	{
+		vector< vector<int> > mb;
+		for(int k=2; k<numerationBase; ++k)
+			mb.push_back( mbase(numerationBase, k) );
+		return count( mb.begin(), mb.end(), mb[divisor-2] );
+	}
+
+	vector<int> mbase(int n, int k)
+	{
+		vector<int> r;
+		int b = 1;
+		for(int i=0; i<n; ++i) {
+			r.push_back(b);
+			b = (b*n)%k;
+		}
+		return r;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 10; int Arg1 = 3; int Arg2 = 2; verify_case(0, Arg2, similar(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 10; int Arg1 = 5; int Arg2 = 2; verify_case(1, Arg2, similar(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 511; int Arg1 = 32; int Arg2 = 10; verify_case(2, Arg2, similar(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 3; int Arg1 = 2; int Arg2 = 1; verify_case(3, Arg2, similar(Arg0, Arg1)); }
+	void test_case_4() { int Arg0 = 1000; int Arg1 = 999; int Arg2 = 7; verify_case(4, Arg2, similar(Arg0, Arg1)); }
+	void test_case_5() { int Arg0 = 655; int Arg1 = 532; int Arg2 = 1; verify_case(5, Arg2, similar(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { DivisibilityRules().run_test(-1); }
+// END CUT HERE

ADDED   SRM/264/1B.cpp
Index: SRM/264/1B.cpp
==================================================================
--- SRM/264/1B.cpp
+++ SRM/264/1B.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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+int gcd(int x, int y)
+{
+	while(y) {
+		int t = x;
+		x = y;
+		y = t%y;
+	}
+	return x;
+}
+
+class GradingGridIns
+{
+public:
+	vector <string> score(vector <string> answer, vector <int> lower, vector <int> upper) 
+	{
+		int lg = gcd(lower[0], lower[1]);
+		double la=lower[0]/lg, lb=lower[1]/lg;
+		int ug = gcd(upper[0], upper[1]);
+		double ua=upper[0]/ug, ub=upper[1]/ug;
+
+		vector<double> world;
+
+		char c[] = " ./0123456789";
+		for(int i=0; i<sizeof(c)-1; ++i)
+		for(int j=0; j<sizeof(c)-1; ++j)
+		for(int k=0; k<sizeof(c)-1; ++k)
+		for(int l=0; l<sizeof(c)-1; ++l) {
+			try {
+				double d = eval( string(1,c[i])+c[j]+c[k]+c[l] );
+				world.push_back(d);
+			} catch( const char* ) {
+			}
+		}
+
+		sort(world.begin(), world.end());
+		world.erase(unique(world.begin(), world.end()), world.end());
+		vector<double>::iterator lt = lower_bound( world.begin(), world.end(), la/lb );
+		vector<double>::iterator ut = upper_bound( world.begin(), world.end(), ua/ub );
+		if( lt!=world.begin() ) --lt;
+
+		vector<string> result(answer.size());
+		for(int i=0; i<answer.size(); ++i)
+		{
+			try {
+				double d = eval(answer[i]);
+				result[i] = (*lt<=d && (ut==world.end() || d<=*ut) ? "CORRECT" : "INCORRECT");
+			} catch( const char* ) {
+				result[i] = "MALFORMED";
+			}
+		}
+		return result;
+	}
+
+	static double eval( string ans )
+	{
+		int ii=0; while(ii<ans.size()&&ans[ii]==' ') ++ii;
+		ans = ans.substr(ii);
+		ii = ans.size(); while(ii>0 && ans[ii-1]==' ') --ii;
+		ans = ans.substr(0, ii);
+
+
+		int dot=-1, sla=-1, numdig=0;
+		int value = 0, value_pre = 0;
+		for(int i=0; i<ans.size(); ++i)
+			if( ans[i]=='.' )
+			{
+				if(dot>=0 || sla>=0)
+					throw "MALFORMED";
+				dot = i;
+				value_pre = value;
+				value = 0;
+			}
+			else if( ans[i]=='/' )
+			{
+				if(dot>=0 || sla>=0 || numdig==0 )
+					throw "MALFORMED";
+				sla = i;
+				value_pre = value;
+				value = 0;
+			}
+			else if( '0'<=ans[i] && ans[i]<='9' )
+			{
+				++numdig;
+				value = value*10 + ans[i]-'0';
+			}
+			else
+				throw "MALFORMED";
+		if(numdig==0)
+			throw "MALFORMED";
+
+		int L = value_pre, R = value;
+		if( sla >= 0 ) {
+			if( R == 0 )
+				throw "MALFORMED";
+			int g = gcd(L,R); L/=g, R/=g;
+			return L/double(R);
+		}
+		else if( dot >= 0 ) {
+			return L + R / pow(10.0, double(ans.size()-dot-1));
+		}
+		else {
+			return R;
+		}
+	}
+
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const vector <string> &Expected, const vector <string> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
+	void test_case_0() { string Arr0[] = {"4/7 "," 4/7","4/07","8/14",".571",".572"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {4,7}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {4,7}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"CORRECT", "CORRECT", "CORRECT", "CORRECT", "CORRECT", "CORRECT" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(0, Arg3, score(Arg0, Arg1, Arg2)); }
+	void test_case_1() { string Arr0[] = {" 4/7","1.01","1.02"," 000"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"CORRECT", "CORRECT", "INCORRECT", "CORRECT" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(1, Arg3, score(Arg0, Arg1, Arg2)); }
+	void test_case_2() { string Arr0[] = {"1.15","1 14","1.14"," 8/7"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1142,1000}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1142,1000}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"INCORRECT", "MALFORMED", "CORRECT", "CORRECT" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(2, Arg3, score(Arg0, Arg1, Arg2)); }
+	void test_case_3() { string Arr0[] = {"    ","...."," .  ","1 23","8//5","9.4.","85/ ","/123","123/"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(3, Arg3, score(Arg0, Arg1, Arg2)); }
+	void test_case_4() { string Arr0[] = {"1/0 "}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {9999,1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"MALFORMED" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(4, Arg3, score(Arg0, Arg1, Arg2)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { GradingGridIns().run_test(-1); }
+// END CUT HERE

ADDED   SRM/264/1C.cpp
Index: SRM/264/1C.cpp
==================================================================
--- SRM/264/1C.cpp
+++ SRM/264/1C.cpp
@@ -0,0 +1,65 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class PolygonDecomposition
+{
+public:
+	int howMany(int n, int k) 
+	{
+		if( n-2 < k )
+			return -1;
+
+		LL dp[101][101] = {};
+		dp[2][0] = 1;
+		for(int N=3; N<=n; ++N)
+			dp[N][1] = 1;
+
+		for(int N=4; N<=n; ++N)
+		for(int K=2; K<=k; ++K)
+		{
+			LL sum = 0;
+			for(LL v=3; v<=N-1; ++v) // use 1--v and don't use 1--3, ..., 1--(v-1)
+				for(int x=1; x<=K-1; ++x) // left: x pieces, right: K-x pieces
+					sum += (dp[v-1][x-1]+dp[v-1][x]) * dp[N-v+2][K-x] % 1000000000;
+
+			// don't use 1--*; if use 2--N, we'll have dp[N-1][K-1] cuts
+			//                 otherwise, will have dp[N-1][K] because 2--1--N
+			//                            can be regarded as a single edge
+			sum += dp[N-1][K-1] + dp[N-1][K];
+			dp[N][K] = sum % 1000000000;
+		}
+		return (int) dp[n][k];
+	}
+
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 4; int Arg1 = 2; int Arg2 = 2; verify_case(0, Arg2, howMany(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 100; int Arg1 = 1; int Arg2 = 1; verify_case(1, Arg2, howMany(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 6; int Arg1 = 4; int Arg2 = 14; verify_case(2, Arg2, howMany(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 31; int Arg1 = 20; int Arg2 = 956146480; verify_case(3, Arg2, howMany(Arg0, Arg1)); }
+	void test_case_4() { int Arg0 = 3; int Arg1 = 4; int Arg2 = -1; verify_case(4, Arg2, howMany(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { PolygonDecomposition().run_test(-1); }
+// END CUT HERE

ADDED   SRM/282/1A.cpp
Index: SRM/282/1A.cpp
==================================================================
--- SRM/282/1A.cpp
+++ SRM/282/1A.cpp
@@ -0,0 +1,237 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TileCutting {
+public:
+	int cuts(vector <string> layout) 
+	{
+		int san=0, ni=0, ic=0;
+		for(int y=0; y<layout.size(); y+=2)
+			for(int x=0; x<layout[0].size(); x+=2)
+			{
+				string s = layout[y].substr(x,2) + layout[y+1].substr(x,2);
+				if( s==".xxx" || s=="x.xx" || s=="xx.x" || s=="xxx." )
+					ic++;
+				else if( s=="..xx" || s=="x.x." || s=="xx.." || s==".x.x" )
+					ni++;
+				else if( s=="x..x" || s==".xx." )
+					ic+=2;
+				else if( s=="x..." || s==".x.." || s=="..x." || s=="...x" )
+					san++;
+			}
+		int mincut=0x7fffffff;
+		for(int nk=0; nk<=san; ++nk)
+			if(nk+nk/3>=san)
+				mincut = min(mincut, calc(san,ni,ic,nk));
+		return mincut;
+	}
+
+	int calc(int san, int ni, int ic, int nk) {
+		// create nk pieces of L-shaped block
+		// reuse nk pieces of single-block to form the rest of neede L-blocks
+		int cut   = nk*2;
+		int piece = nk-(san-nk)*3;  // single-block piecese left
+
+		// form single-blocks
+		int pi = min(ic, piece);
+		ic    -= pi;
+		piece -= pi;
+
+		// if still left, use single-blocks to form I-shaped blocks
+		if( piece )
+		{
+			ni    -= piece/2;
+			piece -= piece/2*2;
+		}
+
+		// create I-shaped blocks
+		int xpiece = 0;
+		if(ni) {
+			cut  +=  (ni+1)/2*2;
+			xpiece = ni%2 ? 1 : 0;
+		}
+
+		// create single-blocks
+		pi = min(ic, piece);
+		ic    -= pi;
+		piece -= pi;
+		if( ic ) {
+			if( xpiece ) ic-=2, cut+=1;
+			if(ic>0)
+				cut += ic/4*4 + ic%4 + (ic%4==0 ? 0 : 1);
+		}
+		return cut;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string layout_[] = { "..",
+  ".." };
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+int Test_(Case_<1>) {
+	string layout_[] = { "x.",
+  ".." };
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 2; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+int Test_(Case_<2>) {
+	string layout_[] = { ".x",
+  "xx" };
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 2; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+int Test_(Case_<3>) {
+	string layout_[] = { "xxxx..xxxx",
+  "x..x..xx..",
+  "x..xxxxx..",
+  "xxxxxxxxxx" };
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 6; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+int Test_(Case_<4>) {
+	string layout_[] = { "xxxxxx",
+  "x....x" };
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 3; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+int Test_(Case_<5>) {
+	string layout_[] = { "x..x....",
+  "x..xx...",
+  "..xx....",
+  "...x....",
+  "......xx",
+  "......xx" };
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+int Test_(Case_<6>) {
+	string layout_[] = { "x..xx.x..x.xx..x.xx.",
+  "..x..x..x.x..xx...x.",
+  ".xx...x...x...x..x..",
+  ".xx...x.x.x...x..xx.",
+  ".x..x...x.....x...x.",
+  ".x.x.x..x..x..x..x.x",
+  "...x.x.x.x.x.x.x...x",
+  ".x..x..x...x..x...x.",
+  "...x.x.x..x.x.x.....",
+  "...x.x.x..x.x.xxx.x.",
+  "xx.xx.xx.x.x.x.x..x.",
+  ".x..xxx...x.xx...x.x",
+  "xx..x.x...x.x.x.x..x",
+  ".xx..x.xx.xxxxx...xx",
+  "x....x.x...x...x.x..",
+  ".x.xx.x..x.x.xxx.x..",
+  "...xx.xxx.....xx.xxx",
+  ".xx..x..xx.x...x.xx.",
+  "x.x...x.x.xx.x..x.xx",
+  ".....xx.x.......xx.x",
+  "x...x.xx.x..x....x..",
+  ".x..xxx.....x.x.x.xx" }
+;
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 121; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+int Test_(Case_<7>) {
+	string layout_[] = { "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  "..................................................",
+  ".................................................." }
+;
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+int Test_(Case_<8>) {
+	string layout_[] = 
+{"x..x...x...x..x....x",
+ ".x..x.xxx....xx..x..",
+ "..x...x..x...xxx....",
+ "x....x.....xx..xx...",
+ "..x.x...x..x........",
+ ".x...xx.xx...xxx...x",
+ "x..x.x......xx.x....",
+ "...xxx.....x.x..xx.."}
+;
+	  vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	int RetVal = 44; 
+	return verify_case(RetVal, TileCutting().cuts(layout)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/282/1B.cpp
Index: SRM/282/1B.cpp
==================================================================
--- SRM/282/1B.cpp
+++ SRM/282/1B.cpp
@@ -0,0 +1,146 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+int gcd(int a, int b) {
+	while(a) swap(a,b%=a); return b;
+}
+
+class Fractionalization {
+public:
+	vector <string> partial(vector <string> definitions, int m, int n, string danceCall) 
+	{
+		// input
+		map< string, vector<string> > D;
+		for(int i=0; i<definitions.size(); ++i) {
+			stringstream sin(definitions[i]);
+			string name; sin>>name; name=name.substr(0, name.size()-1);
+			vector<string> ds;
+			for(string d; sin>>d;)
+				ds.push_back(d);
+			D[name] = ds;
+		}
+
+		// solve
+		vector<string> result;
+		while(m) {
+			if( !D.count(danceCall) )
+				return vector<string>(1, "ILLEGAL");
+			vector<string>& d = D[danceCall];
+			int q = d.size();
+			int z = m*q/n;
+			for(int i=0; i<z; ++i)
+				result.push_back(d[i]);
+			m = m*q - z*n;
+			danceCall = d[z];
+		}
+		return result;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string definitions_[] = { "FiveParts: One Two Three Four Five" };
+	  vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_)); 
+	int m = 2; 
+	int n = 5; 
+	string danceCall = "FiveParts"; 
+	string RetVal_[] = {"One", "Two" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
+int Test_(Case_<1>) {
+	string definitions_[] = { "Trade: Hinge Hinge",
+  "TradeThreeTimes: Trade Trade Trade" };
+	  vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_)); 
+	int m = 5; 
+	int n = 6; 
+	string danceCall = "TradeThreeTimes"; 
+	string RetVal_[] = {"Trade", "Trade", "Hinge" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
+int Test_(Case_<2>) {
+	string definitions_[] = { "Trade: Hinge Hinge",
+  "CenterTwoTrade: CenterTwoHinge CenterTwoHinge",
+  "SpinTheTop: Trade FanTheTop",
+  "HotFootSpin: FanTheTop CenterTwoTrade SpinTheTop" };
+	  vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_)); 
+	int m = 1; 
+	int n = 2; 
+	string danceCall = "HotFootSpin"; 
+	string RetVal_[] = {"FanTheTop", "CenterTwoHinge" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
+int Test_(Case_<3>) {
+	string definitions_[] = { "Trade: Hinge Hinge",
+  "CenterTwoTrade: CenterTwoHinge CenterTwoHinge",
+  "SpinTheTop: Trade FanTheTop",
+  "HotFootSpin: FanTheTop CenterTwoTrade SpinTheTop" };
+	  vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_)); 
+	int m = 3; 
+	int n = 4; 
+	string danceCall = "HotFootSpin"; 
+	string RetVal_[] = {"FanTheTop", "CenterTwoTrade", "Hinge" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
+int Test_(Case_<4>) {
+	string definitions_[] = { "A: One Two",
+  "B: One Two Three",
+  "C: One Two Three Four" };
+	  vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_)); 
+	int m = 3; 
+	int n = 4; 
+	string danceCall = "C"; 
+	string RetVal_[] = {"One", "Two", "Three" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
+int Test_(Case_<5>) {
+	string definitions_[] = { "A: X Y Z",
+  "B: A A A" };
+	  vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_)); 
+	int m = 7; 
+	int n = 23; 
+	string danceCall = "B"; 
+	string RetVal_[] = {"ILLEGAL" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
+int Test_(Case_<6>) {
+	string definitions_[] = { "A: B C",
+  "D: E F" };
+	  vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_)); 
+	int m = 1; 
+	int n = 2; 
+	string danceCall = "G"; 
+	string RetVal_[] = {"ILLEGAL" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/282/1C.cpp
Index: SRM/282/1C.cpp
==================================================================
--- SRM/282/1C.cpp
+++ SRM/282/1C.cpp
@@ -0,0 +1,138 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class GreatExpectations {
+public:
+	double expectedTime(vector <string> doors) 
+	{
+		const int Y = doors.size()/2  +1;
+		const int X = doors[0].size() +1;
+
+		vector< vector<double> > e(Y, vector<double>(X, -1.0));
+		e[Y-1][X-1] = 0.0;
+
+		for(int k=0; k<X*Y; ++k)
+			for(int y=0; y<Y; ++y)
+				for(int x=0; x<X; ++x)
+				{
+					// neibours : (expected_time, door_prob)
+					vector< pair<double,double> > ep;
+					if( x+1<X && doors[y*2][x]!='0' && e[y][x+1]>=0 )
+						ep.push_back( make_pair(e[y][x+1], (doors[y*2][x]-'0')/8.0) );
+					if( 0<x && doors[y*2][x-1]!='0' && e[y][x-1]>=0 )
+						ep.push_back( make_pair(e[y][x-1], (doors[y*2][x-1]-'0')/8.0) );
+					if( y+1<Y && doors[y*2+1][x]!='0' && e[y+1][x]>=0 )
+						ep.push_back( make_pair(e[y+1][x], (doors[y*2+1][x]-'0')/8.0) );
+					if( 0<y && doors[y*2-1][x]!='0' && e[y-1][x]>=0 )
+						ep.push_back( make_pair(e[y-1][x], (doors[y*2-1][x]-'0')/8.0) );
+
+					if( ep.empty() ) continue;
+					sort( ep.begin(), ep.end() ); // better first
+
+					// choose k that minimizes the following E:
+					//   E = (1+e[0])*p[0]
+					//     + (1+e[1])*(1-p[0])*p[1]
+					//     + (1+e[2])*(1-p[0])*(1-p[1])*p[2]
+					//     + ...
+					//     + (1+E)   *(1-p[0])*(1-p[1])*...*(1-p[k])
+					double r=1.0, s=0.0, E=1e+50;
+					for(int i=0; i<ep.size(); ++i) {
+						double s2 = s + r * ep[i].second * (1 + ep[i].first);
+						double r2 = r * (1 - ep[i].second);
+						double E2 = (s2 + r2) / (1-r2);
+						if( E2 > E ) break;
+						r=r2, s=s2, E=E2;
+					}
+					if( e[y][x]<0 || e[y][x]>E )
+						e[y][x]=E;
+				}
+
+		return e[0][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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string doors_[] = { "4",
+  "44",
+  "4" };
+	  vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_)); 
+	double RetVal = 3.3333333333333335; 
+	return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
+int Test_(Case_<1>) {
+	string doors_[] = { "48",
+  "440",
+  "42",
+  "862",
+  "06" };
+	  vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_)); 
+	double RetVal = 6.0; 
+	return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
+int Test_(Case_<2>) {
+	string doors_[] = { "0808",
+  "88888",
+  "0000",
+  "88888",
+  "8080" }
+;
+	  vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_)); 
+	double RetVal = 14.0; 
+	return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
+int Test_(Case_<3>) {
+	string doors_[] = { "2815",
+  "67686",
+  "1324",
+  "75767",
+  "6051" }
+;
+	  vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_)); 
+	double RetVal = 11.852782338798935; 
+	return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
+int Test_(Case_<4>) {
+	string doors_[] = { "823",
+  "2630",
+  "130" }
+;
+	  vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_)); 
+	double RetVal = -1.0; 
+	return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
+int Test_(Case_<5>) {
+	string doors_[] = { "0",
+  "44",
+  "4" }
+;
+	  vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_)); 
+	double RetVal = 4.0; 
+	return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/330/1A.cpp
Index: SRM/330/1A.cpp
==================================================================
--- SRM/330/1A.cpp
+++ SRM/330/1A.cpp
@@ -0,0 +1,77 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Arrows { public:
+	int longestArrow(string s) 
+	{
+		string rs = s;
+		reverse(rs.begin(), rs.end());
+		return max(max(la(s,'<','-'), la(s,'<','=')), max(la(rs,'>','-'), la(rs,'>','=')));
+	}
+	int la(string s, char h, char t)
+	{
+		int m = -1;
+		for(int i=0; i<s.size(); ++i)
+			if( s[i]==h ) {
+				int j=i+1;
+				while( j<s.size() && s[j]==t )
+					++j;
+				m = max(m, j-i);
+			}
+		return m;
+	}
+};
+
+// 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(_, Arrows().longestArrow(s));}
+int main(){
+
+CASE(0)
+	string s = "<--->--==>"; 
+	int _ = 4; 
+END
+CASE(1)
+	string s = "<<<<<<<<<<"; 
+	int _ = 1; 
+END
+CASE(2)
+	string s = "----==-"; 
+	int _ = -1; 
+END
+CASE(3)
+	string s = "<----=====>"; 
+	int _ = 6; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/330/1B.cpp
Index: SRM/330/1B.cpp
==================================================================
--- SRM/330/1B.cpp
+++ SRM/330/1B.cpp
@@ -0,0 +1,105 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+struct byLength {
+	bool operator()(const string& lhs, const string& rhs) const {
+		if(lhs.size() != rhs.size()) return lhs.size() < rhs.size();
+		return lhs < rhs;
+	}
+};
+class PrefixFreeSubsets { public:
+	long long cantPrefFreeSubsets(vector <string> words) 
+	{
+		int N = words.size();
+		sort(words.begin(), words.end(), byLength());
+
+		vector< vector<int> > dc;
+		for(int i=0; i<N; ++i)
+			dc.push_back( direct_children(words[i], words, i+1) );
+		dc.push_back( direct_children("", words, 0) );
+		return rec(N, dc) - 1;
+	}
+
+	LL rec(int t, vector< vector<int> >& dc )
+	{
+		LL p = 1;
+		for(int i=0; i<dc[t].size(); ++i)
+			p *= rec(dc[t][i], dc);
+		return p+1;
+	}
+
+	bool is_prefix(const string& pre, const string& all) {
+		return equal(pre.begin(), pre.end(), all.begin());
+	}
+
+	vector<int> direct_children(const string& s, vector<string>& w, int i) {
+		vector<int> ans;
+		for(; i<w.size(); ++i)
+			if( is_prefix(s,w[i]) ){
+				bool direct = true;
+				for(int j=0; j<ans.size(); ++j)
+					direct = direct && !is_prefix(w[ans[j]], w[i]);
+				if( direct )
+					ans.push_back(i);
+			}
+		return ans;
+	}
+};
+
+// 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(_, PrefixFreeSubsets().cantPrefFreeSubsets(words));}
+int main(){
+
+CASE(0)
+	string words_[] = {"hello","hell","hi"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long _ = 6LL; 
+END
+CASE(1)
+	string words_[] = {"a","b","c","d"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long _ = 16LL; 
+END
+CASE(2)
+	string words_[] = {"a","ab","abc","abcd","abcde","abcdef"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long _ = 7LL; 
+END
+CASE(3)
+	string words_[] = {"a","b","aa","ab","ba","bb"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long _ = 25LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/330/1C.cpp
Index: SRM/330/1C.cpp
==================================================================
--- SRM/330/1C.cpp
+++ SRM/330/1C.cpp
@@ -0,0 +1,121 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class LongLongNim { public:
+	int numberOfWins(int maxN, vector <int> moves) 
+	{
+		int FULL = (1 << *max_element(moves.begin(), moves.end())) - 1;
+		int MASK = 0;
+		for(int i=0; i<moves.size(); ++i)
+			MASK |= 1 << (moves[i]-1);
+
+		vector<int> ss;
+		vector<int> visited(FULL+1, -1);
+		for(int i=1,s=1; i<=maxN; ++i)
+		{
+			s = (s<<1 | ((~s&MASK)==MASK)) & FULL;
+			if( visited[s] >= 0 )
+				return countBits(ss, visited[s], ss.size(), maxN);
+			else
+			{
+				visited[s] = ss.size();
+				ss.push_back(s&1);
+			}
+		}
+		return countBits(ss, 0, maxN, maxN);
+	}
+
+	int countBits(const vector<int>& b, int lb, int le, int N)
+	{
+		// Given an infinite seq b[0] ... b[lb-1] (b[lb] ... b[le-1])*,
+		// compute \Sigma b[0..N)
+		int sum = 0;
+		for(int i=0; i<lb; ++i)
+			sum += b[i];
+
+		N -= lb;
+		int ll = le - lb;
+		int Q = N/ll;
+		int R = N%ll;
+		for(int i=lb; i<le; ++i)
+			sum += b[i] * Q;
+		for(int i=lb; i<lb+R; ++i)
+			sum += b[i];
+		return sum;
+	}
+};
+
+// 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(_, LongLongNim().numberOfWins(maxN, moves));}
+int main(){
+
+CASE(0)
+	int maxN = 20; 
+	int moves_[] = {1,2,3};
+	  vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_)); 
+	int _ = 5; 
+END
+CASE(1)
+	int maxN = 999; 
+	int moves_[] = {1};
+	  vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_)); 
+	int _ = 499; 
+END
+CASE(3)
+	int maxN = 6543; 
+	int moves_[] = {2,4,7,11,20};
+	  vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_)); 
+	int _ = 1637; 
+END
+CASE(2)
+	int maxN = 1000000000; 
+	int moves_[] = {1,2};
+	  vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_)); 
+	int _ = 333333333; 
+END
+/*
+CASE(4)
+	int maxN = ; 
+	int moves_[] = ;
+	  vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_)); 
+	int _ = ; 
+END
+CASE(5)
+	int maxN = ; 
+	int moves_[] = ;
+	  vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/330/2C.cpp
Index: SRM/330/2C.cpp
==================================================================
--- SRM/330/2C.cpp
+++ SRM/330/2C.cpp
@@ -0,0 +1,96 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class NextPalindromicNumber { public:
+	string getNext(string n) 
+	{
+		string s = mirror(n);
+		if( n < s )
+			return s;
+		return mirror(plus1(s, (s.size()-1)/2));
+	}
+
+	string mirror(const string& s)
+	{
+		return string(s.begin(), s.begin()+s.size()/2) + string(s.rbegin()+s.size()/2, s.rend());
+	}
+
+	string plus1(string s, int i)
+	{
+		while( s[i] == '9' )
+		{
+			s[i--] = '0';
+			if( i < 0 )
+				return '1'+s;
+		}
+		s[i]++;
+		return s;
+	}
+};
+
+// 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(_, NextPalindromicNumber().getNext(n));}
+int main(){
+
+CASE(0)
+	string n = "12345"; 
+	string _ = "12421"; 
+END
+CASE(1)
+	string n = "858"; 
+	string _ = "868"; 
+END
+CASE(2)
+	string n = "1999"; 
+	string _ = "2002"; 
+END
+CASE(3)
+	string n = "1"; 
+	string _ = "2"; 
+END
+CASE(4)
+	string n = "9999"; 
+	string _ = "10001"; 
+END
+/*
+CASE(5)
+	string n = ; 
+	string _ = ; 
+END
+CASE(6)
+	string n = ; 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/331/1A.cpp
Index: SRM/331/1A.cpp
==================================================================
--- SRM/331/1A.cpp
+++ SRM/331/1A.cpp
@@ -0,0 +1,83 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CarolsSinging {
+public:
+	int choose(vector <string> lyrics) 
+	{
+		int nP = lyrics.size();
+		int nS = lyrics[0].size();
+		vector<int> people_who_know_the_song(nS);
+		for(int s=0; s<nS; ++s)
+			for(int p=0; p<nP; ++p)
+				people_who_know_the_song[s] |= (lyrics[p][s]=='Y')<<p;
+
+		int minPop = nS;
+		for(int m=1; m<(1<<nS); ++m)
+		{
+			int canSing = 0;
+			for(int s=0; (1<<s)<=m; ++s)
+				if( (1<<s) & m )
+					canSing |= people_who_know_the_song[s];
+			if( canSing == (1<<nP)-1 )
+				minPop = min(minPop, __builtin_popcount(m));
+		}
+		return minPop;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string lyrics_[] = {"YN","NY"};
+	  vector <string> lyrics(lyrics_, lyrics_+sizeof(lyrics_)/sizeof(*lyrics_)); 
+	int RetVal = 2; 
+	return verify_case(RetVal, CarolsSinging().choose(lyrics)); }
+int Test_(Case_<1>) {
+	string lyrics_[] = {"YN","YY","YN"};
+	  vector <string> lyrics(lyrics_, lyrics_+sizeof(lyrics_)/sizeof(*lyrics_)); 
+	int RetVal = 1; 
+	return verify_case(RetVal, CarolsSinging().choose(lyrics)); }
+int Test_(Case_<2>) {
+	string lyrics_[] = {"YNN","YNY","YNY","NYY","NYY","NYN"};
+	  vector <string> lyrics(lyrics_, lyrics_+sizeof(lyrics_)/sizeof(*lyrics_)); 
+	int RetVal = 2; 
+	return verify_case(RetVal, CarolsSinging().choose(lyrics)); }
+int Test_(Case_<3>) {
+	string lyrics_[] = {"YNNYYY","YYNYYY","YNNYYN","NYYNNN","YYYNNN","YYYNNY","NYYYYY","NYNYYY","NNNNYY",
+ "YYYYYY","YNNNNN","YYYYNY","YYNNNN","NNYYYN","NNNNYY","YYYNNN","NYNNYN","YNNYYN",
+ "YYNNNY","NYYNNY","NNYYYN","YNYYYN","NNNYNY","YYYYNN","YYNYNN","NYYNYY","YYNYYN"};
+	  vector <string> lyrics(lyrics_, lyrics_+sizeof(lyrics_)/sizeof(*lyrics_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, CarolsSinging().choose(lyrics)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/331/1B.cpp
Index: SRM/331/1B.cpp
==================================================================
--- SRM/331/1B.cpp
+++ SRM/331/1B.cpp
@@ -0,0 +1,80 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Shopping {
+public:
+	int minNumber(int X, vector <int> values) 
+	{
+		sort( values.begin(), values.end() );
+
+		int next=1, cnt=0;
+		while( next <= X )
+		{
+			// maximum <= next;
+			vector<int>::iterator it = upper_bound(values.begin(), values.end(), next);
+			if( it == values.begin() )
+				return -1;
+			next += *(it-1);
+			++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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int X = 20; 
+	int values_[] = {1, 2, 5, 10};
+	  vector <int> values(values_, values_+sizeof(values_)/sizeof(*values_)); 
+	int RetVal = 5; 
+	return verify_case(RetVal, Shopping().minNumber(X, values)); }
+int Test_(Case_<1>) {
+	int X = 7; 
+	int values_[] = {2, 4, 1, 7};
+	  vector <int> values(values_, values_+sizeof(values_)/sizeof(*values_)); 
+	int RetVal = 3; 
+	return verify_case(RetVal, Shopping().minNumber(X, values)); }
+int Test_(Case_<2>) {
+	int X = 20; 
+	int values_[] = {2,4,6,8};
+	  vector <int> values(values_, values_+sizeof(values_)/sizeof(*values_)); 
+	int RetVal = -1; 
+	return verify_case(RetVal, Shopping().minNumber(X, values)); }
+int Test_(Case_<3>) {
+	int X = 600; 
+	int values_[] = {1,2,3,10,11,30};
+	  vector <int> values(values_, values_+sizeof(values_)/sizeof(*values_)); 
+	int RetVal = 25; 
+	return verify_case(RetVal, Shopping().minNumber(X, values)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/331/1C.cpp
Index: SRM/331/1C.cpp
==================================================================
--- SRM/331/1C.cpp
+++ SRM/331/1C.cpp
@@ -0,0 +1,231 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+typedef pair<int,int> pt;
+typedef pair<int,int> range;
+
+class HiddenSquares {
+public:
+	int count(vector <int> x1, vector <int> y1, vector <int> x2, vector <int> y2) 
+	{
+		vector< pair<int, range> > xseg, yseg;
+		for(int i=0; i<x1.size(); ++i)
+		{
+			xseg.push_back( make_pair(x1[i], range(y1[i], y2[i])) );
+			xseg.push_back( make_pair(x2[i], range(y1[i], y2[i])) );
+			yseg.push_back( make_pair(y1[i], range(x1[i], x2[i])) );
+			yseg.push_back( make_pair(y2[i], range(x1[i], x2[i])) );
+		}
+
+		// copy and
+		map<int, vector<range> > xray;
+		for(int i=0; i<xseg.size(); ++i)
+		{
+			set<int> p;
+
+			p.insert(xseg[i].second.first);
+			p.insert(xseg[i].second.second);
+			for(int j=0; j<yseg.size(); ++j)
+				if( xseg[i].second.first<=yseg[j].first && yseg[j].first<=xseg[i].second.second
+				 && yseg[j].second.first<=xseg[i].first && xseg[i].first<=yseg[j].second.second )
+					p.insert( yseg[j].first );
+
+			int py = xseg[i].second.first;
+			for(set<int>::iterator y=p.begin(); ++y!=p.end(); py=*y)
+				xray[xseg[i].first].push_back( range(py,*y) );
+		}
+
+		// paset!
+		map<int, vector<range> > yray;
+		for(int i=0; i<yseg.size(); ++i)
+		{
+			set<int> p;
+
+			p.insert(yseg[i].second.first);
+			p.insert(yseg[i].second.second);
+			for(int j=0; j<xseg.size(); ++j)
+				if( yseg[i].second.first<=xseg[j].first && xseg[j].first<=yseg[i].second.second
+				 && xseg[j].second.first<=yseg[i].first && yseg[i].first<=xseg[j].second.second )
+					p.insert( xseg[j].first );
+
+			int px = yseg[i].second.first;
+			for(set<int>::iterator x=p.begin(); ++x!=p.end(); px=*x)
+				yray[yseg[i].first].push_back( range(px,*x) );
+		}
+
+		// copy and
+		map< pt, set<pt> > xconn;
+		for(map<int, vector< pt > >::iterator it=xray.begin(); it!=xray.end(); ++it)
+		{
+			int            x = it->first;
+			vector<range>& r = it->second;
+
+			vector< pair<int,bool> > es;
+			for(int i=0; i!=r.size(); ++i)
+				es.push_back( make_pair(r[i].first,false) ),
+				es.push_back( make_pair(r[i].second,true) );
+			sort(es.begin(), es.end());
+			vector<int> cur;
+			int nest = 0;
+			for(int i=0; i!=es.size(); ++i)
+			{
+				cur.push_back( es[i].first );
+				es[i].second ? --nest : ++nest;
+				if( nest == 0 )
+				{
+					for(int j=0; j<cur.size(); ++j)
+						for(int k=j+1; k<cur.size(); ++k)
+							if( cur[j] < cur[k] )
+								xconn[pt(x,cur[j])].insert( pt(x,cur[k]) );
+					cur.clear();
+				}
+			}
+		}
+
+		// paste!
+		map< pt, set<pt> > yconn;
+		for(map<int, vector< pt > >::iterator it=yray.begin(); it!=yray.end(); ++it)
+		{
+			int            y = it->first;
+			vector<range>& r = it->second;
+
+			vector< pair<int,bool> > es;
+			for(int i=0; i!=r.size(); ++i)
+				es.push_back( make_pair(r[i].first,false) ),
+				es.push_back( make_pair(r[i].second,true) );
+			sort(es.begin(), es.end());
+
+			vector<int> cur;
+			int nest = 0;
+			for(int i=0; i!=es.size(); ++i)
+			{
+				cur.push_back( es[i].first );
+				es[i].second ? --nest : ++nest;
+				if( nest == 0 )
+				{
+					for(int j=0; j<cur.size(); ++j)
+						for(int k=j+1; k<cur.size(); ++k)
+							if( cur[j] < cur[k] )
+								yconn[pt(cur[j],y)].insert( pt(cur[k],y) );
+					cur.clear();
+				}
+			}
+		}
+
+		// count squares
+		int cnt = 0;
+		for(map< pt, set<pt> >::iterator it=xconn.begin(); it!=xconn.end(); ++it)
+		{
+			pt       p = it->first;
+			set<pt>& c = it->second;
+			for(set<pt>::iterator jt=c.begin(); jt!=c.end(); ++jt)
+			{
+				pt q = *jt;
+				int w = q.second-p.second;
+				pt p1(p.first+w,p.second);
+				pt q1(q.first+w,q.second);
+				if( yconn[p].count(p1) && yconn[q].count(q1) && xconn[p1].count(q1) )
+					++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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int x1_[] = {0,1,0};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int y1_[] = {0,0,1};
+	  vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_)); 
+	int x2_[] = {3,2,3};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y2_[] = {3,3,2};
+	  vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_)); 
+	int RetVal = 14; 
+	return verify_case(RetVal, HiddenSquares().count(x1, y1, x2, y2)); }
+int Test_(Case_<1>) {
+	int x1_[] = {0,2};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int y1_[] = {0,0};
+	  vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_)); 
+	int x2_[] = {2,4};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y2_[] = {4,4};
+	  vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_)); 
+	int RetVal = 1; 
+	return verify_case(RetVal, HiddenSquares().count(x1, y1, x2, y2)); }
+int Test_(Case_<2>) {
+	int x1_[] = {0,0,3};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int y1_[] = {0,3,0};
+	  vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_)); 
+	int x2_[] = {1,4,4};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y2_[] = {3,4,3};
+	  vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, HiddenSquares().count(x1, y1, x2, y2)); }
+int Test_(Case_<3>) {
+	int x1_[] = {453453463,453453500,453453495,453453512,453453478,453453489,
+ 453453466,453453500,453453498,453453510,453453472,453453512,
+ 453453519,453453514,453453521,453453518,453453523,453453517,
+ 453453466,453453525,453453496,453453495,453453463,453453461,
+ 453453460,453453522,453453471,453453468,453453479,453453517,
+ 453453485,453453518,453453499,453453464,453453494};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int y1_[] = {364646438,364646402,364646449,364646438,364646415,364646401,
+ 364646446,364646416,364646456,364646414,364646463,364646407,
+ 364646436,364646450,364646421,364646411,364646414,364646419,
+ 364646445,364646427,364646405,364646442,364646418,364646464,
+ 364646457,364646463,364646432,364646426,364646444,364646431,
+ 364646450,364646418,364646434,364646458,364646402};
+	  vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_)); 
+	int x2_[] = {453453488,453453510,453453525,453453523,453453493,453453500,
+ 453453470,453453511,453453499,453453521,453453518,453453524,
+ 453453523,453453523,453453524,453453523,453453525,453453519,
+ 453453473,453453526,453453511,453453517,453453470,453453464,
+ 453453511,453453524,453453516,453453516,453453492,453453524,
+453453513,453453522,453453520,453453505,453453512};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y2_[] = {364646460,364646454,364646462,364646466,364646464,364646455,
+ 364646457,364646461,364646457,364646450,364646466,364646453,
+ 364646441,364646451,364646460,364646461,364646446,364646464,
+ 364646447,364646460,364646454,364646450,364646444,364646466,
+ 364646458,364646466,364646455,364646442,364646462,364646435,
+ 364646464,364646444,364646455,364646459,364646430};
+	  vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_)); 
+	int RetVal = 124; 
+	return verify_case(RetVal, HiddenSquares().count(x1, y1, x2, y2)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/332/1A.cpp
Index: SRM/332/1A.cpp
==================================================================
--- SRM/332/1A.cpp
+++ SRM/332/1A.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class CreatePairs {
+public:
+	int maximalSum(vector <int> data) 
+	{
+		sort(data.begin(), data.end());
+		vector<int>::iterator neg = upper_bound(data.begin(), data.end(), 0);
+
+		LL sum = 0;
+		for(vector<int>::iterator it=data.begin(); it!=neg; ++it)
+			if( it+1 == neg )
+				sum += *it;
+			else
+				sum += *it * *(it+1), ++it;
+
+		vector<int>::iterator pos = lower_bound(data.begin(), data.end(), 2);
+		for(vector<int>::iterator it=data.end()-1; it>=pos; --it)
+			if( it == pos )
+				sum += *it;
+			else
+				sum += *it * *(it-1), --it;
+		for(vector<int>::iterator it=neg; it!=pos; ++it)
+			sum += *it;
+		return sum;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int data_[] = {0, 1, 2, 4, 3, 5};
+	  vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_)); 
+	int RetVal = 27; 
+	return verify_case(RetVal, CreatePairs().maximalSum(data)); }
+int Test_(Case_<1>) {
+	int data_[] = {-1, 1, 2, 3};
+	  vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_)); 
+	int RetVal = 6; 
+	return verify_case(RetVal, CreatePairs().maximalSum(data)); }
+int Test_(Case_<2>) {
+	int data_[] = {-1};
+	  vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_)); 
+	int RetVal = -1; 
+	return verify_case(RetVal, CreatePairs().maximalSum(data)); }
+int Test_(Case_<3>) {
+	int data_[] = {-1, 0, 1};
+	  vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_)); 
+	int RetVal = 1; 
+	return verify_case(RetVal, CreatePairs().maximalSum(data)); }
+int Test_(Case_<4>) {
+	int data_[] = {1, 1};
+	  vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_)); 
+	int RetVal = 2; 
+	return verify_case(RetVal, CreatePairs().maximalSum(data)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/332/1B.cpp
Index: SRM/332/1B.cpp
==================================================================
--- SRM/332/1B.cpp
+++ SRM/332/1B.cpp
@@ -0,0 +1,184 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+struct edge {
+	int y, x1, x2;
+	edge(){}
+	edge(int y, int x1, int x2) :y(y),x1(min(x1,x2)),x2(max(x1,x2)) {}
+	bool operator<( const edge& rhs ) const {
+		if( y != rhs.y ) return y<rhs.y;
+		if( x1 != rhs.x1 ) return x1<rhs.x1;
+		return x2 < rhs.x2;
+	}
+};
+
+class RestoringPolygon {
+public:
+	int restore(vector <int> x1, vector <int> x2, vector <int> y) 
+	{
+		int N = x1.size();
+
+		vector<edge> e;
+		for(int i=0; i!=N; ++i)
+			e.push_back( edge(y[i], x1[i], x2[i]) );
+		sort(e.begin(), e.end());
+
+		int ans = 0;
+		for(int m=1; m<(1<<N); ++m)
+			ans = max(ans, calc(e,m));
+		return ans;
+	}
+
+	int calc(vector<edge>& e_, int m)
+	{
+		vector<edge> e;
+		for(int i=0; (1<<i)<=m; ++i)
+			if( m & (1<<i) )
+				e.push_back( e_[i] );
+
+		if( e.size() <= 1 )
+			return 0;
+
+		typedef pair<int,int> point;
+		typedef map< point, vector<point> > graph;
+		graph G;
+		for(int i=0; i<e.size(); ++i)
+		{
+			int y = e[i].y;
+			int xx[] = {e[i].x1, e[i].x2};
+
+			G[ point(e[i].x1,y) ].push_back( point(e[i].x2,y) );
+			G[ point(e[i].x2,y) ].push_back( point(e[i].x1,y) );
+
+			for(int k=0; k<2; ++k) {
+				int x = xx[k];
+				for(int j=i-1; j>=0; --j)
+					if( e[j].x1 == x ) {
+						point p1(x, y);
+						point p2(e[j].x1, e[j].y);
+						if( G[p2].size() < 2 ) {
+							G[p1].push_back(p2);
+							G[p2].push_back(p1);
+						}
+					} else if( e[j].x2 == x ) {
+						point p1(x, y);
+						point p2(e[j].x2, e[j].y);
+						if( G[p2].size() < 2 ) {
+							G[p1].push_back(p2);
+							G[p2].push_back(p1);
+						}
+					} else if( e[j].x1 < x && x < e[j].x2 ) {
+						break;
+					}
+			}
+		}
+
+		for(graph::iterator it=G.begin(); it!=G.end(); ++it)
+			if( it->second.size() != 2 )
+				return 0;
+
+		point s = G.begin()->first;
+		point p = s, p2 = G[p][0];
+		for(int c=2 ;; ++c) {
+			point q = (G[p2][0] == p ? G[p2][1] : G[p2][0]);
+			p=p2, p2=q;
+			if( q == s )
+				return c==e.size()*2 ? c : 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int x1_[] = {1,2,3,1};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int x2_[] = {2,3,5,5};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y_[] = {1,4,2,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int RetVal = 8; 
+	return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
+int Test_(Case_<1>) {
+	int x1_[] = {1,1,2,2};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int x2_[] = {3,3,4,4};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y_[] = {0,2,1,3};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
+int Test_(Case_<2>) {
+	int x1_[] = {1};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int x2_[] = {2};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y_[] = {1};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
+int Test_(Case_<3>) {
+	int x1_[] = {0,0,0};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int x2_[] = {1000,1000,1000};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y_[] = {0,1,2};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
+int Test_(Case_<4>) {
+	int x1_[] = {0,1,1,2};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int x2_[] = {1,0,2,1};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y_[] = {0,4,2,3};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int RetVal = 8; 
+	return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
+int Test_(Case_<5>) {
+	int x1_[] = {696, -193, -193, 367};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int x2_[] = {367, -276, -276, 696};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y_[] = {-14, 168, -14, 168};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
+int Test_(Case_<6>) {
+	int x1_[] = { 0,  1, 6, 5, 5,  1,  6,  1,  0,  0,  9};
+	  vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_)); 
+	int x2_[] = { 5,  9, 9, 6, 6,  0,  9,  0,  1,  5,  6};
+	  vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_)); 
+	int y_[] = { 1,  4, 5, 3, 2,  0,  0,  2,  3,  5,  1};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int RetVal = 16; 
+	return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/332/1C.cpp
Index: SRM/332/1C.cpp
==================================================================
--- SRM/332/1C.cpp
+++ SRM/332/1C.cpp
@@ -0,0 +1,126 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class LadderPermutation { public:
+	vector <int> createLadder(int n, int m, int k) 
+	{
+		try {
+			vector<int> v = gen(n-k, m-1, k);
+			for(int i=0; i<k; ++i)
+				v.push_back(n-i);
+			return v;
+		} catch(...) {
+			return vector<int>();
+		}
+	}
+
+	vector<int> gen(int n, int m, int k) // make m blocks of length <=k
+	{
+		if( m==0 ) {
+			if( n==0 )
+				return vector<int>();
+			throw "fail";
+		}
+		int x = min(k, n-(m-1));
+		if( x <= 0 )
+			throw "fail";
+		vector<int> v = gen(n-x, m-1, k);
+		for(int i=0; i<x; ++i)
+			v.push_back(n-i);
+		return v;
+	}
+};
+
+// 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 <int>& Expected, const vector <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(_, LadderPermutation().createLadder(n, m, k));}
+int main(){
+
+CASE(0)
+	int n = 4; 
+	int m = 2; 
+	int k = 2; 
+	int __[] = {2, 1, 4, 3 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int n = 3; 
+	int m = 2; 
+	int k = 2; 
+	int __[] = {1, 3, 2 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int n = 2; 
+	int m = 1; 
+	int k = 1; 
+	vector <int> _; 
+END
+CASE(3)
+	int n = 6; 
+	int m = 3; 
+	int k = 2; 
+	int __[] = {2, 1, 4, 3, 6, 5 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	int n = 6; 
+	int m = 2; 
+	int k = 3; 
+	int __[] = {3, 2, 1, 6, 5, 4 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	int n = 7; 
+	int m = 4; 
+	int k = 4; 
+	int __[] = {1, 2, 3, 7, 6, 5, 4 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(6)
+	int n = ; 
+	int m = ; 
+	int k = ; 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(7)
+	int n = ; 
+	int m = ; 
+	int k = ; 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/332/2C.cpp
Index: SRM/332/2C.cpp
==================================================================
--- SRM/332/2C.cpp
+++ SRM/332/2C.cpp
@@ -0,0 +1,97 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Squares { public:
+	int countSquares(vector <string> field) 
+	{
+		const int H = field.size();
+		const int W = field[0].size();
+
+		int cnt = 0;
+		for(int y=0; y<H; ++y)
+		for(int x=0; x<W; ++x)
+			for(int y2=0; y2<H; ++y2)
+			for(int x2=0; x2<W; ++x2) if( y!=y2 || x!=x2 )
+			{
+				char c = field[y][x];
+				int x3 = x+(y2-y);
+				int y3 = y-(x2-x);
+				int x4 = x3+(x2-x);
+				int y4 = y3+(y2-y);
+				if( 0<=x3 && x3<W && 0<=y3 && y3<H )
+				if( 0<=x4 && x4<W && 0<=y4 && y4<H )
+				if( field[y2][x2]==c && field[y3][x3]==c && field[y4][x4]==c )
+					++cnt;
+			}
+		return cnt/4;
+	}
+};
+
+// 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(_, Squares().countSquares(field));}
+int main(){
+
+CASE(0)
+	string field_[] = {"ABA", "BAB", "ABA"};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 2; 
+END
+CASE(1)
+	string field_[] = {"AA", "AA"};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 1; 
+END
+CASE(2)
+	string field_[] = {"ABC", "DEF", "GHI"};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 0; 
+END
+CASE(3)
+	string field_[] = {"AABCA", "AAAAA", "BAAAB", "AAAEA", "ADBFA"};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 11; 
+END
+/*
+CASE(4)
+	string field_[] = ;
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = ; 
+END
+CASE(5)
+	string field_[] = ;
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/333/1A.cpp
Index: SRM/333/1A.cpp
==================================================================
--- SRM/333/1A.cpp
+++ SRM/333/1A.cpp
@@ -0,0 +1,98 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+int to_i(const string& s) {
+	int n;
+	stringstream(s)>>n;
+	return n;
+}
+
+class BirthNumbersValidator {
+public:
+	vector <string> validate(vector <string> test) 
+	{
+		vector<string> ans;
+		transform(test.begin(), test.end(), back_inserter(ans), &testeach);
+		return ans;
+	}
+
+	static string testeach( const string& x )
+	{
+		int y = to_i(x.substr(0,2));
+		int m = to_i(x.substr(2,2));
+		int d = to_i(x.substr(4,2));
+		if( 1<=m && m<=12 ) {}
+		else if( 51<=m && m<=62 ) { m-=50; }
+		else return "NO";
+
+		bool leap = (y%4)==0;
+		int dd[] = {31, leap?29:28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+		if( 1<=d && d<=dd[m-1] ) {}
+		else return "NO";
+
+		LL cd; stringstream(x)>>cd;
+		return cd%11==0 ? "YES" : "NO";
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string test_[] = {"8104121234"};
+	  vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_)); 
+	string RetVal_[] = {"YES" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
+int Test_(Case_<1>) {
+	string test_[] = {"8154121239"};
+	  vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_)); 
+	string RetVal_[] = {"YES" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
+int Test_(Case_<2>) {
+	string test_[] = {"8134120005"};
+	  vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_)); 
+	string RetVal_[] = {"NO" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
+int Test_(Case_<3>) {
+	string test_[] = {"8102310007","8104121235"};
+	  vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_)); 
+	string RetVal_[] = {"NO", "NO" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
+int Test_(Case_<4>) {
+	string test_[] = {"0411131237"};
+	  vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_)); 
+	string RetVal_[] = {"YES" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/333/1B.cpp
Index: SRM/333/1B.cpp
==================================================================
--- SRM/333/1B.cpp
+++ SRM/333/1B.cpp
@@ -0,0 +1,160 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class RepeatedPatterns {
+public:
+	long long findZeroSegment(string P1, string P2, string zeroCount) 
+	{
+		LL zc; stringstream(zeroCount)>>zc;
+
+		bool allz1 = (P1.find('1') == string::npos);
+		bool allz2 = (P2.find('1') == string::npos);
+		if( allz1 && allz2 )
+			return 0;
+
+		if( allz1 )
+		{
+			LL z1 = P1.size()*1000000;
+			if( zc <= z1 )
+				return 0;
+
+			LL a2 = 0; while( P2[a2]=='0' )             ++a2;
+			LL b2 = 0; while( P2[P2.size()-1-b2]=='0' ) ++b2;
+			LL c2=0, i2;
+			for(int i=0; i<P2.size(); ++i)
+				if( P2[i]=='0' ) {
+					size_t ii = P2.find('1',i);
+					if(ii==string::npos) ii=P2.size();
+					if( ii-i > c2 ) c2=ii-i, i2=i;
+				}
+
+			if( zc <= z1+a2 )
+				return 0;
+			if( zc <= c2 )
+				return P1.size()*1000000 + i2;
+			if( zc <= b2+z1+a2 )
+				return P1.size()*1000000 + P2.size() - b2;
+			return -1;
+		}
+		else if( allz2 )
+		{
+			LL a1 = 0; while( P1[a1]=='0' )             ++a1;
+			LL b1 = 0; while( P1[P1.size()-1-b1]=='0' ) ++b1;
+			LL c1=0, i1;
+			for(int i=0; i<P1.size(); ++i)
+				if( P1[i]=='0' ) {
+					size_t ii = P1.find('1',i);
+					if(ii==string::npos) ii=P1.size();
+					if( ii-i > c1 ) c1=ii-i, i1=i;
+				}
+			if( zc <= a1 )
+				return 0;
+			if( zc <= c1 )
+				return i1;
+			if( zc <= b1+a1 )
+				return P1.size() - b1;
+			// zc <= b1 + k*P2.size() + a1;
+			LL k = (zc-b1-a1) / P2.size() + ((zc-b1-a1)%P2.size() ? 1 : 0);
+			LL idx = P1.size()*1000000*k + (k-1)*k/2*P2.size() - b1;
+			return 0<=idx && idx+zc<=10000000000000000LL ? idx : -1;
+		}
+		else
+		{
+			LL a1 = 0; while( P1[a1]=='0' )             ++a1;
+			LL b1 = 0; while( P1[P1.size()-1-b1]=='0' ) ++b1;
+			LL c1=0, i1;
+			for(int i=0; i<P1.size(); ++i)
+				if( P1[i]=='0' ) {
+					size_t ii = P1.find('1',i);
+					if(ii==string::npos) ii=P1.size();
+					if( ii-i > c1 ) c1=ii-i, i1=i;
+				}
+			LL a2 = 0; while( P2[a2]=='0' )             ++a2;
+			LL b2 = 0; while( P2[P2.size()-1-b2]=='0' ) ++b2;
+			LL c2=0, i2;
+			for(int i=0; i<P2.size(); ++i)
+				if( P2[i]=='0' ) {
+					size_t ii = P2.find('1',i);
+					if(ii==string::npos) ii=P2.size();
+					if( ii-i > c2 ) c2=ii-i, i2=i;
+				}
+			if( zc <= a1 )
+				return 0;
+			if( zc <= c1 )
+				return i1;
+			if( zc <= b1+a1 )
+				return P1.size() - b1;
+			if( zc <= b1+a2 )
+				return P1.size()*1000000 - b1;
+			if( zc <= c2 )
+				return P1.size()*1000000 + i2;
+			if( zc <= b2+a1 )
+				return P1.size()*1000000 + P2.size() - b2;
+			if( zc <= b2+a2 )
+				return P1.size()*1000000 + P2.size() + P1.size()*1000000 + P2.size() - b2;
+			return -1;
+		}
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string P1 = "111010100001010"; 
+	string P2 = "010000001000"; 
+	string zeroCount = "3"; 
+	long long RetVal = 7LL; 
+	return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
+int Test_(Case_<1>) {
+	string P1 = "1101010010"; 
+	string P2 = "0001000"; 
+	string zeroCount = "3"; 
+	long long RetVal = 9999999LL; 
+	return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
+int Test_(Case_<2>) {
+	string P1 = "1101010010"; 
+	string P2 = "0001000"; 
+	string zeroCount = "5"; 
+	long long RetVal = 20000011LL; 
+	return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
+int Test_(Case_<3>) {
+	string P1 = "10101010"; 
+	string P2 = "101010101010"; 
+	string zeroCount = "9876543219876"; 
+	long long RetVal = -1LL; 
+	return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
+int Test_(Case_<4>) {
+	string P1 = "11111111111111111111111111"; 
+	string P2 = "0"; 
+	string zeroCount = "9876543219876"; 
+	long long RetVal = -1LL; 
+	return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/333/1C.cpp
Index: SRM/333/1C.cpp
==================================================================
--- SRM/333/1C.cpp
+++ SRM/333/1C.cpp
@@ -0,0 +1,106 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class ThreeBuses {
+public:
+	double getProbability(vector <int> wait, vector <int> travel, int timeLeft) 
+	{
+		double t = timeLeft - accumulate(travel.begin(), travel.end(), 0);
+		sort(wait.begin(), wait.end());
+		double w1 = wait[0];
+		double w2 = wait[1];
+		double w3 = wait[2];
+		// [0,w1] + [0,w2] + [0,w3] <= t ??
+		if( t >= w1+w2+w3 ) return 1;
+		if( t <= 0 )        return 0;
+
+		if( w2==0 ) return t / w3;
+		if( w1==0 ) {
+			double vol = t*t/2;
+			if( t > w2 ) vol -= (t-w2)*(t-w2)/2;
+			if( t > w3 ) vol -= (t-w3)*(t-w3)/2;
+			return vol / (w2*w3);
+		}
+
+		double vol = t*t*t/6;
+		if( t > w1 )    vol -= (t-w1)*(t-w1)*(t-w1)/6;
+		if( t > w2 )    vol -= (t-w2)*(t-w2)*(t-w2)/6;
+		if( t > w3 )    vol -= (t-w3)*(t-w3)*(t-w3)/6;
+		if( t > w1+w2 ) vol += (t-w1-w2)*(t-w1-w2)*(t-w1-w2)/6;
+		if( t > w2+w3 ) vol += (t-w2-w3)*(t-w2-w3)*(t-w2-w3)/6;
+		if( t > w3+w1 ) vol += (t-w3-w1)*(t-w3-w1)*(t-w3-w1)/6;
+		return vol / (w1*w2*w3);
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int wait_[] = {0, 0, 0};
+	  vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_)); 
+	int travel_[] = {10, 15, 10};
+	  vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int timeLeft = 47; 
+	double RetVal = 1.0; 
+	return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
+int Test_(Case_<1>) {
+	int wait_[] = {0, 0, 0};
+	  vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_)); 
+	int travel_[] = {10, 15, 10};
+	  vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int timeLeft = 35; 
+	double RetVal = 1.0; 
+	return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
+int Test_(Case_<2>) {
+	int wait_[] = {1, 100, 1};
+	  vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_)); 
+	int travel_[] = {10, 10, 10};
+	  vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int timeLeft = 52; 
+	double RetVal = 0.21; 
+	return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
+int Test_(Case_<3>) {
+	int wait_[] = {100, 100, 70};
+	  vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_)); 
+	int travel_[] = {1, 1, 1};
+	  vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int timeLeft = 47; 
+	double RetVal = 0.020281904761904737; 
+	return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
+int Test_(Case_<4>) {
+	int wait_[] = {43210, 31730, 0};
+	  vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_)); 
+	int travel_[] = {1, 1, 1};
+	  vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int timeLeft = 43212; 
+	double RetVal = 0.6328164776672066; 
+	return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/334/1A.cpp
Index: SRM/334/1A.cpp
==================================================================
--- SRM/334/1A.cpp
+++ SRM/334/1A.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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class EncodedSum
+{
+public:
+	long long maximumSum(vector <string> numbers) 
+	{
+		set<int> nonzero;
+		for(int i=0; i<numbers.size(); ++i)
+			nonzero.insert( numbers[i][0]-'A' );
+
+		LL v[] = {0,0,0,0,0,0,0,0,0,0};
+		for(int i=0; i<numbers.size(); ++i)
+			for(LL j=numbers[i].size()-1,d=1; j>=0; --j,d*=10)
+				v[numbers[i][j]-'A'] += d;
+
+		LL d[] = {0,1,2,3,4,5,6,7,8,9};
+		LL sumMax = 0;
+		do {
+			LL sum = 0;
+			for(int c=0; c<10; ++c)
+				if( d[c]==0 && nonzero.count(c) )
+					goto nextPerm;
+				else
+					sum += v[c] * d[c];
+			sumMax = max(sumMax, sum);
+		nextPerm:;
+		} while( next_permutation(d+0, d+10) );
+		return sumMax;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string numbers_[] = {"ABC",
+ "BCA"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	long long RetVal = 1875LL; 
+	return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
+int Test_(Case_<1>) {
+	string numbers_[] = {"ABCDEFGHIJ"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	long long RetVal = 9876543210LL; 
+	return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
+int Test_(Case_<2>) {
+	string numbers_[] = {"ABCDEFGHIJ", 
+ "J"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	long long RetVal = 9876543202LL; 
+	return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
+int Test_(Case_<3>) {
+	string numbers_[] = {"A", 
+ "BB", 
+ "CCC", 
+ "DDDD", 
+ "EEEEE", 
+ "FFFFFF", 
+ "GGGGGGG", 
+ "HHHHHHHH", 
+ "IIIIIIIII", 
+ "AJJJJJJJJJ"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	long long RetVal = 9973936905LL; 
+	return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
+int Test_(Case_<4>) {
+	string numbers_[] = {"GHJIDDD",
+ "AHHCCCA",
+ "IIJCEJ",
+ "F",
+ "HDBIGFJAAJ"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	long long RetVal = 9888114550LL; 
+	return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/334/1B.cpp
Index: SRM/334/1B.cpp
==================================================================
--- SRM/334/1B.cpp
+++ SRM/334/1B.cpp
@@ -0,0 +1,122 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class ExtendedHappyNumbers
+{
+public:
+	long long calcTheSum(int A, int B, int K) 
+	{
+		vector<int> happy(9*9*9*9*9*9*7);
+//		map<int,int> happy;
+		LL sum = 0;
+		for(int n=A; n<=B; ++n)
+			sum += rec(n, K, happy);
+		return sum;
+	}
+
+	int S(int K, int n)
+	{
+		int sum = 0;
+		for(int d=1; d<=n; d*=10)
+		{
+			int v = n/d%10;
+			int t = 1;
+			for(int i=0; i<K; ++i)
+				t *= v;
+			sum += t;
+		}
+		return sum;
+	}
+
+	int rec(int n, int K, vector<int>& happy)
+	{
+		int LOOP = -1;
+		stack<int> vs;
+		int m = 0x7fffffff;
+		for(;;)
+		{
+			if( happy[n] == LOOP )
+				{m = looped(n, K); break;}
+			if( happy[n] )
+				{m = happy[n]; break;}
+			happy[n] = LOOP;
+			vs.push(n);
+			n = S(K, n);
+		}
+		while(!vs.empty()) {
+			int v = vs.top(); vs.pop();
+			happy[v] = m = min(m, v);
+		}
+		return m;
+	}
+
+	int looped(int n, int K)
+	{
+		int mn = n;
+		vector<int> vs(1, n);
+		for(int v=S(K,n); v!=n; v=S(K,v)) 
+			mn = min(mn, v);
+		return mn;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int A = 13; 
+	int B = 13; 
+	int K = 2; 
+	long long RetVal = 1LL; 
+	return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
+int Test_(Case_<1>) {
+	int A = 1; 
+	int B = 5; 
+	int K = 2; 
+	long long RetVal = 14LL; 
+	return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
+int Test_(Case_<2>) {
+	int A = 10; 
+	int B = 99; 
+	int K = 1; 
+	long long RetVal = 450LL; 
+	return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
+int Test_(Case_<3>) {
+	int A = 535; 
+	int B = 538; 
+	int K = 3; 
+	long long RetVal = 820LL; 
+	return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
+int Test_(Case_<4>) {
+	int A = 100000; 
+	int B = 400000; 
+	int K = 6; 
+	long long RetVal = 5169721292LL; 
+	return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/334/1C.cpp
Index: SRM/334/1C.cpp
==================================================================
--- SRM/334/1C.cpp
+++ SRM/334/1C.cpp
@@ -0,0 +1,137 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+typedef int cost;
+typedef int vert;
+typedef vector< vector<cost> > graph;
+
+cost bidi_minCut( graph G, int N)
+{
+	vector<vert> V;
+	for(int v=0; v<N; ++v)
+		V.push_back(v);
+
+	cost result = 0x7fffffff;
+	for(int n=N; n>1; --n)
+	{
+		// invariant:
+		//   the current set of vertices = {V[0] .. V[n-1]}
+
+		// order the vertices
+		vector<int> vs;
+		cost lastCut = 0;
+		{
+			vector<cost> ws(n, 0);
+			ws[0] = 1;
+
+			for(int i=0; i<n; ++i) {
+				int j = max_element(ws.begin(), ws.end()) - ws.begin();
+				lastCut = ws[j];
+
+				vs.push_back(j);
+				ws[j] = -1;
+				for(int k=0; k<n; ++k)
+					if( ws[k] != -1 )
+						ws[k] += G[V[k]][V[j]];
+			}
+		}
+
+		// update mincut
+		result = min(result, lastCut);
+
+		// reduce the graph (unify vs[n-2] and vs[n-1])
+		vert v2=vs[n-2], v1=vs[n-1];
+		for(int i=0; i<n; ++i) {
+			G[V[v2]][V[i]] += G[V[v1]][V[i]];
+			G[V[i]][V[v2]] += G[V[i]][V[v1]];
+		}
+		V.erase( V.begin() + v1 );
+	}
+	return result;
+}
+
+class Terrorists
+{
+public:
+	int requiredCost(vector <string> roads) 
+	{
+		int N = roads.size();
+		graph G(N, vector<cost>(N));
+
+		for(int i=0; i<N; ++i)
+		for(int j=0; j<N; ++j)
+			G[i][j] = roads[i][j]-'0';
+
+		return bidi_minCut(G, N);
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string roads_[] = {"0911",
+ "9011",
+ "1109",
+ "1190"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, Terrorists().requiredCost(roads)); }
+int Test_(Case_<1>) {
+	string roads_[] = {"0399",
+ "3033",
+ "9309",
+ "9390"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int RetVal = 9; 
+	return verify_case(RetVal, Terrorists().requiredCost(roads)); }
+int Test_(Case_<2>) {
+	string roads_[] = {"030900",
+ "304120",
+ "040174",
+ "911021",
+ "027207",
+ "004170"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int RetVal = 8; 
+	return verify_case(RetVal, Terrorists().requiredCost(roads)); }
+int Test_(Case_<3>) {
+	string roads_[] = {"044967263",
+ "409134231",
+ "490642938",
+ "916036261",
+ "634306024",
+ "742660550",
+ "229205069",
+ "633625604",
+ "318140940"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int RetVal = 27; 
+	return verify_case(RetVal, Terrorists().requiredCost(roads)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/335/1A.cpp
Index: SRM/335/1A.cpp
==================================================================
--- SRM/335/1A.cpp
+++ SRM/335/1A.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class Multifactorial
+{
+public:
+	string calcMultiFact(int n, int k) 
+	{
+		LL ans = 1;
+		for(LL v=n; v>0; v-=k)
+		{
+			if( ans*v<ans || ans*v/v!=ans || ans*v>1000000000000000000LL )
+				return "overflow";
+			ans *= v;
+		}
+		stringstream sout;
+		sout << ans;
+		return sout.str();
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int n = 14; 
+	int k = 3; 
+	string RetVal = "12320"; 
+	return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
+int Test_(Case_<1>) {
+	int n = 5; 
+	int k = 4; 
+	string RetVal = "5"; 
+	return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
+int Test_(Case_<2>) {
+	int n = 1000; 
+	int k = 2; 
+	string RetVal = "overflow"; 
+	return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
+int Test_(Case_<3>) {
+	int n = 2000000000; 
+	int k = 1900000000; 
+	string RetVal = "200000000000000000"; 
+	return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
+int Test_(Case_<4>) {
+	int n = 1000; 
+	int k = 256; 
+	string RetVal = "84232704000"; 
+	return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
+int Test_(Case_<5>) {
+	int n = 2000000000; 
+	int k = 1; 
+	string RetVal = "overflow"; 
+	return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/335/1B.cpp
Index: SRM/335/1B.cpp
==================================================================
--- SRM/335/1B.cpp
+++ SRM/335/1B.cpp
@@ -0,0 +1,175 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+typedef pair<int,int> vert;
+typedef int cost;
+
+// dijkstra
+template<typename OutIt>
+void neighbors(cost e[50][50], int Y, int X, vert v, bool vis[50][50], OutIt out)
+{
+	typedef pair<cost,vert> cedge;
+	priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+	Q.push( cedge(e[v.first][v.second],v) );
+
+	set<vert> visited_now;
+	while( !Q.empty() )
+	{
+		cedge ce = Q.top(); Q.pop();
+		cost cc = ce.first;
+		vert cv = ce.second;
+		if( visited_now.count(cv) )
+			continue;
+		visited_now.insert(cv);
+
+		if( !vis[cv.first][cv.second] ) {
+			*out++ = cv;
+			vis[cv.first][cv.second] = true;
+		}
+
+		// for 4 neibs
+		int dy[]={0,0,-1,+1};
+		int dx[]={-1,+1,0,0};
+		for(int i=0; i<4; ++i)
+		{
+			int yyy = cv.first  + dy[i];
+			int xxx = cv.second + dx[i];
+			if( 0<=yyy && yyy<Y && 0<=xxx && xxx<X )
+			{
+				int ccc = cc + e[yyy][xxx];
+				vert vvv(yyy, xxx);
+				if( ccc<=9*8*7*6*5*4*3*2*1 )
+					Q.push( cedge(ccc, vvv) );
+			}
+		}
+	}
+}
+
+int bfs( cost e[50][50], int Y, int X, vert s, vert d )
+{
+	vector<vert> Q(1, s);
+	bool vis[50][50] = {}; vis[s.first][s.second] = true;
+
+	for(int step=0; !Q.empty(); ++step)
+	{
+		vector<vert> Q2;
+		for(int i=0; i!=Q.size(); ++i)
+		{
+			if( Q[i] == d )
+				return step;
+			neighbors(e, Y, X, Q[i], vis, back_inserter(Q2));
+		}
+		Q.swap(Q2);
+	}
+	return -1;
+}
+
+class ExpensiveTravel
+{
+public:
+	int minTime(vector <string> m, int startRow, int startCol, int endRow, int endCol) 
+	{
+		int Y = m.size(), X = m[0].size();
+		int Sy = startRow-1, Sx = startCol-1;
+		int Ey = endRow-1,   Ex = endCol-1;
+		cost e[50][50];
+		for(int y=0; y<Y; ++y)
+		for(int x=0; x<X; ++x)
+			e[y][x] = 9*8*7*6*5*4*3*2*1 / (m[y][x]-'0');
+
+		return bfs( e, Y, X, vert(Sy,Sx), vert(Ey,Ex) );
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string m_[] = {"22334"};
+	  vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_)); 
+	int startRow = 1; 
+	int startCol = 1; 
+	int endRow = 1; 
+	int endCol = 5; 
+	int RetVal = 3; 
+	return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
+int Test_(Case_<1>) {
+	string m_[] = {"55",
+ "52",
+ "55"};
+	  vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_)); 
+	int startRow = 1; 
+	int startCol = 2; 
+	int endRow = 3; 
+	int endCol = 2; 
+	int RetVal = 1; 
+	return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
+int Test_(Case_<2>) {
+	string m_[] = {"251",
+ "212",
+ "122"};
+	  vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_)); 
+	int startRow = 1; 
+	int startCol = 1; 
+	int endRow = 3; 
+	int endCol = 3; 
+	int RetVal = -1; 
+	return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
+int Test_(Case_<3>) {
+	string m_[] = {"452232",
+ "287979",
+ "219872",
+ "928234",
+ "767676"};
+	  vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_)); 
+	int startRow = 1; 
+	int startCol = 6; 
+	int endRow = 3; 
+	int endCol = 1; 
+	int RetVal = 3; 
+	return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
+int Test_(Case_<4>) {
+	string m_[] = {"11"};
+	  vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_)); 
+	int startRow = 1; 
+	int startCol = 1; 
+	int endRow = 1; 
+	int endCol = 2; 
+	int RetVal = -1; 
+	return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
+int Test_(Case_<5>) {
+	string m_[] = {"123456789987654321"};
+	  vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_)); 
+	int startRow = 1; 
+	int startCol = 2; 
+	int endRow = 1; 
+	int endCol = 16; 
+	int RetVal = 5; 
+	return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/335/1C.cpp
Index: SRM/335/1C.cpp
==================================================================
--- SRM/335/1C.cpp
+++ SRM/335/1C.cpp
@@ -0,0 +1,133 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+void gen( vector<int>& X, vector<LL>& R, int n )
+{
+	int j = 0;
+	int m = X.size();
+	for(int i=0; i<n; ++i)
+	{
+		R[i] = X[j];
+		int s = (j+1)%m;
+		X[j] = ( ( X[j] ^ X[s] ) + 13 ) % 49999;
+		j = s;
+	}
+}
+
+class RandomFights
+{
+public:
+	double expectedNrOfPoints(vector <int> Aseed, vector <int> Bseed, int n) 
+	{
+		vector<LL> A(n), B(n);
+		gen(Aseed, A, n);
+		gen(Bseed, B, n);
+
+		// expected gain by A[i] = sqSum{B[j] | B[j]<A[i]} - sqSum{B[j] | B[j]>A[i]}
+
+		sort(B.begin(), B.end());
+		vector<LL> B2(n);
+		for(int i=0; i<n; ++i) B2[i] = B[i]*B[i];
+
+		vector<LL> L1(n), R1(n), L2(n), R2(n);
+		partial_sum( B.begin(),   B.end(),   L1.begin()  );
+		partial_sum( B.rbegin(),  B.rend(),  R1.rbegin() );
+		partial_sum( B2.begin(),  B2.end(),  L2.begin()  );
+		partial_sum( B2.rbegin(), B2.rend(), R2.rbegin() );
+
+		LL e = 0;
+		for(int i=0; i<n; ++i)
+		{
+			int j = lower_bound(B.begin(), B.end(), A[i]) - B.begin();
+
+			LL ln  = j;
+			LL ls  = (j==0 ? 0 : L1[j-1]);
+			LL ls2 = (j==0 ? 0 : L2[j-1]);
+			LL rn  = n-j;
+			LL rs  = (j==n ? 0 : R1[j]);
+			LL rs2 = (j==n ? 0 : R2[j]);
+
+			e += (ls2-rs2) - 2*A[i]*(ls-rs) + (ln-rn)*A[i]*A[i];
+		}
+		return double(e) / n;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int A_[] = {6};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {4};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int n = 1; 
+	double RetVal = 4.0; 
+	return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
+int Test_(Case_<1>) {
+	int A_[] = {1,7};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {3,5};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int n = 2; 
+	double RetVal = 0.0; 
+	return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
+int Test_(Case_<2>) {
+	int A_[] = {3,7};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {1,5};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int n = 2; 
+	double RetVal = 20.0; 
+	return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
+int Test_(Case_<3>) {
+	int A_[] = {45,35,236,2342,5543,21,32,2,6,23,24,23,41,1};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {2345,45,2345,345};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int n = 50; 
+	double RetVal = 1.2721986164E8; 
+	return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
+int Test_(Case_<4>) {
+	int A_[] = {34,3245,2534,53,53,46,346,246,346,2,624,624,6,245,6324,6542,624,6};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {345,234,523,4624,6,2456,345,634,634,7,3457,376,34,6234,62,523,52,35,32};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int n = 7; 
+	double RetVal = -9713701.714285715; 
+	return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
+int Test_(Case_<5>) {
+	int A_[] = {1,2,3,4};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {1,2,3,4};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int n = 50000; 
+	double RetVal = 0.0; 
+	return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/336/1A.cpp
Index: SRM/336/1A.cpp
==================================================================
--- SRM/336/1A.cpp
+++ SRM/336/1A.cpp
@@ -0,0 +1,61 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class ServiceNames
+{
+public:
+	vector <string> makeList(vector <string> services) 
+	{
+		map< string, set<string> > lst;
+		for(int i=0; i<services.size(); ++i) {
+			stringstream sin(services[i]);
+			string h; sin>>h;
+			for(string s; sin>>s; )
+				lst[s].insert(h);
+		}
+
+		vector<string> out;
+		transform(lst.begin(), lst.end(), back_inserter(out), &pr);
+		return out;
+	}
+
+	static string pr( const pair< string, set<string> >& p )
+	{
+		stringstream sout;
+		sout << p.first;
+		string sep = " ==> ";
+		for(set<string>::const_iterator it=p.second.begin(); it!=p.second.end(); ++it)
+			sout << sep << *it, sep=", ";
+		return sout.str();
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const vector <string> &Expected, const vector <string> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
+	void test_case_0() { string Arr0[] = {"BLAST Genome Annotation Sensitivity","PING","X Annotation"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"Annotation ==> BLAST, X", "Genome ==> BLAST", "Sensitivity ==> BLAST" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(0, Arg1, makeList(Arg0)); }
+	void test_case_1() { string Arr0[] = {"PING"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); vector <string> Arg1; verify_case(1, Arg1, makeList(Arg0)); }
+	void test_case_2() { string Arr0[] = {"BLAST Genome annotation Sensitivity","PING","X Annotation","Apple X ample"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"Annotation ==> X", "Genome ==> BLAST", "Sensitivity ==> BLAST", "X ==> Apple", "ample ==> Apple", "annotation ==> BLAST" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(2, Arg1, makeList(Arg0)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { ServiceNames().run_test(-1); }
+// END CUT HERE

ADDED   SRM/336/1B.cpp
Index: SRM/336/1B.cpp
==================================================================
--- SRM/336/1B.cpp
+++ SRM/336/1B.cpp
@@ -0,0 +1,95 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class LikelyWord
+{
+public:
+	int likely(vector <string> dictionary, int k) 
+	{
+		vector<LL> dl, dr;
+		dl.push_back(-1);
+		dr.push_back(-1);
+		for(int i=0; i<dictionary.size(); ++i) {
+			dl.push_back( toLLl(dictionary[i],k) );
+			dr.push_back( toLLr(dictionary[i],k) );
+		}
+		dl.push_back( ipow(26,k) );
+		dr.push_back( ipow(26,k) );
+
+		LL max=-1, maxi=-1;
+		for(int i=0; i+1<dl.size(); ++i) {
+			LL hm = dr[i+1] - dl[i] - 1;
+			if( hm>max )
+				max=hm, maxi=i;
+			else if(hm==max)
+				maxi=-1;
+		}
+		return maxi;
+	}
+
+	LL toLLl( string s, LL k )
+	{
+		if( s.size() > k )
+			s.resize(k);
+		else if( s.size() < k )
+			s.resize(k, 'a'), s[s.size()-1]-=1;
+		return toLL(s,k);
+	}
+
+	LL toLLr( string s, LL k )
+	{
+		if( s.size() > k )
+			s.resize(k), s[s.size()-1]+=1;
+		else if( s.size() < k )
+			s.resize(k, 'a');
+		return toLL(s,k);
+	}
+
+	LL toLL( string s, LL k )
+	{
+		LL n = 0;
+		for(int i=0; i<k; ++i)
+			n = n*26 + s[i]-'a';
+		return n;
+	}
+
+	LL ipow(LL a, LL k) {
+		LL n = 1;
+		while(k--)
+			n *= a;
+		return n;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arr0[] = {"time","zoology"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 0; verify_case(0, Arg2, likely(Arg0, Arg1)); }
+	void test_case_1() { string Arr0[] = {"az","ma","xz"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 1; verify_case(1, Arg2, likely(Arg0, Arg1)); }
+	void test_case_2() { string Arr0[] = {"az","ma","xz"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 2; verify_case(2, Arg2, likely(Arg0, Arg1)); }
+	void test_case_3() { string Arr0[] = {"a","m","y"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = -1; verify_case(3, Arg2, likely(Arg0, Arg1)); }
+	void test_case_4() { string Arr0[] = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 25; verify_case(4, Arg2, likely(Arg0, Arg1)); }
+	void test_case_5() { string Arr0[] = {"aa", "ab", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 0; verify_case(5, Arg2, likely(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { LikelyWord().run_test(-1); }
+// END CUT HERE

ADDED   SRM/336/1C.cpp
Index: SRM/336/1C.cpp
==================================================================
--- SRM/336/1C.cpp
+++ SRM/336/1C.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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+typedef complex<double> pt;
+
+bool byY( pt a, pt b )
+{
+	if( a.imag() == b.imag() )
+		return a.real() < b.real();
+	return a.imag() < b.imag();
+}
+
+bool byArg( pt a, pt b )
+{
+	return arg(a) < arg(b);
+}
+
+bool isRight( pt a, pt b, pt c )
+{
+	return arg((c-b) / (b-a)) < 0;
+}
+
+vector<pt> convex_hull( vector<pt> p )
+{
+	vector<pt>::iterator it = min_element( p.begin(), p.end(), byY );
+	pt o = *it;
+	p.erase(it);
+	for(int i=0; i<p.size(); ++i)
+		p[i] -= o;
+	sort( p.begin(), p.end(), byArg );
+
+	vector<pt> q;
+	q.push_back( pt(0,0) );
+	q.push_back( p[0] );
+	for(int i=1; i<p.size(); ++i) {
+		while( isRight(q[q.size()-2], q[q.size()-1], p[i]) )
+			q.pop_back();
+		q.push_back( p[i] );
+	}
+	for(int i=0; i<q.size(); ++i)
+		q[i] += o;
+	return q;
+}
+
+double outer_prod( pt a, pt b )
+{
+	return (a.real()*b.imag() - b.real()*a.imag())/2;
+}
+
+double area( const vector<pt>& q )
+{
+	double a = 0.0;
+
+	pt o = q[0];
+	for(int i=1; i+1<q.size(); ++i)
+		a += outer_prod(q[i]-o, q[i+1]-o);
+	return abs(a);
+}
+
+
+class Shadow
+{
+public:
+	double area(vector <int> tree, vector <int> light) 
+	{
+		double x1 = min(tree[0], tree[3]);
+		double x2 = max(tree[0], tree[3]);
+		double y1 = min(tree[1], tree[4]);
+		double y2 = max(tree[1], tree[4]);
+		double z1 = min(tree[2], tree[5]);
+		double z2 = max(tree[2], tree[5]);
+		double x  = light[0];
+		double y  = light[1];
+		double z  = light[2];
+
+		if(x1==x2 && y1==y2 || y1==y2 && z1==z2 || z1==z2 && x1==x2 )
+			return 0; // line
+		if(x1==x2 && x==x1 || y1==y2 && y==y1 || z1==z2 && z==z1 )
+			return 0; // seen as a line
+		if( y1 >= y )
+			return 0; // tree above light
+		if( y2 >= y )
+			return -1; // infinite
+
+		// otherwise project all vertices two y=0 plain
+		vector<pt> p;
+		for(int i=0; i<8; ++i)
+		{
+			double X=(i&1 ? x1 : x2);
+			double Y=(i&2 ? y1 : y2);
+			double Z=(i&4 ? z1 : z2);
+
+			// (Xp-X) : (x-X) = (0-Y) : (y-Y)
+			double Xp = (X-x)*Y/(y-Y) + X;
+			double Zp = (Z-z)*Y/(y-Y) + Z;
+			p.push_back( pt(Xp,Zp) );
+		}
+
+		// calc convex hull and its area
+		p = convex_hull(p);
+		return ::area(p);
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {1,1,1, 10,1,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {5,5,5}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); double Arg2 = 0.0; verify_case(0, Arg2, area(Arg0, Arg1)); }
+	void test_case_1() { int Arr0[] = {1,3,1, 10,1,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2,2,2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); double Arg2 = -1.0; verify_case(1, Arg2, area(Arg0, Arg1)); }
+	void test_case_2() { int Arr0[] = {1,1,1, 2,2,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {3,3,3}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); double Arg2 = 15.75; verify_case(2, Arg2, area(Arg0, Arg1)); }
+	void test_case_3() { int Arr0[] =  {1,1,1, 3,3,3} ; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2,2,2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); double Arg2 = -1.0; verify_case(3, Arg2, area(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { Shadow().run_test(-1); }
+// END CUT HERE

ADDED   SRM/337/1A.cpp
Index: SRM/337/1A.cpp
==================================================================
--- SRM/337/1A.cpp
+++ SRM/337/1A.cpp
@@ -0,0 +1,67 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class CardStraights
+{
+public:
+	int longestStraight(vector <int> cards) 
+	{
+		int jok = count(cards.begin(), cards.end(), 0);
+
+		set<int> cs(cards.begin(), cards.end());
+		cs.erase(0);
+		if( cs.empty() )
+			return jok; // Ouggggggggg
+
+		int ans = 0;
+		for(set<int>::iterator it=cs.begin(); it!=cs.end(); ++it)
+			ans = max(ans, asLongAsPossible(it, cs.end(), jok));
+		return ans;
+	}
+
+	int asLongAsPossible(set<int>::iterator it, set<int>::iterator end, int jok)
+	{
+		int b = *it;
+		int e = *it;
+		for(++it; it!=end; e=*it++)
+			if( *it-e-1 <= jok )
+				jok -= *it-e-1;
+			else
+				break;
+		int nAfter = min(1000000-e, jok);
+		e += nAfter;
+		b -= min(b-1, jok-nAfter);
+		return e-b+1;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {0,6,5,10,3,0,11}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 5; verify_case(0, Arg1, longestStraight(Arg0)); }
+	void test_case_1() { int Arr0[] = {100,100,100,101,100,99,97,103}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; verify_case(1, Arg1, longestStraight(Arg0)); }
+	void test_case_2() { int Arr0[] = {0,0,0,1,2,6,8,1000}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; verify_case(2, Arg1, longestStraight(Arg0)); }
+	void test_case_3() { int Arr0[] = {1,9,5,7,3,4,0,0,0,10}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 10; verify_case(3, Arg1, longestStraight(Arg0)); }
+	void test_case_4() { int Arr0[] = {0,0,999999}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; verify_case(4, Arg1, longestStraight(Arg0)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { CardStraights().run_test(-1); }
+// END CUT HERE

ADDED   SRM/337/1B+.cpp
Index: SRM/337/1B+.cpp
==================================================================
--- SRM/337/1B+.cpp
+++ SRM/337/1B+.cpp
@@ -0,0 +1,104 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+template<typename T>
+struct RMQ
+{
+	vector< vector<int> > rm;
+	vector<T> d;
+
+	RMQ( const vector<T>& d ) : d(d) {
+		int n = d.size();
+
+		// rm[k][x] = z s.t. d[z] is the minimum in [x, x+2^k)
+		rm.push_back( vector<int>(n) );
+		for(int x=0; x<n; ++x)
+			rm[0][x] = x;
+		for(int k=1; (1<<k)<=n; ++k) {
+			rm.push_back( rm[k-1] );
+			for(int x=0; x+(1<<k-1)<n; ++x)
+				if( d[rm[k][x]] > d[rm[k-1][x + (1<<k-1)]] )
+					rm[k][x] = rm[k-1][x + (1<<k-1)];
+		}
+	}
+
+	int operator()(int L, int R) const { // inclusive
+		int k=0;
+		for(; L+(1<<k) < R-(1<<k)+1; ++k) {}
+		LL i = rm[k][L];
+		LL j = rm[k][R-(1<<k)+1];
+		return (d[i]<=d[j] ? i : j);
+	}
+};
+
+class BuildingAdvertise
+{
+public:
+	long long getMaxArea(vector <int> hseed, int n) 
+	{
+		// input
+		LL j = 0;
+		LL m = hseed.size();
+		vector<LL> h(n);
+		for(int i=0; i<n; ++i) {
+			h[i] = hseed[j];
+			LL s = (j+1)%m;
+			hseed[j] = ( ( hseed[j] ^ hseed[s] ) + 13 ) % 835454957;
+			j = s;
+		}
+
+		// solve
+		return rec(RMQ<LL>(h), h, 0, n-1);
+	}
+	LL rec(const RMQ<LL>& rmq, vector<LL>& h, LL L, LL R)
+	{
+		LL result = 0;
+
+		stack< pair<LL,LL> > S;
+		S.push( make_pair(L,R) );
+		while( !S.empty() )
+		{
+			L = S.top().first;
+			R = S.top().second;
+			S.pop();
+
+			LL C = rmq(L, R);
+			if( L < C ) S.push( make_pair(L,C-1) );
+			if( C < R ) S.push( make_pair(C+1,R) );
+			result = max(result, (R-L+1) * h[C]);
+		}
+
+		return result;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const long long &Expected, const long long &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {3,6,5,6,2,4}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; long long Arg2 = 15LL; verify_case(0, Arg2, getMaxArea(Arg0, Arg1)); }
+	void test_case_1() { int Arr0[] = {5,0,7,0,2,6,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; long long Arg2 = 7LL; verify_case(1, Arg2, getMaxArea(Arg0, Arg1)); }
+	void test_case_2() { int Arr0[] = {1048589,2097165}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100000; long long Arg2 = 104858900000LL; verify_case(2, Arg2, getMaxArea(Arg0, Arg1)); }
+	void test_case_3() { int Arr0[] = {1,7,2,5,3,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; long long Arg2 = 8LL; verify_case(3, Arg2, getMaxArea(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { BuildingAdvertise().run_test(-1); }
+// END CUT HERE

ADDED   SRM/337/1B.cpp
Index: SRM/337/1B.cpp
==================================================================
--- SRM/337/1B.cpp
+++ SRM/337/1B.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class BuildingAdvertise
+{
+public:
+	long long getMaxArea(vector <int> h, int n) 
+	{
+		// input
+		LL j = 0;
+		LL m = h.size();
+		vector<LL> R(n);
+		for(int i=0; i<n; ++i) {
+			R[i] = h[j];
+			LL s = (j+1)%m;
+			h[j] = ( ( h[j] ^ h[s] ) + 13 ) % 835454957;
+			j = s;
+		}
+
+		// solve
+		vector<int> left(n);
+		{
+			map<LL, int> h; h[-1] = -1;
+			for(int i=0; i<n; ++i) {
+				// position of the highest building < R[i]
+				map<LL,int>::iterator it = h.lower_bound(R[i]);
+				left[i] = (--it)->second+1;
+				h.erase( ++it, h.end() );
+				h[ R[i] ] = i;
+			}
+		}
+		vector<int> right(n);
+		{
+			map<LL, int> h; h[-1] = n;
+			for(int i=n-1; i>=0; --i) {
+				// position of the highest building < R[i]
+				map<LL,int>::iterator it = h.lower_bound(R[i]);
+				right[i] = (--it)->second-1;
+				h.erase( ++it, h.end() );
+				h[ R[i] ] = i;
+			}
+		}
+		LL ans = 0;
+		for(int i=0; i<n; ++i) {
+			LL area = R[i] * (right[i] - left[i] + 1);
+			ans = max(ans, area);
+		}
+		return ans;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const long long &Expected, const long long &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {3,6,5,6,2,4}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; long long Arg2 = 15LL; verify_case(0, Arg2, getMaxArea(Arg0, Arg1)); }
+	void test_case_1() { int Arr0[] = {5,0,7,0,2,6,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; long long Arg2 = 7LL; verify_case(1, Arg2, getMaxArea(Arg0, Arg1)); }
+	void test_case_2() { int Arr0[] = {1048589,2097165}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100000; long long Arg2 = 104858900000LL; verify_case(2, Arg2, getMaxArea(Arg0, Arg1)); }
+	void test_case_3() { int Arr0[] = {1,7,2,5,3,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; long long Arg2 = 8LL; verify_case(3, Arg2, getMaxArea(Arg0, Arg1)); }
+	void test_case_4() { int Arr0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 9999; long long Arg2 = 1903656LL; verify_case(4, Arg2, getMaxArea(Arg0, Arg1)); }
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { BuildingAdvertise().run_test(-1); }
+// END CUT HERE

ADDED   SRM/337/1C.cpp
Index: SRM/337/1C.cpp
==================================================================
--- SRM/337/1C.cpp
+++ SRM/337/1C.cpp
@@ -0,0 +1,106 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+static const LL MODVAL = 835454957;
+int memo[50*15*101*2];
+int memo_k[101];
+
+class CountPalindromes
+{
+public:
+	vector<string> w;
+	int count(vector<string> words, int k) 
+	{
+		w = words;
+		memset(memo, 0xff, sizeof(memo));
+
+		LL ans = 0;
+		memo_k[0] = 0;
+		for(int kk=1; kk<=k; ++kk) {
+			LL ak = 0;
+			for(int i=0; i<w.size(); ++i)
+				ak += rec_l(i, 0, kk);
+			ans += (memo_k[kk] = ak%MODVAL);
+		}
+		return int(ans % MODVAL);
+
+	}
+
+	int rec_l(int i, int ix, int k)
+	{
+		int key = (((i*15)+ix)*101+k)*2+0;
+		if( memo[key]>=0 )
+			return memo[key];
+
+		LL ans = 0;
+		for(int j=0; j<w.size(); ++j)
+			ans += rec(i, ix, j, w[j].size()-1, k);
+		return memo[key] = int(ans % MODVAL);
+	}
+
+	int rec_r(int j, int jx, int k)
+	{
+		int key = (((j*15)+jx)*101+k)*2+1;
+		if( memo[key]>=0 )
+			return memo[key];
+
+		LL ans = 0;
+		for(int i=0; i<w.size(); ++i)
+			ans += rec(i, 0, j, jx, k);
+		return memo[key] = int(ans % MODVAL);
+	}
+
+
+	int rec(int i, int ix, int j, int jx, int k)
+	{
+		while( k>=2 && ix<w[i].size() && 0<=jx )
+			if( w[i][ix] != w[j][jx] )
+				return 0;
+			else
+				++ix, --jx, k-=2;
+
+		if( k == 0 )
+			return (i==j && ix==jx+1 ? 1 : 0);
+		if( k == 1 )
+			return (i==j && ix==jx || ix==w[i].size() && jx==-1 ? 1 : 0);
+
+		if( ix==w[i].size() && jx==-1 )
+			return memo_k[k-2];
+		else if( ix==w[i].size() )
+			return rec_r(j, jx, k-1);
+		else if( jx==-1 )
+			return rec_l(i, ix, k-1);
+		else
+			return 0;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arr0[] = {"tragic","cigar"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 24; int Arg2 = 1; verify_case(0, Arg2, count(Arg0, Arg1)); }
+	void test_case_1() { string Arr0[] = {"z","zz"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 5; verify_case(1, Arg2, count(Arg0, Arg1)); }
+	void test_case_2() { string Arr0[] = {"aba","acaba","baca","cac","b","c","a"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 70; int Arg2 = 370786966; verify_case(2, Arg2, count(Arg0, Arg1)); }
+	void test_case_3() { string Arr0[] = {"hello"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100; int Arg2 = 0; verify_case(3, Arg2, count(Arg0, Arg1)); }
+	void test_case_4() { string Arr0[] = {"a", "aaaaaaaaab", "aaa", "aaaaaaaaaaaa", "aabbaaa", "babaaaaaaaa", "aaaaaabaaaba", "aaaa", "aaaaaaaaa", "aaaaaaaaaa", "aab", "aaaaaababaaaaa", "aaaaaaaaaaabba", "aaaaaabaa", "aaabaaaaaa", "abaaaaaaaa", "aaaaaa", "aabaaaaaaaaaba", "ab", "bbbaabaaaab", "aaaabaaaaa", "aa", "baaaaaaaaaaaa", "aabaa", "aabaaaaaaaabbaa", "aaaaaaaabaaaaaa", "aaaaaaaa", "aaaaa", "aaaaaaaaaaa", "aabaaaaa", "baabaaaaaaaaa", "baaaaa", "aaaaaaaabaaaaa", "aaaaaaaaaaaaaaa", "abaaaaaaaaaaa", "aaabababaaaa", "aaaaaaaaaabaaaa", "abaaa", "aaaaabaaaab", "aaaabaaaaaaa", "aaaaaaaba", "babbbaaaaaba", "aaaaaaaaaaaaa", "aaababaabaab", "aaabaabaaab", "aaaabbaaabaaaaa", "abaaaaaaaaaaaaa", "aaaaaaa", "abaaaaabaaaaaaa", "aaabaaaaaaaaa"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100; int Arg2 = 570277357; verify_case(4, Arg2, count(Arg0, Arg1)); }
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { CountPalindromes().run_test(-1); }
+// END CUT HERE

ADDED   SRM/338/1A.cpp
Index: SRM/338/1A.cpp
==================================================================
--- SRM/338/1A.cpp
+++ SRM/338/1A.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class ImprovingStatistics
+{
+public:
+	int howManyGames(int played, int won) 
+	{
+		LL p = played, w = won;
+		LL z = w*100 / p;
+
+		// z+1 <= (w+X)*100 / (p+X)
+		// (z+1)(p+X) <= (w+X)*100
+		// (z+1)*p-w*100 <= (99-z)X
+		if( z >= 99 )
+			return -1;
+		LL a = (z+1)*p-w*100, b = 99-z;
+		// a <= b*X
+		return int(a%b==0 ? a/b : a/b+1);
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 10; int Arg1 = 8; int Arg2 = 1; verify_case(0, Arg2, howManyGames(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 100; int Arg1 = 80; int Arg2 = 6; verify_case(1, Arg2, howManyGames(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 47; int Arg1 = 47; int Arg2 = -1; verify_case(2, Arg2, howManyGames(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 99000; int Arg1 = 0; int Arg2 = 1000; verify_case(3, Arg2, howManyGames(Arg0, Arg1)); }
+	void test_case_4() { int Arg0 = 1000000000; int Arg1 = 470000000; int Arg2 = 19230770; verify_case(4, Arg2, howManyGames(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { ImprovingStatistics().run_test(-1); }
+// END CUT HERE

ADDED   SRM/338/1B.cpp
Index: SRM/338/1B.cpp
==================================================================
--- SRM/338/1B.cpp
+++ SRM/338/1B.cpp
@@ -0,0 +1,88 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+vector< vector<double> > mMul( const vector< vector<double> >& A, const vector< vector<double> >& B )
+{
+	const int n = A.size();
+
+	vector< vector<double> > C(n, vector<double>(n));
+	for(int i=0; i<n; ++i)
+		for(int j=0; j<n; ++j) {
+			double Cij = 0;
+			for(int k=0; k<n; ++k)
+				Cij += A[i][k] * B[k][j];
+			C[i][j] = Cij;
+		}
+	return C;
+}
+
+vector< vector<double> > mPow( vector< vector<double> > M, int t ) // t>0
+{
+	vector< vector<double> > R;
+	for(; t; t>>=1, M=mMul(M,M))
+		if( t&1 )
+			R = (R.empty() ? M : mMul(R,M));
+	return R;
+}
+
+class RandomSwaps
+{
+public:
+	double getProbability(int arrayLength, int swapCount, int a, int b) 
+	{
+		double P = 1 / double(arrayLength * (arrayLength-1)/2);
+		double Q = 1 - (arrayLength-1)*P;
+		if( a != b ) {
+			vector< vector<double> > M(3, vector<double>(3));
+			M[0][0] = Q;
+			M[0][1] = P;
+			M[0][2] = 1 - P - Q;
+			M[1][0] = P;
+			M[1][1] = Q;
+			M[1][2] = 1 - P - Q;
+			M[2][0] = P;
+			M[2][1] = P;
+			M[2][2] = 1 - M[2][0] - M[2][1];
+			M = mPow( M, swapCount );
+			return M[0][1];
+		} else {
+			vector< vector<double> > M(2, vector<double>(2));
+			M[0][0] = Q;
+			M[0][1] = 1 - M[0][0];
+			M[1][0] = P;
+			M[1][1] = 1 - P;
+			M = mPow( M, swapCount );
+			return M[0][0];
+		}
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 5; int Arg1 = 1; int Arg2 = 0; int Arg3 = 0; double Arg4 = 0.6; verify_case(0, Arg4, getProbability(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_1() { int Arg0 = 5; int Arg1 = 1; int Arg2 = 0; int Arg3 = 3; double Arg4 = 0.1; verify_case(1, Arg4, getProbability(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_2() { int Arg0 = 5; int Arg1 = 2; int Arg2 = 0; int Arg3 = 0; double Arg4 = 0.4; verify_case(2, Arg4, getProbability(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_3() { int Arg0 = 100; int Arg1 = 500; int Arg2 = 3; int Arg3 = 3; double Arg4 = 0.010036635745123007; verify_case(3, Arg4, getProbability(Arg0, Arg1, Arg2, Arg3)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { RandomSwaps().run_test(-1); }
+// END CUT HERE

ADDED   SRM/338/1C.cpp
Index: SRM/338/1C.cpp
==================================================================
--- SRM/338/1C.cpp
+++ SRM/338/1C.cpp
@@ -0,0 +1,172 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class CakeParty
+{
+public:
+	string makeMove(vector <int> pieces) 
+	{
+		// Win iff #{i | pieces[i]==max(pieces)} is odd
+		//    --> if #==1      move not to make the opponent winning pos
+		//        if #==odd>=3 any move will do. choose the lexic-first one
+		//        if #==even   any move leads to lose. choose the lex1st
+/*
+<<Sprague Grundy Theorem による導出>>
+
+定理のステートメント
+
+    対象となるゲーム
+      - 二人ゲーム
+      - 二人とも動かせる手の集合は同じ
+      - 動かせなくなった方が負け
+      - 無限ループしない
+
+    nim
+      - サイズ s1, s2, .., sk の山がある
+      - どれか一つ山を選んで 1 〜 山サイズ の任意個取り除ける
+      - 最後の山を取った方が勝ち（山がなくなって打つ手が無くなった方が負け）
+
+    *n をサイズ n の山が1個だけの nim とする
+      - *0 は負け
+      - *n は勝ち n>=1
+
+    ゲーム
+      - 状態 G から打てる手で遷移する先を G1, ..., Gk とする
+        G = {G1, ..., Gk} と書く
+
+    等価
+      - 二つのゲームG, Fが等価なことを G ≡ F と書く
+        等価というのは勝ち負け一致よりもっと強い。二つのゲームの和を取ると必敗になること
+        *n と *n は同サイズの山2つのnimは必敗なので等価。同サイズでなければ必勝なので等価でない
+
+    定理
+      - G1≡*n1, ..., Gk≡*nk ならば、G={G1, ..., Gk} ≡ *mex(n1,...,nk)
+        where mex(S) = min(nat \setminus S)
+        帰納的に、全てのゲームはなんらかの *n と等価
+
+適用
+
+  "#max == 1 なら必勝"
+       [X,...] = { [X-1,...], [X-2,...], ..., [1, ...], [...] }
+     で
+       [X-1,...] = { [X-2,...], ..., [1, ...], [...] }
+     なので
+       [X,...] の nim 値は mex(mex{[X-2,...], ..., [1, ...], [...]}, [X-2,...], ..., [1, ...], [...])
+       になるが、これはmex2回がけなので *0 ではない。よって必勝
+  "#max == 2 なら必敗"
+     どうやっても相手に#max==1で渡ってしまう
+  "#max == 3 なら必勝"
+     どうやっても相手に#max==2で渡る
+  ...
+
+*/
+		LL maxI = max_element(pieces.begin(), pieces.end()) - pieces.begin();
+		LL maxP = pieces[maxI];
+		if( count(pieces.begin(), pieces.end(), maxP) == 1 )
+		{
+			pieces[maxI] = 0;
+			LL second = *max_element(pieces.begin(), pieces.end());
+
+			// if there's odd number of the second largests, make it even
+			if( count(pieces.begin(), pieces.end(), second)%2 == 1 )
+			{
+				stringstream sout;
+				sout << "CAKE " << maxI << " PIECES " << (maxP - second);
+				return sout.str();
+			}
+			// otherwise, leave it as is. choose the lex-first move
+			else
+			{
+				LL eat = maxP - second + 1;
+
+				// d : lexicographically first number more than "eat"
+				LL d = 1;
+				while( !(eat <= d) )
+					d *= 10;
+				if( d <= maxP ) // if edible
+					eat = d;
+				stringstream sout;
+				sout << "CAKE " << maxI << " PIECES " << eat;
+				return sout.str();
+			}
+		}
+		else
+		{
+			string ans = "Z";
+			for(LL i=0; i<pieces.size(); ++i)
+				if( pieces[i] == maxP )
+				{
+					stringstream sout;
+					sout << "CAKE " << i << " PIECES 1";
+					ans = min(ans, sout.str());
+				}
+			return ans;
+		}
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int pieces_[] = {47};
+	  vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_)); 
+	string RetVal = "CAKE 0 PIECES 47"; 
+	return verify_case(RetVal, CakeParty().makeMove(pieces)); }
+int Test_(Case_<1>) {
+	int pieces_[] = {3,3};
+	  vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_)); 
+	string RetVal = "CAKE 0 PIECES 1"; 
+	return verify_case(RetVal, CakeParty().makeMove(pieces)); }
+int Test_(Case_<2>) {
+	int pieces_[] = {3,5};
+	  vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_)); 
+	string RetVal = "CAKE 1 PIECES 2"; 
+	return verify_case(RetVal, CakeParty().makeMove(pieces)); }
+int Test_(Case_<3>) {
+	int pieces_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+	  vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_)); 
+	string RetVal = "CAKE 0 PIECES 1"; 
+	return verify_case(RetVal, CakeParty().makeMove(pieces)); }
+int Test_(Case_<4>) {
+	int pieces_[] = {3,3,112};
+	  vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_)); 
+	string RetVal = "CAKE 2 PIECES 110"; 
+	return verify_case(RetVal, CakeParty().makeMove(pieces)); }
+int Test_(Case_<5>) {
+	int pieces_[] = {3,3,1};
+	  vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_)); 
+	string RetVal = "CAKE 0 PIECES 1"; 
+	return verify_case(RetVal, CakeParty().makeMove(pieces)); }
+int Test_(Case_<6>) {
+	int pieces_[] = {4,7,4,7,4,7,4,7,47,47,47,47};
+	  vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_)); 
+	string RetVal = "CAKE 10 PIECES 1"; 
+	return verify_case(RetVal, CakeParty().makeMove(pieces)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/339/1A.cpp
Index: SRM/339/1A.cpp
==================================================================
--- SRM/339/1A.cpp
+++ SRM/339/1A.cpp
@@ -0,0 +1,86 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class BusTrip
+{
+public:
+	int returnTime(int, vector <string> buses) 
+	{
+		int t=-1, v=0;
+		do
+			onestep( t, v, buses );
+		while( v );
+		return t;
+	}
+
+	void onestep(int& t, int& v, vector<string>& buses)
+	{
+		int mt=1001, mv=0;
+		for(int j=0; j<buses.size(); ++j)
+		{
+			stringstream sin(buses[j]);
+			vector<int> vs;
+			for(int x; sin>>x;)
+				vs.push_back(x);
+
+			int loop_time = 0;
+			for(int i=0; i<vs.size(); ++i)
+				loop_time += abs(vs[(i+1)%vs.size()] - vs[i]);
+
+			int rem = 0;
+			for(int i=0; i<vs.size(); ++i) {
+				if( v==vs[i] )
+				{
+					int nt = rem;
+					while( t >= nt )
+						nt += loop_time;
+					if( nt < mt ) {
+						mt = nt;
+						mv = vs[(i+1)%vs.size()];
+					}
+				}
+				rem += abs(vs[(i+1)%vs.size()] - vs[i]);
+			}
+		}
+
+		t = mt + abs(mv-v);
+		v = mv;
+		if( t > 1000 )
+			t=-1, v=0;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 3; string Arr1[] = {"0 1 2"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 12; verify_case(0, Arg2, returnTime(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 51; string Arr1[] = {"0 5 10 15 20 25 30 35 40 50"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 1000; verify_case(1, Arg2, returnTime(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 3; string Arr1[] = {"0 1 2", "2 1 0"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = -1; verify_case(2, Arg2, returnTime(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 5; string Arr1[] = {"0 1 2 3 4", "3 1 2 0", "4 1 2 3 0", "1 2 0 3 4", "4 0"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 12; verify_case(3, Arg2, returnTime(Arg0, Arg1)); }
+	void test_case_4() { int Arg0 = 25; string Arr1[] = {"24 14 9 7 2", "21 4 18 24 7 1 2 11 8 9 14 16 5 17 13 23 19 15 22", "12 22 24 9 1 5 10 8 7 18 16 19 4 13 17", 
+ "14 5 17 9 23 7 16 22 10 4 6", "19 8 1 9 24 3 5 22 16 7 6 4 10 23 17 0 13 15", 
+ "2 16 10 13 14 1 11 20 0 24 22 23 19 4 18", "19 15 18 0", "15 9 22 5 20 8 23 14 24 18 21 6 13 19", 
+ "2 6 19 3 21 10 20 22 24 13 16 15 8 18 17 14 5", "19 10 1 7 5 11 21 8 14 0 17 23 12 2 3 16"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 157; verify_case(4, Arg2, returnTime(Arg0, Arg1)); }
+	void test_case_5() { int Arg0 = 100; string Arr1[] = {"0 10 30 45 60 46 39 31 20", "9 20 0 86"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = -1; verify_case(5, Arg2, returnTime(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { BusTrip().run_test(-1); }
+// END CUT HERE

ADDED   SRM/339/1B.cpp
Index: SRM/339/1B.cpp
==================================================================
--- SRM/339/1B.cpp
+++ SRM/339/1B.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class TestBettingStrategy
+{
+public:
+	map<int, double> memo;
+	double winProbability(int initSum, int goalSum, int rounds, int prob) 
+	{
+		memo.clear();
+		return rec(initSum, 1, rounds, goalSum, prob/100.0);
+	}
+
+	double rec(int cur, int bet, int rest, int goal, double pWin)
+	{
+		if( cur >= goal ) return 1.0;
+		if( cur < bet )   return 0.0;
+		if( rest == 0 )   return 0.0;
+
+		int key = rest*2000*2000 + cur*2000 + bet;
+		if( memo.count(key) )
+			return memo[key];
+		return memo[key]
+			=    pWin *rec(cur+bet, 1, rest-1, goal, pWin)
+			+ (1-pWin)*rec(cur-bet, bet*2, rest-1, goal, pWin);
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 10; int Arg1 = 11; int Arg2 = 4; int Arg3 = 50; double Arg4 = 0.875; verify_case(0, Arg4, winProbability(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_1() { int Arg0 = 10; int Arg1 = 20; int Arg2 = 20; int Arg3 = 50; double Arg4 = 0.3441343307495117; verify_case(1, Arg4, winProbability(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_2() { int Arg0 = 10; int Arg1 = 20; int Arg2 = 10; int Arg3 = 90; double Arg4 = 0.34867844010000015; verify_case(2, Arg4, winProbability(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_3() { int Arg0 = 24; int Arg1 = 38; int Arg2 = 24; int Arg3 = 60; double Arg4 = 0.5940784635646947; verify_case(3, Arg4, winProbability(Arg0, Arg1, Arg2, Arg3)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { TestBettingStrategy().run_test(-1); }
+// END CUT HERE

ADDED   SRM/339/1C.cpp
Index: SRM/339/1C.cpp
==================================================================
--- SRM/339/1C.cpp
+++ SRM/339/1C.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class RPSTournament
+{
+public:
+	int greatestSeed(int rounds, int C) 
+	{
+		int L=1, R=(1<<rounds)+1;
+		while( R-L > 1) {
+			int M = (L+R)/2;
+			(can_win(M, rounds, C) ? L : R) = M;
+		}
+		return L;
+	}
+
+	bool can_win(int X, int R, int C)
+	{
+		queue< pair<int,int> > Q;
+		Q.push( make_pair(R, X) );
+
+		set<int> unused;
+		for(int n=0; n<=(1<<R); ++n)
+			if( n!=X )
+				unused.insert(n);
+
+		while( !Q.empty() ) {
+			int r=Q.front().first;
+			int x=Q.front().second;
+			Q.pop();
+
+			int xl = x-(int)sqrt((double)C*x);
+			set<int>::iterator it = unused.lower_bound(xl);
+			if( it==unused.end() )
+				return false;
+			if(r > 1) {
+				Q.push( make_pair(r-1,max(*it,x)) );
+				Q.push( make_pair(r-1,min(*it,x)) );
+			}
+			unused.erase(it);
+		}
+		return true;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 2; int Arg1 = 0; int Arg2 = 1; verify_case(0, Arg2, greatestSeed(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 3; int Arg1 = 1; int Arg2 = 6; verify_case(1, Arg2, greatestSeed(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 4; int Arg1 = 1; int Arg2 = 9; verify_case(2, Arg2, greatestSeed(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 7; int Arg1 = 3; int Arg2 = 50; verify_case(3, Arg2, greatestSeed(Arg0, Arg1)); }
+	void test_case_4() { int Arg0 = 15; int Arg1 = 180; int Arg2 = 9755; verify_case(4, Arg2, greatestSeed(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { RPSTournament().run_test(-1); }
+// END CUT HERE

ADDED   SRM/340-U/1A.cpp
Index: SRM/340-U/1A.cpp
==================================================================
--- SRM/340-U/1A.cpp
+++ SRM/340-U/1A.cpp
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class ProblemsToSolve
+{
+public:
+	int minNumber(vector <int> pre, int variety) 
+	{
+		int ans = pre.size();
+		for(int i=0; i<pre.size(); ++i)
+			for(int j=i+1; j<pre.size(); ++j)
+				if( abs(pre[i]-pre[j]) >= variety )
+					ans = min(ans, solve(min(i,j), max(i,j)));
+		return ans;
+	}
+
+	int solve(int S, int D)
+	{
+		return (S+1)/2+1 + (D-S+1)/2;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {1, 2, 3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 2; verify_case(0, Arg2, minNumber(Arg0, Arg1)); }
+	void test_case_1() { int Arr0[] = {1, 2, 3, 4, 5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 3; verify_case(1, Arg2, minNumber(Arg0, Arg1)); }
+	void test_case_2() { int Arr0[] = {10, 1, 12, 101}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100; int Arg2 = 3; verify_case(2, Arg2, minNumber(Arg0, Arg1)); }
+	void test_case_3() { int Arr0[] = {10, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 9; int Arg2 = 2; verify_case(3, Arg2, minNumber(Arg0, Arg1)); }
+	void test_case_4() { int Arr0[] = {6, 2, 6, 2, 6, 3, 3, 3, 7}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 2; verify_case(4, Arg2, minNumber(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { ProblemsToSolve().run_test(-1); }
+// END CUT HERE

ADDED   SRM/340-U/1B.cpp
Index: SRM/340-U/1B.cpp
==================================================================
--- SRM/340-U/1B.cpp
+++ SRM/340-U/1B.cpp
@@ -0,0 +1,80 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class CsCourses
+{
+public:
+	vector <int> getOrder(vector <int> theoreticalValue, vector <int> practicalValue, vector <int> expire, int skillBound) 
+	{
+		typedef pair<int,int> State;
+
+		vector<State> Q;
+		Q.push_back( State(0,0) );
+		map<State, State> prev;
+		map<State, int> lect;
+		lect[State(0,0)] = -1;
+
+		for(int Month=0; !Q.empty(); ++Month)
+		{
+			vector<State> Q2;
+			for(int i=0; i<Q.size(); ++i)
+			{
+				State s = Q[i];
+				int th=s.first, pr=s.second;
+				if( min(th,pr) >= skillBound )
+				{
+					vector<int> ans;
+					for(State p=s; lect[p]>=0; p=prev[p])
+						ans.push_back(lect[p]);
+					reverse(ans.begin(), ans.end());
+					return ans;
+				}
+
+				for(int k=0; k<theoreticalValue.size(); ++k)
+					if( th >= theoreticalValue[k]-1
+					 && pr >= practicalValue[k]-1
+					 && Month < expire[k] )
+					{
+						State s2( max(th,theoreticalValue[k]), max(pr, practicalValue[k]) );
+						if( !lect.count(s2) )
+							Q2.push_back(s2), prev[s2]=s, lect[s2]=k;
+					}
+			}
+			Q.swap(Q2);
+		}
+
+		return vector<int>();
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const vector <int> &Expected, const vector <int> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
+	void test_case_0() { int Arr0[] = {1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; int Arr4[] = {0 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(0, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_1() { int Arr0[] = {1, 2, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2, 1, 1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {5, 5, 5}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; int Arr4[] = {2, 0, 1 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(1, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_2() { int Arr0[] = {1, 2, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2, 1, 1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 1, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; vector <int> Arg4; verify_case(2, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_3() { int Arr0[] = {1, 2, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2, 1, 1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {3, 2, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; int Arr4[] = {2, 1, 0 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(3, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_4() { int Arr0[] = {1, 2, 3, 4, 5, 6, 7}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 2, 3, 4, 5, 6, 7}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 2, 3, 4, 5, 6, 7}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 7; int Arr4[] = {0, 1, 2, 3, 4, 5, 6 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(4, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_5() { int Arr0[] = {0, 1, 2, 2, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0, 0, 1, 2, 1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {9, 9, 9, 9, 9}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; int Arr4[] = {4, 3 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(5, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { CsCourses().run_test(-1); }
+// END CUT HERE

ADDED   SRM/341/1A.cpp
Index: SRM/341/1A.cpp
==================================================================
--- SRM/341/1A.cpp
+++ SRM/341/1A.cpp
@@ -0,0 +1,65 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class KLastNonZeroDigits
+{
+public:
+	string getKDigits(int N, int K) 
+	{
+		// 20! = 20*..*11*10! < 20*..*11*2^22
+		//                    < 16^10 * 2^22
+		//                    = 2^62
+
+		// 10^K
+		LL Z = 1;
+		for(int i=0; i<K; ++i)
+			Z *= 10;
+
+		// N!
+		LL x = 1;
+		for(LL n=2; n<=N; ++n)
+			x *= n;
+		while(x%10==0)
+			x /= 10;
+
+		// Output
+		stringstream sout;
+		if( x < Z )
+			sout << x;
+		else
+			sout << setw(K) << setfill('0') << x%Z;
+		return sout.str();
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 10; int Arg1 = 3; string Arg2 = "288"; verify_case(0, Arg2, getKDigits(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 6; int Arg1 = 1; string Arg2 = "2"; verify_case(1, Arg2, getKDigits(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 6; int Arg1 = 3; string Arg2 = "72"; verify_case(2, Arg2, getKDigits(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 7; int Arg1 = 2; string Arg2 = "04"; verify_case(3, Arg2, getKDigits(Arg0, Arg1)); }
+	void test_case_4() { int Arg0 = 20; int Arg1 = 9; string Arg2 = "200817664"; verify_case(4, Arg2, getKDigits(Arg0, Arg1)); }
+	void test_case_5() { int Arg0 = 1; int Arg1 = 1; string Arg2 = "1"; verify_case(5, Arg2, getKDigits(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { KLastNonZeroDigits().run_test(-1); }
+// END CUT HERE

ADDED   SRM/341/1B.cpp
Index: SRM/341/1B.cpp
==================================================================
--- SRM/341/1B.cpp
+++ SRM/341/1B.cpp
@@ -0,0 +1,170 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+int dy[] = {-1,1, 0,0,-1,-1, 1,1};
+int dx[] = { 0,0,-1,1,-1, 1,-1,1};
+
+class LandAndSea
+{
+public:
+	vector<int> howManyIslands(vector<string> seaMap) 
+	{
+		const int Y = seaMap.size();
+		const int X = seaMap[0].size();
+
+		// paint
+		vector< vector<int> > idMap(Y, vector<int>(X, -1));
+		int nIsland = 0;
+		for(int y=0; y<Y; ++y)
+		for(int x=0; x<X; ++x)
+			if( seaMap[y][x]=='x' && idMap[y][x]==-1 )
+			{
+				int id = (idMap[y][x] = nIsland++);
+				stack< pair<int,int> > S;
+				S.push( make_pair(y,x) );
+				while( !S.empty() ) {
+					pair<int,int> p = S.top();  S.pop();
+					for(int i=0; i<8; ++i) {
+						int yy = p.first +dy[i];
+						int xx = p.second+dx[i];
+						if( 0<=yy && yy<Y && 0<=xx && xx<X )
+							if( seaMap[yy][xx]=='x' && idMap[yy][xx]==-1 )
+								idMap[yy][xx] = id, S.push( make_pair(yy,xx) );
+					}
+				}
+			}
+
+		// I is contained by J
+		vector<int> refered(nIsland);
+		vector<int> ct(nIsland, -1);
+
+		set<int> outer_world;
+		while( outer_world.size() < nIsland )
+		{
+			set<int> outer2;
+			for(int I=0; I<nIsland; ++I)
+				if( !outer_world.count(I) )
+				{
+					stack< pair<int,int> > S;
+					set< pair<int,int> > vis;
+					for(int y=0; y<Y; ++y)
+						for(int x=0; x<X; ++x)
+							if( idMap[y][x] == I )
+								S.push( make_pair(y,x) ), vis.insert(S.top());
+
+					int sID = -1;
+					while( !S.empty() ) {
+						pair<int,int> p = S.top();  S.pop();
+						for(int i=0; i<4; ++i) {
+							int yy = p.first+dy[i];
+							int xx = p.second+dx[i];
+							if( !(0<=yy && yy<Y && 0<=xx && xx<X) )
+								goto notContained;
+							int ssID = idMap[yy][xx];
+							if( outer_world.count(ssID) )
+								{sID=ssID; goto notContained;}
+
+							pair<int,int> pp(yy,xx);
+							if( !vis.count(pp) && seaMap[yy][xx]=='.' )
+								S.push(pp), vis.insert(S.top());
+						}
+					}
+					continue;
+				notContained:
+					outer2.insert(I);
+					if(sID != -1) {
+						ct[I] = sID;
+						refered[sID]++;
+					}
+				}
+			outer_world.insert(outer2.begin(), outer2.end());
+		}
+
+		// topological sort
+		vector<int> level(nIsland, -1);
+		for(int L=0;;++L)
+		{
+			vector<int> victim;
+
+			for(int I=0; I<nIsland; ++I)
+				if( level[I] == -1 && refered[I] == 0 )
+					level[I] = L, victim.push_back(I);
+
+			if( victim.size() == 0 )
+				break;
+
+			for(int i=0; i<victim.size(); ++i)
+			{
+				int J = ct[victim[i]];
+				if( J != -1 )
+					refered[J]--;
+			}
+		}
+
+		vector<int> ans;
+		for(int i=0; i<level.size(); ++i) {
+			if( level[i]+1 > ans.size() )
+				ans.resize( level[i]+1 );
+			ans[level[i]]++;
+		}
+		return ans;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const vector <int> &Expected, const vector <int> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
+	void test_case_0() { string Arr0[] = {"x"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(0, Arg1, howManyIslands(Arg0)); }
+	void test_case_1() { string Arr0[] = {
+"xxxxx",
+"x...x",
+"x.x.x",
+"x...x",
+"xxxxx"
+}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(1, Arg1, howManyIslands(Arg0)); }
+	void test_case_2() { string Arr0[] = {
+"xxxxx",
+"x...x",
+"x.x.x",
+"x...x",
+"xxxxx",
+"xxxxx",
+"x...x",
+"x.x.x",
+"x...x",
+"xxxxx"
+}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2, 1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(2, Arg1, howManyIslands(Arg0)); }
+	void test_case_3() { string Arr0[] = {
+"..",
+".."
+}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); vector <int> Arg1; verify_case(3, Arg1, howManyIslands(Arg0)); }
+	void test_case_4() { string Arr0[] = {
+"............",
+".......xxxx.",
+"..xxx.x...x.",
+"..x..x..x.x.",
+"..x.x.x...x.",
+"..xx...xxx.."
+}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(4, Arg1, howManyIslands(Arg0)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { LandAndSea().run_test(-1); }
+// END CUT HERE

ADDED   SRM/341/1C.cpp
Index: SRM/341/1C.cpp
==================================================================
--- SRM/341/1C.cpp
+++ SRM/341/1C.cpp
@@ -0,0 +1,175 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+vector<LL> vMul( const vector< vector<LL> >& A, const vector<LL>& B )
+{
+	const int n = A.size();
+
+	vector<LL> C(n);
+	for(int i=0; i<n; ++i)
+		for(int j=0; j<n; ++j)
+			C[i] += A[i][j] * B[j];
+	return C;
+}
+
+vector< vector<LL> > mMul( const vector< vector<LL> >& A, const vector< vector<LL> >& B )
+{
+	const int n = A.size();
+
+	vector< vector<LL> > C(n, vector<LL>(n));
+	for(int i=0; i<n; ++i)
+		for(int j=0; j<n; ++j) {
+			LL Cij = 0;
+			for(int k=0; k<n; ++k)
+				Cij += A[i][k] * B[k][j];
+			C[i][j] = Cij;
+		}
+	return C;
+}
+
+vector< vector<LL> > mPow( vector< vector<LL> > M, int t )
+{
+	if( t == 0 ) {
+		vector< vector<LL> > R(M.size(), vector<LL>(M.size()));
+		for(int i=0; i<R.size(); ++i) R[i][i] = 1;
+		return R;
+	}
+	vector< vector<LL> > R;
+	for(; t; t>>=1, M=mMul(M,M))
+		if( t&1 )
+			R = (R.empty() ? M : mMul(R,M));
+	return R;
+}
+
+class ValidPlates
+{
+public:
+	map<pair<int,int>, LL> memo;
+
+	string getPlate(vector <string> profane, int seqno) 
+	{
+		// parse
+		bool proh[10][10] = {};
+		for(int i=0; i<profane.size(); ++i) {
+			stringstream sin(profane[i]);
+			for(int n; sin>>n; )
+				proh[n/10][n%10] = true;
+		}
+
+		// matrix
+		vector<LL> N(11, 1); N[10] = 0;
+		vector< vector<LL> > M(11, vector<LL>(11));
+		for(int i=0; i<10; ++i)
+		for(int j=0; j<10; ++j)
+			if( !proh[i][j] )
+				M[i][j] = 1;
+		for(int j=1; j<11; ++j)
+			M[10][j] = 1;
+
+		// binary search...
+		LL L=-1, R=0;
+		for(LL atprev=-1;; R=R*2+1)
+		{
+			vector< vector<LL> > Mt = mPow(M,  R);
+			vector<LL>           Nt = vMul(Mt, N);
+			LL                   at = accumulate(Nt.begin()+1, Nt.end(), 0LL);
+			if( atprev == at )
+				return "";
+			atprev = at;
+			if( seqno <= at )
+				break;
+		}
+		while(R-L>1)
+		{
+			LL C=(L+R)/2;
+			vector< vector<LL> > Mt = mPow(M, C);
+			vector<LL>           Nt = vMul(Mt, N);
+			(seqno <= accumulate(Nt.begin()+1, Nt.end(), 0LL) ? R : L) = C;
+		}
+		LL d = R+1; // #digits
+		seqno -= vMul(mPow(M,R), N)[10];
+
+		string buf;
+		int prev = -1;
+		for(int i=0; i<(d>50 ? 47 : d); ++i)
+			if( prev == -1 )
+			{
+				vector<LL> Nt = vMul(mPow(M, d-1-i), N);
+				LL n = 0;
+				for(int a=1; a<10; ++a)
+				{
+					n += Nt[a];
+					if( seqno <= n )
+						{buf += char('0'+a); prev=a; seqno-=n-Nt[a]; break;}
+				}
+			}
+			else
+			{
+				vector<LL> Nt = vMul(mPow(M, d-1-i), N);
+				LL n = 0;
+				for(int a=0; a<10; ++a) if( !proh[prev][a] )
+				{
+					n += Nt[a];
+					if( seqno <= n )
+						{buf += char('0'+a); prev=a; seqno-=n-Nt[a]; break;}
+				}
+			}
+		return (d>50 ? buf+"..." : buf);
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { vector <string> Arg0; int Arg1 = 1000; string Arg2 = "1000"; verify_case(0, Arg2, getPlate(Arg0, Arg1)); }
+	void test_case_1() { string Arr0[] = {"10"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 10; string Arg2 = "11"; verify_case(1, Arg2, getPlate(Arg0, Arg1)); }
+	void test_case_2() { string Arr0[] = {"10"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2000000000; string Arg2 = "2277659869"; verify_case(2, Arg2, getPlate(Arg0, Arg1)); }
+	void test_case_3() { string Arr0[] = {"00 01 02 03 04 05 06 07 08 09 11 12 13 14 15 16 17",
+ "18 19 22 23 24 25 26 27 28 29 33 34 35 36 37 38 39",
+ "44 45 46 47 48 49 55 56 57 58 59 66 67 68 69 77 78",
+ "79 88 89 99 99 99 99 99"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1023; string Arg2 = ""; verify_case(3, Arg2, getPlate(Arg0, Arg1)); }
+	void test_case_4() { string Arr0[] = {"00 01 02 03 04 05 07 08 09",
+ "10 11 12 13 14 15 17 18 19",
+ "20 21 22 24 25 26 27 28 29",
+ "30 31 32 33 34 36 37 38 39",
+ "41 43 45 46 48",
+ "52 53 54 55 56 58 59",
+ "60 61 63 64 66 67 68 69",
+ "70 72 73 74 75 76 77 78",
+ "80 81 82 83 84 86 87 88 89",
+ "90 91 92 94 95 96 97 98"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2000000000; string Arg2 = "79999999351623516571657999935799993"; verify_case(4, Arg2, getPlate(Arg0, Arg1)); }
+	void test_case_5() { string Arr0[] = {"00 01 02 03 04 05 06 07 08 09",
+ "10 11 12 13 14 16 17 19",
+ "20 21 22 23 24 25 26 27 28 29",
+ "30 31 32 33 34 35 36 38 39",
+ "41 42 43 44 45 46 49",
+ "50 52 53 54 55 57 58 59",
+ "60 61 62 63 64 65 66 67 68 69",
+ "70 72 73 74 75 76 77 78 79",
+ "80 81 82 83 84 85 86 87 88 89",
+ "90 91 92 93 94 95 98 99"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2000000000; string Arg2 = "37151515151515151515151515151515151515151515151..."; verify_case(5, Arg2, getPlate(Arg0, Arg1)); }
+	void test_case_6() { string Arr0[] = {"00 01 02 03 04 05 06 07 08 09", "10 12 13 14 15 16 17 18 19", "20 21 22 23 24 25 26 27 28 29", "30 31 32 33 34 35 36 37 38 39", "40 41 42 43 44 45 46 47 48 49", "50 51 52 53 54 55 56 57 58 59", "60 61 62 63 64 65 66 67 68 69", "70 71 72 73 74 75 76 77 78 79", "80 81 82 83 84 85 86 87 88 89", "90 91 92 93 94 95 96 97 98 99"};
+ vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2000000000; string Arg2 = "11111111111111111111111111111111111111111111111..."; verify_case(6, Arg2, getPlate(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { ValidPlates().run_test(-1); }
+// END CUT HERE

ADDED   SRM/342/1A.cpp
Index: SRM/342/1A.cpp
==================================================================
--- SRM/342/1A.cpp
+++ SRM/342/1A.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+int get_and_go( const string& a, int& i )
+{
+	int dict[] =
+		{'a','b','k','d','e','g','h','i','l','m','n','n'/*g*/,'o','p','r','s','t','u','w','y'};
+	for(int k=0;; ++k)
+		if( dict[k] == a[i] )
+			if( a[i]=='n' && i+1<a.size() && a[i+1]=='g' )
+				{i+=2; return k+1;}
+			else
+				{i++;  return k;}
+}
+
+bool tgcmp( const string& a, const string& b )
+{
+	int i=0, j=0;
+	for(;;)
+	{
+		if( i==a.size() && j==b.size() )
+			return false;
+		if( i==a.size() )
+			return true;
+		if( j==b.size() )
+			return false;
+
+		int ai = get_and_go(a, i);
+		int bj = get_and_go(b, j);
+		if( ai != bj )
+			return ai < bj;
+	}
+}
+
+class TagalogDictionary
+{
+public:
+	vector <string> sortWords(vector <string> words) 
+	{
+		sort( words.begin(), words.end(), &tgcmp );
+		return words;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const vector <string> &Expected, const vector <string> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
+	void test_case_0() { string Arr0[] = {"abakada","alpabet","tagalog","ako"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"abakada", "ako", "alpabet", "tagalog" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(0, Arg1, sortWords(Arg0)); }
+	void test_case_1() { string Arr0[] = {"ang","ano","anim","alak","alam","alab"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"alab", "alak", "alam", "anim", "ano", "ang" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(1, Arg1, sortWords(Arg0)); }
+	void test_case_2() { string Arr0[] = {"siya","niya","kaniya","ikaw","ito","iyon"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"kaniya", "ikaw", "ito", "iyon", "niya", "siya" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(2, Arg1, sortWords(Arg0)); }
+	void test_case_3() { string Arr0[] = {"kaba","baka","naba","ngipin","nipin"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"baka", "kaba", "naba", "nipin", "ngipin" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(3, Arg1, sortWords(Arg0)); }
+	void test_case_4() { string Arr0[] = {"knilngiggnngginggn","ingkigningg","kingkong","dingdong","dindong","dingdont","ingkblot"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"kingkong", "knilngiggnngginggn", "dindong", "dingdont", "dingdong", "ingkblot", "ingkigningg" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(4, Arg1, sortWords(Arg0)); }
+	void test_case_5() { string Arr0[] = {"silangang", "baka", "bada", "silang"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"baka", "bada", "silang", "silangang" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(5, Arg1, sortWords(Arg0)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	TagalogDictionary().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/342/1B.cpp
Index: SRM/342/1B.cpp
==================================================================
--- SRM/342/1B.cpp
+++ SRM/342/1B.cpp
@@ -0,0 +1,112 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+static const int MODNUM = 1000000007;
+
+// make [i,j) by k[z..$]
+LL dp[31][31][51][51];
+
+class ReverseResources
+{
+public:
+	int findDecompositions(string str, vector <string> resources) 
+	{
+		memset(dp, 0xff, sizeof(dp));
+
+		LL sum = 0;
+		for(int k=0; k<resources.size(); ++k)
+			sum = (sum + rec(0, str.size(), k, 0, str, resources, dp)) % MODNUM;
+		return sum;
+	}
+
+	LL rec(int i, int j, int k, int z, string& s, vector<string>& rs, LL dp[31][31][51][51] )
+	{
+		if( dp[i][j][k][z] >= 0 )
+			return dp[i][j][k][z];
+
+		string& r = rs[k];
+		if( z==r.size() )
+			return dp[i][j][k][z] = (i==j ? 1 : 0);
+
+		if( r[z] == '%' )
+		{
+			LL sum = 0;
+			if( z+2 == r.size() )
+			{
+				for(int kk=0; kk<rs.size(); ++kk)
+					sum = (sum + rec(i, j, kk, 0, s, rs, dp)) % MODNUM;
+			}
+			else
+			{
+				for(int jj=i+1; jj<j; ++jj)
+				{
+					LL right = rec(jj, j, k, z+2, s, rs, dp);
+					if( right ) {
+						LL left = 0;
+						for(int kk=0; kk<rs.size(); ++kk)
+							left = (left + rec(i, jj, kk, 0, s, rs, dp)) % MODNUM;
+						sum = (sum + left*right) % MODNUM;
+					}
+				}
+			}
+			return dp[i][j][k][z] = sum;
+		}
+		else
+		{
+			if( r[z]==s[i] && i+1<=j )
+				return dp[i][j][k][z] = rec(i+1,j,k,z+1,s,rs,dp);
+			else
+				return dp[i][j][k][z] = 0;
+		}
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arg0 = "Error in module foo, code 123."; string Arr1[] = {"foo", "123", "Error in module %s.", "%s, code %s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 1; verify_case(0, Arg2, findDecompositions(Arg0, Arg1)); }
+	void test_case_1() { string Arg0 = "The fox jumped over the dog."; string Arr1[] = {"The fox %s over the dog.",
+ "lazy",
+ "brown",
+ "jump%s",
+ "s",
+ "ed",
+ "The %s",
+ "fox %s",
+ "%s over %s",
+ "the dog."}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 5; verify_case(1, Arg2, findDecompositions(Arg0, Arg1)); }
+	void test_case_2() { string Arg0 = "abcde"; string Arr1[] = {"%sc%s", "b", "de", "a%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 2; verify_case(2, Arg2, findDecompositions(Arg0, Arg1)); }
+	void test_case_3() { string Arg0 = "abcde"; string Arr1[] = {"%se", "a%s", "%sb%s", "%sc%s", "%sd%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 0; verify_case(3, Arg2, findDecompositions(Arg0, Arg1)); }
+	void test_case_4() { string Arg0 = "aaaaa"; string Arr1[] = {"a","%s%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 14; verify_case(4, Arg2, findDecompositions(Arg0, Arg1)); }
+	void test_case_5() { string Arg0 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; string Arr1[] = {"a","aa","%s%s","%sa","a%s","aaa","aa%s","a%sa",
+"a%s%s","%saa","%sa%s","%s%sa","%s%s%s","aaaa",
+"aaa%s","aa%sa","aa%s%s","a%saa","a%sa%s","a%s%sa",
+"a%s%s%s","%saaa","%saa%s","%sa%sa","%sa%s%s",
+"%s%saa","%s%sa%s","%s%s%sa","%s%s%s%s","aaaaa",
+"aaaa%s","aaa%sa","aaa%s%s","aa%saa","aa%sa%s",
+"aa%s%sa","aa%s%s%s","a%saaa","a%saa%s","a%sa%sa",
+"a%sa%s%s","a%s%saa","a%s%sa%s","a%s%s%sa",
+"a%s%s%s%s","%saaaa","%saaa%s","%saa%sa","%saa%s%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 879704799; verify_case(5, Arg2, findDecompositions(Arg0, Arg1)); }
+	void test_case_6() { string Arg0 = "aa"; string Arr1[] = {"a", "a", "%s%s", "%s%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 8; verify_case(6, Arg2, findDecompositions(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { ReverseResources().run_test(-1); }
+// END CUT HERE

ADDED   SRM/342/1C.cpp
Index: SRM/342/1C.cpp
==================================================================
--- SRM/342/1C.cpp
+++ SRM/342/1C.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+vector< vector<LL> > mMul( const vector< vector<LL> >& A, const vector< vector<LL> >& B )
+{
+	const int n = A.size();
+
+	vector< vector<LL> > C(n, vector<LL>(n));
+	for(int i=0; i<n; ++i)
+		for(int j=0; j<n; ++j) {
+			LL Cij = 0;
+			for(int k=0; k<n; ++k)
+				Cij += A[i][k] * B[k][j];
+			C[i][j] = Cij % 1000003;
+		}
+	return C;
+}
+
+vector< vector<LL> > mPow( vector< vector<LL> > M, int t ) // t>0
+{
+	vector< vector<LL> > R;
+	for(; t; t>>=1, M=mMul(M,M))
+		if( t&1 )
+			R = (R.empty() ? M : mMul(R,M));
+	return R;
+}
+
+class DrivingAround
+{
+public:
+	int numberOfWays(vector <string> adj, int start, int finish, int time) 
+	{
+		int n = adj.size()*5;
+		vector< vector<LL> > M(n, vector<LL>(n));
+		for(int u=0; u<adj.size(); ++u)
+			for(int d=0; d<4; ++d)
+				M[u*5+d+1][u*5+d] = 1;
+
+		for(int u=0; u<adj.size(); ++u)
+		for(int v=0; v<adj.size(); ++v)
+			if( adj[u][v] != '.' )
+				M[u*5][v*5+adj[u][v]-'0'-1] = 1;
+
+		return int( mPow(M, time)[start*5][finish*5] );
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arr0[] = {".12",
+ "2.1",
+ "12."}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 0; int Arg2 = 2; int Arg3 = 5; int Arg4 = 8; verify_case(0, Arg4, numberOfWays(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_1() { string Arr0[] = {"....52....",
+ "..5.......",
+ "..........",
+ ".......1..",
+ "......42.2",
+ "5...4.....",
+ ".5...4...1",
+ "......5...",
+ ".3244.....",
+ ".........."}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 2; int Arg3 = 10; int Arg4 = 0; verify_case(1, Arg4, numberOfWays(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_2() { string Arr0[] = {"...14....1",
+ "......13..",
+ ".2...4....",
+ "....52.5..",
+ "1.3..4....",
+ ".3....35.5",
+ "4......1.1",
+ "..4.4.1.54",
+ "....4.11.5",
+ "31144.2.4."}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; int Arg2 = 2; int Arg3 = 100; int Arg4 = 316984; verify_case(2, Arg4, numberOfWays(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_3() { string Arr0[] = {".555555555", "5.55555555", "55.5554555", "555.555555", "5555.55555", "55555.5555", "555555.555", "5555555.55", "55553555.5", "555555555."};
+vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 0; int Arg2 = 7; int Arg3 = 1000000000; int Arg4 = 255218; verify_case(3, Arg4, numberOfWays(Arg0, Arg1, Arg2, Arg3)); }
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { DrivingAround().run_test(-1); }
+// END CUT HERE

ADDED   SRM/343/1A.cpp
Index: SRM/343/1A.cpp
==================================================================
--- SRM/343/1A.cpp
+++ SRM/343/1A.cpp
@@ -0,0 +1,84 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class CDPlayer
+{
+public:
+	int isRandom(vector <string> songlist, int n)
+	{
+		string s;
+		for(int i=0; i<songlist.size(); ++i)
+			s += songlist[i];
+
+		for(int k=0; k<n; ++k)
+			if( check(s, k, n) )
+				return k;
+		return -1;
+	}
+
+	bool check(const string& s, int k, int n)
+	{
+		for(int i=0,e=k; i<s.size(); i=e,e+=n)
+			if( !distinct(s, i, min<int>(e,s.size())) )
+				return false;
+		return true;
+	}
+
+	bool distinct( const string& s, int i, int e )
+	{
+		set<char> x;
+		for(; i<e; ++i)
+			if( x.count(s[i]) )
+				return false;
+			else
+				x.insert( s[i] );
+		return true;
+	}
+
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arr0[] = {"BBAC"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 1; verify_case(0, Arg2, isRandom(Arg0, Arg1)); }
+	void test_case_1() { string Arr0[] = {"BACAB",
+ "BCA"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 2; verify_case(1, Arg2, isRandom(Arg0, Arg1)); }
+	void test_case_2() { string Arr0[] = {"AAACBACBACBACBACBACBACB"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = -1; verify_case(2, Arg2, isRandom(Arg0, Arg1)); }
+	void test_case_3() { string Arr0[] = {"ABCDEABDECBAECDEDACB"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 5; int Arg2 = 0; verify_case(3, Arg2, isRandom(Arg0, Arg1)); }
+	void test_case_4() { string Arr0[] = {"ABCABCABCABCABCABCABC",
+ "ABCABCABCABCABCABCABC"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 22; int Arg2 = -1; verify_case(4, Arg2, isRandom(Arg0, Arg1)); }
+	void test_case_5() { string Arr0[] = {"AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAA"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 0; verify_case(5, Arg2, isRandom(Arg0, Arg1)); }
+	void test_case_6() { string Arr0[] = {"ADEF"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 12; int Arg2 = 0; verify_case(6, Arg2, isRandom(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	CDPlayer().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/343/1B.cpp
Index: SRM/343/1B.cpp
==================================================================
--- SRM/343/1B.cpp
+++ SRM/343/1B.cpp
@@ -0,0 +1,83 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class MoneyGame
+{
+public:
+	int V1, V2, V3;
+	map<int, int> memo;
+	int play(vector <int> lennysCoins, vector <int> fredsCoins, vector <int> values) 
+	{
+		V1 = values[0];
+		V2 = values[1];
+		V3 = values[2];
+		memo.clear();
+		return rec( lennysCoins[0], lennysCoins[1], lennysCoins[2],
+		             fredsCoins[0],  fredsCoins[1],  fredsCoins[2], 0, 0, 0 );
+	}
+
+	int rec(int L1, int L2, int L3, int F1, int F2, int F3, int B1, int B2, int B3)
+	{
+		if( !L1 && !L2 && !L3 )
+			return -(V1*F1+V2*F2+V3*F3);
+		int key = (L1<<20)|(L2<<16)|(L3<<12)|(F1<<8)|(F2<<4)|(F3<<0);
+		if( memo.count(key) )
+			return memo[key];
+
+		int score = -0x7fffffff;
+		if(L1) {
+			for(int b1=0; b1<=B1 && V1*b1<V1; ++b1)
+			for(int b2=0; b2<=B2 && V1*b1+V2*b2<V1; ++b2)
+			for(int b3=0; b3<=B3 && V1*b1+V2*b2+V3*b3<V1; ++b3)
+				score = max(score, -rec(F1, F2, F3, L1+b1-1, L2+b2, L3+b3, B1-b1+1, B2-b2, B3-b3));
+		}
+		if(L2) {
+			for(int b1=0; b1<=B1 && V1*b1<V2; ++b1)
+			for(int b2=0; b2<=B2 && V1*b1+V2*b2<V2; ++b2)
+			for(int b3=0; b3<=B3 && V1*b1+V2*b2+V3*b3<V2; ++b3)
+				score = max(score, -rec(F1, F2, F3, L1+b1, L2+b2-1, L3+b3, B1-b1, B2-b2+1, B3-b3));
+		}
+		if(L3) {
+			for(int b1=0; b1<=B1 && V1*b1<V3; ++b1)
+			for(int b2=0; b2<=B2 && V1*b1+V2*b2<V3; ++b2)
+			for(int b3=0; b3<=B3 && V1*b1+V2*b2+V3*b3<V3; ++b3)
+				score = max(score, -rec(F1, F2, F3, L1+b1, L2+b2, L3+b3-1, B1-b1, B2-b2, B3-b3+1));
+		}
+		return memo[key] = score;
+	}
+
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {0,1,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {20,10,2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = -2; verify_case(0, Arg3, play(Arg0, Arg1, Arg2)); }
+	void test_case_1() { int Arr0[] = {0,1,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {20,10,2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; verify_case(1, Arg3, play(Arg0, Arg1, Arg2)); }
+	void test_case_2() { int Arr0[] = {1,1,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,5,10}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 0; verify_case(2, Arg3, play(Arg0, Arg1, Arg2)); }
+	void test_case_3() { int Arr0[] = {4,4,3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {4,3,4}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {100,753,100}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 600; verify_case(3, Arg3, play(Arg0, Arg1, Arg2)); }
+	void test_case_4() { int Arr0[] = {0,0,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {5,5,5}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1000,1000,1000}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = -15000; verify_case(4, Arg3, play(Arg0, Arg1, Arg2)); }
+	void test_case_5() { int Arr0[] = {3,2,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0,0}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {6,8,14}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 42; verify_case(5, Arg3, play(Arg0, Arg1, Arg2)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	MoneyGame().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/343/1C.cpp
Index: SRM/343/1C.cpp
==================================================================
--- SRM/343/1C.cpp
+++ SRM/343/1C.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class RefactorableNumber
+{
+public:
+	vector<int> P;
+
+	int count(int low, int high) 
+	{
+		P.clear();
+		vector<bool> isP(2000, true);
+		for(int p=2; p<2000; ++p)
+			if( isP[p] ) {
+				P.push_back(p);
+				for(int q=p*p; q<2000; q+=p)
+					isP[q] = false;
+			}
+
+		int cnt = 0;
+		for(int n=low; n<=high; ++n)
+			if( ref(n) )
+				++cnt;
+		return cnt;
+	}
+
+	bool ref(int N)
+	{
+		int n = N;
+		int x = 1;
+		for(int i=0; i<P.size() && n>1; ++i)
+		{
+			int p = P[i];
+			if( p*p > n )
+				break;
+			int c = 0;
+			while(n%p==0)
+				n/=p, ++c;
+			x *= c+1;
+		}
+		if(n>1)
+			x *= 2;
+		return N%x == 0;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 1; int Arg1 = 10; int Arg2 = 4; verify_case(0, Arg2, count(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 10; int Arg1 = 100; int Arg2 = 12; verify_case(1, Arg2, count(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 25; int Arg1 = 35; int Arg2 = 0; verify_case(2, Arg2, count(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 123; int Arg1 = 4567; int Arg2 = 315; verify_case(3, Arg2, count(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	RefactorableNumber().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/344/1A.cpp
Index: SRM/344/1A.cpp
==================================================================
--- SRM/344/1A.cpp
+++ SRM/344/1A.cpp
@@ -0,0 +1,80 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class VolleyballTournament
+{
+public:
+	string reconstructResults(int wonMatches, int lostMatches, int wonSets, int lostSets) 
+	{
+		//0-3, 1-3, 2-3, 3-0, 3-1, 3-2
+		//Z0   Z1   Z2   W0   W1   W2
+
+		//Z0+    Z1   + Z2                  == lostMatches
+		//Z0*0 + Z1*1 + Z2*2 + 3*wonMatches == wonSets
+
+		//W0+W1+W2 == wonMatches
+		//W0*0+W1*1+W2*2+3*lostMatches == lostSets
+
+		int a[6] = {-1};
+		for(int Z1=0; Z1<=lostMatches; ++Z1)
+		{
+			int Z2 = (wonSets - 3*wonMatches - Z1) / 2;
+			int Z0 = lostMatches - Z1 - Z2;
+			if( Z0<0 || Z2<0 || lostMatches<Z0 || lostMatches<Z2 ) continue;
+			if( Z1+Z2*2+3*wonMatches != wonSets ) continue;
+
+			for(int W1=0; W1<=wonMatches; ++W1)
+			{
+				int W2 = (lostSets - 3*lostMatches - W1) / 2;
+				int W0 = wonMatches - W1 - W2;
+				if( W0<0 || W2<0 || wonMatches<W0 || wonMatches<W2 ) continue;
+				if( W1+W2*2+3*lostMatches != lostSets ) continue;
+
+				if( a[0]>=0 )
+					return "AMBIGUITY";
+				else
+					a[0]=Z0, a[1]=Z1, a[2]=Z2, a[3]=W0, a[4]=W1, a[5]=W2;
+			}
+		}
+		const char* s[6] = {"0-3", "1-3", "2-3", "3-0", "3-1", "3-2"};
+
+		string ans;
+		for(int i=0; i<6; ++i)
+			for(int j=0; j<a[i]; ++j)
+				ans += s[i], ans += ",";
+		ans.resize(ans.size()-1);
+		return ans;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 3; int Arg1 = 3; int Arg2 = 9; int Arg3 = 9; string Arg4 = "0-3,0-3,0-3,3-0,3-0,3-0"; verify_case(0, Arg4, reconstructResults(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_1() { int Arg0 = 0; int Arg1 = 3; int Arg2 = 6; int Arg3 = 9; string Arg4 = "2-3,2-3,2-3"; verify_case(1, Arg4, reconstructResults(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_2() { int Arg0 = 3; int Arg1 = 0; int Arg2 = 9; int Arg3 = 3; string Arg4 = "AMBIGUITY"; verify_case(2, Arg4, reconstructResults(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_3() { int Arg0 = 1; int Arg1 = 1; int Arg2 = 4; int Arg3 = 4; string Arg4 = "1-3,3-1"; verify_case(3, Arg4, reconstructResults(Arg0, Arg1, Arg2, Arg3)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	VolleyballTournament().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/344/1B.cpp
Index: SRM/344/1B.cpp
==================================================================
--- SRM/344/1B.cpp
+++ SRM/344/1B.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class QuantumAlchemy
+{
+public:
+	int minSteps(string initial, vector <string> reactions) 
+	{
+		map<char, string> r;
+		for(int i=0; i<reactions.size(); ++i)
+		{
+			int j = reactions[i].find('-');
+			r[reactions[i][j+2]] = reactions[i].substr(0, j);
+		}
+
+		map<char, int> g;
+		for(int i=0; i<initial.size(); ++i)
+			g[initial[i]]++;
+
+		if( g['X'] )
+			return 0;
+		set<char> stk; stk.insert('X');
+		return make('X', r, g, stk);
+	}
+
+	int make(char X, map<char,string>& r, map<char, int>& g, set<char>& stk)
+	{
+		if( !r.count(X) )
+			return -1;
+		string s = r[X];
+
+		int rea = 1;
+		for(int i=0; i<s.size(); ++i)
+			if( g[s[i]] )
+				g[s[i]]--;
+			else {
+				if( stk.count(s[i]) )
+					return -1;
+				stk.insert(s[i]);
+				int subrea = make(s[i], r, g, stk);
+				stk.erase(s[i]);
+				if( subrea == -1 )
+					return -1;
+				rea += subrea;
+			}
+		return rea;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arg0 = "ABCDE"; string Arr1[] = {"ABC->F", "FE->X"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 2; verify_case(0, Arg2, minSteps(Arg0, Arg1)); }
+	void test_case_1() { string Arg0 = "AABBB"; string Arr1[] = {"BZ->Y", "ZY->X", "AB->Z"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 4; verify_case(1, Arg2, minSteps(Arg0, Arg1)); }
+	void test_case_2() { string Arg0 = "AAABB"; string Arr1[] = {"BZ->Y", "ZY->X", "AB->Z"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = -1; verify_case(2, Arg2, minSteps(Arg0, Arg1)); }
+	void test_case_3() { string Arg0 = "AAXB"; string Arr1[] = {"BZ->Y", "ZY->X", "AB->Z"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 0; verify_case(3, Arg2, minSteps(Arg0, Arg1)); }
+	void test_case_4() { string Arg0 = "ABCDEFGHIJKLMNOPQRSTUVWYZABCDEFGHIJKLMNOPQRSTUVWYZ"; string Arr1[] = {"ABCE->Z", "RTYUIO->P", "QWER->T", "MN->B"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = -1; verify_case(4, Arg2, minSteps(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	QuantumAlchemy().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/344/1C.cpp
Index: SRM/344/1C.cpp
==================================================================
--- SRM/344/1C.cpp
+++ SRM/344/1C.cpp
@@ -0,0 +1,84 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class FairTournament
+{
+public:
+	vector<string> memo;
+
+	string add(const string& a, const string& b)
+	{
+		int n = max(a.size(), b.size()), carry=0;
+		string c(n, '0');
+		for(int i=0; i<n; ++i) {
+			int x = (a.size()<=i ? 0 : a[a.size()-1-i]-'0')
+			      + (b.size()<=i ? 0 : b[b.size()-1-i]-'0') + carry;
+			c[n-1-i] = char('0'+x%10);
+			carry = x/10;
+		}
+		if( carry ) c = char('0'+carry)+c;
+		return c;
+	}
+
+	string countPermutations(int n, int k) 
+	{
+		memo.clear();
+		memo.resize(n<<k+1+k, "X");
+
+		int pending = (1<<k+1) - 1; // 0b00111 (case k=2)
+		return rec(pending, 0, n, k);
+	}
+
+	string rec(int pending, int i, int n, int k)
+	{
+		if( i == n )
+			return "1";
+
+		int key = (i<<k+1+k) | pending;
+		if( memo[key]!="X" )
+			return memo[key];
+
+		string sum = "";
+		for(int m=1,j=k; m<=pending; m<<=1,j--)
+			if( (pending & m) && i+j<n )
+			{
+				int p2 = ((pending^m)<<1) | 1;
+				if( p2 >= (1<<k+1+k) ) // 0b100000
+					continue;
+				sum = add(sum, rec(p2, i+1, n, k));
+			}
+		return memo[key]=sum;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 3; int Arg1 = 1; string Arg2 = "3"; verify_case(0, Arg2, countPermutations(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 3; int Arg1 = 2; string Arg2 = "6"; verify_case(1, Arg2, countPermutations(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 10; int Arg1 = 3; string Arg2 = "19708"; verify_case(2, Arg2, countPermutations(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 100; int Arg1 = 1; string Arg2 = "573147844013817084101"; verify_case(3, Arg2, countPermutations(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	FairTournament().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/345/1A.cpp
Index: SRM/345/1A.cpp
==================================================================
--- SRM/345/1A.cpp
+++ SRM/345/1A.cpp
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class Pathfinding
+{
+public:
+	int getDirections(int x, int y) 
+	{
+		if( x==0 && y==0 )
+			return 0;
+
+		int xincr = 0;
+		int yincr = 0;
+		if(x<0) yincr=1, x=-x;
+		if(y<0) xincr=1, y=-y;
+		if( x==0 )
+			swap(xincr, yincr), swap(x, y);
+
+		if( y==0 )
+		{
+			if( yincr == 0 )
+				return x;
+			else
+				if( x%2 == 1 )
+					return x+2;
+				else
+					return x+4;
+		}
+
+		if( 0==xincr && y%2==yincr || 0==yincr && x%2==xincr )
+			return x+y;
+
+		if( 0==xincr && x%2==xincr || 0==yincr && y%2==yincr )
+			return x+y;
+
+		if( 0==xincr || 0==yincr )
+			return x+y+2;
+
+		if( x%2==xincr || y%2==yincr )
+			return x+y+2;
+
+		return x+y+4;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 0; int Arg1 = -4; int Arg2 = 8; verify_case(0, Arg2, getDirections(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 5; int Arg1 = -4; int Arg2 = 9; verify_case(1, Arg2, getDirections(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 5; int Arg1 = 4; int Arg2 = 9; verify_case(2, Arg2, getDirections(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = -1; int Arg1 = -4; int Arg2 = 7; verify_case(3, Arg2, getDirections(Arg0, Arg1)); }
+	void test_case_4() { int Arg0 = 0; int Arg1 = 0; int Arg2 = 0; verify_case(4, Arg2, getDirections(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { Pathfinding().run_test(-1); }
+// END CUT HERE

ADDED   SRM/345/1B.cpp
Index: SRM/345/1B.cpp
==================================================================
--- SRM/345/1B.cpp
+++ SRM/345/1B.cpp
@@ -0,0 +1,62 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class StoneGame
+{
+public:
+	int getScore(vector <int> treasure, vector <int> stones) 
+	{
+		// Note that we always lose 'even' piles...
+
+		vector<int> ones;
+		int numOdds = 0;
+		int sumGt1  = 0;
+
+		int n = treasure.size();
+		for(int i=0; i<n; ++i)
+			if( stones[i] == 1 )
+				ones.push_back( treasure[i] );
+			else
+				numOdds += stones[i]%2,
+				sumGt1  += treasure[i];
+
+		sort(ones.rbegin(), ones.rend());
+
+		int score = 0;
+		for(int i=0; i<ones.size(); i+=2) // take 1-stone piles altenatively
+			score += ones[i];
+		if(  (ones.size()+numOdds)%2 == 1 ) // then make odd-stone piles into even
+			score += sumGt1; // if all piles are made even, one-side takes all
+		return score;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {3,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 5; verify_case(0, Arg2, getScore(Arg0, Arg1)); }
+	void test_case_1() { int Arr0[] = {5,4,3,2,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,1,1,1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 9; verify_case(1, Arg2, getScore(Arg0, Arg1)); }
+	void test_case_2() { int Arr0[] = {5,5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2,2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 0; verify_case(2, Arg2, getScore(Arg0, Arg1)); }
+	void test_case_3() { int Arr0[] = {1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 0; verify_case(3, Arg2, getScore(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { StoneGame().run_test(-1); }
+// END CUT HERE

ADDED   SRM/345/1C.cpp
Index: SRM/345/1C.cpp
==================================================================
--- SRM/345/1C.cpp
+++ SRM/345/1C.cpp
@@ -0,0 +1,143 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+LL next_combination(LL p)
+{
+	LL lsb = p & -p;
+	LL rem = p + lsb;
+	LL rit = rem & ~p;
+	return rem|(((rit/lsb)>>1)-1);
+}
+
+class ByteLand
+{
+public:
+	int buildCastles(vector<int> road, vector<int> distance, vector<int> castle, int k) 
+	{
+		int n = road.size();
+
+		// Construct the Graph
+		int d[50][50] = {};
+		for(int v=0; v<n; ++v)
+			for(int u=v+1; u<n; ++u)
+				d[v][u] = d[u][v] = 0x3fffffff;
+		for(int v=0; v<n; ++v)
+			d[v][road[v]] = d[road[v]][v] = min( d[v][road[v]], distance[v] );
+
+		// Warshall-Floyd
+		for(int m=0; m<n; ++m)
+			for(int i=0; i<n; ++i)
+				for(int j=0; j<n; ++j)
+					d[i][j] = min(d[i][j], d[i][m]+d[m][j]);
+
+		// Binary Search: the answer is in (L,R]
+		int L=-1, R=accumulate(distance.begin(), distance.end(), 0);
+		while( R-L > 1 )
+			(is_possible((L+R)/2, d, n, castle, k) ? R : L) = (L+R)/2;
+		return R;
+	}
+
+	bool is_possible( int D, int d[50][50], int n, const vector<int>& c, int k )
+	{
+		// the set of cities not covered yet
+		LL goal = (1LL << n) - 1;
+		for(int v=0; v<n; ++v)
+			for(int i=0; i<c.size(); ++i)
+				if( d[v][c[i]] <= D )
+					goal &= ~(1LL << v);
+
+		// the set of cities each city can cover
+		set<LL> mask;
+		for(int v=0; v<n; ++v) {
+			LL m = 0;
+			for(int u=0; u<n; ++u)
+				if( d[v][u] <= D )
+					m |= (1LL << u);
+			if( m&goal )
+				mask.insert( m&goal );
+		}
+
+		// is it possible to cover the goal by at most k elements from mask?
+		return canCover(goal, mask, k);
+	}
+
+	bool canCover( LL goal, set<LL>& mask, int k )
+	{
+		// optimizer
+		for(bool update=true; update; ) {
+			update = false;
+
+			// if *it \subseteq *jt for some jt, then we NEVER use it
+			// if *it is the only mask covering some city, we ALWAYS use it
+			for(set<LL>::iterator it=mask.begin(); it!=mask.end(); ) {
+				bool isSubset = false;
+				LL   onlyByMe = *it & goal;
+				for(set<LL>::iterator jt=mask.begin(); jt!=mask.end(); ++jt)
+					if( it!=jt ) {
+						onlyByMe &= ~*jt;
+						isSubset |= (*it & *jt & goal) == (*it & goal);
+					}
+
+				update |= isSubset | !!onlyByMe;
+
+				if( isSubset )
+					mask.erase(it++);
+				else if( onlyByMe ) {
+					if( --k < 0 )
+						return false;
+					goal &= ~*it;
+					mask.erase(it++);
+				}
+				else
+					++it;
+			}
+
+			if( mask.size()<=k || goal==0 )
+				return true;
+		}
+
+		// exhaustive search
+		vector<LL> ms(mask.begin(), mask.end());
+		for(LL i=(1LL<<k)-1; i<(1LL<<ms.size()); i=next_combination(i))
+		{
+			LL gg = goal;
+			for(LL j=0; (1LL<<j)<=i; ++j)
+				if( i & (1<<j) )
+					gg &= ~ms[j];
+			if( gg == 0 )
+				return true;
+		}
+		return false;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {1,2,3,4,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,1,1,1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); vector <int> Arg2; int Arg3 = 1; int Arg4 = 2; verify_case(0, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_1() { int Arr0[] = {1,2,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,2,3}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; int Arg4 = 1; verify_case(1, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_2() { int Arr0[] = {0,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; int Arg4 = 0; verify_case(2, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_3() { int Arr0[] = {0,2,0,0,2,2,8,3,8,7}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {10,9,1,8,1,3,7,2,8,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {3,4,6}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 3; int Arg4 = 3; verify_case(3, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_4() { int Arr0[] = {1, 0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {5, 10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); vector <int> Arg2; int Arg3 = 1; int Arg4 = 5; verify_case(4, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { ByteLand().run_test(-1); }
+// END CUT HERE

ADDED   SRM/346-U/1A.cpp
Index: SRM/346-U/1A.cpp
==================================================================
--- SRM/346-U/1A.cpp
+++ SRM/346-U/1A.cpp
@@ -0,0 +1,108 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+LL gcd(LL a, LL b)
+{
+	while(a)
+		swap(a, b%=a);
+	return b;
+}
+
+LL lcm(LL a, LL b)
+{
+	return a/gcd(a,b)*b;
+}
+
+class CommonMultiples { public:
+	int countCommMult(vector <int> a, int lower, int upper) 
+	{
+		LL m = 1;
+		for(int i=0; i<a.size(); ++i)
+		{
+			m = lcm(m, a[i]);
+			if( m > upper )
+				return 0;
+		}
+		return upper/m - (lower-1)/m;
+	}
+};
+
+// 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(_, CommonMultiples().countCommMult(a, lower, upper));}
+int main(){
+
+CASE(0)
+	int a_[] = {1,2,3};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	int lower = 5; 
+	int upper = 15; 
+	int _ = 2; 
+END
+CASE(1)
+	int a_[] = {1,2,4,8,16,32,64};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	int lower = 128; 
+	int upper = 128; 
+	int _ = 1; 
+END
+CASE(2)
+	int a_[] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,49};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	int lower = 1; 
+	int upper = 2000000000; 
+	int _ = 0; 
+END
+CASE(3)
+	int a_[] = {1,1,1};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	int lower = 1; 
+	int upper = 2000000000; 
+	int _ = 2000000000; 
+END
+CASE(4)
+	int a_[] = {1};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	int lower = 1; 
+	int upper = 1; 
+	int _ = 1; 
+END
+CASE(5)
+	int a_[] = {2,4};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	int lower = 4; 
+	int upper = 8; 
+	int _ = 2; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/346-U/1B.cpp
Index: SRM/346-U/1B.cpp
==================================================================
--- SRM/346-U/1B.cpp
+++ SRM/346-U/1B.cpp
@@ -0,0 +1,144 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class HeightRound { public:
+	typedef pair<pair<int,int>,int> key_t;
+	map<key_t, int> memo;
+
+	int score( int F, int B, int I, const vector<int>& h )
+	{
+		if( I == h.size()-1 )
+			return max(h[I]-h[F], h[I]-h[B]);
+
+		key_t key(make_pair(F,B), I);
+		if( memo.count(key) )
+			return memo[key];
+
+		int s1 = max(h[I]-h[F], score(I, B, I+1, h));
+		int s2 = max(h[I]-h[B], score(F, I, I+1, h));
+		return memo[key] = min(s1, s2);
+	}
+
+	void best( int F, int B, int I, const vector<int>& h, int acc, deque<int>& result )
+	{
+		if( I == h.size()-1 ) {
+			result = deque<int>(1, h[I]);
+			result.push_front(h[F]);
+			result.push_back(h[B]);
+			return;
+		}
+
+		int s1 = max(acc, max(h[I]-h[F], score(I, B, I+1, h)));
+		int s2 = max(acc, max(h[I]-h[B], score(F, I, I+1, h)));
+
+		if( s1<=s2 ) { // if tie, choose lexicographically earlier one
+			best( I, B, I+1, h, s1, result );
+			result.push_front( h[F] );
+		}
+		else {
+			best( F, I, I+1, h, s2, result );
+			result.push_back( h[B] );
+		}
+	}
+
+	vector <int> getBestRound(vector <int> h) 
+	{
+		// The answer must be of form:
+		//    h[0], h[1], (...ascending...), h[$-1], (...descending...).
+		// Thus, I begin from
+		//    F=1, B=0: [h[1], ..........,  h[0]]
+		// and fill each h[I=2,3,...] either to the left or right of the blank space,
+		// and choose the best one. To choose lex-first candidate, I use the "jo-seki"
+		// technique, which first computes only scores and then choose the instance
+		// lexicographically afterwards.
+
+		sort(h.begin(), h.end());
+
+		deque<int> result;
+		best( 1, 0, 2, h, 0, result );
+
+		rotate(result.begin(), result.end()-1, result.end());
+		return vector<int>(result.begin(), result.end());
+	}
+};
+
+// 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 <int>& Expected, const vector <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(_, HeightRound().getBestRound(heights));}
+int main(){
+
+CASE(0)
+	int heights_[] = {1,2,3,4};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int __[] = {1, 2, 4, 3 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int heights_[] = {1000,500,1};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int __[] = {1, 500, 1000 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int heights_[] = {1,3,4,5,7};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int __[] = {1, 3, 5, 7, 4 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	int heights_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int __[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	int heights_[] = {1,2,1};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int __[] = {1,1,2};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	int heights_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,1000};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int __[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,1000,49};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+	int heights_[] = {7, 43, 3, 6, 32, 2, 42, 23, 1, 30};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int __[] = {1, 2, 3, 6, 7, 30, 32, 42, 43, 23};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+
+}
+// END CUT HERE

ADDED   SRM/346-U/2C.cpp
Index: SRM/346-U/2C.cpp
==================================================================
--- SRM/346-U/2C.cpp
+++ SRM/346-U/2C.cpp
@@ -0,0 +1,158 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class FastPostman { public:
+	struct vert
+	{
+		int Ldone, Rdone;
+		bool nowAtL;
+
+		bool operator<( const vert& rhs ) const {
+			if( Ldone != rhs.Ldone ) return Ldone < rhs.Ldone;
+			if( Rdone != rhs.Rdone ) return Rdone < rhs.Rdone;
+			return nowAtL < rhs.nowAtL;
+		}
+		vert(int l, int r, bool b) : Ldone(l), Rdone(r), nowAtL(b) {}
+	};
+	typedef vert edge;
+	typedef pair<int,edge> cedge;
+
+	int minTime(vector <int> address, vector <int> maxTime, int initialPos) 
+	{
+		const int N = address.size();
+
+		vector< pair<int,int> > L, R;
+		R.push_back( make_pair(initialPos,0) );
+		for(int i=0; i<N; ++i)
+			if( initialPos <= address[i] )
+				R.push_back( make_pair(address[i], maxTime[i]) );
+			else
+				L.push_back( make_pair(address[i], maxTime[i]) );
+		stable_sort( R.begin(), R.end() );
+		stable_sort( L.rbegin(), L.rend() );
+
+		vert S(0, 1, false);
+		priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+		set<vert> V;
+		Q.push( cedge(0,S) );
+		while( !Q.empty() )
+		{
+			int  c = Q.top().first;
+			vert v = Q.top().second;
+			Q.pop();
+			if( V.count(v) )
+				continue;
+			if( v.Ldone == L.size() && v.Rdone == R.size() )
+				return c;
+			V.insert(v);
+
+			if( v.Ldone < L.size() ) {
+				vert u(v.Ldone+1, v.Rdone, true);
+				int cu = c + abs( (v.nowAtL ? L[v.Ldone-1] : R[v.Rdone-1]).first - L[v.Ldone].first );
+				if( !V.count(u) && cu <= L[v.Ldone].second )
+					Q.push( cedge(cu,u) );
+			}
+			if( v.Rdone < R.size() ) {
+				vert u(v.Ldone, v.Rdone+1, false);
+				int cu = c + abs( (v.nowAtL ? L[v.Ldone-1] : R[v.Rdone-1]).first - R[v.Rdone].first );
+				if( !V.count(u) && cu <= R[v.Rdone].second )
+					Q.push( cedge(cu,u) );
+			}
+		}
+		return -1;
+	}
+};
+
+// 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(_, FastPostman().minTime(address, maxTime, initialPos));}
+int main(){
+
+CASE(0)
+	int address_[] = {1,3,5,7};
+	  vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	int maxTime_[] = {9,2,5,100};
+	  vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_)); 
+	int initialPos = 4; 
+	int _ = 13; 
+END
+CASE(1)
+	int address_[] = {1,5};
+	  vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	int maxTime_[] = {6,2};
+	  vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_)); 
+	int initialPos = 3; 
+	int _ = 6; 
+END
+CASE(2)
+	int address_[] = {1000000};
+	  vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	int maxTime_[] = {45634};
+	  vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_)); 
+	int initialPos = 876; 
+	int _ = -1; 
+END
+CASE(3)
+	int address_[] = {1,7,10,4};
+	  vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	int maxTime_[] = {15,6,28,39};
+	  vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_)); 
+	int initialPos = 2; 
+	int _ = 20; 
+END
+CASE(4)
+	int address_[] = {1000000,1000000,1000000,1000000};
+	  vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	int maxTime_[] = {563,23452,32426,1};
+	  vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_)); 
+	int initialPos = 1000000; 
+	int _ = 0; 
+END
+CASE(5)
+	int address_[] = {1};
+	  vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	int maxTime_[] = {2};
+	  vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_)); 
+	int initialPos = {3}; 
+	int _ = 2; 
+END
+CASE(6)
+	int address_[] = {0, 1000000};
+	  vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	int maxTime_[] = {500000, 1500000};
+	  vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_)); 
+	int initialPos = 500000; 
+	int _ = 1500000; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/347-U/1A.cpp
Index: SRM/347-U/1A.cpp
==================================================================
--- SRM/347-U/1A.cpp
+++ SRM/347-U/1A.cpp
@@ -0,0 +1,194 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Aircraft { public:
+	double f(const double p[], const double v[], double t)
+	{
+		return sqrt( (p[0]+t*v[0])*(p[0]+t*v[0]) + (p[1]+t*v[1])*(p[1]+t*v[1]) + (p[2]+t*v[2])*(p[2]+t*v[2]) );
+	}
+	string nearMiss(vector <int> p1, vector <int> v1, vector <int> p2, vector <int> v2, int R) 
+	{
+		const double p[] = {p1[0]-p2[0], p1[1]-p2[1], p1[2]-p2[2]};
+		const double v[] = {v1[0]-v2[0], v1[1]-v2[1], v1[2]-v2[2]};
+
+		double x = 0.0;
+		double w = 1e+10;
+		for(int k=0; k<1000000; ++k)
+		{
+			double y = 2*x/3 + w/3;
+			double z = x/3 + 2*w/3;
+			double fx = f(p,v,x);
+			double fy = f(p,v,y);
+			double fz = f(p,v,z);
+			double fw = f(p,v,w);
+			if( fx < fy )
+				w = y;
+			else if( fz > fw )
+				x = z;
+			else if( fy < fz )
+				w = z;
+			else
+				x = y;
+		}
+
+		return f(p,v,x)-0.000001<=R ? "YES" : "NO";
+	}
+};
+
+// 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(_, Aircraft().nearMiss(p1, v1, p2, v2, R));}
+int main(){
+
+CASE(0)
+	int p1_[] = {15,50,5};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {25,1,0};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {161,102,9};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {-10,-10,-1};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 10; 
+	string _ = "YES"; 
+END
+CASE(1)
+	int p1_[] = {0,0,0};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {2,2,0};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {9,0,5};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {-2,2,0};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 5; 
+	string _ = "YES"; 
+END
+CASE(2)
+	int p1_[] = {0,0,0};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {-2,2,0};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {9,0,5};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {2,2,0};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 5; 
+	string _ = "NO"; 
+END
+CASE(3)
+	int p1_[] = {-2838,-7940,-2936};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {1,1,-2};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {532,3850,9590};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {1,0,-3};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 3410; 
+	string _ = "YES"; 
+END
+CASE(4)
+	int p1_[] = {-8509,9560,345};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {-89,-33,62};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {-5185,-1417,2846};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {-58,24,26};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 8344; 
+	string _ = "YES"; 
+END
+CASE(5)
+	int p1_[] = {-7163,-371,-2459};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {-59,-41,-14};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {-2398,-426,-5487};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {-43,27,67};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 5410; 
+	string _ = "NO"; 
+END
+CASE(6)
+	int p1_[] = {1774,-4491,7810};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {-12,19,-24};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {2322,3793,9897};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {-12,19,-24};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 10000; 
+	string _ = "YES"; 
+END
+CASE(7)
+	int p1_[] = {3731,8537,5661};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {-70,71,32};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {8701,-1886,-5115};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {28,-13,7};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 9766; 
+	string _ = "NO"; 
+END
+CASE(8)
+	int p1_[] = {0,0,0};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {0,0,0};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {1,0,0};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {0,0,0};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 1; 
+	string _ = "YES"; 
+END
+CASE(9)
+	int p1_[] = {0,0,0};
+	  vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_)); 
+	int v1_[] = {0,0,0};
+	  vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_)); 
+	int p2_[] = {2,0,0};
+	  vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_)); 
+	int v2_[] = {0,0,0};
+	  vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_)); 
+	int R = 1; 
+	string _ = "NO"; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/347-U/1B.cpp
Index: SRM/347-U/1B.cpp
==================================================================
--- SRM/347-U/1B.cpp
+++ SRM/347-U/1B.cpp
@@ -0,0 +1,105 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class FlightScheduler { public:
+	double f(double n, int distance, int K, int emptyMass, int takeoffFuel)
+	{
+		return n * (exp(distance/n / K) * emptyMass - emptyMass + takeoffFuel);
+	}
+	double minimizeFuel(int distance, int K, int emptyMass, int takeoffFuel) 
+	{
+		LL x = 1;
+		LL w = (1LL<<60);
+		while( w-x > 10 )
+		{
+			LL y = 2*x/3 + w/3;
+			LL z = x/3 + 2*w/3;
+			double fx = f(x, distance, K, emptyMass, takeoffFuel);
+			double fy = f(y, distance, K, emptyMass, takeoffFuel);
+			double fz = f(z, distance, K, emptyMass, takeoffFuel);
+			double fw = f(w, distance, K, emptyMass, takeoffFuel);
+			if( fx < fy )      w = y;
+			else if( fz > fw ) x = z;
+			else if( fy < fz ) w = z;
+			else               x = y;
+		}
+
+		double fuMin = 1e+300;
+		for(LL n=x; n<=w; ++n)
+			fuMin = min(fuMin, f(n, distance, K, emptyMass, takeoffFuel));
+		return fuMin;
+	}
+};
+
+// 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) {
+ double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 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(_, FlightScheduler().minimizeFuel(distance, K, emptyMass, takeoffFuel));}
+int main(){
+
+CASE(0)
+	int distance = 40000; 
+	int K = 100000; 
+	int emptyMass = 150000; 
+	int takeoffFuel = 5000; 
+	double _ = 76420.82744805096; 
+END
+CASE(1)
+	int distance = 40000; 
+	int K = 55000; 
+	int emptyMass = 150000; 
+	int takeoffFuel = 5000; 
+	double _ = 138450.61724934017; 
+END
+CASE(2)
+	int distance = 1000; 
+	int K = 500; 
+	int emptyMass = 1000; 
+	int takeoffFuel = 50; 
+	double _ = 2664.9853821314487; 
+END
+CASE(3)
+	int distance = 10000; 
+	int K = 100; 
+	int emptyMass = 200; 
+	int takeoffFuel = 5; 
+	double _ = 24635.869665316768; 
+END
+CASE(4)
+	int distance = 140000; 
+	int K = 4; 
+	int emptyMass = 10000; 
+	int takeoffFuel = 10; 
+	double _ = 3.6576871282155204E8; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/347-U/2C.cpp
Index: SRM/347-U/2C.cpp
==================================================================
--- SRM/347-U/2C.cpp
+++ SRM/347-U/2C.cpp
@@ -0,0 +1,172 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int INF = 0x3fffffff;
+
+class TaxiManager { public:
+	int schedule(vector <string> roads, vector <string> customers) 
+	{
+		const int V = roads.size();
+		vector< vector<int> > d(V, vector<int>(V));
+		for(int i=0; i<V; ++i)
+			for(int j=0; j<V; ++j)
+				if( i != j )
+					d[i][j] = (roads[i][j]=='0' ? INF : roads[i][j]-'0');
+		for(int k=0; k<V; ++k)
+			for(int i=0; i<V; ++i)
+				for(int j=0; j<V; ++j)
+					d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
+
+		const int M = customers.size();
+		vector< pair<int,int> > c;
+		for(int i=0; i<M; ++i)
+		{
+			int f, t;
+			stringstream(customers[i]) >> f >> t;
+			c.push_back( make_pair(f,t) );
+		}
+
+		int best = INF;
+		for(int mask=0; mask<(1<<M); ++mask)
+			best = min(best, max(tsp(d,c,mask), tsp(d,c,((1<<M)-1)&~mask)));
+		return best;
+	}
+
+	map<pair<int,int>, int> memo;
+	int tsp(const vector< vector<int> >& d, const vector< pair<int,int> >& c, int mask, int cur=0)
+	{
+		if( mask == 0 )
+			return d[cur][0];
+
+		pair<int,int> key(mask, cur);
+		if( memo.count(key) ) return memo[key];
+
+		int best = INF;
+		for(int next=0; (1<<next)<=mask; ++next)
+			if( (1<<next) & mask )
+				best = min(best,
+					d[cur][c[next].first] + d[c[next].first][c[next].second] + tsp(d,c,mask&~(1<<next),c[next].second));
+		return memo[key] = best;
+	}
+};
+
+// 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(_, TaxiManager().schedule(roads, customers));}
+int main(){
+
+CASE(0)
+	string roads_[] = {"020200"
+,"202020"
+,"020002"
+,"200020"
+,"020202"
+,"002020"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	string customers_[] = {"5 3","2 4","1 5","3 2"};
+	  vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_)); 
+	int _ = 16; 
+END
+CASE(1)
+	string roads_[] = 
+{"00020251090265906661"
+,"00763002550100090081"
+,"06003699000080062771"
+,"00000710460400035310"
+,"50000039119198350060"
+,"66060004050810046028"
+,"02333108565000200880"
+,"40212560000209205231"
+,"02601150098329905062"
+,"00210383709951005203"
+,"10111087340780827070"
+,"05065800003095040140"
+,"15604020082000100090"
+,"83430030070580600750"
+,"10588355007006001150"
+,"14400080790005400536"
+,"23400990400933060004"
+,"11053016300602000090"
+,"90040920084059282502"
+,"61300007077904050900"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	string customers_[] = {"0 19","4 16","15 16","4 18","2 7","9 15","11 6","7 13","19 13","12 19","14 12","16 1"};
+	  vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_)); 
+	int _ = 33; 
+END
+CASE(2)
+	string roads_[] = 
+{"095222800320504"
+,"107600288090501"
+,"760973530769345"
+,"963093337510830"
+,"338404069255826"
+,"291700050155264"
+,"002783031709004"
+,"404730701707712"
+,"068870030090995"
+,"320025180036103"
+,"468695042801904"
+,"233626561000105"
+,"070014432197086"
+,"887301000143802"
+,"230852749990330"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	string customers_[] = {"3 6","0 4","2 7","9 7","13 9","1 6","7 13","14 2","8 7","10 1","11 13","7 12"};
+	  vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_)); 
+	int _ = 28; 
+END
+CASE(3)
+	string roads_[] = {"00401","50990","00062","08008","03000"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	string customers_[] = {"2 4"};
+	  vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_)); 
+	int _ = 14; 
+END
+/*
+CASE(4)
+	string roads_[] = ;
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	string customers_[] = ;
+	  vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_)); 
+	int _ = ; 
+END
+CASE(5)
+	string roads_[] = ;
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	string customers_[] = ;
+	  vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/348-U/1A.cpp
Index: SRM/348-U/1A.cpp
==================================================================
--- SRM/348-U/1A.cpp
+++ SRM/348-U/1A.cpp
@@ -0,0 +1,94 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class LostParentheses { public:
+	int minResult(string e) 
+	{
+		int sum = 0;
+		bool prevOpPlus = true;
+		bool minusFound = false;
+		for(int p=0,i=0; i<=e.size(); ++i)
+			if( i==e.size() || e[i] == '-' )
+			{
+				stringstream ss;
+				ss << e.substr(p, i-p);
+				int num;
+				ss >> num;
+
+				sum += (prevOpPlus ? +num : -num);
+				p = i+1;
+				minusFound = true;
+				prevOpPlus = false;
+			}
+			else if( e[i] == '+' )
+			{
+				stringstream ss;
+				ss << e.substr(p, i-p);
+				int num;
+				ss >> num;
+
+				sum += (prevOpPlus ? +num : -num);
+				p = i+1;
+				prevOpPlus = !minusFound;
+			}
+		return sum;
+	}
+};
+
+// 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(_, LostParentheses().minResult(e));}
+int main(){
+
+CASE(0)
+	string e = "55-50+40"; 
+	int _ = -35; 
+END
+CASE(1)
+	string e = "10+20+30+40"; 
+	int _ = 100; 
+END
+CASE(2)
+	string e = "00009-00009"; 
+	int _ = 0; 
+END
+CASE(3)
+	string e = "1"; 
+	int _ = 1; 
+END
+CASE(4)
+	string e = "1-2+3"; 
+	int _ = -4; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/348-U/1B-U.cpp
Index: SRM/348-U/1B-U.cpp
==================================================================
--- SRM/348-U/1B-U.cpp
+++ SRM/348-U/1B-U.cpp
@@ -0,0 +1,130 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename To, typename From>
+	To lexical_cast( const From& f )
+	{
+		stringstream ss;
+		ss << f;
+		To t;
+		ss >> t;
+		return t;
+	}
+
+
+class RailwayTickets { public:
+	int minRejects(vector <string> travel, int seats) 
+	{
+		typedef pair<bool,int> event; // [true,A  --- false,B)
+		vector<event> evs;
+
+		for(int i=0; i<travel.size(); ++i)
+		{
+			stringstream ss(travel[i]);
+			for(string s; ss>>s; )
+			{
+				int k = s.find('-');
+				int A = lexical_cast<int>( s.substr(0, k) );
+				int B = lexical_cast<int>( s.substr(k+1) );
+				evs.push_back( event(true,A) );
+				evs.push_back( event(false,B) );
+			}
+		}
+
+		sort( evs.begin(), evs.end() );
+
+		vector< vector<int> > minDeny(evs.size()+1, vector<int>(seats+1));
+		for(int ti=evs.size()-1; ti>=0; --ti)
+			for(int si=0; si<=seats; ++si)
+				if( evs[ti].first )
+				{
+					if( si==0 )
+						minDeny[ti][si] = minDeny[ti+1][si]+1;
+					else
+						minDeny[ti][si] = min( minDeny[ti+1][si]+1, minDeny[ti+1][si-1] );
+				}
+				else
+				{
+					minDeny[ti][si] = minDeny[ti+1][si+1];
+				}
+		return minDeny[0][seats];
+	}
+};
+
+// 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(_, RailwayTickets().minRejects(travel, seats));}
+int main(){
+
+CASE(0)
+	string travel_[] = {"1-3 3-5",
+ "2-4 4-6",
+ "1-2 2-3 3-4 4-5"};
+	  vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int seats = 2; 
+	int _ = 2; 
+END
+CASE(1)
+	string travel_[] = {"1-10000","2-10000","1-9999","2-9999","5000-5001"};
+	  vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int seats = 3; 
+	int _ = 2; 
+END
+CASE(2)
+	string travel_[] = {"1-2 2-5 2-8 234-236 56-878 6-34",
+ "234-776 3242-8000 999-1000 3-14",
+ "121-122 435-3455 123-987 77-999"};
+	  vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int seats = 1000; 
+	int _ = 0; 
+END
+CASE(3)
+	string travel_[] = {"1-2 2-3 3-4 4-5 5-6 6-7 1-3 2-7 1-2 1-4"};
+	  vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int seats = 1; 
+	int _ = 4; 
+END
+CASE(4)
+	string travel_[] = {"1-2","1-2"};
+	  vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int seats = 1; 
+	int _ = 1; 
+END
+CASE(5)
+	string travel_[] = {"1-2"};
+	  vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_)); 
+	int seats = 1; 
+	int _ = 0; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/348-U/2C.cpp
Index: SRM/348-U/2C.cpp
==================================================================
--- SRM/348-U/2C.cpp
+++ SRM/348-U/2C.cpp
@@ -0,0 +1,100 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class IncreasingSubsequences { public:
+	long long count(vector <int> a) 
+	{
+		a.insert(a.begin(), -1);
+
+		int N = a.size();
+
+		vector< vector<int> > next(N);
+		for(int i=0; i<N; ++i) {
+			int L = a[i]+1;
+			int R = INT_MAX;
+			for(int j=i+1; j<N; ++j)
+				if( L<=a[j] && a[j]<=R ) {
+					next[i].push_back(j);
+					R = a[j];
+				}
+		}
+
+		vector<LL> num(N);
+		for(int i=N-1; i>=0; --i) {
+			if( next[i].size() == 0 )
+				num[i] = 1;
+			else
+				for(int j=0; j<next[i].size(); ++j)
+					num[i] += num[next[i][j]];
+		}
+		return num[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 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(_, IncreasingSubsequences().count(a));}
+int main(){
+
+CASE(0)
+	int a_[] = {1,3,2,6,4,5};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	long long _ = 4LL; 
+END
+CASE(1)
+	int a_[] = {1000000000,100000000,10000000,1000000,100000,10000,1000,100,10,1};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	long long _ = 10LL; 
+END
+CASE(2)
+	int a_[] = {1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	long long _ = 1LL; 
+END
+CASE(3)
+	int a_[] = {564,234,34,4365,424,2234,306,21,934,592,195,2395,2396,29345,13295423,23945,2};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	long long _ = 41LL; 
+END
+CASE(4)
+	int a_[] = {1};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	long long _ = 1LL; 
+END
+CASE(5)
+	int a_[] = {5,4,3,2,1};
+	  vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_)); 
+	long long _ = 5LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/349-U/1A.cpp
Index: SRM/349-U/1A.cpp
==================================================================
--- SRM/349-U/1A.cpp
+++ SRM/349-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 <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class RadarFinder { public:
+	int possibleLocations(int x1, int y1, int r1, int x2, int y2, int r2) 
+	{
+		if( x1==x2 && y1==y2 )
+			return r1==r2 ? -1 : 0;
+		LL rr = LL(x1-x2)*(x1-x2) + LL(y1-y2)*(y1-y2);
+		LL p12 = LL(r1+r2)*(r1+r2);
+		LL m12 = LL(r1-r2)*(r1-r2);
+		if( rr > p12 )
+			return 0;
+		else if( rr == p12 )
+			return 1;
+		else
+			if( rr < m12 )
+				return 0;
+			else if( rr == m12 )
+				return 1;
+			else
+				return 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(_, RadarFinder().possibleLocations(x1, y1, r1, x2, y2, r2));}
+int main(){
+
+CASE(0)
+	int x1 = 0; 
+	int y1 = 0; 
+	int r1 = 13; 
+	int x2 = 40; 
+	int y2 = 0; 
+	int r2 = 37; 
+	int _ = 2; 
+END
+CASE(1)
+	int x1 = 0; 
+	int y1 = 0; 
+	int r1 = 3; 
+	int x2 = 0; 
+	int y2 = 7; 
+	int r2 = 4; 
+	int _ = 1; 
+END
+CASE(2)
+	int x1 = 0; 
+	int y1 = 0; 
+	int r1 = 5; 
+	int x2 = 10; 
+	int y2 = 10; 
+	int r2 = 3; 
+	int _ = 0; 
+END
+CASE(3)
+	int x1 = 0; 
+	int y1 = 0; 
+	int r1 = 1; 
+	int x2 = 0; 
+	int y2 = 0; 
+	int r2 = 1; 
+	int _ = -1; 
+END
+CASE(4)
+	int x1 = 1; 
+	int y1 = 1; 
+	int r1 = 1; 
+	int x2 = 1; 
+	int y2 = 1; 
+	int r2 = 2; 
+	int _ = 0; 
+END
+CASE(5)
+	int x1 = -100000000; 
+	int y1 = -100000000; 
+	int r1 = 141421357; 
+	int x2 = 100000000; 
+	int y2 = 100000000; 
+	int r2 = 141421357; 
+	int _ = 2; 
+END
+CASE(6)
+	int x1 = 0;
+	int y1 = 0;
+	int r1 = 5;
+	int x2 = 1; 
+	int y2 = 0; 
+	int r2 = 4; 
+	int _ = 1; 
+END
+CASE(7)
+	int x1 = -1000000000;
+	int y1 = -1000000000;
+	int r1 =  1000000000;
+	int x2 =  -999999999; 
+	int y2 =  1000000000; 
+	int r2 =  1000000000; 
+	int _ = 0;
+END
+
+}
+// END CUT HERE

ADDED   SRM/349-U/1B.cpp
Index: SRM/349-U/1B.cpp
==================================================================
--- SRM/349-U/1B.cpp
+++ SRM/349-U/1B.cpp
@@ -0,0 +1,88 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class DiceGames { public:
+	long long countFormations(vector <int> sides) 
+	{
+		sort(sides.begin(), sides.end());
+
+		vector<LL> dp(sides.back(), 0);
+		dp[0] = 1;
+		for(int i=0; i<sides.size(); ++i)
+			partial_sum(dp.begin(), dp.begin()+sides[i], dp.begin());
+		return accumulate(dp.begin(), dp.end(), 0LL);
+	}
+};
+
+// 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(_, DiceGames().countFormations(sides));}
+int main(){
+
+CASE(0)
+	int sides_[] = {4};
+	  vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_)); 
+	long long _ = 4LL; 
+END
+CASE(1)
+	int sides_[] = {2, 2};
+	  vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_)); 
+	long long _ = 3LL; 
+END
+CASE(2)
+	int sides_[] = {4, 4};
+	  vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_)); 
+	long long _ = 10LL; 
+END
+CASE(3)
+	int sides_[] = {3, 4};
+	  vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_)); 
+	long long _ = 9LL; 
+END
+CASE(4)
+	int sides_[] = {4, 5, 6};
+	  vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_)); 
+	long long _ = 48LL; 
+END
+CASE(5)
+	int sides_[] = {1};
+	  vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_)); 
+	long long _ = 1LL; 
+END
+CASE(6)
+	int sides_[] = {1,1,1,1,1,1,1,1,1,1};
+	  vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_)); 
+	long long _ = 1LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/349-U/1C-U.cpp
Index: SRM/349-U/1C-U.cpp
==================================================================
--- SRM/349-U/1C-U.cpp
+++ SRM/349-U/1C-U.cpp
@@ -0,0 +1,147 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class LastMarble { public:
+	typedef pair<int,int>  rb;
+	typedef map<rb,double> state;
+
+	double winningChance(int red, int blue, int removed) 
+	{
+		state s;
+		addNextStates( red, blue, 1.0, removed, s );
+		return winChance(s);
+	}
+
+	double winChance( state& s )
+	{
+		if( s.empty() )
+			return 1.0; // any value is ok because it will be multiplied by 0.0
+
+		int r_plus_b = s.begin()->first.first + s.begin()->first.second;
+
+		double lc = 1.0;
+		for(int take=1; take<=min(3,r_plus_b); ++take)
+		{
+			state ns;
+			for(state::iterator it=s.begin(); it!=s.end(); ++it)
+				addNextStates(it->first.first, it->first.second, it->second, take, ns);
+
+			double nowLoseChance = 0.0;
+			for(state::iterator it=ns.begin(); it!=ns.end(); )
+				if( it->first.first == 0 ) {
+					nowLoseChance += it->second;
+					ns.erase( it++ );
+				} else {
+					++it;
+				}
+	
+			double continueChance = 1.0 - nowLoseChance;
+			for(state::iterator it=ns.begin(); it!=ns.end(); ++it)
+				it->second /= continueChance;
+			double loseChance = nowLoseChance + winChance(ns)*continueChance;
+			lc = min(lc, loseChance);
+		}
+		return 1.0 - lc;
+	}
+
+	void addNextStates(int r, int b, double p, int take, state& m)
+	{
+		if( take == 0 ) {
+			m[rb(r,b)] += p;
+			return;
+		}
+
+		state tmp;
+		tmp[rb(r,b)] = p;
+
+		while( take --> 0 )
+		{
+			state tmp2;
+			state& tgt = (take ? tmp2 : m);
+			for(state::iterator it=tmp.begin(); it!=tmp.end(); ++it)
+			{
+				int r = it->first.first;
+				int b = it->first.second;
+				double p = it->second;
+				if( r>0 ) tgt[rb(r-1,b)] += p * r / (r+b);
+				if( b>0 ) tgt[rb(r,b-1)] += p * b / (r+b);
+			}
+			tmp.swap(tmp2);
+		}
+	}
+};
+
+// 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) {
+ double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 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(_, LastMarble().winningChance(red, blue, removed));}
+int main(){
+
+CASE(0)
+	int red = 1; 
+	int blue = 1; 
+	int removed = 0; 
+	double _ = 0.5; 
+END
+CASE(1)
+	int red = 1; 
+	int blue = 2; 
+	int removed = 0; 
+	double _ = 0.3333333333333333; 
+END
+CASE(2)
+	int red = 2; 
+	int blue = 1; 
+	int removed = 0; 
+	double _ = 0.6666666666666666; 
+END
+CASE(3)
+	int red = 2; 
+	int blue = 2; 
+	int removed = 1; 
+	double _ = 0.5; 
+END
+/*
+CASE(4)
+	int red = ; 
+	int blue = ; 
+	int removed = ; 
+	double _ = ; 
+END
+CASE(5)
+	int red = ; 
+	int blue = ; 
+	int removed = ; 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/350-U/1A.cpp
Index: SRM/350-U/1A.cpp
==================================================================
--- SRM/350-U/1A.cpp
+++ SRM/350-U/1A.cpp
@@ -0,0 +1,99 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class SumsOfPerfectPowers { public:
+	int howMany(int lowerBound, int upperBound) 
+	{
+		set<LL> sq;
+		sq.insert(0);
+		sq.insert(1);
+		for(LL n=2; n*n<=upperBound; ++n)
+			for(LL nk=n*n; nk<=upperBound; nk*=n)
+				sq.insert(nk);
+		vector<LL> sqv( sq.begin(), sq.end() );
+
+		vector<LL> pp;
+		for(vector<LL>::iterator it=sqv.begin(); it!=sqv.end(); ++it)
+			for(vector<LL>::iterator jt=it; jt!=sqv.end() && *it+*jt<=upperBound; ++jt)
+				pp.push_back( *it + *jt );
+		sort( pp.begin(), pp.end() );
+		pp.erase( unique(pp.begin(),pp.end()), pp.end() );
+
+		vector<LL>::iterator s = lower_bound( pp.begin(), pp.end(), lowerBound );
+		vector<LL>::iterator e = upper_bound( pp.begin(), pp.end(), upperBound );
+		return distance(s, e);
+	}
+};
+
+// 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(_, SumsOfPerfectPowers().howMany(lowerBound, upperBound));}
+int main(){
+
+CASE(0)
+	int lowerBound = 0; 
+	int upperBound = 1; 
+	int _ = 2; 
+END
+CASE(1)
+	int lowerBound = 5; 
+	int upperBound = 6; 
+	int _ = 1; 
+END
+CASE(2)
+	int lowerBound = 25; 
+	int upperBound = 30; 
+	int _ = 5; 
+END
+CASE(3)
+	int lowerBound = 103; 
+	int upperBound = 103; 
+	int _ = 0; 
+END
+CASE(4)
+	int lowerBound = 1; 
+	int upperBound = 100000; 
+	int _ = 33604; 
+END
+CASE(5)
+	int lowerBound = 0; 
+	int upperBound = 0; 
+	int _ = 1; 
+END
+CASE(6)
+	int lowerBound = 0; 
+	int upperBound = 5000000; 
+	int _ = 1272868; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/350-U/1B.cpp
Index: SRM/350-U/1B.cpp
==================================================================
--- SRM/350-U/1B.cpp
+++ SRM/350-U/1B.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 <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+LL comb(LL n, LL k)
+{
+	k = min(k, n-k);
+
+	LL c = 1;
+	for(LL i=0; i<k; ++i)
+		c *= n-i, c /= i+1;
+	return c;
+}
+
+class StarsInGraphs { public:
+	int starnum(LL n, LL C)
+	{
+		if( n<=2 )
+			return -1;
+		LL sum = 0;
+		for(LL k=3; k<=n; ++k)
+		{
+			sum += comb(n,k);
+			if( sum > C )
+				return -1;
+		}
+		return (int) sum;
+	}
+
+	int starryPaths(vector <string> adjacencyMatrix, int C)
+	{
+		const int N = adjacencyMatrix.size();
+
+		vector<int> sn;
+		for(int i=0; i<N; ++i)
+			sn.push_back( starnum(count(adjacencyMatrix[i].begin(), adjacencyMatrix[i].end(), '1'), C) );
+
+		vector<int> v;
+		for(int i=0; i<N; ++i)
+			if( sn[i] > 0 )
+				v.push_back(i);
+
+		for(int step=0 ;; ++step)
+		{
+			if( v.empty() )
+				return step;
+			if( step >= 3*N )
+				break; // infinite
+
+			vector<int> v2;
+			for(int u=0; u<N; ++u)
+				for(int i=0; i<v.size(); ++i)
+					if( adjacencyMatrix[v[i]][u]=='1' && sn[v[i]] <= sn[u] )
+						{v2.push_back(u); break;}
+			v.swap(v2);
+		}
+
+		return -1;
+	}
+};
+
+// 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(_, StarsInGraphs().starryPaths(adjacencyMatrix, C));}
+int main(){
+
+CASE(0)
+	string adjacencyMatrix_[] = {"01110",
+ "10111",
+ "00000",
+ "00000",
+ "00000"};
+	  vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_)); 
+	int C = 1000; 
+	int _ = 2; 
+END
+CASE(1)
+	string adjacencyMatrix_[] = {"01011",
+ "00111",
+ "10011",
+ "00000",
+ "00000"};
+	  vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_)); 
+	int C = 1; 
+	int _ = -1; 
+END
+CASE(2)
+	string adjacencyMatrix_[] = {"0111",
+ "0000",
+ "0000",
+ "0000"};
+	  vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_)); 
+	int C = 1; 
+	int _ = 1; 
+END
+CASE(3)
+	string adjacencyMatrix_[] = {"01111",
+ "00000",
+ "00000",
+ "00000",
+ "00000"};
+	  vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_)); 
+	int C = 4; 
+	int _ = 0; 
+END
+CASE(4)
+	string adjacencyMatrix_[] = {"010001100",
+ "001001100",
+ "000101110",
+ "000010111",
+ "000001111",
+ "010000000",
+ "000110000",
+ "000100001",
+ "100001000"};
+	  vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_)); 
+	int C = 10; 
+	int _ = 5; 
+END
+CASE(5)
+	string adjacencyMatrix_[] = {"00","00"};
+	  vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_)); 
+	int C = 9999999; 
+	int _ = 0; 
+END
+CASE(6)
+	string adjacencyMatrix_[] = {"0111","1011","1101","1110"};
+	  vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_)); 
+	int C = 9999; 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/351-U/1A.cpp
Index: SRM/351-U/1A.cpp
==================================================================
--- SRM/351-U/1A.cpp
+++ SRM/351-U/1A.cpp
@@ -0,0 +1,109 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CoinsExchange { public:
+	int countExchanges(int G1, int S1, int B1, int G2, int S2, int B2) 
+	{
+		if( G1 < G2 ) {
+			int n = G2-G1;
+			return check2( S1, B1, S2+n*11, B2, n ); // 11*n silver needed
+		}
+		if( B1 < B2 ) {
+			int n = (B2-B1+8)/9;
+			return check2( G1, S1, G2, S2+n, n ); // n silver needed
+		}
+
+		// need silver
+		int n = 0;
+		while( S1<S2 && G1- 1>=G2 ) S1+=9, G1-= 1, n++;
+		while( S1<S2 && B1-11>=B2 ) S1+=1, B1-=11, n++;
+		return S1<S2 ? -1 : n;
+	}
+
+	int check2(int S1, int B1, int S2, int B2, int acc)
+	{
+		if( S1 < S2 ) {
+			int n = S2-S1;
+			return B2<=B1-n*11 ? n+acc : -1;
+		}
+		if( B1 < B2 ) {
+			int n = (B2-B1+8)/9;
+			return S2<=S1-n ? n+acc : -1;
+		}
+		return acc;
+	}
+};
+
+// 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(_, CoinsExchange().countExchanges(G1, S1, B1, G2, S2, B2));}
+int main(){
+
+CASE(0)
+	int G1 = 1; 
+	int S1 = 0; 
+	int B1 = 0; 
+	int G2 = 0; 
+	int S2 = 0; 
+	int B2 = 81; 
+	int _ = 10; 
+END
+CASE(1)
+	int G1 = 1; 
+	int S1 = 100; 
+	int B1 = 12; 
+	int G2 = 5; 
+	int S2 = 53; 
+	int B2 = 33; 
+	int _ = 7; 
+END
+CASE(2)
+	int G1 = 1; 
+	int S1 = 100; 
+	int B1 = 12; 
+	int G2 = 5; 
+	int S2 = 63; 
+	int B2 = 33; 
+	int _ = -1; 
+END
+CASE(3)
+	int G1 = 5; 
+	int S1 = 10; 
+	int B1 = 12; 
+	int G2 = 3; 
+	int S2 = 7; 
+	int B2 = 9; 
+	int _ = 0; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/351-U/1B.cpp
Index: SRM/351-U/1B.cpp
==================================================================
--- SRM/351-U/1B.cpp
+++ SRM/351-U/1B.cpp
@@ -0,0 +1,104 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename T>
+struct DP5
+{
+	int N1, N2, N3, N4, N5;
+	vector<T> data;
+	DP5(int N1, int N2, int N3, int N4, int N5, const T& t = T())
+		: N1(N1), N2(N2), N3(N3), N4(N4), N5(N5), data(N1*N2*N3*N4*N5, t) {}
+	T& operator()(int i1, int i2, int i3, int i4, int i5)
+		{ return data[ ((((i1*N2)+i2)*N3+i3)*N4+i4)*N5+i5 ]; }
+};
+
+
+class BoxesArrangement { public:
+	int maxUntouched(string boxes) 
+	{
+		int NA = count( boxes.begin(), boxes.end(), 'A' );
+		int NB = count( boxes.begin(), boxes.end(), 'B' );
+		int NC = count( boxes.begin(), boxes.end(), 'C' );
+
+		DP5<int> dp(NA+1, NB+1, NC+1, 3, 3);
+		for(int na=NA; na>=0; --na)
+		for(int nb=NB; nb>=0; --nb)
+		for(int nc=NC; nc>=0; --nc)
+		for(int c=0; c<3; ++c)
+		for(int l=0; l<3; ++l)
+		{
+			int n = na+nb+nc;
+			if( n == boxes.size() )
+				continue;
+			int m = -1;
+			for(int x=0; x<3; ++x) {
+				int nna = na+(x==0);
+				int nnb = nb+(x==1);
+				int nnc = nc+(x==2);
+				int nl  = (x==c ? l+1 : 1);
+				if( nna<=NA && nnb<=NB && nnc<=NC && nl<3 && dp(nna,nnb,nnc,x,nl)>=0 )
+					m = max(m, (boxes[n]=='A'+x) + dp(nna,nnb,nnc,x,nl));
+			}
+			dp(na,nb,nc,c,l) = m;
+		}
+
+		return dp(0,0,0,0,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(_, BoxesArrangement().maxUntouched(boxes));}
+int main(){
+
+CASE(0)
+	string boxes = "AAABBBCCC"; 
+	int _ = 6; 
+END
+CASE(1)
+	string boxes = "AAAAAAAACBB"; 
+	int _ = 7; 
+END
+CASE(2)
+	string boxes = "CCCCCB"; 
+	int _ = -1; 
+END
+CASE(3)
+	string boxes = "BAACAABAACAAA"; 
+	int _ = 5; 
+END
+CASE(4)
+	string boxes = "CBBABA"; 
+	int _ = 6; 
+END
+}
+// END CUT HERE

ADDED   SRM/352-U/1A.cpp
Index: SRM/352-U/1A.cpp
==================================================================
--- SRM/352-U/1A.cpp
+++ SRM/352-U/1A.cpp
@@ -0,0 +1,77 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class NumberofFiboCalls { public:
+	vector <int> fiboCallsMade(int n) 
+	{
+		vector<int> z(n+2), o(n+2);
+		z[0] = 1;
+		o[1] = 1;
+		for(int i=2; i<=n; ++i) {
+			z[i] = z[i-2] + z[i-1];
+			o[i] = o[i-2] + o[i-1];
+		}
+		vector<int> ans(2);
+		ans[0] = z[n];
+		ans[1] = o[n];
+		return ans;
+	}
+};
+
+// 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 <int>& Expected, const vector <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(_, NumberofFiboCalls().fiboCallsMade(n));}
+int main(){
+
+CASE(0)
+	int n = 0; 
+	int __[] = {1, 0 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int n = 3; 
+	int __[] = {1, 2 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int n = 6; 
+	int __[] = {5, 8 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	int n = 22; 
+	int __[] = {10946, 17711 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+
+}
+// END CUT HERE

ADDED   SRM/352-U/1B-U.cpp
Index: SRM/352-U/1B-U.cpp
==================================================================
--- SRM/352-U/1B-U.cpp
+++ SRM/352-U/1B-U.cpp
@@ -0,0 +1,122 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class FibonacciKnapsack { public:
+	long long maximalCost(vector <string> items, string C_) 
+	{
+		LL C;
+		stringstream(C_) >> C;
+
+		vector< pair<LL,LL> > wp;
+		for(int i=0; i<items.size(); ++i) {
+			LL W, P;
+			stringstream(items[i]) >> W >> P;
+			wp.push_back( make_pair(W,P) );
+		}
+		sort( wp.begin(), wp.end() );
+
+		LL lW = 0, lP = 0;
+		for(int i=0; i<wp.size(); ++i)
+			lW += wp[i].first, lP += wp[i].second;
+
+		best = 0;
+		rec( lW, lP, wp, wp.size()-1, C, 0 );
+		return best;
+	}
+
+	LL best;
+	void rec( LL lW, LL lP, vector< pair<LL,LL> >& wp, int i, LL w, LL cP )
+	{
+		if( lW <= w )
+			best = max(best, lP+cP);
+		if( lP+cP <= best )
+			return;
+
+		for(int k=i; k>=0 && wp[k].first==wp[i].first; --k)
+		{
+			lW -= wp[k].first;
+			lP -= wp[k].second;
+			if( w >= 0 )
+				rec(lW, lP, wp, k-1, w, cP);
+			w  -= wp[k].first;
+			cP += wp[k].second;
+		}
+	}
+};
+
+// 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(_, FibonacciKnapsack().maximalCost(items, C));}
+int main(){
+
+CASE(0)
+	string items_[] = {"5 555", "8 195", "13 651"};
+	  vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_)); 
+	string C = "15"; 
+	long long _ = 750LL; 
+END
+CASE(1)
+	string items_[] = {"5 555", "8 195", "13 751"};
+	  vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_)); 
+	string C = "15"; 
+	long long _ = 751LL; 
+END
+CASE(2)
+	string items_[] = {"55 1562", "5 814", "55 1962", "8 996", "2 716", "34 1792"};
+	  vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_)); 
+	string C = "94"; 
+	long long _ = 4568LL; 
+END
+CASE(3)
+	string items_[] = {"13 89"};
+	  vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_)); 
+	string C = "1"; 
+	long long _ = 0LL; 
+END
+CASE(4)
+	string items_[] = {"27777890035288 9419696870097445", 
+ "53316291173 6312623457097563", 
+ "165580141 8848283653257131"};
+	  vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_)); 
+	string C = "27777900000000"; 
+	long long _ = 15160907110354694LL; 
+END
+CASE(5)
+	string items_[] = {"89 90", "55 54", "55 54", "34 35", "34 35", "34 35", "34 35", "21 23", "21 23", "21 23", "21 23", "21 23", "21 23", "21 23", "21 23", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10"};
+	  vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_)); 
+	string C = "200"; 
+	long long _ = 241LL;
+END
+
+
+}
+// END CUT HERE

ADDED   SRM/387-U/2U.cpp
Index: SRM/387-U/2U.cpp
==================================================================
--- SRM/387-U/2U.cpp
+++ SRM/387-U/2U.cpp
@@ -0,0 +1,230 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int NV = 256;
+typedef int           flow;
+typedef int           cost;
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+typedef flow          flow_graph[NV][NV];
+typedef cost          cost_graph[NV][NV];
+static const flow FLOW_INF = 0x7FFFFFFF;
+static const cost COST_INF = 0x7FFFFFFF;
+
+// edges(bidi), capacity, cost(s.t. C[x][y]=-C[y][x]) per 1 flow, src, dst
+pair<cost,flow> mincostFlow(graph& G, flow_graph F, cost_graph C, vert S, vert D)
+{
+	int N = G.size();
+	cost total_cost = 0;
+	flow total_flow = 0;
+
+	vector<cost> h(N, 0); // potential
+	for(cost RF=FLOW_INF; RF>0; ) // residual flow
+	{
+		// Dijkstra -- find the min-cost path
+		vector<cost> d(N, COST_INF);  d[S] = 0;
+		vector<vert> prev(N, -1);
+
+		typedef pair<cost, pair<vert,vert> > cedge;
+		priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+		Q.push( cedge(0, make_pair(S,S)) );
+		while( !Q.empty() ) {
+			cedge e = Q.top(); Q.pop();
+			if( prev[e.second.second] >= 0 )
+				continue;
+			prev[e.second.second] = e.second.first;
+
+			vert u = e.second.second;
+			for(int i=0; i<G[u].size(); ++i) {
+				vert v = G[u][i];
+				cost r_cost = C[u][v] + h[u] - h[v];
+				if( F[u][v] > 0 && d[v] > d[u]+r_cost )
+					Q.push( cedge(d[v]=d[u]+r_cost, make_pair(u,v)) );
+			}
+		}
+
+		if( prev[D] < 0 )
+			break; // Finished
+
+		// As much as possible
+		flow f = RF;
+		for(vert u=D; u!=S; u=prev[u])
+			f = min(f, F[prev[u]][u]);
+		RF         -= f;
+		total_flow += f;
+
+		for(vert u=D; u!=S; u=prev[u])
+		{
+			total_cost    += f * C[prev[u]][u];
+			F[prev[u]][u] -= f;
+			F[u][prev[u]] += f;
+		}
+
+		// Update the potential
+		for(vert u=0; u<N; ++u)
+			h[u] += d[u];
+	}
+	return make_pair(total_cost, total_flow);
+}
+
+class MarblesRegroupingHard { public:
+	int minMoves(vector <string> boxes) 
+	{
+		const int NB = boxes.size();
+		vector< vector<int> > bb(NB);
+		for(int i=0; i<boxes.size(); ++i)
+		{
+			stringstream sin(boxes[i]);
+			for(int v; sin>>v; )
+				bb[i].push_back(v);
+		}
+		const int NC = bb[0].size();
+
+		graph G(NB+NC+3);
+		flow_graph F = {};
+		cost_graph C = {};
+		for(int i=0; i<NB; ++i) {
+			G[0].push_back(2+i);
+			G[2+i].push_back(0);
+			F[0][2+i] = 1;
+		}
+		for(int i=0; i<NC; ++i) {
+			G[2+NB+i].push_back(1);
+			G[1].push_back(2+NB+i);
+			F[2+NB+i][1] = 1;
+		}
+		{
+			G[2+NB+NC].push_back(1);
+			G[1].push_back(2+NB+NC);
+			F[2+NB+NC][1] = NB-NC;
+		}
+		for(int i=0; i<NB; ++i)
+		for(int j=0; j<NC; ++j) {
+			G[2+i].push_back(2+NB+j);
+			G[2+NB+j].push_back(2+i);
+			F[2+i][2+NB+j] = 1;
+			int c = 0;
+			for(int k=0; k<NB; ++k) if(k!=i)
+				c += bb[k][j];
+			C[2+i][2+NB+j] = c;
+			C[2+NB+j][2+i] = -c;
+		}
+		for(int i=0; i<NB; ++i) {
+			G[2+i].push_back(2+NB+NC);
+			G[2+NB+NC].push_back(2+i);
+			F[2+i][2+NB+NC] = 1;
+		}
+		pair<cost,flow> ff = mincostFlow(G, F, C, 0, 1);
+		return ff.first;
+	}
+};
+
+// 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(_, MarblesRegroupingHard().minMoves(boxes));}
+int main(){
+
+CASE(0)
+	string boxes_[] = {"0"};
+	  vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_)); 
+	int _ = 0; 
+END
+CASE(1)
+	string boxes_[] = {"77 97","8 0"};
+	  vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_)); 
+	int _ = 77; 
+END
+CASE(2)
+	string boxes_[] = {"6 97 7","73 45 0","67 45 63"};
+	  vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_)); 
+	int _ = 170; 
+END
+CASE(3)
+	string boxes_[] = {"97 94 0 99","1 72 46 45","0 10 47 75","0 92 76 20","2 25 98 22"};
+	  vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_)); 
+	int _ = 559; 
+END
+CASE(4)
+	string boxes_[] = {"38 0 0 45 77 61 0 0 8 87 65 53 0 2",
+ "0 97 79 37 70 0 69 35 95 11 75 96 77 29",
+ "39 32 0 24 63 22 91 71 0 63 92 59 12 0",
+ "34 0 0 71 88 13 60 56 0 22 29 89 81 53",
+ "69 95 65 0 94 98 84 37 0 87 16 0 58 18",
+ "82 0 36 88 0 54 82 40 6 0 34 44 80 2",
+ "33 58 7 95 83 87 0 0 79 35 0 51 22 84",
+ "7 0 30 57 33 4 0 26 44 55 67 31 88 42",
+ "62 58 62 93 91 0 1 0 44 23 95 0 55 57",
+ "35 8 22 26 76 0 78 54 0 46 42 0 0 64",
+ "93 54 58 0 89 89 0 0 57 0 98 3 24 0",
+ "9 0 0 23 82 18 0 46 0 0 94 84 19 18",
+ "78 12 6 45 0 80 16 69 59 76 35 0 66 0",
+ "0 68 77 13 15 0 52 72 0 0 18 65 23 0",
+ "0 0 73 53 0 95 91 44 27 96 85 0 99 85",
+ "93 29 4 89 27 44 27 17 21 6 0 8 3 91",
+ "0 46 73 94 60 59 15 50 18 75 74 88 46 93",
+ "0 0 0 94 93 26 21 83 54 62 0 89 59 77",
+ "32 98 0 44 34 38 56 20 0 61 29 94 52 57",
+ "52 60 0 22 0 5 38 0 50 98 12 75 0 81",
+ "23 0 41 18 36 87 49 32 62 43 22 74 0 97",
+ "0 0 30 79 16 73 61 0 75 51 64 13 45 0",
+ "11 0 14 2 0 1 2 16 84 37 95 45 48 33",
+ "10 0 0 35 0 85 28 76 99 74 76 32 52 8",
+ "60 0 96 0 95 26 59 13 0 0 44 42 97 48",
+ "34 7 77 25 91 85 35 78 32 99 7 29 18 15",
+ "61 50 43 22 42 63 64 50 9 94 42 22 21 33",
+ "58 0 41 10 16 0 27 67 83 27 14 37 98 47",
+ "37 60 60 76 71 2 84 32 27 39 82 84 0 94",
+ "15 98 69 82 36 66 0 97 62 39 0 65 62 67",
+ "0 41 0 43 0 0 94 0 0 58 0 0 27 33",
+ "53 90 71 91 85 0 32 86 40 60 11 0 99 28",
+ "79 62 0 0 79 0 14 62 87 76 35 0 70 0",
+ "0 40 73 48 0 63 0 0 63 5 30 18 47 51",
+ "75 6 58 69 33 57 66 0 12 0 46 0 65 10"};
+	  vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_)); 
+	int _ = 18618; 
+END
+/*
+CASE(5)
+	string boxes_[] = ;
+	  vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_)); 
+	int _ = ; 
+END
+CASE(6)
+	string boxes_[] = ;
+	  vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/394-U/2C.cpp
Index: SRM/394-U/2C.cpp
==================================================================
--- SRM/394-U/2C.cpp
+++ SRM/394-U/2C.cpp
@@ -0,0 +1,90 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ProperDivisors { public:
+	int analyzeInterval(int a, int b, int n) 
+	{
+		int c = 0;
+		for(int k=2; k+k<=a+b; ++k)
+			c += cd(a+b, k, n) - cd(a-1, k, n);
+		return c;
+	}
+
+	int cd(int x, int k, int n)
+	{
+		LL kn = 1;
+		for(int i=0; i<n; ++i)
+			if( (kn*=k) > x )
+				return x/k - (x>=k ? 1 : 0);
+		return x/k - x/kn - (x>=k ? 1 : 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(_, ProperDivisors().analyzeInterval(a, b, n));}
+int main(){
+
+CASE(0)
+	int a = 32; 
+	int b = 1; 
+	int n = 3; 
+	int _ = 5; 
+END
+CASE(1)
+	int a = 1; 
+	int b = 12; 
+	int n = 2; 
+	int _ = 8; 
+END
+CASE(2)
+	int a = 1000000; 
+	int b = 10000000; 
+	int n = 10; 
+	int _ = 146066338; 
+END
+/*
+CASE(3)
+	int a = ; 
+	int b = ; 
+	int n = ; 
+	int _ = ; 
+END
+CASE(4)
+	int a = ; 
+	int b = ; 
+	int n = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/396-U/2C.cpp
Index: SRM/396-U/2C.cpp
==================================================================
--- SRM/396-U/2C.cpp
+++ SRM/396-U/2C.cpp
@@ -0,0 +1,120 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class RemovingDigits { public:
+	string maxNumber(string number, string digits) 
+	{
+		vector<int> d(9);
+		for(int i=0; i<digits.size(); ++i)
+			d[digits[i]-'1'] ++;
+		vector<int> n(9);
+		for(int i=0; i<number.size(); ++i)
+			n[number[i]-'1'] ++;
+		return maximize(number, 0, n, d);
+	}
+
+	map<pair< int, vector<int> >, string> memo;
+
+	string maximize(const string& number, int s, vector<int>& n, vector<int>& d)
+	{
+		if( s == number.size() )
+			return "";
+
+		pair< int, vector<int> > key(s, d);
+		if( memo.count(key) )
+			return memo[key];
+
+		char ch = number[s]-'1';
+		string cand = "";
+
+		n[ch]--;
+		if( n[ch] >= d[ch] )
+		{
+			string c1 = number[s] + maximize(number, s+1, n, d);
+			cand = max(cand, c1);
+		}
+		if( d[ch] > 0 )
+		{
+			d[ch]--;
+			string c2 = maximize(number, s+1, n, d);
+			cand = max(cand, c2);
+			d[ch]++;
+		}
+		n[ch]++;
+		return memo[key] = cand;
+	}
+};
+
+// 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(_, RemovingDigits().maxNumber(number, digits));}
+int main(){
+
+CASE(0)
+	string number = "12345"; 
+	string digits = "513"; 
+	string _ = "24"; 
+END
+CASE(1)
+	string number = "112352"; 
+	string digits = "1123"; 
+	string _ = "52"; 
+END
+CASE(2)
+	string number = "123456654321"; 
+	string digits = "612534"; 
+	string _ = "654321"; 
+END
+CASE(3)
+	string number = "654321123456"; 
+	string digits = "612534"; 
+	string _ = "654321"; 
+END
+CASE(4)
+	string number = "2654982765982365"; 
+	string digits = "2345978"; 
+	string _ = "698265265"; 
+END
+/*
+CASE(5)
+	string number = ; 
+	string digits = ; 
+	string _ = ; 
+END
+CASE(6)
+	string number = ; 
+	string digits = ; 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/397/1A.cpp
Index: SRM/397/1A.cpp
==================================================================
--- SRM/397/1A.cpp
+++ SRM/397/1A.cpp
@@ -0,0 +1,68 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class SortingGame
+{
+public:
+	int fewestMoves(vector<int> board, int k) 
+	{
+		vector<int> sorted(board);
+		sort(sorted.begin(), sorted.end());
+
+		vector< vector<int> > Q;
+		set< vector<int> >    V;
+		Q.push_back(board), V.insert(board);
+		for(int N=0; !Q.empty(); ++N)
+		{
+			vector< vector<int> > Q2;
+			for(int i=0; i<Q.size(); ++i)
+			{
+				vector<int>& b = Q[i];
+				if( b == sorted )
+					return N;
+				for(int i=0; i+k<=b.size(); ++i)
+				{
+					reverse(b.begin()+i, b.begin()+i+k);
+					if( !V.count(b) )
+						Q2.push_back(b), V.insert(b);
+					reverse(b.begin()+i, b.begin()+i+k);
+				}
+			}
+			Q.swap(Q2);
+		}
+		return -1;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {1,2,3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 0; verify_case(0, Arg2, fewestMoves(Arg0, Arg1)); }
+	void test_case_1() { int Arr0[] = {3,2,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 1; verify_case(1, Arg2, fewestMoves(Arg0, Arg1)); }
+	void test_case_2() { int Arr0[] = {5,4,3,2,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 10; verify_case(2, Arg2, fewestMoves(Arg0, Arg1)); }
+	void test_case_3() { int Arr0[] = {3,2,4,1,5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = -1; verify_case(3, Arg2, fewestMoves(Arg0, Arg1)); }
+	void test_case_4() { int Arr0[] = {7,2,1,6,8,4,3,5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 7; verify_case(4, Arg2, fewestMoves(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	SortingGame().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/397/1B.cpp
Index: SRM/397/1B.cpp
==================================================================
--- SRM/397/1B.cpp
+++ SRM/397/1B.cpp
@@ -0,0 +1,90 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class SumOfPowers
+{
+public:
+	int value(int n, int k) 
+	{
+		//  2^m - 1^m = (1+1)^m - 1^m = mC1 1^(m-1) + ... + mCi 1^(m-i) + ... + mCm 1^0
+		//  3^m - 2^m = (2+1)^m - 1^m = mC1 2^(m-1) + ... + mCi 2^(m-i) + ... + mCm 2^0
+		//+ ...
+		//--------------------------------------------------------------------------------
+		//  (n+1)^m - 1  = mC1 \Sigma n^(m-1) + ... + mCi \Sigma n^(m-i) + ... + mCm \Sigma n^0
+
+		vector<LL> vals;
+		for(int m=1; m<=k+1; ++m)
+		{
+			LL x = SUB(POW(n+1, m), 1);
+			for(int i=2; i<=m; ++i)
+				x = SUB( x, MUL(C(m, i), vals[m-i]) );
+			x = DIV(x, m);
+			vals.push_back(x);
+		}
+		return (int)vals.back();
+	}
+	LL ADD(LL x, LL y) { return (x+y)%1000000007; }
+	LL SUB(LL x, LL y) { return (x-y+1000000007)%1000000007; }
+	LL MUL(LL x, LL y) { return (x*y)%1000000007; }
+	LL C(LL n, LL k) {
+		LL v = 1;
+		for(LL i=1; i<=k; ++i)
+			v = DIV(MUL(v, n-i+1), i);
+		return v;
+	}
+	LL POW(LL x, LL e) {
+		LL v = 1;
+		for(;e;x=MUL(x,x),e>>=1)
+			if(e&1)
+				v = MUL(v, x);
+		return v;
+	}
+	LL DIV(LL x, LL y) {
+		LL iy, _;
+		xgcd(y, 1000000007, &iy, &_);
+		return MUL(x, (iy+1000000007)%1000000007);
+	}
+	LL xgcd(LL a, LL b, LL* x, LL* y) { // ax+by=g
+		if(b) {
+			LL yy, g = xgcd(b,a%b,&yy,x);
+			*y = yy - a/b**x;
+			return g;
+		}
+		else {
+			*x=1, *y=0;
+			return a;
+		}
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 5; int Arg1 = 1; int Arg2 = 15; verify_case(0, Arg2, value(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 4; int Arg1 = 2; int Arg2 = 30; verify_case(1, Arg2, value(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 13; int Arg1 = 5; int Arg2 = 1002001; verify_case(2, Arg2, value(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 123456789; int Arg1 = 1; int Arg2 = 383478132; verify_case(3, Arg2, value(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	SumOfPowers().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/397/1C.cpp
Index: SRM/397/1C.cpp
==================================================================
--- SRM/397/1C.cpp
+++ SRM/397/1C.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+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;
+}
+
+static const int NV=100;
+int biMatch( graph& G, int L ) // [0,L):left, [L,?):right
+{
+	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 HouseProtection
+{
+public:
+	double safetyFactor(vector <int> bx, vector <int> by, vector <int> rx, vector <int> ry, int R) 
+	{
+		double r[50][50];
+		set<double> rs;
+		for(int i=0; i<bx.size(); ++i)
+		for(int j=0; j<rx.size(); ++j) {
+			r[i][j] = sqrt((double)(bx[i]-rx[j])*(bx[i]-rx[j]) + (by[i]-ry[j])*(by[i]-ry[j]))/2;
+			rs.insert( min<double>(r[i][j], R) );
+		}
+		rs.insert(R);
+
+		double result = 0;
+		for(set<double>::iterator it=rs.begin(); it!=rs.end(); ++it)
+		{
+			double curR = *it;
+			graph G(bx.size()+rx.size());
+			for(int i=0; i<bx.size(); ++i)
+			for(int j=0; j<rx.size(); ++j)
+				if( r[i][j] < curR ) {
+					G[i].push_back( bx.size()+j );
+				}
+			int Num = bx.size() + rx.size() - biMatch( G, bx.size() );
+			result = max(result, Num*curR*curR);
+		}
+		return result * M_PI;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = { 0, 4 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = { 0, 0 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = { 2, 1 }; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = { 2, -1 }; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); int Arg4 = 1; double Arg5 = 9.42477796076938; verify_case(0, Arg5, safetyFactor(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+	void test_case_1() { int Arr0[] = { 1 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = { 1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = { 1 }; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = { 1 }; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); int Arg4 = 5; double Arg5 = 78.53981633974483; verify_case(1, Arg5, safetyFactor(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+	void test_case_2() { int Arr0[] = { 0 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = { 0 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = { 100 }; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = { 0 }; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); int Arg4 = 51; double Arg5 = 15707.963267948966; verify_case(2, Arg5, safetyFactor(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+	void test_case_3() { int Arr0[] = { 23, 29, 29, 35 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = { 77, 79, 75, 77 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = { 26, 26, 32 }; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = { 78, 76, 76 }; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); int Arg4 = 3; double Arg5 = 113.09733552923255; verify_case(3, Arg5, safetyFactor(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	HouseProtection().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/398/1A.cpp
Index: SRM/398/1A.cpp
==================================================================
--- SRM/398/1A.cpp
+++ SRM/398/1A.cpp
@@ -0,0 +1,28 @@
+struct CountExpressions
+{
+	static int add(int x, int y) { return x+y; }
+	static int sub(int x, int y) { return x-y; }
+	static int mul(int x, int y) { return x*y; }
+
+	int calcExpressions(int x, int y, int val)
+	{
+		int num[][4] = {
+			{x,x,y,y},
+			{x,y,x,y},
+			{x,y,y,x},
+			{y,x,x,y},
+			{y,x,y,x},
+			{y,y,x,x},
+		};
+		int (*op[])(int,int) = { &add, &sub, &mul };
+
+		int cnt = 0;
+		for(int a=0; a<6; ++a)
+		for(int i=0; i<3; ++i)
+		for(int j=0; j<3; ++j)
+		for(int k=0; k<3; ++k)
+			if( val == op[k]( op[j]( op[i](num[a][0], num[a][1]), num[a][2] ), num[a][3] ) )
+				++cnt;
+		return cnt;
+	}
+};

ADDED   SRM/398/1B.cpp
Index: SRM/398/1B.cpp
==================================================================
--- SRM/398/1B.cpp
+++ SRM/398/1B.cpp
@@ -0,0 +1,62 @@
+#include <vector>
+#include <map>
+#include <cstring>
+using namespace std;
+
+
+long long dp[51][51][51][51]; // y,x,n,i
+
+struct CountPaths
+{
+	vector <int> difPaths(int r, int c, vector <int> fieldrow, vector <int> fieldcol)
+	{
+		int k = fieldrow.size();
+		map< pair<int,int>, int > f;
+		for(int i=0; i<fieldrow.size(); ++i)
+			f[make_pair(fieldrow[i],fieldcol[i])] = i;
+
+		memset(dp, 0, sizeof(dp));
+		if( f.count( make_pair(1,1) ) )
+			dp[1][1][1][ f[make_pair(1,1)]+1 ] = 1;
+		else
+			dp[1][1][0][0] = 1;
+
+		for(int y=1; y<=r; ++y)
+		for(int x=(y==1?2:1); x<=c; ++x)
+		{
+			if( f.count(make_pair(y,x)) ) {
+				int I = f[make_pair(y,x)];
+				for(int n=1; n<=k; ++n) {
+					int sum = 0;
+					for(int i=0; i<=I; ++i) {
+						if( y>=2 )
+							sum += dp[y-1][x][n-1][i];
+						if( x>=2 )
+							sum += dp[y][x-1][n-1][i];
+					}
+					dp[y][x][n][I+1] = sum % 1000007;
+				}
+			} else {
+				for(int n=0; n<=k; ++n) {
+					for(int i=0; i<=k; ++i) {
+						int sum = 0;
+						if( y>=2 )
+							sum += dp[y-1][x][n][i];
+						if( x>=2 )
+							sum += dp[y][x-1][n][i];
+						dp[y][x][n][i] = sum % 1000007;
+					}
+				}
+			}
+		}
+
+		vector<int> ans;
+		for(int n=0; n<=k; ++n) {
+			int sum = 0;
+			for(int i=0; i<=k; ++i)
+				sum += dp[r][c][n][i];
+			ans.push_back( sum % 1000007 );
+		}
+		return ans;
+	}
+};

ADDED   SRM/398/1C.cpp
Index: SRM/398/1C.cpp
==================================================================
--- SRM/398/1C.cpp
+++ SRM/398/1C.cpp
@@ -0,0 +1,103 @@
+#include <vector>
+#include <string>
+#include <cmath>
+#include <algorithm>
+using namespace std;
+
+vector<double> solve_linear_eq( int n, vector< vector<double> > M, const vector<double>& V )
+{
+	vector<double> A(V);
+	for(int i=0; i<n; ++i)
+	{
+		// pivot
+		if( M[i][i] == 0 )
+			for(int j=i+1; j<n; ++j)
+				if( M[j][i] != 0 )
+					{swap(M[i], M[j]); swap(A[i], A[j]); break;}
+		if( M[i][i] == 0 )
+			throw "no anser";
+
+		// M[i][i] <-- 1
+		double p = M[i][i];
+		for(int j=i; j<n; ++j)
+			M[i][j] /= p;
+		A[i] /= p;
+
+		// M[*][i] <-- 0
+		for(int j=0; j<n; ++j) if(j!=i)
+		{
+			double r = M[j][i];
+			for(int k=i; k<n; ++k)
+				M[j][k] -= M[i][k] * r;
+			A[j] -= A[i] * r;
+		}
+	}
+	return A;
+}
+
+//-------------------------------------------------------------
+// Check the given list can be a degree list of some graph
+//   O(n^2 log n)
+//
+// Verified by
+//   - SRM 398 Div1 LV3
+//
+//((
+// Havel-Hakimi
+//   If G[0], ..., G[n] (decreasing) is graphical,
+//   then G[1]-1, G[2]-1, ..., G[G[0]]-1, G[G[0]+1], .., G[n]
+//   is also graphical.
+//))
+//-------------------------------------------------------------
+
+bool isGraphical( vector<int> G )
+{
+	sort( G.begin(), G.end() );
+
+	vector<int>::iterator b = lower_bound( G.begin(), G.end(), 1 );
+	vector<int>::iterator e = G.end();
+
+	while( b < e )
+	{
+		int n = *(--e);
+		if( e-b < n )
+			return false;
+		for(vector<int>::iterator i=e-n; i!=e; ++i)
+			--*i;
+		inplace_merge( b, e-n, e );
+		b = lower_bound( G.begin(), G.end(), 1 );
+	}
+	return true;
+}
+
+struct MyFriends
+{
+	string calcFriends(vector <int> sumFriends, int k)
+	{
+		int n = sumFriends.size();
+
+		vector< vector<double> > M(n, vector<double>(n));
+		for(int i=0; i<n; ++i)
+			for(int j=0; j<n; ++j)
+				M[i][j] = (i==j || (i+k)%n==j ? 0 : 1);
+
+		// calc #friends of each kid
+		vector<double> V( sumFriends.begin(), sumFriends.end() );
+		vector<double> Ad = solve_linear_eq( n, M, V );
+		vector<int> A;
+		for(int i=0; i<n; ++i)
+			A.push_back( (int)floor(Ad[i]+0.5) );
+
+		// verify
+		for(int i=0; i<n; ++i)
+		{
+			int sum = 0;
+			for(int j=0; j<n; ++j)
+				sum += (i==j || (i+k)%n==j ? 0 : A[j]);
+			if( sum != sumFriends[i] )
+				return "IMPOSSIBLE";
+		}
+
+		return isGraphical(A) ? "POSSIBLE" : "IMPOSSIBLE";
+	}
+};

ADDED   SRM/399/1A.cpp
Index: SRM/399/1A.cpp
==================================================================
--- SRM/399/1A.cpp
+++ SRM/399/1A.cpp
@@ -0,0 +1,37 @@
+#include <iostream>
+#include <vector>
+#include <cmath>
+#include <set>
+#include <algorithm>
+using namespace std;
+
+
+struct AvoidingProduct
+{
+	vector<int> getTriple(vector<int> a, int n)
+	{
+		int best = 1000000000;
+		vector<int> ans(3);
+
+		set<int> as(a.begin(), a.end());
+		for(int x=1;; ++x) if( !as.count(x) ) {
+			for(int y=x;; ++y) if( !as.count(y) ) {
+				for(int z=y;; ++z) if( !as.count(z) ) {
+					int m = x*y*z;
+					if( abs(m-n) < best ) {
+						best = abs(m-n);
+						ans[0] = x;
+						ans[1] = y;
+						ans[2] = z;
+					}
+
+					if( x*y*z>n ) break;
+				}
+				if( x*y*y>n ) break;
+			}
+			if( x*x*x>n ) break;
+		}
+			
+		return ans;
+	}
+};

ADDED   SRM/399/1B.cpp
Index: SRM/399/1B.cpp
==================================================================
--- SRM/399/1B.cpp
+++ SRM/399/1B.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <string>
+#include <map>
+using namespace std;
+
+string err = "222222222222222222222222222222222222222222222222";
+
+void operator&=( string& x, const string& r )
+{
+	if( x.size() > r.size() )
+		x = r;
+	else if( x.size()==r.size() && x > r )
+		x = r;
+}
+
+struct BinarySum
+{
+	map<int, string> memo;
+
+	int rearrange(int a, int b, int c)
+	{
+		int an=0,bn=0,cn=0,n=0;
+		for(unsigned int i=1,t=1; i<=a; i<<=1,++t) {if(a&i) an++; n=max<int>(n,t);}
+		for(unsigned int i=1,t=1; i<=b; i<<=1,++t) {if(b&i) bn++; n=max<int>(n,t);}
+		for(unsigned int i=1,t=1; i<=c; i<<=1,++t) {if(c&i) cn++; n=max<int>(n,t);}
+		string ans = err;
+		ans &= mini( 0, cn-1, an-1, bn   ); // 1+0(+0)=01
+		ans &= mini( 0, cn-1, an,   bn-1 ); // 0+1(+0)=01
+		ans &= mini( 1, cn-1, an,   bn );   // 0+0(+1)=01
+		if( ans.find('2') != string::npos )
+			return -1;
+		ans = "1"+ans;
+		if( ans.size() > n )
+			return -1;
+		int v = 0;
+		for(int i=0; i<ans.size(); ++i)
+			v = (v<<1) | (ans[i] - '0');
+		return v;
+	}
+
+	string mini(int d, int cn, int an, int bn)
+	{
+		if( cn<0 || an<0 || bn<0 )
+			return err;
+
+		int key = (cn<<24)+(an<<16)+(bn<<8)+d;
+		if( memo.count(key) )
+			return memo[key];
+
+		if( d==0 && cn==0 && an==0 && bn==0 )
+			return "";
+
+		string ans = err;
+		if( d == 0 ) {
+			ans &= "1"+mini( 0, cn-1, an-1, bn ); // 1+0(+0)=01
+			ans &= "1"+mini( 0, cn-1, an, bn-1 ); // 0+1(+0)=01
+			ans &= "1"+mini( 1, cn-1, an, bn );   // 0+0(+1)=01
+		} else {
+			ans &= "0"+mini( 0, cn, an-1, bn-1 ); // 1+1(+0)=10
+			ans &= "0"+mini( 1, cn, an-1, bn );   // 1+0(+1)=10
+			ans &= "0"+mini( 1, cn, an, bn-1 );    // 0+1(+1)=10
+			ans &= "1"+mini( 1, cn-1, an-1, bn-1 ); // 1+1(+1)=11
+		}
+		return memo[key] = ans;
+	}
+};

ADDED   SRM/399/1C.cpp
Index: SRM/399/1C.cpp
==================================================================
--- SRM/399/1C.cpp
+++ SRM/399/1C.cpp
@@ -0,0 +1,127 @@
+#include <vector>
+#include <string>
+#include <iostream>
+#include <cstring>
+using namespace std;
+
+
+
+
+static const int NV = 512;
+typedef int           flow;
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+typedef flow          flow_graph[NV][NV];
+
+flow dinic_dfs( graph& G, flow_graph F, vert v, vert D,
+                int LV[], flow flow_in, int blocked[] )
+{
+	flow flow_out = 0;
+	for(int i=0; i!=G[v].size(); ++i)
+	{
+		int u = G[v][i];
+		if( LV[v]+1==LV[u] && F[v][u] )
+		{
+			flow f = min(flow_in-flow_out, F[v][u]);
+			if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) )
+			{
+				F[v][u]  -= f;
+				F[u][v]  += f;
+				flow_out += f;
+				if( flow_in == flow_out ) return flow_out;
+			}
+		}
+	}
+	blocked[v] = (flow_out==0);
+	return flow_out;
+}
+
+flow dinic( graph& G, flow_graph F, vert S, vert D )
+{
+	for( flow total=0 ;; ) {
+		int LV[NV] = {0};
+		vector<int> Q(1, S);
+		for(int lv=1; !Q.empty(); ++lv)
+		{
+			vector<int> Q2;
+			for(int i=0; i!=Q.size(); ++i)
+			{
+				edges& ne = G[Q[i]];
+				for(int j=0; j!=ne.size(); ++j)
+					if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
+						LV[ne[j]]=lv, Q2.push_back(ne[j]);
+			}
+			Q.swap(Q2);
+		}
+
+		if( !LV[D] )
+			return total;
+
+		int blocked[NV] = {};
+		total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
+	}
+}
+
+
+
+struct DancingParty
+{
+	int maxDances(vector<string> likes, int k)
+	{
+		int n = likes.size();
+		#define SRC 0
+		#define DST 1
+		#define L(i)  2+n*0+i
+		#define R(i)  2+n*1+i
+		#define YL(i) 2+n*2+i
+		#define NL(i) 2+n*3+i
+		#define YR(i) 2+n*4+i
+		#define NR(i) 2+n*5+i
+
+		graph G(2+n*6);
+
+		// Graph
+		for(int i=0; i<n; ++i) {
+			G[SRC ].push_back(L(i));  G[L(i) ].push_back(SRC);
+			G[L(i)].push_back(YL(i)); G[YL(i)].push_back(L(i));
+			G[L(i)].push_back(NL(i)); G[NL(i)].push_back(L(i));
+
+			G[DST ].push_back(R(i));  G[R(i) ].push_back(DST);
+			G[R(i)].push_back(YR(i)); G[YR(i)].push_back(R(i));
+			G[R(i)].push_back(NR(i)); G[NR(i)].push_back(R(i));
+
+			for(int j=0; j<n; ++j)
+				if( likes[i][j] == 'Y' )
+					G[YL(i)].push_back(YR(j)), G[YR(j)].push_back(YL(i));
+				else
+					G[NL(i)].push_back(NR(j)), G[NR(j)].push_back(NL(i));
+		}
+
+		for(int M=1; M<=n; ++M) {
+			// Flow
+			flow_graph F = {};
+			for(int i=0; i<n; ++i) {
+				F[SRC][L(i)] = M;
+				F[L(i)][YL(i)] = M;
+				F[L(i)][NL(i)] = k;
+
+				F[R(i)][DST] = M;
+				F[YR(i)][R(i)] = M;
+				F[NR(i)][R(i)] = k;
+
+				for(int j=0; j<n; ++j)
+					if( likes[i][j] == 'Y' )
+						F[YL(i)][YR(j)] = 1;
+					else
+						F[NL(i)][NR(j)] = 1;
+			}
+
+			// Maxflow
+			if( dinic(G, F, SRC, DST) < M*n )
+				return M-1;
+		}
+		return n;
+	}
+};

ADDED   SRM/400/1A.cpp
Index: SRM/400/1A.cpp
==================================================================
--- SRM/400/1A.cpp
+++ SRM/400/1A.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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class StrongPrimePower
+{
+public:
+	vector <int> baseAndExponent(string n) 
+	{
+		LL N;
+		stringstream(n) >> N;
+
+		LL sN = (LL) sqrt( (double)N );
+		if( sN*sN == N && isPrime(sN) ) {
+			vector<int> ans;
+			ans.push_back(sN);
+			ans.push_back(2);
+			return ans;
+		}
+		if( (sN+1)*(sN+1) == N && isPrime(sN+1) ) {
+			vector<int> ans;
+			ans.push_back(sN+1);
+			ans.push_back(2);
+			return ans;
+		}
+
+		for(LL p=2; p*p*p<=N; ++p)
+			if( N%p==0 ) {
+				LL q=0;
+				while(N%p==0)
+					N /= p, ++q;
+				if( N==1 ) {
+					vector<int> ans;
+					ans.push_back(p);
+					ans.push_back(q);
+					return ans;
+				}
+				break;
+			}
+		return vector<int>();
+	}
+
+	bool isPrime(LL N) {
+		for(LL p=2; p*p<=N; ++p)
+			if(N%p==0)
+				return false;
+		return true;
+	}
+};
+
+// BEGIN CUT HERE
+template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ {};
+char Test_(...);
+int Test_(Case_<0>) {
+	string n = "27"; 
+	int RetVal_[] = {3, 3 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
+int Test_(Case_<1>) {
+	string n = "10"; 
+	vector <int> RetVal; 
+	return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
+int Test_(Case_<2>) {
+	string n = "7"; 
+	vector <int> RetVal; 
+	return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
+int Test_(Case_<3>) {
+	string n = "1296"; 
+	vector <int> RetVal; 
+	return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
+int Test_(Case_<4>) {
+	string n = "576460752303423488"; 
+	int RetVal_[] = {2, 59 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
+int Test_(Case_<5>) {
+	string n = "999999874000003969"; 
+	int RetVal_[] = {999999937, 2 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/400/1B.cpp
Index: SRM/400/1B.cpp
==================================================================
--- SRM/400/1B.cpp
+++ SRM/400/1B.cpp
@@ -0,0 +1,109 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+#include <bitset>
+
+static const int INF = 3000;
+class ReversalChain
+{
+public:
+	map<pair<pair<LL,LL>,int>,int> memo;
+	int minReversal(string init, string goal) 
+	{
+		LL s=0, sb=0; for(int i=0; i<init.size(); ++i) if(init[i]=='1') s |= (1LL<<i), sb++;
+		LL g=0, gb=0; for(int i=0; i<goal.size(); ++i) if(goal[i]=='1') g |= (1LL<<i), gb++;
+		if( sb != gb )
+			return -1;
+		int a = mrev(s, g, init.size());
+		return a>=INF ? -1 : a;
+	}
+	int mrev(LL s, LL g, int m)
+	{
+		#define mask(x)  ((x) & (1LL<<(m))-1)
+		#define ith(x,i) (((x)>>(i))&1)
+
+		if( mask(s) == mask(g) )
+			return 0;
+
+		pair<pair<LL,LL>,int> key(make_pair(mask(s),mask(g)),m);
+		if( memo.count(key) )
+			return memo[key];
+
+		int a = INF;
+		if( ith(s,m-1)==ith(g,m-1) ) a = min(a, mrev(s, g, m-1));
+		if( ith(s,0)==ith(g,0) )     a = min(a, mrev(s>>1, g>>1, m-1));
+
+		s = bitrev(s,m);
+		if( ith(s,m-1)==ith(g,m-1) ) a = min(a, 1+mrev(s, g, m-1));
+		if( ith(s,0)==ith(g,0) )     a = min(a, 1+mrev(s>>1, g>>1, m-1));
+
+		return memo[key] = a;
+	}
+	LL bitrev(LL x, LL m)
+	{
+		LL y = 0;
+		for(int i=0; i<m; ++i)
+			y |= (((x>>i)&1) << (m-1-i));
+		return y;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string init = "1100"; 
+	string goal = "0110"; 
+	int RetVal = 1; 
+	return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
+int Test_(Case_<1>) {
+	string init = "111000"; 
+	string goal = "101010"; 
+	int RetVal = 2; 
+	return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
+int Test_(Case_<2>) {
+	string init = "0"; 
+	string goal = "1"; 
+	int RetVal = -1; 
+	return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
+int Test_(Case_<3>) {
+	string init = "10101"; 
+	string goal = "10101"; 
+	int RetVal = 0; 
+	return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
+int Test_(Case_<4>) {
+	string init = "111000111000"; 
+	string goal = "001100110011"; 
+	int RetVal = 4; 
+	return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
+int Test_(Case_<5>) {
+	string init = "001000011000000111000000001111";
+	string goal = "100100100100100100100100100100"; 
+	int RetVal = 9; 
+	return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/400/1C.cpp
Index: SRM/400/1C.cpp
==================================================================
--- SRM/400/1C.cpp
+++ SRM/400/1C.cpp
@@ -0,0 +1,108 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CollectingBonuses { public:
+	double expectedBuy(string n, string k) 
+	{
+		LL N; {stringstream ss; ss<<n; ss>>N;}
+		LL K; {stringstream ss; ss<<k; ss>>K;}
+		return N * sigma(K,N);
+	}
+	double f(LL b)
+	{
+		return 0.5772156649015313 + log(b+0.5);
+	}
+	double sigma(LL k, LL n)
+	{
+		// compute (1/n-k+1 + ... + 1/n)
+
+		if(k<=10000000) {
+			double p=0.0;
+			for(LL i=0; i<k; ++i)
+				p += 1.0 / (n-i);
+			return p;
+		}
+		else if(n-k<=10000000) {
+			double p=0.0;
+			for(LL i=1; i<=n-k; ++i)
+				p += 1.0 / i;
+			return f(n) - p;
+		}
+		LL x = 2*n+1;
+		LL y = 2*n-2*k+1;
+		if( x<y*2 )
+			return log1p(double(x-y)/y);
+		else
+			return log( double(x)/y );
+	}
+
+};
+
+// 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(_, CollectingBonuses().expectedBuy(n, k));}
+int main(){
+
+CASE(0)
+	string n = "1"; 
+	string k = "1"; 
+	double _ = 1.0; 
+END
+CASE(1)
+	string n = "2"; 
+	string k = "1"; 
+	double _ = 1.0; 
+END
+CASE(2)
+	string n = "2"; 
+	string k = "2"; 
+	double _ = 3.0; 
+END
+CASE(3)
+	string n = "4"; 
+	string k = "3"; 
+	double _ = 4.333333333333333; 
+END
+CASE(4)
+	string n = "999999999999999999"; 
+	string k = "999999999999999999"; 
+	double _ = 4.202374733879435E19; 
+END
+/*
+CASE(5)
+	string n = ; 
+	string k = ; 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/424/1A-2B.cpp
Index: SRM/424/1A-2B.cpp
==================================================================
--- SRM/424/1A-2B.cpp
+++ SRM/424/1A-2B.cpp
@@ -0,0 +1,13 @@
+struct ProductOfDigits
+{
+	int smallestNumber( int N )
+	{
+		if( N < 10 )
+			return 1;
+		int ans = 0;
+		for(int d=9; d>=2; --d)
+			while( N%d == 0 )
+				N/=d, ans++;
+		return N==1 ? ans : -1;
+	}
+};

ADDED   SRM/424/1B.cpp
Index: SRM/424/1B.cpp
==================================================================
--- SRM/424/1B.cpp
+++ SRM/424/1B.cpp
@@ -0,0 +1,64 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+int memo[1001][1001];
+
+class StrengthOrIntellect
+{
+public:
+	int numberOfMissions(vector <int> strength, vector <int> intellect, vector <int> points) 
+	{
+		memset(memo, 0xff, sizeof(memo));
+		return rec(1, 1, strength, intellect, points);
+	}
+
+	int rec(int s, int i, vector<int>& strength, vector<int>& intellect, vector<int>& points)
+	{
+		if( memo[s][i] >= 0 )
+			return memo[s][i];
+
+		int pt = 2-s-i, cnt=0;
+		for(int j=0; j<strength.size(); ++j)
+			if( strength[j]<=s || intellect[j]<=i )
+				pt+=points[j], ++cnt;
+
+		for(int ds=0; ds<=pt; ++ds) {
+			int ss = min(1000,s + ds);
+			int ii = min(1000,i + pt-ds);
+			if( ss>s || ii>i )
+				cnt = max(cnt, rec(ss, ii, strength, intellect, points));
+		}
+		return memo[s][i] = cnt;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {1, 2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; verify_case(0, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
+	void test_case_1() { int Arr0[] = {3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 0; verify_case(1, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
+	void test_case_2() { int Arr0[] = {1, 3, 1, 10, 3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 1, 3, 20, 3}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {2, 1, 1, 5, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 4; verify_case(2, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
+	void test_case_3() { int Arr0[] = {1, 2, 100, 5, 100, 10, 100, 17, 100}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 100, 3, 100, 7, 100, 13, 100, 21}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 2, 3, 4, 5, 6, 7, 8, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 9; verify_case(3, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
+	void test_case_4() { int Arr0[] = {1, 10, 1, 2, 16, 12, 13, 19, 12, 8}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 5, 1, 8, 3, 5, 3, 16, 19, 20}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 1, 1, 2, 1, 1, 2, 3, 5, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 7; verify_case(4, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { StrengthOrIntellect().run_test(-1); }
+// END CUT HERE

ADDED   SRM/424/1C.cpp
Index: SRM/424/1C.cpp
==================================================================
--- SRM/424/1C.cpp
+++ SRM/424/1C.cpp
@@ -0,0 +1,89 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+template<typename T = LL>
+struct FenwickTree
+{
+	vector<T> x;
+	FenwickTree(size_t n, const T& v = T()) : x(n, v) {}
+
+	void incr( int k, const T& a ) { // z[k] += a;
+		for(; k < x.size(); k|=k+1)
+			x[k] += a;
+	}
+
+	T sum(int i, int j) { // z[i]+...+z[j] : inclusive
+		if(i)
+			return sum(0, j) - sum(0, i-1);
+		else {
+			T v = T();
+			for(; j>=0; j=(j&(j+1))-1)
+				v += x[j];
+			return v;
+		}
+	}
+};
+
+static const int MODVAL = 1000000007;
+
+class ProductOfPrices
+{
+public:
+	int product(int N, int L, int X0, int A, int B) 
+	{
+		LL result = 1;
+
+		FenwickTree<> fw(L), nm(L);
+
+		LL X = X0 % L;
+		fw.incr(X, X);
+		nm.incr(X, 1);
+		for(int i=1; i<N; ++i)
+		{
+			X = (X*A+B) % L;
+
+			LL sumL = fw.sum(0, X-1);
+			LL sumR = fw.sum(X, L-1);
+			LL numL = nm.sum(0, X-1);
+			LL numR = nm.sum(X, L-1);
+
+			LL price = ((X*numL - sumL) + (sumR - X*numR)) % MODVAL;
+			result = (result * price) % MODVAL;
+
+			fw.incr(X, X);
+			nm.incr(X, 1);
+		}
+		return result;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 5; int Arg1 = 10; int Arg2 = 3; int Arg3 = 1; int Arg4 = 1; int Arg5 = 180; verify_case(0, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+	void test_case_1() { int Arg0 = 3; int Arg1 = 20; int Arg2 = 5; int Arg3 = 2; int Arg4 = 3; int Arg5 = 64; verify_case(1, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+	void test_case_2() { int Arg0 = 4; int Arg1 = 21; int Arg2 = 1; int Arg3 = 7; int Arg4 = 1; int Arg5 = 3087; verify_case(2, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+	void test_case_3() { int Arg0 = 10; int Arg1 = 100; int Arg2 = 4; int Arg3 = 37; int Arg4 = 11; int Arg5 = 591860767; verify_case(3, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+	void test_case_4() { int Arg0 = 5; int Arg1 = 200000; int Arg2 = 999999999; int Arg3 = 123456789; int Arg4 = 987654321; int Arg5 = 499739175; verify_case(4, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { ProductOfPrices().run_test(-1); }
+// END CUT HERE

ADDED   SRM/424/2A.cpp
Index: SRM/424/2A.cpp
==================================================================
--- SRM/424/2A.cpp
+++ SRM/424/2A.cpp
@@ -0,0 +1,18 @@
+#include <string>
+#include <stack>
+using namespace std;
+
+struct MagicSpell
+{
+	string fixTheSpell( string spell )
+	{
+		stack<char> s;
+		for(int i=0; i<spell.size(); ++i)
+			if( spell[i]=='A' || spell[i]=='Z' )
+				s.push( spell[i] );
+		for(int i=0; i<spell.size(); ++i)
+			if( spell[i]=='A' || spell[i]=='Z' )
+				spell[i]=s.top(), s.pop();
+		return spell;
+	}
+};

ADDED   SRM/424/2C.cpp
Index: SRM/424/2C.cpp
==================================================================
--- SRM/424/2C.cpp
+++ SRM/424/2C.cpp
@@ -0,0 +1,41 @@
+#include <vector>
+#include <string>
+#include <set>
+using namespace std;
+
+struct BestRoads
+{
+	vector<int> numberOfRoads(vector<string> roads, int M)
+	{
+		int N = roads.size();
+		vector<int> ans(N);
+
+		// Kruskal
+		typedef pair<int,int> road;
+		set<road> Q;
+		for(int i=0; i<N; ++i)
+			for(int j=i+1; j<N; ++j)
+				if( roads[i][j]=='Y' )
+					Q.insert( road(i,j) );
+
+		vector<int> p(N,-1), s(N, 1); // Union-Find
+		int div=N, red=M-N+1;
+
+		for(set<road>::iterator it=Q.begin(); it!=Q.end(); ++it)
+		{
+			road r = *it;
+			int a=r.first;  while(p[a]!=-1) a=p[a];
+			int b=r.second; while(p[b]!=-1) b=p[b];
+			if( a != b )
+			{
+				ans[r.first]++, ans[r.second]++, div--;
+				if(s[a]<s[b]) p[a]=b, s[b]+=s[a];
+				else          p[b]=a, s[a]+=s[b];
+			}
+			else if( red )
+				ans[r.first]++, ans[r.second]++, red--;
+		}
+
+		return (red==0 && div==1) ? ans : vector<int>();
+	}
+};

ADDED   SRM/425/1A.cpp
Index: SRM/425/1A.cpp
==================================================================
--- SRM/425/1A.cpp
+++ SRM/425/1A.cpp
@@ -0,0 +1,41 @@
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <map>
+#include <set>
+using namespace std;
+
+typedef pair<int,int> point;
+
+class CrazyBot
+{
+public:
+	double getProbability(int n, int east, int west, int south, int north)
+	{
+		set<point> vis;
+		vis.insert( point(0,0) );
+		vis.insert( point(0,1) );
+		return rec(vis, point(0,1), n-1, east, west, south, north);
+	}
+
+	double rec( set<point>& vis, point p, int N, int e, int w, int s, int n)
+	{
+		if( N == 0 )
+			return 1;
+		int dx[] = {0,0,1,-1};
+		int dy[] = {1,-1,0,0};
+		int pr[] = {e,w,s,n};
+		double ans = 0;
+		for(int i=0; i<4; ++i)
+		{
+			point q( p.first+dx[i], p.second+dy[i] );
+			if( !vis.count(q) )
+			{
+				vis.insert(q);
+				ans += double(pr[i])/100 * rec(vis, q, N-1, e, w, s, n);
+				vis.erase(q);
+			}
+		}
+		return ans;
+	}
+};

ADDED   SRM/425/1B.cpp
Index: SRM/425/1B.cpp
==================================================================
--- SRM/425/1B.cpp
+++ SRM/425/1B.cpp
@@ -0,0 +1,85 @@
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <set>
+#include <iostream>
+using namespace std;
+
+class PiecesMover
+{
+public:
+	static bool is_connected(int cur)
+	{
+		int py[5], px[5], pn=0;
+		for(int j=0; j<25; ++j)
+			if( cur & (1<<j) )
+				py[pn]=j/5, px[pn]=j%5, pn++;
+
+		int uf[5] = {0,1,2,3,4}, conn = pn;
+
+		for(int i=0; i<pn; ++i)
+		for(int j=i+1; j<pn; ++j)
+			if( px[i]==px[j] && abs(py[i]-py[j])==1
+			 || py[i]==py[j] && abs(px[i]-px[j])==1 ) {
+				int a=i; while(uf[a]!=a) a=uf[a];
+				int b=j; while(uf[b]!=b) b=uf[b];
+				if(a!=b) { uf[a]=b, --conn; }
+			}
+		return conn==1;
+	}
+
+	int getMinimumMoves(vector <string> board)
+	{
+		int start = 0;
+		for(int i=0; i<25; ++i)
+			if( board[i/5][i%5]=='*' )
+				start |= (1<<i);
+
+		vector<bool> visited(1<<25); visited[start] = false;
+		vector<int> Q(1, start);
+		int step = 0;
+		for(;; ++step)
+		{
+			vector<int> Q2;
+			for(int i=0; i!=Q.size(); ++i)
+			{
+				int cur = Q[i];
+				if( is_connected(cur) )
+					return step;
+
+				// next
+				int dx[] = {1,-1,0,0};
+				int dy[] = {0,0,1,-1};
+				for(int j=0; j<25; ++j)
+					if( cur & (1<<j) )
+						for(int k=0; k<4; ++k)
+						{
+							int jy=j/5+dy[k], jx=j%5+dx[k];
+							if(0<=jy && jy<5 && 0<=jx && jx<5) {
+								int next = 1 << (jy*5+jx);
+								if( !(cur&next) ) {
+									next = cur&~(1<<j)|next;
+									if( !visited[next] ) {
+										visited[next]=true;
+										Q2.push_back(next);
+									}
+								}
+							}
+						}
+			}
+			Q.swap(Q2);
+		}
+		return -1;
+	}
+};
+
+int main()
+{
+	vector<string> x;
+x.push_back(".....");
+x.push_back("..**.");
+x.push_back(".....");
+x.push_back("...*.");
+x.push_back(".....");
+	cout << PiecesMover().getMinimumMoves(x) << endl;;
+}

ADDED   SRM/425/1C.cpp
Index: SRM/425/1C.cpp
==================================================================
--- SRM/425/1C.cpp
+++ SRM/425/1C.cpp
@@ -0,0 +1,175 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class RoadsOfKingdom { public:
+	vector< vector<double> > P;
+
+	double getProbability(vector <string> roads) 
+	{
+		P     = read_input(roads);
+		memo  = vector<double>(1<<P.size(), -1);
+		memo0 = vector<double>(P.size()<<P.size(), -1);
+		memo1 = vector<double>(P.size()<<P.size(), -1);
+		return prob_tree( (1<<P.size())-1 );
+	}
+
+	vector< vector<double> > read_input(const vector<string>& R)
+	{
+		int N = R.size();
+		vector< vector<double> > P(N, vector<double>(N));
+		for(int i=0; i<N; ++i)
+			for(int j=0; j<N; ++j)
+				P[i][j] = (R[i][j] - '0') / 8.0;
+		return P;
+	}
+
+	vector<double> memo;
+	double prob_tree(int S)
+	{
+		if( memo[S] >= 0 )
+			return memo[S];
+
+		// the first and the second smallest IDs in S
+		int v, w;
+		for(v=0;   (1<<v)<=S; ++v) if( S & 1<<v ) break;
+		for(w=v+1; (1<<w)<=S; ++w) if( S & 1<<w ) break;
+
+		// if |S| < 2 then it always forms a tree
+		if( (1<<w) > S )
+			return memo[S] = 1.0;
+
+		// Let's consider v as the "root node" of S, and try all possible "subtrees" T containing w.
+		// The situation is (other nodes)=v-(T where w in T)
+		double p = 0.0;
+		for(int T=S; T; T=(T-1)&S)
+			if( (T & 1<<w) && !(T & 1<<v) )
+				p += prob_tree(T) * prob_tree(S&~T) * prob_separated(T, S&~T&~(1<<v)) * prob_one(v, T);
+		return memo[S] = p;
+	}
+
+	double prob_separated(int S1, int S2)
+	{
+		double p = 1.0;
+		for(int v=0; (1<<v)<=S1; ++v) if( S1 & 1<<v )
+			p *= prob_zero(v, S2);
+		return p;
+	}
+
+	vector<double> memo0;
+	double prob_zero(int v, int S) // 0 connection between v and S
+	{
+		const int key = v<<P.size() | S;
+		if( memo0[key] >= 0 ) return memo0[key];
+
+		double p = 1.0;
+		for(int u=0; (1<<u)<=S; ++u) if( S & 1<<u )
+			p *= 1.0 - P[v][u];
+		return memo0[key] = p;
+	}
+
+	vector<double> memo1;
+	double prob_one(int v, int S) // exactly 1 connection between v and S
+	{
+		const int key = v<<P.size() | S;
+		if( memo1[key] >= 0 ) return memo1[key];
+
+		double p = 0.0;
+		for(int c=0; (1<<c)<=S; ++c) if( S & 1<<c )
+		{
+			double q = 1.0;
+			for(int u=0; (1<<u)<=S; ++u) if( S & 1<<u )
+				q *= u==c ? P[v][u] : 1-P[v][u];
+			p += q;
+		}
+		return memo1[key] = p;
+	}
+};
+
+// 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(_, RoadsOfKingdom().getProbability(roads));}
+int main(){
+
+CASE(0)
+	string roads_[] = {"04",
+ "40"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	double _ = 0.5; 
+END
+CASE(1)
+	string roads_[] = {"08",
+ "80"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	double _ = 1.0; 
+END
+CASE(2)
+	string roads_[] = {"00",
+ "00"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	double _ = 0.0; 
+END
+CASE(3)
+	string roads_[] = {"088",
+ "808",
+ "880"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	double _ = 0.0; 
+END
+CASE(4)
+	string roads_[] = {"044",
+ "404",
+ "440"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	double _ = 0.375; 
+END
+CASE(5)
+	string roads_[] = {"0701",
+ "7071",
+ "0708",
+ "1180"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	double _ = 0.622314453125; 
+END
+CASE(6)
+	string roads_[] = {"0622100102300020", "6070000107208008", "2700207010110410", "2000188001010820", "1021032008000021", "0008300013001000", "0078200200000201", "1100002007000011", "0010010000600000", "2701830700518172", "3210000065000200", "0011000001002081", "0800010008020100", "0048002001201000", "2012200107080000", "0800101102010000"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	double _ = 5.519032471358341E-5; 
+END
+/*
+CASE(7)
+	string roads_[] = ;
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/425/2C.cpp
Index: SRM/425/2C.cpp
==================================================================
--- SRM/425/2C.cpp
+++ SRM/425/2C.cpp
@@ -0,0 +1,164 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PiecesMover { public:
+	typedef vector< pair<int,int> > state;
+	int getMinimumMoves(vector <string> board) 
+	{
+		set<state> V;
+		vector<state> Q(1, to_state(board));
+		V.insert( Q.front() );
+		for(int step=0; !Q.empty(); ++step)
+		{
+			vector<state> Q_next;
+			for(int i=0; i<Q.size(); ++i)
+			{
+				const state& b = Q[i];
+				if( is_connected(b) )
+					return step;
+				const vector<state>& next = next_states(b);
+				for(int j=0; j<next.size(); ++j)
+					if( V.insert(next[j]).second )
+						Q_next.push_back(next[j]);
+			}
+			Q.swap(Q_next);
+		}
+		assert(false);
+	}
+
+	state to_state( const vector<string>& b )
+	{
+		state s;
+		for(int y=0; y<5; ++y)
+		for(int x=0; x<5; ++x)
+			if( b[y][x] == '*' )
+				s.push_back( make_pair(y,x) );
+		sort( s.begin(), s.end() );
+		return s;
+	}
+
+	bool is_connected( const state& s )
+	{
+		int N = s.size();
+		vector< vector<int> > G(N, vector<int>(N));
+		for(int i=0; i<N; ++i)
+			for(int j=0; j<N; ++j)
+				if( i == j )
+					G[i][j] = 0;
+				else
+					G[i][j] = (abs(s[i].first-s[j].first)+abs(s[i].second-s[j].second) == 1 ? 1 : 100);
+		for(int k=0; k<N; ++k)
+			for(int i=0; i<N; ++i)
+				for(int j=0; j<N; ++j)
+					G[i][j] = min(G[i][j], G[i][k]+G[k][j]);
+		for(int i=0; i<N; ++i)
+			for(int j=0; j<N; ++j)
+				if( G[i][j] > N )
+					return false;
+		return true;
+	}
+
+	vector<state> next_states( const state& s )
+	{
+		vector<state> result;
+		for(int i=0; i<s.size(); ++i)
+			for(int d=0; d<4; ++d)
+			{
+				set< pair<int,int> > x;
+				for(int k=0; k<s.size(); ++k)
+					if( i != k )
+						x.insert( s[k] );
+					else
+					{
+						static const int dy[] = {-1,+1,0,0};
+						static const int dx[] = {0,0,-1,+1};
+						int ny = s[k].first+dy[d];
+						int nx = s[k].second+dx[d];
+						if( 0<=ny && ny<5 && 0<=nx && nx<5 )
+							x.insert( make_pair(ny, nx) );
+					}
+				if( x.size() == s.size() )
+					result.push_back( state(x.begin(), x.end()) );
+			}
+		return result;
+	}
+};
+
+// 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(_, PiecesMover().getMinimumMoves(board));}
+int main(){
+
+CASE(0)
+	string board_[] = {".....",
+ "..**.",
+ ".....",
+ "...*.",
+ "....."}
+;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string board_[] = {".....",
+ ".....",
+ ".**..",
+ ".*...",
+ "**..."}
+;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 0; 
+END
+CASE(2)
+	string board_[] = {"*...*",
+ ".....",
+ ".....",
+ ".....",
+ "*...*"}
+;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 12; 
+END
+/*
+CASE(3)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = ; 
+END
+CASE(4)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/426-U/1A.cpp
Index: SRM/426-U/1A.cpp
==================================================================
--- SRM/426-U/1A.cpp
+++ SRM/426-U/1A.cpp
@@ -0,0 +1,62 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class ShufflingMachine
+{
+public:
+	double stackDeck(vector <int> shuffle, int maxShuffles, vector <int> cardsReceived, int K) 
+	{
+		set<int> my( cardsReceived.begin(), cardsReceived.end() );
+
+		vector<int> cur(shuffle.size());
+		for(int i=0; i<cur.size(); ++i)
+			cur[i] = i;
+
+		vector<double> prob(shuffle.size());
+		for(int N=1; N<=maxShuffles; ++N)
+		{
+			for(int i=0; i<cur.size(); ++i)
+				cur[i] = shuffle[cur[i]];
+
+			for(int i=0; i<cur.size(); ++i)
+				if( my.count(cur[i]) )
+					prob[i] += 1.0 / maxShuffles;
+		}
+
+		sort( prob.rbegin(), prob.rend() );
+		return accumulate( prob.begin(), prob.begin()+K, 0.0 );
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {1,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arr2[] = {0}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; double Arg4 = 0.6666666666666666; verify_case(0, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_1() { int Arr0[] = {1,2,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 5; int Arr2[] = {0}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; double Arg4 = 0.8; verify_case(1, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_2() { int Arr0[] = {1,2,0,4,3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; int Arr2[] = {0,3}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; double Arg4 = 1.0; verify_case(2, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_3() { int Arr0[] = {0,4,3,5,2,6,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 19; int Arr2[] = {1,3,5}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; double Arg4 = 1.0526315789473684; verify_case(3, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_4() { int Arr0[] = {3,4,7,2,8,5,6,1,0,9}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 47; int Arr2[] = {6,3,5,2,8,7,4}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 8; double Arg4 = 6.297872340425532; verify_case(4, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	ShufflingMachine().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/426-U/1B.cpp
Index: SRM/426-U/1B.cpp
==================================================================
--- SRM/426-U/1B.cpp
+++ SRM/426-U/1B.cpp
@@ -0,0 +1,100 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class CatchTheMice
+{
+public:
+	double intersect(double b1, double a1, double b2, double a2)
+	{
+		// a1x + b1 == a2x + b2
+		if( a1 == a2 ) return -1;
+		return (b2-b1) / (a1-a2);
+	}
+
+	double largestCage(vector <int> xp, vector <int> yp, vector <int> xv, vector <int> yv) 
+	{
+		vector<double> t; // collision time
+		t.push_back(0);
+
+		int n = xp.size();
+		for(int i=0; i<n; ++i)
+			for(int j=i+1; j<n; ++j)
+			{
+				double ct = intersect(xp[i], xv[i], xp[j], xv[j]);
+				if(ct>0) t.push_back(ct);
+				ct = intersect(yp[i], yv[i], yp[j], yv[j]);
+				if(ct>0) t.push_back(ct);
+			}
+
+		sort(t.begin(), t.end());
+		t.erase(unique(t.begin(), t.end()), t.end());
+		t.push_back( t.back()+1.0 );
+
+		double Lmin = 1e+300;
+		for(int i=0; i+1<t.size(); ++i)
+		{
+			double ti = (t[i]+t[i+1])/2;
+
+			int j_xm=0; double xm =  1e+300;
+			int j_xM=0; double xM = -1e+300;
+			int j_ym=0; double ym =  1e+300;
+			int j_yM=0; double yM = -1e+300;
+			for(int j=0; j<n; ++j) {
+				if( xm > xp[j]+xv[j]*ti ) j_xm=j, xm=xp[j]+xv[j]*ti;
+				if( xM < xp[j]+xv[j]*ti ) j_xM=j, xM=xp[j]+xv[j]*ti;
+				if( ym > yp[j]+yv[j]*ti ) j_ym=j, ym=yp[j]+yv[j]*ti;
+				if( yM < yp[j]+yv[j]*ti ) j_yM=j, yM=yp[j]+yv[j]*ti;
+			}
+
+			int Xp = xp[j_xM]-xp[j_xm];
+			int Xv = xv[j_xM]-xv[j_xm];
+			int Yp = yp[j_yM]-yp[j_ym];
+			int Yv = yv[j_yM]-yv[j_ym];
+
+			// min of max(x,y)
+			double ct = intersect(Xp,Xv,Yp,Yv);
+			if( t[i] <= ct && ct <= t[i+1] )
+				Lmin = min(Lmin, Xp + Xv*ct);
+			else {
+				Lmin = min(Lmin, max(Xp+Xv*t[i+0], Yp+Yv*t[i+0]));
+				Lmin = min(Lmin, max(Xp+Xv*t[i+1], Yp+Yv*t[i+1]));
+			}
+		}
+		return Lmin;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {0,10}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {10,-10}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {0,0}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 10.0; verify_case(0, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_1() { int Arr0[] = {0,10,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0,10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,-6,4}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {4,5,-4}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 3.0; verify_case(1, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_2() { int Arr0[] = {50,10,30,15}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {-10,30,20,40}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {-5,-10,-15,-5}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {40,-10,-1,-50}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 40.526315789473685; verify_case(2, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_3() { int Arr0[] = {0,10,10,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0,10,10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,0,-1,0}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {0,1,0,-1}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 10.0; verify_case(3, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_4() { int Arr0[] = {13,50,100,40,-100}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {20,20,-150,-40,63}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {4,50,41,-41,-79}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,1,1,3,-1}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 212.78688524590163; verify_case(4, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_5() { int Arr0[] = {0,10}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {5,5}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {3,3}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 10.0; verify_case(5, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
+	void test_case_6() { int Arr0[] = {-49,-463,-212,-204,-557,-67,-374,-335,-590,-4}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {352,491,280,355,129,78,404,597,553,445}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {-82,57,-23,-32,89,-72,27,17,100,-94}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {-9,-58,9,-14,56,75,-32,-98,-81,-43}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 25.467532467532468; verify_case(6, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	CatchTheMice().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/426-U/1C-take1.cpp
Index: SRM/426-U/1C-take1.cpp
==================================================================
--- SRM/426-U/1C-take1.cpp
+++ SRM/426-U/1C-take1.cpp
@@ -0,0 +1,150 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+vector<double> solve_linear_eq( int n, vector< vector<double> > M, const vector<double>& V )
+{
+	vector<double> A(V);
+	for(int i=0; i<n; ++i)
+	{
+		// pivot
+		if( M[i][i] == 0 )
+			for(int j=i+1; j<n; ++j)
+				if( M[j][i] != 0 )
+					{swap(M[i], M[j]); swap(A[i], A[j]); break;}
+		if( M[i][i] == 0 )
+			throw "no anser";
+
+		// M[i][i] <-- 1
+		double p = M[i][i];
+		for(int j=i; j<n; ++j)
+			M[i][j] /= p;
+		A[i] /= p;
+
+		// M[*][i] <-- 0
+		for(int j=0; j<n; ++j) if(j!=i)
+		{
+			double r = M[j][i];
+			for(int k=i; k<n; ++k)
+				M[j][k] -= M[i][k] * r;
+			A[j] -= A[i] * r;
+		}
+	}
+	// consistency check
+	for(int i=n; i<M.size(); ++i) {
+		double s = 0.0;
+		for(int j=0; j<n; ++j)
+			s += M[i][j] * A[j];
+		if( abs(s-A[i]) > 1e-4 )
+			throw "no answer";
+	}
+	return A;
+}
+
+
+class LongStraightRoad
+{
+public:
+	int distanceToDestination(vector <string> signs, string destination) 
+	{
+		typedef map< string, vector< pair<double,int> > > MSV;
+		MSV data;
+		for(int i=0; i<signs.size(); ++i)
+		{
+			stringstream sin(signs[i]);
+			while(sin) {
+				string n; int d; sin>>n>>d;
+				char c; sin>>c; // ';'
+				data[n].push_back( make_pair(double(d), i) );
+			}
+		}
+		if( data[destination].empty() )
+			return -1;
+
+		vector< vector<double> > M;
+		vector<double> V;
+		for(MSV::iterator it=data.begin(); it!=data.end(); ++it)
+		{
+			vector< pair<double,int> >& d = it->second;
+			for(int i=0; i+1<d.size(); ++i)
+			{
+				if( d[i].first <= d[i+1].first )
+					return -1;
+
+				// S[d[i].second] - S[d[i+1].second] == d[i+1].first - d[i].first
+				vector<double> Mk(signs.size());
+				Mk[d[i].second]   = 1;
+				Mk[d[i+1].second] = -1;
+				M.push_back(Mk);
+				V.push_back( d[i+1].first - d[i].first );
+			}
+		}
+		// S[last] = 0.0
+		vector<double> Mk(signs.size());
+		Mk[signs.size()-1] = 1;
+		M.push_back(Mk);
+		V.push_back(0);
+
+		if( signs.size() > M.size() )
+			return -1;
+		try {
+			vector<double> S = solve_linear_eq( signs.size(), M, V );
+			for(int i=0; i+1<S.size(); ++i)
+				if( S[i] > S[i+1] )
+					return -1;
+			double result = 
+				S[ data[destination][0].second ] + data[destination][0].first;
+			int rI = (int)floor(result+0.5);
+			if( abs(result-rI) > 1e-4 )
+				return -1;
+			return ( rI < 0 ? -1 : rI );
+		} catch(const char*) {
+			return -1;
+		}
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arr0[] = {"COLCHESTER 5;GLASTONBURY 25;MARLBOROUGH 13"
+,"MARLBOROUGH 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "GLASTONBURY"; int Arg2 = 14; verify_case(0, Arg2, distanceToDestination(Arg0, Arg1)); }
+	void test_case_1() { string Arr0[] = {"COLCHESTER 5;GLASTONBURY 25;MARLBOROUGH 13"
+,"GLASTONBURY 13;MARLBOROUGH 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "GLASTONBURY"; int Arg2 = -1; verify_case(1, Arg2, distanceToDestination(Arg0, Arg1)); }
+	void test_case_2() { string Arr0[] = {"A 25;B 15"
+,"A 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "B"; int Arg2 = -1; verify_case(2, Arg2, distanceToDestination(Arg0, Arg1)); }
+	void test_case_3() { string Arr0[] = {"YVO 60;J 62"
+,"K 45"
+,"K 40;MV 17"
+,"K 37;YVO 44;HY 48;CC 69;D 77;YXF 80"
+,"YVO 30;B 37;RB 59"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "MV"; int Arg2 = 0; verify_case(3, Arg2, distanceToDestination(Arg0, Arg1)); }
+	void test_case_4() { string Arr0[] = {"A 200;B 150"
+,"C 45;D 100;E 150"
+,"C 25;E 130"
+,"F 80;G 65"
+,"G 35;H 160"
+,"A 160"
+,"H 130"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "F"; int Arg2 = -1; verify_case(4, Arg2, distanceToDestination(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	LongStraightRoad().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/426-U/1C-take2.cpp
Index: SRM/426-U/1C-take2.cpp
==================================================================
--- SRM/426-U/1C-take2.cpp
+++ SRM/426-U/1C-take2.cpp
@@ -0,0 +1,156 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+
+class LongStraightRoad
+{
+public:
+	typedef pair<int,int> edge; // (index,dist)
+	int distanceToDestination(vector<string> signs, string destination) 
+	{
+		int n = signs.size();
+
+		// parse
+		vector< map<string, int> > data(n);
+		map<string, vector<edge> > n2d; // name -> (index, dist)
+		for(int i=0; i<n; ++i)
+		{
+			stringstream sin(signs[i]);
+			while(sin) {
+				string n; int d; sin>>n>>d;
+				char c; sin>>c; // ';'
+				data[i][n] = d;
+				n2d[n].push_back( edge(i,d) );
+			}
+		}
+
+		// construct the graph
+		vector< vector<edge> > G(n);
+		for(int i=0; i<n; ++i)
+		{
+			for(map<string,int>::iterator it=data[i].begin(); it!=data[i].end(); ++it)
+			{
+				vector<edge>& es = n2d[it->first];
+				for(int j=0; j<es.size(); ++j)
+					if( es[j].first != i )
+						G[i].push_back( edge(es[j].first, it->second - es[j].second) );
+			}
+		}
+
+		try {
+			vector<bool> done(n, false);
+			vector<int>     p(n);
+			{
+				vector<bool> visited(n, false);
+				dfs(n-1, 0, G, visited, p);
+
+				vector<int> kn;
+				for(int i=0; i<n; ++i)
+					if( visited[i] ) {
+						kn.push_back( p[i] );
+						done[i] = true;
+					}
+				if( !sorted(kn) ) {
+cerr << "ns1" << endl;
+					return -1;
+}
+			}
+			vector<edge>& es = n2d[destination];
+			int result = p[es[0].first] + es[0].second;
+			if( result < 0 )
+				return -1;
+
+			for(int v=0; v<n; ++v)
+				if( !done[v] )
+				{
+					vector<bool> visited(n, false);
+					dfs(v, 0, G, visited, p);
+
+					vector<int> kn;
+					for(int i=0; i<n; ++i)
+						if( visited[i] ) {
+							kn.push_back( p[i] );
+							done[i] = true;
+						}
+					if( !sorted(kn) ) {
+cerr << "ns@" << v << endl;
+						return -1;
+}
+				}
+			return result;
+		} catch (const char*) {
+			return -1;
+		}
+	}
+
+	bool sorted( vector<int>& kn )
+	{
+		for(int i=0; i+1<kn.size(); ++i)
+			if( kn[i] >= kn[i+1] )
+				return false;
+		return true;
+	}
+
+	void dfs(int v, int d, vector< vector<edge> >& G, vector<bool>& visited, vector<int>& p)
+	{
+		if( visited[v] ) {
+			if( d != p[v] ) {
+cerr << d << " " << v << " " << p[v] << endl;
+				throw "bad";
+}
+			return;
+		}
+		visited[v] = true;
+		p[v]       = d;
+		for(int i=0; i<G[v].size(); ++i) {
+cerr << v << "->" << G[v][i].first << " : " << G[v][i].second << endl;
+			dfs( G[v][i].first, d+G[v][i].second, G, visited, p );
+}
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arr0[] = {"COLCHESTER 5;GLASTONBURY 25;MARLBOROUGH 13"
+,"MARLBOROUGH 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "GLASTONBURY"; int Arg2 = 14; verify_case(0, Arg2, distanceToDestination(Arg0, Arg1)); }
+	void test_case_1() { string Arr0[] = {"COLCHESTER 5;GLASTONBURY 25;MARLBOROUGH 13"
+,"GLASTONBURY 13;MARLBOROUGH 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "GLASTONBURY"; int Arg2 = -1; verify_case(1, Arg2, distanceToDestination(Arg0, Arg1)); }
+	void test_case_2() { string Arr0[] = {"A 25;B 15"
+,"A 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "B"; int Arg2 = -1; verify_case(2, Arg2, distanceToDestination(Arg0, Arg1)); }
+	void test_case_3() { string Arr0[] = {"YVO 60;J 62"
+,"K 45"
+,"K 40;MV 17"
+,"K 37;YVO 44;HY 48;CC 69;D 77;YXF 80"
+,"YVO 30;B 37;RB 59"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "MV"; int Arg2 = 0; verify_case(3, Arg2, distanceToDestination(Arg0, Arg1)); }
+	void test_case_4() { string Arr0[] = {"A 200;B 150"
+,"C 45;D 100;E 150"
+,"C 25;E 130"
+,"F 80;G 65"
+,"G 35;H 160"
+,"A 160"
+,"H 130"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "F"; int Arg2 = -1; verify_case(4, Arg2, distanceToDestination(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() {
+	LongStraightRoad().run_test(-1);
+}
+// END CUT HERE

ADDED   SRM/427/1A.cpp
Index: SRM/427/1A.cpp
==================================================================
--- SRM/427/1A.cpp
+++ SRM/427/1A.cpp
@@ -0,0 +1,53 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+int gcd(int a, int b)
+{
+	while(a) {
+		int t = a;
+		a = b%a;
+		b = t;
+	}
+	return b;
+}
+
+class DesignCalendar
+{
+public:
+	int shortestPeriod(int dayLength, int yearLength) 
+	{
+		return dayLength / gcd(yearLength, dayLength);
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 4; int Arg1 = 1461; int Arg2 = 4; verify_case(0, Arg2, shortestPeriod(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 86400; int Arg1 = 31558150; int Arg2 = 1728; verify_case(1, Arg2, shortestPeriod(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 98; int Arg1 = 100; int Arg2 = 49; verify_case(2, Arg2, shortestPeriod(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 1000 ; int Arg1 = 50000100; int Arg2 = 10; verify_case(3, Arg2, shortestPeriod(Arg0, Arg1)); }
+	void test_case_4() { int Arg0 = 5673; int Arg1 = 28565335; int Arg2 = 5673; verify_case(4, Arg2, shortestPeriod(Arg0, Arg1)); }
+	void test_case_5() { int Arg0 = 5555; int Arg1 = 846555; int Arg2 = 1111; verify_case(5, Arg2, shortestPeriod(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { DesignCalendar().run_test(-1); }
+// END CUT HERE

ADDED   SRM/427/1B.cpp
Index: SRM/427/1B.cpp
==================================================================
--- SRM/427/1B.cpp
+++ SRM/427/1B.cpp
@@ -0,0 +1,117 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+LL dig(LL x)
+{
+	if(x<=9) return x;
+	LL s = 0;
+	while(x)
+		s += x%10, x/=10;
+	return dig(s);
+}
+class LocateTreasure
+{
+public:
+	string location(int K, int m) 
+	{
+		vector<LL> ds;
+		ds.push_back(1);
+		LL found[10] = {-1, 0, -1, -1, -1, -1, -1, -1, -1, -1};
+		LL loop_beg, loop_end;
+		for(LL i=1;; ++i) {
+			LL d = dig( ds.back()*m );
+			if( found[d] < 0 )
+			{
+				ds.push_back(d);
+				found[d] = i;
+			}
+			else
+			{
+				loop_beg = found[d];
+				loop_end = i;
+				break;
+			}
+		}
+
+		vector<LL> ds2 = ds;
+		ds2.insert(ds2.end(), ds.begin()+loop_beg, ds.begin()+loop_end);
+		ds2.insert(ds2.end(), ds.begin()+loop_beg, ds.begin()+loop_end);
+		ds2.insert(ds2.end(), ds.begin()+loop_beg, ds.begin()+loop_end);
+		ds2.insert(ds2.end(), ds.begin()+loop_beg, ds.begin()+loop_end);
+		ds = ds2;
+
+		LL x=0, y=0;
+
+		if( K <= loop_beg )
+		{
+			for(LL i=0; i<K; ++i) {
+				if( i%4==0 ) y += ds[i];
+				if( i%4==1 ) x += ds[i];
+				if( i%4==2 ) y -= ds[i];
+				if( i%4==3 ) x -= ds[i];
+			}
+		}
+		else
+		{
+			for(LL i=0; i<loop_beg; ++i) {
+				if( i%4==0 ) y += ds[i];
+				if( i%4==1 ) x += ds[i];
+				if( i%4==2 ) y -= ds[i];
+				if( i%4==3 ) x -= ds[i];
+			}
+
+			LL loop_len = 4 * (loop_end - loop_beg);
+			K -= loop_beg;
+			LL dx=0, dy=0;
+			for(LL i=0; i<loop_len; ++i) {
+				if( (loop_beg+i)%4==0 ) dy += ds[loop_beg+i];
+				if( (loop_beg+i)%4==1 ) dx += ds[loop_beg+i];
+				if( (loop_beg+i)%4==2 ) dy -= ds[loop_beg+i];
+				if( (loop_beg+i)%4==3 ) dx -= ds[loop_beg+i];
+			}
+			x += dx * (K / loop_len);
+			y += dy * (K / loop_len);
+
+			K %= loop_len;
+			for(LL i=0; i<K; ++i) {
+				if( (loop_beg+i)%4==0 ) y += ds[loop_beg+i];
+				if( (loop_beg+i)%4==1 ) x += ds[loop_beg+i];
+				if( (loop_beg+i)%4==2 ) y -= ds[loop_beg+i];
+				if( (loop_beg+i)%4==3 ) x -= ds[loop_beg+i];
+			}
+		}
+
+		stringstream sout;
+		sout << x << " " << y;
+		return sout.str();
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 5; int Arg1 = 2; string Arg2 = "-6 4"; verify_case(0, Arg2, location(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 99; int Arg1 = 1; string Arg2 = "1 0"; verify_case(1, Arg2, location(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 6; int Arg1 = 9; string Arg2 = "9 1"; verify_case(2, Arg2, location(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { LocateTreasure().run_test(-1); }
+// END CUT HERE

ADDED   SRM/427/1C.cpp
Index: SRM/427/1C.cpp
==================================================================
--- SRM/427/1C.cpp
+++ SRM/427/1C.cpp
@@ -0,0 +1,96 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+static const LL MODVAL = 1234567891;
+
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL FACT(LL x) { return x<=1 ? 1 : MUL(x, FACT(x-1)); }
+
+class PSequence
+{
+public:
+	map<pair<vector<LL>,int>, LL> memo;
+
+	int count(vector <int> S, int p) 
+	{
+		memo.clear();
+
+		vector<LL> cs; // congruences mod p
+
+		bool used[30] = {};
+		for(int i=0; i<S.size(); ++i)
+			if( !used[i] )
+			{
+				int cnt = 0;
+				for(int j=i; j<S.size(); ++j)
+					if( abs(S[i]-S[j]) % p == 0 )
+						{used[j]=true; ++cnt;}
+				cs.push_back(cnt);
+			}
+
+		LL f = num_perm( cs, -1, S.size() );
+		for(int i=0; i<cs.size(); ++i)
+			f = MUL(f, FACT(cs[i]));
+		return f;
+	}
+
+	LL num_perm( vector<LL>& cs, int forbidden, int n )
+	{
+		if( n == 0 )
+			return 1;
+
+		int v = (forbidden >= 0 ? cs[forbidden] : -1);
+		pair<vector<LL>,int> key(cs, forbidden);
+		sort(key.first.begin(), key.first.end());
+		key.second = find(key.first.begin(), key.first.end(), v) - key.first.begin();
+
+		if( memo.count(key) )
+			return memo[key];
+
+		LL np = 0;
+		for(int i=0; i<cs.size(); ++i)
+			if( cs[i] && i!=forbidden ) {
+				cs[i]--;
+				np = ADD(np, num_perm( cs, i, n-1 ));
+				cs[i]++;
+			}
+		return memo[key] = np;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arr0[] = {-1,0,1,2,3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 10; int Arg2 = 120; verify_case(0, Arg2, count(Arg0, Arg1)); }
+	void test_case_1() { int Arr0[] = {6,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 0; verify_case(1, Arg2, count(Arg0, Arg1)); }
+	void test_case_2() { int Arr0[] = {1,2,3,4}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 12; verify_case(2, Arg2, count(Arg0, Arg1)); }
+	void test_case_3() { int Arr0[] = {4,6,8,-3,7}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 12; verify_case(3, Arg2, count(Arg0, Arg1)); }
+	void test_case_4() {
+ int Arr0[] = {0,1,2,3,4,5,6,7,8,9,
+10,11,12,13,14,15,16,17,18,19,
+20,21,22,23,24,25,26,27,28,29};
+vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0])));
+ int Arg1 = 15; int Arg2 = 12; verify_case(4, Arg2, count(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { PSequence().run_test(-1); }
+// END CUT HERE

ADDED   SRM/428/1A.cpp
Index: SRM/428/1A.cpp
==================================================================
--- SRM/428/1A.cpp
+++ SRM/428/1A.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+class TheLuckyString
+{
+public:
+	int count(string s) 
+	{
+		int cnt = 0;
+
+		sort(s.begin(), s.end());
+		do
+			if( adjacent_find(s.begin(), s.end()) == s.end() )
+				++cnt;
+		while( next_permutation(s.begin(), s.end()) );
+
+		return cnt;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { string Arg0 = "ab"; int Arg1 = 2; verify_case(0, Arg1, count(Arg0)); }
+	void test_case_1() { string Arg0 = "aaab"; int Arg1 = 0; verify_case(1, Arg1, count(Arg0)); }
+	void test_case_2() { string Arg0 = "aabbbaa"; int Arg1 = 1; verify_case(2, Arg1, count(Arg0)); }
+	void test_case_3() { string Arg0 = "abcdefghij"; int Arg1 = 3628800; verify_case(3, Arg1, count(Arg0)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { TheLuckyString().run_test(-1); }
+// END CUT HERE

ADDED   SRM/428/1B.cpp
Index: SRM/428/1B.cpp
==================================================================
--- SRM/428/1B.cpp
+++ SRM/428/1B.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+using namespace std;
+typedef long long LL;
+
+static const LL MODVAL = 1234567891;
+
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL POW(LL x, LL e) {
+	LL v = 1;
+	for(;e;x=MUL(x,x),e>>=1)
+		if(e&1)
+			v = MUL(v, x);
+	return v;
+}
+LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
+LL C(LL n, LL k) {
+	LL v = 1;
+	for(LL i=1; i<=k; ++i)
+		v = DIV(MUL(v, n-i+1), i);
+	return v;
+}
+LL GSS(LL k, LL b, LL e) // k^b + k^b+1 + ... + k^e
+{
+	if( b >  e ) return 0;
+	if( k <= 1 ) return k*(e-b+1);
+	return DIV(SUB(POW(k, e+1), POW(k,b)), k-1);
+}
+
+class TheLongPalindrome
+{
+public:
+	int count(int n, int k) 
+	{
+		LL ans = 0;
+		for(int i=1; i<=k; ++i)
+		{
+			LL aa = f(i,i,n);
+			for(int j=i-1; j>=1; --j)
+				aa = (i-j)%2
+				  ? SUB(aa, MUL(f(j,i,n), C(i,j)))
+				  : ADD(aa, MUL(f(j,i,n), C(i,j)));
+			ans = ADD(ans, MUL(aa, C(26,i)));
+		}
+		return ans;
+	}
+
+	LL f(LL i, LL b, LL n) // i^b + i^b + i^b+1 + i^b+1 + ... + (nth)
+	{
+		LL v = MUL(GSS(i, b, n/2), 2);
+		if( n%2 == 1 )
+			v = ADD(v, POW(i, n/2+1));
+		return v;
+	}
+
+// BEGIN CUT HERE
+	public:
+	void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
+	private:
+	template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+	void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
+	void test_case_0() { int Arg0 = 1; int Arg1 = 1; int Arg2 = 26; verify_case(0, Arg2, count(Arg0, Arg1)); }
+	void test_case_1() { int Arg0 = 2; int Arg1 = 10; int Arg2 = 52; verify_case(1, Arg2, count(Arg0, Arg1)); }
+	void test_case_2() { int Arg0 = 3; int Arg1 = 2; int Arg2 = 728; verify_case(2, Arg2, count(Arg0, Arg1)); }
+	void test_case_3() { int Arg0 = 44; int Arg1 = 7; int Arg2 = 240249781; verify_case(3, Arg2, count(Arg0, Arg1)); }
+
+// END CUT HERE
+};
+// BEGIN CUT HERE 
+int main() { TheLongPalindrome().run_test(-1); }
+// END CUT HERE

ADDED   SRM/428/1C.cpp
Index: SRM/428/1C.cpp
==================================================================
--- SRM/428/1C.cpp
+++ SRM/428/1C.cpp
@@ -0,0 +1,129 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cstring>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+char memo[81*81*81*81];
+int  n, X[16];
+static const char NIL = 99;
+
+bool win[243];
+
+class TheStringGame
+{
+public:
+	string winner(string s) 
+	{
+		// construct the winning condition table
+		for(int mm=0; mm<243; ++mm)
+			win[mm] = (mm/ 9%3==0 &&
+					(  mm/81%3==2 && mm/27%3==1     // LOX
+					|| mm/27%3==2 && mm/ 3%3==2     //  LXL
+					|| mm/ 3%3==1 && mm/ 1%3==2 )); //   XOL
+
+		// read the input
+		int m=0, numX=0;
+		{
+			memset(memo, NIL, sizeof(memo));
+			n = s.size();
+			for(int i=0; i<n; ++i) {
+				m *= 3;
+				for(int j=0; j<numX; ++j)
+					X[j] *= 3;
+	
+				if( s[i]=='X' )
+					X[numX++] = 1;
+				else
+					m += (s[i]=='O' ? 1 : 2);
+			}
+		}
+
+		// solve
+		if( int r = negaMax(m, numX) )
+		{
+			stringstream sout;
+			sout << (r>0 ? "John" : "Brus") << " " << numX-abs(r)+1;
+			return sout.str();
+		}
+		return "Draw";
+	}
+
+	static int rev(int m)
+	{
+		int z = 0;
+		for(int i=0; i<n; ++i)
+			z = z*3 + m%3, m/=3;
+		return z;
+	}
+
+	static char negaMax(int m, int numX)
+	{
+		if( numX == 0 )
+			return 0;
+		if( memo[m] != NIL )
+			return memo[m];
+
+		for(int j=0; j<numX; ++j)
+			if( win[m*9/X[j]%243] )
+				return memo[m] = numX;
+
+		int sc = -numX;
+		for(int j=0; j<numX; ++j) {
+			int M = X[j];
+			swap(X[j], X[numX-1]);
+			sc = max(sc, -negaMax(m+M*1, numX-1));
+			sc = max(sc, -negaMax(m+M*2, numX-1));
+			swap(X[j], X[numX-1]);
+		}
+		return memo[m] = memo[rev(m)] = sc;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string s = "XXOXXXLXLX"; 
+	string RetVal = "John 1"; 
+	return verify_case(RetVal, TheStringGame().winner(s)); }
+int Test_(Case_<1>) {
+	string s = "LXXLXXL"; 
+	string RetVal = "Brus 2"; 
+	return verify_case(RetVal, TheStringGame().winner(s)); }
+int Test_(Case_<2>) {
+	string s = "LLOOLLOOLLOOLLOO"; 
+	string RetVal = "Draw"; 
+	return verify_case(RetVal, TheStringGame().winner(s)); }
+int Test_(Case_<3>) {
+	string s = "XXXXXXXXXXXXXXXX"; 
+	string RetVal = "Brus 16"; 
+	return verify_case(RetVal, TheStringGame().winner(s)); }
+int Test_(Case_<4>) {
+	string s = "XXXXXXXXXXXXXXXO"; 
+	string RetVal = "John 15"; 
+	return verify_case(RetVal, TheStringGame().winner(s)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE

ADDED   SRM/429/1A.cpp
Index: SRM/429/1A.cpp
==================================================================
--- SRM/429/1A.cpp
+++ SRM/429/1A.cpp
@@ -0,0 +1,72 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class SubrectanglesOfTable
+{
+public:
+	vector<long long> getQuantity(vector <string> table) 
+	{
+		for(int i=0,n=table.size(); i<n; ++i)
+			table.push_back( table[i]+=table[i] );
+
+		vector<LL> ans(26);
+
+		LL Y = table.size(), X = table[0].size();
+		for(LL y=0; y<Y; ++y)
+			for(LL x=0; x<X; ++x)
+				ans[table[y][x]-'A'] += (y+1)*(x+1)*(Y-y)*(X-x);
+		return ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector<long long> &Expected, const vector<long long> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string table_[] = {"OK"};
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	long RetVal_[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+	  vector<long long> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SubrectanglesOfTable().getQuantity(table)); }
+int Test_(Case_<1>) {
+	string table_[] = {"GOOD", "LUCK"};
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	long RetVal_[] = {0, 0, 320, 280, 0, 0, 280, 0, 0, 0, 280, 280, 0, 0, 640, 0, 0, 0, 0, 0, 320, 0, 0, 0, 0, 0 };
+	  vector<long long> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SubrectanglesOfTable().getQuantity(table)); }
+int Test_(Case_<2>) {
+	string table_[] = {"TANYA",
+ "HAPPY",
+ "BIRTH",
+ "DAYYY"};
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	long RetVal_[] = {5168, 1280, 0, 1120, 0, 0, 0, 2560, 1472, 0, 0, 0, 0, 1344, 0, 3008, 0, 1536, 0, 2592, 0, 0, 0, 0, 6320, 0 };
+	  vector<long long> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SubrectanglesOfTable().getQuantity(table)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/429/1B.cpp
Index: SRM/429/1B.cpp
==================================================================
--- SRM/429/1B.cpp
+++ SRM/429/1B.cpp
@@ -0,0 +1,112 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+LL gcd(LL a, LL b)
+{
+	while(a) swap(a, b%=a); return b;
+}
+LL lcm(LL a, LL b)
+{
+	return a/gcd(a,b)*b;
+}
+
+class IngredientProportions
+{
+public:
+	vector <int> getMasses(vector <string> proportions) 
+	{
+		int N = proportions.size() + 1;
+		vector<LL> a(N-1),b(N-1),p(N-1),q(N-1);
+
+		for(int i=0; i<proportions.size(); ++i)
+		{
+			stringstream sin(proportions[i]);
+			sin.get();//#
+			sin>>a[i];
+			sin.get();sin.get();sin.get();sin.get();sin.get();sin.get();//" and #"
+			sin>>b[i];
+			sin.get();sin.get();sin.get();sin.get();//" as "
+			sin>>p[i];
+			sin.get(); //:
+			sin>>q[i];
+		}
+
+		vector<LL> g(N, -1); g[0]=1;
+		for(int _=0; _<N; ++_)
+			for(int i=0; i<N-1; ++i)
+			{
+				LL A=a[i],B=b[i],P=p[i],Q=q[i];
+				if( g[A]==-1 && g[B]!=-1 )
+					swap(A,B), swap(P,Q);
+				if( g[A]!=-1 && g[B]==-1 )
+				{
+					LL f = lcm(g[A],P) / g[A];
+					for(int j=0; j<N; ++j)
+						if( g[j] != -1 )
+							g[j] *= f;
+					g[B] = g[A]/P*Q;
+				}
+			}
+		LL gg = accumulate( g.begin(), g.end(), g.back(), gcd );
+		vector<int> ans(N);
+		for(int i=0; i<N; ++i)
+			ans[i] = g[i]/gg;
+		return ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string proportions_[] = {"#0 and #1 as 6:4"};
+	  vector <string> proportions(proportions_, proportions_+sizeof(proportions_)/sizeof(*proportions_)); 
+	int RetVal_[] = {3, 2 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, IngredientProportions().getMasses(proportions)); }
+int Test_(Case_<1>) {
+	string proportions_[] = {"#0 and #1 as 9:8","#1 and #2 as 9:8"}
+;
+	  vector <string> proportions(proportions_, proportions_+sizeof(proportions_)/sizeof(*proportions_)); 
+	int RetVal_[] = {81, 72, 64 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, IngredientProportions().getMasses(proportions)); }
+int Test_(Case_<2>) {
+	string proportions_[] = {"#4 and #0 as 1:1", "#4 and #1 as 3:1", "#4 and #2 as 5:1", "#4 and #3 as 7:1"};
+	  vector <string> proportions(proportions_, proportions_+sizeof(proportions_)/sizeof(*proportions_)); 
+	int RetVal_[] = {105, 35, 21, 15, 105 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, IngredientProportions().getMasses(proportions)); }
+int Test_(Case_<3>) {
+	string proportions_[] = {"#2 and #3 as 6:8", "#0 and #1 as 9:3", "#3 and #0 as 7:5"};
+	  vector <string> proportions(proportions_, proportions_+sizeof(proportions_)/sizeof(*proportions_)); 
+	int RetVal_[] = {60, 20, 63, 84 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, IngredientProportions().getMasses(proportions)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/429/1C.cpp
Index: SRM/429/1C.cpp
==================================================================
--- SRM/429/1C.cpp
+++ SRM/429/1C.cpp
@@ -0,0 +1,173 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class SpecificPolyominoCovering
+{
+public:
+	vector <string> findCovering(vector <string> region) 
+	{
+		try {
+			rec(0, 0, region);
+		} catch( vector<string>& r ) {
+			return r;
+		}
+		return vector<string>();
+	}
+
+	bool nextX(int &y, int &x, vector<string>& r)
+	{
+		while( r[y][x] != 'X' ) {
+			++x;
+			if( x == r[y].size() ) {
+				x=0, ++y;
+				if( y == r.size() )
+					return false;
+			}
+		}
+		return true;
+	}
+
+	bool canFill( vector<string> r )
+	{
+		return canFill_rec(0, 0, r);
+	}
+
+	bool canFill_rec(int y, int x, vector<string>& r)
+	{
+		if( !nextX(y, x, r) )
+			return true;
+
+		// if it was the pattern fillable both by B and A,
+		//     XX?X
+		//     XXXX
+		// then, if we can fill starting from A it implies ?=X
+		// In this case, we must have been able to fill starting
+		// from B. Thus, we never need to try A if we've failed
+		// filling by B. The "lexicographically first" will by
+		// considered elsewhere.
+
+		if( x+1 < r[y].size() && r[y][x+1]=='X' )
+		{
+			r[y][x] = r[y][x+1] = 'B';
+			return canFill_rec(y, x, r);
+		}
+
+		if( x+3 < r[y].size() && y+1 < r.size() )
+		{
+			int py[] = {0,0,1,1,1,1};
+			int px[] = {0,3,0,1,2,3};
+			for(int i=0; i<6; ++i)
+				if( r[y+py[i]][x+px[i]]!='X' )
+					return false;
+				else
+					r[y+py[i]][x+px[i]] = 'A';
+			return canFill_rec(y, x, r);
+		}
+
+		return false;
+	}
+
+	void rec(int y, int x, vector<string>& r)
+	{
+		if( !nextX(y, x, r) )
+			throw r;
+
+		// try to fill by A
+		if( x+3 < r[y].size() && y+1 < r.size() )
+		{
+			int py[] = {0,0,1,1,1,1};
+			int px[] = {0,3,0,1,2,3};
+			bool bad = false;
+			for(int i=0; i<6; ++i)
+				if( r[y+py[i]][x+px[i]]!='X' )
+					bad = true;
+			if( !bad )
+			{
+				for(int i=0; i<6; ++i)
+					r[y+py[i]][x+px[i]] = 'A';
+				if( canFill(r) )
+					rec(y, x, r);
+				for(int i=0; i<6; ++i)
+					r[y+py[i]][x+px[i]] = 'X';
+			}
+		}
+		// try to fill by B
+		if( x+1 < r[y].size() && r[y][x+1]=='X' )
+		{
+			r[y][x] = r[y][x+1] = 'B';
+			rec(y, x, r);
+			r[y][x] = r[y][x+1] = '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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string region_[] = {"XXXX",
+ "XXXX"};
+	  vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_)); 
+	string RetVal_[] = {"ABBA", "AAAA" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
+int Test_(Case_<1>) {
+	string region_[] = {"X..XXXX..X",
+ "XXXX..XXXX"};
+	  vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_)); 
+	string RetVal_[] = {"A..ABBA..A", "AAAA..AAAA" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
+int Test_(Case_<2>) {
+	string region_[] = {"XXXXXX",
+ "XXXXXX",
+ "XXXXXX"};
+	  vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_)); 
+	string RetVal_[] = {"ABBABB", "AAAABB", "BBBBBB" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
+int Test_(Case_<3>) {
+	string region_[] = {"X..XX",
+ "XXXXX"};
+	  vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_)); 
+	vector <string> RetVal; 
+	return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
+int Test_(Case_<4>) {
+	string region_[] = {"XXXXXXXXXX",
+ "XXXXXXXXXX",
+ "XXXXXXXXXX",
+ "XXXXX..XXX",
+ "XXXXXXXXXX",
+ "XXXXXXXXXX",
+ "XXXXXXXXXX"};
+	  vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_)); 
+	string RetVal_[] = {"ABBAABBABB", "AAAAAAAABB", "ABBABBBBBB", "AAAAA..ABB", "ABBAAAAABB", "AAAAABBABB", "BBBBAAAABB" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/430/1A.cpp
Index: SRM/430/1A.cpp
==================================================================
--- SRM/430/1A.cpp
+++ SRM/430/1A.cpp
@@ -0,0 +1,66 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class BitwiseEquations
+{
+public:
+	long long kthPlusOrSolution(int x, int k) 
+	{
+		LL y = 0;
+		for(LL i=1; k; i<<=1)
+			if( !(x&i) )
+				y |= (k&1)*i, k>>=1;
+		return y;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int x = 5; 
+	int k = 1; 
+	long long RetVal = 2LL; 
+	return verify_case(RetVal, BitwiseEquations().kthPlusOrSolution(x, k)); }
+int Test_(Case_<1>) {
+	int x = 5; 
+	int k = 5; 
+	long long RetVal = 18LL; 
+	return verify_case(RetVal, BitwiseEquations().kthPlusOrSolution(x, k)); }
+int Test_(Case_<2>) {
+	int x = 10; 
+	int k = 3; 
+	long long RetVal = 5LL; 
+	return verify_case(RetVal, BitwiseEquations().kthPlusOrSolution(x, k)); }
+int Test_(Case_<3>) {
+	int x = 1; 
+	int k = 1000000000; 
+	long long RetVal = 2000000000LL; 
+	return verify_case(RetVal, BitwiseEquations().kthPlusOrSolution(x, k)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/430/1B.cpp
Index: SRM/430/1B.cpp
==================================================================
--- SRM/430/1B.cpp
+++ SRM/430/1B.cpp
@@ -0,0 +1,168 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+int INF = 10000000;
+
+class TwinTowns
+{
+public:
+	vector <int> optimalTwinTowns(vector <int> x, vector <int> y, int maxPartners, int minDistance) 
+	{
+		int N = x.size();
+		int cost[10][10];
+		for(int i=0; i<N; ++i)
+		for(int j=0; j<N; ++j)
+		{
+			int d = abs(x[i]-x[j]) + abs(y[i]-y[j]);
+			cost[i][j] = (d < minDistance ? INF : d);
+		}
+
+		vector<int> v(N, maxPartners);
+		pair<int,int> r = rec(0, N, v, cost);
+		vector<int> ans(2);
+		ans[0] = -r.first;
+		ans[1] = r.second;
+		return ans;
+	}
+
+	map< vector<int>,pair<int,int> > memo;
+	pair<int,int> rec(int i, int N, vector<int>& v, int cost[10][10])
+	{
+		if( i==N )
+			return make_pair(0, 0);
+		vector<int> key(v.begin()+i, v.end());
+		if( memo.count(key) )
+			return memo[key];
+
+		// choose at most v[i] js s.t. cost[i][j]!=INF && v[j]!=0
+		pair<int,int> best = rec(i+1, N, v, cost);
+		if( v[i] >= 1 )
+		{
+			for(int j1= i+1; j1<N; ++j1) if(cost[i][j1]!=INF && v[j1])
+			{
+				v[j1]--;
+				pair<int,int> a = rec(i+1, N, v, cost);
+				a.first  -= 1;
+				a.second += cost[i][j1];
+				best = min(best, a);
+				v[j1]++;
+			}
+		}
+		if( v[i] >= 2 )
+		{
+			for(int j1= i+1; j1<N; ++j1) if(cost[i][j1]!=INF && v[j1])
+			for(int j2=j1+1; j2<N; ++j2) if(cost[i][j2]!=INF && v[j2])
+			{
+				v[j1]--;
+				v[j2]--;
+				pair<int,int> a = rec(i+1, N, v, cost);
+				a.first  -= 2;
+				a.second += cost[i][j1] + cost[i][j2];
+				best = min(best, a);
+				v[j1]++;
+				v[j2]++;
+			}
+		}
+		if( v[i] >= 3 )
+		{
+			for(int j1= i+1; j1<N; ++j1) if(cost[i][j1]!=INF && v[j1])
+			for(int j2=j1+1; j2<N; ++j2) if(cost[i][j2]!=INF && v[j2])
+			for(int j3=j2+1; j3<N; ++j3) if(cost[i][j3]!=INF && v[j3])
+			{
+				v[j1]--;
+				v[j2]--;
+				v[j3]--;
+				pair<int,int> a = rec(i+1, N, v, cost);
+				a.first  -= 3;
+				a.second += cost[i][j1] + cost[i][j2] + cost[i][j3];
+				best = min(best, a);
+				v[j1]++;
+				v[j2]++;
+				v[j3]++;
+			}
+		}
+
+		return memo[key] = best;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int x_[] = {0,0,10};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,10,4};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int maxPartners = 1; 
+	int minDistance = 1; 
+	int RetVal_[] = {1, 10 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
+int Test_(Case_<1>) {
+	int x_[] = {0,0,10};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,10,4};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int maxPartners = 1; 
+	int minDistance = 11; 
+	int RetVal_[] = {1, 14 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
+int Test_(Case_<2>) {
+	int x_[] = {0,10,0,10};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,0,20,20};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int maxPartners = 1; 
+	int minDistance = 1; 
+	int RetVal_[] = {2, 20 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
+int Test_(Case_<3>) {
+	int x_[] = {0,10,0,10};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,0,20,20};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int maxPartners = 2; 
+	int minDistance = 10; 
+	int RetVal_[] = {4, 60 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
+int Test_(Case_<4>) {
+	int x_[] = {0,0,0,0,0,0,0,0,0};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,2,3,4,5,6,7,8,9};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int maxPartners = 3; 
+	int minDistance = 6; 
+	int RetVal_[] = {6, 40 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/430/1C.cpp
Index: SRM/430/1C.cpp
==================================================================
--- SRM/430/1C.cpp
+++ SRM/430/1C.cpp
@@ -0,0 +1,143 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <functional>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+typedef LL BITS;
+
+class PickingUp
+{
+public:
+	vector<int> fairPickingUp(vector<long long> score1, vector<long long> score2) 
+	{
+		LL t = accumulate(score2.begin(), score2.end(), 0LL);
+		vector<LL> s;
+		transform(score1.begin(), score1.end(), score2.begin(), back_inserter(s), plus<LL>());
+
+		int N = s.size() / 2;
+
+		vector< map<LL,BITS> > L = try_all( s.begin(), N );
+		vector< map<LL,BITS> > R = try_all( s.begin()+N, N );
+
+		pair<LL, BITS> best(0x7fffffffffffffffLL, 0);
+		for(int i=0; i<=N; ++i)
+			best = min(best, best_possible( L[i], R[N-i], t, N ));
+
+		vector<int> ans;
+		for(int i=0; i!=s.size(); ++i)
+			ans.push_back( (-best.second & (1LL<<s.size()-1-i)) ? 1 : 2 );
+		return ans;
+	}
+
+	pair<LL, BITS> best_possible( map<LL,BITS>& L, map<LL,BITS>& R, LL t, int N )
+	{
+		typedef map<LL,BITS>::iterator mit;
+
+		pair<LL, BITS> best(0x7fffffffffffffffLL, 0);
+		for(mit i=L.begin(); i!=L.end(); ++i)
+		{
+			LL as = i->first;
+			LL am = i->second;
+			mit j = R.lower_bound(t-as);
+			if( j!=R.end() ) {
+				LL bs = j->first;
+				LL bm = j->second;
+				best = min(best, make_pair(abs(as+bs-t), -((am<<N)|bm)));
+			}
+			if( j!=R.begin() ) {
+				--j;
+				LL bs = j->first;
+				LL bm = j->second;
+				best = min(best, make_pair(abs(as+bs-t), -((am<<N)|bm)));
+			}
+		}
+
+		return best;
+	}
+
+	template<typename Ite>
+	vector< map<LL,BITS> > try_all( Ite s, int N )
+	{
+		vector< map<LL,BITS> > a(N+1);
+		for(BITS m=(1<<N)-1; m>=0; --m)
+		{
+			int nb = 0;
+			LL  sm = 0;
+			for(int i=0; i<N; ++i)
+				if( m & (1LL<<N-1-i) )
+					++nb, sm+=*(s+i);
+			if( !a[nb].count(sm) )
+				a[nb][sm] = m;
+		}
+		return a;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	long score1_[] = {5,9};
+	  vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_)); 
+	long score2_[] = {8,6};
+	  vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_)); 
+	int RetVal_[] = {1, 2 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
+int Test_(Case_<1>) {
+	long score1_[] = {2,3,4,7};
+	  vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_)); 
+	long score2_[] = {2,4,5,8};
+	  vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_)); 
+	int RetVal_[] = {1, 2, 2, 1 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
+int Test_(Case_<2>) {
+	long score1_[] = {1,5,6,8};
+	  vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_)); 
+	long score2_[] = {7,5,3,1};
+	  vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_)); 
+	int RetVal_[] = {1, 2, 1, 2 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
+int Test_(Case_<3>) {
+	long score1_[] = {300,300,300,300};
+	  vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_)); 
+	long score2_[] = {600,10,10,10};
+	  vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_)); 
+	int RetVal_[] = {2, 1, 1, 2 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
+int Test_(Case_<4>) {
+	long score1_[] = {50,50,50,1};
+	  vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_)); 
+	long score2_[] = {30,30,30,150};
+	  vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_)); 
+	int RetVal_[] = {1, 2, 2, 1 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/431/1A.cpp
Index: SRM/431/1A.cpp
==================================================================
--- SRM/431/1A.cpp
+++ SRM/431/1A.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+
+class LaserShooting
+{
+public:
+	double numberOfHits(vector <int> x, vector <int> y1, vector <int> y2) 
+	{
+		double ans = 0.0;
+		for(int i=0; i<x.size(); ++i)
+		{
+			double a1 = atan2(min(y1[i],y2[i]), x[i]);
+			double a2 = atan2(max(y1[i],y2[i]), x[i]);
+			ans += (a2-a1) / M_PI;
+		}
+		return ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int x_[] = {1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y1_[] = {-1};
+	  vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_)); 
+	int y2_[] = {1};
+	  vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_)); 
+	double RetVal = 0.5; 
+	return verify_case(RetVal, LaserShooting().numberOfHits(x, y1, y2)); }
+int Test_(Case_<1>) {
+	int x_[] = {1,2};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y1_[] = {-1,-2};
+	  vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_)); 
+	int y2_[] = {1,2};
+	  vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_)); 
+	double RetVal = 1.0; 
+	return verify_case(RetVal, LaserShooting().numberOfHits(x, y1, y2)); }
+int Test_(Case_<2>) {
+	int x_[] = {3,4,7,1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y1_[] = {1,2,3,4};
+	  vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_)); 
+	int y2_[] = {4,3,2,1};
+	  vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_)); 
+	double RetVal = 0.4623163952488826; 
+	return verify_case(RetVal, LaserShooting().numberOfHits(x, y1, y2)); }
+int Test_(Case_<3>) {
+	int x_[] = {134,298,151,942};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y1_[] = {-753,-76,19,568};
+	  vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_)); 
+	int y2_[] = {440,689,-39,672};
+	  vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_)); 
+	double RetVal = 1.444210260641501; 
+	return verify_case(RetVal, LaserShooting().numberOfHits(x, y1, y2)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/431/1B.cpp
Index: SRM/431/1B.cpp
==================================================================
--- SRM/431/1B.cpp
+++ SRM/431/1B.cpp
@@ -0,0 +1,89 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+static const LL MODVAL = 1000000007;
+int memo[10][11][1001][9];
+
+class MegaCoolNumbers
+{
+public:
+	int count(int N, int A)
+	{
+		memset(memo, -1, sizeof(memo));
+		return rec(1, 10, N, A);
+	}
+
+	int rec(int D, int F, int N, int A)
+	{
+		if( A==0 )     return N==0 ? 1 : 0;
+		if( N < A )    return 0;
+		if( N==1 )     return 10-D - (F==10 ? 0 : 1);
+		if( 10-D < A ) return 0;
+		if( memo[D][F][N][A] != -1 )
+			return memo[D][F][N][A];
+
+		LL ans = 0;
+		for(int d=D; d<=9; ++d) if(d!=F)
+			for(int k=2; k<=N; ++k)
+				for(int q=0; d+(k-1)*q<=9; ++q)
+					ans += rec(d+(k-1)*q, min(10, d+k*q), N-k, A-1);
+		return memo[D][F][N][A] = int(ans % MODVAL);
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int N = 1; 
+	int A = 1; 
+	int RetVal = 9; 
+	return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
+int Test_(Case_<1>) {
+	int N = 2; 
+	int A = 1; 
+	int RetVal = 45; 
+	return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
+int Test_(Case_<2>) {
+	int N = 2; 
+	int A = 2; 
+	int RetVal = 0; 
+	return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
+int Test_(Case_<3>) {
+	int N = 10; 
+	int A = 3; 
+	int RetVal = 7502; 
+	return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
+int Test_(Case_<4>) {
+	int N = 1000; 
+	int A = 5; 
+	int RetVal = 7502; 
+	return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/431/1C.cpp
Index: SRM/431/1C.cpp
==================================================================
--- SRM/431/1C.cpp
+++ SRM/431/1C.cpp
@@ -0,0 +1,198 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#include <cstdlib>
+using namespace std;
+typedef long long LL;
+
+template<typename T>
+struct RMQ
+{
+	vector< vector<int> > rm;
+	T*  d;
+	int n;
+
+	RMQ( T* d, int n ) : d(d), n(n) {
+		rm.push_back( vector<int>(n) );
+		for(int x=0; x<n; ++x)
+			rm[0][x] = x;
+		for(int k=1; (1<<k)<=n; ++k) {
+			rm.push_back( rm[k-1] );
+			for(int x=0; x+(1<<k-1)<n; ++x)
+				if( d[rm[k][x]] > d[rm[k-1][x + (1<<k-1)]] )
+					rm[k][x] = rm[k-1][x + (1<<k-1)];
+		}
+	}
+
+	int operator()(int L, int R) const {
+		int k=0;
+		for(; L+(1<<k) < R-(1<<k)+1; ++k) {}
+		LL i = rm[k][L];
+		LL j = rm[k][R-(1<<k)+1];
+		return (d[i]<=d[j] ? i : j);
+	}
+
+	vector<int> all(int L, int R) const {
+		vector<int> ans;
+		int minValue = d[(*this)(L, R)];
+		while( L <= R ) {
+			int C = (*this)(L, R);
+			if( minValue < d[C] )
+				break;
+			ans.push_back(C);
+			L = C+1;
+		}
+		return ans;
+	}
+};
+
+int B[2048][2048];
+int U[2048][2048];
+int D[2048][2048];
+
+class PerfectRectangles
+{
+public:
+	int numberOfRectangles(int N, int M, int X0, int A, int _B, int Y0, int C, int _D) 
+	{
+		// input
+		int x=X0%N, y=Y0%N;
+		memset(B, 0, sizeof(B));
+		for(int i=0; i<M; ++i) {
+			B[x][y] = 1;
+			x = (x*A+_B)%N;
+			y = (y*C+_D)%N;
+		}
+
+		// up
+		for(int y=0; y<N; ++y)
+			for(int x=0; x<N; ++x)
+				U[y][x] = (B[y][x] ? 0 : y==0 ? 1 : U[y-1][x]+1);
+
+		// down
+		for(int y=N-1; y>=0; --y)
+			for(int x=0; x<N; ++x)
+				D[y][x] = (B[y][x] ? 0 : y==N-1 ? 1 : D[y+1][x]+1);
+
+		// solve
+		int cnt = 0;
+		for(int y=0; y<N; ++y) {
+			RMQ<int> rmU(U[y], N);
+			RMQ<int> rmD(D[y], N);
+
+			stack< pair<int,int> > S;
+			S.push( make_pair(0, N-1) );
+			while( !S.empty() ) {
+				int L = S.top().first;
+				int R = S.top().second;
+				S.pop();
+
+				int d = rmD(L,R);
+				if( D[y][d] == 1 )
+					++cnt;
+				if( D[y][d] <= 1 ) {
+					vector<int> m = rmU.all(L, R);
+					m.push_back(R+1);
+					for(int i=0; i<m.size(); L=m[i++]+1)
+						if( L <= m[i]-1 )
+							S.push( make_pair(L, m[i]-1) );
+				}
+			}
+		}
+		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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int N = 5; 
+	int M = 1; 
+	int X0 = 2; 
+	int A = 0; 
+	int B = 0; 
+	int Y0 = 2; 
+	int C = 0; 
+	int D = 0; 
+	int RetVal = 4; 
+	return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
+int Test_(Case_<1>) {
+	int N = 4; 
+	int M = 4; 
+	int X0 = 0; 
+	int A = 1; 
+	int B = 1; 
+	int Y0 = 0; 
+	int C = 1; 
+	int D = 1; 
+	int RetVal = 6; 
+	return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
+int Test_(Case_<2>) {
+	int N = 1; 
+	int M = 1000000; 
+	int X0 = 1; 
+	int A = 2; 
+	int B = 3; 
+	int Y0 = 1; 
+	int C = 4; 
+	int D = 7; 
+	int RetVal = 0; 
+	return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
+int Test_(Case_<3>) {
+	int N = 10; 
+	int M = 20; 
+	int X0 = 4; 
+	int A = 76; 
+	int B = 2; 
+	int Y0 = 6; 
+	int C = 2; 
+	int D = 43; 
+	int RetVal = 12; 
+	return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
+int Test_(Case_<4>) {
+	int N = 1999; 
+	int M = 4000000; 
+	int X0 = 1000; 
+	int A = 1; 
+	int B = 1; 
+	int Y0 = 0; 
+	int C = 1; 
+	int D = 1; 
+	int RetVal = 1002995; 
+	return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
+int Test_(Case_<5>) {
+	int N = 2000; 
+	int M = 4000000; 
+	int X0 = 1500; 
+	int A = 1; 
+	int B = 1; 
+	int Y0 = 500; 
+	int C = 1; 
+	int D = 1; 
+	int RetVal = 1003997; 
+	return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<> void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/432/1A.cpp
Index: SRM/432/1A.cpp
==================================================================
--- SRM/432/1A.cpp
+++ SRM/432/1A.cpp
@@ -0,0 +1,121 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class LampsGrid {
+public:
+	int curMax;
+
+	int mostLit(vector <string> initial, int K) 
+	{
+		// atama-warui
+		//   only meaningful way to flip lights are
+		//   that: exists i {j | initial[i][j]=='0'}
+		//   so at most initial.size() try is sufficient...
+
+		vector<LL> s;
+		for(int j=0; j<initial[0].size(); ++j) {
+			LL x = 0;
+			for(int i=0; i<initial.size(); ++i)
+				if( initial[i][j]=='1' )
+					x |= (1LL << i);
+			s.push_back(x);
+		}
+
+		curMax = 0;
+		for(; K>=0; K-=2)
+			if( K <= initial[0].size() )
+				rec((1LL<<initial.size())-1, s, 0, K);
+		return curMax;
+	}
+
+	void rec(LL lit, vector<LL> s, int i, int K) // exact K flips
+	{
+		int c = 0;
+		for(LL j=1; j<=lit; j<<=1)
+			if( lit&j )
+				++c;
+		if( c<=curMax )
+			return;
+		if( i == s.size() )
+		{
+			curMax = c;
+			return;
+		}
+
+		if( i+K < s.size() ) // noflip
+			rec( lit&s[i], s, i+1, K );
+		if( K ) // flip
+			rec( lit&~s[i], s, i+1, K-1 );
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string initial_[] = {"01",
+ "10",
+ "10"};
+	  vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_)); 
+	int K = 1; 
+	int RetVal = 2; 
+	return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
+int Test_(Case_<1>) {
+	string initial_[] = {"101010"};
+	  vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_)); 
+	int K = 2; 
+	int RetVal = 0; 
+	return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
+int Test_(Case_<2>) {
+	string initial_[] = {"00", "11"};
+	  vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_)); 
+	int K = 999; 
+	int RetVal = 0; 
+	return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
+int Test_(Case_<3>) {
+	string initial_[] = {"0", "1", "0", "1", "0"}
+;
+	  vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_)); 
+	int K = 1000; 
+	int RetVal = 2; 
+	return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
+int Test_(Case_<4>) {
+	string initial_[] = {"001", "101", "001", "000", "111", "001", "101", "111", "110", "000", "111", "010", "110", "001"};
+	  vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_)); 
+	int K = 6; 
+	int RetVal = 4; 
+	return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
+int Test_(Case_<5>) {
+	string initial_[] = {"01", "10", "01", "01", "10"};
+	  vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_)); 
+	int K = 1; 
+	int RetVal = 3; 
+	return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/432/1B.cpp
Index: SRM/432/1B.cpp
==================================================================
--- SRM/432/1B.cpp
+++ SRM/432/1B.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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class GroupedWord {
+public:
+	string restore(vector <string> parts) 
+	{
+		while( reduce(parts) ) {}
+
+		if( parts.size() == 1 )
+			return gd(parts[0]) ? parts[0] : "IMPOSSIBLE";
+
+		string s = accumulate(parts.begin(), parts.end(), string(""));
+		return gd(s) ? "MANY" : "IMPOSSIBLE";
+	}
+
+	bool reduce( vector<string>& p )
+	{
+		for(int j=0; j<p.size(); ++j) {
+			string& s = p[j];
+
+			char last = s[s.size()-1];
+			for(int i=0; i<p.size(); ++i) if(i!=j)
+				if( count(p[i].begin(), p[i].end(), last) == p[i].size() )
+				{
+					p.push_back(s+p[i]);
+					p.erase(p.begin()+max(i,j));
+					p.erase(p.begin()+min(i,j));
+					return true;
+				}
+
+			for(int i=0; i<p.size(); ++i) if(i!=j)
+				if( p[i][0] == last )
+				{
+					p.push_back(s+p[i]);
+					p.erase(p.begin()+max(i,j));
+					p.erase(p.begin()+min(i,j));
+					return true;
+				}
+		}
+		return false;
+	}
+
+	bool gd(const string& s)
+	{
+		for(int i=0; i<s.size(); )
+		{
+			int j=i;
+			while( j<s.size() && s[i]==s[j] ) ++j;
+			if( s.find(s[i], j)!=string::npos )
+				return false;
+			i=j;
+		}
+		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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string parts_[] = {"aaa", "a", "aa"};
+	  vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_)); 
+	string RetVal = "aaaaaa"; 
+	return verify_case(RetVal, GroupedWord().restore(parts)); }
+int Test_(Case_<1>) {
+	string parts_[] = {"ab", "bba"};
+	  vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_)); 
+	string RetVal = "IMPOSSIBLE"; 
+	return verify_case(RetVal, GroupedWord().restore(parts)); }
+int Test_(Case_<2>) {
+	string parts_[] = {"te", "st"};
+	  vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_)); 
+	string RetVal = "stte"; 
+	return verify_case(RetVal, GroupedWord().restore(parts)); }
+int Test_(Case_<3>) {
+	string parts_[] = {"te", "s", "t"};
+	  vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_)); 
+	string RetVal = "MANY"; 
+	return verify_case(RetVal, GroupedWord().restore(parts)); }
+int Test_(Case_<4>) {
+	string parts_[] = {"orr", "rd", "woo", "www"};
+	  vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_)); 
+	string RetVal = "wwwwooorrrd"; 
+	return verify_case(RetVal, GroupedWord().restore(parts)); }
+int Test_(Case_<5>) {
+	string parts_[] = {"abcb"};
+	  vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_)); 
+	string RetVal = "IMPOSSIBLE"; 
+	return verify_case(RetVal, GroupedWord().restore(parts)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/432/1C.cpp
Index: SRM/432/1C.cpp
==================================================================
--- SRM/432/1C.cpp
+++ SRM/432/1C.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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+struct union_find {
+	vector<int> p, s;
+	union_find(int N) : p(N, -1), s(N, 1) {}
+
+	int repr(int u) {
+		while( p[u]>=0 ) u=p[u];
+		return u;
+	}
+	bool conn(int u, int v) {
+		u = repr(u);
+		v = repr(v);
+		if( u==v ) return false;
+		if( s[u] < s[v] ) { p[u]=v; s[v]+=s[u]; }
+		else              { p[v]=u; s[u]+=s[v]; }
+		return true;
+	}
+};
+
+class BuildersCountry {
+public:
+	long long minCost(vector <int> before, vector <int> after, vector <int> houseCost, vector <string> g, int roadCost) 
+	{
+		int N = before.size();
+
+		LL baseCost = 0;
+
+		vector< vector<LL> > cost(N, vector<LL>(N));
+		for(int i=0; i!=N; ++i)
+			for(int j=i+1; j!=N; ++j)
+{				LL cc = LL(roadCost)*(before[i]+before[j]);
+
+				int mi = houseCost[i]<houseCost[j] ? i : j;
+				int mj = houseCost[i]<houseCost[j] ? j : i;
+				LL cc2 = LL(houseCost[mj])*(after[mj]-before[mj])*before[mi]
+				       + LL(houseCost[mi])*(after[mi]-before[mi])*after[mj];
+
+				cost[i][j] = cost[j][i] = cc+cc2;
+
+				if( g[i][j] == 'Y' )
+					baseCost += cc2;
+			}
+
+		for(int i=0; i!=N; ++i)
+			baseCost += LL(houseCost[i]) * LL(before[i]+after[i]-1) * LL(after[i] - before[i]) / 2;
+		return baseCost + mst(cost, g, N);
+	}
+
+	LL mst(vector<vector<LL> >& c, vector<string>& g, int N)
+	{
+		union_find uf(N);
+		for(int i=0; i!=N; ++i)
+			for(int j=i+1; j!=N; ++j)
+				if( g[i][j]=='Y' )
+					uf.conn(i,j);
+
+		typedef pair<LL,pair<int,int> > cedge;
+		vector<cedge> es;
+		for(int i=0; i!=N; ++i)
+			for(int j=i+1; j!=N; ++j)
+				es.push_back( make_pair( c[i][j], make_pair(i,j) ) );
+		sort(es.begin(), es.end());
+
+		LL cc = 0;
+		for(int i=0; i!=es.size(); ++i)
+		{
+			int u = es[i].second.first;
+			int v = es[i].second.second;
+			LL c = es[i].first;
+			if( uf.conn(u,v) )
+				cc += c;
+		}
+		return cc;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int before_[] = {2, 1, 3, 5};
+	  vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_)); 
+	int after_[] = {2, 1, 3, 5};
+	  vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_)); 
+	int houseCost_[] = {4, 5, 3, 2};
+	  vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_)); 
+	string g_[] = {"NNNN", "NNNN", "NNNN", "NNNN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int roadCost = 1000; 
+	long long RetVal = 13000LL; 
+	return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
+int Test_(Case_<1>) {
+	int before_[] = {1, 1, 1, 1};
+	  vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_)); 
+	int after_[] = {1, 3, 1, 2};
+	  vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_)); 
+	int houseCost_[] = {8, 5, 3, 2};
+	  vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_)); 
+	string g_[] = {"NYNN", "YNYN", "NYNY", "NNYN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int roadCost = 100000; 
+	long long RetVal = 39LL; 
+	return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
+int Test_(Case_<2>) {
+	int before_[] = {9, 11};
+	  vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_)); 
+	int after_[] = {10, 11};
+	  vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_)); 
+	int houseCost_[] = {5, 1};
+	  vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_)); 
+	string g_[] = {"NN", "NN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int roadCost = 15; 
+	long long RetVal = 400LL; 
+	return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
+int Test_(Case_<3>) {
+	int before_[] = {1};
+	  vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_)); 
+	int after_[] = {1000};
+	  vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_)); 
+	int houseCost_[] = {2};
+	  vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_)); 
+	string g_[] = {"N"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int roadCost = 888; 
+	long long RetVal = 999000LL; 
+	return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
+int Test_(Case_<4>) {
+	int before_[] = {99, 23, 44, 55, 32};
+	  vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_)); 
+	int after_[] = {99, 23, 44, 55, 32};
+	  vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_)); 
+	int houseCost_[] = {39, 32, 11, 23, 89};
+	  vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_)); 
+	string g_[] = {"NYNNN", "YNNNY", "NNNYY", "NNYNY", "NYYYN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int roadCost = 54; 
+	long long RetVal = 0LL; 
+	return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/433/1A.cpp
Index: SRM/433/1A.cpp
==================================================================
--- SRM/433/1A.cpp
+++ SRM/433/1A.cpp
@@ -0,0 +1,111 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class MagicWords {
+public:
+	int count(vector <string> S, int K) 
+	{
+		int cnt = 0;
+
+		int idx[] = {0,1,2,3,4,5,6,7};
+		do {
+			string s; for(int i=0; i<S.size(); ++i) s += S[idx[i]];
+
+			if( s.size()%K==0 && rep_of(s, s.size()/K) )
+			{
+				for(int n=1; n<s.size()/K; ++n)
+					if( s.size()%n==0 && rep_of(s, n) )
+						goto fail;
+				++cnt;
+			fail:;
+			}
+		} while( next_permutation(idx+0, idx+S.size()) );
+
+		return cnt;
+	}
+
+	bool rep_of( string& s, int n ) {
+		return s == s.substr(n, s.size()-n) + s.substr(0, n);
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string S_[] = {"CAD","ABRA","ABRA"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int K = 1; 
+	int RetVal = 6; 
+	return verify_case(RetVal, MagicWords().count(S, K)); }
+int Test_(Case_<1>) {
+	string S_[] = {"AB","RAAB","RA"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int K = 2; 
+	int RetVal = 3; 
+	return verify_case(RetVal, MagicWords().count(S, K)); }
+int Test_(Case_<2>) {
+	string S_[] = {"AA","AA","AAA","A"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int K = 1; 
+	int RetVal = 0; 
+	return verify_case(RetVal, MagicWords().count(S, K)); }
+int Test_(Case_<3>) {
+	string S_[] = {"AA","AA","AAA","A","AAA","AAAA"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int K = 15; 
+	int RetVal = 720; 
+	return verify_case(RetVal, MagicWords().count(S, K)); }
+int Test_(Case_<4>) {
+	string S_[] = {"ABC","AB","ABC","CA"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int K = 3; 
+	int RetVal = 0; 
+	return verify_case(RetVal, MagicWords().count(S, K)); }
+int Test_(Case_<5>) {
+	string S_[] = {"A","B","C","A","B","C"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int K = 1; 
+	int RetVal = 672; 
+	return verify_case(RetVal, MagicWords().count(S, K)); }
+int Test_(Case_<6>) {
+	string S_[] = {"AAAAAAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAAAAAA",
+ "AAAAAAAAAAAAAAAAAAAB"};
+	  vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_)); 
+	int K = 1; 
+	int RetVal = 40320; 
+	return verify_case(RetVal, MagicWords().count(S, K)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/433/1B.cpp
Index: SRM/433/1B.cpp
==================================================================
--- SRM/433/1B.cpp
+++ SRM/433/1B.cpp
@@ -0,0 +1,88 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+int gcd(int a, int b) { while(a) swap(a,b%=a); return b; }
+
+class SettingTents {
+public:
+	int countSites(int N, int M) 
+	{
+		int cnt = 0;
+		for(int w=1; w<=N; ++w)     // for each
+			for(int h=1; h<=M; ++h) // bounding box...
+			{
+				int numWH = (N+1-w)*(M+1-h);
+
+				// w/2 - k(h-2j) = x
+				// h/2 + kw      = y
+				for(int j=1; j<h; ++j) // the case when both two diags contribute to the bounds
+					if( (w*w+h*(h-2*j)) % (2*w) == 0 )
+					{
+						int x = (w*w+h*(h-2*j)) / (2*w);
+						if( 0<=x && x<=w )
+							cnt += numWH;
+					}
+
+				for(int y=0; 2*y<h; ++y) // the case when only one diag contribut to the bounds
+					if( (w*w - (2*y-h)*h) % (2*w) == 0 )
+					{
+						int x = (w*w - (2*y-h)*h) / (2*w);
+						if( x<w )
+							cnt += 2*numWH;
+					}
+
+				if( w==h ) // special case
+					cnt += numWH;
+			}
+		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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int N = 2; 
+	int M = 2; 
+	int RetVal = 6; 
+	return verify_case(RetVal, SettingTents().countSites(N, M)); }
+int Test_(Case_<1>) {
+	int N = 1; 
+	int M = 6; 
+	int RetVal = 6; 
+	return verify_case(RetVal, SettingTents().countSites(N, M)); }
+int Test_(Case_<2>) {
+	int N = 6; 
+	int M = 8; 
+	int RetVal = 527; 
+	return verify_case(RetVal, SettingTents().countSites(N, M)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/433/1C.cpp
Index: SRM/433/1C.cpp
==================================================================
--- SRM/433/1C.cpp
+++ SRM/433/1C.cpp
@@ -0,0 +1,231 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL SHIFT = 1000000000LL;
+static const LL INF   = 1000001LL;
+static const LL MAX   = 1000000LL;
+static const int NV = 5002;
+typedef LL            flow;
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+//typedef flow          flow_graph[NV][NV];
+typedef map< vert,map<vert,flow> > flow_graph;
+
+flow dinic_dfs( graph& G, flow_graph& F, vert v, vert D,
+                int LV[], flow flow_in, int blocked[] )
+{
+	flow flow_out = 0;
+	for(int i=0; i!=G[v].size(); ++i) {
+		int u = G[v][i];
+		if( LV[v]+1==LV[u] && F[v][u] ) {
+			flow f = min(flow_in-flow_out, F[v][u]);
+			if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) ) {
+				F[v][u]  -= f;
+				F[u][v]  += f;
+				flow_out += f;
+				if( flow_in == flow_out ) return flow_out;
+			}
+		}
+	}
+	blocked[v] = (flow_out==0);
+	return flow_out;
+}
+
+flow maxFlow( graph& G, flow_graph& F, vert S, vert D )
+{
+	for( flow total=0 ;; ) {
+		int LV[NV] = {0};
+		vector<int> Q(1, S);
+		for(int lv=1; !Q.empty(); ++lv) {
+			vector<int> Q2;
+			for(int i=0; i!=Q.size(); ++i) {
+				edges& ne = G[Q[i]];
+				for(int j=0; j!=ne.size(); ++j)
+					if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
+						LV[ne[j]]=lv, Q2.push_back(ne[j]);
+			}
+			Q.swap(Q2);
+		}
+
+		if( !LV[D] )
+			return total;
+
+		int blocked[NV] = {};
+		total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
+	}
+}
+
+flow_graph F;
+class BarbarianInvasion {
+public:
+	int minimalDetachment(vector <string> countryMap, vector <int> detachmentSize) 
+	{
+		int H = countryMap.size();
+		int W = countryMap[0].size();
+		vert OUT = 0, CAP = 1;
+
+		graph G(H*W*2+2);
+		flow_graph F;
+
+		for(int y=0; y<H; ++y)
+		for(int x=0; x<W; ++x)
+		{
+			if( countryMap[y][x] == '-' )
+				continue;
+
+			vert CUR_A = countryMap[y][x] == '*' ? CAP : (y*W+x)*2+2; // ==>A->B==>
+			vert CUR_B = countryMap[y][x] == '*' ? CAP : (y*W+x)*2+3;
+			if( countryMap[y][x] != '*' && countryMap[y][x] != '-' ) {
+				G[CUR_A].push_back(CUR_B);
+				G[CUR_B].push_back(CUR_A);
+				F[CUR_A][CUR_B] = SHIFT + detachmentSize[countryMap[y][x]-'A'];
+				F[CUR_B][CUR_A] = 0;
+			}
+
+			int DY[] = {-1,+1,0,0}, DX[]={0,0,-1,+1};
+			for(int d=0; d<4; ++d)
+			{
+				int dy = DY[d], dx = DX[d];
+				if( 0<=y+dy && y+dy<H && 0<=x+dx && x+dx<W )
+				{
+					if( countryMap[y+dy][x+dx] == '-' )
+						continue;
+					if( countryMap[y+dy][x+dx] == '*' )
+						continue;
+					vert ADJ_B = ((y+dy)*W+(x+dx))*2+3;
+					G[ADJ_B].push_back(CUR_A);
+					G[CUR_A].push_back(ADJ_B);
+					F[ADJ_B][CUR_A] = SHIFT+INF;
+					F[CUR_A][ADJ_B] = 0;
+				}
+				else
+				{
+					G[OUT].push_back(CUR_A);
+					G[CUR_A].push_back(OUT);
+					F[OUT][CUR_A] = SHIFT+INF;
+					F[CUR_A][OUT] = 0;
+				}
+			}
+		}
+
+		flow mf = maxFlow(G, F, OUT, CAP);
+		return mf%SHIFT;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string countryMap_[] = {"ABA",
+ "A*A",
+ "AAA"};
+	  vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_)); 
+	int detachmentSize_[] = {1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+	  vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_)); 
+	int RetVal = 5; 
+	return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
+int Test_(Case_<1>) {
+	string countryMap_[] = {"CCCC",
+ "-BAC",
+ "-*AC",
+ "--AC"};
+	  vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_)); 
+	int detachmentSize_[] = {5,20,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+	  vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_)); 
+	int RetVal = 25; 
+	return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
+int Test_(Case_<2>) {
+	string countryMap_[] = {"A----A",
+ "-AAAA-",
+ "-AA*A-",
+ "-AAAA-",
+ "A----A"};
+	  vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_)); 
+	int detachmentSize_[] = {9,8,2,5,3,2,1,2,6,10,4,6,7,1,7,8,8,8,2,9,7,6,5,1,5,10};
+	  vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
+int Test_(Case_<3>) {
+	string countryMap_[] = {"-A-----",
+ "-BCCC*-",
+ "-A-----"};
+	  vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_)); 
+	int detachmentSize_[] = {1,5,10,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+	  vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_)); 
+	int RetVal = 5; 
+	return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
+int Test_(Case_<4>) {
+	string countryMap_[] = {"WANNABRUTEFORCEMEHUH",
+ "ASUDQWNHIOCASFIUQISA",
+ "UWQD-ASFFC-AJSQOOWE-",
+ "-----*Y--AVSSFIUQISA",
+ "UWQD-ASFFC-AJSQOOWE-",
+ "JUFDIFD-CHBVISBOOWE-",
+ "WANNABRUTEFORCEMEHUH"};
+	  vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_)); 
+	int detachmentSize_[] = {87,78,20,43,30,12,9,18,57,93,32,60,64,9,69,74,74,78,12,81,63,57,48,8,44,95};
+	  vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_)); 
+	int RetVal = 218; 
+	return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
+int Test_(Case_<5>) {
+	string countryMap_[] = {
+ "WOMP-PVE-LV-NB-J---E",
+ "K--MKNWSOLFKK-JHP--W",
+ "BE-K--MPP-YGZI-DMVKG",
+ "JGWRXQ-UYEROYGC--SZR",
+ "KFYN--CRX*N--JS-M-S-",
+ "TBFGG-OL--D-DY--RR-A",
+ "AMJT-NV--P--XF-YUSBM",
+ "HJ-C--KHU-KDZHERUUHM",
+ "-FGQZOI-A--ZIPB--QOT",
+ "PNLI-RWYZG-MNV-SUNJD",
+ "YJ-EJLD-H---K-HSVZF-",
+ "LKPGZGF-IQ-ETYQJ-VAR",
+ "UGS--V-BOUGG-SMO--Q-",
+ "DFVWRHC-D-XES-MEQMCQ",
+ "L-PUXR-C-HL-WX-NFJJR",
+ "-A-JLUQX--VWPFENHJZ-",
+ "HNG-NQAF-VVCUU-WU-HL"};
+	  vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_)); 
+	int detachmentSize_[] = {
+96882, 90320, 19358, 82732, 80637, //ABCDE
+88638, 43236, 34294, 49732, 86156, //FGHIJ
+ 1186, 84308, 49312, 92789, 49312, //KLMNO
+14324, 27420, 32881, 73865, 91069, //PQRST
+ 7266, 60052, 98451, 84652, 3991, 58948}; //UVWXYZ
+	  vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_)); 
+	int RetVal = 69753; 
+	return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/434-U/1A.cpp
Index: SRM/434-U/1A.cpp
==================================================================
--- SRM/434-U/1A.cpp
+++ SRM/434-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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+bool is_ps( LL v )
+{
+	LL sv = (LL)sqrt( double(v) );
+	return (sv-1)*(sv-1) == v
+	    || sv*sv == v
+	    || (sv+1)*(sv+1) == v;
+}
+
+class FindingSquareInTable {
+public:
+	int findMaximalSquare(vector <string> table) 
+	{
+		LL ans = -1;
+
+		int Y = table.size();
+		int X = table[0].size();
+		for(int y=0; y<Y; ++y)
+			for(int x=0; x<X; ++x)
+				for(int dy=-Y; dy<Y; ++dy)
+					for(int dx=-X; dx<X; ++dx)
+						if(dy||dx)
+						{
+							LL v = 0;
+							for(int i=0;; ++i)
+							{
+								int yy = y+dy*i;
+								int xx = x+dx*i;
+								if( xx<0 || X<=xx || yy<0 || Y<=yy )
+									break;
+								int d = table[yy][xx]-'0';
+								v = v*10 + d;
+								if( is_ps(v) )
+									ans = max(v, ans);
+							}
+						}
+		return ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string table_[] = {"123",
+ "456"};
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	int RetVal = 64; 
+	return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
+int Test_(Case_<1>) {
+	string table_[] = {"00000",
+ "00000",
+ "00200",
+ "00000",
+ "00000"};
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
+int Test_(Case_<2>) {
+	string table_[] = {"3791178",
+ "1283252",
+ "4103617",
+ "8233494",
+ "8725572",
+ "2937261"};
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	int RetVal = 320356; 
+	return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
+int Test_(Case_<3>) {
+	string table_[] = {"135791357",
+ "357913579",
+ "579135791",
+ "791357913",
+ "913579135"}
+;
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	int RetVal = 9; 
+	return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
+int Test_(Case_<4>) {
+	string table_[] = {"553333733",
+ "775337775",
+ "777537775",
+ "777357333",
+ "755553557",
+ "355533335",
+ "373773573",
+ "337373777",
+ "775557777"};
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	int RetVal = -1; 
+	return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
+int Test_(Case_<5>) {
+	string table_[] = {"257240281",
+ "197510846",
+ "014345401",
+ "035562575",
+ "974935632",
+ "865865933",
+ "684684987",
+ "768934659",
+ "287493867"};
+	  vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_)); 
+	int RetVal = 95481; 
+	return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/434-U/1B.cpp
Index: SRM/434-U/1B.cpp
==================================================================
--- SRM/434-U/1B.cpp
+++ SRM/434-U/1B.cpp
@@ -0,0 +1,135 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+static const int N = 60;
+
+typedef vector<int> Num;
+Num conv( const string& s )
+{
+	Num n(N);
+	for(int i=0; i<s.size(); ++i)
+	{
+		char c = s[s.size()-1-i];
+		n[N-1-i] = ('0'<=c&&c<='9' ? c-'0' : c-'A'+10);
+	}
+	return n;
+}
+
+Num add( const Num& a, const Num& b )
+{
+	Num n(N);
+	int c = 0;
+	for(int i=0; i<N; ++i)
+	{
+		int s = a[N-1-i] + b[N-1-i] + c;
+		n[N-1-i] = s%36;
+		c = s/36;
+	}
+	return n;
+}
+
+class HexatridecimalSum {
+public:
+	string maximizeSum(vector <string> numbers, int k) 
+	{
+		vector<Num> ns;
+		transform( numbers.begin(), numbers.end(), back_inserter(ns), &conv );
+
+		vector<Num> gain(36);
+		for(int d=0; d<36; ++d)
+		{
+			vector<int> g(N);
+			for(int i=0; i<ns.size(); ++i)
+				for(int j=0,f=0; j<N; ++j) {
+					if( ns[i][j] ) f=1;
+					if( f && ns[i][j] == d )
+						g[j] += (35-d);
+				}
+			Num gg(N);
+			for(int j=0; j<N; ++j) {
+				int x = g[N-1-j];
+				gg[N-1-j] = x % 36;
+				if(x/36) g[N-1-j-1] += x/36;
+			}
+			gain[d] = gg;
+		}
+		sort( gain.rbegin(), gain.rend() );
+		Num zero(N);
+		Num n = accumulate( gain.begin(), gain.begin()+k, zero, &add );
+		Num m = accumulate( ns.begin(), ns.end(), n, &add );
+
+		string ans;
+		for(int i=0,f=0; i<N; ++i)
+		{
+			if(m[i]) f=1;
+			if(f)
+				if( m[i]<=9 )
+					ans += char(m[i]+'0');
+				else
+					ans += char(m[i]-10+'A');
+		}
+		return ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string numbers_[] = {"HELLO"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	int k = 2; 
+	string RetVal = "ZZLLO"; 
+	return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
+int Test_(Case_<1>) {
+	string numbers_[] = {"500", "POINTS", "FOR", "THIS", "PROBLEM"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	int k = 5; 
+	string RetVal = "1100TC85"; 
+	return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
+int Test_(Case_<2>) {
+	string numbers_[] = {"TO", "BE", "OR", "NOT", "TO", "BE"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	int k = 0; 
+	string RetVal = "QNO"; 
+	return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
+int Test_(Case_<3>) {
+	string numbers_[] = {"KEQUALS36"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	int k = 36; 
+	string RetVal = "ZZZZZZZZZ"; 
+	return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
+int Test_(Case_<4>) {
+	string numbers_[] = {"GOOD", "LUCK", "AND", "HAVE", "FUN"};
+	  vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_)); 
+	int k = 7; 
+	string RetVal = "31YUB"; 
+	return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/434-U/1C-U.cpp
Index: SRM/434-U/1C-U.cpp
==================================================================
--- SRM/434-U/1C-U.cpp
+++ SRM/434-U/1C-U.cpp
@@ -0,0 +1,154 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class IncreasingLists {
+public:
+	string ans;
+	typedef pair<int,pair<string,string> > key;
+	map<key,bool> memo;
+
+	vector<string> cm;
+
+	string makeIncreasingList(string mask) 
+	{
+		string buf(mask);
+		comma(mask, 0, 1, 0, buf);
+
+		for(int i=0; i<cm.size(); ++i)
+		{
+			// try_fill
+		}
+
+		return rec(mask, 0, "", "", buf) ? ans : "impossible";
+	}
+
+	void comma( const string& mask, int i, int prev, int cur, string& buf )
+	{
+		if( i==mask.size() || mask[i]==',' )
+			if( prev > cur )
+				return;
+		if( i==mask.size() ) {
+			cm.push_back(buf);
+			return;
+		}
+		if( mask[i]==',' ) {
+			buf[i] = ',';
+			comma( mask, i+1, cur, 0, buf );
+		}
+		else if( mask[i]=='?' ) {
+			if( prev<=cur ) {
+				buf[i]=',';
+				comma( mask, i+1, cur, 0, buf );
+			}
+			buf[i]='?';
+			comma( mask, i+1, prev, cur+1, buf );
+		}
+		else {
+			buf[i] = mask[i];
+			comma( mask, i+1, prev, cur+1, buf );
+		}
+	}
+
+	bool rec(const string& mask, int i, const string& prev, const string& cur, string& buf)
+	{
+		key k(i, make_pair(prev,cur));
+		if( memo.count(k) )
+			return false;
+		if( i==mask.size() || mask[i]==',' )
+		{
+			if( prev.size() > cur.size()
+			 || prev.size() == cur.size() && prev>=cur )
+				return false;
+		}
+
+		if( i==mask.size() ) {
+			ans = buf;
+			return true;
+		}
+
+		if( mask[i]==',' )
+			return rec(mask, i+1, cur, "", buf);
+
+		if( '0' <= mask[i] && mask[i] <='9' )
+			return rec(mask, i+1, prev, cur+mask[i], buf);
+
+		// try ,
+		if( !(prev.size()>cur.size() || prev.size()==cur.size() && prev>=cur) ) {
+			buf[i] = ',';
+			if( rec(mask, i+1, cur, "", buf) )
+				return true;
+		}
+		// try 0
+		for(int d=0; d<9; ++d)
+			if(cur.size()>0 || d>0) {
+				buf[i] = char(d+'0');
+				if( rec(mask, i+1, prev, cur+char(d+'0'), buf) )
+					return true;
+			}
+		return memo[k] = false;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string mask = "??"; 
+	string RetVal = "10"; 
+	return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
+int Test_(Case_<1>) {
+	string mask = "???"; 
+	string RetVal = "1,2"; 
+	return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
+int Test_(Case_<2>) {
+	string mask = "?????????,9"; 
+	string RetVal = "1,2,3,4,5,9"; 
+	return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
+int Test_(Case_<3>) {
+	string mask = "??????????,9"; 
+	string RetVal = "impossible"; 
+	return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
+int Test_(Case_<4>) {
+	string mask = "?,10,?????????????????,16,??"; 
+	string RetVal = "impossible"; 
+	return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
+int Test_(Case_<5>) {
+	string mask = "?2?5??7?,??"; 
+	string RetVal = "12,50,70,71"; 
+	return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
+int Test_(Case_<6>) {
+	string mask = "???????????????????????????????,???"; 
+	string RetVal = "1,10,11,100,101,102,103,104,105,106"; 
+	return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
+int Test_(Case_<7>) {
+	string mask   = "??????????????????????????????????????????????????";
+	string RetVal = "1,10,100,1000,10000,100000,1000000,100000000000000"; 
+	return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/435/1A.cpp
Index: SRM/435/1A.cpp
==================================================================
--- SRM/435/1A.cpp
+++ SRM/435/1A.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class CellRemoval {
+public:
+	int cellsLeft(vector <int> parent, int deletedCell) 
+	{
+		vector<bool> dead(parent.size(), false);
+
+		for(int i=0; i<parent.size(); ++i)
+		{
+			for(int p=i; p!=-1; p=parent[p], (p!=-1 ? dead[p]=true : 0) )
+				if( p == deletedCell )
+					dead[i] = true;
+		}
+		int cnt = 0;
+		for(int i=0; i<dead.size(); ++i)
+			if( !dead[i] )
+				++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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int parent_[] = {-1,0,0,1,1};
+	  vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_)); 
+	int deletedCell = 2; 
+	int RetVal = 2; 
+	return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
+int Test_(Case_<1>) {
+	int parent_[] = {-1,0,0,1,1};
+	  vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_)); 
+	int deletedCell = 1; 
+	int RetVal = 1; 
+	return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
+int Test_(Case_<2>) {
+	int parent_[] = {-1,0,0,1,1};
+	  vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_)); 
+	int deletedCell = 0; 
+	int RetVal = 0; 
+	return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
+int Test_(Case_<3>) {
+	int parent_[] = {-1,0,0,2,2,4,4,6,6};
+	  vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_)); 
+	int deletedCell = 4; 
+	int RetVal = 2; 
+	return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
+int Test_(Case_<4>) {
+	int parent_[] = {26,2,32,36,40,19,43,24,30,13,21,14,24,21,19,4,30,10,44,12,7,32,17,43,
+ 35,18,7,36,10,16,5,38,35,4,13,-1,16,26,1,12,2,5,18,40,1,17,38,44,14};
+	  vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_)); 
+	int deletedCell = 24; 
+	int RetVal = 14; 
+	return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/435/1B.cpp
Index: SRM/435/1B.cpp
==================================================================
--- SRM/435/1B.cpp
+++ SRM/435/1B.cpp
@@ -0,0 +1,122 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+static const LL MODVAL = 1000000007;
+
+class DNADeletion {
+public:
+	int differentProteins(vector <string> DNASequence, vector <string> codonTable) 
+	{
+		string dna;
+		for(int i=0; i<DNASequence.size(); ++i) dna += DNASequence[i];
+		int N = dna.size();
+
+		vector<string> cL, cR;
+		for(int i=0; i<codonTable.size(); ++i) {
+			stringstream sin(codonTable[i]);
+			string s, t; sin>>s>>t;
+			cL.push_back(s);
+			cR.push_back(t);
+		}
+		int M = cL.size();
+
+
+		vector<LL> dp(N+1); dp[0] = 1;
+		for(int i=0; i<N; ++i)
+		{
+			// there's dp[i] ways to generate some aminoseq from dna[0...i]
+
+			vector<int> p(M);
+
+			set<string> done;
+			for(int j=i; j<dna.size(); ++j)
+			{
+				for(int k=0; k<M; ++k)
+					if( p[k]<3 && dna[j]==cL[k][p[k]] ) {
+						p[k]++;
+						if( p[k]==3 && !done.count(cR[k]) ) {
+							done.insert(cR[k]);
+							dp[j+1] = (dp[j+1] + dp[i]) % MODVAL;
+						}
+					}
+			}
+		}
+
+		LL n = (accumulate(dp.begin(), dp.end(), 0LL) - 1) % MODVAL;
+		return int(n);
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string DNASequence_[] = {"ACTG"};
+	  vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_)); 
+	string codonTable_[] = {"ACT gua", "ACG cys", "ATG leu", "CTG thr"};
+	  vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
+int Test_(Case_<1>) {
+	string DNASequence_[] = {"AAACCC"};
+	  vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_)); 
+	string codonTable_[] = {"AAA thr", "CCC cys"};
+	  vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_)); 
+	int RetVal = 3; 
+	return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
+int Test_(Case_<2>) {
+	string DNASequence_[] = {"AAATCCC"};
+	  vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_)); 
+	string codonTable_[] = {"AAA gua","TCC dop","AAT dop","CCC gua"};
+	  vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_)); 
+	int RetVal = 5; 
+	return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
+int Test_(Case_<3>) {
+	string DNASequence_[] = {"ATGCGCATTAACCTCCTACCATGGAAGGGACGTAACCCGGCAATTTGATC",
+ "CTGATGACGGCATAAGCTACCCCTAGAGGTAAAAATGCATACTGCGTGCT",
+ "ATGCAG"};
+	  vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_)); 
+	string codonTable_[] = {"AAC RpjZt","AAT ZeiC","GCA ChZwh","TCC RpjZt","GAA I",
+ "TAG ZeiC","CTG dVK","GAG ZeiC","GTG I","AAG q","ATT dVK",
+ "AGA cJEjM","GGG KONUd","GTC ZRV","GGC ZeiC","TTA KONUd",
+ "GAC q","CCA q","GCC ZRV","GCG RpjZt","CCT ZRV","ATG dVK",
+ "ATC ChZwh","CTC cJEjM","CCC q","ATA dWjz","TTG DkEG",
+ "CAG q","CAA ZRV","ACT dVK","TCG dVK","ACC I","CGC dVK"};
+	  vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_)); 
+	int RetVal = 455985264; 
+	return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
+int Test_(Case_<4>) {
+	string DNASequence_[] = {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"};
+	  vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_));
+	string codonTable_[] = {"AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys"};
+	  vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_)); 
+	int RetVal = 3; 
+	return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/435/1C.cpp
Index: SRM/435/1C.cpp
==================================================================
--- SRM/435/1C.cpp
+++ SRM/435/1C.cpp
@@ -0,0 +1,192 @@
+#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>
+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 CompanyRestructuring {
+public:
+	int fewestDivisions(vector <string> hasManaged) 
+	{
+		int N = hasManaged.size();
+
+		bool hm[50][50], hmStar[50][50];
+		for(int i=0; i<N; ++i)
+			for(int j=0; j<N; ++j)
+				hm[i][j] = hmStar[i][j] = hasManaged[i][j]=='Y';
+
+		for(int k=0; k<N; ++k)
+			for(int i=0; i<N; ++i)
+				for(int j=0; j<N; ++j)
+					hmStar[i][j] |= hmStar[i][k] & hmStar[k][j];
+
+		graph g(N);
+		int nextID = N;
+		for(int p=0; p<N; ++p)
+		{
+			vector<int> cs;
+			vector<int> pi;
+
+			for(int c=0; c<N; ++c)
+				if( hm[p][c] && !hmStar[c][p] )
+				{
+					int pid = -1;
+					
+					for(int j=0; j<cs.size(); ++j)
+						if( hmStar[c][cs[j]] && hmStar[cs[j]][c] )
+							{pid = pi[j]; break;}
+
+					if(pid<0) pid = nextID++;
+					cs.push_back(c);
+					pi.push_back(pid);
+					g[c].push_back(pid);
+				}
+		}
+		g.resize(nextID);
+
+		return N - biMatch<5000>(g, N);
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string hasManaged_[] = {"NNNN","NNYN","NNNN","YYYN"};
+	  vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_)); 
+	int RetVal = 1; 
+	return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
+int Test_(Case_<1>) {
+	string hasManaged_[] = {"NNYN","NNYN","YNNN","YYYN"};
+	  vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_)); 
+	int RetVal = 1; 
+	return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
+int Test_(Case_<2>) {
+	string hasManaged_[] = {"NYNNN","NNYNN","NNNYN","NNNNY","YNNNN"};
+	  vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_)); 
+	int RetVal = 5; 
+	return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
+int Test_(Case_<3>) {
+	string hasManaged_[] = {"NYNYYYNN"
+,"NNNNYYNN"
+,"NYNNYYNN"
+,"NNYNYYNN"
+,"NNNNNNNN"
+,"NYYNYNNN"
+,"YYNYYYNN"
+,"YYNYYYYN"};
+	  vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_)); 
+	int RetVal = 1; 
+	return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
+int Test_(Case_<4>) {
+	string hasManaged_[] = {"NYNYNNYYNYNNNYYNYNYY"
+,"YNNNNNYYNNNYYNYNYNYY"
+,"NNNNNNYYNNNYYNYNNNNY"
+,"YNYNNNNYNNNYNNYNYNNY"
+,"NYNNNNNYYYYNYNYYNNYN"
+,"YYYYNNYNYNNNNNYYNYNY"
+,"NNNNNNNNNNNYYNNNNNYY"
+,"NNNNNNYNNNNYYNYNNNYN"
+,"NYYYNNNYNNNNYYNYYNYY"
+,"NNYNNNYYNNNNYNNNNNYY"
+,"YYNNNYNNYNNNNYNNYNYY"
+,"NNNNNNNYNNNNYNYNNNNY"
+,"NNNNNNYNNNNYNNNNNNNN"
+,"NNYNNNNNNNNYYNYNNYYN"
+,"NNNNNNNNNNNYNNNNNNNY"
+,"YNYYNYYNNNYYNNNNYNYY"
+,"NYNNNNNYNYNYYYYNNNNY"
+,"NNYNNNNYNYNYYYNNNNYY"
+,"NNNNNNNYNNNYNNNNNNNY"
+,"NNNNNNYYNNNYYNYNNNYN"};
+	  vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
+int Test_(Case_<5>) {
+	string hasManaged_[] = {"NNNYNNNNNNNYNNNNNNNN"
+,"NNNNNNYNNYNNNNNYNYYN"
+,"YNNNNNYNYNNNNNNNNNNY"
+,"YNNNNNNNNNNNNNNNNNNN"
+,"NNYNNNYNYNNYNNYNNNNY"
+,"NNNYNNNNNNNYNNYYYNYY"
+,"NNYYNNNNYNNNNNNNNNNY"
+,"NYNNNYNNYNNNYNYNYNNN"
+,"NNNNNNNNNNNNNNNNNNNN"
+,"YNNNNNNNNNNYNNYYNNYN"
+,"NNYYNYNNYYNNNNYYNYNN"
+,"NNNNNNNNYNNNNNNNNNNN"
+,"NNNYYNYNYYYYNNNNYNYY"
+,"NNYYNYNNYYYYNNNNNYNY"
+,"NNYYYNNNYNNNNNNNNNNN"
+,"YNNYYYNNNNNNNNYNYNYY"
+,"NNNNYNYNNNNYNNYNNNNN"
+,"YNNYYYYNNYNNYNNNYNYN"
+,"YNNYYYYNYNNYNNYYYNNY"
+,"YNYNNNNNYNNYNNNNNNNN"};
+	  vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_)); 
+	int RetVal = 2; 
+	return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
+int Test_(Case_<6>) {
+	string hasManaged_[] = {"NNNNN","NNNNN","NNNNN","NNNNN","NNNNN"};
+	  vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_)); 
+	int RetVal = 5; 
+	return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/436/1A.cpp
Index: SRM/436/1A.cpp
==================================================================
--- SRM/436/1A.cpp
+++ SRM/436/1A.cpp
@@ -0,0 +1,102 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class BestView {
+public:
+	int numberOfBuildings(vector <int> heights) 
+	{
+		int maxCnt = -1;
+
+		int N = heights.size();
+		for(int from=0; from<N; ++from)
+		{
+			int cnt = 0;
+			for(int to=0; to<N; ++to) if(to != from)
+			{
+				bool hidden = false;
+				for(int h=min(from,to)+1; h<max(from,to); ++h)
+				{
+					LL X1 = from;
+					LL Y1 = heights[from];
+					LL X2 = to;
+					LL Y2 = heights[to];
+					LL x = h;
+					LL y = heights[h];
+					// hide = (Y2-Y1)/(X2-X1)*(x-X1)+Y1 <= y
+					if( X2-X1 > 0 ) {
+						if( (Y2-Y1)*(x-X1) + Y1*(X2-X1) <= y * (X2-X1) )
+							hidden = true;
+					} else {
+						if( (Y2-Y1)*(x-X1) + Y1*(X2-X1) >= y * (X2-X1) )
+							hidden = true;
+					}
+				}
+				if(!hidden) cnt++;
+			}
+			maxCnt = max(maxCnt, cnt);
+		}
+		return maxCnt;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int heights_[] = {10};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
+int Test_(Case_<1>) {
+	int heights_[] = {5,5,5,5};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int RetVal = 2; 
+	return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
+int Test_(Case_<2>) {
+	int heights_[] = {1,2,7,3,2};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
+int Test_(Case_<3>) {
+	int heights_[] = {1,5,3,2,6,3,2,6,4,2,5,7,3,1,5};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int RetVal = 7; 
+	return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
+int Test_(Case_<4>) {
+	int heights_[] = {1000000000,999999999,999999998,999999997,999999996,1,2,3,4,5};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int RetVal = 6; 
+	return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
+int Test_(Case_<5>) {
+	int heights_[] = {244645169,956664793,752259473,577152868,605440232,569378507,111664772,653430457,454612157,397154317};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int RetVal = 7; 
+	return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/436/1B.cpp
Index: SRM/436/1B.cpp
==================================================================
--- SRM/436/1B.cpp
+++ SRM/436/1B.cpp
@@ -0,0 +1,172 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+bool w[500][500];
+bool v[500][500];
+
+class DoNotTurn {
+public:
+	int minimumTurns(int N, int X0, int A, int B, int Y0, int C, int D, int P, int M) 
+	{
+		// input
+		memset(w, 0, sizeof w);
+		memset(v, 0, sizeof v);
+
+		LL X=X0%P, Y=Y0%P;
+		for(int i=1; i<=M; ++i)
+		{
+			if( !((X%N)==0 && (Y%N)==0 || (X%N)==N-1 && (Y%N)==N-1) )
+				w[X%N][Y%N] = 1;
+			X = (X*A+B) % P;
+			Y = (Y*C+D) % P;
+		}
+
+		// solve
+		vector< pair<int,int> > Q(1, make_pair(0,0)); v[0][0]=1;
+		for(int step=-1; !Q.empty(); ++step)
+		{
+			vector< pair<int,int> > Q2;
+			for(int i=0; i<Q.size(); ++i)
+			{
+				int x = Q[i].first;
+				int y = Q[i].second;
+				if( x==N-1 && y==N-1 )
+					return step;
+
+				int dx[] = {-1, +1, 0, 0};
+				int dy[] = {0, 0, -1, +1};
+				for(int d=0; d<4; ++d)
+				{
+					for(int k=1 ;; ++k) {
+						int xx = x + dx[d]*k;
+						int yy = y + dy[d]*k;
+						if( xx<0 || N<=xx || yy<0 || N<=yy || w[xx][yy] )
+							break;
+						if( !v[xx][yy] ) {
+							v[xx][yy] = true;
+							Q2.push_back( make_pair(xx,yy) );
+						}
+					}
+				}
+			}
+			Q.swap(Q2);
+		}
+		return -1;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int N = 2; 
+	int X0 = 0; 
+	int A = 0; 
+	int B = 1; 
+	int Y0 = 0; 
+	int C = 0; 
+	int D = 1; 
+	int P = 10; 
+	int M = 2; 
+	int RetVal = 1; 
+	return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
+int Test_(Case_<1>) {
+	int N = 3; 
+	int X0 = 0; 
+	int A = 1; 
+	int B = 1; 
+	int Y0 = 1; 
+	int C = 1; 
+	int D = 0; 
+	int P = 3; 
+	int M = 3; 
+	int RetVal = -1; 
+	return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
+int Test_(Case_<2>) {
+	int N = 3; 
+	int X0 = 0; 
+	int A = 1; 
+	int B = 1; 
+	int Y0 = 1; 
+	int C = 1; 
+	int D = 1; 
+	int P = 3; 
+	int M = 3; 
+	int RetVal = 3; 
+	return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
+int Test_(Case_<3>) {
+	int N = 10; 
+	int X0 = 911111; 
+	int A = 845499; 
+	int B = 866249; 
+	int Y0 = 688029; 
+	int C = 742197; 
+	int D = 312197; 
+	int P = 384409; 
+	int M = 40; 
+	int RetVal = 12; 
+	return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
+int Test_(Case_<4>) {
+	int N = 5; 
+	int X0 = 23; 
+	int A = 2; 
+	int B = 3; 
+	int Y0 = 35; 
+	int C = 5; 
+	int D = 7; 
+	int P = 9; 
+	int M = 3; 
+	int RetVal = 2; 
+	return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
+int Test_(Case_<5>) {
+	int N = 2; 
+	int X0 = 0; 
+	int A = 0; 
+	int B = 0; 
+	int Y0 = 0; 
+	int C = 0; 
+	int D = 0; 
+	int P = 1; 
+	int M = 0; 
+	int RetVal = 1; 
+	return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
+int Test_(Case_<6>) {
+	int N = 500; 
+	int X0 = 0; 
+	int A = 0; 
+	int B = 0; 
+	int Y0 = 0; 
+	int C = 0; 
+	int D = 0; 
+	int P = 1; 
+	int M = 0; 
+	int RetVal = 1; 
+	return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/436/1C.cpp
Index: SRM/436/1C.cpp
==================================================================
--- SRM/436/1C.cpp
+++ SRM/436/1C.cpp
@@ -0,0 +1,137 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+CMP tmp[65536*4];
+
+void fft_impl( CMP a[], int stride, int n, double Wt )
+{
+	if( n > 1 )
+	{
+		CMP *ev=a, *od=a+stride;
+		int s2=stride*2, n2=n/2;
+
+		fft_impl( ev, s2, n2, Wt*2 );
+		fft_impl( od, s2, n2, Wt*2 );
+
+		for(int i=0; i<n; ++i) tmp[i] = ev[s2*(i%n2)] + od[s2*(i%n2)]*polar(1.0,i*Wt);
+		for(int i=0; i<n; ++i) a[stride*i] = tmp[i];
+	}
+}
+
+void fft( vector<CMP>& a )
+{
+	fft_impl(&a[0], 1, a.size(), +2*M_PI/a.size());
+}
+
+void ifft( vector<CMP>& a )
+{
+	fft_impl(&a[0], 1, a.size(), -2*M_PI/a.size());
+	for(int i=0; i<a.size(); ++i)
+		a[i] /= a.size();
+}
+
+class CircularShifts {
+public:
+	int maxScore(int N, int Z0, int A, int B, int M) 
+	{
+		// input
+		LL X[60000], Y[60000], Z=Z0%M;
+		for(int i=0; i<N+N; ++i)
+		{
+			(i<N ? X[i] : Y[i-N]) = Z % 100;
+			Z = (Z*A+B) % M;
+		}
+
+		// solve
+		int NN = 1;
+		while( NN < N*2 ) NN*=2;
+
+		vector<CMP> CX(NN), CY(NN), CZ(NN);
+		for(int i=0; i<N; ++i)
+			CX[i]=CX[i+N]=X[N-i-1], CY[i]=Y[i];
+
+		fft(CX);
+		fft(CY);
+		transform( CX.begin(), CX.end(), CY.begin(), CZ.begin(), multiplies<CMP>() );
+		ifft(CZ);
+
+		double m = 0;
+		for(int i=0; i<NN; ++i)
+			m = max(m, CZ[i].real());
+		return int(m+0.5);
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int N = 5; 
+	int Z0 = 1; 
+	int A = 1; 
+	int B = 0; 
+	int M = 13; 
+	int RetVal = 5; 
+	return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
+int Test_(Case_<1>) {
+	int N = 4; 
+	int Z0 = 1; 
+	int A = 1; 
+	int B = 1; 
+	int M = 20; 
+	int RetVal = 70; 
+	return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
+int Test_(Case_<2>) {
+	int N = 10; 
+	int Z0 = 23; 
+	int A = 11; 
+	int B = 51; 
+	int M = 4322; 
+	int RetVal = 28886; 
+	return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
+int Test_(Case_<3>) {
+	int N = 1000; 
+	int Z0 = 3252; 
+	int A = 3458736; 
+	int B = 233421; 
+	int M = 111111111; 
+	int RetVal = 2585408; 
+	return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
+int Test_(Case_<4>) {
+	int N = 141; 
+	int Z0 = 96478; 
+	int A = 24834; 
+	int B = 74860; 
+	int M = 92112; 
+	int RetVal = 419992; 
+	return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/437-U/1A.cpp
Index: SRM/437-U/1A.cpp
==================================================================
--- SRM/437-U/1A.cpp
+++ SRM/437-U/1A.cpp
@@ -0,0 +1,104 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename D, typename S>
+  D lexical_cast(const S& s) { D d; stringstream ss; ss<<s; ss>>d; return d; }
+
+class TheSwap {
+public:
+	int findMax(int n, int k) 
+	{
+		set<string> canMake;
+		canMake.insert( lexical_cast<string>(n) );
+
+		while( k --> 0 )
+		{
+			set<string> prev;
+			prev.swap(canMake);
+
+			for(set<string>::iterator it=prev.begin(); it!=prev.end(); ++it)
+			{
+				string s = *it;
+				for(int i=0; i<s.size(); ++i)
+				for(int j=i+1; j<s.size(); ++j)
+					if( !(i==0 && s[j]=='0') )
+					{
+						swap(s[i], s[j]);
+						canMake.insert(s);
+						swap(s[i], s[j]);
+					}
+			}
+		}
+
+		return canMake.empty() ? -1 : lexical_cast<int>(*canMake.rbegin());
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int n = 16375; 
+	int k = 1; 
+	int RetVal = 76315; 
+	return verify_case(RetVal, TheSwap().findMax(n, k)); }
+int Test_(Case_<1>) {
+	int n = 432; 
+	int k = 1; 
+	int RetVal = 423; 
+	return verify_case(RetVal, TheSwap().findMax(n, k)); }
+int Test_(Case_<2>) {
+	int n = 90; 
+	int k = 4; 
+	int RetVal = -1; 
+	return verify_case(RetVal, TheSwap().findMax(n, k)); }
+int Test_(Case_<3>) {
+	int n = 5; 
+	int k = 2; 
+	int RetVal = -1; 
+	return verify_case(RetVal, TheSwap().findMax(n, k)); }
+int Test_(Case_<4>) {
+	int n = 436659; 
+	int k = 2; 
+	int RetVal = 966354; 
+	return verify_case(RetVal, TheSwap().findMax(n, k)); }
+int Test_(Case_<5>) {
+	int n = 325664; 
+	int k = 2; 
+	int RetVal = 665324; 
+	return verify_case(RetVal, TheSwap().findMax(n, k)); }
+int Test_(Case_<6>) {
+	int n = 325664; 
+	int k = 4; 
+	int RetVal = 665432; 
+	return verify_case(RetVal, TheSwap().findMax(n, k)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/437-U/1B.cpp
Index: SRM/437-U/1B.cpp
==================================================================
--- SRM/437-U/1B.cpp
+++ SRM/437-U/1B.cpp
@@ -0,0 +1,163 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheInteger {
+public:
+	long long find(long long n, int k) 
+	{
+		stringstream ss;
+		ss << n;
+		string s;
+		ss >> s;
+
+		if( s.size() < k )
+			s = string(k-s.size(), '0') + s;
+
+		LL a = solve(s, k);
+		if( a )
+			return a;
+		return solve("0"+s, k);
+	}
+
+	LL solve(string s, int k)
+	{
+		// no change
+		if( s[0] != '0' )
+		{
+			set<char> d;
+			for(int i=0; i<s.size(); ++i)
+				d.insert( s[i] );
+			if( d.size() == k )
+				return toll(s);
+		}
+
+		// a-th digit larger
+		int lim = s[0]=='0' ? 1 : s.size();
+		for(int a=lim-1; a>=0; --a)
+			for(char v=s[a]+1; v<='9'; ++v)
+			{
+				set<char> d;
+				for(int i=0; i<a; ++i)
+					d.insert(s[i]);
+				d.insert(v);
+				if( d.size() > k )
+					continue;
+				else if( d.size() == k )
+				{
+					s[a] = v;
+					for(int i=a+1; i<s.size(); ++i)
+						s[i] = *d.begin();
+					return toll(s);
+				}
+				else
+				{
+					int rest = k - d.size();
+					if( s.size()-a-1 < rest )
+						continue;
+					s[a] = v;
+
+					int fi = s.size()-rest;
+
+					for(int i=a+1; i<fi; ++i)
+						s[i] = '0';
+
+					for(char z='0'; z<='9'; ++z)
+						if( !d.count(z) )
+						{
+							s[fi++] = z;
+							if( fi == s.size() )
+								break;
+						}
+
+					return toll(s);
+				}
+			}
+		return 0;
+	}
+
+	LL toll( string s )
+	{
+		stringstream ss; ss << s;
+		LL n; ss >> n;
+		return n;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	long long n = 47LL; 
+	int k = 1; 
+	long long RetVal = 55LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+int Test_(Case_<1>) {
+	long long n = 7LL; 
+	int k = 3; 
+	long long RetVal = 102LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+int Test_(Case_<2>) {
+	long long n = 69LL; 
+	int k = 2; 
+	long long RetVal = 69LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+int Test_(Case_<3>) {
+	long long n = 12364LL; 
+	int k = 3; 
+	long long RetVal = 12411LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+int Test_(Case_<4>) {
+	long long n = 1LL; 
+	int k = 10; 
+	long long RetVal = 1023456789LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+int Test_(Case_<5>) {
+	long long n = 111111111111111LL; 
+	int k = 10; 
+	long long RetVal = 111111203456789LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+int Test_(Case_<6>) {
+	long long n = 111111111111111LL; 
+	int k = 8; 
+	long long RetVal = 111111112034567LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+int Test_(Case_<7>) {
+	long long n = 100000000000000LL; 
+	int k = 10; 
+	long long RetVal = 100000023456789LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+int Test_(Case_<8>) {
+	long long n = 100000000000000LL; 
+	int k = 5; 
+	long long RetVal = 100000000000234LL; 
+	return verify_case(RetVal, TheInteger().find(n, k)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/438-U/1A.cpp
Index: SRM/438-U/1A.cpp
==================================================================
--- SRM/438-U/1A.cpp
+++ SRM/438-U/1A.cpp
@@ -0,0 +1,127 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class UnluckyIntervals {
+public:
+	vector <int> getLuckiest(vector <int> luckySet, int n) 
+	{
+		sort(luckySet.begin(), luckySet.end());
+
+		// zeros
+		vector<int> luk = luckySet;
+		for(LL i=0; i+1<luckySet.size(); ++i)
+			if( i+1 < luckySet.size() )
+				if( luckySet[i]+2 == luckySet[i+1] )
+					luk.push_back( luckySet[i]+1 );
+		if( luckySet[0]==2 )
+			luk.push_back(1);
+		sort(luk.begin(), luk.end());
+		if( luk.size() >= n )
+			return vector<int>(luk.begin(), luk.begin()+n);
+
+		// finites
+		vector< pair<LL, LL> > luk_val;
+		LL from = 1;
+		for(int i=0; i<luckySet.size(); ++i)
+		{
+			LL to = luckySet[i]; // [from,to)
+			if( from+2 <= to )
+			{
+				for(LL j=0; j<min<LL>(to-from,n); ++j) {
+					LL val = (j%2==0 ? from+j/2 : to-1-j/2);
+					LL unluk = (j/2+1) * (to-from-j/2) - 1;
+					luk_val.push_back( make_pair(unluk,val) );
+				}
+			}
+			from = luckySet[i]+1;
+		}
+		sort( luk_val.begin(), luk_val.end() );
+		for(int i=0; i<luk_val.size(); ++i)
+			luk.push_back(luk_val[i].second);
+
+		if( luk.size() >= n )
+			return vector<int>(luk.begin(), luk.begin()+n);
+
+		// infinites
+		int v = luckySet.back()+1;
+		while( luk.size() < n )
+			luk.push_back(v++);
+		return luk;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int luckySet_[] = {3};
+	  vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_)); 
+	int n = 6; 
+	int RetVal_[] = {3, 1, 2, 4, 5, 6 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
+int Test_(Case_<1>) {
+	int luckySet_[] = {5, 11, 18};
+	  vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_)); 
+	int n = 9; 
+	int RetVal_[] = {5, 11, 18, 1, 4, 6, 10, 2, 3 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
+int Test_(Case_<2>) {
+	int luckySet_[] = {7, 13, 18};
+	  vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_)); 
+	int n = 9; 
+	int RetVal_[] = {7, 13, 18, 14, 17, 8, 12, 1, 6 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
+int Test_(Case_<3>) {
+	int luckySet_[] = {1000, 1004, 4000, 4003, 5000};
+	  vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_)); 
+	int n = 19; 
+	int RetVal_[] = {1000, 1004, 4000, 4003, 5000, 4001, 4002, 1001, 1003, 1002, 4004, 4999, 1, 999, 4005, 4998, 2, 998, 4006 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
+int Test_(Case_<4>) {
+	int luckySet_[] = {1000000000};
+	  vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_)); 
+	int n = 8; 
+	int RetVal_[] = {1000000000, 1, 999999999, 2, 999999998, 3, 999999997, 4 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
+int Test_(Case_<5>) {
+	int luckySet_[] = {2};
+	  vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_)); 
+	int n = 1;
+	int RetVal_[] = {1};
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/438-U/1B.cpp
Index: SRM/438-U/1B.cpp
==================================================================
--- SRM/438-U/1B.cpp
+++ SRM/438-U/1B.cpp
@@ -0,0 +1,177 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+string g_input;
+string g_program;
+LL g_num_d;
+LL g_non_d;
+
+class EndlessStringMachine {
+public:
+	string getFragment(string input, string program, int s_, int min_, int max_) 
+	{
+		LL s = s_;
+		LL min = min_ - 1;
+		LL max = max_;
+
+		int nd = 0, id = -1;
+		for(int i=0; i!=program.size(); ++i)
+			if( program[i]=='$' )
+				++nd, id=i;
+
+		if( nd == 0 )
+		{
+			string result;
+			for(LL i=min; i<max; ++i)
+				result += (i < program.size() ? program[i] : '-');
+			return result;
+		}
+		else if( nd == 1 )
+		{
+			// output = program[..id]^s input program[id+1..]^s
+			string L = program.substr(0, id);
+			string C = input;
+			string R = program.substr(id+1);
+			string result;
+			for(LL i=min; i<max; ++i)
+				if( i < L.size()*s )
+					result += L[i%L.size()];
+				else if( i < L.size()*s + C.size() ) 
+					result += C[i - L.size()*s];
+				else if( i < L.size()*s + C.size() + R.size()*s )
+					result += R[(i-L.size()*s-C.size()) % R.size()];
+				else
+					result += '-';
+			return result;
+		}
+		else
+		{
+			g_input = input;
+			g_program = program;
+			g_num_d = nd;
+			g_non_d = program.size() - nd;
+
+			string result;
+			for(int i=min; i<max; ++i)
+				result += theChar(i, s);
+			return result;
+		}
+	}
+
+	char theChar( LL i, LL s )
+	{
+		if( s == 0 )
+		{
+			return ( i < g_input.size() ? g_input[i] : '-' );
+		}
+
+		LL cur = 0;
+		for(LL ip=0; ip<g_program.size(); ++ip)
+		{
+			if( g_program[ip]=='$' ) {
+				LL len = theLen(s-1);
+				if( cur<=i && i<cur+len )
+				{
+					i -= cur;
+					LL theLevel = 0, lvLen = g_input.size();
+					while( lvLen <= i )
+						theLevel ++, lvLen = lvLen*g_num_d + g_non_d;
+					return theChar(i, theLevel);
+				}
+				else
+					cur += len;
+			} else {
+				if( cur == i )
+					return g_program[ip];
+				else
+					cur += 1;
+			}
+		}
+		return '-';
+	}
+
+	LL theLen(LL s)
+	{
+		if( s == 0 )
+			return g_input.size();
+		if( s > 32 )
+			return 2000000000LL;
+		LL pr = theLen(s-1);
+		LL nx = pr*g_num_d + g_non_d;
+		return min(2000000000LL, nx);
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string input = "a"; 
+	string program = "$meric$"; 
+	int s = 6; 
+	int min = 1; 
+	int max = 35; 
+	string RetVal = "americamericamericamericamericameri"; 
+	return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
+int Test_(Case_<1>) {
+	string input = "top"; 
+	string program = "$coder"; 
+	int s = 1; 
+	int min = 1; 
+	int max = 20; 
+	string RetVal = "topcoder------------"; 
+	return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
+int Test_(Case_<2>) {
+	string input = "abc"; 
+	string program = "$x$y$z$"; 
+	int s = 10; 
+	int min = 30; 
+	int max = 50; 
+	string RetVal = "bcyabcxabcyabczabczab"; 
+	return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
+int Test_(Case_<3>) {
+	string input = "xy"; 
+	string program = "$a$bb"; 
+	int s = 12; 
+	int min = 5000; 
+	int max = 5099; 
+	string RetVal = "xybbbbaxyaxybbaxyaxybbbbbbbbaxyaxybbaxyaxybbbbaxyaxybbaxyaxybbbbbbaxyaxybbaxyaxybbbbaxyaxybbaxyaxybb"; 
+	return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
+int Test_(Case_<4>) {
+	string input = "x"; 
+	string program = "$y$"; 
+	int s = 999999999; 
+	int min = 5000; 
+	int max = 5001; 
+	string RetVal = "xx";
+	return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/439-U/1A.cpp
Index: SRM/439-U/1A.cpp
==================================================================
--- SRM/439-U/1A.cpp
+++ SRM/439-U/1A.cpp
@@ -0,0 +1,69 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PouringWater {
+public:
+	int nbits(int n) {
+		int cnt = 0;
+		while(n) {
+			if(n&1) ++cnt;
+			n>>=1;
+		}
+		return cnt;
+	}
+	int getMinBottles(int N, int K) 
+	{
+		for(int i=0;;++i)
+			if( nbits(N+i) <= K )
+				return i;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int N = 3; 
+	int K = 1; 
+	int RetVal = 1; 
+	return verify_case(RetVal, PouringWater().getMinBottles(N, K)); }
+int Test_(Case_<1>) {
+	int N = 13; 
+	int K = 2; 
+	int RetVal = 3; 
+	return verify_case(RetVal, PouringWater().getMinBottles(N, K)); }
+int Test_(Case_<2>) {
+	int N = 1000000; 
+	int K = 5; 
+	int RetVal = 15808; 
+	return verify_case(RetVal, PouringWater().getMinBottles(N, K)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/439-U/1B.cpp
Index: SRM/439-U/1B.cpp
==================================================================
--- SRM/439-U/1B.cpp
+++ SRM/439-U/1B.cpp
@@ -0,0 +1,196 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PalindromePhrases {
+public:
+	vector<string> W;
+	int N;
+	map<pair<int,string>, LL> memo1;
+	map<pair<int,string>, LL> memo2;
+	map<pair<int,string>, LL> memo3;
+	map<pair<int,string>, LL> memo4;
+	map<pair<int,string>, LL> memo5;
+
+	string rev(string s)
+	{
+		reverse(s.begin(), s.end());
+		return s;
+	}
+
+	bool prefix_all(const string& p, const string& a)
+	{
+		return p.size() <= a.size() && equal(p.begin(), p.end(), a.begin());
+	}
+
+	bool suffix_all(const string& p, const string& a)
+	{
+		return p.size() <= a.size() && equal(p.begin(), p.end(), a.begin()+a.size()-p.size());
+	}
+
+	long long getAmount(vector <string> words) 
+	{
+		W = words;
+		N = W.size();
+
+		LL cnt = 0;
+		for(int i=0; i<N; ++i)
+		{
+			int mask = (1<<N) - 1;
+			mask &= ~ (1<<i);
+
+			cnt += rec_startpalin(mask, W[i]);
+		}
+		return cnt;
+	}
+
+	LL rec_startpalin(int mask, const string& w) // #{ws | ws is palin}
+	{
+		pair<int,string> key(mask, w);
+		if( memo1.count(key) )
+			return memo1[key];
+
+		string rw = rev(w);
+
+		LL cnt = 0;
+		cnt += rec_end(mask, rw);
+		for(int ov=1; ov<=w.size(); ++ov)
+			if( w.substr(w.size()-ov) == rw.substr(0,ov) )
+				cnt += exact(mask, rw.substr(ov));
+		return memo1[key]=cnt;
+	}
+
+	LL rec_endpalin(int mask, const string& w) // #{sw | sw is palin}
+	{
+		pair<int,string> key(mask, w);
+		if( memo4.count(key) )
+			return memo4[key];
+
+		string rw = rev(w);
+
+		LL cnt = 0;
+		cnt += rec(mask, rw);
+		for(int ov=1; ov<=w.size(); ++ov)
+			if( rw.substr(w.size()-ov) == w.substr(0,ov) )
+				cnt += exact(mask, rw.substr(0,w.size()-ov));
+		return memo4[key]=cnt;
+	}
+
+	LL rec(int mask, const string& w) // #{ws | s is palin}
+	{
+		pair<int,string> key(mask, w);
+		if( memo2.count(key) )
+			return memo2[key];
+
+		LL cnt = (w.empty() ? 1 : 0);
+		for(int i=0; i<N; ++i)
+			if( mask & (1<<i) )
+			{
+				if( prefix_all(W[i], w) )
+					cnt += rec( mask &~ (1<<i), 
+						w.substr(W[i].size())
+					);
+				else if( prefix_all(w, W[i]) )
+					cnt += rec_startpalin( mask &~ (1<<i),
+						W[i].substr(w.size())
+					);
+			}
+		return memo2[key]=cnt;
+	}
+
+	LL rec_end(int mask, const string& w) // #{sw | s is palin}
+	{
+		pair<int,string> key(mask, w);
+		if( memo5.count(key) )
+			return memo5[key];
+
+		LL cnt = (w.empty() ? 1 : 0);
+		for(int i=0; i<N; ++i)
+			if( mask & (1<<i) )
+			{
+				if( suffix_all(W[i], w) )
+					cnt += rec_end( mask &~ (1<<i),
+						w.substr(0,w.size()-W[i].size())
+					);
+				else if( suffix_all(w, W[i]) )
+					cnt += rec_endpalin( mask &~ (1<<i),
+						W[i].substr(0, W[i].size()-w.size())
+					);
+			}
+		return memo5[key]=cnt;
+	}
+
+	LL exact(int mask, const string& w) // # of ways to create w
+	{
+		pair<int,string> key(mask, w);
+		if( memo3.count(key) )
+			return memo3[key];
+
+		LL cnt = (w.empty() ? 1 : 0);
+		for(int i=0; i<N; ++i)
+			if( mask & (1<<i) )
+				if( prefix_all(W[i], w) )
+					cnt += exact( mask &~ (1<<i), w.substr(W[i].size()) );
+
+		return memo3[key] = 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string words_[] = {"a","ba"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long RetVal = 2LL; 
+	return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
+int Test_(Case_<1>) {
+	string words_[] = {"ab","bcd","efg"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long RetVal = 0LL; 
+	return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
+int Test_(Case_<2>) {
+	string words_[] = {"a", "bba", "abb"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long RetVal = 7LL; 
+	return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
+int Test_(Case_<3>) {
+	string words_[] = {"aabccc", "ccbbca", "a", "acaabb", "aaa", "aab", "c", "babb", "aacaa", "b"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long RetVal = 47LL; 
+	return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
+int Test_(Case_<4>) {
+	string words_[] = {"a", "aa", "aaa"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	long long RetVal = 47LL; 
+	return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE

ADDED   SRM/440/1A.cpp
Index: SRM/440/1A.cpp
==================================================================
--- SRM/440/1A.cpp
+++ SRM/440/1A.cpp
@@ -0,0 +1,110 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class IncredibleMachine {
+public:
+	double gravitationalAcceleration(vector <int> x, vector <int> y, int T) 
+	{
+		double gL = 0.0, gR = 1e+9;
+		for(int i=0; i<100; ++i)
+		{
+			double gC = (gL + gR) / 2;
+			double tC = est(x, y, gC);
+			(tC < T ? gR : gL) = gC;
+		}
+		return gL;
+	}
+
+	double est(const vector<int>& x, const vector<int>& y, double g)
+	{
+		double v = 0.0;
+		double tot_t = 0.0;
+		for(int i=0; i+1<x.size(); ++i)
+		{
+			double v0 = v;
+			double len = sqrt(double((x[i+1]-x[i])*(x[i+1]-x[i]) + (y[i+1]-y[i])*(y[i+1]-y[i])));
+			double sin_alpha = (y[i]-y[i+1]) / len;
+			double a = g * sin_alpha;
+			// len = v0*t + 0.5a t^2
+			// 0.5a t^2 + v0 t - len = 0
+			double t = (-v0 + sqrt(v0*v0 + 2*a*len)) / a;
+			v = v0 + a*t;
+			tot_t += t;
+		}
+		return tot_t;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int x_[] = {0,6};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {100,22};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int T = 4; 
+	double RetVal = 9.807692307692307; 
+	return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
+int Test_(Case_<1>) {
+	int x_[] = {0,26,100};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {50,26,24};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int T = 4; 
+	double RetVal = 26.743031720603582; 
+	return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
+int Test_(Case_<2>) {
+	int x_[] = {0,7,8};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {10,6,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int T = 7; 
+	double RetVal = 1.1076837407708007; 
+	return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
+int Test_(Case_<3>) {
+	int x_[] = {0,100};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int T = 1; 
+	double RetVal = 20002; 
+	return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
+int Test_(Case_<4>) {
+	int x_[] = {0,1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {100,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int T = 100; 
+	double RetVal = 0.020002; 
+	return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/440/1B.cpp
Index: SRM/440/1B.cpp
==================================================================
--- SRM/440/1B.cpp
+++ SRM/440/1B.cpp
@@ -0,0 +1,154 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int dy[] = {-1,+1,0,0};
+static const int dx[] = {0,0,-1,+1};
+
+class MazeWandering {
+public:
+	double expectedTime(vector <string> maze) 
+	{
+		int Y = maze.size();
+		int X = maze[0].size();
+
+		vector< vector<int> >  d(Y, vector<int>(X, -1));
+		vector< pair<int,int> > q, Q;
+
+		for(int y=0; y<Y; ++y)
+			for(int x=0; x<X; ++x)
+				if( maze[y][x] == '*' ) {
+					d[y][x] = 0;
+					q.push_back( make_pair(y,x) );
+					Q.push_back( make_pair(y,x) );
+				}
+
+		for(int step=1; !q.empty(); ++step)
+		{
+			vector< pair<int,int> > q2;
+			for(int j=0; j<q.size(); ++j)
+			{
+				int qy = q[j].first;
+				int qx = q[j].second;
+				for(int i=0; i<4; ++i)
+				{
+					int y = qy+dy[i], x = qx+dx[i];
+					if( 0<=y && y<Y && 0<=x && x<X && maze[y][x]=='.' && d[y][x]==-1 )
+					{
+						d[y][x] = step;
+						q2.push_back( make_pair(y,x) );
+						Q.push_back( make_pair(y,x) );
+					}
+				}
+			}
+			q2.swap(q);
+		}
+
+		vector< vector<int> > w(Y, vector<int>(X, 0));
+		for(int j=Q.size()-1; j>0; --j)
+		{
+			int qy = Q[j].first;
+			int qx = Q[j].second;
+
+			for(int i=0; i<4; ++i)
+			{
+				int y = qy+dy[i], x = qx+dx[i];
+				if( 0<=y && y<Y && 0<=x && x<X && maze[y][x]!='X' && d[y][x] > d[qy][qx] )
+					w[qy][qx] += w[y][x] + 1;
+			}
+		}
+
+		double esum = 0.0;
+		vector< vector<double> >  e(Y, vector<double>(X, 0.0));
+		for(int j=0; j<Q.size(); ++j)
+		{
+			int qy = Q[j].first;
+			int qx = Q[j].second;
+			if( d[qy][qx] > 0 )
+			{
+				for(int i=0; i<4; ++i)
+				{
+					int y = qy+dy[i], x = qx+dx[i];
+					if( 0<=y && y<Y && 0<=x && x<X && maze[y][x]!='X' && d[y][x] < d[qy][qx] )
+					{
+						e[qy][qx] = e[y][x] + 1 + 2*w[qy][qx];
+						esum += e[qy][qx];
+						break;
+					}
+				}
+			}
+		}
+		return esum / Q.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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	string maze_[] = {"*",
+ "."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	double RetVal = 0.5; 
+	return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
+int Test_(Case_<1>) {
+	string maze_[] = {"*.."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	double RetVal = 2.3333333333333335; 
+	return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
+int Test_(Case_<2>) {
+	string maze_[] = {"...",
+ "X*X",
+ "..."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	double RetVal = 4.857142857142857; 
+	return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
+int Test_(Case_<3>) {
+	string maze_[] = {".*.",
+ ".XX",
+ "..."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	double RetVal = 13.714285714285714; 
+	return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
+int Test_(Case_<4>) {
+	string maze_[] = {"*........",
+ "XXX.XXXX.",
+ ".XX.X....",
+ ".....XX.X"};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	double RetVal = 167.2608695652174; 
+	return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
+int Test_(Case_<5>) {
+	string maze_[] = {"X*X"};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	double RetVal = 0;
+	return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/440/1C.cpp
Index: SRM/440/1C.cpp
==================================================================
--- SRM/440/1C.cpp
+++ SRM/440/1C.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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int MODVAL = 1000000007;
+
+bool is_square_free(int n)
+{
+	for(int p=2; p*p<=n; ++p)
+		if( n%(p*p) == 0 )
+			return false;
+	return true;
+}
+
+static const int SP[] = {2,3,5,7,11,13,17,19}; // <= sqrt(N)
+static const int SPN  = sizeof(SP)/sizeof(*SP);
+
+int small_prime_mask(int n)
+{
+	int m = 0;
+	for(int i=0; i<SPN; ++i)
+		if( n%SP[i] == 0 )
+			m |= 1<<i;
+	return m;
+}
+
+int big_prime_factor(int n)
+{
+	for(int i=0; i<SPN; ++i)
+		while( n%SP[i] == 0 )
+			n /= SP[i];
+	return n;
+}
+
+class SquareFreeSets {
+public:
+	int countPerfect(int N, int K) 
+	{
+		// way[k][m] = # of ways to make a k-elem psf-set with small prime factors m
+		int way[501][1<<SPN] = {};
+		way[0][0] = 1;
+
+		for(int n=2; n<=N; ++n)
+			if( is_square_free(n) )
+				if( big_prime_factor(n) == 1 )
+				{
+					int mask = small_prime_mask(n);
+					for(int k=K; k>=1; --k)
+						for(int m=0; m<(1<<SPN); ++m)
+							if( (m|mask) == m )
+								way[k][m] = (way[k][m] + way[k-1][m&~mask]) % MODVAL;
+				}
+				else if( big_prime_factor(n) == n )
+				{
+					vector<int> mask;
+					for(int p=1; n*p<=N; ++p)
+						if( is_square_free(p) )
+							mask.push_back( small_prime_mask(p) );
+
+					for(int k=K; k>=1; --k)
+						for(int m=0; m<(1<<SPN); ++m)
+							for(int j=0; j<mask.size(); ++j)
+								if( (m|mask[j]) == m )
+									way[k][m] = (way[k][m] + way[k-1][m&~mask[j]]) % MODVAL;
+				}
+
+		// summing up
+		int sum = 0;
+		for(int k=1; k<=K; ++k)
+			for(int m=0; m<(1<<SPN); ++m)
+				sum = (sum + way[k][m]) % MODVAL;
+		return sum;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int N = 5; 
+	int K = 1; 
+	int RetVal = 3; 
+	return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
+int Test_(Case_<1>) {
+	int N = 5; 
+	int K = 2; 
+	int RetVal = 6; 
+	return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
+int Test_(Case_<2>) {
+	int N = 5; 
+	int K = 3; 
+	int RetVal = 7; 
+	return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
+int Test_(Case_<3>) {
+	int N = 6; 
+	int K = 3; 
+	int RetVal = 9; 
+	return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
+int Test_(Case_<4>) {
+	int N = 28; 
+	int K = 41; 
+	int RetVal = 1599; 
+	return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
+int Test_(Case_<5>) {
+	int N = 500; 
+	int K = 500; 
+	int RetVal = 59964104; 
+	return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
+int Test_(Case_<6>) {
+	int N = 100; 
+	int K = 1;
+	int RetVal = 60; 
+	return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/441-U/1A.cpp
Index: SRM/441-U/1A.cpp
==================================================================
--- SRM/441-U/1A.cpp
+++ SRM/441-U/1A.cpp
@@ -0,0 +1,82 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PerfectPermutation { public:
+	int reorder(vector <int> P) 
+	{
+		vector<bool> used(P.size(), false);
+
+		int num_loop = 0;
+		for(int i=0; i<P.size(); ++i)
+			if( !used[i] ) {
+				++num_loop;
+
+				for(int p=i; !used[p]; p=P[p])
+					used[p] = true;
+			}
+		return num_loop==1 ? 0 : num_loop;
+	}
+};
+
+// 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(_, PerfectPermutation().reorder(P));}
+int main(){
+
+CASE(0)
+	int P_[] = {2, 0, 1};
+	  vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_)); 
+	int _ = 0; 
+END
+CASE(1)
+	int P_[] = {2, 0, 1, 4, 3};
+	  vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_)); 
+	int _ = 2; 
+END
+CASE(2)
+	int P_[] = {2, 3, 0, 1};
+	  vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_)); 
+	int _ = 2; 
+END
+CASE(3)
+	int P_[] = {0, 5, 3, 2, 1, 4};
+	  vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_)); 
+	int _ = 3; 
+END
+CASE(4)
+	int P_[] = {4, 2, 6, 0, 3, 5, 9, 7, 8, 1};
+	  vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_)); 
+	int _ = 5; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/441-U/1B.cpp
Index: SRM/441-U/1B.cpp
==================================================================
--- SRM/441-U/1B.cpp
+++ SRM/441-U/1B.cpp
@@ -0,0 +1,117 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class StrangeCountry { public:
+	int transform(vector <string> g) 
+	{
+		int nConn=g.size(), nEdge=0;
+
+		vector<int> uf(g.size(), -1); // union_find
+		for(int x=0; x<g.size(); ++x)
+		{
+			if( g[x].find('Y')==-1 )
+				return -1; // orphan
+
+			for(int y=x+1; y<g.size(); ++y)
+				if( g[x][y]=='Y' ) {
+					++nEdge;
+					int rx=x; while( uf[rx]>=0 ) rx=uf[rx];
+					int ry=y; while( uf[ry]>=0 ) ry=uf[ry];
+					if( rx != ry ) uf[rx]=ry, --nConn;
+				}
+		}
+
+		int redundant = nEdge - (g.size() - nConn);
+		return redundant>=nConn-1 ? nConn-1 : -1;
+	}
+};
+
+// 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(_, StrangeCountry().transform(g));}
+int main(){
+
+CASE(0)
+	string g_[] = {"NY",
+ "YN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int _ = 0; 
+END
+CASE(1)
+	string g_[] = {"NYYNN",
+ "YNYNN",
+ "YYNNN",
+ "NNNNY",
+ "NNNYN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int _ = 1; 
+END
+CASE(2)
+	string g_[] = {"NYYNNNN",
+ "YNYNNNN",
+ "YYNNNNN",
+ "NNNNYYN",
+ "NNNYNYY",
+ "NNNYYNY",
+ "NNNNYYN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int _ = 1; 
+END
+CASE(3)
+	string g_[] = {"NYNYNNNNNNNN",
+ "YNYNNNNNNNNN",
+ "NYNYYNNNNNNN",
+ "YNYNNNNNNNNN",
+ "NNYNNYYNNNNN",
+ "NNNNYNYNNNNN",
+ "NNNNYYNNNNNN",
+ "NNNNNNNNYYNN",
+ "NNNNNNNYNYNN",
+ "NNNNNNNYYNNN",
+ "NNNNNNNNNNNY",
+ "NNNNNNNNNNYN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int _ = 2; 
+END
+CASE(4)
+	string g_[] = {"NYNNNN",
+ "YNYNNN",
+ "NYNYNN",
+ "NNYNNN",
+ "NNNNNY",
+ "NNNNYN"};
+	  vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_)); 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/442-U/1A.cpp
Index: SRM/442-U/1A.cpp
==================================================================
--- SRM/442-U/1A.cpp
+++ SRM/442-U/1A.cpp
@@ -0,0 +1,81 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+int nf(int n)
+{
+	int c = 0;
+	for(int p=2; p*p<=n; ++p)
+		if( n%p==0 )
+			while(n%p==0)
+				c++, n/=p;
+	return c + (n==1 ? 0 : 1);
+}
+
+class Underprimes { public:
+	int howMany(int A, int B) 
+	{
+		int cnt = 0;
+		for(int n=A; n<=B; ++n)
+			if( nf(nf(n)) == 1 )
+				++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(_, Underprimes().howMany(A, B));}
+int main(){
+
+CASE(0)
+	int A = 2; 
+	int B = 10; 
+	int _ = 5; 
+END
+CASE(1)
+	int A = 100; 
+	int B = 105; 
+	int _ = 2; 
+END
+CASE(2)
+	int A = 17; 
+	int B = 17; 
+	int _ = 0; 
+END
+CASE(3)
+	int A = 123; 
+	int B = 456; 
+	int _ = 217; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/442-U/1B.cpp
Index: SRM/442-U/1B.cpp
==================================================================
--- SRM/442-U/1B.cpp
+++ SRM/442-U/1B.cpp
@@ -0,0 +1,157 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BedroomFloor { public:
+	LL b[6];
+
+	long long numberOfSticks(int x1, int y1, int x2, int y2) 
+	{
+		b[1] = b[2] = b[3] = b[4] = b[5] = 0;
+
+		devideX_and_count(x1, x2, y1, y2);
+		return optimize();
+	}
+
+	// utils
+	LL FLOOR(LL x) { return x/5*5; }
+	LL CEIL (LL x) { return FLOOR(x+4); }
+
+	// counting routines
+	void devideX_and_count(LL x1, LL x2, LL y1, LL y2)
+	{
+		if( FLOOR(x1) == FLOOR(x2) )
+			devideY_and_count(x1, x2, y1, y2, 1);
+		else
+			devideY_and_count(         x1,    CEIL(x1), y1, y2, 1 ),
+			devideY_and_count(   CEIL(x1),  CEIL(x1)+5, y1, y2, ((FLOOR(x2)-CEIL(x1))/5+1)/2 ),
+			devideY_and_count( CEIL(x1)+5, CEIL(x1)+10, y1, y2, ((FLOOR(x2)-CEIL(x1))/5+0)/2 ),
+			devideY_and_count(  FLOOR(x2),          x2, y1, y2, 1 );
+	}
+
+	void devideY_and_count(LL x1, LL x2, LL y1, LL y2, LL rep)
+	{
+		if( FLOOR(y1) == FLOOR(y2) )
+			count(x1, x2, y1, y2, rep);
+		else
+			count(x1, x2,         y1,    CEIL(y1), rep),
+			count(x1, x2,   CEIL(y1),  CEIL(y1)+5, rep*(((FLOOR(y2)-CEIL(y1))/5+1)/2) ),
+			count(x1, x2, CEIL(y1)+5, CEIL(y1)+10, rep*(((FLOOR(y2)-CEIL(y1))/5+0)/2) ),
+			count(x1, x2,  FLOOR(y2),         y2 , rep);
+	}
+
+	void count(LL x1, LL x2, LL y1, LL y2, LL rep)
+	{
+		if( x1/5%2 == y1/5%2 ) // is_horizontal
+			b[x2-x1] += rep*(y2-y1);
+		else
+			b[y2-y1] += rep*(x2-x1);
+	}
+
+	// compute minimum number of 1x5 blocks required (by greedily removing larger blocks)
+	LL optimize()
+	{
+		LL total = 0;
+		for(int K=6*6*6*6*6; --K>0; )
+		{
+			int k[] = {-1, K%6, K/6%6, K/6/6%6, K/6/6/6%6, K/6/6/6/6%6};
+			if( 1*k[1] + 2*k[2] + 3*k[3] + 4*k[4] + 5*k[5] <= 5 )
+			{
+				LL n = 1LL<<62;
+				for(int i=1; i<=5; ++i)
+					if( k[i] )
+						n = min(n, b[i]/k[i]);
+				for(int i=1; i<=5; ++i)
+					b[i] -= n*k[i];
+				total += n;
+			}
+		}
+		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 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(_, BedroomFloor().numberOfSticks(x1, y1, x2, y2));}
+int main(){
+
+CASE(0)
+	int x1 = 0; 
+	int y1 = 0; 
+	int x2 = 5; 
+	int y2 = 5; 
+	long long _ = 5LL; 
+END
+CASE(1)
+	int x1 = 0; 
+	int y1 = 0; 
+	int x2 = 10; 
+	int y2 = 2; 
+	long long _ = 5LL; 
+END
+CASE(2)
+	int x1 = 2; 
+	int y1 = 2; 
+	int x2 = 8; 
+	int y2 = 8; 
+	long long _ = 12LL; 
+END
+CASE(3)
+	int x1 = 8; 
+	int y1 = 5; 
+	int x2 = 20; 
+	int y2 = 16; 
+	long long _ = 27LL; 
+END
+CASE(4)
+	int x1 = 0; 
+	int y1 = 0; 
+	int x2 = 1000000; 
+	int y2 = 1000000; 
+	long long _ = 200000000000LL; 
+END
+CASE(5)
+	int x1 = 1; 
+	int y1 = 4; 
+	int x2 = 20; 
+	int y2 = 19; 
+	long long _ = 58LL; 
+END
+CASE(5)
+	int x1 = 49; 
+	int y1 = 51; 
+	int x2 = 64; 
+	int y2 = 70; 
+	long long _ = 58LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/442-U/1C-U.cpp
Index: SRM/442-U/1C-U.cpp
==================================================================
--- SRM/442-U/1C-U.cpp
+++ SRM/442-U/1C-U.cpp
@@ -0,0 +1,116 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class NowhereLand { public:
+	int placeGuards(vector <string> cities, int k, vector <string> guards, vector <string> agencies) 
+	{
+		int mc = 0;
+		for(int gid=0; gid<k; ++gid)
+			mc += minimizeConflict(cities, guards, agencies, gid);
+		return mc;
+	}
+
+	int minimizeConflict(vector<string>& C, vector<string>& G_, vector<string>& A_, int gid)
+	{
+		vector<bool> G(C.size());
+		vector<bool> A(C.size());
+		for(int i=0; i<C.size(); ++i)
+		{
+			{ stringstream sin(G_[i]);
+			  for(int g; sin>>g; ) if(g==gid) G[i] = true; }
+			{ stringstream sin(A_[i]);
+			  for(int g; sin>>g; ) if(g==gid) A[i] = true; }
+		}
+		return -1;
+	}
+};
+
+// 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(_, NowhereLand().placeGuards(cities, k, guards, agencies));}
+int main(){
+
+CASE(0)
+	string cities_[] = { "0111",
+  "1000",
+  "1000",
+  "1000" };
+	  vector <string> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	int k = 1; 
+	string guards_[] = { "0", "", "", "" };
+	  vector <string> guards(guards_, guards_+sizeof(guards_)/sizeof(*guards_)); 
+	string agencies_[] = { "0", "0", "", "0" };
+	  vector <string> agencies(agencies_, agencies_+sizeof(agencies_)/sizeof(*agencies_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string cities_[] = { "011",
+  "101",
+  "110"  };
+	  vector <string> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	int k = 1; 
+	string guards_[] = { "0", "", "" };
+	  vector <string> guards(guards_, guards_+sizeof(guards_)/sizeof(*guards_)); 
+	string agencies_[] = { "0", "", "" };
+	  vector <string> agencies(agencies_, agencies_+sizeof(agencies_)/sizeof(*agencies_)); 
+	int _ = 2; 
+END
+CASE(2)
+	string cities_[] = { "011",
+  "101",
+  "110"  };
+	  vector <string> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	int k = 1; 
+	string guards_[] = { "", "", "" }	;
+	  vector <string> guards(guards_, guards_+sizeof(guards_)/sizeof(*guards_)); 
+	string agencies_[] = { "0", "0", "0" };
+	  vector <string> agencies(agencies_, agencies_+sizeof(agencies_)/sizeof(*agencies_)); 
+	int _ = 0; 
+END
+CASE(3)
+	string cities_[] = { "010100",
+  "101100",
+  "010011",
+  "110010",
+  "001100",
+  "001000" };
+	  vector <string> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	int k = 3; 
+	string guards_[] = { "1 2", "", "1", "", "0", "0" };
+	  vector <string> guards(guards_, guards_+sizeof(guards_)/sizeof(*guards_)); 
+	string agencies_[] = { "0 1 2", "0 1", "0 1 2", "1 2", "0", "0" };
+	  vector <string> agencies(agencies_, agencies_+sizeof(agencies_)/sizeof(*agencies_)); 
+	int _ = 7; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/443-U/1A.cpp
Index: SRM/443-U/1A.cpp
==================================================================
--- SRM/443-U/1A.cpp
+++ SRM/443-U/1A.cpp
@@ -0,0 +1,128 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CirclesCountry { public:
+	int leastBorders(vector <int> X, vector <int> Y, vector <int> R, int x1, int y1, int x2, int y2) 
+	{
+		int cnt = 0;
+		for(int i=0; i<X.size(); ++i)
+			cnt += hypot(X[i]-x1, Y[i]-y1)<R[i] ^ hypot(X[i]-x2, Y[i]-y2)<R[i];
+		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(_, CirclesCountry().leastBorders(X, Y, R, x1, y1, x2, y2));}
+int main(){
+
+CASE(0)
+	int X_[] = {0};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {0};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {2};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int x1 = -5; 
+	int y1 = 1; 
+	int x2 = 5; 
+	int y2 = 1; 
+	int _ = 0; 
+END
+CASE(1)
+	int X_[] = {0,-6,6};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {0,1,2};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {2,2,2};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int x1 = -5; 
+	int y1 = 1; 
+	int x2 = 5; 
+	int y2 = 1; 
+	int _ = 2; 
+END
+CASE(2)
+	int X_[] = {1,-3,2,5,-4,12,12};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {1,-1,2,5,5,1,1};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {8,1,2,1,1,1,2};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int x1 = -5; 
+	int y1 = 1; 
+	int x2 = 12; 
+	int y2 = 1; 
+	int _ = 3; 
+END
+CASE(3)
+	int X_[] = {-3,2,2,0,-4,12,12,12};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {-1,2,3,1,5,1,1,1};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {1,3,1,7,1,1,2,3};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int x1 = 2; 
+	int y1 = 3; 
+	int x2 = 13; 
+	int y2 = 2; 
+	int _ = 5; 
+END
+CASE(4)
+	int X_[] = {-107,-38,140,148,-198,172,-179,148,176,153,-56,-187};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {175,-115,23,-2,-49,-151,-52,42,0,68,109,-174};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {135,42,70,39,89,39,43,150,10,120,16,8};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int x1 = 102; 
+	int y1 = 16; 
+	int x2 = 19; 
+	int y2 = -108; 
+	int _ = 3; 
+END
+CASE(5)
+	int X_[] = {0};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {0};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {2};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int x1 = -5; 
+	int y1 = 1; 
+	int x2 = 2; 
+	int y2 = 2; 
+	int _ = 0; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/443-U/1B.cpp
Index: SRM/443-U/1B.cpp
==================================================================
--- SRM/443-U/1B.cpp
+++ SRM/443-U/1B.cpp
@@ -0,0 +1,151 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BinaryFlips { public:
+	int minimalMoves(int A, int B, int K) 
+	{
+		vector<int> visitedUpto(A+B+1, -1);
+		visitedUpto[B] = B;
+
+		// Breadth-first search from the initial state (A,B)
+		queue< pair<int,int> > q;
+		q.push( make_pair(B, 0) );
+		while( !q.empty() )
+		{
+			// pop state (a,b)
+			int b=q.front().first, a=A+B-b, step=q.front().second; q.pop();
+
+			// if (a,b) == (0,A+B), done
+			if( b == A+B )
+				return step;
+
+			// for all possible next values (nb) of b...
+			int nb_min = abs(b-K), nb_max = A+B-abs(a-K);
+			for(int nb=nb_min; nb<=nb_max; nb+=2)
+				if( visitedUpto[nb] == -1 )
+				{
+					// if not visited, push the new state to the queue
+					q.push( make_pair(nb, step+1) );
+					visitedUpto[nb] = nb_max;
+				}
+				else
+				{
+					// if visited, skip it
+					int nb2 = visitedUpto[nb];
+					visitedUpto[nb] = max(visitedUpto[nb], nb_max);
+					nb = nb2;
+				}
+		}
+		return -1;
+	}
+};
+
+// 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(_, BinaryFlips().minimalMoves(A, B, K));}
+int main(){
+
+CASE(0)
+	int A = 3; 
+	int B = 0; 
+	int K = 3; 
+	int _ = 1; 
+END
+CASE(1)
+	int A = 4; 
+	int B = 0; 
+	int K = 3; 
+	int _ = 4; 
+END
+CASE(2)
+	int A = 4; 
+	int B = 1; 
+	int K = 3; 
+	int _ = 2; 
+END
+CASE(3)
+	int A = 3; 
+	int B = 2; 
+	int K = 5; 
+	int _ = -1; 
+END
+CASE(4)
+	int A = 100000; 
+	int B = 100000; 
+	int K = 578; 
+	int _ = 174; 
+END
+CASE(5)
+	int A = 0; 
+	int B = 0; 
+	int K = 1; 
+	int _ = 0; 
+END
+CASE(6)
+	int A = 4; 
+	int B = 44; 
+	int K = 50; 
+	int _ = -1; 
+END
+CASE(7)
+	int A = 11; 
+	int B = 99995; 
+	int K = 99999; 
+	int _ = 14285;
+END
+CASE(8)
+	int A = 100000; 
+	int B = 100000; 
+	int K = 15781; 
+	int _ = 8; 
+END
+CASE(9)
+	int A = 7; 
+	int B = 99128; 
+	int K = 70613; 
+	int _ = 5; 
+END
+CASE(10)
+	int A = 45903; 
+	int B = 89257; 
+	int K = 98937; 
+	int _ = 3; 
+END
+CASE(11)
+	int A = 93851; 
+	int B = 72517; 
+	int K = 16031; 
+	int _ = 7; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/444/1A.cpp
Index: SRM/444/1A.cpp
==================================================================
--- SRM/444/1A.cpp
+++ SRM/444/1A.cpp
@@ -0,0 +1,199 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class UnfoldingTriangles { public:
+	int solve(vector <string> grid, int unfoldLimit) 
+	{
+		int X = grid[0].size();
+		int Y = grid.size();
+
+		int Max = -1;
+		// top-right
+		for(int y=0; y<Y; ++y)
+			for(int x=X; x>=1; --x)
+			{
+				int numTri = 0;
+				// size
+				for(int n=1; x-n>=0 && y+n<=Y; ++n)
+				{
+					// right-check
+					if( x<X && grid[y+n-1][x]=='#' )
+						goto NextTopRight;
+					// diag-check
+					if( grid[y+n-1][x-n]!='/' )
+						goto NextTopRight;
+					// inner-check
+					for(int k=1; k<n; ++k) {
+						if( grid[y+n-1][x-k] == '.' )
+							goto NextTopRight;
+						if( grid[y+n-1][x-k] == '/' )
+							if( ++numTri > unfoldLimit )
+								goto NextTopRight;
+					}
+					// bottom-check
+					bool ok = true;
+					if( y+n == Y )
+						ok = true;
+					else
+						for(int k=1; k<=n; ++k) {
+							if( grid[y+n][x-k] == '#' )
+								{ok=false; break;}
+						}
+
+					// update
+					if( ok )
+						Max = max( Max, n*(n+1)/2 );
+				}
+			NextTopRight:;
+			}
+
+		return Max;
+	}
+};
+
+// 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(_, UnfoldingTriangles().solve(grid, unfoldLimit));}
+int main(){
+
+CASE(0)
+	string grid_[] = {".../",
+ "../#",
+ "./#/",
+ "/#//"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int unfoldLimit = 4; 
+	int _ = 10; 
+END
+CASE(1)
+	string grid_[] = {".../",
+ "../#",
+ "./#/",
+ "/#//"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int unfoldLimit = 2; 
+	int _ = 3; 
+END
+CASE(2)
+	string grid_[] = {"////",
+ "////",
+ "////",
+ "////"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int unfoldLimit = 5; 
+	int _ = 6; 
+END
+CASE(3)
+	string grid_[] = {".....#...",
+ "....###.."};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int unfoldLimit = 10; 
+	int _ = -1; 
+END
+CASE(4)
+	string grid_[] = {"#//#",
+ "#//#",
+ "####",
+ "///#"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int unfoldLimit = 4; 
+	int _ = 1; 
+END
+CASE(5)
+	string grid_[] = {".../.../",
+ "../#..//",
+ "./.#.///",
+ "/###...."};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int unfoldLimit = 3; 
+	int _ = 6; 
+END
+CASE(6)
+	string grid_[] = {
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ "//////////////////////////////////////////////////",
+ };
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int unfoldLimit = 2500; 
+	int _ = 6; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/444/1B.cpp
Index: SRM/444/1B.cpp
==================================================================
--- SRM/444/1B.cpp
+++ SRM/444/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 <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+int memo[1024][30];
+
+class FourBlocks { public:
+	int X, Y;
+	vector<string> G;
+	int maxScore(vector <string> grid) 
+	{
+		X = grid.size();
+		Y = grid[0].size();
+		G = grid;
+
+		// sentinels
+		for(int x=0; x<X; ++x)
+			G[x] += '0';
+		G.push_back( string(Y+1,'0') );
+
+		int baseScore = 0;
+		for(int x=0; x<X; ++x)
+		for(int y=0; y<Y; ++y)
+			baseScore += (G[x][y]=='1');
+
+		// memoized search
+		memset(memo, 0xff, sizeof(memo));
+		return baseScore + best(0);
+	}
+
+	int best(int y)
+	{
+		if( Y <= y )
+			return 0;
+
+		int mask = 0;
+		for(int x=0; x<X; ++x)
+			mask |= ((G[x][y]=='.') << x);
+		if( memo[mask][y] != -1 )
+			return memo[mask][y];
+		return memo[mask][y] = best(0, y);
+	}
+
+	int best(int x, int y)
+	{
+		if( X <= x )
+			return best(y+1);
+		int Max = 0;
+		if( G[x][y]=='.' )
+		{
+			if( G[x+1][y]=='.' && G[x][y+1]=='.' && G[x+1][y+1]=='.' )
+			{
+				// can put 4
+				G[x][y]=G[x+1][y]=G[x][y+1]=G[x+1][y+1] = '4';
+				Max = max(Max, 16+best(x+2, y));
+				G[x][y]=G[x+1][y]=G[x][y+1]=G[x+1][y+1] = '.';
+			}
+			// can put 1
+			G[x][y] = '1';
+			Max = max(Max, 1+best(x+1, y));
+			G[x][y] = '.';
+		}
+		else
+		{
+			Max = max(Max, best(x+1, y));
+		}
+		return Max;
+	}
+};
+
+// 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(_, FourBlocks().maxScore(grid));}
+int main(){
+
+CASE(0)
+	string grid_[] = {".....1..1..",
+ "..1.....1.."};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int _ = 70; 
+END
+CASE(1)
+	string grid_[] = {"...1.",
+ ".....",
+ ".1..1",
+ ".....",
+ "1...."};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int _ = 73; 
+END
+CASE(2)
+	string grid_[] = {"...1.",
+ ".1...",
+ "..1.1",
+ "1...."};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int _ = 20; 
+END
+CASE(3)
+	string grid_[] = {".....1...",
+ ".....1...",
+ "111111111",
+ ".....1...",
+ ".....1..."};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int _ = 117; 
+END
+CASE(4)
+	string grid_[] = {".........................",
+ ".........................",
+ ".........................",
+ ".........................",
+ ".........................",
+ ".........................",
+ ".........................",
+ ".........................",
+ ".........................",
+ ".........................",
+ };
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int _ = 117; 
+END
+CASE(5)
+	string grid_[] = {
+ "1...", "....", "..11",
+ };
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int _ = 36; 
+END
+CASE(6)
+	string grid_[] = {
+ "1..", "...", "..1", "..1",
+ };
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int _ = 36; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/444/1C.cpp
Index: SRM/444/1C.cpp
==================================================================
--- SRM/444/1C.cpp
+++ SRM/444/1C.cpp
@@ -0,0 +1,143 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000007;
+typedef vector< vector<LL> > matrix;
+
+vector<LL> vMul( const matrix& A, const vector<LL>& B )
+{
+  const int n = A.size();
+
+  vector<LL> C(n);
+  for(int i=0; i<n; ++i)
+    for(int j=0; j<n; ++j)
+      C[i] = (C[i] + A[i][j] * B[j]) % MODVAL;
+  return C;
+}
+
+matrix mMul( const matrix& A, const matrix& B )
+{
+  const int n = A.size();
+
+  matrix C(n, vector<LL>(n));
+  for(int i=0; i<n; ++i)
+    for(int j=0; j<n; ++j) {
+      LL Cij = 0;
+      for(int k=0; k<n; ++k)
+        Cij = (Cij + A[i][k] * B[k][j]) % MODVAL;
+      C[i][j] = Cij;
+    }
+  return C;
+}
+
+matrix mPow( matrix M, LL t ) // t>0
+{
+  matrix R;
+  for(; t; t>>=1, M=mMul(M,M))
+    if( t&1 )
+      R = (R.empty() ? M : mMul(R,M));
+  return R;
+}
+
+LL GCD(LL a, LL b) { while(a) swap(b%=a,a); return b; }
+LL LCM(LL a, LL b) { return a/GCD(a,b)*b; }
+
+class AvoidFour { public:
+  int count(long long n) 
+  {
+    matrix A(6, vector<LL>(6));
+    A[1][0] = 8; A[1][1] = 9; A[1][2] = 9; A[1][3] = 9; A[1][4] = 9;
+    A[2][0] = 1; A[2][1] = 1;
+                              A[3][2] = 1;
+                                           A[4][3] = 1;
+                 A[5][1] = 1; A[5][2] = 1; A[5][3] = 1; A[5][4] = 1; A[5][5] = 1;
+
+    vector<LL> v(6);
+    v[0] = 1;
+
+
+    vector<LL> fours;
+    for(LL f=44; f<=n; f=f*10+4)
+      fours.push_back(f);
+    int N = fours.size();
+
+    LL total = 0;
+    for(int m=0; m<(1<<N); ++m)
+    {
+      LL lcm=1, bitCnt=0;
+      for(int i=0; (1<<i)<=m; ++i)
+        if( m & (1<<i) ) {
+          lcm = LCM(lcm, fours[i]);
+          if( lcm > n )
+            break;
+          bitCnt ++;
+        }
+      if( lcm <= n ) {
+        matrix Af = mPow(A, lcm);
+        Af[5] = A[5];
+
+        LL sub = vMul(mMul(A,mPow(Af,n/lcm)), v)[5];
+        total = (bitCnt&1 ? total-sub+MODVAL : total+sub) % MODVAL;
+      }
+    }
+    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(_, AvoidFour().count(n));}
+int main(){
+
+CASE(0)
+  long long n = 4LL; 
+  int _ = 9998; 
+END
+CASE(1)
+  long long n = 5LL; 
+  int _ = 99980; 
+END
+CASE(2)
+  long long n = 87LL; 
+  int _ = 576334228; 
+END
+CASE(3)
+  long long n = 88LL; 
+  int _ = 576334228; 
+END
+CASE(4)
+  long long n = 4128LL; 
+  int _ = 547731225; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/445/1A.cpp
Index: SRM/445/1A.cpp
==================================================================
--- SRM/445/1A.cpp
+++ SRM/445/1A.cpp
@@ -0,0 +1,89 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheNewHouseDivOne { public:
+	double distance(vector <int> x, vector <int> y, int k) 
+	{
+		double minD = 1e+99;
+		for(double X=-50; X<=+50; X+=0.5)
+			for(double Y=-50; Y<=+50; Y+=0.5)
+			{
+				vector<double> d;
+				for(int i=0; i<x.size(); ++i)
+					d.push_back( abs(x[i]-X) + abs(y[i]-Y) );
+				nth_element(d.begin(), d.begin()+k-1, d.end());
+				minD = min(minD, d[k-1]);
+			}
+		return minD;
+	}
+};
+
+// 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) {
+ double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 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(_, TheNewHouseDivOne().distance(x, y, k));}
+int main(){
+
+CASE(0)
+	int x_[] = {-1, -1, 1, 1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-1, 1, -1, 1};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int k = 3; 
+	double _ = 2.0; 
+END
+CASE(1)
+	int x_[] = {-1, -1, 1, 1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-1, 1, -1, 1};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int k = 2; 
+	double _ = 1.0; 
+END
+CASE(2)
+	int x_[] = {4, 4, 4, 4, 4, 3, 3, 5, 5};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {7, 7, 7, 4, 4, 5, 6, 5, 6};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int k = 9; 
+	double _ = 1.5; 
+END
+CASE(3)
+	int x_[] = {30, -15, 24, -23, 43, -8, -6, -47, 23, -11, 43, 6, -18, 44, -46, 16, 32, 31, 13, 9, 22, 25, 4, -44, 38, -41, -20, 41, -35, 7, 25, 39, -36, -20, -5, -38, -15, -22, 0};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-45, -7, -33, 31, -8, -33, -20, -14, -50, -48, -31, 35, -24, -31, -11, 41, -41, -11, 46, -1, -5, 5, -39, -26, -40, -9, 16, 38, -30, 34, 46, -17, -27, 33, -38, 28, 46, -16, -46};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int k = 13; 
+	double _ = 32.0; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/445/1B.cpp
Index: SRM/445/1B.cpp
==================================================================
--- SRM/445/1B.cpp
+++ SRM/445/1B.cpp
@@ -0,0 +1,105 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheLockDivOne { public:
+	string password(int n, long long k) 
+	{
+		--k;
+		return lexlast(n-1, k);
+	}
+
+	string kth(int i, LL k)
+	{
+		if( i < 0 )
+			return "";
+
+		if( k & (1LL<<i) )
+			return "1" + kth(i-1, k==(1LL<<i) ? (1LL<<i)-1 : k-(1LL<<i)-1);
+		else
+			return "0" + kth(i-1, k);
+	}
+
+	string lexlast(int i, LL k)
+	{
+		if( i < 0 )
+			return "";
+
+		if( k & (1LL<<i) ) {
+			string a = kth(i-1, (1LL<<i)-1);
+			if( k == (1LL<<i) )
+				return "1" + a;
+			string b = lexlast(i-1, k-(1LL<<i)-1);
+			return "1" + max(a,b);
+		}
+		else
+			return "0" + lexlast(i-1, k);
+	}
+};
+
+// 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(_, TheLockDivOne().password(n, k));}
+int main(){
+
+CASE(0)
+	int n = 2; 
+	long long k = 4LL; 
+	string _ = "11"; 
+END
+CASE(1)
+	int n = 3; 
+	long long k = 8LL; 
+	string _ = "111"; 
+END
+CASE(2)
+	int n = 4; 
+	long long k = 6LL; 
+	string _ = "0110"; 
+END
+CASE(3)
+	int n = 10; 
+	long long k = 1LL; 
+	string _ = "0000000000"; 
+END
+CASE(4)
+	int n = 7; 
+	long long k = 100LL; 
+	string _ = "1111110"; 
+END
+CASE(4)
+	int n = 50; 
+	long long k = 0xffffffffffffLL; 
+	string _ = "1111110"; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/445/1C.cpp
Index: SRM/445/1C.cpp
==================================================================
--- SRM/445/1C.cpp
+++ SRM/445/1C.cpp
@@ -0,0 +1,130 @@
+#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>
+#include <cctype>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1234567891;
+
+class TheEncryptionDivOne { public:
+	map<vector<int>, LL> memo;
+
+	int count(string msg, string encMsg) 
+	{
+		// accumulate unused characters
+		char cs[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		set<char> ori(cs+0, cs+52), enc(cs+0, cs+52);
+		for(int i=0; i<msg.size(); ++i)
+			ori.erase(msg[i]), enc.erase(encMsg[i]);
+
+		// obviously-invalid cases
+		for(int i=0; i<msg.size(); ++i)
+			if( toupper(msg[i]) == toupper(encMsg[i]) )
+				return 0;
+		if( ori.size() != enc.size() )
+			return 0;
+
+		// count
+		vector<int> s(9);
+		for(char c='a'; c<='z'; ++c)
+		{
+			int oc = ori.count(c)+ori.count(c+'A'-'a');
+			int ec = enc.count(c)+enc.count(c+'A'-'a');
+			s[oc*3+ec] ++;
+		}
+		return rec(s);
+	}
+
+	LL rec( const vector<int>& s )
+	{
+		if( memo.count(s) )
+			return memo[s];
+
+		for(int a=1; a<=2; ++a)
+		for(int b=0; b<=2; ++b) if( s[a*3+b] )
+		{
+			LL val = 0;
+			for(int c=0; c<=2; ++c)
+			for(int d=1; d<=2; ++d) if( s[c*3+d] )
+			{
+				vector<int> t = s;
+				t[a*3+b] --;
+				if( LL choices = t[c*3+d]*d )
+				{
+					t[(a-1)*3+b] ++;
+					t[c*3+d]     --;
+					t[c*3+(d-1)] ++;
+					val += choices * rec(t);
+				}
+			}
+			return memo[s] = val%MODVAL;
+		}
+		return 1;
+	}
+};
+
+// 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(_, TheEncryptionDivOne().count(msg, encMsg));}
+int main(){
+
+CASE(0)
+	string msg = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX"; 
+	string encMsg = "cdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
+	int _ = 2; 
+END
+CASE(1)
+	string msg = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX"; 
+	string encMsg = "bcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXY"; 
+	int _ = 1; 
+END
+CASE(2)
+	string msg = "topcoder"; 
+	string encMsg = "TOPCODER"; 
+	int _ = 0; 
+END
+CASE(3)
+	string msg = "thisisaveryhardproblem"; 
+	string encMsg = "nobodywillsolveittoday"; 
+	int _ = 0; 
+END
+CASE(4)
+	string msg = "a";
+	string encMsg = "W";
+	int _ = 710479617; 
+END
+CASE(5)
+	string msg    = "aMgqyMOaWSyaAxOyvOaRAEajOOAWWAqqAAj";
+	string encMsg = "qKYEnKaqMgnqGWanlaqkGdquaaGMMGEEGGu";
+	int _ = 650838813;
+END
+
+}
+// END CUT HERE

ADDED   SRM/447-U/1A.cpp
Index: SRM/447-U/1A.cpp
==================================================================
--- SRM/447-U/1A.cpp
+++ SRM/447-U/1A.cpp
@@ -0,0 +1,171 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class KnightsTour { public:
+	int visitedPositions(vector <string> board) 
+	{
+		// sentinels
+		for(int yy=0; yy<board.size(); ++yy)
+			board[yy] = "**"+board[yy]+"**";
+		board.push_back( string(board[0].size(),'*') );
+		board.push_back( string(board[0].size(),'*') );
+		board.insert( board.begin(), string(board[0].size(),'*') );
+		board.insert( board.begin(), string(board[0].size(),'*') );
+
+		// starting point
+		int y, x;
+		for(int yy=0; yy<board.size(); ++yy)
+		for(int xx=0; xx<board[yy].size(); ++xx)
+			if(board[yy][xx]=='K')
+				y=yy, x=xx;
+
+		int n = 1;
+		while( step(board,y,x) )
+			++n;
+		return n;
+	}
+
+	bool step(vector<string>& B, int& Y, int& X)
+	{
+		int dy[]={-2,-2,-1,-1,+1,+1,+2,+2};
+		int dx[]={-1,+1,-2,+2,-2,+2,-1,+1};
+		int minAn = 9999;
+		for(int i=0; i<8; ++i)
+			if( B[Y+dy[i]][X+dx[i]] == '.' )
+				minAn = min(minAn, an(B,Y+dy[i],X+dx[i]));
+		if( minAn == 9999 )
+			return false;
+		for(int i=0; i<8; ++i)
+			if( B[Y+dy[i]][X+dx[i]] == '.' )
+				if( minAn == an(B,Y+dy[i],X+dx[i]) ) {
+					Y+=dy[i];
+					X+=dx[i];
+					B[Y][X] = 'K';
+					break;
+				}
+		return true;
+	}
+
+	int an(vector<string>& B, int Y, int X)
+	{
+		int dy[]={-2,-2,-1,-1,+1,+1,+2,+2};
+		int dx[]={-1,+1,-2,+2,-2,+2,-1,+1};
+		int cnt = 0;
+		for(int i=0; i<8; ++i)
+			cnt += (B[Y+dy[i]][X+dx[i]] == '.');
+		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(_, KnightsTour().visitedPositions(board));}
+int main(){
+
+CASE(0)
+	string board_[] = {
+ "........"
+,".*.*...."
+,".*......"
+,"..K...*."
+,"*...*..."
+,"...*...."
+,"...*.*.."
+,"........"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 39; 
+END
+CASE(1)
+	string board_[] = {
+ "K......."
+,"........"
+,"........"
+,"........"
+,"........"
+,"........"
+,"........"
+,"........"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 64; 
+END
+CASE(2)
+	string board_[] = {
+ "********"
+,"*******."
+,"********"
+,"**.***.*"
+,"********"
+,"***.*.**"
+,"********"
+,"****K***"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 3; 
+END
+CASE(3)
+	string board_[] = {
+ "*.*....*"
+,".......*"
+,"**...*.."
+,"..***..."
+,".**.*..."
+,"..*.*..K"
+,"..***.*."
+,"**...*.."};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 17; 
+END
+CASE(4)
+	string board_[] = {
+ "..*...*."
+,"**.....*"
+,"*..*...."
+,"*..*...."
+,".....*.."
+,"....*..K"
+,"**.*...*"
+,"..**...."};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 27; 
+END
+CASE(5)
+	string board_[] = {
+ "**.**"
+,"K****"
+,"**.**"
+,"**.*."
+};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 3; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/447-U/1B.cpp
Index: SRM/447-U/1B.cpp
==================================================================
--- SRM/447-U/1B.cpp
+++ SRM/447-U/1B.cpp
@@ -0,0 +1,150 @@
+#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>
+using namespace std;
+
+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;
+}
+
+static const int NV = 100;
+int biMatch( graph& G, int L ) // [0,L):left, [L,?):right
+{
+	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 PeopleYouMayKnow { public:
+	int maximalScore(vector <string> friends, int personA, int personB) 
+	{
+		int removed = 0;
+
+		// A-C-B : C must be removed
+		int N = friends.size();
+		int A = personA, B = personB;
+		for(int C=0; C<N; ++C) if(C!=A && C!=B)
+			if( friends[A][C]=='Y' && friends[C][B]=='Y' ) {
+				removed ++;
+				for(int D=0; D<N; ++D)
+					friends[C][D] = friends[D][C] = 'N';
+			}
+
+		// A-A1, B1-B : A1-B1 must be disconnected
+		vector<int> A1;
+		for(int C=0; C<N; ++C) if(C!=A && C!=B)
+			if( friends[A][C]=='Y' )
+				A1.push_back(C);
+		vector<int> B1;
+		for(int C=0; C<N; ++C) if(C!=A && C!=B)
+			if( friends[C][B]=='Y' )
+				B1.push_back(C);
+
+		// == bimatch
+		graph G(A1.size()+B1.size());
+		for(int a=0; a<A1.size(); ++a)
+			for(int b=0; b<B1.size(); ++b)
+				if( friends[A1[a]][B1[b]]=='Y' )
+					G[a].push_back( A1.size()+b );
+		return removed + biMatch(G, A1.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(_, PeopleYouMayKnow().maximalScore(friends, personA, personB));}
+int main(){
+
+CASE(0)
+	string friends_[] = {"NN"
+,"NN"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int personA = 0; 
+	int personB = 1; 
+	int _ = 0; 
+END
+CASE(1)
+	string friends_[] = {"NYNN"
+,"YNYN"
+,"NYNY"
+,"NNYN"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int personA = 0; 
+	int personB = 3; 
+	int _ = 1; 
+END
+CASE(2)
+	string friends_[] = {"NYNYYYN"
+,"YNYNNYY"
+,"NYNNNNY"
+,"YNNNNNN"
+,"YNNNNYN"
+,"YYNNYNY"
+,"NYYNNYN"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int personA = 2; 
+	int personB = 3; 
+	int _ = 1; 
+END
+CASE(3)
+	string friends_[] = {"NYYYYNNNN"
+,"YNNNNYYYN"
+,"YNNNNNNYN"
+,"YNNNNNNYN"
+,"YNNNNNNNY"
+,"NYNNNNNNY"
+,"NYNNNNNNY"
+,"NYYYNNNNY"
+,"NNNNYYYYN"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int personA = 8; 
+	int personB = 0; 
+	int _ = 3; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/447-U/1C-U.cpp
Index: SRM/447-U/1C-U.cpp
==================================================================
--- SRM/447-U/1C-U.cpp
+++ SRM/447-U/1C-U.cpp
@@ -0,0 +1,146 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CellScores { public:
+	long long countScores(int N, int M, int K, int X0, int A, int B, int Y0, int C, int D) 
+	{
+		vector<int> X(M+K,X0%N), Y(M+K,Y0%N);
+		for(int i=1; i<M+K; ++i)
+			X[i] = (X[i-1]*A+B)%N,
+			Y[i] = (Y[i-1]*C+D)%N;
+
+		vector< vector<bool> > black(N, vector<bool>(N, false));
+		for(int i=0; i<M; ++i)
+			black[Y[i]][X[i]] = true;
+
+		// how to compute them????
+		vector< vector<int> > score_b(N, vector<int>(N, 0)); // # of gd rects around(Y,X) whose bottom line is y=Y+1
+		vector< vector<int> > score_t(N, vector<int>(N, 0)); // top line is y=Y
+		vector< vector<int> > score_l(N, vector<int>(N, 0)); // ...
+		vector< vector<int> > score_r(N, vector<int>(N, 0));
+
+		// O(1) score computation
+		vector< vector<int> > score(N, vector<int>(N, 0));
+		score[0][0] = score_t[0][0];
+		for(int x=1; x<N; ++x)
+			score[0][x] = score[0][x-1] - score_r[0][x-x] + score_l[0][x];
+		for(int y=1; y<N; ++y)
+			for(int x=0; x<N; ++x)
+				score[y][x] = score[y-1][x] - score_b[y-1][x] + score_t[y][x];
+
+		LL ss = 0;
+		for(int i=M; i<M+K; ++i)
+			ss += score[Y[i]][X[i]];
+		return ss;
+	}
+};
+
+// 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(_, CellScores().countScores(N, M, K, X0, A, B, Y0, C, D));}
+int main(){
+
+CASE(0)
+	int N = 10; 
+	int M = 0; 
+	int K = 1; 
+	int X0 = 0; 
+	int A = 1; 
+	int B = 1; 
+	int Y0 = 0; 
+	int C = 1; 
+	int D = 1; 
+	long long _ = 100LL; 
+END
+CASE(1)
+	int N = 10; 
+	int M = 1; 
+	int K = 1; 
+	int X0 = 5; 
+	int A = 1; 
+	int B = 5; 
+	int Y0 = 5; 
+	int C = 1; 
+	int D = 5; 
+	long long _ = 75LL; 
+END
+CASE(2)
+	int N = 7; 
+	int M = 4; 
+	int K = 3; 
+	int X0 = 0; 
+	int A = 1; 
+	int B = 1; 
+	int Y0 = 0; 
+	int C = 1; 
+	int D = 1; 
+	long long _ = 194LL; 
+END
+CASE(3)
+	int N = 23; 
+	int M = 10; 
+	int K = 30; 
+	int X0 = 26; 
+	int A = 48; 
+	int B = 76; 
+	int Y0 = 231; 
+	int C = 463; 
+	int D = 707; 
+	long long _ = 8088LL; 
+END
+CASE(4)
+	int N = 211; 
+	int M = 30; 
+	int K = 12; 
+	int X0 = 3; 
+	int A = 35; 
+	int B = 82; 
+	int Y0 = 0; 
+	int C = 43; 
+	int D = 15; 
+	long long _ = 18196443LL; 
+END
+CASE(5)
+	int N = 3; 
+	int M = 0; 
+	int K = 100; 
+	int X0 = 0; 
+	int A = 0; 
+	int B = 0; 
+	int Y0 = 0; 
+	int C = 0; 
+	int D = 0; 
+	long long _ = 900LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/450-U/1A.cpp
Index: SRM/450-U/1A.cpp
==================================================================
--- SRM/450-U/1A.cpp
+++ SRM/450-U/1A.cpp
@@ -0,0 +1,88 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class OrderedNim { public:
+	string winner(vector <int> layout) 
+	{
+		bool firstWin = false;
+		for(int i=layout.size()-1; i>=0; --i)
+			if( layout[i] == 1 )
+				firstWin = !firstWin;
+			else
+				firstWin = true;
+		return firstWin ? "Alice" : "Bob";
+	}
+};
+
+// 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(_, OrderedNim().winner(layout));}
+int main(){
+
+CASE(0)
+	int layout_[] = {5};
+	  vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	string _ = "Alice"; 
+END
+CASE(1)
+	int layout_[] = {1,2};
+	  vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	string _ = "Bob"; 
+END
+CASE(2)
+	int layout_[] = {2,1};
+	  vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	string _ = "Alice"; 
+END
+CASE(3)
+	int layout_[] = {10,9,8,7,6,5,4,3,2,1};
+	  vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	string _ = "Alice"; 
+END
+CASE(4)
+	int layout_[] = {1,1,1,1};
+	  vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	string _ = "Bob"; 
+END
+CASE(5)
+	int layout_[] = {1};
+	  vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	string _ = "Alice"; 
+END
+CASE(6)
+	int layout_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+	  vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_)); 
+	string _ = "Bob"; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/450-U/1B.cpp
Index: SRM/450-U/1B.cpp
==================================================================
--- SRM/450-U/1B.cpp
+++ SRM/450-U/1B.cpp
@@ -0,0 +1,125 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class StrongEconomy { public:
+
+	long long earn(long long n, long long k, long long price, long long target) 
+	{
+		if( target/n < k )
+			return 1;
+
+		LL best = target;
+		for(LL money=0, round=0; round+1<best;)
+		{
+			// ここから何もしなかった場合のラウンド数
+			best = min(best, round + roundsNeededToEarn(target-money, n*k));
+
+			// (n,k) を増やせる様になるまで待つ
+			if( money < price )
+			{
+				LL rp = roundsNeededToEarn(price-money, n*k);
+				round += rp;
+				money += n*k*rp;
+			}
+
+			// (n,k) を増やしてみる
+			//   - もう増やさない方がいい可能性は「何もしなかった場合」で考慮済み
+			//   - 今増やさず後で増やす方がいい、ということはあり得ない
+			(n<k ? n : k)++;
+			money -= price;
+		}
+		return best;
+	}
+
+	LL roundsNeededToEarn(LL t, LL v)
+	{
+		return (t-1)/v + 1;
+	}
+};
+
+// 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(_, StrongEconomy().earn(n, k, price, target));}
+int main(){
+
+CASE(0)
+	long long n = 2LL; 
+	long long k = 1LL; 
+	long long price = 2LL; 
+	long long target = 10LL; 
+	long long _ = 4LL; 
+END
+CASE(1)
+	long long n = 2LL; 
+	long long k = 1LL; 
+	long long price = 2LL; 
+	long long target = 9LL; 
+	long long _ = 3LL; 
+END
+CASE(2)
+	long long n = 1LL; 
+	long long k = 1LL; 
+	long long price = 500000LL; 
+	long long target = 1000002LL; 
+	long long _ = 1000001LL; 
+END
+CASE(3)
+	long long n = 5LL; 
+	long long k = 4LL; 
+	long long price = 15LL; 
+	long long target = 100LL; 
+	long long _ = 5LL; 
+END
+CASE(4)
+	long long n = 1000000000000LL; 
+	long long k = 1000000000000LL; 
+	long long price = 1000000000000LL; 
+	long long target = 1000000000000LL; 
+	long long _ = 1LL; 
+END
+CASE(5)
+	long long n = 1LL; 
+	long long k = 1LL; 
+	long long price = 1000000000000LL; 
+	long long target = 1000000000000LL; 
+	long long _ = 1000000000000LL; 
+END
+CASE(6)
+	long long n = 1LL; 
+	long long k = 1LL; 
+	long long price = 1LL; 
+	long long target = 1000000000000LL; 
+	long long _ = 8LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/450-U/1C-U.cpp
Index: SRM/450-U/1C-U.cpp
==================================================================
--- SRM/450-U/1C-U.cpp
+++ SRM/450-U/1C-U.cpp
@@ -0,0 +1,131 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class RowGame { public:
+	long long score(vector <int> board, int k) 
+	{
+		int N = board.size();
+		vector<LL> best(N, -1);
+		best[0] = 0;
+
+		LL bestOfBest = 0;
+		LL dif = -1, loopCnt = 0;
+
+		int dir=+1;
+		for(int ki=0; ki<k; ++ki, dir=-dir)
+		{
+			vector<LL> best2(N, -1);
+			for(int s=0; s<N; ++s)
+				if( best[s] >= 0 )
+				{
+					LL sum = 0;
+					for(int t=s; 0<=t && t<N; t+=dir) {
+						sum += board[t];
+						if( best[s]+sum >= 0 )
+						best2[t] = max(best2[t], best[s]+sum);
+					}
+				}
+			best.swap(best2);
+			LL bb2 = max(bestOfBest, *max_element(best.begin(), best.end()));
+			{
+				if( bb2-bestOfBest == dif )
+					++loopCnt;
+				else {
+					loopCnt = 0;
+					dif = bb2-bestOfBest;
+				}
+				if( loopCnt >= 2501 )
+					return bestOfBest + dif*(k-ki);
+			}
+			bestOfBest = bb2;
+		}
+		return bestOfBest;
+	}
+};
+
+// 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(_, RowGame().score(board, k));}
+int main(){
+
+CASE(0)
+	int board_[] = {2,-2,4,3,-10} ;
+	  vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int k = 3; 
+	long long _ = 21LL; 
+END
+CASE(1)
+	int board_[] = {-6,5};
+	  vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int k = 10; 
+	long long _ = 0LL; 
+END
+CASE(2)
+	int board_[] = {5,-6};
+	  vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int k = 10; 
+	long long _ = 50LL; 
+END
+CASE(3)
+	int board_[] = {10,-100,80};
+	  vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int k = 3; 
+	long long _ = 30LL; 
+END
+CASE(4)
+	int board_[] = {10,-100,80};
+	  vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int k = 4; 
+	long long _ = 90LL; 
+END
+CASE(5)
+	int board_[] = {-100,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
+	  vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int k = 400000000; 
+	long long _ = 41999999900LL; 
+END
+/*
+CASE(6)
+	int board_[] = ;
+	  vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int k = ; 
+	long long _ = LL; 
+END
+CASE(7)
+	int board_[] = ;
+	  vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int k = ; 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/451-U/1A.cpp
Index: SRM/451-U/1A.cpp
==================================================================
--- SRM/451-U/1A.cpp
+++ SRM/451-U/1A.cpp
@@ -0,0 +1,107 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class MagicalSource { public:
+	long long calculate(long long x) 
+	{
+		LL d[] = {
+			1LL,
+			11LL,
+			111LL,
+			1111LL,
+			11111LL,
+			111111LL,
+			1111111LL,
+			11111111LL,
+			111111111LL,
+			1111111111LL,
+			11111111111LL,
+			111111111111LL,
+			1111111111111LL,
+		};
+		int N = sizeof(d) / sizeof(*d);
+		assert( d[N-1] > 1000000000000LL );
+		for(int i=N-1; i>=0; --i)
+			if( x%d[i] == 0 )
+				return x/d[i];
+		return x; // unreachable
+	}
+};
+
+// 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(_, MagicalSource().calculate(x));}
+int main(){
+
+CASE(0)
+	long long x = 1371110974LL; 
+	long long _ = 1234LL; 
+END
+CASE(1)
+	long long x = 111111LL; 
+	long long _ = 1LL; 
+END
+CASE(2)
+	long long x = 10989LL; 
+	long long _ = 99LL; 
+END
+CASE(3)
+	long long x = 120LL; 
+	long long _ = 120LL; 
+END
+CASE(4)
+	long long x = 109999999989LL; 
+	long long _ = 99LL; 
+END
+CASE(5)
+	long long x = 1LL; 
+	long long _ = 1LL; 
+END
+CASE(6)
+	long long x = 1000000000000LL; 
+	long long _ = 1000000000000LL; 
+END
+CASE(7)
+	long long x = 111111111111LL; 
+	long long _ = 1LL; 
+END
+CASE(8)
+	long long x = 123456654321LL; 
+	long long _ = 111111LL; 
+END
+CASE(9)
+	long long x = 12222221LL; 
+	long long _ = 11LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/451-U/1B.cpp
Index: SRM/451-U/1B.cpp
==================================================================
--- SRM/451-U/1B.cpp
+++ SRM/451-U/1B.cpp
@@ -0,0 +1,174 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BaronsAndCoins { public:
+	int getMaximum(vector <int> x, vector <int> y) 
+	{
+		vector< pair<int,int> > P;
+		for(int i=0; i<x.size(); ++i)
+			P.push_back( make_pair(y[i], x[i]) );
+		P.push_back( make_pair(0, 0) );
+		sort( P.begin(), P.end() );
+
+		return maxDepth(0, 0, P);
+	}
+
+	map<pair<int,int>,int> memo;
+	int maxDepth( int i, int k, vector< pair<int,int> >& P )
+	{
+		pair<int,int> key(i,k);
+		if( memo.count(key) )
+			return memo[key];
+
+		int md = 0;
+		for(int j=i+1; j<P.size(); ++j)
+		{
+			int lk = leastReachK( P[j].first-P[i].first, P[j].second-P[i].second, k );
+			if( lk > 0 )
+				md = max(md, 1 + maxDepth(j, lk, P));
+		}
+		return memo[key] = md;
+	}
+
+	int leastReachK( int dy, int dx, int k )
+	{
+		if( dy <= 0 || dx <= 0 )
+			return -1;
+
+		int minX = ((k+1)+(k+dy))*dy / 2;
+		if( dx < minX )
+			return -1;
+
+		int curK = k+dy;
+		int rest = dx - minX;
+		while( rest )
+		{
+			curK += rest / dy;
+			rest %= dy;
+			--dy;
+		}
+		return curK;
+	}
+};
+
+// 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(_, BaronsAndCoins().getMaximum(x, y));}
+int main(){
+
+CASE(0)
+	int x_[] = {15, 5, 30};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {4, 5, 6};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 2; 
+END
+CASE(1)
+	int x_[] = {10};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {10};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 0; 
+END
+CASE(2)
+	int x_[] = {1, 3, 6, 10, 15, 21};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1, 2, 3, 4, 5, 6};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 6; 
+END
+CASE(3)
+	int x_[] = {5, 10, 15, 20, 25, 30, 35, 40, 45};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1, 1, 1, 2, 2, 2, 3, 3, 3};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 3; 
+END
+CASE(4)
+	int x_[] = {1, 3, 6, 10, 22, 35, 50, 66};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1, 2, 3, 1, 2, 3, 4, 5};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 5; 
+END
+CASE(5)
+	int x_[] = {10};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {4};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 1; 
+END
+CASE(6)
+	int x_[] = {9};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {4};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 0; 
+END
+CASE(7)
+	int x_[] = {11};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {4};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 1; 
+END
+CASE(8)
+	int x_[] = {1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,276,300,325,351,378,406,435,465,496,528,561,595,630,666,703,741,780,820,861,903,946,990,1035,1081,1128,1176,1225,1275};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 50; 
+END
+CASE(9)
+	int x_[] = {1,30,60,100,150,210,280,360,450,550,660,780,910,1050,1200,1360,1530,1710,1900,2100,2310,2530,2760,3000,3250,3510,3780,4060,4350,4650,4960,5280,5610,5950,6300,6660,7030,7410,7800,8200,8610,9030,9460,9900};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 44; 
+END
+CASE(10)
+	int x_[] = {999,3,15};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,2,3};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 2; 
+END
+CASE(11)
+	int x_[] = {4,12,18};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,3,4};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int _ = 2; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/452/1A.cpp
Index: SRM/452/1A.cpp
==================================================================
--- SRM/452/1A.cpp
+++ SRM/452/1A.cpp
@@ -0,0 +1,84 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class NotTwo { public:
+	int maxStones(int width, int height) 
+	{
+		return ms( (width+1)/2, (height+1)/2 )
+			+  ms( (width+1)/2, height/2 )
+			+  ms( width/2, (height+1)/2 )
+			+  ms( width/2, height/2 );
+	}
+	int ms( int w, int h )
+	{
+		return ((w+1)/2) * ((h+1)/2) + (w/2)*(h/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(_, NotTwo().maxStones(width, height));}
+int main(){
+
+CASE(0)
+	int width = 3; 
+	int height = 2; 
+	int _ = 4; 
+END
+CASE(1)
+	int width = 3; 
+	int height = 3; 
+	int _ = 5; 
+END
+CASE(2)
+	int width = 8; 
+	int height = 5; 
+	int _ = 20; 
+END
+CASE(3)
+	int width = 1; 
+	int height = 1; 
+	int _ = 1; 
+END
+CASE(4)
+	int width = 1; 
+	int height = 2; 
+	int _ = 2; 
+END
+CASE(5)
+	int width = 1; 
+	int height = 3; 
+	int _ = 2; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/452/1B.cpp
Index: SRM/452/1B.cpp
==================================================================
--- SRM/452/1B.cpp
+++ SRM/452/1B.cpp
@@ -0,0 +1,186 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+LL MODVAL = 1000000007LL;
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL POW(LL x, LL e) {
+	LL v = 1;
+	for(;e;x=MUL(x,x),e>>=1)
+		if(e&1)
+			v = MUL(v, x);
+	return v;
+}
+
+class IOIString { public:
+	string  s;
+	LL nI, nQ;
+
+	int countIOIs(vector <string> mask) 
+	{
+		s  = accumulate( mask.begin(), mask.end(), string("") );
+		nI = count( s.begin(), s.end(), 'I' );
+		nQ = count( s.begin(), s.end(), '?' );
+
+		return SUB( POW(2,nQ), non_IOI() );
+	}
+
+	LL non_IOI()
+	{
+		LL ans = 0;
+		if( nI == 0 ) ans = ADD(ans,  1); // #I == 0
+		if( nI == 0 ) ans = ADD(ans, nQ); // #I == 1
+		if( nI == 1 ) ans = ADD(ans,  1); // #I == 1
+		for(int D=1; D<s.size(); D+=2)
+			for(int S=0; S<D; ++S)
+				ans = ADD(ans, non_IOI_2(S, D)); // #I >= 2
+		return ans;
+	}
+
+	LL non_IOI_2( int S, int D )
+	{
+		string t;
+		for(int i=S; i<s.size(); i+=D)
+			t += s[i];
+
+		// t 以外の部分は全部 'O' でないとダメ
+		if( count(t.begin(), t.end(), 'I') < nI )
+			return 0;
+
+		// t は /O*II+O*/ にマッチしないとダメ。4状態のオートマトンでDP
+		LL q0=1, q1=0, q2=0, q3=0;
+		for(int i=0; i<t.size(); ++i)
+		{
+			LL p0 = (t[i]=='O' ?         q0 : t[i]=='I' ?          0 : q0);
+			LL p1 = (t[i]=='O' ?          0 : t[i]=='I' ?         q0 : q0);
+			LL p2 = (t[i]=='O' ?          0 : t[i]=='I' ? ADD(q1,q2) : ADD(q1,q2));
+			LL p3 = (t[i]=='O' ? ADD(q2,q3) : t[i]=='I' ?          0 : ADD(q2,q3));
+			q0=p0, q1=p1, q2=p2, q3=p3;
+		}
+		return ADD(q2, q3);
+	}
+};
+
+// 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(_, IOIString().countIOIs(mask));}
+int main(){
+
+CASE(0)
+	string mask_[] = {"IO?"};
+	  vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string mask_[] = {"????"};
+	  vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_)); 
+	int _ = 4; 
+END
+CASE(2)
+	string mask_[] = {"?II"};
+	  vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_)); 
+	int _ = 0; 
+END
+CASE(3)
+	string mask_[] = {"I??O??I"};
+	  vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_)); 
+	int _ = 16; 
+END
+CASE(4)
+	string mask_[] = {"???I???????O???","???????????O??IO????????I???"};
+	  vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_)); 
+	int _ = 438952513; 
+END
+CASE(5)
+	string mask_[] = {"?"};
+	  vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_)); 
+	int _ = 0; 
+END
+CASE(6)
+	string mask_[] = {
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+"??????????????????????????????????????????????????",
+};
+	  vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_)); 
+	int _ = 967087276; 
+END
+}
+// END CUT HERE

ADDED   SRM/452/1C.cpp
Index: SRM/452/1C.cpp
==================================================================
--- SRM/452/1C.cpp
+++ SRM/452/1C.cpp
@@ -0,0 +1,179 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+// mod 演算用ユーティリティ
+LL MODVAL = 1000000007LL;
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL POW(LL x, LL e) {
+   LL v = 1;
+   for(;e;x=MUL(x,x),e>>=1)
+      if(e&1)
+         v = MUL(v, x);
+   return v;
+}
+LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
+LL C(LL n, LL k) {
+   LL v = 1;
+   k = min(k, n-k);
+   for(LL i=1; i<=k; ++i)
+      v = DIV(MUL(v, n-i+1), i);
+   return v;
+}
+
+// 本体
+class IncreasingNumber { public:
+   int countNumbers(long long digits, int divisor) 
+   {
+      LL  N = digits;
+      int D = divisor;
+
+      //  ちょうど N 桁の Increasing number
+      //＝
+      //  0<=Σa<=8 な a[] を使って
+      //    1*a[0] + 11*a[1] + ... + 111..111*(a[N-1]+1)
+      //  の形で書ける数
+      //
+      //なので
+      //
+      //  D で割れるちょうど N 桁の Increasing number の個数
+      //＝
+      //  0<=Σa<=8 な a[] で
+      //     coeff[0]*a[0] + coeff[1]*a[1] + ... + coeff[N-1]*(a[N-1]+1) = 0
+      //  なものの個数 ( where coeff[i] := "1がi+1個並んだもの" % D )
+
+
+      // ステージ１
+
+      vector<LL> nc(D); // nc[m] = (coeff[i]%D==m な i の数)
+      int       ceLast; // coeff[N-1]
+      {
+         // coeff は高々 D 回でループしてるはず
+         vector<int> coeff;
+         int loop_start = -1;
+         for(int v=1%D ;;)
+         {
+            loop_start = find(coeff.begin(), coeff.end(), v) - coeff.begin();
+            if( loop_start != coeff.size() )
+               break;
+            coeff.push_back( v );
+            v = (v*10 + 1) % D;
+         }
+         int loop_len = coeff.size() - loop_start;
+
+         for(int i=0; i<coeff.size() && i<N; ++i)
+            if( i < loop_start )
+               nc[coeff[i]] = 1;
+            else
+               nc[coeff[i]] = (N-i+loop_len-1)/loop_len % MODVAL;
+         ceLast = N-1 < loop_start ? coeff[N-1]
+                                   : coeff[(N-1-loop_start)%loop_len+loop_start];
+      }
+
+
+      // ステージ1.5
+
+      vector< vector<LL> > choice(D, vector<LL>(9));
+      for(int m=0; m<D; ++m)
+         for(int n=0; n<=8; ++n)
+            // nc[m] 種類のものから n 個取る取り方
+            choice[m][n] = (n==0 ? 1 : nc[m]==0 ? 0 : C(n+nc[m]-1, nc[m]-1));
+
+
+      // ステージ２
+      // dp[m][n][q] = 余り [0, 1, ... m] 係数から n 個使って総和を余り q にするやり方は何通り？
+
+      vector< vector< vector<LL> > > dp(D, vector< vector<LL> >(9, vector<LL>(D)));
+      for(int m=0; m<D; ++m)
+         dp[m][0][ceLast] = 1;
+      for(int n=1; n<=8; ++n)
+         dp[0][n][ceLast] = choice[0][n];
+      for(int m=1; m<D; ++m)
+         for(int n=1; n<=8; ++n)
+            for(int q=0; q<D; ++q)
+               for(int k=0,q2=q; k<=n; ++k,q2=(q2-m+D)%D)
+                  dp[m][n][q] = ADD( dp[m][n][q], MUL( dp[m-1][n-k][q2], choice[m][k] ) );
+
+      LL ans = 0;
+      for(int n=0; n<=8; ++n)
+         ans = ADD(ans, dp[D-1][n][0]);
+      return ans;
+   }
+};
+
+// 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(_, IncreasingNumber().countNumbers(digits, divisor));}
+int main(){
+CASE(-2)
+   long long digits = 1LL;
+   int divisor = 16; 
+   int _ = 0; 
+END
+CASE(-1)
+   long long digits = 1LL;
+   int divisor = 1; 
+   int _ = 9; 
+END
+CASE(0)
+   long long digits = 2LL; 
+   int divisor = 12; 
+   int _ = 4; 
+END
+CASE(1)
+   long long digits = 3LL; 
+   int divisor = 111; 
+   int _ = 9; 
+END
+CASE(2)
+   long long digits = 452LL; 
+   int divisor = 10; 
+   int _ = 0; 
+END
+CASE(3)
+   long long digits = 6LL; 
+   int divisor = 58; 
+   int _ = 38; 
+END
+CASE(4)
+   long long digits = 1000000000000000000LL; 
+   int divisor = 500; 
+   int _ = 0; 
+END
+CASE(5)
+   long long digits = 26542766498659LL; 
+   int divisor = 25; 
+   int _ = 766312864; 
+END
+}
+// END CUT HERE

ADDED   SRM/453.5/1A.cpp
Index: SRM/453.5/1A.cpp
==================================================================
--- SRM/453.5/1A.cpp
+++ SRM/453.5/1A.cpp
@@ -0,0 +1,180 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class MazeMaker { public:
+	int longestPath(vector <string> maze, int startRow, int startCol, vector <int> moveRow, vector <int> moveCol) 
+	{
+		const int H = maze.size();
+		const int W = maze[0].size();
+
+		typedef pair<int,int> point;
+
+		int cell = 0;
+		for(int y=0; y<H; ++y)
+			for(int x=0; x<W; ++x)
+				if( maze[y][x] == '.' )
+					++cell;
+
+		vector<point> q(1, point(startRow, startCol));
+		set<point> visited; visited.insert(q[0]);
+
+		for(int step=0 ;; ++step)
+		{
+			vector<point> q2;
+			for(int i=0; i<q.size(); ++i)
+				for(int j=0; j<moveRow.size(); ++j)
+				{
+					int yy = q[i].first+moveRow[j];
+					int xx = q[i].second+moveCol[j];
+					point pp( yy, xx );
+					if( visited.count(pp) || yy<0 || H<=yy || xx<0 || W<=xx || maze[yy][xx]!='.' )
+						continue;
+					visited.insert(pp);
+					q2.push_back(pp);
+				}
+			q.swap(q2);
+
+			if( q.empty() )
+				return (visited.size()==cell ? step : -1);
+		}
+		assert(false);
+	}
+};
+
+// 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(_, MazeMaker().longestPath(maze, startRow, startCol, moveRow, moveCol));}
+int main(){
+
+CASE(0)
+	string maze_[] = {"...",
+ "...",
+ "..."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int startRow = 0; 
+	int startCol = 1; 
+	int moveRow_[] = {1,0,-1,0};
+	  vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_)); 
+	int moveCol_[] = {0,1,0,-1};
+	  vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_)); 
+	int _ = 3; 
+END
+CASE(1)
+	string maze_[] = {"...",
+ "...",
+ "..."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int startRow = 0; 
+	int startCol = 1; 
+	int moveRow_[] = {1, 0, -1, 0, 1, 1, -1, -1};
+	  vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_)); 
+	int moveCol_[] = {0, 1, 0, -1, 1, -1, 1, -1};
+	  vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_)); 
+	int _ = 2; 
+END
+CASE(2)
+	string maze_[] = {"X.X",
+ "...",
+ "XXX",
+ "X.X"};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int startRow = 0; 
+	int startCol = 1; 
+	int moveRow_[] = {1, 0, -1, 0};
+	  vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_)); 
+	int moveCol_[] = {0, 1, 0, -1};
+	  vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_)); 
+	int _ = -1; 
+END
+CASE(3)
+	string maze_[] = {".......",
+ "X.X.X..",
+ "XXX...X",
+ "....X..",
+ "X....X.",
+ "......."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int startRow = 5; 
+	int startCol = 0; 
+	int moveRow_[] = {1, 0, -1, 0,-2, 1};
+	  vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_)); 
+	int moveCol_[] = {0, -1, 0, 1, 3, 0};
+	  vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_)); 
+	int _ = 7; 
+END
+CASE(4)
+	string maze_[] = {"......."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int startRow = 0; 
+	int startCol = 0; 
+	int moveRow_[] = {1, 0, 1, 0, 1, 0};
+	  vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_)); 
+	int moveCol_[] = {0, 1, 0, 1, 0, 1};
+	  vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_)); 
+	int _ = 6; 
+END
+CASE(5)
+	string maze_[] = {"..X.X.X.X.X.X."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int startRow = 0; 
+	int startCol = 0; 
+	int moveRow_[] = {2,0,-2,0};
+	  vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_)); 
+	int moveCol_[] = {0,2,0,-2};
+	  vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_)); 
+	int _ = -1; 
+END
+CASE(6)
+	string maze_[] = {".X","X."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int startRow = 0; 
+	int startCol = 0; 
+	int moveRow_[] = {1};
+	  vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_)); 
+	int moveCol_[] = {1};
+	  vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_)); 
+	int _ = 1; 
+END
+CASE(7)
+	string maze_[] = {".X","X."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int startRow = 0; 
+	int startCol = 0; 
+	int moveRow_[] = {1};
+	  vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_)); 
+	int moveCol_[] = {0};
+	  vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_)); 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/453.5/1B.cpp
Index: SRM/453.5/1B.cpp
==================================================================
--- SRM/453.5/1B.cpp
+++ SRM/453.5/1B.cpp
@@ -0,0 +1,100 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PlanarGraphShop { public:
+	int bestCount(int N) 
+	{
+		set<int> possible;
+		possible.insert(1*1*1 + 0*0);
+		possible.insert(2*2*2 + 0*0);
+		possible.insert(2*2*2 + 1*1);
+		for(int V=3,EMax=3; V*V*V<=N; ++V,EMax+=3)
+			for(int E=0; V*V*V+E*E<=N && E<=EMax; ++E)
+				possible.insert(V*V*V + E*E);
+		vector<int> p(possible.rbegin(), possible.rend());
+
+		vector<int> q(1, 0);
+		vector<bool> visited(N+1);
+		for(int step=0 ;; ++step)
+		{
+			vector<int> q2;
+			for(int i=0; i!=q.size(); ++i)
+			{
+				if( q[i] == N ) 
+					return step;
+
+				for(int j=0; j<p.size(); ++j)
+				{
+					int next = q[i] + p[j];
+					if( next>N || visited[next] )
+						continue;
+					visited[next] = true;
+					q2.push_back(next);
+				}
+			}
+			q.swap(q2);
+		}
+		assert(false);
+	}
+};
+
+// 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(_, PlanarGraphShop().bestCount(N));}
+int main(){
+
+CASE(0)
+	int N = 36; 
+	int _ = 1; 
+END
+CASE(1)
+	int N = 7; 
+	int _ = 7; 
+END
+CASE(2)
+	int N = 72; 
+	int _ = 2; 
+END
+CASE(3)
+	int N = 46; 
+	int _ = 3; 
+END
+CASE(4)
+	int N = 50000; 
+	int _ = -1; 
+END
+CASE(5)
+	int N = 1; 
+	int _ = 1; 
+END
+}
+// END CUT HERE

ADDED   SRM/453.5/1C.cpp
Index: SRM/453.5/1C.cpp
==================================================================
--- SRM/453.5/1C.cpp
+++ SRM/453.5/1C.cpp
@@ -0,0 +1,161 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+typedef long long LL;
+LL gcd(LL a, LL b)
+{
+   while(a)
+      swap(a, b%=a);
+   return b;
+}
+
+LL lcm(LL a, LL b)
+{
+   return a/gcd(a,b)*b;
+}
+
+class TheAlmostLuckyNumbers { public:
+   void genLuck(vector<LL>& v)
+   {
+      // lucky numbers
+      vector<LL> u;
+      for(int d=1; d<=10; ++d)
+         genLuck(d, u);
+
+      // filtering
+      for(int i=0; i<u.size(); ++i)
+      {
+         for(int j=0; j<i; ++j)
+            if( u[i] % u[j] == 0 )
+               goto next;
+         v.push_back( u[i] );
+      next:;
+      }
+      sort(v.begin(), v.end());
+   }
+
+   void genLuck(int d, vector<LL>& v)
+   {
+      // d-digit lucky numbers
+      for(int b=0; b<(1<<d); ++b)
+      {
+         LL n = 0;
+         for(int i=0; i<d; ++i)
+            n = n*10 + (b&(1<<i) ? 4 : 7);
+         v.push_back(n);
+      }
+   }
+
+   long long count(long long a, long long b) 
+   {
+      vector<LL> v;
+      genLuck(v);
+
+      static const int M = 16;
+
+      // inclusion-exclusion
+      LL cnt = 0;
+      {
+         for(int m=1; m<(1<<M); ++m)
+         {
+            int bc = 0;
+            LL n = 1;
+            for(int i=0; i<M; ++i)
+               if( m & (1<<i) )
+                  ++bc, n=lcm(n, v[i]);
+            cnt += (bc&1) ? (b/n-(a-1)/n) : -(b/n-(a-1)/n);
+         }
+      }
+
+      // sieve
+      vector<LL> aml; // almost lucky numbers
+      for(int i=M; i<v.size() && v[i]<=b; ++i)
+      {
+         LL u = v[i];
+         for(LL s=a%u?(a/u+1)*u:a; s<=b; s+=u)
+         {
+            for(int k=0; k<M; ++k)
+               if( s%v[k]==0 )
+                  goto next;
+            aml.push_back(s);
+         next:;
+         }
+         if( aml.size() > 10000000 ) {
+            sort(aml.begin(), aml.end());
+            aml.erase(unique(aml.begin(), aml.end()), aml.end());
+         }
+      }
+
+      sort(aml.begin(), aml.end());
+      aml.erase(unique(aml.begin(), aml.end()), aml.end());
+      return cnt + aml.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 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(_, TheAlmostLuckyNumbers().count(a, b));}
+int main(){
+
+CASE(0)
+   long long a = 1LL; 
+   long long b = 10LL; 
+   long long _ = 3LL; 
+END
+CASE(1)
+   long long a = 14LL; 
+   long long b = 14LL; 
+   long long _ = 1LL; 
+END
+CASE(2)
+   long long a = 1LL; 
+   long long b = 100LL; 
+   long long _ = 39LL; 
+END
+CASE(3)
+   long long a = 1234LL; 
+   long long b = 4321LL; 
+   long long _ = 1178LL; 
+END
+CASE(4)
+   long long a = 1LL; 
+   long long b = 10000000000LL; 
+   long long _ = -1LL; 
+END
+CASE(5)
+   long long a = 10000000000LL; 
+   long long b = 10000000000LL; 
+   long long _ = -1LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/454-U/1A.cpp
Index: SRM/454-U/1A.cpp
==================================================================
--- SRM/454-U/1A.cpp
+++ SRM/454-U/1A.cpp
@@ -0,0 +1,133 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class DoubleXor { public:
+	int calculate(int N) 
+	{
+		int x = N;
+		for(int y=N-1; y>=1; --y)
+			x = dxor(x, y);
+
+		int z = 1;
+		for(int y=2; y<=N; ++y)
+			z = dxor(z, y);
+if( x != z )
+cerr << N << ": " << x << " -- " << z << endl; 
+		return x;
+	}
+	int dxor(int x, int y)
+	{
+		int z = 0;
+		int d = 1;
+		while( x>0 || y>0 ) {
+			z += d * ((x%10 ^ y%10)%10);
+			x /= 10;
+			y /= 10;
+			d *= 10;
+		}
+		return z;
+	}
+};
+
+// 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(_, DoubleXor().calculate(N));}
+int main(){
+
+for(int N=1;;++N) {
+CASE(-2)
+	int _ = -1; 
+END
+}
+CASE(-1)
+	int N = 8; 
+	int _ = 2; 
+END
+CASE(0)
+	int N = 1; 
+	int _ = 1; 
+END
+CASE(1)
+	int N = 2; 
+	int _ = 3; 
+END
+CASE(2)
+	int N = 7; 
+	int _ = 0; 
+END
+CASE(3)
+	int N = 10; 
+	int _ = 11; 
+END
+CASE(4)
+	int N = 102; 
+	int _ = 103; 
+END
+CASE(5)
+	int N = 1000000; 
+	int _ = -1; 
+END
+CASE(6)
+	int N = 1; 
+	int _ = 1; 
+END
+CASE(6)
+	int N = 2; 
+	int _ = 3; 
+END
+CASE(6)
+	int N = 3; 
+	int _ = 0; 
+END
+CASE(6)
+	int N = 4; 
+	int _ = 4; 
+END
+CASE(6)
+	int N = 5; 
+	int _ = 1; 
+END
+CASE(6)
+	int N = 6; 
+	int _ = 7; 
+END
+CASE(6)
+	int N = 7; 
+	int _ = 0; 
+END
+CASE(6)
+	int N = 9; 
+	int _ = 1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/454-U/1B.cpp
Index: SRM/454-U/1B.cpp
==================================================================
--- SRM/454-U/1B.cpp
+++ SRM/454-U/1B.cpp
@@ -0,0 +1,148 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename T>
+struct DP2
+{
+	const int N1, N2;
+	vector<T> data;
+	DP2(int N1, int N2, const T& t = T())
+		: N1(N1), N2(N2), data(N1*N2, t) {}
+	T& operator()(int i1, int i2)
+		{ return data[ (i1*N2)+i2 ]; }
+	void swap(DP2& rhs)
+		{ data.swap(rhs.data); }
+};
+
+class NumbersAndMatches { public:
+	long long differentNumbers(long long N, int K) 
+	{
+		string s;
+		for(; N; N/=10)
+			s = char('0' + N%10) + s;
+
+		DP2<LL> dp(127,127);
+		dp(0,0) = 1;
+
+		for(int i=0; i<s.size(); ++i)
+		{
+			DP2<LL> dp2(127, 127);
+			for(int tooMany=0; tooMany<=K; ++tooMany)
+			for(int tooFew=0; tooFew<=K; ++tooFew)
+				for(char c='0'; c<='9'; ++c)
+				{
+					int tM=tooMany, tF=tooFew;
+					diff(s[i], c, &tM, &tF);
+					if( tM<=K && tF<=K )
+						dp2(tM,tF) += dp(tooMany,tooFew);
+				}
+			dp.swap(dp2);
+		}
+
+		LL ans = 0;
+		for(int tMF=0; tMF<=K; ++tMF)
+			ans += dp(tMF, tMF);
+		return ans;
+	}
+
+	void diff(char a, char b, int* tF, int* tM)
+	{
+		const char* a7 = seven_seg(a);
+		const char* b7 = seven_seg(b);
+		for(int i=0; i<7; ++i)
+			if( a7[i] < b7[i] )
+				++*tF;
+			else if( a7[i] > b7[i] )
+				++*tM;
+	}
+
+	const char* seven_seg(char c)
+	{
+		const char* ans[] = {
+			"1110111",
+			"0010011",
+			"1011101",
+			"1011011",
+			"0111010",
+			"1101011",
+			"1101111",
+			"1010010",
+			"1111111",
+			"1111011",
+		};
+		return ans[c-'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 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(_, NumbersAndMatches().differentNumbers(N, K));}
+int main(){
+
+CASE(0)
+	long long N = 10LL; 
+	int K = 1; 
+	long long _ = 4LL; 
+END
+CASE(1)
+	long long N = 23LL; 
+	int K = 1; 
+	long long _ = 4LL; 
+END
+CASE(2)
+	long long N = 66LL; 
+	int K = 2; 
+	long long _ = 15LL; 
+END
+CASE(3)
+	long long N = 888888888LL; 
+	int K = 100; 
+	long long _ = 1LL; 
+END
+CASE(4)
+	long long N = 444444444444444444LL; 
+	int K = 2; 
+	long long _ = 1LL; 
+END
+CASE(5)
+	long long N = 1LL; 
+	int K = 1; 
+	long long _ = 2LL; 
+END
+CASE(6)
+	long long N = 12345678901234567LL; 
+	int K = 126; 
+	long long _ = -1LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/454-U/1C-U.cpp
Index: SRM/454-U/1C-U.cpp
==================================================================
--- SRM/454-U/1C-U.cpp
+++ SRM/454-U/1C-U.cpp
@@ -0,0 +1,157 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000007LL;
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+
+class MegaSum { public:
+	int calculate(long long N) 
+	{
+		LL nth = sq(N);
+		pair<LL,LL> p = position_of(N);
+
+		LL cnt = 0;
+		for(LL lane=1; lane<=nth; ++lane)
+			cnt = ADD(cnt, sum_in_the_lane(p, lane));
+		return cnt;
+	}
+
+	LL sq( LL N )
+	{
+		LL nth=1;
+		while( !(N <= nth*nth) )
+			++nth;
+		return nth;
+	}
+
+	pair<LL,LL> position_of( LL N )
+	{
+		// in which lane?
+		LL nth = sq(N);
+
+		// position
+		LL dif = N - (nth-1)*(nth-1);
+		LL y = (dif<=nth ? dif : nth);
+		LL x = (dif<=nth ? nth : nth+nth-dif);
+		if( nth%2 == 1 ) swap(x, y);
+
+		return make_pair(y,x);
+	}
+
+	LL sum_in_the_lane(pair<LL,LL> p, LL lane)
+	{
+		LL y = p.first;
+		LL x = p.second;
+
+
+		if( lane%2 == 0 )
+		{
+			//     V
+			//     V
+			//<<<<<<
+			LL s = lane<=x ? sumV( 1, lane, min(y,lane), lane, y, x ) : 0;
+			s = ADD(s, lane<=y ? sumH(lane,min(x,lane-1),lane,1,y,x) : 0);
+			return s;
+		}
+		else
+		{
+			//     A
+			//     A
+			//>>>>>>
+			LL s = lane<=y ? sumH( lane, 1, lane, min(x,lane), y, x ) : 0;
+			s = ADD(s, lane<=x ? sumV(min(y,lane-1),lane,1,lane,y,x) : 0);
+			return s;
+		}
+	}
+
+	LL value_of(LL y, LL x)
+	{
+		LL lane = max(x, y);
+		return (lane-1)*(lane-1) + (lane%2==0 ? (y<lane ? y : lane+lane-x)
+		                                      : (x<lane ? x : lane+lane-y));
+	}
+
+	LL sumH(LL y0, LL x, LL y1, LL _, LL Y, LL X)
+	{
+		// \Sigma value_of(y0+i,x) * (X-x+1)*(Y-(y0+i)+1)
+		//=
+		// \Sigma (value_of(y0,x)+i) * (X-x+1)*(Y-(y0+i)+1)
+		//=
+		// \Sigma (V0            +i) * XX     *(YY-i)
+		//=
+		// ...
+		assert(false);
+	}
+
+	LL sumV(LL y, LL x0, LL _, LL x1, LL Y, LL X)
+	{
+		assert(false);
+	}
+};
+
+// 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(_, MegaSum().calculate(N));}
+int main(){
+
+CASE(0)
+	long long N = 8LL; 
+	int _ = 58; 
+END
+CASE(1)
+	long long N = 12LL; 
+	int _ = 282; 
+END
+CASE(2)
+	long long N = 11LL; 
+	int _ = 128; 
+END
+CASE(3)
+	long long N = 6LL; 
+	int _ = 50; 
+END
+CASE(4)
+	long long N = 34539LL; 
+	int _ = 437909839; 
+END
+CASE(5)
+	long long N = 10000000000LL; 
+	int _ = -1; 
+END
+CASE(6)
+	long long N = 123456789LL; 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/456-U/1A.cpp
Index: SRM/456-U/1A.cpp
==================================================================
--- SRM/456-U/1A.cpp
+++ SRM/456-U/1A.cpp
@@ -0,0 +1,83 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class SilverDistance { public:
+	int minSteps(int sx, int sy, int gx, int gy) 
+	{
+		return abs(sx-gx)%2 == abs(sy-gy)%2
+			? max(abs(sx-gx),abs(sy-gy)) : 1+max(abs(sx-gx),abs(sy+1-gy));
+	}
+};
+
+// 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(_, SilverDistance().minSteps(sx, sy, gx, gy));}
+int main(){
+
+CASE(0)
+	int sx = 1; 
+	int sy = 0; 
+	int gx = 1; 
+	int gy = 9; 
+	int _ = 9; 
+END
+CASE(1)
+	int sx = 0; 
+	int sy = 0; 
+	int gx = -4; 
+	int gy = 3; 
+	int _ = 5; 
+END
+CASE(2)
+	int sx = 0; 
+	int sy = 0; 
+	int gx = 5; 
+	int gy = 8; 
+	int _ = 8; 
+END
+CASE(3)
+	int sx = -487617; 
+	int sy = 826524; 
+	int gx = 892309; 
+	int gy = -918045; 
+	int _ = 1744571; 
+END
+CASE(4)
+	int sx = -27857; 
+	int sy = 31475; 
+	int gx = -27857; 
+	int gy = 31475; 
+	int _ = 0; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/456-U/1B.cpp
Index: SRM/456-U/1B.cpp
==================================================================
--- SRM/456-U/1B.cpp
+++ SRM/456-U/1B.cpp
@@ -0,0 +1,101 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CutSticks { public:
+	double maxKth(vector <int> sticks, int Ct, int K) 
+	{
+		double L=0, R=1000000000;
+		for(int n=0; n<1000; ++n)
+		{
+			double C = (L+R)/2;
+
+			// can we create K sticks of length C from sticks within Ct cuts?
+			int cnt = 0;
+			int ncut = 0;
+			for(int i=0; i<sticks.size(); ++i) {
+				int ct = int( sticks[i] / C )-1;
+				if( ct >= 0 ) {
+					ct = min(ct, Ct-ncut);
+					ncut += ct;
+					cnt += ct+1;
+				}
+			}
+
+			(cnt >= K ? L : R) = C;
+		}
+		return L;
+	}
+};
+
+// 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) {
+ double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 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(_, CutSticks().maxKth(sticks, C, K));}
+int main(){
+
+CASE(0)
+	int sticks_[] = {5, 8};
+	  vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_)); 
+	int C = 1; 
+	int K = 1; 
+	double _ = 8.0; 
+END
+CASE(1)
+	int sticks_[] = {5, 8};
+	  vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_)); 
+	int C = 1; 
+	int K = 2; 
+	double _ = 5.0; 
+END
+CASE(2)
+	int sticks_[] = {5, 8};
+	  vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_)); 
+	int C = 1; 
+	int K = 3; 
+	double _ = 4.0; 
+END
+CASE(3)
+	int sticks_[] = {1000000000, 1000000000, 1};
+	  vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_)); 
+	int C = 2; 
+	int K = 5; 
+	double _ = 1.0; 
+END
+CASE(4)
+	int sticks_[] = {76, 594, 17, 6984, 26, 57, 9, 876, 5816, 73, 969, 527, 49};
+	  vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_)); 
+	int C = 789; 
+	int K = 456; 
+	double _ = 34.92; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/457-U/1A.cpp
Index: SRM/457-U/1A.cpp
==================================================================
--- SRM/457-U/1A.cpp
+++ SRM/457-U/1A.cpp
@@ -0,0 +1,102 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheTriangleBothDivs { public:
+	string fix(string time) 
+	{
+		string answer;
+
+		for(int hh= 0; hh<=23; ++hh)
+		for(int mm= 0; mm<=59; ++mm)
+		for(int of=-9; of<=+9; ++of)
+			if( is_possible(hh,mm,of,time) ) {
+				stringstream ss;
+				ss << setw(2) << setfill('0') << (hh-of+24)%24
+				   << ":"
+				   << setw(2) << setfill('0') << mm;
+
+				if( answer.empty() || ss.str()<answer )
+					answer = ss.str();
+			}
+		return answer;
+	}
+
+	bool is_possible(int hh, int mm, int of, const string& time)
+	{
+		stringstream ss;
+		ss << setw(2) << setfill('0') << hh
+		   << ":"
+		   << setw(2) << setfill('0') << mm
+		   << " GMT"
+		   << (of>=0 ? '+' : '-')
+		   << (of>=0 ? of : -of);
+
+		string s = ss.str();
+		for(int i=0; i<s.size(); ++i)
+			if( s[i] != time[i] && time[i]!='?' )
+				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 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(_, TheTriangleBothDivs().fix(time));}
+int main(){
+
+CASE(0)
+	string time = "17:45 GMT-4"; 
+	string _ = "21:45"; 
+END
+CASE(1)
+	string time = "16:?? GMT??"; 
+	string _ = "00:00"; 
+END
+CASE(2)
+	string time = "?1:34 GMT-9"; 
+	string _ = "06:34"; 
+END
+CASE(3)
+	string time = "??:?? GMT??"; 
+	string _ = "00:00"; 
+END
+CASE(4)
+	string time = "01:?? GMT?1"; 
+	string _ = "00:00"; 
+END
+CASE(5)
+	string time = "00:00 GMT-?"; 
+	string _ = "01:00"; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/457-U/1B.cpp
Index: SRM/457-U/1B.cpp
==================================================================
--- SRM/457-U/1B.cpp
+++ SRM/457-U/1B.cpp
@@ -0,0 +1,128 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheHexagonsDivOne { public:
+	long long count(int n) 
+	{
+		// at least there must be 7<=2*n numbers...
+		if( n <= 3 )
+			return 0;
+
+		// center hex has 2n possibility
+		// choose others from 2(n-1) candidates
+		// normalize by /6 to classify by the least number
+
+		LL ans = 0;
+		vector<int> pat;
+		count_pat( pat, n-1, ans );
+		return ans*2*n/6;
+	}
+
+	void count_pat( vector<int>& pat, LL n, LL& ans )
+	{
+		int i = pat.size();
+		if( i == 6 )
+		{
+			LL distinct = set<int>(pat.begin(), pat.end()).size();
+			LL tmp = 1;
+			for(int d=0; d<distinct; ++d)
+				tmp *= (n-d);
+
+			LL dup = 6 - distinct;
+			for(int d=0; d<dup; ++d)
+				tmp *= 2;
+
+			LL nodup = 6 - 2*dup;
+			for(int d=0; d<nodup; ++d)
+				tmp *= 2;
+
+			ans += tmp;
+			return;
+		}
+
+		vector<int> use(7);
+		int next = 1;
+		for(int k=0; k<pat.size(); ++k) {
+			use[pat[k]]++;
+			next = max(next, pat[k]+1);
+		}
+
+		if( next <= n )
+		{
+			pat.push_back(next);
+			count_pat( pat, n, ans );
+			pat.pop_back();
+		}
+
+		for(int p=1; p<next; ++p)
+			if( use[p]<=1 )
+				if( i==0 || (pat[i-1]!=p && (i<5 || pat[0]!=p)) )
+				{
+					pat.push_back(p);
+					count_pat( pat, n, ans );
+					pat.pop_back();
+				}
+	}
+};
+
+// 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(_, TheHexagonsDivOne().count(n));}
+int main(){
+
+CASE(0)
+	int n = 3; 
+	long long _ = 0LL; 
+END
+CASE(1)
+	int n = 4; 
+	long long _ = 256LL; 
+END
+CASE(2)
+	int n = 8; 
+	long long _ = 3458560LL; 
+END
+CASE(3)
+	int n = 20; 
+	long long _ = 11193888000LL; 
+END
+CASE(4)
+	int n = 1; 
+	long long _ = 0LL; 
+END
+CASE(5)
+	int n = 150; 
+	long long _ = -1LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/457-U/1C-U.cpp
Index: SRM/457-U/1C-U.cpp
==================================================================
--- SRM/457-U/1C-U.cpp
+++ SRM/457-U/1C-U.cpp
@@ -0,0 +1,265 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int NV = 18*18*2+18+2;
+typedef int           flow;
+typedef LL            cost;
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+typedef flow          flow_graph[NV][NV];
+typedef cost          cost_graph[NV][NV];
+static const flow FLOW_INF = 0x7FFFFFFF;
+static const cost COST_INF = 0x7FFFFFFFFFFFFFFFLL;
+
+// edges(bidi), capacity, cost(s.t. C[x][y]=-C[y][x]) per 1 flow, src, dst
+pair<cost,flow> mincostFlow(graph& G, flow_graph F, cost_graph C, vert S, vert D)
+{
+	int N = G.size();
+	cost total_cost = 0;
+	flow total_flow = 0;
+
+	vector<cost> h(N, 0); // potential
+	for(cost RF=FLOW_INF; RF>0; ) // residual flow
+	{
+		// Dijkstra -- find the min-cost path
+		vector<cost> d(N, COST_INF);  d[S] = 0;
+		vector<vert> prev(N, -1);
+
+		typedef pair<cost, pair<vert,vert> > cedge;
+		priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+		Q.push( cedge(0, make_pair(S,S)) );
+		while( !Q.empty() ) {
+			cedge e = Q.top(); Q.pop();
+			if( prev[e.second.second] >= 0 )
+				continue;
+			prev[e.second.second] = e.second.first;
+
+			vert u = e.second.second;
+			for(int i=0; i<G[u].size(); ++i) {
+				vert v = G[u][i];
+				cost r_cost = C[u][v] + h[u] - h[v];
+				if( F[u][v] > 0 && d[v] > d[u]+r_cost )
+					Q.push( cedge(d[v]=d[u]+r_cost, make_pair(u,v)) );
+			}
+		}
+
+		if( prev[D] < 0 )
+			break; // Finished
+
+		// As much as possible
+		flow f = RF;
+		for(vert u=D; u!=S; u=prev[u])
+			f = min(f, F[prev[u]][u]);
+		RF         -= f;
+		total_flow += f;
+
+		for(vert u=D; u!=S; u=prev[u])
+		{
+			total_cost    += f * C[prev[u]][u];
+			F[prev[u]][u] -= f;
+			F[u][prev[u]] += f;
+		}
+
+		// Update the potential
+		for(vert u=0; u<N; ++u)
+			h[u] += d[u];
+	}
+	return make_pair(total_cost, total_flow);
+}
+
+
+flow_graph F;
+cost_graph C;
+
+LL f(LL n) {
+	return n*n*n*n*n;
+}
+
+class TheSquareDivOne { public:
+	vector <string> solve(vector <string> board) 
+	{
+		int n = board.size();
+		vector<int> R(n);
+		for(int y=0; y<n; ++y)
+			for(int x=0; x<n; ++x)
+				if( board[y][x]=='C' )
+					R[y] ++;
+
+		graph      G(2+n+n*n*2);
+		memset(F, 0, sizeof(F));
+		memset(C, 0, sizeof(C));
+		vert       S = 0;
+		vert       D = 1;
+
+		for(int y=0; y<n; ++y)
+			for(int x=0; x<n; ++x) {
+				vert v = (2+n) + y*n + x;
+				G[S].push_back(v);
+				G[v].push_back(S);
+				if( board[y][x]=='C' )
+					F[S][v] = 1;
+			}
+
+		for(int y=0; y<n; ++y)
+			for(int x=0; x<n; ++x) {
+				vert v = (2+n) + (n*n) + y*n + x;
+				vert u = 2+x;
+				G[v].push_back(u);
+				G[u].push_back(v);
+				F[v][u] = 1;
+//				C[u][v] = -(C[v][u] = (1LL<<(n-y-1))<<30);
+			}
+
+		for(int x=0; x<n; ++x) {
+			vert u = 2+x;
+			G[u].push_back(D);
+			G[D].push_back(u);
+			F[u][D] = R[x];
+//			C[u][D] = -(C[D][u] = (1LL<<2*(n-x-1)));
+		}
+
+		for(int y1=0; y1<n; ++y1)
+			for(int x1=0; x1<n; ++x1)
+				for(int y2=0; y2<n; ++y2)
+					for(int x2=0; x2<n; ++x2) {
+						vert v = (2+n) + y1*n + x1;
+						vert u = (2+n) + (n*n) + y2*n + x2;
+						G[u].push_back(v);
+						G[v].push_back(u);
+						F[v][u] = 1;
+						C[u][v] = -(C[v][u] = abs(y1-y2)+abs(x1-x2));
+//						C[u][v] = -(C[v][u] = LL(abs(y1-y2)+abs(x1-x2))<<50);
+					}
+
+		pair<cost,flow> mf = mincostFlow(G,F,C,S,D);
+//		cerr << "Cost: " << (mf.first>>50) << "+" << ((mf.first&(1LL<<50)-1)) << ", Flow: " << mf.second << endl;
+
+		for(int y=0; y<n; ++y)
+			for(int x=0; x<n; ++x)
+				board[y][x] = (F[(2+n) + (n*n) + y*n + x][2+x]==0 ? 'C' : '.');
+
+		// not lexicographically first ...orz
+		return board;
+	}
+};
+
+// 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(_, TheSquareDivOne().solve(board));}
+int main(){
+
+CASE(0)
+	string board_[] = {"...",
+ "...",
+ "C.."};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	string __[] = {"...", "...", "..C" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	string board_[] = {"CCC",
+ ".C.",
+ "CCC"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	string __[] = {"C.C", "C.C", "CCC" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	string board_[] = {"C..",
+ ".C.",
+ "..C"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	string __[] = {"C..", ".C.", "..C" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	string board_[] = {"C....","CCCCC","...CC",".CC..",".C.C."};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	string __[] = {".C...", "CCCCC", ".C..C", ".CC..", ".C.C." };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	string board_[] = {
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	string __[] = {
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+"CCCCCCCCCCCCCCCCCC",
+};
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(5)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	string __[] = ;
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/458-U/1A.cpp
Index: SRM/458-U/1A.cpp
==================================================================
--- SRM/458-U/1A.cpp
+++ SRM/458-U/1A.cpp
@@ -0,0 +1,113 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BouncingBalls { public:
+	double expectedBounces(vector <int> x, int T) 
+	{
+		sort(x.begin(), x.end());
+
+		double  total = 0;
+
+		int N = x.size();
+		for(int m=0; m<(1<<N); ++m)
+		{
+			vector<bool> goLeft(N);
+			for(int i=0; i<N; ++i)
+				goLeft[i] = ((1<<i)&m) != 0;
+
+			total += num(x, goLeft, T);
+		}
+
+		return total / (1<<N);
+	}
+
+	double num( const vector<int>& x, const vector<bool>& goLeft, int T )
+	{
+		int cnt = 0;
+		for(int i=0; i<x.size(); ++i)
+			for(int j=i+1; j<x.size(); ++j)
+				if( !goLeft[i] && goLeft[j] && x[j]-x[i]<=2*T )
+					++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 double& Expected, const double& Received) {
+ double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 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(_, BouncingBalls().expectedBounces(x, T));}
+int main(){
+
+CASE(0)
+	int x_[] = {5, 8};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int T = 2; 
+	double _ = 0.25; 
+END
+CASE(1)
+	int x_[] = {5, 8};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int T = 1; 
+	double _ = 0.0; 
+END
+CASE(2)
+	int x_[] = {91, 857, 692, 54, 8679, 83, 792, 86, 9537, 913, 64, 592};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int T = 458; 
+	double _ = 11.5; 
+END
+CASE(3)
+	int x_[] = {75432};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int T = 386; 
+	double _ = 0.0; 
+END
+CASE(4)
+	int x_[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int T = 3; 
+	double _ = 12.75; 
+END
+CASE(5)
+	int x_[] = {1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int T = 100000000; 
+	double _ = 0; 
+END
+CASE(6)
+	int x_[] = {10000000};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int T = 100000; 
+	double _ = 0; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/458-U/1B.cpp
Index: SRM/458-U/1B.cpp
==================================================================
--- SRM/458-U/1B.cpp
+++ SRM/458-U/1B.cpp
@@ -0,0 +1,110 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class NewCoins { public:
+	int minCoins(vector <int> price) 
+	{
+		memo.resize(100001, -1);
+		return mc(1, price);
+	}
+
+	vector<int> memo;
+	int mc( int d, const vector<int>& price )
+	{
+		if( memo[d] != -1 )
+			return memo[d];
+		if( price.size() == 0 )
+			return 0;
+
+		// all 1
+		int X = accumulate(price.begin(), price.end(), 0);
+
+		int P = *max_element(price.begin(), price.end());
+		for(int p=2; p<=P; ++p)
+		{
+			int byOne = 0;
+
+			vector<int> p2;
+			for(int i=0; i<price.size(); ++i) {
+				byOne += price[i] % p;
+				if( memo[d*p]==-1 )
+					if(price[i] / p) p2.push_back(price[i]/p);
+			}
+			X = min(X, byOne + mc(d*p, p2));
+		}
+		return memo[d] = 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 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(_, NewCoins().minCoins(price));}
+int main(){
+
+CASE(0)
+	int price_[] = {25, 102};
+	  vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_)); 
+	int _ = 4; 
+END
+CASE(1)
+	int price_[] = {58};
+	  vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_)); 
+	int _ = 1; 
+END
+CASE(2)
+	int price_[] = {1, 4, 5, 9, 16};
+	  vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_)); 
+	int _ = 7; 
+END
+CASE(3)
+	int price_[] = {1, 1, 1, 1, 1};
+	  vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_)); 
+	int _ = 5; 
+END
+CASE(4)
+	int price_[] = {28, 569, 587, 256, 15, 87, 927, 4, 589, 73, 98, 87, 597, 163, 6, 498};
+	  vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_)); 
+	int _ = 62; 
+END
+CASE(5)
+	int price_[] = {1};
+	  vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_)); 
+	int _ = 1; 
+END
+CASE(6)
+	int price_[] = {1,2,3,4,5,6,9997,9998,9999,99910,99911,99912,99913,99914,99915,99916,99917,99918,99919,99920,99921,99922,99923,99924,87625,87626,87627,87628,87629,87630,87631,87632,87633,87634,87635,87636,87637,87638,87639,99940,99991,99992,99993,99994,99995,99996,99997,99998,99999,100000};
+	  vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_)); 
+	int _ = 183; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/458-U/2C.cpp
Index: SRM/458-U/2C.cpp
==================================================================
--- SRM/458-U/2C.cpp
+++ SRM/458-U/2C.cpp
@@ -0,0 +1,129 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ProductTriplet { public:
+	long long countTriplets(int minx, int maxx, int miny, int maxy, int minz, int maxz) 
+	{
+		return comp(minx, maxx, miny, maxy, maxz) - comp(minx, maxx, miny, maxy, minz-1);
+	}
+
+	LL comp(LL mx, LL Mx, LL my, LL My, LL Z)
+	{
+		LL cnt = 0;
+		for(LL x=mx; x<=Mx; )
+		{
+			LL Cy = Z / x;
+			if( Cy < my )
+				break;
+
+			// max n such that Cy == Z / x+n
+			LL n = (Z/Cy)-x;
+
+			n = min(n, Mx-x)+1;
+			cnt += n * (min(Cy,My) - my + 1);
+			x += n;
+		}
+		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 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(_, ProductTriplet().countTriplets(minx, maxx, miny, maxy, minz, maxz));}
+int main(){
+
+CASE(0)
+	int minx = 2; 
+	int maxx = 2; 
+	int miny = 3; 
+	int maxy = 3; 
+	int minz = 6; 
+	int maxz = 6; 
+	long long _ = 1LL; 
+END
+CASE(1)
+	int minx = 2; 
+	int maxx = 2; 
+	int miny = 3; 
+	int maxy = 3; 
+	int minz = 7; 
+	int maxz = 7; 
+	long long _ = 0LL; 
+END
+CASE(2)
+	int minx = 6; 
+	int maxx = 8; 
+	int miny = 4; 
+	int maxy = 5; 
+	int minz = 27; 
+	int maxz = 35; 
+	long long _ = 4LL; 
+END
+CASE(3)
+	int minx = 1; 
+	int maxx = 458; 
+	int miny = 1; 
+	int maxy = 458; 
+	int minz = 1; 
+	int maxz = 458; 
+	long long _ = 2877LL; 
+END
+CASE(4)
+	int minx = 8176; 
+	int maxx = 184561; 
+	int miny = 1348; 
+	int maxy = 43168; 
+	int minz = 45814517; 
+	int maxz = 957843164; 
+	long long _ = 2365846085LL; 
+END
+CASE(5)
+	int minx = 1; 
+	int maxx = 1; 
+	int miny = 1; 
+	int maxy = 1; 
+	int minz = 1; 
+	int maxz = 1; 
+	long long _ = 1LL; 
+END
+CASE(6)
+	int minx = 1; 
+	int maxx = 1000000000; 
+	int miny = 1; 
+	int maxy = 1000000000; 
+	int minz = 1; 
+	int maxz = 1000000000; 
+	long long _ = -1LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/459-U/1A.cpp
Index: SRM/459-U/1A.cpp
==================================================================
--- SRM/459-U/1A.cpp
+++ SRM/459-U/1A.cpp
@@ -0,0 +1,122 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Inequalities { public:
+	int maximumSubset(vector <string> inequalities) 
+	{
+		set<double> v;
+
+		for(int i=0; i<inequalities.size(); ++i)
+		{
+			stringstream ss(inequalities[i]);
+			char _; string OP; double C;
+			ss >> _ >> OP >> C;
+
+			v.insert(C);
+		}
+
+		set<double> vv = v;
+		vv.insert( *v.begin() - 1 );
+		vv.insert( *v.rbegin() + 1 );
+
+		for(set<double>::iterator it=v.begin(); it!=v.end(); ++it)
+		for(set<double>::iterator jt=v.begin(); jt!=v.end(); ++jt)
+			vv.insert( (*it + *jt)/2 );
+
+		int maxSat = 0;
+		for(set<double>::iterator it=vv.begin(); it!=vv.end(); ++it)
+		{
+			double X = *it;
+
+			int sat = 0;
+			for(int i=0; i<inequalities.size(); ++i)
+			{
+				stringstream ss(inequalities[i]);
+				char _; string OP; double C;
+				ss >> _ >> OP >> C;
+
+				if( (OP=="<" && X<C)
+				 || (OP=="<=" && X<=C)
+				 || (OP=="=" && X==C)
+				 || (OP==">" && X>C)
+				 || (OP==">=" && X>=C) )
+					++sat;
+			}
+			maxSat = max(maxSat, sat);
+		}
+		return maxSat;
+	}
+};
+
+// 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(_, Inequalities().maximumSubset(inequalities));}
+int main(){
+
+CASE(0)
+	string inequalities_[] = {"X <= 12","X = 13","X > 9","X < 10","X >= 14"};
+	  vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_)); 
+	int _ = 3; 
+END
+CASE(1)
+	string inequalities_[] = {"X < 0","X <= 0"};
+	  vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_)); 
+	int _ = 2; 
+END
+CASE(2)
+	string inequalities_[] = {"X = 1","X = 2","X = 3","X > 0"};
+	  vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_)); 
+	int _ = 2; 
+END
+CASE(3)
+	string inequalities_[] = {"X <= 521","X >= 521","X = 521","X > 902","X > 12","X <= 1000"};
+	  vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_)); 
+	int _ = 5; 
+END
+CASE(4)
+	string inequalities_[] = {"X > 0"};
+	  vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_)); 
+	int _ = 1; 
+END
+CASE(5)
+	string inequalities_[] = {"X > 0", "X <= 0"};
+	  vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_)); 
+	int _ = 1; 
+END
+CASE(6)
+	string inequalities_[] = {"X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", };
+	  vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_)); 
+	int _ = 50; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/459-U/1B.cpp
Index: SRM/459-U/1B.cpp
==================================================================
--- SRM/459-U/1B.cpp
+++ SRM/459-U/1B.cpp
@@ -0,0 +1,94 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class NumberPyramids { public:
+	int count(int baseLength, int top) 
+	{
+		const int n = baseLength-1;
+		const int s = top - (1<<n);
+		if( s<0 || n>20 )
+			return 0;
+
+		vector<int> dp(s+1, 0);
+		dp[0] = 1;
+
+		for(int i=0, nCi=1; i<=n; ++i, nCi=nCi*(n-i+1)/i)
+			for(int x=nCi; x<=s; ++x)
+				(dp[x] += dp[x-nCi]) %= 1000000009;
+
+		return dp[s];
+	}
+};
+
+// 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(_, NumberPyramids().count(baseLength, top));}
+int main(){
+
+CASE(0)
+	int baseLength = 3; 
+	int top = 5; 
+	int _ = 2; 
+END
+CASE(1)
+	int baseLength = 5; 
+	int top = 16; 
+	int _ = 1; 
+END
+CASE(2)
+	int baseLength = 4; 
+	int top = 15; 
+	int _ = 24; 
+END
+CASE(3)
+	int baseLength = 15; 
+	int top = 31556; 
+	int _ = 74280915; 
+END
+CASE(4)
+	int baseLength = 150; 
+	int top = 500; 
+	int _ = 0; 
+END
+CASE(5)
+	int baseLength = 2; 
+	int top = 3; 
+	int _ = 2; 
+END
+CASE(6)
+	int baseLength = 20; 
+	int top = 1000000; 
+	int _ = 503596690; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/460-U/1A.cpp
Index: SRM/460-U/1A.cpp
==================================================================
--- SRM/460-U/1A.cpp
+++ SRM/460-U/1A.cpp
@@ -0,0 +1,131 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+LL comb(LL n, LL k)
+{
+	k = min(k, n-k);
+
+	LL c = 1;
+	for(LL i=0; i<k; ++i)
+		c *= n-i, c /= i+1;
+	return c;
+}
+
+class TheQuestionsAndAnswersDivOne { public:
+	int find(int questions, vector <string> answers) 
+	{
+		int Y = count(answers.begin(), answers.end(), string("Yes"));
+		int N = count(answers.begin(), answers.end(), string( "No"));
+
+		int cnt = 0;
+		for(int y=0; y<=questions; ++y)
+		{
+			int n = questions - y;
+			if( y<=Y && n<=N )
+				cnt += distr(Y,y)*distr(N,n)*comb(questions, y);
+		}
+		return cnt;
+	}
+
+	int distr(int n, int k)
+	{
+		if( k <= 1 )
+			return (k==1 || n==0&&k==0) ? 1 : 0;
+		int sum = 0;
+		for(int m=1; m<(1<<n); ++m) {
+			int pop = 0;
+			for(int i=1; i<=m; i<<=1)
+				if(m&i)
+					++pop;
+			if( n-pop >= k-1 )
+				sum += distr(n-pop, k-1);
+		}
+		return sum;
+	}
+};
+
+// 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(_, TheQuestionsAndAnswersDivOne().find(questions, answers));}
+int main(){
+
+CASE(0)
+	int questions = 2; 
+	string answers_[] = {"No", "Yes"};
+	  vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_)); 
+	int _ = 2; 
+END
+CASE(1)
+	int questions = 2; 
+	string answers_[] = {"No", "No", "No"};
+	  vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_)); 
+	int _ = 6; 
+END
+CASE(2)
+	int questions = 3; 
+	string answers_[] = {"Yes", "No", "No", "Yes"};
+	  vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_)); 
+	int _ = 12; 
+END
+CASE(3)
+	int questions = 3; 
+	string answers_[] = {"Yes", "Yes", "Yes", "No"};
+	  vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_)); 
+	int _ = 18; 
+END
+CASE(4)
+	int questions = 2; 
+	string answers_[] = {"Yes","Yes"};
+	  vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_)); 
+	int _ = 2; 
+END
+CASE(4)
+	int questions = 2; 
+	string answers_[] = {"No","No"};
+	  vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_)); 
+	int _ = 2; 
+END
+CASE(4)
+	int questions = 2; 
+	string answers_[] = {"Yes","No"};
+	  vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_)); 
+	int _ = 2; 
+END
+CASE(5)
+	int questions = 7; 
+	string answers_[] = {"Yes","Yes","Yes","Yes","Yes","Yes","Yes","Yes","Yes"};
+	  vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_)); 
+	int _ = 40320*9; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/460-U/1B.cpp
Index: SRM/460-U/1B.cpp
==================================================================
--- SRM/460-U/1B.cpp
+++ SRM/460-U/1B.cpp
@@ -0,0 +1,204 @@
+#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>
+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) {}
+	T& operator()(int i1, int i2, int i3)
+		{ return data[ ((i1*N2)+i2)*N3+i3 ]; }
+	void swap(DP3& rhs)
+		{ data.swap(rhs.data); }
+};
+
+class TheFansAndMeetingsDivOne { public:
+	double find(vector <int> minJ, vector <int> maxJ, vector <int> minB, vector <int> maxB, int k) 
+	{
+		const int N = minJ.size();
+		const int S = max( accumulate(maxB.begin(), maxB.end(), 0), accumulate(maxJ.begin(), maxJ.end(), 0) );
+
+		DP3<double> dpJ(41,41,1601);
+		dpJ(0,0,0) = 1.0;
+		for(int i=1; i<=N; ++i)
+		for(int vis=0; vis<=k; ++vis)
+		for(int s=0; s<=S; ++s)
+		{
+			double PP = 0;
+			if(vis)
+				for(int p=minJ[i-1]; p<=maxJ[i-1] && p<=s; ++p)
+					PP += dpJ(vis-1, i-1, s-p);
+			dpJ(vis,i,s) = dpJ(vis, i-1, s) + PP / (maxJ[i-1]-minJ[i-1]+1);
+		}
+
+		DP3<double> dpB(41,41,1601);
+		dpB(0,0,0) = 1.0;
+		for(int i=1; i<=N; ++i)
+		for(int vis=0; vis<=k; ++vis)
+		for(int s=0; s<=S; ++s)
+		{
+			double PP = 0;
+			if(vis)
+				for(int p=minB[i-1]; p<=maxB[i-1] && p<=s; ++p)
+					PP += dpB(vis-1, i-1, s-p);
+			dpB(vis,i,s) = dpB(vis, i-1, s) + PP / (maxB[i-1]-minB[i-1]+1);
+		}
+
+		double ans = 0.0, nB=0.0, nJ=0.0;
+		for(int s=0; s<=S; ++s)
+			nB += dpB(k, N, s), nJ += dpJ(k, N, s);
+		for(int s=0; s<=S; ++s)
+			ans += dpB(k, N, s) * dpJ(k, N, s) / nB / nJ;
+		return ans;
+	}
+};
+
+// 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) {
+ double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 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(_, TheFansAndMeetingsDivOne().find(minJ, maxJ, minB, maxB, k));}
+int main(){
+
+CASE(0)
+	int minJ_[] = {1};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {9};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {5};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {5};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 1; 
+	double _ = 0.1111111111111111; 
+END
+CASE(0)
+	int minJ_[] = {5};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {5};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {1};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {9};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 1; 
+	double _ = 0.1111111111111111; 
+END
+CASE(1)
+	int minJ_[] = {5, 2, 5, 1, 1, 2, 4, 1};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {7, 6, 7, 3, 4, 3, 5, 1};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {8, 9, 7, 11, 12, 7, 8, 40};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {9, 10, 9, 33, 14, 7, 11, 40};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 2; 
+	double _ = 4.724111866969009E-5; 
+END
+CASE(1)
+	int minJ_[] = {8, 9, 7, 11, 12, 7, 8, 40};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {9, 10, 9, 33, 14, 7, 11, 40};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {5, 2, 5, 1, 1, 2, 4, 1};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {7, 6, 7, 3, 4, 3, 5, 1};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 2; 
+	double _ = 4.724111866969009E-5; 
+END
+CASE(2)
+	int minJ_[] = {4, 7, 4};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {7, 7, 7};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {40, 40, 40};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {40, 40, 40};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 1; 
+	double _ = 0.0; 
+END
+CASE(2)
+	int minJ_[] = {40, 40, 40};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {40, 40, 40};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {4, 7, 4};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {7, 7, 7};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 1; 
+	double _ = 0.0; 
+END
+CASE(3)
+	int minJ_[] = {3, 6, 2, 1, 1, 10, 3};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {6, 9, 5, 6, 5, 10, 9};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {1, 1, 1, 1, 8, 3, 1};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {3, 9, 7, 3, 10, 6, 5};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 4; 
+	double _ = 0.047082056525158976; 
+END
+CASE(4)
+	int minJ_[] = {40};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {40};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {40};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {40};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 1; 
+	double _ = 1.0; 
+END
+CASE(5)
+//1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
+//40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40
+	int minJ_[] = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10};
+	  vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_)); 
+	int maxJ_[] = {30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30};
+	  vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_)); 
+	int minB_[] = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10};
+	  vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_)); 
+	int maxB_[] = {30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30};
+	  vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_)); 
+	int k = 40; 
+	double _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/460-U/1C-U.cpp
Index: SRM/460-U/1C-U.cpp
==================================================================
--- SRM/460-U/1C-U.cpp
+++ SRM/460-U/1C-U.cpp
@@ -0,0 +1,182 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1234567891;
+struct UnionFind
+{
+	vector<int> uf, sz, cyc;
+	int nc;
+
+	bool operator<(const UnionFind& rhs) const {
+		if( nc != rhs.nc ) return nc < rhs.nc;
+		if( uf != rhs.uf ) return uf < rhs.uf;
+		if( sz != rhs.sz ) return sz < rhs.sz;
+		return cyc < rhs.cyc;
+	}
+
+	UnionFind(int N): uf(N), sz(N,1), cyc(N), 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]); }
+	int 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];
+				cyc[b] += cyc[a];
+				--nc;
+			}
+			else
+				cyc[a] ++;
+			return cyc[a];
+		}
+};
+
+class TheCitiesAndRoadsDivOne { public:
+	int find(vector <string> map) 
+	{
+		int N = map.size();
+		UnionFind uf(N);
+
+		for(int i=0; i<N; ++i)
+			for(int j=i+1; j<N; ++j)
+				if( map[i][j]=='Y' )
+					if( uf.Union(i, j) >= 2 )
+						return 0;
+		return rec(uf, 0, 1, N, map);
+	}
+
+	map< pair<UnionFind,int>, int > memo;
+	int rec(UnionFind& uf, int i, int j , int N, vector<string>& map)
+	{
+		if( i == N )
+			return uf.nc==1 ? 1 : 0;
+		if( j == N )
+			return rec(uf, i+1, i+2, N, map);
+
+		pair<UnionFind,int> key(uf, i*N+j);
+		if( memo.count(key) )
+			return memo[key];
+
+		LL cnt = rec(uf, i, j+1, N, map);
+		if( map[i][j] == 'N' )
+		{
+			UnionFind uf2(uf);
+			if( uf2.Union(i,j) < 2 )
+				cnt = (cnt + rec(uf2,i,j+1,N,map)) % MODVAL;
+		}
+		return memo[key] = (int)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(_, TheCitiesAndRoadsDivOne().find(map));}
+int main(){
+
+CASE(0)
+	string map_[] = {"NN",
+ "NN"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string map_[] = {"NNY",
+ "NNN",
+ "YNN"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = 3; 
+END
+CASE(2)
+	string map_[] = {"NY",
+ "YN"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = 1; 
+END
+CASE(3)
+	string map_[] = {"NYNN",
+ "YNNN",
+ "NNNY",
+ "NNYN"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = 10; 
+END
+CASE(4)
+	string map_[] = {"NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN",
+ "NNNNNNNNNNNN"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = 1137797187; 
+END
+CASE(5)
+	string map_[] = {"N"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = 1; 
+END
+CASE(6)
+	string map_[] = {"NYYNN",
+ "YNYNN",
+ "YYNNN",
+ "NNNNY",
+ "NNNYN"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = 6; 
+END
+/*
+CASE(7)
+	string map_[] = ;
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = ; 
+END
+CASE(8)
+	string map_[] = ;
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/461-U/1A.cpp
Index: SRM/461-U/1A.cpp
==================================================================
--- SRM/461-U/1A.cpp
+++ SRM/461-U/1A.cpp
@@ -0,0 +1,152 @@
+#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 <limits.h>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ColoringRectangle { public:
+	int chooseDisks(int width, int height, vector <int> red, vector <int> blue) 
+	{
+		vector<double> R;
+		for(int i=0; i<red.size(); ++i) {
+			double r = red[i]/2.0;
+			if( r < height/2 )
+				continue;
+			R.push_back( sqrt(r*r - (height/2.0)*(height/2.0))*2 );
+		}
+		vector<double> B;
+		for(int i=0; i<blue.size(); ++i) {
+			double r = blue[i]/2.0;
+			if( r < height/2 )
+				continue;
+			B.push_back( sqrt(r*r - (height/2.0)*(height/2.0))*2 );
+		}
+		sort(R.rbegin(), R.rend());
+		sort(B.rbegin(), B.rend());
+
+		int m = f(R, B, width);
+		int n = f(B, R, width);
+		int a = min(m,n);
+		if( a == INT_MAX )
+			return -1;
+		return a;
+	}
+	int f(vector<double>& R, vector<double>& B, double W) {
+		double w = 0;
+		for(int i=0 ;; ++i) {
+			if( i%2 == 0 ) {
+				if( i/2>=R.size() )
+					return INT_MAX;
+				w += R[i/2];
+				if( W <= w )
+					return i+1;
+			} else {
+				if( i/2>=B.size() )
+					return INT_MAX;
+				w += B[i/2];
+				if( W <= w )
+					return i+1;
+			}
+		}
+	}
+};
+
+// 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(_, ColoringRectangle().chooseDisks(width, height, red, blue));}
+int main(){
+
+CASE(0)
+	int width = 11; 
+	int height = 3; 
+	int red_[] = {5,5};
+	  vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_)); 
+	int blue_[] = {2,5};
+	  vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_)); 
+	int _ = 3; 
+END
+CASE(1)
+	int width = 30; 
+	int height = 5; 
+	int red_[] = {4,10,7,8,10};
+	  vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_)); 
+	int blue_[] = {5,6,11,7,5};
+	  vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_)); 
+	int _ = 4; 
+END
+CASE(2)
+	int width = 16; 
+	int height = 4; 
+	int red_[] = {6,5,7};
+	  vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_)); 
+	int blue_[] = {5};
+	  vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_)); 
+	int _ = -1; 
+END
+CASE(3)
+	int width = 4; 
+	int height = 4; 
+	int red_[] = {5};
+	  vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_)); 
+	int blue_[] = {6};
+	  vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_)); 
+	int _ = 1; 
+END
+CASE(4)
+	int width = 6; 
+	int height = 2; 
+	int red_[] = {6,6};
+	  vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_)); 
+	int blue_[] = {2};
+	  vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_)); 
+	int _ = 3; 
+END
+CASE(5)
+	int width = 16; 
+	int height = 13; 
+	int red_[] = {20};
+	  vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_)); 
+	int blue_[] = {20};
+	  vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_)); 
+	int _ = -1; 
+END
+/*
+CASE(6)
+	int width = ; 
+	int height = ; 
+	int red_[] = ;
+	  vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_)); 
+	int blue_[] = ;
+	  vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/461-U/1B.cpp
Index: SRM/461-U/1B.cpp
==================================================================
--- SRM/461-U/1B.cpp
+++ SRM/461-U/1B.cpp
@@ -0,0 +1,144 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BuildingCities { public:
+   int findMinimumCities(int maxDirect, int maxTravel, vector <int> cityX, vector <int> cityY) 
+   {
+      int result = 0x7fffffff;
+
+      const int N = cityX.size();
+      typedef pair<int,    int>  vert; // city, extra_city_built
+      typedef pair<double, vert> cedge;
+
+      // dijkstra
+      set<vert> V;
+      priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+      Q.push( cedge(0, vert(0,0)) );
+      while( !Q.empty() )
+      {
+         double d = Q.top().first;
+         vert   v = Q.top().second;
+         Q.pop();
+         if( V.count(v) )
+            continue;
+         V.insert(v);
+
+         int vc = v.first;
+         int vs = v.second;
+         if( vc==N-1 )
+            result = min(result, vs);
+
+         for(int j=0; j<N; ++j) if( vc != j )
+         {
+            double dd = hypot( cityX[vc] -cityX[j], cityY[vc] -cityY[j] );
+            double dx = hypot( cityX[N-1]-cityX[j], cityY[N-1]-cityY[j] );
+            vert u(j, vs+int(dd/maxDirect - 1e-10));
+            if( d+dd+dx<=maxTravel && !V.count(u) && u.second<result )
+               Q.push( cedge(d+dd, u) );
+         }
+      }
+      return result==0x7fffffff ? -1 : result;
+   }
+};
+
+// 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(_, BuildingCities().findMinimumCities(maxDirect, maxTravel, cityX, cityY));}
+int main(){
+
+CASE(0)
+   int maxDirect = 1; 
+   int maxTravel = 5; 
+   int cityX_[] = {0,0,0,1,2,2,3};
+     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_)); 
+   int cityY_[] = {0,1,2,2,2,1,1};
+     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_)); 
+   int _ = 1; 
+END
+CASE(1)
+   int maxDirect = 3; 
+   int maxTravel = 15; 
+   int cityX_[] = {2,6,10,14};
+     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_)); 
+   int cityY_[] = {2,6,2,6};
+     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_)); 
+   int _ = 3; 
+END
+CASE(2)
+   int maxDirect = 2; 
+   int maxTravel = 15; 
+   int cityX_[] = {0,5,2,3,1,8,6,4,7,9,10};
+     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_)); 
+   int cityY_[] = {0,5,2,3,1,8,6,4,7,9,10};
+     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_)); 
+   int _ = 0; 
+END
+CASE(3)
+   int maxDirect = 2; 
+   int maxTravel = 5; 
+   int cityX_[] = {0,5};
+     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_)); 
+   int cityY_[] = {0,5};
+     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_)); 
+   int _ = -1; 
+END
+CASE(4)
+   int maxDirect = 5; 
+   int maxTravel = 1500; 
+   int cityX_[] = {0,1000};
+     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_)); 
+   int cityY_[] = {0,1000};
+     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_)); 
+   int _ = 282; 
+END
+/*
+CASE(5)
+   int maxDirect = ; 
+   int maxTravel = ; 
+   int cityX_[] = ;
+     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_)); 
+   int cityY_[] = ;
+     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_)); 
+   int _ = ; 
+END
+CASE(6)
+   int maxDirect = ; 
+   int maxTravel = ; 
+   int cityX_[] = ;
+     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_)); 
+   int cityY_[] = ;
+     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_)); 
+   int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/462/1A.cpp
Index: SRM/462/1A.cpp
==================================================================
--- SRM/462/1A.cpp
+++ SRM/462/1A.cpp
@@ -0,0 +1,139 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class AgeEncoding { public:
+	double getRadix(int age, string c) 
+	{
+		int i = c.find('1');
+		if( i==string::npos ) i = c.size();
+		c = c.substr(i);
+
+		int N = c.size();
+		if( N == 0 )
+			return -1;
+		if( N == 1 )
+			return (age==1 ? -2 : -1);
+		if( age == 1 && c[N-1]=='1' )
+			return -1;
+
+		double L=0, R=1;
+		for(;;R*=2){
+			double fR = 0.0;
+			for(int i=0; i<N; ++i)
+				fR +=pow(R,i)*(c[N-1-i]=='1');
+			if(fR>age)
+				break;
+		}
+
+		for(int i=0; i<1000; ++i)
+		{
+			double C = (L+R)/2;
+
+			double fL = 0.0;
+			for(int i=0; i<N; ++i)
+				fL +=pow(L,i)*(c[N-1-i]=='1');
+			double fR = 0.0;
+			for(int i=0; i<N; ++i)
+				fR +=pow(R,i)*(c[N-1-i]=='1');
+			double fC = 0.0;
+			for(int i=0; i<N; ++i)
+				fC +=pow(C,i)*(c[N-1-i]=='1');
+
+			(age < fC ? R : L) = C;
+		}
+		return R;
+	}
+};
+
+// 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) {
+ double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 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(_, AgeEncoding().getRadix(age, candlesLine));}
+int main(){
+
+CASE(0)
+	int age = 10; 
+	string candlesLine = "00010"; 
+	double _ = 10.0; 
+END
+CASE(1)
+	int age = 21; 
+	string candlesLine = "10101"; 
+	double _ = 2.0; 
+END
+CASE(2)
+	int age = 6; 
+	string candlesLine = "10100"; 
+	double _ = 1.414213562373095; 
+END
+CASE(3)
+	int age = 21; 
+	string candlesLine = "10111111110111101111111100111111110111111111111100"; 
+	double _ = 0.9685012944510603; 
+END
+CASE(4)
+	int age = 16; 
+	string candlesLine = "1"; 
+	double _ = -1.0; 
+END
+CASE(5)
+	int age = 1; 
+	string candlesLine = "1"; 
+	double _ = -2.0; 
+END
+CASE(6)
+	int age = 1; 
+	string candlesLine = "001000"; 
+	double _ = 1.0; 
+END
+CASE(7)
+	int age = 1; 
+	string candlesLine = "110"; 
+	double _ = (sqrt(5)-1)/2; 
+END
+CASE(8)
+	int age = 1; 
+	string candlesLine = "0000"; 
+	double _ = -1; 
+END
+CASE(9)
+	int age = 1; 
+	string candlesLine = "11"; 
+	double _ = -1; 
+END
+CASE(10)
+	int age = 1; 
+	string candlesLine = "11"; 
+	double _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/462/1B.cpp
Index: SRM/462/1B.cpp
==================================================================
--- SRM/462/1B.cpp
+++ SRM/462/1B.cpp
@@ -0,0 +1,147 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+vector< vector<double> > mMul( const vector< vector<double> >& A, const vector< vector<double> >& B )
+{
+	const int n = A.size();
+
+	vector< vector<double> > C(n, vector<double>(n));
+	for(int i=0; i<n; ++i)
+		for(int j=0; j<n; ++j) {
+			double Cij = 0;
+			for(int k=0; k<n; ++k)
+				Cij += A[i][k] * B[k][j];
+			C[i][j] = Cij;
+		}
+	return C;
+}
+
+vector< vector<double> > mPow( vector< vector<double> > M, LL t )
+{
+	vector< vector<double> > R;
+	if( t == 0 ) {
+		const int n = M.size();
+		R = M;
+		for(int i=0; i<n; ++i)
+			for(int j=0; j<n; ++j)
+				R[i][j] = (i==j);
+		return R;
+	}
+
+	for(; t; t>>=1, M=mMul(M,M))
+		if( t&1 )
+			R = (R.empty() ? M : mMul(R,M));
+	return R;
+}
+
+class CandyBox { public:
+	vector <double> expectedScore(int C, vector <int> score, int S) 
+	{
+		int N = score.size();
+
+		vector< vector<double> > m(N, vector<double>(N));
+		for(int i=0; i<N; ++i)
+			for(int j=0; j<N; ++j) {
+				double pOut  = 2.0/(N*(N*C-1));
+				m[i][j] = (i==j ? 1-pOut*(N-1) : pOut);
+			}
+		m = mPow(m, S);
+
+		double as = accumulate(score.begin(), score.end(), 0.0);
+		double stay = m[0][0];
+		double  out = (N==1 ? 0 : m[1][0]);
+
+		vector<double> result(N);
+		for(int i=0; i<N; ++i)
+			result[i] = (as-score[i])*out + score[i]*stay;
+		return result;
+	}
+};
+
+// 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 <double>& Expected, const vector <double>& Received) {
+ bool ok = true;
+ for(int i=0; i<Expected.size(); ++i)
+   if( abs(Expected[i]-Received[i])>1e-9 )
+     ok = false;
+ 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(_, CandyBox().expectedScore(C, score, S));}
+int main(){
+
+CASE(0)
+	int C = 10; 
+	int score_[] = {1, 10};
+	  vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_)); 
+	int S = 0; 
+	double __[] = {1.0, 10.0 };
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int C = 2; 
+	int score_[] = {1, 10};
+	  vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_)); 
+	int S = 1; 
+	double __[] = {4.0, 7.000000000000001 };
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int C = 1; 
+	int score_[] = {1, 4, 10};
+	  vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_)); 
+	int S = 1; 
+	double __[] = {5.0, 5.0, 5.0 };
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	int C = 98; 
+	int score_[] = {13, 82, 74, 78, 12, 71, 81, 80, 30};
+	  vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_)); 
+	int S = 154; 
+	double __[] = {26.25622829378155, 74.87969915903301, 69.24219529059805, 72.06094722481552, 25.551540310227182, 67.12813133993495, 74.17501117547864, 73.47032319192427, 38.23592401420582 };
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	int C = 1; 
+	int score_[] = {1,1};
+	  vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_)); 
+	int S = 1; 
+	double __[] = {1,1};
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	int C = 2; 
+	int score_[] = {1};
+	  vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_)); 
+	int S = 10000; 
+	double __[] = {1};
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+}
+// END CUT HERE

ADDED   SRM/462/1C.cpp
Index: SRM/462/1C.cpp
==================================================================
--- SRM/462/1C.cpp
+++ SRM/462/1C.cpp
@@ -0,0 +1,204 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+typedef int             vert;
+typedef int             cost;
+typedef pair<cost,vert> edge;
+typedef vector<edge>    edges;
+typedef vector<edges>   graph;
+
+static const cost INF   = 0x12345678; // large enough but INF+INF<2^31
+static const vert START = 0;
+static const vert GOAL  = 1;
+
+class WarTransportation { public:
+	int messenger(int n, vector <string> highways) 
+	{
+		return solve( parse(n, highways) );
+	}
+
+	graph parse(int n, vector <string> highways)
+	{
+		graph G(n);
+
+		string hi = accumulate(highways.begin(), highways.end(), string());
+		for(int i=0; i<hi.size(); )
+		{
+			int k = hi.find(',', i);
+			if( k == string::npos ) k = hi.size();
+
+			int a, b, c;
+			stringstream(hi.substr(i,k-i)) >> a >> b >> c;
+			G[a-1].push_back( edge(c,b-1) );
+
+			i = k+1;
+		}
+
+		return G;
+	}
+
+	int solve( const graph& G )
+	{
+		// Suppose you reached the city "v", and found there the most critical load is broken.
+		// How long will it take a detour to the GOAL?  It's ukai[v]!
+
+		vector<cost> ukai;
+		for(int v=0; v<G.size(); ++v)
+			ukai.push_back( ukaiDist(G,v) );
+
+		// Compute the least T such that:
+		//   we get to the GOAL, making the worst case time <= T?
+
+		cost L=0, R=99999999;
+		if( !reachable(G, ukai, R) ) return -1;
+		if(  reachable(G, ukai, L) ) return 0;
+
+		// We can when T=R, and cannot T=L. 
+		// That is, T in (L, R]. Now let's binary-search!
+
+		while( R-L>1 )
+			(reachable(G, ukai, (L+R)/2) ? R : L) = (L+R)/2;
+		return R;
+	}
+
+	cost ukaiDist( const graph& G, vert v )
+	{
+		if( v == GOAL )        return 0;
+		if( G[v].size() == 0 ) return INF;
+
+		cost worst = 0;
+		for(int f=0; f<G[v].size(); ++f) // f : broken road
+		{
+			priority_queue< edge, vector<edge>, greater<edge> > Q;
+			set<vert> V;
+			V.insert(v);
+			for(int i=0; i<G[v].size(); ++i) // push all loads from v, except f
+				if( i != f )
+					Q.push( G[v][i] );
+			worst = max( worst, dijkstra(G,Q,V) ); // start dijkstraing
+		}
+		return worst;
+	}
+
+
+	bool reachable( const graph& G, const vector<cost>& ukai, cost ukaiLimit )
+	{
+		priority_queue< edge, vector<edge>, greater<edge> > Q;
+		set<vert> V;
+		Q.push( edge(0,START) );
+		return dijkstra(G, Q, V, ukai, ukaiLimit) != INF;
+	}
+
+	cost dijkstra( const graph& G,
+		priority_queue< edge, vector<edge>, greater<edge> >& Q, set<vert>& V,
+		const vector<cost>& ukai=vector<cost>(), cost ukaiLimit=-1
+	) {
+		while( !Q.empty() )
+		{
+			// pop
+			cost c = Q.top().first;
+			vert v = Q.top().second;
+			Q.pop();
+
+			// check
+			if( V.count(v) || (ukaiLimit>=0 && c+ukai[v]>ukaiLimit) )
+				continue;
+			if( v == GOAL )
+				 return c;
+			V.insert(v);
+
+			// next
+			for(int i=0; i<G[v].size(); ++i)
+				if( !V.count(G[v][i].second) )
+					Q.push( edge(c+G[v][i].first, G[v][i].second) );
+		}
+		return INF;
+	}
+};
+
+// 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(_, WarTransportation().messenger(n, highways));}
+int main(){
+
+CASE(0)
+	int n = 3; 
+	string highways_[] = {"1 2 1,1 3 2,3 2 3"};
+	  vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_)); 
+	int _ = 5; 
+END
+CASE(1)
+	int n = 8; 
+	string highways_[] = {"1 3 1,1 4 1,3 5 1,4 5 1,5 6 1,6 7 1,6 8 1,7 2 1,",
+ "8 2 1"};
+	  vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_)); 
+	int _ = -1; 
+END
+CASE(2)
+	int n = 4; 
+	string highways_[] = {"1 3 1,1 3 2,3 2 1,1 4 1,4 2 1"};
+	  vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_)); 
+	int _ = -1; 
+END
+CASE(3)
+	int n = 4; 
+	string highways_[] = {"1 3 1,3 2 1,1 4 1,4 2 1,3 4 1"};
+	  vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_)); 
+	int _ = 3; 
+END
+CASE(4)
+	int n = 20; 
+	string highways_[] = {"1 13 3,13 4 7,4 3 4,3 10 8,10 18 9,18 12 6,12 2 3,",
+ "1 17 6,17 13 6,13 9 4,9 10 8,10 7 2,7 5 5,5 19 9,1",
+ "9 14 6,14 16 9,16 18 7,18 15 5,15 20 3,20 12 9,12 ",
+ "8 4,8 11 3,11 4 1,4 3 7,3 2 3,20 10 2,1 18 2,16 19",
+ " 9,4 15 9,13 15 6"};
+	  vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_)); 
+	int _ = 23; 
+END
+CASE(5)
+	int n = 30; 
+	string highways_[] = {
+		"11 22 752,9 28 573,8 20 549,2 29 96,12 25 835,11 2", "3 443,28 20 59,5 16 223,29 24 382,14 6 436,5 21 47", "7,28 1 290,20 23 567,6 26 347,14 8 436,23 7 585,22", " 14 829,19 8 897,18 7 161,29 22 446,6 3 47,6 11 11", "9,23 13 357,15 2 539,30 27 246,20 26 364,11 13 518", ",20 29 360,10 9 140,9 19 178,24 5 75,4 9 465,22 4 ", "271,21 25 632,25 16 705,23 19 777,15 11 668,25 6 9", "11,26 21 940,27 12 114,23 29 775,15 22 907,10 15 1", "86,25 21 727,26 7 324,15 21 251,20 7 369,29 9 5,5 ", "4 780,10 23 774,13 15 65,2 8 938,9 3 150,6 9 109,4", " 22 649,24 13 274,14 3 403,12 19 66,3 13 798,7 20 ", "912,24 14 751,25 27 575,14 20 580,2 5 110,24 7 215", ",1 5 194,3 2 786,2 19 716,22 24 331,9 21 375,15 9 ", "397,18 27 753,24 23 181,17 27 386,12 30 313,18 25 ", "155,19 24 162,11 7 533,13 2 307,20 21 100,14 24 52", "6,29 8 505,28 8 776,5 27 949,16 14 43,16 30 84,10 ", "1 323,12 18 590,8 15 357,12 6 185,20 8 328,26 4 83", ",5 10 67,1 11 582,9 23 610,16 1 246,6 4 679,22 21 ", "149,17 10 321,29 27 560,20 19 771,11 30 506,6 25 1", "83,1 23 948,23 17 125,26 5 912,15 23 470,30 10 293", ",4 18 313,11 19 261,16 29 259,19 5 408,18 12 960,2", "4 3 743,17 3 4,30 17 347,11 2 648,16 8 868,12 10 6", "50,21 14 425,5 28 947,10 13 578,14 15 681,5 2 656,", "16 12 447,26 27 915,16 10 477,8 25 994,20 10 582,9", " 7 420,10 26 389,20 22 360,26 10 321,28 19 922,23 ", "20 393,13 14 447,29 15 33,30 1 811,2 28 597,13 8 5", "9,18 29 437,23 2 101,30 12 999,1 27 701,19 28 534,", "23 21 518,3 11 589,18 14 662,5 14 455,16 15 230,2 ", "17 633,19 13 242,10 18 404,10 4 731,15 6 221,25 15", " 747,3 23 465,24 9 569,12 11 645,5 24 748,23 26 44", "4,30 21 451,29 17 141,25 3 292,26 6 400,18 8 497,2", "4 19 901,17 5 49,21 12 141,30 18 7,20 18 271,13 3 ", "17,29 4 952,2 13 903,1 24 558,25 1 125,14 13 914,1", "4 12 385,1 3 40,30 8 704,18 5 901,19 10 822,22 27 ", "938,5 18 808,5 29 1,10 8 791,2 7 920,12 5 359,5 9 ", "744,1 25 819,6 30 262,24 6 7,12 7 870,17 25 932,28", " 18 771,23 16 699,26 24 834,27 20 824,30 23 95,22 ", "5 553,26 29 150,25 4 70,4 20 501,9 16 291,2 30 40,", "19 18 602,19 3 108,29 11 827,19 22 702,26 11 238,2", "8 22 392,22 10 496,13 25 160,12 24 700,22 29 654,9", " 2 701,28 7 946,21 5 223,7 22 902,12 15 43,21 8 67", "8,28 27 946,7 15 603,15 8 114,25 10 234,19 4 128,2", "4 8 990,11 12 554,23 9 646,10 24 755,8 16 857,23 1", " 806,15 13 929,21 11 601,19 30 245,17 21 474,27 25", " 638,11 21 411,4 26 895,13 24 599,12 13 226,30 22 ", "104,30 24 53,29 10 69,29 30 263,28 6 349,6 16 982,", "4 6 273,1 30 533,29 21 443,7 3 867,17 11 756,1 7 6", "87,29 2 799,5 22 42,16 20 708,25 11 476,23 8 186,2", "3 3 820,23 18 226,21 9 429,17 26 201,25 26 79,12 2", " 671,23 14 698,10 30 92,3 25 380,14 30 420"};
+	  vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_)); 
+	int _ = 799; 
+END
+/*
+CASE(6)
+	int n = ; 
+	string highways_[] = ;
+	  vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/463-U/1A.cpp
Index: SRM/463-U/1A.cpp
==================================================================
--- SRM/463-U/1A.cpp
+++ SRM/463-U/1A.cpp
@@ -0,0 +1,80 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000007;
+class RabbitNumbering { public:
+	int theCount(vector <int> maxNumber) 
+	{
+		sort(maxNumber.begin(), maxNumber.end());
+		LL c = 1;
+		for(int i=0; i<maxNumber.size(); ++i)
+			if( maxNumber[i]-i <= 0 )
+				return 0;
+			else
+				c = (c * (maxNumber[i]-i)) % MODVAL;
+		return c;
+	}
+};
+
+// 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(_, RabbitNumbering().theCount(maxNumber));}
+int main(){
+
+CASE(0)
+	int maxNumber_[] = {5};
+	  vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_)); 
+	int _ = 5; 
+END
+CASE(1)
+	int maxNumber_[] = {4, 4, 4, 4};
+	  vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_)); 
+	int _ = 24; 
+END
+CASE(2)
+	int maxNumber_[] = {5, 8};
+	  vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_)); 
+	int _ = 35; 
+END
+CASE(3)
+	int maxNumber_[] = {2, 1, 2};
+	  vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_)); 
+	int _ = 0; 
+END
+CASE(4)
+	int maxNumber_[] = {25, 489, 76, 98, 704, 98, 768, 39, 697, 8, 56, 74, 36, 95, 87, 2, 968, 4, 920, 54, 873, 90};
+	  vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_)); 
+	int _ = 676780400; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/463-U/1B.cpp
Index: SRM/463-U/1B.cpp
==================================================================
--- SRM/463-U/1B.cpp
+++ SRM/463-U/1B.cpp
@@ -0,0 +1,88 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Nisoku { public:
+   double theMax(vector <double> cards) 
+   {
+      sort(cards.begin(), cards.end());
+
+      double ans = 0.0;
+      for(int i=0; 2*i<=cards.size(); ++i)
+         ans = max(ans,
+            accumulate(cards.begin()+2*i, cards.end(),
+               inner_product( cards.begin(), cards.begin()+i,
+                              cards.rend()-2*i,
+                              1.0, multiplies<double>(), plus<double>() ),
+               multiplies<double>()
+            )
+         );
+      return ans;
+   }
+};
+
+// 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(_, Nisoku().theMax(cards));}
+int main(){
+
+CASE(0)
+   double cards_[] = {5, 8};
+     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_)); 
+   double _ = 40.0; 
+END
+CASE(1)
+   double cards_[] = {1.5, 1.8};
+     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_)); 
+   double _ = 3.3; 
+END
+CASE(2)
+   double cards_[] = {8.26, 7.54, 3.2567};
+     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_)); 
+   double _ = 202.82857868; 
+END
+CASE(3)
+   double cards_[] = {1.5, 1.7, 1.6, 1.5};
+     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_)); 
+   double _ = 9.920000000000002; 
+END
+CASE(4)
+   double cards_[] = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_)); 
+   double _ = 1.0E50; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/463-U/1C-U.cpp
Index: SRM/463-U/1C-U.cpp
==================================================================
--- SRM/463-U/1C-U.cpp
+++ SRM/463-U/1C-U.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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int MODVAL = 1000000007;
+typedef pair<pair<LL,LL>,LL> state;
+
+class RabbitPuzzle { public:
+	int theCount(vector<long long> rabbits, vector<long long> nests, int K) 
+	{
+		state s(make_pair(rabbits[0],rabbits[1]), rabbits[2]);
+		state g(make_pair(nests[0],nests[1]), nests[2]);
+
+		map<state,int> ms, mg;
+		calc(s, K/2, ms);
+		calc(g, (K+1)/2, mg);
+
+		int result = 0;
+		for(map<state,int>::iterator it=ms.begin(); it!=ms.end(); ++it) {
+			map<state,int>::iterator jt = mg.find(it->first);
+			if( jt != mg.end() )
+				result = (result + LL(it->second)*jt->second)%MODVAL;
+		}
+		return result;
+	}
+
+	void calc(const state& s, int n, map<state,int>& m)
+	{
+		if( n == 0 )
+			(m[s] += 1) %= MODVAL;
+		else {
+			LL a = s.first.first;
+			LL b = s.first.second;
+			LL c = s.second;
+			if( 2*b-a < c ) calc(state(make_pair(b,2*b-a),c), n-1, m);
+			calc(state(make_pair(2*a-b,a),c), n-1, m);
+			calc(state(make_pair(a,c),2*c-b), n-1, m);
+			if( a < 2*b-c ) calc(state(make_pair(a,2*b-c),b), n-1, m);
+		}
+	}
+};
+
+// 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(_, RabbitPuzzle().theCount(rabbits, nests, K));}
+int main(){
+
+CASE(0)
+	long rabbits_[] = {0, 5, 8};
+	  vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_)); 
+	long nests_[] = {0, 8, 11};
+	  vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_)); 
+	int K = 1; 
+	int _ = 1; 
+END
+CASE(1)
+	long rabbits_[] = {0, 5, 8};
+	  vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_)); 
+	long nests_[] = {0, 8, 11};
+	  vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_)); 
+	int K = 3; 
+	int _ = 5; 
+END
+CASE(2)
+	long rabbits_[] = {0, 5, 8};
+	  vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_)); 
+	long nests_[] = {0, 8, 11};
+	  vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_)); 
+	int K = 2; 
+	int _ = 0; 
+END
+CASE(3)
+	long rabbits_[] = {5, 8, 58};
+	  vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_)); 
+	long nests_[] = {13, 22, 64};
+	  vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_)); 
+	int K = 58; 
+	int _ = 0; 
+END
+CASE(4)
+	long rabbits_[] = {0, 1, 2};
+	  vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_)); 
+	long nests_[] = {1, 2, 3};
+	  vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_)); 
+	int K = 100; 
+	int _ = 0; 
+END
+CASE(5)
+	long rabbits_[] = {5, 8, 58};
+	  vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_)); 
+	long nests_[] = {20, 26, 61};
+	  vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_)); 
+	int K = 58; 
+	int _ = 537851168; 
+END
+CASE(6)
+	long rabbits_[] = {67, 281, 2348};
+	  vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_)); 
+	long nests_[] = {235, 1394, 3293};
+	  vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_)); 
+	int K = 83; 
+	int _ = 167142023; 
+END
+CASE(7)
+	long rabbits_[] = {-1000000000000000000, 999999999999999998, 999999999999999999};
+	  vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_)); 
+	long nests_[] = {-1000000000000000000, 999999999999999999, 1000000000000000000};
+	  vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_)); 
+	int K = 5; 
+	int _ = 29; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/464/1A.cpp
Index: SRM/464/1A.cpp
==================================================================
--- SRM/464/1A.cpp
+++ SRM/464/1A.cpp
@@ -0,0 +1,125 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ColorfulStrings { public:
+	string getKth(int n, int k) 
+	{
+		// cannot have 11 distinct digits
+		// if we have 0, then ...
+		// if we have 1, then ...
+		if(n>8)
+			return "";
+
+		string s = (n>=2 ? "23456789" : "0123456789");
+		do {
+			if( is_colorful(s,n) )
+				if( --k == 0 )
+					return s.substr(0,n);
+		} while( next_perm(s, n>=2 ? 8-n : 10-n) );
+		return "";
+	}
+
+	bool is_colorful(string& s, int n) {
+		set<int> ps;
+		for(int i=0; i<n; ++i) {
+			int p = s[i]-'0';
+			if( !ps.insert(p).second )
+				return false;
+			for(int j=i+1; j<n; ++j) {
+				p *= s[j]-'0';
+				if( !ps.insert(p).second )
+					return false;
+			}
+		}
+		return true;
+	}
+
+	int fact(int n) {
+		return n ? n*fact(n-1) : 1;
+	}
+	bool next_perm(string& s, int nn) {
+		int f = fact(nn);
+		while(f--)
+			if( !next_permutation(s.begin(), s.end()) )
+				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 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(_, ColorfulStrings().getKth(n, k));}
+int main(){
+
+CASE(0)
+	int n = 3; 
+	int k = 4; 
+	string _ = "238"; 
+END
+CASE(1)
+	int n = 4; 
+	int k = 2000; 
+	string _ = ""; 
+END
+CASE(2)
+	int n = 5; 
+	int k = 1; 
+	string _ = "23457"; 
+END
+CASE(3)
+	int n = 2; 
+	int k = 22; 
+	string _ = "52"; 
+END
+CASE(4)
+	int n = 6; 
+	int k = 464; 
+	string _ = "257936"; 
+END
+CASE(5)
+	int n = 1; 
+	int k = 1; 
+	string _ = "0"; 
+END
+CASE(6)
+	int n = 50; 
+	int k = 1000000000; 
+	string _ = "???"; 
+END
+CASE(7)
+	int n = 2; 
+	int k = 57; 
+	string _ = "???"; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/464/1B.cpp
Index: SRM/464/1B.cpp
==================================================================
--- SRM/464/1B.cpp
+++ SRM/464/1B.cpp
@@ -0,0 +1,193 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ColorfulDecoration { public:
+	int getMaximum(vector <int> xa, vector <int> ya, vector <int> xb, vector <int> yb) 
+	{
+		int L=0, R=1000000001;
+		while( R-L>=2 )
+		{
+			int C = (L+R)/2;
+			(canPlace(C, xa, ya, xb, yb)?L:R) = C;
+		}
+		return L;
+	}
+
+	typedef vector< vector<int> > graph;
+
+	bool canPlace(int C, vector <int> xa, vector <int> ya, vector <int> xb, vector <int> yb)
+	{
+		int N = xa.size();
+
+		graph G(2*N);
+		for(int i=0; i<N; ++i) {
+			for(int j=0; j<N; ++j) if(i!=j)
+				if( !ok(C, xa[i], ya[i], xa[j], ya[j]) )
+					G[i].push_back(N+j);
+			for(int j=0; j<N; ++j) if(i!=j)
+				if( !ok(C, xa[i], ya[i], xb[j], yb[j]) )
+					G[i].push_back(j);
+			for(int j=0; j<N; ++j) if(i!=j)
+				if( !ok(C, xb[i], yb[i], xa[j], ya[j]) )
+					G[N+i].push_back(N+j);
+			for(int j=0; j<N; ++j) if(i!=j)
+				if( !ok(C, xb[i], yb[i], xb[j], yb[j]) )
+					G[N+i].push_back(j);
+		}
+
+		for(int i=0; i<N; ++i)
+			if( reachable(G,i,N+i) && reachable(G,N+i,i) )
+				return false;
+		return true;
+	}
+
+	bool reachable(graph& G, int s, int d)
+	{
+		set<int> V;
+		queue<int> Q;
+		Q.push(s);
+		V.insert(s);
+		while( !Q.empty() ) {
+			int v = Q.front(); Q.pop();
+			for(int i=0; i<G[v].size(); ++i) {
+				int u = G[v][i];
+				if( u == d )
+					return true;
+				if( !V.count(u) )
+					V.insert(u), Q.push(u);
+			}
+		}
+		return false;
+	}
+
+	bool ok(int C, int x1, int y1, int x2, int y2)
+	{
+		return C <= max(abs(x1-x2), abs(y1-y2));
+	}
+};
+
+// 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(_, ColorfulDecoration().getMaximum(xa, ya, xb, yb));}
+int main(){
+
+CASE(0)
+	int xa_[] = { 10,  0,  7 };
+	  vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_)); 
+	int ya_[] = {  0, 19,  6 };
+	  vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_)); 
+	int xb_[] = { 20, 10, 25 };
+	  vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_)); 
+	int yb_[] = { 20, 35, 25 };
+	  vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_)); 
+	int _ = 19; 
+END
+CASE(1)
+	int xa_[] = { 464, 20 };
+	  vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_)); 
+	int ya_[] = { 464, 10 };
+	  vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_)); 
+	int xb_[] = { 464,  3 };
+	  vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_)); 
+	int yb_[] = { 464, 16 };
+	  vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_)); 
+	int _ = 461; 
+END
+CASE(2)
+	int xa_[] = { 0, 0, 1, 1 };
+	  vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_)); 
+	int ya_[] = { 0, 0, 1, 1 };
+	  vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_)); 
+	int xb_[] = { 1, 1, 0, 0 };
+	  vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_)); 
+	int yb_[] = { 1, 1, 0, 0 };
+	  vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_)); 
+	int _ = 0; 
+END
+CASE(3)
+	int xa_[] = { 0, 3, 0, 5, 6 };
+	  vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_)); 
+	int ya_[] = { 1, 6, 0, 8, 5 };
+	  vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_)); 
+	int xb_[] = { 6, 1, 7, 4, 7 };
+	  vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_)); 
+	int yb_[] = { 5, 9, 2, 8, 9 };
+	  vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_)); 
+	int _ = 3; 
+END
+CASE(4)
+	int xa_[] = { 1000000000, 0 };
+	  vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_)); 
+	int ya_[] = { 0, 1000000000 };
+	  vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_)); 
+	int xb_[] = { 0, 1000000000 };
+	  vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_)); 
+	int yb_[] = { 0, 1000000000 };
+	  vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_)); 
+	int _ = 1000000000; 
+END
+CASE(5)
+	int xa_[] = {0,0};
+	  vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_)); 
+	int ya_[] = {0,0};
+	  vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_)); 
+	int xb_[] = {0,0};
+	  vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_)); 
+	int yb_[] = {0,0};
+	  vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_)); 
+	int _ = 0; 
+END
+CASE(6)
+	int xa_[] = {0,0};
+	  vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_)); 
+	int ya_[] = {0,0};
+	  vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_)); 
+	int xb_[] = {1,1};
+	  vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_)); 
+	int yb_[] = {1,1};
+	  vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_)); 
+	int _ = 1; 
+END
+CASE(7)
+	int xa_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
+	  vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_)); 
+	int ya_[] = {1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,10};
+	  vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_)); 
+	int xb_[] = {2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,10,11};
+	  vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_)); 
+	int yb_[] = {3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,10,11,12};
+	  vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_)); 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/464/1C.cpp
Index: SRM/464/1C.cpp
==================================================================
--- SRM/464/1C.cpp
+++ SRM/464/1C.cpp
@@ -0,0 +1,190 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ColorfulMaze { public:
+	double getProbability(vector <string> maze, vector <int> trap) 
+	{
+		return solve(maze, trap, 0);
+	}
+
+	typedef int vert;
+
+	double solve(const vector<string>& maze, const vector<int>& trap, int damage)
+	{
+		const int H = maze.size();
+		const int W = maze[0].size();
+
+		// R[i] == list of cells colored 'A'+i and reachable from '$'
+		vector<vert> R[7];
+		{
+			stack<vert>  Q;
+			vector<bool> V(H*W);
+			for(int y=0; y<H; ++y)
+				for(int x=0; x<W; ++x)
+					if( maze[y][x] == '$' )
+						{Q.push(y*W+x); V[y*W+x]=1;}
+
+			while( !Q.empty() ) {
+				vert v=Q.top(); Q.pop();
+				int y=v/W, x=v%W;
+
+				int dy[]={-1,+1,0,0}, dx[]={0,0,-1,+1};
+				for(int i=0; i<4; ++i) {
+					int yy=y+dy[i], xx=x+dx[i],u=yy*W+xx;
+					if( 0<=yy && yy<H && 0<=xx && xx<W && maze[yy][xx]!='#' && !V[u] ) {
+						if( maze[yy][xx]=='!' )
+							return 1.0;
+						V[u]=1;
+						if( maze[yy][xx] == '.' )
+							Q.push(u);
+						else
+							R[maze[yy][xx]-'A'].push_back(u);
+					}
+				}
+			}
+		}
+
+		double pMax = 0.0;
+		for(int k=0; k<7; ++k) if(!R[k].empty()) {
+			double p = 0; // prob. to survive when you first step in the color 'A'+k
+
+			vector<string> m = maze;
+			{ // the case it was not a trap
+				for(int y=0; y<H; ++y)
+					for(int x=0; x<W; ++x)
+						if(maze[y][x]=='A'+k)    m[y][x] = '.';
+						else if(maze[y][x]=='$') m[y][x] = ".#"[damage];
+				for(int i=0; i<R[k].size(); ++i)
+					m[R[k][i]/W][R[k][i]%W] = '$';
+				p = (1-trap[k]/100.0) * solve(m, trap, damage); 
+			}
+			if( damage == 0 ) { // the case it was a trap
+				for(int y=0; y<H; ++y)
+					for(int x=0; x<W; ++x)
+						if(maze[y][x]=='A'+k && m[y][x]!='$') m[y][x] = '#';
+				p += (trap[k]/100.0) * solve(m, trap, damage+1);
+			}
+
+			pMax = max(pMax, p); // take the maximum
+		}
+		return pMax;
+	}
+};
+
+// 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(_, ColorfulMaze().getProbability(maze, trap));}
+int main(){
+
+CASE(0)
+	string maze_[] = { ".$.",
+  "A#B",
+  "A#B",
+  ".!." };
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = { 50, 40, 0, 0, 0, 0, 0 };
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.8; 
+END
+CASE(1)
+	string maze_[] = { ".$.",
+  "A#B",
+  "A#C",
+  ".!." };
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = { 20, 70, 40, 0, 0, 0, 0 };
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.86; 
+END
+CASE(2)
+	string maze_[] = { "$A#",
+  ".#.",
+  "#B!" };
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = { 10, 10, 10, 10, 10, 10, 10 };
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.0; 
+END
+CASE(3)
+	string maze_[] = { "$A..",
+  "##.A",
+  "..B!" };
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = { 50, 50, 0, 0, 0, 0, 0 };
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.75; 
+END
+CASE(4)
+	string maze_[] = { "$C..",
+  "##.A",
+  "..B!" };
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = { 50, 50, 100, 0, 0, 0, 0 };
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.5; 
+END
+CASE(5)
+	string maze_[] = { ".$.D.E.F.G.!." };
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = { 10, 20, 30, 40, 50, 60, 70 };
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.23400000000000004; 
+END
+CASE(6)
+	string maze_[] = { "CC...AA",
+  "C##.##A",
+  "!.E.E.$",
+  "D##.##B",
+  "DD...BB" };
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = { 90, 90, 25, 50, 75, 0, 0 };
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.8125; 
+END
+/*
+CASE(7)
+	string maze_[] = {"#BGGCAG#B##EFEBFCBGFD#E##FA##BBF#BCADAFGG#CD#AGFAD", "#CGEGBFF#GECDCFF#FBDDAAG#DCCBBB#CC#BGCBDD##AEDAAG#", "E##E#GEBC#CC#GGAEDECBBA#BE#ECE#FAGEBFGD#BCADGF##D#", "DB##BDCABBBADAFGEDEEFBEFFEGEAGFBEFGDA#CE#AFA#DF#DD", "GEGG##AA#GAE##DDEFGFA#CEAEG#BBFGBBADBGCEDBABCBGFEF", "DCGECEDEC#E##BBBEGGFDDF#C##DC#EFCF#EE#FCAGBGAAGFEF", "GCAFCFEGDFCCC##CGFF#A#BAFEAD#D#FC#D##DAADAF#B#DEEE", "C#G###BD#FBG#E#D###GCGG#GGFBD#EEGBE#BCE#FF##AEDEE#", "CDA##AGBDFDE#FD#ACCC#GDBABF#CC#B#AEBFCFG#GFACBA#AB", "AA#CDFCACAFEEEA#ABAFDFEGAE#FADBFAECBBAF##BGGDBEFDF", "FABGDDEBDDCADAC#ECAG##CFDEA#FFA#DAA#CABCGBFCFA###A", "!FCFG#FACC#GABA#CGBFCBC#BGGDCAFDDCFDGADEGDGAB#F#AG", "CDEAE#E#DEDDDGFEFEE#DDDBCDDFF####FAG#FB#G#GB###EFC", "#AF##B#BGD#E#GGEEEC##FBEGBG#DGDCBBFBEGAF##ADGGA#GG", "GBBEDAFDFFCG#GADACCC###EDFCE#GBFD#BBAEAFC#BEDGAFBA", "G#FFEF#EFEEGDADAC#BA#DCB#EG#GADE##ABAEFCGDD##BB##B", "BF#C##BBCCCAEDCD##FA#ACA#FCFA#EDGAGEFECCBBGFCGDEEB", "DE#FEDFFDDCBA#AD#GDAE#BGAEGEBF#GEDGCF#DACA#DDBCGA#", "GAEBFCEF##E#EFC#BFC#GCGEFAD#GDB#DG#FBDD#FAG##ABEED", "GFGDFDDEFAGEBCBB#DCA##FEEA#GABGBBD#FEBDECF##A#BD#F", "##BGADFCA##B##EBEBADADCCFBDEFAF#C#GGAADE#D##ACGF#C", "ECF##DCCDEGCG#C#CG#EGE#B##ADD#ADA#BGCADECECBD#DD#B", "GDFEAEBG##GAGBBFBECGCBEACB##GDDFGGAEFEBCCEACDAE#A#", "B#G#D#BABEDGBC#BCBFC#DGEBE#B#BCDB#CBBDBAAAF###FD#F", "EFDCFAGG#GB##BEDGFF#BBCF#BEDCABCEFCGED#EFABBBCGBCB", "#GEB#ACECDCCFGFGDGABACCG#FGAAGGD#ED##FEFBDEF#C#FDE", "#BGEFEG#CDGBFBFDEC#DGFFB#B#GBFGBEGF###CDBDEA##BE#F", "CCGBCGF#E#BBEFF###GED#DEEE##E#B#EEG#FA#GBCEGBGGCEF", "A##DA#A#BADG#DDF#EC#BABDE#CAD#DFB#GFBAEBCGACGCA#B#", "DB###BAD#FDCGCD#EBGGEEGF#DAFGDEC#FCCAEFDBCDFA###BB", "#DCEEEEABG#GFADBDFDBABEGDAEFEC#D#F#ADECBEG#CFEDD##", "#CD#DD##D#BA#AB#CBB#DDEDGBDDDDECB#DGB#GCEG#AAEFBFA", "FB#E#GDCBFF#DGDDDG#DFCCAD##CBFGGFDDGDDFCBGADAEACFE", "B#FF#BE##GCEA#CDDGECCAB#BEDFGCF#CEEFC#EDD#DEBGA###", "FE#FGBA#DAFC#D#EC#FECBED#B#GB####AB#DCGECE#BEG#AGF", "##BDCF#DBEC#FCFBGEDDAAECFGDG#EF###ACEABGEEGAG##BA#", "FF#EAGG##A#DB#BBE#BFDDCDBD#GGFAEEDBBEG#DDG##DFGGCA", "###E#BFGDBEA##EBCB#GG#CEBFGDBAGDF#CC#ABCFGAAEFABGC", "AGCGFBFBFGCE#ECCABCCBD#D##BBGACGCBFAD#DBDE#CE#EAD#", "AGGBGCEA##A#EFEF#FGAAFCB#EF#DGCFF#CBAAE#GFB#A#EFDD", "BEEDCDDGFFB#FB##FEFBFACBACA#EGDAEDGG#D###DECFEEAD#", "FDDBDDG#GGACG#F$#D#FEECF##FDCGAF#CGDEGC#GD##ABFEF#", "GBDDAB#BDDFGDBDDC#BABBGEGDAAG#FEDCAGGA#FDEC#ADGAED", "D#B#GBABD##AE#DD##A#CG#DF#AC#ABDDEBGEBA#A#FCDCAGDF", "DDD#FEFBCBFADADEBEF#FBEF#BAGFBD#GE#CFGG#CABGDGB#CF", "DGEGDDAE#F##C#DDF#DGEABCG#CFCF#FABFG#GEB#DG#EDECDE", "CCFEEB#A###AEB##GFB#FA#EDD#E#FAD#DB#ECFD#A#EFAG###", "CBEDEEG#FC##D##FBEEFEEA##ECADB#BFC#BDDDGDDGGEAEFEE", "#DB#GG#CA#AFBFGCCDGDD#BG#A#C#DA#B#CAGEADF#BEAD#E#A", "FC#GBFDEFAFCG#C#F#ECDB##ABA##AEEACAAEEAD#AAD#CFFA#"};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = {32, 65, 91, 81, 62, 45, 52};
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.009185498471999998; 
+END
+*/
+CASE(8)
+	string maze_[] = {"#A####.F...##B..#.B.A#....#.#......#B###.#.#.####.", "###F....DD###.#F..#.#...#.#.##..#F....##..#...G.#.", "#F.D##..DDD....##.D..D#DF..##...#F......#.F#E##.#.", ".#.#.E.#..#...#.##F#.#.#.###F##F##..#####.#F..#.#.", "##.#F#B..B..D###D#...#.D.##F#F####CA.#...###A##...", "C.#B#.#..##..B####.#..##.#.#.#####.#...GD#.DC##..#", "##C###CC.#C.##...##..#..##.##.E..##.#####....##...", ".###EE...##.#E##..##D#D.#D#F###..#..C###.#..C.C...", "A####.#..A...A#.#.###.#.A#A####..####.#BD...D.#.#.", ".#..E..CC.#.C#.#.#.C...C....G#..GA..##.####.#...#.", "####.A.#..AA#..###.#B#G.EE##...#..#G#CC#..#.....#.", "C....#...#.F#.C#C###.#.....F#.#..#..#F#...#####..#", "F...#C##.#D###.#C#..C...#C...CD.D...D#.#D#.F....#A", ".##AA#G##..#GB##DD#.....##.DD##..#..AA###.A..####.", ".##.A...#.A#...#..#GE###.C##.#.#.#.F.###......####", "###F.F##..#####.......##FF#F#E#E.#E.#...##B##B####", "##..#B#BA###.A..#..#A.####.GDD..####DE##.#.E.#####", "#D###.#.#.##D..##FB#.E##ED.##..D##.####.#....#D#.#", "D#..##.#####.BA.###A#B.#.#.....##..#.####.#.#.#B..", "BBB#..####..D#..#.##.#..#..#...##...#..##.#D.##.A.", "..B.BD#E#.#.E.......E##....E..#..#CC.C#.###.#.#...", "####CC....#E#.E###..##E..#EE.####.#....#.DDCC..##.", "#....#.##E.#####..####..E#F##.#..F.##A#..#..###.##", ".#..#G#G.#..#.#G.G.##.##G#G#.####.G..G#..G###..#G.", "#G###.#...D#D####.F####..#F#A##.#.G.###D##..###A#A", ".##AB####.F..#C.CF.#.F##..#.AAAA.BBB.B.##B#..##...", ".#.#F#...C#G#.F#.G##G#.##.##..####.GG.#.GBB#.###.B", "...F##.#.#.#.FA.#A##..#..B#A###..#.##..#..#.#AA.#.", "##.......AEEE#.#E..#...###B#.....#.....##.#..B#.BF", "...F..#..$C###...G..###.G##..#..G#....G.#.##EE#B#.", "FFFF.G.F.#.F#..#.#..##C#.#..A##.#A.##..#A#..A##.A.", "B#.B.#F##.A...#A#DG...G.#..E##B##...#.#.A#CC##C..#", "##D..#F.G####..G##G..##.#######GG#..#.GG#.#A#A##.#", "#B..#.#.#..##.#G#..#EEE.E.###.###EG#.##..G###E#E..", "###.#.ED#..DF###.#.#..##.####...##AE###BB##..#.B#F", ".#F#.#..#..#####CC...##.C#CBB.#...##B#..D#AA#A..#.", "...BBFB.#B..B#B####BG..#.G.#.##.###.G###...#GA..#A", ".#C.CA##E##EF#DF#E.E.###E.#G..CC.#..##..#A.#.E##EE", "..#F#.#.#....#F##F#F#..##.###F..#..#.G#####GG#.##G", ".#...DE#..#.#.#####.#.###D.#D.D.#....D#B#B#..DA..A", "#..##.#.###A.F##...#.....F#F#....F##F#.###E###ED#C", "C...C#F.#A##.#..#..#....#F#B#..F##F.D..###.A###A.A", ".###..#D..#..##C.#....##..##......###E.#..##EE.F##", "..F.#D.#...##D#..D#..#.F#.C..##..#..#....C..#B.#..", "#...##...B.###..#BF#C..##...###.##.##.GBB..#....#F", "F.#.##.##.#..C..#..E.CC#...C#G...#.G..G.A..F#F.#..", "##..F#.#....F.###D##.#G.##.###..##GG####.....##GG.", "##..#....#GG#G.G.F..F#..#....#.##..##.#CC.#.BA.#.#", "#.#..##D#.##.#.##.#.#A#.C..####.....#..#.###C.#C.#", ".#C!##...C###.E...#.#..###...E#####E#.###F#F.###.."};
+	  vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_)); 
+	int trap_[] = {14, 22, 100, 34, 15, 33, 42};
+	  vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_)); 
+	double _ = 0.34491599999999994; 
+END
+}
+// END CUT HERE

ADDED   SRM/465-U/1A.cpp
Index: SRM/465-U/1A.cpp
==================================================================
--- SRM/465-U/1A.cpp
+++ SRM/465-U/1A.cpp
@@ -0,0 +1,99 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TurretPlacement { public:
+	long long count(vector <int> x, vector <int> y) 
+	{
+		LL cnt = 0;
+		for(int i=0; i<x.size(); ++i)
+			for(int j=i+1; j<x.size(); ++j)
+				cnt += howMany(x[i], y[i], x[j], y[j]);
+		return cnt;
+	}
+	LL howMany(int x, int y, int X, int Y)
+	{
+		LL n = int(2*sqrt((X-x)*(X-x) + (Y-y)*(Y-y)));
+		return (n-1)*n/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 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(_, TurretPlacement().count(x, y));}
+int main(){
+
+CASE(0)
+	int x_[] = {0,2};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,2};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	long long _ = 10LL; 
+END
+CASE(1)
+	int x_[] = {0,1,2};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,1,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	long long _ = 8LL; 
+END
+CASE(2)
+	int x_[] = {1,2,3,0};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-1,-5,-7,100};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	long long _ = 65137LL; 
+END
+CASE(3)
+	int x_[] = {9998,-10000,10000,0};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {9998,10000,10000,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	long long _ = 2799564895LL; 
+END
+CASE(4)
+	int x_[] = {0,0};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	long long _ = 0LL; 
+END
+CASE(5)
+	int x_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
+	int y_[] = {10000,-10000,9000,-9000,8000,-8000,-7000,-7000,6000,-6000,5000,-5000,4000,-4000,3000,-3000,2000,-2000,1000,-1000,
+				 9800,- 9800,9500,-9500,8500,-8500,-7500,-7500,6500,-6500,5500,-5500,4500,-4500,3500,-3500,2500,-2500,1500,-1500};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	long long _ = -1LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/465-U/1B.cpp
Index: SRM/465-U/1B.cpp
==================================================================
--- SRM/465-U/1B.cpp
+++ SRM/465-U/1B.cpp
@@ -0,0 +1,260 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int NV = 512;
+typedef int           flow;
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+typedef flow          flow_graph[NV][NV];
+static const flow INF = 0x3fffffff;
+
+flow dinic_dfs( graph& G, flow_graph F, vert v, vert D,
+                int LV[], flow flow_in, int blocked[] )
+{
+	flow flow_out = 0;
+	for(int i=0; i!=G[v].size(); ++i) {
+		int u = G[v][i];
+		if( LV[v]+1==LV[u] && F[v][u] ) {
+			flow f = min(flow_in-flow_out, F[v][u]);
+			if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) ) {
+				F[v][u]  -= f;
+				F[u][v]  += f;
+				flow_out += f;
+				if( flow_in == flow_out ) return flow_out;
+			}
+		}
+	}
+	blocked[v] = (flow_out==0);
+	return flow_out;
+}
+
+flow maxFlow( graph& G, flow_graph F, vert S, vert D )
+{
+	for( flow total=0 ;; ) {
+		int LV[NV] = {0};
+		vector<int> Q(1, S);
+		for(int lv=1; !Q.empty(); ++lv) {
+			vector<int> Q2;
+			for(int i=0; i!=Q.size(); ++i) {
+				edges& ne = G[Q[i]];
+				for(int j=0; j!=ne.size(); ++j)
+					if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
+						LV[ne[j]]=lv, Q2.push_back(ne[j]);
+			}
+			Q.swap(Q2);
+		}
+
+		if( !LV[D] )
+			return total;
+
+		int blocked[NV] = {};
+		total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
+	}
+}
+
+class GreenWarfare { public:
+	int minimumEnergyCost(vector <int> canonX, vector <int> canonY, vector <int> baseX, vector <int> baseY, vector <int> plantX, vector <int> plantY, int energySupplyRadius) 
+	{
+		int B = baseX.size();
+		int P = plantX.size();
+
+		graph      G(P+P+B+B+2);
+		flow_graph F = {};
+
+		for(int x=0; x<P; ++x) {
+			G[P+P+B+B].push_back(x);
+			G[x].push_back(P+P+B+B);
+			F[P+P+B+B][x] = INF;
+		}
+		for(int x=0; x<P; ++x) {
+			G[x].push_back(P+x);
+			G[P+x].push_back(x);
+			F[x][P+x] = breakEnergy(canonX, canonY, plantX[x], plantY[x]);
+		}
+		for(int x=0; x<P; ++x)
+			for(int y=0; y<B; ++y)
+				if( dist(plantX[x],plantY[x],baseX[y],baseY[y]) <= energySupplyRadius*energySupplyRadius ) {
+					G[P+x].push_back(P+P+y);
+					G[P+P+y].push_back(P+x);
+					F[P+x][P+P+y] = INF;
+				}
+		for(int x=0; x<B; ++x) {
+			G[P+P+x].push_back(P+P+B+x);
+			G[P+P+B+x].push_back(P+P+x);
+			F[P+P+x][P+P+B+x] = breakEnergy(canonX, canonY, baseX[x], baseY[x]);
+		}
+		for(int x=0; x<B; ++x) {
+			G[P+P+B+x].push_back(P+P+B+B+1);
+			G[P+P+B+B+1].push_back(P+P+B+x);
+			F[P+P+B+x][P+P+B+B+1] = INF;
+		}
+
+		return maxFlow(G, F, P+P+B+B, P+P+B+B+1);
+	}
+
+	int dist(int x, int y, int X, int Y)
+	{
+		return (X-x)*(X-x) + (Y-y)*(Y-y);
+	}
+
+	int breakEnergy(const vector<int>& cx, const vector<int>& cy, int x, int y)
+	{
+		int e = 0x7fffffff;
+		for(int i=0; i<cx.size(); ++i)
+			e = min(e, dist(x,y,cx[i],cy[i]));
+		return e;
+	}
+};
+
+// 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(_, GreenWarfare().minimumEnergyCost(canonX, canonY, baseX, baseY, plantX, plantY, energySupplyRadius));}
+int main(){
+
+CASE(0)
+	int canonX_[] = { 0 };
+	  vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_)); 
+	int canonY_[] = { 0 };
+	  vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_)); 
+	int baseX_[] = {1,2,3};
+	  vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_)); 
+	int baseY_[] = {0,0,0};
+	  vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_)); 
+	int plantX_[] = {3};
+	  vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_)); 
+	int plantY_[] = {3};
+	  vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_)); 
+	int energySupplyRadius = 4; 
+	int _ = 14; 
+END
+CASE(1)
+	int canonX_[] = { 0 };
+	  vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_)); 
+	int canonY_[] = { 0 };
+	  vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_)); 
+	int baseX_[] = {1,2,3};
+	  vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_)); 
+	int baseY_[] = {0,0,0};
+	  vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_)); 
+	int plantX_[] = {2};
+	  vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_)); 
+	int plantY_[] = {2};
+	  vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_)); 
+	int energySupplyRadius = 4; 
+	int _ = 8; 
+END
+CASE(2)
+	int canonX_[] = {3,6};
+	  vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_)); 
+	int canonY_[] = {3,6};
+	  vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_)); 
+	int baseX_[] = {1,2,3,4,5};
+	  vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_)); 
+	int baseY_[] = {5,4,2,3,1};
+	  vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_)); 
+	int plantX_[] = {1,2,5};
+	  vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_)); 
+	int plantY_[] = {1,2,5};
+	  vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_)); 
+	int energySupplyRadius = 5; 
+	int _ = 12; 
+END
+CASE(3)
+	int canonX_[] = {0};
+	  vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_)); 
+	int canonY_[] = {0};
+	  vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_)); 
+	int baseX_[] = {-10,-10,10};
+	  vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_)); 
+	int baseY_[] = {10,-10,0};
+	  vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_)); 
+	int plantX_[] = {10,10,-10};
+	  vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_)); 
+	int plantY_[] = {10,-10,0};
+	  vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_)); 
+	int energySupplyRadius = 10; 
+	int _ = 200; 
+END
+CASE(4)
+	int canonX_[] = {0};
+	  vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_)); 
+	int canonY_[] = {0};
+	  vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_)); 
+	int baseX_[] = {3};
+	  vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_)); 
+	int baseY_[] = {3};
+	  vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_)); 
+	int plantX_[] = {1,2,3};
+	  vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_)); 
+	int plantY_[] = {0,0,0};
+	  vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_)); 
+	int energySupplyRadius = 4; 
+	int _ = 14; 
+END
+/*
+CASE(5)
+	int canonX_[] = ;
+	  vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_)); 
+	int canonY_[] = ;
+	  vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_)); 
+	int baseX_[] = ;
+	  vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_)); 
+	int baseY_[] = ;
+	  vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_)); 
+	int plantX_[] = ;
+	  vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_)); 
+	int plantY_[] = ;
+	  vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_)); 
+	int energySupplyRadius = ; 
+	int _ = ; 
+END
+CASE(6)
+	int canonX_[] = ;
+	  vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_)); 
+	int canonY_[] = ;
+	  vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_)); 
+	int baseX_[] = ;
+	  vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_)); 
+	int baseY_[] = ;
+	  vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_)); 
+	int plantX_[] = ;
+	  vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_)); 
+	int plantY_[] = ;
+	  vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_)); 
+	int energySupplyRadius = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/465-U/1C-U.cpp
Index: SRM/465-U/1C-U.cpp
==================================================================
--- SRM/465-U/1C-U.cpp
+++ SRM/465-U/1C-U.cpp
@@ -0,0 +1,116 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BouncingDiceGame { public:
+	double winProbability(int n, int d, int x, int y) 
+	{
+		int B = n-d;
+		x = min(B,x);
+		y = min(B,y);
+		int Z = min(x,y);
+		vector< vector<double> > p(B+1, vector<double>(B+1, 0));
+
+		// solve:
+		//   p[B][k] = 1 - p[k][B]
+		//   p[i][k] = 1/d \Sigma_{b=1..d} (1 - p[k][min(B,i+b)])
+		// return p[x][y];
+
+		for(int ik=B*2; ik>=Z*2; --ik)
+		for(int i=Z; i<=B; ++i)
+		{
+			int k = ik-i;
+			if( Z<=k && k<=B ) {
+				if(i==B && k==B) p[B][B] = d / (2*d-1);
+				else if( i==B ) p[B][k] = 1 - p[k][B]*(d-1)/d;
+				else {
+					double q = 0;
+					for(int b=1; b<=d; ++b)
+						q += 1 - p[k][min(B,i+b)];
+					p[i][k] = q/d;
+				}
+			}
+		}
+		return p[x][y];
+	}
+};
+
+// 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(_, BouncingDiceGame().winProbability(n, d, x, y));}
+int main(){
+
+CASE(0)
+	int n = 10; 
+	int d = 6; 
+	int x = 1; 
+	int y = 1; 
+	double _ = 0.5417251215862328; 
+END
+CASE(1)
+	int n = 10; 
+	int d = 2; 
+	int x = 1; 
+	int y = 1; 
+	double _ = 0.6090494791666666; 
+END
+CASE(2)
+	int n = 100; 
+	int d = 20; 
+	int x = 1; 
+	int y = 10; 
+	double _ = 0.49158887163174947; 
+END
+CASE(3)
+	int n = 10; 
+	int d = 5; 
+	int x = 9; 
+	int y = 1; 
+	double _ = 0.6943018666666667; 
+END
+/*
+CASE(4)
+	int n = ; 
+	int d = ; 
+	int x = ; 
+	int y = ; 
+	double _ = ; 
+END
+CASE(5)
+	int n = ; 
+	int d = ; 
+	int x = ; 
+	int y = ; 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/466-U/1A.cpp
Index: SRM/466-U/1A.cpp
==================================================================
--- SRM/466-U/1A.cpp
+++ SRM/466-U/1A.cpp
@@ -0,0 +1,104 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class LotteryCheating { public:
+	int minimalChange(string ID) 
+	{
+		int minMod = ID.size();
+
+		for(LL x=0;; ++x)
+		{
+			string s;
+			{stringstream ss; ss << x*x; ss >> s;}
+
+			if( s.size() > ID.size() )
+				break;
+			s = string(ID.size()-s.size(),'0')+s;
+			int c = 0;
+			for(int i=0; i<ID.size(); ++i)
+				if( s[i] != ID[i] )
+					++c;
+			minMod = min(minMod, c);
+		}
+
+		return minMod;
+	}
+};
+
+// 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(_, LotteryCheating().minimalChange(ID));}
+int main(){
+
+CASE(0)
+	string ID = "1"; 
+	int _ = 0; 
+END
+CASE(1)
+	string ID = "1234"; 
+	int _ = 2; 
+END
+CASE(2)
+	string ID = "9000000000"; 
+	int _ = 1; 
+END
+CASE(3)
+	string ID = "4294967296"; 
+	int _ = 0; 
+END
+CASE(4)
+	string ID = "7654321"; 
+	int _ = 3; 
+END
+CASE(5)
+	string ID = "2"; 
+	int _ = 1; 
+END
+CASE(6)
+	string ID = "4"; 
+	int _ = 0; 
+END
+CASE(7)
+	string ID = "8"; 
+	int _ = 1; 
+END
+CASE(8)
+	string ID = "1111111111"; 
+	int _ = -1; 
+END
+CASE(9)
+	string ID = "00201"; 
+	int _ = 1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/466-U/1B.cpp
Index: SRM/466-U/1B.cpp
==================================================================
--- SRM/466-U/1B.cpp
+++ SRM/466-U/1B.cpp
@@ -0,0 +1,77 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class LotteryPyaterochka { public:
+	double chanceToWin(int N_) 
+	{
+		LL N = N_;
+		LL n5 = N;
+		LL n4 = N*5*(N-1)*5;
+		LL n32 = N*10*(N-1)*10;
+		LL n311 = N*10*((N-1)*(N-2)/2)*5*5;
+		LL all = (5*N)*(5*N-1)*(5*N-2)*(5*N-3)*(5*N-4)/120;
+		return double(n5+n4+n32+n311) / all;
+	}
+};
+
+// 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(_, LotteryPyaterochka().chanceToWin(N));}
+int main(){
+
+CASE(0)
+	int N = 1; 
+	double _ = 1.0; 
+END
+CASE(1)
+	int N = 2; 
+	double _ = 1.0; 
+END
+CASE(2)
+	int N = 3; 
+	double _ = 0.5004995004995004; 
+END
+CASE(3)
+	int N = 6; 
+	double _ = 0.13161551092585574; 
+END
+CASE(4)
+	int N = 99; 
+	double _ = -1; 
+END
+CASE(5)
+	int N = 100; 
+	double _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/466-U/1C-U.cpp
Index: SRM/466-U/1C-U.cpp
==================================================================
--- SRM/466-U/1C-U.cpp
+++ SRM/466-U/1C-U.cpp
@@ -0,0 +1,156 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000007;
+
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL FACT(LL x) {return x<=1 ? 1 : MUL(x, FACT(x-1));}
+
+class DrawingBlackCrosses { public:
+	map<int, LL> memo;
+	LL rec(int must, int mustNot, int i, vector<int>& mask, int full)
+	{
+		int key = mustNot*20+i;
+		if( memo.count(key) )
+			return memo[key];
+
+		if( i == mask.size() ) {
+			if( must==0 ) {
+				int b = 0;
+				for(int i=0; (1<<i)<=mustNot; ++i)
+					if( mustNot & (1<<i) )
+						++b;
+				return FACT(b);
+			}
+			else
+				return 0;
+		}
+
+		LL cnt = 0;
+
+		// select this row
+		int seled   = mustNot | mask[i];
+		int notDone = full &~ seled;
+		for(int k=0; (1<<k)<=notDone; ++k)
+			if( (1<<k) & notDone ) {
+				LL c = rec(must&~(1<<k), mustNot|(1<<k), i+1, mask, full);
+				cnt = (cnt + c) % MODVAL;
+			}
+
+		// don't select
+		LL c = rec(must|notDone, mustNot, i+1, mask, full);
+		cnt = (cnt + c) % MODVAL;
+		return memo[key] = cnt;
+	}
+	int count(vector <string> field) 
+	{
+		vector<int> mask;
+		for(int i=0; i<field.size(); ++i) {
+			int m = 0;
+			for(int j=0; j<field[i].size(); ++j)
+				m |= (field[i][j]=='B')<<j;
+			mask.push_back(m);
+		}
+		int full = (1<<field[0].size()) - 1;
+		return rec(0, 0, 0, mask, full);
+	}
+};
+
+// 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(_, DrawingBlackCrosses().count(field));}
+int main(){
+
+CASE(0)
+	string field_[] = {"."};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string field_[] = {"BBB",
+ "BBB"};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 1; 
+END
+CASE(2)
+	string field_[] = {"...", 
+ "BB."};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 5; 
+END
+CASE(3)
+	string field_[] = {"....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "....................", 
+ "...................."};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 563200757; 
+END
+CASE(4)
+	string field_[] = {"B..B",
+ "B.B.",
+ "...B",
+ "BB.B",
+ "...."};
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = 324; 
+END
+/*
+CASE(5)
+	string field_[] = ;
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = ; 
+END
+CASE(6)
+	string field_[] = ;
+	  vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/467-U/1A.cpp
Index: SRM/467-U/1A.cpp
==================================================================
--- SRM/467-U/1A.cpp
+++ SRM/467-U/1A.cpp
@@ -0,0 +1,132 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class LateProfessor { public:
+	double getProbability(int waitTime, int walkTime, int lateTime, int bestArrival, int worstArrival) 
+	{
+		if( worstArrival - bestArrival == 0 )
+		{
+			int t = bestArrival % (waitTime+walkTime);
+			if( t<=waitTime )
+				return 0;
+			if( t+lateTime <= waitTime+walkTime )
+				return 1;
+			return 0;
+		}
+
+		if( walkTime <= lateTime )
+			return 0;
+
+		int bad = 0;
+		for(int t=0; t<=worstArrival; t+=waitTime+walkTime)
+		{
+			int tb = max(bestArrival, t+waitTime);
+			int te = min(worstArrival, t+waitTime+walkTime-lateTime);
+			if( tb < te )
+				bad += te - tb;
+		}
+		return double(bad) / (worstArrival - bestArrival);
+	}
+};
+
+// 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(_, LateProfessor().getProbability(waitTime, walkTime, lateTime, bestArrival, worstArrival));}
+int main(){
+
+CASE(0)
+	int waitTime = 20; 
+	int walkTime = 30; 
+	int lateTime = 10; 
+	int bestArrival = 0; 
+	int worstArrival = 50; 
+	double _ = 0.4; 
+END
+CASE(1)
+	int waitTime = 20; 
+	int walkTime = 30; 
+	int lateTime = 10; 
+	int bestArrival = 30; 
+	int worstArrival = 100; 
+	double _ = 0.42857142857142855; 
+END
+CASE(2)
+	int waitTime = 20; 
+	int walkTime = 40; 
+	int lateTime = 50; 
+	int bestArrival = 0; 
+	int worstArrival = 300; 
+	double _ = 0.0; 
+END
+CASE(3)
+	int waitTime = 101; 
+	int walkTime = 230; 
+	int lateTime = 10; 
+	int bestArrival = 654; 
+	int worstArrival = 17890; 
+	double _ = 0.6637270828498492; 
+END
+CASE(4)
+	int waitTime = 20; 
+	int walkTime = 30; 
+	int lateTime = 10; 
+	int bestArrival = 90; 
+	int worstArrival = 90; 
+	double _ = 1.0; 
+END
+CASE(5)
+	int waitTime = 1000; 
+	int walkTime = 600; 
+	int lateTime = 1; 
+	int bestArrival = 17000; 
+	int worstArrival = 17000; 
+	double _ = 0.0; 
+END
+CASE(6)
+	int waitTime = 1; 
+	int walkTime = 2; 
+	int lateTime = 1; 
+	int bestArrival = 2; 
+	int worstArrival = 2; 
+	double _ = -1; 
+END
+CASE(7)
+	int waitTime = 1000; 
+	int walkTime = 1000; 
+	int lateTime = 1000; 
+	int bestArrival = 0; 
+	int worstArrival = 10000000; 
+	double _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/467-U/1B.cpp
Index: SRM/467-U/1B.cpp
==================================================================
--- SRM/467-U/1B.cpp
+++ SRM/467-U/1B.cpp
@@ -0,0 +1,104 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000007;
+
+
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL POW(LL x, LL e) {
+	LL v = 1;
+	for(;e;x=MUL(x,x),e>>=1)
+		if(e&1)
+			v = MUL(v, x);
+	return v;
+}
+LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
+
+LL C(LL n, LL k) {
+	LL v = 1;
+	for(LL i=1; i<=k; ++i)
+		v = DIV(MUL(v, n-i+1), i);
+	return v;
+}
+
+class SuperSum { public:
+	int calculate(int k, int n) 
+	{
+		return C(n+k, k+1);
+	}
+};
+
+// 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(_, SuperSum().calculate(k, n));}
+int main(){
+
+CASE(0)
+	int k = 1; 
+	int n = 3; 
+	int _ = 6; 
+END
+CASE(1)
+	int k = 2; 
+	int n = 3; 
+	int _ = 10; 
+END
+CASE(2)
+	int k = 4; 
+	int n = 10; 
+	int _ = 2002; 
+END
+CASE(3)
+	int k = 10; 
+	int n = 35; 
+	int _ = 150595840; 
+END
+CASE(4)
+	int k = 1; 
+	int n = 1; 
+	int _ = 1; 
+END
+CASE(5)
+	int k = 50; 
+	int n = 1000000000; 
+	int _ = -1; 
+END
+CASE(6)
+	int k = 50; 
+	int n = 900000000; 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/467-U/1C-U.cpp
Index: SRM/467-U/1C-U.cpp
==================================================================
--- SRM/467-U/1C-U.cpp
+++ SRM/467-U/1C-U.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>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class NextHomogeneousStrings { public:
+	string getNext(int d, int n, string seed, long long k) 
+	{
+		int M = seed.size();
+
+		LL L=0, R=1; // [L,R)
+		while( R-L > 2 ) {
+			LL C = (R+L)/2;
+			string t = xth(d,n,C,M);
+			(t=="" || seed<t ? R : L) = C;
+		}
+		return seed==xth(d,n,L,M) ? xth(d,n,L+k-1,M) : xth(d,n,L+k,M);
+	}
+	string xth(int d, int n, LL x, int M)
+	{
+		return rec( string(), x, d, n, M );
+	}
+	string rec( string hist, LL x, int d, int n, int M )
+	{
+		if( M == 0 )
+			return "";
+		for(char c='a'; c<='z'; ++c)
+		{
+			string hh = hist + c;
+			// todo: normalize
+			if( x < cnt(hh,d,n,M) )
+				return c + rec(hist+c, x, d, n, M-1);
+			x -= cnt(hh,d,n,M);
+		}
+		return "";
+	}
+
+	LL cnt(string hist, int d, int n, int M)
+	{
+		if( M == 0 )
+			return 1;
+
+		// todo: memoize
+
+		LL ans = 0;
+		for(char c='a'; c<='z'; ++c)
+		{
+			char cc = c;
+			if( find(hist.begin(), hist.end(), c)==hist.end() )
+				cc = *max_element(hist.begin(),hist.end()) + 1; // todo: end then 'a'
+			string h2 = hist+cc;
+			// todo: check violation
+			// todo: drop 1st (if needed)
+			// todo: normalize
+			//ans += cnt(h2, dd, nn, M-1);
+		}
+		return ans;
+	}
+};
+
+// 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(_, NextHomogeneousStrings().getNext(d, n, seed, k));}
+int main(){
+
+CASE(0)
+	int d = 1; 
+	int n = 2; 
+	string seed = "aaa"; 
+	long long k = 3LL; 
+	string _ = "ddd"; 
+END
+CASE(1)
+	int d = 2; 
+	int n = 3; 
+	string seed = "abc"; 
+	long long k = 0LL; 
+	string _ = "aca"; 
+END
+CASE(2)
+	int d = 2; 
+	int n = 4; 
+	string seed = "ttrrzz"; 
+	long long k = 6LL; 
+	string _ = "ttsssc"; 
+END
+CASE(3)
+	int d = 6; 
+	int n = 8; 
+	string seed = "txyaaxaassaaaarghjsdohasdghususdidisisdodo"; 
+	long long k = 10000000000000000LL; 
+	string _ = "txyaaxaassaaaarghjsgaaaaaaaaadntffiniqrddy"; 
+END
+CASE(4)
+	int d = 2; 
+	int n = 5; 
+	string seed = "zzzzzaa"; 
+	long long k = 100LL; 
+	string _ = ""; 
+END
+/*
+CASE(5)
+	int d = ; 
+	int n = ; 
+	string seed = ; 
+	long long k = LL; 
+	string _ = ; 
+END
+CASE(6)
+	int d = ; 
+	int n = ; 
+	string seed = ; 
+	long long k = LL; 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/468/1A.cpp
Index: SRM/468/1A.cpp
==================================================================
--- SRM/468/1A.cpp
+++ SRM/468/1A.cpp
@@ -0,0 +1,180 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class T9 { public:
+	string message(vector <string> part, vector <string> dict, vector <string> keystr) 
+	{
+		string key;
+		for(int i=0; i<keystr.size(); ++i)
+			key += keystr[i];
+
+		sort(dict.begin(), dict.end());
+
+		string answer;
+
+		const char* p = key.c_str();
+		while( *p )
+		{
+			if( *p == '0' ) {
+				answer += ' ';
+				++p;
+			} else {
+				vector<int> alp;
+				while( '1' <= *p && *p <= '9' )
+					alp.push_back( *p++ - '1' );
+				int cnt = 0;
+				while( *p=='*' || *p=='#' )
+					cnt += (*p++=='*' ? 5 : 1);
+				answer += decode(part, dict, alp, cnt);
+			}
+		}
+		return answer;
+	}
+
+	string decode(const vector<string>& part, const vector<string>& dict, const vector<int>& alp, int cnt)
+	{
+		for(int i=0; i<dict.size(); ++i)
+			if( match(dict[i], part, alp) )
+				if( cnt-- == 0 )
+					return dict[i];
+		assert(false);
+	}
+
+	bool match(const string& d, const vector<string>& part, const vector<int>& alp)
+	{
+		if( d.size() != alp.size() )
+			return false;
+
+		for(int i=0; i<d.size(); ++i)
+			if( part[alp[i]].find(d[i]) == string::npos )
+				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 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(_, T9().message(part, dict, keystr));}
+int main(){
+
+CASE(0)
+	string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+	  vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_)); 
+	string dict_[] = {"bad"};
+	  vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_)); 
+	string keystr_[] = {"2230223"};
+	  vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_)); 
+	string _ = "bad bad"; 
+END
+CASE(1)
+	string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+	  vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_)); 
+	string dict_[] = {"the", "tie"};
+	  vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_)); 
+	string keystr_[] = {"0843#000843#000"};
+	  vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_)); 
+	string _ = " tie   tie   "; 
+END
+CASE(2)
+	string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+	  vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_)); 
+	string dict_[] = {"bad", "ace", "aad", "aae", "aaf", "acf", "acd", "the", "tie"};
+	  vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_)); 
+	string keystr_[] = {"223#02", "23*#00843#0"};
+	  vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_)); 
+	string _ = "aae bad  tie "; 
+END
+CASE(3)
+	string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+	  vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_)); 
+	string dict_[] = {"the", "tie", "bad", "ace", "aad", "aae", "aaf", "acf", "acd"};
+	  vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_)); 
+	string keystr_[] = {"84300223#02", "23#*"};
+	  vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_)); 
+	string _ = "the  aae bad"; 
+END
+CASE(4)
+	string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+	  vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_)); 
+	string dict_[] = {"bad", "ace", "aad", "aae", "tie", "aaf", "acf", "acd", "the"};
+	  vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_)); 
+	string keystr_[] = {"223#02", "23######"};
+	  vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_)); 
+	string _ = "aae bad"; 
+END
+CASE(5)
+	string part_[] = {"", "rq", "lde", "yoauz", "cbfgn", "tjkpx", "wvs", "ih", "m"};
+	  vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_)); 
+	string dict_[] = {"xktgmfmoqlmivm", 
+ "hmthr", 
+ "tpjgmnmaremiwm", 
+ "tpjcmnmyrlmhvm", 
+ "xkpnmgmzqdmhsm", 
+ "wqopvvmiig", 
+ "melbcbqeeg", 
+ "jkxnmbmardmhwm", 
+ "kpxnmcmyqlmism", 
+ "wrztvsmhhf", 
+ "srztssmiic", 
+ "pxtgmfmyrdmhwm", 
+ "vqoxswmiin", 
+ "wryksvmihb", 
+ "ptjfmbmoremhvm"};
+	  vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_)); 
+	string keystr_[] = {"00", 
+ "7246779885##00000089682000007246779885##0000724677", 
+ "9885#000089682000093355523350066659594239879###000"};
+	  vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_)); 
+	string _ = "  wqopvvmiig      hmthr     wqopvvmiig    vqoxswmiin    hmthr    melbcbqeeg  pxtgmfmyrdmhwm   "; 
+END
+/*
+CASE(6)
+	string part_[] = ;
+	  vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_)); 
+	string dict_[] = ;
+	  vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_)); 
+	string keystr_[] = ;
+	  vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_)); 
+	string _ = ; 
+END
+CASE(7)
+	string part_[] = ;
+	  vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_)); 
+	string dict_[] = ;
+	  vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_)); 
+	string keystr_[] = ;
+	  vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_)); 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/468/1B.cpp
Index: SRM/468/1B.cpp
==================================================================
--- SRM/468/1B.cpp
+++ SRM/468/1B.cpp
@@ -0,0 +1,197 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename T>
+struct DP3x
+{
+	int N1, N2, N3;
+	vector<T> data;
+	DP3x(int, int N2, int N3, const T& t = T())
+		: N1(2), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T) < (1<<26)); }
+	T& operator()(int i1, int i2, int i3)
+		{ i1&=1; return data[ ((i1*N2)+i2)*N3+i3 ]; }
+	void swap(DP3x& rhs)
+		{ data.swap(rhs.data); }
+};
+
+static const LL inf = (1LL << 60);
+
+class RoadOrFlightHard { public:
+	long long minTime(int N, int roadFirst, int roadProd, int roadAdd, int roadMod, int flightFirst, int flightProd, int flightAdd, int flightMod, int K) 
+	{
+		// input
+		vector<LL> rt(N), ft(N);
+		{
+			rt[0] = roadFirst % roadMod;
+			for(int i=1; i<N; ++i)
+				rt[i] = (LL(rt[i-1])*roadProd + roadAdd) % roadMod;
+		}
+		{
+			ft[0] = flightFirst % flightMod;
+			for(int i=1; i<N; ++i)
+				ft[i] = (LL(ft[i-1])*flightProd + flightAdd) % flightMod;
+		}
+
+		DP3x<LL> dp(N+1, K+1, 2);
+		for(int n=0; n<=N; ++n)
+		for(int k=0; k<=K; ++k)
+			if( n == 0 ) {
+				dp(n,k,0) = 0;
+				dp(n,k,1) = inf;
+			}
+			else {
+				dp(n,k,0) = min(dp(n-1,k,0), dp(n-1,k,1)) + rt[n-1];
+				if( k == 0 )
+					dp(n,k,1) = inf;
+				else
+					dp(n,k,1) = min(dp(n-1,k,1), dp(n-1,k-1,0)) + ft[n-1];
+			}
+
+		LL ans = inf;
+		for(int k=0; k<=K; ++k)
+			ans = min(ans, min(dp(N,k,0), dp(N,k,1)));
+		return ans;
+	}
+};
+
+// 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(_, RoadOrFlightHard().minTime(N, roadFirst, roadProd, roadAdd, roadMod, flightFirst, flightProd, flightAdd, flightMod, K));}
+int main(){
+
+CASE(0)
+	int N = 3; 
+	int roadFirst = 14; 
+	int roadProd = 1; 
+	int roadAdd = 2; 
+	int roadMod = 10; 
+	int flightFirst = 18; 
+	int flightProd = 1; 
+	int flightAdd = 10; 
+	int flightMod = 17; 
+	int K = 1; 
+	long long _ = 14LL; 
+END
+CASE(1)
+	int N = 3; 
+	int roadFirst = 4; 
+	int roadProd = 1; 
+	int roadAdd = 2; 
+	int roadMod = 10; 
+	int flightFirst = 1; 
+	int flightProd = 1; 
+	int flightAdd = 10; 
+	int flightMod = 17; 
+	int K = 2; 
+	long long _ = 11LL; 
+END
+CASE(2)
+	int N = 3; 
+	int roadFirst = 4; 
+	int roadProd = 1; 
+	int roadAdd = 2; 
+	int roadMod = 10; 
+	int flightFirst = 1; 
+	int flightProd = 1; 
+	int flightAdd = 6; 
+	int flightMod = 9; 
+	int K = 1; 
+	long long _ = 12LL; 
+END
+CASE(3)
+	int N = 5; 
+	int roadFirst = 85739; 
+	int roadProd = 94847; 
+	int roadAdd = 93893; 
+	int roadMod = 98392; 
+	int flightFirst = 92840; 
+	int flightProd = 93802; 
+	int flightAdd = 93830; 
+	int flightMod = 92790; 
+	int K = 3; 
+	long long _ = 122365LL; 
+END
+CASE(4)
+	int N = 1; 
+	int roadFirst = 2; 
+	int roadProd = 1; 
+	int roadAdd = 1; 
+	int roadMod = 100; 
+	int flightFirst = 1; 
+	int flightProd = 1; 
+	int flightAdd = 1; 
+	int flightMod = 2; 
+	int K = 0; 
+	long long _ = 2LL; 
+END
+CASE(4)
+	int N = 1; 
+	int roadFirst = 2; 
+	int roadProd = 1; 
+	int roadAdd = 1; 
+	int roadMod = 100; 
+	int flightFirst = 1; 
+	int flightProd = 1; 
+	int flightAdd = 1; 
+	int flightMod = 2; 
+	int K = 1; 
+	long long _ = 1LL; 
+END
+CASE(5)
+	int N = 1; 
+	int roadFirst = 0; 
+	int roadProd = 1; 
+	int roadAdd = 1; 
+	int roadMod = 100; 
+	int flightFirst = 0; 
+	int flightProd = 1; 
+	int flightAdd = 1; 
+	int flightMod = 1; 
+	int K = 1; 
+	long long _ = 0LL; 
+END
+CASE(6)
+	int N = 400000; 
+	int roadFirst = 1234; 
+	int roadProd = 56789; 
+	int roadAdd = 32323; 
+	int roadMod = 99999; 
+	int flightFirst = 9876; 
+	int flightProd = 44344; 
+	int flightAdd = 7865; 
+	int flightMod = 99999; 
+	int K = 40; 
+	long long _ = -1LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/468/1C.cpp
Index: SRM/468/1C.cpp
==================================================================
--- SRM/468/1C.cpp
+++ SRM/468/1C.cpp
@@ -0,0 +1,204 @@
+#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>
+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
+{
+	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;
+}
+
+int bitcnt(LL x)
+{
+	int c = 0;
+	for(; x; x>>=1)
+		c += x&1;
+	return c;
+}
+
+class MallSecurity { public:
+	pair<graph, int> generateBipartiteGraph(
+		const vector<int>& As, const vector<int>& Bs, const vector<int>& Cs, const vector<int>& Ds,
+		const vector<int>& Ks, int msf, int mask )
+	{
+		// construct a bipartite graph representation, in which
+		//   - "even"-floor stations go to the left
+		//   - "odd"-floor stations go to the right
+		// here floor number is normalized by rotating the msf-th floor to zero
+		#define LR(f) (((f)>msf ? (f)-msf : Ks.size()-msf+(f))%2)
+
+		// assign interger-ID for each "choosable" station, i.e.,
+		// a station which is not at msf and is not connected to a 'mask'ed station on msf
+		map<pair<int,int>,int> ID;
+		int nextID[2] = {0,0}; // use different sets of IDs for even/odd floors
+		{
+			for(int f=0; f<Ks.size(); ++f) if( f != msf )
+			for(int i=0; i<Ks[f]; ++i)
+			{
+				bool can_use = true;
+				for(int j=0; j<As.size(); ++j)
+					if( Cs[j]==f && As[j]==i && Ds[j]==msf && (mask & 1<<Bs[j])
+					 || Ds[j]==f && Bs[j]==i && Cs[j]==msf && (mask & 1<<As[j]) )
+					 can_use = false;
+				if( can_use )
+					ID[make_pair(f,i)] = nextID[LR(f)]++;
+			}
+		}
+
+		// then create the graph
+		graph G( nextID[0] + nextID[1] );
+		for(int j=0; j<As.size(); ++j)
+		{
+			pair<int,int> p(Cs[j], As[j]);
+			pair<int,int> q(Ds[j], Bs[j]);
+			if( ID.count(p) && ID.count(q) )
+			{
+				int pid = ID[p] + (LR(Cs[j]) ? nextID[0] : 0);
+				int qid = ID[q] + (LR(Ds[j]) ? nextID[0] : 0);
+				G[pid].push_back(qid);
+				G[qid].push_back(pid);
+			}
+		}
+		return make_pair(G, nextID[0]);
+	}
+
+	int maxGuards(int N, vector <string> escDescription) 
+	{
+		// parse the input
+		vector<int> As, Bs, Cs, Ds, Ks(N);
+		{
+			stringstream sin;
+			copy( escDescription.begin(), escDescription.end(), ostream_iterator<string>(sin,"") );
+
+			for(int A,B,C; sin>>A>>B>>C; )
+			{
+				{char comma; sin>>comma;}
+				--A, --B, --C; int D=(C+1)%N; // to 0-orign
+				As.push_back(A);
+				Bs.push_back(B);
+				Cs.push_back(C);
+				Ds.push_back(D);
+				Ks[C] = max(Ks[C], A+1);
+				Ks[D] = max(Ks[D], B+1);
+			}
+		}
+
+		// the most simple floor, where the number Ks[msf] of stations is the least
+		int msf = min_element(Ks.begin(), Ks.end()) - Ks.begin();
+
+		// try all possibilities at the msf-th floor
+		size_t answer = 0;
+		for(int mask=0; mask<(1<<Ks[msf]); ++mask)
+		{
+			// then the rest of the part becomes a bipartite graph
+			pair<graph, int> G = generateBipartiteGraph(As,Bs,Cs,Ds,Ks,msf,mask);
+
+			// |MaxIndenepdentSet| == |V|-|MinCover| =(for bipartite graphs)= |V|-|MaxMatch|
+			answer = max(answer, G.first.size() - biMatch<100>(G.first,G.second) + bitcnt(mask));
+		}
+		return answer;
+	}
+};
+
+// 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(_, MallSecurity().maxGuards(N, escDescription));}
+int main(){
+
+CASE(0)
+	int N = 10; 
+	string escDescription_[] = {"1 1 1,1 1 2,1 1 3,1 1 4,1 1 5,1 1 6,1 1 7,1 1 8,1 ", 
+ "1 9,1 1 10"};
+	  vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_)); 
+	int _ = 5; 
+END
+CASE(1)
+	int N = 11; 
+	string escDescription_[] = {"1 1 1,1 1 2,1 1 3,1 1 4,1 1 5,1 1 6,1 1 7,1 1 8,1 ", 
+ "1 9,1 1 10"};
+	  vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_)); 
+	int _ = 6; 
+END
+CASE(2)
+	int N = 10; 
+	string escDescription_[] = {"1 1 7,1 2 9,2 1", 
+ " 8,1 2 6,1 1 8,1 2 3,1 2 2,2 ", 
+ "2 4,1 1 1,2 1 2,3 2 3,1 1 5,2 1 1,4 ", 
+ "1 7,1 1 10,3 2 5,1 2 5,3 3 1,", 
+ "3 2 8,3 1 2,1 1 3,4 4 2,2", 
+ " 4 6,4 2 5,2 3 3,6 4 1,5 2 8,1 3 6,1 3 7,", 
+ "4 3 8,1 3 8,5 2 3,4 2 8,2 6 7,1 3 9,", 
+ "1 1 4,6 1 1,2 3 1,5 1 5,6 1 8,5 ", 
+ "2 2,3 2 10,3 3 9,1 5 2,4 1 1,1 5 10"};
+	  vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_)); 
+	int _ = 25; 
+END
+CASE(3)
+	int N = 13; 
+	string escDescription_[] = {"5 1 11,2 3 9,3 7 10,5 2 11,5 5 8,7 5 6,5 2 13,4 2 ", "8,3 7 12,7 3 9,2 7 12,8 5 4,4 6 6,7 3 11,1 5 7,4 4", " 10,3 1 9,7 2 5,4 6 12,5 5 5,6 6 5,1 5 12,6 4 3,2 ", "5 1,2 5 5,5 4 3,5 6 8,3 5 11,6 2 7,8 3 7,6 8 2,5 3", " 12,6 1 3,6 2 8,6 2 6,5 5 6,3 2 2,4 3 11,1 8 2,3 4", " 5,1 6 8,5 7 6,3 2 7,4 1 9,4 7 8,4 3 7,4 5 4,2 1 7", ",5 4 2,6 5 4,6 8 13,2 6 3,6 3 6,3 4 7,4 5 8,1 3 11", ",6 6 1,5 1 8,3 5 7,7 3 4,3 4 13,5 4 6,7 4 1,3 1 13", ",1 5 6,7 7 12,4 7 3,7 4 4,1 6 10,3 4 6,7 4 10,5 3 ", "13,1 1 4,8 7 7,2 7 13,5 6 11,1 4 9,4 4 13,2 6 8,7 ", "5 10,1 2 7,1 7 8,8 8 3,2 4 1,7 6 12,2 5 12,2 2 3,1", " 2 2,1 4 7,4 1 11,6 2 4,4 6 4,6 3 8,5 6 7,4 2 4,2 ", "7 6,7 2 1,3 4 4,4 4 3,1 2 3,1 1 10,2 3 8,6 6 11,5 ", "5 13,7 7 4,5 3 11,6 6 8,6 4 12,6 1 7,3 8 9,2 1 1,5", " 5 10,8 1 7,7 2 6,1 7 4,5 1 12,2 5 7,6 7 7,3 6 3,8", " 1 1,3 8 2,3 6 6,3 6 4,6 3 2,4 5 5,2 6 4,3 2 6,7 6", " 5,1 8 6,5 5 4,2 7 10", ",1 7 9,1 1 3,4 4 4,4 3 5,4 2 10,5 7 3,5 3 5,3 6 9,", "2 5 11,3 2 3,4 1 1,2 5 10,5 1 4,6 5 5,1 7 5,7 5 5,", "8 5 12,7 8 13,1 2 10,3 7 6,4 7 13,4 3 13,6 4 11,6 ", "7 4,2 6 7,2 7 3,7 8 8,6 1 12,6 7 8,3 1 10,8 6 1,1 ", "7 10,1 3 9,7 7 11,5 6 4,7 7 1,4 2 1,8 2 3,7 8 2,1 ", "4 13,2 3 13,3 2 11,6 7 12,4 8 2,5 6 1,6 3 12,3 5 3", ",1 5 10,1 4 5,4 6 10,1 6 6,6 3 5,4 3 12,6 2 11,3 8", " 3,7 5 3,6 7 10,3 2 13,7 4 3,1 7 12,2 7 4,4 7 1,8 ", "5 10,6 6 4,6 7 2,4 7 7,1 3 1,1 4 12,6 5 7,5 1 13,5", " 8 13,2 1 10,5 2 7,8 3 10,5 1 5,1 4 6,1 1 6,5 2 2,", "2 3 11,3 2 10,2 1 13,8 2 9,3 5 2,1 7 2,3 3 5,5 2 5", ",8 4 12,7 3 2,2 5 3,3 7 1,6 7 6,8 5 9,4 5 7,2 8 3,", "2 4 6,7 1 10,5 8 11,4 7 6,7 6 4,3 6 11,5 3 1,7 7 8", ",1 6 9,7 6 7,1 2 1,2 2 12,3 5 9,4 4 1,6 4 5,5 8 3,", "2 1 2,6 6 10,1 5 9,8 1 3,5 1 10,4 7 2,8 4 9,2 2 7,", "2 3 4,6 1 4,1 4 11,7 1 1,3 7 7,5 4 13,1 6 1,4 7 12"};
+	  vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_)); 
+	int _ = 50; 
+END
+/*
+CASE(4)
+	int N = ; 
+	string escDescription_[] = ;
+	  vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/469/1A.cpp
Index: SRM/469/1A.cpp
==================================================================
--- SRM/469/1A.cpp
+++ SRM/469/1A.cpp
@@ -0,0 +1,173 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheMoviesLevelOneDivOne { public:
+	long long find(int n, int m, vector <int> row, vector <int> seat) 
+	{
+		LL all = LL(n)*LL(m-1);
+
+		set< pair<int,int> > dead;
+		for(int i=0; i<row.size(); ++i)
+		{
+			int y = row[i]-1;
+			int x = seat[i]-1;
+			if(x<m-1)dead.insert( make_pair(y,x) );
+			if(x>0) dead.insert( make_pair(y,x-1) );
+		}
+		return all - dead.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 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(_, TheMoviesLevelOneDivOne().find(n, m, row, seat));}
+int main(){
+
+CASE(0)
+	int n = 2; 
+	int m = 3; 
+	int row_[] = {1, 2};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	int seat_[] = {2, 3};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 1LL; 
+END
+CASE(1)
+	int n = 2; 
+	int m = 3; 
+	int row_[] = {1, 1, 1, 2, 2, 2};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	int seat_[] = {1, 2, 3, 1, 2, 3};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 0LL; 
+END
+CASE(2)
+	int n = 4; 
+	int m = 7; 
+	int row_[] = {1};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	int seat_[] = {1};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 23LL; 
+END
+CASE(3)
+	int n = 10; 
+	int m = 8; 
+	int row_[] = {1, 9, 6, 10, 6, 7, 9, 3, 9, 2};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	int seat_[] = {7, 7, 3, 3, 7, 1, 5, 1, 6, 2};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 54LL; 
+END
+CASE(4)
+	int n = 1; 
+	int m = 1; 
+	int row_[] = {1};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {1};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 0LL; 
+END
+CASE(5)
+	int n = 1000000000; 
+	int m = 1; 
+	int row_[] = {1};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {1};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 0LL; 
+END
+CASE(6)
+	int n = 1000000000; 
+	int m = 100000001; 
+	int row_[] = {1};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {1};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 100000000000000000LL - 1; 
+END
+CASE(7)
+	int n = 1000000000; 
+	int m = 100000001; 
+	int row_[] = {2};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {1};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 100000000000000000LL - 1; 
+END
+CASE(8)
+	int n = 1000000000; 
+	int m = 100000001; 
+	int row_[] = {1};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {2};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 100000000000000000LL - 2; 
+END
+CASE(9)
+	int n = 1000000000; 
+	int m = 100000001; 
+	int row_[] = {1};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {100000001};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 100000000000000000LL - 1; 
+END
+CASE(10)
+	int n = 1000000000; 
+	int m = 100000001; 
+	int row_[] = {1};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {100000000};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 100000000000000000LL - 2; 
+END
+CASE(11)
+	int n = 3; 
+	int m = 3; 
+	int row_[] = {1,2,3};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {2,2,2};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 0LL;
+END
+CASE(12)
+	int n = 3; 
+	int m = 3; 
+	int row_[] = {1,2,3,2,2};
+	  vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_)); 
+	  int seat_[] = {1,2,3,1,3};
+	  vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_)); 
+	long long _ = 2LL;
+END
+}
+// END CUT HERE

ADDED   SRM/469/1B.cpp
Index: SRM/469/1B.cpp
==================================================================
--- SRM/469/1B.cpp
+++ SRM/469/1B.cpp
@@ -0,0 +1,151 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheMoviesLevelTwoDivOne { public:
+	vector <int> find(vector <int> length, vector <int> scary) 
+	{
+		int N = length.size();
+
+		vector<int> lwb(N), inc(N);
+		for(int i=0; i<N; ++i)
+			if( scary[i]+47 < length[i] )
+				lwb[i] = length[i] - 47;
+			else
+				lwb[i] = scary[i];
+		for(int i=0; i<N; ++i)
+			inc[i] = 47 - length[i];
+
+		memo = vector<bool>(1<<N);
+		memo[(1<<N)-1] = true;
+		vector<int> temp;
+		rec(0, 74, N, lwb, inc, temp);
+
+		set<int> not_used;
+		for(int i=0; i<N; ++i) not_used.insert(i);
+		for(int i=0; i<result.size(); ++i)
+			not_used.erase(result[i]);
+		result.insert(result.end(), not_used.begin(), not_used.end());
+
+		return result;
+	}
+
+	vector<int>  result;
+	vector<bool> memo;
+	void rec(int mask, int cur, int N, vector<int>& lwb, vector<int>& inc, vector<int>& temp)
+	{
+		if( result.size() < temp.size() )
+			result = temp;
+		if( memo[mask] )
+			return;
+		memo[mask] = true;
+
+		for(int i=0; i<N; ++i)
+			if( !(mask & (1<<i)) && cur>=lwb[i] )
+			{
+				temp.push_back(i);
+				rec(mask|(1<<i), cur+inc[i], N, lwb, inc, temp);
+				temp.pop_back();
+			}
+	}
+};
+
+// 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 <int>& Expected, const vector <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(_, TheMoviesLevelTwoDivOne().find(length, scary));}
+int main(){
+
+CASE(0)
+	int length_[] = {100, 50};
+	  vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_)); 
+	int scary_[] = {1, 1};
+	  vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_)); 
+	int __[] = {0, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int length_[] = {100, 50};
+	  vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_)); 
+	int scary_[] = {1, 49};
+	  vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_)); 
+	int __[] = {1, 0 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int length_[] = {100, 100, 100, 100};
+	  vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_)); 
+	int scary_[] = {77, 76, 75, 74};
+	  vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_)); 
+	int __[] = {3, 0, 1, 2 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	int length_[] = {100};
+	  vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_)); 
+	int scary_[] = {99};
+	  vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_)); 
+	int __[] = {0 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	int length_[] = {2};
+	  vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_)); 
+	int scary_[] = {1};
+	  vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_)); 
+	  int __[] = {0};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	int length_[] = {3};
+	  vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_)); 
+	int scary_[] = {1};
+	  vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_)); 
+	  int __[] = {0};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+  int length_[] = {5,6,7,8,9,10,11,10,9,8,7,6,5,6,7,8,9,10,11,10};
+	  vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_)); 
+  int scary_[] = {3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3};
+	  vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_)); 
+  int __[] = {-1};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(7)
+  int length_[] = {185, 53, 28, 92, 70};
+	  vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_)); 
+  int scary_[] = {96, 17, 4, 6, 34};
+	  vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_)); 
+  int __[] = {1,2,3,4,0};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+}
+// END CUT HERE

ADDED   SRM/469/1C.cpp
Index: SRM/469/1C.cpp
==================================================================
--- SRM/469/1C.cpp
+++ SRM/469/1C.cpp
@@ -0,0 +1,121 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheMoviesLevelThreeDivOne { public:
+	long long find(vector <int> timeJ, vector <int> timeB) 
+	{
+		int N = timeJ.size();
+		return (1LL<<N) - quitJ(N, timeJ, timeB) - quitJ(N, timeB, timeJ);
+	}
+
+	LL quitJ(int N, vector<int>& J, vector<int>& B) // # of patterns in which J quits
+	{
+		typedef pair<int,int>            state;
+		typedef map<state, LL>::iterator iter;
+
+		map<pair<int,int>, LL> M;
+		M[state(0,-0x3fffffff)] = 1;
+
+		for(int i=0; i<N; ++i)
+		{
+			map<state, LL> M2;
+			for(iter it=M.begin(); it!=M.end(); ++it)
+			{
+				int sum   = it->first.first;
+				int bound = it->first.second;
+				LL  n     = it->second;
+
+				M2[state(sum+J[i],      bound-J[i])]           += n; // i goes to J
+				M2[state(sum+J[i]-B[i], max(bound, B[i]-sum))] += n; // i goes to B
+			}
+			M2.swap(M);
+		}
+
+		LL cnt = 0;
+		for(iter it=M.begin(); it!=M.end(); ++it)
+			if( 0 < it->first.second )
+				cnt += it->second;
+		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 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(_, TheMoviesLevelThreeDivOne().find(timeJ, timeB));}
+int main(){
+
+CASE(0)
+	int timeJ_[] = {4, 4};
+	  vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_)); 
+	int timeB_[] = {4, 4};
+	  vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_)); 
+	long long _ = 2LL; 
+END
+CASE(1)
+	int timeJ_[] = {1, 4};
+	  vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_)); 
+	int timeB_[] = {4, 2};
+	  vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_)); 
+	long long _ = 1LL; 
+END
+CASE(2)
+	int timeJ_[] = {10, 10, 10, 10};
+	  vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_)); 
+	int timeB_[] = {1, 1, 1, 10};
+	  vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_)); 
+	long long _ = 3LL; 
+END
+CASE(3)
+	int timeJ_[] = {1, 2, 3, 4, 5, 6, 7};
+	  vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_)); 
+	int timeB_[] = {7, 6, 5, 4, 3, 2, 1};
+	  vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_)); 
+	long long _ = 98LL; 
+END
+CASE(4)
+	int timeJ_[] = {8,19,17,5,9,15,10,14,13,11,4,1,18,11,10,8,13,8,20,4,5,3,20,5,16,8,17,6,16,14,1,17,10,17,20,14,13,17,17,19,20,2,17,6,12,4,2};
+	  vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_)); 
+	int timeB_[] = {9,19,6,12,2,13,19,11,9,12,17,6,7,6,1,17,15,8,7,6,10,6,2,20,9,8,3,7,7,14,17,8,2,5,5,12,11,1,2,5,20,16,18,15,16,14,12};
+	  vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_)); 
+	long long _ = -1LL; 
+END
+/*
+CASE(5)
+	int timeJ_[] = ;
+	  vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_)); 
+	int timeB_[] = ;
+	  vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_)); 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/470-U/1A.cpp
Index: SRM/470-U/1A.cpp
==================================================================
--- SRM/470-U/1A.cpp
+++ SRM/470-U/1A.cpp
@@ -0,0 +1,150 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class DoorsGame { public:
+	int determineOutcome(string doors, int trophy) 
+	{
+		vector<int> score(2<<16);
+		vector<bool> computed(2<<16);
+		return rec(score, computed, 0, doors, trophy);
+	}
+	int rec(vector<int>& score, vector<bool>& computed, int mask, string& doors, int trophy)
+	{
+		if( computed[mask] )
+			return score[mask];
+		computed[mask] = true;
+
+		bool Lwin = true;
+		for(int i=0; i<trophy; ++i)
+			if( !(mask & (1<<(doors[i]-'A'))) )
+				Lwin = false;
+		bool Rwin = true;
+		for(int i=doors.size()-1; i>=trophy; --i)
+			if( !(mask & (1<<(doors[i]-'A'))) )
+				Rwin = false;
+
+		if( Lwin && Rwin )
+			return score[mask] = 0;
+		if( Lwin )
+			return score[mask] = +bitcnt(mask);
+		if( Rwin )
+			return score[mask] = -bitcnt(mask);
+
+		vector<int> ss;
+		for(int c=0; c<16; ++c)
+			if( !(mask & (1<<c)) )
+				ss.push_back( rec(score,computed,mask|(1<<c),doors,trophy) );
+
+		bool L = !(bitcnt(mask)&1);
+		if(!L)
+			for(int i=0; i<ss.size(); ++i)
+				ss[i] = -ss[i];
+
+		int Ms = *max_element(ss.begin(),ss.end());
+		if( Ms == 0 )
+			return score[mask] = 0;
+		if( Ms > 0 ) {
+			int posMin = 99999;
+			for(int i=0; i<ss.size(); ++i)
+				if(ss[i]>0)
+					posMin = min(posMin,ss[i]);
+			return score[mask] = (L ? posMin : -posMin);
+		}
+		int me = *min_element(ss.begin(), ss.end());
+		return score[mask] = (L ? me : -me);
+	}
+	int bitcnt(int mask)
+	{
+		int cnt = 0;
+		for(; mask; mask>>=1)
+			cnt += mask&1;
+		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(_, DoorsGame().determineOutcome(doors, trophy));}
+int main(){
+
+CASE(0)
+	string doors = "ABCD"; 
+	int trophy = 2; 
+	int _ = 3; 
+END
+CASE(1)
+	string doors = "ABCC"; 
+	int trophy = 2; 
+	int _ = -2; 
+END
+CASE(2)
+	string doors = "ABABAB"; 
+	int trophy = 3; 
+	int _ = 0; 
+END
+CASE(3)
+	string doors = "ABAPDCAA"; 
+	int trophy = 5; 
+	int _ = -4; 
+END
+CASE(4)
+	string doors = "MOCFDCE"; 
+	int trophy = 3; 
+	int _ = 5; 
+END
+CASE(5)
+	string doors = "ABCCDE"; 
+	int trophy = 3; 
+	int _ = 0; 
+END
+CASE(6)
+	string doors = "ABCCD"; 
+	int trophy = 3; 
+	int _ = 0; 
+END
+CASE(7)
+	string doors = "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPCC"; 
+	int trophy = 25; 
+	int _ = 0; 
+END
+CASE(8)
+	string doors = "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPCC"; 
+	int trophy = 7; 
+	int _ = 0; 
+END
+CASE(8)
+	string doors = "AAAAAAAAAAAAAAAAABCDEFGHIJKLMNOPPPPPPPPPPPPPPPPPP"; 
+	int trophy = 25; 
+	int _ = 0; 
+END
+}
+// END CUT HERE

ADDED   SRM/470-U/1B.cpp
Index: SRM/470-U/1B.cpp
==================================================================
--- SRM/470-U/1B.cpp
+++ SRM/470-U/1B.cpp
@@ -0,0 +1,157 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class DrawingLines { public:
+	double countLineCrossings(int n, vector <int> startDot, vector <int> endDot) 
+	{
+		int m = n-startDot.size();
+		double news = c(m);
+		double ooolds = 0.0;
+		for(int i=0; i<startDot.size(); ++i)
+			for(int j=i+1; j<startDot.size(); ++j)
+				if( startDot[i]<startDot[j] && endDot[i]>endDot[j]
+				||  startDot[i]>startDot[j] && endDot[i]<endDot[j] ) 
+					ooolds += 1;
+		double olds = 0.0;
+
+		vector<int> sTaken, eTaken;
+		for(int i=0; i<startDot.size(); ++i) {
+			sTaken.push_back(startDot[i]);
+			eTaken.push_back(endDot[i]);
+		}
+		sort(sTaken.begin(), sTaken.end());
+		sort(eTaken.begin(), eTaken.end());
+
+		if( n > startDot.size() )
+		for(int i=0; i<startDot.size(); ++i) {
+			vector<int>::iterator si = lower_bound(sTaken.begin(), sTaken.end(), startDot[i]);
+			vector<int>::iterator ei = lower_bound(eTaken.begin(), eTaken.end(),   endDot[i]);
+			olds += f( (startDot[i]-1) - (si-sTaken.begin()),
+			           (n-startDot[i]) - (sTaken.end()-si-1),
+					   (endDot[i]-1) - (ei-eTaken.begin()),
+					   (n-endDot[i]) - (eTaken.end()-ei-1)
+					   );
+		}
+		return news + ooolds + olds;
+	}
+
+	double c(int m)
+	{
+		return m*(m-1) / 4.0;
+	}
+
+	double f(double a, double b, double c, double d)
+	{
+		return a * d/(c+d) + b*c/(c+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(_, DrawingLines().countLineCrossings(n, startDot, endDot));}
+int main(){
+
+CASE(0)
+	int n = 3; 
+	int startDot_[] = {2};
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	int endDot_[] = {3};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = 1.5; 
+END
+CASE(1)
+	int n = 5; 
+	int startDot_[] = {1,4};
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	int endDot_[] = {3,1};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = 5.5; 
+END
+CASE(2)
+	int n = 4; 
+	int startDot_[] = {4,1};
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	int endDot_[] = {4,1};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = 0.5; 
+END
+CASE(3)
+	int n = 8; 
+	int startDot_[] = {1,4,3,6,7};
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	int endDot_[] = {1,3,2,4,5};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = 7.5; 
+END
+CASE(4)
+	int n = 2; 
+	int startDot_[] = {1,2} ;
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	int endDot_[] = {1,2};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = 0; 
+END
+CASE(5)
+	int n = 2; 
+	int startDot_[] = {1,2} ;
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	int endDot_[] = {2,1};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = 1; 
+END
+CASE(6)
+	int n = 3; 
+	int startDot_[] = {1} ;
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	int endDot_[] = {1};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = 0.5; 
+END
+CASE(7)
+	int n = 3; 
+	int startDot_[] = {1} ;
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	int endDot_[] = {3};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = 2.5; 
+END
+CASE(8)
+	int n = 10000; 
+	int startDot_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+	  vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_)); 
+	  int endDot_[] = {20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
+	  vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_)); 
+	double _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/471-U/1A.cpp
Index: SRM/471-U/1A.cpp
==================================================================
--- SRM/471-U/1A.cpp
+++ SRM/471-U/1A.cpp
@@ -0,0 +1,136 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PrimeSequences { public:
+	int getLargestGenerator(int N, int D) 
+	{
+		int result = -1;
+
+		vector<int> p(N+1, 1);
+		p[0] = p[1] = 0;
+		for(int q=2; q<=N; ++q)
+			if( p[q] ) {
+				if(q<=N/q)
+					for(int qq=q*q; qq<=N; qq+=q)
+						p[qq] = 0;
+				p[q] = p[q/2]+1;
+				if( p[q] >= D )
+					result = q;
+			}
+
+		return result;
+	}
+};
+
+// 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(_, PrimeSequences().getLargestGenerator(N, D));}
+int main(){
+
+CASE(0)
+	int N = 10; 
+	int D = 2; 
+	int _ = 7; 
+END
+CASE(1)
+	int N = 42; 
+	int D = 3; 
+	int _ = 23; 
+END
+CASE(2)
+	int N = 666; 
+	int D = 7; 
+	int _ = -1; 
+END
+CASE(3)
+	int N = 1337; 
+	int D = 5; 
+	int _ = 47; 
+END
+CASE(4)
+	int N = 100000; 
+	int D = 5; 
+	int _ = 2879; 
+END
+CASE(5)
+	int N = 40000; 
+	int D = 1; 
+	int _ = 39989; 
+END
+CASE(6)
+	int N = 10000000; 
+	int D = 10; 
+	int _ = -1; 
+END
+CASE(7)
+	int N = 2; 
+	int D = 1; 
+	int _ = 2; 
+END
+CASE(7)
+	int N = 3; 
+	int D = 1; 
+	int _ = 3; 
+END
+CASE(7)
+	int N = 4; 
+	int D = 1; 
+	int _ = 3; 
+END
+CASE(7)
+	int N = 5; 
+	int D = 1; 
+	int _ = 5; 
+END
+CASE(7)
+	int N = 6; 
+	int D = 1; 
+	int _ = 5; 
+END
+CASE(7)
+	int N = 6; 
+	int D = 2; 
+	int _ = 5; 
+END
+CASE(7)
+	int N = 6; 
+	int D = 3; 
+	int _ = -1; 
+END
+CASE(7)
+	int N = 7; 
+	int D = 2; 
+	int _ = 7; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/471-U/1B.cpp
Index: SRM/471-U/1B.cpp
==================================================================
--- SRM/471-U/1B.cpp
+++ SRM/471-U/1B.cpp
@@ -0,0 +1,158 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ThirteenHard { public:
+	int calcTime(vector <string> city) 
+	{
+		typedef int vert;
+		typedef int cost;
+		typedef pair<cost,vert> cedge;
+		priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+		Q.push( cedge(0,1*32+0) );
+
+		set<int> visited;
+		while( !Q.empty() )
+		{
+			cedge s = Q.top();
+			Q.pop();
+			if( visited.count(s.second) )
+				continue;
+			visited.insert(s.second);
+
+			int v = s.second%32;
+			int mask = s.second/32;
+			int c = s.first;
+			if( v == (int)city.size()-1 )
+				return c;
+
+			for(int i=0; i<city.size(); ++i)
+			{
+				char dd = city[v][i];
+				int d = ('a'<=dd && dd<='z' ? dd-'a'+27 : dd-'A'+1);
+				if( dd!='#' && d%13>0 )
+				{
+					int mask2 = mask << (d%13);
+					if( mask2 & (1<<13) )
+						continue;
+					mask2 = (mask2 & ((1<<13) - 1)) | (mask2 >> 13) | (1<<d%13);
+					int s2 = mask2*32 + i;
+					if( !visited.count(s2) )
+						Q.push( cedge(c+d, s2) );
+				}
+			}
+		}
+		return -1;
+	}
+};
+
+// 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(_, ThirteenHard().calcTime(city));}
+int main(){
+
+CASE(0)
+	string city_[] = { "#AB##",
+  "###A#",
+  "###C#",
+  "####K",
+  "#####" };
+	  vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_)); 
+	int _ = 16; 
+END
+CASE(1)
+	string city_[] = { "#Z",
+  "Z#" };
+	  vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_)); 
+	int _ = -1; 
+END
+CASE(2)
+	string city_[] = { "Good#####",
+  "#Luck####",
+  "##and####",
+  "##Have###",
+  "####Fun##",
+  "#####in##",
+  "#####the#",
+  "CHALLENGE",
+  "##PHASE##" };
+	  vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_)); 
+	int _ = 137; 
+END
+CASE(3)
+	string city_[] = { "###No#####",
+  "####Zaphod",
+  "#####Just#",
+  "######very",
+  "####very##",
+  "improbable",
+  "##########",
+  "##########",
+  "##########",
+  "##########" };
+	  vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_)); 
+	int _ = 103; 
+END
+CASE(4)
+	string city_[] = { "#B#C##T#M",
+  "##K######",
+  "########A",
+  "####R####",
+  "#####U###",
+  "########C",
+  "#######H#",
+  "########S",
+  "#########" };
+	  vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_)); 
+	int _ = 47; 
+END
+CASE(5)
+string city_[] = {"#a","##"};
+	  vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_)); 
+	int _ = 27; 
+END
+CASE(5)
+string city_[] = {"#z","##"};
+	  vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_)); 
+	int _ = -1; 
+END
+CASE(6)
+string city_[] = {"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy",
+"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy",
+"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy",
+"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy",
+"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy"};
+	  vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_)); 
+	int _ = -999; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/472-U/1A.cpp
Index: SRM/472-U/1A.cpp
==================================================================
--- SRM/472-U/1A.cpp
+++ SRM/472-U/1A.cpp
@@ -0,0 +1,75 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PotatoGame { public:
+	string theWinner(int n) 
+	{
+		return n%5==0 || n%5==2 ? "Hanako" : "Taro";
+	}
+};
+
+// 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(_, PotatoGame().theWinner(n));}
+int main(){
+
+CASE(0)
+	int n = 1; 
+	string _ = "Taro"; 
+END
+CASE(1)
+	int n = 2; 
+	string _ = "Hanako"; 
+END
+CASE(2)
+	int n = 3; 
+	string _ = "Taro"; 
+END
+CASE(3)
+	int n = 4; 
+	string _ = "Taro"; 
+END
+CASE(4)
+	int n = 5; 
+	string _ = "??"; 
+END
+CASE(6)
+	int n = 1000000000; 
+	string _ = "??"; 
+END
+CASE(7)
+	int n = 8; 
+	string _ = "Taro"; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/472-U/1B.cpp
Index: SRM/472-U/1B.cpp
==================================================================
--- SRM/472-U/1B.cpp
+++ SRM/472-U/1B.cpp
@@ -0,0 +1,212 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename T>
+struct DP4
+{
+	int N1, N2, N3, N4;
+	vector<T> data;
+	DP4(int N1, int N2, int N3, int N4, const T& t = T())
+		: N1(N1), N2(N2), N3(N3), N4(N4), data(N1*N2*N3*N4, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2, int i3, int i4)
+		{ return data[ (((i1*N2)+i2)*N3+i3)*N4+i4 ]; }
+	void swap(DP4& rhs)
+		{ data.swap(rhs.data); }
+};
+
+static const LL MODVAL = 1000000007;
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL POW(LL x, LL e) {
+	LL v = 1;
+	for(;e;x=MUL(x,x),e>>=1)
+		if(e&1)
+			v = MUL(v, x);
+	return v;
+}
+LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
+LL C(LL n, LL k) {
+	k = min(n, n-k);
+	LL v = 1;
+	for(LL i=1; i<=k; ++i)
+		v = DIV(MUL(v, n-i+1), i);
+	return v;
+}
+LL FACT(LL n) {
+	return n<=1 ? 1 : MUL(n, FACT(n-1));
+}
+
+class TwoSidedCards { public:
+	int theCount(vector <int> taro, vector <int> hanako) 
+	{
+		int N = taro.size();
+		vector<LL> loops;
+		{
+			vector<int> next(N);
+			for(int i=0; i<N; ++i)
+				next[taro[i]-1] = hanako[i]-1;
+
+			vector<bool> used(N);
+			for(int s=0; s<N; ++s)
+				if( !used[s] ) {
+					used[s] = true;
+
+					LL looplen = 1;
+					for(int v=next[s]; v!=s; v=next[v]) {
+						used[v] = true;
+						++looplen;
+					}
+					loops.push_back(looplen);
+				}
+		}
+
+		return (int)solve(N, loops);
+	}
+
+	LL solve(int N, const vector<LL>& loops)
+	{
+		LL result = 1;
+
+		LL rest = N;
+		for(int i=0; i<loops.size(); ++i) {
+			result = MUL(result, MUL(singleloop(loops[i]), C(rest,loops[i])));
+			rest -= loops[i];
+		}
+		return result;
+	}
+
+	map< pair< pair<int,int>,pair<int,int> >, LL > memo;
+	LL num_downtrig(int first, int last, int i, int n, int c)
+	{
+		if( i == n )
+			return (last==1 && first==0 ? 1 : 0)==c ? 1 : 0;
+		if( c < 0 )
+			return 0;
+		pair< pair<int,int>,pair<int,int> > key( make_pair(first,last), make_pair(i,c) );
+		if( memo.count(key) )
+			return memo[key];
+		return memo[key] = ADD(
+			num_downtrig(first, 0, i+1, n, c-(last==1)),
+			num_downtrig(first, 1, i+1, n, c));
+	}
+	LL singleloop(int n)
+	{
+		if( n == 1 )
+			return 1;
+		LL fn = FACT(n);
+		LL result = 0;
+		memo.clear();
+		for(int c=0; c<n; ++c)
+		{
+			LL z;
+			if( c == 0 )
+				z = num_downtrig(0, 0, 1, n, c);
+			else
+				z = ADD(
+					num_downtrig(0, 0, 1, n, c),
+					num_downtrig(1, 1, 1, n, c));
+			result = ADD(result, DIV(MUL(z,fn), POW(2,c)));
+		}
+		return result;
+	}
+};
+
+// 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(_, TwoSidedCards().theCount(taro, hanako));}
+int main(){
+
+CASE(0)
+	int taro_[] = {1, 2, 3};
+	  vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_)); 
+	int hanako_[] = {1, 3, 2};
+	  vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_)); 
+	int _ = 12; 
+END
+CASE(1)
+	int taro_[] = {1, 2, 3};
+	  vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_)); 
+	int hanako_[] = {1, 2, 3};
+	  vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_)); 
+	int _ = 6; 
+END
+CASE(2)
+	int taro_[] = {1, 2};
+	  vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_)); 
+	int hanako_[] = {2, 1};
+	  vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_)); 
+	int _ = 4; 
+END
+CASE(3)
+	int taro_[] = {5, 8, 1, 2, 3, 4, 6, 7};
+	  vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_)); 
+	int hanako_[] = {1, 2, 3, 4, 5, 6, 7, 8};
+	  vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_)); 
+	int _ = 2177280; 
+END
+CASE(4)
+	int taro_[] = {41, 22, 17, 36, 26, 15, 10, 23, 33, 48, 49, 9, 34, 6, 21, 2, 46, 16, 25, 3, 24, 13, 40, 37, 35,
+50, 44, 42, 31, 12, 29, 7, 43, 18, 30, 19, 45, 32, 39, 14, 8, 27, 1, 5, 38, 11, 4, 20, 47, 28};
+	  vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_)); 
+	int hanako_[] = {19, 6, 23, 35, 17, 7, 50, 2, 33, 36, 12, 31, 46, 21, 30, 13, 47, 22, 44, 4, 25, 24, 3, 15, 20,
+48, 10, 28, 26, 18, 5, 45, 49, 16, 40, 42, 43, 14, 1, 37, 29, 8, 41, 38, 9, 11, 34, 32, 39, 27};
+	  vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_)); 
+	int _ = 529165844; 
+END
+CASE(5)
+	int taro_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
+	31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
+	  vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_)); 
+	int hanako_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
+	31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
+	  vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_)); 
+	int _ = -1; 
+END
+CASE(6)
+int taro_[] = {1};
+	  vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_)); 
+	  int hanako_[] = {1};
+	  vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_)); 
+	int _ = 1; 
+END
+CASE(7)
+	int taro_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
+	31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
+	  vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_)); 
+	int hanako_[] = {50,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
+	31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49};
+	  vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_)); 
+	int _ = 1; 
+END
+}
+// END CUT HERE

ADDED   SRM/473-U/1A.cpp
Index: SRM/473-U/1A.cpp
==================================================================
--- SRM/473-U/1A.cpp
+++ SRM/473-U/1A.cpp
@@ -0,0 +1,98 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class SequenceOfCommands { public:
+	string whatHappens(vector <string> commands) 
+	{
+		string cmd = accumulate(commands.begin(), commands.end(), string (""));
+		cmd = cmd+cmd+cmd+cmd;
+
+		int dx=1, dy=0;
+		int px=0, py=0;
+		for(int i=0; i<cmd.size(); ++i)
+			if(cmd[i]=='S')
+				{px+=dx, py+=dy;}
+			else if(cmd[i]=='L')
+				{int t=dx; dx=-dy; dy=t;}
+			else if(cmd[i]=='R')
+				{int t=dx; dx=dy; dy=-t;}
+		return (px==0 && py==0 ? "bounded" : "unbounded");
+	}
+};
+
+// 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(_, SequenceOfCommands().whatHappens(commands));}
+int main(){
+
+CASE(0)
+	string commands_[] = {"L"};
+	  vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_)); 
+	string _ = "bounded"; 
+END
+CASE(1)
+	string commands_[] = {"SRSL"};
+	  vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_)); 
+	string _ = "unbounded"; 
+END
+CASE(2)
+	string commands_[] = {"SSSS","R"};
+	  vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_)); 
+	string _ = "bounded"; 
+END
+CASE(3)
+	string commands_[] = {"SRSL","LLSSSSSSL","SSSSSS","L"};
+	  vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_)); 
+	string _ = "unbounded"; 
+END
+CASE(4)
+	string commands_[] = {"SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL"};
+	  vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_)); 
+	string _ = "bounded"; 
+END
+CASE(5)
+	string commands_[] = {"R"};
+	  vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_)); 
+	string _ = "bounded"; 
+END
+CASE(6)
+	string commands_[] = {"S"};
+	  vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_)); 
+	string _ = "unbounded"; 
+END
+CASE(7)
+	string commands_[] = {"SRSLSRSL", "RR"};
+	  vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_)); 
+	string _ = "bounded"; 
+END
+}
+// END CUT HERE

ADDED   SRM/473-U/1B.cpp
Index: SRM/473-U/1B.cpp
==================================================================
--- SRM/473-U/1B.cpp
+++ SRM/473-U/1B.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 <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class RightTriangle { public:
+	long long triangleCount(int places, int points, int a, int b, int c) 
+	{
+		vector<bool> red(places);
+		set<int> vacant;
+		for(int i=0; i<places; ++i)
+			vacant.insert(i);
+
+		for(LL n=0; n<points; ++n) {
+			LL p = (a*n*n + b*n + c) % places;
+			if( red[p] ) {
+				set<int>::iterator it = vacant.lower_bound(p);
+				if( it != vacant.end() )
+					p = *it;
+				else {
+					it = vacant.lower_bound(0);
+					p = *it;
+				}
+			}
+			red[p] = true;
+			vacant.erase(p);
+		}
+
+		if( places%2 == 1 )
+			return 0;
+
+		LL result = 0;
+		for(int a=0,b=a+places/2; b<places; ++a, ++b)
+			if( red[a] && red[b] )
+				result += points-2;
+		return result;
+	}
+};
+
+// 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(_, RightTriangle().triangleCount(places, points, a, b, c));}
+int main(){
+
+CASE(0)
+	int places = 9; 
+	int points = 3; 
+	int a = 0; 
+	int b = 3; 
+	int c = 0; 
+	long long _ = 0LL; 
+END
+CASE(1)
+	int places = 40; 
+	int points = 3; 
+	int a = 5; 
+	int b = 0; 
+	int c = 0; 
+	long long _ = 1LL; 
+END
+CASE(2)
+	int places = 4; 
+	int points = 4; 
+	int a = 16; 
+	int b = 24; 
+	int c = 17; 
+	long long _ = 4LL; 
+END
+CASE(3)
+	int places = 1000000; 
+	int points = 47000; 
+	int a = 0; 
+	int b = 2; 
+	int c = 5; 
+	long long _ = 0LL; 
+END
+CASE(4)
+	int places = 200000; 
+	int points = 700; 
+	int a = 123456; 
+	int b = 789012; 
+	int c = 345678; 
+	long long _ = 6980LL; 
+END
+CASE(5)
+	int places = 1000000; 
+	int points = 0; 
+	int a = 0; 
+	int b = 0; 
+	int c = 0; 
+	long long _ = 0LL; 
+END
+CASE(6)
+	int places = 1000000; 
+	int points = 100000; 
+	int a = 0; 
+	int b = 0; 
+	int c = 0; 
+	long long _ = 0LL; 
+END
+CASE(7)
+	int places = 1; 
+	int points = 0; 
+	int a = 1; 
+	int b = 2; 
+	int c = 3; 
+	long long _ = 0LL; 
+END
+CASE(8)
+	int places = 1; 
+	int points = 1; 
+	int a = 3; 
+	int b = 2; 
+	int c = 1; 
+	long long _ = 0LL; 
+END
+CASE(9)
+	int places = 3; 
+	int points = 3; 
+	int a = 1000000; 
+	int b = 1000000; 
+	int c = 1000000; 
+	long long _ = 0LL; 
+END
+CASE(9)
+	int places = 4; 
+	int points = 4; 
+	int a = 1000000; 
+	int b = 1000000; 
+	int c = 1000000; 
+	long long _ = 4LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/473-U/1C-U.cpp
Index: SRM/473-U/1C-U.cpp
==================================================================
--- SRM/473-U/1C-U.cpp
+++ SRM/473-U/1C-U.cpp
@@ -0,0 +1,180 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000009;
+
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL POW(LL x, LL e) {
+	LL v = 1;
+	for(;e;x=MUL(x,x),e>>=1)
+		if(e&1)
+			v = MUL(v, x);
+	return v;
+}
+LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
+LL C_impl(LL n, LL k) {
+	LL v = 1;
+	for(LL i=1; i<=k; ++i)
+		v = DIV(MUL(v, n-i+1), i);
+	return v;
+}
+LL C_tbl[40][40];
+LL C(LL n, LL k) {
+	if( C_tbl[n][k] < 0 )
+		C_tbl[n][k] = C_impl(n,k);
+	return C_tbl[n][k];
+}
+
+class RooksParty { public:
+	int countArrangements(int rows, int columns, vector <int> counts) 
+	{
+		for(int n=0;n<40;++n)
+			for(int k=0;k<40;++k)
+				C_tbl[n][k] = -1;
+		sort(counts.rbegin(), counts.rend());
+		return (int)rec(rows, columns, counts, 0);	
+	}
+	map<pair<pair<int,int>,int>, LL> memo;
+	LL rec(int H, int W, vector<int>& counts, int i)
+	{
+		if( i == counts.size() )
+			return 1;
+		int n = counts[i];
+		if( H*W < n )
+			return 0;
+
+		if(H>W)
+			swap(H,W);
+
+		pair<pair<int,int>,int> key(make_pair(H,W),i);
+		if( memo.count(key) )
+			return memo[key];
+
+		LL cnt = 0;
+		for(int h=1; h<=min(H,n); ++h)
+			for(int w=1; w<=min(W,n); ++w)
+				if( h*w >= n )
+					cnt = ADD(cnt, MUL(MUL(C(H,h), C(W,w)), MUL(count(h,w,n),rec(H-h,W-w,counts,i+1))));
+		return memo[key] = cnt;
+	}
+
+	map<pair<pair<int,int>,int>, LL> memo2;
+	LL count(int h, int w, int n)
+	{
+		if( h*w < n )
+			return 0;
+		pair<pair<int,int>,int> key(make_pair(h,w),n);
+		if(memo2.count(key))
+			return memo2[key];
+		LL cnt = freedom(h,w,n);
+		for(int t=1; t<=w-1; ++t)
+			cnt = SUB(cnt, MUL(count(h,w-t,n),C(w,t)));
+		return memo2[key] = cnt;
+	}
+
+	map<pair<pair<int,int>,int>, LL> memo3;
+	LL freedom(int h, int w, int n)
+	{
+		if(h*w<n) return 0;
+		//if(h>n)   return 0;
+		if(h==0)  return 1;
+		pair<pair<int,int>,int> key(make_pair(h,w),n);
+		if(memo3.count(key))
+			return memo3[key];
+
+		LL cnt = 0;
+		for(int t=0; t<=min(n,w); ++t)
+			cnt = ADD(cnt, MUL(freedom(h-1, w, n-t), C(w,t)));
+		return memo3[key]=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(_, RooksParty().countArrangements(rows, columns, counts));}
+int main(){
+
+CASE(0)
+	int rows = 2; 
+	int columns = 3; 
+	int counts_[] = {1,1};
+	  vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_)); 
+	int _ = 12; 
+END
+CASE(1)
+	int rows = 5; 
+	int columns = 2; 
+	int counts_[] = {3};
+	  vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_)); 
+	int _ = 120; 
+END
+CASE(2)
+	int rows = 5; 
+	int columns = 2; 
+	int counts_[] = {1,1,1};
+	  vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_)); 
+	int _ = 0; 
+END
+CASE(3)
+	int rows = 8; 
+	int columns = 8; 
+	int counts_[] = {1,1,1,1,1,1,1,1};
+	  vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_)); 
+	int _ = 625702391; 
+END
+CASE(4)
+	int rows = 4; 
+	int columns = 2; 
+	int counts_[] = {3,1};
+	  vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_)); 
+	int _ = 8; 
+END
+/*
+CASE(5)
+	int rows = ; 
+	int columns = ; 
+	int counts_[] = ;
+	  vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_)); 
+	int _ = ; 
+END
+CASE(6)
+	int rows = ; 
+	int columns = ; 
+	int counts_[] = ;
+	  vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/474/1A.cpp
Index: SRM/474/1A.cpp
==================================================================
--- SRM/474/1A.cpp
+++ SRM/474/1A.cpp
@@ -0,0 +1,130 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class RouteIntersection { public:
+	string isValid(int N, vector <int> coords, string moves) 
+	{
+		vector< map<int,int> > route;
+
+		map<int,int> cur;
+		route.push_back(cur);
+		for(int i=0; i<moves.size(); ++i) {
+			int c = coords[i];
+			int m = moves[i]=='+' ? +1 : -1;
+			cur[c] += m;
+			route.push_back(cur);
+		}
+	
+		for(int i=0; i<route.size(); ++i)
+			for(int j=i+1; j<route.size(); ++j)
+				if( is_same(route[i], route[j]) )
+					return "NOT VALID";
+		return "VALID";
+	}
+
+	bool is_same(map<int,int>& a, map<int,int>& b)
+	{
+		for(map<int,int>::iterator it=b.begin(); it!=b.end(); ++it)
+			if( a[it->first] != it->second )
+				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 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(_, RouteIntersection().isValid(N, coords, moves));}
+int main(){
+
+CASE(0)
+	int N = 1; 
+	int coords_[] = {1};
+	  vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_)); 
+	string moves = "+"; 
+	string _ = "VALID"; 
+END
+CASE(1)
+	int N = 2; 
+	int coords_[] = {1,2,1,2};
+	  vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_)); 
+	string moves = "++--"; 
+	string _ = "NOT VALID"; 
+END
+CASE(2)
+	int N = 3; 
+	int coords_[] = {1,2,3,1,2};
+	  vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_)); 
+	string moves = "+++--"; 
+	string _ = "VALID"; 
+END
+CASE(3)
+	int N = 344447; 
+	int coords_[] = {132,51717,628,344447,628,51717,344447,2};
+	  vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_)); 
+	string moves = "+-++-+--"; 
+	string _ = "NOT VALID"; 
+END
+CASE(4)
+	int N = 1; 
+	int coords_[] = {1,1};
+	  vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_)); 
+	string moves = "+-"; 
+	string _ = "NOT VALID"; 
+END
+CASE(5)
+	int N = 990630; 
+	int coords_[] = {833196,524568,361663,108056,28026,824639,269315,440977,440977,765458,
+988451,242440,948414,130873,773990,765458,130873,28026,853121,553636,
+581069,82254,735536,833196,898562,898562,940783,988451,540613,317306,
+623194,940783,571384,988451,108056,514374,97664};
+	  vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_)); 
+	string moves = "--+---+-+++-+-+---++-++-+---+-+--+-++"; 
+	string _ = "NOT VALID"; 
+END
+/*
+CASE(6)
+	int N = ; 
+	int coords_[] = ;
+	  vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_)); 
+	string moves = ; 
+	string _ = ; 
+END
+CASE(7)
+	int N = ; 
+	int coords_[] = ;
+	  vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_)); 
+	string moves = ; 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/474/1B.cpp
Index: SRM/474/1B.cpp
==================================================================
--- SRM/474/1B.cpp
+++ SRM/474/1B.cpp
@@ -0,0 +1,141 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+typedef int vert;
+typedef int cost;
+typedef pair<cost,vert> cedge;
+
+bool byVert( const cedge& e1, const cedge& e2 )
+{
+	if( e1.second != e2.second )
+		return e1.second < e2.second;
+	return e1.first < e2.first;
+}
+
+class TreesCount { public:
+	int count(vector <string> graph) 
+	{
+		LL answer = 1;
+
+		priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+		set<vert> V;
+		Q.push( cedge(0, 0) );
+		while( !Q.empty() )
+		{
+			const cost c0 = Q.top().first;
+
+			vector<cedge> cand;
+			while( !Q.empty() && Q.top().first==c0 ) {
+				if( !V.count(Q.top().second) )
+					cand.push_back( Q.top() );
+				Q.pop();
+			}
+
+			sort( cand.begin(), cand.end(), byVert );
+			for(int i=0; i<cand.size();) {
+				cost c = cand[i].first;
+				vert v = cand[i].second;
+				int j = i;
+				while( j<cand.size() && cand[j].second==v )
+					++j;
+
+				answer = answer * (j-i) % 1000000007;
+				V.insert(v);
+				for(int u=0; u<graph.size(); ++u)
+					if( graph[v][u]>'0' && !V.count(u) )
+						Q.push( cedge(c+graph[v][u]-'0', u) );
+
+				i = j;
+			}
+		}
+
+		return (int)answer;
+	}
+};
+
+// 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(_, TreesCount().count(graph));}
+int main(){
+
+CASE(0)
+	string graph_[] = {"01",
+ "10"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string graph_[] = {"011",
+ "101",
+ "110"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 1; 
+END
+CASE(2)
+	string graph_[] = {"021",
+ "201",
+ "110"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 2; 
+END
+CASE(3)
+	string graph_[] = {"0123",
+ "1012",
+ "2101",
+ "3210"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 6; 
+END
+CASE(4)
+	string graph_[] = {"073542",
+ "705141",
+ "350721",
+ "517031",
+ "442304",
+ "211140"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = 2; 
+END
+	/*
+CASE(5)
+	string graph_[] = ;
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = ; 
+END
+CASE(6)
+	string graph_[] = ;
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/474/1C.cpp
Index: SRM/474/1C.cpp
==================================================================
--- SRM/474/1C.cpp
+++ SRM/474/1C.cpp
@@ -0,0 +1,281 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename T>
+struct DP3
+{
+	int N1, N2, N3;
+	vector<T> data;
+	DP3(){}
+	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 GameWithGraphAndTree { public:
+	vector<string>        graph;
+	vector< vector<int> > children;
+	vector<int>           subtree_size;
+
+	int calc(vector <string> graph_, vector <string> tree_) 
+	{
+		int N = graph_.size();
+
+		graph = graph_;
+		children.resize(N);
+		subtree_size.resize(N);
+		computeChildren(-1, 0, tree_);
+
+		memo = DP3<LL>(N,N,1<<N,-1);
+
+		LL answer = 0;
+		for(int gv=0; gv<graph.size(); ++gv)
+			answer += vertical(0, gv, (1<<N)-1);
+		return int(answer % 1000000007);
+	}
+
+	void computeChildren(int tparent, int tv, const vector<string>& tree)
+	{
+		subtree_size[tv] = 1;
+		for(int tc=0; tc<tree.size(); ++tc)
+			if( tree[tv][tc] == 'Y' && tc!=tparent ) {
+				children[tv].push_back(tc);
+				computeChildren(tv, tc, tree);
+				subtree_size[tv] += subtree_size[tc];
+			}
+	}
+
+	LL vertical(int tv, int gv, int mask)
+	{
+		return horizontal(tv, gv, mask&~(1<<gv), 0); 
+	}
+
+	DP3<LL> memo;
+	LL horizontal(int tv, int gv, int mask, int i)
+	{
+		if( i == children[tv].size() ) 
+			return 1;
+		int tu = children[tv][i];
+
+		if( memo(tv,gv,mask) >= 0 )
+			return memo(tv,gv,mask);
+
+		LL answer = 0;
+		for(int subset=mask; subset; subset=(subset-1)&mask)
+			if( __builtin_popcount(subset) == subtree_size[tu] )
+				for(int gu=0; (1<<gu)<=subset; ++gu)
+					if( graph[gv][gu]=='Y' && ((1<<gu)&subset) )
+						answer += vertical(tu, gu, subset) * horizontal(tv, gv, mask&~subset, i+1);
+
+		return memo(tv,gv,mask) = answer % 1000000007;
+	}
+};
+
+// 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(_, GameWithGraphAndTree().calc(graph, tree));}
+int main(){
+
+CASE(0)
+	string graph_[] = {"NYN",
+ "YNY",
+ "NYN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	string tree_[] = {"NYY",
+ "YNN",
+ "YNN"};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 2; 
+END
+CASE(1)
+	string graph_[] = {"NYNNN",
+ "YNYYY",
+ "NYNYY",
+ "NYYNY",
+ "NYYYN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	string tree_[] = {"NYNNN", 
+ "YNYNN",
+ "NYNYN",
+ "NNYNY",
+ "NNNYN"};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 12; 
+END
+CASE(2)
+	string graph_[] = {"NYNNNY",
+ "YNYNNN",
+ "NYNYNN",
+ "NNYNYN", 
+ "NNNYNY",
+ "YNNNYN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	string tree_[] = {"NYNNYN",
+ "YNNYNY",
+ "NNNNYN",
+ "NYNNNN",
+ "YNYNNN",
+ "NYNNNN"};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 0; 
+END
+CASE(3)
+	string graph_[] = {"NYNNYN",
+ "YNNYNY",
+ "NNNNYN",
+ "NYNNNN",
+ "YNYNNN",
+ "NYNNNN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	string tree_[] = {"NNNYYN", 
+ "NNYNNN",
+ "NYNNYY", 
+ "YNNNNN",
+ "YNYNNN",
+ "NNYNNN"};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 2; 
+END
+CASE(4)
+	string graph_[] = {"NYNNNYNNY",
+ "YNNNNNNYN",
+ "NNNNYYNYY",
+ "NNNNNYNNY",
+ "NNYNNNYNY",
+ "YNYYNNNYN",
+ "NNNNYNNYN",
+ "NYYNNYYNN",
+ "YNYYYNNNN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	string tree_[] = {"NNYNNNYYN",
+ "NNNNYNNNN",
+ "YNNNNNNNN",
+ "NNNNNNYNN",
+ "NYNNNNNYY",
+ "NNNNNNNNY",
+ "YNNYNNNNN",
+ "YNNNYNNNN",
+ "NNNNYYNNN"};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 90; 
+END
+CASE(5)
+string graph_[] = {"N"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	  string tree_[] = {"N"};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 1; 
+END
+CASE(6)
+	string graph_[] = {
+	"NYYYYYYYYYYYYY",
+	"YNYYYYYYYYYYYY",
+	"YYNYYYYYYYYYYY",
+	"YYYNYYYYYYYYYY",
+	"YYYYNYYYYYYYYY",
+	"YYYYYNYYYYYYYY",
+	"YYYYYYNYYYYYYY",
+	"YYYYYYYNYYYYYY",
+	"YYYYYYYYNYYYYY",
+	"YYYYYYYYYNYYYY",
+	"YYYYYYYYYYNYYY",
+	"YYYYYYYYYYYNYY",
+	"YYYYYYYYYYYYNY",
+	"YYYYYYYYYYYYYN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	string tree_[] = {
+			"NYNNNNNNNNNNNN",
+			"YNYNNNNNNNNNNN",
+			"NYNYNNNNNNNNNN",
+			"NNYNYNNNNNNNNN",
+			"NNNYNYNNNNNNNN",
+			"NNNNYNYNNNNNNN",
+			"NNNNNYNYNNNNNN",
+			"NNNNNNYNYNNNNN",
+			"NNNNNNNYNYNNNN",
+			"NNNNNNNNYNYNNN",
+			"NNNNNNNNNYNYNN",
+			"NNNNNNNNNNYNYN",
+			"NNNNNNNNNNNYNY",
+			"NNNNNNNNNNNNYN",
+	};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 178290591; 
+END
+CASE(7)
+	string graph_[] = {
+	"NYYYYYYYYYYYYY",
+	"YNYYYYYYYYYYYY",
+	"YYNYYYYYYYYYYY",
+	"YYYNYYYYYYYYYY",
+	"YYYYNYYYYYYYYY",
+	"YYYYYNYYYYYYYY",
+	"YYYYYYNYYYYYYY",
+	"YYYYYYYNYYYYYY",
+	"YYYYYYYYNYYYYY",
+	"YYYYYYYYYNYYYY",
+	"YYYYYYYYYYNYYY",
+	"YYYYYYYYYYYNYY",
+	"YYYYYYYYYYYYNY",
+	"YYYYYYYYYYYYYN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	string tree_[] = {
+			"NYYYNNNNNNNNNN",
+			"YNNNYYYNNNNNNN",
+			"YNNNNNNYYYNNNN",
+			"YNNNNNNNNNYYYY",
+			"NYNNNNNNNNNNNN",
+			"NYNNNNNNNNNNNN",
+			"NYNNNNNNNNNNNN",
+			"NNYNNNNNNNNNNN",
+			"NNYNNNNNNNNNNN",
+			"NNYNNNNNNNNNNN",
+			"NNNYNNNNNNNNNN",
+			"NNNYNNNNNNNNNN",
+			"NNNYNNNNNNNNNN",
+			"NNNYNNNNNNNNNN",
+	};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 178290591; 
+END
+CASE(8)
+	string graph_[] = {"NYYYYYYYYYYYYY", "YNYYYYYYYYYYYY", "YYNYYYYYYYYYYY", "YYYNYYYYYYYYYY", "YYYYNYYYYYYYYY", "YYYYYNYYYYYYYY", "YYYYYYNYYYYYYY", "YYYYYYYNYYYYYY", "YYYYYYYYNYYYYY", "YYYYYYYYYNYYYY", "YYYYYYYYYYNYYY", "YYYYYYYYYYYNYY", "YYYYYYYYYYYYNY", "YYYYYYYYYYYYYN"};
+	  vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_)); 
+	string tree_[] = {"NYYYYYYYYYYYYY", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN"};
+	  vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_)); 
+	int _ = 178290591; 
+END
+}
+// END CUT HERE

ADDED   SRM/475-U/1A.cpp
Index: SRM/475-U/1A.cpp
==================================================================
--- SRM/475-U/1A.cpp
+++ SRM/475-U/1A.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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+int bitcnt(int m)
+{
+	int c = 0;
+	for(;m;m>>=1)
+		c += (m&1);
+	return c;
+}
+
+class RabbitStepping { public:
+	double getExpected(string field, int r) 
+	{
+		cerr<<field.size()<<endl;
+		int ex = 0;
+		int cn = 0;
+
+		int N = field.size();
+		for(int mask=1; mask<(1<<N); ++mask)
+			if( bitcnt(mask) == r )
+			{
+				vector< pair<int,int> > rs;
+				for(int i=0; i<N; ++i)
+					if( mask & (1<<i) )
+						rs.push_back(make_pair(-1,i));
+				int left = run(field, rs, N);
+				ex += left;
+				cn += 1;
+			}
+		return double(ex) / cn;
+	}
+
+	int run(const string& field, vector< pair<int,int> >& rs, int size)
+	{
+		while( size > 2 && !rs.empty() )
+		{
+			oneStep(field, rs, size);
+			int cnt[20] = {};
+			for(int i=0; i<rs.size(); ++i)
+				cnt[rs[i].second] ++;
+			vector< pair<int,int> > rs2;
+			for(int i=0; i<rs.size(); ++i)
+				if( cnt[rs[i].second] == 1 )
+					rs2.push_back(rs[i]);
+			rs.swap(rs2);
+		}
+		return rs.size();
+	}
+
+	void oneStep(const string& field, vector< pair<int,int> >& rs, int& size)
+	{
+		for(int i=0; i<rs.size(); ++i) {
+			int prev = rs[i].first;
+			int& cur = rs[i].second;
+			rs[i].first = cur;
+			if( cur == 0 )
+				cur ++;
+			else if( cur >= size-2 )
+				cur --;
+			else if( field[cur]=='W' )
+				cur --;
+			else if( field[cur]=='B' )
+				cur ++;
+			else if( prev == -1 )
+				cur --;
+			else
+				cur = prev;
+		}
+		--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 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(_, RabbitStepping().getExpected(field, r));}
+int main(){
+
+CASE(0)
+	string field = "WRBRW"; 
+	int r = 4; 
+	double _ = 0.8; 
+END
+CASE(1)
+	string field = "WWB"; 
+	int r = 2; 
+	double _ = 1.3333333333333333; 
+END
+CASE(2)
+	string field = "WW"; 
+	int r = 1; 
+	double _ = 1.0; 
+END
+CASE(3)
+	string field = "BBBBBBBBBB"; 
+	int r = 4; 
+	double _ = 0.9523809523809523; 
+END
+CASE(4)
+	string field = "RRBRRWRRBRRW"; 
+	int r = 8; 
+	double _ = 0.9696969696969697; 
+END
+CASE(5)
+	string field = "RRRRRRRRRRRRRRRRR"; 
+	int r = 8; 
+	double _ = -1; 
+END
+CASE(6)
+	string field = "BBBBBBBBBBBBBBBBB"; 
+	int r = 8; 
+	double _ = -1; 
+END
+CASE(7)
+	string field = "WWWWWWWWWWWWWWWWW"; 
+	int r = 8; 
+	double _ = -1; 
+END
+CASE(8)
+	string field = "BWBWBWBWBWBWBWBWB"; 
+	int r = 8; 
+	double _ = -1; 
+END
+CASE(9)
+	string field = "RR"; 
+	int r = 2; 
+	double _ = 2; 
+END
+CASE(9)
+	string field = "RR"; 
+	int r = 1; 
+	double _ = 1; 
+END
+CASE(9)
+	string field = "BRWWBRBWBWBWBRBWR"; 
+	int r = 1; 
+	double _ = 1; 
+END
+}
+// END CUT HERE

ADDED   SRM/475-U/1B.cpp
Index: SRM/475-U/1B.cpp
==================================================================
--- SRM/475-U/1B.cpp
+++ SRM/475-U/1B.cpp
@@ -0,0 +1,154 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000009; // must fit in 32-bits
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL POW(LL x, LL e) {
+	LL v = 1;
+	for(;e;x=MUL(x,x),e>>=1)
+		if(e&1)
+			v = MUL(v, x);
+	return v;
+}
+LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
+
+class RabbitIncreasing { public:
+	int getNumber(vector <int> leaving, int k) 
+	{
+		if( leaving.front() <= 1 )
+			return 0;
+		int li = 0;
+
+		LL y[] = {1,0,0};
+		LL p[] = {1,0,0};
+		LL PP = (1LL << 55);
+		for(int i=2; i<=k; ++i)
+		{
+			LL a=y[0], b=y[1], c=y[2];
+			y[0]=y[2]=ADD(b,c); y[1]=a;
+			LL pa=p[0], pb=p[1], pc=p[2];
+			p[0]=p[2]=(pb+pc)%PP; p[1]=pa;
+			if( li<leaving.size() && i==leaving[li] ) {
+				++li;
+				y[2] = 0;
+				p[2] = 0;
+				if( p[1]&1 ) {
+					y[1]=DIV(SUB(y[1],1),2);
+				} else {
+					y[1]=DIV(y[1],2);
+				}
+				p[1]=p[1]/2;
+				PP >>= 1;
+			}
+		}
+		return ADD(y[0],ADD(y[1],y[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(_, RabbitIncreasing().getNumber(leaving, k));}
+int main(){
+
+CASE(0)
+	int leaving_[] = { 3 };
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 3; 
+	int _ = 1; 
+END
+CASE(1)
+	int leaving_[] = { 5, 9 };
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 10; 
+	int _ = 6; 
+END
+CASE(2)
+	int leaving_[] = { 5, 10, 15 };
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 19; 
+	int _ = 212; 
+END
+CASE(3)
+	int leaving_[] = { 2 };
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 10000000; 
+	int _ = 0; 
+END
+CASE(4)
+	int leaving_[] = { 195, 211, 227, 230, 260, 
+  297, 346, 350, 403, 411, 
+  428, 485, 594, 606, 876 }
+;
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 1000; 
+	int _ = 975206486; 
+END
+CASE(5)
+int leaving_[] = {2};
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 1; 
+	int _ = 1; 
+END
+CASE(5)
+int leaving_[] = {2};
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 2; 
+	int _ = 0; 
+END
+CASE(5)
+int leaving_[] = {1};
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 1; 
+	int _ = 0; 
+END
+CASE(6)
+	int leaving_[] = {999};
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 10000000; 
+	int _ = 536491299; 
+END
+CASE(7)
+	int leaving_[] = {
+	100,200,300,400,500,600,700,800,900,1000,
+	1100,1200,1300,1400,1500,1600,1700,1800,1900,2000,
+	3100,3200,3300,3400,3500,3600,3700,3800,3900,31000,
+	43100,43200,43300,43400,43500,43600,43700,43800,43900,431000,
+	999100,999200,999300,999400,999500,999600,999700,999800,999900,9991000,
+};
+	  vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_)); 
+	int k = 10000000; 
+	int _ = 260357174; 
+END
+}
+// END CUT HERE

ADDED   SRM/476-U/1A.cpp
Index: SRM/476-U/1A.cpp
==================================================================
--- SRM/476-U/1A.cpp
+++ SRM/476-U/1A.cpp
@@ -0,0 +1,121 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Badgers { public:
+	int feedMost(vector <int> hunger, vector <int> greed, int totalFood) 
+	{
+		for(int m=hunger.size(); m>0; --m)	
+			if( can(m, hunger, greed, totalFood) )
+				return m;
+		return 0;
+	}
+	bool can(int m, vector<int> h, const vector<int>& g, int totalFood)
+	{
+		for(int i=0; i<h.size(); ++i)
+			h[i] += g[i]*(m-1);
+		sort(h.begin(), h.end());
+		return accumulate(h.begin(), h.begin()+m, 0) <= totalFood;
+	}
+};
+
+// 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(_, Badgers().feedMost(hunger, greed, totalFood));}
+int main(){
+
+CASE(0)
+	int hunger_[] = {1,2,3};
+	  vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_)); 
+	int greed_[] = {2,2,1};
+	  vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_)); 
+	int totalFood = 7; 
+	int _ = 2; 
+END
+CASE(1)
+	int hunger_[] = {5,2,1,5};
+	  vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_)); 
+	int greed_[] = {0,2,4,1};
+	  vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_)); 
+	int totalFood = 19; 
+	int _ = 3; 
+END
+CASE(2)
+	int hunger_[] = {1,1,1,1,1};
+	  vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_)); 
+	int greed_[] = {1000,1000,1000,1000,1000};
+	  vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_)); 
+	int totalFood = 10; 
+	int _ = 1; 
+END
+CASE(3)
+	int hunger_[] = {1,2,3,4,5,6,7,8,9,10};
+	  vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_)); 
+	int greed_[] = {10,9,8,7,6,5,4,3,2,1};
+	  vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_)); 
+	int totalFood = 100; 
+	int _ = 5; 
+END
+CASE(4)
+	int hunger_[] = {2};
+	  vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_)); 
+	  int greed_[] = {0};
+	  vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_)); 
+	  int totalFood = {1}; 
+	  int _ = 0; 
+END
+CASE(4)
+	int hunger_[] = {2};
+	  vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_)); 
+	  int greed_[] = {0};
+	  vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_)); 
+	  int totalFood = {2}; 
+	  int _ = 1; 
+END
+CASE(4)
+	int hunger_[] = {2};
+	  vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_)); 
+	  int greed_[] = {0};
+	  vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_)); 
+	  int totalFood = {1000000}; 
+	  int _ = 1; 
+END
+CASE(5)
+int hunger_[] = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10};
+	  vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_)); 
+	  int greed_[] = {100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100};
+	  vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_)); 
+	int totalFood = 10000; 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/476-U/1B.cpp
Index: SRM/476-U/1B.cpp
==================================================================
--- SRM/476-U/1B.cpp
+++ SRM/476-U/1B.cpp
@@ -0,0 +1,193 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename T>
+struct DP2
+{
+	int N1, N2;
+	vector<T> data;
+	DP2(){}
+	DP2(int N1, int N2, const T& t = T())
+		: N1(N1), N2(N2), data(N1*N2, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2)
+		{ return data[ (i1*N2)+i2 ]; }
+	void swap(DP2& rhs)
+		{ data.swap(rhs.data); }
+};
+
+class FriendTour { public:
+	double tourProbability(vector <string> friends, int K) 
+	{
+		int N = (int)friends.size();
+		vector< vector<int> > f(N);
+		for(int i=0; i<N; ++i)
+		{
+			stringstream sin( friends[i] );
+			for(int v; sin>>v; )
+				f[i].push_back(v-1);
+		}
+
+		map<int,int> rename;
+		rename[0] = 0;
+		for(int k=0; k<f[0].size(); ++k)
+		{
+			int newid = rename.size();
+			rename[f[0][k]] = newid;
+		}
+
+		vector< vector<int> > ff(rename.size());
+		for(int i=0; i<N; ++i)
+			if( rename.count(i) )
+			{
+				int k = rename[i];
+				for(int j=0; j<f[i].size(); ++j)
+					if( f[i][j]!=0 && rename.count(f[i][j]) )
+						ff[k].push_back( rename[f[i][j]] );
+					else
+						ff[k].push_back( -1 );
+			}
+		return solve(ff, K);
+	}
+
+	double solve(vector<vector<int> >& f, int K)
+	{
+		memo = DP2<double>(f.size(), 1<<f.size(), -1);
+		return rec(f, K, 0, 1);
+	}
+
+	double C(int N, int K)
+	{
+		double p = 1.0;
+		for(int i=0; i<min(K,N-K); ++i)
+			p = p * (N-i) / (1+i);
+		return p;
+	}
+
+	DP2<double> memo;
+	double rec(vector<vector<int> >& f, int K, int v, int mask)
+	{
+		if( memo(v,mask) != -1 )
+			return memo(v,mask);
+
+		if( mask == (1<<f.size())-1 )
+			return 1.0;
+
+		vector<double> nxt;
+		for(int i=0; i<f[v].size(); ++i)
+			if( f[v][i]==-1 || (mask & (1<<f[v][i])) )
+				nxt.push_back(0);
+			else
+				nxt.push_back( rec(f,K,f[v][i],mask|(1<<f[v][i])) );
+		sort(nxt.rbegin(), nxt.rend());
+		int N = nxt.size();
+		if( N == 0 )
+			return memo(v,mask) = 0.0;
+
+		if( N <= K )
+			return memo(v,mask) = nxt[0];
+
+		double p = 0.0;
+		for(int i=0; i<nxt.size(); ++i) {
+			if( N-1-i < K ) {
+				p += C(N-i,K) / C(N,K) * nxt[i];
+				break;
+			}
+			p += (C(N-i,K) - C(N-1-i,K)) / C(N,K) * nxt[i];
+		}
+		return memo(v,mask) = p;
+	}
+};
+
+// 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(_, FriendTour().tourProbability(friends, K));}
+int main(){
+
+CASE(0)
+	string friends_[] = {"2 3 4",
+ "1 3 4",
+ "1 2 4",
+ "1 2 3"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int K = 1; 
+	double _ = 0.2222222222222222; 
+END
+CASE(1)
+	string friends_[] = {"2 3 4",
+ "1 3 4",
+ "1 2 4",
+ "1 2 3"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int K = 2; 
+	double _ = 0.6666666666666666; 
+END
+CASE(2)
+	string friends_[] = {"3 2 4",
+ "3 5 1",
+ "5 2 1 4",
+ "3 1 5",
+ "3 2 4"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int K = 2; 
+	double _ = 0.3333333333333333; 
+END
+CASE(3)
+	string friends_[] = {"3 2 4",
+ "3 5 1",
+ "5 2 1 4",
+ "3 1 5 6",
+ "3 2 4",
+ "4"}
+;
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int K = 2; 
+	double _ = 0.3055555555555556; 
+END
+CASE(4)
+	string friends_[] = {"6 5 4 2",
+ "1 6 3 5",
+ "5 4 2",
+ "3 1 5",
+ "2 4 3 1 6",
+ "1 2 5"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int K = 3; 
+	double _ = 0.73125; 
+END
+CASE(5)
+	string friends_[] = {"2 3 4 5 6 7 8 9 10 11 12 13 14 15 16", "1 3 4 5 6 7 8 9 10 11 12 13 14 15 16", "1 2 4 5 6 7 8 9 10 11 12 13 14 15 16", "1 2 3 5 6 7 8 9 10 11 12 13 14 15 16", "1 2 3 4 6 7 8 9 10 11 12 13 14 15 16", "1 2 3 4 5 7 8 9 10 11 12 13 14 15 16", "1 2 3 4 5 6 8 9 10 11 12 13 14 15 16", "1 2 3 4 5 6 7 9 10 11 12 13 14 15 16", "1 2 3 4 5 6 7 8 10 11 12 13 14 15 16", "1 2 3 4 5 6 7 8 9 11 12 13 14 15 16", "1 2 3 4 5 6 7 8 9 10 12 13 14 15 16", "1 2 3 4 5 6 7 8 9 10 11 13 14 15 16", "1 2 3 4 5 6 7 8 9 10 11 12 14 15 16", "1 2 3 4 5 6 7 8 9 10 11 12 13 15 16", "1 2 3 4 5 6 7 8 9 10 11 12 13 14 16", "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15"};
+	  vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_)); 
+	int K = 3; 
+	double _ = 0.010989546288518458; 
+END
+}
+// END CUT HERE

ADDED   SRM/476-U/1C-U.cpp
Index: SRM/476-U/1C-U.cpp
==================================================================
--- SRM/476-U/1C-U.cpp
+++ SRM/476-U/1C-U.cpp
@@ -0,0 +1,111 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class SpaceshipEvacuation { public:
+	int additionalCabins(int N, vector <string> tunnelNetwork, int crewSize) 
+	{
+		
+	}
+};
+
+// 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(_, SpaceshipEvacuation().additionalCabins(N, tunnelNetwork, crewSize));}
+int main(){
+
+CASE(0)
+	int N = 3; 
+	string tunnelNetwork_[] = {"0 1 5 3",
+ "2 1 0 0"};
+	  vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_)); 
+	int crewSize = 5; 
+	int _ = 7; 
+END
+CASE(1)
+	int N = 3; 
+	string tunnelNetwork_[] = {"0 1 0 2",
+ "0 2 0 4"};
+	  vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_)); 
+	int crewSize = 5; 
+	int _ = 4; 
+END
+CASE(2)
+	int N = 4; 
+	string tunnelNetwork_[] = {"0 1 0 6",
+ "3 2 3 1",
+ "2 1 0 1",
+ "3 1 2 2"};
+	  vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_)); 
+	int crewSize = 6; 
+	int _ = 6; 
+END
+CASE(3)
+	int N = 10; 
+	string tunnelNetwork_[] = {"0 1 11 101",
+ "1 2 0 100",
+ "2 3 20 100",
+ "3 4 0 107",
+ "4 1 66 0",
+ "3 5 104 2",
+ "4 6 82 0",
+ "5 7 25 25",
+ "7 8 14 42",
+ "8 9 0 94",
+ "9 5 17 92"};
+	  vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_)); 
+	int crewSize = 110; 
+	int _ = 376; 
+END
+CASE(4)
+	int N = 3; 
+	string tunnelNetwork_[] = {"0 1 0 0"};
+	  vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_)); 
+	int crewSize = 1; 
+	int _ = -1; 
+END
+CASE(5)
+	int N = ; 
+	string tunnelNetwork_[] = ;
+	  vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_)); 
+	int crewSize = ; 
+	int _ = ; 
+END
+CASE(6)
+	int N = ; 
+	string tunnelNetwork_[] = ;
+	  vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_)); 
+	int crewSize = ; 
+	int _ = ; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/478-U/1A.cpp
Index: SRM/478-U/1A.cpp
==================================================================
--- SRM/478-U/1A.cpp
+++ SRM/478-U/1A.cpp
@@ -0,0 +1,91 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL =  1000000007;
+class CarrotJumping { public:
+	int theJump(int init) 
+	{
+		LL x = (init+1) % MODVAL;
+		int i = 2;
+		x = (x*4) % MODVAL;
+		while(i < 1000000){
+			if( x == 1 ) {
+				int z = i/3 + (i%3 ? 1 : 0);
+				return z>100000 ? -1 : z;
+			}
+			i++;
+			x = (x*2)% MODVAL;
+		}
+		return -1;
+	}
+};
+
+// 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(_, CarrotJumping().theJump(init));}
+int main(){
+
+CASE(0)
+	int init = 125000000; 
+	int _ = 1; 
+END
+CASE(1)
+	int init = 281250001; 
+	int _ = 2; 
+END
+CASE(2)
+	int init = 18426114; 
+	int _ = 58; 
+END
+CASE(3)
+	int init = 4530664; 
+	int _ = 478; 
+END
+CASE(4)
+	int init = 705616876; 
+	int _ = 100000; 
+END
+CASE(5)
+	int init = 852808441; 
+	int _ = -1; 
+END
+CASE(6)
+	int init = 1; 
+	int _ = -2; 
+END
+CASE(7)
+	int init = 1000000006; 
+	int _ = -2; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/478-U/1B.cpp
Index: SRM/478-U/1B.cpp
==================================================================
--- SRM/478-U/1B.cpp
+++ SRM/478-U/1B.cpp
@@ -0,0 +1,135 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class KiwiJuice { public:
+	int theProfit(int C, vector <int> bottles, vector <int> prices) 
+	{
+		best.clear();
+		best.resize(1<<bottles.size(), -1);
+		return rec((1<<bottles.size())-1, C, bottles, prices);
+	}
+
+	vector<int> best;
+	int rec(int mask, int C, vector<int>& B, const vector<int>& P)
+	{
+		if( mask == 0 )
+			return 0;
+		if( best[mask] != -1 )
+			return best[mask];
+		int maxSc = 0;
+		for(int subset=mask; subset; subset=((subset-1)&mask)) {
+			int sum = 0;
+			int bin = 0;
+			for(int i=0; i<B.size(); ++i)
+				if( subset & (1<<i) ) {
+					sum += B[i];
+					bin += 1;
+				}
+			int sc = P[C] * (sum/C);
+			if(sum%C) sc += P[sum%C];
+			sc += P[0] *  (bin-((sum/C)+(sum%C?1:0)));
+			sc += rec(mask&~subset, C, B, P);
+			maxSc = max(maxSc, sc);
+		}
+		return best[mask] = maxSc;
+	}
+};
+
+// 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(_, KiwiJuice().theProfit(C, bottles, prices));}
+int main(){
+
+CASE(0)
+	int C = 10; 
+	int bottles_[] = {5, 8};
+	  vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_)); 
+	int prices_[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10};
+	  vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_)); 
+	int _ = 10; 
+END
+CASE(1)
+	int C = 10; 
+	int bottles_[] = {5, 8};
+	  vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_)); 
+	int prices_[] = {0, 0, 0, 0, 0, 10, 10, 10, 10, 10, 10};
+	  vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_)); 
+	int _ = 20; 
+END
+CASE(2)
+	int C = 10; 
+	int bottles_[] = {4, 5, 3, 7};
+	  vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_)); 
+	int prices_[] = {14, 76, 12, 35, 6, 94, 26, 3, 93, 90, 420};
+	  vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_)); 
+	int _ = 625; 
+END
+CASE(3)
+	int C = 1; 
+	int bottles_[] = {0};
+	  vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_)); 
+	int prices_[] = {1000000, 1000000};
+	  vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_)); 
+	int _ = 1000000; 
+END
+CASE(4)
+	int C = 49; 
+	int bottles_[] = {2, 47, 24, 14, 0, 32, 9, 12, 31, 46, 39, 12, 16, 22, 29};
+	  vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_)); 
+	int prices_[] = {428668, 995687, 128567, 37241, 496916, 238624, 304781, 997819, 85856, 417008,
+398570, 951499, 750349, 333625, 927594, 188616, 942498, 259414, 654344, 354809,
+25303, 226854, 98578, 207140, 305527, 358343, 393213, 256248, 282644, 103327,
+667191, 103402, 609183, 619323, 189127, 518006, 778846, 400460, 128334, 795097,
+605203, 669142, 121825, 934404, 837430, 554265, 610818, 546228, 80784, 949440};
+	  vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_)); 
+	int _ = 12873962; 
+END
+CASE(5)
+	int C = 10; 
+	int bottles_[] = {2,3,5};
+	  vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_)); 
+	  int prices_[] = {0,0,9,9,0,9,0,0,0,0,99};
+	  vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_)); 
+	int _ = 99; 
+END
+/*
+CASE(6)
+	int C = ; 
+	int bottles_[] = ;
+	  vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_)); 
+	int prices_[] = ;
+	  vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/479-U/1A-U.cpp
Index: SRM/479-U/1A-U.cpp
==================================================================
--- SRM/479-U/1A-U.cpp
+++ SRM/479-U/1A-U.cpp
@@ -0,0 +1,106 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheCoffeeTimeDivOne { public:
+	long long find(int ____n, vector <int> tea) 
+	{
+		sort(tea.begin(), tea.end());
+
+		LL n = ____n;
+		LL t = n*4 + 47LL*((tea.size()+6)/7) + 47LL*((n-tea.size()+6)/7);
+
+		for(int tp=tea.size()-1; tp>=0; )
+		{
+			t  += tea[tp]*2;
+			tp -= 7;
+		}
+
+		if( n > tea.size() )
+		{
+			LL s = (n-tea.size()) % 7;
+			if(s==0) s = 7;
+			for(int tp=0; s<=n; s+=7)
+			{
+				while(tp<tea.size() && tea[tp]<=s)
+					++s, ++tp;
+				t += 2*s;
+			}
+		}
+		return t;
+	}
+};
+
+// 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(_, TheCoffeeTimeDivOne().find(n, tea));}
+int main(){
+
+CASE(0)
+	int n = 2; 
+	int tea_[] = {1};
+	  vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_)); 
+	long long _ = 108LL; 
+END
+CASE(1)
+	int n = 2; 
+	int tea_[] = {2, 1};
+	  vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_)); 
+	long long _ = 59LL; 
+END
+CASE(2)
+	int n = 15; 
+	int tea_[] = {1, 2, 3, 4, 5, 6, 7};
+	  vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_)); 
+	long long _ = 261LL; 
+END
+CASE(3)
+	int n = 47; 
+	int tea_[] = {1, 10, 6, 2, 4};
+	  vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_)); 
+	long long _ = 891LL; 
+END
+CASE(4)
+	int n = 44777777; 
+	int tea_[] = {1,2,4,8,16,32,64,128,1000,2000,3000,4000,5000,6000,7000,8000,9000};
+	  vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_)); 
+	long long _ = -1LL; 
+END
+/*
+CASE(5)
+	int n = ; 
+	int tea_[] = ;
+	  vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_)); 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/479-U/1B.cpp
Index: SRM/479-U/1B.cpp
==================================================================
--- SRM/479-U/1B.cpp
+++ SRM/479-U/1B.cpp
@@ -0,0 +1,173 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheAirTripDivOne { public:
+	struct edge {
+		int to;
+		LL F, T, P;
+	};
+	int find(int n, vector <string> flights, int time) 
+	{
+		vector< vector<edge> > e(n);
+		{
+			string input = accumulate(flights.begin(), flights.end(), string(""));
+			stringstream sin(input);
+			for(string line; sin>>line;) {
+				stringstream sin(line);
+				int a,b; LL f,t,p; char _;
+				sin >> a >> _ >> b >> _ >> f >> _ >> t >> _ >> p;
+				edge eg = {b-1,f,t,p};
+				e[a-1].push_back(eg);
+			}
+		}
+
+		int lf=0, ri=1000000001;
+		while( ri-lf>1 )
+		{
+			int c = (lf+ri)/2;
+			(ok(n,e,c,time) ? lf : ri) = c;
+		}
+		return lf ? lf : -1;
+	}
+	bool ok(int n, vector< vector<edge> >& e, LL transfer, LL TL)
+	{
+		typedef int vert;
+		typedef LL cost;
+		typedef pair<cost,int> cedge;
+		priority_queue<cedge, vector<cedge>, greater<cedge> > Q;
+		set<vert> V;
+		Q.push( cedge(0,0) );
+		while( !Q.empty() )
+		{
+			cost c = Q.top().first;
+			vert v = Q.top().second;
+			Q.pop();
+			if( V.count(v) )
+				continue;
+			if( v == n-1 )
+				return true;
+			V.insert(v);
+			vector<edge>& ne = e[v];
+			for(int i=0; i<ne.size(); ++i)
+			{
+				vert u = ne[i].to;
+				LL F=ne[i].F, T=ne[i].T, P=ne[i].P;
+				LL t = nextTime(c, F, P, v==0 ? 0 : transfer);
+//				cerr<<c<<" "<<F<<" "<<P<<" "<<transfer<<" !! "<<t<<endl;
+				if( !V.count(u) && t+T<=TL )
+					Q.push( cedge(t+T, u) );
+			}
+		}
+		return false;
+	}
+
+	LL nextTime(LL cur, LL F, LL P, LL transfer)
+	{
+		cur += transfer;
+		if( cur <= F )
+			return F;
+		return (cur-F)%P==0 ? cur : ((cur-F)/P+1)*P+F;
+	}
+};
+
+// 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(_, TheAirTripDivOne().find(n, flights, time));}
+int main(){
+
+CASE(0)
+	int n = 3; 
+	string flights_[] = {"1,2,1,4,7 ", "2,3,9,1,10"};
+	  vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int time = 20; 
+	int _ = 14; 
+END
+CASE(1)
+	int n = 3; 
+	string flights_[] = {"1,2,1,1,1 2,3,2,1,98"};
+	  vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int time = 100; 
+	int _ = -1; 
+END
+CASE(2)
+	int n = 477; 
+	string flights_[] = {"47,74,1,1,1"};
+	  vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int time = 20; 
+	int _ = -1; 
+END
+CASE(3)
+	int n = 7; 
+	string flights_[] = {"1,3,15,17,11 1,3,14,16,14 5,7,12,18,18 1,6,13,1", 
+ "6,12 1,2,18,14,13 5,6,10,10,18 3,1,10,10,10 1,3",
+ ",17,16,10 2,3,16,18,16 6,1,15,12,10 2,1,15,18,1",
+ "0 4,7,10,16,15 6,3,10,14,10 1,6,19,19,15 1,4,12",
+ ",10,14 4,7,10,18,14 2,3,16,12,12 1,3,14,10,19 3",
+ ",7,17,10,12 2,1,14,12,16 4,3,19,11,12 1,6,10,18",
+ ",12 2,3,16,12,10 6,2,10,18,12 5,1,14,18,12 5,1,",
+ "18,10,10 3,2,19,15,10 7,4,16,19,14 6,3,16,12,10",
+ " 5,7,14,13,13 1,3,12,10,16 5,7,16,18,15 6,2,18,",
+ "12,14 3,2,10,18,16 4,2,18,18,14 1,5,10,18,16 2,",
+ "3,10,19,16 1,4,11,18,15 2,1,15,15,14 7,2,10,12,",
+ "10"};
+	  vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int time = 74; 
+	int _ = 33; 
+END
+CASE(4)
+	int n = 7; 
+	string flights_[] = {"1,4,10,8,2 4,6,14,8,2 6,2,8,1",
+ "0,1 2,7,19,5,1 ",
+ "1,5,15,17,11 5,3,10,1",
+ "0,18 3,7,12,18,18"};
+	  vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int time = 147; 
+	int _ = 35; 
+END
+	/*
+CASE(5)
+	int n = ; 
+	string flights_[] = ;
+	  vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int time = ; 
+	int _ = ; 
+END
+CASE(6)
+	int n = ; 
+	string flights_[] = ;
+	  vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int time = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/479-U/2A.cpp
Index: SRM/479-U/2A.cpp
==================================================================
--- SRM/479-U/2A.cpp
+++ SRM/479-U/2A.cpp
@@ -0,0 +1,85 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheAirTripDivTwo { public:
+	int find(vector <int> flights, int fuel) 
+	{
+		partial_sum(flights.begin(), flights.end(), flights.begin());
+		return upper_bound(flights.begin(), flights.end(), fuel) - flights.begin();
+	}
+};
+
+// 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(_, TheAirTripDivTwo().find(flights, fuel));}
+int main(){
+
+CASE(0)
+	int flights_[] = {1, 2, 3, 4, 5, 6, 7};
+	  vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int fuel = 10; 
+	int _ = 4; 
+END
+CASE(1)
+	int flights_[] = {7, 6, 5, 4, 3, 2, 1};
+	  vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int fuel = 10; 
+	int _ = 1; 
+END
+CASE(2)
+	int flights_[] = {1};
+	  vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int fuel = 1000; 
+	int _ = 1; 
+END
+CASE(3)
+	int flights_[] = {8, 7, 7, 1, 5, 7, 9};
+	  vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int fuel = 21; 
+	int _ = 2; 
+END
+	/*
+CASE(4)
+	int flights_[] = ;
+	  vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int fuel = ; 
+	int _ = ; 
+END
+CASE(5)
+	int flights_[] = ;
+	  vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_)); 
+	int fuel = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/480-U/1A.cpp
Index: SRM/480-U/1A.cpp
==================================================================
--- SRM/480-U/1A.cpp
+++ SRM/480-U/1A.cpp
@@ -0,0 +1,153 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class InternetSecurity { public:
+	vector <string> determineWebsite(vector <string> address, vector <string> keyword, vector <string> dangerous, int threshold) 
+	{
+		int N = address.size();
+
+		vector< set<string> > kwd(N);
+		for(int i=0; i<N; ++i) {
+			stringstream ss(keyword[i]);
+			for(string s; ss >> s; )
+				kwd[i].insert(s);
+		}
+
+		set<string> dng(dangerous.begin(), dangerous.end());
+
+		vector<bool> is_danger(N);
+
+		bool changed = true;
+		while( changed )
+		{
+			changed = false;
+			for(int i=0; i<N; ++i)
+				if( !is_danger[i] )
+				{
+					vector<string> buf;
+					set_intersection( kwd[i].begin(), kwd[i].end(), dng.begin(), dng.end(), back_inserter(buf) );
+					if( buf.size() >= threshold )
+					{
+						changed = true;
+						dng.insert(kwd[i].begin(), kwd[i].end());
+						is_danger[i] = true;
+					}
+				}
+		}
+
+		vector<string> result;
+		for(int i=0; i<N; ++i)
+			if( is_danger[i] )
+				result.push_back( address[i] );
+		return result;
+	}
+};
+
+// 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(_, InternetSecurity().determineWebsite(address, keyword, dangerous, threshold));}
+int main(){
+
+CASE(0)
+	string address_[] = {"www.topcoder.com",
+"www.sindicate_of_evil.com",
+"www.happy_citizens.com"};
+	  vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	string keyword_[] = {"hack encryption decryption internet algorithm",
+"signal interference evil snake poison algorithm",
+"flower baloon topcoder blue sky sea"};
+	  vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_)); 
+	string dangerous_[] = {"hack","encryption","decryption","interference","signal","internet"};
+	  vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_)); 
+	int threshold = 3; 
+	string __[] = {"www.topcoder.com", "www.sindicate_of_evil.com" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	string address_[] = {"brokenlink","flowerpower.net","purchasedomain.com"};
+	  vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	string keyword_[] = {"broken","rose tulips","cheap free domain biggest greatest"};
+	  vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_)); 
+	string dangerous_[] = {"biggest","enemy","hideout"};
+	  vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_)); 
+	int threshold = 2; 
+	vector <string> _; 
+END
+CASE(2)
+	string address_[] = {"a..a.ab.","...aa.b"};
+	  vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	string keyword_[] = {"a bc def","def ghij klmno"};
+	  vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_)); 
+	string dangerous_[] = {"a","b","c","d","e"};
+	  vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_)); 
+	int threshold = 1; 
+	string __[] = {"a..a.ab.", "...aa.b" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	string address_[] = {"www.tsa.gov"};
+	  vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	string keyword_[] = {"information assurance signal intelligence research"};
+	  vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_)); 
+	string dangerous_[] = {"signal","assurance","penguin"};
+	  vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_)); 
+	int threshold = 2; 
+	string __[] = {"www.tsa.gov" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+string address_[] = {"","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""};
+	  vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	  string keyword_[] = {"a b c d e f g h i j k l m n o p q r s t u v w x y",
+		  "A B C D E F G H I J K L M N O P Q R S T U V W X Y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y"};
+	  vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_)); 
+	  string dangerous_[] = {"a","b","c"};
+	  vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_)); 
+	int threshold = 3; 
+	string __[] = {"XXX"};
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(5)
+	string address_[] = ;
+	  vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_)); 
+	string keyword_[] = ;
+	  vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_)); 
+	string dangerous_[] = ;
+	  vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_)); 
+	int threshold = ; 
+	string __[] = ;
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/480-U/1B.cpp
Index: SRM/480-U/1B.cpp
==================================================================
--- SRM/480-U/1B.cpp
+++ SRM/480-U/1B.cpp
@@ -0,0 +1,59 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class NetworkSecurity { public:
+	int secureNetwork(vector <string> clientCable, vector <string> serverCable) 
+	{
+		int N = clientCable.size();
+		int M = serverCable[0].size();
+
+		vector< vector<int> > cd(N, vector<int>(N));
+		for(int i=0; i<N; ++i)
+			for(int j=0; j<N; ++j)
+				if( clientCable[i][j]=='Y' )
+					cd[i][j] = 1;
+		for(int k=0; k<N; ++k)
+			for(int i=0; i<N; ++i)
+				for(int j=0; j<N; ++j)
+					cd[i][j] |= cd[i][k] & cd[k][j];
+
+		int cnt = 0;
+		for(int i=0; i<N; ++i)
+			for(int j=0; j<M; ++j)
+			{
+				if( serverCable[i][j]=='Y' )
+				{
+					for(int k=0; k<N; ++k)
+						if( cd[i][k]==1 && serverCable[k][j]=='Y' )
+							goto next;
+					++cnt;
+				next:;
+				}
+			}
+		return cnt;
+	}
+};
+
+
+
+// Powered by FileEdit
+// Powered by TZTester 1.01 [25-Feb-2003] : <cafelier&naoya_t>-custom
+// Powered by CodeProcessor

ADDED   SRM/481/1A.cpp
Index: SRM/481/1A.cpp
==================================================================
--- SRM/481/1A.cpp
+++ SRM/481/1A.cpp
@@ -0,0 +1,101 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ChickenOracle { public:
+	string theTruth(int n, int eggCount, int lieCount, int liarCount) 
+	{
+		bool egg = canTruthTellerBe(   eggCount, n, lieCount, liarCount );
+		bool chk = canTruthTellerBe( n-eggCount, n, lieCount, liarCount );
+		if( egg && chk ) return "Ambiguous";
+		if( egg ) return "The egg";
+		if( chk ) return "The chicken";
+		return "The oracle is a lie";
+	}
+	bool canTruthTellerBe( int A, int n, int B, int  C )
+	{
+		int two_x = A+B+C - n;
+		if( (two_x&1) == 1 )
+			return false;
+		int x = two_x/2;
+		return 0<=x && x<=C && x<=B && (C-x)<=(n-B);
+	}
+};
+
+// 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(_, ChickenOracle().theTruth(n, eggCount, lieCount, liarCount));}
+int main(){
+
+CASE(0)
+	int n = 10; 
+	int eggCount = 10; 
+	int lieCount = 0; 
+	int liarCount = 0; 
+	string _ = "The egg"; 
+END
+CASE(1)
+	int n = 60; 
+	int eggCount = 40; 
+	int lieCount = 0; 
+	int liarCount = 30; 
+	string _ = "The oracle is a lie"; 
+END
+CASE(2)
+	int n = 60; 
+	int eggCount = 20; 
+	int lieCount = 5; 
+	int liarCount = 25; 
+	string _ = "The chicken"; 
+END
+CASE(3)
+	int n = 1000; 
+	int eggCount = 500; 
+	int lieCount = 250; 
+	int liarCount = 250; 
+	string _ = "Ambiguous"; 
+END
+CASE(4)
+	int n = 338919; 
+	int eggCount = 310645; 
+	int lieCount = 70422; 
+	int liarCount = 304279; 
+	string _ = "The oracle is a lie"; 
+END
+CASE(5)
+	int n = 1; 
+	int eggCount = 0; 
+	int lieCount = 0; 
+	int liarCount = 0; 
+	string _ = "The chicken"; 
+END
+}
+// END CUT HERE

ADDED   SRM/481/1B.cpp
Index: SRM/481/1B.cpp
==================================================================
--- SRM/481/1B.cpp
+++ SRM/481/1B.cpp
@@ -0,0 +1,128 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BatchSystemRoulette { public:
+	vector <double> expectedFinishTimes(vector <int> duration, vector <string> user) 
+	{
+		vector<double> answer(duration.begin(), duration.end());
+
+		map<string, LL> userSum;
+		for(int i=0; i<user.size(); ++i)
+			userSum[user[i]] += duration[i];
+		map<LL, vector<string> > usInv;
+		for(map<string,LL>::iterator it=userSum.begin(); it!=userSum.end(); ++it)
+			usInv[it->second].push_back(it->first);
+
+		double base = 0;
+		for(map<LL, vector<string> >::iterator it=usInv.begin(); it!=usInv.end(); ++it)
+		{
+			LL t = it->first;
+			vector<string>& us = it->second;
+			int n = us.size();
+
+			double baseAve = base + t*(n-1)/2.0;
+			for(int u=0; u<n; ++u)
+			{
+				vector<int> idxs;
+				for(int i=0; i<answer.size(); ++i)
+					if( user[i] == us[u] ) {
+						answer[i] += baseAve;
+						idxs.push_back(i);
+					}
+				for(int k=0; k<idxs.size(); ++k) {
+					int i = idxs[k];
+					for(int m=0; m<idxs.size(); ++m) if(m!=k) {
+						int j = idxs[m];
+						answer[i] += duration[j]/2.0;
+					}
+				}
+			}
+
+			base += t*n;
+		}
+
+		return answer;
+	}
+};
+
+// 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 <double>& Expected, const vector <double>& Received) {
+ bool ok = true;
+ for(int i=0; i<Expected.size(); ++i)
+   if( abs(Expected[i]-Received[i]) >= 1e-9 )
+     ok = false;
+ 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(_, BatchSystemRoulette().expectedFinishTimes(duration, user));}
+int main(){
+
+CASE(0)
+	int duration_[] = {3, 2, 4, 1};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	string user_[] = {"Gil Grissom", "Sarah Sidle", "Warrick Brown", "Catherine Willows"};
+	  vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_)); 
+	double __[] = {6.0, 3.0, 10.0, 1.0 };
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int duration_[] = {3, 2, 4, 1};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	string user_[] = {"mac taylor", "Mac Taylor", "Mac Taylor", "Peyton Driscoll"};
+	  vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_)); 
+	double __[] = {4.0, 8.0, 9.0, 1.0 };
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int duration_[] = {13, 14, 15, 56, 56};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	string user_[] = {"Tim Speedle", "Tim Speedle", "Tim Speedle", "Horatio Caine", "YEEEAAAAAAAAAAH"};
+	  vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_)); 
+	double __[] = {27.5, 28.0, 28.5, 126.0, 126.0 };
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(3)
+	int duration_[] = ;
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	string user_[] = ;
+	  vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_)); 
+	double __[] = ;
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	int duration_[] = ;
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	string user_[] = ;
+	  vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_)); 
+	double __[] = ;
+	  vector <double> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/481/1C.cpp
Index: SRM/481/1C.cpp
==================================================================
--- SRM/481/1C.cpp
+++ SRM/481/1C.cpp
@@ -0,0 +1,155 @@
+#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>
+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); }
+};
+
+int bitcnt(int U)
+{
+	int c = 0;
+	for(; U; U>>=1)
+		c += (U&1);
+	return c;
+}
+
+class TicketPrinters { public:
+	int minTime(int currentPrinter, vector <int> printerDistance, vector <int> startingValues, vector <int> wantedValues) 
+	{
+		int N = startingValues.size();
+
+		vector<int> d(N);
+		partial_sum( printerDistance.begin(), printerDistance.end(), d.begin()+1 );
+
+		// left, used, LeftOrRight
+		DP3<int> dp(N,1<<N,2);
+		for(int D=(1<<N)-1; D>=0; --D)
+		{
+			int bc = bitcnt(D);
+			for(int L=0; L<N && L+bc<=N; ++L)
+				for(int C=0; C<=1; ++C)
+				{
+					if( bc == N )
+						dp(L,D,C) = 0;
+					else {
+						int cur = (C==0 ? L : L+bc-1);
+						int mn = 0x7fffffff;
+						for(int nextW=0; nextW<N; ++nextW)
+							if( ((1<<nextW) & D) == 0 ) {
+								int caseLeft = 0x7fffffff;
+								if( L>0 ) {
+									caseLeft = d[cur] - d[L-1] + max(dp(L-1, D|1<<nextW, 0),
+										1+abs(startingValues[L-1]-wantedValues[nextW]));
+								}
+								int caseRight = 0x7fffffff;
+								if( L+bc < N ) {
+									caseRight = d[L+bc] - d[cur] + max(dp(L, D|1<<nextW, 1),
+										1+abs(startingValues[L+bc]-wantedValues[nextW]));
+								}
+								mn = min(mn, min(caseLeft, caseRight));
+							}
+						dp(L,D,C) = mn;
+					}
+				}
+		}
+		return dp(currentPrinter,0,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(_, TicketPrinters().minTime(currentPrinter, printerDistance, startingValues, wantedValues));}
+int main(){
+
+CASE(0)
+	int currentPrinter = 0; 
+	int printerDistance_[] = {100, 20, 50};
+	  vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_)); 
+	int startingValues_[] = {66, 78, 99, 5};
+	  vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_)); 
+	int wantedValues_[] = {99, 5, 78, 66};
+	  vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_)); 
+	int _ = 171; 
+END
+CASE(1)
+	int currentPrinter = 1; 
+	int printerDistance_[] = {50, 50};
+	  vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_)); 
+	int startingValues_[] = {100, 200, 300};
+	  vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_)); 
+	int wantedValues_[] = {101, 201, 302};
+	  vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_)); 
+	int _ = 152; 
+END
+CASE(2)
+	int currentPrinter = 2; 
+	int printerDistance_[] = {13, 26, 39, 13};
+	  vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_)); 
+	int startingValues_[] = {123, 12, 32, 67, 1015};
+	  vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_)); 
+	int wantedValues_[] = {1, 2, 3, 4, 5};
+	  vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_)); 
+	int _ = 1063; 
+END
+	/*
+CASE(3)
+	int currentPrinter = ; 
+	int printerDistance_[] = ;
+	  vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_)); 
+	int startingValues_[] = ;
+	  vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_)); 
+	int wantedValues_[] = ;
+	  vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_)); 
+	int _ = ; 
+END
+CASE(4)
+	int currentPrinter = ; 
+	int printerDistance_[] = ;
+	  vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_)); 
+	int startingValues_[] = ;
+	  vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_)); 
+	int wantedValues_[] = ;
+	  vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/482-U/1A.cpp
Index: SRM/482-U/1A.cpp
==================================================================
--- SRM/482-U/1A.cpp
+++ SRM/482-U/1A.cpp
@@ -0,0 +1,108 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class LockersDivOne { public:
+	int lastOpened(int N) 
+	{
+		vector<int> v;
+		for(int i=1; i<=N; ++i)
+			v.push_back(i);
+		int last = -1;
+		for(int s=2; !v.empty(); ++s) {
+			vector<int> vv;
+			for(int i=0; i<v.size(); ++i)
+				if( i%s>0 )
+					vv.push_back(v[i]);
+				else
+					last = v[i];
+			v.swap(vv);
+		}
+		return last;
+	}
+};
+
+// 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(_, LockersDivOne().lastOpened(N));}
+int main(){
+
+CASE(0)
+	int N = 9; 
+	int _ = 6; 
+END
+CASE(1)
+	int N = 42; 
+	int _ = 42; 
+END
+CASE(2)
+	int N = 314; 
+	int _ = 282; 
+END
+CASE(4)
+	int N = 1; 
+	int _ = 1; 
+END
+CASE(5)
+	int N = 2; 
+	int _ = 2; 
+END
+CASE(6)
+	int N = 3; 
+	int _ = 2; 
+END
+CASE(7)
+	int N = 4; 
+	int _ = 4; 
+END
+CASE(7)
+	int N = 5; 
+	int _ = 4; 
+END
+CASE(7)
+	int N = 6; 
+	int _ = 6; 
+END
+CASE(7)
+	int N = 7; 
+	int _ = 6; 
+END
+CASE(7)
+	int N = 8; 
+	int _ = 6; 
+END
+CASE(3)
+	int N = 2000000; 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/482-U/1B.cpp
Index: SRM/482-U/1B.cpp
==================================================================
--- SRM/482-U/1B.cpp
+++ SRM/482-U/1B.cpp
@@ -0,0 +1,115 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+int powi(int a, int b)
+{
+	int v=1;
+	for(int i=0; i<b; ++i)
+		v*=a;
+	return v;
+}
+
+class HanoiGoodAndBad { public:
+	int moves(int N, int Dave) 
+	{
+		if( N == 0 )
+			return 0;
+		if( Dave <= (1<<N-1)-1 )
+			return moves2(N-1, Dave);
+		return (powi(3,N-1))*2+moves3(N-1, Dave - (1<<N-1));
+	}
+	int moves2(int N, int Dave)
+	{
+		if( N == 0 )
+			return 0;
+		if( Dave <= (1<<N-1)-1 )
+			return moves(N-1, Dave);
+		return powi(3,N-1)+moves2(N-1, Dave - (1<<N-1));
+	}
+	int moves3(int N, int Dave)
+	{
+		if( N == 0 )
+			return 0;
+		if( Dave <= (1<<N-1)-1 )
+			return powi(3,N-1)+moves3(N-1, Dave);
+		return (powi(3,N-1))*2+moves(N-1, Dave - (1<<N-1));
+	}
+};
+
+// 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(_, HanoiGoodAndBad().moves(N, Dave));}
+int main(){
+
+CASE(0)
+	int N = 1; 
+	int Dave = 1; 
+	int _ = 2; 
+END
+CASE(0)
+	int N = 2; 
+	int Dave = 1; 
+	int _ = 2; 
+END
+CASE(0)
+	int N = 3; 
+	int Dave = 1; 
+	int _ = 2; 
+END
+CASE(1)
+	int N = 4; 
+	int Dave = 15; 
+	int _ = 80; 
+END
+CASE(2)
+	int N = 9; 
+	int Dave = 265; 
+	int _ = 16418; 
+END
+CASE(3)
+	int N = 1; 
+	int Dave = 0; 
+	int _ = 0; 
+END
+CASE(3)
+	int N = 1;
+	int Dave = 1; 
+	int _ = 2; 
+END
+CASE(4)
+	int N = 19; 
+	int Dave = (1<<19)-1; 
+	int _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/482-U/1C-U.cpp
Index: SRM/482-U/1C-U.cpp
==================================================================
--- SRM/482-U/1C-U.cpp
+++ SRM/482-U/1C-U.cpp
@@ -0,0 +1,173 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BalancingAct { public:
+	vector <string> recover(vector <int> labeled, vector <int> unlabeled) 
+	{
+		vector<int> same(unlabeled.size());
+		for(int i=0; i<same.size(); ++i)
+			same[i] = count(unlabeled.begin(), unlabeled.end(), unlabeled[i]);
+
+		set<unsigned int> canBeMade;
+		canBeMade.insert(0);
+		for(int i=0; i<labeled.size(); ++i) {
+			set<unsigned int> next;
+			for(set<unsigned int>::iterator it=canBeMade.begin(); it!=canBeMade.end(); ++it) {
+				if(*it+labeled[i] > *it )
+					next.insert(*it+labeled[i]);
+			}
+			canBeMade.insert(next.begin(), next.end());
+		}
+		vector<unsigned int> cbm(canBeMade.begin(), canBeMade.end());
+
+		vector<string> answer(unlabeled.size(), "no");
+		for(;;) {
+			bool updated = false;
+			for(int i=0; i<unlabeled.size(); ++i)
+				if( answer[i] == "no" ) {
+					unsigned int ul = unlabeled[i];
+					bool ok = false;
+					if( canMake(ul, cbm) )
+						ok = true;
+					else if( canMake(ul+1, cbm) && canMake(ul-1, cbm) )
+						ok = true;
+					else if( same[i]>=2 ) {
+						for(int k=2; k<=same[i]; ++k) {
+							if(canMake(ul*k, cbm))
+								{ok=true; break;}
+							bool lok = false, rok=false;
+							for(int j=1; j<=k; ++j) {
+								if(canMake(ul*k-j, cbm))
+									lok=true;
+								if(canMake(ul*k+j, cbm))
+									rok=true;
+								if(lok&&rok){ok=true; break;}
+							}
+						}
+					}
+
+					if( ok ) {
+						// update
+						updated = true;
+						answer[i] = "yes";
+						for(int k=0,ke=cbm.size(); k!=ke; ++k)
+							cbm.push_back(cbm[k]+unlabeled[i]);
+						sort(cbm.begin(), cbm.end());
+						cbm.erase(unique(cbm.begin(),cbm.end()), cbm.end());
+					}
+				}
+			if( !updated )
+				break;
+		}
+		return answer;
+	}
+
+	bool canMake( int t, vector<unsigned int>& cbm )
+	{
+		if( t==0 || t==100000001 )
+			return true;
+		if( binary_search(cbm.begin(), cbm.end(), t) )
+			return true;
+		for(vector<unsigned int>::iterator it=cbm.begin(); it!=cbm.end(); ++it)
+			if( binary_search(cbm.begin(), cbm.end(), t+*it) )
+				return true;
+		return false;
+	}
+};
+
+// 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(_, BalancingAct().recover(labeled, unlabeled));}
+int main(){
+
+CASE(0)
+	int labeled_[] = {9,13,15,16};
+	  vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_)); 
+	int unlabeled_[] = {19};
+	  vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_)); 
+	string __[] = {"yes" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int labeled_[] = {20};
+	  vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_)); 
+	int unlabeled_[] = {10,10};
+	  vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_)); 
+	string __[] = {"yes", "yes" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int labeled_[] = {33333332,33333334};
+	  vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_)); 
+	int unlabeled_[] = {33333333,73,100000000};
+	  vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_)); 
+	string __[] = {"yes", "no", "yes" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	int labeled_[] = {12};
+	  vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_)); 
+	int unlabeled_[] = {1,1,2,2};
+	  vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_)); 
+	string __[] = {"yes", "yes", "yes", "yes" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	int labeled_[] = {31415926,5358979,32384626,43383279,50288419,
+71693993,75105820,9749445,92307816,40628620,
+89986280,34825342,11706798,21480865,13282306};
+	  vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_)); 
+	int unlabeled_[] = {64709384,46095505,82231725,35940812};
+	  vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_)); 
+	string __[] = {"no", "no", "no", "no" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+int labeled_[] = {1,2,4,8,16,32,64,128,256,512,1024,2048*1,2048*2,2048*4,2048*8,2048*16,2048*32,2048*64,2048*128,2048*256};
+	  vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_)); 
+	  int unlabeled_[] = {999, 888, 777, 666};
+	  vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_)); 
+	  string __[] = {"yes","yes","yes","yes"};
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(6)
+	int labeled_[] = ;
+	  vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_)); 
+	int unlabeled_[] = ;
+	  vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_)); 
+	string __[] = ;
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/484-U/1A.cpp
Index: SRM/484-U/1A.cpp
==================================================================
--- SRM/484-U/1A.cpp
+++ SRM/484-U/1A.cpp
@@ -0,0 +1,115 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class RabbitNumber { public:
+	LL dsum(LL n) {
+		LL x = 0;
+		while(n) {
+			x+=n%10;
+			n/=10;
+		}
+		return x;
+	}
+	bool isRabbit(LL n) {
+		LL a = dsum(n);
+		LL b = dsum(n*n);
+		return b==a*a;
+	}
+	void enumerate(int s, LL c, vector<int>& v)
+	{
+		if( c > 1000000000 )
+			return;
+		if( s == 0 )
+			if( isRabbit(c) )
+				v.push_back(int(c));
+		for(int i=(c==0?1:0); i<=s && i<=9; ++i)
+			enumerate(s-i, c*10+i, v);
+	}
+
+	int theCount(int low, int high) 
+	{
+		vector<int> v;
+		for(int s=1; s<=15; ++s)
+			enumerate(s, 0, v);
+		sort(v.begin(), v.end());
+		return upper_bound(v.begin(), v.end(), high)
+		     - lower_bound(v.begin(), v.end(), low);
+	}
+};
+
+// 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(_, RabbitNumber().theCount(low, high));}
+int main(){
+
+CASE(0)
+	int low = 22; 
+	int high = 22; 
+	int _ = 1; 
+END
+CASE(1)
+	int low = 484; 
+	int high = 484; 
+	int _ = 0; 
+END
+CASE(2)
+	int low = 1; 
+	int high = 58; 
+	int _ = 12; 
+END
+CASE(3)
+	int low = 58; 
+	int high = 484; 
+	int _ = 24; 
+END
+CASE(4)
+	int low = 1000000000; 
+	int high = 1000000000; 
+	int _ = 1; 
+END
+CASE(5)
+	int low = 1; 
+	int high = 1; 
+	int _ = 1; 
+END
+CASE(6)
+	int low = 1; 
+	int high = 1000000; 
+	int _ = 615; 
+END
+CASE(7)
+	int low = 1; 
+	int high = 1000000000; 
+	int _ = -1; 
+END
+}
+// END CUT HERE

ADDED   SRM/484-U/1B.cpp
Index: SRM/484-U/1B.cpp
==================================================================
--- SRM/484-U/1B.cpp
+++ SRM/484-U/1B.cpp
@@ -0,0 +1,109 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000007;
+
+class PuyoPuyo { public:
+	int theCount(int L, int N) 
+	{
+		// A4 ::= U*
+		// U  ::= x A3 x A3 x A3 x   (U::=U[0],  U[i]::=x A3 U[i+1],  U[L-1]::=x)
+
+		vector<LL>           A4(N+1), A3(N+1);
+		vector< vector<LL> > U(L, vector<LL>(N+1));
+
+		A4[0] = A3[0] = U[L-1][1] = 1;
+		for(int n=1; n<=N; ++n) {
+			for(int k=L-2; k>=0; --k)
+				for(int z=0; n-z-1>=1; z+=L)
+					U[k][n] = (U[k][n] + A3[z]*U[k+1][n-z-1]) % MODVAL;
+			for(int i=L; i<=n; i+=L)
+				A4[n] = (A4[n] + 4*U[0][i]*A4[n-i]) % MODVAL;
+			for(int i=L; i<=n; i+=L)
+				A3[n] = (A3[n] + 3*U[0][i]*A3[n-i]) % MODVAL;
+		}
+		return int(A4[N]);
+	}
+};
+
+// 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(_, PuyoPuyo().theCount(L, N));}
+int main(){
+
+CASE(0)
+	int L = 2; 
+	int N = 2; 
+	int _ = 4; 
+END
+CASE(1)
+	int L = 2; 
+	int N = 4; 
+	int _ = 28; 
+END
+CASE(2)
+	int L = 2; 
+	int N = 58; 
+	int _ = 868294620; 
+END
+CASE(3)
+	int L = 4; 
+	int N = 84; 
+	int _ = 621871151; 
+END
+CASE(4)
+	int L = 5; 
+	int N = 8; 
+	int _ = 0; 
+END
+CASE(5)
+	int L = 2; 
+	int N = 1; 
+	int _ = 0; 
+END
+CASE(6)
+	int L = 2; 
+	int N = 1000; 
+	int _ = -1; 
+END
+CASE(7)
+	int L = 2; 
+	int N = 6; 
+	int _ = 232; 
+END
+CASE(8)
+	int L = 2; 
+	int N = 8; 
+	int _ = 2092; 
+END
+}
+// END CUT HERE

ADDED   SRM/484-U/2C.cpp
Index: SRM/484-U/2C.cpp
==================================================================
--- SRM/484-U/2C.cpp
+++ SRM/484-U/2C.cpp
@@ -0,0 +1,104 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CubeColoring { public:
+	long long theCount(vector <string> colors)
+	{
+		const int NC = colors[0].size();
+
+		int c1=0,c3=0,c4=0,c6=0;
+		for(int i=0; i<NC; ++i) {
+			c1 += colors[1][i]=='Y';
+			c3 += colors[3][i]=='Y';
+			c4 += colors[4][i]=='Y';
+			c6 += colors[6][i]=='Y';
+		}
+		LL answer = 0;
+		for(int i0=0; i0<NC; ++i0) if(colors[0][i0]=='Y')
+		for(int i2=0; i2<NC; ++i2) if(colors[2][i2]=='Y')
+		for(int i5=0; i5<NC; ++i5) if(colors[5][i5]=='Y')
+		for(int i7=0; i7<NC; ++i7) if(colors[7][i7]=='Y')
+		{
+			int cc1 = c1 - (colors[1][i0]=='Y') - (i0!=i2 && colors[1][i2]=='Y') - (i0!=i5 && i2!=i5 && colors[1][i5]=='Y');
+			int cc3 = c3 - (colors[3][i0]=='Y') - (i0!=i2 && colors[3][i2]=='Y') - (i0!=i7 && i2!=i7 && colors[3][i7]=='Y');
+			int cc4 = c4 - (colors[4][i0]=='Y') - (i0!=i5 && colors[4][i5]=='Y') - (i0!=i7 && i5!=i7 && colors[4][i7]=='Y');
+			int cc6 = c6 - (colors[6][i2]=='Y') - (i2!=i5 && colors[6][i5]=='Y') - (i2!=i7 && i5!=i7 && colors[6][i7]=='Y');
+			answer += cc1*cc3*cc4*cc6;
+		}
+		return answer;
+	}
+};
+
+// 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(_, CubeColoring().theCount(colors));}
+int main(){
+
+CASE(0)
+	string colors_[] = {"Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y"};
+	  vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_)); 
+	long long _ = 0LL; 
+END
+CASE(1)
+	string colors_[] = {"YNNNNNNN", "NYNNNNNN", "NNYNNNNN", "NNNYNNNN", "NNNNYNNN", "NNNNNYNN", "NNNNNNYN", "NNNNNNNY"};
+	  vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_)); 
+	long long _ = 1LL; 
+END
+CASE(2)
+	string colors_[] = {"YNNYN", "YYYYY", "NYYNY", "YNYYN", "YNNYY", "YNNYY", "NNNYY", "NYYYY"};
+	  vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_)); 
+	long long _ = 250LL; 
+END
+CASE(3)
+	string colors_[] = {"YNNYN", "YYYYY", "NNNNN", "YNYYN", "YNNYY", "YNNYY", "NNNYY", "NYYYY"};
+	  vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_)); 
+	long long _ = 0LL; 
+END
+CASE(4)
+	string colors_[] = {"YNNYNYYYYYNN", "NNNYNYYNYNNY", "YYNNYYNNNYYN", "YYYYYNNYYYNN", "NNNYYYNNYNYN", "YYYNYYYYNYNN", "NNNNNNYYNYYN", "NNYNYYNNYNYY"};
+	  vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_)); 
+	long long _ = 611480LL; 
+END
+/*
+CASE(5)
+	string colors_[] = ;
+	  vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_)); 
+	long long _ = LL; 
+END
+CASE(6)
+	string colors_[] = ;
+	  vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_)); 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/485-U/1A.cpp
Index: SRM/485-U/1A.cpp
==================================================================
--- SRM/485-U/1A.cpp
+++ SRM/485-U/1A.cpp
@@ -0,0 +1,117 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class AfraidOfEven { public:
+	vector <int> restoreProgression(vector <int> seq) 
+	{
+		LL a = seq[0];
+		LL b = seq[1];
+		for(LL aa=a; aa<=0x7fffffff; aa*=2)
+		for(LL bb=b; bb<=0x7fffffff; bb*=2)
+			if( possible(seq,aa,bb) )
+				return seq;
+		assert(false);
+	}
+	bool possible(vector<int>& seq, LL a, LL b)
+	{
+		LL d = b-a;
+		vector<LL> q(seq.size());
+		q[0] = a;
+		q[1] = b;
+		for(int i=2; i<seq.size(); ++i)
+		{
+			q[i] = q[i-1] + d;
+			if( q[i] <= 0 )
+				return false;
+			if( q[i] % seq[i] != 0 )
+				return false;
+			LL f = q[i] / seq[i];
+			if( f & (f-1) )
+				return false;
+		}
+		for(int i=0; i<seq.size(); ++i)
+			seq[i] = int(q[i]);
+		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 vector <int>& Expected, const vector <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(_, AfraidOfEven().restoreProgression(seq));}
+int main(){
+
+CASE(0)
+	int seq_[] = {1, 1, 3, 1, 5};
+	  vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_)); 
+	int __[] = {1, 2, 3, 4, 5 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int seq_[] = {9, 7, 5, 3, 1};
+	  vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_)); 
+	int __[] = {9, 7, 5, 3, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int seq_[] = {999, 999, 999, 999};
+	  vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_)); 
+	int __[] = {999, 999, 999, 999 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	int seq_[] = {7, 47, 5, 113, 73, 179, 53};
+	  vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_)); 
+	int __[] = {14, 47, 80, 113, 146, 179, 212 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	int seq_[] = {749, 999, 125, 1};
+	  vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_)); 
+	int __[] = {1498, 999, 500, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+int seq_[] = {3,7,1,9};
+	  vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_)); 
+	  int __[] = {6,7,8,9};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(6)
+	int seq_[] = ;
+	  vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_)); 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/485-U/1B.cpp
Index: SRM/485-U/1B.cpp
==================================================================
--- SRM/485-U/1B.cpp
+++ SRM/485-U/1B.cpp
@@ -0,0 +1,173 @@
+#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>
+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 RectangleAvoidingColoring { public:
+	long long count(vector <string> board) 
+	{
+		int H = board.size();
+		int W = board[0].size();
+		// o????
+		// o????
+		// xooxo
+		// xoxoo
+		// xxooo
+		if( H>=5 && W>=5 )
+			return 0;
+		if( H >= 5 )
+			transpose(board, H, W);
+		// H <= 4
+
+		int BADPAT = H*(H-1)/2;
+		DP3<LL> dp(1<<BADPAT, 1<<BADPAT, W+1);
+		dp(0,0,0) = 1;
+		for(int i=0; i<W; ++i)
+		for(int BlackBad=0; BlackBad<(1<<BADPAT); BlackBad++)
+		for(int WhiteBad=0; WhiteBad<(1<<BADPAT); WhiteBad++)
+		{
+			for(int pat=0; pat<(1<<H); ++pat) {
+				int bbb = bb(pat,H);
+				int wbb = wb(pat,H);
+				if( possible(pat, board, i, H) && !(bbb&BlackBad) && !(wbb&WhiteBad) )
+					dp(BlackBad|bbb,WhiteBad|wbb,i+1) += dp(BlackBad,WhiteBad,i);
+			}
+		}
+		LL sum = 0;
+		for(int BlackBad=0; BlackBad<(1<<BADPAT); BlackBad++)
+		for(int WhiteBad=0; WhiteBad<(1<<BADPAT); WhiteBad++)
+			sum += dp(BlackBad,WhiteBad,W);
+		return sum;
+	}
+	bool possible(int pat, const vector<string>& board, int i, int H)
+	{
+		for(int y=0; y<H; ++y) {
+			if( board[y][i]=='B' && !(pat&(1<<y))) return false;
+			if( board[y][i]=='W' && (pat&(1<<y))) return false;
+		}
+		return true;
+	}
+	int bb(int pat,int H)
+	{
+		int mask = 0, idx=0;
+		for(int i=0; i<H; ++i)
+		for(int j=i+1; j<H; ++j,++idx)
+			if(pat & (1<<i))
+			if(pat & (1<<j))
+				mask |= (1<<idx);
+		return mask;
+	}
+	int wb(int pat,int H)
+	{
+		int mask = 0, idx=0;
+		for(int i=0; i<H; ++i)
+		for(int j=i+1; j<H; ++j,++idx)
+			if(!(pat & (1<<i)))
+			if(!(pat & (1<<j)))
+				mask |= (1<<idx);
+		return mask;
+	}
+	void transpose(vector<string>& b, int& H, int& W)
+	{
+		vector<string> bb(W);
+		for(int x=0; x<W; ++x)
+			for(int y=0; y<H; ++y)
+				bb[x] += b[y][x];
+		swap(H, W);
+		b = bb;
+	}
+};
+
+// 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(_, RectangleAvoidingColoring().count(board));}
+int main(){
+
+CASE(0)
+	string board_[] = {"??",
+ "??"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	long long _ = 14LL; 
+END
+CASE(1)
+	string board_[] = {"B?",
+ "?B"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	long long _ = 3LL; 
+END
+CASE(2)
+	string board_[] = {"WW",
+ "WW"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	long long _ = 0LL; 
+END
+CASE(3)
+	string board_[] = {"??B??",
+ "W???W",
+ "??B??"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	long long _ = 12LL; 
+END
+CASE(4)
+	string board_[] = {"??",
+ "W?",
+ "W?",
+ "?W",
+ "W?"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	long long _ = 16LL; 
+END
+/*
+CASE(5)
+	string board_[] = {};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	long long _ = LL; 
+END
+CASE(6)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/485-U/1C-U.cpp
Index: SRM/485-U/1C-U.cpp
==================================================================
--- SRM/485-U/1C-U.cpp
+++ SRM/485-U/1C-U.cpp
@@ -0,0 +1,199 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Deposit { public:
+	vector<CMP> make_polygon(const vector<int>& xs, const vector<int>& ys)
+	{
+		vector<CMP> vs;
+		for(int i=0; i<xs.size(); ++i)
+			vs.push_back( CMP(xs[i], ys[i]) );
+		return vs;
+	}
+
+	double successProbability(vector <int> siteX, vector <int> siteY, vector <int> depositX, vector <int> depositY) 
+	{
+		const vector<CMP> ss = make_polygon(siteX, siteY);
+		const vector<CMP> dd = make_polygon(depositX, depositY);
+		const int SN = ss.size();
+
+		double totallen=0, hitlen=0;
+		for(int i=0; i<SN; ++i)
+		{
+			const CMP p0 = ss[i];
+			const CMP p1 = ss[(i+1)%SN];
+			totallen += abs(p1-p0);
+
+
+			CMP pv = p1 - p0; pv /= abs(pv);
+
+			// calc furthest on p0 - p1
+			double q = 1.0;
+			for(int k=i+1; k!=i; k=(k+1)%SN)
+			{
+				const CMP q0 = ss[k];
+				const CMP q1 = ss[(k+1)%SN];
+				// compute vertical-eqsplitter of lineseg q0 - q1
+				CMP mid = (q0+q1)/2.0;
+				CMP vec = (q0-q1)*CMP(0,1);;
+				// compute crossing with p0 - p1
+				double qq = solve(p0,pv,mid,vec);
+				if( qq < q )
+				{
+					if( qq <= 0.0 )
+						qq = 0.0;
+					// in (qq,q), furthest is q1
+					// [todo] compute the fraction of the region crossing with the deposit
+					// by ternery search or something like that
+					double r = computeFractionOfCross(p0+qq*pv, p0+q*pv, q1, dd);
+
+					hitlen += abs(p0-p1)*(q-qq)*r;
+					q = qq;
+				}
+				if( q == 0.0 )
+					break;
+			}
+		}
+		return hitlen / totallen;
+	}
+	double solve(CMP a, CMP b, CMP c, CMP d)
+	{
+		// solve: a + <return ?>*b == c + ??*d
+		return -1;
+	}
+	double computeFractionOfCross(CMP p0, CMP p1, CMP q, const vector<CMP>& d)
+	{
+		// retur the fraction of k in [0,1]  s.t.  line (p0 + k(p1-p0)) to q crosses d.
+		return -1;
+	}
+};
+
+// 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(_, Deposit().successProbability(siteX, siteY, depositX, depositY));}
+int main(){
+
+CASE(0)
+	int siteX_[] = {0,4,4,0};
+	  vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_)); 
+	int siteY_[] = {0,0,4,4};
+	  vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_)); 
+	int depositX_[] = {1,2,2,1};
+	  vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_)); 
+	int depositY_[] = {1,1,2,2};
+	  vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_)); 
+	double _ = 0.6666666666666666; 
+END
+CASE(1)
+	int siteX_[] = {0,4,4,0};
+	  vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_)); 
+	int siteY_[] = {0,0,4,4};
+	  vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_)); 
+	int depositX_[] = {1,3,3,1};
+	  vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_)); 
+	int depositY_[] = {1,1,3,3};
+	  vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_)); 
+	double _ = 1.0; 
+END
+CASE(2)
+	int siteX_[] = {5,2,-1,0,4};
+	  vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_)); 
+	int siteY_[] = {3,4,2,0,0};
+	  vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_)); 
+	int depositX_[] = {3,3,4};
+	  vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_)); 
+	int depositY_[] = {3,2,1};
+	  vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_)); 
+	double _ = 0.6112700209855423; 
+END
+CASE(3)
+	int siteX_[] = {200,-99,-405,-601,-708,-494,-300,-88};
+	  vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_)); 
+	int siteY_[] = {520,516,407,321,104,-97,-221,-101};
+	  vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_)); 
+	int depositX_[] = {-101,-201,-296,-400,-402};
+	  vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_)); 
+	int depositY_[] = {318,396,402,305,200};
+	  vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_)); 
+	double _ = 0.49892756207100747; 
+END
+CASE(4)
+	int siteX_[] = {-3,6,10,10,-2};
+	  vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_)); 
+	int siteY_[] = {-1,-10,-9,7,3};
+	  vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_)); 
+	int depositX_[] = {3,5,6,4};
+	  vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_)); 
+	int depositY_[] = {-5,-7,-6,-4};
+	  vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_)); 
+	double _ = 0.16641662251521538; 
+END
+CASE(5)
+	int siteX_[] = {-2,4,-2}
+;
+	  vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_)); 
+	int siteY_[] = {-2,-2,8}
+;
+	  vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_)); 
+	int depositX_[] = {-1,0,0}
+;
+	  vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_)); 
+	int depositY_[] = {0,-1,0}
+;
+	  vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_)); 
+	double _ = 0.04518850219072291; 
+END
+/*
+CASE(6)
+	int siteX_[] = ;
+	  vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_)); 
+	int siteY_[] = ;
+	  vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_)); 
+	int depositX_[] = ;
+	  vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_)); 
+	int depositY_[] = ;
+	  vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_)); 
+	double _ = ; 
+END
+CASE(7)
+	int siteX_[] = ;
+	  vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_)); 
+	int siteY_[] = ;
+	  vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_)); 
+	int depositX_[] = ;
+	  vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_)); 
+	int depositY_[] = ;
+	  vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_)); 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/486/1A.cpp
Index: SRM/486/1A.cpp
==================================================================
--- SRM/486/1A.cpp
+++ SRM/486/1A.cpp
@@ -0,0 +1,137 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class OneRegister { public:
+	string getProgram(int s, int t) 
+	{
+		string x = run("",s,t);
+		string y = run("/",1, t);
+		string z = takeMin(x,y);
+		return z=="NO" ? ":-(" : z;
+	}
+
+	string takeMin(const string& x, const string& y)
+	{
+		if( x == "NO" )
+			return y;
+		else if( y == "NO" )
+			return x;
+		else
+			return (x.size()<y.size() ? x : (x.size()==y.size() ? min(x,y) : y));
+	}
+
+	// by using only '*' and '+'
+	string run(const string& buf, LL s, LL t)
+	{
+		if( s == t )
+			return buf;
+		if( s > t )
+			return "NO";
+		string x = run(buf+"+", s+s, t);
+		string y = (s==1 ? "NO" : run(buf+"*", s*s, t));
+		return takeMin(x,y);
+	}
+};
+
+// 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(_, OneRegister().getProgram(s, t));}
+int main(){
+
+CASE(0)
+	int s = 7; 
+	int t = 392; 
+	string _ = "+*+"; 
+END
+CASE(1)
+	int s = 7; 
+	int t = 256; 
+	string _ = "/+***"; 
+END
+CASE(2)
+	int s = 4; 
+	int t = 256; 
+	string _ = "**"; 
+END
+CASE(3)
+	int s = 7; 
+	int t = 7; 
+	string _ = ""; 
+END
+CASE(4)
+	int s = 7; 
+	int t = 9; 
+	string _ = ":-("; 
+END
+CASE(5)
+	int s = 10; 
+	int t = 1; 
+	string _ = "/"; 
+END
+CASE(6)
+	int s = 1; 
+	int t = 1000000000; 
+	string _ = "dummy"; 
+END
+CASE(6)
+	int s = 2; 
+	int t = 1<<30; 
+	string _ = "dummy"; 
+END
+CASE(7)
+	int s = 1000000000; 
+	int t = 1; 
+	string _ = "dummy"; 
+END
+CASE(8)
+	int s = 1; 
+	int t = 1; 
+	string _ = ""; 
+END
+CASE(9)
+	int s = 2; 
+	int t = 2; 
+	string _ = ""; 
+END
+CASE(10)
+	int s = 1; 
+	int t = 2; 
+	string _ = "+"; 
+END
+CASE(11)
+	int s = 512; 
+	int t = 65536; 
+	string _ = "*"; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/486/1B.cpp
Index: SRM/486/1B.cpp
==================================================================
--- SRM/486/1B.cpp
+++ SRM/486/1B.cpp
@@ -0,0 +1,111 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class QuickSort { public:
+	double getEval(vector <int> L) 
+	{
+		int m = *min_element(L.begin(), L.end());
+		int M = *max_element(L.begin(), L.end());
+		return rec(L, m, M+1);
+	}
+	map<pair<int,int>, double> memo;
+	double rec(const vector<int>& L, int m, int M)
+	{
+		pair<int,int> key(m,M);
+		if(memo.count(key))
+			return memo[key];
+
+		vector<int> c;
+		for(int i=0; i<L.size(); ++i)
+			if( m<=L[i] && L[i]<M )
+				c.push_back(L[i]);
+
+		if( c.size() <= 1 )
+			return memo[key] = 0;
+
+		double e = 0;
+		for(int k=0; k<c.size(); ++k)
+		{
+			int p = c[k];
+			int cnt = 0;
+			for(int i=0; i<k; ++i)
+				if( c[i] > p )
+					++cnt;
+			for(int i=k+1; i<c.size(); ++i)
+				if( p > c[i] )
+					++cnt;
+			e += rec(L, m, p) + rec(L, p+1, M) + cnt;
+		}
+
+		return memo[key] = e / c.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 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(_, QuickSort().getEval(L));}
+int main(){
+
+CASE(0)
+	int L_[] = {1,2,3,4,5};
+	  vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_)); 
+	double _ = 0.0; 
+END
+CASE(1)
+	int L_[] = {1,2,4,3,5,6};
+	  vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_)); 
+	double _ = 1.0; 
+END
+CASE(2)
+	int L_[] = {3,2,1};
+	  vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_)); 
+	double _ = 2.6666666666666665; 
+END
+CASE(3)
+	int L_[] = {50,40,30,20,10,15,25,35,45};
+	  vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_)); 
+	double _ = 11.07698412698413; 
+END
+CASE(4)
+	int L_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
+	31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
+	  vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_)); 
+	double _ = -1; 
+END
+CASE(5)
+	int L_[] = {48,49,50,10,11,12,40,41,42,5,39,32,33,34,43,44,45,46,6,7,8,9,22,23,24,25,26,27,28,29,30,
+	31,13,1,2,3,4,35,36,37,38,47,14,15,16,17,18,19,20,21};
+	  vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_)); 
+	double _ = -1; 
+END
+}
+// END CUT HERE

ADDED   SRM/486/1C.cpp
Index: SRM/486/1C.cpp
==================================================================
--- SRM/486/1C.cpp
+++ SRM/486/1C.cpp
@@ -0,0 +1,180 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
+double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
+
+int ccw(const CMP& a, CMP b, CMP c) {
+	b -= a; c -= a;
+	if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
+	if( outer_prod(b,c) < 0 ) return -1; // clockwise
+	if( inner_prod(b,c) < 0 ) return +2; // c--a--b on line
+	if( norm(b) < norm(c) )   return -2; // a--b--c on line
+	return 0;
+}
+
+bool byX( const CMP& a, const CMP& b ) {
+	if( a.real() != b.real() )
+		return a.real() < b.real();
+	return a.imag() < b.imag();
+}
+
+vector<CMP> convex_hull( vector<CMP> p )
+{
+	#define IS_RIGHT <0   // skip on-line verts
+	//#define IS_RIGHT ==-1 // take all
+
+	sort(p.begin(), p.end(), &byX);
+
+	vector<CMP> ans;
+	for(int i=0; i<p.size(); ans.push_back(p[i++])) // left-to-right
+		while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
+			ans.pop_back();
+	if( ans.size() == p.size() )
+		return ans;
+	for(int i=p.size()-2; i>=0; ans.push_back(p[i--])) // right-to-left
+		while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
+			ans.pop_back();
+	ans.pop_back();
+	return ans;
+}
+
+double area( const vector<CMP>& q )
+{
+	double a = 0.0;
+
+	CMP o = q[0];
+	for(int i=1; i+1<q.size(); ++i)
+		a += outer_prod(q[i]-o, q[i+1]-o);
+	return abs(a)/2;
+}
+
+class BatmanAndRobin { public:
+	double minArea(vector <int> x, vector <int> y) 
+	{
+		int N = x.size();
+		vector<CMP> p;
+		for(int i=0; i<N; ++i)
+			p.push_back(CMP(x[i],y[i]));
+
+		const double eps = 1e-6;
+		CMP diff[] = {CMP(eps,0), CMP(0,eps), CMP(-eps,0), CMP(0,-eps)};
+		double answer = area(convex_hull(p));
+		for(int i=0; i<N; ++i)
+			for(int j=i+1; j<N; ++j) {
+				for(int di=0; di<4; ++di)
+					for(int dj=0; dj<4; ++dj) {
+						vector<CMP> a = left_of(p, p[i]+diff[di], p[j]+diff[dj]);
+						vector<CMP> b = right_of(p, p[i]+diff[di], p[j]+diff[dj]);
+						double aa = a.size()<=2 ? 0 : area(convex_hull(a));
+						double bb = b.size()<=2 ? 0 : area(convex_hull(b));
+						answer = min(answer, max(aa,bb));
+					}
+			}
+		return answer;
+	}
+
+	vector<CMP> left_of(const vector<CMP>& p, const CMP& o, CMP v)
+	{
+		v -= o;
+		vector<CMP> r;
+		for(int i=0; i<p.size(); ++i)
+			if( is_left(p[i]-o, v) )
+				r.push_back(p[i]);
+		return r;
+	}
+	vector<CMP> right_of(const vector<CMP>& p, const CMP& o, CMP v)
+	{
+		v -= o;
+		vector<CMP> r;
+		for(int i=0; i<p.size(); ++i)
+			if( !is_left(p[i]-o, v) )
+				r.push_back(p[i]);
+		return r;
+	}
+	bool is_left(const CMP& p, const CMP& v)
+	{
+		return arg(p/v)>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 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(_, BatmanAndRobin().minArea(x, y));}
+int main(){
+
+CASE(0)
+	int x_[] = {100,100,90,90,-100,-100,-90,-90};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {100,90,100,90,-100,-90,-100,-90};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	double _ = 100.0; 
+END
+CASE(1)
+	int x_[] = {-1000,-1000,1000,1000,1000,-1000};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-1000,1000,-1000,1000,0,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	double _ = 0.0; 
+END
+CASE(2)
+	int x_[] = {-1000,-1000,1000,1000,0};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-1000,1000,-1000,1000,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	double _ = 1000000.0; 
+END
+CASE(3)
+	int x_[] = {-904,-812,-763,-735,-692,-614,-602,-563,-435,-243,-87,-52,-28,121,126,149,157,185,315,336,390,470,528,591,673,798,815,837,853,874};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {786,10,-144,949,37,-857,-446,-969,-861,-712,5,-972,-3,-202,-845,559,-244,-542,-421,422,526,-501,-791,-899,-315,281,-275,467,743,-321};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	double _ = 1067472.0; 
+END
+CASE(4)
+	int x_[] = {-904,-812,-763,-735,-692,-614,-602,-563,-435,-243,-87,-52,-28,121,126,149,157,185,315,336,390,470,528,591,673,798,815,837,853,874,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {786,10,-144,949,37,-857,-446,-969,-861,-712,5,-972,-3,-202,-845,559,-244,-542,-421,422,526,-501,-791,-899,-315,281,-275,467,743,-321,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	double _ = -1; 
+END
+/*
+CASE(5)
+	int x_[] = ;
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = ;
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/486/2C.cpp
Index: SRM/486/2C.cpp
==================================================================
--- SRM/486/2C.cpp
+++ SRM/486/2C.cpp
@@ -0,0 +1,128 @@
+#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>
+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 CrazyLine { public:
+	int maxCrazyness(vector <int> heights) 
+	{
+		typedef pair< int, pair<int,int> > cand;
+		priority_queue<cand> Q;
+		for(int i=0; i<heights.size(); ++i)
+		for(int j=i+1; j<heights.size(); ++j)
+			Q.push( cand(abs(heights[i]-heights[j]), make_pair(i,j)) );
+
+		UnionFind uf(heights.size());
+
+		int score=0;
+		vector<int> used(heights.size());
+		while( uf.size()>1 )
+		{
+			int s = Q.top().first;
+			int i = Q.top().second.first;
+			int j = Q.top().second.second;
+			Q.pop();
+			if( used[i]<=1 && used[j]<=1 && uf.Find(i)!=uf.Find(j) )
+			{
+				score += s;
+				used[i]++;
+				used[j]++;
+				uf.Union(i,j);
+			}
+		}
+		return 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(_, CrazyLine().maxCrazyness(heights));}
+int main(){
+
+CASE(0)
+	int heights_[] = {5,10,25,40,25};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int _ = 100; 
+END
+CASE(1)
+	int heights_[] = {2,3,5,7,11,13,17,19};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int _ = 82; 
+END
+CASE(2)
+	int heights_[] = {1,1,1,1,1,1,501};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int _ = 1000; 
+END
+CASE(3)
+	int heights_[] = {1000,1000,1000,1000,1000,1000,1000,1000,1000};
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int _ = 0; 
+END
+/*
+CASE(4)
+	int heights_[] = ;
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int _ = ; 
+END
+CASE(5)
+	int heights_[] = ;
+	  vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/487/1A.cpp
Index: SRM/487/1A.cpp
==================================================================
--- SRM/487/1A.cpp
+++ SRM/487/1A.cpp
@@ -0,0 +1,102 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BunnyComputer { public:
+	int getMaximum(vector <int> preference, int k) 
+	{
+		int sum = 0;
+
+		int N = preference.size();
+		for(int s=0; s<=k && s<N; ++s)
+		{
+			vector<int> sub;
+			for(int i=s; i<N; i+=1+k)
+				sub.push_back( preference[i] );
+			sum += accumulate(sub.begin(), sub.end(), 0);
+			if( sub.size() % 2 == 1 )
+			{
+				vector<int> skip;
+				for(int i=0; i<sub.size(); i+=2)
+					skip.push_back( sub[i] );
+				sum -= *min_element(skip.begin(), skip.end());
+			}
+		}
+
+		return sum;
+	}
+};
+
+// 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(_, BunnyComputer().getMaximum(preference, k));}
+int main(){
+
+CASE(0)
+	int preference_[] = { 3, 1, 4, 1, 5, 9, 2, 6 };
+	  vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_)); 
+	int k = 2; 
+	int _ = 28; 
+END
+CASE(1)
+	int preference_[] = { 3, 1, 4, 1, 5, 9, 2, 6 };
+	  vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_)); 
+	int k = 1; 
+	int _ = 31; 
+END
+CASE(2)
+	int preference_[] = { 1, 2, 3, 4, 5, 6 };
+	  vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_)); 
+	int k = 3; 
+	int _ = 14; 
+END
+CASE(3)
+	int preference_[] = { 487, 2010 };
+	  vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_)); 
+	int k = 2; 
+	int _ = 0; 
+END
+/*
+CASE(4)
+	int preference_[] = ;
+	  vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_)); 
+	int k = ; 
+	int _ = ; 
+END
+CASE(5)
+	int preference_[] = ;
+	  vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_)); 
+	int k = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/487/1B.cpp
Index: SRM/487/1B.cpp
==================================================================
--- SRM/487/1B.cpp
+++ SRM/487/1B.cpp
@@ -0,0 +1,159 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BunnyExam { public:
+	double getExpected(int m, int k, vector <int> linkage) 
+	{
+		// trivially impossible cases
+		if( k==1 && m>1	)
+			return -1;
+		if( k==2 )
+			for(int i=0; i<linkage.size(); i+=2)
+				if( (linkage[i] ^ linkage[i+1])&1 )
+					return -1;
+		for(int i=0; i<linkage.size(); i+=2)
+			if( abs(linkage[i] - linkage[i+1]) == 1 )
+				return -1;
+
+		// interference graph
+		int M = linkage.size()/2;
+		vector< vector<int> > conflict(M);
+		for(int i=0; i<M; ++i)
+		for(int j=0; j<M; ++j)
+			if( abs(linkage[2*i+0]-linkage[2*j+0])==1 || abs(linkage[2*i+1]-linkage[2*j+0])==1
+			 || abs(linkage[2*i+0]-linkage[2*j+1])==1 || abs(linkage[2*i+1]-linkage[2*j+1])==1 )
+				conflict[i].push_back(j);
+
+		// check k-colorability
+		if( colorable(conflict, k) )
+			return double(m)/k;
+		else
+			return -1;
+	}
+
+	bool colorable(vector< vector<int> >& G, int k)
+	{
+		if( G.size() <= k )
+			return true;
+		vector<int> color(G.size(), (1<<k)-1);
+		color[0] = 1;
+		return rec(G, color, 0);
+	}
+
+	bool rec(vector< vector<int> >& G, const vector<int>& color, int i)
+	{
+		if( i == color.size() )
+			return true;
+		for(int k=1; k<=color[i]; k<<=1)
+			if( color[i] & k ) // use color k
+			{
+				vector<int> c2 = color;
+				for(int j=0; j<G[i].size(); ++j) // G[i][j] cannot use k
+					c2[G[i][j]] &= ~k;
+				if( rec(G, c2, i+1) )
+					return true;
+			}
+		return false;
+	}
+};
+
+// 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(_, BunnyExam().getExpected(m, k, linkage));}
+int main(){
+
+CASE(0)
+	int m = 3; 
+	int k = 2; 
+	int linkage_[] = { 1, 3 };
+	  vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_)); 
+	double _ = 1.5; 
+END
+CASE(1)
+	int m = 4; 
+	int k = 2; 
+	int linkage_[] = { 1, 4 };
+	  vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_)); 
+	double _ = -1.0; 
+END
+CASE(2)
+	int m = 2; 
+	int k = 8; 
+	vector <int> linkage; 
+	double _ = 0.25; 
+END
+CASE(3)
+	int m = 1000000000; 
+	int k = 1; 
+	int linkage_[] = { 11, 13, 2010, 487 };
+	  vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_)); 
+	double _ = -1.0; 
+END
+CASE(4)
+	int m = 128; 
+	int k = 64; 
+	int linkage_[] = { 32, 16, 8, 4, 2, 1 }
+;
+	  vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_)); 
+	double _ = -1.0; 
+END
+CASE(5)
+	int m = 13; 
+	int k = 3; 
+	int linkage_[] = { 1, 3, 7, 9, 13, 10, 6, 2  }
+;
+	  vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_)); 
+	double _ = 4.333333333333333; 
+END
+CASE(6)
+	int m = 8; 
+	int k = 3; 
+	int linkage_[] = {1,4,2,6,3,8,5,7};
+	  vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_)); 
+	double _ = -1; 
+END
+CASE(7)
+	int m = 1000000000; 
+	int k = 4; 
+	int linkage_[] = {1,4,2,6,3,8,5,7,9,19,  10,20,11,21,12,22,13,23,14,24};
+	  vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_)); 
+	double _ = -1; 
+END
+CASE(8)
+	int m = 20; 
+	int k = 3; 
+	int linkage_[] = {19, 6, 1, 14, 13, 9, 20, 10, 15, 8, 17, 5, 12, 7, 16, 2, 18, 4, 3, 11};
+	  vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_)); 
+	double _ = 6.666666666666667; 
+END
+}
+// END CUT HERE

ADDED   SRM/487/1C.cpp
Index: SRM/487/1C.cpp
==================================================================
--- SRM/487/1C.cpp
+++ SRM/487/1C.cpp
@@ -0,0 +1,93 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL MODVAL = 1000000009;
+
+class BunnySequence { public:
+	int getNumber(int m, int n) 
+	{
+		vector<LL> tbl(n+1);
+		vector<LL> tbl_sum(n+1);
+		tbl[0] = 1;
+		tbl_sum[0] = 1;
+		for(int i=1; i<=n; ++i) {
+			tbl[i] = (tbl_sum[i-1] - (i-m-1>=0 ? tbl_sum[i-m-1] : 0) + MODVAL) % MODVAL;
+			tbl_sum[i] = (tbl_sum[i-1] + tbl[i]) % MODVAL;
+		}
+		return (tbl[n] - (n>=m ? tbl[n-m] : 0) + MODVAL) % MODVAL;
+	}
+};
+
+// 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(_, BunnySequence().getNumber(m, n));}
+int main(){
+
+CASE(0)
+	int m = 5; 
+	int n = 3; 
+	int _ = 4; 
+END
+CASE(1)
+	int m = 487; 
+	int n = 0; 
+	int _ = 1; 
+END
+CASE(2)
+	int m = 19; 
+	int n = 10; 
+	int _ = 512; 
+END
+CASE(3)
+	int m = 3; 
+	int n = 4; 
+	int _ = 6; 
+END
+CASE(4)
+	int m = 10; 
+	int n = 487; 
+	int _ = 829515032; 
+END
+/*
+CASE(5)
+	int m = ; 
+	int n = ; 
+	int _ = ; 
+END
+CASE(6)
+	int m = ; 
+	int n = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/487/2C.cpp
Index: SRM/487/2C.cpp
==================================================================
--- SRM/487/2C.cpp
+++ SRM/487/2C.cpp
@@ -0,0 +1,135 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BunnyConverter { public:
+	vector< vector<int> > n_sqrt;
+
+	int getMinimum(int n, int z, int start, int goal) 
+	{
+		n_sqrt.resize(n);
+		for(LL y=0; y<n; ++y)
+			n_sqrt[y*y%n].push_back(int(y?y:n));
+
+		set<int> v;
+		v.insert(start);
+		vector<int> q(1,start);
+		for(int step=0; !q.empty(); ++step)
+		{
+			vector<int> qNext;
+			for(int i=0; i<q.size(); ++i)
+			{
+				int x = q[i];
+				if( x == goal )
+					return step;
+				const vector<int>& ys = next(x,z,n);
+				for(int j=0; j<ys.size(); ++j)
+				{
+					int y = ys[j];
+					if( v.insert(y).second )
+						qNext.push_back(y);
+				}
+			}
+			q.swap(qNext);
+		}
+		return -1;
+	}
+
+
+	const vector<int>& next(LL x, LL z, LL n)
+	{
+		x %= n;
+		z %= n;
+		#define SUB(a,b) (((a)+n-(b))%n)
+		#define MUL(a,b) ((a)*(b)%n)
+		LL y2 = SUB(SUB(0, x), MUL(z,MUL(z,z)));
+		return n_sqrt[int(y2)];
+	}
+};
+
+// 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(_, BunnyConverter().getMinimum(n, z, start, goal));}
+int main(){
+
+CASE(0)
+	int n = 5; 
+	int z = 1; 
+	int start = 5; 
+	int goal = 3; 
+	int _ = 1; 
+END
+CASE(1)
+	int n = 5; 
+	int z = 1; 
+	int start = 5; 
+	int goal = 1; 
+	int _ = 2; 
+END
+CASE(2)
+	int n = 6; 
+	int z = 2; 
+	int start = 3; 
+	int goal = 4; 
+	int _ = -1; 
+END
+CASE(3)
+	int n = 7; 
+	int z = 7; 
+	int start = 7; 
+	int goal = 7; 
+	int _ = 0; 
+END
+CASE(4)
+	int n = 499979; 
+	int z = 499979; 
+	int start = 499976; 
+	int goal = 3; 
+	int _ = 249988; 
+END
+/*
+CASE(5)
+	int n = ; 
+	int z = ; 
+	int start = ; 
+	int goal = ; 
+	int _ = ; 
+END
+CASE(6)
+	int n = ; 
+	int z = ; 
+	int start = ; 
+	int goal = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/489-U/1A.cpp
Index: SRM/489-U/1A.cpp
==================================================================
--- SRM/489-U/1A.cpp
+++ SRM/489-U/1A.cpp
@@ -0,0 +1,91 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheBoredomDivOne { public:
+	double find(int n, int m) 
+	{
+		double total = (n+m)*(n+m-1);
+
+		vector<double> e(n+m+1);
+		e[n+m] = 0;
+		for(int i=n+m-1; i>=n; --i)
+		{
+			double p2 = (n+m-i)*(n+m-i-1) / total;
+			double p1 = 2*i*(n+m-i) / total;
+			double p0 = 1-p2-p1;
+
+			// e[i] = 1 + p0*e[i] + p1*e[i+1] + p2*e[i+2];
+			e[i] = 1/(1-p0) + p1/(1-p0)*e[i+1] + (i==n+m-1 ? 0 : p2/(1-p0)*e[i+2]);
+		}
+		return e[n];
+	}
+};
+
+// 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(_, TheBoredomDivOne().find(n, m));}
+int main(){
+
+CASE(0)
+	int n = 1; 
+	int m = 1; 
+	double _ = 1.0; 
+END
+CASE(1)
+	int n = 2; 
+	int m = 1; 
+	double _ = 1.5; 
+END
+CASE(2)
+	int n = 1; 
+	int m = 2; 
+	double _ = 2.0; 
+END
+CASE(3)
+	int n = 4; 
+	int m = 7; 
+	double _ = 13.831068977298521; 
+END
+	/*
+CASE(4)
+	int n = ; 
+	int m = ; 
+	double _ = ; 
+END
+CASE(5)
+	int n = ; 
+	int m = ; 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/489-U/1B.cpp
Index: SRM/489-U/1B.cpp
==================================================================
--- SRM/489-U/1B.cpp
+++ SRM/489-U/1B.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 <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheBoringStoreDivOne { public:
+	// entry point
+	string J, B;
+	string find(string J, string B) 
+	{
+		this->J=J; this->B=B; return solve();
+	}
+
+	// just for clarifying types
+	typedef int           J_index, B_index;
+	typedef pair<int,int> J_sub,   B_sub;
+	string jsub(J_index js, J_index je) { return J.substr(js, je-js); }
+	string bsub(B_index bs, B_index be) { return B.substr(bs, be-bs); }
+
+	// update if better
+	void update(string* a, const string& b)
+	{
+		if( a->size()<b.size() || (a->size()==b.size() && *a>b) )
+			*a = b;
+	}
+
+	// O(|J|^4) in total
+	string solve()
+	{
+		string result;
+		for(J_index js=0;    js< J.size(); ++js)
+		for(J_index je=js+1; je<=J.size(); ++je) // for each J[js, je)
+		for(J_index ks=0;    ks< J.size(); ++ks) // try each J[ks, ks+k) which ...
+		{
+			// ... is a maximal nonempty prefix of J[js, je) not intersecting with it
+			int k;
+			for(k=0; js+k<je && ks+k<J.size() && (ks+k<js || je<=ks); ++k)
+				if( J[js+k] != J[ks+k] )
+					break;
+			if( k==0 )
+				continue;
+
+			// we have J[js, js+k)+J[js+k, je) in J, so we want              m in B
+			//         J[ks, ks+k)                              J[js+k,je) + m
+			string m = findInB(J_sub(js+k,je));
+			if( !m.empty() )
+				update(&result, jsub(js,je)+m);
+		}
+		return result;
+	}
+
+	// O(|J|^2 |B|^2) in total
+	map<J_sub, string> memo_fib;
+	string findInB(J_sub key)
+	{
+		if( memo_fib.count(key) )
+			return memo_fib[key];
+
+		string result;
+		for(string::iterator it=B.begin(); it!=B.end(); ++it) // for each B[ks,ke)==key
+		{
+			it = search(it, B.end(), J.begin()+key.first, J.begin()+key.second);
+			if( it == B.end() )
+				break;
+			B_index ks = it - B.begin();
+			B_index ke = ks + (key.second - key.first);
+
+			// try all B[ks, ke)+B[ke, kee), and try to find another B[ke, kee) before ks or after kee
+			for(B_index kee=ke+1; kee<=B.size(); ++kee)
+				if( canFindBefore(ks, B_sub(ke,kee)) || canFindAfter(kee, B_sub(ke,kee)) )
+					update(&result, bsub(ke,kee));
+		}
+		return memo_fib[key] = result;
+	}
+
+	// O(|B|^4) in total : for each substring m of B, the first and last occurence is memoized
+	bool canFindBefore(B_index bi, B_sub m) { return firstOccurence(m)+(m.second-m.first) <= bi; }
+	bool canFindAfter (B_index bi, B_sub m) { return bi <= lastOccurence(m)-(m.second-m.first); }
+
+	map<B_sub, B_index> memo_fo;
+	B_index firstOccurence(B_sub m)
+	{
+		if( memo_fo.count(m) )
+			return memo_fo[m];
+		return memo_fo[m] = search(B.begin(), B.end(), B.begin()+m.first, B.begin()+m.second)-B.begin();
+	}
+
+	map<B_sub, B_index> memo_lo;
+	B_index lastOccurence(B_sub m)
+	{
+		if( memo_lo.count(m) )
+			return memo_lo[m];
+		int mrs = B.size() - m.second;
+		int mre = B.size() - m.first;
+		return memo_lo[m] = B.size() - (search(B.rbegin(), B.rend(), B.rbegin()+mrs, B.rbegin()+mre)-B.rbegin());
+	}
+};
+
+// 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(_, TheBoringStoreDivOne().find(J, B));}
+int main(){
+
+CASE(0)
+	string J = "StoreOfJohn"; 
+	string B = "StoreOfBrus"; 
+	string _ = "or"; 
+END
+CASE(1)
+	string J = "JohnAndJohn"; 
+	string B = "John"; 
+	string _ = ""; 
+END
+CASE(2)
+	string J = "JohnLikesToPlayGames"; 
+	string B = "BrusAlsoLikesToPlayGames"; 
+	string _ = "esToPlayGames"; 
+END
+CASE(3)
+	string J = "abacaba"; 
+	string B = "abacabadabacaba"; 
+	string _ = "abaabacaba"; 
+END
+CASE(4)
+	string J = "abacabaabacabaabacabaabacabaabacabaabacabaabacabaab"; 
+	string B = "abacabaabacabaabacabaabacabaabacabaabacabaabacabaab"; 
+	string _ = "abacabaabacabaabacabaabacabaabacabaabacabaabacabaab"; 
+END
+CASE(5)
+	string J = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; 
+	string B = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; 
+	string _ = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; 
+END
+}
+// END CUT HERE

ADDED   SRM/489-U/1C-U.cpp
Index: SRM/489-U/1C-U.cpp
==================================================================
--- SRM/489-U/1C-U.cpp
+++ SRM/489-U/1C-U.cpp
@@ -0,0 +1,155 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheBoringGameDivOne { public:
+	vector <int> find(int sJ, int kJ, int sB, int kB, int sF, int kF) 
+	{
+		// init:
+		//   ( 0, 0, 0, 0, 0, 0)
+		// possible transitions:
+		//   (+1,+1, 0, 0, 0, 0)
+		//   ( 0, 0,+1,+1, 0, 0)
+		//   ( 0,+2, 0, 0, 0, 0)
+		//   ( 0, 0, 0,+2, 0, 0)
+		//   (+1,+1, 0, 0,+1,+1)
+		//   ( 0, 0,+1,+1,+1,+1)
+		//   ( 0, 0, 0, 0,+2,+2)
+		//   (-1,+1, 0, 0,+1,+1)
+		//   ( 0, 0,-1,+1,+1,+1)
+		vector<int> result;
+		if(sF!=kF)
+			return result;
+
+		for(int f=0; 2*f<=sF; ++f)
+		{
+			int ff = sF - 2*f;
+			if( kJ-ff>=0 && sB-ff>=0 )
+			{
+				vector<int> c = calc(sJ+ff, kJ-ff, sB+ff, kB-ff);
+				if( !c.empty() )
+				{
+					c[0] += f+ff;
+					c[1] += f+ff;
+					if( result.empty() )
+						result = c;
+					else {
+						result[0] = min(result[0],c[0]);
+						result[1] = max(result[1],c[1]);
+					}
+				}
+			}
+		}
+		return result;
+	}
+	vector<int> calc(int sJ, int kJ, int sB, int kB)
+	{
+		// init:
+		//   ( 0, 0, 0, 0,)
+		// possible transitions:
+		//   (+1,+1, 0, 0)
+		//   ( 0, 0,+1,+1)
+		//   ( 0,+2, 0, 0)
+		//   ( 0, 0, 0,+2)
+		if(kJ<sJ || kB<sB || (kJ-sJ)%2==1 || (kB-sB)%2==1)
+			return vector<int>();
+		return vector<int>(2, sJ+(kJ-sJ)/2 + sB+(kB-sB)/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 vector <int>& Expected, const vector <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(_, TheBoringGameDivOne().find(scoreJ, killedJ, scoreB, killedB, scoreF, killedF));}
+int main(){
+
+CASE(0)
+	int scoreJ = 1; 
+	int killedJ = 1; 
+	int scoreB = 1; 
+	int killedB = 1; 
+	int scoreF = 2; 
+	int killedF = 2; 
+	int __[] = {2, 3 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int scoreJ = 0; 
+	int killedJ = 0; 
+	int scoreB = 0; 
+	int killedB = 0; 
+	int scoreF = 0; 
+	int killedF = 0; 
+	int __[] = {0, 0 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int scoreJ = 4; 
+	int killedJ = 7; 
+	int scoreB = -2; 
+	int killedB = 5; 
+	int scoreF = 1; 
+	int killedF = 9; 
+	vector <int> _; 
+END
+CASE(3)
+	int scoreJ = 1; 
+	int killedJ = 5; 
+	int scoreB = -1; 
+	int killedB = 4; 
+	int scoreF = 3; 
+	int killedF = 6; 
+	int __[] = {8, 9 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(4)
+	int scoreJ = ; 
+	int killedJ = ; 
+	int scoreB = ; 
+	int killedB = ; 
+	int scoreF = ; 
+	int killedF = ; 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	int scoreJ = ; 
+	int killedJ = ; 
+	int scoreB = ; 
+	int killedB = ; 
+	int scoreF = ; 
+	int killedF = ; 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+	*/
+}
+// END CUT HERE

ADDED   SRM/490-U/1A.cpp
Index: SRM/490-U/1A.cpp
==================================================================
--- SRM/490-U/1A.cpp
+++ SRM/490-U/1A.cpp
@@ -0,0 +1,114 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+int gcd(int a, int b)
+{
+	while(a)
+		swap(a, b%=a);
+	return b;
+}
+
+class Starport { public:
+	double getExpectedTime(int N, int M) 
+	{
+		return (N-gcd(N,M)) / 2.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 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(_, Starport().getExpectedTime(N, M));}
+int main(){
+
+CASE(0)
+	int N = 4; 
+	int M = 2; 
+	double _ = 1.0; 
+END
+CASE(1)
+	int N = 5; 
+	int M = 3; 
+	double _ = 2.0; 
+END
+CASE(2)
+	int N = 6; 
+	int M = 1; 
+	double _ = 2.5; 
+END
+CASE(3)
+	int N = 12345; 
+	int M = 2345; 
+	double _ = 6170.0; 
+END
+CASE(3)
+	int N = 1; 
+	int M = 1; 
+	double _ = 0; 
+END
+CASE(3)
+	int N = 1; 
+	int M = 100; 
+	double _ = 0; 
+END
+CASE(3)
+	int N = 2; 
+	int M = 1; 
+	double _ = 0.5; 
+END
+CASE(7)
+	int N = 6; 
+	int M = 4; 
+	double _ = 2; 
+END
+CASE(7)
+	int N = 4; 
+	int M = 6; 
+	double _ = 1; 
+END
+CASE(4)
+	int N = 3; 
+	int M = 1000000000; 
+	double _ = -1; 
+END
+CASE(5)
+	int N = 1000000000; 
+	int M = 3; 
+	double _ = -1; 
+END
+CASE(6)
+	int N = 1000000000; 
+	int M = 1000000000; 
+	double _ = -1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/490-U/1B.cpp
Index: SRM/490-U/1B.cpp
==================================================================
--- SRM/490-U/1B.cpp
+++ SRM/490-U/1B.cpp
@@ -0,0 +1,173 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class QuickT9 { public:
+	int minimumPressings(vector <string> t9, string word) 
+	{
+		map< string, set<string> > D2U;
+		for(int i=0; i<t9.size(); ++i) {
+			stringstream sin(t9[i]);
+			for(string u;sin>>u;) {
+				string d;
+				for(int i=0; i<u.size(); ++i) {
+					if(u[i]<='c') d+='2';
+					else if(u[i]<='f') d+='3';
+					else if(u[i]<='i') d+='4';
+					else if(u[i]<='l') d+='5';
+					else if(u[i]<='o') d+='6';
+					else if(u[i]<='s') d+='7';
+					else if(u[i]<='v') d+='8';
+					else if(u[i]<='z') d+='9';
+					D2U[d].insert( u.substr(0,i+1) );
+				}
+			}
+		}
+		return rec(D2U, word, 0, "", "");
+	}
+
+	// Now, the state is F=word[0..i), D=D, U=U. What is the minimal number of steps from here?
+	// It is computed by simply implementing the problem statement, with memoization.
+	map<pair<int,string>, int> memo;
+	int rec( map< string, set<string> >& D2U, const string& word, int i, const string& D, const string& U )
+	{
+		if( i == word.size() ) return 0;
+		if( i < 0 )            return -1;
+
+		pair<int,string> key(i,U);
+		if( memo.count(key) )
+			return memo[key];
+		memo[key] = -1; // avoid cyclic dependency
+
+		int best = -1;
+		#define UPDATE(s,k) { if(s!=-1 && (best==-1 || s+(k)<best)) best=s+(k); }
+
+		// try RIGHT
+		{
+			int cp = 0;
+			while( i+cp<word.size() && cp<U.size() && word[i+cp] == U[cp] )
+				++cp;
+			int k = U.size()-cp;
+			int s = rec(D2U, word, i+U.size()-k, "", "");
+			UPDATE(s,k+1);
+		}
+		// try C
+		{
+			int cp = 0;
+			while( i+cp<word.size() && cp<U.size() && word[i+cp] == U[cp] )
+				++cp;
+			int k = U.size()-cp;
+			if(k==0) k=1; // the only difference is here
+			int s = rec(D2U, word, i+U.size()-k, "", "");
+			UPDATE(s,k);
+		}
+		// try *
+		if( !D.empty() ) {
+			set<string>& Us = D2U[D];
+			set<string>::iterator it = Us.find(U);
+			++it;
+			if( it == Us.end() )
+				it = Us.begin();
+			int s = rec(D2U, word, i, D, *it);
+			UPDATE(s,1);
+		}
+		// try 2-9
+		for(char c='2'; c<='9'; ++c)
+		{
+			string nextD = D + c;
+			if( D2U.count(nextD) ) {
+				set<string>& Us = D2U[nextD];
+				int s = rec(D2U, word, i, nextD, *Us.begin());
+				UPDATE(s,1);
+			}
+		}
+		// done
+		return memo[key] = best;
+	}
+};
+
+// 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(_, QuickT9().minimumPressings(t9, word));}
+int main(){
+
+CASE(0)
+	string t9_[] = {"aae", "bab", "abad", "bdbd", "beta"};
+	  vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_)); 
+	string word = "babe"; 
+	int _ = 9; 
+END
+CASE(1)
+	string t9_[] = {"ann","ie"};
+	  vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_)); 
+	string word = "annie"; 
+	int _ = 7; 
+END
+CASE(2)
+	string t9_[] = {"ann","amm"};
+	  vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_)); 
+	string word = "annie"; 
+	int _ = -1; 
+END
+CASE(3)
+	string t9_[] = {"aaa aab","aac aba abb ccca"};
+	  vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_)); 
+	string word = "aba"; 
+	int _ = 6; 
+END
+CASE(4)
+	string t9_[] = {"acac aba aaab","aab aa baa","bba bacade abb","baba"};
+	  vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_)); 
+	string word = "abbaca"; 
+	int _ = 10; 
+END
+CASE(5)
+	string t9_[] = {"aaa aab aac","aba abb","ccca"};
+	  vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_)); 
+	string word = "ccc"; 
+	int _ = 5; 
+END
+CASE(6)
+string t9_[] = {"abc"};
+	  vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_)); 
+	string word = "a"; 
+	int _ = 2; 
+END
+/*
+CASE(7)
+	string t9_[] = ;
+	  vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_)); 
+	string word = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/490-U/1C-U.cpp
Index: SRM/490-U/1C-U.cpp
==================================================================
--- SRM/490-U/1C-U.cpp
+++ SRM/490-U/1C-U.cpp
@@ -0,0 +1,218 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class InfiniteLab { public:
+	long long getDistance(vector <string> map, long long r1, int c1, long long r2, int c2) 
+	{
+		LL H = map.size();
+		LL W = map[0].size();
+
+		if( r1 > r2 ) {
+			swap(r1,r2);
+			swap(c1,c2);
+		}
+		if( r1 < 0 ) {
+			// check!!!!
+			LL Hx = (-r1/H + 1)*H;
+			r1 += Hx;
+			r2 += Hx;
+		}
+		cerr << r1 << " " << r2 << endl;
+
+		vector<string> mmm(map);
+		mmm.insert(mmm.end(), map.begin(), map.end());
+		mmm.insert(mmm.end(), map.begin(), map.end());
+
+		if( r1/H == r2/H )
+			return dist(mmm, H+(r1%H), c1, H+(r2%H), c2);
+		return -1;
+
+		// top to top
+		vector<vector<LL> > tochu(W, vector<LL>(W, -1));
+		for(int x1=0; x1<W; ++x1) if( map[0][x1] != '#' )
+		for(int x2=0; x2<W; ++x2) if( map[0][x2] != '#' )
+			tochu[x1][x2] = dist( mmm, H, x1, H*2, x2 );
+
+		// r1c1 to top
+		vector<LL> from(W, -1);
+		for(int x1=0; x1<W; ++x1) if( map[0][x1] != '#' )
+			from[W] = dist( mmm, H+(r1%H), c1, H*2, x1 );
+
+		// top to r2c2
+		vector<LL> to(W, -1);
+		for(int x1=0; x1<W; ++x1) if( map[0][x1] != '#' )
+			to[W] = dist( mmm, H, x1, H*2+(r2%H), c2 );
+
+		LL best = -1;
+		for(int i=0; i<from.size(); ++i) if( from[i]>=0 )
+			for(int j=0; j<to.size(); ++j) if( to[j]>=0 )
+			{
+				LL sc = from[i] + to[j];
+				LL s2 = -1; // TODO!
+				if( s2 != -1 && (best == -1 || s2+sc<best) )
+					best = s2+sc;
+			}
+		return best;
+	}
+
+	LL dist(vector<string>& mmm, LL y1, LL x1, LL y2, LL x2)
+	{
+		vector< pair<LL,LL> > Q;
+		set< pair<LL,LL> > V;
+		Q.push_back( make_pair(y1,x1) );
+		V.insert( make_pair(y1,x1) );
+		for(int d=0; !Q.empty(); ++d)
+		{
+			vector< pair<LL,LL> > Q_next;
+			for(int i=0; i<Q.size(); ++i)
+			{
+				LL y = Q[i].first;
+				LL x = Q[i].second;
+				if( y==y2 && x==x2 )
+					return d;
+				int dy[] = {-1,+1,0,0};
+				int dx[] = {0,0,-1,+1};
+				for(int i=0; i<4; ++i) {
+					LL yy = y+dy[i];
+					LL xx = x+dx[i];
+					if( 0<=yy && yy<mmm.size() && 0<=xx && xx<mmm[0].size() && mmm[yy][xx]!='#' ) {
+						pair<LL,LL> p(yy,xx);
+						if( ! V.count(p) ) {
+							V.insert(p);
+							Q_next.push_back(p);
+						}
+					}
+				}
+				if( mmm[y][x] == 'T' ) {
+					for(int xt=0; xt<mmm[y].size(); ++xt) if(xt!=x && mmm[y][xt]=='T') {
+						pair<LL,LL> p(y,xt);
+						if( ! V.count(p) ) {
+							V.insert(p);
+							Q_next.push_back(p);
+						}
+						break;
+					}
+				}
+			}
+			Q_next.swap(Q);
+		}
+		return -1;
+	}
+};
+
+// 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(_, InfiniteLab().getDistance(map, r1, c1, r2, c2));}
+int main(){
+
+CASE(0)
+	string map_[] = {"#...##",
+ ".##...",
+ "..#.##",
+ "#.#.##"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	long long r1 = 1LL; 
+	int c1 = 0; 
+	long long r2 = 5LL; 
+	int c2 = 3; 
+	long long _ = 7LL; 
+END
+CASE(1)
+	string map_[] = {"##.#.",
+ ".#T#T",
+ "...#.",
+ "##.#."};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	long long r1 = 7LL; 
+	int c1 = 4; 
+	long long r2 = 1LL; 
+	int c2 = 0; 
+	long long _ = 9LL; 
+END
+CASE(2)
+	string map_[] = {"..######.#",
+ ".###T###.T",
+ "..T#.##T##",
+ ".######..#"};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	long long r1 = 1LL; 
+	int c1 = 0; 
+	long long r2 = 6LL; 
+	int c2 = 4; 
+	long long _ = 11LL; 
+END
+CASE(3)
+	string map_[] = {"..#..",
+ ".#.#.",
+ "....."};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	long long r1 = -29LL; 
+	int c1 = 2; 
+	long long r2 = 19LL; 
+	int c2 = 2; 
+	long long _ = 54LL; 
+END
+CASE(4)
+	string map_[] = {".#.#.",
+ "..#..",
+ ".....",
+ ".....",
+ "..#.."};
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	long long r1 = -999LL; 
+	int c1 = 3; 
+	long long r2 = 100LL; 
+	int c2 = 2; 
+	long long _ = -1LL; 
+END
+/*
+CASE(5)
+	string map_[] = ;
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	long long r1 = LL; 
+	int c1 = ; 
+	long long r2 = LL; 
+	int c2 = ; 
+	long long _ = LL; 
+END
+CASE(6)
+	string map_[] = ;
+	  vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_)); 
+	long long r1 = LL; 
+	int c1 = ; 
+	long long r2 = LL; 
+	int c2 = ; 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/491/1A.cpp
Index: SRM/491/1A.cpp
==================================================================
--- SRM/491/1A.cpp
+++ SRM/491/1A.cpp
@@ -0,0 +1,111 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class FoxMakingDice { public:
+	long long theCount(int N, int K) 
+	{
+		LL cnt = 0;
+		for(int sum=K; sum<=N+N; ++sum)
+		{
+			LL v = 0;
+			for(int s=1; s<=N; ++s)
+				if( s<sum-s && 1<=sum-s && sum-s<=N )
+					++v;
+			cnt += v*(v-1)*(v-2)/6*2;
+		}
+		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 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(_, FoxMakingDice().theCount(N, K));}
+int main(){
+
+CASE(0)
+	int N = 6; 
+	int K = 7; 
+	long long _ = 2LL; 
+END
+CASE(1)
+	int N = 5; 
+	int K = 7; 
+	long long _ = 0LL; 
+END
+CASE(2)
+	int N = 1000; 
+	int K = 1; 
+	long long _ = 20625666000LL; 
+END
+CASE(3)
+	int N = 456; 
+	int K = 123; 
+	long long _ = 879075732LL; 
+END
+CASE(4)
+	int N = 913; 
+	int K = 1014; 
+	long long _ = 4506149340LL; 
+END
+CASE(5)
+	int N = 1000; 
+	int K = 2000; 
+	long long _ = -1LL; 
+END
+CASE(6)
+	int N = 1; 
+	int K = 7; 
+	long long _ = 0LL; 
+END
+CASE(6)
+	int N = 2; 
+	int K = 7; 
+	long long _ = 0LL; 
+END
+CASE(6)
+	int N = 3; 
+	int K = 7; 
+	long long _ = 0LL; 
+END
+CASE(6)
+	int N = 4; 
+	int K = 7; 
+	long long _ = 0LL; 
+END
+CASE(6)
+	int N = 5; 
+	int K = 7; 
+	long long _ = 0LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/491/1B.cpp
Index: SRM/491/1B.cpp
==================================================================
--- SRM/491/1B.cpp
+++ SRM/491/1B.cpp
@@ -0,0 +1,133 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PrefixTree { public:
+	static vector<int> wordToFreq( const string& word )
+	{
+		vector<int> freq(26);
+		for(int i=0; i<word.size(); ++i)
+			freq[word[i]-'a']++;
+		return freq;
+	}
+
+	static vector< vector<int> > wordsToFreqs( const vector<string>& words )
+	{
+		vector< vector<int> > freqs;
+		transform(words.begin(), words.end(), back_inserter(freqs), &wordToFreq);
+		return freqs;
+	}
+
+	static int commonPrefix(const vector< vector<int> >& freqs, int s)
+	{
+		vector<int> common;
+		for(int first=1,i=0; (1<<i)<=s; ++i)
+			if( s & (1<<i) )
+				if( first ) {
+					common = freqs[i];
+					first = 0;
+				} else {
+					for(int k=0; k<26; ++k)
+						common[k] = min(common[k], freqs[i][k]);
+				}
+		return accumulate(common.begin(), common.end(), 0);
+	}
+
+	int getNumNodes(vector<string> words) 
+	{
+		const int N = words.size();
+		const vector< vector<int> >& freqs = wordsToFreqs(words);
+
+		vector<int> dp(1<<N);
+		for(int s=1; s<(1<<N); ++s)
+		{
+			dp[s] = 1;
+			for(int i=0; i<N; ++i)
+				if( s & (1<<i) )
+					dp[s] += words[i].size();
+
+			int cp = commonPrefix(freqs, s);
+			for(int ss=s-1; ss&=s; --ss)
+				dp[s] = min(dp[s], dp[ss]+dp[s&~ss]-cp-1);
+		}
+		return dp[(1<<N)-1];
+	}
+};
+
+// 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(_, PrefixTree().getNumNodes(words));}
+int main(){
+
+CASE(0)
+	string words_[] = {"topcoder"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	int _ = 9; 
+END
+CASE(1)
+	string words_[] = {"topcoder","topcoder"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	int _ = 9; 
+END
+CASE(2)
+	string words_[] = {"aab","ca"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	int _ = 5; 
+END
+CASE(3)
+	string words_[] = {"aab","ca","ba"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	int _ = 5; 
+END
+CASE(4)
+	string words_[] = {"ab","cd","ef"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	int _ = 7; 
+END
+CASE(5)
+	string words_[] = {"a","aa","aaa"};
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	int _ = 4; 
+END
+/*
+CASE(6)
+	string words_[] = ;
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	int _ = ; 
+END
+CASE(7)
+	string words_[] = ;
+	  vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/491/1C.cpp
Index: SRM/491/1C.cpp
==================================================================
--- SRM/491/1C.cpp
+++ SRM/491/1C.cpp
@@ -0,0 +1,213 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+template<typename T>
+class IdGen
+{
+	map<T, int> v2id_;
+	vector<T>   id2v_;
+public:
+	int v2id(const T& v) {
+		if( !v2id_.count(v) ) { v2id_[v] = size(); id2v_.push_back(v); }
+		return v2id_[v];
+	}
+	const T& id2v(int i) const { return id2v_[i]; }
+	int size() const { return id2v_.size(); }
+};
+
+template<typename Vert, typename Cost, typename Flow, int NV=256>
+class MinCostFlow
+{
+	IdGen<Vert> idgen;
+
+	vector<int> G[NV];
+	Flow F[NV][NV];
+	Cost C[NV][NV];
+
+public:
+	void addEdge( Vert s_, Vert t_, Cost c, Flow f )
+	{
+		int s = idgen.v2id(s_), t = idgen.v2id(t_);
+		G[s].push_back(t);
+		G[t].push_back(s);
+		C[s][t] = c;
+		C[t][s] = -c;
+		F[s][t] = f;
+		F[t][s] = 0;
+	}
+
+	pair<Cost, Flow> calc( Vert s_, Vert t_ )
+	{
+		const int N=idgen.size(), S=idgen.v2id(s_), T=idgen.v2id(t_);
+		static const Cost COST_INF = 1e+300; // !!EDIT HERE!!
+		static const Flow FLOW_INF = 0x7fffffff;
+
+		Cost total_cost = 0;
+		Flow total_flow = 0;
+		vector<Cost> h(N, 0); // potential
+		for(Flow RF=FLOW_INF; RF>0; ) // residual flow
+		{
+			// Dijkstra -- find the min-cost path
+			vector<Cost> d(N, COST_INF);  d[S] = 0;
+			vector<int>  prev(N, -1);
+
+			typedef pair< Cost, pair<int,int> > cedge;
+			priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+			Q.push( cedge(0, make_pair(S,S)) );
+			while( !Q.empty() ) {
+				cedge e = Q.top(); Q.pop();
+				if( prev[e.second.second] >= 0 )
+					continue;
+				prev[e.second.second] = e.second.first;
+
+				int u = e.second.second;
+				for(int i=0; i<G[u].size(); ++i) {
+					int  v = G[u][i];
+					Cost r_cost = C[u][v] + h[u] - h[v];
+					if( F[u][v] > 0 && d[v] > d[u]+r_cost )
+						Q.push( cedge(d[v]=d[u]+r_cost, make_pair(u,v)) );
+				}
+			}
+
+			if( prev[T] < 0 )
+				break; // Finished
+
+			// Run the flow as much as possible
+			Flow f = RF;
+			for(int u=T; u!=S; u=prev[u])
+				f = min(f, F[prev[u]][u]);
+			RF         -= f;
+			total_flow += f;
+
+			for(int u=T; u!=S; u=prev[u])
+			{
+				total_cost    += f * C[prev[u]][u];
+				F[prev[u]][u] -= f;
+				F[u][prev[u]] += f;
+			}
+
+			// Update the potential
+			for(int u=0; u<N; ++u)
+				h[u] += d[u];
+		}
+		return make_pair(total_cost, total_flow);
+	}
+};
+
+class FoxCardGame { public:
+	double theMaxProportion(vector <double> pileA, vector <double> pileB, int k) 
+	{
+		double L=1, R=50;
+		for(int i=0; i<50; ++i)
+			(possible(pileA, pileB, k, (L+R)/2) ? L : R) = (L+R)/2;
+		return L;
+	}
+
+	enum Tag {Src, Left, Right, Target, Goal};
+	bool possible(vector <double> pileA, vector <double> pileB, int k, double R)
+	{
+		MinCostFlow<pair<Tag,int>, double, int> mcf;
+
+		for(int a=0; a<pileA.size(); ++a)
+			mcf.addEdge( make_pair(Src,0), make_pair(Left,a), 0.0, 1 );
+		for(int a=0; a<pileA.size(); ++a)
+		for(int b=0; b<pileB.size(); ++b)
+		{
+			double x_ = pileA[a]+pileB[b], y_ = pileA[a]*pileB[b];
+			double x = max(x_,y_), y = min(x_,y_);
+			mcf.addEdge( make_pair(Left,a), make_pair(Right,b), R*y-x+10000.0, 1 );
+		}
+		for(int b=0; b<pileB.size(); ++b)
+			mcf.addEdge( make_pair(Right,b), make_pair(Target,0), 0.0, 1 );
+		mcf.addEdge( make_pair(Target,0), make_pair(Goal,0), 0.0, k );
+
+		return mcf.calc( make_pair(Src,0), make_pair(Goal,0) ).first <= 10000.0*k;
+	}
+};
+
+// 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(_, FoxCardGame().theMaxProportion(pileA, pileB, k));}
+int main(){
+
+CASE(0)
+	double pileA_[] = {1, 2, 3};
+	  vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_)); 
+	double pileB_[] = {4, 5, 6};
+	  vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_)); 
+	int k = 2; 
+	double _ = 1.7692307692309948; 
+END
+CASE(1)
+	double pileA_[] = {1.234, 5.678, 9.012, 3.456, 7.89};
+	  vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_)); 
+	double pileB_[] = {2.345, 6.789, 9.876, 5.432, 1.012};
+	  vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_)); 
+	int k = 3; 
+	double _ = 4.159424420079586; 
+END
+CASE(2)
+	double pileA_[] = {1, 1.1, 1.2, 1.3, 1.4, 1.5};
+	  vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_)); 
+	double pileB_[] = {5, 10, 15, 20, 25, 30};
+	  vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_)); 
+	int k = 2; 
+	double _ = 1.3972602739726827; 
+END
+CASE(3)
+	double pileA_[] = {85.302, 92.798, 76.813, 37.994, 36.737, 98.659};
+	  vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_)); 
+	double pileB_[] = {13.352, 7.3094, 54.761, 8.2706, 63.223, 37.486};
+	  vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_)); 
+	int k = 3; 
+	double _ = 33.58603889836175; 
+END
+CASE(4)
+	double pileA_[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0};
+	  vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_)); 
+	double pileB_[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0};
+	  vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_)); 
+	int k = 50; 
+	double _ = 16.846938775510203; 
+END
+/*
+CASE(5)
+	double pileA_[] = ;
+	  vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_)); 
+	double pileB_[] = ;
+	  vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_)); 
+	int k = ; 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/491/2C.cpp
Index: SRM/491/2C.cpp
==================================================================
--- SRM/491/2C.cpp
+++ SRM/491/2C.cpp
@@ -0,0 +1,171 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+LL gcd(LL a, LL b)
+{
+	while(a)
+		swap(a, b%=a);
+	return b;
+}
+
+LL lcm(LL a, LL b)
+{
+	return a/gcd(a,b)*b;
+}
+
+class BottlesOnShelf { public:
+	int getNumBroken(int N, vector <int> left, vector <int> right, vector <int> damage) 
+	{
+		int total = 0;
+		for(int mask=1; mask<(1<<left.size()); ++mask)
+			total += (bitcnt(mask)%2==0 ? -1 : +1) * hit(N, left, right, damage, mask);
+		return total;
+	}
+
+	int bitcnt(int m)
+	{
+		int c = 0;
+		for(; m; m>>=1)
+			c += (m&1);
+		return c;
+	}
+
+	LL ceil(LL x, LL q)
+	{
+		return (x + q - 1) / q * q;
+	}
+
+	int hit(int N, vector <int> left, vector <int> right, vector <int> damage, int mask)
+	{
+		LL theLeft   = 1;
+		LL theRight  = N+1;
+		LL theDamage = 1;
+		for(int i=0; i<left.size(); ++i)
+			if( mask & (1<<i) )
+			{
+				theLeft   = max<LL>(theLeft,  left[i]);
+				theRight  = min<LL>(theRight, right[i]+1);
+				theDamage = lcm(theDamage, damage[i]);
+			}
+		return int( max(0LL, ceil(theRight,theDamage)-ceil(theLeft,theDamage)) / theDamage );
+	}
+};
+
+// 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(_, BottlesOnShelf().getNumBroken(N, left, right, damage));}
+int main(){
+
+CASE(0)
+	int N = 7; 
+	int left_[] = {1};
+	  vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_)); 
+	int right_[] = {7};
+	  vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_)); 
+	int damage_[] = {2};
+	  vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_)); 
+	int _ = 3; 
+END
+CASE(1)
+	int N = 7; 
+	int left_[] = {1,1};
+	  vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_)); 
+	int right_[] = {7,7};
+	  vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_)); 
+	int damage_[] = {2,3};
+	  vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_)); 
+	int _ = 4; 
+END
+CASE(2)
+	int N = 7; 
+	int left_[] = {1,1,1};
+	  vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_)); 
+	int right_[] = {7,7,7};
+	  vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_)); 
+	int damage_[] = {2,3,6};
+	  vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_)); 
+	int _ = 4; 
+END
+CASE(3)
+	int N = 10; 
+	int left_[] = {1,6};
+	  vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_)); 
+	int right_[] = {5,10};
+	  vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_)); 
+	int damage_[] = {1,7};
+	  vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_)); 
+	int _ = 6; 
+END
+CASE(4)
+	int N = 5; 
+	int left_[] = {4};
+	  vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_)); 
+	int right_[] = {4};
+	  vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_)); 
+	int damage_[] = {7};
+	  vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_)); 
+	int _ = 0; 
+END
+CASE(5)
+	int N = 1000000000; 
+	int left_[] = {1};
+	  vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_)); 
+	int right_[] = {1000000000};
+	  vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_)); 
+	int damage_[] = {1};
+	  vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_)); 
+	int _ = 1000000000; 
+END
+/*
+CASE(6)
+	int N = ; 
+	int left_[] = ;
+	  vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_)); 
+	int right_[] = ;
+	  vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_)); 
+	int damage_[] = ;
+	  vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_)); 
+	int _ = ; 
+END
+CASE(7)
+	int N = ; 
+	int left_[] = ;
+	  vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_)); 
+	int right_[] = ;
+	  vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_)); 
+	int damage_[] = ;
+	  vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/492-U/1A.cpp
Index: SRM/492-U/1A.cpp
==================================================================
--- SRM/492-U/1A.cpp
+++ SRM/492-U/1A.cpp
@@ -0,0 +1,135 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
+double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
+int ccw(const CMP& a, CMP b, CMP c) {
+	b -= a; c -= a;
+	if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
+	if( outer_prod(b,c) < 0 ) return -1; // clockwise
+	if( inner_prod(b,c) < 0 ) return +2; // c--[a--b] on line
+	if( norm(b) < norm(c) )   return -2; // [a--b]--c on line
+	return 0; // [a--c--b] on line
+}
+
+class TimeTravellingGardener { public:
+	int determineUsage(vector <int> distance, vector <int> height) 
+	{
+		const int N = height.size();
+
+		distance.insert(distance.begin(), 0);
+		partial_sum(distance.begin(), distance.end(), distance.begin());
+
+		vector<CMP> p;
+		for(int i=0; i<N; ++i)
+			p.push_back( CMP(distance[i], height[i]) );
+
+		int best = N-1;
+		for(int i=0; i<N; ++i)
+			for(int j=i+1; j<N; ++j)
+			{
+				best = min(best, score(p[i], p[j], p));
+				best = min(best, score(p[i].real(), p[j], p));
+				best = min(best, score(p[i], p[j].real(), p));
+			}
+		return best;
+	}
+
+	int score(const CMP& a, const CMP& b, const vector<CMP>& p)
+	{
+		int s = 0;
+		for(int i=0; i<p.size(); ++i)
+		{
+			if( ccw(a, b, p[i]) == -1 ) return INT_MAX;
+			if( ccw(a, b, p[i].real()) == +1 ) return INT_MAX;
+			if( ccw(a, b, p[i]) == +1 ) ++s;
+		}
+		return s;
+	}
+};
+
+// 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(_, TimeTravellingGardener().determineUsage(distance, height));}
+int main(){
+
+CASE(0)
+	int distance_[] = {2,2};
+	  vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_)); 
+	int height_[] = {1,3,10};
+	  vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_)); 
+	int _ = 1; 
+END
+CASE(1)
+	int distance_[] = {3,3};
+	  vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_)); 
+	int height_[] = {3,1,3};
+	  vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_)); 
+	int _ = 2; 
+END
+CASE(2)
+	int distance_[] = {1,3};
+	  vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_)); 
+	int height_[] = {4,4,4};
+	  vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_)); 
+	int _ = 0; 
+END
+CASE(3)
+	int distance_[] = {4,2};
+	  vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_)); 
+	int height_[] = {9,8,5};
+	  vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_)); 
+	int _ = 1; 
+END
+CASE(4)
+	int distance_[] = {476,465,260,484};
+	  vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_)); 
+	int height_[] = {39,13,8,72,80};
+	  vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_)); 
+	int _ = 3; 
+END
+CASE(5)
+	int distance_[] = {173,36,668,79,26,544};
+	  vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_)); 
+	int height_[] = {488,743,203,446,444,91,453};
+	  vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_)); 
+	int _ = 5; 
+END
+CASE(6)
+	int distance_[] = {2,4,2,2,4,2,4,2,2,4};
+	  vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_)); 
+	int height_[] = {2,2,10,10,10,16,16,22,22,28,28};
+	  vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_)); 
+	int _ = 6; 
+END
+}
+// END CUT HERE

ADDED   SRM/492-U/1B.cpp
Index: SRM/492-U/1B.cpp
==================================================================
--- SRM/492-U/1B.cpp
+++ SRM/492-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>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const LL INF = 0x1fffffffffffffffLL;
+
+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 TimeTravellingTour { public:
+	long long determineCost(int N, vector <int> cities, vector <string> roads) 
+	{
+		vector< vector<LL> > G(N, vector<LL>(N,INF));
+		{
+			string str = accumulate(roads.begin(), roads.end(), string(""));
+			for(int i=0; i<str.size(); ++i)
+				if( str[i] == ',' )
+					str[i] = ' ';
+			stringstream sin(str);
+			for(int a,b,cost; sin>>a>>b>>cost; )
+				G[a][b] = G[b][a] = cost;
+		}
+		for(int i=0; i<N; ++i)
+			G[i][i] = 0;
+		for(int k=0; k<N; ++k)
+			for(int i=0; i<N; ++i)
+				for(int j=0; j<N; ++j)
+					G[i][j] = min(G[i][j], G[i][k]+G[k][j]);
+
+		DP3<LL> memo(N, cities.size()+1, cities.size()+1, -1);
+		LL a = rec( 0, 0, cities.size(), cities, G, memo );
+		return a>=INF ? -1 : a;
+	}
+
+	LL rec(int cur, int s, int e, const vector<int>& C, const vector< vector<LL> >& G, DP3<LL>& memo )
+	{
+		if( s+1 == e )
+			return G[cur][C[s]];
+		if( memo(cur,s,e) >= 0 )
+			return memo(cur,s,e);
+
+		LL best = INF;
+		for(int v=0; v<G[cur].size(); ++v)
+			if( G[cur][v] < INF )
+				for(int m=s+1; m<e; ++m)
+					best = min(best, G[cur][v]+rec(v,s,m,C,G,memo)+rec(v,m,e,C,G,memo));
+		return memo(cur,s,e) = best;
+	}
+};
+
+// 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(_, TimeTravellingTour().determineCost(N, cities, roads));}
+int main(){
+
+CASE(0)
+	int N = 5; 
+	int cities_[] = {2,3,2,4};
+	  vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	string roads_[] = {"0,2,4 0,1,2 2,1,2 1,3,3 4,0,4"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	long long _ = 13LL; 
+END
+CASE(1)
+	int N = 3; 
+	int cities_[] = {1,0,1};
+	  vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	string roads_[] = {"0,2,1"," 2",",1,5"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	long long _ = 12LL; 
+END
+CASE(2)
+	int N = 3; 
+	int cities_[] = {2};
+	  vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	string roads_[] = {"0,1,2"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	long long _ = -1LL; 
+END
+CASE(3)
+	int N = 6; 
+	int cities_[] = {4, 1, 3, 2};
+	  vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	string roads_[] = {"0,1,5 0,2,5 0,5,2 2,3,5 2,4,2 3,4,4 3,5,1"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	long long _ = 19LL; 
+END
+/*
+CASE(4)
+	int N = ; 
+	int cities_[] = ;
+	  vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	string roads_[] = ;
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	long long _ = LL; 
+END
+CASE(5)
+	int N = ; 
+	int cities_[] = ;
+	  vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_)); 
+	string roads_[] = ;
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/493-U/1A.cpp
Index: SRM/493-U/1A.cpp
==================================================================
--- SRM/493-U/1A.cpp
+++ SRM/493-U/1A.cpp
@@ -0,0 +1,122 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class StonesGame { public:
+	string winner(int N, int M, int K, int L) 
+	{
+		if( isOneStep(N,M,K,L) ) // M から L に一手でいけるなら先手の勝ち
+			return "Romeo";
+		for(int x=1; x<=N; ++x)
+			if( isOneStep(N,M,K,x) && !isOneStep(N,x,K,L) )
+				return "Draw"; // 先手も後手も勝てない場合
+		return "Strangelet"; // M からは「Lに一手で行けちゃうx」にしか行けないなら、後手の勝ち
+	}
+
+	bool isOneStep(int N, int M, int K, int L)
+	{
+		int d = abs(M-L);
+		if( d<K && (d%2)!=(K%2) )
+		{
+			int mid = (M+L)/2; // M と L の真ん中を中心に
+			int e = mid + K/2; // 右に K/2
+			int b = e - K+1;   // 左に K/2 伸ばした範囲をreverseすればMがLに行けるはず…
+			return 1<=b && e<=N; // そんな範囲で大丈夫か
+		}
+		return false;
+	}
+};
+
+// 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(_, StonesGame().winner(N, M, K, L));}
+int main(){
+
+CASE(0)
+	int N = 3; 
+	int M = 1; 
+	int K = 1; 
+	int L = 2; 
+	string _ = "Draw"; 
+END
+CASE(1)
+	int N = 5; 
+	int M = 1; 
+	int K = 2; 
+	int L = 2; 
+	string _ = "Romeo"; 
+END
+CASE(2)
+	int N = 5; 
+	int M = 5; 
+	int K = 2; 
+	int L = 3; 
+	string _ = "Strangelet"; 
+END
+CASE(3)
+	int N = 5; 
+	int M = 5; 
+	int K = 2; 
+	int L = 2; 
+	string _ = "Draw"; 
+END
+CASE(4)
+	int N = 1000000; 
+	int M = 804588; 
+	int K = 705444; 
+	int L = 292263; 
+	string _ = "Romeo"; 
+END
+CASE(5)
+	int N = 1000000; 
+	int M = 100000; 
+	int K = 500000; 
+	int L = 600000; 
+	string _ = "Strangelet"; 
+END
+CASE(6)
+	int N = 5; 
+	int M = 1; 
+	int K = 3; 
+	int L = 5; 
+	string _ = "Strangelet"; 
+END
+/*
+CASE(7)
+	int N = ; 
+	int M = ; 
+	int K = ; 
+	int L = ; 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/493-U/1B.cpp
Index: SRM/493-U/1B.cpp
==================================================================
--- SRM/493-U/1B.cpp
+++ SRM/493-U/1B.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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class AmoebaCode { public:
+	// メインルーチン
+	int find(string code, int K) 
+	{
+		int answer = 1;
+		for(int D=2; D<=K; ++D)
+			if( can(code, K, 0, string(D-1,'X')) ) // 最小距離が D 以上になるようにできる？
+				answer = max(answer, D);
+		return answer; // できるような D の最大値を返す
+	}
+
+	// 「code[i..$) に 1 〜 K を埋められるか？」を再帰的に判定
+	// prev には code[i] の直前 D-1 文字を入れて呼び出す。
+	// この D-1 文字は避けないと最小距離 D 以上にならないので避けましょう
+	map<pair<size_t,string>, bool> memo;
+	bool can(const string& code, const int K, size_t i, const string& prev)
+	{
+		if( i == code.size() )
+			return true; // 最後まで埋まった。OK!
+
+		pair<int,string> key(i, prev);
+		if( memo.count(key) )
+			return memo[key]; // メモ化。すでに見た引数なら覚えてる結果を返す
+
+		// code[i] に入れる文字の候補を列挙
+		vector<char> cand;
+		if( code[i] == '0' ) // '0' なら 1 から K のどれに置き換えてもいい
+			for(int k=1; k<=K; ++k)
+				cand.push_back( char('0'+k) );
+		else // それ以外なら置き換えられない
+			cand.push_back( code[i] );
+
+		bool ok = false;
+		for(int k=0; k<cand.size(); ++k) // 候補を全部試してみる
+			if( count(prev.begin(), prev.end(), cand[k])    // prev を避けてて
+			 && can(code, K, i+1, prev.substr(1)+cand[k]) ) // code[i+1..$) も全部埋められればOK
+				ok |= true;
+
+		return memo[key] = ok; // メモ化の表に記憶しつつ return
+	}
+};
+
+// 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(_, AmoebaCode().find(code, K));}
+int main(){
+
+CASE(0)
+	string code = "01"; 
+	int K = 1; 
+	int _ = 1; 
+END
+CASE(1)
+	string code = "1001"; 
+	int K = 2; 
+	int _ = 1; 
+END
+CASE(2)
+	string code = "1010"; 
+	int K = 2; 
+	int _ = 2; 
+END
+CASE(3)
+	string code = "01001"; 
+	int K = 3; 
+	int _ = 3; 
+END
+CASE(4)
+	string code = "10012031001"; 
+	int K = 3; 
+	int _ = 2; 
+END
+CASE(5)
+	string code = "00000000000000000000000000000000000000000000000000"; 
+	int K = 7; 
+	int _ = -1; 
+END
+/*
+CASE(6)
+	string code = ; 
+	int K = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/493-U/2C.cpp
Index: SRM/493-U/2C.cpp
==================================================================
--- SRM/493-U/2C.cpp
+++ SRM/493-U/2C.cpp
@@ -0,0 +1,147 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CrouchingAmoebas { public:
+	int count(vector <int> x, vector <int> y, int A, int T) 
+	{
+		int answer = 0;
+
+		const int N = x.size();
+
+		vector<int> ys, xs;
+		for(int i=0; i<N; ++i)
+			for(int dy=-T; dy<=+T; ++dy)
+				ys.push_back(y[i]+dy);
+		for(int i=0; i<N; ++i)
+			for(int dx=-T; dx<=+T; ++dx)
+				xs.push_back(x[i]+dx);
+
+		for(int i=0; i<xs.size(); ++i)
+		for(int k=0; k<ys.size(); ++k)
+		{
+			int Y = ys[k];
+			int X = xs[i];
+			vector<unsigned int> ds;
+			for(int j=0; j<N; ++j) {
+				unsigned int d = distance(Y,X,A,y[j],x[j]);
+				if( d <= T )
+					ds.push_back(d);
+			}
+			sort( ds.begin(), ds.end() );
+			int e=T, c=0;
+			for(int j=0; j<ds.size() && ds[j]<=e; ++j) 
+				e-=ds[j], ++c;
+			answer = max(answer, c);
+		}
+		return answer;
+	}
+
+	static unsigned int distance(int Y, int X, int A, int y, int x)
+	{
+		unsigned int yd = (y<Y ? Y-y : Y+A<y ? y-(Y+A) : 0);
+		unsigned int xd = (x<X ? X-x : X+A<x ? x-(X+A) : 0);
+		return xd + yd;
+	}
+};
+
+// 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(_, CrouchingAmoebas().count(x, y, A, T));}
+int main(){
+
+CASE(0)
+	int x_[] = {0,0};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,1};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int A = 1; 
+	int T = 1; 
+	int _ = 2; 
+END
+CASE(1)
+	int x_[] = {0,1,2};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,2,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int A = 1; 
+	int T = 1; 
+	int _ = 2; 
+END
+CASE(2)
+	int x_[] = {0,1,2};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,2,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int A = 1; 
+	int T = 2; 
+	int _ = 3; 
+END
+CASE(3)
+	int x_[] = {0,0,3,3};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,3,0,3};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int A = 2; 
+	int T = 4; 
+	int _ = 4; 
+END
+CASE(4)
+	int x_[] = {-1000000000,1000000000};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {-1000000000,1000000000};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int A = 1; 
+	int T = 15; 
+	int _ = 1; 
+END
+/*
+CASE(5)
+	int x_[] = ;
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = ;
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int A = ; 
+	int T = ; 
+	int _ = ; 
+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_)); 
+	int A = ; 
+	int T = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/494-U/1A.cpp
Index: SRM/494-U/1A.cpp
==================================================================
--- SRM/494-U/1A.cpp
+++ SRM/494-U/1A.cpp
@@ -0,0 +1,215 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class Painting { public:
+	int largestBrush(vector <string> picture) 
+	{
+		const int Y = picture.size();
+		const int X = picture[0].size();
+
+		int best = 1;
+		for(int S=2; S<=min(Y,X); ++S)
+		{
+			vector<string> duty = picture;
+			for(int y=0; y+S<=Y; ++y)
+			for(int x=0; x+S<=X; ++x)
+				if( all<'B'>(picture, y, x, y+S, x+S) ) // SxS が全部黒ならここを左上にして塗れる
+					fill<'W'>(duty, y, x, y+S, x+S); // 塗る
+			if( all<'W'>(duty, 0, 0, Y, X) )
+				best = max(best, S); // 全部塗れてたらベストスコア更新
+		}
+		return best;
+	}
+
+	template<char color>
+	bool all(const vector<string>& p, int ys, int xs, int ye, int xe)
+	{
+		int cnt = 0;
+		for(int y=ys; y<ye; ++y)
+		for(int x=xs; x<xe; ++x)
+			cnt += (p[y][x]==color);
+		return cnt == (ye-ys)*(xe-xs);
+	}
+
+	template<char color>
+	void fill(vector<string>& p, int ys, int xs, int ye, int xe)
+	{
+		for(int y=ys; y<ye; ++y)
+		for(int x=xs; x<xe; ++x)
+			p[y][x] = color;
+	}
+};
+
+// 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(_, Painting().largestBrush(picture));}
+int main(){
+
+CASE(0)
+	string picture_[] = {"BBBB",
+ "BBBB",
+ "BBBB",
+ "BBBB"};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 4; 
+END
+CASE(1)
+	string picture_[] = {"BBBB",
+ "BWWB",
+ "BWWB",
+ "BBBB"};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 1; 
+END
+CASE(2)
+	string picture_[] = {
+ "WBBBBB",
+ "BBBBBB",
+ "BBBBBB",
+ "BBBBBB"}
+;
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 3; 
+END
+CASE(3)
+	string picture_[] = {"BBBB",
+ "BBBB",
+ "WBBB",
+ "BBBB",
+ "BBBB",
+ "BBBB"}
+;
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 2; 
+END
+CASE(4)
+	string picture_[] = {
+ "WBBBBBWWWWWWWWW",
+ "WBBBBBBWWWWWWWW",
+ "WBBBBBBBBBBBWWW",
+ "WBBBBBBBBBBBWWW",
+ "BBBBBBBBBBBBBBB",
+ "BBBBBBBBBBBBBBB",
+ "BBBBBBBBBBBBBBB",
+ "BBBBBBBBWWBBBBB",
+ "BBBBBBBBWBBBBBB",
+ "WBBBBBBBWBBBBBW",
+ "BBBBBBBWWBBBBBW",
+ "BBBBBBBWWBBBBBW",
+ "BBBBBBWWWBBBBBW",
+ "BBBBBWWWWWWWWWW",
+ "BBBBBWWWWWWWWWW"}
+;
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 5; 
+END
+CASE(5)
+	string picture_[] = {"B"};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 1; 
+END
+CASE(6)
+	string picture_[] = {"WWWWWWBWWWWW"};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 1; 
+END
+CASE(7)
+	string picture_[] = {
+"WWBBWW",
+"WBBBBW",
+"BBWWBB",
+"BBWWBB",
+"WBBBBW",
+"WWBBWW",
+};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 1; 
+END
+CASE(8)
+	string picture_[] = {
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
+};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 1; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/494-U/1B.cpp
Index: SRM/494-U/1B.cpp
==================================================================
--- SRM/494-U/1B.cpp
+++ SRM/494-U/1B.cpp
@@ -0,0 +1,112 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class AlternatingLane { public:
+	double expectedBeauty(vector <int> low, vector <int> high) 
+	{
+		double eSum = 0.0;
+		for(int i=1; i<low.size(); ++i)
+		{
+			// ランダムに
+			//   h ∈ [low[i-1], high[i-1]]
+			//   g ∈ [low[i],   high[i]  ]
+			// を取ってきたときの、|h-g| の期待値…
+			double e = 0;
+			for(int h=low[i-1]; h<=high[i-1]; ++h)
+				if( h <= low[i] )
+					e += sequenceSum(low[i]-h, high[i]-h);
+				else if( high[i] <= h )
+					e += sequenceSum(h-high[i], h-low[i]);
+				else
+					e += sequenceSum(0, h-low[i]) + sequenceSum(0, high[i]-h);
+			eSum += e / (high[i]-low[i]+1) / (high[i-1]-low[i-1]+1);
+		}
+		return eSum; // …の和、が答え
+	}
+
+	LL sequenceSum(LL a, LL b) // a+(a+1)+...+b
+	{
+		return (a+b) * (b-a+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 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(_, AlternatingLane().expectedBeauty(low, high));}
+int main(){
+
+CASE(0)
+	int low_[] = {1};
+	  vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_)); 
+	int high_[] = {100};
+	  vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_)); 
+	double _ = 0.0; 
+END
+CASE(1)
+	int low_[] = {1, 1, 1};
+	  vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_)); 
+	int high_[] = {2, 2, 2};
+	  vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_)); 
+	double _ = 1.0; 
+END
+CASE(2)
+	int low_[] = {1, 3, 5, 7, 9};
+	  vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_)); 
+	int high_[] = {2, 4, 6, 8, 10};
+	  vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_)); 
+	double _ = 8.0; 
+END
+CASE(3)
+	int low_[] = {4, 3, 3, 7};
+	  vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_)); 
+	int high_[] = {10, 7, 7, 7};
+	  vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_)); 
+	double _ = 6.171428571428572; 
+END
+CASE(4)
+int low_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+	  vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_)); 
+	  int high_[] = {100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000};
+	  vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_)); 
+	double _ = -1; 
+END
+/*
+CASE(5)
+	int low_[] = ;
+	  vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_)); 
+	int high_[] = ;
+	  vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_)); 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/495-U/1A.cpp
Index: SRM/495-U/1A.cpp
==================================================================
--- SRM/495-U/1A.cpp
+++ SRM/495-U/1A.cpp
@@ -0,0 +1,158 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ColorfulCards { public:
+	vector <int> theCards(int N, string colors) 
+	{
+		vector<bool> isPrime(N+1, true);
+		isPrime[1] = false;
+		for(int p=2; p<=N; ++p)
+			if( isPrime[p] )
+				for(int q=p+p; q<=N; q+=p)
+					isPrime[q] = false;
+
+		vector<int> result(colors.size(), 0);
+		for(int i=0; i<colors.size(); ++i)
+			for(int n=1; n<=N; ++n)
+				if( canItBe(i, n, colors, isPrime) )
+					if( result[i] > 0 )
+						{result[i] = -1; break;}
+					else
+						result[i] = n;
+		return result;
+	}
+
+	bool canItBe(int i, int n, const string& colors, vector<bool>& isPrime)
+	{
+		if( colors[i]=='R' && !isPrime[n] )
+			return false;
+		if( colors[i]=='B' &&  isPrime[n] )
+			return false;
+		return greedyDown(i-1, n-1, colors, isPrime) && greedyUp(i+1, n+1, colors, isPrime);
+	}
+
+	bool greedyUp(int i, int n, const string& colors, vector<bool>& isPrime)
+	{
+		while( i<colors.size() )
+		{
+			if( n >= isPrime.size() )
+				return false;
+			if( colors[i]=='R' && isPrime[n] )
+				{++i; ++n;}
+			else
+			if( colors[i]=='B' && !isPrime[n] )
+				{++i; ++n;}
+			else
+				++n;
+		}
+		return true;
+	}
+
+	bool greedyDown(int i, int n, const string& colors, vector<bool>& isPrime)
+	{
+		while( i>=0 )
+		{
+			if( n < 1 )
+				return false;
+			if( colors[i]=='R' && isPrime[n] )
+				{--i; --n;}
+			else
+			if( colors[i]=='B' && !isPrime[n] )
+				{--i; --n;}
+			else
+				--n;
+		}
+		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 vector <int>& Expected, const vector <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(_, ColorfulCards().theCards(N, colors));}
+int main(){
+
+CASE(0)
+	int N = 5; 
+	string colors = "RRR"; 
+	int __[] = {2, 3, 5 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int N = 7; 
+	string colors = "BBB"; 
+	int __[] = {1, 4, 6 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int N = 6; 
+	string colors = "RBR"; 
+	int __[] = {-1, 4, 5 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	int N = 58; 
+	string colors = "RBRRBRBBRBRRBBRRBBBRRBBBRR"; 
+	int __[] = {-1, -1, -1, -1, -1, -1, -1, -1, 17, 18, 19, 23, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, 53 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	int N = 495; 
+	string colors = "RBRRBRBBRBRRBBRRBBBRRBBBRR"; 
+	int __[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	int N = 1000; 
+	string colors = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"; 
+	int __[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+	int N = 1; 
+	string colors = "B"; 
+	int __[] = {1};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+	int N = 2; 
+	string colors = "R"; 
+	int __[] = {2};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+	int N = 2; 
+	string colors = "B"; 
+	int __[] = {1};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+}
+// END CUT HERE

ADDED   SRM/495-U/1B.cpp
Index: SRM/495-U/1B.cpp
==================================================================
--- SRM/495-U/1B.cpp
+++ SRM/495-U/1B.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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CarrotBoxes { public:
+	double theProbability(vector <string> info)
+	{
+		info = warshall_floyd(info);
+
+		double answer=0.0, p=1.0;
+
+		set<int> boxes;
+		for(int v=0; v<info.size(); ++v)
+			boxes.insert(v);
+
+		while( !boxes.empty() )
+		{
+			for(set<int>::iterator it=boxes.begin(); it!=boxes.end(); ++it)
+				if( isRoot(*it, info, boxes) && !isSingleton(*it, info, boxes) )
+				{
+					int N = boxes.size();
+					int nr = 0;
+					for(int u=0; u<info.size(); ++u)
+						if( info[*it][u]=='Y' && boxes.count(u) )
+							{++nr; boxes.erase(u);}
+					answer += p * (nr-1) / N;
+					p *= double(N-nr) / N;
+					goto nextIter;
+				}
+
+			// 全部が stand alone
+			answer += p / boxes.size();
+			break;
+
+		nextIter:;
+		}
+		return answer;
+	}
+
+	bool isRoot(int v, const vector<string>& info, const set<int>& boxes)
+	{
+		for(set<int>::const_iterator jt=boxes.begin(); jt!=boxes.end(); ++jt)
+			if( info[v][*jt]=='N' && info[*jt][v]=='Y' )
+				return false;
+		return true;
+	}
+
+	bool isSingleton(int v, const vector<string>& info, const set<int>& boxes)
+	{
+		for(set<int>::const_iterator jt=boxes.begin(); jt!=boxes.end(); ++jt)
+			if( v!=*jt && info[v][*jt]=='Y' )
+				return false;
+		return true;
+	}
+
+	vector<string> warshall_floyd(const vector<string>& gg)
+	{
+		vector<string> g = gg;
+		for(int k=0; k<g.size(); ++k)
+			for(int i=0; i<g.size(); ++i)
+				for(int j=0; j<g.size(); ++j)
+					if( g[i][k]=='Y' && g[k][j]=='Y' )
+						g[i][j] = 'Y';
+		return g;
+	}
+};
+
+// 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(_, CarrotBoxes().theProbability(information));}
+int main(){
+
+CASE(0)
+	string information_[] = {"YYYYY",
+ "NYNNN",
+ "NNYNN",
+ "NNNYN",
+ "NNNNY"}
+;
+	  vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_)); 
+	double _ = 0.8; 
+END
+CASE(1)
+	string information_[] = {"YNNNN",
+ "NYNNN",
+ "NNYNN",
+ "NNNYN",
+ "NNNNY"};
+	  vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_)); 
+	double _ = 0.2; 
+END
+CASE(2)
+	string information_[] = {"Y"};
+	  vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_)); 
+	double _ = 1.0; 
+END
+CASE(3)
+	string information_[] = {"YNNNN",
+ "YYNNN",
+ "YNYNN",
+ "NNNYY",
+ "NNNYY"}
+;
+	  vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_)); 
+	double _ = 0.6; 
+END
+CASE(4)
+	string information_[] = {"YYYNNNYN",
+ "NYNNNNYN",
+ "NNYNNNNN",
+ "NYNYNNNN",
+ "YNNNYNNY",
+ "NNYNNYNN",
+ "NNNNYNYN",
+ "NNYNNNNY"}
+;
+	  vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_)); 
+	double _ = 0.875; 
+END
+CASE(5)
+	string information_[] = {"YNNNNNNNNYNNNNNNNNNN",
+ "NYNNNNNNNNNNNNNNNNNN",
+ "NNYNNNNNNNYNNNNNYNNN",
+ "NNNYNYNNNNNNNNYNNNNN",
+ "NNNNYNNNNNNNNNYNNNNY",
+ "NNNNNYNNNNNNNNNNNNNY",
+ "NNNNYNYNYNNNNNNNNNNN",
+ "NNNNNNNYNNNYYNNNNNNN",
+ "NNNNNNNNYNNNNNNNNNNN",
+ "YNNNNNNNNYNNNNNYNNNN",
+ "NNNNNNNNNNYNNNNNNNNN",
+ "NYNNNNNNNNNYNNNNNNNN",
+ "NNNNNNNYNNNNYNNNNNNN",
+ "NNNNNNNNNNNNNYNNNYNN",
+ "NNNNNNNNNNNYNNYNNNYN",
+ "NYNNNNNNNNNNNNNYNNNN",
+ "NNYNNNNNNNNNNNNNYNNN",
+ "NNNNNNNNNNNNNYNYNYNN",
+ "NNNNNNNNYNYNNNNNNNYY",
+ "NNNYNNNNNNNNNNNNNNNY"};
+	  vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_)); 
+	double _ = 0.75; 
+END
+/*
+CASE(6)
+	string information_[] = ;
+	  vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_)); 
+	double _ = ; 
+END
+CASE(7)
+	string information_[] = ;
+	  vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_)); 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/495-U/2C.cpp
Index: SRM/495-U/2C.cpp
==================================================================
--- SRM/495-U/2C.cpp
+++ SRM/495-U/2C.cpp
@@ -0,0 +1,187 @@
+#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>
+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 HexagonPuzzle { public:
+	int theCount(vector <string> board) 
+	{
+		vector< pair<int,int> > id2pos;
+		map<pair<int,int>, int> pos2id;
+		int N = board.size();
+		for(int i=0; i<N; ++i)
+			for(int k=0; k<=i; ++k) {
+				id2pos.push_back( make_pair(i,k) );
+				pos2id[make_pair(i,k)] = id2pos.size()-1;
+			}
+
+		int M = id2pos.size();
+		UnionFind uf(M);
+
+		for(int i=0; i<N; ++i)
+			for(int k=0; k<=i; ++k)
+				if( board[i][k] == '.' )
+				{
+					if( i+1<N && board[i+1][k]=='.' && board[i+1][k+1]=='.' )
+					{
+						int a = pos2id[ make_pair(i,k) ];
+						int b = pos2id[ make_pair(i+1,k) ];
+						int c = pos2id[ make_pair(i+1,k+1) ];
+						uf.Union(a,b);
+						uf.Union(b,c);
+					}
+					if( i+1<N && k+1<=i && board[i][k+1]=='.' && board[i+1][k+1]=='.' )
+					{
+						int a = pos2id[ make_pair(i,k) ];
+						int b = pos2id[ make_pair(i,k+1) ];
+						int c = pos2id[ make_pair(i+1,k+1) ];
+						uf.Union(a,b);
+						uf.Union(b,c);
+					}
+				}
+
+		map<int, int> sc;
+		for(int i=0; i<N; ++i)
+			for(int k=0; k<=i; ++k)
+				if( board[i][k] == '.' )
+				{
+					int a = pos2id[ make_pair(i,k) ];
+					int ra = uf.Find(a);
+					sc[ra] = uf.sz[ra];
+				}
+
+		static const int MODVAL = 1000000007;
+		LL result = 1;
+		for(map<int,int>::iterator it=sc.begin(); it!=sc.end(); ++it)
+		{
+			int n = it->second;
+			LL r = 1;
+			for(int i=3; i<=n; ++i)
+				r = (r*i)%MODVAL;
+			result = (result * r) % MODVAL;
+		}
+		return int(result);
+	}
+};
+
+// 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(_, HexagonPuzzle().theCount(board));}
+int main(){
+
+CASE(0)
+	string board_[] = {".",
+ ".X",
+ "X..",
+ ".X.X"}
+;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 3; 
+END
+CASE(1)
+	string board_[] = {"X"}
+;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 1; 
+END
+CASE(2)
+	string board_[] = {".",
+ "..",
+ "...",
+ ".X.."}
+;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 20160; 
+END
+CASE(3)
+	string board_[] = {".",
+ "..",
+ "XXX",
+ "..X.",
+ ".X..X",
+ "XXXX..",
+ "..X.X.X",
+ "..X.XX.."}
+;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 108; 
+END
+CASE(4)
+	string board_[] = {".",
+ "..",
+ "...",
+ "....",
+ ".....",
+ "......",
+ ".......",
+ "........"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 261547992; 
+END
+/*
+CASE(5)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = ; 
+END
+CASE(6)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/496/1A.cpp
Index: SRM/496/1A.cpp
==================================================================
--- SRM/496/1A.cpp
+++ SRM/496/1A.cpp
@@ -0,0 +1,133 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class ColoredStrokes { public:
+	int getLeast(vector <string> picture) 
+	{
+		const int H = picture.size();
+		const int W = picture[0].size();
+
+		int cnt = 0;
+		for(int y=0; y<H; ++y)
+		{
+			string line = picture[y];
+			for(int i=0; i<line.size(); ++i)
+				if( line[i]=='G' ) line[i] = 'R';
+				else if(line[i]=='B') line[i]='.';
+			cnt += howMany('R', line);
+		}
+		for(int x=0; x<W; ++x)
+		{
+			string line;
+			for(int y=0; y<H; ++y)
+				line += picture[y][x];
+			for(int i=0; i<line.size(); ++i)
+				if( line[i]=='G' ) line[i] = 'B';
+				else if(line[i]=='R') line[i]='.';
+			cnt += howMany('B', line);
+		}
+		return cnt;
+	}
+
+	int howMany(char c, const string& s)
+	{
+		int cnt = 0;
+		for(int i=0; i<s.size(); )
+		{
+			while(i<s.size() && s[i]!=c)
+				++i;
+			if( i == s.size() )
+				break;
+			++cnt;
+			while(i<s.size() && s[i]==c)
+				++i;
+		}
+		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(_, ColoredStrokes().getLeast(picture));}
+int main(){
+
+CASE(0)
+	string picture_[] = {"...",
+ "..."};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 0; 
+END
+CASE(1)
+	string picture_[] = {"..B.",
+ "..B."};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 1; 
+END
+CASE(2)
+	string picture_[] = {".BB."};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 2; 
+END
+CASE(3)
+	string picture_[] = {"...B..",
+ ".BRGRR",
+ ".B.B.."};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 3; 
+END
+CASE(4)
+	string picture_[] = {"...B..",
+ ".BRBRR",
+ ".B.B.."};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 4; 
+END
+CASE(5)
+	string picture_[] = {"GR",
+ "BG"};
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = 4; 
+END
+/*
+CASE(6)
+	string picture_[] = ;
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = ; 
+END
+CASE(7)
+	string picture_[] = ;
+	  vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/496/1B.cpp
Index: SRM/496/1B.cpp
==================================================================
--- SRM/496/1B.cpp
+++ SRM/496/1B.cpp
@@ -0,0 +1,152 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class OneDimensionalBalls { public:
+	long long countValidGuesses(vector <int> firstPicture, vector <int> secondPicture) 
+	{
+		LL answer = 0;
+
+		const int N = firstPicture.size();
+		set<int> sp(secondPicture.begin(), secondPicture.end());
+
+		for(set<int>::iterator it=sp.begin(); it!=sp.end(); ++it)
+		{
+			if( firstPicture[0] != *it )
+			{
+				const int d = abs(firstPicture[0] - *it);
+
+				set<int> avail = sp;
+				avail.erase(*it);
+
+				vector<bool> done(N, false);
+				done[0] = true;
+
+				for(;;)
+				{
+					bool upd = false;
+					for(int k=0; k<N; ++k)
+						if( !done[k] )
+						{
+							bool aL = avail.count(firstPicture[k]-d)>0;
+							bool aR = avail.count(firstPicture[k]+d)>0;
+							if( !aL && !aR )
+								goto nextIt;
+							else if( aL && !aR )
+								{upd=done[k]=true; avail.erase(firstPicture[k]-d);}
+							else if( !aL && aR )
+								{upd=done[k]=true; avail.erase(firstPicture[k]+d);}
+						}
+					if( !upd )
+						break;
+				}
+
+				set<int> notDone;
+				for(int k=0; k<N; ++k)
+					if( !done[k] )
+						notDone.insert(firstPicture[k]);
+
+				LL cnt = 1;
+
+				set<int> nnd;
+				for(set<int>::iterator jt=notDone.begin(); jt!=notDone.end(); ++jt)
+					if( !nnd.count(*jt) )
+					{
+						int chain = 1;
+						for(int q=*jt+2*d; notDone.count(q); q+=2*d)
+							{nnd.insert(q); ++chain;}
+						cnt *= chain+1;
+					}
+				answer += cnt;
+			}
+		nextIt:;
+		}
+
+		return answer;
+	}
+};
+
+// 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(_, OneDimensionalBalls().countValidGuesses(firstPicture, secondPicture));}
+int main(){
+
+CASE(0)
+	int firstPicture_[] = {12,11};
+	  vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_)); 
+	int secondPicture_[] = {10,11,13};
+	  vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_)); 
+	long long _ = 3LL; 
+END
+CASE(1)
+	int firstPicture_[] = {1,2,3};
+	  vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_)); 
+	int secondPicture_[] = {1,2,3};
+	  vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_)); 
+	long long _ = 0LL; 
+END
+CASE(2)
+	int firstPicture_[] = {1,3};
+	  vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_)); 
+	int secondPicture_[] = {1,3};
+	  vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_)); 
+	long long _ = 1LL; 
+END
+CASE(3)
+	int firstPicture_[] = {7234};
+	  vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_)); 
+	int secondPicture_[] = {6316,689156,689160,689161,800000,1000001};
+	  vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_)); 
+	long long _ = 6LL; 
+END
+CASE(4)
+	int firstPicture_[] = {6,2,4};
+	  vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_)); 
+	int secondPicture_[] = {1,2,3,4,5,7,8};
+	  vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_)); 
+	long long _ = 7LL; 
+END
+CASE(5)
+int firstPicture_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30};
+	  vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_)); 
+	int secondPicture_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30};
+	  vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_)); 
+	long long _ = -1LL; 
+END
+CASE(6)
+	int firstPicture_[] = {1,2,3,4};
+	  vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_)); 
+	int secondPicture_[] = {1,2,3,4};
+	  vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_)); 
+	long long _ = 2LL; 
+END
+}
+// END CUT HERE

ADDED   SRM/496/1C.cpp
Index: SRM/496/1C.cpp
==================================================================
--- SRM/496/1C.cpp
+++ SRM/496/1C.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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class YetAnotherHamiltonianPath { public:
+	int leastCost(vector <string> label) 
+	{
+		int cost = 0;
+		for(int i=0; i<label.size(); ++i)
+			cost += label[i].size()*label[i].size() * (i<=1 ? 1 : 2); // どうやってもかかる分のコスト
+		return cost - radixSort(label); // あとは max (Σ LCP^2) を引き算
+	}
+
+	int radixSort(const vector<string>& v, int i=0, bool single=true, bool hasBothZeroOne=true)
+	{
+		// 原則的に、0文字目が同じものどうしを一カ所にまとめた方が当然ベター
+		// 0文字目が同じ中では1文字目が同じものどうしを一カ所に…という再帰
+		map< char, vector<string> > classify;
+		for(int k=0; k<v.size(); ++k)
+			classify[v[k].c_str()[i]].push_back( v[k] );
+
+		// N 個のブロックに分かれたら、分かれ目ではLCPが i なので、その分の Σ LCP^2 は i*i*(N-1)。
+		int score = i*i * (classify.size()-1); 
+
+		// あとはブロックごとに再帰的に LCP^2 の和を求めて足していく
+		for(map<char, vector<string> >::iterator it=classify.begin(); it!=classify.end(); ++it)
+		{
+			bool sgl = single && classify.size()==1;
+			bool hzo = hasBothZeroOne && it->first==v[0].c_str()[i] && it->first==v[1].c_str()[i];
+			if( it->first )
+				score += radixSort( it->second, i+1, sgl, hzo );
+			else
+				score += i*i * (it->second.size()-1 + (sgl?1:0) - (hzo?1:0));
+		}
+
+		// ただし、label[0] と label[1] が生き別れになる分かれ目は（最初から分かれてるので）数えない
+		if( hasBothZeroOne && v[0].c_str()[i]!=v[1].c_str()[i] ) score -= i*i;
+
+		// 逆に、全体が2つ以上のブロックに分かれるときには label[0] と label[1] の間に挟まるので ΣLCP^2 がその分多い
+		if( single && classify.size()>1 ) score += i*i;
+
+		// 以上
+		return 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(_, YetAnotherHamiltonianPath().leastCost(label));}
+int main(){
+
+CASE(0)
+	string label_[] = {"home", "school", "pub"} ;
+	  vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_)); 
+	int _ = 70; 
+END
+CASE(1)
+	string label_[] = {"school", "home", "pub", "stadium"};
+	  vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_)); 
+	int _ = 167; 
+END
+CASE(2)
+	string label_[] = {"abcd","aecgh","abef","aecd"};
+	  vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_)); 
+	int _ = 91; 
+END
+CASE(3)
+	string label_[] = {"canada", "cyprus", "croatia", "colombia", "chile", "china", "cameroon"};
+	  vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_)); 
+	int _ = 509; 
+END
+CASE(4)
+	string label_[] = {"aaa", "aab", "b"};
+	  vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_)); 
+	int _ = 9+1 + 1+9; 
+END
+CASE(4)
+	string label_[] = {"caaa", "caab", "cb"};
+	  vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_)); 
+	int _ = 16+4 + 4+16 - 1 - 1; 
+END
+/*
+CASE(5)
+	string label_[] = ;
+	  vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/496/2C.cpp
Index: SRM/496/2C.cpp
==================================================================
--- SRM/496/2C.cpp
+++ SRM/496/2C.cpp
@@ -0,0 +1,129 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PalindromfulString { public:
+	long long count(int N, int M, int K) 
+	{
+		vector<int> tmp;
+		return rec(N, M, K, tmp, 0);
+	}
+
+	static LL rec(int N, int M, int K, vector<int>& cur, int usedMax)
+	{
+		if( cur.size() == N )
+		{
+			int pc=0;
+			for(int s=0; s+M<=N; ++s)
+				if( isPalin(cur, s, s+M) )
+					pc++;
+			return (pc>=K ? P(26, usedMax) : 0);
+		}
+		else
+		{
+			LL sum = 0;
+			for(int k=1; k<=usedMax+1; ++k)
+			{
+				cur.push_back(k);
+				sum += rec(N, M, K, cur, max(usedMax,k));
+				cur.pop_back();
+			}
+			return sum;
+		}
+	}
+
+	static bool isPalin(const vector<int>& v, int s, int e)
+	{
+		for( ; s<=--e; ++s)
+			if( v[s] != v[e] )
+				return false;
+		return true;
+	}
+
+	static LL P(int v, int n)
+	{
+		LL x = 1;
+		for(int i=0; i<n; ++i)
+			x *= v-i;
+		return 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 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(_, PalindromfulString().count(N, M, K));}
+int main(){
+
+CASE(0)
+	int N = 2; 
+	int M = 2; 
+	int K = 1; 
+	long long _ = 26LL; 
+END
+CASE(1)
+	int N = 2; 
+	int M = 2; 
+	int K = 0; 
+	long long _ = 676LL; 
+END
+CASE(2)
+	int N = 3; 
+	int M = 2; 
+	int K = 1; 
+	long long _ = 1326LL; 
+END
+CASE(3)
+	int N = 4; 
+	int M = 4; 
+	int K = 1; 
+	long long _ = 676LL; 
+END
+CASE(4)
+	int N = 7; 
+	int M = 3; 
+	int K = 3; 
+	long long _ = 4310176LL; 
+END
+CASE(5)
+	int N = 11; 
+	int M = 2; 
+	int K = 0; 
+	long long _ = -1LL; 
+END
+CASE(6)
+	int N = 11; 
+	int M = 5; 
+	int K = 0; 
+	long long _ = -1LL; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/497-U/1A.cpp
Index: SRM/497-U/1A.cpp
==================================================================
--- SRM/497-U/1A.cpp
+++ SRM/497-U/1A.cpp
@@ -0,0 +1,96 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class PermutationSignature { public:
+	vector <int> reconstruct(string signature) 
+	{
+		deque<int> cur(1, 1);
+		for(int i=signature.size()-1; i>=0; --i)
+		{
+			int ins = (signature[i]=='I' ? 1 : cur.front()+1);
+			cur.push_front(ins);
+			for(int k=1; k<cur.size(); ++k)
+				if( cur[k] >= ins )
+					cur[k] ++;
+		}
+		return vector<int>(cur.begin(), cur.end());
+	}
+};
+
+// 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 <int>& Expected, const vector <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(_, PermutationSignature().reconstruct(signature));}
+int main(){
+
+CASE(0)
+	string signature = "IIIII"; 
+	int __[] = {1, 2, 3, 4, 5, 6 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	string signature = "DI"; 
+	int __[] = {2, 1, 3 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	string signature = "IIIID"; 
+	int __[] = {1, 2, 3, 4, 6, 5 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	string signature = "DIIDID"; 
+	int __[] = {2, 1, 3, 5, 4, 7, 6 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	string signature = "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"; 
+	int __[] = {-1};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	string signature = "IDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDID"; 
+int __[] = {-1};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+	string signature = "I"; 
+	int __[] = {1,2};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(7)
+	string signature = "D"; 
+	int __[] = {2,1};
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+
+}
+// END CUT HERE

ADDED   SRM/497-U/1B.cpp
Index: SRM/497-U/1B.cpp
==================================================================
--- SRM/497-U/1B.cpp
+++ SRM/497-U/1B.cpp
@@ -0,0 +1,249 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CssRules { public:
+	int getMinimalCssRuleCount(vector <string> xthml) 
+	{
+		tree virtual_root;
+		{
+			num_node = 0;
+			string xs = accumulate(xthml.begin(), xthml.end(), string(""));
+			const char* p = xs.c_str();
+			virtual_root.children = parse_tags(p);
+		}
+		vector<int> memo(num_node*8*8*8, -1);
+		return rec(virtual_root.children, 7*64+7*8+7, memo);
+	}
+
+	struct tree
+	{
+		int id;
+		int tag;
+		int color;
+		vector<tree*> children;
+		~tree() { for(int i=0; i<children.size(); ++i) delete children[i]; }
+	};
+
+	// solver -------------------------------------------------------------
+
+	int rec(vector<tree*>& ts, int tag_to_color, vector<int>& memo)
+	{
+		int sum = 0;
+		for(int i=0; i<ts.size(); ++i)
+			sum += rec(ts[i], tag_to_color, memo);
+		return sum;
+	}
+
+	int rec(tree* t, int tag_to_color, vector<int>& memo)
+	{
+		const int key = t->id * 8*8*8 + tag_to_color;
+		if( memo[key] >= 0 )
+			return memo[key];
+
+		int me   = ((tag_to_color>>(3*t->tag))&7) != t->color;
+		int best = 0x3fffffff;
+		for(int ttc=0; ttc<8*8*8; ++ttc)
+		{
+			int cost = 0;
+			cost += ((tag_to_color>>0)&7) != ((ttc>>0)&7);
+			cost += ((tag_to_color>>3)&7) != ((ttc>>3)&7);
+			cost += ((tag_to_color>>6)&7) != ((ttc>>6)&7);
+			best = min(best, cost + srec(t->children, ttc, memo));
+		}
+		return memo[key] = me + best;
+	}
+
+	// parser ------------------------------------------------------
+
+	int num_node;
+
+	vector<tree*> parse_tags( const char*& p )
+	{
+		vector<tree*> res;
+		while(*p && p[1]!='/')
+			res.push_back(parse_tag(p));
+		return res;
+	}
+
+	tree* parse_tag( const char*& p )
+	{
+		static map<string, int> color_map;
+		if( color_map.empty() )
+		{
+			color_map["black"]  = 0;
+			color_map["blue"]   = 1;
+			color_map["gray"]   = 2;
+			color_map["green"]  = 3;
+			color_map["red"]    = 4;
+			color_map["white"]  = 5;
+			color_map["yellow"] = 6;
+		}
+		static map<string, int> tag_map;
+		if( tag_map.empty() )
+		{
+			tag_map["b"] = 0;
+			tag_map["u"] = 1;
+			tag_map["i"] = 2;
+		}
+
+		// <TAG id='ID' style='color:COLOR'>tagContent</TAG>
+		p++;                                  // <
+		string tag; while(*p!=' ') tag+=*p++; // TAG
+		while(*p==' ') ++p;                   // _sp_
+		p += 4;                               // id='
+		string id;  while(*p!='\'') id+=*p++; // ID
+		++p;                                  // '
+		while(*p==' ') ++p;                   // _sp_
+		p += 13;                              // style='color:
+		string cl;  while(*p!='\'') cl+=*p++; // COLOR
+		p += 2;                               // '>
+		vector<tree*> ch = parse_tags(p);     // tagContent
+		p += 4;                               // </TAG>
+
+		tree* t = new tree;
+		t->id       = num_node++;
+		t->tag      = tag_map[tag];
+		t->color    = color_map[cl];
+		t->children = ch;
+		return t;
+	}
+};
+
+// 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(_, CssRules().getMinimalCssRuleCount(xthml));}
+int main(){
+
+CASE(6)
+	string xthml_[] = {"<i id='b' style='color:white'><u id='f' styl", "e='color:red'></u><u id='e' style='color:red", "'></u><u id='d' style='color:gray'></u><i id", "='c' style='color:white'></i></i><i id='a' s", "tyle='color:red'></i>"};
+	  vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_)); 
+	int _ = 5; 
+END
+CASE(0)
+	string xthml_[] = {"<b id='x' style='color:red'></b>"};
+	  vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_)); 
+	int _ = 1; 
+END
+CASE(1)
+	string xthml_[] = {"<b id='x' style='color:red'>","<b id='y' style='color:red'>",
+ "<b id='z' style='color:red'>","</b></b></b>"}
+;
+	  vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_)); 
+	int _ = 2; 
+END
+CASE(2)
+	string xthml_[] = {"<b id='x' style='color:red'>",
+"<b id='y' style='color:red'>",
+"<b id='w' style='color:red'>",
+"</b>",
+"</b>",
+"<u id='z' style='color:red'>",
+"</u>",
+"</b>"};
+	  vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_)); 
+	int _ = 3; 
+END
+CASE(3)
+	string xthml_[] = {"<b id='x' style='color:red'>",
+"<i id='y' style='color:black'>",
+"<u id='w' style='color:white'>",
+"</u>",
+"</i>",
+"<u id='z' style='color:yellow'>",
+"</u>",
+"</b>"};
+	  vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_)); 
+	int _ = 4; 
+END
+CASE(4)
+	string xthml_[] = {"<b id='x' style='col", "or:red'></b>", "<b id=", "'xx' style='color", ":red'></b>"};
+	  vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_)); 
+	int _ = 2; 
+END
+CASE(5)
+	string xthml_[] = {
+"<b id='aa' style='color:red'><b id='ab' style='col",
+"or:red'><b id='ac' style='color:red'><b id='ad' st",
+"yle='color:red'><b id='ae' style='color:red'><b id",
+"='af' style='color:red'><b id='ag' style='color:re",
+"d'><b id='ah' style='color:red'><b id='ai' style='",
+"color:red'><b id='aj' style='color:red'><b id='ak'",
+" style='color:red'><b id='al' style='color:red'><b",
+" id='am' style='color:red'><b id='an' style='color",
+":red'><b id='ao' style='color:red'><b id='ap' styl",
+"e='color:red'><b id='aq' style='color:red'><b id='",
+"ar' style='color:red'><b id='as' style='color:red'",
+"><b id='at' style='color:red'><b id='au' style='co",
+"lor:red'><b id='av' style='color:red'><b id='aw' s",
+"tyle='color:red'><b id='ax' style='color:red'><b i",
+"d='ay' style='color:red'><b id='az' style='color:r",
+"ed'><b id='ba' style='color:red'><b id='bb' style=",
+"'color:red'><b id='bc' style='color:red'><b id='bd",
+"' style='color:red'><b id='be' style='color:red'><",
+"b id='bf' style='color:red'><b id='bg' style='colo",
+"r:red'><b id='bh' style='color:red'><b id='bi' sty",
+"le='color:red'><b id='bj' style='color:red'><b id=",
+"'bk' style='color:red'><b id='bl' style='color:red",
+"'><b id='bm' style='color:red'><b id='bn' style='c",
+"olor:red'><b id='bo' style='color:red'><b id='bp' ",
+"style='color:red'><b id='bq' style='color:red'><b ",
+"id='br' style='color:red'><b id='bs' style='color:",
+"red'><b id='bt' style='color:red'><b id='bu' style",
+"='color:red'><b id='bv' style='color:red'><b id='b",
+"w' style='color:red'><b id='bx' style='color:red'>",
+"<b id='by' style='color:red'><b id='bz' style='col",
+"or:red'><b id='ca' style='color:red'><b id='cb' st",
+"yle='color:red'><b id='cc' style='color:red'><b id",
+"='cd' style='color:red'><b id='ce' style='color:re",
+"d'><b id='cf' style='color:red'><b id='cg' style='",
+"color:red'><b id='ch' style='color:red'><b id='ci'",
+" style='color:red'><b id='cj' style='color:red'><b",
+" id='ck' style='color:red'><b id='cl' style='color",
+":red'><b id='cm' style='color:red'><b id='cn' styl",
+"e='color:red'><b id='co' style='color:red'><b id='",
+"cp' style='color:red'><b id='cq' style='color:red'",
+"><b id='cr' style='color:red'><b id='cs' style='co",
+"lor:red'><b id='ct' style='color:red'><b id='cu' s",
+"tyle='color:red'><b id='cv' style='color:red'><b i",
+"d='cw' style='color:red'></b></b></b></b></b></b><",
+"/b></b></b></b></b></b></b></b></b></b></b></b></b",
+"></b></b></b></b></b></b></b></b></b></b></b></b><",
+"/b></b></b></b></b></b></b></b></b></b></b></b></b",
+"></b></b></b></b></b></b></b></b></b></b></b></b><",
+"/b></b></b></b></b></b></b></b></b></b></b></b></b",
+"></b></b></b></b></b></b>"
+};
+	  vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_)); 
+	int _ = -1; 
+END
+}
+// END CUT HERE

ADDED   SRM/TCO10-1-U/1A.cpp
Index: SRM/TCO10-1-U/1A.cpp
==================================================================
--- SRM/TCO10-1-U/1A.cpp
+++ SRM/TCO10-1-U/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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class EqualizeStrings { public:
+	string getEq(string s, string t) 
+	{
+		string answer;
+		for(int i=0; i<s.size(); ++i)
+			answer += char(adjust(s[i]-'a', t[i]-'a')+'a');
+		return answer;
+	}
+	int adjust(int x, int y)
+	{
+		int minC = 9999;
+		int minZ = 0;
+		for(int z=0; z<26; ++z)
+		{
+			int c = min(abs(x-z), 26-abs(x-z)) + min(abs(y-z), 26-abs(y-z));
+			if( c < minC ) {
+				minC = c;
+				minZ = z;
+			}
+		}
+		return minZ;
+	}
+};
+
+// 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(_, EqualizeStrings().getEq(s, t));}
+int main(){
+
+CASE(0)
+	string s = "cat"; 
+	string t = "dog"; 
+	string _ = "caa"; 
+END
+CASE(1)
+	string s = "abcdefghijklmnopqrstuvwxyz"; 
+	string t = "bcdefghijklmnopqrstuvwxyza"; 
+	string _ = "abcdefghijklmnopqrstuvwxya"; 
+END
+CASE(2)
+	string s = "programmingcompetitionsrule"; 
+	string t = "programmingcompetitionsrule"; 
+	string _ = "programmingcompetitionsrule"; 
+END
+CASE(3)
+	string s = "topcoderopen"; 
+	string t = "onlinerounds"; 
+	string _ = "onlcndaoondn"; 
+END
+CASE(4)
+	string s = "a"; 
+	string t = "z"; 
+	string _ = "a"; 
+END
+CASE(5)
+	string s = "y"; 
+	string t = "z"; 
+	string _ = "y"; 
+END
+CASE(5)
+	string s = "z"; 
+	string t = "b"; 
+	string _ = "a"; 
+END
+CASE(5)
+	string s = "h"; 
+	string t = "t"; 
+	string _ = "h"; 
+END
+CASE(5)
+	string s = "b"; 
+	string t = "o"; 
+	string _ = "a"; 
+END
+CASE(5)
+	string s = "b"; 
+	string t = "n"; 
+	string _ = "b"; 
+END
+CASE(5)
+	string s = "b"; 
+	string t = "q"; 
+	string _ = "a"; 
+END
+}
+// END CUT HERE

ADDED   SRM/TCO10-1-U/1B.cpp
Index: SRM/TCO10-1-U/1B.cpp
==================================================================
--- SRM/TCO10-1-U/1B.cpp
+++ SRM/TCO10-1-U/1B.cpp
@@ -0,0 +1,148 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TwoRegisters { public:
+	string minProg(int r) 
+	{
+		int minn = 0x7fffffff;
+		vector<int> miny;
+		for(int y=1; y<r; ++y)
+		{
+			int n = cnt(r,y);
+			if( n != -1 )
+				if( n <= minn ) {
+					if( n < minn )
+						miny.clear();
+					minn = n;
+					miny.push_back(y);
+				}
+		}
+
+		string answer;
+		for(int i=0; i<miny.size(); ++i)
+		{
+			int y = miny[i];
+			string s;
+			compute(r, y, false, s);
+			if( i==0 || s < answer )
+				answer = s;
+		}
+		return answer;
+	}
+
+	int cnt(int r, int y)
+	{
+		if( y==0 )
+			return -1;
+		if( y==1 )
+			return r-1;
+		int k = r/y;
+		int kk = cnt(y, r%y);
+		if( kk == -1 )
+			return -1;
+		return k+kk;
+	}
+
+	void compute(int r, int y, bool isY, string& s)
+	{
+		if( y==1 ) {
+			for(int i=0; i<r-1; ++i)
+				s += (isY ? 'Y' : 'X');
+			return;
+		}
+		int k = r/y;
+		compute(y, r%y, !isY, s);
+		while( k --> 0 )
+			s += (isY ? 'Y' : '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(_, TwoRegisters().minProg(r));}
+int main(){
+
+CASE(0)
+	int r = 10; 
+	string _ = "XXYYX"; 
+END
+CASE(1)
+	int r = 3; 
+	string _ = "XX"; 
+END
+CASE(2)
+	int r = 20; 
+	string _ = "XYYYYXX"; 
+END
+CASE(3)
+	int r = 34; 
+	string _ = "XYXYXYX"; 
+END
+CASE(4)
+	int r = 1; 
+	string _ = ""; 
+END
+CASE(5)
+	int r = 1000000; 
+	string _ = "??"; 
+END
+CASE(6)
+	int r = 2; 
+	string _ = "X"; 
+END
+CASE(6)
+	int r = 999999; 
+	string _ = "??"; 
+END
+CASE(6)
+	int r = 999998; 
+	string _ = "??"; 
+END
+CASE(6)
+	int r = 999997; 
+	string _ = "??"; 
+END
+CASE(6)
+	int r = 999996; 
+	string _ = "??"; 
+END
+CASE(6)
+	int r = 999995; 
+	string _ = "??"; 
+END
+CASE(6)
+	int r = 5; 
+	string _ = "??"; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/TCO10-1-U/1C-U.cpp
Index: SRM/TCO10-1-U/1C-U.cpp
==================================================================
--- SRM/TCO10-1-U/1C-U.cpp
+++ SRM/TCO10-1-U/1C-U.cpp
@@ -0,0 +1,179 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class VacationTours { public:
+	int getIncome(vector <string> c, vector <string> d, int fee) 
+	{
+		int N = c.size();
+		vector< vector<int> > G(N, vector<int>(N));
+		for(int i=0; i<N; ++i)
+			for(int j=0; j<N; ++j)
+				G[i][j] = dec(c[i][j])*64 + dec(d[i][j]);
+
+		int basefee = fee * (N-1);
+		for(int i=1; i<N; ++i)
+			basefee -= G[0][i] + G[i][0];
+
+		typedef pair< int, pair<int,int> > edge;
+		set< edge, greater<edge> > es;
+		vector< vector<int> > P(N, vector<int>(N));
+		for(int i=1; i<N; ++i)
+			for(int j=1; j<N; ++j) if(i!=j) {
+				P[i][j] = -fee - G[i][j] + G[i][0] + G[0][j];
+				es.insert( edge(P[i][j], make_pair(i,j)) );
+			}
+
+		int gain = 0;
+
+		vector<bool> out(N,true), in(N,true);
+		vector<int> uf(N), sz(N);
+		for(int v=0; v<N; ++v) uf[v]=v, sz[v]=1;
+
+		for(set< edge, greater<edge> >::iterator it=es.begin(); it!=es.end(); ++it)
+		{
+			int c = it->first;
+			int a = it->second.first;
+			int b = it->second.second;
+			if( c <= 0 )
+				break;
+			if( !out[a] || !in[b] )
+				continue;
+			// repr
+			int ra=a; while(uf[ra]!=ra) ra=uf[ra];
+			int rb=b; while(uf[rb]!=rb) rb=uf[rb];
+			if( ra != rb ) {
+				gain += c;
+				// union
+				if( sz[ra] > sz[rb] ) swap(ra,rb);
+				uf[ra] = rb;
+				sz[rb] += sz[ra];
+				out[a] = false;
+				in[b] = false;
+			}
+		}
+
+		return max(0, basefee+gain);
+	}
+
+	int dec(char c)
+	{
+		if('A'<=c && c<='Z') return c-'A';
+		if('a'<=c && c<='z') return c-'a'+26;
+		if('0'<=c && c<='9') return c-'0'+52;
+		if(c=='+')return 62;
+		return 63;
+	}
+};
+
+// 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(_, VacationTours().getIncome(c, d, fee));}
+int main(){
+
+CASE(0)
+	string c_[] = {"AAA",
+ "AAA",
+ "AAA"};
+	  vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_)); 
+	string d_[] = {"ABJ",
+ "JAB",
+ "BJA"};
+	  vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_)); 
+	int fee = 15; 
+	int _ = 12; 
+END
+CASE(1)
+	string c_[] = {"AAAA",
+ "AAAA",
+ "AAAA",
+ "AAAA"};
+	  vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_)); 
+	string d_[] = {"AAAA",
+ "AAAA",
+ "AAAA",
+ "AAAA"};
+	  vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_)); 
+	int fee = 100; 
+	int _ = 300; 
+END
+CASE(2)
+	string c_[] = {"A//",
+ "/A/",
+ "//A"};
+	  vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_)); 
+	string d_[] = {"A//",
+ "/A/",
+ "//A"};
+	  vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_)); 
+	int fee = 1000; 
+	int _ = 0; 
+END
+CASE(3)
+	string c_[] = {"AAA////",
+ "/AA/A//",
+ "//AA/A/",
+ "A//AA//",
+ "///AAA/",
+ "///A/AA",
+ "AA////A"};
+	  vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_)); 
+	string d_[] = {"AKo////",
+ "/AU/X//",
+ "//AZ/o/",
+ "j//AK//",
+ "///XAo/",
+ "///y/AK",
+ "KP////A"};
+	  vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_)); 
+	int fee = 1000; 
+	int _ = 1809; 
+END
+	/*
+CASE(4)
+	string c_[] = ;
+	  vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_)); 
+	string d_[] = ;
+	  vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_)); 
+	int fee = ; 
+	int _ = ; 
+END
+CASE(5)
+	string c_[] = ;
+	  vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_)); 
+	string d_[] = ;
+	  vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_)); 
+	int fee = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/TCO10-2-U/1A.cpp
Index: SRM/TCO10-2-U/1A.cpp
==================================================================
--- SRM/TCO10-2-U/1A.cpp
+++ SRM/TCO10-2-U/1A.cpp
@@ -0,0 +1,129 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class SnowPlow { public:
+	int solve(vector <string> roads) 
+	{
+		int N = roads.size();
+
+		set< pair<int,int> > edges;
+		int sum = 0;
+		for(int i=0; i<N; ++i)
+			for(int j=i+1; j<N; ++j)
+				if( roads[i][j] > '0' ) {
+					edges.insert( make_pair(i,j) );
+					sum += 2*(roads[i][j]-'0');
+				}
+
+		set<int> vis;
+		queue<int> q; q.push(0);
+		while( !q.empty() ) {
+			int v = q.front();
+			q.pop();
+			for(int j=0; j<N; ++j) if( j!=v )
+				if( roads[v][j]>'0' ) {
+					edges.erase( make_pair(min(j,v), max(j,v)) );
+					if( !vis.count(j) ) {
+						q.push(j);
+						vis.insert(j);
+					}
+				}
+		}
+		return edges.empty() ? sum : -1;
+	}
+};
+
+// 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(_, SnowPlow().solve(roads));}
+int main(){
+
+CASE(0)
+	string roads_[] = {"010000",
+ "101000",
+ "010100",
+ "001010",
+ "000101",
+ "000010"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int _ = 10; 
+END
+CASE(1)
+	string roads_[] = {"010000",
+ "101000",
+ "010100",
+ "001020",
+ "000201",
+ "000010"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int _ = 12; 
+END
+CASE(2)
+	string roads_[] = {"031415",
+ "300000",
+ "100000",
+ "400000",
+ "100000",
+ "500000"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int _ = 28; 
+END
+CASE(3)
+	string roads_[] = {"0100",
+ "1000",
+ "0001",
+ "0010"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int _ = -1; 
+END
+CASE(4)
+	string roads_[] = {"0101",
+ "1001",
+ "0000",
+ "1100"};
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int _ = 6; 
+END
+/*
+CASE(5)
+	string roads_[] = ;
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int _ = ; 
+END
+CASE(6)
+	string roads_[] = ;
+	  vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/TCO10-2-U/1B.cpp
Index: SRM/TCO10-2-U/1B.cpp
==================================================================
--- SRM/TCO10-2-U/1B.cpp
+++ SRM/TCO10-2-U/1B.cpp
@@ -0,0 +1,143 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class RepresentableNumbers { public:
+	int getNext(int X) 
+	{
+		for(;; ++X) {
+			string s;
+			{stringstream sio; sio<<X; sio>>s;}
+			memo.clear();
+			memo.resize(200, -1);
+			if( rec(s, 0, false, false) )
+				return X;
+			if( s[0]=='1' ) {
+				if( rec(s, 1, false, true) )
+					return X;
+			}
+		}
+		assert(false);
+	}
+
+	vector<int> memo;
+	bool rec(const string& s, int i, bool mustUseBoth, bool needCarry)
+	{
+		if( i == (int)s.size() )
+			return !needCarry;
+		if( i+1 == (int)s.size() )
+			mustUseBoth = true;
+
+		int key = (i*2+mustUseBoth)*2+needCarry;
+		if( memo[key]>=0 )
+			return memo[key];
+		int t = (s[i]-'0') + (needCarry ? 10 : 0);
+
+		if( !mustUseBoth && (t==1 || t==3 || t==5 || t==7 || t==9) )
+			if( rec(s, i+1, false, false) )
+				return memo[key]=true;
+		if( !mustUseBoth && (t==2 || t==4 || t==6 || t==8 || t==10) )
+			if( rec(s, i+1, false, true) )
+				return memo[key]=true;
+		if( t<=1 )
+			return memo[key]=false;
+		if( t%2==0 )
+			return memo[key]=rec(s, i+1, true, false);
+		else
+			return memo[key]=rec(s, i+1, true, 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 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(_, RepresentableNumbers().getNext(X));}
+int main(){
+
+CASE(0)
+	int X = 1; 
+	int _ = 2; 
+END
+CASE(1)
+	int X = 999; 
+	int _ = 1000; 
+END
+CASE(2)
+	int X = 2000; 
+	int _ = 2000; 
+END
+CASE(3)
+	int X = 4201234; 
+	int _ = 4222222; 
+END
+CASE(4)
+	int X = 10101010; 
+	int _ = 10102222; 
+END
+CASE(5)
+	int X = 2; 
+	int _ = 2; 
+END
+CASE(5)
+	int X = 3; 
+	int _ = 4; 
+END
+CASE(5)
+	int X = 4; 
+	int _ = 4; 
+END
+CASE(5)
+	int X = 5; 
+	int _ = 6; 
+END
+CASE(5)
+	int X = 6; 
+	int _ = 6; 
+END
+CASE(5)
+	int X = 20; 
+	int _ = 20; 
+END
+CASE(6)
+	int X = 100000000; 
+	int _ = -1; 
+END
+CASE(6)
+	int X =  42012345; 
+	int _ = -1; 
+END
+CASE(6)
+	int X =  21999999; 
+	int _ = -1; 
+END
+
+
+}
+// END CUT HERE

ADDED   SRM/TCO10-2-U/1C-U.cpp
Index: SRM/TCO10-2-U/1C-U.cpp
==================================================================
--- SRM/TCO10-2-U/1C-U.cpp
+++ SRM/TCO10-2-U/1C-U.cpp
@@ -0,0 +1,110 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class BreakingChocolate { public:
+	int minSteps(int W, int H, vector <int> sx, vector <int> sy) 
+	{
+		
+	}
+};
+
+// 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(_, BreakingChocolate().minSteps(W, H, sx, sy));}
+int main(){
+
+CASE(0)
+	int W = 3; 
+	int H = 3; 
+	int sx_[] = {2};
+	  vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_)); 
+	int sy_[] = {2};
+	  vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_)); 
+	int _ = 4; 
+END
+CASE(1)
+	int W = 2; 
+	int H = 2; 
+	int sx_[] = {1,2};
+	  vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_)); 
+	int sy_[] = {2,1};
+	  vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_)); 
+	int _ = 3; 
+END
+CASE(2)
+	int W = 10; 
+	int H = 10; 
+	int sx_[] = {1};
+	  vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_)); 
+	int sy_[] = {1};
+	  vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_)); 
+	int _ = 2; 
+END
+CASE(3)
+	int W = 10; 
+	int H = 10; 
+	int sx_[] = {3,5,6};
+	  vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_)); 
+	int sy_[] = {5,5,5};
+	  vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_)); 
+	int _ = 6; 
+END
+CASE(4)
+	int W = 3; 
+	int H = 3; 
+	int sx_[] = {1,1,1,2,2,3,3,3};
+	  vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_)); 
+	int sy_[] = {1,2,3,1,3,1,2,3};
+	  vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_)); 
+	int _ = 4; 
+END
+CASE(5)
+	int W = ; 
+	int H = ; 
+	int sx_[] = ;
+	  vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_)); 
+	int sy_[] = ;
+	  vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_)); 
+	int _ = ; 
+END
+CASE(6)
+	int W = ; 
+	int H = ; 
+	int sx_[] = ;
+	  vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_)); 
+	int sy_[] = ;
+	  vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_)); 
+	int _ = ; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/TCO10-3/1A.cpp
Index: SRM/TCO10-3/1A.cpp
==================================================================
--- SRM/TCO10-3/1A.cpp
+++ SRM/TCO10-3/1A.cpp
@@ -0,0 +1,98 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class SieveOfEratosthenes { public:
+	vector<int> eratos(int M)
+	{
+		vector<bool> isComposite(M+1);
+		vector<int> ps;
+		for(int p=2; p<=M; ++p)
+			if( !isComposite[p] )
+			{
+				ps.push_back(p);
+				for(LL q=LL(p)*p; q<=M; q+=p)
+					isComposite[q] = true;
+			}
+		return ps;
+	}
+
+	int minFactor(int N, const vector<int>& ps)
+	{
+		for(int i=0; i<ps.size(); ++i)
+			if( N % ps[i] == 0 )
+				return ps[i];
+		return INT_MAX;
+	}
+
+	int lastScratch(int maxNum)
+	{
+		vector<int> ps = eratos(int(sqrt(double(maxNum))));
+		int P = ps.back();
+		int M = P*P;
+		for(int Q=P+1; P*Q<=maxNum; ++Q)
+			if( minFactor(Q,ps) >= P )
+				M = P*Q;
+		return M;
+	}
+};
+
+// 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(_, SieveOfEratosthenes().lastScratch(maxNum));}
+int main(){
+
+CASE(0)
+	int maxNum = 18; 
+	int _ = 15; 
+END
+CASE(1)
+	int maxNum = 5; 
+	int _ = 4; 
+END
+CASE(2)
+	int maxNum = 100; 
+	int _ = 91; 
+END
+CASE(3)
+	int maxNum = 400; 
+	int _ = 361; 
+END
+CASE(4)
+	int maxNum = 2000000000; 
+	int _ = -1; 
+END
+CASE(5)
+	int maxNum = 8; 
+	int _ = 8; 
+END
+}
+// END CUT HERE

ADDED   SRM/TCO10-3/1B.cpp
Index: SRM/TCO10-3/1B.cpp
==================================================================
--- SRM/TCO10-3/1B.cpp
+++ SRM/TCO10-3/1B.cpp
@@ -0,0 +1,150 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class TheChroniclesOfAmber { public:
+	double minimumTime(vector <int> princeX, vector <int> princeY, vector <int> destinationX, vector <int> destinationY) 
+	{
+		int N = princeX.size();
+
+		// d[s][g] := the distance from prince[s] to dest[g]
+		vector< vector<double> > d(N, vector<double>(N));
+		for(int s=0; s<N; ++s)
+			for(int g=0; g<N; ++g)
+				d[s][g] = hypot(princeX[s]-destinationX[g], princeY[s]-destinationY[g]);
+
+		// no teleportation
+		double noTelepo = 0;
+		for(int i=0; i<N; ++i)
+			noTelepo = max(noTelepo, d[i][i]);
+
+		// with teleportation: at least one position must be empty
+		double answer = noTelepo;
+		for(int unused_s=0; unused_s<N; ++unused_s) {
+			double withTelepo = 0;
+			for(int g=0; g<N; ++g) { // for each goal
+				double t = 1e+300;
+				for(int s=0; s<N; ++s) if( s != unused_s )
+					t = min(t, d[s][g]); // find the nearest starting point
+				withTelepo = max(withTelepo, t);
+			}
+			answer = min(answer, withTelepo); // take the minimum
+		}
+		return answer;
+	}
+};
+
+// 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(_, TheChroniclesOfAmber().minimumTime(princeX, princeY, destinationX, destinationY));}
+int main(){
+
+CASE(0)
+	int princeX_[] = {1,5,5};
+	  vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_)); 
+	int princeY_[] = {0,0,0};
+	  vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_)); 
+	int destinationX_[] = {1,1,0};
+	  vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_)); 
+	int destinationY_[] = {4,2,3};
+	  vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_)); 
+	double _ = 4.0; 
+END
+CASE(1)
+	int princeX_[] = {0,0,0};
+	  vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_)); 
+	int princeY_[] = {1,2,3};
+	  vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_)); 
+	int destinationX_[] = {0,0,0};
+	  vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_)); 
+	int destinationY_[] = {0,2,4};
+	  vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_)); 
+	double _ = 1.0; 
+END
+CASE(2)
+	int princeX_[] = {0,0,0};
+	  vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_)); 
+	int princeY_[] = {1,2,3};
+	  vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_)); 
+	int destinationX_[] = {0,0,0};
+	  vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_)); 
+	int destinationY_[] = {4,2,0};
+	  vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_)); 
+	double _ = 1.0; 
+END
+CASE(3)
+	int princeX_[] = {0,3,5};
+	  vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_)); 
+	int princeY_[] = {0,4,0};
+	  vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_)); 
+	int destinationX_[] = {3,5,0};
+	  vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_)); 
+	int destinationY_[] = {4,0,0};
+	  vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_)); 
+	double _ = 4.47213595499958; 
+END
+CASE(4)
+	int princeX_[] = {3629,6751,8655,5115,7809,6759,7133,1810,6102,2539,1777,242};
+	  vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_)); 
+	int princeY_[] = {5294,180,988,7780,1635,7904,845,7405,4800,2567,4795,2339};
+	  vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_)); 
+	int destinationX_[] = {8723,9275,6705,5875,7981,7666,1158,4135,17,2984,5086,3570};
+	  vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_)); 
+	int destinationY_[] = {6166,53,5980,4499,412,9074,8190,847,650,9158,9116,4396};
+	  vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_)); 
+	double _ = 2622.582696503582; 
+END
+CASE(5)
+int princeX_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
+	  vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_)); 
+	int princeY_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
+	  vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_)); 
+	int destinationX_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
+	  vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_)); 
+	int destinationY_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
+	  vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_)); 
+	double _ = 0; 
+END
+/*
+CASE(6)
+	int princeX_[] = ;
+	  vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_)); 
+	int princeY_[] = ;
+	  vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_)); 
+	int destinationX_[] = ;
+	  vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_)); 
+	int destinationY_[] = ;
+	  vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_)); 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/TCO10-3/1C.cpp
Index: SRM/TCO10-3/1C.cpp
==================================================================
--- SRM/TCO10-3/1C.cpp
+++ SRM/TCO10-3/1C.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 <cstring>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int MODVAL = 1000000009;
+struct mint
+{
+	int val;
+	mint():val(0){}
+	mint(int x):val(x%MODVAL) {}
+	mint(LL  x):val(x%MODVAL) {}
+};
+
+mint operator+(mint x, mint y) { return x.val+y.val; }
+mint operator-(mint x, mint y) { return x.val-y.val+MODVAL; }
+mint operator*(mint x, mint y) { return LL(x.val)*y.val; }
+mint POW(mint x, int e) {
+	mint v = 1;
+	for(;e;x=x*x,e>>=1)
+		if(e&1)
+			v=v*x;
+	return v;
+}
+mint operator/(mint x, mint y) { return x * POW(y, MODVAL-2); }
+
+vector<mint> FAC_(1,1);
+void FAC_INIT(int n) { for(int i=1; i<=n; ++i) FAC_.push_back( FAC_.back()*i ); }
+mint FAC(mint x)       { return FAC_[x.val]; }
+mint C(mint n, mint k) { return k.val<0 || n.val<k.val ? 0 : FAC(n) / (FAC(k) * FAC(n-k)); }
+
+class Passwords { public:
+	int countValid(int N, int L, int U, int D) 
+	{
+		FAC_INIT(200000);
+
+		//  Sigma_{D<=d<=N-U-L} [C(N,d) 10^d Sigma_{L<=l,U<=u,u+l=N-d}[ C(N-d,u) 26^u 26^l ] ]
+		//= Sigma_{D<=d<=N-U-L} [C(N,d) 10^d 26^(N-d) Sigma_{U<=u<=N-d-L}[ C(N-d,u) ] ]
+		//   let f(N') = Sigma_{U<=u<=N'-L}[ C(N',u) ]
+		//      then by Pascal's triangle, f(N') = 2*f(N'-1)+C(N'-1,U-1)+C(N'-1,N'-L)
+
+		mint answer=0, f=C(U+L,U);
+		for(int d=N-U-L; d>=D; --d)
+		{
+			answer = answer + C(N,d)*POW(10,d)*POW(26,N-d)*f;
+			f = f*2 + C(N-d,U-1) + C(N-d, N-d-L+1);
+		}
+		return answer.val;
+	}
+};
+
+// 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(_, Passwords().countValid(N, L, U, D));}
+int main(){
+
+CASE(0)
+	int N = 2; 
+	int L = 0; 
+	int U = 0; 
+	int D = 2; 
+	int _ = 100; 
+END
+CASE(1)
+	int N = 3; 
+	int L = 1; 
+	int U = 1; 
+	int D = 1; 
+	int _ = 40560; 
+END
+CASE(2)
+	int N = 4; 
+	int L = 1; 
+	int U = 1; 
+	int D = 1; 
+	int _ = 5029440; 
+END
+CASE(3)
+	int N = 10; 
+	int L = 1; 
+	int U = 3; 
+	int D = 3; 
+	int _ = 818019214; 
+END
+CASE(4)
+	int N = 5; 
+	int L = 2; 
+	int U = 2; 
+	int D = 2; 
+	int _ = 0; 
+END
+CASE(5)
+	int N = 199201;
+	int L = 0; 
+	int U = 70000; 
+	int D = 0; 
+	int _ = 943311211; 
+END
+CASE(6)
+	int N = 200000; 
+	int L = 11; 
+	int U = 111; 
+	int D = 1111; 
+	int _ = 298235838; 
+END
+}
+// END CUT HERE

ADDED   SRM/TCO9-1/A.cpp
Index: SRM/TCO9-1/A.cpp
==================================================================
--- SRM/TCO9-1/A.cpp
+++ SRM/TCO9-1/A.cpp
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class SequenceSums {
+public:
+	vector <int> sequence(int N, int LL) 
+	{
+		for(int L=LL; L<=100; ++L)
+		{
+			int Z = N - L*(L-1)/2;
+			if( Z % L )
+				continue;
+			int a = Z / L;
+			if( a < 0 )
+				continue;
+
+			vector<int> ans;
+			for(int x=a; x<a+L; ++x)
+				ans.push_back(x);
+			return ans;
+		}
+		return vector<int>();
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int N = 18; 
+	int L = 2; 
+	int RetVal_[] = {5, 6, 7 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SequenceSums().sequence(N, L)); }
+int Test_(Case_<1>) {
+	int N = 18; 
+	int L = 4; 
+	int RetVal_[] = {3, 4, 5, 6 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SequenceSums().sequence(N, L)); }
+int Test_(Case_<2>) {
+	int N = 18; 
+	int L = 5; 
+	vector <int> RetVal; 
+	return verify_case(RetVal, SequenceSums().sequence(N, L)); }
+int Test_(Case_<3>) {
+	int N = 45; 
+	int L = 10; 
+	int RetVal_[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SequenceSums().sequence(N, L)); }
+int Test_(Case_<4>) {
+	int N = 1000000000; 
+	int L = 2; 
+	int RetVal_[] = {199999998, 199999999, 200000000, 200000001, 200000002 };
+	  vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, SequenceSums().sequence(N, L)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/TCO9-1/B.cpp
Index: SRM/TCO9-1/B.cpp
==================================================================
--- SRM/TCO9-1/B.cpp
+++ SRM/TCO9-1/B.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 <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+class KthProbableElement {
+public:
+  double probability(int M, int lowerBound, int upperBound, int N, int K) 
+  {
+    double dp1[101][101]={0}, dp2[101][101], (*P)[101]=dp1, (*Q)[101]=dp2;
+
+    P[0][0] = 1.0;
+    for(int i=0; i<M; ++i)
+    {
+      memset( Q, 0, sizeof(double)*101*101 );
+      for(int a=0; a<=i; ++a)
+        for(int b=0; a+b<=i; ++b)
+        {
+          Q[a+1][b] += P[a][b] * (N-lowerBound) / (upperBound-lowerBound+1);
+          Q[a][b+1] += P[a][b] * 1 / (upperBound-lowerBound+1);
+          Q[a][b]   += P[a][b] * (upperBound-N) / (upperBound-lowerBound+1);
+        }
+      swap(P, Q);
+    }
+
+    double p = 0.0;
+    for(int a=0; a<=M; ++a)
+      for(int b=0; a+b<=M; ++b)
+        if( a<K && K<=a+b )
+          p += P[a][b];
+    return p;
+  }
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+  int M = 1; 
+  int lowerBound = 1; 
+  int upperBound = 10; 
+  int N = 3; 
+  int K = 1; 
+  double RetVal = 0.1; 
+  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
+int Test_(Case_<1>) {
+  int M = 3; 
+  int lowerBound = 1; 
+  int upperBound = 2; 
+  int N = 2; 
+  int K = 2; 
+  double RetVal = 0.5; 
+  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
+int Test_(Case_<2>) {
+  int M = 3; 
+  int lowerBound = 1; 
+  int upperBound = 3; 
+  int N = 2; 
+  int K = 2; 
+  double RetVal = 0.48148148148148145; 
+  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
+int Test_(Case_<3>) {
+  int M = 10; 
+  int lowerBound = 1; 
+  int upperBound = 10; 
+  int N = 1; 
+  int K = 10; 
+  double RetVal = 1.0000000000000003E-10; 
+  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
+int Test_(Case_<4>) {
+  int M = 4; 
+  int lowerBound = 61; 
+  int upperBound = 65; 
+  int N = 62; 
+  int K = 3; 
+  double RetVal = 0.15200000000000002; 
+  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/TCO9-1/C.cpp
Index: SRM/TCO9-1/C.cpp
==================================================================
--- SRM/TCO9-1/C.cpp
+++ SRM/TCO9-1/C.cpp
@@ -0,0 +1,161 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+using namespace std;
+typedef long long LL;
+
+static const int MODVAL = 1000000007;
+int ADD(int x, int y) { return (x+y)%MODVAL; }
+int SUB(int x, int y) { return (x-y+MODVAL)%MODVAL; }
+
+class Unicorn {
+public:
+	int countWays(int R, int C, int L, int seed, string word) 
+	{
+		// input...
+		char B[300][300];
+		{
+			int x = seed;
+			int d = (65535 / L)+1;
+			for (int r=0; r<R; r++)
+			  for (int c=0; c<C; c++) {
+			    x = (x * 25173 + 13849) % 65536;
+			    B[r][c] = (65+(x / d));
+			  }
+		}
+
+		// solve
+		vector<int> cnt(C*R);
+		for(int r=0; r<R; ++r)
+		for(int c=0; c<C; ++c)
+			if( B[r][c] == word[0] )
+				cnt[r*C+c] = 1;
+
+		for(int i=1; i<word.size(); ++i)
+		{
+			int total_cnt = 0;
+			vector<int> c_cnt(C);
+			vector<int> r_cnt(R);
+			for(int r=0; r<R; ++r)
+			for(int c=0; c<C; ++c)
+				r_cnt[r]  = ADD( r_cnt[r], cnt[r*C+c]),
+				c_cnt[c]  = ADD( c_cnt[c], cnt[r*C+c]),
+				total_cnt = ADD(total_cnt, cnt[r*C+c]);
+
+			vector<int> cnt2(C*R);
+			for(int r=0; r<R; ++r)
+			for(int c=0; c<C; ++c)
+				if( B[r][c] == word[i] )
+				{
+					int x = total_cnt;
+
+					for(int rr=r-1; rr<=r+1; ++rr) if(0<=rr && rr<R)
+						x = SUB(x, r_cnt[rr]);
+					for(int cc=c-1; cc<=c+1; ++cc) if(0<=cc && cc<C)
+						x = SUB(x, c_cnt[cc]);
+
+					for(int rr=r-1; rr<=r+1; ++rr) if(0<=rr && rr<R)
+					for(int cc=c-1; cc<=c+1; ++cc) if(0<=cc && cc<C)
+						x = ADD(x, cnt[rr*C+cc]);
+
+					for(int rr=r-2; rr<=r+2; rr+=4) if(0<=rr && rr<R)
+					for(int cc=c-2; cc<=c+2; cc+=4) if(0<=cc && cc<C)
+						x = SUB(x, cnt[rr*C+cc]);
+
+					cnt2[r*C+c] = x;
+				}
+			cnt.swap(cnt2);
+		}
+
+		int live = 0;
+		for(int r=0; r<R; ++r)
+		for(int c=0; c<C; ++c)
+			live = ADD(live, cnt[r*C+c]);
+		return live;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int R = 3; 
+	int C = 4; 
+	int L = 2; 
+	int seed = 47; 
+	string word = "AB"; 
+	int RetVal = 2; 
+	return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
+int Test_(Case_<1>) {
+	int R = 5; 
+	int C = 5; 
+	int L = 2; 
+	int seed = 47; 
+	string word = "CD"; 
+	int RetVal = 0; 
+	return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
+int Test_(Case_<2>) {
+	int R = 4; 
+	int C = 4; 
+	int L = 1; 
+	int seed = 42; 
+	string word = "AA"; 
+	int RetVal = 20; 
+	return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
+int Test_(Case_<3>) {
+	int R = 4; 
+	int C = 4; 
+	int L = 1; 
+	int seed = 42; 
+	string word = "AAAAA"; 
+	int RetVal = 172; 
+	return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
+int Test_(Case_<4>) {
+	int R = 1; 
+	int C = 1; 
+	int L = 5; 
+	int seed = 54321; 
+	string word = "ABCDE"; 
+	int RetVal = 0; 
+	return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
+int Test_(Case_<5>) {
+	int R = 8; 
+	int C = 8; 
+	int L = 26; 
+	int seed = 226; 
+	string word = "TOPCODER"; 
+	int RetVal = 1; 
+	return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
+int Test_(Case_<6>) {
+	int R = 20; 
+	int C = 20; 
+	int L = 2; 
+	int seed = 47; 
+	string word = "AAAAA"; 
+	int RetVal = 373977054; 
+	return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/TCO9-2/1A.cpp
Index: SRM/TCO9-2/1A.cpp
==================================================================
--- SRM/TCO9-2/1A.cpp
+++ SRM/TCO9-2/1A.cpp
@@ -0,0 +1,113 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+LL s, N, K;
+
+class PlaneFractal {
+public:
+	vector <string> getPattern(int _s, int _N, int _K, int r1, int r2, int c1, int c2) 
+	{
+		s = _s;
+		N = _N;
+		K = _K;
+
+		LL Ns=1; for(int i=0; i<s-1; ++i) Ns*=N;
+
+		vector<string> ans(r2-r1+1, string(c2-c1+1, '0'));
+		for(int r=r1; r<=r2; ++r)
+		for(int c=c1; c<=c2; ++c)
+			if( s>0 && black(r,c,Ns) )
+				ans[r-r1][c-c1] = '1';
+		return ans;
+	}
+
+	bool black(int y, int x, LL Ns) const
+	{
+		if( Ns == 0 )
+			return false;
+
+		int Y = y/Ns, X = x/Ns;
+		y%=Ns, x%=Ns;
+		if( (Y<(N-K)/2 || N-(N-K)/2<=Y) || (X<(N-K)/2 || N-(N-K)/2<=X) )
+			return black(y, x, Ns/N);
+		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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int s = 1; 
+	int N = 5; 
+	int K = 3; 
+	int r1 = 0; 
+	int r2 = 4; 
+	int c1 = 0; 
+	int c2 = 4; 
+	string RetVal_[] = {"00000", "01110", "01110", "01110", "00000" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PlaneFractal().getPattern(s, N, K, r1, r2, c1, c2)); }
+int Test_(Case_<1>) {
+	int s = 2; 
+	int N = 3; 
+	int K = 1; 
+	int r1 = 0; 
+	int r2 = 8; 
+	int c1 = 0; 
+	int c2 = 8; 
+	string RetVal_[] = {"000000000", "010010010", "000000000", "000111000", "010111010", "000111000", "000000000", "010010010", "000000000" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PlaneFractal().getPattern(s, N, K, r1, r2, c1, c2)); }
+int Test_(Case_<2>) {
+	int s = 3; 
+	int N = 3; 
+	int K = 1; 
+	int r1 = 4; 
+	int r2 = 11; 
+	int c1 = 5; 
+	int c2 = 10; 
+	string RetVal_[] = {"101001", "100000", "000000", "001001", "000000", "000011", "001011", "000011" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PlaneFractal().getPattern(s, N, K, r1, r2, c1, c2)); }
+int Test_(Case_<3>) {
+	int s = 2; 
+	int N = 8; 
+	int K = 4; 
+	int r1 = 56; 
+	int r2 = 61; 
+	int c1 = 33; 
+	int c2 = 56; 
+	string RetVal_[] = {"000000000000000000000000", "000000000000000000000000", "011110000111100001111000", "011110000111100001111000", "011110000111100001111000", "011110000111100001111000" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, PlaneFractal().getPattern(s, N, K, r1, r2, c1, c2)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/TCO9-2/1B.cpp
Index: SRM/TCO9-2/1B.cpp
==================================================================
--- SRM/TCO9-2/1B.cpp
+++ SRM/TCO9-2/1B.cpp
@@ -0,0 +1,187 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<int> CMP;
+
+double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
+double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
+
+int ccw(const CMP& a, CMP b, CMP c) {
+	b -= a; c -= a;
+	if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
+	if( outer_prod(b,c) < 0 ) return -1; // clockwise
+	if( inner_prod(b,c) < 0 ) return +2; // c--a--b on line
+	if( norm(b) < norm(c) )   return -2; // a--b--c on line
+	return 0;
+}
+
+bool byX( const CMP& a, const CMP& b ) {
+	if( a.real() != b.real() )
+		return a.real() < b.real();
+	return a.imag() < b.imag();
+}
+
+vector<CMP> convex_hull( vector<CMP> p )
+{
+	//#define IS_RIGHT <0   // skip on-line verts
+	#define IS_RIGHT ==-1 // take all
+
+	sort(p.begin(), p.end(), &byX);
+
+	vector<CMP> ans;
+	for(int i=0; i<p.size(); ans.push_back(p[i++])) // left-to-right
+		while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
+			ans.pop_back();
+	if( ans.size() == p.size() )
+		return ans;
+	for(int i=p.size()-2; i>=0; ans.push_back(p[i--])) // right-to-left
+		while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
+			ans.pop_back();
+	ans.pop_back();
+	return ans;
+}
+
+int area(const CMP& a, const CMP& b, const CMP& c)
+{
+	return (int) abs( outer_prod(b-a,c-a) );
+}
+
+class ExtendableTriangles {
+public:
+	int getCount(vector <string> grid) 
+	{
+		vector<CMP> r, g, b;
+		for(int y=0; y<grid.size(); ++y)
+			for(int x=0; x<grid[0].size(); ++x)
+				(grid[y][x]=='R' ? r : grid[y][x]=='G' ? g : b).push_back( CMP(y,x) );
+
+		int cnt = r.size() * g.size() * b.size();
+
+		r = convex_hull(r);
+		g = convex_hull(g);
+		b = convex_hull(b);
+
+		bool (*ext)[200][200] = (bool(*)[200][200])calloc(200*200*200, 1);
+		for(int i=0; i<r.size(); ++i)
+			for(int j=0; j<g.size(); ++j)
+			{
+				int ma = -1;
+				for(int k=0; k<b.size(); ++k)
+					ma = max(ma, area(r[i], g[j], b[k]));
+				for(int k=0; k<b.size(); ++k)
+					if( area(r[i], g[j], b[k]) < ma )
+						ext[i][j][k] = true;
+			}
+		for(int j=0; j<g.size(); ++j)
+			for(int k=0; k<b.size(); ++k)
+			{
+				int ma = -1;
+				for(int i=0; i<r.size(); ++i)
+					ma = max(ma, area(r[i], g[j], b[k]));
+				for(int i=0; i<r.size(); ++i)
+					if( area(r[i], g[j], b[k]) < ma )
+						ext[i][j][k] = true;
+			}
+		for(int k=0; k<b.size(); ++k)
+			for(int i=0; i<r.size(); ++i)
+			{
+				int ma = -1;
+				for(int j=0; j<g.size(); ++j)
+					ma = max(ma, area(r[i], g[j], b[k]));
+				for(int j=0; j<g.size(); ++j)
+					if( area(r[i], g[j], b[k]) < ma )
+						ext[i][j][k] = true;
+			}
+		for(int i=0; i<r.size(); ++i)
+			for(int j=0; j<g.size(); ++j)
+				for(int k=0; k<b.size(); ++k)
+					if( !ext[i][j][k] )
+						--cnt;
+		free(ext);
+		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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+
+int Test_(Case_<0>) {
+	string grid_[] = {"RGB"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
+int Test_(Case_<1>) {
+	string grid_[] = {"RGB",
+ "RGB"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int RetVal = 6; 
+	return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
+int Test_(Case_<2>) {
+	string grid_[] = {"RRRRRRRR",
+ "GGGGBBBB",
+ "RRRRRRRR"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int RetVal = 240; 
+	return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
+int Test_(Case_<3>) {
+	string grid_[] = {"RBRBRBRB",
+ "BRBRBRBR",
+ "RBRBRBRB",
+ "BRBRBRBR",
+ "RRRRRRRR",
+ "BBBBBBBB",
+ "RRRRBBBB",
+ "BBBBRRRR"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
+int Test_(Case_<4>) {
+	string grid_[] = {"RGB",
+ "RBG",
+ "GRB",
+ "GBR",
+ "BRG",
+ "BGR"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int RetVal = 208; 
+	return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
+int Test_(Case_<5>) {
+	string grid_[] = {"BBRRBBGRBG"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int RetVal = 0; 
+	return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
+int Test_(Case_<6>) {
+	string grid_[] = {"RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR", "RGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGR", "RGBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBGR", "RGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGR", "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR"};
+	  vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_)); 
+	int RetVal = 565039154;
+	return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
+
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/TCO9-2/1C.cpp
Index: SRM/TCO9-2/1C.cpp
==================================================================
--- SRM/TCO9-2/1C.cpp
+++ SRM/TCO9-2/1C.cpp
@@ -0,0 +1,207 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const int NV = 128;
+typedef int           flow;
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+typedef flow          flow_graph[NV][NV];
+
+flow dinic_dfs( graph& G, flow_graph F, vert v, vert D,
+                int LV[], flow flow_in, int blocked[] )
+{
+	flow flow_out = 0;
+	for(int i=0; i!=G[v].size(); ++i) {
+		int u = G[v][i];
+		if( LV[v]+1==LV[u] && F[v][u] ) {
+			flow f = min(flow_in-flow_out, F[v][u]);
+			if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) ) {
+				F[v][u]  -= f;
+				F[u][v]  += f;
+				flow_out += f;
+				if( flow_in == flow_out ) return flow_out;
+			}
+		}
+	}
+	blocked[v] = (flow_out==0);
+	return flow_out;
+}
+
+flow maxFlow( graph& G, flow_graph F, vert S, vert D )
+{
+	for( flow total=0 ;; ) {
+		int LV[NV] = {0};
+		vector<int> Q(1, S);
+		for(int lv=1; !Q.empty(); ++lv) {
+			vector<int> Q2;
+			for(int i=0; i!=Q.size(); ++i) {
+				edges& ne = G[Q[i]];
+				for(int j=0; j!=ne.size(); ++j)
+					if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
+						LV[ne[j]]=lv, Q2.push_back(ne[j]);
+			}
+			Q.swap(Q2);
+		}
+
+		if( !LV[D] )
+			return total;
+
+		int blocked[NV] = {};
+		total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
+	}
+}
+
+flow_graph F, XXF;
+
+class ConnectingAirports {
+public:
+	vector <string> getSchedule(vector <int> capacityA, vector <int> capacityB) 
+	{
+		int NA = capacityA.size();
+		int NB = capacityB.size();
+		int CAsum = accumulate(capacityA.begin(), capacityA.end(), 0);
+		int CBsum = accumulate(capacityB.begin(), capacityB.end(), 0);
+		if( CAsum != CBsum )
+			return vector<string>();
+
+		graph G(2+NA+NB);
+		memset(XXF, 0, sizeof XXF);
+		for(int i=0; i<capacityA.size(); ++i) {
+			G[0].push_back( 2+i );
+			G[2+i].push_back( 0 );
+			XXF[0][2+i] = capacityA[i];
+		}
+		for(int i=0; i<capacityB.size(); ++i) {
+			G[2+NA+i].push_back( 1 );
+			G[1].push_back( 2+NA+i );
+			XXF[2+NA+i][1] = capacityB[i];
+		}
+		for(int i=0; i<capacityA.size(); ++i)
+		for(int j=0; j<capacityB.size(); ++j) {
+			G[2+i].push_back( 2+NA+j );
+			G[2+NA+j].push_back( 2+i );
+			XXF[2+i][2+NA+j] = 1;
+		}
+
+		memcpy(F, XXF, sizeof F);
+		flow mf = maxFlow(G,F,0,1);
+		if( mf != CAsum )
+			return vector<string>();
+
+		// find lex-best
+		int rest = CAsum;
+		vector<string> ans(NA, string(NB, '0'));
+		for(int i=0; i<capacityA.size(); ++i)
+		for(int j=0; j<capacityB.size(); ++j)
+		{
+			if( rest==0 )
+				return ans;
+
+			memcpy(F, XXF, sizeof F);
+			bool toUse = true;
+
+			F[2+i][2+NA+j] --;
+			flow mf = maxFlow(G,F,0,1);
+			toUse = (mf < rest);
+
+			ans[i][j] = toUse ? '1' : '0';
+			if( toUse ) {
+				XXF[0][2+i] --;
+				XXF[2+NA+j][1] --;
+				rest--;
+			}
+			XXF[2+i][2+NA+j] --;
+		}
+		return ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int capacityA_[] = {1,2,3};
+	  vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_)); 
+	int capacityU_[] = {3,1,2};
+	  vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_)); 
+	string RetVal_[] = {"100", "101", "111" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
+int Test_(Case_<1>) {
+	int capacityA_[] = {3,2,1,1};
+	  vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_)); 
+	int capacityU_[] = {1,3,1,2};
+	  vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_)); 
+	string RetVal_[] = {"0111", "0101", "0100", "1000" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
+int Test_(Case_<2>) {
+	int capacityA_[] = {1,2,3,4};
+	  vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_)); 
+	int capacityU_[] = {5,6,7,8};
+	  vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_)); 
+	vector <string> RetVal; 
+	return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
+int Test_(Case_<3>) {
+	int capacityA_[] = {47,47};
+	  vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_)); 
+	int capacityU_[] = {47,40,7};
+	  vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_)); 
+	vector <string> RetVal; 
+	return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
+int Test_(Case_<4>) {
+	int capacityA_[] = {5,5};
+	  vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_)); 
+	int capacityU_[] = {1,1,2,1,1,1,1,1,1};
+	  vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_)); 
+	string RetVal_[] = {"001001111", "111110000" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
+int Test_(Case_<5>) {
+	int capacityA_[] = {0,0,0,0};
+	  vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_)); 
+	int capacityU_[] = {0,0,0,0,0,0};
+	  vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_)); 
+	string RetVal_[] = {"000000", "000000", "000000", "000000" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
+int Test_(Case_<6>) {
+	int capacityA_[] = {50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,};
+	  vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_)); 
+	int capacityU_[] = {50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,};
+	  vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_)); 
+	string RetVal_[] = {"000000", "000000", "000000", "000000" };
+	  vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_)); 
+	return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   SRM/TCO9-3-U/1A.cpp
Index: SRM/TCO9-3-U/1A.cpp
==================================================================
--- SRM/TCO9-3-U/1A.cpp
+++ SRM/TCO9-3-U/1A.cpp
@@ -0,0 +1,141 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class SaveTheTrees {
+public:
+	int minimumCut(vector <int> x, vector <int> y, vector <int> h) 
+	{
+		int N = x.size();
+		int ans = N-1;
+		for(int i1=0; i1<N; ++i1)
+		for(int i2=0; i2<N; ++i2)
+		for(int k1=0; k1<N; ++k1)
+		for(int k2=0; k2<N; ++k2) {
+			int mx = min(x[i1], x[i2]);
+			int Mx = max(x[i1], x[i2]);
+			int my = min(y[k1], y[k2]);
+			int My = max(y[k1], y[k2]);
+
+			int hh[40], q=0;
+			int cut = 0, need = ((Mx-mx) + (My-my))*2;
+			for(int j=0; j<N; ++j)
+				if( mx<=x[j] && x[j]<=Mx && my<=y[j] && y[j]<=My )
+					hh[q++] = h[j];
+				else {
+					cut++, need-=h[j];
+					if(cut>=ans) goto next;
+				}
+			if( need > 0 )
+			{
+				sort( &hh[0], &hh[q], greater<int>() );
+//				partial_sum( &hh[0], &hh[q], &hh[0] );
+//				cut += lower_bound( &hh[0], &hh[q], need ) - &hh[0];
+				for(int p=0; p<q; ++p) {
+					++cut, need -= hh[p];
+					if(cut>=ans) goto next;
+					if(need <= 0) break;
+				}
+			}
+			ans = cut;
+		next:;
+		}
+		return ans;
+	}
+};
+
+// 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> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
+int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
+
+template<int N> struct Case_ { Case_(){start_time=clock();} };
+char Test_(...);
+int Test_(Case_<0>) {
+	int x_[] = {1, 2, 8, 9, 5};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1, 8, 2, 9, 5};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int h_[] = {1, 1, 1, 1, 32};
+	  vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_)); 
+	int RetVal = 1; 
+	return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
+int Test_(Case_<1>) {
+	int x_[] = {1, 2, 8, 9, 5};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1, 8, 2, 9, 5};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int h_[] = {1, 1, 1, 1, 27};
+	  vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_)); 
+	int RetVal = 2; 
+	return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
+int Test_(Case_<2>) {
+	int x_[] = {1, 2, 8, 9, 5};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1, 8, 2, 9, 5};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int h_[] = {4, 4, 4, 4, 4};
+	  vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_)); 
+	int RetVal = 3; 
+	return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
+int Test_(Case_<3>) {
+	int x_[] = {1, 2, 8, 9, 5};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1, 8, 2, 9, 5};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int h_[] = {3, 3, 3, 3, 3};
+	  vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_)); 
+	int RetVal = 4; 
+	return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
+int Test_(Case_<4>) {
+	int x_[] = {3, 10, 6, 2, 8, 7, 5, 4, 9, 1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {4, 10, 6, 9, 8, 7, 3, 2, 5, 1};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int h_[] = {4, 2, 2, 4, 4, 5, 4, 4, 2, 3};
+	  vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_)); 
+	int RetVal = 5; 
+	return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
+int Test_(Case_<5>) {
+	int x_[] = {55, 67, 100, 38, 80, 98, 47, 58, 61, 33};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {87, 17, 20, 7, 57, 19, 23, 68, 27, 39};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int h_[] = {6, 2, 8, 8, 31, 25, 23, 19, 45, 4};
+	  vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_)); 
+	int RetVal = 6; 
+	return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
+int Test_(Case_<6>) {
+	int x_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int h_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+	  vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_)); 
+	int RetVal = 6; 
+	return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
+
+template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
+template<>      void Run_<-1>() {}
+int main() { Run_<0>(); }
+// END CUT HERE
+

ADDED   _lib/dataStructure/fenwickTree.cpp
Index: _lib/dataStructure/fenwickTree.cpp
==================================================================
--- _lib/dataStructure/fenwickTree.cpp
+++ _lib/dataStructure/fenwickTree.cpp
@@ -0,0 +1,30 @@
+//-------------------------------------------------------------
+// Fenwick Tree
+//   O(log N) per each operation
+//
+// Verified by
+//   - SRM424 Div1 LV3
+//-------------------------------------------------------------
+
+template<typename T = LL>
+struct FenwickTree
+{
+	vector<T> x;
+	FenwickTree(size_t n, const T& v = T()) : x(n, v) {}
+
+	void incr( int k, const T& a ) { // z[k] += a;
+		for(; k < x.size(); k|=k+1)
+			x[k] += a;
+	}
+
+	T sum(int i, int j) { // z[i]+...+z[j] : inclusive
+		if(i)
+			return sum(0, j) - sum(0, i-1);
+		else {
+			T v = T();
+			for(; j>=0; j=(j&(j+1))-1)
+				v += x[j];
+			return v;
+		}
+	}
+};

ADDED   _lib/dataStructure/rmq.cpp
Index: _lib/dataStructure/rmq.cpp
==================================================================
--- _lib/dataStructure/rmq.cpp
+++ _lib/dataStructure/rmq.cpp
@@ -0,0 +1,53 @@
+//-------------------------------------------------------------
+// Range Minimum Query
+//   O(N log N) construction
+//   O(1) per each query
+//   returns the LEFTMOST/ALL minimum index (I hope)
+//
+// Verified by
+//   - SRM337 Div1 LV2
+//   - SRM431 Div1 LV3
+//-------------------------------------------------------------
+
+template<typename T>
+struct RMQ
+{
+	vector< vector<int> > rm;
+	vector<T> d;
+
+	RMQ( const vector<T>& d ) : d(d) {
+		int n = d.size();
+
+		// rm[k][x] = i s.t. d[i] is the minimum in [x, x+2^k)
+		rm.push_back( vector<int>(n) );
+		for(int x=0; x<n; ++x)
+			rm[0][x] = x;
+		for(int k=1; (1<<k)<=n; ++k) {
+			rm.push_back( rm[k-1] );
+			for(int x=0; x+(1<<k-1)<n; ++x)
+				if( d[rm[k][x]] > d[rm[k-1][x + (1<<k-1)]] )
+					rm[k][x] = rm[k-1][x + (1<<k-1)];
+		}
+	}
+
+	int operator()(int L, int R) const { // inclusive
+		int k=0;
+		for(; L+(1<<k) < R-(1<<k)+1; ++k) {}
+		LL i = rm[k][L];
+		LL j = rm[k][R-(1<<k)+1];
+		return (d[i]<=d[j] ? i : j);
+	}
+
+	vector<int> all(int L, int R) const {
+		vector<int> ans;
+		int minValue = d[(*this)(L, R)];
+		while( L <= R ) {
+			int C = (*this)(L, R);
+			if( minValue < d[C] )
+				break;
+			ans.push_back(C);
+			L = C+1;
+		}
+		return ans;
+	}
+};

ADDED   _lib/doc/hitori-sharp.pdf
Index: _lib/doc/hitori-sharp.pdf
==================================================================
--- _lib/doc/hitori-sharp.pdf
+++ _lib/doc/hitori-sharp.pdf
cannot compute difference between binary files

ADDED   _lib/doc/lb_ub.txt
Index: _lib/doc/lb_ub.txt
==================================================================
--- _lib/doc/lb_ub.txt
+++ _lib/doc/lb_ub.txt
@@ -0,0 +1,21 @@
+lb = lower_bound(k)
+  ... k-1] lb [k ...
+
+
+ub = upper_bound(k)
+  .., k] ub [k+1 ...
+
+
+縺ｪ縺ｮ縺ｧ莉ｻ諢上�ｮ髢矩哩蛹ｺ髢薙ｒ繧､繝�繝ｬ繝ｼ繧ｿ縺ｮ [) 蛹ｺ髢薙↓逶ｴ縺吶↓縺ｯ
+
+  [A, B]
+    = [ lower_bound(A), upper_bound(B) )
+
+  [A, B)
+    = [ lower_bound(A), lower_bound(B) )
+
+  (A, B]
+    = [ upper_bound(A), upper_bound(B) )
+
+  (A, B)
+    = [ upper_bound(A), lower_bound(B) )

ADDED   _lib/doc/nim.txt
Index: _lib/doc/nim.txt
==================================================================
--- _lib/doc/nim.txt
+++ _lib/doc/nim.txt
@@ -0,0 +1,38 @@
+// SRM338 Div1 LV3
+
+螳夂炊縺ｮ繧ｹ繝�繝ｼ繝医Γ繝ｳ繝�
+
+    蟇ｾ雎｡縺ｨ縺ｪ繧九ご繝ｼ繝�
+      - 莠御ｺｺ繧ｲ繝ｼ繝�
+      - 莠御ｺｺ縺ｨ繧ょ虚縺九○繧区焔縺ｮ髮�蜷医�ｯ蜷後§
+      - 蜍輔°縺帙↑縺上↑縺｣縺滓婿縺瑚ｲ�縺�
+      - 辟｡髯舌Ν繝ｼ繝励＠縺ｪ縺�
+
+    nim
+      - 繧ｵ繧､繧ｺ s1, s2, .., sk 縺ｮ螻ｱ縺後≠繧�
+      - 縺ｩ繧後°荳�縺､螻ｱ繧帝∈繧薙〒 1 �ｽ� 螻ｱ繧ｵ繧､繧ｺ 縺ｮ莉ｻ諢丞�句叙繧企勁縺代ｋ
+      - 譛�蠕後�ｮ螻ｱ繧貞叙縺｣縺滓婿縺悟享縺｡�ｼ亥ｱｱ縺後↑縺上↑縺｣縺ｦ謇薙▽謇九′辟｡縺上↑縺｣縺滓婿縺瑚ｲ�縺托ｼ�
+
+    *n 繧偵し繧､繧ｺ n 縺ｮ螻ｱ縺�1蛟九□縺代�ｮ nim 縺ｨ縺吶ｋ
+      - *0 縺ｯ雋�縺�
+      - *n 縺ｯ蜍昴■ n>=1
+
+    繧ｲ繝ｼ繝�
+      - 迥ｶ諷� G 縺九ｉ謇薙※繧区焔縺ｧ驕ｷ遘ｻ縺吶ｋ蜈医ｒ G1, ..., Gk 縺ｨ縺吶ｋ
+        G = {G1, ..., Gk} 縺ｨ譖ｸ縺�
+
+    遲我ｾ｡
+      - 莠後▽縺ｮ繧ｲ繝ｼ繝�G, F縺檎ｭ我ｾ｡縺ｪ縺薙→繧� G 竕｡ F 縺ｨ譖ｸ縺�
+        遲我ｾ｡縺ｨ縺�縺�縺ｮ縺ｯ蜍昴■雋�縺台ｸ�閾ｴ繧医ｊ繧ゅ▲縺ｨ蠑ｷ縺�縲ゆｺ後▽縺ｮ繧ｲ繝ｼ繝�縺ｮ蜥後ｒ蜿悶ｋ縺ｨ蠢�謨励↓縺ｪ繧九％縺ｨ
+        *n 縺ｨ *n 縺ｯ蜷後し繧､繧ｺ縺ｮ螻ｱ2縺､縺ｮnim縺ｯ蠢�謨励↑縺ｮ縺ｧ遲我ｾ｡縲ょ酔繧ｵ繧､繧ｺ縺ｧ縺ｪ縺代ｌ縺ｰ蠢�蜍昴↑縺ｮ縺ｧ遲我ｾ｡縺ｧ縺ｪ縺�
+
+    螳夂炊
+      - G1竕｡*n1, ..., Gk竕｡*nk 縺ｪ繧峨�ｰ縲；={G1, ..., Gk} 竕｡ *mex(n1,...,nk)
+        where mex(S) = min(nat \setminus S)
+        蟶ｰ邏咲噪縺ｫ縲∝�ｨ縺ｦ縺ｮ繧ｲ繝ｼ繝�縺ｯ縺ｪ繧薙ｉ縺九�ｮ *n 縺ｨ遲我ｾ｡
+
+
+縺翫∪縺�
+  @G 繧� G 縺ｮnim蛟､縺ｨ縺吶ｋ縲ゅ▽縺ｾ繧絵竕｡*@G
+  G = X + Y 縺ｪ繧峨�ｰ @G = @X xor @Y
+  螻ｱ縺瑚､�謨ｰ縺ｮnim縺ｮ蜍晄風縺ｯ蜈ｨ驛ｨxor縺ｨ縺｣縺�1縺､螻ｱ縺ｮnim縺ｫ遲峨＠縺�縺ｮ縺ｨ蜷後§蜴溽炊縲�

ADDED   _lib/gcj/!gcj-smpl.aml
Index: _lib/gcj/!gcj-smpl.aml
==================================================================
--- _lib/gcj/!gcj-smpl.aml
+++ _lib/gcj/!gcj-smpl.aml
@@ -0,0 +1,40 @@
+(****************************************************************************
+ * Written in
+ *    Alice 1.4
+ *    http://www.ps.uni-saarland.de/alice/
+ ****************************************************************************)
+
+fun solve (n : int, k : int) : bool =
+	let
+		open Word
+		infix 5 << andb
+		val mask = (0wx1 << fromInt n) - 0wx1
+	in
+		(fromInt k) andb mask = mask
+	end
+
+fun main () =
+	let
+		fun readLine () =
+			case TextIO.inputLine TextIO.stdIn of
+			| NONE    => []
+			| SOME(s) => map Int.fromString (String.tokens (fn x => x = #" ") s)
+
+		fun parseOne c =
+			case readLine() of
+			| [SOME n, SOME k] => (c, (n, k))
+			| _                => assert false
+
+		fun spawn solveOne (c, inp) =
+			(c, solve inp)
+
+		fun printOne (c, ans) =
+			print ("Case #" ^ Int.toString (c+1) ^ ": " ^ (if ans then "ON" else "OFF") ^ "\n")
+	in
+		case readLine () of
+		| [SOME t] => List.app printOne (List.map solveOne (List.tabulate (t, parseOne)))
+		| _        => assert false
+	end
+
+do main ()
+do OS.Process.exit 0

ADDED   _lib/gcj/!gcj-smpl.as
Index: _lib/gcj/!gcj-smpl.as
==================================================================
--- _lib/gcj/!gcj-smpl.as
+++ _lib/gcj/!gcj-smpl.as
@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Written in
+//    ActionScript (using mtasc 1.14)
+//    http://www.mtasc.org/
+/////////////////////////////////////////////////////////////////////////////
+
+class A
+{
+	static function main(mc)
+	{
+		var input_string = "<paste the input data here>";
+		var input = input_string.split("\n");
+		var T = Number(input[0]);
+
+		var output_string = ""
+		for(var C=1; C<=T; ++C)
+		{
+			var theCase = input[C].split(" ");
+			var N = Number(theCase[0]);
+			var K = Number(theCase[1]);
+			output_string += "Case #" + C + ": " + (solve(N,K)?"ON":"OFF") + "\n"
+		}
+
+		_root.createTextField("tf",0,0,0,800,600);
+		_root.tf.text = output_string;
+	}
+
+	static function solve(N, K)
+	{
+		var mask = (1<<N) - 1;
+		return (K & mask) == mask;
+	}
+}

ADDED   _lib/gcj/!gcj-smpl.bl
Index: _lib/gcj/!gcj-smpl.bl
==================================================================
--- _lib/gcj/!gcj-smpl.bl
+++ _lib/gcj/!gcj-smpl.bl
@@ -0,0 +1,133 @@
+#############################################################################
+# Written in
+#    Blue 1.7.5
+#    http://www.lechak.info/blue/
+#############################################################################
+
+global FROM_STRING = func {
+	arg s;
+
+	a = [];
+	i = 0;
+	loop {
+		a = a.append( s.substr(i,i+1).num() );
+		(i=i+1) >= s.length() ? return;
+	};
+	return a;
+};
+
+global TO_STRING = func {
+	arg x;
+	lexical s = "";
+	x.map( func{ s = s + this; } );
+	return s;
+};
+
+global LESS = func {
+	arg x;
+	arg y;
+
+	xl = x.length();
+	yl = y.length();
+	(xl < yl) ? return 1;
+	(xl > yl) ? return 0;
+	i = 0;
+	return loop {
+		(i == xl)     ? return 0;
+		(x[i] < y[i]) ? return 1;
+		(x[i] > y[i]) ? return 0;
+		i = i+1;
+	};
+};
+
+global SUB = func {
+	arg x;
+	arg y;
+
+	x.length() > y.length() ? (y = [].resize(x.length()-y.length(),0).merge(y));
+	z = [].resize(x.length(), 0);
+	i = x.length()-1;
+	carry = 0;
+	loop {
+		z[i]  = x[i] - y[i] - carry;
+		carry = z[i] < 0 ? (z[i]=z[i]+10; 1) : 0;
+		(i=i-1) < 0 ? return;
+	};
+	head = 0;
+	loop {
+		head == z.length()-1 ? return;
+		z[head] != 0 ? return;
+		head = head + 1;
+	};
+	return z.slice(head, z.length());
+};
+
+global DBL = func {
+	arg x;
+
+	z = [].resize(x.length(), 0);
+	i = x.length()-1;
+	carry = 0;
+	loop {
+		z[i]  = x[i] + x[i] + carry;
+		carry = z[i] > 9 ? (z[i]=z[i]-10; 1) : 0;
+		((i=i-1) < 0) ? return;
+	};
+	return (carry==1 ? [1].merge(z) : z);
+};
+
+global DIF = func {
+	arg x;
+	arg y;
+	return LESS(x, y) ? SUB(y, x) : SUB(x, y);
+};
+
+global MOD = func {
+	arg x;
+	arg y;
+
+	LESS(x,y) ? return x;
+	z = MOD(x, DBL(y));
+	LESS(z,y) ? return z;
+	return SUB(z,y);
+};
+
+global ISZERO = func {
+	arg x;
+	return x[0] == 0;
+};
+
+global GCD = func {
+	arg x;
+	arg y;
+	return ISZERO(x) ? y : GCD(MOD(y,x),x);
+};
+
+#############################################################################
+
+solve = func {
+	arg N;
+	arg t;
+	t = t.map( func{return FROM_STRING(this);} );
+
+	lexical t0 = t[0];
+	lexical g  = DIF(t0, t[1]);
+	t.slice(2, t.length()).map(func{
+		g = GCD(g, DIF(t0, this));
+	});
+	r = MOD(t[0], g);
+	return TO_STRING( ISZERO(r) ? r : DIF(g,r) );
+};
+
+input = sys.library("streams").stdio().read(1000000000).split("\n").map(func{return this.split(" ");});
+C = input[0][0].num();
+
+CaseID = (args.length() >= 2 ? args[1].num() : 1);
+loop {
+	"Case #".print();
+	CaseID.print();
+	": ".print();
+	solve( input[CaseID][0].num(), input[CaseID].slice(1,input[CaseID].length()) ).print();
+	"\n".print();
+	((CaseID = CaseID+1) > C) ? return;
+};

ADDED   _lib/gcj/!gcj-smpl.cl
Index: _lib/gcj/!gcj-smpl.cl
==================================================================
--- _lib/gcj/!gcj-smpl.cl
+++ _lib/gcj/!gcj-smpl.cl
@@ -0,0 +1,150 @@
+/////////////////////////////////////////////////////////////////////////////
+// Writte in
+//    Claire v3.3.37
+//    http://www.claire-language.com/
+/////////////////////////////////////////////////////////////////////////////
+
+D :: 1000000000
+
+long <: ephemeral_object(hi:integer, lo:integer)
+
+[long!(x: integer) : long ->
+	long(hi = x / D, lo = x mod D)
+]
+
+[+(x:long, y:long) : long ->
+	let lolo := x.lo - D + y.lo in
+	(
+		if ( lolo < 0 )
+			long(hi = x.hi + y.hi,     lo = lolo + D)
+		else
+			long(hi = x.hi + y.hi + 1, lo = lolo)
+	)
+]
+
+[-(x:long, y:long) : long ->
+	let lolo := x.lo - y.lo in
+	(
+		if ( lolo < 0 )
+			long(hi = x.hi - y.hi - 1, lo = lolo + D)
+		else
+			long(hi = x.hi - y.hi,     lo = lolo)
+	)
+]
+
+[*(x:long, y:integer) : long ->
+	let r := long!(0) in
+	let c := x in
+		(while (y > 0) (
+			(if (y mod 2 = 1) r :+ c),
+			c := c + c,
+			y :/ 2
+		),
+		r)
+]
+
+[+(x:long, y:integer) : long ->
+	x + long!(y)
+]
+
+[<(x:long, y:long) : boolean ->
+	if (x.hi < y.hi)
+		true
+	else if (x.hi > y.hi)
+		false
+	else
+		x.lo < y.lo
+]
+[>=(x:long, y:long) : boolean -> not(x < y)]
+[<=(x:long, y:long) : boolean -> not(y < x)]
+[>(x:long, y:long) : boolean -> (y < x)]
+
+[>=(x:long, y:integer) : boolean -> not(x < long!(y))]
+[<=(x:long, y:integer) : boolean -> not(long!(y) < x)]
+[<(x:long, y:integer) : boolean -> (x < long!(y))]
+[>(x:long, y:integer) : boolean -> (long!(y) < x)]
+
+[>=(x:integer, y:long) : boolean -> not(long!(x) < y)]
+[<=(x:integer, y:long) : boolean -> not(y < long!(x))]
+[<(x:integer, y:long) : boolean -> (long!(x) < y)]
+[>(x:integer, y:long) : boolean -> (y < long!(x))]
+
+
+[string!(x: long) : string ->
+	if (x.hi > 0)
+		let los := string!(x.lo) in
+			string!(x.hi) /+ make_string(9 - length(los), '0') /+ los
+	else
+		string!(x.lo)
+]
+
+/////////////////////////////////////////////////////////////////////////////
+
+[readLine() : list<integer> ->
+	list<integer>{integer!(s) | s in explode(freadline(stdin), " ")}
+]
+
+[solve(R:integer, k:integer, N:integer, g:list<integer>) ->
+	let dest := make_list(N, 0) in
+	let earn := make_list(N, long!(0)) in
+	(
+		for s in (0 .. N - 1) (
+			let ride := long!(0) in
+			let i    := 0        in
+			(
+				while (i < N)
+				(
+					let ride2 := ride + g[((s + i) mod N) + 1] in
+					(if (ride2 > k)
+						break()
+					else
+						(ride := ride2, i :+ 1))
+				),
+				earn[s + 1] := ride,
+				dest[s + 1] := ((s + i) mod N) + 1
+			)
+		),
+		let firstVisitTime := make_list(N,       -1) in
+		let firstVisitEarn := make_list(N, long!(0)) in
+		let q         := 1        in
+		let totalEarn := long!(0) in
+		let i         := 0        in
+		(
+			(while (i < R) (
+				if (firstVisitTime[q] = -1)
+				(
+					firstVisitTime[q] := i,
+					firstVisitEarn[q] := totalEarn,
+					totalEarn         :+ earn[q],
+					q                 := dest[q],
+					i                 :+ 1
+				)
+				else
+				(
+					let loopSize := i - firstVisitTime[q] in
+					let loopEarn := totalEarn - firstVisitEarn[q] in
+					let rest     := R - i in
+					(
+						totalEarn :+ loopEarn * (rest / loopSize),
+						// clear
+						firstVisitTime := make_list(N, -1),
+						i              := R - (rest mod loopSize)
+					)
+				)
+			)),
+			princ(string!(totalEarn))
+		)
+	)
+]
+
+[main() ->
+	let T := readLine()[1] in
+		for C in (1 .. T)
+		(
+			printf("Case #~A: ", C),
+			let RkN := readLine() in solve(RkN[1], RkN[2], RkN[3], readLine()),
+			princ("\n")
+		)
+]
+
+(main())

ADDED   _lib/gcj/!gcj-smpl.cs
Index: _lib/gcj/!gcj-smpl.cs
==================================================================
--- _lib/gcj/!gcj-smpl.cs
+++ _lib/gcj/!gcj-smpl.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Linq;
+
+class C
+{
+	static void Main()
+	{
+		long[] Ts = readLongArray();
+		long   T  = Ts[0];
+
+		for(long C=1; C<=T; ++C)
+		{
+			long[] RkN = readLongArray();
+			long   R = RkN[0];
+			long   k = RkN[1];
+			long   N = RkN[2];
+			long[] g = readLongArray();
+
+			Console.WriteLine("Case #{0}: {1}", C, solveSmall(R,k,N,g));
+		}
+	}
+
+	static long[] readLongArray()
+	{
+		return (from s in Console.ReadLine().Split(' ') select long.Parse(s)).ToArray();
+	}
+
+	static long solveSmall(long R, long k, long N, long[] g)
+	{
+		long totalEarn = 0;
+
+		for(int i=0; i<R; ++i)
+		{
+			long ride = 0;
+			for(int q=0; q<g.Length; ++q)
+				if( ride + g[q] > k )
+				{
+					g = rotate(g, q);
+					break;
+				}
+				else
+				{
+					ride += g[q];
+				}
+			totalEarn += ride;
+		}
+
+		return totalEarn;
+	}
+
+	static long[] rotate(long[] g, int s)
+	{
+		long[] g2 = new long[g.Length];
+		for(int i=s; i<g.Length; ++i)
+			g2[i-s] = g[i];
+		for(int i=0; i<s; ++i)
+			g2[i+g.Length-s] = g[i];
+		return g2;
+	}
+}

ADDED   _lib/gcj/!gcj-smpl.vbs
Index: _lib/gcj/!gcj-smpl.vbs
==================================================================
--- _lib/gcj/!gcj-smpl.vbs
+++ _lib/gcj/!gcj-smpl.vbs
@@ -0,0 +1,39 @@
+'
+' Written in VBScript
+'
+
+Function ReadLine()
+	Dim s
+	s = Split(WScript.StdIn.ReadLine, " ")
+	For i = LBound(s) To UBound(s)
+		s(i) = CLng(s(i))
+	Next
+	ReadLine = s
+End Function
+
+Function Gcd(a, b)
+	If a = 0 Then
+		Gcd = b
+	Else
+		Gcd = Gcd(b mod a, a)
+	End If
+End Function
+
+Function Solve(T)
+	Dim g, r
+	g = Abs(T(1) - T(2))
+	For i = 2 To UBound(T)
+		g = Gcd(g, Abs(T(1) - T(i)))
+	Next
+	r = T(1) mod g
+	If r = 0 Then
+		Solve = 0
+	Else
+		Solve = g - r
+	End If
+End Function
+
+C = ReadLine()(0)
+For CaseID = 1 To C
+	WScript.StdOut.WriteLine "Case #" & CaseID & ": " & Solve(ReadLine)
+Next

ADDED   _lib/gcj/!gcj-tmpl.cpp
Index: _lib/gcj/!gcj-tmpl.cpp
==================================================================
--- _lib/gcj/!gcj-tmpl.cpp
+++ _lib/gcj/!gcj-tmpl.cpp
@@ -0,0 +1,100 @@
+//-----------------------------------------------------------------------------
+// >>Code Template<< (for Visual C++)
+
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <string>
+#include <vector>
+#include <set>
+#include <map>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <complex>
+#include <functional>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+#define  cout os
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+void END_OF_INPUT_FOR_THIS_TEST_CASE(); // stub for multi-threading
+
+//-----------------------------------------------------------------------------
+// >>Main<<
+
+void case_main( ostream& os )
+{
+	END_OF_INPUT_FOR_THIS_TEST_CASE();
+}
+
+//-----------------------------------------------------------------------------
+// >>Code Template<< (Multi-Thread Solver)
+
+#if 1
+#undef cout
+#include <windows.h>
+#include <process.h>
+
+static const int THREAD_NUM = 2;
+volatile int     g_id;
+int              g_nCase;
+CRITICAL_SECTION g_cs;
+vector<string>   g_output;
+
+unsigned __stdcall thread_main( void* t_id ) {
+	for(;;) {
+		EnterCriticalSection(&g_cs);
+		const int id = ++g_id;
+		if(id>g_nCase) { LeaveCriticalSection(&g_cs); break; }
+		cerr << setw(4) << id << " @ " << (int)t_id << " start" << endl;
+
+		ostringstream ss;
+		ss << "Case #" << id << ": ";
+		case_main( ss );
+
+		EnterCriticalSection(&g_cs);
+		if(g_output.size()<id) g_output.resize(id);
+		g_output[id-1] = ss.str();
+		cerr << setw(4) << id << " @ " << (int)t_id << " end" << endl;
+		LeaveCriticalSection(&g_cs);
+	}
+	return 0;
+}
+
+void END_OF_INPUT_FOR_THIS_TEST_CASE() { LeaveCriticalSection(&g_cs); }
+
+int main() {
+	cin >> g_nCase;
+	string dummy; getline(cin, dummy);
+
+	InitializeCriticalSection(&g_cs);
+	vector<HANDLE> thread;
+	for(int i=0; i<THREAD_NUM; ++i)
+		thread.push_back( (HANDLE)_beginthreadex(0, 0, &thread_main, (void*)i, 0, 0) );
+	WaitForMultipleObjects( thread.size(), &thread[0], TRUE, INFINITE );
+	DeleteCriticalSection(&g_cs);
+
+	copy( g_output.begin(), g_output.end(), ostream_iterator<string>(cout) );
+}
+
+//-----------------------------------------------------------------------------
+// >>Code Template<< (Single-Thread Solver)
+
+#else
+#undef cout
+void END_OF_INPUT_FOR_THIS_TEST_CASE() {}
+int main() {
+	int nCase; cin >> nCase;
+	string dummy; getline(cin, dummy);
+
+	for(int id=1; id<=nCase; ++id) {
+		cout << "Case #" << id << ": ";
+		case_main( cout );
+	}
+}
+#endif

ADDED   _lib/gcj/!gcj-tmpl.java
Index: _lib/gcj/!gcj-tmpl.java
==================================================================
--- _lib/gcj/!gcj-tmpl.java
+++ _lib/gcj/!gcj-tmpl.java
@@ -0,0 +1,40 @@
+import java.io.*;
+import java.util.*;
+
+public class <CLASSNAME>
+{
+	public static void main(String[] arg)
+	{
+		Scanner sc = new Scanner(System.in);
+		int T = sc.nextInt();
+		for(int C=1; C<=T; ++C)
+		{
+			System.out.printf("Case #%d: ", C);
+			(new <CLASSNAME>(sc)).caseMain();
+		}
+	}
+
+	Scanner sc;
+	<CLASSNAME>( Scanner sc ) { this.sc = sc; }
+
+	void caseMain()
+	{
+		int n = sc.nextInt();
+		long[] x = new long[n];
+		for(int i=0; i<n; ++i) x[i] = sc.nextInt();
+		long[] y = new long[n];
+		for(int i=0; i<n; ++i) y[i] = sc.nextInt();
+
+		System.out.println(solve(x, y, n));
+	}
+
+	long solve(long[] x, long[] y, int n)
+	{
+		Arrays.sort(x);
+		Arrays.sort(y);
+		long s = 0;
+		for(int i=0; i<n; ++i)
+			s += x[i] * y[n-1-i];
+		return s;
+	}
+}

ADDED   _lib/gcj/!gcj-tmpl.lua
Index: _lib/gcj/!gcj-tmpl.lua
==================================================================
--- _lib/gcj/!gcj-tmpl.lua
+++ _lib/gcj/!gcj-tmpl.lua
@@ -0,0 +1,19 @@
+CN = io.stdin:read("*n")
+for C=1, CN, 1 do
+	io.stdout:write( string.format("Case #%d: ", C) )
+
+	N = io.stdin:read("*n")
+	M = io.stdin:read("*n")
+
+	fav = {}
+	for i=1, M, 1 do
+		T = io.stdin:read("*n")
+		fav[i] = {}
+		for j=1, T, 1 do
+			X, Y = io.stdin:read("*n", "*n")
+			fav[i][j] = {X, Y}
+		end
+	end
+
+	io.stdout:write( string.format("%d %d\n", N, M) )
+end

ADDED   _lib/gcj/!gcj-tmpl.py
Index: _lib/gcj/!gcj-tmpl.py
==================================================================
--- _lib/gcj/!gcj-tmpl.py
+++ _lib/gcj/!gcj-tmpl.py
@@ -0,0 +1,11 @@
+import sys
+
+CN = int(sys.stdin.next())
+for C in range(1, CN+1):
+	print "Case #%d:"%(C),
+	N = int(sys.stdin.next())
+	M = int(sys.stdin.next())
+	for i in range(0, M):
+		a = map(int, sys.stdin.next().split(" "))
+		print a
+	print N, M

ADDED   _lib/geo/area.cpp
Index: _lib/geo/area.cpp
==================================================================
--- _lib/geo/area.cpp
+++ _lib/geo/area.cpp
@@ -0,0 +1,23 @@
+//-------------------------------------------------------------
+// Area of a polygon
+//   O(N)
+//
+// Verified by
+//   - SRM 337 Div1 LV3
+//   - SRM 486 Div1 LV3
+//-------------------------------------------------------------
+
+double outer_prod( pt a, pt b )
+{
+	return (a.real()*b.imag() - b.real()*a.imag())/2;
+}
+
+double area( const vector<pt>& q )
+{
+	double a = 0.0;
+
+	pt o = q[0];
+	for(int i=1; i+1<q.size(); ++i)
+		a += outer_prod(q[i]-o, q[i+1]-o);
+	return abs(a) / 2;
+}

ADDED   _lib/geo/ccw.cpp
Index: _lib/geo/ccw.cpp
==================================================================
--- _lib/geo/ccw.cpp
+++ _lib/geo/ccw.cpp
@@ -0,0 +1,18 @@
+//-------------------------------------------------------------
+// ccw
+//
+// Verified by
+//   - SRM 492 Div1 LV1
+//-------------------------------------------------------------
+
+double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
+double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
+
+int ccw(const CMP& a, CMP b, CMP c) {
+	b -= a; c -= a;
+	if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
+	if( outer_prod(b,c) < 0 ) return -1; // clockwise
+	if( inner_prod(b,c) < 0 ) return +2; // c--[a--b] on line
+	if( norm(b) < norm(c) )   return -2; // [a--b]--c on line
+	return 0; // [a--c--b] on line
+}

ADDED   _lib/geo/circle_3pt.cpp
Index: _lib/geo/circle_3pt.cpp
==================================================================
--- _lib/geo/circle_3pt.cpp
+++ _lib/geo/circle_3pt.cpp
@@ -0,0 +1,55 @@
+
+//-------------------------------------------------------------
+// The circle passing three points
+//
+// Verified by
+//   - AOJ 0010
+//-------------------------------------------------------------
+
+vector<double> solve_linear_eq( int n, vector< vector<double> > M, const vector<double>& V )
+{
+	vector<double> A(V);
+	for(int i=0; i<n; ++i)
+	{
+		// pivot
+		if( M[i][i] == 0 )
+			for(int j=i+1; j<n; ++j)
+				if( M[j][i] != 0 )
+					{swap(M[i], M[j]); swap(A[i], A[j]); break;}
+		if( M[i][i] == 0 )
+			throw "no anser";
+
+		// M[i][i] <-- 1
+		double p = M[i][i];
+		for(int j=i; j<n; ++j)
+			M[i][j] /= p;
+		A[i] /= p;
+
+		// M[*][i] <-- 0
+		for(int j=0; j<n; ++j) if(j!=i)
+		{
+			double r = M[j][i];
+			for(int k=i; k<n; ++k)
+				M[j][k] -= M[i][k] * r;
+			A[j] -= A[i] * r;
+		}
+	}
+	return A;
+}
+
+void circle_3pt( CMP p1, CMP p2, CMP p3, CMP* c, double* r )
+{
+	p2 -= p1;
+	p3 -= p1;
+	// c == p2/2 + A p2 i == p3/2 + B p3 i
+
+	vector< vector<double> > M(2, vector<double>(2));
+	vector<double> V(2);
+	M[0][0] = -p2.imag(); M[0][1] = +p3.imag(); V[0] = (p3.real()-p2.real())/2.0;
+	M[1][0] = +p2.real(); M[1][1] = -p3.real(); V[1] = (p3.imag()-p2.imag())/2.0;
+	V = solve_linear_eq(2, M, V);
+
+	double A=V[0], B=V[1];
+	*c = p1 + p2/2.0 + A * p2 * CMP(0,1);
+	*r = abs(*c - p1);
+}

ADDED   _lib/geo/convexHull.cpp
Index: _lib/geo/convexHull.cpp
==================================================================
--- _lib/geo/convexHull.cpp
+++ _lib/geo/convexHull.cpp
@@ -0,0 +1,48 @@
+
+//-------------------------------------------------------------
+// Convex Hull -- Andrew's Monotone Chain
+//   O(N log N)
+//
+// Verified by
+//   - SRM 336 Div1 LV3
+//   - TCO09 Round2 LV2
+//   - SRM 486 Div1 LV3
+//-------------------------------------------------------------
+
+double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
+double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
+
+int ccw(const CMP& a, CMP b, CMP c) {
+	b -= a; c -= a;
+	if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
+	if( outer_prod(b,c) < 0 ) return -1; // clockwise
+	if( inner_prod(b,c) < 0 ) return +2; // c--a--b on line
+	if( norm(b) < norm(c) )   return -2; // a--b--c on line
+	return 0;
+}
+
+bool byX( const CMP& a, const CMP& b ) {
+	if( a.real() != b.real() )
+		return a.real() < b.real();
+	return a.imag() < b.imag();
+}
+
+vector<CMP> convex_hull( vector<CMP> p )
+{
+	#define IS_RIGHT <0   // skip on-line verts
+	//#define IS_RIGHT ==-1 // take all
+
+	sort(p.begin(), p.end(), &byX);
+
+	vector<CMP> ans;
+	for(int i=0; i<p.size(); ans.push_back(p[i++])) // left-to-right
+		while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
+			ans.pop_back();
+	if( ans.size() == p.size() )
+		return ans;
+	for(int i=p.size()-2; i>=0; ans.push_back(p[i--])) // right-to-left
+		while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
+			ans.pop_back();
+	ans.pop_back();
+	return ans;
+}

ADDED   _lib/geo/convexHull_old.cpp
Index: _lib/geo/convexHull_old.cpp
==================================================================
--- _lib/geo/convexHull_old.cpp
+++ _lib/geo/convexHull_old.cpp
@@ -0,0 +1,49 @@
+
+//-------------------------------------------------------------
+// Convex Hull -- Gift Wrapping
+//   O(N log N)
+//
+// ToDo : Rewrite by CCW...
+//
+// Verified by
+//   - SRM 336 Div1 LV3
+//-------------------------------------------------------------
+
+bool byY( CMP a, CMP b )
+{
+	if( a.imag() == b.imag() )
+		return a.real() < b.real();
+	return a.imag() < b.imag();
+}
+
+bool byArg( CMP a, CMP b )
+{
+	return arg(a) < arg(b);
+}
+
+bool isRight( CMP a, CMP b, CMP c )
+{
+	return arg((c-b) / (b-a)) < 0;
+}
+
+vector<CMP> convex_hull( vector<CMP> p )
+{
+	vector<CMP>::iterator it = min_element( p.begin(), p.end(), byY );
+	CMP o = *it;
+	p.erase(it);
+	for(int i=0; i<p.size(); ++i)
+		p[i] -= o;
+	sort( p.begin(), p.end(), byArg );
+
+	vector<CMP> q;
+	q.push_back( CMP(0,0) );
+	q.push_back( p[0] );
+	for(int i=1; i<p.size(); ++i) {
+		while( isRight(q[q.size()-2], q[q.size()-1], p[i]) )
+			q.pop_back();
+		q.push_back( p[i] );
+	}
+	for(int i=0; i<q.size(); ++i)
+		q[i] += o;
+	return q;
+}

ADDED   _lib/geo/pt_in_poly.cpp
Index: _lib/geo/pt_in_poly.cpp
==================================================================
--- _lib/geo/pt_in_poly.cpp
+++ _lib/geo/pt_in_poly.cpp
@@ -0,0 +1,28 @@
+
+//-------------------------------------------------------------
+// The circle passing three points
+//
+// Verified by
+//   - AOJ 0012 (only triangles)
+//-------------------------------------------------------------
+
+double outer_prod( CMP a, CMP b )
+{
+	return (a.real()*b.imag() - b.real()*a.imag())/2;
+}
+
+bool point_in_polygon( vector<CMP>& ps, CMP p )
+{
+	bool in = false;
+	for(int i=0; i<ps.size(); ++i) {
+		CMP a = ps[i] - p;
+		CMP b = ps[(i+1)%ps.size()] - p;
+		if(a.imag() > b.imag()) swap(a,b);
+		if(a.imag()<=0 && 0<b.imag()) {
+			if( outer_prod(a,b) < 0 )
+				in = !in;
+		}
+		//if( outer_prod(a,b)==0 && inner_prod(a,b)<=0 ) return ON;
+	}
+	return in;
+}

ADDED   _lib/graph/__goldberg.cpp
Index: _lib/graph/__goldberg.cpp
==================================================================
--- _lib/graph/__goldberg.cpp
+++ _lib/graph/__goldberg.cpp
@@ -0,0 +1,126 @@
+//----------------------------------------------------------------------------
+// Goldberg(-Tarjan?) 法 (最大流)
+//
+// 容量付きグラフ G 上での Src から Dest への最大流量を求める
+//   - グラフは隣接行列で渡すこと。G は破壊されます。
+//   - 流量だけでなくFlow自体が欲しいときは G の容量が減ってる部分を見る
+//
+// 計算量は
+//   - O(V^3)
+//       # 証明はまだ理解していない
+//
+// アルゴリズムの概略
+//   基本形は以下の通り
+//      1. とりあえずSrcから出てる辺全部に容量限界まで流す
+//      2. 流入 > 流出 なノードを見つけてバランスを取る
+//          - そこからDestまで到達するパスがあるなら、より
+//            Destに近い方向へ進む辺への流出量を増やす
+//          - ないなら、よりSrcへ近い方向から来る辺からの
+//            流入量を減らす
+//      3. 2.をアンバランスな頂点がなくなるまで繰り返す
+//   「流入 > 流出 なノードを見つけて」の処理は、流出入バランスを変えた時に
+//   Queueに突っ込んでおくことでFIFOでやる。
+//   「Destに近い方向」「Srcに近い方向」を常に厳密に評価する必要はなくて、
+//   ある程度の近似でも十分。下のコードではその近似値を d[] で持っている。
+//   d[] の評価を適度にちゃんとやったりするheuristicsで速くなるらしい。
+//   というかやらないと実際上は使い物にならないらしい。あとでちゃんとやる。
+//----------------------------------------------------------------------------
+
+#include <vector>
+#include <queue>
+#include <limits>
+using namespace std;
+
+typedef int                        Vert;
+typedef int                        Capacity;
+typedef vector< vector<Capacity> > Graph;
+
+Capacity goldberg_tarjan( Graph& G, Vert Src, Vert Dest )
+{
+	vector<Capacity> e( G.size() ); // excess   : 流入量 - 流出量
+	vector<int>      d( G.size() ); // distance : Destへの距離||Srcへの距離-Nの下限
+	d[Src] = G.size();
+
+	queue<Vert> Q; // e[v]>0 なノードを入れておくキュー
+
+	// とりあえずSrcから全力で流す
+	for(int v=0; v!=G.size(); ++v)
+		if( G[Src][v] )
+		{
+			G[v][Src] += G[Src][v];
+			e[v]      += G[Src][v];
+			G[Src][v]  = 0;
+			Q.push(v);
+		}
+
+	// e[v]>0 なノードがなくなるまで繰り返す
+	while( !Q.empty() )
+	{
+		Vert v = Q.front();
+
+		for(int u=0; u!=G.size() && e[v]; ++u)
+			if( G[v][u] && d[v]>d[u] ) // 適切な方向に流す "PUSH"
+			{
+				Capacity f = min(e[v], G[v][u]);
+				G[v][u] -= f;
+				G[u][v] += f;
+				e[v] -= f;
+				e[u] += f;
+				if( e[u]==f && u!=Src && u!=Dest ) Q.push(u);
+			}
+
+		if( e[v] == 0 ) // バランス取れたのでキューから除く
+			Q.pop();
+		else // バランス取れてないのはおかしいのでd[v]を調整してやり直し "RELABEL"
+		{
+			Capacity m = numeric_limits<Capacity>::max();
+			for(int u=0; u!=G.size(); ++u)
+				if( G[v][u] )
+					m = min(m, d[u]+1);
+			d[v] = m;
+		}
+	}
+
+	// Dest への流入量を返す
+	return e[Dest];
+}
+
+//----------------------------------------------------------------------------
+// PKU 1459
+//----------------------------------------------------------------------------
+
+#include <iostream>
+#include <locale>
+
+int main()
+{
+	cin.imbue( std::locale("C") );
+	for(int n,np,nc,m; cin>>n>>np>>nc>>m;)
+	{
+		// 0: src, 1: dst, 2: ...
+		Graph g(n+2, vector<Capacity>(n+2));
+
+		while(m--)
+		{
+			int u, v, z; char _;
+			cin >> _ >> u >> _ >> v >> _ >> z;
+			g[u+2][v+2] = z;
+		}
+
+		while(np--)
+		{
+			int u, z; char _;
+			cin >> _ >> u >> _ >> z;
+			g[0][u+2] = z;
+		}
+
+		while(nc--)
+		{
+			int u, z; char _;
+			cin >> _ >> u >> _ >> z;
+			g[u+2][1] = z;
+		}
+
+		cout << goldberg_tarjan(g, 0, 1) << endl;
+	}
+}

ADDED   _lib/graph/biMatch.cpp
Index: _lib/graph/biMatch.cpp
==================================================================
--- _lib/graph/biMatch.cpp
+++ _lib/graph/biMatch.cpp
@@ -0,0 +1,40 @@
+
+//-------------------------------------------------------------
+// Bipertite max-matching (by duality, min-vert-cover)
+//   O(V E)
+//
+// Verified by
+//   SRM 397 Div1 Lv3
+//-------------------------------------------------------------
+
+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;
+}

ADDED   _lib/graph/isGraphical.cpp
Index: _lib/graph/isGraphical.cpp
==================================================================
--- _lib/graph/isGraphical.cpp
+++ _lib/graph/isGraphical.cpp
@@ -0,0 +1,34 @@
+//-------------------------------------------------------------
+// Check the given list can be a degree list of some graph
+//   O(n^2)  (I suspect it can be made faster, though...)
+//
+// Verified by
+//   - SRM 398 Div1 LV3
+//
+//((
+// Havel-Hakimi
+//   If G[0], ..., G[n] (decreasing) is graphical,
+//   then G[1]-1, G[2]-1, ..., G[G[0]]-1, G[G[0]+1], .., G[n]
+//   is also graphical.
+//))
+//-------------------------------------------------------------
+
+bool isGraphical( vector<int> G )
+{
+	sort( G.begin(), G.end() );
+
+	vector<int>::iterator b = lower_bound( G.begin(), G.end(), 1 );
+	vector<int>::iterator e = G.end();
+
+	while( b < e )
+	{
+		int n = *(--e);
+		if( e-b < n )
+			return false;
+		for(vector<int>::iterator i=e-n; i!=e; ++i)
+			--*i;
+		inplace_merge( b, e-n, e );
+		b = lower_bound( G.begin(), G.end(), 1 );
+	}
+	return true;
+}

ADDED   _lib/graph/maxFlow.cpp
Index: _lib/graph/maxFlow.cpp
==================================================================
--- _lib/graph/maxFlow.cpp
+++ _lib/graph/maxFlow.cpp
@@ -0,0 +1,66 @@
+
+//-------------------------------------------------------------
+// Dinic's Algorithm
+//   O(V E)
+//
+// G : bidirectional (G[i].has(j) <==> G[j].has(i))
+// F : flow-capacity F[i][j] = Capacity, F[j][i] = 0
+//
+// Verified by
+//   - SRM 399 Div1 LV3
+//   - PKU 1459
+//   - CodeCraft 09 CUTS
+//   - SRM 465 Div1 LV2
+//-------------------------------------------------------------
+
+static const int NV = 512;
+typedef int           flow;
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+typedef flow          flow_graph[NV][NV];
+
+flow dinic_dfs( graph& G, flow_graph F, vert v, vert D,
+                int LV[], flow flow_in, int blocked[] )
+{
+	flow flow_out = 0;
+	for(int i=0; i!=G[v].size(); ++i) {
+		int u = G[v][i];
+		if( LV[v]+1==LV[u] && F[v][u] ) {
+			flow f = min(flow_in-flow_out, F[v][u]);
+			if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) ) {
+				F[v][u]  -= f;
+				F[u][v]  += f;
+				flow_out += f;
+				if( flow_in == flow_out ) return flow_out;
+			}
+		}
+	}
+	blocked[v] = (flow_out==0);
+	return flow_out;
+}
+
+flow maxFlow( graph& G, flow_graph F, vert S, vert D )
+{
+	for( flow total=0 ;; ) {
+		int LV[NV] = {0};
+		vector<int> Q(1, S);
+		for(int lv=1; !Q.empty(); ++lv) {
+			vector<int> Q2;
+			for(int i=0; i!=Q.size(); ++i) {
+				edges& ne = G[Q[i]];
+				for(int j=0; j!=ne.size(); ++j)
+					if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
+						LV[ne[j]]=lv, Q2.push_back(ne[j]);
+			}
+			Q.swap(Q2);
+		}
+
+		if( !LV[D] )
+			return total;
+
+		int blocked[NV] = {};
+		total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
+	}
+}

ADDED   _lib/graph/mincostFlow.cpp
Index: _lib/graph/mincostFlow.cpp
==================================================================
--- _lib/graph/mincostFlow.cpp
+++ _lib/graph/mincostFlow.cpp
@@ -0,0 +1,108 @@
+//-------------------------------------------------------------
+// MinCost-MaxFlow
+//   O(??)
+//
+// Verified by
+//   - SRM 487 Div2 LV3
+//   - SRM 491 Div1 LV3
+//-------------------------------------------------------------
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <map>
+#include <queue>
+using namespace std;
+
+template<typename T>
+class IdGen
+{
+	map<T, int> v2id_;
+	vector<T>   id2v_;
+public:
+	int v2id(const T& v) {
+		if( !v2id_.count(v) ) { v2id_[v] = size(); id2v_.push_back(v); }
+		return v2id_[v];
+	}
+	const T& id2v(int i) const { return id2v_[i]; }
+	int size() const { return id2v_.size(); }
+};
+
+template<typename Vert, typename Cost, typename Flow, int NV=256>
+class MinCostFlow
+{
+	IdGen<Vert> idgen;
+
+	vector<int> G[NV];
+	Flow F[NV][NV];
+	Cost C[NV][NV];
+
+public:
+	void addEdge( Vert s_, Vert t_, Cost c, Flow f )
+	{
+		int s = idgen.v2id(s_), t = idgen.v2id(t_);
+		G[s].push_back(t);
+		G[t].push_back(s);
+		C[s][t] = c;
+		C[t][s] = -c;
+		F[s][t] = f;
+		F[t][s] = 0;
+	}
+
+	pair<Cost, Flow> calc( Vert s_, Vert t_ )
+	{
+		const int N=idgen.size(), S=idgen.v2id(s_), T=idgen.v2id(t_);
+		static const Cost COST_INF = 1e+300; // !!EDIT HERE!!
+		static const Flow FLOW_INF = 0x7fffffff;
+
+		Cost total_cost = 0;
+		Flow total_flow = 0;
+		vector<Cost> h(N, 0); // potential
+		for(Flow RF=FLOW_INF; RF>0; ) // residual flow
+		{
+			// Dijkstra -- find the min-cost path
+			vector<Cost> d(N, COST_INF);  d[S] = 0;
+			vector<int>  prev(N, -1);
+
+			typedef pair< Cost, pair<int,int> > cedge;
+			priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
+			Q.push( cedge(0, make_pair(S,S)) );
+			while( !Q.empty() ) {
+				cedge e = Q.top(); Q.pop();
+				if( prev[e.second.second] >= 0 )
+					continue;
+				prev[e.second.second] = e.second.first;
+
+				int u = e.second.second;
+				for(int i=0; i<G[u].size(); ++i) {
+					int  v = G[u][i];
+					Cost r_cost = C[u][v] + h[u] - h[v];
+					if( F[u][v] > 0 && d[v] > d[u]+r_cost )
+						Q.push( cedge(d[v]=d[u]+r_cost, make_pair(u,v)) );
+				}
+			}
+
+			if( prev[T] < 0 )
+				break; // Finished
+
+			// Run the flow as much as possible
+			Flow f = RF;
+			for(int u=T; u!=S; u=prev[u])
+				f = min(f, F[prev[u]][u]);
+			RF         -= f;
+			total_flow += f;
+
+			for(int u=T; u!=S; u=prev[u])
+			{
+				total_cost    += f * C[prev[u]][u];
+				F[prev[u]][u] -= f;
+				F[u][prev[u]] += f;
+			}
+
+			// Update the potential
+			for(int u=0; u<N; ++u)
+				h[u] += d[u];
+		}
+		return make_pair(total_cost, total_flow);
+	}
+};

ADDED   _lib/graph/undAllPairMinCut.cpp
Index: _lib/graph/undAllPairMinCut.cpp
==================================================================
--- _lib/graph/undAllPairMinCut.cpp
+++ _lib/graph/undAllPairMinCut.cpp
@@ -0,0 +1,99 @@
+
+//-------------------------------------------------------------
+// Gomory-Hu
+// All Pair Minimum Cuts for an Undirected Graph
+//   O(V^4)
+//
+// G : undirected (G[i].has(j) <==> G[j].has(i))
+// F : flow-capacity F[i][j] = F[j][i] = Capacity
+//
+// Verified by
+//   - CodeCraft 09 CUTS
+//-------------------------------------------------------------
+
+static const int NV = 512;
+typedef int           flow;
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+typedef flow          flow_graph[NV][NV];
+
+flow_graph GHF;
+void GomoryHu( graph& G, flow_graph F, flow_graph AllPairMinCut )
+{
+	int N = G.size();
+	vector<vert> parent(N, 0);
+	vector<flow> weight(N, 0);
+
+	// construct the Gomory-Hu Tree
+	for(vert s=1; s<N; ++s)
+	{
+		vert t = parent[s];
+
+		// mincut between s and t
+		memcpy(GHF, F, sizeof(GHF));
+		flow mincut = 0;
+		for(;;) {
+			// bfs
+			vector<vert> prev(N, -1); prev[s]=s;
+			queue<vert> Q; Q.push(s);
+			while( !Q.empty() ) {
+				vert v = Q.front(); Q.pop();
+				for(int i=0; i<G[v].size(); ++i) {
+					vert u = G[v][i];
+					if( prev[u]==-1 && GHF[v][u] )
+						prev[u]=v, Q.push(u);
+				}
+			}
+
+			if( prev[t] == -1 )
+			{
+				// done: separeted to {v|prev[v]!=-1} and {v|prev[v]==-1}
+				// split t's children
+				weight[s] = mincut;
+				for(vert v=0; v<N; ++v)
+					if( parent[v]==t && prev[v]!=-1 && v!=s )
+						parent[v] = s;
+				vert pt = parent[t];
+				if( prev[pt]!=-1 )
+					parent[s]=pt, parent[t]=s, weight[s]=weight[t], weight[t]=mincut;
+				break;
+			}
+
+			// flow...
+			flow cur = 0x7fffffff;
+			for(vert v=t; v!=s; v=prev[v])
+				cur = min(cur, GHF[prev[v]][v]);
+			for(vert v=t; v!=s; v=prev[v])
+				GHF[prev[v]][v] -= cur, GHF[v][prev[v]] += cur;
+			mincut += cur;
+		}
+	}
+
+	// AllPairMinCuts over the G-H tree
+	for(vert s=0; s<N; ++s) {
+		vector<vert> ps_s;
+		for(vert v=s ;; v=parent[v])
+			{ ps_s.push_back(v); if( v==parent[v] ) break; }
+		reverse(ps_s.begin(), ps_s.end());
+
+		for(vert t=s+1; t<N; ++t) {
+			vector<vert> ps_t;
+			for(vert v=t ;; v=parent[v])
+				{ ps_t.push_back(v); if( v==parent[v] ) break; }
+			reverse(ps_t.begin(), ps_t.end());
+
+			vert ca;
+			for(int i=0; i<ps_s.size() && i<ps_t.size() && ps_s[i]==ps_t[i]; ++i)
+				ca = ps_s[i];
+
+			flow s_to_root = 0x7fffffff, t_to_root = 0x7fffffff;
+			for(vert v=s; v!=ca; v=parent[v])
+				s_to_root = min(s_to_root, weight[v]);
+			for(vert v=t; v!=ca; v=parent[v])
+				t_to_root = min(t_to_root, weight[v]);
+			AllPairMinCut[s][t] = AllPairMinCut[t][s] = min(s_to_root, t_to_root);
+		}
+	}
+}

ADDED   _lib/graph/undMinCut.cpp
Index: _lib/graph/undMinCut.cpp
==================================================================
--- _lib/graph/undMinCut.cpp
+++ _lib/graph/undMinCut.cpp
@@ -0,0 +1,68 @@
+
+//-------------------------------------------------------------
+// Stoer-Wagner
+// Minimum cost for making the graph unconnected
+//   O(V^3)
+//
+// G : bidirectional (G[v][u] == G[u][v])
+//
+// Verified by
+//   - SRM 340 Div1 LV3
+//-------------------------------------------------------------
+
+typedef int cost;
+typedef int vert;
+typedef vector< vector<cost> > graph;
+
+cost bidi_minCut( graph G, int N )
+{
+	vector<vert> V;
+	for(int v=0; v<N; ++v)
+		V.push_back(v);
+
+	cost result = 0x7fffffff;
+	for(int n=N; n>1; --n)
+	{
+		// invariant:
+		//   the current set of vertices = {V[0] .. V[n-1]}
+
+		// order the vertices
+		//   v0 = 0 (arbitrary),
+		//   v1 = (u that maximizes \Sigma G[v0][u])
+		//   v2 = (u that maximizes \Sigma G[v0][u]+G[v1][u])
+		//   ...
+		//   vn-2
+		//   vn-1 = (maximizes lastCut = \Sigma G[v0][u]+G[vn-2][u])
+		vector<int> vs;
+		cost lastCut = 0;
+		{
+			vector<cost> ws(n, 0);
+			ws[0] = 1;
+
+			for(int i=0; i<n; ++i) {
+				int j = max_element(ws.begin(), ws.end()) - ws.begin();
+				lastCut = ws[j];
+
+				vs.push_back(j);
+				ws[j] = -1;
+				for(int k=0; k<n; ++k)
+					if( ws[k] != -1 )
+						ws[k] += G[V[k]][V[j]];
+			}
+		}
+
+		// update mincut
+		//   lemma: "the min cost for separating vn-2 and vn-1"==lastCut
+		result = min(result, lastCut);
+
+		// reduce the graph (unify vn-2 and vn-1)
+		//   for testing the case vn-2 and vn-1 is connected
+		vert v2=vs[n-2], v1=vs[n-1];
+		for(int i=0; i<n; ++i) {
+			G[V[v2]][V[i]] += G[V[v1]][V[i]];
+			G[V[i]][V[v2]] += G[V[i]][V[v1]];
+		}
+		V.erase( V.begin() + v1 );
+	}
+	return result;
+}

ADDED   _lib/numeric/bigintFake.cpp
Index: _lib/numeric/bigintFake.cpp
==================================================================
--- _lib/numeric/bigintFake.cpp
+++ _lib/numeric/bigintFake.cpp
@@ -0,0 +1,14 @@
+
+string add(const string& a, const string& b)
+{
+	int n = max(a.size(), b.size()), carry=0;
+	string c(n, '0');
+	for(int i=0; i<n; ++i) {
+		int x = (a.size()<=i ? 0 : a[a.size()-1-i]-'0')
+		      + (b.size()<=i ? 0 : b[b.size()-1-i]-'0') + carry;
+		c[n-1-i] = char('0'+x%10);
+		carry = x/10;
+	}
+	if( carry ) c = char('0'+carry)+c;
+	return c;
+}

ADDED   _lib/numeric/erathos.cpp
Index: _lib/numeric/erathos.cpp
==================================================================
--- _lib/numeric/erathos.cpp
+++ _lib/numeric/erathos.cpp
@@ -0,0 +1,9 @@
+	static const int N = 999999;
+	vector<bool> isp(N+1, true);
+	vector<int> ps;
+	for(int p=2; p<=N; ++p)
+		if( isp[p] ) {
+			ps.push_back(p);
+			for(int q=p+p; q<=N; q+=p)
+				isp[q] = false;
+		}

ADDED   _lib/numeric/fft.cpp
Index: _lib/numeric/fft.cpp
==================================================================
--- _lib/numeric/fft.cpp
+++ _lib/numeric/fft.cpp
@@ -0,0 +1,39 @@
+
+//-------------------------------------------------------------
+// Fast Discrete Fourier Transform
+//   O(n log n)
+//   n must be a power of 2.
+//
+// Verified by
+//   - SRM 436 LV3
+//-------------------------------------------------------------
+
+CMP tmp[65536*4];
+
+template<int F>
+void fft_impl( CMP a[], int n, int stride = 1 )
+{
+	if( n > 1 )
+	{
+		CMP *ev=a, *od=a+stride;
+		int s2=stride*2, n2=n/2;
+
+		fft_impl<F>( ev, n2, s2 );
+		fft_impl<F>( od, n2, s2 );
+
+		for(int i=0; i<n; ++i) tmp[i] = ev[s2*(i%n2)] + od[s2*(i%n2)]*polar(1.0, F*2*M_PI*i/n);
+		for(int i=0; i<n; ++i) a[stride*i] = tmp[i];
+	}
+}
+
+void fft( vector<CMP>& a )
+{
+	fft_impl<+1>(&a[0], a.size());
+}
+
+void ifft( vector<CMP>& a )
+{
+	fft_impl<-1>(&a[0], a.size());
+	for(int i=0; i<a.size(); ++i)
+		a[i] /= a.size();
+}

ADDED   _lib/numeric/gcd_lcm.cpp
Index: _lib/numeric/gcd_lcm.cpp
==================================================================
--- _lib/numeric/gcd_lcm.cpp
+++ _lib/numeric/gcd_lcm.cpp
@@ -0,0 +1,28 @@
+LL gcd(LL a, LL b)
+{
+	while(a)
+		swap(a, b%=a);
+	return b;
+}
+
+LL lcm(LL a, LL b)
+{
+	return a/gcd(a,b)*b;
+}
+
+// Assumption: (a/b)*b+(a%b) == a
+//   For typical C/C++ compilers, % on negatives satisfies this.
+//   To be sure, replace a%b by a-a/b*b
+
+LL xgcd(LL a, LL b, LL* x, LL* y) // ax+by=g
+{
+	if(b) {
+		LL yy, g = xgcd(b,a%b,&yy,x);
+		*y = yy - a/b**x;
+		return g;
+	}
+	else {
+		*x=1, *y=0;
+		return a;
+	}
+}

ADDED   _lib/numeric/linearEq.cpp
Index: _lib/numeric/linearEq.cpp
==================================================================
--- _lib/numeric/linearEq.cpp
+++ _lib/numeric/linearEq.cpp
@@ -0,0 +1,40 @@
+
+//-------------------------------------------------------------
+// Linear Equation Solver
+//   O(n^3)
+//
+// Verified by
+//   - SRM 398 Div1 LV3
+//   - AOJ 0004
+//-------------------------------------------------------------
+
+vector<double> solve_linear_eq( int n, vector< vector<double> > M, const vector<double>& V )
+{
+	vector<double> A(V);
+	for(int i=0; i<n; ++i)
+	{
+		// pivot
+		if( M[i][i] == 0 )
+			for(int j=i+1; j<n; ++j)
+				if( M[j][i] != 0 )
+					{swap(M[i], M[j]); swap(A[i], A[j]); break;}
+		if( M[i][i] == 0 )
+			throw "no anser";
+
+		// M[i][i] <-- 1
+		double p = M[i][i];
+		for(int j=i; j<n; ++j)
+			M[i][j] /= p;
+		A[i] /= p;
+
+		// M[*][i] <-- 0
+		for(int j=0; j<n; ++j) if(j!=i)
+		{
+			double r = M[j][i];
+			for(int k=i; k<n; ++k)
+				M[j][k] -= M[i][k] * r;
+			A[j] -= A[i] * r;
+		}
+	}
+	return A;
+}

ADDED   _lib/numeric/linearEq2.cpp
Index: _lib/numeric/linearEq2.cpp
==================================================================
--- _lib/numeric/linearEq2.cpp
+++ _lib/numeric/linearEq2.cpp
@@ -0,0 +1,71 @@
+//-------------------------------------------------------------
+// Linear Equation Solver for Teplitz Matrix
+//   O(n^2)
+//
+// Faster solver for matrices satisfying
+//   M[i][j] == M[i+1][j+1]
+// for all i, j>0
+// Be careful that this implementation does not support the
+// case M[0][0]=M[1][1]=...=0. (zero-division)
+//
+// TODO: support M[0][0]=M[1][1]=...=0
+// QUICKHACK:
+//    find the least degenerated k and 
+//    calc initial vectors by gauss_jordan...
+//
+// Verified by
+//   - (Checked by random data to match with linearEq.cpp)
+//-------------------------------------------------------------
+
+vector<double> solve_teplitz( int n, vector< vector<double> > M, const vector<double>& V )
+{
+	vector<double> f, b, x;
+
+	// invariants
+	//   M|k f|k = (1 0 ... 0)
+	//   M|k b|k = (0 ... 0 1)
+	//   M|k x|k = V|k
+	f.push_back(    1 / M[0][0] );
+	b.push_back(    1 / M[0][0] );
+	x.push_back( V[0] / M[0][0] );
+
+	for(int k=2; k<=n; ++k)
+	{
+		// M|k (f|k-1 0) = (1 0 ... 0 ea)
+		double ea = 0;
+		for(int i=0; i<k-1; ++i)
+			ea += M[k-1][i] * f[i];
+
+		// M|k (0 b|k-1) = (eb 0 ... 0 1)
+		double eb = 0;
+		for(int i=1; i<k; ++i)
+			eb += M[0][i] * b[i-1];
+
+		// u(1 ea) + v(eb 1) = (1 0)
+		//==> u = 1 / (1-ea.eb),  v = -ea /(1-ea.eb)
+		double u = 1/(1-ea*eb), v = -ea/(1-ea*eb);
+		vector<double> ff;
+		for(int i=0; i<k; ++i)
+			ff.push_back( u*(i<k-1 ? f[i] : 0) + v*(i>0 ? b[i-1] : 0) );
+
+		// similarly...
+		u = -eb/(1-ea*eb), v = 1/(1-ea*eb);
+		vector<double> bb;
+		for(int i=0; i<k; ++i)
+			bb.push_back( u*(i<k-1 ? f[i] : 0) + v*(i>0 ? b[i-1] : 0) );
+
+		// update
+		f.swap(ff);
+		b.swap(bb);
+
+		// M|k (x|k 0) (V|k ec)
+		double ec = 0;
+		for(int i=0; i<k-1; ++i)
+			ec += M[k-1][i] * x[i];
+		x.push_back(0);
+		for(int i=0; i<k; ++i)
+			x[i] -= b[i] * (ec-V[k-1]);
+	}
+
+	return x;
+}

ADDED   _lib/numeric/matrix.cpp
Index: _lib/numeric/matrix.cpp
==================================================================
--- _lib/numeric/matrix.cpp
+++ _lib/numeric/matrix.cpp
@@ -0,0 +1,55 @@
+
+//-------------------------------------------------------------
+// Matrix Operations
+//
+// Verified by
+//   - SRM342 Div1 LV3
+//   - SRM341 Div1 LV3
+//   - SRM338 Div1 LV2
+//-------------------------------------------------------------
+
+vector<LL> vMul( const vector< vector<LL> >& A, const vector<LL>& B )
+{
+	const int n = A.size();
+
+	vector<LL> C(n);
+	for(int i=0; i<n; ++i)
+		for(int j=0; j<n; ++j)
+			C[i] += A[i][j] * B[j];
+	return C;
+}
+
+vector< vector<LL> > mMul( const vector< vector<LL> >& A, const vector< vector<LL> >& B )
+{
+	const int n = A.size();
+
+	vector< vector<LL> > C(n, vector<LL>(n));
+	for(int i=0; i<n; ++i)
+		for(int j=0; j<n; ++j) {
+			LL Cij = 0;
+			for(int k=0; k<n; ++k)
+				Cij += A[i][k] * B[k][j];
+			C[i][j] = Cij;
+		}
+	return C;
+}
+
+vector< vector<LL> > mPow( vector< vector<LL> > M, LL t ) // t>0
+{
+	vector< vector<LL> > R;
+	for(; t; t>>=1, M=mMul(M,M))
+		if( t&1 )
+			R = (R.empty() ? M : mMul(R,M));
+	return R;
+}
+
+vector< vector<LL> > mAdd( const vector< vector<LL> >& A, const vector< vector<LL> >& B )
+{
+	const int n = A.size();
+
+	vector< vector<LL> > C(n, vector<LL>(n));
+	for(int i=0; i<n; ++i)
+		for(int j=0; j<n; ++j)
+			C[i][j] = A[i][j] + B[i][j];
+	return C;
+}

ADDED   _lib/numeric/mebius.cpp
Index: _lib/numeric/mebius.cpp
==================================================================
--- _lib/numeric/mebius.cpp
+++ _lib/numeric/mebius.cpp
@@ -0,0 +1,36 @@
+
+//-------------------------------------------------------------
+// Mebius Function
+//   O( sqrt(N) )
+//
+// mebius(n) = 0      if n=0 mod p*p for some p
+// mebius(n) = (-1)^k otherwise, where k is the number of n's prime factors
+//
+// properties:
+//  1: mebius(nm) = mebius(n) mebius(m)   if gcd(n,m)=1
+//  2: f(n) = Sigma_{d|n} g(d)
+//       <=>
+//     g(n) = Sigma_{d|n} f(d)mebius(n/d)
+//
+// Verified by
+//   - CodeCraft '11 PSTR
+//
+// Further memoization or more might be needed.
+//-------------------------------------------------------------
+
+int mebius(int n)
+{
+	int f = 1;
+	for(int q=2; q*q<=n; ++q)
+		if( n%q == 0 )
+		{
+			if( n%(q*q) == 0 )
+				return 0;
+			n /= q;
+			f *= -1;
+		}
+	if(n>1)
+		f *= -1;
+	return f;
+}
+

ADDED   _lib/numeric/modArith.cpp
Index: _lib/numeric/modArith.cpp
==================================================================
--- _lib/numeric/modArith.cpp
+++ _lib/numeric/modArith.cpp
@@ -0,0 +1,93 @@
+
+//-------------------------------------------------------------
+// Modulo Arithmetics
+//
+// Verified by
+//   - TCO10 R3 LV3
+//-------------------------------------------------------------
+
+static const int MODVAL = 1000000007; // op/ depends on primarity of the MODVAL
+struct mint
+{
+	int val;
+	mint():val(0){}
+	mint(int x):val(x%MODVAL) {}
+	mint(LL  x):val(x%MODVAL) {}
+};
+
+mint operator+(mint x, mint y) { return x.val+y.val; }
+mint operator-(mint x, mint y) { return x.val-y.val+MODVAL; }
+mint operator*(mint x, mint y) { return LL(x.val)*y.val; }
+mint POW(mint x, int e) {
+	mint v = 1;
+	for(;e;x=x*x,e>>=1)
+		if(e&1)
+			v=v*x;
+	return v;
+}
+mint operator/(mint x, mint y) { return x * POW(y, MODVAL-2); }
+
+vector<mint> FAC_(1,1);
+void FAC_INIT(int n) { for(int i=1; i<=n; ++i) FAC_.push_back( FAC_.back()*i ); }
+mint FAC(mint x)       { return FAC_[x.val]; }
+mint C(mint n, mint k) { return k.val<0 || n.val<k.val ? 0 : FAC(n) / (FAC(k) * FAC(n-k)); }
+
+/*
+// MODVAL must be a prime!!
+LL GSS(LL k, LL b, LL e) // k^b + k^b+1 + ... + k^e
+{
+	if( b >  e ) return 0;
+	if( k <= 1 ) return k*(e-b+1);
+	return DIV(SUB(POW(k, e+1), POW(k,b)), k-1);
+}
+
+LL Cpascal(LL n, LL k)
+{
+	vector< vector<LL> > c(n+1, vector<LL>(k+1));
+	for(LL nn=1; nn<=n; ++nn)
+		for(LL kk=0; kk<=min(nn,k); ++kk)
+			c[nn][kk] = kk==0 || kk==nn ? 1 : ADD(c[nn-1][kk-1], c[nn-1][kk]);
+	return c[n][k];
+}
+
+vector< vector<LL> > MATMUL(vector< vector<LL> >& a, vector< vector<LL> >& b)
+{
+   int N = a.size();
+   vector< vector<LL> > c(N, vector<LL>(N));
+   for(int i=0; i<N; ++i)
+   for(int j=0; j<N; ++j)
+   for(int k=0; k<N; ++k)
+      c[i][j] = ADD(c[i][j], MUL(a[i][k],b[k][j]));
+   return c;
+}
+
+// works for non-prime MODVAL
+LL GEO(LL x_, LL e) // x^0 + x^1 + ... + x^e-1
+{
+   vector< vector<LL> > v(2, vector<LL>(2));
+   vector< vector<LL> > x(2, vector<LL>(2));
+   v[0][0] = v[1][1] = 1;
+   x[0][0] = x_; x[0][1] = 0;
+   x[1][0] = 1 ; x[1][1] = 1;
+   for(;e;x=MATMUL(x,x),e>>=1)
+      if(e&1)
+         v = MATMUL(v, x);
+   return v[1][0];
+}
+
+// works for non-prime MODVAL
+LL HYP(LL x_, LL e) // e x^0 + (e-1) x^1 + ... + 1 x^e-1 = GEO(x,1)+GEO(x,2)+...+GEO(x,e)
+{
+   vector< vector<LL> > v(3, vector<LL>(3));
+   vector< vector<LL> > x(3, vector<LL>(3));
+   v[0][0] = v[1][1] = v[2][2] = 1;
+   x[0][0] = x_; x[0][1] = 0; x[0][2] = 0;
+   x[1][0] = 1 ; x[1][1] = 1; x[1][2] = 0;
+   x[2][0] = 0 ; x[2][1] = 1; x[2][2] = 1;
+   e++;
+   for(;e;x=MATMUL(x,x),e>>=1)
+      if(e&1)
+         v = MATMUL(v, x);
+   return v[2][0];
+}
+*/

ADDED   _lib/numeric/modArithOld.cpp
Index: _lib/numeric/modArithOld.cpp
==================================================================
--- _lib/numeric/modArithOld.cpp
+++ _lib/numeric/modArithOld.cpp
@@ -0,0 +1,94 @@
+
+//-------------------------------------------------------------
+// Modulo Arithmetics
+//
+// Verified by
+//   - SRM 397 Div1 LV2
+//   - SRM 428 Div1 LV2
+//   - CodeCraft 2010 CNTINT DRAW
+//-------------------------------------------------------------
+
+static const LL MODVAL = 1000000007; // must fit in 32-bits
+
+LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
+LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
+LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
+LL POW(LL x, LL e) {
+	LL v = 1;
+	for(;e;x=MUL(x,x),e>>=1)
+		if(e&1)
+			v = MUL(v, x);
+	return v;
+}
+
+// MODVAL must be a prime!!
+LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
+
+// MODVAL must be a prime!!
+LL C(LL n, LL k) {
+	LL v = 1;
+	for(LL i=1; i<=k; ++i)
+		v = DIV(MUL(v, n-i+1), i);
+	return v;
+}
+
+// MODVAL must be a prime!!
+LL GSS(LL k, LL b, LL e) // k^b + k^b+1 + ... + k^e
+{
+	if( b >  e ) return 0;
+	if( k <= 1 ) return k*(e-b+1);
+	return DIV(SUB(POW(k, e+1), POW(k,b)), k-1);
+}
+
+
+
+
+LL Cpascal(LL n, LL k)
+{
+	vector< vector<LL> > c(n+1, vector<LL>(k+1));
+	for(LL nn=1; nn<=n; ++nn)
+		for(LL kk=0; kk<=min(nn,k); ++kk)
+			c[nn][kk] = kk==0 || kk==nn ? 1 : ADD(c[nn-1][kk-1], c[nn-1][kk]);
+	return c[n][k];
+}
+
+vector< vector<LL> > MATMUL(vector< vector<LL> >& a, vector< vector<LL> >& b)
+{
+   int N = a.size();
+   vector< vector<LL> > c(N, vector<LL>(N));
+   for(int i=0; i<N; ++i)
+   for(int j=0; j<N; ++j)
+   for(int k=0; k<N; ++k)
+      c[i][j] = ADD(c[i][j], MUL(a[i][k],b[k][j]));
+   return c;
+}
+
+// works for non-prime MODVAL
+LL GEO(LL x_, LL e) // x^0 + x^1 + ... + x^e-1
+{
+   vector< vector<LL> > v(2, vector<LL>(2));
+   vector< vector<LL> > x(2, vector<LL>(2));
+   v[0][0] = v[1][1] = 1;
+   x[0][0] = x_; x[0][1] = 0;
+   x[1][0] = 1 ; x[1][1] = 1;
+   for(;e;x=MATMUL(x,x),e>>=1)
+      if(e&1)
+         v = MATMUL(v, x);
+   return v[1][0];
+}
+
+// works for non-prime MODVAL
+LL HYP(LL x_, LL e) // e x^0 + (e-1) x^1 + ... + 1 x^e-1 = GEO(x,1)+GEO(x,2)+...+GEO(x,e)
+{
+   vector< vector<LL> > v(3, vector<LL>(3));
+   vector< vector<LL> > x(3, vector<LL>(3));
+   v[0][0] = v[1][1] = v[2][2] = 1;
+   x[0][0] = x_; x[0][1] = 0; x[0][2] = 0;
+   x[1][0] = 1 ; x[1][1] = 1; x[1][2] = 0;
+   x[2][0] = 0 ; x[2][1] = 1; x[2][2] = 1;
+   e++;
+   for(;e;x=MATMUL(x,x),e>>=1)
+      if(e&1)
+         v = MATMUL(v, x);
+   return v[2][0];
+}

ADDED   _lib/numeric/nextComb.cpp
Index: _lib/numeric/nextComb.cpp
==================================================================
--- _lib/numeric/nextComb.cpp
+++ _lib/numeric/nextComb.cpp
@@ -0,0 +1,15 @@
+//-------------------------------------------------------------
+// Next Combination
+//
+// Verified by
+//   - SRM345 Div1 LV3
+//-------------------------------------------------------------
+
+LL next_combination(LL p)
+{
+	assert( p > 0 );
+	LL lsb = p & -p;
+	LL rem = p + lsb;
+	LL rit = rem & ~p;
+	return rem | (rit/lsb >> 1)-1;
+}

ADDED   _lib/numeric/sternBrocot.cpp
Index: _lib/numeric/sternBrocot.cpp
==================================================================
--- _lib/numeric/sternBrocot.cpp
+++ _lib/numeric/sternBrocot.cpp
@@ -0,0 +1,52 @@
+
+//-------------------------------------------------------------
+// Enumerate all positive reduced fractions in a 
+// systematic manner.
+//   [pl/ql, pr/qr] --> [pl/ql, pm/qm] + [pm/qm, pr/qr]
+//                  --> ...
+//
+// Verified by
+//   - CodeCraft 09 FRACTION
+//-------------------------------------------------------------
+
+void sternBrocot(LL pl = 0, LL ql = 1, LL pr = 1, LL qr = 0)
+{
+	LL pm = pl + pr, qm = ql + qr;
+	sternBrocot(pl, ql, pm, qm);
+	sternBrocot(pm, qm, pr, qr);
+}
+
+/*
+bool fleq(LL p1, LL q1, LL p2, LL q2)
+{
+	return p1*q2 <= p2*q1;
+}
+
+void sternBrocot(LL pl = 0, LL ql = 1, LL pr = 1, LL qr = 0)
+{
+	for(;;) {
+		LL pm = pl + pr, qm = ql + qr;
+
+		if( fleq(c,d,pm,qm) ) {
+//			pr = pm, qr = qm; // [pl/ql, pm/qm]
+			LL X = c*ql - d*pl;
+			LL Y = d*pr - c*qr;
+			LL k = max(1LL, Y/X);
+			pr += k*pl;
+			qr += k*ql;
+		}
+		else if( fleq(pm,qm,a,b) ) {
+//			pl = pm, ql = qm; // [pm/qm, pr/qr]
+			LL X = b*pr - a*qr;
+			LL Y = a*ql - b*pl;
+			LL k = max(1LL, Y/X);
+			pl += k*pr;
+			ql += k*qr;
+		}
+		else {
+			cout << pm+qm*base << "/" << qm << endl;
+			break;
+		}
+	}
+}
+*/

ADDED   _lib/typical/amap.cpp
Index: _lib/typical/amap.cpp
==================================================================
--- _lib/typical/amap.cpp
+++ _lib/typical/amap.cpp
@@ -0,0 +1,72 @@
+//
+// accumulative map
+//   basically a map<K,V>, but it eliminates duplication lazily
+//   first keep all inserted elements in a vector. only when the buffer
+//   overflows, it eliminates duplication
+//
+
+template<typename K, typename V, int LIMIT = (1<<26)/3/sizeof(pair<K,V>)>
+struct amap
+{
+	typedef typename vector< pair<K,V> >::iterator iterator;
+
+	vector< pair<K,V> > kv;
+	amap() { kv.reserve(LIMIT); }
+
+	void add(const K& k, const V& v)
+	{
+		kv.push_back( make_pair(k,v) );
+		if( kv.size() == LIMIT )
+			normalize();
+	}
+
+	iterator begin()       { return kv.begin(); }
+	iterator end()         { return kv.end(); }
+	void swap( amap& rhs ) { kv.swap(rhs.kv); }
+
+	// Tested: SRM 469 Lv3
+	void normalize()
+	{
+		sort(kv.begin(), kv.end());
+		int i=0;
+		for(int j=0; j<kv.size(); ++i)
+		{
+			int k = j;
+			kv[i] = kv[k];
+			while( ++j<kv.size() && kv[k].first==kv[j].first )
+				kv[i].second += kv[j].second;
+		}
+		kv.resize(i);
+	}
+/*
+	// Not Tested (Prefer First)
+	void normalize()
+	{
+		sort(kv.begin(), kv.end());
+		int i=0;
+		for(int j=0; j<kv.size(); ++i)
+		{
+			int k = j;
+			kv[i] = kv[k];
+			while( ++j<kv.size() && kv[k].first==kv[j].first )
+				{}
+		}
+		kv.resize(i);
+	}
+
+	// Not Tested (Prefer Last)
+	void normalize()
+	{
+		sort(kv.begin(), kv.end());
+		int i=0;
+		for(int j=0; j<kv.size(); ++i)
+		{
+			int k = j;
+			while( ++j<kv.size() && kv[k].first==kv[j].first )
+				{}
+			kv[i] = kv[j-1];
+		}
+		kv.resize(i);
+	}
+*/
+};

ADDED   _lib/typical/bfs.cpp
Index: _lib/typical/bfs.cpp
==================================================================
--- _lib/typical/bfs.cpp
+++ _lib/typical/bfs.cpp
@@ -0,0 +1,26 @@
+// code template for BFS
+
+		State start = /*start*/;
+		vector<State> Q( 1, start );
+		set<State>    V; V.insert(start);
+
+		for(int step=0; !Q.empty(); ++step)
+		{
+			vector<State> Qold; Qold.swap(Q);
+			for(int qi=0; qi<Qold.size(); ++qi)
+			{
+				State& cur = Qold[qi];
+				if( /*isGoal(cur)*/ )
+				{
+				}
+
+				foreach(next)
+				{
+					if( !V.count(next) )
+					{
+						V.insert(next);
+						Q.push_back(next);
+					}
+				}
+			}
+		}

ADDED   _lib/typical/bitop.cpp
Index: _lib/typical/bitop.cpp
==================================================================
--- _lib/typical/bitop.cpp
+++ _lib/typical/bitop.cpp
@@ -0,0 +1,7 @@
+int bitcnt(LL x)
+{
+	int c = 0;
+	for(; x; x>>=1)
+		c += x&1;
+	return c;
+}

ADDED   _lib/typical/comb.cpp
Index: _lib/typical/comb.cpp
==================================================================
--- _lib/typical/comb.cpp
+++ _lib/typical/comb.cpp
@@ -0,0 +1,18 @@
+//-------------------------------------------------------------
+// number of combinations choosing k out of n
+// # you might better consider to use Pascal's triangle
+// # for comb modulo some number...
+//
+// Verified by
+//   - SRM 350 Div1 LV2
+//-------------------------------------------------------------
+
+LL comb(LL n, LL k)
+{
+	k = min(k, n-k);
+
+	LL c = 1;
+	for(LL i=0; i<k; ++i)
+		c *= n-i, c /= i+1;
+	return c;
+}

ADDED   _lib/typical/dp.cpp
Index: _lib/typical/dp.cpp
==================================================================
--- _lib/typical/dp.cpp
+++ _lib/typical/dp.cpp
@@ -0,0 +1,112 @@
+// Tested: SRM 454 Lv2
+template<typename T>
+struct DP2
+{
+	const int N1, N2;
+	vector<T> data;
+	DP2(int N1, int N2, const T& t = T())
+		: N1(N1), N2(N2), data(N1*N2, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2)
+		{ return data[ (i1*N2)+i2 ]; }
+	void swap(DP2& rhs)
+		{ data.swap(rhs.data); }
+};
+
+// Tested: Codeforces #13 C
+template<typename T>
+struct DP2x
+{
+	const int N1, N2;
+	vector<T> data;
+	DP2x(int, int N2, const T& t = T())
+		: N1(2), N2(N2), data(N1*N2, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2)
+		{ i1&=1; return data[ (i1*N2)+i2 ]; }
+	void swap(DP2x& rhs)
+		{ data.swap(rhs.data); }
+};
+
+// Tested: SRM 452 Lv3
+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); }
+};
+
+// Tested: SRM 468 Lv2
+template<typename T>
+struct DP3x
+{
+	int N1, N2, N3;
+	vector<T> data;
+	DP3x(int, int N2, int N3, const T& t = T())
+		: N1(2), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T) < (1<<26)); }
+	T& operator()(int i1, int i2, int i3)
+		{ i1&=1; return data[ ((i1*N2)+i2)*N3+i3 ]; }
+	void swap(DP3x& rhs)
+		{ data.swap(rhs.data); }
+};
+
+// Not Tested
+template<typename T>
+struct DP4
+{
+	int N1, N2, N3, N4;
+	vector<T> data;
+	DP4(int N1, int N2, int N3, int N4, const T& t = T())
+		: N1(N1), N2(N2), N3(N3), N4(N4), data(N1*N2*N3*N4, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2, int i3, int i4)
+		{ return data[ (((i1*N2)+i2)*N3+i3)*N4+i4 ]; }
+	void swap(DP4& rhs)
+		{ data.swap(rhs.data); }
+};
+
+// Not Tested
+template<typename T>
+struct DP4x
+{
+	int N1, N2, N3, N4;
+	vector<T> data;
+	DP4x(int, int N2, int N3, int N4, const T& t = T())
+		: N1(2), N2(N2), N3(N3), N4(N4), data(N1*N2*N3*N4, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2, int i3, int i4)
+		{ i1&=1; return data[ (((i1*N2)+i2)*N3+i3)*N4+i4 ]; }
+	void swap(DP4x& rhs)
+		{ data.swap(rhs.data); }
+};
+
+
+// Tested: SRM 351 Lv2
+template<typename T>
+struct DP5
+{
+	int N1, N2, N3, N4, N5;
+	vector<T> data;
+	DP5(int N1, int N2, int N3, int N4, int N5, const T& t = T())
+		: N1(N1), N2(N2), N3(N3), N4(N4), N5(N5), data(N1*N2*N3*N4*N5, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2, int i3, int i4, int i5)
+		{ return data[ ((((i1*N2)+i2)*N3+i3)*N4+i4)*N5+i5 ]; }
+	void swap(DP5& rhs)
+		{ data.swap(rhs.data); }
+};
+
+// Not Tested
+template<typename T>
+struct DP5x
+{
+	int N1, N2, N3, N4, N5;
+	vector<T> data;
+	DP5x(int, int N2, int N3, int N4, int N5, const T& t = T())
+		: N1(2), N2(N2), N3(N3), N4(N4), N5(N5), data(N1*N2*N3*N4*N5, t) { assert(data.size()*sizeof(T)<(1<<26)); }
+	T& operator()(int i1, int i2, int i3, int i4, int i5)
+		{ i1&=1; return data[ ((((i1*N2)+i2)*N3+i3)*N4+i4)*N5+i5 ]; }
+	void swap(DP5x& rhs)
+		{ data.swap(rhs.data); }
+};

ADDED   _lib/typical/idGen.cpp
Index: _lib/typical/idGen.cpp
==================================================================
--- _lib/typical/idGen.cpp
+++ _lib/typical/idGen.cpp
@@ -0,0 +1,21 @@
+//-------------------------------------------------------------
+// ID Assignment
+//
+// Verified by
+//   - ACM/ICPC Tokyo 2010 A
+//   - SRM 491 Div1 LV3
+//-------------------------------------------------------------
+
+template<typename T>
+class IdGen
+{
+	map<T, int> v2id_;
+	vector<T>   id2v_;
+public:
+	int v2id(const T& v) {
+		if( !v2id_.count(v) ) { v2id_[v] = size(); id2v_.push_back(v); }
+		return v2id_[v];
+	}
+	const T& id2v(int i) const { return id2v_[i]; }
+	int size() const { return id2v_.size(); }
+};

ADDED   _lib/typical/inMap.cpp
Index: _lib/typical/inMap.cpp
==================================================================
--- _lib/typical/inMap.cpp
+++ _lib/typical/inMap.cpp
@@ -0,0 +1,5 @@
+
+bool inMap(int H, int W, int y, int x)
+{
+	return (0<=y && y<H && 0<=x && x<W);
+}

ADDED   _lib/typical/maxRectArea.cpp
Index: _lib/typical/maxRectArea.cpp
==================================================================
--- _lib/typical/maxRectArea.cpp
+++ _lib/typical/maxRectArea.cpp
@@ -0,0 +1,39 @@
+//-------------------------------------------------------------
+// h[] : list of heights
+//   i-th rectangle is located at (i,0)--(i+1,h[i])
+//
+// calculate the area of maximum sub-rectangle
+//
+// Verified by
+//   - SRM 337 Div1 LV2
+//-------------------------------------------------------------
+
+		// solve
+		vector<int> left(n);
+		{
+			map<LL, int> h; h[-1] = -1;
+			for(int i=0; i<n; ++i) {
+				// position of the highest building < R[i]
+				map<LL,int>::iterator it = h.lower_bound(R[i]);
+				left[i] = (--it)->second+1;
+				h.erase( ++it, h.end() );
+				h[ R[i] ] = i;
+			}
+		}
+		vector<int> right(n);
+		{
+			map<LL, int> h; h[-1] = n;
+			for(int i=n-1; i>=0; --i) {
+				// position of the highest building < R[i]
+				map<LL,int>::iterator it = h.lower_bound(R[i]);
+				right[i] = (--it)->second-1;
+				h.erase( ++it, h.end() );
+				h[ R[i] ] = i;
+			}
+		}
+		LL ans = 0;
+		for(int i=0; i<n; ++i) {
+			LL area = R[i] * (right[i] - left[i] + 1);
+			ans = max(ans, area);
+		}
+		return ans;

ADDED   _lib/typical/setCover.cpp
Index: _lib/typical/setCover.cpp
==================================================================
--- _lib/typical/setCover.cpp
+++ _lib/typical/setCover.cpp
@@ -0,0 +1,69 @@
+
+//-------------------------------------------------------------
+// (Minimum) Set Cover
+//   NP-complete
+//
+// Consider using SetCoverEasy, when mask is downward closed.
+//
+// Verified by
+//   - SRM345 Div1 LV3
+//-------------------------------------------------------------
+
+LL next_combination(LL p)
+{
+	LL lsb = p & -p;
+	LL rem = p + lsb;
+	LL rit = rem & ~p;
+	return rem|(((rit/lsb)>>1)-1);
+}
+
+// Is it possible to cover the goal by at most k elements from mask?
+// Assumption:  goal \subseteq \bigcup mask
+bool canCover( LL goal, set<LL>& mask, int k )
+{
+	// optimizer
+	for(bool update=true; update; ) {
+		update = false;
+
+		// if *it \subseteq *jt for some jt, then we NEVER use it
+		// if *it is the only mask covering some city, we ALWAYS use it
+		for(set<LL>::iterator it=mask.begin(); it!=mask.end(); ) {
+			bool isSubset = false;
+			LL   onlyByMe = *it & goal;
+			for(set<LL>::iterator jt=mask.begin(); jt!=mask.end(); ++jt)
+				if( it!=jt ) {
+					onlyByMe &= ~*jt;
+					isSubset |= (*it & *jt & goal) == (*it & goal);
+				}
+
+			update |= isSubset | !!onlyByMe;
+
+			if( isSubset )
+				mask.erase(it++);
+			else if( onlyByMe ) {
+				if( --k < 0 )
+					return false;
+				goal &= ~*it;
+				mask.erase(it++);
+			}
+			else
+				++it;
+		}
+
+		if( mask.size()<=k || goal==0 )
+			return true;
+	}
+
+	// exhaustive search
+	vector<LL> ms(mask.begin(), mask.end());
+	for(LL i=(1LL<<k)-1; i<(1LL<<ms.size()); i=next_combination(i))
+	{
+		LL gg = goal;
+		for(LL j=0; (1LL<<j)<=i; ++j)
+			if( i & (1<<j) )
+				gg &= ~ms[j];
+		if( gg == 0 )
+			return true;
+	}
+	return false;
+}

ADDED   _lib/typical/setCoverEasy.cpp
Index: _lib/typical/setCoverEasy.cpp
==================================================================
--- _lib/typical/setCoverEasy.cpp
+++ _lib/typical/setCoverEasy.cpp
@@ -0,0 +1,74 @@
+
+//-------------------------------------------------------------
+// (Minimum) Set Cover
+//   NP-complete
+//
+// Assumption: "mask" must be downward closerd,
+//   i.e., X subset Y & Y in mask => X in mask
+//
+// Verified by
+//   - Google Code Jam 09 Round2 C
+//     (The "Only" part never tested, in the test cases of
+//      the problem, that optimization had never used.
+//      Be careful to use that; to be on the safer side,
+//      consider using the <true,false> mode.)
+//-------------------------------------------------------------
+
+int minCover_exhaustive( int goal, const set<int>& mask )
+{
+	typedef int STATE;
+
+	vector<STATE> Q( 1, 0 );
+	set<STATE> visited;
+	for(int step=0; step<=mask.size(); ++step)
+	{
+		vector<STATE> Q2;
+		for(int i=0; i<Q.size(); ++i)
+		{
+			STATE s = Q[i];
+			if( s == goal )
+				return step;
+			for(set<int>::const_iterator it=mask.begin(); it!=mask.end(); ++it)
+				if( !visited.count( s|*it ) )
+				{
+					visited.insert( s|*it );
+					Q2.push_back( s|*it );
+				}
+		}
+		Q.swap(Q2);
+	}
+	return -1;
+}
+
+template<bool Subs, bool Only>
+int minCover( int goal, set<int> mask )
+{
+	if( Subs )
+		for(set<int>::iterator it=mask.begin(); it!=mask.end(); )
+		{
+			bool needed = true;
+			for(int m=1; m<=goal; m<<=1)
+				if( (goal&m) && !(*it&m) && mask.count(*it|m))
+					{needed = false; break;}
+
+			if( needed )
+				++it;
+			else
+				mask.erase(it++);
+		}
+
+	if( Only )
+		for(set<int>::iterator it=mask.begin(); it!=mask.end(); )
+		{
+			int onlyByMe = goal & *it;
+			for(set<int>::iterator jt=mask.begin(); jt!=mask.end(); ++jt)
+				onlyByMe &= ~*jt;
+	
+			if( !onlyByMe )
+				++it;
+			else
+				mask.erase(it++), goal &= ~onlyByMe;
+		}
+
+	return minCover_exhaustive(goal, mask);
+}

ADDED   _lib/typical/ternery.cpp
Index: _lib/typical/ternery.cpp
==================================================================
--- _lib/typical/ternery.cpp
+++ _lib/typical/ternery.cpp
@@ -0,0 +1,18 @@
+// ternery search (for shita-ni-totsu)
+{
+	double x = ~min~;
+	double w = ~max~;
+	for(int i=0; i<~iteration~; ++i) // or, while( w-x > ~eps~ ) be careful for precision!
+	{
+		double y = 2*x/3 + w/3;
+		double z = x/3 + 2*w/3;
+		double fx = f(x);
+		double fy = f(y);
+		double fz = f(z);
+		double fw = f(w);
+		if( fx < fy )      w = y;
+		else if( fz > fw ) x = z;
+		else if( fy < fz ) w = z;
+		else               x = y;
+	}
+}

ADDED   _lib/typical/unionfind.cpp
Index: _lib/typical/unionfind.cpp
==================================================================
--- _lib/typical/unionfind.cpp
+++ _lib/typical/unionfind.cpp
@@ -0,0 +1,33 @@
+//-------------------------------------------------------------
+// Union-Find
+//   Balancing + Path-Compression : O(invAckermann)
+//
+// Verified by
+//   - SRM Member Pilot 2 Div1 LV2
+//-------------------------------------------------------------
+
+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);
+		}
+};