Leetcode周赛285

原创于 2022-03-22 14:01:27 发布 · 957 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

Coding 专栏收录该内容

16 篇文章

订阅专栏

这篇博客介绍了三道LeetCode上的编程题目，分别是统计数组中峰和谷的数量、道路上的碰撞次数以及射箭比赛中的最大得分。作者通过详细解析思路，展示了动态规划和状态转移等算法的应用，帮助读者理解如何解决此类问题。

由于很久很久没有刷过题了，从leetcode重新入手刷题。

2210. 统计数组中峰和谷的数量

思路：用flag表示上升或下降，注意开始时如果是平的，flag应赋其他值以区分。

class Solution {
public:
    int countHillValley(vector<int>& nums) {
        int cnt = 0;
        if(nums.size()<3) return 0;
        int flag = 3;
        if (nums[1]>nums[0]) flag = 1;
        if (nums[0]>nums[1]) flag = 0;
        int last = nums[1];
        for(int i = 2;i<nums.size();i++){
            if (nums[i]>nums[i-1]){
                if(flag==0){
                    cnt++;
                    
                }flag = 1;
            }
            else if (nums[i]<nums[i-1]){
                if(flag==1){
                    cnt++;
                    
                }flag=0;
            }
            else{
                continue;
            }
        }
        return cnt;
    }
};

2211. 统计道路上的碰撞次数

思路：从左到右，维护向右以及静止的车辆数目，当遇到S或L时进行碰撞判断并更新R及S的数量。

class Solution {
public:
    int countCollisions(string directions) {
        int s = 0,r = 0,ans = 0;
        int l = directions.length();
        for(int i = 0;i<l;i++){
            if(directions[i]=='S'){
                while(r>0){
                    ans += 1;
                    r -=1;
                    s += 1;
                }
                s += 1;
                
            }
            if(directions[i]=='R'){
                r += 1;
            }
            if(directions[i]=='L'){
                if(r>0){
                    ans += 2;
                    r -= 1;
                    s += 2;
                    while(r>0){
                        ans += 1;
                        s += 2;
                        r -= 1;
                    }
                }
                else if(s>0){
                    ans += 1;
                    s += 1;
                }

            }
        }
        return ans;
    }
};

2212. 射箭比赛中的最大得分

思路：动态规划，dp[i][j]表示从0开始到区域i时，共使用j根箭可获得的最多分数，最后进行路径恢复。

class Solution {
public:
    vector<int> maximumBobPoints(int numArrows, vector<int>& aliceArrows) {
        vector<vector<int>> dp(13,vector<int>(numArrows+1,0));
        vector<int> out(12);
        int ans = 0;
        for(int i = 1;i<=12;i++){
            for(int j = 1;j<=numArrows;j++){
                if (j<aliceArrows[i-1]+1){
                    dp[i][j] = dp[i-1][j];
                }
                else{
                    dp[i][j] = max(dp[i-1][j],dp[i-1][j-aliceArrows[i-1]-1]+(i-1));
                
                }
            }
        }
        int last_arrows = numArrows;
        for(int i = 12;i>0;i--){
            if(dp[i][last_arrows]>dp[i-1][last_arrows]){
                out[i-1] = aliceArrows[i-1] +1;
                last_arrows -= (aliceArrows[i-1] +1);
            }
            out[0] = last_arrows;
        }
        return out;
    }
};