滑动窗口与双指针

最新推荐文章于 2023-10-13 00:59:39 发布
最新推荐文章于 2023-10-13 00:59:39 发布
阅读量837 收藏 2
点赞数
分类专栏： leetCode 文章标签： leetcode 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41282486/article/details/121622641
版权

1.最长区间

模板：

int maxLength(int[] A) {

  int N = A.length;

  // 区间的左指针

  int left = -1;

  int ans = 0;

  for (int i = 0; i < N; i++) {

    // assert 在加入A[i]之前，(left, i-1]是一个合法有效的区间

    // step 1. 直接将A[i]加到区间中，形成(left, i]

    // step 2. 将A[i]加入之后，惰性原则

    while (check((left, i]))/*TODO 检查区间状态是否满足条件*/) {

      ++left; // 如果不满足条件，移动左指针

      // TODO 修改区间的状态

    }

    // assert 此时(left, i]必然满足条件

    ans = max(ans, i - left);

  }

  return ans; // 返回最优解

}

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

class Solution {
    public int lengthOfLongestSubstring(String s) {

        final int N = (null == s ? 0 : s.length());

        final int[] pos = new int[256];
        Arrays.fill(pos, -1);

        int res = 0;
        int left = -1;

        for (int i = 0; i < N; i ++) {
            final int idx = (int)s.charAt(i);
            while (pos[idx] > left) {
                left = pos[idx];
            }
            pos[idx] = i;
            res = Math.max(res, i - left);
        }
        
        return res;
    }
}

424. 替换后的最长重复字符

class Solution {
    public int characterReplacement(String s, int k) {
        final int N = s.length();
        int left = -1;
        int res = 0;
        int oneNumber = 0;
        int[] cnt = new int[256];

        for (int i = 0; i < N; i ++) {
           final int c = s.charAt(i);
           cnt[c] ++;

           oneNumber = Math.max(oneNumber, cnt[c]);

           while (i - left - oneNumber > k) {
               final int ct = s.charAt(++ left);
               cnt[ct] --;
           }

           res = Math.max(res, i - left);
        }

        return res;
    }
}

904. 水果成篮

class Solution {

    // 根据题目设计数据结构
    private class Counter extends HashMap<Integer, Integer> {

        public Integer get(final Integer key) {
            return super.containsKey(key) ? super.get(key) : 0;
        }

        public void add(final Integer key, final Integer value) {
            super.put(key, this.get(key) + value);
        }

    }

    public int totalFruit(int[] tree) {

       final int n = tree.length;
       int left = -1;
       int res = 0;
       final Counter counter = new Counter();

       for (int i = 0; i < n; i ++) {

           final Integer rightType = tree[i];
           counter.add(rightType, 1);

           while (counter.size() > 2) {
               final Integer leftType = tree[++ left];
               counter.add(leftType, -1);

               if (0 == counter.get(leftType)) {
                   counter.remove(leftType);
               }
           } 

           res = Math.max(res, i - left);
       }

       return res;
    }
}

参考题解：
https://github.com/lagoueduCol/Algorithm-Dryad/blob/main/10.DoublePointer/904.%E6%B0%B4%E6%9E%9C%E6%88%90%E7%AF%AE.java?fileGuid=xxQTRXtVcqtHK6j8

386 · 最多有k个不同字符的最长子字符串

public class Solution {

    private class Counter extends HashMap<Character, Integer> {

            public Integer get(Character key) {
                return super.containsKey(key) ? super.get(key) : 0;
            }

            public void add(Character key, Integer value) {
                super.put(key, this.get(key) + value);
                if (0 == this.get(key)) {
                    super.remove(key);
                }
            }

    }

    /**
     * @param s: A string
     * @param k: An integer
     * @return: An integer
     */

    public int lengthOfLongestSubstringKDistinct(String s, int k) {
        // write your code here

        final int n = s.length();
        int left = -1;
        int res = 0;
        final Counter counter = new Counter();

        for (int i = 0; i < n; i ++) {

            final Character rightCh = (Character)s.charAt(i);
            counter.add(rightCh, 1);

            while (counter.size() > k) {
                
                final Character leftCh = (Character)s.charAt(++ left);
                counter.add(leftCh, -1);

            }

            res = Math.max(res, i - left);
        }

        return res;
   }
}

845. 数组中的最长山脉

class Solution {
    public int longestMountain(int[] arr) {
        int n = arr.length;
        int res = 0;
        for (int i = 1; i < n - 1; i ++) {
            int left = i - 1;
            while (left >= 0) {
                if (arr[left] < arr[left + 1]) {
                    left --;
                } else {
                    break;
                }
            }

            if (left + 1 == i) {
                continue;
            }

            int right = i + 1;
            while (right < n) {
                if (arr[right - 1] > arr[right]) {
                    right ++;
                } else {
                    break;
                }
            }

            if (right == i + 1) {
                continue;
            }

            res = Math.max(res, right - left - 1);
        }

        return res;
    }
}

// myself pass

2.区间计数

模板：

int rangeCounter(int[] A) {

  int N = A.length;

  // 区间的左指针

  int left = -1;

  int ans = 0;

  // 不变式0: 最开始的区间为(-1, -1] 是一个空区间

  //         我们认为空区间总是满足条件!

  for (int i = 0; i < N; i++) {

    // 不变式1: 在加入A[i]之前，(left, i-1]是一个合法有效的区间

    // step 1. 直接将A[i]加到区间中，形成(left, i]

    // step 2. 将A[i]加入之后，惰性原则

    while (check((left, i]))/*TODO 检查区间状态是否满足条件*/) {

      ++left; // 如果不满足条件，移动左指针

      // TODO 修改区间的状态

    }

    // 不变式2：此时(left, i]必然合法

    // 累计区间个数

    ans += i - left;

  }

  return ans; // 返回最优解

}

713. 乘积小于K的子数组

class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {

        final int n = nums.length;
        int left = -1;
        int s = 1;
        int res = 0;

        for (int i = 0; i < n; i ++) {

            s *= nums[i];

            while (left < i && s >= k) {
                s /= nums[++ left];
            }

            res += (i - left);
        }

        return res;
    }
}

911 · 最大子数组之和为k

public class Solution {
    /**
     * @param nums: an array
     * @param k: a target value
     * @return: the maximum length of a subarray that sums to k
     */
    public int maxSubArrayLen(int[] A, int k) {
        final int N = A == null ? 0 : A.length;
        Map<Long, Integer> H = new HashMap<>();
        Long s = Long.valueOf(0);
        int ans = 0;
        H.put(s, -1);
        for (int i = 0; i < N; i++) {
            s += A[i];
            Long want = Long.valueOf(s - k);
            int wantPos = H.getOrDefault(want, N + 1);
            ans = Math.max(ans, i - wantPos);
            // 如果已经存在了
            if (!H.containsKey(s)) {
                H.put(s, i);
            }
        }
        return ans;
    }
}

3.定长区间

定长区间问题是要找到一个固定长度的区间，并且这个区间必须满足某种条件。所以求解定长区间问题，实质上是需要找满足两个条件的子串。

子串的长度固定。由于长度固定，因此，定长区间问题不需要满足单调性。

子串必须满足某种条件。

567. 字符串的排列

class Solution {
    public boolean checkInclusion(String s1, String s2) {

        final int aLen = (null == s1 ? 0 : s1.length());
        final int bLen = (null == s2 ? 0 : s2.length());

        int[] aStr = new int[256];
        for (int i = 0; i < aLen; i ++) {
            aStr[s1.charAt(i)] ++;
        }

        int[] bStr = new int[256];
        int left = -1;
        
        for (int i = 0; i < bLen; i ++) {

            bStr[s2.charAt(i)] ++;

            if (i - left < aLen) {
                continue;
            }

            boolean same = true;
            for (int j = 0; j < 256 && same; j ++) {
                same = (aStr[j] == bStr[j]); 
            }

            if (same) {
                return true;
            }

            left ++;
            bStr[s2.charAt(left)] --;
        }

        return false;
    }
}

30. 串联所有单词的子串

class Solution {

    private class Counter extends HashMap<String, Integer> {

        public Integer get(String key) {
            return super.containsKey(key) ? super.get(key) : 0;
        }

        public void add(String key, Integer value) {
            if ("".equals(key)) {
                return;
            }
            super.put(key, this.get(key) + value);
            if (0 == this.get(key)) {
                super.remove(key);
            }
        }

    }

