Synitis的博客

746.使用最小花费爬楼梯

Thu, 23 Jul 2026 00:00:00 GMT

746.使用最小花费爬楼梯#

题目说每个楼梯都千奇百怪，有的楼梯从上面迈步很简单，有的则很难，不同的楼梯迈步的难度我们将其抽象成费用，费用高的就难，低的就简单，我们的目的就是找到最简单的路线

题目会给出一个长度至少为2的列表cost，下例

1
cost = [1,100,1,1,100]

我们一次可以迈出一步或两步，比如说我们在第i阶楼梯，我们就可以走到第i+1阶或者第i+2阶上，那我们就想了是不是我们只要找两个之中花费最小的走就行了呢？让我们试试

第1个楼梯花费1，第2个楼梯花费100，第1个小，所以跳到第1个上，开始没有花费花费+0 总花费0 开始->[0]

第2个楼梯花费100，第3个楼梯花费1，第3个小，所以跳到第3个上，第2个楼梯的花费是1 花费+1 总花费1 [0]->[2]

第4个楼梯花费1，第5个楼梯花费100，第4个小，所以跳到第4个上，第3个楼梯的花费是1 花费+1 总花费2 [2]->[3]

第5个楼梯花费1，跳2阶可以直接到终点，所以跳到终点上，第4个楼梯的花费是1 花费+1 总花费3 [3]->终点

在脑内仔细一验算发现还真是最小花费，直接提交

然后发现没通过，看下输入发现两个选最小并不能适应所用场景，比如在下面

1
cost=[10,15,20]

这里如果我们迈向10，那么就掉进陷阱了，因为直接到15才是最优的

那我们应该怎么办？

思考一下我们想到，其实这就是之前问题的翻版，之前我们输出1楼梯的种类加到2楼梯上，输出2楼梯的种类加到3楼梯上…直到算出n楼梯的数量

我们不直接求整体，而是先求部分，再从部分算出整体

我们这里也可以运用这样的思想，我们的目标是到顶，我们把数组长度称为n吧，那么我们的目标就是到n+1，到 n+1有几种路可以走呢

(虽然数组从0开始，但为了方便，我们就姑且认为下面的数组从1开始吧)

从n迈一步到n+1 花费cost[n] + 迈上n的最优花费
从n-1迈两步到n+1 花费cost[n-1] + 迈上n-1的最优花费

那么迈上n和n-1的花费怎么算呢

从n-1迈一步到n 花费cost[n-1] + 迈上n-1的最优花费
从n-2迈两步到n 花费cost[n-2] + 迈上n-2的最优花费

n的花费就是上面两个中最小的

从n-2迈一步到n-1 花费cost[n-2] + 迈上n-2的最优花费
从n-3迈两步到n-1 花费cost[n-3] + 迈上n-3的最优花费

n-1的花费就是上面两个中最小的

观察上面算式，我们发现n的最优花费总是为

1
#用M[n]来表示n的最优花费
2
M[n] = min(cost[n-1]+M[n-1] , cost[n-2]+M[n-1])
3
#min表示两个中取最小

我们继续推导，为了知道n-1的最优花费，我们得先知道n-2和n-3的，为了知道n-2…

最后，为了知道3的最优花费，我们得知道1和2最优花费，由于我们可以直接跳上1和2，所以1和2的最优花费为0，即

1
M[1]=0;M[2]=0;

之后我们就可以算出爬上3的最优花费，算出3的最优花费后我们就可以算出4的，然后就能算出5的…最后我们就能算出爬到n+1的最优花费了，也就是我们的答案

然后我们直接写程序

1
class Solution {
2
public:
3
    int minCostClimbingStairs(vector<int>& cost) {
4
    //传入一个费用数组cost
5
        int n1 = 0,n2=0,curl;
6
    //观察公式可发现，算出n，只需n-1,n-2的费用及其花费，所以只用存两个数
7
    //curl是用来保存n的最优费用
8
        for(int i = 2; i <= std::size(cost); i++){
9
            curl = min(n1 + cost[i-1] , n2 + cost[i-2]);
10
      //算出i的最优费用
11
            n2 = n1;
12
            n1 = curl;
13
        }
14
        return n1;
15
    }
16
};

展开收起

Linux学习

Thu, 23 Jul 2026 00:00:00 GMT

Linux学习-进程基础操作#

查看进程#

Terminal window

1
ps -aux

查找进程#

Terminal window

1
ps -aux | grep 进程名

查看进程树#

Terminal window

1
pstree

停止或开始进程#

Terminal window

1
sudo systemctl stop 进程名
2
sudo systemctl start 进程名

查看进程状态#

Terminal window

1
sudo systemctl status 进程名

阻止/启用自启动#

Terminal window

1
sudo systemctl disable 进程名
2
sudo systemctl enable 进程名

查看进程列表(活跃的)#

Terminal window

1
sudo systenctl list-units
2
sudo systenctl list-units -t 进程类别

查看所有进程(全部)#

Terminal window

1
sudo systemctl list-unit-files

198. 打家劫舍

Thu, 23 Jul 2026 00:00:00 GMT

