偷懒总结篇|贪心算法|动态规划|单调栈|图论

news2024/11/23 18:40:57

由于这周来不及了,先过一遍后面的思路,具体实现等下周再开始详细写。

贪心算法

这个图非常好

122.买卖股票的最佳时机 II(妙,拆分利润)

把利润分解为每天为单位的维度,需要收集每天的正利润就可以,收集正利润的区间,就是股票买卖的区间,而我们只需要关注最终利润,不需要记录区间

55. 跳跃游戏(妙,覆盖范围)

不用拘泥于每次究竟跳几步,而是看覆盖范围,覆盖范围内一定是可以跳过来的,不用管是怎么跳的。

45.跳跃游戏 II(难)

还是要看最大覆盖范围。

以最小的步数增加最大的覆盖范围,覆盖范围一旦覆盖了终点,得到的就是最少步数!不用管具体是怎么跳的,不纠结于一步究竟跳一个单位还是两个单位。

这里需要统计两个覆盖范围,当前这一步的最大覆盖和下一步最大覆盖

如果移动下标达到了当前这一步的最大覆盖最远距离了,还没有到终点的话,那么就必须再走一步来增加覆盖范围,直到覆盖范围覆盖了终点。

1005.K次取反后最大化的数组和(简单)

先让绝对值大的负数变为正数,当前数值达到最大;然后如果K依然大于0,只找数值最小的正整数进行反转。

  • 第一步:将数组按照绝对值大小从大到小排序,注意要按照绝对值的大小
  • 第二步:从前向后遍历,遇到负数将其变为正数,同时K--
  • 第三步:如果K还大于0,那么反复转变数值最小的元素,将K用完
  • 第四步:求和

将数组按照绝对值大小从大到小排序

nums = IntStream.of(nums)
		     .boxed()
		     .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))
		     .mapToInt(Integer::intValue).toArray();

对int[]数组元素求和

Arrays.stream(nums).sum()
        int ans = 0;
        for (int num : nums) {
            ans += num;
        }

134. 加油站(妙)

(补充:for循环适合模拟从头到尾的遍历,而while循环适合模拟环形遍历,要善于使用while!

当前累加rest[i]的和curSum一旦小于0,起始位置至少要是i+1,因为从i之前开始一定不行。全局最优:找到可以跑一圈的起始位置

135. 分发糖果(妙,2次贪心)

先确定一边之后,再确定另一边,例如比较每一个孩子的左边,然后再比较右边,如果两边一起考虑一定会顾此失彼

两次贪心的策略:

  • 一次是从左到右遍历,只比较右边孩子评分比左边大的情况。
  • 一次是从右到左遍历,只比较左边孩子评分比右边大的情况。
分两个阶段
1、起点下标1 从左往右,只要 右边 比 左边 大,右边的糖果=左边 + 1
2、起点下标 ratings.length - 2 从右往左, 只要左边 比 右边 大,
此时 左边的糖果应该 取本身的糖果数(符合比它左边大) 
和 右边糖果数 + 1 二者的最大值,这样才符合 
它比它左边的大,也比它右边大

860.柠檬水找零(简单)

直接统计five,ten的count就好了

  • 情况一:账单是5,直接收下。
  • 情况二:账单是10,消耗一个5,增加一个10
  • 情况三:账单是20,优先消耗一个10和一个5,如果不够,再消耗三个5

406.根据身高重建队列(难,妙,2次贪心)

本题有两个维度,h和k,看到这种题目一定要想如何确定一个维度,然后再按照另一个维度重新排列。

如果按照k来从小到大排序,排完之后,会发现k的排列并不符合条件,身高也不符合条件,两个维度哪一个都没确定下来。

那么按照身高h来排序呢,身高一定是从大到小排(身高相同的话则k小的站前面),让高个子在前面。

此时我们可以确定一个维度了,就是身高,前面的节点一定都比本节点高!

那么只需要按照k为下标重新插入队列就可以了

 二维数据排序

// 身高从大到小排(身高相同k小的站前面)
        Arrays.sort(people, (a, b) -> {
            if (a[0] == b[0]) return a[1] - b[1];   // a - b 是升序排列,故在a[0] == b[0]的狀況下,會根據k值升序排列
            return b[0] - a[0];   //b - a 是降序排列,在a[0] != b[0],的狀況會根據h值降序排列
        });

Linkedlist.add()

Linkedlist.add(index, value),会将value插入到指定index里

452. 用最少数量的箭引爆气球(重叠区间)

重叠区间问题:本质就是更新区间的边界

按照气球的起始位置排序

// int[][] points
Arrays.sort(points, (a, b) -> Integer.compare(a[0], b[0]));

如果气球重叠了,重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭

不需要移走气球,直接记录res++即可。

技巧:寻找重复的气球,寻找重叠气球最小右边界

points[i][1] = Math.min(points[i][1], points[i - 1][1]); // 更新重叠气球最小右边界

435. 无重叠区间(重叠区间)

本质还是排序+更新边界

有452,本题很好理解

763.划分字母区间(妙,重叠区间)

用最远出现距离模拟了圈字符的行为。思路很巧妙

  1. 统计每一个字符最后出现的位置
  2. 从头遍历字符,并更新字符的最远出现下标,如果找到字符最远出现位置下标和当前下标相等了,则找到了分割点

统计字符串S中每个字母char出现的最远位置

int[] edge = new int[26];
        char[] chars = S.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            edge[chars[i] - 'a'] = i;
        }
