• branch=trunk inherited from [9165bd3629]
• sym-trunk inherited from [9165bd3629]

Added SRM/515/1A.cpp version [27159b7b45b87198]

            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 <cstring>
           18  +using namespace std;
           19  +typedef long long LL;
           20  +typedef complex<double> CMP;
           21  +
           22  +class RotatedClock { public:
           23  + string getEarliest(int hourHand, int minuteHand)
           24  + {
           25  +  for(int h=0; h<12; ++h)
           26  +   for(int m=0; m<60; ++m)
           27  +    for(int offset=0; offset<360; offset+=30) {
           28  +     int hx = (hourHand + offset) % 360;
           29  +     int mx = (minuteHand + offset) % 360;
           30  +     if( match(h, m, hx, mx) ) {
           31  +      char buf[100];
           32  +      sprintf(buf, "%02d:%02d", h, m);
           33  +      return buf;
           34  +     }
           35  +    }
           36  +  return string();
           37  + }
           38  +
           39  + bool match(int h, int m, int hx, int mx)
           40  + {
           41  +  return (h*60+m)*360 == hx*(12*60)
           42  +   && m*360 == mx*60;
           43  + }
           44  +};
           45  +
           46  +// BEGIN CUT HERE
           47  +#include <ctime>
           48  +double start_time; string timer()
           49  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           50  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           51  + { os << "{ ";
           52  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           53  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           54  +void verify_case(const string& Expected, const string& Received) {
           55  + bool ok = (Expected == Received);
           56  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           57  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           58  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           59  +#define END  verify_case(_, RotatedClock().getEarliest(hourHand, minuteHand));}
           60  +int main(){
           61  +
           62  +CASE(0)
           63  + int hourHand = 70;
           64  + int minuteHand = 300;
           65  + string _ = "08:20";
           66  +END
           67  +CASE(1)
           68  + int hourHand = 90;
           69  + int minuteHand = 120;
           70  + string _ = "11:00";
           71  +END
           72  +CASE(2)
           73  + int hourHand = 240;
           74  + int minuteHand = 36;
           75  + string _ = "";
           76  +END
           77  +CASE(3)
           78  + int hourHand = 19;
           79  + int minuteHand = 19;
           80  + string _ = "";
           81  +END
           82  +CASE(4)
           83  + int hourHand = 1;
           84  + int minuteHand = 12;
           85  + string _ = "00:02";
           86  +END
           87  +/*
           88  +CASE(5)
           89  + int hourHand = ;
           90  + int minuteHand = ;
           91  + string _ = ;
           92  +END
           93  +CASE(6)
           94  + int hourHand = ;
           95  + int minuteHand = ;
           96  + string _ = ;
           97  +END
           98  +*/
           99  +}
          100  +// END CUT HERE

Added SRM/515/1B.cpp version [aab4c30d49ab7bd6]

            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 <cstring>
           18  +using namespace std;
           19  +typedef long long LL;
           20  +typedef complex<double> CMP;
           21  +
           22  +struct Event
           23  +{
           24  + int i, T, C, P;
           25  + double P_total;
           26  + bool has_next;
           27  + Event(int i, int T, int C, int P) : i(i), T(T), C(C), P(P) {}
           28  + bool operator<(const Event& rhs) const { return T < rhs.T; }
           29  +};
           30  +
           31  +class NewItemShop { public:
           32  + double getMaximum(int swords, vector <string> customers)
           33  + {
           34  +  vector<Event> ev;
           35  +  for(size_t i=0; i<customers.size(); ++i)
           36  +  {
           37  +   for(size_t k=0; k<customers[i].size(); ++k)
           38  +    if( customers[i][k] == ',' )
           39  +     customers[i][k] = ' ';
           40  +   stringstream ss(customers[i]);
           41  +   for(int T,C,P; ss>>T>>C>>P; )
           42  +    ev.push_back(Event((int)i,T,C,P));
           43  +  }
           44  +  sort(ev.begin(), ev.end());
           45  +  for(int i=0; i<ev.size(); ++i)
           46  +  {
           47  +   ev[i].P_total = 100;
           48  +   ev[i].has_next = false;
           49  +   for(int k=i+1; k<ev.size(); ++k)
           50  +    if( ev[k].i == ev[i].i )
           51  +     ev[i].has_next = true;
           52  +   for(int k=i-1; k>=0; --k)
           53  +    if( ev[k].i == ev[i].i )
           54  +     ev[i].P_total -= ev[k].P;
           55  +  }
           56  +  return rec(0, ev, swords, 0);
           57  + }
           58  +
           59  + map<int, double> memo;
           60  + double rec(int i, const vector<Event>& ev, int swords, int mask)
           61  + {
           62  +  if( i==ev.size() || swords==0 )
           63  +   return 0;
           64  +  int key = (mask*ev.size() + i) * 25 + swords;
           65  +  if( memo.count(key) )
           66  +   return memo[key];
           67  +
           68  +  const int ID = ev[i].i;
           69  +  const double C = ev[i].C;
           70  +  const double P = ev[i].P / ev[i].P_total;
           71  +  const int newmask = (ev[i].has_next ? mask|(1<<ID) : mask);
           72  +
           73  +  if( (1<<ID) & mask )
           74  +   return memo[key] = rec(i+1, ev, swords, mask);
           75  +  return memo[key] =
           76  +         P * max(C+rec(i+1, ev, swords-1, newmask), rec(i+1, ev, swords, newmask))
           77  +   + (1-P) * rec(i+1, ev, swords, mask);
           78  + }
           79  +};
           80  +
           81  +// BEGIN CUT HERE
           82  +#include <ctime>
           83  +double start_time; string timer()
           84  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           85  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           86  + { os << "{ ";
           87  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           88  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           89  +void verify_case(const double& Expected, const double& Received) {
           90  + bool ok = (abs(Expected - Received) < 1e-9);
           91  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           92  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           93  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           94  +#define END  verify_case(_, NewItemShop().getMaximum(swords, customers));}
           95  +int main(){
           96  +
           97  +CASE(0)
           98  + int swords = 1;
           99  + string customers_[] = { "8,1,80 16,100,11", "12,10,100" };
          100  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          101  + double _ = 19.0;
          102  +END
          103  +CASE(1)
          104  + int swords = 2;
          105  + string customers_[] = { "8,1,80 16,100,11", "12,10,100" };
          106  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          107  + double _ = 21.8;
          108  +END
          109  +CASE(2)
          110  + int swords = 1;
          111  + string customers_[] = { "0,90,25 2,90,25 4,90,25 6,90,25", "7,100,80" };
          112  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          113  + double _ = 90.0;
          114  +END
          115  +CASE(3)
          116  + int swords = 3;
          117  + string customers_[] = { "17,31,41 20,59,26 23,53,5", "19,89,79", "16,32,38 22,46,26", "18,43,38 21,32,7" };
          118  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          119  + double _ = 135.5121414;
          120  +END
          121  +CASE(4)
          122  + int swords = 5;
          123  + string customers_[] = { "1,1,10", "2,2,9", "3,3,8", "4,4,7", "5,5,6", "6,6,5", "7,7,4", "8,8,3", "9,9,2", "10,10,1" };
          124  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          125  + double _ = 2.1999744634845344;
          126  +END
          127  +/*
          128  +CASE(5)
          129  + int swords = ;
          130  + string customers_[] = ;
          131  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          132  + double _ = ;
          133  +END
          134  +CASE(6)
          135  + int swords = ;
          136  + string customers_[] = ;
          137  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          138  + double _ = ;
          139  +END
          140  +*/
          141  +}
          142  +// END CUT HERE

Added SRM/515/1C.cpp version [345e49df172a4d83]

            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 <cstring>
           18  +using namespace std;
           19  +typedef long long LL;
           20  +typedef complex<double> CMP;
           21  +
           22  +static const int INF = 0x3fffffff;
           23  +LL gcd(LL x, LL y) { while(x) swap(x,y%=x); return y; }
           24  +static const int dy[] = {-1,+1,0,0};
           25  +static const int dx[] = {0,0,-1,+1};
           26  +
           27  +class MeetInTheMaze { public:
           28  + int H, W;
           29  + map<char, int> count;
           30  +
           31  + void setup_maze(vector<string>& maze)
           32  + {
           33  +  setup_sentinel(maze);
           34  +
           35  +  H = maze.size();
           36  +  W = maze[0].size();
           37  +
           38  +  for(int y=0; y<H; ++y)
           39  +  for(int x=0; x<W; ++x)
           40  +   count[maze[y][x]] ++;
           41  + }
           42  +
           43  + void setup_sentinel(vector<string>& maze)
           44  + {
           45  +  for(int y=0; y<maze.size(); ++y)
           46  +   maze[y] = '#' + maze[y] + '#';
           47  +  maze.insert( maze.begin(), string(maze[0].size(), '#') );
           48  +  maze.insert( maze.end(),   string(maze[0].size(), '#') );
           49  + }
           50  +
           51  + string ratio2str(LL si, LL bo)
           52  + {
           53  +  if( si >= INF )
           54  +   return "";
           55  +  LL g = gcd(si, bo);
           56  +  stringstream ss;
           57  +  ss << si/g << "/" << bo/g;
           58  +  return ss.str();
           59  + }
           60  +
           61  + LL dijkstra(const vector< vector<int> >& FD, const vector< vector<int> >& RD, const vector<string>& maze)
           62  + {
           63  +  typedef pair<int,int>   vert;
           64  +  typedef LL              cost;
           65  +  typedef pair<cost,vert> cvert;
           66  +
           67  +  vector<bool> V(H*W);
           68  +  priority_queue< cvert, vector<cvert>, greater<cvert> > Q;
           69  +  for(int y=0; y<H; ++y)
           70  +  for(int x=0; x<W; ++x)
           71  +   if( maze[y][x] != '#' )
           72  +    Q.push( cvert(FD[y][x]+RD[y][x], make_pair(y,x)) );
           73  +
           74  +  cost total = 0;
           75  +  while( !Q.empty() )
           76  +  {
           77  +   cvert v = Q.top(); Q.pop();
           78  +   cost c = v.first;
           79  +   int y = v.second.first;
           80  +   int x = v.second.second;
           81  +   if( V[y*W+x] )
           82  +    continue;
           83  +   V[y*W+x] = true;
           84  +
           85  +   if( maze[y][x] == 'L' )
           86  +    total += c;
           87  +
           88  +   for(int k=0; k<4; ++k) {
           89  +    int yy = y+dy[k];
           90  +    int xx = x+dx[k];
           91  +    cvert u(c+1, make_pair(yy,xx));
           92  +    if( maze[yy][xx]!='#' && !V[yy*W+xx] )
           93  +     Q.push(u);
           94  +   }
           95  +  }
           96  +  return total;
           97  + }
           98  +
           99  + void bfs(vector< vector<int> >& D, vector<string>& m, int y, int x)
          100  + {
          101  +  vector< pair<int,int> > Q(1, make_pair(y,x));
          102  +  D[y][x] = 0;
          103  +  for(int s=1; !Q.empty(); ++s)
          104  +  {
          105  +   vector< pair<int,int> > Q2;
          106  +   for(int i=0; i<Q.size(); ++i){
          107  +    y = Q[i].first;
          108  +    x = Q[i].second;
          109  +    for(int k=0; k<4; ++k) {
          110  +     int yy = y+dy[k];
          111  +     int xx = x+dx[k];
          112  +     if( m[yy][xx]!='#' && D[yy][xx]==INF )
          113  +      Q2.push_back(make_pair(yy,xx)), D[yy][xx]=s;
          114  +    }
          115  +   }
          116  +   Q.swap(Q2);
          117  +  }
          118  + }
          119  +
          120  + string getExpected(vector <string> maze)
          121  + {
          122  +  setup_maze(maze);
          123  +
          124  +  LL total = 0;
          125  +  for(int fy=0; fy<H; ++fy)
          126  +  for(int fx=0; fx<W; ++fx)
          127  +  if( maze[fy][fx] == 'F' )
          128  +  {
          129  +   // Fill the 2d-map FD with the distance from (fy,fx) in the maze.
          130  +   vector< vector<int> > FD(H, vector<int>(W, INF));
          131  +   bfs(FD, maze, fy, fx);
          132  +   for(int ry=0; ry<H; ++ry)
          133  +   for(int rx=0; rx<W; ++rx)
          134  +   if( maze[ry][rx] == 'R' )
          135  +   {
          136  +    // Fill the 2d-map RD with the distance from (ry,rx) in the maze.
          137  +    vector< vector<int> > RD(H, vector<int>(W, INF));
          138  +    bfs(RD, maze, ry, rx);
          139  +    // Compute the distances of all the cells from the base "FD+RD"
          140  +    total += dijkstra(FD, RD, maze);
          141  +   }
          142  +  }
          143  +  return ratio2str(total, count['F']*count['R']*count['L']);
          144  + }
          145  +};
          146  +
          147  +// BEGIN CUT HERE
          148  +#include <ctime>
          149  +double start_time; string timer()
          150  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          151  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          152  + { os << "{ ";
          153  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          154  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          155  +void verify_case(const string& Expected, const string& Received) {
          156  + bool ok = (Expected == Received);
          157  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          158  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          159  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          160  +#define END  verify_case(_, MeetInTheMaze().getExpected(maze));}
          161  +int main(){
          162  +
          163  +CASE(0)
          164  + string maze_[] = { "#########",
          165  +  "####F####",
          166  +  "##L...R##",
          167  +  "####L####",
          168  +  "#########" }
          169  +;
          170  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          171  + string _ = "9/2";
          172  +END
          173  +CASE(1)
          174  + string maze_[] = { "LR",
          175  +  "RF" }
          176  +;
          177  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          178  + string _ = "2/1";
          179  +END
          180  +CASE(2)
          181  + string maze_[] = { "..F.#...",
          182  +  "L.F.#..L",
          183  +  "..F.#...",
          184  +  ".R.#..L.",
          185  +  "...#....",
          186  +  "..R#.L.." }
          187  +;
          188  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          189  + string _ = "";
          190  +END
          191  +CASE(3)
          192  + string maze_[] = { ".L..L..L..",
          193  +  "..........",
          194  +  "..........",
          195  +  "..........",
          196  +  "........R.",
          197  +  "...R......",
          198  +  "..........",
          199  +  "..........",
          200  +  "..........",
          201  +  ".......F.." }
          202  +;
          203  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          204  + string _ = "40/3";
          205  +END
          206  +CASE(4)
          207  + string maze_[] = { "#.#....#...#.#",
          208  +  "#...#..#......",
          209  +  ".L#...#R#..#F.",
          210  +  "#...#......#..",
          211  +  "#......#.....#",
          212  +  ".R.....F....L.",
          213  +  "##..#.......#.",
          214  +  "#........##...",
          215  +  ".F...##L#..#R#" }
          216  +;
          217  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          218  + string _ = "362/27";
          219  +END
          220  +CASE(5)
          221  + string maze_[] = { "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLFLLLLLLLLLFLLLL",
          222  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          223  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          224  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          225  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          226  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          227  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          228  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          229  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLFFLLLLLLLLLLRLLLL",
          230  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          231  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          232  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          233  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLRLLLLLFLLLLLLLLLLLLLLF",
          234  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          235  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLF",
          236  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLFLLL",
          237  +  "LLLLLLLLLLLRLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          238  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRRL",
          239  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          240  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          241  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRLLLLLLLLLLLLLLLL",
          242  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLR",
          243  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          244  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRLLL",
          245  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          246  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRLLLLLL",
          247  +  "LLLLLLLLLLLLLLLLLLLLLLLRLLLLLLLLLLLLLLLLLLLLLLLLLL",
          248  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          249  +  "LLLLLLLLLLLLLLLLRLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          250  +  "LLLLLLLLLFFLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          251  +  "FLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          252  +  "LLLLLLLLLLLLLLLLRLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          253  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          254  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          255  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRLLLLLLLLLLLLLL",
          256  +  "LLLLLLLLLLLLLLLLLLLLLLFLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          257  +  "LLLLLLLLLLLLLLLLFLLLLLLLLLRLLLLLLLLLLLLLLLLLLLRLLL",
          258  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          259  +  "LLLLLLLFLLLLLLLLLLLLLLLLRLLLLLLLLLRLLLLLLLLLLLLRLL",
          260  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRLLLLL",
          261  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          262  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          263  +  "LLLFLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          264  +  "LLLLLLLLLLLLLLLLLLLLLLLLLFLLLLLLLLLLLLLLLLLLLLLLLL",
          265  +  "LLLLLLLLLLLLLLLLLLLLFLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          266  +  "FLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          267  +  "LLLLLLLLLRLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          268  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          269  +  "LLLLLLLLLFLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL",
          270  +  "LLLLLLLLLLLLLLLLLLLLLLLLLLLFLLLLLLLLLLLLLLLLLLLLLL" }
          271  +;
          272  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          273  + string _ = "210623/4100";
          274  +END
          275  +/*
          276  +CASE(6)
          277  + string maze_[] = ;
          278  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          279  + string _ = ;
          280  +END
          281  +CASE(7)
          282  + string maze_[] = ;
          283  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          284  + string _ = ;
          285  +END
          286  +*/
          287  +}
          288  +// END CUT HERE