Leetcode刷题防忘录（四）

目录

 

valid-parentheses（栈，简单）

search-in-rotated-sorted-array（查找，中等）

search-in-rotated-sorted-array-ii（查找，中等）

word-search（回溯,DFS，中等）

combinations（回溯,DFS，中等）

---

 

valid-parentheses（栈，简单）

题目

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。

示例 1: 输入: "()"  输出: true；
示例 2: 输入: "()[]{}"  输出: true
示例 3:  输入: "(]"  输出: false
示例 4:  输入: "([)]"  输出: false
示例 5:  输入: "{[]}" 输出: true

思路

栈的特性是先进后出，那么用来解决括号问题是一个不错的选择。遍历括号序列，只要是左边的括号（大，小，中都行）全部都把对应的右边括号给压入栈中，

最后的else if是点睛之笔：

                else if(sStack.empty() || sStack.top() != s[i])
                return false;

 如果遍历到最后，一种往里面塞，左半边的括号，那这个序列肯定是错的，因为这个是比对的不同类型的括号序列那么左半边的括号肯定是对应着相应的右半边的（不是单一括号的匹配问题），如果，不一样，那肯定是错的，那么如果塞入右半边括号的时候，和栈里面的不对应，那肯定是错的。

关键这个里面记住stack的建立和使用。

class Solution {
public:
    bool isValid(string s) {
        if(s.empty())
            return true;
        stack<char> sStack;
        for(size_t i = 0; i < s.size(); ++i) {
            if(s[i] == '(')
                sStack.push(')');
            else if(s[i] == '[')
                sStack.push(']');
            else if(s[i] == '{')
                sStack.push('}');
            else if(sStack.empty() || sStack.top() != s[i])
                return false;
            else
                sStack.pop();
        }
        return sStack.empty();
    }
};

search-in-rotated-sorted-array（查找，中等）

题目

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:  输入: nums = [4,5,6,7,0,1,2], target = 0      输出: 4
示例 2:  输入: nums = [4,5,6,7,0,1,2], target = 3      输出: -1

思路

用二分法来求解，最关键的地方是：

			if ((A[0] > target) ^ (A[0] > A[mid]) ^ (target > A[mid]))
				lo = mid + 1;

  (A[0] > target) ^ (A[0] > A[mid])（旋转后）或者(target > A[mid])（未旋转）的时候，只可能是target在数列的后半部分，而且，这种情况不同时成立。^的意义是， 按位异或运算符。 参与运算的两个值,如果两个相应位相同,则结果为0,否则为1.

另外，注意的是，二分法更新的是前后两端的坐标，不是mid。

class Solution {
public:
	int search(int A[], int n, int target) {
		int lo = 0, hi =n - 1;
		while (lo < hi) {
			int mid = (lo + hi) / 2;
			//(A[0] > target) ^ (A[0] > A[mid])或者(target > A[mid])的时候，只可能是target在数列的后半部分，
			//而且，这种情况不同时成立。
			if ((A[0] > target) ^ (A[0] > A[mid]) ^ (target > A[mid]))
				lo = mid + 1;
			else
				hi = mid;
		}
		return lo == hi && A[lo] == target ? lo : -1;
	}
};

search-in-rotated-sorted-array-ii（查找，中等）

题目

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

示例 1:  输入: nums = [2,5,6,0,0,1,2], target = 0     输出: true
示例 2:  输入: nums = [2,5,6,0,0,1,2], target = 3     输出: false

思路

最保守的查找，一个一个找。

class Solution {
public:
    bool search(int A[], int n, int target) {
        for(int i = 0;i<n;i++)
            {
            if(A[i]==target)
                return true;
        }
        return false;
    }
};

word-search（回溯,DFS，中等）

给定一个二维网格和一个单词，找出该单词是否存在于网格中。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例:

board =
[
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]

给定 word = "ABCCED", 返回 true.
给定 word = "SEE", 返回 true.
给定 word = "ABCB", 返回 false.

思路

这是典型的回溯+DFS的思路，在eist主函数中，如常规的，首先定义边界条件：

        int row=board.size();        
        if (row==0) return false;
        int col=board[0].size();
        if(col==0) return false;

后面一个大循环，是主要部分。定义了一个新的DFS函数来递归，这个DFS返回值是个bool类型的值，而且，利用这个题的特性，只要有一个字符，不合适，就可以返回false退出了，那整个字符串是都不可能对的。

DFS的参数前两个是访问的行数和列数，第三个参数表明依次判断word里的每个字符的索引，最后两个就是待比较的word和broad了。下面来看下DFS,一开始也是定义判断边界的条件,和递归出口。

        int size=word.size();
        int row=board.size();
        int col=board[0].size();
        if(pos==size)//递归出口，定义说明整个字符都遍历完了，而且，没有发现false，所以，直接返回ture
            return true;
        if(i<0||j<0||i>=row||j>=col)
            return false;