    public List<Integer> findSubstring(String s, String[] words) {

        final int wordsLen = words.length;
        Counter wordsLenCounter = new Counter();
        for (int i = 0; i < wordsLen; i ++) {
            wordsLenCounter.add(words[i], 1);
        }

        final int wordsN = words[0].length();
        final int wordsNumber = words.length;
        final int sLen = s.length();
        int left = -1;
        List<Integer> res = new ArrayList<>();

        for (int i = 0; i < sLen; i ++) {

            if (i - left < (wordsN * wordsLen)) {
                continue;
            }

            Counter sCounter = new Counter();
            for (int j = left + 1; j <= i - wordsN + 1; j += wordsN) {
                String str = s.substring(j, j + wordsN);
                sCounter.add(str, 1);
            }

            left ++;

            boolean same = wordsLenCounter.size() == sCounter.size();
            if (same) {
                for (String sw : wordsLenCounter.keySet()) {
                    if (!(wordsLenCounter.get(sw).equals(sCounter.get(sw)))) {
                        same = false;
                        break;
                    }
                }

                
            }
            
            if (same) {
                res.add(left);
            }
        }

        return res;

    }
}

//

76. 最小覆盖子串

class Solution {

    private class Counter extends HashMap<Character, Integer> {

        public Integer get(Character key) {
            return super.containsKey(key) ? super.get(key) : 0;
        }

        public void add(Character key, Integer value) {
            super.put(key, this.get(key) + value);
            if (0 == super.get(key)) {
                super.remove(key);
            } 
        }

    }

    public String minWindow(String s, String t) {
        final int tLen = t.length();
        final Counter tCounter = new Counter();
        for (int i = 0; i < tLen; i ++) {
            Character key = (Character)t.charAt(i);
            tCounter.add(key, 1);
        }

        final int sLen = s.length();
        int left = -1;
        int minLen = sLen + 1;
        final Counter sCounter = new Counter();
        int resL = 0;
        int resR = 0;
        for (int i = 0; i < sLen; i ++) {

            Character key = (Character)s.charAt(i);
            sCounter.add(key, 1);

            if (i - left < tLen) {
                continue;
            }

            boolean same = true;
            while (same) {
                for (Character c : tCounter.keySet()) {
                    if (tCounter.get(c) > (sCounter.get(c))) {
                        same = false;
                        break;
                    }
                }
                if (same) {
                    if (minLen > i - left) {
                        resL = left + 1;
                        resR = i + 1;
                        minLen = i - left;
                    }
                    left ++;
                    sCounter.add((Character)s.charAt(left), -1);  
                }
                
            }
        }

        return s.substring(resL, resR);
    }
}

209. 长度最小的子数组

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        final int n = nums.length;
        int left = -1;
        int res = 0;

        for (int i = 0; i < n; i ++) {
            res += nums[i];
        }

        if (res < s) {
            return 0;
        }

        res = 0;

        int minLen = n;
        for (int i = 0; i < n; i ++) {

            res += nums[i];

            while (res >= s) {
                minLen = Math.min(minLen, i - left);
                left ++;
                res -= nums[left];
            }
        }

        return minLen;
    }
}
训练

643. 子数组最大平均数 I

class Solution {
    public double findMaxAverage(int[] nums, int k) {
        final int n = nums.length;

        int left = -1;
        double sum = 0;
        double res = Integer.MIN_VALUE;

        for (int i = 0; i < n; i ++) {
            sum += nums[i];

            if (i - left < k) {
                continue;
            }

            res = Math.max(res, sum / k);

            left ++;
            sum -= nums[left];

        }

        return res;
    }
}

// https://kaiwu.lagou.com/course/courseInfo.htm?courseId=685#/detail/pc?id=6699

1052. 爱生气的书店老板

class Solution {
    public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
        final int n = customers.length;
        int sum = 0;
        int res = Integer.MIN_VALUE;
        for (int i = 0; i < n; i ++) {
            if (0 == grumpy[i]) {
                sum += customers[i];
            }
        }

        int left = -1;
        for (int i = 0; i < n; i ++) {

            if (1 == grumpy[i]) {
                sum += customers[i];
            }    

            if (i - left < minutes) {
                continue;
            }

            res = Math.max(res, sum);
            left ++;
            if (1 == grumpy[left]) {
                sum -= customers[left];
            }
        }

        return res;
    }
}

// https://kaiwu.lagou.com/course/courseInfo.htm?courseId=685#/detail/pc?id=6699

1423. 可获得的最大点数

class Solution {
    public int maxScore(int[] cardPoints, int k) {
        final int n = cardPoints.length;
        final int windowLen = n - k;
        int sum = 0;
        for (int i = 0; i < n; i ++) {
            sum += cardPoints[i];
        }

        if (0 == windowLen) {
            return sum;
        }

        int sumWindow = 0;
        int minValue = sum;
        int left = -1;

        for (int i = 0; i < n; i ++) {

            sumWindow += cardPoints[i];

            if (i - left < windowLen) {
                continue;
            }

            minValue = Math.min(minValue, sumWindow);

            left ++;
            sumWindow -= cardPoints[left];
        }

        return sum - minValue;
    }
}

//

1456. 定长子串中元音的最大数目

class Solution {

    private class Counter extends HashMap<Character, Integer> {

        private Integer validSum = 0;

        public Integer getValidSum() {
            return validSum;
        }

        public Integer get(Character key) {
            return super.containsKey(key) ? super.get(key) : 0;
        }

        public void add(Character key, Integer value) {
            super.put(key, this.get(key) + value);
            validSum += value;
            if (0 == this.get(key)) {
                super.remove(key);
            }
        }

    }

    private boolean isValid(Character ch) {
        if ('a' == (char)ch || 'e' == (char)ch || 'i' == (char)ch || 'o' == (char)ch || 'u' == (char)ch) {
            return true;
        }
        return false;
    }

    public int maxVowels(String s, int k) {

        final int n = s.length();

        int left = -1;
        int res = 0;
        Counter counter = new Counter();

        for (int i = 0; i < n; i ++) {

            Character ch = s.charAt(i);
            if (this.isValid(ch)) {
                counter.add(ch, 1);
            }

            if (i - left < k) {
                continue;
            }

            res = Math.max(res, counter.getValidSum());
            left ++;

            Character chLeft = s.charAt(left);
            if (this.isValid(chLeft)) {
                counter.add(chLeft, -1);
            }
        }

        return res;
    }
}

1658. 将 x 减到 0 的最小操作数

class Solution {
    public int minOperations(int[] nums, int x) {
        final int n = nums.length;
        int k = 0;
        for (int i = 0; i < n; i ++) {
            k += nums[i];
        }

        k -= x;

        if (k < 0) {
            return -1;
        } else if (k == 0) {
            return n;
        }

        int left = -1;
        int sum = 0;
        int maxLen = 0;
        for (int i = 0; i < n; i ++) {
            sum += nums[i];

            while (sum > k) {
                left ++;
                sum -= nums[left];
            }

            if (sum == k) {
                maxLen = Math.max(maxLen, i - left);
            } 
        }

        return 0 == maxLen ? -1 : n - maxLen;
    }
}

1695. 删除子数组的最大得分


class Solution {

    
    public int maximumUniqueSubarray(int[] nums) {
        final int n = nums.length;

        int sum = 0;
        int left = 0;
        Set<Integer> set = new HashSet<>();
        int res = 0;
        
        for (int i = 0; i < n; i ++) {

            if (!set.contains(nums[i])) {
                sum += nums[i];
                res = Math.max(res, sum);
                set.add(nums[i]);
            } else {
                while (nums[i] != nums[left]) {
                    sum -= nums[left];
                    set.remove(nums[left]);
                    left ++;
                }
                left ++;
            }           
        }

        return res;
    }
}

438. 找到字符串中所有字母异位词

class Solution {
    public List<Integer> findAnagrams(String s, String p) {

        final int sLen = s.length();
        final int pLen = p.length();
        final int[] pArr = new int[256];

        for (int i = 0; i < pLen; i ++) {
            pArr[p.charAt(i)] ++;
        }

        int left = -1;
        final int[] sArr = new int[256];
        final List<Integer> res = new ArrayList<>();

        for (int i = 0; i < sLen; i ++) {

            sArr[s.charAt(i)] ++;

            if (i - left < pLen) {
                continue;
            }

            left ++;

            boolean same = true;
            for (int j = 0; j < 256; j ++) {
                if (pArr[j] != sArr[j]) {
                    same = false;
                }
            }

            sArr[s.charAt(left)] --;

            if (same) {
                res.add(left);
            }
        }

        return res;
    }
}

