我是一个菜鸡,最后一题想到可能用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 <= 500
1 <= 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 <= 500
s
由字符'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 <= 100
a + 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";
}
};