idx = Math.max(idx,edge[chars[i] - 'a']); // 更新right下标

56. 合并区间(简单,重叠区间)

没什么好说的,简单

//按照左边界排序
Arrays.sort(intervals, (x, y) -> Integer.compare(x[0], y[0]));

738.单调递增的数字(妙,flag的运用)

  1. 例如N=98,一旦出现strNum[i - 1] > strNum[i]的情况(非单调递增),首先想让strNum[i - 1]--,然后strNum[i]给为9,这样这个整数就是89,即小于98的最大的单调递增整数。
  2. 从后向前遍历:

    举个例子,数字:332,从前向后遍历的话,那么就把变成了329,此时2又小于了第一位的3了,真正的结果应该是299。

    那么从后向前遍历,就可以重复利用上次比较得出的结果了,从后向前遍历332的数值变化为:332 -> 329 -> 299

  3. 用一个flag(start)来标记从哪里开始赋值9。

// flag用来标记赋值9从哪里开始
// 设置为这个默认值,为了防止第二个for循环在flag没有被赋值的情况下执行

将一个 int 类型的整数 N 转换为字符串,然后将这个字符串按字符拆分为一个字符数组。

String[] strings = (N + "").split(""); 

String, char 与 int 的转换使用

class Solution {
    public int monotoneIncreasingDigits(int n) {
        String s = String.valueOf(n);
        char[] chars = s.toCharArray();
        int start = s.length();
        for (int i = s.length() - 2; i >= 0; i--) {
            if (chars[i] > chars[i + 1]) {
                chars[i]--;
                start = i+1;
            }
        }
        for (int i = start; i < s.length(); i++) {
            chars[i] = '9';
        }
        return Integer.parseInt(String.valueOf(chars));
    }
}

968.监控二叉树(难)

贪心+二叉树

麻烦的是判断出每个节点的状态与各种转移情况。考虑的细节比较繁多。

思路:从低到上遍历,先给叶子节点父节点放个摄像头,然后隔两个节点放一个摄像头,直至到二叉树头结点。

  1. 后序遍历:左右中
  2. 隔两个节点放一个摄像头(状态转移)

每个节点可能的三种状态:

  • 0:该节点无覆盖
  • 1:本节点有摄像头
  • 2:本节点有覆盖

空节点的状态只能是有覆盖,这样就可以在叶子节点的父节点放摄像头了

单层逻辑处理主要有如下四类情况:

  • 情况1:左右节点都有覆盖,中间节点应该就是无覆盖 return 0;
  • 情况2:左右节点至少有一个无覆盖的情况,中间节点放摄像头 result++,且return 1;
  • 情况3:左右节点至少有一个有摄像头,父节点就是覆盖 return 2;
  • 情况4:头结点没有覆盖 result++(以上都处理完了,递归结束之后,可能头结点 还有一个无覆盖的情况)

动态规划

动态规划中每一个状态一定是由上一个状态推导出来的,这一点就区分于贪心,贪心没有状态推导,而是从局部直接选最优的。

