【算法】滑动窗口题单——2.不定长滑动窗口（求最长/最大）

news2024/9/24 4:20:42

文章目录

  • 3. 无重复字符的最长子串
  • 1493. 删掉一个元素以后全为 1 的最长子数组
  • 904. 水果成篮
  • 1695. 删除子数组的最大得分
  • 2841. 几乎唯一子数组的最大和
  • 2024. 考试的最大困扰度
  • 1004. 最大连续1的个数 III
  • 1438. 绝对差不超过限制的最长连续子数组
  • 2401. 最长优雅子数组
    • 解法1——维护窗口内int各位出现的次数
    • 解法2——利用位运算的性质 维护窗口🐂
  • 1658. 将 x 减到 0 的最小操作数
  • 1838. 最高频元素的频数
  • 2831. 找出最长等值子数组
    • 解法1——双哈希表：频次哈希表 和 频次的频次哈希表
    • 解法2——分组 + 双指针 🐂
  • 2106. 摘水果
  • 1610. 可见点的最大数目⭐（坐标转换成极角）
  • 159. 至多包含两个不同字符的最长子串
  • 340. 至多包含 K 个不同字符的最长子串

题单来源： https://leetcode.cn/problems/minimum-size-subarray-in-infinite-array/solutions/2464878/hua-dong-chuang-kou-on-shi-jian-o1-kong-cqawc/

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

https://leetcode.cn/problems/longest-substring-without-repeating-characters/description/

在这里插入图片描述
提示：
0 <= s.length <= 5 * 10^4
s 由英文字母、数字、符号和空格组成

枚举右端点，根据窗口内计数情况移动左端点。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int ans = 0;
        int[] cnt = new int[128];
        for (int l = 0, r = 0; r < s.length(); ++r) {
            char ch = s.charAt(r);
            cnt[ch]++;
            while (cnt[ch] > 1) cnt[s.charAt(l++)]--;
            ans = Math.max(r - l + 1, ans);
        }
        return ans;
    }
}

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

https://leetcode.cn/problems/longest-subarray-of-1s-after-deleting-one-element/description/

在这里插入图片描述
提示：

1 <= nums.length <= 10^5
nums[i] 要么是 0 要么是 1 。

窗口内最多有 1 个0，用 id 记录上一个出现 0 的位置，当出现新的 0 时，将左端点设置为 l = id + 1。 这样就保持了窗口内始终最多有 1 个 0。

class Solution {
    public int longestSubarray(int[] nums) {
        int n = nums.length, ans = 0;
        for (int l = 0, r = 0, id = -1; r < n; ++r) {
            if (nums[r] == 0) {
                l = id + 1;
                id = r;
            }
            ans = Math.max(r - l, ans);
        }
        return ans;
    }
}

904. 水果成篮

https://leetcode.cn/problems/fruit-into-baskets/description/
在这里插入图片描述
提示：

1 <= fruits.length <= 10^5
0 <= fruits[i] < fruits.length

class Solution {
    public int totalFruit(int[] fruits) {
        Map<Integer, Integer> m = new HashMap<>();
        int ans = 0;
        for (int l = 0, r = 0; r < fruits.length; ++r) {
            m.merge(fruits[r], 1, Integer::sum);
            while (m.size() > 2) {
                m.merge(fruits[l], -1, Integer::sum);
                if (m.get(fruits[l]) == 0) m.remove(fruits[l]);
                l++;
            }
            ans = Math.max(ans, r - l + 1);
        }
        return ans;
    }
}

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

https://leetcode.cn/problems/maximum-erasure-value/description/

在这里插入图片描述

提示：

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^4

class Solution {
    public int maximumUniqueSubarray(int[] nums) {
        int n = nums.length, ans = 0, s = 0;
        int[] cnt = new int[10001];
        for (int l = 0, r = 0; r < n; ++r) {
            s += nums[r];
            cnt[nums[r]]++;
            while (cnt[nums[r]] > 1) {
                s -= nums[l];
                cnt[nums[l++]]--;
            }
            if (s > ans) ans = s;
        }
        return ans;
    }
}

用 s > ans 判断会比使用 s = Math.max(ans, s) 快一些。

2841. 几乎唯一子数组的最大和

https://leetcode.cn/problems/maximum-sum-of-almost-unique-subarray/description/

在这里插入图片描述

提示：

1 <= nums.length <= 2 * 10^4
1 <= m <= k <= nums.length
1 <= nums[i] <= 10^9

class Solution {
    public long maxSum(List<Integer> nums, int m, int k) {
        long ans = 0, n = nums.size(), s = 0;
        Map<Integer, Integer> cnt = new HashMap<>();
        for (int i = 0; i < k - 1; ++i) {
            s += nums.get(i);
            cnt.merge(nums.get(i), 1, Integer::sum);
        }
        for (int l = 0, r = k - 1; r < n; ++l, ++r) {
            s += nums.get(r);
            cnt.merge(nums.get(r), 1, Integer::sum);
            if (cnt.size() >= m) ans = Math.max(ans, s);
            s -= nums.get(l);
            cnt.merge(nums.get(l), -1, Integer::sum);
            if (cnt.get(nums.get(l)) == 0) cnt.remove(nums.get(l));
        }
        return ans;
    }
}

2024. 考试的最大困扰度

https://leetcode.cn/problems/maximize-the-confusion-of-an-exam/description/

在这里插入图片描述

提示：
n == answerKey.length
1 <= n <= 5 * 10^4
answerKey[i] 要么是 'T' ，要么是 'F'
1 <= k <= n

维护一个滑动窗口，枚举右端点，当窗口中T和F的较小数量大于k时，将左端点向右移。
在这个过程中用窗口长度更新答案。

class Solution {
    public int maxConsecutiveAnswers(String answerKey, int k) {
        int n = answerKey.length(), ans = 0;
        int t = 0, f = 0;
        for (int l = 0, r = 0; r < n; ++r) {
            char a = answerKey.charAt(r);
            if (a == 'T') t++;
            else f++;
            // 将左端点向右移
            while (t > k && f > k) {
                a = answerKey.charAt(l++);
                if (a == 'T') t--;
                else f--;
            }
            ans = Math.max(r - l + 1, ans);
        }
        return ans;
    }
}

1004. 最大连续1的个数 III

https://leetcode.cn/problems/max-consecutive-ones-iii/description/

在这里插入图片描述

提示：

1 <= nums.length <= 10^5
nums[i] 不是 0 就是 1
0 <= k <= nums.length

维护一个窗口中最多出现 k 个 0 的滑动窗口。

class Solution {
    public int longestOnes(int[] nums, int k) {
        int n = nums.length, c0 = 0, ans = 0;
        for (int l = 0, r = 0; r < n; ++r) {
            if (nums[r] == 0) c0++;
            while (c0 > k) {
                if (nums[l++] == 0) c0--;
            }
            ans = Math.max(r - l + 1, ans);
        }
        return ans;
    }
}

1438. 绝对差不超过限制的最长连续子数组

https://leetcode.cn/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/description/

在这里插入图片描述

提示：

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
0 <= limit <= 10^9

同时维护窗口内的最大值和最小值。
可以使用 TreeMap 或者 单调队列来做。

class Solution {
    public int longestSubarray(int[] nums, int limit) {
        TreeMap<Integer, Integer> tm = new TreeMap<>();
        int ans = 0;
        for (int l = 0, r = 0; r < nums.length; ++r) {
            tm.merge(nums[r], 1, Integer::sum);
            while (tm.lastKey() - tm.firstKey() > limit) {
                tm.merge(nums[l], -1, Integer::sum);
                if (tm.get(nums[l]) == 0) tm.remove(nums[l]);
                l++;
            }
            ans = Math.max(r - l + 1, ans);
        }
        return ans;
    }
}

