算法学习day26(滑动窗口)

滑动窗口系列题

一、替换后的最长重复子串

给你一个字符串 s 和一个整数 k 。你可以选择字符串中的任一字符，并将其更改为任何其他大写英文字符。该操作最多可执行 k 次。

在执行上述操作后，返回 包含相同字母的最长子字符串的长度。

输入：s = "AABABBA", k = 1
输出：4 AABA BABB

思路：滑动窗口 滑动窗口的大小是根据条件得到的，不是题目中规定好的。

滑动窗口就是能够装更多的重复字母的窗口。：满足条件的时候滑动窗口就扩容，不满足条件的时候滑动窗口左边界移动

那么？这里的条件是什么：滑动窗口的长度<+重复的字母+可以替换的次数。也就是说如果窗口中需要替换的次数<=可以替换的次数，那么该滑动窗口就仍然有效，否则就要移动。

left:滑动窗口的左边界  right:滑动窗口的右边界  maxLen:某个滑动窗口中重复最多的字母。

1.首先，遍历到某一个字母的时候，把它存到数组中 arr[s.charAt(i)-'A']++; 然后更新maxLen

2.判断此时滑动窗口是扩容还是左边界改变。

   2.1 if(right-left+1>maxLen+k) 此时就要左边界改变 arr[s.charAt(left)-'A']--;left++;

   2.2 反之，更新一下滑动窗口的最大长度(也就是要求的结果 最长重复子串):res=Math.max(res,right-left+1);

总结：

其实就是在不断寻找最长滑动窗口长度的过程。滑动窗口的大小只能增大不能减小。

代码：

class Solution {
    public int characterReplacement(String s, int k) {
        int left=0,right=0;
        int res=0;
        int maxLen=-1;
        char[] ch=new char[26];
        while(right<s.length()){
            char c=s.charAt(right);
            ch[c-'A']++;
            maxLen=Math.max(maxLen,ch[c-'A']);
            if(right-left+1>maxLen+k){
                ch[s.charAt(left)-'A']--;
                left++;
            }
            res=Math.max(res,right-left+1);
            right++;
        }
        return res;
    }
}

二、最大连续1的个数（滑动窗口）

给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数。

