LintCode-132: Word Search II (DFS深搜经典难题!）

置顶 已于 2023-11-01 00:22:26 修改
阅读量305 收藏
点赞数
分类专栏： algorithm-design 文章标签： LintCode
于 2018-07-18 12:46:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/roufoo/article/details/81096215
版权
  1. Word Search II
    中文English
    Given a matrix of lower alphabets and a dictionary. Find all words in the dictionary that can be found in the matrix. A word can start from any position in the matrix and go left/right/up/down to the adjacent position. One character only be used once in one word. No same word in dictionary

Example
Example 1:

Input：[“doaf”,“agai”,“dcan”]，[“dog”,“dad”,“dgdg”,“can”,“again”]
Output：[“again”,“can”,“dad”,“dog”]
Explanation：
d o a f
a g a i
d c a n
search in Matrix，so return [“again”,“can”,“dad”,“dog”].
Example 2:

Input：[“a”]，[“b”]
Output：[]
Explanation：
a
search in Matrix，return [].
Challenge
Using trie to implement your algorithm.

解法1：
这题挺难的。我参考的网上的答案。
思路就是暴力深搜 - 每个格子来一次DFS深搜。
注意：

  1. visited[]数组还是需要
  2. 注意剪枝：如果不是prefix，剪掉！ 如果出界或已经访问过，剪掉！
  3. char -> string 不能直接用std里面的to_string()，因为char本来就是integer，to_string(char)会生成"100","103"这样的字符串。可以用string(1,c)来生成一个临时的内容为c，长度为1的字符串。
  4. 对于二维数组或vector，用if (board.size() < 1) 比if (board.empty()) 更好
  5. getPrefixSets()里面，下面一行
    if (prefixSets.find(prefix) == prefixSets.end())
    很关键！因为有可能某个word刚好是之前某个prefix，这样可以避免该word被关联到false！
class Solution {
public:
    /**
     * @param board: A list of lists of character
     * @param words: A list of string
     * @return: A list of string
     */
    vector<int> dx = {0, 1, -1, 0};
    vector<int> dy = {1, 0, 0, -1};
    map<string, bool> prefixSets; //放所有的prefix，如果是word就对应true，否则对应false
    
    vector<string> wordSearchII(vector<vector<char>> &board, vector<string> &words) {
        vector<string> result;
        
        if (board.size() < 1)  //比if (board.empty()) 更好？
            return result;
        
        vector<vector<bool>> visited;
        for (int i = 0; i < board.size(); ++i) 
            visited.push_back(vector<bool>(board[i].size(), false));

        getPrefixSets(words);

        set<string> wordSet;
        
        for (int i = 0; i < board.size(); ++i) {
            for (int j = 0; j < board[i].size(); ++j) {
                visited[i][j] = true;
                //char->string 不可以用to_string,否则就是 100->"100"
                helper(board, visited, i, j, string(1, board[i][j]), wordSet); //注意string(1,c)
                visited[i][j] = false;
            }
        }
        
        for (auto w : wordSet)
            result.push_back(w);

        return result;
    }
    
private:
    //generate the map
    void getPrefixSets(vector<string> &words) {
        for (auto w : words) {
            for (int i = 0; i < w.size() - 1; ++i) {  //不需要到w.size()，因为整个word下面会处理
                string prefix = w.substr(0, i + 1); //前i + 1个字符
                if (prefixSets.find(prefix) == prefixSets.end()) //关键！有可能某个word刚好是之前某个prefix，这样可以避免该word被关联到false！
                    prefixSets[prefix] = false;
            }
            prefixSets[w] = true;
        }
    }
    
    void helper(vector<vector<char>> &board, vector<vector<bool>> &visited, int x, int y, string word, set<string> &wordSet) {
        if (prefixSets.find(word) == prefixSets.end())  //如果不是prefix, 剪枝
            return;
        
        if (prefixSets[word]) 
            wordSet.insert(word);
    
        for (int i = 0; i < 4; ++i) {
            int adjX = x + dx[i];
            int adjY = y + dy[i];
            
            if (!inside(board, adjX, adjY) || visited[adjX][adjY])  // 出界或已访问，剪枝
                continue;
            
            visited[adjX][adjY] = true;
            helper(board, visited, adjX, adjY, word + board[adjX][adjY], wordSet);
            visited[adjX][adjY] = false;
        }
    }
    
    bool inside(vector<vector<char>> &board, int x, int y) {
        return x >= 0 &&
               x < board.size() &&
               y >= 0 &&
               y < board[0].size();
    }        
};

二刷:

class Solution {
public:
    /**
     * @param board: A list of lists of character
     * @param words: A list of string
     * @return: A list of string
     *          we will sort your return value in output
     */
    vector<string> wordSearchII(vector<vector<char>> &board, vector<string> &words) {
        unordered_set<string> wordSets;
        unordered_set<string> preSets;
        for (auto word : words) {
            string pre = "";
            for (int i = 0; i < word.size(); i++) {
                pre = pre + word[i];
                preSets.insert(pre);
            }
            wordSets.insert(pre);
        }
        unordered_set<string> sols;
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                vector<vector<bool>> visited(board.size(), vector<bool>(board[0].size(), false));
                string sol(1, board[i][j]);
                visited[i][j] = true;
                helper(board, wordSets, preSets, i, j, visited, sol, sols);
                visited[i][j] = false;
                sol.pop_back();
            }
        }
        vector<string> res(sols.begin(), sols.end());
        return res;
    }
private:
    void helper(vector<vector<char>> &board, unordered_set<string> &wordSets, unordered_set<string> &preSets,
                int currX, int currY, vector<vector<bool>> &visited, 
                string sol, unordered_set<string> &sols) {
        if (preSets.find(sol) == preSets.end()) return;                
        if (wordSets.find(sol) != wordSets.end() && sols.find(sol) == sols.end()) {
            sols.insert(sol);
        //    return;  //do not stop! continue to search
        }
        for (int i = 0; i < 4; i++) {
            int newX = currX + dx[i];
            int newY = currY + dy[i];
            if (newX < 0 || newX >= board.size() ||
                newY < 0 || newY >= board[0].size() ||
                visited[newX][newY]) continue;
            //sol = sol + board[newX][newY];
            if (preSets.find(sol) != preSets.end()) {
                visited[newX][newY] = true;
                helper(board, wordSets, preSets, newX, newY, visited, sol + board[newX][newY], sols);
                visited[newX][newY] = false;
                //sol.pop_back();  //important
            } //else {
            //    sol.pop_back();
            //}
        }
        return;
    }
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
};

解法2：trie+dfs

struct Node {
    Node *ch[26];
    string str;
    Node() {
        for (int i = 0; i < 26; i++) {
            ch[i] = nullptr;
        }
        str = "";
    }
};

class Solution {
public:
    /**
     * @param board: A list of lists of character
     * @param words: A list of string
     * @return: A list of string
     *          we will sort your return value in output
     */
    vector<string> wordSearchII(vector<vector<char>> &board, vector<string> &words) {
        Node *trieRoot = new Node();
        
        for (auto word : words) {
            insert(trieRoot, word);
        }

        unordered_set<string> sols;
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                vector<vector<bool>> visited(board.size(), vector<bool>(board[0].size(), false));
                
                if (trieRoot->ch[board[i][j] - 'a'] != nullptr) {
                    visited[i][j] = true;
                    search(board, trieRoot->ch[board[i][j] - 'a'], i, j, visited, sols);
                    visited[i][j] = false;
                }
            }
        }
        vector<string> res(sols.begin(), sols.end());
        return res;
    }
private:
    void insert(Node *p, string s) {
        int len = s.size();
        for (int i = 0; i < len; i++) {
            if (p->ch[s[i] - 'a'] == nullptr) {
                p->ch[s[i] - 'a'] = new Node();
            }
            p = p->ch[s[i] - 'a'];
        }
        p->str = s; //store the string at the last node
       // cout << " insert " << p->str << endl;
    }

    void search(vector<vector<char>> &board, Node *node, int x, int y, vector<vector<bool>> &visited, unordered_set<string> &sols) {
        if (!node->str.empty()) {
            sols.insert(node->str);
            //p->str = "";    //can also clear p->str here so there would be no duplicate 
                              //(i.e., we do not need to use set or unordered_set, vector<string> sols is OK)
        }
        for (int i = 0; i < 4; i++) {
            int newX = x + dx[i];
            int newY = y + dy[i];
            if (newX < 0 || newX >= board.size() || newY < 0 || newY >= board[0].size() || visited[newX][newY]) continue;
            if (node->ch[board[newX][newY] - 'a'] != nullptr) {
                visited[newX][newY] = true;
                search(board, node->ch[board[newX][newY] - 'a'], newX, newY, visited, sols);
                visited[newX][newY] = false;
            }
        }
    }

    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
};

