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
    评论
专栏目录
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 ...
leetcode 212. Word Search II(单词搜索 II)
liujunzxcv的专栏
04-08 2340
给出一个2D板和字典中的单词列表，找出所有同时在2D板和字典中出现的单词。 每个单词必须由顺序相邻单元的字母构成，其中“相邻”单元是那些水平或垂直相邻的单元。同一个字母单元在一个单词中可能不会多次使用。 例如， 给出 words = [“oath”,”pea”,”eat”,”rain”] 和 board = [ [‘o’,’a’,’a’,’n’], [‘e’,’t...
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...
212、Word Search II (Hard)
wengeyiming的博客
08-20 387
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
212. Word Search II（单词搜索II）
God_Mood的博客
07-02 162
题目链接：https://leetcode.com/problems/word-search-ii/ 给定一个二维网格 board 和一个字典中的单词列表 words，找出所有同时在二维网格和字典中出现的单词。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。 示例: 输入: wo...
LeetCode 212. Word Search II（单词搜索）
James Pan
05-05 2234
原题网址：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 sequenti
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是一种用于遍历或搜索树或图的算法，它沿着树的深度进行探索，尽可能深地搜索树...
Word Search II 解题报告
正在进行时
02-25 583
转载自：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
[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
#212 Word Search II
YY_Tina的博客
04-23 215
Description Given an m x n board of characters and a list of strings words, return all words on the board. Each word must be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same
深搜的剪枝优化技巧
被一个OIER遗弃的一堆烂代码
11-28 452
【概述】 搜索算法的时间复杂度大多是指数级的，难以满足对程序运行时间的限制要求，为使降低时间复杂度，对深度优先搜索可以进行一种优化的基本方法——剪枝。 搜索的进程可以看做是从树根出发，遍历一颗倒置树（搜索树）的过程，所谓剪枝，就是通过某些判断，避免一些不必要的遍历过程，形象的说，就是减去搜索树中的某些枝条。 显而易见，应用剪枝优化的核心问题是设计剪枝判断方法，即确定哪些枝条舍弃哪些枝条保留，设计出好的剪枝判断方法，可以使得程序运行时间大大缩短，否则会适得其反。 剪枝的原则：正确、准确、高效 【优化技巧】
LintCode 132. Word Search II -- Trie
Choly_chen的博客
05-17 255
Description 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...
LintCode 132-单词搜索II 深度优先
Jason__Liang的博客
02-22 502
本人电子系，只为一学生。心喜计算机，小编以怡情。给出一个由小写字母组成的矩阵和一个字典。找出所有同时在字典和矩阵中出现的单词。一个单词可以从矩阵中的任意位置开始，可以向左/右/上/下四个相邻方向移动。样例 给出矩阵： doaf agai dcan 和字典： {“dog”, “dad”, “dgdg”, “can”, “again”}返回 {“dog”, “dad”, “can”, “ag
DFS深搜经典算法
有朋自远方来，不亦乐乎。
12-01 572
输入样例： 5 4 1 1 2 1 1 1 1 1 1 1 2 1 1 2 1 1 1 1 1 2 1 1 4 3 输出： 7 代码： #include<iostream> using namespace std; int Endx, Endy; int Min = 1000; int map[100][100];//1是空地0是墙 int v[100][100];//访问数组0未访问7访问 void DFS(int x, int y, int step)//x，y表示当前
word-search
llwjason5555的博客
09-22 185
题目：Given a 2D board and a word, find if the word exists in the grid. The word can be constructed from letters of sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically
[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``` ```export PATH=$PATH:$HADOOP_HOME/bin``` 其中/path/to/hadoop是你的Hadoop安装路径。完成设置后，你可以再次尝试运行start-dfs.sh命令来启动Hadoop分布式文件系统。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值