5376. 非递增顺序的最小子序列
将数组 nums 划分为两个子序列 A, B，A 要满足下述两个条件：
- sum(A) > sum(B)
- A 的长度要尽可能的短。
当把 nums 中的所有元素都给 A 时，显然满足第一个条件，因为 nums 中只有正整数。
然后不断的将 A 中最小的元素转移到 B 中，直到无法转移。无法转移的意思是，再转移一个元素就会打破第一条限制。此时 降序排序的 A 即为答案。
实现代码如下：
class Solution {
public:
vector<int> minSubsequence(vector<int>& nums) {
sort(nums.begin(), nums.end(), greater<int>());
int sum = 0;
for(auto v : nums) {
sum += v;
}
int ts = 0;
for(int i = 0; i < nums.size(); i++) {
ts += nums[i];
if(ts > sum - ts) {
return vector<int>(nums.begin(), nums.begin() + i + 1);
}
}
return nums;
}
};
5377. 将二进制表示减到 1 的步骤数
可以借助链表模拟。首先将 string 转为 list。然后模拟规则处理list。
转成 list 是为了降低最高位进位时的时间复杂度。
设 cnt 为操作计数器。
- 如果 list.size() == 1 ，处理结束。
- 如果 list 的最后一个元素为 0，cnt += 1，将最后一个结点弹出。跳转第一步。
- 如果 list 的最后一个元素为 1，cnt += 1，对最后一个结点加一并模拟进位。需要考虑最高位进位的情况。跳转第一步。
代码如下：
class Solution {
public:
int numSteps(string s) {
list<int> node;
for(int i = 0; i < s.size(); ++i) {
node.push_back(s[i]-'0');
}
int cnt = 0;
while(node.size() > 1) {
if(node.back() == 0) {
cnt++;
node.pop_back();
} else {
cnt++;
for(auto it = --node.end();;) {
if(*it == 1) {
*it = 0;
if(it == node.begin()) {
node.insert(it, 1);
break;
} else {
--it;
}
} else {
*it = 1;
break;
}
}
}
}
return cnt;
}
};
5195. 最长快乐字符串
假设给出数据为 a >= b >= c。其他情况也可经过排序转化为这种情况。
- 首先拿出 c 个 ‘a’, ‘b’, ‘c’ 进行拼接。
- 再拿出 b-c 个 ‘a’，‘b’ 进行拼接。此时所有 ‘b’，‘c’ 都已拼接到答案中，仅剩 a-b 个 ‘a’ 未拼接。
- 然后可以通过暴力枚举将尽可能多的 ‘a’ 插入到答案中。
完成前两步后，答案长这个样子。
这样插入，可以保证用两个较少的字符隔开最多的字符，从而保证总体长度最长。
代码如下：
class Solution {
bool check(int pos, const string &str, const string &ch) {
string a = str;
a.insert(pos, ch);
for(int i = 0; i+2 < a.size(); i++) {
if(a[i] == ch[0] && a[i+1] == ch[0] && a[i+2] == ch[0]) {
return false;
}
}
return true;
}
public:
string longestDiverseString(int a, int b, int c) {
vector<pair<int, string>> vec;
vec.push_back(make_pair(a, string("a")));
vec.push_back(make_pair(b, string("b")));
vec.push_back(make_pair(c, string("c")));
sort(vec.begin(), vec.end());
string str;
while(vec[0].first > 0) {
vec[0].first --;
vec[1].first --;
vec[2].first --;
str += vec[2].second;
str += vec[1].second;
str += vec[0].second;
}
while(vec[1].first > 0) {
vec[1].first --;
vec[2].first --;
str += vec[2].second;
str += vec[1].second;
}
while(vec[2].first > 0) {
bool flag = false;
for(int i = 0; i <= str.size(); i++) {
if(check(i, str, vec[2].second)) {
str.insert(i, vec[2].second);
flag = true;
break;
}
}
if(flag == false) {
break;
}
vec[2].first --;
}
return str;
}
};
5379. 石子游戏 III
容易让人魔怔的零和博弈！Σ(っ °Д °;)っ
为了便于理解，我们假设下标从 1 开始。
设 dp[i] 代表在 [i…n] 上，先手采取最优策略的得分。
因为必须拿 1 或 2 或 3 堆，所以 dp[n] = stoneValue[n]，即只有一堆时，先手必须拿走，无论该数字的正负。
当 i ∈ [1, n-1] 时，先手有多种策略可选，但先手一定会选择让后手得分最少的策略。因为是零和博弈，总数就那些，对手得分少了，自己得分就高。
根据题意，先手共有三种策略 j = 1 或 j = 2 或 j = 3，对应的，在后手的回合，后手会面临三种局面，即从 [i+1, n]，[i+2, n]，[i+3, n] 选取最优解。
当然，后手虽然无法选择面临的局面，但他可以选择每种局面中的最优策略。
而先手虽然无法改变后手的策略选择，但可以决定后手面临的局面，先手必然让后手面临三种局面中得分最少的局面！！
Σ(っ °Д °;)っ 品，细品，品完这两句再看下面！
在局面 [i,n] 中，先手选择一块时，自己的最高得分为：
A = stoneValue[i] + sum(i+1, n) - dp[i+1]
先手选择两块时，自己的最高得分为：
B = stoneValue[i, i+1]+ sum(i+2, n) - dp[i+2]
先手选择两块时，自己的最高得分为：
C = stoneValue[i, i+1,i+2]+ sum(i+3, n) - dp[i+3]
腹黑如先手，肯定会选择得分最大的策略！
再细品一下状态转移方程：当先手选完 j 堆石头后，游戏进入到下一回合！先手变后手，后手变先手! 此时的先手依然会选择最优策略即 dp[i+j]，对于上一局的先手来说，他只能获得剩下的部分，即 sum(i+j, n) - dp[i+j]。
品完上代码
class Solution {
public:
string stoneGameIII(vector<int>& stoneValue) {
int dp[50003] = {0};
int sum = 0;
for(int n = stoneValue.size(), i = n-1; i >= 0; i--) {
dp[i] = -0x7FFFFFFE;
sum += stoneValue[i];
for(int j = 1; j <= 3; j++) {
dp[i] = max(dp[i], sum - dp[i+j]);
}
}
if(sum - dp[0] == dp[0]) {
return "Tie";
} else if(sum - dp[0] > dp[0]) {
return "Bob";
}
return "Alice";
}
};