ADDED   SRM/628-U/1A.cpp
Index: SRM/628-U/1A.cpp
==================================================================
--- SRM/628-U/1A.cpp
+++ SRM/628-U/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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class DivisorsPower { public:
+	long long findArgument(long long n)
+	{
+		LL cand = 1LL<<62;
+		for(int p=2; p<=63; ++p) {
+			LL xc = LL(pow(double(n), 1.0/p));
+			for(LL x=max(2LL,xc-100); x<=min(xc+100,n); ++x)
+				if(ok(x,n))
+					cand = min(cand, x);
+		}
+		return (cand==(1LL<<62) ? -1 : cand);
+	}
+
+	int d(LL x)
+	{
+		int cnt = 1;
+		for(int p=2; p*p<=x; ++p)
+			if(x%p==0) {
+				int k = 0;
+				while(x%p==0) x/=p, ++k;
+				cnt *= 1+k;
+			}
+		if(x>1)
+			cnt *= 2;
+		return cnt;
+	}
+
+	int ilog(LL x, LL n)
+	{
+		int cnt = 0;
+		while(n%x==0) 
+			n/=x, ++cnt;
+		return n>1 ? -1 : cnt;
+	}
+
+
+	bool ok(LL x, LL n)
+	{
+		return ilog(x, n) == 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 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(_, DivisorsPower().findArgument(n));}
+int main(){
+
+CASE(0)
+	long long n = 4LL; 
+	long long _ = 2LL; 
+END
+CASE(1)
+	long long n = 10LL; 
+	long long _ = -1LL; 
+END
+CASE(2)
+	long long n = 64LL; 
+	long long _ = 4LL; 
+END
+CASE(3)
+	long long n = 10000LL; 
+	long long _ = 10LL; 
+END
+CASE(4)
+	long long n = 2498388559757689LL; 
+	long long _ = 49983883LL; 
+END
+/*
+CASE(5)
+	long long n = LL; 
+	long long _ = LL; 
+END
+CASE(6)
+	long long n = LL; 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/628-U/1B.cpp
Index: SRM/628-U/1B.cpp
==================================================================
--- SRM/628-U/1B.cpp
+++ SRM/628-U/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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+enum Type {X, SUM, MAX};
+struct Tree {
+	Type type;
+	Tree* left;
+	Tree* right;
+	int size;
+	~Tree() { delete left; delete right; }
+};
+
+class CircuitsConstruction { public:
+	int maximizeResistance(string circuit, vector <int> conductors)
+	{
+		sort(conductors.rbegin(), conductors.rend());
+		const char* p = circuit.c_str();
+		Tree* t = parse(p);
+		int ans = solve(t, conductors);
+		delete t;
+		return ans;
+	}
+
+	Tree* parse(const char*& p)
+	{
+		char tc = *p++;
+		Tree* t = new Tree;
+		t->type = (tc=='X' ? X : tc=='A' ? SUM : MAX);
+		if(tc=='X') {
+			t->left = t->right = 0;
+			t->size = 1;
+		} else {
+			t->left = parse(p);
+			t->right = parse(p);
+			t->size = t->left->size + t->right->size;
+		}
+		return t;
+	}
+
+	int plusdepth(Tree* t)
+	{
+		switch(t->type)
+		{
+		case X:
+			return 0;
+		case SUM:
+			return plusdepth(t->left) + plusdepth(t->right) + 1;
+		case MAX:
+			return max(plusdepth(t->left), plusdepth(t->right));
+		}
+	}
+
+	int solve(Tree* t, const vector<int>& c)
+	{
+		int n = plusdepth(t)+1;
+		return accumulate(c.begin(), c.begin()+n, 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(_, CircuitsConstruction().maximizeResistance(circuit, conductors));}
+int main(){
+
+CASE(0)
+	string circuit = "BXBXX"; 
+	int conductors_[] = {8, 2, 3};
+	  vector <int> conductors(conductors_, conductors_+sizeof(conductors_)/sizeof(*conductors_)); 
+	int _ = 8; 
+END
+CASE(1)
+	string circuit = "AAXXAXAXX"; 
+	int conductors_[] = {1, 1, 2, 8, 10};
+	  vector <int> conductors(conductors_, conductors_+sizeof(conductors_)/sizeof(*conductors_)); 
+	int _ = 22; 
+END
+CASE(2)
+	string circuit = "AXBXX"; 
+	int conductors_[] = {8, 2, 3};
+	  vector <int> conductors(conductors_, conductors_+sizeof(conductors_)/sizeof(*conductors_)); 
+	int _ = 11; 
+END
+CASE(3)
+	string circuit = "BAAXBXXBXAXXBBAXXBXXAAXXX"; 
+	int conductors_[] = {17, 7, 21, 102, 56, 72, 88, 15, 9, 192, 16, 8, 30};
+	  vector <int> conductors(conductors_, conductors_+sizeof(conductors_)/sizeof(*conductors_)); 
+	int _ = 454; 
+END
+/*
+CASE(4)
+	string circuit = ; 
+	int conductors_[] = ;
+	  vector <int> conductors(conductors_, conductors_+sizeof(conductors_)/sizeof(*conductors_)); 
+	int _ = ; 
+END
+CASE(5)
+	string circuit = ; 
+	int conductors_[] = ;
+	  vector <int> conductors(conductors_, conductors_+sizeof(conductors_)/sizeof(*conductors_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/628-U/1C-U.cpp
Index: SRM/628-U/1C-U.cpp
==================================================================
--- SRM/628-U/1C-U.cpp
+++ SRM/628-U/1C-U.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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class DoraemonPuzzleGame { public:
+	double solve(vector <int> X, vector <int> Y, int m)
+	{
+		int N = X.size(), M = m;
+		vector<tuple<double,double,double>> P;
+		for(int i=0; i<N; ++i)
+			P.emplace_back(
+				(1000-X[i]-Y[i])*0.001,
+				X[i]*0.001,
+				Y[i]*0.001
+			);
+		sort(P.begin(), P.end(), [&](const tuple<double,double,double>& lhs, const tuple<double,double,double>& rhs){
+			if(get<2>(lhs) != get<2>(rhs)) return get<2>(lhs) > get<2>(rhs);
+			if(get<1>(lhs) != get<1>(rhs)) return get<1>(lhs) > get<1>(rhs);
+			return get<0>(lhs) > get<0>(rhs);
+		});
+		return solve(M-N, P);
+	}
+
+	double solve(int Extra, const vector<tuple<double,double,double>>& P)
+	{
+		double eee = 0.0;
+		for(int eff=0; eff<=P.size(); ++eff)
+		{
+			double e_clear = 0.0;
+			vector<double> adv(1, 1.0);  // adv[0] = 1.0;
+			for(int i=0; i<P.size(); ++i) {
+				double p1 = get<1>(P[i]);
+				double p2 = get<2>(P[i]);
+				if(i<eff) {
+					e_clear += 1/p2;
+				} else {
+					double p = p1 + p2;
+					e_clear += 1/p;
+
+					vector<double> a2(adv.size()+1);
+					for(int i=0; i<adv.size(); ++i) {
+						a2[i] += adv[i] * p1/p;
+						a2[i+1] += adv[i] * p2/p;
+					}
+					adv = a2;
+				}
+			}
+
+			if(Extra <= eff) {
+				best = min(best, e_clear);
+			} else {
+				best = min(best, 
+			}
+		}
+		return eee;
+	}
+};
+
+// BEGIN CUT HERE
+#include <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(_, DoraemonPuzzleGame().solve(X, Y, m));}
+int main(){
+
+CASE(0)
+	int X_[] = {800};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {200};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int m = 2; 
+	double _ = 5.0; 
+END
+CASE(1)
+	int X_[] = {1,999,999};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {999,1,1};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int m = 3; 
+	double _ = 3.0; 
+END
+CASE(2)
+	int X_[] = {500,500};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {500,500};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int m = 3; 
+	double _ = 2.5; 
+END
+CASE(3)
+	int X_[] = {250,250,250,250};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {250,250,250,250};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int m = 5; 
+	double _ = 8.25; 
+END
+CASE(4)
+	int X_[] = {250,500,250};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {500,250,500};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int m = 5; 
+	double _ = 4.962962962962963; 
+END
+CASE(5)
+	int X_[] = {600,900,800,500,900,200,400,100,800,300,900,300,800,700,800,600,800,900,400,100,100,700,600,100,500,
+800,700,600,900,600,300,100,300,100,700,500,900,200,800,400,300,700,300,400,700,300,400,800,300,200};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {400,100,200,500,100,800,600,900,200,700,100,700,200,300,200,400,200,100,600,900,900,300,400,900,500,
+200,300,400,100,400,700,900,700,900,300,500,100,800,200,600,700,300,700,600,300,700,600,200,700,800};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int m = 95; 
+	double _ = 119.33578280666175; 
+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 m = ; 
+	double _ = ; 
+END
+CASE(7)
+	int X_[] = ;
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = ;
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int m = ; 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE