ADDED   SRM/559-U/1A.cpp
Index: SRM/559-U/1A.cpp
==================================================================
--- SRM/559-U/1A.cpp
+++ SRM/559-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>
+using namespace std;
+typedef long long LL;
+typedef long double LD;
+typedef complex<LD> CMP;
+
+class HyperKnight { public:
+	long long countCells(int a_, int b_, int numRows, int numColumns, int K)
+	{
+		if(a_>b_) swap(a_,b_);
+		const LL A=a_, B=b_, W=numRows, H=numColumns;
+
+		LL xx[] = {0, A, B, W-B, W-A, W};
+		LL yy[] = {0, A, B, H-B, H-A, H};
+		LL dx[] = {+A, +A, -A, -A, +B, +B, -B, -B};
+		LL dy[] = {+B, -B, +B, -B, +A, -A, +A, -A};
+
+		LL cnt = 0;
+		for(int i=0; i+1<sizeof(xx)/sizeof(*xx); ++i)
+		for(int k=0; k+1<sizeof(yy)/sizeof(*yy); ++k) {
+			LL w = xx[i+1]-xx[i], x = xx[i];
+			LL h = yy[k+1]-yy[k], y = yy[k];
+			int av = 0;
+			for(int j=0; j<8; ++j) {
+				LL x2 = x + dx[j];
+				LL y2 = y + dy[j];
+				if(0<=x2 && x2<W && 0<=y2&&y2<H)
+					++av;
+			}
+			if(av==K)
+				cnt += w*h;
+		}
+		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(_, HyperKnight().countCells(a, b, numRows, numColumns, k));}
+int main(){
+
+CASE(0)
+	int a = 2; 
+	int b = 1; 
+	int numRows = 8; 
+	int numColumns = 8; 
+	int k = 4; 
+	long long _ = 20LL; 
+END
+CASE(1)
+	int a = 3; 
+	int b = 2; 
+	int numRows = 8; 
+	int numColumns = 8; 
+	int k = 2; 
+	long long _ = 16LL; 
+END
+CASE(2)
+	int a = 1; 
+	int b = 3; 
+	int numRows = 7; 
+	int numColumns = 11; 
+	int k = 0; 
+	long long _ = 0LL; 
+END
+CASE(3)
+	int a = 3; 
+	int b = 2; 
+	int numRows = 10; 
+	int numColumns = 20; 
+	int k = 8; 
+	long long _ = 56LL; 
+END
+CASE(4)
+	int a = 1; 
+	int b = 4; 
+	int numRows = 100; 
+	int numColumns = 10; 
+	int k = 6; 
+	long long _ = 564LL; 
+END
+CASE(5)
+	int a = 2; 
+	int b = 3; 
+	int numRows = 1000000000; 
+	int numColumns = 1000000000; 
+	int k = 8; 
+	long long _ = 999999988000000036LL; 
+END
+/*
+CASE(6)
+	int a = ; 
+	int b = ; 
+	int numRows = ; 
+	int numColumns = ; 
+	int k = ; 
+	long long _ = LL; 
+END
+CASE(7)
+	int a = ; 
+	int b = ; 
+	int numRows = ; 
+	int numColumns = ; 
+	int k = ; 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/559-U/1B.cpp
Index: SRM/559-U/1B.cpp
==================================================================
--- SRM/559-U/1B.cpp
+++ SRM/559-U/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>
+using namespace std;
+typedef long long LL;
+typedef long double LD;
+typedef complex<LD> CMP;
+
+typedef int vert;
+typedef vector< vector<vert> > graph;
+
+class HatRack { public:
+	long long countWays(vector <int> knob1, vector <int> knob2)
+	{
+		int N = knob1.size() + 1;
+		graph G(N);
+		for(int i=0; i<knob1.size(); ++i) {
+			int u = knob1[i] - 1;
+			int v = knob2[i] - 1;
+			G[u].push_back(v);
+			G[v].push_back(u);
+		}
+		memo.assign((N+1)*N*N, -1);
+		LL total = 0;
+		for(int root=0; root<N; ++root)
+			total += solve(G, N, root);
+		return total;
+	}
+
+	LL solve(const graph& G, int N, vert root)
+	{
+		return rec(G, N, N, root, 1);
+	}
+
+	vector<LL> memo;
+	LL rec(const graph& G, const int N, int pre, int cur, int loc) {
+		int key = (pre*N+cur)*N+(loc-1);
+		if(memo[key] != -1)
+			return memo[key];
+
+		vector<int> e_child;
+		if(loc*2+0 <= N) e_child.push_back(loc*2+0);
+		if(loc*2+1 <= N) e_child.push_back(loc*2+1);
+
+		vector<int> r_child;
+		for(int i=0; i<G[cur].size(); ++i)
+			if(G[cur][i] != pre)
+				r_child.push_back(G[cur][i]);
+
+		if(e_child.size() != r_child.size())
+			return memo[key] = 0;
+
+		LL total = 0;
+		do {
+			LL me = 1;
+			for(int i=0; i<e_child.size(); ++i)
+				me *= rec(G, N, cur, r_child[i], e_child[i]);
+			total += me;
+		} while( next_permutation(e_child.begin(), e_child.end()) );
+		return memo[key] = 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(_, HatRack().countWays(knob1, knob2));}
+int main(){
+
+CASE(0)
+	int knob1_[] = {1};
+	  vector <int> knob1(knob1_, knob1_+sizeof(knob1_)/sizeof(*knob1_)); 
+	int knob2_[] = {2};
+	  vector <int> knob2(knob2_, knob2_+sizeof(knob2_)/sizeof(*knob2_)); 
+	long long _ = 2LL; 
+END
+CASE(1)
+	int knob1_[] = {1,1};
+	  vector <int> knob1(knob1_, knob1_+sizeof(knob1_)/sizeof(*knob1_)); 
+	int knob2_[] = {2,3};
+	  vector <int> knob2(knob2_, knob2_+sizeof(knob2_)/sizeof(*knob2_)); 
+	long long _ = 2LL; 
+END
+CASE(2)
+	int knob1_[] = {1,1,1,1};
+	  vector <int> knob1(knob1_, knob1_+sizeof(knob1_)/sizeof(*knob1_)); 
+	int knob2_[] = {2,3,4,5};
+	  vector <int> knob2(knob2_, knob2_+sizeof(knob2_)/sizeof(*knob2_)); 
+	long long _ = 0LL; 
+END
+CASE(3)
+	int knob1_[] = {6,6,6,4,1};
+	  vector <int> knob1(knob1_, knob1_+sizeof(knob1_)/sizeof(*knob1_)); 
+	int knob2_[] = {1,2,4,5,3};
+	  vector <int> knob2(knob2_, knob2_+sizeof(knob2_)/sizeof(*knob2_)); 
+	long long _ = 0LL; 
+END
+CASE(4)
+	int knob1_[] = {1,1,2,2,11,11,8,8,3,3,4,4,5};
+	  vector <int> knob1(knob1_, knob1_+sizeof(knob1_)/sizeof(*knob1_)); 
+	int knob2_[] = {2,3,11,8,12,13,9,10,4,5,7,6,14};
+	  vector <int> knob2(knob2_, knob2_+sizeof(knob2_)/sizeof(*knob2_)); 
+	long long _ = 16LL; 
+END
+CASE(5)
+	int knob1_[] = {1,2,3,4,5,6,7,8,9};
+	  vector <int> knob1(knob1_, knob1_+sizeof(knob1_)/sizeof(*knob1_)); 
+	int knob2_[] = {2,3,4,5,6,7,8,9,10};
+	  vector <int> knob2(knob2_, knob2_+sizeof(knob2_)/sizeof(*knob2_)); 
+	long long _ = 0LL; 
+END
+/*
+CASE(6)
+	int knob1_[] = ;
+	  vector <int> knob1(knob1_, knob1_+sizeof(knob1_)/sizeof(*knob1_)); 
+	int knob2_[] = ;
+	  vector <int> knob2(knob2_, knob2_+sizeof(knob2_)/sizeof(*knob2_)); 
+	long long _ = LL; 
+END
+CASE(7)
+	int knob1_[] = ;
+	  vector <int> knob1(knob1_, knob1_+sizeof(knob1_)/sizeof(*knob1_)); 
+	int knob2_[] = ;
+	  vector <int> knob2(knob2_, knob2_+sizeof(knob2_)/sizeof(*knob2_)); 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/559-U/1C-U.cpp
Index: SRM/559-U/1C-U.cpp
==================================================================
--- SRM/559-U/1C-U.cpp
+++ SRM/559-U/1C-U.cpp
@@ -0,0 +1,200 @@
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+#include <complex>
+#include <queue>
+#include <stack>
+#include <cmath>
+#include <cassert>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+struct Circle {
+	CMP o;
+	double r;
+};
+
+bool line_circle(CMP la, CMP lb, CMP c, double r, CMP* p1, CMP* p2)
+{
+	CMP v = (lb-la) / abs(lb-la);
+	CMP o = (c-la) / v;
+	if( abs(o.imag()) > r )
+		return false;
+	double dx = sqrt(r*r - o.imag()*o.imag());
+	*p1 = la + (o.real()-dx)*v;
+	*p2 = la + (o.real()+dx)*v;
+	return true;
+}
+
+class CircusTents { public:
+	double findMaximumDistance(vector <int> x, vector <int> y, vector <int> r)
+	{
+		double f = r[0];
+
+		vector<Circle> cs;
+		for(int i=1; i<x.size(); ++i) {
+			Circle you = {CMP(x[1]-x[0], y[1]-y[0])/f, double(r[1])/f};
+			cs.push_back(you);
+		}
+
+		return solve(cs) * f;
+	}
+
+	double solve(const vector<Circle>& cs)
+	{
+		vector<double> args;
+
+		for(int i=0; i<cs.size(); ++i)
+		for(int k=i+1; k<cs.size(); ++k) {
+			CMP p = cs[i].o;
+			CMP q = cs[k].o;
+
+			double len = abs(q-p);
+			double mid = (len - cs[i].r - cs[k].r)/2+cs[i].r;
+			CMP r = (q-p)/len*mid;
+			CMP d = (q-p)/len*CMP(0,1);
+			/// r + td is the splitting line.
+
+			CMP x1, x2;
+			if( line_circle(r, r+d, CMP(0,0), 1.0, &x1, &x2) ) {
+				args.push_back(arg(x1));
+				args.push_back(arg(x2));
+			}
+		}
+
+		if(args.empty()) {
+			args.push_back(0.0);
+			args.push_back(1.0);
+		}
+		sort(args.begin(), args.end());
+
+		double best = 0.0;
+		for(int i=0; i<args.size(); ++i) {
+			double aL = args[i];
+			double aR = (i+1==args.size() ? args[0]+M_PI/2 : args[i+1]);
+
+			double aC = (aL+aR) / 2;
+			CMP p = polar(1.0, aC);
+
+			int close = -1; double close_d = 999999999;
+			for(int k=0; k<cs.size(); ++k) {
+				double d = abs(p - cs[k].o) - cs[k].r;
+				if(d<close_d) {close=k, close_d=d;}
+			}
+
+			CMP pL = polar(1.0, aL);
+			CMP pR = polar(1.0, aR);
+			CMP v = cs[close].o;
+			pL /= v/abs(v);
+			pR /= v/abs(v);
+			double aaL = arg(pL);
+			double aaR = arg(pR);
+			double theA;
+			if(aaL > aaR) {
+				theA = M_PI;
+			} else {
+				theA = (abs(aaL)>abs(aaR) ? aaL : aaR);
+			}
+
+			// distance from polar(1.0, theA) to Circ((abs(v),0), cs[close].r)
+			// ... avoiding the two circle!
+			double ddd = 0;
+cerr<<polar(1.0, theA)<<endl;
+			best = min(best, ddd);
+		}
+		return 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 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(_, CircusTents().findMaximumDistance(x, y, r));}
+int main(){
+
+CASE(0)
+	int x_[] = {0,3};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int r_[] = {1,1};
+	  vector <int> r(r_, r_+sizeof(r_)/sizeof(*r_)); 
+	double _ = 3.7390603609952078; 
+END
+CASE(1)
+	int x_[] = {0,3,-3,3,-3};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,3,3,-3,-3};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int r_[] = {1,1,1,1,1};
+	  vector <int> r(r_, r_+sizeof(r_)/sizeof(*r_)); 
+	double _ = 2.6055512754639887; 
+END
+CASE(2)
+	int x_[] = {3,7,7,7,3};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {4,6,1,-3,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int r_[] = {2,2,2,1,1};
+	  vector <int> r(r_, r_+sizeof(r_)/sizeof(*r_)); 
+	double _ = 4.3264459099620725; 
+END
+CASE(3)
+	int x_[] = {10,-1};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,0};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int r_[] = {8,2};
+	  vector <int> r(r_, r_+sizeof(r_)/sizeof(*r_)); 
+	double _ = 24.63092458664212; 
+END
+CASE(4)
+	int x_[] = {0,4,-4};
+	  vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_)); 
+	int y_[] = {0,4,-4};
+	  vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_)); 
+	int r_[] = {1,1,1};
+	  vector <int> r(r_, r_+sizeof(r_)/sizeof(*r_)); 
+	double _ = 4.745474963675133; 
+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 r_[] = ;
+	  vector <int> r(r_, r_+sizeof(r_)/sizeof(*r_)); 
+	double _ = ; 
+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 r_[] = ;
+	  vector <int> r(r_, r_+sizeof(r_)/sizeof(*r_)); 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE