2021-12-23 187. 重复的DNA序列 3. 无重复字符的最长子串 209. 长度最小的子数组 77. 组合

最新推荐文章于 2024-09-09 22:01:06 发布

rookieyx

最新推荐文章于 2024-09-09 22:01:06 发布

阅读量3k

点赞数

分类专栏：力扣文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/m0_52001011/article/details/122112428

版权

力扣专栏收录该内容

64 篇文章 0 订阅

订阅专栏

187. 重复的DNA序列

class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        int n=s.length();
        ArrayList<String> list=new ArrayList<>();
        if(n<10) return list;
        HashMap<String,Integer> map=new HashMap<>();
        for(int i=0;i<=n-10;i++){
            String temp=s.substring(i,i+10);
            map.put(temp,map.getOrDefault(temp,0)+1);
            if(map.get(temp)==2) list.add(temp);
        }
        return list;
    }
}

3. 无重复字符的最长子串

class Solution {
    public int lengthOfLongestSubstring(String s) {
        HashMap<Character,Integer> map=new HashMap<>();
        int n=s.length();
        int max=0;
        int left=0;
        for(int i=0;i<n;i++){
        if(map.containsKey(s.charAt(i))  ){
            //主要思想在于移动做左侧的标记位置，发现重复字符后，判断和当前的起始位置进行比较，来进行左边界的更新
                left=Math.max(left,map.get(s.charAt(i))+1);
                }
                map.put(s.charAt(i),i);
                max=Math.max(max,i-left+1);
        }
    return max;
    }
}

209. 长度最小的子数组

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int sum=0;
        for(int num:nums) sum+=num;
        if(sum<target) return 0;
        int min=nums.length;
        int left=0;
        sum=0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
                while(sum>=target){
                    min=Math.min(min,i-left+1);
                    sum-=nums[left];
                    left++;
            }
        }
    return min;
    }
}

77. 组合

class Solution {
    List<List<Integer>> res=new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
    backtracking(n,k,1);
    //  backtracking(n,k,0);
    return res;
    }

public void backtracking(int n,int k,int index){
       if(path.size()==k){
          res.add(new ArrayList<>(path));
          return;
        }
      //注意：这里的第一个数从一开始而不是0  
    // for(int i=index;i<n;i++){
    for(int i=index;i<=n;i++){
         //if(path.size()==k){
      //      res.add(new ArrayList<>(path));
       //     return;
       // }
        path.add(i);
        backtracking(n,k,i+1);
        path.remove(path.size()-1);
    }
    }
}