双周赛掉分之旅，周六晚上第三题，DFS或者BFS都可以，我用了BFS，结果超内存，检查半天不知道哪里出错了，心态爆炸，名次很差，可怜呀。排名：459 / 822。
不过好像双周赛掉分也不算多，掉了 6 分，可能是我分本来也不高吧，哈哈哈。
第一题：模拟。
第二题：二分。
第三题：DFS 或者 BFS。
第四题：动态规划DP。
详细题解如下。
1. 将每个元素替换为右侧最大元素（Replace Elements with Greatest Element on Right Side）
2. 转变数组后最接近目标值的数组和（Sum of Mutated Array Closest to Target）
3.层数最深叶子节点的和（Deepest Leaves Sum）
4.最大得分的路径数目（Number of Paths with Max Score）
LeetCode第16场双周赛地址：
https://leetcode-cn.com/contest/biweekly-contest-16/
1. 将每个元素替换为右侧最大元素（Replace Elements with Greatest Element on Right Side）
题目链接
https://leetcode-cn.com/problems/replace-elements-with-greatest-element-on-right-side/
题意
给你一个数组
arr，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用-1替换。完成所有替换操作后，请你返回这个数组。
示例 1：
输入：arr = [17,18,5,4,6,1] 输出：[18,6,6,6,1,-1]提示：
1 <= arr.length <= 10^41 <= arr[i] <= 10^5
解题思路
题目要求，给你一个数组 arr ，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用 -1 替换。
那么我们可以根据题意，对数组从后往前遍历，用一个变量记录右边的最大值，然后将当前位置的值更新为最大值，同时把这个位置之前的值和当前最大值两者再取最大值记录。
时间复杂度 O(n)
比如示例 1
[17,18,5,4,6,1]
数组更新为 [17,18,5,4,6,-1]，maxVal ： 1
数组更新为 [17,18,5,4,1,-1]，maxVal ： 6 （6 > 1）
数组更新为 [17,18,5,6,1,-1]，maxVal ： 6 (6 > 4)
数组更新为 [17,18,6,6,1,-1]，maxVal ： 6
数组更新为 [17,6,6,6,1,-1]，maxVal ： 18 （18 > 6）
数组更新为 [18,6,6,6,1,-1]，maxVal ： 18 （18 > 17）
AC代码（C++）
class Solution {
public:
vector<int> replaceElements(vector<int>& arr) {
int n = arr.size();
int maxVal = arr[n-1];
arr[n-1] = -1;
for(int i = n-2;i >=0; --i)
{
// 先把原来的值记录，不然后面无法更新maxVal
int temp = arr[i];
arr[i] = maxVal;
maxVal = max(temp, maxVal);
}
return arr;
}
};2. 转变数组后最接近目标值的数组和（Sum of Mutated Array Closest to Target）
题目链接
https://leetcode-cn.com/problems/sum-of-mutated-array-closest-to-target/
题意
给你一个整数数组 arr 和一个目标值 target ，请你返回一个整数 value ，使得将数组中所有大于 value 的值变成 value 后，数组的和最接近 target （最接近表示两者之差的绝对值最小）。
如果有多种使得和最接近 target 的方案，请你返回这些整数中的最小值。
请注意，答案不一定是 arr 中的数字。
示例 1：
输入：arr = [4,9,3], target = 10 输出：3 解释：当选择 value 为 3 时，数组会变成 [3, 3, 3]，和为 9 ，这是最接近 target 的方案。示例 2：
输入：arr = [2,3,5], target = 10 输出：5示例 3：
输入：arr = [60864,25176,27249,21296,20204], target = 56803 输出：11361提示：
1 <= arr.length <= 10^41 <= arr[i], target <= 10^5
解题思路
拿到题目，一开始想的就是暴力枚举，根据 arr[ i ] 的数据范围，我们可以知道，答案就在 0 到 10^5（要考虑0，因为当等于 0的时候，数组所有数变为0，也是符合考虑情况的）。
但是直接暴力枚举的话，那就是 O(N * M)，N是数组长度，M是数组中最大值，根据数据范围，会超时。
所以无法直接暴力枚举，那么我们如果将答案范围的寻找，从线性复杂度降低，就可以了，那么就想到了 二分查找
二分查找，主要就是要能根据不同的情况，缩小查找范围，即能根据不同情况，分为找左区间还是右区间。
假设我们当前找到的某个值，为 mid，然后得到对应数组的和为 sum
- 如果 sum > target，说明， 此时的 mid 应该更小一点，这样子 sum值变小 （因为 sum 再大，也不可能比当前的绝对值之差小）。
- 如果 sum < target，说明， 此时的 mid 应该更大一点，这样子 sum值变大 （因为 sum 再变小，绝对值之差会变大，也不可能比当前的绝对值之差小）。
所以可以根据不同情况，缩小查找范围，因此可以使用二分查找
时间复杂度为 O(logM * N)
AC代码（C++）
#define INF 0x3f3f3f3f
class Solution {
public:
int findBestValue(vector<int>& arr, int target) {
int ans = INF; // 记录答案
int diff = INF; // 记录当前差值
int l = 0, r = 100000;
while(l < r)
{
int mid = (l + r)/2;
int sum = 0;
for(int i = 0;i < arr.size();++i)
{
if(arr[i] > mid)
sum += mid;
else
sum += arr[i];
}
int temp = abs(target - sum);
// 如果差值小于当前记录的，说明有更小的差值，更新
// 如果差值等于当前差值，那么对于答案 ans而言，相同差值，取最小值的 value
if(temp < diff)
{
diff = temp;
ans = mid;
}
else if(temp == diff)
{
ans = min(ans, mid);
}
// 二分的两种情况讨论
if(sum >= target)
{
r = mid;
}
else
{
l = mid + 1;
}
}
return ans;
}
};3.层数最深叶子节点的和（Deepest Leaves Sum）
题目链接
https://leetcode-cn.com/problems/deepest-leaves-sum/
题意
给你一棵二叉树，请你返回层数最深的叶子节点的和。
示例 1：
（示例有图，具体看链接） 输入：root = [1,2,3,4,5,null,6,7,null,null,null,null,8] 输出：15提示：
- 树中节点数目在
1到10^4之间。- 每个节点的值在
1到100之间。
解题分析
这道题的要求是，求出二叉树中，深度最大的所有叶子节点的和。示例 1 的15，是 7 + 8 而来的。
方法一：DFS
该题相当于二叉树遍历，找到深度最大的所有叶子节点，将其值加起来
因此我们用两次 DFS，第一次DFS是先得到最大的深度，第二次DFS是遍历所有节点，如果等于最大深度，那么就对其值求和。
方法二：BFS
BFS的好处，利用了队列，那么在队列的同一连续区域中的所有节点都是同一层的
因此我们可以不断的入队列，然后出队判断，我们用一个变量记录此时找到的最大深度 deep，ans记录同一深度的节点值之和
如果出队这个节点，
- 深度大于当前深度 deep，那么更新deep，同时说明有新的一层节点，那么 ans = 0，重新记录
- 深度等于当前深度 deep，那么 ans 累加此时的节点值
这样子对于DFS的好处是，不需要两次DFS。BFS一次就可以得到答案和最大深度
AC代码（方法一 DFS C++）
class Solution {
public:
int ans = 0;
int deep = 0;
// 求深度
void dfsDeep(TreeNode* root, int d)
{
if(root == NULL) return;
deep = max(d, deep);
dfsDeep(root->left, d + 1);
dfsDeep(root->right, d + 1);
}
// 求题目要求的答案
void dfs(TreeNode* root, int d)
{
if(root == NULL) return;
if(deep == d)
ans += root->val;
dfs(root->left, d + 1);
dfs(root->right, d + 1);
}
int deepestLeavesSum(TreeNode* root) {
// 先求深度，再求深度的和，用dfs
dfsDeep(root, 0);
dfs(root, 0);
return ans;
}
};AC代码（方法二 BFS C++）
class Solution {
public:
struct Node{
TreeNode* r;
int d;
Node(TreeNode* r_, int d_): r(r_), d(d_) {}
};
int deepestLeavesSum(TreeNode* root) {
queue<Node> q;
int deep = -1, ans = 0;
q.push(Node(root, 0)); // 同时记录节点和节点的深度
while(!q.empty())
{
Node cur = q.front();
q.pop();
if(cur.d > deep)
{
deep = cur.d;
ans = 0;
}
ans += (cur.r)->val;
if((cur.r)->left != NULL)
{
q.push(Node((cur.r)->left, cur.d+1));
}
if((cur.r)->right != NULL)
{
q.push(Node((cur.r)->right, cur.d+1));
}
}
return ans;
}
};4.最大得分的路径数目（Number of Paths with Max Score）
题目链接
https://leetcode-cn.com/problems/number-of-paths-with-max-score/
题意
给你一个正方形字符数组 board ，你从数组最右下方的字符 'S' 出发。
你的目标是到达数组最左上角的字符 'E' ，数组剩余的部分为数字字符 1, 2, ..., 9 或者障碍 'X'。在每一步移动中，你可以向上、向左或者左上方移动，可以移动的前提是到达的格子没有障碍。
一条路径的 「得分」 定义为：路径上所有数字的和。
请你返回一个列表，包含两个整数：第一个整数是 「得分」 的最大值，第二个整数是得到最大得分的方案数，请把结果对 10^9 + 7 取余。
如果没有任何路径可以到达终点，请返回 [0, 0] 。
示例 1：
输入：board = ["E23","2X2","12S"] 输出：[7,1]示例 2：
输入：board = ["E12","1X1","21S"] 输出：[4,2]示例 3：
输入：board = ["E11","XXX","11S"] 输出：[0,0]提示：
- 2 <= board.length == board[i].length <= 100
解题分析
根据题意分析，要求的是，最大值，同时还有最大值分数的方案数。
本来考虑BFS，但它不是最短路。如果用DFS去遍历，有可能会超时，因为数组的范围比较大
那么最大值还可以考虑是动态规划，动态规划的时间复杂度是线性的，所以不会超时，那么就要设好变量、边界条件、还有转移关系。数组大小为 n,m
- 1）设 dp[ i ][ j ] 表示在(i, j)处的最大得分， cnt[ i ][ j ] 表示 (i, j) 处对应这个最大得分的方案数。
- 2）边界条件，先初始化所有的 dp，cnt 为0。然后在起点处，dp = 0, cnt = 1，因为是起点，得分为0，方案数为1。
- 3）转移关系，对于数组，我们起点在右下角，终点在左上角，所以是从后往前遍历。那么对于一个位置 (i, j)，可以往三个方向考虑转移，左边，左上，上边。转移的要求是，不会越界，且对应位置不是障碍。如果走到了，我们记录 从 dp[i][j]走到对应位置，此时的新得分为 一个值，v。此时有两种情况
- 此时新得分 v 大于本身我们要走到的位置记录的最大得分，那么更新此时的最大得分为 v，同时方案数和 cnt[i][j]一样，因为是直接过来的
- 如果新得分 v 等于本身我们要走到的位置记录的最大得分，相当于方案数有多个，那么此时的方案数是本身的方案数 + cnt[i][j]
- 如果新得分 v 小于，那么不用考虑
最后答案就是 dp[ 0 ][ 0 ]，cnt[ 0 ][ 0 ]。
时间复杂度是 O(N * M)
AC代码（ C++）
const int MOD = 1e9 + 7;
class Solution {
public:
// dp[i][j] 表示在(i,j)处的最大得分，cnt[i][j]对应为这个最大得分的方案数
int dp[150][150], cnt[150][150];
vector<int> pathsWithMaxScore(vector<string>& board) {
int n = board.size(), m = board[0].size();
// 初始化
memset(dp, 0, sizeof(dp));
memset(cnt, 0, sizeof(cnt));
cnt[n-1][m-1] = 1;
board[0][0] = '0'; // 这个处理为 '0'，就可以统一处理，不用特殊 E处理，因为 0 不会影响得分。
for(int i = n-1;i >= 0; --i)
{
for(int j = m-1;j >= 0; --j)
{
// 如果一个地方没有方案，说明这个地方本来就无法到达，要么就是'X'，所以就直接不用考虑这个对应点的转移情况
if(cnt[i][j] == 0) continue;
// 从某个点，可以往三个方向走，要检查能不能走到（不越界，且不是'X'）
if(i > 0 && board[i-1][j] != 'X'){
int cur = dp[i][j] + (board[i-1][j] - '0');
if(cur > dp[i-1][j]){
dp[i-1][j] = cur;
cnt[i-1][j] = cnt[i][j] % MOD;
}
else if(cur == dp[i-1][j]){
cnt[i-1][j] = (cnt[i-1][j] + cnt[i][j]) % MOD;
}
}
if(j > 0 && board[i][j-1] != 'X'){
int cur = dp[i][j] + (board[i][j-1] - '0');
if(cur > dp[i][j-1]){
dp[i][j-1] = cur;
cnt[i][j-1] = cnt[i][j];
}
else if(cur == dp[i][j-1]){
cnt[i][j-1] = (cnt[i][j-1] + cnt[i][j]) % MOD;
}
}
if(i > 0 && j > 0 && board[i-1][j-1] != 'X'){
int cur = dp[i][j] + (board[i-1][j-1] - '0');
if(cur > dp[i-1][j-1]){
dp[i-1][j-1] = cur;
cnt[i-1][j-1] = cnt[i][j];
}
else if(cur == dp[i-1][j-1]){
cnt[i-1][j-1] = (cnt[i-1][j-1] + cnt[i][j]) % MOD;
}
}
}
}
return {dp[0][0], cnt[0][0]};
}
};
1029
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
