leetcode 刷题总结【21-40】题

最新推荐文章于 2022-07-12 12:01:03 发布

嘤嘤怪QQQ

最新推荐文章于 2022-07-12 12:01:03 发布

阅读量390

点赞数

分类专栏：算法文章标签： leetcode 算法 java

本文链接：https://blog.csdn.net/zj20165149/article/details/104291835

版权

算法专栏收录该内容

44 篇文章 0 订阅

订阅专栏

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);
            }
            
        }
    }
}

嘤嘤怪QQQ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode 刷题总结【21-40】题

目录30. 串联所有单词的子串30. 串联所有单词的子串这道题，首先会想到先求出可以匹配的字符串（排列组合），再找出其在原字符串的位置。class Solution { public List<Integer> findSubstring(String s, String[] words) { int n=words.length; if...
复制链接

扫一扫