2401. 最长优雅子数组

https://leetcode.cn/problems/longest-nice-subarray/description/

在这里插入图片描述

提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9

解法1——维护窗口内int各位出现的次数

题目要求即为int的32位中，每一位都最多出现一次。

class Solution {
    public int longestNiceSubarray(int[] nums) {
        int n = nums.length, ans = 0;
        int[] cnt = new int[32];
        for (int l = 0, r = 0; r < n; ++r) {
            op(cnt, nums[r], 1);
            while (!check(cnt)) op(cnt, nums[l++], -1);
            ans = Math.max(ans, r - l + 1);
        }
        return ans;
    }

    public void op(int[] cnt, int x, int m) {
        for (int i = 0; i < cnt.length; ++i) {
            if ((x >> i & 1) == 1) cnt[i] += m;
        }
    }

    public boolean check(int[] cnt) {
        for (int c: cnt) {
            if (c > 1) return false;
        }
        return true;
    }
}

解法2——利用位运算的性质 维护窗口🐂

充分 利用了 & ^ | 三种运算的性质。

使用 & 判断是否有交集。
使用 ^ 模拟去除。
使用 | 模拟加入。

class Solution {
    public int longestNiceSubarray(int[] nums) {
        int ans = 0;
        for (int left = 0, right = 0, or = 0; right < nums.length; right++) {
            // 有交集
            while ((or & nums[right]) > 0) {
                or ^= nums[left++]; // 从 or 中去掉集合 nums[left]
            }
            or |= nums[right];      // 把集合 nums[right] 并入 or 中
            ans = Math.max(ans, right - left + 1);
        }
        return ans;
    }
}

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

https://leetcode.cn/problems/minimum-operations-to-reduce-x-to-zero/description/

在这里插入图片描述

提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^4
1 <= x <= 10^9

等价于找到窗口内和为 sum - x 的最长子数组的长度。

class Solution {
    public int minOperations(int[] nums, int x) {
        // 等价于找到窗口内和为 sum - x 的最长子数组的长度。
        int n = nums.length, t = Arrays.stream(nums).sum() - x, ans = -1, s = 0;
        for (int l = 0, r = 0; r < n; ++r) {
            s += nums[r];
            while (l <= r && s > t) s -= nums[l++];
            if (s == t) ans = Math.max(ans, r - l + 1); 
        }
        return ans != -1? n - ans: -1;
    }
}

1838. 最高频元素的频数

https://leetcode.cn/problems/frequency-of-the-most-frequent-element/description/

在这里插入图片描述

提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= k <= 10^5

排序 + 滑动窗口。
每个窗口都假设变成最大的那个数字，不能变的移出窗口。

class Solution {
    public int maxFrequency(int[] nums, int k) {
        Arrays.sort(nums);
        int n = nums.length, ans = 1;
        long s = 0;
        for (int l = 0, r = 0; r < n; ++r) {
            s += nums[r];
            while ((long)(r - l + 1) * nums[r] - k > s) s -= nums[l++];
            if ((long)(r - l + 1) * nums[r] - k <= s) ans = Math.max(ans, r - l + 1);
        }
        return ans;
    }
}

2831. 找出最长等值子数组

https://leetcode.cn/problems/find-the-longest-equal-subarray/description/

在这里插入图片描述

提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= nums.length
0 <= k <= nums.length

解法1——双哈希表：频次哈希表 和 频次的频次哈希表

频次的频次哈希表 用于 快速找到最大的频次。

class Solution {
    public int longestEqualSubarray(List<Integer> nums, int k) {
        int n = nums.size(), ans = 0;
        Map<Integer, Integer> cnt = new HashMap<>();
        // 频次 哈希表 ，用于快速找到最大的频次
        TreeMap<Integer, Integer> pCnt = new TreeMap<>();
        for (int l = 0, r = 0; r < n; ++r) {
            cnt.merge(nums.get(r), 1, Integer::sum);
            pCnt.merge(cnt.get(nums.get(r)), 1, Integer::sum);
            pCnt.merge(cnt.get(nums.get(r)) - 1, -1, Integer::sum);
            while (r - l + 1 - pCnt.lastKey() > k) {
                cnt.merge(nums.get(l), -1, Integer::sum);
                pCnt.merge(cnt.get(nums.get(l)), 1, Integer::sum);
                pCnt.merge(cnt.get(nums.get(l)) + 1, -1, Integer::sum);
                if (pCnt.get(cnt.get(nums.get(l)) + 1) == 0) pCnt.remove(cnt.get(nums.get(l)) + 1);
                l++;
            }
            ans = Math.max(pCnt.lastKey(), ans);
        }
        return ans;
    }
}

解法2——分组 + 双指针 🐂

https://leetcode.cn/problems/find-the-longest-equal-subarray/solutions/2396401/fen-zu-shuang-zhi-zhen-pythonjavacgo-by-lqqau/

算法思路见下图。
在这里插入图片描述

class Solution {
    public int longestEqualSubarray(List<Integer> nums, int k) {
        int n = nums.size(), ans = 0;
        Map<Integer, List<Integer>> m = new HashMap<>();
        for (int i = 0; i < n; ++i) {
            if (!m.containsKey(nums.get(i))) {
                m.put(nums.get(i), new ArrayList<>());
            }
            List<Integer> ls = m.get(nums.get(i));
            ls.add(i - ls.size());
        }
        for (List<Integer> ls: m.values()) {
            int res = 0;
            for (int l = 0, r = 0; r < ls.size(); ++r) {
                while (ls.get(r) - ls.get(l) > k) l++;
                res = Math.max(res, r - l + 1);
            }
            ans = Math.max(ans, res);
        }
        return ans;
    }
}

2106. 摘水果

https://leetcode.cn/problems/maximum-fruits-harvested-after-at-most-k-steps/description/

在这里插入图片描述

在这里插入图片描述

维护一个窗口，窗口中是可以被采集的水果。
随着右端点的枚举，左端点也会随着窗口的扩大导致不合理，从而将左端点右移。

class Solution {
    public int maxTotalFruits(int[][] fruits, int startPos, int k) {
        int ans = 0, s = 0;
        for (int l = 0, r = 0; r < fruits.length; ++r) {
            s += fruits[r][1];
            while (l <= r && !check(fruits[l][0], fruits[r][0], startPos, k)) s-= fruits[l++][1];
            ans = Math.max(ans, s);
        }
        return ans;
    }

    // 检查窗口是否合理
    public boolean check(int a, int b, int x, int k) {
        if (a <= x && b <= x) return x - a <= k;    // 都在左边
        if (a >= x && b >= x) return b - x <= k;    // 都在右边
        // a在左边，b在右边
        a = x - a;
        b = b - x;
        return Math.min(a, b) * 2 + Math.max(a, b) <= k;
    }
}

1610. 可见点的最大数目⭐（坐标转换成极角）

https://leetcode.cn/problems/maximum-number-of-visible-points/description/

在这里插入图片描述

在这里插入图片描述

提示：
1 <= points.length <= 10^5
points[i].length == 2
location.length == 2
0 <= angle < 360
0 <= posx, posy, xi, yi <= 100

坐标转成极角的方法为 Math.atan2()，见：https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Math.html#atan2(double,double)

将极角存入列表之后，再重复加入 + 2pi 的元素，这是为了计算完全。
最后使用滑动窗口计算。

class Solution {
    public int visiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {
        int sameCnt = 0;
        List<Double> polarDegrees = new ArrayList<>();
        int x0 = location.get(0), y0 = location.get(1);
        for (int i = 0; i < points.size(); ++i) {
            int x = points.get(i).get(0), y = points.get(i).get(1);
            if (x == x0 && y == y0) {
                sameCnt++;
                continue;
            }
            Double degree = Math.atan2(y - y0, x - x0);
            polarDegrees.add(degree);
        }
        Collections.sort(polarDegrees);

        int m = polarDegrees.size();
        for (int i = 0; i < m; ++i) {
            polarDegrees.add(polarDegrees.get(i) + 2 * Math.PI);
        }

        int maxCnt = 0;
        double toDegree = angle * Math.PI / 180;
        for (int l = 0, r = 0; l < m; ++l) {
            Double curr = polarDegrees.get(l) + toDegree;
            while (r < polarDegrees.size() && polarDegrees.get(r) <= curr) {
                r++;
            }
            maxCnt = Math.max(maxCnt, r - l);
        }

        return maxCnt + sameCnt;
    }
}

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

https://leetcode.cn/problems/longest-substring-with-at-most-two-distinct-characters/description/

在这里插入图片描述

维护各个字符的出现次数，当哈希表中字符种类大于 2 的时候将左端点右移。

class Solution {
    public int lengthOfLongestSubstringTwoDistinct(String s) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> cnt = new HashMap<>();
        for (int l = 0, r = 0; r < n; ++r) {
            cnt.merge(s.charAt(r), 1, Integer::sum);
            while (cnt.size() > 2) {
                cnt.merge(s.charAt(l), -1, Integer::sum);
                if (cnt.get(s.charAt(l)) == 0) cnt.remove(s.charAt(l));
                l++;
            }
            ans = Math.max(ans, r - l + 1);
        }
        return ans;
    }
}

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

https://leetcode.cn/problems/longest-substring-with-at-most-k-distinct-characters/description/

在这里插入图片描述

把上一题的 2 换成 k 就好了。