487. 最大连续1的个数 II

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {

        final int n = nums.length;
        int oneNum = 0;
        int left = -1;
        int res = 0;

        for (int i = 0; i < n; i ++) {

            if (1 == nums[i]) {
                oneNum ++;
            }

            while (i - left > 1 + oneNum) {
                left ++;
                if (1 == nums[left]) {
                    oneNum --;
                }
            }

            res = Math.max(res, i - left);

        }

        return res;
    }
}

1004. 最大连续1的个数 III

class Solution {
    public int longestOnes(int[] nums, int k) {

        final int n = nums.length;
        int left = -1;
        int oneNum = 0;
        int res = 0;

        for (int i = 0; i < n; i ++) {

            if (1 == nums[i]) {
                oneNum ++;
            }

            while (i - left > k + oneNum) {
                left ++;
                if (1 == nums[left]) {
                    oneNum --;
                }
            }

            res = Math.max(res, i - left);
        }

        return res;
    }
}

1493. 删掉一个元素以后全为 1 的最长子数组

class Solution {
    public int longestSubarray(int[] nums) {

        final int n = nums.length;
        int zeroNum = 0;
        int left = -1;
        int res = 0;
        
        for (int i = 0; i < n; i ++) {

            if (0 == nums[i]) {
                zeroNum ++;
            }

            while (zeroNum > 1) {
                left ++;
                if (0 == nums[left]) {
                    zeroNum --;
                }
            }

            res = Math.max(res, i - left - 1);
        }

        return res;
    }
}

978. 最长湍流子数组

class Solution {
    public int maxTurbulenceSize(int[] arr) {
        return Math.max(oneContion(arr), twoContion(arr));
    }

    private int oneContion(int[] arr) {

        final int n = arr.length;
        int left = 0;
        int res = 1;

        for (int i = 1; i < n; i ++) {

            if (0 == i % 2) {
                if (arr[i - 1] <= arr[i]) {
                    left = i;
                    continue;
                }
            } else {
                if (arr[i] <= arr[i - 1]) {
                    left = i;
                    continue;
                }
            }

            res = Math.max(res, i - left + 1);

        }

        return res;
    }

    private int twoContion(int[] arr) {

        final int n = arr.length;
        int left = 0;
        int res = 1;

        for (int i = 1; i < n; i ++) {

            if (0 == i % 2) {
                if (arr[i] <= arr[i - 1]) {
                    left = i;
                    continue;
                }
            } else {
                if (arr[i - 1] <= arr[i]) {
                    left = i;
                    continue;
                }
            }

            res = Math.max(res, i - left + 1);

        }

        return res;
    }
}

159. 至多包含两个不同字符的最长子串

class Solution {

    private class Counter extends HashMap<Character, Integer> {

        public Integer get(Character key) {
            return super.containsKey(key) ? super.get(key) : 0;
        }

        public void add(Character key, Integer value) {
            super.put(key, this.get(key) + value);
            if (0 == this.get(key)) {
                super.remove(key);
            }
        }

    }

    public int lengthOfLongestSubstringTwoDistinct(String s) {
       
        final int n = s.length();
        int left = -1;
        int res = 0;
        Counter counter = new Counter();

        for (int i = 0; i < n; i ++) {

            counter.add(s.charAt(i), 1);

            while (counter.size() > 2) {
                left ++;
                counter.add(s.charAt(left), -1);
            }

            res = Math.max(res, i - left);

        }

        return res;

    }
}

340. 至多包含 K 个不同字符的最长子串

class Solution {
    
    private class Counter extends HashMap<Character, Integer> {

        public Integer get(Character key) {
            return super.containsKey(key) ? super.get(key) : 0;
        }

        public void add(Character key, Integer value) {
            super.put(key, this.get(key) + value);
            if (0 == this.get(key)) {
                super.remove(key);
            }
        }

    }

    public int lengthOfLongestSubstringKDistinct(String s, int k) {
        
        final int n = s.length();
        int left = -1;
        int res = 0;
        Counter counter = new Counter();

        for (int i = 0; i < n; i ++) {

            counter.add(s.charAt(i), 1);

            while (counter.size() > k) {
                left ++;
                counter.add(s.charAt(left), -1);
            }

            res = Math.max(res, i - left);

        }

        return res;
    }
}

795. 区间子数组个数

class Solution {
    public int numSubarrayBoundedMax(int[] nums, int left, int right) {
        return numSubarrayBoundedMax(nums, right) - numSubarrayBoundedMax(nums, left - 1);
    }