接着，将board和word里待比较的字符都提取出来，存在暂时变量里面。

        char tmp=board[i][j];
        char wordpos=word[pos];

 如果发现这里量不一样，那么就说明，有字符不匹配，直接返回false,程序结束。

        if(tmp!=wordpos)
            return false;

如果一样，那就把当前比较的board中的这个数，置成“*”，代表以及给检查过了（如果不这样，再下层递归的时候，很可能又探查到这个位置了，但题目明确规定：“同一个单元格内的字母不允许被重复使用。”，所以，需要给先置成"*",来避免重复使用）。接着，开始递归，都将pos+1，代表进行检查word的下一个字符，接着，带入当前board点的上（i-1,j）下（i+1,j）左（i,j+1）右（i,j-1）四个位置坐标,继续递归。（注意：这种写法很值得记住，面试的时候就被问到了，这样写很优雅，不冗杂，但前提是返回值是bool类型才可以。）用||连接，表明只要四个方向上有一个是true的，就代表这个数可以，可以是找到的。然后，就把原来置为"*"的值给还原回去，方便其他量再用到这个值去检查。最后，将获得的bool判断结果存到res里，作为当前递归的返回值。

        board[i][j]='*';
        bool res=DFS(i,j+1,pos+1,word,board)||DFS(i,j-1,pos+1,word,board)||
               DFS(i+1,j,pos+1,word,board)||DFS(i-1,j,pos+1,word,board);
        board[i][j]=tmp;
        return res;

 完整code

class Solution {
public:
    bool exist(vector<vector<char> > &board, string word) {
        int row=board.size();
        if (row==0) return false;
        int col=board[0].size();
        if(col==0) return false;
        //bool result=false;
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(DFS(i,j,0,word,board)==true)
                    return true;
            }
        }
        return false;
    }
    bool DFS(int i,int j,int pos,string &word,vector<vector<char> > &board){
        int size=word.size();
        int row=board.size();
        int col=board[0].size();
        if(pos==size)
            return true;
        if(i<0||j<0||i>=row||j>=col)
            return false;
        char tmp=board[i][j];
        char wordpos=word[pos];
        if(tmp!=wordpos)
            return false;
        board[i][j]='*';
        bool res=DFS(i,j+1,pos+1,word,board)||DFS(i,j-1,pos+1,word,board)||
               DFS(i+1,j,pos+1,word,board)||DFS(i-1,j,pos+1,word,board);
        board[i][j]=tmp;
        return res;
    }
};

combinations（回溯,DFS，中等）

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

示例:

输入: n = 4, k = 2
输出:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

思路

采用递归的思路来进行回溯，在dfs函数里面，res代表最后的结果数组，ary存在每一种组合的可能，start是每次遍历的起始位置。

其中，最不容易想通的地方就是下面的代码部分:,如果k!=0,说明长度为k的ary没塞满，需要继续塞，那继续塞的时候，该塞多少呢？传入的start默认是1，说明ary最开始塞的时候，而且里面没有数，就塞1，塞完1后，在下一次递归dfs的时候，将start增1，说明之后要塞的数是（start+1）,这样保证了数的逐步增加，不会出现重复的；那么该塞多少个呢？，code给的上限是i <= n - k + 1,还是以初始数值为例，n=4,k=2。首次塞入的时候，上限是4-2+1，对应的是每个ary开头数字分别能为：1，2，3，那么，这个上限就是限制了每个ary的开头数字。在之后环节的递归中，传入def的K位置参数逐次减一，这样，每次的上限就变小，因为当前一位确定后，后一位所能利用的数字的确少了一个。

另外，每次的push_back和pop_back，体现了回溯的思想，每次操作完后，将ary清空，这样ary数组可以重复使用了。

for (int i = start; i <= n - k + 1; i++)
{
	ary.push_back(i);
	dfs(res, ary, n, i + 1, k - 1);
	ary.pop_back();
}

def,首先定义递归出口，检查k是否为0，为0的时候将所得到的ary,存入res，完成一次递归。如果不为0，开始下次递归，首先在当前大循环里确定首位的数值（由start决定，一次相加），再利用后面的递归，依次将后位可选的数字依次填补，直至k==0，到达递归出口，完成全部操作。

完整code

class Solution {
public:
	vector<vector<int>> combine(int n, int k) {
		vector<vector<int>> res;
		vector<int> ary;
		dfs(res, ary, n, 1, k);
		return res;
	}

	void dfs(vector<vector<int>> &res, vector<int> &ary, int n, int start, int k)
	{
		if (k == 0) { res.push_back(ary); }
		else
			for (int i = start; i <= n - k + 1; i++)
			{
				ary.push_back(i);
				dfs(res, ary, n, i + 1, k - 1);
				ary.pop_back();
			}
	}
};