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) > 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 > 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() > 61 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 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> s > 24 { > 25 vector<int> s; > 26 { > 27 string S1000 = accumulate(s1000.begin(), s1000.end(), st > 28 string S100 = accumulate(s100.begin() , s100.end() , st > 29 string S10 = accumulate(s10.begin() , s10.end() , st > 30 string S1 = accumulate(s1.begin() , s1.end() , st > 31 for(int i=0; i<S1.size(); ++i) > 32 s.push_back(atoi((string(1, S1000[i])+S100[i]+S1 > 33 } > 34 vector<int> t; > 35 { > 36 string T1000 = accumulate(t1000.begin(), t1000.end(), st > 37 string T100 = accumulate(t100.begin(), t100.end(), strin > 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]+T1 > 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] > 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) > 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 > 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() > 124 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 125 #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock( > 126 #define END verify_case(_, ShoutterDiv1().count(s1000, s100, s10, s1, t1000 > 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) > 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 > 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() > 79 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 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