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) << " msec)"; return os.str(); } 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 os; } 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() << endl; 84 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 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 + tgt*c)%9)*f; 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) << " msec)"; return os.str(); } 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 os; } 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() << endl; 101 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 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,19,26,29,31,28,27,10,20,23}; 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], p[i]) IS_RIGHT ) 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], p[i]) IS_RIGHT ) 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> prob, vector <int> blueX, vector <int> blueY) 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& lhs, const CMP& rhs){ 110 + if(lhs.imag() != rhs.imag()) return lhs.imag() < rhs.imag(); 111 + return lhs.real() < rhs.real(); 112 + }); 113 + 114 + sort(rp.begin(), rp.end(), [&](const pair<CMP,double>& lhs, const pair<CMP,double>& rhs) { 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 : rp[next].second) * rec(next, done_from); 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 * rec(from, to); 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) << " msec)"; return os.str(); } 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 os; } 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() << endl; 177 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 178 +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock(); 179 +#define END verify_case(_, BichromeSky().totallyCovered(redX, redY, prob, blueX, blueY));} 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