输入：nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出：10
解释：[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 10。

模拟：

1. 0,0,1,1,0,0 此时maxLen+k<right-left+1 此时滑动窗口的左边界+1; left为0

2. 0,1,1,0,0,1 此时是滑动窗口长度增大的过程 直到增长到1,1,0,0,1,1,1,0,1,1 此时maxLen+k=10

left为2

3. 到1,0,0,1,1,1,0,1,1之后，就再也没有机会能使滑动窗口扩容了，此后滑动窗口的长度一直保持left-right+1;

思路：

当遇到1的时候，cnt++;maxLen=Math.max(cnt,maxLen);直到maxLen+k<right-left+1的时候，说明滑动窗口无法继续扩容了，此时将左边界右移一位，此时的right-left+1就是滑动窗口的大小(也就是maxLen+k) 通过cnt变大，使得maxLen取最大，从而使得滑动窗口maxLen+k变最大

代码：

class Solution {
    public int longestOnes(int[] nums, int k) {
        int cnt=0;
        int left=0;
        int right=0;
        int maxLen=0;
        int res=-1;
        while(right<nums.length){
            if(nums[right]==1)cnt++;
            maxLen=Math.max(maxLen,cnt);
            while(right-left+1>maxLen+k){
                if(nums[left]==1)cnt--;
                left++;
            }
            res=Math.max(res,right-left+1);
            right++;
        }
        return res;
    }
}

三、尽可能使字符串相等(滑动窗口)

题意：

给你两个字符串s,t;s[i]和t[i]的ASCII值的绝对值为转换的开销。在给定一个maxCost的前提下，求可以转换的最大长度。

输入：s = "abcd", t = "bcdf", maxCost = 3
输出：3
解释：s 中的 "abc" 可以变为 "bcd"。开销为 3，所以最大长度为 3。

思路：滑动窗口

利用滑动窗口，主要是判断什么时候扩容，什么时候左边界右移；

1.扩容，当totalCost<=maxCost的时候，right++。移动之后更新totalCost

2.右移:  当totalCost>maxCost的时候，左边界就要右移，left++；移动之后更新totalCost；

3.在移动的过程中记录最大的长度即，res=Math.max(res,right-left+1);

代码：

class Solution {
    public int equalSubstring(String s, String t, int maxCost) {
        int totalCost=0;
        int left=0;
        int right=0;
        int res=0;
        while(right<t.length()){
            totalCost+=Math.abs(s.charAt(right)-t.charAt(right));
            if(totalCost>maxCost){
                totalCost-=Math.abs(s.charAt(left)-t.charAt(left));
                left++;
            }
            res=Math.max(res,right-left+1);
            right++;
        }
        return res;
    }
}

四、最小覆盖子串(滑动窗口) 

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

题意：

在s串中寻找涵盖t串的最小子串，并且返回最小子串；如果不存在就返回"";

思路：

要在s串中寻找涵盖t串的最小子串。

1.先将t串的字符和数量都统计起来(使用数组和map都可以)，这里使用数组进行统计字符的种类，count统计字符的数量

2.统计完毕之后就开始在s串进行遍历了。如果遍历到的字符是字符中出现的字符，那么count--；

如果count==0的话，就说明找到了一个子串涵盖t串，此时右边界为right

3.找到右边界之后，对左边界进行压缩，if(--cnt[s.charAt(left)]>0)，就说明letf所指向的该元素是在t串中出现的，因此左边界不能再移动了。此时更新子串的长度。right-left;

代码：先固定右边界 再固定左边界

class Solution {
    public String minWindow(String s, String t) {
        char[] ch1 = s.toCharArray();
        char[] ch2 = t.toCharArray();
        int[] cnt = new int[128];
        int count = 0;
        // 将t串中的字符都收集起来
        for (char ch : ch2) {
            cnt[ch - 'A']++;
            count++;
        }
        // 遍历s串
        int left = 0, start = -1, end = s.length();
        for (int right = 0; right < s.length(); right++) {
            // 如果遍历到的该字符 在t串中出现过的 就count--
            if (--cnt[ch1[right] - 'A'] >= 0)
                count--;
            // 在s中找到子串
            while (count == 0) {
                // 如果当前left所指向的字符是t串中出现的字符 那么就不能向右更新了
                if (++cnt[ch1[left] - 'A'] > 0) {
                    if (right - left < end - start) {
                        end = right;
                        start = left;
                    }
                    count++;
                }
                left++;// 当前left还能继续移动
            }
        }
        return start == -1 ? "" : s.substring(start, end + 1);
    }
}

快慢指针应用

五、环形链表II

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

思路：

1.首先判断环形链表是否有环，可以根据快慢指针是否相等判断。慢指针每次移动一个距离，快指针每次移动两个距离，如果有环的话，那么快指针可以由领先(在慢指针的前面)再到落后(在慢指针的后面)再到相等。因为快指针每次追一个距离，差距每次-1，差距为0的时候，就相遇了。

2.有环则一定有入口，根据公式2(x+y)=n*(y+z)+x+y，得到x=(n-1)(y+z)+z;可以得到

起点到入口的距离 == 相遇的点到起点的距离(顺时针)

代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null||head.next==null)return null;
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null&&fast.next.next!=null){
            slow=slow.next;
            fast=fast.next.next;
            //快慢指针相遇 说明有环
            if(slow==fast){
                ListNode index1=slow;
                ListNode index2=head;
                while(index1!=index2){
                    index1=index1.next;
                    index2=index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}

六、重排链表（寻找中间值+翻转链表）

给定一个单链表 L 的头节点 head ，单链表 L 表示为：L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

题意：按照 1,n,2,n-1,3,n-2的规律排列

思路：找到中间值，变成两段序列(0->中间值前一个)、(中间值->最后)。将中间值以后的序列反转。反转之后两端序列依次出一个然后形成一段链表

1->2->3->4->5 

1.找中间值 3。分成两段：1->2\ 3->4->5 

2.中间值作为新的头结点反转 5->4->3

3.1->2\ 5->4->3 左边拿一个 右边拿一个 1->5->2->4->3

代码：

class Solution {
    public void reorderList(ListNode head) {
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }
        //slow就是中间值 将中间值为新的起点 进行翻转
        ListNode pre=null;
        while(slow!=null){
            ListNode temp=slow.next;
            slow.next=pre;
            pre=slow;
            slow=temp;
        }
        //反转完了 此时pre就是新的头结点
        while(pre.next!=null){
            ListNode temp1=head.next;
            ListNode temp2=pre.next;
            head.next=pre;
            pre.next=temp1;
            head=temp1;
            pre=temp2;
        }
    }
}