class Solution {
    public int lengthOfLongestSubstringKDistinct(String s, int k) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> cnt = new HashMap<>();
        for (int l = 0, r = 0; r < n; ++r) {
            cnt.merge(s.charAt(r), 1, Integer::sum);
            while (cnt.size() > k) {
                cnt.merge(s.charAt(l), -1, Integer::sum);
                if (cnt.get(s.charAt(l)) == 0) cnt.remove(s.charAt(l));
                l++;
            }
            ans = Math.max(ans, r - l + 1);
        }
        return ans;
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1228357.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

nodejs微信小程序-实验室上机管理系统的设计与实现-安卓-python-PHP-计算机毕业设计

nodejs微信小程序-实验室上机管理系统的设计与实现-安卓-python-PHP-计算机毕业设计

用户&#xff1a;管理员、教师、学生 基础功能&#xff1a;管理课表、管理机房情况、预约机房预约&#xff1b;权限不同&#xff0c;预约类型不同&#xff0c;教师可选课堂预约和个人&#xff1b;课堂预约。 目 录 摘 要 I ABSTRACT II 目 录 II 第1章 绪论 1 1.1背景及意义 1 …
阅读更多...
容斥 C. Strange Function改编题

容斥 C. Strange Function改编题

补题&#xff1a; 题目详情 - 9.段坤爱取模%%% - SUSTOJ 本题或许是参考 Problem - C - Codeforces 根据题意&#xff0c;f(i)就是不能被整除的最小的一个质因子。 打表发现&#xff0c;当15个质因子相乘后&#xff0c;长度就大于18。 因此可以知道小于等于1e16内的正整数x…
阅读更多...
（动手学习深度学习）第13章 计算机视觉---微调

（动手学习深度学习）第13章 计算机视觉---微调

文章目录 微调总结 微调代码实现 微调 总结 微调通过使用在大数据上的恶道的预训练好的模型来初始化模型权重来完成提升精度。预训练模型质量很重要微调通常速度更快、精确度更高 微调代码实现 导入相关库 %matplotlib inline import os import torch import torchvision f…
阅读更多...
java文件压缩加密，使用流的方式

java文件压缩加密，使用流的方式

使用net.lingala.zip4j来进行文件加密压缩。 添加依赖net.lingala.zip4j包依赖&#xff0c;这里使用的是最新的包2.11.5版本。 <dependency><groupId>net.lingala.zip4j</groupId><artifactId>zip4j</artifactId><version>${zip4j.versi…
阅读更多...
丹麦能源袭击预示着更关键的基础设施成为目标

丹麦能源袭击预示着更关键的基础设施成为目标

5 月&#xff0c;22 个丹麦能源部门组织在与俄罗斯 Sandworm APT 部分相关的攻击中受到损害。 丹麦关键基础设施安全非营利组织 SektorCERT 的一份新报告描述了不同的攻击者群体利用合勤防火墙设备中的多个关键漏洞&#xff08;包括两个零日漏洞&#xff09;侵入工业机械&…
阅读更多...
Dockerfile自定义镜像以及案例分析

Dockerfile自定义镜像以及案例分析

文章目录 一、Dockerfile自定义镜像1.1 镜像结构1.2 Dockerfile语法 二、构建Java项目三、基于java8构建java四、小结 一、Dockerfile自定义镜像 常见的镜像在DockerHub就能找到&#xff0c;但是我们自己写的项目就必须自己构建镜像了。 而要自定义镜像&#xff0c;就必须先了…
阅读更多...
boomYouth

boomYouth

上一周实在是过得太颓废了&#xff0c;我感觉还是要把自己的规划做好一下&#xff1a; 周计划 这周截至周四&#xff0c;我可以用vue简单的画完登陆注册的界面并且弄一点预处理&#xff1a; 周一 的话可以把这些都学一下&#xff1a; 父传子&#xff0c;子传父&#xff1a…
阅读更多...
配置iTerm2打开自动执行命令

配置iTerm2打开自动执行命令

打开iTerm2&#xff0c;commado&#xff0c;打开profies->edit profies&#xff0c;点击号&#xff0c;创建一个新的profile 在新的profile中填写 name&#xff1a;随意 command&#xff1a;Login Shell Send text at start&#xff1a;执行脚本的命令&#xff0c;不想写路…
阅读更多...
python django 小程序图书借阅源码

python django 小程序图书借阅源码

开发工具&#xff1a; PyCharm&#xff0c;mysql5.7&#xff0c;微信开发者工具 技术说明&#xff1a; python django html 小程序 功能介绍&#xff1a; 用户端&#xff1a; 登录注册&#xff08;含授权登录&#xff09; 首页显示搜索图书&#xff0c;轮播图&#xff0…
阅读更多...
某60区块链安全之不安全的随机数实战一

某60区块链安全之不安全的随机数实战一

区块链安全 文章目录 区块链安全不安全的随机数实战一实验目的实验环境实验工具实验原理实验内容攻击过程分析合约源代码漏洞EXP利用 不安全的随机数实战一 实验目的 学会使用python3的web3模块 学会以太坊不安全的随机数漏洞分析及利用 实验环境 Ubuntu18.04操作机 实验工…
阅读更多...
环境配置|GitHub——解决Github无法显示图片以及README无法显示图片

环境配置|GitHub——解决Github无法显示图片以及README无法显示图片

一、问题背景 最近在整理之前写过的实验、项目&#xff0c;打算把这些东西写成blog&#xff0c;并把工程文件整理上传到Github上。但在上传README文件的时候&#xff0c;发现github无法显示README中的图片&#xff0c;如下图所示&#xff1a; 在README中该图片路径为&#xff1…
阅读更多...
Unity Meta Quest 一体机开发（七）：配置玩家 Hand Grab 功能

Unity Meta Quest 一体机开发（七）：配置玩家 Hand Grab 功能

文章目录 &#x1f4d5;教程说明&#x1f4d5;玩家物体配置 Hand Grab Interactor⭐添加 Hand Grab Interactor 物体⭐激活 Hand Grab Visual 和 Hand Grab Glow⭐更新 Best Hover Interactor Group &#x1f4d5;配置可抓取物体&#xff08;无抓取手势&#xff09;⭐刚体和碰撞…
阅读更多...
【算法】树形DP③ 监控二叉树 ⭐（二叉树染色二叉树灯饰）！

【算法】树形DP③ 监控二叉树 ⭐（二叉树染色二叉树灯饰）！

文章目录 前期知识 & 相关链接例题968. 监控二叉树解法1——标记状态贪心解法2——动态规划 相关练习题目P2458 [SDOI2006] 保安站岗⭐&#xff08;有多个儿子节点&#xff09;&#x1f6b9;LCP 34. 二叉树染色⭐&#xff08;每个节点 单独dp[k 1]数组&#xff09;LCP 64.…
阅读更多...
时间序列预测实战(十七)利用Prophet实现电力负荷长期预测（附代码+数据集+详细讲解）

时间序列预测实战(十七)利用Prophet实现电力负荷长期预测（附代码+数据集+详细讲解）

一、本文介绍 Prophet是一个由Facebook开发的开源工具&#xff0c;用于时间序列预测。这个工具特别适合于具有强季节性影响和多个历史数据季节的业务时间序列数据。Prophet的主要思想是将数据分解为如下三个部分&#xff1a;趋势、季节性、节假日和特殊事件。这个模型非常适合…
阅读更多...
GIT无效的源路径/URL

GIT无效的源路径/URL

ssh-add /Users/haijunyan/.ssh/id_rsa ssh-add -K /Users/haijunyan/.ssh/id_rsa
阅读更多...
SQL基础理论篇（七）：多表关联的连接算法

SQL基础理论篇（七）：多表关联的连接算法

文章目录 简介Nested LoopsMerge JoinHash Join总结参考文献 简介 多表之间基础的关联算法一共有三种&#xff1a; Hash JoinNested LoopsMerge Join 还有很多基于这三种基础算法的变体&#xff0c;以Nested Loops为例&#xff0c;就有用于in和exist的半连接&#xff08;Nes…
阅读更多...
【Android Jetpack】Hilt的理解与浅析

【Android Jetpack】Hilt的理解与浅析

文章目录 依赖注入DaggerHiltKoin添加依赖项Hilt常用注解的含义HiltAndroidAppAndroidEntryPointInjectModuleInstallInProvidesEntryPoint Hilt组件生命周期和作用域如何使用 Hilt 进行依赖注入 本文只是进行了简单入门&#xff0c;博客仅当做笔记用。 依赖注入 依赖注入是一…
阅读更多...
文档向量化工具（一）：Apache Tika介绍

文档向量化工具（一）：Apache Tika介绍

Apache Tika是什么&#xff1f;能干什么&#xff1f; Apache Tika是一个内容分析工具包。 该工具包可以从一千多种不同的文件类型&#xff08;如PPT、XLS和PDF&#xff09;中检测并提取元数据和文本。 所有这些文件类型都可以通过同一个接口进行解析&#xff0c;这使得Tika在…
阅读更多...
node实战——koa实现文件上传

node实战——koa实现文件上传

文章目录 ⭐前言⭐koa实现文件上传⭐foxapi测试⭐总结⭐结束⭐前言 大家好，我是yma16，本文分享关于node实战——node实战——koa实现文件上传。 本文适用对象：前端初学者转node方向，在校大学生，即将毕业的同学，计算机爱好者。 node系列往期文章 node_windows环境变量配置…
阅读更多...
Day35力扣打卡

Day35力扣打卡

打卡记录 相邻字符不同的最长路径&#xff08;树状DP&#xff09; 链接 若节点也存在父节点的情况下&#xff0c;传入父节点参数&#xff0c;若是遍历到父节点&#xff0c;直接循环里 continue。 class Solution:def longestPath(self, parent: List[int], s: str) -> in…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023