C语言数据结构与算法 ---滑动窗口

框架：滑动窗口的基本实现框架

int FindSubArry(char* nums)
{
    int start = 0; // 左指针，用于在不满足条件场景下的滑动窗口收缩，被迫移动
    int end = 0; // 右指针，用于滑动窗口的向前移动，主动移动
    // [start, end] 用于保存当前有效的遍历区间
    int res = 0; // 存放结果
    int len = strlen(nums); // 这个长度也是最后end移动的边界值（数组或字符串的长度）
    int sums = 0; // 统计 子数组或子空间是否有效 （可能是求和，计数，等）    

    while(end < len) {  // 
        sum += nums[end];  // 增加当前右指针的内容 （求和、计数等）
        while ([start,end]不符合题意) {   // 这里也有可能是if(.....)
            sums -= nums[start];  // 将当前左指针的内容去掉（求和、计数等）
            start += 1;  // 开始移动左指针, 注意这两步的顺序
        }
        // 当while结束的时候就找到了一个满足题意的当前的[start, end] 子数组/子空间
        res = max(end - start + 1, res);  // 更新当前的res
        end += 1；// 移动右指针
    }
    return res; 
}

1:

给定一个由若干 0 和 1 组成的数组 A，我们最多可以将 K 个值从 0 变成 1 。

返回仅包含 1 的最长（连续）子数组的长度。

 

示例 1：

输入：A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
解释： 
[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。
示例 2：

输入：A = [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。

int max (int a, int b)
{
    if (a > b) {
        return a;
    }
    return b;
}

int longestOnes(int* A, int ASize, int K)
{
    int start = 0;
    int end = 0;
    int res = 0;
    int count = 0;
    while(end < ASize) {
        if (A[end] == 0) {
            count += 1;
        }
        while (count > K) {
            if (A[start] == 0) {
                count -= 1;
            }
            start += 1;
        }
        res = max(end - start + 1, res);
        end += 1;
    }
    return res;
}

2:

给你一个仅由大写英文字母组成的字符串，你可以将任意位置上的字符替换成另外的字符，总共可最多替换 k 次。在执行上述操作后，找到包含重复字母的最长子串的长度。

注意：字符串长度 和 k 不会超过 104。

 

示例 1：

输入：s = "ABAB", k = 2
输出：4
解释：用两个'A'替换为两个'B',反之亦然。
示例 2：

输入：s = "AABABBA", k = 1
输出：4
解释：
将中间的一个'A'替换为'B',字符串变为 "AABBBBA"。
子串 "BBBB" 有最长重复字母, 答案为 4。

int max(int a, int b)
{
    if (a > b) {
        return a;
    }
    return b;
}


int characterReplacement(char * s, int k)
{
    int record[26] = {0}; // 用来存放大写字母出现的次数  record[s[end] - 'A']
    // memset(record, 0, sizeof(record));
    int len = strlen(s); 
    int start = 0;
    int end = 0;
    int maxCount = 0;
    int res = 0;
    while (end < len) {
        record[s[end] - 'A'] += 1;
        maxCount = max(maxCount, record[s[end] - 'A']);  // maxCount 统计当前区间出现的最大次数
        while (end - start + 1 - maxCount > k) {
            record[s[start] - 'A'] -= 1;  // 
            start += 1;
        }
        res = max(res, end - start + 1);  
        end += 1;
    }
    return res;
}

3：

给你两个长度相同的字符串，s 和 t。

将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。

用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。

如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。

如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。

 

示例 1：

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

示例 2：

输入：s = "abcd", t = "cdef", maxCost = 3
输出：1
解释：s 中的任一字符要想变成 t 中对应的字符，其开销都是 2。因此，最大长度为

int max(int a, int b)
{
    if (a > b) {
        return a;
    }
    return b;
}

int equalSubstring(char * s, char * t, int maxCost)
{
    int start = 0;
    int end = 0;
    int res = 0;
    int len = strlen(s);
    int sum = 0;
    int* record = (int*)malloc(sizeof(int) * len);
    memset(record, 0, len);
    for (int i = 0;i < len; i++) {
        record[i] = abs(s[i] - t[i]);
    }

    while (end < len) {
        sum += record[end];
        while (sum > maxCost) {
           sum -=  record[start];
            start += 1;
        }
        res = max(res, end - start + 1);
        end++;

    }
    return res;
}

 

4:

给定一个二进制数组， 计算其中最大连续 1 的个数。

示例：

输入：[1,1,0,1,1,1]
输出：3
解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.

int max(int a, int b)
{
    if (a > b) {
        return a;
    }
    return b;
}
int findMaxConsecutiveOnes(int* nums, int numsSize)
{   
    int start = 0;
    int end = 0;
    int res = 0;
    int count = 0;
    while (end < numsSize) {
        if (nums[end] != 1) {
            count++;
        }
        while(count > 0) {
            if (nums[start] != 1) {
                count--;
            }
            start++;
        }
        res = max(res, end - start + 1);
        end++;
    }
    return res;
}