字符串 s 可以按下述步骤划分为若干长度为 k 的组：
第一组由字符串中的前 k 个字符组成，第二组由接下来的 k 个字符串组成，依此类推。每个字符都能够成为 某一个 组的一部分。
对于最后一组，如果字符串剩下的字符 不足 k 个，需使用字符 fill 来补全这一组字符。
注意，在去除最后一个组的填充字符 fill（如果存在的话）并按顺序连接所有的组后，所得到的字符串应该是 s 。
给你一个字符串 s ，以及每组的长度 k 和一个用于填充的字符 fill ，按上述步骤处理之后，返回一个字符串数组，该数组表示 s 分组后 每个组的组成情况 。
示例 1：
输入：s = "abcdefghi", k = 3, fill = "x"
输出：["abc","def","ghi"]
解释：
前 3 个字符是 "abc" ，形成第一组。
接下来 3 个字符是 "def" ，形成第二组。
最后 3 个字符是 "ghi" ，形成第三组。
由于所有组都可以由字符串中的字符完全填充，所以不需要使用填充字符。
因此，形成 3 组，分别是 "abc"、"def" 和 "ghi" 。
示例 2：
输入：s = "abcdefghij", k = 3, fill = "x"
输出：["abc","def","ghi","jxx"]
解释：
与前一个例子类似，形成前三组 "abc"、"def" 和 "ghi" 。
对于最后一组，字符串中仅剩下字符 'j' 可以用。为了补全这一组，使用填充字符 'x' 两次。
因此，形成 4 组，分别是 "abc"、"def"、"ghi" 和 "jxx" 。
提示：
1 <= s.length <= 100-
s仅由小写英文字母组成 1 <= k <= 100-
fill是一个小写英文字母
解题思路：简单字符串模拟，重点在于如何判断到了最后一组字符串。
代码及提交截图如下：
class Solution {
public String[] divideString(String s, int k, char fill) {
int len = s.length();
List<String> res = new ArrayList();
int index = 0;
while(index < len){
StringBuffer s1 = new StringBuffer();
for(int i = 0 ; i < k ; i++){
if(index >= s.length()){
s1.append(fill);
}else{
s1.append(s.charAt(index));
}
index++;
}
res.add(new String(s1));
}
String[] ress = res.toArray(new String[res.size()]);
return ress;
}
}你正在玩一个整数游戏。从整数 1 开始，期望得到整数 target 。
在一次行动中，你可以做下述两种操作之一：
递增，将当前整数的值加 1（即， x = x + 1）。
加倍，使当前整数的值翻倍（即，x = 2 * x）。
在整个游戏过程中，你可以使用 递增 操作 任意 次数。但是只能使用 加倍 操作 至多 maxDoubles 次。
给你两个整数 target 和 maxDoubles ，返回从 1 开始得到 target 需要的最少行动次数。
示例 1：
输入：target = 5, maxDoubles = 0
输出：4
解释：一直递增 1 直到得到 target 。
示例 2：
输入：target = 19, maxDoubles = 2
输出：7
解释：最初，x = 1 。
递增 3 次，x = 4 。
加倍 1 次，x = 8 。
递增 1 次，x = 9 。
加倍 1 次，x = 18 。
递增 1 次，x = 19 。
示例 3：
输入：target = 10, maxDoubles = 4
输出：4
解释：
最初，x = 1 。
递增 1 次，x = 2 。
加倍 1 次，x = 4 。
递增 1 次，x = 5 。
加倍 1 次，x = 10 。
提示：
1 <= target <= 1090 <= maxDoubles <= 100
解题思路：可以使用 target 往 1 反推，如果 target 为奇数则先 -1 让其变成偶数，然后再除 2 也算是一次操作，要注意的是，当 除 2 的次数用完之后，target 变成 1 还需要 target-1 次。
代码及提交截图如下：
class Solution {
public int minMoves(int target, int maxDoubles) {
int count = 0;
while(target > 1){
if(maxDoubles == 0){
count+=target-1;
break;
}
count++;
if(target%2 == 1){
target--;
}else{
if(maxDoubles > 0){
target/=2;
maxDoubles--;
}
}
}
return count;
}
}T3 5982. 解决智力问题
给你一个下标从 0 开始的二维整数数组 questions ，其中 questions[i] = [pointsi, brainpoweri] 。
这个数组表示一场考试里的一系列题目，你需要 按顺序 （也就是从问题 0 开始依次解决），针对每个问题选择 解决 或者 跳过 操作。解决问题 i 将让你 获得 pointsi 的分数，但是你将 无法 解决接下来的 brainpoweri 个问题（即只能跳过接下来的 brainpoweri 个问题）。如果你跳过问题 i ，你可以对下一个问题决定使用哪种操作。
比方说，给你 questions = [[3, 2], [4, 3], [4, 4], [2, 5]] ：
如果问题 0 被解决了， 那么你可以获得 3 分，但你不能解决问题 1 和 2 。
如果你跳过问题 0 ，且解决问题 1 ，你将获得 4 分但是不能解决问题 2 和 3 。
请你返回这场考试里你能获得的 最高 分数。
示例 1：
输入：questions = [[3,2],[4,3],[4,4],[2,5]]
输出：5
解释：解决问题 0 和 3 得到最高分。
- 解决问题 0 ：获得 3 分，但接下来 2 个问题都不能解决。
- 不能解决问题 1 和 2
- 解决问题 3 ：获得 2 分
总得分为：3 + 2 = 5 。没有别的办法获得 5 分或者多于 5 分。
示例 2：
输入：questions = [[1,1],[2,2],[3,3],[4,4],[5,5]]
输出：7
解释：解决问题 1 和 4 得到最高分。
- 跳过问题 0
- 解决问题 1 ：获得 2 分，但接下来 2 个问题都不能解决。
- 不能解决问题 2 和 3
- 解决问题 4 ：获得 5 分
总得分为：2 + 5 = 7 。没有别的办法获得 7 分或者多于 7 分。
提示：
1 <= questions.length <= 105
questions[i].length == 2
1 <= pointsi, brainpoweri <= 105
解题思路：动态规划（我看着这个题第一眼就是动态规划，后来多看了好多眼，还是只知道它要用动态规划，哈哈哈哈）
解法一：倒序 DP（查表法）
设有 n 个问题，定义 f[i] 表示解决区间 [i,n−1] 内的问题可以获得的最高分数。
倒序遍历问题列表，对于第 i 个问题，我们有两种决策：跳过或解决。
若跳过，则有 f[i]=f[i+1]。
若解决，则需要跳过后续 brainpower[i] 个问题。记 j=i+brainpower[i]+1。
这两种决策取最大值。最后答案为 f[0]。
代码和提交结果如下：
class Solution {
public long mostPoints(int[][] questions) {
int n = questions.length;
long[] f = new long[n + 1];
for (int i = n - 1; i >= 0; --i) {
int[] q = questions[i];
int j = i + q[1] + 1;
f[i] = Math.max(f[i + 1], q[0] + (j < n ? f[j] : 0));
}
return f[0];
}
}
解法二：正序 DP（刷表法）
定义 f[i] 表示解决区间 [0,i] 内的问题可以获得的最高分数。
对于问题 i，若跳过，则可以更新 f[i+1]=max(f[i+1],f[i])。
若不跳过，记 j=i+{brainpower}[i]+1，则可以更新 f[j]=max(f[j],f[i]+point[i])。
对于 i=n-1 和 j≥n 的情况，为了简化代码逻辑，我们可以将其更新到 f[n] 中。
最后答案为 f[n]。
代码和提交结果如图：
class Solution {
public long mostPoints(int[][] questions) {
int n = questions.length;
long f[] = new long[n + 1];
for (int i = 0; i < n; i++) {
f[i + 1] = Math.max(f[i + 1], f[i]);
int[] q = questions[i];
int j = Math.min(i + q[1] + 1, n);
f[j] = Math.max(f[j], f[i] + q[0]);
}
return f[n];
}
}总结： 这次周赛写了两道题，第三道动态规划方程到最后也没写出来。第三题看第一眼就知道是动态规划，看了20分钟，还是只知道用动态规划，哈哈哈哈哈哈哈。加油加油。