MidnightSun 's Blog

Day48-单调栈 part01

Mon, 28 Apr 2025 00:00:00 GMT

单调栈

单调栈是一种栈结构，但有特殊要求：

栈里的元素是单调递增或者单调递减排列的。

通常分为两种：

单调递增栈：栈内元素从栈底到栈顶是递增的。
单调递减栈：栈内元素从栈底到栈顶是递减的。

注意：这里的"单调"指的是栈内元素大小关系，而不是压入栈的顺序。

核心思想：

维护一个栈，在遍历数组时动态保持栈的单调性，一旦遇到破坏单调性的元素，就弹出栈顶，处理对应关系。

每日温度

739. 每日温度

用单调递减栈：

栈中存放下标，对应的温度是单调递减的。
当新温度比栈顶元素温度高时，说明找到了栈顶元素的下一个更大温度。

具体实现思路：

初始化一个空栈 stk，和一个与 temperatures 长度相同的 result 数组，初始为全 0。
从左到右遍历 temperatures：
- 当前温度大于栈顶所代表的温度，说明找到了更高温度。
- 弹出栈顶元素，更新 result[栈顶下标] = 当前下标 - 栈顶下标。
- 然后继续比较，直到栈为空或栈顶温度大于当前温度。
- 当前下标压入栈中。
最后栈中剩下的元素没有更高温度，对应的 answer[i] = 0（初始就是 0，不需要再动）。

整体代码如下:

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> result(temperatures.size(), 0); // 初始化结果数组，默认值为0
        stack<int> stk; // 单调栈，存储索引

        for (int i = 0; i < temperatures.size(); i++) {
            // 当栈不为空且当前温度大于栈顶温度时，说明找到了更高的温度
            while (!stk.empty() && temperatures[i] > temperatures[stk.top()]) {
                int index = stk.top(); // 获取栈顶索引
                stk.pop(); // 弹出栈顶元素
                result[index] = i - index; // 计算天数差并存入结果数组
            }
            stk.push(i); // 将当前索引压入栈中
        }
        return result; // 返回结果数组
    }
};

下一个更大元素 I

739. 下一个更大元素 I

思路：

预处理 nums2 中每个元素的下一个更大元素，然后查询 nums1。

用单调递减栈：

栈中存放 nums2 的元素。
遇到比栈顶大的元素时，栈顶元素的下一个更大元素就是当前元素。

具体步骤：

用一个哈希表 map，记录每个元素对应的下一个更大元素。
遍历 nums2：
- 栈为空或者当前元素小于等于栈顶元素，入栈。
- 如果当前元素大于栈顶元素，弹栈，并在 map 中记录：map[栈顶元素] = 当前元素。
遍历 nums1：
- 查找每个元素对应的下一个更大元素，如果没有则返回 -1。

整体实现：

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int, int> nextGreaterMap; // 存储每个元素的下一个更大元素
        stack<int> stk; // 单调栈，存储索引

        for (int i = 0; i < nums2.size(); i++) {
            // 当栈不为空且当前元素大于栈顶元素时，说明找到了下一个更大元素
            while (!stk.empty() && nums2[i] > nums2[stk.top()]) {
                nextGreaterMap[nums2[stk.top()]] = nums2[i]; // 存储下一个更大元素
                stk.pop(); // 弹出栈顶元素
            }
            stk.push(i); // 将当前索引压入栈中
        }

        vector<int> result; // 存储结果
        for (int num : nums1) {
            result.push_back(nextGreaterMap.count(num) ? nextGreaterMap[num] : -1); // 如果没有下一个更大元素，则返回-1
        }
        return result; // 返回结果数组
    }
};

下一个更大元素 II

503. 下一个更大元素 II

处理方式和上题差不多，只是需要循环两遍数组来模拟“环形”。

用单调递减栈：

遍历两遍数组（2n长度），用取模操作 i % n 访问元素。

具体步骤：

初始化一个栈，存放下标。
初始化一个数组 answer，全设为 -1。
遍历 2 * n 次：
- 当前元素大于栈顶元素代表找到了下一个更大的元素。
- 弹出栈，更新结果。
- 只在第一次遍历（i < n）时压栈，避免重复压入元素。
最终得到所有答案。

整体代码：

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> result(n, -1); // 初始化结果数组，默认值为-1
        stack<int> stk; // 单调栈，存储索引

        for (int i = 0; i < 2 * n; i++) {
            int index = i % n; // 处理循环数组的索引
            // 当栈不为空且当前元素大于栈顶元素时，说明找到了下一个更大元素
            while (!stk.empty() && nums[index] > nums[stk.top()]) {
                result[stk.top()] = nums[index]; // 存储下一个更大元素
                stk.pop(); // 弹出栈顶元素
            }
            if (i < n) { // 只在第一次遍历时将索引压入栈中
                stk.push(index); // 将当前索引压入栈中
            }
        }
        return result; // 返回结果数组
    }
};

Day45-动态规划 part12

Fri, 25 Apr 2025 00:00:00 GMT

115. 不同的子序列

1. 确定dp数组以及下标的含义

定义一个二维数组 dp[i][j]，表示 s 的前 i 个字符中，组成 t 的前 j 个字符的子序列个数。

2. 确定递推公式

如果 s[i - 1] == t[j - 1]，那么可以有两种选择：
- 要用 s[i-1] 来匹配 t[j-1]：即 dp[i-1][j-1]
- 不用 s[i-1]，直接继承前面的状态：即 dp[i-1][j]
因此递推公式为：

if (s[i - 1] == t[j - 1]) {
    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
} else {
    dp[i][j] = dp[i - 1][j];
}

3. 初始化

dp[0][0] = 1，空字符串可以匹配空字符串。
dp[i][0] = 1，任何字符串都可以通过删除全部字符得到空字符串。
dp[0][j] = 0（j > 0），空字符串无法组成非空字符串。

vector<vector<long long>> dp(s.size() + 1, vector<long long>(t.size() + 1, 0));
dp[0][0] = 1;
for (int i = 1; i <= s.size(); i++) dp[i][0] = 1;

4. 遍历顺序

从 i = 1 遍历到 s.size()，j = 1 遍历到 t.size()，先遍历 s，再遍历 t。

for (int i = 1; i <= s.size(); i++) {
    for (int j = 1; j <= t.size(); j++) {
        ...
    }
}

5. 整体代码

class Solution {
public:
    int numDistinct(string s, string t) {
        vector<vector<long long>> dp(s.size() + 1, vector<long long>(t.size() + 1, 0));
        for (int i = 0; i <= s.size(); i++) dp[i][0] = 1;
        
        for (int i = 1; i <= s.size(); i++) {
            for (int j = 1; j <= t.size(); j++) {
                if (s[i - 1] == t[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        
        return dp[s.size()][t.size()];
    }
};

583. 两个字符串的删除操作

1. 确定dp数组以及下标的含义

定义 dp[i][j] 表示将 word1 的前 i 个字符和 word2 的前 j 个字符变得相同所需要删除的最少步数。

2. 确定递推公式

如果 word1[i-1] == word2[j-1]，那么不需要删除字符，继承前面的状态：
```
dp[i][j] = dp[i-1][j-1];
```
如果 word1[i-1] != word2[j-1]，要么删 word1[i-1]，要么删 word2[j-1]，取最小值再加一：
```
dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + 1;
```

3. 初始化

dp[i][0] = i，将 word1 删除成空字符串
dp[0][j] = j，将 word2 删除成空字符串

vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;

4. 遍历顺序

从 i = 1 遍历到 word1.size()，j = 1 遍历到 word2.size()，从前向后遍历。

for (int i = 1; i <= word1.size(); i++) {
    for (int j = 1; j <= word2.size(); j++) {
        ...
    }
}

5. 整体代码

class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
        for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
        for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;

        for (int i = 1; i <= word1.size(); i++) {
            for (int j = 1; j <= word2.size(); j++) {
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1;
                }
            }
        }

        return dp[word1.size()][word2.size()];
    }
};

72. 编辑距离

1. 确定dp数组以及下标的含义

定义 dp[i][j] 表示将 word1 的前 i 个字符转换成 word2 的前 j 个字符所使用的最少编辑操作次数。

编辑操作包括：插入、删除、替换。

2. 确定递推公式

如果 word1[i-1] == word2[j-1]，则不需要任何操作：
```
dp[i][j] = dp[i-1][j-1];
```
如果 word1[i-1] != word2[j-1]，则考虑三种情况：
- 插入：dp[i][j-1] + 1
- 删除：dp[i-1][j] + 1
- 替换：dp[i-1][j-1] + 1

取三者最小值：

dp[i][j] = min({dp[i-1][j] + 1, dp[i][j-1] + 1, dp[i-1][j-1] + 1});

3. 初始化

dp[i][0] = i，把 word1 变成空字符串
dp[0][j] = j，把空字符串变成 word2

vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;

4. 遍历顺序

从 i = 1 遍历到 word1.size()，j = 1 遍历到 word2.size()，先遍历 word1 再遍历 word2。

for (int i = 1; i <= word1.size(); i++) {
    for (int j = 1; j <= word2.size(); j++) {
        ...
    }
}

5. 整体代码

class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
        for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
        for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;

        for (int i = 1; i <= word1.size(); i++) {
            for (int j = 1; j <= word2.size(); j++) {
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = min({dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1});
                }
            }
        }

        return dp[word1.size()][word2.size()];
    }
};

Day46-动态规划 part13

Fri, 25 Apr 2025 00:00:00 GMT

647. 回文子串

1. 确定dp数组以及下标的含义

定义一个二维数组 dp[i][j]，表示字符串 s 中从下标 i 到下标 j 这一子串是否是回文子串。

如果是回文子串，则 dp[i][j] = true，否则为 false。

2. 确定递推公式

如果 s[i] == s[j]，并且：
- j - i <= 1，说明子串长度是 1 或 2，直接就是回文子串；
- 或者 dp[i+1][j-1] == true，说明去掉两端字符后，中间子串是回文，那么整个也是回文。
因此递推公式为：

if (s[i] == s[j]) {
    if (j - i <= 1) dp[i][j] = true;
    else dp[i][j] = dp[i + 1][j - 1];
}

3. 初始化

初始时，dp[i][i] = true，单个字符本身就是回文子串。

vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
for (int i = 0; i < s.size(); i++) {
    dp[i][i] = true;
}

4. 遍历顺序

因为 dp[i][j] 依赖于 dp[i+1][j-1]，所以 i 要从大到小遍历，j 要从小到大遍历。

for (int i = s.size() - 1; i >= 0; i--) {
    for (int j = i + 1; j < s.size(); j++) {
        ...
    }
}

5. 整体代码

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size();
        vector<vector<bool>> dp(n, vector<bool>(n, false));
        int result = 0;

        for (int i = n - 1; i >= 0; i--) {
            for (int j = i; j < n; j++) {
                if (s[i] == s[j]) {
                    if (j - i <= 1) dp[i][j] = true;
                    else dp[i][j] = dp[i + 1][j - 1];
                }
                if (dp[i][j]) result++;
            }
        }
        return result;
    }
};

516. 最长回文子序列

1. 确定dp数组以及下标的含义

定义一个二维数组 dp[i][j]，表示字符串 s 中从下标 i 到下标 j 的子串内，最长回文子序列的长度。

2. 确定递推公式

如果 s[i] == s[j]，那么两端可以构成回文，长度加 2：

dp[i][j] = dp[i+1][j-1] + 2;

如果 s[i] != s[j]，则取删除左边或者右边元素后能得到的最长回文子序列长度的最大值：

dp[i][j] = max(dp[i+1][j], dp[i][j-1]);

3. 初始化

dp[i][i] = 1，每个单独的字符，最长回文子序列长度就是 1。

vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
for (int i = 0; i < s.size(); i++) {
    dp[i][i] = 1;
}

4. 遍历顺序

因为 dp[i][j] 依赖于 dp[i+1][j-1]、dp[i+1][j] 和 dp[i][j-1]，所以 i 要从大到小遍历，j 从小到大遍历。

for (int i = s.size() - 1; i >= 0; i--) {
    for (int j = i + 1; j < s.size(); j++) {
        ...
    }
}

5. 整体代码

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        vector<vector<int>> dp(n, vector<int>(n, 0));
        for (int i = 0; i < n; i++) {
            dp[i][i] = 1;
        }

        for (int i = n - 1; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                if (s[i] == s[j]) {
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                } else {
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[0][n - 1];
    }
};

Day44-动态规划 part11

Thu, 24 Apr 2025 00:00:00 GMT

最长公共子序列

1143. 最长公共子序列

1. 确定dp数组以及下标的含义

定义一个二维数组 dp[i][j]，表示 text1 的前 i 个字符与 text2 的前 j 个字符的最长公共子序列长度。

注意：这里的“前 i 个字符”不包括 text1[i]，即 dp 的下标是从 1 开始表示字符串前缀长度。

2. 确定递推公式

如果 text1[i - 1] == text2[j - 1]，说明两个字符串当前字符相等，那么 dp[i][j] = dp[i - 1][j - 1] + 1
否则，dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

即：

if (text1[i - 1] == text2[j - 1]) {
    dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}

3. 初始化

当 i == 0 或 j == 0 时，即其中一个字符串为空，最长公共子序列为 0

vector<vector<int>> dp(text1.size() + 1, vector<int>(text2.size() + 1, 0));

4. 遍历顺序

我们从 i = 1 遍历到 text1.size()，j = 1 遍历到 text2.size()，并根据 text1[i - 1] 和 text2[j - 1] 进行转移。

for (int i = 1; i <= text1.size(); i++) {
    for (int j = 1; j <= text2.size(); j++) {
        ...
    }
}

5. 整体代码

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text1.size(), n = text2.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (text1[i - 1] == text2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m][n];
    }
};

1035. 不相交的线

1. 确定dp数组以及下标的含义

dp[i][j] 表示 A 的前 i 个元素与 B 的前 j 个元素之间，最多可以连接多少条不相交的线。

2. 确定递推公式

本质上与最长公共子序列类似：

如果 A[i-1] == B[j-1]，则可以连接一条线：dp[i][j] = dp[i-1][j-1] + 1
否则：dp[i][j] = max(dp[i-1][j], dp[i][j-1])

3. 初始化

dp[i][0] = 0，表示 B 为空时无法连接
dp[0][j] = 0，表示 A 为空时无法连接

vector<vector<int>> dp(A.size() + 1, vector<int>(B.size() + 1, 0));

4. 遍历顺序

从前往后遍历 A 和 B：

for (int i = 1; i <= A.size(); i++) {
    for (int j = 1; j <= B.size(); j++) {
        ...
    }
}

5. 整体代码

class Solution {
public:
    int maxUncrossedLines(vector<int>& A, vector<int>& B) {
        vector<vector<int>> dp(A.size() + 1, vector<int>(B.size() + 1, 0));
        for (int i = 1; i <= A.size(); i++) {
            for (int j = 1; j <= B.size(); j++) {
                if (A[i - 1] == B[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[A.size()][B.size()];
    }
};

53. 最大子序和

1. 确定dp数组以及下标的含义

dp[i] 表示以 nums[i] 结尾的连续子数组的最大和。

2. 确定递推公式

我们有两种选择：

要么将 nums[i] 加到 dp[i-1] 上，表示继续累加；
要么舍弃前面的子数组，从 nums[i] 重新开始。

dp[i] = max(dp[i - 1] + nums[i], nums[i]);

3. 初始化

dp[0] = nums[0]，表示以第一个元素结尾的最大子数组和就是它自己。

vector<int> dp(nums.size());
dp[0] = nums[0];

4. 遍历顺序

从前往后遍历即可。

for (int i = 1; i < nums.size(); i++) {
    dp[i] = max(dp[i - 1] + nums[i], nums[i]);
}

5. 整体代码

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp(nums.size());
        dp[0] = nums[0];
        int result = dp[0];
        for (int i = 1; i < nums.size(); i++) {
            dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            result = max(result, dp[i]);
        }
        return result;
    }
};

392. 判断子序列

1. 确定dp数组以及下标的含义

这道题不一定要用动态规划，用双指针更加简单直观。

2. 算法核心思路（双指针法）

指针 i 指向 s，j 指向 t。
如果 s[i] == t[j]，说明匹配上了，i++；
否则 j++，继续匹配下一个字符。
如果最后 i == s.size()，说明 s 是 t 的子序列。

3. 初始化

int i = 0, j = 0;

4. 遍历顺序

只需要从左往右遍历两个字符串。

5. 整体代码

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int i = 0, j = 0;
        while (i < s.size() && j < t.size()) {
            if (s[i] == t[j]) i++;
            j++;
        }
        return i == s.size();
    }
};

Day43-动态规划 part10

Wed, 23 Apr 2025 00:00:00 GMT

最长递增子序列

300. 最长递增子序列

1. 确定dp数组以及下标的含义

我们可以定义一个一维的dp数组 dp[i]，表示以 nums[i] 结尾的最长递增子序列的长度。

2. 确定递推公式

位置 i 的最长递增子序列的长度等于 j 从 0 到 i - 1 的所有位置中，nums[j] < nums[i] 的最大值加 1。

因此我们可以得到递推公式：

if (nums[j] < nums[i]) {
    dp[i] = max(dp[i], dp[j] + 1);
}

3. 初始化

对于每一个位置 i，我们都可以认为它本身就是一个递增子序列，因此我们可以将 dp[i] 初始化为 1。

vector<int> dp(nums.size(), 1);

4. 遍历顺序

在递推公式中，我们需要用到 j 从 0 到 i - 1 的所有位置，因此我们需要先遍历 i，再遍历 j，并且是从前往后遍历。

for (int i = 0; i < nums.size(); i++) {
    for (int j = 0; j < i; j++) {
        if (nums[j] < nums[i]) {
            dp[i] = max(dp[i], dp[j] + 1);
        }
    }
}

5. 整体代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(), 1); // 初始化为1
        for (int i = 0; i < nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) { // 如果nums[j] < nums[i]，说明可以组成递增子序列
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
        }
        return *max_element(dp.begin(), dp.end());
    }
};

最长连续递增序列

674. 最长连续递增序列

1. 确定dp数组以及下标的含义

我们可以定义一个一维的dp数组 dp[i]，表示以下标 i 结尾的最长连续递增子序列的长度。

2. 确定递推公式

如果 nums[i] > nums[i - 1]，那么以 nums[i] 结尾的最长连续递增子序列的长度等于以 nums[i - 1] 结尾的最长连续递增子序列的长度加 1。

即：

dp[i] = dp[i - 1] + 1;

因为是连续递增，所以我们只需要判断 nums[i] > nums[i - 1] 即可，不再需要判断 j 从 0 到 i - 1 的所有位置，也就是只用一层循环即可。

3. 初始化

和之前求最长递增子序列一样，以下标 i 结尾的最长连续递增子序列的长度为 1。

vector<int> dp(nums.size(), 1); // 初始化为1

4. 遍历顺序

在递推公式中，我们只需要用到 i - 1 的位置，因此我们只需要从前往后遍历即可。

for (int i = 1; i < nums.size(); i++) {
    if (nums[i] > nums[i - 1]) { // 如果nums[i] > nums[i - 1]，说明可以组成递增子序列
        dp[i] = dp[i - 1] + 1;
    }
}

5. 整体代码

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 0) return 0; // 如果数组为空，返回0
        vector<int> dp(nums.size(), 1); // 初始化为1
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] > nums[i - 1]) { // 如果nums[i] > nums[i - 1]，说明可以组成递增子序列
                dp[i] = dp[i - 1] + 1;
            }
        }
        return *max_element(dp.begin(), dp.end()); // 返回dp的最大值
    }
};

最长重复子序列

1143. 最长公共子序列

我们可以使用一个二维的dp数组 dp[i][j]，表示 AA[0...i] 和 B[0...j] 的最长公共子序列的长度。

1. 确定dp数组以及下标的含义

dp[i][j] ：以下标 i - 1 为结尾的 A，和以下标 j - 1 为结尾的 B，最长重复子数组长度为 dp[i][j]。（“以下标 i - 1 为结尾的 A” 标明一定是以 A[i-1] 为结尾的字符串）

2. 确定递推公式

根据 dp数组的定义，dp[i][j] 由 dp[i - 1][j - 1] 递推而来。

当 A[i - 1] == B[j - 1] 时，dp[i][j] = dp[i - 1][j - 1] + 1。

3. 初始化

根据 dp数组的定义，dp[i][j] 由 dp[i - 1][j - 1] 递推而来，dp[i][0] 和 dp[0][j] 实际上是没有意义的，但是在递推的过程中需要用到，因此我们可以将 dp[i][0] 和 dp[0][j] 初始化为 0。

vector<vector<int>> dp(A.size() + 1, vector<int>(B.size() + 1, 0)); // 初始化为0

4. 遍历顺序

在递推公式中，我们需要用到 i - 1 和 j - 1 的位置，因此我们需要先遍历 i，再遍历 j，并且是从前往后遍历。先遍历 A，再遍历 B。

for (int i = 1; i <= text1.size(); i++) {
            for (int j = 1; j <= text2.size(); j++) {
                if (text1[i - 1] == text2[j - 1]) { // 如果当前字符相等，则最长公共子序列长度加1
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else { // 如果当前字符不相等，则取前一个状态的最大值
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }

5. 整体代码

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size() + 1, vector<int>(text2.size() + 1, 0)); // dp[i][j]表示text1前i个字符和text2前j个字符的最长公共子序列长度
        for (int i = 1; i <= text1.size(); i++) {
            for (int j = 1; j <= text2.size(); j++) {
                if (text1[i - 1] == text2[j - 1]) { // 如果当前字符相等，则最长公共子序列长度加1
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else { // 如果当前字符不相等，则取前一个状态的最大值
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[text1.size()][text2.size()]; // 返回最长公共子序列长度
    }
};

Day42-动态规划 part09

Tue, 22 Apr 2025 00:00:00 GMT

买卖股票 IV

188. 买卖股票的最佳时机 IV

本题和之前的买卖股票类似，都是在给定的交易次数内求最大利润。

我们同样可以使用一个二维的dp数组来表示状态。

用 dp[i][j] 表示第 i 天对股票的持有状态为 j 时的最大利润。j 的状态可以表示为：

j = 0：表示不操作
j = 1：表示第一次持有股票
j = 2：表示第一次卖出股票
j = 3：表示第二次持有股票
j = 4：表示第二次卖出股票

可以发现除了 j = 0 以外，当 j 为奇数时表示持有股票，为偶数时表示不持有股票。

因为有 k 次交易，所以二维的dp数组的大小可以定义为 2 * k + 1。

1. 确定dp数组以及下标的含义

根据上面的分析，我们可以定义一个二维的dp数组 dp[i][j]

dp[i][j] 表示第 i 天对股票的持有状态为 j 时的最大利润。

2. 确定递推公式

到达 dp[i][1] （第一次持有股票）的状态有两种情况：

第 i 天不买入股票，保持原有状态 dp[i-1][1]。
第 i 天买入股票，说明在第 i - 1 天不持有股票，买入股票后的所持金额为 dp[i-1][0] - prices[i]。

在两者中选择最大的：

dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);

同理到达 dp[i][2] （第一次不持有股票）的状态有两种情况：

第 i 天不卖出股票，保持原有状态 dp[i-1][2]。
第 i 天卖出股票，说明在第 i - 1 天持有股票，卖出股票后的所持金额为 dp[i-1][1] + prices[i]。

在两者中选择最大的：

dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);

同理类比以上的状态，我们可以得到其他状态的递推公式：

for (int j = 0; j < 2 * k - 1; j += 2) {
    dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
    dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
}

3. 初始化dp数组

我们可以发现 dp[i][j] 的都是由 dp[i-1][j] 和 dp[i-1][j+1] 递推而来，因此我们可以先初始化 dp[0][j]。

第0天没有操作，所以 dp[0][0] = 0。
第0天第一次持有股票，即首日就买入股票，所以 dp[0][1] = -prices[0]。
第0天第一次不持有股票，即首日就买入卖出，所以 dp[0][2] = 0。
第0天第二次持有股票，所以 dp[0][3] = -prices[0]。
第0天第二次不持有股票，所以 dp[0][4] = 0。
...

所以在这里我们可以当 j 为偶数时，dp[0][j] = 0，当 j 为奇数时，dp[0][j] = -prices[0]。

for (int j = 1; j < 2 * k; j += 2) {
    dp[0][j] = -prices[0];
}

4. 遍历顺序

我们可以发现 dp[i][j] 的都是由 dp[i-1][j] 和 dp[i-1][j+1] 递推而来，因此遍历顺序是从前往后

5. 整体代码

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0)); // 二维dp数组，大小为2*k+1
        for (int j = 1; j < 2 * k; j += 2) { // 初始化dp数组
            dp[0][j] = -prices[0];
        }
        for (int i = 1; i < prices.size(); i++) {
            for (int j = 0; j < 2 * k - 1; j += 2) {
                dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
                dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
            }
        }
        return dp[prices.size() - 1][2 * k];
    }
};

最佳买卖股票时机含冷冻期

309. 最佳买卖股票时机含冷冻期

1. 确定dp数组以及下标的含义

我们可以定义一个二维的dp数组来表示状态。

dp[i][j] 第i天状态为j，所剩的最多现金为dp[i][j]。

2. 确定递推公式

具体可以区分出如下四个状态：

状态一：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
不持有股票状态，这里就有两种卖出股票状态
- 状态二：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
- 状态三：今天卖出股票
状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天

我们可以将 j 状态表示为:

j = 0：状态1
j = 1：状态2
j = 2：状态3
j = 3：状态4

冷冻期的前一天，只能是「今天卖出股票」状态，如果是「不持有股票状态」那么就很模糊，因为不一定是卖出股票的操作。

到达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：
- 前一天持有股票，保持不变，dp[i-1][0]。
- 前一天不持有股票，今天买入股票，那么又会有两种情况：
  - 前一天是冷冻期（状态四），那么今天买入股票的金额为 dp[i-1][3] - prices[i]。
  - 前一天是卖出股票（状态二），那么今天买入股票的金额为 dp[i-1][1] - prices[i]。
所以 dp[i][0] 的状态转移方程为：
```
dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);
```
到达到卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：
- 前一天就是卖出股票的状态，保持不变，dp[i-1][1]。
- 前一天是冷冻期（状态四），那么今天卖出股票的金额为 dp[i-1][3]。
所以有：
```
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
```
到达今天卖出股票状态（状态三）即：dp[i][2]，就只有一个操作：
- 前一天一定是持有股票状态（状态一），那么今天卖出股票的金额为 dp[i-1][0] + prices[i]。
所以有：
```
dp[i][2] = dp[i - 1][0] + prices[i];
```
到达冷冻期状态（状态四）即：dp[i][3]，就只有一个操作：
- 昨天一定是卖出股票状态（状态三），今天冷冻期的金额为 dp[i-1][2]。
所以有：
```
dp[i][3] = dp[i - 1][2];
```

因此我们可以得到状态转移方程：

dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
dp[i][2] = dp[i - 1][0] + prices[i];
dp[i][3] = dp[i - 1][2];

3. 初始化dp数组

对于第0天的状态，我们可以直接初始化：

状态一：dp[0][0] = -prices[0]，表示第0天买入股票。
状态二：dp[0][1] = 0
状态三：dp[0][2] = 0
状态四：dp[0][3] = 0

4. 遍历顺序

我们可以发现 dp[i][j] 的都是由 dp[i-1][j] 和 dp[i-1][j+1] 递推而来，因此遍历顺序是从前往后

5. 整体代码


class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if (n == 0) return 0;
        vector<vector<int>> dp(n, vector<int>(4, 0));
        dp[0][0] -= prices[0]; // 持股票
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]));
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
            dp[i][2] = dp[i - 1][0] + prices[i];
            dp[i][3] = dp[i - 1][2];
        }
        return max(dp[n - 1][3], max(dp[n - 1][1], dp[n - 1][2]));
    }
};

Day41-动态规划 part08

Mon, 21 Apr 2025 00:00:00 GMT

买卖股票 I

121. 买卖股票的最佳时机

1. 确定dp数组以及下标的含义

我们可以用一个二维的dp数组来表示状态。

dp[i][j] 表示第 i 天持有股票的最大利润，j 代表持有状态，0 代表持有，1 代表不持有。 dp[i][0] 表示第 i 天持有股票的最大利润，dp[i][1] 表示第 i 天不持有股票的最大利润。

2. 确定递推公式

如果第 i 天持有股票，即 dp[i][0]，那么有两种情况：
- 第 i-1 天也持有股票，即状态和第 i - 1 天一样，所持金额为 dp[i-1][0]。
- 第 i-1 天不持有股票，说明在第 i 天买入了股票，所得所持现金就是买入今天的股票后所得现金，也就是 -prices[i]。
那么 dp[i][0] 应当选择最大的所持金额：
```
dp[i][0] = max(dp[i - 1][0], -prices[i]);
```
如果第 i 天不持有股票，即 dp[i][1]，那么有两种情况：
- 第 i-1 天也不持有股票，即状态和第 i - 1 天一样，所持金额为 dp[i-1][1]。
- 第 i-1 天持有股票，说明在第 i 天卖出了股票，所得所持现金就是卖出今天的股票后所得现金，那么所持金就要加上今天卖出的股票的价格，也就是 dp[i-1][0] + prices[i]。
同样的，dp[i][1] 应当选择最大的所持金额：
```
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
```

3. 初始化dp数组

我们可以发现 dp[i][0] 和 dp[i][1] 的都是由 dp[i-1][0] 和 dp[i-1][1] 递推而来，因此我们可以先初始化 dp[0][0] 和 dp[0][1]。

dp[0][0] 表示第 0 天持有股票的最大利润，也就是第 0 天就买入了股票，所持金额为 -prices[0]（我们假设初始现金为0）。
dp[0][1] 表示第 0 天不持有股票的最大利润，也就是第 0 天不买入股票，所持金额为 0。

4. 遍历顺序

显然我们的遍历顺序是从前往后遍历的。

5. 整体代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() <= 1) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(2, 0));
        dp[0][0] = -prices[0]; // 第 0 天持有股票
        dp[0][1] = 0; // 第 0 天不持有股票

        for (int i = 1; i < prices.size(); i++) {
            dp[i][0] = max(dp[i - 1][0], -prices[i]); // 持有股票
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]); // 不持有股票
        }
        return max(dp[prices.size() - 1][0], dp[prices.size() - 1][1]);
    }
};

买卖股票 II

122. 买卖股票的最佳时机 II

本题和买卖股票 I 的区别在于：

买卖股票 I 只能进行一次交易，而买卖股票 II 可以进行多次交易。

唯一不同的地方，就是推导 dp[i][0] 的时候，第i天买入股票的情况。

因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。

如果第 i 天买入股票，所得现金就是昨天不持有股票的所得现金减去今天的股票价格即：dp[i - 1][1] - prices[i]。

整体代码：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        // 动态规划
        int n = prices.size();
        if (n < 2) return 0;
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] = -prices[0]; // 第 0 天持有股票
        dp[0][1] = 0; // 第 0 天不持有股票

        for (int i = 1; i < n; i++) {
            // 持有股票，在前一天不持有股票的基础上买入
            // 那么今天的利润就是前一天不持有股票的利润减去今天的价格
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); 
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]); // 不持有股票
        }
        return dp[n - 1][1]; // 返回最后一天不持有股票的最大利润
    }
};

买卖股票 III

123. 买卖股票的最佳时机 III

1. 确定dp数组以及下标的含义

和买卖股票 I, II 类似，我们可以用一个二维的dp数组来表示状态。

dp[i][j] 表示第 i 天持有股票的最大利润，j 代表持有状态，0 代表不操作，1 代表第一次持有，2 代表第一次不持有，3 代表第二次持有，4 代表第二次不持有。

dp[i][0] 表示第 i 天不操作的最大利润
dp[i][1] 表示第 i 天第一次持有股票的最大利润
dp[i][2] 表示第 i 天第一次不持有股票的最大利润
dp[i][3] 表示第 i 天第二次持有股票的最大利润
dp[i][4] 表示第 i 天第二次不持有股票的最大利润

2. 确定递推公式

对于第 i 天不操作的最大利润，即 dp[i][0]，那么 dp[i][0] 就是前一天的最大利润 dp[i - 1][0]。
对于 dp[i][1] 第 i 天第一次持有股票的最大利润, 我们可以有两个操作：
- 第 i 天买入股票，那么所持现金就是前一天不操作的最大利润减去今天的股票价格，即 dp[i - 1][0] - prices[i]。
- 第 i 天不操作，那么所持现金就是前一天第一次持有股票的最大利润，即 dp[i - 1][1]。
那么 dp[i][1] 应当选择最大的所持金额：
```
dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);
```
对于 dp[i][2] 第 i 天第一次不持有股票的最大利润, 类似的我们可以有两个操作：
- 第 i 天卖出股票，那么所持现金就是前一天第一次持有股票的最大利润加上今天的股票价格，即 dp[i - 1][1] + prices[i]。
- 第 i 天不操作，那么所持现金就是前一天第一次不持有股票的最大利润，即 dp[i - 1][2]。
那么 dp[i][2] 应当选择最大的所持金额：
```
dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2]);
```

同理，我们可以推导出 dp[i][3] 和 dp[i][4] 的递推公式：

dp[i][3] = max(dp[i - 1][2] - prices[i], dp[i - 1][3]);
dp[i][4] = max(dp[i - 1][3] + prices[i], dp[i - 1][4]);

3. 初始化dp数组

第0天没有操作，就是0，即：dp[0][0] = 0; 第0天做第一次买入的操作，dp[0][1] = -prices[0]; 第0天做第一次卖出的操作, 可以理解为第一天就买入并卖出，dp[0][2] = 0; 第0天做第二次买入的操作，相当于第一天买入并卖出，再买入，dp[0][3] = -prices[0]; 第0天做第二次卖出的操作, 可以理解为第一天买入并卖出，之后再买入并卖出，dp[0][4] = 0;

4. 遍历顺序

从递推公式我们可以看出，dp[i][0] 依赖于 dp[i-1][0]，因此我们需要从前往后遍历。

5. 整体代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() < 2) return 0;
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(5, 0)); // dp[i][j]表示第i天第j种状态的最大利润
        dp[0][0] = 0; // 不操作，即为0
        dp[0][1] = -prices[0]; // 第0天买入股票
        dp[0][2] = 0; // 第0天卖出股票，即为0
        dp[0][3] = -prices[0]; // 第0天第二次买入股票
        dp[0][4] = 0; // 第0天第二次卖出股票，即为0

        for (int i = 1; i < n; i++) {
            dp[i][0] = dp[i - 1][0]; // 不操作
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]); // 第i天第一次持有股票
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]); // 第i天第一次不持有股票
            dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]); // 第i天第二次持有股票
            dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]); // 第i天第二次不持有股票
        }
        // return max(dp[n - 1][2], dp[n - 1][4]); // 返回最后一天的最大利润
        return dp[n - 1][4]; // 返回最后一天第二次卖出股票的最大利润
    }
};

Day39-动态规划 part07

Sun, 20 Apr 2025 00:00:00 GMT

打家劫舍 I

198. 打家劫舍

1. 确定dp数组以及下标的含义

dp[i] 表示偷前 i 个房子能获得的最大金额

2. 确定递推公式

如果偷第 i 个房子，那么前 i-1 个房子不能偷，因此 dp[i] = dp[i-2] + nums[i]
如果不偷第 i 个房子，那么前 i 个房子能获得的最大金额为 dp[i-1]。

因此递推公式为：

dp[i] = max(dp[i-1], dp[i-2] + nums[i]);

3. 初始化dp数组

dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])

4. 遍历顺序

由于 dp[i] 依赖于 dp[i-1] 和 dp[i-2]，因此我们需要从前往后遍历。

5. 整体代码

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) return 0;
        if (n == 1) return nums[0];

        vector<int> dp(n);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);

        for (int i = 2; i < n; i++) {
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        }

        return dp[n - 1];
    }
};

打家劫舍 II

1. 确定dp数组以及下标的含义

和打家劫舍 I 类似，但因为房子是环形的，所以我们不能同时偷第一个和最后一个房子。

我们将问题拆解成两个子问题：

偷第 0 ~ n-2 间房屋（不偷最后一间）
偷第 1 ~ n-1 间房屋（不偷第一间）

每个子问题都是打家劫舍 I 的线性版本。

我们设：

dp[i] 表示从第 i 间房屋开始偷，到当前能偷到的最大金额

2. 确定递推公式

与打家劫舍 I 相同：

dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])

3. 初始化dp数组

对于子问题 [start ~ end]：

dp[start] = nums[start]
dp[start + 1] = max(nums[start], nums[start + 1])

4. 遍历顺序

从 start + 2 开始到 end，依次计算 dp[i]。

5. 整体代码（包含空间优化）

class Solution {
private:
    int robRange(vector<int>& nums, int start, int end) {
        if (start == end) return nums[start];
        int pre2 = nums[start];
        int pre1 = max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; ++i) {
            int cur = max(pre1, pre2 + nums[i]);
            pre2 = pre1;
            pre1 = cur;
        }
        return pre1;
    }

public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) return 0;
        if (n == 1) return nums[0];
        return max(robRange(nums, 0, n - 2), robRange(nums, 1, n - 1));
    }
};

打家劫舍 III

1. 确定dp数组以及下标的含义

本题的结构是二叉树，不能用下标作为状态，因此不能直接使用数组。

我们使用树形动态规划，对每一个节点 root：

记录两个状态：
- 偷当前节点：dp[root][1]（当前节点值 + 左右子树不偷的结果）
- 不偷当前节点：dp[root][0]（左右子树偷或不偷的最大值之和）

由于树是结构体，不能直接建立数组，用函数返回 pair<int, int> 实现。

