LeetCode 热题 100打卡第九天

LeeCode热题 100打卡第九天

第一道题

最小覆盖子串（LeeCode第76题）：

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

class Solution {
    public String minWindow(String S, String T) {
        char[] s = S.toCharArray();
        char[] t = T.toCharArray();
        int [] cnt = new int[128];
        int count = 0;
        for(int i = 0; i < t.length; i++){
            cnt[t[i] - 'A']++;
            count++;
        }
        int l = 0, start = -1, end = s.length;
        for(int r = 0;r < s.length; r++){
            if(--cnt[s[r] - 'A'] >= 0) count--;
            while(count ==0){
                if(++cnt[s[l] - 'A'] > 0){
                    if(r -l < end - start){
                        start = l;
                        end = r;
                    }
                    count++;
                }
                l++;
            }
        }
        return start == -1 ? "": S.substring(start, end + 1);
    }
}                                                

第二道题

最大子数组和（LeeCode第53题）：

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组:是数组中的一个连续部分。

解法一：贪心算法

解法一主要采用贪心算法，对当前数而言，前面的连续和若为负数，比起加上前面的负数，不如直接从当前位置开始加起，主要用这个思路来实现整个的算法

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        ArrayList<Integer> list= new ArrayList<Integer>();
        int slen = s.length(),plen = p.length();
        if(plen > slen) return list;
        int[] arrs = new int[26];
        int[] arrp = new int[26];
        for (int i = 0; i < plen; i++){
            arrs[s.charAt(i) - 'a'] += 1;
            arrp[p.charAt(i) - 'a'] += 1;
        }
        if(Arrays.equals(arrs, arrp)){
            list.add(0);
        }
        for(int i = 1; plen + i - 1 < slen; i++){
            arrs[s.charAt(i - 1) - 'a'] -=1;
            arrs[s.charAt(plen + i - 1) - 'a'] +=1;
            if(Arrays.equals(arrs, arrp)){
                list.add(i);}
        }
        return list;
    }
}

解法二：动态规划算法

class Solution {
    public int maxSubArray(int[] nums) {
        int ans = Integer.MIN_VALUE;
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        ans = dp[0];

        for(int i = 1; i < nums.length; i++){
            dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
            ans = Math.max(dp[i], ans);
        }
        return ans;
    }
}