动态规划中dp[j]是由dp[j-weight[i]]推导出来的,然后取max(dp[j], dp[j - weight[i]] + value[i])。

动态规划的解题步骤

  1. 确定dp数组以及下标的含义
  2. 确定递推公式
  3. dp数组如何初始化
  4. 确定遍历顺序
  5. 举例推导dp数组

DP压缩节约空间复杂度:

  1. 一维数组可使用三个变量来代替数组(509,70,746)
  2. 二维数组可拆成2个一维数组

509. 斐波那契数(简单)

递归/dp都可以

70. 爬楼梯(妙)

爬楼梯居然是斐波那契的另一版本!

dp[i]: 爬到第i层楼梯,有dp[i]种方法

dp[i] = dp[i - 1] + dp[i - 2] (难在怎么确定递推公式)

dp[1] = 1,dp[2] = 2

从前向后遍历

746. 使用最小花费爬楼梯

  • dp[i]的定义:到达第i台阶所花费的最少体力为dp[i]。
  • dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);

可以有两个途径得到dp[i],一个是dp[i-1] 一个是dp[i-2]。

dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。

dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。

  • dp[0] = 0,dp[1] = 0;
  • 从前到后遍历cost数组
  • 打印dp

62.不同路径

  • dp[i][j] :表示从(0 ,0)出发,到(i, j) 有dp[i][j]条不同的路径。
  • dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
  • 如何初始化呢,首先dp[i][0]一定都是1,因为从(0, 0)的位置到(i, 0)的路径只有一条,那么dp[0][j]也同理。
  • dp[i][j]都是从其上方和左方推导而来,那么从左到右一层一层遍历就可以了。

本题可用动态规划,也可以用数论

数论方法(求组合问题)

无论怎么走,走到终点都需要 m + n - 2 步。

在这m + n - 2 步中,一定有 m - 1 步是要向下走的,不用管什么时候向下走。

那么有几种走法呢? 可以转化为,给你m + n - 2个不同的数,随便取m - 1个数,有几种取法。

求组合问题

 求组合的时候,要防止两个int相乘溢出! 所以不能把算式的分子都算出来,分母都算出来再做除法。

需要在计算分子的时候,不断除以分母

63. 不同路径 II

有障碍的话,其实就是标记对应的dp table(dp数组)保持初始值(0)就可以了。

  • dp[i][j] :表示从(0 ,0)出发,到(i, j) 有dp[i][j]条不同的路径。
  • 递推公式不变,加个if限制,如果没有障碍,再更新dp
  • 初始化一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作,dp[0][j]同理

343. 整数拆分(难)

  • dp[i]:分拆数字i,可以得到的最大乘积为dp[i]。
  • 递推公式:dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
  • 初始化dp[2] = 1
  • 从前向后遍历

j * (i - j) 是单纯的把整数拆分为两个数相乘,而j * dp[i - j]是拆分成两个以及两个以上的个数相乘。

拆分一个数n 使之乘积最大,那么一定是拆分成m个近似相同的子数相乘才是最大的

96. 不同的二叉搜索树(抽象思路,难)

难以想象,这个思路

  • dp[i] : 1到i为节点组成的二叉搜索树的个数为dp[i]。
  • dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]

  • dp[i] += dp[j - 1] * dp[i - j]; ,j-1 为j为头结点左子树节点数量,i-j 为以j为头结点右子树节点数量(j相当于是头结点的元素,从1遍历到i为止。)
  • 初始化dp[0] = 1。空节点也是一棵二叉树,也是一棵二叉搜索树
  • 遍历i里面每一个数作为头结点的状态,用j来遍历

背包问题

背包递推公式

  • 问能否能装满背包(或者最多装多少):dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);

  • 问装满背包有几种方法:dp[j] += dp[j - nums[i]] ;
  • 问背包装满最大价值:dp[j] = max(dp[j], dp[j - weight[i]] + value[i]); 
  • 问装满背包所有物品的最小个数:dp[j] = min(dp[j - coins[i]] + 1, dp[j]); 

遍历顺序

01背包
  • 二维dp数组01背包先遍历物品还是先遍历背包都是可以的,且第二层for循环是从小到大遍历。
  • 一维dp数组01背包只能先遍历物品再遍历背包容量,且第二层for循环是从大到小遍历。
