算法和数据结构
day1
1：正确
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
// 中序遍历一遍二叉树，并统计节点数目
class Solution {
public:
int count = 0; // 统计节点数
void inorder(TreeNode* root) {
if(!root) return;
inorder(root->left);
count += 1;
inorder(root->right);
}
int countNodes(TreeNode* root) {
inorder(root);
return count;
}
};2：不会
93. 复原 IP 地址 - 力扣（LeetCode）
class Solution {
public:
vector restoreIpAddresses(string s) {
// 对于 "25525511135" 中最左边的255，我们有不同的划分方式
// 25 5 和 255 具体划分的依据不清楚是什么
}
}; 3：解答错误
123. 买卖股票的最佳时机 III - 力扣（LeetCode）
class Solution {
public:
int maxProfit(vector& prices) {
// 1 特判
// 如果数组只有一个元素，不能交易，返回 0
if (prices.size() == 1) return 0;
// 如果数组有两个元素，判断能否交易
if (prices.size() == 2) {
return (prices[1] - prices[0]) > 0 ? (prices[1] - prices[0]) : 0;
}
// 2 先判断能否完成至少一次交易
// 先找到最左边的 [a, b] 可交易区间 a < b
int l1, r1, l2, r2;
bool flag1 = false; // flag1 = true 表示至少可以完成一次交易
bool flag2 = false; // flag2 = true 表示至少可以完成一次交易
for(int i = 0; i <= prices.size() - 2; ++i) {
for(int j = i + 1; j <= prices.size() - 1; ++j) {
if (prices[j] > prices[i]) {
flag1 = true;
l1 = i;
r1 = j;
break;
}
}
}
if (flag1 == false) {
return 0;
}
// 再找最右边的 [a, b] 可交易区间 a < b
for (int i = prices.size() - 1; i >= 1; --i) {
for (int j = prices.size() - 2; j >= 0; --j) {
if (prices[i] > prices[j]) {
l2 = i;
r2 = j;
break;
}
}
}
if (r1 < l2) {
flag2 = true;
}
// 3 如果只有一段可交易区间
int value = -1;
if (flag1 == true && flag2 == false) {
for(int i = 0; i <= prices.size() - 2; ++i) {
for(int j = i + 1; j <= prices.size() - 1; ++j) {
if (prices[j] > prices[i]) {
value = max((prices[j] - prices[i]), value);
}
}
}
return value;
}
// 4 如果可能有两段可交易区间
if (flag1 == true && flag2 == true) {
int i1, j1, i2, j2;
j2 = prices.size() - 1;
i2 = prices.size() - 2;
for(i1 = 0; i1 <= prices.size() - 2; ++i1) {
for(j1 = i1 + 1; j1 <= prices.size() - 1; ++j1) {
if (prices[j1] > prices[i1]) {
for (i2 = prices.size() - 2; i2 > j1; --i2) {
for (j2 = prices.size() - 1; j2 > i2; --j2) {
if (prices[j2] > prices[i2]) {
value = max(value, (prices[j1] - prices[i1]) + (prices[j2] - prices[i2]) );
}
}
}
}
}
}
return value;
}
return 0;
}
}; 4: 解答错误
不知道动规错在哪
416. 分割等和子集 - 力扣（LeetCode）
class Solution {
public:
bool canPartition(vector& nums) {
// 1 特判
// 如果只有一个元素不可能
if (nums.size() == 1) {
return false;
}
// 如果和为奇数，不可能
int sum = accumulate(nums.begin(), nums.end(), 0);
int frac = sum % 2;
int half = sum / 2;
if (frac == 1) {
return false;
}
// 如果最大值大于一半，不可能
int maxValue = -1;
for (int i = 0; i <= nums.size() - 1; ++i) {
maxValue = max(maxValue, nums[0]);
}
if (maxValue > half) {
return false;
}
// 2
int n = nums.size();
sort(nums.begin(), nums.end());
vector> dp(n, vector(half + 1, false));
for (int i = 0; i < n; ++i) {
dp[i][0] = true;
}
for (int j = 1; j <= half; ++j) {
if (j == nums[0]) {
dp[0][j] = true;
} else {
dp[0][j] = false;
}
}
for (int i = 1; i < n; ++i) {
for (int j = 1; j <= half; ++j) {
if (j >= nums[i]) {
dp[i][j] = dp[i - 1][j - nums[i]] || dp[i - 1][j];
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[n - 1][half + 1];
}
}; 5：解答错误
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
class Solution {
public:
int length = 0; // 记录最大长度
void bfs(vector>& matrix, int i, int j, int m, int n) {
length += 1;
matrix[i][j] = -10;
if ( ((i - 1) >= 0) && ((matrix[i - 1][j]) > matrix[i][j]) ) {
bfs(matrix, i - 1, j, m, n);
length -=1;
}
if ( ((j - 1) >= 0) && ((matrix[i][j - 1]) > matrix[i][j]) ) {
bfs(matrix, i, j - 1, m, n);
length -=1;
}
if ( ((i + 1) <= m - 1) && ((matrix[i + 1][j]) > matrix[i][j]) ) {
bfs(matrix, i + 1, j, m, n);
length -=1;
}
if ( ((j + 1) <= n - 1) && ((matrix[i][j + 1]) > matrix[i][j]) ) {
bfs(matrix, i, j + 1, m, n);
length -=1;
}
}
int longestIncreasingPath(vector>& matrix) {
int m = matrix.size(), n = matrix[0].size();
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
bfs(matrix, i, j, m, n);
}
}
return length;
}
}; 6：有思路
class Solution {
public:
int equalSubstring(string s, string t, int maxCost) {
int n = s.size();
vector cost(n, 0);
for (int i = 0; i < n; i++) {
cost[i] = abs(s[i] - t[i]);
}
// 双指针滑动窗口求最大长度
// 计算滑窗内的 cost 值
int l1 = 0, r1 = 0;
int ans = 0;
int res = 0;
while (r1 < n && l1 <= r1) {
int costRange = 0;
// 计算当前窗口中的 cost 和 长度
for (int i = l1; i <= r1; ++i) {
costRange += cost[i];
ans = r1 - l1 + 1;
}
// 区间cost小，则递增右边界
// 此时也需要更新 res
if (costRange < maxCost) {
res = max(res, ans);
r1++;
}
// 区间 cost 相等，递增左边界
// 储存当前值
if (costRange == maxCost) {
res = max(res, ans);
l1++;
}
// 区间 cost 大，则递增左边界
if (costRange > maxCost) {
l1++;
}
}
return res;
}
}; 7：不会
410. 分割数组的最大值 - 力扣（LeetCode）
8：正确
class Solution {
public:
vector nextGreaterElements(vector& nums) {
int n = nums.size();
vector next(n, -1);
for (int i = 0; i < n; ++i) {
int j = (i + 1) % n;
while (j != i) {
if (nums[j] > nums[i]) {
next[i] = nums[j];
break;
}
j = (j + 1) % n;
}
}
return next;
}
}; 回溯
1: 77
path：递归路径
index：下标
停止条件：path.size() == k
递归方向：[index, n]
class Solution {
public:
// 储存递归路径
vector temp;
vector> res;
void dfs(int index, int n, int k) {
// 剪枝：temp 长度加上区间 [index, n] 的长度小于 k，不可能构造出长度为 k 的 temp
if ((temp.size() + (n - index + 1)) < k) {
return;
}
// 停止条件
if (temp.size() == k) {
res.push_back(temp);
return;
}
// 从 index 到 n 进行回溯
for (int i = index; i <= n; ++i) {
// 考虑当前位置
temp.push_back(i);
dfs(i + 1, n, k);
temp.pop_back();
}
}
vector> combine(int n, int k) {
dfs(1, n, k);
return res;
}
}; 2: 39
class Solution {
public:
// 有序数组可以优化
vector> res;
vector temp;
vector> combinationSum(vector& candidates, int target) {
dfs(0, 0, candidates, target);
return res;
}
void dfs(int index, int sum, vector& candidates, int target) {
if (sum >= target) {
if (sum == target) {
res.push_back(temp);
}
return;
}
for (int i = index; i <= candidates.size() - 1; ++i) {
temp.push_back(candidates[i]);
// 这次选的是i则继续从i考虑，不考虑小于 i 的
dfs(i, sum + candidates[i], candidates, target);
temp.pop_back();
}
}
}; class Solution {
public:
// 有序数组可以优化
vector> res;
vector temp;
vector> combinationSum(vector& candidates, int target) {
sort(candidates.begin(), candidates.end());
dfs(0, 0, candidates, target);
return res;
}
void dfs(int index, int sum, vector& candidates, int target) {
if (sum >= target) {
if (sum == target) {
res.push_back(temp);
}
return;
}
for (int i = index; i <= candidates.size() - 1; ++i) {
// 优化
if (sum + candidates[i] > target) return;
temp.push_back(candidates[i]);
// 这次选的是i则继续从i考虑，不考虑小于 i 的
dfs(i, sum + candidates[i], candidates, target);
temp.pop_back();
}
}
};