《Cracking the Coding Interview》——第18章：难题——题目13

2014-04-29 04:40

题目：给定一个字母组成的矩阵，和一个包含一堆单词的词典。请从矩阵中找出一个最大的子矩阵，使得从左到右每一行，从上到下每一列组成的单词都包含在词典中。

解法：O(n^3)级别的时间和空间进行动态规划。这道题目和第17章的最后一题很像，由于这题的时间复杂度实在是高，我动手写了字典树进行加速。如果单纯用哈希表来作为词典，查询效率实际会达到O(n)级别，导致最终的算法复杂度为O(n^4)。用字典树则可以加速到O(n^3)，因为对于一个字符串“abcd”，只需要从字典树的根节点出发往下走，就可以一次性判断“a”、“ab”、“abc”、“abcd”是否包含在字典里，而用哈希表无法做到这样的效率。动态规划过程仍然是O(n^4)级别，字典树只是将查单词的过程中进行了加速，从O(n^4)加速到了O(n^3)。空间复杂度为O(n^3)，用于标记横向和纵向的每一个子段是否包含在字典里。

代码：

 // 18.13 There is a matrix of lower case letters. Given a dictionary of words, you have to find the maximum subrectangle, such that every row reading from left to right, and every column reading from top to bottom is a word in the dictionary. Return the area as the result.
 #include <iostream>
 #include <string>
 #include <unordered_set>
 #include <vector>
 using namespace std;

 const int MAX_NODE = ;

 struct TrieNode {
     bool is_word;
     char ch;
     vector<int> child;
     TrieNode(char _ch = ): is_word(false), ch(_ch), child(vector<int>(, -)) {};
 };
 int node_count;
 TrieNode nodes[MAX_NODE];

 void insertWordIntoTrie(int root, const string &s)
 {
     int len = s.length();

     for (int i = ; i < len; ++i) {
         if (nodes[root].child[s[i] - 'a'] < ) {
             nodes[root].child[s[i] - 'a'] = node_count++;
             root = nodes[root].child[s[i] - 'a'];
             nodes[root].ch = s[i];
         } else {
             root = nodes[root].child[s[i] - 'a'];
         }
         if (i == len - ) {
             nodes[root].is_word = true;
         }
     }
 }

 int constructTrie(const unordered_set<string> &dict)
 {
     int root = node_count++;

     unordered_set<string>::const_iterator usit;
     for (usit = dict.begin(); usit != dict.end(); ++usit) {
         insertWordIntoTrie(root, *usit);
     }

     return root;
 }

 int main()
 {
     int i, j, k;
     int i1, i2;
     string s;
     int n, m;
     vector<vector<char> > matrix;
     vector<vector<vector<bool> > > is_row_word;
     vector<vector<vector<bool> > > is_col_word;
     vector<int> dp;
     unordered_set<string> dict;
     int root;
     int ptr;
     int max_area;

     while (cin >> n && n > ) {
         node_count = ;
         for (i = ; i < n; ++i) {
             cin >> s;
             dict.insert(s);
         }
         root = constructTrie(dict);

         cin >> n >> m;

         matrix.resize(n);
         for (i = ; i < n; ++i) {
             matrix[i].resize(m);
         }
         for (i = ; i < n; ++i) {
             cin >> s;
             for (j = ; j < m; ++j) {
                 matrix[i][j] = s[j];
             }
         }

         is_row_word.resize(n);
         for (i = ; i < n; ++i) {
             is_row_word[i].resize(m);
             for (j = ; j < m; ++j) {
                 is_row_word[i][j].resize(m);
             }
         }

         is_col_word.resize(m);
         for (i = ; i < m; ++i) {
             is_col_word[i].resize(n);
             for (j = ; j < n; ++j) {
                 is_col_word[i][j].resize(n);
             }
         }

         for (i = ; i < n; ++i) {
             for (j = ; j < m; ++j) {
                 ptr = root;
                 for (k = j; k < m; ++k) {
                     if (ptr < ) {
                         is_row_word[i][j][k] = false;
                         continue;
                     }

                     ptr = nodes[ptr].child[matrix[i][k] - 'a'];
                     if (ptr < ) {
                         is_row_word[i][j][k] = false;
                         continue;
                     }

                     is_row_word[i][j][k] = nodes[ptr].is_word;
                 }
             }
         }

         for (i = ; i < m; ++i) {
             for (j = ; j < n; ++j) {
                 ptr = root;
                 for (k = j; k < n; ++k) {
                     if (ptr < ) {
                         is_col_word[i][j][k] = false;
                         continue;
                     }

                     ptr = nodes[ptr].child[matrix[k][i] - 'a'];
                     if (ptr < ) {
                         is_col_word[i][j][k] = false;
                         continue;
                     }

                     is_col_word[i][j][k] = nodes[ptr].is_word;
                 }
             }
         }

         max_area = ;
         dp.resize(m);
         for (i1 = ; i1 < n; ++i1) {
             for (i2 = i1; i2 < n; ++i2) {
                 k = ;
                 for (j = ; j < m; ++j) {
                     dp[j] = is_col_word[j][i1][i2] ? (++k) : (k = );
                     if (!dp[j]) {
                         continue;
                     }

                     for (i = i1; i <= i2; ++i) {
                         if (!is_row_word[i][j - dp[j] + ][j]) {
                             break;
                         }
                     }
                     if (i > i2) {
                         max_area = max(max_area, (i2 - i1 + ) * dp[j]);
                     }
                 }
             }
         }

         cout << max_area << endl;

         // clear up data
         dict.clear();
         for (i = ; i < n; ++i) {
             matrix[i].clear();
         }
         matrix.clear();

         for (i = ; i < n; ++i) {
             for (j = ; j < m; ++j) {
                 is_row_word[i][j].clear();
             }
             is_row_word[i].clear();
         }
         is_row_word.clear();

         for (i = ; i < m; ++i) {
             for (j = ; j < n; ++j) {
                 is_col_word[i][j].clear();
             }
             is_col_word[i].clear();
         }
         is_col_word.clear();
     }

     return ;
 }