完全背包
  • 纯完全背包的一维dp数组实现,先遍历物品还是先遍历背包都是可以的,且第二层for循环是从小到大遍历。
  • 如果求组合数就是外层for循环遍历物品,内层for遍历背包

  • 如果求排列数就是外层for遍历背包,内层for循环遍历物品

  • 如果求最小数,那么两层for循环的先后顺序就无所谓了

01背包

二维dp数组

  • dp[i][j] 表示从下标为[0-i]的物品里任意取,放进容量为j的背包,价值总和最大是多少
  • 递归公式: dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
  • 遍历顺序,先物品先背包都可以,从小到大
  1. 不放物品i:背包容量为j,里面不放物品i的最大价值是dp[i - 1][j]。

  2. 放物品i:背包空出物品i的容量后,背包容量为j - weight[i],dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]且不放物品i的最大价值,那么dp[i - 1][j - weight[i]] + value[i] (物品i的价值),就是背包放物品i得到的最大价值

二维背包模板

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int bagweight = scanner.nextInt();

        int[] weight = new int[n];
        int[] value = new int[n];

        for (int i = 0; i < n; ++i) {
            weight[i] = scanner.nextInt();
        }
        for (int j = 0; j < n; ++j) {
            value[j] = scanner.nextInt();
        }

        int[][] dp = new int[n][bagweight + 1];

        for (int j = weight[0]; j <= bagweight; j++) {
            dp[0][j] = value[0];
        }

        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= bagweight; j++) {
                if (j < weight[i]) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
                }
            }
        }

        System.out.println(dp[n - 1][bagweight]);
    }
}

一维dp数组(滚动数组)

滚动数组,需要满足的条件是上一层可以重复利用,直接拷贝到当前层。

  • dp[i][j] 表示从下标为[0-i]的物品里任意取,放进容量为j的背包,价值总和最大是多少。
  • dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

此时dp[j]有两个选择,一个是取自己dp[j] 相当于 二维dp数组中的dp[i-1][j],即不放物品i,一个是取dp[j - weight[i]] + value[i],即放物品i,指定是取最大的,毕竟是求最大价值。

  • 初始化为0
  • 先遍历物品,再遍历背包,并且背包是倒序遍历,否则物品就会被加入多次

一维背包模板

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取 M 和 N
        int M = scanner.nextInt();  // 研究材料的数量
        int N = scanner.nextInt();  // 行李空间的大小

        int[] costs = new int[M];   // 每种材料的空间占用
        int[] values = new int[M];  // 每种材料的价值

        // 输入每种材料的空间占用
        for (int i = 0; i < M; i++) {
            costs[i] = scanner.nextInt();
        }

        // 输入每种材料的价值
        for (int j = 0; j < M; j++) {
            values[j] = scanner.nextInt();
        }

        // 创建一个动态规划数组 dp,初始值为 0
        int[] dp = new int[N + 1];

        // 外层循环遍历每个类型的研究材料
        for (int i = 0; i < M; i++) {
            // 内层循环从 N 空间逐渐减少到当前研究材料所占空间
            for (int j = N; j >= costs[i]; j--) {
                // 考虑当前研究材料选择和不选择的情况,选择最大值
                dp[j] = Math.max(dp[j], dp[j - costs[i]] + values[i]);
            }
        }

        // 输出 dp[N],即在给定 N 行李空间可以携带的研究材料的最大价值
        System.out.println(dp[N]);

        scanner.close();
    }
}

求装满背包有几种方法

01背包应用之“有多少种不同的填满背包最大容量的方法“  494.

递推公式一般为:

dp[j] += dp[j - nums[i]];

0-1背包的多种应用

  • 纯 0 - 1 背包 (opens new window)是求 给定背包容量 装满背包 的最大价值是多少。
  • 416. 分割等和子集 (opens new window)是求 给定背包容量,能不能装满这个背包。
  • 1049. 最后一块石头的重量 II (opens new window)是求 给定背包容量,尽可能装,最多能装多少
  • 494. 目标和 (opens new window)是求 给定背包容量,装满背包有多少种方法。
  • 474.一和零 给定背包容量,装满背包最多有多少个物品。

完全背包

  • 如果求组合数就是外层for循环遍历物品,内层for遍历背包
  • 如果求排列数就是外层for遍历背包,内层for循环遍历物品

