ADDED   SRM/616-U/1A.cpp
Index: SRM/616-U/1A.cpp
==================================================================
--- SRM/616-U/1A.cpp
+++ SRM/616-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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class AmebaDiv1 { public:
+	int count(vector <int> X)
+	{
+		set<int> last(X.begin(), X.end());
+		int cnt = 0;
+		for(int E : last)
+			if(!can_end_by(X, E))
+				++cnt;
+		return cnt;
+	}
+
+	bool can_end_by(const vector<int>& X, int E)
+	{
+		for(int B=E;;) {
+			if(run(B, X) == E)
+				return true;
+
+			if(B%2==0)
+				B/=2;
+			else
+				break;
+		}
+		return false;
+	}
+
+	int run(int B, const vector<int>& X)
+	{
+		for(int x: X)
+			B = (x==B ? B*2 : B);
+		return 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 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(_, AmebaDiv1().count(X));}
+int main(){
+
+CASE(0)
+	int X_[] = {3,2,1};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int _ = 2; 
+END
+CASE(1)
+	int X_[] = {2,2,2,2,2,2,4,2,2,2};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int _ = 2; 
+END
+CASE(2)
+	int X_[] = {1,2,4,8,16,32,64,128,256,1024,2048};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int _ = 11; 
+END
+CASE(3)
+	int X_[] = {854,250,934,1000,281,250,281,467,854,562,934,1000,854,500,562};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int _ = 7; 
+END
+/*
+CASE(4)
+	int X_[] = ;
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int _ = ; 
+END
+CASE(5)
+	int X_[] = ;
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/616-U/1B-U.cpp
Index: SRM/616-U/1B-U.cpp
==================================================================
--- SRM/616-U/1B-U.cpp
+++ SRM/616-U/1B-U.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 <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 LongLongTripDiv1 { public:
+	string isAble(int N, vector <int> A, vector <int> B, vector <int> D, long long T)
+	{
+		return solve(N, A, B, D, T) ? "Possible" : "Impossible";
+	}
+
+	bool solve(int N, const vector <int>& A, const vector <int>& B, const vector <int>& D, long long T)
+	{
+		vector<vector<pair<int,int>>> edges(N);
+		for(int i=0; i<A.size(); ++i) {
+			edges[A[i]].emplace_back(B[i], D[i]);
+			edges[B[i]].emplace_back(A[i], D[i]);
+		}
+
+
+		if(!solve_mod(99961, N, edges, T))
+			return false;
+		if(!solve_mod(99971, N, edges, T))
+			return false;
+		if(!solve_mod(99989, N, edges, T))
+			return false;
+		if(!solve_mod(99991, N, edges, T))
+			return false;
+		for(int mod=2; mod<=1000; ++mod)
+			if(!solve_mod(mod, N, edges, T))
+				return false;
+		return true;
+	}
+
+	bool solve_mod(int mod, int N, const vector<vector<pair<int,int>>>& E, long long T)
+	{
+		vector<bool> V(mod*N); V[0*mod+0] = true;
+		queue<int> Q; Q.push(0*mod+0);
+		while(!Q.empty())
+		{
+			int v = Q.front() / mod;
+			int m = Q.front() % mod;
+			Q.pop();
+			for(auto ud : E[v]) {
+				int u = ud.first;
+				int d = ud.second;
+				int m2 = (m+d)%mod;
+				if(!V[u*mod+m2]) {
+					V[u*mod+m2] = true;
+					Q.push(u*mod+m2);
+				}
+			}
+		}
+		return V[(N-1)*mod+int(T%mod)];
+	}
+};
+
+// 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(_, LongLongTripDiv1().isAble(N, A, B, D, T));}
+int main(){
+
+CASE(6)
+	int N = 50; 
+int A_[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {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,2};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int D_[] = {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> D(D_, D_+sizeof(D_)/sizeof(*D_)); 
+	long long T = 1000000000000000000LL; 
+	string _ = "Possible"; 
+END
+CASE(0)
+	int N = 3; 
+	int A_[] = {0,0,1};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {2,1,2};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int D_[] = {7,6,5};
+	  vector <int> D(D_, D_+sizeof(D_)/sizeof(*D_)); 
+	long long T = 11LL; 
+	string _ = "Possible"; 
+END
+CASE(1)
+	int N = 3; 
+	int A_[] = {0,0,1};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {2,1,2};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int D_[] = {7,6,5};
+	  vector <int> D(D_, D_+sizeof(D_)/sizeof(*D_)); 
+	long long T = 25LL; 
+	string _ = "Possible"; 
+END
+CASE(2)
+	int N = 2; 
+	int A_[] = {0};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {1};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int D_[] = {1};
+	  vector <int> D(D_, D_+sizeof(D_)/sizeof(*D_)); 
+	long long T = 9LL; 
+	string _ = "Possible"; 
+END
+CASE(3)
+	int N = 2; 
+	int A_[] = {1};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {0};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int D_[] = {1};
+	  vector <int> D(D_, D_+sizeof(D_)/sizeof(*D_)); 
+	long long T = 1000000000000000000LL; 
+	string _ = "Impossible"; 
+END
+CASE(4)
+	int N = 4; 
+	int A_[] = {0,0,1};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {2,1,2};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int D_[] = {10,10,10};
+	  vector <int> D(D_, D_+sizeof(D_)/sizeof(*D_)); 
+	long long T = 1000LL; 
+	string _ = "Impossible"; 
+END
+CASE(5)
+	int N = 9; 
+	int A_[] = {4,8,5,8,3,6,2,6,7,6,6};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {2,7,1,5,1,3,1,1,5,4,2};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int D_[] = {6580,8822,1968,673,1394,9337,5486,1746,5229,4092,195};
+	  vector <int> D(D_, D_+sizeof(D_)/sizeof(*D_)); 
+	long long T = 937186357646035002LL; 
+	string _ = "Impossible"; 
+END
+}
+// END CUT HERE

ADDED   SRM/616-U/1C.cpp
Index: SRM/616-U/1C.cpp
==================================================================
--- SRM/616-U/1C.cpp
+++ SRM/616-U/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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+static const unsigned MODVAL = 1000000007;
+struct mint
+{
+	unsigned val;
+	mint():val(0){}
+	mint(int      x):val(x%MODVAL) {}
+	mint(unsigned x):val(x%MODVAL) {}
+	mint(LL       x):val(x%MODVAL) {}
+};
+mint& operator+=(mint& x, mint y) { return x = x.val+y.val; }
+mint operator+(mint x, mint y) { return x+=y; }
+
+class AlternativePiles { public:
+	int count(string C, int M)
+	{
+		vector<mint> dp((M+1)*M);
+		dp[0] = 1;
+
+		for(char c : C)
+		{
+			vector<mint> dp2((M+1)*M);
+			for(int m=0; m<=M; ++m)
+			for(int r=0; r<M; ++r) {
+				int mr = m*M+r;
+				if((c=='R' || c=='W') && m+1<=M)
+					dp2[(m+1)*M+(r+1)%M] += dp[mr];
+				if((c=='G' || c=='W') && m-1>=0)
+					dp2[(m-1)*M+r] += dp[mr];
+				if(c=='B' || c=='W')
+					dp2[m*M+r] += dp[mr];
+			}
+			dp.swap(dp2);
+		}
+		return dp[0].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(_, AlternativePiles().count(C, M));}
+int main(){
+
+CASE(0)
+	string C = "WRGWWRGW"; 
+	int M = 2; 
+	int _ = 3; 
+END
+CASE(1)
+	string C = "RRGG"; 
+	int M = 1; 
+	int _ = 0; 
+END
+CASE(2)
+	string C = "BBBB"; 
+	int M = 5; 
+	int _ = 1; 
+END
+CASE(3)
+	string C = "WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW"; 
+	int M = 50; 
+	int _ = 265470435; 
+END
+CASE(4)
+	string C = "WRWRGWWGWWWRWBWRWGWWRWBWWRGWBWGRGWWGWGRWGRWBRWBW"; 
+	int M = 7; 
+	int _ = 7400348; 
+END
+/*
+CASE(6)
+	string C = ; 
+	int M = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE