leetcode第一刷_Word Search

这道题之前一直没敢做,没想到前天用递归一遍过了。。

当时为什么想着用递归,而不是dp呢,因为我想到达某个位置的情况有很多,即使从当前位置开始的搜索是已知的,但之前的状态是怎样的也无从得知啊,实话实说,我是不会用dp解这个。。

递归的思路就好说多了,从当前点开始,有上下左右四个位置可以探测,如果探测成功的话,要把当前的位置用其他符号标记出来,以免重复访问。实际上就是DFS嘛,只不过入口多一些。

需要注意的一点是,每个点都可以作为起点,所以这个要穷举一下,否则会漏掉情况的。当然有一种情况走通就可以返回了,剪枝之。

代码又臭又长,不过work:

class Solution {
public:
    int row, column;
    bool doexist(vector<vector<char> > &board, string &word, int len, int i, int j){
        if(len == word.length())    return true;
        bool res;
        if(i>0&&board[i-1][j] == word[len]){
            board[i-1][j] = ‘.‘;
            res = doexist(board, word, len+1, i-1, j);
            if(res) return true;
            else    board[i-1][j] = word[len];
        }
        if(i<row-1&&board[i+1][j] == word[len]){
            board[i+1][j] = ‘.‘;
            res = doexist(board, word, len+1, i+1, j);
            if(res) return true;
            else    board[i+1][j] = word[len];
        }
        if(j>0&&board[i][j-1] == word[len]){
            board[i][j-1] = ‘.‘;
            res = doexist(board, word, len+1, i, j-1);
            if(res) return true;
            else    board[i][j-1] = word[len];
        }
        if(j<column-1&&board[i][j+1] == word[len]){
            board[i][j+1] = ‘.‘;
            res = doexist(board, word, len+1, i, j+1);
            if(res) return true;
            else    board[i][j+1] = word[len];
        }
        return false;
    }
    bool exist(vector<vector<char> > &board, string word) {
        row = board.size();
        if(row == 0)    return false;
        column = board[0].size();
        char c;
        for(int i=0;i<row;i++){
            for(int j=0;j<column;j++){
                if(board[i][j] == word[0]){
                    board[i][j] = ‘.‘;
                    if(doexist(board, word, 1, i, j))
                        return true;
                    board[i][j] = word[0];
                }
            }
        }
        return false;
    }
};

leetcode第一刷_Word Search

时间: 2024-10-12 01:12:36

leetcode第一刷_Word Search的相关文章

leetcode第一刷_Word Ladder II

注:本文仅供技术探讨, 研究,测试使用. 这个漏洞是2014年2月4日被发现的, 因为该组件试用范围非常广, 所以该漏洞的影响也非常巨大.通过特制的包含畸形header的http请求,可以导致使用该组件的应用程序进入无限循环从而耗尽CPU等资源并最终崩溃. 最近因为在修补struts1的可操纵classLoader的漏洞(struts2也有该漏洞, 不在本文讨论范围), 所以我就在我建立的struts1的项目上直接做测试,怎么创建struts1的项目不在本文讨论范围之列你可以在这里下载strut

leetcode第一刷_Word Break

这种题一看,立马就会想到递归,但直接递归的代价太大了,当字典里的单词长度很小,而单词长度很长时,肯定会超时的.再仔细想一下,是不是每次递归验证都是有必要的呢?如果从i位置开始已经被验证为不行了,那么其他递归分支走到这个位置的时候就不用走了,因为肯定是死胡同.想到了打表,把不行的位置记录下来,速度显著提高. 下面说一点实现的事情,记录一个位置行不行,用map最简单直接,查找速度也快.每次选择步长的时候,不用从0到length,我的做法是先统计一下最长和最小的单词长度,每次验证这个长度就可以了. 代

leetcode第一刷_Word Ladder

这道题思路不难,本质就是BFS嘛,从一个单词开始,他的下一层是所有可以一步变到,且从来没变到过得那些string.问题是怎样确定这些可以变到的string呢?有两个条件,一,只能通过上一层的string变化一个数字得到,二,变化之后单词必须在字典中.注意是变化一个字母得到,而不是编辑距离是1,要么就复杂了,情况多了好多好多. 我最开始的思路是建个map,保存所有从开始单词能变化到得单词及这些单词一步能变化到的那些单词.too young too simple, 在一个字典非常大的测试用例上超时了

leetcode第一刷_Unique Binary Search Trees

这道题其实跟二叉搜索树没有什么关系,给定n个节点,让你求有多少棵二叉树也是完全一样的做法.思想是什么呢,给定一个节点数x,求f(x),f(x)跟什么有关系呢,当然是跟他的左右子树都有关系,所以可以利用其左右子树的结论,大问题被成功转化成了小问题.最熟悉的方法是递归和dp,这里显然有大量的重复计算,用dp打表好一些. 后来实验的同学说,这其实是一个Catalan数,上网查了一下,果然啊.Catalan数是这样子的: h(0) = 1, h(1) = 1; 递推式:h(n)= h(0)*h(n-1)

leetcode第一刷_Unique Binary Search Trees II

http://acm.hdu.edu.cn/showproblem.php?pid=1507 大致题意:在一个n*m的格子上,黑色的地方不可用,问在白色格子上最多可放多少1*2的矩阵. 思路:建图,每个白色格子与它临近的上下左右的白色格子建边,求最大匹配,答案为最大匹配/2,因为是双向图.最后输出匹配边时,当找到一组匹配边记得将该边标记,以防重复计算. #include <stdio.h> #include <algorithm> #include <set> #inc

leetcode第一刷_Convert Sorted List to Binary Search Tree

好,二叉搜索树粉末登场,有关他的问题有这么几个,给你一个n,怎样求所有的n个节点的二叉搜索树个数?能不能把所有的这些二叉搜索树打印出来? 这道题倒不用考虑这么多,直接转就行了,我用的思想是分治,每次找到一半的位置,分离出中间节点,作为新子树的根节点,然后递归构造前半部分和后半部分. class Solution { public: TreeNode *sortedListToBST(ListNode *head) { if(head == NULL) return NULL; int len =

leetcode第一刷_Recover Binary Search Tree

这是一道好题,思路虽然有,但是提交之后总是有数据过不了,又按照数据改改改,最后代码都没法看了.收到的教训是如果必须为自己的代码加上很多很多特殊的限定,来过一些特殊的数据的话,说明代码本身有很大的漏洞. 这道题,我想到了要用两个指针保存乱序的节点,甚至想到了用一个pre指针来保存前面一个节点,但是问题出在哪里呢?我觉得应该是自己对树的遍历理解的不够深刻.既然知道了二叉搜索树一定是用中序遍历的,那么程序的框架应该马上写的出来,先左子树,再根,再右子树,那你说什么时候更新pre指针呢,当然是访问根节点

leetcode第一刷_Search in Rotated Sorted Array

旋转数组的查找问题.从头开始扫一遍,O(N)的复杂度,一般也能过,甚至先排序以下,再二分都能过.不过这道题的目的当然不在于此. 想一下旋转之后对我们的查找产生了什么影响.如果没旋转过,我们直接比较target与A[middle]的大小,然后总能非常确定的丢掉源数组的一半,即把搜索空间减半,但是旋转之后,只根据A[middle]是确定不了下一轮的走向的,因为即使A[middle]比target大,按理说我们应该往前找,但是如果源数组是循环左移的,较小的数可能在后半部分. 上面说的都是旋转之后与没旋

leetcode第一刷_Search in Rotated Sorted Array II

接着上一篇,同样是旋转数组中查找问题.如果这个数组有重复元素怎么办呢?会有什么影响? 我举一个极端的例子,假设数组中的元素是这样的,1,1,2,1,1,1,1,我们要在这个数组中查找2,一开始的A[middle]=1,发现比target小,那我们就看看A[0]和A[N],发现都跟A[middle]相等,那么这个2到底在哪一半中?只有上帝知道,如果他老人家真的存在的话.这种时候我们怎么办呢?没有其他的办法,只能从头开始乖乖的扫描,直到发现target或者确定他不存在. 为什么会出现这种情况,或者说