2. 确定递推公式

设当前节点为 node，左右子树为 left 和 right，对应状态分别为 (l0, l1) 和 (r0, r1)：

dp[node][1] = node->val + l0 + r0      // 偷当前节点
dp[node][0] = max(l0, l1) + max(r0, r1) // 不偷当前节点

3. 初始化dp数组

后序遍历中，递归到空节点时返回 {0, 0} 表示偷与不偷都为0。

4. 遍历顺序

后序遍历（从叶子到根），因为我们在计算当前节点状态时需要用到左右子树的状态。

5. 整体代码

class Solution {
private:
    pair<int, int> dfs(TreeNode* root) {
        if (!root) return {0, 0};

        auto left = dfs(root->left);
        auto right = dfs(root->right);

        int rob = root->val + left.second + right.second;
        int notRob = max(left.first, left.second) + max(right.first, right.second);

        return {rob, notRob};
    }

public:
    int rob(TreeNode* root) {
        auto res = dfs(root);
        return max(res.first, res.second);
    }
};

Day38-动态规划 part06

Sat, 19 Apr 2025 00:00:00 GMT

零钱兑换

322. 零钱兑换

这题与零钱兑换 II的区别在于：本题在于求最少的硬币数量，而零钱兑换 II 是求组合数。

转换为背包问题：

背包容量：amount，即目标金额。
物品：coins，即硬币的面值。
物品的体积：coins[i]，即硬币的面值。

1. 确定dp数组以及下标的含义

dp[i]：表示背包容量为 i 时，所需的最少硬币数量。

2. 确定递推公式

要凑满 j - coins[i] 的金额，最少需要 dp[j - coins[i]] 个硬币。
那么要凑满 j 的金额，最少需要 dp[j - coins[i]] + 1 个硬币，也就是 dp[j] 的值。
不放硬币 i：背包容量为 j，最少需要 dp[j] 个硬币。
我们的目标是求最少的硬币数量，因此我们需要取最小值。

因此递推公式为：

dp[j] = min(dp[j], dp[j - coins[i]] + 1);

3. 初始化dp数组

首先凑满0的金额需要0个硬币，因此 dp[0] = 0。
但因为递推公式的性质，我们要求的是最小值，因此我们需要初始化 dp[j] 为一个较大的数。可以用 INT_MAX 来表示。

4. 遍历顺序

本题求的是最少的硬币数量，与排列组合问题无关，一次我们的遍历顺序可以先背包或者先物品。

for (int i = 1; i <= amount; ++i) {
    for (int j = 0; j < coins.size(); ++j) {
        if (i >= coins[j]) {
            dp[i] = min(dp[i], dp[i - coins[j]] + 1);
        }
    }
}

5. 整体代码

class Solution {
private:
    void printDp(const vector<int>& dp) {
        for (auto _dp : dp) {
            if (_dp == INT_MAX) cout << "INF ";
            else cout << _dp << ' ';
        }
        cout << endl;
    }

public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1, INT_MAX);
        dp[0] = 0;
        
        for (auto coin : coins) { // 先遍历物品
            // cout << "coin = " << coin << endl;
            for (auto j = coin; j <= amount; j++) { // 再遍历背包
                // 边界处理，可能出现 INT_MAX + 1 溢出
                // dp[j - coin] == INT_MAX，代表此时尚未找到能凑出 j - coin 金额的方案。
                if (dp[j - coin] != INT_MAX) { 
                    dp[j] = min(dp[j], dp[j - coin] + 1);
                }
            }
            // printDp(dp);
            // cout << "----------" << endl;
        }
        return dp[amount] == INT_MAX ? -1 : dp[amount];
    }
};

这里因为我们的 dp[j] 是从 dp[j - coin] 推算出来的，也就是说，我们要知道凑成金额为 j - coin 的最小硬币数，才能推算出凑成金额为 j 的最小硬币数。

如果 dp[j - coin] 是 INT_MAX，即说明我们还没有找到凑成金额为 j - coin 的方案，那么我们就不能用 dp[j - coin] + 1 来推算出 dp[j]。

完全平方数

279. 完全平方数

我们可以把这题解释为：我们可以使用任意个数的完全平方数，去凑成一个目标值 n，然后求出最少的完全平方数的个数。

因此我们可以把这题转换为背包问题：

背包容量：n，即目标值。
物品：1, 4, 9, 16, ...，即完全平方数。
物品的体积：i * i，即完全平方数的值。

1. 确定dp数组以及下标的含义

dp[j]：表示背包容量（凑成总和）为 j 时，所需的最少完全平方数的个数。

2. 确定递推公式

要凑成总和 j，当前遍历到的完全平方数为 i * i，那么我们可以选择放入这个完全平方数，或者不放入。
- 放入 i * i：那么我们需要凑成 j - i * i 的总和，最少需要 dp[j - i * i] + 1 个完全平方数。
不放入 i * i：那么我们需要凑成 j 的总和，最少需要 dp[j] 个完全平方数。
我们的目标是求最少的完全平方数的个数，因此我们需要取最小值。

因此递推公式为：

dp[j] = min(dp[j], dp[j - i * i] + 1);

可以发现这里的解法其实就和零钱兑换问题是一样的。

3. 初始化dp数组

首先凑满和为 0 的完全平方数的个数为 0，因此 dp[0] = 0。
但因为递推公式的性质，我们要求的是最小值，因此我们需要初始化 dp[j] 为一个较大的数。可以用 INT_MAX 来表示。

因此初始化 dp 数组为：

dp[0] = 0; // 凑成总和为0的完全平方数的个数为0
for (int j = 1; j <= n; ++j) {
    dp[j] = INT_MAX; // 凑成总和为j的完全平方数的个数为无穷大
}

4. 遍历顺序

本题求的是最少的完全平方数的个数，与排列组合问题无关，一次我们的遍历顺序可以先背包或者先物品。

5. 整体代码

class Solution {
private:
    void printDp(const vector<int>& dp) {
        for (auto _dp : dp) {
            if (_dp == INT_MAX) {
                cout << "INF" << " ";
            } else {
                cout << _dp << " ";
            }
        }
        cout << endl;
        cout << "--------------" << endl;
    }

public:
    int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0; // 初始化：和为0需要0个完全平方数

        for (int i = 1; i * i <= n; i++) { // 遍历物品（完全平方数）
            for (int j = i * i; j <= n; j++) { // 遍历背包容量
                if (dp[j - i * i] != INT_MAX) {
                    dp[j] = min(dp[j], dp[j - i * i] + 1);
                }
            }
            // printDp(dp);
        }
        return dp[n];
    }
};

单词拆分

139. 单词拆分

本题是一个“字符串切割 + 判断的”问题，可以类比成字符串长度为背包容量，字典中的单词为物品，判断能否恰好组成字符串。

1. 确定dp数组以及下标的含义

dp[i]：表示字符串 s[0...i-1] 是否可以被拆分成字典中的单词。

2. 确定递推公式

我们枚举每一个位置 i，再枚举 j（j < i），看 s[j:i] 是否是字典中的单词，如果是且 dp[j] == true，那么 dp[i] = true

dp[i] = dp[j] && (s[j:i] ∈ wordDict)

3. 初始化dp数组

从递推公式中可以看出，dp[i] 的状态依靠 dp[j] 是否为 true，那么 dp[0] 就是递推的基础，dp[0]一定要为 true，否则递推下去后面都是 false 了。

4. 遍历顺序

题目中说是拆分为一个或多个在字典中出现的单词，所以这是完全背包。还要讨论两层for循环的前后顺序。

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

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

而本题我们要求的其实是排列，我们可以拿以下例子：

s = "applepenapple"
wordDict = ["apple", "pen"]

那么我们在物品中选择 "apple" + "pen" + "apple"，才能组成 "applepenapple"。

如果选择 "pen" + "apple" + "apple"，虽然单词都在字典中，但是不能组成 "applepenapple"。

因此这里强调了一个单词之间顺序的问题。

所以我们的遍历顺序应该是：外层for循环遍历背包，内层for循环遍历物品。

for (int i = 1; i <= s.size(); i++) { // 遍历背包容量，从1~字符串长度
    for (int j = 0; j < i; j++) { // 遍历物品（单词）
        string word = s.substr(j, i - j); // 从j到i的子串
        // 如果当前子串在字典中，并且前面部分可以拆分成单词
        // dp[j] == true 代表前面部分可以拆分成单词
        // dp[i] == true 代表当前子串可以拆分成单词
        if (set.find(word) != set.end() && dp[j]) {
            dp[i] = true;
        }
    
    }
}

5. 整体代码

class Solution {
private:    
    void printDp(const vector<bool>& dp) {
        for (auto _dp : dp) {
            cout << _dp << " ";
        }
        cout << endl;
        cout << "--------------" << endl;
    }

public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> set(wordDict.begin(), wordDict.end());

        vector<bool> dp(s.size() + 1, false);
        dp[0] = true; // 空字符串可以被拆分成字典中的单词

        for (int i = 1; i <= s.size(); i++) { // 遍历背包容量，从1~字符串长度
            for (int j = 0; j < i; j++) { // 遍历物品（单词）
                string word = s.substr(j, i - j); // 从j到i的子串
                // 如果当前子串在字典中，并且前面部分可以拆分成单词
                // dp[j] == true 代表前面部分可以拆分成单词
                // dp[i] == true 代表当前子串可以拆分成单词
                if (set.find(word) != set.end() && dp[j]) {
                    dp[i] = true;
                }
            }
            // printDp(dp);
        }
        return dp[s.size()];
    }
};

Day37-动态规划 part05

Thu, 17 Apr 2025 00:00:00 GMT

完全背包问题

完全背包与0-1背包问题非常相似，不同之处在于：

每种物品可以选择无限次，而不是只能选一次。

假设有 N 件物品和一个容量为 W 的背包。每件物品有两个属性：

体积：v[i]
价值：w[i]

目标是从这些物品中选取若干件（每种物品可以选无限多次），使得在不超过背包容量的前提下，获得的最大总价值是多少。

完全背包的二维dp表示

1. 确定dp数组以及下标的含义

dp[i][j]：表示从下标为 [0-i] 的物品，每个物品可以取无限次，放进容量为 j 的背包，价值总和最大是多少。

2. 确定递推公式

不放物品 i：背包容量为 j，最大价值为 dp[i-1][j]。
放物品 i：背包空出物品 i 的体积 v[i]，剩余容量为 j - v[i]，dp[i][j - v[i]] 表示背包容量为 j - v[i] 时的最大价值。那么放入物品 i 后的最大价值为：dp[i][j - v[i]] + w[i]。
- 放入物品 i 后，背包容量为 j - v[i]，但是物品 i 还可以继续放入背包中，因此我们还是在考虑物品 i。

因此递推公式为：

dp[i][j] = max(dp[i-1][j], dp[i][j - v[i]] + w[i]);

这里与0-1背包的递推公式不同的是：dp[i][j - v[i]] 这里的 i 没有减去1，也就是说物品 i 还可以继续放入背包中。

0 - 1背包的递推公式为：

dp[i][j] = max(dp[i-1][j], dp[i-1][j - v[i]] + w[i]);

3. 初始化dp数组

首先从 dp[i][j] 的定义出发，如果背包容量 j 为0的话，即 dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。

状态转移方程中： dp[i][j] = max(dp[i-1][j], dp[i-1][j - v[i]] + w[i]) 可以看出，dp[i][j] 依赖于 dp[i-1][j] 和 dp[i][j - v[i]]。可以看出有一个方向 i 是由 i-1 推导出来，那么 i 为0的时候就一定要初始化。因此我们需要初始化 dp[0][j]，即当没有物品时，背包的最大价值为0。

dp[0][j]，即：存放编号0的物品的时候，各个容量的背包所能存放的最大价值。

那么很明显当 j < v[0] 时，dp[0][j] 应该为0，因为背包容量不够放下物品0。
当 j >= v[0] 时，dp[0][j] 应该为 w[0]，因为背包容量足够放下物品0。

j >= v[0] ，dp[0][j] 如果能放下 v[0] 的话，就一直装，每一种物品有无限个。

因此我们可以初始化 dp[0][j] 为：

vector<int> dp(W + 1, 0);
for (int j = 0; j <= W; ++j) {
    if (j >= v[0]) {
        dp[j] = w[0];
    }
}

4. 遍历顺序

在0 - 1背包中，先遍历物品，再遍历背包容量，或者是先遍历背包容量，再遍历物品，都是可行的，因为这是由推导顺序决定的。

// 先遍历物品，再遍历背包容量
for (int i = 0; i < N; ++i) {
    for (int j = 1; j <= W; ++j) {
        if (j < v[i]) {
            dp[i][j] = dp[i-1][j]; // 背包容量不够放下物品i
        } else {
            dp[i][j] = max(dp[i-1][j], dp[i][j - v[i]] + w[i]); // 放下物品i
        }
    }
}

// 先遍历背包容量，再遍历物品
for (int j = 0; j <= W; ++j) {
    for (int i = 1; i < N; ++i) {
        if (j < v[i]) {
            dp[i][j] = dp[i-1][j]; // 背包容量不够放下物品i
        } else {
            dp[i][j] = max(dp[i-1][j], dp[i][j - v[i]] + w[i]); // 放下物品i
        }
    }
}

5. 整体代码

vector<int> knapsack(int W, vector<int>& v, vector<int>& w) {
    int N = v.size();
    vector<vector<int>> dp(N + 1, vector<int>(W + 1, 0)); // dp[i][j]表示从下标为[0-i]的物品，每个物品可以取无限次，放进容量为j的背包，价值总和最大是多少。
    
    for (int j = 0; j <= W; ++j) {
        if (j >= v[0]) {
            dp[0][j] = w[0];
        }
    }

    for (int i = 1; i < N; ++i) {
        for (int j = 0; j <= W; ++j) {
            if (j < v[i]) {
                dp[i][j] = dp[i-1][j]; // 背包容量不够放下物品i
            } else {
                dp[i][j] = max(dp[i-1][j], dp[i][j - v[i]] + w[i]); // 放下物品i
            }
        }
    }

    return dp[N - 1]; // 返回最后一行，即所有物品的最大价值
}

完全背包的一维dp表示

1. 确定dp数组以及下标的含义

dp[j]：表示从下标为 [0-N] 的物品，每个物品可以取无限次，放进容量为 j 的背包，价值总和最大是多少。

2. 确定递推公式

在上面的二维dp表示中，dp[i][j] = max(dp[i-1][j], dp[i][j - v[i]] + w[i])。

for (int i = 0; i < N; ++i) {
    for (int j = 1; j <= W; ++j) {
        if (j < v[i]) {
            dp[i][j] = dp[i-1][j]; // 背包容量不够放下物品i
        } else {
            dp[i][j] = max(dp[i-1][j], dp[i][j - v[i]] + w[i]); // 放下物品i
        }
    }
}

将上一层 dp[i-1] 的那一层拷贝到当前层 dp[i] ，那么递推公式由：dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]) 变成： dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i])

所以我们可以将二维dp表示转化为一维dp表示。

dp[j] = max(dp[j], dp[j - v[i]] + w[i]);

这里的 j 是从 W 到 v[i] 递减的，表示当前背包容量为 j，如果放入物品 i，那么剩余容量为 j - v[i]。

3. 初始化dp数组

vector<int> dp(W + 1, 0);

4. 遍历顺序

在完全背包中，对于一维dp数组来说，其实两个for循环嵌套顺序是无所谓的，因为 dp[j] 是根据下标 j 之前所对应的 dp[j] 计算出来的。只要保证下标j之前的 dp[j] 都是经过计算的就可以了。

// 先遍历物品，再遍历背包容量
for (int i = 0; i < N; ++i) {
    for (int j = v[i]; j <= W; ++j) { // 从v[i]开始遍历
        dp[j] = max(dp[j], dp[j - v[i]] + w[i]); // 放下物品i
    }
}

// 先遍历背包容量，再遍历物品
for (int j = 0; j <= W; ++j) {
    for (int i = 0; i < N; ++i) { // 从0开始遍历
        if (j >= v[i]) {
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]); // 放下物品i
        }
    }
}

零钱兑换 II

518. 零钱兑换 II

1. 状态定义

dp[i] 表示金额为 i 的组合数。

2. 状态转移方程

dp[i] = dp[i] + dp[i - coins[j]]

意思是：对于当前硬币 coin，凑成金额 j 的方法数 = 凑成金额 j - coin 的方法数之和。

dp[i] 表示当前金额为 i 的组合数。
dp[i - coins[j]] 表示当前金额为 i - coins[j] 的组合数。

3. 初始化

dp[0] = 1，表示凑成金额为0的组合数为1（即不选任何数字）。

4. 遍历顺序

因为纯完全背包求得装满背包的最大价值是多少，和凑成总和的元素有没有顺序没关系，即：有顺序也行，没有顺序也行。

而本题要求凑成总和的组合数，元素之间明确要求没有顺序。所以纯完全背包是能凑成总和就行，不用管怎么凑的。本题是求凑出来的方案个数，且每个方案个数是组合数。

正确的遍历顺序应该是：先遍历硬币，再遍历容量(金额)

for (int coin : coins) {
    for (int j = coin; j <= amount; ++j) {
        dp[j] += dp[j - coin];
    }
}

此时先遍历硬币，就是求组合。如果先遍历的是容量，那么就会出现重复计算的情况，也就是求的是排列。

5. 整体代码

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount + 1, 0);
        dp[0] = 1; // 凑出金额为0的组合数是1（空集）

        for (int coin : coins) {           // 遍历每种硬币（物品）
            for (int j = coin; j <= amount; ++j) { // 遍历容量，从小到大
                if (dp[j] < INT_MAX - dp[j - coin]) { //防止相加数据超int
                    dp[j] += dp[j - coin];
                }
            }
        }
        return dp[amount];
    }
};

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

组合总和 IV

377. 组合总和 IV

因为本题的描述中，元素相同但顺序不同的组合算作不同的组合，所以这其实是一个排列问题。

所以本题的思路和零钱兑换 II 是一样的，只不过本题是求排列数。

遍历顺序是：先遍历背包，再遍历物品。

这里就直接给出代码了：

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        // 求的是排列
        vector<unsigned int> dp(target + 1, 0);
        dp[0] = 1; // 凑出金额为0的组合数是1（空集）

        for (int i = 1; i <= target; ++i) { // 遍历容量，从小到大
            for (int num : nums) {           // 遍历每种硬币（物品）
                if (i >= num) {
                    dp[i] += dp[i - num];
                }
            }
        }
        return dp[target];
    }
};

爬楼梯 - 完全背包问题

70. 爬楼梯

这里我们将爬楼梯的规则稍微改一下：

每次可以爬 1 ~ 无限步。
也就是每次可以选择爬 1 步，2 步，3 步，...，n 步。

问题：有多少种不同的方式可以爬到楼梯的顶部？

那么这里就变成了一个完全背包问题了。

跳多少阶楼梯 -> 背包容量
爬楼梯的方式 -> 物品

背包问题	爬楼梯
背包容量 n	要达到的目标楼梯高度 n
物品	每次可以选择的步数 1, 2, ..., n
物品体积	每次爬的步数
物品价值	这里我们不是求最大价值，而是求组合数（方案数）

1. 状态定义

dp[i] 表示爬到第 i 层楼梯的方式数。

2. 状态转移方程

装满背包有几种方法，递推公式一般都是 dp[i] += dp[i - nums[j]];

本题呢，dp[i] 有几种来源，dp[i - 1]，dp[i - 2]，dp[i - 3] 等等，即：dp[i - j]

那么递推公式为：dp[i] += dp[i - j]`

3. 初始化

dp[0] = 1，表示爬到第0层楼梯的方式数为1（即不爬）。

4. 遍历顺序

这是背包里求排列问题，即：1、2 步和 2、1 步都是上三个台阶，但是这两种方法是不同的，所以我们需要先遍历背包，再遍历物品。

for (int i = 1; i <= n; ++i) { // 遍历背包
    for (int j = 1; j <= m; ++j) { // 遍历物品
        if (i >= j) {
            dp[i] += dp[i - j];
        }
    }
}

5. 整体代码

class Solution {
public:
    int climbStairs(int n) {
        vector<int> dp(n + 1, 0);
        dp[0] = 1; // 爬到第0层楼梯的方式数为1（即不爬）

        for (int i = 1; i <= n; ++i) { // 遍历背包
            for (int j = 1; j <= i; ++j) { // 遍历物品
                if (i >= j) {
                    dp[i] += dp[i - j];
                }
            }
        }
        return dp[n];
    }
};

Day36-动态规划 part04

Wed, 16 Apr 2025 00:00:00 GMT

最后一块石头的重量II

1049. 最后一块石头的重量 II

题中要求的是两两石头相撞之后的重量差的最小值。

这也就意味着，我们应该尽可能让石头分成重量相等的两堆，那么相撞之后剩下的石头就是最小的重量。

因此这也和分割等和子集是相似的，也就是一个0 - 1背包问题。

唯一的区别是：分割等和子集是求是否可以分割成两堆相等的重量，如果凑不成就返回false，否则返回true。而这个题是求最小的重量差，因此可以两堆石头的重量不相等。

转换成背包问题：

物品就是石头，物品的重量为 stone[i]，物品的价值为 stone[i]。
物品的数量为 n，背包的容量为 sum(stone) / 2。

1. 确定dp数组以及下标的含义

dp][j]：表示容量为 j 的背包，最大可以装入的石头重量为 dp[j]。

“最多可以装的价值为 dp[j]” 等同于 “最多可以背的重量为 dp[j]”

2. 确定递推公式

0 - 1背包问题的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])。

对于本题来说，则转变成了：dp[j] = max(dp[j], dp[j - stone[i]] + stone[i])。

3. 初始化dp数组

首先，dp[0] = 0，表示背包容量为0时，最大可以装入的石头重量为0。
dp数组定义为多大：
- 题中给出的石头数量范围是 1 <= stone.length <= 30，重量范围是 1 <= stone[i] <= 100。
- 那么在极端情况下，石头的数量为30，重量为100，那么总重量为3000。
- 我们要求的是背包容量为在总重量的一半，因此我们可以将背包的容量定义为 1501的长度，也就是 vector<int> dp(1501, 0)。

4. 确定遍历顺序

在使用一维dp数组时，外层应该遍历的是物品，内层循环应该是倒序遍历背包容量。

for (int i = 0; i < n; ++i) {                  // 遍历每一个物品
    for (int j = sum / 2; j >= stone[i]; --j) { // 容量从大到小倒序遍历
        dp[j] = max(dp[j], dp[j - stone[i]] + stone[i]);
    }
}

5. 推导dp数组样例

假设我们的输入：stones = [2,7,4,1,8,1], sum = 23，那么我们可以将背包的容量定义为 sum / 2 = 11。

i = 0: 用stone[0], 遍历背包: dp[0...11]: [0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
i = 1: 用stone[1], 遍历背包: dp[0...11]: [0, 0, 2, 2, 2, 2, 2, 7, 7, 9, 9, 9]
i = 2: 用stone[2], 遍历背包: dp[0...11]: [0, 0, 2, 2, 2, 2, 2, 7, 7, 9, 9, 11]
i = 3: 用stone[3], 遍历背包: dp[0...11]: [0, 0, 2, 2, 2, 2, 2, 7, 7, 9, 9, 11]
i = 4: 用stone[4], 遍历背包: dp[0...11]: [0, 0, 2, 2, 2, 2, 2, 7, 7, 9, 9, 11]
i = 5: 用stone[5], 遍历背包: dp[0...11]: [0, 0, 2, 2, 2, 2, 2, 7, 7, 9, 9, 11]

我们得到最终结果：dp[11] = 11，说明我们可以将石头分成两堆，重量分别为11和12，那么此时的差值为1，也就是最小的差值。

6. 返回结果

最后 dp[target] 里表示的就是容量为 target 的背包，最大可以装入的石头重量。那么分成两堆石头的话，剩下的石头重量就是 sum - dp[target]。

在计算 target 的时候，target = sum / 2 因为是向下取整，所以 sum - dp[target] 一定是大于等于dp[target] 的。

那么相撞之后剩下的石头最小重量就是：(sum - dp[target]) - dp[target]。

7. 代码实现

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        vector<int> dp(1501, 0); // dp[i]表示容量为i的背包能装的最大重量
        int sum = accumulate(stones.begin(), stones.end(), 0); // 计算所有石头的总重量
        int target = sum / 2; // 背包的最大容量为总重量的一半

        for (int i = 0; i < stones.size(); i++) { // 遍历每个石头
            for (int j = target; j >= stones[i]; j--) { // 从后往前遍历每个容量
                // 如果当前容量j大于等于当前石头的重量stones[i]，则可以选择放入这个石头
                // 更新dp[j]为放入当前石头后的最大重量
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        // 分成两堆石头，一堆是dp[target]，另一堆是sum - dp[target]
        // 返回两堆石头的重量差的绝对值，即为最后剩下的石头的重量
        return abs(dp[target] - (sum - dp[target]));
    }
};

8. 复杂度分析 & 总结

时间复杂度：O(n * target)，其中n为石头的数量，target为背包的容量。
空间复杂度：O(target)，使用了一维dp数组来存储每个容量的最大重量。

本题其实和分割等和子集几乎是一样的，只是最后对 dp[target] 的处理方式不同。

割等和子集相当于是求背包是否正好装满，而本题是求背包最多能装多少。

目标和

494. 目标和

回溯暴力解法

这里其实和组合总和的思路是一样的，只不过我们可以在每次选择数字的时候选择加号或者减号。

class Solution {
private:
    int dfs(vector<int>& nums, int i, int target) {
        if (i == nums.size()) { // 到达数组末尾
            // 如果目标值为0，说明找到了一个符合条件的组合，返回1；否则返回0
            return target == 0 ? 1 : 0;
        }
        // 递归调用，分别考虑加上当前数字和减去当前数字的两种情况
        return dfs(nums, i + 1, target - nums[i]) + dfs(nums, i + 1, target + nums[i]);
    }

public:
    int findTargetSumWays(vector<int>& nums, int target) {
        // 通过递归的方式计算所有可能的组合
        return dfs(nums, 0, target);
    }
};

但是使用回溯暴力求解法的时间复杂度是O(2^n)，其中n为数组的长度。在力扣上提交的数据为：

141/141 cases passed (948 ms)
Your runtime beats 11.67 % of cpp submissions
Your memory usage beats 97.37 % of cpp submissions (11.3 MB)

动态规划

本题可以通过数学推导转换为 0-1 背包问题：

我们将数组划分为两个子集:

一个子集 P 的数添加 +
另一个子集 N 的数添加 -

目标是使得最终表达式等于 target。

sum(P) - sum(N) = target // P表示加号的数，N表示减号的数
sum(P) + sum(N) = sum // sum表示所有数的和

两式相加可以得到：

2 * sum(P) = target + sum
            ↓
sum(P) = (target + sum) / 2

所以问题转化为：从数组中选一些数字，使它们的和等于 (target + sum) / 2，每个数字只能用一次，一共有多少种选法。

1. 前置判断（剪枝）

首先我们要判断：

int sum = accumulate(nums.begin(), nums.end(), 0);
if ((target + sum) % 2 != 0 || abs(target) > sum) return 0;

(target + sum) 必须为偶数，否则 P 不为整数，不能划分
如果 target > sum，显然无法达到目标

2. 确定dp数组以及下标的含义

dp[j]：表示和为 j 的子集个数（从 nums 中选，元素不可重复）

3. 确定递推公式

对于当前数字 num，我们可以选择放入背包或者不放入背包：

不选当前数字：dp[j] 保持原样

dp[j] = dp[j]

选当前数 num:
- 那么必须从一个“原本和为 j - num 的子集”中，加上当前 num，才能变成和为 j。
- 所以我们有：
```
dp[j] = dp[j] + dp[j - num]
```
- 表示：我们把所有“原本和为 j - num 的子集”，都加上 num，得到新的和为 j 的子集。

最终状态转移方程为：

for (int j = target; j >= num; --j) {
    dp[j] += dp[j - num];
}

dp[j - num] 表示之前已有多少种方法能组成 j - num
把当前 num 加进去就能组成 j

4. 初始化dp数组

dp[0] = 1：表示和为0的子集只有一种，就是不选任何数字
其余 dp[j] = 0

5. 确定遍历顺序

外层遍历每个物品 i
内层倒序遍历容量 j，从 target 到 num

6. 代码实现

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = accumulate(nums.begin(), nums.end(), 0); // 计算所有数字的总和
        if (sum < target || (sum - target) % 2 != 0) return 0; // 如果目标不可能达到，返回0
        int s = (sum - target) / 2; // 将问题转化为背包问题，求子集和为s的组合数

        vector<int> dp(s + 1, 0); // dp[i]表示和为i的组合数
        dp[0] = 1; // 和为0的组合数为1（即不选任何数字）

        for (int num : nums) { // 遍历每个数字
            for (int j = s; j >= num; j--) { // 从后往前遍历每个容量
                dp[j] += dp[j - num]; // 更新dp[j]为当前数字num的组合数
            }
        }
        return dp[s]; // 返回和为s的组合数
    }
};

一和零

474. 一和零

1. 状态定义

我们使用二维数组 dp[i][j] 表示状态：

dp[i][j] 表示在限定 i 个 0 和 j 个 1 的容量下，最多可以选择多少个字符串。
初始时所有 dp[i][j] = 0，表示一个字符串都不选。

2. 状态初始化

初始化条件为 dp[0][0] = 0，含义是：不使用任何 0 或 1，最多能选 0 个字符串；
其余 dp[i][j] 也初始化为 0，表示在该容量下尚未选择任何字符串。

3. 状态转移方程

对于每个字符串 s ∈ strs，我们统计它的 0 和 1 数量分别为 zeros 和 ones。然后进行如下状态更新：

for (int i = m; i >= zeros; --i) {
    for (int j = n; j >= ones; --j) {
        dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1);
    }
}

解释如下：

不选当前字符串 s：dp[i][j] 保持不变；
选当前字符串 s：
- 要消耗 zeros 个 0 和 ones 个 1；
- 那么剩余容量为 i - zeros 和 j - ones；
- 对应的最大选择数为 dp[i - zeros][j - ones]，加上当前字符串，变为 dp[i - zeros][j - ones] + 1；
两种方案取最大值，表示当前容量下最多可选字符串数。

4. 遍历顺序

必须从大到小（倒序）枚举 i 和 j，这是因为每个字符串只能使用一次（符合 0-1 背包特性）。如果从小到大遍历，会导致同一个字符串被多次选入。

5. 最终结果

状态转移结束后，最终结果为 dp[m][n]，表示在不超过 m 个 0 和 n 个 1 的条件下，最多可以选择多少个字符串。

6. 代码实现

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        // 初始化二维 dp 数组，dp[i][j] 表示在 i 个 0 和 j 个 1 的容量限制下，最多可选字符串数量
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        // 遍历每个字符串，相当于遍历每个“物品”
        for (const string& s : strs) {
            // 统计当前字符串中的 0 和 1 的个数
            int zeros = 0, ones = 0;
            for (char c : s) {
                if (c == '0') zeros++;
                else if (c == '1') ones++;
            }
            // 进行二维 0-1 背包状态更新，必须倒序遍历（保证每个字符串最多只被使用一次）
            for (int i = m; i >= zeros; --i) {
                for (int j = n; j >= ones; --j) {
                    // 状态转移：选 or 不选当前字符串
                    dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1);
                }
            }
        }
        // 返回最大可选字符串数量
        return dp[m][n];
    }
};

状态表变化过程（示例）

以如下数据为例：

strs = ["10", "0", "1"]
m = 1（最多 1 个 0），n = 1（最多 1 个 1）

初始化状态表（dp）：

i \ j	0	1
0	0	0
1	0	0

处理字符串 `"10"`：

zeros = 1，ones = 1
从 i=1 到 zeros=1，j=1 到 ones=1：

dp[1][1] = max(dp[1][1], dp[0][0] + 1) = max(0, 1) = 1

更新后的表：

i \ j	0	1
0	0	0
1	0	1

处理字符串 `"0"`：

zeros = 1，ones = 0

dp[1][1] = max(1, dp[0][1] + 1) = max(1, 1) = 1
dp[1][0] = max(0, dp[0][0] + 1) = max(0, 1) = 1

更新后的表：

i \ j	0	1
0	0	0
1	1	1

处理字符串 `"1"`：

zeros = 0，ones = 1

dp[1][1] = max(1, dp[1][0] + 1) = max(1, 2) = 2
dp[0][1] = max(0, dp[0][0] + 1) = max(0, 1) = 1

最终状态表：

i \ j	0	1
0	0	1
1	1	2

最终结果：

dp[1][1] = 2，最多可以选 2 个字符串，比如："0" 和 "1"，或 "10" 和 "1"。

Day35-动态规划 part03

Tue, 15 Apr 2025 00:00:00 GMT

0-1背包问题

0 - 1 背包问题定义：

有 N 个物品，每个物品有一个体积（或重量）w[i] 和价值 v[i]。现在给你一个容量为 C 的背包（不能超过容量），请你从这 N 个物品中选出若干个，使得在不超过背包容量的前提下，总价值最大。

“01”表示每个物品只能选择一次（要么选，要么不选）

二维 dp 解法

状态定义：

定义二维数组 dp[i][j]，表示使用第 0 到第 i 件物品，在背包容量为 j 的限制下所能达到的最大价值。

状态转移方程：

对于第 i 件物品（体积为 weight[i]，价值为 value[i]）：

不选：dp[i][j] = dp[i - 1][j]

如果我们不选择第 i 件物品，那么当前背包容量为 j 时的最大价值就是：

从前 0 到 i-1 这些物品中选取，在容量限制为 j 的条件下所能达到的最大价值。

换句话说，我们跳过第 i 件物品，不把它放入背包中。

是否还需要我把整段上下文整合输出？如果你要用于文档用途，我可以重新排好完整段落。

选：dp[i][j] = dp[i - 1][j - weight[i]] + value[i]（前提是 j >= weight[i]）

如果我们选择了第 i 件物品：
- 会消耗 weight[i] 的容量，背包剩余空间变成 j - weight[i]
- 从前 i-1 件物品中在剩余容量内选取的最大价值为 dp[i - 1][j - weight[i]]
- 加上当前物品的价值 value[i]，就是选当前物品的总价值
注意：只有当 j >= weight[i] 时，背包才放得下这件物品

因此状态转移方程为：

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

初始化：

dp[0][j] 表示只使用第 0 件物品，在容量为 j 时的最大价值：
- 若 j < weight[0]，则 dp[0][j] = 0
- 若 j >= weight[0]，则 dp[0][j] = value[0]

可以统一初始化方式如下：

for (int j = 0; j <= N; ++j) {
    dp[0][j] = (j >= weight[0]) ? value[0] : 0;
}

最终答案：

dp[M - 1][N]，表示使用前 M 件物品（编号 0~M-1），在容量为 N 时的最大价值。

示例（模板）：

vector<vector<int>> dp(M, vector<int>(N + 1, 0));

// 初始化第0件物品
for (int j = 0; j <= N; ++j) {
    if (j >= weight[0]) dp[0][j] = value[0];
}

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

一维 dp 解法

状态定义：

定义一维数组 dp[j]，表示在背包容量为 j 时，可获得的最大价值（考虑过的所有物品来自 weight[0..i]）。

状态转移方程：

对于第 i 件物品（体积 weight[i]，价值 value[i]）：

如果当前容量 j >= weight[i]，可以选择该物品，状态转移为：

dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

如果 j < weight[i]，不能选该物品，dp[j] 保持不变。

注意：为防止一个物品被重复使用，必须倒序枚举容量 j。

初始化：

dp[0] = 0：表示容量为 0 时，最大价值只能是 0
其余 dp[j] 也初始化为 0（未放入任何物品）

遍历顺序：

在一维 dp 中，为防止每个物品被选多次，遍历顺序必须如下：

for (int i = 0; i < M; ++i) {                  // 遍历每一个物品
    for (int j = N; j >= weight[i]; --j) {     // 容量从大到小倒序遍历
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

外层循环表示依次考虑物品 0 ~ M-1
内层倒序循环容量，从 N 到 weight[i]，以确保当前物品不会在同一轮中被重复使用

最终答案：

dp[N] 表示背包容量为 N 时所能取得的最大价值

示例（模板）：

vector<int> dp(N + 1, 0);

for (int i = 0; i < M; ++i) {
    for (int j = N; j >= weight[i]; --j) {
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

分割等和子集

416. 分割等和子集

我们想把数组分成两个子集，使得两个子集的和相等。

等价于：在数组中选出一些元素，使它们的总和为整个数组和的一半。

记数组总和为 sum，只要能选出若干个数使它们的和为 sum / 2，那么剩下的就是另外一半。

数组元素都是正整数
每个数只能选一次（0-1 背包）
不求最大价值，而是判断是否能达到某个“目标和” → 判断型背包

举例：

nums = [1, 5, 11, 5]
sum = 22 → target = 11

我们要判断：能否从数组中选出若干个数，使它们的和恰好为 11？

这正是一个 0-1 背包问题：

每个数是一个“物品”，
数值是物品的“体积”，
背包容量为 target = sum / 2，
每个物品只能选择一次。

动态规划解法（一维数组）

状态定义：

定义 dp[j] 表示：是否能选出若干个数，使它们的和恰好为 j。

dp[j] = true：能选出和为 j 的子集
dp[j] = false：不能选出

状态转移方程：

遍历数组中每个数 num，从容量 target 倒序遍历：

for (int j = target; j >= num; --j) {
    dp[j] = dp[j] || dp[j - num];
}

含义：

不选当前数字：dp[j] 保持原样
选当前数字：如果 dp[j - num] 是 true，则 dp[j] 也为 true

初始化：

dp[0] = true：容量为 0 的背包一定可以被“什么都不选”填满
其余 dp[j] = false

遍历顺序：

外层遍历每个物品 i
内层倒序遍历容量 j，从 target 到 num

倒序是为了确保每个物品最多只能使用一次（0-1背包的特性）

最终结果：

判断 dp[target] 是否为 true，表示能否恰好选出和为 sum / 2 的子集

整体代码如下：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 != 0) return false; // 总和为奇数，肯定不能平分

        int target = sum / 2;
        vector<bool> dp(target + 1, false);
        dp[0] = true; // 初始条件

        for (int num : nums) {
            for (int j = target; j >= num; --j) {
                dp[j] = dp[j] || dp[j - num];
            }
        }

        return dp[target];
    }
};

时间复杂度：

时间复杂度：O(N * target)，其中 N 为数组长度，target = sum / 2
空间复杂度：O(target)，使用一维 dp 数组优化空间

Day34-动态规划 part02

Mon, 14 Apr 2025 00:00:00 GMT

不同路径

62. 不同路径

动态规划

定义 dp 数组：dp[i][j] 表示从 (0, 0) 到 (i, j) 的路径数。
- 最终我们需要求的是右下角的路径数，即 dp[m - 1][n - 1]。
确定递推公式：
- 我们要到达 (i, j)，只能从上面 (i - 1, j) 或者左边 (i, j - 1) 来。
- 所以 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。
确定初始条件：
- 如果我们只有一行或者一列，那么只有一种路径。
- 所以 dp[0][j] = 1 和 dp[i][0] = 1，因此我们可以初始化第一行和第一列为 1。
- 不过也可以将dp数组直接初始化为 1，因为只有第一行和第一列的值是 1，其他的值会在后续的计算中被覆盖。
确定计算顺序：
- 从 0 到 m - 1，从 0 到 n - 1。
- 即从左上角到右下角。
返回结果：
- dp[m - 1][n - 1]。

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1; // 第一列只能从上方到达
        }
        for (int j = 0; j < n; j++) {
            dp[0][j] = 1; // 第一行只能从左方到达
        }
        // 其实可以全都初始化为1 
        // vector<vector<int>> dp(m, vector<int>(n, 1)); 
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1]; // 返回右下角的路径数
    }
};

数学方法

其实也就是组合数学的问题。

从左上角走到右下角需要走 m - 1 步“下”，n - 1 步“右”，总共 m + n - 2 步。在这些步中选出 m - 1 步向下，其余为向右，所以总路径数是：

C(m + n - 2, m - 1) 或者 C(m + n - 2, n - 1)。
其中 C(n, k) 表示从 n 个元素中选出 k 个元素的组合数，计算公式为：
C(m+n-2, m-1) = (m+n-2)! / ((m-1)! * (n-1)!)

class Solution {
public:
    int uniquePaths(int m, int n) {
        long long res = 1;
        for (int i = 1; i <= m - 1; ++i) {
            res = res * (n - 1 + i) / i;
        }
        return res;
    }
};

不同路径 II

63. 不同路径 II

定义 dp 数组：这里的定义其实和上面是一样的dp[i][j] 表示从 (0, 0) 到 (i, j) 的路径数。
- 最终我们需要求的是右下角的路径数，即 dp[m - 1][n - 1]。
确定递推公式：
- 我们要到达 (i, j)，只能从上面 (i - 1, j) 或者左边 (i, j - 1) 来。
- 但是当 (i, j) 是障碍物时，dp[i][j] = 0。
- 因此我们要有一个先决条件：if (obstacleGrid[i][j] == 0)
  - 所以在这个条件下 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。
确定初始条件：
- 如果我们只有一行或者一列，那么只有一种路径。
- 与之前不同的是，如果第一行或者第一列有障碍物，那么包括障碍物在内之后的路径都是不能到达的。
  - 所以我们需要在初始化时判断是否有障碍物，如果有障碍物，那么后面的路径数都初始化为 0。
确定计算顺序：
- 从 0 到 m - 1，从 0 到 n - 1。
- 即从左上角到右下角。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();

        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0; // 起点或终点有障碍物
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
            dp[i][0] = 1; // 第一列只能从上方到达，如果有障碍物则不初始化
        }
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
            dp[0][j] = 1; // 第一行只能从左方到达，如果有障碍物则不初始化
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 0) { // 递推前先判断当前有没有障碍物，如果没有障碍物
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]; // 上方和左方的路径数之和
                } else {
                    dp[i][j] = 0; // 有障碍物则路径数为0
                }
            }
        }
        return dp[m - 1][n - 1]; // 返回右下角的路径数
    }
};

整数拆分

343. 整数拆分

状态定义：

dp[i] 表示将正整数 i 拆分成至少两个正整数之和后，这些数的最大乘积

状态转移方程：

对 i 来说，可以拆成 j + (i - j)，其中 `1 <= j < i。

