LeetCode 第 16 场双周赛(402/822,前48.9%)

文章目录

    • 1. 比赛结果
    • 2. 题目
      • LeetCode 1299. 将每个元素替换为右侧最大元素 easy
      • LeetCode 1300. 转变数组后最接近目标值的数组和 medium
      • LeetCode 1302. 层数最深叶子节点的和 medium
      • LeetCode 1301. 最大得分的路径数目 hard

1. 比赛结果

做出了2道题,第二道题耽搁时间有点长,放弃了,第四题在时间到了后一会就做出来了。
LeetCode 第 16 场双周赛(402/822,前48.9%)_第1张图片
LeetCode 第 16 场双周赛(402/822,前48.9%)_第2张图片

2. 题目

LeetCode 1299. 将每个元素替换为右侧最大元素 easy

给你一个数组 arr ,请你将每个元素用它右边最大的元素替换,如果是最后一个元素,用 -1 替换。
完成所有替换操作后,请你返回这个数组。
示例: 输入:arr = [17,18,5,4,6,1]
输出:[18,6,6,6,1,-1]
提示:
1 <= arr.length
<= 10^4 1 <= arr[i] <= 10^5

解题:
从后往前遍历,记录当前的最大值。

class Solution {
public:
    vector<int> replaceElements(vector<int>& arr) {
        int m = arr.back(), origin;
        arr.back() = -1;
        for(int i = arr.size()-2; i >= 0; --i)
        {
            origin = arr[i];//记录原始数据
            arr[i] = m;//右侧的最大值填入
            m = max(m, origin);//更新最大值
        }
        return arr;
    }
};

LeetCode 1300. 转变数组后最接近目标值的数组和 medium

LeetCode 1302. 层数最深叶子节点的和 medium

给你一棵二叉树,请你返回层数最深的叶子节点的和。

LeetCode 第 16 场双周赛(402/822,前48.9%)_第3张图片

输入:root = [1,2,3,4,5,null,6,7,null,null,null,null,8]
输出:15
提示:
树中节点数目在 1 到 10^4 之间。 每个节点的值在 1 到 100 之间。

解题:按层遍历即可

class Solution {
public:
    int deepestLeavesSum(TreeNode* root) {
        queue<TreeNode*> q;
        int sum, n;
        q.push(root);
        while(!q.empty())
        {
            n = q.size();
            sum = 0;
            while(n--)
            {
                sum += q.front()->val;
                if(q.front()->left)
                    q.push(q.front()->left);
                if(q.front()->right)
                    q.push(q.front()->right);
                q.pop();
            }
        }
        return sum;
    }
};

LeetCode 1301. 最大得分的路径数目 hard

给你一个正方形字符数组 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

解题:
dp二维数组存储一个pair(得分,方案数)

class Solution {
    int n, i, j;
public:
    vector<int> pathsWithMaxScore(vector<string>& board) {
        n = board.size();
        board[0][0] = board[n-1][n-1] = '0';//方便后面处理起点和终点的得分
        vector<vector<pair<int,int>>> dp(n,vector<pair<int,int>> (n, make_pair(0,0)));
        dp[n-1][n-1].second = 1;//起点的方案数为1
        for(i = n-2; i >= 0 && board[i][n-1] != 'X'; --i)
        {	//初始化最后1列
            dp[i][n-1].first = dp[i+1][n-1].first+board[i][n-1]-'0';//得分累加
            dp[i][n-1].second = 1;//方案数只有1种
        }
        for(i = n-2; i >= 0 && board[n-1][i] != 'X'; --i)
        {	//初始化最后1行
            dp[n-1][i].first = dp[n-1][i+1].first+board[n-1][i]-'0';
            dp[n-1][i].second = 1;
        }
        
        for(i = n-2; i >= 0; i--)
        {
            for(j = n-2; j >= 0; j--)
            {	//填写其他dp数组
                if(board[i][j] != 'X')//没有障碍
                {
                    if(dp[i+1][j+1].second)//右下角 如果有方案数,则可以过来
                    {
                        if(dp[i+1][j+1].first+board[i][j]-'0' > dp[i][j].first)//得分大,更新得分,方案数
                        {
                            dp[i][j].first = dp[i+1][j+1].first+board[i][j]-'0';
                            dp[i][j].second = dp[i+1][j+1].second%1000000007;
                        }
                        else if(dp[i+1][j+1].first+board[i][j]-'0' == dp[i][j].first)//得分相等,方案数相加
                        {
                            dp[i][j].second += dp[i+1][j+1].second%1000000007;
                        }
                    }
                    if(dp[i][j+1].second)//右边
                    {
                        if(dp[i][j+1].first+board[i][j]-'0' > dp[i][j].first)
                        {
                            dp[i][j].first = dp[i][j+1].first+board[i][j]-'0';
                            dp[i][j].second = dp[i][j+1].second%1000000007;
                        }
                        else if(dp[i][j+1].first+board[i][j]-'0' == dp[i][j].first)
                        {
                            dp[i][j].second += dp[i][j+1].second%1000000007;
                        }
                    }
                    if(dp[i+1][j].second)//下边
                    {
                        if(dp[i+1][j].first+board[i][j]-'0' > dp[i][j].first)
                        {
                            dp[i][j].first = dp[i+1][j].first+board[i][j]-'0';
                            dp[i][j].second = dp[i+1][j].second%1000000007;
                        }
                        else if(dp[i+1][j].first+board[i][j]-'0' == dp[i][j].first)
                        {
                            dp[i][j].second += dp[i+1][j].second%1000000007;
                        }
                    }
                }
            }
        }
        return {dp[0][0].first, dp[0][0].second%1000000007};//得分,方案数
    }
};

你可能感兴趣的:(LeetCode)