leetcode 刷题总结【21-40】题
目录
- 30. 串联所有单词的子串——使用map解决子串包含单词的顺序问题
- 31. 下一个排列——技巧
- 32. 最长有效括号——动态规划
- 33. 搜索旋转排序数组
- 34. 在排序数组中查找元素的第一个和最后一个位置
- 35. 搜索插入位置
- 36. 有效的数独——hashset or 位图
- 37. 解数独——回溯（注意：这里是求得一个解就返回 dfs返回值应该为 boolean型）
- 38. 外观数列
- 39.组合总和
- 40.组合总和 II
30. 串联所有单词的子串——使用map解决子串包含单词的顺序问题
这道题，首先会想到先求出可以匹配的字符串（排列组合），再找出其在原字符串的位置。
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
int n=words.length;
if(n==0){
return new ArrayList<Integer>();
}
List<String> list =new ArrayList<String>();
String str="";
boolean[] visited=new boolean[n];
fun(list,words,n,0,str,visited);
List<Integer> re=new ArrayList<Integer>();
for(int i=0;i<list.size();i++){
int j=s.indexOf(list.get(i));
while(j!=-1){
if(!re.contains(j)){
re.add(j);
}
j=s.indexOf(list.get(i),j+1);
}
}
return re;
}
private void fun(List<String> list,String[] words,int n,int path,String s,boolean[] visited){
if(path==n){
list.add(s);
return;
}
for(int i=0;i<n;i++){
if(!visited[i]){
boolean[] newVisited = new boolean[n];
System.arraycopy(visited, 0, newVisited, 0, n);
newVisited[i] = true;
fun(list,words,n,path+1,s+words[i]+"",newVisited);
}
}
}
}
结果悲催的事情发生了！！！超时
这可怎么办呢？？？
采用滑动窗口、
如上图，利用循环变量 i ，依次后移，判断每个子串是否符合即可。
怎么判断子串是否符合？这也是这个题的难点了，由于子串包含的单词顺序并不需要固定，如果是两个单词 A，B，我们只需要判断子串是否是 AB 或者 BA 即可。如果是三个单词 A，B，C 也还好，只需要判断子串是否是 ABC，或者 ACB，BAC，BCA，CAB，CBA 就可以了，但如果更多单词呢？那就崩溃了。
用两个 HashMap 来解决。首先，我们把所有的单词存到 HashMap 里，key 直接存单词，value 存单词出现的个数（因为给出的单词可能会有重复的，所以可能是 1 或 2 或者其他）。然后扫描子串的单词，如果当前扫描的单词在之前的 HashMap 中，就把该单词存到新的 HashMap 中，并判断新的 HashMap 中该单词的 value 是不是大于之前的 HashMap 该单词的 value ，如果大了，就代表该子串不是我们要找的，接着判断下一个子串就可以了。如果不大于，那么我们接着判断下一个单词的情况。子串扫描结束，如果子串的全部单词都符合，那么该子串就是我们找的其中一个。看下具体的例子。
看下图，我们把 words 存到一个 HashMap 中。
第一个单词在 HashMap1 中，然后我们把 foo 存到 HashMap2 中。并且比较此时 foo 的 value 和 HashMap1 中 foo 的 value，1 < 2，所以我们继续扫描。
第三个单词也在 HashMap1 中，然后把 foo 存到 HashMap2 中，因为之前已经存过了，所以更新它的 value 为 3，然后继续比较此时 foo 的 value 和 HashMap1 中 foo 的 value，3 > 2，所以表明该字符串不符合。然后判断下个子串就好了。
当然上边的情况都是单词在 HashMap1 中，如果不在的话就更好说了，不在就表明当前子串肯定不符合了，直接判断下个子串就好了。
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
List<Integer> res = new ArrayList<Integer>();
int wordNum = words.length;
if (wordNum == 0) {
return res;
}
int wordLen = words[0].length();
//HashMap1 存所有单词
HashMap<String, Integer> allWords = new HashMap<String, Integer>();
for (String w : words) {
int value = allWords.getOrDefault(w, 0);
allWords.put(w, value + 1);
}
//遍历所有子串
for (int i = 0; i < s.length() - wordNum * wordLen + 1; i++) {
//HashMap2 存当前扫描的字符串含有的单词
HashMap<String, Integer> hasWords = new HashMap<String, Integer>();
int num = 0;
//判断该子串是否符合
while (num < wordNum) {
String word = s.substring(i + num * wordLen, i + (num + 1) * wordLen);
//判断该单词在 HashMap1 中
if (allWords.containsKey(word)) {
int value = hasWords.getOrDefault(word, 0);
hasWords.put(word, value + 1);
//判断当前单词的 value 和 HashMap1 中该单词的 value
if (hasWords.get(word) > allWords.get(word)) {
break;
}
} else {
break;
}
num++;
}
//判断是不是所有的单词都符合条件
if (num == wordNum) {
res.add(i);
}
}
return res;
}
}
时间复杂度：假设 s 的长度是 n，words 里有 m 个单词，那么时间复杂度就是 O（n * m）。
空间复杂度：两个 HashMap，假设 words 里有 m 个单词，就是 O（m）。
](https://img-blog.csdnimg.cn/20200213105921644.png)
慢的可怜！！！！
怎么优化呢？？
- 情况一：当子串完全匹配，移动到下一个子串的时候。
在解法一中，对于 i = 3 的子串，我们肯定是从第一个 foo 开始判断。但其实前两个 foo 都不用判断了 ，因为在判断上一个 i = 0 的子串的时候我们已经判断过了。所以解法一中的 HashMap2 每次并不需要清空从 0 开始，而是可以只移除之前 i = 0 子串的第一个单词 bar 即可，然后直接从箭头所指的 foo 开始就可以了。 - 情况二：当判断过程中，出现不符合的单词。
但判断 i = 0 的子串的时候，出现了 the ，并不在所给的单词中。所以此时 i = 3，i = 6 的子串，我们其实并不需要判断了。我们直接判断 i = 9 的情况就可以了。 - 情况三：判断过程中，出现的是符合的单词，但是次数超了。
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
List<Integer> res = new ArrayList<Integer>();
int wordNum = words.length;
if (wordNum == 0) {
return res;
}
int wordLen = words[0].length();
HashMap<String, Integer> map1 = new HashMap<String, Integer>();
//map1赋予值
for (String w : words) {
int value = map1.getOrDefault(w, 0);
map1.put(w, value + 1);
}
int gasLen=0;//移动的距离
for(int i=0;i<s.length()-wordNum*wordLen+1;i++){
HashMap<String, Integer> map2 = new HashMap<String, Integer>();
int num = 0;
while(num<wordNum){
String word = s.substring(i + num * wordLen, i + (num + 1) * wordLen);
if(map1.containsKey(word)){
int value=map2.getOrDefault(word,0);
map2.put(word,value+1);
if(map2.get(word)>map1.get(word)){
break;
}
}
else{
break;
}
num++;
}
if (num == wordNum) {
res.add(i);
}
}
return res;
}
}
总
这道题最大的亮点就是应用了 HashMap 了吧，使得我们不再纠结于子串包含单词的顺序。然后对于算法的优化上，还是老思路，去分析哪些判断是不必要的，然后把它除之。
31. 下一个排列——技巧
class Solution {
public void nextPermutation(int[] nums) {
//判断是否是最大值（全部是降序排列）
if(nums.length==1){
return ;
}
int i=1;
boolean flag=true;
for(;i<nums.length;i++){
if(nums[i]>nums[i-1]){
flag=false;
}
}
if(flag)
{
int p=0;
int q=nums.length-1;
while(p<q){
int temp=nums[p];
nums[p]=nums[q];
nums[q]=temp;
p++;
q--;
}
return ;
}
//从后到前找到最大降序序列 j到n-1
//将j-1置位j到n-1的比它大的最小值，并且将后面的j到n-1降序排列
int j=nums.length-1;
for(;j>0;j--){
if(nums[j]>nums[j-1]){
break;
}
}
//j=2;
int k=nums[j-1];//存放
//j-1置位j到n-1的比它大的最小值
int pos=-1;
int min=Integer.MAX_VALUE;
for(int m=j;m<nums.length;m++){
if(nums[m]>k&&nums[m]<min){
min=nums[m];
pos=m;
}
}
nums[j-1]=min;
nums[pos]=k;
//将后面的数升序排列
Arrays.sort(nums, j, nums.length);
}
}
32. 最长有效括号——动态规划
这道题会想到动态规划
为什么会想到动态规划呢？？
首先明确一点动态规划解决的是 有很多解求最优解的问题
而本题中 求最长有效括号。
有效括号 有很多我们求的是最长的那个，即为最优解。
首先定义动态规划的数组代表什么
dp [ i ] 代表以下标 i 结尾的合法序列的最长长度，例如下图
下标 1 结尾的最长合法字符串长度是 2，下标 3 结尾的最长字符串是 str [ 0 , 3 ]，长度是 4 。
我们来分析下 dp 的规律。
首先我们初始化所有的 dp 都等于零。
以左括号结尾的字符串一定是非法序列，所以 dp 是零，不用更改。
以右括号结尾的字符串分两种情况。
- 右括号前边是 ( ，类似于 ……（）。
dp [ i ] = dp [ i - 2] + 2 （前一个合法序列的长度，加上当前新增的长度 2）
类似于上图中 index = 3 的时候的情况。
dp [ 3 ] = dp [ 3 - 2 ] + 2 = dp [ 1 ] + 2 = 2 + 2 = 4
- 右括号前边是 )，类似于 ……））。
此时我们需要判断 i - dp[i - 1] - 1 （前一个合法序列的前边一个位置） 是不是左括号。
例如上图的 index = 7 的时候，此时 index - 1 也是右括号，我们需要知道 i - dp[i - 1] - 1 = 7 - dp [ 6 ] - 1 = 4 位置的括号的情况。
而刚好 index = 4 的位置是左括号，此时 dp [ i ] = dp [ i - 1 ] + dp [ i - dp [ i - 1] - 2 ] + 2 （当前位置的前一个合法序列的长度，加上匹配的左括号前边的合法序列的长度，加上新增的长度 2），也就是 dp [ 7 ] = dp [ 7 - 1 ] + dp [ 7 - dp [ 7 - 1] - 2 ] + 2 = dp [ 6 ] + dp [7 - 2 - 2] + 2 = 2 + 4 + 2 = 8。
如果 index = 4 不是左括号，那么此时位置 7 的右括号没有匹配的左括号，所以 dp [ 7 ] = 0 ，不需要更新。
上边的分析可以结合图看一下，可以更好的理解，下边看下代码。
class Solution {
public int longestValidParentheses(String s) {
int maxans = 0;
int dp[] = new int[s.length()];
for (int i = 1; i < s.length(); i++) {
if (s.charAt(i) == ')') {
//右括号前边是左括号
if (s.charAt(i - 1) == '(') {
dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
//右括号前边是右括号，并且除去前边的合法序列的前边是左括号
} else if (i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') {
dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
}
maxans = Math.max(maxans, dp[i]);
}
}
return maxans;
}
}
33. 搜索旋转排序数组
class Solution {
public int search(int[] nums, int target) {
int len = nums.length;
int left = 0, right = len-1;
while(left <= right){
int mid = (left + right) / 2;
if(nums[mid] == target)
return mid;
else if(nums[mid] < nums[right]){
if(nums[mid] < target && target <= nums[right])
left = mid+1;
else
right = mid-1;
}
else{
if(nums[left] <= target && target < nums[mid])
right = mid-1;
else
left = mid+1;
}
}
return -1;
}
}
34. 在排序数组中查找元素的第一个和最后一个位置
class Solution {
public int[] searchRange(int[] nums, int target) {
int n=nums.length;
if(n==0){
return new int[]{-1,-1};
}
int low=0;
int high=n-1;
int first=-1,last=-1;
while(low<=high){
int mid=(low+high)/2;
if(nums[mid]==target){
first=mid;
last=mid;
while(first>=0&&nums[first]==target){
first--;
}
while(last<=n-1&& nums[last]==target){
last++;
}
first++;
last--;
break;
}
else if(nums[mid]>target){
high=mid-1;
}
else{
low=mid+1;
}
}
return new int[]{first,last};
}
}
35. 搜索插入位置
class Solution {
public int searchInsert(int[] nums, int target) {
int n=nums.length;
if(n==0){
return 0;
}
int low=0;
int high=n-1;
int first=-1,last=-1;
while(low<=high){
int mid=(low+high)/2;
if(nums[mid]==target){
return mid;
}
else if(nums[mid]<target){
low=mid+1;
}
else{
high=mid-1;
}
}
return low;
}
}
36. 有效的数独——hashset or 位图
方法一：使用hashset
public class Solution {
public boolean isValidSudoku(char[][] board) {
Set<String> seen = new HashSet<>();
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
char number = board[i][j];
if (number != '.')
if (!seen.add(number + " in row " + i)
|| !seen.add(number + " in column " + j)
|| !seen.add(number + " in block " + i / 3 + "-"+ j / 3))
return false;
}
}
return true;
}
}
方法二：使用位图（快）
class Solution {
public boolean isValidSudoku(char[][] board) {
int[] map = new int[9];
for(int y=0; y<9; y++){
for(int x=0; x<9; x++){
int key = board[y][x] - '1'; //key:数字
if(key >= 0 && key <= 8) { //1~9有效数字
int index = (1<<x) //Value:位置编码，最低9位存放列号
| (1<<(y+9)) //中间9位存放行号
| (1<<(x/3 + y/3*3 + 18)); // z为9宫格区域序号
int old = map[key];
if((old & index) == 0) //无重复，则按位或，加入位置集合
map[key] = old | index;
else //有重复
return false;
}
}
}
return true;
}
}
37. 解数独——回溯（注意：这里是求得一个解就返回 dfs返回值应该为 boolean型）
class Solution {
public void solveSudoku(char[][] board) {
int[] map = new int[9];
//初始化map
init(board,map);
int cur=blockNum(board);
dfs(cur,board,map);
return ;
}
public boolean dfs(int cur,char[][] board, int[] map){
if(cur==0){
return true ;//表示填完了
}
int x = 0, y = 0;
//记为x y
boolean flag=false;
for(int i = 0; i < 9; i++){
for(int j = 0; j < 9; j++){
if(board[i][j] == '.'){
x = i;
y = j;
flag=true;
break;
}
}
if(flag){
break;
}
}
//遍历当前的可选数字
int index = (1<<y) //Value:位置编码，最低9位存放列号
| (1<<(x+9)) //中间9位存放行号
| (1<<(y/3 + x/3*3 + 18)); // z为9宫格区域序号
for(int i=0;i<9;i++){
int old=map[i];
if((old & index)==0){
//无重复，表示可以放在i+1这个数，则按位或
board[x][y]=(char)('1' + i);
map[i]=old | index;
if(dfs(cur-1, board,map))
{return true;}
//恢复现场
map[i]=old;
board[x][y]='.';
}
}
return false;
}
public int blockNum(char[][] board){
int cur=0;
for(int i=0;i<9;i++){
for(int j=0;j<9;j++){
if(board[i][j]=='.'){
cur++;
}
}
}
return cur;
}
public void init(char[][] board ,int[] map) {
for(int x=0; x<9; x++){
for(int y=0; y<9; y++){
int key = board[x][y] - '1'; //key:数字
if(key >= 0 && key <= 8) { //1~9有效数字
int index = (1<<y) //Value:位置编码，最低9位存放列号
| (1<<(x+9)) //中间9位存放行号
| (1<<(y/3 + x/3*3 + 18)); // z为9宫格区域序号
int old = map[key];
map[key] = old | index;
}
}
}
return ;
}
}
38. 外观数列
class Solution {
public String countAndSay(int n) {
if(n==0)
return "";
if(n==1){
return "1";
}
String re="1";
String s="";
for(int i=1;i<n;i++){
for(int j=0;j<re.length();j++){
int k=1;
while(j+k<re.length()&&re.charAt(j)==re.charAt(j+k)){
k++;
}
s+=(k+""+re.charAt(j)+"");
j=j+k-1;
}
re=s;
s="";
}
return re;
}
}
39.组合总和
class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
List<List<Integer>> list=new ArrayList<List<Integer>>();
List<Integer> l=new ArrayList<Integer>();
int sum=0;
Arrays.sort(candidates);
dfs(list,l,target,sum,candidates);
return list;
}
private void dfs(List<List<Integer>> list,List<Integer> l,int target,int sum,int[] candidates){
if(sum==target){
list.add(l);
}
for(int i=0;i<candidates.length;i++){
if(sum+candidates[i]>target){
break;
}
if(l.size()>0&&l.get(l.size()-1)>candidates[i]){
continue;
}
List<Integer> newL =new ArrayList<Integer>(l);
newL.add(candidates[i]);
dfs(list,newL,target,sum+candidates[i],candidates);
}
}
}
40.组合总和 II
class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
List<List<Integer>> list=new ArrayList<List<Integer>>();
List<Integer> l=new ArrayList<Integer>();
int sum=0;
boolean[] used=new boolean[candidates.length];
Arrays.sort(candidates);
dfs(list,l,target,sum,candidates,used);
return list;
}
private void dfs(List<List<Integer>> list,List<Integer> l,int target,int sum,int[] candidates,boolean[] used){
if(sum==target){
list.add(l);
}
for(int i=0;i<candidates.length;i++){
if(sum+candidates[i]>target){
break;
}
if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1]) {
continue;
}
if(l.size()>0&&l.get(l.size()-1)>candidates[i]){
continue;
}
if(!used[i]){
List<Integer> newL =new ArrayList<Integer>(l);
newL.add(candidates[i]);
boolean[] newUsed = new boolean[used.length];
System.arraycopy(used, 0, newUsed, 0,used.length);
newUsed[i] = true;
dfs(list,newL,target,sum+candidates[i],candidates, newUsed);
}
}
}
}