我是一个菜鸡，最后一题想到可能用DP，但还是不会做，继续加油吧！！！
第一题：排序。
第二题：模拟。
第三题：模拟 + 思维。
第四题：博弈 + DP。
详细题解如下。
1.非递增顺序的最小子序列（Minimum Subsequence In Non Increasing Order）
2. 将二进制表示减到 1 的步骤数（Number of Steps to Reduce A Number in Binary Representation to One）
3.最长快乐字符串（Longest Happy String）
LeetCode第183场周赛地址：
https://leetcode-cn.com/contest/weekly-contest-183/
1.非递增顺序的最小子序列（Minimum Subsequence In Non Increasing Order）
题目链接
https://leetcode-cn.com/problems/minimum-subsequence-in-non-increasing-order/
题意
给你一个数组 nums，请你从中抽取一个子序列，满足该子序列的元素之和 严格 大于未包含在该子序列中的各元素之和。
如果存在多个解决方案，只需返回 长度最小 的子序列。如果仍然有多个解决方案，则返回 元素之和最大 的子序列。
与子数组不同的地方在于，「数组的子序列」不强调元素在原数组中的连续性，也就是说，它可以通过从数组中分离一些（也可能不分离）元素得到。
注意，题目数据保证满足所有约束条件的解决方案是 唯一 的。同时，返回的答案应当按 非递增顺序 排列。
示例 2：
输入：nums = [4,4,7,6,7] 输出：[7,7,6] 解释：子序列 [7,7] 的和为 14 ，不严格大于剩下的其他元素之和（14 = 4 + 4 + 6）。因此，[7,6,7] 是满足题意的最小子序列。注意，元素按非递增顺序返回。提示：
1 <= nums.length <= 5001 <= nums[i] <= 100
解题思路
根据题意，其实就是，找到一个子序列，使得这个子序列尽可能短，同时和尽可能大。
那么根据子序列的定义，我们如果要取数作为子序列，只要取一个数，那么长度 + 1，那么在长度 + 1 的前提下，我们尽可能取最大值即可。
所以，我们只要不断的取最大值，只要当子序列和 > 剩余部分的和，那么就结束。否则，一直数（取剩余部分中的最大数）。
因此，只要对原数组进行排序即可。
时间复杂度 O(n * logn)。
AC代码（C++）
class Solution {
public:
vector<int> minSubsequence(vector<int>& nums) {
sort(nums.begin(), nums.end());
reverse(nums.begin(), nums.end());
int n = nums.size();
int sum = 0;
for(int num : nums) sum += num;
int cur = 0;
vector<int> ans;
for(int i = 0;i < n; ++i)
{
ans.push_back(nums[i]);
cur += nums[i];
if(cur > sum - cur) break;
}
return ans;
}
};2. 将二进制表示减到 1 的步骤数（Number of Steps to Reduce A Number in Binary Representation to One）
题目链接
https://leetcode-cn.com/problems/number-of-steps-to-reduce-a-number-in-binary-representation-to-one/
题意
给你一个以二进制形式表示的数字 s 。请你返回按下述规则将其减少到 1 所需要的步骤数：
如果当前数字为偶数，则将其除以 2 。
如果当前数字为奇数，则将其加上 1 。
题目保证你总是可以按上述规则将测试用例变为 1 。
示例 1：
输入：s = "1101" 输出：6 解释："1101" 表示十进制数 13 。 Step 1) 13 是奇数，加 1 得到 14 Step 2) 14 是偶数，除 2 得到 7 Step 3) 7 是奇数，加 1 得到 8 Step 4) 8 是偶数，除 2 得到 4 Step 5) 4 是偶数，除 2 得到 2 Step 6) 2 是偶数，除 2 得到 1示例 2：
输入：s = "10" 输出：1 解释："10" 表示十进制数 2 。 Step 1) 2 是偶数，除 2 得到 1提示：
1 <= s.length <= 500s由字符'0'或'1'组成。s[0] == '1'
解题思路
模拟，根据题目和数据范围，我们直接从最后一个数开始计算。
当是 1 的时候，+ 1 进位，同时下一个数。（这样子就是 + 1 并 / 2，所以 操作数 + 2）
当时 0 的时候，直接下一个数。(因为是 偶数 ，所以直接 /2，相当于二进制就是到下一个数，那么 操作数 + 1)。
注意的是，我们可能会由于有进位的影响，所以要 c 记录进位（一开始进位 = 0）
特别的，当到了 第一个位数 的时候，我们判断，如果此时，加上进位后 = 1，那就是答案直接为 1 了，操作数不处理。如果加上进位 后 = 0，说明是 偶数，先要 除 / 2 后，就得到答案，所以是操作数 + 1
时间复杂度，就是 O(n)，对字符串按每一位进行操作。
AC代码（C++）
class Solution {
public:
int numSteps(string s) {
int ans = 0;
int n = s.size();
int c = 0;
for(int i = n - 1;i >= 0; --i)
{
int tep = c + s[i] - '0'; // 计算 + 进位后，当前位置上的数
// 特判，当时第一位的时候，如果是 1 ，那就是答案了。不操作。否则 偶数，操作 + 1。
if(i == 0 && tep % 2 == 1) break;
if(tep % 2 == 1) // 奇数，先 + 1，同时操作数 + 1
{
tep += 1;
++ans;
}
c = tep / 2; // 无论是计数 + 1 变成偶数，还是原本偶数，都要操作数 + 1
++ans;
}
return ans;
}
};3.最长快乐字符串（Longest Happy String）
题目链接
https://leetcode-cn.com/problems/longest-happy-string/
题意
如果字符串中不含有任何 'aaa'，'bbb' 或 'ccc' 这样的字符串作为子串，那么该字符串就是一个「快乐字符串」。
给你三个整数 a，b ，c，请你返回 任意一个 满足下列全部条件的字符串 s：
- s 是一个尽可能长的快乐字符串。
- s 中 最多 有a 个字母 'a'、b 个字母 'b'、c 个字母 'c' 。
- s 中只含有 'a'、'b' 、'c' 三种字母。
如果不存在这样的字符串 s ，请返回一个空字符串 ""。
示例 1：
输入：a = 1, b = 1, c = 7 输出："ccaccbcc" 解释："ccbccacc" 也是一种正确答案。示例 2：
输入：a = 2, b = 2, c = 1 输出："aabbc"提示：
0 <= a, b, c <= 100a + b + c > 0
解题分析
思维 + 模拟。其实就是先思考如何构造，然后按照要求构造即可。
自己的做法
其实就是，我们每一次都把（a，b，c）最大值那个作为 两个组合，然后下一次，依旧是最大值的两个做组合。
这里就有一个小问题，比如 示例 1， c 都是最大，所以出现了 cc，cc，那么我们加入第二次 cc 的时候，要注意，如果前面那个还是 c，说明会 ccc 出现，那么我们要 加入 cc 之前，加入一个其他数，进行隔开，这个隔开的数，我们也是用最大数。
然后剩下的有一些小问题，就是在代码中，逐渐增加条件。
所以自己的做法，就是利用 很多 if 来进行判断。。。比较麻烦，哈哈哈
大佬的做法
参考了 huangyuyang 这个大佬的代码
其实就是，我每一次增加一个 字符 进去，那么此时要考虑
- 依旧是从最大值那个加
- 在上一步的前提，应该是，最大值加进去的那个数，如果前两个数相同了，那么这个 字符 就不能取。比如原本 1 1 5，现在有 cc，那么加入第三个字符的时候，应该加入的是最大值，但是发现 最大值对应的是 c，也就是不能取这个。所以再剩下的其他中，找到最大值。
- 如果找不到，那么就是结束了
大佬的方便就是，没有那么多 if ，我们可以用一个数组，0 1 2 分别存 a，b，c的数量，那么我们一个变量记录对应要取得下标，那么加入得字符就是 'a' + index。
下面得代码，第一个是大佬的代码，方便整洁。
第二个自己得代码，if 很多，就是在基本得情况下，不断得加限制条件，不整洁，还乱。
AC代码（大佬的代码 C++）
class Solution {
public:
string longestDiverseString(int a, int b, int c) {
string ret = "";
vector <int> sur; // 保存 三个值的剩余数量
sur.push_back(a);
sur.push_back(b);
sur.push_back(c);
while (true) {
int ban = -1; // 记录，如果前两个字符一样，那么对应这个 这个字符不能取
if (ret.size() >= 2 && ret[ret.size() - 1] == ret[ret.size() - 2]) {
ban = ret[ret.size() - 1] - 'a';
}
// 找到，三个中的最大值，同时要求，不能是 ban 的那个字符
int sel = -1;
for (int i = 0; i < 3; i++) {
if (i == ban || sur[i] == 0) {
continue;
}
if (sel == -1 || sur[i] > sur[sel]) {
sel = i;
}
}
if (sel == -1) { // 如果 == -1，说明找不出那个最大值，也就是字符串无法再增长了
break;
}
ret += ('a' + sel); // 加上字符，同时对应那个字符数量-1
sur[sel]--;
}
return ret;
}
};AC代码（自己的代码 C++）
class Solution {
public:
string longestDiverseString(int a, int b, int c) {
string res = "";
while(a > 0 || b > 0 || c > 0)
{
if(a == 0 && b == 0 && c == 0) break;
if(a >= b && a >= c)
{
if(res.size() != 0 && res[res.size() - 1] == 'a')
{
if(b == 0 && c == 0) break;
if(b >= c)
{
res += 'b';
--b;
}
else
{
res += 'c';
--c;
}
}
else if(res.size() >= 2 && res[res.size() - 1] == 'a' && res[res.size() - 1] != 'a')
{
if(a == 1)
{
res += 'a';
--a;
}
}
if(a >= 2)
{
res += "aa";
a -= 2;
}
else if(a == 1)
{
res += 'a';
--a;
}
}
else if(b >= a && b >= c)
{
if(res.size() != 0 && res[res.size() - 1] == 'b')
{
if(a == 0 && c == 0) break;
if(a >= c)
{
res += 'a';
--a;
}
else
{
res += 'c';
--c;
}
}
else if(res.size() >= 2 && res[res.size() - 1] == 'b' && res[res.size() - 1] != 'b')
{
if(b == 1)
{
res += 'b';
--b;
}
}
if(b >= 2)
{
res += "bb";
b -= 2;
}
else if(b == 1)
{
res += 'b';
--b;
}
}
else if(c >= a && c >= b)
{
if(res.size() != 0 && res[res.size() - 1] == 'c')
{
if(b == 0 && a == 0) break;
if(a >= b)
{
res += 'a';
--a;
}
else
{
res += 'b';
--b;
}
}
else if(res.size() >= 2 && res[res.size() - 1] == 'c' && res[res.size() - 1] != 'c')
{
if(c == 1)
{
res += 'c';
--c;
}
}
if(c >= 2)
{
res += "cc";
c -= 2;
}
else if(c == 1)
{
res += 'c';
--c;
}
}
}
return res;
}
};4.石子游戏 III（Stone Game III）
题目链接
https://leetcode-cn.com/problems/stone-game-iii/
题意
Alice 和 Bob 用几堆石子在做游戏。几堆石子排成一行，每堆石子都对应一个得分，由数组 stoneValue 给出。
Alice 和 Bob 轮流取石子，Alice 总是先开始。在每个玩家的回合中，该玩家可以拿走剩下石子中的的前 1、2 或 3 堆石子 。比赛一直持续到所有石头都被拿走。
每个玩家的最终得分为他所拿到的每堆石子的对应得分之和。每个玩家的初始分数都是 0 。比赛的目标是决出最高分，得分最高的选手将会赢得比赛，比赛也可能会出现平局。
假设 Alice 和 Bob 都采取 最优策略 。如果 Alice 赢了就返回 "Alice" ，Bob 赢了就返回 "Bob"，平局（分数相同）返回 "Tie" 。
示例 1：
输入：values = [1,2,3,7] 输出："Bob" 解释：Alice 总是会输，她的最佳选择是拿走前三堆，得分变成 6 。但是 Bob 的得分为 7，Bob 获胜。示例 2：
输入：values = [1,2,3,-9] 输出："Alice" 解释：Alice 要想获胜就必须在第一个回合拿走前三堆石子，给 Bob 留下负分。 如果 Alice 只拿走第一堆，那么她的得分为 1，接下来 Bob 拿走第二、三堆，得分为 5 。之后 Alice 只能拿到分数 -9 的石子堆，输掉比赛。 如果 Alice 拿走前两堆，那么她的得分为 3，接下来 Bob 拿走第三堆，得分为 3 。之后 Alice 只能拿到分数 -9 的石子堆，同样会输掉比赛。 注意，他们都应该采取 最优策略 ，所以在这里 Alice 将选择能够使她获胜的方案。提示：
1 <= values.length <= 50000-1000 <= values[i] <= 1000
解题分析
这道题的难点，主要就是分析，“最优策略”。那么我们的想法，无论当前是谁拿，那么它都有三种情况，拿一堆、两堆、三堆。
那么对应一个人先手，我们假设记录其最优策略，也就是它能得到的最大分数（这样子，另外一个人就是最小分数了）为 dp[ i ]
也就是，当我们取 dp[ i ] 作为先手的时候，它有三种情况，拿一堆、两堆、三堆，也就是，可以是从 dp[ i +1 ]，dp[ i +2 ]，dp[ i +3 ]，转移过来的（因为我们现在不考虑具体谁先手，我们都考虑 dp 是先手的最大值，因为每一个人先手，都是要最优，那么肯定是想要自己最大）
那么比如 [ i, i + 1, i + 2, i + 3, ... n ]，现在我们要更新 dp[ i ]，那么它可以是从 dp[ i +1 ]，dp[ i +2 ]，dp[ i +3 ]，转移过来的，这是因为，当我们取 一堆的时候，那么下一次那个人的先手就是 dp[ i +1 ]，也就是两者之间有关系。
这个关系就是状态转移方程，我们先 dp[ i +1 ]，dp[ i +2 ]，dp[ i +3 ] 统一记录为 dp[ j ]，那么此时 [ i, i + 1, i + 2, i + 3, ... n ] 变为了 [ i, i + 1, ... j - 1 ], [ j, j +1, j + 2, ... n ]。
那么对于 dp[ i ] = 目前拿到的堆值（i， i + 1...） + （后面堆中，这个先手的值）
那么（后面堆中，这个先手的值），也就是，后面的所有值 - dp[ j ]，这是因为，dp[ j ]，是另一个人的先手，那么对于目前 i 对应 的这个人的值，那么就是，后面所有值 - dp[ j ]。
所以 dp[ i ] = 目前拿到的堆值（i， i + 1...） + 后面所有值 - dp[ j ]。。。。
我们又发现 目前拿到的堆值（i， i + 1...） + 后面所有值 = sum(i, ... n)
所以就是 dp[ i ] = sum(i, ... n) - dp[ j ]。
那么状态转移方程出来的，我们发现，对于 i 而言，我们先要知道 j ，才能更新 i，所以更新的时候，是从最后 n - 1，更新到 0 的。
那么初始值，我们是要求最大值，那么设的是初始值是最小值，那么对于每一个 dp[ n - 1 ... 0 ] = - INF，这里我们可以按照数据， 设 INF = 1e9。同时 dp[ n ] = 0，也就是，当还没有取堆的时候，取得值是 0。
然后根据上面，进行状态转移方程，得到 了 dp[ 0 ] 就是 Alice 先手得值，那么 Bob 的值 = sum(0 ... n - 1) - dp[ 0 ]
然后比较这两个得分，就可以得到答案了。
AC代码（C++）
const int INF = 1e9;
class Solution {
public:
string stoneGameIII(vector<int>& stoneValue) {
int n = stoneValue.size();
vector<int> dp(n + 1, -INF); // 所有初始值都是 -INF
dp[n] = 0; // n 表示，还没开始取 堆，所以就是 0
int sum = 0;
for(int i = n - 1;i >= 0; --i) //从后往前更新
{
sum += stoneValue[i]; // 根据分析，我们要计算 [i...n - 1] 的所有值之和。
for(int j = i + 1;j <= n && j <= i + 3; ++j)
{
dp[i] = max(dp[i], sum - dp[j]); // 更新，更新的时候，j 就是 i + 1,i + 2,i + 3，并且，j 应该最多到 n，因为 dp 的边界是 n。
}
}
// 最后比较即可。
if(dp[0] > sum - dp[0]) return "Alice";
if(dp[0] < sum - dp[0]) return "Bob";
return "Tie";
}
};
238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