198. 打家劫舍#

题目链接

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的数组，计算你不触动警报装置的情况下能够偷窃到的最高金额，下例

1
cost = [1,2,3,4,5,6,7,8]

因为有报警系统的原因，所以我们不能连着偷两栋，比如说我们偷了1，那么我们就不能偷2了

这时候我们的第一个想法就出来了，既然我们不能连着偷，那么隔一个偷一个大概就是最好的方案了吧，我们可以从第一栋开始偷，也可以从第二栋开始偷，如果我们从第三栋开始的话，那就和第一栋开始偷一样了，所以摆在我们面前的选择只有两个，偷奇数栋或者偷偶数栋

1
class Solution {
2
public:
3
    int rob(vector<int>& nums) {
4
        int odd=0,even=0;
5
        //定义两个计数器
6
        for(int i = 0;i < size(nums) ; i += 2){
7
            odd += nums[i];
8
            if(i + 1 < size(nums)) even += nums[i + 1];
9
            //如果存在偶数次的话就加上
10
        }
11
        return max(odd , even);
12
        //返回其中最大的
13
    }
14
};

写完了直接提交，然后发现不行（；´д｀）ゞ

1
cost = [2,1,1,2]

我们倒在了这个样例上，在这个例子上，偷第一家和最后一家才是最优的结果，他们的奇偶性不同，所以我们的程序不会考虑这种可能

这就麻烦了，我们应该如何处理这样的例子呢

对于这样要我们去规划路径的题，我们知道直接找出整体最优解是不太可能的，那么我们就来看看局部最优解怎么算

1
cost = [1,2,3]

我们回到最初的例子上面，但我们先只看前3项，我们经过前三户人家的时候我们最多能偷多少钱呢，我们有两个可能

偷第1户和第3户总钱数 = 1 + 3 = 4
只偷第2户总钱数 = 2

所以对于前3项来说，总钱数最多为4，让我们再来看看前4项

1
cost = [1,2,3,4]

对于前4项，也有两种可能

偷第2户和第4户总钱数 = 2 + 4 = 6
偷第1户和第3户总钱数 = 1 + 3 = 4

这时候我们好像隐隐感觉到了一丝规律（没感觉到也没事）

再看前5项

1
cost=[1,2,3,4,5]

两种可能

偷1、3、5户的总钱数 =1 + 3 + 5 =9
偷2、4户的总钱数 = 2 + 4 = 6

我们看到这里的“1 + 3 + 5”中的“1 + 3”我们之前算过啊，以及“2 + 4”我们也算过啊

然后我们就能总结出规律，假设我们在前i项，第一种可能总是为：第i间房本身的钱 + 前i-2间房最多能偷到的钱。第二种可能总是为：前i-1间房最多能偷到的钱

写成代码就是

1
M[i] = max(
2
    cost[i] + M[i-2],
3
    M[i-1]
4
    )
5
//M[i]代表第i间房最多能偷到的钱
6
//max代表在两个中选一个最大的

有了这个公示后就可以开始推导了，前1间由于没有前面的房子，所以永远是其本身的钱，即M[0] = B[0]，第2间房有了前面的房子的结果，因为没有M[i-2]所以把M[i-2]视为0，接着套公式，第三间房有了前两间也可以直接套，后面的房子同理，这样我们就能算出前n间房最多能偷多少了

下为示例代码

1
class Solution {
2
public:
3
    int rob(vector<int>& nums) {
4
        int n1 = nums[0],n2 = 0;
5
    //这里n1表示M[i-1],n2表示M[i-2]
6
    //值得注意的是，观察公式发现，除了cost以外，我们只需要额外存储两个值，分别是M[i-1]，M[i-2]
7
        for(int i = 1;i < size(nums);i++){
8
      //但是实际上，我们必须要多写一个变量才能实现两个值的更新
9
            int curl=max(n1,n2+nums[i]);
10
      //curl用来存储M[i]的值
11
            n2 = n1;
12
            n1 = curl;
13
      //这里将n2变成M[i-1],n1变成[i]，之后执行i++，这些值整体前移
14
        }
15
        return n1;
16
    }
17
};

展开收起

第二天

Wed, 22 Jul 2026 00:00:00 GMT

第二天的第二份#

这是为了测试写的，为什么一觉醒来不是第三天？ (手抓饼真好吃)

Linux学习1

Wed, 22 Jul 2026 00:00:00 GMT

linux学习1#

教程链接

所以我今天学历什么呢?idk

简单来说就是在linux上安装软件吧

dpkg

dpkg -i "包名"

这个很不方便，就像在Windows上安装软件，你必须先找到软件包下载下来，然后才能安装

apt

sudo apt install "软件名"

这个可以自动安装，然后我们可以通过

sudo apt edit-sources

获取到你的库的地址，然后用库的地址

sudo nano 地址

然后你就能修改你的库地址

其他

pip用于pygit用于github,其他不做补充

第一天

Tue, 21 Jul 2026 00:00:00 GMT

这是我第一天写博客#

就这样，我很累了,而且这个博客也只做到半成品