那么我们有两种选择：

不继续拆 i - j，也就是说乘积为 j * (i - j)
继续拆 i - j，也就是说乘积为 j * dp[i - j]

所以状态转移为：

dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))

初始化：

dp[0] = 0，实际上没有意义
dp[1] = 0，实际上没有意义
dp[2] = 1，表示拆分成 1 + 1，乘积为 1

遍历顺序：

外层从 2 到 n，内层从 1 到 i - 1，也可以从 1 到 i / 2，因为 j 和 i - j 是对称的。

class Solution {
public:
    int integerBreak(int n) {
        if (n <= 2) return 1; // 1和2只能拆分成1
        vector<int> dp(n + 1, 0); // dp[i]表示整数i的最大乘积
        dp[0] = 0;
        dp[1] = 0;
        dp[2] = 1;

        for (int i = 3; i <= n; i++) {
            for (int j = 1; j <= i / 2; j++) {
                // j * (i - j)表示拆分成j和i-j的乘积
                // j * dp[i - j]表示拆分成j和i-j的乘积，i-j可以继续拆分
                // 取两者的最大值
                // 同时因为固定了i，我们还要在当前取dp[i]的最大值
                dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]));
            }
        }
        return dp[n]; // 返回整数n的最大乘积  
    }
};

不同的二叉搜索树

96. 不同的二叉搜索树

状态定义：

我们定义 dp[i] 表示 i 个节点能组成的不同二叉搜索树的个数。

状态转移方程：

假设当前总共有 i 个节点，我们枚举每一个数 j 当作根节点，那么：

左子树节点数为 j - 1
右子树节点数为 i - j

那么以 j 为根的 BST 数量为：

dp[j - 1] * dp[i - j]

对所有可能的根节点求和：

dp[i] = dp[0] * dp[i - 1] + dp[1] * dp[i - 2] + ... + dp[i - 1] * dp[0]
/*这其实是 卡特兰数 的定义*/

初始化：

dp[0] = 1：空树也算一种
dp[1] = 1：只有一个节点，只有一种 BST

遍历顺序：节点数为 i 的状态是依靠 i 之前节点数的状态。外层从 2 到 n，内层从 1 到 i。

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1, 0); // dp[i]表示i个节点的二叉搜索树的个数
        dp[0] = 1; // 0个节点的二叉搜索树的个数为1（空树）
        dp[1] = 1; // 1个节点的二叉搜索树的个数为1（只有一个节点）

        for (int i = 2; i <=n; i++) {
            for (int j = 1; j <= i; j++) {
                // j作为根节点，左子树有j-1个节点，右子树有i-j个节点
                dp[i] += dp[j - 1] * dp[i - j]; // 左子树和右子树的组合
            }
        }
        return dp[n]; // 返回n个节点的二叉搜索树的个数
    }
};

Day32-动态规划 part01

Sat, 12 Apr 2025 00:00:00 GMT

动态规划

动态规划（Dynamic Programming，简称DP）是一种用于解决最优化问题的算法设计方法，其核心思想是将原问题划分为若干子问题，先解决子问题，并利用子问题的解构造原问题的解，从而避免重复计算，提高效率。

动态规划适用于满足以下两个条件的问题：

最优子结构（Optimal Substructure）
原问题的最优解可以由子问题的最优解构成。
重叠子问题（Overlapping Subproblems）
原问题在递归求解过程中会反复遇到相同的子问题。

动态规划五步曲：

定义状态（确定dp数组（dp table）以及下标的含义）：用一个或多个变量来描述子问题的结构，一般以 dp[i] 或 dp[i][j] 表示。
确定状态转移方程（确定递推公式）：描述如何通过已知状态计算出新的状态。
确定初始条件（dp数组如何初始化）：即基础状态的值，作为递推的起点。
确定计算顺序（确定遍历顺序）：通常是从小到大递推。
返回最终结果（举例推导dp数组）：即问题的答案对应的状态值。

斐波那契数列

509. 斐波那契数

用递归的方式来实现斐波那契数列的实现其实很简单，直接递归调用 fib(n - 1) + fib(n - 2) 即可。如果使用动态规划的方式来实现，我们按照动态规划五步曲来实现：

dp[i] 表示第 i 个斐波那契数的值。
递推公式：dp[i] = dp[i - 1] + dp[i - 2]。
初始化dp数组：dp[0] = 0, dp[1] = 1。
遍历顺序：从 2 到 n。
返回结果：dp[n]。

因此我们动态规划的实现如下：

class Solution {
public:
    int fib(int n) {
        // 动态规划
        if (n <= 1) return n;
        // dp[i] 表示第 i 个斐波那契数的值
        // 
        vector<int> dp(n + 1, 0); // 
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
        
    }
};

为什么dp数组要初始化为 dp(n + 1, 0)

因为我们需要计算到 n，所以我们需要一个大小为 n + 1 的数组来存储从 0 到 n 的斐波那契数。

假设 n = 5
F(0) = 0  
F(1) = 1  
F(2) = F(1) + F(0)  
F(3) = F(2) + F(1)  
F(4) = F(3) + F(2)  
F(5) = F(4) + F(3)

从 0 到 5 一共需要 6 个数，所以 dp 数组的大小为 n + 1。
数组必须有 n + 1 个元素，才能保证 dp[0] ~ dp[n] 都能合法访问

爬楼梯

70. 爬楼梯

我们可以把这个问题简化一下：

假设我们要爬到第3层
我们可以从第2层爬上来（走一步）
或者从第1层爬上来（走两步）

因此我们可以推导出：

因为爬到第 n 层楼梯有两种方式：
从第 n - 1 层楼梯爬上来（走一步）
从第 n - 2 层楼梯爬上来（走两步）
从而爬到第 n 层楼梯的方式有 f(n) = f(n - 1) + f(n - 2)种方式

所以我们可以定义 dp 数组 dp[i]，用来表示爬到第 i 层楼梯的方式有多少种。

递推公式：dp[i] = dp[i - 1] + dp[i - 2]。

所以这题的思路其实也就转换成了和斐波那契数列一样了。

接下来是定义初始条件：

dp[i] 表示第 i 层楼梯的方式
因为题中描述了 n 是从 1 开始的，因此我们直接从 1 开始定义
dp[1] = 1，爬到第 1 层楼梯只有一种方式
dp[2] = 2，爬到第 2 层楼梯有两种方式：
- 走一步到第 1 层，再走一步到第 2 层
- 一次性走两步到第 2 层

:::tip[如果一定要初始化dp[0]] 由于到达第0层楼梯在题中并没有实际意义，所以我们可以根据题意，“到达第 2 层有两种方式”，反推出dp[0] = 1 :::

遍历顺序：因为我们是一层一层往上爬的，所以很自然是从前往后遍历，再根据题意，所以我们从 3 开始遍历到 n。

所以我们的整体代码如下：

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2) return n; // 如果台阶数小于等于2，直接返回n
        vector<int> dp(n + 1, 0); // dp[i]表示到达第i级台阶的方法数
        dp[1] = 1; // 到达第1级台阶的方法数为1
        dp[2] = 2; // 到达第2级台阶的方法数为2
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2]; // 到达第i级台阶的方法数为到达第i-1级台阶和第i-2级台阶的方法数之和
        }
        return dp[n]; // 返回到达第n级台阶的方法数
    }
};

使用最小花费爬楼梯

746. 使用最小花费爬楼梯

确定转移状态方程 dp[i] 和下标 i 的含义：

dp[i] 表示到达第 i 级台阶的最小花费。根据题意，我们只能选择跳 1 级或 2 级台阶，所以当我们需要跳到第 i 级台阶时：
从第 i - 1 级台阶跳上来，花费 cost[i - 1] 的费用
- dp[i] = dp[i - 1] + cost[i - 1]
从第 i - 2 级台阶跳上来，花费 cost[i - 2] 的费用
- dp[i] = dp[i - 2] + cost[i - 2]

既然我们可以从第 i - 1 级台阶跳上来，也可以从第 i - 2 级台阶跳上来，有两种选择，根据题意我们需要选择最小的费用，所以我们可以得到：

dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])

初始化 dp 数组：

题意中：“你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯” 也就是说到达第 0 个台阶是不花费的，但从第 0 个台阶往上跳的话，需要花费 cost[0]。
所以我们可以定义 dp[0] = 0，表示到达第 0 个台阶的费用为 0。
dp[1] = 0，表示到达第 1 个台阶的费用为 0。
也就是默认第一步是不花费体力的。

所以我们的整体代码如下：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size(); // 台阶数
        vector<int> dp(n + 1, 0); // dp[i]表示到达第i级台阶的最小花费
        dp[0] = 0; // 从下标为 0 或下标为 1 的台阶开始，因此支付费用为0
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]); // 到达第i级台阶的最小花费为到达第i-1级台阶和第i-2级台阶的最小花费之和
        }
        return dp[n]; // 返回到达第n级台阶的最小花费
    }
};

:::important[其实还是要理解题意] 这里其实理解题意比较重要，跳到第 0 级台阶和第 1 级台阶是不需要花费体力的，所以我们可以直接将 dp[0] 和 dp[1] 初始化为 0。 :::

Day31-贪心算法 part05

Fri, 11 Apr 2025 00:00:00 GMT

合并区间

56. 合并区间

这题的本质其实还是判断重叠区间的问题。

我们可以先将区间按照起始位置进行排序，然后遍历区间

如果当前区间的起始位置小于等于上一个区间的结束位置，则说明两个区间重叠，需要进行合并。
否则，说明两个区间不重叠，可以直接将当前区间加入结果中。
合并区间的方式是将上一个区间的结束位置更新为两个区间的结束位置的最大值。

因此整体代码不难

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        if (intervals.size() < 2) return intervals; // 如果区间数量小于2，直接返回
        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[0] < b[0]; // 按照区间的起始位置排序
        });
        vector<vector<int>> merged; // 存储合并后的区间
        merged.push_back(intervals[0]); // 将第一个区间加入结果
        for (int i = 1; i < intervals.size(); i++) {
            // 如果当前区间的起始位置小于等于上一个区间的结束位置，进行合并
            if (intervals[i][0] <= merged.back()[1]) {
                merged.back()[1] = max(merged.back()[1], intervals[i][1]); // 更新结束位置
            } else {
                merged.push_back(intervals[i]); // 否则，直接加入结果
            }
        }
        return merged; // 返回合并后的区间
    }
};

单调递增的数字

738. 单调递增的数字

这里的思路是我们从后往前遍历数组，如果当前的数字小于前一个数字(s[i] < s[i - 1])，那么我们记录下当前这个位置 flag，并将前一个数字减1, 重复这个过程知道遍历结束。

然后我们将 flag 位置之后的数字全部改为9，最后返回结果。

整体代码如下：

class Solution {
private:
    bool check(int n) {
        string s = to_string(n); // 将数字转换为字符串
        for (int i = 1; i < s.size(); i++) { 
            // 如果当前数字小于前一个数字，返回false
            if (s[i] < s[i - 1]) {
                return false;
            }
        }
        return true;
    }
public:
    int monotoneIncreasingDigits(int n) {
        if (check(n)) return n; // 如果已经是单调递增的数字，直接返回
        string s = to_string(n);
        int flag = s.size(); // 标记位置
        for (int i = s.size() - 1; i > 0; i--) { // 从后往前遍历
            // 如果当前数字小于前一个数字，更新标记位置
            if (s[i] < s[i - 1]) {
                flag = i;
                s[i - 1]--; // 前一个数字减1
            }
        }
        // 将标记位置之后的数字全部改为9
        for (int i = flag; i < s.size(); i++) {
            s[i] = '9';
        }
        return stoi(s); // 将字符串转换为整数并返回
    }
};

这里需要注意的是只有从后向前遍历才能重复利用上次比较的结果。

监控二叉树

968. 监控二叉树

#TODO

Day30-贪心算法 part04

Thu, 10 Apr 2025 00:00:00 GMT

用最少数量的箭引爆气球

452. 用最少数量的箭引爆气球

为了尽量使气球重叠，我们可以将气球的右端点进行排序。我们可以从第一个气球开始，记录当前的箭头位置，然后遍历后面的气球，如果当前气球的左边界大于箭头位置，则需要增加一支箭头，并更新箭头位置为当前气球的右边界。

如果当前气球的左边界小于等于箭头位置，则说明当前气球可以被当前箭头引爆，所以不需要增加箭头。

局部最优解：
- 每次选择右端点最小的气球进行引爆

points = [[10,16],[2,8],[1,6],[7,12]]
排序后：
points = [[1,6],[2,8],[7,12],[10,16]]
    
           end        
           ↓
     1 --- 6
     
            2 --- 8       左端点小于end，不需要增加箭头
                        
                      end
                       ↓
                7 --- 12     此时的end为6，左端点大于end，需要增加箭头，并更新end为12

                    10 --- 16   此时左端点小于end，不需要增加箭头

class Solution {
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if (points.empty()) return 0; // 如果没有气球，返回0
        // 按照气球的结束位置进行排序
        sort(points.begin(), points.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[1] < b[1];
        });
        
        int arrows = 1; // 至少需要一支箭
        int end = points[0][1]; // 第一个气球的右边界

        for (int i = 1; i < points.size(); i++) {
            // 如果当前气球的开始位置大于上一个气球的结束位置，增加箭的数量
            if (points[i][0] > end) {
                arrows++;
                end = points[i][1]; // 更新结束位置
            }
        }

        return arrows;
    }
};

当然这里也可以依据左边界进行排序。

我们同样的使用一个 end 变量来记录当前箭头的结束位置，也就是当前箭头可以引爆的气球的右边界。

如果当前气球的左边界大于 end，说明当前气球不能被当前箭头引爆，需要增加一支箭头，并更新 end 为当前气球的右边界。
如果当前气球的左边界小于等于 end，说明当前气球可以被当前箭头引爆，所以不需要增加箭头。
- 此时我们需要更新 end 为当前气球的右边界和 end 的最小值，因为我们要尽量让气球重叠。

class Solution {
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if (points.empty()) return 0; // 如果没有气球，返回0
        // 按照气球的结束位置进行排序
        sort(points.begin(), points.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[0] < b[0];
        });
        
        int arrows = 1; // 至少需要一支箭
        int end = points[0][1]; // 记录第一个气球的结束位置
        for (int i = 0; i < points.size(); i++) {
            // 如果当前气球的开始位置大于上一个气球的结束位置，说明需要新的箭
            if (points[i][0] > end) {
                arrows++; // 增加箭的数量
                end = points[i][1]; // 更新结束位置为当前气球的结束位置
            } else {
                // 如果当前气球的开始位置小于等于上一个气球的结束位置，更新结束位置为二者的最小值
                end = min(end, points[i][1]);
            }
        }
        return arrows;
    }
};

无重叠区间

435. 无重叠区间

这里的整体思路其实和无重叠区间的思路是一样的，我们同样可以根据结束位置进行排序。我们可以使用一个 end 变量来记录当前区间的结束位置，也就是当前区间的右边界。

如果当前区间的开始位置大于等于 end，则说明无重叠，此时我们要更新 end 为当前区间的右边界。
如果当前区间的开始位置小于 end，则说明有重叠，此时我们要更新 end 为当前区间的右边界和 end 的最小值，并使 count++。

intervals = [[1,2],[2,3],[3,4],[1,3]]
排序后：
intervals = [[1,2],[1,3],[2,3],[3,4]]
    
         end = 2        
          ↓
    1 ---  2

    1 ----------- 3       左边界小于end，count++，相当于删除了[1,3]，end更新为2（2和3的最小值）
                        
         end = 2
          ↓          
          2 ----- 3     此时的end为2，左边界等于end，说明没有重叠（指[1, 2]），并更新end为右边界3

                  3 --- 4   此时左边界大于end，说明没有重叠，更新end为4

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size() < 2) return 0; // 如果区间数量小于2，返回0

        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){return a[1] < b[1];});

        int count = 0;
        int end = intervals[0][1]; // 记录第一个区间的结束位置

        for (int i = 1; i < intervals.size(); i++) {
            // 如果当前区间的开始位置大于等于上一个区间的结束位置，说明没有重叠
            // 更新结束位置为当前区间的结束位置
            if (intervals[i][0] >= end) {
                end = intervals[i][1]; // 更新结束位置为当前区间的结束位置
            } else {
                count++; // 如果当前区间与上一个区间重叠，增加计数
                end = min(end, intervals[i][1]); // 更新结束位置为二者的最小值
            }
        }
        return count;
    }
};

划分字母区间

763. 划分字母区间

本题的题意可以分解为，给定任意一个字符 ch，该区间需要包含所有的 ch 字符。

我们可以使用一个 map 来记录每一个字符的最后出现位置。（当然也可以使用一个数组来记录 int LastIndex[26] = -1;）

使用一个 start 变量来记录当前区间的开始位置，end 变量来记录当前区间的结束位置。

在每次遍历中：

更新 end 为当前字符的最后出现位置和 end 的最大值。
如果当前字符的下标等于 end，说明当前区间已经划分完成，此时我们可以将 start 更新为 i + 1，并将 end 重置为 0。

class Solution {
public:
    vector<int> partitionLabels(string s) {
        unordered_map<char, int> lastIndex; // 记录每个字符最后出现的位置
        for (int i = 0; i < s.size(); i++) {
            lastIndex[s[i]] = i; // 更新字符的最后出现位置
        }

        vector<int> result; // 存储划分的区间长度
        int start = 0; // 当前区间的起始位置
        int end = 0; // 当前区间的结束位置

        for (int i = 0; i < s.size(); i++) {
            end = max(end, lastIndex[s[i]]); // 更新当前区间的结束位置
            if (i == end) { // 如果当前索引等于结束位置，说明可以划分一个区间
                result.push_back(end - start + 1); // 计算区间长度并加入结果
                start = i + 1; // 更新起始位置为下一个字符
            }
        }
        return result; 
    }
};

总结

这三题的思路其实都是一个重叠区间的问题，引爆气球和无重叠区间是典型的区间选择问题，而划分字母区间是利用区间合并来进行划分的问题。都通过“优先选择最有利的区间”实现了贪心最优化。

题号	本质问题	贪心点	排序依据
435	最少移除重叠区间	每次保留最早结束的区间	按 end 升序
452	最少箭数射爆气球	每次一箭射最右的可覆盖区间	按 end 升序
763	最多不重叠分区	当前分区的最大右边界到达时划分	字符最远出现位置

Day29-贪心算法 part03

Wed, 09 Apr 2025 00:00:00 GMT

加油站

134. 加油站

我们可以设定一个净增的油量，也就是每次到达加油站获取的油量，减去下一次所需要的油量。

也就是说 total = gas[i] - cost[i]，然后对 total 做一个累加，如果 total 小于 0，则说明无论从哪里开始都无法到达终点。

反之，如果 total 大于 0，则我们先不管是从哪里出发的，一定存在一个点 start，使得从 start 出发可以到达终点。

我们可以定义一个变量 total，用来计算从第 0 个加油站出发到达终点的净油量。同时定义一个变量 cur，用来表示当前的净油量。

如果 cur 小于 0，则说明我们已经无法到达下一个加油站了，所以我们需要将 start 更新为 i + 1，并将 cur 重置为 0。

整体代码如下：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int total = 0; // 总的净油量
        int cur = 0;   // 当前段的净油量
        int start = 0; // 起始加油站索引

        for (int i = 0; i < gas.size(); i++) {
            total += gas[i] - cost[i]; // 计算总净油量
            cur += gas[i] - cost[i];   // 计算当前段净油量

            if (cur < 0) { // 当前段净油量不足以到达下一站
                start = i + 1; // 更新起始加油站为下一站
                cur = 0;       // 重置当前段净油量
            }
        }
        // 如果总净油量为正，则说明可以绕行一圈，否则返回 -1
        return total >= 0 ? start : -1;
    }
};

gas  =  [1, 2, 3, 4, 5]
cost = [3, 4, 5, 1, 2]
net = gas[i] - cost[i] = [-2, -2, -2, 3, 3]

站点:     0     1     2     3     4
         ↓     ↓     ↓     ↓     ↓
净油量: -2   -2   -2   +3   +3

cur:   <---当前段累计油量差

核心在于：

我们只关心有没有一个起点 start，从这个起点出发，走一圈能不能回到起点。
cur 每次失败就重置成 0，表示当前这段肯定不能作为起点，那我们就跳过。
最后如果 total >= 0，说明全局油量足够绕一圈，这时候 start 一定就是那个唯一可行的起点。

分发糖果

135. 分发糖果

题目要求分发糖果，规则如下：

每个孩子至少分配一个糖果。
相邻的孩子中，评分更高的孩子必须获得更多的糖果。

我们可以初始化一个数组将每人分得1个糖果，然后分两次遍历数组：

从左到右遍历：
- 如果当前孩子的评分比左边的孩子高，则当前孩子的糖果数应该比左边孩子多 1。
- 这样可以保证从左到右的规则满足。
从右到左遍历：
- 如果当前孩子的评分比右边的孩子高，则当前孩子的糖果数应该比右边孩子多 1。
- 同时需要取当前糖果数和右边孩子糖果数 +1 的最大值，以确保不覆盖从左到右遍历的结果。
计算总糖果数：
- 遍历糖果数组，将所有孩子的糖果数累加即可。

整体代码如下：

class Solution {
public:
    int candy(vector<int>& ratings) {
        int n = ratings.size();
        vector<int> candies(n, 1); // 每个孩子至少分配一个糖果

        // 从左到右遍历，确保右边评分更高的孩子糖果更多
        for (int i = 1; i < n; i++) {
            if (ratings[i] > ratings[i - 1]) { // 当前孩子评分高于左边孩子
                candies[i] = candies[i - 1] + 1; // 当前孩子糖果数比左边孩子多 1
            }
        }
        // 从右到左遍历，确保左边评分更高的孩子糖果更多
        for (int i = n - 2; i >= 0; i--) { // 从倒数第二个孩子开始遍历
            if (ratings[i] > ratings[i + 1]) { // 当前孩子评分高于右边孩子
                // 如果 ratings[i] > ratings[i + 1]，此时candy[i]（第i个小孩的糖果数量）就有两个选择
                // 一个是candy[i + 1] + 1（从右边这个加1得到的糖果数量）
                // 一个是candyVec[i]（之前比较右孩子大于左孩子得到的糖果数量）
                // 那么我们取局部最优，也就是取两者的最大值
                candies[i] = max(candies[i], candies[i + 1] + 1);
            }
        }
        // 计算糖果总数
        return accumulate(candies.begin(), candies.end(), 0);
    }
};

因此这题其实利用了两次贪心策略，第一次是从左到右，每次保证右边的孩子比左边的孩子多 1，第二次是从右到左，每次保证左边的孩子比右边的孩子多 1，同时还要考虑在左到右过程中可能已经被加过的糖果，因此我们取两者的最大值。

柠檬水找零

860. 柠檬水找零

这里我们根据题意，对于客户支付的情况一共有三种：

支付5：
- 不需要找零，并收下5美元
支付10：
- 只能找零5美元，并收下10美元
- 如果没有5美元的零钱，则无法找零，返回 false
支付20：
- 需要找零15美元
  - 如果有10美元和5美元的零钱，则找零10美元和5美元
  - 如果没有10美元的零钱，则需要找零3个5美元
  - 如果都不满足，则无法找零，返回 false
- 如果没有5美元的零钱，则无法找零，返回 false

我们的局部最优情况在于，当支付20美元时，优先找10美元和5美元的零钱，这样可以保证后续支付5美元和10美元时有足够的零钱可找，因为5美元能够用来找零的情况更多。因此遇到账单20，优先消耗美元10，完成本次找零。

所以我们可以维护两个变量 five 和 ten，分别表示5美元和10美元的零钱数量。

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int five = 0, ten = 0; // 记录5美元和10美元的数量

        for (int bill : bills) {
            if (bill == 5) {
                five++; // 收到5美元，不需要找零
            } 
            else if (bill == 10) {
                if (five > 0) { // 找零1张5美元，并收下10美元
                    five--;
                    ten++;
                } 
                else {
                    return false; // 无法找零
                }
            } 
            else if (bill == 20) {
                if (ten > 0 && five > 0) { // 优先找零1张10美元和1张5美元
                    ten--;
                    five--;
                } 
                else if (five >= 3) { // 否则找零3张5美元
                    five -= 3;
                } 
                else {
                    return false; // 无法找零
                }
            }
        }
        return true; // 所有顾客都成功找零
    }
};

根据身高重建队列

406. 根据身高重建队列

这题的题意其实是，需要重新构造一个队列，使得每个人的前面有 k 个人的身高大于等于他。

result = [ ?, ?, ?, ?, ?, ? ]

使得对于每一个人在这个 result 队列中:

他前面有正好 k 个“身高 ≥ 他身高”的人

我们可以先将所有人按照身高从高到低排序，如果身高相同，则按照 k 从小到大排序。

class Solution {
public:
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        // 按身高降序排序，如果身高相同则按 k 值升序排序
        sort(people.begin(), people.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[0] > b[0] || (a[0] == b[0] && a[1] < b[1]);
        });

        vector<vector<int>> result;
        // 按照 k 值插入到结果队列中
        for (const auto& person : people) {
            result.insert(result.begin() + person[1], person);
        }

        return result;
    }
};

Day28-贪心算法 part02

Tue, 08 Apr 2025 00:00:00 GMT

买卖股票的最佳时机 II

122. 买卖股票的最佳时机 II

这里的想法其实容易陷入一个误区，就是我们一般都会认为在最低点买入，在最高点卖出，这样就能获得最大的收益。

而其实我们可以在每一个上升的区间内进行交易，来获得最大的收益。

当我们把利润分解为以每天为单位的利润时，我们就可以把每一天的利润都加起来，来获得最大的收益。

局部最优解：

收集每天的正利润全局最优解：
收集所有的正利润

假设我们在第 i 天买入，第 j 天卖出，那么我们可以将利润分解为：

利润 = 第 j 天的价格 - 第 i 天的价格
     = (第 j 天的价格 - 第 (j-1) 天的价格) + (第 (j-1) 天的价格 - 第 (j-2) 天的价格) + ... + (第 i+1 天的价格 - 第 i 天的价格)

所以其实我们只要判断当前的价格是否比前一天的价格高，如果是，就将差值加入到利润中。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() < 2) return 0;
        int sum = 0;
        for (int i = 1; i < prices.size(); i++) {
            // 如果今天的价格比昨天高，则计算利润
            if (prices[i] > prices[i - 1]) {
                sum += prices[i] - prices[i - 1];
            }
        }
        return sum;
    }
};

跳跃游戏

55. 跳跃游戏

这里重要的不是每次跳多少步，而是跳跃的范围能否覆盖最后一个元素。

我们可以定义一个变量 maxReach，表示当前能跳到的最远位置。 i + nums[i] 表示当前下标 i 能跳到的最远位置。如果当前的下标 i 大于 maxReach，说明无法到达最后一个元素，返回 false。

如图所示：

那么我们只要在遍历数组的过程中，如果遍历到尾了，那么返回 true就可以了。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if (nums.size() == 1) return true; // 只有一个元素，返回true
        int maxReach = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (maxReach < i) { // 如果跳跃的范围到不了当前的下标
                return false; // 直接返回false
            }
            else { // 否则更新当前跳跃的最大范围
                maxReach = max(maxReach, i + nums[i]);
            }
        }
        return true;
    }
};

这道题目关键点在于不用拘泥于每次究竟跳几步，而是看覆盖范围，覆盖范围内一定是可以跳过来的，不用管是怎么跳的。

跳跃游戏 II

45. 跳跃游戏 II

题的核心是用贪心思想模拟 BFS 的层次遍历，每次“跳跃”都尽可能跳得远。

我们定义以下几个变量：

curEnd：当前这一跳所能到达的最远位置（当前“层”的边界）
curFarthest：下一跳所能到达的最远位置
jumps：跳跃次数

把每次跳跃看作 BFS 中的一“层”：

curEnd 是当前层的最远边界，
curFarthest 是我们能探索到的下一层最远边界，
一旦我们走到了 curEnd，说明该跳一次了（从当前层跳到下一层），此时就增加一次跳跃次数。

class Solution {
public:
    int jump(vector<int>& nums) {
        if (nums.size() == 1) return 0;
        int jumps = 0;
        int curEnd = 0;
        int curFarthest = 0;
        int n = nums.size();
        for (int i = 0; i < n - 1; ++i) {
            curFarthest = max(curFarthest, i + nums[i]);  // 能跳的最远
            if (i == curEnd) {  // 到了当前这跳的最远位置
                jumps++;            // 需要跳一次
                curEnd = curFarthest;  // 更新下一跳的边界
            }
        }
        return jumps;
    }
};

我们可以把这个过程想象成一个 BFS 的过程：

假定：

nums = [2, 3, 1, 1, 4]
index:  0   1   2   3   4

转换成树结构，格式是：节点(值) → 子节点

         0(2)
        /   \
     1(3)   2(1)
    / | \     \
 3(1) 4(4)     3(1)

最短路径是：0 → 1 → 4，即跳跃次数为2。

K次取反后最大化的数组和

1005. K 次取反后最大化的数组和

我们的目标是尽可能多地把负数变成正数，因为正数才对总和有贡献。

步骤如下：

把数组按绝对值从大到小排序；
从前往后遍历，如果当前是负数且还有操作次数，就取反；
如果最后还剩奇数个 k，对最后一个元素（绝对值最小的）再取反一次；如果是偶数个 k，则不需要再取反，因为两个负号抵消了。

代码如下：

class Solution {
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        // 按照绝对值从大到小排序
        sort(nums.begin(), nums.end(), [](int a, int b) { //使用lamda表达式进行排序
            return abs(a) > abs(b);
        });
        for (int i = 0; i < nums.size(); ++i) {
            if (nums[i] < 0 && k > 0) {
                nums[i] = -nums[i];  // 取反负数
                --k;
            }
        }
        // 如果 k 还剩奇数次，对最小的那个数取反（一定是最后一个）
        if (k % 2 == 1) {
            nums[nums.size() - 1] = -nums[nums.size() - 1];
        }
        return accumulate(nums.begin(), nums.end(), 0);
    }
};

Day27-贪心算法 part01

Mon, 07 Apr 2025 00:00:00 GMT

贪心算法基础

贪心算法（Greedy Algorithm）是一种在每一步选择中都采取当前状态下最优或最有利的选择，从而希望通过一系列局部最优的选择，最终得到全局最优解的方法。

贪心算法的核心思想是利用局部最优解推导出全局最优解。它通常用于解决一些最优化问题，如最小生成树、最短路径、活动选择等。贪心算法的关键在于选择标准和选择过程，选择标准决定了每一步的选择，而选择过程则是根据当前状态进行决策。

它的工作方式是：

从问题的某个初始状态出发；
在每一步中都做出一个局部最优选择（即当前看来最好的选择）；
求出每一步的的最优解；
最终得到一个可行解， 但不一定是最优解，这取决于问题本身是否适合贪心策略。

贪心算法并不总是适用，它适用于具有“贪心选择性质”和“最优子结构”的问题。

贪心选择性质：可以通过局部最优的选择构造出全局最优解；
最优子结构：一个问题的最优解包含其子问题的最优解。

分发饼干

455. 分发饼干

这里我们可以对两个数组进行排序，然后在每一次试行中，将当前最小的饼干分配给当前最小的孩子，如果当前最小的饼干不能满足当前最小的孩子，那么就将下一个饼干分配给当前最小的孩子。

所以这里的代码其实很简单：

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int count = 0;
        int i = 0, j = 0;
        while (i < g.size() && j < s.size()) {
            if (g[i] <= s[j]) { // 当前饼干值满足当前胃口值
                count++;
                i++;
                j++;
            }
            else { // 当前饼干值不满足当前胃口值，小孩不动，饼干前移
                j++;
            }
        }
        return count;
    }
};

或者是，尽量使用大的饼干去满足胃口大的小孩，其思路是一样的。

摆动序列

376. 摆动序列

贪心算法

局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。

整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

在计算是否有峰值的时候，计算 prediff(nums[i] - nums[i-1]) 和 curdiff(nums[i+1] - nums[i])，如果 prediff < 0 && curdiff > 0 或者 prediff > 0 && curdiff < 0 此时就有波动就需要统计。

那么这里有三种情况需要考虑：

上下坡中有平坡

在图中，当 i 指向第一个 2 的时候，prediff > 0 && curdiff = 0 ，当 i 指向最后一个 2 的时候 prediff = 0 && curdiff < 0。

如果我们采用，删左面三个 2 的规则，那么当 prediff = 0 && curdiff < 0 也要记录一个峰值，因为他是把之前相同的元素都删掉留下的峰值。

所以我们记录峰值的条件应该是： (preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)

数组首位两端

因为我们在计算 prediff(nums[i] - nums[i-1]) 和 curdiff(nums[i+1] - nums[i]) 的时候，至少需要三个数字才能计算，而数组只有两个数字。

这里我们可以写死，就是如果只有两个元素，且元素不同，那么结果为 2。

