Overview
| SHA1 Hash: | 892b20bec86e001080c9336874bfdd39920aae59 |
|---|---|
| Date: | 2015-04-28 00:52:10 |
| User: | kinaba |
| Comment: | 655 (or it may be 656 |
| 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/655-U/1A.cpp version [f84d4323f44297d3]
> 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 #include <tuple> > 18 using namespace std; > 19 typedef long long LL; > 20 typedef complex<double> CMP; > 21 > 22 class BichromePainting { public: > 23 string isThatPossible(vector <string> board, int k) > 24 { > 25 return solve(board, k) ? "Possible" : "Impossible"; > 26 } > 27 > 28 bool solve(vector<string> board, int K) > 29 { > 30 while(!no_black(board)) > 31 if(!step_back(board, K)) > 32 return false; > 33 return true; > 34 } > 35 > 36 bool no_black(const vector<string>& board) > 37 { > 38 const int H = board.size(); > 39 const int W = board[0].size(); > 40 for(int y=0; y<H; ++y) > 41 for(int x=0; x<W; ++x) if(board[y][x] == 'B') > 42 return false; > 43 return true; > 44 } > 45 > 46 bool step_back(vector<string>& board, int K) { > 47 bool updated = false; > 48 > 49 const int H = board.size(); > 50 const int W = board[0].size(); > 51 for(int y=0; y+K<=H; ++y) > 52 for(int x=0; x+K<=W; ++x) { > 53 bool has_white = false; > 54 bool has_black = false; > 55 for(int dy=0; dy<K; ++dy) > 56 for(int dx=0; dx<K; ++dx) { > 57 if(board[y+dy][x+dx]=='W') has_white=true; > 58 if(board[y+dy][x+dx]=='B') has_black=true; > 59 } > 60 if(has_white && has_black) > 61 continue; > 62 if(has_white || has_black) { > 63 for(int dy=0; dy<K; ++dy) > 64 for(int dx=0; dx<K; ++dx) > 65 board[y+dy][x+dx] = '*'; > 66 updated = true; > 67 } > 68 } > 69 return updated; > 70 } > 71 }; > 72 > 73 // BEGIN CUT HERE > 74 #include <ctime> > 75 double start_time; string timer() > 76 { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) > 77 template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) > 78 { os << "{ "; > 79 for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) > 80 os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return > 81 void verify_case(const string& Expected, const string& Received) { > 82 bool ok = (Expected == Received); > 83 if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() > 84 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 85 #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock( > 86 #define END verify_case(_, BichromePainting().isThatPossible(board, k));} > 87 int main(){ > 88 > 89 CASE(0) > 90 string board_[] = {"BBBW", > 91 "BWWW", > 92 "BWWW", > 93 "WWWW"}; > 94 vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); > 95 int k = 3; > 96 string _ = "Possible"; > 97 END > 98 CASE(1) > 99 string board_[] = {"BW", > 100 "WB"} > 101 ; > 102 vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); > 103 int k = 2; > 104 string _ = "Impossible"; > 105 END > 106 CASE(2) > 107 string board_[] = {"BWBWBB", > 108 "WBWBBB", > 109 "BWBWBB", > 110 "WBWBBB", > 111 "BBBBBB", > 112 "BBBBBB"} > 113 ; > 114 vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); > 115 int k = 2; > 116 string _ = "Possible"; > 117 END > 118 CASE(3) > 119 string board_[] = {"BWBWBB", > 120 "WBWBWB", > 121 "BWBWBB", > 122 "WBWBWB", > 123 "BWBWBB", > 124 "BBBBBB"} > 125 ; > 126 vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); > 127 int k = 2; > 128 string _ = "Impossible"; > 129 END > 130 CASE(4) > 131 string board_[] = {"BWBWBB", > 132 "WBWBWB", > 133 "BWBWBB", > 134 "WBWBWB", > 135 "BWBWBB", > 136 "BBBBBB"} > 137 ; > 138 vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); > 139 int k = 1; > 140 string _ = "Possible"; > 141 END > 142 CASE(5) > 143 string board_[] = {"BB", > 144 "BB"}; > 145 vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); > 146 int k = 2; > 147 string _ = "Possible"; > 148 END > 149 CASE(6) > 150 string board_[] = {"BBWW", "BBWW", "WBBW", "WWWW"}; > 151 vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); > 152 int k = 2; > 153 string _ = "Possible"; > 154 END > 155 /* > 156 CASE(7) > 157 string board_[] = ; > 158 vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_)); > 159 int k = ; > 160 string _ = ; > 161 END > 162 */ > 163 } > 164 // END CUT HERE
Added SRM/655-U/1B-U.cpp version [ba4c7d03121589b0]
> 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 #include <tuple> > 18 using namespace std; > 19 typedef long long LL; > 20 typedef complex<double> CMP; > 21 > 22 static const unsigned MODVAL = 1000000007; > 23 struct mint > 24 { > 25 unsigned val; > 26 mint():val(0){} > 27 mint(int x):val(x%MODVAL) {} > 28 mint(unsigned x):val(x%MODVAL) {} > 29 mint(LL x):val(x%MODVAL) {} > 30 }; > 31 mint& operator+=(mint& x, mint y) { return x = x.val+y.val; } > 32 mint& operator-=(mint& x, mint y) { return x = x.val-y.val+MODVAL; } > 33 mint& operator*=(mint& x, mint y) { return x = LL(x.val)*y.val; } > 34 mint operator+(mint x, mint y) { return x+=y; } > 35 mint operator-(mint x, mint y) { return x-=y; } > 36 mint operator*(mint x, mint y) { return x*=y; } > 37 > 38 mint POW(mint x, LL e) { mint v=1; for(;e;x*=x,e>>=1) if(e&1) v*=x; return v; } > 39 > 40 class Nine { public: > 41 int count(int N, vector <int> d) > 42 { > 43 const int M = d.size(); > 44 > 45 vector<int> cnt(1<<N); > 46 for(int di: d) > 47 cnt[di]++; > 48 > 49 vector<vector<mint>> pat(M+1, vector<mint>(9)); > 50 pat[0][0] = 1; > 51 for(int cnt=1; cnt<=M; ++cnt) { > 52 for(int pre=0; pre<9; ++pre) > 53 for(int incr=0; incr<=9; ++incr) > 54 pat[cnt][(pre+incr)%9] += pat[cnt-1][pre]; > 55 } > 56 > 57 int TBLMAX = 1; for(int i=0; i<N; ++i) TBLMAX*=9; > 58 vector<mint> dp(TBLMAX); > 59 dp[0] = 1; > 60 > 61 for(int mask=0; mask<(1<<N); ++mask) > 62 { > 63 int c = cnt[mask]; // #{i | d[i] = mask} > 64 vector<mint> dp2(TBLMAX); > 65 > 66 for(int rem_state=0; rem_state<TBLMAX; ++rem_state) > 67 { > 68 for(int tgt=0; tgt<9; ++tgt) > 69 { > 70 int r2 = 0; > 71 for(int f=1,i=0; i<N; f*=9,++i) > 72 { > 73 if(mask&(1<<i)) { > 74 r2 += ((rem_state/f + tg > 75 } else { > 76 r2 += (rem_state/f%9)*f; > 77 } > 78 } > 79 dp2[r2] += dp[rem_state] * pat[c][tgt]; > 80 } > 81 } > 82 > 83 dp = std::move(dp2); > 84 } > 85 return dp[0].val; > 86 } > 87 > 88 }; > 89 > 90 // BEGIN CUT HERE > 91 #include <ctime> > 92 double start_time; string timer() > 93 { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) > 94 template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) > 95 { os << "{ "; > 96 for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) > 97 os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return > 98 void verify_case(const int& Expected, const int& Received) { > 99 bool ok = (Expected == Received); > 100 if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() > 101 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 102 #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock( > 103 #define END verify_case(_, Nine().count(N, d));} > 104 int main(){ > 105 > 106 CASE(0) > 107 int N = 2; > 108 int d_[] = {1,2}; > 109 vector <int> d(d_, d_+sizeof(d_)/sizeof(*d_)); > 110 int _ = 4; > 111 END > 112 CASE(1) > 113 int N = 2; > 114 int d_[] = {1,2,3}; > 115 vector <int> d(d_, d_+sizeof(d_)/sizeof(*d_)); > 116 int _ = 16; > 117 END > 118 CASE(2) > 119 int N = 1; > 120 int d_[] = {0,0,1}; > 121 vector <int> d(d_, d_+sizeof(d_)/sizeof(*d_)); > 122 int _ = 200; > 123 END > 124 CASE(3) > 125 int N = 5; > 126 int d_[] = {1,3,5,8,24,22,25,21,30,2,4,0,6,7,9,11,14,13,12,15,18,17,16,1 > 127 vector <int> d(d_, d_+sizeof(d_)/sizeof(*d_)); > 128 int _ = 450877328; > 129 END > 130 CASE(4) > 131 int N = 5; > 132 int d_[] = {31,31,31,31,31}; > 133 vector <int> d(d_, d_+sizeof(d_)/sizeof(*d_)); > 134 int _ = 11112; > 135 END > 136 /* > 137 CASE(5) > 138 int N = ; > 139 int d_[] = ; > 140 vector <int> d(d_, d_+sizeof(d_)/sizeof(*d_)); > 141 int _ = ; > 142 END > 143 CASE(6) > 144 int N = ; > 145 int d_[] = ; > 146 vector <int> d(d_, d_+sizeof(d_)/sizeof(*d_)); > 147 int _ = ; > 148 END > 149 */ > 150 } > 151 // END CUT HERE
Added SRM/655-U/1C-U.cpp version [c4b7e5143c129dea]
> 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 #include <tuple> > 18 using namespace std; > 19 typedef long long LL; > 20 typedef complex<double> CMP; > 21 > 22 double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); } > 23 double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); } > 24 > 25 int ccw(const CMP& a, CMP b, CMP c) { > 26 b -= a; c -= a; > 27 if( outer_prod(b,c) > 0 ) return +1; // counter clockwise > 28 if( outer_prod(b,c) < 0 ) return -1; // clockwise > 29 if( inner_prod(b,c) < 0 ) return +2; // c--a--b on line > 30 if( norm(b) < norm(c) ) return -2; // a--b--c on line > 31 return 0; > 32 } > 33 > 34 bool byX( const CMP& a, const CMP& b ) { > 35 if( a.real() != b.real() ) > 36 return a.real() < b.real(); > 37 return a.imag() < b.imag(); > 38 } > 39 > 40 vector<CMP> convex_hull( vector<CMP> p ) > 41 { > 42 #define IS_RIGHT <0 // skip on-line verts > 43 //#define IS_RIGHT ==-1 // take all > 44 > 45 sort(p.begin(), p.end(), &byX); > 46 > 47 vector<CMP> ans; > 48 for(int i=0; i<p.size(); ans.push_back(p[i++])) // left-to-right > 49 while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1] > 50 ans.pop_back(); > 51 if( ans.size() == p.size() ) > 52 return ans; > 53 for(int i=p.size()-2; i>=0; ans.push_back(p[i--])) // right-to-left > 54 while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1] > 55 ans.pop_back(); > 56 ans.pop_back(); > 57 return ans; > 58 } > 59 > 60 bool point_in_polygon( vector<CMP>& ps, CMP p ) > 61 { > 62 bool in = false; > 63 for(int i=0; i<ps.size(); ++i) { > 64 CMP a = ps[i] - p; > 65 CMP b = ps[(i+1)%ps.size()] - p; > 66 if(a.imag() > b.imag()) swap(a,b); > 67 if(a.imag()<=0 && 0<b.imag()) { > 68 if( outer_prod(a,b) < 0 ) > 69 in = !in; > 70 } > 71 //if( outer_prod(a,b)==0 && inner_prod(a,b)<=0 ) return ON; > 72 } > 73 return in; > 74 } > 75 > 76 class BichromeSky { public: > 77 double totallyCovered(vector <int> redX, vector <int> redY, vector <int> > 78 { > 79 vector<CMP> blue; > 80 for(int i=0; i<blueX.size(); ++i) > 81 blue.emplace_back(CMP(blueX[i], blueY[i])); > 82 blue = convex_hull(blue); > 83 > 84 vector<CMP> red; > 85 vector<double> p_red; > 86 for(int i=0; i<redX.size(); ++i) { > 87 CMP p = CMP(redX[i], redY[i]); > 88 if(!point_in_polygon(blue, p)) { > 89 red.emplace_back(p); > 90 p_red.emplace_back(prob[i] / 1000.0); > 91 } > 92 } > 93 > 94 // trivial > 95 if(red.size() <= 2) > 96 return 0.0; > 97 > 98 // trivial > 99 vector<CMP> red_hull = convex_hull(red); > 100 for(auto p: blue) > 101 if(!point_in_polygon(red_hull, p)) > 102 return 0.0; > 103 > 104 vector<pair<CMP,double>> rp; > 105 for(int i=0; i<red.size(); ++i) > 106 rp.emplace_back(red[i], p_red[i]); > 107 const int N = rp.size(); > 108 > 109 CMP base = *min_element(red.begin(), red.end(), [](const CMP& lh > 110 if(lhs.imag() != rhs.imag()) return lhs.imag() < rhs.ima > 111 return lhs.real() < rhs.real(); > 112 }); > 113 > 114 sort(rp.begin(), rp.end(), [&](const pair<CMP,double>& lhs, cons > 115 if(lhs == rhs) return false; > 116 if(lhs.first == base) return true; > 117 if(rhs.first == base) return false; > 118 return arg(lhs.first - base) < arg(rhs.first - base); > 119 }); > 120 > 121 function<bool(int,int)> is_right_of_blue = [&](int ai, int bi) { > 122 CMP a = rp[ai%N].first; > 123 CMP b = rp[bi%N].first; > 124 for(CMP p: blue) > 125 if(ccw(a, b, p) != +1) > 126 return false; > 127 return true; // TODO > 128 }; > 129 > 130 function<double(int,int)> rec; > 131 map<pair<int,int>, double> memo; > 132 rec = [&](int done_from, int done_to) { > 133 if(done_from == done_to) > 134 return 1.0; > 135 > 136 pair<int,int> key(done_from, done_to); > 137 if(memo.count(key)) > 138 return memo[key]; > 139 > 140 double total = 0.0; > 141 double pp = 1.0; > 142 for(int next=done_to+1; next<=done_from; ++next) { > 143 if(is_right_of_blue(done_to, next)) { > 144 total += pp * (next==done_from ? 1.0 : r > 145 } > 146 pp *= 1.0 - rp[next].second; > 147 } > 148 return memo[key] = total; > 149 }; > 150 > 151 double ans = 0.0; > 152 for(int from=N; from>=2; --from) > 153 for(int to=1; to<from; ++to) { > 154 if(is_right_of_blue(from, to)) { > 155 double pp = 1.0; > 156 for(int k=(from+1)%N; k!=to; k=(k+1)%N) > 157 pp *= 1.0 - rp[k].second; > 158 ans += rp[from%N].second * rp[to].second * pp * > 159 } > 160 } > 161 > 162 return ans; > 163 } > 164 }; > 165 > 166 // BEGIN CUT HERE > 167 #include <ctime> > 168 double start_time; string timer() > 169 { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) > 170 template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) > 171 { os << "{ "; > 172 for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) > 173 os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return > 174 void verify_case(const double& Expected, const double& Received) { > 175 bool ok = (abs(Expected - Received) < 1e-9); > 176 if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() > 177 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 178 #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock( > 179 #define END verify_case(_, BichromeSky().totallyCovered(redX, redY, prob, b > 180 int main(){ > 181 > 182 CASE(0) > 183 int redX_[] = {3,-3,0}; > 184 vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_)); > 185 int redY_[] = {-1,-1,2}; > 186 vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_)); > 187 int prob_[] = {400,500,600}; > 188 vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_)); > 189 int blueX_[] = {1,0,-1}; > 190 vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_)); > 191 int blueY_[] = {0,1,0}; > 192 vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_)); > 193 double _ = 0.12; > 194 END > 195 CASE(1) > 196 int redX_[] = {3,-3,3,-3}; > 197 vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_)); > 198 int redY_[] = {3,3,-3,-3}; > 199 vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_)); > 200 int prob_[] = {200,300,400,500}; > 201 vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_)); > 202 int blueX_[] = {0,1,-1}; > 203 vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_)); > 204 int blueY_[] = {-1,-2,-2}; > 205 vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_)); > 206 double _ = 0.088; > 207 END > 208 CASE(2) > 209 int redX_[] = {3,-3,0}; > 210 vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_)); > 211 int redY_[] = {-1,-1,2}; > 212 vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_)); > 213 int prob_[] = {400,500,600}; > 214 vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_)); > 215 int blueX_[] = {1,0,-1,123456}; > 216 vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_)); > 217 int blueY_[] = {0,1,0,-654321}; > 218 vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_)); > 219 double _ = 0.0; > 220 END > 221 CASE(3) > 222 int redX_[] = {0,-2,-3,-4,-3,-2,0,2,3,4,3,2}; > 223 vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_)); > 224 int redY_[] = {4,3,2,0,-2,-3,-4,-3,-2,0,2,3}; > 225 vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_)); > 226 int prob_[] = {501,502,503,504,505,506,507,508,509,510,511,512}; > 227 vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_)); > 228 int blueX_[] = {1,-1,-1,1}; > 229 vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_)); > 230 int blueY_[] = {1,1,-1,-1}; > 231 vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_)); > 232 double _ = 0.6555037822772468; > 233 END > 234 CASE(4) > 235 int redX_[] = {0,1,-3,3}; > 236 vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_)); > 237 int redY_[] = {0,4,-2,-2}; > 238 vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_)); > 239 int prob_[] = {200,300,400,500}; > 240 vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_)); > 241 int blueX_[] = {0,-1,1}; > 242 vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_)); > 243 int blueY_[] = {1,-1,-1}; > 244 vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_)); > 245 double _ = 0.06; > 246 END > 247 CASE(5) > 248 int redX_[] = {10,-17,12,-11,-13,-10,-15,14,-4,2}; > 249 vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_)); > 250 int redY_[] = {8,17,-13,-19,-14,11,17,8,-8,-15}; > 251 vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_)); > 252 int prob_[] = {412,360,656,876,984,160,368,873,223,128}; > 253 vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_)); > 254 int blueX_[] = {-9,-3,6,-9,-5,4,-3,10,-7,2}; > 255 vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_)); > 256 int blueY_[] = {-6,10,10,-9,-10,-6,2,-10,-9,6}; > 257 vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_)); > 258 double _ = 0.34037052019900405; > 259 END > 260 /* > 261 CASE(6) > 262 int redX_[] = ; > 263 vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_)); > 264 int redY_[] = ; > 265 vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_)); > 266 int prob_[] = ; > 267 vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_)); > 268 int blueX_[] = ; > 269 vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_)); > 270 int blueY_[] = ; > 271 vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_)); > 272 double _ = ; > 273 END > 274 CASE(7) > 275 int redX_[] = ; > 276 vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_)); > 277 int redY_[] = ; > 278 vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_)); > 279 int prob_[] = ; > 280 vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_)); > 281 int blueX_[] = ; > 282 vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_)); > 283 int blueY_[] = ; > 284 vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_)); > 285 double _ = ; > 286 END > 287 */ > 288 } > 289 // END CUT HERE