    private int numSubarrayBoundedMax(int[] nums, int k) {

        final int n = nums.length;
        int left = -1;
        int res = 0;

        for (int i = 0; i < n; i ++) {

            if (nums[i] > k) {
                left = i;
                continue;
            }

            res += (i - left);


        }

        return res;

    }
}

// https://leetcode-cn.com/leetbook/read/sliding-window-and-two-pointers/riika5/

剑指 Offer II 009. 乘积小于 K 的子数组

class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {

        final int n = nums.length;
        int res = 0;
        int sum = 1;
        int left = -1;

        for (int i = 0; i < n; i ++) {

            sum *= nums[i];

            while (left < i && sum >= k) {
                left ++;
                sum /= nums[left];
            }

            res += (i - left);
        }

        return res;
    }
}

// https://kaiwu.lagou.com/course/courseInfo.htm?courseId=685#/content
远腾飞
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Day2 数据结构与算法(Java)----数组（双指针），滑动窗口
qq_52698263的博客
11-17 405
数组深入，双指针法，滑动窗口,注意左闭右开区间。力扣题库
《算法系列》之滑动窗口
小夏陌的博客
08-20 1353
其实滑动窗口是一类特殊的双指针类型题，两个指针同向移动，我们更关心两个指针内所包含的数据，这时就可以称为滑动窗口类型的题了。
Leetcode-滑动窗口
m0_50536492的博客
01-23 252
Leetcode-滑动窗口滑动窗口模板及例题例题理解相关例题Leetcode 1208.尽可能使字符串相等Leetcode 3.无重复字符的最长字串Leetcode 1934 最短超串 滑动窗口模板及例题 滑动窗口为了解决时间复杂度而提出的一种优化方法，一般可以在O(n)的时间复杂度下解决O(n2)的问题，因此这里进行提供模板，以及Leetcode例题方便读者进行理解。 例题理解 下面我们首先给出一道Leetcode中的例题来进行理解，并给出解题模板。 Leetcode 最长连续子串 题目要求 给定一个字符
【LeetCode】双指针 & 滑动窗口
dropout的博客
10-13 251
双指针是指在算法中同时使用两个指针来追踪数组或序列中的元素位置。这两个指针可以朝着相同方向移动，也可以朝着相反方向移动。在算法问题中，双指针通常用于在数组、链表或其他数据结构中执行一些特定的操作，如搜索、遍历、或找出满足条件的子序列等。
双指针和滑动窗口
Jachoc的博客
03-07 253
双指针和滑动窗口
java双指针和数组.zip
01-14
4. **滑动窗口**：计算数组中的最大/最小元素、平均值、中位数等，常用于动态数据统计。 三、双指针策略 1. **左右指针**：从数组的两端开始，逐渐缩小搜索范围，如查找并删除有序数组中的重复元素。 2. **单边扫描...
滑动窗口刷题笔记, 针对初学滑动窗口的人员合适
04-03
滑动窗口的核心是使用两个指针，一个指向窗口的开始（left），另一个指向窗口的结束（right）。初始时，left和right都位于数组或字符串的起始位置。随着right向右移动，窗口不断扩大；当满足特定条件时，left会向右...
计算机网络 滑动窗口协议
05-03
在提供的C源代码清单中，可以看到与滑动窗口协议相关的部分，特别是涉及到内存管理和流量控制的策略。代码中的一些关键变量和函数如下： 1. `tcp_memory_allocated`：这是一个原子变量，用于跟踪当前分配给TCP连接...
专题篇：滑动窗口1
08-03
滑动窗口是算法中一种非常重要的思想，常用于解决数组或字符串中与连续子序列相关的题目。这个专题我们将深入探讨滑动窗口的概念、应用以及它如何优化算法的效率。 滑动窗口可以理解为一个在数据结构（如数组或链表...
dam-滑动窗口demo
最新发布
05-04
滑动窗口是一种在数据处理和算法设计中广泛使用的概念，特别是在计算机网络、数据流分析、时间序列分析以及并发控制等领域。...理解和掌握滑动窗口的原理与实现，对于提升数据处理能力、优化系统性能具有重要意义。
Leetcode算法入门与数组丨6. 数组双指针、滑动窗口
AXYZdong的博客
09-24 324
算法入门与数组之——数组双指针、滑动窗口，包括双指针基础知识、 双指针简介、左右指针（对撞指针）、快慢指针、分离双指针、滑动窗口基础知识、滑动窗口算法介绍、滑动窗口适用范围、固定长度滑动窗口和不固定长度滑动窗口。
双指针 & 滑动窗口
一蓑烟雨任平生
11-14 2537
快慢指针 解决主要解决链表中的问题，比如典型的判定链表中是否包含环 快慢指针一般都初始化指向链表的头结点head，前进时快指针fast在前，慢指针slow在后，巧妙解决一些链表中的问题。 1、判定链表中是否含有环 用两个指针，一个跑得快，一个跑得慢。如果不含有环，跑得快的那个指针最终会遇到null，说明链表不含环；如果含有环，快指针最终会超慢指针一圈，和慢指针相遇，说明链表含有环。 2、已知链表中含有环，返回这个环的起始位置 当快慢指针相遇时，让其中任一个指针指向头节点，然后让它俩以相同速度前进
详解双指针算法（三）之滑动窗口
weixin_74119644的博客
09-10 273
上一期我主要讲了一般类型的双指针，对于解决数组划分或按需求遍历数组的问题，该算法能极大程度地提高效率这一期我主要讲解滑动窗口算法，该算法常用于解决找子数组或找子串的问题，同一般类型的双指针，滑动窗口也能极大程度降低时间复杂度滑动窗口算法都可以通过暴力解法优化而来概念滑动窗口通常定义 left 和 right 两个指针，两指针同向移动，指针需要通过判断区间 [ left , right ] 是否合法来决定指针的走向；
滑动窗口与双指针的区别
wangmj_hdu的博客
02-22 4206
双指针 计算过程仅与两端点相关的称为双指针。 不固定大小。 双指针是解决问题的一种方法。 双指针可以同向移动可以双向移动。 同向移动的双指针和滑动窗口没有任何联系 滑动窗口 计算过程与两端点表示的区间相关的称为滑动窗口。 默认固定大小的窗口，在一些条件触发的情况下，可能会将其大小进行修改。 滑动窗口本身并不是解决问题的一种方法（或者说算法），它其实就是问题本身。 滑动窗口一定是同向移动的。 滑动窗口是一类问题，不同的问题需要使用不同的算法和数据结构来解决。 ...
数组双指针、滑动窗口
xjl13007043300的博客
11-27 473
学习资料来源： 【算法通关手册】：https://algo.itcharge.cn/ 【datawhale组队学习】https://github.com/datawhalechina/team-learning 大多是对这次组队学习的学习资料的学习笔记，非原创~ 另外时间原因滑动窗口部分暂时还没有时间写博客，之后会补上~ 数组双指针 双指针简介 双指针（Two Pointers）：指的是在遍历元素的过程中，不是使用单个指针进行访问，而是使用两个指针进行访问，从而达到相应的目的。 对撞时针：两个指针方向相反
学习笔记 | 双指针、滑动窗口、快慢指针
大虎牙的博客
10-10 686
双指针，two pointers 所谓双指针，指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向或者相反方向的指针进行扫描，从而达到相应的目的。(移动两个指针包夹求解） 时间复杂度一般为O(n) 掌握: 递增整数序列中，哪两个元素之和等于target 使用下标i，j对序列进行扫描(可以同向扫描，也可以反向扫描) 利用序列递增的性质,以浅显的思想降低了时间复杂度...
二、数组（双指针和滑动窗口）
LJYYYY的博客
07-19 239
双指针： 设置两个不同的指针 ，或者头，或者尾。在一个递增的序列中， 根据结果分类，说明指针的下一步应该怎么移动。 例： 给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 说明：你不能倾斜容器。 示例 1： 输入：[1,8,6,2,5,4,8,3,7] 输出：49 解释：图中垂直线代表输入数组 [1,8,6,2
【算法笔记】数组篇-双指针以及滑动窗口
computs的博客
01-14 512
27. 移除元素 分析：解1 暴力解法：从前往后遍历，遇到相等的就整体往前 int removeElement(vector<int>& nums, int val) { int len=nums.size(); for(int i=0;i<len;i++){ if(nums[i]==val){ for(int j=i;j<len.
双索引技巧 - 滑动窗口
05-31
双索引技巧和滑动窗口经常一起使用。滑动窗口是一种用于解决数组/字符串中子元素问题的算法。它可以将嵌套的循环问题，转换为单循环问题，降低时间复杂度。 滑动窗口通常使用双索引技巧来实现。它使用两个指针来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值