因此我们可以规定，最前面还有一个数字，他的值等于 nums[0]，这样它就有坡度了即 preDiff = 0。针对以上情形，result 初始为 1（默认最右面有一个峰值），此时 curDiff > 0 && preDiff <= 0，那么 result++（计算了左面的峰值），最后得到的 result 就是 2（峰值个数为 2 即摆动序列长度为 2）

单调坡中有平坡

图中，我们可以看出，如果用情况1在三个地方记录峰值，但其实结果因为是 2，因为单调中的平坡不能算峰值（即摆动）。

我们只需要在这个坡度摆动变化的时候，更新 prediff 就行，这样 prediff 在单调区间有平坡的时候就不会发生变化.

所以整体代码如下：

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size();
        int curDiff = 0; // 当前一对差值
        int preDiff = 0; // 前一对差值，默认最前面还有一个数等于nums[0]
        int result = 1;  // 记录峰值个数，序列默认序列最右边有一个峰值
        for (int i = 0; i < nums.size() - 1; i++) { // 到倒数第二个
            curDiff = nums[i + 1] - nums[i];
            // 出现峰值
            if ((preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)) {
                result++;
                preDiff = curDiff; // 注意这里，只在摆动变化的时候更新prediff
            }
        }
        return result;
    }
};

贪心 + 动态规划

我们维护两个变量：

up[i]：以第 i 个元素结尾，最后一个波动是上升时的最长摆动序列长度
down[i]：以第 i 个元素结尾，最后一个波动是下降时的最长摆动序列长度
up[i] 和 down[i] 的初始值都为1，因为单个元素本身就是一个摆动序列。

但我们可以把它进一步简化成两个变量 up 和 down，因为我们只关心上一个状态（不需要保存整个数组）。

具体思路

如果 nums[i] > nums[i-1]，说明当前是一个上升，那么我们希望它接在一个下降后面，才能构成「摆动」。
- 所以：up = down + 1
如果 nums[i] < nums[i-1]，说明当前是一个下降，希望它接在一个上升后面：
- 所以：down = up + 1
如果两者相等，那就忽略它（不会更新任何一个）。

我们以题中给出的例子 nums = [1, 7, 4, 9, 2, 5] 为例，输入：nums = [1, 7, 4, 9, 2, 5]，i 从 1 开始：

i	nums[i]	nums[i]-nums[i-1]	up	down
1	7	6 ↑	2	1
2	4	-3 ↓	2	3
3	9	5 ↑	4	3
4	2	-7 ↓	4	5
5	5	3 ↑	6	5

整体代码如下：

int wiggleMaxLength(vector<int>& nums) {
    if (nums.size() < 2) return nums.size(); // 只有一个元素，返回1
    int up = 1, down = 1; // up和down的初始值都为1，因为单个元素本身就是一个摆动序列
    for (int i = 1; i < nums.size(); ++i) { // 从第二个元素开始遍历
        if (nums[i] > nums[i - 1]) up = down + 1; // 当前是一个上升，那么我们希望它接在一个下降后面，才能构成「摆动」
        else if (nums[i] < nums[i - 1]) down = up + 1; // 当前是一个下降，希望它接在一个上升后面
    }
    // 整个过程中并不知道最终的波动是“升”还是“降”
    // 所以我们需要记录两种情况的最大长度
    // 最终返回 max(up, down)，才是整个序列中最长的摆动子序列长度。
    return max(up, down);
}

最大子数组和

53. 最大子数组和

局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。

因此我们可以遍历 nums 数组，计算当前的连续和，如果当前的连续和小于 0，那么就将当前的连续和置为 0, 并且从下一个元素重新计算连续和。

同时我们还需要维护一个变量 maxSum，用来记录当前的最大连续和，因此不会出现类似错过某一个最大连续和的情况。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int maxSum = INT_MIN; // 记录当前的最大连续和
        int curSum = 0; // 记录当前的连续和
        for (int i = 0; i < nums.size(); i++) {
            curSum += nums[i]; // 当前的连续和
            maxSum = max(maxSum, curSum); // 更新最大连续和
            if (curSum < 0) { // 如果当前的连续和小于0，那么就放弃当前的连续和，从下一个元素重新计算
                curSum = 0;
            }
        }
        return maxSum;
    }
};

Day26-回溯算法 part05

Sun, 06 Apr 2025 00:00:00 GMT

重新安排行程

332. 重新安排行程

题意：现在我们一堆「机票」，每张机票都是一个出发机场 -> 到达机场，比如 ["JFK", "SFO"] 表示从 JFK 飞到 SFO。

要求你用所有机票安排一个「完整的行程」，而且：

必须从 "JFK" 出发。
如果有多种行程方案可以使用完所有机票，就选字典序最小的那个（比如 A < B < C...）。

这本质是一个 图的欧拉路径问题（所有边恰好走一次），并结合了字典序优先遍历（DFS + 小顶堆）：

把机票变成一张图（邻接表），从出发点 "JFK" 开始 DFS。
每次从当前机场出发，优先访问「按字典序最小」的下一站。
回溯构建路径。

使用回溯 + map映射

首先我们要构建机场的和机场-机票的映射关系，这里我们可以使用 unordered_map 来存储机场和各机场的机票数量的关系。

各机场的机票数量可以使用 map<string, int> 来存储，key 为机场名，value 为机票数量。

所以我们的这个映射关系可以使用 unordered_map<string, map<string, int>> 来存储。

unordered_map<string, map<string, int>> targets;

// 初始化target
for (auto& ticket : tickets) {
    targets[ticket[0]][ticket[1]]++;
}

targets[出发机场][到达机场] = 这条航线剩余多少张票

例如：tickets = [["JFK", "ATL"], ["JFK", "SFO"], ["ATL", "SFO"]]

初始化之后会变成：

targets = {
    "JFK": {
        "ATL": 1,
        "SFO": 1
    },
    "ATL": {
        "SFO": 1
    }
}

之后是回溯函数的实现，回溯函数的参数为：

bool backTacking(int ticketNum, vector<string>& path)

- ticketNum：表示当前已经使用的机票数量
- path：表示当前的路径

回溯函数的返回值为 bool，表示是否找到了一条完整的路径。

回溯的终止条件：

if (ticketNum + 1== path.size()) {
    return true;
}

当机票数量加1等于搜索的路径长度时，说明找到了完整的路径。换一种说法就是找到了一条欧拉路径。
假如最后我们的路径是：["JFK", "SFO", "ATL"]，那么机票数量 ticketNum = 2，路径长度 path.size() = 3。

单层搜索的逻辑：

for (auto& target : targets[path.back()]) {
    // path.back(): path中的最后一个元素，也就是当前遍历到的机场
    // target[path.back()]: 当前机场的每条航线和机票数量，也就是遍历当前机场的每条航线
    // type(tar[path.back()]): map<string, int>
    if (target.second > 0) { // 如果遍历的当前航线机票还有剩余
        path.push_back(target.first); // 选择目的地，加入到path中
        target.second--; // 机票数量 - 1
        if (backTacking(ticketNum, path)) return true; // 如果递归刚加入的机场返回true，则继续向上返回
        target.second++; // 回溯 机票数量 + 1
        path.pop_back(); // 撤销目的地选择
    }
}

这里我们以初始化后的targets为例，可以有以下树状图：

targets = {
    "JFK": {
        "ATL": 1,
        "SFO": 1
    },
    "ATL": {
        "SFO": 1
    }
}

整体代码如下：

class Solution {
private:
    unordered_map<string, map<string, int>> targets;
    vector<string> ans;

    bool backTacking(int ticketNum, vector<string>& path) {
        if (ticketNum + 1 == path.size()) { // 如果机票数量 + 1 == 机场数量，说明找到了一条可行的路径，也就是找到了一条欧拉路径
            return true;
        }
        for (auto& target : targets[path.back()]) {
            // path.back(): path中的最后一个元素，也就是当前遍历到的机场
            // target[path.back()]: 当前机场的每条航线和机票数量，也就是遍历当前机场的每条航线
            // type(tar[path.back()]): map<string, int>
            if (target.second > 0) { // 如果遍历的当前航线机票还有剩余
                path.push_back(target.first); // 选择目的地
                target.second--; // 机票数量 - 1
                if (backTacking(ticketNum, path)) return true; // 如果递归刚加入的机场返回true，则继续向上返回
                target.second++; // 回溯 机票数量 + 1
                path.pop_back(); // 撤销目的地选择
            }
        }
        return false; // 否则返回false，说明没有找到
    }
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear();
        ans.clear();
        // 初始化targets
        for (const auto ticket : tickets) {
            // 初始化unordered_map
            // ticket[0]: 机场名
            // ticket[1]: 该机场对应的航班以及机票数量，是一个map<string, int>
            // 相当于从初始化有向图
            targets[ticket[0]][ticket[1]]++;
        }
        ans.push_back("JFK");
        backTacking(tickets.size(), ans);
        return ans;
    }
};

使用链表 + 优先级队列

这种做法其实是基于有向图的 DFS + 小顶堆（优先级队列）来实现的。属于是一种 Hierholzer 算法的变种，用来找欧拉路径，但加入了一个要求：每次访问字典序最小的边。

Hierholzer 算法主要思路是：

在图中从起点开始一路走下去，每次都选择字典序最小的下一站，走完一条路径后“回溯地插入”路径到最终结果中。

数据结构的选择：

// 使用优先队列来存储每个机场的目的地
unordered_map<string, priority_queue<string, vector<string>, greater<string>>> graph;

key 是出发机场
value 是一个小顶堆（优先队列），每次能快速拿到字典序最小的目的地

它的含义是：建立一个从出发机场 string 到多个目的地 string 的映射，并且这些目的地是按字母排序的优先级队列（小顶堆），这样可以随时快速找到“字典序最小的下一个目的地”。

第一层：

unordered_map<string, ...>

这是一张哈希表（无序 map），
key 是出发机场（比如 "JFK"、"LHR" 等）；
value 是从这个机场出发所能到达的所有机场的集合（你要用优先队列来维护这些目的地）。

第二层：

priority_queue<string, vector<string>, greater<string>>

这是 C++ 的小顶堆写法，它的含义是：一个会自动维护“字典序最小”的字符串在队首的优先队列。

默认 priority_queue 是大顶堆，也就是“最大的在前面” 所以我们要自己写成小顶堆（最小字母在前）：

vector<string> 是底层容器
greater<string> 是比较函数（实现小顶堆）

// 优先级队列数据结构预览
graph["JFK"] = {"ATL", "SFO", "LHR"} // 自动按字母顺序管理
graph["LHR"] = {"SFO"}

/// 使用链表来保存最终结果
list<string> itinerary;

使用链表 list 来保存最终结果，方便在路径前面插入（从后往前构建路径）

深度优先搜索（DFS）过程：

// Hierholzer 算法的 DFS 过程
void dfs(const string& airport) {
        auto& pq = graph[airport]; // 引用当前机场对应的优先队列
        // 当还有目的地没访问时，一直往下走
        while (!pq.empty()) {
            string next = pq.top(); // 拿出字典序最小的目的地
            pq.pop(); // 模拟用掉这张票
            dfs(next); // 递归访问下一个目的地
        }
        // 所有路径走完后，把当前节点插到最前面
        itinerary.push_front(airport); // 回溯插入
    }

最后整体的代码如下：

class Solution {
private:
   // 图结构：每个出发地 -> 所有目的地的小顶堆（按字母排序）
   unordered_map<string, priority_queue<string, vector<string>, greater<string>>> graph;

   // 用链表保存最终行程，方便在前面插入（欧拉路径是回溯构建的）
   list<string> itinerary;

   // 深度优先遍历构建行程
    void dfs(const string& airport) {
        // 引用当前机场对应的优先队列
        auto& pq = graph[airport];

        // 当还有目的地没访问时，一直往下走
        while (!pq.empty()) {
            string next = pq.top(); // 拿出字典序最小的目的地
            pq.pop();               // 模拟用掉这张票
            dfs(next);              // 递归访问下一站
        }

        // 所有路径走完后，把当前节点插到最前面
        itinerary.push_front(airport);  // 回溯时构建路径
    }
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        // 构建图
        for (const auto& ticket : tickets) {
            graph[ticket[0]].push(ticket[1]); // 加入小顶堆
        }

        // 从 JFK 出发执行 DFS
        dfs("JFK");

        // 把链表转换成 vector 输出结果
        return vector<string>(itinerary.begin(), itinerary.end());
    }
};

整体的思想：

用一个“出发机场 → 小顶堆目的地”的图结构，配合 Hierholzer 算法从 "JFK" 出发递归走图，每次优先访问字典序最小的目的地，构建出字典序最小的欧拉路径。

步骤	做的事情	用到的结构
1️	把机票构造成一张有向图	`unordered_map<string, 优先级队列(小顶堆)>`
2️	用 DFS 找一条「覆盖所有边」的路径（Hierholzer 算法）	递归 + 小顶堆控制顺序
3️	每当走完当前点所有边，就把它「插入路径前面」	`list<string>` 反向构造路径
4️	最终返回完整路径	`list` → `vector`

N 皇后

51. N 皇后

在国际象棋的规则中，皇后可以在同一行、同一列和同一对角线上攻击其他棋子。所以本题的题意可以转换成：给定一个整数 n，要求在 n x n 的棋盘上放置 n 个皇后，使得：

每行只能有一个皇后
每列只能有一个皇后
每条对角线（↘ / ↙）也不能有两个皇后

攻击范围矩阵 + 回溯

每次在某个位置放皇后，就把它能攻击到的位置都标记为 true（即“危险”）；然后递归下一行；回溯时撤销刚刚这一步设置的“危险区域”，恢复原状态。

首先我们可以定义两个全局变量：

vector<vector<string>> ans：用于存储所有的解
vector<string> board：用于存储当前的棋盘路径

回溯函数的参数为：

void backTracking(int n, int row, vector<vector<bool>>& danger)

n：表示棋盘的大小
row：表示当前行数
danger：表示当前危险的位置

递归终止的条件是：

if (row == n) {
    ans.push_back(board); // 当皇后数量等于n时（等于行数或列数）说明遍历结束
    return;
}

单层回溯逻辑：

从第 0 行开始，尝试在每一列放皇后，后记为 row 为行数，i 为列数
如果当前行的 danger[row][i] 为 true，说明当前位置是危险的，跳过
如果当前位置是安全的，即 danger[row][i] 为 false：
- 初始化 changed：用于记录 danger 矩阵中有哪些元素被修改过，标记其位置
- 放皇后：在 board[row][col] 放 Q
- 调用 flip()：标记所有攻击范围为 true，并记录 changed
- 递归下一行；
- 回溯时恢复：撤销并记录 board[row][col] = '.'，调用 unflip() 恢复 danger 矩阵状态；

最后的整体代码如下：

class Solution {
private:
    vector<vector<string>> ans;   // 所有解
    vector<string> board; // 当前棋盘路径

     // 标记攻击范围：行、列、主对角线、副对角线
     void flip(vector<vector<bool>>& danger, int i, int j, vector<pair<int, int>>& changed) {
        int n = danger.size();
        // 行
        for (int col = 0; col < n; ++col) {
            if (!danger[i][col]) { // 如果该位置尚未被标记为危险
                danger[i][col] = true; // 标记为危险
                changed.emplace_back(i, col); // 记录此次改动
            }
        }
        // 列
        for (int row = 0; row < n; ++row) {
            if (!danger[row][j]) { // 如果该位置尚未被标记为危险
                danger[row][j] = true; // 标记为危险
                changed.emplace_back(row, j); // 记录此次改动
            }
        }
        // -n 到 +n 是为了确保无论皇后在棋盘哪个位置，都能完整枚举它对应的整条对角线上的所有格子；然后通过边界检查来保证不越界。

        // 右对角线 ↘
        for (int d = -n; d <= n; ++d) { 
            int row = i + d;  // 当前对角线上的行坐标（沿 ↘ 方向增加）
            int col = j + d;  // 当前对角线上的列坐标（列也一样增加）
            // 保证当前(row, col)在棋盘范围内，且这个位置还没有被标记为危险
            if (row >= 0 && row < n && col >= 0 && col < n && !danger[row][col]) {
                danger[row][col] = true; // 标记为危险（不可放皇后）
                changed.emplace_back(row, col); // 记录这个位置，以便回溯还原
            }
        }
        // 左对角线 ↙
        for (int d = -n; d <= n; ++d) {
            int row = i + d; // 当前对角线上的行坐标（向下走）
            int col = j - d; // 列坐标反向移动（↙ 的方向）
            // 保证当前(row, col)在棋盘范围内，且这个位置还没有被标记为危险
            if (row >= 0 && row < n && col >= 0 && col < n && !danger[row][col]) {
                danger[row][col] = true; // 标记为危险
                changed.emplace_back(row, col); // 记录用于撤销
            } 
        }
    }

    void unflip(vector<vector<bool>>& danger, const vector<pair<int, int>>& changed) {
        // 将 flip() 中记录的所有变更位置恢复为 false，撤销当前层的影响
        for (const auto& [i, j] : changed) {
            danger[i][j] = false;
        }
    }

    void backTracking(int n, int row, vector<vector<bool>>& danger) {
        if (row == n) { // 当皇后数量等于n时（等于行数或列数）说明遍历结束
            ans.push_back(board);
            return;
        }

        for (int i = 0; i < n; i++) {
            if (danger[row][i]) {
                continue;
            }
            board[row][i] = 'Q';
            vector<pair<int, int>> changed;
            // 更改danger的当前行，当前列，两条对角线的布尔值
            flip(danger, row, i, changed);
            // 递归下一行
            backTracking(n, row + 1, danger);
            // 回溯danger的当前行，当前列，两条对角线的布尔值
            unflip(danger, changed);
            board[row][i] = '.';
        }
    }

public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<bool>> danger(n, vector<bool>(n, false)); // 用于记录当前危险的位置
        board = vector<string>(n, string(n, '.')); // 初始化棋盘路径
        backTracking(n, 0, danger);
        return ans;
    }
};

其实这种方法的难点在于如何标记和撤销危险区域，也就是 flip() 和 unflip() 函数的实现。

不过这种方法效率并不高，有一点绕弯路的意思。

不使用攻击标记

如果使用以上的方法的话，时间复杂度是 O(N^3)，空间复杂度是 O(N^2)。相对来说是耗时的。我们可以直接在回溯的逻辑中，直接判断当前位置放皇后是否合法。

也就是在递归逻辑中：

if (isValid(row, i, board)) {
    board[row][i] = 'Q'; // 放皇后
    backTracking(n, row + 1, board); // 递归下一行
    board[row][i] = '.'; // 回溯，并放置 '.`
}

重点就是如何实现 isValid() 函数：

bool isValid(int row, int col, const vector<string>& board) {
    // 检查当前列是否有皇后
    // 因为是要在每一行中放置一个皇后，所以可以不需要对行进行判断
    // 当前这一行是第一次处理，行里还没有任何皇后；
    // 前面的所有皇后都在上面的行中；
    // 因为我们是一行一行往下放，只需要检查 0 到 row-1 行
    for (int i = 0; i < row; ++i) {
        if (board[i][col] == 'Q') return false; // 当前列有皇后
    }
    // 检查主对角线 ↘
    for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; --i, --j) {
        if (board[i][j] == 'Q') return false; // 主对角线有皇后
    }
    // 检查副对角线 ↙
    for (int i = row - 1, j = col + 1; i >= 0 && j < board.size(); --i, ++j) {
        if (board[i][j] == 'Q') return false; // 副对角线有皇后
    }
    return true; // 没有冲突，可以放皇后
}

所以整体的代码如下：

class Solution {
private:
    vector<vector<string>> ans;   // 所有解
    vector<string> board; // 当前棋盘路径

    bool isValid(int row, int col, const vector<string>& board) {
        // 检查当前列是否有皇后
        // 因为是要在每一行中放置一个皇后，所以可以不需要对行进行判断
        // 当前这一行是第一次处理，行里还没有任何皇后；
        // 前面的所有皇后都在上面的行中；
        // 因为我们是一行一行往下放，只需要检查 0 到 row-1 行
        for (int i = 0; i < row; ++i) {
            if (board[i][col] == 'Q') return false; // 当前列有皇后
        }
        // 检查主对角线 ↘
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; --i, --j) {
            if (board[i][j] == 'Q') return false; // 主对角线有皇后
        }
        // 检查副对角线 ↙
        for (int i = row - 1, j = col + 1; i >= 0 && j < board.size(); --i, ++j) {
            if (board[i][j] == 'Q') return false; // 副对角线有皇后
        }
        return true; // 没有冲突，可以放皇后
    }

    void backTracking(int n, int row, vector<string>& board) {
        if (row == n) {
            ans.push_back(board);
            return;
        }

        for (int col = 0; col < n; col++) {
            if (isValid(row, col, board)) { // 如果这个位置放置皇后合法
                board[row][col] = 'Q'; // 放置皇后
                backTracking(n, row + 1, board); // 递归下一行
                board[row][col] = '.'; // 回溯标记为 '.'
            }
        }
    }

public:
    vector<vector<string>> solveNQueens(int n) {
        board = vector<string>(n, string(n, '.')); // 初始化棋盘路径
        backTracking(n, 0, board);
        return ans;
    }
};

这种方法的时间复杂度是 O(N^2)，空间复杂度是 O(N)。相对来说是比较高效的。

解数独

37. 解数独

这里于之前的 N 皇后不同的是，要做的是一个二维递归。因为在棋盘的每一个位置都要放置一个数字，并检查数字是否合法，解数独的树形结构要比N皇后更宽更深。

所以本质上还是一个回溯问题。

递归函数的参数：

bool backTracking(vector<vector<char>>& board)

因为我们需要搜索一个满足条件的答案，所以我们需要一个布尔返回值，当找到了解时就立刻返回。

递归终止条件：

这里其实可以不用写，因为我们在每次递归时都会检查当前的棋盘是否满足条件，如果满足条件就返回 true，否则会继续递归或者是 false。

单层回溯逻辑：

这里我们需要用到二维递归，因为每一个位置都要放置一个数字，所以我们需要两个循环来遍历每一个位置。

for (int i = 0; i < board.size(); i++) {
    for (int j = 0; j < board[0].size(); j++) {
        if (board[i][j] == '.') { // 遇到 '.'时进行处理
            for (char c = '1'; c <= '9'; c++) {
                if (isValid(i, j, c, board)) {
                    board[i][j] = c; // 放置数字
                    if (backTracking(board)) return true;
                    board[i][j] = '.'; // 回溯
                }
            }
            // 如果上述for循环已经走完了，说明没有合适的数字填在此处，等于数独无解返回false
            return false; 
        }
    }
}

然后还需要一个 isValid() 函数来判断当前数字是否合法：

bool isValid(int row, int col, char ch, vector<vector<char>>& board) {
    // 行中是否有该数字
    for (int i = 0; i < 9; i++) {
        if (board[row][i] == ch) return false;
    }

    // 列中是否有该数字
    for (int j = 0; j < 9; j++) {
        if (board[j][col] == ch) return false;
    }
    // 九宫格中是否有该数字
    //把 0~2 映射成 0，3~5 映射成 1，6~8 映射成 2
    // 再将这个 “宫格编号” 映射成其实际起点坐标：0 → 0，1 → 3，2 → 6
    int blockRow = (row / 3) * 3; // 九宫格行起始位置
    int blockCol = (col / 3) * 3; // 九宫格列起始位置
    for (int i = blockRow; i < blockRow + 3; i++) {
        for (int j = blockCol; j < blockCol + 3; j++) {
            if (board[i][j] == ch) return false;
        }
    }
    return true;
}

最后整体的代码如下：

class Solution {
private:
    vector<vector<char>> ans;

    bool isValid(int row, int col, char ch, vector<vector<char>>& board) {
        // 行中是否有该数字
        for (int i = 0; i < 9; i++) {
            if (board[row][i] == ch) return false;
        }

        // 列中是否有该数字
        for (int j = 0; j < 9; j++) {
            if (board[j][col] == ch) return false;
        }
        // 九宫格中是否有该数字
        //把 0~2 映射成 0，3~5 映射成 1，6~8 映射成 2
        // 再将这个 “宫格编号” 映射成其实际起点坐标：0 → 0，1 → 3，2 → 6
        int blockRow = (row / 3) * 3; // 九宫格行起始位置
        int blockCol = (col / 3) * 3; // 九宫格列起始位置
        for (int i = blockRow; i < blockRow + 3; i++) {
            for (int j = blockCol; j < blockCol + 3; j++) {
                if (board[i][j] == ch) return false;
            }
        }
        return true;
    }

    bool backTracking(vector<vector<char>>& board) {
        // 这里可以不需要返回值
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                if (board[i][j] == '.') { // 遇到 '.'时进行处理
                   for (char c = '1'; c <= '9'; c++) {
                        if (isValid(i, j, c, board)) {
                        board[i][j] = c; // 放置数字
                        if (backTracking(board)) return true;
                        board[i][j] = '.'; // 回溯
                        }
                    }
                    // 如果上述for循环已经走完了，说明没有合适的数字填在此处，等于数独无解返回false
                    return false; 
                }
            }
        }
        return true;
    }

public:
    void solveSudoku(vector<vector<char>>& board) {
        backTracking(board);
    }
};

总结

回溯算法的框架其实基本上是固定的一个写法，即使是二维递归也可以套用这个框架。总体的思路都是一致的，当满足条件，则进行下一层递归。

最后再回顾一下回溯算法的框架：

void backTracking(参数) {
    if (满足终止条件) { // 根据情况可能没有终止条件的情况
        // 处理结果
        return;
    }
    for (选择：所有可能的选择) {
        // 做选择
        backTracking(参数); // 递归进入下一层
        // 撤销选择
    }
}

最后当要搜索某一个路径的时候，可以用 bool 类型的返回值，如果是搜索所有的情况，则可以不需要返回值，也就是 void。

Day25-回溯算法 part04

Sat, 05 Apr 2025 00:00:00 GMT

非递减子序列

491. 非递减子序列

这里是要求所有的非递减子序列，和之前的组合问题类似，但这里不能对数组进行排序。

所以这里的去重逻辑和之前都不一样。

首先是和之前的子集问题一样，可以不加终止条件，不过按照题意至少拥有两个元素，所以当我们的 path 大于等于 2 时，才将其加入到 ans 中。

单层的搜索逻辑：

如果我们转换成树状图，可以发现，在同一层（也就是 for 循环中）中，已经用到的元素就不能再用了，而我们可以使用一个 set 来存储已经用过的元素，来达到去重的效果。

整体的代码如下：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> ans;

    void backTracking (vector<int>& nums, int startIndex) {
        if (path.size() >= 2) { // 当path长度大于等2时才加入结果集
            ans.push_back(path);
        }
        
        unordered_set<int> used; // 使用set来对同一层的元素进行去重
        for (int i = startIndex; i < nums.size(); i++) {
            // 当path不为空且当层遍历的元素小于path中最后一个元素，就跳过
            if (!path.empty() && nums[i] < path.back()) continue;
            // 当遍历的元素存在set中，说明之前已经用过该元素，跳过
            if (used.find(nums[i]) != used.end()) continue;
            used.insert(nums[i]);
            path.push_back(nums[i]);
            backTracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        path.clear();
        ans.clear();
        backTracking(nums, 0);
        return ans;
    }
};

全排列

46. 全排列

由于是求排列，因此在每一层的 for 循环中，我们都要遍历所有的元素，除了已经使用过的元素。

因此处理的逻辑其实可以和非递减子序列一样，使用一个 set 来存储已经使用过的元素。或者是使用 find 来判断是否已经使用过。

总体代码如下：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> ans;

    void backTracking(vector<int>& nums) {
        if (path.size() == nums.size()) { // 当路径长度等于数组长度时，找到一个排列
            ans.push_back(path);
            return;
        }
        // 注意因为求排列，所以i从0开始，以遍历所有的元素（除了已经使用过的）
        for (int i = 0; i < nums.size(); i++) { // 遍历每个数字
            if (find(path.begin(), path.end(), nums[i]) != path.end()) continue; // 如果数字已经在路径中，跳过
            path.push_back(nums[i]); // 选择数字
            backTracking(nums); // 递归
            path.pop_back(); // 撤销选择
        }
    }

public:
    vector<vector<int>> permute(vector<int>& nums) {
        path.clear();
        ans.clear();
        backTracking(nums);
        return ans;
    }
};

当然这里也可以使用一个 used 数组来标记是否使用过，代码如下：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> ans;

    // 使用used数组的方式
    void backTracking(vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) { // 当路径长度等于数组长度时，找到一个排列
            ans.push_back(path);
            return;
        }
        // 注意因为求排列，所以i从0开始，以遍历所有的元素（除了已经使用过的）
        for (int i = 0; i < nums.size(); i++) {
            if (used[i] == true) continue; // 如果数字已经在路径中，跳过
            used[i] = true; // 标记为已使用
            path.push_back(nums[i]);
            backTracking(nums, used);
            path.pop_back();
            used[i] = false; // 回溯时撤销标记
        }
    }

public:
    vector<vector<int>> permute(vector<int>& nums) {
        path.clear();
        ans.clear();
        vector<bool> used(nums.size(), false); // 初始化used数组
        backTracking(nums, used);
        return ans;
    }
};

全排列 II

47. 全排列 II

这里与全排列的区别在于，数组中可能存在重复的元素，因此我们需要对同一层的元素进行去重。

去重还一定要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。

我们对同一树层，前一位（也就是 nums[i-1] ）如果使用过，那么就进行去重。

总体的代码如下：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> ans;

    void backTracking(vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) { // 当路径长度等于数组长度时，找到一个排列
            ans.push_back(path);
            return;
        }

        for (int i = 0; i < nums.size(); i++) { // 遍历每个数字
            // used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果同一树层nums[i - 1]使用过则直接跳过
            if (used[i]) continue; // 如果数字已经被使用，跳过
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue; 
            used[i] = true; // 标记数字为已使用
            path.push_back(nums[i]); // 选择数字
            backTracking(nums, used); // 递归
            path.pop_back(); // 撤销选择
            used[i] = false; // 取消标记
        }
    }

public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
        ans.clear();    
        vector<bool> used(nums.size(), false); // 用于标记数字是否被使用
        sort(nums.begin(), nums.end()); // 排序以便去重
        backTracking(nums, used);
        return ans;
    }
};

:::tip[去重条件] 对于这个去重条件 if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;，我们可以理解为：在当前层中，如果我们遇到了两个值相同的元素，而前一个还没被用（说明它在当前层的某个位置被跳过了），那我们就不应该再用当前这个重复值了。

也就是说：

如果在当前层我们还没选过 nums[i - 1]，那就不应该再选 nums[i]（因为它俩相等）；
如果我们已经选过了 nums[i - 1]，说明当前这条路径在“不同树枝”上，可以选 nums[i]。 :::

在去重的代码中，我们可以看到 used[i - 1] 的判断条件，这里是为了避免在同一树层中，使用了相同的元素。

如果改成 used[i - 1] == true，也是正确的。如果要对树层中前一位去重，就用 used[i - 1] == false，如果要对树枝前一位去重用 used[i - 1] == true。

对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高。

这里以随想录中的所举的例子 [1, 1, 1] 为例^1：

树层上去重：

if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;

树枝上去重：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1]) continue;

树层上对前一位去重非常彻底，效率很高，树枝上对前一位去重虽然最后可以得到答案，但是做了很多无用搜索。

总结

如果我们在去重操作中不写这个条件，!used[i - 1] 或者 used[i - 1]，直接写成：

if (i > 0 && nums[i] == nums[i - 1]) continue;

其实并不行，一定要加上 used[i - 1] == false 或者 used[i - 1] == true，因为 used[i - 1] 要一直是 true 或者一直是 false 才可以，而不是一会是 true 一会又是 false, 所以这个条件要写上。

Day24-回溯算法 part03

Fri, 04 Apr 2025 00:00:00 GMT

复原IP地址

93. 复原IP地址

我们需要将一个字符串分割成4段合法的IP地址段，问题就变成了在字符串中寻找三个切割点，将整个字符串分为四段，每段都要符合合法条件。

其实与组合问题的思路是一样的，-字符串切割与组合问题的区别：

组合问题：选一个字母后，在剩余字母中继续选
切割问题：切掉一段后，在剩余部分继续切下一段

如果我们把这个问题转换成树形图，如图：

首先我们先定义两个全局变量：

vector<string> path;
vector<string> ans;

回溯三部曲：

递归参数因为我们在递归过程中需要知道从哪个地方进行下一层递归，所以我们需要一个 startIndex 参数来表示当前的起始位置。同时需要一个 dotCount 参数来表示当前的点的数量。
```
// 参数：字符串s，字符串起始位置startIndex，'.'的个数dotCount
void backTracking(const string& s, int startIndex, int dotCount)
```
递归终止条件
- 当 dotCount 等于 4 时，说明我们已经找到了 4 段合法的 IP 地址段
- 并且当 startIndex 等于字符串的长度时，说明我们已经遍历完了整个字符串
此时可以将 path 中的字符串加入到 ans 中。
```
if (dotCount == 4 && startIndex == s.size()) {
        ans.push_back(path[0] + "." + path[1] + "." + path[2] + "." + path[3]);
        return;
    }
```

单层搜索逻辑

每次分割的字符串最多只有三位，所以可以控制 i - startIndex <= 2，也就是每段最多三位数。
重要的地方是如何切割字符串，s.substr(startIndex, i - startIndex + 1) 表示从 startIndex 开始，取 i - startIndex + 1 个字符，也就是取 s[startIndex...i]。
我们将切割的字符串放入 path
进入下一层递归，i + 1 表示下一个起始位置，dotCount + 1 表示点的数量加 1。
回溯时将 path 中的最后一个元素删除。

// 每段最多3位，i是当前段的终止位置
    for (int i = startIndex; i < s.size() && i - startIndex <= 2; ++i) {
        if (isValid(s, startIndex, i)) {
            // 将当前分割的字符串先放入path中：[startIndex, i]
            path.push_back(s.substr(startIndex, i - startIndex + 1)); // 从startIndex开始, 取i - startIndex + 1个字符，也就是取s[startIndex...i]
            backTracking(s, i + 1, dotCount + 1);
            path.pop_back(); // 回溯
        } else {
            break; // 剪枝
        }
    }

isValid() 函数

段位以0为开头的数字不合法
段位里有非正整数字符不合法
段位如果大于255了不合法

bool isValid(const string& s, int start, int end) {
    if (start > end) return false;
    if (s[start] == '0' && start != end) return false; // 有前导 0
    int num = 0;
    for (int i = start; i <= end; i++) {
        if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
            return false;
        }
        num = num * 10 + (s[i] - '0');
        if (num > 255) { // 如果大于255了不合法
            return false;
    }
    return true;
}

总体的代码如下：

class Solution {
private:
    vector<string> path;
    vector<string> ans;

    bool isValid(const string& s, int start, int end) {
        if (start > end) return false;
        if (s[start] == '0' && start != end) return false; // 有前导 0
        int num = 0;
        for (int i = start; i <= end; i++) { // 如果该字符串转换成整数的数值>255返回false
            if (!isdigit(s[i])) return false;
            num = num * 10 + (s[i] - '0');
            if (num > 255) return false;
        }
        return true;
    }
public:
    // 参数：字符串s，字符串起始位置startIndex，'.'的个数dotCount
    void backTracking(const string& s, int startIndex, int dotCount) {
        // 如果已经切了4段，检查是否用完字符串
        // 并且已经切割到最后一个字符串
        if (dotCount == 4 && startIndex == s.size()) {
            ans.push_back(path[0] + "." + path[1] + "." + path[2] + "." + path[3]);
            return;
        }
        
        // 每段最多3位，i是当前段的终止位置
        for (int i = startIndex; i < s.size() && i - startIndex <= 2; ++i) {
            if (isValid(s, startIndex, i)) {
                // 将当前分割的字符串先放入path中：[startIndex, i]
                path.push_back(s.substr(startIndex, i - startIndex + 1)); // 从startIndex开始, 取i - startIndex + 1个字符，也就是取s[startIndex...i]
                backTracking(s, i + 1, dotCount + 1);
                path.pop_back(); // 回溯
            } else {
                break; // 剪枝
            }
        }
    }

    vector<string> restoreIpAddresses(string s) {
        ans.clear();
        if (s.size() < 4 || s.size() > 12) return ans;
        backTracking(s, 0, 0);
        return ans;
    }
};

子集

78. 子集

如果把子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点。

因此这里的差别就体现在什么时候收集结果。以 nums = [1,2,3] 为例把求子集抽象为树型结构，如下：

可以发现，我们每进行一次递归，就要把当前的 path 加入到结果中。

class Solution {
private:
    vector<int> path;
    vector<vector<int>> ans;
public:
    void backTracking(vector<int>& nums, int startIndex) {
        ans.push_back(path); // 刚进入递归时，就收集结果
        if (startIndex >= nums.size()) { // 可以不写终止条件，因为满足该条件时，以下for循环不会进行
            return;
        }

        for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backTracking(nums, i + 1); // 不重复，从i + 1开始
            path.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        ans.clear();
        path.clear();
        backTracking(nums, 0);
        return ans;
    }
};

子集II

90. 子集 II

次问题是一个综合了子集和组合总和II的问题，无非就是在子集问题上加了一个去重的操作。

代码其实不难，主要是要注意去重的操作。

class Solution {
private:
    vector<int> path;
    vector<vector<int>> ans;
public:
    void backTracking(vector<int>& nums, int startIndex) {
        ans.push_back(path); // 每进入一次递归就要收集结果
        if (startIndex >= nums.size());

        for (int i = startIndex; i < nums.size(); i++) {
            if (i > startIndex && nums[i] == nums[i - 1]) continue; // 去重
            path.push_back(nums[i]);
            backTracking(nums, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        path.clear();
        ans.clear();
        sort(nums.begin(), nums.end()); // 针对去重需要排序
        backTracking(nums, 0);
        return ans;
    }
};

总结

对于组合问题和分割问题，我们都是从树的叶子节点收集结果，最后是当满足一定条件才收集结果。

而对于子集问题，我们是从树的所有节点收集结果，也就是每进行一次递归都要收集一次结果。

Day23-回溯算法 part02

Thu, 03 Apr 2025 00:00:00 GMT

组合总和

39. 组合总和

这里和组合总和III 的区别在于，本题的数组中的元素是可以重复使用的，也就是说在 for 循环中的回溯递归过程中，选取元素的位置可以从当前的 i 开始，而不是 i + 1。

这里对于组合问题，什么时候需要用到 start 标识来控制元素的选择：

如果是用一个数组（或集合）中的元素来进行组合，那么就需要用到 start 来控制元素的选择。例如77. 组合中的 start 就是用来控制元素的选择的。
如果是多个数组（或集合）中的元素来进行组合，那么就不需要用到 start 来控制元素的选择。例如17. 电话号码的字母组合，各个集合之间的元素互不影响，所以不需要用到 start 来控制元素的选择。

所以我们可以有以下的思路：

class Solution {
private:
    vector<int> path; // 全局变量，存储当前遍历的数字
    vector<vector<int>> ans; // 全局变量，存储所有的组合
public:
    void backTracking(vector<int>& candidates, int target, int start) {
        if (target < 0) return; // 重要：如果target小于0，说明当前路径不符合条件，直接返回
        if (target == 0) { // 如果target等于0，说明当前路径符合条件
            ans.push_back(path);
            return;
        }
        for (int i = start; i < candidates.size() && candidates[i] <= target; i++) { //一旦 candidates[i] > target，就不会再往后递归，这里的数组一定是有序的
            path.push_back(candidates[i]);
            backTracking(candidates, target - candidates[i], i); // 这里的 i 而不是 i + 1，表示可以重复使用当前元素
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        // 剪枝操作一定要对数组进行排序
        sort(candidates.begin(), candidates.end());
        backTracking(candidates, target, 0);
        return ans;
    }
};

注意这里的剪枝操作，没有排序时，candidates[i] > target 不代表后面的都更大，所以不能剪枝，否则就会漏掉组合。

组合总和II

40. 组合总和 II

这个问题其实和之前的组合问题区别不大，主要是需要对重复的元素进行去重处理。

所以这里就直接写出代码了

class Solution {
private:
    vector<int> path;
    vector<vector<int>> ans;
public:
    void backTracking(vector<int>& candidates, int target, int start) {
        if (target < 0) return;
        if (target == 0) {
            ans.push_back(path);
            return;
        }
        for (int i = start; i < candidates.size() && candidates[i] <= target; i++) {
            // start是在该层的第一个选择，所以要先判断i>start，相当于后续子数组的“0”位置
            if (i > start && candidates[i] == candidates[i - 1]) continue; // 去重操作
            path.push_back(candidates[i]);
            backTracking(candidates, target - candidates[i], i + 1); // 从下一个元素开始，避免重复使用
            path.pop_back();
        }
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backTracking(candidates, target, 0);
        return ans;
    }
};

分割回文串

131. 分割回文串

字符串的切割问题和之前的组合问题类似，例如对于字符串 abcdef：

组合问题：选取一个 a 之后，在 bcdef 中再去选取第二个，选取 b之后在 cdef 中再选取第三个.....。切割问题：切割一个 a 之后，在 bcdef 中再去切割第二段，切割b之后在 cdef 中再切割第三段.....。

可以抽象为以下的树形图：

递归用来纵向遍历，for循环用来横向遍历，切割线（就是图中的红线）切割到字符串的结尾位置，说明找到了一个切割方法。^1

从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。

if (start == s.size()) {
    ans.push_back(path);
    return;
    }

对于如何分割：

从 start 开始，枚举所有的子串 s[start..i]，判断是否是回文串。
如果是回文串，就将 s[start..i] 加入到当前路径 path 中，然后递归分割剩下的子串 s[i+1..end]。
如果不是回文串，就继续枚举下一个子串 s[start..i+1]，直到 i 到达字符串的末尾。
递归结束后，回溯到上一个状态，移除上一次加入的子串 s[start..i]，继续枚举下一个子串 s[start..i+1]。
直到所有的子串都枚举完毕，返回所有的分割方案。

可以有以下的代码：

class Solution {
private:
    vector<vector<string>> ans;  // 最终结果，包含所有分割方案
    vector<string> path;         // 当前递归路径下的分割结果

    // 判断 s[left..right] 是否是回文串
    bool isPalindrome(const string& s, int left, int right) {
        while (left < right) {
            if (s[left++] != s[right--]) return false;  // 有不相等的字符就不是回文
        }
        return true;  // 所有字符相等，说明是回文
    }

    void backtrack(const string& s, int start) {
        // 如果 start 到达字符串末尾，说明已经成功分割一组，加入结果
        if (start == s.size()) {
            ans.push_back(path);
            return;
        }

        // 枚举所有从 start 开始的子串
        for (int i = start; i < s.size(); ++i) {
            // 判断 s[start..i] 是否是回文串
            if (isPalindrome(s, start, i)) {
                // 是回文串就加入当前路径
                path.push_back(s.substr(start, i - start + 1));
                // 递归分割剩下的子串（从 i+1 开始）
                backtrack(s, i + 1);
                // 回溯，移除上一次加入的子串
                path.pop_back();
            }
        }
    }

public:
    // 主函数，调用回溯
    vector<vector<string>> partition(string s) {
        backtrack(s, 0);  // 从索引 0 开始回溯
        return ans;       // 返回所有合法的分割方案
    }
};

这里其实也可以使用动态规划来解决这个问题，不过当前阶段就先不使用了。

Day22-回溯算法 part01

Wed, 02 Apr 2025 00:00:00 GMT

回溯算法

回溯算法就是在尝试一条路径的过程中不断深入，如果发现不能达到目标，就回退一步，换另一种选择继续尝试，直到找到解或者穷尽所有解。

它本质上是一个 递归过程 + 状态恢复。

回溯算法与 DFS 的关系：回溯算法是深度优先搜索（DFS）的一种特例。但回溯算法更强调“撤销操作”，是“DFS + 剪枝 + 撤销”的过程。

回溯法，一般可以解决如下几种问题：

组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等

回溯算法通用模板(C++伪代码)：

void backtrack(参数) {
    if (满足结束条件) {
        保存结果;
        return;
    }

    for (每一个可选选择) {
        if (不合法) continue;

        做出选择;
        backtrack(进入下一层); // 递归
        撤销选择; // 回溯
    }
}

组合

77. 组合

这里的关键点：

数字之间的顺序不重要，只要组合内的数字集合相同就认为是相同的结果。
要求输出所有可能的组合，这要求遍历所有可能的选择。

如果要使用 for 循环来实现，可能会导致当 k 较大时，循环的次数会非常多，导致时间复杂度过高。因此我们可以使用回溯算法来实现。

我们可以有以下思路：

1. 参数

路径（path）：当前已经选择的数字集合，代表当前的决策过程。
候选列表：在数字 1 到 n 中，当前还可以选择的数字。
起点（start）：为了避免重复组合，我们规定每次递归选择数字时只能从当前数字之后的数字中进行选择。
- 例如，第一次选择从 1 开始；如果选了 1，那么接下来只能从 2 开始，这样保证了组合的顺序和唯一性。

2. 终止条件

当路径的长度等于 k 时，说明当前构建的组合已经完整，此时将当前的路径记录下来，然后返回上层，进行其他分支的探索。
- 终止条件：if (path.size() == k)。

3. 递归过程

循环选择：从当前起点 start 到 n 进行遍历，每一次循环：
- 选择数字 i：将 i 加入当前路径。
- 递归调用：更新起点为 i+1，因为后续的选择只考虑比 i 大的数字。
- 撤销选择：递归返回后，将 i 从路径中移除，以便探索其他可能的数字。
这个过程对应于在一棵决策树中深度优先地遍历所有可能的路径。

根据回溯算法的通用模板，我们可以实现如下代码：

vector<int> path; // 全局变量存储组合
vector<vector<int>> ans; // 全局变量存储所有的组合

void backTracking(int n, int k, int start, vector<int>& path) {
    if (path.size() == k) { // 如果path长度等于k，那么存储结果并返回
        ans.push_back(path);
        return;
    }
    // 单层搜索逻辑
    for (int i = start; i <= n; i++) { // i == n 是有意义的
        path.push_back(i); // 将当前数字 i 添加到组合中
        backTracking(n, k, i + 1, path); // 递归：将起点更新为 i+1，表示后续只选择比 i 大的数字
        path.pop_back(); // 回溯：将 i 移除，恢复状态，以便尝试其他选择
    }
    return;
}
vector<vector<int>> combine(int n, int k) {
    backTracking(n, k, 1, path); // 根据题意这里是从1开始
    return ans;
}

:::tip[剪枝操作] 在 for 循环中，我们可以进行剪枝操作，避免不必要的递归调用。例如，如果当前路径的长度加上剩余的数字数量小于 k，那么就没有必要继续递归下去，因为不可能满足条件。

if (path.size() + (n - i + 1) < k) { // 当剩余数字数量小于 k 时，剪枝
    break; // 剪枝操作
}

path_size(): 当前路径的长度
(n - i + 1): 剩余数字的数量

:::

我们也可以将这个问题抽象成一个树的遍历问题^1：

每个节点代表一个数字的选择。
每个节点的子节点代表在当前选择的基础上，继续选择下一个数字。
叶子节点代表一个完整的组合。

如图所示：

每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。

图中可以发现 n 相当于树的宽度，k 相当于树的深度。

组合总和III

216. 组合总和 III

这里和组合问题是相似的回溯算法，只是添加了一些限制条件，我们可以用相同的思路来写以下的代码：

vector<int> path; // 全局变量存储组合
vector<vector<int>> ans; // 全局变量存储所有的组合

void backTracking(int n, int k, int start, vector<int>& path) {
    if (n == 0 && path.size() == k) { // 如果相加之和被减到0, 且path的大小等于k，说明满足条件
        ans.push_back(path);
        return;
    }
    // 单层搜索逻辑
    // 剪枝操作 i + (k - path.size()) + 1 <= 9，和之前的剪枝是一个原理
    for (int i = start; i <= 9; i++) {
        path.push_back(i); // 将当前数字 i 添加到组合中
        backTracking(n - i, k, i + 1, path); // 隐藏的回溯逻辑，n的值没有被改变
        path.pop_back(); // 回溯：将 i 移除，恢复状态，以便尝试其他选择
    }
}

vector<vector<int>> combinationSum3(int k, int n) {
    backTracking(n, k, 1, path); // 根据题意这里是从1开始
    return ans;
}

:::tip[剪枝操作] 在 for 循环中，进行剪枝避免不必要的递归调用。例如，如果当前路径的长度加上剩余的数字数量小于 k，就没有必要继续递归下去。

if (path.size() + (n - i + 1) < k) { // 当剩余数字数量小于 k 时，剪枝
    break; // 剪枝操作
}
path_size(): 当前路径的长度
(n - i + 1): 剩余数字的数量

:::

总体来说和之前的组合问题是一个类型。

电话号码字母组合

17. 电话号码的字母组合

这是一个排列问题，不同于组合（无序），本题要求输出所有有顺序的字母排列组合，每一位数字都有自己的字母选择。

"23" -> 两位数字
→ 第1位可选 ['a','b','c']
→ 第2位可选 ['d','e','f']
目标是从每一位中选出一个字母，组成一个字符串，最终生成所有可能结果。

我们可以把问题想成一个多叉树：

每一层表示一个数字；
每一层的分支是当前数字可选的字母；
我们从第一层一路向下选择，直到路径长度和输入数字长度相等，得到一个完整组合。

我们以“23”为例
                  " "
        /          |          \
        a          b           c                 ← 第一个数字 2 的字母
      / | \      / | \      /  |  \
     d  e  f    d  e  f    d   e   f             ← 第二个数字 3 的字母

从根节点开始，每层做一个选择，最终到达叶子节点，就完成一个组合。

根据前面的经验我们可以写出以下的代码：

class Solution {
private:
    string path;
    vector<string> ans;
    // 数字到字母的映射
    vector<string> phoneMap = {
        "",     // 0
        "",     // 1
        "abc",  // 2
        "def",  // 3
        "ghi",  // 4
        "jkl",  // 5
        "mno",  // 6
        "pqrs", // 7
        "tuv",  // 8
        "wxyz"  // 9
    };
public:
    // 回溯函数：用于从 digits[index] 开始，尝试所有可能的组合
    void backTracking(const string &digits, int index) { // index是传入字符串的下标
        // 终止条件：当 index 等于 digits 的长度，说明所有数字都处理完
        if (index == digits.size()) {
            // 到达末尾，把当前路径保存
            if (!path.empty()) ans.push_back(path);
            return;
        }
        // 当前要处理的数字字符，ASCII 值处理方式
        int digit = digits[index] - '0';
        // 遍历该数字对应的所有字母
        for (char c : phoneMap[digit]) {
            path.push_back(c);
            backTracking(digits, index + 1); // 递归下一层
            path.pop_back();
        }
        return;
    }

    vector<string> letterCombinations(string digits) {
        backTracking(digits, 0); // 从第0位开始处理
        return ans;
    }
};

Day21-二叉树 part08

Tue, 01 Apr 2025 00:00:00 GMT

修剪二叉搜索树

669. 修剪二叉搜索树

本题可以使用递归来完成，利用二叉搜索树的特性，我们可以有效地剪枝不符合条件的子树。主要的处理逻辑分为以下几种情况：

递归终止条件
当当前节点为空时，说明已经遍历到空节点，直接返回 nullptr。
当前节点的值小于 low
说明当前节点及其左子树所有节点的值都小于 low，根据 BST 的性质，左子树上的所有节点也都不符合条件，因此可以直接舍弃左子树和当前节点，递归修剪右子树，并将修剪结果返回。
当前节点的值大于 high
说明当前节点及其右子树所有节点的值都大于 high，同理可以舍弃右子树和当前节点，递归修剪左子树，并将修剪结果返回。
当前节点的值在区间 [low, high] 之内
当前节点是合法的，我们保留该节点，并继续分别修剪它的左右子树。将修剪后的左子树接到当前节点的 left 指针，将修剪后的右子树接到当前节点的 right 指针。
最终返回当前节点
经过上述判断和修剪后，当前节点要么是合法节点，要么已经替换为左右子树中修剪后合法的部分，最终返回该节点。

:::important 不能在当前节点值不在 [low, high] 的时候直接 return nullptr，而是应该继续处理它的左子树或右子树。

例如：

如果当前节点值小于 low ，那么它的左子树所有值一定也小于 low，可以舍弃，但右子树可能有合法值，需要递归处理右子树。
同理，如果当前节点值大于 high，左子树可能有合法值，不能直接舍弃整个子树。

:::

例如一棵树的结构如下：

      3
     / \
    3
   / \
  0   4
   \
    2
   /
  1

L = 1, R = 3
遇到节点 0 时判断其不在范围内，直接返回 nullptr，但 0 的右子树中有 2 和 1，是合法的节点，却被错误舍弃了。

因此我们可以根据上面的逻辑写出以下的代码：

TreeNode* trimBST(TreeNode* root, int low, int high) {
    // 1. 递归终止条件，如果当前节点为空，直接返回空
    if (!root) return nullptr;
    // 2. 如果当前节点的值小于 low，说明当前节点及其左子树都不符合要求，那么我们需要递归修建右子树
    if (root->val < low) {
        TreeNode* right = trimBST(root->right, low, high);
        return right;
    }
    // 3. 如果当前节点的值大于high，说明当前节点及其右子树不符合要求，那么需要递归修剪其左子树
    if (root->val > high) {
        TreeNode* left = trimBST(root->left, low, high);
        return left;
    }

    // 将向左递归的结果用root的左孩子接住
    root->left = trimBST(root->left, low, high);
    // 将向右递归的结果用root的右孩子接住
    root->right = trimBST(root->right, low, high);

    return root;
}

将有序数组转换为平衡二叉搜索树

108. 将有序数组转换为二叉搜索树

原标题是“将有序数组转换为二叉搜索树”，但实际上要注意是将有序数组转换为平衡二叉搜索树。

首先平衡树的定义是：对于每个节点，左子树和右子树的高度差不超过 1。然后同时保证这棵树是一棵二叉搜索树。

在构造二叉树时，一般都可以默认使用数组的中间元素作为根节点。其实本质就是寻找数组的分割点，以分割点作为根节点，左边的元素作为左子树，右边的元素作为右子树。

核心思路：分治 + 递归

将升序数组转换为平衡 BST，本质上就是要保持结构对称：

每次选择数组的“中间元素”作为根节点
左半部分构成左子树
右半部分构成右子树
对左右子数组递归执行相同操作

所以我们可以有以下的步骤：

定义递归函数 buildBST(nums, left, right)，表示构造从 nums[left] 到 nums[right] 的子数组对应的平衡 BST
如果 left > right，说明区间无效，返回空指针（递归终止条件）
计算中间索引：mid = (left + right) / 2
创建根节点：TreeNode* root = new TreeNode(nums[mid])
递归构造左子树：root->left = buildBST(nums, left, mid - 1)
递归构造右子树：root->right = buildBST(nums, mid + 1, right)
返回当前构建的 root

最终调用 buildBST(nums, 0, nums.size() - 1) 得到整棵树的根节点

// 从 nums[left] 到 nums[right] 构造平衡 BST
TreeNode* buildBST(const vector<int>& nums, int left, int right) {
    // 递归终止条件：区间为空时返回空指针
    if (left > right) return nullptr;
    // 取中间位置作为当前子树的根节点，保持平衡性
    int mid = left + (right - left) / 2; // 防止整型溢出
    TreeNode* root = new TreeNode(nums[mid]); // 创建根节点

    root->left = buildBST(nums, left, mid - 1); // 递归构建左子树，左半部分 [left, mid - 1]
    root->right = buildBST(nums, mid + 1, right); // 递归构建右子树，右半部分 [mid + 1, right]

    return root;
}

TreeNode* sortedArrayToBST(vector<int>& nums) {
    return buildBST(nums, 0, nums.size() - 1);
}

把二叉搜索树转换为累加树

538. 把二叉搜索树转换为累加树

累加树的定义：

对每个节点，它的新值 = 原值 + 所有 大于它的节点值之和

也就是说：

每个节点都会“获得”所有比它大的节点值的“加成”
原本的 BST 被“累加”成了一个新的树结构

我们可以把二叉搜素树看作一个“有序的数组”，用中序遍历来得到这个数组，以这个数组作为例子。

假设原始 BST：

      5
     / \
    2   13

中序遍历（左→中→右）得到的序列是：2, 5, 13（升序）

现在，我们希望变成累加树：

遍历顺序换成右→中→左（从大到小）
初始 sum = 0

开始反向遍历：

访问 13
- sum += 13 → sum = 13
- 节点值 = 13
访问 5
- sum += 5 → sum = 18
- 节点值 = 18
访问 2
- sum += 2 → sum = 20
- 节点值 = 20

结果树：

      18
     /  \
   20    13

把这个树理解为一个“从右向左”不断“累加贡献值”的结构，累加树就非常好理解了。

所以我们需要实现一个类似数组的“倒序遍历”二叉搜索树，并在遍历的过程中进行累加。从树中可以看出累加的顺序是右中左，那么这个“倒序遍历”其实就是反向中序遍历。所以我们需要反中序遍历这个二叉树，然后顺序累加就可以了。

在数组中，我们可以用刷换那个指针来实现反向遍历，在二叉搜索树中，我们也可以使用双指针来实现累加的过程。

用sum来记录当前的累加值，遍历到每个节点时，先把sum加到当前节点的值上，然后再更新sum。

整体代码如下：

int sum = 0; // 用于记录累加值
void traverse(TreeNode* root) {
    if (root == nullptr) return;
    // 先访问右子树（较大的节点）
    traverse(root->right); // 右
    // 累加当前节点值
    // 中
    sum += root->val;
    root->val = sum;
    // 再访问左子树（较小的节点）
    traverse(root->left); // 左
}

TreeNode* convertBST(TreeNode* root) {
    traverse(root);
    return root;
}

Day20-二叉树 part07

Mon, 31 Mar 2025 00:00:00 GMT

二叉搜索树的最近公共祖先

235. 二叉搜索树的最近公共祖先

二叉搜索树（BST）的特性，对于任意一个节点 root：

左子树所有值 < root->val
右子树所有值 > root->val

所以根据二叉搜索树的这个特性，我们可以有以下的思路：

我们从根节点 root 开始，比较 p 和 q 的值：

情况一：p.val < root.val && q.val < root.val

→ 说明 p 和 q 都在左子树 → 往左走
情况二：p.val > root.val && q.val > root.val

→ 说明 p 和 q 都在右子树 → 往右走
情况三：p 和 q 分别在两边

→ 当前 root 就是最近公共祖先

:::tip[为什么当 p 和 q 分别在两边时，当前 root 就是最近公共祖先] 在 BST 中，每个节点都有如下性质：

所有左子树节点 < 当前节点值
所有右子树节点 > 当前节点值

假设我们在当前节点 root 发现：

p < root->val && q > root->val 或者相反
说明它们分布在两边

→ 如果再往上走一层，p 和 q 仍然是它的子孙，但距离更远

→ 如果再往下走一层，那一边就不包含两个节点了

所以，“第一次分叉的地方”一定是最近公共祖先。 :::

因此我们可以写出以下的代码：

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
    // 如果 p 和 q 都比 root 小，说明 LCA 在左子树
    if (p->val < root->val && q->val < root->val) {
        return lowestCommonAncestor(root->left, p, q);
    }
    // 如果 p 和 q 都比 root 大，说明 LCA 在右子树
    else if (p->val > root->val && q->val > root->val) {
        return lowestCommonAncestor(root->right, p, q);
    }
    // 否则，说明分布在两边，当前 root 就是最近公共祖先
    else {
        return root;
    }
}

二叉搜索树中的插入操作

701. 二叉搜索树中的插入操作

我们要做的事很简单：

从根节点出发，根据大小关系，递归或迭代地走到合适的位置，然后插入新节点。

当前节点不为空：
- 如果 val < root->val，递归插入到左子树
- 如果 val > root->val，递归插入到右子树
当前节点为空（走到叶子外部了）：
- 创建新节点并返回

所以可以写出以下的代码：

TreeNode* insertIntoBST(TreeNode* root, int val) {
    // 如果当前节点为空，说明找到了插入位置
    if (root == nullptr) {
    return new TreeNode(val);
    }
    // 如果插入值小于当前节点，插入到左子树
    if (val < root->val) {
    root->left = insertIntoBST(root->left, val);
    }
    // 如果插入值大于当前节点，插入到右子树
    else if (val > root->val) {
    root->right = insertIntoBST(root->right, val);
    }
    // 返回当前节点（整棵树最终返回 root）
    return root;
}

:::tip[为什么不需要“重新排序”或者“重构整棵树”，只需要在正确的位置插入就行？] 我们在“每一步决策”里都遵守了 BST 的基本规则：

如果 val < 当前节点 → 插入左子树
如果 val > 当前节点 → 插入右子树

这样保证了“局部有序性”：插入后，每一层都仍然满足 BST 条件，再加上 BST 是递归结构，每个子树也是一棵 BST，所以这种局部有序性会自动延续下去。

换句话说，只要遵守 “小左大右” 的递归结构，BST 的性质就保持住了 :::

二叉树中的删除操作

450. 二叉搜索树中的删除操作

相比插入节点相比，删除的逻辑更复杂一些。

递归函数的终止条件是：当当前节点为空时，返回空指针。

if (root == nullptr) return nullptr;

这里我们大致可以分为三种情况，也可以看作是五种：

未找到节点，直接返回空指针
删除的节点是叶子节点，直接删除
仅有右子树存在，右子树补位
仅有左子树存在，左子树补位
左右子树都存在，找到右子树的最小节点（后继），将当前节点的左子树接到它的左侧
- 这里的最小节点是指：在右子树中，最左边的节点（也就是最小值）
- 之后将当前节点的左子树接到它的左侧
- 然后返回当前节点的右子树为新的根节点

以下为第五种情况的动画演示

根据上面的逻辑，我们可以写出以下的代码：

TreeNode* deleteNode(TreeNode* root, int key) {
    if (root == nullptr) return nullptr; // 情况 1：未找到节点，直接返回空

    if (key < root->val) {
        // 说明目标值在左子树中，递归删除
        root->left = deleteNode(root->left, key);
    } 
    else if (key > root->val) {
        // 说明目标值在右子树中，递归删除
        root->right = deleteNode(root->right, key);
    } 
    else {
        // 情况 2~5：找到目标节点，开始分类处理

        // 情况 2：叶子节点，直接删除
        if (root->left == nullptr && root->right == nullptr) {
            delete root;
            return nullptr;
        }
        // 情况 3：仅右子树存在，右子树补位
        else if (root->left == nullptr) {
            TreeNode* retNode = root->right;
            delete root;
            return retNode;
        }
        // 情况 4：仅左子树存在，左子树补位
        else if (root->right == nullptr) {
            TreeNode* retNode = root->left;
            delete root;
            return retNode;
        }
        // 情况 5：左右子树都存在
        // 找到右子树的最小节点（后继），将当前节点的左子树接到它的左侧
        else {
            TreeNode* successor = findMin(root->right);
            successor->left = root->left;
            TreeNode* temp = root;
            root = root->right;  // 把 root->right 提上来作为新的根
            delete temp;
            return root;
        }
    }
    return root;
}

// 辅助函数：查找某个子树的最小节点（一直往左走）
TreeNode* findMin(TreeNode* node) {
    while (node->left != nullptr) {
        node = node->left;
    }
    return node;
}

总结

操作二叉搜索树的关键在于始终遵循“小于放左，大于放右”的结构规律。无论是查找、插入还是删除，本质都是在利用这一规则不断缩小问题规模。

二叉搜索树添加节点只需要在叶子上添加就可以的，不涉及到结构的调整，而删除节点操作涉及到结构的调整。

Day18-二叉树 part06

Sun, 30 Mar 2025 00:00:00 GMT

二叉树搜索树的最小绝对值差

530.二叉搜索树的最小绝对值差

利用二叉搜素树的特性

这里的思路与验证二叉搜索树其实是一致的，需要明确的是，二叉搜索树进行中序遍历的时候一定是一个递增的序列。

所以可以利用这个特性来求解最小绝对值差。

void traversal(TreeNode* node, vector<int>& nums) { // 中序遍历搜索二叉树，返回有序数组
    if (!node) return;
    if (node->left) traversal(node->left, nums); // 左
    nums.push_back(node->val); // 中
    if (node->right) traversal(node->right, nums); // 右
}
int getMinimumDifference(TreeNode* root) {
    vector<int> vec;
    if (!root) return 0;
    traversal(root, vec);
    // 求数组中的最小绝对值差
    int ans = INT_MAX;
    for (int i = 1; i < vec.size(); i++) {
        int temp = abs(vec[i] - vec[i - 1]); // -> temp = min(temp, abs(vec[i] - vec[i - 1]));
        if (temp < ans) ans = temp;
    }
    return ans;
}

二叉搜索树的双指针遍历

这里在遍历的时候可以定义两个指针 cur 和 pre，cur 指向当前节点，pre 指向前一个节点。

然后在遍历的时候，cur 和 pre 之间的差值就是当前节点和前一个节点之间的差值。

int ans = INT_MAX; // 定义全局变量 ans，初始值为 INT_MAX
void traversal (TreeNode* cur, TreeNode*& pre) { // 这里 pre 是引用类型
    if (!cur) return;
    if (cur->left) traversal(cur->left, pre);
    if (pre) { // 当pre为空的时候不会进行这一步
        ans = min(ans, cur->val - pre->val); // 计算差值
    }
    pre = cur; // 更新pre指针
    if (cur->right) traversal(cur->right, pre);
}
int getMinimumDifference(TreeNode* root) {
    if (!root) return 0;
    TreeNode *pre = nullptr;
    traversal(root, pre);
    return ans;
}

:::tip[为什么pre要使用引用类型]

cur 的作用 cur 是当前递归函数正在处理的节点。它是一个普通的指针，因为每次递归调用时，cur 都会被赋值为树中的下一个节点（左子节点或右子节点）。递归调用时，cur 的值会被复制到新的栈帧中，因此不需要使用引用。
pre 的作用 pre 是用来记录当前节点的前一个节点，以便计算两个节点值之间的差值。由于递归函数需要在不同的递归栈帧之间共享和更新 pre 的值，因此必须使用引用类型 TreeNode*&。

如果 pre 不使用引用类型，而是普通指针 TreeNode*，那么在递归调用中对 pre 的修改只会影响当前栈帧的局部变量，而不会影响外层递归栈帧中的 pre。这会导致 pre 无法正确地在整个递归过程中保持更新。

为什么 cur 不需要引用 cur 是递归函数的输入参数，每次递归调用时都会传入新的节点值。即使不使用引用，递归调用时 cur 的值也会正确传递到下一个栈帧中，因此不需要用引用 :::

二叉搜索树中的众数

501.二叉搜索树中的众数

这里直观的思路是使用一个哈希表来存储每个节点的值和出现的次数，然后遍历哈希表，找出出现次数最多的值。

首先递归遍历二叉树（何种遍历顺序都无所谓），统计每个节点的值出现的次数，存入 map 中。

之后遍历 map，找出出现次数最多的值。

这里就不多介绍这种一般的解法了。

下面使用和二叉树中的双指针遍历一样的思路，使用 pre 和 cur 来遍历二叉树。可以遍历两遍二叉树，一遍遍历找出最大值，另一遍遍历找出众数。

不过这里介绍的还是只遍历一次二叉树的写法。

int count = 0; // 定义全局变量 count，初始值为 0
int maxCount = 0; // 定义全局变量 maxCount，初始值为 0
vector<int> ans; // 定义全局变量 ans，存储众数
void traversal(TreeNode* cur, TreeNode*& pre) {
    if (!cur) return;
    if (cur->left) traversal(cur->left, pre); // 左

    if (!pre) count = 1; // 当遍历到第一个节点时，还没有pre此时count就直接等于1
    else if (cur->val == pre->val) count++; // 当前后节点的数值相等时，count加1
    else count = 1; // 否则，前后数值不相等了，重新让count等于1
    pre = cur; // 赋值pre指针

    if (count > maxCount) { // 当count的值大于maxCount时
        maxCount = count; // 更新maxCount
        ans.clear(); // 此时因为更新maxCount，结果集中的就不是出现最多的数了，因为要清空结果集
        ans.push_back(cur->val); // 将新的值放入结果集中
    } else if (count == maxCount) { // 否则当count和maxCount相等时
        ans.push_back(cur->val); // 加入结果集
    }

    if (cur->right) traversal(cur->right, pre); // 右
    return;
}
vector<int> findMode(TreeNode* root) {
    if (!root) return ans;
    TreeNode *pre = nullptr;
    traversal(root, pre);
    return ans;
}

:::tip[更新结果集] 频率 count 大于 maxCount 的时候，不仅要更新 maxCount，而且要清空结果集，因为结果集之前的元素都失效了。 :::

二叉树的最近公共祖先

236.二叉树的最近公共祖先

这里涉及到二叉树的一个自底向上处理的一个思路，当要向上处理的时候，可以使用后序遍历的方式来解决。

在查找公共祖先的时候有以下的几种情况：

如果找到一个节点，发现左子树出现结点 p，右子树出现节点 q，或者左子树出现结点 q，右子树出现节点 p，那么该节点就是节点 p 和 q 的最近公共祖先

节点本身 p(q)，它拥有一个子孙节点 q(p), 那么该节点就是节点 p 和 q 的最近公共祖先

判断的逻辑是：如果递归遍历遇到 q，就将 q 返回，遇到 p 就将 p 返回，那么如果左右子树的返回值都不为空，说明此时的中节点，一定是 q 和 p 的最近祖先。

其实情况一和情况二代码实现过程都是一样的，也可以说，实现情况一的逻辑，顺便包含了情况二。因为遇到 q 或者 p 就返回，这样也包含了 q 或者 p 本身就是公共祖先的情况。

完整的代码如下：

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 如果当前节点为空，说明递归到底了，返回空
        if (root == nullptr) {
            return nullptr;
        }

        // 如果当前节点就是 p 或 q，那么说明找到了其中一个
        // 直接返回这个节点（不再继续往下找）
        if (root == p || root == q) {
            return root;
        }

        // 在左子树中递归查找 p 和 q
        TreeNode* leftResult = lowestCommonAncestor(root->left, p, q);

        // 在右子树中递归查找 p 和 q
        TreeNode* rightResult = lowestCommonAncestor(root->right, p, q);

        // 情况一：如果左子树和右子树都不为空，说明 p 和 q 分别出现在两边
        // 此时当前 root 就是最近公共祖先
        if (leftResult != nullptr && rightResult != nullptr) {
            return root;
        }

        // 情况二：如果只有左子树不为空，说明 p 和 q 都在左边
        if (leftResult != nullptr) {
            return leftResult;
        }

        // 情况三：如果只有右子树不为空，说明 p 和 q 都在右边
        if (rightResult != nullptr) {
            return rightResult;
        }

        // 情况四：左右子树都没找到，返回空
        return nullptr;
    }

求最小公共祖先，需要从底向上遍历，那么二叉树，只能通过后序遍历（即：回溯）实现从底向上的遍历方式。
在回溯的过程中，必然要遍历整棵二叉树，即使已经找到结果了，依然要把其他节点遍历完，因为要使用递归函数的返回值（也就是代码中的 left 和 right）做逻辑判断。
要理解如果返回值 left 为空，right 不为空为什么要返回 right，为什么可以用返回 right 传给上一层结果。

总结

在确定单层递归逻辑的时候，要关注函数是否有返回值，是因为回溯的过程需要递归函数的返回值做判断，也可以从是否要遍历整棵树来做判断。

:::tip[二叉树-递归函数返回值] 是否需要返回值，取决于是否需要从子树返回“信息”给父节点来“做决策”。如果要“从子树拿信息回来” —— 要返回值；如果只是“走一遍树做操作” —— 不需要返回值。

问题类型	是否需要返回值	典型例子
查找、判断、返回某个节点	是	最近公共祖先、查找值、路径求和
纯遍历或修改树结构	否	遍历打印、翻转、修改值
:::

如果递归函数有返回值，如何区分要搜索一条边，还是搜索整个树呢？

是否遍历整个树，取决于是否需要从“多个子树中综合信息”，还是在**某一条路径上找到目标后立刻返回，不再继续搜索。

搜索一条边（路径）的写法：

if (递归函数(root->left)) return true;
if (递归函数(root->right)) return true;
return false;

搜索整个树写法：

auto left = 递归函数(root->left);    // 左子树递归
auto right = 递归函数(root->right);  // 右子树递归
// 根据 left 和 right 的返回值判断逻辑
return 结果;

Day17-二叉树 part05

Fri, 28 Mar 2025 00:00:00 GMT

最大二叉树

654.最大二叉树

这里我们可以参考使用前序+中序数组来构造二叉树的思路来写，首先根节点就是数组中的最大值，然后根据最大值的下标，我们可以区分左和右区间。

假设最大值下标是 maxIndex，那么左区间就是 [left, maxIndex)，右区间就是[maxIndex+1, right)。

然后在区间中分别递归调用，直到区间的左边界大于等于右边界。

TreeNode* traversal(vector<int>& nums, int left, int right) { // 传入数组的左边界和有边界
    if (left >= right) { // 如果左边界 >= 右边界， 那么就返回空节点
        return nullptr;
    }
    // 找到最大值和下标
    int maxIndex = left; // 初始化最大值的下标是数组区间的最左边的值的下标
    for (int i = left + 1; i < right; i++) { // 寻找最大值的下标，从左边界的下一个开始
        if (nums[i] > nums[maxIndex]) {
            maxIndex = i;
        }
    }
    // 前序遍历
    TreeNode* node = new TreeNode(nums[maxIndex]); // 定义新节点，最大值
    // 左区间 [left, maxindex)
    node->left = traversal(nums, left, maxIndex); // 左
    // 右区间 [maxIndex + 1, right)
    node->right = traversal(nums, maxIndex + 1, right); // 右

    return node;
}

TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
    if (nums.empty()) return nullptr;
    int left = 0, right = nums.size(); // 因为需要左开右闭区间，所以是[0, nums.size())
    return traversal(nums, left, right);
}

这里我觉得这种方式更好理解一些所以采用的这种写法，如果要完全按照之前的思路分成两个数组来做也是可以的，就是稍微麻烦一点。

合并二叉树

617.合并二叉树

递归实现

这题的思路其实不需要想的太复杂，遍历两棵树的逻辑其实和遍历一棵树是一样的，只不过需要传入两个树的根节点。

所以我们的递归函数需要输入的是两个树的根节点，返回合并后的根节点。

然后要确定递归函数的终止条件：

如果两个树都是空的，返回空节点
如果树1是空的，那么合并的只有树2，也就是可以返回树2的根节点
如果树2是空的，那么合并的只有树1，也就是可以返回树1的根节点

之后是确定单层的递归逻辑，当两个树都不为空时，我们就可以新建一个节点，值为两棵树的根节点之和。然后递归调用左子树和右子树的合并函数，分别传入两棵树的左子树和右子树。

整体代码如下：

