前言
来自 英雄哪里出来 的一个 免费 集训,每天
5
5
5 点打卡学习算法(我是为了卷吗,主要是想早起 😏),希望能坚持下去。这里用来复盘每天都的打卡题目。
今日份知识点:贪心
一、题目
题目 | 难度 |
---|---|
1221. 分割平衡字符串 | ⭐️ |
1217. 玩筹码 | ⭐️ |
1029. 两地调度 | ⭐️ |
面试题 10.11. 峰与谷 | ⭐️⭐️ |
二、算法思路
1、分割平衡字符串
(1)题目保证了
s
s
s 一定是一个平衡字符串,那么我们从左往右依次选择 LR
数量相等的 最短
字符串进行切割。
(2)贪心证明:使每个子字符串的长度最小,得到最优解。
反证法:假设存在两个合法的分割位置
a
,
b
a,b
a,b,其中
a
<
b
a<b
a<b,并且第一次分割点选
b
b
b 得到最优解。
① 将第一个分割位置由
b
b
b 调整为
a
a
a,分割后两端依旧是合法的平衡字符串,不会由 “有解” 变成 “无解”。
② 从
a
a
a 点首次分割剩下部分的长度要大于 从
b
b
b 点首次分割,并且由
a
a
a 分割后剩余部分严格覆盖由
b
b
b 分割后的剩余部分,因此首次由
a
a
a 分割的解要优于由
b
b
b 分割的解。与假设矛盾。
class Solution {
public:
int balancedStringSplit(string s) {
int ret = 0;
int cl = 0, cr = 0;
for (auto x: s) {
if (x == 'L') ++ cl;
if (x == 'R') ++ cr;
if (cl == cr) {
++ ret;
cl = 0, cr = 0;
}
}
return ret;
}
};
(3)这里可以转化为数学判定,
L
L
L 记
−
1
-1
−1 分,
R
R
R 记
1
1
1 分,那么一个合格的 LR
子串的充要条件为 整个 LR
子串得分为0。
class Solution {
public:
int balancedStringSplit(string s) {
int ret = 0;
int cnt = 0;
for (auto x: s) {
if (x == 'L') -- cnt;
if (x == 'R') ++ cnt;
if (cnt == 0) {
++ ret;
}
}
return ret;
}
};
2、玩筹码
(1)根据题目中给出的条件,筹码移动 偶数
个位置代价为 0,移动 奇数
次代价为1,那么所有 奇数
位置上的筹码移动到 奇数
位置的代价为 0, 偶数
位置上的筹码同理。
(2)对结果分析:最后所有筹码在 奇数
位置上,代价为筹码初始位置为 偶数
的筹码数量;在 偶数
位置上,代价为筹码初始位置在 奇数
位置上的筹码数量,二者取最小值即为最优解。
class Solution {
public:
int minCostToMoveChips(vector<int>& position) {
int cl = 0, cr = 0;
for (auto x: position) {
if (x & 1) ++ cl;
else ++ cr;
}
return min(cl, cr);
}
};
3、两地调度
(1)假设所有人都飞到城市
b
b
b,然后从中挑一半人飞到城市
a
a
a,那么公司额外的花费为
p
r
i
c
e
(
a
)
−
p
r
i
c
e
(
b
)
price(a)-price(b)
price(a)−price(b),这个花费可能是负数,挑选额外花费最小的
n
n
n 个人飞到城市
a
a
a;
(2)那么我们先对
c
o
s
t
s
costs
costs 数组按照
p
r
i
c
e
(
a
)
−
p
r
i
c
e
(
b
)
price(a)-price(b)
price(a)−price(b) 排序,前
n
n
n 个人到城市
a
a
a,后
n
n
n 个人到城市
b
b
b。
class Solution {
public:
int twoCitySchedCost(vector<vector<int>>& costs) {
sort(costs.begin(), costs.end(), [](const vector<int>& a, const vector<int>& b) {
return (a[0] - a[1]) < (b[0] - b[1]);
});
int ret = 0;
int n = costs.size() / 2;
for (int i = 0; i < n; ++ i) {
ret += costs[i][0] + costs[i + n][1];
}
return ret;
}
};
4、面试题 10.11. 峰与谷
(1)直观的做法,对数组排序,分别从最前面和最后面个挑一个数放进数组,这样一来就是 峰-谷 交替了。
class Solution {
public:
void wiggleSort(vector<int>& nums) {
if (nums.size() < 3)
return;
int n = nums.size();
vector<int> v(nums);
sort(v.begin(), v.end());
int l = 0, r = nums.size() - 1;
int idx = 0;
while (l < r)
{
nums[idx ++] = v[l ++];
nums[idx ++] = v[r --];
}
if (n % 2)
nums[idx] = v[l];
}
};
(2)另一个做法,从前往后依次与前面一个比较,如果当前位置是峰,那么要满足
n
u
m
s
[
i
]
⩾
n
u
m
s
[
i
−
1
]
nums[i] \geqslant nums[i-1]
nums[i]⩾nums[i−1],如果不满足,则交换两个数;如果当前位置是谷,那么需要满足
n
u
m
s
[
i
]
⩽
n
u
m
s
[
i
−
1
]
nums[i] \leqslant nums[i-1]
nums[i]⩽nums[i−1],如果不满足,则交换;
(3)如果当前是峰的位置,并且
n
u
m
s
[
i
]
⩽
n
u
m
s
[
i
−
1
]
nums[i] \leqslant nums[i-1]
nums[i]⩽nums[i−1],交换两个数之后,再看
i
−
1
i-1
i−1 的位置,它的数变成了
n
u
m
s
[
i
]
nums[i]
nums[i],要比
n
u
m
s
[
i
−
1
]
nums[i-1]
nums[i−1] 更小,所以可以满足其谷的要求;另一个同理。
class Solution {
public:
void wiggleSort(vector<int>& nums) {
for (int i = 1; i < nums.size(); ++ i) {
if (i % 2 == 0) {
if (nums[i - 1] < nums[i])
swap(nums[i - 1], nums[i]);
}else {
if (nums[i - 1] > nums[i])
swap(nums[i - 1], nums[i]);
}
}
}
};
结语
计算机离不开准确性,科学的证明非常有必要,对于贪心,直觉上可以做,但还是需要证明,日常的学习尽量做好每一步,菜鸡在学走路。