Overview
| SHA1 Hash: | 6b700c1e679ad11267c2c421d706baf50444994f |
|---|---|
| Date: | 2013-06-04 01:07:10 |
| User: | kinaba |
| Comment: | 580 |
| Timelines: | family | ancestors | descendants | both | trunk |
| Downloads: | Tarball | ZIP archive |
| Other Links: | files | file ages | manifest |
Tags And Properties
- branch=trunk inherited from [9165bd3629]
- sym-trunk inherited from [9165bd3629]
Changes
Added SRM/580-U/1A.cpp version [e6d30ceb98389bc1]
1 +#include <iostream> 2 +#include <sstream> 3 +#include <iomanip> 4 +#include <vector> 5 +#include <string> 6 +#include <map> 7 +#include <set> 8 +#include <algorithm> 9 +#include <numeric> 10 +#include <iterator> 11 +#include <functional> 12 +#include <complex> 13 +#include <queue> 14 +#include <stack> 15 +#include <cmath> 16 +#include <cassert> 17 +using namespace std; 18 +typedef long long LL; 19 +typedef long double LD; 20 +typedef complex<double> CMP; 21 + 22 +class EelAndRabbit { public: 23 + int getmax(vector <int> l, vector <int> t) 24 + { 25 + const int N = l.size(); 26 + 27 + vector<int> ps; 28 + for(int i=0; i<N; ++i) { 29 + ps.push_back(t[i]); 30 + ps.push_back(t[i]+l[i]); 31 + } 32 + 33 + int best = 0; 34 + for(int i=0; i<ps.size(); ++i) 35 + for(int k=0; k<ps.size(); ++k) { 36 + int p = ps[i], q = ps[k]; 37 + int cat = 0; 38 + for(int x=0; x<N; ++x) 39 + { 40 + if(t[x]<=p && p<=t[x]+l[x] 41 + || t[x]<=q && q<=t[x]+l[x]) 42 + ++cat; 43 + } 44 + best = max(best, cat); 45 + } 46 + return best; 47 + } 48 +}; 49 + 50 +// BEGIN CUT HERE 51 +#include <ctime> 52 +double start_time; string timer() 53 + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); } 54 +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) 55 + { os << "{ "; 56 + for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) 57 + os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; } 58 +void verify_case(const int& Expected, const int& Received) { 59 + bool ok = (Expected == Received); 60 + if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; 61 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 62 +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock(); 63 +#define END verify_case(_, EelAndRabbit().getmax(l, t));} 64 +int main(){ 65 + 66 +CASE(0) 67 + int l_[] = {2, 4, 3, 2, 2, 1, 10}; 68 + vector <int> l(l_, l_+sizeof(l_)/sizeof(*l_)); 69 + int t_[] = {2, 6, 3, 7, 0, 2, 0}; 70 + vector <int> t(t_, t_+sizeof(t_)/sizeof(*t_)); 71 + int _ = 6; 72 +END 73 +CASE(1) 74 + int l_[] = {1, 1, 1}; 75 + vector <int> l(l_, l_+sizeof(l_)/sizeof(*l_)); 76 + int t_[] = {2, 0, 4}; 77 + vector <int> t(t_, t_+sizeof(t_)/sizeof(*t_)); 78 + int _ = 2; 79 +END 80 +CASE(2) 81 + int l_[] = {1}; 82 + vector <int> l(l_, l_+sizeof(l_)/sizeof(*l_)); 83 + int t_[] = {1}; 84 + vector <int> t(t_, t_+sizeof(t_)/sizeof(*t_)); 85 + int _ = 1; 86 +END 87 +CASE(3) 88 + int l_[] = {8, 2, 1, 10, 8, 6, 3, 1, 2, 5}; 89 + vector <int> l(l_, l_+sizeof(l_)/sizeof(*l_)); 90 + int t_[] = {17, 27, 26, 11, 1, 27, 23, 12, 11, 13}; 91 + vector <int> t(t_, t_+sizeof(t_)/sizeof(*t_)); 92 + int _ = 7; 93 +END 94 +/* 95 +CASE(4) 96 + int l_[] = ; 97 + vector <int> l(l_, l_+sizeof(l_)/sizeof(*l_)); 98 + int t_[] = ; 99 + vector <int> t(t_, t_+sizeof(t_)/sizeof(*t_)); 100 + int _ = ; 101 +END 102 +CASE(5) 103 + int l_[] = ; 104 + vector <int> l(l_, l_+sizeof(l_)/sizeof(*l_)); 105 + int t_[] = ; 106 + vector <int> t(t_, t_+sizeof(t_)/sizeof(*t_)); 107 + int _ = ; 108 +END 109 +*/ 110 +} 111 +// END CUT HERE
Added SRM/580-U/1B.cpp version [ffad7ee1c1aa0fe1]
1 +#include <iostream> 2 +#include <sstream> 3 +#include <iomanip> 4 +#include <vector> 5 +#include <string> 6 +#include <map> 7 +#include <set> 8 +#include <algorithm> 9 +#include <numeric> 10 +#include <iterator> 11 +#include <functional> 12 +#include <complex> 13 +#include <queue> 14 +#include <stack> 15 +#include <cmath> 16 +#include <cassert> 17 +using namespace std; 18 +typedef long long LL; 19 +typedef long double LD; 20 +typedef complex<double> CMP; 21 + 22 +class ShoutterDiv1 { public: 23 + int count(vector <string> s1000, vector <string> s100, vector <string> s10, vector <string> s1, vector <string> t1000, vector <string> t100, vector <string> t10, vector <string> t1) 24 + { 25 + vector<int> s; 26 + { 27 + string S1000 = accumulate(s1000.begin(), s1000.end(), string()); 28 + string S100 = accumulate(s100.begin() , s100.end() , string()); 29 + string S10 = accumulate(s10.begin() , s10.end() , string()); 30 + string S1 = accumulate(s1.begin() , s1.end() , string()); 31 + for(int i=0; i<S1.size(); ++i) 32 + s.push_back(atoi((string(1, S1000[i])+S100[i]+S10[i]+S1[i]).c_str())); 33 + } 34 + vector<int> t; 35 + { 36 + string T1000 = accumulate(t1000.begin(), t1000.end(), string()); 37 + string T100 = accumulate(t100.begin(), t100.end(), string()); 38 + string T10 = accumulate(t10.begin(), t10.end(), string()); 39 + string T1 = accumulate(t1.begin(), t1.end(), string()); 40 + for(int i=0; i<T1.size(); ++i) 41 + t.push_back(atoi((string(1, T1000[i])+T100[i]+T10[i]+T1[i]).c_str())); 42 + } 43 + vector<pair<int,int> > st; 44 + for(int i=0; i<s.size(); ++i) 45 + st.push_back(make_pair(s[i], t[i])); 46 + sort(st.begin(), st.end()); 47 + return solve(st); 48 + } 49 + 50 + int solve(const vector<pair<int,int> >& st) 51 + { 52 + const int N = st.size(); 53 + 54 + int L = 99999; // the time first rabbit leaves. 55 + int R = 0; // the time last rabbit comes. 56 + for(int i=0; i<N; ++i) { 57 + int l = st[i].first; 58 + int r = st[i].second; 59 + L = min(L, r); 60 + R = max(R, l); 61 + } 62 + 63 + // fill [L,R] with minimum number of intervals. 64 + // must include st[i] for each i. 65 + 66 + int total = 0; 67 + for(int i=0; i<N; ++i) { 68 + int c = cost(st, N, i, L, R); 69 + if(c==-1) 70 + return -1; 71 + total += c - 1; 72 + } 73 + return total; 74 + } 75 + 76 + int cost(const vector<pair<int,int> >& st, int N, int I, int L, int R) 77 + { 78 + bool I_used = false; 79 + int covered = L; 80 + int used = 0; 81 + for(int ks=0; ks<N; ) 82 + { 83 + int ke=ks; 84 + while(ke<N && st[ke].first<=covered) 85 + ++ke; 86 + if(ke==ks) 87 + break; 88 + 89 + if(ks<=I && I<ke && !I_used) 90 + { 91 + ++used; 92 + I_used = true; 93 + covered = max(covered, st[I].second); 94 + } 95 + else 96 + { 97 + if(covered < R) { 98 + int bestRight = 0; 99 + for(int i=ks; i<ke; ++i) if(i!=I) 100 + bestRight = max(bestRight, st[i].second); 101 + if(covered < bestRight) { 102 + ++used; 103 + covered = max(covered, bestRight); 104 + } 105 + } 106 + ks = ke; 107 + } 108 + } 109 + return (R<=covered ? used : -1); 110 + } 111 +}; 112 + 113 +// BEGIN CUT HERE 114 +#include <ctime> 115 +double start_time; string timer() 116 + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); } 117 +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) 118 + { os << "{ "; 119 + for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) 120 + os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; } 121 +void verify_case(const int& Expected, const int& Received) { 122 + bool ok = (Expected == Received); 123 + if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; 124 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 125 +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock(); 126 +#define END verify_case(_, ShoutterDiv1().count(s1000, s100, s10, s1, t1000, t100, t10, t1));} 127 +int main(){ 128 + 129 +CASE(0) 130 + string s1000_[] = {"22", "2"}; 131 + vector <string> s1000(s1000_, s1000_+sizeof(s1000_)/sizeof(*s1000_)); 132 + string s100_[] = {"00", "0"}; 133 + vector <string> s100(s100_, s100_+sizeof(s100_)/sizeof(*s100_)); 134 + string s10_[] = {"11", "1"}; 135 + vector <string> s10(s10_, s10_+sizeof(s10_)/sizeof(*s10_)); 136 + string s1_[] = {"21", "4"}; 137 + vector <string> s1(s1_, s1_+sizeof(s1_)/sizeof(*s1_)); 138 + string t1000_[] = {"22", "2"}; 139 + vector <string> t1000(t1000_, t1000_+sizeof(t1000_)/sizeof(*t1000_)); 140 + string t100_[] = {"00", "0"}; 141 + vector <string> t100(t100_, t100_+sizeof(t100_)/sizeof(*t100_)); 142 + string t10_[] = {"11", "1"}; 143 + vector <string> t10(t10_, t10_+sizeof(t10_)/sizeof(*t10_)); 144 + string t1_[] = {"43", "6"}; 145 + vector <string> t1(t1_, t1_+sizeof(t1_)/sizeof(*t1_)); 146 + int _ = 2; 147 +END 148 +CASE(1) 149 + string s1000_[] = {"00"}; 150 + vector <string> s1000(s1000_, s1000_+sizeof(s1000_)/sizeof(*s1000_)); 151 + string s100_[] = {"00"}; 152 + vector <string> s100(s100_, s100_+sizeof(s100_)/sizeof(*s100_)); 153 + string s10_[] = {"00"}; 154 + vector <string> s10(s10_, s10_+sizeof(s10_)/sizeof(*s10_)); 155 + string s1_[] = {"13"}; 156 + vector <string> s1(s1_, s1_+sizeof(s1_)/sizeof(*s1_)); 157 + string t1000_[] = {"00"}; 158 + vector <string> t1000(t1000_, t1000_+sizeof(t1000_)/sizeof(*t1000_)); 159 + string t100_[] = {"00"}; 160 + vector <string> t100(t100_, t100_+sizeof(t100_)/sizeof(*t100_)); 161 + string t10_[] = {"00"}; 162 + vector <string> t10(t10_, t10_+sizeof(t10_)/sizeof(*t10_)); 163 + string t1_[] = {"24"}; 164 + vector <string> t1(t1_, t1_+sizeof(t1_)/sizeof(*t1_)); 165 + int _ = -1; 166 +END 167 +CASE(2) 168 + string s1000_[] = {"0000"}; 169 + vector <string> s1000(s1000_, s1000_+sizeof(s1000_)/sizeof(*s1000_)); 170 + string s100_[] = {"0000"}; 171 + vector <string> s100(s100_, s100_+sizeof(s100_)/sizeof(*s100_)); 172 + string s10_[] = {"0000"}; 173 + vector <string> s10(s10_, s10_+sizeof(s10_)/sizeof(*s10_)); 174 + string s1_[] = {"1234"}; 175 + vector <string> s1(s1_, s1_+sizeof(s1_)/sizeof(*s1_)); 176 + string t1000_[] = {"0000"}; 177 + vector <string> t1000(t1000_, t1000_+sizeof(t1000_)/sizeof(*t1000_)); 178 + string t100_[] = {"0000"}; 179 + vector <string> t100(t100_, t100_+sizeof(t100_)/sizeof(*t100_)); 180 + string t10_[] = {"0000"}; 181 + vector <string> t10(t10_, t10_+sizeof(t10_)/sizeof(*t10_)); 182 + string t1_[] = {"2345"}; 183 + vector <string> t1(t1_, t1_+sizeof(t1_)/sizeof(*t1_)); 184 + int _ = 6; 185 +END 186 +CASE(3) 187 + string s1000_[] = {"0000000000"}; 188 + vector <string> s1000(s1000_, s1000_+sizeof(s1000_)/sizeof(*s1000_)); 189 + string s100_[] = {"0000000000"}; 190 + vector <string> s100(s100_, s100_+sizeof(s100_)/sizeof(*s100_)); 191 + string s10_[] = {"0000000000"}; 192 + vector <string> s10(s10_, s10_+sizeof(s10_)/sizeof(*s10_)); 193 + string s1_[] = {"7626463146"}; 194 + vector <string> s1(s1_, s1_+sizeof(s1_)/sizeof(*s1_)); 195 + string t1000_[] = {"0000000000"}; 196 + vector <string> t1000(t1000_, t1000_+sizeof(t1000_)/sizeof(*t1000_)); 197 + string t100_[] = {"0000000000"}; 198 + vector <string> t100(t100_, t100_+sizeof(t100_)/sizeof(*t100_)); 199 + string t10_[] = {"0000000000"}; 200 + vector <string> t10(t10_, t10_+sizeof(t10_)/sizeof(*t10_)); 201 + string t1_[] = {"9927686479"}; 202 + vector <string> t1(t1_, t1_+sizeof(t1_)/sizeof(*t1_)); 203 + int _ = 18; 204 +END 205 +CASE(4) 206 + string s1000_[] = {"00000000000000000000000000000000000000000000000000"}; 207 + vector <string> s1000(s1000_, s1000_+sizeof(s1000_)/sizeof(*s1000_)); 208 + string s100_[] = {"00000000000000000000000000000000000000000000000000"}; 209 + vector <string> s100(s100_, s100_+sizeof(s100_)/sizeof(*s100_)); 210 + string s10_[] = {"50353624751857130208544645495168271486083954769538"}; 211 + vector <string> s10(s10_, s10_+sizeof(s10_)/sizeof(*s10_)); 212 + string s1_[] = {"85748487990028258641117783760944852941545064635928"}; 213 + vector <string> s1(s1_, s1_+sizeof(s1_)/sizeof(*s1_)); 214 + string t1000_[] = {"00000000000000000000000000000000000000000000000000"}; 215 + vector <string> t1000(t1000_, t1000_+sizeof(t1000_)/sizeof(*t1000_)); 216 + string t100_[] = {"00000000000000000000000000000000000000000000000000"}; 217 + vector <string> t100(t100_, t100_+sizeof(t100_)/sizeof(*t100_)); 218 + string t10_[] = {"61465744851859252308555855596388482696094965779649"}; 219 + vector <string> t10(t10_, t10_+sizeof(t10_)/sizeof(*t10_)); 220 + string t1_[] = {"37620749792666153778227385275518278477865684777411"}; 221 + vector <string> t1(t1_, t1_+sizeof(t1_)/sizeof(*t1_)); 222 + int _ = 333; 223 +END 224 +/* 225 +CASE(5) 226 + string s1000_[] = ; 227 + vector <string> s1000(s1000_, s1000_+sizeof(s1000_)/sizeof(*s1000_)); 228 + string s100_[] = ; 229 + vector <string> s100(s100_, s100_+sizeof(s100_)/sizeof(*s100_)); 230 + string s10_[] = ; 231 + vector <string> s10(s10_, s10_+sizeof(s10_)/sizeof(*s10_)); 232 + string s1_[] = ; 233 + vector <string> s1(s1_, s1_+sizeof(s1_)/sizeof(*s1_)); 234 + string t1000_[] = ; 235 + vector <string> t1000(t1000_, t1000_+sizeof(t1000_)/sizeof(*t1000_)); 236 + string t100_[] = ; 237 + vector <string> t100(t100_, t100_+sizeof(t100_)/sizeof(*t100_)); 238 + string t10_[] = ; 239 + vector <string> t10(t10_, t10_+sizeof(t10_)/sizeof(*t10_)); 240 + string t1_[] = ; 241 + vector <string> t1(t1_, t1_+sizeof(t1_)/sizeof(*t1_)); 242 + int _ = ; 243 +END 244 +CASE(6) 245 + string s1000_[] = ; 246 + vector <string> s1000(s1000_, s1000_+sizeof(s1000_)/sizeof(*s1000_)); 247 + string s100_[] = ; 248 + vector <string> s100(s100_, s100_+sizeof(s100_)/sizeof(*s100_)); 249 + string s10_[] = ; 250 + vector <string> s10(s10_, s10_+sizeof(s10_)/sizeof(*s10_)); 251 + string s1_[] = ; 252 + vector <string> s1(s1_, s1_+sizeof(s1_)/sizeof(*s1_)); 253 + string t1000_[] = ; 254 + vector <string> t1000(t1000_, t1000_+sizeof(t1000_)/sizeof(*t1000_)); 255 + string t100_[] = ; 256 + vector <string> t100(t100_, t100_+sizeof(t100_)/sizeof(*t100_)); 257 + string t10_[] = ; 258 + vector <string> t10(t10_, t10_+sizeof(t10_)/sizeof(*t10_)); 259 + string t1_[] = ; 260 + vector <string> t1(t1_, t1_+sizeof(t1_)/sizeof(*t1_)); 261 + int _ = ; 262 +END 263 +*/ 264 +} 265 +// END CUT HERE
Added SRM/580-U/1C-U.cpp version [1a7c1f0c0f50f317]
1 +#include <iostream> 2 +#include <sstream> 3 +#include <iomanip> 4 +#include <vector> 5 +#include <string> 6 +#include <map> 7 +#include <set> 8 +#include <algorithm> 9 +#include <numeric> 10 +#include <iterator> 11 +#include <functional> 12 +#include <complex> 13 +#include <queue> 14 +#include <stack> 15 +#include <cmath> 16 +#include <cassert> 17 +using namespace std; 18 +typedef long long LL; 19 +typedef long double LD; 20 +typedef complex<double> CMP; 21 + 22 +class WallGameDiv1 { public: 23 + int play(vector <string> costs) 24 + { 25 + int H = costs.size(); 26 + int W = costs[0].size(); 27 + vector<vector<int> > C(H, vector<int>(W)); 28 + for(int y=0; y<H; ++y) 29 + for(int x=0; x<W; ++x) 30 + C[y][x] = costs[y][x] = '0'; 31 + 32 + vector<vector<int> > dp(H, vector<int>(W)); 33 + for(int x=0; x<W; ++x) 34 + dp[H-1][x] = C[H-1][x]; 35 + 36 + // dp[y][x] = what is the score of entering C[y] from [x]?? 37 + for(int y=H-2; y>=0; --y) 38 + for(int x=0; x<W; ++x) 39 + { 40 + int le = lefty(C[y], dp[y+1], x); 41 + vector<int> CC = C[y], DD = dp[y+1]; 42 + reverse(CC.begin(), CC.end()); 43 + reverse(DD.begin(), DD.end()); 44 + int ri = lefty(CC, DD, W-1-x); 45 + 46 + if(min(le, ri) < dp[y+1][x]) 47 + dp[y][x] = C[y][x] + dp[y+1][x]; 48 + else 49 + dp[y][x] = C[y][x] + min(le, ri); 50 + // no blocking score 51 + vector<int> s = dp[y+1]; 52 + s[x] += C[y][x]; 53 + for(int p=C[y][x], xx=x-1; xx>=0; --xx) 54 + s[xx] += (p += C[y][xx]); 55 + for(int p=C[y][x], xx=x+1; xx<W; ++xx) 56 + s[xx] += (p += C[y][xx]); 57 + } 58 + return *min_element(dp[0].begin(), dp[0].end()); 59 + } 60 + 61 + int lefty(const vector<int>& cur, const vector<int>& down, const int S) 62 + { 63 + // best score when moved to left from S first; 64 + return -1; 65 + } 66 +}; 67 + 68 +// BEGIN CUT HERE 69 +#include <ctime> 70 +double start_time; string timer() 71 + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); } 72 +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) 73 + { os << "{ "; 74 + for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) 75 + os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; } 76 +void verify_case(const int& Expected, const int& Received) { 77 + bool ok = (Expected == Received); 78 + if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; 79 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 80 +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock(); 81 +#define END verify_case(_, WallGameDiv1().play(costs));} 82 +int main(){ 83 + 84 +CASE(0) 85 + string costs_[] = {"12" 86 +,"34"}; 87 + vector <string> costs(costs_, costs_+sizeof(costs_)/sizeof(*costs_)); 88 + int _ = 6; 89 +END 90 +CASE(1) 91 + string costs_[] = {"99999" 92 +,"99999" 93 +,"99999"}; 94 + vector <string> costs(costs_, costs_+sizeof(costs_)/sizeof(*costs_)); 95 + int _ = 99; 96 +END 97 +CASE(2) 98 + string costs_[] = {"11111" 99 +,"90005"}; 100 + vector <string> costs(costs_, costs_+sizeof(costs_)/sizeof(*costs_)); 101 + int _ = 10; 102 +END 103 +CASE(3) 104 + string costs_[] = {"4417231387449337370319219832088987579792" 105 +,"3117295688208899006196193430472892512797" 106 +,"0835796222361526836944954410684516919758" 107 +,"1988200069973565052900745230547016216225" 108 +,"8080511471118865780390486996601082102418" 109 +,"4229084185957675819725844582167613108400" 110 +,"9068653877952162764545674979144308771754" 111 +,"8551565425951612499712254182109991511690" 112 +,"7090525592007482152807163656647658543093" 113 +,"9198968742256995592729889137556032960142" 114 +,"2071864379877766468141740053503050313101" 115 +,"1055375249261868472993219156394129253481" 116 +,"2461178270502857106406495509025426298874" 117 +,"8216781259733537757203421037984512664825" 118 +,"4693452554407216935375049784445568498482" 119 +,"2709693439640250842244170297203200674391" 120 +,"5122217695676372684217182241705137947908" 121 +,"6668814191410691246849638388008228444294" 122 +,"4952122070212780440963814752538149378639" 123 +,"9827737761436134120332969866554332504400" 124 +,"3412406588339828249986707470540386748886" 125 +,"7521506848088506994554600408372456405830" 126 +,"1916926179183007872881163173153907665999" 127 +,"6636166791472761992310264951474925339024" 128 +,"6679667717747231380196787943691121008076" 129 +,"3218993234115685151069259138068533004433" 130 +,"4920152552986426962081492913852060211795" 131 +,"0365186235986445521382132973036266396894" 132 +,"3205351414936828189305188614651974318855" 133 +,"3144278971529524658788277656125598825426" 134 +,"5525287537572356662391582052968411726245" 135 +,"2130137226726919525622574701068062252930" 136 +,"2369996694245544770519574837226971226841" 137 +,"6806769058165410189286521891570936341547" 138 +,"0448109211631660241710734664066810078242" 139 +,"4622919135804954122810530631429501069659" 140 +,"0235247446548732490429856705369583140671" 141 +,"2193399741215975228987754171460722199304" 142 +,"1203037020703833716225328076959743850915" 143 +,"5419885193880826109484912489603262199432"}; 144 + vector <string> costs(costs_, costs_+sizeof(costs_)/sizeof(*costs_)); 145 + int _ = 7366; 146 +END 147 +CASE(4) 148 + string costs_[] = ; 149 + vector <string> costs(costs_, costs_+sizeof(costs_)/sizeof(*costs_)); 150 + int _ = ; 151 +END 152 +CASE(5) 153 + string costs_[] = ; 154 + vector <string> costs(costs_, costs_+sizeof(costs_)/sizeof(*costs_)); 155 + int _ = ; 156 +END 157 + 158 +} 159 +// END CUT HERE