TreeNode* mergeTrees(TreeNode* ro root1, TreeNode* root2) {
    if (ro root1 == nullptr && root2 == nullptr) { // 如果两个树都是空的，返回空
        return nullptr;
    }
    if (ro root1 == nullptr) { // 如果树1是空的，返回树2
        return root2;
    }
    if (root2 == nullptr) { // 如果树2是空的，返回树1
        return root1;
    }
    // 如果两个树都不为空，那么就合并
    TreeNode* node = new TreeNode(ro root1->val + root2->val); // 新建一个节点，值为两棵树的根节点之和
    node->left = mergeTrees(ro root1->left, root2->left); // 左子树合并
    node->right = mergeTrees(ro root1->right, root2->right); // 右子树合并

    return node; // 返回合并后的节点
}

其实这里的遍历顺序用三种之一都可以，不过用前序遍历更好理解。

迭代实现

对于同时操作两棵树，我们可以使用队列，将两棵树的节点同时加入队列进行比较，最后我们可以返回树1的根节点。

同样的，我们有以下条件：

如果两棵树左节点都不为空，加入队列
如果两棵树右节点都不为空，加入队列
root1的左节点为空 root2左节点不为空，就赋值过去
root1的右节点为空 root2右节点不为空，就赋值过去

最后我们只需要返回树1的根节点即可（因为修改的是root1）。

TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
    if  root1 == NULL) return root2;
    if (root2 == NULL) return root1;
    queue<TreeNode*> que;
    que.push root1);
    que.push(root2);
    while(!que.empty()) {
        TreeNode* node1 = que.front(); que.pop();
        TreeNode* node2 = que.front(); que.pop();
        // 此时两个节点一定不为空，val相加
        node1->val += node2->val;

        // 如果两棵树左节点都不为空，加入队列
        if (node1->left != NULL && node2->left != NULL) {
            que.push(node1->left);
            que.push(node2->left);
        }
        // 如果两棵树右节点都不为空，加入队列
        if (node1->right != NULL && node2->right != NULL) {
            que.push(node1->right);
            que.push(node2->right);
        }

        //  root1的左节点 为空 t2左节点不为空，就赋值过去
        if (node1->left == NULL && node2->left != NULL) {
            node1->left = node2->left;
        }
        //  root1的右节点 为空 t2右节点不为空，就赋值过去
        if (node1->right == NULL && node2->right != NULL) {
            node1->right = node2->right;
        }
    }
    return root1;
}

二叉搜索树中的搜索

700.二叉搜索树中的搜索

递归实现

因为二叉搜索树的性质是左子树的值小于根节点的值，右子树的值大于根节点的值，所以我们可以根据这个性质来进行搜索。

如果当前节点的值等于目标值，返回当前节点
如果当前节点的值大于目标值，搜索左子树
如果当前节点的值小于目标值，搜索右子树

根据这个逻辑我们可以有以下递归的写法：

TreeNode* searchBST(TreeNode* root, int val) {
    if (!root || root->val == val) return root; // 1. 如果当前节点为空或者当前节点的值等于目标值，返回当前节点
    // 2. 如果当前节点的值大于目标值，搜索左子树
    if (root->val > val) return searchBST(root->left, val);
    // 3. 如果当前节点的值小于目标值，搜索右子树
    if (root->val < val) return searchBST(root->right, val);
    // 都没有找到，返回空节点
    return nullptr;
}

迭代实现

迭代的写法相对就简单了，因为二叉搜索树的特殊性，也就是节点的有序性，可以不使用辅助栈或者队列就可以写出迭代法。并且对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。

从根节点开始，如果当前节点的值等于目标值，返回当前节点；如果当前节点的值大于目标值，搜索左子树；如果当前节点的值小于目标值，搜索右子树。

TreeNode* searchBST(TreeNode* root, int val) {
    TreeNode* node = root; // 定义一个节点，指向根节点
    while (node != nullptr) { // 如果节点不为空
        if (node->val == val) { // 如果节点的值等于目标值，返回该节点
            return node;
        } else if (node->val < val) { // 如果节点的值小于目标值，去右子树查找
            node = node->right;
        } else { // 如果节点的值大于目标值，去左子树查找
            node = node->left;
        }
    }
    return nullptr; // 如果没有找到，返回空
}

验证二叉搜索树

98.验证二叉搜索树

在二叉搜索树中，每个节点的值都大于其左子树的所有节点的值，并且小于其右子树的所有节点的值。

因此使用中序遍历的方式来遍历二叉搜索树，得到的结果应该是一个升序的数组。

所以我们可以使用这个特性，将中序遍历的结果存储在一个数组中，然后判断这个数组是否是升序的。

void inorder(TreeNode* root, vector<int>& nums) {
    if (root == nullptr) { // 如果节点为空，返回
        return;
    }
    inorder(root->left, nums); // 左子树
    nums.push_back(root->val); // 中序遍历，先左子树，再根节点，最后右子树
    inorder(root->right, nums); // 右子树
}
bool isValidBST(TreeNode* root) {
    vector<int> nums; // 定义一个数组，存储中序遍历的结果
    inorder(root, nums); // 中序遍历
    for (int i = 1; i < nums.size(); i++) { // 遍历数组
        if (nums[i] <= nums[i - 1]) { // 如果当前值小于等于前一个值，返回false
            return false;
        }
    }
    return true; // 如果没有返回false，说明是二叉搜索树，返回true
}

Day16-二叉树 part04

Thu, 27 Mar 2025 00:00:00 GMT

找树左下角的值

513.找树左下角的值

这里如果使用层序遍历那么就很轻松，只要记录最后一层的第一个节点的值即可。

int findBottomLeftValue(TreeNode* root) {
    if (!root) return 0;
    queue<TreeNode*> que;
    que.push(root);
    int ans;
    while (!que.empty()) {
        int size = que.size();
        vector<int> vec;
        while (size--) {
            TreeNode* node = que.front();
            que.pop();
            vec.push_back(node->val);
            if (node->left) que.push(node->left);
            if (node->right) que.push(node->right);
        }
        ans = vec[0];
    }
    return ans;
}

当然也可以使用递归遍历的方式，我们只要找到深度最大的叶子节点，然后要找左节点的话，我们只需要使用前序遍历（或者是中序，后序都行，因为左一直在右的前面）来保证优先搜索左边节点，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。

在递归过程中，每当深度大于当前最大深度时，我们就更新最大深度和最左边的值。所以可以定义两个全局变量。

int maxDepth = INT_MIN; // 记录最大深度
int ans = 0;

在找最大深度的时候，递归的过程中依然要使用回溯。

我们可以有以下递归代码：

int maxDepth = INT_MIN; // 全局变量记录最大深度
int result = 0; // 全局变量记录最左边的值
void traversal(TreeNode* node, int depth) { // 1. 传入根节点，和当前深度
    // 2. 递归终止条件，遇到叶子节点
    if (!node->left && !node->right) { // 找到叶子节点，比较当前深度是否大于最大深度
        if (depth > maxDepth) { // 如果当前深度大于最大深度，更新最大深度和结果
            maxDepth = depth;
            result = node->val;
        }
    }
    // 3. 单层递归逻辑
    if (node->left) { // 左
        depth++;
        traversal(node->left, depth); // -> traversal(node->left, depth + 1);
        depth--; // 回溯
    }
    if (node->right) { // 右
        depth++;
        traversal(node->right, depth); // -> traversal(node->right, depth + 1);
        depth--; // 回溯
    }
    return;
}

int findBottomLeftValue(TreeNode* root) {
    traversal(root, 0);
    return result;
}

要注意的是这里的遍历顺序其实只需要保证左节点在右节点前面就行，因为没有对中间节点的处理过程。

路径总和

112.路径总和

这里和上面一样因为没有中间节点的处理逻辑，所以用什么遍历顺序都可以。

关于递归函数什么时候需要返回值，可以根据需不需要处理递归返回值来进行判断。

如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。
如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。
如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。

这里进行统计的值，我们可以使用减法的方式来统计，当遍历到叶子节点是，如果当前总和为0，那么就是找到了一条符合条件的路径。

这样的做法要比使用加法更简洁，很多时候使用减法的做法会更简单。

整体的代码如下：

 bool dfs(TreeNode* node, int sum) { // 1. 返回值：是否找到一条符合条件的路径，参数：当前节点，当前总和
    if (!node->left && !node->right) { // 2. 递归终止条件，遇到叶子节点
        if (sum == 0) return true; // 如果当前总和为0，那么就是找到了一条符合条件的路径
        else return false; // 否则返回false
    }
    // 3. 单层递归逻辑
    if (node->left) { // 左
        sum -= node->left->val; // 先减去当前节点的值
        if (dfs(node->left, sum)) return true; // -> if(dfs(node->left, sum - node->left->val))
        sum += node->left->val; // 回溯， 加上当前节点的值
    }

    if (node->right) {
        sum -= node->right->val; // 先减去当前节点的值
        if (dfs(node->right, sum)) return true; // -> if(dfs(node->right, sum - node->right->val))
        sum += node->right->val; // 回溯， 加上当前节点的值
    }
    return false;
}
bool hasPathSum(TreeNode* root, int targetSum) {
    if (!root) return false;
    return dfs(root, targetSum - root->val); // 这里要提前减去root的值
}

要注意的是回溯问题，先减去当前节点的值，然后递归，递归完之后再加上当前节点的值。

从中序与后序遍历序列构造二叉树

106.从中序与后序遍历序列构造二叉树

在二叉树遍历顺序中：

中序遍历：左 -> 中 -> 右
后序遍历：左 -> 右 -> 中

所以在后序遍历中，最后一个节点一定是根节点，然后在中序遍历中，根节点的左边是左子树，右边是右子树。

因此可以根据这个规则，来切割中序数组，分成左右子树

然后再根据左右子树在后序遍历中的位置，来切割后序数组，分成左右子树

当后序数组为空时，就返回空节点。

所以大体的思路可以分为以下几步：

如果数组大小为零的话，说明是空节点了。
如果不为空，那么取后序数组最后一个元素作为节点元素。
找到后序数组最后一个元素在中序数组的位置，作为切割点
切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）
切割后序数组，切成后序左数组和后序右数组
递归处理左区间和右区间

那么难点就在于如何切分中序数组和后序数组。

在切割的过程中会产生四个区间，分别是中序左区间，中序右区间，后序左区间，后序右区间。

切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组。

中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割：

// 4. 切割中序数组
// 左子树区间 [0, delimiterIndex)
vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex); 
// 右子树区间 [delimiterIndex + 1, end)
vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());

对于后序数组，首先需要舍弃最后一个元素，因为最后一个元素是根节点已经被使用了，然后再找到切割点在中序数组。后序数组没有明确的切割元素来进行左右切割，不像中序数组有明确的切割点，切割点左右分开就可以了。

此时有一个很关键的点，就是中序数组大小一定是和后序数组的大小相同的，那么我们可以根据中序数组的大小来切割后序数组。

// postorder 舍弃末尾元素
postorder.resize(postorder.size() - 1);

// 5. 切割后序数组
// 依然左闭右开，注意这里使用了左中序数组大小作为切割点
// [0, leftInorder.size)
vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
// [leftInorder.size(), end)
vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

此时完整的代码如下：

TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
    // 1. 当后序数组为空，返回空节点 
    if (postorder.empty()) return nullptr; 
    // 2. 后序遍历数组最后一个元素，就是当前的中间节点
    int rootValue = postorder[postorder.size() - 1];
    TreeNode* root = new TreeNode(rootValue);

    // 当后序数组的大小为1时，也就是叶子节点，返回这个节点
    if (postorder.size() == 1) return root;

    // 3. 找到中序遍历的切割点
    int delimiterIndex;
    for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
        if (inorder[delimiterIndex] == rootValue) break;
    }
    // 4. 切割中序数组
    // 左子树区间 [0, delimiterIndex)
    vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex); 
    // 右子树区间 [delimiterIndex + 1, end)
    vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end()); 

    // postorder 舍弃末尾元素
    postorder.resize(postorder.size() - 1);

    // 5. 切割后序数组
    // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
    // [0, leftInorder.size)
    vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
    // [leftInorder.size(), end)
    vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

    // 6. 递归处理左区间和右区间
    root->left = traversal(leftInorder, leftPostorder);
    root->right = traversal(rightInorder, rightPostorder);

    return root;
}

TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
    if (inorder.size() == 0 || postorder.size() == 0) return NULL;
    return traversal(inorder, postorder);
}

对于105.从前序与中序遍历序列构造二叉树也是类似的思路，只是切割点在前序数组的第一个元素。因为前序遍历是中左右，所以前序数组的第一个元素就是根节点。

总结

关于递归函数的写法，什么时候需要返回值，传入的参数是什么，有些还是不太清楚，需要多练习。

像这种查找路径或者是涉及到一些需要深度来判断的问题，我们需要多留意回溯的问题，有递归就一定有回溯。

从中序数组和后序数组，或者是从前序数组和中序数组都可以构造二叉树，因为可以根据中间节点来区分左右子树。但是从前序数组和后序数组是无法构造二叉树的，因为前序和后序数组都没有明确的切割点来区分左右子树。

Day15-二叉树 part03

Wed, 26 Mar 2025 00:00:00 GMT

平衡二叉树

110.平衡二叉树

平衡二叉树的定义是：对于树中的每个节点，其左右子树的高度差的绝对值不超过1。

既然要求的是高度，那么可以使用后序遍历的方式，

明确递归函数的参数和返回值

参数：当前传入节点。返回值：以当前传入节点为根节点的树的高度。

如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。

所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。
明确终止条件

递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0
明确单层递归的逻辑

如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。

分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。

那么整体代码可以如下：

int checkHeight(TreeNode* root) {
    if (!root) return 0;
    int left = checkHeight(root->left); // 左
    if (left == -1) return -1; // 如果左子树已经不是平衡树了，直接返回-1

    int right = checkHeight(root->right); // 右
    if (right == -1) return -1; // 如果右子树已经不是平衡树了，直接返回-1

    if (abs(left - right) > 1) return -1; // 如果当前节点的左右子树高度差大于1，说明不是平衡树，直接返回-1
    return max(left, right) + 1; // 是平衡树的情况下返回当前节点为根节点的高度
}

bool isBalanced(TreeNode* root) {
    return checkHeight(root) != -1; // 只需要比较是否等于-1即可
}

二叉树的所有路径

257.二叉树的所有路径

这里要求的是从根节点到叶子节点的所有路径，所以很自然可以想到使用前序遍历。因为前序遍历是中左右，符合从根节点到叶子节点的路径。

并且在这里涉及到回溯，每当找完一条路径（也就是访问到叶子节点的时候），需要回退到上一个节点，继续遍历其他路径。

明确递归函数的参数和返回值

参数：当前传入节点，一个用来存储路径的 path，一个用来存储所有路径的结果 result。

void traversal(TreeNode* node, vector<int>& path, vector<string>& result)
// 中，因为最后一个节点也要加入到path中
path.push_back(node->val);

明确终止条件

递归的过程中遇到叶子节点的时候，那么需要把 path中存储的节点记录下来保存到 result中，然后返回。在这里可以不需要判断当前节点是否为空。

if (!node->left && !node->right) { // 终止条件：遇到叶子节点
        string sPath;
        for (int i = 0; i < path.size() - 1; i++) { // 遍历到倒数第二个
            sPath += to_string(path[i]);
            sPath += "->";
        }
        sPath += to_string(path[path.size() - 1]); // 最后一个节点不需要加->
        result.push_back(sPath);
        return;
    }

明确单层递归的逻辑

然后是递归和回溯的过程，上面说过没有判断是否为空，那么在这里递归的时候，如果为空就不进行下一层递归了。

需要注意的是回溯和递归是一一对应的，因此在每次递归之后，需要回溯到上一个节点。

所以递归前要加上判断语句，下面要递归的节点是否为空，整体如下
```
if (node->left) {
    traversal(node->left, path, result);
    path.pop_back(); // 回溯
}
if (node->right) {
    traversal(node->right, path, result);
    path.pop_back(); //回溯
}
```

最后的代码如下：

vector<string> binaryTreePaths(TreeNode* root) {
    vector<string> ans;
    vector<int> path;
    if (!root) return ans;
    traversal(root, path, ans);
    return ans;
}

左子叶之和

404.左叶子之和

这里提到的是求左子叶之和，我们可以使用后序遍历的方式，将左右子树的左子叶之和返回给上一层。

那么如何判断一个节点是左子叶呢？

:::tip 如果一个节点的左节点不为空，且该左节点的左右节点都为空，那么这个节点就是左子叶。 :::

明确递归函数的参数和返回值

参数：当前传入节点。返回值：当前节点的左子叶之和。
```
int traversal (TreeNode* node)
```
明确终止条件

如果遍历到空节点，那么左叶子值一定是0。当前遍历的节点是叶子节点，那其左叶子也必定是0。
```
if (!node) return 0;
if (!node->left && !node->right) return 0;
```

明确单层递归的逻辑

根据后序遍历，先往左递归，因为最后的结果一定会出现在往左递归的过程中，所以结果要在这一过程中保存

int left = traversal(node->left);
if (node->left && !node->left->left && !node->left->right) {
    left = node->left->val;
}
int right = traversal(node->right);

return left + right;

整体代码如下：

int traversal (TreeNode* node) {
    if (!node) return 0;
    if (!node->left && !node->right) return 0;

    int left = traversal(node->left); // 左
    if (node->left && !node->left->left && !node->left->right) {
        left = node->left->val; 
    }
    int right = traversal(node->right); // 右
    
    return left + right; // 中
}
int sumOfLeftLeaves(TreeNode* root) {
    return traversal(root);
}

完全二叉树的节点个数

222.完全二叉树的节点个数

这里可以简单地使用后序遍历的方式，分别求出左右子树的节点个数，然后加上根节点，就是整个完全二叉树的节点个数。

int traversal(TreeNode* node) {
    if (!node) return 0;

    int left = traversal(node->left); // 左
    int right = traversal(node->right); // 右

    int res = left + right + 1; // 中
    return res;
}
int countNodes(TreeNode* root) {
    if (!root) return 0;
    return traversal(root);
}

在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。

完全二叉树只有两种情况

情况一：就是满二叉树，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。
情况二：最后一层叶子节点没有满。分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

这里的关键在于如何去判断一个左子树或者右子树是不是满二叉树。

在完全二叉树中，如果递归向左遍历的深度等于递归向右遍历的深度，那说明就是满二叉树。如图所示：

在完全二叉树中，如果递归向左遍历的深度不等于递归向右遍历的深度，则说明不是满二叉树

判断其子树是不是满二叉树，如果是则利用公式计算这个子树（满二叉树）的节点数量，如果不是则继续递归，那么在递归三部曲中，第二部：终止条件的写法应该是这样的：

if (root == nullptr) return 0; 
// 开始根据左深度和右深度是否相同来判断该子树是不是满二叉树
TreeNode* left = root->left;
TreeNode* right = root->right;
int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
while (left) {  // 求左子树深度
    left = left->left;
    leftDepth++;
}
while (right) { // 求右子树深度
    right = right->right;
    rightDepth++;
}
if (leftDepth == rightDepth) {
    return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，返回满足满二叉树的子树节点数量
}

第三部，单层递归的逻辑：（可以看出使用后序遍历）

int leftTreeNum = countNodes(root->left);       // 左
int rightTreeNum = countNodes(root->right);     // 右
int result = leftTreeNum + rightTreeNum + 1;    // 中
return result;

最后的代码如下：

int countNodes(TreeNode* root) {
    if (root == nullptr) return 0;
    TreeNode* left = root->left;
    TreeNode* right = root->right;
    int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
    while (left) {  // 求左子树深度
        left = left->left;
        leftDepth++;
    }
    while (right) { // 求右子树深度
        right = right->right;
        rightDepth++;
    }
    if (leftDepth == rightDepth) {
        return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
    }
    return countNodes(root->left) + countNodes(root->right) + 1;
}

Day14-二叉树 part02

Tue, 25 Mar 2025 00:00:00 GMT

翻转二叉树

226.翻转二叉树

对于二叉树的翻转，其实用前序遍历和后序遍历都能实现，但是用中序遍历的话会使一些节点的左右子树翻转两次。

如果使用中序遍历的话：

      4                   4
    /   \  数次遍历后    /   \
   2     7    --->     7     2  --> 此时再遍历右子树会使以2位根节点的子树再次翻转
  / \   / \           / \   / \
 1   3 6   9         9   6 3   1

所以实现其实很简单，在遍历的时候只要交换左右子树然后递归遍历左右子树即可。

TreeNode* invertTree(TreeNode* root) {
    if (!root) return root;
    if (!root->left && !root->right) return root; // 递归终止条件，是叶子节点直接返回
    // swap(root->left, root->right);
    // 中
    TreeNode* node = root->right;
    root->right = root->left;
    root->left = node;

    if (root->left) invertTree(root->left); // 左
    if (root->right) invertTree(root->right); // 右
    return root;
}

也可以使用迭代的同意写法方式来实现

TreeNode* invertTree(TreeNode* root) { // 前序遍历
    stack<TreeNode*> stk;
    if (root) stk.push(root);
    while (!stk.empty()) {
        TreeNode* node = stk.top();
        if (node) {
            stk.pop();
            
            if (node->right) stk.push(node->right); // 右
            if (node->left) stk.push(node->left); // 左
            // 中
            stk.push(node);
            stk.push(nullptr);
        }
        else {
            stk.pop();
            node = stk.top();
            stk.pop();
            swap(node->left, node->right);
        }
    }
    return root;
}

对称二叉树

101.对称二叉树

要判断一个二叉树是否为对称二叉树，需要判断左右子树节点是否对称：

如果左子树节点和右子树节点都为空，那么说明左右对称，返回 true。
如果左右子树有其中一个为空，则说明不对称，返回 false。
如果左右子树节点都不为空，那么需要判断左右子树的值是否相等，且左子树的左节点和右子树的右节点对称，左子树的右节点和右子树的左节点对称。

递归写法

那么在递归函数中需要传入两个节点（t1, t2分别表示左右子树）来判断，根据上面的条件可以写出：

// 1. 左右子树节点都为空
if (!t1 && !t2) return true;
// 2. 左右子树有其中一个为空
if (!t1 || !t2) return false; // 如果上面条件满足那么就会直接返回 true 不会进行这个判断。
// 3. 左右子树节点都不为空
if (t1->val != t2->val) return false;

所以可以有以下的递归函数：

bool isMirro(TreeNode* t1, TreeNode* t2) {
    if (!t1 && !t2) return true;
    if (!t1 || !t2) return false;

    return ((t1->val == t2->val) 
            && isMirro(t1->left, t2->right) // 左子树的左节点和右子树的右节点对称
            && isMirro(t1->right, t2->left)); // 左子树的右节点和右子树的左节点对称
}

bool isSymmetric(TreeNode* root) { 
    if (!root) return false;
    return isMirro(root->left, root->right); // 传入左右子树节点
}

迭代写法

在这里我们可以使用队列来实现迭代的写法，队列中存放的是左右子树的节点，每次取出两个节点进行比较，然后将左子树的左节点和右子树的右节点入队，左子树的右节点和右子树的左节点入队。

使用队列的图示如下^1：

迭代写法的代码如下：

bool isSymmetric(TreeNode* root) { // 迭代写法
    if (!root) return true;
    queue<TreeNode*> que;
    que.push(root->left);
    que.push(root->right);

    while (!que.empty()) {
        TreeNode* t1 = que.front(); // 取出两个节点
        que.pop();
        TreeNode* t2 = que.front();
        que.pop();

        if (!t1 && !t2) continue; // 1. 左右子树节点都为空
        if (!t1 || !t2 || t1->val != t2->val) return false; // 2. 左右子树有其中一个为空或者值不相等

        que.push(t1->left); // 将左子树的左节点和右子树的右节点入队
        que.push(t2->right);
        que.push(t1->right);// 将左子树的右节点和右子树的左节点入队
        que.push(t2->left);
    }
    return true;
}

二叉树的最大深度

104.二叉树的最大深度

如果求的是二叉树的深度，那么可以用前序遍历，如果求的是二叉树的高度，那么可以用后序遍历。

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）

而二叉树的最大深度就是二叉树的高度。

所以这题可以很轻松的解决：

int maxDepth(TreeNode* root) {
        if (!root) return 0; // 如果是空节点，返回高度0

        int left = maxDepth(root->left); // 左，递归求左子树的高度
        int right = maxDepth(root->right); // 右，递归求右子树的高度
        return max(left, right) + 1; // 中，返回左右子树的最大高度加上根节点的高度
    }

当然还可以使用层序遍历来解决，遍历的层数就是二叉树的高度，也就是最大深度。

int maxDepth(TreeNode* root) {
    int depth = 0;
    if (!root) return depth;
    queue<TreeNode*> que;
    que.push(root);
    while (!que.empty()) { // 层序遍历
        depth++; // 每遍历一层，深度加1
        int size = que.size();
        while (size--) {
            TreeNode* node = que.front();
            que.pop();

            if (node->left) que.push(node->left);
            if (node->right) que.push(node->right);
        }
    }
    return depth;
}

二叉树的最小深度

111.二叉树的最小深度

这里和二叉树的最大深度不同的是，最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

如果一个节点是空节点，那么它的最小深度为0。
如果一个节点只有左子树，右子树为空，那么它的最小深度为左子树的最小深度+1。
如果一个节点只有右子树，左子树为空，那么它的最小深度为右子树的最小深度+1。

因此这里是与最大深度的本质区别，如果按照最大深度的写法，那么可能会返回空子树的深度。

同样是后序遍历：

int minDepth(TreeNode* root) {
    if (!root) return 0;

    int left = minDepth(root->left); // 左
    int right = minDepth(root->right); // 右

    if (!root->left && root->right) { // 如果左子树为空，右子树不为空
        return right + 1; // 返回右子树的最小深度+1
    }
    if (root->left && !root->right) { // 如果右子树为空，左子树不为空
        return left + 1; // 返回左子树的最小深度+1
    }

    return min(left, right) + 1; // 返回左右子树的最小深度+1
}

总结

二叉树的翻转，可以使用前序遍历和后序遍历，也可以使用迭代的方式实现。
对称二叉树，要同时判断左右子树的相应左右节点是否对称。
对于于求二叉树的高度，用前序最合适
对于求二叉树的深度，用后序最合适
对于二叉树的最小深度，需要注意左右子树为空的情况。

Day13-二叉树 part01

Mon, 24 Mar 2025 00:00:00 GMT

二叉树

二叉树是一种树形结构，它的每个节点最多有两个子节点，分别是左子节点和右子节点。

二叉树的存储方式一般是链式存储：

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

如果使用数组来存储二叉树，假设父节点的下标是 i，那么左子节点的下标是 2*i+1，右子节点的下标是 2*i+2。

二叉树的递归遍历

二叉树的遍历方式主要有两种：

深度优先搜索（DFS）：前序遍历、中序遍历、后序遍历（递归，迭代）
广度优先搜索（BFS）：层序遍历（跌代）

这里我们先看深度优先搜索的递归实现，也就是三种常见的遍历方式。这里遍历的顺序其实就是根节点的访问顺序。

关于递归的写法，我们可以确定三个要素^1：

确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
单层递归的逻辑：确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

前序遍历

二叉树的前序遍历

按照递归写法的思路：

确定递归函数的参数和返回值：这里要存储遍历的结果，所以要传入一个 vector<int> 来存储结果，返回值是 void。
确定终止条件：当节点为空时，直接返回。
单层递归的逻辑：先访问根节点，再递归访问左子树，再递归访问右子树。

void traversal(TreeNode* root, vector<int>& vec) { // 1. 确定递归函数的参数和返回值
    if (!root) return; // 2. 确定终止条件
    // 3. 单层递归的逻辑
    vec.push_back(root->val); // 中
    if (root->left) traversal(root->left, vec); // 左
    if (root->right) traversal(root->right, vec); // 右
}

确定好递归函数之后，遍历的函数就很好写了：

vector<int> preorderTraversal(TreeNode* root) {
    if (!root) return {};
    vector<int> ans;
    traversal(root, ans);
    return ans;
}

中序遍历

二叉树的中序遍历

依照之前的思路，我们只需要在前序遍历中的代码调整一下遍历顺序即可。

void traversal(TreeNode* root, vector<int>& vec) { // 1. 确定递归函数的参数和返回值
    if (!root) return; // 2. 确定终止条件
    // 3. 单层递归的逻辑
    if (root->left) traversal(root->left, vec); // 左
    vec.push_back(root->val); // 中
    if (root->right) traversal(root->right, vec); // 右
}

后序遍历

二叉树的后序遍历

写法同上，只需要调整遍历顺序即可。

void traversal(TreeNode* root, vector<int>& vec) { // 1. 确定递归函数的参数和返回值
    if (!root) return; // 2. 确定终止条件
    // 3. 单层递归的逻辑
    if (root->left) traversal(root->left, vec); // 左
    if (root->right) traversal(root->right, vec); // 右
    vec.push_back(root->val); // 中
}

二叉树的迭代遍历

在二叉树的迭代遍历中，我们需要借助栈来实现。递归的实现方式是隐式地使用了系统栈，而迭代的实现方式是显式地使用一个栈来模拟系统栈。

前序遍历

在前序遍历中，遍历的顺序是中左右，所以我们先将根节点入栈，然后处理根节点，再将右子节点入栈，再将左子节点入栈。

:::tip[前序遍历的入栈顺序] 先入栈右节点，再入栈左节点，这样在出栈的时候就是先左后右的顺序。 :::

vector<int> preorderTraversal(TreeNode* root) {
    // 迭代法
    stack<TreeNode*> stk;
    vector<int> ans;
    if (!root) return ans;
    stk.push(root); // 先入栈根节点
        
    while (!stk.empty()) {
        // 处理中节点
        TreeNode* node = stk.top(); 
        stk.pop();
        ans.push_back(node->val);

        if (node->right) stk.push(node->right); // 右
        if (node->left) stk.push(node->left); // 左
    }
    return ans;
}

后序遍历

先序遍历是中左右，后序遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了。

前序遍历->中左右
调整代码顺序->中右左
反转结果集->左右中

因此可以根据前序遍历的代码稍作调整即可。

vector<int> postorderTraversal(TreeNode* root) {
    // 迭代法
    stack<TreeNode*> stk;
    vector<int> ans;
    if (!root) return ans;
    stk.push(root); // 先入栈根节点
        
    while (!stk.empty()) {
        // 处理中间节点
        TreeNode* node = stk.top();
        stk.pop();
        ans.push_back(node->val);

        if (node->left) stk.push(node->left); // 左
        if (node->right) stk.push(node->right); // 右
    }
    reverse(ans.begin(), ans.end()); // 反转结果集
    return ans;
}

中序遍历

在这里需要注意的是，之前的前序和后序遍历的代码在中序遍历中不能通用，因为之前的代码的处理过程是：先访问中间节点，处理的也是中间节点，因为要访问的元素和要处理的元素都是同一个。

而中序遍历的顺序是左中右，我们需要一步一步访问到最左下的节点，然后再处理中间节点，这造成了访问的元素和处理的元素不是同一个。

那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

所以在中序遍历中，我们需要先将根节点入栈，然后一直往左走，直到走到最左下的节点，然后处理这个节点，再处理右子节点。

vector<int> inorderTraversal(TreeNode* root) {
    // 迭代法
    stack<TreeNode*> stk;
    vector<int> ans;
    TreeNode* node = root; // 指针遍历
    while (node || !stk.empty()) { // 当node不为空或者栈不为空时
        while (node) { // 一直往左走
            stk.push(node);
            node = node->left;
        }
        // 处理中间节点
        node = stk.top(); 
        stk.pop(); 
        ans.push_back(node->val);

        node = node->right; // 处理右子节点
    }
    return ans;
}

迭代遍历的统一写法

这里我们以中序遍历为例，来解决上述提到的访问元素和处理元素不一致的问题。

我们可以将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记，这样在处理的时候就可以知道这个节点是要处理的节点还是要访问的节点。

这里有两种标记的方式^2:

就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。这种方法可以叫做空指针标记法。
加一个 boolean 值跟随每个节点，false(默认值) 表示需要为该节点和它的左右儿子安排在栈中的位次，true 表示该节点的位次之前已经安排过了，可以收割节点了。这种方法可以叫做 boolean 标记法。

// 空指针标记法
vector<int> inorderTraversal(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> st;
    if (root != NULL) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        if (node != NULL) {
            st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
            if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

            st.push(node);                          // 添加中节点
            st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

            if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
        } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
            st.pop();           // 将空节点弹出
            node = st.top();    // 重新取出栈中元素
            st.pop();
            result.push_back(node->val); // 加入到结果集
        }
    }
    return result;
}

// boolean 标记法
vector<int> inorderTraversal(TreeNode* root) {
    // 迭代法
    stack<pair<TreeNode*, bool>> stk;
    vector<int> ans;
    if (!root) return ans;
    stk.push({root, false}); // 先入栈根节点
        
    while (!stk.empty()) {
        auto [node, flag] = stk.top(); // stk.top() 返回的是一个pair
        stk.pop();
        if (flag) ans.push_back(node->val); // 处理节点
        else { // 访问节点
            if (node->right) stk.push({node->right, false}); // 右
            stk.push({node, true}); // 标记
            if (node->left) stk.push({node->left, false}); // 左
        }
    }
    return ans;
}

二叉树的层序遍历

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和之前的都不太一样。

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

vector<vector<int>> levelOrder(TreeNode* root) {
    queue<TreeNode*> que;
    vector<vector<int>> ans;
    if (!root) return ans;
    que.push(root);
    while (!que.empty()) { // 当队列不为空时
        int size = que.size();  // 记录当前层的节点个数，que.size()是动态变化的
        vector<int> vec; // 存储当前层的节点值
        for (int i = 0; i < size; i++) {    // 遍历当前层的节点
            TreeNode* node = que.front(); // 取出队首元素
            que.pop();
            vec.push_back(node->val); // 存储当前层的节点值

            if (node->left) que.push(node->left); // 将左子节点入队
            if (node->right) que.push(node->right); // 将右子节点入队
        }
        ans.push_back(vec);
    }
    return ans;
}

总结

总的来说递归的写法看起来还是简单易懂，不过使用迭代的写法，就需要思考很多，希望自己能熟练掌握这种迭代写法的。

层序遍历的应用相当广泛，后序自己也会把随想录中提到的题目都做一遍。

Day11-栈与队列 part02

Sat, 22 Mar 2025 00:00:00 GMT

逆波兰表达式

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。

这里其实与二叉树的后序遍历（左右中）是差不多的。

在这里我们可以直接使用栈来解决，思路就是将数字入栈，然后遇到操作符，弹出两个数字进行运算，再将结果入栈。

图示如下^1：

int f (int a, int b, string op) {
    if (op == "+") return a + b;
    if (op == "-") return a - b;
    if (op == "*") return a * b;
    if (op == "/") return a / b;
    return 0;
}
int evalRPN(vector<string>& tokens) {
    stack<int> stk;
    for (int i = 0; i <= tokens.size() - 1; i++){
        // 当遇到操作符的时候
        if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
            // 注意栈的弹出顺序，先弹出b再弹出a
            int b = stk.top();
            stk.pop();
            int a = stk.top();
            stk.pop();
            stk.push(f(a, b, tokens[i]));
        }
        else {
            stk.push(stoi(tokens[i])); // 这里要注意将字符串转为整数
        }
    }
    int ans = stk.top();
    stk.pop();
    return ans;
    }

唯一要注意的就是弹出元素的顺序，先弹出的是第二个操作数，之后才是第一个。

滑动窗口最大值

239. 滑动窗口最大值

暴力求解

最直观的解法是使用 max_element() 直接返回每次滑动窗口的最大值，然而这种方法会超时，时间复杂度为 $O(nk)$，k 是窗口大小，遍历数组 n - k + 1 次，max_element() 遍历k次。

vector<int> maxSlidingWindow(vector<int>& nums, int k) { // 暴力求解超时
    vector<int> ans;
    for (int i = 0; i + k <= nums.size(); i++) {
        ans.push_back(*max_element(nums.begin() + i, nums.begin() + i + k));
    }
    return ans;
}

单调队列^2

这里我们可以使用单调队列来解决，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么。

我们需要的队列有以下操作：

class MyQueue {
public:
    void pop(int value) {
    }
    void push(int value) {
    }
    int front() {
        return que.front();
    }
};

在每次移动滑动窗口的时候，调用 pop() 和 push() 方法，然后 front() 方法返回队列的最大值。

这里有个思路是：没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。

以下图示展示了单调队列的过程：

设计单调队列的时候，pop，和 push 操作要保持如下规则：

pop(value)：如果窗口移除的元素 value 等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
push(value)：如果 push 的元素 value 大于入口元素的数值，那么就将队列入口的元素弹出，直到 push 元素的数值小于等于队列入口元素的数值为止

在保持以上规则的前提下，每次滑动窗口移动时，我们只需要调用 front() 方法就可以得到窗口的最大值。

下面是一个更清晰展示单调队列的过程：

那么使用哪种队列呢，答案是 deque，因为 deque 可以在队列的两端进行插入和删除操作。

那么根据以上规则，我们可以实现 MyQueue 类：

class MyQueue {
    public:
    deque<int> que;
    // 每次pop()之前，首先要判断队列是否为空，然后比较当前要弹出的数值时候等于队列的第一个元素，如果是则弹出
    void pop(int value) {
        if (!que.empty() && value == que.front()) {
            que.pop_front();
        }
    }
    // 如果push()的数值大于入口元素的数值，那么就将队列入口的元素弹出，直到push()元素的数值小于等于队列入口元素的数值为止
    // 这样可保持队列里的元素是单调的
    void push(int value) {
        while (!que.empty() && value > que.back()) {
            que.pop_back();
        }
        que.push_back(value);
    }

