Leetcode 第 139 场双周赛题解

Leetcode 第 139 场双周赛题解

  • [Leetcode 第 139 场双周赛题解](#Leetcode 第 139 场双周赛题解)

Leetcode 第 139 场双周赛题解

题目1:3285. 找到稳定山的下标

思路

遍历。

代码

cpp 复制代码
class Solution
{
public:
    vector<int> stableMountains(vector<int> &height, int threshold)
    {
        vector<int> ans;
        for (int i = 1; i < height.size(); i++)
            if (height[i - 1] > threshold)
                ans.push_back(i);
        return ans;
    }
};

复杂度分析

时间复杂度:O(n),其中 n 是数组 height 的长度。

空间复杂度:O(n),其中 n 是数组 height 的长度。

题目2:3286. 穿越网格图的安全路径

思路

广度优先搜索。

代码

py 复制代码
#
# @lc app=leetcode.cn id=3286 lang=python3
#
# [3286] 穿越网格图的安全路径
#

# @lc code=start
class Solution:
    def findSafeWalk(self, grid: List[List[int]], health: int) -> bool:
        m, n = len(grid), len(grid[0])

        vis = [[False] * n for _ in range(m)]
        vis[0][0] = True

        dx = [0, 1, 0, -1]
        dy = [1, 0, -1, 0]

        @cache
        def dfs(x: int, y: int, h: int) -> bool:
            if h <= 0:
                return False
            if x == m - 1 and y == n - 1 and h > 0:
                return True
            
            for i in range(4):
                nx = x + dx[i]
                ny = y + dy[i]
                if nx >= 0 and nx < m and ny >= 0 and ny < n and vis[nx][ny] == False:
                    vis[nx][ny] = True
                    if dfs(nx, ny, h - grid[nx][ny]):
                        return True
                    vis[nx][ny] = False
            return False

        return dfs(0, 0, health - grid[0][0])
# @lc code=end

复杂度分析

时间复杂度:O(m * n),其中 m 和 n 分别为 grid 的行数和列数。

空间复杂度:O(m * n),其中 m 和 n 分别为 grid 的行数和列数。

题目3:3287. 求出数组中最大序列值

思路

前后缀分解。

把数组nums 分成左右两部分,左部和右部分别计算所有长为 k 的子序列的 OR 都有哪些值。

两两组合计算 XOR,取其中最大值作为答案。

代码

cpp 复制代码
/*
 * @lc app=leetcode.cn id=3287 lang=cpp
 *
 * [3287] 求出数组中最大序列值
 */

// @lc code=start
class Solution
{
private:
    static const int MX = 1 << 7;

public:
    int maxValue(vector<int> &nums, int k)
    {
        int n = nums.size();
        vector<array<bool, MX>> pre(k + 1);
        vector<array<bool, MX>> suf(n - k + 1);
        vector<array<bool, MX>> dp(k + 1);
        dp[0][0] = true;
        // 状态转移
        for (int i = n - 1; i >= k; i--)
        {
            int v = nums[i];
            for (int j = min(k - 1, n - 1 - i); j >= 0; j--)
            {
                for (int x = 0; x < MX; x++)
                    if (dp[j][x])
                        dp[j + 1][x | v] = true;
            }
            if (i <= n - k)
                suf[i] = dp[k];
        }
        int ans = 0;

        pre[0][0] = true;
        for (int i = 0; i < n - k; i++)
        {
            int v = nums[i];
            for (int j = min(k - 1, i); j >= 0; j--)
                for (int x = 0; x < MX; x++)
                    if (pre[j][x])
                        pre[j + 1][x | v] = true;
            if (i < k - 1)
                continue;
            for (int x = 0; x < MX; x++)
                if (pre[k][x])
                    for (int y = 0; y < MX; y++)
                        if (suf[i + 1][y])
                            ans = max(ans, x ^ y);
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

时间复杂度:O(nkU+nU^2^),其中 n 是数组 nums 的长度,U 是数组 nums 所有元素的 OR,本题至多为 2^7^−1。DP 是 O(nkU) 的,计算 XOR 最大值是 O(U^2^) 的。

空间复杂度:O(nU),其中 n 是数组 nums 的长度,U 是数组 nums 所有元素的 OR,本题至多为 2^7^−1。

题目4:3288. 最长上升路径的长度

思路

将每个点按横坐标从小到大排序之后,我们就只要考虑纵坐标单调递增。因此问题就变成了经过某个点的最长上升子序列有多长。

经过某个点的最长上升子序列,可以分成以它为终点的、从左到右看的最长上升子序列,加上以它为终点的、从右到左看的最长下降子序列。

注:最长上升 / 下降子序列问题可以用二分查找求解。

代码

cpp 复制代码
/*
 * @lc app=leetcode.cn id=3288 lang=cpp
 *
 * [3288] 最长上升路径的长度
 */

// @lc code=start
class Solution
{
public:
    int maxPathLength(vector<vector<int>> &coordinates, int k)
    {
        int n = coordinates.size();
        vector<array<int, 3>> vec;
        for (int i = 0; i < n; i++)
            vec.push_back({coordinates[i][0], coordinates[i][1], i});
        sort(vec.begin(), vec.end(),
             [&](array<int, 3> &a, array<int, 3> &b)
             {
                 if (a[0] != b[0])
                     return a[0] < b[0];
                 else
                     return a[1] > b[1];
             });

        int ans = -1;

        // 以规定点为终点的,从左到右看的最长上升子序列
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = INT_MIN;
        for (int i = 0; i < n; i++)
        {
            int head = 0, tail = n;
            while (head < tail)
            {
                int mid = (head + tail + 1) >> 1;
                if (dp[mid] < vec[i][1])
                    head = mid;
                else
                    tail = mid - 1;
            }
            dp[head + 1] = vec[i][1];
            if (vec[i][2] == k)
            {
                ans += head + 1;
                break;
            }
        }

        // 以规定点为终点的,从右到左看的最长下降子序列
        fill(dp.begin() + 1, dp.end(), INT_MIN);
        dp[0] = INT_MAX;
        for (int i = n - 1; i >= 0; i--)
        {
            int head = 0, tail = n;
            while (head < tail)
            {
                int mid = (head + tail + 1) >> 1;
                if (dp[mid] > vec[i][1])
                    head = mid;
                else
                    tail = mid - 1;
            }
            dp[head + 1] = vec[i][1];
            if (vec[i][2] == k)
            {
                ans += head + 1;
                break;
            }
        }

        return ans;
    }
};
// @lc code=end

复杂度分析

时间复杂度:O(nlogn),其中 n 是数组 coordinates 的长度。

空间复杂度:O(n),其中 n 是数组 coordinates 的长度。

相关推荐
zz40_几秒前
C++自己写类 和 运算符重载函数
c++
Dong雨8 分钟前
力扣hot100-->栈/单调栈
算法·leetcode·职场和发展
六月的翅膀12 分钟前
C++:实例访问静态成员函数和类访问静态成员函数有什么区别
开发语言·c++
liujjjiyun42 分钟前
小R的随机播放顺序
数据结构·c++·算法
¥ 多多¥1 小时前
c++中mystring运算符重载
开发语言·c++·算法
trueEve2 小时前
SQL,力扣题目1369,获取最近第二次的活动
算法·leetcode·职场和发展
天若有情6732 小时前
c++框架设计展示---提高开发效率!
java·c++·算法
Root_Smile2 小时前
【C++】类和对象
开发语言·c++
Reese_Cool2 小时前
【数据结构与算法】排序
java·c语言·开发语言·数据结构·c++·算法·排序算法
九圣残炎3 小时前
【从零开始的LeetCode-算法】3354. 使数组元素等于零
java·算法·leetcode