Overview
| SHA1 Hash: | 143923277fcb664536f8b36ff6745bf3c005ec0b |
|---|---|
| Date: | 2014-11-03 04:00:22 |
| User: | kinaba |
| Comment: | 638 |
| 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/638-U/1A-U.cpp version [21a69859a51bc35b]
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 +struct UnionFind 23 +{ 24 + vector<int> uf, sz; 25 + int nc; 26 + 27 + UnionFind(int N): uf(N), sz(N,1), nc(N) 28 + { for(int i=0; i<N; ++i) uf[i] = i; } 29 + int size() 30 + { return nc; } 31 + int size(int a) 32 + { return sz[Find(a)]; } 33 + int Find(int a) 34 + { return uf[a]==a ? a : uf[a]=Find(uf[a]); } 35 + bool Union(int a, int b) 36 + { 37 + a = Find(a); 38 + b = Find(b); 39 + if( a != b ) 40 + { 41 + if( sz[a] >= sz[b] ) swap(a, b); 42 + uf[a] = b; 43 + sz[b] += sz[a]; 44 + --nc; 45 + } 46 + return (a!=b); 47 + } 48 +}; 49 + 50 +class ShadowSculpture { public: 51 + string possible(vector <string> XY, vector <string> YZ, vector <string> ZX) 52 + { 53 + const int N = XY.size(); 54 + 55 + // Init 56 + bool XYZ[10][10][10]; 57 + for(int x=0; x<N; ++x) 58 + for(int y=0; y<N; ++y) 59 + for(int z=0; z<N; ++z) 60 + XYZ[x][y][z] = true; 61 + 62 + // Grave 63 + for(int x=0; x<N; ++x) 64 + for(int y=0; y<N; ++y) 65 + for(int z=0; z<N; ++z) 66 + if(XY[x][y] == 'N' || YZ[y][z] == 'N' || ZX[z][x] == 'N') 67 + XYZ[x][y][z] = false; 68 + 69 + // Sanity check 70 + for(int x=0; x<N; ++x) 71 + for(int y=0; y<N; ++y) { 72 + bool a=false,b=false,c=false; 73 + for(int z=0; z<N; ++z) { 74 + a |= XYZ[x][y][z]; 75 + b |= XYZ[z][x][y]; 76 + c |= XYZ[y][z][x]; 77 + } 78 + if(XY[x][y]=='Y'&&!a) return "Impossible"; 79 + if(YZ[x][y]=='Y'&&!b) return "Impossible"; 80 + if(ZX[x][y]=='Y'&&!c) return "Impossible"; 81 + } 82 + 83 + // Judge 84 + return is_connected(XYZ, N) ? "Possible" : "Impossible"; 85 + } 86 + 87 + bool is_connected(bool XYZ[10][10][10], int N) 88 + { 89 + UnionFind uf(N*N*N); 90 + function<int(int,int,int)> id = [&](int x, int y, int z) { 91 + return (x*N+y)*N+z; 92 + }; 93 + 94 + const int dx[] = {-1,+1,0,0,0,0}; 95 + const int dy[] = {0,0,-1,+1,0,0}; 96 + const int dz[] = {0,0,0,0,-1,+1}; 97 + int cnt = 0; 98 + for(int x=0; x<N; ++x) 99 + for(int y=0; y<N; ++y) 100 + for(int z=0; z<N; ++z) if(XYZ[x][y][z]) { 101 + ++cnt; 102 + for(int d=0; d<6; ++d) { 103 + int xx=x+dx[d], yy=y+dy[d], zz=z+dz[d]; 104 + if(0<=xx&&xx<N&&0<=yy&&yy<N&&0<=zz&&zz<N&&XYZ[xx][yy][zz]) 105 + uf.Union(id(x,y,z), id(xx,yy,zz)); 106 + } 107 + } 108 + 109 + for(int x=0; x<N; ++x) 110 + for(int y=0; y<N; ++y) 111 + for(int z=0; z<N; ++z) if(XYZ[x][y][z] && uf.size(id(x,y,z))!=cnt) 112 + return false; 113 + return true; 114 + } 115 +}; 116 + 117 +// BEGIN CUT HERE 118 +#include <ctime> 119 +double start_time; string timer() 120 + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); } 121 +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) 122 + { os << "{ "; 123 + for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) 124 + os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; } 125 +void verify_case(const string& Expected, const string& Received) { 126 + bool ok = (Expected == Received); 127 + if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; 128 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 129 +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock(); 130 +#define END verify_case(_, ShadowSculpture().possible(XY, YZ, ZX));} 131 +int main(){ 132 + 133 +CASE(0) 134 + string XY_[] = {"YN","NN"}; 135 + vector <string> XY(XY_, XY_+sizeof(XY_)/sizeof(*XY_)); 136 + string YZ_[] = {"YN","NN"}; 137 + vector <string> YZ(YZ_, YZ_+sizeof(YZ_)/sizeof(*YZ_)); 138 + string ZX_[] = {"YN","NN"}; 139 + vector <string> ZX(ZX_, ZX_+sizeof(ZX_)/sizeof(*ZX_)); 140 + string _ = "Possible"; 141 +END 142 +CASE(1) 143 + string XY_[] = {"YN","NY"}; 144 + vector <string> XY(XY_, XY_+sizeof(XY_)/sizeof(*XY_)); 145 + string YZ_[] = {"YN","NY"}; 146 + vector <string> YZ(YZ_, YZ_+sizeof(YZ_)/sizeof(*YZ_)); 147 + string ZX_[] = {"YN","NY"}; 148 + vector <string> ZX(ZX_, ZX_+sizeof(ZX_)/sizeof(*ZX_)); 149 + string _ = "Impossible"; 150 +END 151 +CASE(2) 152 + string XY_[] = {"YYY","YNY","YYY"}; 153 + vector <string> XY(XY_, XY_+sizeof(XY_)/sizeof(*XY_)); 154 + string YZ_[] = {"YYY","YNY","YYY"}; 155 + vector <string> YZ(YZ_, YZ_+sizeof(YZ_)/sizeof(*YZ_)); 156 + string ZX_[] = {"YYY","YNY","YYY"}; 157 + vector <string> ZX(ZX_, ZX_+sizeof(ZX_)/sizeof(*ZX_)); 158 + string _ = "Possible"; 159 +END 160 +CASE(3) 161 + string XY_[] = {"YYY","YNY","YYY"}; 162 + vector <string> XY(XY_, XY_+sizeof(XY_)/sizeof(*XY_)); 163 + string YZ_[] = {"NYY","YNY","YYY"}; 164 + vector <string> YZ(YZ_, YZ_+sizeof(YZ_)/sizeof(*YZ_)); 165 + string ZX_[] = {"YYY","YNY","YYN"}; 166 + vector <string> ZX(ZX_, ZX_+sizeof(ZX_)/sizeof(*ZX_)); 167 + string _ = "Impossible"; 168 +END 169 +CASE(4) 170 + string XY_[] = {"N"}; 171 + vector <string> XY(XY_, XY_+sizeof(XY_)/sizeof(*XY_)); 172 + string YZ_[] = {"N"}; 173 + vector <string> YZ(YZ_, YZ_+sizeof(YZ_)/sizeof(*YZ_)); 174 + string ZX_[] = {"N"}; 175 + vector <string> ZX(ZX_, ZX_+sizeof(ZX_)/sizeof(*ZX_)); 176 + string _ = "Possible"; 177 +END 178 +/* 179 +CASE(5) 180 + string XY_[] = ; 181 + vector <string> XY(XY_, XY_+sizeof(XY_)/sizeof(*XY_)); 182 + string YZ_[] = ; 183 + vector <string> YZ(YZ_, YZ_+sizeof(YZ_)/sizeof(*YZ_)); 184 + string ZX_[] = ; 185 + vector <string> ZX(ZX_, ZX_+sizeof(ZX_)/sizeof(*ZX_)); 186 + string _ = ; 187 +END 188 +CASE(6) 189 + string XY_[] = ; 190 + vector <string> XY(XY_, XY_+sizeof(XY_)/sizeof(*XY_)); 191 + string YZ_[] = ; 192 + vector <string> YZ(YZ_, YZ_+sizeof(YZ_)/sizeof(*YZ_)); 193 + string ZX_[] = ; 194 + vector <string> ZX(ZX_, ZX_+sizeof(ZX_)/sizeof(*ZX_)); 195 + string _ = ; 196 +END 197 +*/ 198 +} 199 +// END CUT HERE
Added SRM/638-U/1B.cpp version [43426d2047e44511]
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 +const int MODVAL = 1000000007; 23 + 24 +class NarrowPassage2 { public: 25 + int count(vector <int> size, int maxSizeSum) 26 + { 27 + if(size.size() <= 1) 28 + return 1; 29 + 30 + int mi = min_element(size.begin(), size.end()) - size.begin(); 31 + 32 + int lm=mi; 33 + for(int k=mi-1; k>=0 && size[k]+size[mi]<=maxSizeSum; --k) 34 + lm = k; 35 + int rm=mi; 36 + for(int k=mi+1; k<size.size() && size[k]+size[mi]<=maxSizeSum; ++k) 37 + rm = k; 38 + 39 + size.erase(size.begin()+mi); 40 + return LL(rm-lm+1) * count(size, maxSizeSum) % MODVAL; 41 + } 42 +}; 43 + 44 +// BEGIN CUT HERE 45 +#include <ctime> 46 +double start_time; string timer() 47 + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); } 48 +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) 49 + { os << "{ "; 50 + for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) 51 + os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; } 52 +void verify_case(const int& Expected, const int& Received) { 53 + bool ok = (Expected == Received); 54 + if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; 55 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 56 +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock(); 57 +#define END verify_case(_, NarrowPassage2().count(size, maxSizeSum));} 58 +int main(){ 59 + 60 +CASE(0) 61 + int size_[] = {1, 2, 3}; 62 + vector <int> size(size_, size_+sizeof(size_)/sizeof(*size_)); 63 + int maxSizeSum = 3; 64 + int _ = 2; 65 +END 66 +CASE(1) 67 + int size_[] = {1, 2, 3}; 68 + vector <int> size(size_, size_+sizeof(size_)/sizeof(*size_)); 69 + int maxSizeSum = 1000; 70 + int _ = 6; 71 +END 72 +CASE(2) 73 + int size_[] = {1, 2, 3}; 74 + vector <int> size(size_, size_+sizeof(size_)/sizeof(*size_)); 75 + int maxSizeSum = 4; 76 + int _ = 3; 77 +END 78 +CASE(3) 79 + int size_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1}; 80 + vector <int> size(size_, size_+sizeof(size_)/sizeof(*size_)); 81 + int maxSizeSum = 2; 82 + int _ = 227020758; 83 +END 84 +CASE(4) 85 + int size_[] = {2,4,6,1,3,5}; 86 + vector <int> size(size_, size_+sizeof(size_)/sizeof(*size_)); 87 + int maxSizeSum = 8; 88 + int _ = 60; 89 +END 90 +CASE(5) 91 + int size_[] = {1000000000}; 92 + vector <int> size(size_, size_+sizeof(size_)/sizeof(*size_)); 93 + int maxSizeSum = 1000000000; 94 + int _ = 1; 95 +END 96 +/* 97 +CASE(6) 98 + int size_[] = ; 99 + vector <int> size(size_, size_+sizeof(size_)/sizeof(*size_)); 100 + int maxSizeSum = ; 101 + int _ = ; 102 +END 103 +CASE(7) 104 + int size_[] = ; 105 + vector <int> size(size_, size_+sizeof(size_)/sizeof(*size_)); 106 + int maxSizeSum = ; 107 + int _ = ; 108 +END 109 +*/ 110 +} 111 +// END CUT HERE
Added SRM/638-U/1C-U.cpp version [a8492d73123f6c2f]
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 +const int INF = 0x1fffffff; 23 + 24 +class CandleTimer { public: 25 + int differentTime(vector <int> A, vector <int> B, vector <int> len) 26 + { 27 + if(A.size() == 1) { 28 + // Special case, just in case. All nodes are leaves. 29 + // Either light only one end or both ends. 30 + return 2; 31 + } 32 + 33 + // x2, to make all the possible final points on integer coordinates. 34 + for(auto& li: len) 35 + li *= 2; 36 + 37 + // Prepare.... 38 + const int E = A.size(), V = E+1; 39 + 40 + vector<int> leaf; 41 + vector<bool> is_leaf(V, false); 42 + { 43 + vector<int> degree(V); 44 + for(auto a: A) degree[a]++; 45 + for(auto b: B) degree[b]++; 46 + 47 + for(int v=0; v<V; ++v) 48 + if(degree[v]==1) { 49 + leaf.push_back(v); 50 + is_leaf[v] = true; 51 + } 52 + } 53 + 54 + vector<vector<int>> dist(V, vector<int>(V, INF)); 55 + { 56 + for(int i=0; i<V; ++i) 57 + dist[i][i] = 0; 58 + for(int i=0; i<E; ++i) 59 + dist[A[i]][B[i]] = dist[B[i]][A[i]] = len[i]; 60 + for(int k=0; k<V; ++k) 61 + for(int i=0; i<V; ++i) 62 + for(int j=0; j<V; ++j) 63 + dist[i][j] = min(dist[i][j], dist[i][k]+dist[k][j]); 64 + } 65 + 66 + vector<vector<pair<int,int>>> G(V); // len, dest 67 + for(int e=0; e<E; ++e) { 68 + G[A[e]].emplace_back(len[e], B[e]); 69 + G[B[e]].emplace_back(len[e], A[e]); 70 + } 71 + 72 + // Compute all possible final points. 73 + enum {EID, POS}; 74 + vector<tuple<int,int>> cand; 75 + { 76 + vector<bool> done(V, false); 77 + 78 + // Add all leaves as the possible final point 79 + for(int e=0; e<E; ++e) { 80 + if(is_leaf[A[e]] && !done[A[e]]) 81 + cand.emplace_back(e, 0), done[A[e]]=true; 82 + if(is_leaf[B[e]] && !done[B[e]]) 83 + cand.emplace_back(e, len[e]), done[B[e]]=true; 84 + } 85 + 86 + // Add all mid points. 87 + for(int la: leaf) 88 + for(int lb: leaf) 89 + for(int e=0; e<E; ++e) 90 + { 91 + int a=A[e], b=B[e], ll=len[e]; 92 + if(dist[la][a]+ll+dist[lb][b] == dist[la][lb]) { 93 + if(abs(dist[la][a] - dist[lb][b]) <= ll) { 94 + tuple<int,int> c(e, (ll+dist[lb][b]-dist[la][a])/2); 95 + // TODO: reduce by done[] 96 + cand.push_back(c); 97 + } 98 + } else if(dist[la][b]+ll+dist[lb][a] == dist[la][lb]) { 99 + if(abs(dist[la][b] - dist[lb][a]) <= ll) { 100 + tuple<int,int> c(e, (ll+dist[la][b]-dist[lb][a])/2); 101 + // TODO: reduce by done[] 102 + cand.push_back(c); 103 + } 104 + } 105 + } 106 + } 107 + 108 + // Distance between a candidate point and a node. 109 + function<int(tuple<int,int>,int)> calc_d = [&](tuple<int,int> c, int v) { 110 + return min( 111 + dist[A[get<EID>(c)]][v] + get<POS>(c), 112 + dist[B[get<EID>(c)]][v] + len[get<EID>(c)] - get<POS>(c) 113 + ); 114 + }; 115 + 116 + // Simulate all. 117 + set<int> answer; 118 + for(auto c: cand) 119 + { 120 + vector<pair<int,int>> dist_leaf; 121 + for(int v: leaf) 122 + dist_leaf.emplace_back(calc_d(c, v), v); 123 + sort(dist_leaf.begin(), dist_leaf.end()); 124 + 125 + for(int i=0; i<dist_leaf.size(); ++i) 126 + { 127 + const int cand_time = dist_leaf[i].first; 128 + if(i>0 && cand_time == dist_leaf[i-1].first) 129 + continue; 130 + 131 + // Light all leaves further or equal to dist_leaf[i]. 132 + // Can the point |c| be the last point (burning at |cand_time|?) 133 + 134 + // Dijkstra. 135 + vector<int> burn_time(V, INF); 136 + { 137 + priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> Q; 138 + for(int k=i; k<dist_leaf.size(); ++k) 139 + Q.emplace(0, dist_leaf[k].second); 140 + while(!Q.empty()) { 141 + int d = Q.top().first; 142 + int v = Q.top().second; 143 + Q.pop(); 144 + if(burn_time[v] != INF) 145 + continue; 146 + burn_time[v] = d; 147 + for(int i=0; i<G[v].size(); ++i) 148 + { 149 + int dd = G[v][i].first; 150 + int u = G[v][i].second; 151 + if(burn_time[u] == INF) 152 + Q.emplace(d+dd, u); 153 + } 154 + } 155 + } 156 + 157 + int bt_min = INF; 158 + for(int e=0; e<E; ++e) 159 + { 160 + int a=A[e], b=B[e], ll=len[e], bt; 161 + if(burn_time[a]+ll == burn_time[b] || burn_time[b]+ll == burn_time[a]) { 162 + bt = max(burn_time[a], burn_time[b]); 163 + } else { 164 + bt = max(burn_time[a], burn_time[b]) + (ll - abs(burn_time[b] - burn_time[a]))/2; 165 + } 166 + bt_min = min(bt_min, bt); 167 + } 168 + 169 + if(bt_min >= cand_time) 170 + answer.insert(cand_time); 171 + } 172 + } 173 + 174 + return answer.size(); 175 + } 176 +}; 177 + 178 +// BEGIN CUT HERE 179 +#include <ctime> 180 +double start_time; string timer() 181 + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); } 182 +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) 183 + { os << "{ "; 184 + for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) 185 + os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; } 186 +void verify_case(const int& Expected, const int& Received) { 187 + bool ok = (Expected == Received); 188 + if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; 189 + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } } 190 +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock(); 191 +#define END verify_case(_, CandleTimer().differentTime(A, B, len));} 192 +int main(){ 193 + 194 +CASE(0) 195 + int A_[] = {0,1}; 196 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 197 + int B_[] = {1,2}; 198 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 199 + int len_[] = {10,1}; 200 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 201 + int _ = 2; 202 +END 203 +CASE(1) 204 + int A_[] = {0,0,0}; 205 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 206 + int B_[] = {1,2,3}; 207 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 208 + int len_[] = {1,1,1}; 209 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 210 + int _ = 2; 211 +END 212 +CASE(2) 213 + int A_[] = {0,0,0}; 214 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 215 + int B_[] = {1,2,3}; 216 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 217 + int len_[] = {1,2,3}; 218 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 219 + int _ = 4; 220 +END 221 +CASE(3) 222 + int A_[] = {0,1,1,2,3,3,2,4}; 223 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 224 + int B_[] = {1,2,3,4,5,6,7,8}; 225 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 226 + int len_[] = {5,3,2,4,6,8,7,1}; 227 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 228 + int _ = 7; 229 +END 230 +CASE(4) 231 + int A_[] = {0,0,0,0}; 232 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 233 + int B_[] = {1,2,3,4}; 234 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 235 + int len_[] = {123,456,789,1000}; 236 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 237 + int _ = 8; 238 +END 239 +CASE(5) 240 + int A_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30}; 241 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 242 + int B_[] = {0,1,2,0,0,0,1,0,0,0,2,5,4,7,13,13,6,15,11,18,19,21,22,16,19,19,20,18,22,27}; 243 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 244 + int len_[] = {59,58,147,169,34,14,150,55,156,151,130,109,124,15,100,1,156,16,38,97,99,132,150,18,27,91,110,127,15,105}; 245 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 246 + int _ = 65; 247 +END 248 +CASE(6) 249 + int A_[] = {0}; 250 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 251 + int B_[] = {1}; 252 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 253 + int len_[] = {1000}; 254 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 255 + int _ = 2; 256 +END 257 +/* 258 +CASE(7) 259 + int A_[] = ; 260 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 261 + int B_[] = ; 262 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 263 + int len_[] = ; 264 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 265 + int _ = ; 266 +END 267 +CASE(8) 268 + int A_[] = ; 269 + vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_)); 270 + int B_[] = ; 271 + vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_)); 272 + int len_[] = ; 273 + vector <int> len(len_, len_+sizeof(len_)/sizeof(*len_)); 274 + int _ = ; 275 +END 276 +*/ 277 +} 278 +// END CUT HERE