    int front() {
        return que.front();
    }
};

然后就是遍历数组，实现求解滑动窗口的最大值：

vector<int> maxSlidingWindow(vector<int>& nums, int k) { 
    MyQueue que;
    vector<int> ans;
    for (int i = 0; i < k; i++) { // 先把前k个元素push进队列
        que.push(nums[i]);
    }
    ans.push_back(que.front()); // 记录前k个元素的最大值 
    for (int i = k; i < nums.size(); i++) { 
        que.pop(nums[i - k]); // 滑动窗口移除最前面元素
        que.push(nums[i]); // 滑动窗口前加入最后面的元素
        ans.push_back(que.front()); // 记录对应的最大值
    }
    return ans;
}

前k个高频元素

347. 前K个高频元素

这里我们可以先用一个哈希表来统计每个元素出现的频率，然后再使用优先级队列来维护前 k 个高频元素。

优先级队列（priority_queue）底层通常基于堆实现，能在 O(log n) 的时间复杂度内插入或取出优先级最高的元素。默认情况下是大顶堆，即每次取出的都是值最大的元素。

vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> map;
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }
        // 优先队列，大顶堆
        priority_queue<pair<int, int>> pq;
        for (auto it = map.begin(); it != map.end(); it++) { // 遍历map，将map中的元素push进优先队列
            pq.push(make_pair(it->second, it->first)); // 优先队列中存储的是pair<int, int>，第一个元素是频率，第二个元素是元素值
        }
        vector<int> ans;
        for (int i = 0; i < k; i++) { // 取出前k个元素
            ans.push_back(pq.top().second);
            pq.pop();
        }
        return ans;
    }

要注意的是，优先队列默认是大顶堆，所以我们要将频率作为第一个元素，元素值作为第二个元素，这样就可以取出前 k 个高频元素。

总结

今天的这个单调队列还是有点难以理解，不过难的并不是 myQueue 类的实现，在下面的遍历逻辑里，饶了半天有点没绕明白。

最后要知道什么时候用优先级队列，什么时候用单调队列

优先级队列：求最大值或最小值
单调队列：求最大值或最小值，同时还要保持队列里的元素是单调的

Day10-栈与队列 part01

Fri, 21 Mar 2025 00:00:00 GMT

栈，队列

已经知道的是栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。

不过在C++中，栈和队列的实现都是一种容器适配器(Container Adapte)，而非容器。容器适配器是对已有容器（比如 deque 或 vector）的一种封装，用来提供不同的接口和使用方式。

:::tip[容器和容器适配器] 在 STL 中，容器分为两类：

标准容器（Standard Containers）

如：vector、deque、list、set、map、unordered_map 等。
这些容器拥有完整的接口，比如随机访问、插入、删除等。

容器适配器（Container Adapters）

如：stack、queue、priority_queue
它们是对标准容器的一种“限制使用接口的包装器”，让容器只能以特定的方式使用。
例如：
- stack 能后进先出（LIFO）
- queue 先进先出（FIFO）
- priority_queue 最大堆（默认） :::

容器适配器内部使用一个标准容器作为基础，比如 deque 或 vector，但不暴露全部接口，而是提供受限制的操作方式。在C++中，栈的默认底层实现是 deque。

#include <stack>

std::stack<int> stk1;                // 默认底层容器是 deque
std::stack<int, std::vector<int>> stk2; // 指定使用 vector 作为底层容器

// 无法对 stack 做 begin() 或 end()，因为这些操作在适配器中被屏蔽了

用栈实现队列

232.用栈实现队列

如果只使用一个栈，是无法做到模拟队列的先进先出的，但如果使用两个栈，一个用来入栈，一个用来出栈，就可以实现模拟队列的先进先出。

class MyQueue {
public:
    stack<int> stk_in;
    stack<int> stk_out;

    MyQueue() {
 
    }
    
    void push(int x) {
        stk_in.push(x); // 直接push进stk_in中
    }
    
    int pop() {
        if (stk_out.empty()) { 
            // 首先需要判断stk_out中是否有元素，如果没有则需要把stk_in中的元素全部放入stk_out中
            // 否则直接弹出stk_out栈顶元素
            while (!stk_in.empty()) { // stk_out入栈是一个持续的过程
                stk_out.push(stk_in.top());
                stk_in.pop();
            }
        }
        int result = stk_out.top();
        stk_out.pop();
        return result;
    }
    
    int peek() {
        int result = this->pop(); // 复用pop()方法，弹出栈顶元素
        stk_out.push(result); // 使用pop()方法将stk_out栈顶弹出，还要再push回去
        return result;
    }
    
    bool empty() {
        return stk_in.empty() && stk_out.empty();
    }
};

:::tip[关于 peek() 方法] 根据之前写python的经验，python中的 pop() 方法不仅会弹出栈顶元素，还会返回这个元素，而C++中的 pop() 方法只会弹出栈顶元素，不会返回这个元素。所以在 peek() 方法中，需要调用 pop() 方法，再将弹出的元素 push() 回去。 :::

用队列实现栈

225. 用队列实现栈

使用两个队列来实现栈

这里我们可以沿用上面的思路，用两个队列来模拟栈的实现（其实也是题中的要求使用两个队列）。

这里的主要思路是，用两个队列 q1 和 q2，q1 用来存储栈中的元素，q2 用来辅助操作。并且很重要的一点是，要保证 q1.fornt() 一定是栈顶元素。

class MyStack { // 使用两个队列来实现栈
public:
    queue<int> q1; // q1 主栈
    queue<int> q2; // q2 用来临时存放q1的元素

    MyStack() {

    }
    
    void push(int x) { // 始终保证q1.front()是栈顶元素
        q2.push(x);  // 将新元素放入q2中
        while (!q1.empty()) { // 如果q1不为空，将q1中的元素放入q2中，这样保证q2.fornt()是栈顶元素
            q2.push(q1.front());
            q1.pop();
        }
        // swap q1 和 q2，使得 q1 始终是主栈
        swap(q1, q2);
    }
    
    int pop() {
        int result = q1.front(); // 因为q1.front()是栈顶元素，所以直接pop()，下一个元素自动成为栈顶元素
        q1.pop();
        return result;
    }
    
    int top() {
        return q1.front(); // 同pop()
    }
    
    bool empty() { // 只需返回q1是否为空即可
        return q1.empty();
    }
};

这里我们只使用其中一个队列来维护栈顶元素，始终保持 q1 的前端是栈顶元素。

仅使用一个队列来实现栈

这里的思路其实和上面是一样的，我们只需要在 push() 的时候，把新元素插入队尾，然后把前面的所有元素都重新入队，这样新元素就变成队首了。

class MyStack { // 仅使用一个队列来实现栈
public:
    queue<int> q;

    MyStack() {}

    void push(int x) {
        q.push(x);
        int n = q.size(); // 这里一定要提前保存队列的大小，因为在循环中q的size是在不断改变的
        // 把前 n-1 个元素重新入队
        for (int i = 0; i < n - 1; ++i) {
            q.push(q.front());
            q.pop();
        }
    }
    // 剩余操作不变
    int pop() {
        int result = q.front();
        q.pop();
        return result;
    }

    int top() {
        return q.front();
    }

    bool empty() {
        return q.empty();
    }
};

与随想录中的实现不同的是，这里只需要在 push() 方法里实现入栈的逻辑就行了，维护队列的第一个元素始终是栈顶元素即可。

有效的括号

20. 有效的括号

括号匹配是一个使用栈来解决的经典问题，

我们可以模拟出当括号不匹配时的几种情况：

当字符串遍历完了，但是栈不为空，说明还存在有未匹配的括号，返回 false。
遍历字符串的过程中，发现栈里没有要匹配的字符，返回 false。
遍历字符串的过程中，栈已经空了，但是还有右括号，返回 false。

第一种方法使用的是直接入栈左括号的方式：

bool isPair(char a, char b) { // 定义一个判断括号是否匹配的函数
        return (a == '(' && b == ')' 
                || a == '[' && b == ']' 
                || a == '{' && b == '}');
    }

    bool isValid(string s) {
        stack<char> stk;
        int n = s.size() - 1;
        for (int i = 0; i <= n; i++) {
            if (s[i] == '(' || s[i] == '[' || s[i] == '{') {
                stk.push(s[i]);
                cout << stk.top();
            }
            else {
                if (stk.empty() || !isPair(stk.top(), s[i])) { // 如果是空栈或者不匹配，返回false
                    return false;
                }
                else { // 否则匹配，弹出栈顶元素
                    stk.pop();
                }
            }
        }
        return stk.empty();
    }

第二种方法使用的是直接入栈右括号的方式：

bool isValid(string s) { // 入栈右括号的方式
    stack<char> stk;
    int n = s.size() - 1;
    for (int i = 0; i <= n; i++ ) {
        if (s[i] == '(') stk.push(')');
        else if (s[i] == '[') stk.push(']');
        else if (s[i] == '{') stk.push('}');
        // 1. 匹配到右括号，但是stk已经是空的，说明没有左括号与其匹配
        // 2. 匹配到右括号，但是s[i] != stk.top() 说明没有右括号与其匹配
        else if (stk.empty() || s[i] != stk.top()) return false;
        else stk.pop();
    }
    return stk.empty();
}

所以在匹配左括号的时候，右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了，比左括号先入栈代码实现要简单的多了。

删除字符串中的所有相邻重复项

1047. 删除字符串中的所有相邻重复项

这题其实还算比较简单，不过因为随想录的验证码出了些问题，所以就自己写了写简单的思路。

string removeDuplicates(string s) {
    stack<char> stk;
    int n = s.size() - 1;
    for (int i = 0; i <= n; i++) {
        if (!stk.empty() && stk.top() == s[i]) {
            stk.pop();
        }
        else stk.push(s[i]);
    }
    string ans;
    // 将stk中的元素存入ans中，这里还是倒序
    while (!stk.empty()) {
        ans += stk.top();
        stk.pop();
    }
    // 反转ans
    reverse(ans.begin(), ans.end());
    return ans;
}

不难理解，只要栈不为空的时候，且栈顶元素和当前元素相等，就弹出栈顶元素，否则入栈。

不过这里也只是删除相邻的重复项并不是所有重复项，切勿想得太复杂。

总结

不太难，用队列实现栈中的这两个写法我觉得可以提一个PR，因为只要处理 push() 的逻辑就行了，看起来更清晰一点。

Day09-字符串 part02

Thu, 20 Mar 2025 00:00:00 GMT

反转字符串中的单词

151.反转字符串中的单词

用栈实现

其实一开始想到这题的时候，用栈道思路会比较清楚，用LIFO就很好理解，不过空间复杂度为 O(n)

string reverseWords(string s) {
    stack<string> st;
    string word, ans;

    //遍历字符串，按单词存入栈中
    for (int i = 0; i < s.size(); i++) {
        if (s[i] != ' ') { // 如果遇到的是字符，添加到word里
            word += s[i];
        }
        else if (!word.empty()) { //遇到空格且word为不为空，将word压入栈中
            st.push(word);
            word.clear();
        }
    }
    // 如果遍历完了，还有单词，即word不为空
    if (!word.empty()) st.push(word);
    // 从栈中弹出单词，形成结果
    while (!st.empty()) {
        ans += st.top();
        st.pop();
        if (!st.empty()) ans += " ";  // 仅在不是最后一个单词时添加空格
    }
    return ans;
}

时间复杂度：O(n)，n 为字符串的长度空间复杂度：O(n)，最坏情况下，栈中存储了 n 个字符

:::important

为什么要用 else if 而不是 if ：因为这里不是 default 的情况，当遇到空格时，还需要判断当前 word 是否为空
在遍历结束之后，还需要再判断一次 word 是否为空，如果不为空，将 word 压入栈中：这是因为在遍历结束之后，我们可能进行了将字符添加到word中，但是最后没有遇到空格，因此我们还剩最后一个word没有入栈，所以需要单独处理一次。
在出栈道过程中，如果栈为空，说明已经弹出了最后一个单词，不需要再添加空格。 :::

在原字符串上来实现

这题的关键问题其实在于如何去除多余的空格，要判断的情况很多，但又没有像 python 那样方便的库函数。因此我们需要自己实现一个去除多余空格的函数。

void removeExtraSpaces(string &s) {
    int n = s.size();
    int slow = 0, fast = 0;
    // 1. 去除字符串前面的空格
    while (fast < n && s[fast] == ' ') fast++;
    // 1.5 去除中间的空格
    while (fast < n) {
        // 2. 复制非空格字符，参考27.移除元素
        if (s[fast] != ' ') {
            s[slow++] = s[fast];
        }
        // 3.确保中间只有一个空格
        else if (slow > 0 && s[slow - 1] != ' ') { // 当slow的前一位不是空格，也就是字符的时候，才添加空格
            s[slow++] = ' ';
        }
        fast++;
    }
    // 4. 去除字符串末尾的空格
    if (slow > 0 && s[slow - 1] == ' ') slow--;
    // 5. 重新设置字符串大小
    s.resize(slow);
    cout<< s<<endl; 
}

在不使用库函数和辅助空间的前提下，我们可以使用两次反转来实现。

第一次将整个字符串反转
第二次将每个单词反转

因此我们整体的处理逻辑可以分以下几步：

去除多余空格
将整个字符串反转
将每个单词反转

反转过程的如下：

string reverseWords(string s) {
    removeExtraSpaces(s); // 去除多余空格
    reverse(s.begin(), s.end()); // 反转整个字符串

    int start = 0; // 定义一个start指向单词的起始位置
    for (int i = 0; i <= s.size(); i++){
        if ( i == s.size() || s[i] == ' ') { // 遇到字符串结束或者当前字符为空格
            reverse(s.begin() + start, s.begin() + i); // 反转区间[s.begin() + start, s.begin() + i]
            start = i + 1; // start 移动到下一位
        }
    }
    return s;
    }

：：：tip 复杂的其实是空格的处理逻辑。：：：

右旋字符串

这个其实用pyhton来做就非常简单了，伟大

return s[-k:] + s[:-k]

C++没有类似python的切片操作，不过根据反转字符串中单词的思路，我们也可以使用两次反转字符串来实现。

图示如下：

# include <iostream>
# include <string>
using namespace std;

void reverse(string& s, int begin, int end) {
    while (begin < end) {
        swap(s[begin], s[end]);
        begin++;
        end--;
    }
}

int main() {
    int k;
    cin >> k;

    string s;
    cin >> s;

    if (s.size() <= 1) {
        cout << s;
        return 0;
    }
    reverse(s, 0, s.size() - 1);
    reverse(s, 0, k - 1);
    reverse(s, k, s.size() - 1);

    cout << s << endl;
    return 0;
}

总结

双指针法在数组，字符串，链表中很常用，需要熟练掌握。

在反转数组中，还是要提高自己的逻辑理解能力，反转很容易，但是各种处理的逻辑却很复杂。

今天本来应该还有个KMP算法，但是内容有些多，KMP又比较复杂，今天这里先鸽一会。

Day08-字符串 part01

Wed, 19 Mar 2025 00:00:00 GMT

反转字符串

344.反转字符串

这题其实用双指针非常容易解决，但是用递归的话说实话还没有什么头绪。

双指针的解法：

void reverseString(vector<char>& s) {
    int left = 0;
    int right = s.size() - 1;
    while (left < right) { // 当left与right相等时，说明已经遍历完了
        swap(s[left], s[right]);
        left++;
        right--;
    }
}

关于递归写法，我们可以使用一个辅助函数 reverse(),这个函数接受两个参数，一个是字符串，一个是左右指针。

递归的终止条件是 left >= right，说明已经遍历完了，直接返回即可。

// 递归写法
void reverse(vector<char>& s, int left, int right) {
    if (left >= right) return; // 递归终止条件
    swap(s[left], s[right]); // 交换
    reverse(s, left + 1, right - 1); // 递归s[left + 1], s[right - 1]
}
void reverseString(vector<char>& s) {
    reverse(s, 0, s.size() - 1);
}

反转字符串II

541.反转字符串II

这里的重点其实是理解题意，用不用库函数都不是重点。

我们可以画个图来帮助理解

所以可以写出以下代码：

string reverseStr(string s, int k) {
    for (int i = 0; i < s.size(); i += 2 * k) { // i每次增加2k
        if (i + k <= s.size()) { // 如果剩余字符大于等于k个，但是小于2k个，则反转前k个字符
            reverse(s.begin() + i, s.begin() + i + k);
        } else { // 如果剩余字符小于k个，则反转所有字符
            reverse(s.begin() + i, s.end());
        }
    }
    return s;
}

:::tip[题外话] 其实这里的 if (i + k <= s.size()) 也可以不写等于，直接让 else 去判断，虽然意思都是一样的：当剩余字符正好等于 k 个，反转剩余所有字符的逻辑其实是一样的。只是这种写法没有按照题意而已，依照题意还是写 <= 比较好。 :::

替换数字

这题最直接的思路就是遍历字符串，如果是数字就替换，不是就跳过。

# include <iostream>
# include <vector>
using namespace std;

int main() {
    string s, ans;
    cin >> s;
    for (char c : s) {
        if (c >= 'a' && c <= 'z')
        ans += c;
        else {
            ans += "number";
            continue;
        }
    }
    cout << ans;
    return 0;
}

其实这里也可以不使用额外空间，直接在原字符串上进行操作，但是要先将原字符串扩容。

例如字符串 a5b 的长度为3，那么将数字字符变成字符串 number 之后的字符串为 anumberb 长度为 8。

然后从后向前替换数字字符，也就是双指针法，过程如下：i 指向新长度的末尾，j 指向旧长度的末尾[^1]。 [^1]: 代码随想录-替换数字

从后向前填充，避免每次添加元素都要将添加元素之后的所有元素整体向后移动。

# include <iostream>
# include <vector>
using namespace std;

int main() {
    string s;
    cin >> s;
    int count = 0;
    for (char c : s) {
        if (c >= '0' && c <= '9') count++;

    }
    int left = s.size() - 1;
    s.resize(s.size() + count * 5); // 扩容数组
    int right = s.size() - 1;
    
    while (left >= 0) { // 从后向前遍历
        if (s[left] >= '0' && s[left] <= '9') { // 遇到数字从向前填充"number"
            s[right--] = 'r';
            s[right--] = 'e';
            s[right--] = 'b';
            s[right--] = 'm';
            s[right--] = 'u';
            s[right--] = 'n';
        }
        else {
            s[right--] = s[left]; // 遇到字母直接填充
        }
        left--;
    }
    cout << s;
    return 0;
}

总结

今天的任务总的来说比较简单，没有太大难度，不过这个填充数字的在原字符串上操作的思路确实还是要多思考一会，多看几遍图解其实就也还好。

这两天估计要特别忙了，训练营说不好可能要鸽几天。

Day07-哈希表 part02

Tue, 18 Mar 2025 00:00:00 GMT

四数相加

454.四数相加II

这题的思考方式其实和之前写过的有效的字母异位词

四数相加和四数之和是有区别的，四数之和是在同一个数组中要求四个数的和等于目标值。

其实一开是也想到了将数组两两分组，然后用哈希表来解决，但是想了想好像这个时间复杂度都已经O(n^2)了，总不至此吧。

事实上，这个解法是正确的，后续也查阅过貌似无法再优化时间复杂度到O(n^2)以下。

整体思路与之前的题目类似：

int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
    // 哈希表，两两数组分别处理
    unordered_map<int, int> map;
    int count = 0;
    // 将a+b映射到map中
    for (int a : nums1) {
        for (int b : nums2) {
            map[a+b]++;
        }
    }
    // 在map中查找0 - (c + d)
    for (int c : nums3) {
        for (int d : nums4) {
            int target = - (c + d);
            if (map.find(target) != map.end()) {
                count += map[target]; // 这里注意count是要加上所有符合条件的元组
            }
        }
    }
    return count;
}

这里需要注意的是，要求的是所有符合条件的元组，所以在进行哈希表查询的时候，count 要加上所有符合条件的元组，也就是 map[target] 的值。

赎金信

383.赎金信

这道题的思路其实和前面的差不多，都是通过建立哈希表，然后从另一个字符串中查找是否存在。

用map的实现（无论是将magazine还是ransomNote做成哈希表都可以实现）：

// 将magazine做成哈希表
bool canConstruct(string ransomNote, string magazine) {
    unordered_map<char, int> map;
    for (char c : magazine) {
        map[c]++;
    }
    for (char c : ransomNote) {
        if (map.find(c) != map.end()) { // 如果在哈希表中找到了ransomNote中的字符
            if (map[c] <= 0) return false; // 如果哈希表中的值小于等于0，说明ransomNote中不存在这个字符
            else map[c]--; // 否则哈希表中的值减1，也就是找到了
        }
        else return false; // 如果在哈希表中没有找到ransomNote中的字符，直接返回false
    }
    return true;
}

// 如果将ransomNote做成哈希表
bool canConstruct(string ransomNote, string magazine) {
    unordered_map<char, int> map;
    for (char c :  ransomNote) { // 将ransomNote做成哈希表
        map[c]++;
    }
    for (char c : magazine) { // 在magazine中查找
        if (map.find(c) != map.end()) { // 如果在哈希表中找到了magazine中的字符
            if (map[c] <= 0) continue; // 如果哈希表中的值小于等于0，则说明magazine中已经满足了ransomNote中的字符，直接跳过
            else map[c]--; // 否则哈希表中的值减1
        }
    }
    //检查map中键的值是否都为0
    for (auto& pair : map) {
        if (pair.second != 0)return false;
    }
    return true;
}

在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的，数据量大的话就能体现出来差别了：

// 用数组来实现
bool canConstruct(string ransomNote, string magazine) {
    int count[26] = {0};

    for (char c : magazine) {
        count[c - 'a']++;
    }

    for (char c : ransomNote) {
        count[c - 'a']--;
        if (count[c - 'a'] < 0) return false;
    }
    return true;
}

三数之和

15.三数之和

其实这道题用哈希表来解决是不太合适的，因为涉及到复杂的去重操作，而且时间复杂度也不会比排序+双指针更优。

这里我们可以使用双指针的解法：

我们首先将数组进行排序，同时定义 left 和 right 指针，然后遍历数组，对于每一个元素，我们都将其作为第一个元素，然后在剩下的元素中使用双指针来寻找另外两个元素。

依然还是在数组中找到 abc 使得 a + b +c = 0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动 left 和 right，如果 nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以 right 下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到 left 与 right 相遇为止。

总体代码如下：

vector<vector<int>> threeSum(vector<int>& nums) {
    sort(nums.begin(), nums.end()); // 对数组排序
    vector<vector<int>> ans;
    if (nums[0] > 0 || nums[nums.size() - 1] < 0) return {};
    for (int i = 0; i < nums.size() - 1; i++) {
        if (i >0 && nums[i] == nums[i - 1]) continue; // 对i进行去重操作，注意i是与上一次比较
        int left = i + 1;
        int right = nums.size() - 1;

        while (left < right) {
            if (nums[i] + nums[left] + nums[right] > 0) right--;
            else if (nums[i] + nums[left] + nums[right] < 0) left ++;
            else {
                ans.push_back({nums[i], nums[left], nums[right]}); // 保存结果集
                while (left < right && nums[left] == nums[left + 1]) left++; // 对left去重
                while (left < right && nums[right] == nums[right - 1]) right--; // 对right去重
                // 去重结束后，再移动一位
                left++; 
                right--;
            }
        }
    }
    return ans;
}

时间复杂度：O(n^2)

i 遍历一次数组，时间复杂度为O(n)。
left 和 right 使用双指针，时间复杂度为O(n)。

对于去重的思考：

对于 a 的去重，要判断 nums[i] == nums[i - 1]，因为 i 是与上一次比较的。
对于 b 的去重，要判断 nums[left] == nums[left + 1]，因为 left 是与上一次比较的。
对于 c 的去重，要判断 nums[right] == nums[right - 1]，因为 right 是与上一次比较的。
最后因为去重是持续进行的，所以要使用 while 循环，直到不重复为止。

四数之和

18.四数之和

做了三数之和之后，其实四数之后就很好理解了，无疑是在外面再套一层循环。

主要的问题还是在剪枝和去重的操作上。

这里剪枝操作不同于三数之和的地方在于，数据中可能存在负数，所以之前的条件不能照搬。如果要进行剪枝，我们要使用:

 if (nums[a] > target && nums[a] > 0) break;

有了三数之和的基础上，很容易写出以下代码，不过这里的与随想录的代码不同的是，我使用的是从两侧靠拢的思路：

vector<vector<int>> fourSum(vector<int>& nums, int target) {
    sort(nums.begin(), nums.end());
    vector<vector<int>> ans = {};
    // 这里不能像三数之和那样做剪枝操作，因为可能存在负数
    // if (nums[0] > target || nums[nums.size() - 1] < target) return {};
    for (int a = 0; a < nums.size(); a++) {
        if (a > 0 && nums[a] == nums[a - 1]) continue; // 对a进行去重
        for (int d = nums.size() - 1; d > a + 2; d--) {
            if (d < nums.size() - 1 && nums[d] == nums[d + 1]) continue; // 对d进行去重
            int b = a + 1;
            int c = d - 1;
            while (b < c) {
                // sum = nums[a] + nums[b] + nums[c] + nums[d];
                // 这里应该使sum的类型为long long，int类型可能会溢出
                long long sum = (long long)nums[a] + nums[b] + nums[c] + nums[d];
                if (sum > target) c--;
                else if (sum < target) b++;
                else {
                    ans.push_back({nums[a], nums[b], nums[c], nums[d]});
                    while (b < c && nums[b] == nums[b + 1]) b++; // 对b进行去重
                    while (b < c && nums[c] == nums[c - 1]) c--; // 对c进行去重
                    // 去重结束后，再移动一位
                    b++;
                    c--;
                }   
            }
        }
    }
    return ans;
}

这里要注意的是题中给出的条件是 -10^9 <= nums[i] <= 10^9，-109 <= target <= 109，在计算的时候如果sum的类型是 int，那么可能会导致结果溢出，保险起见将 sum 设置为 long long 类型（在提交代码的时候不通过也是因为这个原因）。

时间复杂度为O(n^3)

a 遍历一次数组，时间复杂度为O(n)。
d 遍历一次数组，时间复杂度为O(n)。
b 和 c 使用双指针，时间复杂度为O(n)。

总结

这里的两道题其实都没有使用哈希表，而是使用了排序+双指针的方法。

时间复杂度高的算法，就不需要再感到意外了，不能因为是个O(n^2)的算法就默认不是最优解。

会了三数之和，四数之和感觉通透了，没看视频也能自己写出来了~~除了sum的类型溢出问题整了好久。~~

Day06-哈希表 part01

Mon, 17 Mar 2025 00:00:00 GMT

哈希表

哈希表的概念

哈希表（Hash Table），也叫做散列表，是一种键值对（key-value）存储的数据结构，能够在平均O(1)的时间复杂度下进行查找，插入和删除的操作，广泛运用于数据库，缓存系统，计数统计等场景。

哈希表的核心思想是利用哈希函数（Hash Function）将键（Key）映射到数组的某个位置（索引），从而快速存取数据。

哈希表的基本组成

键（Key）：用于唯一标识数据的值，如 "apple"、123、user_id。
值（Value）：键对应的存储数据，如 "fruit"、"张三"、56.7。
哈希函数（Hash Function）：将键转换为数组索引的函数。
哈希桶（Bucket）：用于存储键值对的数据单元。
冲突解决机制：当不同的键被映射到相同的位置时，如何处理（如链地址法、开放寻址法等）。

哈希函数

哈希函数[^1]用于将任意的键值映射到一个固定的索引值，一个好的哈希函数应该具有：

均匀性（Uniformity）：不同的键应该尽可能均匀地分布到哈希表中。
确定性（Deterministic）：相同的输入必须产生相同的输出。
高效性（Efficiency）：计算哈希值的时间开销要尽可能小。

[^1]: Hash function - Wikipedia

哈希碰撞

哈希碰撞（Hash Collision）是指两个不同的键映射到相同的索引，常见的解决哈希碰撞的方法有：

开放寻址法：当发生冲突时，寻找下一个空闲位置存储数据，如果还是冲突，继续寻找下一个空闲位置。当然，开放寻址法也有多种实现方式，如线性探测、二次探测、双重散列等，图中是线性探测的示例。

:::tip 开放寻址法的优点是不需要额外的链表存储，缺点是当负载因子较大时，查找性能会下降。 :::

链地址法：也叫拉链法，每个哈希桶存储一个链表（或其他数据结构），当多个键映射到相同索引时，放入链表中。

:::tip 链地址法的有点是实现简单，易于扩展，缺点是当链表过长时，查找性能会下降（退化为 O(n)）。 :::

常见的哈希结构^2

在哈希表中，常用的数据结构有：

数组
set（集合）
map（映射）

在 C++ 标准模板库（STL）中，set 和 map 是两种常用的关联容器，用于存储具有特定规则的数据。它们的底层实现通常采用红黑树，这是一种自平衡的二叉搜索树，确保了元素的有序性和操作的高效性。

在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
`std::set`	红黑树	有序	否	否	O(log n)	O(log n)
`std::multiset`	红黑树	有序	是	否	O(logn)	O(logn)
`std::unordered_set`	哈希表	无序	否	否	O(1)	O(1)

std::unordered_set 底层实现为哈希表，std::set 和 std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以 key 值是有序的，但 key 不可以修改，改动 key 值会导致整棵树的错乱，所以只能删除和增加。

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
`std::map`	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
`std::multimap`	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
`std::unordered_map`	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

std::unordered_map 底层实现为哈希表，std::map 和 std::multimap 的底层实现是红黑树。同理，std::map 和 std::multimap 的 key 也是有序的。

当我们要使用集合来解决哈希问题的时候，优先使用 unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用 set，如果要求不仅有序还要有重复数据的话，那么就用 multiset。

那么再来看一下 map ，在 map 是一个 key value 的数据结构，map 中，对 key 是有限制，对 value 没有限制的，因为 key 的存储方式使用红黑树实现的。

其他语言例如：java里的 HashMap ，TreeMap 都是一样的原理。可以灵活贯通。

虽然 std::set 和 std::multiset 的底层实现基于红黑树而非哈希表，它们通过红黑树来索引和存储数据。不过给我们的使用方式，还是哈希法的使用方式，即依靠键 key 来访问值 value。所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法。std::map 也是一样的道理。

有效的字母异位词

242.有效的字母异位词

数组实现

这里要注意的是，题中给出的是小写字母，所以这个数据是比较小的，我们可以使用数组来实现哈希表。

bool isAnagram(string s, string t) {
    // 用数组来实现哈希表
    int hash[26] = {0};
    // 遍历s
    for (char c : s) { 
        hash[c - 'a']++; 
    }
    // 遍历t
    for (char c : t) {
        hash[c - 'a']--;
    }
    // 检查数组是否全部为0
    for (int i = 0; i < 26; i++) {
        if (hash[i] != 0) return false;
    }
    return true;
}

这里其实掌握了 hash[c - 'a'] 这个概念，就很好理解了，c - 'a' 代表的就是当前字符在数组中的位置，然后做递增操作就能得到这个字符出现的次数。

然后通过相同的操作再对另一个字符串做递减操作，最后检查数组是否全部为0，如果不为0，说明两个字符串不是字母异位词。

顺便附上随想录中的图解^3，这样更好理解。

map实现

bool isAnagram(string s, string t) {
    // 用map实现
    unordered_map<char, int> count;

    for (char c : s) count[c]++;
    for (char c : t) {
        count[c]--;
        if (count[c] < 0) return false;
    }

    // 检查map元素
    for (const auto& pair : count) { // 自动推导pair类型
        if (pair.second != 0) return false; // second指的是定义的count类型的第二个元素
    }
    return true;
}

整体思路其实是一致的，只是这个题目的数据量小，适合用数组。

最后这里并不适用 set，因为 set 是用来存储不重复的元素的，而这里是要统计每个元素的个数。

两个数组的交集

349.两个数组的交集

:::tip[什么时候用set什么时候用数组？] 当一个问题中的数据量比较小，且数据量有限时，我们可以使用数组来实现哈希表。而当数据量比较大时，或者是数据量很分散的时候我们可以使用 set 来实现哈希表。例如 [1, 2, 10000],这个数据很分散，如果用数组来实现哈希表，会浪费很多空间(需要开辟一个长度10000的数组)。 :::

vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    // 用set实现哈希表
    unordered_set<int> set(nums1.begin(), nums1.end()); // 将nums1中的元素放入set中
    unordered_set<int> ans;

    for (int i : nums2) {
        if (set.find(i) != set.end()) { // 判断nums2中的元素在set中是否存在，否则返回set.end()
            ans.insert(i); // 将该元素插入到ans中
        }
    }
    return vector<int>(ans.begin(), ans.end()); // 将ans转换为vector返回
}

快乐数

202.快乐数

哈希表解法

这里可以这么思考，如果一个数不是快乐数，那么它不是快乐数的理由是什么？

在验证快乐数的过程中，某次计算的结果出现了重复，从而导致无限循环。

因此，我们只要记录每次计算的结果，如果这个结果重复了，那么之后的计算必然是陷入无限循环。所以我们的思路就是使用一个哈希表来记录每次计算的结果，如果结果重复，那么就返回 false。

那么我们就可以使用 unordered_set 来实现哈希表。

int getsum (int n) {
    int sum = 0;
    while (n) {
        sum += (n % 10) * (n % 10); // 计算每一位的平方和
        n = n / 10;
    }
    return sum;
}
bool isHappy(int n) {
    unordered_set<int> all_sum;
    int cur_sum = 0;
    while (true) {
        cur_sum = getsum(n); // 计算平方和
        if (cur_sum == 1) return true; // 如果平方和为1，返回true
        if (all_sum.find(cur_sum) != all_sum.end()) return false; // 如果平方和重复，返回false
        else all_sum.insert(cur_sum);
        n = cur_sum;
    }
}

时间复杂度: O(logn)
- getsum(n) 计算平方和的时间复杂度是 O(log n)（数字有 log n 位，每位计算 x^2）。
- 最坏情况下，n 可能进入一个循环，导致 seen.insert(n) 运行 O(log n) 次。
- 综合复杂度：O(logn)
空间复杂度: O(logn)

快慢指针解法

之前在链表中的环形链表中介绍过Flyod判圈算法，这里也可以使用快慢指针来解决这个问题。

快慢指针的方法如下：

快指针 fast 每次走两步，即 fast = getsum(getsum(fast))，每次运算两次 getsum()
慢指针 slow 每次走一步，即 slow = getsum(slow)

之后会出现两种情况：

如果 fast 和 slow 相遇，说明存在循环，返回 false
如果 fast 等于1，说明是快乐数，返回 true

我们假设 n = 19，那么计算过程如下：

n = 19 → 82 → 68 → 100 → 1  ✅（快乐数）

如果 n = 2，那么计算过程如下：

n = 2 → 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4 ❌（不是快乐数）
        ↑                                       ↑
        └───────────────────────────────────────┘
        存在循环，那么就会演变成fast追slow，最终相遇

双指针方法的代码如下：

int getsum (int n) {
    int sum = 0;
    while (n) {
        sum += (n % 10) * (n % 10); // 计算每一位的平方和
        n = n / 10;
    }
    return sum;
}
bool isHappy(int n) {
    int slow = n, fast = getsum(n);
    while (fast != 1 && slow != fast) { // 当fast等于1或者slow等于fast时，退出循环
        slow = getsum(slow);
        fast = getsum(getsum(fast));
    }
    return fast == 1;
}

两数之和

1.两数之和

当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

在这个题目中，我们可以使用哈希表来存储每个元素的索引，然后在遍历的过程中，查询 target - nums[i] 是否在哈希表中，如果在，那么就返回这两个元素的索引。

在这个情形中，我们不仅要保存元素的值，还需要保存元素的索引，所以我们可以使用 map。而我们不需要元素有序，所以我们可以使用 unordered_map 来实现哈希表。

:::tip[map中 key 和 value 分别表示什么] 判断元素是否出现，这个元素就要作为 key，所以数组中的元素作为 key，有 key 对应的就是 value，value 用来存下标。所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。 :::

vector<int> twoSum(vector<int>& nums, int target) {
    // key：target-nums[i]，value: 下标i
    unordered_map<int, int> map;
    vector<int> ans;
    for (int i = 0; i < nums.size(); i++) {
        if (map.find(target - nums[i]) != map.end()) { // 如果找到了
            int a = map[target - nums[i]]; // 也可以是map.find(target - nums[i])->second
            int b = i;
            ans.push_back(a);
            ans.push_back(b);
            return ans;
        }
        map.insert(pair<int, int>(nums[i], i));
    }
    return {};
}

本题其实有四个重点：

为什么会想到用哈希表：因为要查询元素是否出现过
哈希表为什么用map：因为不仅要存储元素，也要存储元素的下标
本题map是用来存什么的：存储的是 target - nums[i] 和 i 的对应关系，类比python中的{target - nums[i]：i}
map中的key和value用来存什么的：key存储的是 target - nums[i]，value存储的是 i

把这四点想清楚了，才算是理解透彻了。

总结

我们需要养成一个习惯，当遇到需要查询元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

然后清楚什么时候用数组，什么时候用集合，什么时候用映射。

当数据量比较小，且数据量有限时，我们可以使用数组来实现哈希表。
当数据量比较大时，或者是数据量很分散的时候我们可以使用 set 来实现哈希表。
当我们需要存储键值对的时候，我们可以使用 map 来实现哈希表。

Day04-链表 part02

Sat, 15 Mar 2025 00:00:00 GMT

两两交换链表中的节点

24. 两两交换链表中的节点

遍历链表

在这种类型的题中，通常可以使用虚拟头节点的方法来做。这样可以避免对头节点的特殊处理。