注意：

  1. 排重。否则下面的输入例子会有两个"dad"。
    Explanation：
    d o a f
    a g a i
    d c a n
    排重可用set或unordered_set，然后再将结果传给一个vector返回。也可以在得到一个node->str后，将node->str设为""，这样下一次就不会再得到这个node->str。

二刷:

struct TrieNode {
    bool isWord;
    TrieNode * children[26];
    TrieNode() : isWord(false) {
        for (int i = 0; i < 26; i++) {
            children[i] = NULL;
        }
    }
};

class Solution {
public:
    /**
     * @param board: A list of lists of character
     * @param words: A list of string
     * @return: A list of string
     *          we will sort your return value in output
     */
    vector<string> wordSearchII(vector<vector<char>> &board, vector<string> &words) {
        int nRow = board.size();
        int nCol = board[0].size();
        root = new TrieNode();
        visited.resize(nRow, vector<bool>(nCol, false));
        for (auto word : words) insertWord(word);
        unordered_set<string> res;
        for (int i = 0; i < nRow; i++) {
            for (int j = 0; j < nCol; j++) {
                string str = string(1, board[i][j]);
                if (startWith(str)) {
                    visited[i][j] = true;
                    string str = string(1, board[i][j]);
                    helper(board, words, i, j, str, res, visited);
                    visited[i][j] = false;
                }
            }
        }
        vector<string> ret(res.begin(), res.end());
        return ret;
    }
private:
    TrieNode *root;
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    vector<vector<bool>> visited;
    void helper(vector<vector<char>> &board, vector<string> &words, int x, int y, 
                string str, unordered_set<string> &res, vector<vector<bool>> &visited) {
        if (searchWord(str)) {
            res.insert(str);
        }
        for (int i = 0; i < 4; i++) {
            int newX = x + dx[i];
            int newY = y + dy[i];
            if (newX >= 0 && newX < board.size() && newY >= 0 && newY < board[0].size()
                && !visited[newX][newY]) {
                str += board[newX][newY];
                if (startWith(str)) {
                    visited[newX][newY] = true;
                    helper(board, words, newX, newY, str, res, visited);
                    visited[newX][newY] = false;
                }
                str.pop_back();
            }
        }
    }
    void insertWord(string& word) {
        TrieNode *cur = root;
        int n = word.size();
        for (int i = 0; i < n; i++) {
            if (!cur->children[word[i] - 'a']) cur->children[word[i] - 'a'] = new TrieNode();
            cur = cur->children[word[i] - 'a'];
        }
        cur->isWord = true;
    }
    bool searchWord(string &str) {
        TrieNode *cur = root;
        int n = str.size();
        for (int i = 0; i < n; i++) {
            if (!cur->children[str[i] - 'a']) return false;
            cur = cur->children[str[i] - 'a'];
        }
        if (cur->isWord) return true;
        return false;
    }
    bool startWith(string &str) {
        TrieNode *cur = root;
        int n = str.size();
        for (int i = 0; i < n; i++) {
            if (!cur->children[str[i] - 'a']) return false;
            cur = cur->children[str[i] - 'a'];
        }
        return true;
    }
};
纸上得来终觉浅 绝知此事要躬行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【LeetCode】Word Search II 解题报告
跳出温水的青蛙
05-19 1万+
【题目】 Given a 2D board and a list of words from the dictionary, find all words in the board. Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are
Word Search II
futangxiang4793的博客
08-16 191
Given a 2D board and a list of words from the dictionary, find all words in the board. Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horiz...
leetcode 212. Word Search II(单词搜索 II)
liujunzxcv的专栏
04-08 2336
给出一个2D板和字典中的单词列表，找出所有同时在2D板和字典中出现的单词。 每个单词必须由顺序相邻单元的字母构成，其中“相邻”单元是那些水平或垂直相邻的单元。同一个字母单元在一个单词中可能不会多次使用。 例如， 给出 words = [“oath”,”pea”,”eat”,”rain”] 和 board = [ [‘o’,’a’,’a’,’n’], [‘e’,’t...
深度优先搜索（DFS）优化手册
最新发布
m0_69596371的博客
06-15 817
在通过搜索解决实际问题的过程中，我们是通过穷举每种情况来寻找合法解，然而在一些情况比较复杂的题目、数据量较强的题目中，由于算法的时间复杂度较高、数据规模过大，从而会导致运行超时甚至程序卡死，因此在对复杂问题的答案进行搜索时，我们应该灵活的针对每种题型设计对应的搜索规则并进行优化，通常通过设置剪枝、排除无效情况、对问题进行适当的转化等手法对搜索算法进行优化，使算法高效的执行并得出我们想要的结果。
Wordsearch-Solver-Python:简单的Wordsearch解决Python脚本
05-08
Wordsearch解算器Python 首先，它要求一个包含单词搜索的文本文件。 然后，它将数据导入到数组中。 用户输入他们要查找的单词，然后打印单词搜索并突出显示该单词，因此您可以清楚地看到其位置。 查找单词的算法...
The-Search-in-Pac-Man:使用BFS DFS UCS Astar在吃豆人中搜索
05-14
在search.py的depthFirstSearch函数中实现了深度优先搜索（DFS）算法。 python pacman.py -l tinyMaze -p SearchAgent python pacman.py -l mediumMaze -p SearchAgent python pacman.py -l bigMaze -z ...
formation-vuejs-dfs:支持信息格式DFS IFA de METZ
03-10
"formation-vuejs-dfs" 概念可能指的是一个关于Vue.js的培训课程或者项目，其中涉及到DFS（深度优先搜索，Depth-First Search）和IFA（可能是信息交换格式或某种特定的数据格式）。METZ可能是一个组织、公司或者项目...
DFS-BFS-Implementations:UPenn 类的 DFS 和 BFS 实现
06-24
DFS_BFS UPenn 类的 DFS 和 BFS 实现在这个程序中，我创建了一个名为 AdjacencyStructure 的接口，其中包含添加、减去或更改边的各种方法。 我现在已经实现了一个 AdjacencyMatrix 类（我的主要数据结构），它是一个...
leetcode-DFS-1:DFS-1
06-29
标题 "leetcode-DFS-1:DFS-1" 暗示了这是一个关于使用深度优先搜索（DFS, Depth First Search）解决LeetCode算法题目的教程或项目。DFS是一种用于遍历或搜索树或图的算法，它沿着树的深度进行探索，尽可能深地搜索树...
leetcode:word search +word searchII总结
xiaodidadada的博客
03-15 797
leetcode:word search +word searchII总结①word search：给定一个m x n的矩阵A[  ['A','B','C','E'],  ['S','F','C','S'],  ['A','D','E','E']]，同时给定一个单词，例如word = "ABCCED", 在矩阵中任意连续不重复走动，若可以找到word对应的单词则返回true，否则返回false.主...
Word Search II 解题报告
正在进行时
02-25 581
转载自：http://blog.csdn.net/ljiabin/article/details/45846527   【题目】 Given a 2D board and a list of words from the dictionary, find all words in the board. Each word must be constructed from lett
212. Word Search II
weixin_41704428的博客
04-29 113
Given a 2D board and a list of words from the dictionary, find all words in the board. Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those hori...
[leetcode] 212. Word Search II 解题报告
小榕流光的专栏
03-29 3571
题目链接: https://leetcode.com/problems/word-search-ii/ Given a 2D board and a list of words from the dictionary, find all words in the board. Each word must be constructed from letters of sequent
word search II
poiop221的专栏
09-30 281
Given a 2D board and a list of words from the dictionary, find all words in the board. Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those hor
[leetcode] 212. Word Search II
TstsUgeg的博客
06-02 1419
Given a 2D board and a list of words from the dictionary, find all words in the board. Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those hor
[root@zhaosai hadoop]# start-dfs.sh -bash: start-dfs.sh: 未找到命令 [root@zhaosai hadoop]# start-dfs.sh -bash: start-dfs.sh: 未找到命令
06-11
这个错误提示是因为系统无法找到start-dfs.sh命令。通常情况下，这是因为Hadoop的环境变量没有正确设置。你可以尝试在终端中通过以下命令来设置Hadoop的环境变量： ```export HADOOP_HOME=/path/to/hadoop``` ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值