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

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

贪心算法

这个图非常好

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 和 Nint 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，初始值为 0int[] 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.rhkb.cn/news/458871.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

HarmonyOS ArkTS与C++数据类型转换

HarmonyOS ArkTS与C++数据类型转换

1. HarmonyOS ArkTS与C数据类型转换 本文介绍了C与TS各自数据类型与互相之间的数据类型转换&#xff0c;在需要使用C模块时可以快速上手对各种数据类型进行转换。 1.1. 概述 HarmonyOS的主力开发语言是ArkTS&#xff0c;也提供了C语言的支持&#xff0c;对于一些能力&#xff…
阅读更多...
1.3 面向对象 C++面试问题

1.3 面向对象 C++面试问题

1.3.1 简述一下什么是面向对象,面向对象与面向过程的区别 什么是面向对象 面向对象&#xff08;Object-Oriented Programming&#xff0c;OOP&#xff09;是一种编程范式&#xff0c;它通过将现实世界中的实体抽象为“对象”来组织代码。面向对象编程关注对象及其交互&#x…
阅读更多...
D51【python 接口自动化学习】- python基础之模块与标准库

D51【python 接口自动化学习】- python基础之模块与标准库

day51 模块的导入 学习日期&#xff1a;20241027 学习目标&#xff1a;模块与标准库 -- 66 模块的导入&#xff1a;如何使用其他人编写好的代码功能&#xff1f; 学习笔记 模块的作用 导入模块的方法 # 导入模块 # 方式一 import os # 获取当前的位置 print(os.getcwd())# …
阅读更多...
arduino uno R3更换328pb-au芯片，烧录bootloader

arduino uno R3更换328pb-au芯片，烧录bootloader

使用usbasp烧录器进行烧录&#xff0c;解压 【免费】usbsap驱动以及软件资源-CSDN文库 安装驱动 然后打开软件 界面如下 1按步骤选中芯片&#xff0c; ATmega328P&#xff08;由于没有328PB&#xff0c;直接选这个也行&#xff09; 2查看spi接线&#xff0c; 3读取芯片id&a…
阅读更多...
【SpringCloud】07-分布式事务与Seata

【SpringCloud】07-分布式事务与Seata

1. 分布式事务 2. Seata 3. 安装seata 配置数据库 CREATE DATABASE IF NOT EXISTS seata /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci */ /*!80016 DEFAULT ENCRYPTIONN */; USE seata;------------------------------- The script used when storeM…
阅读更多...
加强版 第一节图像二值化定义

加强版 第一节图像二值化定义

本节课介绍了图像又彩色图像转变为彩色图像转变为灰度图像转变为黑色图像的转化过程。 灰度图像-单通道-取值范围为0-255 二值图像-单通道-取值0&#xff08;黑色&#xff09;-255&#xff08;白色&#xff09; 二值分割 有五种分割方式 如图所示 第一种&#xff1a;大于…
阅读更多...
RabbitMQ 高级特性——事务

RabbitMQ 高级特性——事务

文章目录 前言事务配置事务管理器加上Transactional注解 前言 前面我们学习了 RabbitMQ 的延迟队列&#xff0c;通过延迟队列可以实现生产者生产的消息不是立即被消费者消费。那么这篇文章我们将来学习 RabbitMQ 的事务。 事务 RabbitMQ 是基于 AMQP 协议实现的&#xff0c;…
阅读更多...
「C/C++」C/C++标准库之#include ＜cmath＞数学库

「C/C++」C/C++标准库之#include ＜cmath＞数学库

✨博客主页何曾参静谧的博客&#x1f4cc;文章专栏「C/C」C/C程序设计&#x1f4da;全部专栏「VS」Visual Studio「C/C」C/C程序设计「UG/NX」BlockUI集合「Win」Windows程序设计「DSA」数据结构与算法「UG/NX」NX二次开发「QT」QT5程序设计「File」数据文件格式「PK」Parasoli…
阅读更多...
认识线程 — JavaEE

认识线程 — JavaEE

目录 认识线程&#xff08;Thread&#xff09; 1 线程是什么? 2 为什么要有线程 3 进程和线程的区别 区别一 区别二 区别三 区别四 4. Java的线程和操作系统线程的关系 认识线程&#xff08;Thread&#xff09; 1 线程是什么? 一个线程就是一个 "执行流"。…
阅读更多...
Excel-多表数据查找匹配(VLOOKUP)

Excel-多表数据查找匹配(VLOOKUP)

&#x1f496;简介 Excel的VLOOKUP函数同样可以用来查找表格中的数据。VLOOKUP&#xff08;垂直查找&#xff09;是一个非常有用的函数&#xff0c;它可以在一个表格或数据表的一列中搜索特定的值&#xff0c;并返回与之在同一行上的另一列中的值。 &#x1f4d6;环境 WPS …
阅读更多...
R语言机器学习算法实战系列（十二）线性判别分析分类算法 (Linear Discriminant Analysis)