在遍历链表时，要注意遍历结束的条件：

当链表节点为奇数个时，此时 cur->next->next 为空
当链表节点为偶数个时，此时 cur->next 为空

在交换节点的过程中，画出图会更好地理解交换的进行过程。

为了更清晰的表达交换的过程，我们把要交换的两个节点分别记为 first 和 second，此时 cur 指向的应该是 first，交换的过程如下：

将 first->next 指向 second->next
将 second->next 指向 first
将 cur->next 指向 second
交换完成，将 cur 指向 first

ListNode* swapPairs(ListNode* head) {
    if (!head || !head->next) return head;

    ListNode *dummyhead = new ListNode(0, head);
    ListNode *cur = dummyhead; // 创建虚拟头节点，避免对头节点做特殊处理。

    while (cur->next && cur->next->next) {
        ListNode *first = cur->next; // 交换的第一个节点
        ListNode *second = cur->next->next; // 交换的第二个节点
        // 交换节点
        first->next = second->next; // 步骤1
        second->next = first; // 步骤2
        cur->next = second; // 步骤3
        cur = first;// 步骤4，将cur移到下一次要交换的节点前
    }
    ListNode *ans = dummyhead->next;
    delete dummyhead;
    return ans;
}

在不清楚的地方，把图画一下就很好理解了。

递归的实现

这里也可以使用递归的方法来来实现，这里我们递归交换后续节点，并将其连接到 head 的后面

ListNode* swapPairs(ListNode* head) {
    //递归终止条件
    if (!head || !head->next) return head;
    //单层递归逻辑
    ListNode *newhead = head->next; // // 交换后的新头节点
    ListNode *remaining = head->next->next; // 剩余未交换部分

    head->next = swapPairs(remaining); // 递归交换后续节点，并让head连接到交换后的新链表
    newhead->next = head; // 交换当前两个节点

    return newhead; // 返回新的头节点
}

该递归逻辑如下:

// 初始链表: 1 -> 2 -> 3 -> 4
swapPairs(1)

// 递归调用：
swapPairs(1)
    ├── swapPairs(3)
    │    ├── swapPairs(NULL) → 直接返回 3
    │    ├── 交换 3 和 4 → 返回 4 -> 3
    ├── 交换 1 和 2 → 返回 2 -> 1 -> 4 -> 3

删除链表的倒数第N个节点

19. 删除链表的倒数第 N 个结点

这一题其实还是有点印象的，那就是使用双指针的思路，不过还需要注意使用头节点。

:::tip[快慢指针的用法] 定义两个指针，先让 fast 提前走n步，然后再两个指针一起走，直到 fast->next 为空，那么此时 slow 一定指向要删除节点的上一个节点，也就是目标节点的前驱节点。 :::

先提前让fast往前走n步
直到 fast->next 为空，那么此时 slow 就是要删除节点的前驱节点。

假设链表为：
1 -> 2 -> 3 -> 4 

n = 1

整体代码如下：

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode *dummyhead = new ListNode(0, head); // 创建虚拟头节点
    ListNode *fast = dummyhead; //定义快慢指针
    ListNode *slow = dummyhead;

    while (n-- && fast) { //先让fast走n步
        fast = fast->next;
    }
    while (fast->next) { // 当fast的下一个节点为空时，slow找到要删除节点的前一个节点
        fast = fast->next;
        slow = slow->next;
    }
    // 基本操作
    ListNode *temp = slow->next;
    slow->next = slow->next->next;
    delete temp;
    ListNode *ans = dummyhead->next;
    delete dummyhead;
    return ans;
    }

这里要注意的问题就是对于要删除的节点，要操作的一定是该节点的前驱节点。

链表相交

160. 相交链表

哈希表方法

首先最直观的一个想法是使用哈希表

我们先遍历链表 A, 将 A 中的元素记录到哈希表中，然后再遍历链表 B，如果在哈希表中找到了相同的节点，那么这个节点就是相交的节点。

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    // 使用哈希表的方法
    // 时间复杂度：O(n+m)，其中 n 和 m 分别为两个链表的长度。
    // 空间复杂度：O(n)，其中 n 是链表 A 的长度。
    unordered_set<ListNode*> set;
    while (headA) {
        set.insert(headA);
        headA = headA->next;
    }
    while (headB) {
        if (set.find(headB) != set.end()) {
            return headB;
        }
        headB = headB->next;
    }
    return nullptr;
}

随想录中的解法

我们可以分别求出两个链表的长度，然后让较长的链表先走 lenA - lenB 步，然后两个链表一起走，直到找到相交的节点。

因为从短的链表开始出发，如果两个链表相交，那么就会存在一个相同的节点，使得两个链表同时到达。

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    // 随想录中的方法
    int lenA = 0, lenB = 0;
    ListNode *cur = headA;
    while (cur) { // A的长度
        cur = cur->next;
        lenA++;
    }
    cur = headB;
    while (cur) { // B的长度
        cur = cur->next;
        lenB++;
    }
    ListNode *longL;
    ListNode *shortL;
    if (lenA >= lenB) { // 依照长度定义长链表和短链表
        longL = headA;
        shortL = headB;
    }
    else {
        longL = headB;
        shortL = headA;
    }
    int gap = abs(lenA - lenB); 
    while (gap--) { // 长链表先走gap步
        longL = longL->next;
    }

    while(longL && shortL) {
        if (longL == shortL) return longL; // 注意是指针相等而不是值相等
        longL = longL->next;
        shortL = shortL->next;
    }
    return NULL;
}

这里需要注意的就是在判断相交的时候一定是判断指针相等而不是值相等。

双指针法

双指针的思路，使用两个指针 p1 和 p2 分别遍历两个链表：

p1 从 headA 开始，p2 从 headB 开始。
当 p1 走到 nullptr，则跳到 headB 继续走；
当 p2 走到 nullptr，则跳到 headA 继续走。
如果两个链表相交，最终 p1 和 p2 会在相交点相遇。
如果没有相交，最终 p1 == p2 == nullptr，返回 nullptr。

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    if (!headA || !headB) return nullptr; // 如果有空链表，则不可能相交
    ListNode *p1 = headA, *p2 = headB;
    while (p1 != p2) {  
        // p1 走完 A 就去 B，p2 走完 B 就去 A
        p1 = (p1 == nullptr) ? headB : p1->next;
        p2 = (p2 == nullptr) ? headA : p2->next;
    }
    return p1; // 如果相交，p1 == p2（相交点）；如果无交点，p1 == nullptr
}

对比哈希表方法，可以做到 O(1) 的空间复杂度，而哈希表的空间复杂度为 O(n)。

下面可以说明一下为什么这种方法可以找到相交的节点：

两个指针最终都会走 A + B 的步数
- 假设：headA 长度 n，headB 长度 m，相交点前分别是 a 和 b（相交部分长度 c）。
- p1 走 A → B，共走 a + c + b 步。
- p2 走 B → A，共走 b + c + a 步。
- 最终，两者都会在相交点相遇，或者都变成 nullptr（无交点）。
如果没有交点
- p1 和 p2 都会走 n + m 步，最终都等于 nullptr，所以返回 nullptr。

核心思路在于两个指针 p1 和 p2 走相同的距离，既然两个指针都走了相同的距离，那么他们最终一定会在相交的节点相遇。

环形链表II

142. 环形链表 II

对于这一题，与其说是算法题，其实多少还设计到一些数学知识。

解决这个问题，我们需要拆分成两个步骤。

如何确定有环

搜了一下，这个其实有个专有名词，叫Floyd 判圈法。

:::tip[Floyd 判圈法] Floyd 判圈法（Floyd’s Cycle Detection Algorithm）是一种使用快慢指针判断链表是否有环的算法，也叫龟兔赛跑算法（Tortoise and Hare Algorithm）。 :::

可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇，说明这个链表有环。

快指针 fast 每次走 2 步，慢指针 slow 每次走 1 步。
如果 fast 和 slow 相遇，则链表有环。
如果 fast 走到 nullptr，说明链表无环。

因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。

动画演示如下^1：

这里还有一个明确的地方：慢指针和快指针的相遇，一定是在第一圈内。

如何确定环的入口（Floyd 判圈法）

假设：

head → 环入口的距离为 a
环入口 → 相遇点的距离为 b
环的总长度为 c

当快慢指针相遇时：

慢指针走的路程：a + b
快指针走的路程：a + b + k * c（比 slow 多走 k 圈环）
由于 fast 每次走 2 步，slow 走 1 步，因此：

$$ 2(a + b) = a + b + k \cdot c $$

化简可以得到：

$$ a + b = k \cdot c $$

说明从 head 走 a 步，等价于从相遇点继续走 c - b 步到达环入口（也就是要求的 x 距离），也就是图中黄色区域的距离。

也就是说让 slow 从 head 出发，fast 从相遇点出发，每次走一步，最终相遇的点就是环的入口。

整体代码：

ListNode *detectCycle(ListNode *head) {
    if (!head) return nullptr;
    ListNode *fast = head; // 定义快慢指针
    ListNode *slow = head;

    while (fast && fast->next) { // 因为要访问fast->next->next所以这里也不能为空
        fast = fast->next->next; // fast一次走2
        slow = slow->next; // slow一次走1

        if (slow == fast) { // 当slow和fast相等的时候说明相遇了
            ListNode *index1 = slow; // 此时一个指针从slow/fast出发，另一个从head出发
            ListNode *index2 = head;

            while (index1 != index2) { // 当index1==index2时，说明找到了入口
                index1 = index1->next;
                index2 = index2->next;
            }
            return index1;
        }
    }
    return nullptr;
}

总结

今天的内容还算比较多，其实大部分的时间还是用来写文档了，全文也并没有照抄随想录，因为想着留给自己一些更深的印象。

虽然有些内容是问了问gpt贴了过来，大AI时代嘛，当然在背后也是有自己好好去理解这些内容的。我觉得不失为一种有效的学习方式。

Day03-链表 part01

Fri, 14 Mar 2025 00:00:00 GMT

链表基础

定义

链表（Linked List）是一种线性数据结构，由一系列的节点（Node）组成，每个节点包含数据和指向下一个节点的指针。相较于数组，链表的特点是动态存储、插入和删除操作更高效，但随机访问速度较慢。

链表的种类

链表可以分为以下几种类型^1：

单链表（Singly Linked List）：每个节点存储一个指向下一个节点的指针。
双向链表（Doubly Linked List）：每个节点存储前后两个指针（指向前驱和后继）。
循环链表（Circular Linked List）：链表的最后一个节点指向头节点，形成循环。
双向循环链表（Doubly Circular Linked List）：结合双向链表和循环链表的特性。

链表的基本操作

链表的核心操作包括：

插入（Insertion）
删除（Deletion）
查找（Search）
遍历（Traversal）

关于这部分的内容，会在后面的内容进行更详细的讲解。

链表与数组的对比

	插入/删除（时间复杂度）	查询（时间复杂度）	适用的场景
数组	`O(n)`	`O(1)`	数据量固定，频繁查询，较少的增删操作
链表	`O(1)`	`O(n)`	数据量不固定，频繁的增删操作，较少的查询

移除链表元素

203.移除链表元素

对于删除链表中的节点，一般的步骤是这样的：

:::important[删除过程中要注意的问题] 需要相当注意的是，在删除一个节点时，操作的对象一定是前一个节点，而不是当前节点。因为在删除才做中，一定需要使被删除节点的前一个节点的next指针指向被删除节点的下一个节点。 :::

ListNode* temp = cur->next;
cur->next = cur->next->next;
delete temp; // 在C++中，需要手动释放内存

在移除链表元素时，可以有几种方法：

直接在原链表上操作

这里需要注意的是，如果头节点是要删除的节点，那么需要特殊处理。

ListNode* removeElements(ListNode* head, int val) {
    while (head != nullptr && head->val == val) { // 这里要使用while而不是if，因为可能有多个连续的节点都是要删除的节点
        ListNode* temp = head;
        head = head->next;
        delete temp;
    }

    // 定义前驱节点
    ListNode* cur = head;
    while (cur != nullptr && cur->next != nullptr) { 
        if (cur->next->val == val) {
            ListNode* temp = cur->next;
            cur->next = cur->next->next;
            delete temp;
        }
        else {
            cur = cur->next;
        }
    }
    return head;
}

使用虚拟头节点

使用虚拟头节点可以简化代码逻辑，避免对头节点的特殊处理。

ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyhead = new ListNode(0, head); // 创建虚拟头节点
        ListNode* cur = dummyhead; // 定义前驱节点
        while (cur->next) { 
            if (cur->next->val == val) {
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }
            else cur = cur->next;
        }
        head = dummyhead->next;
        delete dummyhead;
        return head;
    }

递归

递归删除链表元素是利用递归函数的调用栈，逐层返回时执行删除操作，从而达到删除链表节点的目的。

ListNode* removeElements(ListNode* head, int val) {
    if (head == nullptr) { // 递归终止条件
        return head;
    }
    head->next = removeElements(head->next, val); // 递归调用
    return head->val == val ? head->next : head; // 如果当前节点的值等于 val，则删除当前节点
}

设计链表

707.设计链表

这里我们需要设计一个链表的数据结构，支持以下操作：

获取链表的第index个节点的值。
在链表的头部插入一个新节点。
在链表尾部插入一个新节点。
在链表中的第index个节点前添加一个新节点。
删除链表中的第index个节点。

class MyLinkedList {
public:

    struct ListNode { // 定义链表节点
        int val;
        ListNode* next;
        ListNode(int val): val(val), next(nullptr){} // 构造函数
    };
    
    MyLinkedList() {
        _size = 0; // 初始化链表长度
        _dummyhead = new ListNode(0); // 创建虚拟头节点
    }
    
    int get(int index) { // 获取第index个节点的值
        // 注意下标问题，这里的index是从0开始的，例如只有一个元素，那么它的index(0)=size-1
        if (index < 0 || index > (_size - 1)) return -1; // index是从0开始的，所以判断条件是size-1
        ListNode* cur = _dummyhead->next; 
        while (index--){
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) { // 在头部添加节点
        ListNode* new_node = new ListNode(val); // 创建新节点
        new_node->next = _dummyhead->next; // 新节点直接指向虚拟头节点的下一个节点
        _dummyhead->next = new_node; // 虚拟头节点指向新节点，新节点成为新的头节点
        _size++; // 链表长度+1
    }
    
    void addAtTail(int val) { // 在尾部添加节点
        ListNode* new_node = new ListNode(val); // 创建新节点
        ListNode* cur = _dummyhead; // 创建前驱节点，指向虚拟头节点
        while (cur->next != nullptr) { // 遍历到链表尾
            cur = cur->next;
        }
        cur->next = new_node; // 前驱节点指向新节点
        _size++; // 链表长度-1
    }
    
    void addAtIndex(int index, int val) { // 在第index个节点前添加节点
        if (index > _size || index < 0) {return;} // 若index不合法，如果index=size，则说明在末尾添加
        //如果index=0，则说明在头部添加
        ListNode* new_node = new ListNode(val); // 创建新节点
        ListNode* cur = _dummyhead; // 创建前驱节点，指向虚拟头节点
        while (index--) { // 遍历到index位置，例如index=0，即在头节点插入
            cur = cur->next;
        }
        new_node->next = cur->next; // 新节点指向前驱节点的下一节点
        cur->next = new_node; // 前驱节点指向新节点
        _size++; // 链表长度+1
    }
    
    void deleteAtIndex(int index) { // 删除第index个节点
        if (index >= _size || index < 0) {return;} //若index不合法
        //eg. 若size=1，index=1，那要删除的其实是第二个节点（不存在），所以不合法
        ListNode* cur = _dummyhead; // 创建前驱节点指向虚拟头节点
        while (index--) { // 遍历到index节点
            cur = cur->next;
        }   
        ListNode* temp = cur->next; // 将要删除的节点保存到临时节点
        cur->next = cur->next->next; // 前驱节点指向要删除节点的下一个节点
        delete temp; // 删除临时节点
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        temp=nullptr;
        _size--;       
    }

private:
    int _size; // 链表长度
    ListNode* _dummyhead; // 虚拟头节点
};

:::important[添加节点的顺序问题] 和删除链表中元素类似，在链表中添加节点的时候，一定要注意操作的顺序：

新节点指向前驱节点的下一个节点
前驱节点指向新节点 :::

反转链表

206.反转链表

反转链表是一个对考察基础数据结构操作能力很好的问题。

双指针解法

在这里可以定义一个前驱节点pre和一个当前节点cur：

然后让cur指向pre

当cur为空时，说明已经遍历完链表，此时pre指向的就是反转后的链表头节点。

用双指针的写法如下：

ListNode* reverseList(ListNode* head) {
        if (head == nullptr) return head; 
        ListNode* cur = head; // 定义cur指向头节点
        ListNode* pre = nullptr; //定义pre指向空节点
        ListNode* temp; // 定义临时节点用于存储cur的下一个节点
        while (cur) { // 当cur指向空时，说明遍历结束
            temp = cur->next; // 存储cur的下一个节点
            cur->next = pre; // 翻转操作
            pre = cur; // 将pre向前移
            cur = temp; //将cur向后移
        }
        return pre;
    }

在这里需要注意的就是操作的顺序，一定是先存储cur的下一个节点，然后再进行翻转操作，先将pre向前移，再将cur向后移。

递归解法

可以依据双指针的思路，写出递归的解法。和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。

// 递归写法
ListNode* reverse(ListNode* pre, ListNode* cur) {
    if (cur == nullptr) return pre; // 递归终止条件，终止之后，返回的是pre
    // 单层递归
    ListNode* temp = cur->next;
    cur->next = pre; // 翻转操作
    // 进入下一层递归
    // pre = cur;
    // cur = temp; 
    return reverse(cur, temp); // 按照双指针的解法来写
}

ListNode* reverseList(ListNode* head) {
    return reverse(nullptr, head); //按照双指针解法，pre指向空节点，cur指向头节点
}

对比双指针解法的过程，来写递归的思路会更清晰一些

总结

链表的操作自己理解起来还是比较清晰的，不过在写代码的过程中，还是不太熟练，还是要更多的时间来练习。最后，递归这个东西还是比较抽象的，希望后面能够在更多的题目中，更加熟练的掌握递归的写法。

Day02-数组 part02

Thu, 13 Mar 2025 00:00:00 GMT

滑动窗口-最小子数组

209.长度最小的子数组

首先解决这个问题最简单的方法就是暴力求解。

使用两个循环，外层循环遍历数组，内层循环计算以当前元素为起点的子数组和。然后比较子数组和是否大于等于目标值，如果是则更新最小长度。

int minSubArrayLen(int target, vector<int>& nums) {
        // 一般解法, 超时
        int ans = INT_MAX;
        int n = nums.size() - 1;
        for (int i = 0; i <=  n; i++) {
            int sum = 0;
            for (int j = i; j <= n; j++){
                sum += nums[j];
                if (sum >= target) {
                    ans = min(ans, (j-i+1));
                    break; //即使提前中断内循环，时间复杂度也是O(n^2)，结果上来说还是超时
                }
            }
        }
        return ans == INT_MAX ? 0 : ans;
    }

:::note[滑动窗口] 滑动窗口的思路是维护一个窗口，使得窗口内的元素和满足某种条件。 ::: 在这个问题中，实现滑动窗口需要考虑三个问题：

滑动窗口内是什么
- 窗口其实就是满足条件(subArraySum >= target)的一段区间。
如何移动滑动窗口的起始位置
- 如果当前窗口的值大于等于target了，窗口就要向前移动了（也就是该缩小了）。
如何移动滑动窗口的结束位置
- 窗口的结束位置就是遍历数组的指针，也就是循环里的end索引

而关键在于如何移动窗口的起始位置：

while (sum >= target) { 
    // 每次加入新元素后，检查 sum 是否大于等于目标值 s。如果是，则计算当前子数组的长度，
    //并与已记录的最小长度进行比较，取较小值。
    //然后，移动起始指针 i，并从 sum 中减去 nums[i]，以缩小窗口，直到 sum 小于 s
    //随后start向前移动一位
    subLength = end - start  + 1;
    ans = min(ans, subLength); 
    sum -= nums[start++]; 
}

滑动窗口的过程，其实类似向前蠕动的蛇，每次向前移动一格，然后检查是否满足条件，满足条件则记录当前窗口的长度，然后继续向前移动。

完整的代码如下：

int minSubArrayLen(int target, vector<int>& nums) {
        // 使用滑动窗口
        int sum = 0;
        int ans = INT_MAX;
        int start = 0, end = 0; //滑动窗口的起始和终止位置
        int subLength = 0; //滑动窗口的长度
        while (end < nums.size()) { // 移动结束指针，将nums[end]加入子数组
            sum += nums[end];
            while (sum >= target) { //注释如上
                subLength = end - start  + 1;
                ans = min(ans, subLength); 
                sum -= nums[start++]; 
            }
            end++; //使用的while的写法，最后要将end++
        }
        return ans == INT_MAX? 0 : ans;
    }

:::tip[时间复杂度] 在滑动窗口方法中，每个元素最多被访问两次（一次被右指针访问，另一次被左指针访问），因此时间复杂度为 O(n)。 :::

螺旋矩阵

54.螺旋矩阵

59.螺旋矩阵II

随想录里面讲到的题目是59.螺旋矩阵II，本质上是同一个类型，59只是将一般矩阵换成了方阵，都是了解循环的边界处理条件。

这里我将两题都做了，然后以54.螺旋矩阵为例，以及这种题的两种思路。

随想录中的思路

要模拟螺旋矩阵的遍历，就是从四个方向：

遍历上行从左到右
遍历右列从上到下
遍历下行从右到左
遍历左列从下到上

如图所示：

在这里，对于每一次遍历，都是最后一个元素不处理，留给下一次遍历处理，这也是坚持了每条边左闭右开的原则。

由于在螺旋遍历过程中，每次遍历都会缩小矩阵的范围。当行数和列数的差值为奇数时，最终可能会剩下一行或一列未被遍历，因此也许要对这集中情况进行处理。

在59.螺旋矩阵II中，只是将矩阵换成了方阵，因此最多只会出现剩余一个元素的情况。依照随想录给出的思路：

vector<int> spiralOrder(vector<vector<int>>& matrix) {
    int startx = 0, starty = 0;
    int m = matrix.size();
    int n = matrix[0].size();
    int loop = min(m, n) / 2;
    int offset = 1;
    int i, j;
    vector<int> ans;
    while (loop--) {
        i = startx;
        j = starty;
        for (j = starty; j < n - offset; j++) ans.push_back(matrix[i][j]); //记录当前循环上面的行          
        for (i = startx; i < m - offset; i++) ans.push_back(matrix[i][j]); //记录当前循环右边的列    
        for ( ; j > starty; j--) ans.push_back(matrix[i][j]); //记录当前循环下面的行 
        for( ; i > startx; i--) ans.push_back(matrix[i][j]); //记录当前循环左边的列
        startx++;
        starty++;
        offset++;
    }
        // 如果循环次数是奇数，那么需要把中间的元素加入结果
    if (min(m, n) % 2 == 1) {
        if (m < n) {
            // 中间剩余一行
            for (j = starty; j < n - starty; j++) {
                ans.push_back(matrix[startx][j]);
            }
        } else if (m > n) {
            // 中间剩余一列
            for (i = startx; i < m - startx; i++) {
                ans.push_back(matrix[i][starty]);
            }
        } else {
            // 中间剩余一个元素
            ans.push_back(matrix[startx][starty]);
        }
    }
    return ans;
}

逐层模拟

我们可以通过定义上下左右四个边界来模拟螺旋矩阵的遍历。确保了对所有情况的处理，包括奇数维度的矩阵。

初始化边界：定义 left、right、top、bottom 四个变量，分别表示当前层的左、右、上、下边界。
循环遍历：在 left <= right 且 top <= bottom 的条件下，进行以下操作：
- 从左到右遍历上边界：从 left 到 right，将元素添加到结果中。
- 从上到下遍历右边界：从 top + 1 到 bottom，将元素添加到结果中。
- 从右到左遍历下边界（需要确保当前层至少有两行两列）：从 right - 1 到 left，将元素添加到结果中。
- 从下到上遍历左边界（需要确保当前层至少有两行两列）：从 bottom - 1 到 top + 1，将元素添加到结果中。
缩小边界：在完成一层的遍历后，缩小边界范围，进入下一层的遍历。

实现如下：

vector<int> spiralOrder(vector<vector<int>>& matrix) {
    vector<int> ans;
    int m = matrix.size(), n = matrix[0].size();

    int left = 0, right = n - 1, top = 0, bottom = m - 1; // 定义上下左右边界，逐层遍历

    while (left <= right && top <= bottom) { //当对应边界还未交错时，进行处理
        // 列j: 从左边界处理到右边界，行此时为上边界top
        for (int j = left; j <= right; ++j) ans.push_back(matrix[top][j]);
        // 行i: 从上边界处理到下边界，列此时为右边界right
        // 因为上边界处理完，所以i=top+1
        for (int i = top + 1; i <= bottom; ++i) ans.push_back(matrix[i][right]);

        if (left < right && top < bottom) { // 当矩阵至少拥有两行两列时，处理逻辑与上右不一样
            // 列j：从右边界处理到左边界，行此时为下边界bottom
            //因为右边界处理完，所以j = right - 1，同时不访问左下角元素
            for (int j = right - 1; j > left; --j) ans.push_back(matrix[bottom][j]);
            // 行i：从下边界处理到上边界，列此时为左边界left
            for (int i = bottom; i > top; --i) ans.push_back(matrix[i][left]);
        }
        ++left; --right; ++top; --bottom; //处理边界
    }
    return ans; 
}

:::important[边界处理] 与随想录中不同的是，在这种处理方法中，处理下边界和左边界的循环条件与上边界和右边界的循环条件有所不同，主要原因在于避免重复访问元素。 :::

区间和

kamacoder-58.区间和

这里涉及到的一个数据中的技巧：前缀和(Prefix Sum)。

:::note[前缀和（Prefix Sum）简介] 前缀和是一种用于高效计算子数组区间和的数据结构。它的核心思想是预先计算数组的前缀和数组，然后通过O(1) 时间复杂度查询任意区间的和。 :::

前缀和的定义

对于一个数组 A ，定义其前缀和数组 S：

S[i] = A[0] + A[1] + ... + A[i-1]

其中：

S[i] 表示从索引 0 到索引 i-1 （不含 i ）的元素总和。
通过前缀和，可以快速求解子数组[L, R]的和： SUM(L, R) = S[R+1] - S[L]

这样，计算 任意区间和 仅需 O(1) 时间，而不是直接遍历数组求和的 O(n)。

计算前缀和

(1) 构建前缀和数组

#include <iostream>
#include <vector>
using namespace std;

vector<int> computePrefixSum(const vector<int>& A) {
    int n = A.size();
    vector<int> S(n + 1, 0); // S[0] = 0，保证计算区间时不会越界
    for (int i = 1; i <= n; i++) {
        S[i] = S[i - 1] + A[i - 1]; // S[i] 存储 A[0] 到 A[i-1] 的和
    }
    return S;
}

时间复杂度：O(n)

(2) 快速计算区间和

int rangeSum(const vector<int>& S, int L, int R) {
    return S[R + 1] - S[L]; // O(1) 计算子数组 [L, R] 的和
}

示例：

int main() {
    vector<int> A = {2, 3, 5, 7, 11, 13};
    vector<int> S = computePrefixSum(A);

    cout << "Sum of A[1] to A[3]: " << rangeSum(S, 1, 3) << endl; // 3 + 5 + 7 = 15
    cout << "Sum of A[2] to A[5]: " << rangeSum(S, 2, 5) << endl; // 5 + 7 + 11 + 13 = 36
}

Output:
Sum of A[1] to A[3]: 15
Sum of A[2] to A[5]: 36

时间复杂度：

预处理（计算前缀和）：O(n)
查询区间和：O(1)

需要注意的就是这里的前缀和数组的长度是n+1，因为S[0] = 0，这样可以保证计算区间和时不会越界，这一点与kamacode中的解法有些区别。

开发商购买土地问题

kamacoder-44.开发商购买土地

这里其实也是一个可以使用前缀和来解决问题，对于我来说前缀和的思路可能更好理解。关键就是无论对于哪种分割方向来说，都是是找到一个index，使得区间[0, index]的总和与区间(index, L]的总和差值最小。

代码写的有些冗长，但是思路是清晰的。

#include <climits>
#include <iostream>
#include <vector>
using namespace std;

int main() {
  int n, m;
  cin >> n >> m;
  // 初始化矩阵
  vector<vector<int>> vec(n, vector<int>(m, 0));
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      cin >> vec[i][j];
    }
  }
    // 计算横向总和
    vector<int> total_h(n, 0);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            total_h[i] += vec[i][j];
        }
    }
    // 计算横向前缀和
    vector<int> p_h(n + 1, 0);
    for (int i = 1; i <= n; i++) {
        p_h[i] = p_h[i - 1] + total_h[i - 1];
    }
    // 计算纵向总和
    vector<int> total_v(m, 0);
    for (int j = 0; j < m; j++) {
        for (int i = 0; i < n; i++) {
            total_v[j] += vec[i][j];
        }
    }
    // 计算纵向前缀和
    vector<int> p_v(m + 1, 0);
    for (int i = 1; i <= m; i++) {
        p_v[i] = p_v[i - 1] + total_v[i - 1];
    }
  // 无论对于哪种分割方向来说，都是是找到一个index，使得区间[0, index]的总和与区间(index, L]的总和差值最小。
  int ans = INT_MAX;
  int block_A, block_B;
  // 对于横向
  for (int idx = 1; idx < n; idx++) {
    // 分给A
    block_A = p_h[idx];
    // 分给B
    block_B = p_h[n] - p_h[idx];
    ans = min(ans, abs(block_A - block_B));
  }
  // 对于纵向
  for (int idx = 1; idx < m; idx++) {
    // 分给A
    block_A = p_v[idx];
    // 分给B
    block_B = p_v[m] - p_v[idx];
    ans = min(ans, abs(block_A - block_B));
  }
  cout << ans << endl;
}

这里需要注意的是 <!-- ```cpp block_A = p_h[idx]; // 其实这里的内容是p_h[idx] - p_h[0], 由于p_h[0] = 0，所以这里可以直接写成p_h[idx] block_B = p_h[n] - p_h[idx];

这里的`p_h[n]`是整个矩阵的和，`p_h[idx]`是前`idx`行的和，所以`p_h[n] - p_h[idx]`就是剩下的行的和。
也就是说，`p_h[idx]`只属于A，而不会同时算入B。 -->

以横向为例，在计算的过程中，我们使用了下面的方法来计算前缀和：
```cpp
for (int i = 1; i <= n; i++) {
    p_h[i] = p_h[i - 1] + total_h[i - 1];
}

假设 idx=2，那么：

p_h[2] = total_h[0] + total_h[1]
block_A = p_h[2] - p_h[0] -> A 包含第 0, 1 行
block_B = p_h[n] - p_h[2] -> B 包含第 2, 3, ..., n-1 行

p_h[n] = total_h[0] + total_h[1] + total_h[2] + ... + total_h[n-1];
p_h[n] - p_h[2] = total_h[2] + total_h[3] + ... + total_h[n-1];

B 仅包含 idx 及之后的行（即从 idx 开始到 n-1）。

弄清楚了前缀和的下标问题，其实就很好理解了。

总结

今天的内容说实话有点多，滑动窗口的应用，螺旋矩阵的遍历，以及前缀和的应用。

滑动窗口通过动态调整子数组的范围，可以有效解决子数组问题，如最小子数组和。
螺旋矩阵的遍历方法包括模拟四个方向的移动和逐层缩小边界，确保了矩阵所有元素的正确访问，需要注意的是边界的处理。
前缀和作为高效计算区间和的技巧，能够在 O(1) 时间内查询子数组和，并用于优化矩阵分割问题，如开发商购买土地问题。

其实还有很多相关题没看，等到有时间再自己看看吧。

摸了摸了摸了！

Day01-数组 part01

Wed, 12 Mar 2025 00:00:00 GMT

数组基础

数组是一种存放在连续空间内的相同类型的集合

连续存储：在内存中占据连续的地址空间。
固定长度：数组的长度在定义时就已经确定，不可动态调整（某些语言例如python的列表可以动态扩展）。
随机访问：支持O(1)的索引访问。
相同数据类型：数组中的元素类型必须相同。

静态数组不能直接插入新元素，必须创建一个更大的数据复制元素。同理数组也无法“删除”一个元素，所谓“删除”，指的是用原来的元素进行覆盖。

二分查找

704.二分查找

这是一个典型的二分查找问题，给定一个有序数组，查找目标值的索引。需要注意的是，二分查找的边界条件，以及mid的计算方法。

在通常的情况下，我们可以有两种写法： :::note[1. 左闭右闭区间] 对于第一种写法：区间的定义这就决定了二分法的代码应该如何写，因为定义target在[left, right]区间，所以有如下两点： :::

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left <= right) { //因为区间是左闭右闭，因此left与right相等是有意义的，所以使用<=
            int mid = left + (right - left) / 2;
            if (nums[mid] > target) { // target在左区间， 所以[left, mid - 1]，nums[mid]已经被排除，所以mid - 1
                right = mid - 1;
            }
            else if (nums[mid] < target) { // target在右区间，所以[mid + 1, right]
                left = mid + 1;
            }
            else {
                return mid;
            }
        }
        return -1;
    }

:::note[2. 左闭右开区间] 如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。有如下两点： :::

while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

int search_v2(vector<int>& nums, int target) {
        int left = 0, right = nums.size(); // 因为是左闭右开，因此right = nums.size()
        while (left < right) { // 因为区间是左闭右开，因此left与right相等是没有意义的，所以使用<
            int mid = left + (right - left) / 2;
            if (nums[mid] > target) { //target在左区间，所以[left, mid)，因为左闭右开，下一次查找为[left, mid), nums[mid]并不会被再次访问
                right = mid;
            }
            else if (nums[mid] < target) { //target在有区间，所以[mid + 1, right)
                left = mid + 1;
            }
            else {
                return mid;
            }
        }
        return -1;
    }

循环条件：根据区间的定义，循环条件有所不同：
- 左闭右闭区间：使用 while (left <= right)，因为当 left == right 时，区间 [left, right] 仍然有效。
- 左闭右开区间：使用 while (left < right)，因为当 left == right 时，区间 [left, right) 已为空。

对数组元素进行操作

27.移除元素

:::important[数组的特性] 数组中的元素无法直接删除，只能通过覆盖的方式进行删除。 ::: 最直观的想法是，遍历数组，如果遇到目标值，就将后面的元素向前移动一位，然后数组长度减一。这里如果使用暴力解法，时间复杂度为O(n^2), 空间复杂度为O(1)。

int removeElement(vector<int>& nums, int val) {
        int n = nums.size();
        int i = 0;
        while (i < n) {
            if (nums[i] == val) {
                for (int j = i + 1; j < n; ++j) { 
                    nums[j - 1] = nums[j]; //将后面的元素向前移动一位
                }
                --n; // 数组长度减一
            } else {
                ++i;
            }
        }
        return n;
    }

:::tip[双指针] 双指针法（快慢指针法）可以将时间复杂度降低到O(n)，空间复杂度为O(1)。 :::

双指针的思路实际上是用一层for循环做了暴力解法中两层for循环的操作。

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组
慢指针：指向更新新数组下标的位置

// 通过将快指针指向的元素赋值给慢指针指向的元素，实现元素的覆盖
int removeElement(vector<int>& nums, int val) {
        int slow = 0;
        for (int fast = 0; fast < nums.size(); fast++) { // 定义快指针，遍历数组
            if (nums[fast] != val) { 
                // 如果快指针不等于要删除的元素，那么将快指针指向的元素赋值给慢指针指向的元素，然后慢指针向后移动一位
                // 如果快指针等于要删除的元素，那么快指针向后移动一位，慢指针不动
                nums[slow++] = nums[fast];
            }
        }
        return slow;
}

动画演示如下^1：

双指针

977.有序数组的平方

一般解法

最简单的想法是，遍历数组，将每个元素平方，然后排序。

vector<int> sortedSquares(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) { //时间复杂度为O(n)
            nums[i] = nums[i] * nums[i];
        }
        sort(nums.begin(), nums.end()); // 这里使用的是快排，时间复杂度为O(nlogn)
        return nums;
    }

双指针解法

:::tip[有序数组的特性] 首先数组是有序的，但因为存在负数，所以平方后的数组不一定是有序的。根据数组有序的特性，左右两端的平方值其中之一一定为最大，所以我们可以使用双指针，从两端开始遍历，将较大的平方值放入结果数组中。 :::

vector<int> sortedSquares(vector<int>& nums) {
        int left = 0;
        int right = nums.size() - 1;
        vector<int> res(nums.size());
        int index = res.size() - 1; // 从后往前填充结果数组

        while (left <= right) { // 这里使用的是左闭右闭
            int square_left = nums[left] * nums[left];
            int square_right = nums[right] * nums[right];

            if (square_left < square_right) { //当左边的平方小于右边的平方时，将右边的平方放入结果数组中
                res[index--] = square_right;
                right--;
            } else {                          //当左边的平方大于等于右边的平方时，将左边的平方放入结果数组中
                res[index--] = square_left;
                left++;
            }
        }
        return res;
    }

其动画演示如下^2：

总结

Day1总归是结束了，大概会是个好的开始吧。

其实自己之前只会写python，这次使用C++一个很大的目的还是想让自己在做题的过程中，熟悉C++的用法，多掌握一些东西倒也不是坏事。

训练营第一天的内容其实很快就做完了，大把时间还是用来想怎么写markdown，这个博客还在刚刚完成部署的阶段，后日会慢慢完善吧。

要学的东西还是太多了。