SHA1 Hash:	4fd800b3a8ad1d42cc1a75a0cc716ee53f9fad04
Date:	2011-02-23 09:21:16
User:	kinaba
Comment:	Copied from private svn repository.
Timelines:	family | ancestors | descendants | both | trunk
Downloads:	Tarball | ZIP archive
Other Links:	files | file ages | manifest

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

Added CheckList.pptx version [41156cd7a947e2a7]

cannot compute difference between binary files

Added SRM/144/1A.cpp version [053f425528226932]

            1  +#include <vector>
            2  +#include <string>
            3  +using namespace std;
            4  +
            5  +struct BinaryCode
            6  +{
            7  + vector<string> decode( string message )
            8  + {
            9  +  vector<string> ans;
           10  +  ans.push_back( decode(0, message) );
           11  +  ans.push_back( decode(1, message) );
           12  +  return ans;
           13  + }
           14  +
           15  + string decode(int c, string Q)
           16  + {
           17  +  string P; P += char('0'+c);
           18  +  for(int i=0; i<Q.size()-1; ++i)
           19  +   if( '0' <= Q[i]-c && Q[i]-c<='1' )
           20  +    P += char(Q[i]-c),
           21  +    c = P[P.size()-2]-'0' + P[P.size()-1]-'0';
           22  +   else
           23  +    return "NONE";
           24  +  return c==Q[Q.size()-1]-'0' ? P : "NONE";
           25  + }
           26  +};

Added SRM/144/1B.cpp version [014f566256f8eca5]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <sstream>
            4  +#include <utility>
            5  +#include <algorithm>
            6  +using namespace std;
            7  +
            8  +struct Lottery
            9  +{
           10  + vector<string> sortByOdds(vector<string> rules)
           11  + {
           12  +  vector< pair<long long, string> > lots;
           13  +  for(int i=0; i<rules.size(); ++i)
           14  +  {
           15  +   stringstream sin(rules[i]);
           16  +   string name;
           17  +   int  ch, bl;
           18  +   char so, un;
           19  +   getline(sin, name, ':') >> ch >> bl >> so >> un;
           20  +
           21  +   lots.push_back( make_pair(numChoice(ch,bl,so=='T',un=='T'), name) );
           22  +  }
           23  +  sort( lots.begin(), lots.end() );
           24  +
           25  +  vector<string> ans;
           26  +  for(int i=0; i<lots.size(); ++i)
           27  +   ans.push_back( lots[i].second );
           28  +  return ans;
           29  + }
           30  +
           31  + long long numChoice(long long ch, long long bl, bool so, bool un)
           32  + {
           33  +  // Note: so && !un
           34  +  //   3 out of 5  ===
           35  +  //      +|++++[5][5][5], +|+++[4]+[5][5], +|+++[4][4]+[5], ...
           36  +  //   === 3+5-1 C 3
           37  +  long long a = 1;
           38  +  if(so)
           39  +   for(long long i=1; i<=bl; ++i) a = a*(ch-i+(un?1:bl))/i;
           40  +  else
           41  +   while(bl--) a *= (un ? ch-- : ch);
           42  +  return a;
           43  + }
           44  +};

Added SRM/144/1C.cpp version [709c778ec7e505b9]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <sstream>
            4  +#include <set>
            5  +#include <map>
            6  +using namespace std;
            7  +
            8  +struct PenLift
            9  +{
           10  + typedef pair<int, int>           point;
           11  + typedef map< point, set<point> > graph;
           12  +
           13  + int numTimes( vector<string> segments, int n )
           14  + {
           15  +  // Determine All Significant Coordinates
           16  +  set<int> xs, ys;
           17  +  for(int i=0; i<segments.size(); ++i)
           18  +  {
           19  +   stringstream sin(segments[i]);
           20  +   int x1, y1, x2, y2; sin >> x1 >> y1 >> x2 >> y2;
           21  +   xs.insert(x1);
           22  +   xs.insert(x2);
           23  +   ys.insert(y1);
           24  +   ys.insert(y2);
           25  +  }
           26  +
           27  +  // Construct the graph, separated by all significant coordinates
           28  +  graph G;
           29  +  for(int i=0; i<segments.size(); ++i)
           30  +  {
           31  +   stringstream sin(segments[i]);
           32  +   int x1, y1, x2, y2; sin >> x1 >> y1 >> x2 >> y2;
           33  +   if( x1 == x2 )
           34  +   {
           35  +    set<int>::iterator it = ys.lower_bound(min(y1,y2));
           36  +    set<int>::iterator ed = ys.upper_bound(max(y1,y2));
           37  +    for(set<int>::iterator pv=it++; it!=ed; ++it,++pv)
           38  +     G[point(x1,*pv)].insert(point(x1,*it)),
           39  +     G[point(x1,*it)].insert(point(x1,*pv));
           40  +   }
           41  +   else
           42  +   {
           43  +    set<int>::iterator it = xs.lower_bound(min(x1,x2));
           44  +    set<int>::iterator ed = xs.upper_bound(max(x1,x2));
           45  +    for(set<int>::iterator pv=it++; it!=ed; ++it,++pv)
           46  +     G[point(*pv,y1)].insert(point(*it,y1)),
           47  +     G[point(*it,y1)].insert(point(*pv,y1));
           48  +   }
           49  +  }
           50  +
           51  +  // count the number of odd vertices (/2) per connected components
           52  +  set<point> vis;
           53  +
           54  +  int cnt = 0;
           55  +  for(graph::iterator s=G.begin(); s!=G.end(); ++s)
           56  +   if( !vis.count(s->first) )
           57  +    cnt += max(1, numOdd(s->first, G, vis, n)/2);
           58  +  return cnt - 1; // first touch do not require a pen-lift
           59  + }
           60  +
           61  + // simple dfs
           62  + int numOdd( point p, graph& G, set<point>& vis, int n )
           63  + {
           64  +  if( vis.count(p) )
           65  +   return 0;
           66  +  vis.insert(p);
           67  +
           68  +  int cnt = G[p].size()*n % 2; // if odd degree then 1 else 0
           69  +  for(set<point>::iterator it=G[p].begin(); it!=G[p].end(); ++it)
           70  +   cnt += numOdd(*it, G, vis, n);
           71  +  return cnt;
           72  + }
           73  +};

Added SRM/145/1A.cpp version [070f78c25ba825a7]

            1  +#include <vector>
            2  +#include <numeric>
            3  +#include <algorithm>
            4  +#include <utility>
            5  +using namespace std;
            6  +
            7  +struct Bonuses
            8  +{
            9  + vector<int> getDivision(vector<int> points)
           10  + {
           11  +  int sum = accumulate(points.begin(), points.end(), 0);
           12  +
           13  +  int left = 100;
           14  +  vector<int> ans(points.size());
           15  +  for(int i=0; i<points.size(); ++i)
           16  +   left -= (ans[i] = points[i]*100/sum);
           17  +
           18  +  vector< pair<int,int> > poid(points.size());
           19  +  for(int i=0; i<points.size(); ++i)
           20  +   poid[i] = make_pair( -points[i], i );
           21  +  sort(poid.begin(), poid.end());
           22  +
           23  +  for(int i=0; left--; ++i)
           24  +   ans[poid[i].second]++;
           25  +  return ans;
           26  + }
           27  +};

Added SRM/145/1B.cpp version [aea0e2196df4be28]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <sstream>
            4  +#include <cstdlib>
            5  +using namespace std;
            6  +
            7  +struct VendingMachine
            8  +{
            9  + int motorUse(vector<string> prices, vector<string> purchases)
           10  + {
           11  +  vector<int>           sum;
           12  +  vector< vector<int> > pri(prices.size());
           13  +  for(int i=0; i<prices.size(); ++i)
           14  +  {
           15  +   stringstream sin(prices[i]);
           16  +   for(int j=0,n; sin>>n; ++j)
           17  +    {if(j>=sum.size())sum.push_back(0); sum[j]+=n; pri[i].push_back(n);}
           18  +  }
           19  +  int M = pri[0].size();
           20  +
           21  +  int mot = 0;
           22  +  int pc=0, pt=-5;
           23  +  for(int i=0; i<purchases.size(); ++i)
           24  +  {
           25  +   stringstream sin(purchases[i]);
           26  +   string a; getline(sin,a,',');
           27  +   string b; getline(sin,b,':');
           28  +   string c; getline(sin,c);
           29  +   int sh = atoi(a.c_str());
           30  +   int cl = atoi(b.c_str());
           31  +   int  t = atoi(c.c_str());
           32  +
           33  +   if( pri[sh][cl] == 0 )
           34  +    return -1;
           35  +
           36  +   if( t-pt >= 5 )
           37  +   {
           38  +    // rotate
           39  +    int hc = max_element(sum.begin(), sum.end()) - sum.begin();
           40  +    mot += min( abs(hc-pc), M-abs(hc-pc) );
           41  +    pc = hc;
           42  +   }
           43  +
           44  +   // buy
           45  +   sum[cl]    -= pri[sh][cl];
           46  +   pri[sh][cl] = 0;
           47  +   mot += min( abs(cl-pc), M-abs(cl-pc) );
           48  +   pc = cl;
           49  +   pt = t;
           50  +  }
           51  +
           52  +  // rotate
           53  +  int hc = max_element(sum.begin(), sum.end()) - sum.begin();
           54  +  mot += min( abs(hc-pc), M-abs(hc-pc) );
           55  +  pc = hc;
           56  +
           57  +  return mot;
           58  + }
           59  +};

Added SRM/145/1C.cpp version [55b5f1c30cb956ae]

            1  +#include <vector>
            2  +using namespace std;
            3  +
            4  +struct HillHike
            5  +{
            6  + long long numPaths(int distance, int maxHeight, vector<int> landmarks)
            7  + {
            8  +  // reached-maxHeight?, #reached-landmarks, current-height
            9  +  long long buf1[2][51][51]={0}, buf2[2][51][51], (*dp)[51][51]=buf1;
           10  +  dp[0][0][0] = 1;
           11  +
           12  +  for(int d=1; d<=distance; ++d)
           13  +  {
           14  +   long long (*dp2)[51][51] = (dp==buf1 ? buf2 : buf1);
           15  +   memset(dp2, 0, sizeof(long long)*2*51*51);
           16  +
           17  +   for(int rm=0; rm<=1; ++rm)
           18  +    for(int rl=0; rl<=landmarks.size(); ++rl)
           19  +     for(int ch=0; ch<=maxHeight; ++ch)
           20  +     {
           21  +      if(ch>1 || d==distance && ch>0)
           22  +      {
           23  +       dp2[rm]
           24  +          [rl<landmarks.size() && landmarks[rl]==ch-1 ? rl+1 : rl]
           25  +          [ch-1] += dp[rm][rl][ch];
           26  +      }
           27  +      if(ch>0 || d==distance)
           28  +      {
           29  +       dp2[rm]
           30  +          [rl<landmarks.size() && landmarks[rl]==ch ? rl+1 : rl]
           31  +          [ch] += dp[rm][rl][ch];
           32  +      }
           33  +      if( ch<maxHeight )
           34  +      {
           35  +       dp2[ch+1==maxHeight ? 1 : rm]
           36  +          [rl<landmarks.size() && landmarks[rl]==ch+1 ? rl+1 : rl]
           37  +          [ch+1] += dp[rm][rl][ch];
           38  +      }
           39  +     }
           40  +
           41  +   dp = dp2;
           42  +  }
           43  +
           44  +  return dp[1][landmarks.size()][0];
           45  + }
           46  +};

Added SRM/146/1A.cpp version [d12dbd8cea2ce431]

            1  +using namespace std;
            2  +
            3  +struct RectangularGrid
            4  +{
            5  + long long countRectangles(int width, int height)
            6  + {
            7  +  long long w = width+1;
            8  +  long long h = height+1;
            9  +  long long s = w*(w-1)/2*h*(h-1)/2;
           10  +  for(long long x=1; x<w && x<h; ++x)
           11  +   s -= (w-x)*(h-x);
           12  +  return s;
           13  + }
           14  +};

Added SRM/146/1B.cpp version [3e66f13d80d37e14]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <set>
            4  +#include <algorithm>
            5  +#include <iterator>
            6  +using namespace std;
            7  +
            8  +struct Masterbrain
            9  +{
           10  + int possibleSecrets(vector<string> guesses, vector<string> results)
           11  + {
           12  +  int N = guesses.size();
           13  +  int cnt = 0;
           14  +  for(int n=0; n<7*7*7*7; ++n)
           15  +  {
           16  +   int x[] = {n/7/7/7%7+1,n/7/7%7+1,n/7%7+1,n%7+1};
           17  +
           18  +   bool possible = false;
           19  +   for(int lie=0; lie<N && !possible; ++lie)
           20  +   {
           21  +    bool possible_by_the_lie = true;
           22  +    for(int i=0; i<N && possible_by_the_lie; ++i)
           23  +    {
           24  +     int g[] = {guesses[i][0]-'0',guesses[i][1]-'0',guesses[i][2]-'0',guesses[i][3]-'0'};
           25  +     int b = results[i][0]-'0';
           26  +     int w = results[i][3]-'0';
           27  +
           28  +     if( (i==lie) == match(x,g,b,w) )
           29  +      possible_by_the_lie = false;
           30  +    }
           31  +    possible |= possible_by_the_lie;
           32  +   }
           33  +   if( possible )
           34  +    ++cnt;
           35  +  }
           36  +  return cnt;
           37  + }
           38  +
           39  + bool match(int x[], int g[], int b, int w)
           40  + {
           41  +  int true_b = 0;
           42  +  multiset<int> xs, gs;
           43  +  for(int i=0; i<4; ++i)
           44  +   if( g[i] == x[i] )
           45  +    true_b++;
           46  +   else
           47  +    xs.insert(x[i]), gs.insert(g[i]);
           48  +  vector<int> p;
           49  +  set_intersection(xs.begin(), xs.end(), gs.begin(), gs.end(), back_inserter(p));
           50  +  return true_b==b && w==p.size();
           51  + }
           52  +};

Added SRM/146/1C.cpp version [561b82c7ab9e8ca6]

            1  +#include <string>
            2  +#include <queue>
            3  +#include <algorithm>
            4  +using namespace std;
            5  +
            6  +struct Roundabout
            7  +{
            8  + int clearUpTime(string north, string east, string south, string west)
            9  + {
           10  +  char        M[4] = {'N', 'E', 'S', 'W'};
           11  +  string      C[4] = {north, east, south, west};
           12  +  char        R[4] = {'-', '-', '-', '-'};
           13  +  queue<char> Q[4];
           14  +
           15  +  int N = 0;
           16  +  for(int i=0; i<4; ++i)
           17  +   for(int j=0; j<C[i].size(); ++j)
           18  +    if( C[i][j] != '-' )
           19  +     ++N;
           20  +
           21  +  int t = 0;
           22  +  for( ;; ++t )
           23  +  {
           24  +   // leave
           25  +   for(int i=0; i<4; ++i)
           26  +    if( R[i] == M[i] )
           27  +     R[i] = M[i]-'A'+'a', --N; // put ghosts
           28  +   if( !N )
           29  +    return t;
           30  +
           31  +   // rotate
           32  +   rotate( R+0, R+1, R+4 );
           33  +
           34  +   // enter
           35  +   if( !Q[0].empty() && !Q[1].empty() && !Q[2].empty() && !Q[3].empty() )
           36  +   {
           37  +    if( R[0]=='-' )
           38  +     R[0] = Q[0].front(), Q[0].pop();
           39  +   }
           40  +   else
           41  +   {
           42  +    bool Go[] = {
           43  +     R[0]=='-' && Q[1].empty(),
           44  +     R[1]=='-' && Q[2].empty(),
           45  +     R[2]=='-' && Q[3].empty(),
           46  +     R[3]=='-' && Q[0].empty(),
           47  +    };
           48  +    for(int i=0; i<4; ++i)
           49  +     if( Go[i] && !Q[i].empty() )
           50  +      R[i] = Q[i].front(), Q[i].pop();
           51  +   }
           52  +
           53  +   // clear ghost
           54  +   for(int i=0; i<4; ++i)
           55  +    if( 'a'<=R[i] && R[i]<='z' )
           56  +     R[i] = '-';
           57  +
           58  +   // queue
           59  +   for(int i=0; i<4; ++i)
           60  +    if( t < C[i].size() && C[i][t]!='-' )
           61  +     Q[i].push( C[i][t] );
           62  +  }
           63  + }
           64  +};

Added SRM/245/1A.cpp version [29731d8057f68993]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +double f(int a, int n)
           20  +{
           21  + double x = 1;
           22  + while( n --> 0 )
           23  +  x *= a--;
           24  + return x;
           25  +}
           26  +double f(int a)
           27  +{
           28  + return f(a, a);
           29  +}
           30  +double C(int n, int k)
           31  +{
           32  + return f(n,k) / f(k,k);
           33  +}
           34  +
           35  +class Flush
           36  +{
           37  +public:
           38  + double size(vector <int> suits, int number)
           39  + {
           40  +  double all = f(accumulate(suits.begin(), suits.end(), 0), number);
           41  +
           42  +  double ans = 0;
           43  +  for(int i1=0; i1<=number && i1<=suits[0]; ++i1)
           44  +  for(int i2=0; i1+i2<=number && i2<=suits[1]; ++i2)
           45  +  for(int i3=0; i1+i2+i3<=number && i3<=suits[2]; ++i3)
           46  +  {
           47  +   int i4 = number - i1 - i2 - i3;
           48  +   if( i4 <= suits[3] ) {
           49  +    double nf = max(max(i1,i2),max(i3,i4));
           50  +    double n = C(number, i1) * C(number-i1, i2) * C(number-i1-i2, i3)
           51  +     * f(suits[0],i1) * f(suits[1],i2) * f(suits[2],i3) * f(suits[3],i4);
           52  +    ans += nf * n/all;
           53  +   }
           54  +  }
           55  +  return ans;
           56  + }
           57  +};
           58  +
           59  +// BEGIN CUT HERE
           60  +#include <ctime>
           61  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           62  +
           63  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           64  +int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           65  +
           66  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           67  +char Test_(...);
           68  +int Test_(Case_<0>) {
           69  + int suits_[] = {2,2,2,2};
           70  +   vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_));
           71  + int number = 2;
           72  + double RetVal = 1.1428571428571428;
           73  + return verify_case(RetVal, Flush().size(suits, number)); }
           74  +int Test_(Case_<1>) {
           75  + int suits_[] = {1,4,7,10};
           76  +   vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_));
           77  + int number = 22;
           78  + double RetVal = 10.0;
           79  + return verify_case(RetVal, Flush().size(suits, number)); }
           80  +int Test_(Case_<2>) {
           81  + int suits_[] = {13, 13, 13, 13};
           82  +   vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_));
           83  + int number = 49;
           84  + double RetVal = 13.0;
           85  + return verify_case(RetVal, Flush().size(suits, number)); }
           86  +int Test_(Case_<3>) {
           87  + int suits_[] = {13, 13, 13, 13};
           88  +   vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_));
           89  + int number = 26;
           90  + double RetVal = 8.351195960938014;
           91  + return verify_case(RetVal, Flush().size(suits, number)); }
           92  +int Test_(Case_<4>) {
           93  + int suits_[] = {13,13,13,13};
           94  +   vector <int> suits(suits_, suits_+sizeof(suits_)/sizeof(*suits_));
           95  + int number = 0;
           96  + double RetVal = 0.0;
           97  + return verify_case(RetVal, Flush().size(suits, number)); }
           98  +
           99  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          100  +template<>      void Run_<-1>() {}
          101  +int main() { Run_<0>(); }
          102  +// END CUT HERE
          103  +

Added SRM/245/1B.cpp version [990eb2ca96ab96cb]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class BikeLock
           20  +{
           21  +public:
           22  + map<pair<int,string>,int> memo;
           23  + int minTurns(string current, string desired)
           24  + {
           25  +  current += "__";
           26  +  return rec(0, current.size()-2, current, desired);
           27  + }
           28  +
           29  + int rec(int i, int N, string& s, const string& d)
           30  + {
           31  +  if( i == N )
           32  +   return 0;
           33  +  if( s[i] == d[i] )
           34  +   return rec(i+1, N, s, d);
           35  +  pair<int,string> key( i, s.substr(i,3) );
           36  +  if( memo.count(key) )
           37  +   return memo[key];
           38  +  memo[key] = 9999;
           39  +
           40  +  int ans = 9999;
           41  +  for(int w=1; w<=3; ++w)
           42  +   for(int r=-3; r<=3; ++r) if(r)
           43  +   {
           44  +    for(int j=0; j<w; ++j)
           45  +     s[i+j] = (s[i+j]-'0'+10+r)%10+'0';
           46  +    ans = min(ans, 1 + rec(i, N, s, d));
           47  +    for(int j=0; j<w; ++j)
           48  +     s[i+j] = (s[i+j]-'0'+10-r)%10+'0';
           49  +   }
           50  +  return memo[key] = ans;
           51  + }
           52  +};
           53  +
           54  +// BEGIN CUT HERE
           55  +#include <ctime>
           56  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           57  +
           58  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           59  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           60  +
           61  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           62  +char Test_(...);
           63  +int Test_(Case_<0>) {
           64  + string current = "555";
           65  + string desired = "464";
           66  + int RetVal = 2;
           67  + return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
           68  +int Test_(Case_<1>) {
           69  + string current = "1234";
           70  + string desired = "3456";
           71  + int RetVal = 2;
           72  + return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
           73  +int Test_(Case_<2>) {
           74  + string current = "06012005";
           75  + string desired = "06012005";
           76  + int RetVal = 0;
           77  + return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
           78  +int Test_(Case_<3>) {
           79  + string current = "123456789";
           80  + string desired = "567412490";
           81  + int RetVal = 5;
           82  + return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
           83  +int Test_(Case_<4>) {
           84  + string current = "23887547676234543215443276347856987698648735634265";
           85  + string desired = "14327805497625497814327632146531429785698765309822";
           86  + int RetVal = 34;
           87  + return verify_case(RetVal, BikeLock().minTurns(current, desired)); }
           88  +
           89  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           90  +template<>      void Run_<-1>() {}
           91  +int main() { Run_<0>(); }
           92  +// END CUT HERE
           93  +

Added SRM/245/1C.cpp version [3313e77040505eed]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +int N;
           20  +vector<int> A;
           21  +
           22  +typedef int vert;
           23  +typedef int cost;
           24  +typedef pair<cost,vert> edge;
           25  +typedef vector<edge>    edges;
           26  +
           27  +vector<int> dijkstra_like( vert S, int T, int I )
           28  +{
           29  + set<int> ans;
           30  + for(int i=1; i<=I; ++i) ans.insert(i);
           31  +
           32  + priority_queue< edge, edges, greater<edge> > Q;
           33  + Q.push( edge(0, S) );
           34  +
           35  +// set<vert> vis;
           36  + vector<bool> vis(1<<24);
           37  +
           38  + while( !Q.empty() )
           39  + {
           40  +  edge ce=Q.top(); Q.pop();
           41  +
           42  +  int  t = ce.first;
           43  +  vert v = ce.second;
           44  +  if( vis[v] )
           45  +   continue;
           46  +  vis[v]=true;
           47  +
           48  +  int sw = v&511;
           49  +  int a[] = {(v>>9)&31, (v>>14)&31, (v>>19)&31};
           50  +
           51  +  ans.erase(sw);
           52  +  for(int i=0; i<(1<<N+1); ++i)
           53  +  {
           54  +   int sw2 = sw;
           55  +   int a2[] = {a[0], a[1], a[2]};
           56  +
           57  +   int nzMin = 9999;
           58  +   for(int j=0; j<N; ++j) {
           59  +    if( (i&(1<<j)) )
           60  +     a2[j] = A[j]-a2[j];
           61  +    if( a2[j] )
           62  +     nzMin = min(nzMin, a2[j]);
           63  +   }
           64  +   if( (i&(1<<N)) ) sw2 = 0;
           65  +   if( nzMin==9999 ) continue;
           66  +   if( t+nzMin > T )
           67  +    continue;
           68  +   for(int j=0; j<N; ++j)
           69  +    if( a2[j] )
           70  +     a2[j] -= nzMin;
           71  +   sw2 += nzMin;
           72  +   vert u = sw2 | (a2[0]<<9) | (a2[1]<<14) | (a2[2]<<19);
           73  +   if( !vis[u] ) {
           74  +    Q.push( edge(t+nzMin,u) );
           75  +   }
           76  +  }
           77  + }
           78  + return vector<int>(ans.begin(), ans.end());
           79  +}
           80  +
           81  +class SandTimers
           82  +{
           83  +public:
           84  + vector <int> badIntervals(vector <int> timers, int maxInterval, int maxTime)
           85  + {
           86  +  N = timers.size();
           87  +  A = timers;
           88  +  return dijkstra_like( vert(), maxTime, maxInterval );
           89  + }
           90  +};
           91  +
           92  +// BEGIN CUT HERE
           93  +#include <ctime>
           94  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           95  +
           96  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           97  +int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           98  +
           99  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          100  +char Test_(...);
          101  +int Test_(Case_<0>) {
          102  + int timers_[] = { 5, 7 };
          103  +   vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_));
          104  + int maxInterval = 10;
          105  + int maxTime = 10;
          106  + int RetVal_[] = {1, 6, 8 };
          107  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          108  + return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
          109  +int Test_(Case_<1>) {
          110  + int timers_[] = { 2, 10, 20 };
          111  +   vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_));
          112  + int maxInterval = 30;
          113  + int maxTime = 40;
          114  + int RetVal_[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29 };
          115  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          116  + return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
          117  +int Test_(Case_<2>) {
          118  + int timers_[] = { 2, 5, 9 };
          119  +   vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_));
          120  + int maxInterval = 360;
          121  + int maxTime = 360;
          122  + vector <int> RetVal;
          123  + return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
          124  +int Test_(Case_<3>) {
          125  + int timers_[] = { 4 };
          126  +   vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_));
          127  + int maxInterval = 23;
          128  + int maxTime = 47;
          129  + int RetVal_[] = {1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 18, 19, 21, 22, 23 };
          130  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          131  + return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
          132  +int Test_(Case_<4>) {
          133  + int timers_[] = { 20, 13 };
          134  +   vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_));
          135  + int maxInterval = 30;
          136  + int maxTime = 30;
          137  + int RetVal_[] = {1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 28, 29, 30 };
          138  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          139  + return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
          140  +int Test_(Case_<5>) {
          141  + int timers_[] = { 20, 17, 13 };
          142  +   vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_));
          143  + int maxInterval = 25;
          144  + int maxTime = 30;
          145  + int RetVal_[] = {18, 19 };
          146  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          147  + return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
          148  +int Test_(Case_<6>) {
          149  + int timers_[] = { 20, 20, 19 };
          150  +   vector <int> timers(timers_, timers_+sizeof(timers_)/sizeof(*timers_));
          151  + int maxInterval = 360;
          152  + int maxTime = 360;
          153  + vector <int> RetVal;
          154  + return verify_case(RetVal, SandTimers().badIntervals(timers, maxInterval, maxTime)); }
          155  +
          156  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          157  +template<>      void Run_<-1>() {}
          158  +int main() { Run_<0>(); }
          159  +// END CUT HERE
          160  +

Added SRM/264/1A.cpp version [7fcb01fe631559ac]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class DivisibilityRules
           19  +{
           20  +public:
           21  + int similar(int numerationBase, int divisor)
           22  + {
           23  +  vector< vector<int> > mb;
           24  +  for(int k=2; k<numerationBase; ++k)
           25  +   mb.push_back( mbase(numerationBase, k) );
           26  +  return count( mb.begin(), mb.end(), mb[divisor-2] );
           27  + }
           28  +
           29  + vector<int> mbase(int n, int k)
           30  + {
           31  +  vector<int> r;
           32  +  int b = 1;
           33  +  for(int i=0; i<n; ++i) {
           34  +   r.push_back(b);
           35  +   b = (b*n)%k;
           36  +  }
           37  +  return r;
           38  + }
           39  +
           40  +// BEGIN CUT HERE
           41  + public:
           42  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
           43  + private:
           44  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           45  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           46  + void test_case_0() { int Arg0 = 10; int Arg1 = 3; int Arg2 = 2; verify_case(0, Arg2, similar(Arg0, Arg1)); }
           47  + void test_case_1() { int Arg0 = 10; int Arg1 = 5; int Arg2 = 2; verify_case(1, Arg2, similar(Arg0, Arg1)); }
           48  + void test_case_2() { int Arg0 = 511; int Arg1 = 32; int Arg2 = 10; verify_case(2, Arg2, similar(Arg0, Arg1)); }
           49  + void test_case_3() { int Arg0 = 3; int Arg1 = 2; int Arg2 = 1; verify_case(3, Arg2, similar(Arg0, Arg1)); }
           50  + void test_case_4() { int Arg0 = 1000; int Arg1 = 999; int Arg2 = 7; verify_case(4, Arg2, similar(Arg0, Arg1)); }
           51  + void test_case_5() { int Arg0 = 655; int Arg1 = 532; int Arg2 = 1; verify_case(5, Arg2, similar(Arg0, Arg1)); }
           52  +
           53  +// END CUT HERE
           54  +};
           55  +// BEGIN CUT HERE
           56  +int main() { DivisibilityRules().run_test(-1); }
           57  +// END CUT HERE

Added SRM/264/1B.cpp version [936ab331eda74764]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +int gcd(int x, int y)
           19  +{
           20  + while(y) {
           21  +  int t = x;
           22  +  x = y;
           23  +  y = t%y;
           24  + }
           25  + return x;
           26  +}
           27  +
           28  +class GradingGridIns
           29  +{
           30  +public:
           31  + vector <string> score(vector <string> answer, vector <int> lower, vector <int> upper)
           32  + {
           33  +  int lg = gcd(lower[0], lower[1]);
           34  +  double la=lower[0]/lg, lb=lower[1]/lg;
           35  +  int ug = gcd(upper[0], upper[1]);
           36  +  double ua=upper[0]/ug, ub=upper[1]/ug;
           37  +
           38  +  vector<double> world;
           39  +
           40  +  char c[] = " ./0123456789";
           41  +  for(int i=0; i<sizeof(c)-1; ++i)
           42  +  for(int j=0; j<sizeof(c)-1; ++j)
           43  +  for(int k=0; k<sizeof(c)-1; ++k)
           44  +  for(int l=0; l<sizeof(c)-1; ++l) {
           45  +   try {
           46  +    double d = eval( string(1,c[i])+c[j]+c[k]+c[l] );
           47  +    world.push_back(d);
           48  +   } catch( const char* ) {
           49  +   }
           50  +  }
           51  +
           52  +  sort(world.begin(), world.end());
           53  +  world.erase(unique(world.begin(), world.end()), world.end());
           54  +  vector<double>::iterator lt = lower_bound( world.begin(), world.end(), la/lb );
           55  +  vector<double>::iterator ut = upper_bound( world.begin(), world.end(), ua/ub );
           56  +  if( lt!=world.begin() ) --lt;
           57  +
           58  +  vector<string> result(answer.size());
           59  +  for(int i=0; i<answer.size(); ++i)
           60  +  {
           61  +   try {
           62  +    double d = eval(answer[i]);
           63  +    result[i] = (*lt<=d && (ut==world.end() || d<=*ut) ? "CORRECT" : "INCORRECT");
           64  +   } catch( const char* ) {
           65  +    result[i] = "MALFORMED";
           66  +   }
           67  +  }
           68  +  return result;
           69  + }
           70  +
           71  + static double eval( string ans )
           72  + {
           73  +  int ii=0; while(ii<ans.size()&&ans[ii]==' ') ++ii;
           74  +  ans = ans.substr(ii);
           75  +  ii = ans.size(); while(ii>0 && ans[ii-1]==' ') --ii;
           76  +  ans = ans.substr(0, ii);
           77  +
           78  +
           79  +  int dot=-1, sla=-1, numdig=0;
           80  +  int value = 0, value_pre = 0;
           81  +  for(int i=0; i<ans.size(); ++i)
           82  +   if( ans[i]=='.' )
           83  +   {
           84  +    if(dot>=0 || sla>=0)
           85  +     throw "MALFORMED";
           86  +    dot = i;
           87  +    value_pre = value;
           88  +    value = 0;
           89  +   }
           90  +   else if( ans[i]=='/' )
           91  +   {
           92  +    if(dot>=0 || sla>=0 || numdig==0 )
           93  +     throw "MALFORMED";
           94  +    sla = i;
           95  +    value_pre = value;
           96  +    value = 0;
           97  +   }
           98  +   else if( '0'<=ans[i] && ans[i]<='9' )
           99  +   {
          100  +    ++numdig;
          101  +    value = value*10 + ans[i]-'0';
          102  +   }
          103  +   else
          104  +    throw "MALFORMED";
          105  +  if(numdig==0)
          106  +   throw "MALFORMED";
          107  +
          108  +  int L = value_pre, R = value;
          109  +  if( sla >= 0 ) {
          110  +   if( R == 0 )
          111  +    throw "MALFORMED";
          112  +   int g = gcd(L,R); L/=g, R/=g;
          113  +   return L/double(R);
          114  +  }
          115  +  else if( dot >= 0 ) {
          116  +   return L + R / pow(10.0, double(ans.size()-dot-1));
          117  +  }
          118  +  else {
          119  +   return R;
          120  +  }
          121  + }
          122  +
          123  +
          124  +// BEGIN CUT HERE
          125  + public:
          126  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
          127  + private:
          128  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          129  + void verify_case(int Case, const vector <string> &Expected, const vector <string> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
          130  + void test_case_0() { string Arr0[] = {"4/7 "," 4/7","4/07","8/14",".571",".572"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {4,7}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {4,7}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"CORRECT", "CORRECT", "CORRECT", "CORRECT", "CORRECT", "CORRECT" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(0, Arg3, score(Arg0, Arg1, Arg2)); }
          131  + void test_case_1() { string Arr0[] = {" 4/7","1.01","1.02"," 000"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"CORRECT", "CORRECT", "INCORRECT", "CORRECT" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(1, Arg3, score(Arg0, Arg1, Arg2)); }
          132  + void test_case_2() { string Arr0[] = {"1.15","1 14","1.14"," 8/7"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1142,1000}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1142,1000}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"INCORRECT", "MALFORMED", "CORRECT", "CORRECT" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(2, Arg3, score(Arg0, Arg1, Arg2)); }
          133  + void test_case_3() { string Arr0[] = {"    ","...."," .  ","1 23","8//5","9.4.","85/ ","/123","123/"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED", "MALFORMED" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(3, Arg3, score(Arg0, Arg1, Arg2)); }
          134  + void test_case_4() { string Arr0[] = {"1/0 "}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {9999,1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); string Arr3[] = {"MALFORMED" }; vector <string> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); verify_case(4, Arg3, score(Arg0, Arg1, Arg2)); }
          135  +
          136  +// END CUT HERE
          137  +};
          138  +// BEGIN CUT HERE
          139  +int main() { GradingGridIns().run_test(-1); }
          140  +// END CUT HERE

Added SRM/264/1C.cpp version [b836622385c9a165]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class PolygonDecomposition
           19  +{
           20  +public:
           21  + int howMany(int n, int k)
           22  + {
           23  +  if( n-2 < k )
           24  +   return -1;
           25  +
           26  +  LL dp[101][101] = {};
           27  +  dp[2][0] = 1;
           28  +  for(int N=3; N<=n; ++N)
           29  +   dp[N][1] = 1;
           30  +
           31  +  for(int N=4; N<=n; ++N)
           32  +  for(int K=2; K<=k; ++K)
           33  +  {
           34  +   LL sum = 0;
           35  +   for(LL v=3; v<=N-1; ++v) // use 1--v and don't use 1--3, ..., 1--(v-1)
           36  +    for(int x=1; x<=K-1; ++x) // left: x pieces, right: K-x pieces
           37  +     sum += (dp[v-1][x-1]+dp[v-1][x]) * dp[N-v+2][K-x] % 1000000000;
           38  +
           39  +   // don't use 1--*; if use 2--N, we'll have dp[N-1][K-1] cuts
           40  +   //                 otherwise, will have dp[N-1][K] because 2--1--N
           41  +   //                            can be regarded as a single edge
           42  +   sum += dp[N-1][K-1] + dp[N-1][K];
           43  +   dp[N][K] = sum % 1000000000;
           44  +  }
           45  +  return (int) dp[n][k];
           46  + }
           47  +
           48  +
           49  +// BEGIN CUT HERE
           50  + public:
           51  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           52  + private:
           53  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           54  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           55  + void test_case_0() { int Arg0 = 4; int Arg1 = 2; int Arg2 = 2; verify_case(0, Arg2, howMany(Arg0, Arg1)); }
           56  + void test_case_1() { int Arg0 = 100; int Arg1 = 1; int Arg2 = 1; verify_case(1, Arg2, howMany(Arg0, Arg1)); }
           57  + void test_case_2() { int Arg0 = 6; int Arg1 = 4; int Arg2 = 14; verify_case(2, Arg2, howMany(Arg0, Arg1)); }
           58  + void test_case_3() { int Arg0 = 31; int Arg1 = 20; int Arg2 = 956146480; verify_case(3, Arg2, howMany(Arg0, Arg1)); }
           59  + void test_case_4() { int Arg0 = 3; int Arg1 = 4; int Arg2 = -1; verify_case(4, Arg2, howMany(Arg0, Arg1)); }
           60  +
           61  +// END CUT HERE
           62  +};
           63  +// BEGIN CUT HERE
           64  +int main() { PolygonDecomposition().run_test(-1); }
           65  +// END CUT HERE

Added SRM/282/1A.cpp version [284412eb45068628]

            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 TileCutting {
           23  +public:
           24  + int cuts(vector <string> layout)
           25  + {
           26  +  int san=0, ni=0, ic=0;
           27  +  for(int y=0; y<layout.size(); y+=2)
           28  +   for(int x=0; x<layout[0].size(); x+=2)
           29  +   {
           30  +    string s = layout[y].substr(x,2) + layout[y+1].substr(x,2);
           31  +    if( s==".xxx" || s=="x.xx" || s=="xx.x" || s=="xxx." )
           32  +     ic++;
           33  +    else if( s=="..xx" || s=="x.x." || s=="xx.." || s==".x.x" )
           34  +     ni++;
           35  +    else if( s=="x..x" || s==".xx." )
           36  +     ic+=2;
           37  +    else if( s=="x..." || s==".x.." || s=="..x." || s=="...x" )
           38  +     san++;
           39  +   }
           40  +  int mincut=0x7fffffff;
           41  +  for(int nk=0; nk<=san; ++nk)
           42  +   if(nk+nk/3>=san)
           43  +    mincut = min(mincut, calc(san,ni,ic,nk));
           44  +  return mincut;
           45  + }
           46  +
           47  + int calc(int san, int ni, int ic, int nk) {
           48  +  // create nk pieces of L-shaped block
           49  +  // reuse nk pieces of single-block to form the rest of neede L-blocks
           50  +  int cut   = nk*2;
           51  +  int piece = nk-(san-nk)*3;  // single-block piecese left
           52  +
           53  +  // form single-blocks
           54  +  int pi = min(ic, piece);
           55  +  ic    -= pi;
           56  +  piece -= pi;
           57  +
           58  +  // if still left, use single-blocks to form I-shaped blocks
           59  +  if( piece )
           60  +  {
           61  +   ni    -= piece/2;
           62  +   piece -= piece/2*2;
           63  +  }
           64  +
           65  +  // create I-shaped blocks
           66  +  int xpiece = 0;
           67  +  if(ni) {
           68  +   cut  +=  (ni+1)/2*2;
           69  +   xpiece = ni%2 ? 1 : 0;
           70  +  }
           71  +
           72  +  // create single-blocks
           73  +  pi = min(ic, piece);
           74  +  ic    -= pi;
           75  +  piece -= pi;
           76  +  if( ic ) {
           77  +   if( xpiece ) ic-=2, cut+=1;
           78  +   if(ic>0)
           79  +    cut += ic/4*4 + ic%4 + (ic%4==0 ? 0 : 1);
           80  +  }
           81  +  return cut;
           82  + }
           83  +};
           84  +
           85  +// BEGIN CUT HERE
           86  +#include <ctime>
           87  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           88  +
           89  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           90  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           91  +
           92  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           93  +char Test_(...);
           94  +int Test_(Case_<0>) {
           95  + string layout_[] = { "..",
           96  +  ".." };
           97  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
           98  + int RetVal = 0;
           99  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          100  +int Test_(Case_<1>) {
          101  + string layout_[] = { "x.",
          102  +  ".." };
          103  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
          104  + int RetVal = 2;
          105  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          106  +int Test_(Case_<2>) {
          107  + string layout_[] = { ".x",
          108  +  "xx" };
          109  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
          110  + int RetVal = 2;
          111  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          112  +int Test_(Case_<3>) {
          113  + string layout_[] = { "xxxx..xxxx",
          114  +  "x..x..xx..",
          115  +  "x..xxxxx..",
          116  +  "xxxxxxxxxx" };
          117  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
          118  + int RetVal = 6;
          119  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          120  +int Test_(Case_<4>) {
          121  + string layout_[] = { "xxxxxx",
          122  +  "x....x" };
          123  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
          124  + int RetVal = 3;
          125  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          126  +int Test_(Case_<5>) {
          127  + string layout_[] = { "x..x....",
          128  +  "x..xx...",
          129  +  "..xx....",
          130  +  "...x....",
          131  +  "......xx",
          132  +  "......xx" };
          133  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
          134  + int RetVal = 4;
          135  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          136  +int Test_(Case_<6>) {
          137  + string layout_[] = { "x..xx.x..x.xx..x.xx.",
          138  +  "..x..x..x.x..xx...x.",
          139  +  ".xx...x...x...x..x..",
          140  +  ".xx...x.x.x...x..xx.",
          141  +  ".x..x...x.....x...x.",
          142  +  ".x.x.x..x..x..x..x.x",
          143  +  "...x.x.x.x.x.x.x...x",
          144  +  ".x..x..x...x..x...x.",
          145  +  "...x.x.x..x.x.x.....",
          146  +  "...x.x.x..x.x.xxx.x.",
          147  +  "xx.xx.xx.x.x.x.x..x.",
          148  +  ".x..xxx...x.xx...x.x",
          149  +  "xx..x.x...x.x.x.x..x",
          150  +  ".xx..x.xx.xxxxx...xx",
          151  +  "x....x.x...x...x.x..",
          152  +  ".x.xx.x..x.x.xxx.x..",
          153  +  "...xx.xxx.....xx.xxx",
          154  +  ".xx..x..xx.x...x.xx.",
          155  +  "x.x...x.x.xx.x..x.xx",
          156  +  ".....xx.x.......xx.x",
          157  +  "x...x.xx.x..x....x..",
          158  +  ".x..xxx.....x.x.x.xx" }
          159  +;
          160  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
          161  + int RetVal = 121;
          162  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          163  +int Test_(Case_<7>) {
          164  + string layout_[] = { "..................................................",
          165  +  "..................................................",
          166  +  "..................................................",
          167  +  "..................................................",
          168  +  "..................................................",
          169  +  "..................................................",
          170  +  "..................................................",
          171  +  "..................................................",
          172  +  "..................................................",
          173  +  "..................................................",
          174  +  "..................................................",
          175  +  "..................................................",
          176  +  "..................................................",
          177  +  "..................................................",
          178  +  "..................................................",
          179  +  "..................................................",
          180  +  "..................................................",
          181  +  "..................................................",
          182  +  "..................................................",
          183  +  "..................................................",
          184  +  "..................................................",
          185  +  "..................................................",
          186  +  "..................................................",
          187  +  "..................................................",
          188  +  "..................................................",
          189  +  "..................................................",
          190  +  "..................................................",
          191  +  "..................................................",
          192  +  "..................................................",
          193  +  "..................................................",
          194  +  "..................................................",
          195  +  "..................................................",
          196  +  "..................................................",
          197  +  "..................................................",
          198  +  "..................................................",
          199  +  "..................................................",
          200  +  "..................................................",
          201  +  "..................................................",
          202  +  "..................................................",
          203  +  "..................................................",
          204  +  "..................................................",
          205  +  "..................................................",
          206  +  "..................................................",
          207  +  "..................................................",
          208  +  "..................................................",
          209  +  "..................................................",
          210  +  "..................................................",
          211  +  "..................................................",
          212  +  "..................................................",
          213  +  ".................................................." }
          214  +;
          215  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
          216  + int RetVal = 0;
          217  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          218  +int Test_(Case_<8>) {
          219  + string layout_[] =
          220  +{"x..x...x...x..x....x",
          221  + ".x..x.xxx....xx..x..",
          222  + "..x...x..x...xxx....",
          223  + "x....x.....xx..xx...",
          224  + "..x.x...x..x........",
          225  + ".x...xx.xx...xxx...x",
          226  + "x..x.x......xx.x....",
          227  + "...xxx.....x.x..xx.."}
          228  +;
          229  +   vector <string> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
          230  + int RetVal = 44;
          231  + return verify_case(RetVal, TileCutting().cuts(layout)); }
          232  +
          233  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          234  +template<>      void Run_<-1>() {}
          235  +int main() { Run_<0>(); }
          236  +// END CUT HERE
          237  +

Added SRM/282/1B.cpp version [0008d0ab74cb7d3e]

            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  +int gcd(int a, int b) {
           23  + while(a) swap(a,b%=a); return b;
           24  +}
           25  +
           26  +class Fractionalization {
           27  +public:
           28  + vector <string> partial(vector <string> definitions, int m, int n, string danceCall)
           29  + {
           30  +  // input
           31  +  map< string, vector<string> > D;
           32  +  for(int i=0; i<definitions.size(); ++i) {
           33  +   stringstream sin(definitions[i]);
           34  +   string name; sin>>name; name=name.substr(0, name.size()-1);
           35  +   vector<string> ds;
           36  +   for(string d; sin>>d;)
           37  +    ds.push_back(d);
           38  +   D[name] = ds;
           39  +  }
           40  +
           41  +  // solve
           42  +  vector<string> result;
           43  +  while(m) {
           44  +   if( !D.count(danceCall) )
           45  +    return vector<string>(1, "ILLEGAL");
           46  +   vector<string>& d = D[danceCall];
           47  +   int q = d.size();
           48  +   int z = m*q/n;
           49  +   for(int i=0; i<z; ++i)
           50  +    result.push_back(d[i]);
           51  +   m = m*q - z*n;
           52  +   danceCall = d[z];
           53  +  }
           54  +  return result;
           55  + }
           56  +};
           57  +
           58  +// BEGIN CUT HERE
           59  +#include <ctime>
           60  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           61  +
           62  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           63  +int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           64  +
           65  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           66  +char Test_(...);
           67  +int Test_(Case_<0>) {
           68  + string definitions_[] = { "FiveParts: One Two Three Four Five" };
           69  +   vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_));
           70  + int m = 2;
           71  + int n = 5;
           72  + string danceCall = "FiveParts";
           73  + string RetVal_[] = {"One", "Two" };
           74  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           75  + return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
           76  +int Test_(Case_<1>) {
           77  + string definitions_[] = { "Trade: Hinge Hinge",
           78  +  "TradeThreeTimes: Trade Trade Trade" };
           79  +   vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_));
           80  + int m = 5;
           81  + int n = 6;
           82  + string danceCall = "TradeThreeTimes";
           83  + string RetVal_[] = {"Trade", "Trade", "Hinge" };
           84  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           85  + return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
           86  +int Test_(Case_<2>) {
           87  + string definitions_[] = { "Trade: Hinge Hinge",
           88  +  "CenterTwoTrade: CenterTwoHinge CenterTwoHinge",
           89  +  "SpinTheTop: Trade FanTheTop",
           90  +  "HotFootSpin: FanTheTop CenterTwoTrade SpinTheTop" };
           91  +   vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_));
           92  + int m = 1;
           93  + int n = 2;
           94  + string danceCall = "HotFootSpin";
           95  + string RetVal_[] = {"FanTheTop", "CenterTwoHinge" };
           96  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           97  + return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
           98  +int Test_(Case_<3>) {
           99  + string definitions_[] = { "Trade: Hinge Hinge",
          100  +  "CenterTwoTrade: CenterTwoHinge CenterTwoHinge",
          101  +  "SpinTheTop: Trade FanTheTop",
          102  +  "HotFootSpin: FanTheTop CenterTwoTrade SpinTheTop" };
          103  +   vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_));
          104  + int m = 3;
          105  + int n = 4;
          106  + string danceCall = "HotFootSpin";
          107  + string RetVal_[] = {"FanTheTop", "CenterTwoTrade", "Hinge" };
          108  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          109  + return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
          110  +int Test_(Case_<4>) {
          111  + string definitions_[] = { "A: One Two",
          112  +  "B: One Two Three",
          113  +  "C: One Two Three Four" };
          114  +   vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_));
          115  + int m = 3;
          116  + int n = 4;
          117  + string danceCall = "C";
          118  + string RetVal_[] = {"One", "Two", "Three" };
          119  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          120  + return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
          121  +int Test_(Case_<5>) {
          122  + string definitions_[] = { "A: X Y Z",
          123  +  "B: A A A" };
          124  +   vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_));
          125  + int m = 7;
          126  + int n = 23;
          127  + string danceCall = "B";
          128  + string RetVal_[] = {"ILLEGAL" };
          129  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          130  + return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
          131  +int Test_(Case_<6>) {
          132  + string definitions_[] = { "A: B C",
          133  +  "D: E F" };
          134  +   vector <string> definitions(definitions_, definitions_+sizeof(definitions_)/sizeof(*definitions_));
          135  + int m = 1;
          136  + int n = 2;
          137  + string danceCall = "G";
          138  + string RetVal_[] = {"ILLEGAL" };
          139  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          140  + return verify_case(RetVal, Fractionalization().partial(definitions, m, n, danceCall)); }
          141  +
          142  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          143  +template<>      void Run_<-1>() {}
          144  +int main() { Run_<0>(); }
          145  +// END CUT HERE
          146  +

Added SRM/282/1C.cpp version [c1dd4b267114bf1f]

            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 GreatExpectations {
           23  +public:
           24  + double expectedTime(vector <string> doors)
           25  + {
           26  +  const int Y = doors.size()/2  +1;
           27  +  const int X = doors[0].size() +1;
           28  +
           29  +  vector< vector<double> > e(Y, vector<double>(X, -1.0));
           30  +  e[Y-1][X-1] = 0.0;
           31  +
           32  +  for(int k=0; k<X*Y; ++k)
           33  +   for(int y=0; y<Y; ++y)
           34  +    for(int x=0; x<X; ++x)
           35  +    {
           36  +     // neibours : (expected_time, door_prob)
           37  +     vector< pair<double,double> > ep;
           38  +     if( x+1<X && doors[y*2][x]!='0' && e[y][x+1]>=0 )
           39  +      ep.push_back( make_pair(e[y][x+1], (doors[y*2][x]-'0')/8.0) );
           40  +     if( 0<x && doors[y*2][x-1]!='0' && e[y][x-1]>=0 )
           41  +      ep.push_back( make_pair(e[y][x-1], (doors[y*2][x-1]-'0')/8.0) );
           42  +     if( y+1<Y && doors[y*2+1][x]!='0' && e[y+1][x]>=0 )
           43  +      ep.push_back( make_pair(e[y+1][x], (doors[y*2+1][x]-'0')/8.0) );
           44  +     if( 0<y && doors[y*2-1][x]!='0' && e[y-1][x]>=0 )
           45  +      ep.push_back( make_pair(e[y-1][x], (doors[y*2-1][x]-'0')/8.0) );
           46  +
           47  +     if( ep.empty() ) continue;
           48  +     sort( ep.begin(), ep.end() ); // better first
           49  +
           50  +     // choose k that minimizes the following E:
           51  +     //   E = (1+e[0])*p[0]
           52  +     //     + (1+e[1])*(1-p[0])*p[1]
           53  +     //     + (1+e[2])*(1-p[0])*(1-p[1])*p[2]
           54  +     //     + ...
           55  +     //     + (1+E)   *(1-p[0])*(1-p[1])*...*(1-p[k])
           56  +     double r=1.0, s=0.0, E=1e+50;
           57  +     for(int i=0; i<ep.size(); ++i) {
           58  +      double s2 = s + r * ep[i].second * (1 + ep[i].first);
           59  +      double r2 = r * (1 - ep[i].second);
           60  +      double E2 = (s2 + r2) / (1-r2);
           61  +      if( E2 > E ) break;
           62  +      r=r2, s=s2, E=E2;
           63  +     }
           64  +     if( e[y][x]<0 || e[y][x]>E )
           65  +      e[y][x]=E;
           66  +    }
           67  +
           68  +  return e[0][0];
           69  + }
           70  +};
           71  +
           72  +// BEGIN CUT HERE
           73  +#include <ctime>
           74  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           75  +
           76  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           77  +int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           78  +
           79  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           80  +char Test_(...);
           81  +int Test_(Case_<0>) {
           82  + string doors_[] = { "4",
           83  +  "44",
           84  +  "4" };
           85  +   vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_));
           86  + double RetVal = 3.3333333333333335;
           87  + return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
           88  +int Test_(Case_<1>) {
           89  + string doors_[] = { "48",
           90  +  "440",
           91  +  "42",
           92  +  "862",
           93  +  "06" };
           94  +   vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_));
           95  + double RetVal = 6.0;
           96  + return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
           97  +int Test_(Case_<2>) {
           98  + string doors_[] = { "0808",
           99  +  "88888",
          100  +  "0000",
          101  +  "88888",
          102  +  "8080" }
          103  +;
          104  +   vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_));
          105  + double RetVal = 14.0;
          106  + return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
          107  +int Test_(Case_<3>) {
          108  + string doors_[] = { "2815",
          109  +  "67686",
          110  +  "1324",
          111  +  "75767",
          112  +  "6051" }
          113  +;
          114  +   vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_));
          115  + double RetVal = 11.852782338798935;
          116  + return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
          117  +int Test_(Case_<4>) {
          118  + string doors_[] = { "823",
          119  +  "2630",
          120  +  "130" }
          121  +;
          122  +   vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_));
          123  + double RetVal = -1.0;
          124  + return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
          125  +int Test_(Case_<5>) {
          126  + string doors_[] = { "0",
          127  +  "44",
          128  +  "4" }
          129  +;
          130  +   vector <string> doors(doors_, doors_+sizeof(doors_)/sizeof(*doors_));
          131  + double RetVal = 4.0;
          132  + return verify_case(RetVal, GreatExpectations().expectedTime(doors)); }
          133  +
          134  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          135  +template<>      void Run_<-1>() {}
          136  +int main() { Run_<0>(); }
          137  +// END CUT HERE
          138  +

Added SRM/330/1A.cpp version [2cfe42a5f5982f84]

            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 Arrows { public:
           23  + int longestArrow(string s)
           24  + {
           25  +  string rs = s;
           26  +  reverse(rs.begin(), rs.end());
           27  +  return max(max(la(s,'<','-'), la(s,'<','=')), max(la(rs,'>','-'), la(rs,'>','=')));
           28  + }
           29  + int la(string s, char h, char t)
           30  + {
           31  +  int m = -1;
           32  +  for(int i=0; i<s.size(); ++i)
           33  +   if( s[i]==h ) {
           34  +    int j=i+1;
           35  +    while( j<s.size() && s[j]==t )
           36  +     ++j;
           37  +    m = max(m, j-i);
           38  +   }
           39  +  return m;
           40  + }
           41  +};
           42  +
           43  +// BEGIN CUT HERE
           44  +#include <ctime>
           45  +double start_time; string timer()
           46  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           47  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           48  + { os << "{ ";
           49  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           50  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           51  +void verify_case(const int& Expected, const int& Received) {
           52  + bool ok = (Expected == Received);
           53  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           54  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           55  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           56  +#define END  verify_case(_, Arrows().longestArrow(s));}
           57  +int main(){
           58  +
           59  +CASE(0)
           60  + string s = "<--->--==>";
           61  + int _ = 4;
           62  +END
           63  +CASE(1)
           64  + string s = "<<<<<<<<<<";
           65  + int _ = 1;
           66  +END
           67  +CASE(2)
           68  + string s = "----==-";
           69  + int _ = -1;
           70  +END
           71  +CASE(3)
           72  + string s = "<----=====>";
           73  + int _ = 6;
           74  +END
           75  +
           76  +}
           77  +// END CUT HERE

Added SRM/330/1B.cpp version [0980b7195d8f96ca]

            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 byLength {
           23  + bool operator()(const string& lhs, const string& rhs) const {
           24  +  if(lhs.size() != rhs.size()) return lhs.size() < rhs.size();
           25  +  return lhs < rhs;
           26  + }
           27  +};
           28  +class PrefixFreeSubsets { public:
           29  + long long cantPrefFreeSubsets(vector <string> words)
           30  + {
           31  +  int N = words.size();
           32  +  sort(words.begin(), words.end(), byLength());
           33  +
           34  +  vector< vector<int> > dc;
           35  +  for(int i=0; i<N; ++i)
           36  +   dc.push_back( direct_children(words[i], words, i+1) );
           37  +  dc.push_back( direct_children("", words, 0) );
           38  +  return rec(N, dc) - 1;
           39  + }
           40  +
           41  + LL rec(int t, vector< vector<int> >& dc )
           42  + {
           43  +  LL p = 1;
           44  +  for(int i=0; i<dc[t].size(); ++i)
           45  +   p *= rec(dc[t][i], dc);
           46  +  return p+1;
           47  + }
           48  +
           49  + bool is_prefix(const string& pre, const string& all) {
           50  +  return equal(pre.begin(), pre.end(), all.begin());
           51  + }
           52  +
           53  + vector<int> direct_children(const string& s, vector<string>& w, int i) {
           54  +  vector<int> ans;
           55  +  for(; i<w.size(); ++i)
           56  +   if( is_prefix(s,w[i]) ){
           57  +    bool direct = true;
           58  +    for(int j=0; j<ans.size(); ++j)
           59  +     direct = direct && !is_prefix(w[ans[j]], w[i]);
           60  +    if( direct )
           61  +     ans.push_back(i);
           62  +   }
           63  +  return ans;
           64  + }
           65  +};
           66  +
           67  +// BEGIN CUT HERE
           68  +#include <ctime>
           69  +double start_time; string timer()
           70  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           71  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           72  + { os << "{ ";
           73  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           74  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           75  +void verify_case(const long long& Expected, const long long& Received) {
           76  + bool ok = (Expected == Received);
           77  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           78  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           79  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           80  +#define END  verify_case(_, PrefixFreeSubsets().cantPrefFreeSubsets(words));}
           81  +int main(){
           82  +
           83  +CASE(0)
           84  + string words_[] = {"hello","hell","hi"};
           85  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
           86  + long long _ = 6LL;
           87  +END
           88  +CASE(1)
           89  + string words_[] = {"a","b","c","d"};
           90  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
           91  + long long _ = 16LL;
           92  +END
           93  +CASE(2)
           94  + string words_[] = {"a","ab","abc","abcd","abcde","abcdef"};
           95  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
           96  + long long _ = 7LL;
           97  +END
           98  +CASE(3)
           99  + string words_[] = {"a","b","aa","ab","ba","bb"};
          100  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          101  + long long _ = 25LL;
          102  +END
          103  +
          104  +}
          105  +// END CUT HERE

Added SRM/330/1C.cpp version [9065451ab4e56b9f]

            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 LongLongNim { public:
           23  + int numberOfWins(int maxN, vector <int> moves)
           24  + {
           25  +  int FULL = (1 << *max_element(moves.begin(), moves.end())) - 1;
           26  +  int MASK = 0;
           27  +  for(int i=0; i<moves.size(); ++i)
           28  +   MASK |= 1 << (moves[i]-1);
           29  +
           30  +  vector<int> ss;
           31  +  vector<int> visited(FULL+1, -1);
           32  +  for(int i=1,s=1; i<=maxN; ++i)
           33  +  {
           34  +   s = (s<<1 | ((~s&MASK)==MASK)) & FULL;
           35  +   if( visited[s] >= 0 )
           36  +    return countBits(ss, visited[s], ss.size(), maxN);
           37  +   else
           38  +   {
           39  +    visited[s] = ss.size();
           40  +    ss.push_back(s&1);
           41  +   }
           42  +  }
           43  +  return countBits(ss, 0, maxN, maxN);
           44  + }
           45  +
           46  + int countBits(const vector<int>& b, int lb, int le, int N)
           47  + {
           48  +  // Given an infinite seq b[0] ... b[lb-1] (b[lb] ... b[le-1])*,
           49  +  // compute \Sigma b[0..N)
           50  +  int sum = 0;
           51  +  for(int i=0; i<lb; ++i)
           52  +   sum += b[i];
           53  +
           54  +  N -= lb;
           55  +  int ll = le - lb;
           56  +  int Q = N/ll;
           57  +  int R = N%ll;
           58  +  for(int i=lb; i<le; ++i)
           59  +   sum += b[i] * Q;
           60  +  for(int i=lb; i<lb+R; ++i)
           61  +   sum += b[i];
           62  +  return sum;
           63  + }
           64  +};
           65  +
           66  +// BEGIN CUT HERE
           67  +#include <ctime>
           68  +double start_time; string timer()
           69  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           70  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           71  + { os << "{ ";
           72  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           73  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           74  +void verify_case(const int& Expected, const int& Received) {
           75  + bool ok = (Expected == Received);
           76  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           77  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           78  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           79  +#define END  verify_case(_, LongLongNim().numberOfWins(maxN, moves));}
           80  +int main(){
           81  +
           82  +CASE(0)
           83  + int maxN = 20;
           84  + int moves_[] = {1,2,3};
           85  +   vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_));
           86  + int _ = 5;
           87  +END
           88  +CASE(1)
           89  + int maxN = 999;
           90  + int moves_[] = {1};
           91  +   vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_));
           92  + int _ = 499;
           93  +END
           94  +CASE(3)
           95  + int maxN = 6543;
           96  + int moves_[] = {2,4,7,11,20};
           97  +   vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_));
           98  + int _ = 1637;
           99  +END
          100  +CASE(2)
          101  + int maxN = 1000000000;
          102  + int moves_[] = {1,2};
          103  +   vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_));
          104  + int _ = 333333333;
          105  +END
          106  +/*
          107  +CASE(4)
          108  + int maxN = ;
          109  + int moves_[] = ;
          110  +   vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_));
          111  + int _ = ;
          112  +END
          113  +CASE(5)
          114  + int maxN = ;
          115  + int moves_[] = ;
          116  +   vector <int> moves(moves_, moves_+sizeof(moves_)/sizeof(*moves_));
          117  + int _ = ;
          118  +END
          119  +*/
          120  +}
          121  +// END CUT HERE

Added SRM/330/2C.cpp version [97604476ec6f9367]

            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 NextPalindromicNumber { public:
           23  + string getNext(string n)
           24  + {
           25  +  string s = mirror(n);
           26  +  if( n < s )
           27  +   return s;
           28  +  return mirror(plus1(s, (s.size()-1)/2));
           29  + }
           30  +
           31  + string mirror(const string& s)
           32  + {
           33  +  return string(s.begin(), s.begin()+s.size()/2) + string(s.rbegin()+s.size()/2, s.rend());
           34  + }
           35  +
           36  + string plus1(string s, int i)
           37  + {
           38  +  while( s[i] == '9' )
           39  +  {
           40  +   s[i--] = '0';
           41  +   if( i < 0 )
           42  +    return '1'+s;
           43  +  }
           44  +  s[i]++;
           45  +  return s;
           46  + }
           47  +};
           48  +
           49  +// BEGIN CUT HERE
           50  +#include <ctime>
           51  +double start_time; string timer()
           52  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           53  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           54  + { os << "{ ";
           55  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           56  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           57  +void verify_case(const string& Expected, const string& Received) {
           58  + bool ok = (Expected == Received);
           59  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           60  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           61  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           62  +#define END  verify_case(_, NextPalindromicNumber().getNext(n));}
           63  +int main(){
           64  +
           65  +CASE(0)
           66  + string n = "12345";
           67  + string _ = "12421";
           68  +END
           69  +CASE(1)
           70  + string n = "858";
           71  + string _ = "868";
           72  +END
           73  +CASE(2)
           74  + string n = "1999";
           75  + string _ = "2002";
           76  +END
           77  +CASE(3)
           78  + string n = "1";
           79  + string _ = "2";
           80  +END
           81  +CASE(4)
           82  + string n = "9999";
           83  + string _ = "10001";
           84  +END
           85  +/*
           86  +CASE(5)
           87  + string n = ;
           88  + string _ = ;
           89  +END
           90  +CASE(6)
           91  + string n = ;
           92  + string _ = ;
           93  +END
           94  +*/
           95  +}
           96  +// END CUT HERE

Added SRM/331/1A.cpp version [f62c58c81f050ba2]

            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 CarolsSinging {
           23  +public:
           24  + int choose(vector <string> lyrics)
           25  + {
           26  +  int nP = lyrics.size();
           27  +  int nS = lyrics[0].size();
           28  +  vector<int> people_who_know_the_song(nS);
           29  +  for(int s=0; s<nS; ++s)
           30  +   for(int p=0; p<nP; ++p)
           31  +    people_who_know_the_song[s] |= (lyrics[p][s]=='Y')<<p;
           32  +
           33  +  int minPop = nS;
           34  +  for(int m=1; m<(1<<nS); ++m)
           35  +  {
           36  +   int canSing = 0;
           37  +   for(int s=0; (1<<s)<=m; ++s)
           38  +    if( (1<<s) & m )
           39  +     canSing |= people_who_know_the_song[s];
           40  +   if( canSing == (1<<nP)-1 )
           41  +    minPop = min(minPop, __builtin_popcount(m));
           42  +  }
           43  +  return minPop;
           44  + }
           45  +};
           46  +
           47  +// BEGIN CUT HERE
           48  +#include <ctime>
           49  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           50  +
           51  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           52  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           53  +
           54  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           55  +char Test_(...);
           56  +int Test_(Case_<0>) {
           57  + string lyrics_[] = {"YN","NY"};
           58  +   vector <string> lyrics(lyrics_, lyrics_+sizeof(lyrics_)/sizeof(*lyrics_));
           59  + int RetVal = 2;
           60  + return verify_case(RetVal, CarolsSinging().choose(lyrics)); }
           61  +int Test_(Case_<1>) {
           62  + string lyrics_[] = {"YN","YY","YN"};
           63  +   vector <string> lyrics(lyrics_, lyrics_+sizeof(lyrics_)/sizeof(*lyrics_));
           64  + int RetVal = 1;
           65  + return verify_case(RetVal, CarolsSinging().choose(lyrics)); }
           66  +int Test_(Case_<2>) {
           67  + string lyrics_[] = {"YNN","YNY","YNY","NYY","NYY","NYN"};
           68  +   vector <string> lyrics(lyrics_, lyrics_+sizeof(lyrics_)/sizeof(*lyrics_));
           69  + int RetVal = 2;
           70  + return verify_case(RetVal, CarolsSinging().choose(lyrics)); }
           71  +int Test_(Case_<3>) {
           72  + string lyrics_[] = {"YNNYYY","YYNYYY","YNNYYN","NYYNNN","YYYNNN","YYYNNY","NYYYYY","NYNYYY","NNNNYY",
           73  + "YYYYYY","YNNNNN","YYYYNY","YYNNNN","NNYYYN","NNNNYY","YYYNNN","NYNNYN","YNNYYN",
           74  + "YYNNNY","NYYNNY","NNYYYN","YNYYYN","NNNYNY","YYYYNN","YYNYNN","NYYNYY","YYNYYN"};
           75  +   vector <string> lyrics(lyrics_, lyrics_+sizeof(lyrics_)/sizeof(*lyrics_));
           76  + int RetVal = 4;
           77  + return verify_case(RetVal, CarolsSinging().choose(lyrics)); }
           78  +
           79  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           80  +template<>      void Run_<-1>() {}
           81  +int main() { Run_<0>(); }
           82  +// END CUT HERE
           83  +

Added SRM/331/1B.cpp version [b050d3607f1a5bd8]

            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 Shopping {
           23  +public:
           24  + int minNumber(int X, vector <int> values)
           25  + {
           26  +  sort( values.begin(), values.end() );
           27  +
           28  +  int next=1, cnt=0;
           29  +  while( next <= X )
           30  +  {
           31  +   // maximum <= next;
           32  +   vector<int>::iterator it = upper_bound(values.begin(), values.end(), next);
           33  +   if( it == values.begin() )
           34  +    return -1;
           35  +   next += *(it-1);
           36  +   ++cnt;
           37  +  }
           38  +  return cnt;
           39  + }
           40  +};
           41  +
           42  +// BEGIN CUT HERE
           43  +#include <ctime>
           44  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           45  +
           46  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           47  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           48  +
           49  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           50  +char Test_(...);
           51  +int Test_(Case_<0>) {
           52  + int X = 20;
           53  + int values_[] = {1, 2, 5, 10};
           54  +   vector <int> values(values_, values_+sizeof(values_)/sizeof(*values_));
           55  + int RetVal = 5;
           56  + return verify_case(RetVal, Shopping().minNumber(X, values)); }
           57  +int Test_(Case_<1>) {
           58  + int X = 7;
           59  + int values_[] = {2, 4, 1, 7};
           60  +   vector <int> values(values_, values_+sizeof(values_)/sizeof(*values_));
           61  + int RetVal = 3;
           62  + return verify_case(RetVal, Shopping().minNumber(X, values)); }
           63  +int Test_(Case_<2>) {
           64  + int X = 20;
           65  + int values_[] = {2,4,6,8};
           66  +   vector <int> values(values_, values_+sizeof(values_)/sizeof(*values_));
           67  + int RetVal = -1;
           68  + return verify_case(RetVal, Shopping().minNumber(X, values)); }
           69  +int Test_(Case_<3>) {
           70  + int X = 600;
           71  + int values_[] = {1,2,3,10,11,30};
           72  +   vector <int> values(values_, values_+sizeof(values_)/sizeof(*values_));
           73  + int RetVal = 25;
           74  + return verify_case(RetVal, Shopping().minNumber(X, values)); }
           75  +
           76  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           77  +template<>      void Run_<-1>() {}
           78  +int main() { Run_<0>(); }
           79  +// END CUT HERE
           80  +

Added SRM/331/1C.cpp version [1922da4e015e264c]

            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  +typedef pair<int,int> pt;
           23  +typedef pair<int,int> range;
           24  +
           25  +class HiddenSquares {
           26  +public:
           27  + int count(vector <int> x1, vector <int> y1, vector <int> x2, vector <int> y2)
           28  + {
           29  +  vector< pair<int, range> > xseg, yseg;
           30  +  for(int i=0; i<x1.size(); ++i)
           31  +  {
           32  +   xseg.push_back( make_pair(x1[i], range(y1[i], y2[i])) );
           33  +   xseg.push_back( make_pair(x2[i], range(y1[i], y2[i])) );
           34  +   yseg.push_back( make_pair(y1[i], range(x1[i], x2[i])) );
           35  +   yseg.push_back( make_pair(y2[i], range(x1[i], x2[i])) );
           36  +  }
           37  +
           38  +  // copy and
           39  +  map<int, vector<range> > xray;
           40  +  for(int i=0; i<xseg.size(); ++i)
           41  +  {
           42  +   set<int> p;
           43  +
           44  +   p.insert(xseg[i].second.first);
           45  +   p.insert(xseg[i].second.second);
           46  +   for(int j=0; j<yseg.size(); ++j)
           47  +    if( xseg[i].second.first<=yseg[j].first && yseg[j].first<=xseg[i].second.second
           48  +     && yseg[j].second.first<=xseg[i].first && xseg[i].first<=yseg[j].second.second )
           49  +     p.insert( yseg[j].first );
           50  +
           51  +   int py = xseg[i].second.first;
           52  +   for(set<int>::iterator y=p.begin(); ++y!=p.end(); py=*y)
           53  +    xray[xseg[i].first].push_back( range(py,*y) );
           54  +  }
           55  +
           56  +  // paset!
           57  +  map<int, vector<range> > yray;
           58  +  for(int i=0; i<yseg.size(); ++i)
           59  +  {
           60  +   set<int> p;
           61  +
           62  +   p.insert(yseg[i].second.first);
           63  +   p.insert(yseg[i].second.second);
           64  +   for(int j=0; j<xseg.size(); ++j)
           65  +    if( yseg[i].second.first<=xseg[j].first && xseg[j].first<=yseg[i].second.second
           66  +     && xseg[j].second.first<=yseg[i].first && yseg[i].first<=xseg[j].second.second )
           67  +     p.insert( xseg[j].first );
           68  +
           69  +   int px = yseg[i].second.first;
           70  +   for(set<int>::iterator x=p.begin(); ++x!=p.end(); px=*x)
           71  +    yray[yseg[i].first].push_back( range(px,*x) );
           72  +  }
           73  +
           74  +  // copy and
           75  +  map< pt, set<pt> > xconn;
           76  +  for(map<int, vector< pt > >::iterator it=xray.begin(); it!=xray.end(); ++it)
           77  +  {
           78  +   int            x = it->first;
           79  +   vector<range>& r = it->second;
           80  +
           81  +   vector< pair<int,bool> > es;
           82  +   for(int i=0; i!=r.size(); ++i)
           83  +    es.push_back( make_pair(r[i].first,false) ),
           84  +    es.push_back( make_pair(r[i].second,true) );
           85  +   sort(es.begin(), es.end());
           86  +   vector<int> cur;
           87  +   int nest = 0;
           88  +   for(int i=0; i!=es.size(); ++i)
           89  +   {
           90  +    cur.push_back( es[i].first );
           91  +    es[i].second ? --nest : ++nest;
           92  +    if( nest == 0 )
           93  +    {
           94  +     for(int j=0; j<cur.size(); ++j)
           95  +      for(int k=j+1; k<cur.size(); ++k)
           96  +       if( cur[j] < cur[k] )
           97  +        xconn[pt(x,cur[j])].insert( pt(x,cur[k]) );
           98  +     cur.clear();
           99  +    }
          100  +   }
          101  +  }
          102  +
          103  +  // paste!
          104  +  map< pt, set<pt> > yconn;
          105  +  for(map<int, vector< pt > >::iterator it=yray.begin(); it!=yray.end(); ++it)
          106  +  {
          107  +   int            y = it->first;
          108  +   vector<range>& r = it->second;
          109  +
          110  +   vector< pair<int,bool> > es;
          111  +   for(int i=0; i!=r.size(); ++i)
          112  +    es.push_back( make_pair(r[i].first,false) ),
          113  +    es.push_back( make_pair(r[i].second,true) );
          114  +   sort(es.begin(), es.end());
          115  +
          116  +   vector<int> cur;
          117  +   int nest = 0;
          118  +   for(int i=0; i!=es.size(); ++i)
          119  +   {
          120  +    cur.push_back( es[i].first );
          121  +    es[i].second ? --nest : ++nest;
          122  +    if( nest == 0 )
          123  +    {
          124  +     for(int j=0; j<cur.size(); ++j)
          125  +      for(int k=j+1; k<cur.size(); ++k)
          126  +       if( cur[j] < cur[k] )
          127  +        yconn[pt(cur[j],y)].insert( pt(cur[k],y) );
          128  +     cur.clear();
          129  +    }
          130  +   }
          131  +  }
          132  +
          133  +  // count squares
          134  +  int cnt = 0;
          135  +  for(map< pt, set<pt> >::iterator it=xconn.begin(); it!=xconn.end(); ++it)
          136  +  {
          137  +   pt       p = it->first;
          138  +   set<pt>& c = it->second;
          139  +   for(set<pt>::iterator jt=c.begin(); jt!=c.end(); ++jt)
          140  +   {
          141  +    pt q = *jt;
          142  +    int w = q.second-p.second;
          143  +    pt p1(p.first+w,p.second);
          144  +    pt q1(q.first+w,q.second);
          145  +    if( yconn[p].count(p1) && yconn[q].count(q1) && xconn[p1].count(q1) )
          146  +     ++cnt;
          147  +   }
          148  +  }
          149  +  return cnt;
          150  + }
          151  +};
          152  +
          153  +// BEGIN CUT HERE
          154  +#include <ctime>
          155  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          156  +
          157  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          158  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          159  +
          160  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          161  +char Test_(...);
          162  +int Test_(Case_<0>) {
          163  + int x1_[] = {0,1,0};
          164  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          165  + int y1_[] = {0,0,1};
          166  +   vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_));
          167  + int x2_[] = {3,2,3};
          168  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          169  + int y2_[] = {3,3,2};
          170  +   vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_));
          171  + int RetVal = 14;
          172  + return verify_case(RetVal, HiddenSquares().count(x1, y1, x2, y2)); }
          173  +int Test_(Case_<1>) {
          174  + int x1_[] = {0,2};
          175  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          176  + int y1_[] = {0,0};
          177  +   vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_));
          178  + int x2_[] = {2,4};
          179  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          180  + int y2_[] = {4,4};
          181  +   vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_));
          182  + int RetVal = 1;
          183  + return verify_case(RetVal, HiddenSquares().count(x1, y1, x2, y2)); }
          184  +int Test_(Case_<2>) {
          185  + int x1_[] = {0,0,3};
          186  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          187  + int y1_[] = {0,3,0};
          188  +   vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_));
          189  + int x2_[] = {1,4,4};
          190  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          191  + int y2_[] = {3,4,3};
          192  +   vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_));
          193  + int RetVal = 0;
          194  + return verify_case(RetVal, HiddenSquares().count(x1, y1, x2, y2)); }
          195  +int Test_(Case_<3>) {
          196  + int x1_[] = {453453463,453453500,453453495,453453512,453453478,453453489,
          197  + 453453466,453453500,453453498,453453510,453453472,453453512,
          198  + 453453519,453453514,453453521,453453518,453453523,453453517,
          199  + 453453466,453453525,453453496,453453495,453453463,453453461,
          200  + 453453460,453453522,453453471,453453468,453453479,453453517,
          201  + 453453485,453453518,453453499,453453464,453453494};
          202  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          203  + int y1_[] = {364646438,364646402,364646449,364646438,364646415,364646401,
          204  + 364646446,364646416,364646456,364646414,364646463,364646407,
          205  + 364646436,364646450,364646421,364646411,364646414,364646419,
          206  + 364646445,364646427,364646405,364646442,364646418,364646464,
          207  + 364646457,364646463,364646432,364646426,364646444,364646431,
          208  + 364646450,364646418,364646434,364646458,364646402};
          209  +   vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_));
          210  + int x2_[] = {453453488,453453510,453453525,453453523,453453493,453453500,
          211  + 453453470,453453511,453453499,453453521,453453518,453453524,
          212  + 453453523,453453523,453453524,453453523,453453525,453453519,
          213  + 453453473,453453526,453453511,453453517,453453470,453453464,
          214  + 453453511,453453524,453453516,453453516,453453492,453453524,
          215  +453453513,453453522,453453520,453453505,453453512};
          216  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          217  + int y2_[] = {364646460,364646454,364646462,364646466,364646464,364646455,
          218  + 364646457,364646461,364646457,364646450,364646466,364646453,
          219  + 364646441,364646451,364646460,364646461,364646446,364646464,
          220  + 364646447,364646460,364646454,364646450,364646444,364646466,
          221  + 364646458,364646466,364646455,364646442,364646462,364646435,
          222  + 364646464,364646444,364646455,364646459,364646430};
          223  +   vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_));
          224  + int RetVal = 124;
          225  + return verify_case(RetVal, HiddenSquares().count(x1, y1, x2, y2)); }
          226  +
          227  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          228  +template<>      void Run_<-1>() {}
          229  +int main() { Run_<0>(); }
          230  +// END CUT HERE
          231  +

Added SRM/332/1A.cpp version [40a888ac9f7816df]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class CreatePairs {
           21  +public:
           22  + int maximalSum(vector <int> data)
           23  + {
           24  +  sort(data.begin(), data.end());
           25  +  vector<int>::iterator neg = upper_bound(data.begin(), data.end(), 0);
           26  +
           27  +  LL sum = 0;
           28  +  for(vector<int>::iterator it=data.begin(); it!=neg; ++it)
           29  +   if( it+1 == neg )
           30  +    sum += *it;
           31  +   else
           32  +    sum += *it * *(it+1), ++it;
           33  +
           34  +  vector<int>::iterator pos = lower_bound(data.begin(), data.end(), 2);
           35  +  for(vector<int>::iterator it=data.end()-1; it>=pos; --it)
           36  +   if( it == pos )
           37  +    sum += *it;
           38  +   else
           39  +    sum += *it * *(it-1), --it;
           40  +  for(vector<int>::iterator it=neg; it!=pos; ++it)
           41  +   sum += *it;
           42  +  return sum;
           43  + }
           44  +};
           45  +
           46  +// BEGIN CUT HERE
           47  +#include <ctime>
           48  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           49  +
           50  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           51  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           52  +
           53  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           54  +char Test_(...);
           55  +int Test_(Case_<0>) {
           56  + int data_[] = {0, 1, 2, 4, 3, 5};
           57  +   vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_));
           58  + int RetVal = 27;
           59  + return verify_case(RetVal, CreatePairs().maximalSum(data)); }
           60  +int Test_(Case_<1>) {
           61  + int data_[] = {-1, 1, 2, 3};
           62  +   vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_));
           63  + int RetVal = 6;
           64  + return verify_case(RetVal, CreatePairs().maximalSum(data)); }
           65  +int Test_(Case_<2>) {
           66  + int data_[] = {-1};
           67  +   vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_));
           68  + int RetVal = -1;
           69  + return verify_case(RetVal, CreatePairs().maximalSum(data)); }
           70  +int Test_(Case_<3>) {
           71  + int data_[] = {-1, 0, 1};
           72  +   vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_));
           73  + int RetVal = 1;
           74  + return verify_case(RetVal, CreatePairs().maximalSum(data)); }
           75  +int Test_(Case_<4>) {
           76  + int data_[] = {1, 1};
           77  +   vector <int> data(data_, data_+sizeof(data_)/sizeof(*data_));
           78  + int RetVal = 2;
           79  + return verify_case(RetVal, CreatePairs().maximalSum(data)); }
           80  +
           81  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           82  +template<>      void Run_<-1>() {}
           83  +int main() { Run_<0>(); }
           84  +// END CUT HERE
           85  +

Added SRM/332/1B.cpp version [42786b6cea1fe8ed]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +struct edge {
           21  + int y, x1, x2;
           22  + edge(){}
           23  + edge(int y, int x1, int x2) :y(y),x1(min(x1,x2)),x2(max(x1,x2)) {}
           24  + bool operator<( const edge& rhs ) const {
           25  +  if( y != rhs.y ) return y<rhs.y;
           26  +  if( x1 != rhs.x1 ) return x1<rhs.x1;
           27  +  return x2 < rhs.x2;
           28  + }
           29  +};
           30  +
           31  +class RestoringPolygon {
           32  +public:
           33  + int restore(vector <int> x1, vector <int> x2, vector <int> y)
           34  + {
           35  +  int N = x1.size();
           36  +
           37  +  vector<edge> e;
           38  +  for(int i=0; i!=N; ++i)
           39  +   e.push_back( edge(y[i], x1[i], x2[i]) );
           40  +  sort(e.begin(), e.end());
           41  +
           42  +  int ans = 0;
           43  +  for(int m=1; m<(1<<N); ++m)
           44  +   ans = max(ans, calc(e,m));
           45  +  return ans;
           46  + }
           47  +
           48  + int calc(vector<edge>& e_, int m)
           49  + {
           50  +  vector<edge> e;
           51  +  for(int i=0; (1<<i)<=m; ++i)
           52  +   if( m & (1<<i) )
           53  +    e.push_back( e_[i] );
           54  +
           55  +  if( e.size() <= 1 )
           56  +   return 0;
           57  +
           58  +  typedef pair<int,int> point;
           59  +  typedef map< point, vector<point> > graph;
           60  +  graph G;
           61  +  for(int i=0; i<e.size(); ++i)
           62  +  {
           63  +   int y = e[i].y;
           64  +   int xx[] = {e[i].x1, e[i].x2};
           65  +
           66  +   G[ point(e[i].x1,y) ].push_back( point(e[i].x2,y) );
           67  +   G[ point(e[i].x2,y) ].push_back( point(e[i].x1,y) );
           68  +
           69  +   for(int k=0; k<2; ++k) {
           70  +    int x = xx[k];
           71  +    for(int j=i-1; j>=0; --j)
           72  +     if( e[j].x1 == x ) {
           73  +      point p1(x, y);
           74  +      point p2(e[j].x1, e[j].y);
           75  +      if( G[p2].size() < 2 ) {
           76  +       G[p1].push_back(p2);
           77  +       G[p2].push_back(p1);
           78  +      }
           79  +     } else if( e[j].x2 == x ) {
           80  +      point p1(x, y);
           81  +      point p2(e[j].x2, e[j].y);
           82  +      if( G[p2].size() < 2 ) {
           83  +       G[p1].push_back(p2);
           84  +       G[p2].push_back(p1);
           85  +      }
           86  +     } else if( e[j].x1 < x && x < e[j].x2 ) {
           87  +      break;
           88  +     }
           89  +   }
           90  +  }
           91  +
           92  +  for(graph::iterator it=G.begin(); it!=G.end(); ++it)
           93  +   if( it->second.size() != 2 )
           94  +    return 0;
           95  +
           96  +  point s = G.begin()->first;
           97  +  point p = s, p2 = G[p][0];
           98  +  for(int c=2 ;; ++c) {
           99  +   point q = (G[p2][0] == p ? G[p2][1] : G[p2][0]);
          100  +   p=p2, p2=q;
          101  +   if( q == s )
          102  +    return c==e.size()*2 ? c : 0;
          103  +  }
          104  + }
          105  +};
          106  +
          107  +// BEGIN CUT HERE
          108  +#include <ctime>
          109  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          110  +
          111  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          112  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          113  +
          114  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          115  +char Test_(...);
          116  +int Test_(Case_<0>) {
          117  + int x1_[] = {1,2,3,1};
          118  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          119  + int x2_[] = {2,3,5,5};
          120  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          121  + int y_[] = {1,4,2,0};
          122  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          123  + int RetVal = 8;
          124  + return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
          125  +int Test_(Case_<1>) {
          126  + int x1_[] = {1,1,2,2};
          127  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          128  + int x2_[] = {3,3,4,4};
          129  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          130  + int y_[] = {0,2,1,3};
          131  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          132  + int RetVal = 4;
          133  + return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
          134  +int Test_(Case_<2>) {
          135  + int x1_[] = {1};
          136  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          137  + int x2_[] = {2};
          138  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          139  + int y_[] = {1};
          140  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          141  + int RetVal = 0;
          142  + return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
          143  +int Test_(Case_<3>) {
          144  + int x1_[] = {0,0,0};
          145  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          146  + int x2_[] = {1000,1000,1000};
          147  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          148  + int y_[] = {0,1,2};
          149  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          150  + int RetVal = 4;
          151  + return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
          152  +int Test_(Case_<4>) {
          153  + int x1_[] = {0,1,1,2};
          154  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          155  + int x2_[] = {1,0,2,1};
          156  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          157  + int y_[] = {0,4,2,3};
          158  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          159  + int RetVal = 8;
          160  + return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
          161  +int Test_(Case_<5>) {
          162  + int x1_[] = {696, -193, -193, 367};
          163  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          164  + int x2_[] = {367, -276, -276, 696};
          165  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          166  + int y_[] = {-14, 168, -14, 168};
          167  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          168  + int RetVal = 4;
          169  + return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
          170  +int Test_(Case_<6>) {
          171  + int x1_[] = { 0,  1, 6, 5, 5,  1,  6,  1,  0,  0,  9};
          172  +   vector <int> x1(x1_, x1_+sizeof(x1_)/sizeof(*x1_));
          173  + int x2_[] = { 5,  9, 9, 6, 6,  0,  9,  0,  1,  5,  6};
          174  +   vector <int> x2(x2_, x2_+sizeof(x2_)/sizeof(*x2_));
          175  + int y_[] = { 1,  4, 5, 3, 2,  0,  0,  2,  3,  5,  1};
          176  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          177  + int RetVal = 16;
          178  + return verify_case(RetVal, RestoringPolygon().restore(x1, x2, y)); }
          179  +
          180  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          181  +template<>      void Run_<-1>() {}
          182  +int main() { Run_<0>(); }
          183  +// END CUT HERE
          184  +

Added SRM/332/1C.cpp version [8e94bd05bec60fef]

            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 LadderPermutation { public:
           23  + vector <int> createLadder(int n, int m, int k)
           24  + {
           25  +  try {
           26  +   vector<int> v = gen(n-k, m-1, k);
           27  +   for(int i=0; i<k; ++i)
           28  +    v.push_back(n-i);
           29  +   return v;
           30  +  } catch(...) {
           31  +   return vector<int>();
           32  +  }
           33  + }
           34  +
           35  + vector<int> gen(int n, int m, int k) // make m blocks of length <=k
           36  + {
           37  +  if( m==0 ) {
           38  +   if( n==0 )
           39  +    return vector<int>();
           40  +   throw "fail";
           41  +  }
           42  +  int x = min(k, n-(m-1));
           43  +  if( x <= 0 )
           44  +   throw "fail";
           45  +  vector<int> v = gen(n-x, m-1, k);
           46  +  for(int i=0; i<x; ++i)
           47  +   v.push_back(n-i);
           48  +  return v;
           49  + }
           50  +};
           51  +
           52  +// BEGIN CUT HERE
           53  +#include <ctime>
           54  +double start_time; string timer()
           55  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           56  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           57  + { os << "{ ";
           58  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           59  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           60  +void verify_case(const vector <int>& Expected, const vector <int>& Received) {
           61  + bool ok = (Expected == Received);
           62  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           63  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           64  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           65  +#define END  verify_case(_, LadderPermutation().createLadder(n, m, k));}
           66  +int main(){
           67  +
           68  +CASE(0)
           69  + int n = 4;
           70  + int m = 2;
           71  + int k = 2;
           72  + int __[] = {2, 1, 4, 3 };
           73  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           74  +END
           75  +CASE(1)
           76  + int n = 3;
           77  + int m = 2;
           78  + int k = 2;
           79  + int __[] = {1, 3, 2 };
           80  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           81  +END
           82  +CASE(2)
           83  + int n = 2;
           84  + int m = 1;
           85  + int k = 1;
           86  + vector <int> _;
           87  +END
           88  +CASE(3)
           89  + int n = 6;
           90  + int m = 3;
           91  + int k = 2;
           92  + int __[] = {2, 1, 4, 3, 6, 5 };
           93  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           94  +END
           95  +CASE(4)
           96  + int n = 6;
           97  + int m = 2;
           98  + int k = 3;
           99  + int __[] = {3, 2, 1, 6, 5, 4 };
          100  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          101  +END
          102  +CASE(5)
          103  + int n = 7;
          104  + int m = 4;
          105  + int k = 4;
          106  + int __[] = {1, 2, 3, 7, 6, 5, 4 };
          107  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          108  +END
          109  +/*
          110  +CASE(6)
          111  + int n = ;
          112  + int m = ;
          113  + int k = ;
          114  + int __[] = ;
          115  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          116  +END
          117  +CASE(7)
          118  + int n = ;
          119  + int m = ;
          120  + int k = ;
          121  + int __[] = ;
          122  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          123  +END
          124  +*/
          125  +}
          126  +// END CUT HERE

Added SRM/332/2C.cpp version [4fe2b90f4373a079]

            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 Squares { public:
           23  + int countSquares(vector <string> field)
           24  + {
           25  +  const int H = field.size();
           26  +  const int W = field[0].size();
           27  +
           28  +  int cnt = 0;
           29  +  for(int y=0; y<H; ++y)
           30  +  for(int x=0; x<W; ++x)
           31  +   for(int y2=0; y2<H; ++y2)
           32  +   for(int x2=0; x2<W; ++x2) if( y!=y2 || x!=x2 )
           33  +   {
           34  +    char c = field[y][x];
           35  +    int x3 = x+(y2-y);
           36  +    int y3 = y-(x2-x);
           37  +    int x4 = x3+(x2-x);
           38  +    int y4 = y3+(y2-y);
           39  +    if( 0<=x3 && x3<W && 0<=y3 && y3<H )
           40  +    if( 0<=x4 && x4<W && 0<=y4 && y4<H )
           41  +    if( field[y2][x2]==c && field[y3][x3]==c && field[y4][x4]==c )
           42  +     ++cnt;
           43  +   }
           44  +  return cnt/4;
           45  + }
           46  +};
           47  +
           48  +// BEGIN CUT HERE
           49  +#include <ctime>
           50  +double start_time; string timer()
           51  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           52  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           53  + { os << "{ ";
           54  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           55  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           56  +void verify_case(const int& Expected, const int& Received) {
           57  + bool ok = (Expected == Received);
           58  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           59  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           60  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           61  +#define END  verify_case(_, Squares().countSquares(field));}
           62  +int main(){
           63  +
           64  +CASE(0)
           65  + string field_[] = {"ABA", "BAB", "ABA"};
           66  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
           67  + int _ = 2;
           68  +END
           69  +CASE(1)
           70  + string field_[] = {"AA", "AA"};
           71  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
           72  + int _ = 1;
           73  +END
           74  +CASE(2)
           75  + string field_[] = {"ABC", "DEF", "GHI"};
           76  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
           77  + int _ = 0;
           78  +END
           79  +CASE(3)
           80  + string field_[] = {"AABCA", "AAAAA", "BAAAB", "AAAEA", "ADBFA"};
           81  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
           82  + int _ = 11;
           83  +END
           84  +/*
           85  +CASE(4)
           86  + string field_[] = ;
           87  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
           88  + int _ = ;
           89  +END
           90  +CASE(5)
           91  + string field_[] = ;
           92  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
           93  + int _ = ;
           94  +END
           95  +*/
           96  +}
           97  +// END CUT HERE

Added SRM/333/1A.cpp version [a3074f7b005ac1af]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +int to_i(const string& s) {
           21  + int n;
           22  + stringstream(s)>>n;
           23  + return n;
           24  +}
           25  +
           26  +class BirthNumbersValidator {
           27  +public:
           28  + vector <string> validate(vector <string> test)
           29  + {
           30  +  vector<string> ans;
           31  +  transform(test.begin(), test.end(), back_inserter(ans), &testeach);
           32  +  return ans;
           33  + }
           34  +
           35  + static string testeach( const string& x )
           36  + {
           37  +  int y = to_i(x.substr(0,2));
           38  +  int m = to_i(x.substr(2,2));
           39  +  int d = to_i(x.substr(4,2));
           40  +  if( 1<=m && m<=12 ) {}
           41  +  else if( 51<=m && m<=62 ) { m-=50; }
           42  +  else return "NO";
           43  +
           44  +  bool leap = (y%4)==0;
           45  +  int dd[] = {31, leap?29:28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
           46  +  if( 1<=d && d<=dd[m-1] ) {}
           47  +  else return "NO";
           48  +
           49  +  LL cd; stringstream(x)>>cd;
           50  +  return cd%11==0 ? "YES" : "NO";
           51  + }
           52  +};
           53  +
           54  +// BEGIN CUT HERE
           55  +#include <ctime>
           56  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           57  +
           58  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           59  +int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           60  +
           61  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           62  +char Test_(...);
           63  +int Test_(Case_<0>) {
           64  + string test_[] = {"8104121234"};
           65  +   vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_));
           66  + string RetVal_[] = {"YES" };
           67  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           68  + return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
           69  +int Test_(Case_<1>) {
           70  + string test_[] = {"8154121239"};
           71  +   vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_));
           72  + string RetVal_[] = {"YES" };
           73  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           74  + return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
           75  +int Test_(Case_<2>) {
           76  + string test_[] = {"8134120005"};
           77  +   vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_));
           78  + string RetVal_[] = {"NO" };
           79  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           80  + return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
           81  +int Test_(Case_<3>) {
           82  + string test_[] = {"8102310007","8104121235"};
           83  +   vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_));
           84  + string RetVal_[] = {"NO", "NO" };
           85  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           86  + return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
           87  +int Test_(Case_<4>) {
           88  + string test_[] = {"0411131237"};
           89  +   vector <string> test(test_, test_+sizeof(test_)/sizeof(*test_));
           90  + string RetVal_[] = {"YES" };
           91  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           92  + return verify_case(RetVal, BirthNumbersValidator().validate(test)); }
           93  +
           94  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           95  +template<>      void Run_<-1>() {}
           96  +int main() { Run_<0>(); }
           97  +// END CUT HERE
           98  +

Added SRM/333/1B.cpp version [42a89a8a845fafd6]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class RepeatedPatterns {
           21  +public:
           22  + long long findZeroSegment(string P1, string P2, string zeroCount)
           23  + {
           24  +  LL zc; stringstream(zeroCount)>>zc;
           25  +
           26  +  bool allz1 = (P1.find('1') == string::npos);
           27  +  bool allz2 = (P2.find('1') == string::npos);
           28  +  if( allz1 && allz2 )
           29  +   return 0;
           30  +
           31  +  if( allz1 )
           32  +  {
           33  +   LL z1 = P1.size()*1000000;
           34  +   if( zc <= z1 )
           35  +    return 0;
           36  +
           37  +   LL a2 = 0; while( P2[a2]=='0' )             ++a2;
           38  +   LL b2 = 0; while( P2[P2.size()-1-b2]=='0' ) ++b2;
           39  +   LL c2=0, i2;
           40  +   for(int i=0; i<P2.size(); ++i)
           41  +    if( P2[i]=='0' ) {
           42  +     size_t ii = P2.find('1',i);
           43  +     if(ii==string::npos) ii=P2.size();
           44  +     if( ii-i > c2 ) c2=ii-i, i2=i;
           45  +    }
           46  +
           47  +   if( zc <= z1+a2 )
           48  +    return 0;
           49  +   if( zc <= c2 )
           50  +    return P1.size()*1000000 + i2;
           51  +   if( zc <= b2+z1+a2 )
           52  +    return P1.size()*1000000 + P2.size() - b2;
           53  +   return -1;
           54  +  }
           55  +  else if( allz2 )
           56  +  {
           57  +   LL a1 = 0; while( P1[a1]=='0' )             ++a1;
           58  +   LL b1 = 0; while( P1[P1.size()-1-b1]=='0' ) ++b1;
           59  +   LL c1=0, i1;
           60  +   for(int i=0; i<P1.size(); ++i)
           61  +    if( P1[i]=='0' ) {
           62  +     size_t ii = P1.find('1',i);
           63  +     if(ii==string::npos) ii=P1.size();
           64  +     if( ii-i > c1 ) c1=ii-i, i1=i;
           65  +    }
           66  +   if( zc <= a1 )
           67  +    return 0;
           68  +   if( zc <= c1 )
           69  +    return i1;
           70  +   if( zc <= b1+a1 )
           71  +    return P1.size() - b1;
           72  +   // zc <= b1 + k*P2.size() + a1;
           73  +   LL k = (zc-b1-a1) / P2.size() + ((zc-b1-a1)%P2.size() ? 1 : 0);
           74  +   LL idx = P1.size()*1000000*k + (k-1)*k/2*P2.size() - b1;
           75  +   return 0<=idx && idx+zc<=10000000000000000LL ? idx : -1;
           76  +  }
           77  +  else
           78  +  {
           79  +   LL a1 = 0; while( P1[a1]=='0' )             ++a1;
           80  +   LL b1 = 0; while( P1[P1.size()-1-b1]=='0' ) ++b1;
           81  +   LL c1=0, i1;
           82  +   for(int i=0; i<P1.size(); ++i)
           83  +    if( P1[i]=='0' ) {
           84  +     size_t ii = P1.find('1',i);
           85  +     if(ii==string::npos) ii=P1.size();
           86  +     if( ii-i > c1 ) c1=ii-i, i1=i;
           87  +    }
           88  +   LL a2 = 0; while( P2[a2]=='0' )             ++a2;
           89  +   LL b2 = 0; while( P2[P2.size()-1-b2]=='0' ) ++b2;
           90  +   LL c2=0, i2;
           91  +   for(int i=0; i<P2.size(); ++i)
           92  +    if( P2[i]=='0' ) {
           93  +     size_t ii = P2.find('1',i);
           94  +     if(ii==string::npos) ii=P2.size();
           95  +     if( ii-i > c2 ) c2=ii-i, i2=i;
           96  +    }
           97  +   if( zc <= a1 )
           98  +    return 0;
           99  +   if( zc <= c1 )
          100  +    return i1;
          101  +   if( zc <= b1+a1 )
          102  +    return P1.size() - b1;
          103  +   if( zc <= b1+a2 )
          104  +    return P1.size()*1000000 - b1;
          105  +   if( zc <= c2 )
          106  +    return P1.size()*1000000 + i2;
          107  +   if( zc <= b2+a1 )
          108  +    return P1.size()*1000000 + P2.size() - b2;
          109  +   if( zc <= b2+a2 )
          110  +    return P1.size()*1000000 + P2.size() + P1.size()*1000000 + P2.size() - b2;
          111  +   return -1;
          112  +  }
          113  + }
          114  +};
          115  +
          116  +// BEGIN CUT HERE
          117  +#include <ctime>
          118  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          119  +
          120  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          121  +int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          122  +
          123  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          124  +char Test_(...);
          125  +int Test_(Case_<0>) {
          126  + string P1 = "111010100001010";
          127  + string P2 = "010000001000";
          128  + string zeroCount = "3";
          129  + long long RetVal = 7LL;
          130  + return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
          131  +int Test_(Case_<1>) {
          132  + string P1 = "1101010010";
          133  + string P2 = "0001000";
          134  + string zeroCount = "3";
          135  + long long RetVal = 9999999LL;
          136  + return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
          137  +int Test_(Case_<2>) {
          138  + string P1 = "1101010010";
          139  + string P2 = "0001000";
          140  + string zeroCount = "5";
          141  + long long RetVal = 20000011LL;
          142  + return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
          143  +int Test_(Case_<3>) {
          144  + string P1 = "10101010";
          145  + string P2 = "101010101010";
          146  + string zeroCount = "9876543219876";
          147  + long long RetVal = -1LL;
          148  + return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
          149  +int Test_(Case_<4>) {
          150  + string P1 = "11111111111111111111111111";
          151  + string P2 = "0";
          152  + string zeroCount = "9876543219876";
          153  + long long RetVal = -1LL;
          154  + return verify_case(RetVal, RepeatedPatterns().findZeroSegment(P1, P2, zeroCount)); }
          155  +
          156  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          157  +template<>      void Run_<-1>() {}
          158  +int main() { Run_<0>(); }
          159  +// END CUT HERE
          160  +

Added SRM/333/1C.cpp version [b6921f196282e5d1]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class ThreeBuses {
           21  +public:
           22  + double getProbability(vector <int> wait, vector <int> travel, int timeLeft)
           23  + {
           24  +  double t = timeLeft - accumulate(travel.begin(), travel.end(), 0);
           25  +  sort(wait.begin(), wait.end());
           26  +  double w1 = wait[0];
           27  +  double w2 = wait[1];
           28  +  double w3 = wait[2];
           29  +  // [0,w1] + [0,w2] + [0,w3] <= t ??
           30  +  if( t >= w1+w2+w3 ) return 1;
           31  +  if( t <= 0 )        return 0;
           32  +
           33  +  if( w2==0 ) return t / w3;
           34  +  if( w1==0 ) {
           35  +   double vol = t*t/2;
           36  +   if( t > w2 ) vol -= (t-w2)*(t-w2)/2;
           37  +   if( t > w3 ) vol -= (t-w3)*(t-w3)/2;
           38  +   return vol / (w2*w3);
           39  +  }
           40  +
           41  +  double vol = t*t*t/6;
           42  +  if( t > w1 )    vol -= (t-w1)*(t-w1)*(t-w1)/6;
           43  +  if( t > w2 )    vol -= (t-w2)*(t-w2)*(t-w2)/6;
           44  +  if( t > w3 )    vol -= (t-w3)*(t-w3)*(t-w3)/6;
           45  +  if( t > w1+w2 ) vol += (t-w1-w2)*(t-w1-w2)*(t-w1-w2)/6;
           46  +  if( t > w2+w3 ) vol += (t-w2-w3)*(t-w2-w3)*(t-w2-w3)/6;
           47  +  if( t > w3+w1 ) vol += (t-w3-w1)*(t-w3-w1)*(t-w3-w1)/6;
           48  +  return vol / (w1*w2*w3);
           49  + }
           50  +};
           51  +
           52  +// BEGIN CUT HERE
           53  +#include <ctime>
           54  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           55  +
           56  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           57  +int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           58  +
           59  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           60  +char Test_(...);
           61  +int Test_(Case_<0>) {
           62  + int wait_[] = {0, 0, 0};
           63  +   vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_));
           64  + int travel_[] = {10, 15, 10};
           65  +   vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
           66  + int timeLeft = 47;
           67  + double RetVal = 1.0;
           68  + return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
           69  +int Test_(Case_<1>) {
           70  + int wait_[] = {0, 0, 0};
           71  +   vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_));
           72  + int travel_[] = {10, 15, 10};
           73  +   vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
           74  + int timeLeft = 35;
           75  + double RetVal = 1.0;
           76  + return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
           77  +int Test_(Case_<2>) {
           78  + int wait_[] = {1, 100, 1};
           79  +   vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_));
           80  + int travel_[] = {10, 10, 10};
           81  +   vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
           82  + int timeLeft = 52;
           83  + double RetVal = 0.21;
           84  + return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
           85  +int Test_(Case_<3>) {
           86  + int wait_[] = {100, 100, 70};
           87  +   vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_));
           88  + int travel_[] = {1, 1, 1};
           89  +   vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
           90  + int timeLeft = 47;
           91  + double RetVal = 0.020281904761904737;
           92  + return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
           93  +int Test_(Case_<4>) {
           94  + int wait_[] = {43210, 31730, 0};
           95  +   vector <int> wait(wait_, wait_+sizeof(wait_)/sizeof(*wait_));
           96  + int travel_[] = {1, 1, 1};
           97  +   vector <int> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
           98  + int timeLeft = 43212;
           99  + double RetVal = 0.6328164776672066;
          100  + return verify_case(RetVal, ThreeBuses().getProbability(wait, travel, timeLeft)); }
          101  +
          102  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          103  +template<>      void Run_<-1>() {}
          104  +int main() { Run_<0>(); }
          105  +// END CUT HERE
          106  +

Added SRM/334/1A.cpp version [aed588e5efe51737]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class EncodedSum
           20  +{
           21  +public:
           22  + long long maximumSum(vector <string> numbers)
           23  + {
           24  +  set<int> nonzero;
           25  +  for(int i=0; i<numbers.size(); ++i)
           26  +   nonzero.insert( numbers[i][0]-'A' );
           27  +
           28  +  LL v[] = {0,0,0,0,0,0,0,0,0,0};
           29  +  for(int i=0; i<numbers.size(); ++i)
           30  +   for(LL j=numbers[i].size()-1,d=1; j>=0; --j,d*=10)
           31  +    v[numbers[i][j]-'A'] += d;
           32  +
           33  +  LL d[] = {0,1,2,3,4,5,6,7,8,9};
           34  +  LL sumMax = 0;
           35  +  do {
           36  +   LL sum = 0;
           37  +   for(int c=0; c<10; ++c)
           38  +    if( d[c]==0 && nonzero.count(c) )
           39  +     goto nextPerm;
           40  +    else
           41  +     sum += v[c] * d[c];
           42  +   sumMax = max(sumMax, sum);
           43  +  nextPerm:;
           44  +  } while( next_permutation(d+0, d+10) );
           45  +  return sumMax;
           46  + }
           47  +};
           48  +
           49  +// BEGIN CUT HERE
           50  +#include <ctime>
           51  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           52  +
           53  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           54  +int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           55  +
           56  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           57  +char Test_(...);
           58  +int Test_(Case_<0>) {
           59  + string numbers_[] = {"ABC",
           60  + "BCA"};
           61  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
           62  + long long RetVal = 1875LL;
           63  + return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
           64  +int Test_(Case_<1>) {
           65  + string numbers_[] = {"ABCDEFGHIJ"};
           66  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
           67  + long long RetVal = 9876543210LL;
           68  + return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
           69  +int Test_(Case_<2>) {
           70  + string numbers_[] = {"ABCDEFGHIJ",
           71  + "J"};
           72  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
           73  + long long RetVal = 9876543202LL;
           74  + return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
           75  +int Test_(Case_<3>) {
           76  + string numbers_[] = {"A",
           77  + "BB",
           78  + "CCC",
           79  + "DDDD",
           80  + "EEEEE",
           81  + "FFFFFF",
           82  + "GGGGGGG",
           83  + "HHHHHHHH",
           84  + "IIIIIIIII",
           85  + "AJJJJJJJJJ"};
           86  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
           87  + long long RetVal = 9973936905LL;
           88  + return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
           89  +int Test_(Case_<4>) {
           90  + string numbers_[] = {"GHJIDDD",
           91  + "AHHCCCA",
           92  + "IIJCEJ",
           93  + "F",
           94  + "HDBIGFJAAJ"};
           95  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
           96  + long long RetVal = 9888114550LL;
           97  + return verify_case(RetVal, EncodedSum().maximumSum(numbers)); }
           98  +
           99  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          100  +template<>      void Run_<-1>() {}
          101  +int main() { Run_<0>(); }
          102  +// END CUT HERE
          103  +

Added SRM/334/1B.cpp version [3402769c07a731ca]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class ExtendedHappyNumbers
           20  +{
           21  +public:
           22  + long long calcTheSum(int A, int B, int K)
           23  + {
           24  +  vector<int> happy(9*9*9*9*9*9*7);
           25  +//  map<int,int> happy;
           26  +  LL sum = 0;
           27  +  for(int n=A; n<=B; ++n)
           28  +   sum += rec(n, K, happy);
           29  +  return sum;
           30  + }
           31  +
           32  + int S(int K, int n)
           33  + {
           34  +  int sum = 0;
           35  +  for(int d=1; d<=n; d*=10)
           36  +  {
           37  +   int v = n/d%10;
           38  +   int t = 1;
           39  +   for(int i=0; i<K; ++i)
           40  +    t *= v;
           41  +   sum += t;
           42  +  }
           43  +  return sum;
           44  + }
           45  +
           46  + int rec(int n, int K, vector<int>& happy)
           47  + {
           48  +  int LOOP = -1;
           49  +  stack<int> vs;
           50  +  int m = 0x7fffffff;
           51  +  for(;;)
           52  +  {
           53  +   if( happy[n] == LOOP )
           54  +    {m = looped(n, K); break;}
           55  +   if( happy[n] )
           56  +    {m = happy[n]; break;}
           57  +   happy[n] = LOOP;
           58  +   vs.push(n);
           59  +   n = S(K, n);
           60  +  }
           61  +  while(!vs.empty()) {
           62  +   int v = vs.top(); vs.pop();
           63  +   happy[v] = m = min(m, v);
           64  +  }
           65  +  return m;
           66  + }
           67  +
           68  + int looped(int n, int K)
           69  + {
           70  +  int mn = n;
           71  +  vector<int> vs(1, n);
           72  +  for(int v=S(K,n); v!=n; v=S(K,v))
           73  +   mn = min(mn, v);
           74  +  return mn;
           75  + }
           76  +};
           77  +
           78  +// BEGIN CUT HERE
           79  +#include <ctime>
           80  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           81  +
           82  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           83  +int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           84  +
           85  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           86  +char Test_(...);
           87  +int Test_(Case_<0>) {
           88  + int A = 13;
           89  + int B = 13;
           90  + int K = 2;
           91  + long long RetVal = 1LL;
           92  + return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
           93  +int Test_(Case_<1>) {
           94  + int A = 1;
           95  + int B = 5;
           96  + int K = 2;
           97  + long long RetVal = 14LL;
           98  + return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
           99  +int Test_(Case_<2>) {
          100  + int A = 10;
          101  + int B = 99;
          102  + int K = 1;
          103  + long long RetVal = 450LL;
          104  + return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
          105  +int Test_(Case_<3>) {
          106  + int A = 535;
          107  + int B = 538;
          108  + int K = 3;
          109  + long long RetVal = 820LL;
          110  + return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
          111  +int Test_(Case_<4>) {
          112  + int A = 100000;
          113  + int B = 400000;
          114  + int K = 6;
          115  + long long RetVal = 5169721292LL;
          116  + return verify_case(RetVal, ExtendedHappyNumbers().calcTheSum(A, B, K)); }
          117  +
          118  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          119  +template<>      void Run_<-1>() {}
          120  +int main() { Run_<0>(); }
          121  +// END CUT HERE
          122  +

Added SRM/334/1C.cpp version [bbf018ad57eb14ba]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +typedef int cost;
           20  +typedef int vert;
           21  +typedef vector< vector<cost> > graph;
           22  +
           23  +cost bidi_minCut( graph G, int N)
           24  +{
           25  + vector<vert> V;
           26  + for(int v=0; v<N; ++v)
           27  +  V.push_back(v);
           28  +
           29  + cost result = 0x7fffffff;
           30  + for(int n=N; n>1; --n)
           31  + {
           32  +  // invariant:
           33  +  //   the current set of vertices = {V[0] .. V[n-1]}
           34  +
           35  +  // order the vertices
           36  +  vector<int> vs;
           37  +  cost lastCut = 0;
           38  +  {
           39  +   vector<cost> ws(n, 0);
           40  +   ws[0] = 1;
           41  +
           42  +   for(int i=0; i<n; ++i) {
           43  +    int j = max_element(ws.begin(), ws.end()) - ws.begin();
           44  +    lastCut = ws[j];
           45  +
           46  +    vs.push_back(j);
           47  +    ws[j] = -1;
           48  +    for(int k=0; k<n; ++k)
           49  +     if( ws[k] != -1 )
           50  +      ws[k] += G[V[k]][V[j]];
           51  +   }
           52  +  }
           53  +
           54  +  // update mincut
           55  +  result = min(result, lastCut);
           56  +
           57  +  // reduce the graph (unify vs[n-2] and vs[n-1])
           58  +  vert v2=vs[n-2], v1=vs[n-1];
           59  +  for(int i=0; i<n; ++i) {
           60  +   G[V[v2]][V[i]] += G[V[v1]][V[i]];
           61  +   G[V[i]][V[v2]] += G[V[i]][V[v1]];
           62  +  }
           63  +  V.erase( V.begin() + v1 );
           64  + }
           65  + return result;
           66  +}
           67  +
           68  +class Terrorists
           69  +{
           70  +public:
           71  + int requiredCost(vector <string> roads)
           72  + {
           73  +  int N = roads.size();
           74  +  graph G(N, vector<cost>(N));
           75  +
           76  +  for(int i=0; i<N; ++i)
           77  +  for(int j=0; j<N; ++j)
           78  +   G[i][j] = roads[i][j]-'0';
           79  +
           80  +  return bidi_minCut(G, N);
           81  + }
           82  +};
           83  +
           84  +// BEGIN CUT HERE
           85  +#include <ctime>
           86  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           87  +
           88  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           89  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           90  +
           91  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           92  +char Test_(...);
           93  +int Test_(Case_<0>) {
           94  + string roads_[] = {"0911",
           95  + "9011",
           96  + "1109",
           97  + "1190"};
           98  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
           99  + int RetVal = 4;
          100  + return verify_case(RetVal, Terrorists().requiredCost(roads)); }
          101  +int Test_(Case_<1>) {
          102  + string roads_[] = {"0399",
          103  + "3033",
          104  + "9309",
          105  + "9390"};
          106  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          107  + int RetVal = 9;
          108  + return verify_case(RetVal, Terrorists().requiredCost(roads)); }
          109  +int Test_(Case_<2>) {
          110  + string roads_[] = {"030900",
          111  + "304120",
          112  + "040174",
          113  + "911021",
          114  + "027207",
          115  + "004170"};
          116  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          117  + int RetVal = 8;
          118  + return verify_case(RetVal, Terrorists().requiredCost(roads)); }
          119  +int Test_(Case_<3>) {
          120  + string roads_[] = {"044967263",
          121  + "409134231",
          122  + "490642938",
          123  + "916036261",
          124  + "634306024",
          125  + "742660550",
          126  + "229205069",
          127  + "633625604",
          128  + "318140940"};
          129  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          130  + int RetVal = 27;
          131  + return verify_case(RetVal, Terrorists().requiredCost(roads)); }
          132  +
          133  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          134  +template<>      void Run_<-1>() {}
          135  +int main() { Run_<0>(); }
          136  +// END CUT HERE
          137  +

Added SRM/335/1A.cpp version [9d8dcb43599a380c]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class Multifactorial
           20  +{
           21  +public:
           22  + string calcMultiFact(int n, int k)
           23  + {
           24  +  LL ans = 1;
           25  +  for(LL v=n; v>0; v-=k)
           26  +  {
           27  +   if( ans*v<ans || ans*v/v!=ans || ans*v>1000000000000000000LL )
           28  +    return "overflow";
           29  +   ans *= v;
           30  +  }
           31  +  stringstream sout;
           32  +  sout << ans;
           33  +  return sout.str();
           34  + }
           35  +};
           36  +
           37  +// BEGIN CUT HERE
           38  +#include <ctime>
           39  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           40  +
           41  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           42  +int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           43  +
           44  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           45  +char Test_(...);
           46  +int Test_(Case_<0>) {
           47  + int n = 14;
           48  + int k = 3;
           49  + string RetVal = "12320";
           50  + return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
           51  +int Test_(Case_<1>) {
           52  + int n = 5;
           53  + int k = 4;
           54  + string RetVal = "5";
           55  + return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
           56  +int Test_(Case_<2>) {
           57  + int n = 1000;
           58  + int k = 2;
           59  + string RetVal = "overflow";
           60  + return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
           61  +int Test_(Case_<3>) {
           62  + int n = 2000000000;
           63  + int k = 1900000000;
           64  + string RetVal = "200000000000000000";
           65  + return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
           66  +int Test_(Case_<4>) {
           67  + int n = 1000;
           68  + int k = 256;
           69  + string RetVal = "84232704000";
           70  + return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
           71  +int Test_(Case_<5>) {
           72  + int n = 2000000000;
           73  + int k = 1;
           74  + string RetVal = "overflow";
           75  + return verify_case(RetVal, Multifactorial().calcMultiFact(n, k)); }
           76  +
           77  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           78  +template<>      void Run_<-1>() {}
           79  +int main() { Run_<0>(); }
           80  +// END CUT HERE
           81  +

Added SRM/335/1B.cpp version [77edbded42c604a6]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +typedef pair<int,int> vert;
           20  +typedef int cost;
           21  +
           22  +// dijkstra
           23  +template<typename OutIt>
           24  +void neighbors(cost e[50][50], int Y, int X, vert v, bool vis[50][50], OutIt out)
           25  +{
           26  + typedef pair<cost,vert> cedge;
           27  + priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           28  + Q.push( cedge(e[v.first][v.second],v) );
           29  +
           30  + set<vert> visited_now;
           31  + while( !Q.empty() )
           32  + {
           33  +  cedge ce = Q.top(); Q.pop();
           34  +  cost cc = ce.first;
           35  +  vert cv = ce.second;
           36  +  if( visited_now.count(cv) )
           37  +   continue;
           38  +  visited_now.insert(cv);
           39  +
           40  +  if( !vis[cv.first][cv.second] ) {
           41  +   *out++ = cv;
           42  +   vis[cv.first][cv.second] = true;
           43  +  }
           44  +
           45  +  // for 4 neibs
           46  +  int dy[]={0,0,-1,+1};
           47  +  int dx[]={-1,+1,0,0};
           48  +  for(int i=0; i<4; ++i)
           49  +  {
           50  +   int yyy = cv.first  + dy[i];
           51  +   int xxx = cv.second + dx[i];
           52  +   if( 0<=yyy && yyy<Y && 0<=xxx && xxx<X )
           53  +   {
           54  +    int ccc = cc + e[yyy][xxx];
           55  +    vert vvv(yyy, xxx);
           56  +    if( ccc<=9*8*7*6*5*4*3*2*1 )
           57  +     Q.push( cedge(ccc, vvv) );
           58  +   }
           59  +  }
           60  + }
           61  +}
           62  +
           63  +int bfs( cost e[50][50], int Y, int X, vert s, vert d )
           64  +{
           65  + vector<vert> Q(1, s);
           66  + bool vis[50][50] = {}; vis[s.first][s.second] = true;
           67  +
           68  + for(int step=0; !Q.empty(); ++step)
           69  + {
           70  +  vector<vert> Q2;
           71  +  for(int i=0; i!=Q.size(); ++i)
           72  +  {
           73  +   if( Q[i] == d )
           74  +    return step;
           75  +   neighbors(e, Y, X, Q[i], vis, back_inserter(Q2));
           76  +  }
           77  +  Q.swap(Q2);
           78  + }
           79  + return -1;
           80  +}
           81  +
           82  +class ExpensiveTravel
           83  +{
           84  +public:
           85  + int minTime(vector <string> m, int startRow, int startCol, int endRow, int endCol)
           86  + {
           87  +  int Y = m.size(), X = m[0].size();
           88  +  int Sy = startRow-1, Sx = startCol-1;
           89  +  int Ey = endRow-1,   Ex = endCol-1;
           90  +  cost e[50][50];
           91  +  for(int y=0; y<Y; ++y)
           92  +  for(int x=0; x<X; ++x)
           93  +   e[y][x] = 9*8*7*6*5*4*3*2*1 / (m[y][x]-'0');
           94  +
           95  +  return bfs( e, Y, X, vert(Sy,Sx), vert(Ey,Ex) );
           96  + }
           97  +};
           98  +
           99  +// BEGIN CUT HERE
          100  +#include <ctime>
          101  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          102  +
          103  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          104  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          105  +
          106  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          107  +char Test_(...);
          108  +int Test_(Case_<0>) {
          109  + string m_[] = {"22334"};
          110  +   vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_));
          111  + int startRow = 1;
          112  + int startCol = 1;
          113  + int endRow = 1;
          114  + int endCol = 5;
          115  + int RetVal = 3;
          116  + return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
          117  +int Test_(Case_<1>) {
          118  + string m_[] = {"55",
          119  + "52",
          120  + "55"};
          121  +   vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_));
          122  + int startRow = 1;
          123  + int startCol = 2;
          124  + int endRow = 3;
          125  + int endCol = 2;
          126  + int RetVal = 1;
          127  + return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
          128  +int Test_(Case_<2>) {
          129  + string m_[] = {"251",
          130  + "212",
          131  + "122"};
          132  +   vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_));
          133  + int startRow = 1;
          134  + int startCol = 1;
          135  + int endRow = 3;
          136  + int endCol = 3;
          137  + int RetVal = -1;
          138  + return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
          139  +int Test_(Case_<3>) {
          140  + string m_[] = {"452232",
          141  + "287979",
          142  + "219872",
          143  + "928234",
          144  + "767676"};
          145  +   vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_));
          146  + int startRow = 1;
          147  + int startCol = 6;
          148  + int endRow = 3;
          149  + int endCol = 1;
          150  + int RetVal = 3;
          151  + return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
          152  +int Test_(Case_<4>) {
          153  + string m_[] = {"11"};
          154  +   vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_));
          155  + int startRow = 1;
          156  + int startCol = 1;
          157  + int endRow = 1;
          158  + int endCol = 2;
          159  + int RetVal = -1;
          160  + return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
          161  +int Test_(Case_<5>) {
          162  + string m_[] = {"123456789987654321"};
          163  +   vector <string> m(m_, m_+sizeof(m_)/sizeof(*m_));
          164  + int startRow = 1;
          165  + int startCol = 2;
          166  + int endRow = 1;
          167  + int endCol = 16;
          168  + int RetVal = 5;
          169  + return verify_case(RetVal, ExpensiveTravel().minTime(m, startRow, startCol, endRow, endCol)); }
          170  +
          171  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          172  +template<>      void Run_<-1>() {}
          173  +int main() { Run_<0>(); }
          174  +// END CUT HERE
          175  +

Added SRM/335/1C.cpp version [3fd802a4d545ca8e]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +void gen( vector<int>& X, vector<LL>& R, int n )
           20  +{
           21  + int j = 0;
           22  + int m = X.size();
           23  + for(int i=0; i<n; ++i)
           24  + {
           25  +  R[i] = X[j];
           26  +  int s = (j+1)%m;
           27  +  X[j] = ( ( X[j] ^ X[s] ) + 13 ) % 49999;
           28  +  j = s;
           29  + }
           30  +}
           31  +
           32  +class RandomFights
           33  +{
           34  +public:
           35  + double expectedNrOfPoints(vector <int> Aseed, vector <int> Bseed, int n)
           36  + {
           37  +  vector<LL> A(n), B(n);
           38  +  gen(Aseed, A, n);
           39  +  gen(Bseed, B, n);
           40  +
           41  +  // expected gain by A[i] = sqSum{B[j] | B[j]<A[i]} - sqSum{B[j] | B[j]>A[i]}
           42  +
           43  +  sort(B.begin(), B.end());
           44  +  vector<LL> B2(n);
           45  +  for(int i=0; i<n; ++i) B2[i] = B[i]*B[i];
           46  +
           47  +  vector<LL> L1(n), R1(n), L2(n), R2(n);
           48  +  partial_sum( B.begin(),   B.end(),   L1.begin()  );
           49  +  partial_sum( B.rbegin(),  B.rend(),  R1.rbegin() );
           50  +  partial_sum( B2.begin(),  B2.end(),  L2.begin()  );
           51  +  partial_sum( B2.rbegin(), B2.rend(), R2.rbegin() );
           52  +
           53  +  LL e = 0;
           54  +  for(int i=0; i<n; ++i)
           55  +  {
           56  +   int j = lower_bound(B.begin(), B.end(), A[i]) - B.begin();
           57  +
           58  +   LL ln  = j;
           59  +   LL ls  = (j==0 ? 0 : L1[j-1]);
           60  +   LL ls2 = (j==0 ? 0 : L2[j-1]);
           61  +   LL rn  = n-j;
           62  +   LL rs  = (j==n ? 0 : R1[j]);
           63  +   LL rs2 = (j==n ? 0 : R2[j]);
           64  +
           65  +   e += (ls2-rs2) - 2*A[i]*(ls-rs) + (ln-rn)*A[i]*A[i];
           66  +  }
           67  +  return double(e) / n;
           68  + }
           69  +};
           70  +
           71  +// BEGIN CUT HERE
           72  +#include <ctime>
           73  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           74  +
           75  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           76  +int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           77  +
           78  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           79  +char Test_(...);
           80  +int Test_(Case_<0>) {
           81  + int A_[] = {6};
           82  +   vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_));
           83  + int B_[] = {4};
           84  +   vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_));
           85  + int n = 1;
           86  + double RetVal = 4.0;
           87  + return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
           88  +int Test_(Case_<1>) {
           89  + int A_[] = {1,7};
           90  +   vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_));
           91  + int B_[] = {3,5};
           92  +   vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_));
           93  + int n = 2;
           94  + double RetVal = 0.0;
           95  + return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
           96  +int Test_(Case_<2>) {
           97  + int A_[] = {3,7};
           98  +   vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_));
           99  + int B_[] = {1,5};
          100  +   vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_));
          101  + int n = 2;
          102  + double RetVal = 20.0;
          103  + return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
          104  +int Test_(Case_<3>) {
          105  + int A_[] = {45,35,236,2342,5543,21,32,2,6,23,24,23,41,1};
          106  +   vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_));
          107  + int B_[] = {2345,45,2345,345};
          108  +   vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_));
          109  + int n = 50;
          110  + double RetVal = 1.2721986164E8;
          111  + return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
          112  +int Test_(Case_<4>) {
          113  + int A_[] = {34,3245,2534,53,53,46,346,246,346,2,624,624,6,245,6324,6542,624,6};
          114  +   vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_));
          115  + int B_[] = {345,234,523,4624,6,2456,345,634,634,7,3457,376,34,6234,62,523,52,35,32};
          116  +   vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_));
          117  + int n = 7;
          118  + double RetVal = -9713701.714285715;
          119  + return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
          120  +int Test_(Case_<5>) {
          121  + int A_[] = {1,2,3,4};
          122  +   vector <int> A(A_, A_+sizeof(A_)/sizeof(*A_));
          123  + int B_[] = {1,2,3,4};
          124  +   vector <int> B(B_, B_+sizeof(B_)/sizeof(*B_));
          125  + int n = 50000;
          126  + double RetVal = 0.0;
          127  + return verify_case(RetVal, RandomFights().expectedNrOfPoints(A, B, n)); }
          128  +
          129  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          130  +template<>      void Run_<-1>() {}
          131  +int main() { Run_<0>(); }
          132  +// END CUT HERE
          133  +

Added SRM/336/1A.cpp version [4da7fa5c9a34c708]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class ServiceNames
           20  +{
           21  +public:
           22  + vector <string> makeList(vector <string> services)
           23  + {
           24  +  map< string, set<string> > lst;
           25  +  for(int i=0; i<services.size(); ++i) {
           26  +   stringstream sin(services[i]);
           27  +   string h; sin>>h;
           28  +   for(string s; sin>>s; )
           29  +    lst[s].insert(h);
           30  +  }
           31  +
           32  +  vector<string> out;
           33  +  transform(lst.begin(), lst.end(), back_inserter(out), &pr);
           34  +  return out;
           35  + }
           36  +
           37  + static string pr( const pair< string, set<string> >& p )
           38  + {
           39  +  stringstream sout;
           40  +  sout << p.first;
           41  +  string sep = " ==> ";
           42  +  for(set<string>::const_iterator it=p.second.begin(); it!=p.second.end(); ++it)
           43  +   sout << sep << *it, sep=", ";
           44  +  return sout.str();
           45  + }
           46  +
           47  +// BEGIN CUT HERE
           48  + public:
           49  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); }
           50  + private:
           51  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           52  + void verify_case(int Case, const vector <string> &Expected, const vector <string> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
           53  + void test_case_0() { string Arr0[] = {"BLAST Genome Annotation Sensitivity","PING","X Annotation"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"Annotation ==> BLAST, X", "Genome ==> BLAST", "Sensitivity ==> BLAST" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(0, Arg1, makeList(Arg0)); }
           54  + void test_case_1() { string Arr0[] = {"PING"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); vector <string> Arg1; verify_case(1, Arg1, makeList(Arg0)); }
           55  + void test_case_2() { string Arr0[] = {"BLAST Genome annotation Sensitivity","PING","X Annotation","Apple X ample"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"Annotation ==> X", "Genome ==> BLAST", "Sensitivity ==> BLAST", "X ==> Apple", "ample ==> Apple", "annotation ==> BLAST" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(2, Arg1, makeList(Arg0)); }
           56  +
           57  +// END CUT HERE
           58  +};
           59  +// BEGIN CUT HERE
           60  +int main() { ServiceNames().run_test(-1); }
           61  +// END CUT HERE

Added SRM/336/1B.cpp version [3c0ef4de970a84c9]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class LikelyWord
           20  +{
           21  +public:
           22  + int likely(vector <string> dictionary, int k)
           23  + {
           24  +  vector<LL> dl, dr;
           25  +  dl.push_back(-1);
           26  +  dr.push_back(-1);
           27  +  for(int i=0; i<dictionary.size(); ++i) {
           28  +   dl.push_back( toLLl(dictionary[i],k) );
           29  +   dr.push_back( toLLr(dictionary[i],k) );
           30  +  }
           31  +  dl.push_back( ipow(26,k) );
           32  +  dr.push_back( ipow(26,k) );
           33  +
           34  +  LL max=-1, maxi=-1;
           35  +  for(int i=0; i+1<dl.size(); ++i) {
           36  +   LL hm = dr[i+1] - dl[i] - 1;
           37  +   if( hm>max )
           38  +    max=hm, maxi=i;
           39  +   else if(hm==max)
           40  +    maxi=-1;
           41  +  }
           42  +  return maxi;
           43  + }
           44  +
           45  + LL toLLl( string s, LL k )
           46  + {
           47  +  if( s.size() > k )
           48  +   s.resize(k);
           49  +  else if( s.size() < k )
           50  +   s.resize(k, 'a'), s[s.size()-1]-=1;
           51  +  return toLL(s,k);
           52  + }
           53  +
           54  + LL toLLr( string s, LL k )
           55  + {
           56  +  if( s.size() > k )
           57  +   s.resize(k), s[s.size()-1]+=1;
           58  +  else if( s.size() < k )
           59  +   s.resize(k, 'a');
           60  +  return toLL(s,k);
           61  + }
           62  +
           63  + LL toLL( string s, LL k )
           64  + {
           65  +  LL n = 0;
           66  +  for(int i=0; i<k; ++i)
           67  +   n = n*26 + s[i]-'a';
           68  +  return n;
           69  + }
           70  +
           71  + LL ipow(LL a, LL k) {
           72  +  LL n = 1;
           73  +  while(k--)
           74  +   n *= a;
           75  +  return n;
           76  + }
           77  +
           78  +// BEGIN CUT HERE
           79  + public:
           80  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
           81  + private:
           82  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           83  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           84  + void test_case_0() { string Arr0[] = {"time","zoology"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 0; verify_case(0, Arg2, likely(Arg0, Arg1)); }
           85  + void test_case_1() { string Arr0[] = {"az","ma","xz"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 1; verify_case(1, Arg2, likely(Arg0, Arg1)); }
           86  + void test_case_2() { string Arr0[] = {"az","ma","xz"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 2; verify_case(2, Arg2, likely(Arg0, Arg1)); }
           87  + void test_case_3() { string Arr0[] = {"a","m","y"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = -1; verify_case(3, Arg2, likely(Arg0, Arg1)); }
           88  + void test_case_4() { string Arr0[] = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 25; verify_case(4, Arg2, likely(Arg0, Arg1)); }
           89  + void test_case_5() { string Arr0[] = {"aa", "ab", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 0; verify_case(5, Arg2, likely(Arg0, Arg1)); }
           90  +
           91  +// END CUT HERE
           92  +};
           93  +// BEGIN CUT HERE
           94  +int main() { LikelyWord().run_test(-1); }
           95  +// END CUT HERE

Added SRM/336/1C.cpp version [6ae24e1dde2eb7e0]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +typedef complex<double> pt;
           20  +
           21  +bool byY( pt a, pt b )
           22  +{
           23  + if( a.imag() == b.imag() )
           24  +  return a.real() < b.real();
           25  + return a.imag() < b.imag();
           26  +}
           27  +
           28  +bool byArg( pt a, pt b )
           29  +{
           30  + return arg(a) < arg(b);
           31  +}
           32  +
           33  +bool isRight( pt a, pt b, pt c )
           34  +{
           35  + return arg((c-b) / (b-a)) < 0;
           36  +}
           37  +
           38  +vector<pt> convex_hull( vector<pt> p )
           39  +{
           40  + vector<pt>::iterator it = min_element( p.begin(), p.end(), byY );
           41  + pt o = *it;
           42  + p.erase(it);
           43  + for(int i=0; i<p.size(); ++i)
           44  +  p[i] -= o;
           45  + sort( p.begin(), p.end(), byArg );
           46  +
           47  + vector<pt> q;
           48  + q.push_back( pt(0,0) );
           49  + q.push_back( p[0] );
           50  + for(int i=1; i<p.size(); ++i) {
           51  +  while( isRight(q[q.size()-2], q[q.size()-1], p[i]) )
           52  +   q.pop_back();
           53  +  q.push_back( p[i] );
           54  + }
           55  + for(int i=0; i<q.size(); ++i)
           56  +  q[i] += o;
           57  + return q;
           58  +}
           59  +
           60  +double outer_prod( pt a, pt b )
           61  +{
           62  + return (a.real()*b.imag() - b.real()*a.imag())/2;
           63  +}
           64  +
           65  +double area( const vector<pt>& q )
           66  +{
           67  + double a = 0.0;
           68  +
           69  + pt o = q[0];
           70  + for(int i=1; i+1<q.size(); ++i)
           71  +  a += outer_prod(q[i]-o, q[i+1]-o);
           72  + return abs(a);
           73  +}
           74  +
           75  +
           76  +class Shadow
           77  +{
           78  +public:
           79  + double area(vector <int> tree, vector <int> light)
           80  + {
           81  +  double x1 = min(tree[0], tree[3]);
           82  +  double x2 = max(tree[0], tree[3]);
           83  +  double y1 = min(tree[1], tree[4]);
           84  +  double y2 = max(tree[1], tree[4]);
           85  +  double z1 = min(tree[2], tree[5]);
           86  +  double z2 = max(tree[2], tree[5]);
           87  +  double x  = light[0];
           88  +  double y  = light[1];
           89  +  double z  = light[2];
           90  +
           91  +  if(x1==x2 && y1==y2 || y1==y2 && z1==z2 || z1==z2 && x1==x2 )
           92  +   return 0; // line
           93  +  if(x1==x2 && x==x1 || y1==y2 && y==y1 || z1==z2 && z==z1 )
           94  +   return 0; // seen as a line
           95  +  if( y1 >= y )
           96  +   return 0; // tree above light
           97  +  if( y2 >= y )
           98  +   return -1; // infinite
           99  +
          100  +  // otherwise project all vertices two y=0 plain
          101  +  vector<pt> p;
          102  +  for(int i=0; i<8; ++i)
          103  +  {
          104  +   double X=(i&1 ? x1 : x2);
          105  +   double Y=(i&2 ? y1 : y2);
          106  +   double Z=(i&4 ? z1 : z2);
          107  +
          108  +   // (Xp-X) : (x-X) = (0-Y) : (y-Y)
          109  +   double Xp = (X-x)*Y/(y-Y) + X;
          110  +   double Zp = (Z-z)*Y/(y-Y) + Z;
          111  +   p.push_back( pt(Xp,Zp) );
          112  +  }
          113  +
          114  +  // calc convex hull and its area
          115  +  p = convex_hull(p);
          116  +  return ::area(p);
          117  + }
          118  +
          119  +// BEGIN CUT HERE
          120  + public:
          121  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
          122  + private:
          123  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          124  + void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
          125  + void test_case_0() { int Arr0[] = {1,1,1, 10,1,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {5,5,5}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); double Arg2 = 0.0; verify_case(0, Arg2, area(Arg0, Arg1)); }
          126  + void test_case_1() { int Arr0[] = {1,3,1, 10,1,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2,2,2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); double Arg2 = -1.0; verify_case(1, Arg2, area(Arg0, Arg1)); }
          127  + void test_case_2() { int Arr0[] = {1,1,1, 2,2,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {3,3,3}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); double Arg2 = 15.75; verify_case(2, Arg2, area(Arg0, Arg1)); }
          128  + void test_case_3() { int Arr0[] =  {1,1,1, 3,3,3} ; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2,2,2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); double Arg2 = -1.0; verify_case(3, Arg2, area(Arg0, Arg1)); }
          129  +
          130  +// END CUT HERE
          131  +};
          132  +// BEGIN CUT HERE
          133  +int main() { Shadow().run_test(-1); }
          134  +// END CUT HERE

Added SRM/337/1A.cpp version [73f5cf8f82efdd62]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class CardStraights
           19  +{
           20  +public:
           21  + int longestStraight(vector <int> cards)
           22  + {
           23  +  int jok = count(cards.begin(), cards.end(), 0);
           24  +
           25  +  set<int> cs(cards.begin(), cards.end());
           26  +  cs.erase(0);
           27  +  if( cs.empty() )
           28  +   return jok; // Ouggggggggg
           29  +
           30  +  int ans = 0;
           31  +  for(set<int>::iterator it=cs.begin(); it!=cs.end(); ++it)
           32  +   ans = max(ans, asLongAsPossible(it, cs.end(), jok));
           33  +  return ans;
           34  + }
           35  +
           36  + int asLongAsPossible(set<int>::iterator it, set<int>::iterator end, int jok)
           37  + {
           38  +  int b = *it;
           39  +  int e = *it;
           40  +  for(++it; it!=end; e=*it++)
           41  +   if( *it-e-1 <= jok )
           42  +    jok -= *it-e-1;
           43  +   else
           44  +    break;
           45  +  int nAfter = min(1000000-e, jok);
           46  +  e += nAfter;
           47  +  b -= min(b-1, jok-nAfter);
           48  +  return e-b+1;
           49  + }
           50  +
           51  +// BEGIN CUT HERE
           52  + public:
           53  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           54  + private:
           55  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           56  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           57  + void test_case_0() { int Arr0[] = {0,6,5,10,3,0,11}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 5; verify_case(0, Arg1, longestStraight(Arg0)); }
           58  + void test_case_1() { int Arr0[] = {100,100,100,101,100,99,97,103}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; verify_case(1, Arg1, longestStraight(Arg0)); }
           59  + void test_case_2() { int Arr0[] = {0,0,0,1,2,6,8,1000}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; verify_case(2, Arg1, longestStraight(Arg0)); }
           60  + void test_case_3() { int Arr0[] = {1,9,5,7,3,4,0,0,0,10}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 10; verify_case(3, Arg1, longestStraight(Arg0)); }
           61  + void test_case_4() { int Arr0[] = {0,0,999999}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; verify_case(4, Arg1, longestStraight(Arg0)); }
           62  +
           63  +// END CUT HERE
           64  +};
           65  +// BEGIN CUT HERE
           66  +int main() { CardStraights().run_test(-1); }
           67  +// END CUT HERE

Added SRM/337/1B+.cpp version [b4ff9352141581da]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +template<typename T>
           20  +struct RMQ
           21  +{
           22  + vector< vector<int> > rm;
           23  + vector<T> d;
           24  +
           25  + RMQ( const vector<T>& d ) : d(d) {
           26  +  int n = d.size();
           27  +
           28  +  // rm[k][x] = z s.t. d[z] is the minimum in [x, x+2^k)
           29  +  rm.push_back( vector<int>(n) );
           30  +  for(int x=0; x<n; ++x)
           31  +   rm[0][x] = x;
           32  +  for(int k=1; (1<<k)<=n; ++k) {
           33  +   rm.push_back( rm[k-1] );
           34  +   for(int x=0; x+(1<<k-1)<n; ++x)
           35  +    if( d[rm[k][x]] > d[rm[k-1][x + (1<<k-1)]] )
           36  +     rm[k][x] = rm[k-1][x + (1<<k-1)];
           37  +  }
           38  + }
           39  +
           40  + int operator()(int L, int R) const { // inclusive
           41  +  int k=0;
           42  +  for(; L+(1<<k) < R-(1<<k)+1; ++k) {}
           43  +  LL i = rm[k][L];
           44  +  LL j = rm[k][R-(1<<k)+1];
           45  +  return (d[i]<=d[j] ? i : j);
           46  + }
           47  +};
           48  +
           49  +class BuildingAdvertise
           50  +{
           51  +public:
           52  + long long getMaxArea(vector <int> hseed, int n)
           53  + {
           54  +  // input
           55  +  LL j = 0;
           56  +  LL m = hseed.size();
           57  +  vector<LL> h(n);
           58  +  for(int i=0; i<n; ++i) {
           59  +   h[i] = hseed[j];
           60  +   LL s = (j+1)%m;
           61  +   hseed[j] = ( ( hseed[j] ^ hseed[s] ) + 13 ) % 835454957;
           62  +   j = s;
           63  +  }
           64  +
           65  +  // solve
           66  +  return rec(RMQ<LL>(h), h, 0, n-1);
           67  + }
           68  + LL rec(const RMQ<LL>& rmq, vector<LL>& h, LL L, LL R)
           69  + {
           70  +  LL result = 0;
           71  +
           72  +  stack< pair<LL,LL> > S;
           73  +  S.push( make_pair(L,R) );
           74  +  while( !S.empty() )
           75  +  {
           76  +   L = S.top().first;
           77  +   R = S.top().second;
           78  +   S.pop();
           79  +
           80  +   LL C = rmq(L, R);
           81  +   if( L < C ) S.push( make_pair(L,C-1) );
           82  +   if( C < R ) S.push( make_pair(C+1,R) );
           83  +   result = max(result, (R-L+1) * h[C]);
           84  +  }
           85  +
           86  +  return result;
           87  + }
           88  +
           89  +// BEGIN CUT HERE
           90  + public:
           91  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           92  + private:
           93  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           94  + void verify_case(int Case, const long long &Expected, const long long &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           95  + void test_case_0() { int Arr0[] = {3,6,5,6,2,4}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; long long Arg2 = 15LL; verify_case(0, Arg2, getMaxArea(Arg0, Arg1)); }
           96  + void test_case_1() { int Arr0[] = {5,0,7,0,2,6,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; long long Arg2 = 7LL; verify_case(1, Arg2, getMaxArea(Arg0, Arg1)); }
           97  + void test_case_2() { int Arr0[] = {1048589,2097165}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100000; long long Arg2 = 104858900000LL; verify_case(2, Arg2, getMaxArea(Arg0, Arg1)); }
           98  + void test_case_3() { int Arr0[] = {1,7,2,5,3,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; long long Arg2 = 8LL; verify_case(3, Arg2, getMaxArea(Arg0, Arg1)); }
           99  +
          100  +// END CUT HERE
          101  +};
          102  +// BEGIN CUT HERE
          103  +int main() { BuildingAdvertise().run_test(-1); }
          104  +// END CUT HERE

Added SRM/337/1B.cpp version [15a7013bcd917907]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class BuildingAdvertise
           20  +{
           21  +public:
           22  + long long getMaxArea(vector <int> h, int n)
           23  + {
           24  +  // input
           25  +  LL j = 0;
           26  +  LL m = h.size();
           27  +  vector<LL> R(n);
           28  +  for(int i=0; i<n; ++i) {
           29  +   R[i] = h[j];
           30  +   LL s = (j+1)%m;
           31  +   h[j] = ( ( h[j] ^ h[s] ) + 13 ) % 835454957;
           32  +   j = s;
           33  +  }
           34  +
           35  +  // solve
           36  +  vector<int> left(n);
           37  +  {
           38  +   map<LL, int> h; h[-1] = -1;
           39  +   for(int i=0; i<n; ++i) {
           40  +    // position of the highest building < R[i]
           41  +    map<LL,int>::iterator it = h.lower_bound(R[i]);
           42  +    left[i] = (--it)->second+1;
           43  +    h.erase( ++it, h.end() );
           44  +    h[ R[i] ] = i;
           45  +   }
           46  +  }
           47  +  vector<int> right(n);
           48  +  {
           49  +   map<LL, int> h; h[-1] = n;
           50  +   for(int i=n-1; i>=0; --i) {
           51  +    // position of the highest building < R[i]
           52  +    map<LL,int>::iterator it = h.lower_bound(R[i]);
           53  +    right[i] = (--it)->second-1;
           54  +    h.erase( ++it, h.end() );
           55  +    h[ R[i] ] = i;
           56  +   }
           57  +  }
           58  +  LL ans = 0;
           59  +  for(int i=0; i<n; ++i) {
           60  +   LL area = R[i] * (right[i] - left[i] + 1);
           61  +   ans = max(ans, area);
           62  +  }
           63  +  return ans;
           64  + }
           65  +
           66  +// BEGIN CUT HERE
           67  + public:
           68  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           69  + private:
           70  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           71  + void verify_case(int Case, const long long &Expected, const long long &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           72  + void test_case_0() { int Arr0[] = {3,6,5,6,2,4}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; long long Arg2 = 15LL; verify_case(0, Arg2, getMaxArea(Arg0, Arg1)); }
           73  + void test_case_1() { int Arr0[] = {5,0,7,0,2,6,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; long long Arg2 = 7LL; verify_case(1, Arg2, getMaxArea(Arg0, Arg1)); }
           74  + void test_case_2() { int Arr0[] = {1048589,2097165}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100000; long long Arg2 = 104858900000LL; verify_case(2, Arg2, getMaxArea(Arg0, Arg1)); }
           75  + void test_case_3() { int Arr0[] = {1,7,2,5,3,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 6; long long Arg2 = 8LL; verify_case(3, Arg2, getMaxArea(Arg0, Arg1)); }
           76  + void test_case_4() { int Arr0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 9999; long long Arg2 = 1903656LL; verify_case(4, Arg2, getMaxArea(Arg0, Arg1)); }
           77  +// END CUT HERE
           78  +};
           79  +// BEGIN CUT HERE
           80  +int main() { BuildingAdvertise().run_test(-1); }
           81  +// END CUT HERE

Added SRM/337/1C.cpp version [c85a397b1091370e]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +static const LL MODVAL = 835454957;
           19  +int memo[50*15*101*2];
           20  +int memo_k[101];
           21  +
           22  +class CountPalindromes
           23  +{
           24  +public:
           25  + vector<string> w;
           26  + int count(vector<string> words, int k)
           27  + {
           28  +  w = words;
           29  +  memset(memo, 0xff, sizeof(memo));
           30  +
           31  +  LL ans = 0;
           32  +  memo_k[0] = 0;
           33  +  for(int kk=1; kk<=k; ++kk) {
           34  +   LL ak = 0;
           35  +   for(int i=0; i<w.size(); ++i)
           36  +    ak += rec_l(i, 0, kk);
           37  +   ans += (memo_k[kk] = ak%MODVAL);
           38  +  }
           39  +  return int(ans % MODVAL);
           40  +
           41  + }
           42  +
           43  + int rec_l(int i, int ix, int k)
           44  + {
           45  +  int key = (((i*15)+ix)*101+k)*2+0;
           46  +  if( memo[key]>=0 )
           47  +   return memo[key];
           48  +
           49  +  LL ans = 0;
           50  +  for(int j=0; j<w.size(); ++j)
           51  +   ans += rec(i, ix, j, w[j].size()-1, k);
           52  +  return memo[key] = int(ans % MODVAL);
           53  + }
           54  +
           55  + int rec_r(int j, int jx, int k)
           56  + {
           57  +  int key = (((j*15)+jx)*101+k)*2+1;
           58  +  if( memo[key]>=0 )
           59  +   return memo[key];
           60  +
           61  +  LL ans = 0;
           62  +  for(int i=0; i<w.size(); ++i)
           63  +   ans += rec(i, 0, j, jx, k);
           64  +  return memo[key] = int(ans % MODVAL);
           65  + }
           66  +
           67  +
           68  + int rec(int i, int ix, int j, int jx, int k)
           69  + {
           70  +  while( k>=2 && ix<w[i].size() && 0<=jx )
           71  +   if( w[i][ix] != w[j][jx] )
           72  +    return 0;
           73  +   else
           74  +    ++ix, --jx, k-=2;
           75  +
           76  +  if( k == 0 )
           77  +   return (i==j && ix==jx+1 ? 1 : 0);
           78  +  if( k == 1 )
           79  +   return (i==j && ix==jx || ix==w[i].size() && jx==-1 ? 1 : 0);
           80  +
           81  +  if( ix==w[i].size() && jx==-1 )
           82  +   return memo_k[k-2];
           83  +  else if( ix==w[i].size() )
           84  +   return rec_r(j, jx, k-1);
           85  +  else if( jx==-1 )
           86  +   return rec_l(i, ix, k-1);
           87  +  else
           88  +   return 0;
           89  + }
           90  +
           91  +// BEGIN CUT HERE
           92  + public:
           93  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           94  + private:
           95  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           96  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           97  + void test_case_0() { string Arr0[] = {"tragic","cigar"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 24; int Arg2 = 1; verify_case(0, Arg2, count(Arg0, Arg1)); }
           98  + void test_case_1() { string Arr0[] = {"z","zz"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 5; verify_case(1, Arg2, count(Arg0, Arg1)); }
           99  + void test_case_2() { string Arr0[] = {"aba","acaba","baca","cac","b","c","a"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 70; int Arg2 = 370786966; verify_case(2, Arg2, count(Arg0, Arg1)); }
          100  + void test_case_3() { string Arr0[] = {"hello"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100; int Arg2 = 0; verify_case(3, Arg2, count(Arg0, Arg1)); }
          101  + void test_case_4() { string Arr0[] = {"a", "aaaaaaaaab", "aaa", "aaaaaaaaaaaa", "aabbaaa", "babaaaaaaaa", "aaaaaabaaaba", "aaaa", "aaaaaaaaa", "aaaaaaaaaa", "aab", "aaaaaababaaaaa", "aaaaaaaaaaabba", "aaaaaabaa", "aaabaaaaaa", "abaaaaaaaa", "aaaaaa", "aabaaaaaaaaaba", "ab", "bbbaabaaaab", "aaaabaaaaa", "aa", "baaaaaaaaaaaa", "aabaa", "aabaaaaaaaabbaa", "aaaaaaaabaaaaaa", "aaaaaaaa", "aaaaa", "aaaaaaaaaaa", "aabaaaaa", "baabaaaaaaaaa", "baaaaa", "aaaaaaaabaaaaa", "aaaaaaaaaaaaaaa", "abaaaaaaaaaaa", "aaabababaaaa", "aaaaaaaaaabaaaa", "abaaa", "aaaaabaaaab", "aaaabaaaaaaa", "aaaaaaaba", "babbbaaaaaba", "aaaaaaaaaaaaa", "aaababaabaab", "aaabaabaaab", "aaaabbaaabaaaaa", "abaaaaaaaaaaaaa", "aaaaaaa", "abaaaaabaaaaaaa", "aaabaaaaaaaaa"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100; int Arg2 = 570277357; verify_case(4, Arg2, count(Arg0, Arg1)); }
          102  +// END CUT HERE
          103  +};
          104  +// BEGIN CUT HERE
          105  +int main() { CountPalindromes().run_test(-1); }
          106  +// END CUT HERE

Added SRM/338/1A.cpp version [35838fc5989717b0]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class ImprovingStatistics
           19  +{
           20  +public:
           21  + int howManyGames(int played, int won)
           22  + {
           23  +  LL p = played, w = won;
           24  +  LL z = w*100 / p;
           25  +
           26  +  // z+1 <= (w+X)*100 / (p+X)
           27  +  // (z+1)(p+X) <= (w+X)*100
           28  +  // (z+1)*p-w*100 <= (99-z)X
           29  +  if( z >= 99 )
           30  +   return -1;
           31  +  LL a = (z+1)*p-w*100, b = 99-z;
           32  +  // a <= b*X
           33  +  return int(a%b==0 ? a/b : a/b+1);
           34  + }
           35  +
           36  +// BEGIN CUT HERE
           37  + public:
           38  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           39  + private:
           40  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           41  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           42  + void test_case_0() { int Arg0 = 10; int Arg1 = 8; int Arg2 = 1; verify_case(0, Arg2, howManyGames(Arg0, Arg1)); }
           43  + void test_case_1() { int Arg0 = 100; int Arg1 = 80; int Arg2 = 6; verify_case(1, Arg2, howManyGames(Arg0, Arg1)); }
           44  + void test_case_2() { int Arg0 = 47; int Arg1 = 47; int Arg2 = -1; verify_case(2, Arg2, howManyGames(Arg0, Arg1)); }
           45  + void test_case_3() { int Arg0 = 99000; int Arg1 = 0; int Arg2 = 1000; verify_case(3, Arg2, howManyGames(Arg0, Arg1)); }
           46  + void test_case_4() { int Arg0 = 1000000000; int Arg1 = 470000000; int Arg2 = 19230770; verify_case(4, Arg2, howManyGames(Arg0, Arg1)); }
           47  +
           48  +// END CUT HERE
           49  +};
           50  +// BEGIN CUT HERE
           51  +int main() { ImprovingStatistics().run_test(-1); }
           52  +// END CUT HERE

Added SRM/338/1B.cpp version [21cb8b2950411a4a]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +vector< vector<double> > mMul( const vector< vector<double> >& A, const vector< vector<double> >& B )
           19  +{
           20  + const int n = A.size();
           21  +
           22  + vector< vector<double> > C(n, vector<double>(n));
           23  + for(int i=0; i<n; ++i)
           24  +  for(int j=0; j<n; ++j) {
           25  +   double Cij = 0;
           26  +   for(int k=0; k<n; ++k)
           27  +    Cij += A[i][k] * B[k][j];
           28  +   C[i][j] = Cij;
           29  +  }
           30  + return C;
           31  +}
           32  +
           33  +vector< vector<double> > mPow( vector< vector<double> > M, int t ) // t>0
           34  +{
           35  + vector< vector<double> > R;
           36  + for(; t; t>>=1, M=mMul(M,M))
           37  +  if( t&1 )
           38  +   R = (R.empty() ? M : mMul(R,M));
           39  + return R;
           40  +}
           41  +
           42  +class RandomSwaps
           43  +{
           44  +public:
           45  + double getProbability(int arrayLength, int swapCount, int a, int b)
           46  + {
           47  +  double P = 1 / double(arrayLength * (arrayLength-1)/2);
           48  +  double Q = 1 - (arrayLength-1)*P;
           49  +  if( a != b ) {
           50  +   vector< vector<double> > M(3, vector<double>(3));
           51  +   M[0][0] = Q;
           52  +   M[0][1] = P;
           53  +   M[0][2] = 1 - P - Q;
           54  +   M[1][0] = P;
           55  +   M[1][1] = Q;
           56  +   M[1][2] = 1 - P - Q;
           57  +   M[2][0] = P;
           58  +   M[2][1] = P;
           59  +   M[2][2] = 1 - M[2][0] - M[2][1];
           60  +   M = mPow( M, swapCount );
           61  +   return M[0][1];
           62  +  } else {
           63  +   vector< vector<double> > M(2, vector<double>(2));
           64  +   M[0][0] = Q;
           65  +   M[0][1] = 1 - M[0][0];
           66  +   M[1][0] = P;
           67  +   M[1][1] = 1 - P;
           68  +   M = mPow( M, swapCount );
           69  +   return M[0][0];
           70  +  }
           71  + }
           72  +
           73  +// BEGIN CUT HERE
           74  + public:
           75  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           76  + private:
           77  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           78  + void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           79  + void test_case_0() { int Arg0 = 5; int Arg1 = 1; int Arg2 = 0; int Arg3 = 0; double Arg4 = 0.6; verify_case(0, Arg4, getProbability(Arg0, Arg1, Arg2, Arg3)); }
           80  + void test_case_1() { int Arg0 = 5; int Arg1 = 1; int Arg2 = 0; int Arg3 = 3; double Arg4 = 0.1; verify_case(1, Arg4, getProbability(Arg0, Arg1, Arg2, Arg3)); }
           81  + void test_case_2() { int Arg0 = 5; int Arg1 = 2; int Arg2 = 0; int Arg3 = 0; double Arg4 = 0.4; verify_case(2, Arg4, getProbability(Arg0, Arg1, Arg2, Arg3)); }
           82  + void test_case_3() { int Arg0 = 100; int Arg1 = 500; int Arg2 = 3; int Arg3 = 3; double Arg4 = 0.010036635745123007; verify_case(3, Arg4, getProbability(Arg0, Arg1, Arg2, Arg3)); }
           83  +
           84  +// END CUT HERE
           85  +};
           86  +// BEGIN CUT HERE
           87  +int main() { RandomSwaps().run_test(-1); }
           88  +// END CUT HERE

Added SRM/338/1C.cpp version [c308f15b218b41e1]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class CakeParty
           20  +{
           21  +public:
           22  + string makeMove(vector <int> pieces)
           23  + {
           24  +  // Win iff #{i | pieces[i]==max(pieces)} is odd
           25  +  //    --> if #==1      move not to make the opponent winning pos
           26  +  //        if #==odd>=3 any move will do. choose the lexic-first one
           27  +  //        if #==even   any move leads to lose. choose the lex1st
           28  +/*
           29  +<<Sprague Grundy Theorem ‚É‚æ‚铱�o>>
           30  +
           31  +’è—�‚̃Xƒe�[ƒgƒ�ƒ“ƒg
           32  +
           33  +    ‘Î�Û‚Æ‚È‚éƒQ�[ƒ€
           34  +      - “ñ�lƒQ�[ƒ€
           35  +      - “ñ�l‚Æ‚à“®‚©‚¹‚éŽè‚Ì�W�‡‚Í“¯‚¶
           36  +      - “®‚©‚¹‚È‚­‚È‚Á‚½•û‚ª•‰‚¯
           37  +      - –³ŒÀƒ‹�[ƒv‚µ‚È‚¢
           38  +
           39  +    nim
           40  +      - ƒTƒCƒY s1, s2, .., sk ‚ÌŽR‚ª‚ ‚é
           41  +      - ‚Ç‚ê‚©ˆê‚ÂŽR‚ð‘I‚ñ‚Å 1 �` ŽRƒTƒCƒY ‚Ì”CˆÓŒÂŽæ‚è�œ‚¯‚é
           42  +      - �ÅŒã‚ÌŽR‚ðŽæ‚Á‚½•û‚ª�Ÿ‚¿�iŽR‚ª‚È‚­‚È‚Á‚đłŽ肪–³‚­‚È‚Á‚½•û‚ª•‰‚¯�j
           43  +
           44  +    *n ‚ðƒTƒCƒY n ‚ÌŽR‚ª1ŒÂ‚¾‚¯‚Ì nim ‚Æ‚·‚é
           45  +      - *0 ‚Í•‰‚¯
           46  +      - *n ‚Í�Ÿ‚¿ n>=1
           47  +
           48  +    ƒQ�[ƒ€
           49  +      - �ó‘Ô G ‚©‚ç‘Å‚Ä‚éŽè‚Å‘JˆÚ‚·‚é�æ‚ð G1, ..., Gk ‚Æ‚·‚é
           50  +        G = {G1, ..., Gk} ‚Æ�‘‚­
           51  +
           52  +    “™‰¿
           53  +      - “ñ‚‚̃Q�[ƒ€G, F‚ª“™‰¿‚È‚±‚Æ‚ð G �ß F ‚Æ�‘‚­
           54  +        “™‰¿‚Æ‚¢‚¤‚Ì‚Í�Ÿ‚¿•‰‚¯ˆê’v‚æ‚è‚à‚Á‚Æ‹­‚¢�B“ñ‚‚̃Q�[ƒ€‚̘a‚ðŽæ‚é‚Æ•K”s‚ɂȂ邱‚Æ
           55  +        *n ‚Æ *n ‚Í“¯ƒTƒCƒY‚ÌŽR2‚‚Ìnim‚Í•K”s‚È‚Ì‚Å“™‰¿�B“¯ƒTƒCƒY‚Å‚È‚¯‚ê‚ΕK�Ÿ‚È‚Ì‚Å“™‰¿‚Å‚È‚¢
           56  +
           57  +    ’è—�
           58  +      - G1�ß*n1, ..., Gk�ß*nk ‚È‚ç‚Î�AG={G1, ..., Gk} �ß *mex(n1,...,nk)
           59  +        where mex(S) = min(nat \setminus S)
           60  +        ‹A”[“I‚É�A‘S‚ẴQ�[ƒ€‚Í‚È‚ñ‚ç‚©‚Ì *n ‚Æ“™‰¿
           61  +
           62  +“K—p
           63  +
           64  +  "#max == 1 ‚È‚ç•K�Ÿ"
           65  +       [X,...] = { [X-1,...], [X-2,...], ..., [1, ...], [...] }
           66  +     ‚Å
           67  +       [X-1,...] = { [X-2,...], ..., [1, ...], [...] }
           68  +     ‚È‚Ì‚Å
           69  +       [X,...] ‚Ì nim ’l‚Í mex(mex{[X-2,...], ..., [1, ...], [...]}, [X-2,...], ..., [1, ...], [...])
           70  +       ‚ɂȂ邪�A‚±‚ê‚Ímex2‰ñ‚ª‚¯‚È‚Ì‚Å *0 ‚Å‚Í‚È‚¢�B‚æ‚Á‚Ä•K�Ÿ
           71  +  "#max == 2 ‚È‚ç•K”s"
           72  +     ‚Ç‚¤‚â‚Á‚Ä‚à‘ŠŽè‚É#max==1‚Å“n‚Á‚Ä‚µ‚Ü‚¤
           73  +  "#max == 3 ‚È‚ç•K�Ÿ"
           74  +     ‚Ç‚¤‚â‚Á‚Ä‚à‘ŠŽè‚É#max==2‚Å“n‚é
           75  +  ...
           76  +
           77  +*/
           78  +  LL maxI = max_element(pieces.begin(), pieces.end()) - pieces.begin();
           79  +  LL maxP = pieces[maxI];
           80  +  if( count(pieces.begin(), pieces.end(), maxP) == 1 )
           81  +  {
           82  +   pieces[maxI] = 0;
           83  +   LL second = *max_element(pieces.begin(), pieces.end());
           84  +
           85  +   // if there's odd number of the second largests, make it even
           86  +   if( count(pieces.begin(), pieces.end(), second)%2 == 1 )
           87  +   {
           88  +    stringstream sout;
           89  +    sout << "CAKE " << maxI << " PIECES " << (maxP - second);
           90  +    return sout.str();
           91  +   }
           92  +   // otherwise, leave it as is. choose the lex-first move
           93  +   else
           94  +   {
           95  +    LL eat = maxP - second + 1;
           96  +
           97  +    // d : lexicographically first number more than "eat"
           98  +    LL d = 1;
           99  +    while( !(eat <= d) )
          100  +     d *= 10;
          101  +    if( d <= maxP ) // if edible
          102  +     eat = d;
          103  +    stringstream sout;
          104  +    sout << "CAKE " << maxI << " PIECES " << eat;
          105  +    return sout.str();
          106  +   }
          107  +  }
          108  +  else
          109  +  {
          110  +   string ans = "Z";
          111  +   for(LL i=0; i<pieces.size(); ++i)
          112  +    if( pieces[i] == maxP )
          113  +    {
          114  +     stringstream sout;
          115  +     sout << "CAKE " << i << " PIECES 1";
          116  +     ans = min(ans, sout.str());
          117  +    }
          118  +   return ans;
          119  +  }
          120  + }
          121  +};
          122  +
          123  +// BEGIN CUT HERE
          124  +#include <ctime>
          125  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          126  +
          127  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          128  +int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          129  +
          130  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          131  +char Test_(...);
          132  +int Test_(Case_<0>) {
          133  + int pieces_[] = {47};
          134  +   vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_));
          135  + string RetVal = "CAKE 0 PIECES 47";
          136  + return verify_case(RetVal, CakeParty().makeMove(pieces)); }
          137  +int Test_(Case_<1>) {
          138  + int pieces_[] = {3,3};
          139  +   vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_));
          140  + string RetVal = "CAKE 0 PIECES 1";
          141  + return verify_case(RetVal, CakeParty().makeMove(pieces)); }
          142  +int Test_(Case_<2>) {
          143  + int pieces_[] = {3,5};
          144  +   vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_));
          145  + string RetVal = "CAKE 1 PIECES 2";
          146  + return verify_case(RetVal, CakeParty().makeMove(pieces)); }
          147  +int Test_(Case_<3>) {
          148  + int pieces_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1};
          149  +   vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_));
          150  + string RetVal = "CAKE 0 PIECES 1";
          151  + return verify_case(RetVal, CakeParty().makeMove(pieces)); }
          152  +int Test_(Case_<4>) {
          153  + int pieces_[] = {3,3,112};
          154  +   vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_));
          155  + string RetVal = "CAKE 2 PIECES 110";
          156  + return verify_case(RetVal, CakeParty().makeMove(pieces)); }
          157  +int Test_(Case_<5>) {
          158  + int pieces_[] = {3,3,1};
          159  +   vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_));
          160  + string RetVal = "CAKE 0 PIECES 1";
          161  + return verify_case(RetVal, CakeParty().makeMove(pieces)); }
          162  +int Test_(Case_<6>) {
          163  + int pieces_[] = {4,7,4,7,4,7,4,7,47,47,47,47};
          164  +   vector <int> pieces(pieces_, pieces_+sizeof(pieces_)/sizeof(*pieces_));
          165  + string RetVal = "CAKE 10 PIECES 1";
          166  + return verify_case(RetVal, CakeParty().makeMove(pieces)); }
          167  +
          168  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          169  +template<>      void Run_<-1>() {}
          170  +int main() { Run_<0>(); }
          171  +// END CUT HERE
          172  +

Added SRM/339/1A.cpp version [85245486553aa92b]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class BusTrip
           19  +{
           20  +public:
           21  + int returnTime(int, vector <string> buses)
           22  + {
           23  +  int t=-1, v=0;
           24  +  do
           25  +   onestep( t, v, buses );
           26  +  while( v );
           27  +  return t;
           28  + }
           29  +
           30  + void onestep(int& t, int& v, vector<string>& buses)
           31  + {
           32  +  int mt=1001, mv=0;
           33  +  for(int j=0; j<buses.size(); ++j)
           34  +  {
           35  +   stringstream sin(buses[j]);
           36  +   vector<int> vs;
           37  +   for(int x; sin>>x;)
           38  +    vs.push_back(x);
           39  +
           40  +   int loop_time = 0;
           41  +   for(int i=0; i<vs.size(); ++i)
           42  +    loop_time += abs(vs[(i+1)%vs.size()] - vs[i]);
           43  +
           44  +   int rem = 0;
           45  +   for(int i=0; i<vs.size(); ++i) {
           46  +    if( v==vs[i] )
           47  +    {
           48  +     int nt = rem;
           49  +     while( t >= nt )
           50  +      nt += loop_time;
           51  +     if( nt < mt ) {
           52  +      mt = nt;
           53  +      mv = vs[(i+1)%vs.size()];
           54  +     }
           55  +    }
           56  +    rem += abs(vs[(i+1)%vs.size()] - vs[i]);
           57  +   }
           58  +  }
           59  +
           60  +  t = mt + abs(mv-v);
           61  +  v = mv;
           62  +  if( t > 1000 )
           63  +   t=-1, v=0;
           64  + }
           65  +
           66  +// BEGIN CUT HERE
           67  + public:
           68  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
           69  + private:
           70  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           71  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           72  + void test_case_0() { int Arg0 = 3; string Arr1[] = {"0 1 2"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 12; verify_case(0, Arg2, returnTime(Arg0, Arg1)); }
           73  + void test_case_1() { int Arg0 = 51; string Arr1[] = {"0 5 10 15 20 25 30 35 40 50"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 1000; verify_case(1, Arg2, returnTime(Arg0, Arg1)); }
           74  + void test_case_2() { int Arg0 = 3; string Arr1[] = {"0 1 2", "2 1 0"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = -1; verify_case(2, Arg2, returnTime(Arg0, Arg1)); }
           75  + void test_case_3() { int Arg0 = 5; string Arr1[] = {"0 1 2 3 4", "3 1 2 0", "4 1 2 3 0", "1 2 0 3 4", "4 0"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 12; verify_case(3, Arg2, returnTime(Arg0, Arg1)); }
           76  + void test_case_4() { int Arg0 = 25; string Arr1[] = {"24 14 9 7 2", "21 4 18 24 7 1 2 11 8 9 14 16 5 17 13 23 19 15 22", "12 22 24 9 1 5 10 8 7 18 16 19 4 13 17",
           77  + "14 5 17 9 23 7 16 22 10 4 6", "19 8 1 9 24 3 5 22 16 7 6 4 10 23 17 0 13 15",
           78  + "2 16 10 13 14 1 11 20 0 24 22 23 19 4 18", "19 15 18 0", "15 9 22 5 20 8 23 14 24 18 21 6 13 19",
           79  + "2 6 19 3 21 10 20 22 24 13 16 15 8 18 17 14 5", "19 10 1 7 5 11 21 8 14 0 17 23 12 2 3 16"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 157; verify_case(4, Arg2, returnTime(Arg0, Arg1)); }
           80  + void test_case_5() { int Arg0 = 100; string Arr1[] = {"0 10 30 45 60 46 39 31 20", "9 20 0 86"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = -1; verify_case(5, Arg2, returnTime(Arg0, Arg1)); }
           81  +
           82  +// END CUT HERE
           83  +};
           84  +// BEGIN CUT HERE
           85  +int main() { BusTrip().run_test(-1); }
           86  +// END CUT HERE

Added SRM/339/1B.cpp version [f3f43873cef11bb1]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class TestBettingStrategy
           19  +{
           20  +public:
           21  + map<int, double> memo;
           22  + double winProbability(int initSum, int goalSum, int rounds, int prob)
           23  + {
           24  +  memo.clear();
           25  +  return rec(initSum, 1, rounds, goalSum, prob/100.0);
           26  + }
           27  +
           28  + double rec(int cur, int bet, int rest, int goal, double pWin)
           29  + {
           30  +  if( cur >= goal ) return 1.0;
           31  +  if( cur < bet )   return 0.0;
           32  +  if( rest == 0 )   return 0.0;
           33  +
           34  +  int key = rest*2000*2000 + cur*2000 + bet;
           35  +  if( memo.count(key) )
           36  +   return memo[key];
           37  +  return memo[key]
           38  +   =    pWin *rec(cur+bet, 1, rest-1, goal, pWin)
           39  +   + (1-pWin)*rec(cur-bet, bet*2, rest-1, goal, pWin);
           40  + }
           41  +
           42  +// BEGIN CUT HERE
           43  + public:
           44  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           45  + private:
           46  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           47  + void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           48  + void test_case_0() { int Arg0 = 10; int Arg1 = 11; int Arg2 = 4; int Arg3 = 50; double Arg4 = 0.875; verify_case(0, Arg4, winProbability(Arg0, Arg1, Arg2, Arg3)); }
           49  + void test_case_1() { int Arg0 = 10; int Arg1 = 20; int Arg2 = 20; int Arg3 = 50; double Arg4 = 0.3441343307495117; verify_case(1, Arg4, winProbability(Arg0, Arg1, Arg2, Arg3)); }
           50  + void test_case_2() { int Arg0 = 10; int Arg1 = 20; int Arg2 = 10; int Arg3 = 90; double Arg4 = 0.34867844010000015; verify_case(2, Arg4, winProbability(Arg0, Arg1, Arg2, Arg3)); }
           51  + void test_case_3() { int Arg0 = 24; int Arg1 = 38; int Arg2 = 24; int Arg3 = 60; double Arg4 = 0.5940784635646947; verify_case(3, Arg4, winProbability(Arg0, Arg1, Arg2, Arg3)); }
           52  +
           53  +// END CUT HERE
           54  +};
           55  +// BEGIN CUT HERE
           56  +int main() { TestBettingStrategy().run_test(-1); }
           57  +// END CUT HERE

Added SRM/339/1C.cpp version [3ecdbbbf9c0cd8ea]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class RPSTournament
           19  +{
           20  +public:
           21  + int greatestSeed(int rounds, int C)
           22  + {
           23  +  int L=1, R=(1<<rounds)+1;
           24  +  while( R-L > 1) {
           25  +   int M = (L+R)/2;
           26  +   (can_win(M, rounds, C) ? L : R) = M;
           27  +  }
           28  +  return L;
           29  + }
           30  +
           31  + bool can_win(int X, int R, int C)
           32  + {
           33  +  queue< pair<int,int> > Q;
           34  +  Q.push( make_pair(R, X) );
           35  +
           36  +  set<int> unused;
           37  +  for(int n=0; n<=(1<<R); ++n)
           38  +   if( n!=X )
           39  +    unused.insert(n);
           40  +
           41  +  while( !Q.empty() ) {
           42  +   int r=Q.front().first;
           43  +   int x=Q.front().second;
           44  +   Q.pop();
           45  +
           46  +   int xl = x-(int)sqrt((double)C*x);
           47  +   set<int>::iterator it = unused.lower_bound(xl);
           48  +   if( it==unused.end() )
           49  +    return false;
           50  +   if(r > 1) {
           51  +    Q.push( make_pair(r-1,max(*it,x)) );
           52  +    Q.push( make_pair(r-1,min(*it,x)) );
           53  +   }
           54  +   unused.erase(it);
           55  +  }
           56  +  return true;
           57  + }
           58  +
           59  +// BEGIN CUT HERE
           60  + public:
           61  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           62  + private:
           63  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           64  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           65  + void test_case_0() { int Arg0 = 2; int Arg1 = 0; int Arg2 = 1; verify_case(0, Arg2, greatestSeed(Arg0, Arg1)); }
           66  + void test_case_1() { int Arg0 = 3; int Arg1 = 1; int Arg2 = 6; verify_case(1, Arg2, greatestSeed(Arg0, Arg1)); }
           67  + void test_case_2() { int Arg0 = 4; int Arg1 = 1; int Arg2 = 9; verify_case(2, Arg2, greatestSeed(Arg0, Arg1)); }
           68  + void test_case_3() { int Arg0 = 7; int Arg1 = 3; int Arg2 = 50; verify_case(3, Arg2, greatestSeed(Arg0, Arg1)); }
           69  + void test_case_4() { int Arg0 = 15; int Arg1 = 180; int Arg2 = 9755; verify_case(4, Arg2, greatestSeed(Arg0, Arg1)); }
           70  +
           71  +// END CUT HERE
           72  +};
           73  +// BEGIN CUT HERE
           74  +int main() { RPSTournament().run_test(-1); }
           75  +// END CUT HERE

Added SRM/340-U/1A.cpp version [5df1a0f8d5879ebe]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class ProblemsToSolve
           19  +{
           20  +public:
           21  + int minNumber(vector <int> pre, int variety)
           22  + {
           23  +  int ans = pre.size();
           24  +  for(int i=0; i<pre.size(); ++i)
           25  +   for(int j=i+1; j<pre.size(); ++j)
           26  +    if( abs(pre[i]-pre[j]) >= variety )
           27  +     ans = min(ans, solve(min(i,j), max(i,j)));
           28  +  return ans;
           29  + }
           30  +
           31  + int solve(int S, int D)
           32  + {
           33  +  return (S+1)/2+1 + (D-S+1)/2;
           34  + }
           35  +
           36  +// BEGIN CUT HERE
           37  + public:
           38  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           39  + private:
           40  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           41  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           42  + void test_case_0() { int Arr0[] = {1, 2, 3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 2; verify_case(0, Arg2, minNumber(Arg0, Arg1)); }
           43  + void test_case_1() { int Arr0[] = {1, 2, 3, 4, 5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 3; verify_case(1, Arg2, minNumber(Arg0, Arg1)); }
           44  + void test_case_2() { int Arr0[] = {10, 1, 12, 101}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 100; int Arg2 = 3; verify_case(2, Arg2, minNumber(Arg0, Arg1)); }
           45  + void test_case_3() { int Arr0[] = {10, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 9; int Arg2 = 2; verify_case(3, Arg2, minNumber(Arg0, Arg1)); }
           46  + void test_case_4() { int Arr0[] = {6, 2, 6, 2, 6, 3, 3, 3, 7}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 2; verify_case(4, Arg2, minNumber(Arg0, Arg1)); }
           47  +
           48  +// END CUT HERE
           49  +};
           50  +// BEGIN CUT HERE
           51  +int main() { ProblemsToSolve().run_test(-1); }
           52  +// END CUT HERE

Added SRM/340-U/1B.cpp version [bcaad1def4f8a2ec]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class CsCourses
           19  +{
           20  +public:
           21  + vector <int> getOrder(vector <int> theoreticalValue, vector <int> practicalValue, vector <int> expire, int skillBound)
           22  + {
           23  +  typedef pair<int,int> State;
           24  +
           25  +  vector<State> Q;
           26  +  Q.push_back( State(0,0) );
           27  +  map<State, State> prev;
           28  +  map<State, int> lect;
           29  +  lect[State(0,0)] = -1;
           30  +
           31  +  for(int Month=0; !Q.empty(); ++Month)
           32  +  {
           33  +   vector<State> Q2;
           34  +   for(int i=0; i<Q.size(); ++i)
           35  +   {
           36  +    State s = Q[i];
           37  +    int th=s.first, pr=s.second;
           38  +    if( min(th,pr) >= skillBound )
           39  +    {
           40  +     vector<int> ans;
           41  +     for(State p=s; lect[p]>=0; p=prev[p])
           42  +      ans.push_back(lect[p]);
           43  +     reverse(ans.begin(), ans.end());
           44  +     return ans;
           45  +    }
           46  +
           47  +    for(int k=0; k<theoreticalValue.size(); ++k)
           48  +     if( th >= theoreticalValue[k]-1
           49  +      && pr >= practicalValue[k]-1
           50  +      && Month < expire[k] )
           51  +     {
           52  +      State s2( max(th,theoreticalValue[k]), max(pr, practicalValue[k]) );
           53  +      if( !lect.count(s2) )
           54  +       Q2.push_back(s2), prev[s2]=s, lect[s2]=k;
           55  +     }
           56  +   }
           57  +   Q.swap(Q2);
           58  +  }
           59  +
           60  +  return vector<int>();
           61  + }
           62  +
           63  +// BEGIN CUT HERE
           64  + public:
           65  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
           66  + private:
           67  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           68  + void verify_case(int Case, const vector <int> &Expected, const vector <int> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
           69  + void test_case_0() { int Arr0[] = {1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; int Arr4[] = {0 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(0, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
           70  + void test_case_1() { int Arr0[] = {1, 2, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2, 1, 1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {5, 5, 5}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; int Arr4[] = {2, 0, 1 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(1, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
           71  + void test_case_2() { int Arr0[] = {1, 2, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2, 1, 1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 1, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; vector <int> Arg4; verify_case(2, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
           72  + void test_case_3() { int Arr0[] = {1, 2, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2, 1, 1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {3, 2, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; int Arr4[] = {2, 1, 0 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(3, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
           73  + void test_case_4() { int Arr0[] = {1, 2, 3, 4, 5, 6, 7}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 2, 3, 4, 5, 6, 7}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 2, 3, 4, 5, 6, 7}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 7; int Arr4[] = {0, 1, 2, 3, 4, 5, 6 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(4, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
           74  + void test_case_5() { int Arr0[] = {0, 1, 2, 2, 1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0, 0, 1, 2, 1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {9, 9, 9, 9, 9}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; int Arr4[] = {4, 3 }; vector <int> Arg4(Arr4, Arr4 + (sizeof(Arr4) / sizeof(Arr4[0]))); verify_case(5, Arg4, getOrder(Arg0, Arg1, Arg2, Arg3)); }
           75  +
           76  +// END CUT HERE
           77  +};
           78  +// BEGIN CUT HERE
           79  +int main() { CsCourses().run_test(-1); }
           80  +// END CUT HERE

Added SRM/341/1A.cpp version [1da7b34c9052097a]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class KLastNonZeroDigits
           19  +{
           20  +public:
           21  + string getKDigits(int N, int K)
           22  + {
           23  +  // 20! = 20*..*11*10! < 20*..*11*2^22
           24  +  //                    < 16^10 * 2^22
           25  +  //                    = 2^62
           26  +
           27  +  // 10^K
           28  +  LL Z = 1;
           29  +  for(int i=0; i<K; ++i)
           30  +   Z *= 10;
           31  +
           32  +  // N!
           33  +  LL x = 1;
           34  +  for(LL n=2; n<=N; ++n)
           35  +   x *= n;
           36  +  while(x%10==0)
           37  +   x /= 10;
           38  +
           39  +  // Output
           40  +  stringstream sout;
           41  +  if( x < Z )
           42  +   sout << x;
           43  +  else
           44  +   sout << setw(K) << setfill('0') << x%Z;
           45  +  return sout.str();
           46  + }
           47  +
           48  +// BEGIN CUT HERE
           49  + public:
           50  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
           51  + private:
           52  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           53  + void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           54  + void test_case_0() { int Arg0 = 10; int Arg1 = 3; string Arg2 = "288"; verify_case(0, Arg2, getKDigits(Arg0, Arg1)); }
           55  + void test_case_1() { int Arg0 = 6; int Arg1 = 1; string Arg2 = "2"; verify_case(1, Arg2, getKDigits(Arg0, Arg1)); }
           56  + void test_case_2() { int Arg0 = 6; int Arg1 = 3; string Arg2 = "72"; verify_case(2, Arg2, getKDigits(Arg0, Arg1)); }
           57  + void test_case_3() { int Arg0 = 7; int Arg1 = 2; string Arg2 = "04"; verify_case(3, Arg2, getKDigits(Arg0, Arg1)); }
           58  + void test_case_4() { int Arg0 = 20; int Arg1 = 9; string Arg2 = "200817664"; verify_case(4, Arg2, getKDigits(Arg0, Arg1)); }
           59  + void test_case_5() { int Arg0 = 1; int Arg1 = 1; string Arg2 = "1"; verify_case(5, Arg2, getKDigits(Arg0, Arg1)); }
           60  +
           61  +// END CUT HERE
           62  +};
           63  +// BEGIN CUT HERE
           64  +int main() { KLastNonZeroDigits().run_test(-1); }
           65  +// END CUT HERE

Added SRM/341/1B.cpp version [bcf3463f5c537591]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +int dy[] = {-1,1, 0,0,-1,-1, 1,1};
           19  +int dx[] = { 0,0,-1,1,-1, 1,-1,1};
           20  +
           21  +class LandAndSea
           22  +{
           23  +public:
           24  + vector<int> howManyIslands(vector<string> seaMap)
           25  + {
           26  +  const int Y = seaMap.size();
           27  +  const int X = seaMap[0].size();
           28  +
           29  +  // paint
           30  +  vector< vector<int> > idMap(Y, vector<int>(X, -1));
           31  +  int nIsland = 0;
           32  +  for(int y=0; y<Y; ++y)
           33  +  for(int x=0; x<X; ++x)
           34  +   if( seaMap[y][x]=='x' && idMap[y][x]==-1 )
           35  +   {
           36  +    int id = (idMap[y][x] = nIsland++);
           37  +    stack< pair<int,int> > S;
           38  +    S.push( make_pair(y,x) );
           39  +    while( !S.empty() ) {
           40  +     pair<int,int> p = S.top();  S.pop();
           41  +     for(int i=0; i<8; ++i) {
           42  +      int yy = p.first +dy[i];
           43  +      int xx = p.second+dx[i];
           44  +      if( 0<=yy && yy<Y && 0<=xx && xx<X )
           45  +       if( seaMap[yy][xx]=='x' && idMap[yy][xx]==-1 )
           46  +        idMap[yy][xx] = id, S.push( make_pair(yy,xx) );
           47  +     }
           48  +    }
           49  +   }
           50  +
           51  +  // I is contained by J
           52  +  vector<int> refered(nIsland);
           53  +  vector<int> ct(nIsland, -1);
           54  +
           55  +  set<int> outer_world;
           56  +  while( outer_world.size() < nIsland )
           57  +  {
           58  +   set<int> outer2;
           59  +   for(int I=0; I<nIsland; ++I)
           60  +    if( !outer_world.count(I) )
           61  +    {
           62  +     stack< pair<int,int> > S;
           63  +     set< pair<int,int> > vis;
           64  +     for(int y=0; y<Y; ++y)
           65  +      for(int x=0; x<X; ++x)
           66  +       if( idMap[y][x] == I )
           67  +        S.push( make_pair(y,x) ), vis.insert(S.top());
           68  +
           69  +     int sID = -1;
           70  +     while( !S.empty() ) {
           71  +      pair<int,int> p = S.top();  S.pop();
           72  +      for(int i=0; i<4; ++i) {
           73  +       int yy = p.first+dy[i];
           74  +       int xx = p.second+dx[i];
           75  +       if( !(0<=yy && yy<Y && 0<=xx && xx<X) )
           76  +        goto notContained;
           77  +       int ssID = idMap[yy][xx];
           78  +       if( outer_world.count(ssID) )
           79  +        {sID=ssID; goto notContained;}
           80  +
           81  +       pair<int,int> pp(yy,xx);
           82  +       if( !vis.count(pp) && seaMap[yy][xx]=='.' )
           83  +        S.push(pp), vis.insert(S.top());
           84  +      }
           85  +     }
           86  +     continue;
           87  +    notContained:
           88  +     outer2.insert(I);
           89  +     if(sID != -1) {
           90  +      ct[I] = sID;
           91  +      refered[sID]++;
           92  +     }
           93  +    }
           94  +   outer_world.insert(outer2.begin(), outer2.end());
           95  +  }
           96  +
           97  +  // topological sort
           98  +  vector<int> level(nIsland, -1);
           99  +  for(int L=0;;++L)
          100  +  {
          101  +   vector<int> victim;
          102  +
          103  +   for(int I=0; I<nIsland; ++I)
          104  +    if( level[I] == -1 && refered[I] == 0 )
          105  +     level[I] = L, victim.push_back(I);
          106  +
          107  +   if( victim.size() == 0 )
          108  +    break;
          109  +
          110  +   for(int i=0; i<victim.size(); ++i)
          111  +   {
          112  +    int J = ct[victim[i]];
          113  +    if( J != -1 )
          114  +     refered[J]--;
          115  +   }
          116  +  }
          117  +
          118  +  vector<int> ans;
          119  +  for(int i=0; i<level.size(); ++i) {
          120  +   if( level[i]+1 > ans.size() )
          121  +    ans.resize( level[i]+1 );
          122  +   ans[level[i]]++;
          123  +  }
          124  +  return ans;
          125  + }
          126  +
          127  +// BEGIN CUT HERE
          128  + public:
          129  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
          130  + private:
          131  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          132  + void verify_case(int Case, const vector <int> &Expected, const vector <int> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
          133  + void test_case_0() { string Arr0[] = {"x"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(0, Arg1, howManyIslands(Arg0)); }
          134  + void test_case_1() { string Arr0[] = {
          135  +"xxxxx",
          136  +"x...x",
          137  +"x.x.x",
          138  +"x...x",
          139  +"xxxxx"
          140  +}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(1, Arg1, howManyIslands(Arg0)); }
          141  + void test_case_2() { string Arr0[] = {
          142  +"xxxxx",
          143  +"x...x",
          144  +"x.x.x",
          145  +"x...x",
          146  +"xxxxx",
          147  +"xxxxx",
          148  +"x...x",
          149  +"x.x.x",
          150  +"x...x",
          151  +"xxxxx"
          152  +}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2, 1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(2, Arg1, howManyIslands(Arg0)); }
          153  + void test_case_3() { string Arr0[] = {
          154  +"..",
          155  +".."
          156  +}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); vector <int> Arg1; verify_case(3, Arg1, howManyIslands(Arg0)); }
          157  + void test_case_4() { string Arr0[] = {
          158  +"............",
          159  +".......xxxx.",
          160  +"..xxx.x...x.",
          161  +"..x..x..x.x.",
          162  +"..x.x.x...x.",
          163  +"..xx...xxx.."
          164  +}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(4, Arg1, howManyIslands(Arg0)); }
          165  +
          166  +// END CUT HERE
          167  +};
          168  +// BEGIN CUT HERE
          169  +int main() { LandAndSea().run_test(-1); }
          170  +// END CUT HERE

Added SRM/341/1C.cpp version [655c27d7a69723ce]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +vector<LL> vMul( const vector< vector<LL> >& A, const vector<LL>& B )
           20  +{
           21  + const int n = A.size();
           22  +
           23  + vector<LL> C(n);
           24  + for(int i=0; i<n; ++i)
           25  +  for(int j=0; j<n; ++j)
           26  +   C[i] += A[i][j] * B[j];
           27  + return C;
           28  +}
           29  +
           30  +vector< vector<LL> > mMul( const vector< vector<LL> >& A, const vector< vector<LL> >& B )
           31  +{
           32  + const int n = A.size();
           33  +
           34  + vector< vector<LL> > C(n, vector<LL>(n));
           35  + for(int i=0; i<n; ++i)
           36  +  for(int j=0; j<n; ++j) {
           37  +   LL Cij = 0;
           38  +   for(int k=0; k<n; ++k)
           39  +    Cij += A[i][k] * B[k][j];
           40  +   C[i][j] = Cij;
           41  +  }
           42  + return C;
           43  +}
           44  +
           45  +vector< vector<LL> > mPow( vector< vector<LL> > M, int t )
           46  +{
           47  + if( t == 0 ) {
           48  +  vector< vector<LL> > R(M.size(), vector<LL>(M.size()));
           49  +  for(int i=0; i<R.size(); ++i) R[i][i] = 1;
           50  +  return R;
           51  + }
           52  + vector< vector<LL> > R;
           53  + for(; t; t>>=1, M=mMul(M,M))
           54  +  if( t&1 )
           55  +   R = (R.empty() ? M : mMul(R,M));
           56  + return R;
           57  +}
           58  +
           59  +class ValidPlates
           60  +{
           61  +public:
           62  + map<pair<int,int>, LL> memo;
           63  +
           64  + string getPlate(vector <string> profane, int seqno)
           65  + {
           66  +  // parse
           67  +  bool proh[10][10] = {};
           68  +  for(int i=0; i<profane.size(); ++i) {
           69  +   stringstream sin(profane[i]);
           70  +   for(int n; sin>>n; )
           71  +    proh[n/10][n%10] = true;
           72  +  }
           73  +
           74  +  // matrix
           75  +  vector<LL> N(11, 1); N[10] = 0;
           76  +  vector< vector<LL> > M(11, vector<LL>(11));
           77  +  for(int i=0; i<10; ++i)
           78  +  for(int j=0; j<10; ++j)
           79  +   if( !proh[i][j] )
           80  +    M[i][j] = 1;
           81  +  for(int j=1; j<11; ++j)
           82  +   M[10][j] = 1;
           83  +
           84  +  // binary search...
           85  +  LL L=-1, R=0;
           86  +  for(LL atprev=-1;; R=R*2+1)
           87  +  {
           88  +   vector< vector<LL> > Mt = mPow(M,  R);
           89  +   vector<LL>           Nt = vMul(Mt, N);
           90  +   LL                   at = accumulate(Nt.begin()+1, Nt.end(), 0LL);
           91  +   if( atprev == at )
           92  +    return "";
           93  +   atprev = at;
           94  +   if( seqno <= at )
           95  +    break;
           96  +  }
           97  +  while(R-L>1)
           98  +  {
           99  +   LL C=(L+R)/2;
          100  +   vector< vector<LL> > Mt = mPow(M, C);
          101  +   vector<LL>           Nt = vMul(Mt, N);
          102  +   (seqno <= accumulate(Nt.begin()+1, Nt.end(), 0LL) ? R : L) = C;
          103  +  }
          104  +  LL d = R+1; // #digits
          105  +  seqno -= vMul(mPow(M,R), N)[10];
          106  +
          107  +  string buf;
          108  +  int prev = -1;
          109  +  for(int i=0; i<(d>50 ? 47 : d); ++i)
          110  +   if( prev == -1 )
          111  +   {
          112  +    vector<LL> Nt = vMul(mPow(M, d-1-i), N);
          113  +    LL n = 0;
          114  +    for(int a=1; a<10; ++a)
          115  +    {
          116  +     n += Nt[a];
          117  +     if( seqno <= n )
          118  +      {buf += char('0'+a); prev=a; seqno-=n-Nt[a]; break;}
          119  +    }
          120  +   }
          121  +   else
          122  +   {
          123  +    vector<LL> Nt = vMul(mPow(M, d-1-i), N);
          124  +    LL n = 0;
          125  +    for(int a=0; a<10; ++a) if( !proh[prev][a] )
          126  +    {
          127  +     n += Nt[a];
          128  +     if( seqno <= n )
          129  +      {buf += char('0'+a); prev=a; seqno-=n-Nt[a]; break;}
          130  +    }
          131  +   }
          132  +  return (d>50 ? buf+"..." : buf);
          133  + }
          134  +
          135  +// BEGIN CUT HERE
          136  + public:
          137  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); }
          138  + private:
          139  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          140  + void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
          141  + void test_case_0() { vector <string> Arg0; int Arg1 = 1000; string Arg2 = "1000"; verify_case(0, Arg2, getPlate(Arg0, Arg1)); }
          142  + void test_case_1() { string Arr0[] = {"10"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 10; string Arg2 = "11"; verify_case(1, Arg2, getPlate(Arg0, Arg1)); }
          143  + void test_case_2() { string Arr0[] = {"10"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2000000000; string Arg2 = "2277659869"; verify_case(2, Arg2, getPlate(Arg0, Arg1)); }
          144  + void test_case_3() { string Arr0[] = {"00 01 02 03 04 05 06 07 08 09 11 12 13 14 15 16 17",
          145  + "18 19 22 23 24 25 26 27 28 29 33 34 35 36 37 38 39",
          146  + "44 45 46 47 48 49 55 56 57 58 59 66 67 68 69 77 78",
          147  + "79 88 89 99 99 99 99 99"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1023; string Arg2 = ""; verify_case(3, Arg2, getPlate(Arg0, Arg1)); }
          148  + void test_case_4() { string Arr0[] = {"00 01 02 03 04 05 07 08 09",
          149  + "10 11 12 13 14 15 17 18 19",
          150  + "20 21 22 24 25 26 27 28 29",
          151  + "30 31 32 33 34 36 37 38 39",
          152  + "41 43 45 46 48",
          153  + "52 53 54 55 56 58 59",
          154  + "60 61 63 64 66 67 68 69",
          155  + "70 72 73 74 75 76 77 78",
          156  + "80 81 82 83 84 86 87 88 89",
          157  + "90 91 92 94 95 96 97 98"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2000000000; string Arg2 = "79999999351623516571657999935799993"; verify_case(4, Arg2, getPlate(Arg0, Arg1)); }
          158  + void test_case_5() { string Arr0[] = {"00 01 02 03 04 05 06 07 08 09",
          159  + "10 11 12 13 14 16 17 19",
          160  + "20 21 22 23 24 25 26 27 28 29",
          161  + "30 31 32 33 34 35 36 38 39",
          162  + "41 42 43 44 45 46 49",
          163  + "50 52 53 54 55 57 58 59",
          164  + "60 61 62 63 64 65 66 67 68 69",
          165  + "70 72 73 74 75 76 77 78 79",
          166  + "80 81 82 83 84 85 86 87 88 89",
          167  + "90 91 92 93 94 95 98 99"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2000000000; string Arg2 = "37151515151515151515151515151515151515151515151..."; verify_case(5, Arg2, getPlate(Arg0, Arg1)); }
          168  + void test_case_6() { string Arr0[] = {"00 01 02 03 04 05 06 07 08 09", "10 12 13 14 15 16 17 18 19", "20 21 22 23 24 25 26 27 28 29", "30 31 32 33 34 35 36 37 38 39", "40 41 42 43 44 45 46 47 48 49", "50 51 52 53 54 55 56 57 58 59", "60 61 62 63 64 65 66 67 68 69", "70 71 72 73 74 75 76 77 78 79", "80 81 82 83 84 85 86 87 88 89", "90 91 92 93 94 95 96 97 98 99"};
          169  + vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2000000000; string Arg2 = "11111111111111111111111111111111111111111111111..."; verify_case(6, Arg2, getPlate(Arg0, Arg1)); }
          170  +
          171  +// END CUT HERE
          172  +};
          173  +// BEGIN CUT HERE
          174  +int main() { ValidPlates().run_test(-1); }
          175  +// END CUT HERE

Added SRM/342/1A.cpp version [d1f9e48a4c45888d]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +int get_and_go( const string& a, int& i )
           19  +{
           20  + int dict[] =
           21  +  {'a','b','k','d','e','g','h','i','l','m','n','n'/*g*/,'o','p','r','s','t','u','w','y'};
           22  + for(int k=0;; ++k)
           23  +  if( dict[k] == a[i] )
           24  +   if( a[i]=='n' && i+1<a.size() && a[i+1]=='g' )
           25  +    {i+=2; return k+1;}
           26  +   else
           27  +    {i++;  return k;}
           28  +}
           29  +
           30  +bool tgcmp( const string& a, const string& b )
           31  +{
           32  + int i=0, j=0;
           33  + for(;;)
           34  + {
           35  +  if( i==a.size() && j==b.size() )
           36  +   return false;
           37  +  if( i==a.size() )
           38  +   return true;
           39  +  if( j==b.size() )
           40  +   return false;
           41  +
           42  +  int ai = get_and_go(a, i);
           43  +  int bj = get_and_go(b, j);
           44  +  if( ai != bj )
           45  +   return ai < bj;
           46  + }
           47  +}
           48  +
           49  +class TagalogDictionary
           50  +{
           51  +public:
           52  + vector <string> sortWords(vector <string> words)
           53  + {
           54  +  sort( words.begin(), words.end(), &tgcmp );
           55  +  return words;
           56  + }
           57  +
           58  +// BEGIN CUT HERE
           59  + public:
           60  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
           61  + private:
           62  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           63  + void verify_case(int Case, const vector <string> &Expected, const vector <string> &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } }
           64  + void test_case_0() { string Arr0[] = {"abakada","alpabet","tagalog","ako"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"abakada", "ako", "alpabet", "tagalog" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(0, Arg1, sortWords(Arg0)); }
           65  + void test_case_1() { string Arr0[] = {"ang","ano","anim","alak","alam","alab"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"alab", "alak", "alam", "anim", "ano", "ang" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(1, Arg1, sortWords(Arg0)); }
           66  + void test_case_2() { string Arr0[] = {"siya","niya","kaniya","ikaw","ito","iyon"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"kaniya", "ikaw", "ito", "iyon", "niya", "siya" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(2, Arg1, sortWords(Arg0)); }
           67  + void test_case_3() { string Arr0[] = {"kaba","baka","naba","ngipin","nipin"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"baka", "kaba", "naba", "nipin", "ngipin" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(3, Arg1, sortWords(Arg0)); }
           68  + void test_case_4() { string Arr0[] = {"knilngiggnngginggn","ingkigningg","kingkong","dingdong","dindong","dingdont","ingkblot"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"kingkong", "knilngiggnngginggn", "dindong", "dingdont", "dingdong", "ingkblot", "ingkigningg" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(4, Arg1, sortWords(Arg0)); }
           69  + void test_case_5() { string Arr0[] = {"silangang", "baka", "bada", "silang"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arr1[] = {"baka", "bada", "silang", "silangang" }; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); verify_case(5, Arg1, sortWords(Arg0)); }
           70  +
           71  +// END CUT HERE
           72  +};
           73  +// BEGIN CUT HERE
           74  +int main() {
           75  + TagalogDictionary().run_test(-1);
           76  +}
           77  +// END CUT HERE

Added SRM/342/1B.cpp version [7881a6a8a8d93b4d]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +static const int MODNUM = 1000000007;
           19  +
           20  +// make [i,j) by k[z..$]
           21  +LL dp[31][31][51][51];
           22  +
           23  +class ReverseResources
           24  +{
           25  +public:
           26  + int findDecompositions(string str, vector <string> resources)
           27  + {
           28  +  memset(dp, 0xff, sizeof(dp));
           29  +
           30  +  LL sum = 0;
           31  +  for(int k=0; k<resources.size(); ++k)
           32  +   sum = (sum + rec(0, str.size(), k, 0, str, resources, dp)) % MODNUM;
           33  +  return sum;
           34  + }
           35  +
           36  + LL rec(int i, int j, int k, int z, string& s, vector<string>& rs, LL dp[31][31][51][51] )
           37  + {
           38  +  if( dp[i][j][k][z] >= 0 )
           39  +   return dp[i][j][k][z];
           40  +
           41  +  string& r = rs[k];
           42  +  if( z==r.size() )
           43  +   return dp[i][j][k][z] = (i==j ? 1 : 0);
           44  +
           45  +  if( r[z] == '%' )
           46  +  {
           47  +   LL sum = 0;
           48  +   if( z+2 == r.size() )
           49  +   {
           50  +    for(int kk=0; kk<rs.size(); ++kk)
           51  +     sum = (sum + rec(i, j, kk, 0, s, rs, dp)) % MODNUM;
           52  +   }
           53  +   else
           54  +   {
           55  +    for(int jj=i+1; jj<j; ++jj)
           56  +    {
           57  +     LL right = rec(jj, j, k, z+2, s, rs, dp);
           58  +     if( right ) {
           59  +      LL left = 0;
           60  +      for(int kk=0; kk<rs.size(); ++kk)
           61  +       left = (left + rec(i, jj, kk, 0, s, rs, dp)) % MODNUM;
           62  +      sum = (sum + left*right) % MODNUM;
           63  +     }
           64  +    }
           65  +   }
           66  +   return dp[i][j][k][z] = sum;
           67  +  }
           68  +  else
           69  +  {
           70  +   if( r[z]==s[i] && i+1<=j )
           71  +    return dp[i][j][k][z] = rec(i+1,j,k,z+1,s,rs,dp);
           72  +   else
           73  +    return dp[i][j][k][z] = 0;
           74  +  }
           75  + }
           76  +
           77  +// BEGIN CUT HERE
           78  + public:
           79  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); }
           80  + private:
           81  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           82  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           83  + void test_case_0() { string Arg0 = "Error in module foo, code 123."; string Arr1[] = {"foo", "123", "Error in module %s.", "%s, code %s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 1; verify_case(0, Arg2, findDecompositions(Arg0, Arg1)); }
           84  + void test_case_1() { string Arg0 = "The fox jumped over the dog."; string Arr1[] = {"The fox %s over the dog.",
           85  + "lazy",
           86  + "brown",
           87  + "jump%s",
           88  + "s",
           89  + "ed",
           90  + "The %s",
           91  + "fox %s",
           92  + "%s over %s",
           93  + "the dog."}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 5; verify_case(1, Arg2, findDecompositions(Arg0, Arg1)); }
           94  + void test_case_2() { string Arg0 = "abcde"; string Arr1[] = {"%sc%s", "b", "de", "a%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 2; verify_case(2, Arg2, findDecompositions(Arg0, Arg1)); }
           95  + void test_case_3() { string Arg0 = "abcde"; string Arr1[] = {"%se", "a%s", "%sb%s", "%sc%s", "%sd%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 0; verify_case(3, Arg2, findDecompositions(Arg0, Arg1)); }
           96  + void test_case_4() { string Arg0 = "aaaaa"; string Arr1[] = {"a","%s%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 14; verify_case(4, Arg2, findDecompositions(Arg0, Arg1)); }
           97  + void test_case_5() { string Arg0 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; string Arr1[] = {"a","aa","%s%s","%sa","a%s","aaa","aa%s","a%sa",
           98  +"a%s%s","%saa","%sa%s","%s%sa","%s%s%s","aaaa",
           99  +"aaa%s","aa%sa","aa%s%s","a%saa","a%sa%s","a%s%sa",
          100  +"a%s%s%s","%saaa","%saa%s","%sa%sa","%sa%s%s",
          101  +"%s%saa","%s%sa%s","%s%s%sa","%s%s%s%s","aaaaa",
          102  +"aaaa%s","aaa%sa","aaa%s%s","aa%saa","aa%sa%s",
          103  +"aa%s%sa","aa%s%s%s","a%saaa","a%saa%s","a%sa%sa",
          104  +"a%sa%s%s","a%s%saa","a%s%sa%s","a%s%s%sa",
          105  +"a%s%s%s%s","%saaaa","%saaa%s","%saa%sa","%saa%s%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 879704799; verify_case(5, Arg2, findDecompositions(Arg0, Arg1)); }
          106  + void test_case_6() { string Arg0 = "aa"; string Arr1[] = {"a", "a", "%s%s", "%s%s"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 8; verify_case(6, Arg2, findDecompositions(Arg0, Arg1)); }
          107  +
          108  +// END CUT HERE
          109  +};
          110  +// BEGIN CUT HERE
          111  +int main() { ReverseResources().run_test(-1); }
          112  +// END CUT HERE

Added SRM/342/1C.cpp version [067a5c147f5030d5]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +vector< vector<LL> > mMul( const vector< vector<LL> >& A, const vector< vector<LL> >& B )
           19  +{
           20  + const int n = A.size();
           21  +
           22  + vector< vector<LL> > C(n, vector<LL>(n));
           23  + for(int i=0; i<n; ++i)
           24  +  for(int j=0; j<n; ++j) {
           25  +   LL Cij = 0;
           26  +   for(int k=0; k<n; ++k)
           27  +    Cij += A[i][k] * B[k][j];
           28  +   C[i][j] = Cij % 1000003;
           29  +  }
           30  + return C;
           31  +}
           32  +
           33  +vector< vector<LL> > mPow( vector< vector<LL> > M, int t ) // t>0
           34  +{
           35  + vector< vector<LL> > R;
           36  + for(; t; t>>=1, M=mMul(M,M))
           37  +  if( t&1 )
           38  +   R = (R.empty() ? M : mMul(R,M));
           39  + return R;
           40  +}
           41  +
           42  +class DrivingAround
           43  +{
           44  +public:
           45  + int numberOfWays(vector <string> adj, int start, int finish, int time)
           46  + {
           47  +  int n = adj.size()*5;
           48  +  vector< vector<LL> > M(n, vector<LL>(n));
           49  +  for(int u=0; u<adj.size(); ++u)
           50  +   for(int d=0; d<4; ++d)
           51  +    M[u*5+d+1][u*5+d] = 1;
           52  +
           53  +  for(int u=0; u<adj.size(); ++u)
           54  +  for(int v=0; v<adj.size(); ++v)
           55  +   if( adj[u][v] != '.' )
           56  +    M[u*5][v*5+adj[u][v]-'0'-1] = 1;
           57  +
           58  +  return int( mPow(M, time)[start*5][finish*5] );
           59  + }
           60  +
           61  +// BEGIN CUT HERE
           62  + public:
           63  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           64  + private:
           65  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           66  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           67  + void test_case_0() { string Arr0[] = {".12",
           68  + "2.1",
           69  + "12."}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 0; int Arg2 = 2; int Arg3 = 5; int Arg4 = 8; verify_case(0, Arg4, numberOfWays(Arg0, Arg1, Arg2, Arg3)); }
           70  + void test_case_1() { string Arr0[] = {"....52....",
           71  + "..5.......",
           72  + "..........",
           73  + ".......1..",
           74  + "......42.2",
           75  + "5...4.....",
           76  + ".5...4...1",
           77  + "......5...",
           78  + ".3244.....",
           79  + ".........."}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 2; int Arg3 = 10; int Arg4 = 0; verify_case(1, Arg4, numberOfWays(Arg0, Arg1, Arg2, Arg3)); }
           80  + void test_case_2() { string Arr0[] = {"...14....1",
           81  + "......13..",
           82  + ".2...4....",
           83  + "....52.5..",
           84  + "1.3..4....",
           85  + ".3....35.5",
           86  + "4......1.1",
           87  + "..4.4.1.54",
           88  + "....4.11.5",
           89  + "31144.2.4."}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; int Arg2 = 2; int Arg3 = 100; int Arg4 = 316984; verify_case(2, Arg4, numberOfWays(Arg0, Arg1, Arg2, Arg3)); }
           90  + void test_case_3() { string Arr0[] = {".555555555", "5.55555555", "55.5554555", "555.555555", "5555.55555", "55555.5555", "555555.555", "5555555.55", "55553555.5", "555555555."};
           91  +vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 0; int Arg2 = 7; int Arg3 = 1000000000; int Arg4 = 255218; verify_case(3, Arg4, numberOfWays(Arg0, Arg1, Arg2, Arg3)); }
           92  +// END CUT HERE
           93  +};
           94  +// BEGIN CUT HERE
           95  +int main() { DrivingAround().run_test(-1); }
           96  +// END CUT HERE

Added SRM/343/1A.cpp version [caafadae3df4cf52]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class CDPlayer
           19  +{
           20  +public:
           21  + int isRandom(vector <string> songlist, int n)
           22  + {
           23  +  string s;
           24  +  for(int i=0; i<songlist.size(); ++i)
           25  +   s += songlist[i];
           26  +
           27  +  for(int k=0; k<n; ++k)
           28  +   if( check(s, k, n) )
           29  +    return k;
           30  +  return -1;
           31  + }
           32  +
           33  + bool check(const string& s, int k, int n)
           34  + {
           35  +  for(int i=0,e=k; i<s.size(); i=e,e+=n)
           36  +   if( !distinct(s, i, min<int>(e,s.size())) )
           37  +    return false;
           38  +  return true;
           39  + }
           40  +
           41  + bool distinct( const string& s, int i, int e )
           42  + {
           43  +  set<char> x;
           44  +  for(; i<e; ++i)
           45  +   if( x.count(s[i]) )
           46  +    return false;
           47  +   else
           48  +    x.insert( s[i] );
           49  +  return true;
           50  + }
           51  +
           52  +
           53  +// BEGIN CUT HERE
           54  + public:
           55  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); }
           56  + private:
           57  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           58  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           59  + void test_case_0() { string Arr0[] = {"BBAC"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 1; verify_case(0, Arg2, isRandom(Arg0, Arg1)); }
           60  + void test_case_1() { string Arr0[] = {"BACAB",
           61  + "BCA"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 2; verify_case(1, Arg2, isRandom(Arg0, Arg1)); }
           62  + void test_case_2() { string Arr0[] = {"AAACBACBACBACBACBACBACB"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = -1; verify_case(2, Arg2, isRandom(Arg0, Arg1)); }
           63  + void test_case_3() { string Arr0[] = {"ABCDEABDECBAECDEDACB"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 5; int Arg2 = 0; verify_case(3, Arg2, isRandom(Arg0, Arg1)); }
           64  + void test_case_4() { string Arr0[] = {"ABCABCABCABCABCABCABC",
           65  + "ABCABCABCABCABCABCABC"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 22; int Arg2 = -1; verify_case(4, Arg2, isRandom(Arg0, Arg1)); }
           66  + void test_case_5() { string Arr0[] = {"AAAAAAAAAAAAAAAA",
           67  + "AAAAAAAAAAAAAAAA",
           68  + "AAAAAAAAAAAAAAAA",
           69  + "AAAAAAAAAAAAAAAA",
           70  + "AAAAAAAAAAAAAAAA",
           71  + "AAAAAAAAAAAAAAAA",
           72  + "AAAAAAAAAAAAAAAA",
           73  + "AAAAAAAAAAAAAAAA",
           74  + "AAAAAAAAAAAAAAAA",
           75  + "AAAAAAAAAAAAAAAA"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 1; int Arg2 = 0; verify_case(5, Arg2, isRandom(Arg0, Arg1)); }
           76  + void test_case_6() { string Arr0[] = {"ADEF"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 12; int Arg2 = 0; verify_case(6, Arg2, isRandom(Arg0, Arg1)); }
           77  +
           78  +// END CUT HERE
           79  +};
           80  +// BEGIN CUT HERE
           81  +int main() {
           82  + CDPlayer().run_test(-1);
           83  +}
           84  +// END CUT HERE

Added SRM/343/1B.cpp version [718000c8b2d4687f]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class MoneyGame
           19  +{
           20  +public:
           21  + int V1, V2, V3;
           22  + map<int, int> memo;
           23  + int play(vector <int> lennysCoins, vector <int> fredsCoins, vector <int> values)
           24  + {
           25  +  V1 = values[0];
           26  +  V2 = values[1];
           27  +  V3 = values[2];
           28  +  memo.clear();
           29  +  return rec( lennysCoins[0], lennysCoins[1], lennysCoins[2],
           30  +               fredsCoins[0],  fredsCoins[1],  fredsCoins[2], 0, 0, 0 );
           31  + }
           32  +
           33  + int rec(int L1, int L2, int L3, int F1, int F2, int F3, int B1, int B2, int B3)
           34  + {
           35  +  if( !L1 && !L2 && !L3 )
           36  +   return -(V1*F1+V2*F2+V3*F3);
           37  +  int key = (L1<<20)|(L2<<16)|(L3<<12)|(F1<<8)|(F2<<4)|(F3<<0);
           38  +  if( memo.count(key) )
           39  +   return memo[key];
           40  +
           41  +  int score = -0x7fffffff;
           42  +  if(L1) {
           43  +   for(int b1=0; b1<=B1 && V1*b1<V1; ++b1)
           44  +   for(int b2=0; b2<=B2 && V1*b1+V2*b2<V1; ++b2)
           45  +   for(int b3=0; b3<=B3 && V1*b1+V2*b2+V3*b3<V1; ++b3)
           46  +    score = max(score, -rec(F1, F2, F3, L1+b1-1, L2+b2, L3+b3, B1-b1+1, B2-b2, B3-b3));
           47  +  }
           48  +  if(L2) {
           49  +   for(int b1=0; b1<=B1 && V1*b1<V2; ++b1)
           50  +   for(int b2=0; b2<=B2 && V1*b1+V2*b2<V2; ++b2)
           51  +   for(int b3=0; b3<=B3 && V1*b1+V2*b2+V3*b3<V2; ++b3)
           52  +    score = max(score, -rec(F1, F2, F3, L1+b1, L2+b2-1, L3+b3, B1-b1, B2-b2+1, B3-b3));
           53  +  }
           54  +  if(L3) {
           55  +   for(int b1=0; b1<=B1 && V1*b1<V3; ++b1)
           56  +   for(int b2=0; b2<=B2 && V1*b1+V2*b2<V3; ++b2)
           57  +   for(int b3=0; b3<=B3 && V1*b1+V2*b2+V3*b3<V3; ++b3)
           58  +    score = max(score, -rec(F1, F2, F3, L1+b1, L2+b2, L3+b3-1, B1-b1, B2-b2, B3-b3+1));
           59  +  }
           60  +  return memo[key] = score;
           61  + }
           62  +
           63  +
           64  +// BEGIN CUT HERE
           65  + public:
           66  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
           67  + private:
           68  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           69  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           70  + void test_case_0() { int Arr0[] = {0,1,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {20,10,2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = -2; verify_case(0, Arg3, play(Arg0, Arg1, Arg2)); }
           71  + void test_case_1() { int Arr0[] = {0,1,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {20,10,2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; verify_case(1, Arg3, play(Arg0, Arg1, Arg2)); }
           72  + void test_case_2() { int Arr0[] = {1,1,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,5,10}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 0; verify_case(2, Arg3, play(Arg0, Arg1, Arg2)); }
           73  + void test_case_3() { int Arr0[] = {4,4,3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {4,3,4}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {100,753,100}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 600; verify_case(3, Arg3, play(Arg0, Arg1, Arg2)); }
           74  + void test_case_4() { int Arr0[] = {0,0,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {5,5,5}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1000,1000,1000}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = -15000; verify_case(4, Arg3, play(Arg0, Arg1, Arg2)); }
           75  + void test_case_5() { int Arr0[] = {3,2,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0,0}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {6,8,14}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 42; verify_case(5, Arg3, play(Arg0, Arg1, Arg2)); }
           76  +
           77  +// END CUT HERE
           78  +};
           79  +// BEGIN CUT HERE
           80  +int main() {
           81  + MoneyGame().run_test(-1);
           82  +}
           83  +// END CUT HERE

Added SRM/343/1C.cpp version [efa6784811dbad8e]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class RefactorableNumber
           19  +{
           20  +public:
           21  + vector<int> P;
           22  +
           23  + int count(int low, int high)
           24  + {
           25  +  P.clear();
           26  +  vector<bool> isP(2000, true);
           27  +  for(int p=2; p<2000; ++p)
           28  +   if( isP[p] ) {
           29  +    P.push_back(p);
           30  +    for(int q=p*p; q<2000; q+=p)
           31  +     isP[q] = false;
           32  +   }
           33  +
           34  +  int cnt = 0;
           35  +  for(int n=low; n<=high; ++n)
           36  +   if( ref(n) )
           37  +    ++cnt;
           38  +  return cnt;
           39  + }
           40  +
           41  + bool ref(int N)
           42  + {
           43  +  int n = N;
           44  +  int x = 1;
           45  +  for(int i=0; i<P.size() && n>1; ++i)
           46  +  {
           47  +   int p = P[i];
           48  +   if( p*p > n )
           49  +    break;
           50  +   int c = 0;
           51  +   while(n%p==0)
           52  +    n/=p, ++c;
           53  +   x *= c+1;
           54  +  }
           55  +  if(n>1)
           56  +   x *= 2;
           57  +  return N%x == 0;
           58  + }
           59  +
           60  +// BEGIN CUT HERE
           61  + public:
           62  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           63  + private:
           64  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           65  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           66  + void test_case_0() { int Arg0 = 1; int Arg1 = 10; int Arg2 = 4; verify_case(0, Arg2, count(Arg0, Arg1)); }
           67  + void test_case_1() { int Arg0 = 10; int Arg1 = 100; int Arg2 = 12; verify_case(1, Arg2, count(Arg0, Arg1)); }
           68  + void test_case_2() { int Arg0 = 25; int Arg1 = 35; int Arg2 = 0; verify_case(2, Arg2, count(Arg0, Arg1)); }
           69  + void test_case_3() { int Arg0 = 123; int Arg1 = 4567; int Arg2 = 315; verify_case(3, Arg2, count(Arg0, Arg1)); }
           70  +
           71  +// END CUT HERE
           72  +};
           73  +// BEGIN CUT HERE
           74  +int main() {
           75  + RefactorableNumber().run_test(-1);
           76  +}
           77  +// END CUT HERE

Added SRM/344/1A.cpp version [581a4d8a9088ed23]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class VolleyballTournament
           19  +{
           20  +public:
           21  + string reconstructResults(int wonMatches, int lostMatches, int wonSets, int lostSets)
           22  + {
           23  +  //0-3, 1-3, 2-3, 3-0, 3-1, 3-2
           24  +  //Z0   Z1   Z2   W0   W1   W2
           25  +
           26  +  //Z0+    Z1   + Z2                  == lostMatches
           27  +  //Z0*0 + Z1*1 + Z2*2 + 3*wonMatches == wonSets
           28  +
           29  +  //W0+W1+W2 == wonMatches
           30  +  //W0*0+W1*1+W2*2+3*lostMatches == lostSets
           31  +
           32  +  int a[6] = {-1};
           33  +  for(int Z1=0; Z1<=lostMatches; ++Z1)
           34  +  {
           35  +   int Z2 = (wonSets - 3*wonMatches - Z1) / 2;
           36  +   int Z0 = lostMatches - Z1 - Z2;
           37  +   if( Z0<0 || Z2<0 || lostMatches<Z0 || lostMatches<Z2 ) continue;
           38  +   if( Z1+Z2*2+3*wonMatches != wonSets ) continue;
           39  +
           40  +   for(int W1=0; W1<=wonMatches; ++W1)
           41  +   {
           42  +    int W2 = (lostSets - 3*lostMatches - W1) / 2;
           43  +    int W0 = wonMatches - W1 - W2;
           44  +    if( W0<0 || W2<0 || wonMatches<W0 || wonMatches<W2 ) continue;
           45  +    if( W1+W2*2+3*lostMatches != lostSets ) continue;
           46  +
           47  +    if( a[0]>=0 )
           48  +     return "AMBIGUITY";
           49  +    else
           50  +     a[0]=Z0, a[1]=Z1, a[2]=Z2, a[3]=W0, a[4]=W1, a[5]=W2;
           51  +   }
           52  +  }
           53  +  const char* s[6] = {"0-3", "1-3", "2-3", "3-0", "3-1", "3-2"};
           54  +
           55  +  string ans;
           56  +  for(int i=0; i<6; ++i)
           57  +   for(int j=0; j<a[i]; ++j)
           58  +    ans += s[i], ans += ",";
           59  +  ans.resize(ans.size()-1);
           60  +  return ans;
           61  + }
           62  +
           63  +// BEGIN CUT HERE
           64  + public:
           65  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           66  + private:
           67  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           68  + void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           69  + void test_case_0() { int Arg0 = 3; int Arg1 = 3; int Arg2 = 9; int Arg3 = 9; string Arg4 = "0-3,0-3,0-3,3-0,3-0,3-0"; verify_case(0, Arg4, reconstructResults(Arg0, Arg1, Arg2, Arg3)); }
           70  + void test_case_1() { int Arg0 = 0; int Arg1 = 3; int Arg2 = 6; int Arg3 = 9; string Arg4 = "2-3,2-3,2-3"; verify_case(1, Arg4, reconstructResults(Arg0, Arg1, Arg2, Arg3)); }
           71  + void test_case_2() { int Arg0 = 3; int Arg1 = 0; int Arg2 = 9; int Arg3 = 3; string Arg4 = "AMBIGUITY"; verify_case(2, Arg4, reconstructResults(Arg0, Arg1, Arg2, Arg3)); }
           72  + void test_case_3() { int Arg0 = 1; int Arg1 = 1; int Arg2 = 4; int Arg3 = 4; string Arg4 = "1-3,3-1"; verify_case(3, Arg4, reconstructResults(Arg0, Arg1, Arg2, Arg3)); }
           73  +
           74  +// END CUT HERE
           75  +};
           76  +// BEGIN CUT HERE
           77  +int main() {
           78  + VolleyballTournament().run_test(-1);
           79  +}
           80  +// END CUT HERE

Added SRM/344/1B.cpp version [be660a3b96dfe736]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class QuantumAlchemy
           19  +{
           20  +public:
           21  + int minSteps(string initial, vector <string> reactions)
           22  + {
           23  +  map<char, string> r;
           24  +  for(int i=0; i<reactions.size(); ++i)
           25  +  {
           26  +   int j = reactions[i].find('-');
           27  +   r[reactions[i][j+2]] = reactions[i].substr(0, j);
           28  +  }
           29  +
           30  +  map<char, int> g;
           31  +  for(int i=0; i<initial.size(); ++i)
           32  +   g[initial[i]]++;
           33  +
           34  +  if( g['X'] )
           35  +   return 0;
           36  +  set<char> stk; stk.insert('X');
           37  +  return make('X', r, g, stk);
           38  + }
           39  +
           40  + int make(char X, map<char,string>& r, map<char, int>& g, set<char>& stk)
           41  + {
           42  +  if( !r.count(X) )
           43  +   return -1;
           44  +  string s = r[X];
           45  +
           46  +  int rea = 1;
           47  +  for(int i=0; i<s.size(); ++i)
           48  +   if( g[s[i]] )
           49  +    g[s[i]]--;
           50  +   else {
           51  +    if( stk.count(s[i]) )
           52  +     return -1;
           53  +    stk.insert(s[i]);
           54  +    int subrea = make(s[i], r, g, stk);
           55  +    stk.erase(s[i]);
           56  +    if( subrea == -1 )
           57  +     return -1;
           58  +    rea += subrea;
           59  +   }
           60  +  return rea;
           61  + }
           62  +
           63  +// BEGIN CUT HERE
           64  + public:
           65  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           66  + private:
           67  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           68  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           69  + void test_case_0() { string Arg0 = "ABCDE"; string Arr1[] = {"ABC->F", "FE->X"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 2; verify_case(0, Arg2, minSteps(Arg0, Arg1)); }
           70  + void test_case_1() { string Arg0 = "AABBB"; string Arr1[] = {"BZ->Y", "ZY->X", "AB->Z"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 4; verify_case(1, Arg2, minSteps(Arg0, Arg1)); }
           71  + void test_case_2() { string Arg0 = "AAABB"; string Arr1[] = {"BZ->Y", "ZY->X", "AB->Z"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = -1; verify_case(2, Arg2, minSteps(Arg0, Arg1)); }
           72  + void test_case_3() { string Arg0 = "AAXB"; string Arr1[] = {"BZ->Y", "ZY->X", "AB->Z"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 0; verify_case(3, Arg2, minSteps(Arg0, Arg1)); }
           73  + void test_case_4() { string Arg0 = "ABCDEFGHIJKLMNOPQRSTUVWYZABCDEFGHIJKLMNOPQRSTUVWYZ"; string Arr1[] = {"ABCE->Z", "RTYUIO->P", "QWER->T", "MN->B"}; vector <string> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = -1; verify_case(4, Arg2, minSteps(Arg0, Arg1)); }
           74  +
           75  +// END CUT HERE
           76  +};
           77  +// BEGIN CUT HERE
           78  +int main() {
           79  + QuantumAlchemy().run_test(-1);
           80  +}
           81  +// END CUT HERE

Added SRM/344/1C.cpp version [8458c6f3c3bb106e]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class FairTournament
           19  +{
           20  +public:
           21  + vector<string> memo;
           22  +
           23  + string add(const string& a, const string& b)
           24  + {
           25  +  int n = max(a.size(), b.size()), carry=0;
           26  +  string c(n, '0');
           27  +  for(int i=0; i<n; ++i) {
           28  +   int x = (a.size()<=i ? 0 : a[a.size()-1-i]-'0')
           29  +         + (b.size()<=i ? 0 : b[b.size()-1-i]-'0') + carry;
           30  +   c[n-1-i] = char('0'+x%10);
           31  +   carry = x/10;
           32  +  }
           33  +  if( carry ) c = char('0'+carry)+c;
           34  +  return c;
           35  + }
           36  +
           37  + string countPermutations(int n, int k)
           38  + {
           39  +  memo.clear();
           40  +  memo.resize(n<<k+1+k, "X");
           41  +
           42  +  int pending = (1<<k+1) - 1; // 0b00111 (case k=2)
           43  +  return rec(pending, 0, n, k);
           44  + }
           45  +
           46  + string rec(int pending, int i, int n, int k)
           47  + {
           48  +  if( i == n )
           49  +   return "1";
           50  +
           51  +  int key = (i<<k+1+k) | pending;
           52  +  if( memo[key]!="X" )
           53  +   return memo[key];
           54  +
           55  +  string sum = "";
           56  +  for(int m=1,j=k; m<=pending; m<<=1,j--)
           57  +   if( (pending & m) && i+j<n )
           58  +   {
           59  +    int p2 = ((pending^m)<<1) | 1;
           60  +    if( p2 >= (1<<k+1+k) ) // 0b100000
           61  +     continue;
           62  +    sum = add(sum, rec(p2, i+1, n, k));
           63  +   }
           64  +  return memo[key]=sum;
           65  + }
           66  +
           67  +// BEGIN CUT HERE
           68  + public:
           69  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           70  + private:
           71  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           72  + void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           73  + void test_case_0() { int Arg0 = 3; int Arg1 = 1; string Arg2 = "3"; verify_case(0, Arg2, countPermutations(Arg0, Arg1)); }
           74  + void test_case_1() { int Arg0 = 3; int Arg1 = 2; string Arg2 = "6"; verify_case(1, Arg2, countPermutations(Arg0, Arg1)); }
           75  + void test_case_2() { int Arg0 = 10; int Arg1 = 3; string Arg2 = "19708"; verify_case(2, Arg2, countPermutations(Arg0, Arg1)); }
           76  + void test_case_3() { int Arg0 = 100; int Arg1 = 1; string Arg2 = "573147844013817084101"; verify_case(3, Arg2, countPermutations(Arg0, Arg1)); }
           77  +
           78  +// END CUT HERE
           79  +};
           80  +// BEGIN CUT HERE
           81  +int main() {
           82  + FairTournament().run_test(-1);
           83  +}
           84  +// END CUT HERE

Added SRM/345/1A.cpp version [c2bedd2e817bc099]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class Pathfinding
           19  +{
           20  +public:
           21  + int getDirections(int x, int y)
           22  + {
           23  +  if( x==0 && y==0 )
           24  +   return 0;
           25  +
           26  +  int xincr = 0;
           27  +  int yincr = 0;
           28  +  if(x<0) yincr=1, x=-x;
           29  +  if(y<0) xincr=1, y=-y;
           30  +  if( x==0 )
           31  +   swap(xincr, yincr), swap(x, y);
           32  +
           33  +  if( y==0 )
           34  +  {
           35  +   if( yincr == 0 )
           36  +    return x;
           37  +   else
           38  +    if( x%2 == 1 )
           39  +     return x+2;
           40  +    else
           41  +     return x+4;
           42  +  }
           43  +
           44  +  if( 0==xincr && y%2==yincr || 0==yincr && x%2==xincr )
           45  +   return x+y;
           46  +
           47  +  if( 0==xincr && x%2==xincr || 0==yincr && y%2==yincr )
           48  +   return x+y;
           49  +
           50  +  if( 0==xincr || 0==yincr )
           51  +   return x+y+2;
           52  +
           53  +  if( x%2==xincr || y%2==yincr )
           54  +   return x+y+2;
           55  +
           56  +  return x+y+4;
           57  + }
           58  +
           59  +// BEGIN CUT HERE
           60  + public:
           61  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           62  + private:
           63  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           64  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           65  + void test_case_0() { int Arg0 = 0; int Arg1 = -4; int Arg2 = 8; verify_case(0, Arg2, getDirections(Arg0, Arg1)); }
           66  + void test_case_1() { int Arg0 = 5; int Arg1 = -4; int Arg2 = 9; verify_case(1, Arg2, getDirections(Arg0, Arg1)); }
           67  + void test_case_2() { int Arg0 = 5; int Arg1 = 4; int Arg2 = 9; verify_case(2, Arg2, getDirections(Arg0, Arg1)); }
           68  + void test_case_3() { int Arg0 = -1; int Arg1 = -4; int Arg2 = 7; verify_case(3, Arg2, getDirections(Arg0, Arg1)); }
           69  + void test_case_4() { int Arg0 = 0; int Arg1 = 0; int Arg2 = 0; verify_case(4, Arg2, getDirections(Arg0, Arg1)); }
           70  +
           71  +// END CUT HERE
           72  +};
           73  +// BEGIN CUT HERE
           74  +int main() { Pathfinding().run_test(-1); }
           75  +// END CUT HERE

Added SRM/345/1B.cpp version [75343b8007c95b13]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class StoneGame
           19  +{
           20  +public:
           21  + int getScore(vector <int> treasure, vector <int> stones)
           22  + {
           23  +  // Note that we always lose 'even' piles...
           24  +
           25  +  vector<int> ones;
           26  +  int numOdds = 0;
           27  +  int sumGt1  = 0;
           28  +
           29  +  int n = treasure.size();
           30  +  for(int i=0; i<n; ++i)
           31  +   if( stones[i] == 1 )
           32  +    ones.push_back( treasure[i] );
           33  +   else
           34  +    numOdds += stones[i]%2,
           35  +    sumGt1  += treasure[i];
           36  +
           37  +  sort(ones.rbegin(), ones.rend());
           38  +
           39  +  int score = 0;
           40  +  for(int i=0; i<ones.size(); i+=2) // take 1-stone piles altenatively
           41  +   score += ones[i];
           42  +  if(  (ones.size()+numOdds)%2 == 1 ) // then make odd-stone piles into even
           43  +   score += sumGt1; // if all piles are made even, one-side takes all
           44  +  return score;
           45  + }
           46  +
           47  +// BEGIN CUT HERE
           48  + public:
           49  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           50  + private:
           51  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           52  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           53  + void test_case_0() { int Arr0[] = {3,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 5; verify_case(0, Arg2, getScore(Arg0, Arg1)); }
           54  + void test_case_1() { int Arr0[] = {5,4,3,2,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,1,1,1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 9; verify_case(1, Arg2, getScore(Arg0, Arg1)); }
           55  + void test_case_2() { int Arr0[] = {5,5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2,2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 0; verify_case(2, Arg2, getScore(Arg0, Arg1)); }
           56  + void test_case_3() { int Arr0[] = {1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arg2 = 0; verify_case(3, Arg2, getScore(Arg0, Arg1)); }
           57  +
           58  +// END CUT HERE
           59  +};
           60  +// BEGIN CUT HERE
           61  +int main() { StoneGame().run_test(-1); }
           62  +// END CUT HERE

Added SRM/345/1C.cpp version [84d7893a9bc28147]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +LL next_combination(LL p)
           19  +{
           20  + LL lsb = p & -p;
           21  + LL rem = p + lsb;
           22  + LL rit = rem & ~p;
           23  + return rem|(((rit/lsb)>>1)-1);
           24  +}
           25  +
           26  +class ByteLand
           27  +{
           28  +public:
           29  + int buildCastles(vector<int> road, vector<int> distance, vector<int> castle, int k)
           30  + {
           31  +  int n = road.size();
           32  +
           33  +  // Construct the Graph
           34  +  int d[50][50] = {};
           35  +  for(int v=0; v<n; ++v)
           36  +   for(int u=v+1; u<n; ++u)
           37  +    d[v][u] = d[u][v] = 0x3fffffff;
           38  +  for(int v=0; v<n; ++v)
           39  +   d[v][road[v]] = d[road[v]][v] = min( d[v][road[v]], distance[v] );
           40  +
           41  +  // Warshall-Floyd
           42  +  for(int m=0; m<n; ++m)
           43  +   for(int i=0; i<n; ++i)
           44  +    for(int j=0; j<n; ++j)
           45  +     d[i][j] = min(d[i][j], d[i][m]+d[m][j]);
           46  +
           47  +  // Binary Search: the answer is in (L,R]
           48  +  int L=-1, R=accumulate(distance.begin(), distance.end(), 0);
           49  +  while( R-L > 1 )
           50  +   (is_possible((L+R)/2, d, n, castle, k) ? R : L) = (L+R)/2;
           51  +  return R;
           52  + }
           53  +
           54  + bool is_possible( int D, int d[50][50], int n, const vector<int>& c, int k )
           55  + {
           56  +  // the set of cities not covered yet
           57  +  LL goal = (1LL << n) - 1;
           58  +  for(int v=0; v<n; ++v)
           59  +   for(int i=0; i<c.size(); ++i)
           60  +    if( d[v][c[i]] <= D )
           61  +     goal &= ~(1LL << v);
           62  +
           63  +  // the set of cities each city can cover
           64  +  set<LL> mask;
           65  +  for(int v=0; v<n; ++v) {
           66  +   LL m = 0;
           67  +   for(int u=0; u<n; ++u)
           68  +    if( d[v][u] <= D )
           69  +     m |= (1LL << u);
           70  +   if( m&goal )
           71  +    mask.insert( m&goal );
           72  +  }
           73  +
           74  +  // is it possible to cover the goal by at most k elements from mask?
           75  +  return canCover(goal, mask, k);
           76  + }
           77  +
           78  + bool canCover( LL goal, set<LL>& mask, int k )
           79  + {
           80  +  // optimizer
           81  +  for(bool update=true; update; ) {
           82  +   update = false;
           83  +
           84  +   // if *it \subseteq *jt for some jt, then we NEVER use it
           85  +   // if *it is the only mask covering some city, we ALWAYS use it
           86  +   for(set<LL>::iterator it=mask.begin(); it!=mask.end(); ) {
           87  +    bool isSubset = false;
           88  +    LL   onlyByMe = *it & goal;
           89  +    for(set<LL>::iterator jt=mask.begin(); jt!=mask.end(); ++jt)
           90  +     if( it!=jt ) {
           91  +      onlyByMe &= ~*jt;
           92  +      isSubset |= (*it & *jt & goal) == (*it & goal);
           93  +     }
           94  +
           95  +    update |= isSubset | !!onlyByMe;
           96  +
           97  +    if( isSubset )
           98  +     mask.erase(it++);
           99  +    else if( onlyByMe ) {
          100  +     if( --k < 0 )
          101  +      return false;
          102  +     goal &= ~*it;
          103  +     mask.erase(it++);
          104  +    }
          105  +    else
          106  +     ++it;
          107  +   }
          108  +
          109  +   if( mask.size()<=k || goal==0 )
          110  +    return true;
          111  +  }
          112  +
          113  +  // exhaustive search
          114  +  vector<LL> ms(mask.begin(), mask.end());
          115  +  for(LL i=(1LL<<k)-1; i<(1LL<<ms.size()); i=next_combination(i))
          116  +  {
          117  +   LL gg = goal;
          118  +   for(LL j=0; (1LL<<j)<=i; ++j)
          119  +    if( i & (1<<j) )
          120  +     gg &= ~ms[j];
          121  +   if( gg == 0 )
          122  +    return true;
          123  +  }
          124  +  return false;
          125  + }
          126  +
          127  +// BEGIN CUT HERE
          128  + public:
          129  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
          130  + private:
          131  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          132  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
          133  + void test_case_0() { int Arr0[] = {1,2,3,4,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,1,1,1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); vector <int> Arg2; int Arg3 = 1; int Arg4 = 2; verify_case(0, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
          134  + void test_case_1() { int Arr0[] = {1,2,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,2,3}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; int Arg4 = 1; verify_case(1, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
          135  + void test_case_2() { int Arr0[] = {0,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; int Arg4 = 0; verify_case(2, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
          136  + void test_case_3() { int Arr0[] = {0,2,0,0,2,2,8,3,8,7}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {10,9,1,8,1,3,7,2,8,1}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {3,4,6}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 3; int Arg4 = 3; verify_case(3, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
          137  + void test_case_4() { int Arr0[] = {1, 0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {5, 10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); vector <int> Arg2; int Arg3 = 1; int Arg4 = 5; verify_case(4, Arg4, buildCastles(Arg0, Arg1, Arg2, Arg3)); }
          138  +
          139  +// END CUT HERE
          140  +};
          141  +// BEGIN CUT HERE
          142  +int main() { ByteLand().run_test(-1); }
          143  +// END CUT HERE

Added SRM/346-U/1A.cpp version [fe758173c829bb2f]

            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  +LL gcd(LL a, LL b)
           23  +{
           24  + while(a)
           25  +  swap(a, b%=a);
           26  + return b;
           27  +}
           28  +
           29  +LL lcm(LL a, LL b)
           30  +{
           31  + return a/gcd(a,b)*b;
           32  +}
           33  +
           34  +class CommonMultiples { public:
           35  + int countCommMult(vector <int> a, int lower, int upper)
           36  + {
           37  +  LL m = 1;
           38  +  for(int i=0; i<a.size(); ++i)
           39  +  {
           40  +   m = lcm(m, a[i]);
           41  +   if( m > upper )
           42  +    return 0;
           43  +  }
           44  +  return upper/m - (lower-1)/m;
           45  + }
           46  +};
           47  +
           48  +// BEGIN CUT HERE
           49  +#include <ctime>
           50  +double start_time; string timer()
           51  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           52  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           53  + { os << "{ ";
           54  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           55  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           56  +void verify_case(const int& Expected, const int& Received) {
           57  + bool ok = (Expected == Received);
           58  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           59  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           60  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           61  +#define END  verify_case(_, CommonMultiples().countCommMult(a, lower, upper));}
           62  +int main(){
           63  +
           64  +CASE(0)
           65  + int a_[] = {1,2,3};
           66  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           67  + int lower = 5;
           68  + int upper = 15;
           69  + int _ = 2;
           70  +END
           71  +CASE(1)
           72  + int a_[] = {1,2,4,8,16,32,64};
           73  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           74  + int lower = 128;
           75  + int upper = 128;
           76  + int _ = 1;
           77  +END
           78  +CASE(2)
           79  + int a_[] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,49};
           80  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           81  + int lower = 1;
           82  + int upper = 2000000000;
           83  + int _ = 0;
           84  +END
           85  +CASE(3)
           86  + int a_[] = {1,1,1};
           87  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           88  + int lower = 1;
           89  + int upper = 2000000000;
           90  + int _ = 2000000000;
           91  +END
           92  +CASE(4)
           93  + int a_[] = {1};
           94  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           95  + int lower = 1;
           96  + int upper = 1;
           97  + int _ = 1;
           98  +END
           99  +CASE(5)
          100  + int a_[] = {2,4};
          101  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
          102  + int lower = 4;
          103  + int upper = 8;
          104  + int _ = 2;
          105  +END
          106  +
          107  +}
          108  +// END CUT HERE

Added SRM/346-U/1B.cpp version [b041c671ce46ca29]

            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 HeightRound { public:
           23  + typedef pair<pair<int,int>,int> key_t;
           24  + map<key_t, int> memo;
           25  +
           26  + int score( int F, int B, int I, const vector<int>& h )
           27  + {
           28  +  if( I == h.size()-1 )
           29  +   return max(h[I]-h[F], h[I]-h[B]);
           30  +
           31  +  key_t key(make_pair(F,B), I);
           32  +  if( memo.count(key) )
           33  +   return memo[key];
           34  +
           35  +  int s1 = max(h[I]-h[F], score(I, B, I+1, h));
           36  +  int s2 = max(h[I]-h[B], score(F, I, I+1, h));
           37  +  return memo[key] = min(s1, s2);
           38  + }
           39  +
           40  + void best( int F, int B, int I, const vector<int>& h, int acc, deque<int>& result )
           41  + {
           42  +  if( I == h.size()-1 ) {
           43  +   result = deque<int>(1, h[I]);
           44  +   result.push_front(h[F]);
           45  +   result.push_back(h[B]);
           46  +   return;
           47  +  }
           48  +
           49  +  int s1 = max(acc, max(h[I]-h[F], score(I, B, I+1, h)));
           50  +  int s2 = max(acc, max(h[I]-h[B], score(F, I, I+1, h)));
           51  +
           52  +  if( s1<=s2 ) { // if tie, choose lexicographically earlier one
           53  +   best( I, B, I+1, h, s1, result );
           54  +   result.push_front( h[F] );
           55  +  }
           56  +  else {
           57  +   best( F, I, I+1, h, s2, result );
           58  +   result.push_back( h[B] );
           59  +  }
           60  + }
           61  +
           62  + vector <int> getBestRound(vector <int> h)
           63  + {
           64  +  // The answer must be of form:
           65  +  //    h[0], h[1], (...ascending...), h[$-1], (...descending...).
           66  +  // Thus, I begin from
           67  +  //    F=1, B=0: [h[1], ..........,  h[0]]
           68  +  // and fill each h[I=2,3,...] either to the left or right of the blank space,
           69  +  // and choose the best one. To choose lex-first candidate, I use the "jo-seki"
           70  +  // technique, which first computes only scores and then choose the instance
           71  +  // lexicographically afterwards.
           72  +
           73  +  sort(h.begin(), h.end());
           74  +
           75  +  deque<int> result;
           76  +  best( 1, 0, 2, h, 0, result );
           77  +
           78  +  rotate(result.begin(), result.end()-1, result.end());
           79  +  return vector<int>(result.begin(), result.end());
           80  + }
           81  +};
           82  +
           83  +// BEGIN CUT HERE
           84  +#include <ctime>
           85  +double start_time; string timer()
           86  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           87  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           88  + { os << "{ ";
           89  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           90  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           91  +void verify_case(const vector <int>& Expected, const vector <int>& Received) {
           92  + bool ok = (Expected == Received);
           93  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           94  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           95  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           96  +#define END  verify_case(_, HeightRound().getBestRound(heights));}
           97  +int main(){
           98  +
           99  +CASE(0)
          100  + int heights_[] = {1,2,3,4};
          101  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          102  + int __[] = {1, 2, 4, 3 };
          103  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          104  +END
          105  +CASE(1)
          106  + int heights_[] = {1000,500,1};
          107  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          108  + int __[] = {1, 500, 1000 };
          109  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          110  +END
          111  +CASE(2)
          112  + int heights_[] = {1,3,4,5,7};
          113  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          114  + int __[] = {1, 3, 5, 7, 4 };
          115  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          116  +END
          117  +CASE(3)
          118  + int heights_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
          119  + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
          120  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          121  + int __[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
          122  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          123  +END
          124  +CASE(4)
          125  + int heights_[] = {1,2,1};
          126  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          127  + int __[] = {1,1,2};
          128  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          129  +END
          130  +CASE(5)
          131  + int heights_[] = {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,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,1000};
          132  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          133  + int __[] = {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,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,1000,49};
          134  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          135  +END
          136  +CASE(6)
          137  + int heights_[] = {7, 43, 3, 6, 32, 2, 42, 23, 1, 30};
          138  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          139  + int __[] = {1, 2, 3, 6, 7, 30, 32, 42, 43, 23};
          140  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          141  +END
          142  +
          143  +}
          144  +// END CUT HERE

Added SRM/346-U/2C.cpp version [c4cdee79cf335842]

            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 FastPostman { public:
           23  + struct vert
           24  + {
           25  +  int Ldone, Rdone;
           26  +  bool nowAtL;
           27  +
           28  +  bool operator<( const vert& rhs ) const {
           29  +   if( Ldone != rhs.Ldone ) return Ldone < rhs.Ldone;
           30  +   if( Rdone != rhs.Rdone ) return Rdone < rhs.Rdone;
           31  +   return nowAtL < rhs.nowAtL;
           32  +  }
           33  +  vert(int l, int r, bool b) : Ldone(l), Rdone(r), nowAtL(b) {}
           34  + };
           35  + typedef vert edge;
           36  + typedef pair<int,edge> cedge;
           37  +
           38  + int minTime(vector <int> address, vector <int> maxTime, int initialPos)
           39  + {
           40  +  const int N = address.size();
           41  +
           42  +  vector< pair<int,int> > L, R;
           43  +  R.push_back( make_pair(initialPos,0) );
           44  +  for(int i=0; i<N; ++i)
           45  +   if( initialPos <= address[i] )
           46  +    R.push_back( make_pair(address[i], maxTime[i]) );
           47  +   else
           48  +    L.push_back( make_pair(address[i], maxTime[i]) );
           49  +  stable_sort( R.begin(), R.end() );
           50  +  stable_sort( L.rbegin(), L.rend() );
           51  +
           52  +  vert S(0, 1, false);
           53  +  priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           54  +  set<vert> V;
           55  +  Q.push( cedge(0,S) );
           56  +  while( !Q.empty() )
           57  +  {
           58  +   int  c = Q.top().first;
           59  +   vert v = Q.top().second;
           60  +   Q.pop();
           61  +   if( V.count(v) )
           62  +    continue;
           63  +   if( v.Ldone == L.size() && v.Rdone == R.size() )
           64  +    return c;
           65  +   V.insert(v);
           66  +
           67  +   if( v.Ldone < L.size() ) {
           68  +    vert u(v.Ldone+1, v.Rdone, true);
           69  +    int cu = c + abs( (v.nowAtL ? L[v.Ldone-1] : R[v.Rdone-1]).first - L[v.Ldone].first );
           70  +    if( !V.count(u) && cu <= L[v.Ldone].second )
           71  +     Q.push( cedge(cu,u) );
           72  +   }
           73  +   if( v.Rdone < R.size() ) {
           74  +    vert u(v.Ldone, v.Rdone+1, false);
           75  +    int cu = c + abs( (v.nowAtL ? L[v.Ldone-1] : R[v.Rdone-1]).first - R[v.Rdone].first );
           76  +    if( !V.count(u) && cu <= R[v.Rdone].second )
           77  +     Q.push( cedge(cu,u) );
           78  +   }
           79  +  }
           80  +  return -1;
           81  + }
           82  +};
           83  +
           84  +// BEGIN CUT HERE
           85  +#include <ctime>
           86  +double start_time; string timer()
           87  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           88  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           89  + { os << "{ ";
           90  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           91  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           92  +void verify_case(const int& Expected, const int& Received) {
           93  + bool ok = (Expected == Received);
           94  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           95  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           96  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           97  +#define END  verify_case(_, FastPostman().minTime(address, maxTime, initialPos));}
           98  +int main(){
           99  +
          100  +CASE(0)
          101  + int address_[] = {1,3,5,7};
          102  +   vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_));
          103  + int maxTime_[] = {9,2,5,100};
          104  +   vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_));
          105  + int initialPos = 4;
          106  + int _ = 13;
          107  +END
          108  +CASE(1)
          109  + int address_[] = {1,5};
          110  +   vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_));
          111  + int maxTime_[] = {6,2};
          112  +   vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_));
          113  + int initialPos = 3;
          114  + int _ = 6;
          115  +END
          116  +CASE(2)
          117  + int address_[] = {1000000};
          118  +   vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_));
          119  + int maxTime_[] = {45634};
          120  +   vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_));
          121  + int initialPos = 876;
          122  + int _ = -1;
          123  +END
          124  +CASE(3)
          125  + int address_[] = {1,7,10,4};
          126  +   vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_));
          127  + int maxTime_[] = {15,6,28,39};
          128  +   vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_));
          129  + int initialPos = 2;
          130  + int _ = 20;
          131  +END
          132  +CASE(4)
          133  + int address_[] = {1000000,1000000,1000000,1000000};
          134  +   vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_));
          135  + int maxTime_[] = {563,23452,32426,1};
          136  +   vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_));
          137  + int initialPos = 1000000;
          138  + int _ = 0;
          139  +END
          140  +CASE(5)
          141  + int address_[] = {1};
          142  +   vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_));
          143  + int maxTime_[] = {2};
          144  +   vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_));
          145  + int initialPos = {3};
          146  + int _ = 2;
          147  +END
          148  +CASE(6)
          149  + int address_[] = {0, 1000000};
          150  +   vector <int> address(address_, address_+sizeof(address_)/sizeof(*address_));
          151  + int maxTime_[] = {500000, 1500000};
          152  +   vector <int> maxTime(maxTime_, maxTime_+sizeof(maxTime_)/sizeof(*maxTime_));
          153  + int initialPos = 500000;
          154  + int _ = 1500000;
          155  +END
          156  +
          157  +}
          158  +// END CUT HERE

Added SRM/347-U/1A.cpp version [dc68ca069cbe1c91]

            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 Aircraft { public:
           23  + double f(const double p[], const double v[], double t)
           24  + {
           25  +  return sqrt( (p[0]+t*v[0])*(p[0]+t*v[0]) + (p[1]+t*v[1])*(p[1]+t*v[1]) + (p[2]+t*v[2])*(p[2]+t*v[2]) );
           26  + }
           27  + string nearMiss(vector <int> p1, vector <int> v1, vector <int> p2, vector <int> v2, int R)
           28  + {
           29  +  const double p[] = {p1[0]-p2[0], p1[1]-p2[1], p1[2]-p2[2]};
           30  +  const double v[] = {v1[0]-v2[0], v1[1]-v2[1], v1[2]-v2[2]};
           31  +
           32  +  double x = 0.0;
           33  +  double w = 1e+10;
           34  +  for(int k=0; k<1000000; ++k)
           35  +  {
           36  +   double y = 2*x/3 + w/3;
           37  +   double z = x/3 + 2*w/3;
           38  +   double fx = f(p,v,x);
           39  +   double fy = f(p,v,y);
           40  +   double fz = f(p,v,z);
           41  +   double fw = f(p,v,w);
           42  +   if( fx < fy )
           43  +    w = y;
           44  +   else if( fz > fw )
           45  +    x = z;
           46  +   else if( fy < fz )
           47  +    w = z;
           48  +   else
           49  +    x = y;
           50  +  }
           51  +
           52  +  return f(p,v,x)-0.000001<=R ? "YES" : "NO";
           53  + }
           54  +};
           55  +
           56  +// BEGIN CUT HERE
           57  +#include <ctime>
           58  +double start_time; string timer()
           59  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           60  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           61  + { os << "{ ";
           62  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           63  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           64  +void verify_case(const string& Expected, const string& Received) {
           65  + bool ok = (Expected == Received);
           66  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           67  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           68  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           69  +#define END  verify_case(_, Aircraft().nearMiss(p1, v1, p2, v2, R));}
           70  +int main(){
           71  +
           72  +CASE(0)
           73  + int p1_[] = {15,50,5};
           74  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
           75  + int v1_[] = {25,1,0};
           76  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
           77  + int p2_[] = {161,102,9};
           78  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
           79  + int v2_[] = {-10,-10,-1};
           80  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
           81  + int R = 10;
           82  + string _ = "YES";
           83  +END
           84  +CASE(1)
           85  + int p1_[] = {0,0,0};
           86  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
           87  + int v1_[] = {2,2,0};
           88  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
           89  + int p2_[] = {9,0,5};
           90  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
           91  + int v2_[] = {-2,2,0};
           92  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
           93  + int R = 5;
           94  + string _ = "YES";
           95  +END
           96  +CASE(2)
           97  + int p1_[] = {0,0,0};
           98  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
           99  + int v1_[] = {-2,2,0};
          100  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
          101  + int p2_[] = {9,0,5};
          102  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
          103  + int v2_[] = {2,2,0};
          104  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
          105  + int R = 5;
          106  + string _ = "NO";
          107  +END
          108  +CASE(3)
          109  + int p1_[] = {-2838,-7940,-2936};
          110  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
          111  + int v1_[] = {1,1,-2};
          112  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
          113  + int p2_[] = {532,3850,9590};
          114  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
          115  + int v2_[] = {1,0,-3};
          116  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
          117  + int R = 3410;
          118  + string _ = "YES";
          119  +END
          120  +CASE(4)
          121  + int p1_[] = {-8509,9560,345};
          122  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
          123  + int v1_[] = {-89,-33,62};
          124  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
          125  + int p2_[] = {-5185,-1417,2846};
          126  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
          127  + int v2_[] = {-58,24,26};
          128  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
          129  + int R = 8344;
          130  + string _ = "YES";
          131  +END
          132  +CASE(5)
          133  + int p1_[] = {-7163,-371,-2459};
          134  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
          135  + int v1_[] = {-59,-41,-14};
          136  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
          137  + int p2_[] = {-2398,-426,-5487};
          138  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
          139  + int v2_[] = {-43,27,67};
          140  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
          141  + int R = 5410;
          142  + string _ = "NO";
          143  +END
          144  +CASE(6)
          145  + int p1_[] = {1774,-4491,7810};
          146  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
          147  + int v1_[] = {-12,19,-24};
          148  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
          149  + int p2_[] = {2322,3793,9897};
          150  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
          151  + int v2_[] = {-12,19,-24};
          152  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
          153  + int R = 10000;
          154  + string _ = "YES";
          155  +END
          156  +CASE(7)
          157  + int p1_[] = {3731,8537,5661};
          158  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
          159  + int v1_[] = {-70,71,32};
          160  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
          161  + int p2_[] = {8701,-1886,-5115};
          162  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
          163  + int v2_[] = {28,-13,7};
          164  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
          165  + int R = 9766;
          166  + string _ = "NO";
          167  +END
          168  +CASE(8)
          169  + int p1_[] = {0,0,0};
          170  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
          171  + int v1_[] = {0,0,0};
          172  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
          173  + int p2_[] = {1,0,0};
          174  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
          175  + int v2_[] = {0,0,0};
          176  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
          177  + int R = 1;
          178  + string _ = "YES";
          179  +END
          180  +CASE(9)
          181  + int p1_[] = {0,0,0};
          182  +   vector <int> p1(p1_, p1_+sizeof(p1_)/sizeof(*p1_));
          183  + int v1_[] = {0,0,0};
          184  +   vector <int> v1(v1_, v1_+sizeof(v1_)/sizeof(*v1_));
          185  + int p2_[] = {2,0,0};
          186  +   vector <int> p2(p2_, p2_+sizeof(p2_)/sizeof(*p2_));
          187  + int v2_[] = {0,0,0};
          188  +   vector <int> v2(v2_, v2_+sizeof(v2_)/sizeof(*v2_));
          189  + int R = 1;
          190  + string _ = "NO";
          191  +END
          192  +
          193  +}
          194  +// END CUT HERE

Added SRM/347-U/1B.cpp version [915c95d134abe3d5]

            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 FlightScheduler { public:
           23  + double f(double n, int distance, int K, int emptyMass, int takeoffFuel)
           24  + {
           25  +  return n * (exp(distance/n / K) * emptyMass - emptyMass + takeoffFuel);
           26  + }
           27  + double minimizeFuel(int distance, int K, int emptyMass, int takeoffFuel)
           28  + {
           29  +  LL x = 1;
           30  +  LL w = (1LL<<60);
           31  +  while( w-x > 10 )
           32  +  {
           33  +   LL y = 2*x/3 + w/3;
           34  +   LL z = x/3 + 2*w/3;
           35  +   double fx = f(x, distance, K, emptyMass, takeoffFuel);
           36  +   double fy = f(y, distance, K, emptyMass, takeoffFuel);
           37  +   double fz = f(z, distance, K, emptyMass, takeoffFuel);
           38  +   double fw = f(w, distance, K, emptyMass, takeoffFuel);
           39  +   if( fx < fy )      w = y;
           40  +   else if( fz > fw ) x = z;
           41  +   else if( fy < fz ) w = z;
           42  +   else               x = y;
           43  +  }
           44  +
           45  +  double fuMin = 1e+300;
           46  +  for(LL n=x; n<=w; ++n)
           47  +   fuMin = min(fuMin, f(n, distance, K, emptyMass, takeoffFuel));
           48  +  return fuMin;
           49  + }
           50  +};
           51  +
           52  +// BEGIN CUT HERE
           53  +#include <ctime>
           54  +double start_time; string timer()
           55  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           56  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           57  + { os << "{ ";
           58  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           59  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           60  +void verify_case(const double& Expected, const double& Received) {
           61  + double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 1e-9);
           62  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           63  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           64  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           65  +#define END  verify_case(_, FlightScheduler().minimizeFuel(distance, K, emptyMass, takeoffFuel));}
           66  +int main(){
           67  +
           68  +CASE(0)
           69  + int distance = 40000;
           70  + int K = 100000;
           71  + int emptyMass = 150000;
           72  + int takeoffFuel = 5000;
           73  + double _ = 76420.82744805096;
           74  +END
           75  +CASE(1)
           76  + int distance = 40000;
           77  + int K = 55000;
           78  + int emptyMass = 150000;
           79  + int takeoffFuel = 5000;
           80  + double _ = 138450.61724934017;
           81  +END
           82  +CASE(2)
           83  + int distance = 1000;
           84  + int K = 500;
           85  + int emptyMass = 1000;
           86  + int takeoffFuel = 50;
           87  + double _ = 2664.9853821314487;
           88  +END
           89  +CASE(3)
           90  + int distance = 10000;
           91  + int K = 100;
           92  + int emptyMass = 200;
           93  + int takeoffFuel = 5;
           94  + double _ = 24635.869665316768;
           95  +END
           96  +CASE(4)
           97  + int distance = 140000;
           98  + int K = 4;
           99  + int emptyMass = 10000;
          100  + int takeoffFuel = 10;
          101  + double _ = 3.6576871282155204E8;
          102  +END
          103  +
          104  +}
          105  +// END CUT HERE

Added SRM/347-U/2C.cpp version [e3b47001da49105a]

            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  +
           24  +class TaxiManager { public:
           25  + int schedule(vector <string> roads, vector <string> customers)
           26  + {
           27  +  const int V = roads.size();
           28  +  vector< vector<int> > d(V, vector<int>(V));
           29  +  for(int i=0; i<V; ++i)
           30  +   for(int j=0; j<V; ++j)
           31  +    if( i != j )
           32  +     d[i][j] = (roads[i][j]=='0' ? INF : roads[i][j]-'0');
           33  +  for(int k=0; k<V; ++k)
           34  +   for(int i=0; i<V; ++i)
           35  +    for(int j=0; j<V; ++j)
           36  +     d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
           37  +
           38  +  const int M = customers.size();
           39  +  vector< pair<int,int> > c;
           40  +  for(int i=0; i<M; ++i)
           41  +  {
           42  +   int f, t;
           43  +   stringstream(customers[i]) >> f >> t;
           44  +   c.push_back( make_pair(f,t) );
           45  +  }
           46  +
           47  +  int best = INF;
           48  +  for(int mask=0; mask<(1<<M); ++mask)
           49  +   best = min(best, max(tsp(d,c,mask), tsp(d,c,((1<<M)-1)&~mask)));
           50  +  return best;
           51  + }
           52  +
           53  + map<pair<int,int>, int> memo;
           54  + int tsp(const vector< vector<int> >& d, const vector< pair<int,int> >& c, int mask, int cur=0)
           55  + {
           56  +  if( mask == 0 )
           57  +   return d[cur][0];
           58  +
           59  +  pair<int,int> key(mask, cur);
           60  +  if( memo.count(key) ) return memo[key];
           61  +
           62  +  int best = INF;
           63  +  for(int next=0; (1<<next)<=mask; ++next)
           64  +   if( (1<<next) & mask )
           65  +    best = min(best,
           66  +     d[cur][c[next].first] + d[c[next].first][c[next].second] + tsp(d,c,mask&~(1<<next),c[next].second));
           67  +  return memo[key] = best;
           68  + }
           69  +};
           70  +
           71  +// BEGIN CUT HERE
           72  +#include <ctime>
           73  +double start_time; string timer()
           74  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           75  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           76  + { os << "{ ";
           77  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           78  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           79  +void verify_case(const int& Expected, const int& Received) {
           80  + bool ok = (Expected == Received);
           81  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           82  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           83  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           84  +#define END  verify_case(_, TaxiManager().schedule(roads, customers));}
           85  +int main(){
           86  +
           87  +CASE(0)
           88  + string roads_[] = {"020200"
           89  +,"202020"
           90  +,"020002"
           91  +,"200020"
           92  +,"020202"
           93  +,"002020"};
           94  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
           95  + string customers_[] = {"5 3","2 4","1 5","3 2"};
           96  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
           97  + int _ = 16;
           98  +END
           99  +CASE(1)
          100  + string roads_[] =
          101  +{"00020251090265906661"
          102  +,"00763002550100090081"
          103  +,"06003699000080062771"
          104  +,"00000710460400035310"
          105  +,"50000039119198350060"
          106  +,"66060004050810046028"
          107  +,"02333108565000200880"
          108  +,"40212560000209205231"
          109  +,"02601150098329905062"
          110  +,"00210383709951005203"
          111  +,"10111087340780827070"
          112  +,"05065800003095040140"
          113  +,"15604020082000100090"
          114  +,"83430030070580600750"
          115  +,"10588355007006001150"
          116  +,"14400080790005400536"
          117  +,"23400990400933060004"
          118  +,"11053016300602000090"
          119  +,"90040920084059282502"
          120  +,"61300007077904050900"};
          121  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          122  + string customers_[] = {"0 19","4 16","15 16","4 18","2 7","9 15","11 6","7 13","19 13","12 19","14 12","16 1"};
          123  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          124  + int _ = 33;
          125  +END
          126  +CASE(2)
          127  + string roads_[] =
          128  +{"095222800320504"
          129  +,"107600288090501"
          130  +,"760973530769345"
          131  +,"963093337510830"
          132  +,"338404069255826"
          133  +,"291700050155264"
          134  +,"002783031709004"
          135  +,"404730701707712"
          136  +,"068870030090995"
          137  +,"320025180036103"
          138  +,"468695042801904"
          139  +,"233626561000105"
          140  +,"070014432197086"
          141  +,"887301000143802"
          142  +,"230852749990330"};
          143  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          144  + string customers_[] = {"3 6","0 4","2 7","9 7","13 9","1 6","7 13","14 2","8 7","10 1","11 13","7 12"};
          145  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          146  + int _ = 28;
          147  +END
          148  +CASE(3)
          149  + string roads_[] = {"00401","50990","00062","08008","03000"};
          150  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          151  + string customers_[] = {"2 4"};
          152  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          153  + int _ = 14;
          154  +END
          155  +/*
          156  +CASE(4)
          157  + string roads_[] = ;
          158  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          159  + string customers_[] = ;
          160  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          161  + int _ = ;
          162  +END
          163  +CASE(5)
          164  + string roads_[] = ;
          165  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          166  + string customers_[] = ;
          167  +   vector <string> customers(customers_, customers_+sizeof(customers_)/sizeof(*customers_));
          168  + int _ = ;
          169  +END
          170  +*/
          171  +}
          172  +// END CUT HERE

Added SRM/348-U/1A.cpp version [7f2279a9bdb2181b]

            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 LostParentheses { public:
           23  + int minResult(string e)
           24  + {
           25  +  int sum = 0;
           26  +  bool prevOpPlus = true;
           27  +  bool minusFound = false;
           28  +  for(int p=0,i=0; i<=e.size(); ++i)
           29  +   if( i==e.size() || e[i] == '-' )
           30  +   {
           31  +    stringstream ss;
           32  +    ss << e.substr(p, i-p);
           33  +    int num;
           34  +    ss >> num;
           35  +
           36  +    sum += (prevOpPlus ? +num : -num);
           37  +    p = i+1;
           38  +    minusFound = true;
           39  +    prevOpPlus = false;
           40  +   }
           41  +   else if( e[i] == '+' )
           42  +   {
           43  +    stringstream ss;
           44  +    ss << e.substr(p, i-p);
           45  +    int num;
           46  +    ss >> num;
           47  +
           48  +    sum += (prevOpPlus ? +num : -num);
           49  +    p = i+1;
           50  +    prevOpPlus = !minusFound;
           51  +   }
           52  +  return sum;
           53  + }
           54  +};
           55  +
           56  +// BEGIN CUT HERE
           57  +#include <ctime>
           58  +double start_time; string timer()
           59  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           60  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           61  + { os << "{ ";
           62  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           63  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           64  +void verify_case(const int& Expected, const int& Received) {
           65  + bool ok = (Expected == Received);
           66  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           67  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           68  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           69  +#define END  verify_case(_, LostParentheses().minResult(e));}
           70  +int main(){
           71  +
           72  +CASE(0)
           73  + string e = "55-50+40";
           74  + int _ = -35;
           75  +END
           76  +CASE(1)
           77  + string e = "10+20+30+40";
           78  + int _ = 100;
           79  +END
           80  +CASE(2)
           81  + string e = "00009-00009";
           82  + int _ = 0;
           83  +END
           84  +CASE(3)
           85  + string e = "1";
           86  + int _ = 1;
           87  +END
           88  +CASE(4)
           89  + string e = "1-2+3";
           90  + int _ = -4;
           91  +END
           92  +
           93  +}
           94  +// END CUT HERE

Added SRM/348-U/1B-U.cpp version [cb0ca96bc6d09c19]

            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  +template<typename To, typename From>
           23  + To lexical_cast( const From& f )
           24  + {
           25  +  stringstream ss;
           26  +  ss << f;
           27  +  To t;
           28  +  ss >> t;
           29  +  return t;
           30  + }
           31  +
           32  +
           33  +class RailwayTickets { public:
           34  + int minRejects(vector <string> travel, int seats)
           35  + {
           36  +  typedef pair<bool,int> event; // [true,A  --- false,B)
           37  +  vector<event> evs;
           38  +
           39  +  for(int i=0; i<travel.size(); ++i)
           40  +  {
           41  +   stringstream ss(travel[i]);
           42  +   for(string s; ss>>s; )
           43  +   {
           44  +    int k = s.find('-');
           45  +    int A = lexical_cast<int>( s.substr(0, k) );
           46  +    int B = lexical_cast<int>( s.substr(k+1) );
           47  +    evs.push_back( event(true,A) );
           48  +    evs.push_back( event(false,B) );
           49  +   }
           50  +  }
           51  +
           52  +  sort( evs.begin(), evs.end() );
           53  +
           54  +  vector< vector<int> > minDeny(evs.size()+1, vector<int>(seats+1));
           55  +  for(int ti=evs.size()-1; ti>=0; --ti)
           56  +   for(int si=0; si<=seats; ++si)
           57  +    if( evs[ti].first )
           58  +    {
           59  +     if( si==0 )
           60  +      minDeny[ti][si] = minDeny[ti+1][si]+1;
           61  +     else
           62  +      minDeny[ti][si] = min( minDeny[ti+1][si]+1, minDeny[ti+1][si-1] );
           63  +    }
           64  +    else
           65  +    {
           66  +     minDeny[ti][si] = minDeny[ti+1][si+1];
           67  +    }
           68  +  return minDeny[0][seats];
           69  + }
           70  +};
           71  +
           72  +// BEGIN CUT HERE
           73  +#include <ctime>
           74  +double start_time; string timer()
           75  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           76  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           77  + { os << "{ ";
           78  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           79  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           80  +void verify_case(const int& Expected, const int& Received) {
           81  + bool ok = (Expected == Received);
           82  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           83  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           84  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           85  +#define END  verify_case(_, RailwayTickets().minRejects(travel, seats));}
           86  +int main(){
           87  +
           88  +CASE(0)
           89  + string travel_[] = {"1-3 3-5",
           90  + "2-4 4-6",
           91  + "1-2 2-3 3-4 4-5"};
           92  +   vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
           93  + int seats = 2;
           94  + int _ = 2;
           95  +END
           96  +CASE(1)
           97  + string travel_[] = {"1-10000","2-10000","1-9999","2-9999","5000-5001"};
           98  +   vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
           99  + int seats = 3;
          100  + int _ = 2;
          101  +END
          102  +CASE(2)
          103  + string travel_[] = {"1-2 2-5 2-8 234-236 56-878 6-34",
          104  + "234-776 3242-8000 999-1000 3-14",
          105  + "121-122 435-3455 123-987 77-999"};
          106  +   vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
          107  + int seats = 1000;
          108  + int _ = 0;
          109  +END
          110  +CASE(3)
          111  + string travel_[] = {"1-2 2-3 3-4 4-5 5-6 6-7 1-3 2-7 1-2 1-4"};
          112  +   vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
          113  + int seats = 1;
          114  + int _ = 4;
          115  +END
          116  +CASE(4)
          117  + string travel_[] = {"1-2","1-2"};
          118  +   vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
          119  + int seats = 1;
          120  + int _ = 1;
          121  +END
          122  +CASE(5)
          123  + string travel_[] = {"1-2"};
          124  +   vector <string> travel(travel_, travel_+sizeof(travel_)/sizeof(*travel_));
          125  + int seats = 1;
          126  + int _ = 0;
          127  +END
          128  +
          129  +}
          130  +// END CUT HERE

Added SRM/348-U/2C.cpp version [2ec49067c50d0e11]

            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 IncreasingSubsequences { public:
           23  + long long count(vector <int> a)
           24  + {
           25  +  a.insert(a.begin(), -1);
           26  +
           27  +  int N = a.size();
           28  +
           29  +  vector< vector<int> > next(N);
           30  +  for(int i=0; i<N; ++i) {
           31  +   int L = a[i]+1;
           32  +   int R = INT_MAX;
           33  +   for(int j=i+1; j<N; ++j)
           34  +    if( L<=a[j] && a[j]<=R ) {
           35  +     next[i].push_back(j);
           36  +     R = a[j];
           37  +    }
           38  +  }
           39  +
           40  +  vector<LL> num(N);
           41  +  for(int i=N-1; i>=0; --i) {
           42  +   if( next[i].size() == 0 )
           43  +    num[i] = 1;
           44  +   else
           45  +    for(int j=0; j<next[i].size(); ++j)
           46  +     num[i] += num[next[i][j]];
           47  +  }
           48  +  return num[0];
           49  + }
           50  +};
           51  +
           52  +// BEGIN CUT HERE
           53  +#include <ctime>
           54  +double start_time; string timer()
           55  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           56  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           57  + { os << "{ ";
           58  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           59  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           60  +void verify_case(const long long& Expected, const long long& Received) {
           61  + bool ok = (Expected == Received);
           62  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           63  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           64  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           65  +#define END  verify_case(_, IncreasingSubsequences().count(a));}
           66  +int main(){
           67  +
           68  +CASE(0)
           69  + int a_[] = {1,3,2,6,4,5};
           70  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           71  + long long _ = 4LL;
           72  +END
           73  +CASE(1)
           74  + int a_[] = {1000000000,100000000,10000000,1000000,100000,10000,1000,100,10,1};
           75  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           76  + long long _ = 10LL;
           77  +END
           78  +CASE(2)
           79  + int a_[] = {1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};
           80  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           81  + long long _ = 1LL;
           82  +END
           83  +CASE(3)
           84  + int a_[] = {564,234,34,4365,424,2234,306,21,934,592,195,2395,2396,29345,13295423,23945,2};
           85  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           86  + long long _ = 41LL;
           87  +END
           88  +CASE(4)
           89  + int a_[] = {1};
           90  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           91  + long long _ = 1LL;
           92  +END
           93  +CASE(5)
           94  + int a_[] = {5,4,3,2,1};
           95  +   vector <int> a(a_, a_+sizeof(a_)/sizeof(*a_));
           96  + long long _ = 5LL;
           97  +END
           98  +
           99  +}
          100  +// END CUT HERE

Added SRM/349-U/1A.cpp version [b7df62dcd4535e42]

            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 RadarFinder { public:
           23  + int possibleLocations(int x1, int y1, int r1, int x2, int y2, int r2)
           24  + {
           25  +  if( x1==x2 && y1==y2 )
           26  +   return r1==r2 ? -1 : 0;
           27  +  LL rr = LL(x1-x2)*(x1-x2) + LL(y1-y2)*(y1-y2);
           28  +  LL p12 = LL(r1+r2)*(r1+r2);
           29  +  LL m12 = LL(r1-r2)*(r1-r2);
           30  +  if( rr > p12 )
           31  +   return 0;
           32  +  else if( rr == p12 )
           33  +   return 1;
           34  +  else
           35  +   if( rr < m12 )
           36  +    return 0;
           37  +   else if( rr == m12 )
           38  +    return 1;
           39  +   else
           40  +    return 2;
           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(_, RadarFinder().possibleLocations(x1, y1, r1, x2, y2, r2));}
           58  +int main(){
           59  +
           60  +CASE(0)
           61  + int x1 = 0;
           62  + int y1 = 0;
           63  + int r1 = 13;
           64  + int x2 = 40;
           65  + int y2 = 0;
           66  + int r2 = 37;
           67  + int _ = 2;
           68  +END
           69  +CASE(1)
           70  + int x1 = 0;
           71  + int y1 = 0;
           72  + int r1 = 3;
           73  + int x2 = 0;
           74  + int y2 = 7;
           75  + int r2 = 4;
           76  + int _ = 1;
           77  +END
           78  +CASE(2)
           79  + int x1 = 0;
           80  + int y1 = 0;
           81  + int r1 = 5;
           82  + int x2 = 10;
           83  + int y2 = 10;
           84  + int r2 = 3;
           85  + int _ = 0;
           86  +END
           87  +CASE(3)
           88  + int x1 = 0;
           89  + int y1 = 0;
           90  + int r1 = 1;
           91  + int x2 = 0;
           92  + int y2 = 0;
           93  + int r2 = 1;
           94  + int _ = -1;
           95  +END
           96  +CASE(4)
           97  + int x1 = 1;
           98  + int y1 = 1;
           99  + int r1 = 1;
          100  + int x2 = 1;
          101  + int y2 = 1;
          102  + int r2 = 2;
          103  + int _ = 0;
          104  +END
          105  +CASE(5)
          106  + int x1 = -100000000;
          107  + int y1 = -100000000;
          108  + int r1 = 141421357;
          109  + int x2 = 100000000;
          110  + int y2 = 100000000;
          111  + int r2 = 141421357;
          112  + int _ = 2;
          113  +END
          114  +CASE(6)
          115  + int x1 = 0;
          116  + int y1 = 0;
          117  + int r1 = 5;
          118  + int x2 = 1;
          119  + int y2 = 0;
          120  + int r2 = 4;
          121  + int _ = 1;
          122  +END
          123  +CASE(7)
          124  + int x1 = -1000000000;
          125  + int y1 = -1000000000;
          126  + int r1 =  1000000000;
          127  + int x2 =  -999999999;
          128  + int y2 =  1000000000;
          129  + int r2 =  1000000000;
          130  + int _ = 0;
          131  +END
          132  +
          133  +}
          134  +// END CUT HERE

Added SRM/349-U/1B.cpp version [177e44b83c8f6a87]

            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 DiceGames { public:
           23  + long long countFormations(vector <int> sides)
           24  + {
           25  +  sort(sides.begin(), sides.end());
           26  +
           27  +  vector<LL> dp(sides.back(), 0);
           28  +  dp[0] = 1;
           29  +  for(int i=0; i<sides.size(); ++i)
           30  +   partial_sum(dp.begin(), dp.begin()+sides[i], dp.begin());
           31  +  return accumulate(dp.begin(), dp.end(), 0LL);
           32  + }
           33  +};
           34  +
           35  +// BEGIN CUT HERE
           36  +#include <ctime>
           37  +double start_time; string timer()
           38  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           39  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           40  + { os << "{ ";
           41  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           42  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           43  +void verify_case(const long long& Expected, const long long& Received) {
           44  + bool ok = (Expected == Received);
           45  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           46  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           47  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           48  +#define END  verify_case(_, DiceGames().countFormations(sides));}
           49  +int main(){
           50  +
           51  +CASE(0)
           52  + int sides_[] = {4};
           53  +   vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_));
           54  + long long _ = 4LL;
           55  +END
           56  +CASE(1)
           57  + int sides_[] = {2, 2};
           58  +   vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_));
           59  + long long _ = 3LL;
           60  +END
           61  +CASE(2)
           62  + int sides_[] = {4, 4};
           63  +   vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_));
           64  + long long _ = 10LL;
           65  +END
           66  +CASE(3)
           67  + int sides_[] = {3, 4};
           68  +   vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_));
           69  + long long _ = 9LL;
           70  +END
           71  +CASE(4)
           72  + int sides_[] = {4, 5, 6};
           73  +   vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_));
           74  + long long _ = 48LL;
           75  +END
           76  +CASE(5)
           77  + int sides_[] = {1};
           78  +   vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_));
           79  + long long _ = 1LL;
           80  +END
           81  +CASE(6)
           82  + int sides_[] = {1,1,1,1,1,1,1,1,1,1};
           83  +   vector <int> sides(sides_, sides_+sizeof(sides_)/sizeof(*sides_));
           84  + long long _ = 1LL;
           85  +END
           86  +
           87  +}
           88  +// END CUT HERE

Added SRM/349-U/1C-U.cpp version [627b63bf02167db1]

            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 LastMarble { public:
           23  + typedef pair<int,int>  rb;
           24  + typedef map<rb,double> state;
           25  +
           26  + double winningChance(int red, int blue, int removed)
           27  + {
           28  +  state s;
           29  +  addNextStates( red, blue, 1.0, removed, s );
           30  +  return winChance(s);
           31  + }
           32  +
           33  + double winChance( state& s )
           34  + {
           35  +  if( s.empty() )
           36  +   return 1.0; // any value is ok because it will be multiplied by 0.0
           37  +
           38  +  int r_plus_b = s.begin()->first.first + s.begin()->first.second;
           39  +
           40  +  double lc = 1.0;
           41  +  for(int take=1; take<=min(3,r_plus_b); ++take)
           42  +  {
           43  +   state ns;
           44  +   for(state::iterator it=s.begin(); it!=s.end(); ++it)
           45  +    addNextStates(it->first.first, it->first.second, it->second, take, ns);
           46  +
           47  +   double nowLoseChance = 0.0;
           48  +   for(state::iterator it=ns.begin(); it!=ns.end(); )
           49  +    if( it->first.first == 0 ) {
           50  +     nowLoseChance += it->second;
           51  +     ns.erase( it++ );
           52  +    } else {
           53  +     ++it;
           54  +    }
           55  +
           56  +   double continueChance = 1.0 - nowLoseChance;
           57  +   for(state::iterator it=ns.begin(); it!=ns.end(); ++it)
           58  +    it->second /= continueChance;
           59  +   double loseChance = nowLoseChance + winChance(ns)*continueChance;
           60  +   lc = min(lc, loseChance);
           61  +  }
           62  +  return 1.0 - lc;
           63  + }
           64  +
           65  + void addNextStates(int r, int b, double p, int take, state& m)
           66  + {
           67  +  if( take == 0 ) {
           68  +   m[rb(r,b)] += p;
           69  +   return;
           70  +  }
           71  +
           72  +  state tmp;
           73  +  tmp[rb(r,b)] = p;
           74  +
           75  +  while( take --> 0 )
           76  +  {
           77  +   state tmp2;
           78  +   state& tgt = (take ? tmp2 : m);
           79  +   for(state::iterator it=tmp.begin(); it!=tmp.end(); ++it)
           80  +   {
           81  +    int r = it->first.first;
           82  +    int b = it->first.second;
           83  +    double p = it->second;
           84  +    if( r>0 ) tgt[rb(r-1,b)] += p * r / (r+b);
           85  +    if( b>0 ) tgt[rb(r,b-1)] += p * b / (r+b);
           86  +   }
           87  +   tmp.swap(tmp2);
           88  +  }
           89  + }
           90  +};
           91  +
           92  +// BEGIN CUT HERE
           93  +#include <ctime>
           94  +double start_time; string timer()
           95  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           96  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           97  + { os << "{ ";
           98  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           99  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          100  +void verify_case(const double& Expected, const double& Received) {
          101  + double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 1e-9);
          102  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          103  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          104  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          105  +#define END  verify_case(_, LastMarble().winningChance(red, blue, removed));}
          106  +int main(){
          107  +
          108  +CASE(0)
          109  + int red = 1;
          110  + int blue = 1;
          111  + int removed = 0;
          112  + double _ = 0.5;
          113  +END
          114  +CASE(1)
          115  + int red = 1;
          116  + int blue = 2;
          117  + int removed = 0;
          118  + double _ = 0.3333333333333333;
          119  +END
          120  +CASE(2)
          121  + int red = 2;
          122  + int blue = 1;
          123  + int removed = 0;
          124  + double _ = 0.6666666666666666;
          125  +END
          126  +CASE(3)
          127  + int red = 2;
          128  + int blue = 2;
          129  + int removed = 1;
          130  + double _ = 0.5;
          131  +END
          132  +/*
          133  +CASE(4)
          134  + int red = ;
          135  + int blue = ;
          136  + int removed = ;
          137  + double _ = ;
          138  +END
          139  +CASE(5)
          140  + int red = ;
          141  + int blue = ;
          142  + int removed = ;
          143  + double _ = ;
          144  +END
          145  +*/
          146  +}
          147  +// END CUT HERE

Added SRM/350-U/1A.cpp version [691135ca23ec3f16]

            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 SumsOfPerfectPowers { public:
           23  + int howMany(int lowerBound, int upperBound)
           24  + {
           25  +  set<LL> sq;
           26  +  sq.insert(0);
           27  +  sq.insert(1);
           28  +  for(LL n=2; n*n<=upperBound; ++n)
           29  +   for(LL nk=n*n; nk<=upperBound; nk*=n)
           30  +    sq.insert(nk);
           31  +  vector<LL> sqv( sq.begin(), sq.end() );
           32  +
           33  +  vector<LL> pp;
           34  +  for(vector<LL>::iterator it=sqv.begin(); it!=sqv.end(); ++it)
           35  +   for(vector<LL>::iterator jt=it; jt!=sqv.end() && *it+*jt<=upperBound; ++jt)
           36  +    pp.push_back( *it + *jt );
           37  +  sort( pp.begin(), pp.end() );
           38  +  pp.erase( unique(pp.begin(),pp.end()), pp.end() );
           39  +
           40  +  vector<LL>::iterator s = lower_bound( pp.begin(), pp.end(), lowerBound );
           41  +  vector<LL>::iterator e = upper_bound( pp.begin(), pp.end(), upperBound );
           42  +  return distance(s, e);
           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 int& Expected, const int& 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(_, SumsOfPerfectPowers().howMany(lowerBound, upperBound));}
           60  +int main(){
           61  +
           62  +CASE(0)
           63  + int lowerBound = 0;
           64  + int upperBound = 1;
           65  + int _ = 2;
           66  +END
           67  +CASE(1)
           68  + int lowerBound = 5;
           69  + int upperBound = 6;
           70  + int _ = 1;
           71  +END
           72  +CASE(2)
           73  + int lowerBound = 25;
           74  + int upperBound = 30;
           75  + int _ = 5;
           76  +END
           77  +CASE(3)
           78  + int lowerBound = 103;
           79  + int upperBound = 103;
           80  + int _ = 0;
           81  +END
           82  +CASE(4)
           83  + int lowerBound = 1;
           84  + int upperBound = 100000;
           85  + int _ = 33604;
           86  +END
           87  +CASE(5)
           88  + int lowerBound = 0;
           89  + int upperBound = 0;
           90  + int _ = 1;
           91  +END
           92  +CASE(6)
           93  + int lowerBound = 0;
           94  + int upperBound = 5000000;
           95  + int _ = 1272868;
           96  +END
           97  +
           98  +}
           99  +// END CUT HERE

Added SRM/350-U/1B.cpp version [cbfcaf5b708d4921]

            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  +LL comb(LL n, LL k)
           23  +{
           24  + k = min(k, n-k);
           25  +
           26  + LL c = 1;
           27  + for(LL i=0; i<k; ++i)
           28  +  c *= n-i, c /= i+1;
           29  + return c;
           30  +}
           31  +
           32  +class StarsInGraphs { public:
           33  + int starnum(LL n, LL C)
           34  + {
           35  +  if( n<=2 )
           36  +   return -1;
           37  +  LL sum = 0;
           38  +  for(LL k=3; k<=n; ++k)
           39  +  {
           40  +   sum += comb(n,k);
           41  +   if( sum > C )
           42  +    return -1;
           43  +  }
           44  +  return (int) sum;
           45  + }
           46  +
           47  + int starryPaths(vector <string> adjacencyMatrix, int C)
           48  + {
           49  +  const int N = adjacencyMatrix.size();
           50  +
           51  +  vector<int> sn;
           52  +  for(int i=0; i<N; ++i)
           53  +   sn.push_back( starnum(count(adjacencyMatrix[i].begin(), adjacencyMatrix[i].end(), '1'), C) );
           54  +
           55  +  vector<int> v;
           56  +  for(int i=0; i<N; ++i)
           57  +   if( sn[i] > 0 )
           58  +    v.push_back(i);
           59  +
           60  +  for(int step=0 ;; ++step)
           61  +  {
           62  +   if( v.empty() )
           63  +    return step;
           64  +   if( step >= 3*N )
           65  +    break; // infinite
           66  +
           67  +   vector<int> v2;
           68  +   for(int u=0; u<N; ++u)
           69  +    for(int i=0; i<v.size(); ++i)
           70  +     if( adjacencyMatrix[v[i]][u]=='1' && sn[v[i]] <= sn[u] )
           71  +      {v2.push_back(u); break;}
           72  +   v.swap(v2);
           73  +  }
           74  +
           75  +  return -1;
           76  + }
           77  +};
           78  +
           79  +// BEGIN CUT HERE
           80  +#include <ctime>
           81  +double start_time; string timer()
           82  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           83  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           84  + { os << "{ ";
           85  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           86  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           87  +void verify_case(const int& Expected, const int& Received) {
           88  + bool ok = (Expected == Received);
           89  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           90  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           91  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           92  +#define END  verify_case(_, StarsInGraphs().starryPaths(adjacencyMatrix, C));}
           93  +int main(){
           94  +
           95  +CASE(0)
           96  + string adjacencyMatrix_[] = {"01110",
           97  + "10111",
           98  + "00000",
           99  + "00000",
          100  + "00000"};
          101  +   vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_));
          102  + int C = 1000;
          103  + int _ = 2;
          104  +END
          105  +CASE(1)
          106  + string adjacencyMatrix_[] = {"01011",
          107  + "00111",
          108  + "10011",
          109  + "00000",
          110  + "00000"};
          111  +   vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_));
          112  + int C = 1;
          113  + int _ = -1;
          114  +END
          115  +CASE(2)
          116  + string adjacencyMatrix_[] = {"0111",
          117  + "0000",
          118  + "0000",
          119  + "0000"};
          120  +   vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_));
          121  + int C = 1;
          122  + int _ = 1;
          123  +END
          124  +CASE(3)
          125  + string adjacencyMatrix_[] = {"01111",
          126  + "00000",
          127  + "00000",
          128  + "00000",
          129  + "00000"};
          130  +   vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_));
          131  + int C = 4;
          132  + int _ = 0;
          133  +END
          134  +CASE(4)
          135  + string adjacencyMatrix_[] = {"010001100",
          136  + "001001100",
          137  + "000101110",
          138  + "000010111",
          139  + "000001111",
          140  + "010000000",
          141  + "000110000",
          142  + "000100001",
          143  + "100001000"};
          144  +   vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_));
          145  + int C = 10;
          146  + int _ = 5;
          147  +END
          148  +CASE(5)
          149  + string adjacencyMatrix_[] = {"00","00"};
          150  +   vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_));
          151  + int C = 9999999;
          152  + int _ = 0;
          153  +END
          154  +CASE(6)
          155  + string adjacencyMatrix_[] = {"0111","1011","1101","1110"};
          156  +   vector <string> adjacencyMatrix(adjacencyMatrix_, adjacencyMatrix_+sizeof(adjacencyMatrix_)/sizeof(*adjacencyMatrix_));
          157  + int C = 9999;
          158  + int _ = -1;
          159  +END
          160  +
          161  +}
          162  +// END CUT HERE

Added SRM/351-U/1A.cpp version [a746083be2e0008b]

            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 CoinsExchange { public:
           23  + int countExchanges(int G1, int S1, int B1, int G2, int S2, int B2)
           24  + {
           25  +  if( G1 < G2 ) {
           26  +   int n = G2-G1;
           27  +   return check2( S1, B1, S2+n*11, B2, n ); // 11*n silver needed
           28  +  }
           29  +  if( B1 < B2 ) {
           30  +   int n = (B2-B1+8)/9;
           31  +   return check2( G1, S1, G2, S2+n, n ); // n silver needed
           32  +  }
           33  +
           34  +  // need silver
           35  +  int n = 0;
           36  +  while( S1<S2 && G1- 1>=G2 ) S1+=9, G1-= 1, n++;
           37  +  while( S1<S2 && B1-11>=B2 ) S1+=1, B1-=11, n++;
           38  +  return S1<S2 ? -1 : n;
           39  + }
           40  +
           41  + int check2(int S1, int B1, int S2, int B2, int acc)
           42  + {
           43  +  if( S1 < S2 ) {
           44  +   int n = S2-S1;
           45  +   return B2<=B1-n*11 ? n+acc : -1;
           46  +  }
           47  +  if( B1 < B2 ) {
           48  +   int n = (B2-B1+8)/9;
           49  +   return S2<=S1-n ? n+acc : -1;
           50  +  }
           51  +  return acc;
           52  + }
           53  +};
           54  +
           55  +// BEGIN CUT HERE
           56  +#include <ctime>
           57  +double start_time; string timer()
           58  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           59  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           60  + { os << "{ ";
           61  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           62  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           63  +void verify_case(const int& Expected, const int& Received) {
           64  + bool ok = (Expected == Received);
           65  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           66  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           67  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           68  +#define END  verify_case(_, CoinsExchange().countExchanges(G1, S1, B1, G2, S2, B2));}
           69  +int main(){
           70  +
           71  +CASE(0)
           72  + int G1 = 1;
           73  + int S1 = 0;
           74  + int B1 = 0;
           75  + int G2 = 0;
           76  + int S2 = 0;
           77  + int B2 = 81;
           78  + int _ = 10;
           79  +END
           80  +CASE(1)
           81  + int G1 = 1;
           82  + int S1 = 100;
           83  + int B1 = 12;
           84  + int G2 = 5;
           85  + int S2 = 53;
           86  + int B2 = 33;
           87  + int _ = 7;
           88  +END
           89  +CASE(2)
           90  + int G1 = 1;
           91  + int S1 = 100;
           92  + int B1 = 12;
           93  + int G2 = 5;
           94  + int S2 = 63;
           95  + int B2 = 33;
           96  + int _ = -1;
           97  +END
           98  +CASE(3)
           99  + int G1 = 5;
          100  + int S1 = 10;
          101  + int B1 = 12;
          102  + int G2 = 3;
          103  + int S2 = 7;
          104  + int B2 = 9;
          105  + int _ = 0;
          106  +END
          107  +
          108  +}
          109  +// END CUT HERE

Added SRM/351-U/1B.cpp version [89c00d40736da67f]

            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  +template<typename T>
           23  +struct DP5
           24  +{
           25  + int N1, N2, N3, N4, N5;
           26  + vector<T> data;
           27  + DP5(int N1, int N2, int N3, int N4, int N5, const T& t = T())
           28  +  : N1(N1), N2(N2), N3(N3), N4(N4), N5(N5), data(N1*N2*N3*N4*N5, t) {}
           29  + T& operator()(int i1, int i2, int i3, int i4, int i5)
           30  +  { return data[ ((((i1*N2)+i2)*N3+i3)*N4+i4)*N5+i5 ]; }
           31  +};
           32  +
           33  +
           34  +class BoxesArrangement { public:
           35  + int maxUntouched(string boxes)
           36  + {
           37  +  int NA = count( boxes.begin(), boxes.end(), 'A' );
           38  +  int NB = count( boxes.begin(), boxes.end(), 'B' );
           39  +  int NC = count( boxes.begin(), boxes.end(), 'C' );
           40  +
           41  +  DP5<int> dp(NA+1, NB+1, NC+1, 3, 3);
           42  +  for(int na=NA; na>=0; --na)
           43  +  for(int nb=NB; nb>=0; --nb)
           44  +  for(int nc=NC; nc>=0; --nc)
           45  +  for(int c=0; c<3; ++c)
           46  +  for(int l=0; l<3; ++l)
           47  +  {
           48  +   int n = na+nb+nc;
           49  +   if( n == boxes.size() )
           50  +    continue;
           51  +   int m = -1;
           52  +   for(int x=0; x<3; ++x) {
           53  +    int nna = na+(x==0);
           54  +    int nnb = nb+(x==1);
           55  +    int nnc = nc+(x==2);
           56  +    int nl  = (x==c ? l+1 : 1);
           57  +    if( nna<=NA && nnb<=NB && nnc<=NC && nl<3 && dp(nna,nnb,nnc,x,nl)>=0 )
           58  +     m = max(m, (boxes[n]=='A'+x) + dp(nna,nnb,nnc,x,nl));
           59  +   }
           60  +   dp(na,nb,nc,c,l) = m;
           61  +  }
           62  +
           63  +  return dp(0,0,0,0,0);
           64  + }
           65  +};
           66  +
           67  +// BEGIN CUT HERE
           68  +#include <ctime>
           69  +double start_time; string timer()
           70  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           71  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           72  + { os << "{ ";
           73  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           74  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           75  +void verify_case(const int& Expected, const int& Received) {
           76  + bool ok = (Expected == Received);
           77  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           78  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           79  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           80  +#define END  verify_case(_, BoxesArrangement().maxUntouched(boxes));}
           81  +int main(){
           82  +
           83  +CASE(0)
           84  + string boxes = "AAABBBCCC";
           85  + int _ = 6;
           86  +END
           87  +CASE(1)
           88  + string boxes = "AAAAAAAACBB";
           89  + int _ = 7;
           90  +END
           91  +CASE(2)
           92  + string boxes = "CCCCCB";
           93  + int _ = -1;
           94  +END
           95  +CASE(3)
           96  + string boxes = "BAACAABAACAAA";
           97  + int _ = 5;
           98  +END
           99  +CASE(4)
          100  + string boxes = "CBBABA";
          101  + int _ = 6;
          102  +END
          103  +}
          104  +// END CUT HERE

Added SRM/352-U/1A.cpp version [0f9aa2d57aa32391]

            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 NumberofFiboCalls { public:
           23  + vector <int> fiboCallsMade(int n)
           24  + {
           25  +  vector<int> z(n+2), o(n+2);
           26  +  z[0] = 1;
           27  +  o[1] = 1;
           28  +  for(int i=2; i<=n; ++i) {
           29  +   z[i] = z[i-2] + z[i-1];
           30  +   o[i] = o[i-2] + o[i-1];
           31  +  }
           32  +  vector<int> ans(2);
           33  +  ans[0] = z[n];
           34  +  ans[1] = o[n];
           35  +  return ans;
           36  + }
           37  +};
           38  +
           39  +// BEGIN CUT HERE
           40  +#include <ctime>
           41  +double start_time; string timer()
           42  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           43  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           44  + { os << "{ ";
           45  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           46  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           47  +void verify_case(const vector <int>& Expected, const vector <int>& Received) {
           48  + bool ok = (Expected == Received);
           49  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           50  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           51  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           52  +#define END  verify_case(_, NumberofFiboCalls().fiboCallsMade(n));}
           53  +int main(){
           54  +
           55  +CASE(0)
           56  + int n = 0;
           57  + int __[] = {1, 0 };
           58  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           59  +END
           60  +CASE(1)
           61  + int n = 3;
           62  + int __[] = {1, 2 };
           63  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           64  +END
           65  +CASE(2)
           66  + int n = 6;
           67  + int __[] = {5, 8 };
           68  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           69  +END
           70  +CASE(3)
           71  + int n = 22;
           72  + int __[] = {10946, 17711 };
           73  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           74  +END
           75  +
           76  +}
           77  +// END CUT HERE

Added SRM/352-U/1B-U.cpp version [426e0d13a9708eff]

            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 FibonacciKnapsack { public:
           23  + long long maximalCost(vector <string> items, string C_)
           24  + {
           25  +  LL C;
           26  +  stringstream(C_) >> C;
           27  +
           28  +  vector< pair<LL,LL> > wp;
           29  +  for(int i=0; i<items.size(); ++i) {
           30  +   LL W, P;
           31  +   stringstream(items[i]) >> W >> P;
           32  +   wp.push_back( make_pair(W,P) );
           33  +  }
           34  +  sort( wp.begin(), wp.end() );
           35  +
           36  +  LL lW = 0, lP = 0;
           37  +  for(int i=0; i<wp.size(); ++i)
           38  +   lW += wp[i].first, lP += wp[i].second;
           39  +
           40  +  best = 0;
           41  +  rec( lW, lP, wp, wp.size()-1, C, 0 );
           42  +  return best;
           43  + }
           44  +
           45  + LL best;
           46  + void rec( LL lW, LL lP, vector< pair<LL,LL> >& wp, int i, LL w, LL cP )
           47  + {
           48  +  if( lW <= w )
           49  +   best = max(best, lP+cP);
           50  +  if( lP+cP <= best )
           51  +   return;
           52  +
           53  +  for(int k=i; k>=0 && wp[k].first==wp[i].first; --k)
           54  +  {
           55  +   lW -= wp[k].first;
           56  +   lP -= wp[k].second;
           57  +   if( w >= 0 )
           58  +    rec(lW, lP, wp, k-1, w, cP);
           59  +   w  -= wp[k].first;
           60  +   cP += wp[k].second;
           61  +  }
           62  + }
           63  +};
           64  +
           65  +// BEGIN CUT HERE
           66  +#include <ctime>
           67  +double start_time; string timer()
           68  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           69  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           70  + { os << "{ ";
           71  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           72  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           73  +void verify_case(const long long& Expected, const long long& Received) {
           74  + bool ok = (Expected == Received);
           75  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           76  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           77  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           78  +#define END  verify_case(_, FibonacciKnapsack().maximalCost(items, C));}
           79  +int main(){
           80  +
           81  +CASE(0)
           82  + string items_[] = {"5 555", "8 195", "13 651"};
           83  +   vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_));
           84  + string C = "15";
           85  + long long _ = 750LL;
           86  +END
           87  +CASE(1)
           88  + string items_[] = {"5 555", "8 195", "13 751"};
           89  +   vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_));
           90  + string C = "15";
           91  + long long _ = 751LL;
           92  +END
           93  +CASE(2)
           94  + string items_[] = {"55 1562", "5 814", "55 1962", "8 996", "2 716", "34 1792"};
           95  +   vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_));
           96  + string C = "94";
           97  + long long _ = 4568LL;
           98  +END
           99  +CASE(3)
          100  + string items_[] = {"13 89"};
          101  +   vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_));
          102  + string C = "1";
          103  + long long _ = 0LL;
          104  +END
          105  +CASE(4)
          106  + string items_[] = {"27777890035288 9419696870097445",
          107  + "53316291173 6312623457097563",
          108  + "165580141 8848283653257131"};
          109  +   vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_));
          110  + string C = "27777900000000";
          111  + long long _ = 15160907110354694LL;
          112  +END
          113  +CASE(5)
          114  + string items_[] = {"89 90", "55 54", "55 54", "34 35", "34 35", "34 35", "34 35", "21 23", "21 23", "21 23", "21 23", "21 23", "21 23", "21 23", "21 23", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "13 14", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10", "8 10"};
          115  +   vector <string> items(items_, items_+sizeof(items_)/sizeof(*items_));
          116  + string C = "200";
          117  + long long _ = 241LL;
          118  +END
          119  +
          120  +
          121  +}
          122  +// END CUT HERE

Added SRM/387-U/2U.cpp version [8d99ffa6917f3084]

            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 NV = 256;
           23  +typedef int           flow;
           24  +typedef int           cost;
           25  +typedef int           vert;
           26  +typedef vert          edge;
           27  +typedef vector<edge>  edges;
           28  +typedef vector<edges> graph;
           29  +typedef flow          flow_graph[NV][NV];
           30  +typedef cost          cost_graph[NV][NV];
           31  +static const flow FLOW_INF = 0x7FFFFFFF;
           32  +static const cost COST_INF = 0x7FFFFFFF;
           33  +
           34  +// edges(bidi), capacity, cost(s.t. C[x][y]=-C[y][x]) per 1 flow, src, dst
           35  +pair<cost,flow> mincostFlow(graph& G, flow_graph F, cost_graph C, vert S, vert D)
           36  +{
           37  + int N = G.size();
           38  + cost total_cost = 0;
           39  + flow total_flow = 0;
           40  +
           41  + vector<cost> h(N, 0); // potential
           42  + for(cost RF=FLOW_INF; RF>0; ) // residual flow
           43  + {
           44  +  // Dijkstra -- find the min-cost path
           45  +  vector<cost> d(N, COST_INF);  d[S] = 0;
           46  +  vector<vert> prev(N, -1);
           47  +
           48  +  typedef pair<cost, pair<vert,vert> > cedge;
           49  +  priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           50  +  Q.push( cedge(0, make_pair(S,S)) );
           51  +  while( !Q.empty() ) {
           52  +   cedge e = Q.top(); Q.pop();
           53  +   if( prev[e.second.second] >= 0 )
           54  +    continue;
           55  +   prev[e.second.second] = e.second.first;
           56  +
           57  +   vert u = e.second.second;
           58  +   for(int i=0; i<G[u].size(); ++i) {
           59  +    vert v = G[u][i];
           60  +    cost r_cost = C[u][v] + h[u] - h[v];
           61  +    if( F[u][v] > 0 && d[v] > d[u]+r_cost )
           62  +     Q.push( cedge(d[v]=d[u]+r_cost, make_pair(u,v)) );
           63  +   }
           64  +  }
           65  +
           66  +  if( prev[D] < 0 )
           67  +   break; // Finished
           68  +
           69  +  // As much as possible
           70  +  flow f = RF;
           71  +  for(vert u=D; u!=S; u=prev[u])
           72  +   f = min(f, F[prev[u]][u]);
           73  +  RF         -= f;
           74  +  total_flow += f;
           75  +
           76  +  for(vert u=D; u!=S; u=prev[u])
           77  +  {
           78  +   total_cost    += f * C[prev[u]][u];
           79  +   F[prev[u]][u] -= f;
           80  +   F[u][prev[u]] += f;
           81  +  }
           82  +
           83  +  // Update the potential
           84  +  for(vert u=0; u<N; ++u)
           85  +   h[u] += d[u];
           86  + }
           87  + return make_pair(total_cost, total_flow);
           88  +}
           89  +
           90  +class MarblesRegroupingHard { public:
           91  + int minMoves(vector <string> boxes)
           92  + {
           93  +  const int NB = boxes.size();
           94  +  vector< vector<int> > bb(NB);
           95  +  for(int i=0; i<boxes.size(); ++i)
           96  +  {
           97  +   stringstream sin(boxes[i]);
           98  +   for(int v; sin>>v; )
           99  +    bb[i].push_back(v);
          100  +  }
          101  +  const int NC = bb[0].size();
          102  +
          103  +  graph G(NB+NC+3);
          104  +  flow_graph F = {};
          105  +  cost_graph C = {};
          106  +  for(int i=0; i<NB; ++i) {
          107  +   G[0].push_back(2+i);
          108  +   G[2+i].push_back(0);
          109  +   F[0][2+i] = 1;
          110  +  }
          111  +  for(int i=0; i<NC; ++i) {
          112  +   G[2+NB+i].push_back(1);
          113  +   G[1].push_back(2+NB+i);
          114  +   F[2+NB+i][1] = 1;
          115  +  }
          116  +  {
          117  +   G[2+NB+NC].push_back(1);
          118  +   G[1].push_back(2+NB+NC);
          119  +   F[2+NB+NC][1] = NB-NC;
          120  +  }
          121  +  for(int i=0; i<NB; ++i)
          122  +  for(int j=0; j<NC; ++j) {
          123  +   G[2+i].push_back(2+NB+j);
          124  +   G[2+NB+j].push_back(2+i);
          125  +   F[2+i][2+NB+j] = 1;
          126  +   int c = 0;
          127  +   for(int k=0; k<NB; ++k) if(k!=i)
          128  +    c += bb[k][j];
          129  +   C[2+i][2+NB+j] = c;
          130  +   C[2+NB+j][2+i] = -c;
          131  +  }
          132  +  for(int i=0; i<NB; ++i) {
          133  +   G[2+i].push_back(2+NB+NC);
          134  +   G[2+NB+NC].push_back(2+i);
          135  +   F[2+i][2+NB+NC] = 1;
          136  +  }
          137  +  pair<cost,flow> ff = mincostFlow(G, F, C, 0, 1);
          138  +  return ff.first;
          139  + }
          140  +};
          141  +
          142  +// BEGIN CUT HERE
          143  +#include <ctime>
          144  +double start_time; string timer()
          145  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          146  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          147  + { os << "{ ";
          148  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          149  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          150  +void verify_case(const int& Expected, const int& Received) {
          151  + bool ok = (Expected == Received);
          152  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          153  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          154  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          155  +#define END  verify_case(_, MarblesRegroupingHard().minMoves(boxes));}
          156  +int main(){
          157  +
          158  +CASE(0)
          159  + string boxes_[] = {"0"};
          160  +   vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_));
          161  + int _ = 0;
          162  +END
          163  +CASE(1)
          164  + string boxes_[] = {"77 97","8 0"};
          165  +   vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_));
          166  + int _ = 77;
          167  +END
          168  +CASE(2)
          169  + string boxes_[] = {"6 97 7","73 45 0","67 45 63"};
          170  +   vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_));
          171  + int _ = 170;
          172  +END
          173  +CASE(3)
          174  + string boxes_[] = {"97 94 0 99","1 72 46 45","0 10 47 75","0 92 76 20","2 25 98 22"};
          175  +   vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_));
          176  + int _ = 559;
          177  +END
          178  +CASE(4)
          179  + string boxes_[] = {"38 0 0 45 77 61 0 0 8 87 65 53 0 2",
          180  + "0 97 79 37 70 0 69 35 95 11 75 96 77 29",
          181  + "39 32 0 24 63 22 91 71 0 63 92 59 12 0",
          182  + "34 0 0 71 88 13 60 56 0 22 29 89 81 53",
          183  + "69 95 65 0 94 98 84 37 0 87 16 0 58 18",
          184  + "82 0 36 88 0 54 82 40 6 0 34 44 80 2",
          185  + "33 58 7 95 83 87 0 0 79 35 0 51 22 84",
          186  + "7 0 30 57 33 4 0 26 44 55 67 31 88 42",
          187  + "62 58 62 93 91 0 1 0 44 23 95 0 55 57",
          188  + "35 8 22 26 76 0 78 54 0 46 42 0 0 64",
          189  + "93 54 58 0 89 89 0 0 57 0 98 3 24 0",
          190  + "9 0 0 23 82 18 0 46 0 0 94 84 19 18",
          191  + "78 12 6 45 0 80 16 69 59 76 35 0 66 0",
          192  + "0 68 77 13 15 0 52 72 0 0 18 65 23 0",
          193  + "0 0 73 53 0 95 91 44 27 96 85 0 99 85",
          194  + "93 29 4 89 27 44 27 17 21 6 0 8 3 91",
          195  + "0 46 73 94 60 59 15 50 18 75 74 88 46 93",
          196  + "0 0 0 94 93 26 21 83 54 62 0 89 59 77",
          197  + "32 98 0 44 34 38 56 20 0 61 29 94 52 57",
          198  + "52 60 0 22 0 5 38 0 50 98 12 75 0 81",
          199  + "23 0 41 18 36 87 49 32 62 43 22 74 0 97",
          200  + "0 0 30 79 16 73 61 0 75 51 64 13 45 0",
          201  + "11 0 14 2 0 1 2 16 84 37 95 45 48 33",
          202  + "10 0 0 35 0 85 28 76 99 74 76 32 52 8",
          203  + "60 0 96 0 95 26 59 13 0 0 44 42 97 48",
          204  + "34 7 77 25 91 85 35 78 32 99 7 29 18 15",
          205  + "61 50 43 22 42 63 64 50 9 94 42 22 21 33",
          206  + "58 0 41 10 16 0 27 67 83 27 14 37 98 47",
          207  + "37 60 60 76 71 2 84 32 27 39 82 84 0 94",
          208  + "15 98 69 82 36 66 0 97 62 39 0 65 62 67",
          209  + "0 41 0 43 0 0 94 0 0 58 0 0 27 33",
          210  + "53 90 71 91 85 0 32 86 40 60 11 0 99 28",
          211  + "79 62 0 0 79 0 14 62 87 76 35 0 70 0",
          212  + "0 40 73 48 0 63 0 0 63 5 30 18 47 51",
          213  + "75 6 58 69 33 57 66 0 12 0 46 0 65 10"};
          214  +   vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_));
          215  + int _ = 18618;
          216  +END
          217  +/*
          218  +CASE(5)
          219  + string boxes_[] = ;
          220  +   vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_));
          221  + int _ = ;
          222  +END
          223  +CASE(6)
          224  + string boxes_[] = ;
          225  +   vector <string> boxes(boxes_, boxes_+sizeof(boxes_)/sizeof(*boxes_));
          226  + int _ = ;
          227  +END
          228  +*/
          229  +}
          230  +// END CUT HERE

Added SRM/394-U/2C.cpp version [d68ad4a9285e9556]

            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 ProperDivisors { public:
           23  + int analyzeInterval(int a, int b, int n)
           24  + {
           25  +  int c = 0;
           26  +  for(int k=2; k+k<=a+b; ++k)
           27  +   c += cd(a+b, k, n) - cd(a-1, k, n);
           28  +  return c;
           29  + }
           30  +
           31  + int cd(int x, int k, int n)
           32  + {
           33  +  LL kn = 1;
           34  +  for(int i=0; i<n; ++i)
           35  +   if( (kn*=k) > x )
           36  +    return x/k - (x>=k ? 1 : 0);
           37  +  return x/k - x/kn - (x>=k ? 1 : 0);
           38  + }
           39  +};
           40  +
           41  +// BEGIN CUT HERE
           42  +#include <ctime>
           43  +double start_time; string timer()
           44  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           45  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           46  + { os << "{ ";
           47  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           48  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           49  +void verify_case(const int& Expected, const int& Received) {
           50  + bool ok = (Expected == Received);
           51  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           52  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           53  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           54  +#define END  verify_case(_, ProperDivisors().analyzeInterval(a, b, n));}
           55  +int main(){
           56  +
           57  +CASE(0)
           58  + int a = 32;
           59  + int b = 1;
           60  + int n = 3;
           61  + int _ = 5;
           62  +END
           63  +CASE(1)
           64  + int a = 1;
           65  + int b = 12;
           66  + int n = 2;
           67  + int _ = 8;
           68  +END
           69  +CASE(2)
           70  + int a = 1000000;
           71  + int b = 10000000;
           72  + int n = 10;
           73  + int _ = 146066338;
           74  +END
           75  +/*
           76  +CASE(3)
           77  + int a = ;
           78  + int b = ;
           79  + int n = ;
           80  + int _ = ;
           81  +END
           82  +CASE(4)
           83  + int a = ;
           84  + int b = ;
           85  + int n = ;
           86  + int _ = ;
           87  +END
           88  +*/
           89  +}
           90  +// END CUT HERE

Added SRM/396-U/2C.cpp version [c544017c1bc2bc01]

            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 RemovingDigits { public:
           23  + string maxNumber(string number, string digits)
           24  + {
           25  +  vector<int> d(9);
           26  +  for(int i=0; i<digits.size(); ++i)
           27  +   d[digits[i]-'1'] ++;
           28  +  vector<int> n(9);
           29  +  for(int i=0; i<number.size(); ++i)
           30  +   n[number[i]-'1'] ++;
           31  +  return maximize(number, 0, n, d);
           32  + }
           33  +
           34  + map<pair< int, vector<int> >, string> memo;
           35  +
           36  + string maximize(const string& number, int s, vector<int>& n, vector<int>& d)
           37  + {
           38  +  if( s == number.size() )
           39  +   return "";
           40  +
           41  +  pair< int, vector<int> > key(s, d);
           42  +  if( memo.count(key) )
           43  +   return memo[key];
           44  +
           45  +  char ch = number[s]-'1';
           46  +  string cand = "";
           47  +
           48  +  n[ch]--;
           49  +  if( n[ch] >= d[ch] )
           50  +  {
           51  +   string c1 = number[s] + maximize(number, s+1, n, d);
           52  +   cand = max(cand, c1);
           53  +  }
           54  +  if( d[ch] > 0 )
           55  +  {
           56  +   d[ch]--;
           57  +   string c2 = maximize(number, s+1, n, d);
           58  +   cand = max(cand, c2);
           59  +   d[ch]++;
           60  +  }
           61  +  n[ch]++;
           62  +  return memo[key] = cand;
           63  + }
           64  +};
           65  +
           66  +// BEGIN CUT HERE
           67  +#include <ctime>
           68  +double start_time; string timer()
           69  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           70  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           71  + { os << "{ ";
           72  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           73  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           74  +void verify_case(const string& Expected, const string& Received) {
           75  + bool ok = (Expected == Received);
           76  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           77  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           78  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           79  +#define END  verify_case(_, RemovingDigits().maxNumber(number, digits));}
           80  +int main(){
           81  +
           82  +CASE(0)
           83  + string number = "12345";
           84  + string digits = "513";
           85  + string _ = "24";
           86  +END
           87  +CASE(1)
           88  + string number = "112352";
           89  + string digits = "1123";
           90  + string _ = "52";
           91  +END
           92  +CASE(2)
           93  + string number = "123456654321";
           94  + string digits = "612534";
           95  + string _ = "654321";
           96  +END
           97  +CASE(3)
           98  + string number = "654321123456";
           99  + string digits = "612534";
          100  + string _ = "654321";
          101  +END
          102  +CASE(4)
          103  + string number = "2654982765982365";
          104  + string digits = "2345978";
          105  + string _ = "698265265";
          106  +END
          107  +/*
          108  +CASE(5)
          109  + string number = ;
          110  + string digits = ;
          111  + string _ = ;
          112  +END
          113  +CASE(6)
          114  + string number = ;
          115  + string digits = ;
          116  + string _ = ;
          117  +END
          118  +*/
          119  +}
          120  +// END CUT HERE

Added SRM/397/1A.cpp version [55345db3fdf9a047]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class SortingGame
           19  +{
           20  +public:
           21  + int fewestMoves(vector<int> board, int k)
           22  + {
           23  +  vector<int> sorted(board);
           24  +  sort(sorted.begin(), sorted.end());
           25  +
           26  +  vector< vector<int> > Q;
           27  +  set< vector<int> >    V;
           28  +  Q.push_back(board), V.insert(board);
           29  +  for(int N=0; !Q.empty(); ++N)
           30  +  {
           31  +   vector< vector<int> > Q2;
           32  +   for(int i=0; i<Q.size(); ++i)
           33  +   {
           34  +    vector<int>& b = Q[i];
           35  +    if( b == sorted )
           36  +     return N;
           37  +    for(int i=0; i+k<=b.size(); ++i)
           38  +    {
           39  +     reverse(b.begin()+i, b.begin()+i+k);
           40  +     if( !V.count(b) )
           41  +      Q2.push_back(b), V.insert(b);
           42  +     reverse(b.begin()+i, b.begin()+i+k);
           43  +    }
           44  +   }
           45  +   Q.swap(Q2);
           46  +  }
           47  +  return -1;
           48  + }
           49  +
           50  +// BEGIN CUT HERE
           51  + public:
           52  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           53  + private:
           54  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           55  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           56  + void test_case_0() { int Arr0[] = {1,2,3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 0; verify_case(0, Arg2, fewestMoves(Arg0, Arg1)); }
           57  + void test_case_1() { int Arr0[] = {3,2,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 1; verify_case(1, Arg2, fewestMoves(Arg0, Arg1)); }
           58  + void test_case_2() { int Arr0[] = {5,4,3,2,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 10; verify_case(2, Arg2, fewestMoves(Arg0, Arg1)); }
           59  + void test_case_3() { int Arr0[] = {3,2,4,1,5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = -1; verify_case(3, Arg2, fewestMoves(Arg0, Arg1)); }
           60  + void test_case_4() { int Arr0[] = {7,2,1,6,8,4,3,5}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 7; verify_case(4, Arg2, fewestMoves(Arg0, Arg1)); }
           61  +
           62  +// END CUT HERE
           63  +};
           64  +// BEGIN CUT HERE
           65  +int main() {
           66  + SortingGame().run_test(-1);
           67  +}
           68  +// END CUT HERE

Added SRM/397/1B.cpp version [148a1a19572b802a]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class SumOfPowers
           19  +{
           20  +public:
           21  + int value(int n, int k)
           22  + {
           23  +  //  2^m - 1^m = (1+1)^m - 1^m = mC1 1^(m-1) + ... + mCi 1^(m-i) + ... + mCm 1^0
           24  +  //  3^m - 2^m = (2+1)^m - 1^m = mC1 2^(m-1) + ... + mCi 2^(m-i) + ... + mCm 2^0
           25  +  //+ ...
           26  +  //--------------------------------------------------------------------------------
           27  +  //  (n+1)^m - 1  = mC1 \Sigma n^(m-1) + ... + mCi \Sigma n^(m-i) + ... + mCm \Sigma n^0
           28  +
           29  +  vector<LL> vals;
           30  +  for(int m=1; m<=k+1; ++m)
           31  +  {
           32  +   LL x = SUB(POW(n+1, m), 1);
           33  +   for(int i=2; i<=m; ++i)
           34  +    x = SUB( x, MUL(C(m, i), vals[m-i]) );
           35  +   x = DIV(x, m);
           36  +   vals.push_back(x);
           37  +  }
           38  +  return (int)vals.back();
           39  + }
           40  + LL ADD(LL x, LL y) { return (x+y)%1000000007; }
           41  + LL SUB(LL x, LL y) { return (x-y+1000000007)%1000000007; }
           42  + LL MUL(LL x, LL y) { return (x*y)%1000000007; }
           43  + LL C(LL n, LL k) {
           44  +  LL v = 1;
           45  +  for(LL i=1; i<=k; ++i)
           46  +   v = DIV(MUL(v, n-i+1), i);
           47  +  return v;
           48  + }
           49  + LL POW(LL x, LL e) {
           50  +  LL v = 1;
           51  +  for(;e;x=MUL(x,x),e>>=1)
           52  +   if(e&1)
           53  +    v = MUL(v, x);
           54  +  return v;
           55  + }
           56  + LL DIV(LL x, LL y) {
           57  +  LL iy, _;
           58  +  xgcd(y, 1000000007, &iy, &_);
           59  +  return MUL(x, (iy+1000000007)%1000000007);
           60  + }
           61  + LL xgcd(LL a, LL b, LL* x, LL* y) { // ax+by=g
           62  +  if(b) {
           63  +   LL yy, g = xgcd(b,a%b,&yy,x);
           64  +   *y = yy - a/b**x;
           65  +   return g;
           66  +  }
           67  +  else {
           68  +   *x=1, *y=0;
           69  +   return a;
           70  +  }
           71  + }
           72  +
           73  +// BEGIN CUT HERE
           74  + public:
           75  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           76  + private:
           77  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           78  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           79  + void test_case_0() { int Arg0 = 5; int Arg1 = 1; int Arg2 = 15; verify_case(0, Arg2, value(Arg0, Arg1)); }
           80  + void test_case_1() { int Arg0 = 4; int Arg1 = 2; int Arg2 = 30; verify_case(1, Arg2, value(Arg0, Arg1)); }
           81  + void test_case_2() { int Arg0 = 13; int Arg1 = 5; int Arg2 = 1002001; verify_case(2, Arg2, value(Arg0, Arg1)); }
           82  + void test_case_3() { int Arg0 = 123456789; int Arg1 = 1; int Arg2 = 383478132; verify_case(3, Arg2, value(Arg0, Arg1)); }
           83  +
           84  +// END CUT HERE
           85  +};
           86  +// BEGIN CUT HERE
           87  +int main() {
           88  + SumOfPowers().run_test(-1);
           89  +}
           90  +// END CUT HERE

Added SRM/397/1C.cpp version [9cb81db248e7a64c]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +typedef int           vert;
           19  +typedef vert          edge;
           20  +typedef vector<edge>  edges;
           21  +typedef vector<edges> graph;
           22  +
           23  +bool augment( graph& G, int v, vector<vert>& matchTo, bool visited[] )
           24  +{
           25  + for(int i=0; i<G[v].size(); ++i) {
           26  +  vert u = G[v][i];
           27  +  if( visited[u] ) continue;
           28  +  visited[u] = true;
           29  +
           30  +  if( matchTo[u]<0 || augment(G, matchTo[u], matchTo, visited) )
           31  +   { matchTo[v]=u, matchTo[u]=v; return true; }
           32  + }
           33  + return false;
           34  +}
           35  +
           36  +static const int NV=100;
           37  +int biMatch( graph& G, int L ) // [0,L):left, [L,?):right
           38  +{
           39  + vector<vert> matchTo(G.size(), -1);
           40  + int ans = 0;
           41  + for(vert v=0; v<L; ++v) {
           42  +  bool visited[NV] = {};
           43  +  if( augment(G, v, matchTo, visited) )
           44  +   ++ans;
           45  + }
           46  + return ans;
           47  +}
           48  +
           49  +class HouseProtection
           50  +{
           51  +public:
           52  + double safetyFactor(vector <int> bx, vector <int> by, vector <int> rx, vector <int> ry, int R)
           53  + {
           54  +  double r[50][50];
           55  +  set<double> rs;
           56  +  for(int i=0; i<bx.size(); ++i)
           57  +  for(int j=0; j<rx.size(); ++j) {
           58  +   r[i][j] = sqrt((double)(bx[i]-rx[j])*(bx[i]-rx[j]) + (by[i]-ry[j])*(by[i]-ry[j]))/2;
           59  +   rs.insert( min<double>(r[i][j], R) );
           60  +  }
           61  +  rs.insert(R);
           62  +
           63  +  double result = 0;
           64  +  for(set<double>::iterator it=rs.begin(); it!=rs.end(); ++it)
           65  +  {
           66  +   double curR = *it;
           67  +   graph G(bx.size()+rx.size());
           68  +   for(int i=0; i<bx.size(); ++i)
           69  +   for(int j=0; j<rx.size(); ++j)
           70  +    if( r[i][j] < curR ) {
           71  +     G[i].push_back( bx.size()+j );
           72  +    }
           73  +   int Num = bx.size() + rx.size() - biMatch( G, bx.size() );
           74  +   result = max(result, Num*curR*curR);
           75  +  }
           76  +  return result * M_PI;
           77  + }
           78  +
           79  +// BEGIN CUT HERE
           80  + public:
           81  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           82  + private:
           83  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           84  + void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           85  + void test_case_0() { int Arr0[] = { 0, 4 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = { 0, 0 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = { 2, 1 }; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = { 2, -1 }; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); int Arg4 = 1; double Arg5 = 9.42477796076938; verify_case(0, Arg5, safetyFactor(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           86  + void test_case_1() { int Arr0[] = { 1 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = { 1 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = { 1 }; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = { 1 }; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); int Arg4 = 5; double Arg5 = 78.53981633974483; verify_case(1, Arg5, safetyFactor(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           87  + void test_case_2() { int Arr0[] = { 0 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = { 0 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = { 100 }; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = { 0 }; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); int Arg4 = 51; double Arg5 = 15707.963267948966; verify_case(2, Arg5, safetyFactor(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           88  + void test_case_3() { int Arr0[] = { 23, 29, 29, 35 }; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = { 77, 79, 75, 77 }; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = { 26, 26, 32 }; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = { 78, 76, 76 }; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); int Arg4 = 3; double Arg5 = 113.09733552923255; verify_case(3, Arg5, safetyFactor(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           89  +
           90  +// END CUT HERE
           91  +};
           92  +// BEGIN CUT HERE
           93  +int main() {
           94  + HouseProtection().run_test(-1);
           95  +}
           96  +// END CUT HERE

Added SRM/398/1A.cpp version [0a8206adef988889]

            1  +struct CountExpressions
            2  +{
            3  + static int add(int x, int y) { return x+y; }
            4  + static int sub(int x, int y) { return x-y; }
            5  + static int mul(int x, int y) { return x*y; }
            6  +
            7  + int calcExpressions(int x, int y, int val)
            8  + {
            9  +  int num[][4] = {
           10  +   {x,x,y,y},
           11  +   {x,y,x,y},
           12  +   {x,y,y,x},
           13  +   {y,x,x,y},
           14  +   {y,x,y,x},
           15  +   {y,y,x,x},
           16  +  };
           17  +  int (*op[])(int,int) = { &add, &sub, &mul };
           18  +
           19  +  int cnt = 0;
           20  +  for(int a=0; a<6; ++a)
           21  +  for(int i=0; i<3; ++i)
           22  +  for(int j=0; j<3; ++j)
           23  +  for(int k=0; k<3; ++k)
           24  +   if( val == op[k]( op[j]( op[i](num[a][0], num[a][1]), num[a][2] ), num[a][3] ) )
           25  +    ++cnt;
           26  +  return cnt;
           27  + }
           28  +};

Added SRM/398/1B.cpp version [5b09cb848fba3930]

            1  +#include <vector>
            2  +#include <map>
            3  +#include <cstring>
            4  +using namespace std;
            5  +
            6  +
            7  +long long dp[51][51][51][51]; // y,x,n,i
            8  +
            9  +struct CountPaths
           10  +{
           11  + vector <int> difPaths(int r, int c, vector <int> fieldrow, vector <int> fieldcol)
           12  + {
           13  +  int k = fieldrow.size();
           14  +  map< pair<int,int>, int > f;
           15  +  for(int i=0; i<fieldrow.size(); ++i)
           16  +   f[make_pair(fieldrow[i],fieldcol[i])] = i;
           17  +
           18  +  memset(dp, 0, sizeof(dp));
           19  +  if( f.count( make_pair(1,1) ) )
           20  +   dp[1][1][1][ f[make_pair(1,1)]+1 ] = 1;
           21  +  else
           22  +   dp[1][1][0][0] = 1;
           23  +
           24  +  for(int y=1; y<=r; ++y)
           25  +  for(int x=(y==1?2:1); x<=c; ++x)
           26  +  {
           27  +   if( f.count(make_pair(y,x)) ) {
           28  +    int I = f[make_pair(y,x)];
           29  +    for(int n=1; n<=k; ++n) {
           30  +     int sum = 0;
           31  +     for(int i=0; i<=I; ++i) {
           32  +      if( y>=2 )
           33  +       sum += dp[y-1][x][n-1][i];
           34  +      if( x>=2 )
           35  +       sum += dp[y][x-1][n-1][i];
           36  +     }
           37  +     dp[y][x][n][I+1] = sum % 1000007;
           38  +    }
           39  +   } else {
           40  +    for(int n=0; n<=k; ++n) {
           41  +     for(int i=0; i<=k; ++i) {
           42  +      int sum = 0;
           43  +      if( y>=2 )
           44  +       sum += dp[y-1][x][n][i];
           45  +      if( x>=2 )
           46  +       sum += dp[y][x-1][n][i];
           47  +      dp[y][x][n][i] = sum % 1000007;
           48  +     }
           49  +    }
           50  +   }
           51  +  }
           52  +
           53  +  vector<int> ans;
           54  +  for(int n=0; n<=k; ++n) {
           55  +   int sum = 0;
           56  +   for(int i=0; i<=k; ++i)
           57  +    sum += dp[r][c][n][i];
           58  +   ans.push_back( sum % 1000007 );
           59  +  }
           60  +  return ans;
           61  + }
           62  +};

Added SRM/398/1C.cpp version [19f42a31025a41f7]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <cmath>
            4  +#include <algorithm>
            5  +using namespace std;
            6  +
            7  +vector<double> solve_linear_eq( int n, vector< vector<double> > M, const vector<double>& V )
            8  +{
            9  + vector<double> A(V);
           10  + for(int i=0; i<n; ++i)
           11  + {
           12  +  // pivot
           13  +  if( M[i][i] == 0 )
           14  +   for(int j=i+1; j<n; ++j)
           15  +    if( M[j][i] != 0 )
           16  +     {swap(M[i], M[j]); swap(A[i], A[j]); break;}
           17  +  if( M[i][i] == 0 )
           18  +   throw "no anser";
           19  +
           20  +  // M[i][i] <-- 1
           21  +  double p = M[i][i];
           22  +  for(int j=i; j<n; ++j)
           23  +   M[i][j] /= p;
           24  +  A[i] /= p;
           25  +
           26  +  // M[*][i] <-- 0
           27  +  for(int j=0; j<n; ++j) if(j!=i)
           28  +  {
           29  +   double r = M[j][i];
           30  +   for(int k=i; k<n; ++k)
           31  +    M[j][k] -= M[i][k] * r;
           32  +   A[j] -= A[i] * r;
           33  +  }
           34  + }
           35  + return A;
           36  +}
           37  +
           38  +//-------------------------------------------------------------
           39  +// Check the given list can be a degree list of some graph
           40  +//   O(n^2 log n)
           41  +//
           42  +// Verified by
           43  +//   - SRM 398 Div1 LV3
           44  +//
           45  +//((
           46  +// Havel-Hakimi
           47  +//   If G[0], ..., G[n] (decreasing) is graphical,
           48  +//   then G[1]-1, G[2]-1, ..., G[G[0]]-1, G[G[0]+1], .., G[n]
           49  +//   is also graphical.
           50  +//))
           51  +//-------------------------------------------------------------
           52  +
           53  +bool isGraphical( vector<int> G )
           54  +{
           55  + sort( G.begin(), G.end() );
           56  +
           57  + vector<int>::iterator b = lower_bound( G.begin(), G.end(), 1 );
           58  + vector<int>::iterator e = G.end();
           59  +
           60  + while( b < e )
           61  + {
           62  +  int n = *(--e);
           63  +  if( e-b < n )
           64  +   return false;
           65  +  for(vector<int>::iterator i=e-n; i!=e; ++i)
           66  +   --*i;
           67  +  inplace_merge( b, e-n, e );
           68  +  b = lower_bound( G.begin(), G.end(), 1 );
           69  + }
           70  + return true;
           71  +}
           72  +
           73  +struct MyFriends
           74  +{
           75  + string calcFriends(vector <int> sumFriends, int k)
           76  + {
           77  +  int n = sumFriends.size();
           78  +
           79  +  vector< vector<double> > M(n, vector<double>(n));
           80  +  for(int i=0; i<n; ++i)
           81  +   for(int j=0; j<n; ++j)
           82  +    M[i][j] = (i==j || (i+k)%n==j ? 0 : 1);
           83  +
           84  +  // calc #friends of each kid
           85  +  vector<double> V( sumFriends.begin(), sumFriends.end() );
           86  +  vector<double> Ad = solve_linear_eq( n, M, V );
           87  +  vector<int> A;
           88  +  for(int i=0; i<n; ++i)
           89  +   A.push_back( (int)floor(Ad[i]+0.5) );
           90  +
           91  +  // verify
           92  +  for(int i=0; i<n; ++i)
           93  +  {
           94  +   int sum = 0;
           95  +   for(int j=0; j<n; ++j)
           96  +    sum += (i==j || (i+k)%n==j ? 0 : A[j]);
           97  +   if( sum != sumFriends[i] )
           98  +    return "IMPOSSIBLE";
           99  +  }
          100  +
          101  +  return isGraphical(A) ? "POSSIBLE" : "IMPOSSIBLE";
          102  + }
          103  +};

Added SRM/399/1A.cpp version [daf9553b63d995fb]

            1  +#include <iostream>
            2  +#include <vector>
            3  +#include <cmath>
            4  +#include <set>
            5  +#include <algorithm>
            6  +using namespace std;
            7  +
            8  +
            9  +struct AvoidingProduct
           10  +{
           11  + vector<int> getTriple(vector<int> a, int n)
           12  + {
           13  +  int best = 1000000000;
           14  +  vector<int> ans(3);
           15  +
           16  +  set<int> as(a.begin(), a.end());
           17  +  for(int x=1;; ++x) if( !as.count(x) ) {
           18  +   for(int y=x;; ++y) if( !as.count(y) ) {
           19  +    for(int z=y;; ++z) if( !as.count(z) ) {
           20  +     int m = x*y*z;
           21  +     if( abs(m-n) < best ) {
           22  +      best = abs(m-n);
           23  +      ans[0] = x;
           24  +      ans[1] = y;
           25  +      ans[2] = z;
           26  +     }
           27  +
           28  +     if( x*y*z>n ) break;
           29  +    }
           30  +    if( x*y*y>n ) break;
           31  +   }
           32  +   if( x*x*x>n ) break;
           33  +  }
           34  +
           35  +  return ans;
           36  + }
           37  +};

Added SRM/399/1B.cpp version [bfb46b6941f2d6d4]

            1  +#include <iostream>
            2  +#include <string>
            3  +#include <map>
            4  +using namespace std;
            5  +
            6  +string err = "222222222222222222222222222222222222222222222222";
            7  +
            8  +void operator&=( string& x, const string& r )
            9  +{
           10  + if( x.size() > r.size() )
           11  +  x = r;
           12  + else if( x.size()==r.size() && x > r )
           13  +  x = r;
           14  +}
           15  +
           16  +struct BinarySum
           17  +{
           18  + map<int, string> memo;
           19  +
           20  + int rearrange(int a, int b, int c)
           21  + {
           22  +  int an=0,bn=0,cn=0,n=0;
           23  +  for(unsigned int i=1,t=1; i<=a; i<<=1,++t) {if(a&i) an++; n=max<int>(n,t);}
           24  +  for(unsigned int i=1,t=1; i<=b; i<<=1,++t) {if(b&i) bn++; n=max<int>(n,t);}
           25  +  for(unsigned int i=1,t=1; i<=c; i<<=1,++t) {if(c&i) cn++; n=max<int>(n,t);}
           26  +  string ans = err;
           27  +  ans &= mini( 0, cn-1, an-1, bn   ); // 1+0(+0)=01
           28  +  ans &= mini( 0, cn-1, an,   bn-1 ); // 0+1(+0)=01
           29  +  ans &= mini( 1, cn-1, an,   bn );   // 0+0(+1)=01
           30  +  if( ans.find('2') != string::npos )
           31  +   return -1;
           32  +  ans = "1"+ans;
           33  +  if( ans.size() > n )
           34  +   return -1;
           35  +  int v = 0;
           36  +  for(int i=0; i<ans.size(); ++i)
           37  +   v = (v<<1) | (ans[i] - '0');
           38  +  return v;
           39  + }
           40  +
           41  + string mini(int d, int cn, int an, int bn)
           42  + {
           43  +  if( cn<0 || an<0 || bn<0 )
           44  +   return err;
           45  +
           46  +  int key = (cn<<24)+(an<<16)+(bn<<8)+d;
           47  +  if( memo.count(key) )
           48  +   return memo[key];
           49  +
           50  +  if( d==0 && cn==0 && an==0 && bn==0 )
           51  +   return "";
           52  +
           53  +  string ans = err;
           54  +  if( d == 0 ) {
           55  +   ans &= "1"+mini( 0, cn-1, an-1, bn ); // 1+0(+0)=01
           56  +   ans &= "1"+mini( 0, cn-1, an, bn-1 ); // 0+1(+0)=01
           57  +   ans &= "1"+mini( 1, cn-1, an, bn );   // 0+0(+1)=01
           58  +  } else {
           59  +   ans &= "0"+mini( 0, cn, an-1, bn-1 ); // 1+1(+0)=10
           60  +   ans &= "0"+mini( 1, cn, an-1, bn );   // 1+0(+1)=10
           61  +   ans &= "0"+mini( 1, cn, an, bn-1 );    // 0+1(+1)=10
           62  +   ans &= "1"+mini( 1, cn-1, an-1, bn-1 ); // 1+1(+1)=11
           63  +  }
           64  +  return memo[key] = ans;
           65  + }
           66  +};

Added SRM/399/1C.cpp version [b357fd2040b9449a]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <iostream>
            4  +#include <cstring>
            5  +using namespace std;
            6  +
            7  +
            8  +
            9  +
           10  +static const int NV = 512;
           11  +typedef int           flow;
           12  +typedef int           vert;
           13  +typedef vert          edge;
           14  +typedef vector<edge>  edges;
           15  +typedef vector<edges> graph;
           16  +typedef flow          flow_graph[NV][NV];
           17  +
           18  +flow dinic_dfs( graph& G, flow_graph F, vert v, vert D,
           19  +                int LV[], flow flow_in, int blocked[] )
           20  +{
           21  + flow flow_out = 0;
           22  + for(int i=0; i!=G[v].size(); ++i)
           23  + {
           24  +  int u = G[v][i];
           25  +  if( LV[v]+1==LV[u] && F[v][u] )
           26  +  {
           27  +   flow f = min(flow_in-flow_out, F[v][u]);
           28  +   if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) )
           29  +   {
           30  +    F[v][u]  -= f;
           31  +    F[u][v]  += f;
           32  +    flow_out += f;
           33  +    if( flow_in == flow_out ) return flow_out;
           34  +   }
           35  +  }
           36  + }
           37  + blocked[v] = (flow_out==0);
           38  + return flow_out;
           39  +}
           40  +
           41  +flow dinic( graph& G, flow_graph F, vert S, vert D )
           42  +{
           43  + for( flow total=0 ;; ) {
           44  +  int LV[NV] = {0};
           45  +  vector<int> Q(1, S);
           46  +  for(int lv=1; !Q.empty(); ++lv)
           47  +  {
           48  +   vector<int> Q2;
           49  +   for(int i=0; i!=Q.size(); ++i)
           50  +   {
           51  +    edges& ne = G[Q[i]];
           52  +    for(int j=0; j!=ne.size(); ++j)
           53  +     if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
           54  +      LV[ne[j]]=lv, Q2.push_back(ne[j]);
           55  +   }
           56  +   Q.swap(Q2);
           57  +  }
           58  +
           59  +  if( !LV[D] )
           60  +   return total;
           61  +
           62  +  int blocked[NV] = {};
           63  +  total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
           64  + }
           65  +}
           66  +
           67  +
           68  +
           69  +struct DancingParty
           70  +{
           71  + int maxDances(vector<string> likes, int k)
           72  + {
           73  +  int n = likes.size();
           74  +  #define SRC 0
           75  +  #define DST 1
           76  +  #define L(i)  2+n*0+i
           77  +  #define R(i)  2+n*1+i
           78  +  #define YL(i) 2+n*2+i
           79  +  #define NL(i) 2+n*3+i
           80  +  #define YR(i) 2+n*4+i
           81  +  #define NR(i) 2+n*5+i
           82  +
           83  +  graph G(2+n*6);
           84  +
           85  +  // Graph
           86  +  for(int i=0; i<n; ++i) {
           87  +   G[SRC ].push_back(L(i));  G[L(i) ].push_back(SRC);
           88  +   G[L(i)].push_back(YL(i)); G[YL(i)].push_back(L(i));
           89  +   G[L(i)].push_back(NL(i)); G[NL(i)].push_back(L(i));
           90  +
           91  +   G[DST ].push_back(R(i));  G[R(i) ].push_back(DST);
           92  +   G[R(i)].push_back(YR(i)); G[YR(i)].push_back(R(i));
           93  +   G[R(i)].push_back(NR(i)); G[NR(i)].push_back(R(i));
           94  +
           95  +   for(int j=0; j<n; ++j)
           96  +    if( likes[i][j] == 'Y' )
           97  +     G[YL(i)].push_back(YR(j)), G[YR(j)].push_back(YL(i));
           98  +    else
           99  +     G[NL(i)].push_back(NR(j)), G[NR(j)].push_back(NL(i));
          100  +  }
          101  +
          102  +  for(int M=1; M<=n; ++M) {
          103  +   // Flow
          104  +   flow_graph F = {};
          105  +   for(int i=0; i<n; ++i) {
          106  +    F[SRC][L(i)] = M;
          107  +    F[L(i)][YL(i)] = M;
          108  +    F[L(i)][NL(i)] = k;
          109  +
          110  +    F[R(i)][DST] = M;
          111  +    F[YR(i)][R(i)] = M;
          112  +    F[NR(i)][R(i)] = k;
          113  +
          114  +    for(int j=0; j<n; ++j)
          115  +     if( likes[i][j] == 'Y' )
          116  +      F[YL(i)][YR(j)] = 1;
          117  +     else
          118  +      F[NL(i)][NR(j)] = 1;
          119  +   }
          120  +
          121  +   // Maxflow
          122  +   if( dinic(G, F, SRC, DST) < M*n )
          123  +    return M-1;
          124  +  }
          125  +  return n;
          126  + }
          127  +};

Added SRM/400/1A.cpp version [8c5bdf5260c77024]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class StrongPrimePower
           20  +{
           21  +public:
           22  + vector <int> baseAndExponent(string n)
           23  + {
           24  +  LL N;
           25  +  stringstream(n) >> N;
           26  +
           27  +  LL sN = (LL) sqrt( (double)N );
           28  +  if( sN*sN == N && isPrime(sN) ) {
           29  +   vector<int> ans;
           30  +   ans.push_back(sN);
           31  +   ans.push_back(2);
           32  +   return ans;
           33  +  }
           34  +  if( (sN+1)*(sN+1) == N && isPrime(sN+1) ) {
           35  +   vector<int> ans;
           36  +   ans.push_back(sN+1);
           37  +   ans.push_back(2);
           38  +   return ans;
           39  +  }
           40  +
           41  +  for(LL p=2; p*p*p<=N; ++p)
           42  +   if( N%p==0 ) {
           43  +    LL q=0;
           44  +    while(N%p==0)
           45  +     N /= p, ++q;
           46  +    if( N==1 ) {
           47  +     vector<int> ans;
           48  +     ans.push_back(p);
           49  +     ans.push_back(q);
           50  +     return ans;
           51  +    }
           52  +    break;
           53  +   }
           54  +  return vector<int>();
           55  + }
           56  +
           57  + bool isPrime(LL N) {
           58  +  for(LL p=2; p*p<=N; ++p)
           59  +   if(N%p==0)
           60  +    return false;
           61  +  return true;
           62  + }
           63  +};
           64  +
           65  +// BEGIN CUT HERE
           66  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           67  +int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           68  +
           69  +template<int N> struct Case_ {};
           70  +char Test_(...);
           71  +int Test_(Case_<0>) {
           72  + string n = "27";
           73  + int RetVal_[] = {3, 3 };
           74  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           75  + return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
           76  +int Test_(Case_<1>) {
           77  + string n = "10";
           78  + vector <int> RetVal;
           79  + return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
           80  +int Test_(Case_<2>) {
           81  + string n = "7";
           82  + vector <int> RetVal;
           83  + return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
           84  +int Test_(Case_<3>) {
           85  + string n = "1296";
           86  + vector <int> RetVal;
           87  + return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
           88  +int Test_(Case_<4>) {
           89  + string n = "576460752303423488";
           90  + int RetVal_[] = {2, 59 };
           91  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           92  + return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
           93  +int Test_(Case_<5>) {
           94  + string n = "999999874000003969";
           95  + int RetVal_[] = {999999937, 2 };
           96  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           97  + return verify_case(RetVal, StrongPrimePower().baseAndExponent(n)); }
           98  +
           99  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          100  +template<>      void Run_<-1>() {}
          101  +int main() { Run_<0>(); }
          102  +// END CUT HERE
          103  +

Added SRM/400/1B.cpp version [a8db06433cf2bbb2]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +#include <bitset>
           19  +
           20  +static const int INF = 3000;
           21  +class ReversalChain
           22  +{
           23  +public:
           24  + map<pair<pair<LL,LL>,int>,int> memo;
           25  + int minReversal(string init, string goal)
           26  + {
           27  +  LL s=0, sb=0; for(int i=0; i<init.size(); ++i) if(init[i]=='1') s |= (1LL<<i), sb++;
           28  +  LL g=0, gb=0; for(int i=0; i<goal.size(); ++i) if(goal[i]=='1') g |= (1LL<<i), gb++;
           29  +  if( sb != gb )
           30  +   return -1;
           31  +  int a = mrev(s, g, init.size());
           32  +  return a>=INF ? -1 : a;
           33  + }
           34  + int mrev(LL s, LL g, int m)
           35  + {
           36  +  #define mask(x)  ((x) & (1LL<<(m))-1)
           37  +  #define ith(x,i) (((x)>>(i))&1)
           38  +
           39  +  if( mask(s) == mask(g) )
           40  +   return 0;
           41  +
           42  +  pair<pair<LL,LL>,int> key(make_pair(mask(s),mask(g)),m);
           43  +  if( memo.count(key) )
           44  +   return memo[key];
           45  +
           46  +  int a = INF;
           47  +  if( ith(s,m-1)==ith(g,m-1) ) a = min(a, mrev(s, g, m-1));
           48  +  if( ith(s,0)==ith(g,0) )     a = min(a, mrev(s>>1, g>>1, m-1));
           49  +
           50  +  s = bitrev(s,m);
           51  +  if( ith(s,m-1)==ith(g,m-1) ) a = min(a, 1+mrev(s, g, m-1));
           52  +  if( ith(s,0)==ith(g,0) )     a = min(a, 1+mrev(s>>1, g>>1, m-1));
           53  +
           54  +  return memo[key] = a;
           55  + }
           56  + LL bitrev(LL x, LL m)
           57  + {
           58  +  LL y = 0;
           59  +  for(int i=0; i<m; ++i)
           60  +   y |= (((x>>i)&1) << (m-1-i));
           61  +  return y;
           62  + }
           63  +};
           64  +
           65  +// BEGIN CUT HERE
           66  +#include <ctime>
           67  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           68  +
           69  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           70  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           71  +
           72  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           73  +char Test_(...);
           74  +int Test_(Case_<0>) {
           75  + string init = "1100";
           76  + string goal = "0110";
           77  + int RetVal = 1;
           78  + return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
           79  +int Test_(Case_<1>) {
           80  + string init = "111000";
           81  + string goal = "101010";
           82  + int RetVal = 2;
           83  + return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
           84  +int Test_(Case_<2>) {
           85  + string init = "0";
           86  + string goal = "1";
           87  + int RetVal = -1;
           88  + return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
           89  +int Test_(Case_<3>) {
           90  + string init = "10101";
           91  + string goal = "10101";
           92  + int RetVal = 0;
           93  + return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
           94  +int Test_(Case_<4>) {
           95  + string init = "111000111000";
           96  + string goal = "001100110011";
           97  + int RetVal = 4;
           98  + return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
           99  +int Test_(Case_<5>) {
          100  + string init = "001000011000000111000000001111";
          101  + string goal = "100100100100100100100100100100";
          102  + int RetVal = 9;
          103  + return verify_case(RetVal, ReversalChain().minReversal(init, goal)); }
          104  +
          105  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          106  +template<>      void Run_<-1>() {}
          107  +int main() { Run_<0>(); }
          108  +// END CUT HERE
          109  +

Added SRM/400/1C.cpp version [9f9946fdf86740c4]

            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 CollectingBonuses { public:
           23  + double expectedBuy(string n, string k)
           24  + {
           25  +  LL N; {stringstream ss; ss<<n; ss>>N;}
           26  +  LL K; {stringstream ss; ss<<k; ss>>K;}
           27  +  return N * sigma(K,N);
           28  + }
           29  + double f(LL b)
           30  + {
           31  +  return 0.5772156649015313 + log(b+0.5);
           32  + }
           33  + double sigma(LL k, LL n)
           34  + {
           35  +  // compute (1/n-k+1 + ... + 1/n)
           36  +
           37  +  if(k<=10000000) {
           38  +   double p=0.0;
           39  +   for(LL i=0; i<k; ++i)
           40  +    p += 1.0 / (n-i);
           41  +   return p;
           42  +  }
           43  +  else if(n-k<=10000000) {
           44  +   double p=0.0;
           45  +   for(LL i=1; i<=n-k; ++i)
           46  +    p += 1.0 / i;
           47  +   return f(n) - p;
           48  +  }
           49  +  LL x = 2*n+1;
           50  +  LL y = 2*n-2*k+1;
           51  +  if( x<y*2 )
           52  +   return log1p(double(x-y)/y);
           53  +  else
           54  +   return log( double(x)/y );
           55  + }
           56  +
           57  +};
           58  +
           59  +// BEGIN CUT HERE
           60  +#include <ctime>
           61  +double start_time; string timer()
           62  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           63  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           64  + { os << "{ ";
           65  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           66  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           67  +void verify_case(const double& Expected, const double& Received) {
           68  + bool ok = (abs(Expected - Received) < 1e-9);
           69  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           70  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           71  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           72  +#define END  verify_case(_, CollectingBonuses().expectedBuy(n, k));}
           73  +int main(){
           74  +
           75  +CASE(0)
           76  + string n = "1";
           77  + string k = "1";
           78  + double _ = 1.0;
           79  +END
           80  +CASE(1)
           81  + string n = "2";
           82  + string k = "1";
           83  + double _ = 1.0;
           84  +END
           85  +CASE(2)
           86  + string n = "2";
           87  + string k = "2";
           88  + double _ = 3.0;
           89  +END
           90  +CASE(3)
           91  + string n = "4";
           92  + string k = "3";
           93  + double _ = 4.333333333333333;
           94  +END
           95  +CASE(4)
           96  + string n = "999999999999999999";
           97  + string k = "999999999999999999";
           98  + double _ = 4.202374733879435E19;
           99  +END
          100  +/*
          101  +CASE(5)
          102  + string n = ;
          103  + string k = ;
          104  + double _ = ;
          105  +END
          106  +*/
          107  +}
          108  +// END CUT HERE

Added SRM/424/1A-2B.cpp version [28d343930b8a6ef8]

            1  +struct ProductOfDigits
            2  +{
            3  + int smallestNumber( int N )
            4  + {
            5  +  if( N < 10 )
            6  +   return 1;
            7  +  int ans = 0;
            8  +  for(int d=9; d>=2; --d)
            9  +   while( N%d == 0 )
           10  +    N/=d, ans++;
           11  +  return N==1 ? ans : -1;
           12  + }
           13  +};

Added SRM/424/1B.cpp version [bc1042fb4b67d356]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +int memo[1001][1001];
           19  +
           20  +class StrengthOrIntellect
           21  +{
           22  +public:
           23  + int numberOfMissions(vector <int> strength, vector <int> intellect, vector <int> points)
           24  + {
           25  +  memset(memo, 0xff, sizeof(memo));
           26  +  return rec(1, 1, strength, intellect, points);
           27  + }
           28  +
           29  + int rec(int s, int i, vector<int>& strength, vector<int>& intellect, vector<int>& points)
           30  + {
           31  +  if( memo[s][i] >= 0 )
           32  +   return memo[s][i];
           33  +
           34  +  int pt = 2-s-i, cnt=0;
           35  +  for(int j=0; j<strength.size(); ++j)
           36  +   if( strength[j]<=s || intellect[j]<=i )
           37  +    pt+=points[j], ++cnt;
           38  +
           39  +  for(int ds=0; ds<=pt; ++ds) {
           40  +   int ss = min(1000,s + ds);
           41  +   int ii = min(1000,i + pt-ds);
           42  +   if( ss>s || ii>i )
           43  +    cnt = max(cnt, rec(ss, ii, strength, intellect, points));
           44  +  }
           45  +  return memo[s][i] = cnt;
           46  + }
           47  +
           48  +// BEGIN CUT HERE
           49  + public:
           50  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           51  + private:
           52  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           53  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           54  + void test_case_0() { int Arr0[] = {1, 2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 2}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; verify_case(0, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
           55  + void test_case_1() { int Arr0[] = {3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {2}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 0; verify_case(1, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
           56  + void test_case_2() { int Arr0[] = {1, 3, 1, 10, 3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 1, 3, 20, 3}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {2, 1, 1, 5, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 4; verify_case(2, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
           57  + void test_case_3() { int Arr0[] = {1, 2, 100, 5, 100, 10, 100, 17, 100}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 100, 3, 100, 7, 100, 13, 100, 21}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 2, 3, 4, 5, 6, 7, 8, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 9; verify_case(3, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
           58  + void test_case_4() { int Arr0[] = {1, 10, 1, 2, 16, 12, 13, 19, 12, 8}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {1, 5, 1, 8, 3, 5, 3, 16, 19, 20}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1, 1, 1, 2, 1, 1, 2, 3, 5, 1}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 7; verify_case(4, Arg3, numberOfMissions(Arg0, Arg1, Arg2)); }
           59  +
           60  +// END CUT HERE
           61  +};
           62  +// BEGIN CUT HERE
           63  +int main() { StrengthOrIntellect().run_test(-1); }
           64  +// END CUT HERE

Added SRM/424/1C.cpp version [b256d59b02db33a5]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +template<typename T = LL>
           19  +struct FenwickTree
           20  +{
           21  + vector<T> x;
           22  + FenwickTree(size_t n, const T& v = T()) : x(n, v) {}
           23  +
           24  + void incr( int k, const T& a ) { // z[k] += a;
           25  +  for(; k < x.size(); k|=k+1)
           26  +   x[k] += a;
           27  + }
           28  +
           29  + T sum(int i, int j) { // z[i]+...+z[j] : inclusive
           30  +  if(i)
           31  +   return sum(0, j) - sum(0, i-1);
           32  +  else {
           33  +   T v = T();
           34  +   for(; j>=0; j=(j&(j+1))-1)
           35  +    v += x[j];
           36  +   return v;
           37  +  }
           38  + }
           39  +};
           40  +
           41  +static const int MODVAL = 1000000007;
           42  +
           43  +class ProductOfPrices
           44  +{
           45  +public:
           46  + int product(int N, int L, int X0, int A, int B)
           47  + {
           48  +  LL result = 1;
           49  +
           50  +  FenwickTree<> fw(L), nm(L);
           51  +
           52  +  LL X = X0 % L;
           53  +  fw.incr(X, X);
           54  +  nm.incr(X, 1);
           55  +  for(int i=1; i<N; ++i)
           56  +  {
           57  +   X = (X*A+B) % L;
           58  +
           59  +   LL sumL = fw.sum(0, X-1);
           60  +   LL sumR = fw.sum(X, L-1);
           61  +   LL numL = nm.sum(0, X-1);
           62  +   LL numR = nm.sum(X, L-1);
           63  +
           64  +   LL price = ((X*numL - sumL) + (sumR - X*numR)) % MODVAL;
           65  +   result = (result * price) % MODVAL;
           66  +
           67  +   fw.incr(X, X);
           68  +   nm.incr(X, 1);
           69  +  }
           70  +  return result;
           71  + }
           72  +
           73  +// BEGIN CUT HERE
           74  + public:
           75  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           76  + private:
           77  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           78  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           79  + void test_case_0() { int Arg0 = 5; int Arg1 = 10; int Arg2 = 3; int Arg3 = 1; int Arg4 = 1; int Arg5 = 180; verify_case(0, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           80  + void test_case_1() { int Arg0 = 3; int Arg1 = 20; int Arg2 = 5; int Arg3 = 2; int Arg4 = 3; int Arg5 = 64; verify_case(1, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           81  + void test_case_2() { int Arg0 = 4; int Arg1 = 21; int Arg2 = 1; int Arg3 = 7; int Arg4 = 1; int Arg5 = 3087; verify_case(2, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           82  + void test_case_3() { int Arg0 = 10; int Arg1 = 100; int Arg2 = 4; int Arg3 = 37; int Arg4 = 11; int Arg5 = 591860767; verify_case(3, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           83  + void test_case_4() { int Arg0 = 5; int Arg1 = 200000; int Arg2 = 999999999; int Arg3 = 123456789; int Arg4 = 987654321; int Arg5 = 499739175; verify_case(4, Arg5, product(Arg0, Arg1, Arg2, Arg3, Arg4)); }
           84  +
           85  +// END CUT HERE
           86  +};
           87  +// BEGIN CUT HERE
           88  +int main() { ProductOfPrices().run_test(-1); }
           89  +// END CUT HERE

Added SRM/424/2A.cpp version [d8235f29f64235d2]

            1  +#include <string>
            2  +#include <stack>
            3  +using namespace std;
            4  +
            5  +struct MagicSpell
            6  +{
            7  + string fixTheSpell( string spell )
            8  + {
            9  +  stack<char> s;
           10  +  for(int i=0; i<spell.size(); ++i)
           11  +   if( spell[i]=='A' || spell[i]=='Z' )
           12  +    s.push( spell[i] );
           13  +  for(int i=0; i<spell.size(); ++i)
           14  +   if( spell[i]=='A' || spell[i]=='Z' )
           15  +    spell[i]=s.top(), s.pop();
           16  +  return spell;
           17  + }
           18  +};

Added SRM/424/2C.cpp version [8b2db66f69d32595]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <set>
            4  +using namespace std;
            5  +
            6  +struct BestRoads
            7  +{
            8  + vector<int> numberOfRoads(vector<string> roads, int M)
            9  + {
           10  +  int N = roads.size();
           11  +  vector<int> ans(N);
           12  +
           13  +  // Kruskal
           14  +  typedef pair<int,int> road;
           15  +  set<road> Q;
           16  +  for(int i=0; i<N; ++i)
           17  +   for(int j=i+1; j<N; ++j)
           18  +    if( roads[i][j]=='Y' )
           19  +     Q.insert( road(i,j) );
           20  +
           21  +  vector<int> p(N,-1), s(N, 1); // Union-Find
           22  +  int div=N, red=M-N+1;
           23  +
           24  +  for(set<road>::iterator it=Q.begin(); it!=Q.end(); ++it)
           25  +  {
           26  +   road r = *it;
           27  +   int a=r.first;  while(p[a]!=-1) a=p[a];
           28  +   int b=r.second; while(p[b]!=-1) b=p[b];
           29  +   if( a != b )
           30  +   {
           31  +    ans[r.first]++, ans[r.second]++, div--;
           32  +    if(s[a]<s[b]) p[a]=b, s[b]+=s[a];
           33  +    else          p[b]=a, s[a]+=s[b];
           34  +   }
           35  +   else if( red )
           36  +    ans[r.first]++, ans[r.second]++, red--;
           37  +  }
           38  +
           39  +  return (red==0 && div==1) ? ans : vector<int>();
           40  + }
           41  +};

Added SRM/425/1A.cpp version [637ed2e24dcc1d56]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <algorithm>
            4  +#include <map>
            5  +#include <set>
            6  +using namespace std;
            7  +
            8  +typedef pair<int,int> point;
            9  +
           10  +class CrazyBot
           11  +{
           12  +public:
           13  + double getProbability(int n, int east, int west, int south, int north)
           14  + {
           15  +  set<point> vis;
           16  +  vis.insert( point(0,0) );
           17  +  vis.insert( point(0,1) );
           18  +  return rec(vis, point(0,1), n-1, east, west, south, north);
           19  + }
           20  +
           21  + double rec( set<point>& vis, point p, int N, int e, int w, int s, int n)
           22  + {
           23  +  if( N == 0 )
           24  +   return 1;
           25  +  int dx[] = {0,0,1,-1};
           26  +  int dy[] = {1,-1,0,0};
           27  +  int pr[] = {e,w,s,n};
           28  +  double ans = 0;
           29  +  for(int i=0; i<4; ++i)
           30  +  {
           31  +   point q( p.first+dx[i], p.second+dy[i] );
           32  +   if( !vis.count(q) )
           33  +   {
           34  +    vis.insert(q);
           35  +    ans += double(pr[i])/100 * rec(vis, q, N-1, e, w, s, n);
           36  +    vis.erase(q);
           37  +   }
           38  +  }
           39  +  return ans;
           40  + }
           41  +};

Added SRM/425/1B.cpp version [e714e7afac0b764b]

            1  +#include <vector>
            2  +#include <string>
            3  +#include <algorithm>
            4  +#include <set>
            5  +#include <iostream>
            6  +using namespace std;
            7  +
            8  +class PiecesMover
            9  +{
           10  +public:
           11  + static bool is_connected(int cur)
           12  + {
           13  +  int py[5], px[5], pn=0;
           14  +  for(int j=0; j<25; ++j)
           15  +   if( cur & (1<<j) )
           16  +    py[pn]=j/5, px[pn]=j%5, pn++;
           17  +
           18  +  int uf[5] = {0,1,2,3,4}, conn = pn;
           19  +
           20  +  for(int i=0; i<pn; ++i)
           21  +  for(int j=i+1; j<pn; ++j)
           22  +   if( px[i]==px[j] && abs(py[i]-py[j])==1
           23  +    || py[i]==py[j] && abs(px[i]-px[j])==1 ) {
           24  +    int a=i; while(uf[a]!=a) a=uf[a];
           25  +    int b=j; while(uf[b]!=b) b=uf[b];
           26  +    if(a!=b) { uf[a]=b, --conn; }
           27  +   }
           28  +  return conn==1;
           29  + }
           30  +
           31  + int getMinimumMoves(vector <string> board)
           32  + {
           33  +  int start = 0;
           34  +  for(int i=0; i<25; ++i)
           35  +   if( board[i/5][i%5]=='*' )
           36  +    start |= (1<<i);
           37  +
           38  +  vector<bool> visited(1<<25); visited[start] = false;
           39  +  vector<int> Q(1, start);
           40  +  int step = 0;
           41  +  for(;; ++step)
           42  +  {
           43  +   vector<int> Q2;
           44  +   for(int i=0; i!=Q.size(); ++i)
           45  +   {
           46  +    int cur = Q[i];
           47  +    if( is_connected(cur) )
           48  +     return step;
           49  +
           50  +    // next
           51  +    int dx[] = {1,-1,0,0};
           52  +    int dy[] = {0,0,1,-1};
           53  +    for(int j=0; j<25; ++j)
           54  +     if( cur & (1<<j) )
           55  +      for(int k=0; k<4; ++k)
           56  +      {
           57  +       int jy=j/5+dy[k], jx=j%5+dx[k];
           58  +       if(0<=jy && jy<5 && 0<=jx && jx<5) {
           59  +        int next = 1 << (jy*5+jx);
           60  +        if( !(cur&next) ) {
           61  +         next = cur&~(1<<j)|next;
           62  +         if( !visited[next] ) {
           63  +          visited[next]=true;
           64  +          Q2.push_back(next);
           65  +         }
           66  +        }
           67  +       }
           68  +      }
           69  +   }
           70  +   Q.swap(Q2);
           71  +  }
           72  +  return -1;
           73  + }
           74  +};
           75  +
           76  +int main()
           77  +{
           78  + vector<string> x;
           79  +x.push_back(".....");
           80  +x.push_back("..**.");
           81  +x.push_back(".....");
           82  +x.push_back("...*.");
           83  +x.push_back(".....");
           84  + cout << PiecesMover().getMinimumMoves(x) << endl;;
           85  +}

Added SRM/425/1C.cpp version [bd2409ddf241ebbe]

            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 RoadsOfKingdom { public:
           23  + vector< vector<double> > P;
           24  +
           25  + double getProbability(vector <string> roads)
           26  + {
           27  +  P     = read_input(roads);
           28  +  memo  = vector<double>(1<<P.size(), -1);
           29  +  memo0 = vector<double>(P.size()<<P.size(), -1);
           30  +  memo1 = vector<double>(P.size()<<P.size(), -1);
           31  +  return prob_tree( (1<<P.size())-1 );
           32  + }
           33  +
           34  + vector< vector<double> > read_input(const vector<string>& R)
           35  + {
           36  +  int N = R.size();
           37  +  vector< vector<double> > P(N, vector<double>(N));
           38  +  for(int i=0; i<N; ++i)
           39  +   for(int j=0; j<N; ++j)
           40  +    P[i][j] = (R[i][j] - '0') / 8.0;
           41  +  return P;
           42  + }
           43  +
           44  + vector<double> memo;
           45  + double prob_tree(int S)
           46  + {
           47  +  if( memo[S] >= 0 )
           48  +   return memo[S];
           49  +
           50  +  // the first and the second smallest IDs in S
           51  +  int v, w;
           52  +  for(v=0;   (1<<v)<=S; ++v) if( S & 1<<v ) break;
           53  +  for(w=v+1; (1<<w)<=S; ++w) if( S & 1<<w ) break;
           54  +
           55  +  // if |S| < 2 then it always forms a tree
           56  +  if( (1<<w) > S )
           57  +   return memo[S] = 1.0;
           58  +
           59  +  // Let's consider v as the "root node" of S, and try all possible "subtrees" T containing w.
           60  +  // The situation is (other nodes)=v-(T where w in T)
           61  +  double p = 0.0;
           62  +  for(int T=S; T; T=(T-1)&S)
           63  +   if( (T & 1<<w) && !(T & 1<<v) )
           64  +    p += prob_tree(T) * prob_tree(S&~T) * prob_separated(T, S&~T&~(1<<v)) * prob_one(v, T);
           65  +  return memo[S] = p;
           66  + }
           67  +
           68  + double prob_separated(int S1, int S2)
           69  + {
           70  +  double p = 1.0;
           71  +  for(int v=0; (1<<v)<=S1; ++v) if( S1 & 1<<v )
           72  +   p *= prob_zero(v, S2);
           73  +  return p;
           74  + }
           75  +
           76  + vector<double> memo0;
           77  + double prob_zero(int v, int S) // 0 connection between v and S
           78  + {
           79  +  const int key = v<<P.size() | S;
           80  +  if( memo0[key] >= 0 ) return memo0[key];
           81  +
           82  +  double p = 1.0;
           83  +  for(int u=0; (1<<u)<=S; ++u) if( S & 1<<u )
           84  +   p *= 1.0 - P[v][u];
           85  +  return memo0[key] = p;
           86  + }
           87  +
           88  + vector<double> memo1;
           89  + double prob_one(int v, int S) // exactly 1 connection between v and S
           90  + {
           91  +  const int key = v<<P.size() | S;
           92  +  if( memo1[key] >= 0 ) return memo1[key];
           93  +
           94  +  double p = 0.0;
           95  +  for(int c=0; (1<<c)<=S; ++c) if( S & 1<<c )
           96  +  {
           97  +   double q = 1.0;
           98  +   for(int u=0; (1<<u)<=S; ++u) if( S & 1<<u )
           99  +    q *= u==c ? P[v][u] : 1-P[v][u];
          100  +   p += q;
          101  +  }
          102  +  return memo1[key] = p;
          103  + }
          104  +};
          105  +
          106  +// BEGIN CUT HERE
          107  +#include <ctime>
          108  +double start_time; string timer()
          109  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          110  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          111  + { os << "{ ";
          112  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          113  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          114  +void verify_case(const double& Expected, const double& Received) {
          115  + bool ok = (abs(Expected - Received) < 1e-9);
          116  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          117  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          118  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          119  +#define END  verify_case(_, RoadsOfKingdom().getProbability(roads));}
          120  +int main(){
          121  +
          122  +CASE(0)
          123  + string roads_[] = {"04",
          124  + "40"};
          125  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          126  + double _ = 0.5;
          127  +END
          128  +CASE(1)
          129  + string roads_[] = {"08",
          130  + "80"};
          131  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          132  + double _ = 1.0;
          133  +END
          134  +CASE(2)
          135  + string roads_[] = {"00",
          136  + "00"};
          137  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          138  + double _ = 0.0;
          139  +END
          140  +CASE(3)
          141  + string roads_[] = {"088",
          142  + "808",
          143  + "880"};
          144  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          145  + double _ = 0.0;
          146  +END
          147  +CASE(4)
          148  + string roads_[] = {"044",
          149  + "404",
          150  + "440"};
          151  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          152  + double _ = 0.375;
          153  +END
          154  +CASE(5)
          155  + string roads_[] = {"0701",
          156  + "7071",
          157  + "0708",
          158  + "1180"};
          159  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          160  + double _ = 0.622314453125;
          161  +END
          162  +CASE(6)
          163  + string roads_[] = {"0622100102300020", "6070000107208008", "2700207010110410", "2000188001010820", "1021032008000021", "0008300013001000", "0078200200000201", "1100002007000011", "0010010000600000", "2701830700518172", "3210000065000200", "0011000001002081", "0800010008020100", "0048002001201000", "2012200107080000", "0800101102010000"};
          164  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          165  + double _ = 5.519032471358341E-5;
          166  +END
          167  +/*
          168  +CASE(7)
          169  + string roads_[] = ;
          170  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          171  + double _ = ;
          172  +END
          173  +*/
          174  +}
          175  +// END CUT HERE

Added SRM/425/2C.cpp version [f7ec079893dd31a3]

            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 PiecesMover { public:
           23  + typedef vector< pair<int,int> > state;
           24  + int getMinimumMoves(vector <string> board)
           25  + {
           26  +  set<state> V;
           27  +  vector<state> Q(1, to_state(board));
           28  +  V.insert( Q.front() );
           29  +  for(int step=0; !Q.empty(); ++step)
           30  +  {
           31  +   vector<state> Q_next;
           32  +   for(int i=0; i<Q.size(); ++i)
           33  +   {
           34  +    const state& b = Q[i];
           35  +    if( is_connected(b) )
           36  +     return step;
           37  +    const vector<state>& next = next_states(b);
           38  +    for(int j=0; j<next.size(); ++j)
           39  +     if( V.insert(next[j]).second )
           40  +      Q_next.push_back(next[j]);
           41  +   }
           42  +   Q.swap(Q_next);
           43  +  }
           44  +  assert(false);
           45  + }
           46  +
           47  + state to_state( const vector<string>& b )
           48  + {
           49  +  state s;
           50  +  for(int y=0; y<5; ++y)
           51  +  for(int x=0; x<5; ++x)
           52  +   if( b[y][x] == '*' )
           53  +    s.push_back( make_pair(y,x) );
           54  +  sort( s.begin(), s.end() );
           55  +  return s;
           56  + }
           57  +
           58  + bool is_connected( const state& s )
           59  + {
           60  +  int N = s.size();
           61  +  vector< vector<int> > G(N, vector<int>(N));
           62  +  for(int i=0; i<N; ++i)
           63  +   for(int j=0; j<N; ++j)
           64  +    if( i == j )
           65  +     G[i][j] = 0;
           66  +    else
           67  +     G[i][j] = (abs(s[i].first-s[j].first)+abs(s[i].second-s[j].second) == 1 ? 1 : 100);
           68  +  for(int k=0; k<N; ++k)
           69  +   for(int i=0; i<N; ++i)
           70  +    for(int j=0; j<N; ++j)
           71  +     G[i][j] = min(G[i][j], G[i][k]+G[k][j]);
           72  +  for(int i=0; i<N; ++i)
           73  +   for(int j=0; j<N; ++j)
           74  +    if( G[i][j] > N )
           75  +     return false;
           76  +  return true;
           77  + }
           78  +
           79  + vector<state> next_states( const state& s )
           80  + {
           81  +  vector<state> result;
           82  +  for(int i=0; i<s.size(); ++i)
           83  +   for(int d=0; d<4; ++d)
           84  +   {
           85  +    set< pair<int,int> > x;
           86  +    for(int k=0; k<s.size(); ++k)
           87  +     if( i != k )
           88  +      x.insert( s[k] );
           89  +     else
           90  +     {
           91  +      static const int dy[] = {-1,+1,0,0};
           92  +      static const int dx[] = {0,0,-1,+1};
           93  +      int ny = s[k].first+dy[d];
           94  +      int nx = s[k].second+dx[d];
           95  +      if( 0<=ny && ny<5 && 0<=nx && nx<5 )
           96  +       x.insert( make_pair(ny, nx) );
           97  +     }
           98  +    if( x.size() == s.size() )
           99  +     result.push_back( state(x.begin(), x.end()) );
          100  +   }
          101  +  return result;
          102  + }
          103  +};
          104  +
          105  +// BEGIN CUT HERE
          106  +#include <ctime>
          107  +double start_time; string timer()
          108  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          109  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          110  + { os << "{ ";
          111  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          112  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          113  +void verify_case(const int& Expected, const int& Received) {
          114  + bool ok = (Expected == Received);
          115  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          116  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          117  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          118  +#define END  verify_case(_, PiecesMover().getMinimumMoves(board));}
          119  +int main(){
          120  +
          121  +CASE(0)
          122  + string board_[] = {".....",
          123  + "..**.",
          124  + ".....",
          125  + "...*.",
          126  + "....."}
          127  +;
          128  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          129  + int _ = 1;
          130  +END
          131  +CASE(1)
          132  + string board_[] = {".....",
          133  + ".....",
          134  + ".**..",
          135  + ".*...",
          136  + "**..."}
          137  +;
          138  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          139  + int _ = 0;
          140  +END
          141  +CASE(2)
          142  + string board_[] = {"*...*",
          143  + ".....",
          144  + ".....",
          145  + ".....",
          146  + "*...*"}
          147  +;
          148  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          149  + int _ = 12;
          150  +END
          151  +/*
          152  +CASE(3)
          153  + string board_[] = ;
          154  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          155  + int _ = ;
          156  +END
          157  +CASE(4)
          158  + string board_[] = ;
          159  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          160  + int _ = ;
          161  +END
          162  +*/
          163  +}
          164  +// END CUT HERE

Added SRM/426-U/1A.cpp version [4232481aaf925462]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class ShufflingMachine
           19  +{
           20  +public:
           21  + double stackDeck(vector <int> shuffle, int maxShuffles, vector <int> cardsReceived, int K)
           22  + {
           23  +  set<int> my( cardsReceived.begin(), cardsReceived.end() );
           24  +
           25  +  vector<int> cur(shuffle.size());
           26  +  for(int i=0; i<cur.size(); ++i)
           27  +   cur[i] = i;
           28  +
           29  +  vector<double> prob(shuffle.size());
           30  +  for(int N=1; N<=maxShuffles; ++N)
           31  +  {
           32  +   for(int i=0; i<cur.size(); ++i)
           33  +    cur[i] = shuffle[cur[i]];
           34  +
           35  +   for(int i=0; i<cur.size(); ++i)
           36  +    if( my.count(cur[i]) )
           37  +     prob[i] += 1.0 / maxShuffles;
           38  +  }
           39  +
           40  +  sort( prob.rbegin(), prob.rend() );
           41  +  return accumulate( prob.begin(), prob.begin()+K, 0.0 );
           42  + }
           43  +
           44  +// BEGIN CUT HERE
           45  + public:
           46  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           47  + private:
           48  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           49  + void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           50  + void test_case_0() { int Arr0[] = {1,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arr2[] = {0}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 1; double Arg4 = 0.6666666666666666; verify_case(0, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
           51  + void test_case_1() { int Arr0[] = {1,2,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 5; int Arr2[] = {0}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; double Arg4 = 0.8; verify_case(1, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
           52  + void test_case_2() { int Arr0[] = {1,2,0,4,3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 7; int Arr2[] = {0,3}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; double Arg4 = 1.0; verify_case(2, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
           53  + void test_case_3() { int Arr0[] = {0,4,3,5,2,6,1}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 19; int Arr2[] = {1,3,5}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 2; double Arg4 = 1.0526315789473684; verify_case(3, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
           54  + void test_case_4() { int Arr0[] = {3,4,7,2,8,5,6,1,0,9}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 47; int Arr2[] = {6,3,5,2,8,7,4}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arg3 = 8; double Arg4 = 6.297872340425532; verify_case(4, Arg4, stackDeck(Arg0, Arg1, Arg2, Arg3)); }
           55  +
           56  +// END CUT HERE
           57  +};
           58  +// BEGIN CUT HERE
           59  +int main() {
           60  + ShufflingMachine().run_test(-1);
           61  +}
           62  +// END CUT HERE

Added SRM/426-U/1B.cpp version [0e4f7f13c5c792cd]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class CatchTheMice
           19  +{
           20  +public:
           21  + double intersect(double b1, double a1, double b2, double a2)
           22  + {
           23  +  // a1x + b1 == a2x + b2
           24  +  if( a1 == a2 ) return -1;
           25  +  return (b2-b1) / (a1-a2);
           26  + }
           27  +
           28  + double largestCage(vector <int> xp, vector <int> yp, vector <int> xv, vector <int> yv)
           29  + {
           30  +  vector<double> t; // collision time
           31  +  t.push_back(0);
           32  +
           33  +  int n = xp.size();
           34  +  for(int i=0; i<n; ++i)
           35  +   for(int j=i+1; j<n; ++j)
           36  +   {
           37  +    double ct = intersect(xp[i], xv[i], xp[j], xv[j]);
           38  +    if(ct>0) t.push_back(ct);
           39  +    ct = intersect(yp[i], yv[i], yp[j], yv[j]);
           40  +    if(ct>0) t.push_back(ct);
           41  +   }
           42  +
           43  +  sort(t.begin(), t.end());
           44  +  t.erase(unique(t.begin(), t.end()), t.end());
           45  +  t.push_back( t.back()+1.0 );
           46  +
           47  +  double Lmin = 1e+300;
           48  +  for(int i=0; i+1<t.size(); ++i)
           49  +  {
           50  +   double ti = (t[i]+t[i+1])/2;
           51  +
           52  +   int j_xm=0; double xm =  1e+300;
           53  +   int j_xM=0; double xM = -1e+300;
           54  +   int j_ym=0; double ym =  1e+300;
           55  +   int j_yM=0; double yM = -1e+300;
           56  +   for(int j=0; j<n; ++j) {
           57  +    if( xm > xp[j]+xv[j]*ti ) j_xm=j, xm=xp[j]+xv[j]*ti;
           58  +    if( xM < xp[j]+xv[j]*ti ) j_xM=j, xM=xp[j]+xv[j]*ti;
           59  +    if( ym > yp[j]+yv[j]*ti ) j_ym=j, ym=yp[j]+yv[j]*ti;
           60  +    if( yM < yp[j]+yv[j]*ti ) j_yM=j, yM=yp[j]+yv[j]*ti;
           61  +   }
           62  +
           63  +   int Xp = xp[j_xM]-xp[j_xm];
           64  +   int Xv = xv[j_xM]-xv[j_xm];
           65  +   int Yp = yp[j_yM]-yp[j_ym];
           66  +   int Yv = yv[j_yM]-yv[j_ym];
           67  +
           68  +   // min of max(x,y)
           69  +   double ct = intersect(Xp,Xv,Yp,Yv);
           70  +   if( t[i] <= ct && ct <= t[i+1] )
           71  +    Lmin = min(Lmin, Xp + Xv*ct);
           72  +   else {
           73  +    Lmin = min(Lmin, max(Xp+Xv*t[i+0], Yp+Yv*t[i+0]));
           74  +    Lmin = min(Lmin, max(Xp+Xv*t[i+1], Yp+Yv*t[i+1]));
           75  +   }
           76  +  }
           77  +  return Lmin;
           78  + }
           79  +
           80  +// BEGIN CUT HERE
           81  + public:
           82  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); if ((Case == -1) || (Case == 6)) test_case_6(); }
           83  + private:
           84  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           85  + void verify_case(int Case, const double &Expected, const double &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           86  + void test_case_0() { int Arr0[] = {0,10}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {10,-10}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {0,0}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 10.0; verify_case(0, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
           87  + void test_case_1() { int Arr0[] = {0,10,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0,10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,-6,4}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {4,5,-4}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 3.0; verify_case(1, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
           88  + void test_case_2() { int Arr0[] = {50,10,30,15}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {-10,30,20,40}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {-5,-10,-15,-5}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {40,-10,-1,-50}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 40.526315789473685; verify_case(2, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
           89  + void test_case_3() { int Arr0[] = {0,10,10,0}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0,10,10}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {1,0,-1,0}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {0,1,0,-1}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 10.0; verify_case(3, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
           90  + void test_case_4() { int Arr0[] = {13,50,100,40,-100}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {20,20,-150,-40,63}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {4,50,41,-41,-79}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {1,1,1,3,-1}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 212.78688524590163; verify_case(4, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
           91  + void test_case_5() { int Arr0[] = {0,10}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {0,0}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {5,5}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {3,3}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 10.0; verify_case(5, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
           92  + void test_case_6() { int Arr0[] = {-49,-463,-212,-204,-557,-67,-374,-335,-590,-4}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arr1[] = {352,491,280,355,129,78,404,597,553,445}; vector <int> Arg1(Arr1, Arr1 + (sizeof(Arr1) / sizeof(Arr1[0]))); int Arr2[] = {-82,57,-23,-32,89,-72,27,17,100,-94}; vector <int> Arg2(Arr2, Arr2 + (sizeof(Arr2) / sizeof(Arr2[0]))); int Arr3[] = {-9,-58,9,-14,56,75,-32,-98,-81,-43}; vector <int> Arg3(Arr3, Arr3 + (sizeof(Arr3) / sizeof(Arr3[0]))); double Arg4 = 25.467532467532468; verify_case(6, Arg4, largestCage(Arg0, Arg1, Arg2, Arg3)); }
           93  +
           94  +// END CUT HERE
           95  +};
           96  +// BEGIN CUT HERE
           97  +int main() {
           98  + CatchTheMice().run_test(-1);
           99  +}
          100  +// END CUT HERE

Added SRM/426-U/1C-take1.cpp version [4413ce4dac004874]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +vector<double> solve_linear_eq( int n, vector< vector<double> > M, const vector<double>& V )
           19  +{
           20  + vector<double> A(V);
           21  + for(int i=0; i<n; ++i)
           22  + {
           23  +  // pivot
           24  +  if( M[i][i] == 0 )
           25  +   for(int j=i+1; j<n; ++j)
           26  +    if( M[j][i] != 0 )
           27  +     {swap(M[i], M[j]); swap(A[i], A[j]); break;}
           28  +  if( M[i][i] == 0 )
           29  +   throw "no anser";
           30  +
           31  +  // M[i][i] <-- 1
           32  +  double p = M[i][i];
           33  +  for(int j=i; j<n; ++j)
           34  +   M[i][j] /= p;
           35  +  A[i] /= p;
           36  +
           37  +  // M[*][i] <-- 0
           38  +  for(int j=0; j<n; ++j) if(j!=i)
           39  +  {
           40  +   double r = M[j][i];
           41  +   for(int k=i; k<n; ++k)
           42  +    M[j][k] -= M[i][k] * r;
           43  +   A[j] -= A[i] * r;
           44  +  }
           45  + }
           46  + // consistency check
           47  + for(int i=n; i<M.size(); ++i) {
           48  +  double s = 0.0;
           49  +  for(int j=0; j<n; ++j)
           50  +   s += M[i][j] * A[j];
           51  +  if( abs(s-A[i]) > 1e-4 )
           52  +   throw "no answer";
           53  + }
           54  + return A;
           55  +}
           56  +
           57  +
           58  +class LongStraightRoad
           59  +{
           60  +public:
           61  + int distanceToDestination(vector <string> signs, string destination)
           62  + {
           63  +  typedef map< string, vector< pair<double,int> > > MSV;
           64  +  MSV data;
           65  +  for(int i=0; i<signs.size(); ++i)
           66  +  {
           67  +   stringstream sin(signs[i]);
           68  +   while(sin) {
           69  +    string n; int d; sin>>n>>d;
           70  +    char c; sin>>c; // ';'
           71  +    data[n].push_back( make_pair(double(d), i) );
           72  +   }
           73  +  }
           74  +  if( data[destination].empty() )
           75  +   return -1;
           76  +
           77  +  vector< vector<double> > M;
           78  +  vector<double> V;
           79  +  for(MSV::iterator it=data.begin(); it!=data.end(); ++it)
           80  +  {
           81  +   vector< pair<double,int> >& d = it->second;
           82  +   for(int i=0; i+1<d.size(); ++i)
           83  +   {
           84  +    if( d[i].first <= d[i+1].first )
           85  +     return -1;
           86  +
           87  +    // S[d[i].second] - S[d[i+1].second] == d[i+1].first - d[i].first
           88  +    vector<double> Mk(signs.size());
           89  +    Mk[d[i].second]   = 1;
           90  +    Mk[d[i+1].second] = -1;
           91  +    M.push_back(Mk);
           92  +    V.push_back( d[i+1].first - d[i].first );
           93  +   }
           94  +  }
           95  +  // S[last] = 0.0
           96  +  vector<double> Mk(signs.size());
           97  +  Mk[signs.size()-1] = 1;
           98  +  M.push_back(Mk);
           99  +  V.push_back(0);
          100  +
          101  +  if( signs.size() > M.size() )
          102  +   return -1;
          103  +  try {
          104  +   vector<double> S = solve_linear_eq( signs.size(), M, V );
          105  +   for(int i=0; i+1<S.size(); ++i)
          106  +    if( S[i] > S[i+1] )
          107  +     return -1;
          108  +   double result =
          109  +    S[ data[destination][0].second ] + data[destination][0].first;
          110  +   int rI = (int)floor(result+0.5);
          111  +   if( abs(result-rI) > 1e-4 )
          112  +    return -1;
          113  +   return ( rI < 0 ? -1 : rI );
          114  +  } catch(const char*) {
          115  +   return -1;
          116  +  }
          117  + }
          118  +
          119  +// BEGIN CUT HERE
          120  + public:
          121  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
          122  + private:
          123  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          124  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
          125  + void test_case_0() { string Arr0[] = {"COLCHESTER 5;GLASTONBURY 25;MARLBOROUGH 13"
          126  +,"MARLBOROUGH 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "GLASTONBURY"; int Arg2 = 14; verify_case(0, Arg2, distanceToDestination(Arg0, Arg1)); }
          127  + void test_case_1() { string Arr0[] = {"COLCHESTER 5;GLASTONBURY 25;MARLBOROUGH 13"
          128  +,"GLASTONBURY 13;MARLBOROUGH 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "GLASTONBURY"; int Arg2 = -1; verify_case(1, Arg2, distanceToDestination(Arg0, Arg1)); }
          129  + void test_case_2() { string Arr0[] = {"A 25;B 15"
          130  +,"A 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "B"; int Arg2 = -1; verify_case(2, Arg2, distanceToDestination(Arg0, Arg1)); }
          131  + void test_case_3() { string Arr0[] = {"YVO 60;J 62"
          132  +,"K 45"
          133  +,"K 40;MV 17"
          134  +,"K 37;YVO 44;HY 48;CC 69;D 77;YXF 80"
          135  +,"YVO 30;B 37;RB 59"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "MV"; int Arg2 = 0; verify_case(3, Arg2, distanceToDestination(Arg0, Arg1)); }
          136  + void test_case_4() { string Arr0[] = {"A 200;B 150"
          137  +,"C 45;D 100;E 150"
          138  +,"C 25;E 130"
          139  +,"F 80;G 65"
          140  +,"G 35;H 160"
          141  +,"A 160"
          142  +,"H 130"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "F"; int Arg2 = -1; verify_case(4, Arg2, distanceToDestination(Arg0, Arg1)); }
          143  +
          144  +// END CUT HERE
          145  +};
          146  +// BEGIN CUT HERE
          147  +int main() {
          148  + LongStraightRoad().run_test(-1);
          149  +}
          150  +// END CUT HERE

Added SRM/426-U/1C-take2.cpp version [3cd3d111843830ab]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +
           19  +class LongStraightRoad
           20  +{
           21  +public:
           22  + typedef pair<int,int> edge; // (index,dist)
           23  + int distanceToDestination(vector<string> signs, string destination)
           24  + {
           25  +  int n = signs.size();
           26  +
           27  +  // parse
           28  +  vector< map<string, int> > data(n);
           29  +  map<string, vector<edge> > n2d; // name -> (index, dist)
           30  +  for(int i=0; i<n; ++i)
           31  +  {
           32  +   stringstream sin(signs[i]);
           33  +   while(sin) {
           34  +    string n; int d; sin>>n>>d;
           35  +    char c; sin>>c; // ';'
           36  +    data[i][n] = d;
           37  +    n2d[n].push_back( edge(i,d) );
           38  +   }
           39  +  }
           40  +
           41  +  // construct the graph
           42  +  vector< vector<edge> > G(n);
           43  +  for(int i=0; i<n; ++i)
           44  +  {
           45  +   for(map<string,int>::iterator it=data[i].begin(); it!=data[i].end(); ++it)
           46  +   {
           47  +    vector<edge>& es = n2d[it->first];
           48  +    for(int j=0; j<es.size(); ++j)
           49  +     if( es[j].first != i )
           50  +      G[i].push_back( edge(es[j].first, it->second - es[j].second) );
           51  +   }
           52  +  }
           53  +
           54  +  try {
           55  +   vector<bool> done(n, false);
           56  +   vector<int>     p(n);
           57  +   {
           58  +    vector<bool> visited(n, false);
           59  +    dfs(n-1, 0, G, visited, p);
           60  +
           61  +    vector<int> kn;
           62  +    for(int i=0; i<n; ++i)
           63  +     if( visited[i] ) {
           64  +      kn.push_back( p[i] );
           65  +      done[i] = true;
           66  +     }
           67  +    if( !sorted(kn) ) {
           68  +cerr << "ns1" << endl;
           69  +     return -1;
           70  +}
           71  +   }
           72  +   vector<edge>& es = n2d[destination];
           73  +   int result = p[es[0].first] + es[0].second;
           74  +   if( result < 0 )
           75  +    return -1;
           76  +
           77  +   for(int v=0; v<n; ++v)
           78  +    if( !done[v] )
           79  +    {
           80  +     vector<bool> visited(n, false);
           81  +     dfs(v, 0, G, visited, p);
           82  +
           83  +     vector<int> kn;
           84  +     for(int i=0; i<n; ++i)
           85  +      if( visited[i] ) {
           86  +       kn.push_back( p[i] );
           87  +       done[i] = true;
           88  +      }
           89  +     if( !sorted(kn) ) {
           90  +cerr << "ns@" << v << endl;
           91  +      return -1;
           92  +}
           93  +    }
           94  +   return result;
           95  +  } catch (const char*) {
           96  +   return -1;
           97  +  }
           98  + }
           99  +
          100  + bool sorted( vector<int>& kn )
          101  + {
          102  +  for(int i=0; i+1<kn.size(); ++i)
          103  +   if( kn[i] >= kn[i+1] )
          104  +    return false;
          105  +  return true;
          106  + }
          107  +
          108  + void dfs(int v, int d, vector< vector<edge> >& G, vector<bool>& visited, vector<int>& p)
          109  + {
          110  +  if( visited[v] ) {
          111  +   if( d != p[v] ) {
          112  +cerr << d << " " << v << " " << p[v] << endl;
          113  +    throw "bad";
          114  +}
          115  +   return;
          116  +  }
          117  +  visited[v] = true;
          118  +  p[v]       = d;
          119  +  for(int i=0; i<G[v].size(); ++i) {
          120  +cerr << v << "->" << G[v][i].first << " : " << G[v][i].second << endl;
          121  +   dfs( G[v][i].first, d+G[v][i].second, G, visited, p );
          122  +}
          123  + }
          124  +
          125  +// BEGIN CUT HERE
          126  + public:
          127  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
          128  + private:
          129  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          130  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
          131  + void test_case_0() { string Arr0[] = {"COLCHESTER 5;GLASTONBURY 25;MARLBOROUGH 13"
          132  +,"MARLBOROUGH 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "GLASTONBURY"; int Arg2 = 14; verify_case(0, Arg2, distanceToDestination(Arg0, Arg1)); }
          133  + void test_case_1() { string Arr0[] = {"COLCHESTER 5;GLASTONBURY 25;MARLBOROUGH 13"
          134  +,"GLASTONBURY 13;MARLBOROUGH 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "GLASTONBURY"; int Arg2 = -1; verify_case(1, Arg2, distanceToDestination(Arg0, Arg1)); }
          135  + void test_case_2() { string Arr0[] = {"A 25;B 15"
          136  +,"A 2"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "B"; int Arg2 = -1; verify_case(2, Arg2, distanceToDestination(Arg0, Arg1)); }
          137  + void test_case_3() { string Arr0[] = {"YVO 60;J 62"
          138  +,"K 45"
          139  +,"K 40;MV 17"
          140  +,"K 37;YVO 44;HY 48;CC 69;D 77;YXF 80"
          141  +,"YVO 30;B 37;RB 59"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "MV"; int Arg2 = 0; verify_case(3, Arg2, distanceToDestination(Arg0, Arg1)); }
          142  + void test_case_4() { string Arr0[] = {"A 200;B 150"
          143  +,"C 45;D 100;E 150"
          144  +,"C 25;E 130"
          145  +,"F 80;G 65"
          146  +,"G 35;H 160"
          147  +,"A 160"
          148  +,"H 130"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "F"; int Arg2 = -1; verify_case(4, Arg2, distanceToDestination(Arg0, Arg1)); }
          149  +
          150  +// END CUT HERE
          151  +};
          152  +// BEGIN CUT HERE
          153  +int main() {
          154  + LongStraightRoad().run_test(-1);
          155  +}
          156  +// END CUT HERE

Added SRM/427/1A.cpp version [ad7c58f810045566]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +int gcd(int a, int b)
           19  +{
           20  + while(a) {
           21  +  int t = a;
           22  +  a = b%a;
           23  +  b = t;
           24  + }
           25  + return b;
           26  +}
           27  +
           28  +class DesignCalendar
           29  +{
           30  +public:
           31  + int shortestPeriod(int dayLength, int yearLength)
           32  + {
           33  +  return dayLength / gcd(yearLength, dayLength);
           34  + }
           35  +
           36  +// BEGIN CUT HERE
           37  + public:
           38  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); if ((Case == -1) || (Case == 5)) test_case_5(); }
           39  + private:
           40  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           41  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           42  + void test_case_0() { int Arg0 = 4; int Arg1 = 1461; int Arg2 = 4; verify_case(0, Arg2, shortestPeriod(Arg0, Arg1)); }
           43  + void test_case_1() { int Arg0 = 86400; int Arg1 = 31558150; int Arg2 = 1728; verify_case(1, Arg2, shortestPeriod(Arg0, Arg1)); }
           44  + void test_case_2() { int Arg0 = 98; int Arg1 = 100; int Arg2 = 49; verify_case(2, Arg2, shortestPeriod(Arg0, Arg1)); }
           45  + void test_case_3() { int Arg0 = 1000 ; int Arg1 = 50000100; int Arg2 = 10; verify_case(3, Arg2, shortestPeriod(Arg0, Arg1)); }
           46  + void test_case_4() { int Arg0 = 5673; int Arg1 = 28565335; int Arg2 = 5673; verify_case(4, Arg2, shortestPeriod(Arg0, Arg1)); }
           47  + void test_case_5() { int Arg0 = 5555; int Arg1 = 846555; int Arg2 = 1111; verify_case(5, Arg2, shortestPeriod(Arg0, Arg1)); }
           48  +
           49  +// END CUT HERE
           50  +};
           51  +// BEGIN CUT HERE
           52  +int main() { DesignCalendar().run_test(-1); }
           53  +// END CUT HERE

Added SRM/427/1B.cpp version [cd5512e0c909abdd]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +LL dig(LL x)
           19  +{
           20  + if(x<=9) return x;
           21  + LL s = 0;
           22  + while(x)
           23  +  s += x%10, x/=10;
           24  + return dig(s);
           25  +}
           26  +class LocateTreasure
           27  +{
           28  +public:
           29  + string location(int K, int m)
           30  + {
           31  +  vector<LL> ds;
           32  +  ds.push_back(1);
           33  +  LL found[10] = {-1, 0, -1, -1, -1, -1, -1, -1, -1, -1};
           34  +  LL loop_beg, loop_end;
           35  +  for(LL i=1;; ++i) {
           36  +   LL d = dig( ds.back()*m );
           37  +   if( found[d] < 0 )
           38  +   {
           39  +    ds.push_back(d);
           40  +    found[d] = i;
           41  +   }
           42  +   else
           43  +   {
           44  +    loop_beg = found[d];
           45  +    loop_end = i;
           46  +    break;
           47  +   }
           48  +  }
           49  +
           50  +  vector<LL> ds2 = ds;
           51  +  ds2.insert(ds2.end(), ds.begin()+loop_beg, ds.begin()+loop_end);
           52  +  ds2.insert(ds2.end(), ds.begin()+loop_beg, ds.begin()+loop_end);
           53  +  ds2.insert(ds2.end(), ds.begin()+loop_beg, ds.begin()+loop_end);
           54  +  ds2.insert(ds2.end(), ds.begin()+loop_beg, ds.begin()+loop_end);
           55  +  ds = ds2;
           56  +
           57  +  LL x=0, y=0;
           58  +
           59  +  if( K <= loop_beg )
           60  +  {
           61  +   for(LL i=0; i<K; ++i) {
           62  +    if( i%4==0 ) y += ds[i];
           63  +    if( i%4==1 ) x += ds[i];
           64  +    if( i%4==2 ) y -= ds[i];
           65  +    if( i%4==3 ) x -= ds[i];
           66  +   }
           67  +  }
           68  +  else
           69  +  {
           70  +   for(LL i=0; i<loop_beg; ++i) {
           71  +    if( i%4==0 ) y += ds[i];
           72  +    if( i%4==1 ) x += ds[i];
           73  +    if( i%4==2 ) y -= ds[i];
           74  +    if( i%4==3 ) x -= ds[i];
           75  +   }
           76  +
           77  +   LL loop_len = 4 * (loop_end - loop_beg);
           78  +   K -= loop_beg;
           79  +   LL dx=0, dy=0;
           80  +   for(LL i=0; i<loop_len; ++i) {
           81  +    if( (loop_beg+i)%4==0 ) dy += ds[loop_beg+i];
           82  +    if( (loop_beg+i)%4==1 ) dx += ds[loop_beg+i];
           83  +    if( (loop_beg+i)%4==2 ) dy -= ds[loop_beg+i];
           84  +    if( (loop_beg+i)%4==3 ) dx -= ds[loop_beg+i];
           85  +   }
           86  +   x += dx * (K / loop_len);
           87  +   y += dy * (K / loop_len);
           88  +
           89  +   K %= loop_len;
           90  +   for(LL i=0; i<K; ++i) {
           91  +    if( (loop_beg+i)%4==0 ) y += ds[loop_beg+i];
           92  +    if( (loop_beg+i)%4==1 ) x += ds[loop_beg+i];
           93  +    if( (loop_beg+i)%4==2 ) y -= ds[loop_beg+i];
           94  +    if( (loop_beg+i)%4==3 ) x -= ds[loop_beg+i];
           95  +   }
           96  +  }
           97  +
           98  +  stringstream sout;
           99  +  sout << x << " " << y;
          100  +  return sout.str();
          101  + }
          102  +
          103  +// BEGIN CUT HERE
          104  + public:
          105  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); }
          106  + private:
          107  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          108  + void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
          109  + void test_case_0() { int Arg0 = 5; int Arg1 = 2; string Arg2 = "-6 4"; verify_case(0, Arg2, location(Arg0, Arg1)); }
          110  + void test_case_1() { int Arg0 = 99; int Arg1 = 1; string Arg2 = "1 0"; verify_case(1, Arg2, location(Arg0, Arg1)); }
          111  + void test_case_2() { int Arg0 = 6; int Arg1 = 9; string Arg2 = "9 1"; verify_case(2, Arg2, location(Arg0, Arg1)); }
          112  +
          113  +// END CUT HERE
          114  +};
          115  +// BEGIN CUT HERE
          116  +int main() { LocateTreasure().run_test(-1); }
          117  +// END CUT HERE

Added SRM/427/1C.cpp version [c7e9f05169f65f76]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +static const LL MODVAL = 1234567891;
           19  +
           20  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           21  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           22  +LL FACT(LL x) { return x<=1 ? 1 : MUL(x, FACT(x-1)); }
           23  +
           24  +class PSequence
           25  +{
           26  +public:
           27  + map<pair<vector<LL>,int>, LL> memo;
           28  +
           29  + int count(vector <int> S, int p)
           30  + {
           31  +  memo.clear();
           32  +
           33  +  vector<LL> cs; // congruences mod p
           34  +
           35  +  bool used[30] = {};
           36  +  for(int i=0; i<S.size(); ++i)
           37  +   if( !used[i] )
           38  +   {
           39  +    int cnt = 0;
           40  +    for(int j=i; j<S.size(); ++j)
           41  +     if( abs(S[i]-S[j]) % p == 0 )
           42  +      {used[j]=true; ++cnt;}
           43  +    cs.push_back(cnt);
           44  +   }
           45  +
           46  +  LL f = num_perm( cs, -1, S.size() );
           47  +  for(int i=0; i<cs.size(); ++i)
           48  +   f = MUL(f, FACT(cs[i]));
           49  +  return f;
           50  + }
           51  +
           52  + LL num_perm( vector<LL>& cs, int forbidden, int n )
           53  + {
           54  +  if( n == 0 )
           55  +   return 1;
           56  +
           57  +  int v = (forbidden >= 0 ? cs[forbidden] : -1);
           58  +  pair<vector<LL>,int> key(cs, forbidden);
           59  +  sort(key.first.begin(), key.first.end());
           60  +  key.second = find(key.first.begin(), key.first.end(), v) - key.first.begin();
           61  +
           62  +  if( memo.count(key) )
           63  +   return memo[key];
           64  +
           65  +  LL np = 0;
           66  +  for(int i=0; i<cs.size(); ++i)
           67  +   if( cs[i] && i!=forbidden ) {
           68  +    cs[i]--;
           69  +    np = ADD(np, num_perm( cs, i, n-1 ));
           70  +    cs[i]++;
           71  +   }
           72  +  return memo[key] = np;
           73  + }
           74  +
           75  +// BEGIN CUT HERE
           76  + public:
           77  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
           78  + private:
           79  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           80  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           81  + void test_case_0() { int Arr0[] = {-1,0,1,2,3}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 10; int Arg2 = 120; verify_case(0, Arg2, count(Arg0, Arg1)); }
           82  + void test_case_1() { int Arr0[] = {6,2}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 4; int Arg2 = 0; verify_case(1, Arg2, count(Arg0, Arg1)); }
           83  + void test_case_2() { int Arr0[] = {1,2,3,4}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 3; int Arg2 = 12; verify_case(2, Arg2, count(Arg0, Arg1)); }
           84  + void test_case_3() { int Arr0[] = {4,6,8,-3,7}; vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); int Arg1 = 2; int Arg2 = 12; verify_case(3, Arg2, count(Arg0, Arg1)); }
           85  + void test_case_4() {
           86  + int Arr0[] = {0,1,2,3,4,5,6,7,8,9,
           87  +10,11,12,13,14,15,16,17,18,19,
           88  +20,21,22,23,24,25,26,27,28,29};
           89  +vector <int> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0])));
           90  + int Arg1 = 15; int Arg2 = 12; verify_case(4, Arg2, count(Arg0, Arg1)); }
           91  +
           92  +// END CUT HERE
           93  +};
           94  +// BEGIN CUT HERE
           95  +int main() { PSequence().run_test(-1); }
           96  +// END CUT HERE

Added SRM/428/1A.cpp version [08de86b9b3316798]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +class TheLuckyString
           19  +{
           20  +public:
           21  + int count(string s)
           22  + {
           23  +  int cnt = 0;
           24  +
           25  +  sort(s.begin(), s.end());
           26  +  do
           27  +   if( adjacent_find(s.begin(), s.end()) == s.end() )
           28  +    ++cnt;
           29  +  while( next_permutation(s.begin(), s.end()) );
           30  +
           31  +  return cnt;
           32  + }
           33  +
           34  +// BEGIN CUT HERE
           35  + public:
           36  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           37  + private:
           38  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           39  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           40  + void test_case_0() { string Arg0 = "ab"; int Arg1 = 2; verify_case(0, Arg1, count(Arg0)); }
           41  + void test_case_1() { string Arg0 = "aaab"; int Arg1 = 0; verify_case(1, Arg1, count(Arg0)); }
           42  + void test_case_2() { string Arg0 = "aabbbaa"; int Arg1 = 1; verify_case(2, Arg1, count(Arg0)); }
           43  + void test_case_3() { string Arg0 = "abcdefghij"; int Arg1 = 3628800; verify_case(3, Arg1, count(Arg0)); }
           44  +
           45  +// END CUT HERE
           46  +};
           47  +// BEGIN CUT HERE
           48  +int main() { TheLuckyString().run_test(-1); }
           49  +// END CUT HERE

Added SRM/428/1B.cpp version [e110c16d9a9bffd5]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +using namespace std;
           16  +typedef long long LL;
           17  +
           18  +static const LL MODVAL = 1234567891;
           19  +
           20  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           21  +LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
           22  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           23  +LL POW(LL x, LL e) {
           24  + LL v = 1;
           25  + for(;e;x=MUL(x,x),e>>=1)
           26  +  if(e&1)
           27  +   v = MUL(v, x);
           28  + return v;
           29  +}
           30  +LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
           31  +LL C(LL n, LL k) {
           32  + LL v = 1;
           33  + for(LL i=1; i<=k; ++i)
           34  +  v = DIV(MUL(v, n-i+1), i);
           35  + return v;
           36  +}
           37  +LL GSS(LL k, LL b, LL e) // k^b + k^b+1 + ... + k^e
           38  +{
           39  + if( b >  e ) return 0;
           40  + if( k <= 1 ) return k*(e-b+1);
           41  + return DIV(SUB(POW(k, e+1), POW(k,b)), k-1);
           42  +}
           43  +
           44  +class TheLongPalindrome
           45  +{
           46  +public:
           47  + int count(int n, int k)
           48  + {
           49  +  LL ans = 0;
           50  +  for(int i=1; i<=k; ++i)
           51  +  {
           52  +   LL aa = f(i,i,n);
           53  +   for(int j=i-1; j>=1; --j)
           54  +    aa = (i-j)%2
           55  +      ? SUB(aa, MUL(f(j,i,n), C(i,j)))
           56  +      : ADD(aa, MUL(f(j,i,n), C(i,j)));
           57  +   ans = ADD(ans, MUL(aa, C(26,i)));
           58  +  }
           59  +  return ans;
           60  + }
           61  +
           62  + LL f(LL i, LL b, LL n) // i^b + i^b + i^b+1 + i^b+1 + ... + (nth)
           63  + {
           64  +  LL v = MUL(GSS(i, b, n/2), 2);
           65  +  if( n%2 == 1 )
           66  +   v = ADD(v, POW(i, n/2+1));
           67  +  return v;
           68  + }
           69  +
           70  +// BEGIN CUT HERE
           71  + public:
           72  + void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
           73  + private:
           74  + template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           75  + void verify_case(int Case, const int &Expected, const int &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
           76  + void test_case_0() { int Arg0 = 1; int Arg1 = 1; int Arg2 = 26; verify_case(0, Arg2, count(Arg0, Arg1)); }
           77  + void test_case_1() { int Arg0 = 2; int Arg1 = 10; int Arg2 = 52; verify_case(1, Arg2, count(Arg0, Arg1)); }
           78  + void test_case_2() { int Arg0 = 3; int Arg1 = 2; int Arg2 = 728; verify_case(2, Arg2, count(Arg0, Arg1)); }
           79  + void test_case_3() { int Arg0 = 44; int Arg1 = 7; int Arg2 = 240249781; verify_case(3, Arg2, count(Arg0, Arg1)); }
           80  +
           81  +// END CUT HERE
           82  +};
           83  +// BEGIN CUT HERE
           84  +int main() { TheLongPalindrome().run_test(-1); }
           85  +// END CUT HERE

Added SRM/428/1C.cpp version [0bbb80b9b0468b3d]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cstring>
           16  +#include <cassert>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +char memo[81*81*81*81];
           21  +int  n, X[16];
           22  +static const char NIL = 99;
           23  +
           24  +bool win[243];
           25  +
           26  +class TheStringGame
           27  +{
           28  +public:
           29  + string winner(string s)
           30  + {
           31  +  // construct the winning condition table
           32  +  for(int mm=0; mm<243; ++mm)
           33  +   win[mm] = (mm/ 9%3==0 &&
           34  +     (  mm/81%3==2 && mm/27%3==1     // LOX
           35  +     || mm/27%3==2 && mm/ 3%3==2     //  LXL
           36  +     || mm/ 3%3==1 && mm/ 1%3==2 )); //   XOL
           37  +
           38  +  // read the input
           39  +  int m=0, numX=0;
           40  +  {
           41  +   memset(memo, NIL, sizeof(memo));
           42  +   n = s.size();
           43  +   for(int i=0; i<n; ++i) {
           44  +    m *= 3;
           45  +    for(int j=0; j<numX; ++j)
           46  +     X[j] *= 3;
           47  +
           48  +    if( s[i]=='X' )
           49  +     X[numX++] = 1;
           50  +    else
           51  +     m += (s[i]=='O' ? 1 : 2);
           52  +   }
           53  +  }
           54  +
           55  +  // solve
           56  +  if( int r = negaMax(m, numX) )
           57  +  {
           58  +   stringstream sout;
           59  +   sout << (r>0 ? "John" : "Brus") << " " << numX-abs(r)+1;
           60  +   return sout.str();
           61  +  }
           62  +  return "Draw";
           63  + }
           64  +
           65  + static int rev(int m)
           66  + {
           67  +  int z = 0;
           68  +  for(int i=0; i<n; ++i)
           69  +   z = z*3 + m%3, m/=3;
           70  +  return z;
           71  + }
           72  +
           73  + static char negaMax(int m, int numX)
           74  + {
           75  +  if( numX == 0 )
           76  +   return 0;
           77  +  if( memo[m] != NIL )
           78  +   return memo[m];
           79  +
           80  +  for(int j=0; j<numX; ++j)
           81  +   if( win[m*9/X[j]%243] )
           82  +    return memo[m] = numX;
           83  +
           84  +  int sc = -numX;
           85  +  for(int j=0; j<numX; ++j) {
           86  +   int M = X[j];
           87  +   swap(X[j], X[numX-1]);
           88  +   sc = max(sc, -negaMax(m+M*1, numX-1));
           89  +   sc = max(sc, -negaMax(m+M*2, numX-1));
           90  +   swap(X[j], X[numX-1]);
           91  +  }
           92  +  return memo[m] = memo[rev(m)] = sc;
           93  + }
           94  +};
           95  +
           96  +// BEGIN CUT HERE
           97  +#include <ctime>
           98  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           99  +
          100  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          101  +int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          102  +
          103  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          104  +char Test_(...);
          105  +int Test_(Case_<0>) {
          106  + string s = "XXOXXXLXLX";
          107  + string RetVal = "John 1";
          108  + return verify_case(RetVal, TheStringGame().winner(s)); }
          109  +int Test_(Case_<1>) {
          110  + string s = "LXXLXXL";
          111  + string RetVal = "Brus 2";
          112  + return verify_case(RetVal, TheStringGame().winner(s)); }
          113  +int Test_(Case_<2>) {
          114  + string s = "LLOOLLOOLLOOLLOO";
          115  + string RetVal = "Draw";
          116  + return verify_case(RetVal, TheStringGame().winner(s)); }
          117  +int Test_(Case_<3>) {
          118  + string s = "XXXXXXXXXXXXXXXX";
          119  + string RetVal = "Brus 16";
          120  + return verify_case(RetVal, TheStringGame().winner(s)); }
          121  +int Test_(Case_<4>) {
          122  + string s = "XXXXXXXXXXXXXXXO";
          123  + string RetVal = "John 15";
          124  + return verify_case(RetVal, TheStringGame().winner(s)); }
          125  +
          126  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          127  +template<>      void Run_<-1>() {}
          128  +int main() { Run_<0>(); }
          129  +// END CUT HERE

Added SRM/429/1A.cpp version [0c272f575c59737f]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class SubrectanglesOfTable
           20  +{
           21  +public:
           22  + vector<long long> getQuantity(vector <string> table)
           23  + {
           24  +  for(int i=0,n=table.size(); i<n; ++i)
           25  +   table.push_back( table[i]+=table[i] );
           26  +
           27  +  vector<LL> ans(26);
           28  +
           29  +  LL Y = table.size(), X = table[0].size();
           30  +  for(LL y=0; y<Y; ++y)
           31  +   for(LL x=0; x<X; ++x)
           32  +    ans[table[y][x]-'A'] += (y+1)*(x+1)*(Y-y)*(X-x);
           33  +  return ans;
           34  + }
           35  +};
           36  +
           37  +// BEGIN CUT HERE
           38  +#include <ctime>
           39  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           40  +
           41  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           42  +int verify_case(const vector<long long> &Expected, const vector<long long> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           43  +
           44  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           45  +char Test_(...);
           46  +int Test_(Case_<0>) {
           47  + string table_[] = {"OK"};
           48  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
           49  + long RetVal_[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
           50  +   vector<long long> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           51  + return verify_case(RetVal, SubrectanglesOfTable().getQuantity(table)); }
           52  +int Test_(Case_<1>) {
           53  + string table_[] = {"GOOD", "LUCK"};
           54  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
           55  + long RetVal_[] = {0, 0, 320, 280, 0, 0, 280, 0, 0, 0, 280, 280, 0, 0, 640, 0, 0, 0, 0, 0, 320, 0, 0, 0, 0, 0 };
           56  +   vector<long long> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           57  + return verify_case(RetVal, SubrectanglesOfTable().getQuantity(table)); }
           58  +int Test_(Case_<2>) {
           59  + string table_[] = {"TANYA",
           60  + "HAPPY",
           61  + "BIRTH",
           62  + "DAYYY"};
           63  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
           64  + long RetVal_[] = {5168, 1280, 0, 1120, 0, 0, 0, 2560, 1472, 0, 0, 0, 0, 1344, 0, 3008, 0, 1536, 0, 2592, 0, 0, 0, 0, 6320, 0 };
           65  +   vector<long long> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           66  + return verify_case(RetVal, SubrectanglesOfTable().getQuantity(table)); }
           67  +
           68  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           69  +template<>      void Run_<-1>() {}
           70  +int main() { Run_<0>(); }
           71  +// END CUT HERE
           72  +

Added SRM/429/1B.cpp version [61896c32b2eaf928]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +LL gcd(LL a, LL b)
           20  +{
           21  + while(a) swap(a, b%=a); return b;
           22  +}
           23  +LL lcm(LL a, LL b)
           24  +{
           25  + return a/gcd(a,b)*b;
           26  +}
           27  +
           28  +class IngredientProportions
           29  +{
           30  +public:
           31  + vector <int> getMasses(vector <string> proportions)
           32  + {
           33  +  int N = proportions.size() + 1;
           34  +  vector<LL> a(N-1),b(N-1),p(N-1),q(N-1);
           35  +
           36  +  for(int i=0; i<proportions.size(); ++i)
           37  +  {
           38  +   stringstream sin(proportions[i]);
           39  +   sin.get();//#
           40  +   sin>>a[i];
           41  +   sin.get();sin.get();sin.get();sin.get();sin.get();sin.get();//" and #"
           42  +   sin>>b[i];
           43  +   sin.get();sin.get();sin.get();sin.get();//" as "
           44  +   sin>>p[i];
           45  +   sin.get(); //:
           46  +   sin>>q[i];
           47  +  }
           48  +
           49  +  vector<LL> g(N, -1); g[0]=1;
           50  +  for(int _=0; _<N; ++_)
           51  +   for(int i=0; i<N-1; ++i)
           52  +   {
           53  +    LL A=a[i],B=b[i],P=p[i],Q=q[i];
           54  +    if( g[A]==-1 && g[B]!=-1 )
           55  +     swap(A,B), swap(P,Q);
           56  +    if( g[A]!=-1 && g[B]==-1 )
           57  +    {
           58  +     LL f = lcm(g[A],P) / g[A];
           59  +     for(int j=0; j<N; ++j)
           60  +      if( g[j] != -1 )
           61  +       g[j] *= f;
           62  +     g[B] = g[A]/P*Q;
           63  +    }
           64  +   }
           65  +  LL gg = accumulate( g.begin(), g.end(), g.back(), gcd );
           66  +  vector<int> ans(N);
           67  +  for(int i=0; i<N; ++i)
           68  +   ans[i] = g[i]/gg;
           69  +  return ans;
           70  + }
           71  +};
           72  +
           73  +// BEGIN CUT HERE
           74  +#include <ctime>
           75  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           76  +
           77  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           78  +int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           79  +
           80  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           81  +char Test_(...);
           82  +int Test_(Case_<0>) {
           83  + string proportions_[] = {"#0 and #1 as 6:4"};
           84  +   vector <string> proportions(proportions_, proportions_+sizeof(proportions_)/sizeof(*proportions_));
           85  + int RetVal_[] = {3, 2 };
           86  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           87  + return verify_case(RetVal, IngredientProportions().getMasses(proportions)); }
           88  +int Test_(Case_<1>) {
           89  + string proportions_[] = {"#0 and #1 as 9:8","#1 and #2 as 9:8"}
           90  +;
           91  +   vector <string> proportions(proportions_, proportions_+sizeof(proportions_)/sizeof(*proportions_));
           92  + int RetVal_[] = {81, 72, 64 };
           93  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           94  + return verify_case(RetVal, IngredientProportions().getMasses(proportions)); }
           95  +int Test_(Case_<2>) {
           96  + string proportions_[] = {"#4 and #0 as 1:1", "#4 and #1 as 3:1", "#4 and #2 as 5:1", "#4 and #3 as 7:1"};
           97  +   vector <string> proportions(proportions_, proportions_+sizeof(proportions_)/sizeof(*proportions_));
           98  + int RetVal_[] = {105, 35, 21, 15, 105 };
           99  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          100  + return verify_case(RetVal, IngredientProportions().getMasses(proportions)); }
          101  +int Test_(Case_<3>) {
          102  + string proportions_[] = {"#2 and #3 as 6:8", "#0 and #1 as 9:3", "#3 and #0 as 7:5"};
          103  +   vector <string> proportions(proportions_, proportions_+sizeof(proportions_)/sizeof(*proportions_));
          104  + int RetVal_[] = {60, 20, 63, 84 };
          105  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          106  + return verify_case(RetVal, IngredientProportions().getMasses(proportions)); }
          107  +
          108  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          109  +template<>      void Run_<-1>() {}
          110  +int main() { Run_<0>(); }
          111  +// END CUT HERE
          112  +

Added SRM/429/1C.cpp version [0b43e0ef88516e58]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class SpecificPolyominoCovering
           20  +{
           21  +public:
           22  + vector <string> findCovering(vector <string> region)
           23  + {
           24  +  try {
           25  +   rec(0, 0, region);
           26  +  } catch( vector<string>& r ) {
           27  +   return r;
           28  +  }
           29  +  return vector<string>();
           30  + }
           31  +
           32  + bool nextX(int &y, int &x, vector<string>& r)
           33  + {
           34  +  while( r[y][x] != 'X' ) {
           35  +   ++x;
           36  +   if( x == r[y].size() ) {
           37  +    x=0, ++y;
           38  +    if( y == r.size() )
           39  +     return false;
           40  +   }
           41  +  }
           42  +  return true;
           43  + }
           44  +
           45  + bool canFill( vector<string> r )
           46  + {
           47  +  return canFill_rec(0, 0, r);
           48  + }
           49  +
           50  + bool canFill_rec(int y, int x, vector<string>& r)
           51  + {
           52  +  if( !nextX(y, x, r) )
           53  +   return true;
           54  +
           55  +  // if it was the pattern fillable both by B and A,
           56  +  //     XX?X
           57  +  //     XXXX
           58  +  // then, if we can fill starting from A it implies ?=X
           59  +  // In this case, we must have been able to fill starting
           60  +  // from B. Thus, we never need to try A if we've failed
           61  +  // filling by B. The "lexicographically first" will by
           62  +  // considered elsewhere.
           63  +
           64  +  if( x+1 < r[y].size() && r[y][x+1]=='X' )
           65  +  {
           66  +   r[y][x] = r[y][x+1] = 'B';
           67  +   return canFill_rec(y, x, r);
           68  +  }
           69  +
           70  +  if( x+3 < r[y].size() && y+1 < r.size() )
           71  +  {
           72  +   int py[] = {0,0,1,1,1,1};
           73  +   int px[] = {0,3,0,1,2,3};
           74  +   for(int i=0; i<6; ++i)
           75  +    if( r[y+py[i]][x+px[i]]!='X' )
           76  +     return false;
           77  +    else
           78  +     r[y+py[i]][x+px[i]] = 'A';
           79  +   return canFill_rec(y, x, r);
           80  +  }
           81  +
           82  +  return false;
           83  + }
           84  +
           85  + void rec(int y, int x, vector<string>& r)
           86  + {
           87  +  if( !nextX(y, x, r) )
           88  +   throw r;
           89  +
           90  +  // try to fill by A
           91  +  if( x+3 < r[y].size() && y+1 < r.size() )
           92  +  {
           93  +   int py[] = {0,0,1,1,1,1};
           94  +   int px[] = {0,3,0,1,2,3};
           95  +   bool bad = false;
           96  +   for(int i=0; i<6; ++i)
           97  +    if( r[y+py[i]][x+px[i]]!='X' )
           98  +     bad = true;
           99  +   if( !bad )
          100  +   {
          101  +    for(int i=0; i<6; ++i)
          102  +     r[y+py[i]][x+px[i]] = 'A';
          103  +    if( canFill(r) )
          104  +     rec(y, x, r);
          105  +    for(int i=0; i<6; ++i)
          106  +     r[y+py[i]][x+px[i]] = 'X';
          107  +   }
          108  +  }
          109  +  // try to fill by B
          110  +  if( x+1 < r[y].size() && r[y][x+1]=='X' )
          111  +  {
          112  +   r[y][x] = r[y][x+1] = 'B';
          113  +   rec(y, x, r);
          114  +   r[y][x] = r[y][x+1] = 'X';
          115  +  }
          116  + }
          117  +};
          118  +
          119  +// BEGIN CUT HERE
          120  +#include <ctime>
          121  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          122  +
          123  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          124  +int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
          125  +
          126  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          127  +char Test_(...);
          128  +int Test_(Case_<0>) {
          129  + string region_[] = {"XXXX",
          130  + "XXXX"};
          131  +   vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_));
          132  + string RetVal_[] = {"ABBA", "AAAA" };
          133  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          134  + return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
          135  +int Test_(Case_<1>) {
          136  + string region_[] = {"X..XXXX..X",
          137  + "XXXX..XXXX"};
          138  +   vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_));
          139  + string RetVal_[] = {"A..ABBA..A", "AAAA..AAAA" };
          140  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          141  + return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
          142  +int Test_(Case_<2>) {
          143  + string region_[] = {"XXXXXX",
          144  + "XXXXXX",
          145  + "XXXXXX"};
          146  +   vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_));
          147  + string RetVal_[] = {"ABBABB", "AAAABB", "BBBBBB" };
          148  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          149  + return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
          150  +int Test_(Case_<3>) {
          151  + string region_[] = {"X..XX",
          152  + "XXXXX"};
          153  +   vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_));
          154  + vector <string> RetVal;
          155  + return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
          156  +int Test_(Case_<4>) {
          157  + string region_[] = {"XXXXXXXXXX",
          158  + "XXXXXXXXXX",
          159  + "XXXXXXXXXX",
          160  + "XXXXX..XXX",
          161  + "XXXXXXXXXX",
          162  + "XXXXXXXXXX",
          163  + "XXXXXXXXXX"};
          164  +   vector <string> region(region_, region_+sizeof(region_)/sizeof(*region_));
          165  + string RetVal_[] = {"ABBAABBABB", "AAAAAAAABB", "ABBABBBBBB", "AAAAA..ABB", "ABBAAAAABB", "AAAAABBABB", "BBBBAAAABB" };
          166  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          167  + return verify_case(RetVal, SpecificPolyominoCovering().findCovering(region)); }
          168  +
          169  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          170  +template<>      void Run_<-1>() {}
          171  +int main() { Run_<0>(); }
          172  +// END CUT HERE
          173  +

Added SRM/430/1A.cpp version [2990a35eb58be62a]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class BitwiseEquations
           20  +{
           21  +public:
           22  + long long kthPlusOrSolution(int x, int k)
           23  + {
           24  +  LL y = 0;
           25  +  for(LL i=1; k; i<<=1)
           26  +   if( !(x&i) )
           27  +    y |= (k&1)*i, k>>=1;
           28  +  return y;
           29  + }
           30  +};
           31  +
           32  +// BEGIN CUT HERE
           33  +#include <ctime>
           34  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           35  +
           36  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           37  +int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           38  +
           39  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           40  +char Test_(...);
           41  +int Test_(Case_<0>) {
           42  + int x = 5;
           43  + int k = 1;
           44  + long long RetVal = 2LL;
           45  + return verify_case(RetVal, BitwiseEquations().kthPlusOrSolution(x, k)); }
           46  +int Test_(Case_<1>) {
           47  + int x = 5;
           48  + int k = 5;
           49  + long long RetVal = 18LL;
           50  + return verify_case(RetVal, BitwiseEquations().kthPlusOrSolution(x, k)); }
           51  +int Test_(Case_<2>) {
           52  + int x = 10;
           53  + int k = 3;
           54  + long long RetVal = 5LL;
           55  + return verify_case(RetVal, BitwiseEquations().kthPlusOrSolution(x, k)); }
           56  +int Test_(Case_<3>) {
           57  + int x = 1;
           58  + int k = 1000000000;
           59  + long long RetVal = 2000000000LL;
           60  + return verify_case(RetVal, BitwiseEquations().kthPlusOrSolution(x, k)); }
           61  +
           62  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           63  +template<>      void Run_<-1>() {}
           64  +int main() { Run_<0>(); }
           65  +// END CUT HERE
           66  +

Added SRM/430/1B.cpp version [d61bab3b8e785a85]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +int INF = 10000000;
           20  +
           21  +class TwinTowns
           22  +{
           23  +public:
           24  + vector <int> optimalTwinTowns(vector <int> x, vector <int> y, int maxPartners, int minDistance)
           25  + {
           26  +  int N = x.size();
           27  +  int cost[10][10];
           28  +  for(int i=0; i<N; ++i)
           29  +  for(int j=0; j<N; ++j)
           30  +  {
           31  +   int d = abs(x[i]-x[j]) + abs(y[i]-y[j]);
           32  +   cost[i][j] = (d < minDistance ? INF : d);
           33  +  }
           34  +
           35  +  vector<int> v(N, maxPartners);
           36  +  pair<int,int> r = rec(0, N, v, cost);
           37  +  vector<int> ans(2);
           38  +  ans[0] = -r.first;
           39  +  ans[1] = r.second;
           40  +  return ans;
           41  + }
           42  +
           43  + map< vector<int>,pair<int,int> > memo;
           44  + pair<int,int> rec(int i, int N, vector<int>& v, int cost[10][10])
           45  + {
           46  +  if( i==N )
           47  +   return make_pair(0, 0);
           48  +  vector<int> key(v.begin()+i, v.end());
           49  +  if( memo.count(key) )
           50  +   return memo[key];
           51  +
           52  +  // choose at most v[i] js s.t. cost[i][j]!=INF && v[j]!=0
           53  +  pair<int,int> best = rec(i+1, N, v, cost);
           54  +  if( v[i] >= 1 )
           55  +  {
           56  +   for(int j1= i+1; j1<N; ++j1) if(cost[i][j1]!=INF && v[j1])
           57  +   {
           58  +    v[j1]--;
           59  +    pair<int,int> a = rec(i+1, N, v, cost);
           60  +    a.first  -= 1;
           61  +    a.second += cost[i][j1];
           62  +    best = min(best, a);
           63  +    v[j1]++;
           64  +   }
           65  +  }
           66  +  if( v[i] >= 2 )
           67  +  {
           68  +   for(int j1= i+1; j1<N; ++j1) if(cost[i][j1]!=INF && v[j1])
           69  +   for(int j2=j1+1; j2<N; ++j2) if(cost[i][j2]!=INF && v[j2])
           70  +   {
           71  +    v[j1]--;
           72  +    v[j2]--;
           73  +    pair<int,int> a = rec(i+1, N, v, cost);
           74  +    a.first  -= 2;
           75  +    a.second += cost[i][j1] + cost[i][j2];
           76  +    best = min(best, a);
           77  +    v[j1]++;
           78  +    v[j2]++;
           79  +   }
           80  +  }
           81  +  if( v[i] >= 3 )
           82  +  {
           83  +   for(int j1= i+1; j1<N; ++j1) if(cost[i][j1]!=INF && v[j1])
           84  +   for(int j2=j1+1; j2<N; ++j2) if(cost[i][j2]!=INF && v[j2])
           85  +   for(int j3=j2+1; j3<N; ++j3) if(cost[i][j3]!=INF && v[j3])
           86  +   {
           87  +    v[j1]--;
           88  +    v[j2]--;
           89  +    v[j3]--;
           90  +    pair<int,int> a = rec(i+1, N, v, cost);
           91  +    a.first  -= 3;
           92  +    a.second += cost[i][j1] + cost[i][j2] + cost[i][j3];
           93  +    best = min(best, a);
           94  +    v[j1]++;
           95  +    v[j2]++;
           96  +    v[j3]++;
           97  +   }
           98  +  }
           99  +
          100  +  return memo[key] = best;
          101  + }
          102  +};
          103  +
          104  +// BEGIN CUT HERE
          105  +#include <ctime>
          106  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          107  +
          108  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          109  +int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
          110  +
          111  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          112  +char Test_(...);
          113  +int Test_(Case_<0>) {
          114  + int x_[] = {0,0,10};
          115  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          116  + int y_[] = {0,10,4};
          117  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          118  + int maxPartners = 1;
          119  + int minDistance = 1;
          120  + int RetVal_[] = {1, 10 };
          121  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          122  + return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
          123  +int Test_(Case_<1>) {
          124  + int x_[] = {0,0,10};
          125  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          126  + int y_[] = {0,10,4};
          127  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          128  + int maxPartners = 1;
          129  + int minDistance = 11;
          130  + int RetVal_[] = {1, 14 };
          131  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          132  + return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
          133  +int Test_(Case_<2>) {
          134  + int x_[] = {0,10,0,10};
          135  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          136  + int y_[] = {0,0,20,20};
          137  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          138  + int maxPartners = 1;
          139  + int minDistance = 1;
          140  + int RetVal_[] = {2, 20 };
          141  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          142  + return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
          143  +int Test_(Case_<3>) {
          144  + int x_[] = {0,10,0,10};
          145  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          146  + int y_[] = {0,0,20,20};
          147  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          148  + int maxPartners = 2;
          149  + int minDistance = 10;
          150  + int RetVal_[] = {4, 60 };
          151  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          152  + return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
          153  +int Test_(Case_<4>) {
          154  + int x_[] = {0,0,0,0,0,0,0,0,0};
          155  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          156  + int y_[] = {1,2,3,4,5,6,7,8,9};
          157  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          158  + int maxPartners = 3;
          159  + int minDistance = 6;
          160  + int RetVal_[] = {6, 40 };
          161  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          162  + return verify_case(RetVal, TwinTowns().optimalTwinTowns(x, y, maxPartners, minDistance)); }
          163  +
          164  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          165  +template<>      void Run_<-1>() {}
          166  +int main() { Run_<0>(); }
          167  +// END CUT HERE
          168  +

Added SRM/430/1C.cpp version [0d8ab1eb2aa0ceeb]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <functional>
           16  +#include <cassert>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +typedef LL BITS;
           20  +
           21  +class PickingUp
           22  +{
           23  +public:
           24  + vector<int> fairPickingUp(vector<long long> score1, vector<long long> score2)
           25  + {
           26  +  LL t = accumulate(score2.begin(), score2.end(), 0LL);
           27  +  vector<LL> s;
           28  +  transform(score1.begin(), score1.end(), score2.begin(), back_inserter(s), plus<LL>());
           29  +
           30  +  int N = s.size() / 2;
           31  +
           32  +  vector< map<LL,BITS> > L = try_all( s.begin(), N );
           33  +  vector< map<LL,BITS> > R = try_all( s.begin()+N, N );
           34  +
           35  +  pair<LL, BITS> best(0x7fffffffffffffffLL, 0);
           36  +  for(int i=0; i<=N; ++i)
           37  +   best = min(best, best_possible( L[i], R[N-i], t, N ));
           38  +
           39  +  vector<int> ans;
           40  +  for(int i=0; i!=s.size(); ++i)
           41  +   ans.push_back( (-best.second & (1LL<<s.size()-1-i)) ? 1 : 2 );
           42  +  return ans;
           43  + }
           44  +
           45  + pair<LL, BITS> best_possible( map<LL,BITS>& L, map<LL,BITS>& R, LL t, int N )
           46  + {
           47  +  typedef map<LL,BITS>::iterator mit;
           48  +
           49  +  pair<LL, BITS> best(0x7fffffffffffffffLL, 0);
           50  +  for(mit i=L.begin(); i!=L.end(); ++i)
           51  +  {
           52  +   LL as = i->first;
           53  +   LL am = i->second;
           54  +   mit j = R.lower_bound(t-as);
           55  +   if( j!=R.end() ) {
           56  +    LL bs = j->first;
           57  +    LL bm = j->second;
           58  +    best = min(best, make_pair(abs(as+bs-t), -((am<<N)|bm)));
           59  +   }
           60  +   if( j!=R.begin() ) {
           61  +    --j;
           62  +    LL bs = j->first;
           63  +    LL bm = j->second;
           64  +    best = min(best, make_pair(abs(as+bs-t), -((am<<N)|bm)));
           65  +   }
           66  +  }
           67  +
           68  +  return best;
           69  + }
           70  +
           71  + template<typename Ite>
           72  + vector< map<LL,BITS> > try_all( Ite s, int N )
           73  + {
           74  +  vector< map<LL,BITS> > a(N+1);
           75  +  for(BITS m=(1<<N)-1; m>=0; --m)
           76  +  {
           77  +   int nb = 0;
           78  +   LL  sm = 0;
           79  +   for(int i=0; i<N; ++i)
           80  +    if( m & (1LL<<N-1-i) )
           81  +     ++nb, sm+=*(s+i);
           82  +   if( !a[nb].count(sm) )
           83  +    a[nb][sm] = m;
           84  +  }
           85  +  return a;
           86  + }
           87  +};
           88  +
           89  +// BEGIN CUT HERE
           90  +#include <ctime>
           91  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           92  +
           93  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           94  +int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           95  +
           96  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           97  +char Test_(...);
           98  +int Test_(Case_<0>) {
           99  + long score1_[] = {5,9};
          100  +   vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_));
          101  + long score2_[] = {8,6};
          102  +   vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_));
          103  + int RetVal_[] = {1, 2 };
          104  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          105  + return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
          106  +int Test_(Case_<1>) {
          107  + long score1_[] = {2,3,4,7};
          108  +   vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_));
          109  + long score2_[] = {2,4,5,8};
          110  +   vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_));
          111  + int RetVal_[] = {1, 2, 2, 1 };
          112  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          113  + return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
          114  +int Test_(Case_<2>) {
          115  + long score1_[] = {1,5,6,8};
          116  +   vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_));
          117  + long score2_[] = {7,5,3,1};
          118  +   vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_));
          119  + int RetVal_[] = {1, 2, 1, 2 };
          120  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          121  + return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
          122  +int Test_(Case_<3>) {
          123  + long score1_[] = {300,300,300,300};
          124  +   vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_));
          125  + long score2_[] = {600,10,10,10};
          126  +   vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_));
          127  + int RetVal_[] = {2, 1, 1, 2 };
          128  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          129  + return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
          130  +int Test_(Case_<4>) {
          131  + long score1_[] = {50,50,50,1};
          132  +   vector<long long> score1(score1_, score1_+sizeof(score1_)/sizeof(*score1_));
          133  + long score2_[] = {30,30,30,150};
          134  +   vector<long long> score2(score2_, score2_+sizeof(score2_)/sizeof(*score2_));
          135  + int RetVal_[] = {1, 2, 2, 1 };
          136  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          137  + return verify_case(RetVal, PickingUp().fairPickingUp(score1, score2)); }
          138  +
          139  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          140  +template<>      void Run_<-1>() {}
          141  +int main() { Run_<0>(); }
          142  +// END CUT HERE
          143  +

Added SRM/431/1A.cpp version [b3187b46cfd5d3bb]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +using namespace std;
           17  +typedef long long LL;
           18  +
           19  +class LaserShooting
           20  +{
           21  +public:
           22  + double numberOfHits(vector <int> x, vector <int> y1, vector <int> y2)
           23  + {
           24  +  double ans = 0.0;
           25  +  for(int i=0; i<x.size(); ++i)
           26  +  {
           27  +   double a1 = atan2(min(y1[i],y2[i]), x[i]);
           28  +   double a2 = atan2(max(y1[i],y2[i]), x[i]);
           29  +   ans += (a2-a1) / M_PI;
           30  +  }
           31  +  return ans;
           32  + }
           33  +};
           34  +
           35  +// BEGIN CUT HERE
           36  +#include <ctime>
           37  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           38  +
           39  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           40  +int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           41  +
           42  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           43  +char Test_(...);
           44  +int Test_(Case_<0>) {
           45  + int x_[] = {1};
           46  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           47  + int y1_[] = {-1};
           48  +   vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_));
           49  + int y2_[] = {1};
           50  +   vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_));
           51  + double RetVal = 0.5;
           52  + return verify_case(RetVal, LaserShooting().numberOfHits(x, y1, y2)); }
           53  +int Test_(Case_<1>) {
           54  + int x_[] = {1,2};
           55  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           56  + int y1_[] = {-1,-2};
           57  +   vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_));
           58  + int y2_[] = {1,2};
           59  +   vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_));
           60  + double RetVal = 1.0;
           61  + return verify_case(RetVal, LaserShooting().numberOfHits(x, y1, y2)); }
           62  +int Test_(Case_<2>) {
           63  + int x_[] = {3,4,7,1};
           64  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           65  + int y1_[] = {1,2,3,4};
           66  +   vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_));
           67  + int y2_[] = {4,3,2,1};
           68  +   vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_));
           69  + double RetVal = 0.4623163952488826;
           70  + return verify_case(RetVal, LaserShooting().numberOfHits(x, y1, y2)); }
           71  +int Test_(Case_<3>) {
           72  + int x_[] = {134,298,151,942};
           73  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           74  + int y1_[] = {-753,-76,19,568};
           75  +   vector <int> y1(y1_, y1_+sizeof(y1_)/sizeof(*y1_));
           76  + int y2_[] = {440,689,-39,672};
           77  +   vector <int> y2(y2_, y2_+sizeof(y2_)/sizeof(*y2_));
           78  + double RetVal = 1.444210260641501;
           79  + return verify_case(RetVal, LaserShooting().numberOfHits(x, y1, y2)); }
           80  +
           81  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           82  +template<>      void Run_<-1>() {}
           83  +int main() { Run_<0>(); }
           84  +// END CUT HERE
           85  +

Added SRM/431/1B.cpp version [b5f1e84102a9aa7f]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +static const LL MODVAL = 1000000007;
           21  +int memo[10][11][1001][9];
           22  +
           23  +class MegaCoolNumbers
           24  +{
           25  +public:
           26  + int count(int N, int A)
           27  + {
           28  +  memset(memo, -1, sizeof(memo));
           29  +  return rec(1, 10, N, A);
           30  + }
           31  +
           32  + int rec(int D, int F, int N, int A)
           33  + {
           34  +  if( A==0 )     return N==0 ? 1 : 0;
           35  +  if( N < A )    return 0;
           36  +  if( N==1 )     return 10-D - (F==10 ? 0 : 1);
           37  +  if( 10-D < A ) return 0;
           38  +  if( memo[D][F][N][A] != -1 )
           39  +   return memo[D][F][N][A];
           40  +
           41  +  LL ans = 0;
           42  +  for(int d=D; d<=9; ++d) if(d!=F)
           43  +   for(int k=2; k<=N; ++k)
           44  +    for(int q=0; d+(k-1)*q<=9; ++q)
           45  +     ans += rec(d+(k-1)*q, min(10, d+k*q), N-k, A-1);
           46  +  return memo[D][F][N][A] = int(ans % MODVAL);
           47  + }
           48  +};
           49  +
           50  +// BEGIN CUT HERE
           51  +#include <ctime>
           52  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           53  +
           54  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           55  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           56  +
           57  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           58  +char Test_(...);
           59  +int Test_(Case_<0>) {
           60  + int N = 1;
           61  + int A = 1;
           62  + int RetVal = 9;
           63  + return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
           64  +int Test_(Case_<1>) {
           65  + int N = 2;
           66  + int A = 1;
           67  + int RetVal = 45;
           68  + return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
           69  +int Test_(Case_<2>) {
           70  + int N = 2;
           71  + int A = 2;
           72  + int RetVal = 0;
           73  + return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
           74  +int Test_(Case_<3>) {
           75  + int N = 10;
           76  + int A = 3;
           77  + int RetVal = 7502;
           78  + return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
           79  +int Test_(Case_<4>) {
           80  + int N = 1000;
           81  + int A = 5;
           82  + int RetVal = 7502;
           83  + return verify_case(RetVal, MegaCoolNumbers().count(N, A)); }
           84  +
           85  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           86  +template<>      void Run_<-1>() {}
           87  +int main() { Run_<0>(); }
           88  +// END CUT HERE
           89  +

Added SRM/431/1C.cpp version [c220b48258d1e633]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +#include <cstdlib>
           18  +using namespace std;
           19  +typedef long long LL;
           20  +
           21  +template<typename T>
           22  +struct RMQ
           23  +{
           24  + vector< vector<int> > rm;
           25  + T*  d;
           26  + int n;
           27  +
           28  + RMQ( T* d, int n ) : d(d), n(n) {
           29  +  rm.push_back( vector<int>(n) );
           30  +  for(int x=0; x<n; ++x)
           31  +   rm[0][x] = x;
           32  +  for(int k=1; (1<<k)<=n; ++k) {
           33  +   rm.push_back( rm[k-1] );
           34  +   for(int x=0; x+(1<<k-1)<n; ++x)
           35  +    if( d[rm[k][x]] > d[rm[k-1][x + (1<<k-1)]] )
           36  +     rm[k][x] = rm[k-1][x + (1<<k-1)];
           37  +  }
           38  + }
           39  +
           40  + int operator()(int L, int R) const {
           41  +  int k=0;
           42  +  for(; L+(1<<k) < R-(1<<k)+1; ++k) {}
           43  +  LL i = rm[k][L];
           44  +  LL j = rm[k][R-(1<<k)+1];
           45  +  return (d[i]<=d[j] ? i : j);
           46  + }
           47  +
           48  + vector<int> all(int L, int R) const {
           49  +  vector<int> ans;
           50  +  int minValue = d[(*this)(L, R)];
           51  +  while( L <= R ) {
           52  +   int C = (*this)(L, R);
           53  +   if( minValue < d[C] )
           54  +    break;
           55  +   ans.push_back(C);
           56  +   L = C+1;
           57  +  }
           58  +  return ans;
           59  + }
           60  +};
           61  +
           62  +int B[2048][2048];
           63  +int U[2048][2048];
           64  +int D[2048][2048];
           65  +
           66  +class PerfectRectangles
           67  +{
           68  +public:
           69  + int numberOfRectangles(int N, int M, int X0, int A, int _B, int Y0, int C, int _D)
           70  + {
           71  +  // input
           72  +  int x=X0%N, y=Y0%N;
           73  +  memset(B, 0, sizeof(B));
           74  +  for(int i=0; i<M; ++i) {
           75  +   B[x][y] = 1;
           76  +   x = (x*A+_B)%N;
           77  +   y = (y*C+_D)%N;
           78  +  }
           79  +
           80  +  // up
           81  +  for(int y=0; y<N; ++y)
           82  +   for(int x=0; x<N; ++x)
           83  +    U[y][x] = (B[y][x] ? 0 : y==0 ? 1 : U[y-1][x]+1);
           84  +
           85  +  // down
           86  +  for(int y=N-1; y>=0; --y)
           87  +   for(int x=0; x<N; ++x)
           88  +    D[y][x] = (B[y][x] ? 0 : y==N-1 ? 1 : D[y+1][x]+1);
           89  +
           90  +  // solve
           91  +  int cnt = 0;
           92  +  for(int y=0; y<N; ++y) {
           93  +   RMQ<int> rmU(U[y], N);
           94  +   RMQ<int> rmD(D[y], N);
           95  +
           96  +   stack< pair<int,int> > S;
           97  +   S.push( make_pair(0, N-1) );
           98  +   while( !S.empty() ) {
           99  +    int L = S.top().first;
          100  +    int R = S.top().second;
          101  +    S.pop();
          102  +
          103  +    int d = rmD(L,R);
          104  +    if( D[y][d] == 1 )
          105  +     ++cnt;
          106  +    if( D[y][d] <= 1 ) {
          107  +     vector<int> m = rmU.all(L, R);
          108  +     m.push_back(R+1);
          109  +     for(int i=0; i<m.size(); L=m[i++]+1)
          110  +      if( L <= m[i]-1 )
          111  +       S.push( make_pair(L, m[i]-1) );
          112  +    }
          113  +   }
          114  +  }
          115  +  return cnt;
          116  + }
          117  +};
          118  +
          119  +// BEGIN CUT HERE
          120  +#include <ctime>
          121  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          122  +
          123  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          124  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          125  +
          126  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          127  +char Test_(...);
          128  +int Test_(Case_<0>) {
          129  + int N = 5;
          130  + int M = 1;
          131  + int X0 = 2;
          132  + int A = 0;
          133  + int B = 0;
          134  + int Y0 = 2;
          135  + int C = 0;
          136  + int D = 0;
          137  + int RetVal = 4;
          138  + return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
          139  +int Test_(Case_<1>) {
          140  + int N = 4;
          141  + int M = 4;
          142  + int X0 = 0;
          143  + int A = 1;
          144  + int B = 1;
          145  + int Y0 = 0;
          146  + int C = 1;
          147  + int D = 1;
          148  + int RetVal = 6;
          149  + return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
          150  +int Test_(Case_<2>) {
          151  + int N = 1;
          152  + int M = 1000000;
          153  + int X0 = 1;
          154  + int A = 2;
          155  + int B = 3;
          156  + int Y0 = 1;
          157  + int C = 4;
          158  + int D = 7;
          159  + int RetVal = 0;
          160  + return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
          161  +int Test_(Case_<3>) {
          162  + int N = 10;
          163  + int M = 20;
          164  + int X0 = 4;
          165  + int A = 76;
          166  + int B = 2;
          167  + int Y0 = 6;
          168  + int C = 2;
          169  + int D = 43;
          170  + int RetVal = 12;
          171  + return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
          172  +int Test_(Case_<4>) {
          173  + int N = 1999;
          174  + int M = 4000000;
          175  + int X0 = 1000;
          176  + int A = 1;
          177  + int B = 1;
          178  + int Y0 = 0;
          179  + int C = 1;
          180  + int D = 1;
          181  + int RetVal = 1002995;
          182  + return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
          183  +int Test_(Case_<5>) {
          184  + int N = 2000;
          185  + int M = 4000000;
          186  + int X0 = 1500;
          187  + int A = 1;
          188  + int B = 1;
          189  + int Y0 = 500;
          190  + int C = 1;
          191  + int D = 1;
          192  + int RetVal = 1003997;
          193  + return verify_case(RetVal, PerfectRectangles().numberOfRectangles(N, M, X0, A, B, Y0, C, D)); }
          194  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          195  +template<> void Run_<-1>() {}
          196  +int main() { Run_<0>(); }
          197  +// END CUT HERE
          198  +

Added SRM/432/1A.cpp version [329bdbe17af21f45]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class LampsGrid {
           21  +public:
           22  + int curMax;
           23  +
           24  + int mostLit(vector <string> initial, int K)
           25  + {
           26  +  // atama-warui
           27  +  //   only meaningful way to flip lights are
           28  +  //   that: exists i {j | initial[i][j]=='0'}
           29  +  //   so at most initial.size() try is sufficient...
           30  +
           31  +  vector<LL> s;
           32  +  for(int j=0; j<initial[0].size(); ++j) {
           33  +   LL x = 0;
           34  +   for(int i=0; i<initial.size(); ++i)
           35  +    if( initial[i][j]=='1' )
           36  +     x |= (1LL << i);
           37  +   s.push_back(x);
           38  +  }
           39  +
           40  +  curMax = 0;
           41  +  for(; K>=0; K-=2)
           42  +   if( K <= initial[0].size() )
           43  +    rec((1LL<<initial.size())-1, s, 0, K);
           44  +  return curMax;
           45  + }
           46  +
           47  + void rec(LL lit, vector<LL> s, int i, int K) // exact K flips
           48  + {
           49  +  int c = 0;
           50  +  for(LL j=1; j<=lit; j<<=1)
           51  +   if( lit&j )
           52  +    ++c;
           53  +  if( c<=curMax )
           54  +   return;
           55  +  if( i == s.size() )
           56  +  {
           57  +   curMax = c;
           58  +   return;
           59  +  }
           60  +
           61  +  if( i+K < s.size() ) // noflip
           62  +   rec( lit&s[i], s, i+1, K );
           63  +  if( K ) // flip
           64  +   rec( lit&~s[i], s, i+1, K-1 );
           65  + }
           66  +};
           67  +
           68  +// BEGIN CUT HERE
           69  +#include <ctime>
           70  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           71  +
           72  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           73  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           74  +
           75  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           76  +char Test_(...);
           77  +int Test_(Case_<0>) {
           78  + string initial_[] = {"01",
           79  + "10",
           80  + "10"};
           81  +   vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_));
           82  + int K = 1;
           83  + int RetVal = 2;
           84  + return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
           85  +int Test_(Case_<1>) {
           86  + string initial_[] = {"101010"};
           87  +   vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_));
           88  + int K = 2;
           89  + int RetVal = 0;
           90  + return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
           91  +int Test_(Case_<2>) {
           92  + string initial_[] = {"00", "11"};
           93  +   vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_));
           94  + int K = 999;
           95  + int RetVal = 0;
           96  + return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
           97  +int Test_(Case_<3>) {
           98  + string initial_[] = {"0", "1", "0", "1", "0"}
           99  +;
          100  +   vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_));
          101  + int K = 1000;
          102  + int RetVal = 2;
          103  + return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
          104  +int Test_(Case_<4>) {
          105  + string initial_[] = {"001", "101", "001", "000", "111", "001", "101", "111", "110", "000", "111", "010", "110", "001"};
          106  +   vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_));
          107  + int K = 6;
          108  + int RetVal = 4;
          109  + return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
          110  +int Test_(Case_<5>) {
          111  + string initial_[] = {"01", "10", "01", "01", "10"};
          112  +   vector <string> initial(initial_, initial_+sizeof(initial_)/sizeof(*initial_));
          113  + int K = 1;
          114  + int RetVal = 3;
          115  + return verify_case(RetVal, LampsGrid().mostLit(initial, K)); }
          116  +
          117  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          118  +template<>      void Run_<-1>() {}
          119  +int main() { Run_<0>(); }
          120  +// END CUT HERE
          121  +

Added SRM/432/1B.cpp version [22831069cfdf7e1f]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class GroupedWord {
           21  +public:
           22  + string restore(vector <string> parts)
           23  + {
           24  +  while( reduce(parts) ) {}
           25  +
           26  +  if( parts.size() == 1 )
           27  +   return gd(parts[0]) ? parts[0] : "IMPOSSIBLE";
           28  +
           29  +  string s = accumulate(parts.begin(), parts.end(), string(""));
           30  +  return gd(s) ? "MANY" : "IMPOSSIBLE";
           31  + }
           32  +
           33  + bool reduce( vector<string>& p )
           34  + {
           35  +  for(int j=0; j<p.size(); ++j) {
           36  +   string& s = p[j];
           37  +
           38  +   char last = s[s.size()-1];
           39  +   for(int i=0; i<p.size(); ++i) if(i!=j)
           40  +    if( count(p[i].begin(), p[i].end(), last) == p[i].size() )
           41  +    {
           42  +     p.push_back(s+p[i]);
           43  +     p.erase(p.begin()+max(i,j));
           44  +     p.erase(p.begin()+min(i,j));
           45  +     return true;
           46  +    }
           47  +
           48  +   for(int i=0; i<p.size(); ++i) if(i!=j)
           49  +    if( p[i][0] == last )
           50  +    {
           51  +     p.push_back(s+p[i]);
           52  +     p.erase(p.begin()+max(i,j));
           53  +     p.erase(p.begin()+min(i,j));
           54  +     return true;
           55  +    }
           56  +  }
           57  +  return false;
           58  + }
           59  +
           60  + bool gd(const string& s)
           61  + {
           62  +  for(int i=0; i<s.size(); )
           63  +  {
           64  +   int j=i;
           65  +   while( j<s.size() && s[i]==s[j] ) ++j;
           66  +   if( s.find(s[i], j)!=string::npos )
           67  +    return false;
           68  +   i=j;
           69  +  }
           70  +  return true;
           71  + }
           72  +};
           73  +
           74  +// BEGIN CUT HERE
           75  +#include <ctime>
           76  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           77  +
           78  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           79  +int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           80  +
           81  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           82  +char Test_(...);
           83  +int Test_(Case_<0>) {
           84  + string parts_[] = {"aaa", "a", "aa"};
           85  +   vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_));
           86  + string RetVal = "aaaaaa";
           87  + return verify_case(RetVal, GroupedWord().restore(parts)); }
           88  +int Test_(Case_<1>) {
           89  + string parts_[] = {"ab", "bba"};
           90  +   vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_));
           91  + string RetVal = "IMPOSSIBLE";
           92  + return verify_case(RetVal, GroupedWord().restore(parts)); }
           93  +int Test_(Case_<2>) {
           94  + string parts_[] = {"te", "st"};
           95  +   vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_));
           96  + string RetVal = "stte";
           97  + return verify_case(RetVal, GroupedWord().restore(parts)); }
           98  +int Test_(Case_<3>) {
           99  + string parts_[] = {"te", "s", "t"};
          100  +   vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_));
          101  + string RetVal = "MANY";
          102  + return verify_case(RetVal, GroupedWord().restore(parts)); }
          103  +int Test_(Case_<4>) {
          104  + string parts_[] = {"orr", "rd", "woo", "www"};
          105  +   vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_));
          106  + string RetVal = "wwwwooorrrd";
          107  + return verify_case(RetVal, GroupedWord().restore(parts)); }
          108  +int Test_(Case_<5>) {
          109  + string parts_[] = {"abcb"};
          110  +   vector <string> parts(parts_, parts_+sizeof(parts_)/sizeof(*parts_));
          111  + string RetVal = "IMPOSSIBLE";
          112  + return verify_case(RetVal, GroupedWord().restore(parts)); }
          113  +
          114  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          115  +template<>      void Run_<-1>() {}
          116  +int main() { Run_<0>(); }
          117  +// END CUT HERE
          118  +

Added SRM/432/1C.cpp version [31dd781df2b6765d]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +struct union_find {
           21  + vector<int> p, s;
           22  + union_find(int N) : p(N, -1), s(N, 1) {}
           23  +
           24  + int repr(int u) {
           25  +  while( p[u]>=0 ) u=p[u];
           26  +  return u;
           27  + }
           28  + bool conn(int u, int v) {
           29  +  u = repr(u);
           30  +  v = repr(v);
           31  +  if( u==v ) return false;
           32  +  if( s[u] < s[v] ) { p[u]=v; s[v]+=s[u]; }
           33  +  else              { p[v]=u; s[u]+=s[v]; }
           34  +  return true;
           35  + }
           36  +};
           37  +
           38  +class BuildersCountry {
           39  +public:
           40  + long long minCost(vector <int> before, vector <int> after, vector <int> houseCost, vector <string> g, int roadCost)
           41  + {
           42  +  int N = before.size();
           43  +
           44  +  LL baseCost = 0;
           45  +
           46  +  vector< vector<LL> > cost(N, vector<LL>(N));
           47  +  for(int i=0; i!=N; ++i)
           48  +   for(int j=i+1; j!=N; ++j)
           49  +{    LL cc = LL(roadCost)*(before[i]+before[j]);
           50  +
           51  +    int mi = houseCost[i]<houseCost[j] ? i : j;
           52  +    int mj = houseCost[i]<houseCost[j] ? j : i;
           53  +    LL cc2 = LL(houseCost[mj])*(after[mj]-before[mj])*before[mi]
           54  +           + LL(houseCost[mi])*(after[mi]-before[mi])*after[mj];
           55  +
           56  +    cost[i][j] = cost[j][i] = cc+cc2;
           57  +
           58  +    if( g[i][j] == 'Y' )
           59  +     baseCost += cc2;
           60  +   }
           61  +
           62  +  for(int i=0; i!=N; ++i)
           63  +   baseCost += LL(houseCost[i]) * LL(before[i]+after[i]-1) * LL(after[i] - before[i]) / 2;
           64  +  return baseCost + mst(cost, g, N);
           65  + }
           66  +
           67  + LL mst(vector<vector<LL> >& c, vector<string>& g, int N)
           68  + {
           69  +  union_find uf(N);
           70  +  for(int i=0; i!=N; ++i)
           71  +   for(int j=i+1; j!=N; ++j)
           72  +    if( g[i][j]=='Y' )
           73  +     uf.conn(i,j);
           74  +
           75  +  typedef pair<LL,pair<int,int> > cedge;
           76  +  vector<cedge> es;
           77  +  for(int i=0; i!=N; ++i)
           78  +   for(int j=i+1; j!=N; ++j)
           79  +    es.push_back( make_pair( c[i][j], make_pair(i,j) ) );
           80  +  sort(es.begin(), es.end());
           81  +
           82  +  LL cc = 0;
           83  +  for(int i=0; i!=es.size(); ++i)
           84  +  {
           85  +   int u = es[i].second.first;
           86  +   int v = es[i].second.second;
           87  +   LL c = es[i].first;
           88  +   if( uf.conn(u,v) )
           89  +    cc += c;
           90  +  }
           91  +  return cc;
           92  + }
           93  +};
           94  +
           95  +// BEGIN CUT HERE
           96  +#include <ctime>
           97  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           98  +
           99  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          100  +int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          101  +
          102  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          103  +char Test_(...);
          104  +int Test_(Case_<0>) {
          105  + int before_[] = {2, 1, 3, 5};
          106  +   vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_));
          107  + int after_[] = {2, 1, 3, 5};
          108  +   vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_));
          109  + int houseCost_[] = {4, 5, 3, 2};
          110  +   vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_));
          111  + string g_[] = {"NNNN", "NNNN", "NNNN", "NNNN"};
          112  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
          113  + int roadCost = 1000;
          114  + long long RetVal = 13000LL;
          115  + return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
          116  +int Test_(Case_<1>) {
          117  + int before_[] = {1, 1, 1, 1};
          118  +   vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_));
          119  + int after_[] = {1, 3, 1, 2};
          120  +   vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_));
          121  + int houseCost_[] = {8, 5, 3, 2};
          122  +   vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_));
          123  + string g_[] = {"NYNN", "YNYN", "NYNY", "NNYN"};
          124  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
          125  + int roadCost = 100000;
          126  + long long RetVal = 39LL;
          127  + return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
          128  +int Test_(Case_<2>) {
          129  + int before_[] = {9, 11};
          130  +   vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_));
          131  + int after_[] = {10, 11};
          132  +   vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_));
          133  + int houseCost_[] = {5, 1};
          134  +   vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_));
          135  + string g_[] = {"NN", "NN"};
          136  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
          137  + int roadCost = 15;
          138  + long long RetVal = 400LL;
          139  + return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
          140  +int Test_(Case_<3>) {
          141  + int before_[] = {1};
          142  +   vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_));
          143  + int after_[] = {1000};
          144  +   vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_));
          145  + int houseCost_[] = {2};
          146  +   vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_));
          147  + string g_[] = {"N"};
          148  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
          149  + int roadCost = 888;
          150  + long long RetVal = 999000LL;
          151  + return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
          152  +int Test_(Case_<4>) {
          153  + int before_[] = {99, 23, 44, 55, 32};
          154  +   vector <int> before(before_, before_+sizeof(before_)/sizeof(*before_));
          155  + int after_[] = {99, 23, 44, 55, 32};
          156  +   vector <int> after(after_, after_+sizeof(after_)/sizeof(*after_));
          157  + int houseCost_[] = {39, 32, 11, 23, 89};
          158  +   vector <int> houseCost(houseCost_, houseCost_+sizeof(houseCost_)/sizeof(*houseCost_));
          159  + string g_[] = {"NYNNN", "YNNNY", "NNNYY", "NNYNY", "NYYYN"};
          160  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
          161  + int roadCost = 54;
          162  + long long RetVal = 0LL;
          163  + return verify_case(RetVal, BuildersCountry().minCost(before, after, houseCost, g, roadCost)); }
          164  +
          165  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          166  +template<>      void Run_<-1>() {}
          167  +int main() { Run_<0>(); }
          168  +// END CUT HERE
          169  +

Added SRM/433/1A.cpp version [2697f802cd1ec7d5]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class MagicWords {
           21  +public:
           22  + int count(vector <string> S, int K)
           23  + {
           24  +  int cnt = 0;
           25  +
           26  +  int idx[] = {0,1,2,3,4,5,6,7};
           27  +  do {
           28  +   string s; for(int i=0; i<S.size(); ++i) s += S[idx[i]];
           29  +
           30  +   if( s.size()%K==0 && rep_of(s, s.size()/K) )
           31  +   {
           32  +    for(int n=1; n<s.size()/K; ++n)
           33  +     if( s.size()%n==0 && rep_of(s, n) )
           34  +      goto fail;
           35  +    ++cnt;
           36  +   fail:;
           37  +   }
           38  +  } while( next_permutation(idx+0, idx+S.size()) );
           39  +
           40  +  return cnt;
           41  + }
           42  +
           43  + bool rep_of( string& s, int n ) {
           44  +  return s == s.substr(n, s.size()-n) + s.substr(0, n);
           45  + }
           46  +};
           47  +
           48  +// BEGIN CUT HERE
           49  +#include <ctime>
           50  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           51  +
           52  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           53  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           54  +
           55  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           56  +char Test_(...);
           57  +int Test_(Case_<0>) {
           58  + string S_[] = {"CAD","ABRA","ABRA"};
           59  +   vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_));
           60  + int K = 1;
           61  + int RetVal = 6;
           62  + return verify_case(RetVal, MagicWords().count(S, K)); }
           63  +int Test_(Case_<1>) {
           64  + string S_[] = {"AB","RAAB","RA"};
           65  +   vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_));
           66  + int K = 2;
           67  + int RetVal = 3;
           68  + return verify_case(RetVal, MagicWords().count(S, K)); }
           69  +int Test_(Case_<2>) {
           70  + string S_[] = {"AA","AA","AAA","A"};
           71  +   vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_));
           72  + int K = 1;
           73  + int RetVal = 0;
           74  + return verify_case(RetVal, MagicWords().count(S, K)); }
           75  +int Test_(Case_<3>) {
           76  + string S_[] = {"AA","AA","AAA","A","AAA","AAAA"};
           77  +   vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_));
           78  + int K = 15;
           79  + int RetVal = 720;
           80  + return verify_case(RetVal, MagicWords().count(S, K)); }
           81  +int Test_(Case_<4>) {
           82  + string S_[] = {"ABC","AB","ABC","CA"};
           83  +   vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_));
           84  + int K = 3;
           85  + int RetVal = 0;
           86  + return verify_case(RetVal, MagicWords().count(S, K)); }
           87  +int Test_(Case_<5>) {
           88  + string S_[] = {"A","B","C","A","B","C"};
           89  +   vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_));
           90  + int K = 1;
           91  + int RetVal = 672;
           92  + return verify_case(RetVal, MagicWords().count(S, K)); }
           93  +int Test_(Case_<6>) {
           94  + string S_[] = {"AAAAAAAAAAAAAAAAAAAA",
           95  + "AAAAAAAAAAAAAAAAAAAA",
           96  + "AAAAAAAAAAAAAAAAAAAA",
           97  + "AAAAAAAAAAAAAAAAAAAA",
           98  + "AAAAAAAAAAAAAAAAAAAA",
           99  + "AAAAAAAAAAAAAAAAAAAA",
          100  + "AAAAAAAAAAAAAAAAAAAA",
          101  + "AAAAAAAAAAAAAAAAAAAB"};
          102  +   vector <string> S(S_, S_+sizeof(S_)/sizeof(*S_));
          103  + int K = 1;
          104  + int RetVal = 40320;
          105  + return verify_case(RetVal, MagicWords().count(S, K)); }
          106  +
          107  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          108  +template<>      void Run_<-1>() {}
          109  +int main() { Run_<0>(); }
          110  +// END CUT HERE
          111  +

Added SRM/433/1B.cpp version [6a8dec603d2a8fec]

            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  +int gcd(int a, int b) { while(a) swap(a,b%=a); return b; }
           23  +
           24  +class SettingTents {
           25  +public:
           26  + int countSites(int N, int M)
           27  + {
           28  +  int cnt = 0;
           29  +  for(int w=1; w<=N; ++w)     // for each
           30  +   for(int h=1; h<=M; ++h) // bounding box...
           31  +   {
           32  +    int numWH = (N+1-w)*(M+1-h);
           33  +
           34  +    // w/2 - k(h-2j) = x
           35  +    // h/2 + kw      = y
           36  +    for(int j=1; j<h; ++j) // the case when both two diags contribute to the bounds
           37  +     if( (w*w+h*(h-2*j)) % (2*w) == 0 )
           38  +     {
           39  +      int x = (w*w+h*(h-2*j)) / (2*w);
           40  +      if( 0<=x && x<=w )
           41  +       cnt += numWH;
           42  +     }
           43  +
           44  +    for(int y=0; 2*y<h; ++y) // the case when only one diag contribut to the bounds
           45  +     if( (w*w - (2*y-h)*h) % (2*w) == 0 )
           46  +     {
           47  +      int x = (w*w - (2*y-h)*h) / (2*w);
           48  +      if( x<w )
           49  +       cnt += 2*numWH;
           50  +     }
           51  +
           52  +    if( w==h ) // special case
           53  +     cnt += numWH;
           54  +   }
           55  +  return cnt;
           56  + }
           57  +};
           58  +
           59  +// BEGIN CUT HERE
           60  +#include <ctime>
           61  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           62  +
           63  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           64  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           65  +
           66  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           67  +char Test_(...);
           68  +int Test_(Case_<0>) {
           69  + int N = 2;
           70  + int M = 2;
           71  + int RetVal = 6;
           72  + return verify_case(RetVal, SettingTents().countSites(N, M)); }
           73  +int Test_(Case_<1>) {
           74  + int N = 1;
           75  + int M = 6;
           76  + int RetVal = 6;
           77  + return verify_case(RetVal, SettingTents().countSites(N, M)); }
           78  +int Test_(Case_<2>) {
           79  + int N = 6;
           80  + int M = 8;
           81  + int RetVal = 527;
           82  + return verify_case(RetVal, SettingTents().countSites(N, M)); }
           83  +
           84  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           85  +template<>      void Run_<-1>() {}
           86  +int main() { Run_<0>(); }
           87  +// END CUT HERE
           88  +

Added SRM/433/1C.cpp version [bfd8440d84a22d10]

            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 LL SHIFT = 1000000000LL;
           23  +static const LL INF   = 1000001LL;
           24  +static const LL MAX   = 1000000LL;
           25  +static const int NV = 5002;
           26  +typedef LL            flow;
           27  +typedef int           vert;
           28  +typedef vert          edge;
           29  +typedef vector<edge>  edges;
           30  +typedef vector<edges> graph;
           31  +//typedef flow          flow_graph[NV][NV];
           32  +typedef map< vert,map<vert,flow> > flow_graph;
           33  +
           34  +flow dinic_dfs( graph& G, flow_graph& F, vert v, vert D,
           35  +                int LV[], flow flow_in, int blocked[] )
           36  +{
           37  + flow flow_out = 0;
           38  + for(int i=0; i!=G[v].size(); ++i) {
           39  +  int u = G[v][i];
           40  +  if( LV[v]+1==LV[u] && F[v][u] ) {
           41  +   flow f = min(flow_in-flow_out, F[v][u]);
           42  +   if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) ) {
           43  +    F[v][u]  -= f;
           44  +    F[u][v]  += f;
           45  +    flow_out += f;
           46  +    if( flow_in == flow_out ) return flow_out;
           47  +   }
           48  +  }
           49  + }
           50  + blocked[v] = (flow_out==0);
           51  + return flow_out;
           52  +}
           53  +
           54  +flow maxFlow( graph& G, flow_graph& F, vert S, vert D )
           55  +{
           56  + for( flow total=0 ;; ) {
           57  +  int LV[NV] = {0};
           58  +  vector<int> Q(1, S);
           59  +  for(int lv=1; !Q.empty(); ++lv) {
           60  +   vector<int> Q2;
           61  +   for(int i=0; i!=Q.size(); ++i) {
           62  +    edges& ne = G[Q[i]];
           63  +    for(int j=0; j!=ne.size(); ++j)
           64  +     if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
           65  +      LV[ne[j]]=lv, Q2.push_back(ne[j]);
           66  +   }
           67  +   Q.swap(Q2);
           68  +  }
           69  +
           70  +  if( !LV[D] )
           71  +   return total;
           72  +
           73  +  int blocked[NV] = {};
           74  +  total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
           75  + }
           76  +}
           77  +
           78  +flow_graph F;
           79  +class BarbarianInvasion {
           80  +public:
           81  + int minimalDetachment(vector <string> countryMap, vector <int> detachmentSize)
           82  + {
           83  +  int H = countryMap.size();
           84  +  int W = countryMap[0].size();
           85  +  vert OUT = 0, CAP = 1;
           86  +
           87  +  graph G(H*W*2+2);
           88  +  flow_graph F;
           89  +
           90  +  for(int y=0; y<H; ++y)
           91  +  for(int x=0; x<W; ++x)
           92  +  {
           93  +   if( countryMap[y][x] == '-' )
           94  +    continue;
           95  +
           96  +   vert CUR_A = countryMap[y][x] == '*' ? CAP : (y*W+x)*2+2; // ==>A->B==>
           97  +   vert CUR_B = countryMap[y][x] == '*' ? CAP : (y*W+x)*2+3;
           98  +   if( countryMap[y][x] != '*' && countryMap[y][x] != '-' ) {
           99  +    G[CUR_A].push_back(CUR_B);
          100  +    G[CUR_B].push_back(CUR_A);
          101  +    F[CUR_A][CUR_B] = SHIFT + detachmentSize[countryMap[y][x]-'A'];
          102  +    F[CUR_B][CUR_A] = 0;
          103  +   }
          104  +
          105  +   int DY[] = {-1,+1,0,0}, DX[]={0,0,-1,+1};
          106  +   for(int d=0; d<4; ++d)
          107  +   {
          108  +    int dy = DY[d], dx = DX[d];
          109  +    if( 0<=y+dy && y+dy<H && 0<=x+dx && x+dx<W )
          110  +    {
          111  +     if( countryMap[y+dy][x+dx] == '-' )
          112  +      continue;
          113  +     if( countryMap[y+dy][x+dx] == '*' )
          114  +      continue;
          115  +     vert ADJ_B = ((y+dy)*W+(x+dx))*2+3;
          116  +     G[ADJ_B].push_back(CUR_A);
          117  +     G[CUR_A].push_back(ADJ_B);
          118  +     F[ADJ_B][CUR_A] = SHIFT+INF;
          119  +     F[CUR_A][ADJ_B] = 0;
          120  +    }
          121  +    else
          122  +    {
          123  +     G[OUT].push_back(CUR_A);
          124  +     G[CUR_A].push_back(OUT);
          125  +     F[OUT][CUR_A] = SHIFT+INF;
          126  +     F[CUR_A][OUT] = 0;
          127  +    }
          128  +   }
          129  +  }
          130  +
          131  +  flow mf = maxFlow(G, F, OUT, CAP);
          132  +  return mf%SHIFT;
          133  + }
          134  +};
          135  +
          136  +// BEGIN CUT HERE
          137  +#include <ctime>
          138  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          139  +
          140  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          141  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          142  +
          143  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          144  +char Test_(...);
          145  +int Test_(Case_<0>) {
          146  + string countryMap_[] = {"ABA",
          147  + "A*A",
          148  + "AAA"};
          149  +   vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_));
          150  + int detachmentSize_[] = {1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
          151  +   vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_));
          152  + int RetVal = 5;
          153  + return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
          154  +int Test_(Case_<1>) {
          155  + string countryMap_[] = {"CCCC",
          156  + "-BAC",
          157  + "-*AC",
          158  + "--AC"};
          159  +   vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_));
          160  + int detachmentSize_[] = {5,20,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
          161  +   vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_));
          162  + int RetVal = 25;
          163  + return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
          164  +int Test_(Case_<2>) {
          165  + string countryMap_[] = {"A----A",
          166  + "-AAAA-",
          167  + "-AA*A-",
          168  + "-AAAA-",
          169  + "A----A"};
          170  +   vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_));
          171  + int detachmentSize_[] = {9,8,2,5,3,2,1,2,6,10,4,6,7,1,7,8,8,8,2,9,7,6,5,1,5,10};
          172  +   vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_));
          173  + int RetVal = 0;
          174  + return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
          175  +int Test_(Case_<3>) {
          176  + string countryMap_[] = {"-A-----",
          177  + "-BCCC*-",
          178  + "-A-----"};
          179  +   vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_));
          180  + int detachmentSize_[] = {1,5,10,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
          181  +   vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_));
          182  + int RetVal = 5;
          183  + return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
          184  +int Test_(Case_<4>) {
          185  + string countryMap_[] = {"WANNABRUTEFORCEMEHUH",
          186  + "ASUDQWNHIOCASFIUQISA",
          187  + "UWQD-ASFFC-AJSQOOWE-",
          188  + "-----*Y--AVSSFIUQISA",
          189  + "UWQD-ASFFC-AJSQOOWE-",
          190  + "JUFDIFD-CHBVISBOOWE-",
          191  + "WANNABRUTEFORCEMEHUH"};
          192  +   vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_));
          193  + int detachmentSize_[] = {87,78,20,43,30,12,9,18,57,93,32,60,64,9,69,74,74,78,12,81,63,57,48,8,44,95};
          194  +   vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_));
          195  + int RetVal = 218;
          196  + return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
          197  +int Test_(Case_<5>) {
          198  + string countryMap_[] = {
          199  + "WOMP-PVE-LV-NB-J---E",
          200  + "K--MKNWSOLFKK-JHP--W",
          201  + "BE-K--MPP-YGZI-DMVKG",
          202  + "JGWRXQ-UYEROYGC--SZR",
          203  + "KFYN--CRX*N--JS-M-S-",
          204  + "TBFGG-OL--D-DY--RR-A",
          205  + "AMJT-NV--P--XF-YUSBM",
          206  + "HJ-C--KHU-KDZHERUUHM",
          207  + "-FGQZOI-A--ZIPB--QOT",
          208  + "PNLI-RWYZG-MNV-SUNJD",
          209  + "YJ-EJLD-H---K-HSVZF-",
          210  + "LKPGZGF-IQ-ETYQJ-VAR",
          211  + "UGS--V-BOUGG-SMO--Q-",
          212  + "DFVWRHC-D-XES-MEQMCQ",
          213  + "L-PUXR-C-HL-WX-NFJJR",
          214  + "-A-JLUQX--VWPFENHJZ-",
          215  + "HNG-NQAF-VVCUU-WU-HL"};
          216  +   vector <string> countryMap(countryMap_, countryMap_+sizeof(countryMap_)/sizeof(*countryMap_));
          217  + int detachmentSize_[] = {
          218  +96882, 90320, 19358, 82732, 80637, //ABCDE
          219  +88638, 43236, 34294, 49732, 86156, //FGHIJ
          220  + 1186, 84308, 49312, 92789, 49312, //KLMNO
          221  +14324, 27420, 32881, 73865, 91069, //PQRST
          222  + 7266, 60052, 98451, 84652, 3991, 58948}; //UVWXYZ
          223  +   vector <int> detachmentSize(detachmentSize_, detachmentSize_+sizeof(detachmentSize_)/sizeof(*detachmentSize_));
          224  + int RetVal = 69753;
          225  + return verify_case(RetVal, BarbarianInvasion().minimalDetachment(countryMap, detachmentSize)); }
          226  +
          227  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          228  +template<>      void Run_<-1>() {}
          229  +int main() { Run_<0>(); }
          230  +// END CUT HERE
          231  +

Added SRM/434-U/1A.cpp version [ca2bcca06d919fe6]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +bool is_ps( LL v )
           21  +{
           22  + LL sv = (LL)sqrt( double(v) );
           23  + return (sv-1)*(sv-1) == v
           24  +     || sv*sv == v
           25  +     || (sv+1)*(sv+1) == v;
           26  +}
           27  +
           28  +class FindingSquareInTable {
           29  +public:
           30  + int findMaximalSquare(vector <string> table)
           31  + {
           32  +  LL ans = -1;
           33  +
           34  +  int Y = table.size();
           35  +  int X = table[0].size();
           36  +  for(int y=0; y<Y; ++y)
           37  +   for(int x=0; x<X; ++x)
           38  +    for(int dy=-Y; dy<Y; ++dy)
           39  +     for(int dx=-X; dx<X; ++dx)
           40  +      if(dy||dx)
           41  +      {
           42  +       LL v = 0;
           43  +       for(int i=0;; ++i)
           44  +       {
           45  +        int yy = y+dy*i;
           46  +        int xx = x+dx*i;
           47  +        if( xx<0 || X<=xx || yy<0 || Y<=yy )
           48  +         break;
           49  +        int d = table[yy][xx]-'0';
           50  +        v = v*10 + d;
           51  +        if( is_ps(v) )
           52  +         ans = max(v, ans);
           53  +       }
           54  +      }
           55  +  return ans;
           56  + }
           57  +};
           58  +
           59  +// BEGIN CUT HERE
           60  +#include <ctime>
           61  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           62  +
           63  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           64  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           65  +
           66  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           67  +char Test_(...);
           68  +int Test_(Case_<0>) {
           69  + string table_[] = {"123",
           70  + "456"};
           71  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
           72  + int RetVal = 64;
           73  + return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
           74  +int Test_(Case_<1>) {
           75  + string table_[] = {"00000",
           76  + "00000",
           77  + "00200",
           78  + "00000",
           79  + "00000"};
           80  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
           81  + int RetVal = 0;
           82  + return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
           83  +int Test_(Case_<2>) {
           84  + string table_[] = {"3791178",
           85  + "1283252",
           86  + "4103617",
           87  + "8233494",
           88  + "8725572",
           89  + "2937261"};
           90  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
           91  + int RetVal = 320356;
           92  + return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
           93  +int Test_(Case_<3>) {
           94  + string table_[] = {"135791357",
           95  + "357913579",
           96  + "579135791",
           97  + "791357913",
           98  + "913579135"}
           99  +;
          100  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
          101  + int RetVal = 9;
          102  + return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
          103  +int Test_(Case_<4>) {
          104  + string table_[] = {"553333733",
          105  + "775337775",
          106  + "777537775",
          107  + "777357333",
          108  + "755553557",
          109  + "355533335",
          110  + "373773573",
          111  + "337373777",
          112  + "775557777"};
          113  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
          114  + int RetVal = -1;
          115  + return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
          116  +int Test_(Case_<5>) {
          117  + string table_[] = {"257240281",
          118  + "197510846",
          119  + "014345401",
          120  + "035562575",
          121  + "974935632",
          122  + "865865933",
          123  + "684684987",
          124  + "768934659",
          125  + "287493867"};
          126  +   vector <string> table(table_, table_+sizeof(table_)/sizeof(*table_));
          127  + int RetVal = 95481;
          128  + return verify_case(RetVal, FindingSquareInTable().findMaximalSquare(table)); }
          129  +
          130  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          131  +template<>      void Run_<-1>() {}
          132  +int main() { Run_<0>(); }
          133  +// END CUT HERE
          134  +

Added SRM/434-U/1B.cpp version [5e2ee475015aa982]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +static const int N = 60;
           21  +
           22  +typedef vector<int> Num;
           23  +Num conv( const string& s )
           24  +{
           25  + Num n(N);
           26  + for(int i=0; i<s.size(); ++i)
           27  + {
           28  +  char c = s[s.size()-1-i];
           29  +  n[N-1-i] = ('0'<=c&&c<='9' ? c-'0' : c-'A'+10);
           30  + }
           31  + return n;
           32  +}
           33  +
           34  +Num add( const Num& a, const Num& b )
           35  +{
           36  + Num n(N);
           37  + int c = 0;
           38  + for(int i=0; i<N; ++i)
           39  + {
           40  +  int s = a[N-1-i] + b[N-1-i] + c;
           41  +  n[N-1-i] = s%36;
           42  +  c = s/36;
           43  + }
           44  + return n;
           45  +}
           46  +
           47  +class HexatridecimalSum {
           48  +public:
           49  + string maximizeSum(vector <string> numbers, int k)
           50  + {
           51  +  vector<Num> ns;
           52  +  transform( numbers.begin(), numbers.end(), back_inserter(ns), &conv );
           53  +
           54  +  vector<Num> gain(36);
           55  +  for(int d=0; d<36; ++d)
           56  +  {
           57  +   vector<int> g(N);
           58  +   for(int i=0; i<ns.size(); ++i)
           59  +    for(int j=0,f=0; j<N; ++j) {
           60  +     if( ns[i][j] ) f=1;
           61  +     if( f && ns[i][j] == d )
           62  +      g[j] += (35-d);
           63  +    }
           64  +   Num gg(N);
           65  +   for(int j=0; j<N; ++j) {
           66  +    int x = g[N-1-j];
           67  +    gg[N-1-j] = x % 36;
           68  +    if(x/36) g[N-1-j-1] += x/36;
           69  +   }
           70  +   gain[d] = gg;
           71  +  }
           72  +  sort( gain.rbegin(), gain.rend() );
           73  +  Num zero(N);
           74  +  Num n = accumulate( gain.begin(), gain.begin()+k, zero, &add );
           75  +  Num m = accumulate( ns.begin(), ns.end(), n, &add );
           76  +
           77  +  string ans;
           78  +  for(int i=0,f=0; i<N; ++i)
           79  +  {
           80  +   if(m[i]) f=1;
           81  +   if(f)
           82  +    if( m[i]<=9 )
           83  +     ans += char(m[i]+'0');
           84  +    else
           85  +     ans += char(m[i]-10+'A');
           86  +  }
           87  +  return ans;
           88  + }
           89  +};
           90  +
           91  +// BEGIN CUT HERE
           92  +#include <ctime>
           93  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           94  +
           95  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           96  +int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           97  +
           98  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           99  +char Test_(...);
          100  +int Test_(Case_<0>) {
          101  + string numbers_[] = {"HELLO"};
          102  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
          103  + int k = 2;
          104  + string RetVal = "ZZLLO";
          105  + return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
          106  +int Test_(Case_<1>) {
          107  + string numbers_[] = {"500", "POINTS", "FOR", "THIS", "PROBLEM"};
          108  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
          109  + int k = 5;
          110  + string RetVal = "1100TC85";
          111  + return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
          112  +int Test_(Case_<2>) {
          113  + string numbers_[] = {"TO", "BE", "OR", "NOT", "TO", "BE"};
          114  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
          115  + int k = 0;
          116  + string RetVal = "QNO";
          117  + return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
          118  +int Test_(Case_<3>) {
          119  + string numbers_[] = {"KEQUALS36"};
          120  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
          121  + int k = 36;
          122  + string RetVal = "ZZZZZZZZZ";
          123  + return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
          124  +int Test_(Case_<4>) {
          125  + string numbers_[] = {"GOOD", "LUCK", "AND", "HAVE", "FUN"};
          126  +   vector <string> numbers(numbers_, numbers_+sizeof(numbers_)/sizeof(*numbers_));
          127  + int k = 7;
          128  + string RetVal = "31YUB";
          129  + return verify_case(RetVal, HexatridecimalSum().maximizeSum(numbers, k)); }
          130  +
          131  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          132  +template<>      void Run_<-1>() {}
          133  +int main() { Run_<0>(); }
          134  +// END CUT HERE
          135  +

Added SRM/434-U/1C-U.cpp version [a7fda6c5ea37e4b7]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class IncreasingLists {
           21  +public:
           22  + string ans;
           23  + typedef pair<int,pair<string,string> > key;
           24  + map<key,bool> memo;
           25  +
           26  + vector<string> cm;
           27  +
           28  + string makeIncreasingList(string mask)
           29  + {
           30  +  string buf(mask);
           31  +  comma(mask, 0, 1, 0, buf);
           32  +
           33  +  for(int i=0; i<cm.size(); ++i)
           34  +  {
           35  +   // try_fill
           36  +  }
           37  +
           38  +  return rec(mask, 0, "", "", buf) ? ans : "impossible";
           39  + }
           40  +
           41  + void comma( const string& mask, int i, int prev, int cur, string& buf )
           42  + {
           43  +  if( i==mask.size() || mask[i]==',' )
           44  +   if( prev > cur )
           45  +    return;
           46  +  if( i==mask.size() ) {
           47  +   cm.push_back(buf);
           48  +   return;
           49  +  }
           50  +  if( mask[i]==',' ) {
           51  +   buf[i] = ',';
           52  +   comma( mask, i+1, cur, 0, buf );
           53  +  }
           54  +  else if( mask[i]=='?' ) {
           55  +   if( prev<=cur ) {
           56  +    buf[i]=',';
           57  +    comma( mask, i+1, cur, 0, buf );
           58  +   }
           59  +   buf[i]='?';
           60  +   comma( mask, i+1, prev, cur+1, buf );
           61  +  }
           62  +  else {
           63  +   buf[i] = mask[i];
           64  +   comma( mask, i+1, prev, cur+1, buf );
           65  +  }
           66  + }
           67  +
           68  + bool rec(const string& mask, int i, const string& prev, const string& cur, string& buf)
           69  + {
           70  +  key k(i, make_pair(prev,cur));
           71  +  if( memo.count(k) )
           72  +   return false;
           73  +  if( i==mask.size() || mask[i]==',' )
           74  +  {
           75  +   if( prev.size() > cur.size()
           76  +    || prev.size() == cur.size() && prev>=cur )
           77  +    return false;
           78  +  }
           79  +
           80  +  if( i==mask.size() ) {
           81  +   ans = buf;
           82  +   return true;
           83  +  }
           84  +
           85  +  if( mask[i]==',' )
           86  +   return rec(mask, i+1, cur, "", buf);
           87  +
           88  +  if( '0' <= mask[i] && mask[i] <='9' )
           89  +   return rec(mask, i+1, prev, cur+mask[i], buf);
           90  +
           91  +  // try ,
           92  +  if( !(prev.size()>cur.size() || prev.size()==cur.size() && prev>=cur) ) {
           93  +   buf[i] = ',';
           94  +   if( rec(mask, i+1, cur, "", buf) )
           95  +    return true;
           96  +  }
           97  +  // try 0
           98  +  for(int d=0; d<9; ++d)
           99  +   if(cur.size()>0 || d>0) {
          100  +    buf[i] = char(d+'0');
          101  +    if( rec(mask, i+1, prev, cur+char(d+'0'), buf) )
          102  +     return true;
          103  +   }
          104  +  return memo[k] = false;
          105  + }
          106  +};
          107  +
          108  +// BEGIN CUT HERE
          109  +#include <ctime>
          110  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          111  +
          112  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          113  +int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          114  +
          115  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          116  +char Test_(...);
          117  +int Test_(Case_<0>) {
          118  + string mask = "??";
          119  + string RetVal = "10";
          120  + return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
          121  +int Test_(Case_<1>) {
          122  + string mask = "???";
          123  + string RetVal = "1,2";
          124  + return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
          125  +int Test_(Case_<2>) {
          126  + string mask = "?????????,9";
          127  + string RetVal = "1,2,3,4,5,9";
          128  + return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
          129  +int Test_(Case_<3>) {
          130  + string mask = "??????????,9";
          131  + string RetVal = "impossible";
          132  + return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
          133  +int Test_(Case_<4>) {
          134  + string mask = "?,10,?????????????????,16,??";
          135  + string RetVal = "impossible";
          136  + return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
          137  +int Test_(Case_<5>) {
          138  + string mask = "?2?5??7?,??";
          139  + string RetVal = "12,50,70,71";
          140  + return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
          141  +int Test_(Case_<6>) {
          142  + string mask = "???????????????????????????????,???";
          143  + string RetVal = "1,10,11,100,101,102,103,104,105,106";
          144  + return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
          145  +int Test_(Case_<7>) {
          146  + string mask   = "??????????????????????????????????????????????????";
          147  + string RetVal = "1,10,100,1000,10000,100000,1000000,100000000000000";
          148  + return verify_case(RetVal, IncreasingLists().makeIncreasingList(mask)); }
          149  +
          150  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          151  +template<>      void Run_<-1>() {}
          152  +int main() { Run_<0>(); }
          153  +// END CUT HERE
          154  +

Added SRM/435/1A.cpp version [90be7959357bf00f]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class CellRemoval {
           21  +public:
           22  + int cellsLeft(vector <int> parent, int deletedCell)
           23  + {
           24  +  vector<bool> dead(parent.size(), false);
           25  +
           26  +  for(int i=0; i<parent.size(); ++i)
           27  +  {
           28  +   for(int p=i; p!=-1; p=parent[p], (p!=-1 ? dead[p]=true : 0) )
           29  +    if( p == deletedCell )
           30  +     dead[i] = true;
           31  +  }
           32  +  int cnt = 0;
           33  +  for(int i=0; i<dead.size(); ++i)
           34  +   if( !dead[i] )
           35  +    ++cnt;
           36  +  return cnt;
           37  + }
           38  +};
           39  +
           40  +// BEGIN CUT HERE
           41  +#include <ctime>
           42  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           43  +
           44  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           45  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           46  +
           47  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           48  +char Test_(...);
           49  +int Test_(Case_<0>) {
           50  + int parent_[] = {-1,0,0,1,1};
           51  +   vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_));
           52  + int deletedCell = 2;
           53  + int RetVal = 2;
           54  + return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
           55  +int Test_(Case_<1>) {
           56  + int parent_[] = {-1,0,0,1,1};
           57  +   vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_));
           58  + int deletedCell = 1;
           59  + int RetVal = 1;
           60  + return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
           61  +int Test_(Case_<2>) {
           62  + int parent_[] = {-1,0,0,1,1};
           63  +   vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_));
           64  + int deletedCell = 0;
           65  + int RetVal = 0;
           66  + return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
           67  +int Test_(Case_<3>) {
           68  + int parent_[] = {-1,0,0,2,2,4,4,6,6};
           69  +   vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_));
           70  + int deletedCell = 4;
           71  + int RetVal = 2;
           72  + return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
           73  +int Test_(Case_<4>) {
           74  + int parent_[] = {26,2,32,36,40,19,43,24,30,13,21,14,24,21,19,4,30,10,44,12,7,32,17,43,
           75  + 35,18,7,36,10,16,5,38,35,4,13,-1,16,26,1,12,2,5,18,40,1,17,38,44,14};
           76  +   vector <int> parent(parent_, parent_+sizeof(parent_)/sizeof(*parent_));
           77  + int deletedCell = 24;
           78  + int RetVal = 14;
           79  + return verify_case(RetVal, CellRemoval().cellsLeft(parent, deletedCell)); }
           80  +
           81  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           82  +template<>      void Run_<-1>() {}
           83  +int main() { Run_<0>(); }
           84  +// END CUT HERE
           85  +

Added SRM/435/1B.cpp version [a9aeb90d8d076e62]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +static const LL MODVAL = 1000000007;
           21  +
           22  +class DNADeletion {
           23  +public:
           24  + int differentProteins(vector <string> DNASequence, vector <string> codonTable)
           25  + {
           26  +  string dna;
           27  +  for(int i=0; i<DNASequence.size(); ++i) dna += DNASequence[i];
           28  +  int N = dna.size();
           29  +
           30  +  vector<string> cL, cR;
           31  +  for(int i=0; i<codonTable.size(); ++i) {
           32  +   stringstream sin(codonTable[i]);
           33  +   string s, t; sin>>s>>t;
           34  +   cL.push_back(s);
           35  +   cR.push_back(t);
           36  +  }
           37  +  int M = cL.size();
           38  +
           39  +
           40  +  vector<LL> dp(N+1); dp[0] = 1;
           41  +  for(int i=0; i<N; ++i)
           42  +  {
           43  +   // there's dp[i] ways to generate some aminoseq from dna[0...i]
           44  +
           45  +   vector<int> p(M);
           46  +
           47  +   set<string> done;
           48  +   for(int j=i; j<dna.size(); ++j)
           49  +   {
           50  +    for(int k=0; k<M; ++k)
           51  +     if( p[k]<3 && dna[j]==cL[k][p[k]] ) {
           52  +      p[k]++;
           53  +      if( p[k]==3 && !done.count(cR[k]) ) {
           54  +       done.insert(cR[k]);
           55  +       dp[j+1] = (dp[j+1] + dp[i]) % MODVAL;
           56  +      }
           57  +     }
           58  +   }
           59  +  }
           60  +
           61  +  LL n = (accumulate(dp.begin(), dp.end(), 0LL) - 1) % MODVAL;
           62  +  return int(n);
           63  + }
           64  +};
           65  +
           66  +// BEGIN CUT HERE
           67  +#include <ctime>
           68  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           69  +
           70  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           71  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           72  +
           73  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           74  +char Test_(...);
           75  +int Test_(Case_<0>) {
           76  + string DNASequence_[] = {"ACTG"};
           77  +   vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_));
           78  + string codonTable_[] = {"ACT gua", "ACG cys", "ATG leu", "CTG thr"};
           79  +   vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_));
           80  + int RetVal = 4;
           81  + return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
           82  +int Test_(Case_<1>) {
           83  + string DNASequence_[] = {"AAACCC"};
           84  +   vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_));
           85  + string codonTable_[] = {"AAA thr", "CCC cys"};
           86  +   vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_));
           87  + int RetVal = 3;
           88  + return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
           89  +int Test_(Case_<2>) {
           90  + string DNASequence_[] = {"AAATCCC"};
           91  +   vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_));
           92  + string codonTable_[] = {"AAA gua","TCC dop","AAT dop","CCC gua"};
           93  +   vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_));
           94  + int RetVal = 5;
           95  + return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
           96  +int Test_(Case_<3>) {
           97  + string DNASequence_[] = {"ATGCGCATTAACCTCCTACCATGGAAGGGACGTAACCCGGCAATTTGATC",
           98  + "CTGATGACGGCATAAGCTACCCCTAGAGGTAAAAATGCATACTGCGTGCT",
           99  + "ATGCAG"};
          100  +   vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_));
          101  + string codonTable_[] = {"AAC RpjZt","AAT ZeiC","GCA ChZwh","TCC RpjZt","GAA I",
          102  + "TAG ZeiC","CTG dVK","GAG ZeiC","GTG I","AAG q","ATT dVK",
          103  + "AGA cJEjM","GGG KONUd","GTC ZRV","GGC ZeiC","TTA KONUd",
          104  + "GAC q","CCA q","GCC ZRV","GCG RpjZt","CCT ZRV","ATG dVK",
          105  + "ATC ChZwh","CTC cJEjM","CCC q","ATA dWjz","TTG DkEG",
          106  + "CAG q","CAA ZRV","ACT dVK","TCG dVK","ACC I","CGC dVK"};
          107  +   vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_));
          108  + int RetVal = 455985264;
          109  + return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
          110  +int Test_(Case_<4>) {
          111  + string DNASequence_[] = {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"};
          112  +   vector <string> DNASequence(DNASequence_, DNASequence_+sizeof(DNASequence_)/sizeof(*DNASequence_));
          113  + string codonTable_[] = {"AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys","AAA thr", "CCC cys", "CCC cys", "CCC cys", "CCC cys"};
          114  +   vector <string> codonTable(codonTable_, codonTable_+sizeof(codonTable_)/sizeof(*codonTable_));
          115  + int RetVal = 3;
          116  + return verify_case(RetVal, DNADeletion().differentProteins(DNASequence, codonTable)); }
          117  +
          118  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          119  +template<>      void Run_<-1>() {}
          120  +int main() { Run_<0>(); }
          121  +// END CUT HERE
          122  +

Added SRM/435/1C.cpp version [0b6298dd57a02ed4]

            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  +typedef int           vert;
           23  +typedef vert          edge;
           24  +typedef vector<edge>  edges;
           25  +typedef vector<edges> graph;
           26  +
           27  +bool augment( graph& G, int v, vector<vert>& matchTo, bool visited[] )
           28  +{
           29  + for(int i=0; i<G[v].size(); ++i) {
           30  +  vert u = G[v][i];
           31  +  if( visited[u] ) continue;
           32  +  visited[u] = true;
           33  +
           34  +  if( matchTo[u]<0 || augment(G, matchTo[u], matchTo, visited) )
           35  +   { matchTo[v]=u, matchTo[u]=v; return true; }
           36  + }
           37  + return false;
           38  +}
           39  +
           40  +template<int NV>
           41  +int biMatch( graph& G, int L ) // [0,L):left, [L,?):right
           42  +    // only left->right edges are used during computation
           43  +{
           44  + vector<vert> matchTo(G.size(), -1);
           45  + int ans = 0;
           46  + for(vert v=0; v<L; ++v) {
           47  +  bool visited[NV] = {};
           48  +  if( augment(G, v, matchTo, visited) )
           49  +   ++ans;
           50  + }
           51  + return ans;
           52  +}
           53  +
           54  +class CompanyRestructuring {
           55  +public:
           56  + int fewestDivisions(vector <string> hasManaged)
           57  + {
           58  +  int N = hasManaged.size();
           59  +
           60  +  bool hm[50][50], hmStar[50][50];
           61  +  for(int i=0; i<N; ++i)
           62  +   for(int j=0; j<N; ++j)
           63  +    hm[i][j] = hmStar[i][j] = hasManaged[i][j]=='Y';
           64  +
           65  +  for(int k=0; k<N; ++k)
           66  +   for(int i=0; i<N; ++i)
           67  +    for(int j=0; j<N; ++j)
           68  +     hmStar[i][j] |= hmStar[i][k] & hmStar[k][j];
           69  +
           70  +  graph g(N);
           71  +  int nextID = N;
           72  +  for(int p=0; p<N; ++p)
           73  +  {
           74  +   vector<int> cs;
           75  +   vector<int> pi;
           76  +
           77  +   for(int c=0; c<N; ++c)
           78  +    if( hm[p][c] && !hmStar[c][p] )
           79  +    {
           80  +     int pid = -1;
           81  +
           82  +     for(int j=0; j<cs.size(); ++j)
           83  +      if( hmStar[c][cs[j]] && hmStar[cs[j]][c] )
           84  +       {pid = pi[j]; break;}
           85  +
           86  +     if(pid<0) pid = nextID++;
           87  +     cs.push_back(c);
           88  +     pi.push_back(pid);
           89  +     g[c].push_back(pid);
           90  +    }
           91  +  }
           92  +  g.resize(nextID);
           93  +
           94  +  return N - biMatch<5000>(g, N);
           95  + }
           96  +};
           97  +
           98  +// BEGIN CUT HERE
           99  +#include <ctime>
          100  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          101  +
          102  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          103  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          104  +
          105  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          106  +char Test_(...);
          107  +int Test_(Case_<0>) {
          108  + string hasManaged_[] = {"NNNN","NNYN","NNNN","YYYN"};
          109  +   vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_));
          110  + int RetVal = 1;
          111  + return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
          112  +int Test_(Case_<1>) {
          113  + string hasManaged_[] = {"NNYN","NNYN","YNNN","YYYN"};
          114  +   vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_));
          115  + int RetVal = 1;
          116  + return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
          117  +int Test_(Case_<2>) {
          118  + string hasManaged_[] = {"NYNNN","NNYNN","NNNYN","NNNNY","YNNNN"};
          119  +   vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_));
          120  + int RetVal = 5;
          121  + return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
          122  +int Test_(Case_<3>) {
          123  + string hasManaged_[] = {"NYNYYYNN"
          124  +,"NNNNYYNN"
          125  +,"NYNNYYNN"
          126  +,"NNYNYYNN"
          127  +,"NNNNNNNN"
          128  +,"NYYNYNNN"
          129  +,"YYNYYYNN"
          130  +,"YYNYYYYN"};
          131  +   vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_));
          132  + int RetVal = 1;
          133  + return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
          134  +int Test_(Case_<4>) {
          135  + string hasManaged_[] = {"NYNYNNYYNYNNNYYNYNYY"
          136  +,"YNNNNNYYNNNYYNYNYNYY"
          137  +,"NNNNNNYYNNNYYNYNNNNY"
          138  +,"YNYNNNNYNNNYNNYNYNNY"
          139  +,"NYNNNNNYYYYNYNYYNNYN"
          140  +,"YYYYNNYNYNNNNNYYNYNY"
          141  +,"NNNNNNNNNNNYYNNNNNYY"
          142  +,"NNNNNNYNNNNYYNYNNNYN"
          143  +,"NYYYNNNYNNNNYYNYYNYY"
          144  +,"NNYNNNYYNNNNYNNNNNYY"
          145  +,"YYNNNYNNYNNNNYNNYNYY"
          146  +,"NNNNNNNYNNNNYNYNNNNY"
          147  +,"NNNNNNYNNNNYNNNNNNNN"
          148  +,"NNYNNNNNNNNYYNYNNYYN"
          149  +,"NNNNNNNNNNNYNNNNNNNY"
          150  +,"YNYYNYYNNNYYNNNNYNYY"
          151  +,"NYNNNNNYNYNYYYYNNNNY"
          152  +,"NNYNNNNYNYNYYYNNNNYY"
          153  +,"NNNNNNNYNNNYNNNNNNNY"
          154  +,"NNNNNNYYNNNYYNYNNNYN"};
          155  +   vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_));
          156  + int RetVal = 4;
          157  + return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
          158  +int Test_(Case_<5>) {
          159  + string hasManaged_[] = {"NNNYNNNNNNNYNNNNNNNN"
          160  +,"NNNNNNYNNYNNNNNYNYYN"
          161  +,"YNNNNNYNYNNNNNNNNNNY"
          162  +,"YNNNNNNNNNNNNNNNNNNN"
          163  +,"NNYNNNYNYNNYNNYNNNNY"
          164  +,"NNNYNNNNNNNYNNYYYNYY"
          165  +,"NNYYNNNNYNNNNNNNNNNY"
          166  +,"NYNNNYNNYNNNYNYNYNNN"
          167  +,"NNNNNNNNNNNNNNNNNNNN"
          168  +,"YNNNNNNNNNNYNNYYNNYN"
          169  +,"NNYYNYNNYYNNNNYYNYNN"
          170  +,"NNNNNNNNYNNNNNNNNNNN"
          171  +,"NNNYYNYNYYYYNNNNYNYY"
          172  +,"NNYYNYNNYYYYNNNNNYNY"
          173  +,"NNYYYNNNYNNNNNNNNNNN"
          174  +,"YNNYYYNNNNNNNNYNYNYY"
          175  +,"NNNNYNYNNNNYNNYNNNNN"
          176  +,"YNNYYYYNNYNNYNNNYNYN"
          177  +,"YNNYYYYNYNNYNNYYYNNY"
          178  +,"YNYNNNNNYNNYNNNNNNNN"};
          179  +   vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_));
          180  + int RetVal = 2;
          181  + return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
          182  +int Test_(Case_<6>) {
          183  + string hasManaged_[] = {"NNNNN","NNNNN","NNNNN","NNNNN","NNNNN"};
          184  +   vector <string> hasManaged(hasManaged_, hasManaged_+sizeof(hasManaged_)/sizeof(*hasManaged_));
          185  + int RetVal = 5;
          186  + return verify_case(RetVal, CompanyRestructuring().fewestDivisions(hasManaged)); }
          187  +
          188  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          189  +template<>      void Run_<-1>() {}
          190  +int main() { Run_<0>(); }
          191  +// END CUT HERE
          192  +

Added SRM/436/1A.cpp version [4452768ad937b4c9]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class BestView {
           21  +public:
           22  + int numberOfBuildings(vector <int> heights)
           23  + {
           24  +  int maxCnt = -1;
           25  +
           26  +  int N = heights.size();
           27  +  for(int from=0; from<N; ++from)
           28  +  {
           29  +   int cnt = 0;
           30  +   for(int to=0; to<N; ++to) if(to != from)
           31  +   {
           32  +    bool hidden = false;
           33  +    for(int h=min(from,to)+1; h<max(from,to); ++h)
           34  +    {
           35  +     LL X1 = from;
           36  +     LL Y1 = heights[from];
           37  +     LL X2 = to;
           38  +     LL Y2 = heights[to];
           39  +     LL x = h;
           40  +     LL y = heights[h];
           41  +     // hide = (Y2-Y1)/(X2-X1)*(x-X1)+Y1 <= y
           42  +     if( X2-X1 > 0 ) {
           43  +      if( (Y2-Y1)*(x-X1) + Y1*(X2-X1) <= y * (X2-X1) )
           44  +       hidden = true;
           45  +     } else {
           46  +      if( (Y2-Y1)*(x-X1) + Y1*(X2-X1) >= y * (X2-X1) )
           47  +       hidden = true;
           48  +     }
           49  +    }
           50  +    if(!hidden) cnt++;
           51  +   }
           52  +   maxCnt = max(maxCnt, cnt);
           53  +  }
           54  +  return maxCnt;
           55  + }
           56  +};
           57  +
           58  +// BEGIN CUT HERE
           59  +#include <ctime>
           60  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           61  +
           62  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           63  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           64  +
           65  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           66  +char Test_(...);
           67  +int Test_(Case_<0>) {
           68  + int heights_[] = {10};
           69  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
           70  + int RetVal = 0;
           71  + return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
           72  +int Test_(Case_<1>) {
           73  + int heights_[] = {5,5,5,5};
           74  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
           75  + int RetVal = 2;
           76  + return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
           77  +int Test_(Case_<2>) {
           78  + int heights_[] = {1,2,7,3,2};
           79  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
           80  + int RetVal = 4;
           81  + return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
           82  +int Test_(Case_<3>) {
           83  + int heights_[] = {1,5,3,2,6,3,2,6,4,2,5,7,3,1,5};
           84  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
           85  + int RetVal = 7;
           86  + return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
           87  +int Test_(Case_<4>) {
           88  + int heights_[] = {1000000000,999999999,999999998,999999997,999999996,1,2,3,4,5};
           89  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
           90  + int RetVal = 6;
           91  + return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
           92  +int Test_(Case_<5>) {
           93  + int heights_[] = {244645169,956664793,752259473,577152868,605440232,569378507,111664772,653430457,454612157,397154317};
           94  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
           95  + int RetVal = 7;
           96  + return verify_case(RetVal, BestView().numberOfBuildings(heights)); }
           97  +
           98  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           99  +template<>      void Run_<-1>() {}
          100  +int main() { Run_<0>(); }
          101  +// END CUT HERE
          102  +

Added SRM/436/1B.cpp version [1b05819e2eb7f37b]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +bool w[500][500];
           21  +bool v[500][500];
           22  +
           23  +class DoNotTurn {
           24  +public:
           25  + int minimumTurns(int N, int X0, int A, int B, int Y0, int C, int D, int P, int M)
           26  + {
           27  +  // input
           28  +  memset(w, 0, sizeof w);
           29  +  memset(v, 0, sizeof v);
           30  +
           31  +  LL X=X0%P, Y=Y0%P;
           32  +  for(int i=1; i<=M; ++i)
           33  +  {
           34  +   if( !((X%N)==0 && (Y%N)==0 || (X%N)==N-1 && (Y%N)==N-1) )
           35  +    w[X%N][Y%N] = 1;
           36  +   X = (X*A+B) % P;
           37  +   Y = (Y*C+D) % P;
           38  +  }
           39  +
           40  +  // solve
           41  +  vector< pair<int,int> > Q(1, make_pair(0,0)); v[0][0]=1;
           42  +  for(int step=-1; !Q.empty(); ++step)
           43  +  {
           44  +   vector< pair<int,int> > Q2;
           45  +   for(int i=0; i<Q.size(); ++i)
           46  +   {
           47  +    int x = Q[i].first;
           48  +    int y = Q[i].second;
           49  +    if( x==N-1 && y==N-1 )
           50  +     return step;
           51  +
           52  +    int dx[] = {-1, +1, 0, 0};
           53  +    int dy[] = {0, 0, -1, +1};
           54  +    for(int d=0; d<4; ++d)
           55  +    {
           56  +     for(int k=1 ;; ++k) {
           57  +      int xx = x + dx[d]*k;
           58  +      int yy = y + dy[d]*k;
           59  +      if( xx<0 || N<=xx || yy<0 || N<=yy || w[xx][yy] )
           60  +       break;
           61  +      if( !v[xx][yy] ) {
           62  +       v[xx][yy] = true;
           63  +       Q2.push_back( make_pair(xx,yy) );
           64  +      }
           65  +     }
           66  +    }
           67  +   }
           68  +   Q.swap(Q2);
           69  +  }
           70  +  return -1;
           71  + }
           72  +};
           73  +
           74  +// BEGIN CUT HERE
           75  +#include <ctime>
           76  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           77  +
           78  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           79  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           80  +
           81  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           82  +char Test_(...);
           83  +int Test_(Case_<0>) {
           84  + int N = 2;
           85  + int X0 = 0;
           86  + int A = 0;
           87  + int B = 1;
           88  + int Y0 = 0;
           89  + int C = 0;
           90  + int D = 1;
           91  + int P = 10;
           92  + int M = 2;
           93  + int RetVal = 1;
           94  + return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
           95  +int Test_(Case_<1>) {
           96  + int N = 3;
           97  + int X0 = 0;
           98  + int A = 1;
           99  + int B = 1;
          100  + int Y0 = 1;
          101  + int C = 1;
          102  + int D = 0;
          103  + int P = 3;
          104  + int M = 3;
          105  + int RetVal = -1;
          106  + return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
          107  +int Test_(Case_<2>) {
          108  + int N = 3;
          109  + int X0 = 0;
          110  + int A = 1;
          111  + int B = 1;
          112  + int Y0 = 1;
          113  + int C = 1;
          114  + int D = 1;
          115  + int P = 3;
          116  + int M = 3;
          117  + int RetVal = 3;
          118  + return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
          119  +int Test_(Case_<3>) {
          120  + int N = 10;
          121  + int X0 = 911111;
          122  + int A = 845499;
          123  + int B = 866249;
          124  + int Y0 = 688029;
          125  + int C = 742197;
          126  + int D = 312197;
          127  + int P = 384409;
          128  + int M = 40;
          129  + int RetVal = 12;
          130  + return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
          131  +int Test_(Case_<4>) {
          132  + int N = 5;
          133  + int X0 = 23;
          134  + int A = 2;
          135  + int B = 3;
          136  + int Y0 = 35;
          137  + int C = 5;
          138  + int D = 7;
          139  + int P = 9;
          140  + int M = 3;
          141  + int RetVal = 2;
          142  + return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
          143  +int Test_(Case_<5>) {
          144  + int N = 2;
          145  + int X0 = 0;
          146  + int A = 0;
          147  + int B = 0;
          148  + int Y0 = 0;
          149  + int C = 0;
          150  + int D = 0;
          151  + int P = 1;
          152  + int M = 0;
          153  + int RetVal = 1;
          154  + return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
          155  +int Test_(Case_<6>) {
          156  + int N = 500;
          157  + int X0 = 0;
          158  + int A = 0;
          159  + int B = 0;
          160  + int Y0 = 0;
          161  + int C = 0;
          162  + int D = 0;
          163  + int P = 1;
          164  + int M = 0;
          165  + int RetVal = 1;
          166  + return verify_case(RetVal, DoNotTurn().minimumTurns(N, X0, A, B, Y0, C, D, P, M)); }
          167  +
          168  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          169  +template<>      void Run_<-1>() {}
          170  +int main() { Run_<0>(); }
          171  +// END CUT HERE
          172  +

Added SRM/436/1C.cpp version [eda6862a8c9a5383]

            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  +CMP tmp[65536*4];
           23  +
           24  +void fft_impl( CMP a[], int stride, int n, double Wt )
           25  +{
           26  + if( n > 1 )
           27  + {
           28  +  CMP *ev=a, *od=a+stride;
           29  +  int s2=stride*2, n2=n/2;
           30  +
           31  +  fft_impl( ev, s2, n2, Wt*2 );
           32  +  fft_impl( od, s2, n2, Wt*2 );
           33  +
           34  +  for(int i=0; i<n; ++i) tmp[i] = ev[s2*(i%n2)] + od[s2*(i%n2)]*polar(1.0,i*Wt);
           35  +  for(int i=0; i<n; ++i) a[stride*i] = tmp[i];
           36  + }
           37  +}
           38  +
           39  +void fft( vector<CMP>& a )
           40  +{
           41  + fft_impl(&a[0], 1, a.size(), +2*M_PI/a.size());
           42  +}
           43  +
           44  +void ifft( vector<CMP>& a )
           45  +{
           46  + fft_impl(&a[0], 1, a.size(), -2*M_PI/a.size());
           47  + for(int i=0; i<a.size(); ++i)
           48  +  a[i] /= a.size();
           49  +}
           50  +
           51  +class CircularShifts {
           52  +public:
           53  + int maxScore(int N, int Z0, int A, int B, int M)
           54  + {
           55  +  // input
           56  +  LL X[60000], Y[60000], Z=Z0%M;
           57  +  for(int i=0; i<N+N; ++i)
           58  +  {
           59  +   (i<N ? X[i] : Y[i-N]) = Z % 100;
           60  +   Z = (Z*A+B) % M;
           61  +  }
           62  +
           63  +  // solve
           64  +  int NN = 1;
           65  +  while( NN < N*2 ) NN*=2;
           66  +
           67  +  vector<CMP> CX(NN), CY(NN), CZ(NN);
           68  +  for(int i=0; i<N; ++i)
           69  +   CX[i]=CX[i+N]=X[N-i-1], CY[i]=Y[i];
           70  +
           71  +  fft(CX);
           72  +  fft(CY);
           73  +  transform( CX.begin(), CX.end(), CY.begin(), CZ.begin(), multiplies<CMP>() );
           74  +  ifft(CZ);
           75  +
           76  +  double m = 0;
           77  +  for(int i=0; i<NN; ++i)
           78  +   m = max(m, CZ[i].real());
           79  +  return int(m+0.5);
           80  + }
           81  +};
           82  +
           83  +// BEGIN CUT HERE
           84  +#include <ctime>
           85  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           86  +
           87  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           88  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           89  +
           90  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           91  +char Test_(...);
           92  +int Test_(Case_<0>) {
           93  + int N = 5;
           94  + int Z0 = 1;
           95  + int A = 1;
           96  + int B = 0;
           97  + int M = 13;
           98  + int RetVal = 5;
           99  + return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
          100  +int Test_(Case_<1>) {
          101  + int N = 4;
          102  + int Z0 = 1;
          103  + int A = 1;
          104  + int B = 1;
          105  + int M = 20;
          106  + int RetVal = 70;
          107  + return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
          108  +int Test_(Case_<2>) {
          109  + int N = 10;
          110  + int Z0 = 23;
          111  + int A = 11;
          112  + int B = 51;
          113  + int M = 4322;
          114  + int RetVal = 28886;
          115  + return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
          116  +int Test_(Case_<3>) {
          117  + int N = 1000;
          118  + int Z0 = 3252;
          119  + int A = 3458736;
          120  + int B = 233421;
          121  + int M = 111111111;
          122  + int RetVal = 2585408;
          123  + return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
          124  +int Test_(Case_<4>) {
          125  + int N = 141;
          126  + int Z0 = 96478;
          127  + int A = 24834;
          128  + int B = 74860;
          129  + int M = 92112;
          130  + int RetVal = 419992;
          131  + return verify_case(RetVal, CircularShifts().maxScore(N, Z0, A, B, M)); }
          132  +
          133  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          134  +template<>      void Run_<-1>() {}
          135  +int main() { Run_<0>(); }
          136  +// END CUT HERE
          137  +

Added SRM/437-U/1A.cpp version [570e3d3e6e5277ce]

            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  +template<typename D, typename S>
           23  +  D lexical_cast(const S& s) { D d; stringstream ss; ss<<s; ss>>d; return d; }
           24  +
           25  +class TheSwap {
           26  +public:
           27  + int findMax(int n, int k)
           28  + {
           29  +  set<string> canMake;
           30  +  canMake.insert( lexical_cast<string>(n) );
           31  +
           32  +  while( k --> 0 )
           33  +  {
           34  +   set<string> prev;
           35  +   prev.swap(canMake);
           36  +
           37  +   for(set<string>::iterator it=prev.begin(); it!=prev.end(); ++it)
           38  +   {
           39  +    string s = *it;
           40  +    for(int i=0; i<s.size(); ++i)
           41  +    for(int j=i+1; j<s.size(); ++j)
           42  +     if( !(i==0 && s[j]=='0') )
           43  +     {
           44  +      swap(s[i], s[j]);
           45  +      canMake.insert(s);
           46  +      swap(s[i], s[j]);
           47  +     }
           48  +   }
           49  +  }
           50  +
           51  +  return canMake.empty() ? -1 : lexical_cast<int>(*canMake.rbegin());
           52  + }
           53  +};
           54  +
           55  +// BEGIN CUT HERE
           56  +#include <ctime>
           57  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           58  +
           59  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           60  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           61  +
           62  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           63  +char Test_(...);
           64  +int Test_(Case_<0>) {
           65  + int n = 16375;
           66  + int k = 1;
           67  + int RetVal = 76315;
           68  + return verify_case(RetVal, TheSwap().findMax(n, k)); }
           69  +int Test_(Case_<1>) {
           70  + int n = 432;
           71  + int k = 1;
           72  + int RetVal = 423;
           73  + return verify_case(RetVal, TheSwap().findMax(n, k)); }
           74  +int Test_(Case_<2>) {
           75  + int n = 90;
           76  + int k = 4;
           77  + int RetVal = -1;
           78  + return verify_case(RetVal, TheSwap().findMax(n, k)); }
           79  +int Test_(Case_<3>) {
           80  + int n = 5;
           81  + int k = 2;
           82  + int RetVal = -1;
           83  + return verify_case(RetVal, TheSwap().findMax(n, k)); }
           84  +int Test_(Case_<4>) {
           85  + int n = 436659;
           86  + int k = 2;
           87  + int RetVal = 966354;
           88  + return verify_case(RetVal, TheSwap().findMax(n, k)); }
           89  +int Test_(Case_<5>) {
           90  + int n = 325664;
           91  + int k = 2;
           92  + int RetVal = 665324;
           93  + return verify_case(RetVal, TheSwap().findMax(n, k)); }
           94  +int Test_(Case_<6>) {
           95  + int n = 325664;
           96  + int k = 4;
           97  + int RetVal = 665432;
           98  + return verify_case(RetVal, TheSwap().findMax(n, k)); }
           99  +
          100  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          101  +template<>      void Run_<-1>() {}
          102  +int main() { Run_<0>(); }
          103  +// END CUT HERE
          104  +

Added SRM/437-U/1B.cpp version [fba485787235da94]

            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 TheInteger {
           23  +public:
           24  + long long find(long long n, int k)
           25  + {
           26  +  stringstream ss;
           27  +  ss << n;
           28  +  string s;
           29  +  ss >> s;
           30  +
           31  +  if( s.size() < k )
           32  +   s = string(k-s.size(), '0') + s;
           33  +
           34  +  LL a = solve(s, k);
           35  +  if( a )
           36  +   return a;
           37  +  return solve("0"+s, k);
           38  + }
           39  +
           40  + LL solve(string s, int k)
           41  + {
           42  +  // no change
           43  +  if( s[0] != '0' )
           44  +  {
           45  +   set<char> d;
           46  +   for(int i=0; i<s.size(); ++i)
           47  +    d.insert( s[i] );
           48  +   if( d.size() == k )
           49  +    return toll(s);
           50  +  }
           51  +
           52  +  // a-th digit larger
           53  +  int lim = s[0]=='0' ? 1 : s.size();
           54  +  for(int a=lim-1; a>=0; --a)
           55  +   for(char v=s[a]+1; v<='9'; ++v)
           56  +   {
           57  +    set<char> d;
           58  +    for(int i=0; i<a; ++i)
           59  +     d.insert(s[i]);
           60  +    d.insert(v);
           61  +    if( d.size() > k )
           62  +     continue;
           63  +    else if( d.size() == k )
           64  +    {
           65  +     s[a] = v;
           66  +     for(int i=a+1; i<s.size(); ++i)
           67  +      s[i] = *d.begin();
           68  +     return toll(s);
           69  +    }
           70  +    else
           71  +    {
           72  +     int rest = k - d.size();
           73  +     if( s.size()-a-1 < rest )
           74  +      continue;
           75  +     s[a] = v;
           76  +
           77  +     int fi = s.size()-rest;
           78  +
           79  +     for(int i=a+1; i<fi; ++i)
           80  +      s[i] = '0';
           81  +
           82  +     for(char z='0'; z<='9'; ++z)
           83  +      if( !d.count(z) )
           84  +      {
           85  +       s[fi++] = z;
           86  +       if( fi == s.size() )
           87  +        break;
           88  +      }
           89  +
           90  +     return toll(s);
           91  +    }
           92  +   }
           93  +  return 0;
           94  + }
           95  +
           96  + LL toll( string s )
           97  + {
           98  +  stringstream ss; ss << s;
           99  +  LL n; ss >> n;
          100  +  return n;
          101  + }
          102  +};
          103  +
          104  +// BEGIN CUT HERE
          105  +#include <ctime>
          106  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          107  +
          108  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          109  +int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          110  +
          111  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          112  +char Test_(...);
          113  +int Test_(Case_<0>) {
          114  + long long n = 47LL;
          115  + int k = 1;
          116  + long long RetVal = 55LL;
          117  + return verify_case(RetVal, TheInteger().find(n, k)); }
          118  +int Test_(Case_<1>) {
          119  + long long n = 7LL;
          120  + int k = 3;
          121  + long long RetVal = 102LL;
          122  + return verify_case(RetVal, TheInteger().find(n, k)); }
          123  +int Test_(Case_<2>) {
          124  + long long n = 69LL;
          125  + int k = 2;
          126  + long long RetVal = 69LL;
          127  + return verify_case(RetVal, TheInteger().find(n, k)); }
          128  +int Test_(Case_<3>) {
          129  + long long n = 12364LL;
          130  + int k = 3;
          131  + long long RetVal = 12411LL;
          132  + return verify_case(RetVal, TheInteger().find(n, k)); }
          133  +int Test_(Case_<4>) {
          134  + long long n = 1LL;
          135  + int k = 10;
          136  + long long RetVal = 1023456789LL;
          137  + return verify_case(RetVal, TheInteger().find(n, k)); }
          138  +int Test_(Case_<5>) {
          139  + long long n = 111111111111111LL;
          140  + int k = 10;
          141  + long long RetVal = 111111203456789LL;
          142  + return verify_case(RetVal, TheInteger().find(n, k)); }
          143  +int Test_(Case_<6>) {
          144  + long long n = 111111111111111LL;
          145  + int k = 8;
          146  + long long RetVal = 111111112034567LL;
          147  + return verify_case(RetVal, TheInteger().find(n, k)); }
          148  +int Test_(Case_<7>) {
          149  + long long n = 100000000000000LL;
          150  + int k = 10;
          151  + long long RetVal = 100000023456789LL;
          152  + return verify_case(RetVal, TheInteger().find(n, k)); }
          153  +int Test_(Case_<8>) {
          154  + long long n = 100000000000000LL;
          155  + int k = 5;
          156  + long long RetVal = 100000000000234LL;
          157  + return verify_case(RetVal, TheInteger().find(n, k)); }
          158  +
          159  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          160  +template<>      void Run_<-1>() {}
          161  +int main() { Run_<0>(); }
          162  +// END CUT HERE
          163  +

Added SRM/438-U/1A.cpp version [65e4989f51362500]

            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 UnluckyIntervals {
           23  +public:
           24  + vector <int> getLuckiest(vector <int> luckySet, int n)
           25  + {
           26  +  sort(luckySet.begin(), luckySet.end());
           27  +
           28  +  // zeros
           29  +  vector<int> luk = luckySet;
           30  +  for(LL i=0; i+1<luckySet.size(); ++i)
           31  +   if( i+1 < luckySet.size() )
           32  +    if( luckySet[i]+2 == luckySet[i+1] )
           33  +     luk.push_back( luckySet[i]+1 );
           34  +  if( luckySet[0]==2 )
           35  +   luk.push_back(1);
           36  +  sort(luk.begin(), luk.end());
           37  +  if( luk.size() >= n )
           38  +   return vector<int>(luk.begin(), luk.begin()+n);
           39  +
           40  +  // finites
           41  +  vector< pair<LL, LL> > luk_val;
           42  +  LL from = 1;
           43  +  for(int i=0; i<luckySet.size(); ++i)
           44  +  {
           45  +   LL to = luckySet[i]; // [from,to)
           46  +   if( from+2 <= to )
           47  +   {
           48  +    for(LL j=0; j<min<LL>(to-from,n); ++j) {
           49  +     LL val = (j%2==0 ? from+j/2 : to-1-j/2);
           50  +     LL unluk = (j/2+1) * (to-from-j/2) - 1;
           51  +     luk_val.push_back( make_pair(unluk,val) );
           52  +    }
           53  +   }
           54  +   from = luckySet[i]+1;
           55  +  }
           56  +  sort( luk_val.begin(), luk_val.end() );
           57  +  for(int i=0; i<luk_val.size(); ++i)
           58  +   luk.push_back(luk_val[i].second);
           59  +
           60  +  if( luk.size() >= n )
           61  +   return vector<int>(luk.begin(), luk.begin()+n);
           62  +
           63  +  // infinites
           64  +  int v = luckySet.back()+1;
           65  +  while( luk.size() < n )
           66  +   luk.push_back(v++);
           67  +  return luk;
           68  + }
           69  +};
           70  +
           71  +// BEGIN CUT HERE
           72  +#include <ctime>
           73  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           74  +
           75  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           76  +int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           77  +
           78  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           79  +char Test_(...);
           80  +int Test_(Case_<0>) {
           81  + int luckySet_[] = {3};
           82  +   vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_));
           83  + int n = 6;
           84  + int RetVal_[] = {3, 1, 2, 4, 5, 6 };
           85  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           86  + return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
           87  +int Test_(Case_<1>) {
           88  + int luckySet_[] = {5, 11, 18};
           89  +   vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_));
           90  + int n = 9;
           91  + int RetVal_[] = {5, 11, 18, 1, 4, 6, 10, 2, 3 };
           92  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           93  + return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
           94  +int Test_(Case_<2>) {
           95  + int luckySet_[] = {7, 13, 18};
           96  +   vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_));
           97  + int n = 9;
           98  + int RetVal_[] = {7, 13, 18, 14, 17, 8, 12, 1, 6 };
           99  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          100  + return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
          101  +int Test_(Case_<3>) {
          102  + int luckySet_[] = {1000, 1004, 4000, 4003, 5000};
          103  +   vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_));
          104  + int n = 19;
          105  + int RetVal_[] = {1000, 1004, 4000, 4003, 5000, 4001, 4002, 1001, 1003, 1002, 4004, 4999, 1, 999, 4005, 4998, 2, 998, 4006 };
          106  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          107  + return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
          108  +int Test_(Case_<4>) {
          109  + int luckySet_[] = {1000000000};
          110  +   vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_));
          111  + int n = 8;
          112  + int RetVal_[] = {1000000000, 1, 999999999, 2, 999999998, 3, 999999997, 4 };
          113  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          114  + return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
          115  +int Test_(Case_<5>) {
          116  + int luckySet_[] = {2};
          117  +   vector <int> luckySet(luckySet_, luckySet_+sizeof(luckySet_)/sizeof(*luckySet_));
          118  + int n = 1;
          119  + int RetVal_[] = {1};
          120  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          121  + return verify_case(RetVal, UnluckyIntervals().getLuckiest(luckySet, n)); }
          122  +
          123  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          124  +template<>      void Run_<-1>() {}
          125  +int main() { Run_<0>(); }
          126  +// END CUT HERE
          127  +

Added SRM/438-U/1B.cpp version [65a8b90d6a216ada]

            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  +string g_input;
           23  +string g_program;
           24  +LL g_num_d;
           25  +LL g_non_d;
           26  +
           27  +class EndlessStringMachine {
           28  +public:
           29  + string getFragment(string input, string program, int s_, int min_, int max_)
           30  + {
           31  +  LL s = s_;
           32  +  LL min = min_ - 1;
           33  +  LL max = max_;
           34  +
           35  +  int nd = 0, id = -1;
           36  +  for(int i=0; i!=program.size(); ++i)
           37  +   if( program[i]=='$' )
           38  +    ++nd, id=i;
           39  +
           40  +  if( nd == 0 )
           41  +  {
           42  +   string result;
           43  +   for(LL i=min; i<max; ++i)
           44  +    result += (i < program.size() ? program[i] : '-');
           45  +   return result;
           46  +  }
           47  +  else if( nd == 1 )
           48  +  {
           49  +   // output = program[..id]^s input program[id+1..]^s
           50  +   string L = program.substr(0, id);
           51  +   string C = input;
           52  +   string R = program.substr(id+1);
           53  +   string result;
           54  +   for(LL i=min; i<max; ++i)
           55  +    if( i < L.size()*s )
           56  +     result += L[i%L.size()];
           57  +    else if( i < L.size()*s + C.size() )
           58  +     result += C[i - L.size()*s];
           59  +    else if( i < L.size()*s + C.size() + R.size()*s )
           60  +     result += R[(i-L.size()*s-C.size()) % R.size()];
           61  +    else
           62  +     result += '-';
           63  +   return result;
           64  +  }
           65  +  else
           66  +  {
           67  +   g_input = input;
           68  +   g_program = program;
           69  +   g_num_d = nd;
           70  +   g_non_d = program.size() - nd;
           71  +
           72  +   string result;
           73  +   for(int i=min; i<max; ++i)
           74  +    result += theChar(i, s);
           75  +   return result;
           76  +  }
           77  + }
           78  +
           79  + char theChar( LL i, LL s )
           80  + {
           81  +  if( s == 0 )
           82  +  {
           83  +   return ( i < g_input.size() ? g_input[i] : '-' );
           84  +  }
           85  +
           86  +  LL cur = 0;
           87  +  for(LL ip=0; ip<g_program.size(); ++ip)
           88  +  {
           89  +   if( g_program[ip]=='$' ) {
           90  +    LL len = theLen(s-1);
           91  +    if( cur<=i && i<cur+len )
           92  +    {
           93  +     i -= cur;
           94  +     LL theLevel = 0, lvLen = g_input.size();
           95  +     while( lvLen <= i )
           96  +      theLevel ++, lvLen = lvLen*g_num_d + g_non_d;
           97  +     return theChar(i, theLevel);
           98  +    }
           99  +    else
          100  +     cur += len;
          101  +   } else {
          102  +    if( cur == i )
          103  +     return g_program[ip];
          104  +    else
          105  +     cur += 1;
          106  +   }
          107  +  }
          108  +  return '-';
          109  + }
          110  +
          111  + LL theLen(LL s)
          112  + {
          113  +  if( s == 0 )
          114  +   return g_input.size();
          115  +  if( s > 32 )
          116  +   return 2000000000LL;
          117  +  LL pr = theLen(s-1);
          118  +  LL nx = pr*g_num_d + g_non_d;
          119  +  return min(2000000000LL, nx);
          120  + }
          121  +};
          122  +
          123  +// BEGIN CUT HERE
          124  +#include <ctime>
          125  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          126  +
          127  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          128  +int verify_case(const string &Expected, const string &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          129  +
          130  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          131  +char Test_(...);
          132  +int Test_(Case_<0>) {
          133  + string input = "a";
          134  + string program = "$meric$";
          135  + int s = 6;
          136  + int min = 1;
          137  + int max = 35;
          138  + string RetVal = "americamericamericamericamericameri";
          139  + return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
          140  +int Test_(Case_<1>) {
          141  + string input = "top";
          142  + string program = "$coder";
          143  + int s = 1;
          144  + int min = 1;
          145  + int max = 20;
          146  + string RetVal = "topcoder------------";
          147  + return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
          148  +int Test_(Case_<2>) {
          149  + string input = "abc";
          150  + string program = "$x$y$z$";
          151  + int s = 10;
          152  + int min = 30;
          153  + int max = 50;
          154  + string RetVal = "bcyabcxabcyabczabczab";
          155  + return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
          156  +int Test_(Case_<3>) {
          157  + string input = "xy";
          158  + string program = "$a$bb";
          159  + int s = 12;
          160  + int min = 5000;
          161  + int max = 5099;
          162  + string RetVal = "xybbbbaxyaxybbaxyaxybbbbbbbbaxyaxybbaxyaxybbbbaxyaxybbaxyaxybbbbbbaxyaxybbaxyaxybbbbaxyaxybbaxyaxybb";
          163  + return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
          164  +int Test_(Case_<4>) {
          165  + string input = "x";
          166  + string program = "$y$";
          167  + int s = 999999999;
          168  + int min = 5000;
          169  + int max = 5001;
          170  + string RetVal = "xx";
          171  + return verify_case(RetVal, EndlessStringMachine().getFragment(input, program, s, min, max)); }
          172  +
          173  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          174  +template<>      void Run_<-1>() {}
          175  +int main() { Run_<0>(); }
          176  +// END CUT HERE
          177  +

Added SRM/439-U/1A.cpp version [403128c17a6bd8b1]

            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 PouringWater {
           23  +public:
           24  + int nbits(int n) {
           25  +  int cnt = 0;
           26  +  while(n) {
           27  +   if(n&1) ++cnt;
           28  +   n>>=1;
           29  +  }
           30  +  return cnt;
           31  + }
           32  + int getMinBottles(int N, int K)
           33  + {
           34  +  for(int i=0;;++i)
           35  +   if( nbits(N+i) <= K )
           36  +    return i;
           37  + }
           38  +};
           39  +
           40  +// BEGIN CUT HERE
           41  +#include <ctime>
           42  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           43  +
           44  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           45  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           46  +
           47  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           48  +char Test_(...);
           49  +int Test_(Case_<0>) {
           50  + int N = 3;
           51  + int K = 1;
           52  + int RetVal = 1;
           53  + return verify_case(RetVal, PouringWater().getMinBottles(N, K)); }
           54  +int Test_(Case_<1>) {
           55  + int N = 13;
           56  + int K = 2;
           57  + int RetVal = 3;
           58  + return verify_case(RetVal, PouringWater().getMinBottles(N, K)); }
           59  +int Test_(Case_<2>) {
           60  + int N = 1000000;
           61  + int K = 5;
           62  + int RetVal = 15808;
           63  + return verify_case(RetVal, PouringWater().getMinBottles(N, K)); }
           64  +
           65  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           66  +template<>      void Run_<-1>() {}
           67  +int main() { Run_<0>(); }
           68  +// END CUT HERE
           69  +

Added SRM/439-U/1B.cpp version [286098999b75ba9e]

            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 PalindromePhrases {
           23  +public:
           24  + vector<string> W;
           25  + int N;
           26  + map<pair<int,string>, LL> memo1;
           27  + map<pair<int,string>, LL> memo2;
           28  + map<pair<int,string>, LL> memo3;
           29  + map<pair<int,string>, LL> memo4;
           30  + map<pair<int,string>, LL> memo5;
           31  +
           32  + string rev(string s)
           33  + {
           34  +  reverse(s.begin(), s.end());
           35  +  return s;
           36  + }
           37  +
           38  + bool prefix_all(const string& p, const string& a)
           39  + {
           40  +  return p.size() <= a.size() && equal(p.begin(), p.end(), a.begin());
           41  + }
           42  +
           43  + bool suffix_all(const string& p, const string& a)
           44  + {
           45  +  return p.size() <= a.size() && equal(p.begin(), p.end(), a.begin()+a.size()-p.size());
           46  + }
           47  +
           48  + long long getAmount(vector <string> words)
           49  + {
           50  +  W = words;
           51  +  N = W.size();
           52  +
           53  +  LL cnt = 0;
           54  +  for(int i=0; i<N; ++i)
           55  +  {
           56  +   int mask = (1<<N) - 1;
           57  +   mask &= ~ (1<<i);
           58  +
           59  +   cnt += rec_startpalin(mask, W[i]);
           60  +  }
           61  +  return cnt;
           62  + }
           63  +
           64  + LL rec_startpalin(int mask, const string& w) // #{ws | ws is palin}
           65  + {
           66  +  pair<int,string> key(mask, w);
           67  +  if( memo1.count(key) )
           68  +   return memo1[key];
           69  +
           70  +  string rw = rev(w);
           71  +
           72  +  LL cnt = 0;
           73  +  cnt += rec_end(mask, rw);
           74  +  for(int ov=1; ov<=w.size(); ++ov)
           75  +   if( w.substr(w.size()-ov) == rw.substr(0,ov) )
           76  +    cnt += exact(mask, rw.substr(ov));
           77  +  return memo1[key]=cnt;
           78  + }
           79  +
           80  + LL rec_endpalin(int mask, const string& w) // #{sw | sw is palin}
           81  + {
           82  +  pair<int,string> key(mask, w);
           83  +  if( memo4.count(key) )
           84  +   return memo4[key];
           85  +
           86  +  string rw = rev(w);
           87  +
           88  +  LL cnt = 0;
           89  +  cnt += rec(mask, rw);
           90  +  for(int ov=1; ov<=w.size(); ++ov)
           91  +   if( rw.substr(w.size()-ov) == w.substr(0,ov) )
           92  +    cnt += exact(mask, rw.substr(0,w.size()-ov));
           93  +  return memo4[key]=cnt;
           94  + }
           95  +
           96  + LL rec(int mask, const string& w) // #{ws | s is palin}
           97  + {
           98  +  pair<int,string> key(mask, w);
           99  +  if( memo2.count(key) )
          100  +   return memo2[key];
          101  +
          102  +  LL cnt = (w.empty() ? 1 : 0);
          103  +  for(int i=0; i<N; ++i)
          104  +   if( mask & (1<<i) )
          105  +   {
          106  +    if( prefix_all(W[i], w) )
          107  +     cnt += rec( mask &~ (1<<i),
          108  +      w.substr(W[i].size())
          109  +     );
          110  +    else if( prefix_all(w, W[i]) )
          111  +     cnt += rec_startpalin( mask &~ (1<<i),
          112  +      W[i].substr(w.size())
          113  +     );
          114  +   }
          115  +  return memo2[key]=cnt;
          116  + }
          117  +
          118  + LL rec_end(int mask, const string& w) // #{sw | s is palin}
          119  + {
          120  +  pair<int,string> key(mask, w);
          121  +  if( memo5.count(key) )
          122  +   return memo5[key];
          123  +
          124  +  LL cnt = (w.empty() ? 1 : 0);
          125  +  for(int i=0; i<N; ++i)
          126  +   if( mask & (1<<i) )
          127  +   {
          128  +    if( suffix_all(W[i], w) )
          129  +     cnt += rec_end( mask &~ (1<<i),
          130  +      w.substr(0,w.size()-W[i].size())
          131  +     );
          132  +    else if( suffix_all(w, W[i]) )
          133  +     cnt += rec_endpalin( mask &~ (1<<i),
          134  +      W[i].substr(0, W[i].size()-w.size())
          135  +     );
          136  +   }
          137  +  return memo5[key]=cnt;
          138  + }
          139  +
          140  + LL exact(int mask, const string& w) // # of ways to create w
          141  + {
          142  +  pair<int,string> key(mask, w);
          143  +  if( memo3.count(key) )
          144  +   return memo3[key];
          145  +
          146  +  LL cnt = (w.empty() ? 1 : 0);
          147  +  for(int i=0; i<N; ++i)
          148  +   if( mask & (1<<i) )
          149  +    if( prefix_all(W[i], w) )
          150  +     cnt += exact( mask &~ (1<<i), w.substr(W[i].size()) );
          151  +
          152  +  return memo3[key] = cnt;
          153  + }
          154  +
          155  +
          156  +};
          157  +
          158  +// BEGIN CUT HERE
          159  +#include <ctime>
          160  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          161  +
          162  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          163  +int verify_case(const long long &Expected, const long long &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          164  +
          165  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          166  +char Test_(...);
          167  +int Test_(Case_<0>) {
          168  + string words_[] = {"a","ba"};
          169  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          170  + long long RetVal = 2LL;
          171  + return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
          172  +int Test_(Case_<1>) {
          173  + string words_[] = {"ab","bcd","efg"};
          174  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          175  + long long RetVal = 0LL;
          176  + return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
          177  +int Test_(Case_<2>) {
          178  + string words_[] = {"a", "bba", "abb"};
          179  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          180  + long long RetVal = 7LL;
          181  + return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
          182  +int Test_(Case_<3>) {
          183  + string words_[] = {"aabccc", "ccbbca", "a", "acaabb", "aaa", "aab", "c", "babb", "aacaa", "b"};
          184  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          185  + long long RetVal = 47LL;
          186  + return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
          187  +int Test_(Case_<4>) {
          188  + string words_[] = {"a", "aa", "aaa"};
          189  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          190  + long long RetVal = 47LL;
          191  + return verify_case(RetVal, PalindromePhrases().getAmount(words)); }
          192  +
          193  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          194  +template<>      void Run_<-1>() {}
          195  +int main() { Run_<0>(); }
          196  +// END CUT HERE

Added SRM/440/1A.cpp version [40b011870ac59713]

            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 IncredibleMachine {
           23  +public:
           24  + double gravitationalAcceleration(vector <int> x, vector <int> y, int T)
           25  + {
           26  +  double gL = 0.0, gR = 1e+9;
           27  +  for(int i=0; i<100; ++i)
           28  +  {
           29  +   double gC = (gL + gR) / 2;
           30  +   double tC = est(x, y, gC);
           31  +   (tC < T ? gR : gL) = gC;
           32  +  }
           33  +  return gL;
           34  + }
           35  +
           36  + double est(const vector<int>& x, const vector<int>& y, double g)
           37  + {
           38  +  double v = 0.0;
           39  +  double tot_t = 0.0;
           40  +  for(int i=0; i+1<x.size(); ++i)
           41  +  {
           42  +   double v0 = v;
           43  +   double len = sqrt(double((x[i+1]-x[i])*(x[i+1]-x[i]) + (y[i+1]-y[i])*(y[i+1]-y[i])));
           44  +   double sin_alpha = (y[i]-y[i+1]) / len;
           45  +   double a = g * sin_alpha;
           46  +   // len = v0*t + 0.5a t^2
           47  +   // 0.5a t^2 + v0 t - len = 0
           48  +   double t = (-v0 + sqrt(v0*v0 + 2*a*len)) / a;
           49  +   v = v0 + a*t;
           50  +   tot_t += t;
           51  +  }
           52  +  return tot_t;
           53  + }
           54  +};
           55  +
           56  +// BEGIN CUT HERE
           57  +#include <ctime>
           58  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           59  +
           60  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           61  +int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           62  +
           63  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           64  +char Test_(...);
           65  +int Test_(Case_<0>) {
           66  + int x_[] = {0,6};
           67  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           68  + int y_[] = {100,22};
           69  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           70  + int T = 4;
           71  + double RetVal = 9.807692307692307;
           72  + return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
           73  +int Test_(Case_<1>) {
           74  + int x_[] = {0,26,100};
           75  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           76  + int y_[] = {50,26,24};
           77  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           78  + int T = 4;
           79  + double RetVal = 26.743031720603582;
           80  + return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
           81  +int Test_(Case_<2>) {
           82  + int x_[] = {0,7,8};
           83  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           84  + int y_[] = {10,6,0};
           85  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           86  + int T = 7;
           87  + double RetVal = 1.1076837407708007;
           88  + return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
           89  +int Test_(Case_<3>) {
           90  + int x_[] = {0,100};
           91  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           92  + int y_[] = {1,0};
           93  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           94  + int T = 1;
           95  + double RetVal = 20002;
           96  + return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
           97  +int Test_(Case_<4>) {
           98  + int x_[] = {0,1};
           99  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          100  + int y_[] = {100,0};
          101  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          102  + int T = 100;
          103  + double RetVal = 0.020002;
          104  + return verify_case(RetVal, IncredibleMachine().gravitationalAcceleration(x, y, T)); }
          105  +
          106  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          107  +template<>      void Run_<-1>() {}
          108  +int main() { Run_<0>(); }
          109  +// END CUT HERE
          110  +

Added SRM/440/1B.cpp version [3dfb717e5a03a7d8]

            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 dy[] = {-1,+1,0,0};
           23  +static const int dx[] = {0,0,-1,+1};
           24  +
           25  +class MazeWandering {
           26  +public:
           27  + double expectedTime(vector <string> maze)
           28  + {
           29  +  int Y = maze.size();
           30  +  int X = maze[0].size();
           31  +
           32  +  vector< vector<int> >  d(Y, vector<int>(X, -1));
           33  +  vector< pair<int,int> > q, Q;
           34  +
           35  +  for(int y=0; y<Y; ++y)
           36  +   for(int x=0; x<X; ++x)
           37  +    if( maze[y][x] == '*' ) {
           38  +     d[y][x] = 0;
           39  +     q.push_back( make_pair(y,x) );
           40  +     Q.push_back( make_pair(y,x) );
           41  +    }
           42  +
           43  +  for(int step=1; !q.empty(); ++step)
           44  +  {
           45  +   vector< pair<int,int> > q2;
           46  +   for(int j=0; j<q.size(); ++j)
           47  +   {
           48  +    int qy = q[j].first;
           49  +    int qx = q[j].second;
           50  +    for(int i=0; i<4; ++i)
           51  +    {
           52  +     int y = qy+dy[i], x = qx+dx[i];
           53  +     if( 0<=y && y<Y && 0<=x && x<X && maze[y][x]=='.' && d[y][x]==-1 )
           54  +     {
           55  +      d[y][x] = step;
           56  +      q2.push_back( make_pair(y,x) );
           57  +      Q.push_back( make_pair(y,x) );
           58  +     }
           59  +    }
           60  +   }
           61  +   q2.swap(q);
           62  +  }
           63  +
           64  +  vector< vector<int> > w(Y, vector<int>(X, 0));
           65  +  for(int j=Q.size()-1; j>0; --j)
           66  +  {
           67  +   int qy = Q[j].first;
           68  +   int qx = Q[j].second;
           69  +
           70  +   for(int i=0; i<4; ++i)
           71  +   {
           72  +    int y = qy+dy[i], x = qx+dx[i];
           73  +    if( 0<=y && y<Y && 0<=x && x<X && maze[y][x]!='X' && d[y][x] > d[qy][qx] )
           74  +     w[qy][qx] += w[y][x] + 1;
           75  +   }
           76  +  }
           77  +
           78  +  double esum = 0.0;
           79  +  vector< vector<double> >  e(Y, vector<double>(X, 0.0));
           80  +  for(int j=0; j<Q.size(); ++j)
           81  +  {
           82  +   int qy = Q[j].first;
           83  +   int qx = Q[j].second;
           84  +   if( d[qy][qx] > 0 )
           85  +   {
           86  +    for(int i=0; i<4; ++i)
           87  +    {
           88  +     int y = qy+dy[i], x = qx+dx[i];
           89  +     if( 0<=y && y<Y && 0<=x && x<X && maze[y][x]!='X' && d[y][x] < d[qy][qx] )
           90  +     {
           91  +      e[qy][qx] = e[y][x] + 1 + 2*w[qy][qx];
           92  +      esum += e[qy][qx];
           93  +      break;
           94  +     }
           95  +    }
           96  +   }
           97  +  }
           98  +  return esum / Q.size();
           99  + }
          100  +};
          101  +
          102  +// BEGIN CUT HERE
          103  +#include <ctime>
          104  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          105  +
          106  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          107  +int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          108  +
          109  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          110  +char Test_(...);
          111  +int Test_(Case_<0>) {
          112  + string maze_[] = {"*",
          113  + "."};
          114  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          115  + double RetVal = 0.5;
          116  + return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
          117  +int Test_(Case_<1>) {
          118  + string maze_[] = {"*.."};
          119  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          120  + double RetVal = 2.3333333333333335;
          121  + return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
          122  +int Test_(Case_<2>) {
          123  + string maze_[] = {"...",
          124  + "X*X",
          125  + "..."};
          126  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          127  + double RetVal = 4.857142857142857;
          128  + return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
          129  +int Test_(Case_<3>) {
          130  + string maze_[] = {".*.",
          131  + ".XX",
          132  + "..."};
          133  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          134  + double RetVal = 13.714285714285714;
          135  + return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
          136  +int Test_(Case_<4>) {
          137  + string maze_[] = {"*........",
          138  + "XXX.XXXX.",
          139  + ".XX.X....",
          140  + ".....XX.X"};
          141  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          142  + double RetVal = 167.2608695652174;
          143  + return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
          144  +int Test_(Case_<5>) {
          145  + string maze_[] = {"X*X"};
          146  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          147  + double RetVal = 0;
          148  + return verify_case(RetVal, MazeWandering().expectedTime(maze)); }
          149  +
          150  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          151  +template<>      void Run_<-1>() {}
          152  +int main() { Run_<0>(); }
          153  +// END CUT HERE
          154  +

Added SRM/440/1C.cpp version [29d8b3c8147890db]

            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 MODVAL = 1000000007;
           23  +
           24  +bool is_square_free(int n)
           25  +{
           26  + for(int p=2; p*p<=n; ++p)
           27  +  if( n%(p*p) == 0 )
           28  +   return false;
           29  + return true;
           30  +}
           31  +
           32  +static const int SP[] = {2,3,5,7,11,13,17,19}; // <= sqrt(N)
           33  +static const int SPN  = sizeof(SP)/sizeof(*SP);
           34  +
           35  +int small_prime_mask(int n)
           36  +{
           37  + int m = 0;
           38  + for(int i=0; i<SPN; ++i)
           39  +  if( n%SP[i] == 0 )
           40  +   m |= 1<<i;
           41  + return m;
           42  +}
           43  +
           44  +int big_prime_factor(int n)
           45  +{
           46  + for(int i=0; i<SPN; ++i)
           47  +  while( n%SP[i] == 0 )
           48  +   n /= SP[i];
           49  + return n;
           50  +}
           51  +
           52  +class SquareFreeSets {
           53  +public:
           54  + int countPerfect(int N, int K)
           55  + {
           56  +  // way[k][m] = # of ways to make a k-elem psf-set with small prime factors m
           57  +  int way[501][1<<SPN] = {};
           58  +  way[0][0] = 1;
           59  +
           60  +  for(int n=2; n<=N; ++n)
           61  +   if( is_square_free(n) )
           62  +    if( big_prime_factor(n) == 1 )
           63  +    {
           64  +     int mask = small_prime_mask(n);
           65  +     for(int k=K; k>=1; --k)
           66  +      for(int m=0; m<(1<<SPN); ++m)
           67  +       if( (m|mask) == m )
           68  +        way[k][m] = (way[k][m] + way[k-1][m&~mask]) % MODVAL;
           69  +    }
           70  +    else if( big_prime_factor(n) == n )
           71  +    {
           72  +     vector<int> mask;
           73  +     for(int p=1; n*p<=N; ++p)
           74  +      if( is_square_free(p) )
           75  +       mask.push_back( small_prime_mask(p) );
           76  +
           77  +     for(int k=K; k>=1; --k)
           78  +      for(int m=0; m<(1<<SPN); ++m)
           79  +       for(int j=0; j<mask.size(); ++j)
           80  +        if( (m|mask[j]) == m )
           81  +         way[k][m] = (way[k][m] + way[k-1][m&~mask[j]]) % MODVAL;
           82  +    }
           83  +
           84  +  // summing up
           85  +  int sum = 0;
           86  +  for(int k=1; k<=K; ++k)
           87  +   for(int m=0; m<(1<<SPN); ++m)
           88  +    sum = (sum + way[k][m]) % MODVAL;
           89  +  return sum;
           90  + }
           91  +};
           92  +
           93  +// BEGIN CUT HERE
           94  +#include <ctime>
           95  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           96  +
           97  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           98  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           99  +
          100  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          101  +char Test_(...);
          102  +int Test_(Case_<0>) {
          103  + int N = 5;
          104  + int K = 1;
          105  + int RetVal = 3;
          106  + return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
          107  +int Test_(Case_<1>) {
          108  + int N = 5;
          109  + int K = 2;
          110  + int RetVal = 6;
          111  + return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
          112  +int Test_(Case_<2>) {
          113  + int N = 5;
          114  + int K = 3;
          115  + int RetVal = 7;
          116  + return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
          117  +int Test_(Case_<3>) {
          118  + int N = 6;
          119  + int K = 3;
          120  + int RetVal = 9;
          121  + return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
          122  +int Test_(Case_<4>) {
          123  + int N = 28;
          124  + int K = 41;
          125  + int RetVal = 1599;
          126  + return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
          127  +int Test_(Case_<5>) {
          128  + int N = 500;
          129  + int K = 500;
          130  + int RetVal = 59964104;
          131  + return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
          132  +int Test_(Case_<6>) {
          133  + int N = 100;
          134  + int K = 1;
          135  + int RetVal = 60;
          136  + return verify_case(RetVal, SquareFreeSets().countPerfect(N, K)); }
          137  +
          138  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          139  +template<>      void Run_<-1>() {}
          140  +int main() { Run_<0>(); }
          141  +// END CUT HERE
          142  +

Added SRM/441-U/1A.cpp version [e8ca5f00584e6a13]

            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 PerfectPermutation { public:
           23  + int reorder(vector <int> P)
           24  + {
           25  +  vector<bool> used(P.size(), false);
           26  +
           27  +  int num_loop = 0;
           28  +  for(int i=0; i<P.size(); ++i)
           29  +   if( !used[i] ) {
           30  +    ++num_loop;
           31  +
           32  +    for(int p=i; !used[p]; p=P[p])
           33  +     used[p] = true;
           34  +   }
           35  +  return num_loop==1 ? 0 : num_loop;
           36  + }
           37  +};
           38  +
           39  +// BEGIN CUT HERE
           40  +#include <ctime>
           41  +double start_time; string timer()
           42  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           43  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           44  + { os << "{ ";
           45  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           46  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           47  +void verify_case(const int& Expected, const int& Received) {
           48  + bool ok = (Expected == Received);
           49  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           50  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           51  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           52  +#define END  verify_case(_, PerfectPermutation().reorder(P));}
           53  +int main(){
           54  +
           55  +CASE(0)
           56  + int P_[] = {2, 0, 1};
           57  +   vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_));
           58  + int _ = 0;
           59  +END
           60  +CASE(1)
           61  + int P_[] = {2, 0, 1, 4, 3};
           62  +   vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_));
           63  + int _ = 2;
           64  +END
           65  +CASE(2)
           66  + int P_[] = {2, 3, 0, 1};
           67  +   vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_));
           68  + int _ = 2;
           69  +END
           70  +CASE(3)
           71  + int P_[] = {0, 5, 3, 2, 1, 4};
           72  +   vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_));
           73  + int _ = 3;
           74  +END
           75  +CASE(4)
           76  + int P_[] = {4, 2, 6, 0, 3, 5, 9, 7, 8, 1};
           77  +   vector <int> P(P_, P_+sizeof(P_)/sizeof(*P_));
           78  + int _ = 5;
           79  +END
           80  +
           81  +}
           82  +// END CUT HERE

Added SRM/441-U/1B.cpp version [607f8314241c61a9]

            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 StrangeCountry { public:
           23  + int transform(vector <string> g)
           24  + {
           25  +  int nConn=g.size(), nEdge=0;
           26  +
           27  +  vector<int> uf(g.size(), -1); // union_find
           28  +  for(int x=0; x<g.size(); ++x)
           29  +  {
           30  +   if( g[x].find('Y')==-1 )
           31  +    return -1; // orphan
           32  +
           33  +   for(int y=x+1; y<g.size(); ++y)
           34  +    if( g[x][y]=='Y' ) {
           35  +     ++nEdge;
           36  +     int rx=x; while( uf[rx]>=0 ) rx=uf[rx];
           37  +     int ry=y; while( uf[ry]>=0 ) ry=uf[ry];
           38  +     if( rx != ry ) uf[rx]=ry, --nConn;
           39  +    }
           40  +  }
           41  +
           42  +  int redundant = nEdge - (g.size() - nConn);
           43  +  return redundant>=nConn-1 ? nConn-1 : -1;
           44  + }
           45  +};
           46  +
           47  +// BEGIN CUT HERE
           48  +#include <ctime>
           49  +double start_time; string timer()
           50  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           51  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           52  + { os << "{ ";
           53  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           54  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           55  +void verify_case(const int& Expected, const int& Received) {
           56  + bool ok = (Expected == Received);
           57  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           58  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           59  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           60  +#define END  verify_case(_, StrangeCountry().transform(g));}
           61  +int main(){
           62  +
           63  +CASE(0)
           64  + string g_[] = {"NY",
           65  + "YN"};
           66  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
           67  + int _ = 0;
           68  +END
           69  +CASE(1)
           70  + string g_[] = {"NYYNN",
           71  + "YNYNN",
           72  + "YYNNN",
           73  + "NNNNY",
           74  + "NNNYN"};
           75  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
           76  + int _ = 1;
           77  +END
           78  +CASE(2)
           79  + string g_[] = {"NYYNNNN",
           80  + "YNYNNNN",
           81  + "YYNNNNN",
           82  + "NNNNYYN",
           83  + "NNNYNYY",
           84  + "NNNYYNY",
           85  + "NNNNYYN"};
           86  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
           87  + int _ = 1;
           88  +END
           89  +CASE(3)
           90  + string g_[] = {"NYNYNNNNNNNN",
           91  + "YNYNNNNNNNNN",
           92  + "NYNYYNNNNNNN",
           93  + "YNYNNNNNNNNN",
           94  + "NNYNNYYNNNNN",
           95  + "NNNNYNYNNNNN",
           96  + "NNNNYYNNNNNN",
           97  + "NNNNNNNNYYNN",
           98  + "NNNNNNNYNYNN",
           99  + "NNNNNNNYYNNN",
          100  + "NNNNNNNNNNNY",
          101  + "NNNNNNNNNNYN"};
          102  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
          103  + int _ = 2;
          104  +END
          105  +CASE(4)
          106  + string g_[] = {"NYNNNN",
          107  + "YNYNNN",
          108  + "NYNYNN",
          109  + "NNYNNN",
          110  + "NNNNNY",
          111  + "NNNNYN"};
          112  +   vector <string> g(g_, g_+sizeof(g_)/sizeof(*g_));
          113  + int _ = -1;
          114  +END
          115  +
          116  +}
          117  +// END CUT HERE

Added SRM/442-U/1A.cpp version [0aeee53c2fe85791]

            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  +int nf(int n)
           23  +{
           24  + int c = 0;
           25  + for(int p=2; p*p<=n; ++p)
           26  +  if( n%p==0 )
           27  +   while(n%p==0)
           28  +    c++, n/=p;
           29  + return c + (n==1 ? 0 : 1);
           30  +}
           31  +
           32  +class Underprimes { public:
           33  + int howMany(int A, int B)
           34  + {
           35  +  int cnt = 0;
           36  +  for(int n=A; n<=B; ++n)
           37  +   if( nf(nf(n)) == 1 )
           38  +    ++cnt;
           39  +  return cnt;
           40  + }
           41  +};
           42  +
           43  +// BEGIN CUT HERE
           44  +#include <ctime>
           45  +double start_time; string timer()
           46  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           47  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           48  + { os << "{ ";
           49  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           50  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           51  +void verify_case(const int& Expected, const int& Received) {
           52  + bool ok = (Expected == Received);
           53  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           54  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           55  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           56  +#define END  verify_case(_, Underprimes().howMany(A, B));}
           57  +int main(){
           58  +
           59  +CASE(0)
           60  + int A = 2;
           61  + int B = 10;
           62  + int _ = 5;
           63  +END
           64  +CASE(1)
           65  + int A = 100;
           66  + int B = 105;
           67  + int _ = 2;
           68  +END
           69  +CASE(2)
           70  + int A = 17;
           71  + int B = 17;
           72  + int _ = 0;
           73  +END
           74  +CASE(3)
           75  + int A = 123;
           76  + int B = 456;
           77  + int _ = 217;
           78  +END
           79  +
           80  +}
           81  +// END CUT HERE

Added SRM/442-U/1B.cpp version [3917b4343fc07af5]

            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 BedroomFloor { public:
           23  + LL b[6];
           24  +
           25  + long long numberOfSticks(int x1, int y1, int x2, int y2)
           26  + {
           27  +  b[1] = b[2] = b[3] = b[4] = b[5] = 0;
           28  +
           29  +  devideX_and_count(x1, x2, y1, y2);
           30  +  return optimize();
           31  + }
           32  +
           33  + // utils
           34  + LL FLOOR(LL x) { return x/5*5; }
           35  + LL CEIL (LL x) { return FLOOR(x+4); }
           36  +
           37  + // counting routines
           38  + void devideX_and_count(LL x1, LL x2, LL y1, LL y2)
           39  + {
           40  +  if( FLOOR(x1) == FLOOR(x2) )
           41  +   devideY_and_count(x1, x2, y1, y2, 1);
           42  +  else
           43  +   devideY_and_count(         x1,    CEIL(x1), y1, y2, 1 ),
           44  +   devideY_and_count(   CEIL(x1),  CEIL(x1)+5, y1, y2, ((FLOOR(x2)-CEIL(x1))/5+1)/2 ),
           45  +   devideY_and_count( CEIL(x1)+5, CEIL(x1)+10, y1, y2, ((FLOOR(x2)-CEIL(x1))/5+0)/2 ),
           46  +   devideY_and_count(  FLOOR(x2),          x2, y1, y2, 1 );
           47  + }
           48  +
           49  + void devideY_and_count(LL x1, LL x2, LL y1, LL y2, LL rep)
           50  + {
           51  +  if( FLOOR(y1) == FLOOR(y2) )
           52  +   count(x1, x2, y1, y2, rep);
           53  +  else
           54  +   count(x1, x2,         y1,    CEIL(y1), rep),
           55  +   count(x1, x2,   CEIL(y1),  CEIL(y1)+5, rep*(((FLOOR(y2)-CEIL(y1))/5+1)/2) ),
           56  +   count(x1, x2, CEIL(y1)+5, CEIL(y1)+10, rep*(((FLOOR(y2)-CEIL(y1))/5+0)/2) ),
           57  +   count(x1, x2,  FLOOR(y2),         y2 , rep);
           58  + }
           59  +
           60  + void count(LL x1, LL x2, LL y1, LL y2, LL rep)
           61  + {
           62  +  if( x1/5%2 == y1/5%2 ) // is_horizontal
           63  +   b[x2-x1] += rep*(y2-y1);
           64  +  else
           65  +   b[y2-y1] += rep*(x2-x1);
           66  + }
           67  +
           68  + // compute minimum number of 1x5 blocks required (by greedily removing larger blocks)
           69  + LL optimize()
           70  + {
           71  +  LL total = 0;
           72  +  for(int K=6*6*6*6*6; --K>0; )
           73  +  {
           74  +   int k[] = {-1, K%6, K/6%6, K/6/6%6, K/6/6/6%6, K/6/6/6/6%6};
           75  +   if( 1*k[1] + 2*k[2] + 3*k[3] + 4*k[4] + 5*k[5] <= 5 )
           76  +   {
           77  +    LL n = 1LL<<62;
           78  +    for(int i=1; i<=5; ++i)
           79  +     if( k[i] )
           80  +      n = min(n, b[i]/k[i]);
           81  +    for(int i=1; i<=5; ++i)
           82  +     b[i] -= n*k[i];
           83  +    total += n;
           84  +   }
           85  +  }
           86  +  return total;
           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 long long& Expected, const long long& 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(_, BedroomFloor().numberOfSticks(x1, y1, x2, y2));}
          104  +int main(){
          105  +
          106  +CASE(0)
          107  + int x1 = 0;
          108  + int y1 = 0;
          109  + int x2 = 5;
          110  + int y2 = 5;
          111  + long long _ = 5LL;
          112  +END
          113  +CASE(1)
          114  + int x1 = 0;
          115  + int y1 = 0;
          116  + int x2 = 10;
          117  + int y2 = 2;
          118  + long long _ = 5LL;
          119  +END
          120  +CASE(2)
          121  + int x1 = 2;
          122  + int y1 = 2;
          123  + int x2 = 8;
          124  + int y2 = 8;
          125  + long long _ = 12LL;
          126  +END
          127  +CASE(3)
          128  + int x1 = 8;
          129  + int y1 = 5;
          130  + int x2 = 20;
          131  + int y2 = 16;
          132  + long long _ = 27LL;
          133  +END
          134  +CASE(4)
          135  + int x1 = 0;
          136  + int y1 = 0;
          137  + int x2 = 1000000;
          138  + int y2 = 1000000;
          139  + long long _ = 200000000000LL;
          140  +END
          141  +CASE(5)
          142  + int x1 = 1;
          143  + int y1 = 4;
          144  + int x2 = 20;
          145  + int y2 = 19;
          146  + long long _ = 58LL;
          147  +END
          148  +CASE(5)
          149  + int x1 = 49;
          150  + int y1 = 51;
          151  + int x2 = 64;
          152  + int y2 = 70;
          153  + long long _ = 58LL;
          154  +END
          155  +
          156  +}
          157  +// END CUT HERE

Added SRM/442-U/1C-U.cpp version [e2301b523ba75830]

            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 NowhereLand { public:
           23  + int placeGuards(vector <string> cities, int k, vector <string> guards, vector <string> agencies)
           24  + {
           25  +  int mc = 0;
           26  +  for(int gid=0; gid<k; ++gid)
           27  +   mc += minimizeConflict(cities, guards, agencies, gid);
           28  +  return mc;
           29  + }
           30  +
           31  + int minimizeConflict(vector<string>& C, vector<string>& G_, vector<string>& A_, int gid)
           32  + {
           33  +  vector<bool> G(C.size());
           34  +  vector<bool> A(C.size());
           35  +  for(int i=0; i<C.size(); ++i)
           36  +  {
           37  +   { stringstream sin(G_[i]);
           38  +     for(int g; sin>>g; ) if(g==gid) G[i] = true; }
           39  +   { stringstream sin(A_[i]);
           40  +     for(int g; sin>>g; ) if(g==gid) A[i] = true; }
           41  +  }
           42  +  return -1;
           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 int& Expected, const int& 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(_, NowhereLand().placeGuards(cities, k, guards, agencies));}
           60  +int main(){
           61  +
           62  +CASE(0)
           63  + string cities_[] = { "0111",
           64  +  "1000",
           65  +  "1000",
           66  +  "1000" };
           67  +   vector <string> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
           68  + int k = 1;
           69  + string guards_[] = { "0", "", "", "" };
           70  +   vector <string> guards(guards_, guards_+sizeof(guards_)/sizeof(*guards_));
           71  + string agencies_[] = { "0", "0", "", "0" };
           72  +   vector <string> agencies(agencies_, agencies_+sizeof(agencies_)/sizeof(*agencies_));
           73  + int _ = 1;
           74  +END
           75  +CASE(1)
           76  + string cities_[] = { "011",
           77  +  "101",
           78  +  "110"  };
           79  +   vector <string> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
           80  + int k = 1;
           81  + string guards_[] = { "0", "", "" };
           82  +   vector <string> guards(guards_, guards_+sizeof(guards_)/sizeof(*guards_));
           83  + string agencies_[] = { "0", "", "" };
           84  +   vector <string> agencies(agencies_, agencies_+sizeof(agencies_)/sizeof(*agencies_));
           85  + int _ = 2;
           86  +END
           87  +CASE(2)
           88  + string cities_[] = { "011",
           89  +  "101",
           90  +  "110"  };
           91  +   vector <string> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
           92  + int k = 1;
           93  + string guards_[] = { "", "", "" } ;
           94  +   vector <string> guards(guards_, guards_+sizeof(guards_)/sizeof(*guards_));
           95  + string agencies_[] = { "0", "0", "0" };
           96  +   vector <string> agencies(agencies_, agencies_+sizeof(agencies_)/sizeof(*agencies_));
           97  + int _ = 0;
           98  +END
           99  +CASE(3)
          100  + string cities_[] = { "010100",
          101  +  "101100",
          102  +  "010011",
          103  +  "110010",
          104  +  "001100",
          105  +  "001000" };
          106  +   vector <string> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
          107  + int k = 3;
          108  + string guards_[] = { "1 2", "", "1", "", "0", "0" };
          109  +   vector <string> guards(guards_, guards_+sizeof(guards_)/sizeof(*guards_));
          110  + string agencies_[] = { "0 1 2", "0 1", "0 1 2", "1 2", "0", "0" };
          111  +   vector <string> agencies(agencies_, agencies_+sizeof(agencies_)/sizeof(*agencies_));
          112  + int _ = 7;
          113  +END
          114  +
          115  +}
          116  +// END CUT HERE

Added SRM/443-U/1A.cpp version [9e9e07b8082e082d]

            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 CirclesCountry { public:
           23  + int leastBorders(vector <int> X, vector <int> Y, vector <int> R, int x1, int y1, int x2, int y2)
           24  + {
           25  +  int cnt = 0;
           26  +  for(int i=0; i<X.size(); ++i)
           27  +   cnt += hypot(X[i]-x1, Y[i]-y1)<R[i] ^ hypot(X[i]-x2, Y[i]-y2)<R[i];
           28  +  return cnt;
           29  + }
           30  +};
           31  +
           32  +// BEGIN CUT HERE
           33  +#include <ctime>
           34  +double start_time; string timer()
           35  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           36  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           37  + { os << "{ ";
           38  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           39  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           40  +void verify_case(const int& Expected, const int& Received) {
           41  + bool ok = (Expected == Received);
           42  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           43  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           44  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           45  +#define END  verify_case(_, CirclesCountry().leastBorders(X, Y, R, x1, y1, x2, y2));}
           46  +int main(){
           47  +
           48  +CASE(0)
           49  + int X_[] = {0};
           50  +   vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_));
           51  + int Y_[] = {0};
           52  +   vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_));
           53  + int R_[] = {2};
           54  +   vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_));
           55  + int x1 = -5;
           56  + int y1 = 1;
           57  + int x2 = 5;
           58  + int y2 = 1;
           59  + int _ = 0;
           60  +END
           61  +CASE(1)
           62  + int X_[] = {0,-6,6};
           63  +   vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_));
           64  + int Y_[] = {0,1,2};
           65  +   vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_));
           66  + int R_[] = {2,2,2};
           67  +   vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_));
           68  + int x1 = -5;
           69  + int y1 = 1;
           70  + int x2 = 5;
           71  + int y2 = 1;
           72  + int _ = 2;
           73  +END
           74  +CASE(2)
           75  + int X_[] = {1,-3,2,5,-4,12,12};
           76  +   vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_));
           77  + int Y_[] = {1,-1,2,5,5,1,1};
           78  +   vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_));
           79  + int R_[] = {8,1,2,1,1,1,2};
           80  +   vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_));
           81  + int x1 = -5;
           82  + int y1 = 1;
           83  + int x2 = 12;
           84  + int y2 = 1;
           85  + int _ = 3;
           86  +END
           87  +CASE(3)
           88  + int X_[] = {-3,2,2,0,-4,12,12,12};
           89  +   vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_));
           90  + int Y_[] = {-1,2,3,1,5,1,1,1};
           91  +   vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_));
           92  + int R_[] = {1,3,1,7,1,1,2,3};
           93  +   vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_));
           94  + int x1 = 2;
           95  + int y1 = 3;
           96  + int x2 = 13;
           97  + int y2 = 2;
           98  + int _ = 5;
           99  +END
          100  +CASE(4)
          101  + int X_[] = {-107,-38,140,148,-198,172,-179,148,176,153,-56,-187};
          102  +   vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_));
          103  + int Y_[] = {175,-115,23,-2,-49,-151,-52,42,0,68,109,-174};
          104  +   vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_));
          105  + int R_[] = {135,42,70,39,89,39,43,150,10,120,16,8};
          106  +   vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_));
          107  + int x1 = 102;
          108  + int y1 = 16;
          109  + int x2 = 19;
          110  + int y2 = -108;
          111  + int _ = 3;
          112  +END
          113  +CASE(5)
          114  + int X_[] = {0};
          115  +   vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_));
          116  + int Y_[] = {0};
          117  +   vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_));
          118  + int R_[] = {2};
          119  +   vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_));
          120  + int x1 = -5;
          121  + int y1 = 1;
          122  + int x2 = 2;
          123  + int y2 = 2;
          124  + int _ = 0;
          125  +END
          126  +
          127  +}
          128  +// END CUT HERE

Added SRM/443-U/1B.cpp version [1096f6b690aa542d]

            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 BinaryFlips { public:
           23  + int minimalMoves(int A, int B, int K)
           24  + {
           25  +  vector<int> visitedUpto(A+B+1, -1);
           26  +  visitedUpto[B] = B;
           27  +
           28  +  // Breadth-first search from the initial state (A,B)
           29  +  queue< pair<int,int> > q;
           30  +  q.push( make_pair(B, 0) );
           31  +  while( !q.empty() )
           32  +  {
           33  +   // pop state (a,b)
           34  +   int b=q.front().first, a=A+B-b, step=q.front().second; q.pop();
           35  +
           36  +   // if (a,b) == (0,A+B), done
           37  +   if( b == A+B )
           38  +    return step;
           39  +
           40  +   // for all possible next values (nb) of b...
           41  +   int nb_min = abs(b-K), nb_max = A+B-abs(a-K);
           42  +   for(int nb=nb_min; nb<=nb_max; nb+=2)
           43  +    if( visitedUpto[nb] == -1 )
           44  +    {
           45  +     // if not visited, push the new state to the queue
           46  +     q.push( make_pair(nb, step+1) );
           47  +     visitedUpto[nb] = nb_max;
           48  +    }
           49  +    else
           50  +    {
           51  +     // if visited, skip it
           52  +     int nb2 = visitedUpto[nb];
           53  +     visitedUpto[nb] = max(visitedUpto[nb], nb_max);
           54  +     nb = nb2;
           55  +    }
           56  +  }
           57  +  return -1;
           58  + }
           59  +};
           60  +
           61  +// BEGIN CUT HERE
           62  +#include <ctime>
           63  +double start_time; string timer()
           64  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           65  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           66  + { os << "{ ";
           67  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           68  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           69  +void verify_case(const int& Expected, const int& Received) {
           70  + bool ok = (Expected == Received);
           71  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           72  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           73  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           74  +#define END  verify_case(_, BinaryFlips().minimalMoves(A, B, K));}
           75  +int main(){
           76  +
           77  +CASE(0)
           78  + int A = 3;
           79  + int B = 0;
           80  + int K = 3;
           81  + int _ = 1;
           82  +END
           83  +CASE(1)
           84  + int A = 4;
           85  + int B = 0;
           86  + int K = 3;
           87  + int _ = 4;
           88  +END
           89  +CASE(2)
           90  + int A = 4;
           91  + int B = 1;
           92  + int K = 3;
           93  + int _ = 2;
           94  +END
           95  +CASE(3)
           96  + int A = 3;
           97  + int B = 2;
           98  + int K = 5;
           99  + int _ = -1;
          100  +END
          101  +CASE(4)
          102  + int A = 100000;
          103  + int B = 100000;
          104  + int K = 578;
          105  + int _ = 174;
          106  +END
          107  +CASE(5)
          108  + int A = 0;
          109  + int B = 0;
          110  + int K = 1;
          111  + int _ = 0;
          112  +END
          113  +CASE(6)
          114  + int A = 4;
          115  + int B = 44;
          116  + int K = 50;
          117  + int _ = -1;
          118  +END
          119  +CASE(7)
          120  + int A = 11;
          121  + int B = 99995;
          122  + int K = 99999;
          123  + int _ = 14285;
          124  +END
          125  +CASE(8)
          126  + int A = 100000;
          127  + int B = 100000;
          128  + int K = 15781;
          129  + int _ = 8;
          130  +END
          131  +CASE(9)
          132  + int A = 7;
          133  + int B = 99128;
          134  + int K = 70613;
          135  + int _ = 5;
          136  +END
          137  +CASE(10)
          138  + int A = 45903;
          139  + int B = 89257;
          140  + int K = 98937;
          141  + int _ = 3;
          142  +END
          143  +CASE(11)
          144  + int A = 93851;
          145  + int B = 72517;
          146  + int K = 16031;
          147  + int _ = 7;
          148  +END
          149  +
          150  +}
          151  +// END CUT HERE

Added SRM/444/1A.cpp version [3aabd385e4b10b4a]

            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 UnfoldingTriangles { public:
           23  + int solve(vector <string> grid, int unfoldLimit)
           24  + {
           25  +  int X = grid[0].size();
           26  +  int Y = grid.size();
           27  +
           28  +  int Max = -1;
           29  +  // top-right
           30  +  for(int y=0; y<Y; ++y)
           31  +   for(int x=X; x>=1; --x)
           32  +   {
           33  +    int numTri = 0;
           34  +    // size
           35  +    for(int n=1; x-n>=0 && y+n<=Y; ++n)
           36  +    {
           37  +     // right-check
           38  +     if( x<X && grid[y+n-1][x]=='#' )
           39  +      goto NextTopRight;
           40  +     // diag-check
           41  +     if( grid[y+n-1][x-n]!='/' )
           42  +      goto NextTopRight;
           43  +     // inner-check
           44  +     for(int k=1; k<n; ++k) {
           45  +      if( grid[y+n-1][x-k] == '.' )
           46  +       goto NextTopRight;
           47  +      if( grid[y+n-1][x-k] == '/' )
           48  +       if( ++numTri > unfoldLimit )
           49  +        goto NextTopRight;
           50  +     }
           51  +     // bottom-check
           52  +     bool ok = true;
           53  +     if( y+n == Y )
           54  +      ok = true;
           55  +     else
           56  +      for(int k=1; k<=n; ++k) {
           57  +       if( grid[y+n][x-k] == '#' )
           58  +        {ok=false; break;}
           59  +      }
           60  +
           61  +     // update
           62  +     if( ok )
           63  +      Max = max( Max, n*(n+1)/2 );
           64  +    }
           65  +   NextTopRight:;
           66  +   }
           67  +
           68  +  return Max;
           69  + }
           70  +};
           71  +
           72  +// BEGIN CUT HERE
           73  +#include <ctime>
           74  +double start_time; string timer()
           75  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           76  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           77  + { os << "{ ";
           78  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           79  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           80  +void verify_case(const int& Expected, const int& Received) {
           81  + bool ok = (Expected == Received);
           82  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           83  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           84  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           85  +#define END  verify_case(_, UnfoldingTriangles().solve(grid, unfoldLimit));}
           86  +int main(){
           87  +
           88  +CASE(0)
           89  + string grid_[] = {".../",
           90  + "../#",
           91  + "./#/",
           92  + "/#//"};
           93  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
           94  + int unfoldLimit = 4;
           95  + int _ = 10;
           96  +END
           97  +CASE(1)
           98  + string grid_[] = {".../",
           99  + "../#",
          100  + "./#/",
          101  + "/#//"};
          102  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          103  + int unfoldLimit = 2;
          104  + int _ = 3;
          105  +END
          106  +CASE(2)
          107  + string grid_[] = {"////",
          108  + "////",
          109  + "////",
          110  + "////"};
          111  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          112  + int unfoldLimit = 5;
          113  + int _ = 6;
          114  +END
          115  +CASE(3)
          116  + string grid_[] = {".....#...",
          117  + "....###.."};
          118  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          119  + int unfoldLimit = 10;
          120  + int _ = -1;
          121  +END
          122  +CASE(4)
          123  + string grid_[] = {"#//#",
          124  + "#//#",
          125  + "####",
          126  + "///#"};
          127  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          128  + int unfoldLimit = 4;
          129  + int _ = 1;
          130  +END
          131  +CASE(5)
          132  + string grid_[] = {".../.../",
          133  + "../#..//",
          134  + "./.#.///",
          135  + "/###...."};
          136  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          137  + int unfoldLimit = 3;
          138  + int _ = 6;
          139  +END
          140  +CASE(6)
          141  + string grid_[] = {
          142  + "//////////////////////////////////////////////////",
          143  + "//////////////////////////////////////////////////",
          144  + "//////////////////////////////////////////////////",
          145  + "//////////////////////////////////////////////////",
          146  + "//////////////////////////////////////////////////",
          147  + "//////////////////////////////////////////////////",
          148  + "//////////////////////////////////////////////////",
          149  + "//////////////////////////////////////////////////",
          150  + "//////////////////////////////////////////////////",
          151  + "//////////////////////////////////////////////////",
          152  + "//////////////////////////////////////////////////",
          153  + "//////////////////////////////////////////////////",
          154  + "//////////////////////////////////////////////////",
          155  + "//////////////////////////////////////////////////",
          156  + "//////////////////////////////////////////////////",
          157  + "//////////////////////////////////////////////////",
          158  + "//////////////////////////////////////////////////",
          159  + "//////////////////////////////////////////////////",
          160  + "//////////////////////////////////////////////////",
          161  + "//////////////////////////////////////////////////",
          162  + "//////////////////////////////////////////////////",
          163  + "//////////////////////////////////////////////////",
          164  + "//////////////////////////////////////////////////",
          165  + "//////////////////////////////////////////////////",
          166  + "//////////////////////////////////////////////////",
          167  + "//////////////////////////////////////////////////",
          168  + "//////////////////////////////////////////////////",
          169  + "//////////////////////////////////////////////////",
          170  + "//////////////////////////////////////////////////",
          171  + "//////////////////////////////////////////////////",
          172  + "//////////////////////////////////////////////////",
          173  + "//////////////////////////////////////////////////",
          174  + "//////////////////////////////////////////////////",
          175  + "//////////////////////////////////////////////////",
          176  + "//////////////////////////////////////////////////",
          177  + "//////////////////////////////////////////////////",
          178  + "//////////////////////////////////////////////////",
          179  + "//////////////////////////////////////////////////",
          180  + "//////////////////////////////////////////////////",
          181  + "//////////////////////////////////////////////////",
          182  + "//////////////////////////////////////////////////",
          183  + "//////////////////////////////////////////////////",
          184  + "//////////////////////////////////////////////////",
          185  + "//////////////////////////////////////////////////",
          186  + "//////////////////////////////////////////////////",
          187  + "//////////////////////////////////////////////////",
          188  + "//////////////////////////////////////////////////",
          189  + "//////////////////////////////////////////////////",
          190  + "//////////////////////////////////////////////////",
          191  + "//////////////////////////////////////////////////",
          192  + };
          193  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          194  + int unfoldLimit = 2500;
          195  + int _ = 6;
          196  +END
          197  +
          198  +}
          199  +// END CUT HERE

Added SRM/444/1B.cpp version [2b2cc140266eef07]

            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  +int memo[1024][30];
           23  +
           24  +class FourBlocks { public:
           25  + int X, Y;
           26  + vector<string> G;
           27  + int maxScore(vector <string> grid)
           28  + {
           29  +  X = grid.size();
           30  +  Y = grid[0].size();
           31  +  G = grid;
           32  +
           33  +  // sentinels
           34  +  for(int x=0; x<X; ++x)
           35  +   G[x] += '0';
           36  +  G.push_back( string(Y+1,'0') );
           37  +
           38  +  int baseScore = 0;
           39  +  for(int x=0; x<X; ++x)
           40  +  for(int y=0; y<Y; ++y)
           41  +   baseScore += (G[x][y]=='1');
           42  +
           43  +  // memoized search
           44  +  memset(memo, 0xff, sizeof(memo));
           45  +  return baseScore + best(0);
           46  + }
           47  +
           48  + int best(int y)
           49  + {
           50  +  if( Y <= y )
           51  +   return 0;
           52  +
           53  +  int mask = 0;
           54  +  for(int x=0; x<X; ++x)
           55  +   mask |= ((G[x][y]=='.') << x);
           56  +  if( memo[mask][y] != -1 )
           57  +   return memo[mask][y];
           58  +  return memo[mask][y] = best(0, y);
           59  + }
           60  +
           61  + int best(int x, int y)
           62  + {
           63  +  if( X <= x )
           64  +   return best(y+1);
           65  +  int Max = 0;
           66  +  if( G[x][y]=='.' )
           67  +  {
           68  +   if( G[x+1][y]=='.' && G[x][y+1]=='.' && G[x+1][y+1]=='.' )
           69  +   {
           70  +    // can put 4
           71  +    G[x][y]=G[x+1][y]=G[x][y+1]=G[x+1][y+1] = '4';
           72  +    Max = max(Max, 16+best(x+2, y));
           73  +    G[x][y]=G[x+1][y]=G[x][y+1]=G[x+1][y+1] = '.';
           74  +   }
           75  +   // can put 1
           76  +   G[x][y] = '1';
           77  +   Max = max(Max, 1+best(x+1, y));
           78  +   G[x][y] = '.';
           79  +  }
           80  +  else
           81  +  {
           82  +   Max = max(Max, best(x+1, y));
           83  +  }
           84  +  return Max;
           85  + }
           86  +};
           87  +
           88  +// BEGIN CUT HERE
           89  +#include <ctime>
           90  +double start_time; string timer()
           91  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           92  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           93  + { os << "{ ";
           94  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           95  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           96  +void verify_case(const int& Expected, const int& Received) {
           97  + bool ok = (Expected == Received);
           98  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           99  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          100  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          101  +#define END  verify_case(_, FourBlocks().maxScore(grid));}
          102  +int main(){
          103  +
          104  +CASE(0)
          105  + string grid_[] = {".....1..1..",
          106  + "..1.....1.."};
          107  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          108  + int _ = 70;
          109  +END
          110  +CASE(1)
          111  + string grid_[] = {"...1.",
          112  + ".....",
          113  + ".1..1",
          114  + ".....",
          115  + "1...."};
          116  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          117  + int _ = 73;
          118  +END
          119  +CASE(2)
          120  + string grid_[] = {"...1.",
          121  + ".1...",
          122  + "..1.1",
          123  + "1...."};
          124  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          125  + int _ = 20;
          126  +END
          127  +CASE(3)
          128  + string grid_[] = {".....1...",
          129  + ".....1...",
          130  + "111111111",
          131  + ".....1...",
          132  + ".....1..."};
          133  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          134  + int _ = 117;
          135  +END
          136  +CASE(4)
          137  + string grid_[] = {".........................",
          138  + ".........................",
          139  + ".........................",
          140  + ".........................",
          141  + ".........................",
          142  + ".........................",
          143  + ".........................",
          144  + ".........................",
          145  + ".........................",
          146  + ".........................",
          147  + };
          148  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          149  + int _ = 117;
          150  +END
          151  +CASE(5)
          152  + string grid_[] = {
          153  + "1...", "....", "..11",
          154  + };
          155  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          156  + int _ = 36;
          157  +END
          158  +CASE(6)
          159  + string grid_[] = {
          160  + "1..", "...", "..1", "..1",
          161  + };
          162  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          163  + int _ = 36;
          164  +END
          165  +
          166  +}
          167  +// END CUT HERE

Added SRM/444/1C.cpp version [f7d0e00a6c0eeef7]

            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 LL MODVAL = 1000000007;
           23  +typedef vector< vector<LL> > matrix;
           24  +
           25  +vector<LL> vMul( const matrix& A, const vector<LL>& B )
           26  +{
           27  +  const int n = A.size();
           28  +
           29  +  vector<LL> C(n);
           30  +  for(int i=0; i<n; ++i)
           31  +    for(int j=0; j<n; ++j)
           32  +      C[i] = (C[i] + A[i][j] * B[j]) % MODVAL;
           33  +  return C;
           34  +}
           35  +
           36  +matrix mMul( const matrix& A, const matrix& B )
           37  +{
           38  +  const int n = A.size();
           39  +
           40  +  matrix C(n, vector<LL>(n));
           41  +  for(int i=0; i<n; ++i)
           42  +    for(int j=0; j<n; ++j) {
           43  +      LL Cij = 0;
           44  +      for(int k=0; k<n; ++k)
           45  +        Cij = (Cij + A[i][k] * B[k][j]) % MODVAL;
           46  +      C[i][j] = Cij;
           47  +    }
           48  +  return C;
           49  +}
           50  +
           51  +matrix mPow( matrix M, LL t ) // t>0
           52  +{
           53  +  matrix R;
           54  +  for(; t; t>>=1, M=mMul(M,M))
           55  +    if( t&1 )
           56  +      R = (R.empty() ? M : mMul(R,M));
           57  +  return R;
           58  +}
           59  +
           60  +LL GCD(LL a, LL b) { while(a) swap(b%=a,a); return b; }
           61  +LL LCM(LL a, LL b) { return a/GCD(a,b)*b; }
           62  +
           63  +class AvoidFour { public:
           64  +  int count(long long n)
           65  +  {
           66  +    matrix A(6, vector<LL>(6));
           67  +    A[1][0] = 8; A[1][1] = 9; A[1][2] = 9; A[1][3] = 9; A[1][4] = 9;
           68  +    A[2][0] = 1; A[2][1] = 1;
           69  +                              A[3][2] = 1;
           70  +                                           A[4][3] = 1;
           71  +                 A[5][1] = 1; A[5][2] = 1; A[5][3] = 1; A[5][4] = 1; A[5][5] = 1;
           72  +
           73  +    vector<LL> v(6);
           74  +    v[0] = 1;
           75  +
           76  +
           77  +    vector<LL> fours;
           78  +    for(LL f=44; f<=n; f=f*10+4)
           79  +      fours.push_back(f);
           80  +    int N = fours.size();
           81  +
           82  +    LL total = 0;
           83  +    for(int m=0; m<(1<<N); ++m)
           84  +    {
           85  +      LL lcm=1, bitCnt=0;
           86  +      for(int i=0; (1<<i)<=m; ++i)
           87  +        if( m & (1<<i) ) {
           88  +          lcm = LCM(lcm, fours[i]);
           89  +          if( lcm > n )
           90  +            break;
           91  +          bitCnt ++;
           92  +        }
           93  +      if( lcm <= n ) {
           94  +        matrix Af = mPow(A, lcm);
           95  +        Af[5] = A[5];
           96  +
           97  +        LL sub = vMul(mMul(A,mPow(Af,n/lcm)), v)[5];
           98  +        total = (bitCnt&1 ? total-sub+MODVAL : total+sub) % MODVAL;
           99  +      }
          100  +    }
          101  +    return total;
          102  +  }
          103  +};
          104  +
          105  +// BEGIN CUT HERE
          106  +#include <ctime>
          107  +double start_time; string timer()
          108  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          109  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          110  + { os << "{ ";
          111  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          112  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          113  +void verify_case(const int& Expected, const int& Received) {
          114  + bool ok = (Expected == Received);
          115  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          116  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          117  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          118  +#define END   verify_case(_, AvoidFour().count(n));}
          119  +int main(){
          120  +
          121  +CASE(0)
          122  +  long long n = 4LL;
          123  +  int _ = 9998;
          124  +END
          125  +CASE(1)
          126  +  long long n = 5LL;
          127  +  int _ = 99980;
          128  +END
          129  +CASE(2)
          130  +  long long n = 87LL;
          131  +  int _ = 576334228;
          132  +END
          133  +CASE(3)
          134  +  long long n = 88LL;
          135  +  int _ = 576334228;
          136  +END
          137  +CASE(4)
          138  +  long long n = 4128LL;
          139  +  int _ = 547731225;
          140  +END
          141  +
          142  +}
          143  +// END CUT HERE

Added SRM/445/1A.cpp version [fc75099a804bb837]

            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 TheNewHouseDivOne { public:
           23  + double distance(vector <int> x, vector <int> y, int k)
           24  + {
           25  +  double minD = 1e+99;
           26  +  for(double X=-50; X<=+50; X+=0.5)
           27  +   for(double Y=-50; Y<=+50; Y+=0.5)
           28  +   {
           29  +    vector<double> d;
           30  +    for(int i=0; i<x.size(); ++i)
           31  +     d.push_back( abs(x[i]-X) + abs(y[i]-Y) );
           32  +    nth_element(d.begin(), d.begin()+k-1, d.end());
           33  +    minD = min(minD, d[k-1]);
           34  +   }
           35  +  return minD;
           36  + }
           37  +};
           38  +
           39  +// BEGIN CUT HERE
           40  +#include <ctime>
           41  +double start_time; string timer()
           42  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           43  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           44  + { os << "{ ";
           45  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           46  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           47  +void verify_case(const double& Expected, const double& Received) {
           48  + double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 1e-9);
           49  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           50  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           51  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           52  +#define END  verify_case(_, TheNewHouseDivOne().distance(x, y, k));}
           53  +int main(){
           54  +
           55  +CASE(0)
           56  + int x_[] = {-1, -1, 1, 1};
           57  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           58  + int y_[] = {-1, 1, -1, 1};
           59  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           60  + int k = 3;
           61  + double _ = 2.0;
           62  +END
           63  +CASE(1)
           64  + int x_[] = {-1, -1, 1, 1};
           65  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           66  + int y_[] = {-1, 1, -1, 1};
           67  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           68  + int k = 2;
           69  + double _ = 1.0;
           70  +END
           71  +CASE(2)
           72  + int x_[] = {4, 4, 4, 4, 4, 3, 3, 5, 5};
           73  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           74  + int y_[] = {7, 7, 7, 4, 4, 5, 6, 5, 6};
           75  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           76  + int k = 9;
           77  + double _ = 1.5;
           78  +END
           79  +CASE(3)
           80  + int x_[] = {30, -15, 24, -23, 43, -8, -6, -47, 23, -11, 43, 6, -18, 44, -46, 16, 32, 31, 13, 9, 22, 25, 4, -44, 38, -41, -20, 41, -35, 7, 25, 39, -36, -20, -5, -38, -15, -22, 0};
           81  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           82  + int y_[] = {-45, -7, -33, 31, -8, -33, -20, -14, -50, -48, -31, 35, -24, -31, -11, 41, -41, -11, 46, -1, -5, 5, -39, -26, -40, -9, 16, 38, -30, 34, 46, -17, -27, 33, -38, 28, 46, -16, -46};
           83  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           84  + int k = 13;
           85  + double _ = 32.0;
           86  +END
           87  +
           88  +}
           89  +// END CUT HERE

Added SRM/445/1B.cpp version [299e5c03487b074c]

            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 TheLockDivOne { public:
           23  + string password(int n, long long k)
           24  + {
           25  +  --k;
           26  +  return lexlast(n-1, k);
           27  + }
           28  +
           29  + string kth(int i, LL k)
           30  + {
           31  +  if( i < 0 )
           32  +   return "";
           33  +
           34  +  if( k & (1LL<<i) )
           35  +   return "1" + kth(i-1, k==(1LL<<i) ? (1LL<<i)-1 : k-(1LL<<i)-1);
           36  +  else
           37  +   return "0" + kth(i-1, k);
           38  + }
           39  +
           40  + string lexlast(int i, LL k)
           41  + {
           42  +  if( i < 0 )
           43  +   return "";
           44  +
           45  +  if( k & (1LL<<i) ) {
           46  +   string a = kth(i-1, (1LL<<i)-1);
           47  +   if( k == (1LL<<i) )
           48  +    return "1" + a;
           49  +   string b = lexlast(i-1, k-(1LL<<i)-1);
           50  +   return "1" + max(a,b);
           51  +  }
           52  +  else
           53  +   return "0" + lexlast(i-1, k);
           54  + }
           55  +};
           56  +
           57  +// BEGIN CUT HERE
           58  +#include <ctime>
           59  +double start_time; string timer()
           60  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           61  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           62  + { os << "{ ";
           63  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           64  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           65  +void verify_case(const string& Expected, const string& Received) {
           66  + bool ok = (Expected == Received);
           67  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           68  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           69  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           70  +#define END  verify_case(_, TheLockDivOne().password(n, k));}
           71  +int main(){
           72  +
           73  +CASE(0)
           74  + int n = 2;
           75  + long long k = 4LL;
           76  + string _ = "11";
           77  +END
           78  +CASE(1)
           79  + int n = 3;
           80  + long long k = 8LL;
           81  + string _ = "111";
           82  +END
           83  +CASE(2)
           84  + int n = 4;
           85  + long long k = 6LL;
           86  + string _ = "0110";
           87  +END
           88  +CASE(3)
           89  + int n = 10;
           90  + long long k = 1LL;
           91  + string _ = "0000000000";
           92  +END
           93  +CASE(4)
           94  + int n = 7;
           95  + long long k = 100LL;
           96  + string _ = "1111110";
           97  +END
           98  +CASE(4)
           99  + int n = 50;
          100  + long long k = 0xffffffffffffLL;
          101  + string _ = "1111110";
          102  +END
          103  +
          104  +}
          105  +// END CUT HERE

Added SRM/445/1C.cpp version [b01c730886ab7aca]

            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  +#include <cctype>
           19  +using namespace std;
           20  +typedef long long LL;
           21  +typedef complex<double> CMP;
           22  +
           23  +static const LL MODVAL = 1234567891;
           24  +
           25  +class TheEncryptionDivOne { public:
           26  + map<vector<int>, LL> memo;
           27  +
           28  + int count(string msg, string encMsg)
           29  + {
           30  +  // accumulate unused characters
           31  +  char cs[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
           32  +  set<char> ori(cs+0, cs+52), enc(cs+0, cs+52);
           33  +  for(int i=0; i<msg.size(); ++i)
           34  +   ori.erase(msg[i]), enc.erase(encMsg[i]);
           35  +
           36  +  // obviously-invalid cases
           37  +  for(int i=0; i<msg.size(); ++i)
           38  +   if( toupper(msg[i]) == toupper(encMsg[i]) )
           39  +    return 0;
           40  +  if( ori.size() != enc.size() )
           41  +   return 0;
           42  +
           43  +  // count
           44  +  vector<int> s(9);
           45  +  for(char c='a'; c<='z'; ++c)
           46  +  {
           47  +   int oc = ori.count(c)+ori.count(c+'A'-'a');
           48  +   int ec = enc.count(c)+enc.count(c+'A'-'a');
           49  +   s[oc*3+ec] ++;
           50  +  }
           51  +  return rec(s);
           52  + }
           53  +
           54  + LL rec( const vector<int>& s )
           55  + {
           56  +  if( memo.count(s) )
           57  +   return memo[s];
           58  +
           59  +  for(int a=1; a<=2; ++a)
           60  +  for(int b=0; b<=2; ++b) if( s[a*3+b] )
           61  +  {
           62  +   LL val = 0;
           63  +   for(int c=0; c<=2; ++c)
           64  +   for(int d=1; d<=2; ++d) if( s[c*3+d] )
           65  +   {
           66  +    vector<int> t = s;
           67  +    t[a*3+b] --;
           68  +    if( LL choices = t[c*3+d]*d )
           69  +    {
           70  +     t[(a-1)*3+b] ++;
           71  +     t[c*3+d]     --;
           72  +     t[c*3+(d-1)] ++;
           73  +     val += choices * rec(t);
           74  +    }
           75  +   }
           76  +   return memo[s] = val%MODVAL;
           77  +  }
           78  +  return 1;
           79  + }
           80  +};
           81  +
           82  +// BEGIN CUT HERE
           83  +#include <ctime>
           84  +double start_time; string timer()
           85  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           86  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           87  + { os << "{ ";
           88  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           89  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           90  +void verify_case(const int& Expected, const int& Received) {
           91  + bool ok = (Expected == Received);
           92  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           93  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           94  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           95  +#define END  verify_case(_, TheEncryptionDivOne().count(msg, encMsg));}
           96  +int main(){
           97  +
           98  +CASE(0)
           99  + string msg = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX";
          100  + string encMsg = "cdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
          101  + int _ = 2;
          102  +END
          103  +CASE(1)
          104  + string msg = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX";
          105  + string encMsg = "bcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXY";
          106  + int _ = 1;
          107  +END
          108  +CASE(2)
          109  + string msg = "topcoder";
          110  + string encMsg = "TOPCODER";
          111  + int _ = 0;
          112  +END
          113  +CASE(3)
          114  + string msg = "thisisaveryhardproblem";
          115  + string encMsg = "nobodywillsolveittoday";
          116  + int _ = 0;
          117  +END
          118  +CASE(4)
          119  + string msg = "a";
          120  + string encMsg = "W";
          121  + int _ = 710479617;
          122  +END
          123  +CASE(5)
          124  + string msg    = "aMgqyMOaWSyaAxOyvOaRAEajOOAWWAqqAAj";
          125  + string encMsg = "qKYEnKaqMgnqGWanlaqkGdquaaGMMGEEGGu";
          126  + int _ = 650838813;
          127  +END
          128  +
          129  +}
          130  +// END CUT HERE

Added SRM/447-U/1A.cpp version [a89ac69a75cbec94]

            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 KnightsTour { public:
           23  + int visitedPositions(vector <string> board)
           24  + {
           25  +  // sentinels
           26  +  for(int yy=0; yy<board.size(); ++yy)
           27  +   board[yy] = "**"+board[yy]+"**";
           28  +  board.push_back( string(board[0].size(),'*') );
           29  +  board.push_back( string(board[0].size(),'*') );
           30  +  board.insert( board.begin(), string(board[0].size(),'*') );
           31  +  board.insert( board.begin(), string(board[0].size(),'*') );
           32  +
           33  +  // starting point
           34  +  int y, x;
           35  +  for(int yy=0; yy<board.size(); ++yy)
           36  +  for(int xx=0; xx<board[yy].size(); ++xx)
           37  +   if(board[yy][xx]=='K')
           38  +    y=yy, x=xx;
           39  +
           40  +  int n = 1;
           41  +  while( step(board,y,x) )
           42  +   ++n;
           43  +  return n;
           44  + }
           45  +
           46  + bool step(vector<string>& B, int& Y, int& X)
           47  + {
           48  +  int dy[]={-2,-2,-1,-1,+1,+1,+2,+2};
           49  +  int dx[]={-1,+1,-2,+2,-2,+2,-1,+1};
           50  +  int minAn = 9999;
           51  +  for(int i=0; i<8; ++i)
           52  +   if( B[Y+dy[i]][X+dx[i]] == '.' )
           53  +    minAn = min(minAn, an(B,Y+dy[i],X+dx[i]));
           54  +  if( minAn == 9999 )
           55  +   return false;
           56  +  for(int i=0; i<8; ++i)
           57  +   if( B[Y+dy[i]][X+dx[i]] == '.' )
           58  +    if( minAn == an(B,Y+dy[i],X+dx[i]) ) {
           59  +     Y+=dy[i];
           60  +     X+=dx[i];
           61  +     B[Y][X] = 'K';
           62  +     break;
           63  +    }
           64  +  return true;
           65  + }
           66  +
           67  + int an(vector<string>& B, int Y, int X)
           68  + {
           69  +  int dy[]={-2,-2,-1,-1,+1,+1,+2,+2};
           70  +  int dx[]={-1,+1,-2,+2,-2,+2,-1,+1};
           71  +  int cnt = 0;
           72  +  for(int i=0; i<8; ++i)
           73  +   cnt += (B[Y+dy[i]][X+dx[i]] == '.');
           74  +  return cnt;
           75  + }
           76  +};
           77  +
           78  +// BEGIN CUT HERE
           79  +#include <ctime>
           80  +double start_time; string timer()
           81  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           82  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           83  + { os << "{ ";
           84  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           85  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           86  +void verify_case(const int& Expected, const int& Received) {
           87  + bool ok = (Expected == Received);
           88  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           89  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           90  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           91  +#define END  verify_case(_, KnightsTour().visitedPositions(board));}
           92  +int main(){
           93  +
           94  +CASE(0)
           95  + string board_[] = {
           96  + "........"
           97  +,".*.*...."
           98  +,".*......"
           99  +,"..K...*."
          100  +,"*...*..."
          101  +,"...*...."
          102  +,"...*.*.."
          103  +,"........"};
          104  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          105  + int _ = 39;
          106  +END
          107  +CASE(1)
          108  + string board_[] = {
          109  + "K......."
          110  +,"........"
          111  +,"........"
          112  +,"........"
          113  +,"........"
          114  +,"........"
          115  +,"........"
          116  +,"........"};
          117  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          118  + int _ = 64;
          119  +END
          120  +CASE(2)
          121  + string board_[] = {
          122  + "********"
          123  +,"*******."
          124  +,"********"
          125  +,"**.***.*"
          126  +,"********"
          127  +,"***.*.**"
          128  +,"********"
          129  +,"****K***"};
          130  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          131  + int _ = 3;
          132  +END
          133  +CASE(3)
          134  + string board_[] = {
          135  + "*.*....*"
          136  +,".......*"
          137  +,"**...*.."
          138  +,"..***..."
          139  +,".**.*..."
          140  +,"..*.*..K"
          141  +,"..***.*."
          142  +,"**...*.."};
          143  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          144  + int _ = 17;
          145  +END
          146  +CASE(4)
          147  + string board_[] = {
          148  + "..*...*."
          149  +,"**.....*"
          150  +,"*..*...."
          151  +,"*..*...."
          152  +,".....*.."
          153  +,"....*..K"
          154  +,"**.*...*"
          155  +,"..**...."};
          156  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          157  + int _ = 27;
          158  +END
          159  +CASE(5)
          160  + string board_[] = {
          161  + "**.**"
          162  +,"K****"
          163  +,"**.**"
          164  +,"**.*."
          165  +};
          166  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          167  + int _ = 3;
          168  +END
          169  +
          170  +}
          171  +// END CUT HERE

Added SRM/447-U/1B.cpp version [89bd12ca6419d95a]

            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  +
           20  +typedef int           vert;
           21  +typedef vert          edge;
           22  +typedef vector<edge>  edges;
           23  +typedef vector<edges> graph;
           24  +
           25  +bool augment( graph& G, int v, vector<vert>& matchTo, bool visited[] )
           26  +{
           27  + for(int i=0; i<G[v].size(); ++i) {
           28  +  vert u = G[v][i];
           29  +  if( visited[u] ) continue;
           30  +  visited[u] = true;
           31  +
           32  +  if( matchTo[u]<0 || augment(G, matchTo[u], matchTo, visited) )
           33  +   { matchTo[v]=u, matchTo[u]=v; return true; }
           34  + }
           35  + return false;
           36  +}
           37  +
           38  +static const int NV = 100;
           39  +int biMatch( graph& G, int L ) // [0,L):left, [L,?):right
           40  +{
           41  + vector<vert> matchTo(G.size(), -1);
           42  + int ans = 0;
           43  + for(vert v=0; v<L; ++v) {
           44  +  bool visited[NV] = {};
           45  +  if( augment(G, v, matchTo, visited) )
           46  +   ++ans;
           47  + }
           48  + return ans;
           49  +}
           50  +
           51  +class PeopleYouMayKnow { public:
           52  + int maximalScore(vector <string> friends, int personA, int personB)
           53  + {
           54  +  int removed = 0;
           55  +
           56  +  // A-C-B : C must be removed
           57  +  int N = friends.size();
           58  +  int A = personA, B = personB;
           59  +  for(int C=0; C<N; ++C) if(C!=A && C!=B)
           60  +   if( friends[A][C]=='Y' && friends[C][B]=='Y' ) {
           61  +    removed ++;
           62  +    for(int D=0; D<N; ++D)
           63  +     friends[C][D] = friends[D][C] = 'N';
           64  +   }
           65  +
           66  +  // A-A1, B1-B : A1-B1 must be disconnected
           67  +  vector<int> A1;
           68  +  for(int C=0; C<N; ++C) if(C!=A && C!=B)
           69  +   if( friends[A][C]=='Y' )
           70  +    A1.push_back(C);
           71  +  vector<int> B1;
           72  +  for(int C=0; C<N; ++C) if(C!=A && C!=B)
           73  +   if( friends[C][B]=='Y' )
           74  +    B1.push_back(C);
           75  +
           76  +  // == bimatch
           77  +  graph G(A1.size()+B1.size());
           78  +  for(int a=0; a<A1.size(); ++a)
           79  +   for(int b=0; b<B1.size(); ++b)
           80  +    if( friends[A1[a]][B1[b]]=='Y' )
           81  +     G[a].push_back( A1.size()+b );
           82  +  return removed + biMatch(G, A1.size());
           83  + }
           84  +};
           85  +
           86  +// BEGIN CUT HERE
           87  +#include <ctime>
           88  +double start_time; string timer()
           89  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           90  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           91  + { os << "{ ";
           92  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           93  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           94  +void verify_case(const int& Expected, const int& Received) {
           95  + bool ok = (Expected == Received);
           96  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           97  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           98  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           99  +#define END  verify_case(_, PeopleYouMayKnow().maximalScore(friends, personA, personB));}
          100  +int main(){
          101  +
          102  +CASE(0)
          103  + string friends_[] = {"NN"
          104  +,"NN"};
          105  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          106  + int personA = 0;
          107  + int personB = 1;
          108  + int _ = 0;
          109  +END
          110  +CASE(1)
          111  + string friends_[] = {"NYNN"
          112  +,"YNYN"
          113  +,"NYNY"
          114  +,"NNYN"};
          115  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          116  + int personA = 0;
          117  + int personB = 3;
          118  + int _ = 1;
          119  +END
          120  +CASE(2)
          121  + string friends_[] = {"NYNYYYN"
          122  +,"YNYNNYY"
          123  +,"NYNNNNY"
          124  +,"YNNNNNN"
          125  +,"YNNNNYN"
          126  +,"YYNNYNY"
          127  +,"NYYNNYN"};
          128  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          129  + int personA = 2;
          130  + int personB = 3;
          131  + int _ = 1;
          132  +END
          133  +CASE(3)
          134  + string friends_[] = {"NYYYYNNNN"
          135  +,"YNNNNYYYN"
          136  +,"YNNNNNNYN"
          137  +,"YNNNNNNYN"
          138  +,"YNNNNNNNY"
          139  +,"NYNNNNNNY"
          140  +,"NYNNNNNNY"
          141  +,"NYYYNNNNY"
          142  +,"NNNNYYYYN"};
          143  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          144  + int personA = 8;
          145  + int personB = 0;
          146  + int _ = 3;
          147  +END
          148  +
          149  +}
          150  +// END CUT HERE

Added SRM/447-U/1C-U.cpp version [1ff60a30e59ecd0b]

            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 CellScores { public:
           23  + long long countScores(int N, int M, int K, int X0, int A, int B, int Y0, int C, int D)
           24  + {
           25  +  vector<int> X(M+K,X0%N), Y(M+K,Y0%N);
           26  +  for(int i=1; i<M+K; ++i)
           27  +   X[i] = (X[i-1]*A+B)%N,
           28  +   Y[i] = (Y[i-1]*C+D)%N;
           29  +
           30  +  vector< vector<bool> > black(N, vector<bool>(N, false));
           31  +  for(int i=0; i<M; ++i)
           32  +   black[Y[i]][X[i]] = true;
           33  +
           34  +  // how to compute them????
           35  +  vector< vector<int> > score_b(N, vector<int>(N, 0)); // # of gd rects around(Y,X) whose bottom line is y=Y+1
           36  +  vector< vector<int> > score_t(N, vector<int>(N, 0)); // top line is y=Y
           37  +  vector< vector<int> > score_l(N, vector<int>(N, 0)); // ...
           38  +  vector< vector<int> > score_r(N, vector<int>(N, 0));
           39  +
           40  +  // O(1) score computation
           41  +  vector< vector<int> > score(N, vector<int>(N, 0));
           42  +  score[0][0] = score_t[0][0];
           43  +  for(int x=1; x<N; ++x)
           44  +   score[0][x] = score[0][x-1] - score_r[0][x-x] + score_l[0][x];
           45  +  for(int y=1; y<N; ++y)
           46  +   for(int x=0; x<N; ++x)
           47  +    score[y][x] = score[y-1][x] - score_b[y-1][x] + score_t[y][x];
           48  +
           49  +  LL ss = 0;
           50  +  for(int i=M; i<M+K; ++i)
           51  +   ss += score[Y[i]][X[i]];
           52  +  return ss;
           53  + }
           54  +};
           55  +
           56  +// BEGIN CUT HERE
           57  +#include <ctime>
           58  +double start_time; string timer()
           59  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           60  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           61  + { os << "{ ";
           62  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           63  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           64  +void verify_case(const long long& Expected, const long long& Received) {
           65  + bool ok = (Expected == Received);
           66  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           67  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           68  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           69  +#define END  verify_case(_, CellScores().countScores(N, M, K, X0, A, B, Y0, C, D));}
           70  +int main(){
           71  +
           72  +CASE(0)
           73  + int N = 10;
           74  + int M = 0;
           75  + int K = 1;
           76  + int X0 = 0;
           77  + int A = 1;
           78  + int B = 1;
           79  + int Y0 = 0;
           80  + int C = 1;
           81  + int D = 1;
           82  + long long _ = 100LL;
           83  +END
           84  +CASE(1)
           85  + int N = 10;
           86  + int M = 1;
           87  + int K = 1;
           88  + int X0 = 5;
           89  + int A = 1;
           90  + int B = 5;
           91  + int Y0 = 5;
           92  + int C = 1;
           93  + int D = 5;
           94  + long long _ = 75LL;
           95  +END
           96  +CASE(2)
           97  + int N = 7;
           98  + int M = 4;
           99  + int K = 3;
          100  + int X0 = 0;
          101  + int A = 1;
          102  + int B = 1;
          103  + int Y0 = 0;
          104  + int C = 1;
          105  + int D = 1;
          106  + long long _ = 194LL;
          107  +END
          108  +CASE(3)
          109  + int N = 23;
          110  + int M = 10;
          111  + int K = 30;
          112  + int X0 = 26;
          113  + int A = 48;
          114  + int B = 76;
          115  + int Y0 = 231;
          116  + int C = 463;
          117  + int D = 707;
          118  + long long _ = 8088LL;
          119  +END
          120  +CASE(4)
          121  + int N = 211;
          122  + int M = 30;
          123  + int K = 12;
          124  + int X0 = 3;
          125  + int A = 35;
          126  + int B = 82;
          127  + int Y0 = 0;
          128  + int C = 43;
          129  + int D = 15;
          130  + long long _ = 18196443LL;
          131  +END
          132  +CASE(5)
          133  + int N = 3;
          134  + int M = 0;
          135  + int K = 100;
          136  + int X0 = 0;
          137  + int A = 0;
          138  + int B = 0;
          139  + int Y0 = 0;
          140  + int C = 0;
          141  + int D = 0;
          142  + long long _ = 900LL;
          143  +END
          144  +
          145  +}
          146  +// END CUT HERE

Added SRM/450-U/1A.cpp version [41eb9ab0d33a154b]

            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 OrderedNim { public:
           23  + string winner(vector <int> layout)
           24  + {
           25  +  bool firstWin = false;
           26  +  for(int i=layout.size()-1; i>=0; --i)
           27  +   if( layout[i] == 1 )
           28  +    firstWin = !firstWin;
           29  +   else
           30  +    firstWin = true;
           31  +  return firstWin ? "Alice" : "Bob";
           32  + }
           33  +};
           34  +
           35  +// BEGIN CUT HERE
           36  +#include <ctime>
           37  +double start_time; string timer()
           38  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           39  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           40  + { os << "{ ";
           41  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           42  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           43  +void verify_case(const string& Expected, const string& Received) {
           44  + bool ok = (Expected == Received);
           45  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           46  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           47  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           48  +#define END  verify_case(_, OrderedNim().winner(layout));}
           49  +int main(){
           50  +
           51  +CASE(0)
           52  + int layout_[] = {5};
           53  +   vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
           54  + string _ = "Alice";
           55  +END
           56  +CASE(1)
           57  + int layout_[] = {1,2};
           58  +   vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
           59  + string _ = "Bob";
           60  +END
           61  +CASE(2)
           62  + int layout_[] = {2,1};
           63  +   vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
           64  + string _ = "Alice";
           65  +END
           66  +CASE(3)
           67  + int layout_[] = {10,9,8,7,6,5,4,3,2,1};
           68  +   vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
           69  + string _ = "Alice";
           70  +END
           71  +CASE(4)
           72  + int layout_[] = {1,1,1,1};
           73  +   vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
           74  + string _ = "Bob";
           75  +END
           76  +CASE(5)
           77  + int layout_[] = {1};
           78  +   vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
           79  + string _ = "Alice";
           80  +END
           81  +CASE(6)
           82  + int layout_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
           83  +   vector <int> layout(layout_, layout_+sizeof(layout_)/sizeof(*layout_));
           84  + string _ = "Bob";
           85  +END
           86  +
           87  +}
           88  +// END CUT HERE

Added SRM/450-U/1B.cpp version [076d8405b22e14c4]

            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 StrongEconomy { public:
           23  +
           24  + long long earn(long long n, long long k, long long price, long long target)
           25  + {
           26  +  if( target/n < k )
           27  +   return 1;
           28  +
           29  +  LL best = target;
           30  +  for(LL money=0, round=0; round+1<best;)
           31  +  {
           32  +   // ‚±‚±‚©‚牽‚à‚µ‚È‚©‚Á‚½�ê�‡‚̃‰ƒEƒ“ƒh�”
           33  +   best = min(best, round + roundsNeededToEarn(target-money, n*k));
           34  +
           35  +   // (n,k) ‚ð‘�‚₹‚é—l‚É‚È‚é‚Ü‚Å‘Ò‚Â
           36  +   if( money < price )
           37  +   {
           38  +    LL rp = roundsNeededToEarn(price-money, n*k);
           39  +    round += rp;
           40  +    money += n*k*rp;
           41  +   }
           42  +
           43  +   // (n,k) ‚ð‘�‚₵‚Ä‚Ý‚é
           44  +   //   - ‚à‚¤‘�‚₳‚È‚¢•û‚ª‚¢‚¢‰Â”\�«‚Í�u‰½‚à‚µ‚È‚©‚Á‚½�ê�‡�v‚Å�l—¶�Ï‚Ý
           45  +   //   - �¡‘�‚₳‚¸Œã‚Å‘�‚â‚·•û‚ª‚¢‚¢�A‚Æ‚¢‚¤‚±‚Æ‚Í‚ ‚蓾‚È‚¢
           46  +   (n<k ? n : k)++;
           47  +   money -= price;
           48  +  }
           49  +  return best;
           50  + }
           51  +
           52  + LL roundsNeededToEarn(LL t, LL v)
           53  + {
           54  +  return (t-1)/v + 1;
           55  + }
           56  +};
           57  +
           58  +// BEGIN CUT HERE
           59  +#include <ctime>
           60  +double start_time; string timer()
           61  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           62  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           63  + { os << "{ ";
           64  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           65  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           66  +void verify_case(const long long& Expected, const long long& Received) {
           67  + bool ok = (Expected == Received);
           68  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           69  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           70  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           71  +#define END  verify_case(_, StrongEconomy().earn(n, k, price, target));}
           72  +int main(){
           73  +
           74  +CASE(0)
           75  + long long n = 2LL;
           76  + long long k = 1LL;
           77  + long long price = 2LL;
           78  + long long target = 10LL;
           79  + long long _ = 4LL;
           80  +END
           81  +CASE(1)
           82  + long long n = 2LL;
           83  + long long k = 1LL;
           84  + long long price = 2LL;
           85  + long long target = 9LL;
           86  + long long _ = 3LL;
           87  +END
           88  +CASE(2)
           89  + long long n = 1LL;
           90  + long long k = 1LL;
           91  + long long price = 500000LL;
           92  + long long target = 1000002LL;
           93  + long long _ = 1000001LL;
           94  +END
           95  +CASE(3)
           96  + long long n = 5LL;
           97  + long long k = 4LL;
           98  + long long price = 15LL;
           99  + long long target = 100LL;
          100  + long long _ = 5LL;
          101  +END
          102  +CASE(4)
          103  + long long n = 1000000000000LL;
          104  + long long k = 1000000000000LL;
          105  + long long price = 1000000000000LL;
          106  + long long target = 1000000000000LL;
          107  + long long _ = 1LL;
          108  +END
          109  +CASE(5)
          110  + long long n = 1LL;
          111  + long long k = 1LL;
          112  + long long price = 1000000000000LL;
          113  + long long target = 1000000000000LL;
          114  + long long _ = 1000000000000LL;
          115  +END
          116  +CASE(6)
          117  + long long n = 1LL;
          118  + long long k = 1LL;
          119  + long long price = 1LL;
          120  + long long target = 1000000000000LL;
          121  + long long _ = 8LL;
          122  +END
          123  +
          124  +}
          125  +// END CUT HERE

Added SRM/450-U/1C-U.cpp version [d0bfb26f428b0c51]

            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 RowGame { public:
           23  + long long score(vector <int> board, int k)
           24  + {
           25  +  int N = board.size();
           26  +  vector<LL> best(N, -1);
           27  +  best[0] = 0;
           28  +
           29  +  LL bestOfBest = 0;
           30  +  LL dif = -1, loopCnt = 0;
           31  +
           32  +  int dir=+1;
           33  +  for(int ki=0; ki<k; ++ki, dir=-dir)
           34  +  {
           35  +   vector<LL> best2(N, -1);
           36  +   for(int s=0; s<N; ++s)
           37  +    if( best[s] >= 0 )
           38  +    {
           39  +     LL sum = 0;
           40  +     for(int t=s; 0<=t && t<N; t+=dir) {
           41  +      sum += board[t];
           42  +      if( best[s]+sum >= 0 )
           43  +      best2[t] = max(best2[t], best[s]+sum);
           44  +     }
           45  +    }
           46  +   best.swap(best2);
           47  +   LL bb2 = max(bestOfBest, *max_element(best.begin(), best.end()));
           48  +   {
           49  +    if( bb2-bestOfBest == dif )
           50  +     ++loopCnt;
           51  +    else {
           52  +     loopCnt = 0;
           53  +     dif = bb2-bestOfBest;
           54  +    }
           55  +    if( loopCnt >= 2501 )
           56  +     return bestOfBest + dif*(k-ki);
           57  +   }
           58  +   bestOfBest = bb2;
           59  +  }
           60  +  return bestOfBest;
           61  + }
           62  +};
           63  +
           64  +// BEGIN CUT HERE
           65  +#include <ctime>
           66  +double start_time; string timer()
           67  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           68  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           69  + { os << "{ ";
           70  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           71  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           72  +void verify_case(const long long& Expected, const long long& Received) {
           73  + bool ok = (Expected == Received);
           74  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           75  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           76  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           77  +#define END  verify_case(_, RowGame().score(board, k));}
           78  +int main(){
           79  +
           80  +CASE(0)
           81  + int board_[] = {2,-2,4,3,-10} ;
           82  +   vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_));
           83  + int k = 3;
           84  + long long _ = 21LL;
           85  +END
           86  +CASE(1)
           87  + int board_[] = {-6,5};
           88  +   vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_));
           89  + int k = 10;
           90  + long long _ = 0LL;
           91  +END
           92  +CASE(2)
           93  + int board_[] = {5,-6};
           94  +   vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_));
           95  + int k = 10;
           96  + long long _ = 50LL;
           97  +END
           98  +CASE(3)
           99  + int board_[] = {10,-100,80};
          100  +   vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_));
          101  + int k = 3;
          102  + long long _ = 30LL;
          103  +END
          104  +CASE(4)
          105  + int board_[] = {10,-100,80};
          106  +   vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_));
          107  + int k = 4;
          108  + long long _ = 90LL;
          109  +END
          110  +CASE(5)
          111  + int board_[] = {-100,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
          112  +   vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_));
          113  + int k = 400000000;
          114  + long long _ = 41999999900LL;
          115  +END
          116  +/*
          117  +CASE(6)
          118  + int board_[] = ;
          119  +   vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_));
          120  + int k = ;
          121  + long long _ = LL;
          122  +END
          123  +CASE(7)
          124  + int board_[] = ;
          125  +   vector <int> board(board_, board_+sizeof(board_)/sizeof(*board_));
          126  + int k = ;
          127  + long long _ = LL;
          128  +END
          129  +*/
          130  +}
          131  +// END CUT HERE

Added SRM/451-U/1A.cpp version [5ddd5533b318ee93]

            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 MagicalSource { public:
           23  + long long calculate(long long x)
           24  + {
           25  +  LL d[] = {
           26  +   1LL,
           27  +   11LL,
           28  +   111LL,
           29  +   1111LL,
           30  +   11111LL,
           31  +   111111LL,
           32  +   1111111LL,
           33  +   11111111LL,
           34  +   111111111LL,
           35  +   1111111111LL,
           36  +   11111111111LL,
           37  +   111111111111LL,
           38  +   1111111111111LL,
           39  +  };
           40  +  int N = sizeof(d) / sizeof(*d);
           41  +  assert( d[N-1] > 1000000000000LL );
           42  +  for(int i=N-1; i>=0; --i)
           43  +   if( x%d[i] == 0 )
           44  +    return x/d[i];
           45  +  return x; // unreachable
           46  + }
           47  +};
           48  +
           49  +// BEGIN CUT HERE
           50  +#include <ctime>
           51  +double start_time; string timer()
           52  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           53  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           54  + { os << "{ ";
           55  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           56  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           57  +void verify_case(const long long& Expected, const long long& Received) {
           58  + bool ok = (Expected == Received);
           59  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           60  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           61  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           62  +#define END  verify_case(_, MagicalSource().calculate(x));}
           63  +int main(){
           64  +
           65  +CASE(0)
           66  + long long x = 1371110974LL;
           67  + long long _ = 1234LL;
           68  +END
           69  +CASE(1)
           70  + long long x = 111111LL;
           71  + long long _ = 1LL;
           72  +END
           73  +CASE(2)
           74  + long long x = 10989LL;
           75  + long long _ = 99LL;
           76  +END
           77  +CASE(3)
           78  + long long x = 120LL;
           79  + long long _ = 120LL;
           80  +END
           81  +CASE(4)
           82  + long long x = 109999999989LL;
           83  + long long _ = 99LL;
           84  +END
           85  +CASE(5)
           86  + long long x = 1LL;
           87  + long long _ = 1LL;
           88  +END
           89  +CASE(6)
           90  + long long x = 1000000000000LL;
           91  + long long _ = 1000000000000LL;
           92  +END
           93  +CASE(7)
           94  + long long x = 111111111111LL;
           95  + long long _ = 1LL;
           96  +END
           97  +CASE(8)
           98  + long long x = 123456654321LL;
           99  + long long _ = 111111LL;
          100  +END
          101  +CASE(9)
          102  + long long x = 12222221LL;
          103  + long long _ = 11LL;
          104  +END
          105  +
          106  +}
          107  +// END CUT HERE

Added SRM/451-U/1B.cpp version [179a24bc8356088b]

            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 BaronsAndCoins { public:
           23  + int getMaximum(vector <int> x, vector <int> y)
           24  + {
           25  +  vector< pair<int,int> > P;
           26  +  for(int i=0; i<x.size(); ++i)
           27  +   P.push_back( make_pair(y[i], x[i]) );
           28  +  P.push_back( make_pair(0, 0) );
           29  +  sort( P.begin(), P.end() );
           30  +
           31  +  return maxDepth(0, 0, P);
           32  + }
           33  +
           34  + map<pair<int,int>,int> memo;
           35  + int maxDepth( int i, int k, vector< pair<int,int> >& P )
           36  + {
           37  +  pair<int,int> key(i,k);
           38  +  if( memo.count(key) )
           39  +   return memo[key];
           40  +
           41  +  int md = 0;
           42  +  for(int j=i+1; j<P.size(); ++j)
           43  +  {
           44  +   int lk = leastReachK( P[j].first-P[i].first, P[j].second-P[i].second, k );
           45  +   if( lk > 0 )
           46  +    md = max(md, 1 + maxDepth(j, lk, P));
           47  +  }
           48  +  return memo[key] = md;
           49  + }
           50  +
           51  + int leastReachK( int dy, int dx, int k )
           52  + {
           53  +  if( dy <= 0 || dx <= 0 )
           54  +   return -1;
           55  +
           56  +  int minX = ((k+1)+(k+dy))*dy / 2;
           57  +  if( dx < minX )
           58  +   return -1;
           59  +
           60  +  int curK = k+dy;
           61  +  int rest = dx - minX;
           62  +  while( rest )
           63  +  {
           64  +   curK += rest / dy;
           65  +   rest %= dy;
           66  +   --dy;
           67  +  }
           68  +  return curK;
           69  + }
           70  +};
           71  +
           72  +// BEGIN CUT HERE
           73  +#include <ctime>
           74  +double start_time; string timer()
           75  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           76  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           77  + { os << "{ ";
           78  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           79  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           80  +void verify_case(const int& Expected, const int& Received) {
           81  + bool ok = (Expected == Received);
           82  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           83  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           84  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           85  +#define END  verify_case(_, BaronsAndCoins().getMaximum(x, y));}
           86  +int main(){
           87  +
           88  +CASE(0)
           89  + int x_[] = {15, 5, 30};
           90  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           91  + int y_[] = {4, 5, 6};
           92  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           93  + int _ = 2;
           94  +END
           95  +CASE(1)
           96  + int x_[] = {10};
           97  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           98  + int y_[] = {10};
           99  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          100  + int _ = 0;
          101  +END
          102  +CASE(2)
          103  + int x_[] = {1, 3, 6, 10, 15, 21};
          104  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          105  + int y_[] = {1, 2, 3, 4, 5, 6};
          106  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          107  + int _ = 6;
          108  +END
          109  +CASE(3)
          110  + int x_[] = {5, 10, 15, 20, 25, 30, 35, 40, 45};
          111  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          112  + int y_[] = {1, 1, 1, 2, 2, 2, 3, 3, 3};
          113  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          114  + int _ = 3;
          115  +END
          116  +CASE(4)
          117  + int x_[] = {1, 3, 6, 10, 22, 35, 50, 66};
          118  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          119  + int y_[] = {1, 2, 3, 1, 2, 3, 4, 5};
          120  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          121  + int _ = 5;
          122  +END
          123  +CASE(5)
          124  + int x_[] = {10};
          125  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          126  + int y_[] = {4};
          127  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          128  + int _ = 1;
          129  +END
          130  +CASE(6)
          131  + int x_[] = {9};
          132  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          133  + int y_[] = {4};
          134  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          135  + int _ = 0;
          136  +END
          137  +CASE(7)
          138  + int x_[] = {11};
          139  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          140  + int y_[] = {4};
          141  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          142  + int _ = 1;
          143  +END
          144  +CASE(8)
          145  + int x_[] = {1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,276,300,325,351,378,406,435,465,496,528,561,595,630,666,703,741,780,820,861,903,946,990,1035,1081,1128,1176,1225,1275};
          146  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          147  + int y_[] = {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,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
          148  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          149  + int _ = 50;
          150  +END
          151  +CASE(9)
          152  + int x_[] = {1,30,60,100,150,210,280,360,450,550,660,780,910,1050,1200,1360,1530,1710,1900,2100,2310,2530,2760,3000,3250,3510,3780,4060,4350,4650,4960,5280,5610,5950,6300,6660,7030,7410,7800,8200,8610,9030,9460,9900};
          153  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          154  + int y_[] = {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,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46};
          155  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          156  + int _ = 44;
          157  +END
          158  +CASE(10)
          159  + int x_[] = {999,3,15};
          160  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          161  + int y_[] = {1,2,3};
          162  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          163  + int _ = 2;
          164  +END
          165  +CASE(11)
          166  + int x_[] = {4,12,18};
          167  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          168  + int y_[] = {1,3,4};
          169  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          170  + int _ = 2;
          171  +END
          172  +
          173  +}
          174  +// END CUT HERE

Added SRM/452/1A.cpp version [a26c173c3d2bd17e]

            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 NotTwo { public:
           23  + int maxStones(int width, int height)
           24  + {
           25  +  return ms( (width+1)/2, (height+1)/2 )
           26  +   +  ms( (width+1)/2, height/2 )
           27  +   +  ms( width/2, (height+1)/2 )
           28  +   +  ms( width/2, height/2 );
           29  + }
           30  + int ms( int w, int h )
           31  + {
           32  +  return ((w+1)/2) * ((h+1)/2) + (w/2)*(h/2);
           33  + }
           34  +};
           35  +
           36  +// BEGIN CUT HERE
           37  +#include <ctime>
           38  +double start_time; string timer()
           39  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           40  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           41  + { os << "{ ";
           42  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           43  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           44  +void verify_case(const int& Expected, const int& Received) {
           45  + bool ok = (Expected == Received);
           46  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           47  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           48  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           49  +#define END  verify_case(_, NotTwo().maxStones(width, height));}
           50  +int main(){
           51  +
           52  +CASE(0)
           53  + int width = 3;
           54  + int height = 2;
           55  + int _ = 4;
           56  +END
           57  +CASE(1)
           58  + int width = 3;
           59  + int height = 3;
           60  + int _ = 5;
           61  +END
           62  +CASE(2)
           63  + int width = 8;
           64  + int height = 5;
           65  + int _ = 20;
           66  +END
           67  +CASE(3)
           68  + int width = 1;
           69  + int height = 1;
           70  + int _ = 1;
           71  +END
           72  +CASE(4)
           73  + int width = 1;
           74  + int height = 2;
           75  + int _ = 2;
           76  +END
           77  +CASE(5)
           78  + int width = 1;
           79  + int height = 3;
           80  + int _ = 2;
           81  +END
           82  +
           83  +}
           84  +// END CUT HERE

Added SRM/452/1B.cpp version [aa7e1a1a6f23a9b6]

            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  +LL MODVAL = 1000000007LL;
           23  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           24  +LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
           25  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           26  +LL POW(LL x, LL e) {
           27  + LL v = 1;
           28  + for(;e;x=MUL(x,x),e>>=1)
           29  +  if(e&1)
           30  +   v = MUL(v, x);
           31  + return v;
           32  +}
           33  +
           34  +class IOIString { public:
           35  + string  s;
           36  + LL nI, nQ;
           37  +
           38  + int countIOIs(vector <string> mask)
           39  + {
           40  +  s  = accumulate( mask.begin(), mask.end(), string("") );
           41  +  nI = count( s.begin(), s.end(), 'I' );
           42  +  nQ = count( s.begin(), s.end(), '?' );
           43  +
           44  +  return SUB( POW(2,nQ), non_IOI() );
           45  + }
           46  +
           47  + LL non_IOI()
           48  + {
           49  +  LL ans = 0;
           50  +  if( nI == 0 ) ans = ADD(ans,  1); // #I == 0
           51  +  if( nI == 0 ) ans = ADD(ans, nQ); // #I == 1
           52  +  if( nI == 1 ) ans = ADD(ans,  1); // #I == 1
           53  +  for(int D=1; D<s.size(); D+=2)
           54  +   for(int S=0; S<D; ++S)
           55  +    ans = ADD(ans, non_IOI_2(S, D)); // #I >= 2
           56  +  return ans;
           57  + }
           58  +
           59  + LL non_IOI_2( int S, int D )
           60  + {
           61  +  string t;
           62  +  for(int i=S; i<s.size(); i+=D)
           63  +   t += s[i];
           64  +
           65  +  // t ˆÈŠO‚Ì•”•ª‚Í‘S•” 'O' ‚Å‚È‚¢‚ƃ_ƒ�
           66  +  if( count(t.begin(), t.end(), 'I') < nI )
           67  +   return 0;
           68  +
           69  +  // t ‚Í /O*II+O*/ ‚Ƀ}ƒbƒ`‚µ‚È‚¢‚ƃ_ƒ��B4�ó‘Ԃ̃I�[ƒgƒ}ƒgƒ“‚ÅDP
           70  +  LL q0=1, q1=0, q2=0, q3=0;
           71  +  for(int i=0; i<t.size(); ++i)
           72  +  {
           73  +   LL p0 = (t[i]=='O' ?         q0 : t[i]=='I' ?          0 : q0);
           74  +   LL p1 = (t[i]=='O' ?          0 : t[i]=='I' ?         q0 : q0);
           75  +   LL p2 = (t[i]=='O' ?          0 : t[i]=='I' ? ADD(q1,q2) : ADD(q1,q2));
           76  +   LL p3 = (t[i]=='O' ? ADD(q2,q3) : t[i]=='I' ?          0 : ADD(q2,q3));
           77  +   q0=p0, q1=p1, q2=p2, q3=p3;
           78  +  }
           79  +  return ADD(q2, q3);
           80  + }
           81  +};
           82  +
           83  +// BEGIN CUT HERE
           84  +#include <ctime>
           85  +double start_time; string timer()
           86  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           87  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           88  + { os << "{ ";
           89  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           90  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           91  +void verify_case(const int& Expected, const int& Received) {
           92  + bool ok = (Expected == Received);
           93  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           94  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           95  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           96  +#define END  verify_case(_, IOIString().countIOIs(mask));}
           97  +int main(){
           98  +
           99  +CASE(0)
          100  + string mask_[] = {"IO?"};
          101  +   vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_));
          102  + int _ = 1;
          103  +END
          104  +CASE(1)
          105  + string mask_[] = {"????"};
          106  +   vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_));
          107  + int _ = 4;
          108  +END
          109  +CASE(2)
          110  + string mask_[] = {"?II"};
          111  +   vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_));
          112  + int _ = 0;
          113  +END
          114  +CASE(3)
          115  + string mask_[] = {"I??O??I"};
          116  +   vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_));
          117  + int _ = 16;
          118  +END
          119  +CASE(4)
          120  + string mask_[] = {"???I???????O???","???????????O??IO????????I???"};
          121  +   vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_));
          122  + int _ = 438952513;
          123  +END
          124  +CASE(5)
          125  + string mask_[] = {"?"};
          126  +   vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_));
          127  + int _ = 0;
          128  +END
          129  +CASE(6)
          130  + string mask_[] = {
          131  +"??????????????????????????????????????????????????",
          132  +"??????????????????????????????????????????????????",
          133  +"??????????????????????????????????????????????????",
          134  +"??????????????????????????????????????????????????",
          135  +"??????????????????????????????????????????????????",
          136  +"??????????????????????????????????????????????????",
          137  +"??????????????????????????????????????????????????",
          138  +"??????????????????????????????????????????????????",
          139  +"??????????????????????????????????????????????????",
          140  +"??????????????????????????????????????????????????",
          141  +"??????????????????????????????????????????????????",
          142  +"??????????????????????????????????????????????????",
          143  +"??????????????????????????????????????????????????",
          144  +"??????????????????????????????????????????????????",
          145  +"??????????????????????????????????????????????????",
          146  +"??????????????????????????????????????????????????",
          147  +"??????????????????????????????????????????????????",
          148  +"??????????????????????????????????????????????????",
          149  +"??????????????????????????????????????????????????",
          150  +"??????????????????????????????????????????????????",
          151  +"??????????????????????????????????????????????????",
          152  +"??????????????????????????????????????????????????",
          153  +"??????????????????????????????????????????????????",
          154  +"??????????????????????????????????????????????????",
          155  +"??????????????????????????????????????????????????",
          156  +"??????????????????????????????????????????????????",
          157  +"??????????????????????????????????????????????????",
          158  +"??????????????????????????????????????????????????",
          159  +"??????????????????????????????????????????????????",
          160  +"??????????????????????????????????????????????????",
          161  +"??????????????????????????????????????????????????",
          162  +"??????????????????????????????????????????????????",
          163  +"??????????????????????????????????????????????????",
          164  +"??????????????????????????????????????????????????",
          165  +"??????????????????????????????????????????????????",
          166  +"??????????????????????????????????????????????????",
          167  +"??????????????????????????????????????????????????",
          168  +"??????????????????????????????????????????????????",
          169  +"??????????????????????????????????????????????????",
          170  +"??????????????????????????????????????????????????",
          171  +"??????????????????????????????????????????????????",
          172  +"??????????????????????????????????????????????????",
          173  +"??????????????????????????????????????????????????",
          174  +"??????????????????????????????????????????????????",
          175  +"??????????????????????????????????????????????????",
          176  +"??????????????????????????????????????????????????",
          177  +"??????????????????????????????????????????????????",
          178  +"??????????????????????????????????????????????????",
          179  +"??????????????????????????????????????????????????",
          180  +"??????????????????????????????????????????????????",
          181  +};
          182  +   vector <string> mask(mask_, mask_+sizeof(mask_)/sizeof(*mask_));
          183  + int _ = 967087276;
          184  +END
          185  +}
          186  +// END CUT HERE

Added SRM/452/1C.cpp version [c255d7f6a0dc7167]

            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  +// mod ‰‰ŽZ—pƒ†�[ƒeƒBƒŠƒeƒB
           23  +LL MODVAL = 1000000007LL;
           24  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           25  +LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
           26  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           27  +LL POW(LL x, LL e) {
           28  +   LL v = 1;
           29  +   for(;e;x=MUL(x,x),e>>=1)
           30  +      if(e&1)
           31  +         v = MUL(v, x);
           32  +   return v;
           33  +}
           34  +LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
           35  +LL C(LL n, LL k) {
           36  +   LL v = 1;
           37  +   k = min(k, n-k);
           38  +   for(LL i=1; i<=k; ++i)
           39  +      v = DIV(MUL(v, n-i+1), i);
           40  +   return v;
           41  +}
           42  +
           43  +// –{‘Ì
           44  +class IncreasingNumber { public:
           45  +   int countNumbers(long long digits, int divisor)
           46  +   {
           47  +      LL  N = digits;
           48  +      int D = divisor;
           49  +
           50  +      //  ‚¿‚傤‚Ç N Œ…‚Ì Increasing number
           51  +      //��
           52  +      //  0<=ƒ°a<=8 ‚È a[] ‚ðŽg‚Á‚Ä
           53  +      //    1*a[0] + 11*a[1] + ... + 111..111*(a[N-1]+1)
           54  +      //  ‚ÌŒ`‚Å�‘‚¯‚é�”
           55  +      //
           56  +      //‚È‚Ì‚Å
           57  +      //
           58  +      //  D ‚ÅŠ„‚ê‚é‚¿‚傤‚Ç N Œ…‚Ì Increasing number ‚ÌŒÂ�”
           59  +      //��
           60  +      //  0<=ƒ°a<=8 ‚È a[] ‚Å
           61  +      //     coeff[0]*a[0] + coeff[1]*a[1] + ... + coeff[N-1]*(a[N-1]+1) = 0
           62  +      //  ‚È‚à‚Ì‚ÌŒÂ�” ( where coeff[i] := "1‚ªi+1ŒÂ•À‚ñ‚¾‚à‚Ì" % D )
           63  +
           64  +
           65  +      // ƒXƒe�[ƒW‚P
           66  +
           67  +      vector<LL> nc(D); // nc[m] = (coeff[i]%D==m ‚È i ‚Ì�”)
           68  +      int       ceLast; // coeff[N-1]
           69  +      {
           70  +         // coeff ‚Í�‚�X D ‰ñ‚Ń‹�[ƒv‚µ‚Ä‚é‚Í‚¸
           71  +         vector<int> coeff;
           72  +         int loop_start = -1;
           73  +         for(int v=1%D ;;)
           74  +         {
           75  +            loop_start = find(coeff.begin(), coeff.end(), v) - coeff.begin();
           76  +            if( loop_start != coeff.size() )
           77  +               break;
           78  +            coeff.push_back( v );
           79  +            v = (v*10 + 1) % D;
           80  +         }
           81  +         int loop_len = coeff.size() - loop_start;
           82  +
           83  +         for(int i=0; i<coeff.size() && i<N; ++i)
           84  +            if( i < loop_start )
           85  +               nc[coeff[i]] = 1;
           86  +            else
           87  +               nc[coeff[i]] = (N-i+loop_len-1)/loop_len % MODVAL;
           88  +         ceLast = N-1 < loop_start ? coeff[N-1]
           89  +                                   : coeff[(N-1-loop_start)%loop_len+loop_start];
           90  +      }
           91  +
           92  +
           93  +      // ƒXƒe�[ƒW1.5
           94  +
           95  +      vector< vector<LL> > choice(D, vector<LL>(9));
           96  +      for(int m=0; m<D; ++m)
           97  +         for(int n=0; n<=8; ++n)
           98  +            // nc[m] Ží—Þ‚Ì‚à‚Ì‚©‚ç n ŒÂŽæ‚éŽæ‚è•û
           99  +            choice[m][n] = (n==0 ? 1 : nc[m]==0 ? 0 : C(n+nc[m]-1, nc[m]-1));
          100  +
          101  +
          102  +      // ƒXƒe�[ƒW‚Q
          103  +      // dp[m][n][q] = —]‚è [0, 1, ... m] ŒW�”‚©‚ç n ŒÂŽg‚Á‚Ä‘�˜a‚ð—]‚è q ‚É‚·‚é‚â‚è•û‚͉½’Ê‚è�H
          104  +
          105  +      vector< vector< vector<LL> > > dp(D, vector< vector<LL> >(9, vector<LL>(D)));
          106  +      for(int m=0; m<D; ++m)
          107  +         dp[m][0][ceLast] = 1;
          108  +      for(int n=1; n<=8; ++n)
          109  +         dp[0][n][ceLast] = choice[0][n];
          110  +      for(int m=1; m<D; ++m)
          111  +         for(int n=1; n<=8; ++n)
          112  +            for(int q=0; q<D; ++q)
          113  +               for(int k=0,q2=q; k<=n; ++k,q2=(q2-m+D)%D)
          114  +                  dp[m][n][q] = ADD( dp[m][n][q], MUL( dp[m-1][n-k][q2], choice[m][k] ) );
          115  +
          116  +      LL ans = 0;
          117  +      for(int n=0; n<=8; ++n)
          118  +         ans = ADD(ans, dp[D-1][n][0]);
          119  +      return ans;
          120  +   }
          121  +};
          122  +
          123  +// BEGIN CUT HERE
          124  +#include <ctime>
          125  +double start_time; string timer()
          126  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          127  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          128  + { os << "{ ";
          129  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          130  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          131  +void verify_case(const int& Expected, const int& Received) {
          132  + bool ok = (Expected == Received);
          133  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          134  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          135  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          136  +#define END    verify_case(_, IncreasingNumber().countNumbers(digits, divisor));}
          137  +int main(){
          138  +CASE(-2)
          139  +   long long digits = 1LL;
          140  +   int divisor = 16;
          141  +   int _ = 0;
          142  +END
          143  +CASE(-1)
          144  +   long long digits = 1LL;
          145  +   int divisor = 1;
          146  +   int _ = 9;
          147  +END
          148  +CASE(0)
          149  +   long long digits = 2LL;
          150  +   int divisor = 12;
          151  +   int _ = 4;
          152  +END
          153  +CASE(1)
          154  +   long long digits = 3LL;
          155  +   int divisor = 111;
          156  +   int _ = 9;
          157  +END
          158  +CASE(2)
          159  +   long long digits = 452LL;
          160  +   int divisor = 10;
          161  +   int _ = 0;
          162  +END
          163  +CASE(3)
          164  +   long long digits = 6LL;
          165  +   int divisor = 58;
          166  +   int _ = 38;
          167  +END
          168  +CASE(4)
          169  +   long long digits = 1000000000000000000LL;
          170  +   int divisor = 500;
          171  +   int _ = 0;
          172  +END
          173  +CASE(5)
          174  +   long long digits = 26542766498659LL;
          175  +   int divisor = 25;
          176  +   int _ = 766312864;
          177  +END
          178  +}
          179  +// END CUT HERE

Added SRM/453.5/1A.cpp version [264b779c9b54203f]

            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 MazeMaker { public:
           23  + int longestPath(vector <string> maze, int startRow, int startCol, vector <int> moveRow, vector <int> moveCol)
           24  + {
           25  +  const int H = maze.size();
           26  +  const int W = maze[0].size();
           27  +
           28  +  typedef pair<int,int> point;
           29  +
           30  +  int cell = 0;
           31  +  for(int y=0; y<H; ++y)
           32  +   for(int x=0; x<W; ++x)
           33  +    if( maze[y][x] == '.' )
           34  +     ++cell;
           35  +
           36  +  vector<point> q(1, point(startRow, startCol));
           37  +  set<point> visited; visited.insert(q[0]);
           38  +
           39  +  for(int step=0 ;; ++step)
           40  +  {
           41  +   vector<point> q2;
           42  +   for(int i=0; i<q.size(); ++i)
           43  +    for(int j=0; j<moveRow.size(); ++j)
           44  +    {
           45  +     int yy = q[i].first+moveRow[j];
           46  +     int xx = q[i].second+moveCol[j];
           47  +     point pp( yy, xx );
           48  +     if( visited.count(pp) || yy<0 || H<=yy || xx<0 || W<=xx || maze[yy][xx]!='.' )
           49  +      continue;
           50  +     visited.insert(pp);
           51  +     q2.push_back(pp);
           52  +    }
           53  +   q.swap(q2);
           54  +
           55  +   if( q.empty() )
           56  +    return (visited.size()==cell ? step : -1);
           57  +  }
           58  +  assert(false);
           59  + }
           60  +};
           61  +
           62  +// BEGIN CUT HERE
           63  +#include <ctime>
           64  +double start_time; string timer()
           65  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           66  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           67  + { os << "{ ";
           68  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           69  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           70  +void verify_case(const int& Expected, const int& Received) {
           71  + bool ok = (Expected == Received);
           72  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           73  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           74  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           75  +#define END  verify_case(_, MazeMaker().longestPath(maze, startRow, startCol, moveRow, moveCol));}
           76  +int main(){
           77  +
           78  +CASE(0)
           79  + string maze_[] = {"...",
           80  + "...",
           81  + "..."};
           82  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
           83  + int startRow = 0;
           84  + int startCol = 1;
           85  + int moveRow_[] = {1,0,-1,0};
           86  +   vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_));
           87  + int moveCol_[] = {0,1,0,-1};
           88  +   vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_));
           89  + int _ = 3;
           90  +END
           91  +CASE(1)
           92  + string maze_[] = {"...",
           93  + "...",
           94  + "..."};
           95  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
           96  + int startRow = 0;
           97  + int startCol = 1;
           98  + int moveRow_[] = {1, 0, -1, 0, 1, 1, -1, -1};
           99  +   vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_));
          100  + int moveCol_[] = {0, 1, 0, -1, 1, -1, 1, -1};
          101  +   vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_));
          102  + int _ = 2;
          103  +END
          104  +CASE(2)
          105  + string maze_[] = {"X.X",
          106  + "...",
          107  + "XXX",
          108  + "X.X"};
          109  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          110  + int startRow = 0;
          111  + int startCol = 1;
          112  + int moveRow_[] = {1, 0, -1, 0};
          113  +   vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_));
          114  + int moveCol_[] = {0, 1, 0, -1};
          115  +   vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_));
          116  + int _ = -1;
          117  +END
          118  +CASE(3)
          119  + string maze_[] = {".......",
          120  + "X.X.X..",
          121  + "XXX...X",
          122  + "....X..",
          123  + "X....X.",
          124  + "......."};
          125  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          126  + int startRow = 5;
          127  + int startCol = 0;
          128  + int moveRow_[] = {1, 0, -1, 0,-2, 1};
          129  +   vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_));
          130  + int moveCol_[] = {0, -1, 0, 1, 3, 0};
          131  +   vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_));
          132  + int _ = 7;
          133  +END
          134  +CASE(4)
          135  + string maze_[] = {"......."};
          136  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          137  + int startRow = 0;
          138  + int startCol = 0;
          139  + int moveRow_[] = {1, 0, 1, 0, 1, 0};
          140  +   vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_));
          141  + int moveCol_[] = {0, 1, 0, 1, 0, 1};
          142  +   vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_));
          143  + int _ = 6;
          144  +END
          145  +CASE(5)
          146  + string maze_[] = {"..X.X.X.X.X.X."};
          147  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          148  + int startRow = 0;
          149  + int startCol = 0;
          150  + int moveRow_[] = {2,0,-2,0};
          151  +   vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_));
          152  + int moveCol_[] = {0,2,0,-2};
          153  +   vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_));
          154  + int _ = -1;
          155  +END
          156  +CASE(6)
          157  + string maze_[] = {".X","X."};
          158  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          159  + int startRow = 0;
          160  + int startCol = 0;
          161  + int moveRow_[] = {1};
          162  +   vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_));
          163  + int moveCol_[] = {1};
          164  +   vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_));
          165  + int _ = 1;
          166  +END
          167  +CASE(7)
          168  + string maze_[] = {".X","X."};
          169  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          170  + int startRow = 0;
          171  + int startCol = 0;
          172  + int moveRow_[] = {1};
          173  +   vector <int> moveRow(moveRow_, moveRow_+sizeof(moveRow_)/sizeof(*moveRow_));
          174  + int moveCol_[] = {0};
          175  +   vector <int> moveCol(moveCol_, moveCol_+sizeof(moveCol_)/sizeof(*moveCol_));
          176  + int _ = -1;
          177  +END
          178  +
          179  +}
          180  +// END CUT HERE

Added SRM/453.5/1B.cpp version [c3946bd33dff056f]

            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 PlanarGraphShop { public:
           23  + int bestCount(int N)
           24  + {
           25  +  set<int> possible;
           26  +  possible.insert(1*1*1 + 0*0);
           27  +  possible.insert(2*2*2 + 0*0);
           28  +  possible.insert(2*2*2 + 1*1);
           29  +  for(int V=3,EMax=3; V*V*V<=N; ++V,EMax+=3)
           30  +   for(int E=0; V*V*V+E*E<=N && E<=EMax; ++E)
           31  +    possible.insert(V*V*V + E*E);
           32  +  vector<int> p(possible.rbegin(), possible.rend());
           33  +
           34  +  vector<int> q(1, 0);
           35  +  vector<bool> visited(N+1);
           36  +  for(int step=0 ;; ++step)
           37  +  {
           38  +   vector<int> q2;
           39  +   for(int i=0; i!=q.size(); ++i)
           40  +   {
           41  +    if( q[i] == N )
           42  +     return step;
           43  +
           44  +    for(int j=0; j<p.size(); ++j)
           45  +    {
           46  +     int next = q[i] + p[j];
           47  +     if( next>N || visited[next] )
           48  +      continue;
           49  +     visited[next] = true;
           50  +     q2.push_back(next);
           51  +    }
           52  +   }
           53  +   q.swap(q2);
           54  +  }
           55  +  assert(false);
           56  + }
           57  +};
           58  +
           59  +// BEGIN CUT HERE
           60  +#include <ctime>
           61  +double start_time; string timer()
           62  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           63  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           64  + { os << "{ ";
           65  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           66  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           67  +void verify_case(const int& Expected, const int& Received) {
           68  + bool ok = (Expected == Received);
           69  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           70  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           71  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           72  +#define END  verify_case(_, PlanarGraphShop().bestCount(N));}
           73  +int main(){
           74  +
           75  +CASE(0)
           76  + int N = 36;
           77  + int _ = 1;
           78  +END
           79  +CASE(1)
           80  + int N = 7;
           81  + int _ = 7;
           82  +END
           83  +CASE(2)
           84  + int N = 72;
           85  + int _ = 2;
           86  +END
           87  +CASE(3)
           88  + int N = 46;
           89  + int _ = 3;
           90  +END
           91  +CASE(4)
           92  + int N = 50000;
           93  + int _ = -1;
           94  +END
           95  +CASE(5)
           96  + int N = 1;
           97  + int _ = 1;
           98  +END
           99  +}
          100  +// END CUT HERE

Added SRM/453.5/1C.cpp version [199b4b73c8055eff]

            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  +typedef long long LL;
           23  +LL gcd(LL a, LL b)
           24  +{
           25  +   while(a)
           26  +      swap(a, b%=a);
           27  +   return b;
           28  +}
           29  +
           30  +LL lcm(LL a, LL b)
           31  +{
           32  +   return a/gcd(a,b)*b;
           33  +}
           34  +
           35  +class TheAlmostLuckyNumbers { public:
           36  +   void genLuck(vector<LL>& v)
           37  +   {
           38  +      // lucky numbers
           39  +      vector<LL> u;
           40  +      for(int d=1; d<=10; ++d)
           41  +         genLuck(d, u);
           42  +
           43  +      // filtering
           44  +      for(int i=0; i<u.size(); ++i)
           45  +      {
           46  +         for(int j=0; j<i; ++j)
           47  +            if( u[i] % u[j] == 0 )
           48  +               goto next;
           49  +         v.push_back( u[i] );
           50  +      next:;
           51  +      }
           52  +      sort(v.begin(), v.end());
           53  +   }
           54  +
           55  +   void genLuck(int d, vector<LL>& v)
           56  +   {
           57  +      // d-digit lucky numbers
           58  +      for(int b=0; b<(1<<d); ++b)
           59  +      {
           60  +         LL n = 0;
           61  +         for(int i=0; i<d; ++i)
           62  +            n = n*10 + (b&(1<<i) ? 4 : 7);
           63  +         v.push_back(n);
           64  +      }
           65  +   }
           66  +
           67  +   long long count(long long a, long long b)
           68  +   {
           69  +      vector<LL> v;
           70  +      genLuck(v);
           71  +
           72  +      static const int M = 16;
           73  +
           74  +      // inclusion-exclusion
           75  +      LL cnt = 0;
           76  +      {
           77  +         for(int m=1; m<(1<<M); ++m)
           78  +         {
           79  +            int bc = 0;
           80  +            LL n = 1;
           81  +            for(int i=0; i<M; ++i)
           82  +               if( m & (1<<i) )
           83  +                  ++bc, n=lcm(n, v[i]);
           84  +            cnt += (bc&1) ? (b/n-(a-1)/n) : -(b/n-(a-1)/n);
           85  +         }
           86  +      }
           87  +
           88  +      // sieve
           89  +      vector<LL> aml; // almost lucky numbers
           90  +      for(int i=M; i<v.size() && v[i]<=b; ++i)
           91  +      {
           92  +         LL u = v[i];
           93  +         for(LL s=a%u?(a/u+1)*u:a; s<=b; s+=u)
           94  +         {
           95  +            for(int k=0; k<M; ++k)
           96  +               if( s%v[k]==0 )
           97  +                  goto next;
           98  +            aml.push_back(s);
           99  +         next:;
          100  +         }
          101  +         if( aml.size() > 10000000 ) {
          102  +            sort(aml.begin(), aml.end());
          103  +            aml.erase(unique(aml.begin(), aml.end()), aml.end());
          104  +         }
          105  +      }
          106  +
          107  +      sort(aml.begin(), aml.end());
          108  +      aml.erase(unique(aml.begin(), aml.end()), aml.end());
          109  +      return cnt + aml.size();
          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) << " msec)"; return os.str(); }
          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 os; }
          121  +void verify_case(const long long& Expected, const long long& Received) {
          122  + bool ok = (Expected == Received);
          123  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          124  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          125  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          126  +#define END    verify_case(_, TheAlmostLuckyNumbers().count(a, b));}
          127  +int main(){
          128  +
          129  +CASE(0)
          130  +   long long a = 1LL;
          131  +   long long b = 10LL;
          132  +   long long _ = 3LL;
          133  +END
          134  +CASE(1)
          135  +   long long a = 14LL;
          136  +   long long b = 14LL;
          137  +   long long _ = 1LL;
          138  +END
          139  +CASE(2)
          140  +   long long a = 1LL;
          141  +   long long b = 100LL;
          142  +   long long _ = 39LL;
          143  +END
          144  +CASE(3)
          145  +   long long a = 1234LL;
          146  +   long long b = 4321LL;
          147  +   long long _ = 1178LL;
          148  +END
          149  +CASE(4)
          150  +   long long a = 1LL;
          151  +   long long b = 10000000000LL;
          152  +   long long _ = -1LL;
          153  +END
          154  +CASE(5)
          155  +   long long a = 10000000000LL;
          156  +   long long b = 10000000000LL;
          157  +   long long _ = -1LL;
          158  +END
          159  +
          160  +}
          161  +// END CUT HERE

Added SRM/454-U/1A.cpp version [f520f03e2411db6e]

            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 DoubleXor { public:
           23  + int calculate(int N)
           24  + {
           25  +  int x = N;
           26  +  for(int y=N-1; y>=1; --y)
           27  +   x = dxor(x, y);
           28  +
           29  +  int z = 1;
           30  +  for(int y=2; y<=N; ++y)
           31  +   z = dxor(z, y);
           32  +if( x != z )
           33  +cerr << N << ": " << x << " -- " << z << endl;
           34  +  return x;
           35  + }
           36  + int dxor(int x, int y)
           37  + {
           38  +  int z = 0;
           39  +  int d = 1;
           40  +  while( x>0 || y>0 ) {
           41  +   z += d * ((x%10 ^ y%10)%10);
           42  +   x /= 10;
           43  +   y /= 10;
           44  +   d *= 10;
           45  +  }
           46  +  return z;
           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) << " msec)"; return os.str(); }
           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 os; }
           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() << endl;
           61  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           62  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           63  +#define END  verify_case(_, DoubleXor().calculate(N));}
           64  +int main(){
           65  +
           66  +for(int N=1;;++N) {
           67  +CASE(-2)
           68  + int _ = -1;
           69  +END
           70  +}
           71  +CASE(-1)
           72  + int N = 8;
           73  + int _ = 2;
           74  +END
           75  +CASE(0)
           76  + int N = 1;
           77  + int _ = 1;
           78  +END
           79  +CASE(1)
           80  + int N = 2;
           81  + int _ = 3;
           82  +END
           83  +CASE(2)
           84  + int N = 7;
           85  + int _ = 0;
           86  +END
           87  +CASE(3)
           88  + int N = 10;
           89  + int _ = 11;
           90  +END
           91  +CASE(4)
           92  + int N = 102;
           93  + int _ = 103;
           94  +END
           95  +CASE(5)
           96  + int N = 1000000;
           97  + int _ = -1;
           98  +END
           99  +CASE(6)
          100  + int N = 1;
          101  + int _ = 1;
          102  +END
          103  +CASE(6)
          104  + int N = 2;
          105  + int _ = 3;
          106  +END
          107  +CASE(6)
          108  + int N = 3;
          109  + int _ = 0;
          110  +END
          111  +CASE(6)
          112  + int N = 4;
          113  + int _ = 4;
          114  +END
          115  +CASE(6)
          116  + int N = 5;
          117  + int _ = 1;
          118  +END
          119  +CASE(6)
          120  + int N = 6;
          121  + int _ = 7;
          122  +END
          123  +CASE(6)
          124  + int N = 7;
          125  + int _ = 0;
          126  +END
          127  +CASE(6)
          128  + int N = 9;
          129  + int _ = 1;
          130  +END
          131  +
          132  +}
          133  +// END CUT HERE

Added SRM/454-U/1B.cpp version [54e51fc242068030]

            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  +template<typename T>
           23  +struct DP2
           24  +{
           25  + const int N1, N2;
           26  + vector<T> data;
           27  + DP2(int N1, int N2, const T& t = T())
           28  +  : N1(N1), N2(N2), data(N1*N2, t) {}
           29  + T& operator()(int i1, int i2)
           30  +  { return data[ (i1*N2)+i2 ]; }
           31  + void swap(DP2& rhs)
           32  +  { data.swap(rhs.data); }
           33  +};
           34  +
           35  +class NumbersAndMatches { public:
           36  + long long differentNumbers(long long N, int K)
           37  + {
           38  +  string s;
           39  +  for(; N; N/=10)
           40  +   s = char('0' + N%10) + s;
           41  +
           42  +  DP2<LL> dp(127,127);
           43  +  dp(0,0) = 1;
           44  +
           45  +  for(int i=0; i<s.size(); ++i)
           46  +  {
           47  +   DP2<LL> dp2(127, 127);
           48  +   for(int tooMany=0; tooMany<=K; ++tooMany)
           49  +   for(int tooFew=0; tooFew<=K; ++tooFew)
           50  +    for(char c='0'; c<='9'; ++c)
           51  +    {
           52  +     int tM=tooMany, tF=tooFew;
           53  +     diff(s[i], c, &tM, &tF);
           54  +     if( tM<=K && tF<=K )
           55  +      dp2(tM,tF) += dp(tooMany,tooFew);
           56  +    }
           57  +   dp.swap(dp2);
           58  +  }
           59  +
           60  +  LL ans = 0;
           61  +  for(int tMF=0; tMF<=K; ++tMF)
           62  +   ans += dp(tMF, tMF);
           63  +  return ans;
           64  + }
           65  +
           66  + void diff(char a, char b, int* tF, int* tM)
           67  + {
           68  +  const char* a7 = seven_seg(a);
           69  +  const char* b7 = seven_seg(b);
           70  +  for(int i=0; i<7; ++i)
           71  +   if( a7[i] < b7[i] )
           72  +    ++*tF;
           73  +   else if( a7[i] > b7[i] )
           74  +    ++*tM;
           75  + }
           76  +
           77  + const char* seven_seg(char c)
           78  + {
           79  +  const char* ans[] = {
           80  +   "1110111",
           81  +   "0010011",
           82  +   "1011101",
           83  +   "1011011",
           84  +   "0111010",
           85  +   "1101011",
           86  +   "1101111",
           87  +   "1010010",
           88  +   "1111111",
           89  +   "1111011",
           90  +  };
           91  +  return ans[c-'0'];
           92  + }
           93  +};
           94  +
           95  +// BEGIN CUT HERE
           96  +#include <ctime>
           97  +double start_time; string timer()
           98  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           99  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          100  + { os << "{ ";
          101  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          102  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          103  +void verify_case(const long long& Expected, const long long& Received) {
          104  + bool ok = (Expected == Received);
          105  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          106  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          107  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          108  +#define END  verify_case(_, NumbersAndMatches().differentNumbers(N, K));}
          109  +int main(){
          110  +
          111  +CASE(0)
          112  + long long N = 10LL;
          113  + int K = 1;
          114  + long long _ = 4LL;
          115  +END
          116  +CASE(1)
          117  + long long N = 23LL;
          118  + int K = 1;
          119  + long long _ = 4LL;
          120  +END
          121  +CASE(2)
          122  + long long N = 66LL;
          123  + int K = 2;
          124  + long long _ = 15LL;
          125  +END
          126  +CASE(3)
          127  + long long N = 888888888LL;
          128  + int K = 100;
          129  + long long _ = 1LL;
          130  +END
          131  +CASE(4)
          132  + long long N = 444444444444444444LL;
          133  + int K = 2;
          134  + long long _ = 1LL;
          135  +END
          136  +CASE(5)
          137  + long long N = 1LL;
          138  + int K = 1;
          139  + long long _ = 2LL;
          140  +END
          141  +CASE(6)
          142  + long long N = 12345678901234567LL;
          143  + int K = 126;
          144  + long long _ = -1LL;
          145  +END
          146  +
          147  +}
          148  +// END CUT HERE

Added SRM/454-U/1C-U.cpp version [237d262a30af7167]

            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 LL MODVAL = 1000000007LL;
           23  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           24  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           25  +
           26  +class MegaSum { public:
           27  + int calculate(long long N)
           28  + {
           29  +  LL nth = sq(N);
           30  +  pair<LL,LL> p = position_of(N);
           31  +
           32  +  LL cnt = 0;
           33  +  for(LL lane=1; lane<=nth; ++lane)
           34  +   cnt = ADD(cnt, sum_in_the_lane(p, lane));
           35  +  return cnt;
           36  + }
           37  +
           38  + LL sq( LL N )
           39  + {
           40  +  LL nth=1;
           41  +  while( !(N <= nth*nth) )
           42  +   ++nth;
           43  +  return nth;
           44  + }
           45  +
           46  + pair<LL,LL> position_of( LL N )
           47  + {
           48  +  // in which lane?
           49  +  LL nth = sq(N);
           50  +
           51  +  // position
           52  +  LL dif = N - (nth-1)*(nth-1);
           53  +  LL y = (dif<=nth ? dif : nth);
           54  +  LL x = (dif<=nth ? nth : nth+nth-dif);
           55  +  if( nth%2 == 1 ) swap(x, y);
           56  +
           57  +  return make_pair(y,x);
           58  + }
           59  +
           60  + LL sum_in_the_lane(pair<LL,LL> p, LL lane)
           61  + {
           62  +  LL y = p.first;
           63  +  LL x = p.second;
           64  +
           65  +
           66  +  if( lane%2 == 0 )
           67  +  {
           68  +   //     V
           69  +   //     V
           70  +   //<<<<<<
           71  +   LL s = lane<=x ? sumV( 1, lane, min(y,lane), lane, y, x ) : 0;
           72  +   s = ADD(s, lane<=y ? sumH(lane,min(x,lane-1),lane,1,y,x) : 0);
           73  +   return s;
           74  +  }
           75  +  else
           76  +  {
           77  +   //     A
           78  +   //     A
           79  +   //>>>>>>
           80  +   LL s = lane<=y ? sumH( lane, 1, lane, min(x,lane), y, x ) : 0;
           81  +   s = ADD(s, lane<=x ? sumV(min(y,lane-1),lane,1,lane,y,x) : 0);
           82  +   return s;
           83  +  }
           84  + }
           85  +
           86  + LL value_of(LL y, LL x)
           87  + {
           88  +  LL lane = max(x, y);
           89  +  return (lane-1)*(lane-1) + (lane%2==0 ? (y<lane ? y : lane+lane-x)
           90  +                                        : (x<lane ? x : lane+lane-y));
           91  + }
           92  +
           93  + LL sumH(LL y0, LL x, LL y1, LL _, LL Y, LL X)
           94  + {
           95  +  // \Sigma value_of(y0+i,x) * (X-x+1)*(Y-(y0+i)+1)
           96  +  //=
           97  +  // \Sigma (value_of(y0,x)+i) * (X-x+1)*(Y-(y0+i)+1)
           98  +  //=
           99  +  // \Sigma (V0            +i) * XX     *(YY-i)
          100  +  //=
          101  +  // ...
          102  +  assert(false);
          103  + }
          104  +
          105  + LL sumV(LL y, LL x0, LL _, LL x1, LL Y, LL X)
          106  + {
          107  +  assert(false);
          108  + }
          109  +};
          110  +
          111  +// BEGIN CUT HERE
          112  +#include <ctime>
          113  +double start_time; string timer()
          114  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          115  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          116  + { os << "{ ";
          117  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          118  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          119  +void verify_case(const int& Expected, const int& Received) {
          120  + bool ok = (Expected == Received);
          121  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          122  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          123  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          124  +#define END  verify_case(_, MegaSum().calculate(N));}
          125  +int main(){
          126  +
          127  +CASE(0)
          128  + long long N = 8LL;
          129  + int _ = 58;
          130  +END
          131  +CASE(1)
          132  + long long N = 12LL;
          133  + int _ = 282;
          134  +END
          135  +CASE(2)
          136  + long long N = 11LL;
          137  + int _ = 128;
          138  +END
          139  +CASE(3)
          140  + long long N = 6LL;
          141  + int _ = 50;
          142  +END
          143  +CASE(4)
          144  + long long N = 34539LL;
          145  + int _ = 437909839;
          146  +END
          147  +CASE(5)
          148  + long long N = 10000000000LL;
          149  + int _ = -1;
          150  +END
          151  +CASE(6)
          152  + long long N = 123456789LL;
          153  + int _ = -1;
          154  +END
          155  +
          156  +}
          157  +// END CUT HERE

Added SRM/456-U/1A.cpp version [cddace57bcfd8713]

            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 SilverDistance { public:
           23  + int minSteps(int sx, int sy, int gx, int gy)
           24  + {
           25  +  return abs(sx-gx)%2 == abs(sy-gy)%2
           26  +   ? max(abs(sx-gx),abs(sy-gy)) : 1+max(abs(sx-gx),abs(sy+1-gy));
           27  + }
           28  +};
           29  +
           30  +// BEGIN CUT HERE
           31  +#include <ctime>
           32  +double start_time; string timer()
           33  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           34  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           35  + { os << "{ ";
           36  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           37  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           38  +void verify_case(const int& Expected, const int& Received) {
           39  + bool ok = (Expected == Received);
           40  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           41  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           42  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           43  +#define END  verify_case(_, SilverDistance().minSteps(sx, sy, gx, gy));}
           44  +int main(){
           45  +
           46  +CASE(0)
           47  + int sx = 1;
           48  + int sy = 0;
           49  + int gx = 1;
           50  + int gy = 9;
           51  + int _ = 9;
           52  +END
           53  +CASE(1)
           54  + int sx = 0;
           55  + int sy = 0;
           56  + int gx = -4;
           57  + int gy = 3;
           58  + int _ = 5;
           59  +END
           60  +CASE(2)
           61  + int sx = 0;
           62  + int sy = 0;
           63  + int gx = 5;
           64  + int gy = 8;
           65  + int _ = 8;
           66  +END
           67  +CASE(3)
           68  + int sx = -487617;
           69  + int sy = 826524;
           70  + int gx = 892309;
           71  + int gy = -918045;
           72  + int _ = 1744571;
           73  +END
           74  +CASE(4)
           75  + int sx = -27857;
           76  + int sy = 31475;
           77  + int gx = -27857;
           78  + int gy = 31475;
           79  + int _ = 0;
           80  +END
           81  +
           82  +}
           83  +// END CUT HERE

Added SRM/456-U/1B.cpp version [4a688b8acc36f02d]

            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 CutSticks { public:
           23  + double maxKth(vector <int> sticks, int Ct, int K)
           24  + {
           25  +  double L=0, R=1000000000;
           26  +  for(int n=0; n<1000; ++n)
           27  +  {
           28  +   double C = (L+R)/2;
           29  +
           30  +   // can we create K sticks of length C from sticks within Ct cuts?
           31  +   int cnt = 0;
           32  +   int ncut = 0;
           33  +   for(int i=0; i<sticks.size(); ++i) {
           34  +    int ct = int( sticks[i] / C )-1;
           35  +    if( ct >= 0 ) {
           36  +     ct = min(ct, Ct-ncut);
           37  +     ncut += ct;
           38  +     cnt += ct+1;
           39  +    }
           40  +   }
           41  +
           42  +   (cnt >= K ? L : R) = C;
           43  +  }
           44  +  return L;
           45  + }
           46  +};
           47  +
           48  +// BEGIN CUT HERE
           49  +#include <ctime>
           50  +double start_time; string timer()
           51  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           52  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           53  + { os << "{ ";
           54  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           55  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           56  +void verify_case(const double& Expected, const double& Received) {
           57  + double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 1e-9);
           58  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           59  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           60  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           61  +#define END  verify_case(_, CutSticks().maxKth(sticks, C, K));}
           62  +int main(){
           63  +
           64  +CASE(0)
           65  + int sticks_[] = {5, 8};
           66  +   vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_));
           67  + int C = 1;
           68  + int K = 1;
           69  + double _ = 8.0;
           70  +END
           71  +CASE(1)
           72  + int sticks_[] = {5, 8};
           73  +   vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_));
           74  + int C = 1;
           75  + int K = 2;
           76  + double _ = 5.0;
           77  +END
           78  +CASE(2)
           79  + int sticks_[] = {5, 8};
           80  +   vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_));
           81  + int C = 1;
           82  + int K = 3;
           83  + double _ = 4.0;
           84  +END
           85  +CASE(3)
           86  + int sticks_[] = {1000000000, 1000000000, 1};
           87  +   vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_));
           88  + int C = 2;
           89  + int K = 5;
           90  + double _ = 1.0;
           91  +END
           92  +CASE(4)
           93  + int sticks_[] = {76, 594, 17, 6984, 26, 57, 9, 876, 5816, 73, 969, 527, 49};
           94  +   vector <int> sticks(sticks_, sticks_+sizeof(sticks_)/sizeof(*sticks_));
           95  + int C = 789;
           96  + int K = 456;
           97  + double _ = 34.92;
           98  +END
           99  +
          100  +}
          101  +// END CUT HERE

Added SRM/457-U/1A.cpp version [3c8f623356e9f51d]

            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 TheTriangleBothDivs { public:
           23  + string fix(string time)
           24  + {
           25  +  string answer;
           26  +
           27  +  for(int hh= 0; hh<=23; ++hh)
           28  +  for(int mm= 0; mm<=59; ++mm)
           29  +  for(int of=-9; of<=+9; ++of)
           30  +   if( is_possible(hh,mm,of,time) ) {
           31  +    stringstream ss;
           32  +    ss << setw(2) << setfill('0') << (hh-of+24)%24
           33  +       << ":"
           34  +       << setw(2) << setfill('0') << mm;
           35  +
           36  +    if( answer.empty() || ss.str()<answer )
           37  +     answer = ss.str();
           38  +   }
           39  +  return answer;
           40  + }
           41  +
           42  + bool is_possible(int hh, int mm, int of, const string& time)
           43  + {
           44  +  stringstream ss;
           45  +  ss << setw(2) << setfill('0') << hh
           46  +     << ":"
           47  +     << setw(2) << setfill('0') << mm
           48  +     << " GMT"
           49  +     << (of>=0 ? '+' : '-')
           50  +     << (of>=0 ? of : -of);
           51  +
           52  +  string s = ss.str();
           53  +  for(int i=0; i<s.size(); ++i)
           54  +   if( s[i] != time[i] && time[i]!='?' )
           55  +    return false;
           56  +  return true;
           57  + }
           58  +};
           59  +
           60  +// BEGIN CUT HERE
           61  +#include <ctime>
           62  +double start_time; string timer()
           63  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           64  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           65  + { os << "{ ";
           66  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           67  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           68  +void verify_case(const string& Expected, const string& Received) {
           69  + bool ok = (Expected == Received);
           70  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           71  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           72  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           73  +#define END  verify_case(_, TheTriangleBothDivs().fix(time));}
           74  +int main(){
           75  +
           76  +CASE(0)
           77  + string time = "17:45 GMT-4";
           78  + string _ = "21:45";
           79  +END
           80  +CASE(1)
           81  + string time = "16:?? GMT??";
           82  + string _ = "00:00";
           83  +END
           84  +CASE(2)
           85  + string time = "?1:34 GMT-9";
           86  + string _ = "06:34";
           87  +END
           88  +CASE(3)
           89  + string time = "??:?? GMT??";
           90  + string _ = "00:00";
           91  +END
           92  +CASE(4)
           93  + string time = "01:?? GMT?1";
           94  + string _ = "00:00";
           95  +END
           96  +CASE(5)
           97  + string time = "00:00 GMT-?";
           98  + string _ = "01:00";
           99  +END
          100  +
          101  +}
          102  +// END CUT HERE

Added SRM/457-U/1B.cpp version [66d130730b42345e]

            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 TheHexagonsDivOne { public:
           23  + long long count(int n)
           24  + {
           25  +  // at least there must be 7<=2*n numbers...
           26  +  if( n <= 3 )
           27  +   return 0;
           28  +
           29  +  // center hex has 2n possibility
           30  +  // choose others from 2(n-1) candidates
           31  +  // normalize by /6 to classify by the least number
           32  +
           33  +  LL ans = 0;
           34  +  vector<int> pat;
           35  +  count_pat( pat, n-1, ans );
           36  +  return ans*2*n/6;
           37  + }
           38  +
           39  + void count_pat( vector<int>& pat, LL n, LL& ans )
           40  + {
           41  +  int i = pat.size();
           42  +  if( i == 6 )
           43  +  {
           44  +   LL distinct = set<int>(pat.begin(), pat.end()).size();
           45  +   LL tmp = 1;
           46  +   for(int d=0; d<distinct; ++d)
           47  +    tmp *= (n-d);
           48  +
           49  +   LL dup = 6 - distinct;
           50  +   for(int d=0; d<dup; ++d)
           51  +    tmp *= 2;
           52  +
           53  +   LL nodup = 6 - 2*dup;
           54  +   for(int d=0; d<nodup; ++d)
           55  +    tmp *= 2;
           56  +
           57  +   ans += tmp;
           58  +   return;
           59  +  }
           60  +
           61  +  vector<int> use(7);
           62  +  int next = 1;
           63  +  for(int k=0; k<pat.size(); ++k) {
           64  +   use[pat[k]]++;
           65  +   next = max(next, pat[k]+1);
           66  +  }
           67  +
           68  +  if( next <= n )
           69  +  {
           70  +   pat.push_back(next);
           71  +   count_pat( pat, n, ans );
           72  +   pat.pop_back();
           73  +  }
           74  +
           75  +  for(int p=1; p<next; ++p)
           76  +   if( use[p]<=1 )
           77  +    if( i==0 || (pat[i-1]!=p && (i<5 || pat[0]!=p)) )
           78  +    {
           79  +     pat.push_back(p);
           80  +     count_pat( pat, n, ans );
           81  +     pat.pop_back();
           82  +    }
           83  + }
           84  +};
           85  +
           86  +// BEGIN CUT HERE
           87  +#include <ctime>
           88  +double start_time; string timer()
           89  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           90  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           91  + { os << "{ ";
           92  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           93  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           94  +void verify_case(const long long& Expected, const long long& Received) {
           95  + bool ok = (Expected == Received);
           96  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           97  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           98  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           99  +#define END  verify_case(_, TheHexagonsDivOne().count(n));}
          100  +int main(){
          101  +
          102  +CASE(0)
          103  + int n = 3;
          104  + long long _ = 0LL;
          105  +END
          106  +CASE(1)
          107  + int n = 4;
          108  + long long _ = 256LL;
          109  +END
          110  +CASE(2)
          111  + int n = 8;
          112  + long long _ = 3458560LL;
          113  +END
          114  +CASE(3)
          115  + int n = 20;
          116  + long long _ = 11193888000LL;
          117  +END
          118  +CASE(4)
          119  + int n = 1;
          120  + long long _ = 0LL;
          121  +END
          122  +CASE(5)
          123  + int n = 150;
          124  + long long _ = -1LL;
          125  +END
          126  +
          127  +}
          128  +// END CUT HERE

Added SRM/457-U/1C-U.cpp version [1f56abd1e071f50d]

            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 NV = 18*18*2+18+2;
           23  +typedef int           flow;
           24  +typedef LL            cost;
           25  +typedef int           vert;
           26  +typedef vert          edge;
           27  +typedef vector<edge>  edges;
           28  +typedef vector<edges> graph;
           29  +typedef flow          flow_graph[NV][NV];
           30  +typedef cost          cost_graph[NV][NV];
           31  +static const flow FLOW_INF = 0x7FFFFFFF;
           32  +static const cost COST_INF = 0x7FFFFFFFFFFFFFFFLL;
           33  +
           34  +// edges(bidi), capacity, cost(s.t. C[x][y]=-C[y][x]) per 1 flow, src, dst
           35  +pair<cost,flow> mincostFlow(graph& G, flow_graph F, cost_graph C, vert S, vert D)
           36  +{
           37  + int N = G.size();
           38  + cost total_cost = 0;
           39  + flow total_flow = 0;
           40  +
           41  + vector<cost> h(N, 0); // potential
           42  + for(cost RF=FLOW_INF; RF>0; ) // residual flow
           43  + {
           44  +  // Dijkstra -- find the min-cost path
           45  +  vector<cost> d(N, COST_INF);  d[S] = 0;
           46  +  vector<vert> prev(N, -1);
           47  +
           48  +  typedef pair<cost, pair<vert,vert> > cedge;
           49  +  priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           50  +  Q.push( cedge(0, make_pair(S,S)) );
           51  +  while( !Q.empty() ) {
           52  +   cedge e = Q.top(); Q.pop();
           53  +   if( prev[e.second.second] >= 0 )
           54  +    continue;
           55  +   prev[e.second.second] = e.second.first;
           56  +
           57  +   vert u = e.second.second;
           58  +   for(int i=0; i<G[u].size(); ++i) {
           59  +    vert v = G[u][i];
           60  +    cost r_cost = C[u][v] + h[u] - h[v];
           61  +    if( F[u][v] > 0 && d[v] > d[u]+r_cost )
           62  +     Q.push( cedge(d[v]=d[u]+r_cost, make_pair(u,v)) );
           63  +   }
           64  +  }
           65  +
           66  +  if( prev[D] < 0 )
           67  +   break; // Finished
           68  +
           69  +  // As much as possible
           70  +  flow f = RF;
           71  +  for(vert u=D; u!=S; u=prev[u])
           72  +   f = min(f, F[prev[u]][u]);
           73  +  RF         -= f;
           74  +  total_flow += f;
           75  +
           76  +  for(vert u=D; u!=S; u=prev[u])
           77  +  {
           78  +   total_cost    += f * C[prev[u]][u];
           79  +   F[prev[u]][u] -= f;
           80  +   F[u][prev[u]] += f;
           81  +  }
           82  +
           83  +  // Update the potential
           84  +  for(vert u=0; u<N; ++u)
           85  +   h[u] += d[u];
           86  + }
           87  + return make_pair(total_cost, total_flow);
           88  +}
           89  +
           90  +
           91  +flow_graph F;
           92  +cost_graph C;
           93  +
           94  +LL f(LL n) {
           95  + return n*n*n*n*n;
           96  +}
           97  +
           98  +class TheSquareDivOne { public:
           99  + vector <string> solve(vector <string> board)
          100  + {
          101  +  int n = board.size();
          102  +  vector<int> R(n);
          103  +  for(int y=0; y<n; ++y)
          104  +   for(int x=0; x<n; ++x)
          105  +    if( board[y][x]=='C' )
          106  +     R[y] ++;
          107  +
          108  +  graph      G(2+n+n*n*2);
          109  +  memset(F, 0, sizeof(F));
          110  +  memset(C, 0, sizeof(C));
          111  +  vert       S = 0;
          112  +  vert       D = 1;
          113  +
          114  +  for(int y=0; y<n; ++y)
          115  +   for(int x=0; x<n; ++x) {
          116  +    vert v = (2+n) + y*n + x;
          117  +    G[S].push_back(v);
          118  +    G[v].push_back(S);
          119  +    if( board[y][x]=='C' )
          120  +     F[S][v] = 1;
          121  +   }
          122  +
          123  +  for(int y=0; y<n; ++y)
          124  +   for(int x=0; x<n; ++x) {
          125  +    vert v = (2+n) + (n*n) + y*n + x;
          126  +    vert u = 2+x;
          127  +    G[v].push_back(u);
          128  +    G[u].push_back(v);
          129  +    F[v][u] = 1;
          130  +//    C[u][v] = -(C[v][u] = (1LL<<(n-y-1))<<30);
          131  +   }
          132  +
          133  +  for(int x=0; x<n; ++x) {
          134  +   vert u = 2+x;
          135  +   G[u].push_back(D);
          136  +   G[D].push_back(u);
          137  +   F[u][D] = R[x];
          138  +//   C[u][D] = -(C[D][u] = (1LL<<2*(n-x-1)));
          139  +  }
          140  +
          141  +  for(int y1=0; y1<n; ++y1)
          142  +   for(int x1=0; x1<n; ++x1)
          143  +    for(int y2=0; y2<n; ++y2)
          144  +     for(int x2=0; x2<n; ++x2) {
          145  +      vert v = (2+n) + y1*n + x1;
          146  +      vert u = (2+n) + (n*n) + y2*n + x2;
          147  +      G[u].push_back(v);
          148  +      G[v].push_back(u);
          149  +      F[v][u] = 1;
          150  +      C[u][v] = -(C[v][u] = abs(y1-y2)+abs(x1-x2));
          151  +//      C[u][v] = -(C[v][u] = LL(abs(y1-y2)+abs(x1-x2))<<50);
          152  +     }
          153  +
          154  +  pair<cost,flow> mf = mincostFlow(G,F,C,S,D);
          155  +//  cerr << "Cost: " << (mf.first>>50) << "+" << ((mf.first&(1LL<<50)-1)) << ", Flow: " << mf.second << endl;
          156  +
          157  +  for(int y=0; y<n; ++y)
          158  +   for(int x=0; x<n; ++x)
          159  +    board[y][x] = (F[(2+n) + (n*n) + y*n + x][2+x]==0 ? 'C' : '.');
          160  +
          161  +  // not lexicographically first ...orz
          162  +  return board;
          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 vector <string>& Expected, const vector <string>& Received) {
          175  + bool ok = (Expected == Received);
          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(_, TheSquareDivOne().solve(board));}
          180  +int main(){
          181  +
          182  +CASE(0)
          183  + string board_[] = {"...",
          184  + "...",
          185  + "C.."};
          186  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          187  + string __[] = {"...", "...", "..C" };
          188  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          189  +END
          190  +CASE(1)
          191  + string board_[] = {"CCC",
          192  + ".C.",
          193  + "CCC"};
          194  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          195  + string __[] = {"C.C", "C.C", "CCC" };
          196  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          197  +END
          198  +CASE(2)
          199  + string board_[] = {"C..",
          200  + ".C.",
          201  + "..C"};
          202  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          203  + string __[] = {"C..", ".C.", "..C" };
          204  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          205  +END
          206  +CASE(3)
          207  + string board_[] = {"C....","CCCCC","...CC",".CC..",".C.C."};
          208  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          209  + string __[] = {".C...", "CCCCC", ".C..C", ".CC..", ".C.C." };
          210  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          211  +END
          212  +CASE(4)
          213  + string board_[] = {
          214  +"CCCCCCCCCCCCCCCCCC",
          215  +"CCCCCCCCCCCCCCCCCC",
          216  +"CCCCCCCCCCCCCCCCCC",
          217  +"CCCCCCCCCCCCCCCCCC",
          218  +"CCCCCCCCCCCCCCCCCC",
          219  +"CCCCCCCCCCCCCCCCCC",
          220  +"CCCCCCCCCCCCCCCCCC",
          221  +"CCCCCCCCCCCCCCCCCC",
          222  +"CCCCCCCCCCCCCCCCCC",
          223  +"CCCCCCCCCCCCCCCCCC",
          224  +"CCCCCCCCCCCCCCCCCC",
          225  +"CCCCCCCCCCCCCCCCCC",
          226  +"CCCCCCCCCCCCCCCCCC",
          227  +"CCCCCCCCCCCCCCCCCC",
          228  +"CCCCCCCCCCCCCCCCCC",
          229  +"CCCCCCCCCCCCCCCCCC",
          230  +"CCCCCCCCCCCCCCCCCC",
          231  +"CCCCCCCCCCCCCCCCCC",
          232  +};
          233  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          234  + string __[] = {
          235  +"CCCCCCCCCCCCCCCCCC",
          236  +"CCCCCCCCCCCCCCCCCC",
          237  +"CCCCCCCCCCCCCCCCCC",
          238  +"CCCCCCCCCCCCCCCCCC",
          239  +"CCCCCCCCCCCCCCCCCC",
          240  +"CCCCCCCCCCCCCCCCCC",
          241  +"CCCCCCCCCCCCCCCCCC",
          242  +"CCCCCCCCCCCCCCCCCC",
          243  +"CCCCCCCCCCCCCCCCCC",
          244  +"CCCCCCCCCCCCCCCCCC",
          245  +"CCCCCCCCCCCCCCCCCC",
          246  +"CCCCCCCCCCCCCCCCCC",
          247  +"CCCCCCCCCCCCCCCCCC",
          248  +"CCCCCCCCCCCCCCCCCC",
          249  +"CCCCCCCCCCCCCCCCCC",
          250  +"CCCCCCCCCCCCCCCCCC",
          251  +"CCCCCCCCCCCCCCCCCC",
          252  +"CCCCCCCCCCCCCCCCCC",
          253  +};
          254  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          255  +END
          256  +/*
          257  +CASE(5)
          258  + string board_[] = ;
          259  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          260  + string __[] = ;
          261  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          262  +END
          263  +*/
          264  +}
          265  +// END CUT HERE

Added SRM/458-U/1A.cpp version [dd4898e19fbf1df8]

            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 BouncingBalls { public:
           23  + double expectedBounces(vector <int> x, int T)
           24  + {
           25  +  sort(x.begin(), x.end());
           26  +
           27  +  double  total = 0;
           28  +
           29  +  int N = x.size();
           30  +  for(int m=0; m<(1<<N); ++m)
           31  +  {
           32  +   vector<bool> goLeft(N);
           33  +   for(int i=0; i<N; ++i)
           34  +    goLeft[i] = ((1<<i)&m) != 0;
           35  +
           36  +   total += num(x, goLeft, T);
           37  +  }
           38  +
           39  +  return total / (1<<N);
           40  + }
           41  +
           42  + double num( const vector<int>& x, const vector<bool>& goLeft, int T )
           43  + {
           44  +  int cnt = 0;
           45  +  for(int i=0; i<x.size(); ++i)
           46  +   for(int j=i+1; j<x.size(); ++j)
           47  +    if( !goLeft[i] && goLeft[j] && x[j]-x[i]<=2*T )
           48  +     ++cnt;
           49  +  return cnt;
           50  + }
           51  +};
           52  +
           53  +// BEGIN CUT HERE
           54  +#include <ctime>
           55  +double start_time; string timer()
           56  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           57  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           58  + { os << "{ ";
           59  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           60  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           61  +void verify_case(const double& Expected, const double& Received) {
           62  + double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 1e-9);
           63  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           64  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           65  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           66  +#define END  verify_case(_, BouncingBalls().expectedBounces(x, T));}
           67  +int main(){
           68  +
           69  +CASE(0)
           70  + int x_[] = {5, 8};
           71  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           72  + int T = 2;
           73  + double _ = 0.25;
           74  +END
           75  +CASE(1)
           76  + int x_[] = {5, 8};
           77  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           78  + int T = 1;
           79  + double _ = 0.0;
           80  +END
           81  +CASE(2)
           82  + int x_[] = {91, 857, 692, 54, 8679, 83, 792, 86, 9537, 913, 64, 592};
           83  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           84  + int T = 458;
           85  + double _ = 11.5;
           86  +END
           87  +CASE(3)
           88  + int x_[] = {75432};
           89  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           90  + int T = 386;
           91  + double _ = 0.0;
           92  +END
           93  +CASE(4)
           94  + int x_[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
           95  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           96  + int T = 3;
           97  + double _ = 12.75;
           98  +END
           99  +CASE(5)
          100  + int x_[] = {1};
          101  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          102  + int T = 100000000;
          103  + double _ = 0;
          104  +END
          105  +CASE(6)
          106  + int x_[] = {10000000};
          107  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          108  + int T = 100000;
          109  + double _ = 0;
          110  +END
          111  +
          112  +}
          113  +// END CUT HERE

Added SRM/458-U/1B.cpp version [4c507d892b5c2673]

            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 NewCoins { public:
           23  + int minCoins(vector <int> price)
           24  + {
           25  +  memo.resize(100001, -1);
           26  +  return mc(1, price);
           27  + }
           28  +
           29  + vector<int> memo;
           30  + int mc( int d, const vector<int>& price )
           31  + {
           32  +  if( memo[d] != -1 )
           33  +   return memo[d];
           34  +  if( price.size() == 0 )
           35  +   return 0;
           36  +
           37  +  // all 1
           38  +  int X = accumulate(price.begin(), price.end(), 0);
           39  +
           40  +  int P = *max_element(price.begin(), price.end());
           41  +  for(int p=2; p<=P; ++p)
           42  +  {
           43  +   int byOne = 0;
           44  +
           45  +   vector<int> p2;
           46  +   for(int i=0; i<price.size(); ++i) {
           47  +    byOne += price[i] % p;
           48  +    if( memo[d*p]==-1 )
           49  +     if(price[i] / p) p2.push_back(price[i]/p);
           50  +   }
           51  +   X = min(X, byOne + mc(d*p, p2));
           52  +  }
           53  +  return memo[d] = X;
           54  + }
           55  +};
           56  +
           57  +// BEGIN CUT HERE
           58  +#include <ctime>
           59  +double start_time; string timer()
           60  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           61  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           62  + { os << "{ ";
           63  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           64  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           65  +void verify_case(const int& Expected, const int& Received) {
           66  + bool ok = (Expected == Received);
           67  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           68  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           69  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           70  +#define END  verify_case(_, NewCoins().minCoins(price));}
           71  +int main(){
           72  +
           73  +CASE(0)
           74  + int price_[] = {25, 102};
           75  +   vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_));
           76  + int _ = 4;
           77  +END
           78  +CASE(1)
           79  + int price_[] = {58};
           80  +   vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_));
           81  + int _ = 1;
           82  +END
           83  +CASE(2)
           84  + int price_[] = {1, 4, 5, 9, 16};
           85  +   vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_));
           86  + int _ = 7;
           87  +END
           88  +CASE(3)
           89  + int price_[] = {1, 1, 1, 1, 1};
           90  +   vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_));
           91  + int _ = 5;
           92  +END
           93  +CASE(4)
           94  + int price_[] = {28, 569, 587, 256, 15, 87, 927, 4, 589, 73, 98, 87, 597, 163, 6, 498};
           95  +   vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_));
           96  + int _ = 62;
           97  +END
           98  +CASE(5)
           99  + int price_[] = {1};
          100  +   vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_));
          101  + int _ = 1;
          102  +END
          103  +CASE(6)
          104  + int price_[] = {1,2,3,4,5,6,9997,9998,9999,99910,99911,99912,99913,99914,99915,99916,99917,99918,99919,99920,99921,99922,99923,99924,87625,87626,87627,87628,87629,87630,87631,87632,87633,87634,87635,87636,87637,87638,87639,99940,99991,99992,99993,99994,99995,99996,99997,99998,99999,100000};
          105  +   vector <int> price(price_, price_+sizeof(price_)/sizeof(*price_));
          106  + int _ = 183;
          107  +END
          108  +
          109  +}
          110  +// END CUT HERE

Added SRM/458-U/2C.cpp version [fa4ee92d598a5396]

            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 ProductTriplet { public:
           23  + long long countTriplets(int minx, int maxx, int miny, int maxy, int minz, int maxz)
           24  + {
           25  +  return comp(minx, maxx, miny, maxy, maxz) - comp(minx, maxx, miny, maxy, minz-1);
           26  + }
           27  +
           28  + LL comp(LL mx, LL Mx, LL my, LL My, LL Z)
           29  + {
           30  +  LL cnt = 0;
           31  +  for(LL x=mx; x<=Mx; )
           32  +  {
           33  +   LL Cy = Z / x;
           34  +   if( Cy < my )
           35  +    break;
           36  +
           37  +   // max n such that Cy == Z / x+n
           38  +   LL n = (Z/Cy)-x;
           39  +
           40  +   n = min(n, Mx-x)+1;
           41  +   cnt += n * (min(Cy,My) - my + 1);
           42  +   x += n;
           43  +  }
           44  +  return cnt;
           45  + }
           46  +};
           47  +
           48  +// BEGIN CUT HERE
           49  +#include <ctime>
           50  +double start_time; string timer()
           51  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           52  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           53  + { os << "{ ";
           54  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           55  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           56  +void verify_case(const long long& Expected, const long long& Received) {
           57  + bool ok = (Expected == Received);
           58  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           59  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           60  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           61  +#define END  verify_case(_, ProductTriplet().countTriplets(minx, maxx, miny, maxy, minz, maxz));}
           62  +int main(){
           63  +
           64  +CASE(0)
           65  + int minx = 2;
           66  + int maxx = 2;
           67  + int miny = 3;
           68  + int maxy = 3;
           69  + int minz = 6;
           70  + int maxz = 6;
           71  + long long _ = 1LL;
           72  +END
           73  +CASE(1)
           74  + int minx = 2;
           75  + int maxx = 2;
           76  + int miny = 3;
           77  + int maxy = 3;
           78  + int minz = 7;
           79  + int maxz = 7;
           80  + long long _ = 0LL;
           81  +END
           82  +CASE(2)
           83  + int minx = 6;
           84  + int maxx = 8;
           85  + int miny = 4;
           86  + int maxy = 5;
           87  + int minz = 27;
           88  + int maxz = 35;
           89  + long long _ = 4LL;
           90  +END
           91  +CASE(3)
           92  + int minx = 1;
           93  + int maxx = 458;
           94  + int miny = 1;
           95  + int maxy = 458;
           96  + int minz = 1;
           97  + int maxz = 458;
           98  + long long _ = 2877LL;
           99  +END
          100  +CASE(4)
          101  + int minx = 8176;
          102  + int maxx = 184561;
          103  + int miny = 1348;
          104  + int maxy = 43168;
          105  + int minz = 45814517;
          106  + int maxz = 957843164;
          107  + long long _ = 2365846085LL;
          108  +END
          109  +CASE(5)
          110  + int minx = 1;
          111  + int maxx = 1;
          112  + int miny = 1;
          113  + int maxy = 1;
          114  + int minz = 1;
          115  + int maxz = 1;
          116  + long long _ = 1LL;
          117  +END
          118  +CASE(6)
          119  + int minx = 1;
          120  + int maxx = 1000000000;
          121  + int miny = 1;
          122  + int maxy = 1000000000;
          123  + int minz = 1;
          124  + int maxz = 1000000000;
          125  + long long _ = -1LL;
          126  +END
          127  +
          128  +}
          129  +// END CUT HERE

Added SRM/459-U/1A.cpp version [70860f519d844ba5]

            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 Inequalities { public:
           23  + int maximumSubset(vector <string> inequalities)
           24  + {
           25  +  set<double> v;
           26  +
           27  +  for(int i=0; i<inequalities.size(); ++i)
           28  +  {
           29  +   stringstream ss(inequalities[i]);
           30  +   char _; string OP; double C;
           31  +   ss >> _ >> OP >> C;
           32  +
           33  +   v.insert(C);
           34  +  }
           35  +
           36  +  set<double> vv = v;
           37  +  vv.insert( *v.begin() - 1 );
           38  +  vv.insert( *v.rbegin() + 1 );
           39  +
           40  +  for(set<double>::iterator it=v.begin(); it!=v.end(); ++it)
           41  +  for(set<double>::iterator jt=v.begin(); jt!=v.end(); ++jt)
           42  +   vv.insert( (*it + *jt)/2 );
           43  +
           44  +  int maxSat = 0;
           45  +  for(set<double>::iterator it=vv.begin(); it!=vv.end(); ++it)
           46  +  {
           47  +   double X = *it;
           48  +
           49  +   int sat = 0;
           50  +   for(int i=0; i<inequalities.size(); ++i)
           51  +   {
           52  +    stringstream ss(inequalities[i]);
           53  +    char _; string OP; double C;
           54  +    ss >> _ >> OP >> C;
           55  +
           56  +    if( (OP=="<" && X<C)
           57  +     || (OP=="<=" && X<=C)
           58  +     || (OP=="=" && X==C)
           59  +     || (OP==">" && X>C)
           60  +     || (OP==">=" && X>=C) )
           61  +     ++sat;
           62  +   }
           63  +   maxSat = max(maxSat, sat);
           64  +  }
           65  +  return maxSat;
           66  + }
           67  +};
           68  +
           69  +// BEGIN CUT HERE
           70  +#include <ctime>
           71  +double start_time; string timer()
           72  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           73  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           74  + { os << "{ ";
           75  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           76  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           77  +void verify_case(const int& Expected, const int& Received) {
           78  + bool ok = (Expected == Received);
           79  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           80  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           81  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           82  +#define END  verify_case(_, Inequalities().maximumSubset(inequalities));}
           83  +int main(){
           84  +
           85  +CASE(0)
           86  + string inequalities_[] = {"X <= 12","X = 13","X > 9","X < 10","X >= 14"};
           87  +   vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_));
           88  + int _ = 3;
           89  +END
           90  +CASE(1)
           91  + string inequalities_[] = {"X < 0","X <= 0"};
           92  +   vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_));
           93  + int _ = 2;
           94  +END
           95  +CASE(2)
           96  + string inequalities_[] = {"X = 1","X = 2","X = 3","X > 0"};
           97  +   vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_));
           98  + int _ = 2;
           99  +END
          100  +CASE(3)
          101  + string inequalities_[] = {"X <= 521","X >= 521","X = 521","X > 902","X > 12","X <= 1000"};
          102  +   vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_));
          103  + int _ = 5;
          104  +END
          105  +CASE(4)
          106  + string inequalities_[] = {"X > 0"};
          107  +   vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_));
          108  + int _ = 1;
          109  +END
          110  +CASE(5)
          111  + string inequalities_[] = {"X > 0", "X <= 0"};
          112  +   vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_));
          113  + int _ = 1;
          114  +END
          115  +CASE(6)
          116  + string inequalities_[] = {"X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", "X = 0", };
          117  +   vector <string> inequalities(inequalities_, inequalities_+sizeof(inequalities_)/sizeof(*inequalities_));
          118  + int _ = 50;
          119  +END
          120  +
          121  +}
          122  +// END CUT HERE

Added SRM/459-U/1B.cpp version [9ca9b4bf809d337c]

            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 NumberPyramids { public:
           23  + int count(int baseLength, int top)
           24  + {
           25  +  const int n = baseLength-1;
           26  +  const int s = top - (1<<n);
           27  +  if( s<0 || n>20 )
           28  +   return 0;
           29  +
           30  +  vector<int> dp(s+1, 0);
           31  +  dp[0] = 1;
           32  +
           33  +  for(int i=0, nCi=1; i<=n; ++i, nCi=nCi*(n-i+1)/i)
           34  +   for(int x=nCi; x<=s; ++x)
           35  +    (dp[x] += dp[x-nCi]) %= 1000000009;
           36  +
           37  +  return dp[s];
           38  + }
           39  +};
           40  +
           41  +// BEGIN CUT HERE
           42  +#include <ctime>
           43  +double start_time; string timer()
           44  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           45  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           46  + { os << "{ ";
           47  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           48  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           49  +void verify_case(const int& Expected, const int& Received) {
           50  + bool ok = (Expected == Received);
           51  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           52  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           53  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           54  +#define END  verify_case(_, NumberPyramids().count(baseLength, top));}
           55  +int main(){
           56  +
           57  +CASE(0)
           58  + int baseLength = 3;
           59  + int top = 5;
           60  + int _ = 2;
           61  +END
           62  +CASE(1)
           63  + int baseLength = 5;
           64  + int top = 16;
           65  + int _ = 1;
           66  +END
           67  +CASE(2)
           68  + int baseLength = 4;
           69  + int top = 15;
           70  + int _ = 24;
           71  +END
           72  +CASE(3)
           73  + int baseLength = 15;
           74  + int top = 31556;
           75  + int _ = 74280915;
           76  +END
           77  +CASE(4)
           78  + int baseLength = 150;
           79  + int top = 500;
           80  + int _ = 0;
           81  +END
           82  +CASE(5)
           83  + int baseLength = 2;
           84  + int top = 3;
           85  + int _ = 2;
           86  +END
           87  +CASE(6)
           88  + int baseLength = 20;
           89  + int top = 1000000;
           90  + int _ = 503596690;
           91  +END
           92  +
           93  +}
           94  +// END CUT HERE

Added SRM/460-U/1A.cpp version [70b68db021e8c302]

            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  +LL comb(LL n, LL k)
           23  +{
           24  + k = min(k, n-k);
           25  +
           26  + LL c = 1;
           27  + for(LL i=0; i<k; ++i)
           28  +  c *= n-i, c /= i+1;
           29  + return c;
           30  +}
           31  +
           32  +class TheQuestionsAndAnswersDivOne { public:
           33  + int find(int questions, vector <string> answers)
           34  + {
           35  +  int Y = count(answers.begin(), answers.end(), string("Yes"));
           36  +  int N = count(answers.begin(), answers.end(), string( "No"));
           37  +
           38  +  int cnt = 0;
           39  +  for(int y=0; y<=questions; ++y)
           40  +  {
           41  +   int n = questions - y;
           42  +   if( y<=Y && n<=N )
           43  +    cnt += distr(Y,y)*distr(N,n)*comb(questions, y);
           44  +  }
           45  +  return cnt;
           46  + }
           47  +
           48  + int distr(int n, int k)
           49  + {
           50  +  if( k <= 1 )
           51  +   return (k==1 || n==0&&k==0) ? 1 : 0;
           52  +  int sum = 0;
           53  +  for(int m=1; m<(1<<n); ++m) {
           54  +   int pop = 0;
           55  +   for(int i=1; i<=m; i<<=1)
           56  +    if(m&i)
           57  +     ++pop;
           58  +   if( n-pop >= k-1 )
           59  +    sum += distr(n-pop, k-1);
           60  +  }
           61  +  return sum;
           62  + }
           63  +};
           64  +
           65  +// BEGIN CUT HERE
           66  +#include <ctime>
           67  +double start_time; string timer()
           68  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           69  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           70  + { os << "{ ";
           71  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           72  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           73  +void verify_case(const int& Expected, const int& Received) {
           74  + bool ok = (Expected == Received);
           75  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           76  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           77  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           78  +#define END  verify_case(_, TheQuestionsAndAnswersDivOne().find(questions, answers));}
           79  +int main(){
           80  +
           81  +CASE(0)
           82  + int questions = 2;
           83  + string answers_[] = {"No", "Yes"};
           84  +   vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_));
           85  + int _ = 2;
           86  +END
           87  +CASE(1)
           88  + int questions = 2;
           89  + string answers_[] = {"No", "No", "No"};
           90  +   vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_));
           91  + int _ = 6;
           92  +END
           93  +CASE(2)
           94  + int questions = 3;
           95  + string answers_[] = {"Yes", "No", "No", "Yes"};
           96  +   vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_));
           97  + int _ = 12;
           98  +END
           99  +CASE(3)
          100  + int questions = 3;
          101  + string answers_[] = {"Yes", "Yes", "Yes", "No"};
          102  +   vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_));
          103  + int _ = 18;
          104  +END
          105  +CASE(4)
          106  + int questions = 2;
          107  + string answers_[] = {"Yes","Yes"};
          108  +   vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_));
          109  + int _ = 2;
          110  +END
          111  +CASE(4)
          112  + int questions = 2;
          113  + string answers_[] = {"No","No"};
          114  +   vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_));
          115  + int _ = 2;
          116  +END
          117  +CASE(4)
          118  + int questions = 2;
          119  + string answers_[] = {"Yes","No"};
          120  +   vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_));
          121  + int _ = 2;
          122  +END
          123  +CASE(5)
          124  + int questions = 7;
          125  + string answers_[] = {"Yes","Yes","Yes","Yes","Yes","Yes","Yes","Yes","Yes"};
          126  +   vector <string> answers(answers_, answers_+sizeof(answers_)/sizeof(*answers_));
          127  + int _ = 40320*9;
          128  +END
          129  +
          130  +}
          131  +// END CUT HERE

Added SRM/460-U/1B.cpp version [2b2ccff9854de3ab]

            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  +template<typename T>
           23  +struct DP3
           24  +{
           25  + int N1, N2, N3;
           26  + vector<T> data;
           27  + DP3(int N1, int N2, int N3, const T& t = T())
           28  +  : N1(N1), N2(N2), N3(N3), data(N1*N2*N3, t) {}
           29  + T& operator()(int i1, int i2, int i3)
           30  +  { return data[ ((i1*N2)+i2)*N3+i3 ]; }
           31  + void swap(DP3& rhs)
           32  +  { data.swap(rhs.data); }
           33  +};
           34  +
           35  +class TheFansAndMeetingsDivOne { public:
           36  + double find(vector <int> minJ, vector <int> maxJ, vector <int> minB, vector <int> maxB, int k)
           37  + {
           38  +  const int N = minJ.size();
           39  +  const int S = max( accumulate(maxB.begin(), maxB.end(), 0), accumulate(maxJ.begin(), maxJ.end(), 0) );
           40  +
           41  +  DP3<double> dpJ(41,41,1601);
           42  +  dpJ(0,0,0) = 1.0;
           43  +  for(int i=1; i<=N; ++i)
           44  +  for(int vis=0; vis<=k; ++vis)
           45  +  for(int s=0; s<=S; ++s)
           46  +  {
           47  +   double PP = 0;
           48  +   if(vis)
           49  +    for(int p=minJ[i-1]; p<=maxJ[i-1] && p<=s; ++p)
           50  +     PP += dpJ(vis-1, i-1, s-p);
           51  +   dpJ(vis,i,s) = dpJ(vis, i-1, s) + PP / (maxJ[i-1]-minJ[i-1]+1);
           52  +  }
           53  +
           54  +  DP3<double> dpB(41,41,1601);
           55  +  dpB(0,0,0) = 1.0;
           56  +  for(int i=1; i<=N; ++i)
           57  +  for(int vis=0; vis<=k; ++vis)
           58  +  for(int s=0; s<=S; ++s)
           59  +  {
           60  +   double PP = 0;
           61  +   if(vis)
           62  +    for(int p=minB[i-1]; p<=maxB[i-1] && p<=s; ++p)
           63  +     PP += dpB(vis-1, i-1, s-p);
           64  +   dpB(vis,i,s) = dpB(vis, i-1, s) + PP / (maxB[i-1]-minB[i-1]+1);
           65  +  }
           66  +
           67  +  double ans = 0.0, nB=0.0, nJ=0.0;
           68  +  for(int s=0; s<=S; ++s)
           69  +   nB += dpB(k, N, s), nJ += dpJ(k, N, s);
           70  +  for(int s=0; s<=S; ++s)
           71  +   ans += dpB(k, N, s) * dpJ(k, N, s) / nB / nJ;
           72  +  return ans;
           73  + }
           74  +};
           75  +
           76  +// BEGIN CUT HERE
           77  +#include <ctime>
           78  +double start_time; string timer()
           79  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           80  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           81  + { os << "{ ";
           82  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           83  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           84  +void verify_case(const double& Expected, const double& Received) {
           85  + double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 1e-9);
           86  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           87  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           88  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           89  +#define END  verify_case(_, TheFansAndMeetingsDivOne().find(minJ, maxJ, minB, maxB, k));}
           90  +int main(){
           91  +
           92  +CASE(0)
           93  + int minJ_[] = {1};
           94  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
           95  + int maxJ_[] = {9};
           96  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
           97  + int minB_[] = {5};
           98  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
           99  + int maxB_[] = {5};
          100  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          101  + int k = 1;
          102  + double _ = 0.1111111111111111;
          103  +END
          104  +CASE(0)
          105  + int minJ_[] = {5};
          106  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
          107  + int maxJ_[] = {5};
          108  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
          109  + int minB_[] = {1};
          110  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
          111  + int maxB_[] = {9};
          112  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          113  + int k = 1;
          114  + double _ = 0.1111111111111111;
          115  +END
          116  +CASE(1)
          117  + int minJ_[] = {5, 2, 5, 1, 1, 2, 4, 1};
          118  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
          119  + int maxJ_[] = {7, 6, 7, 3, 4, 3, 5, 1};
          120  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
          121  + int minB_[] = {8, 9, 7, 11, 12, 7, 8, 40};
          122  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
          123  + int maxB_[] = {9, 10, 9, 33, 14, 7, 11, 40};
          124  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          125  + int k = 2;
          126  + double _ = 4.724111866969009E-5;
          127  +END
          128  +CASE(1)
          129  + int minJ_[] = {8, 9, 7, 11, 12, 7, 8, 40};
          130  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
          131  + int maxJ_[] = {9, 10, 9, 33, 14, 7, 11, 40};
          132  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
          133  + int minB_[] = {5, 2, 5, 1, 1, 2, 4, 1};
          134  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
          135  + int maxB_[] = {7, 6, 7, 3, 4, 3, 5, 1};
          136  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          137  + int k = 2;
          138  + double _ = 4.724111866969009E-5;
          139  +END
          140  +CASE(2)
          141  + int minJ_[] = {4, 7, 4};
          142  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
          143  + int maxJ_[] = {7, 7, 7};
          144  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
          145  + int minB_[] = {40, 40, 40};
          146  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
          147  + int maxB_[] = {40, 40, 40};
          148  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          149  + int k = 1;
          150  + double _ = 0.0;
          151  +END
          152  +CASE(2)
          153  + int minJ_[] = {40, 40, 40};
          154  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
          155  + int maxJ_[] = {40, 40, 40};
          156  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
          157  + int minB_[] = {4, 7, 4};
          158  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
          159  + int maxB_[] = {7, 7, 7};
          160  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          161  + int k = 1;
          162  + double _ = 0.0;
          163  +END
          164  +CASE(3)
          165  + int minJ_[] = {3, 6, 2, 1, 1, 10, 3};
          166  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
          167  + int maxJ_[] = {6, 9, 5, 6, 5, 10, 9};
          168  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
          169  + int minB_[] = {1, 1, 1, 1, 8, 3, 1};
          170  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
          171  + int maxB_[] = {3, 9, 7, 3, 10, 6, 5};
          172  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          173  + int k = 4;
          174  + double _ = 0.047082056525158976;
          175  +END
          176  +CASE(4)
          177  + int minJ_[] = {40};
          178  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
          179  + int maxJ_[] = {40};
          180  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
          181  + int minB_[] = {40};
          182  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
          183  + int maxB_[] = {40};
          184  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          185  + int k = 1;
          186  + double _ = 1.0;
          187  +END
          188  +CASE(5)
          189  +//1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
          190  +//40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40
          191  + int minJ_[] = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10};
          192  +   vector <int> minJ(minJ_, minJ_+sizeof(minJ_)/sizeof(*minJ_));
          193  + int maxJ_[] = {30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30};
          194  +   vector <int> maxJ(maxJ_, maxJ_+sizeof(maxJ_)/sizeof(*maxJ_));
          195  + int minB_[] = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10};
          196  +   vector <int> minB(minB_, minB_+sizeof(minB_)/sizeof(*minB_));
          197  + int maxB_[] = {30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30};
          198  +   vector <int> maxB(maxB_, maxB_+sizeof(maxB_)/sizeof(*maxB_));
          199  + int k = 40;
          200  + double _ = -1;
          201  +END
          202  +
          203  +}
          204  +// END CUT HERE

Added SRM/460-U/1C-U.cpp version [94cf308d5baaaf21]

            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 LL MODVAL = 1234567891;
           23  +struct UnionFind
           24  +{
           25  + vector<int> uf, sz, cyc;
           26  + int nc;
           27  +
           28  + bool operator<(const UnionFind& rhs) const {
           29  +  if( nc != rhs.nc ) return nc < rhs.nc;
           30  +  if( uf != rhs.uf ) return uf < rhs.uf;
           31  +  if( sz != rhs.sz ) return sz < rhs.sz;
           32  +  return cyc < rhs.cyc;
           33  + }
           34  +
           35  + UnionFind(int N): uf(N), sz(N,1), cyc(N), nc(N)
           36  +  { for(int i=0; i<N; ++i) uf[i] = i; }
           37  + int size()
           38  +  { return nc; }
           39  + int Find(int a)
           40  +  { return uf[a]==a ? a : uf[a]=Find(uf[a]); }
           41  + int Union(int a, int b)
           42  +  {
           43  +   a = Find(a);
           44  +   b = Find(b);
           45  +   if( a != b )
           46  +   {
           47  +    if( sz[a] >= sz[b] ) swap(a, b);
           48  +    uf[a] = b;
           49  +    sz[b] += sz[a];
           50  +    cyc[b] += cyc[a];
           51  +    --nc;
           52  +   }
           53  +   else
           54  +    cyc[a] ++;
           55  +   return cyc[a];
           56  +  }
           57  +};
           58  +
           59  +class TheCitiesAndRoadsDivOne { public:
           60  + int find(vector <string> map)
           61  + {
           62  +  int N = map.size();
           63  +  UnionFind uf(N);
           64  +
           65  +  for(int i=0; i<N; ++i)
           66  +   for(int j=i+1; j<N; ++j)
           67  +    if( map[i][j]=='Y' )
           68  +     if( uf.Union(i, j) >= 2 )
           69  +      return 0;
           70  +  return rec(uf, 0, 1, N, map);
           71  + }
           72  +
           73  + map< pair<UnionFind,int>, int > memo;
           74  + int rec(UnionFind& uf, int i, int j , int N, vector<string>& map)
           75  + {
           76  +  if( i == N )
           77  +   return uf.nc==1 ? 1 : 0;
           78  +  if( j == N )
           79  +   return rec(uf, i+1, i+2, N, map);
           80  +
           81  +  pair<UnionFind,int> key(uf, i*N+j);
           82  +  if( memo.count(key) )
           83  +   return memo[key];
           84  +
           85  +  LL cnt = rec(uf, i, j+1, N, map);
           86  +  if( map[i][j] == 'N' )
           87  +  {
           88  +   UnionFind uf2(uf);
           89  +   if( uf2.Union(i,j) < 2 )
           90  +    cnt = (cnt + rec(uf2,i,j+1,N,map)) % MODVAL;
           91  +  }
           92  +  return memo[key] = (int)cnt;
           93  + }
           94  +};
           95  +
           96  +// BEGIN CUT HERE
           97  +#include <ctime>
           98  +double start_time; string timer()
           99  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          100  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          101  + { os << "{ ";
          102  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          103  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          104  +void verify_case(const int& Expected, const int& Received) {
          105  + bool ok = (Expected == Received);
          106  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          107  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          108  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          109  +#define END  verify_case(_, TheCitiesAndRoadsDivOne().find(map));}
          110  +int main(){
          111  +
          112  +CASE(0)
          113  + string map_[] = {"NN",
          114  + "NN"};
          115  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          116  + int _ = 1;
          117  +END
          118  +CASE(1)
          119  + string map_[] = {"NNY",
          120  + "NNN",
          121  + "YNN"};
          122  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          123  + int _ = 3;
          124  +END
          125  +CASE(2)
          126  + string map_[] = {"NY",
          127  + "YN"};
          128  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          129  + int _ = 1;
          130  +END
          131  +CASE(3)
          132  + string map_[] = {"NYNN",
          133  + "YNNN",
          134  + "NNNY",
          135  + "NNYN"};
          136  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          137  + int _ = 10;
          138  +END
          139  +CASE(4)
          140  + string map_[] = {"NNNNNNNNNNNN",
          141  + "NNNNNNNNNNNN",
          142  + "NNNNNNNNNNNN",
          143  + "NNNNNNNNNNNN",
          144  + "NNNNNNNNNNNN",
          145  + "NNNNNNNNNNNN",
          146  + "NNNNNNNNNNNN",
          147  + "NNNNNNNNNNNN",
          148  + "NNNNNNNNNNNN",
          149  + "NNNNNNNNNNNN",
          150  + "NNNNNNNNNNNN",
          151  + "NNNNNNNNNNNN"};
          152  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          153  + int _ = 1137797187;
          154  +END
          155  +CASE(5)
          156  + string map_[] = {"N"};
          157  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          158  + int _ = 1;
          159  +END
          160  +CASE(6)
          161  + string map_[] = {"NYYNN",
          162  + "YNYNN",
          163  + "YYNNN",
          164  + "NNNNY",
          165  + "NNNYN"};
          166  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          167  + int _ = 6;
          168  +END
          169  +/*
          170  +CASE(7)
          171  + string map_[] = ;
          172  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          173  + int _ = ;
          174  +END
          175  +CASE(8)
          176  + string map_[] = ;
          177  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          178  + int _ = ;
          179  +END
          180  +*/
          181  +}
          182  +// END CUT HERE

Added SRM/461-U/1A.cpp version [0fb66fe6be1bd22d]

            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 <limits.h>
           18  +#include <cstring>
           19  +using namespace std;
           20  +typedef long long LL;
           21  +typedef complex<double> CMP;
           22  +
           23  +class ColoringRectangle { public:
           24  + int chooseDisks(int width, int height, vector <int> red, vector <int> blue)
           25  + {
           26  +  vector<double> R;
           27  +  for(int i=0; i<red.size(); ++i) {
           28  +   double r = red[i]/2.0;
           29  +   if( r < height/2 )
           30  +    continue;
           31  +   R.push_back( sqrt(r*r - (height/2.0)*(height/2.0))*2 );
           32  +  }
           33  +  vector<double> B;
           34  +  for(int i=0; i<blue.size(); ++i) {
           35  +   double r = blue[i]/2.0;
           36  +   if( r < height/2 )
           37  +    continue;
           38  +   B.push_back( sqrt(r*r - (height/2.0)*(height/2.0))*2 );
           39  +  }
           40  +  sort(R.rbegin(), R.rend());
           41  +  sort(B.rbegin(), B.rend());
           42  +
           43  +  int m = f(R, B, width);
           44  +  int n = f(B, R, width);
           45  +  int a = min(m,n);
           46  +  if( a == INT_MAX )
           47  +   return -1;
           48  +  return a;
           49  + }
           50  + int f(vector<double>& R, vector<double>& B, double W) {
           51  +  double w = 0;
           52  +  for(int i=0 ;; ++i) {
           53  +   if( i%2 == 0 ) {
           54  +    if( i/2>=R.size() )
           55  +     return INT_MAX;
           56  +    w += R[i/2];
           57  +    if( W <= w )
           58  +     return i+1;
           59  +   } else {
           60  +    if( i/2>=B.size() )
           61  +     return INT_MAX;
           62  +    w += B[i/2];
           63  +    if( W <= w )
           64  +     return i+1;
           65  +   }
           66  +  }
           67  + }
           68  +};
           69  +
           70  +// BEGIN CUT HERE
           71  +#include <ctime>
           72  +double start_time; string timer()
           73  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           74  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           75  + { os << "{ ";
           76  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           77  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           78  +void verify_case(const int& Expected, const int& Received) {
           79  + bool ok = (Expected == Received);
           80  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           81  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           82  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           83  +#define END  verify_case(_, ColoringRectangle().chooseDisks(width, height, red, blue));}
           84  +int main(){
           85  +
           86  +CASE(0)
           87  + int width = 11;
           88  + int height = 3;
           89  + int red_[] = {5,5};
           90  +   vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_));
           91  + int blue_[] = {2,5};
           92  +   vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_));
           93  + int _ = 3;
           94  +END
           95  +CASE(1)
           96  + int width = 30;
           97  + int height = 5;
           98  + int red_[] = {4,10,7,8,10};
           99  +   vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_));
          100  + int blue_[] = {5,6,11,7,5};
          101  +   vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_));
          102  + int _ = 4;
          103  +END
          104  +CASE(2)
          105  + int width = 16;
          106  + int height = 4;
          107  + int red_[] = {6,5,7};
          108  +   vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_));
          109  + int blue_[] = {5};
          110  +   vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_));
          111  + int _ = -1;
          112  +END
          113  +CASE(3)
          114  + int width = 4;
          115  + int height = 4;
          116  + int red_[] = {5};
          117  +   vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_));
          118  + int blue_[] = {6};
          119  +   vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_));
          120  + int _ = 1;
          121  +END
          122  +CASE(4)
          123  + int width = 6;
          124  + int height = 2;
          125  + int red_[] = {6,6};
          126  +   vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_));
          127  + int blue_[] = {2};
          128  +   vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_));
          129  + int _ = 3;
          130  +END
          131  +CASE(5)
          132  + int width = 16;
          133  + int height = 13;
          134  + int red_[] = {20};
          135  +   vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_));
          136  + int blue_[] = {20};
          137  +   vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_));
          138  + int _ = -1;
          139  +END
          140  +/*
          141  +CASE(6)
          142  + int width = ;
          143  + int height = ;
          144  + int red_[] = ;
          145  +   vector <int> red(red_, red_+sizeof(red_)/sizeof(*red_));
          146  + int blue_[] = ;
          147  +   vector <int> blue(blue_, blue_+sizeof(blue_)/sizeof(*blue_));
          148  + int _ = ;
          149  +END
          150  +*/
          151  +}
          152  +// END CUT HERE

Added SRM/461-U/1B.cpp version [800766c7be5a99d9]

            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 BuildingCities { public:
           23  +   int findMinimumCities(int maxDirect, int maxTravel, vector <int> cityX, vector <int> cityY)
           24  +   {
           25  +      int result = 0x7fffffff;
           26  +
           27  +      const int N = cityX.size();
           28  +      typedef pair<int,    int>  vert; // city, extra_city_built
           29  +      typedef pair<double, vert> cedge;
           30  +
           31  +      // dijkstra
           32  +      set<vert> V;
           33  +      priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           34  +      Q.push( cedge(0, vert(0,0)) );
           35  +      while( !Q.empty() )
           36  +      {
           37  +         double d = Q.top().first;
           38  +         vert   v = Q.top().second;
           39  +         Q.pop();
           40  +         if( V.count(v) )
           41  +            continue;
           42  +         V.insert(v);
           43  +
           44  +         int vc = v.first;
           45  +         int vs = v.second;
           46  +         if( vc==N-1 )
           47  +            result = min(result, vs);
           48  +
           49  +         for(int j=0; j<N; ++j) if( vc != j )
           50  +         {
           51  +            double dd = hypot( cityX[vc] -cityX[j], cityY[vc] -cityY[j] );
           52  +            double dx = hypot( cityX[N-1]-cityX[j], cityY[N-1]-cityY[j] );
           53  +            vert u(j, vs+int(dd/maxDirect - 1e-10));
           54  +            if( d+dd+dx<=maxTravel && !V.count(u) && u.second<result )
           55  +               Q.push( cedge(d+dd, u) );
           56  +         }
           57  +      }
           58  +      return result==0x7fffffff ? -1 : result;
           59  +   }
           60  +};
           61  +
           62  +// BEGIN CUT HERE
           63  +#include <ctime>
           64  +double start_time; string timer()
           65  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           66  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           67  + { os << "{ ";
           68  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           69  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           70  +void verify_case(const int& Expected, const int& Received) {
           71  + bool ok = (Expected == Received);
           72  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           73  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           74  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           75  +#define END    verify_case(_, BuildingCities().findMinimumCities(maxDirect, maxTravel, cityX, cityY));}
           76  +int main(){
           77  +
           78  +CASE(0)
           79  +   int maxDirect = 1;
           80  +   int maxTravel = 5;
           81  +   int cityX_[] = {0,0,0,1,2,2,3};
           82  +     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_));
           83  +   int cityY_[] = {0,1,2,2,2,1,1};
           84  +     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_));
           85  +   int _ = 1;
           86  +END
           87  +CASE(1)
           88  +   int maxDirect = 3;
           89  +   int maxTravel = 15;
           90  +   int cityX_[] = {2,6,10,14};
           91  +     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_));
           92  +   int cityY_[] = {2,6,2,6};
           93  +     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_));
           94  +   int _ = 3;
           95  +END
           96  +CASE(2)
           97  +   int maxDirect = 2;
           98  +   int maxTravel = 15;
           99  +   int cityX_[] = {0,5,2,3,1,8,6,4,7,9,10};
          100  +     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_));
          101  +   int cityY_[] = {0,5,2,3,1,8,6,4,7,9,10};
          102  +     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_));
          103  +   int _ = 0;
          104  +END
          105  +CASE(3)
          106  +   int maxDirect = 2;
          107  +   int maxTravel = 5;
          108  +   int cityX_[] = {0,5};
          109  +     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_));
          110  +   int cityY_[] = {0,5};
          111  +     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_));
          112  +   int _ = -1;
          113  +END
          114  +CASE(4)
          115  +   int maxDirect = 5;
          116  +   int maxTravel = 1500;
          117  +   int cityX_[] = {0,1000};
          118  +     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_));
          119  +   int cityY_[] = {0,1000};
          120  +     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_));
          121  +   int _ = 282;
          122  +END
          123  +/*
          124  +CASE(5)
          125  +   int maxDirect = ;
          126  +   int maxTravel = ;
          127  +   int cityX_[] = ;
          128  +     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_));
          129  +   int cityY_[] = ;
          130  +     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_));
          131  +   int _ = ;
          132  +END
          133  +CASE(6)
          134  +   int maxDirect = ;
          135  +   int maxTravel = ;
          136  +   int cityX_[] = ;
          137  +     vector <int> cityX(cityX_, cityX_+sizeof(cityX_)/sizeof(*cityX_));
          138  +   int cityY_[] = ;
          139  +     vector <int> cityY(cityY_, cityY_+sizeof(cityY_)/sizeof(*cityY_));
          140  +   int _ = ;
          141  +END
          142  +*/
          143  +}
          144  +// END CUT HERE

Added SRM/462/1A.cpp version [3ac34d38668840d0]

            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 AgeEncoding { public:
           23  + double getRadix(int age, string c)
           24  + {
           25  +  int i = c.find('1');
           26  +  if( i==string::npos ) i = c.size();
           27  +  c = c.substr(i);
           28  +
           29  +  int N = c.size();
           30  +  if( N == 0 )
           31  +   return -1;
           32  +  if( N == 1 )
           33  +   return (age==1 ? -2 : -1);
           34  +  if( age == 1 && c[N-1]=='1' )
           35  +   return -1;
           36  +
           37  +  double L=0, R=1;
           38  +  for(;;R*=2){
           39  +   double fR = 0.0;
           40  +   for(int i=0; i<N; ++i)
           41  +    fR +=pow(R,i)*(c[N-1-i]=='1');
           42  +   if(fR>age)
           43  +    break;
           44  +  }
           45  +
           46  +  for(int i=0; i<1000; ++i)
           47  +  {
           48  +   double C = (L+R)/2;
           49  +
           50  +   double fL = 0.0;
           51  +   for(int i=0; i<N; ++i)
           52  +    fL +=pow(L,i)*(c[N-1-i]=='1');
           53  +   double fR = 0.0;
           54  +   for(int i=0; i<N; ++i)
           55  +    fR +=pow(R,i)*(c[N-1-i]=='1');
           56  +   double fC = 0.0;
           57  +   for(int i=0; i<N; ++i)
           58  +    fC +=pow(C,i)*(c[N-1-i]=='1');
           59  +
           60  +   (age < fC ? R : L) = C;
           61  +  }
           62  +  return R;
           63  + }
           64  +};
           65  +
           66  +// BEGIN CUT HERE
           67  +#include <ctime>
           68  +double start_time; string timer()
           69  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           70  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           71  + { os << "{ ";
           72  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           73  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           74  +void verify_case(const double& Expected, const double& Received) {
           75  + double diff = Expected - Received; if (diff < 0) diff = -diff; bool ok = (diff < 1e-9);
           76  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           77  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           78  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           79  +#define END  verify_case(_, AgeEncoding().getRadix(age, candlesLine));}
           80  +int main(){
           81  +
           82  +CASE(0)
           83  + int age = 10;
           84  + string candlesLine = "00010";
           85  + double _ = 10.0;
           86  +END
           87  +CASE(1)
           88  + int age = 21;
           89  + string candlesLine = "10101";
           90  + double _ = 2.0;
           91  +END
           92  +CASE(2)
           93  + int age = 6;
           94  + string candlesLine = "10100";
           95  + double _ = 1.414213562373095;
           96  +END
           97  +CASE(3)
           98  + int age = 21;
           99  + string candlesLine = "10111111110111101111111100111111110111111111111100";
          100  + double _ = 0.9685012944510603;
          101  +END
          102  +CASE(4)
          103  + int age = 16;
          104  + string candlesLine = "1";
          105  + double _ = -1.0;
          106  +END
          107  +CASE(5)
          108  + int age = 1;
          109  + string candlesLine = "1";
          110  + double _ = -2.0;
          111  +END
          112  +CASE(6)
          113  + int age = 1;
          114  + string candlesLine = "001000";
          115  + double _ = 1.0;
          116  +END
          117  +CASE(7)
          118  + int age = 1;
          119  + string candlesLine = "110";
          120  + double _ = (sqrt(5)-1)/2;
          121  +END
          122  +CASE(8)
          123  + int age = 1;
          124  + string candlesLine = "0000";
          125  + double _ = -1;
          126  +END
          127  +CASE(9)
          128  + int age = 1;
          129  + string candlesLine = "11";
          130  + double _ = -1;
          131  +END
          132  +CASE(10)
          133  + int age = 1;
          134  + string candlesLine = "11";
          135  + double _ = -1;
          136  +END
          137  +
          138  +}
          139  +// END CUT HERE

Added SRM/462/1B.cpp version [da8cd7890ede0b8d]

            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  +vector< vector<double> > mMul( const vector< vector<double> >& A, const vector< vector<double> >& B )
           23  +{
           24  + const int n = A.size();
           25  +
           26  + vector< vector<double> > C(n, vector<double>(n));
           27  + for(int i=0; i<n; ++i)
           28  +  for(int j=0; j<n; ++j) {
           29  +   double Cij = 0;
           30  +   for(int k=0; k<n; ++k)
           31  +    Cij += A[i][k] * B[k][j];
           32  +   C[i][j] = Cij;
           33  +  }
           34  + return C;
           35  +}
           36  +
           37  +vector< vector<double> > mPow( vector< vector<double> > M, LL t )
           38  +{
           39  + vector< vector<double> > R;
           40  + if( t == 0 ) {
           41  +  const int n = M.size();
           42  +  R = M;
           43  +  for(int i=0; i<n; ++i)
           44  +   for(int j=0; j<n; ++j)
           45  +    R[i][j] = (i==j);
           46  +  return R;
           47  + }
           48  +
           49  + for(; t; t>>=1, M=mMul(M,M))
           50  +  if( t&1 )
           51  +   R = (R.empty() ? M : mMul(R,M));
           52  + return R;
           53  +}
           54  +
           55  +class CandyBox { public:
           56  + vector <double> expectedScore(int C, vector <int> score, int S)
           57  + {
           58  +  int N = score.size();
           59  +
           60  +  vector< vector<double> > m(N, vector<double>(N));
           61  +  for(int i=0; i<N; ++i)
           62  +   for(int j=0; j<N; ++j) {
           63  +    double pOut  = 2.0/(N*(N*C-1));
           64  +    m[i][j] = (i==j ? 1-pOut*(N-1) : pOut);
           65  +   }
           66  +  m = mPow(m, S);
           67  +
           68  +  double as = accumulate(score.begin(), score.end(), 0.0);
           69  +  double stay = m[0][0];
           70  +  double  out = (N==1 ? 0 : m[1][0]);
           71  +
           72  +  vector<double> result(N);
           73  +  for(int i=0; i<N; ++i)
           74  +   result[i] = (as-score[i])*out + score[i]*stay;
           75  +  return result;
           76  + }
           77  +};
           78  +
           79  +// BEGIN CUT HERE
           80  +#include <ctime>
           81  +double start_time; string timer()
           82  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           83  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           84  + { os << "{ ";
           85  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           86  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           87  +void verify_case(const vector <double>& Expected, const vector <double>& Received) {
           88  + bool ok = true;
           89  + for(int i=0; i<Expected.size(); ++i)
           90  +   if( abs(Expected[i]-Received[i])>1e-9 )
           91  +     ok = false;
           92  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           93  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           94  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           95  +#define END  verify_case(_, CandyBox().expectedScore(C, score, S));}
           96  +int main(){
           97  +
           98  +CASE(0)
           99  + int C = 10;
          100  + int score_[] = {1, 10};
          101  +   vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_));
          102  + int S = 0;
          103  + double __[] = {1.0, 10.0 };
          104  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          105  +END
          106  +CASE(1)
          107  + int C = 2;
          108  + int score_[] = {1, 10};
          109  +   vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_));
          110  + int S = 1;
          111  + double __[] = {4.0, 7.000000000000001 };
          112  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          113  +END
          114  +CASE(2)
          115  + int C = 1;
          116  + int score_[] = {1, 4, 10};
          117  +   vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_));
          118  + int S = 1;
          119  + double __[] = {5.0, 5.0, 5.0 };
          120  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          121  +END
          122  +CASE(3)
          123  + int C = 98;
          124  + int score_[] = {13, 82, 74, 78, 12, 71, 81, 80, 30};
          125  +   vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_));
          126  + int S = 154;
          127  + double __[] = {26.25622829378155, 74.87969915903301, 69.24219529059805, 72.06094722481552, 25.551540310227182, 67.12813133993495, 74.17501117547864, 73.47032319192427, 38.23592401420582 };
          128  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          129  +END
          130  +CASE(4)
          131  + int C = 1;
          132  + int score_[] = {1,1};
          133  +   vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_));
          134  + int S = 1;
          135  + double __[] = {1,1};
          136  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          137  +END
          138  +CASE(5)
          139  + int C = 2;
          140  + int score_[] = {1};
          141  +   vector <int> score(score_, score_+sizeof(score_)/sizeof(*score_));
          142  + int S = 10000;
          143  + double __[] = {1};
          144  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          145  +END
          146  +}
          147  +// END CUT HERE

Added SRM/462/1C.cpp version [12341843ad5afdc4]

            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  +typedef int             vert;
           23  +typedef int             cost;
           24  +typedef pair<cost,vert> edge;
           25  +typedef vector<edge>    edges;
           26  +typedef vector<edges>   graph;
           27  +
           28  +static const cost INF   = 0x12345678; // large enough but INF+INF<2^31
           29  +static const vert START = 0;
           30  +static const vert GOAL  = 1;
           31  +
           32  +class WarTransportation { public:
           33  + int messenger(int n, vector <string> highways)
           34  + {
           35  +  return solve( parse(n, highways) );
           36  + }
           37  +
           38  + graph parse(int n, vector <string> highways)
           39  + {
           40  +  graph G(n);
           41  +
           42  +  string hi = accumulate(highways.begin(), highways.end(), string());
           43  +  for(int i=0; i<hi.size(); )
           44  +  {
           45  +   int k = hi.find(',', i);
           46  +   if( k == string::npos ) k = hi.size();
           47  +
           48  +   int a, b, c;
           49  +   stringstream(hi.substr(i,k-i)) >> a >> b >> c;
           50  +   G[a-1].push_back( edge(c,b-1) );
           51  +
           52  +   i = k+1;
           53  +  }
           54  +
           55  +  return G;
           56  + }
           57  +
           58  + int solve( const graph& G )
           59  + {
           60  +  // Suppose you reached the city "v", and found there the most critical load is broken.
           61  +  // How long will it take a detour to the GOAL?  It's ukai[v]!
           62  +
           63  +  vector<cost> ukai;
           64  +  for(int v=0; v<G.size(); ++v)
           65  +   ukai.push_back( ukaiDist(G,v) );
           66  +
           67  +  // Compute the least T such that:
           68  +  //   we get to the GOAL, making the worst case time <= T?
           69  +
           70  +  cost L=0, R=99999999;
           71  +  if( !reachable(G, ukai, R) ) return -1;
           72  +  if(  reachable(G, ukai, L) ) return 0;
           73  +
           74  +  // We can when T=R, and cannot T=L.
           75  +  // That is, T in (L, R]. Now let's binary-search!
           76  +
           77  +  while( R-L>1 )
           78  +   (reachable(G, ukai, (L+R)/2) ? R : L) = (L+R)/2;
           79  +  return R;
           80  + }
           81  +
           82  + cost ukaiDist( const graph& G, vert v )
           83  + {
           84  +  if( v == GOAL )        return 0;
           85  +  if( G[v].size() == 0 ) return INF;
           86  +
           87  +  cost worst = 0;
           88  +  for(int f=0; f<G[v].size(); ++f) // f : broken road
           89  +  {
           90  +   priority_queue< edge, vector<edge>, greater<edge> > Q;
           91  +   set<vert> V;
           92  +   V.insert(v);
           93  +   for(int i=0; i<G[v].size(); ++i) // push all loads from v, except f
           94  +    if( i != f )
           95  +     Q.push( G[v][i] );
           96  +   worst = max( worst, dijkstra(G,Q,V) ); // start dijkstraing
           97  +  }
           98  +  return worst;
           99  + }
          100  +
          101  +
          102  + bool reachable( const graph& G, const vector<cost>& ukai, cost ukaiLimit )
          103  + {
          104  +  priority_queue< edge, vector<edge>, greater<edge> > Q;
          105  +  set<vert> V;
          106  +  Q.push( edge(0,START) );
          107  +  return dijkstra(G, Q, V, ukai, ukaiLimit) != INF;
          108  + }
          109  +
          110  + cost dijkstra( const graph& G,
          111  +  priority_queue< edge, vector<edge>, greater<edge> >& Q, set<vert>& V,
          112  +  const vector<cost>& ukai=vector<cost>(), cost ukaiLimit=-1
          113  + ) {
          114  +  while( !Q.empty() )
          115  +  {
          116  +   // pop
          117  +   cost c = Q.top().first;
          118  +   vert v = Q.top().second;
          119  +   Q.pop();
          120  +
          121  +   // check
          122  +   if( V.count(v) || (ukaiLimit>=0 && c+ukai[v]>ukaiLimit) )
          123  +    continue;
          124  +   if( v == GOAL )
          125  +     return c;
          126  +   V.insert(v);
          127  +
          128  +   // next
          129  +   for(int i=0; i<G[v].size(); ++i)
          130  +    if( !V.count(G[v][i].second) )
          131  +     Q.push( edge(c+G[v][i].first, G[v][i].second) );
          132  +  }
          133  +  return INF;
          134  + }
          135  +};
          136  +
          137  +// BEGIN CUT HERE
          138  +#include <ctime>
          139  +double start_time; string timer()
          140  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          141  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          142  + { os << "{ ";
          143  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          144  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          145  +void verify_case(const int& Expected, const int& Received) {
          146  + bool ok = (Expected == Received);
          147  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          148  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          149  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          150  +#define END  verify_case(_, WarTransportation().messenger(n, highways));}
          151  +int main(){
          152  +
          153  +CASE(0)
          154  + int n = 3;
          155  + string highways_[] = {"1 2 1,1 3 2,3 2 3"};
          156  +   vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_));
          157  + int _ = 5;
          158  +END
          159  +CASE(1)
          160  + int n = 8;
          161  + string highways_[] = {"1 3 1,1 4 1,3 5 1,4 5 1,5 6 1,6 7 1,6 8 1,7 2 1,",
          162  + "8 2 1"};
          163  +   vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_));
          164  + int _ = -1;
          165  +END
          166  +CASE(2)
          167  + int n = 4;
          168  + string highways_[] = {"1 3 1,1 3 2,3 2 1,1 4 1,4 2 1"};
          169  +   vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_));
          170  + int _ = -1;
          171  +END
          172  +CASE(3)
          173  + int n = 4;
          174  + string highways_[] = {"1 3 1,3 2 1,1 4 1,4 2 1,3 4 1"};
          175  +   vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_));
          176  + int _ = 3;
          177  +END
          178  +CASE(4)
          179  + int n = 20;
          180  + string highways_[] = {"1 13 3,13 4 7,4 3 4,3 10 8,10 18 9,18 12 6,12 2 3,",
          181  + "1 17 6,17 13 6,13 9 4,9 10 8,10 7 2,7 5 5,5 19 9,1",
          182  + "9 14 6,14 16 9,16 18 7,18 15 5,15 20 3,20 12 9,12 ",
          183  + "8 4,8 11 3,11 4 1,4 3 7,3 2 3,20 10 2,1 18 2,16 19",
          184  + " 9,4 15 9,13 15 6"};
          185  +   vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_));
          186  + int _ = 23;
          187  +END
          188  +CASE(5)
          189  + int n = 30;
          190  + string highways_[] = {
          191  +  "11 22 752,9 28 573,8 20 549,2 29 96,12 25 835,11 2", "3 443,28 20 59,5 16 223,29 24 382,14 6 436,5 21 47", "7,28 1 290,20 23 567,6 26 347,14 8 436,23 7 585,22", " 14 829,19 8 897,18 7 161,29 22 446,6 3 47,6 11 11", "9,23 13 357,15 2 539,30 27 246,20 26 364,11 13 518", ",20 29 360,10 9 140,9 19 178,24 5 75,4 9 465,22 4 ", "271,21 25 632,25 16 705,23 19 777,15 11 668,25 6 9", "11,26 21 940,27 12 114,23 29 775,15 22 907,10 15 1", "86,25 21 727,26 7 324,15 21 251,20 7 369,29 9 5,5 ", "4 780,10 23 774,13 15 65,2 8 938,9 3 150,6 9 109,4", " 22 649,24 13 274,14 3 403,12 19 66,3 13 798,7 20 ", "912,24 14 751,25 27 575,14 20 580,2 5 110,24 7 215", ",1 5 194,3 2 786,2 19 716,22 24 331,9 21 375,15 9 ", "397,18 27 753,24 23 181,17 27 386,12 30 313,18 25 ", "155,19 24 162,11 7 533,13 2 307,20 21 100,14 24 52", "6,29 8 505,28 8 776,5 27 949,16 14 43,16 30 84,10 ", "1 323,12 18 590,8 15 357,12 6 185,20 8 328,26 4 83", ",5 10 67,1 11 582,9 23 610,16 1 246,6 4 679,22 21 ", "149,17 10 321,29 27 560,20 19 771,11 30 506,6 25 1", "83,1 23 948,23 17 125,26 5 912,15 23 470,30 10 293", ",4 18 313,11 19 261,16 29 259,19 5 408,18 12 960,2", "4 3 743,17 3 4,30 17 347,11 2 648,16 8 868,12 10 6", "50,21 14 425,5 28 947,10 13 578,14 15 681,5 2 656,", "16 12 447,26 27 915,16 10 477,8 25 994,20 10 582,9", " 7 420,10 26 389,20 22 360,26 10 321,28 19 922,23 ", "20 393,13 14 447,29 15 33,30 1 811,2 28 597,13 8 5", "9,18 29 437,23 2 101,30 12 999,1 27 701,19 28 534,", "23 21 518,3 11 589,18 14 662,5 14 455,16 15 230,2 ", "17 633,19 13 242,10 18 404,10 4 731,15 6 221,25 15", " 747,3 23 465,24 9 569,12 11 645,5 24 748,23 26 44", "4,30 21 451,29 17 141,25 3 292,26 6 400,18 8 497,2", "4 19 901,17 5 49,21 12 141,30 18 7,20 18 271,13 3 ", "17,29 4 952,2 13 903,1 24 558,25 1 125,14 13 914,1", "4 12 385,1 3 40,30 8 704,18 5 901,19 10 822,22 27 ", "938,5 18 808,5 29 1,10 8 791,2 7 920,12 5 359,5 9 ", "744,1 25 819,6 30 262,24 6 7,12 7 870,17 25 932,28", " 18 771,23 16 699,26 24 834,27 20 824,30 23 95,22 ", "5 553,26 29 150,25 4 70,4 20 501,9 16 291,2 30 40,", "19 18 602,19 3 108,29 11 827,19 22 702,26 11 238,2", "8 22 392,22 10 496,13 25 160,12 24 700,22 29 654,9", " 2 701,28 7 946,21 5 223,7 22 902,12 15 43,21 8 67", "8,28 27 946,7 15 603,15 8 114,25 10 234,19 4 128,2", "4 8 990,11 12 554,23 9 646,10 24 755,8 16 857,23 1", " 806,15 13 929,21 11 601,19 30 245,17 21 474,27 25", " 638,11 21 411,4 26 895,13 24 599,12 13 226,30 22 ", "104,30 24 53,29 10 69,29 30 263,28 6 349,6 16 982,", "4 6 273,1 30 533,29 21 443,7 3 867,17 11 756,1 7 6", "87,29 2 799,5 22 42,16 20 708,25 11 476,23 8 186,2", "3 3 820,23 18 226,21 9 429,17 26 201,25 26 79,12 2", " 671,23 14 698,10 30 92,3 25 380,14 30 420"};
          192  +   vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_));
          193  + int _ = 799;
          194  +END
          195  +/*
          196  +CASE(6)
          197  + int n = ;
          198  + string highways_[] = ;
          199  +   vector <string> highways(highways_, highways_+sizeof(highways_)/sizeof(*highways_));
          200  + int _ = ;
          201  +END
          202  +*/
          203  +}
          204  +// END CUT HERE

Added SRM/463-U/1A.cpp version [9b89d023895fe0e4]

            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 LL MODVAL = 1000000007;
           23  +class RabbitNumbering { public:
           24  + int theCount(vector <int> maxNumber)
           25  + {
           26  +  sort(maxNumber.begin(), maxNumber.end());
           27  +  LL c = 1;
           28  +  for(int i=0; i<maxNumber.size(); ++i)
           29  +   if( maxNumber[i]-i <= 0 )
           30  +    return 0;
           31  +   else
           32  +    c = (c * (maxNumber[i]-i)) % MODVAL;
           33  +  return c;
           34  + }
           35  +};
           36  +
           37  +// BEGIN CUT HERE
           38  +#include <ctime>
           39  +double start_time; string timer()
           40  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           41  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           42  + { os << "{ ";
           43  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           44  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           45  +void verify_case(const int& Expected, const int& Received) {
           46  + bool ok = (Expected == Received);
           47  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           48  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           49  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           50  +#define END  verify_case(_, RabbitNumbering().theCount(maxNumber));}
           51  +int main(){
           52  +
           53  +CASE(0)
           54  + int maxNumber_[] = {5};
           55  +   vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_));
           56  + int _ = 5;
           57  +END
           58  +CASE(1)
           59  + int maxNumber_[] = {4, 4, 4, 4};
           60  +   vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_));
           61  + int _ = 24;
           62  +END
           63  +CASE(2)
           64  + int maxNumber_[] = {5, 8};
           65  +   vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_));
           66  + int _ = 35;
           67  +END
           68  +CASE(3)
           69  + int maxNumber_[] = {2, 1, 2};
           70  +   vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_));
           71  + int _ = 0;
           72  +END
           73  +CASE(4)
           74  + int maxNumber_[] = {25, 489, 76, 98, 704, 98, 768, 39, 697, 8, 56, 74, 36, 95, 87, 2, 968, 4, 920, 54, 873, 90};
           75  +   vector <int> maxNumber(maxNumber_, maxNumber_+sizeof(maxNumber_)/sizeof(*maxNumber_));
           76  + int _ = 676780400;
           77  +END
           78  +
           79  +}
           80  +// END CUT HERE

Added SRM/463-U/1B.cpp version [72b87e10d5e14a67]

            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 Nisoku { public:
           23  +   double theMax(vector <double> cards)
           24  +   {
           25  +      sort(cards.begin(), cards.end());
           26  +
           27  +      double ans = 0.0;
           28  +      for(int i=0; 2*i<=cards.size(); ++i)
           29  +         ans = max(ans,
           30  +            accumulate(cards.begin()+2*i, cards.end(),
           31  +               inner_product( cards.begin(), cards.begin()+i,
           32  +                              cards.rend()-2*i,
           33  +                              1.0, multiplies<double>(), plus<double>() ),
           34  +               multiplies<double>()
           35  +            )
           36  +         );
           37  +      return ans;
           38  +   }
           39  +};
           40  +
           41  +// BEGIN CUT HERE
           42  +#include <ctime>
           43  +double start_time; string timer()
           44  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           45  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           46  + { os << "{ ";
           47  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           48  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           49  +void verify_case(const double& Expected, const double& Received) {
           50  + bool ok = (abs(Expected - Received) < 1e-9);
           51  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           52  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           53  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           54  +#define END    verify_case(_, Nisoku().theMax(cards));}
           55  +int main(){
           56  +
           57  +CASE(0)
           58  +   double cards_[] = {5, 8};
           59  +     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_));
           60  +   double _ = 40.0;
           61  +END
           62  +CASE(1)
           63  +   double cards_[] = {1.5, 1.8};
           64  +     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_));
           65  +   double _ = 3.3;
           66  +END
           67  +CASE(2)
           68  +   double cards_[] = {8.26, 7.54, 3.2567};
           69  +     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_));
           70  +   double _ = 202.82857868;
           71  +END
           72  +CASE(3)
           73  +   double cards_[] = {1.5, 1.7, 1.6, 1.5};
           74  +     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_));
           75  +   double _ = 9.920000000000002;
           76  +END
           77  +CASE(4)
           78  +   double cards_[] = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
           79  +10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
           80  +10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
           81  +10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
           82  +10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
           83  +     vector <double> cards(cards_, cards_+sizeof(cards_)/sizeof(*cards_));
           84  +   double _ = 1.0E50;
           85  +END
           86  +
           87  +}
           88  +// END CUT HERE

Added SRM/463-U/1C-U.cpp version [7e42d41150443f38]

            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 MODVAL = 1000000007;
           23  +typedef pair<pair<LL,LL>,LL> state;
           24  +
           25  +class RabbitPuzzle { public:
           26  + int theCount(vector<long long> rabbits, vector<long long> nests, int K)
           27  + {
           28  +  state s(make_pair(rabbits[0],rabbits[1]), rabbits[2]);
           29  +  state g(make_pair(nests[0],nests[1]), nests[2]);
           30  +
           31  +  map<state,int> ms, mg;
           32  +  calc(s, K/2, ms);
           33  +  calc(g, (K+1)/2, mg);
           34  +
           35  +  int result = 0;
           36  +  for(map<state,int>::iterator it=ms.begin(); it!=ms.end(); ++it) {
           37  +   map<state,int>::iterator jt = mg.find(it->first);
           38  +   if( jt != mg.end() )
           39  +    result = (result + LL(it->second)*jt->second)%MODVAL;
           40  +  }
           41  +  return result;
           42  + }
           43  +
           44  + void calc(const state& s, int n, map<state,int>& m)
           45  + {
           46  +  if( n == 0 )
           47  +   (m[s] += 1) %= MODVAL;
           48  +  else {
           49  +   LL a = s.first.first;
           50  +   LL b = s.first.second;
           51  +   LL c = s.second;
           52  +   if( 2*b-a < c ) calc(state(make_pair(b,2*b-a),c), n-1, m);
           53  +   calc(state(make_pair(2*a-b,a),c), n-1, m);
           54  +   calc(state(make_pair(a,c),2*c-b), n-1, m);
           55  +   if( a < 2*b-c ) calc(state(make_pair(a,2*b-c),b), n-1, m);
           56  +  }
           57  + }
           58  +};
           59  +
           60  +// BEGIN CUT HERE
           61  +#include <ctime>
           62  +double start_time; string timer()
           63  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           64  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           65  + { os << "{ ";
           66  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           67  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           68  +void verify_case(const int& Expected, const int& Received) {
           69  + bool ok = (Expected == Received);
           70  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           71  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           72  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           73  +#define END  verify_case(_, RabbitPuzzle().theCount(rabbits, nests, K));}
           74  +int main(){
           75  +
           76  +CASE(0)
           77  + long rabbits_[] = {0, 5, 8};
           78  +   vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_));
           79  + long nests_[] = {0, 8, 11};
           80  +   vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_));
           81  + int K = 1;
           82  + int _ = 1;
           83  +END
           84  +CASE(1)
           85  + long rabbits_[] = {0, 5, 8};
           86  +   vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_));
           87  + long nests_[] = {0, 8, 11};
           88  +   vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_));
           89  + int K = 3;
           90  + int _ = 5;
           91  +END
           92  +CASE(2)
           93  + long rabbits_[] = {0, 5, 8};
           94  +   vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_));
           95  + long nests_[] = {0, 8, 11};
           96  +   vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_));
           97  + int K = 2;
           98  + int _ = 0;
           99  +END
          100  +CASE(3)
          101  + long rabbits_[] = {5, 8, 58};
          102  +   vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_));
          103  + long nests_[] = {13, 22, 64};
          104  +   vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_));
          105  + int K = 58;
          106  + int _ = 0;
          107  +END
          108  +CASE(4)
          109  + long rabbits_[] = {0, 1, 2};
          110  +   vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_));
          111  + long nests_[] = {1, 2, 3};
          112  +   vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_));
          113  + int K = 100;
          114  + int _ = 0;
          115  +END
          116  +CASE(5)
          117  + long rabbits_[] = {5, 8, 58};
          118  +   vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_));
          119  + long nests_[] = {20, 26, 61};
          120  +   vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_));
          121  + int K = 58;
          122  + int _ = 537851168;
          123  +END
          124  +CASE(6)
          125  + long rabbits_[] = {67, 281, 2348};
          126  +   vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_));
          127  + long nests_[] = {235, 1394, 3293};
          128  +   vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_));
          129  + int K = 83;
          130  + int _ = 167142023;
          131  +END
          132  +CASE(7)
          133  + long rabbits_[] = {-1000000000000000000, 999999999999999998, 999999999999999999};
          134  +   vector<long long> rabbits(rabbits_, rabbits_+sizeof(rabbits_)/sizeof(*rabbits_));
          135  + long nests_[] = {-1000000000000000000, 999999999999999999, 1000000000000000000};
          136  +   vector<long long> nests(nests_, nests_+sizeof(nests_)/sizeof(*nests_));
          137  + int K = 5;
          138  + int _ = 29;
          139  +END
          140  +
          141  +}
          142  +// END CUT HERE

Added SRM/464/1A.cpp version [22cbd7d786057de9]

            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 ColorfulStrings { public:
           23  + string getKth(int n, int k)
           24  + {
           25  +  // cannot have 11 distinct digits
           26  +  // if we have 0, then ...
           27  +  // if we have 1, then ...
           28  +  if(n>8)
           29  +   return "";
           30  +
           31  +  string s = (n>=2 ? "23456789" : "0123456789");
           32  +  do {
           33  +   if( is_colorful(s,n) )
           34  +    if( --k == 0 )
           35  +     return s.substr(0,n);
           36  +  } while( next_perm(s, n>=2 ? 8-n : 10-n) );
           37  +  return "";
           38  + }
           39  +
           40  + bool is_colorful(string& s, int n) {
           41  +  set<int> ps;
           42  +  for(int i=0; i<n; ++i) {
           43  +   int p = s[i]-'0';
           44  +   if( !ps.insert(p).second )
           45  +    return false;
           46  +   for(int j=i+1; j<n; ++j) {
           47  +    p *= s[j]-'0';
           48  +    if( !ps.insert(p).second )
           49  +     return false;
           50  +   }
           51  +  }
           52  +  return true;
           53  + }
           54  +
           55  + int fact(int n) {
           56  +  return n ? n*fact(n-1) : 1;
           57  + }
           58  + bool next_perm(string& s, int nn) {
           59  +  int f = fact(nn);
           60  +  while(f--)
           61  +   if( !next_permutation(s.begin(), s.end()) )
           62  +    return false;
           63  +  return true;
           64  + }
           65  +};
           66  +
           67  +// BEGIN CUT HERE
           68  +#include <ctime>
           69  +double start_time; string timer()
           70  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           71  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           72  + { os << "{ ";
           73  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           74  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           75  +void verify_case(const string& Expected, const string& Received) {
           76  + bool ok = (Expected == Received);
           77  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           78  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           79  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           80  +#define END  verify_case(_, ColorfulStrings().getKth(n, k));}
           81  +int main(){
           82  +
           83  +CASE(0)
           84  + int n = 3;
           85  + int k = 4;
           86  + string _ = "238";
           87  +END
           88  +CASE(1)
           89  + int n = 4;
           90  + int k = 2000;
           91  + string _ = "";
           92  +END
           93  +CASE(2)
           94  + int n = 5;
           95  + int k = 1;
           96  + string _ = "23457";
           97  +END
           98  +CASE(3)
           99  + int n = 2;
          100  + int k = 22;
          101  + string _ = "52";
          102  +END
          103  +CASE(4)
          104  + int n = 6;
          105  + int k = 464;
          106  + string _ = "257936";
          107  +END
          108  +CASE(5)
          109  + int n = 1;
          110  + int k = 1;
          111  + string _ = "0";
          112  +END
          113  +CASE(6)
          114  + int n = 50;
          115  + int k = 1000000000;
          116  + string _ = "???";
          117  +END
          118  +CASE(7)
          119  + int n = 2;
          120  + int k = 57;
          121  + string _ = "???";
          122  +END
          123  +
          124  +}
          125  +// END CUT HERE

Added SRM/464/1B.cpp version [5d045ee47ad32484]

            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 ColorfulDecoration { public:
           23  + int getMaximum(vector <int> xa, vector <int> ya, vector <int> xb, vector <int> yb)
           24  + {
           25  +  int L=0, R=1000000001;
           26  +  while( R-L>=2 )
           27  +  {
           28  +   int C = (L+R)/2;
           29  +   (canPlace(C, xa, ya, xb, yb)?L:R) = C;
           30  +  }
           31  +  return L;
           32  + }
           33  +
           34  + typedef vector< vector<int> > graph;
           35  +
           36  + bool canPlace(int C, vector <int> xa, vector <int> ya, vector <int> xb, vector <int> yb)
           37  + {
           38  +  int N = xa.size();
           39  +
           40  +  graph G(2*N);
           41  +  for(int i=0; i<N; ++i) {
           42  +   for(int j=0; j<N; ++j) if(i!=j)
           43  +    if( !ok(C, xa[i], ya[i], xa[j], ya[j]) )
           44  +     G[i].push_back(N+j);
           45  +   for(int j=0; j<N; ++j) if(i!=j)
           46  +    if( !ok(C, xa[i], ya[i], xb[j], yb[j]) )
           47  +     G[i].push_back(j);
           48  +   for(int j=0; j<N; ++j) if(i!=j)
           49  +    if( !ok(C, xb[i], yb[i], xa[j], ya[j]) )
           50  +     G[N+i].push_back(N+j);
           51  +   for(int j=0; j<N; ++j) if(i!=j)
           52  +    if( !ok(C, xb[i], yb[i], xb[j], yb[j]) )
           53  +     G[N+i].push_back(j);
           54  +  }
           55  +
           56  +  for(int i=0; i<N; ++i)
           57  +   if( reachable(G,i,N+i) && reachable(G,N+i,i) )
           58  +    return false;
           59  +  return true;
           60  + }
           61  +
           62  + bool reachable(graph& G, int s, int d)
           63  + {
           64  +  set<int> V;
           65  +  queue<int> Q;
           66  +  Q.push(s);
           67  +  V.insert(s);
           68  +  while( !Q.empty() ) {
           69  +   int v = Q.front(); Q.pop();
           70  +   for(int i=0; i<G[v].size(); ++i) {
           71  +    int u = G[v][i];
           72  +    if( u == d )
           73  +     return true;
           74  +    if( !V.count(u) )
           75  +     V.insert(u), Q.push(u);
           76  +   }
           77  +  }
           78  +  return false;
           79  + }
           80  +
           81  + bool ok(int C, int x1, int y1, int x2, int y2)
           82  + {
           83  +  return C <= max(abs(x1-x2), abs(y1-y2));
           84  + }
           85  +};
           86  +
           87  +// BEGIN CUT HERE
           88  +#include <ctime>
           89  +double start_time; string timer()
           90  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           91  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           92  + { os << "{ ";
           93  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           94  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           95  +void verify_case(const int& Expected, const int& Received) {
           96  + bool ok = (Expected == Received);
           97  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           98  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           99  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          100  +#define END  verify_case(_, ColorfulDecoration().getMaximum(xa, ya, xb, yb));}
          101  +int main(){
          102  +
          103  +CASE(0)
          104  + int xa_[] = { 10,  0,  7 };
          105  +   vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_));
          106  + int ya_[] = {  0, 19,  6 };
          107  +   vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_));
          108  + int xb_[] = { 20, 10, 25 };
          109  +   vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_));
          110  + int yb_[] = { 20, 35, 25 };
          111  +   vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_));
          112  + int _ = 19;
          113  +END
          114  +CASE(1)
          115  + int xa_[] = { 464, 20 };
          116  +   vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_));
          117  + int ya_[] = { 464, 10 };
          118  +   vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_));
          119  + int xb_[] = { 464,  3 };
          120  +   vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_));
          121  + int yb_[] = { 464, 16 };
          122  +   vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_));
          123  + int _ = 461;
          124  +END
          125  +CASE(2)
          126  + int xa_[] = { 0, 0, 1, 1 };
          127  +   vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_));
          128  + int ya_[] = { 0, 0, 1, 1 };
          129  +   vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_));
          130  + int xb_[] = { 1, 1, 0, 0 };
          131  +   vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_));
          132  + int yb_[] = { 1, 1, 0, 0 };
          133  +   vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_));
          134  + int _ = 0;
          135  +END
          136  +CASE(3)
          137  + int xa_[] = { 0, 3, 0, 5, 6 };
          138  +   vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_));
          139  + int ya_[] = { 1, 6, 0, 8, 5 };
          140  +   vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_));
          141  + int xb_[] = { 6, 1, 7, 4, 7 };
          142  +   vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_));
          143  + int yb_[] = { 5, 9, 2, 8, 9 };
          144  +   vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_));
          145  + int _ = 3;
          146  +END
          147  +CASE(4)
          148  + int xa_[] = { 1000000000, 0 };
          149  +   vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_));
          150  + int ya_[] = { 0, 1000000000 };
          151  +   vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_));
          152  + int xb_[] = { 0, 1000000000 };
          153  +   vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_));
          154  + int yb_[] = { 0, 1000000000 };
          155  +   vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_));
          156  + int _ = 1000000000;
          157  +END
          158  +CASE(5)
          159  + int xa_[] = {0,0};
          160  +   vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_));
          161  + int ya_[] = {0,0};
          162  +   vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_));
          163  + int xb_[] = {0,0};
          164  +   vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_));
          165  + int yb_[] = {0,0};
          166  +   vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_));
          167  + int _ = 0;
          168  +END
          169  +CASE(6)
          170  + int xa_[] = {0,0};
          171  +   vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_));
          172  + int ya_[] = {0,0};
          173  +   vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_));
          174  + int xb_[] = {1,1};
          175  +   vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_));
          176  + int yb_[] = {1,1};
          177  +   vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_));
          178  + int _ = 1;
          179  +END
          180  +CASE(7)
          181  + int xa_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
          182  +   vector <int> xa(xa_, xa_+sizeof(xa_)/sizeof(*xa_));
          183  + int ya_[] = {1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,10};
          184  +   vector <int> ya(ya_, ya_+sizeof(ya_)/sizeof(*ya_));
          185  + int xb_[] = {2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,10,11};
          186  +   vector <int> xb(xb_, xb_+sizeof(xb_)/sizeof(*xb_));
          187  + int yb_[] = {3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,10,11,12};
          188  +   vector <int> yb(yb_, yb_+sizeof(yb_)/sizeof(*yb_));
          189  + int _ = -1;
          190  +END
          191  +
          192  +}
          193  +// END CUT HERE

Added SRM/464/1C.cpp version [ea1144bd38a3e84c]

            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 ColorfulMaze { public:
           23  + double getProbability(vector <string> maze, vector <int> trap)
           24  + {
           25  +  return solve(maze, trap, 0);
           26  + }
           27  +
           28  + typedef int vert;
           29  +
           30  + double solve(const vector<string>& maze, const vector<int>& trap, int damage)
           31  + {
           32  +  const int H = maze.size();
           33  +  const int W = maze[0].size();
           34  +
           35  +  // R[i] == list of cells colored 'A'+i and reachable from '$'
           36  +  vector<vert> R[7];
           37  +  {
           38  +   stack<vert>  Q;
           39  +   vector<bool> V(H*W);
           40  +   for(int y=0; y<H; ++y)
           41  +    for(int x=0; x<W; ++x)
           42  +     if( maze[y][x] == '$' )
           43  +      {Q.push(y*W+x); V[y*W+x]=1;}
           44  +
           45  +   while( !Q.empty() ) {
           46  +    vert v=Q.top(); Q.pop();
           47  +    int y=v/W, x=v%W;
           48  +
           49  +    int dy[]={-1,+1,0,0}, dx[]={0,0,-1,+1};
           50  +    for(int i=0; i<4; ++i) {
           51  +     int yy=y+dy[i], xx=x+dx[i],u=yy*W+xx;
           52  +     if( 0<=yy && yy<H && 0<=xx && xx<W && maze[yy][xx]!='#' && !V[u] ) {
           53  +      if( maze[yy][xx]=='!' )
           54  +       return 1.0;
           55  +      V[u]=1;
           56  +      if( maze[yy][xx] == '.' )
           57  +       Q.push(u);
           58  +      else
           59  +       R[maze[yy][xx]-'A'].push_back(u);
           60  +     }
           61  +    }
           62  +   }
           63  +  }
           64  +
           65  +  double pMax = 0.0;
           66  +  for(int k=0; k<7; ++k) if(!R[k].empty()) {
           67  +   double p = 0; // prob. to survive when you first step in the color 'A'+k
           68  +
           69  +   vector<string> m = maze;
           70  +   { // the case it was not a trap
           71  +    for(int y=0; y<H; ++y)
           72  +     for(int x=0; x<W; ++x)
           73  +      if(maze[y][x]=='A'+k)    m[y][x] = '.';
           74  +      else if(maze[y][x]=='$') m[y][x] = ".#"[damage];
           75  +    for(int i=0; i<R[k].size(); ++i)
           76  +     m[R[k][i]/W][R[k][i]%W] = '$';
           77  +    p = (1-trap[k]/100.0) * solve(m, trap, damage);
           78  +   }
           79  +   if( damage == 0 ) { // the case it was a trap
           80  +    for(int y=0; y<H; ++y)
           81  +     for(int x=0; x<W; ++x)
           82  +      if(maze[y][x]=='A'+k && m[y][x]!='$') m[y][x] = '#';
           83  +    p += (trap[k]/100.0) * solve(m, trap, damage+1);
           84  +   }
           85  +
           86  +   pMax = max(pMax, p); // take the maximum
           87  +  }
           88  +  return pMax;
           89  + }
           90  +};
           91  +
           92  +// BEGIN CUT HERE
           93  +#include <ctime>
           94  +double start_time; string timer()
           95  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           96  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           97  + { os << "{ ";
           98  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           99  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          100  +void verify_case(const double& Expected, const double& Received) {
          101  + bool ok = (abs(Expected - Received) < 1e-9);
          102  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          103  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          104  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          105  +#define END  verify_case(_, ColorfulMaze().getProbability(maze, trap));}
          106  +int main(){
          107  +
          108  +CASE(0)
          109  + string maze_[] = { ".$.",
          110  +  "A#B",
          111  +  "A#B",
          112  +  ".!." };
          113  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          114  + int trap_[] = { 50, 40, 0, 0, 0, 0, 0 };
          115  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          116  + double _ = 0.8;
          117  +END
          118  +CASE(1)
          119  + string maze_[] = { ".$.",
          120  +  "A#B",
          121  +  "A#C",
          122  +  ".!." };
          123  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          124  + int trap_[] = { 20, 70, 40, 0, 0, 0, 0 };
          125  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          126  + double _ = 0.86;
          127  +END
          128  +CASE(2)
          129  + string maze_[] = { "$A#",
          130  +  ".#.",
          131  +  "#B!" };
          132  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          133  + int trap_[] = { 10, 10, 10, 10, 10, 10, 10 };
          134  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          135  + double _ = 0.0;
          136  +END
          137  +CASE(3)
          138  + string maze_[] = { "$A..",
          139  +  "##.A",
          140  +  "..B!" };
          141  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          142  + int trap_[] = { 50, 50, 0, 0, 0, 0, 0 };
          143  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          144  + double _ = 0.75;
          145  +END
          146  +CASE(4)
          147  + string maze_[] = { "$C..",
          148  +  "##.A",
          149  +  "..B!" };
          150  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          151  + int trap_[] = { 50, 50, 100, 0, 0, 0, 0 };
          152  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          153  + double _ = 0.5;
          154  +END
          155  +CASE(5)
          156  + string maze_[] = { ".$.D.E.F.G.!." };
          157  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          158  + int trap_[] = { 10, 20, 30, 40, 50, 60, 70 };
          159  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          160  + double _ = 0.23400000000000004;
          161  +END
          162  +CASE(6)
          163  + string maze_[] = { "CC...AA",
          164  +  "C##.##A",
          165  +  "!.E.E.$",
          166  +  "D##.##B",
          167  +  "DD...BB" };
          168  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          169  + int trap_[] = { 90, 90, 25, 50, 75, 0, 0 };
          170  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          171  + double _ = 0.8125;
          172  +END
          173  +/*
          174  +CASE(7)
          175  + string maze_[] = {"#BGGCAG#B##EFEBFCBGFD#E##FA##BBF#BCADAFGG#CD#AGFAD", "#CGEGBFF#GECDCFF#FBDDAAG#DCCBBB#CC#BGCBDD##AEDAAG#", "E##E#GEBC#CC#GGAEDECBBA#BE#ECE#FAGEBFGD#BCADGF##D#", "DB##BDCABBBADAFGEDEEFBEFFEGEAGFBEFGDA#CE#AFA#DF#DD", "GEGG##AA#GAE##DDEFGFA#CEAEG#BBFGBBADBGCEDBABCBGFEF", "DCGECEDEC#E##BBBEGGFDDF#C##DC#EFCF#EE#FCAGBGAAGFEF", "GCAFCFEGDFCCC##CGFF#A#BAFEAD#D#FC#D##DAADAF#B#DEEE", "C#G###BD#FBG#E#D###GCGG#GGFBD#EEGBE#BCE#FF##AEDEE#", "CDA##AGBDFDE#FD#ACCC#GDBABF#CC#B#AEBFCFG#GFACBA#AB", "AA#CDFCACAFEEEA#ABAFDFEGAE#FADBFAECBBAF##BGGDBEFDF", "FABGDDEBDDCADAC#ECAG##CFDEA#FFA#DAA#CABCGBFCFA###A", "!FCFG#FACC#GABA#CGBFCBC#BGGDCAFDDCFDGADEGDGAB#F#AG", "CDEAE#E#DEDDDGFEFEE#DDDBCDDFF####FAG#FB#G#GB###EFC", "#AF##B#BGD#E#GGEEEC##FBEGBG#DGDCBBFBEGAF##ADGGA#GG", "GBBEDAFDFFCG#GADACCC###EDFCE#GBFD#BBAEAFC#BEDGAFBA", "G#FFEF#EFEEGDADAC#BA#DCB#EG#GADE##ABAEFCGDD##BB##B", "BF#C##BBCCCAEDCD##FA#ACA#FCFA#EDGAGEFECCBBGFCGDEEB", "DE#FEDFFDDCBA#AD#GDAE#BGAEGEBF#GEDGCF#DACA#DDBCGA#", "GAEBFCEF##E#EFC#BFC#GCGEFAD#GDB#DG#FBDD#FAG##ABEED", "GFGDFDDEFAGEBCBB#DCA##FEEA#GABGBBD#FEBDECF##A#BD#F", "##BGADFCA##B##EBEBADADCCFBDEFAF#C#GGAADE#D##ACGF#C", "ECF##DCCDEGCG#C#CG#EGE#B##ADD#ADA#BGCADECECBD#DD#B", "GDFEAEBG##GAGBBFBECGCBEACB##GDDFGGAEFEBCCEACDAE#A#", "B#G#D#BABEDGBC#BCBFC#DGEBE#B#BCDB#CBBDBAAAF###FD#F", "EFDCFAGG#GB##BEDGFF#BBCF#BEDCABCEFCGED#EFABBBCGBCB", "#GEB#ACECDCCFGFGDGABACCG#FGAAGGD#ED##FEFBDEF#C#FDE", "#BGEFEG#CDGBFBFDEC#DGFFB#B#GBFGBEGF###CDBDEA##BE#F", "CCGBCGF#E#BBEFF###GED#DEEE##E#B#EEG#FA#GBCEGBGGCEF", "A##DA#A#BADG#DDF#EC#BABDE#CAD#DFB#GFBAEBCGACGCA#B#", "DB###BAD#FDCGCD#EBGGEEGF#DAFGDEC#FCCAEFDBCDFA###BB", "#DCEEEEABG#GFADBDFDBABEGDAEFEC#D#F#ADECBEG#CFEDD##", "#CD#DD##D#BA#AB#CBB#DDEDGBDDDDECB#DGB#GCEG#AAEFBFA", "FB#E#GDCBFF#DGDDDG#DFCCAD##CBFGGFDDGDDFCBGADAEACFE", "B#FF#BE##GCEA#CDDGECCAB#BEDFGCF#CEEFC#EDD#DEBGA###", "FE#FGBA#DAFC#D#EC#FECBED#B#GB####AB#DCGECE#BEG#AGF", "##BDCF#DBEC#FCFBGEDDAAECFGDG#EF###ACEABGEEGAG##BA#", "FF#EAGG##A#DB#BBE#BFDDCDBD#GGFAEEDBBEG#DDG##DFGGCA", "###E#BFGDBEA##EBCB#GG#CEBFGDBAGDF#CC#ABCFGAAEFABGC", "AGCGFBFBFGCE#ECCABCCBD#D##BBGACGCBFAD#DBDE#CE#EAD#", "AGGBGCEA##A#EFEF#FGAAFCB#EF#DGCFF#CBAAE#GFB#A#EFDD", "BEEDCDDGFFB#FB##FEFBFACBACA#EGDAEDGG#D###DECFEEAD#", "FDDBDDG#GGACG#F$#D#FEECF##FDCGAF#CGDEGC#GD##ABFEF#", "GBDDAB#BDDFGDBDDC#BABBGEGDAAG#FEDCAGGA#FDEC#ADGAED", "D#B#GBABD##AE#DD##A#CG#DF#AC#ABDDEBGEBA#A#FCDCAGDF", "DDD#FEFBCBFADADEBEF#FBEF#BAGFBD#GE#CFGG#CABGDGB#CF", "DGEGDDAE#F##C#DDF#DGEABCG#CFCF#FABFG#GEB#DG#EDECDE", "CCFEEB#A###AEB##GFB#FA#EDD#E#FAD#DB#ECFD#A#EFAG###", "CBEDEEG#FC##D##FBEEFEEA##ECADB#BFC#BDDDGDDGGEAEFEE", "#DB#GG#CA#AFBFGCCDGDD#BG#A#C#DA#B#CAGEADF#BEAD#E#A", "FC#GBFDEFAFCG#C#F#ECDB##ABA##AEEACAAEEAD#AAD#CFFA#"};
          176  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          177  + int trap_[] = {32, 65, 91, 81, 62, 45, 52};
          178  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          179  + double _ = 0.009185498471999998;
          180  +END
          181  +*/
          182  +CASE(8)
          183  + string maze_[] = {"#A####.F...##B..#.B.A#....#.#......#B###.#.#.####.", "###F....DD###.#F..#.#...#.#.##..#F....##..#...G.#.", "#F.D##..DDD....##.D..D#DF..##...#F......#.F#E##.#.", ".#.#.E.#..#...#.##F#.#.#.###F##F##..#####.#F..#.#.", "##.#F#B..B..D###D#...#.D.##F#F####CA.#...###A##...", "C.#B#.#..##..B####.#..##.#.#.#####.#...GD#.DC##..#", "##C###CC.#C.##...##..#..##.##.E..##.#####....##...", ".###EE...##.#E##..##D#D.#D#F###..#..C###.#..C.C...", "A####.#..A...A#.#.###.#.A#A####..####.#BD...D.#.#.", ".#..E..CC.#.C#.#.#.C...C....G#..GA..##.####.#...#.", "####.A.#..AA#..###.#B#G.EE##...#..#G#CC#..#.....#.", "C....#...#.F#.C#C###.#.....F#.#..#..#F#...#####..#", "F...#C##.#D###.#C#..C...#C...CD.D...D#.#D#.F....#A", ".##AA#G##..#GB##DD#.....##.DD##..#..AA###.A..####.", ".##.A...#.A#...#..#GE###.C##.#.#.#.F.###......####", "###F.F##..#####.......##FF#F#E#E.#E.#...##B##B####", "##..#B#BA###.A..#..#A.####.GDD..####DE##.#.E.#####", "#D###.#.#.##D..##FB#.E##ED.##..D##.####.#....#D#.#", "D#..##.#####.BA.###A#B.#.#.....##..#.####.#.#.#B..", "BBB#..####..D#..#.##.#..#..#...##...#..##.#D.##.A.", "..B.BD#E#.#.E.......E##....E..#..#CC.C#.###.#.#...", "####CC....#E#.E###..##E..#EE.####.#....#.DDCC..##.", "#....#.##E.#####..####..E#F##.#..F.##A#..#..###.##", ".#..#G#G.#..#.#G.G.##.##G#G#.####.G..G#..G###..#G.", "#G###.#...D#D####.F####..#F#A##.#.G.###D##..###A#A", ".##AB####.F..#C.CF.#.F##..#.AAAA.BBB.B.##B#..##...", ".#.#F#...C#G#.F#.G##G#.##.##..####.GG.#.GBB#.###.B", "...F##.#.#.#.FA.#A##..#..B#A###..#.##..#..#.#AA.#.", "##.......AEEE#.#E..#...###B#.....#.....##.#..B#.BF", "...F..#..$C###...G..###.G##..#..G#....G.#.##EE#B#.", "FFFF.G.F.#.F#..#.#..##C#.#..A##.#A.##..#A#..A##.A.", "B#.B.#F##.A...#A#DG...G.#..E##B##...#.#.A#CC##C..#", "##D..#F.G####..G##G..##.#######GG#..#.GG#.#A#A##.#", "#B..#.#.#..##.#G#..#EEE.E.###.###EG#.##..G###E#E..", "###.#.ED#..DF###.#.#..##.####...##AE###BB##..#.B#F", ".#F#.#..#..#####CC...##.C#CBB.#...##B#..D#AA#A..#.", "...BBFB.#B..B#B####BG..#.G.#.##.###.G###...#GA..#A", ".#C.CA##E##EF#DF#E.E.###E.#G..CC.#..##..#A.#.E##EE", "..#F#.#.#....#F##F#F#..##.###F..#..#.G#####GG#.##G", ".#...DE#..#.#.#####.#.###D.#D.D.#....D#B#B#..DA..A", "#..##.#.###A.F##...#.....F#F#....F##F#.###E###ED#C", "C...C#F.#A##.#..#..#....#F#B#..F##F.D..###.A###A.A", ".###..#D..#..##C.#....##..##......###E.#..##EE.F##", "..F.#D.#...##D#..D#..#.F#.C..##..#..#....C..#B.#..", "#...##...B.###..#BF#C..##...###.##.##.GBB..#....#F", "F.#.##.##.#..C..#..E.CC#...C#G...#.G..G.A..F#F.#..", "##..F#.#....F.###D##.#G.##.###..##GG####.....##GG.", "##..#....#GG#G.G.F..F#..#....#.##..##.#CC.#.BA.#.#", "#.#..##D#.##.#.##.#.#A#.C..####.....#..#.###C.#C.#", ".#C!##...C###.E...#.#..###...E#####E#.###F#F.###.."};
          184  +   vector <string> maze(maze_, maze_+sizeof(maze_)/sizeof(*maze_));
          185  + int trap_[] = {14, 22, 100, 34, 15, 33, 42};
          186  +   vector <int> trap(trap_, trap_+sizeof(trap_)/sizeof(*trap_));
          187  + double _ = 0.34491599999999994;
          188  +END
          189  +}
          190  +// END CUT HERE

Added SRM/465-U/1A.cpp version [34029dc0172b7ef9]

            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 TurretPlacement { public:
           23  + long long count(vector <int> x, vector <int> y)
           24  + {
           25  +  LL cnt = 0;
           26  +  for(int i=0; i<x.size(); ++i)
           27  +   for(int j=i+1; j<x.size(); ++j)
           28  +    cnt += howMany(x[i], y[i], x[j], y[j]);
           29  +  return cnt;
           30  + }
           31  + LL howMany(int x, int y, int X, int Y)
           32  + {
           33  +  LL n = int(2*sqrt((X-x)*(X-x) + (Y-y)*(Y-y)));
           34  +  return (n-1)*n/2;
           35  + }
           36  +};
           37  +
           38  +// BEGIN CUT HERE
           39  +#include <ctime>
           40  +double start_time; string timer()
           41  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           42  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           43  + { os << "{ ";
           44  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           45  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           46  +void verify_case(const long long& Expected, const long long& Received) {
           47  + bool ok = (Expected == Received);
           48  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           49  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           50  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           51  +#define END  verify_case(_, TurretPlacement().count(x, y));}
           52  +int main(){
           53  +
           54  +CASE(0)
           55  + int x_[] = {0,2};
           56  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           57  + int y_[] = {0,2};
           58  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           59  + long long _ = 10LL;
           60  +END
           61  +CASE(1)
           62  + int x_[] = {0,1,2};
           63  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           64  + int y_[] = {0,1,0};
           65  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           66  + long long _ = 8LL;
           67  +END
           68  +CASE(2)
           69  + int x_[] = {1,2,3,0};
           70  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           71  + int y_[] = {-1,-5,-7,100};
           72  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           73  + long long _ = 65137LL;
           74  +END
           75  +CASE(3)
           76  + int x_[] = {9998,-10000,10000,0};
           77  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           78  + int y_[] = {9998,10000,10000,0};
           79  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           80  + long long _ = 2799564895LL;
           81  +END
           82  +CASE(4)
           83  + int x_[] = {0,0};
           84  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           85  + int y_[] = {1,0};
           86  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           87  + long long _ = 0LL;
           88  +END
           89  +CASE(5)
           90  + int x_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
           91  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           92  + int y_[] = {10000,-10000,9000,-9000,8000,-8000,-7000,-7000,6000,-6000,5000,-5000,4000,-4000,3000,-3000,2000,-2000,1000,-1000,
           93  +     9800,- 9800,9500,-9500,8500,-8500,-7500,-7500,6500,-6500,5500,-5500,4500,-4500,3500,-3500,2500,-2500,1500,-1500};
           94  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           95  + long long _ = -1LL;
           96  +END
           97  +
           98  +}
           99  +// END CUT HERE

Added SRM/465-U/1B.cpp version [93c53f4c26bd697e]

            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 NV = 512;
           23  +typedef int           flow;
           24  +typedef int           vert;
           25  +typedef vert          edge;
           26  +typedef vector<edge>  edges;
           27  +typedef vector<edges> graph;
           28  +typedef flow          flow_graph[NV][NV];
           29  +static const flow INF = 0x3fffffff;
           30  +
           31  +flow dinic_dfs( graph& G, flow_graph F, vert v, vert D,
           32  +                int LV[], flow flow_in, int blocked[] )
           33  +{
           34  + flow flow_out = 0;
           35  + for(int i=0; i!=G[v].size(); ++i) {
           36  +  int u = G[v][i];
           37  +  if( LV[v]+1==LV[u] && F[v][u] ) {
           38  +   flow f = min(flow_in-flow_out, F[v][u]);
           39  +   if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) ) {
           40  +    F[v][u]  -= f;
           41  +    F[u][v]  += f;
           42  +    flow_out += f;
           43  +    if( flow_in == flow_out ) return flow_out;
           44  +   }
           45  +  }
           46  + }
           47  + blocked[v] = (flow_out==0);
           48  + return flow_out;
           49  +}
           50  +
           51  +flow maxFlow( graph& G, flow_graph F, vert S, vert D )
           52  +{
           53  + for( flow total=0 ;; ) {
           54  +  int LV[NV] = {0};
           55  +  vector<int> Q(1, S);
           56  +  for(int lv=1; !Q.empty(); ++lv) {
           57  +   vector<int> Q2;
           58  +   for(int i=0; i!=Q.size(); ++i) {
           59  +    edges& ne = G[Q[i]];
           60  +    for(int j=0; j!=ne.size(); ++j)
           61  +     if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
           62  +      LV[ne[j]]=lv, Q2.push_back(ne[j]);
           63  +   }
           64  +   Q.swap(Q2);
           65  +  }
           66  +
           67  +  if( !LV[D] )
           68  +   return total;
           69  +
           70  +  int blocked[NV] = {};
           71  +  total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
           72  + }
           73  +}
           74  +
           75  +class GreenWarfare { public:
           76  + int minimumEnergyCost(vector <int> canonX, vector <int> canonY, vector <int> baseX, vector <int> baseY, vector <int> plantX, vector <int> plantY, int energySupplyRadius)
           77  + {
           78  +  int B = baseX.size();
           79  +  int P = plantX.size();
           80  +
           81  +  graph      G(P+P+B+B+2);
           82  +  flow_graph F = {};
           83  +
           84  +  for(int x=0; x<P; ++x) {
           85  +   G[P+P+B+B].push_back(x);
           86  +   G[x].push_back(P+P+B+B);
           87  +   F[P+P+B+B][x] = INF;
           88  +  }
           89  +  for(int x=0; x<P; ++x) {
           90  +   G[x].push_back(P+x);
           91  +   G[P+x].push_back(x);
           92  +   F[x][P+x] = breakEnergy(canonX, canonY, plantX[x], plantY[x]);
           93  +  }
           94  +  for(int x=0; x<P; ++x)
           95  +   for(int y=0; y<B; ++y)
           96  +    if( dist(plantX[x],plantY[x],baseX[y],baseY[y]) <= energySupplyRadius*energySupplyRadius ) {
           97  +     G[P+x].push_back(P+P+y);
           98  +     G[P+P+y].push_back(P+x);
           99  +     F[P+x][P+P+y] = INF;
          100  +    }
          101  +  for(int x=0; x<B; ++x) {
          102  +   G[P+P+x].push_back(P+P+B+x);
          103  +   G[P+P+B+x].push_back(P+P+x);
          104  +   F[P+P+x][P+P+B+x] = breakEnergy(canonX, canonY, baseX[x], baseY[x]);
          105  +  }
          106  +  for(int x=0; x<B; ++x) {
          107  +   G[P+P+B+x].push_back(P+P+B+B+1);
          108  +   G[P+P+B+B+1].push_back(P+P+B+x);
          109  +   F[P+P+B+x][P+P+B+B+1] = INF;
          110  +  }
          111  +
          112  +  return maxFlow(G, F, P+P+B+B, P+P+B+B+1);
          113  + }
          114  +
          115  + int dist(int x, int y, int X, int Y)
          116  + {
          117  +  return (X-x)*(X-x) + (Y-y)*(Y-y);
          118  + }
          119  +
          120  + int breakEnergy(const vector<int>& cx, const vector<int>& cy, int x, int y)
          121  + {
          122  +  int e = 0x7fffffff;
          123  +  for(int i=0; i<cx.size(); ++i)
          124  +   e = min(e, dist(x,y,cx[i],cy[i]));
          125  +  return e;
          126  + }
          127  +};
          128  +
          129  +// BEGIN CUT HERE
          130  +#include <ctime>
          131  +double start_time; string timer()
          132  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          133  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          134  + { os << "{ ";
          135  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          136  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          137  +void verify_case(const int& Expected, const int& Received) {
          138  + bool ok = (Expected == Received);
          139  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          140  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          141  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          142  +#define END  verify_case(_, GreenWarfare().minimumEnergyCost(canonX, canonY, baseX, baseY, plantX, plantY, energySupplyRadius));}
          143  +int main(){
          144  +
          145  +CASE(0)
          146  + int canonX_[] = { 0 };
          147  +   vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_));
          148  + int canonY_[] = { 0 };
          149  +   vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_));
          150  + int baseX_[] = {1,2,3};
          151  +   vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_));
          152  + int baseY_[] = {0,0,0};
          153  +   vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_));
          154  + int plantX_[] = {3};
          155  +   vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_));
          156  + int plantY_[] = {3};
          157  +   vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_));
          158  + int energySupplyRadius = 4;
          159  + int _ = 14;
          160  +END
          161  +CASE(1)
          162  + int canonX_[] = { 0 };
          163  +   vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_));
          164  + int canonY_[] = { 0 };
          165  +   vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_));
          166  + int baseX_[] = {1,2,3};
          167  +   vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_));
          168  + int baseY_[] = {0,0,0};
          169  +   vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_));
          170  + int plantX_[] = {2};
          171  +   vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_));
          172  + int plantY_[] = {2};
          173  +   vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_));
          174  + int energySupplyRadius = 4;
          175  + int _ = 8;
          176  +END
          177  +CASE(2)
          178  + int canonX_[] = {3,6};
          179  +   vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_));
          180  + int canonY_[] = {3,6};
          181  +   vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_));
          182  + int baseX_[] = {1,2,3,4,5};
          183  +   vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_));
          184  + int baseY_[] = {5,4,2,3,1};
          185  +   vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_));
          186  + int plantX_[] = {1,2,5};
          187  +   vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_));
          188  + int plantY_[] = {1,2,5};
          189  +   vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_));
          190  + int energySupplyRadius = 5;
          191  + int _ = 12;
          192  +END
          193  +CASE(3)
          194  + int canonX_[] = {0};
          195  +   vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_));
          196  + int canonY_[] = {0};
          197  +   vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_));
          198  + int baseX_[] = {-10,-10,10};
          199  +   vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_));
          200  + int baseY_[] = {10,-10,0};
          201  +   vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_));
          202  + int plantX_[] = {10,10,-10};
          203  +   vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_));
          204  + int plantY_[] = {10,-10,0};
          205  +   vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_));
          206  + int energySupplyRadius = 10;
          207  + int _ = 200;
          208  +END
          209  +CASE(4)
          210  + int canonX_[] = {0};
          211  +   vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_));
          212  + int canonY_[] = {0};
          213  +   vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_));
          214  + int baseX_[] = {3};
          215  +   vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_));
          216  + int baseY_[] = {3};
          217  +   vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_));
          218  + int plantX_[] = {1,2,3};
          219  +   vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_));
          220  + int plantY_[] = {0,0,0};
          221  +   vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_));
          222  + int energySupplyRadius = 4;
          223  + int _ = 14;
          224  +END
          225  +/*
          226  +CASE(5)
          227  + int canonX_[] = ;
          228  +   vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_));
          229  + int canonY_[] = ;
          230  +   vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_));
          231  + int baseX_[] = ;
          232  +   vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_));
          233  + int baseY_[] = ;
          234  +   vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_));
          235  + int plantX_[] = ;
          236  +   vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_));
          237  + int plantY_[] = ;
          238  +   vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_));
          239  + int energySupplyRadius = ;
          240  + int _ = ;
          241  +END
          242  +CASE(6)
          243  + int canonX_[] = ;
          244  +   vector <int> canonX(canonX_, canonX_+sizeof(canonX_)/sizeof(*canonX_));
          245  + int canonY_[] = ;
          246  +   vector <int> canonY(canonY_, canonY_+sizeof(canonY_)/sizeof(*canonY_));
          247  + int baseX_[] = ;
          248  +   vector <int> baseX(baseX_, baseX_+sizeof(baseX_)/sizeof(*baseX_));
          249  + int baseY_[] = ;
          250  +   vector <int> baseY(baseY_, baseY_+sizeof(baseY_)/sizeof(*baseY_));
          251  + int plantX_[] = ;
          252  +   vector <int> plantX(plantX_, plantX_+sizeof(plantX_)/sizeof(*plantX_));
          253  + int plantY_[] = ;
          254  +   vector <int> plantY(plantY_, plantY_+sizeof(plantY_)/sizeof(*plantY_));
          255  + int energySupplyRadius = ;
          256  + int _ = ;
          257  +END
          258  +*/
          259  +}
          260  +// END CUT HERE

Added SRM/465-U/1C-U.cpp version [4ab9d94a2abea13a]

            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 BouncingDiceGame { public:
           23  + double winProbability(int n, int d, int x, int y)
           24  + {
           25  +  int B = n-d;
           26  +  x = min(B,x);
           27  +  y = min(B,y);
           28  +  int Z = min(x,y);
           29  +  vector< vector<double> > p(B+1, vector<double>(B+1, 0));
           30  +
           31  +  // solve:
           32  +  //   p[B][k] = 1 - p[k][B]
           33  +  //   p[i][k] = 1/d \Sigma_{b=1..d} (1 - p[k][min(B,i+b)])
           34  +  // return p[x][y];
           35  +
           36  +  for(int ik=B*2; ik>=Z*2; --ik)
           37  +  for(int i=Z; i<=B; ++i)
           38  +  {
           39  +   int k = ik-i;
           40  +   if( Z<=k && k<=B ) {
           41  +    if(i==B && k==B) p[B][B] = d / (2*d-1);
           42  +    else if( i==B ) p[B][k] = 1 - p[k][B]*(d-1)/d;
           43  +    else {
           44  +     double q = 0;
           45  +     for(int b=1; b<=d; ++b)
           46  +      q += 1 - p[k][min(B,i+b)];
           47  +     p[i][k] = q/d;
           48  +    }
           49  +   }
           50  +  }
           51  +  return p[x][y];
           52  + }
           53  +};
           54  +
           55  +// BEGIN CUT HERE
           56  +#include <ctime>
           57  +double start_time; string timer()
           58  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           59  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           60  + { os << "{ ";
           61  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           62  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           63  +void verify_case(const double& Expected, const double& Received) {
           64  + bool ok = (abs(Expected - Received) < 1e-9);
           65  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           66  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           67  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           68  +#define END  verify_case(_, BouncingDiceGame().winProbability(n, d, x, y));}
           69  +int main(){
           70  +
           71  +CASE(0)
           72  + int n = 10;
           73  + int d = 6;
           74  + int x = 1;
           75  + int y = 1;
           76  + double _ = 0.5417251215862328;
           77  +END
           78  +CASE(1)
           79  + int n = 10;
           80  + int d = 2;
           81  + int x = 1;
           82  + int y = 1;
           83  + double _ = 0.6090494791666666;
           84  +END
           85  +CASE(2)
           86  + int n = 100;
           87  + int d = 20;
           88  + int x = 1;
           89  + int y = 10;
           90  + double _ = 0.49158887163174947;
           91  +END
           92  +CASE(3)
           93  + int n = 10;
           94  + int d = 5;
           95  + int x = 9;
           96  + int y = 1;
           97  + double _ = 0.6943018666666667;
           98  +END
           99  +/*
          100  +CASE(4)
          101  + int n = ;
          102  + int d = ;
          103  + int x = ;
          104  + int y = ;
          105  + double _ = ;
          106  +END
          107  +CASE(5)
          108  + int n = ;
          109  + int d = ;
          110  + int x = ;
          111  + int y = ;
          112  + double _ = ;
          113  +END
          114  +*/
          115  +}
          116  +// END CUT HERE

Added SRM/466-U/1A.cpp version [b77551cfbb4fa077]

            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 LotteryCheating { public:
           23  + int minimalChange(string ID)
           24  + {
           25  +  int minMod = ID.size();
           26  +
           27  +  for(LL x=0;; ++x)
           28  +  {
           29  +   string s;
           30  +   {stringstream ss; ss << x*x; ss >> s;}
           31  +
           32  +   if( s.size() > ID.size() )
           33  +    break;
           34  +   s = string(ID.size()-s.size(),'0')+s;
           35  +   int c = 0;
           36  +   for(int i=0; i<ID.size(); ++i)
           37  +    if( s[i] != ID[i] )
           38  +     ++c;
           39  +   minMod = min(minMod, c);
           40  +  }
           41  +
           42  +  return minMod;
           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 int& Expected, const int& 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(_, LotteryCheating().minimalChange(ID));}
           60  +int main(){
           61  +
           62  +CASE(0)
           63  + string ID = "1";
           64  + int _ = 0;
           65  +END
           66  +CASE(1)
           67  + string ID = "1234";
           68  + int _ = 2;
           69  +END
           70  +CASE(2)
           71  + string ID = "9000000000";
           72  + int _ = 1;
           73  +END
           74  +CASE(3)
           75  + string ID = "4294967296";
           76  + int _ = 0;
           77  +END
           78  +CASE(4)
           79  + string ID = "7654321";
           80  + int _ = 3;
           81  +END
           82  +CASE(5)
           83  + string ID = "2";
           84  + int _ = 1;
           85  +END
           86  +CASE(6)
           87  + string ID = "4";
           88  + int _ = 0;
           89  +END
           90  +CASE(7)
           91  + string ID = "8";
           92  + int _ = 1;
           93  +END
           94  +CASE(8)
           95  + string ID = "1111111111";
           96  + int _ = -1;
           97  +END
           98  +CASE(9)
           99  + string ID = "00201";
          100  + int _ = 1;
          101  +END
          102  +
          103  +}
          104  +// END CUT HERE

Added SRM/466-U/1B.cpp version [7c6bd3238ef8c0b3]

            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 LotteryPyaterochka { public:
           23  + double chanceToWin(int N_)
           24  + {
           25  +  LL N = N_;
           26  +  LL n5 = N;
           27  +  LL n4 = N*5*(N-1)*5;
           28  +  LL n32 = N*10*(N-1)*10;
           29  +  LL n311 = N*10*((N-1)*(N-2)/2)*5*5;
           30  +  LL all = (5*N)*(5*N-1)*(5*N-2)*(5*N-3)*(5*N-4)/120;
           31  +  return double(n5+n4+n32+n311) / all;
           32  + }
           33  +};
           34  +
           35  +// BEGIN CUT HERE
           36  +#include <ctime>
           37  +double start_time; string timer()
           38  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           39  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           40  + { os << "{ ";
           41  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           42  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           43  +void verify_case(const double& Expected, const double& Received) {
           44  + bool ok = (abs(Expected - Received) < 1e-9);
           45  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           46  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           47  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           48  +#define END  verify_case(_, LotteryPyaterochka().chanceToWin(N));}
           49  +int main(){
           50  +
           51  +CASE(0)
           52  + int N = 1;
           53  + double _ = 1.0;
           54  +END
           55  +CASE(1)
           56  + int N = 2;
           57  + double _ = 1.0;
           58  +END
           59  +CASE(2)
           60  + int N = 3;
           61  + double _ = 0.5004995004995004;
           62  +END
           63  +CASE(3)
           64  + int N = 6;
           65  + double _ = 0.13161551092585574;
           66  +END
           67  +CASE(4)
           68  + int N = 99;
           69  + double _ = -1;
           70  +END
           71  +CASE(5)
           72  + int N = 100;
           73  + double _ = -1;
           74  +END
           75  +
           76  +}
           77  +// END CUT HERE

Added SRM/466-U/1C-U.cpp version [c596015123288fc0]

            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 LL MODVAL = 1000000007;
           23  +
           24  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           25  +LL FACT(LL x) {return x<=1 ? 1 : MUL(x, FACT(x-1));}
           26  +
           27  +class DrawingBlackCrosses { public:
           28  + map<int, LL> memo;
           29  + LL rec(int must, int mustNot, int i, vector<int>& mask, int full)
           30  + {
           31  +  int key = mustNot*20+i;
           32  +  if( memo.count(key) )
           33  +   return memo[key];
           34  +
           35  +  if( i == mask.size() ) {
           36  +   if( must==0 ) {
           37  +    int b = 0;
           38  +    for(int i=0; (1<<i)<=mustNot; ++i)
           39  +     if( mustNot & (1<<i) )
           40  +      ++b;
           41  +    return FACT(b);
           42  +   }
           43  +   else
           44  +    return 0;
           45  +  }
           46  +
           47  +  LL cnt = 0;
           48  +
           49  +  // select this row
           50  +  int seled   = mustNot | mask[i];
           51  +  int notDone = full &~ seled;
           52  +  for(int k=0; (1<<k)<=notDone; ++k)
           53  +   if( (1<<k) & notDone ) {
           54  +    LL c = rec(must&~(1<<k), mustNot|(1<<k), i+1, mask, full);
           55  +    cnt = (cnt + c) % MODVAL;
           56  +   }
           57  +
           58  +  // don't select
           59  +  LL c = rec(must|notDone, mustNot, i+1, mask, full);
           60  +  cnt = (cnt + c) % MODVAL;
           61  +  return memo[key] = cnt;
           62  + }
           63  + int count(vector <string> field)
           64  + {
           65  +  vector<int> mask;
           66  +  for(int i=0; i<field.size(); ++i) {
           67  +   int m = 0;
           68  +   for(int j=0; j<field[i].size(); ++j)
           69  +    m |= (field[i][j]=='B')<<j;
           70  +   mask.push_back(m);
           71  +  }
           72  +  int full = (1<<field[0].size()) - 1;
           73  +  return rec(0, 0, 0, mask, full);
           74  + }
           75  +};
           76  +
           77  +// BEGIN CUT HERE
           78  +#include <ctime>
           79  +double start_time; string timer()
           80  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           81  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           82  + { os << "{ ";
           83  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           84  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           85  +void verify_case(const int& Expected, const int& Received) {
           86  + bool ok = (Expected == Received);
           87  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           88  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           89  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           90  +#define END  verify_case(_, DrawingBlackCrosses().count(field));}
           91  +int main(){
           92  +
           93  +CASE(0)
           94  + string field_[] = {"."};
           95  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
           96  + int _ = 1;
           97  +END
           98  +CASE(1)
           99  + string field_[] = {"BBB",
          100  + "BBB"};
          101  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
          102  + int _ = 1;
          103  +END
          104  +CASE(2)
          105  + string field_[] = {"...",
          106  + "BB."};
          107  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
          108  + int _ = 5;
          109  +END
          110  +CASE(3)
          111  + string field_[] = {"....................",
          112  + "....................",
          113  + "....................",
          114  + "....................",
          115  + "....................",
          116  + "....................",
          117  + "....................",
          118  + "....................",
          119  + "....................",
          120  + "....................",
          121  + "....................",
          122  + "....................",
          123  + "....................",
          124  + "....................",
          125  + "....................",
          126  + "....................",
          127  + "....................",
          128  + "....................",
          129  + "....................",
          130  + "...................."};
          131  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
          132  + int _ = 563200757;
          133  +END
          134  +CASE(4)
          135  + string field_[] = {"B..B",
          136  + "B.B.",
          137  + "...B",
          138  + "BB.B",
          139  + "...."};
          140  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
          141  + int _ = 324;
          142  +END
          143  +/*
          144  +CASE(5)
          145  + string field_[] = ;
          146  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
          147  + int _ = ;
          148  +END
          149  +CASE(6)
          150  + string field_[] = ;
          151  +   vector <string> field(field_, field_+sizeof(field_)/sizeof(*field_));
          152  + int _ = ;
          153  +END
          154  +*/
          155  +}
          156  +// END CUT HERE

Added SRM/467-U/1A.cpp version [0013ea53e2a54780]

            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 LateProfessor { public:
           23  + double getProbability(int waitTime, int walkTime, int lateTime, int bestArrival, int worstArrival)
           24  + {
           25  +  if( worstArrival - bestArrival == 0 )
           26  +  {
           27  +   int t = bestArrival % (waitTime+walkTime);
           28  +   if( t<=waitTime )
           29  +    return 0;
           30  +   if( t+lateTime <= waitTime+walkTime )
           31  +    return 1;
           32  +   return 0;
           33  +  }
           34  +
           35  +  if( walkTime <= lateTime )
           36  +   return 0;
           37  +
           38  +  int bad = 0;
           39  +  for(int t=0; t<=worstArrival; t+=waitTime+walkTime)
           40  +  {
           41  +   int tb = max(bestArrival, t+waitTime);
           42  +   int te = min(worstArrival, t+waitTime+walkTime-lateTime);
           43  +   if( tb < te )
           44  +    bad += te - tb;
           45  +  }
           46  +  return double(bad) / (worstArrival - bestArrival);
           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) << " msec)"; return os.str(); }
           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 os; }
           58  +void verify_case(const double& Expected, const double& Received) {
           59  + bool ok = (abs(Expected - Received) < 1e-9);
           60  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           61  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           62  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           63  +#define END  verify_case(_, LateProfessor().getProbability(waitTime, walkTime, lateTime, bestArrival, worstArrival));}
           64  +int main(){
           65  +
           66  +CASE(0)
           67  + int waitTime = 20;
           68  + int walkTime = 30;
           69  + int lateTime = 10;
           70  + int bestArrival = 0;
           71  + int worstArrival = 50;
           72  + double _ = 0.4;
           73  +END
           74  +CASE(1)
           75  + int waitTime = 20;
           76  + int walkTime = 30;
           77  + int lateTime = 10;
           78  + int bestArrival = 30;
           79  + int worstArrival = 100;
           80  + double _ = 0.42857142857142855;
           81  +END
           82  +CASE(2)
           83  + int waitTime = 20;
           84  + int walkTime = 40;
           85  + int lateTime = 50;
           86  + int bestArrival = 0;
           87  + int worstArrival = 300;
           88  + double _ = 0.0;
           89  +END
           90  +CASE(3)
           91  + int waitTime = 101;
           92  + int walkTime = 230;
           93  + int lateTime = 10;
           94  + int bestArrival = 654;
           95  + int worstArrival = 17890;
           96  + double _ = 0.6637270828498492;
           97  +END
           98  +CASE(4)
           99  + int waitTime = 20;
          100  + int walkTime = 30;
          101  + int lateTime = 10;
          102  + int bestArrival = 90;
          103  + int worstArrival = 90;
          104  + double _ = 1.0;
          105  +END
          106  +CASE(5)
          107  + int waitTime = 1000;
          108  + int walkTime = 600;
          109  + int lateTime = 1;
          110  + int bestArrival = 17000;
          111  + int worstArrival = 17000;
          112  + double _ = 0.0;
          113  +END
          114  +CASE(6)
          115  + int waitTime = 1;
          116  + int walkTime = 2;
          117  + int lateTime = 1;
          118  + int bestArrival = 2;
          119  + int worstArrival = 2;
          120  + double _ = -1;
          121  +END
          122  +CASE(7)
          123  + int waitTime = 1000;
          124  + int walkTime = 1000;
          125  + int lateTime = 1000;
          126  + int bestArrival = 0;
          127  + int worstArrival = 10000000;
          128  + double _ = -1;
          129  +END
          130  +
          131  +}
          132  +// END CUT HERE

Added SRM/467-U/1B.cpp version [b74c3219548cc710]

            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 LL MODVAL = 1000000007;
           23  +
           24  +
           25  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           26  +LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
           27  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           28  +LL POW(LL x, LL e) {
           29  + LL v = 1;
           30  + for(;e;x=MUL(x,x),e>>=1)
           31  +  if(e&1)
           32  +   v = MUL(v, x);
           33  + return v;
           34  +}
           35  +LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
           36  +
           37  +LL C(LL n, LL k) {
           38  + LL v = 1;
           39  + for(LL i=1; i<=k; ++i)
           40  +  v = DIV(MUL(v, n-i+1), i);
           41  + return v;
           42  +}
           43  +
           44  +class SuperSum { public:
           45  + int calculate(int k, int n)
           46  + {
           47  +  return C(n+k, k+1);
           48  + }
           49  +};
           50  +
           51  +// BEGIN CUT HERE
           52  +#include <ctime>
           53  +double start_time; string timer()
           54  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           55  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           56  + { os << "{ ";
           57  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           58  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           59  +void verify_case(const int& Expected, const int& Received) {
           60  + bool ok = (Expected == Received);
           61  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           62  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           63  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           64  +#define END  verify_case(_, SuperSum().calculate(k, n));}
           65  +int main(){
           66  +
           67  +CASE(0)
           68  + int k = 1;
           69  + int n = 3;
           70  + int _ = 6;
           71  +END
           72  +CASE(1)
           73  + int k = 2;
           74  + int n = 3;
           75  + int _ = 10;
           76  +END
           77  +CASE(2)
           78  + int k = 4;
           79  + int n = 10;
           80  + int _ = 2002;
           81  +END
           82  +CASE(3)
           83  + int k = 10;
           84  + int n = 35;
           85  + int _ = 150595840;
           86  +END
           87  +CASE(4)
           88  + int k = 1;
           89  + int n = 1;
           90  + int _ = 1;
           91  +END
           92  +CASE(5)
           93  + int k = 50;
           94  + int n = 1000000000;
           95  + int _ = -1;
           96  +END
           97  +CASE(6)
           98  + int k = 50;
           99  + int n = 900000000;
          100  + int _ = -1;
          101  +END
          102  +
          103  +}
          104  +// END CUT HERE

Added SRM/467-U/1C-U.cpp version [02fca67c4fcabadb]

            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 NextHomogeneousStrings { public:
           23  + string getNext(int d, int n, string seed, long long k)
           24  + {
           25  +  int M = seed.size();
           26  +
           27  +  LL L=0, R=1; // [L,R)
           28  +  while( R-L > 2 ) {
           29  +   LL C = (R+L)/2;
           30  +   string t = xth(d,n,C,M);
           31  +   (t=="" || seed<t ? R : L) = C;
           32  +  }
           33  +  return seed==xth(d,n,L,M) ? xth(d,n,L+k-1,M) : xth(d,n,L+k,M);
           34  + }
           35  + string xth(int d, int n, LL x, int M)
           36  + {
           37  +  return rec( string(), x, d, n, M );
           38  + }
           39  + string rec( string hist, LL x, int d, int n, int M )
           40  + {
           41  +  if( M == 0 )
           42  +   return "";
           43  +  for(char c='a'; c<='z'; ++c)
           44  +  {
           45  +   string hh = hist + c;
           46  +   // todo: normalize
           47  +   if( x < cnt(hh,d,n,M) )
           48  +    return c + rec(hist+c, x, d, n, M-1);
           49  +   x -= cnt(hh,d,n,M);
           50  +  }
           51  +  return "";
           52  + }
           53  +
           54  + LL cnt(string hist, int d, int n, int M)
           55  + {
           56  +  if( M == 0 )
           57  +   return 1;
           58  +
           59  +  // todo: memoize
           60  +
           61  +  LL ans = 0;
           62  +  for(char c='a'; c<='z'; ++c)
           63  +  {
           64  +   char cc = c;
           65  +   if( find(hist.begin(), hist.end(), c)==hist.end() )
           66  +    cc = *max_element(hist.begin(),hist.end()) + 1; // todo: end then 'a'
           67  +   string h2 = hist+cc;
           68  +   // todo: check violation
           69  +   // todo: drop 1st (if needed)
           70  +   // todo: normalize
           71  +   //ans += cnt(h2, dd, nn, M-1);
           72  +  }
           73  +  return ans;
           74  + }
           75  +};
           76  +
           77  +// BEGIN CUT HERE
           78  +#include <ctime>
           79  +double start_time; string timer()
           80  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           81  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           82  + { os << "{ ";
           83  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           84  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           85  +void verify_case(const string& Expected, const string& Received) {
           86  + bool ok = (Expected == Received);
           87  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           88  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           89  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           90  +#define END  verify_case(_, NextHomogeneousStrings().getNext(d, n, seed, k));}
           91  +int main(){
           92  +
           93  +CASE(0)
           94  + int d = 1;
           95  + int n = 2;
           96  + string seed = "aaa";
           97  + long long k = 3LL;
           98  + string _ = "ddd";
           99  +END
          100  +CASE(1)
          101  + int d = 2;
          102  + int n = 3;
          103  + string seed = "abc";
          104  + long long k = 0LL;
          105  + string _ = "aca";
          106  +END
          107  +CASE(2)
          108  + int d = 2;
          109  + int n = 4;
          110  + string seed = "ttrrzz";
          111  + long long k = 6LL;
          112  + string _ = "ttsssc";
          113  +END
          114  +CASE(3)
          115  + int d = 6;
          116  + int n = 8;
          117  + string seed = "txyaaxaassaaaarghjsdohasdghususdidisisdodo";
          118  + long long k = 10000000000000000LL;
          119  + string _ = "txyaaxaassaaaarghjsgaaaaaaaaadntffiniqrddy";
          120  +END
          121  +CASE(4)
          122  + int d = 2;
          123  + int n = 5;
          124  + string seed = "zzzzzaa";
          125  + long long k = 100LL;
          126  + string _ = "";
          127  +END
          128  +/*
          129  +CASE(5)
          130  + int d = ;
          131  + int n = ;
          132  + string seed = ;
          133  + long long k = LL;
          134  + string _ = ;
          135  +END
          136  +CASE(6)
          137  + int d = ;
          138  + int n = ;
          139  + string seed = ;
          140  + long long k = LL;
          141  + string _ = ;
          142  +END
          143  +*/
          144  +}
          145  +// END CUT HERE

Added SRM/468/1A.cpp version [bb06222c7a60f7be]

            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 T9 { public:
           23  + string message(vector <string> part, vector <string> dict, vector <string> keystr)
           24  + {
           25  +  string key;
           26  +  for(int i=0; i<keystr.size(); ++i)
           27  +   key += keystr[i];
           28  +
           29  +  sort(dict.begin(), dict.end());
           30  +
           31  +  string answer;
           32  +
           33  +  const char* p = key.c_str();
           34  +  while( *p )
           35  +  {
           36  +   if( *p == '0' ) {
           37  +    answer += ' ';
           38  +    ++p;
           39  +   } else {
           40  +    vector<int> alp;
           41  +    while( '1' <= *p && *p <= '9' )
           42  +     alp.push_back( *p++ - '1' );
           43  +    int cnt = 0;
           44  +    while( *p=='*' || *p=='#' )
           45  +     cnt += (*p++=='*' ? 5 : 1);
           46  +    answer += decode(part, dict, alp, cnt);
           47  +   }
           48  +  }
           49  +  return answer;
           50  + }
           51  +
           52  + string decode(const vector<string>& part, const vector<string>& dict, const vector<int>& alp, int cnt)
           53  + {
           54  +  for(int i=0; i<dict.size(); ++i)
           55  +   if( match(dict[i], part, alp) )
           56  +    if( cnt-- == 0 )
           57  +     return dict[i];
           58  +  assert(false);
           59  + }
           60  +
           61  + bool match(const string& d, const vector<string>& part, const vector<int>& alp)
           62  + {
           63  +  if( d.size() != alp.size() )
           64  +   return false;
           65  +
           66  +  for(int i=0; i<d.size(); ++i)
           67  +   if( part[alp[i]].find(d[i]) == string::npos )
           68  +    return false;
           69  +  return true;
           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(_, T9().message(part, dict, keystr));}
           87  +int main(){
           88  +
           89  +CASE(0)
           90  + string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
           91  +   vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_));
           92  + string dict_[] = {"bad"};
           93  +   vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_));
           94  + string keystr_[] = {"2230223"};
           95  +   vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_));
           96  + string _ = "bad bad";
           97  +END
           98  +CASE(1)
           99  + string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
          100  +   vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_));
          101  + string dict_[] = {"the", "tie"};
          102  +   vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_));
          103  + string keystr_[] = {"0843#000843#000"};
          104  +   vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_));
          105  + string _ = " tie   tie   ";
          106  +END
          107  +CASE(2)
          108  + string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
          109  +   vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_));
          110  + string dict_[] = {"bad", "ace", "aad", "aae", "aaf", "acf", "acd", "the", "tie"};
          111  +   vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_));
          112  + string keystr_[] = {"223#02", "23*#00843#0"};
          113  +   vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_));
          114  + string _ = "aae bad  tie ";
          115  +END
          116  +CASE(3)
          117  + string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
          118  +   vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_));
          119  + string dict_[] = {"the", "tie", "bad", "ace", "aad", "aae", "aaf", "acf", "acd"};
          120  +   vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_));
          121  + string keystr_[] = {"84300223#02", "23#*"};
          122  +   vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_));
          123  + string _ = "the  aae bad";
          124  +END
          125  +CASE(4)
          126  + string part_[] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
          127  +   vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_));
          128  + string dict_[] = {"bad", "ace", "aad", "aae", "tie", "aaf", "acf", "acd", "the"};
          129  +   vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_));
          130  + string keystr_[] = {"223#02", "23######"};
          131  +   vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_));
          132  + string _ = "aae bad";
          133  +END
          134  +CASE(5)
          135  + string part_[] = {"", "rq", "lde", "yoauz", "cbfgn", "tjkpx", "wvs", "ih", "m"};
          136  +   vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_));
          137  + string dict_[] = {"xktgmfmoqlmivm",
          138  + "hmthr",
          139  + "tpjgmnmaremiwm",
          140  + "tpjcmnmyrlmhvm",
          141  + "xkpnmgmzqdmhsm",
          142  + "wqopvvmiig",
          143  + "melbcbqeeg",
          144  + "jkxnmbmardmhwm",
          145  + "kpxnmcmyqlmism",
          146  + "wrztvsmhhf",
          147  + "srztssmiic",
          148  + "pxtgmfmyrdmhwm",
          149  + "vqoxswmiin",
          150  + "wryksvmihb",
          151  + "ptjfmbmoremhvm"};
          152  +   vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_));
          153  + string keystr_[] = {"00",
          154  + "7246779885##00000089682000007246779885##0000724677",
          155  + "9885#000089682000093355523350066659594239879###000"};
          156  +   vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_));
          157  + string _ = "  wqopvvmiig      hmthr     wqopvvmiig    vqoxswmiin    hmthr    melbcbqeeg  pxtgmfmyrdmhwm   ";
          158  +END
          159  +/*
          160  +CASE(6)
          161  + string part_[] = ;
          162  +   vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_));
          163  + string dict_[] = ;
          164  +   vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_));
          165  + string keystr_[] = ;
          166  +   vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_));
          167  + string _ = ;
          168  +END
          169  +CASE(7)
          170  + string part_[] = ;
          171  +   vector <string> part(part_, part_+sizeof(part_)/sizeof(*part_));
          172  + string dict_[] = ;
          173  +   vector <string> dict(dict_, dict_+sizeof(dict_)/sizeof(*dict_));
          174  + string keystr_[] = ;
          175  +   vector <string> keystr(keystr_, keystr_+sizeof(keystr_)/sizeof(*keystr_));
          176  + string _ = ;
          177  +END
          178  +*/
          179  +}
          180  +// END CUT HERE

Added SRM/468/1B.cpp version [9574f58423d94466]

            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  +template<typename T>
           23  +struct DP3x
           24  +{
           25  + int N1, N2, N3;
           26  + vector<T> data;
           27  + DP3x(int, int N2, int N3, const T& t = T())
           28  +  : N1(2), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T) < (1<<26)); }
           29  + T& operator()(int i1, int i2, int i3)
           30  +  { i1&=1; return data[ ((i1*N2)+i2)*N3+i3 ]; }
           31  + void swap(DP3x& rhs)
           32  +  { data.swap(rhs.data); }
           33  +};
           34  +
           35  +static const LL inf = (1LL << 60);
           36  +
           37  +class RoadOrFlightHard { public:
           38  + long long minTime(int N, int roadFirst, int roadProd, int roadAdd, int roadMod, int flightFirst, int flightProd, int flightAdd, int flightMod, int K)
           39  + {
           40  +  // input
           41  +  vector<LL> rt(N), ft(N);
           42  +  {
           43  +   rt[0] = roadFirst % roadMod;
           44  +   for(int i=1; i<N; ++i)
           45  +    rt[i] = (LL(rt[i-1])*roadProd + roadAdd) % roadMod;
           46  +  }
           47  +  {
           48  +   ft[0] = flightFirst % flightMod;
           49  +   for(int i=1; i<N; ++i)
           50  +    ft[i] = (LL(ft[i-1])*flightProd + flightAdd) % flightMod;
           51  +  }
           52  +
           53  +  DP3x<LL> dp(N+1, K+1, 2);
           54  +  for(int n=0; n<=N; ++n)
           55  +  for(int k=0; k<=K; ++k)
           56  +   if( n == 0 ) {
           57  +    dp(n,k,0) = 0;
           58  +    dp(n,k,1) = inf;
           59  +   }
           60  +   else {
           61  +    dp(n,k,0) = min(dp(n-1,k,0), dp(n-1,k,1)) + rt[n-1];
           62  +    if( k == 0 )
           63  +     dp(n,k,1) = inf;
           64  +    else
           65  +     dp(n,k,1) = min(dp(n-1,k,1), dp(n-1,k-1,0)) + ft[n-1];
           66  +   }
           67  +
           68  +  LL ans = inf;
           69  +  for(int k=0; k<=K; ++k)
           70  +   ans = min(ans, min(dp(N,k,0), dp(N,k,1)));
           71  +  return ans;
           72  + }
           73  +};
           74  +
           75  +// BEGIN CUT HERE
           76  +#include <ctime>
           77  +double start_time; string timer()
           78  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           79  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           80  + { os << "{ ";
           81  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           82  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           83  +void verify_case(const long long& Expected, const long long& Received) {
           84  + bool ok = (Expected == Received);
           85  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           86  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           87  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           88  +#define END  verify_case(_, RoadOrFlightHard().minTime(N, roadFirst, roadProd, roadAdd, roadMod, flightFirst, flightProd, flightAdd, flightMod, K));}
           89  +int main(){
           90  +
           91  +CASE(0)
           92  + int N = 3;
           93  + int roadFirst = 14;
           94  + int roadProd = 1;
           95  + int roadAdd = 2;
           96  + int roadMod = 10;
           97  + int flightFirst = 18;
           98  + int flightProd = 1;
           99  + int flightAdd = 10;
          100  + int flightMod = 17;
          101  + int K = 1;
          102  + long long _ = 14LL;
          103  +END
          104  +CASE(1)
          105  + int N = 3;
          106  + int roadFirst = 4;
          107  + int roadProd = 1;
          108  + int roadAdd = 2;
          109  + int roadMod = 10;
          110  + int flightFirst = 1;
          111  + int flightProd = 1;
          112  + int flightAdd = 10;
          113  + int flightMod = 17;
          114  + int K = 2;
          115  + long long _ = 11LL;
          116  +END
          117  +CASE(2)
          118  + int N = 3;
          119  + int roadFirst = 4;
          120  + int roadProd = 1;
          121  + int roadAdd = 2;
          122  + int roadMod = 10;
          123  + int flightFirst = 1;
          124  + int flightProd = 1;
          125  + int flightAdd = 6;
          126  + int flightMod = 9;
          127  + int K = 1;
          128  + long long _ = 12LL;
          129  +END
          130  +CASE(3)
          131  + int N = 5;
          132  + int roadFirst = 85739;
          133  + int roadProd = 94847;
          134  + int roadAdd = 93893;
          135  + int roadMod = 98392;
          136  + int flightFirst = 92840;
          137  + int flightProd = 93802;
          138  + int flightAdd = 93830;
          139  + int flightMod = 92790;
          140  + int K = 3;
          141  + long long _ = 122365LL;
          142  +END
          143  +CASE(4)
          144  + int N = 1;
          145  + int roadFirst = 2;
          146  + int roadProd = 1;
          147  + int roadAdd = 1;
          148  + int roadMod = 100;
          149  + int flightFirst = 1;
          150  + int flightProd = 1;
          151  + int flightAdd = 1;
          152  + int flightMod = 2;
          153  + int K = 0;
          154  + long long _ = 2LL;
          155  +END
          156  +CASE(4)
          157  + int N = 1;
          158  + int roadFirst = 2;
          159  + int roadProd = 1;
          160  + int roadAdd = 1;
          161  + int roadMod = 100;
          162  + int flightFirst = 1;
          163  + int flightProd = 1;
          164  + int flightAdd = 1;
          165  + int flightMod = 2;
          166  + int K = 1;
          167  + long long _ = 1LL;
          168  +END
          169  +CASE(5)
          170  + int N = 1;
          171  + int roadFirst = 0;
          172  + int roadProd = 1;
          173  + int roadAdd = 1;
          174  + int roadMod = 100;
          175  + int flightFirst = 0;
          176  + int flightProd = 1;
          177  + int flightAdd = 1;
          178  + int flightMod = 1;
          179  + int K = 1;
          180  + long long _ = 0LL;
          181  +END
          182  +CASE(6)
          183  + int N = 400000;
          184  + int roadFirst = 1234;
          185  + int roadProd = 56789;
          186  + int roadAdd = 32323;
          187  + int roadMod = 99999;
          188  + int flightFirst = 9876;
          189  + int flightProd = 44344;
          190  + int flightAdd = 7865;
          191  + int flightMod = 99999;
          192  + int K = 40;
          193  + long long _ = -1LL;
          194  +END
          195  +
          196  +}
          197  +// END CUT HERE

Added SRM/468/1C.cpp version [ef7e420ef333d5ce]

            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  +typedef int           vert;
           23  +typedef vert          edge;
           24  +typedef vector<edge>  edges;
           25  +typedef vector<edges> graph;
           26  +
           27  +bool augment( graph& G, int v, vector<vert>& matchTo, bool visited[] )
           28  +{
           29  + for(int i=0; i<G[v].size(); ++i) {
           30  +  vert u = G[v][i];
           31  +  if( visited[u] ) continue;
           32  +  visited[u] = true;
           33  +
           34  +  if( matchTo[u]<0 || augment(G, matchTo[u], matchTo, visited) )
           35  +   { matchTo[v]=u, matchTo[u]=v; return true; }
           36  + }
           37  + return false;
           38  +}
           39  +
           40  +template<int NV>
           41  +int biMatch( graph& G, int L ) // [0,L):left, [L,?):right
           42  +{
           43  + vector<vert> matchTo(G.size(), -1);
           44  + int ans = 0;
           45  + for(vert v=0; v<L; ++v) {
           46  +  bool visited[NV] = {};
           47  +  if( augment(G, v, matchTo, visited) )
           48  +   ++ans;
           49  + }
           50  + return ans;
           51  +}
           52  +
           53  +int bitcnt(LL x)
           54  +{
           55  + int c = 0;
           56  + for(; x; x>>=1)
           57  +  c += x&1;
           58  + return c;
           59  +}
           60  +
           61  +class MallSecurity { public:
           62  + pair<graph, int> generateBipartiteGraph(
           63  +  const vector<int>& As, const vector<int>& Bs, const vector<int>& Cs, const vector<int>& Ds,
           64  +  const vector<int>& Ks, int msf, int mask )
           65  + {
           66  +  // construct a bipartite graph representation, in which
           67  +  //   - "even"-floor stations go to the left
           68  +  //   - "odd"-floor stations go to the right
           69  +  // here floor number is normalized by rotating the msf-th floor to zero
           70  +  #define LR(f) (((f)>msf ? (f)-msf : Ks.size()-msf+(f))%2)
           71  +
           72  +  // assign interger-ID for each "choosable" station, i.e.,
           73  +  // a station which is not at msf and is not connected to a 'mask'ed station on msf
           74  +  map<pair<int,int>,int> ID;
           75  +  int nextID[2] = {0,0}; // use different sets of IDs for even/odd floors
           76  +  {
           77  +   for(int f=0; f<Ks.size(); ++f) if( f != msf )
           78  +   for(int i=0; i<Ks[f]; ++i)
           79  +   {
           80  +    bool can_use = true;
           81  +    for(int j=0; j<As.size(); ++j)
           82  +     if( Cs[j]==f && As[j]==i && Ds[j]==msf && (mask & 1<<Bs[j])
           83  +      || Ds[j]==f && Bs[j]==i && Cs[j]==msf && (mask & 1<<As[j]) )
           84  +      can_use = false;
           85  +    if( can_use )
           86  +     ID[make_pair(f,i)] = nextID[LR(f)]++;
           87  +   }
           88  +  }
           89  +
           90  +  // then create the graph
           91  +  graph G( nextID[0] + nextID[1] );
           92  +  for(int j=0; j<As.size(); ++j)
           93  +  {
           94  +   pair<int,int> p(Cs[j], As[j]);
           95  +   pair<int,int> q(Ds[j], Bs[j]);
           96  +   if( ID.count(p) && ID.count(q) )
           97  +   {
           98  +    int pid = ID[p] + (LR(Cs[j]) ? nextID[0] : 0);
           99  +    int qid = ID[q] + (LR(Ds[j]) ? nextID[0] : 0);
          100  +    G[pid].push_back(qid);
          101  +    G[qid].push_back(pid);
          102  +   }
          103  +  }
          104  +  return make_pair(G, nextID[0]);
          105  + }
          106  +
          107  + int maxGuards(int N, vector <string> escDescription)
          108  + {
          109  +  // parse the input
          110  +  vector<int> As, Bs, Cs, Ds, Ks(N);
          111  +  {
          112  +   stringstream sin;
          113  +   copy( escDescription.begin(), escDescription.end(), ostream_iterator<string>(sin,"") );
          114  +
          115  +   for(int A,B,C; sin>>A>>B>>C; )
          116  +   {
          117  +    {char comma; sin>>comma;}
          118  +    --A, --B, --C; int D=(C+1)%N; // to 0-orign
          119  +    As.push_back(A);
          120  +    Bs.push_back(B);
          121  +    Cs.push_back(C);
          122  +    Ds.push_back(D);
          123  +    Ks[C] = max(Ks[C], A+1);
          124  +    Ks[D] = max(Ks[D], B+1);
          125  +   }
          126  +  }
          127  +
          128  +  // the most simple floor, where the number Ks[msf] of stations is the least
          129  +  int msf = min_element(Ks.begin(), Ks.end()) - Ks.begin();
          130  +
          131  +  // try all possibilities at the msf-th floor
          132  +  size_t answer = 0;
          133  +  for(int mask=0; mask<(1<<Ks[msf]); ++mask)
          134  +  {
          135  +   // then the rest of the part becomes a bipartite graph
          136  +   pair<graph, int> G = generateBipartiteGraph(As,Bs,Cs,Ds,Ks,msf,mask);
          137  +
          138  +   // |MaxIndenepdentSet| == |V|-|MinCover| =(for bipartite graphs)= |V|-|MaxMatch|
          139  +   answer = max(answer, G.first.size() - biMatch<100>(G.first,G.second) + bitcnt(mask));
          140  +  }
          141  +  return answer;
          142  + }
          143  +};
          144  +
          145  +// BEGIN CUT HERE
          146  +#include <ctime>
          147  +double start_time; string timer()
          148  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          149  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          150  + { os << "{ ";
          151  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          152  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          153  +void verify_case(const int& Expected, const int& Received) {
          154  + bool ok = (Expected == Received);
          155  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          156  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          157  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          158  +#define END  verify_case(_, MallSecurity().maxGuards(N, escDescription));}
          159  +int main(){
          160  +
          161  +CASE(0)
          162  + int N = 10;
          163  + string escDescription_[] = {"1 1 1,1 1 2,1 1 3,1 1 4,1 1 5,1 1 6,1 1 7,1 1 8,1 ",
          164  + "1 9,1 1 10"};
          165  +   vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_));
          166  + int _ = 5;
          167  +END
          168  +CASE(1)
          169  + int N = 11;
          170  + string escDescription_[] = {"1 1 1,1 1 2,1 1 3,1 1 4,1 1 5,1 1 6,1 1 7,1 1 8,1 ",
          171  + "1 9,1 1 10"};
          172  +   vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_));
          173  + int _ = 6;
          174  +END
          175  +CASE(2)
          176  + int N = 10;
          177  + string escDescription_[] = {"1 1 7,1 2 9,2 1",
          178  + " 8,1 2 6,1 1 8,1 2 3,1 2 2,2 ",
          179  + "2 4,1 1 1,2 1 2,3 2 3,1 1 5,2 1 1,4 ",
          180  + "1 7,1 1 10,3 2 5,1 2 5,3 3 1,",
          181  + "3 2 8,3 1 2,1 1 3,4 4 2,2",
          182  + " 4 6,4 2 5,2 3 3,6 4 1,5 2 8,1 3 6,1 3 7,",
          183  + "4 3 8,1 3 8,5 2 3,4 2 8,2 6 7,1 3 9,",
          184  + "1 1 4,6 1 1,2 3 1,5 1 5,6 1 8,5 ",
          185  + "2 2,3 2 10,3 3 9,1 5 2,4 1 1,1 5 10"};
          186  +   vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_));
          187  + int _ = 25;
          188  +END
          189  +CASE(3)
          190  + int N = 13;
          191  + string escDescription_[] = {"5 1 11,2 3 9,3 7 10,5 2 11,5 5 8,7 5 6,5 2 13,4 2 ", "8,3 7 12,7 3 9,2 7 12,8 5 4,4 6 6,7 3 11,1 5 7,4 4", " 10,3 1 9,7 2 5,4 6 12,5 5 5,6 6 5,1 5 12,6 4 3,2 ", "5 1,2 5 5,5 4 3,5 6 8,3 5 11,6 2 7,8 3 7,6 8 2,5 3", " 12,6 1 3,6 2 8,6 2 6,5 5 6,3 2 2,4 3 11,1 8 2,3 4", " 5,1 6 8,5 7 6,3 2 7,4 1 9,4 7 8,4 3 7,4 5 4,2 1 7", ",5 4 2,6 5 4,6 8 13,2 6 3,6 3 6,3 4 7,4 5 8,1 3 11", ",6 6 1,5 1 8,3 5 7,7 3 4,3 4 13,5 4 6,7 4 1,3 1 13", ",1 5 6,7 7 12,4 7 3,7 4 4,1 6 10,3 4 6,7 4 10,5 3 ", "13,1 1 4,8 7 7,2 7 13,5 6 11,1 4 9,4 4 13,2 6 8,7 ", "5 10,1 2 7,1 7 8,8 8 3,2 4 1,7 6 12,2 5 12,2 2 3,1", " 2 2,1 4 7,4 1 11,6 2 4,4 6 4,6 3 8,5 6 7,4 2 4,2 ", "7 6,7 2 1,3 4 4,4 4 3,1 2 3,1 1 10,2 3 8,6 6 11,5 ", "5 13,7 7 4,5 3 11,6 6 8,6 4 12,6 1 7,3 8 9,2 1 1,5", " 5 10,8 1 7,7 2 6,1 7 4,5 1 12,2 5 7,6 7 7,3 6 3,8", " 1 1,3 8 2,3 6 6,3 6 4,6 3 2,4 5 5,2 6 4,3 2 6,7 6", " 5,1 8 6,5 5 4,2 7 10", ",1 7 9,1 1 3,4 4 4,4 3 5,4 2 10,5 7 3,5 3 5,3 6 9,", "2 5 11,3 2 3,4 1 1,2 5 10,5 1 4,6 5 5,1 7 5,7 5 5,", "8 5 12,7 8 13,1 2 10,3 7 6,4 7 13,4 3 13,6 4 11,6 ", "7 4,2 6 7,2 7 3,7 8 8,6 1 12,6 7 8,3 1 10,8 6 1,1 ", "7 10,1 3 9,7 7 11,5 6 4,7 7 1,4 2 1,8 2 3,7 8 2,1 ", "4 13,2 3 13,3 2 11,6 7 12,4 8 2,5 6 1,6 3 12,3 5 3", ",1 5 10,1 4 5,4 6 10,1 6 6,6 3 5,4 3 12,6 2 11,3 8", " 3,7 5 3,6 7 10,3 2 13,7 4 3,1 7 12,2 7 4,4 7 1,8 ", "5 10,6 6 4,6 7 2,4 7 7,1 3 1,1 4 12,6 5 7,5 1 13,5", " 8 13,2 1 10,5 2 7,8 3 10,5 1 5,1 4 6,1 1 6,5 2 2,", "2 3 11,3 2 10,2 1 13,8 2 9,3 5 2,1 7 2,3 3 5,5 2 5", ",8 4 12,7 3 2,2 5 3,3 7 1,6 7 6,8 5 9,4 5 7,2 8 3,", "2 4 6,7 1 10,5 8 11,4 7 6,7 6 4,3 6 11,5 3 1,7 7 8", ",1 6 9,7 6 7,1 2 1,2 2 12,3 5 9,4 4 1,6 4 5,5 8 3,", "2 1 2,6 6 10,1 5 9,8 1 3,5 1 10,4 7 2,8 4 9,2 2 7,", "2 3 4,6 1 4,1 4 11,7 1 1,3 7 7,5 4 13,1 6 1,4 7 12"};
          192  +   vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_));
          193  + int _ = 50;
          194  +END
          195  +/*
          196  +CASE(4)
          197  + int N = ;
          198  + string escDescription_[] = ;
          199  +   vector <string> escDescription(escDescription_, escDescription_+sizeof(escDescription_)/sizeof(*escDescription_));
          200  + int _ = ;
          201  +END
          202  +*/
          203  +}
          204  +// END CUT HERE

Added SRM/469/1A.cpp version [d06567508a7c0830]

            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 TheMoviesLevelOneDivOne { public:
           23  + long long find(int n, int m, vector <int> row, vector <int> seat)
           24  + {
           25  +  LL all = LL(n)*LL(m-1);
           26  +
           27  +  set< pair<int,int> > dead;
           28  +  for(int i=0; i<row.size(); ++i)
           29  +  {
           30  +   int y = row[i]-1;
           31  +   int x = seat[i]-1;
           32  +   if(x<m-1)dead.insert( make_pair(y,x) );
           33  +   if(x>0) dead.insert( make_pair(y,x-1) );
           34  +  }
           35  +  return all - dead.size();
           36  + }
           37  +};
           38  +
           39  +// BEGIN CUT HERE
           40  +#include <ctime>
           41  +double start_time; string timer()
           42  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           43  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           44  + { os << "{ ";
           45  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           46  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           47  +void verify_case(const long long& Expected, const long long& Received) {
           48  + bool ok = (Expected == Received);
           49  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           50  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           51  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           52  +#define END  verify_case(_, TheMoviesLevelOneDivOne().find(n, m, row, seat));}
           53  +int main(){
           54  +
           55  +CASE(0)
           56  + int n = 2;
           57  + int m = 3;
           58  + int row_[] = {1, 2};
           59  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
           60  + int seat_[] = {2, 3};
           61  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
           62  + long long _ = 1LL;
           63  +END
           64  +CASE(1)
           65  + int n = 2;
           66  + int m = 3;
           67  + int row_[] = {1, 1, 1, 2, 2, 2};
           68  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
           69  + int seat_[] = {1, 2, 3, 1, 2, 3};
           70  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
           71  + long long _ = 0LL;
           72  +END
           73  +CASE(2)
           74  + int n = 4;
           75  + int m = 7;
           76  + int row_[] = {1};
           77  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
           78  + int seat_[] = {1};
           79  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
           80  + long long _ = 23LL;
           81  +END
           82  +CASE(3)
           83  + int n = 10;
           84  + int m = 8;
           85  + int row_[] = {1, 9, 6, 10, 6, 7, 9, 3, 9, 2};
           86  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
           87  + int seat_[] = {7, 7, 3, 3, 7, 1, 5, 1, 6, 2};
           88  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
           89  + long long _ = 54LL;
           90  +END
           91  +CASE(4)
           92  + int n = 1;
           93  + int m = 1;
           94  + int row_[] = {1};
           95  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
           96  +   int seat_[] = {1};
           97  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
           98  + long long _ = 0LL;
           99  +END
          100  +CASE(5)
          101  + int n = 1000000000;
          102  + int m = 1;
          103  + int row_[] = {1};
          104  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
          105  +   int seat_[] = {1};
          106  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
          107  + long long _ = 0LL;
          108  +END
          109  +CASE(6)
          110  + int n = 1000000000;
          111  + int m = 100000001;
          112  + int row_[] = {1};
          113  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
          114  +   int seat_[] = {1};
          115  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
          116  + long long _ = 100000000000000000LL - 1;
          117  +END
          118  +CASE(7)
          119  + int n = 1000000000;
          120  + int m = 100000001;
          121  + int row_[] = {2};
          122  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
          123  +   int seat_[] = {1};
          124  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
          125  + long long _ = 100000000000000000LL - 1;
          126  +END
          127  +CASE(8)
          128  + int n = 1000000000;
          129  + int m = 100000001;
          130  + int row_[] = {1};
          131  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
          132  +   int seat_[] = {2};
          133  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
          134  + long long _ = 100000000000000000LL - 2;
          135  +END
          136  +CASE(9)
          137  + int n = 1000000000;
          138  + int m = 100000001;
          139  + int row_[] = {1};
          140  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
          141  +   int seat_[] = {100000001};
          142  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
          143  + long long _ = 100000000000000000LL - 1;
          144  +END
          145  +CASE(10)
          146  + int n = 1000000000;
          147  + int m = 100000001;
          148  + int row_[] = {1};
          149  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
          150  +   int seat_[] = {100000000};
          151  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
          152  + long long _ = 100000000000000000LL - 2;
          153  +END
          154  +CASE(11)
          155  + int n = 3;
          156  + int m = 3;
          157  + int row_[] = {1,2,3};
          158  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
          159  +   int seat_[] = {2,2,2};
          160  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
          161  + long long _ = 0LL;
          162  +END
          163  +CASE(12)
          164  + int n = 3;
          165  + int m = 3;
          166  + int row_[] = {1,2,3,2,2};
          167  +   vector <int> row(row_, row_+sizeof(row_)/sizeof(*row_));
          168  +   int seat_[] = {1,2,3,1,3};
          169  +   vector <int> seat(seat_, seat_+sizeof(seat_)/sizeof(*seat_));
          170  + long long _ = 2LL;
          171  +END
          172  +}
          173  +// END CUT HERE

Added SRM/469/1B.cpp version [bec7920e12c18fbc]

            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 TheMoviesLevelTwoDivOne { public:
           23  + vector <int> find(vector <int> length, vector <int> scary)
           24  + {
           25  +  int N = length.size();
           26  +
           27  +  vector<int> lwb(N), inc(N);
           28  +  for(int i=0; i<N; ++i)
           29  +   if( scary[i]+47 < length[i] )
           30  +    lwb[i] = length[i] - 47;
           31  +   else
           32  +    lwb[i] = scary[i];
           33  +  for(int i=0; i<N; ++i)
           34  +   inc[i] = 47 - length[i];
           35  +
           36  +  memo = vector<bool>(1<<N);
           37  +  memo[(1<<N)-1] = true;
           38  +  vector<int> temp;
           39  +  rec(0, 74, N, lwb, inc, temp);
           40  +
           41  +  set<int> not_used;
           42  +  for(int i=0; i<N; ++i) not_used.insert(i);
           43  +  for(int i=0; i<result.size(); ++i)
           44  +   not_used.erase(result[i]);
           45  +  result.insert(result.end(), not_used.begin(), not_used.end());
           46  +
           47  +  return result;
           48  + }
           49  +
           50  + vector<int>  result;
           51  + vector<bool> memo;
           52  + void rec(int mask, int cur, int N, vector<int>& lwb, vector<int>& inc, vector<int>& temp)
           53  + {
           54  +  if( result.size() < temp.size() )
           55  +   result = temp;
           56  +  if( memo[mask] )
           57  +   return;
           58  +  memo[mask] = true;
           59  +
           60  +  for(int i=0; i<N; ++i)
           61  +   if( !(mask & (1<<i)) && cur>=lwb[i] )
           62  +   {
           63  +    temp.push_back(i);
           64  +    rec(mask|(1<<i), cur+inc[i], N, lwb, inc, temp);
           65  +    temp.pop_back();
           66  +   }
           67  + }
           68  +};
           69  +
           70  +// BEGIN CUT HERE
           71  +#include <ctime>
           72  +double start_time; string timer()
           73  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           74  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           75  + { os << "{ ";
           76  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           77  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           78  +void verify_case(const vector <int>& Expected, const vector <int>& Received) {
           79  + bool ok = (Expected == Received);
           80  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           81  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           82  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           83  +#define END  verify_case(_, TheMoviesLevelTwoDivOne().find(length, scary));}
           84  +int main(){
           85  +
           86  +CASE(0)
           87  + int length_[] = {100, 50};
           88  +   vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_));
           89  + int scary_[] = {1, 1};
           90  +   vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_));
           91  + int __[] = {0, 1 };
           92  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           93  +END
           94  +CASE(1)
           95  + int length_[] = {100, 50};
           96  +   vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_));
           97  + int scary_[] = {1, 49};
           98  +   vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_));
           99  + int __[] = {1, 0 };
          100  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          101  +END
          102  +CASE(2)
          103  + int length_[] = {100, 100, 100, 100};
          104  +   vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_));
          105  + int scary_[] = {77, 76, 75, 74};
          106  +   vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_));
          107  + int __[] = {3, 0, 1, 2 };
          108  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          109  +END
          110  +CASE(3)
          111  + int length_[] = {100};
          112  +   vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_));
          113  + int scary_[] = {99};
          114  +   vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_));
          115  + int __[] = {0 };
          116  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          117  +END
          118  +CASE(4)
          119  + int length_[] = {2};
          120  +   vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_));
          121  + int scary_[] = {1};
          122  +   vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_));
          123  +   int __[] = {0};
          124  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          125  +END
          126  +CASE(5)
          127  + int length_[] = {3};
          128  +   vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_));
          129  + int scary_[] = {1};
          130  +   vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_));
          131  +   int __[] = {0};
          132  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          133  +END
          134  +CASE(6)
          135  +  int length_[] = {5,6,7,8,9,10,11,10,9,8,7,6,5,6,7,8,9,10,11,10};
          136  +   vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_));
          137  +  int scary_[] = {3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3};
          138  +   vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_));
          139  +  int __[] = {-1};
          140  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          141  +END
          142  +CASE(7)
          143  +  int length_[] = {185, 53, 28, 92, 70};
          144  +   vector <int> length(length_, length_+sizeof(length_)/sizeof(*length_));
          145  +  int scary_[] = {96, 17, 4, 6, 34};
          146  +   vector <int> scary(scary_, scary_+sizeof(scary_)/sizeof(*scary_));
          147  +  int __[] = {1,2,3,4,0};
          148  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          149  +END
          150  +}
          151  +// END CUT HERE

Added SRM/469/1C.cpp version [d5918a22f737d339]

            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 TheMoviesLevelThreeDivOne { public:
           23  + long long find(vector <int> timeJ, vector <int> timeB)
           24  + {
           25  +  int N = timeJ.size();
           26  +  return (1LL<<N) - quitJ(N, timeJ, timeB) - quitJ(N, timeB, timeJ);
           27  + }
           28  +
           29  + LL quitJ(int N, vector<int>& J, vector<int>& B) // # of patterns in which J quits
           30  + {
           31  +  typedef pair<int,int>            state;
           32  +  typedef map<state, LL>::iterator iter;
           33  +
           34  +  map<pair<int,int>, LL> M;
           35  +  M[state(0,-0x3fffffff)] = 1;
           36  +
           37  +  for(int i=0; i<N; ++i)
           38  +  {
           39  +   map<state, LL> M2;
           40  +   for(iter it=M.begin(); it!=M.end(); ++it)
           41  +   {
           42  +    int sum   = it->first.first;
           43  +    int bound = it->first.second;
           44  +    LL  n     = it->second;
           45  +
           46  +    M2[state(sum+J[i],      bound-J[i])]           += n; // i goes to J
           47  +    M2[state(sum+J[i]-B[i], max(bound, B[i]-sum))] += n; // i goes to B
           48  +   }
           49  +   M2.swap(M);
           50  +  }
           51  +
           52  +  LL cnt = 0;
           53  +  for(iter it=M.begin(); it!=M.end(); ++it)
           54  +   if( 0 < it->first.second )
           55  +    cnt += it->second;
           56  +  return cnt;
           57  + }
           58  +};
           59  +
           60  +// BEGIN CUT HERE
           61  +#include <ctime>
           62  +double start_time; string timer()
           63  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           64  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           65  + { os << "{ ";
           66  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           67  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           68  +void verify_case(const long long& Expected, const long long& Received) {
           69  + bool ok = (Expected == Received);
           70  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           71  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           72  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           73  +#define END  verify_case(_, TheMoviesLevelThreeDivOne().find(timeJ, timeB));}
           74  +int main(){
           75  +
           76  +CASE(0)
           77  + int timeJ_[] = {4, 4};
           78  +   vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_));
           79  + int timeB_[] = {4, 4};
           80  +   vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_));
           81  + long long _ = 2LL;
           82  +END
           83  +CASE(1)
           84  + int timeJ_[] = {1, 4};
           85  +   vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_));
           86  + int timeB_[] = {4, 2};
           87  +   vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_));
           88  + long long _ = 1LL;
           89  +END
           90  +CASE(2)
           91  + int timeJ_[] = {10, 10, 10, 10};
           92  +   vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_));
           93  + int timeB_[] = {1, 1, 1, 10};
           94  +   vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_));
           95  + long long _ = 3LL;
           96  +END
           97  +CASE(3)
           98  + int timeJ_[] = {1, 2, 3, 4, 5, 6, 7};
           99  +   vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_));
          100  + int timeB_[] = {7, 6, 5, 4, 3, 2, 1};
          101  +   vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_));
          102  + long long _ = 98LL;
          103  +END
          104  +CASE(4)
          105  + int timeJ_[] = {8,19,17,5,9,15,10,14,13,11,4,1,18,11,10,8,13,8,20,4,5,3,20,5,16,8,17,6,16,14,1,17,10,17,20,14,13,17,17,19,20,2,17,6,12,4,2};
          106  +   vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_));
          107  + int timeB_[] = {9,19,6,12,2,13,19,11,9,12,17,6,7,6,1,17,15,8,7,6,10,6,2,20,9,8,3,7,7,14,17,8,2,5,5,12,11,1,2,5,20,16,18,15,16,14,12};
          108  +   vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_));
          109  + long long _ = -1LL;
          110  +END
          111  +/*
          112  +CASE(5)
          113  + int timeJ_[] = ;
          114  +   vector <int> timeJ(timeJ_, timeJ_+sizeof(timeJ_)/sizeof(*timeJ_));
          115  + int timeB_[] = ;
          116  +   vector <int> timeB(timeB_, timeB_+sizeof(timeB_)/sizeof(*timeB_));
          117  + long long _ = LL;
          118  +END
          119  +*/
          120  +}
          121  +// END CUT HERE

Added SRM/470-U/1A.cpp version [24617375bbc033b8]

            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 DoorsGame { public:
           23  + int determineOutcome(string doors, int trophy)
           24  + {
           25  +  vector<int> score(2<<16);
           26  +  vector<bool> computed(2<<16);
           27  +  return rec(score, computed, 0, doors, trophy);
           28  + }
           29  + int rec(vector<int>& score, vector<bool>& computed, int mask, string& doors, int trophy)
           30  + {
           31  +  if( computed[mask] )
           32  +   return score[mask];
           33  +  computed[mask] = true;
           34  +
           35  +  bool Lwin = true;
           36  +  for(int i=0; i<trophy; ++i)
           37  +   if( !(mask & (1<<(doors[i]-'A'))) )
           38  +    Lwin = false;
           39  +  bool Rwin = true;
           40  +  for(int i=doors.size()-1; i>=trophy; --i)
           41  +   if( !(mask & (1<<(doors[i]-'A'))) )
           42  +    Rwin = false;
           43  +
           44  +  if( Lwin && Rwin )
           45  +   return score[mask] = 0;
           46  +  if( Lwin )
           47  +   return score[mask] = +bitcnt(mask);
           48  +  if( Rwin )
           49  +   return score[mask] = -bitcnt(mask);
           50  +
           51  +  vector<int> ss;
           52  +  for(int c=0; c<16; ++c)
           53  +   if( !(mask & (1<<c)) )
           54  +    ss.push_back( rec(score,computed,mask|(1<<c),doors,trophy) );
           55  +
           56  +  bool L = !(bitcnt(mask)&1);
           57  +  if(!L)
           58  +   for(int i=0; i<ss.size(); ++i)
           59  +    ss[i] = -ss[i];
           60  +
           61  +  int Ms = *max_element(ss.begin(),ss.end());
           62  +  if( Ms == 0 )
           63  +   return score[mask] = 0;
           64  +  if( Ms > 0 ) {
           65  +   int posMin = 99999;
           66  +   for(int i=0; i<ss.size(); ++i)
           67  +    if(ss[i]>0)
           68  +     posMin = min(posMin,ss[i]);
           69  +   return score[mask] = (L ? posMin : -posMin);
           70  +  }
           71  +  int me = *min_element(ss.begin(), ss.end());
           72  +  return score[mask] = (L ? me : -me);
           73  + }
           74  + int bitcnt(int mask)
           75  + {
           76  +  int cnt = 0;
           77  +  for(; mask; mask>>=1)
           78  +   cnt += mask&1;
           79  +  return cnt;
           80  + }
           81  +};
           82  +
           83  +// BEGIN CUT HERE
           84  +#include <ctime>
           85  +double start_time; string timer()
           86  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           87  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           88  + { os << "{ ";
           89  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           90  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           91  +void verify_case(const int& Expected, const int& Received) {
           92  + bool ok = (Expected == Received);
           93  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           94  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           95  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           96  +#define END  verify_case(_, DoorsGame().determineOutcome(doors, trophy));}
           97  +int main(){
           98  +
           99  +CASE(0)
          100  + string doors = "ABCD";
          101  + int trophy = 2;
          102  + int _ = 3;
          103  +END
          104  +CASE(1)
          105  + string doors = "ABCC";
          106  + int trophy = 2;
          107  + int _ = -2;
          108  +END
          109  +CASE(2)
          110  + string doors = "ABABAB";
          111  + int trophy = 3;
          112  + int _ = 0;
          113  +END
          114  +CASE(3)
          115  + string doors = "ABAPDCAA";
          116  + int trophy = 5;
          117  + int _ = -4;
          118  +END
          119  +CASE(4)
          120  + string doors = "MOCFDCE";
          121  + int trophy = 3;
          122  + int _ = 5;
          123  +END
          124  +CASE(5)
          125  + string doors = "ABCCDE";
          126  + int trophy = 3;
          127  + int _ = 0;
          128  +END
          129  +CASE(6)
          130  + string doors = "ABCCD";
          131  + int trophy = 3;
          132  + int _ = 0;
          133  +END
          134  +CASE(7)
          135  + string doors = "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPCC";
          136  + int trophy = 25;
          137  + int _ = 0;
          138  +END
          139  +CASE(8)
          140  + string doors = "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPCC";
          141  + int trophy = 7;
          142  + int _ = 0;
          143  +END
          144  +CASE(8)
          145  + string doors = "AAAAAAAAAAAAAAAAABCDEFGHIJKLMNOPPPPPPPPPPPPPPPPPP";
          146  + int trophy = 25;
          147  + int _ = 0;
          148  +END
          149  +}
          150  +// END CUT HERE

Added SRM/470-U/1B.cpp version [5418de6c5fb4301b]

            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 DrawingLines { public:
           23  + double countLineCrossings(int n, vector <int> startDot, vector <int> endDot)
           24  + {
           25  +  int m = n-startDot.size();
           26  +  double news = c(m);
           27  +  double ooolds = 0.0;
           28  +  for(int i=0; i<startDot.size(); ++i)
           29  +   for(int j=i+1; j<startDot.size(); ++j)
           30  +    if( startDot[i]<startDot[j] && endDot[i]>endDot[j]
           31  +    ||  startDot[i]>startDot[j] && endDot[i]<endDot[j] )
           32  +     ooolds += 1;
           33  +  double olds = 0.0;
           34  +
           35  +  vector<int> sTaken, eTaken;
           36  +  for(int i=0; i<startDot.size(); ++i) {
           37  +   sTaken.push_back(startDot[i]);
           38  +   eTaken.push_back(endDot[i]);
           39  +  }
           40  +  sort(sTaken.begin(), sTaken.end());
           41  +  sort(eTaken.begin(), eTaken.end());
           42  +
           43  +  if( n > startDot.size() )
           44  +  for(int i=0; i<startDot.size(); ++i) {
           45  +   vector<int>::iterator si = lower_bound(sTaken.begin(), sTaken.end(), startDot[i]);
           46  +   vector<int>::iterator ei = lower_bound(eTaken.begin(), eTaken.end(),   endDot[i]);
           47  +   olds += f( (startDot[i]-1) - (si-sTaken.begin()),
           48  +              (n-startDot[i]) - (sTaken.end()-si-1),
           49  +        (endDot[i]-1) - (ei-eTaken.begin()),
           50  +        (n-endDot[i]) - (eTaken.end()-ei-1)
           51  +        );
           52  +  }
           53  +  return news + ooolds + olds;
           54  + }
           55  +
           56  + double c(int m)
           57  + {
           58  +  return m*(m-1) / 4.0;
           59  + }
           60  +
           61  + double f(double a, double b, double c, double d)
           62  + {
           63  +  return a * d/(c+d) + b*c/(c+d);
           64  + }
           65  +};
           66  +
           67  +// BEGIN CUT HERE
           68  +#include <ctime>
           69  +double start_time; string timer()
           70  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           71  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           72  + { os << "{ ";
           73  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           74  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           75  +void verify_case(const double& Expected, const double& Received) {
           76  + bool ok = (abs(Expected - Received) < 1e-9);
           77  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           78  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           79  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           80  +#define END  verify_case(_, DrawingLines().countLineCrossings(n, startDot, endDot));}
           81  +int main(){
           82  +
           83  +CASE(0)
           84  + int n = 3;
           85  + int startDot_[] = {2};
           86  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
           87  + int endDot_[] = {3};
           88  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
           89  + double _ = 1.5;
           90  +END
           91  +CASE(1)
           92  + int n = 5;
           93  + int startDot_[] = {1,4};
           94  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
           95  + int endDot_[] = {3,1};
           96  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
           97  + double _ = 5.5;
           98  +END
           99  +CASE(2)
          100  + int n = 4;
          101  + int startDot_[] = {4,1};
          102  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
          103  + int endDot_[] = {4,1};
          104  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
          105  + double _ = 0.5;
          106  +END
          107  +CASE(3)
          108  + int n = 8;
          109  + int startDot_[] = {1,4,3,6,7};
          110  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
          111  + int endDot_[] = {1,3,2,4,5};
          112  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
          113  + double _ = 7.5;
          114  +END
          115  +CASE(4)
          116  + int n = 2;
          117  + int startDot_[] = {1,2} ;
          118  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
          119  + int endDot_[] = {1,2};
          120  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
          121  + double _ = 0;
          122  +END
          123  +CASE(5)
          124  + int n = 2;
          125  + int startDot_[] = {1,2} ;
          126  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
          127  + int endDot_[] = {2,1};
          128  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
          129  + double _ = 1;
          130  +END
          131  +CASE(6)
          132  + int n = 3;
          133  + int startDot_[] = {1} ;
          134  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
          135  + int endDot_[] = {1};
          136  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
          137  + double _ = 0.5;
          138  +END
          139  +CASE(7)
          140  + int n = 3;
          141  + int startDot_[] = {1} ;
          142  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
          143  + int endDot_[] = {3};
          144  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
          145  + double _ = 2.5;
          146  +END
          147  +CASE(8)
          148  + int n = 10000;
          149  + int startDot_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
          150  +   vector <int> startDot(startDot_, startDot_+sizeof(startDot_)/sizeof(*startDot_));
          151  +   int endDot_[] = {20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
          152  +   vector <int> endDot(endDot_, endDot_+sizeof(endDot_)/sizeof(*endDot_));
          153  + double _ = -1;
          154  +END
          155  +
          156  +}
          157  +// END CUT HERE

Added SRM/471-U/1A.cpp version [47ade1da7def4515]

            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 PrimeSequences { public:
           23  + int getLargestGenerator(int N, int D)
           24  + {
           25  +  int result = -1;
           26  +
           27  +  vector<int> p(N+1, 1);
           28  +  p[0] = p[1] = 0;
           29  +  for(int q=2; q<=N; ++q)
           30  +   if( p[q] ) {
           31  +    if(q<=N/q)
           32  +     for(int qq=q*q; qq<=N; qq+=q)
           33  +      p[qq] = 0;
           34  +    p[q] = p[q/2]+1;
           35  +    if( p[q] >= D )
           36  +     result = q;
           37  +   }
           38  +
           39  +  return result;
           40  + }
           41  +};
           42  +
           43  +// BEGIN CUT HERE
           44  +#include <ctime>
           45  +double start_time; string timer()
           46  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           47  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           48  + { os << "{ ";
           49  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           50  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           51  +void verify_case(const int& Expected, const int& Received) {
           52  + bool ok = (Expected == Received);
           53  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           54  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           55  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           56  +#define END  verify_case(_, PrimeSequences().getLargestGenerator(N, D));}
           57  +int main(){
           58  +
           59  +CASE(0)
           60  + int N = 10;
           61  + int D = 2;
           62  + int _ = 7;
           63  +END
           64  +CASE(1)
           65  + int N = 42;
           66  + int D = 3;
           67  + int _ = 23;
           68  +END
           69  +CASE(2)
           70  + int N = 666;
           71  + int D = 7;
           72  + int _ = -1;
           73  +END
           74  +CASE(3)
           75  + int N = 1337;
           76  + int D = 5;
           77  + int _ = 47;
           78  +END
           79  +CASE(4)
           80  + int N = 100000;
           81  + int D = 5;
           82  + int _ = 2879;
           83  +END
           84  +CASE(5)
           85  + int N = 40000;
           86  + int D = 1;
           87  + int _ = 39989;
           88  +END
           89  +CASE(6)
           90  + int N = 10000000;
           91  + int D = 10;
           92  + int _ = -1;
           93  +END
           94  +CASE(7)
           95  + int N = 2;
           96  + int D = 1;
           97  + int _ = 2;
           98  +END
           99  +CASE(7)
          100  + int N = 3;
          101  + int D = 1;
          102  + int _ = 3;
          103  +END
          104  +CASE(7)
          105  + int N = 4;
          106  + int D = 1;
          107  + int _ = 3;
          108  +END
          109  +CASE(7)
          110  + int N = 5;
          111  + int D = 1;
          112  + int _ = 5;
          113  +END
          114  +CASE(7)
          115  + int N = 6;
          116  + int D = 1;
          117  + int _ = 5;
          118  +END
          119  +CASE(7)
          120  + int N = 6;
          121  + int D = 2;
          122  + int _ = 5;
          123  +END
          124  +CASE(7)
          125  + int N = 6;
          126  + int D = 3;
          127  + int _ = -1;
          128  +END
          129  +CASE(7)
          130  + int N = 7;
          131  + int D = 2;
          132  + int _ = 7;
          133  +END
          134  +
          135  +}
          136  +// END CUT HERE

Added SRM/471-U/1B.cpp version [bb11249db9cf179a]

            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 ThirteenHard { public:
           23  + int calcTime(vector <string> city)
           24  + {
           25  +  typedef int vert;
           26  +  typedef int cost;
           27  +  typedef pair<cost,vert> cedge;
           28  +  priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           29  +  Q.push( cedge(0,1*32+0) );
           30  +
           31  +  set<int> visited;
           32  +  while( !Q.empty() )
           33  +  {
           34  +   cedge s = Q.top();
           35  +   Q.pop();
           36  +   if( visited.count(s.second) )
           37  +    continue;
           38  +   visited.insert(s.second);
           39  +
           40  +   int v = s.second%32;
           41  +   int mask = s.second/32;
           42  +   int c = s.first;
           43  +   if( v == (int)city.size()-1 )
           44  +    return c;
           45  +
           46  +   for(int i=0; i<city.size(); ++i)
           47  +   {
           48  +    char dd = city[v][i];
           49  +    int d = ('a'<=dd && dd<='z' ? dd-'a'+27 : dd-'A'+1);
           50  +    if( dd!='#' && d%13>0 )
           51  +    {
           52  +     int mask2 = mask << (d%13);
           53  +     if( mask2 & (1<<13) )
           54  +      continue;
           55  +     mask2 = (mask2 & ((1<<13) - 1)) | (mask2 >> 13) | (1<<d%13);
           56  +     int s2 = mask2*32 + i;
           57  +     if( !visited.count(s2) )
           58  +      Q.push( cedge(c+d, s2) );
           59  +    }
           60  +   }
           61  +  }
           62  +  return -1;
           63  + }
           64  +};
           65  +
           66  +// BEGIN CUT HERE
           67  +#include <ctime>
           68  +double start_time; string timer()
           69  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           70  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           71  + { os << "{ ";
           72  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           73  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           74  +void verify_case(const int& Expected, const int& Received) {
           75  + bool ok = (Expected == Received);
           76  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           77  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           78  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           79  +#define END  verify_case(_, ThirteenHard().calcTime(city));}
           80  +int main(){
           81  +
           82  +CASE(0)
           83  + string city_[] = { "#AB##",
           84  +  "###A#",
           85  +  "###C#",
           86  +  "####K",
           87  +  "#####" };
           88  +   vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_));
           89  + int _ = 16;
           90  +END
           91  +CASE(1)
           92  + string city_[] = { "#Z",
           93  +  "Z#" };
           94  +   vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_));
           95  + int _ = -1;
           96  +END
           97  +CASE(2)
           98  + string city_[] = { "Good#####",
           99  +  "#Luck####",
          100  +  "##and####",
          101  +  "##Have###",
          102  +  "####Fun##",
          103  +  "#####in##",
          104  +  "#####the#",
          105  +  "CHALLENGE",
          106  +  "##PHASE##" };
          107  +   vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_));
          108  + int _ = 137;
          109  +END
          110  +CASE(3)
          111  + string city_[] = { "###No#####",
          112  +  "####Zaphod",
          113  +  "#####Just#",
          114  +  "######very",
          115  +  "####very##",
          116  +  "improbable",
          117  +  "##########",
          118  +  "##########",
          119  +  "##########",
          120  +  "##########" };
          121  +   vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_));
          122  + int _ = 103;
          123  +END
          124  +CASE(4)
          125  + string city_[] = { "#B#C##T#M",
          126  +  "##K######",
          127  +  "########A",
          128  +  "####R####",
          129  +  "#####U###",
          130  +  "########C",
          131  +  "#######H#",
          132  +  "########S",
          133  +  "#########" };
          134  +   vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_));
          135  + int _ = 47;
          136  +END
          137  +CASE(5)
          138  +string city_[] = {"#a","##"};
          139  +   vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_));
          140  + int _ = 27;
          141  +END
          142  +CASE(5)
          143  +string city_[] = {"#z","##"};
          144  +   vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_));
          145  + int _ = -1;
          146  +END
          147  +CASE(6)
          148  +string city_[] = {"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy",
          149  +"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy",
          150  +"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy",
          151  +"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy",
          152  +"abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy","abcdefghijklmnopqrstuvwxy"};
          153  +   vector <string> city(city_, city_+sizeof(city_)/sizeof(*city_));
          154  + int _ = -999;
          155  +END
          156  +
          157  +}
          158  +// END CUT HERE

Added SRM/472-U/1A.cpp version [e239d468ae47778c]

            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 PotatoGame { public:
           23  + string theWinner(int n)
           24  + {
           25  +  return n%5==0 || n%5==2 ? "Hanako" : "Taro";
           26  + }
           27  +};
           28  +
           29  +// BEGIN CUT HERE
           30  +#include <ctime>
           31  +double start_time; string timer()
           32  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           33  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           34  + { os << "{ ";
           35  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           36  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           37  +void verify_case(const string& Expected, const string& Received) {
           38  + bool ok = (Expected == Received);
           39  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           40  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           41  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           42  +#define END  verify_case(_, PotatoGame().theWinner(n));}
           43  +int main(){
           44  +
           45  +CASE(0)
           46  + int n = 1;
           47  + string _ = "Taro";
           48  +END
           49  +CASE(1)
           50  + int n = 2;
           51  + string _ = "Hanako";
           52  +END
           53  +CASE(2)
           54  + int n = 3;
           55  + string _ = "Taro";
           56  +END
           57  +CASE(3)
           58  + int n = 4;
           59  + string _ = "Taro";
           60  +END
           61  +CASE(4)
           62  + int n = 5;
           63  + string _ = "??";
           64  +END
           65  +CASE(6)
           66  + int n = 1000000000;
           67  + string _ = "??";
           68  +END
           69  +CASE(7)
           70  + int n = 8;
           71  + string _ = "Taro";
           72  +END
           73  +
           74  +}
           75  +// END CUT HERE

Added SRM/472-U/1B.cpp version [033d37ff367d441d]

            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  +template<typename T>
           23  +struct DP4
           24  +{
           25  + int N1, N2, N3, N4;
           26  + vector<T> data;
           27  + DP4(int N1, int N2, int N3, int N4, const T& t = T())
           28  +  : N1(N1), N2(N2), N3(N3), N4(N4), data(N1*N2*N3*N4, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           29  + T& operator()(int i1, int i2, int i3, int i4)
           30  +  { return data[ (((i1*N2)+i2)*N3+i3)*N4+i4 ]; }
           31  + void swap(DP4& rhs)
           32  +  { data.swap(rhs.data); }
           33  +};
           34  +
           35  +static const LL MODVAL = 1000000007;
           36  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           37  +LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
           38  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           39  +LL POW(LL x, LL e) {
           40  + LL v = 1;
           41  + for(;e;x=MUL(x,x),e>>=1)
           42  +  if(e&1)
           43  +   v = MUL(v, x);
           44  + return v;
           45  +}
           46  +LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
           47  +LL C(LL n, LL k) {
           48  + k = min(n, n-k);
           49  + LL v = 1;
           50  + for(LL i=1; i<=k; ++i)
           51  +  v = DIV(MUL(v, n-i+1), i);
           52  + return v;
           53  +}
           54  +LL FACT(LL n) {
           55  + return n<=1 ? 1 : MUL(n, FACT(n-1));
           56  +}
           57  +
           58  +class TwoSidedCards { public:
           59  + int theCount(vector <int> taro, vector <int> hanako)
           60  + {
           61  +  int N = taro.size();
           62  +  vector<LL> loops;
           63  +  {
           64  +   vector<int> next(N);
           65  +   for(int i=0; i<N; ++i)
           66  +    next[taro[i]-1] = hanako[i]-1;
           67  +
           68  +   vector<bool> used(N);
           69  +   for(int s=0; s<N; ++s)
           70  +    if( !used[s] ) {
           71  +     used[s] = true;
           72  +
           73  +     LL looplen = 1;
           74  +     for(int v=next[s]; v!=s; v=next[v]) {
           75  +      used[v] = true;
           76  +      ++looplen;
           77  +     }
           78  +     loops.push_back(looplen);
           79  +    }
           80  +  }
           81  +
           82  +  return (int)solve(N, loops);
           83  + }
           84  +
           85  + LL solve(int N, const vector<LL>& loops)
           86  + {
           87  +  LL result = 1;
           88  +
           89  +  LL rest = N;
           90  +  for(int i=0; i<loops.size(); ++i) {
           91  +   result = MUL(result, MUL(singleloop(loops[i]), C(rest,loops[i])));
           92  +   rest -= loops[i];
           93  +  }
           94  +  return result;
           95  + }
           96  +
           97  + map< pair< pair<int,int>,pair<int,int> >, LL > memo;
           98  + LL num_downtrig(int first, int last, int i, int n, int c)
           99  + {
          100  +  if( i == n )
          101  +   return (last==1 && first==0 ? 1 : 0)==c ? 1 : 0;
          102  +  if( c < 0 )
          103  +   return 0;
          104  +  pair< pair<int,int>,pair<int,int> > key( make_pair(first,last), make_pair(i,c) );
          105  +  if( memo.count(key) )
          106  +   return memo[key];
          107  +  return memo[key] = ADD(
          108  +   num_downtrig(first, 0, i+1, n, c-(last==1)),
          109  +   num_downtrig(first, 1, i+1, n, c));
          110  + }
          111  + LL singleloop(int n)
          112  + {
          113  +  if( n == 1 )
          114  +   return 1;
          115  +  LL fn = FACT(n);
          116  +  LL result = 0;
          117  +  memo.clear();
          118  +  for(int c=0; c<n; ++c)
          119  +  {
          120  +   LL z;
          121  +   if( c == 0 )
          122  +    z = num_downtrig(0, 0, 1, n, c);
          123  +   else
          124  +    z = ADD(
          125  +     num_downtrig(0, 0, 1, n, c),
          126  +     num_downtrig(1, 1, 1, n, c));
          127  +   result = ADD(result, DIV(MUL(z,fn), POW(2,c)));
          128  +  }
          129  +  return result;
          130  + }
          131  +};
          132  +
          133  +// BEGIN CUT HERE
          134  +#include <ctime>
          135  +double start_time; string timer()
          136  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          137  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          138  + { os << "{ ";
          139  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          140  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          141  +void verify_case(const int& Expected, const int& Received) {
          142  + bool ok = (Expected == Received);
          143  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          144  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          145  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          146  +#define END  verify_case(_, TwoSidedCards().theCount(taro, hanako));}
          147  +int main(){
          148  +
          149  +CASE(0)
          150  + int taro_[] = {1, 2, 3};
          151  +   vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_));
          152  + int hanako_[] = {1, 3, 2};
          153  +   vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_));
          154  + int _ = 12;
          155  +END
          156  +CASE(1)
          157  + int taro_[] = {1, 2, 3};
          158  +   vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_));
          159  + int hanako_[] = {1, 2, 3};
          160  +   vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_));
          161  + int _ = 6;
          162  +END
          163  +CASE(2)
          164  + int taro_[] = {1, 2};
          165  +   vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_));
          166  + int hanako_[] = {2, 1};
          167  +   vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_));
          168  + int _ = 4;
          169  +END
          170  +CASE(3)
          171  + int taro_[] = {5, 8, 1, 2, 3, 4, 6, 7};
          172  +   vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_));
          173  + int hanako_[] = {1, 2, 3, 4, 5, 6, 7, 8};
          174  +   vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_));
          175  + int _ = 2177280;
          176  +END
          177  +CASE(4)
          178  + int taro_[] = {41, 22, 17, 36, 26, 15, 10, 23, 33, 48, 49, 9, 34, 6, 21, 2, 46, 16, 25, 3, 24, 13, 40, 37, 35,
          179  +50, 44, 42, 31, 12, 29, 7, 43, 18, 30, 19, 45, 32, 39, 14, 8, 27, 1, 5, 38, 11, 4, 20, 47, 28};
          180  +   vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_));
          181  + int hanako_[] = {19, 6, 23, 35, 17, 7, 50, 2, 33, 36, 12, 31, 46, 21, 30, 13, 47, 22, 44, 4, 25, 24, 3, 15, 20,
          182  +48, 10, 28, 26, 18, 5, 45, 49, 16, 40, 42, 43, 14, 1, 37, 29, 8, 41, 38, 9, 11, 34, 32, 39, 27};
          183  +   vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_));
          184  + int _ = 529165844;
          185  +END
          186  +CASE(5)
          187  + int taro_[] = {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,
          188  + 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
          189  +   vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_));
          190  + int hanako_[] = {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,
          191  + 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
          192  +   vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_));
          193  + int _ = -1;
          194  +END
          195  +CASE(6)
          196  +int taro_[] = {1};
          197  +   vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_));
          198  +   int hanako_[] = {1};
          199  +   vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_));
          200  + int _ = 1;
          201  +END
          202  +CASE(7)
          203  + int taro_[] = {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,
          204  + 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
          205  +   vector <int> taro(taro_, taro_+sizeof(taro_)/sizeof(*taro_));
          206  + int hanako_[] = {50,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,
          207  + 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49};
          208  +   vector <int> hanako(hanako_, hanako_+sizeof(hanako_)/sizeof(*hanako_));
          209  + int _ = 1;
          210  +END
          211  +}
          212  +// END CUT HERE

Added SRM/473-U/1A.cpp version [54bf3e40d837f13b]

            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 SequenceOfCommands { public:
           23  + string whatHappens(vector <string> commands)
           24  + {
           25  +  string cmd = accumulate(commands.begin(), commands.end(), string (""));
           26  +  cmd = cmd+cmd+cmd+cmd;
           27  +
           28  +  int dx=1, dy=0;
           29  +  int px=0, py=0;
           30  +  for(int i=0; i<cmd.size(); ++i)
           31  +   if(cmd[i]=='S')
           32  +    {px+=dx, py+=dy;}
           33  +   else if(cmd[i]=='L')
           34  +    {int t=dx; dx=-dy; dy=t;}
           35  +   else if(cmd[i]=='R')
           36  +    {int t=dx; dx=dy; dy=-t;}
           37  +  return (px==0 && py==0 ? "bounded" : "unbounded");
           38  + }
           39  +};
           40  +
           41  +// BEGIN CUT HERE
           42  +#include <ctime>
           43  +double start_time; string timer()
           44  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           45  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           46  + { os << "{ ";
           47  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           48  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           49  +void verify_case(const string& Expected, const string& Received) {
           50  + bool ok = (Expected == Received);
           51  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           52  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           53  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           54  +#define END  verify_case(_, SequenceOfCommands().whatHappens(commands));}
           55  +int main(){
           56  +
           57  +CASE(0)
           58  + string commands_[] = {"L"};
           59  +   vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_));
           60  + string _ = "bounded";
           61  +END
           62  +CASE(1)
           63  + string commands_[] = {"SRSL"};
           64  +   vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_));
           65  + string _ = "unbounded";
           66  +END
           67  +CASE(2)
           68  + string commands_[] = {"SSSS","R"};
           69  +   vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_));
           70  + string _ = "bounded";
           71  +END
           72  +CASE(3)
           73  + string commands_[] = {"SRSL","LLSSSSSSL","SSSSSS","L"};
           74  +   vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_));
           75  + string _ = "unbounded";
           76  +END
           77  +CASE(4)
           78  + string commands_[] = {"SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL","SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSL"};
           79  +   vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_));
           80  + string _ = "bounded";
           81  +END
           82  +CASE(5)
           83  + string commands_[] = {"R"};
           84  +   vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_));
           85  + string _ = "bounded";
           86  +END
           87  +CASE(6)
           88  + string commands_[] = {"S"};
           89  +   vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_));
           90  + string _ = "unbounded";
           91  +END
           92  +CASE(7)
           93  + string commands_[] = {"SRSLSRSL", "RR"};
           94  +   vector <string> commands(commands_, commands_+sizeof(commands_)/sizeof(*commands_));
           95  + string _ = "bounded";
           96  +END
           97  +}
           98  +// END CUT HERE

Added SRM/473-U/1B.cpp version [ad649cfd4e78d396]

            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 RightTriangle { public:
           23  + long long triangleCount(int places, int points, int a, int b, int c)
           24  + {
           25  +  vector<bool> red(places);
           26  +  set<int> vacant;
           27  +  for(int i=0; i<places; ++i)
           28  +   vacant.insert(i);
           29  +
           30  +  for(LL n=0; n<points; ++n) {
           31  +   LL p = (a*n*n + b*n + c) % places;
           32  +   if( red[p] ) {
           33  +    set<int>::iterator it = vacant.lower_bound(p);
           34  +    if( it != vacant.end() )
           35  +     p = *it;
           36  +    else {
           37  +     it = vacant.lower_bound(0);
           38  +     p = *it;
           39  +    }
           40  +   }
           41  +   red[p] = true;
           42  +   vacant.erase(p);
           43  +  }
           44  +
           45  +  if( places%2 == 1 )
           46  +   return 0;
           47  +
           48  +  LL result = 0;
           49  +  for(int a=0,b=a+places/2; b<places; ++a, ++b)
           50  +   if( red[a] && red[b] )
           51  +    result += points-2;
           52  +  return result;
           53  + }
           54  +};
           55  +
           56  +// BEGIN CUT HERE
           57  +#include <ctime>
           58  +double start_time; string timer()
           59  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           60  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           61  + { os << "{ ";
           62  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           63  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           64  +void verify_case(const long long& Expected, const long long& Received) {
           65  + bool ok = (Expected == Received);
           66  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           67  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           68  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           69  +#define END  verify_case(_, RightTriangle().triangleCount(places, points, a, b, c));}
           70  +int main(){
           71  +
           72  +CASE(0)
           73  + int places = 9;
           74  + int points = 3;
           75  + int a = 0;
           76  + int b = 3;
           77  + int c = 0;
           78  + long long _ = 0LL;
           79  +END
           80  +CASE(1)
           81  + int places = 40;
           82  + int points = 3;
           83  + int a = 5;
           84  + int b = 0;
           85  + int c = 0;
           86  + long long _ = 1LL;
           87  +END
           88  +CASE(2)
           89  + int places = 4;
           90  + int points = 4;
           91  + int a = 16;
           92  + int b = 24;
           93  + int c = 17;
           94  + long long _ = 4LL;
           95  +END
           96  +CASE(3)
           97  + int places = 1000000;
           98  + int points = 47000;
           99  + int a = 0;
          100  + int b = 2;
          101  + int c = 5;
          102  + long long _ = 0LL;
          103  +END
          104  +CASE(4)
          105  + int places = 200000;
          106  + int points = 700;
          107  + int a = 123456;
          108  + int b = 789012;
          109  + int c = 345678;
          110  + long long _ = 6980LL;
          111  +END
          112  +CASE(5)
          113  + int places = 1000000;
          114  + int points = 0;
          115  + int a = 0;
          116  + int b = 0;
          117  + int c = 0;
          118  + long long _ = 0LL;
          119  +END
          120  +CASE(6)
          121  + int places = 1000000;
          122  + int points = 100000;
          123  + int a = 0;
          124  + int b = 0;
          125  + int c = 0;
          126  + long long _ = 0LL;
          127  +END
          128  +CASE(7)
          129  + int places = 1;
          130  + int points = 0;
          131  + int a = 1;
          132  + int b = 2;
          133  + int c = 3;
          134  + long long _ = 0LL;
          135  +END
          136  +CASE(8)
          137  + int places = 1;
          138  + int points = 1;
          139  + int a = 3;
          140  + int b = 2;
          141  + int c = 1;
          142  + long long _ = 0LL;
          143  +END
          144  +CASE(9)
          145  + int places = 3;
          146  + int points = 3;
          147  + int a = 1000000;
          148  + int b = 1000000;
          149  + int c = 1000000;
          150  + long long _ = 0LL;
          151  +END
          152  +CASE(9)
          153  + int places = 4;
          154  + int points = 4;
          155  + int a = 1000000;
          156  + int b = 1000000;
          157  + int c = 1000000;
          158  + long long _ = 4LL;
          159  +END
          160  +
          161  +}
          162  +// END CUT HERE

Added SRM/473-U/1C-U.cpp version [35a3e3aba95688f7]

            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 LL MODVAL = 1000000009;
           23  +
           24  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           25  +LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
           26  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           27  +LL POW(LL x, LL e) {
           28  + LL v = 1;
           29  + for(;e;x=MUL(x,x),e>>=1)
           30  +  if(e&1)
           31  +   v = MUL(v, x);
           32  + return v;
           33  +}
           34  +LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
           35  +LL C_impl(LL n, LL k) {
           36  + LL v = 1;
           37  + for(LL i=1; i<=k; ++i)
           38  +  v = DIV(MUL(v, n-i+1), i);
           39  + return v;
           40  +}
           41  +LL C_tbl[40][40];
           42  +LL C(LL n, LL k) {
           43  + if( C_tbl[n][k] < 0 )
           44  +  C_tbl[n][k] = C_impl(n,k);
           45  + return C_tbl[n][k];
           46  +}
           47  +
           48  +class RooksParty { public:
           49  + int countArrangements(int rows, int columns, vector <int> counts)
           50  + {
           51  +  for(int n=0;n<40;++n)
           52  +   for(int k=0;k<40;++k)
           53  +    C_tbl[n][k] = -1;
           54  +  sort(counts.rbegin(), counts.rend());
           55  +  return (int)rec(rows, columns, counts, 0);
           56  + }
           57  + map<pair<pair<int,int>,int>, LL> memo;
           58  + LL rec(int H, int W, vector<int>& counts, int i)
           59  + {
           60  +  if( i == counts.size() )
           61  +   return 1;
           62  +  int n = counts[i];
           63  +  if( H*W < n )
           64  +   return 0;
           65  +
           66  +  if(H>W)
           67  +   swap(H,W);
           68  +
           69  +  pair<pair<int,int>,int> key(make_pair(H,W),i);
           70  +  if( memo.count(key) )
           71  +   return memo[key];
           72  +
           73  +  LL cnt = 0;
           74  +  for(int h=1; h<=min(H,n); ++h)
           75  +   for(int w=1; w<=min(W,n); ++w)
           76  +    if( h*w >= n )
           77  +     cnt = ADD(cnt, MUL(MUL(C(H,h), C(W,w)), MUL(count(h,w,n),rec(H-h,W-w,counts,i+1))));
           78  +  return memo[key] = cnt;
           79  + }
           80  +
           81  + map<pair<pair<int,int>,int>, LL> memo2;
           82  + LL count(int h, int w, int n)
           83  + {
           84  +  if( h*w < n )
           85  +   return 0;
           86  +  pair<pair<int,int>,int> key(make_pair(h,w),n);
           87  +  if(memo2.count(key))
           88  +   return memo2[key];
           89  +  LL cnt = freedom(h,w,n);
           90  +  for(int t=1; t<=w-1; ++t)
           91  +   cnt = SUB(cnt, MUL(count(h,w-t,n),C(w,t)));
           92  +  return memo2[key] = cnt;
           93  + }
           94  +
           95  + map<pair<pair<int,int>,int>, LL> memo3;
           96  + LL freedom(int h, int w, int n)
           97  + {
           98  +  if(h*w<n) return 0;
           99  +  //if(h>n)   return 0;
          100  +  if(h==0)  return 1;
          101  +  pair<pair<int,int>,int> key(make_pair(h,w),n);
          102  +  if(memo3.count(key))
          103  +   return memo3[key];
          104  +
          105  +  LL cnt = 0;
          106  +  for(int t=0; t<=min(n,w); ++t)
          107  +   cnt = ADD(cnt, MUL(freedom(h-1, w, n-t), C(w,t)));
          108  +  return memo3[key]=cnt;
          109  + }
          110  +};
          111  +
          112  +// BEGIN CUT HERE
          113  +#include <ctime>
          114  +double start_time; string timer()
          115  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          116  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          117  + { os << "{ ";
          118  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          119  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          120  +void verify_case(const int& Expected, const int& Received) {
          121  + bool ok = (Expected == Received);
          122  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          123  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          124  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          125  +#define END  verify_case(_, RooksParty().countArrangements(rows, columns, counts));}
          126  +int main(){
          127  +
          128  +CASE(0)
          129  + int rows = 2;
          130  + int columns = 3;
          131  + int counts_[] = {1,1};
          132  +   vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_));
          133  + int _ = 12;
          134  +END
          135  +CASE(1)
          136  + int rows = 5;
          137  + int columns = 2;
          138  + int counts_[] = {3};
          139  +   vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_));
          140  + int _ = 120;
          141  +END
          142  +CASE(2)
          143  + int rows = 5;
          144  + int columns = 2;
          145  + int counts_[] = {1,1,1};
          146  +   vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_));
          147  + int _ = 0;
          148  +END
          149  +CASE(3)
          150  + int rows = 8;
          151  + int columns = 8;
          152  + int counts_[] = {1,1,1,1,1,1,1,1};
          153  +   vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_));
          154  + int _ = 625702391;
          155  +END
          156  +CASE(4)
          157  + int rows = 4;
          158  + int columns = 2;
          159  + int counts_[] = {3,1};
          160  +   vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_));
          161  + int _ = 8;
          162  +END
          163  +/*
          164  +CASE(5)
          165  + int rows = ;
          166  + int columns = ;
          167  + int counts_[] = ;
          168  +   vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_));
          169  + int _ = ;
          170  +END
          171  +CASE(6)
          172  + int rows = ;
          173  + int columns = ;
          174  + int counts_[] = ;
          175  +   vector <int> counts(counts_, counts_+sizeof(counts_)/sizeof(*counts_));
          176  + int _ = ;
          177  +END
          178  +*/
          179  +}
          180  +// END CUT HERE

Added SRM/474/1A.cpp version [6b0f4c18c12a29a4]

            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 RouteIntersection { public:
           23  + string isValid(int N, vector <int> coords, string moves)
           24  + {
           25  +  vector< map<int,int> > route;
           26  +
           27  +  map<int,int> cur;
           28  +  route.push_back(cur);
           29  +  for(int i=0; i<moves.size(); ++i) {
           30  +   int c = coords[i];
           31  +   int m = moves[i]=='+' ? +1 : -1;
           32  +   cur[c] += m;
           33  +   route.push_back(cur);
           34  +  }
           35  +
           36  +  for(int i=0; i<route.size(); ++i)
           37  +   for(int j=i+1; j<route.size(); ++j)
           38  +    if( is_same(route[i], route[j]) )
           39  +     return "NOT VALID";
           40  +  return "VALID";
           41  + }
           42  +
           43  + bool is_same(map<int,int>& a, map<int,int>& b)
           44  + {
           45  +  for(map<int,int>::iterator it=b.begin(); it!=b.end(); ++it)
           46  +   if( a[it->first] != it->second )
           47  +    return false;
           48  +  return true;
           49  + }
           50  +};
           51  +
           52  +// BEGIN CUT HERE
           53  +#include <ctime>
           54  +double start_time; string timer()
           55  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           56  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           57  + { os << "{ ";
           58  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           59  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           60  +void verify_case(const string& Expected, const string& Received) {
           61  + bool ok = (Expected == Received);
           62  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           63  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           64  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           65  +#define END  verify_case(_, RouteIntersection().isValid(N, coords, moves));}
           66  +int main(){
           67  +
           68  +CASE(0)
           69  + int N = 1;
           70  + int coords_[] = {1};
           71  +   vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_));
           72  + string moves = "+";
           73  + string _ = "VALID";
           74  +END
           75  +CASE(1)
           76  + int N = 2;
           77  + int coords_[] = {1,2,1,2};
           78  +   vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_));
           79  + string moves = "++--";
           80  + string _ = "NOT VALID";
           81  +END
           82  +CASE(2)
           83  + int N = 3;
           84  + int coords_[] = {1,2,3,1,2};
           85  +   vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_));
           86  + string moves = "+++--";
           87  + string _ = "VALID";
           88  +END
           89  +CASE(3)
           90  + int N = 344447;
           91  + int coords_[] = {132,51717,628,344447,628,51717,344447,2};
           92  +   vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_));
           93  + string moves = "+-++-+--";
           94  + string _ = "NOT VALID";
           95  +END
           96  +CASE(4)
           97  + int N = 1;
           98  + int coords_[] = {1,1};
           99  +   vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_));
          100  + string moves = "+-";
          101  + string _ = "NOT VALID";
          102  +END
          103  +CASE(5)
          104  + int N = 990630;
          105  + int coords_[] = {833196,524568,361663,108056,28026,824639,269315,440977,440977,765458,
          106  +988451,242440,948414,130873,773990,765458,130873,28026,853121,553636,
          107  +581069,82254,735536,833196,898562,898562,940783,988451,540613,317306,
          108  +623194,940783,571384,988451,108056,514374,97664};
          109  +   vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_));
          110  + string moves = "--+---+-+++-+-+---++-++-+---+-+--+-++";
          111  + string _ = "NOT VALID";
          112  +END
          113  +/*
          114  +CASE(6)
          115  + int N = ;
          116  + int coords_[] = ;
          117  +   vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_));
          118  + string moves = ;
          119  + string _ = ;
          120  +END
          121  +CASE(7)
          122  + int N = ;
          123  + int coords_[] = ;
          124  +   vector <int> coords(coords_, coords_+sizeof(coords_)/sizeof(*coords_));
          125  + string moves = ;
          126  + string _ = ;
          127  +END
          128  +*/
          129  +}
          130  +// END CUT HERE

Added SRM/474/1B.cpp version [96cf85c87151dbba]

            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  +typedef int vert;
           23  +typedef int cost;
           24  +typedef pair<cost,vert> cedge;
           25  +
           26  +bool byVert( const cedge& e1, const cedge& e2 )
           27  +{
           28  + if( e1.second != e2.second )
           29  +  return e1.second < e2.second;
           30  + return e1.first < e2.first;
           31  +}
           32  +
           33  +class TreesCount { public:
           34  + int count(vector <string> graph)
           35  + {
           36  +  LL answer = 1;
           37  +
           38  +  priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           39  +  set<vert> V;
           40  +  Q.push( cedge(0, 0) );
           41  +  while( !Q.empty() )
           42  +  {
           43  +   const cost c0 = Q.top().first;
           44  +
           45  +   vector<cedge> cand;
           46  +   while( !Q.empty() && Q.top().first==c0 ) {
           47  +    if( !V.count(Q.top().second) )
           48  +     cand.push_back( Q.top() );
           49  +    Q.pop();
           50  +   }
           51  +
           52  +   sort( cand.begin(), cand.end(), byVert );
           53  +   for(int i=0; i<cand.size();) {
           54  +    cost c = cand[i].first;
           55  +    vert v = cand[i].second;
           56  +    int j = i;
           57  +    while( j<cand.size() && cand[j].second==v )
           58  +     ++j;
           59  +
           60  +    answer = answer * (j-i) % 1000000007;
           61  +    V.insert(v);
           62  +    for(int u=0; u<graph.size(); ++u)
           63  +     if( graph[v][u]>'0' && !V.count(u) )
           64  +      Q.push( cedge(c+graph[v][u]-'0', u) );
           65  +
           66  +    i = j;
           67  +   }
           68  +  }
           69  +
           70  +  return (int)answer;
           71  + }
           72  +};
           73  +
           74  +// BEGIN CUT HERE
           75  +#include <ctime>
           76  +double start_time; string timer()
           77  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           78  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           79  + { os << "{ ";
           80  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           81  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           82  +void verify_case(const int& Expected, const int& Received) {
           83  + bool ok = (Expected == Received);
           84  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           85  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           86  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           87  +#define END  verify_case(_, TreesCount().count(graph));}
           88  +int main(){
           89  +
           90  +CASE(0)
           91  + string graph_[] = {"01",
           92  + "10"};
           93  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
           94  + int _ = 1;
           95  +END
           96  +CASE(1)
           97  + string graph_[] = {"011",
           98  + "101",
           99  + "110"};
          100  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          101  + int _ = 1;
          102  +END
          103  +CASE(2)
          104  + string graph_[] = {"021",
          105  + "201",
          106  + "110"};
          107  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          108  + int _ = 2;
          109  +END
          110  +CASE(3)
          111  + string graph_[] = {"0123",
          112  + "1012",
          113  + "2101",
          114  + "3210"};
          115  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          116  + int _ = 6;
          117  +END
          118  +CASE(4)
          119  + string graph_[] = {"073542",
          120  + "705141",
          121  + "350721",
          122  + "517031",
          123  + "442304",
          124  + "211140"};
          125  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          126  + int _ = 2;
          127  +END
          128  + /*
          129  +CASE(5)
          130  + string graph_[] = ;
          131  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          132  + int _ = ;
          133  +END
          134  +CASE(6)
          135  + string graph_[] = ;
          136  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          137  + int _ = ;
          138  +END
          139  +*/
          140  +}
          141  +// END CUT HERE

Added SRM/474/1C.cpp version [20f85c4e20ad270e]

            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  +template<typename T>
           23  +struct DP3
           24  +{
           25  + int N1, N2, N3;
           26  + vector<T> data;
           27  + DP3(){}
           28  + DP3(int N1, int N2, int N3, const T& t = T())
           29  +  : N1(N1), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           30  + T& operator()(int i1, int i2, int i3)
           31  +  { return data[ ((i1*N2)+i2)*N3+i3 ]; }
           32  + void swap(DP3& rhs)
           33  +  { data.swap(rhs.data); }
           34  +};
           35  +
           36  +class GameWithGraphAndTree { public:
           37  + vector<string>        graph;
           38  + vector< vector<int> > children;
           39  + vector<int>           subtree_size;
           40  +
           41  + int calc(vector <string> graph_, vector <string> tree_)
           42  + {
           43  +  int N = graph_.size();
           44  +
           45  +  graph = graph_;
           46  +  children.resize(N);
           47  +  subtree_size.resize(N);
           48  +  computeChildren(-1, 0, tree_);
           49  +
           50  +  memo = DP3<LL>(N,N,1<<N,-1);
           51  +
           52  +  LL answer = 0;
           53  +  for(int gv=0; gv<graph.size(); ++gv)
           54  +   answer += vertical(0, gv, (1<<N)-1);
           55  +  return int(answer % 1000000007);
           56  + }
           57  +
           58  + void computeChildren(int tparent, int tv, const vector<string>& tree)
           59  + {
           60  +  subtree_size[tv] = 1;
           61  +  for(int tc=0; tc<tree.size(); ++tc)
           62  +   if( tree[tv][tc] == 'Y' && tc!=tparent ) {
           63  +    children[tv].push_back(tc);
           64  +    computeChildren(tv, tc, tree);
           65  +    subtree_size[tv] += subtree_size[tc];
           66  +   }
           67  + }
           68  +
           69  + LL vertical(int tv, int gv, int mask)
           70  + {
           71  +  return horizontal(tv, gv, mask&~(1<<gv), 0);
           72  + }
           73  +
           74  + DP3<LL> memo;
           75  + LL horizontal(int tv, int gv, int mask, int i)
           76  + {
           77  +  if( i == children[tv].size() )
           78  +   return 1;
           79  +  int tu = children[tv][i];
           80  +
           81  +  if( memo(tv,gv,mask) >= 0 )
           82  +   return memo(tv,gv,mask);
           83  +
           84  +  LL answer = 0;
           85  +  for(int subset=mask; subset; subset=(subset-1)&mask)
           86  +   if( __builtin_popcount(subset) == subtree_size[tu] )
           87  +    for(int gu=0; (1<<gu)<=subset; ++gu)
           88  +     if( graph[gv][gu]=='Y' && ((1<<gu)&subset) )
           89  +      answer += vertical(tu, gu, subset) * horizontal(tv, gv, mask&~subset, i+1);
           90  +
           91  +  return memo(tv,gv,mask) = answer % 1000000007;
           92  + }
           93  +};
           94  +
           95  +// BEGIN CUT HERE
           96  +#include <ctime>
           97  +double start_time; string timer()
           98  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           99  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          100  + { os << "{ ";
          101  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          102  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          103  +void verify_case(const int& Expected, const int& Received) {
          104  + bool ok = (Expected == Received);
          105  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          106  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          107  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          108  +#define END  verify_case(_, GameWithGraphAndTree().calc(graph, tree));}
          109  +int main(){
          110  +
          111  +CASE(0)
          112  + string graph_[] = {"NYN",
          113  + "YNY",
          114  + "NYN"};
          115  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          116  + string tree_[] = {"NYY",
          117  + "YNN",
          118  + "YNN"};
          119  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          120  + int _ = 2;
          121  +END
          122  +CASE(1)
          123  + string graph_[] = {"NYNNN",
          124  + "YNYYY",
          125  + "NYNYY",
          126  + "NYYNY",
          127  + "NYYYN"};
          128  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          129  + string tree_[] = {"NYNNN",
          130  + "YNYNN",
          131  + "NYNYN",
          132  + "NNYNY",
          133  + "NNNYN"};
          134  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          135  + int _ = 12;
          136  +END
          137  +CASE(2)
          138  + string graph_[] = {"NYNNNY",
          139  + "YNYNNN",
          140  + "NYNYNN",
          141  + "NNYNYN",
          142  + "NNNYNY",
          143  + "YNNNYN"};
          144  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          145  + string tree_[] = {"NYNNYN",
          146  + "YNNYNY",
          147  + "NNNNYN",
          148  + "NYNNNN",
          149  + "YNYNNN",
          150  + "NYNNNN"};
          151  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          152  + int _ = 0;
          153  +END
          154  +CASE(3)
          155  + string graph_[] = {"NYNNYN",
          156  + "YNNYNY",
          157  + "NNNNYN",
          158  + "NYNNNN",
          159  + "YNYNNN",
          160  + "NYNNNN"};
          161  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          162  + string tree_[] = {"NNNYYN",
          163  + "NNYNNN",
          164  + "NYNNYY",
          165  + "YNNNNN",
          166  + "YNYNNN",
          167  + "NNYNNN"};
          168  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          169  + int _ = 2;
          170  +END
          171  +CASE(4)
          172  + string graph_[] = {"NYNNNYNNY",
          173  + "YNNNNNNYN",
          174  + "NNNNYYNYY",
          175  + "NNNNNYNNY",
          176  + "NNYNNNYNY",
          177  + "YNYYNNNYN",
          178  + "NNNNYNNYN",
          179  + "NYYNNYYNN",
          180  + "YNYYYNNNN"};
          181  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          182  + string tree_[] = {"NNYNNNYYN",
          183  + "NNNNYNNNN",
          184  + "YNNNNNNNN",
          185  + "NNNNNNYNN",
          186  + "NYNNNNNYY",
          187  + "NNNNNNNNY",
          188  + "YNNYNNNNN",
          189  + "YNNNYNNNN",
          190  + "NNNNYYNNN"};
          191  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          192  + int _ = 90;
          193  +END
          194  +CASE(5)
          195  +string graph_[] = {"N"};
          196  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          197  +   string tree_[] = {"N"};
          198  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          199  + int _ = 1;
          200  +END
          201  +CASE(6)
          202  + string graph_[] = {
          203  + "NYYYYYYYYYYYYY",
          204  + "YNYYYYYYYYYYYY",
          205  + "YYNYYYYYYYYYYY",
          206  + "YYYNYYYYYYYYYY",
          207  + "YYYYNYYYYYYYYY",
          208  + "YYYYYNYYYYYYYY",
          209  + "YYYYYYNYYYYYYY",
          210  + "YYYYYYYNYYYYYY",
          211  + "YYYYYYYYNYYYYY",
          212  + "YYYYYYYYYNYYYY",
          213  + "YYYYYYYYYYNYYY",
          214  + "YYYYYYYYYYYNYY",
          215  + "YYYYYYYYYYYYNY",
          216  + "YYYYYYYYYYYYYN"};
          217  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          218  + string tree_[] = {
          219  +   "NYNNNNNNNNNNNN",
          220  +   "YNYNNNNNNNNNNN",
          221  +   "NYNYNNNNNNNNNN",
          222  +   "NNYNYNNNNNNNNN",
          223  +   "NNNYNYNNNNNNNN",
          224  +   "NNNNYNYNNNNNNN",
          225  +   "NNNNNYNYNNNNNN",
          226  +   "NNNNNNYNYNNNNN",
          227  +   "NNNNNNNYNYNNNN",
          228  +   "NNNNNNNNYNYNNN",
          229  +   "NNNNNNNNNYNYNN",
          230  +   "NNNNNNNNNNYNYN",
          231  +   "NNNNNNNNNNNYNY",
          232  +   "NNNNNNNNNNNNYN",
          233  + };
          234  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          235  + int _ = 178290591;
          236  +END
          237  +CASE(7)
          238  + string graph_[] = {
          239  + "NYYYYYYYYYYYYY",
          240  + "YNYYYYYYYYYYYY",
          241  + "YYNYYYYYYYYYYY",
          242  + "YYYNYYYYYYYYYY",
          243  + "YYYYNYYYYYYYYY",
          244  + "YYYYYNYYYYYYYY",
          245  + "YYYYYYNYYYYYYY",
          246  + "YYYYYYYNYYYYYY",
          247  + "YYYYYYYYNYYYYY",
          248  + "YYYYYYYYYNYYYY",
          249  + "YYYYYYYYYYNYYY",
          250  + "YYYYYYYYYYYNYY",
          251  + "YYYYYYYYYYYYNY",
          252  + "YYYYYYYYYYYYYN"};
          253  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          254  + string tree_[] = {
          255  +   "NYYYNNNNNNNNNN",
          256  +   "YNNNYYYNNNNNNN",
          257  +   "YNNNNNNYYYNNNN",
          258  +   "YNNNNNNNNNYYYY",
          259  +   "NYNNNNNNNNNNNN",
          260  +   "NYNNNNNNNNNNNN",
          261  +   "NYNNNNNNNNNNNN",
          262  +   "NNYNNNNNNNNNNN",
          263  +   "NNYNNNNNNNNNNN",
          264  +   "NNYNNNNNNNNNNN",
          265  +   "NNNYNNNNNNNNNN",
          266  +   "NNNYNNNNNNNNNN",
          267  +   "NNNYNNNNNNNNNN",
          268  +   "NNNYNNNNNNNNNN",
          269  + };
          270  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          271  + int _ = 178290591;
          272  +END
          273  +CASE(8)
          274  + string graph_[] = {"NYYYYYYYYYYYYY", "YNYYYYYYYYYYYY", "YYNYYYYYYYYYYY", "YYYNYYYYYYYYYY", "YYYYNYYYYYYYYY", "YYYYYNYYYYYYYY", "YYYYYYNYYYYYYY", "YYYYYYYNYYYYYY", "YYYYYYYYNYYYYY", "YYYYYYYYYNYYYY", "YYYYYYYYYYNYYY", "YYYYYYYYYYYNYY", "YYYYYYYYYYYYNY", "YYYYYYYYYYYYYN"};
          275  +   vector <string> graph(graph_, graph_+sizeof(graph_)/sizeof(*graph_));
          276  + string tree_[] = {"NYYYYYYYYYYYYY", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN", "YNNNNNNNNNNNNN"};
          277  +   vector <string> tree(tree_, tree_+sizeof(tree_)/sizeof(*tree_));
          278  + int _ = 178290591;
          279  +END
          280  +}
          281  +// END CUT HERE

Added SRM/475-U/1A.cpp version [1b625ac1477fd5f0]

            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  +int bitcnt(int m)
           23  +{
           24  + int c = 0;
           25  + for(;m;m>>=1)
           26  +  c += (m&1);
           27  + return c;
           28  +}
           29  +
           30  +class RabbitStepping { public:
           31  + double getExpected(string field, int r)
           32  + {
           33  +  cerr<<field.size()<<endl;
           34  +  int ex = 0;
           35  +  int cn = 0;
           36  +
           37  +  int N = field.size();
           38  +  for(int mask=1; mask<(1<<N); ++mask)
           39  +   if( bitcnt(mask) == r )
           40  +   {
           41  +    vector< pair<int,int> > rs;
           42  +    for(int i=0; i<N; ++i)
           43  +     if( mask & (1<<i) )
           44  +      rs.push_back(make_pair(-1,i));
           45  +    int left = run(field, rs, N);
           46  +    ex += left;
           47  +    cn += 1;
           48  +   }
           49  +  return double(ex) / cn;
           50  + }
           51  +
           52  + int run(const string& field, vector< pair<int,int> >& rs, int size)
           53  + {
           54  +  while( size > 2 && !rs.empty() )
           55  +  {
           56  +   oneStep(field, rs, size);
           57  +   int cnt[20] = {};
           58  +   for(int i=0; i<rs.size(); ++i)
           59  +    cnt[rs[i].second] ++;
           60  +   vector< pair<int,int> > rs2;
           61  +   for(int i=0; i<rs.size(); ++i)
           62  +    if( cnt[rs[i].second] == 1 )
           63  +     rs2.push_back(rs[i]);
           64  +   rs.swap(rs2);
           65  +  }
           66  +  return rs.size();
           67  + }
           68  +
           69  + void oneStep(const string& field, vector< pair<int,int> >& rs, int& size)
           70  + {
           71  +  for(int i=0; i<rs.size(); ++i) {
           72  +   int prev = rs[i].first;
           73  +   int& cur = rs[i].second;
           74  +   rs[i].first = cur;
           75  +   if( cur == 0 )
           76  +    cur ++;
           77  +   else if( cur >= size-2 )
           78  +    cur --;
           79  +   else if( field[cur]=='W' )
           80  +    cur --;
           81  +   else if( field[cur]=='B' )
           82  +    cur ++;
           83  +   else if( prev == -1 )
           84  +    cur --;
           85  +   else
           86  +    cur = prev;
           87  +  }
           88  +  --size;
           89  + }
           90  +};
           91  +
           92  +// BEGIN CUT HERE
           93  +#include <ctime>
           94  +double start_time; string timer()
           95  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           96  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           97  + { os << "{ ";
           98  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           99  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          100  +void verify_case(const double& Expected, const double& Received) {
          101  + bool ok = (abs(Expected - Received) < 1e-9);
          102  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          103  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          104  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          105  +#define END  verify_case(_, RabbitStepping().getExpected(field, r));}
          106  +int main(){
          107  +
          108  +CASE(0)
          109  + string field = "WRBRW";
          110  + int r = 4;
          111  + double _ = 0.8;
          112  +END
          113  +CASE(1)
          114  + string field = "WWB";
          115  + int r = 2;
          116  + double _ = 1.3333333333333333;
          117  +END
          118  +CASE(2)
          119  + string field = "WW";
          120  + int r = 1;
          121  + double _ = 1.0;
          122  +END
          123  +CASE(3)
          124  + string field = "BBBBBBBBBB";
          125  + int r = 4;
          126  + double _ = 0.9523809523809523;
          127  +END
          128  +CASE(4)
          129  + string field = "RRBRRWRRBRRW";
          130  + int r = 8;
          131  + double _ = 0.9696969696969697;
          132  +END
          133  +CASE(5)
          134  + string field = "RRRRRRRRRRRRRRRRR";
          135  + int r = 8;
          136  + double _ = -1;
          137  +END
          138  +CASE(6)
          139  + string field = "BBBBBBBBBBBBBBBBB";
          140  + int r = 8;
          141  + double _ = -1;
          142  +END
          143  +CASE(7)
          144  + string field = "WWWWWWWWWWWWWWWWW";
          145  + int r = 8;
          146  + double _ = -1;
          147  +END
          148  +CASE(8)
          149  + string field = "BWBWBWBWBWBWBWBWB";
          150  + int r = 8;
          151  + double _ = -1;
          152  +END
          153  +CASE(9)
          154  + string field = "RR";
          155  + int r = 2;
          156  + double _ = 2;
          157  +END
          158  +CASE(9)
          159  + string field = "RR";
          160  + int r = 1;
          161  + double _ = 1;
          162  +END
          163  +CASE(9)
          164  + string field = "BRWWBRBWBWBWBRBWR";
          165  + int r = 1;
          166  + double _ = 1;
          167  +END
          168  +}
          169  +// END CUT HERE

Added SRM/475-U/1B.cpp version [0a3d4549914a8f57]

            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 LL MODVAL = 1000000009; // must fit in 32-bits
           23  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           24  +LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
           25  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           26  +LL POW(LL x, LL e) {
           27  + LL v = 1;
           28  + for(;e;x=MUL(x,x),e>>=1)
           29  +  if(e&1)
           30  +   v = MUL(v, x);
           31  + return v;
           32  +}
           33  +LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
           34  +
           35  +class RabbitIncreasing { public:
           36  + int getNumber(vector <int> leaving, int k)
           37  + {
           38  +  if( leaving.front() <= 1 )
           39  +   return 0;
           40  +  int li = 0;
           41  +
           42  +  LL y[] = {1,0,0};
           43  +  LL p[] = {1,0,0};
           44  +  LL PP = (1LL << 55);
           45  +  for(int i=2; i<=k; ++i)
           46  +  {
           47  +   LL a=y[0], b=y[1], c=y[2];
           48  +   y[0]=y[2]=ADD(b,c); y[1]=a;
           49  +   LL pa=p[0], pb=p[1], pc=p[2];
           50  +   p[0]=p[2]=(pb+pc)%PP; p[1]=pa;
           51  +   if( li<leaving.size() && i==leaving[li] ) {
           52  +    ++li;
           53  +    y[2] = 0;
           54  +    p[2] = 0;
           55  +    if( p[1]&1 ) {
           56  +     y[1]=DIV(SUB(y[1],1),2);
           57  +    } else {
           58  +     y[1]=DIV(y[1],2);
           59  +    }
           60  +    p[1]=p[1]/2;
           61  +    PP >>= 1;
           62  +   }
           63  +  }
           64  +  return ADD(y[0],ADD(y[1],y[2]));
           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) << " msec)"; return os.str(); }
           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 os; }
           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() << endl;
           79  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           80  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           81  +#define END  verify_case(_, RabbitIncreasing().getNumber(leaving, k));}
           82  +int main(){
           83  +
           84  +CASE(0)
           85  + int leaving_[] = { 3 };
           86  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
           87  + int k = 3;
           88  + int _ = 1;
           89  +END
           90  +CASE(1)
           91  + int leaving_[] = { 5, 9 };
           92  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
           93  + int k = 10;
           94  + int _ = 6;
           95  +END
           96  +CASE(2)
           97  + int leaving_[] = { 5, 10, 15 };
           98  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
           99  + int k = 19;
          100  + int _ = 212;
          101  +END
          102  +CASE(3)
          103  + int leaving_[] = { 2 };
          104  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
          105  + int k = 10000000;
          106  + int _ = 0;
          107  +END
          108  +CASE(4)
          109  + int leaving_[] = { 195, 211, 227, 230, 260,
          110  +  297, 346, 350, 403, 411,
          111  +  428, 485, 594, 606, 876 }
          112  +;
          113  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
          114  + int k = 1000;
          115  + int _ = 975206486;
          116  +END
          117  +CASE(5)
          118  +int leaving_[] = {2};
          119  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
          120  + int k = 1;
          121  + int _ = 1;
          122  +END
          123  +CASE(5)
          124  +int leaving_[] = {2};
          125  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
          126  + int k = 2;
          127  + int _ = 0;
          128  +END
          129  +CASE(5)
          130  +int leaving_[] = {1};
          131  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
          132  + int k = 1;
          133  + int _ = 0;
          134  +END
          135  +CASE(6)
          136  + int leaving_[] = {999};
          137  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
          138  + int k = 10000000;
          139  + int _ = 536491299;
          140  +END
          141  +CASE(7)
          142  + int leaving_[] = {
          143  + 100,200,300,400,500,600,700,800,900,1000,
          144  + 1100,1200,1300,1400,1500,1600,1700,1800,1900,2000,
          145  + 3100,3200,3300,3400,3500,3600,3700,3800,3900,31000,
          146  + 43100,43200,43300,43400,43500,43600,43700,43800,43900,431000,
          147  + 999100,999200,999300,999400,999500,999600,999700,999800,999900,9991000,
          148  +};
          149  +   vector <int> leaving(leaving_, leaving_+sizeof(leaving_)/sizeof(*leaving_));
          150  + int k = 10000000;
          151  + int _ = 260357174;
          152  +END
          153  +}
          154  +// END CUT HERE

Added SRM/476-U/1A.cpp version [e10f449b73402d2c]

            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 Badgers { public:
           23  + int feedMost(vector <int> hunger, vector <int> greed, int totalFood)
           24  + {
           25  +  for(int m=hunger.size(); m>0; --m)
           26  +   if( can(m, hunger, greed, totalFood) )
           27  +    return m;
           28  +  return 0;
           29  + }
           30  + bool can(int m, vector<int> h, const vector<int>& g, int totalFood)
           31  + {
           32  +  for(int i=0; i<h.size(); ++i)
           33  +   h[i] += g[i]*(m-1);
           34  +  sort(h.begin(), h.end());
           35  +  return accumulate(h.begin(), h.begin()+m, 0) <= totalFood;
           36  + }
           37  +};
           38  +
           39  +// BEGIN CUT HERE
           40  +#include <ctime>
           41  +double start_time; string timer()
           42  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           43  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           44  + { os << "{ ";
           45  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           46  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           47  +void verify_case(const int& Expected, const int& Received) {
           48  + bool ok = (Expected == Received);
           49  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           50  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           51  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           52  +#define END  verify_case(_, Badgers().feedMost(hunger, greed, totalFood));}
           53  +int main(){
           54  +
           55  +CASE(0)
           56  + int hunger_[] = {1,2,3};
           57  +   vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_));
           58  + int greed_[] = {2,2,1};
           59  +   vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_));
           60  + int totalFood = 7;
           61  + int _ = 2;
           62  +END
           63  +CASE(1)
           64  + int hunger_[] = {5,2,1,5};
           65  +   vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_));
           66  + int greed_[] = {0,2,4,1};
           67  +   vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_));
           68  + int totalFood = 19;
           69  + int _ = 3;
           70  +END
           71  +CASE(2)
           72  + int hunger_[] = {1,1,1,1,1};
           73  +   vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_));
           74  + int greed_[] = {1000,1000,1000,1000,1000};
           75  +   vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_));
           76  + int totalFood = 10;
           77  + int _ = 1;
           78  +END
           79  +CASE(3)
           80  + int hunger_[] = {1,2,3,4,5,6,7,8,9,10};
           81  +   vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_));
           82  + int greed_[] = {10,9,8,7,6,5,4,3,2,1};
           83  +   vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_));
           84  + int totalFood = 100;
           85  + int _ = 5;
           86  +END
           87  +CASE(4)
           88  + int hunger_[] = {2};
           89  +   vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_));
           90  +   int greed_[] = {0};
           91  +   vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_));
           92  +   int totalFood = {1};
           93  +   int _ = 0;
           94  +END
           95  +CASE(4)
           96  + int hunger_[] = {2};
           97  +   vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_));
           98  +   int greed_[] = {0};
           99  +   vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_));
          100  +   int totalFood = {2};
          101  +   int _ = 1;
          102  +END
          103  +CASE(4)
          104  + int hunger_[] = {2};
          105  +   vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_));
          106  +   int greed_[] = {0};
          107  +   vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_));
          108  +   int totalFood = {1000000};
          109  +   int _ = 1;
          110  +END
          111  +CASE(5)
          112  +int hunger_[] = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10};
          113  +   vector <int> hunger(hunger_, hunger_+sizeof(hunger_)/sizeof(*hunger_));
          114  +   int greed_[] = {100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100};
          115  +   vector <int> greed(greed_, greed_+sizeof(greed_)/sizeof(*greed_));
          116  + int totalFood = 10000;
          117  + int _ = -1;
          118  +END
          119  +
          120  +}
          121  +// END CUT HERE

Added SRM/476-U/1B.cpp version [98c2d671691b0a48]

            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  +template<typename T>
           23  +struct DP2
           24  +{
           25  + int N1, N2;
           26  + vector<T> data;
           27  + DP2(){}
           28  + DP2(int N1, int N2, const T& t = T())
           29  +  : N1(N1), N2(N2), data(N1*N2, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           30  + T& operator()(int i1, int i2)
           31  +  { return data[ (i1*N2)+i2 ]; }
           32  + void swap(DP2& rhs)
           33  +  { data.swap(rhs.data); }
           34  +};
           35  +
           36  +class FriendTour { public:
           37  + double tourProbability(vector <string> friends, int K)
           38  + {
           39  +  int N = (int)friends.size();
           40  +  vector< vector<int> > f(N);
           41  +  for(int i=0; i<N; ++i)
           42  +  {
           43  +   stringstream sin( friends[i] );
           44  +   for(int v; sin>>v; )
           45  +    f[i].push_back(v-1);
           46  +  }
           47  +
           48  +  map<int,int> rename;
           49  +  rename[0] = 0;
           50  +  for(int k=0; k<f[0].size(); ++k)
           51  +  {
           52  +   int newid = rename.size();
           53  +   rename[f[0][k]] = newid;
           54  +  }
           55  +
           56  +  vector< vector<int> > ff(rename.size());
           57  +  for(int i=0; i<N; ++i)
           58  +   if( rename.count(i) )
           59  +   {
           60  +    int k = rename[i];
           61  +    for(int j=0; j<f[i].size(); ++j)
           62  +     if( f[i][j]!=0 && rename.count(f[i][j]) )
           63  +      ff[k].push_back( rename[f[i][j]] );
           64  +     else
           65  +      ff[k].push_back( -1 );
           66  +   }
           67  +  return solve(ff, K);
           68  + }
           69  +
           70  + double solve(vector<vector<int> >& f, int K)
           71  + {
           72  +  memo = DP2<double>(f.size(), 1<<f.size(), -1);
           73  +  return rec(f, K, 0, 1);
           74  + }
           75  +
           76  + double C(int N, int K)
           77  + {
           78  +  double p = 1.0;
           79  +  for(int i=0; i<min(K,N-K); ++i)
           80  +   p = p * (N-i) / (1+i);
           81  +  return p;
           82  + }
           83  +
           84  + DP2<double> memo;
           85  + double rec(vector<vector<int> >& f, int K, int v, int mask)
           86  + {
           87  +  if( memo(v,mask) != -1 )
           88  +   return memo(v,mask);
           89  +
           90  +  if( mask == (1<<f.size())-1 )
           91  +   return 1.0;
           92  +
           93  +  vector<double> nxt;
           94  +  for(int i=0; i<f[v].size(); ++i)
           95  +   if( f[v][i]==-1 || (mask & (1<<f[v][i])) )
           96  +    nxt.push_back(0);
           97  +   else
           98  +    nxt.push_back( rec(f,K,f[v][i],mask|(1<<f[v][i])) );
           99  +  sort(nxt.rbegin(), nxt.rend());
          100  +  int N = nxt.size();
          101  +  if( N == 0 )
          102  +   return memo(v,mask) = 0.0;
          103  +
          104  +  if( N <= K )
          105  +   return memo(v,mask) = nxt[0];
          106  +
          107  +  double p = 0.0;
          108  +  for(int i=0; i<nxt.size(); ++i) {
          109  +   if( N-1-i < K ) {
          110  +    p += C(N-i,K) / C(N,K) * nxt[i];
          111  +    break;
          112  +   }
          113  +   p += (C(N-i,K) - C(N-1-i,K)) / C(N,K) * nxt[i];
          114  +  }
          115  +  return memo(v,mask) = p;
          116  + }
          117  +};
          118  +
          119  +// BEGIN CUT HERE
          120  +#include <ctime>
          121  +double start_time; string timer()
          122  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          123  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          124  + { os << "{ ";
          125  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          126  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          127  +void verify_case(const double& Expected, const double& Received) {
          128  + bool ok = (abs(Expected - Received) < 1e-9);
          129  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          130  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          131  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          132  +#define END  verify_case(_, FriendTour().tourProbability(friends, K));}
          133  +int main(){
          134  +
          135  +CASE(0)
          136  + string friends_[] = {"2 3 4",
          137  + "1 3 4",
          138  + "1 2 4",
          139  + "1 2 3"};
          140  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          141  + int K = 1;
          142  + double _ = 0.2222222222222222;
          143  +END
          144  +CASE(1)
          145  + string friends_[] = {"2 3 4",
          146  + "1 3 4",
          147  + "1 2 4",
          148  + "1 2 3"};
          149  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          150  + int K = 2;
          151  + double _ = 0.6666666666666666;
          152  +END
          153  +CASE(2)
          154  + string friends_[] = {"3 2 4",
          155  + "3 5 1",
          156  + "5 2 1 4",
          157  + "3 1 5",
          158  + "3 2 4"};
          159  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          160  + int K = 2;
          161  + double _ = 0.3333333333333333;
          162  +END
          163  +CASE(3)
          164  + string friends_[] = {"3 2 4",
          165  + "3 5 1",
          166  + "5 2 1 4",
          167  + "3 1 5 6",
          168  + "3 2 4",
          169  + "4"}
          170  +;
          171  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          172  + int K = 2;
          173  + double _ = 0.3055555555555556;
          174  +END
          175  +CASE(4)
          176  + string friends_[] = {"6 5 4 2",
          177  + "1 6 3 5",
          178  + "5 4 2",
          179  + "3 1 5",
          180  + "2 4 3 1 6",
          181  + "1 2 5"};
          182  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          183  + int K = 3;
          184  + double _ = 0.73125;
          185  +END
          186  +CASE(5)
          187  + string friends_[] = {"2 3 4 5 6 7 8 9 10 11 12 13 14 15 16", "1 3 4 5 6 7 8 9 10 11 12 13 14 15 16", "1 2 4 5 6 7 8 9 10 11 12 13 14 15 16", "1 2 3 5 6 7 8 9 10 11 12 13 14 15 16", "1 2 3 4 6 7 8 9 10 11 12 13 14 15 16", "1 2 3 4 5 7 8 9 10 11 12 13 14 15 16", "1 2 3 4 5 6 8 9 10 11 12 13 14 15 16", "1 2 3 4 5 6 7 9 10 11 12 13 14 15 16", "1 2 3 4 5 6 7 8 10 11 12 13 14 15 16", "1 2 3 4 5 6 7 8 9 11 12 13 14 15 16", "1 2 3 4 5 6 7 8 9 10 12 13 14 15 16", "1 2 3 4 5 6 7 8 9 10 11 13 14 15 16", "1 2 3 4 5 6 7 8 9 10 11 12 14 15 16", "1 2 3 4 5 6 7 8 9 10 11 12 13 15 16", "1 2 3 4 5 6 7 8 9 10 11 12 13 14 16", "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15"};
          188  +   vector <string> friends(friends_, friends_+sizeof(friends_)/sizeof(*friends_));
          189  + int K = 3;
          190  + double _ = 0.010989546288518458;
          191  +END
          192  +}
          193  +// END CUT HERE

Added SRM/476-U/1C-U.cpp version [c81f1fbeaeaef3fd]

            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 SpaceshipEvacuation { public:
           23  + int additionalCabins(int N, vector <string> tunnelNetwork, int crewSize)
           24  + {
           25  +
           26  + }
           27  +};
           28  +
           29  +// BEGIN CUT HERE
           30  +#include <ctime>
           31  +double start_time; string timer()
           32  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           33  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           34  + { os << "{ ";
           35  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           36  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           37  +void verify_case(const int& Expected, const int& Received) {
           38  + bool ok = (Expected == Received);
           39  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           40  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           41  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           42  +#define END  verify_case(_, SpaceshipEvacuation().additionalCabins(N, tunnelNetwork, crewSize));}
           43  +int main(){
           44  +
           45  +CASE(0)
           46  + int N = 3;
           47  + string tunnelNetwork_[] = {"0 1 5 3",
           48  + "2 1 0 0"};
           49  +   vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_));
           50  + int crewSize = 5;
           51  + int _ = 7;
           52  +END
           53  +CASE(1)
           54  + int N = 3;
           55  + string tunnelNetwork_[] = {"0 1 0 2",
           56  + "0 2 0 4"};
           57  +   vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_));
           58  + int crewSize = 5;
           59  + int _ = 4;
           60  +END
           61  +CASE(2)
           62  + int N = 4;
           63  + string tunnelNetwork_[] = {"0 1 0 6",
           64  + "3 2 3 1",
           65  + "2 1 0 1",
           66  + "3 1 2 2"};
           67  +   vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_));
           68  + int crewSize = 6;
           69  + int _ = 6;
           70  +END
           71  +CASE(3)
           72  + int N = 10;
           73  + string tunnelNetwork_[] = {"0 1 11 101",
           74  + "1 2 0 100",
           75  + "2 3 20 100",
           76  + "3 4 0 107",
           77  + "4 1 66 0",
           78  + "3 5 104 2",
           79  + "4 6 82 0",
           80  + "5 7 25 25",
           81  + "7 8 14 42",
           82  + "8 9 0 94",
           83  + "9 5 17 92"};
           84  +   vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_));
           85  + int crewSize = 110;
           86  + int _ = 376;
           87  +END
           88  +CASE(4)
           89  + int N = 3;
           90  + string tunnelNetwork_[] = {"0 1 0 0"};
           91  +   vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_));
           92  + int crewSize = 1;
           93  + int _ = -1;
           94  +END
           95  +CASE(5)
           96  + int N = ;
           97  + string tunnelNetwork_[] = ;
           98  +   vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_));
           99  + int crewSize = ;
          100  + int _ = ;
          101  +END
          102  +CASE(6)
          103  + int N = ;
          104  + string tunnelNetwork_[] = ;
          105  +   vector <string> tunnelNetwork(tunnelNetwork_, tunnelNetwork_+sizeof(tunnelNetwork_)/sizeof(*tunnelNetwork_));
          106  + int crewSize = ;
          107  + int _ = ;
          108  +END
          109  +
          110  +}
          111  +// END CUT HERE

Added SRM/478-U/1A.cpp version [b7f0b3a8ec812310]

            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 LL MODVAL =  1000000007;
           23  +class CarrotJumping { public:
           24  + int theJump(int init)
           25  + {
           26  +  LL x = (init+1) % MODVAL;
           27  +  int i = 2;
           28  +  x = (x*4) % MODVAL;
           29  +  while(i < 1000000){
           30  +   if( x == 1 ) {
           31  +    int z = i/3 + (i%3 ? 1 : 0);
           32  +    return z>100000 ? -1 : z;
           33  +   }
           34  +   i++;
           35  +   x = (x*2)% MODVAL;
           36  +  }
           37  +  return -1;
           38  + }
           39  +};
           40  +
           41  +// BEGIN CUT HERE
           42  +#include <ctime>
           43  +double start_time; string timer()
           44  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           45  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           46  + { os << "{ ";
           47  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           48  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           49  +void verify_case(const int& Expected, const int& Received) {
           50  + bool ok = (Expected == Received);
           51  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           52  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           53  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           54  +#define END  verify_case(_, CarrotJumping().theJump(init));}
           55  +int main(){
           56  +
           57  +CASE(0)
           58  + int init = 125000000;
           59  + int _ = 1;
           60  +END
           61  +CASE(1)
           62  + int init = 281250001;
           63  + int _ = 2;
           64  +END
           65  +CASE(2)
           66  + int init = 18426114;
           67  + int _ = 58;
           68  +END
           69  +CASE(3)
           70  + int init = 4530664;
           71  + int _ = 478;
           72  +END
           73  +CASE(4)
           74  + int init = 705616876;
           75  + int _ = 100000;
           76  +END
           77  +CASE(5)
           78  + int init = 852808441;
           79  + int _ = -1;
           80  +END
           81  +CASE(6)
           82  + int init = 1;
           83  + int _ = -2;
           84  +END
           85  +CASE(7)
           86  + int init = 1000000006;
           87  + int _ = -2;
           88  +END
           89  +
           90  +}
           91  +// END CUT HERE

Added SRM/478-U/1B.cpp version [3cbbfe4224f260a7]

            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 KiwiJuice { public:
           23  + int theProfit(int C, vector <int> bottles, vector <int> prices)
           24  + {
           25  +  best.clear();
           26  +  best.resize(1<<bottles.size(), -1);
           27  +  return rec((1<<bottles.size())-1, C, bottles, prices);
           28  + }
           29  +
           30  + vector<int> best;
           31  + int rec(int mask, int C, vector<int>& B, const vector<int>& P)
           32  + {
           33  +  if( mask == 0 )
           34  +   return 0;
           35  +  if( best[mask] != -1 )
           36  +   return best[mask];
           37  +  int maxSc = 0;
           38  +  for(int subset=mask; subset; subset=((subset-1)&mask)) {
           39  +   int sum = 0;
           40  +   int bin = 0;
           41  +   for(int i=0; i<B.size(); ++i)
           42  +    if( subset & (1<<i) ) {
           43  +     sum += B[i];
           44  +     bin += 1;
           45  +    }
           46  +   int sc = P[C] * (sum/C);
           47  +   if(sum%C) sc += P[sum%C];
           48  +   sc += P[0] *  (bin-((sum/C)+(sum%C?1:0)));
           49  +   sc += rec(mask&~subset, C, B, P);
           50  +   maxSc = max(maxSc, sc);
           51  +  }
           52  +  return best[mask] = maxSc;
           53  + }
           54  +};
           55  +
           56  +// BEGIN CUT HERE
           57  +#include <ctime>
           58  +double start_time; string timer()
           59  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           60  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           61  + { os << "{ ";
           62  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           63  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           64  +void verify_case(const int& Expected, const int& Received) {
           65  + bool ok = (Expected == Received);
           66  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           67  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           68  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           69  +#define END  verify_case(_, KiwiJuice().theProfit(C, bottles, prices));}
           70  +int main(){
           71  +
           72  +CASE(0)
           73  + int C = 10;
           74  + int bottles_[] = {5, 8};
           75  +   vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_));
           76  + int prices_[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10};
           77  +   vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_));
           78  + int _ = 10;
           79  +END
           80  +CASE(1)
           81  + int C = 10;
           82  + int bottles_[] = {5, 8};
           83  +   vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_));
           84  + int prices_[] = {0, 0, 0, 0, 0, 10, 10, 10, 10, 10, 10};
           85  +   vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_));
           86  + int _ = 20;
           87  +END
           88  +CASE(2)
           89  + int C = 10;
           90  + int bottles_[] = {4, 5, 3, 7};
           91  +   vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_));
           92  + int prices_[] = {14, 76, 12, 35, 6, 94, 26, 3, 93, 90, 420};
           93  +   vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_));
           94  + int _ = 625;
           95  +END
           96  +CASE(3)
           97  + int C = 1;
           98  + int bottles_[] = {0};
           99  +   vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_));
          100  + int prices_[] = {1000000, 1000000};
          101  +   vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_));
          102  + int _ = 1000000;
          103  +END
          104  +CASE(4)
          105  + int C = 49;
          106  + int bottles_[] = {2, 47, 24, 14, 0, 32, 9, 12, 31, 46, 39, 12, 16, 22, 29};
          107  +   vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_));
          108  + int prices_[] = {428668, 995687, 128567, 37241, 496916, 238624, 304781, 997819, 85856, 417008,
          109  +398570, 951499, 750349, 333625, 927594, 188616, 942498, 259414, 654344, 354809,
          110  +25303, 226854, 98578, 207140, 305527, 358343, 393213, 256248, 282644, 103327,
          111  +667191, 103402, 609183, 619323, 189127, 518006, 778846, 400460, 128334, 795097,
          112  +605203, 669142, 121825, 934404, 837430, 554265, 610818, 546228, 80784, 949440};
          113  +   vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_));
          114  + int _ = 12873962;
          115  +END
          116  +CASE(5)
          117  + int C = 10;
          118  + int bottles_[] = {2,3,5};
          119  +   vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_));
          120  +   int prices_[] = {0,0,9,9,0,9,0,0,0,0,99};
          121  +   vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_));
          122  + int _ = 99;
          123  +END
          124  +/*
          125  +CASE(6)
          126  + int C = ;
          127  + int bottles_[] = ;
          128  +   vector <int> bottles(bottles_, bottles_+sizeof(bottles_)/sizeof(*bottles_));
          129  + int prices_[] = ;
          130  +   vector <int> prices(prices_, prices_+sizeof(prices_)/sizeof(*prices_));
          131  + int _ = ;
          132  +END
          133  +*/
          134  +}
          135  +// END CUT HERE

Added SRM/479-U/1A-U.cpp version [816649b6f120c38e]

            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 TheCoffeeTimeDivOne { public:
           23  + long long find(int ____n, vector <int> tea)
           24  + {
           25  +  sort(tea.begin(), tea.end());
           26  +
           27  +  LL n = ____n;
           28  +  LL t = n*4 + 47LL*((tea.size()+6)/7) + 47LL*((n-tea.size()+6)/7);
           29  +
           30  +  for(int tp=tea.size()-1; tp>=0; )
           31  +  {
           32  +   t  += tea[tp]*2;
           33  +   tp -= 7;
           34  +  }
           35  +
           36  +  if( n > tea.size() )
           37  +  {
           38  +   LL s = (n-tea.size()) % 7;
           39  +   if(s==0) s = 7;
           40  +   for(int tp=0; s<=n; s+=7)
           41  +   {
           42  +    while(tp<tea.size() && tea[tp]<=s)
           43  +     ++s, ++tp;
           44  +    t += 2*s;
           45  +   }
           46  +  }
           47  +  return t;
           48  + }
           49  +};
           50  +
           51  +// BEGIN CUT HERE
           52  +#include <ctime>
           53  +double start_time; string timer()
           54  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           55  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           56  + { os << "{ ";
           57  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           58  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           59  +void verify_case(const long long& Expected, const long long& Received) {
           60  + bool ok = (Expected == Received);
           61  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           62  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           63  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           64  +#define END  verify_case(_, TheCoffeeTimeDivOne().find(n, tea));}
           65  +int main(){
           66  +
           67  +CASE(0)
           68  + int n = 2;
           69  + int tea_[] = {1};
           70  +   vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_));
           71  + long long _ = 108LL;
           72  +END
           73  +CASE(1)
           74  + int n = 2;
           75  + int tea_[] = {2, 1};
           76  +   vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_));
           77  + long long _ = 59LL;
           78  +END
           79  +CASE(2)
           80  + int n = 15;
           81  + int tea_[] = {1, 2, 3, 4, 5, 6, 7};
           82  +   vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_));
           83  + long long _ = 261LL;
           84  +END
           85  +CASE(3)
           86  + int n = 47;
           87  + int tea_[] = {1, 10, 6, 2, 4};
           88  +   vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_));
           89  + long long _ = 891LL;
           90  +END
           91  +CASE(4)
           92  + int n = 44777777;
           93  + int tea_[] = {1,2,4,8,16,32,64,128,1000,2000,3000,4000,5000,6000,7000,8000,9000};
           94  +   vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_));
           95  + long long _ = -1LL;
           96  +END
           97  +/*
           98  +CASE(5)
           99  + int n = ;
          100  + int tea_[] = ;
          101  +   vector <int> tea(tea_, tea_+sizeof(tea_)/sizeof(*tea_));
          102  + long long _ = LL;
          103  +END
          104  +*/
          105  +}
          106  +// END CUT HERE

Added SRM/479-U/1B.cpp version [5d5ec3acb844c5c9]

            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 TheAirTripDivOne { public:
           23  + struct edge {
           24  +  int to;
           25  +  LL F, T, P;
           26  + };
           27  + int find(int n, vector <string> flights, int time)
           28  + {
           29  +  vector< vector<edge> > e(n);
           30  +  {
           31  +   string input = accumulate(flights.begin(), flights.end(), string(""));
           32  +   stringstream sin(input);
           33  +   for(string line; sin>>line;) {
           34  +    stringstream sin(line);
           35  +    int a,b; LL f,t,p; char _;
           36  +    sin >> a >> _ >> b >> _ >> f >> _ >> t >> _ >> p;
           37  +    edge eg = {b-1,f,t,p};
           38  +    e[a-1].push_back(eg);
           39  +   }
           40  +  }
           41  +
           42  +  int lf=0, ri=1000000001;
           43  +  while( ri-lf>1 )
           44  +  {
           45  +   int c = (lf+ri)/2;
           46  +   (ok(n,e,c,time) ? lf : ri) = c;
           47  +  }
           48  +  return lf ? lf : -1;
           49  + }
           50  + bool ok(int n, vector< vector<edge> >& e, LL transfer, LL TL)
           51  + {
           52  +  typedef int vert;
           53  +  typedef LL cost;
           54  +  typedef pair<cost,int> cedge;
           55  +  priority_queue<cedge, vector<cedge>, greater<cedge> > Q;
           56  +  set<vert> V;
           57  +  Q.push( cedge(0,0) );
           58  +  while( !Q.empty() )
           59  +  {
           60  +   cost c = Q.top().first;
           61  +   vert v = Q.top().second;
           62  +   Q.pop();
           63  +   if( V.count(v) )
           64  +    continue;
           65  +   if( v == n-1 )
           66  +    return true;
           67  +   V.insert(v);
           68  +   vector<edge>& ne = e[v];
           69  +   for(int i=0; i<ne.size(); ++i)
           70  +   {
           71  +    vert u = ne[i].to;
           72  +    LL F=ne[i].F, T=ne[i].T, P=ne[i].P;
           73  +    LL t = nextTime(c, F, P, v==0 ? 0 : transfer);
           74  +//    cerr<<c<<" "<<F<<" "<<P<<" "<<transfer<<" !! "<<t<<endl;
           75  +    if( !V.count(u) && t+T<=TL )
           76  +     Q.push( cedge(t+T, u) );
           77  +   }
           78  +  }
           79  +  return false;
           80  + }
           81  +
           82  + LL nextTime(LL cur, LL F, LL P, LL transfer)
           83  + {
           84  +  cur += transfer;
           85  +  if( cur <= F )
           86  +   return F;
           87  +  return (cur-F)%P==0 ? cur : ((cur-F)/P+1)*P+F;
           88  + }
           89  +};
           90  +
           91  +// BEGIN CUT HERE
           92  +#include <ctime>
           93  +double start_time; string timer()
           94  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           95  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           96  + { os << "{ ";
           97  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           98  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           99  +void verify_case(const int& Expected, const int& Received) {
          100  + bool ok = (Expected == Received);
          101  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          102  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          103  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          104  +#define END  verify_case(_, TheAirTripDivOne().find(n, flights, time));}
          105  +int main(){
          106  +
          107  +CASE(0)
          108  + int n = 3;
          109  + string flights_[] = {"1,2,1,4,7 ", "2,3,9,1,10"};
          110  +   vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
          111  + int time = 20;
          112  + int _ = 14;
          113  +END
          114  +CASE(1)
          115  + int n = 3;
          116  + string flights_[] = {"1,2,1,1,1 2,3,2,1,98"};
          117  +   vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
          118  + int time = 100;
          119  + int _ = -1;
          120  +END
          121  +CASE(2)
          122  + int n = 477;
          123  + string flights_[] = {"47,74,1,1,1"};
          124  +   vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
          125  + int time = 20;
          126  + int _ = -1;
          127  +END
          128  +CASE(3)
          129  + int n = 7;
          130  + string flights_[] = {"1,3,15,17,11 1,3,14,16,14 5,7,12,18,18 1,6,13,1",
          131  + "6,12 1,2,18,14,13 5,6,10,10,18 3,1,10,10,10 1,3",
          132  + ",17,16,10 2,3,16,18,16 6,1,15,12,10 2,1,15,18,1",
          133  + "0 4,7,10,16,15 6,3,10,14,10 1,6,19,19,15 1,4,12",
          134  + ",10,14 4,7,10,18,14 2,3,16,12,12 1,3,14,10,19 3",
          135  + ",7,17,10,12 2,1,14,12,16 4,3,19,11,12 1,6,10,18",
          136  + ",12 2,3,16,12,10 6,2,10,18,12 5,1,14,18,12 5,1,",
          137  + "18,10,10 3,2,19,15,10 7,4,16,19,14 6,3,16,12,10",
          138  + " 5,7,14,13,13 1,3,12,10,16 5,7,16,18,15 6,2,18,",
          139  + "12,14 3,2,10,18,16 4,2,18,18,14 1,5,10,18,16 2,",
          140  + "3,10,19,16 1,4,11,18,15 2,1,15,15,14 7,2,10,12,",
          141  + "10"};
          142  +   vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
          143  + int time = 74;
          144  + int _ = 33;
          145  +END
          146  +CASE(4)
          147  + int n = 7;
          148  + string flights_[] = {"1,4,10,8,2 4,6,14,8,2 6,2,8,1",
          149  + "0,1 2,7,19,5,1 ",
          150  + "1,5,15,17,11 5,3,10,1",
          151  + "0,18 3,7,12,18,18"};
          152  +   vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
          153  + int time = 147;
          154  + int _ = 35;
          155  +END
          156  + /*
          157  +CASE(5)
          158  + int n = ;
          159  + string flights_[] = ;
          160  +   vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
          161  + int time = ;
          162  + int _ = ;
          163  +END
          164  +CASE(6)
          165  + int n = ;
          166  + string flights_[] = ;
          167  +   vector <string> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
          168  + int time = ;
          169  + int _ = ;
          170  +END
          171  +*/
          172  +}
          173  +// END CUT HERE

Added SRM/479-U/2A.cpp version [569c7cb5f3c676ef]

            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 TheAirTripDivTwo { public:
           23  + int find(vector <int> flights, int fuel)
           24  + {
           25  +  partial_sum(flights.begin(), flights.end(), flights.begin());
           26  +  return upper_bound(flights.begin(), flights.end(), fuel) - flights.begin();
           27  + }
           28  +};
           29  +
           30  +// BEGIN CUT HERE
           31  +#include <ctime>
           32  +double start_time; string timer()
           33  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           34  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           35  + { os << "{ ";
           36  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           37  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           38  +void verify_case(const int& Expected, const int& Received) {
           39  + bool ok = (Expected == Received);
           40  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           41  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           42  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           43  +#define END  verify_case(_, TheAirTripDivTwo().find(flights, fuel));}
           44  +int main(){
           45  +
           46  +CASE(0)
           47  + int flights_[] = {1, 2, 3, 4, 5, 6, 7};
           48  +   vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
           49  + int fuel = 10;
           50  + int _ = 4;
           51  +END
           52  +CASE(1)
           53  + int flights_[] = {7, 6, 5, 4, 3, 2, 1};
           54  +   vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
           55  + int fuel = 10;
           56  + int _ = 1;
           57  +END
           58  +CASE(2)
           59  + int flights_[] = {1};
           60  +   vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
           61  + int fuel = 1000;
           62  + int _ = 1;
           63  +END
           64  +CASE(3)
           65  + int flights_[] = {8, 7, 7, 1, 5, 7, 9};
           66  +   vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
           67  + int fuel = 21;
           68  + int _ = 2;
           69  +END
           70  + /*
           71  +CASE(4)
           72  + int flights_[] = ;
           73  +   vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
           74  + int fuel = ;
           75  + int _ = ;
           76  +END
           77  +CASE(5)
           78  + int flights_[] = ;
           79  +   vector <int> flights(flights_, flights_+sizeof(flights_)/sizeof(*flights_));
           80  + int fuel = ;
           81  + int _ = ;
           82  +END
           83  +*/
           84  +}
           85  +// END CUT HERE

Added SRM/480-U/1A.cpp version [c4cc4d65db9bedbb]

            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 InternetSecurity { public:
           23  + vector <string> determineWebsite(vector <string> address, vector <string> keyword, vector <string> dangerous, int threshold)
           24  + {
           25  +  int N = address.size();
           26  +
           27  +  vector< set<string> > kwd(N);
           28  +  for(int i=0; i<N; ++i) {
           29  +   stringstream ss(keyword[i]);
           30  +   for(string s; ss >> s; )
           31  +    kwd[i].insert(s);
           32  +  }
           33  +
           34  +  set<string> dng(dangerous.begin(), dangerous.end());
           35  +
           36  +  vector<bool> is_danger(N);
           37  +
           38  +  bool changed = true;
           39  +  while( changed )
           40  +  {
           41  +   changed = false;
           42  +   for(int i=0; i<N; ++i)
           43  +    if( !is_danger[i] )
           44  +    {
           45  +     vector<string> buf;
           46  +     set_intersection( kwd[i].begin(), kwd[i].end(), dng.begin(), dng.end(), back_inserter(buf) );
           47  +     if( buf.size() >= threshold )
           48  +     {
           49  +      changed = true;
           50  +      dng.insert(kwd[i].begin(), kwd[i].end());
           51  +      is_danger[i] = true;
           52  +     }
           53  +    }
           54  +  }
           55  +
           56  +  vector<string> result;
           57  +  for(int i=0; i<N; ++i)
           58  +   if( is_danger[i] )
           59  +    result.push_back( address[i] );
           60  +  return result;
           61  + }
           62  +};
           63  +
           64  +// BEGIN CUT HERE
           65  +#include <ctime>
           66  +double start_time; string timer()
           67  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           68  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           69  + { os << "{ ";
           70  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           71  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           72  +void verify_case(const vector <string>& Expected, const vector <string>& Received) {
           73  + bool ok = (Expected == Received);
           74  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           75  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           76  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           77  +#define END  verify_case(_, InternetSecurity().determineWebsite(address, keyword, dangerous, threshold));}
           78  +int main(){
           79  +
           80  +CASE(0)
           81  + string address_[] = {"www.topcoder.com",
           82  +"www.sindicate_of_evil.com",
           83  +"www.happy_citizens.com"};
           84  +   vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_));
           85  + string keyword_[] = {"hack encryption decryption internet algorithm",
           86  +"signal interference evil snake poison algorithm",
           87  +"flower baloon topcoder blue sky sea"};
           88  +   vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_));
           89  + string dangerous_[] = {"hack","encryption","decryption","interference","signal","internet"};
           90  +   vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_));
           91  + int threshold = 3;
           92  + string __[] = {"www.topcoder.com", "www.sindicate_of_evil.com" };
           93  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
           94  +END
           95  +CASE(1)
           96  + string address_[] = {"brokenlink","flowerpower.net","purchasedomain.com"};
           97  +   vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_));
           98  + string keyword_[] = {"broken","rose tulips","cheap free domain biggest greatest"};
           99  +   vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_));
          100  + string dangerous_[] = {"biggest","enemy","hideout"};
          101  +   vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_));
          102  + int threshold = 2;
          103  + vector <string> _;
          104  +END
          105  +CASE(2)
          106  + string address_[] = {"a..a.ab.","...aa.b"};
          107  +   vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_));
          108  + string keyword_[] = {"a bc def","def ghij klmno"};
          109  +   vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_));
          110  + string dangerous_[] = {"a","b","c","d","e"};
          111  +   vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_));
          112  + int threshold = 1;
          113  + string __[] = {"a..a.ab.", "...aa.b" };
          114  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          115  +END
          116  +CASE(3)
          117  + string address_[] = {"www.tsa.gov"};
          118  +   vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_));
          119  + string keyword_[] = {"information assurance signal intelligence research"};
          120  +   vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_));
          121  + string dangerous_[] = {"signal","assurance","penguin"};
          122  +   vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_));
          123  + int threshold = 2;
          124  + string __[] = {"www.tsa.gov" };
          125  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          126  +END
          127  +CASE(4)
          128  +string address_[] = {"","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""};
          129  +   vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_));
          130  +   string keyword_[] = {"a b c d e f g h i j k l m n o p q r s t u v w x y",
          131  +    "A B C D E F G H I J K L M N O P Q R S T U V W X Y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y","a b c d e f g h i j k l m n o p q r s t u v w x y"};
          132  +   vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_));
          133  +   string dangerous_[] = {"a","b","c"};
          134  +   vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_));
          135  + int threshold = 3;
          136  + string __[] = {"XXX"};
          137  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          138  +END
          139  +/*
          140  +CASE(5)
          141  + string address_[] = ;
          142  +   vector <string> address(address_, address_+sizeof(address_)/sizeof(*address_));
          143  + string keyword_[] = ;
          144  +   vector <string> keyword(keyword_, keyword_+sizeof(keyword_)/sizeof(*keyword_));
          145  + string dangerous_[] = ;
          146  +   vector <string> dangerous(dangerous_, dangerous_+sizeof(dangerous_)/sizeof(*dangerous_));
          147  + int threshold = ;
          148  + string __[] = ;
          149  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          150  +END
          151  +*/
          152  +}
          153  +// END CUT HERE

Added SRM/480-U/1B.cpp version [4c32e38aec559696]

            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 NetworkSecurity { public:
           23  + int secureNetwork(vector <string> clientCable, vector <string> serverCable)
           24  + {
           25  +  int N = clientCable.size();
           26  +  int M = serverCable[0].size();
           27  +
           28  +  vector< vector<int> > cd(N, vector<int>(N));
           29  +  for(int i=0; i<N; ++i)
           30  +   for(int j=0; j<N; ++j)
           31  +    if( clientCable[i][j]=='Y' )
           32  +     cd[i][j] = 1;
           33  +  for(int k=0; k<N; ++k)
           34  +   for(int i=0; i<N; ++i)
           35  +    for(int j=0; j<N; ++j)
           36  +     cd[i][j] |= cd[i][k] & cd[k][j];
           37  +
           38  +  int cnt = 0;
           39  +  for(int i=0; i<N; ++i)
           40  +   for(int j=0; j<M; ++j)
           41  +   {
           42  +    if( serverCable[i][j]=='Y' )
           43  +    {
           44  +     for(int k=0; k<N; ++k)
           45  +      if( cd[i][k]==1 && serverCable[k][j]=='Y' )
           46  +       goto next;
           47  +     ++cnt;
           48  +    next:;
           49  +    }
           50  +   }
           51  +  return cnt;
           52  + }
           53  +};
           54  +
           55  +
           56  +
           57  +// Powered by FileEdit
           58  +// Powered by TZTester 1.01 [25-Feb-2003] : <cafelier&naoya_t>-custom
           59  +// Powered by CodeProcessor

Added SRM/481/1A.cpp version [5beaeafc55fc55b6]

            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 ChickenOracle { public:
           23  + string theTruth(int n, int eggCount, int lieCount, int liarCount)
           24  + {
           25  +  bool egg = canTruthTellerBe(   eggCount, n, lieCount, liarCount );
           26  +  bool chk = canTruthTellerBe( n-eggCount, n, lieCount, liarCount );
           27  +  if( egg && chk ) return "Ambiguous";
           28  +  if( egg ) return "The egg";
           29  +  if( chk ) return "The chicken";
           30  +  return "The oracle is a lie";
           31  + }
           32  + bool canTruthTellerBe( int A, int n, int B, int  C )
           33  + {
           34  +  int two_x = A+B+C - n;
           35  +  if( (two_x&1) == 1 )
           36  +   return false;
           37  +  int x = two_x/2;
           38  +  return 0<=x && x<=C && x<=B && (C-x)<=(n-B);
           39  + }
           40  +};
           41  +
           42  +// BEGIN CUT HERE
           43  +#include <ctime>
           44  +double start_time; string timer()
           45  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           46  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           47  + { os << "{ ";
           48  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           49  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           50  +void verify_case(const string& Expected, const string& Received) {
           51  + bool ok = (Expected == Received);
           52  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           53  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           54  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           55  +#define END  verify_case(_, ChickenOracle().theTruth(n, eggCount, lieCount, liarCount));}
           56  +int main(){
           57  +
           58  +CASE(0)
           59  + int n = 10;
           60  + int eggCount = 10;
           61  + int lieCount = 0;
           62  + int liarCount = 0;
           63  + string _ = "The egg";
           64  +END
           65  +CASE(1)
           66  + int n = 60;
           67  + int eggCount = 40;
           68  + int lieCount = 0;
           69  + int liarCount = 30;
           70  + string _ = "The oracle is a lie";
           71  +END
           72  +CASE(2)
           73  + int n = 60;
           74  + int eggCount = 20;
           75  + int lieCount = 5;
           76  + int liarCount = 25;
           77  + string _ = "The chicken";
           78  +END
           79  +CASE(3)
           80  + int n = 1000;
           81  + int eggCount = 500;
           82  + int lieCount = 250;
           83  + int liarCount = 250;
           84  + string _ = "Ambiguous";
           85  +END
           86  +CASE(4)
           87  + int n = 338919;
           88  + int eggCount = 310645;
           89  + int lieCount = 70422;
           90  + int liarCount = 304279;
           91  + string _ = "The oracle is a lie";
           92  +END
           93  +CASE(5)
           94  + int n = 1;
           95  + int eggCount = 0;
           96  + int lieCount = 0;
           97  + int liarCount = 0;
           98  + string _ = "The chicken";
           99  +END
          100  +}
          101  +// END CUT HERE

Added SRM/481/1B.cpp version [9a6b2ff88d4819cc]

            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 BatchSystemRoulette { public:
           23  + vector <double> expectedFinishTimes(vector <int> duration, vector <string> user)
           24  + {
           25  +  vector<double> answer(duration.begin(), duration.end());
           26  +
           27  +  map<string, LL> userSum;
           28  +  for(int i=0; i<user.size(); ++i)
           29  +   userSum[user[i]] += duration[i];
           30  +  map<LL, vector<string> > usInv;
           31  +  for(map<string,LL>::iterator it=userSum.begin(); it!=userSum.end(); ++it)
           32  +   usInv[it->second].push_back(it->first);
           33  +
           34  +  double base = 0;
           35  +  for(map<LL, vector<string> >::iterator it=usInv.begin(); it!=usInv.end(); ++it)
           36  +  {
           37  +   LL t = it->first;
           38  +   vector<string>& us = it->second;
           39  +   int n = us.size();
           40  +
           41  +   double baseAve = base + t*(n-1)/2.0;
           42  +   for(int u=0; u<n; ++u)
           43  +   {
           44  +    vector<int> idxs;
           45  +    for(int i=0; i<answer.size(); ++i)
           46  +     if( user[i] == us[u] ) {
           47  +      answer[i] += baseAve;
           48  +      idxs.push_back(i);
           49  +     }
           50  +    for(int k=0; k<idxs.size(); ++k) {
           51  +     int i = idxs[k];
           52  +     for(int m=0; m<idxs.size(); ++m) if(m!=k) {
           53  +      int j = idxs[m];
           54  +      answer[i] += duration[j]/2.0;
           55  +     }
           56  +    }
           57  +   }
           58  +
           59  +   base += t*n;
           60  +  }
           61  +
           62  +  return answer;
           63  + }
           64  +};
           65  +
           66  +// BEGIN CUT HERE
           67  +#include <ctime>
           68  +double start_time; string timer()
           69  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           70  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           71  + { os << "{ ";
           72  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           73  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           74  +void verify_case(const vector <double>& Expected, const vector <double>& Received) {
           75  + bool ok = true;
           76  + for(int i=0; i<Expected.size(); ++i)
           77  +   if( abs(Expected[i]-Received[i]) >= 1e-9 )
           78  +     ok = false;
           79  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           80  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           81  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           82  +#define END  verify_case(_, BatchSystemRoulette().expectedFinishTimes(duration, user));}
           83  +int main(){
           84  +
           85  +CASE(0)
           86  + int duration_[] = {3, 2, 4, 1};
           87  +   vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_));
           88  + string user_[] = {"Gil Grissom", "Sarah Sidle", "Warrick Brown", "Catherine Willows"};
           89  +   vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_));
           90  + double __[] = {6.0, 3.0, 10.0, 1.0 };
           91  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
           92  +END
           93  +CASE(1)
           94  + int duration_[] = {3, 2, 4, 1};
           95  +   vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_));
           96  + string user_[] = {"mac taylor", "Mac Taylor", "Mac Taylor", "Peyton Driscoll"};
           97  +   vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_));
           98  + double __[] = {4.0, 8.0, 9.0, 1.0 };
           99  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          100  +END
          101  +CASE(2)
          102  + int duration_[] = {13, 14, 15, 56, 56};
          103  +   vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_));
          104  + string user_[] = {"Tim Speedle", "Tim Speedle", "Tim Speedle", "Horatio Caine", "YEEEAAAAAAAAAAH"};
          105  +   vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_));
          106  + double __[] = {27.5, 28.0, 28.5, 126.0, 126.0 };
          107  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          108  +END
          109  +/*
          110  +CASE(3)
          111  + int duration_[] = ;
          112  +   vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_));
          113  + string user_[] = ;
          114  +   vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_));
          115  + double __[] = ;
          116  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          117  +END
          118  +CASE(4)
          119  + int duration_[] = ;
          120  +   vector <int> duration(duration_, duration_+sizeof(duration_)/sizeof(*duration_));
          121  + string user_[] = ;
          122  +   vector <string> user(user_, user_+sizeof(user_)/sizeof(*user_));
          123  + double __[] = ;
          124  +   vector <double> _(__, __+sizeof(__)/sizeof(*__));
          125  +END
          126  +*/
          127  +}
          128  +// END CUT HERE

Added SRM/481/1C.cpp version [33f000c44b39ef2d]

            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  +template<typename T>
           23  +struct DP3
           24  +{
           25  + int N1, N2, N3;
           26  + vector<T> data;
           27  + DP3(int N1, int N2, int N3, const T& t = T())
           28  +  : N1(N1), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           29  + T& operator()(int i1, int i2, int i3)
           30  +  { return data[ ((i1*N2)+i2)*N3+i3 ]; }
           31  + void swap(DP3& rhs)
           32  +  { data.swap(rhs.data); }
           33  +};
           34  +
           35  +int bitcnt(int U)
           36  +{
           37  + int c = 0;
           38  + for(; U; U>>=1)
           39  +  c += (U&1);
           40  + return c;
           41  +}
           42  +
           43  +class TicketPrinters { public:
           44  + int minTime(int currentPrinter, vector <int> printerDistance, vector <int> startingValues, vector <int> wantedValues)
           45  + {
           46  +  int N = startingValues.size();
           47  +
           48  +  vector<int> d(N);
           49  +  partial_sum( printerDistance.begin(), printerDistance.end(), d.begin()+1 );
           50  +
           51  +  // left, used, LeftOrRight
           52  +  DP3<int> dp(N,1<<N,2);
           53  +  for(int D=(1<<N)-1; D>=0; --D)
           54  +  {
           55  +   int bc = bitcnt(D);
           56  +   for(int L=0; L<N && L+bc<=N; ++L)
           57  +    for(int C=0; C<=1; ++C)
           58  +    {
           59  +     if( bc == N )
           60  +      dp(L,D,C) = 0;
           61  +     else {
           62  +      int cur = (C==0 ? L : L+bc-1);
           63  +      int mn = 0x7fffffff;
           64  +      for(int nextW=0; nextW<N; ++nextW)
           65  +       if( ((1<<nextW) & D) == 0 ) {
           66  +        int caseLeft = 0x7fffffff;
           67  +        if( L>0 ) {
           68  +         caseLeft = d[cur] - d[L-1] + max(dp(L-1, D|1<<nextW, 0),
           69  +          1+abs(startingValues[L-1]-wantedValues[nextW]));
           70  +        }
           71  +        int caseRight = 0x7fffffff;
           72  +        if( L+bc < N ) {
           73  +         caseRight = d[L+bc] - d[cur] + max(dp(L, D|1<<nextW, 1),
           74  +          1+abs(startingValues[L+bc]-wantedValues[nextW]));
           75  +        }
           76  +        mn = min(mn, min(caseLeft, caseRight));
           77  +       }
           78  +      dp(L,D,C) = mn;
           79  +     }
           80  +    }
           81  +  }
           82  +  return dp(currentPrinter,0,0);
           83  + }
           84  +};
           85  +
           86  +// BEGIN CUT HERE
           87  +#include <ctime>
           88  +double start_time; string timer()
           89  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           90  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           91  + { os << "{ ";
           92  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           93  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           94  +void verify_case(const int& Expected, const int& Received) {
           95  + bool ok = (Expected == Received);
           96  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           97  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           98  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           99  +#define END  verify_case(_, TicketPrinters().minTime(currentPrinter, printerDistance, startingValues, wantedValues));}
          100  +int main(){
          101  +
          102  +CASE(0)
          103  + int currentPrinter = 0;
          104  + int printerDistance_[] = {100, 20, 50};
          105  +   vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_));
          106  + int startingValues_[] = {66, 78, 99, 5};
          107  +   vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_));
          108  + int wantedValues_[] = {99, 5, 78, 66};
          109  +   vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_));
          110  + int _ = 171;
          111  +END
          112  +CASE(1)
          113  + int currentPrinter = 1;
          114  + int printerDistance_[] = {50, 50};
          115  +   vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_));
          116  + int startingValues_[] = {100, 200, 300};
          117  +   vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_));
          118  + int wantedValues_[] = {101, 201, 302};
          119  +   vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_));
          120  + int _ = 152;
          121  +END
          122  +CASE(2)
          123  + int currentPrinter = 2;
          124  + int printerDistance_[] = {13, 26, 39, 13};
          125  +   vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_));
          126  + int startingValues_[] = {123, 12, 32, 67, 1015};
          127  +   vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_));
          128  + int wantedValues_[] = {1, 2, 3, 4, 5};
          129  +   vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_));
          130  + int _ = 1063;
          131  +END
          132  + /*
          133  +CASE(3)
          134  + int currentPrinter = ;
          135  + int printerDistance_[] = ;
          136  +   vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_));
          137  + int startingValues_[] = ;
          138  +   vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_));
          139  + int wantedValues_[] = ;
          140  +   vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_));
          141  + int _ = ;
          142  +END
          143  +CASE(4)
          144  + int currentPrinter = ;
          145  + int printerDistance_[] = ;
          146  +   vector <int> printerDistance(printerDistance_, printerDistance_+sizeof(printerDistance_)/sizeof(*printerDistance_));
          147  + int startingValues_[] = ;
          148  +   vector <int> startingValues(startingValues_, startingValues_+sizeof(startingValues_)/sizeof(*startingValues_));
          149  + int wantedValues_[] = ;
          150  +   vector <int> wantedValues(wantedValues_, wantedValues_+sizeof(wantedValues_)/sizeof(*wantedValues_));
          151  + int _ = ;
          152  +END
          153  +*/
          154  +}
          155  +// END CUT HERE

Added SRM/482-U/1A.cpp version [622c85edd2a0b0bf]

            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 LockersDivOne { public:
           23  + int lastOpened(int N)
           24  + {
           25  +  vector<int> v;
           26  +  for(int i=1; i<=N; ++i)
           27  +   v.push_back(i);
           28  +  int last = -1;
           29  +  for(int s=2; !v.empty(); ++s) {
           30  +   vector<int> vv;
           31  +   for(int i=0; i<v.size(); ++i)
           32  +    if( i%s>0 )
           33  +     vv.push_back(v[i]);
           34  +    else
           35  +     last = v[i];
           36  +   v.swap(vv);
           37  +  }
           38  +  return last;
           39  + }
           40  +};
           41  +
           42  +// BEGIN CUT HERE
           43  +#include <ctime>
           44  +double start_time; string timer()
           45  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           46  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           47  + { os << "{ ";
           48  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           49  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           50  +void verify_case(const int& Expected, const int& Received) {
           51  + bool ok = (Expected == Received);
           52  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           53  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           54  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           55  +#define END  verify_case(_, LockersDivOne().lastOpened(N));}
           56  +int main(){
           57  +
           58  +CASE(0)
           59  + int N = 9;
           60  + int _ = 6;
           61  +END
           62  +CASE(1)
           63  + int N = 42;
           64  + int _ = 42;
           65  +END
           66  +CASE(2)
           67  + int N = 314;
           68  + int _ = 282;
           69  +END
           70  +CASE(4)
           71  + int N = 1;
           72  + int _ = 1;
           73  +END
           74  +CASE(5)
           75  + int N = 2;
           76  + int _ = 2;
           77  +END
           78  +CASE(6)
           79  + int N = 3;
           80  + int _ = 2;
           81  +END
           82  +CASE(7)
           83  + int N = 4;
           84  + int _ = 4;
           85  +END
           86  +CASE(7)
           87  + int N = 5;
           88  + int _ = 4;
           89  +END
           90  +CASE(7)
           91  + int N = 6;
           92  + int _ = 6;
           93  +END
           94  +CASE(7)
           95  + int N = 7;
           96  + int _ = 6;
           97  +END
           98  +CASE(7)
           99  + int N = 8;
          100  + int _ = 6;
          101  +END
          102  +CASE(3)
          103  + int N = 2000000;
          104  + int _ = -1;
          105  +END
          106  +
          107  +}
          108  +// END CUT HERE

Added SRM/482-U/1B.cpp version [c9cf49d6b744849f]

            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  +int powi(int a, int b)
           23  +{
           24  + int v=1;
           25  + for(int i=0; i<b; ++i)
           26  +  v*=a;
           27  + return v;
           28  +}
           29  +
           30  +class HanoiGoodAndBad { public:
           31  + int moves(int N, int Dave)
           32  + {
           33  +  if( N == 0 )
           34  +   return 0;
           35  +  if( Dave <= (1<<N-1)-1 )
           36  +   return moves2(N-1, Dave);
           37  +  return (powi(3,N-1))*2+moves3(N-1, Dave - (1<<N-1));
           38  + }
           39  + int moves2(int N, int Dave)
           40  + {
           41  +  if( N == 0 )
           42  +   return 0;
           43  +  if( Dave <= (1<<N-1)-1 )
           44  +   return moves(N-1, Dave);
           45  +  return powi(3,N-1)+moves2(N-1, Dave - (1<<N-1));
           46  + }
           47  + int moves3(int N, int Dave)
           48  + {
           49  +  if( N == 0 )
           50  +   return 0;
           51  +  if( Dave <= (1<<N-1)-1 )
           52  +   return powi(3,N-1)+moves3(N-1, Dave);
           53  +  return (powi(3,N-1))*2+moves(N-1, Dave - (1<<N-1));
           54  + }
           55  +};
           56  +
           57  +// BEGIN CUT HERE
           58  +#include <ctime>
           59  +double start_time; string timer()
           60  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           61  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           62  + { os << "{ ";
           63  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           64  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           65  +void verify_case(const int& Expected, const int& Received) {
           66  + bool ok = (Expected == Received);
           67  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           68  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           69  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           70  +#define END  verify_case(_, HanoiGoodAndBad().moves(N, Dave));}
           71  +int main(){
           72  +
           73  +CASE(0)
           74  + int N = 1;
           75  + int Dave = 1;
           76  + int _ = 2;
           77  +END
           78  +CASE(0)
           79  + int N = 2;
           80  + int Dave = 1;
           81  + int _ = 2;
           82  +END
           83  +CASE(0)
           84  + int N = 3;
           85  + int Dave = 1;
           86  + int _ = 2;
           87  +END
           88  +CASE(1)
           89  + int N = 4;
           90  + int Dave = 15;
           91  + int _ = 80;
           92  +END
           93  +CASE(2)
           94  + int N = 9;
           95  + int Dave = 265;
           96  + int _ = 16418;
           97  +END
           98  +CASE(3)
           99  + int N = 1;
          100  + int Dave = 0;
          101  + int _ = 0;
          102  +END
          103  +CASE(3)
          104  + int N = 1;
          105  + int Dave = 1;
          106  + int _ = 2;
          107  +END
          108  +CASE(4)
          109  + int N = 19;
          110  + int Dave = (1<<19)-1;
          111  + int _ = -1;
          112  +END
          113  +
          114  +}
          115  +// END CUT HERE

Added SRM/482-U/1C-U.cpp version [65aad8bb5e7b3849]

            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 BalancingAct { public:
           23  + vector <string> recover(vector <int> labeled, vector <int> unlabeled)
           24  + {
           25  +  vector<int> same(unlabeled.size());
           26  +  for(int i=0; i<same.size(); ++i)
           27  +   same[i] = count(unlabeled.begin(), unlabeled.end(), unlabeled[i]);
           28  +
           29  +  set<unsigned int> canBeMade;
           30  +  canBeMade.insert(0);
           31  +  for(int i=0; i<labeled.size(); ++i) {
           32  +   set<unsigned int> next;
           33  +   for(set<unsigned int>::iterator it=canBeMade.begin(); it!=canBeMade.end(); ++it) {
           34  +    if(*it+labeled[i] > *it )
           35  +     next.insert(*it+labeled[i]);
           36  +   }
           37  +   canBeMade.insert(next.begin(), next.end());
           38  +  }
           39  +  vector<unsigned int> cbm(canBeMade.begin(), canBeMade.end());
           40  +
           41  +  vector<string> answer(unlabeled.size(), "no");
           42  +  for(;;) {
           43  +   bool updated = false;
           44  +   for(int i=0; i<unlabeled.size(); ++i)
           45  +    if( answer[i] == "no" ) {
           46  +     unsigned int ul = unlabeled[i];
           47  +     bool ok = false;
           48  +     if( canMake(ul, cbm) )
           49  +      ok = true;
           50  +     else if( canMake(ul+1, cbm) && canMake(ul-1, cbm) )
           51  +      ok = true;
           52  +     else if( same[i]>=2 ) {
           53  +      for(int k=2; k<=same[i]; ++k) {
           54  +       if(canMake(ul*k, cbm))
           55  +        {ok=true; break;}
           56  +       bool lok = false, rok=false;
           57  +       for(int j=1; j<=k; ++j) {
           58  +        if(canMake(ul*k-j, cbm))
           59  +         lok=true;
           60  +        if(canMake(ul*k+j, cbm))
           61  +         rok=true;
           62  +        if(lok&&rok){ok=true; break;}
           63  +       }
           64  +      }
           65  +     }
           66  +
           67  +     if( ok ) {
           68  +      // update
           69  +      updated = true;
           70  +      answer[i] = "yes";
           71  +      for(int k=0,ke=cbm.size(); k!=ke; ++k)
           72  +       cbm.push_back(cbm[k]+unlabeled[i]);
           73  +      sort(cbm.begin(), cbm.end());
           74  +      cbm.erase(unique(cbm.begin(),cbm.end()), cbm.end());
           75  +     }
           76  +    }
           77  +   if( !updated )
           78  +    break;
           79  +  }
           80  +  return answer;
           81  + }
           82  +
           83  + bool canMake( int t, vector<unsigned int>& cbm )
           84  + {
           85  +  if( t==0 || t==100000001 )
           86  +   return true;
           87  +  if( binary_search(cbm.begin(), cbm.end(), t) )
           88  +   return true;
           89  +  for(vector<unsigned int>::iterator it=cbm.begin(); it!=cbm.end(); ++it)
           90  +   if( binary_search(cbm.begin(), cbm.end(), t+*it) )
           91  +    return true;
           92  +  return false;
           93  + }
           94  +};
           95  +
           96  +// BEGIN CUT HERE
           97  +#include <ctime>
           98  +double start_time; string timer()
           99  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          100  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          101  + { os << "{ ";
          102  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          103  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          104  +void verify_case(const vector <string>& Expected, const vector <string>& Received) {
          105  + bool ok = (Expected == Received);
          106  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          107  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
          108  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          109  +#define END  verify_case(_, BalancingAct().recover(labeled, unlabeled));}
          110  +int main(){
          111  +
          112  +CASE(0)
          113  + int labeled_[] = {9,13,15,16};
          114  +   vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_));
          115  + int unlabeled_[] = {19};
          116  +   vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_));
          117  + string __[] = {"yes" };
          118  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          119  +END
          120  +CASE(1)
          121  + int labeled_[] = {20};
          122  +   vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_));
          123  + int unlabeled_[] = {10,10};
          124  +   vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_));
          125  + string __[] = {"yes", "yes" };
          126  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          127  +END
          128  +CASE(2)
          129  + int labeled_[] = {33333332,33333334};
          130  +   vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_));
          131  + int unlabeled_[] = {33333333,73,100000000};
          132  +   vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_));
          133  + string __[] = {"yes", "no", "yes" };
          134  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          135  +END
          136  +CASE(3)
          137  + int labeled_[] = {12};
          138  +   vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_));
          139  + int unlabeled_[] = {1,1,2,2};
          140  +   vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_));
          141  + string __[] = {"yes", "yes", "yes", "yes" };
          142  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          143  +END
          144  +CASE(4)
          145  + int labeled_[] = {31415926,5358979,32384626,43383279,50288419,
          146  +71693993,75105820,9749445,92307816,40628620,
          147  +89986280,34825342,11706798,21480865,13282306};
          148  +   vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_));
          149  + int unlabeled_[] = {64709384,46095505,82231725,35940812};
          150  +   vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_));
          151  + string __[] = {"no", "no", "no", "no" };
          152  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          153  +END
          154  +CASE(5)
          155  +int labeled_[] = {1,2,4,8,16,32,64,128,256,512,1024,2048*1,2048*2,2048*4,2048*8,2048*16,2048*32,2048*64,2048*128,2048*256};
          156  +   vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_));
          157  +   int unlabeled_[] = {999, 888, 777, 666};
          158  +   vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_));
          159  +   string __[] = {"yes","yes","yes","yes"};
          160  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          161  +END
          162  +/*
          163  +CASE(6)
          164  + int labeled_[] = ;
          165  +   vector <int> labeled(labeled_, labeled_+sizeof(labeled_)/sizeof(*labeled_));
          166  + int unlabeled_[] = ;
          167  +   vector <int> unlabeled(unlabeled_, unlabeled_+sizeof(unlabeled_)/sizeof(*unlabeled_));
          168  + string __[] = ;
          169  +   vector <string> _(__, __+sizeof(__)/sizeof(*__));
          170  +END
          171  +*/
          172  +}
          173  +// END CUT HERE

Added SRM/484-U/1A.cpp version [6a42e8ac2f9b115b]

            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 RabbitNumber { public:
           23  + LL dsum(LL n) {
           24  +  LL x = 0;
           25  +  while(n) {
           26  +   x+=n%10;
           27  +   n/=10;
           28  +  }
           29  +  return x;
           30  + }
           31  + bool isRabbit(LL n) {
           32  +  LL a = dsum(n);
           33  +  LL b = dsum(n*n);
           34  +  return b==a*a;
           35  + }
           36  + void enumerate(int s, LL c, vector<int>& v)
           37  + {
           38  +  if( c > 1000000000 )
           39  +   return;
           40  +  if( s == 0 )
           41  +   if( isRabbit(c) )
           42  +    v.push_back(int(c));
           43  +  for(int i=(c==0?1:0); i<=s && i<=9; ++i)
           44  +   enumerate(s-i, c*10+i, v);
           45  + }
           46  +
           47  + int theCount(int low, int high)
           48  + {
           49  +  vector<int> v;
           50  +  for(int s=1; s<=15; ++s)
           51  +   enumerate(s, 0, v);
           52  +  sort(v.begin(), v.end());
           53  +  return upper_bound(v.begin(), v.end(), high)
           54  +       - lower_bound(v.begin(), v.end(), low);
           55  + }
           56  +};
           57  +
           58  +// BEGIN CUT HERE
           59  +#include <ctime>
           60  +double start_time; string timer()
           61  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           62  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           63  + { os << "{ ";
           64  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           65  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           66  +void verify_case(const int& Expected, const int& Received) {
           67  + bool ok = (Expected == Received);
           68  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           69  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           70  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           71  +#define END  verify_case(_, RabbitNumber().theCount(low, high));}
           72  +int main(){
           73  +
           74  +CASE(0)
           75  + int low = 22;
           76  + int high = 22;
           77  + int _ = 1;
           78  +END
           79  +CASE(1)
           80  + int low = 484;
           81  + int high = 484;
           82  + int _ = 0;
           83  +END
           84  +CASE(2)
           85  + int low = 1;
           86  + int high = 58;
           87  + int _ = 12;
           88  +END
           89  +CASE(3)
           90  + int low = 58;
           91  + int high = 484;
           92  + int _ = 24;
           93  +END
           94  +CASE(4)
           95  + int low = 1000000000;
           96  + int high = 1000000000;
           97  + int _ = 1;
           98  +END
           99  +CASE(5)
          100  + int low = 1;
          101  + int high = 1;
          102  + int _ = 1;
          103  +END
          104  +CASE(6)
          105  + int low = 1;
          106  + int high = 1000000;
          107  + int _ = 615;
          108  +END
          109  +CASE(7)
          110  + int low = 1;
          111  + int high = 1000000000;
          112  + int _ = -1;
          113  +END
          114  +}
          115  +// END CUT HERE

Added SRM/484-U/1B.cpp version [be7ddcd5afb0c754]

            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 LL MODVAL = 1000000007;
           23  +
           24  +class PuyoPuyo { public:
           25  + int theCount(int L, int N)
           26  + {
           27  +  // A4 ::= U*
           28  +  // U  ::= x A3 x A3 x A3 x   (U::=U[0],  U[i]::=x A3 U[i+1],  U[L-1]::=x)
           29  +
           30  +  vector<LL>           A4(N+1), A3(N+1);
           31  +  vector< vector<LL> > U(L, vector<LL>(N+1));
           32  +
           33  +  A4[0] = A3[0] = U[L-1][1] = 1;
           34  +  for(int n=1; n<=N; ++n) {
           35  +   for(int k=L-2; k>=0; --k)
           36  +    for(int z=0; n-z-1>=1; z+=L)
           37  +     U[k][n] = (U[k][n] + A3[z]*U[k+1][n-z-1]) % MODVAL;
           38  +   for(int i=L; i<=n; i+=L)
           39  +    A4[n] = (A4[n] + 4*U[0][i]*A4[n-i]) % MODVAL;
           40  +   for(int i=L; i<=n; i+=L)
           41  +    A3[n] = (A3[n] + 3*U[0][i]*A3[n-i]) % MODVAL;
           42  +  }
           43  +  return int(A4[N]);
           44  + }
           45  +};
           46  +
           47  +// BEGIN CUT HERE
           48  +#include <ctime>
           49  +double start_time; string timer()
           50  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           51  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           52  + { os << "{ ";
           53  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           54  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           55  +void verify_case(const int& Expected, const int& Received) {
           56  + bool ok = (Expected == Received);
           57  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           58  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           59  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           60  +#define END  verify_case(_, PuyoPuyo().theCount(L, N));}
           61  +int main(){
           62  +
           63  +CASE(0)
           64  + int L = 2;
           65  + int N = 2;
           66  + int _ = 4;
           67  +END
           68  +CASE(1)
           69  + int L = 2;
           70  + int N = 4;
           71  + int _ = 28;
           72  +END
           73  +CASE(2)
           74  + int L = 2;
           75  + int N = 58;
           76  + int _ = 868294620;
           77  +END
           78  +CASE(3)
           79  + int L = 4;
           80  + int N = 84;
           81  + int _ = 621871151;
           82  +END
           83  +CASE(4)
           84  + int L = 5;
           85  + int N = 8;
           86  + int _ = 0;
           87  +END
           88  +CASE(5)
           89  + int L = 2;
           90  + int N = 1;
           91  + int _ = 0;
           92  +END
           93  +CASE(6)
           94  + int L = 2;
           95  + int N = 1000;
           96  + int _ = -1;
           97  +END
           98  +CASE(7)
           99  + int L = 2;
          100  + int N = 6;
          101  + int _ = 232;
          102  +END
          103  +CASE(8)
          104  + int L = 2;
          105  + int N = 8;
          106  + int _ = 2092;
          107  +END
          108  +}
          109  +// END CUT HERE

Added SRM/484-U/2C.cpp version [ff8a7dedf31c21ec]

            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 CubeColoring { public:
           23  + long long theCount(vector <string> colors)
           24  + {
           25  +  const int NC = colors[0].size();
           26  +
           27  +  int c1=0,c3=0,c4=0,c6=0;
           28  +  for(int i=0; i<NC; ++i) {
           29  +   c1 += colors[1][i]=='Y';
           30  +   c3 += colors[3][i]=='Y';
           31  +   c4 += colors[4][i]=='Y';
           32  +   c6 += colors[6][i]=='Y';
           33  +  }
           34  +  LL answer = 0;
           35  +  for(int i0=0; i0<NC; ++i0) if(colors[0][i0]=='Y')
           36  +  for(int i2=0; i2<NC; ++i2) if(colors[2][i2]=='Y')
           37  +  for(int i5=0; i5<NC; ++i5) if(colors[5][i5]=='Y')
           38  +  for(int i7=0; i7<NC; ++i7) if(colors[7][i7]=='Y')
           39  +  {
           40  +   int cc1 = c1 - (colors[1][i0]=='Y') - (i0!=i2 && colors[1][i2]=='Y') - (i0!=i5 && i2!=i5 && colors[1][i5]=='Y');
           41  +   int cc3 = c3 - (colors[3][i0]=='Y') - (i0!=i2 && colors[3][i2]=='Y') - (i0!=i7 && i2!=i7 && colors[3][i7]=='Y');
           42  +   int cc4 = c4 - (colors[4][i0]=='Y') - (i0!=i5 && colors[4][i5]=='Y') - (i0!=i7 && i5!=i7 && colors[4][i7]=='Y');
           43  +   int cc6 = c6 - (colors[6][i2]=='Y') - (i2!=i5 && colors[6][i5]=='Y') - (i2!=i7 && i5!=i7 && colors[6][i7]=='Y');
           44  +   answer += cc1*cc3*cc4*cc6;
           45  +  }
           46  +  return answer;
           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) << " msec)"; return os.str(); }
           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 os; }
           58  +void verify_case(const long long& Expected, const long long& Received) {
           59  + bool ok = (Expected == Received);
           60  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           61  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           62  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           63  +#define END  verify_case(_, CubeColoring().theCount(colors));}
           64  +int main(){
           65  +
           66  +CASE(0)
           67  + string colors_[] = {"Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y"};
           68  +   vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_));
           69  + long long _ = 0LL;
           70  +END
           71  +CASE(1)
           72  + string colors_[] = {"YNNNNNNN", "NYNNNNNN", "NNYNNNNN", "NNNYNNNN", "NNNNYNNN", "NNNNNYNN", "NNNNNNYN", "NNNNNNNY"};
           73  +   vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_));
           74  + long long _ = 1LL;
           75  +END
           76  +CASE(2)
           77  + string colors_[] = {"YNNYN", "YYYYY", "NYYNY", "YNYYN", "YNNYY", "YNNYY", "NNNYY", "NYYYY"};
           78  +   vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_));
           79  + long long _ = 250LL;
           80  +END
           81  +CASE(3)
           82  + string colors_[] = {"YNNYN", "YYYYY", "NNNNN", "YNYYN", "YNNYY", "YNNYY", "NNNYY", "NYYYY"};
           83  +   vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_));
           84  + long long _ = 0LL;
           85  +END
           86  +CASE(4)
           87  + string colors_[] = {"YNNYNYYYYYNN", "NNNYNYYNYNNY", "YYNNYYNNNYYN", "YYYYYNNYYYNN", "NNNYYYNNYNYN", "YYYNYYYYNYNN", "NNNNNNYYNYYN", "NNYNYYNNYNYY"};
           88  +   vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_));
           89  + long long _ = 611480LL;
           90  +END
           91  +/*
           92  +CASE(5)
           93  + string colors_[] = ;
           94  +   vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_));
           95  + long long _ = LL;
           96  +END
           97  +CASE(6)
           98  + string colors_[] = ;
           99  +   vector <string> colors(colors_, colors_+sizeof(colors_)/sizeof(*colors_));
          100  + long long _ = LL;
          101  +END
          102  +*/
          103  +}
          104  +// END CUT HERE

Added SRM/485-U/1A.cpp version [561cc23e487a1233]

            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 AfraidOfEven { public:
           23  + vector <int> restoreProgression(vector <int> seq)
           24  + {
           25  +  LL a = seq[0];
           26  +  LL b = seq[1];
           27  +  for(LL aa=a; aa<=0x7fffffff; aa*=2)
           28  +  for(LL bb=b; bb<=0x7fffffff; bb*=2)
           29  +   if( possible(seq,aa,bb) )
           30  +    return seq;
           31  +  assert(false);
           32  + }
           33  + bool possible(vector<int>& seq, LL a, LL b)
           34  + {
           35  +  LL d = b-a;
           36  +  vector<LL> q(seq.size());
           37  +  q[0] = a;
           38  +  q[1] = b;
           39  +  for(int i=2; i<seq.size(); ++i)
           40  +  {
           41  +   q[i] = q[i-1] + d;
           42  +   if( q[i] <= 0 )
           43  +    return false;
           44  +   if( q[i] % seq[i] != 0 )
           45  +    return false;
           46  +   LL f = q[i] / seq[i];
           47  +   if( f & (f-1) )
           48  +    return false;
           49  +  }
           50  +  for(int i=0; i<seq.size(); ++i)
           51  +   seq[i] = int(q[i]);
           52  +  return true;
           53  + }
           54  +};
           55  +
           56  +// BEGIN CUT HERE
           57  +#include <ctime>
           58  +double start_time; string timer()
           59  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           60  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           61  + { os << "{ ";
           62  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           63  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           64  +void verify_case(const vector <int>& Expected, const vector <int>& Received) {
           65  + bool ok = (Expected == Received);
           66  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           67  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           68  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           69  +#define END  verify_case(_, AfraidOfEven().restoreProgression(seq));}
           70  +int main(){
           71  +
           72  +CASE(0)
           73  + int seq_[] = {1, 1, 3, 1, 5};
           74  +   vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_));
           75  + int __[] = {1, 2, 3, 4, 5 };
           76  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           77  +END
           78  +CASE(1)
           79  + int seq_[] = {9, 7, 5, 3, 1};
           80  +   vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_));
           81  + int __[] = {9, 7, 5, 3, 1 };
           82  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           83  +END
           84  +CASE(2)
           85  + int seq_[] = {999, 999, 999, 999};
           86  +   vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_));
           87  + int __[] = {999, 999, 999, 999 };
           88  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           89  +END
           90  +CASE(3)
           91  + int seq_[] = {7, 47, 5, 113, 73, 179, 53};
           92  +   vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_));
           93  + int __[] = {14, 47, 80, 113, 146, 179, 212 };
           94  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           95  +END
           96  +CASE(4)
           97  + int seq_[] = {749, 999, 125, 1};
           98  +   vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_));
           99  + int __[] = {1498, 999, 500, 1 };
          100  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          101  +END
          102  +CASE(5)
          103  +int seq_[] = {3,7,1,9};
          104  +   vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_));
          105  +   int __[] = {6,7,8,9};
          106  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          107  +END
          108  +/*
          109  +CASE(6)
          110  + int seq_[] = ;
          111  +   vector <int> seq(seq_, seq_+sizeof(seq_)/sizeof(*seq_));
          112  + int __[] = ;
          113  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          114  +END
          115  +*/
          116  +}
          117  +// END CUT HERE

Added SRM/485-U/1B.cpp version [50efd272f7286bd4]

            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  +template<typename T>
           23  +struct DP3
           24  +{
           25  + int N1, N2, N3;
           26  + vector<T> data;
           27  + DP3(int N1, int N2, int N3, const T& t = T())
           28  +  : N1(N1), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           29  + T& operator()(int i1, int i2, int i3)
           30  +  { return data[ ((i1*N2)+i2)*N3+i3 ]; }
           31  + void swap(DP3& rhs)
           32  +  { data.swap(rhs.data); }
           33  +};
           34  +
           35  +class RectangleAvoidingColoring { public:
           36  + long long count(vector <string> board)
           37  + {
           38  +  int H = board.size();
           39  +  int W = board[0].size();
           40  +  // o????
           41  +  // o????
           42  +  // xooxo
           43  +  // xoxoo
           44  +  // xxooo
           45  +  if( H>=5 && W>=5 )
           46  +   return 0;
           47  +  if( H >= 5 )
           48  +   transpose(board, H, W);
           49  +  // H <= 4
           50  +
           51  +  int BADPAT = H*(H-1)/2;
           52  +  DP3<LL> dp(1<<BADPAT, 1<<BADPAT, W+1);
           53  +  dp(0,0,0) = 1;
           54  +  for(int i=0; i<W; ++i)
           55  +  for(int BlackBad=0; BlackBad<(1<<BADPAT); BlackBad++)
           56  +  for(int WhiteBad=0; WhiteBad<(1<<BADPAT); WhiteBad++)
           57  +  {
           58  +   for(int pat=0; pat<(1<<H); ++pat) {
           59  +    int bbb = bb(pat,H);
           60  +    int wbb = wb(pat,H);
           61  +    if( possible(pat, board, i, H) && !(bbb&BlackBad) && !(wbb&WhiteBad) )
           62  +     dp(BlackBad|bbb,WhiteBad|wbb,i+1) += dp(BlackBad,WhiteBad,i);
           63  +   }
           64  +  }
           65  +  LL sum = 0;
           66  +  for(int BlackBad=0; BlackBad<(1<<BADPAT); BlackBad++)
           67  +  for(int WhiteBad=0; WhiteBad<(1<<BADPAT); WhiteBad++)
           68  +   sum += dp(BlackBad,WhiteBad,W);
           69  +  return sum;
           70  + }
           71  + bool possible(int pat, const vector<string>& board, int i, int H)
           72  + {
           73  +  for(int y=0; y<H; ++y) {
           74  +   if( board[y][i]=='B' && !(pat&(1<<y))) return false;
           75  +   if( board[y][i]=='W' && (pat&(1<<y))) return false;
           76  +  }
           77  +  return true;
           78  + }
           79  + int bb(int pat,int H)
           80  + {
           81  +  int mask = 0, idx=0;
           82  +  for(int i=0; i<H; ++i)
           83  +  for(int j=i+1; j<H; ++j,++idx)
           84  +   if(pat & (1<<i))
           85  +   if(pat & (1<<j))
           86  +    mask |= (1<<idx);
           87  +  return mask;
           88  + }
           89  + int wb(int pat,int H)
           90  + {
           91  +  int mask = 0, idx=0;
           92  +  for(int i=0; i<H; ++i)
           93  +  for(int j=i+1; j<H; ++j,++idx)
           94  +   if(!(pat & (1<<i)))
           95  +   if(!(pat & (1<<j)))
           96  +    mask |= (1<<idx);
           97  +  return mask;
           98  + }
           99  + void transpose(vector<string>& b, int& H, int& W)
          100  + {
          101  +  vector<string> bb(W);
          102  +  for(int x=0; x<W; ++x)
          103  +   for(int y=0; y<H; ++y)
          104  +    bb[x] += b[y][x];
          105  +  swap(H, W);
          106  +  b = bb;
          107  + }
          108  +};
          109  +
          110  +// BEGIN CUT HERE
          111  +#include <ctime>
          112  +double start_time; string timer()
          113  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          114  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          115  + { os << "{ ";
          116  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          117  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          118  +void verify_case(const long long& Expected, const long long& Received) {
          119  + bool ok = (Expected == Received);
          120  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          121  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          122  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          123  +#define END  verify_case(_, RectangleAvoidingColoring().count(board));}
          124  +int main(){
          125  +
          126  +CASE(0)
          127  + string board_[] = {"??",
          128  + "??"};
          129  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          130  + long long _ = 14LL;
          131  +END
          132  +CASE(1)
          133  + string board_[] = {"B?",
          134  + "?B"};
          135  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          136  + long long _ = 3LL;
          137  +END
          138  +CASE(2)
          139  + string board_[] = {"WW",
          140  + "WW"};
          141  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          142  + long long _ = 0LL;
          143  +END
          144  +CASE(3)
          145  + string board_[] = {"??B??",
          146  + "W???W",
          147  + "??B??"};
          148  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          149  + long long _ = 12LL;
          150  +END
          151  +CASE(4)
          152  + string board_[] = {"??",
          153  + "W?",
          154  + "W?",
          155  + "?W",
          156  + "W?"};
          157  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          158  + long long _ = 16LL;
          159  +END
          160  +/*
          161  +CASE(5)
          162  + string board_[] = {};
          163  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          164  + long long _ = LL;
          165  +END
          166  +CASE(6)
          167  + string board_[] = ;
          168  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          169  + long long _ = LL;
          170  +END
          171  +*/
          172  +}
          173  +// END CUT HERE

Added SRM/485-U/1C-U.cpp version [27e70b1898243972]

            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 Deposit { public:
           23  + vector<CMP> make_polygon(const vector<int>& xs, const vector<int>& ys)
           24  + {
           25  +  vector<CMP> vs;
           26  +  for(int i=0; i<xs.size(); ++i)
           27  +   vs.push_back( CMP(xs[i], ys[i]) );
           28  +  return vs;
           29  + }
           30  +
           31  + double successProbability(vector <int> siteX, vector <int> siteY, vector <int> depositX, vector <int> depositY)
           32  + {
           33  +  const vector<CMP> ss = make_polygon(siteX, siteY);
           34  +  const vector<CMP> dd = make_polygon(depositX, depositY);
           35  +  const int SN = ss.size();
           36  +
           37  +  double totallen=0, hitlen=0;
           38  +  for(int i=0; i<SN; ++i)
           39  +  {
           40  +   const CMP p0 = ss[i];
           41  +   const CMP p1 = ss[(i+1)%SN];
           42  +   totallen += abs(p1-p0);
           43  +
           44  +
           45  +   CMP pv = p1 - p0; pv /= abs(pv);
           46  +
           47  +   // calc furthest on p0 - p1
           48  +   double q = 1.0;
           49  +   for(int k=i+1; k!=i; k=(k+1)%SN)
           50  +   {
           51  +    const CMP q0 = ss[k];
           52  +    const CMP q1 = ss[(k+1)%SN];
           53  +    // compute vertical-eqsplitter of lineseg q0 - q1
           54  +    CMP mid = (q0+q1)/2.0;
           55  +    CMP vec = (q0-q1)*CMP(0,1);;
           56  +    // compute crossing with p0 - p1
           57  +    double qq = solve(p0,pv,mid,vec);
           58  +    if( qq < q )
           59  +    {
           60  +     if( qq <= 0.0 )
           61  +      qq = 0.0;
           62  +     // in (qq,q), furthest is q1
           63  +     // [todo] compute the fraction of the region crossing with the deposit
           64  +     // by ternery search or something like that
           65  +     double r = computeFractionOfCross(p0+qq*pv, p0+q*pv, q1, dd);
           66  +
           67  +     hitlen += abs(p0-p1)*(q-qq)*r;
           68  +     q = qq;
           69  +    }
           70  +    if( q == 0.0 )
           71  +     break;
           72  +   }
           73  +  }
           74  +  return hitlen / totallen;
           75  + }
           76  + double solve(CMP a, CMP b, CMP c, CMP d)
           77  + {
           78  +  // solve: a + <return ?>*b == c + ??*d
           79  +  return -1;
           80  + }
           81  + double computeFractionOfCross(CMP p0, CMP p1, CMP q, const vector<CMP>& d)
           82  + {
           83  +  // retur the fraction of k in [0,1]  s.t.  line (p0 + k(p1-p0)) to q crosses d.
           84  +  return -1;
           85  + }
           86  +};
           87  +
           88  +// BEGIN CUT HERE
           89  +#include <ctime>
           90  +double start_time; string timer()
           91  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           92  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           93  + { os << "{ ";
           94  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           95  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           96  +void verify_case(const double& Expected, const double& Received) {
           97  + bool ok = (abs(Expected - Received) < 1e-9);
           98  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           99  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          100  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          101  +#define END  verify_case(_, Deposit().successProbability(siteX, siteY, depositX, depositY));}
          102  +int main(){
          103  +
          104  +CASE(0)
          105  + int siteX_[] = {0,4,4,0};
          106  +   vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_));
          107  + int siteY_[] = {0,0,4,4};
          108  +   vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_));
          109  + int depositX_[] = {1,2,2,1};
          110  +   vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_));
          111  + int depositY_[] = {1,1,2,2};
          112  +   vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_));
          113  + double _ = 0.6666666666666666;
          114  +END
          115  +CASE(1)
          116  + int siteX_[] = {0,4,4,0};
          117  +   vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_));
          118  + int siteY_[] = {0,0,4,4};
          119  +   vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_));
          120  + int depositX_[] = {1,3,3,1};
          121  +   vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_));
          122  + int depositY_[] = {1,1,3,3};
          123  +   vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_));
          124  + double _ = 1.0;
          125  +END
          126  +CASE(2)
          127  + int siteX_[] = {5,2,-1,0,4};
          128  +   vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_));
          129  + int siteY_[] = {3,4,2,0,0};
          130  +   vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_));
          131  + int depositX_[] = {3,3,4};
          132  +   vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_));
          133  + int depositY_[] = {3,2,1};
          134  +   vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_));
          135  + double _ = 0.6112700209855423;
          136  +END
          137  +CASE(3)
          138  + int siteX_[] = {200,-99,-405,-601,-708,-494,-300,-88};
          139  +   vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_));
          140  + int siteY_[] = {520,516,407,321,104,-97,-221,-101};
          141  +   vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_));
          142  + int depositX_[] = {-101,-201,-296,-400,-402};
          143  +   vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_));
          144  + int depositY_[] = {318,396,402,305,200};
          145  +   vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_));
          146  + double _ = 0.49892756207100747;
          147  +END
          148  +CASE(4)
          149  + int siteX_[] = {-3,6,10,10,-2};
          150  +   vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_));
          151  + int siteY_[] = {-1,-10,-9,7,3};
          152  +   vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_));
          153  + int depositX_[] = {3,5,6,4};
          154  +   vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_));
          155  + int depositY_[] = {-5,-7,-6,-4};
          156  +   vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_));
          157  + double _ = 0.16641662251521538;
          158  +END
          159  +CASE(5)
          160  + int siteX_[] = {-2,4,-2}
          161  +;
          162  +   vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_));
          163  + int siteY_[] = {-2,-2,8}
          164  +;
          165  +   vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_));
          166  + int depositX_[] = {-1,0,0}
          167  +;
          168  +   vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_));
          169  + int depositY_[] = {0,-1,0}
          170  +;
          171  +   vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_));
          172  + double _ = 0.04518850219072291;
          173  +END
          174  +/*
          175  +CASE(6)
          176  + int siteX_[] = ;
          177  +   vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_));
          178  + int siteY_[] = ;
          179  +   vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_));
          180  + int depositX_[] = ;
          181  +   vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_));
          182  + int depositY_[] = ;
          183  +   vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_));
          184  + double _ = ;
          185  +END
          186  +CASE(7)
          187  + int siteX_[] = ;
          188  +   vector <int> siteX(siteX_, siteX_+sizeof(siteX_)/sizeof(*siteX_));
          189  + int siteY_[] = ;
          190  +   vector <int> siteY(siteY_, siteY_+sizeof(siteY_)/sizeof(*siteY_));
          191  + int depositX_[] = ;
          192  +   vector <int> depositX(depositX_, depositX_+sizeof(depositX_)/sizeof(*depositX_));
          193  + int depositY_[] = ;
          194  +   vector <int> depositY(depositY_, depositY_+sizeof(depositY_)/sizeof(*depositY_));
          195  + double _ = ;
          196  +END
          197  +*/
          198  +}
          199  +// END CUT HERE

Added SRM/486/1A.cpp version [a62787f87989e0f0]

            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 OneRegister { public:
           23  + string getProgram(int s, int t)
           24  + {
           25  +  string x = run("",s,t);
           26  +  string y = run("/",1, t);
           27  +  string z = takeMin(x,y);
           28  +  return z=="NO" ? ":-(" : z;
           29  + }
           30  +
           31  + string takeMin(const string& x, const string& y)
           32  + {
           33  +  if( x == "NO" )
           34  +   return y;
           35  +  else if( y == "NO" )
           36  +   return x;
           37  +  else
           38  +   return (x.size()<y.size() ? x : (x.size()==y.size() ? min(x,y) : y));
           39  + }
           40  +
           41  + // by using only '*' and '+'
           42  + string run(const string& buf, LL s, LL t)
           43  + {
           44  +  if( s == t )
           45  +   return buf;
           46  +  if( s > t )
           47  +   return "NO";
           48  +  string x = run(buf+"+", s+s, t);
           49  +  string y = (s==1 ? "NO" : run(buf+"*", s*s, t));
           50  +  return takeMin(x,y);
           51  + }
           52  +};
           53  +
           54  +// BEGIN CUT HERE
           55  +#include <ctime>
           56  +double start_time; string timer()
           57  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           58  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           59  + { os << "{ ";
           60  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           61  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           62  +void verify_case(const string& Expected, const string& Received) {
           63  + bool ok = (Expected == Received);
           64  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           65  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           66  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           67  +#define END  verify_case(_, OneRegister().getProgram(s, t));}
           68  +int main(){
           69  +
           70  +CASE(0)
           71  + int s = 7;
           72  + int t = 392;
           73  + string _ = "+*+";
           74  +END
           75  +CASE(1)
           76  + int s = 7;
           77  + int t = 256;
           78  + string _ = "/+***";
           79  +END
           80  +CASE(2)
           81  + int s = 4;
           82  + int t = 256;
           83  + string _ = "**";
           84  +END
           85  +CASE(3)
           86  + int s = 7;
           87  + int t = 7;
           88  + string _ = "";
           89  +END
           90  +CASE(4)
           91  + int s = 7;
           92  + int t = 9;
           93  + string _ = ":-(";
           94  +END
           95  +CASE(5)
           96  + int s = 10;
           97  + int t = 1;
           98  + string _ = "/";
           99  +END
          100  +CASE(6)
          101  + int s = 1;
          102  + int t = 1000000000;
          103  + string _ = "dummy";
          104  +END
          105  +CASE(6)
          106  + int s = 2;
          107  + int t = 1<<30;
          108  + string _ = "dummy";
          109  +END
          110  +CASE(7)
          111  + int s = 1000000000;
          112  + int t = 1;
          113  + string _ = "dummy";
          114  +END
          115  +CASE(8)
          116  + int s = 1;
          117  + int t = 1;
          118  + string _ = "";
          119  +END
          120  +CASE(9)
          121  + int s = 2;
          122  + int t = 2;
          123  + string _ = "";
          124  +END
          125  +CASE(10)
          126  + int s = 1;
          127  + int t = 2;
          128  + string _ = "+";
          129  +END
          130  +CASE(11)
          131  + int s = 512;
          132  + int t = 65536;
          133  + string _ = "*";
          134  +END
          135  +
          136  +}
          137  +// END CUT HERE

Added SRM/486/1B.cpp version [937144173b305ccc]

            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 QuickSort { public:
           23  + double getEval(vector <int> L)
           24  + {
           25  +  int m = *min_element(L.begin(), L.end());
           26  +  int M = *max_element(L.begin(), L.end());
           27  +  return rec(L, m, M+1);
           28  + }
           29  + map<pair<int,int>, double> memo;
           30  + double rec(const vector<int>& L, int m, int M)
           31  + {
           32  +  pair<int,int> key(m,M);
           33  +  if(memo.count(key))
           34  +   return memo[key];
           35  +
           36  +  vector<int> c;
           37  +  for(int i=0; i<L.size(); ++i)
           38  +   if( m<=L[i] && L[i]<M )
           39  +    c.push_back(L[i]);
           40  +
           41  +  if( c.size() <= 1 )
           42  +   return memo[key] = 0;
           43  +
           44  +  double e = 0;
           45  +  for(int k=0; k<c.size(); ++k)
           46  +  {
           47  +   int p = c[k];
           48  +   int cnt = 0;
           49  +   for(int i=0; i<k; ++i)
           50  +    if( c[i] > p )
           51  +     ++cnt;
           52  +   for(int i=k+1; i<c.size(); ++i)
           53  +    if( p > c[i] )
           54  +     ++cnt;
           55  +   e += rec(L, m, p) + rec(L, p+1, M) + cnt;
           56  +  }
           57  +
           58  +  return memo[key] = e / c.size();
           59  + }
           60  +};
           61  +
           62  +// BEGIN CUT HERE
           63  +#include <ctime>
           64  +double start_time; string timer()
           65  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           66  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           67  + { os << "{ ";
           68  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           69  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           70  +void verify_case(const double& Expected, const double& Received) {
           71  + bool ok = (abs(Expected - Received) < 1e-9);
           72  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           73  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           74  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           75  +#define END  verify_case(_, QuickSort().getEval(L));}
           76  +int main(){
           77  +
           78  +CASE(0)
           79  + int L_[] = {1,2,3,4,5};
           80  +   vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_));
           81  + double _ = 0.0;
           82  +END
           83  +CASE(1)
           84  + int L_[] = {1,2,4,3,5,6};
           85  +   vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_));
           86  + double _ = 1.0;
           87  +END
           88  +CASE(2)
           89  + int L_[] = {3,2,1};
           90  +   vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_));
           91  + double _ = 2.6666666666666665;
           92  +END
           93  +CASE(3)
           94  + int L_[] = {50,40,30,20,10,15,25,35,45};
           95  +   vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_));
           96  + double _ = 11.07698412698413;
           97  +END
           98  +CASE(4)
           99  + int L_[] = {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,
          100  + 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50};
          101  +   vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_));
          102  + double _ = -1;
          103  +END
          104  +CASE(5)
          105  + int L_[] = {48,49,50,10,11,12,40,41,42,5,39,32,33,34,43,44,45,46,6,7,8,9,22,23,24,25,26,27,28,29,30,
          106  + 31,13,1,2,3,4,35,36,37,38,47,14,15,16,17,18,19,20,21};
          107  +   vector <int> L(L_, L_+sizeof(L_)/sizeof(*L_));
          108  + double _ = -1;
          109  +END
          110  +}
          111  +// END CUT HERE

Added SRM/486/1C.cpp version [0a15ef1d15a672ee]

            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  +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  +double area( const vector<CMP>& q )
           61  +{
           62  + double a = 0.0;
           63  +
           64  + CMP o = q[0];
           65  + for(int i=1; i+1<q.size(); ++i)
           66  +  a += outer_prod(q[i]-o, q[i+1]-o);
           67  + return abs(a)/2;
           68  +}
           69  +
           70  +class BatmanAndRobin { public:
           71  + double minArea(vector <int> x, vector <int> y)
           72  + {
           73  +  int N = x.size();
           74  +  vector<CMP> p;
           75  +  for(int i=0; i<N; ++i)
           76  +   p.push_back(CMP(x[i],y[i]));
           77  +
           78  +  const double eps = 1e-6;
           79  +  CMP diff[] = {CMP(eps,0), CMP(0,eps), CMP(-eps,0), CMP(0,-eps)};
           80  +  double answer = area(convex_hull(p));
           81  +  for(int i=0; i<N; ++i)
           82  +   for(int j=i+1; j<N; ++j) {
           83  +    for(int di=0; di<4; ++di)
           84  +     for(int dj=0; dj<4; ++dj) {
           85  +      vector<CMP> a = left_of(p, p[i]+diff[di], p[j]+diff[dj]);
           86  +      vector<CMP> b = right_of(p, p[i]+diff[di], p[j]+diff[dj]);
           87  +      double aa = a.size()<=2 ? 0 : area(convex_hull(a));
           88  +      double bb = b.size()<=2 ? 0 : area(convex_hull(b));
           89  +      answer = min(answer, max(aa,bb));
           90  +     }
           91  +   }
           92  +  return answer;
           93  + }
           94  +
           95  + vector<CMP> left_of(const vector<CMP>& p, const CMP& o, CMP v)
           96  + {
           97  +  v -= o;
           98  +  vector<CMP> r;
           99  +  for(int i=0; i<p.size(); ++i)
          100  +   if( is_left(p[i]-o, v) )
          101  +    r.push_back(p[i]);
          102  +  return r;
          103  + }
          104  + vector<CMP> right_of(const vector<CMP>& p, const CMP& o, CMP v)
          105  + {
          106  +  v -= o;
          107  +  vector<CMP> r;
          108  +  for(int i=0; i<p.size(); ++i)
          109  +   if( !is_left(p[i]-o, v) )
          110  +    r.push_back(p[i]);
          111  +  return r;
          112  + }
          113  + bool is_left(const CMP& p, const CMP& v)
          114  + {
          115  +  return arg(p/v)>0;
          116  + }
          117  +};
          118  +
          119  +// BEGIN CUT HERE
          120  +#include <ctime>
          121  +double start_time; string timer()
          122  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          123  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          124  + { os << "{ ";
          125  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          126  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          127  +void verify_case(const double& Expected, const double& Received) {
          128  + bool ok = (abs(Expected - Received) < 1e-9);
          129  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          130  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          131  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          132  +#define END  verify_case(_, BatmanAndRobin().minArea(x, y));}
          133  +int main(){
          134  +
          135  +CASE(0)
          136  + int x_[] = {100,100,90,90,-100,-100,-90,-90};
          137  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          138  + int y_[] = {100,90,100,90,-100,-90,-100,-90};
          139  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          140  + double _ = 100.0;
          141  +END
          142  +CASE(1)
          143  + int x_[] = {-1000,-1000,1000,1000,1000,-1000};
          144  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          145  + int y_[] = {-1000,1000,-1000,1000,0,0};
          146  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          147  + double _ = 0.0;
          148  +END
          149  +CASE(2)
          150  + int x_[] = {-1000,-1000,1000,1000,0};
          151  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          152  + int y_[] = {-1000,1000,-1000,1000,0};
          153  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          154  + double _ = 1000000.0;
          155  +END
          156  +CASE(3)
          157  + int x_[] = {-904,-812,-763,-735,-692,-614,-602,-563,-435,-243,-87,-52,-28,121,126,149,157,185,315,336,390,470,528,591,673,798,815,837,853,874};
          158  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          159  + int y_[] = {786,10,-144,949,37,-857,-446,-969,-861,-712,5,-972,-3,-202,-845,559,-244,-542,-421,422,526,-501,-791,-899,-315,281,-275,467,743,-321};
          160  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          161  + double _ = 1067472.0;
          162  +END
          163  +CASE(4)
          164  + int x_[] = {-904,-812,-763,-735,-692,-614,-602,-563,-435,-243,-87,-52,-28,121,126,149,157,185,315,336,390,470,528,591,673,798,815,837,853,874,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
          165  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          166  + int y_[] = {786,10,-144,949,37,-857,-446,-969,-861,-712,5,-972,-3,-202,-845,559,-244,-542,-421,422,526,-501,-791,-899,-315,281,-275,467,743,-321,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
          167  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          168  + double _ = -1;
          169  +END
          170  +/*
          171  +CASE(5)
          172  + int x_[] = ;
          173  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          174  + int y_[] = ;
          175  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          176  + double _ = ;
          177  +END
          178  +*/
          179  +}
          180  +// END CUT HERE

Added SRM/486/2C.cpp version [894982b1719fd8db]

            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 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 Find(int a)
           32  +  { return uf[a]==a ? a : uf[a]=Find(uf[a]); }
           33  + bool Union(int a, int b)
           34  +  {
           35  +   a = Find(a);
           36  +   b = Find(b);
           37  +   if( a != b )
           38  +   {
           39  +    if( sz[a] >= sz[b] ) swap(a, b);
           40  +    uf[a] = b;
           41  +    sz[b] += sz[a];
           42  +    --nc;
           43  +   }
           44  +   return (a!=b);
           45  +  }
           46  +};
           47  +
           48  +class CrazyLine { public:
           49  + int maxCrazyness(vector <int> heights)
           50  + {
           51  +  typedef pair< int, pair<int,int> > cand;
           52  +  priority_queue<cand> Q;
           53  +  for(int i=0; i<heights.size(); ++i)
           54  +  for(int j=i+1; j<heights.size(); ++j)
           55  +   Q.push( cand(abs(heights[i]-heights[j]), make_pair(i,j)) );
           56  +
           57  +  UnionFind uf(heights.size());
           58  +
           59  +  int score=0;
           60  +  vector<int> used(heights.size());
           61  +  while( uf.size()>1 )
           62  +  {
           63  +   int s = Q.top().first;
           64  +   int i = Q.top().second.first;
           65  +   int j = Q.top().second.second;
           66  +   Q.pop();
           67  +   if( used[i]<=1 && used[j]<=1 && uf.Find(i)!=uf.Find(j) )
           68  +   {
           69  +    score += s;
           70  +    used[i]++;
           71  +    used[j]++;
           72  +    uf.Union(i,j);
           73  +   }
           74  +  }
           75  +  return score;
           76  + }
           77  +};
           78  +
           79  +// BEGIN CUT HERE
           80  +#include <ctime>
           81  +double start_time; string timer()
           82  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           83  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           84  + { os << "{ ";
           85  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           86  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           87  +void verify_case(const int& Expected, const int& Received) {
           88  + bool ok = (Expected == Received);
           89  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           90  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           91  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           92  +#define END  verify_case(_, CrazyLine().maxCrazyness(heights));}
           93  +int main(){
           94  +
           95  +CASE(0)
           96  + int heights_[] = {5,10,25,40,25};
           97  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
           98  + int _ = 100;
           99  +END
          100  +CASE(1)
          101  + int heights_[] = {2,3,5,7,11,13,17,19};
          102  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          103  + int _ = 82;
          104  +END
          105  +CASE(2)
          106  + int heights_[] = {1,1,1,1,1,1,501};
          107  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          108  + int _ = 1000;
          109  +END
          110  +CASE(3)
          111  + int heights_[] = {1000,1000,1000,1000,1000,1000,1000,1000,1000};
          112  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          113  + int _ = 0;
          114  +END
          115  +/*
          116  +CASE(4)
          117  + int heights_[] = ;
          118  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          119  + int _ = ;
          120  +END
          121  +CASE(5)
          122  + int heights_[] = ;
          123  +   vector <int> heights(heights_, heights_+sizeof(heights_)/sizeof(*heights_));
          124  + int _ = ;
          125  +END
          126  +*/
          127  +}
          128  +// END CUT HERE

Added SRM/487/1A.cpp version [4c5e2466526b5e9f]

            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 BunnyComputer { public:
           23  + int getMaximum(vector <int> preference, int k)
           24  + {
           25  +  int sum = 0;
           26  +
           27  +  int N = preference.size();
           28  +  for(int s=0; s<=k && s<N; ++s)
           29  +  {
           30  +   vector<int> sub;
           31  +   for(int i=s; i<N; i+=1+k)
           32  +    sub.push_back( preference[i] );
           33  +   sum += accumulate(sub.begin(), sub.end(), 0);
           34  +   if( sub.size() % 2 == 1 )
           35  +   {
           36  +    vector<int> skip;
           37  +    for(int i=0; i<sub.size(); i+=2)
           38  +     skip.push_back( sub[i] );
           39  +    sum -= *min_element(skip.begin(), skip.end());
           40  +   }
           41  +  }
           42  +
           43  +  return sum;
           44  + }
           45  +};
           46  +
           47  +// BEGIN CUT HERE
           48  +#include <ctime>
           49  +double start_time; string timer()
           50  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           51  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           52  + { os << "{ ";
           53  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           54  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           55  +void verify_case(const int& Expected, const int& Received) {
           56  + bool ok = (Expected == Received);
           57  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           58  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           59  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           60  +#define END  verify_case(_, BunnyComputer().getMaximum(preference, k));}
           61  +int main(){
           62  +
           63  +CASE(0)
           64  + int preference_[] = { 3, 1, 4, 1, 5, 9, 2, 6 };
           65  +   vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_));
           66  + int k = 2;
           67  + int _ = 28;
           68  +END
           69  +CASE(1)
           70  + int preference_[] = { 3, 1, 4, 1, 5, 9, 2, 6 };
           71  +   vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_));
           72  + int k = 1;
           73  + int _ = 31;
           74  +END
           75  +CASE(2)
           76  + int preference_[] = { 1, 2, 3, 4, 5, 6 };
           77  +   vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_));
           78  + int k = 3;
           79  + int _ = 14;
           80  +END
           81  +CASE(3)
           82  + int preference_[] = { 487, 2010 };
           83  +   vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_));
           84  + int k = 2;
           85  + int _ = 0;
           86  +END
           87  +/*
           88  +CASE(4)
           89  + int preference_[] = ;
           90  +   vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_));
           91  + int k = ;
           92  + int _ = ;
           93  +END
           94  +CASE(5)
           95  + int preference_[] = ;
           96  +   vector <int> preference(preference_, preference_+sizeof(preference_)/sizeof(*preference_));
           97  + int k = ;
           98  + int _ = ;
           99  +END
          100  +*/
          101  +}
          102  +// END CUT HERE

Added SRM/487/1B.cpp version [adf3912f0e556cd5]

            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 BunnyExam { public:
           23  + double getExpected(int m, int k, vector <int> linkage)
           24  + {
           25  +  // trivially impossible cases
           26  +  if( k==1 && m>1 )
           27  +   return -1;
           28  +  if( k==2 )
           29  +   for(int i=0; i<linkage.size(); i+=2)
           30  +    if( (linkage[i] ^ linkage[i+1])&1 )
           31  +     return -1;
           32  +  for(int i=0; i<linkage.size(); i+=2)
           33  +   if( abs(linkage[i] - linkage[i+1]) == 1 )
           34  +    return -1;
           35  +
           36  +  // interference graph
           37  +  int M = linkage.size()/2;
           38  +  vector< vector<int> > conflict(M);
           39  +  for(int i=0; i<M; ++i)
           40  +  for(int j=0; j<M; ++j)
           41  +   if( abs(linkage[2*i+0]-linkage[2*j+0])==1 || abs(linkage[2*i+1]-linkage[2*j+0])==1
           42  +    || abs(linkage[2*i+0]-linkage[2*j+1])==1 || abs(linkage[2*i+1]-linkage[2*j+1])==1 )
           43  +    conflict[i].push_back(j);
           44  +
           45  +  // check k-colorability
           46  +  if( colorable(conflict, k) )
           47  +   return double(m)/k;
           48  +  else
           49  +   return -1;
           50  + }
           51  +
           52  + bool colorable(vector< vector<int> >& G, int k)
           53  + {
           54  +  if( G.size() <= k )
           55  +   return true;
           56  +  vector<int> color(G.size(), (1<<k)-1);
           57  +  color[0] = 1;
           58  +  return rec(G, color, 0);
           59  + }
           60  +
           61  + bool rec(vector< vector<int> >& G, const vector<int>& color, int i)
           62  + {
           63  +  if( i == color.size() )
           64  +   return true;
           65  +  for(int k=1; k<=color[i]; k<<=1)
           66  +   if( color[i] & k ) // use color k
           67  +   {
           68  +    vector<int> c2 = color;
           69  +    for(int j=0; j<G[i].size(); ++j) // G[i][j] cannot use k
           70  +     c2[G[i][j]] &= ~k;
           71  +    if( rec(G, c2, i+1) )
           72  +     return true;
           73  +   }
           74  +  return false;
           75  + }
           76  +};
           77  +
           78  +// BEGIN CUT HERE
           79  +#include <ctime>
           80  +double start_time; string timer()
           81  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           82  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           83  + { os << "{ ";
           84  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           85  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           86  +void verify_case(const double& Expected, const double& Received) {
           87  + bool ok = (abs(Expected - Received) < 1e-9);
           88  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           89  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           90  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           91  +#define END  verify_case(_, BunnyExam().getExpected(m, k, linkage));}
           92  +int main(){
           93  +
           94  +CASE(0)
           95  + int m = 3;
           96  + int k = 2;
           97  + int linkage_[] = { 1, 3 };
           98  +   vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_));
           99  + double _ = 1.5;
          100  +END
          101  +CASE(1)
          102  + int m = 4;
          103  + int k = 2;
          104  + int linkage_[] = { 1, 4 };
          105  +   vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_));
          106  + double _ = -1.0;
          107  +END
          108  +CASE(2)
          109  + int m = 2;
          110  + int k = 8;
          111  + vector <int> linkage;
          112  + double _ = 0.25;
          113  +END
          114  +CASE(3)
          115  + int m = 1000000000;
          116  + int k = 1;
          117  + int linkage_[] = { 11, 13, 2010, 487 };
          118  +   vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_));
          119  + double _ = -1.0;
          120  +END
          121  +CASE(4)
          122  + int m = 128;
          123  + int k = 64;
          124  + int linkage_[] = { 32, 16, 8, 4, 2, 1 }
          125  +;
          126  +   vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_));
          127  + double _ = -1.0;
          128  +END
          129  +CASE(5)
          130  + int m = 13;
          131  + int k = 3;
          132  + int linkage_[] = { 1, 3, 7, 9, 13, 10, 6, 2  }
          133  +;
          134  +   vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_));
          135  + double _ = 4.333333333333333;
          136  +END
          137  +CASE(6)
          138  + int m = 8;
          139  + int k = 3;
          140  + int linkage_[] = {1,4,2,6,3,8,5,7};
          141  +   vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_));
          142  + double _ = -1;
          143  +END
          144  +CASE(7)
          145  + int m = 1000000000;
          146  + int k = 4;
          147  + int linkage_[] = {1,4,2,6,3,8,5,7,9,19,  10,20,11,21,12,22,13,23,14,24};
          148  +   vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_));
          149  + double _ = -1;
          150  +END
          151  +CASE(8)
          152  + int m = 20;
          153  + int k = 3;
          154  + int linkage_[] = {19, 6, 1, 14, 13, 9, 20, 10, 15, 8, 17, 5, 12, 7, 16, 2, 18, 4, 3, 11};
          155  +   vector <int> linkage(linkage_, linkage_+sizeof(linkage_)/sizeof(*linkage_));
          156  + double _ = 6.666666666666667;
          157  +END
          158  +}
          159  +// END CUT HERE

Added SRM/487/1C.cpp version [42380d118339650a]

            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 LL MODVAL = 1000000009;
           23  +
           24  +class BunnySequence { public:
           25  + int getNumber(int m, int n)
           26  + {
           27  +  vector<LL> tbl(n+1);
           28  +  vector<LL> tbl_sum(n+1);
           29  +  tbl[0] = 1;
           30  +  tbl_sum[0] = 1;
           31  +  for(int i=1; i<=n; ++i) {
           32  +   tbl[i] = (tbl_sum[i-1] - (i-m-1>=0 ? tbl_sum[i-m-1] : 0) + MODVAL) % MODVAL;
           33  +   tbl_sum[i] = (tbl_sum[i-1] + tbl[i]) % MODVAL;
           34  +  }
           35  +  return (tbl[n] - (n>=m ? tbl[n-m] : 0) + MODVAL) % MODVAL;
           36  + }
           37  +};
           38  +
           39  +// BEGIN CUT HERE
           40  +#include <ctime>
           41  +double start_time; string timer()
           42  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           43  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           44  + { os << "{ ";
           45  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           46  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           47  +void verify_case(const int& Expected, const int& Received) {
           48  + bool ok = (Expected == Received);
           49  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           50  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           51  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           52  +#define END  verify_case(_, BunnySequence().getNumber(m, n));}
           53  +int main(){
           54  +
           55  +CASE(0)
           56  + int m = 5;
           57  + int n = 3;
           58  + int _ = 4;
           59  +END
           60  +CASE(1)
           61  + int m = 487;
           62  + int n = 0;
           63  + int _ = 1;
           64  +END
           65  +CASE(2)
           66  + int m = 19;
           67  + int n = 10;
           68  + int _ = 512;
           69  +END
           70  +CASE(3)
           71  + int m = 3;
           72  + int n = 4;
           73  + int _ = 6;
           74  +END
           75  +CASE(4)
           76  + int m = 10;
           77  + int n = 487;
           78  + int _ = 829515032;
           79  +END
           80  +/*
           81  +CASE(5)
           82  + int m = ;
           83  + int n = ;
           84  + int _ = ;
           85  +END
           86  +CASE(6)
           87  + int m = ;
           88  + int n = ;
           89  + int _ = ;
           90  +END
           91  +*/
           92  +}
           93  +// END CUT HERE

Added SRM/487/2C.cpp version [707c8d59bdc01e9a]

            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 BunnyConverter { public:
           23  + vector< vector<int> > n_sqrt;
           24  +
           25  + int getMinimum(int n, int z, int start, int goal)
           26  + {
           27  +  n_sqrt.resize(n);
           28  +  for(LL y=0; y<n; ++y)
           29  +   n_sqrt[y*y%n].push_back(int(y?y:n));
           30  +
           31  +  set<int> v;
           32  +  v.insert(start);
           33  +  vector<int> q(1,start);
           34  +  for(int step=0; !q.empty(); ++step)
           35  +  {
           36  +   vector<int> qNext;
           37  +   for(int i=0; i<q.size(); ++i)
           38  +   {
           39  +    int x = q[i];
           40  +    if( x == goal )
           41  +     return step;
           42  +    const vector<int>& ys = next(x,z,n);
           43  +    for(int j=0; j<ys.size(); ++j)
           44  +    {
           45  +     int y = ys[j];
           46  +     if( v.insert(y).second )
           47  +      qNext.push_back(y);
           48  +    }
           49  +   }
           50  +   q.swap(qNext);
           51  +  }
           52  +  return -1;
           53  + }
           54  +
           55  +
           56  + const vector<int>& next(LL x, LL z, LL n)
           57  + {
           58  +  x %= n;
           59  +  z %= n;
           60  +  #define SUB(a,b) (((a)+n-(b))%n)
           61  +  #define MUL(a,b) ((a)*(b)%n)
           62  +  LL y2 = SUB(SUB(0, x), MUL(z,MUL(z,z)));
           63  +  return n_sqrt[int(y2)];
           64  + }
           65  +};
           66  +
           67  +// BEGIN CUT HERE
           68  +#include <ctime>
           69  +double start_time; string timer()
           70  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           71  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           72  + { os << "{ ";
           73  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           74  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           75  +void verify_case(const int& Expected, const int& Received) {
           76  + bool ok = (Expected == Received);
           77  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           78  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           79  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           80  +#define END  verify_case(_, BunnyConverter().getMinimum(n, z, start, goal));}
           81  +int main(){
           82  +
           83  +CASE(0)
           84  + int n = 5;
           85  + int z = 1;
           86  + int start = 5;
           87  + int goal = 3;
           88  + int _ = 1;
           89  +END
           90  +CASE(1)
           91  + int n = 5;
           92  + int z = 1;
           93  + int start = 5;
           94  + int goal = 1;
           95  + int _ = 2;
           96  +END
           97  +CASE(2)
           98  + int n = 6;
           99  + int z = 2;
          100  + int start = 3;
          101  + int goal = 4;
          102  + int _ = -1;
          103  +END
          104  +CASE(3)
          105  + int n = 7;
          106  + int z = 7;
          107  + int start = 7;
          108  + int goal = 7;
          109  + int _ = 0;
          110  +END
          111  +CASE(4)
          112  + int n = 499979;
          113  + int z = 499979;
          114  + int start = 499976;
          115  + int goal = 3;
          116  + int _ = 249988;
          117  +END
          118  +/*
          119  +CASE(5)
          120  + int n = ;
          121  + int z = ;
          122  + int start = ;
          123  + int goal = ;
          124  + int _ = ;
          125  +END
          126  +CASE(6)
          127  + int n = ;
          128  + int z = ;
          129  + int start = ;
          130  + int goal = ;
          131  + int _ = ;
          132  +END
          133  +*/
          134  +}
          135  +// END CUT HERE

Added SRM/489-U/1A.cpp version [7de7b5143ca31562]

            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 TheBoredomDivOne { public:
           23  + double find(int n, int m)
           24  + {
           25  +  double total = (n+m)*(n+m-1);
           26  +
           27  +  vector<double> e(n+m+1);
           28  +  e[n+m] = 0;
           29  +  for(int i=n+m-1; i>=n; --i)
           30  +  {
           31  +   double p2 = (n+m-i)*(n+m-i-1) / total;
           32  +   double p1 = 2*i*(n+m-i) / total;
           33  +   double p0 = 1-p2-p1;
           34  +
           35  +   // e[i] = 1 + p0*e[i] + p1*e[i+1] + p2*e[i+2];
           36  +   e[i] = 1/(1-p0) + p1/(1-p0)*e[i+1] + (i==n+m-1 ? 0 : p2/(1-p0)*e[i+2]);
           37  +  }
           38  +  return e[n];
           39  + }
           40  +};
           41  +
           42  +// BEGIN CUT HERE
           43  +#include <ctime>
           44  +double start_time; string timer()
           45  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           46  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           47  + { os << "{ ";
           48  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           49  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           50  +void verify_case(const double& Expected, const double& Received) {
           51  + bool ok = (abs(Expected - Received) < 1e-9);
           52  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           53  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           54  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           55  +#define END  verify_case(_, TheBoredomDivOne().find(n, m));}
           56  +int main(){
           57  +
           58  +CASE(0)
           59  + int n = 1;
           60  + int m = 1;
           61  + double _ = 1.0;
           62  +END
           63  +CASE(1)
           64  + int n = 2;
           65  + int m = 1;
           66  + double _ = 1.5;
           67  +END
           68  +CASE(2)
           69  + int n = 1;
           70  + int m = 2;
           71  + double _ = 2.0;
           72  +END
           73  +CASE(3)
           74  + int n = 4;
           75  + int m = 7;
           76  + double _ = 13.831068977298521;
           77  +END
           78  + /*
           79  +CASE(4)
           80  + int n = ;
           81  + int m = ;
           82  + double _ = ;
           83  +END
           84  +CASE(5)
           85  + int n = ;
           86  + int m = ;
           87  + double _ = ;
           88  +END
           89  +*/
           90  +}
           91  +// END CUT HERE

Added SRM/489-U/1B.cpp version [4377d1219d057c6f]

            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 TheBoringStoreDivOne { public:
           23  + // entry point
           24  + string J, B;
           25  + string find(string J, string B)
           26  + {
           27  +  this->J=J; this->B=B; return solve();
           28  + }
           29  +
           30  + // just for clarifying types
           31  + typedef int           J_index, B_index;
           32  + typedef pair<int,int> J_sub,   B_sub;
           33  + string jsub(J_index js, J_index je) { return J.substr(js, je-js); }
           34  + string bsub(B_index bs, B_index be) { return B.substr(bs, be-bs); }
           35  +
           36  + // update if better
           37  + void update(string* a, const string& b)
           38  + {
           39  +  if( a->size()<b.size() || (a->size()==b.size() && *a>b) )
           40  +   *a = b;
           41  + }
           42  +
           43  + // O(|J|^4) in total
           44  + string solve()
           45  + {
           46  +  string result;
           47  +  for(J_index js=0;    js< J.size(); ++js)
           48  +  for(J_index je=js+1; je<=J.size(); ++je) // for each J[js, je)
           49  +  for(J_index ks=0;    ks< J.size(); ++ks) // try each J[ks, ks+k) which ...
           50  +  {
           51  +   // ... is a maximal nonempty prefix of J[js, je) not intersecting with it
           52  +   int k;
           53  +   for(k=0; js+k<je && ks+k<J.size() && (ks+k<js || je<=ks); ++k)
           54  +    if( J[js+k] != J[ks+k] )
           55  +     break;
           56  +   if( k==0 )
           57  +    continue;
           58  +
           59  +   // we have J[js, js+k)+J[js+k, je) in J, so we want              m in B
           60  +   //         J[ks, ks+k)                              J[js+k,je) + m
           61  +   string m = findInB(J_sub(js+k,je));
           62  +   if( !m.empty() )
           63  +    update(&result, jsub(js,je)+m);
           64  +  }
           65  +  return result;
           66  + }
           67  +
           68  + // O(|J|^2 |B|^2) in total
           69  + map<J_sub, string> memo_fib;
           70  + string findInB(J_sub key)
           71  + {
           72  +  if( memo_fib.count(key) )
           73  +   return memo_fib[key];
           74  +
           75  +  string result;
           76  +  for(string::iterator it=B.begin(); it!=B.end(); ++it) // for each B[ks,ke)==key
           77  +  {
           78  +   it = search(it, B.end(), J.begin()+key.first, J.begin()+key.second);
           79  +   if( it == B.end() )
           80  +    break;
           81  +   B_index ks = it - B.begin();
           82  +   B_index ke = ks + (key.second - key.first);
           83  +
           84  +   // try all B[ks, ke)+B[ke, kee), and try to find another B[ke, kee) before ks or after kee
           85  +   for(B_index kee=ke+1; kee<=B.size(); ++kee)
           86  +    if( canFindBefore(ks, B_sub(ke,kee)) || canFindAfter(kee, B_sub(ke,kee)) )
           87  +     update(&result, bsub(ke,kee));
           88  +  }
           89  +  return memo_fib[key] = result;
           90  + }
           91  +
           92  + // O(|B|^4) in total : for each substring m of B, the first and last occurence is memoized
           93  + bool canFindBefore(B_index bi, B_sub m) { return firstOccurence(m)+(m.second-m.first) <= bi; }
           94  + bool canFindAfter (B_index bi, B_sub m) { return bi <= lastOccurence(m)-(m.second-m.first); }
           95  +
           96  + map<B_sub, B_index> memo_fo;
           97  + B_index firstOccurence(B_sub m)
           98  + {
           99  +  if( memo_fo.count(m) )
          100  +   return memo_fo[m];
          101  +  return memo_fo[m] = search(B.begin(), B.end(), B.begin()+m.first, B.begin()+m.second)-B.begin();
          102  + }
          103  +
          104  + map<B_sub, B_index> memo_lo;
          105  + B_index lastOccurence(B_sub m)
          106  + {
          107  +  if( memo_lo.count(m) )
          108  +   return memo_lo[m];
          109  +  int mrs = B.size() - m.second;
          110  +  int mre = B.size() - m.first;
          111  +  return memo_lo[m] = B.size() - (search(B.rbegin(), B.rend(), B.rbegin()+mrs, B.rbegin()+mre)-B.rbegin());
          112  + }
          113  +};
          114  +
          115  +// BEGIN CUT HERE
          116  +#include <ctime>
          117  +double start_time; string timer()
          118  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          119  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          120  + { os << "{ ";
          121  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          122  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          123  +void verify_case(const string& Expected, const string& Received) {
          124  + bool ok = (Expected == Received);
          125  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          126  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          127  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          128  +#define END  verify_case(_, TheBoringStoreDivOne().find(J, B));}
          129  +int main(){
          130  +
          131  +CASE(0)
          132  + string J = "StoreOfJohn";
          133  + string B = "StoreOfBrus";
          134  + string _ = "or";
          135  +END
          136  +CASE(1)
          137  + string J = "JohnAndJohn";
          138  + string B = "John";
          139  + string _ = "";
          140  +END
          141  +CASE(2)
          142  + string J = "JohnLikesToPlayGames";
          143  + string B = "BrusAlsoLikesToPlayGames";
          144  + string _ = "esToPlayGames";
          145  +END
          146  +CASE(3)
          147  + string J = "abacaba";
          148  + string B = "abacabadabacaba";
          149  + string _ = "abaabacaba";
          150  +END
          151  +CASE(4)
          152  + string J = "abacabaabacabaabacabaabacabaabacabaabacabaabacabaab";
          153  + string B = "abacabaabacabaabacabaabacabaabacabaabacabaabacabaab";
          154  + string _ = "abacabaabacabaabacabaabacabaabacabaabacabaabacabaab";
          155  +END
          156  +CASE(5)
          157  + string J = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
          158  + string B = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
          159  + string _ = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
          160  +END
          161  +}
          162  +// END CUT HERE

Added SRM/489-U/1C-U.cpp version [d8218ea4a0fb855c]

            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 TheBoringGameDivOne { public:
           23  + vector <int> find(int sJ, int kJ, int sB, int kB, int sF, int kF)
           24  + {
           25  +  // init:
           26  +  //   ( 0, 0, 0, 0, 0, 0)
           27  +  // possible transitions:
           28  +  //   (+1,+1, 0, 0, 0, 0)
           29  +  //   ( 0, 0,+1,+1, 0, 0)
           30  +  //   ( 0,+2, 0, 0, 0, 0)
           31  +  //   ( 0, 0, 0,+2, 0, 0)
           32  +  //   (+1,+1, 0, 0,+1,+1)
           33  +  //   ( 0, 0,+1,+1,+1,+1)
           34  +  //   ( 0, 0, 0, 0,+2,+2)
           35  +  //   (-1,+1, 0, 0,+1,+1)
           36  +  //   ( 0, 0,-1,+1,+1,+1)
           37  +  vector<int> result;
           38  +  if(sF!=kF)
           39  +   return result;
           40  +
           41  +  for(int f=0; 2*f<=sF; ++f)
           42  +  {
           43  +   int ff = sF - 2*f;
           44  +   if( kJ-ff>=0 && sB-ff>=0 )
           45  +   {
           46  +    vector<int> c = calc(sJ+ff, kJ-ff, sB+ff, kB-ff);
           47  +    if( !c.empty() )
           48  +    {
           49  +     c[0] += f+ff;
           50  +     c[1] += f+ff;
           51  +     if( result.empty() )
           52  +      result = c;
           53  +     else {
           54  +      result[0] = min(result[0],c[0]);
           55  +      result[1] = max(result[1],c[1]);
           56  +     }
           57  +    }
           58  +   }
           59  +  }
           60  +  return result;
           61  + }
           62  + vector<int> calc(int sJ, int kJ, int sB, int kB)
           63  + {
           64  +  // init:
           65  +  //   ( 0, 0, 0, 0,)
           66  +  // possible transitions:
           67  +  //   (+1,+1, 0, 0)
           68  +  //   ( 0, 0,+1,+1)
           69  +  //   ( 0,+2, 0, 0)
           70  +  //   ( 0, 0, 0,+2)
           71  +  if(kJ<sJ || kB<sB || (kJ-sJ)%2==1 || (kB-sB)%2==1)
           72  +   return vector<int>();
           73  +  return vector<int>(2, sJ+(kJ-sJ)/2 + sB+(kB-sB)/2);
           74  + }
           75  +};
           76  +
           77  +// BEGIN CUT HERE
           78  +#include <ctime>
           79  +double start_time; string timer()
           80  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           81  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           82  + { os << "{ ";
           83  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           84  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           85  +void verify_case(const vector <int>& Expected, const vector <int>& Received) {
           86  + bool ok = (Expected == Received);
           87  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           88  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           89  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           90  +#define END  verify_case(_, TheBoringGameDivOne().find(scoreJ, killedJ, scoreB, killedB, scoreF, killedF));}
           91  +int main(){
           92  +
           93  +CASE(0)
           94  + int scoreJ = 1;
           95  + int killedJ = 1;
           96  + int scoreB = 1;
           97  + int killedB = 1;
           98  + int scoreF = 2;
           99  + int killedF = 2;
          100  + int __[] = {2, 3 };
          101  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          102  +END
          103  +CASE(1)
          104  + int scoreJ = 0;
          105  + int killedJ = 0;
          106  + int scoreB = 0;
          107  + int killedB = 0;
          108  + int scoreF = 0;
          109  + int killedF = 0;
          110  + int __[] = {0, 0 };
          111  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          112  +END
          113  +CASE(2)
          114  + int scoreJ = 4;
          115  + int killedJ = 7;
          116  + int scoreB = -2;
          117  + int killedB = 5;
          118  + int scoreF = 1;
          119  + int killedF = 9;
          120  + vector <int> _;
          121  +END
          122  +CASE(3)
          123  + int scoreJ = 1;
          124  + int killedJ = 5;
          125  + int scoreB = -1;
          126  + int killedB = 4;
          127  + int scoreF = 3;
          128  + int killedF = 6;
          129  + int __[] = {8, 9 };
          130  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          131  +END
          132  +/*
          133  +CASE(4)
          134  + int scoreJ = ;
          135  + int killedJ = ;
          136  + int scoreB = ;
          137  + int killedB = ;
          138  + int scoreF = ;
          139  + int killedF = ;
          140  + int __[] = ;
          141  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          142  +END
          143  +CASE(5)
          144  + int scoreJ = ;
          145  + int killedJ = ;
          146  + int scoreB = ;
          147  + int killedB = ;
          148  + int scoreF = ;
          149  + int killedF = ;
          150  + int __[] = ;
          151  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          152  +END
          153  + */
          154  +}
          155  +// END CUT HERE

Added SRM/490-U/1A.cpp version [d56c04a6bea2df82]

            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  +int gcd(int a, int b)
           23  +{
           24  + while(a)
           25  +  swap(a, b%=a);
           26  + return b;
           27  +}
           28  +
           29  +class Starport { public:
           30  + double getExpectedTime(int N, int M)
           31  + {
           32  +  return (N-gcd(N,M)) / 2.0;
           33  + }
           34  +};
           35  +
           36  +// BEGIN CUT HERE
           37  +#include <ctime>
           38  +double start_time; string timer()
           39  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           40  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           41  + { os << "{ ";
           42  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           43  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           44  +void verify_case(const double& Expected, const double& Received) {
           45  + bool ok = (abs(Expected - Received) < 1e-9);
           46  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           47  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           48  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           49  +#define END  verify_case(_, Starport().getExpectedTime(N, M));}
           50  +int main(){
           51  +
           52  +CASE(0)
           53  + int N = 4;
           54  + int M = 2;
           55  + double _ = 1.0;
           56  +END
           57  +CASE(1)
           58  + int N = 5;
           59  + int M = 3;
           60  + double _ = 2.0;
           61  +END
           62  +CASE(2)
           63  + int N = 6;
           64  + int M = 1;
           65  + double _ = 2.5;
           66  +END
           67  +CASE(3)
           68  + int N = 12345;
           69  + int M = 2345;
           70  + double _ = 6170.0;
           71  +END
           72  +CASE(3)
           73  + int N = 1;
           74  + int M = 1;
           75  + double _ = 0;
           76  +END
           77  +CASE(3)
           78  + int N = 1;
           79  + int M = 100;
           80  + double _ = 0;
           81  +END
           82  +CASE(3)
           83  + int N = 2;
           84  + int M = 1;
           85  + double _ = 0.5;
           86  +END
           87  +CASE(7)
           88  + int N = 6;
           89  + int M = 4;
           90  + double _ = 2;
           91  +END
           92  +CASE(7)
           93  + int N = 4;
           94  + int M = 6;
           95  + double _ = 1;
           96  +END
           97  +CASE(4)
           98  + int N = 3;
           99  + int M = 1000000000;
          100  + double _ = -1;
          101  +END
          102  +CASE(5)
          103  + int N = 1000000000;
          104  + int M = 3;
          105  + double _ = -1;
          106  +END
          107  +CASE(6)
          108  + int N = 1000000000;
          109  + int M = 1000000000;
          110  + double _ = -1;
          111  +END
          112  +
          113  +}
          114  +// END CUT HERE

Added SRM/490-U/1B.cpp version [67cc5158338e6e25]

            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 QuickT9 { public:
           23  + int minimumPressings(vector <string> t9, string word)
           24  + {
           25  +  map< string, set<string> > D2U;
           26  +  for(int i=0; i<t9.size(); ++i) {
           27  +   stringstream sin(t9[i]);
           28  +   for(string u;sin>>u;) {
           29  +    string d;
           30  +    for(int i=0; i<u.size(); ++i) {
           31  +     if(u[i]<='c') d+='2';
           32  +     else if(u[i]<='f') d+='3';
           33  +     else if(u[i]<='i') d+='4';
           34  +     else if(u[i]<='l') d+='5';
           35  +     else if(u[i]<='o') d+='6';
           36  +     else if(u[i]<='s') d+='7';
           37  +     else if(u[i]<='v') d+='8';
           38  +     else if(u[i]<='z') d+='9';
           39  +     D2U[d].insert( u.substr(0,i+1) );
           40  +    }
           41  +   }
           42  +  }
           43  +  return rec(D2U, word, 0, "", "");
           44  + }
           45  +
           46  + // Now, the state is F=word[0..i), D=D, U=U. What is the minimal number of steps from here?
           47  + // It is computed by simply implementing the problem statement, with memoization.
           48  + map<pair<int,string>, int> memo;
           49  + int rec( map< string, set<string> >& D2U, const string& word, int i, const string& D, const string& U )
           50  + {
           51  +  if( i == word.size() ) return 0;
           52  +  if( i < 0 )            return -1;
           53  +
           54  +  pair<int,string> key(i,U);
           55  +  if( memo.count(key) )
           56  +   return memo[key];
           57  +  memo[key] = -1; // avoid cyclic dependency
           58  +
           59  +  int best = -1;
           60  +  #define UPDATE(s,k) { if(s!=-1 && (best==-1 || s+(k)<best)) best=s+(k); }
           61  +
           62  +  // try RIGHT
           63  +  {
           64  +   int cp = 0;
           65  +   while( i+cp<word.size() && cp<U.size() && word[i+cp] == U[cp] )
           66  +    ++cp;
           67  +   int k = U.size()-cp;
           68  +   int s = rec(D2U, word, i+U.size()-k, "", "");
           69  +   UPDATE(s,k+1);
           70  +  }
           71  +  // try C
           72  +  {
           73  +   int cp = 0;
           74  +   while( i+cp<word.size() && cp<U.size() && word[i+cp] == U[cp] )
           75  +    ++cp;
           76  +   int k = U.size()-cp;
           77  +   if(k==0) k=1; // the only difference is here
           78  +   int s = rec(D2U, word, i+U.size()-k, "", "");
           79  +   UPDATE(s,k);
           80  +  }
           81  +  // try *
           82  +  if( !D.empty() ) {
           83  +   set<string>& Us = D2U[D];
           84  +   set<string>::iterator it = Us.find(U);
           85  +   ++it;
           86  +   if( it == Us.end() )
           87  +    it = Us.begin();
           88  +   int s = rec(D2U, word, i, D, *it);
           89  +   UPDATE(s,1);
           90  +  }
           91  +  // try 2-9
           92  +  for(char c='2'; c<='9'; ++c)
           93  +  {
           94  +   string nextD = D + c;
           95  +   if( D2U.count(nextD) ) {
           96  +    set<string>& Us = D2U[nextD];
           97  +    int s = rec(D2U, word, i, nextD, *Us.begin());
           98  +    UPDATE(s,1);
           99  +   }
          100  +  }
          101  +  // done
          102  +  return memo[key] = best;
          103  + }
          104  +};
          105  +
          106  +// BEGIN CUT HERE
          107  +#include <ctime>
          108  +double start_time; string timer()
          109  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          110  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          111  + { os << "{ ";
          112  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          113  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          114  +void verify_case(const int& Expected, const int& Received) {
          115  + bool ok = (Expected == Received);
          116  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          117  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          118  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          119  +#define END  verify_case(_, QuickT9().minimumPressings(t9, word));}
          120  +int main(){
          121  +
          122  +CASE(0)
          123  + string t9_[] = {"aae", "bab", "abad", "bdbd", "beta"};
          124  +   vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_));
          125  + string word = "babe";
          126  + int _ = 9;
          127  +END
          128  +CASE(1)
          129  + string t9_[] = {"ann","ie"};
          130  +   vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_));
          131  + string word = "annie";
          132  + int _ = 7;
          133  +END
          134  +CASE(2)
          135  + string t9_[] = {"ann","amm"};
          136  +   vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_));
          137  + string word = "annie";
          138  + int _ = -1;
          139  +END
          140  +CASE(3)
          141  + string t9_[] = {"aaa aab","aac aba abb ccca"};
          142  +   vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_));
          143  + string word = "aba";
          144  + int _ = 6;
          145  +END
          146  +CASE(4)
          147  + string t9_[] = {"acac aba aaab","aab aa baa","bba bacade abb","baba"};
          148  +   vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_));
          149  + string word = "abbaca";
          150  + int _ = 10;
          151  +END
          152  +CASE(5)
          153  + string t9_[] = {"aaa aab aac","aba abb","ccca"};
          154  +   vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_));
          155  + string word = "ccc";
          156  + int _ = 5;
          157  +END
          158  +CASE(6)
          159  +string t9_[] = {"abc"};
          160  +   vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_));
          161  + string word = "a";
          162  + int _ = 2;
          163  +END
          164  +/*
          165  +CASE(7)
          166  + string t9_[] = ;
          167  +   vector <string> t9(t9_, t9_+sizeof(t9_)/sizeof(*t9_));
          168  + string word = ;
          169  + int _ = ;
          170  +END
          171  +*/
          172  +}
          173  +// END CUT HERE

Added SRM/490-U/1C-U.cpp version [2698a1e7c9451719]

            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 InfiniteLab { public:
           23  + long long getDistance(vector <string> map, long long r1, int c1, long long r2, int c2)
           24  + {
           25  +  LL H = map.size();
           26  +  LL W = map[0].size();
           27  +
           28  +  if( r1 > r2 ) {
           29  +   swap(r1,r2);
           30  +   swap(c1,c2);
           31  +  }
           32  +  if( r1 < 0 ) {
           33  +   // check!!!!
           34  +   LL Hx = (-r1/H + 1)*H;
           35  +   r1 += Hx;
           36  +   r2 += Hx;
           37  +  }
           38  +  cerr << r1 << " " << r2 << endl;
           39  +
           40  +  vector<string> mmm(map);
           41  +  mmm.insert(mmm.end(), map.begin(), map.end());
           42  +  mmm.insert(mmm.end(), map.begin(), map.end());
           43  +
           44  +  if( r1/H == r2/H )
           45  +   return dist(mmm, H+(r1%H), c1, H+(r2%H), c2);
           46  +  return -1;
           47  +
           48  +  // top to top
           49  +  vector<vector<LL> > tochu(W, vector<LL>(W, -1));
           50  +  for(int x1=0; x1<W; ++x1) if( map[0][x1] != '#' )
           51  +  for(int x2=0; x2<W; ++x2) if( map[0][x2] != '#' )
           52  +   tochu[x1][x2] = dist( mmm, H, x1, H*2, x2 );
           53  +
           54  +  // r1c1 to top
           55  +  vector<LL> from(W, -1);
           56  +  for(int x1=0; x1<W; ++x1) if( map[0][x1] != '#' )
           57  +   from[W] = dist( mmm, H+(r1%H), c1, H*2, x1 );
           58  +
           59  +  // top to r2c2
           60  +  vector<LL> to(W, -1);
           61  +  for(int x1=0; x1<W; ++x1) if( map[0][x1] != '#' )
           62  +   to[W] = dist( mmm, H, x1, H*2+(r2%H), c2 );
           63  +
           64  +  LL best = -1;
           65  +  for(int i=0; i<from.size(); ++i) if( from[i]>=0 )
           66  +   for(int j=0; j<to.size(); ++j) if( to[j]>=0 )
           67  +   {
           68  +    LL sc = from[i] + to[j];
           69  +    LL s2 = -1; // TODO!
           70  +    if( s2 != -1 && (best == -1 || s2+sc<best) )
           71  +     best = s2+sc;
           72  +   }
           73  +  return best;
           74  + }
           75  +
           76  + LL dist(vector<string>& mmm, LL y1, LL x1, LL y2, LL x2)
           77  + {
           78  +  vector< pair<LL,LL> > Q;
           79  +  set< pair<LL,LL> > V;
           80  +  Q.push_back( make_pair(y1,x1) );
           81  +  V.insert( make_pair(y1,x1) );
           82  +  for(int d=0; !Q.empty(); ++d)
           83  +  {
           84  +   vector< pair<LL,LL> > Q_next;
           85  +   for(int i=0; i<Q.size(); ++i)
           86  +   {
           87  +    LL y = Q[i].first;
           88  +    LL x = Q[i].second;
           89  +    if( y==y2 && x==x2 )
           90  +     return d;
           91  +    int dy[] = {-1,+1,0,0};
           92  +    int dx[] = {0,0,-1,+1};
           93  +    for(int i=0; i<4; ++i) {
           94  +     LL yy = y+dy[i];
           95  +     LL xx = x+dx[i];
           96  +     if( 0<=yy && yy<mmm.size() && 0<=xx && xx<mmm[0].size() && mmm[yy][xx]!='#' ) {
           97  +      pair<LL,LL> p(yy,xx);
           98  +      if( ! V.count(p) ) {
           99  +       V.insert(p);
          100  +       Q_next.push_back(p);
          101  +      }
          102  +     }
          103  +    }
          104  +    if( mmm[y][x] == 'T' ) {
          105  +     for(int xt=0; xt<mmm[y].size(); ++xt) if(xt!=x && mmm[y][xt]=='T') {
          106  +      pair<LL,LL> p(y,xt);
          107  +      if( ! V.count(p) ) {
          108  +       V.insert(p);
          109  +       Q_next.push_back(p);
          110  +      }
          111  +      break;
          112  +     }
          113  +    }
          114  +   }
          115  +   Q_next.swap(Q);
          116  +  }
          117  +  return -1;
          118  + }
          119  +};
          120  +
          121  +// BEGIN CUT HERE
          122  +#include <ctime>
          123  +double start_time; string timer()
          124  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          125  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          126  + { os << "{ ";
          127  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          128  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          129  +void verify_case(const long long& Expected, const long long& Received) {
          130  + bool ok = (Expected == Received);
          131  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          132  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          133  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          134  +#define END  verify_case(_, InfiniteLab().getDistance(map, r1, c1, r2, c2));}
          135  +int main(){
          136  +
          137  +CASE(0)
          138  + string map_[] = {"#...##",
          139  + ".##...",
          140  + "..#.##",
          141  + "#.#.##"};
          142  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          143  + long long r1 = 1LL;
          144  + int c1 = 0;
          145  + long long r2 = 5LL;
          146  + int c2 = 3;
          147  + long long _ = 7LL;
          148  +END
          149  +CASE(1)
          150  + string map_[] = {"##.#.",
          151  + ".#T#T",
          152  + "...#.",
          153  + "##.#."};
          154  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          155  + long long r1 = 7LL;
          156  + int c1 = 4;
          157  + long long r2 = 1LL;
          158  + int c2 = 0;
          159  + long long _ = 9LL;
          160  +END
          161  +CASE(2)
          162  + string map_[] = {"..######.#",
          163  + ".###T###.T",
          164  + "..T#.##T##",
          165  + ".######..#"};
          166  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          167  + long long r1 = 1LL;
          168  + int c1 = 0;
          169  + long long r2 = 6LL;
          170  + int c2 = 4;
          171  + long long _ = 11LL;
          172  +END
          173  +CASE(3)
          174  + string map_[] = {"..#..",
          175  + ".#.#.",
          176  + "....."};
          177  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          178  + long long r1 = -29LL;
          179  + int c1 = 2;
          180  + long long r2 = 19LL;
          181  + int c2 = 2;
          182  + long long _ = 54LL;
          183  +END
          184  +CASE(4)
          185  + string map_[] = {".#.#.",
          186  + "..#..",
          187  + ".....",
          188  + ".....",
          189  + "..#.."};
          190  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          191  + long long r1 = -999LL;
          192  + int c1 = 3;
          193  + long long r2 = 100LL;
          194  + int c2 = 2;
          195  + long long _ = -1LL;
          196  +END
          197  +/*
          198  +CASE(5)
          199  + string map_[] = ;
          200  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          201  + long long r1 = LL;
          202  + int c1 = ;
          203  + long long r2 = LL;
          204  + int c2 = ;
          205  + long long _ = LL;
          206  +END
          207  +CASE(6)
          208  + string map_[] = ;
          209  +   vector <string> map(map_, map_+sizeof(map_)/sizeof(*map_));
          210  + long long r1 = LL;
          211  + int c1 = ;
          212  + long long r2 = LL;
          213  + int c2 = ;
          214  + long long _ = LL;
          215  +END
          216  +*/
          217  +}
          218  +// END CUT HERE

Added SRM/491/1A.cpp version [ec3c7b925e5f4d41]

            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 FoxMakingDice { public:
           23  + long long theCount(int N, int K)
           24  + {
           25  +  LL cnt = 0;
           26  +  for(int sum=K; sum<=N+N; ++sum)
           27  +  {
           28  +   LL v = 0;
           29  +   for(int s=1; s<=N; ++s)
           30  +    if( s<sum-s && 1<=sum-s && sum-s<=N )
           31  +     ++v;
           32  +   cnt += v*(v-1)*(v-2)/6*2;
           33  +  }
           34  +  return cnt;
           35  + }
           36  +};
           37  +
           38  +// BEGIN CUT HERE
           39  +#include <ctime>
           40  +double start_time; string timer()
           41  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           42  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           43  + { os << "{ ";
           44  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           45  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           46  +void verify_case(const long long& Expected, const long long& Received) {
           47  + bool ok = (Expected == Received);
           48  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           49  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           50  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           51  +#define END  verify_case(_, FoxMakingDice().theCount(N, K));}
           52  +int main(){
           53  +
           54  +CASE(0)
           55  + int N = 6;
           56  + int K = 7;
           57  + long long _ = 2LL;
           58  +END
           59  +CASE(1)
           60  + int N = 5;
           61  + int K = 7;
           62  + long long _ = 0LL;
           63  +END
           64  +CASE(2)
           65  + int N = 1000;
           66  + int K = 1;
           67  + long long _ = 20625666000LL;
           68  +END
           69  +CASE(3)
           70  + int N = 456;
           71  + int K = 123;
           72  + long long _ = 879075732LL;
           73  +END
           74  +CASE(4)
           75  + int N = 913;
           76  + int K = 1014;
           77  + long long _ = 4506149340LL;
           78  +END
           79  +CASE(5)
           80  + int N = 1000;
           81  + int K = 2000;
           82  + long long _ = -1LL;
           83  +END
           84  +CASE(6)
           85  + int N = 1;
           86  + int K = 7;
           87  + long long _ = 0LL;
           88  +END
           89  +CASE(6)
           90  + int N = 2;
           91  + int K = 7;
           92  + long long _ = 0LL;
           93  +END
           94  +CASE(6)
           95  + int N = 3;
           96  + int K = 7;
           97  + long long _ = 0LL;
           98  +END
           99  +CASE(6)
          100  + int N = 4;
          101  + int K = 7;
          102  + long long _ = 0LL;
          103  +END
          104  +CASE(6)
          105  + int N = 5;
          106  + int K = 7;
          107  + long long _ = 0LL;
          108  +END
          109  +
          110  +}
          111  +// END CUT HERE

Added SRM/491/1B.cpp version [258b2dbb2f8262f7]

            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 PrefixTree { public:
           23  + static vector<int> wordToFreq( const string& word )
           24  + {
           25  +  vector<int> freq(26);
           26  +  for(int i=0; i<word.size(); ++i)
           27  +   freq[word[i]-'a']++;
           28  +  return freq;
           29  + }
           30  +
           31  + static vector< vector<int> > wordsToFreqs( const vector<string>& words )
           32  + {
           33  +  vector< vector<int> > freqs;
           34  +  transform(words.begin(), words.end(), back_inserter(freqs), &wordToFreq);
           35  +  return freqs;
           36  + }
           37  +
           38  + static int commonPrefix(const vector< vector<int> >& freqs, int s)
           39  + {
           40  +  vector<int> common;
           41  +  for(int first=1,i=0; (1<<i)<=s; ++i)
           42  +   if( s & (1<<i) )
           43  +    if( first ) {
           44  +     common = freqs[i];
           45  +     first = 0;
           46  +    } else {
           47  +     for(int k=0; k<26; ++k)
           48  +      common[k] = min(common[k], freqs[i][k]);
           49  +    }
           50  +  return accumulate(common.begin(), common.end(), 0);
           51  + }
           52  +
           53  + int getNumNodes(vector<string> words)
           54  + {
           55  +  const int N = words.size();
           56  +  const vector< vector<int> >& freqs = wordsToFreqs(words);
           57  +
           58  +  vector<int> dp(1<<N);
           59  +  for(int s=1; s<(1<<N); ++s)
           60  +  {
           61  +   dp[s] = 1;
           62  +   for(int i=0; i<N; ++i)
           63  +    if( s & (1<<i) )
           64  +     dp[s] += words[i].size();
           65  +
           66  +   int cp = commonPrefix(freqs, s);
           67  +   for(int ss=s-1; ss&=s; --ss)
           68  +    dp[s] = min(dp[s], dp[ss]+dp[s&~ss]-cp-1);
           69  +  }
           70  +  return dp[(1<<N)-1];
           71  + }
           72  +};
           73  +
           74  +// BEGIN CUT HERE
           75  +#include <ctime>
           76  +double start_time; string timer()
           77  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           78  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           79  + { os << "{ ";
           80  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           81  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           82  +void verify_case(const int& Expected, const int& Received) {
           83  + bool ok = (Expected == Received);
           84  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           85  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           86  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           87  +#define END  verify_case(_, PrefixTree().getNumNodes(words));}
           88  +int main(){
           89  +
           90  +CASE(0)
           91  + string words_[] = {"topcoder"};
           92  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
           93  + int _ = 9;
           94  +END
           95  +CASE(1)
           96  + string words_[] = {"topcoder","topcoder"};
           97  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
           98  + int _ = 9;
           99  +END
          100  +CASE(2)
          101  + string words_[] = {"aab","ca"};
          102  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          103  + int _ = 5;
          104  +END
          105  +CASE(3)
          106  + string words_[] = {"aab","ca","ba"};
          107  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          108  + int _ = 5;
          109  +END
          110  +CASE(4)
          111  + string words_[] = {"ab","cd","ef"};
          112  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          113  + int _ = 7;
          114  +END
          115  +CASE(5)
          116  + string words_[] = {"a","aa","aaa"};
          117  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          118  + int _ = 4;
          119  +END
          120  +/*
          121  +CASE(6)
          122  + string words_[] = ;
          123  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          124  + int _ = ;
          125  +END
          126  +CASE(7)
          127  + string words_[] = ;
          128  +   vector <string> words(words_, words_+sizeof(words_)/sizeof(*words_));
          129  + int _ = ;
          130  +END
          131  +*/
          132  +}
          133  +// END CUT HERE

Added SRM/491/1C.cpp version [fc13d82ca1ace550]

            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  +template<typename T>
           23  +class IdGen
           24  +{
           25  + map<T, int> v2id_;
           26  + vector<T>   id2v_;
           27  +public:
           28  + int v2id(const T& v) {
           29  +  if( !v2id_.count(v) ) { v2id_[v] = size(); id2v_.push_back(v); }
           30  +  return v2id_[v];
           31  + }
           32  + const T& id2v(int i) const { return id2v_[i]; }
           33  + int size() const { return id2v_.size(); }
           34  +};
           35  +
           36  +template<typename Vert, typename Cost, typename Flow, int NV=256>
           37  +class MinCostFlow
           38  +{
           39  + IdGen<Vert> idgen;
           40  +
           41  + vector<int> G[NV];
           42  + Flow F[NV][NV];
           43  + Cost C[NV][NV];
           44  +
           45  +public:
           46  + void addEdge( Vert s_, Vert t_, Cost c, Flow f )
           47  + {
           48  +  int s = idgen.v2id(s_), t = idgen.v2id(t_);
           49  +  G[s].push_back(t);
           50  +  G[t].push_back(s);
           51  +  C[s][t] = c;
           52  +  C[t][s] = -c;
           53  +  F[s][t] = f;
           54  +  F[t][s] = 0;
           55  + }
           56  +
           57  + pair<Cost, Flow> calc( Vert s_, Vert t_ )
           58  + {
           59  +  const int N=idgen.size(), S=idgen.v2id(s_), T=idgen.v2id(t_);
           60  +  static const Cost COST_INF = 1e+300; // !!EDIT HERE!!
           61  +  static const Flow FLOW_INF = 0x7fffffff;
           62  +
           63  +  Cost total_cost = 0;
           64  +  Flow total_flow = 0;
           65  +  vector<Cost> h(N, 0); // potential
           66  +  for(Flow RF=FLOW_INF; RF>0; ) // residual flow
           67  +  {
           68  +   // Dijkstra -- find the min-cost path
           69  +   vector<Cost> d(N, COST_INF);  d[S] = 0;
           70  +   vector<int>  prev(N, -1);
           71  +
           72  +   typedef pair< Cost, pair<int,int> > cedge;
           73  +   priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           74  +   Q.push( cedge(0, make_pair(S,S)) );
           75  +   while( !Q.empty() ) {
           76  +    cedge e = Q.top(); Q.pop();
           77  +    if( prev[e.second.second] >= 0 )
           78  +     continue;
           79  +    prev[e.second.second] = e.second.first;
           80  +
           81  +    int u = e.second.second;
           82  +    for(int i=0; i<G[u].size(); ++i) {
           83  +     int  v = G[u][i];
           84  +     Cost r_cost = C[u][v] + h[u] - h[v];
           85  +     if( F[u][v] > 0 && d[v] > d[u]+r_cost )
           86  +      Q.push( cedge(d[v]=d[u]+r_cost, make_pair(u,v)) );
           87  +    }
           88  +   }
           89  +
           90  +   if( prev[T] < 0 )
           91  +    break; // Finished
           92  +
           93  +   // Run the flow as much as possible
           94  +   Flow f = RF;
           95  +   for(int u=T; u!=S; u=prev[u])
           96  +    f = min(f, F[prev[u]][u]);
           97  +   RF         -= f;
           98  +   total_flow += f;
           99  +
          100  +   for(int u=T; u!=S; u=prev[u])
          101  +   {
          102  +    total_cost    += f * C[prev[u]][u];
          103  +    F[prev[u]][u] -= f;
          104  +    F[u][prev[u]] += f;
          105  +   }
          106  +
          107  +   // Update the potential
          108  +   for(int u=0; u<N; ++u)
          109  +    h[u] += d[u];
          110  +  }
          111  +  return make_pair(total_cost, total_flow);
          112  + }
          113  +};
          114  +
          115  +class FoxCardGame { public:
          116  + double theMaxProportion(vector <double> pileA, vector <double> pileB, int k)
          117  + {
          118  +  double L=1, R=50;
          119  +  for(int i=0; i<50; ++i)
          120  +   (possible(pileA, pileB, k, (L+R)/2) ? L : R) = (L+R)/2;
          121  +  return L;
          122  + }
          123  +
          124  + enum Tag {Src, Left, Right, Target, Goal};
          125  + bool possible(vector <double> pileA, vector <double> pileB, int k, double R)
          126  + {
          127  +  MinCostFlow<pair<Tag,int>, double, int> mcf;
          128  +
          129  +  for(int a=0; a<pileA.size(); ++a)
          130  +   mcf.addEdge( make_pair(Src,0), make_pair(Left,a), 0.0, 1 );
          131  +  for(int a=0; a<pileA.size(); ++a)
          132  +  for(int b=0; b<pileB.size(); ++b)
          133  +  {
          134  +   double x_ = pileA[a]+pileB[b], y_ = pileA[a]*pileB[b];
          135  +   double x = max(x_,y_), y = min(x_,y_);
          136  +   mcf.addEdge( make_pair(Left,a), make_pair(Right,b), R*y-x+10000.0, 1 );
          137  +  }
          138  +  for(int b=0; b<pileB.size(); ++b)
          139  +   mcf.addEdge( make_pair(Right,b), make_pair(Target,0), 0.0, 1 );
          140  +  mcf.addEdge( make_pair(Target,0), make_pair(Goal,0), 0.0, k );
          141  +
          142  +  return mcf.calc( make_pair(Src,0), make_pair(Goal,0) ).first <= 10000.0*k;
          143  + }
          144  +};
          145  +
          146  +// BEGIN CUT HERE
          147  +#include <ctime>
          148  +double start_time; string timer()
          149  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          150  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          151  + { os << "{ ";
          152  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          153  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          154  +void verify_case(const double& Expected, const double& Received) {
          155  + bool ok = (abs(Expected - Received) < 1e-9);
          156  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          157  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          158  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          159  +#define END  verify_case(_, FoxCardGame().theMaxProportion(pileA, pileB, k));}
          160  +int main(){
          161  +
          162  +CASE(0)
          163  + double pileA_[] = {1, 2, 3};
          164  +   vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_));
          165  + double pileB_[] = {4, 5, 6};
          166  +   vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_));
          167  + int k = 2;
          168  + double _ = 1.7692307692309948;
          169  +END
          170  +CASE(1)
          171  + double pileA_[] = {1.234, 5.678, 9.012, 3.456, 7.89};
          172  +   vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_));
          173  + double pileB_[] = {2.345, 6.789, 9.876, 5.432, 1.012};
          174  +   vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_));
          175  + int k = 3;
          176  + double _ = 4.159424420079586;
          177  +END
          178  +CASE(2)
          179  + double pileA_[] = {1, 1.1, 1.2, 1.3, 1.4, 1.5};
          180  +   vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_));
          181  + double pileB_[] = {5, 10, 15, 20, 25, 30};
          182  +   vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_));
          183  + int k = 2;
          184  + double _ = 1.3972602739726827;
          185  +END
          186  +CASE(3)
          187  + double pileA_[] = {85.302, 92.798, 76.813, 37.994, 36.737, 98.659};
          188  +   vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_));
          189  + double pileB_[] = {13.352, 7.3094, 54.761, 8.2706, 63.223, 37.486};
          190  +   vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_));
          191  + int k = 3;
          192  + double _ = 33.58603889836175;
          193  +END
          194  +CASE(4)
          195  + double pileA_[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0};
          196  +   vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_));
          197  + double pileB_[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0};
          198  +   vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_));
          199  + int k = 50;
          200  + double _ = 16.846938775510203;
          201  +END
          202  +/*
          203  +CASE(5)
          204  + double pileA_[] = ;
          205  +   vector <double> pileA(pileA_, pileA_+sizeof(pileA_)/sizeof(*pileA_));
          206  + double pileB_[] = ;
          207  +   vector <double> pileB(pileB_, pileB_+sizeof(pileB_)/sizeof(*pileB_));
          208  + int k = ;
          209  + double _ = ;
          210  +END
          211  +*/
          212  +}
          213  +// END CUT HERE

Added SRM/491/2C.cpp version [ba05691b3037f752]

            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  +LL gcd(LL a, LL b)
           23  +{
           24  + while(a)
           25  +  swap(a, b%=a);
           26  + return b;
           27  +}
           28  +
           29  +LL lcm(LL a, LL b)
           30  +{
           31  + return a/gcd(a,b)*b;
           32  +}
           33  +
           34  +class BottlesOnShelf { public:
           35  + int getNumBroken(int N, vector <int> left, vector <int> right, vector <int> damage)
           36  + {
           37  +  int total = 0;
           38  +  for(int mask=1; mask<(1<<left.size()); ++mask)
           39  +   total += (bitcnt(mask)%2==0 ? -1 : +1) * hit(N, left, right, damage, mask);
           40  +  return total;
           41  + }
           42  +
           43  + int bitcnt(int m)
           44  + {
           45  +  int c = 0;
           46  +  for(; m; m>>=1)
           47  +   c += (m&1);
           48  +  return c;
           49  + }
           50  +
           51  + LL ceil(LL x, LL q)
           52  + {
           53  +  return (x + q - 1) / q * q;
           54  + }
           55  +
           56  + int hit(int N, vector <int> left, vector <int> right, vector <int> damage, int mask)
           57  + {
           58  +  LL theLeft   = 1;
           59  +  LL theRight  = N+1;
           60  +  LL theDamage = 1;
           61  +  for(int i=0; i<left.size(); ++i)
           62  +   if( mask & (1<<i) )
           63  +   {
           64  +    theLeft   = max<LL>(theLeft,  left[i]);
           65  +    theRight  = min<LL>(theRight, right[i]+1);
           66  +    theDamage = lcm(theDamage, damage[i]);
           67  +   }
           68  +  return int( max(0LL, ceil(theRight,theDamage)-ceil(theLeft,theDamage)) / theDamage );
           69  + }
           70  +};
           71  +
           72  +// BEGIN CUT HERE
           73  +#include <ctime>
           74  +double start_time; string timer()
           75  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           76  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           77  + { os << "{ ";
           78  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           79  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           80  +void verify_case(const int& Expected, const int& Received) {
           81  + bool ok = (Expected == Received);
           82  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           83  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           84  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           85  +#define END  verify_case(_, BottlesOnShelf().getNumBroken(N, left, right, damage));}
           86  +int main(){
           87  +
           88  +CASE(0)
           89  + int N = 7;
           90  + int left_[] = {1};
           91  +   vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_));
           92  + int right_[] = {7};
           93  +   vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_));
           94  + int damage_[] = {2};
           95  +   vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_));
           96  + int _ = 3;
           97  +END
           98  +CASE(1)
           99  + int N = 7;
          100  + int left_[] = {1,1};
          101  +   vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_));
          102  + int right_[] = {7,7};
          103  +   vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_));
          104  + int damage_[] = {2,3};
          105  +   vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_));
          106  + int _ = 4;
          107  +END
          108  +CASE(2)
          109  + int N = 7;
          110  + int left_[] = {1,1,1};
          111  +   vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_));
          112  + int right_[] = {7,7,7};
          113  +   vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_));
          114  + int damage_[] = {2,3,6};
          115  +   vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_));
          116  + int _ = 4;
          117  +END
          118  +CASE(3)
          119  + int N = 10;
          120  + int left_[] = {1,6};
          121  +   vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_));
          122  + int right_[] = {5,10};
          123  +   vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_));
          124  + int damage_[] = {1,7};
          125  +   vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_));
          126  + int _ = 6;
          127  +END
          128  +CASE(4)
          129  + int N = 5;
          130  + int left_[] = {4};
          131  +   vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_));
          132  + int right_[] = {4};
          133  +   vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_));
          134  + int damage_[] = {7};
          135  +   vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_));
          136  + int _ = 0;
          137  +END
          138  +CASE(5)
          139  + int N = 1000000000;
          140  + int left_[] = {1};
          141  +   vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_));
          142  + int right_[] = {1000000000};
          143  +   vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_));
          144  + int damage_[] = {1};
          145  +   vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_));
          146  + int _ = 1000000000;
          147  +END
          148  +/*
          149  +CASE(6)
          150  + int N = ;
          151  + int left_[] = ;
          152  +   vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_));
          153  + int right_[] = ;
          154  +   vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_));
          155  + int damage_[] = ;
          156  +   vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_));
          157  + int _ = ;
          158  +END
          159  +CASE(7)
          160  + int N = ;
          161  + int left_[] = ;
          162  +   vector <int> left(left_, left_+sizeof(left_)/sizeof(*left_));
          163  + int right_[] = ;
          164  +   vector <int> right(right_, right_+sizeof(right_)/sizeof(*right_));
          165  + int damage_[] = ;
          166  +   vector <int> damage(damage_, damage_+sizeof(damage_)/sizeof(*damage_));
          167  + int _ = ;
          168  +END
          169  +*/
          170  +}
          171  +// END CUT HERE

Added SRM/492-U/1A.cpp version [49693ab4e53ef682]

            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  +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  +int ccw(const CMP& a, CMP b, CMP c) {
           25  + b -= a; c -= a;
           26  + if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
           27  + if( outer_prod(b,c) < 0 ) return -1; // clockwise
           28  + if( inner_prod(b,c) < 0 ) return +2; // c--[a--b] on line
           29  + if( norm(b) < norm(c) )   return -2; // [a--b]--c on line
           30  + return 0; // [a--c--b] on line
           31  +}
           32  +
           33  +class TimeTravellingGardener { public:
           34  + int determineUsage(vector <int> distance, vector <int> height)
           35  + {
           36  +  const int N = height.size();
           37  +
           38  +  distance.insert(distance.begin(), 0);
           39  +  partial_sum(distance.begin(), distance.end(), distance.begin());
           40  +
           41  +  vector<CMP> p;
           42  +  for(int i=0; i<N; ++i)
           43  +   p.push_back( CMP(distance[i], height[i]) );
           44  +
           45  +  int best = N-1;
           46  +  for(int i=0; i<N; ++i)
           47  +   for(int j=i+1; j<N; ++j)
           48  +   {
           49  +    best = min(best, score(p[i], p[j], p));
           50  +    best = min(best, score(p[i].real(), p[j], p));
           51  +    best = min(best, score(p[i], p[j].real(), p));
           52  +   }
           53  +  return best;
           54  + }
           55  +
           56  + int score(const CMP& a, const CMP& b, const vector<CMP>& p)
           57  + {
           58  +  int s = 0;
           59  +  for(int i=0; i<p.size(); ++i)
           60  +  {
           61  +   if( ccw(a, b, p[i]) == -1 ) return INT_MAX;
           62  +   if( ccw(a, b, p[i].real()) == +1 ) return INT_MAX;
           63  +   if( ccw(a, b, p[i]) == +1 ) ++s;
           64  +  }
           65  +  return s;
           66  + }
           67  +};
           68  +
           69  +// BEGIN CUT HERE
           70  +#include <ctime>
           71  +double start_time; string timer()
           72  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           73  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           74  + { os << "{ ";
           75  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           76  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           77  +void verify_case(const int& Expected, const int& Received) {
           78  + bool ok = (Expected == Received);
           79  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           80  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           81  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           82  +#define END  verify_case(_, TimeTravellingGardener().determineUsage(distance, height));}
           83  +int main(){
           84  +
           85  +CASE(0)
           86  + int distance_[] = {2,2};
           87  +   vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_));
           88  + int height_[] = {1,3,10};
           89  +   vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_));
           90  + int _ = 1;
           91  +END
           92  +CASE(1)
           93  + int distance_[] = {3,3};
           94  +   vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_));
           95  + int height_[] = {3,1,3};
           96  +   vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_));
           97  + int _ = 2;
           98  +END
           99  +CASE(2)
          100  + int distance_[] = {1,3};
          101  +   vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_));
          102  + int height_[] = {4,4,4};
          103  +   vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_));
          104  + int _ = 0;
          105  +END
          106  +CASE(3)
          107  + int distance_[] = {4,2};
          108  +   vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_));
          109  + int height_[] = {9,8,5};
          110  +   vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_));
          111  + int _ = 1;
          112  +END
          113  +CASE(4)
          114  + int distance_[] = {476,465,260,484};
          115  +   vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_));
          116  + int height_[] = {39,13,8,72,80};
          117  +   vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_));
          118  + int _ = 3;
          119  +END
          120  +CASE(5)
          121  + int distance_[] = {173,36,668,79,26,544};
          122  +   vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_));
          123  + int height_[] = {488,743,203,446,444,91,453};
          124  +   vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_));
          125  + int _ = 5;
          126  +END
          127  +CASE(6)
          128  + int distance_[] = {2,4,2,2,4,2,4,2,2,4};
          129  +   vector <int> distance(distance_, distance_+sizeof(distance_)/sizeof(*distance_));
          130  + int height_[] = {2,2,10,10,10,16,16,22,22,28,28};
          131  +   vector <int> height(height_, height_+sizeof(height_)/sizeof(*height_));
          132  + int _ = 6;
          133  +END
          134  +}
          135  +// END CUT HERE

Added SRM/492-U/1B.cpp version [90d5ca1902401bc0]

            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 LL INF = 0x1fffffffffffffffLL;
           23  +
           24  +template<typename T>
           25  +struct DP3
           26  +{
           27  + int N1, N2, N3;
           28  + vector<T> data;
           29  + DP3(int N1, int N2, int N3, const T& t = T())
           30  +  : N1(N1), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           31  + T& operator()(int i1, int i2, int i3)
           32  +  { return data[ ((i1*N2)+i2)*N3+i3 ]; }
           33  + void swap(DP3& rhs)
           34  +  { data.swap(rhs.data); }
           35  +};
           36  +
           37  +class TimeTravellingTour { public:
           38  + long long determineCost(int N, vector <int> cities, vector <string> roads)
           39  + {
           40  +  vector< vector<LL> > G(N, vector<LL>(N,INF));
           41  +  {
           42  +   string str = accumulate(roads.begin(), roads.end(), string(""));
           43  +   for(int i=0; i<str.size(); ++i)
           44  +    if( str[i] == ',' )
           45  +     str[i] = ' ';
           46  +   stringstream sin(str);
           47  +   for(int a,b,cost; sin>>a>>b>>cost; )
           48  +    G[a][b] = G[b][a] = cost;
           49  +  }
           50  +  for(int i=0; i<N; ++i)
           51  +   G[i][i] = 0;
           52  +  for(int k=0; k<N; ++k)
           53  +   for(int i=0; i<N; ++i)
           54  +    for(int j=0; j<N; ++j)
           55  +     G[i][j] = min(G[i][j], G[i][k]+G[k][j]);
           56  +
           57  +  DP3<LL> memo(N, cities.size()+1, cities.size()+1, -1);
           58  +  LL a = rec( 0, 0, cities.size(), cities, G, memo );
           59  +  return a>=INF ? -1 : a;
           60  + }
           61  +
           62  + LL rec(int cur, int s, int e, const vector<int>& C, const vector< vector<LL> >& G, DP3<LL>& memo )
           63  + {
           64  +  if( s+1 == e )
           65  +   return G[cur][C[s]];
           66  +  if( memo(cur,s,e) >= 0 )
           67  +   return memo(cur,s,e);
           68  +
           69  +  LL best = INF;
           70  +  for(int v=0; v<G[cur].size(); ++v)
           71  +   if( G[cur][v] < INF )
           72  +    for(int m=s+1; m<e; ++m)
           73  +     best = min(best, G[cur][v]+rec(v,s,m,C,G,memo)+rec(v,m,e,C,G,memo));
           74  +  return memo(cur,s,e) = best;
           75  + }
           76  +};
           77  +
           78  +// BEGIN CUT HERE
           79  +#include <ctime>
           80  +double start_time; string timer()
           81  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           82  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           83  + { os << "{ ";
           84  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           85  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           86  +void verify_case(const long long& Expected, const long long& Received) {
           87  + bool ok = (Expected == Received);
           88  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           89  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           90  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           91  +#define END  verify_case(_, TimeTravellingTour().determineCost(N, cities, roads));}
           92  +int main(){
           93  +
           94  +CASE(0)
           95  + int N = 5;
           96  + int cities_[] = {2,3,2,4};
           97  +   vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
           98  + string roads_[] = {"0,2,4 0,1,2 2,1,2 1,3,3 4,0,4"};
           99  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          100  + long long _ = 13LL;
          101  +END
          102  +CASE(1)
          103  + int N = 3;
          104  + int cities_[] = {1,0,1};
          105  +   vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
          106  + string roads_[] = {"0,2,1"," 2",",1,5"};
          107  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          108  + long long _ = 12LL;
          109  +END
          110  +CASE(2)
          111  + int N = 3;
          112  + int cities_[] = {2};
          113  +   vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
          114  + string roads_[] = {"0,1,2"};
          115  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          116  + long long _ = -1LL;
          117  +END
          118  +CASE(3)
          119  + int N = 6;
          120  + int cities_[] = {4, 1, 3, 2};
          121  +   vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
          122  + string roads_[] = {"0,1,5 0,2,5 0,5,2 2,3,5 2,4,2 3,4,4 3,5,1"};
          123  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          124  + long long _ = 19LL;
          125  +END
          126  +/*
          127  +CASE(4)
          128  + int N = ;
          129  + int cities_[] = ;
          130  +   vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
          131  + string roads_[] = ;
          132  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          133  + long long _ = LL;
          134  +END
          135  +CASE(5)
          136  + int N = ;
          137  + int cities_[] = ;
          138  +   vector <int> cities(cities_, cities_+sizeof(cities_)/sizeof(*cities_));
          139  + string roads_[] = ;
          140  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          141  + long long _ = LL;
          142  +END
          143  +*/
          144  +}
          145  +// END CUT HERE

Added SRM/493-U/1A.cpp version [295e562b1438d93f]

            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 StonesGame { public:
           23  + string winner(int N, int M, int K, int L)
           24  + {
           25  +  if( isOneStep(N,M,K,L) ) // M ‚©‚ç L ‚ɈêŽè‚Å‚¢‚¯‚é‚È‚ç�æŽè‚Ì�Ÿ‚¿
           26  +   return "Romeo";
           27  +  for(int x=1; x<=N; ++x)
           28  +   if( isOneStep(N,M,K,x) && !isOneStep(N,x,K,L) )
           29  +    return "Draw"; // �æŽè‚àŒãŽè‚à�Ÿ‚Ä‚È‚¢�ê�‡
           30  +  return "Strangelet"; // M ‚©‚ç‚Í�uL‚ɈêŽè‚Å�s‚¯‚¿‚Ⴄx�v‚É‚µ‚©�s‚¯‚È‚¢‚È‚ç�AŒãŽè‚Ì�Ÿ‚¿
           31  + }
           32  +
           33  + bool isOneStep(int N, int M, int K, int L)
           34  + {
           35  +  int d = abs(M-L);
           36  +  if( d<K && (d%2)!=(K%2) )
           37  +  {
           38  +   int mid = (M+L)/2; // M ‚Æ L ‚Ì�^‚ñ’†‚ð’†�S‚É
           39  +   int e = mid + K/2; // ‰E‚É K/2
           40  +   int b = e - K+1;   // �¶‚É K/2 �L‚΂µ‚½”͈͂ðreverse‚·‚ê‚ÎM‚ªL‚É�s‚¯‚é‚Í‚¸�c
           41  +   return 1<=b && e<=N; // ‚»‚ñ‚Ȕ͈͂őå�ä•v‚©
           42  +  }
           43  +  return false;
           44  + }
           45  +};
           46  +
           47  +// BEGIN CUT HERE
           48  +#include <ctime>
           49  +double start_time; string timer()
           50  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           51  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           52  + { os << "{ ";
           53  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           54  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           55  +void verify_case(const string& Expected, const string& Received) {
           56  + bool ok = (Expected == Received);
           57  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           58  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           59  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           60  +#define END  verify_case(_, StonesGame().winner(N, M, K, L));}
           61  +int main(){
           62  +
           63  +CASE(0)
           64  + int N = 3;
           65  + int M = 1;
           66  + int K = 1;
           67  + int L = 2;
           68  + string _ = "Draw";
           69  +END
           70  +CASE(1)
           71  + int N = 5;
           72  + int M = 1;
           73  + int K = 2;
           74  + int L = 2;
           75  + string _ = "Romeo";
           76  +END
           77  +CASE(2)
           78  + int N = 5;
           79  + int M = 5;
           80  + int K = 2;
           81  + int L = 3;
           82  + string _ = "Strangelet";
           83  +END
           84  +CASE(3)
           85  + int N = 5;
           86  + int M = 5;
           87  + int K = 2;
           88  + int L = 2;
           89  + string _ = "Draw";
           90  +END
           91  +CASE(4)
           92  + int N = 1000000;
           93  + int M = 804588;
           94  + int K = 705444;
           95  + int L = 292263;
           96  + string _ = "Romeo";
           97  +END
           98  +CASE(5)
           99  + int N = 1000000;
          100  + int M = 100000;
          101  + int K = 500000;
          102  + int L = 600000;
          103  + string _ = "Strangelet";
          104  +END
          105  +CASE(6)
          106  + int N = 5;
          107  + int M = 1;
          108  + int K = 3;
          109  + int L = 5;
          110  + string _ = "Strangelet";
          111  +END
          112  +/*
          113  +CASE(7)
          114  + int N = ;
          115  + int M = ;
          116  + int K = ;
          117  + int L = ;
          118  + string _ = ;
          119  +END
          120  +*/
          121  +}
          122  +// END CUT HERE

Added SRM/493-U/1B.cpp version [13f8fe20f39799a2]

            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 AmoebaCode { public:
           23  + // ƒ�ƒCƒ“ƒ‹�[ƒ`ƒ“
           24  + int find(string code, int K)
           25  + {
           26  +  int answer = 1;
           27  +  for(int D=2; D<=K; ++D)
           28  +   if( can(code, K, 0, string(D-1,'X')) ) // �Å�¬‹——£‚ª D ˆÈ�ã‚É‚È‚é‚悤‚É‚Å‚«‚é�H
           29  +    answer = max(answer, D);
           30  +  return answer; // ‚Å‚«‚é‚悤‚È D ‚Ì�Å‘å’l‚ð•Ô‚·
           31  + }
           32  +
           33  + // �ucode[i..$) ‚É 1 �` K ‚ð–„‚ß‚ç‚ê‚é‚©�H�v‚ð�Ä‹A“I‚É”»’è
           34  + // prev ‚É‚Í code[i] ‚Ì’¼‘O D-1 •¶Žš‚ð“ü‚ê‚ČĂÑ�o‚·�B
           35  + // ‚±‚Ì D-1 •¶Žš‚Í”ð‚¯‚È‚¢‚Æ�Å�¬‹——£ D ˆÈ�ã‚É‚È‚ç‚È‚¢‚Ì‚Å”ð‚¯‚Ü‚µ‚傤
           36  + map<pair<size_t,string>, bool> memo;
           37  + bool can(const string& code, const int K, size_t i, const string& prev)
           38  + {
           39  +  if( i == code.size() )
           40  +   return true; // �ÅŒã‚Ü‚Å–„‚Ü‚Á‚½�BOK!
           41  +
           42  +  pair<int,string> key(i, prev);
           43  +  if( memo.count(key) )
           44  +   return memo[key]; // ƒ�ƒ‚‰»�B‚·‚Å‚ÉŒ©‚½ˆø�”‚È‚çŠo‚¦‚Ă錋‰Ê‚ð•Ô‚·
           45  +
           46  +  // code[i] ‚É“ü‚ê‚镶Žš‚ÌŒó•â‚ð—ñ‹“
           47  +  vector<char> cand;
           48  +  if( code[i] == '0' ) // '0' ‚È‚ç 1 ‚©‚ç K ‚Ì‚Ç‚ê‚É’u‚«Š·‚¦‚Ä‚à‚¢‚¢
           49  +   for(int k=1; k<=K; ++k)
           50  +    cand.push_back( char('0'+k) );
           51  +  else // ‚»‚êˆÈŠO‚È‚ç’u‚«Š·‚¦‚ç‚ê‚È‚¢
           52  +   cand.push_back( code[i] );
           53  +
           54  +  bool ok = false;
           55  +  for(int k=0; k<cand.size(); ++k) // Œó•â‚ð‘S•”ŽŽ‚µ‚Ä‚Ý‚é
           56  +   if( count(prev.begin(), prev.end(), cand[k])    // prev ‚ð”ð‚¯‚Ä‚Ä
           57  +    && can(code, K, i+1, prev.substr(1)+cand[k]) ) // code[i+1..$) ‚à‘S•”–„‚ß‚ç‚ê‚ê‚ÎOK
           58  +    ok |= true;
           59  +
           60  +  return memo[key] = ok; // ƒ�ƒ‚‰»‚Ì•\‚É‹L‰¯‚µ‚‚ return
           61  + }
           62  +};
           63  +
           64  +// BEGIN CUT HERE
           65  +#include <ctime>
           66  +double start_time; string timer()
           67  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           68  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           69  + { os << "{ ";
           70  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           71  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           72  +void verify_case(const int& Expected, const int& Received) {
           73  + bool ok = (Expected == Received);
           74  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           75  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           76  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           77  +#define END  verify_case(_, AmoebaCode().find(code, K));}
           78  +int main(){
           79  +
           80  +CASE(0)
           81  + string code = "01";
           82  + int K = 1;
           83  + int _ = 1;
           84  +END
           85  +CASE(1)
           86  + string code = "1001";
           87  + int K = 2;
           88  + int _ = 1;
           89  +END
           90  +CASE(2)
           91  + string code = "1010";
           92  + int K = 2;
           93  + int _ = 2;
           94  +END
           95  +CASE(3)
           96  + string code = "01001";
           97  + int K = 3;
           98  + int _ = 3;
           99  +END
          100  +CASE(4)
          101  + string code = "10012031001";
          102  + int K = 3;
          103  + int _ = 2;
          104  +END
          105  +CASE(5)
          106  + string code = "00000000000000000000000000000000000000000000000000";
          107  + int K = 7;
          108  + int _ = -1;
          109  +END
          110  +/*
          111  +CASE(6)
          112  + string code = ;
          113  + int K = ;
          114  + int _ = ;
          115  +END
          116  +*/
          117  +}
          118  +// END CUT HERE

Added SRM/493-U/2C.cpp version [11f187ebddae9d97]

            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 CrouchingAmoebas { public:
           23  + int count(vector <int> x, vector <int> y, int A, int T)
           24  + {
           25  +  int answer = 0;
           26  +
           27  +  const int N = x.size();
           28  +
           29  +  vector<int> ys, xs;
           30  +  for(int i=0; i<N; ++i)
           31  +   for(int dy=-T; dy<=+T; ++dy)
           32  +    ys.push_back(y[i]+dy);
           33  +  for(int i=0; i<N; ++i)
           34  +   for(int dx=-T; dx<=+T; ++dx)
           35  +    xs.push_back(x[i]+dx);
           36  +
           37  +  for(int i=0; i<xs.size(); ++i)
           38  +  for(int k=0; k<ys.size(); ++k)
           39  +  {
           40  +   int Y = ys[k];
           41  +   int X = xs[i];
           42  +   vector<unsigned int> ds;
           43  +   for(int j=0; j<N; ++j) {
           44  +    unsigned int d = distance(Y,X,A,y[j],x[j]);
           45  +    if( d <= T )
           46  +     ds.push_back(d);
           47  +   }
           48  +   sort( ds.begin(), ds.end() );
           49  +   int e=T, c=0;
           50  +   for(int j=0; j<ds.size() && ds[j]<=e; ++j)
           51  +    e-=ds[j], ++c;
           52  +   answer = max(answer, c);
           53  +  }
           54  +  return answer;
           55  + }
           56  +
           57  + static unsigned int distance(int Y, int X, int A, int y, int x)
           58  + {
           59  +  unsigned int yd = (y<Y ? Y-y : Y+A<y ? y-(Y+A) : 0);
           60  +  unsigned int xd = (x<X ? X-x : X+A<x ? x-(X+A) : 0);
           61  +  return xd + yd;
           62  + }
           63  +};
           64  +
           65  +// BEGIN CUT HERE
           66  +#include <ctime>
           67  +double start_time; string timer()
           68  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           69  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           70  + { os << "{ ";
           71  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           72  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           73  +void verify_case(const int& Expected, const int& Received) {
           74  + bool ok = (Expected == Received);
           75  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           76  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           77  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           78  +#define END  verify_case(_, CrouchingAmoebas().count(x, y, A, T));}
           79  +int main(){
           80  +
           81  +CASE(0)
           82  + int x_[] = {0,0};
           83  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           84  + int y_[] = {0,1};
           85  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           86  + int A = 1;
           87  + int T = 1;
           88  + int _ = 2;
           89  +END
           90  +CASE(1)
           91  + int x_[] = {0,1,2};
           92  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           93  + int y_[] = {1,2,0};
           94  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           95  + int A = 1;
           96  + int T = 1;
           97  + int _ = 2;
           98  +END
           99  +CASE(2)
          100  + int x_[] = {0,1,2};
          101  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          102  + int y_[] = {1,2,0};
          103  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          104  + int A = 1;
          105  + int T = 2;
          106  + int _ = 3;
          107  +END
          108  +CASE(3)
          109  + int x_[] = {0,0,3,3};
          110  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          111  + int y_[] = {0,3,0,3};
          112  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          113  + int A = 2;
          114  + int T = 4;
          115  + int _ = 4;
          116  +END
          117  +CASE(4)
          118  + int x_[] = {-1000000000,1000000000};
          119  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          120  + int y_[] = {-1000000000,1000000000};
          121  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          122  + int A = 1;
          123  + int T = 15;
          124  + int _ = 1;
          125  +END
          126  +/*
          127  +CASE(5)
          128  + int x_[] = ;
          129  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          130  + int y_[] = ;
          131  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          132  + int A = ;
          133  + int T = ;
          134  + int _ = ;
          135  +END
          136  +CASE(6)
          137  + int x_[] = ;
          138  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          139  + int y_[] = ;
          140  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          141  + int A = ;
          142  + int T = ;
          143  + int _ = ;
          144  +END
          145  +*/
          146  +}
          147  +// END CUT HERE

Added SRM/494-U/1A.cpp version [7486de33876cf546]

            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 Painting { public:
           23  + int largestBrush(vector <string> picture)
           24  + {
           25  +  const int Y = picture.size();
           26  +  const int X = picture[0].size();
           27  +
           28  +  int best = 1;
           29  +  for(int S=2; S<=min(Y,X); ++S)
           30  +  {
           31  +   vector<string> duty = picture;
           32  +   for(int y=0; y+S<=Y; ++y)
           33  +   for(int x=0; x+S<=X; ++x)
           34  +    if( all<'B'>(picture, y, x, y+S, x+S) ) // SxS ‚ª‘S•”�•‚Ȃ炱‚±‚ð�¶�ã‚É‚µ‚Ä“h‚ê‚é
           35  +     fill<'W'>(duty, y, x, y+S, x+S); // “h‚é
           36  +   if( all<'W'>(duty, 0, 0, Y, X) )
           37  +    best = max(best, S); // ‘S•”“h‚ê‚Ä‚½‚çƒxƒXƒgƒXƒRƒA�X�V
           38  +  }
           39  +  return best;
           40  + }
           41  +
           42  + template<char color>
           43  + bool all(const vector<string>& p, int ys, int xs, int ye, int xe)
           44  + {
           45  +  int cnt = 0;
           46  +  for(int y=ys; y<ye; ++y)
           47  +  for(int x=xs; x<xe; ++x)
           48  +   cnt += (p[y][x]==color);
           49  +  return cnt == (ye-ys)*(xe-xs);
           50  + }
           51  +
           52  + template<char color>
           53  + void fill(vector<string>& p, int ys, int xs, int ye, int xe)
           54  + {
           55  +  for(int y=ys; y<ye; ++y)
           56  +  for(int x=xs; x<xe; ++x)
           57  +   p[y][x] = color;
           58  + }
           59  +};
           60  +
           61  +// BEGIN CUT HERE
           62  +#include <ctime>
           63  +double start_time; string timer()
           64  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           65  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           66  + { os << "{ ";
           67  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           68  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           69  +void verify_case(const int& Expected, const int& Received) {
           70  + bool ok = (Expected == Received);
           71  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           72  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           73  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           74  +#define END  verify_case(_, Painting().largestBrush(picture));}
           75  +int main(){
           76  +
           77  +CASE(0)
           78  + string picture_[] = {"BBBB",
           79  + "BBBB",
           80  + "BBBB",
           81  + "BBBB"};
           82  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
           83  + int _ = 4;
           84  +END
           85  +CASE(1)
           86  + string picture_[] = {"BBBB",
           87  + "BWWB",
           88  + "BWWB",
           89  + "BBBB"};
           90  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
           91  + int _ = 1;
           92  +END
           93  +CASE(2)
           94  + string picture_[] = {
           95  + "WBBBBB",
           96  + "BBBBBB",
           97  + "BBBBBB",
           98  + "BBBBBB"}
           99  +;
          100  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          101  + int _ = 3;
          102  +END
          103  +CASE(3)
          104  + string picture_[] = {"BBBB",
          105  + "BBBB",
          106  + "WBBB",
          107  + "BBBB",
          108  + "BBBB",
          109  + "BBBB"}
          110  +;
          111  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          112  + int _ = 2;
          113  +END
          114  +CASE(4)
          115  + string picture_[] = {
          116  + "WBBBBBWWWWWWWWW",
          117  + "WBBBBBBWWWWWWWW",
          118  + "WBBBBBBBBBBBWWW",
          119  + "WBBBBBBBBBBBWWW",
          120  + "BBBBBBBBBBBBBBB",
          121  + "BBBBBBBBBBBBBBB",
          122  + "BBBBBBBBBBBBBBB",
          123  + "BBBBBBBBWWBBBBB",
          124  + "BBBBBBBBWBBBBBB",
          125  + "WBBBBBBBWBBBBBW",
          126  + "BBBBBBBWWBBBBBW",
          127  + "BBBBBBBWWBBBBBW",
          128  + "BBBBBBWWWBBBBBW",
          129  + "BBBBBWWWWWWWWWW",
          130  + "BBBBBWWWWWWWWWW"}
          131  +;
          132  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          133  + int _ = 5;
          134  +END
          135  +CASE(5)
          136  + string picture_[] = {"B"};
          137  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          138  + int _ = 1;
          139  +END
          140  +CASE(6)
          141  + string picture_[] = {"WWWWWWBWWWWW"};
          142  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          143  + int _ = 1;
          144  +END
          145  +CASE(7)
          146  + string picture_[] = {
          147  +"WWBBWW",
          148  +"WBBBBW",
          149  +"BBWWBB",
          150  +"BBWWBB",
          151  +"WBBBBW",
          152  +"WWBBWW",
          153  +};
          154  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          155  + int _ = 1;
          156  +END
          157  +CASE(8)
          158  + string picture_[] = {
          159  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          160  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          161  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          162  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          163  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          164  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          165  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          166  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          167  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          168  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          169  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          170  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          171  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          172  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          173  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          174  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          175  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          176  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          177  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          178  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          179  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          180  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          181  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          182  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          183  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          184  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          185  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          186  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          187  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          188  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          189  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          190  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          191  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          192  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          193  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          194  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          195  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          196  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          197  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          198  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          199  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          200  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          201  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          202  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          203  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          204  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          205  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          206  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          207  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          208  +"WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB",
          209  +};
          210  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          211  + int _ = 1;
          212  +END
          213  +
          214  +}
          215  +// END CUT HERE

Added SRM/494-U/1B.cpp version [7ca249caa65bea30]

            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 AlternatingLane { public:
           23  + double expectedBeauty(vector <int> low, vector <int> high)
           24  + {
           25  +  double eSum = 0.0;
           26  +  for(int i=1; i<low.size(); ++i)
           27  +  {
           28  +   // ƒ‰ƒ“ƒ_ƒ€‚É
           29  +   //   h �¸ [low[i-1], high[i-1]]
           30  +   //   g �¸ [low[i],   high[i]  ]
           31  +   // ‚ðŽæ‚Á‚Ä‚«‚½‚Æ‚«‚Ì�A|h-g| ‚ÌŠú‘Ò’l�c
           32  +   double e = 0;
           33  +   for(int h=low[i-1]; h<=high[i-1]; ++h)
           34  +    if( h <= low[i] )
           35  +     e += sequenceSum(low[i]-h, high[i]-h);
           36  +    else if( high[i] <= h )
           37  +     e += sequenceSum(h-high[i], h-low[i]);
           38  +    else
           39  +     e += sequenceSum(0, h-low[i]) + sequenceSum(0, high[i]-h);
           40  +   eSum += e / (high[i]-low[i]+1) / (high[i-1]-low[i-1]+1);
           41  +  }
           42  +  return eSum; // �c‚̘a�A‚ª“š‚¦
           43  + }
           44  +
           45  + LL sequenceSum(LL a, LL b) // a+(a+1)+...+b
           46  + {
           47  +  return (a+b) * (b-a+1) / 2;
           48  + }
           49  +};
           50  +
           51  +// BEGIN CUT HERE
           52  +#include <ctime>
           53  +double start_time; string timer()
           54  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           55  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           56  + { os << "{ ";
           57  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           58  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           59  +void verify_case(const double& Expected, const double& Received) {
           60  + bool ok = (abs(Expected - Received) < 1e-9);
           61  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           62  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           63  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           64  +#define END  verify_case(_, AlternatingLane().expectedBeauty(low, high));}
           65  +int main(){
           66  +
           67  +CASE(0)
           68  + int low_[] = {1};
           69  +   vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_));
           70  + int high_[] = {100};
           71  +   vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_));
           72  + double _ = 0.0;
           73  +END
           74  +CASE(1)
           75  + int low_[] = {1, 1, 1};
           76  +   vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_));
           77  + int high_[] = {2, 2, 2};
           78  +   vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_));
           79  + double _ = 1.0;
           80  +END
           81  +CASE(2)
           82  + int low_[] = {1, 3, 5, 7, 9};
           83  +   vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_));
           84  + int high_[] = {2, 4, 6, 8, 10};
           85  +   vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_));
           86  + double _ = 8.0;
           87  +END
           88  +CASE(3)
           89  + int low_[] = {4, 3, 3, 7};
           90  +   vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_));
           91  + int high_[] = {10, 7, 7, 7};
           92  +   vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_));
           93  + double _ = 6.171428571428572;
           94  +END
           95  +CASE(4)
           96  +int low_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
           97  +   vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_));
           98  +   int high_[] = {100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000};
           99  +   vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_));
          100  + double _ = -1;
          101  +END
          102  +/*
          103  +CASE(5)
          104  + int low_[] = ;
          105  +   vector <int> low(low_, low_+sizeof(low_)/sizeof(*low_));
          106  + int high_[] = ;
          107  +   vector <int> high(high_, high_+sizeof(high_)/sizeof(*high_));
          108  + double _ = ;
          109  +END
          110  +*/
          111  +}
          112  +// END CUT HERE

Added SRM/495-U/1A.cpp version [87e839b8017e092a]

            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 ColorfulCards { public:
           23  + vector <int> theCards(int N, string colors)
           24  + {
           25  +  vector<bool> isPrime(N+1, true);
           26  +  isPrime[1] = false;
           27  +  for(int p=2; p<=N; ++p)
           28  +   if( isPrime[p] )
           29  +    for(int q=p+p; q<=N; q+=p)
           30  +     isPrime[q] = false;
           31  +
           32  +  vector<int> result(colors.size(), 0);
           33  +  for(int i=0; i<colors.size(); ++i)
           34  +   for(int n=1; n<=N; ++n)
           35  +    if( canItBe(i, n, colors, isPrime) )
           36  +     if( result[i] > 0 )
           37  +      {result[i] = -1; break;}
           38  +     else
           39  +      result[i] = n;
           40  +  return result;
           41  + }
           42  +
           43  + bool canItBe(int i, int n, const string& colors, vector<bool>& isPrime)
           44  + {
           45  +  if( colors[i]=='R' && !isPrime[n] )
           46  +   return false;
           47  +  if( colors[i]=='B' &&  isPrime[n] )
           48  +   return false;
           49  +  return greedyDown(i-1, n-1, colors, isPrime) && greedyUp(i+1, n+1, colors, isPrime);
           50  + }
           51  +
           52  + bool greedyUp(int i, int n, const string& colors, vector<bool>& isPrime)
           53  + {
           54  +  while( i<colors.size() )
           55  +  {
           56  +   if( n >= isPrime.size() )
           57  +    return false;
           58  +   if( colors[i]=='R' && isPrime[n] )
           59  +    {++i; ++n;}
           60  +   else
           61  +   if( colors[i]=='B' && !isPrime[n] )
           62  +    {++i; ++n;}
           63  +   else
           64  +    ++n;
           65  +  }
           66  +  return true;
           67  + }
           68  +
           69  + bool greedyDown(int i, int n, const string& colors, vector<bool>& isPrime)
           70  + {
           71  +  while( i>=0 )
           72  +  {
           73  +   if( n < 1 )
           74  +    return false;
           75  +   if( colors[i]=='R' && isPrime[n] )
           76  +    {--i; --n;}
           77  +   else
           78  +   if( colors[i]=='B' && !isPrime[n] )
           79  +    {--i; --n;}
           80  +   else
           81  +    --n;
           82  +  }
           83  +  return true;
           84  + }
           85  +};
           86  +
           87  +// BEGIN CUT HERE
           88  +#include <ctime>
           89  +double start_time; string timer()
           90  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           91  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           92  + { os << "{ ";
           93  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           94  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           95  +void verify_case(const vector <int>& Expected, const vector <int>& Received) {
           96  + bool ok = (Expected == Received);
           97  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           98  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           99  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          100  +#define END  verify_case(_, ColorfulCards().theCards(N, colors));}
          101  +int main(){
          102  +
          103  +CASE(0)
          104  + int N = 5;
          105  + string colors = "RRR";
          106  + int __[] = {2, 3, 5 };
          107  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          108  +END
          109  +CASE(1)
          110  + int N = 7;
          111  + string colors = "BBB";
          112  + int __[] = {1, 4, 6 };
          113  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          114  +END
          115  +CASE(2)
          116  + int N = 6;
          117  + string colors = "RBR";
          118  + int __[] = {-1, 4, 5 };
          119  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          120  +END
          121  +CASE(3)
          122  + int N = 58;
          123  + string colors = "RBRRBRBBRBRRBBRRBBBRRBBBRR";
          124  + int __[] = {-1, -1, -1, -1, -1, -1, -1, -1, 17, 18, 19, 23, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, 53 };
          125  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          126  +END
          127  +CASE(4)
          128  + int N = 495;
          129  + string colors = "RBRRBRBBRBRRBBRRBBBRRBBBRR";
          130  + int __[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
          131  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          132  +END
          133  +CASE(5)
          134  + int N = 1000;
          135  + string colors = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
          136  + int __[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
          137  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          138  +END
          139  +CASE(6)
          140  + int N = 1;
          141  + string colors = "B";
          142  + int __[] = {1};
          143  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          144  +END
          145  +CASE(6)
          146  + int N = 2;
          147  + string colors = "R";
          148  + int __[] = {2};
          149  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          150  +END
          151  +CASE(6)
          152  + int N = 2;
          153  + string colors = "B";
          154  + int __[] = {1};
          155  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
          156  +END
          157  +}
          158  +// END CUT HERE

Added SRM/495-U/1B.cpp version [3f7b3fa46030db3f]

            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 CarrotBoxes { public:
           23  + double theProbability(vector <string> info)
           24  + {
           25  +  info = warshall_floyd(info);
           26  +
           27  +  double answer=0.0, p=1.0;
           28  +
           29  +  set<int> boxes;
           30  +  for(int v=0; v<info.size(); ++v)
           31  +   boxes.insert(v);
           32  +
           33  +  while( !boxes.empty() )
           34  +  {
           35  +   for(set<int>::iterator it=boxes.begin(); it!=boxes.end(); ++it)
           36  +    if( isRoot(*it, info, boxes) && !isSingleton(*it, info, boxes) )
           37  +    {
           38  +     int N = boxes.size();
           39  +     int nr = 0;
           40  +     for(int u=0; u<info.size(); ++u)
           41  +      if( info[*it][u]=='Y' && boxes.count(u) )
           42  +       {++nr; boxes.erase(u);}
           43  +     answer += p * (nr-1) / N;
           44  +     p *= double(N-nr) / N;
           45  +     goto nextIter;
           46  +    }
           47  +
           48  +   // ‘S•”‚ª stand alone
           49  +   answer += p / boxes.size();
           50  +   break;
           51  +
           52  +  nextIter:;
           53  +  }
           54  +  return answer;
           55  + }
           56  +
           57  + bool isRoot(int v, const vector<string>& info, const set<int>& boxes)
           58  + {
           59  +  for(set<int>::const_iterator jt=boxes.begin(); jt!=boxes.end(); ++jt)
           60  +   if( info[v][*jt]=='N' && info[*jt][v]=='Y' )
           61  +    return false;
           62  +  return true;
           63  + }
           64  +
           65  + bool isSingleton(int v, const vector<string>& info, const set<int>& boxes)
           66  + {
           67  +  for(set<int>::const_iterator jt=boxes.begin(); jt!=boxes.end(); ++jt)
           68  +   if( v!=*jt && info[v][*jt]=='Y' )
           69  +    return false;
           70  +  return true;
           71  + }
           72  +
           73  + vector<string> warshall_floyd(const vector<string>& gg)
           74  + {
           75  +  vector<string> g = gg;
           76  +  for(int k=0; k<g.size(); ++k)
           77  +   for(int i=0; i<g.size(); ++i)
           78  +    for(int j=0; j<g.size(); ++j)
           79  +     if( g[i][k]=='Y' && g[k][j]=='Y' )
           80  +      g[i][j] = 'Y';
           81  +  return g;
           82  + }
           83  +};
           84  +
           85  +// BEGIN CUT HERE
           86  +#include <ctime>
           87  +double start_time; string timer()
           88  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           89  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           90  + { os << "{ ";
           91  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           92  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           93  +void verify_case(const double& Expected, const double& Received) {
           94  + bool ok = (abs(Expected - Received) < 1e-9);
           95  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           96  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           97  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           98  +#define END  verify_case(_, CarrotBoxes().theProbability(information));}
           99  +int main(){
          100  +
          101  +CASE(0)
          102  + string information_[] = {"YYYYY",
          103  + "NYNNN",
          104  + "NNYNN",
          105  + "NNNYN",
          106  + "NNNNY"}
          107  +;
          108  +   vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_));
          109  + double _ = 0.8;
          110  +END
          111  +CASE(1)
          112  + string information_[] = {"YNNNN",
          113  + "NYNNN",
          114  + "NNYNN",
          115  + "NNNYN",
          116  + "NNNNY"};
          117  +   vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_));
          118  + double _ = 0.2;
          119  +END
          120  +CASE(2)
          121  + string information_[] = {"Y"};
          122  +   vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_));
          123  + double _ = 1.0;
          124  +END
          125  +CASE(3)
          126  + string information_[] = {"YNNNN",
          127  + "YYNNN",
          128  + "YNYNN",
          129  + "NNNYY",
          130  + "NNNYY"}
          131  +;
          132  +   vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_));
          133  + double _ = 0.6;
          134  +END
          135  +CASE(4)
          136  + string information_[] = {"YYYNNNYN",
          137  + "NYNNNNYN",
          138  + "NNYNNNNN",
          139  + "NYNYNNNN",
          140  + "YNNNYNNY",
          141  + "NNYNNYNN",
          142  + "NNNNYNYN",
          143  + "NNYNNNNY"}
          144  +;
          145  +   vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_));
          146  + double _ = 0.875;
          147  +END
          148  +CASE(5)
          149  + string information_[] = {"YNNNNNNNNYNNNNNNNNNN",
          150  + "NYNNNNNNNNNNNNNNNNNN",
          151  + "NNYNNNNNNNYNNNNNYNNN",
          152  + "NNNYNYNNNNNNNNYNNNNN",
          153  + "NNNNYNNNNNNNNNYNNNNY",
          154  + "NNNNNYNNNNNNNNNNNNNY",
          155  + "NNNNYNYNYNNNNNNNNNNN",
          156  + "NNNNNNNYNNNYYNNNNNNN",
          157  + "NNNNNNNNYNNNNNNNNNNN",
          158  + "YNNNNNNNNYNNNNNYNNNN",
          159  + "NNNNNNNNNNYNNNNNNNNN",
          160  + "NYNNNNNNNNNYNNNNNNNN",
          161  + "NNNNNNNYNNNNYNNNNNNN",
          162  + "NNNNNNNNNNNNNYNNNYNN",
          163  + "NNNNNNNNNNNYNNYNNNYN",
          164  + "NYNNNNNNNNNNNNNYNNNN",
          165  + "NNYNNNNNNNNNNNNNYNNN",
          166  + "NNNNNNNNNNNNNYNYNYNN",
          167  + "NNNNNNNNYNYNNNNNNNYY",
          168  + "NNNYNNNNNNNNNNNNNNNY"};
          169  +   vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_));
          170  + double _ = 0.75;
          171  +END
          172  +/*
          173  +CASE(6)
          174  + string information_[] = ;
          175  +   vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_));
          176  + double _ = ;
          177  +END
          178  +CASE(7)
          179  + string information_[] = ;
          180  +   vector <string> information(information_, information_+sizeof(information_)/sizeof(*information_));
          181  + double _ = ;
          182  +END
          183  +*/
          184  +}
          185  +// END CUT HERE

Added SRM/495-U/2C.cpp version [6fa6be636b9ebdef]

            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 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 Find(int a)
           32  +  { return uf[a]==a ? a : uf[a]=Find(uf[a]); }
           33  + bool Union(int a, int b)
           34  +  {
           35  +   a = Find(a);
           36  +   b = Find(b);
           37  +   if( a != b )
           38  +   {
           39  +    if( sz[a] >= sz[b] ) swap(a, b);
           40  +    uf[a] = b;
           41  +    sz[b] += sz[a];
           42  +    --nc;
           43  +   }
           44  +   return (a!=b);
           45  +  }
           46  +};
           47  +
           48  +class HexagonPuzzle { public:
           49  + int theCount(vector <string> board)
           50  + {
           51  +  vector< pair<int,int> > id2pos;
           52  +  map<pair<int,int>, int> pos2id;
           53  +  int N = board.size();
           54  +  for(int i=0; i<N; ++i)
           55  +   for(int k=0; k<=i; ++k) {
           56  +    id2pos.push_back( make_pair(i,k) );
           57  +    pos2id[make_pair(i,k)] = id2pos.size()-1;
           58  +   }
           59  +
           60  +  int M = id2pos.size();
           61  +  UnionFind uf(M);
           62  +
           63  +  for(int i=0; i<N; ++i)
           64  +   for(int k=0; k<=i; ++k)
           65  +    if( board[i][k] == '.' )
           66  +    {
           67  +     if( i+1<N && board[i+1][k]=='.' && board[i+1][k+1]=='.' )
           68  +     {
           69  +      int a = pos2id[ make_pair(i,k) ];
           70  +      int b = pos2id[ make_pair(i+1,k) ];
           71  +      int c = pos2id[ make_pair(i+1,k+1) ];
           72  +      uf.Union(a,b);
           73  +      uf.Union(b,c);
           74  +     }
           75  +     if( i+1<N && k+1<=i && board[i][k+1]=='.' && board[i+1][k+1]=='.' )
           76  +     {
           77  +      int a = pos2id[ make_pair(i,k) ];
           78  +      int b = pos2id[ make_pair(i,k+1) ];
           79  +      int c = pos2id[ make_pair(i+1,k+1) ];
           80  +      uf.Union(a,b);
           81  +      uf.Union(b,c);
           82  +     }
           83  +    }
           84  +
           85  +  map<int, int> sc;
           86  +  for(int i=0; i<N; ++i)
           87  +   for(int k=0; k<=i; ++k)
           88  +    if( board[i][k] == '.' )
           89  +    {
           90  +     int a = pos2id[ make_pair(i,k) ];
           91  +     int ra = uf.Find(a);
           92  +     sc[ra] = uf.sz[ra];
           93  +    }
           94  +
           95  +  static const int MODVAL = 1000000007;
           96  +  LL result = 1;
           97  +  for(map<int,int>::iterator it=sc.begin(); it!=sc.end(); ++it)
           98  +  {
           99  +   int n = it->second;
          100  +   LL r = 1;
          101  +   for(int i=3; i<=n; ++i)
          102  +    r = (r*i)%MODVAL;
          103  +   result = (result * r) % MODVAL;
          104  +  }
          105  +  return int(result);
          106  + }
          107  +};
          108  +
          109  +// BEGIN CUT HERE
          110  +#include <ctime>
          111  +double start_time; string timer()
          112  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          113  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          114  + { os << "{ ";
          115  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          116  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          117  +void verify_case(const int& Expected, const int& Received) {
          118  + bool ok = (Expected == Received);
          119  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          120  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          121  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          122  +#define END  verify_case(_, HexagonPuzzle().theCount(board));}
          123  +int main(){
          124  +
          125  +CASE(0)
          126  + string board_[] = {".",
          127  + ".X",
          128  + "X..",
          129  + ".X.X"}
          130  +;
          131  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          132  + int _ = 3;
          133  +END
          134  +CASE(1)
          135  + string board_[] = {"X"}
          136  +;
          137  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          138  + int _ = 1;
          139  +END
          140  +CASE(2)
          141  + string board_[] = {".",
          142  + "..",
          143  + "...",
          144  + ".X.."}
          145  +;
          146  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          147  + int _ = 20160;
          148  +END
          149  +CASE(3)
          150  + string board_[] = {".",
          151  + "..",
          152  + "XXX",
          153  + "..X.",
          154  + ".X..X",
          155  + "XXXX..",
          156  + "..X.X.X",
          157  + "..X.XX.."}
          158  +;
          159  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          160  + int _ = 108;
          161  +END
          162  +CASE(4)
          163  + string board_[] = {".",
          164  + "..",
          165  + "...",
          166  + "....",
          167  + ".....",
          168  + "......",
          169  + ".......",
          170  + "........"};
          171  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          172  + int _ = 261547992;
          173  +END
          174  +/*
          175  +CASE(5)
          176  + string board_[] = ;
          177  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          178  + int _ = ;
          179  +END
          180  +CASE(6)
          181  + string board_[] = ;
          182  +   vector <string> board(board_, board_+sizeof(board_)/sizeof(*board_));
          183  + int _ = ;
          184  +END
          185  +*/
          186  +}
          187  +// END CUT HERE

Added SRM/496/1A.cpp version [02521b08a944dd23]

            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 ColoredStrokes { public:
           23  + int getLeast(vector <string> picture)
           24  + {
           25  +  const int H = picture.size();
           26  +  const int W = picture[0].size();
           27  +
           28  +  int cnt = 0;
           29  +  for(int y=0; y<H; ++y)
           30  +  {
           31  +   string line = picture[y];
           32  +   for(int i=0; i<line.size(); ++i)
           33  +    if( line[i]=='G' ) line[i] = 'R';
           34  +    else if(line[i]=='B') line[i]='.';
           35  +   cnt += howMany('R', line);
           36  +  }
           37  +  for(int x=0; x<W; ++x)
           38  +  {
           39  +   string line;
           40  +   for(int y=0; y<H; ++y)
           41  +    line += picture[y][x];
           42  +   for(int i=0; i<line.size(); ++i)
           43  +    if( line[i]=='G' ) line[i] = 'B';
           44  +    else if(line[i]=='R') line[i]='.';
           45  +   cnt += howMany('B', line);
           46  +  }
           47  +  return cnt;
           48  + }
           49  +
           50  + int howMany(char c, const string& s)
           51  + {
           52  +  int cnt = 0;
           53  +  for(int i=0; i<s.size(); )
           54  +  {
           55  +   while(i<s.size() && s[i]!=c)
           56  +    ++i;
           57  +   if( i == s.size() )
           58  +    break;
           59  +   ++cnt;
           60  +   while(i<s.size() && s[i]==c)
           61  +    ++i;
           62  +  }
           63  +  return cnt;
           64  + }
           65  +};
           66  +
           67  +// BEGIN CUT HERE
           68  +#include <ctime>
           69  +double start_time; string timer()
           70  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           71  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           72  + { os << "{ ";
           73  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           74  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           75  +void verify_case(const int& Expected, const int& Received) {
           76  + bool ok = (Expected == Received);
           77  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           78  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           79  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           80  +#define END  verify_case(_, ColoredStrokes().getLeast(picture));}
           81  +int main(){
           82  +
           83  +CASE(0)
           84  + string picture_[] = {"...",
           85  + "..."};
           86  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
           87  + int _ = 0;
           88  +END
           89  +CASE(1)
           90  + string picture_[] = {"..B.",
           91  + "..B."};
           92  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
           93  + int _ = 1;
           94  +END
           95  +CASE(2)
           96  + string picture_[] = {".BB."};
           97  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
           98  + int _ = 2;
           99  +END
          100  +CASE(3)
          101  + string picture_[] = {"...B..",
          102  + ".BRGRR",
          103  + ".B.B.."};
          104  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          105  + int _ = 3;
          106  +END
          107  +CASE(4)
          108  + string picture_[] = {"...B..",
          109  + ".BRBRR",
          110  + ".B.B.."};
          111  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          112  + int _ = 4;
          113  +END
          114  +CASE(5)
          115  + string picture_[] = {"GR",
          116  + "BG"};
          117  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          118  + int _ = 4;
          119  +END
          120  +/*
          121  +CASE(6)
          122  + string picture_[] = ;
          123  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          124  + int _ = ;
          125  +END
          126  +CASE(7)
          127  + string picture_[] = ;
          128  +   vector <string> picture(picture_, picture_+sizeof(picture_)/sizeof(*picture_));
          129  + int _ = ;
          130  +END
          131  +*/
          132  +}
          133  +// END CUT HERE

Added SRM/496/1B.cpp version [85211b8e1f2074c0]

            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 OneDimensionalBalls { public:
           23  + long long countValidGuesses(vector <int> firstPicture, vector <int> secondPicture)
           24  + {
           25  +  LL answer = 0;
           26  +
           27  +  const int N = firstPicture.size();
           28  +  set<int> sp(secondPicture.begin(), secondPicture.end());
           29  +
           30  +  for(set<int>::iterator it=sp.begin(); it!=sp.end(); ++it)
           31  +  {
           32  +   if( firstPicture[0] != *it )
           33  +   {
           34  +    const int d = abs(firstPicture[0] - *it);
           35  +
           36  +    set<int> avail = sp;
           37  +    avail.erase(*it);
           38  +
           39  +    vector<bool> done(N, false);
           40  +    done[0] = true;
           41  +
           42  +    for(;;)
           43  +    {
           44  +     bool upd = false;
           45  +     for(int k=0; k<N; ++k)
           46  +      if( !done[k] )
           47  +      {
           48  +       bool aL = avail.count(firstPicture[k]-d)>0;
           49  +       bool aR = avail.count(firstPicture[k]+d)>0;
           50  +       if( !aL && !aR )
           51  +        goto nextIt;
           52  +       else if( aL && !aR )
           53  +        {upd=done[k]=true; avail.erase(firstPicture[k]-d);}
           54  +       else if( !aL && aR )
           55  +        {upd=done[k]=true; avail.erase(firstPicture[k]+d);}
           56  +      }
           57  +     if( !upd )
           58  +      break;
           59  +    }
           60  +
           61  +    set<int> notDone;
           62  +    for(int k=0; k<N; ++k)
           63  +     if( !done[k] )
           64  +      notDone.insert(firstPicture[k]);
           65  +
           66  +    LL cnt = 1;
           67  +
           68  +    set<int> nnd;
           69  +    for(set<int>::iterator jt=notDone.begin(); jt!=notDone.end(); ++jt)
           70  +     if( !nnd.count(*jt) )
           71  +     {
           72  +      int chain = 1;
           73  +      for(int q=*jt+2*d; notDone.count(q); q+=2*d)
           74  +       {nnd.insert(q); ++chain;}
           75  +      cnt *= chain+1;
           76  +     }
           77  +    answer += cnt;
           78  +   }
           79  +  nextIt:;
           80  +  }
           81  +
           82  +  return answer;
           83  + }
           84  +};
           85  +
           86  +// BEGIN CUT HERE
           87  +#include <ctime>
           88  +double start_time; string timer()
           89  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           90  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           91  + { os << "{ ";
           92  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           93  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           94  +void verify_case(const long long& Expected, const long long& Received) {
           95  + bool ok = (Expected == Received);
           96  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           97  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           98  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           99  +#define END  verify_case(_, OneDimensionalBalls().countValidGuesses(firstPicture, secondPicture));}
          100  +int main(){
          101  +
          102  +CASE(0)
          103  + int firstPicture_[] = {12,11};
          104  +   vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_));
          105  + int secondPicture_[] = {10,11,13};
          106  +   vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_));
          107  + long long _ = 3LL;
          108  +END
          109  +CASE(1)
          110  + int firstPicture_[] = {1,2,3};
          111  +   vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_));
          112  + int secondPicture_[] = {1,2,3};
          113  +   vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_));
          114  + long long _ = 0LL;
          115  +END
          116  +CASE(2)
          117  + int firstPicture_[] = {1,3};
          118  +   vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_));
          119  + int secondPicture_[] = {1,3};
          120  +   vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_));
          121  + long long _ = 1LL;
          122  +END
          123  +CASE(3)
          124  + int firstPicture_[] = {7234};
          125  +   vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_));
          126  + int secondPicture_[] = {6316,689156,689160,689161,800000,1000001};
          127  +   vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_));
          128  + long long _ = 6LL;
          129  +END
          130  +CASE(4)
          131  + int firstPicture_[] = {6,2,4};
          132  +   vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_));
          133  + int secondPicture_[] = {1,2,3,4,5,7,8};
          134  +   vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_));
          135  + long long _ = 7LL;
          136  +END
          137  +CASE(5)
          138  +int firstPicture_[] = {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};
          139  +   vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_));
          140  + int secondPicture_[] = {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};
          141  +   vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_));
          142  + long long _ = -1LL;
          143  +END
          144  +CASE(6)
          145  + int firstPicture_[] = {1,2,3,4};
          146  +   vector <int> firstPicture(firstPicture_, firstPicture_+sizeof(firstPicture_)/sizeof(*firstPicture_));
          147  + int secondPicture_[] = {1,2,3,4};
          148  +   vector <int> secondPicture(secondPicture_, secondPicture_+sizeof(secondPicture_)/sizeof(*secondPicture_));
          149  + long long _ = 2LL;
          150  +END
          151  +}
          152  +// END CUT HERE

Added SRM/496/1C.cpp version [243d0d4a58986591]

            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 YetAnotherHamiltonianPath { public:
           23  + int leastCost(vector <string> label)
           24  + {
           25  +  int cost = 0;
           26  +  for(int i=0; i<label.size(); ++i)
           27  +   cost += label[i].size()*label[i].size() * (i<=1 ? 1 : 2); // ‚Ç‚¤‚â‚Á‚Ä‚à‚©‚©‚镪‚̃RƒXƒg
           28  +  return cost - radixSort(label); // ‚ ‚Æ‚Í max (ƒ° LCP^2) ‚ðˆø‚«ŽZ
           29  + }
           30  +
           31  + int radixSort(const vector<string>& v, int i=0, bool single=true, bool hasBothZeroOne=true)
           32  + {
           33  +  // Œ´‘¥“I‚É�A0•¶Žš–Ú‚ª“¯‚¶‚à‚Ì‚Ç‚¤‚µ‚ðˆêƒJ�Š‚É‚Ü‚Æ‚ß‚½•û‚ª“–‘Rƒxƒ^�[
           34  +  // 0•¶Žš–Ú‚ª“¯‚¶’†‚Å‚Í1•¶Žš–Ú‚ª“¯‚¶‚à‚Ì‚Ç‚¤‚µ‚ðˆêƒJ�Š‚É�c‚Æ‚¢‚¤�Ä‹A
           35  +  map< char, vector<string> > classify;
           36  +  for(int k=0; k<v.size(); ++k)
           37  +   classify[v[k].c_str()[i]].push_back( v[k] );
           38  +
           39  +  // N ŒÂ‚̃uƒ�ƒbƒN‚É•ª‚©‚ꂽ‚ç�A•ª‚©‚ê–Ú‚Å‚ÍLCP‚ª i ‚È‚Ì‚Å�A‚»‚Ì•ª‚Ì ƒ° LCP^2 ‚Í i*i*(N-1)�B
           40  +  int score = i*i * (classify.size()-1);
           41  +
           42  +  // ‚ ‚Ƃ̓uƒ�ƒbƒN‚²‚Æ‚É�Ä‹A“I‚É LCP^2 ‚̘a‚ð‹�‚ß‚Ä‘«‚µ‚Ä‚¢‚­
           43  +  for(map<char, vector<string> >::iterator it=classify.begin(); it!=classify.end(); ++it)
           44  +  {
           45  +   bool sgl = single && classify.size()==1;
           46  +   bool hzo = hasBothZeroOne && it->first==v[0].c_str()[i] && it->first==v[1].c_str()[i];
           47  +   if( it->first )
           48  +    score += radixSort( it->second, i+1, sgl, hzo );
           49  +   else
           50  +    score += i*i * (it->second.size()-1 + (sgl?1:0) - (hzo?1:0));
           51  +  }
           52  +
           53  +  // ‚½‚¾‚µ�Alabel[0] ‚Æ label[1] ‚ª�¶‚«•Ê‚ê‚ɂȂ镪‚©‚ê–Ú‚Í�i�Å�‰‚©‚番‚©‚ê‚Ä‚é‚Ì‚Å�j�”‚¦‚È‚¢
           54  +  if( hasBothZeroOne && v[0].c_str()[i]!=v[1].c_str()[i] ) score -= i*i;
           55  +
           56  +  // ‹t‚É�A‘S‘Ì‚ª2‚ˆÈ�ã‚̃uƒ�ƒbƒN‚É•ª‚©‚ê‚é‚Æ‚«‚É‚Í label[0] ‚Æ label[1] ‚ÌŠÔ‚É‹²‚Ü‚é‚Ì‚Å ƒ°LCP^2 ‚ª‚»‚Ì•ª‘½‚¢
           57  +  if( single && classify.size()>1 ) score += i*i;
           58  +
           59  +  // ˆÈ�ã
           60  +  return score;
           61  + }
           62  +};
           63  +
           64  +// BEGIN CUT HERE
           65  +#include <ctime>
           66  +double start_time; string timer()
           67  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           68  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           69  + { os << "{ ";
           70  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           71  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           72  +void verify_case(const int& Expected, const int& Received) {
           73  + bool ok = (Expected == Received);
           74  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           75  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           76  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           77  +#define END  verify_case(_, YetAnotherHamiltonianPath().leastCost(label));}
           78  +int main(){
           79  +
           80  +CASE(0)
           81  + string label_[] = {"home", "school", "pub"} ;
           82  +   vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_));
           83  + int _ = 70;
           84  +END
           85  +CASE(1)
           86  + string label_[] = {"school", "home", "pub", "stadium"};
           87  +   vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_));
           88  + int _ = 167;
           89  +END
           90  +CASE(2)
           91  + string label_[] = {"abcd","aecgh","abef","aecd"};
           92  +   vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_));
           93  + int _ = 91;
           94  +END
           95  +CASE(3)
           96  + string label_[] = {"canada", "cyprus", "croatia", "colombia", "chile", "china", "cameroon"};
           97  +   vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_));
           98  + int _ = 509;
           99  +END
          100  +CASE(4)
          101  + string label_[] = {"aaa", "aab", "b"};
          102  +   vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_));
          103  + int _ = 9+1 + 1+9;
          104  +END
          105  +CASE(4)
          106  + string label_[] = {"caaa", "caab", "cb"};
          107  +   vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_));
          108  + int _ = 16+4 + 4+16 - 1 - 1;
          109  +END
          110  +/*
          111  +CASE(5)
          112  + string label_[] = ;
          113  +   vector <string> label(label_, label_+sizeof(label_)/sizeof(*label_));
          114  + int _ = ;
          115  +END
          116  +*/
          117  +}
          118  +// END CUT HERE

Added SRM/496/2C.cpp version [b8edf4ca77074ee3]

            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 PalindromfulString { public:
           23  + long long count(int N, int M, int K)
           24  + {
           25  +  vector<int> tmp;
           26  +  return rec(N, M, K, tmp, 0);
           27  + }
           28  +
           29  + static LL rec(int N, int M, int K, vector<int>& cur, int usedMax)
           30  + {
           31  +  if( cur.size() == N )
           32  +  {
           33  +   int pc=0;
           34  +   for(int s=0; s+M<=N; ++s)
           35  +    if( isPalin(cur, s, s+M) )
           36  +     pc++;
           37  +   return (pc>=K ? P(26, usedMax) : 0);
           38  +  }
           39  +  else
           40  +  {
           41  +   LL sum = 0;
           42  +   for(int k=1; k<=usedMax+1; ++k)
           43  +   {
           44  +    cur.push_back(k);
           45  +    sum += rec(N, M, K, cur, max(usedMax,k));
           46  +    cur.pop_back();
           47  +   }
           48  +   return sum;
           49  +  }
           50  + }
           51  +
           52  + static bool isPalin(const vector<int>& v, int s, int e)
           53  + {
           54  +  for( ; s<=--e; ++s)
           55  +   if( v[s] != v[e] )
           56  +    return false;
           57  +  return true;
           58  + }
           59  +
           60  + static LL P(int v, int n)
           61  + {
           62  +  LL x = 1;
           63  +  for(int i=0; i<n; ++i)
           64  +   x *= v-i;
           65  +  return x;
           66  + }
           67  +};
           68  +
           69  +// BEGIN CUT HERE
           70  +#include <ctime>
           71  +double start_time; string timer()
           72  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           73  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           74  + { os << "{ ";
           75  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           76  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           77  +void verify_case(const long long& Expected, const long long& Received) {
           78  + bool ok = (Expected == Received);
           79  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           80  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           81  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           82  +#define END  verify_case(_, PalindromfulString().count(N, M, K));}
           83  +int main(){
           84  +
           85  +CASE(0)
           86  + int N = 2;
           87  + int M = 2;
           88  + int K = 1;
           89  + long long _ = 26LL;
           90  +END
           91  +CASE(1)
           92  + int N = 2;
           93  + int M = 2;
           94  + int K = 0;
           95  + long long _ = 676LL;
           96  +END
           97  +CASE(2)
           98  + int N = 3;
           99  + int M = 2;
          100  + int K = 1;
          101  + long long _ = 1326LL;
          102  +END
          103  +CASE(3)
          104  + int N = 4;
          105  + int M = 4;
          106  + int K = 1;
          107  + long long _ = 676LL;
          108  +END
          109  +CASE(4)
          110  + int N = 7;
          111  + int M = 3;
          112  + int K = 3;
          113  + long long _ = 4310176LL;
          114  +END
          115  +CASE(5)
          116  + int N = 11;
          117  + int M = 2;
          118  + int K = 0;
          119  + long long _ = -1LL;
          120  +END
          121  +CASE(6)
          122  + int N = 11;
          123  + int M = 5;
          124  + int K = 0;
          125  + long long _ = -1LL;
          126  +END
          127  +
          128  +}
          129  +// END CUT HERE

Added SRM/497-U/1A.cpp version [6442f8ba618ca353]

            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 PermutationSignature { public:
           23  + vector <int> reconstruct(string signature)
           24  + {
           25  +  deque<int> cur(1, 1);
           26  +  for(int i=signature.size()-1; i>=0; --i)
           27  +  {
           28  +   int ins = (signature[i]=='I' ? 1 : cur.front()+1);
           29  +   cur.push_front(ins);
           30  +   for(int k=1; k<cur.size(); ++k)
           31  +    if( cur[k] >= ins )
           32  +     cur[k] ++;
           33  +  }
           34  +  return vector<int>(cur.begin(), cur.end());
           35  + }
           36  +};
           37  +
           38  +// BEGIN CUT HERE
           39  +#include <ctime>
           40  +double start_time; string timer()
           41  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           42  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           43  + { os << "{ ";
           44  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           45  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           46  +void verify_case(const vector <int>& Expected, const vector <int>& Received) {
           47  + bool ok = (Expected == Received);
           48  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           49  + cerr << "\to: " << Expected << endl << "\tx: " << Received << endl; } }
           50  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           51  +#define END  verify_case(_, PermutationSignature().reconstruct(signature));}
           52  +int main(){
           53  +
           54  +CASE(0)
           55  + string signature = "IIIII";
           56  + int __[] = {1, 2, 3, 4, 5, 6 };
           57  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           58  +END
           59  +CASE(1)
           60  + string signature = "DI";
           61  + int __[] = {2, 1, 3 };
           62  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           63  +END
           64  +CASE(2)
           65  + string signature = "IIIID";
           66  + int __[] = {1, 2, 3, 4, 6, 5 };
           67  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           68  +END
           69  +CASE(3)
           70  + string signature = "DIIDID";
           71  + int __[] = {2, 1, 3, 5, 4, 7, 6 };
           72  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           73  +END
           74  +CASE(4)
           75  + string signature = "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD";
           76  + int __[] = {-1};
           77  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           78  +END
           79  +CASE(5)
           80  + string signature = "IDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDIDID";
           81  +int __[] = {-1};
           82  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           83  +END
           84  +CASE(6)
           85  + string signature = "I";
           86  + int __[] = {1,2};
           87  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           88  +END
           89  +CASE(7)
           90  + string signature = "D";
           91  + int __[] = {2,1};
           92  +   vector <int> _(__, __+sizeof(__)/sizeof(*__));
           93  +END
           94  +
           95  +}
           96  +// END CUT HERE

Added SRM/497-U/1B.cpp version [1dd2adf40bd7c456]

            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 CssRules { public:
           23  + int getMinimalCssRuleCount(vector <string> xthml)
           24  + {
           25  +  tree virtual_root;
           26  +  {
           27  +   num_node = 0;
           28  +   string xs = accumulate(xthml.begin(), xthml.end(), string(""));
           29  +   const char* p = xs.c_str();
           30  +   virtual_root.children = parse_tags(p);
           31  +  }
           32  +  vector<int> memo(num_node*8*8*8, -1);
           33  +  return rec(virtual_root.children, 7*64+7*8+7, memo);
           34  + }
           35  +
           36  + struct tree
           37  + {
           38  +  int id;
           39  +  int tag;
           40  +  int color;
           41  +  vector<tree*> children;
           42  +  ~tree() { for(int i=0; i<children.size(); ++i) delete children[i]; }
           43  + };
           44  +
           45  + // solver -------------------------------------------------------------
           46  +
           47  + int rec(vector<tree*>& ts, int tag_to_color, vector<int>& memo)
           48  + {
           49  +  int sum = 0;
           50  +  for(int i=0; i<ts.size(); ++i)
           51  +   sum += rec(ts[i], tag_to_color, memo);
           52  +  return sum;
           53  + }
           54  +
           55  + int rec(tree* t, int tag_to_color, vector<int>& memo)
           56  + {
           57  +  const int key = t->id * 8*8*8 + tag_to_color;
           58  +  if( memo[key] >= 0 )
           59  +   return memo[key];
           60  +
           61  +  int me   = ((tag_to_color>>(3*t->tag))&7) != t->color;
           62  +  int best = 0x3fffffff;
           63  +  for(int ttc=0; ttc<8*8*8; ++ttc)
           64  +  {
           65  +   int cost = 0;
           66  +   cost += ((tag_to_color>>0)&7) != ((ttc>>0)&7);
           67  +   cost += ((tag_to_color>>3)&7) != ((ttc>>3)&7);
           68  +   cost += ((tag_to_color>>6)&7) != ((ttc>>6)&7);
           69  +   best = min(best, cost + srec(t->children, ttc, memo));
           70  +  }
           71  +  return memo[key] = me + best;
           72  + }
           73  +
           74  + // parser ------------------------------------------------------
           75  +
           76  + int num_node;
           77  +
           78  + vector<tree*> parse_tags( const char*& p )
           79  + {
           80  +  vector<tree*> res;
           81  +  while(*p && p[1]!='/')
           82  +   res.push_back(parse_tag(p));
           83  +  return res;
           84  + }
           85  +
           86  + tree* parse_tag( const char*& p )
           87  + {
           88  +  static map<string, int> color_map;
           89  +  if( color_map.empty() )
           90  +  {
           91  +   color_map["black"]  = 0;
           92  +   color_map["blue"]   = 1;
           93  +   color_map["gray"]   = 2;
           94  +   color_map["green"]  = 3;
           95  +   color_map["red"]    = 4;
           96  +   color_map["white"]  = 5;
           97  +   color_map["yellow"] = 6;
           98  +  }
           99  +  static map<string, int> tag_map;
          100  +  if( tag_map.empty() )
          101  +  {
          102  +   tag_map["b"] = 0;
          103  +   tag_map["u"] = 1;
          104  +   tag_map["i"] = 2;
          105  +  }
          106  +
          107  +  // <TAG id='ID' style='color:COLOR'>tagContent</TAG>
          108  +  p++;                                  // <
          109  +  string tag; while(*p!=' ') tag+=*p++; // TAG
          110  +  while(*p==' ') ++p;                   // _sp_
          111  +  p += 4;                               // id='
          112  +  string id;  while(*p!='\'') id+=*p++; // ID
          113  +  ++p;                                  // '
          114  +  while(*p==' ') ++p;                   // _sp_
          115  +  p += 13;                              // style='color:
          116  +  string cl;  while(*p!='\'') cl+=*p++; // COLOR
          117  +  p += 2;                               // '>
          118  +  vector<tree*> ch = parse_tags(p);     // tagContent
          119  +  p += 4;                               // </TAG>
          120  +
          121  +  tree* t = new tree;
          122  +  t->id       = num_node++;
          123  +  t->tag      = tag_map[tag];
          124  +  t->color    = color_map[cl];
          125  +  t->children = ch;
          126  +  return t;
          127  + }
          128  +};
          129  +
          130  +// BEGIN CUT HERE
          131  +#include <ctime>
          132  +double start_time; string timer()
          133  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          134  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          135  + { os << "{ ";
          136  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          137  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          138  +void verify_case(const int& Expected, const int& Received) {
          139  + bool ok = (Expected == Received);
          140  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          141  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          142  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          143  +#define END  verify_case(_, CssRules().getMinimalCssRuleCount(xthml));}
          144  +int main(){
          145  +
          146  +CASE(6)
          147  + string xthml_[] = {"<i id='b' style='color:white'><u id='f' styl", "e='color:red'></u><u id='e' style='color:red", "'></u><u id='d' style='color:gray'></u><i id", "='c' style='color:white'></i></i><i id='a' s", "tyle='color:red'></i>"};
          148  +   vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_));
          149  + int _ = 5;
          150  +END
          151  +CASE(0)
          152  + string xthml_[] = {"<b id='x' style='color:red'></b>"};
          153  +   vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_));
          154  + int _ = 1;
          155  +END
          156  +CASE(1)
          157  + string xthml_[] = {"<b id='x' style='color:red'>","<b id='y' style='color:red'>",
          158  + "<b id='z' style='color:red'>","</b></b></b>"}
          159  +;
          160  +   vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_));
          161  + int _ = 2;
          162  +END
          163  +CASE(2)
          164  + string xthml_[] = {"<b id='x' style='color:red'>",
          165  +"<b id='y' style='color:red'>",
          166  +"<b id='w' style='color:red'>",
          167  +"</b>",
          168  +"</b>",
          169  +"<u id='z' style='color:red'>",
          170  +"</u>",
          171  +"</b>"};
          172  +   vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_));
          173  + int _ = 3;
          174  +END
          175  +CASE(3)
          176  + string xthml_[] = {"<b id='x' style='color:red'>",
          177  +"<i id='y' style='color:black'>",
          178  +"<u id='w' style='color:white'>",
          179  +"</u>",
          180  +"</i>",
          181  +"<u id='z' style='color:yellow'>",
          182  +"</u>",
          183  +"</b>"};
          184  +   vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_));
          185  + int _ = 4;
          186  +END
          187  +CASE(4)
          188  + string xthml_[] = {"<b id='x' style='col", "or:red'></b>", "<b id=", "'xx' style='color", ":red'></b>"};
          189  +   vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_));
          190  + int _ = 2;
          191  +END
          192  +CASE(5)
          193  + string xthml_[] = {
          194  +"<b id='aa' style='color:red'><b id='ab' style='col",
          195  +"or:red'><b id='ac' style='color:red'><b id='ad' st",
          196  +"yle='color:red'><b id='ae' style='color:red'><b id",
          197  +"='af' style='color:red'><b id='ag' style='color:re",
          198  +"d'><b id='ah' style='color:red'><b id='ai' style='",
          199  +"color:red'><b id='aj' style='color:red'><b id='ak'",
          200  +" style='color:red'><b id='al' style='color:red'><b",
          201  +" id='am' style='color:red'><b id='an' style='color",
          202  +":red'><b id='ao' style='color:red'><b id='ap' styl",
          203  +"e='color:red'><b id='aq' style='color:red'><b id='",
          204  +"ar' style='color:red'><b id='as' style='color:red'",
          205  +"><b id='at' style='color:red'><b id='au' style='co",
          206  +"lor:red'><b id='av' style='color:red'><b id='aw' s",
          207  +"tyle='color:red'><b id='ax' style='color:red'><b i",
          208  +"d='ay' style='color:red'><b id='az' style='color:r",
          209  +"ed'><b id='ba' style='color:red'><b id='bb' style=",
          210  +"'color:red'><b id='bc' style='color:red'><b id='bd",
          211  +"' style='color:red'><b id='be' style='color:red'><",
          212  +"b id='bf' style='color:red'><b id='bg' style='colo",
          213  +"r:red'><b id='bh' style='color:red'><b id='bi' sty",
          214  +"le='color:red'><b id='bj' style='color:red'><b id=",
          215  +"'bk' style='color:red'><b id='bl' style='color:red",
          216  +"'><b id='bm' style='color:red'><b id='bn' style='c",
          217  +"olor:red'><b id='bo' style='color:red'><b id='bp' ",
          218  +"style='color:red'><b id='bq' style='color:red'><b ",
          219  +"id='br' style='color:red'><b id='bs' style='color:",
          220  +"red'><b id='bt' style='color:red'><b id='bu' style",
          221  +"='color:red'><b id='bv' style='color:red'><b id='b",
          222  +"w' style='color:red'><b id='bx' style='color:red'>",
          223  +"<b id='by' style='color:red'><b id='bz' style='col",
          224  +"or:red'><b id='ca' style='color:red'><b id='cb' st",
          225  +"yle='color:red'><b id='cc' style='color:red'><b id",
          226  +"='cd' style='color:red'><b id='ce' style='color:re",
          227  +"d'><b id='cf' style='color:red'><b id='cg' style='",
          228  +"color:red'><b id='ch' style='color:red'><b id='ci'",
          229  +" style='color:red'><b id='cj' style='color:red'><b",
          230  +" id='ck' style='color:red'><b id='cl' style='color",
          231  +":red'><b id='cm' style='color:red'><b id='cn' styl",
          232  +"e='color:red'><b id='co' style='color:red'><b id='",
          233  +"cp' style='color:red'><b id='cq' style='color:red'",
          234  +"><b id='cr' style='color:red'><b id='cs' style='co",
          235  +"lor:red'><b id='ct' style='color:red'><b id='cu' s",
          236  +"tyle='color:red'><b id='cv' style='color:red'><b i",
          237  +"d='cw' style='color:red'></b></b></b></b></b></b><",
          238  +"/b></b></b></b></b></b></b></b></b></b></b></b></b",
          239  +"></b></b></b></b></b></b></b></b></b></b></b></b><",
          240  +"/b></b></b></b></b></b></b></b></b></b></b></b></b",
          241  +"></b></b></b></b></b></b></b></b></b></b></b></b><",
          242  +"/b></b></b></b></b></b></b></b></b></b></b></b></b",
          243  +"></b></b></b></b></b></b>"
          244  +};
          245  +   vector <string> xthml(xthml_, xthml_+sizeof(xthml_)/sizeof(*xthml_));
          246  + int _ = -1;
          247  +END
          248  +}
          249  +// END CUT HERE

Added SRM/TCO10-1-U/1A.cpp version [86891d068367bcdf]

            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 EqualizeStrings { public:
           23  + string getEq(string s, string t)
           24  + {
           25  +  string answer;
           26  +  for(int i=0; i<s.size(); ++i)
           27  +   answer += char(adjust(s[i]-'a', t[i]-'a')+'a');
           28  +  return answer;
           29  + }
           30  + int adjust(int x, int y)
           31  + {
           32  +  int minC = 9999;
           33  +  int minZ = 0;
           34  +  for(int z=0; z<26; ++z)
           35  +  {
           36  +   int c = min(abs(x-z), 26-abs(x-z)) + min(abs(y-z), 26-abs(y-z));
           37  +   if( c < minC ) {
           38  +    minC = c;
           39  +    minZ = z;
           40  +   }
           41  +  }
           42  +  return minZ;
           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(_, EqualizeStrings().getEq(s, t));}
           60  +int main(){
           61  +
           62  +CASE(0)
           63  + string s = "cat";
           64  + string t = "dog";
           65  + string _ = "caa";
           66  +END
           67  +CASE(1)
           68  + string s = "abcdefghijklmnopqrstuvwxyz";
           69  + string t = "bcdefghijklmnopqrstuvwxyza";
           70  + string _ = "abcdefghijklmnopqrstuvwxya";
           71  +END
           72  +CASE(2)
           73  + string s = "programmingcompetitionsrule";
           74  + string t = "programmingcompetitionsrule";
           75  + string _ = "programmingcompetitionsrule";
           76  +END
           77  +CASE(3)
           78  + string s = "topcoderopen";
           79  + string t = "onlinerounds";
           80  + string _ = "onlcndaoondn";
           81  +END
           82  +CASE(4)
           83  + string s = "a";
           84  + string t = "z";
           85  + string _ = "a";
           86  +END
           87  +CASE(5)
           88  + string s = "y";
           89  + string t = "z";
           90  + string _ = "y";
           91  +END
           92  +CASE(5)
           93  + string s = "z";
           94  + string t = "b";
           95  + string _ = "a";
           96  +END
           97  +CASE(5)
           98  + string s = "h";
           99  + string t = "t";
          100  + string _ = "h";
          101  +END
          102  +CASE(5)
          103  + string s = "b";
          104  + string t = "o";
          105  + string _ = "a";
          106  +END
          107  +CASE(5)
          108  + string s = "b";
          109  + string t = "n";
          110  + string _ = "b";
          111  +END
          112  +CASE(5)
          113  + string s = "b";
          114  + string t = "q";
          115  + string _ = "a";
          116  +END
          117  +}
          118  +// END CUT HERE

Added SRM/TCO10-1-U/1B.cpp version [56eab9a0d5dca1c4]

            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 TwoRegisters { public:
           23  + string minProg(int r)
           24  + {
           25  +  int minn = 0x7fffffff;
           26  +  vector<int> miny;
           27  +  for(int y=1; y<r; ++y)
           28  +  {
           29  +   int n = cnt(r,y);
           30  +   if( n != -1 )
           31  +    if( n <= minn ) {
           32  +     if( n < minn )
           33  +      miny.clear();
           34  +     minn = n;
           35  +     miny.push_back(y);
           36  +    }
           37  +  }
           38  +
           39  +  string answer;
           40  +  for(int i=0; i<miny.size(); ++i)
           41  +  {
           42  +   int y = miny[i];
           43  +   string s;
           44  +   compute(r, y, false, s);
           45  +   if( i==0 || s < answer )
           46  +    answer = s;
           47  +  }
           48  +  return answer;
           49  + }
           50  +
           51  + int cnt(int r, int y)
           52  + {
           53  +  if( y==0 )
           54  +   return -1;
           55  +  if( y==1 )
           56  +   return r-1;
           57  +  int k = r/y;
           58  +  int kk = cnt(y, r%y);
           59  +  if( kk == -1 )
           60  +   return -1;
           61  +  return k+kk;
           62  + }
           63  +
           64  + void compute(int r, int y, bool isY, string& s)
           65  + {
           66  +  if( y==1 ) {
           67  +   for(int i=0; i<r-1; ++i)
           68  +    s += (isY ? 'Y' : 'X');
           69  +   return;
           70  +  }
           71  +  int k = r/y;
           72  +  compute(y, r%y, !isY, s);
           73  +  while( k --> 0 )
           74  +   s += (isY ? 'Y' : 'X');
           75  + }
           76  +};
           77  +
           78  +// BEGIN CUT HERE
           79  +#include <ctime>
           80  +double start_time; string timer()
           81  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           82  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           83  + { os << "{ ";
           84  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           85  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           86  +void verify_case(const string& Expected, const string& Received) {
           87  + bool ok = (Expected == Received);
           88  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           89  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           90  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           91  +#define END  verify_case(_, TwoRegisters().minProg(r));}
           92  +int main(){
           93  +
           94  +CASE(0)
           95  + int r = 10;
           96  + string _ = "XXYYX";
           97  +END
           98  +CASE(1)
           99  + int r = 3;
          100  + string _ = "XX";
          101  +END
          102  +CASE(2)
          103  + int r = 20;
          104  + string _ = "XYYYYXX";
          105  +END
          106  +CASE(3)
          107  + int r = 34;
          108  + string _ = "XYXYXYX";
          109  +END
          110  +CASE(4)
          111  + int r = 1;
          112  + string _ = "";
          113  +END
          114  +CASE(5)
          115  + int r = 1000000;
          116  + string _ = "??";
          117  +END
          118  +CASE(6)
          119  + int r = 2;
          120  + string _ = "X";
          121  +END
          122  +CASE(6)
          123  + int r = 999999;
          124  + string _ = "??";
          125  +END
          126  +CASE(6)
          127  + int r = 999998;
          128  + string _ = "??";
          129  +END
          130  +CASE(6)
          131  + int r = 999997;
          132  + string _ = "??";
          133  +END
          134  +CASE(6)
          135  + int r = 999996;
          136  + string _ = "??";
          137  +END
          138  +CASE(6)
          139  + int r = 999995;
          140  + string _ = "??";
          141  +END
          142  +CASE(6)
          143  + int r = 5;
          144  + string _ = "??";
          145  +END
          146  +
          147  +}
          148  +// END CUT HERE

Added SRM/TCO10-1-U/1C-U.cpp version [a16249ed416e3f88]

            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 VacationTours { public:
           23  + int getIncome(vector <string> c, vector <string> d, int fee)
           24  + {
           25  +  int N = c.size();
           26  +  vector< vector<int> > G(N, vector<int>(N));
           27  +  for(int i=0; i<N; ++i)
           28  +   for(int j=0; j<N; ++j)
           29  +    G[i][j] = dec(c[i][j])*64 + dec(d[i][j]);
           30  +
           31  +  int basefee = fee * (N-1);
           32  +  for(int i=1; i<N; ++i)
           33  +   basefee -= G[0][i] + G[i][0];
           34  +
           35  +  typedef pair< int, pair<int,int> > edge;
           36  +  set< edge, greater<edge> > es;
           37  +  vector< vector<int> > P(N, vector<int>(N));
           38  +  for(int i=1; i<N; ++i)
           39  +   for(int j=1; j<N; ++j) if(i!=j) {
           40  +    P[i][j] = -fee - G[i][j] + G[i][0] + G[0][j];
           41  +    es.insert( edge(P[i][j], make_pair(i,j)) );
           42  +   }
           43  +
           44  +  int gain = 0;
           45  +
           46  +  vector<bool> out(N,true), in(N,true);
           47  +  vector<int> uf(N), sz(N);
           48  +  for(int v=0; v<N; ++v) uf[v]=v, sz[v]=1;
           49  +
           50  +  for(set< edge, greater<edge> >::iterator it=es.begin(); it!=es.end(); ++it)
           51  +  {
           52  +   int c = it->first;
           53  +   int a = it->second.first;
           54  +   int b = it->second.second;
           55  +   if( c <= 0 )
           56  +    break;
           57  +   if( !out[a] || !in[b] )
           58  +    continue;
           59  +   // repr
           60  +   int ra=a; while(uf[ra]!=ra) ra=uf[ra];
           61  +   int rb=b; while(uf[rb]!=rb) rb=uf[rb];
           62  +   if( ra != rb ) {
           63  +    gain += c;
           64  +    // union
           65  +    if( sz[ra] > sz[rb] ) swap(ra,rb);
           66  +    uf[ra] = rb;
           67  +    sz[rb] += sz[ra];
           68  +    out[a] = false;
           69  +    in[b] = false;
           70  +   }
           71  +  }
           72  +
           73  +  return max(0, basefee+gain);
           74  + }
           75  +
           76  + int dec(char c)
           77  + {
           78  +  if('A'<=c && c<='Z') return c-'A';
           79  +  if('a'<=c && c<='z') return c-'a'+26;
           80  +  if('0'<=c && c<='9') return c-'0'+52;
           81  +  if(c=='+')return 62;
           82  +  return 63;
           83  + }
           84  +};
           85  +
           86  +// BEGIN CUT HERE
           87  +#include <ctime>
           88  +double start_time; string timer()
           89  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           90  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           91  + { os << "{ ";
           92  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           93  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           94  +void verify_case(const int& Expected, const int& Received) {
           95  + bool ok = (Expected == Received);
           96  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           97  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           98  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           99  +#define END  verify_case(_, VacationTours().getIncome(c, d, fee));}
          100  +int main(){
          101  +
          102  +CASE(0)
          103  + string c_[] = {"AAA",
          104  + "AAA",
          105  + "AAA"};
          106  +   vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_));
          107  + string d_[] = {"ABJ",
          108  + "JAB",
          109  + "BJA"};
          110  +   vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_));
          111  + int fee = 15;
          112  + int _ = 12;
          113  +END
          114  +CASE(1)
          115  + string c_[] = {"AAAA",
          116  + "AAAA",
          117  + "AAAA",
          118  + "AAAA"};
          119  +   vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_));
          120  + string d_[] = {"AAAA",
          121  + "AAAA",
          122  + "AAAA",
          123  + "AAAA"};
          124  +   vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_));
          125  + int fee = 100;
          126  + int _ = 300;
          127  +END
          128  +CASE(2)
          129  + string c_[] = {"A//",
          130  + "/A/",
          131  + "//A"};
          132  +   vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_));
          133  + string d_[] = {"A//",
          134  + "/A/",
          135  + "//A"};
          136  +   vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_));
          137  + int fee = 1000;
          138  + int _ = 0;
          139  +END
          140  +CASE(3)
          141  + string c_[] = {"AAA////",
          142  + "/AA/A//",
          143  + "//AA/A/",
          144  + "A//AA//",
          145  + "///AAA/",
          146  + "///A/AA",
          147  + "AA////A"};
          148  +   vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_));
          149  + string d_[] = {"AKo////",
          150  + "/AU/X//",
          151  + "//AZ/o/",
          152  + "j//AK//",
          153  + "///XAo/",
          154  + "///y/AK",
          155  + "KP////A"};
          156  +   vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_));
          157  + int fee = 1000;
          158  + int _ = 1809;
          159  +END
          160  + /*
          161  +CASE(4)
          162  + string c_[] = ;
          163  +   vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_));
          164  + string d_[] = ;
          165  +   vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_));
          166  + int fee = ;
          167  + int _ = ;
          168  +END
          169  +CASE(5)
          170  + string c_[] = ;
          171  +   vector <string> c(c_, c_+sizeof(c_)/sizeof(*c_));
          172  + string d_[] = ;
          173  +   vector <string> d(d_, d_+sizeof(d_)/sizeof(*d_));
          174  + int fee = ;
          175  + int _ = ;
          176  +END
          177  +*/
          178  +}
          179  +// END CUT HERE

Added SRM/TCO10-2-U/1A.cpp version [d7e39504fab93869]

            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 SnowPlow { public:
           23  + int solve(vector <string> roads)
           24  + {
           25  +  int N = roads.size();
           26  +
           27  +  set< pair<int,int> > edges;
           28  +  int sum = 0;
           29  +  for(int i=0; i<N; ++i)
           30  +   for(int j=i+1; j<N; ++j)
           31  +    if( roads[i][j] > '0' ) {
           32  +     edges.insert( make_pair(i,j) );
           33  +     sum += 2*(roads[i][j]-'0');
           34  +    }
           35  +
           36  +  set<int> vis;
           37  +  queue<int> q; q.push(0);
           38  +  while( !q.empty() ) {
           39  +   int v = q.front();
           40  +   q.pop();
           41  +   for(int j=0; j<N; ++j) if( j!=v )
           42  +    if( roads[v][j]>'0' ) {
           43  +     edges.erase( make_pair(min(j,v), max(j,v)) );
           44  +     if( !vis.count(j) ) {
           45  +      q.push(j);
           46  +      vis.insert(j);
           47  +     }
           48  +    }
           49  +  }
           50  +  return edges.empty() ? sum : -1;
           51  + }
           52  +};
           53  +
           54  +// BEGIN CUT HERE
           55  +#include <ctime>
           56  +double start_time; string timer()
           57  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           58  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           59  + { os << "{ ";
           60  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           61  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           62  +void verify_case(const int& Expected, const int& Received) {
           63  + bool ok = (Expected == Received);
           64  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           65  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           66  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           67  +#define END  verify_case(_, SnowPlow().solve(roads));}
           68  +int main(){
           69  +
           70  +CASE(0)
           71  + string roads_[] = {"010000",
           72  + "101000",
           73  + "010100",
           74  + "001010",
           75  + "000101",
           76  + "000010"};
           77  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
           78  + int _ = 10;
           79  +END
           80  +CASE(1)
           81  + string roads_[] = {"010000",
           82  + "101000",
           83  + "010100",
           84  + "001020",
           85  + "000201",
           86  + "000010"};
           87  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
           88  + int _ = 12;
           89  +END
           90  +CASE(2)
           91  + string roads_[] = {"031415",
           92  + "300000",
           93  + "100000",
           94  + "400000",
           95  + "100000",
           96  + "500000"};
           97  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
           98  + int _ = 28;
           99  +END
          100  +CASE(3)
          101  + string roads_[] = {"0100",
          102  + "1000",
          103  + "0001",
          104  + "0010"};
          105  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          106  + int _ = -1;
          107  +END
          108  +CASE(4)
          109  + string roads_[] = {"0101",
          110  + "1001",
          111  + "0000",
          112  + "1100"};
          113  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          114  + int _ = 6;
          115  +END
          116  +/*
          117  +CASE(5)
          118  + string roads_[] = ;
          119  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          120  + int _ = ;
          121  +END
          122  +CASE(6)
          123  + string roads_[] = ;
          124  +   vector <string> roads(roads_, roads_+sizeof(roads_)/sizeof(*roads_));
          125  + int _ = ;
          126  +END
          127  +*/
          128  +}
          129  +// END CUT HERE

Added SRM/TCO10-2-U/1B.cpp version [cd08fa40861c2ec8]

            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 RepresentableNumbers { public:
           23  + int getNext(int X)
           24  + {
           25  +  for(;; ++X) {
           26  +   string s;
           27  +   {stringstream sio; sio<<X; sio>>s;}
           28  +   memo.clear();
           29  +   memo.resize(200, -1);
           30  +   if( rec(s, 0, false, false) )
           31  +    return X;
           32  +   if( s[0]=='1' ) {
           33  +    if( rec(s, 1, false, true) )
           34  +     return X;
           35  +   }
           36  +  }
           37  +  assert(false);
           38  + }
           39  +
           40  + vector<int> memo;
           41  + bool rec(const string& s, int i, bool mustUseBoth, bool needCarry)
           42  + {
           43  +  if( i == (int)s.size() )
           44  +   return !needCarry;
           45  +  if( i+1 == (int)s.size() )
           46  +   mustUseBoth = true;
           47  +
           48  +  int key = (i*2+mustUseBoth)*2+needCarry;
           49  +  if( memo[key]>=0 )
           50  +   return memo[key];
           51  +  int t = (s[i]-'0') + (needCarry ? 10 : 0);
           52  +
           53  +  if( !mustUseBoth && (t==1 || t==3 || t==5 || t==7 || t==9) )
           54  +   if( rec(s, i+1, false, false) )
           55  +    return memo[key]=true;
           56  +  if( !mustUseBoth && (t==2 || t==4 || t==6 || t==8 || t==10) )
           57  +   if( rec(s, i+1, false, true) )
           58  +    return memo[key]=true;
           59  +  if( t<=1 )
           60  +   return memo[key]=false;
           61  +  if( t%2==0 )
           62  +   return memo[key]=rec(s, i+1, true, false);
           63  +  else
           64  +   return memo[key]=rec(s, i+1, true, true);
           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) << " msec)"; return os.str(); }
           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 os; }
           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() << endl;
           79  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           80  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           81  +#define END  verify_case(_, RepresentableNumbers().getNext(X));}
           82  +int main(){
           83  +
           84  +CASE(0)
           85  + int X = 1;
           86  + int _ = 2;
           87  +END
           88  +CASE(1)
           89  + int X = 999;
           90  + int _ = 1000;
           91  +END
           92  +CASE(2)
           93  + int X = 2000;
           94  + int _ = 2000;
           95  +END
           96  +CASE(3)
           97  + int X = 4201234;
           98  + int _ = 4222222;
           99  +END
          100  +CASE(4)
          101  + int X = 10101010;
          102  + int _ = 10102222;
          103  +END
          104  +CASE(5)
          105  + int X = 2;
          106  + int _ = 2;
          107  +END
          108  +CASE(5)
          109  + int X = 3;
          110  + int _ = 4;
          111  +END
          112  +CASE(5)
          113  + int X = 4;
          114  + int _ = 4;
          115  +END
          116  +CASE(5)
          117  + int X = 5;
          118  + int _ = 6;
          119  +END
          120  +CASE(5)
          121  + int X = 6;
          122  + int _ = 6;
          123  +END
          124  +CASE(5)
          125  + int X = 20;
          126  + int _ = 20;
          127  +END
          128  +CASE(6)
          129  + int X = 100000000;
          130  + int _ = -1;
          131  +END
          132  +CASE(6)
          133  + int X =  42012345;
          134  + int _ = -1;
          135  +END
          136  +CASE(6)
          137  + int X =  21999999;
          138  + int _ = -1;
          139  +END
          140  +
          141  +
          142  +}
          143  +// END CUT HERE

Added SRM/TCO10-2-U/1C-U.cpp version [09d7f34f11d09ccc]

            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 BreakingChocolate { public:
           23  + int minSteps(int W, int H, vector <int> sx, vector <int> sy)
           24  + {
           25  +
           26  + }
           27  +};
           28  +
           29  +// BEGIN CUT HERE
           30  +#include <ctime>
           31  +double start_time; string timer()
           32  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           33  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           34  + { os << "{ ";
           35  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           36  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           37  +void verify_case(const int& Expected, const int& Received) {
           38  + bool ok = (Expected == Received);
           39  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           40  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           41  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           42  +#define END  verify_case(_, BreakingChocolate().minSteps(W, H, sx, sy));}
           43  +int main(){
           44  +
           45  +CASE(0)
           46  + int W = 3;
           47  + int H = 3;
           48  + int sx_[] = {2};
           49  +   vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_));
           50  + int sy_[] = {2};
           51  +   vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_));
           52  + int _ = 4;
           53  +END
           54  +CASE(1)
           55  + int W = 2;
           56  + int H = 2;
           57  + int sx_[] = {1,2};
           58  +   vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_));
           59  + int sy_[] = {2,1};
           60  +   vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_));
           61  + int _ = 3;
           62  +END
           63  +CASE(2)
           64  + int W = 10;
           65  + int H = 10;
           66  + int sx_[] = {1};
           67  +   vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_));
           68  + int sy_[] = {1};
           69  +   vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_));
           70  + int _ = 2;
           71  +END
           72  +CASE(3)
           73  + int W = 10;
           74  + int H = 10;
           75  + int sx_[] = {3,5,6};
           76  +   vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_));
           77  + int sy_[] = {5,5,5};
           78  +   vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_));
           79  + int _ = 6;
           80  +END
           81  +CASE(4)
           82  + int W = 3;
           83  + int H = 3;
           84  + int sx_[] = {1,1,1,2,2,3,3,3};
           85  +   vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_));
           86  + int sy_[] = {1,2,3,1,3,1,2,3};
           87  +   vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_));
           88  + int _ = 4;
           89  +END
           90  +CASE(5)
           91  + int W = ;
           92  + int H = ;
           93  + int sx_[] = ;
           94  +   vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_));
           95  + int sy_[] = ;
           96  +   vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_));
           97  + int _ = ;
           98  +END
           99  +CASE(6)
          100  + int W = ;
          101  + int H = ;
          102  + int sx_[] = ;
          103  +   vector <int> sx(sx_, sx_+sizeof(sx_)/sizeof(*sx_));
          104  + int sy_[] = ;
          105  +   vector <int> sy(sy_, sy_+sizeof(sy_)/sizeof(*sy_));
          106  + int _ = ;
          107  +END
          108  +
          109  +}
          110  +// END CUT HERE

Added SRM/TCO10-3/1A.cpp version [4a490e7a696723ed]

            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 SieveOfEratosthenes { public:
           23  + vector<int> eratos(int M)
           24  + {
           25  +  vector<bool> isComposite(M+1);
           26  +  vector<int> ps;
           27  +  for(int p=2; p<=M; ++p)
           28  +   if( !isComposite[p] )
           29  +   {
           30  +    ps.push_back(p);
           31  +    for(LL q=LL(p)*p; q<=M; q+=p)
           32  +     isComposite[q] = true;
           33  +   }
           34  +  return ps;
           35  + }
           36  +
           37  + int minFactor(int N, const vector<int>& ps)
           38  + {
           39  +  for(int i=0; i<ps.size(); ++i)
           40  +   if( N % ps[i] == 0 )
           41  +    return ps[i];
           42  +  return INT_MAX;
           43  + }
           44  +
           45  + int lastScratch(int maxNum)
           46  + {
           47  +  vector<int> ps = eratos(int(sqrt(double(maxNum))));
           48  +  int P = ps.back();
           49  +  int M = P*P;
           50  +  for(int Q=P+1; P*Q<=maxNum; ++Q)
           51  +   if( minFactor(Q,ps) >= P )
           52  +    M = P*Q;
           53  +  return M;
           54  + }
           55  +};
           56  +
           57  +// BEGIN CUT HERE
           58  +#include <ctime>
           59  +double start_time; string timer()
           60  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           61  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           62  + { os << "{ ";
           63  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           64  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           65  +void verify_case(const int& Expected, const int& Received) {
           66  + bool ok = (Expected == Received);
           67  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           68  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           69  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           70  +#define END  verify_case(_, SieveOfEratosthenes().lastScratch(maxNum));}
           71  +int main(){
           72  +
           73  +CASE(0)
           74  + int maxNum = 18;
           75  + int _ = 15;
           76  +END
           77  +CASE(1)
           78  + int maxNum = 5;
           79  + int _ = 4;
           80  +END
           81  +CASE(2)
           82  + int maxNum = 100;
           83  + int _ = 91;
           84  +END
           85  +CASE(3)
           86  + int maxNum = 400;
           87  + int _ = 361;
           88  +END
           89  +CASE(4)
           90  + int maxNum = 2000000000;
           91  + int _ = -1;
           92  +END
           93  +CASE(5)
           94  + int maxNum = 8;
           95  + int _ = 8;
           96  +END
           97  +}
           98  +// END CUT HERE

Added SRM/TCO10-3/1B.cpp version [c7168a3555d839b7]

            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 TheChroniclesOfAmber { public:
           23  + double minimumTime(vector <int> princeX, vector <int> princeY, vector <int> destinationX, vector <int> destinationY)
           24  + {
           25  +  int N = princeX.size();
           26  +
           27  +  // d[s][g] := the distance from prince[s] to dest[g]
           28  +  vector< vector<double> > d(N, vector<double>(N));
           29  +  for(int s=0; s<N; ++s)
           30  +   for(int g=0; g<N; ++g)
           31  +    d[s][g] = hypot(princeX[s]-destinationX[g], princeY[s]-destinationY[g]);
           32  +
           33  +  // no teleportation
           34  +  double noTelepo = 0;
           35  +  for(int i=0; i<N; ++i)
           36  +   noTelepo = max(noTelepo, d[i][i]);
           37  +
           38  +  // with teleportation: at least one position must be empty
           39  +  double answer = noTelepo;
           40  +  for(int unused_s=0; unused_s<N; ++unused_s) {
           41  +   double withTelepo = 0;
           42  +   for(int g=0; g<N; ++g) { // for each goal
           43  +    double t = 1e+300;
           44  +    for(int s=0; s<N; ++s) if( s != unused_s )
           45  +     t = min(t, d[s][g]); // find the nearest starting point
           46  +    withTelepo = max(withTelepo, t);
           47  +   }
           48  +   answer = min(answer, withTelepo); // take the minimum
           49  +  }
           50  +  return answer;
           51  + }
           52  +};
           53  +
           54  +// BEGIN CUT HERE
           55  +#include <ctime>
           56  +double start_time; string timer()
           57  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           58  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           59  + { os << "{ ";
           60  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           61  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           62  +void verify_case(const double& Expected, const double& Received) {
           63  + bool ok = (abs(Expected - Received) < 1e-9);
           64  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           65  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           66  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           67  +#define END  verify_case(_, TheChroniclesOfAmber().minimumTime(princeX, princeY, destinationX, destinationY));}
           68  +int main(){
           69  +
           70  +CASE(0)
           71  + int princeX_[] = {1,5,5};
           72  +   vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_));
           73  + int princeY_[] = {0,0,0};
           74  +   vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_));
           75  + int destinationX_[] = {1,1,0};
           76  +   vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_));
           77  + int destinationY_[] = {4,2,3};
           78  +   vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_));
           79  + double _ = 4.0;
           80  +END
           81  +CASE(1)
           82  + int princeX_[] = {0,0,0};
           83  +   vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_));
           84  + int princeY_[] = {1,2,3};
           85  +   vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_));
           86  + int destinationX_[] = {0,0,0};
           87  +   vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_));
           88  + int destinationY_[] = {0,2,4};
           89  +   vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_));
           90  + double _ = 1.0;
           91  +END
           92  +CASE(2)
           93  + int princeX_[] = {0,0,0};
           94  +   vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_));
           95  + int princeY_[] = {1,2,3};
           96  +   vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_));
           97  + int destinationX_[] = {0,0,0};
           98  +   vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_));
           99  + int destinationY_[] = {4,2,0};
          100  +   vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_));
          101  + double _ = 1.0;
          102  +END
          103  +CASE(3)
          104  + int princeX_[] = {0,3,5};
          105  +   vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_));
          106  + int princeY_[] = {0,4,0};
          107  +   vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_));
          108  + int destinationX_[] = {3,5,0};
          109  +   vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_));
          110  + int destinationY_[] = {4,0,0};
          111  +   vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_));
          112  + double _ = 4.47213595499958;
          113  +END
          114  +CASE(4)
          115  + int princeX_[] = {3629,6751,8655,5115,7809,6759,7133,1810,6102,2539,1777,242};
          116  +   vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_));
          117  + int princeY_[] = {5294,180,988,7780,1635,7904,845,7405,4800,2567,4795,2339};
          118  +   vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_));
          119  + int destinationX_[] = {8723,9275,6705,5875,7981,7666,1158,4135,17,2984,5086,3570};
          120  +   vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_));
          121  + int destinationY_[] = {6166,53,5980,4499,412,9074,8190,847,650,9158,9116,4396};
          122  +   vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_));
          123  + double _ = 2622.582696503582;
          124  +END
          125  +CASE(5)
          126  +int princeX_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
          127  +   vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_));
          128  + int princeY_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
          129  +   vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_));
          130  + int destinationX_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
          131  +   vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_));
          132  + int destinationY_[] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9};
          133  +   vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_));
          134  + double _ = 0;
          135  +END
          136  +/*
          137  +CASE(6)
          138  + int princeX_[] = ;
          139  +   vector <int> princeX(princeX_, princeX_+sizeof(princeX_)/sizeof(*princeX_));
          140  + int princeY_[] = ;
          141  +   vector <int> princeY(princeY_, princeY_+sizeof(princeY_)/sizeof(*princeY_));
          142  + int destinationX_[] = ;
          143  +   vector <int> destinationX(destinationX_, destinationX_+sizeof(destinationX_)/sizeof(*destinationX_));
          144  + int destinationY_[] = ;
          145  +   vector <int> destinationY(destinationY_, destinationY_+sizeof(destinationY_)/sizeof(*destinationY_));
          146  + double _ = ;
          147  +END
          148  +*/
          149  +}
          150  +// END CUT HERE

Added SRM/TCO10-3/1C.cpp version [244c2d068d085457]

            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 MODVAL = 1000000009;
           23  +struct mint
           24  +{
           25  + int val;
           26  + mint():val(0){}
           27  + mint(int x):val(x%MODVAL) {}
           28  + mint(LL  x):val(x%MODVAL) {}
           29  +};
           30  +
           31  +mint operator+(mint x, mint y) { return x.val+y.val; }
           32  +mint operator-(mint x, mint y) { return x.val-y.val+MODVAL; }
           33  +mint operator*(mint x, mint y) { return LL(x.val)*y.val; }
           34  +mint POW(mint x, int e) {
           35  + mint v = 1;
           36  + for(;e;x=x*x,e>>=1)
           37  +  if(e&1)
           38  +   v=v*x;
           39  + return v;
           40  +}
           41  +mint operator/(mint x, mint y) { return x * POW(y, MODVAL-2); }
           42  +
           43  +vector<mint> FAC_(1,1);
           44  +void FAC_INIT(int n) { for(int i=1; i<=n; ++i) FAC_.push_back( FAC_.back()*i ); }
           45  +mint FAC(mint x)       { return FAC_[x.val]; }
           46  +mint C(mint n, mint k) { return k.val<0 || n.val<k.val ? 0 : FAC(n) / (FAC(k) * FAC(n-k)); }
           47  +
           48  +class Passwords { public:
           49  + int countValid(int N, int L, int U, int D)
           50  + {
           51  +  FAC_INIT(200000);
           52  +
           53  +  //  Sigma_{D<=d<=N-U-L} [C(N,d) 10^d Sigma_{L<=l,U<=u,u+l=N-d}[ C(N-d,u) 26^u 26^l ] ]
           54  +  //= Sigma_{D<=d<=N-U-L} [C(N,d) 10^d 26^(N-d) Sigma_{U<=u<=N-d-L}[ C(N-d,u) ] ]
           55  +  //   let f(N') = Sigma_{U<=u<=N'-L}[ C(N',u) ]
           56  +  //      then by Pascal's triangle, f(N') = 2*f(N'-1)+C(N'-1,U-1)+C(N'-1,N'-L)
           57  +
           58  +  mint answer=0, f=C(U+L,U);
           59  +  for(int d=N-U-L; d>=D; --d)
           60  +  {
           61  +   answer = answer + C(N,d)*POW(10,d)*POW(26,N-d)*f;
           62  +   f = f*2 + C(N-d,U-1) + C(N-d, N-d-L+1);
           63  +  }
           64  +  return answer.val;
           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) << " msec)"; return os.str(); }
           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 os; }
           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() << endl;
           79  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           80  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           81  +#define END  verify_case(_, Passwords().countValid(N, L, U, D));}
           82  +int main(){
           83  +
           84  +CASE(0)
           85  + int N = 2;
           86  + int L = 0;
           87  + int U = 0;
           88  + int D = 2;
           89  + int _ = 100;
           90  +END
           91  +CASE(1)
           92  + int N = 3;
           93  + int L = 1;
           94  + int U = 1;
           95  + int D = 1;
           96  + int _ = 40560;
           97  +END
           98  +CASE(2)
           99  + int N = 4;
          100  + int L = 1;
          101  + int U = 1;
          102  + int D = 1;
          103  + int _ = 5029440;
          104  +END
          105  +CASE(3)
          106  + int N = 10;
          107  + int L = 1;
          108  + int U = 3;
          109  + int D = 3;
          110  + int _ = 818019214;
          111  +END
          112  +CASE(4)
          113  + int N = 5;
          114  + int L = 2;
          115  + int U = 2;
          116  + int D = 2;
          117  + int _ = 0;
          118  +END
          119  +CASE(5)
          120  + int N = 199201;
          121  + int L = 0;
          122  + int U = 70000;
          123  + int D = 0;
          124  + int _ = 943311211;
          125  +END
          126  +CASE(6)
          127  + int N = 200000;
          128  + int L = 11;
          129  + int U = 111;
          130  + int D = 1111;
          131  + int _ = 298235838;
          132  +END
          133  +}
          134  +// END CUT HERE

Added SRM/TCO9-1/A.cpp version [07008cbdf3a5db57]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class SequenceSums {
           21  +public:
           22  + vector <int> sequence(int N, int LL)
           23  + {
           24  +  for(int L=LL; L<=100; ++L)
           25  +  {
           26  +   int Z = N - L*(L-1)/2;
           27  +   if( Z % L )
           28  +    continue;
           29  +   int a = Z / L;
           30  +   if( a < 0 )
           31  +    continue;
           32  +
           33  +   vector<int> ans;
           34  +   for(int x=a; x<a+L; ++x)
           35  +    ans.push_back(x);
           36  +   return ans;
           37  +  }
           38  +  return vector<int>();
           39  + }
           40  +};
           41  +
           42  +// BEGIN CUT HERE
           43  +#include <ctime>
           44  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           45  +
           46  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           47  +int verify_case(const vector <int> &Expected, const vector <int> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           48  +
           49  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           50  +char Test_(...);
           51  +int Test_(Case_<0>) {
           52  + int N = 18;
           53  + int L = 2;
           54  + int RetVal_[] = {5, 6, 7 };
           55  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           56  + return verify_case(RetVal, SequenceSums().sequence(N, L)); }
           57  +int Test_(Case_<1>) {
           58  + int N = 18;
           59  + int L = 4;
           60  + int RetVal_[] = {3, 4, 5, 6 };
           61  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           62  + return verify_case(RetVal, SequenceSums().sequence(N, L)); }
           63  +int Test_(Case_<2>) {
           64  + int N = 18;
           65  + int L = 5;
           66  + vector <int> RetVal;
           67  + return verify_case(RetVal, SequenceSums().sequence(N, L)); }
           68  +int Test_(Case_<3>) {
           69  + int N = 45;
           70  + int L = 10;
           71  + int RetVal_[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
           72  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           73  + return verify_case(RetVal, SequenceSums().sequence(N, L)); }
           74  +int Test_(Case_<4>) {
           75  + int N = 1000000000;
           76  + int L = 2;
           77  + int RetVal_[] = {199999998, 199999999, 200000000, 200000001, 200000002 };
           78  +   vector <int> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           79  + return verify_case(RetVal, SequenceSums().sequence(N, L)); }
           80  +
           81  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
           82  +template<>      void Run_<-1>() {}
           83  +int main() { Run_<0>(); }
           84  +// END CUT HERE
           85  +

Added SRM/TCO9-1/B.cpp version [9180662f25d62836]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +class KthProbableElement {
           21  +public:
           22  +  double probability(int M, int lowerBound, int upperBound, int N, int K)
           23  +  {
           24  +    double dp1[101][101]={0}, dp2[101][101], (*P)[101]=dp1, (*Q)[101]=dp2;
           25  +
           26  +    P[0][0] = 1.0;
           27  +    for(int i=0; i<M; ++i)
           28  +    {
           29  +      memset( Q, 0, sizeof(double)*101*101 );
           30  +      for(int a=0; a<=i; ++a)
           31  +        for(int b=0; a+b<=i; ++b)
           32  +        {
           33  +          Q[a+1][b] += P[a][b] * (N-lowerBound) / (upperBound-lowerBound+1);
           34  +          Q[a][b+1] += P[a][b] * 1 / (upperBound-lowerBound+1);
           35  +          Q[a][b]   += P[a][b] * (upperBound-N) / (upperBound-lowerBound+1);
           36  +        }
           37  +      swap(P, Q);
           38  +    }
           39  +
           40  +    double p = 0.0;
           41  +    for(int a=0; a<=M; ++a)
           42  +      for(int b=0; a+b<=M; ++b)
           43  +        if( a<K && K<=a+b )
           44  +          p += P[a][b];
           45  +    return p;
           46  +  }
           47  +};
           48  +
           49  +// BEGIN CUT HERE
           50  +#include <ctime>
           51  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           52  +
           53  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           54  +int verify_case(const double &Expected, const double &Received) { double diff = Expected - Received; if (diff < 0) diff = -diff; if (diff < 1e-9) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           55  +
           56  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           57  +char Test_(...);
           58  +int Test_(Case_<0>) {
           59  +  int M = 1;
           60  +  int lowerBound = 1;
           61  +  int upperBound = 10;
           62  +  int N = 3;
           63  +  int K = 1;
           64  +  double RetVal = 0.1;
           65  +  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
           66  +int Test_(Case_<1>) {
           67  +  int M = 3;
           68  +  int lowerBound = 1;
           69  +  int upperBound = 2;
           70  +  int N = 2;
           71  +  int K = 2;
           72  +  double RetVal = 0.5;
           73  +  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
           74  +int Test_(Case_<2>) {
           75  +  int M = 3;
           76  +  int lowerBound = 1;
           77  +  int upperBound = 3;
           78  +  int N = 2;
           79  +  int K = 2;
           80  +  double RetVal = 0.48148148148148145;
           81  +  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
           82  +int Test_(Case_<3>) {
           83  +  int M = 10;
           84  +  int lowerBound = 1;
           85  +  int upperBound = 10;
           86  +  int N = 1;
           87  +  int K = 10;
           88  +  double RetVal = 1.0000000000000003E-10;
           89  +  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
           90  +int Test_(Case_<4>) {
           91  +  int M = 4;
           92  +  int lowerBound = 61;
           93  +  int upperBound = 65;
           94  +  int N = 62;
           95  +  int K = 3;
           96  +  double RetVal = 0.15200000000000002;
           97  +  return verify_case(RetVal, KthProbableElement().probability(M, lowerBound, upperBound, N, K)); }
           98  +
           99  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          100  +template<>      void Run_<-1>() {}
          101  +int main() { Run_<0>(); }
          102  +// END CUT HERE
          103  +

Added SRM/TCO9-1/C.cpp version [850feccc28db3e68]

            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 <complex>
           12  +#include <queue>
           13  +#include <stack>
           14  +#include <cmath>
           15  +#include <cassert>
           16  +#include <cstring>
           17  +using namespace std;
           18  +typedef long long LL;
           19  +
           20  +static const int MODVAL = 1000000007;
           21  +int ADD(int x, int y) { return (x+y)%MODVAL; }
           22  +int SUB(int x, int y) { return (x-y+MODVAL)%MODVAL; }
           23  +
           24  +class Unicorn {
           25  +public:
           26  + int countWays(int R, int C, int L, int seed, string word)
           27  + {
           28  +  // input...
           29  +  char B[300][300];
           30  +  {
           31  +   int x = seed;
           32  +   int d = (65535 / L)+1;
           33  +   for (int r=0; r<R; r++)
           34  +     for (int c=0; c<C; c++) {
           35  +       x = (x * 25173 + 13849) % 65536;
           36  +       B[r][c] = (65+(x / d));
           37  +     }
           38  +  }
           39  +
           40  +  // solve
           41  +  vector<int> cnt(C*R);
           42  +  for(int r=0; r<R; ++r)
           43  +  for(int c=0; c<C; ++c)
           44  +   if( B[r][c] == word[0] )
           45  +    cnt[r*C+c] = 1;
           46  +
           47  +  for(int i=1; i<word.size(); ++i)
           48  +  {
           49  +   int total_cnt = 0;
           50  +   vector<int> c_cnt(C);
           51  +   vector<int> r_cnt(R);
           52  +   for(int r=0; r<R; ++r)
           53  +   for(int c=0; c<C; ++c)
           54  +    r_cnt[r]  = ADD( r_cnt[r], cnt[r*C+c]),
           55  +    c_cnt[c]  = ADD( c_cnt[c], cnt[r*C+c]),
           56  +    total_cnt = ADD(total_cnt, cnt[r*C+c]);
           57  +
           58  +   vector<int> cnt2(C*R);
           59  +   for(int r=0; r<R; ++r)
           60  +   for(int c=0; c<C; ++c)
           61  +    if( B[r][c] == word[i] )
           62  +    {
           63  +     int x = total_cnt;
           64  +
           65  +     for(int rr=r-1; rr<=r+1; ++rr) if(0<=rr && rr<R)
           66  +      x = SUB(x, r_cnt[rr]);
           67  +     for(int cc=c-1; cc<=c+1; ++cc) if(0<=cc && cc<C)
           68  +      x = SUB(x, c_cnt[cc]);
           69  +
           70  +     for(int rr=r-1; rr<=r+1; ++rr) if(0<=rr && rr<R)
           71  +     for(int cc=c-1; cc<=c+1; ++cc) if(0<=cc && cc<C)
           72  +      x = ADD(x, cnt[rr*C+cc]);
           73  +
           74  +     for(int rr=r-2; rr<=r+2; rr+=4) if(0<=rr && rr<R)
           75  +     for(int cc=c-2; cc<=c+2; cc+=4) if(0<=cc && cc<C)
           76  +      x = SUB(x, cnt[rr*C+cc]);
           77  +
           78  +     cnt2[r*C+c] = x;
           79  +    }
           80  +   cnt.swap(cnt2);
           81  +  }
           82  +
           83  +  int live = 0;
           84  +  for(int r=0; r<R; ++r)
           85  +  for(int c=0; c<C; ++c)
           86  +   live = ADD(live, cnt[r*C+c]);
           87  +  return live;
           88  + }
           89  +};
           90  +
           91  +// BEGIN CUT HERE
           92  +#include <ctime>
           93  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           94  +
           95  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           96  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           97  +
           98  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           99  +char Test_(...);
          100  +int Test_(Case_<0>) {
          101  + int R = 3;
          102  + int C = 4;
          103  + int L = 2;
          104  + int seed = 47;
          105  + string word = "AB";
          106  + int RetVal = 2;
          107  + return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
          108  +int Test_(Case_<1>) {
          109  + int R = 5;
          110  + int C = 5;
          111  + int L = 2;
          112  + int seed = 47;
          113  + string word = "CD";
          114  + int RetVal = 0;
          115  + return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
          116  +int Test_(Case_<2>) {
          117  + int R = 4;
          118  + int C = 4;
          119  + int L = 1;
          120  + int seed = 42;
          121  + string word = "AA";
          122  + int RetVal = 20;
          123  + return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
          124  +int Test_(Case_<3>) {
          125  + int R = 4;
          126  + int C = 4;
          127  + int L = 1;
          128  + int seed = 42;
          129  + string word = "AAAAA";
          130  + int RetVal = 172;
          131  + return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
          132  +int Test_(Case_<4>) {
          133  + int R = 1;
          134  + int C = 1;
          135  + int L = 5;
          136  + int seed = 54321;
          137  + string word = "ABCDE";
          138  + int RetVal = 0;
          139  + return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
          140  +int Test_(Case_<5>) {
          141  + int R = 8;
          142  + int C = 8;
          143  + int L = 26;
          144  + int seed = 226;
          145  + string word = "TOPCODER";
          146  + int RetVal = 1;
          147  + return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
          148  +int Test_(Case_<6>) {
          149  + int R = 20;
          150  + int C = 20;
          151  + int L = 2;
          152  + int seed = 47;
          153  + string word = "AAAAA";
          154  + int RetVal = 373977054;
          155  + return verify_case(RetVal, Unicorn().countWays(R, C, L, seed, word)); }
          156  +
          157  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          158  +template<>      void Run_<-1>() {}
          159  +int main() { Run_<0>(); }
          160  +// END CUT HERE
          161  +

Added SRM/TCO9-2/1A.cpp version [b8cf68d0e0d741f2]

            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  +LL s, N, K;
           23  +
           24  +class PlaneFractal {
           25  +public:
           26  + vector <string> getPattern(int _s, int _N, int _K, int r1, int r2, int c1, int c2)
           27  + {
           28  +  s = _s;
           29  +  N = _N;
           30  +  K = _K;
           31  +
           32  +  LL Ns=1; for(int i=0; i<s-1; ++i) Ns*=N;
           33  +
           34  +  vector<string> ans(r2-r1+1, string(c2-c1+1, '0'));
           35  +  for(int r=r1; r<=r2; ++r)
           36  +  for(int c=c1; c<=c2; ++c)
           37  +   if( s>0 && black(r,c,Ns) )
           38  +    ans[r-r1][c-c1] = '1';
           39  +  return ans;
           40  + }
           41  +
           42  + bool black(int y, int x, LL Ns) const
           43  + {
           44  +  if( Ns == 0 )
           45  +   return false;
           46  +
           47  +  int Y = y/Ns, X = x/Ns;
           48  +  y%=Ns, x%=Ns;
           49  +  if( (Y<(N-K)/2 || N-(N-K)/2<=Y) || (X<(N-K)/2 || N-(N-K)/2<=X) )
           50  +   return black(y, x, Ns/N);
           51  +  return true;
           52  + }
           53  +};
           54  +
           55  +// BEGIN CUT HERE
           56  +#include <ctime>
           57  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           58  +
           59  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           60  +int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
           61  +
           62  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           63  +char Test_(...);
           64  +int Test_(Case_<0>) {
           65  + int s = 1;
           66  + int N = 5;
           67  + int K = 3;
           68  + int r1 = 0;
           69  + int r2 = 4;
           70  + int c1 = 0;
           71  + int c2 = 4;
           72  + string RetVal_[] = {"00000", "01110", "01110", "01110", "00000" };
           73  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           74  + return verify_case(RetVal, PlaneFractal().getPattern(s, N, K, r1, r2, c1, c2)); }
           75  +int Test_(Case_<1>) {
           76  + int s = 2;
           77  + int N = 3;
           78  + int K = 1;
           79  + int r1 = 0;
           80  + int r2 = 8;
           81  + int c1 = 0;
           82  + int c2 = 8;
           83  + string RetVal_[] = {"000000000", "010010010", "000000000", "000111000", "010111010", "000111000", "000000000", "010010010", "000000000" };
           84  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           85  + return verify_case(RetVal, PlaneFractal().getPattern(s, N, K, r1, r2, c1, c2)); }
           86  +int Test_(Case_<2>) {
           87  + int s = 3;
           88  + int N = 3;
           89  + int K = 1;
           90  + int r1 = 4;
           91  + int r2 = 11;
           92  + int c1 = 5;
           93  + int c2 = 10;
           94  + string RetVal_[] = {"101001", "100000", "000000", "001001", "000000", "000011", "001011", "000011" };
           95  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
           96  + return verify_case(RetVal, PlaneFractal().getPattern(s, N, K, r1, r2, c1, c2)); }
           97  +int Test_(Case_<3>) {
           98  + int s = 2;
           99  + int N = 8;
          100  + int K = 4;
          101  + int r1 = 56;
          102  + int r2 = 61;
          103  + int c1 = 33;
          104  + int c2 = 56;
          105  + string RetVal_[] = {"000000000000000000000000", "000000000000000000000000", "011110000111100001111000", "011110000111100001111000", "011110000111100001111000", "011110000111100001111000" };
          106  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          107  + return verify_case(RetVal, PlaneFractal().getPattern(s, N, K, r1, r2, c1, c2)); }
          108  +
          109  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          110  +template<>      void Run_<-1>() {}
          111  +int main() { Run_<0>(); }
          112  +// END CUT HERE
          113  +

Added SRM/TCO9-2/1B.cpp version [5c2f54954f3e8b6d]

            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<int> 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  +int area(const CMP& a, const CMP& b, const CMP& c)
           61  +{
           62  + return (int) abs( outer_prod(b-a,c-a) );
           63  +}
           64  +
           65  +class ExtendableTriangles {
           66  +public:
           67  + int getCount(vector <string> grid)
           68  + {
           69  +  vector<CMP> r, g, b;
           70  +  for(int y=0; y<grid.size(); ++y)
           71  +   for(int x=0; x<grid[0].size(); ++x)
           72  +    (grid[y][x]=='R' ? r : grid[y][x]=='G' ? g : b).push_back( CMP(y,x) );
           73  +
           74  +  int cnt = r.size() * g.size() * b.size();
           75  +
           76  +  r = convex_hull(r);
           77  +  g = convex_hull(g);
           78  +  b = convex_hull(b);
           79  +
           80  +  bool (*ext)[200][200] = (bool(*)[200][200])calloc(200*200*200, 1);
           81  +  for(int i=0; i<r.size(); ++i)
           82  +   for(int j=0; j<g.size(); ++j)
           83  +   {
           84  +    int ma = -1;
           85  +    for(int k=0; k<b.size(); ++k)
           86  +     ma = max(ma, area(r[i], g[j], b[k]));
           87  +    for(int k=0; k<b.size(); ++k)
           88  +     if( area(r[i], g[j], b[k]) < ma )
           89  +      ext[i][j][k] = true;
           90  +   }
           91  +  for(int j=0; j<g.size(); ++j)
           92  +   for(int k=0; k<b.size(); ++k)
           93  +   {
           94  +    int ma = -1;
           95  +    for(int i=0; i<r.size(); ++i)
           96  +     ma = max(ma, area(r[i], g[j], b[k]));
           97  +    for(int i=0; i<r.size(); ++i)
           98  +     if( area(r[i], g[j], b[k]) < ma )
           99  +      ext[i][j][k] = true;
          100  +   }
          101  +  for(int k=0; k<b.size(); ++k)
          102  +   for(int i=0; i<r.size(); ++i)
          103  +   {
          104  +    int ma = -1;
          105  +    for(int j=0; j<g.size(); ++j)
          106  +     ma = max(ma, area(r[i], g[j], b[k]));
          107  +    for(int j=0; j<g.size(); ++j)
          108  +     if( area(r[i], g[j], b[k]) < ma )
          109  +      ext[i][j][k] = true;
          110  +   }
          111  +  for(int i=0; i<r.size(); ++i)
          112  +   for(int j=0; j<g.size(); ++j)
          113  +    for(int k=0; k<b.size(); ++k)
          114  +     if( !ext[i][j][k] )
          115  +      --cnt;
          116  +  free(ext);
          117  +  return cnt;
          118  + }
          119  +};
          120  +
          121  +// BEGIN CUT HERE
          122  +#include <ctime>
          123  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          124  +
          125  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          126  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
          127  +
          128  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          129  +char Test_(...);
          130  +
          131  +int Test_(Case_<0>) {
          132  + string grid_[] = {"RGB"};
          133  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          134  + int RetVal = 0;
          135  + return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
          136  +int Test_(Case_<1>) {
          137  + string grid_[] = {"RGB",
          138  + "RGB"};
          139  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          140  + int RetVal = 6;
          141  + return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
          142  +int Test_(Case_<2>) {
          143  + string grid_[] = {"RRRRRRRR",
          144  + "GGGGBBBB",
          145  + "RRRRRRRR"};
          146  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          147  + int RetVal = 240;
          148  + return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
          149  +int Test_(Case_<3>) {
          150  + string grid_[] = {"RBRBRBRB",
          151  + "BRBRBRBR",
          152  + "RBRBRBRB",
          153  + "BRBRBRBR",
          154  + "RRRRRRRR",
          155  + "BBBBBBBB",
          156  + "RRRRBBBB",
          157  + "BBBBRRRR"};
          158  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          159  + int RetVal = 0;
          160  + return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
          161  +int Test_(Case_<4>) {
          162  + string grid_[] = {"RGB",
          163  + "RBG",
          164  + "GRB",
          165  + "GBR",
          166  + "BRG",
          167  + "BGR"};
          168  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          169  + int RetVal = 208;
          170  + return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
          171  +int Test_(Case_<5>) {
          172  + string grid_[] = {"BBRRBBGRBG"};
          173  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          174  + int RetVal = 0;
          175  + return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
          176  +int Test_(Case_<6>) {
          177  + string grid_[] = {"RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR", "RGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGR", "RGBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBGRGBRBRGBBBBGBRBRBRGRGBBBBRRBGGRGRBGBBBBBGR", "RGBBBGRGRBRGBRGBRGBRGBGGBRBRBRGBRGBRGGBRBBBBBBBBGR", "RGBBBRGBRBRBRGBRGBRBRBRBRGBRGGGGRRBBRGBBBGRRGRBBGR", "RGBBRRGBRBRBRGGBRGRRGRGBRGBRBRGRGBRGRGRGRBRBGRGBGR", "RGBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBGR", "RGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGR", "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR"};
          178  +   vector <string> grid(grid_, grid_+sizeof(grid_)/sizeof(*grid_));
          179  + int RetVal = 565039154;
          180  + return verify_case(RetVal, ExtendableTriangles().getCount(grid)); }
          181  +
          182  +
          183  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          184  +template<>      void Run_<-1>() {}
          185  +int main() { Run_<0>(); }
          186  +// END CUT HERE
          187  +

Added SRM/TCO9-2/1C.cpp version [f35e47b64486be8c]

            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 NV = 128;
           23  +typedef int           flow;
           24  +typedef int           vert;
           25  +typedef vert          edge;
           26  +typedef vector<edge>  edges;
           27  +typedef vector<edges> graph;
           28  +typedef flow          flow_graph[NV][NV];
           29  +
           30  +flow dinic_dfs( graph& G, flow_graph F, vert v, vert D,
           31  +                int LV[], flow flow_in, int blocked[] )
           32  +{
           33  + flow flow_out = 0;
           34  + for(int i=0; i!=G[v].size(); ++i) {
           35  +  int u = G[v][i];
           36  +  if( LV[v]+1==LV[u] && F[v][u] ) {
           37  +   flow f = min(flow_in-flow_out, F[v][u]);
           38  +   if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) ) {
           39  +    F[v][u]  -= f;
           40  +    F[u][v]  += f;
           41  +    flow_out += f;
           42  +    if( flow_in == flow_out ) return flow_out;
           43  +   }
           44  +  }
           45  + }
           46  + blocked[v] = (flow_out==0);
           47  + return flow_out;
           48  +}
           49  +
           50  +flow maxFlow( graph& G, flow_graph F, vert S, vert D )
           51  +{
           52  + for( flow total=0 ;; ) {
           53  +  int LV[NV] = {0};
           54  +  vector<int> Q(1, S);
           55  +  for(int lv=1; !Q.empty(); ++lv) {
           56  +   vector<int> Q2;
           57  +   for(int i=0; i!=Q.size(); ++i) {
           58  +    edges& ne = G[Q[i]];
           59  +    for(int j=0; j!=ne.size(); ++j)
           60  +     if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
           61  +      LV[ne[j]]=lv, Q2.push_back(ne[j]);
           62  +   }
           63  +   Q.swap(Q2);
           64  +  }
           65  +
           66  +  if( !LV[D] )
           67  +   return total;
           68  +
           69  +  int blocked[NV] = {};
           70  +  total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
           71  + }
           72  +}
           73  +
           74  +flow_graph F, XXF;
           75  +
           76  +class ConnectingAirports {
           77  +public:
           78  + vector <string> getSchedule(vector <int> capacityA, vector <int> capacityB)
           79  + {
           80  +  int NA = capacityA.size();
           81  +  int NB = capacityB.size();
           82  +  int CAsum = accumulate(capacityA.begin(), capacityA.end(), 0);
           83  +  int CBsum = accumulate(capacityB.begin(), capacityB.end(), 0);
           84  +  if( CAsum != CBsum )
           85  +   return vector<string>();
           86  +
           87  +  graph G(2+NA+NB);
           88  +  memset(XXF, 0, sizeof XXF);
           89  +  for(int i=0; i<capacityA.size(); ++i) {
           90  +   G[0].push_back( 2+i );
           91  +   G[2+i].push_back( 0 );
           92  +   XXF[0][2+i] = capacityA[i];
           93  +  }
           94  +  for(int i=0; i<capacityB.size(); ++i) {
           95  +   G[2+NA+i].push_back( 1 );
           96  +   G[1].push_back( 2+NA+i );
           97  +   XXF[2+NA+i][1] = capacityB[i];
           98  +  }
           99  +  for(int i=0; i<capacityA.size(); ++i)
          100  +  for(int j=0; j<capacityB.size(); ++j) {
          101  +   G[2+i].push_back( 2+NA+j );
          102  +   G[2+NA+j].push_back( 2+i );
          103  +   XXF[2+i][2+NA+j] = 1;
          104  +  }
          105  +
          106  +  memcpy(F, XXF, sizeof F);
          107  +  flow mf = maxFlow(G,F,0,1);
          108  +  if( mf != CAsum )
          109  +   return vector<string>();
          110  +
          111  +  // find lex-best
          112  +  int rest = CAsum;
          113  +  vector<string> ans(NA, string(NB, '0'));
          114  +  for(int i=0; i<capacityA.size(); ++i)
          115  +  for(int j=0; j<capacityB.size(); ++j)
          116  +  {
          117  +   if( rest==0 )
          118  +    return ans;
          119  +
          120  +   memcpy(F, XXF, sizeof F);
          121  +   bool toUse = true;
          122  +
          123  +   F[2+i][2+NA+j] --;
          124  +   flow mf = maxFlow(G,F,0,1);
          125  +   toUse = (mf < rest);
          126  +
          127  +   ans[i][j] = toUse ? '1' : '0';
          128  +   if( toUse ) {
          129  +    XXF[0][2+i] --;
          130  +    XXF[2+NA+j][1] --;
          131  +    rest--;
          132  +   }
          133  +   XXF[2+i][2+NA+j] --;
          134  +  }
          135  +  return ans;
          136  + }
          137  +};
          138  +
          139  +// BEGIN CUT HERE
          140  +#include <ctime>
          141  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          142  +
          143  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
          144  +int verify_case(const vector <string> &Expected, const vector <string> &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: " << print_array(Expected) << endl; cerr << "\tReceived: " << print_array(Received) << endl; } return 0;}
          145  +
          146  +template<int N> struct Case_ { Case_(){start_time=clock();} };
          147  +char Test_(...);
          148  +int Test_(Case_<0>) {
          149  + int capacityA_[] = {1,2,3};
          150  +   vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_));
          151  + int capacityU_[] = {3,1,2};
          152  +   vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_));
          153  + string RetVal_[] = {"100", "101", "111" };
          154  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          155  + return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
          156  +int Test_(Case_<1>) {
          157  + int capacityA_[] = {3,2,1,1};
          158  +   vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_));
          159  + int capacityU_[] = {1,3,1,2};
          160  +   vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_));
          161  + string RetVal_[] = {"0111", "0101", "0100", "1000" };
          162  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          163  + return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
          164  +int Test_(Case_<2>) {
          165  + int capacityA_[] = {1,2,3,4};
          166  +   vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_));
          167  + int capacityU_[] = {5,6,7,8};
          168  +   vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_));
          169  + vector <string> RetVal;
          170  + return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
          171  +int Test_(Case_<3>) {
          172  + int capacityA_[] = {47,47};
          173  +   vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_));
          174  + int capacityU_[] = {47,40,7};
          175  +   vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_));
          176  + vector <string> RetVal;
          177  + return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
          178  +int Test_(Case_<4>) {
          179  + int capacityA_[] = {5,5};
          180  +   vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_));
          181  + int capacityU_[] = {1,1,2,1,1,1,1,1,1};
          182  +   vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_));
          183  + string RetVal_[] = {"001001111", "111110000" };
          184  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          185  + return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
          186  +int Test_(Case_<5>) {
          187  + int capacityA_[] = {0,0,0,0};
          188  +   vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_));
          189  + int capacityU_[] = {0,0,0,0,0,0};
          190  +   vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_));
          191  + string RetVal_[] = {"000000", "000000", "000000", "000000" };
          192  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          193  + return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
          194  +int Test_(Case_<6>) {
          195  + int capacityA_[] = {50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,};
          196  +   vector <int> capacityA(capacityA_, capacityA_+sizeof(capacityA_)/sizeof(*capacityA_));
          197  + int capacityU_[] = {50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,};
          198  +   vector <int> capacityU(capacityU_, capacityU_+sizeof(capacityU_)/sizeof(*capacityU_));
          199  + string RetVal_[] = {"000000", "000000", "000000", "000000" };
          200  +   vector <string> RetVal(RetVal_, RetVal_+sizeof(RetVal_)/sizeof(*RetVal_));
          201  + return verify_case(RetVal, ConnectingAirports().getSchedule(capacityA, capacityU)); }
          202  +
          203  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          204  +template<>      void Run_<-1>() {}
          205  +int main() { Run_<0>(); }
          206  +// END CUT HERE
          207  +

Added SRM/TCO9-3-U/1A.cpp version [7f6a0aa40df322bf]

            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 SaveTheTrees {
           23  +public:
           24  + int minimumCut(vector <int> x, vector <int> y, vector <int> h)
           25  + {
           26  +  int N = x.size();
           27  +  int ans = N-1;
           28  +  for(int i1=0; i1<N; ++i1)
           29  +  for(int i2=0; i2<N; ++i2)
           30  +  for(int k1=0; k1<N; ++k1)
           31  +  for(int k2=0; k2<N; ++k2) {
           32  +   int mx = min(x[i1], x[i2]);
           33  +   int Mx = max(x[i1], x[i2]);
           34  +   int my = min(y[k1], y[k2]);
           35  +   int My = max(y[k1], y[k2]);
           36  +
           37  +   int hh[40], q=0;
           38  +   int cut = 0, need = ((Mx-mx) + (My-my))*2;
           39  +   for(int j=0; j<N; ++j)
           40  +    if( mx<=x[j] && x[j]<=Mx && my<=y[j] && y[j]<=My )
           41  +     hh[q++] = h[j];
           42  +    else {
           43  +     cut++, need-=h[j];
           44  +     if(cut>=ans) goto next;
           45  +    }
           46  +   if( need > 0 )
           47  +   {
           48  +    sort( &hh[0], &hh[q], greater<int>() );
           49  +//    partial_sum( &hh[0], &hh[q], &hh[0] );
           50  +//    cut += lower_bound( &hh[0], &hh[q], need ) - &hh[0];
           51  +    for(int p=0; p<q; ++p) {
           52  +     ++cut, need -= hh[p];
           53  +     if(cut>=ans) goto next;
           54  +     if(need <= 0) break;
           55  +    }
           56  +   }
           57  +   ans = cut;
           58  +  next:;
           59  +  }
           60  +  return ans;
           61  + }
           62  +};
           63  +
           64  +// BEGIN CUT HERE
           65  +#include <ctime>
           66  +double start_time;string timer() { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           67  +
           68  +template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
           69  +int verify_case(const int &Expected, const int &Received) { if (Expected == Received) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } return 0;}
           70  +
           71  +template<int N> struct Case_ { Case_(){start_time=clock();} };
           72  +char Test_(...);
           73  +int Test_(Case_<0>) {
           74  + int x_[] = {1, 2, 8, 9, 5};
           75  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           76  + int y_[] = {1, 8, 2, 9, 5};
           77  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           78  + int h_[] = {1, 1, 1, 1, 32};
           79  +   vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_));
           80  + int RetVal = 1;
           81  + return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
           82  +int Test_(Case_<1>) {
           83  + int x_[] = {1, 2, 8, 9, 5};
           84  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           85  + int y_[] = {1, 8, 2, 9, 5};
           86  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           87  + int h_[] = {1, 1, 1, 1, 27};
           88  +   vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_));
           89  + int RetVal = 2;
           90  + return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
           91  +int Test_(Case_<2>) {
           92  + int x_[] = {1, 2, 8, 9, 5};
           93  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
           94  + int y_[] = {1, 8, 2, 9, 5};
           95  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
           96  + int h_[] = {4, 4, 4, 4, 4};
           97  +   vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_));
           98  + int RetVal = 3;
           99  + return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
          100  +int Test_(Case_<3>) {
          101  + int x_[] = {1, 2, 8, 9, 5};
          102  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          103  + int y_[] = {1, 8, 2, 9, 5};
          104  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          105  + int h_[] = {3, 3, 3, 3, 3};
          106  +   vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_));
          107  + int RetVal = 4;
          108  + return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
          109  +int Test_(Case_<4>) {
          110  + int x_[] = {3, 10, 6, 2, 8, 7, 5, 4, 9, 1};
          111  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          112  + int y_[] = {4, 10, 6, 9, 8, 7, 3, 2, 5, 1};
          113  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          114  + int h_[] = {4, 2, 2, 4, 4, 5, 4, 4, 2, 3};
          115  +   vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_));
          116  + int RetVal = 5;
          117  + return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
          118  +int Test_(Case_<5>) {
          119  + int x_[] = {55, 67, 100, 38, 80, 98, 47, 58, 61, 33};
          120  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          121  + int y_[] = {87, 17, 20, 7, 57, 19, 23, 68, 27, 39};
          122  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          123  + int h_[] = {6, 2, 8, 8, 31, 25, 23, 19, 45, 4};
          124  +   vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_));
          125  + int RetVal = 6;
          126  + return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
          127  +int Test_(Case_<6>) {
          128  + int x_[] = {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,31,32,33,34,35,36,37,38,39,40};
          129  +   vector <int> x(x_, x_+sizeof(x_)/sizeof(*x_));
          130  + int y_[] = {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,31,32,33,34,35,36,37,38,39,40};
          131  +   vector <int> y(y_, y_+sizeof(y_)/sizeof(*y_));
          132  + int h_[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
          133  +   vector <int> h(h_, h_+sizeof(h_)/sizeof(*h_));
          134  + int RetVal = 6;
          135  + return verify_case(RetVal, SaveTheTrees().minimumCut(x, y, h)); }
          136  +
          137  +template<int N> void Run_() { cerr << "Test Case #" << N << "..." << flush; Test_(Case_<N>()); Run_<sizeof(Test_(Case_<N+1>()))==1 ? -1 : N+1>(); }
          138  +template<>      void Run_<-1>() {}
          139  +int main() { Run_<0>(); }
          140  +// END CUT HERE
          141  +

Added _lib/dataStructure/fenwickTree.cpp version [5a7c5bc1ec0fdf30]

            1  +//-------------------------------------------------------------
            2  +// Fenwick Tree
            3  +//   O(log N) per each operation
            4  +//
            5  +// Verified by
            6  +//   - SRM424 Div1 LV3
            7  +//-------------------------------------------------------------
            8  +
            9  +template<typename T = LL>
           10  +struct FenwickTree
           11  +{
           12  + vector<T> x;
           13  + FenwickTree(size_t n, const T& v = T()) : x(n, v) {}
           14  +
           15  + void incr( int k, const T& a ) { // z[k] += a;
           16  +  for(; k < x.size(); k|=k+1)
           17  +   x[k] += a;
           18  + }
           19  +
           20  + T sum(int i, int j) { // z[i]+...+z[j] : inclusive
           21  +  if(i)
           22  +   return sum(0, j) - sum(0, i-1);
           23  +  else {
           24  +   T v = T();
           25  +   for(; j>=0; j=(j&(j+1))-1)
           26  +    v += x[j];
           27  +   return v;
           28  +  }
           29  + }
           30  +};

Added _lib/dataStructure/rmq.cpp version [a0dd84df47a73891]

            1  +//-------------------------------------------------------------
            2  +// Range Minimum Query
            3  +//   O(N log N) construction
            4  +//   O(1) per each query
            5  +//   returns the LEFTMOST/ALL minimum index (I hope)
            6  +//
            7  +// Verified by
            8  +//   - SRM337 Div1 LV2
            9  +//   - SRM431 Div1 LV3
           10  +//-------------------------------------------------------------
           11  +
           12  +template<typename T>
           13  +struct RMQ
           14  +{
           15  + vector< vector<int> > rm;
           16  + vector<T> d;
           17  +
           18  + RMQ( const vector<T>& d ) : d(d) {
           19  +  int n = d.size();
           20  +
           21  +  // rm[k][x] = i s.t. d[i] is the minimum in [x, x+2^k)
           22  +  rm.push_back( vector<int>(n) );
           23  +  for(int x=0; x<n; ++x)
           24  +   rm[0][x] = x;
           25  +  for(int k=1; (1<<k)<=n; ++k) {
           26  +   rm.push_back( rm[k-1] );
           27  +   for(int x=0; x+(1<<k-1)<n; ++x)
           28  +    if( d[rm[k][x]] > d[rm[k-1][x + (1<<k-1)]] )
           29  +     rm[k][x] = rm[k-1][x + (1<<k-1)];
           30  +  }
           31  + }
           32  +
           33  + int operator()(int L, int R) const { // inclusive
           34  +  int k=0;
           35  +  for(; L+(1<<k) < R-(1<<k)+1; ++k) {}
           36  +  LL i = rm[k][L];
           37  +  LL j = rm[k][R-(1<<k)+1];
           38  +  return (d[i]<=d[j] ? i : j);
           39  + }
           40  +
           41  + vector<int> all(int L, int R) const {
           42  +  vector<int> ans;
           43  +  int minValue = d[(*this)(L, R)];
           44  +  while( L <= R ) {
           45  +   int C = (*this)(L, R);
           46  +   if( minValue < d[C] )
           47  +    break;
           48  +   ans.push_back(C);
           49  +   L = C+1;
           50  +  }
           51  +  return ans;
           52  + }
           53  +};

Added _lib/doc/hitori-sharp.pdf version [7c589d0ad4748936]

cannot compute difference between binary files

Added _lib/doc/lb_ub.txt version [6993ff5a52ea6cbc]

            1  +lb = lower_bound(k)
            2  +  ... k-1] lb [k ...
            3  +
            4  +
            5  +ub = upper_bound(k)
            6  +  .., k] ub [k+1 ...
            7  +
            8  +
            9  +���任��開閉区間をイテレータ� [) 区間�直���
           10  +
           11  +  [A, B]
           12  +    = [ lower_bound(A), upper_bound(B) )
           13  +
           14  +  [A, B)
           15  +    = [ lower_bound(A), lower_bound(B) )
           16  +
           17  +  (A, B]
           18  +    = [ upper_bound(A), upper_bound(B) )
           19  +
           20  +  (A, B)
           21  +    = [ upper_bound(A), lower_bound(B) )

Added _lib/doc/nim.txt version [d63874d4c871cfe6]

            1  +// SRM338 Div1 LV3
            2  +
            3  +定��ステートメント
            4  +
            5  +    対象��るゲーム
            6  +      - 二人ゲーム
            7  +      - 二人�も動��る手�集����
            8  +      - 動�������方�負�
            9  +      - 無�ループ���
           10  +
           11  +    nim
           12  +      - サイズ s1, s2, .., sk �山��る
           13  +      - �れ�一�山を�ん� 1 ～ 山サイズ �任�個�り除�る
           14  +      - 最後�山を���方���（山������打�手�無����方�負�）
           15  +
           16  +    *n をサイズ n �山�1個��� nim ��る
           17  +      - *0 �負�
           18  +      - *n ��� n>=1
           19  +
           20  +    ゲーム
           21  +      - 状態 G �ら打�る手��移�る先を G1, ..., Gk ��る
           22  +        G = {G1, ..., Gk} �書�
           23  +
           24  +    等価
           25  +      - 二��ゲームG, F�等価���を G ≡ F �書�
           26  +        等価�������負�一致よりも��強�。二��ゲーム�和を�る�必敗��る��
           27  +        *n � *n ��サイズ�山2��nim�必敗���等価。�サイズ���れ�必����等価���
           28  +
           29  +    定�
           30  +      - G1≡*n1, ..., Gk≡*nk �ら��G={G1, ..., Gk} ≡ *mex(n1,...,nk)
           31  +        where mex(S) = min(nat \setminus S)
           32  +        帰�的��全��ゲーム��んら�� *n �等価
           33  +
           34  +
           35  +���
           36  +  @G を G �nim値��る。��りG≡*@G
           37  +  G = X + Y �ら� @G = @X xor @Y
           38  +  山�複数�nim��敗�全部xor���1�山�nim�等������原�。

Added _lib/gcj/!gcj-smpl.aml version [9caa644d5228a4f9]

            1  +(****************************************************************************
            2  + * Written in
            3  + *    Alice 1.4
            4  + *    http://www.ps.uni-saarland.de/alice/
            5  + ****************************************************************************)
            6  +
            7  +fun solve (n : int, k : int) : bool =
            8  + let
            9  +  open Word
           10  +  infix 5 << andb
           11  +  val mask = (0wx1 << fromInt n) - 0wx1
           12  + in
           13  +  (fromInt k) andb mask = mask
           14  + end
           15  +
           16  +fun main () =
           17  + let
           18  +  fun readLine () =
           19  +   case TextIO.inputLine TextIO.stdIn of
           20  +   | NONE    => []
           21  +   | SOME(s) => map Int.fromString (String.tokens (fn x => x = #" ") s)
           22  +
           23  +  fun parseOne c =
           24  +   case readLine() of
           25  +   | [SOME n, SOME k] => (c, (n, k))
           26  +   | _                => assert false
           27  +
           28  +  fun spawn solveOne (c, inp) =
           29  +   (c, solve inp)
           30  +
           31  +  fun printOne (c, ans) =
           32  +   print ("Case #" ^ Int.toString (c+1) ^ ": " ^ (if ans then "ON" else "OFF") ^ "\n")
           33  + in
           34  +  case readLine () of
           35  +  | [SOME t] => List.app printOne (List.map solveOne (List.tabulate (t, parseOne)))
           36  +  | _        => assert false
           37  + end
           38  +
           39  +do main ()
           40  +do OS.Process.exit 0

Added _lib/gcj/!gcj-smpl.as version [a762a8ed088b0770]

            1  +/////////////////////////////////////////////////////////////////////////////
            2  +// Written in
            3  +//    ActionScript (using mtasc 1.14)
            4  +//    http://www.mtasc.org/
            5  +/////////////////////////////////////////////////////////////////////////////
            6  +
            7  +class A
            8  +{
            9  + static function main(mc)
           10  + {
           11  +  var input_string = "<paste the input data here>";
           12  +  var input = input_string.split("\n");
           13  +  var T = Number(input[0]);
           14  +
           15  +  var output_string = ""
           16  +  for(var C=1; C<=T; ++C)
           17  +  {
           18  +   var theCase = input[C].split(" ");
           19  +   var N = Number(theCase[0]);
           20  +   var K = Number(theCase[1]);
           21  +   output_string += "Case #" + C + ": " + (solve(N,K)?"ON":"OFF") + "\n"
           22  +  }
           23  +
           24  +  _root.createTextField("tf",0,0,0,800,600);
           25  +  _root.tf.text = output_string;
           26  + }
           27  +
           28  + static function solve(N, K)
           29  + {
           30  +  var mask = (1<<N) - 1;
           31  +  return (K & mask) == mask;
           32  + }
           33  +}

Added _lib/gcj/!gcj-smpl.bl version [e21b6366bf8728d9]

            1  +#############################################################################
            2  +# Written in
            3  +#    Blue 1.7.5
            4  +#    http://www.lechak.info/blue/
            5  +#############################################################################
            6  +
            7  +global FROM_STRING = func {
            8  + arg s;
            9  +
           10  + a = [];
           11  + i = 0;
           12  + loop {
           13  +  a = a.append( s.substr(i,i+1).num() );
           14  +  (i=i+1) >= s.length() ? return;
           15  + };
           16  + return a;
           17  +};
           18  +
           19  +global TO_STRING = func {
           20  + arg x;
           21  + lexical s = "";
           22  + x.map( func{ s = s + this; } );
           23  + return s;
           24  +};
           25  +
           26  +global LESS = func {
           27  + arg x;
           28  + arg y;
           29  +
           30  + xl = x.length();
           31  + yl = y.length();
           32  + (xl < yl) ? return 1;
           33  + (xl > yl) ? return 0;
           34  + i = 0;
           35  + return loop {
           36  +  (i == xl)     ? return 0;
           37  +  (x[i] < y[i]) ? return 1;
           38  +  (x[i] > y[i]) ? return 0;
           39  +  i = i+1;
           40  + };
           41  +};
           42  +
           43  +global SUB = func {
           44  + arg x;
           45  + arg y;
           46  +
           47  + x.length() > y.length() ? (y = [].resize(x.length()-y.length(),0).merge(y));
           48  + z = [].resize(x.length(), 0);
           49  + i = x.length()-1;
           50  + carry = 0;
           51  + loop {
           52  +  z[i]  = x[i] - y[i] - carry;
           53  +  carry = z[i] < 0 ? (z[i]=z[i]+10; 1) : 0;
           54  +  (i=i-1) < 0 ? return;
           55  + };
           56  + head = 0;
           57  + loop {
           58  +  head == z.length()-1 ? return;
           59  +  z[head] != 0 ? return;
           60  +  head = head + 1;
           61  + };
           62  + return z.slice(head, z.length());
           63  +};
           64  +
           65  +global DBL = func {
           66  + arg x;
           67  +
           68  + z = [].resize(x.length(), 0);
           69  + i = x.length()-1;
           70  + carry = 0;
           71  + loop {
           72  +  z[i]  = x[i] + x[i] + carry;
           73  +  carry = z[i] > 9 ? (z[i]=z[i]-10; 1) : 0;
           74  +  ((i=i-1) < 0) ? return;
           75  + };
           76  + return (carry==1 ? [1].merge(z) : z);
           77  +};
           78  +
           79  +global DIF = func {
           80  + arg x;
           81  + arg y;
           82  + return LESS(x, y) ? SUB(y, x) : SUB(x, y);
           83  +};
           84  +
           85  +global MOD = func {
           86  + arg x;
           87  + arg y;
           88  +
           89  + LESS(x,y) ? return x;
           90  + z = MOD(x, DBL(y));
           91  + LESS(z,y) ? return z;
           92  + return SUB(z,y);
           93  +};
           94  +
           95  +global ISZERO = func {
           96  + arg x;
           97  + return x[0] == 0;
           98  +};
           99  +
          100  +global GCD = func {
          101  + arg x;
          102  + arg y;
          103  + return ISZERO(x) ? y : GCD(MOD(y,x),x);
          104  +};
          105  +
          106  +#############################################################################
          107  +
          108  +solve = func {
          109  + arg N;
          110  + arg t;
          111  + t = t.map( func{return FROM_STRING(this);} );
          112  +
          113  + lexical t0 = t[0];
          114  + lexical g  = DIF(t0, t[1]);
          115  + t.slice(2, t.length()).map(func{
          116  +  g = GCD(g, DIF(t0, this));
          117  + });
          118  + r = MOD(t[0], g);
          119  + return TO_STRING( ISZERO(r) ? r : DIF(g,r) );
          120  +};
          121  +
          122  +input = sys.library("streams").stdio().read(1000000000).split("\n").map(func{return this.split(" ");});
          123  +C = input[0][0].num();
          124  +
          125  +CaseID = (args.length() >= 2 ? args[1].num() : 1);
          126  +loop {
          127  + "Case #".print();
          128  + CaseID.print();
          129  + ": ".print();
          130  + solve( input[CaseID][0].num(), input[CaseID].slice(1,input[CaseID].length()) ).print();
          131  + "\n".print();
          132  + ((CaseID = CaseID+1) > C) ? return;
          133  +};

Added _lib/gcj/!gcj-smpl.cl version [5615f7e126fc9cd7]

            1  +/////////////////////////////////////////////////////////////////////////////
            2  +// Writte in
            3  +//    Claire v3.3.37
            4  +//    http://www.claire-language.com/
            5  +/////////////////////////////////////////////////////////////////////////////
            6  +
            7  +D :: 1000000000
            8  +
            9  +long <: ephemeral_object(hi:integer, lo:integer)
           10  +
           11  +[long!(x: integer) : long ->
           12  + long(hi = x / D, lo = x mod D)
           13  +]
           14  +
           15  +[+(x:long, y:long) : long ->
           16  + let lolo := x.lo - D + y.lo in
           17  + (
           18  +  if ( lolo < 0 )
           19  +   long(hi = x.hi + y.hi,     lo = lolo + D)
           20  +  else
           21  +   long(hi = x.hi + y.hi + 1, lo = lolo)
           22  + )
           23  +]
           24  +
           25  +[-(x:long, y:long) : long ->
           26  + let lolo := x.lo - y.lo in
           27  + (
           28  +  if ( lolo < 0 )
           29  +   long(hi = x.hi - y.hi - 1, lo = lolo + D)
           30  +  else
           31  +   long(hi = x.hi - y.hi,     lo = lolo)
           32  + )
           33  +]
           34  +
           35  +[*(x:long, y:integer) : long ->
           36  + let r := long!(0) in
           37  + let c := x in
           38  +  (while (y > 0) (
           39  +   (if (y mod 2 = 1) r :+ c),
           40  +   c := c + c,
           41  +   y :/ 2
           42  +  ),
           43  +  r)
           44  +]
           45  +
           46  +[+(x:long, y:integer) : long ->
           47  + x + long!(y)
           48  +]
           49  +
           50  +[<(x:long, y:long) : boolean ->
           51  + if (x.hi < y.hi)
           52  +  true
           53  + else if (x.hi > y.hi)
           54  +  false
           55  + else
           56  +  x.lo < y.lo
           57  +]
           58  +[>=(x:long, y:long) : boolean -> not(x < y)]
           59  +[<=(x:long, y:long) : boolean -> not(y < x)]
           60  +[>(x:long, y:long) : boolean -> (y < x)]
           61  +
           62  +[>=(x:long, y:integer) : boolean -> not(x < long!(y))]
           63  +[<=(x:long, y:integer) : boolean -> not(long!(y) < x)]
           64  +[<(x:long, y:integer) : boolean -> (x < long!(y))]
           65  +[>(x:long, y:integer) : boolean -> (long!(y) < x)]
           66  +
           67  +[>=(x:integer, y:long) : boolean -> not(long!(x) < y)]
           68  +[<=(x:integer, y:long) : boolean -> not(y < long!(x))]
           69  +[<(x:integer, y:long) : boolean -> (long!(x) < y)]
           70  +[>(x:integer, y:long) : boolean -> (y < long!(x))]
           71  +
           72  +
           73  +[string!(x: long) : string ->
           74  + if (x.hi > 0)
           75  +  let los := string!(x.lo) in
           76  +   string!(x.hi) /+ make_string(9 - length(los), '0') /+ los
           77  + else
           78  +  string!(x.lo)
           79  +]
           80  +
           81  +/////////////////////////////////////////////////////////////////////////////
           82  +
           83  +[readLine() : list<integer> ->
           84  + list<integer>{integer!(s) | s in explode(freadline(stdin), " ")}
           85  +]
           86  +
           87  +[solve(R:integer, k:integer, N:integer, g:list<integer>) ->
           88  + let dest := make_list(N, 0) in
           89  + let earn := make_list(N, long!(0)) in
           90  + (
           91  +  for s in (0 .. N - 1) (
           92  +   let ride := long!(0) in
           93  +   let i    := 0        in
           94  +   (
           95  +    while (i < N)
           96  +    (
           97  +     let ride2 := ride + g[((s + i) mod N) + 1] in
           98  +     (if (ride2 > k)
           99  +      break()
          100  +     else
          101  +      (ride := ride2, i :+ 1))
          102  +    ),
          103  +    earn[s + 1] := ride,
          104  +    dest[s + 1] := ((s + i) mod N) + 1
          105  +   )
          106  +  ),
          107  +  let firstVisitTime := make_list(N,       -1) in
          108  +  let firstVisitEarn := make_list(N, long!(0)) in
          109  +  let q         := 1        in
          110  +  let totalEarn := long!(0) in
          111  +  let i         := 0        in
          112  +  (
          113  +   (while (i < R) (
          114  +    if (firstVisitTime[q] = -1)
          115  +    (
          116  +     firstVisitTime[q] := i,
          117  +     firstVisitEarn[q] := totalEarn,
          118  +     totalEarn         :+ earn[q],
          119  +     q                 := dest[q],
          120  +     i                 :+ 1
          121  +    )
          122  +    else
          123  +    (
          124  +     let loopSize := i - firstVisitTime[q] in
          125  +     let loopEarn := totalEarn - firstVisitEarn[q] in
          126  +     let rest     := R - i in
          127  +     (
          128  +      totalEarn :+ loopEarn * (rest / loopSize),
          129  +      // clear
          130  +      firstVisitTime := make_list(N, -1),
          131  +      i              := R - (rest mod loopSize)
          132  +     )
          133  +    )
          134  +   )),
          135  +   princ(string!(totalEarn))
          136  +  )
          137  + )
          138  +]
          139  +
          140  +[main() ->
          141  + let T := readLine()[1] in
          142  +  for C in (1 .. T)
          143  +  (
          144  +   printf("Case #~A: ", C),
          145  +   let RkN := readLine() in solve(RkN[1], RkN[2], RkN[3], readLine()),
          146  +   princ("\n")
          147  +  )
          148  +]
          149  +
          150  +(main())

Added _lib/gcj/!gcj-smpl.cs version [2cc6fccce968278d]

            1  +using System;
            2  +using System.Linq;
            3  +
            4  +class C
            5  +{
            6  + static void Main()
            7  + {
            8  +  long[] Ts = readLongArray();
            9  +  long   T  = Ts[0];
           10  +
           11  +  for(long C=1; C<=T; ++C)
           12  +  {
           13  +   long[] RkN = readLongArray();
           14  +   long   R = RkN[0];
           15  +   long   k = RkN[1];
           16  +   long   N = RkN[2];
           17  +   long[] g = readLongArray();
           18  +
           19  +   Console.WriteLine("Case #{0}: {1}", C, solveSmall(R,k,N,g));
           20  +  }
           21  + }
           22  +
           23  + static long[] readLongArray()
           24  + {
           25  +  return (from s in Console.ReadLine().Split(' ') select long.Parse(s)).ToArray();
           26  + }
           27  +
           28  + static long solveSmall(long R, long k, long N, long[] g)
           29  + {
           30  +  long totalEarn = 0;
           31  +
           32  +  for(int i=0; i<R; ++i)
           33  +  {
           34  +   long ride = 0;
           35  +   for(int q=0; q<g.Length; ++q)
           36  +    if( ride + g[q] > k )
           37  +    {
           38  +     g = rotate(g, q);
           39  +     break;
           40  +    }
           41  +    else
           42  +    {
           43  +     ride += g[q];
           44  +    }
           45  +   totalEarn += ride;
           46  +  }
           47  +
           48  +  return totalEarn;
           49  + }
           50  +
           51  + static long[] rotate(long[] g, int s)
           52  + {
           53  +  long[] g2 = new long[g.Length];
           54  +  for(int i=s; i<g.Length; ++i)
           55  +   g2[i-s] = g[i];
           56  +  for(int i=0; i<s; ++i)
           57  +   g2[i+g.Length-s] = g[i];
           58  +  return g2;
           59  + }
           60  +}

Added _lib/gcj/!gcj-smpl.vbs version [4dbab301b915fb0d]

            1  +'
            2  +' Written in VBScript
            3  +'
            4  +
            5  +Function ReadLine()
            6  + Dim s
            7  + s = Split(WScript.StdIn.ReadLine, " ")
            8  + For i = LBound(s) To UBound(s)
            9  +  s(i) = CLng(s(i))
           10  + Next
           11  + ReadLine = s
           12  +End Function
           13  +
           14  +Function Gcd(a, b)
           15  + If a = 0 Then
           16  +  Gcd = b
           17  + Else
           18  +  Gcd = Gcd(b mod a, a)
           19  + End If
           20  +End Function
           21  +
           22  +Function Solve(T)
           23  + Dim g, r
           24  + g = Abs(T(1) - T(2))
           25  + For i = 2 To UBound(T)
           26  +  g = Gcd(g, Abs(T(1) - T(i)))
           27  + Next
           28  + r = T(1) mod g
           29  + If r = 0 Then
           30  +  Solve = 0
           31  + Else
           32  +  Solve = g - r
           33  + End If
           34  +End Function
           35  +
           36  +C = ReadLine()(0)
           37  +For CaseID = 1 To C
           38  + WScript.StdOut.WriteLine "Case #" & CaseID & ": " & Solve(ReadLine)
           39  +Next

Added _lib/gcj/!gcj-tmpl.cpp version [8b7e23cf8b869fd6]

            1  +//-----------------------------------------------------------------------------
            2  +// >>Code Template<< (for Visual C++)
            3  +
            4  +#include <iostream>
            5  +#include <sstream>
            6  +#include <iomanip>
            7  +#include <string>
            8  +#include <vector>
            9  +#include <set>
           10  +#include <map>
           11  +#include <algorithm>
           12  +#include <numeric>
           13  +#include <iterator>
           14  +#include <complex>
           15  +#include <functional>
           16  +#include <queue>
           17  +#include <stack>
           18  +#include <cmath>
           19  +#include <cassert>
           20  +#include <cstring>
           21  +#define  cout os
           22  +using namespace std;
           23  +typedef long long LL;
           24  +typedef complex<double> CMP;
           25  +void END_OF_INPUT_FOR_THIS_TEST_CASE(); // stub for multi-threading
           26  +
           27  +//-----------------------------------------------------------------------------
           28  +// >>Main<<
           29  +
           30  +void case_main( ostream& os )
           31  +{
           32  + END_OF_INPUT_FOR_THIS_TEST_CASE();
           33  +}
           34  +
           35  +//-----------------------------------------------------------------------------
           36  +// >>Code Template<< (Multi-Thread Solver)
           37  +
           38  +#if 1
           39  +#undef cout
           40  +#include <windows.h>
           41  +#include <process.h>
           42  +
           43  +static const int THREAD_NUM = 2;
           44  +volatile int     g_id;
           45  +int              g_nCase;
           46  +CRITICAL_SECTION g_cs;
           47  +vector<string>   g_output;
           48  +
           49  +unsigned __stdcall thread_main( void* t_id ) {
           50  + for(;;) {
           51  +  EnterCriticalSection(&g_cs);
           52  +  const int id = ++g_id;
           53  +  if(id>g_nCase) { LeaveCriticalSection(&g_cs); break; }
           54  +  cerr << setw(4) << id << " @ " << (int)t_id << " start" << endl;
           55  +
           56  +  ostringstream ss;
           57  +  ss << "Case #" << id << ": ";
           58  +  case_main( ss );
           59  +
           60  +  EnterCriticalSection(&g_cs);
           61  +  if(g_output.size()<id) g_output.resize(id);
           62  +  g_output[id-1] = ss.str();
           63  +  cerr << setw(4) << id << " @ " << (int)t_id << " end" << endl;
           64  +  LeaveCriticalSection(&g_cs);
           65  + }
           66  + return 0;
           67  +}
           68  +
           69  +void END_OF_INPUT_FOR_THIS_TEST_CASE() { LeaveCriticalSection(&g_cs); }
           70  +
           71  +int main() {
           72  + cin >> g_nCase;
           73  + string dummy; getline(cin, dummy);
           74  +
           75  + InitializeCriticalSection(&g_cs);
           76  + vector<HANDLE> thread;
           77  + for(int i=0; i<THREAD_NUM; ++i)
           78  +  thread.push_back( (HANDLE)_beginthreadex(0, 0, &thread_main, (void*)i, 0, 0) );
           79  + WaitForMultipleObjects( thread.size(), &thread[0], TRUE, INFINITE );
           80  + DeleteCriticalSection(&g_cs);
           81  +
           82  + copy( g_output.begin(), g_output.end(), ostream_iterator<string>(cout) );
           83  +}
           84  +
           85  +//-----------------------------------------------------------------------------
           86  +// >>Code Template<< (Single-Thread Solver)
           87  +
           88  +#else
           89  +#undef cout
           90  +void END_OF_INPUT_FOR_THIS_TEST_CASE() {}
           91  +int main() {
           92  + int nCase; cin >> nCase;
           93  + string dummy; getline(cin, dummy);
           94  +
           95  + for(int id=1; id<=nCase; ++id) {
           96  +  cout << "Case #" << id << ": ";
           97  +  case_main( cout );
           98  + }
           99  +}
          100  +#endif

Added _lib/gcj/!gcj-tmpl.java version [e9cb1325b5300e50]

            1  +import java.io.*;
            2  +import java.util.*;
            3  +
            4  +public class <CLASSNAME>
            5  +{
            6  + public static void main(String[] arg)
            7  + {
            8  +  Scanner sc = new Scanner(System.in);
            9  +  int T = sc.nextInt();
           10  +  for(int C=1; C<=T; ++C)
           11  +  {
           12  +   System.out.printf("Case #%d: ", C);
           13  +   (new <CLASSNAME>(sc)).caseMain();
           14  +  }
           15  + }
           16  +
           17  + Scanner sc;
           18  + <CLASSNAME>( Scanner sc ) { this.sc = sc; }
           19  +
           20  + void caseMain()
           21  + {
           22  +  int n = sc.nextInt();
           23  +  long[] x = new long[n];
           24  +  for(int i=0; i<n; ++i) x[i] = sc.nextInt();
           25  +  long[] y = new long[n];
           26  +  for(int i=0; i<n; ++i) y[i] = sc.nextInt();
           27  +
           28  +  System.out.println(solve(x, y, n));
           29  + }
           30  +
           31  + long solve(long[] x, long[] y, int n)
           32  + {
           33  +  Arrays.sort(x);
           34  +  Arrays.sort(y);
           35  +  long s = 0;
           36  +  for(int i=0; i<n; ++i)
           37  +   s += x[i] * y[n-1-i];
           38  +  return s;
           39  + }
           40  +}

Added _lib/gcj/!gcj-tmpl.lua version [a2c96590b21d65bc]

            1  +CN = io.stdin:read("*n")
            2  +for C=1, CN, 1 do
            3  + io.stdout:write( string.format("Case #%d: ", C) )
            4  +
            5  + N = io.stdin:read("*n")
            6  + M = io.stdin:read("*n")
            7  +
            8  + fav = {}
            9  + for i=1, M, 1 do
           10  +  T = io.stdin:read("*n")
           11  +  fav[i] = {}
           12  +  for j=1, T, 1 do
           13  +   X, Y = io.stdin:read("*n", "*n")
           14  +   fav[i][j] = {X, Y}
           15  +  end
           16  + end
           17  +
           18  + io.stdout:write( string.format("%d %d\n", N, M) )
           19  +end

Added _lib/gcj/!gcj-tmpl.py version [da8352105d588b93]

            1  +import sys
            2  +
            3  +CN = int(sys.stdin.next())
            4  +for C in range(1, CN+1):
            5  + print "Case #%d:"%(C),
            6  + N = int(sys.stdin.next())
            7  + M = int(sys.stdin.next())
            8  + for i in range(0, M):
            9  +  a = map(int, sys.stdin.next().split(" "))
           10  +  print a
           11  + print N, M

Added _lib/geo/area.cpp version [959cda21c7e42a70]

            1  +//-------------------------------------------------------------
            2  +// Area of a polygon
            3  +//   O(N)
            4  +//
            5  +// Verified by
            6  +//   - SRM 337 Div1 LV3
            7  +//   - SRM 486 Div1 LV3
            8  +//-------------------------------------------------------------
            9  +
           10  +double outer_prod( pt a, pt b )
           11  +{
           12  + return (a.real()*b.imag() - b.real()*a.imag())/2;
           13  +}
           14  +
           15  +double area( const vector<pt>& q )
           16  +{
           17  + double a = 0.0;
           18  +
           19  + pt o = q[0];
           20  + for(int i=1; i+1<q.size(); ++i)
           21  +  a += outer_prod(q[i]-o, q[i+1]-o);
           22  + return abs(a) / 2;
           23  +}

Added _lib/geo/ccw.cpp version [81dbefbd30f15e79]

            1  +//-------------------------------------------------------------
            2  +// ccw
            3  +//
            4  +// Verified by
            5  +//   - SRM 492 Div1 LV1
            6  +//-------------------------------------------------------------
            7  +
            8  +double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
            9  +double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
           10  +
           11  +int ccw(const CMP& a, CMP b, CMP c) {
           12  + b -= a; c -= a;
           13  + if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
           14  + if( outer_prod(b,c) < 0 ) return -1; // clockwise
           15  + if( inner_prod(b,c) < 0 ) return +2; // c--[a--b] on line
           16  + if( norm(b) < norm(c) )   return -2; // [a--b]--c on line
           17  + return 0; // [a--c--b] on line
           18  +}

Added _lib/geo/circle_3pt.cpp version [40885cae01887a2c]

            1  +
            2  +//-------------------------------------------------------------
            3  +// The circle passing three points
            4  +//
            5  +// Verified by
            6  +//   - AOJ 0010
            7  +//-------------------------------------------------------------
            8  +
            9  +vector<double> solve_linear_eq( int n, vector< vector<double> > M, const vector<double>& V )
           10  +{
           11  + vector<double> A(V);
           12  + for(int i=0; i<n; ++i)
           13  + {
           14  +  // pivot
           15  +  if( M[i][i] == 0 )
           16  +   for(int j=i+1; j<n; ++j)
           17  +    if( M[j][i] != 0 )
           18  +     {swap(M[i], M[j]); swap(A[i], A[j]); break;}
           19  +  if( M[i][i] == 0 )
           20  +   throw "no anser";
           21  +
           22  +  // M[i][i] <-- 1
           23  +  double p = M[i][i];
           24  +  for(int j=i; j<n; ++j)
           25  +   M[i][j] /= p;
           26  +  A[i] /= p;
           27  +
           28  +  // M[*][i] <-- 0
           29  +  for(int j=0; j<n; ++j) if(j!=i)
           30  +  {
           31  +   double r = M[j][i];
           32  +   for(int k=i; k<n; ++k)
           33  +    M[j][k] -= M[i][k] * r;
           34  +   A[j] -= A[i] * r;
           35  +  }
           36  + }
           37  + return A;
           38  +}
           39  +
           40  +void circle_3pt( CMP p1, CMP p2, CMP p3, CMP* c, double* r )
           41  +{
           42  + p2 -= p1;
           43  + p3 -= p1;
           44  + // c == p2/2 + A p2 i == p3/2 + B p3 i
           45  +
           46  + vector< vector<double> > M(2, vector<double>(2));
           47  + vector<double> V(2);
           48  + M[0][0] = -p2.imag(); M[0][1] = +p3.imag(); V[0] = (p3.real()-p2.real())/2.0;
           49  + M[1][0] = +p2.real(); M[1][1] = -p3.real(); V[1] = (p3.imag()-p2.imag())/2.0;
           50  + V = solve_linear_eq(2, M, V);
           51  +
           52  + double A=V[0], B=V[1];
           53  + *c = p1 + p2/2.0 + A * p2 * CMP(0,1);
           54  + *r = abs(*c - p1);
           55  +}

Added _lib/geo/convexHull.cpp version [75743e110118c49c]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Convex Hull -- Andrew's Monotone Chain
            4  +//   O(N log N)
            5  +//
            6  +// Verified by
            7  +//   - SRM 336 Div1 LV3
            8  +//   - TCO09 Round2 LV2
            9  +//   - SRM 486 Div1 LV3
           10  +//-------------------------------------------------------------
           11  +
           12  +double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
           13  +double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
           14  +
           15  +int ccw(const CMP& a, CMP b, CMP c) {
           16  + b -= a; c -= a;
           17  + if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
           18  + if( outer_prod(b,c) < 0 ) return -1; // clockwise
           19  + if( inner_prod(b,c) < 0 ) return +2; // c--a--b on line
           20  + if( norm(b) < norm(c) )   return -2; // a--b--c on line
           21  + return 0;
           22  +}
           23  +
           24  +bool byX( const CMP& a, const CMP& b ) {
           25  + if( a.real() != b.real() )
           26  +  return a.real() < b.real();
           27  + return a.imag() < b.imag();
           28  +}
           29  +
           30  +vector<CMP> convex_hull( vector<CMP> p )
           31  +{
           32  + #define IS_RIGHT <0   // skip on-line verts
           33  + //#define IS_RIGHT ==-1 // take all
           34  +
           35  + sort(p.begin(), p.end(), &byX);
           36  +
           37  + vector<CMP> ans;
           38  + for(int i=0; i<p.size(); ans.push_back(p[i++])) // left-to-right
           39  +  while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
           40  +   ans.pop_back();
           41  + if( ans.size() == p.size() )
           42  +  return ans;
           43  + for(int i=p.size()-2; i>=0; ans.push_back(p[i--])) // right-to-left
           44  +  while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
           45  +   ans.pop_back();
           46  + ans.pop_back();
           47  + return ans;
           48  +}

Added _lib/geo/convexHull_old.cpp version [9ffbc36d1d4aa6a7]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Convex Hull -- Gift Wrapping
            4  +//   O(N log N)
            5  +//
            6  +// ToDo : Rewrite by CCW...
            7  +//
            8  +// Verified by
            9  +//   - SRM 336 Div1 LV3
           10  +//-------------------------------------------------------------
           11  +
           12  +bool byY( CMP a, CMP b )
           13  +{
           14  + if( a.imag() == b.imag() )
           15  +  return a.real() < b.real();
           16  + return a.imag() < b.imag();
           17  +}
           18  +
           19  +bool byArg( CMP a, CMP b )
           20  +{
           21  + return arg(a) < arg(b);
           22  +}
           23  +
           24  +bool isRight( CMP a, CMP b, CMP c )
           25  +{
           26  + return arg((c-b) / (b-a)) < 0;
           27  +}
           28  +
           29  +vector<CMP> convex_hull( vector<CMP> p )
           30  +{
           31  + vector<CMP>::iterator it = min_element( p.begin(), p.end(), byY );
           32  + CMP o = *it;
           33  + p.erase(it);
           34  + for(int i=0; i<p.size(); ++i)
           35  +  p[i] -= o;
           36  + sort( p.begin(), p.end(), byArg );
           37  +
           38  + vector<CMP> q;
           39  + q.push_back( CMP(0,0) );
           40  + q.push_back( p[0] );
           41  + for(int i=1; i<p.size(); ++i) {
           42  +  while( isRight(q[q.size()-2], q[q.size()-1], p[i]) )
           43  +   q.pop_back();
           44  +  q.push_back( p[i] );
           45  + }
           46  + for(int i=0; i<q.size(); ++i)
           47  +  q[i] += o;
           48  + return q;
           49  +}

Added _lib/geo/pt_in_poly.cpp version [05f672d15009c4b5]

            1  +
            2  +//-------------------------------------------------------------
            3  +// The circle passing three points
            4  +//
            5  +// Verified by
            6  +//   - AOJ 0012 (only triangles)
            7  +//-------------------------------------------------------------
            8  +
            9  +double outer_prod( CMP a, CMP b )
           10  +{
           11  + return (a.real()*b.imag() - b.real()*a.imag())/2;
           12  +}
           13  +
           14  +bool point_in_polygon( vector<CMP>& ps, CMP p )
           15  +{
           16  + bool in = false;
           17  + for(int i=0; i<ps.size(); ++i) {
           18  +  CMP a = ps[i] - p;
           19  +  CMP b = ps[(i+1)%ps.size()] - p;
           20  +  if(a.imag() > b.imag()) swap(a,b);
           21  +  if(a.imag()<=0 && 0<b.imag()) {
           22  +   if( outer_prod(a,b) < 0 )
           23  +    in = !in;
           24  +  }
           25  +  //if( outer_prod(a,b)==0 && inner_prod(a,b)<=0 ) return ON;
           26  + }
           27  + return in;
           28  +}

Added _lib/graph/__goldberg.cpp version [3f97582085a591c3]

            1  +//----------------------------------------------------------------------------
            2  +// Goldberg(-Tarjan?) –@ (�Å‘å—¬)
            3  +//
            4  +// —e—Ê•t‚«ƒOƒ‰ƒt G �ã‚Å‚Ì Src ‚©‚ç Dest ‚Ö‚Ì�Å‘å—¬—Ê‚ð‹�‚ß‚é
            5  +//   - ƒOƒ‰ƒt‚Í—×�Ú�s—ñ‚Å“n‚·‚±‚Æ�BG ‚Í”j‰ó‚³‚ê‚Ü‚·�B
            6  +//   - —¬—Ê‚¾‚¯‚Å‚È‚­FlowŽ©‘Ì‚ª—~‚µ‚¢‚Æ‚«‚Í G ‚Ì—e—Ê‚ªŒ¸‚Á‚Ä‚é•”•ª‚ðŒ©‚é
            7  +//
            8  +// ŒvŽZ—Ê‚Í
            9  +//   - O(V^3)
           10  +//       # �Ø–¾‚Í‚Ü‚¾—�‰ð‚µ‚Ä‚¢‚È‚¢
           11  +//
           12  +// ƒAƒ‹ƒSƒŠƒYƒ€‚ÌŠT—ª
           13  +//   Šî–{Œ`‚͈ȉº‚Ì’Ê‚è
           14  +//      1. ‚Æ‚è‚ ‚¦‚¸Src‚©‚ç�o‚Ä‚é•Ó‘S•”‚É—e—ÊŒÀŠE‚Ü‚Å—¬‚·
           15  +//      2. —¬“ü > —¬�o ‚ȃm�[ƒh‚ðŒ©‚Â‚¯‚ăoƒ‰ƒ“ƒX‚ðŽæ‚é
           16  +//          - ‚»‚±‚©‚çDest‚Ü‚Å“ž’B‚·‚éƒpƒX‚ª‚ ‚é‚È‚ç�A‚æ‚è
           17  +//            Dest‚É‹ß‚¢•ûŒü‚Ö�i‚Þ•Ó‚Ö‚Ì—¬�o—Ê‚ð‘�‚â‚·
           18  +//          - ‚È‚¢‚È‚ç�A‚æ‚èSrc‚Ö‹ß‚¢•ûŒü‚©‚ç—ˆ‚é•Ó‚©‚ç‚Ì
           19  +//            —¬“ü—Ê‚ðŒ¸‚ç‚·
           20  +//      3. 2.‚ðƒAƒ“ƒoƒ‰ƒ“ƒX‚È’¸“_‚ª‚È‚­‚È‚é‚Ü‚ÅŒJ‚è•Ô‚·
           21  +//   �u—¬“ü > —¬�o ‚ȃm�[ƒh‚ðŒ©‚Â‚¯‚Ä�v‚Ì�ˆ—�‚Í�A—¬�o“üƒoƒ‰ƒ“ƒX‚ð•Ï‚¦‚½Žž‚É
           22  +//   Queue‚É“Ë‚Á�ž‚ñ‚Å‚¨‚­‚±‚Æ‚ÅFIFO‚Å‚â‚é�B
           23  +//   �uDest‚É‹ß‚¢•ûŒü�v�uSrc‚É‹ß‚¢•ûŒü�v‚ð�í‚ÉŒµ–§‚É•]‰¿‚·‚é•K—v‚Í‚È‚­‚Ä�A
           24  +//   ‚ ‚é’ö“x‚̋ߎ—‚Å‚à�\•ª�B‰º‚̃R�[ƒh‚Å‚Í‚»‚̋ߎ—’l‚ð d[] ‚ÅŽ�‚Á‚Ä‚¢‚é�B
           25  +//   d[] ‚Ì•]‰¿‚ð“K“x‚É‚¿‚á‚ñ‚Æ‚â‚Á‚½‚è‚·‚éheuristics‚Å‘¬‚­‚È‚é‚炵‚¢�B
           26  +//   ‚Æ‚¢‚¤‚©‚â‚ç‚È‚¢‚ÆŽÀ�Û�ã‚ÍŽg‚¢•¨‚É‚È‚ç‚È‚¢‚炵‚¢�B‚ ‚Æ‚Å‚¿‚á‚ñ‚Æ‚â‚é�B
           27  +//----------------------------------------------------------------------------
           28  +
           29  +#include <vector>
           30  +#include <queue>
           31  +#include <limits>
           32  +using namespace std;
           33  +
           34  +typedef int                        Vert;
           35  +typedef int                        Capacity;
           36  +typedef vector< vector<Capacity> > Graph;
           37  +
           38  +Capacity goldberg_tarjan( Graph& G, Vert Src, Vert Dest )
           39  +{
           40  + vector<Capacity> e( G.size() ); // excess   : —¬“ü—Ê - —¬�o—Ê
           41  + vector<int>      d( G.size() ); // distance : Dest‚Ö‚Ì‹——£||Src‚Ö‚Ì‹——£-N‚̉ºŒÀ
           42  + d[Src] = G.size();
           43  +
           44  + queue<Vert> Q; // e[v]>0 ‚ȃm�[ƒh‚ð“ü‚ê‚Ä‚¨‚­ƒLƒ…�[
           45  +
           46  + // ‚Æ‚è‚ ‚¦‚¸Src‚©‚ç‘S—Í‚Å—¬‚·
           47  + for(int v=0; v!=G.size(); ++v)
           48  +  if( G[Src][v] )
           49  +  {
           50  +   G[v][Src] += G[Src][v];
           51  +   e[v]      += G[Src][v];
           52  +   G[Src][v]  = 0;
           53  +   Q.push(v);
           54  +  }
           55  +
           56  + // e[v]>0 ‚ȃm�[ƒh‚ª‚È‚­‚È‚é‚Ü‚ÅŒJ‚è•Ô‚·
           57  + while( !Q.empty() )
           58  + {
           59  +  Vert v = Q.front();
           60  +
           61  +  for(int u=0; u!=G.size() && e[v]; ++u)
           62  +   if( G[v][u] && d[v]>d[u] ) // “K�Ø‚È•ûŒü‚É—¬‚· "PUSH"
           63  +   {
           64  +    Capacity f = min(e[v], G[v][u]);
           65  +    G[v][u] -= f;
           66  +    G[u][v] += f;
           67  +    e[v] -= f;
           68  +    e[u] += f;
           69  +    if( e[u]==f && u!=Src && u!=Dest ) Q.push(u);
           70  +   }
           71  +
           72  +  if( e[v] == 0 ) // ƒoƒ‰ƒ“ƒXŽæ‚ꂽ‚̂ŃLƒ…�[‚©‚ç�œ‚­
           73  +   Q.pop();
           74  +  else // ƒoƒ‰ƒ“ƒXŽæ‚ê‚Ä‚È‚¢‚Ì‚Í‚¨‚©‚µ‚¢‚Ì‚Åd[v]‚ð’²�®‚µ‚Ä‚â‚è’¼‚µ "RELABEL"
           75  +  {
           76  +   Capacity m = numeric_limits<Capacity>::max();
           77  +   for(int u=0; u!=G.size(); ++u)
           78  +    if( G[v][u] )
           79  +     m = min(m, d[u]+1);
           80  +   d[v] = m;
           81  +  }
           82  + }
           83  +
           84  + // Dest ‚Ö‚Ì—¬“ü—Ê‚ð•Ô‚·
           85  + return e[Dest];
           86  +}
           87  +
           88  +//----------------------------------------------------------------------------
           89  +// PKU 1459
           90  +//----------------------------------------------------------------------------
           91  +
           92  +#include <iostream>
           93  +#include <locale>
           94  +
           95  +int main()
           96  +{
           97  + cin.imbue( std::locale("C") );
           98  + for(int n,np,nc,m; cin>>n>>np>>nc>>m;)
           99  + {
          100  +  // 0: src, 1: dst, 2: ...
          101  +  Graph g(n+2, vector<Capacity>(n+2));
          102  +
          103  +  while(m--)
          104  +  {
          105  +   int u, v, z; char _;
          106  +   cin >> _ >> u >> _ >> v >> _ >> z;
          107  +   g[u+2][v+2] = z;
          108  +  }
          109  +
          110  +  while(np--)
          111  +  {
          112  +   int u, z; char _;
          113  +   cin >> _ >> u >> _ >> z;
          114  +   g[0][u+2] = z;
          115  +  }
          116  +
          117  +  while(nc--)
          118  +  {
          119  +   int u, z; char _;
          120  +   cin >> _ >> u >> _ >> z;
          121  +   g[u+2][1] = z;
          122  +  }
          123  +
          124  +  cout << goldberg_tarjan(g, 0, 1) << endl;
          125  + }
          126  +}

Added _lib/graph/biMatch.cpp version [de8fb2bb9f6a1b6d]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Bipertite max-matching (by duality, min-vert-cover)
            4  +//   O(V E)
            5  +//
            6  +// Verified by
            7  +//   SRM 397 Div1 Lv3
            8  +//-------------------------------------------------------------
            9  +
           10  +typedef int           vert;
           11  +typedef vert          edge;
           12  +typedef vector<edge>  edges;
           13  +typedef vector<edges> graph;
           14  +
           15  +bool augment( graph& G, int v, vector<vert>& matchTo, bool visited[] )
           16  +{
           17  + for(int i=0; i<G[v].size(); ++i) {
           18  +  vert u = G[v][i];
           19  +  if( visited[u] ) continue;
           20  +  visited[u] = true;
           21  +
           22  +  if( matchTo[u]<0 || augment(G, matchTo[u], matchTo, visited) )
           23  +   { matchTo[v]=u, matchTo[u]=v; return true; }
           24  + }
           25  + return false;
           26  +}
           27  +
           28  +template<int NV>
           29  +int biMatch( graph& G, int L ) // [0,L):left, [L,?):right
           30  +    // only left->right edges are used during computation
           31  +{
           32  + vector<vert> matchTo(G.size(), -1);
           33  + int ans = 0;
           34  + for(vert v=0; v<L; ++v) {
           35  +  bool visited[NV] = {};
           36  +  if( augment(G, v, matchTo, visited) )
           37  +   ++ans;
           38  + }
           39  + return ans;
           40  +}

Added _lib/graph/isGraphical.cpp version [5fae6e092a92d7c8]

            1  +//-------------------------------------------------------------
            2  +// Check the given list can be a degree list of some graph
            3  +//   O(n^2)  (I suspect it can be made faster, though...)
            4  +//
            5  +// Verified by
            6  +//   - SRM 398 Div1 LV3
            7  +//
            8  +//((
            9  +// Havel-Hakimi
           10  +//   If G[0], ..., G[n] (decreasing) is graphical,
           11  +//   then G[1]-1, G[2]-1, ..., G[G[0]]-1, G[G[0]+1], .., G[n]
           12  +//   is also graphical.
           13  +//))
           14  +//-------------------------------------------------------------
           15  +
           16  +bool isGraphical( vector<int> G )
           17  +{
           18  + sort( G.begin(), G.end() );
           19  +
           20  + vector<int>::iterator b = lower_bound( G.begin(), G.end(), 1 );
           21  + vector<int>::iterator e = G.end();
           22  +
           23  + while( b < e )
           24  + {
           25  +  int n = *(--e);
           26  +  if( e-b < n )
           27  +   return false;
           28  +  for(vector<int>::iterator i=e-n; i!=e; ++i)
           29  +   --*i;
           30  +  inplace_merge( b, e-n, e );
           31  +  b = lower_bound( G.begin(), G.end(), 1 );
           32  + }
           33  + return true;
           34  +}

Added _lib/graph/maxFlow.cpp version [c6d3325f9b7a789b]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Dinic's Algorithm
            4  +//   O(V E)
            5  +//
            6  +// G : bidirectional (G[i].has(j) <==> G[j].has(i))
            7  +// F : flow-capacity F[i][j] = Capacity, F[j][i] = 0
            8  +//
            9  +// Verified by
           10  +//   - SRM 399 Div1 LV3
           11  +//   - PKU 1459
           12  +//   - CodeCraft 09 CUTS
           13  +//   - SRM 465 Div1 LV2
           14  +//-------------------------------------------------------------
           15  +
           16  +static const int NV = 512;
           17  +typedef int           flow;
           18  +typedef int           vert;
           19  +typedef vert          edge;
           20  +typedef vector<edge>  edges;
           21  +typedef vector<edges> graph;
           22  +typedef flow          flow_graph[NV][NV];
           23  +
           24  +flow dinic_dfs( graph& G, flow_graph F, vert v, vert D,
           25  +                int LV[], flow flow_in, int blocked[] )
           26  +{
           27  + flow flow_out = 0;
           28  + for(int i=0; i!=G[v].size(); ++i) {
           29  +  int u = G[v][i];
           30  +  if( LV[v]+1==LV[u] && F[v][u] ) {
           31  +   flow f = min(flow_in-flow_out, F[v][u]);
           32  +   if( u==D || !blocked[u] && (f=dinic_dfs(G,F,u,D,LV,f,blocked)) ) {
           33  +    F[v][u]  -= f;
           34  +    F[u][v]  += f;
           35  +    flow_out += f;
           36  +    if( flow_in == flow_out ) return flow_out;
           37  +   }
           38  +  }
           39  + }
           40  + blocked[v] = (flow_out==0);
           41  + return flow_out;
           42  +}
           43  +
           44  +flow maxFlow( graph& G, flow_graph F, vert S, vert D )
           45  +{
           46  + for( flow total=0 ;; ) {
           47  +  int LV[NV] = {0};
           48  +  vector<int> Q(1, S);
           49  +  for(int lv=1; !Q.empty(); ++lv) {
           50  +   vector<int> Q2;
           51  +   for(int i=0; i!=Q.size(); ++i) {
           52  +    edges& ne = G[Q[i]];
           53  +    for(int j=0; j!=ne.size(); ++j)
           54  +     if( F[Q[i]][ne[j]] && !LV[ne[j]] && ne[j]!=S )
           55  +      LV[ne[j]]=lv, Q2.push_back(ne[j]);
           56  +   }
           57  +   Q.swap(Q2);
           58  +  }
           59  +
           60  +  if( !LV[D] )
           61  +   return total;
           62  +
           63  +  int blocked[NV] = {};
           64  +  total += dinic_dfs( G, F, S, D, LV, 0x7fffffff, blocked );
           65  + }
           66  +}

Added _lib/graph/mincostFlow.cpp version [a86509e21e3c5ec5]

            1  +//-------------------------------------------------------------
            2  +// MinCost-MaxFlow
            3  +//   O(??)
            4  +//
            5  +// Verified by
            6  +//   - SRM 487 Div2 LV3
            7  +//   - SRM 491 Div1 LV3
            8  +//-------------------------------------------------------------
            9  +
           10  +#include <iostream>
           11  +#include <string>
           12  +#include <vector>
           13  +#include <map>
           14  +#include <queue>
           15  +using namespace std;
           16  +
           17  +template<typename T>
           18  +class IdGen
           19  +{
           20  + map<T, int> v2id_;
           21  + vector<T>   id2v_;
           22  +public:
           23  + int v2id(const T& v) {
           24  +  if( !v2id_.count(v) ) { v2id_[v] = size(); id2v_.push_back(v); }
           25  +  return v2id_[v];
           26  + }
           27  + const T& id2v(int i) const { return id2v_[i]; }
           28  + int size() const { return id2v_.size(); }
           29  +};
           30  +
           31  +template<typename Vert, typename Cost, typename Flow, int NV=256>
           32  +class MinCostFlow
           33  +{
           34  + IdGen<Vert> idgen;
           35  +
           36  + vector<int> G[NV];
           37  + Flow F[NV][NV];
           38  + Cost C[NV][NV];
           39  +
           40  +public:
           41  + void addEdge( Vert s_, Vert t_, Cost c, Flow f )
           42  + {
           43  +  int s = idgen.v2id(s_), t = idgen.v2id(t_);
           44  +  G[s].push_back(t);
           45  +  G[t].push_back(s);
           46  +  C[s][t] = c;
           47  +  C[t][s] = -c;
           48  +  F[s][t] = f;
           49  +  F[t][s] = 0;
           50  + }
           51  +
           52  + pair<Cost, Flow> calc( Vert s_, Vert t_ )
           53  + {
           54  +  const int N=idgen.size(), S=idgen.v2id(s_), T=idgen.v2id(t_);
           55  +  static const Cost COST_INF = 1e+300; // !!EDIT HERE!!
           56  +  static const Flow FLOW_INF = 0x7fffffff;
           57  +
           58  +  Cost total_cost = 0;
           59  +  Flow total_flow = 0;
           60  +  vector<Cost> h(N, 0); // potential
           61  +  for(Flow RF=FLOW_INF; RF>0; ) // residual flow
           62  +  {
           63  +   // Dijkstra -- find the min-cost path
           64  +   vector<Cost> d(N, COST_INF);  d[S] = 0;
           65  +   vector<int>  prev(N, -1);
           66  +
           67  +   typedef pair< Cost, pair<int,int> > cedge;
           68  +   priority_queue< cedge, vector<cedge>, greater<cedge> > Q;
           69  +   Q.push( cedge(0, make_pair(S,S)) );
           70  +   while( !Q.empty() ) {
           71  +    cedge e = Q.top(); Q.pop();
           72  +    if( prev[e.second.second] >= 0 )
           73  +     continue;
           74  +    prev[e.second.second] = e.second.first;
           75  +
           76  +    int u = e.second.second;
           77  +    for(int i=0; i<G[u].size(); ++i) {
           78  +     int  v = G[u][i];
           79  +     Cost r_cost = C[u][v] + h[u] - h[v];
           80  +     if( F[u][v] > 0 && d[v] > d[u]+r_cost )
           81  +      Q.push( cedge(d[v]=d[u]+r_cost, make_pair(u,v)) );
           82  +    }
           83  +   }
           84  +
           85  +   if( prev[T] < 0 )
           86  +    break; // Finished
           87  +
           88  +   // Run the flow as much as possible
           89  +   Flow f = RF;
           90  +   for(int u=T; u!=S; u=prev[u])
           91  +    f = min(f, F[prev[u]][u]);
           92  +   RF         -= f;
           93  +   total_flow += f;
           94  +
           95  +   for(int u=T; u!=S; u=prev[u])
           96  +   {
           97  +    total_cost    += f * C[prev[u]][u];
           98  +    F[prev[u]][u] -= f;
           99  +    F[u][prev[u]] += f;
          100  +   }
          101  +
          102  +   // Update the potential
          103  +   for(int u=0; u<N; ++u)
          104  +    h[u] += d[u];
          105  +  }
          106  +  return make_pair(total_cost, total_flow);
          107  + }
          108  +};

Added _lib/graph/undAllPairMinCut.cpp version [08ac17a6157e8d09]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Gomory-Hu
            4  +// All Pair Minimum Cuts for an Undirected Graph
            5  +//   O(V^4)
            6  +//
            7  +// G : undirected (G[i].has(j) <==> G[j].has(i))
            8  +// F : flow-capacity F[i][j] = F[j][i] = Capacity
            9  +//
           10  +// Verified by
           11  +//   - CodeCraft 09 CUTS
           12  +//-------------------------------------------------------------
           13  +
           14  +static const int NV = 512;
           15  +typedef int           flow;
           16  +typedef int           vert;
           17  +typedef vert          edge;
           18  +typedef vector<edge>  edges;
           19  +typedef vector<edges> graph;
           20  +typedef flow          flow_graph[NV][NV];
           21  +
           22  +flow_graph GHF;
           23  +void GomoryHu( graph& G, flow_graph F, flow_graph AllPairMinCut )
           24  +{
           25  + int N = G.size();
           26  + vector<vert> parent(N, 0);
           27  + vector<flow> weight(N, 0);
           28  +
           29  + // construct the Gomory-Hu Tree
           30  + for(vert s=1; s<N; ++s)
           31  + {
           32  +  vert t = parent[s];
           33  +
           34  +  // mincut between s and t
           35  +  memcpy(GHF, F, sizeof(GHF));
           36  +  flow mincut = 0;
           37  +  for(;;) {
           38  +   // bfs
           39  +   vector<vert> prev(N, -1); prev[s]=s;
           40  +   queue<vert> Q; Q.push(s);
           41  +   while( !Q.empty() ) {
           42  +    vert v = Q.front(); Q.pop();
           43  +    for(int i=0; i<G[v].size(); ++i) {
           44  +     vert u = G[v][i];
           45  +     if( prev[u]==-1 && GHF[v][u] )
           46  +      prev[u]=v, Q.push(u);
           47  +    }
           48  +   }
           49  +
           50  +   if( prev[t] == -1 )
           51  +   {
           52  +    // done: separeted to {v|prev[v]!=-1} and {v|prev[v]==-1}
           53  +    // split t's children
           54  +    weight[s] = mincut;
           55  +    for(vert v=0; v<N; ++v)
           56  +     if( parent[v]==t && prev[v]!=-1 && v!=s )
           57  +      parent[v] = s;
           58  +    vert pt = parent[t];
           59  +    if( prev[pt]!=-1 )
           60  +     parent[s]=pt, parent[t]=s, weight[s]=weight[t], weight[t]=mincut;
           61  +    break;
           62  +   }
           63  +
           64  +   // flow...
           65  +   flow cur = 0x7fffffff;
           66  +   for(vert v=t; v!=s; v=prev[v])
           67  +    cur = min(cur, GHF[prev[v]][v]);
           68  +   for(vert v=t; v!=s; v=prev[v])
           69  +    GHF[prev[v]][v] -= cur, GHF[v][prev[v]] += cur;
           70  +   mincut += cur;
           71  +  }
           72  + }
           73  +
           74  + // AllPairMinCuts over the G-H tree
           75  + for(vert s=0; s<N; ++s) {
           76  +  vector<vert> ps_s;
           77  +  for(vert v=s ;; v=parent[v])
           78  +   { ps_s.push_back(v); if( v==parent[v] ) break; }
           79  +  reverse(ps_s.begin(), ps_s.end());
           80  +
           81  +  for(vert t=s+1; t<N; ++t) {
           82  +   vector<vert> ps_t;
           83  +   for(vert v=t ;; v=parent[v])
           84  +    { ps_t.push_back(v); if( v==parent[v] ) break; }
           85  +   reverse(ps_t.begin(), ps_t.end());
           86  +
           87  +   vert ca;
           88  +   for(int i=0; i<ps_s.size() && i<ps_t.size() && ps_s[i]==ps_t[i]; ++i)
           89  +    ca = ps_s[i];
           90  +
           91  +   flow s_to_root = 0x7fffffff, t_to_root = 0x7fffffff;
           92  +   for(vert v=s; v!=ca; v=parent[v])
           93  +    s_to_root = min(s_to_root, weight[v]);
           94  +   for(vert v=t; v!=ca; v=parent[v])
           95  +    t_to_root = min(t_to_root, weight[v]);
           96  +   AllPairMinCut[s][t] = AllPairMinCut[t][s] = min(s_to_root, t_to_root);
           97  +  }
           98  + }
           99  +}

Added _lib/graph/undMinCut.cpp version [27b1f3ac721526bc]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Stoer-Wagner
            4  +// Minimum cost for making the graph unconnected
            5  +//   O(V^3)
            6  +//
            7  +// G : bidirectional (G[v][u] == G[u][v])
            8  +//
            9  +// Verified by
           10  +//   - SRM 340 Div1 LV3
           11  +//-------------------------------------------------------------
           12  +
           13  +typedef int cost;
           14  +typedef int vert;
           15  +typedef vector< vector<cost> > graph;
           16  +
           17  +cost bidi_minCut( graph G, int N )
           18  +{
           19  + vector<vert> V;
           20  + for(int v=0; v<N; ++v)
           21  +  V.push_back(v);
           22  +
           23  + cost result = 0x7fffffff;
           24  + for(int n=N; n>1; --n)
           25  + {
           26  +  // invariant:
           27  +  //   the current set of vertices = {V[0] .. V[n-1]}
           28  +
           29  +  // order the vertices
           30  +  //   v0 = 0 (arbitrary),
           31  +  //   v1 = (u that maximizes \Sigma G[v0][u])
           32  +  //   v2 = (u that maximizes \Sigma G[v0][u]+G[v1][u])
           33  +  //   ...
           34  +  //   vn-2
           35  +  //   vn-1 = (maximizes lastCut = \Sigma G[v0][u]+G[vn-2][u])
           36  +  vector<int> vs;
           37  +  cost lastCut = 0;
           38  +  {
           39  +   vector<cost> ws(n, 0);
           40  +   ws[0] = 1;
           41  +
           42  +   for(int i=0; i<n; ++i) {
           43  +    int j = max_element(ws.begin(), ws.end()) - ws.begin();
           44  +    lastCut = ws[j];
           45  +
           46  +    vs.push_back(j);
           47  +    ws[j] = -1;
           48  +    for(int k=0; k<n; ++k)
           49  +     if( ws[k] != -1 )
           50  +      ws[k] += G[V[k]][V[j]];
           51  +   }
           52  +  }
           53  +
           54  +  // update mincut
           55  +  //   lemma: "the min cost for separating vn-2 and vn-1"==lastCut
           56  +  result = min(result, lastCut);
           57  +
           58  +  // reduce the graph (unify vn-2 and vn-1)
           59  +  //   for testing the case vn-2 and vn-1 is connected
           60  +  vert v2=vs[n-2], v1=vs[n-1];
           61  +  for(int i=0; i<n; ++i) {
           62  +   G[V[v2]][V[i]] += G[V[v1]][V[i]];
           63  +   G[V[i]][V[v2]] += G[V[i]][V[v1]];
           64  +  }
           65  +  V.erase( V.begin() + v1 );
           66  + }
           67  + return result;
           68  +}

Added _lib/numeric/bigintFake.cpp version [029a85274b27ccda]

            1  +
            2  +string add(const string& a, const string& b)
            3  +{
            4  + int n = max(a.size(), b.size()), carry=0;
            5  + string c(n, '0');
            6  + for(int i=0; i<n; ++i) {
            7  +  int x = (a.size()<=i ? 0 : a[a.size()-1-i]-'0')
            8  +        + (b.size()<=i ? 0 : b[b.size()-1-i]-'0') + carry;
            9  +  c[n-1-i] = char('0'+x%10);
           10  +  carry = x/10;
           11  + }
           12  + if( carry ) c = char('0'+carry)+c;
           13  + return c;
           14  +}

Added _lib/numeric/erathos.cpp version [451164162aaf4750]

            1  + static const int N = 999999;
            2  + vector<bool> isp(N+1, true);
            3  + vector<int> ps;
            4  + for(int p=2; p<=N; ++p)
            5  +  if( isp[p] ) {
            6  +   ps.push_back(p);
            7  +   for(int q=p+p; q<=N; q+=p)
            8  +    isp[q] = false;
            9  +  }

Added _lib/numeric/fft.cpp version [30aac07db1a49b69]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Fast Discrete Fourier Transform
            4  +//   O(n log n)
            5  +//   n must be a power of 2.
            6  +//
            7  +// Verified by
            8  +//   - SRM 436 LV3
            9  +//-------------------------------------------------------------
           10  +
           11  +CMP tmp[65536*4];
           12  +
           13  +template<int F>
           14  +void fft_impl( CMP a[], int n, int stride = 1 )
           15  +{
           16  + if( n > 1 )
           17  + {
           18  +  CMP *ev=a, *od=a+stride;
           19  +  int s2=stride*2, n2=n/2;
           20  +
           21  +  fft_impl<F>( ev, n2, s2 );
           22  +  fft_impl<F>( od, n2, s2 );
           23  +
           24  +  for(int i=0; i<n; ++i) tmp[i] = ev[s2*(i%n2)] + od[s2*(i%n2)]*polar(1.0, F*2*M_PI*i/n);
           25  +  for(int i=0; i<n; ++i) a[stride*i] = tmp[i];
           26  + }
           27  +}
           28  +
           29  +void fft( vector<CMP>& a )
           30  +{
           31  + fft_impl<+1>(&a[0], a.size());
           32  +}
           33  +
           34  +void ifft( vector<CMP>& a )
           35  +{
           36  + fft_impl<-1>(&a[0], a.size());
           37  + for(int i=0; i<a.size(); ++i)
           38  +  a[i] /= a.size();
           39  +}

Added _lib/numeric/gcd_lcm.cpp version [9e6d3cbd67078cb9]

            1  +LL gcd(LL a, LL b)
            2  +{
            3  + while(a)
            4  +  swap(a, b%=a);
            5  + return b;
            6  +}
            7  +
            8  +LL lcm(LL a, LL b)
            9  +{
           10  + return a/gcd(a,b)*b;
           11  +}
           12  +
           13  +// Assumption: (a/b)*b+(a%b) == a
           14  +//   For typical C/C++ compilers, % on negatives satisfies this.
           15  +//   To be sure, replace a%b by a-a/b*b
           16  +
           17  +LL xgcd(LL a, LL b, LL* x, LL* y) // ax+by=g
           18  +{
           19  + if(b) {
           20  +  LL yy, g = xgcd(b,a%b,&yy,x);
           21  +  *y = yy - a/b**x;
           22  +  return g;
           23  + }
           24  + else {
           25  +  *x=1, *y=0;
           26  +  return a;
           27  + }
           28  +}

Added _lib/numeric/linearEq.cpp version [908cbaac8fbb72e4]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Linear Equation Solver
            4  +//   O(n^3)
            5  +//
            6  +// Verified by
            7  +//   - SRM 398 Div1 LV3
            8  +//   - AOJ 0004
            9  +//-------------------------------------------------------------
           10  +
           11  +vector<double> solve_linear_eq( int n, vector< vector<double> > M, const vector<double>& V )
           12  +{
           13  + vector<double> A(V);
           14  + for(int i=0; i<n; ++i)
           15  + {
           16  +  // pivot
           17  +  if( M[i][i] == 0 )
           18  +   for(int j=i+1; j<n; ++j)
           19  +    if( M[j][i] != 0 )
           20  +     {swap(M[i], M[j]); swap(A[i], A[j]); break;}
           21  +  if( M[i][i] == 0 )
           22  +   throw "no anser";
           23  +
           24  +  // M[i][i] <-- 1
           25  +  double p = M[i][i];
           26  +  for(int j=i; j<n; ++j)
           27  +   M[i][j] /= p;
           28  +  A[i] /= p;
           29  +
           30  +  // M[*][i] <-- 0
           31  +  for(int j=0; j<n; ++j) if(j!=i)
           32  +  {
           33  +   double r = M[j][i];
           34  +   for(int k=i; k<n; ++k)
           35  +    M[j][k] -= M[i][k] * r;
           36  +   A[j] -= A[i] * r;
           37  +  }
           38  + }
           39  + return A;
           40  +}

Added _lib/numeric/linearEq2.cpp version [bf7f1d164fa34636]

            1  +//-------------------------------------------------------------
            2  +// Linear Equation Solver for Teplitz Matrix
            3  +//   O(n^2)
            4  +//
            5  +// Faster solver for matrices satisfying
            6  +//   M[i][j] == M[i+1][j+1]
            7  +// for all i, j>0
            8  +// Be careful that this implementation does not support the
            9  +// case M[0][0]=M[1][1]=...=0. (zero-division)
           10  +//
           11  +// TODO: support M[0][0]=M[1][1]=...=0
           12  +// QUICKHACK:
           13  +//    find the least degenerated k and
           14  +//    calc initial vectors by gauss_jordan...
           15  +//
           16  +// Verified by
           17  +//   - (Checked by random data to match with linearEq.cpp)
           18  +//-------------------------------------------------------------
           19  +
           20  +vector<double> solve_teplitz( int n, vector< vector<double> > M, const vector<double>& V )
           21  +{
           22  + vector<double> f, b, x;
           23  +
           24  + // invariants
           25  + //   M|k f|k = (1 0 ... 0)
           26  + //   M|k b|k = (0 ... 0 1)
           27  + //   M|k x|k = V|k
           28  + f.push_back(    1 / M[0][0] );
           29  + b.push_back(    1 / M[0][0] );
           30  + x.push_back( V[0] / M[0][0] );
           31  +
           32  + for(int k=2; k<=n; ++k)
           33  + {
           34  +  // M|k (f|k-1 0) = (1 0 ... 0 ea)
           35  +  double ea = 0;
           36  +  for(int i=0; i<k-1; ++i)
           37  +   ea += M[k-1][i] * f[i];
           38  +
           39  +  // M|k (0 b|k-1) = (eb 0 ... 0 1)
           40  +  double eb = 0;
           41  +  for(int i=1; i<k; ++i)
           42  +   eb += M[0][i] * b[i-1];
           43  +
           44  +  // u(1 ea) + v(eb 1) = (1 0)
           45  +  //==> u = 1 / (1-ea.eb),  v = -ea /(1-ea.eb)
           46  +  double u = 1/(1-ea*eb), v = -ea/(1-ea*eb);
           47  +  vector<double> ff;
           48  +  for(int i=0; i<k; ++i)
           49  +   ff.push_back( u*(i<k-1 ? f[i] : 0) + v*(i>0 ? b[i-1] : 0) );
           50  +
           51  +  // similarly...
           52  +  u = -eb/(1-ea*eb), v = 1/(1-ea*eb);
           53  +  vector<double> bb;
           54  +  for(int i=0; i<k; ++i)
           55  +   bb.push_back( u*(i<k-1 ? f[i] : 0) + v*(i>0 ? b[i-1] : 0) );
           56  +
           57  +  // update
           58  +  f.swap(ff);
           59  +  b.swap(bb);
           60  +
           61  +  // M|k (x|k 0) (V|k ec)
           62  +  double ec = 0;
           63  +  for(int i=0; i<k-1; ++i)
           64  +   ec += M[k-1][i] * x[i];
           65  +  x.push_back(0);
           66  +  for(int i=0; i<k; ++i)
           67  +   x[i] -= b[i] * (ec-V[k-1]);
           68  + }
           69  +
           70  + return x;
           71  +}

Added _lib/numeric/matrix.cpp version [2c92483914a46a56]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Matrix Operations
            4  +//
            5  +// Verified by
            6  +//   - SRM342 Div1 LV3
            7  +//   - SRM341 Div1 LV3
            8  +//   - SRM338 Div1 LV2
            9  +//-------------------------------------------------------------
           10  +
           11  +vector<LL> vMul( const vector< vector<LL> >& A, const vector<LL>& B )
           12  +{
           13  + const int n = A.size();
           14  +
           15  + vector<LL> C(n);
           16  + for(int i=0; i<n; ++i)
           17  +  for(int j=0; j<n; ++j)
           18  +   C[i] += A[i][j] * B[j];
           19  + return C;
           20  +}
           21  +
           22  +vector< vector<LL> > mMul( const vector< vector<LL> >& A, const vector< vector<LL> >& B )
           23  +{
           24  + const int n = A.size();
           25  +
           26  + vector< vector<LL> > C(n, vector<LL>(n));
           27  + for(int i=0; i<n; ++i)
           28  +  for(int j=0; j<n; ++j) {
           29  +   LL Cij = 0;
           30  +   for(int k=0; k<n; ++k)
           31  +    Cij += A[i][k] * B[k][j];
           32  +   C[i][j] = Cij;
           33  +  }
           34  + return C;
           35  +}
           36  +
           37  +vector< vector<LL> > mPow( vector< vector<LL> > M, LL t ) // t>0
           38  +{
           39  + vector< vector<LL> > R;
           40  + for(; t; t>>=1, M=mMul(M,M))
           41  +  if( t&1 )
           42  +   R = (R.empty() ? M : mMul(R,M));
           43  + return R;
           44  +}
           45  +
           46  +vector< vector<LL> > mAdd( const vector< vector<LL> >& A, const vector< vector<LL> >& B )
           47  +{
           48  + const int n = A.size();
           49  +
           50  + vector< vector<LL> > C(n, vector<LL>(n));
           51  + for(int i=0; i<n; ++i)
           52  +  for(int j=0; j<n; ++j)
           53  +   C[i][j] = A[i][j] + B[i][j];
           54  + return C;
           55  +}

Added _lib/numeric/mebius.cpp version [daa89aa8f6eb3e5c]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Mebius Function
            4  +//   O( sqrt(N) )
            5  +//
            6  +// mebius(n) = 0      if n=0 mod p*p for some p
            7  +// mebius(n) = (-1)^k otherwise, where k is the number of n's prime factors
            8  +//
            9  +// properties:
           10  +//  1: mebius(nm) = mebius(n) mebius(m)   if gcd(n,m)=1
           11  +//  2: f(n) = Sigma_{d|n} g(d)
           12  +//       <=>
           13  +//     g(n) = Sigma_{d|n} f(d)mebius(n/d)
           14  +//
           15  +// Verified by
           16  +//   - CodeCraft '11 PSTR
           17  +//
           18  +// Further memoization or more might be needed.
           19  +//-------------------------------------------------------------
           20  +
           21  +int mebius(int n)
           22  +{
           23  + int f = 1;
           24  + for(int q=2; q*q<=n; ++q)
           25  +  if( n%q == 0 )
           26  +  {
           27  +   if( n%(q*q) == 0 )
           28  +    return 0;
           29  +   n /= q;
           30  +   f *= -1;
           31  +  }
           32  + if(n>1)
           33  +  f *= -1;
           34  + return f;
           35  +}
           36  +

Added _lib/numeric/modArith.cpp version [b348fa4dbce4653d]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Modulo Arithmetics
            4  +//
            5  +// Verified by
            6  +//   - TCO10 R3 LV3
            7  +//-------------------------------------------------------------
            8  +
            9  +static const int MODVAL = 1000000007; // op/ depends on primarity of the MODVAL
           10  +struct mint
           11  +{
           12  + int val;
           13  + mint():val(0){}
           14  + mint(int x):val(x%MODVAL) {}
           15  + mint(LL  x):val(x%MODVAL) {}
           16  +};
           17  +
           18  +mint operator+(mint x, mint y) { return x.val+y.val; }
           19  +mint operator-(mint x, mint y) { return x.val-y.val+MODVAL; }
           20  +mint operator*(mint x, mint y) { return LL(x.val)*y.val; }
           21  +mint POW(mint x, int e) {
           22  + mint v = 1;
           23  + for(;e;x=x*x,e>>=1)
           24  +  if(e&1)
           25  +   v=v*x;
           26  + return v;
           27  +}
           28  +mint operator/(mint x, mint y) { return x * POW(y, MODVAL-2); }
           29  +
           30  +vector<mint> FAC_(1,1);
           31  +void FAC_INIT(int n) { for(int i=1; i<=n; ++i) FAC_.push_back( FAC_.back()*i ); }
           32  +mint FAC(mint x)       { return FAC_[x.val]; }
           33  +mint C(mint n, mint k) { return k.val<0 || n.val<k.val ? 0 : FAC(n) / (FAC(k) * FAC(n-k)); }
           34  +
           35  +/*
           36  +// MODVAL must be a prime!!
           37  +LL GSS(LL k, LL b, LL e) // k^b + k^b+1 + ... + k^e
           38  +{
           39  + if( b >  e ) return 0;
           40  + if( k <= 1 ) return k*(e-b+1);
           41  + return DIV(SUB(POW(k, e+1), POW(k,b)), k-1);
           42  +}
           43  +
           44  +LL Cpascal(LL n, LL k)
           45  +{
           46  + vector< vector<LL> > c(n+1, vector<LL>(k+1));
           47  + for(LL nn=1; nn<=n; ++nn)
           48  +  for(LL kk=0; kk<=min(nn,k); ++kk)
           49  +   c[nn][kk] = kk==0 || kk==nn ? 1 : ADD(c[nn-1][kk-1], c[nn-1][kk]);
           50  + return c[n][k];
           51  +}
           52  +
           53  +vector< vector<LL> > MATMUL(vector< vector<LL> >& a, vector< vector<LL> >& b)
           54  +{
           55  +   int N = a.size();
           56  +   vector< vector<LL> > c(N, vector<LL>(N));
           57  +   for(int i=0; i<N; ++i)
           58  +   for(int j=0; j<N; ++j)
           59  +   for(int k=0; k<N; ++k)
           60  +      c[i][j] = ADD(c[i][j], MUL(a[i][k],b[k][j]));
           61  +   return c;
           62  +}
           63  +
           64  +// works for non-prime MODVAL
           65  +LL GEO(LL x_, LL e) // x^0 + x^1 + ... + x^e-1
           66  +{
           67  +   vector< vector<LL> > v(2, vector<LL>(2));
           68  +   vector< vector<LL> > x(2, vector<LL>(2));
           69  +   v[0][0] = v[1][1] = 1;
           70  +   x[0][0] = x_; x[0][1] = 0;
           71  +   x[1][0] = 1 ; x[1][1] = 1;
           72  +   for(;e;x=MATMUL(x,x),e>>=1)
           73  +      if(e&1)
           74  +         v = MATMUL(v, x);
           75  +   return v[1][0];
           76  +}
           77  +
           78  +// works for non-prime MODVAL
           79  +LL HYP(LL x_, LL e) // e x^0 + (e-1) x^1 + ... + 1 x^e-1 = GEO(x,1)+GEO(x,2)+...+GEO(x,e)
           80  +{
           81  +   vector< vector<LL> > v(3, vector<LL>(3));
           82  +   vector< vector<LL> > x(3, vector<LL>(3));
           83  +   v[0][0] = v[1][1] = v[2][2] = 1;
           84  +   x[0][0] = x_; x[0][1] = 0; x[0][2] = 0;
           85  +   x[1][0] = 1 ; x[1][1] = 1; x[1][2] = 0;
           86  +   x[2][0] = 0 ; x[2][1] = 1; x[2][2] = 1;
           87  +   e++;
           88  +   for(;e;x=MATMUL(x,x),e>>=1)
           89  +      if(e&1)
           90  +         v = MATMUL(v, x);
           91  +   return v[2][0];
           92  +}
           93  +*/

Added _lib/numeric/modArithOld.cpp version [b669f317babaf285]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Modulo Arithmetics
            4  +//
            5  +// Verified by
            6  +//   - SRM 397 Div1 LV2
            7  +//   - SRM 428 Div1 LV2
            8  +//   - CodeCraft 2010 CNTINT DRAW
            9  +//-------------------------------------------------------------
           10  +
           11  +static const LL MODVAL = 1000000007; // must fit in 32-bits
           12  +
           13  +LL ADD(LL x, LL y) { return (x+y)%MODVAL; }
           14  +LL SUB(LL x, LL y) { return (x-y+MODVAL)%MODVAL; }
           15  +LL MUL(LL x, LL y) { return (x*y)%MODVAL; }
           16  +LL POW(LL x, LL e) {
           17  + LL v = 1;
           18  + for(;e;x=MUL(x,x),e>>=1)
           19  +  if(e&1)
           20  +   v = MUL(v, x);
           21  + return v;
           22  +}
           23  +
           24  +// MODVAL must be a prime!!
           25  +LL DIV(LL x, LL y) { return MUL(x, POW(y, MODVAL-2)); }
           26  +
           27  +// MODVAL must be a prime!!
           28  +LL C(LL n, LL k) {
           29  + LL v = 1;
           30  + for(LL i=1; i<=k; ++i)
           31  +  v = DIV(MUL(v, n-i+1), i);
           32  + return v;
           33  +}
           34  +
           35  +// MODVAL must be a prime!!
           36  +LL GSS(LL k, LL b, LL e) // k^b + k^b+1 + ... + k^e
           37  +{
           38  + if( b >  e ) return 0;
           39  + if( k <= 1 ) return k*(e-b+1);
           40  + return DIV(SUB(POW(k, e+1), POW(k,b)), k-1);
           41  +}
           42  +
           43  +
           44  +
           45  +
           46  +LL Cpascal(LL n, LL k)
           47  +{
           48  + vector< vector<LL> > c(n+1, vector<LL>(k+1));
           49  + for(LL nn=1; nn<=n; ++nn)
           50  +  for(LL kk=0; kk<=min(nn,k); ++kk)
           51  +   c[nn][kk] = kk==0 || kk==nn ? 1 : ADD(c[nn-1][kk-1], c[nn-1][kk]);
           52  + return c[n][k];
           53  +}
           54  +
           55  +vector< vector<LL> > MATMUL(vector< vector<LL> >& a, vector< vector<LL> >& b)
           56  +{
           57  +   int N = a.size();
           58  +   vector< vector<LL> > c(N, vector<LL>(N));
           59  +   for(int i=0; i<N; ++i)
           60  +   for(int j=0; j<N; ++j)
           61  +   for(int k=0; k<N; ++k)
           62  +      c[i][j] = ADD(c[i][j], MUL(a[i][k],b[k][j]));
           63  +   return c;
           64  +}
           65  +
           66  +// works for non-prime MODVAL
           67  +LL GEO(LL x_, LL e) // x^0 + x^1 + ... + x^e-1
           68  +{
           69  +   vector< vector<LL> > v(2, vector<LL>(2));
           70  +   vector< vector<LL> > x(2, vector<LL>(2));
           71  +   v[0][0] = v[1][1] = 1;
           72  +   x[0][0] = x_; x[0][1] = 0;
           73  +   x[1][0] = 1 ; x[1][1] = 1;
           74  +   for(;e;x=MATMUL(x,x),e>>=1)
           75  +      if(e&1)
           76  +         v = MATMUL(v, x);
           77  +   return v[1][0];
           78  +}
           79  +
           80  +// works for non-prime MODVAL
           81  +LL HYP(LL x_, LL e) // e x^0 + (e-1) x^1 + ... + 1 x^e-1 = GEO(x,1)+GEO(x,2)+...+GEO(x,e)
           82  +{
           83  +   vector< vector<LL> > v(3, vector<LL>(3));
           84  +   vector< vector<LL> > x(3, vector<LL>(3));
           85  +   v[0][0] = v[1][1] = v[2][2] = 1;
           86  +   x[0][0] = x_; x[0][1] = 0; x[0][2] = 0;
           87  +   x[1][0] = 1 ; x[1][1] = 1; x[1][2] = 0;
           88  +   x[2][0] = 0 ; x[2][1] = 1; x[2][2] = 1;
           89  +   e++;
           90  +   for(;e;x=MATMUL(x,x),e>>=1)
           91  +      if(e&1)
           92  +         v = MATMUL(v, x);
           93  +   return v[2][0];
           94  +}

Added _lib/numeric/nextComb.cpp version [291928c806737930]

            1  +//-------------------------------------------------------------
            2  +// Next Combination
            3  +//
            4  +// Verified by
            5  +//   - SRM345 Div1 LV3
            6  +//-------------------------------------------------------------
            7  +
            8  +LL next_combination(LL p)
            9  +{
           10  + assert( p > 0 );
           11  + LL lsb = p & -p;
           12  + LL rem = p + lsb;
           13  + LL rit = rem & ~p;
           14  + return rem | (rit/lsb >> 1)-1;
           15  +}

Added _lib/numeric/sternBrocot.cpp version [bfa0be1fa6ea3c75]

            1  +
            2  +//-------------------------------------------------------------
            3  +// Enumerate all positive reduced fractions in a
            4  +// systematic manner.
            5  +//   [pl/ql, pr/qr] --> [pl/ql, pm/qm] + [pm/qm, pr/qr]
            6  +//                  --> ...
            7  +//
            8  +// Verified by
            9  +//   - CodeCraft 09 FRACTION
           10  +//-------------------------------------------------------------
           11  +
           12  +void sternBrocot(LL pl = 0, LL ql = 1, LL pr = 1, LL qr = 0)
           13  +{
           14  + LL pm = pl + pr, qm = ql + qr;
           15  + sternBrocot(pl, ql, pm, qm);
           16  + sternBrocot(pm, qm, pr, qr);
           17  +}
           18  +
           19  +/*
           20  +bool fleq(LL p1, LL q1, LL p2, LL q2)
           21  +{
           22  + return p1*q2 <= p2*q1;
           23  +}
           24  +
           25  +void sternBrocot(LL pl = 0, LL ql = 1, LL pr = 1, LL qr = 0)
           26  +{
           27  + for(;;) {
           28  +  LL pm = pl + pr, qm = ql + qr;
           29  +
           30  +  if( fleq(c,d,pm,qm) ) {
           31  +//   pr = pm, qr = qm; // [pl/ql, pm/qm]
           32  +   LL X = c*ql - d*pl;
           33  +   LL Y = d*pr - c*qr;
           34  +   LL k = max(1LL, Y/X);
           35  +   pr += k*pl;
           36  +   qr += k*ql;
           37  +  }
           38  +  else if( fleq(pm,qm,a,b) ) {
           39  +//   pl = pm, ql = qm; // [pm/qm, pr/qr]
           40  +   LL X = b*pr - a*qr;
           41  +   LL Y = a*ql - b*pl;
           42  +   LL k = max(1LL, Y/X);
           43  +   pl += k*pr;
           44  +   ql += k*qr;
           45  +  }
           46  +  else {
           47  +   cout << pm+qm*base << "/" << qm << endl;
           48  +   break;
           49  +  }
           50  + }
           51  +}
           52  +*/

Added _lib/typical/amap.cpp version [8e84d319ff86cb61]

            1  +//
            2  +// accumulative map
            3  +//   basically a map<K,V>, but it eliminates duplication lazily
            4  +//   first keep all inserted elements in a vector. only when the buffer
            5  +//   overflows, it eliminates duplication
            6  +//
            7  +
            8  +template<typename K, typename V, int LIMIT = (1<<26)/3/sizeof(pair<K,V>)>
            9  +struct amap
           10  +{
           11  + typedef typename vector< pair<K,V> >::iterator iterator;
           12  +
           13  + vector< pair<K,V> > kv;
           14  + amap() { kv.reserve(LIMIT); }
           15  +
           16  + void add(const K& k, const V& v)
           17  + {
           18  +  kv.push_back( make_pair(k,v) );
           19  +  if( kv.size() == LIMIT )
           20  +   normalize();
           21  + }
           22  +
           23  + iterator begin()       { return kv.begin(); }
           24  + iterator end()         { return kv.end(); }
           25  + void swap( amap& rhs ) { kv.swap(rhs.kv); }
           26  +
           27  + // Tested: SRM 469 Lv3
           28  + void normalize()
           29  + {
           30  +  sort(kv.begin(), kv.end());
           31  +  int i=0;
           32  +  for(int j=0; j<kv.size(); ++i)
           33  +  {
           34  +   int k = j;
           35  +   kv[i] = kv[k];
           36  +   while( ++j<kv.size() && kv[k].first==kv[j].first )
           37  +    kv[i].second += kv[j].second;
           38  +  }
           39  +  kv.resize(i);
           40  + }
           41  +/*
           42  + // Not Tested (Prefer First)
           43  + void normalize()
           44  + {
           45  +  sort(kv.begin(), kv.end());
           46  +  int i=0;
           47  +  for(int j=0; j<kv.size(); ++i)
           48  +  {
           49  +   int k = j;
           50  +   kv[i] = kv[k];
           51  +   while( ++j<kv.size() && kv[k].first==kv[j].first )
           52  +    {}
           53  +  }
           54  +  kv.resize(i);
           55  + }
           56  +
           57  + // Not Tested (Prefer Last)
           58  + void normalize()
           59  + {
           60  +  sort(kv.begin(), kv.end());
           61  +  int i=0;
           62  +  for(int j=0; j<kv.size(); ++i)
           63  +  {
           64  +   int k = j;
           65  +   while( ++j<kv.size() && kv[k].first==kv[j].first )
           66  +    {}
           67  +   kv[i] = kv[j-1];
           68  +  }
           69  +  kv.resize(i);
           70  + }
           71  +*/
           72  +};

Added _lib/typical/bfs.cpp version [b584e6b7fe45956b]

            1  +// code template for BFS
            2  +
            3  +  State start = /*start*/;
            4  +  vector<State> Q( 1, start );
            5  +  set<State>    V; V.insert(start);
            6  +
            7  +  for(int step=0; !Q.empty(); ++step)
            8  +  {
            9  +   vector<State> Qold; Qold.swap(Q);
           10  +   for(int qi=0; qi<Qold.size(); ++qi)
           11  +   {
           12  +    State& cur = Qold[qi];
           13  +    if( /*isGoal(cur)*/ )
           14  +    {
           15  +    }
           16  +
           17  +    foreach(next)
           18  +    {
           19  +     if( !V.count(next) )
           20  +     {
           21  +      V.insert(next);
           22  +      Q.push_back(next);
           23  +     }
           24  +    }
           25  +   }
           26  +  }

Added _lib/typical/bitop.cpp version [80d6730d2c161aa4]

            1  +int bitcnt(LL x)
            2  +{
            3  + int c = 0;
            4  + for(; x; x>>=1)
            5  +  c += x&1;
            6  + return c;
            7  +}

Added _lib/typical/comb.cpp version [d63ada0513560bce]

            1  +//-------------------------------------------------------------
            2  +// number of combinations choosing k out of n
            3  +// # you might better consider to use Pascal's triangle
            4  +// # for comb modulo some number...
            5  +//
            6  +// Verified by
            7  +//   - SRM 350 Div1 LV2
            8  +//-------------------------------------------------------------
            9  +
           10  +LL comb(LL n, LL k)
           11  +{
           12  + k = min(k, n-k);
           13  +
           14  + LL c = 1;
           15  + for(LL i=0; i<k; ++i)
           16  +  c *= n-i, c /= i+1;
           17  + return c;
           18  +}

Added _lib/typical/dp.cpp version [81322e1ce041bb24]

            1  +// Tested: SRM 454 Lv2
            2  +template<typename T>
            3  +struct DP2
            4  +{
            5  + const int N1, N2;
            6  + vector<T> data;
            7  + DP2(int N1, int N2, const T& t = T())
            8  +  : N1(N1), N2(N2), data(N1*N2, t) { assert(data.size()*sizeof(T)<(1<<26)); }
            9  + T& operator()(int i1, int i2)
           10  +  { return data[ (i1*N2)+i2 ]; }
           11  + void swap(DP2& rhs)
           12  +  { data.swap(rhs.data); }
           13  +};
           14  +
           15  +// Tested: Codeforces #13 C
           16  +template<typename T>
           17  +struct DP2x
           18  +{
           19  + const int N1, N2;
           20  + vector<T> data;
           21  + DP2x(int, int N2, const T& t = T())
           22  +  : N1(2), N2(N2), data(N1*N2, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           23  + T& operator()(int i1, int i2)
           24  +  { i1&=1; return data[ (i1*N2)+i2 ]; }
           25  + void swap(DP2x& rhs)
           26  +  { data.swap(rhs.data); }
           27  +};
           28  +
           29  +// Tested: SRM 452 Lv3
           30  +template<typename T>
           31  +struct DP3
           32  +{
           33  + int N1, N2, N3;
           34  + vector<T> data;
           35  + DP3(int N1, int N2, int N3, const T& t = T())
           36  +  : N1(N1), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           37  + T& operator()(int i1, int i2, int i3)
           38  +  { return data[ ((i1*N2)+i2)*N3+i3 ]; }
           39  + void swap(DP3& rhs)
           40  +  { data.swap(rhs.data); }
           41  +};
           42  +
           43  +// Tested: SRM 468 Lv2
           44  +template<typename T>
           45  +struct DP3x
           46  +{
           47  + int N1, N2, N3;
           48  + vector<T> data;
           49  + DP3x(int, int N2, int N3, const T& t = T())
           50  +  : N1(2), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T) < (1<<26)); }
           51  + T& operator()(int i1, int i2, int i3)
           52  +  { i1&=1; return data[ ((i1*N2)+i2)*N3+i3 ]; }
           53  + void swap(DP3x& rhs)
           54  +  { data.swap(rhs.data); }
           55  +};
           56  +
           57  +// Not Tested
           58  +template<typename T>
           59  +struct DP4
           60  +{
           61  + int N1, N2, N3, N4;
           62  + vector<T> data;
           63  + DP4(int N1, int N2, int N3, int N4, const T& t = T())
           64  +  : N1(N1), N2(N2), N3(N3), N4(N4), data(N1*N2*N3*N4, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           65  + T& operator()(int i1, int i2, int i3, int i4)
           66  +  { return data[ (((i1*N2)+i2)*N3+i3)*N4+i4 ]; }
           67  + void swap(DP4& rhs)
           68  +  { data.swap(rhs.data); }
           69  +};
           70  +
           71  +// Not Tested
           72  +template<typename T>
           73  +struct DP4x
           74  +{
           75  + int N1, N2, N3, N4;
           76  + vector<T> data;
           77  + DP4x(int, int N2, int N3, int N4, const T& t = T())
           78  +  : N1(2), N2(N2), N3(N3), N4(N4), data(N1*N2*N3*N4, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           79  + T& operator()(int i1, int i2, int i3, int i4)
           80  +  { i1&=1; return data[ (((i1*N2)+i2)*N3+i3)*N4+i4 ]; }
           81  + void swap(DP4x& rhs)
           82  +  { data.swap(rhs.data); }
           83  +};
           84  +
           85  +
           86  +// Tested: SRM 351 Lv2
           87  +template<typename T>
           88  +struct DP5
           89  +{
           90  + int N1, N2, N3, N4, N5;
           91  + vector<T> data;
           92  + DP5(int N1, int N2, int N3, int N4, int N5, const T& t = T())
           93  +  : N1(N1), N2(N2), N3(N3), N4(N4), N5(N5), data(N1*N2*N3*N4*N5, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           94  + T& operator()(int i1, int i2, int i3, int i4, int i5)
           95  +  { return data[ ((((i1*N2)+i2)*N3+i3)*N4+i4)*N5+i5 ]; }
           96  + void swap(DP5& rhs)
           97  +  { data.swap(rhs.data); }
           98  +};
           99  +
          100  +// Not Tested
          101  +template<typename T>
          102  +struct DP5x
          103  +{
          104  + int N1, N2, N3, N4, N5;
          105  + vector<T> data;
          106  + DP5x(int, int N2, int N3, int N4, int N5, const T& t = T())
          107  +  : N1(2), N2(N2), N3(N3), N4(N4), N5(N5), data(N1*N2*N3*N4*N5, t) { assert(data.size()*sizeof(T)<(1<<26)); }
          108  + T& operator()(int i1, int i2, int i3, int i4, int i5)
          109  +  { i1&=1; return data[ ((((i1*N2)+i2)*N3+i3)*N4+i4)*N5+i5 ]; }
          110  + void swap(DP5x& rhs)
          111  +  { data.swap(rhs.data); }
          112  +};

Added _lib/typical/idGen.cpp version [01a2602f05b036ac]

            1  +//-------------------------------------------------------------
            2  +// ID Assignment
            3  +//
            4  +// Verified by
            5  +//   - ACM/ICPC Tokyo 2010 A
            6  +//   - SRM 491 Div1 LV3
            7  +//-------------------------------------------------------------
            8  +
            9  +template<typename T>
           10  +class IdGen
           11  +{
           12  + map<T, int> v2id_;
           13  + vector<T>   id2v_;
           14  +public:
           15  + int v2id(const T& v) {
           16  +  if( !v2id_.count(v) ) { v2id_[v] = size(); id2v_.push_back(v); }
           17  +  return v2id_[v];
           18  + }
           19  + const T& id2v(int i) const { return id2v_[i]; }
           20  + int size() const { return id2v_.size(); }
           21  +};

Added _lib/typical/inMap.cpp version [a5a448928ab96673]

            1  +
            2  +bool inMap(int H, int W, int y, int x)
            3  +{
            4  + return (0<=y && y<H && 0<=x && x<W);
            5  +}

Added _lib/typical/maxRectArea.cpp version [73000b9fbf0fd9f6]

            1  +//-------------------------------------------------------------
            2  +// h[] : list of heights
            3  +//   i-th rectangle is located at (i,0)--(i+1,h[i])
            4  +//
            5  +// calculate the area of maximum sub-rectangle
            6  +//
            7  +// Verified by
            8  +//   - SRM 337 Div1 LV2
            9  +//-------------------------------------------------------------
           10  +
           11  +  // solve
           12  +  vector<int> left(n);
           13  +  {
           14  +   map<LL, int> h; h[-1] = -1;
           15  +   for(int i=0; i<n; ++i) {
           16  +    // position of the highest building < R[i]
           17  +    map<LL,int>::iterator it = h.lower_bound(R[i]);
           18  +    left[i] = (--it)->second+1;
           19  +    h.erase( ++it, h.end() );
           20  +    h[ R[i] ] = i;
           21  +   }
           22  +  }
           23  +  vector<int> right(n);
           24  +  {
           25  +   map<LL, int> h; h[-1] = n;
           26  +   for(int i=n-1; i>=0; --i) {
           27  +    // position of the highest building < R[i]
           28  +    map<LL,int>::iterator it = h.lower_bound(R[i]);
           29  +    right[i] = (--it)->second-1;
           30  +    h.erase( ++it, h.end() );
           31  +    h[ R[i] ] = i;
           32  +   }
           33  +  }
           34  +  LL ans = 0;
           35  +  for(int i=0; i<n; ++i) {
           36  +   LL area = R[i] * (right[i] - left[i] + 1);
           37  +   ans = max(ans, area);
           38  +  }
           39  +  return ans;

Added _lib/typical/setCover.cpp version [3071774087420287]

            1  +
            2  +//-------------------------------------------------------------
            3  +// (Minimum) Set Cover
            4  +//   NP-complete
            5  +//
            6  +// Consider using SetCoverEasy, when mask is downward closed.
            7  +//
            8  +// Verified by
            9  +//   - SRM345 Div1 LV3
           10  +//-------------------------------------------------------------
           11  +
           12  +LL next_combination(LL p)
           13  +{
           14  + LL lsb = p & -p;
           15  + LL rem = p + lsb;
           16  + LL rit = rem & ~p;
           17  + return rem|(((rit/lsb)>>1)-1);
           18  +}
           19  +
           20  +// Is it possible to cover the goal by at most k elements from mask?
           21  +// Assumption:  goal \subseteq \bigcup mask
           22  +bool canCover( LL goal, set<LL>& mask, int k )
           23  +{
           24  + // optimizer
           25  + for(bool update=true; update; ) {
           26  +  update = false;
           27  +
           28  +  // if *it \subseteq *jt for some jt, then we NEVER use it
           29  +  // if *it is the only mask covering some city, we ALWAYS use it
           30  +  for(set<LL>::iterator it=mask.begin(); it!=mask.end(); ) {
           31  +   bool isSubset = false;
           32  +   LL   onlyByMe = *it & goal;
           33  +   for(set<LL>::iterator jt=mask.begin(); jt!=mask.end(); ++jt)
           34  +    if( it!=jt ) {
           35  +     onlyByMe &= ~*jt;
           36  +     isSubset |= (*it & *jt & goal) == (*it & goal);
           37  +    }
           38  +
           39  +   update |= isSubset | !!onlyByMe;
           40  +
           41  +   if( isSubset )
           42  +    mask.erase(it++);
           43  +   else if( onlyByMe ) {
           44  +    if( --k < 0 )
           45  +     return false;
           46  +    goal &= ~*it;
           47  +    mask.erase(it++);
           48  +   }
           49  +   else
           50  +    ++it;
           51  +  }
           52  +
           53  +  if( mask.size()<=k || goal==0 )
           54  +   return true;
           55  + }
           56  +
           57  + // exhaustive search
           58  + vector<LL> ms(mask.begin(), mask.end());
           59  + for(LL i=(1LL<<k)-1; i<(1LL<<ms.size()); i=next_combination(i))
           60  + {
           61  +  LL gg = goal;
           62  +  for(LL j=0; (1LL<<j)<=i; ++j)
           63  +   if( i & (1<<j) )
           64  +    gg &= ~ms[j];
           65  +  if( gg == 0 )
           66  +   return true;
           67  + }
           68  + return false;
           69  +}

Added _lib/typical/setCoverEasy.cpp version [d2930c13625ebb92]

            1  +
            2  +//-------------------------------------------------------------
            3  +// (Minimum) Set Cover
            4  +//   NP-complete
            5  +//
            6  +// Assumption: "mask" must be downward closerd,
            7  +//   i.e., X subset Y & Y in mask => X in mask
            8  +//
            9  +// Verified by
           10  +//   - Google Code Jam 09 Round2 C
           11  +//     (The "Only" part never tested, in the test cases of
           12  +//      the problem, that optimization had never used.
           13  +//      Be careful to use that; to be on the safer side,
           14  +//      consider using the <true,false> mode.)
           15  +//-------------------------------------------------------------
           16  +
           17  +int minCover_exhaustive( int goal, const set<int>& mask )
           18  +{
           19  + typedef int STATE;
           20  +
           21  + vector<STATE> Q( 1, 0 );
           22  + set<STATE> visited;
           23  + for(int step=0; step<=mask.size(); ++step)
           24  + {
           25  +  vector<STATE> Q2;
           26  +  for(int i=0; i<Q.size(); ++i)
           27  +  {
           28  +   STATE s = Q[i];
           29  +   if( s == goal )
           30  +    return step;
           31  +   for(set<int>::const_iterator it=mask.begin(); it!=mask.end(); ++it)
           32  +    if( !visited.count( s|*it ) )
           33  +    {
           34  +     visited.insert( s|*it );
           35  +     Q2.push_back( s|*it );
           36  +    }
           37  +  }
           38  +  Q.swap(Q2);
           39  + }
           40  + return -1;
           41  +}
           42  +
           43  +template<bool Subs, bool Only>
           44  +int minCover( int goal, set<int> mask )
           45  +{
           46  + if( Subs )
           47  +  for(set<int>::iterator it=mask.begin(); it!=mask.end(); )
           48  +  {
           49  +   bool needed = true;
           50  +   for(int m=1; m<=goal; m<<=1)
           51  +    if( (goal&m) && !(*it&m) && mask.count(*it|m))
           52  +     {needed = false; break;}
           53  +
           54  +   if( needed )
           55  +    ++it;
           56  +   else
           57  +    mask.erase(it++);
           58  +  }
           59  +
           60  + if( Only )
           61  +  for(set<int>::iterator it=mask.begin(); it!=mask.end(); )
           62  +  {
           63  +   int onlyByMe = goal & *it;
           64  +   for(set<int>::iterator jt=mask.begin(); jt!=mask.end(); ++jt)
           65  +    onlyByMe &= ~*jt;
           66  +
           67  +   if( !onlyByMe )
           68  +    ++it;
           69  +   else
           70  +    mask.erase(it++), goal &= ~onlyByMe;
           71  +  }
           72  +
           73  + return minCover_exhaustive(goal, mask);
           74  +}

Added _lib/typical/ternery.cpp version [c1b48b3999a9f65a]

            1  +// ternery search (for shita-ni-totsu)
            2  +{
            3  + double x = ~min~;
            4  + double w = ~max~;
            5  + for(int i=0; i<~iteration~; ++i) // or, while( w-x > ~eps~ ) be careful for precision!
            6  + {
            7  +  double y = 2*x/3 + w/3;
            8  +  double z = x/3 + 2*w/3;
            9  +  double fx = f(x);
           10  +  double fy = f(y);
           11  +  double fz = f(z);
           12  +  double fw = f(w);
           13  +  if( fx < fy )      w = y;
           14  +  else if( fz > fw ) x = z;
           15  +  else if( fy < fz ) w = z;
           16  +  else               x = y;
           17  + }
           18  +}

Added _lib/typical/unionfind.cpp version [734bdff2cfc3cb9d]

            1  +//-------------------------------------------------------------
            2  +// Union-Find
            3  +//   Balancing + Path-Compression : O(invAckermann)
            4  +//
            5  +// Verified by
            6  +//   - SRM Member Pilot 2 Div1 LV2
            7  +//-------------------------------------------------------------
            8  +
            9  +struct UnionFind
           10  +{
           11  + vector<int> uf, sz;
           12  + int nc;
           13  +
           14  + UnionFind(int N): uf(N), sz(N,1), nc(N)
           15  +  { for(int i=0; i<N; ++i) uf[i] = i; }
           16  + int size()
           17  +  { return nc; }
           18  + int Find(int a)
           19  +  { return uf[a]==a ? a : uf[a]=Find(uf[a]); }
           20  + bool Union(int a, int b)
           21  +  {
           22  +   a = Find(a);
           23  +   b = Find(b);
           24  +   if( a != b )
           25  +   {
           26  +    if( sz[a] >= sz[b] ) swap(a, b);
           27  +    uf[a] = b;
           28  +    sz[b] += sz[a];
           29  +    --nc;
           30  +   }
           31  +   return (a!=b);
           32  +  }
           33  +};