2021-03-23力扣刷题

最新推荐文章于 2022-12-15 08:55:47 发布

卍暴力出奇迹卍

最新推荐文章于 2022-12-15 08:55:47 发布

阅读量112

点赞数

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

本文链接：https://blog.csdn.net/qq_43610675/article/details/115124949

版权

算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

编号162，寻找峰值

峰值元素是指其值大于左右相邻值的元素。

给你一个输入数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞ 。

示例 1：

输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。
示例 2：

输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5
解释：你的函数可以返回索引 1，其峰值元素为 2；
或者返回索引 5，其峰值元素为 6。

提示：

1 <= nums.length <= 1000
-231 <= nums[i] <= 231 - 1
对于所有有效的 i 都有 nums[i] != nums[i + 1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-peak-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int findPeakElement(int[] nums) {
        int l=0;
        int r=nums.length-1;
        while(l<r){
            int m = l+(r-l)/2;
            if(nums[m]<nums[m+1]){
                l=m+1;
            }
            else{
                r=m;
            }
        }
        //l和r重合后退出循环返回l的位置
        return l;
    }
}

编号74搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

示例 1：

在这里插入图片描述

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出：true
示例 2：
在这里插入图片描述

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出：false

提示：

m == matrix.length
n == matrix[i].length
1 <= m, n <= 100
-104 <= matrix[i][j], target <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-a-2d-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int l=0;
        int col=matrix[0].length;
        int row=matrix.length;
        int r=col*row-1;
        /**二分查找，将二维数组看成一维数组,二维数组索引和一维数组索引有如下关系
        (x,y)=>(index/col,index%col),index是一维数组索引，col二维数组列数
        **/
        while(l<=r){
            int m=l+(r-l)/2;
            int temp=matrix[m/col][m%col];//转换索引
            if(temp==target){
                return true;
            }
            else if(temp>target){
                r=m-1;
            }
            else{
                l=m+1;
            }
        }
        return false;
    }
}

定长字串中元音的最大数目

给你字符串 s 和整数 k 。

请返回字符串 s 中长度为 k 的单个子字符串中可能包含的最大元音字母数。

英文中的元音字母为（a, e, i, o, u）。

示例 1：

输入：s = “abciiidef”, k = 3
输出：3
解释：子字符串 “iii” 包含 3 个元音字母。
示例 2：

输入：s = “aeiou”, k = 2
输出：2
解释：任意长度为 2 的子字符串都包含 2 个元音字母。
示例 3：

输入：s = “leetcode”, k = 3
输出：2
解释：“lee”、“eet” 和 “ode” 都包含 2 个元音字母。
示例 4：

输入：s = “rhythms”, k = 4
输出：0
解释：字符串 s 中不含任何元音字母。
示例 5：

输入：s = “tryhard”, k = 4
输出：1

提示：

1 <= s.length <= 10^5
s 由小写英文字母组成
1 <= k <= s.length

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-number-of-vowels-in-a-substring-of-given-length
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int maxVowels(String s, int k) {
        HashSet<Character> set = new HashSet<>();
        set.add('a');
        set.add('e');
        set.add('i');
        set.add('o');
        set.add('u');
        int res=0;
        int count=0;
        //先找第一个窗口的元音个数
        for(int i=0;i<k;i++){
            char c = s.charAt(i);
            if(set.contains(c)){
                count++;
            }
        }
        res=Math.max(res,count);
        //从k位置开始，是窗口尾部位置的移动
        for(int i=k;i<s.length();i++){
            char c=s.charAt(i-k);//原窗口头部，要被剔除的
            char c2=s.charAt(i);//即将加进来的字母
            if(set.contains(c)){
                count--;
            }
            if(set.contains(c2)){
                count++;
            }
            res=Math.max(res,count);
        }
        return res;
    }
}

代码参考：https://www.bilibili.com/read/cv8932695?spm_id_from=333.788.b_636f6d6d656e74.42

编号344反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]
示例 2：

输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

双指针交换解法

class Solution {
    public void reverseString(char[] s) {
        int left = 0, right = s.length - 1;
        while (left < right) {
            char tmp = s[left];
            s[left++] = s[right];
            s[right--] = tmp;
        }
    }

}

递归解法

class Solution {
    public void reverseString(char[] s) {
        fun(s,0,s.length-1);
    }

    private void fun(char[] s,int left,int right){
        if(left>=right){
            return;
        }
        fun(s,left+1,right-1);
        //交换
        char tmp = s[left];
        s[left] = s[right];
        s[right] = tmp;
    }

}

编号22括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：

输入：n = 1
输出：["()"]

提示：

1 <= n <= 8

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/generate-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<String>();
        backtrack(n,res,0,0,"");
        return res;
    }
    private void backtrack(int n,List<String> res,int left,int right,String str){
        if(right>left){
            return;
        }
        if(left==right && left==n){
            res.add(str);
            return;
        }
        if(left<n){
            backtrack(n,res,left+1,right,str+"(");
        }
        if(right<left){
            backtrack(n,res,left,right+1,str+")");
        }
    }
}

编号78子集

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按任意顺序返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums 中的所有元素互不相同

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subsets
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

回溯法

//回溯法，循环遍历子集个数的情况
  public List<List<Integer>> subsets(int[] nums) {
      List<List<Integer>> res = new ArrayList<>();
      //空集情况
      res.add(new ArrayList<>());
      for(int i=1;i<=nums.length;i++){
          backtrack(res,nums,i,0,new ArrayList<>());
      }
      return res;
  }

  private void backtrack(List<List<Integer>> res,int[] nums,int len,int index,List<Integer> subsets){
      if(subsets.size()==len){
          List<Integer> temp = new ArrayList<>(subsets);
          res.add(temp);
          return;
      }
      for(int i=index;i<nums.length;i++){
          subsets.add(nums[i]);
          backtrack(res,nums,len,i+1,subsets);//i+1从后一个元素开始遍历防止重复子集
          subsets.remove(subsets.size()-1);
      }
  }

dfs，更快

class Solution {
  public List<List<Integer>> subsets(int[] nums) {
      List<List<Integer>> res = new ArrayList<>();
      dfs(res,nums,0,new ArrayList<>());
      return res;
  }
  private void dfs(List<List<Integer>> res,int[] nums,int index,List<Integer> subsets){
      res.add(new ArrayList<>(subsets));//每次进入都加入结果集一次
      if(index==nums.length){
          return;
      }
      for(int i=index;i<nums.length;i++){
          subsets.add(nums[i]);
          dfs(res,nums,i+1,subsets);
          subsets.remove(subsets.size()-1);
      }
  }
}

卍暴力出奇迹卍

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-03-23力扣刷题

编号162，寻找峰值峰值元素是指其值大于左右相邻值的元素。给你一个输入数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。你可以假设 nums[-1] = nums[n] = -∞ 。示例 1：输入：nums = [1,2,3,1]输出：2解释：3 是峰值元素，你的函数应该返回其索引 2。示例 2：输入：nums = [1,2,1,3,5,6,4]输出：1 或 5解释：你的函数可以返回索引 1，其峰值元素为 2；或者返回索引
复制链接

扫一扫

专栏目录