R语言机器学习算法实战系列（十二）线性判别分析分类算法 (Linear Discriminant Analysis)

禁止商业或二改转载，仅供自学使用，侵权必究，如需截取部分内容请后台联系作者! 文章目录 介绍LDA的原理LDA的步骤教程下载数据加载R包导入数据数据预处理数据描述数据切割构建模型预测测试数据评估模型模型准确性混淆矩阵模型评估指标ROC CurvePRC Curve保存模型总结优点：缺…
阅读更多...
【大数据学习 | kafka】producer的参数与结构

【大数据学习 | kafka】producer的参数与结构

1. producer的结构 producer&#xff1a;生产者 它由三个部分组成 interceptor&#xff1a;拦截器&#xff0c;能拦截到数据&#xff0c;处理完毕以后发送给下游&#xff0c;它和过滤器不同并不是丢弃数据&#xff0c;而是将数据处理完毕再次发送出去&#xff0c;这个默认是不…
阅读更多...
【c++篇】：探索c++中的std::string类--掌握字符串处理的精髓

【c++篇】：探索c++中的std::string类--掌握字符串处理的精髓

✨感谢您阅读本篇文章&#xff0c;文章内容是个人学习笔记的整理&#xff0c;如果哪里有误的话还请您指正噢✨ ✨ 个人主页&#xff1a;余辉zmh–CSDN博客 ✨文章所属专栏&#xff1a;c篇–CSDN博客 文章目录 前言一.std::string对象的创建二.std::string对象的访问三.std::str…
阅读更多...
读取有空格的string对象（getline）

读取有空格的string对象（getline）

文章目录 读取有空格的string对象1.使用标准库中的iostream来写2.**使用getline读取一整行** 读取有空格的string对象 1.使用标准库中的iostream来写 #include<iostream> using namespace std; int main() {string s;cin >> s;cout << s << endl;ret…
阅读更多...
探索Python安全字符串处理的奥秘：MarkupSafe库揭秘

探索Python安全字符串处理的奥秘：MarkupSafe库揭秘

文章目录 探索Python安全字符串处理的奥秘&#xff1a;MarkupSafe库揭秘第一部分&#xff1a;背景介绍第二部分&#xff1a;MarkupSafe是什么&#xff1f;第三部分&#xff1a;如何安装MarkupSafe&#xff1f;第四部分&#xff1a;MarkupSafe的简单使用方法1. 使用escape函数2.…
阅读更多...
Tomcat安装与使用

Tomcat安装与使用

Tomcat优点 1、开源免费&#xff1a;是一个免费、开源的Web服务器&#xff0c;可以在任何环境下自由使用&#xff0c;无需支付任何费用。 2、轻量级&#xff1a;是一个轻量级的Web服务器&#xff0c;其核心仅有几百K&#xff0c;启动速度非常快。 3、易于安装和配置&#xff1a…
阅读更多...
【笔记】LLM位置编码之标准位置编码

【笔记】LLM位置编码之标准位置编码

标准位置编码 起源原理证明&#xff1a;对于任何固定的偏移量 k k k&#xff0c; P E p o s k PE_{posk} PEposk​可以表示为 P E p o s PE_{pos} PEpos​的线性函数。计算 P E p o s k 与 P E p o s PE_{posk} 与PE_{pos} PEposk​与PEpos​的内积结论 通俗理解缺点 起源 由…
阅读更多...
深度学习之降维和聚类

深度学习之降维和聚类

1 降维和聚类 1.1 图解为什么会产生维数灾难 ​ 假如数据集包含10张照片&#xff0c;照片中包含三角形和圆两种形状。现在来设计一个分类器进行训练&#xff0c;让这个分类器对其他的照片进行正确分类&#xff08;假设三角形和圆的总数是无限大&#xff09;&#xff0c;简单的…
阅读更多...
Typora一款极简Markdown文档编辑器和阅读器，实时预览，序列号生成！免费！最新可用！

Typora一款极简Markdown文档编辑器和阅读器，实时预览，序列号生成！免费！最新可用！

文章目录 一、Typora下载和安装二、Typora序列号生成 Typora是一款Markdown编辑器和阅读器&#xff0c;风格极简&#xff0c;实时预览&#xff0c;所见即所得&#xff0c;支持MacOS、Windows、Linux操作系统&#xff0c;有图片和文字、代码块、数学公式、图表、目录大纲、文件管…
阅读更多...
异常处理与调试：如何编写稳健的代码（8/10）

异常处理与调试：如何编写稳健的代码（8/10）

目录 异常处理与调试&#xff1a;如何编写稳健的代码&#xff08;8/10&#xff09; 介绍 异常概述 常见的异常类型 使用 try...except 处理异常 基本结构 示例&#xff1a;读取文件内容 捕获多个异常 自定义异常 示例&#xff1a;自定义异常类 调试代码 使用 print…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023