ADDED   SRM/610-U/1A.cpp
Index: SRM/610-U/1A.cpp
==================================================================
--- SRM/610-U/1A.cpp
+++ SRM/610-U/1A.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 <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 TheMatrix { public:
+	int MaxArea(vector <string> board)
+	{
+		const int H = board.size(), W = board[0].size();
+		vector<vector<int>> yL(H, vector<int>(W));
+
+		for(int y=0; y<H; ++y)
+		for(int x=0; x<W; ++x)
+			for(yL[y][x]=1; y+yL[y][x]<H; ++yL[y][x])
+				if(board[y+yL[y][x]][x] == board[y+yL[y][x]-1][x])
+					break;
+
+		int best = 0;
+		for(int y=0; y<H; ++y)
+		for(int x=0; x<W; ++x)
+		{
+			int h = yL[y][x];
+			best = max(best, h*1);
+			for(int xd=1; x+xd<W; ++xd) if(board[y][x+xd] == board[y][x+xd-1]) break; else {
+				h = min(h, yL[y][x+xd]);
+				best = max(best, h*(xd+1));
+			}
+		}
+		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 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(_, TheMatrix().MaxArea(board));}
+int main(){
+CASE(0)
+	string board_[] = {"1", 
+ "0"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 2; 
+END
+CASE(1)
+	string board_[] = {"0000"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 1; 
+END
+CASE(2)
+	string board_[] = {"01"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 2; 
+END
+CASE(3)
+	string board_[] = {"001",
+ "000",
+ "100"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 2; 
+END
+CASE(4)
+	string board_[] = {"0"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 1; 
+END
+CASE(5)
+	string board_[] = {"101", 
+ "010"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 6; 
+END
+CASE(6)
+	string board_[] = {"101", 
+ "011", 
+ "101", 
+ "010"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 8; 
+END
+CASE(7)
+	string board_[] = {"11001110011000110001111001001110110011010110001011", 
+ "10100100010111111011111001011110101111010011100001", 
+ "11101111001110100110010101101100011100101000010001", 
+ "01000010001010101100010011111000100100110111111000", 
+ "10110100000101100000111000100001011101111101010010", 
+ "00111010000011100001110110010011010110010011100100", 
+ "01100001111101001101001101100001111000111001101010", 
+ "11010000000011011010100010000000111011001001100101", 
+ "10100000000100010100100011010100110110110001000001", 
+ "01101010101100001100000110100110100000010100100010", 
+ "11010000001110111111011010011110001101100011100010", 
+ "11101111000000011010011100100001100011111111110111", 
+ "11000001101100100011000110111010011001010100000001", 
+ "00100001111001010000101101100010000001100100001000", 
+ "01001110110111101011010000111111101011000110010111", 
+ "01001010000111111001100000100010101100100101010100", 
+ "11111101001101110011011011011000111001101100011011", 
+ "10000100110111000001110110010000000000111100101101", 
+ "01010011101101101110000011000110011111001111011100", 
+ "01101010011111010000011001111101011010011100001101", 
+ "11011000011000110010101111100000101011011111101100", 
+ "11100001001000110010100011001010101101001010001100", 
+ "11011011001100111101001100111100000101011101101011", 
+ "11110111100100101011100101111101000111001111110111", 
+ "00011001100110111100111100001100101001111100001111", 
+ "10001111100101110111001111100000000011110000100111", 
+ "10101010110110100110010001001010000111100110100011", 
+ "01100110100000001110101001101011001010001101110101", 
+ "10110101110100110110101001100111110000101111100110", 
+ "01011000001001101110100001101001110011001001110001", 
+ "00100101010001100110110101001010010100001011000011", 
+ "00011101100100001010100000000011000010100110011100", 
+ "11001001011000000101111111000000110010001101101110", 
+ "10101010110110010000010011001100110101110100111011", 
+ "01101001010111010001101000100011101001110101000110", 
+ "00110101101110110001110101110010100100110000101101", 
+ "11010101000111010011110011000001101111010011110011", 
+ "10010000010001110011011101001110110010001100011100", 
+ "00111101110001001100101001110100110010100110110000", 
+ "00010011011000101000100001101110111100100000010100", 
+ "01101110001101000001001000001011101010011101011110", 
+ "00000100110011001011101011110011011101100001110111", 
+ "00110011110000011001011100001110101010100110010110", 
+ "00111001010011011111010100000100100000101101110001", 
+ "10101101101110111110000011111011001011100011110001", 
+ "00101110010101111000001010110100001110111011100011", 
+ "01111110010100111010110001111000111101110100111011"};
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = 12; 
+END
+/*
+CASE(8)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = ; 
+END
+CASE(9)
+	string board_[] = ;
+	  vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/610-U/1B.cpp
Index: SRM/610-U/1B.cpp
==================================================================
--- SRM/610-U/1B.cpp
+++ SRM/610-U/1B.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 <tuple>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class AlbertoTheAviator { public:
+	int MaximumFlights(int F, vector <int> duration, vector <int> refuel)
+	{
+		const int N = duration.size();
+		vector<pair<int,int>> mp;
+		for(int i=0; i<N; ++i)
+			mp.emplace_back(duration[i], refuel[i]);
+
+		// Larger refuel first.
+		sort(mp.begin(), mp.end(), [&](const pair<int,int>& lhs, const pair<int,int>& rhs){
+			if(lhs.second != rhs.second)
+				return lhs.second > rhs.second;
+			return lhs.first < rhs.first;
+		});
+
+		const int BAD = -0x3fffffff;
+		vector<int> dp(F+1, BAD);
+		dp[F] = 0;
+		for(auto& mpi: mp) {
+			int minus = mpi.first;
+			int plus = mpi.second;
+
+			vector<int> dp2 = dp;
+			for(int f=minus; f<=F; ++f)
+				dp2[f-minus+plus] = max(dp2[f-minus+plus], dp[f]+1);
+			dp.swap(dp2);
+		}
+
+		return *max_element(dp.begin(), dp.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 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(_, AlbertoTheAviator().MaximumFlights(F, duration, refuel));}
+int main(){
+
+CASE(0)
+	int F = 10; 
+	int duration_[] = {10};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	int refuel_[] = {0};
+	  vector <int> refuel(refuel_, refuel_+sizeof(refuel_)/sizeof(*refuel_)); 
+	int _ = 1; 
+END
+CASE(1)
+	int F = 10; 
+	int duration_[] = {8, 4};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	int refuel_[] = {0, 2};
+	  vector <int> refuel(refuel_, refuel_+sizeof(refuel_)/sizeof(*refuel_)); 
+	int _ = 2; 
+END
+CASE(2)
+	int F = 12; 
+	int duration_[] = {4, 8, 2, 1};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	int refuel_[] = {2, 0, 0, 0};
+	  vector <int> refuel(refuel_, refuel_+sizeof(refuel_)/sizeof(*refuel_)); 
+	int _ = 3; 
+END
+CASE(3)
+	int F = 9; 
+	int duration_[] = {4, 6};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	int refuel_[] = {0, 1};
+	  vector <int> refuel(refuel_, refuel_+sizeof(refuel_)/sizeof(*refuel_)); 
+	int _ = 2; 
+END
+CASE(4)
+	int F = 100; 
+	int duration_[] = {101};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	int refuel_[] = {100};
+	  vector <int> refuel(refuel_, refuel_+sizeof(refuel_)/sizeof(*refuel_)); 
+	int _ = 0; 
+END
+CASE(5)
+	int F = 1947; 
+	int duration_[] = {2407, 2979, 1269, 2401, 3227, 2230, 3991, 2133, 3338, 356, 2535, 3859, 3267, 365};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	int refuel_[] = {2406, 793, 905, 2400, 1789, 2229, 1378, 2132, 1815, 355, 72, 3858, 3266, 364};
+	  vector <int> refuel(refuel_, refuel_+sizeof(refuel_)/sizeof(*refuel_)); 
+	int _ = 3; 
+END
+CASE(6)
+	int F = 5000; 
+	int duration_[] = {948,914,915,945,952,939,925,951,957,978,926,973,986,949,992,932,968,916,946,901,929,956,976,941,938,980,984,906,979,907,923,931,963,964,932,910,909,981,969,997,936,930,956,949,903,914,954,945,913,969};
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	int refuel_[] = {819,852,834,789,875,833,760,887,796,831,900,805,758,794,882,855,709,803,793,704,760,802,714,881,890,881,839,754,844,896,806,713,809,738,763,749,768,818,732,706,830,702,741,769,816,742,791,803,761,865};
+	  vector <int> refuel(refuel_, refuel_+sizeof(refuel_)/sizeof(*refuel_)); 
+	int _ = -1; 
+END
+/*
+CASE(7)
+	int F = ; 
+	int duration_[] = ;
+	  vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_)); 
+	int refuel_[] = ;
+	  vector <int> refuel(refuel_, refuel_+sizeof(refuel_)/sizeof(*refuel_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT1 HERE900

ADDED   SRM/610-U/1C-U.cpp
Index: SRM/610-U/1C-U.cpp
==================================================================
--- SRM/610-U/1C-U.cpp
+++ SRM/610-U/1C-U.cpp
@@ -0,0 +1,176 @@
+#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 MiningGoldHard { public:
+	int GetMaximumGold(int N, int M, vector <int> event_i, vector <int> event_j, vector <int> event_di, vector <int> event_dj)
+	{
+		return solve(N, event_i, event_di) + solve(M, event_j, event_dj);
+	}
+
+	int solve(int W, const vector<int>& e, const vector<int>& d)
+	{
+		vector<int> dp(W+1, 0);
+		for(int x=0; x<=W; ++x)
+			dp[x] = W - abs(x-e[0]);
+
+		for(int i=0; i<d.size(); ++i) {
+			vector<int> dp2(W+1, 0);
+			for(int x=0; x<=W; ++x)
+				dp2[x] = W - abs(x-e[i+1]);
+
+			deque<int> q;
+			int px = 0;
+			for(px=0; px<=d[i] && px<=W; ++px) {
+				while(!q.empty() && dp[q.back()] < dp[px])
+					q.pop_back();
+				q.push_back(px);
+			}
+
+			for(int x=0; x<=W; ++x) {
+				while(q.front() < x-d[i])
+					q.pop_front();
+
+				dp2[x] += dp[q.front()];
+
+				if(px<=W) {
+					while(!q.empty() && dp[q.back()] < dp[px])
+						q.pop_back();
+					q.push_back(px);
+
+					++px;
+				}
+			}
+
+			dp.swap(dp2);
+		}
+		return *max_element(dp.begin(), dp.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 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(_, MiningGoldHard().GetMaximumGold(N, M, event_i, event_j, event_di, event_dj));}
+int main(){
+
+CASE(0)
+	int N = 3; 
+	int M = 3; 
+	int event_i_[] = {1};
+	  vector <int> event_i(event_i_, event_i_+sizeof(event_i_)/sizeof(*event_i_)); 
+	int event_j_[] = {1};
+	  vector <int> event_j(event_j_, event_j_+sizeof(event_j_)/sizeof(*event_j_)); 
+	vector <int> event_di; 
+	vector <int> event_dj; 
+	int _ = 6; 
+END
+CASE(1)
+	int N = 3; 
+	int M = 3; 
+	int event_i_[] = {0, 2};
+	  vector <int> event_i(event_i_, event_i_+sizeof(event_i_)/sizeof(*event_i_)); 
+	int event_j_[] = {0, 2};
+	  vector <int> event_j(event_j_, event_j_+sizeof(event_j_)/sizeof(*event_j_)); 
+	int event_di_[] = {1};
+	  vector <int> event_di(event_di_, event_di_+sizeof(event_di_)/sizeof(*event_di_)); 
+	int event_dj_[] = {1};
+	  vector <int> event_dj(event_dj_, event_dj_+sizeof(event_dj_)/sizeof(*event_dj_)); 
+	int _ = 10; 
+END
+CASE(2)
+	int N = 4; 
+	int M = 2; 
+	int event_i_[] = {1, 4, 4};
+	  vector <int> event_i(event_i_, event_i_+sizeof(event_i_)/sizeof(*event_i_)); 
+	int event_j_[] = {1, 2, 0};
+	  vector <int> event_j(event_j_, event_j_+sizeof(event_j_)/sizeof(*event_j_)); 
+	int event_di_[] = {1, 1};
+	  vector <int> event_di(event_di_, event_di_+sizeof(event_di_)/sizeof(*event_di_)); 
+	int event_dj_[] = {1, 1};
+	  vector <int> event_dj(event_dj_, event_dj_+sizeof(event_dj_)/sizeof(*event_dj_)); 
+	int _ = 15; 
+END
+CASE(3)
+	int N = 6; 
+	int M = 6; 
+	int event_i_[] = {0, 2, 1, 5, 6, 4};
+	  vector <int> event_i(event_i_, event_i_+sizeof(event_i_)/sizeof(*event_i_)); 
+	int event_j_[] = {4, 3, 1, 6, 2, 0};
+	  vector <int> event_j(event_j_, event_j_+sizeof(event_j_)/sizeof(*event_j_)); 
+	int event_di_[] = {2, 3, 1, 5, 6};
+	  vector <int> event_di(event_di_, event_di_+sizeof(event_di_)/sizeof(*event_di_)); 
+	int event_dj_[] = {2, 4, 0, 5, 1};
+	  vector <int> event_dj(event_dj_, event_dj_+sizeof(event_dj_)/sizeof(*event_dj_)); 
+	int _ = 63; 
+END
+CASE(4)
+	int N = 72; 
+	int M = 90; 
+	int event_i_[] = {9, 9, 42, 64, 37, 4, 67, 65, 20, 18, 25, 45, 19, 57, 34, 29, 20, 43, 17, 46, 61, 1, 18, 53, 54, 23, 9, 69, 57, 44, 34, 50, 37, 4, 26, 1, 8, 4, 66};
+	  vector <int> event_i(event_i_, event_i_+sizeof(event_i_)/sizeof(*event_i_)); 
+	int event_j_[] = {37, 47, 48, 69, 56, 22, 40, 52, 43, 46, 64, 24, 48, 54, 54, 56, 32, 77, 50, 8, 7, 90, 55, 34, 40, 89, 57, 44, 21, 59, 89, 21, 69, 46, 0, 89, 31, 3, 50};
+	  vector <int> event_j(event_j_, event_j_+sizeof(event_j_)/sizeof(*event_j_)); 
+	int event_di_[] = {56, 5, 21, 5, 22, 5, 45, 4, 44, 20, 68, 63, 37, 14, 43, 31, 70, 28, 51, 38, 20, 59, 72, 66, 16, 20, 39, 72, 11, 71, 21, 51, 60, 42, 40, 10, 32, 70};
+	  vector <int> event_di(event_di_, event_di_+sizeof(event_di_)/sizeof(*event_di_)); 
+	int event_dj_[] = {77, 73, 42, 80, 43, 24, 81, 68, 40, 86, 1, 76, 43, 10, 43, 53, 40, 26, 18, 70, 60, 68, 29, 17, 66, 2, 87, 71, 90, 33, 11, 76, 69, 17, 65, 21, 4, 19};
+	  vector <int> event_dj(event_dj_, event_dj_+sizeof(event_dj_)/sizeof(*event_dj_)); 
+	int _ = 5810; 
+END
+CASE(5)
+	int N = 1000000; 
+	int M = 1000000; 
+	int event_i_[] = {9, 9, 42, 64, 37, 4, 67, 65, 20, 18, 25, 45, 19, 57, 34, 29, 20, 43, 17, 46, 61, 1, 18, 53, 54, 23, 9, 69, 57, 44, 34, 50, 37, 4, 26, 1, 8, 4, 66};
+	  vector <int> event_i(event_i_, event_i_+sizeof(event_i_)/sizeof(*event_i_)); 
+	int event_j_[] = {37, 47, 48, 69, 56, 22, 40, 52, 43, 46, 64, 24, 48, 54, 54, 56, 32, 77, 50, 8, 7, 90, 55, 34, 40, 89, 57, 44, 21, 59, 89, 21, 69, 46, 0, 89, 31, 3, 50};
+	  vector <int> event_j(event_j_, event_j_+sizeof(event_j_)/sizeof(*event_j_)); 
+	int event_di_[] = {56, 5, 21, 5, 22, 5, 45, 4, 44, 20, 68, 63, 37, 14, 43, 31, 70, 28, 51, 38, 20, 59, 72, 66, 16, 20, 39, 72, 11, 71, 21, 51, 60, 42, 40, 10, 32, 70};
+	  vector <int> event_di(event_di_, event_di_+sizeof(event_di_)/sizeof(*event_di_)); 
+	int event_dj_[] = {77, 73, 42, 80, 43, 24, 81, 68, 40, 86, 1, 76, 43, 10, 43, 53, 40, 26, 18, 70, 60, 68, 29, 17, 66, 2, 87, 71, 90, 33, 11, 76, 69, 17, 65, 21, 4, 19};
+	  vector <int> event_dj(event_dj_, event_dj_+sizeof(event_dj_)/sizeof(*event_dj_)); 
+	int _ = -1; 
+END
+/*
+CASE(6)
+	int N = 1000000; 
+	int M = 1000000; 
+	int event_i_[] = ;
+	  vector <int> event_i(event_i_, event_i_+sizeof(event_i_)/sizeof(*event_i_)); 
+	int event_j_[] = ;
+	  vector <int> event_j(event_j_, event_j_+sizeof(event_j_)/sizeof(*event_j_)); 
+	int event_di_[] = ;
+	  vector <int> event_di(event_di_, event_di_+sizeof(event_di_)/sizeof(*event_di_)); 
+	int event_dj_[] = ;
+	  vector <int> event_dj(event_dj_, event_dj_+sizeof(event_dj_)/sizeof(*event_dj_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE