【leetcode_week134】边框着色_不相交的线_逃离大迷宫

本文详细解析了LeetCode周赛134的四道题目:移动石子直到连续、边框着色、不相交的线、逃离大迷宫。介绍了每道题目的描述、解题思路及代码实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >


https://leetcode-cn.com/contest/weekly-contest-134


移动石子直到连续

描述

三枚石子放置在数轴上,位置分别为 a,b,c。

每一回合,我们假设这三枚石子当前分别位于位置 x, y, z 且 x < y < z。从位置 x 或者是位置 z 拿起一枚石子,并将该石子移动到某一整数位置 k 处,其中 x < k < z 且 k != y。

当你无法进行任何移动时,即,这些石子的位置连续时,游戏结束。

要使游戏结束,你可以执行的最小和最大移动次数分别是多少? 以长度为 2 的数组形式返回答案:answer = [minimum_moves, maximum_moves]

示例 1:
输入:a = 1, b = 2, c = 5
输出:[1, 2]
解释:将石子从 5 移动到 4 再移动到 3,或者我们可以直接将石子移动到 3。

思路

这题比较简单,主要就是看三数中间有多少间隔的空位,最大值就出来了,最小值也就0、1、2

代码

class Solution {
public:
    vector<int> numMovesStones(int a, int b, int c) {
        int x=a, y=b, z=c;
        int x_y, y_z;
        int min, max;
        int temp;
        // 先对石子位置进行排序
        if(x>y) temp=x,x=y,y=temp;
        if(y>z) temp=y,y=z,z=temp;
        if(x>y) temp=x,x=y,y=temp;

        x_y = y-x-1;
        y_z = z-y-1;
        if (x_y==1 || y_z==1) {
            min = 1;
        }
        else{
            min = (!!x_y)+(!!y_z);
        }
        max = x_y+y_z;

        return {min, max};
    }
};

边框着色

描述

给出一个二维整数网格 grid,网格中的每个值表示该位置处的网格块的颜色。

只有当两个网格块的颜色相同,而且在四个方向中任意一个方向上相邻时,它们属于同一连通分量。

连通分量的边界是指连通分量中的所有与不在分量中的正方形相邻(四个方向上)的所有正方形,或者在网格的边界上(第一行/列或最后一行/列)的所有正方形。

给出位于 (r0, c0) 的网格块和颜色 color,使用指定颜色 color 为所给网格块的连通分量的边界进行着色,并返回最终的网格 grid 。

示例 1:
输入:grid = [[1,1],[1,2]], r0 = 0, c0 = 0, color = 3
输出:[[3, 3], [3, 2]]

思路

这题本来是想直接用以前学的边界跟踪直接找边界的,后来想了一下,一是初始点非边界,而是图形有可能是凹的,原来学的边界跟踪不适用于此。后来换了思路,主要就是区域生长求4连通域,然后在找的过程中判断是否是边界点,主要是利用栈进行区域生长。

代码

class Solution {
public:
    vector<vector<int>> colorBorder(vector<vector<int>>& grid, int r0, int c0, int color) {
        // x方向width(横)和y方向height(竖)
        int height = grid.size();
        int width = grid[0].size();
        int visited[height][width];
        
        memset(visited, 0, sizeof(visited));
        
        int color0 = grid[r0][c0];
        vector<vector<int>> B;
        B.assign(grid.begin(),grid.end());
        // 存放种子点的栈
        stack<vector<int>> S;
        
        int i = r0, j = c0;
        int ii=0, jj=0;
        S.push({i, j});
        
        // 处理栈中的点
        while(!S.empty()) {
            i = S.top()[0];
            j = S.top()[1];
            S.pop();
            // 标记访问过,并判断是否是边界点
            visited[i][j] = 1;
            // 判断是否是边界点
            if ((i==0||j==0||i==height-1||j==width-1) || (grid[i-1][j]!=color0 || grid[i+1][j]!=color0 || grid[i][j-1]!=color0 || grid[i][j+1]!=color0)) {
                B[i][j] = color;
            }
            
            // 扫描该像素点领域,将未访问的前景点入栈
            for (ii = -1; ii <= 1; ii++) {
                for (jj = -1; jj <= 1; jj++) {
                    if (ii*jj==0 && i+ii!=-1 && i+ii!=height && j+jj!=-1 && j+jj!=width && grid[i+ii][j+jj] == color0 && visited[i+ii][j+jj]==0) {
                        S.push({i+ii, j+jj});   // 种子点入栈
                    }
                }
            }
        }
        
        return B;
    }
};

不相交的线

描述

我们在两条独立的水平线上按给定的顺序写下 A 和 B 中的整数。

现在,我们可以绘制一些连接两个数字 A[i] 和 B[j] 的直线,只要 A[i] == B[j],且我们绘制的直线不与任何其他连线(非水平线)相交。

以这种方法绘制线条,并返回我们可以绘制的最大连线数。

示例 1:
输入:A = [1,4,2], B = [1,2,4]
输出:2
解释:
我们可以画出两条不交叉的线。
我们无法画出第三条不相交的直线,因为从 A[1]=4 到 B[2]=4 的直线将与从 A[2]=2 到 B[1]=2 的直线相交。

思路

这题最直接的想法就是动态规划,但是实际做题时在限时时间内没有理清思路,DP方面需要多加练习。
(代码中,用dp[i][j]表示A[:i+1], B[:j + 1]的解)

代码

class Solution {
public:
    int maxUncrossedLines(vector<int>& A, vector<int>& B) {
        int la = A.size(), lb = B.size();
        int dp[la+1][lb+1];
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= la; i++) {
            for (int j = 1; j <= lb; j++) {
                if (A[i-1] == B[j-1]) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                }
                else {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                } 
            }
        }
        return dp[la][lb];
    }
};

逃离大迷宫

描述

在一个 10^6 x 10^6 的网格中,每个网格块的坐标为 (x, y),其中 0 <= x, y < 10^6。

我们从源方格 source 开始出发,意图赶往目标方格 target。每次移动,我们都可以走到网格中在四个方向上相邻的方格,只要该方格不在给出的封锁列表 blocked 上。

只有在可以通过一系列的移动到达目标方格时才返回 true。否则,返回 false。
示例 1:
输入:blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
输出:false
解释:
从源方格无法到达目标方格,因为我们无法在网格中移动。
提示:
0 <= blocked.length <= 200
blocked[i].length == 2
0 <= blocked[i][j] < 10^6
source.length == target.length == 2
0 <= source[i][j], target[i][j] < 10^6
source != target

我的思路

暴力搜索??但是数据量太大肯定不行啊,,,不会做。。。

看完别人思路写的代码

别人的思路都是借用了提示中的信息,很巧妙的将问题进行了简化。
提示中说封锁列表中最多只有200个,所以结合边界,这些障碍物最大可以围城200 * 100的闭环空间。
我们分别查找两个点,如果在200 * 100步内依旧还有搜索空间,则认为这个点是开放的。
如果两个点都是开放的,则认为两个点是可以互相到达的。

看完真的感觉,服,以后还是多做做题吧。。。。。


评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值