《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 = 10000;

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

void insertWordIntoTrie(int root, const string &s)
{
    int len = s.length();
    
    for (int i = 0; i < len; ++i) {
        if (nodes[root].child[s[i] - 'a'] < 0) {
            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 - 1) {
            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 > 0) {
        node_count = 0;
        for (i = 0; i < n; ++i) {
            cin >> s;
            dict.insert(s);
        }
        root = constructTrie(dict);
        
        cin >> n >> m;
        
        matrix.resize(n);
        for (i = 0; i < n; ++i) {
            matrix[i].resize(m);
        }
        for (i = 0; i < n; ++i) {
            cin >> s;
            for (j = 0; j < m; ++j) {
                matrix[i][j] = s[j];
            }
        }
        
        is_row_word.resize(n);
        for (i = 0; i < n; ++i) {
            is_row_word[i].resize(m);
            for (j = 0; j < m; ++j) {
                is_row_word[i][j].resize(m);
            }
        }

        is_col_word.resize(m);
        for (i = 0; i < m; ++i) {
            is_col_word[i].resize(n);
            for (j = 0; j < n; ++j) {
                is_col_word[i][j].resize(n);
            }
        }
        
        for (i = 0; i < n; ++i) {
            for (j = 0; j < m; ++j) {
                ptr = root;
                for (k = j; k < m; ++k) {
                    if (ptr < 0) {
                        is_row_word[i][j][k] = false;
                        continue;
                    }
                    
                    ptr = nodes[ptr].child[matrix[i][k] - 'a'];
                    if (ptr < 0) {
                        is_row_word[i][j][k] = false;
                        continue;
                    }
                    
                    is_row_word[i][j][k] = nodes[ptr].is_word;
                }
            }
        }
        
        for (i = 0; i < m; ++i) {
            for (j = 0; j < n; ++j) {
                ptr = root;
                for (k = j; k < n; ++k) {
                    if (ptr < 0) {
                        is_col_word[i][j][k] = false;
                        continue;
                    }
                    
                    ptr = nodes[ptr].child[matrix[k][i] - 'a'];
                    if (ptr < 0) {
                        is_col_word[i][j][k] = false;
                        continue;
                    }
                    
                    is_col_word[i][j][k] = nodes[ptr].is_word;
                }
            }
        }
        
        max_area = 0;
        dp.resize(m);
        for (i1 = 0; i1 < n; ++i1) {
            for (i2 = i1; i2 < n; ++i2) {
                k = 0;
                for (j = 0; j < m; ++j) {
                    dp[j] = is_col_word[j][i1][i2] ? (++k) : (k = 0);
                    if (!dp[j]) {
                        continue;
                    }
                    
                    for (i = i1; i <= i2; ++i) {
                        if (!is_row_word[i][j - dp[j] + 1][j]) {
                            break;
                        }
                    }
                    if (i > i2) {
                        max_area = max(max_area, (i2 - i1 + 1) * dp[j]);
                    }
                }
            }
        }
        
        cout << max_area << endl;
        
        // clear up data
        dict.clear();
        for (i = 0; i < n; ++i) {
            matrix[i].clear();
        }
        matrix.clear();
        
        for (i = 0; i < n; ++i) {
            for (j = 0; j < m; ++j) {
                is_row_word[i][j].clear();
            }
            is_row_word[i].clear();
        }
        is_row_word.clear();
        
        for (i = 0; i < m; ++i) {
            for (j = 0; j < n; ++j) {
                is_col_word[i][j].clear();
            }
            is_col_word[i].clear();
        }
        is_col_word.clear();
    }
    
    return 0;
}