leetcode word_search

最新推荐文章于 2021-10-01 20:24:09 发布
最新推荐文章于 2021-10-01 20:24:09 发布
阅读量115 收藏
点赞数
分类专栏： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pynash123/article/details/84589020
版权

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 neighboring. The same letter cell may not be used more than once.
For example,
Given board =
[
[“ABCE”],
[“SFCS”],
[“ADEE”]
]
word =“ABCCED”, -> returnstrue,
word =“SEE”, -> returnstrue,
word =“ABCB”, -> returnsfalse.

回朔

class Solution {
public:
    bool exist(vector<vector<char> > &board, string word) 
    {
        vector<vector<bool> > flag(board.size(), vector<bool> (board[0].size(), false));
        for (int i=0;i<board.size();i++)
        {
            for(int j=0;j<board[i].size();j++)
            {
                if (board[i][j] == word[0])
                {
                    flag[i][j] = true;
                    if (find(board, flag, word.substr(1), i, j))
                        return true;
                    flag[i][j] = false;
                }
            }
        }
        return false;
    }
    
    bool find(vector<vector<char> > &board, vector<vector<bool> > &flag, string word, int lastx, int lasty)
    {
        if (word.size() == 0)
            return true;
        bool ret = false;
        if(lastx > 0 && board[lastx-1][lasty] == word[0]&&!flag[lastx-1][lasty])
        {
            flag[lastx-1][lasty] = true;
            if(find(board,flag, word.substr(1), lastx-1,lasty))
                return true;
            flag[lastx-1][lasty] = false;//就算flag不是引用  这里也要回复，不然会对下面有影响
        }
        if(lastx < board.size()-1 && board[lastx+1][lasty] == word[0]&&!flag[lastx+1][lasty])
        {
            flag[lastx+1][lasty] = true;
            if (find(board,flag, word.substr(1), lastx+1,lasty))
                return true;
            flag[lastx+1][lasty] = false;
        }
        if(lasty > 0 && board[lastx][lasty-1] == word[0]&&!flag[lastx][lasty-1])
        {
            flag[lastx][lasty-1] = true;
            if (find(board,flag, word.substr(1), lastx,lasty-1))
                return true;
            flag[lastx][lasty-1] = false;
        }
        if(lasty < board[0].size()-1 && board[lastx][lasty+1] == word[0]&&!flag[lastx][lasty+1])
        {
            flag[lastx][lasty+1] = true;
            if (find(board,flag, word.substr(1), lastx,lasty+1))
                return true;
            flag[lastx][lasty+1] = false;
        }
        return false;
    }
};

//word改成引用  节省空间
class Solution {
public:
    bool exist(vector<vector<char> > &board, string word) 
    {
        vector<vector<bool> > flag(board.size(), vector<bool> (board[0].size(), false));
        for (int i=0;i<board.size();i++)
        {
            for(int j=0;j<board[i].size();j++)
            {
                if (board[i][j] == word[0])
                {
                    flag[i][j] = true;
                    if (find(board, flag, word, i, j, 1))
                        return true;
                    flag[i][j] = false;
                }
            }
        }
        return false;
    }
    
    bool find(vector<vector<char> > &board, vector<vector<bool> > &flag, string &word, int lastx, int lasty, int sequence)
    {
        if (word.size() == sequence)
            return true;
        bool ret = false;
        if(lastx > 0 && board[lastx-1][lasty] == word[sequence]&&!flag[lastx-1][lasty])
        {
            flag[lastx-1][lasty] = true;
            if(find(board,flag, word, lastx-1,lasty,sequence+1 ))
                return true;
            flag[lastx-1][lasty] = false;//就算flag不是引用  这里也要恢复，不然会对下面有影响
        }
        if(lastx < board.size()-1 && board[lastx+1][lasty] == word[sequence]&&!flag[lastx+1][lasty])
        {
            flag[lastx+1][lasty] = true;
            if (find(board,flag, word, lastx+1,lasty,sequence+1))
                return true;
            flag[lastx+1][lasty] = false;
        }
        if(lasty > 0 && board[lastx][lasty-1] == word[sequence]&&!flag[lastx][lasty-1])
        {
            flag[lastx][lasty-1] = true;
            if (find(board,flag, word, lastx,lasty-1,sequence+1))
                return true;
            flag[lastx][lasty-1] = false;
        }
        if(lasty < board[0].size()-1 && board[lastx][lasty+1] == word[sequence]&&!flag[lastx][lasty+1])
        {
            flag[lastx][lasty+1] = true;
            if (find(board,flag, word, lastx,lasty+1,sequence+1))
                return true;
            flag[lastx][lasty+1] = false;
        }
        return false;
    }
};

//宏简化
#define fun(x,y) do \
{\
    flag[x][y] = true;\
    if(find(board,flag, word, x, y,sequence+1))\
        return true;\
    flag[x][y] = false;\
}while(0)

class Solution {
public:
    bool exist(vector<vector<char> > &board, string word) 
    {
        vector<vector<bool> > flag(board.size(), vector<bool> (board[0].size(), false));
        for (int i=0;i<board.size();i++)
        {
            for(int j=0;j<board[i].size();j++)
            {
                if (board[i][j] == word[0])
                {
                    flag[i][j] = true;
                    if (find(board, flag, word, i, j, 1))
                        return true;
                    flag[i][j] = false;
                }
            }
        }
        return false;
    }
    
    bool find(vector<vector<char> > &board, vector<vector<bool> > &flag, string &word, int lastx, int lasty, int sequence)
    {
        if (word.size() == sequence)
            return true;
        bool ret = false;
        if(lastx > 0 && board[lastx-1][lasty] == word[sequence]&&!flag[lastx-1][lasty])
            fun(lastx-1, lasty);
        if(lastx < board.size()-1 && board[lastx+1][lasty] == word[sequence]&&!flag[lastx+1][lasty])
           fun(lastx+1, lasty);
        if(lasty > 0 && board[lastx][lasty-1] == word[sequence]&&!flag[lastx][lasty-1])
            fun(lastx, lasty-1);
        if(lasty < board[0].size()-1 && board[lastx][lasty+1] == word[sequence]&&!flag[lastx][lasty+1])
            fun(lastx, lasty+1);
        return false;
    }
};

测试

#include<iostream>
#include<string>
#include<vector>
using namespace std;
#define fun(x,y) do \
{\
    flag[x][y] = true;\
    if(find(board,flag, word, x, y,sequence+1))\
        return true;\
    flag[x][y] = false;\
}while(0)
    


class Solution {
public:
    bool exist(vector<vector<char> > &board, string word) 
    {
        vector<vector<bool> > flag(board.size(), vector<bool> (board[0].size(), false));
        for (int i=0;i<board.size();i++)
        {
            for(int j=0;j<board[i].size();j++)
            {
                if (board[i][j] == word[0])
                {
                    flag[i][j] = true;
                    if (find(board, flag, word.substr(1), i, j))
                        return true;
                    flag[i][j] = false;
                }
            }
        }
        return false;
    }
    
    bool find(vector<vector<char> > &board, vector<vector<bool> > &flag, string word, int lastx, int lasty)
    {
        if (word.size() == 0)
            return true;
        //cout<<word<<" "<<lastx<<" "<<lasty<<" "<<endl;
        if(lastx > 0 && board[lastx-1][lasty] == word[0]&&!flag[lastx-1][lasty])
        {
            flag[lastx-1][lasty] = true;
            if(find(board,flag, word.substr(1), lastx-1,lasty))
                return true;
            flag[lastx-1][lasty] = false;
        }
        if(lastx < board.size()-1 && board[lastx+1][lasty] == word[0]&&!flag[lastx+1][lasty])
        {
            flag[lastx+1][lasty] = true;
            if (find(board,flag, word.substr(1), lastx+1,lasty))
                return true;
            flag[lastx+1][lasty] = false;
        }
        if(lasty > 0 && board[lastx][lasty-1] == word[0]&&!flag[lastx][lasty-1])
        {
            flag[lastx][lasty-1] = true;
            if (find(board,flag, word.substr(1), lastx,lasty-1))
                return true;
            flag[lastx][lasty-1] = false;
        }
        if(lasty < board[0].size()-1 && board[lastx][lasty+1] == word[0]&&!flag[lastx][lasty+1])
        {
            flag[lastx][lasty+1] = true;
            if (find(board,flag, word.substr(1), lastx,lasty+1))
                return true;
            flag[lastx][lasty+1] = false;
        }
        return false;
    }
};

class Solution1 {
public:
    bool exist(vector<vector<char> > &board, string word) 
    {
        vector<vector<bool> > flag(board.size(), vector<bool> (board[0].size(), false));
        for (int i=0;i<board.size();i++)
        {
            for(int j=0;j<board[i].size();j++)
            {
                if (board[i][j] == word[0])
                {
                    flag[i][j] = true;
                    if (find(board, flag, word, i, j, 1))
                        return true;
                    flag[i][j] = false;
                }
            }
        }
        return false;
    }
    
    bool find(vector<vector<char> > &board, vector<vector<bool> > &flag, string &word, int lastx, int lasty, int sequence)
    {
        if (word.size() == sequence)
            return true;
        bool ret = false;
        if(lastx > 0 && board[lastx-1][lasty] == word[sequence]&&!flag[lastx-1][lasty])
            fun(lastx-1, lasty);
        if(lastx < board.size()-1 && board[lastx+1][lasty] == word[sequence]&&!flag[lastx+1][lasty])
           fun(lastx+1, lasty);
        if(lasty > 0 && board[lastx][lasty-1] == word[sequence]&&!flag[lastx][lasty-1])
            fun(lastx, lasty-1);
        if(lasty < board[0].size()-1 && board[lastx][lasty+1] == word[sequence]&&!flag[lastx][lasty+1])
            fun(lastx, lasty+1);
        return false;
    }
};
/*
Given board =
[
  ["ABCE"],
  ["SFCS"],
  ["ADEE"]
]
word ="ABCCED", -> returnstrue,
word ="SEE", -> returnstrue,
word ="ABCB", -> returnsfalse.
*/
int main()
{
    vector<vector<char> >  board;
    char a1[] = {'A', 'B', 'C', 'E'};
    vector<char> vec1(a1,a1+4);
    board.push_back(vec1);
    char a2[] = {'S', 'F', 'E', 'S'};
    vector<char> vec2(a2,a2+4);
    board.push_back(vec2);
    char a3[] = {'A', 'D', 'E', 'E'};
    vector<char> vec3(a3,a3+4);
    board.push_back(vec3);
    for (int i=0;i<board.size();i++)
    {
        for(int j=0;j<board[i].size();j++)
        {
            cout<<board[i][j]<<" ";
        }
        cout<<endl;
    }
    
    Solution1 s;
    
    if (s.exist(board, "ABCESEEEFS"))
        cout<<"true"<<endl;
    else
        cout<<"false"<<endl;
    
    if (s.exist(board, "SEE"))
        cout<<"true"<<endl;
    else
        cout<<"false"<<endl;
    
    if (s.exist(board, "ABCB"))
        cout<<"true"<<endl;
    else
        cout<<"false"<<endl;
    
}
pynash123
关注
专栏目录
leetcode苹果-LeetCode_No.208_-:LeetCode_No.208_-
06-30
leetcode 苹果 LeetCode_No.208_-实现 Trie (前缀树) 题目介绍 Trie（发音类似 "try"）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完...
leetcode之word-ladder
此心光明，亦复何言~
05-21 424
leetcode之word-ladder 题目 Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that: Only one letter can be changed at a time Ea...
leetcode-word-break
yinger_0131的博客
04-28 283
题目描述 给定一个字符串s和一个词典词典dict，确定s是否可以分割成一个或多个词典单词的空格分隔序列。 例如，给定 s =“leetcode”， dict = [“leet”，“code”]。 因为“leetcode”可以分段为“leet code”，所以返回true。 一道动态规划题 int len = s.length(); vector&lt;bool&g...
leetcode算法题--Word Search
bob的博客
10-01 196
原题链接：https://leetcode.com/problems/word-search/ class Solution { public: int n, m; vector<vector<char>> board; vector<vector<int>> visited; string word; bool exist(vector<vector<char>>& _board, st
图解LeetCode：Word Ladder
码农的荒岛求生
12-06 496
文章目录思考过程建立索引代码实现总结 这是LeetCode的第127号题目Word Ladder，也就是单词梯子，那这个题目是什么意思呢？ 给定两个单词，一个为开头单词beginWord，一个为结尾单词endWord，并且给定一个单词列表，找出从开头单词到结尾单词的最短转换路径，转换规则是这样的： 一次只能转换单词中的一个字符 每次转换后的单词必须存在于单词列表中 比如给定开头单词“hit”，...
LeetCode-Word Pattern
坟头草一米七五
07-04 205
LeetCode Word Pattern Java
圆和矩形是否重叠leetcode-leetcode_solutions:leetcode_solutions
06-30
圆和椭圆重叠leetcode ——#158 尖端 关心特殊情况 从不同的方向思考 简单的 大批 1.Two Sum -> 使用哈希表避免遍历列表448.查找数组中消失的所有数字-> 1.建立缓冲区来计算数字| 2.使用数组作为带符号的缓冲区118....
python-leetcode题解之079-Word-Search
08-28
python python_leetcode题解之079_Word_Search
c语言-leetcode题解之0079-word-search.zip
09-13
c c语言_leetcode题解之0079_word_search.zip
js-leetcode题解之79-word-search.js
最新发布
10-27
javascript js_leetcode题解之79-word-search.js
leetcode:word-search
chenglan9265的博客
07-08 104
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 "ad...
【LeetCode】word-break-ii
Puya的博客
04-14 347
时间限制：1秒空间限制：32768K热度指数：35240 本题知识点：动态规划leetcode 算法知识视频讲解 题目描述 Given a stringsand a dictionary of wordsdict, add spaces insto construct a sentence where each word is a valid dictionary...
LeetCode79:Word Search
07-02 1981
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 neig
分支算法的时间复杂度
pynash123的博客
12-16 2679
记录一下 表示将原问题分解成 a 个 规模大小为 N/b 的子问题，合并这 a 个子问题的代价是 Θ(N^K) （N^k 表示 N 的 k 次方） T(N)=aT(N/b)+Θ(N^K) T(N)的解有以下三种情况： T(N)=O(N(logab)) 当 a > bk 时 T(N)=O(Nk log^N) 当 a = bk 时 T(N)=O(Nk) 当 a &l...
scikit-learning 多项式回归应用房价预测
pynash123的博客
04-14 1074
将sklearn.datasets中的load_boston房价数据用多项式回归进行训练，并画出学习曲线 import matplotlib.pyplot as plt import numpy as np from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split fr...
leetcode:链表中环的入口结点
pynash123的博客
08-16 702
题目： //给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } }; */ 思路: 快慢指针，快指针每次前进两个长度，慢指针每次前进一个长度，若存在环，则一定会在环内相遇。 假设起点到环入...
构建二叉树
pynash123的博客
04-07 528
//输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 /** * Definition for binary tree * struct TreeNode { * int val; * T...
leetcode surrounded-regions
pynash123的博客
04-07 476
Given a 2D board containing’X’and’O’, capture all regions surrounded by’X’. A region is captured by flipping all’O’s into’X’s in that surrounded region . For example, X X X X X O O X X X O X X O X X A...
scikit-learning k临近算法学习之k-d tree
pynash123的博客
04-11 437
k-d tree即k-dimensionaltree，常用来作空间划分及近邻搜索，是二叉空间划分树的一个特例。通常，对于维度为k，数据点数为N的数据集，k-d tree适用于N>>2^k的情形,kd树是基于欧式距离度量的。 k-d树是每个节点都为k维点的二叉树。所有非叶子节点可以视作用一个超平面把空间分区成两个半空间。节点左边的子树代表在超平面左边的点，节点右边的子树代表在超平面右边的...
C语言实现LeetCode 0079题Word Search解法
资源摘要信息:"c语言-leetcode题解之0079-word-search.zip" 知识点概述： 本压缩包文件聚焦于C语言在解决LeetCode在线编程题目中的应用，特别是与"0079-word-search"这一特定问题相关的题解。LeetCode是一个广受...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值