排列的遍历顺序:target(背包)放在外循环,将nums(物品)放在内循环,内循环从前到后遍历

多重背包

每件物品最多有Mi件可用,把Mi件摊开,其实就是一个01背包问题了。

好啦停止啦,来不及写笔记了,直接快速自己过一遍了

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

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

相关文章

时序数据分析:时序分割

目录 0 工况的定义 1 Changepoint 2 TreeSplit 3 Autoplait 4 应用示例 5.分析结论 0 工况的定义 工业设备系统在不同的外部条件&#xff08;即工况&#xff09;下&#xff0c;往往有多种运行模式&#xff0c;工业生产也往往会分阶段进行&#xff0c;在不同工况下&…

阿里云开源 AI 应用开发框架:Spring AI Alibaba

作者&#xff1a;刘军&#xff0c;Spring AI Alibaba 发起人&#xff0c;Apache Member 编者按&#xff1a; 6 年前&#xff0c;2018 年 10 月&#xff0c;阿里巴巴开源 Spring Cloud Alibaba&#xff0c;旨在帮助 Java 开发者通过 Spring Cloud 编程模型轻松开发微服务应用。…

一年期免费HTTPS证书:网络安全新选择

HTTPS证书的重要性 HTTPS证书&#xff0c;全称为安全套接字层/传输层安全协议证书&#xff0c;是一种在互联网上建立安全连接的数字证书。它通过公钥加密技术&#xff0c;对网站和用户之间的数据传输进行加密&#xff0c;有效防止数据被窃取或篡改&#xff0c;保障用户信息的安…

网络搜索引擎Shodan(7)完结

声明&#xff1a;学习视频来自b站up主 泷羽sec&#xff0c;如涉及侵权马上删除文章 声明&#xff1a;本文主要用作技术分享&#xff0c;所有内容仅供参考。任何使用或依赖于本文信息所造成的法律后果均与本人无关。请读者自行判断风险&#xff0c;并遵循相关法律法规。 感谢泷…

Web-高校教务考试管理系统

目录 一、前言 1.1 实践目的和要求 1.2 实践项目背景及意义 二、实践内容 2.1 实践过程 2.2 实践内容 2.2.1 项目介绍 2.2.2项目开发环境 2.2.3系统组成与功能 2.2.4 开发工作 2.3 主要成果 三、总结 3.1 个人心得 3.2 其它意见 一、前言 1.1 实践目的和…

顺序表排序相关算法题|负数移到正数前面|奇数移到偶数前面|小于x的数移到大于x的数前面|快排思想(C)

负数移到正数前面 已知顺序表 ( a 1 , … , a n ) (a_{1},\dots,a_{n}) (a1​,…,an​)&#xff0c;每个元素都是整数&#xff0c;把所有值为负数的元素移到全部正数值元素前边 算法思想 快排的前后指针版本 排序|冒泡排序|快速排序|霍尔版本|挖坑版本|前后指针版本|非递归版…

预览 PDF 文档

引言 在现代Web应用中&#xff0c;文件预览功能是非常常见的需求之一。特别是在企业级应用中&#xff0c;用户经常需要查看各种类型的文件&#xff0c;如 PDF、Word、Excel 等。本文将详细介绍如何在Vue项目中实现 PDF 文档的预览功能。 实现原理 后端API 后端需要提供一个…

蚁剑的介绍和使用

蚁剑介绍 蚁剑&#xff08;AntSword&#xff09;是一个开源的跨平台网站管理工具&#xff0c;主要用于渗透测试和安全研究。它提供了一个图形化界面&#xff0c;方便用户管理和操作被攻陷的网站。 安装教程&#xff1a; github官网&#xff1a;https://github.com/AntSwordPro…

AppInventor2能否用网络摄像头画面作为屏幕的背景?

// 视频是否可以作为背景&#xff1f; // 有会员提问&#xff1a;能否用网络摄像头的实时画面作为屏幕的背景&#xff1f;就跟这个一样背景全覆盖&#xff1a; 摄像头画面是一个在线的网站链接视频流。 // 原先思路 // 1、目前原生组件无法直接实现这个功能&#xff0c;屏幕…

DBeaver如何查看ER图

