SRM 513 2 1000CutTheNumbers（状态压缩）

SRM 513 2 1000CutTheNumbers

---

Problem Statement

Manao has a board filled with digits represented as String[] board. The j-th character of the i-th element of board represents the digit written in cell in row i, column j of the board. The rows are numbered from top to bottom and the columns are numbered from left to right.

Manao is going to cut it into several non-overlapping fragments. Each of the fragments will be a horizontal or vertical strip containing 1 or more elements. A strip of length N can be interpreted as an N-digit number in base 10 by concatenating the digits on the strip in order. The horizontal strips are read from left to right and the vertical strips are read from top to bottom. The picture below shows a possible cutting of a 4x4 board: 

The sum of the numbers on the fragments in this picture is 493 + 7160 + 23 + 58 + 9 + 45 + 91 = 7879.

Manao wants to cut the board in such a way that the sum of the numbers on the resulting fragments is the maximum possible. Compute and return this sum.

Definition

• ClassCutTheNumbers
• MethodmaximumSum
• Parametersvector<string>
• Returnsint
• Method signatureint maximumSum(vector<string> board)

(be sure your method is public)

Limits

• Time limit (s)2.000
• Memory limit (MB)64

Notes

• The numbers on the cut strips are allowed to have leading zeros. See example #2 for details.

Constraints

• board will contain between 1 and 4 elements, inclusive.
• board[0] will be between 1 and 4 characters long, inclusive.
• Each element of board will be of the same length as board[0].
• Each character in board will be a decimal digit ('0'-'9').

Test cases

1.  

   • board{"123",
      "312"}

    

   Returns435

    

   Manao can cut out both rows in whole, obtaining 123 + 312 = 435. He also could cut the columns one by one for a total of 66, or cut the first column and the residual rows one by one, obtaining 13 + 23 + 12 = 48, or even cut out single elements, but would not get a better sum.
2.  

   • board{"99",
      "11"}

    

   Returns182

    

   It's better to cut out the whole columns.
3.  

   • board{"001",
      "010",
      "111",
      "100"}

    

   Returns1131

    

   The numbers on the strips may have leading zeros. Cutting the columns in whole, Manao obtains 0011 + 0110 + 1010 = 1131.
4.  

   • board{ "8" }

    

   Returns8

---

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.

你可以认为０的话，就是向左连，１的话就是向下连。

然后状态压缩一下。枚举所有的状态即可。

 #include <cstdio>
 #include <cmath>
 #include <cstring>
 #include <ctime>
 #include <iostream>
 #include <algorithm>
 #include <set>
 #include <vector>
 #include <sstream>
 #include <typeinfo>
 #include <fstream>
 
 using namespace std;
 const int inf = 0x3f3f3f3f ;
 int n , m ;
 int maxn ;
 int path[] ;
 vector<int> b[] ;
 class CutTheNumbers {
     public:
     int maximumSum(vector<string> board) {
         n = board.size () ;
         m = board[].size () ;
         for (int i =  ; i < n ; i ++) b[i].clear () ;
         for (int i =  ; i < n ; i ++) {
             for (int j =  ; j < m ; j ++) {
                 b[i].push_back( board[i][j] - '' );
             }
         }
         maxn = - inf ;
         dfs () ;
         return maxn ;
     }
 
     void dfs (int dep) {
         if (dep == n) {
             solve () ;
             return ;
         }
         for (int i =  ; i < ( << m) ; i ++) {
            path[dep] = i ;
            dfs (dep + ) ;
         }
     }
 
     void solve () {
         bool map[][] ;
         int ans =  ;
         memset (map ,  , sizeof(map) ) ;
 
         for (int i =  ; i < n ; i ++) {
             int j =  ;
             int tmp = path[i] ;
             while (tmp) {
                 map[i][j ++] = tmp &  ;
                tmp>>=  ;
             }
             reverse (map[i] , map[i] + m) ;
         }
 
         bool mark[][] ;
         memset (mark ,  , sizeof(mark) ) ;
 
         for (int i =  ; i < n ; i ++) {
             for (int j =  ; j < m ; j ++) {
                 if (!mark[i][j]) {
                     int tmp =  ;
                     if (!map[i][j]) {
                         for (int k = j ; k < m && !map[i][k] ; k ++) {
                             mark[i][k] =  ;
                             tmp = tmp *  + b[i][k] ;
                         }
                     }
                     else {
                         for (int k = i ; k < n && map[k][j] ; k ++) {
                             mark[k][j] =  ;
                             tmp = tmp *  + b[k][j] ;
                         }
                     }
                     ans += tmp ;
                 }
             }
         }
         maxn = max (maxn , ans) ;
     }
 
 };
 
 // CUT begin
 ifstream data("CutTheNumbers.sample");
 
 string next_line() {
     string s;
     getline(data, s);
     return s;
 }
 
 template <typename T> void from_stream(T &t) {
     stringstream ss(next_line());
     ss >> t;
 }
 
 void from_stream(string &s) {
     s = next_line();
 }
 
 template <typename T> void from_stream(vector<T> &ts) {
     int len;
     from_stream(len);
     ts.clear();
     for (int i = ; i < len; ++i) {
         T t;
         from_stream(t);
         ts.push_back(t);
     }
 }
 
 template <typename T>
 string to_string(T t) {
     stringstream s;
     s << t;
     return s.str();
 }
 
 string to_string(string t) {
     return "\"" + t + "\"";
 }
 
 bool do_test(vector<string> board, int __expected) {
     time_t startClock = clock();
     CutTheNumbers *instance = new CutTheNumbers();
     int __result = instance->maximumSum(board);
     double elapsed = (double)(clock() - startClock) / CLOCKS_PER_SEC;
     delete instance;
 
     if (__result == __expected) {
         cout << "PASSED!" << " (" << elapsed << " seconds)" << endl;
         return true;
     }
     else {
         cout << "FAILED!" << " (" << elapsed << " seconds)" << endl;
         cout << "           Expected: " << to_string(__expected) << endl;
         cout << "           Received: " << to_string(__result) << endl;
         return false;
     }
 }
 
 int run_test(bool mainProcess, const set<int> &case_set, const string command) {
     int cases = , passed = ;
     while (true) {
         if (next_line().find("--") != )
             break;
         vector<string> board;
         from_stream(board);
         next_line();
         int __answer;
         from_stream(__answer);
 
         cases++;
         if (case_set.size() >  && case_set.find(cases - ) == case_set.end())
             continue;
 
         cout << "  Testcase #" << cases -  << " ... ";
         if ( do_test(board, __answer)) {
             passed++;
         }
     }
     if (mainProcess) {
         cout << endl << "Passed : " << passed << "/" << cases << " cases" << endl;
         int T = time(NULL) - ;
         double PT = T / 60.0, TT = 75.0;
         cout << "Time   : " << T /  << " minutes " << T %  << " secs" << endl;
         cout << "Score  : " <<  * (0.3 + (0.7 * TT * TT) / (10.0 * PT * PT + TT * TT)) << " points" << endl;
     }
     return ;
 }
 
 int main(int argc, char *argv[]) {
     cout.setf(ios::fixed, ios::floatfield);
     cout.precision();
     set<int> cases;
     bool mainProcess = true;
     for (int i = ; i < argc; ++i) {
         if ( string(argv[i]) == "-") {
             mainProcess = false;
         } else {
             cases.insert(atoi(argv[i]));
         }
     }
     if (mainProcess) {
         cout << "CutTheNumbers (1000 Points)" << endl << endl;
     }
     return run_test(mainProcess, cases, argv[]);
 }
 // CUT end