ADDED   SRM/TCO13-3C-U/1A.cpp
Index: SRM/TCO13-3C-U/1A.cpp
==================================================================
--- SRM/TCO13-3C-U/1A.cpp
+++ SRM/TCO13-3C-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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class SubstringReversal { public:
+	vector <int> solve(string S)
+	{
+		multiset<char> chars;
+		for(char c: S) chars.insert(c);
+
+		string T = S;
+		for(int i=0; i<S.size(); ++i) {
+			if(S[i] == *chars.begin()) {
+				chars.erase(chars.begin());
+				continue;
+			}
+
+			// here is the point.
+			int best_k = i;
+			string best = S.substr(i);
+			for(int k=i+1; k<S.size(); ++k) {
+				string T(S.begin()+i, S.begin()+k+1);
+				reverse(T.begin(), T.end());
+				T += S.substr(k+1);
+				if(best > T)
+					best=T, best_k=k;
+			}
+			vector<int> ans;
+			ans.push_back(i);
+			ans.push_back(best_k);
+			return ans;
+		}
+
+		// no need to reverse
+		vector<int> ans;
+		ans.push_back(0);
+		ans.push_back(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 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(_, SubstringReversal().solve(S));}
+int main(){
+
+CASE(0)
+	string S = "abdc"; 
+	int __[] = {2, 3 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	string S = "aabbcc"; 
+	int __[] = {0, 0 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	string S = "misof"; 
+	int __[] = {0, 4 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	string S = "ivan"; 
+	int __[] = {0, 2 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	string S = "thisseemstobeaneasyproblem"; 
+	int __[] = {0, 13 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(5)
+	string S = ; 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+	string S = ; 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/TCO13-3C-U/1B.cpp
Index: SRM/TCO13-3C-U/1B.cpp
==================================================================
--- SRM/TCO13-3C-U/1B.cpp
+++ SRM/TCO13-3C-U/1B.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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CliqueGraph { public:
+	long long calcSum(int N, vector <int> V, vector <int> sizes)
+	{
+		vector<vector<int>> v2c(N);
+		vector<vector<int>> c2v(sizes.size());
+		for(int s=0,i=0; i<sizes.size(); ++i) {
+			int e = s+sizes[i];
+			for(int k=s; k<e; ++k) {
+				v2c[V[k]].push_back(i);
+				c2v[i].push_back(V[k]);
+			}
+			s = e;
+		}
+
+		LL total = 0;
+		for(int v=0; v<N; ++v)
+			total += calc(v, v2c, c2v);
+		return total / 2;
+	}
+
+	LL calc(int S, const vector<vector<int>>& v2c, const vector<vector<int>>& c2v)
+	{
+		const int V = v2c.size(), C = c2v.size();
+		vector<int>  v_d(V, -1);
+		vector<bool> c_visited(C, false);
+		vector<int> q(1, S);
+		v_d[S] = 0;
+		for(int step=1; !q.empty(); step++) {
+			vector<int> cq;
+			for(int v: q)
+				for(int c: v2c[v]) if(!c_visited[c])
+					cq.push_back(c), c_visited[c]=true;
+			vector<int> q2;
+			for(int c: cq)
+				for(int v: c2v[c]) if(v_d[v]<0)
+					q2.push_back(v), v_d[v]=step;
+			q = std::move(q2);
+		}
+
+		LL total = 0;
+		for(int d: v_d)
+			total += d;
+		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(_, CliqueGraph().calcSum(N, V, sizes));}
+int main(){
+
+CASE(0)
+	int N = 4; 
+	int V_[] = {0,1,2,0,3};
+	  vector <int> V(V_, V_+sizeof(V_)/sizeof(*V_)); 
+	int sizes_[] = {3,2};
+	  vector <int> sizes(sizes_, sizes_+sizeof(sizes_)/sizeof(*sizes_)); 
+	long long _ = 8LL; 
+END
+CASE(1)
+	int N = 5; 
+	int V_[] = {0,1,2,3,1,2,4};
+	  vector <int> V(V_, V_+sizeof(V_)/sizeof(*V_)); 
+	int sizes_[] = {4,3};
+	  vector <int> sizes(sizes_, sizes_+sizeof(sizes_)/sizeof(*sizes_)); 
+	long long _ = 12LL; 
+END
+CASE(2)
+	int N = 15; 
+	int V_[] = {1,3,5,7,9,11,13,0
+,2,3,6,7,10,11,14,0
+,4,5,6,7,12,13,14,0
+,8,9,10,11,12,13,14,0};
+	  vector <int> V(V_, V_+sizeof(V_)/sizeof(*V_)); 
+	int sizes_[] = {8,8,8,8};
+	  vector <int> sizes(sizes_, sizes_+sizeof(sizes_)/sizeof(*sizes_)); 
+	long long _ = 130LL; 
+END
+/*
+CASE(3)
+	int N = ; 
+	int V_[] = ;
+	  vector <int> V(V_, V_+sizeof(V_)/sizeof(*V_)); 
+	int sizes_[] = ;
+	  vector <int> sizes(sizes_, sizes_+sizeof(sizes_)/sizeof(*sizes_)); 
+	long long _ = LL; 
+END
+CASE(4)
+	int N = ; 
+	int V_[] = ;
+	  vector <int> V(V_, V_+sizeof(V_)/sizeof(*V_)); 
+	int sizes_[] = ;
+	  vector <int> sizes(sizes_, sizes_+sizeof(sizes_)/sizeof(*sizes_)); 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/TCO13-3C-U/1C-U.cpp
Index: SRM/TCO13-3C-U/1C-U.cpp
==================================================================
--- SRM/TCO13-3C-U/1C-U.cpp
+++ SRM/TCO13-3C-U/1C-U.cpp
@@ -0,0 +1,195 @@
+#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 InverseRMQ { public:
+	string possible(int n, vector <int> A, vector <int> B, vector <int> ans)
+	{
+		vector<tuple<int,int,int>> E;
+		for(int i=0; i<A.size(); ++i)
+			E.emplace_back(A[i], B[i], ans[i]);
+		sort(E.begin(), E.end(), [&](const tuple<int,int,int>& lhs, const tuple<int,int,int>& rhs){
+			if(get<2>(lhs) < get<2>(rhs))
+				return true;
+			return lhs < rhs;
+		});
+
+		vector<pair<int,int>> filled;
+		for(int i=0; i<E.size(); )
+		{
+			int nexti = i+1;
+			for(; nexti<E.size(); ++nexti)
+				if(get<2>(E[i]) != get<2>(E[nexti]))
+					break;
+			// inner
+			int L = get<0>(E[i]);
+			int R = get<1>(E[i]);
+			// outer
+			int l = get<0>(E[i]);
+			int r = get<1>(E[i]);
+			for(int a=i+1; a<nexti; ++a) {
+				if(R<get<0>(E[a]) || get<1>(E[a])<L)
+					return "Impossible";
+				L = max(L, get<0>(E[a]));
+				R = min(R, get<1>(E[a]));
+				l = min(l, get<0>(E[a]));
+				r = max(r, get<1>(E[a]));
+			}
+
+			bool ok = false;
+			if(filled.empty()) ok = true;
+			if(!ok && has_intersection(L,R,0,filled.front().first-1)) ok = true;
+			if(!ok && has_intersection(L,R,filled.back().second+1,n)) ok = true;
+			if(!ok) {
+				for(int i=0; i+1<filled.size(); ++i)
+					if(!ok && has_intersection(L,R,filled[i].second+1,filled[i+1].first-1))
+						ok=true;
+			}
+			if(!ok)
+				return "Impossible";
+
+			int C = get<2>(E[i]);
+
+			// check: enough number of elements for [l,r]
+			int space = 0;
+
+
+			// update
+			filled.emplace_back(l, r);
+			sort(filled.begin(), filled.end());
+			vector<pair<int,int>> f2;
+			filled = f2;
+			for(auto r: filled) {
+				if(f2.empty() || f2.back().second+1 < r.first)
+					f2.push_back(r);
+				else
+					f2.back().second = max(f2.back().second, r.second);
+			}
+
+			i = nexti;
+		}
+		return "Possible";
+	}
+
+	static bool has_intersection(int a, int b, int A, int B)
+	{
+		return !(B<a || b<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> 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(_, InverseRMQ().possible(n, A, B, ans));}
+int main(){
+
+CASE(0)
+	int n = 5; 
+	int A_[] = {1,2,4};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {2,4,5};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int ans_[] = {3,4,5};
+	  vector <int> ans(ans_, ans_+sizeof(ans_)/sizeof(*ans_)); 
+	string _ = "Possible"; 
+END
+CASE(1)
+	int n = 3; 
+	int A_[] = {1,2,3};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {1,2,3};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int ans_[] = {3,3,3};
+	  vector <int> ans(ans_, ans_+sizeof(ans_)/sizeof(*ans_)); 
+	string _ = "Impossible"; 
+END
+CASE(2)
+	int n = 600; 
+	int A_[] = {1,101,201,301,401,501};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {100,200,300,400,500,600};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int ans_[] = {100,200,300,400,500,600};
+	  vector <int> ans(ans_, ans_+sizeof(ans_)/sizeof(*ans_)); 
+	string _ = "Possible"; 
+END
+CASE(3)
+	int n = 1000000000; 
+	int A_[] = {1234,1234};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {5678,5678};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int ans_[] = {10000,20000};
+	  vector <int> ans(ans_, ans_+sizeof(ans_)/sizeof(*ans_)); 
+	string _ = "Impossible"; 
+END
+CASE(4)
+	int n = 8; 
+	int A_[] = {1,2,3,4,5,6,7,8};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {1,2,3,4,5,6,7,8};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int ans_[] = {4,8,2,5,6,3,7,1};
+	  vector <int> ans(ans_, ans_+sizeof(ans_)/sizeof(*ans_)); 
+	string _ = "Possible"; 
+END
+CASE(5)
+	int n = 1000000000; 
+	int A_[] = {1};
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = {1000000000};
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int ans_[] = {19911120};
+	  vector <int> ans(ans_, ans_+sizeof(ans_)/sizeof(*ans_)); 
+	string _ = "Impossible"; 
+END
+CASE(6)
+	int n = ; 
+	int A_[] = ;
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = ;
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int ans_[] = ;
+	  vector <int> ans(ans_, ans_+sizeof(ans_)/sizeof(*ans_)); 
+	string _ = ; 
+END
+CASE(7)
+	int n = ; 
+	int A_[] = ;
+	  vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 
+	int B_[] = ;
+	  vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 
+	int ans_[] = ;
+	  vector <int> ans(ans_, ans_+sizeof(ans_)/sizeof(*ans_)); 
+	string _ = ; 
+END
+
+}
+// END CUT HERE