前言 我们在使用DBeaver时&#xff0c;有时候需要查看某张表的ER图&#xff0c;这能帮助我们快速看到表的结构&#xff0c;那么&#xff0c;我们应该如何在DBeaver里面查看ER图呢&#xff1f; 如何查看 首先&#xff0c;我们点击下我们要查看的某张表&#xff0c;鼠标右击一…

pytest高版本兼容test_data[“log“] = _handle_ansi(“\n“.join(logs))错误

一、问题现象&#xff1a; 执行seleniumpytest结束时报: INTERNALERROR> File "D:\workspace\pytestframe\.venv\Lib\site-packages\pytest_html\report_data.py", line 141, in add_test INTERNALERROR> test_data["log"] _handle_ansi(&q…

mysql8.0.32升级到8.0.40

上篇8.0.32库的准备&#xff1a;mysql: error while loading shared libraries: libncurses.so.5: cannot open shared object file: No suc-CSDN博客 此篇测试升级到8.0.40 MySQL :: Download MySQL Community Server rootjyc:~# mysql -u root -pabcd1234 mysql: [Warning]…

【Spring】Spring 核心和设计思想

Spring 核心和设计思想 1.什么是 Spring1.1 传统程序开发1.2 控制反转程序开发 2.理解 Spring IoC 1.什么是 Spring 我们通常所说的 Spring 指的是 Spring Framework&#xff08;Spring 框架&#xff09;&#xff0c;它是⼀个开源框架&#xff0c;有着活跃而庞大的社区&#x…

白盒测试基本概念(学习笔记)

1.1白盒测试基本概念 测试工作中我们经常遇到的两种测试&#xff0c;就是白盒测试和黑盒测试。基本概念区分如下&#xff1a; 软件的白盒测试是对软件的过程性细节做细致的检查。这一方法是把测试对象看作一个打开的盒子&#xff0c;它允许测试人员利用程序内部的逻辑结构及有…

Mybatis使用和原理

Mybatis使用和原理 1、ORM架构2、Spring整合MyBatis使用2.1 添加maven依赖2.2 配置数据源2.3 创建实体类2.4 创建 MyBatis Mapper2.4.1 使用MyBatis注解2.4.2 使用XML方式 2.5 Service 层 3、Spring整合Hibernate使用3.1 添加maven依赖3.2 配置数据源3.3 创建实体类3.4 创建 Re…

C++核心编程和桌面应用开发 第十七天(set和multiset容器 pair map和multimap容器)

目录 1.set和multiset容器 1.1构造和赋值 1.2交换和大小 1.3插入和删除 1.4统计和查找 1.5pair对组 1.6set和multiset的区别 1.7指定内置数据类型排序规则 1.8指定自定义数据类型排序规则 2.map和multimap容器 2.1构造和赋值 2.2交换和大小 2.3插入和删除 2.4统计…

Android中常用adb命令

目录 1.adb连接安卓模拟器 2.adb列出所有已经连接的设备 3.adb显示设备的日志信息 4.adb 电脑文件推送到安卓模拟器中 5.adb 手机传送文件到电脑 6.adb获取安卓应用的包名和Activity名 附录 1--命令 1&#xff09;adb devices 2&#xff09;adb install 路径> 3&#xff09;…

机器学习算法之回归算法

一、回归算法思维导图 二、算法概念、原理、应用场景和实例代码 1、线性回归 1.1、概念 ‌‌线性回归算法是一种统计分析方法&#xff0c;用于确定两种或两种以上变量之间的定量关系。‌ 线性回归算法通过建立线性方程来预测因变量&#xff08;y&#xff09;和一个或多个自变量…

SpringBoot项目如何设置定时任务总开关

目录 方法一&#xff1a;使用Spring Profiles 1.1 步骤1 1.2 步骤2 1.3 步骤3 1.4 步骤4 方法二&#xff1a;使用ConditionalOnProperty 2.1 步骤1 2.2 步骤2 2.3 步骤3 方法三&#xff1a; 主启动类禁用EnableScheduling 定时任务原理剖析&#xff08;选看&#xf…

计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-10-21

计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-10-21 目录 文章目录 计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-10-21目录1. The Fair Language Model Paradox摘要研究背景问题与挑战如何解决创新点算法模型实验效果重要数据与结论推荐阅读指数&…