LeetCode第163场周赛（Weekly Contest 163）解题报告

这周的周赛，时间冲突，所以是后面补的题目。

第一题，直接按题目的意思进行模拟，时间复杂度过得去

第二题，二叉树，DFS

第三题，动态规划问题

第四题，BFS

详细题解如下。

---

1. 二维网格迁移（Shift 2d Grid）

            AC代码（C++）

2. 在受污染的二叉树中查找元素（Find Elements in A Contaminated Binary Tree）

            AC代码（C++）

3.可被三整除的最大和（Greatest Sum Divisible by Three）

            AC代码（C++）

4.推箱子（Minimum Moves to Move A Box to Their Target Location）

            AC代码（ C++）

 

---

LeetCode第163场周赛地址：

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

---

1. 二维网格迁移（Shift 2d Grid）

题目链接

https://leetcode-cn.com/problems/shift-2d-grid/

题意

给你一个 n 行 m 列的二维网格 grid 和一个整数 k。你需要将 grid 迁移 k 次。

每次「迁移」操作将会引发下述活动：

• 位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]。
• 位于 grid[i][m - 1] 的元素将会移动到 grid[i + 1][0]。
• 位于 grid[n - 1][m - 1] 的元素将会移动到 grid[0][0]。

请你返回 k 次迁移操作后最终得到的 二维网格。

示例 ：有图示，所以具体的看链接

提示：

• 1 <= grid.length <= 50
• 1 <= grid[i].length <= 50
• -1000 <= grid[i][j] <= 1000
• 0 <= k <= 100

解题思路

根据题目的意思，还有示例，发现，每一次操作过后，数组发生了以下变化：

1、所有列都往后移动了一列，即 第 j 列变成了 j+1 列

2、所以最后一列变成第一列

3、在2的基础上，变成第一列后，第一列的数由行向下移动了一位

因此我们根据上述规律，对每一次操作，对数组进行以下变动：（n是行数，m是列数）

1、先保留最后一列的数（因为最后一列要变到第一列）

2、将 0 到 m-2列，往后移一列，变成 1 到 m-1列

3、将保留最后一列的数，向下移动一位的方式，放到第 0 列中。

时间复杂度是O(K*N*M)，不会超时

AC代码（C++）

class Solution {
public:
    vector> shiftGrid(vector>& grid, int k) {
        int temp[55];
        int n = grid.size(), m = grid[0].size();
        while(k--)
        {
            for(int i = 0;i < n;i++) temp[i] = grid[i][m-1]; // 保留最后一列的数

            // 从 0 到 m-2 列的数，移动到 1到 m-1列上
            for(int j = m-1;j > 0;--j)
            {
                for(int i = 0;i < n;++i)
                    grid[i][j] = grid[i][j-1];
            }

            // 把原本最后一列的数，放回到第一列中
            grid[0][0] = temp[n-1];
            for(int i = 1;i < n;i++)
                grid[i][0] = temp[i-1];

        }
        return grid;
    }
};

---

2. 在受污染的二叉树中查找元素（Find Elements in A Contaminated Binary Tree）

题目链接

https://leetcode-cn.com/problems/find-elements-in-a-contaminated-binary-tree/

题意

给出一个满足下述规则的二叉树：

1. root.val == 0
2. 如果 treeNode.val == x 且 treeNode.left != null，那么 treeNode.left.val == 2 * x + 1
3. 如果 treeNode.val == x 且 treeNode.right != null，那么 treeNode.right.val == 2 * x + 2

现在这个二叉树受到「污染」，所有的 treeNode.val 都变成了 -1。

请你先还原二叉树，然后实现 FindElements 类：

• FindElements(TreeNode* root) 用受污染的二叉树初始化对象，你需要先把它还原。
• bool find(int target) 判断目标值 target 是否存在于还原后的二叉树中并返回结果。

示例 ：示例中有图示，因此具体的

提示：

• TreeNode.val == -1
• 二叉树的高度不超过 20
• 节点的总数在 [1, 10^4] 之间
• 调用 find() 的总次数在 [1, 10^4] 之间
• 0 <= target <= 10^6

 

解题思路

DFS + set

题目形容的很复杂，其实就是一棵二叉树，左右子节点的值根据父节点的值来计算，根节点的起始值为 0。

先利用DFS，从根节点深搜，记录父节点的val，然后得到左右子节点的val。

为了可以 find，我们利用一个集合存储所有出现的 val，然后每一个find就查找以下对应值有没有在这个集合中。

AC代码（C++）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class FindElements {
public:
    unordered_set s;
    FindElements(TreeNode* root) {
        if(root) dfs(root, 0);
    }
    
    bool find(int target) {
        return s.count(target);
    }
    
    void dfs(TreeNode* root, int val)
    {
        s.insert(val);
        root->val = val;
        if(root->left) dfs(root->left, 2*val+1);
        if(root->right) dfs(root->right, 2*val+2);
    }

};

/**
 * Your FindElements object will be instantiated and called as such:
 * FindElements* obj = new FindElements(root);
 * bool param_1 = obj->find(target);
 */

---

3.可被三整除的最大和（Greatest Sum Divisible by Three）

题目链接

https://leetcode-cn.com/problems/greatest-sum-divisible-by-three/

题意

给你一个整数数组 nums，请你找出并返回能被三整除的元素最大和。

示例 1：

输入：nums = [3,6,5,1,8]
输出：18
解释：选出数字 3, 6, 1 和 8，它们的和是 18（可被 3 整除的最大和）。

示例 2：

输入：nums = [4]
输出：0
解释：4 不能被 3 整除，所以无法选出数字，返回 0。

示例 3：

输入：nums = [1,2,3,4,4]
输出：12
解释：选出数字 1, 3, 4 以及 4，它们的和是 12（可被 3 整除的最大和）。

提示：

• 1 <= nums.length <= 4 * 10^4
• 1 <= nums[i] <= 10^4

解题分析

根据题意，这个应该是一个动态规划的问题，假设有 n 个数。

设 dp[n][3]，其中 dp[ i ][ j ] 表示，前 i 个数中，余数为 j 的元素最大和。

状态转移方程：

对于当前处理的这个数，设为 num，对于不同的余数 0，1，2（即 j ）

那么 dp[i+1][  (j+num)%3 ]，考虑这个新的数进来后，余数变化的时候，对于余数为 （j+num)%3 应该是

1、要么没有加入这个数，所以是前 i 中的 dp[i][  (j+num)%3 ]

2、要么就是考虑加入了这个数 num，那么就是 dp[i][j] + num，因为对于新的余数（j+num)%3 的最大和而言，应该是 余数为 j 前i 个数的最大和 加上了新的这个数 num，组成新的 对应余数 最大和

初始条件，dp[0][0] = 0，当没有数的时候，余数为0的最大和肯定是0，但是没有数的时候，余数为1，和2 的最大和是不存在的，也就是设为最小值，为了后面更新最大值来处理的。

上面用到的是，二维数组来记录，为了节省内存，我们可以用两个一维数组，一个一维数组每次更新，最后把值保留给另一个数组，这样子就实现了和上面用二维数组相同功能，但节省了内存。

AC代码（C++）

#define INF 0x3f3f3f3f

class Solution {
public:
    int maxSumDivThree(vector& nums) {
        int dp[3], g[3];
        dp[0] = 0;
        dp[1] = dp[2] = -INF;

        for(auto num : nums)
        {
            for(int i = 0;i < 3;i++)
            {
                g[(i + num)%3] = max(dp[(i + num)%3], dp[i] + num);
            }

            for(int i = 0;i < 3;i++) 
                dp[i] = g[i];
        }

        return dp[0];
    }
};

 

---

4.推箱子（Minimum Moves to Move A Box to Their Target Location）

题目链接

https://leetcode-cn.com/problems/minimum-moves-to-move-a-box-to-their-target-location/

题意

「推箱子」是一款风靡全球的益智小游戏，玩家需要将箱子推到仓库中的目标位置。

游戏地图用大小为 n * m 的网格 grid 表示，其中每个元素可以是墙、地板或者是箱子。

现在你将作为玩家参与游戏，按规则将箱子 'B' 移动到目标位置 'T' ：

• 玩家用字符 'S' 表示，只要他在地板上，就可以在网格中向上、下、左、右四个方向移动。
• 地板用字符 '.' 表示，意味着可以自由行走。
• 墙用字符 '#' 表示，意味着障碍物，不能通行。 
• 箱子仅有一个，用字符 'B' 表示。相应地，网格上有一个目标位置 'T'。
• 玩家需要站在箱子旁边，然后沿着箱子的方向进行移动，此时箱子会被移动到相邻的地板单元格。记作一次「推动」。
• 玩家无法越过箱子。

返回将箱子推到目标位置的最小 推动 次数，如果无法做到，请返回 -1。

示例 ：示例中有图示，具体看题目链接

提示：

• 1 <= grid.length <= 20
• 1 <= grid[i].length <= 20
• grid 仅包含字符 '.', '#',  'S' , 'T', 以及 'B'。
• grid 中 'S', 'B' 和 'T' 各只能出现一个。

 

解题分析

BFS的题，同时记录人和箱子的位置。

由于本人对BFS不是很会，因此参考了周赛排名第11的 wnjxyk 大佬的代码。

根据代码的意思，就是要同时记录人和箱子的位置，遍历人BFS，判断是否可以人移动到下一个位置（四个方向），如果可以人就移动

当人与箱子位置重合，说明人推动了箱子，那么箱子同人移动的方向，箱子也移动，此时也要判断箱子是否能移动到下一个位置。

剩下就是基本的额BFS操作。

AC代码（ C++）

struct Node{
    Node(){}
    Node(int x0, int y0, int bx0, int by0){
        x = x0; y = y0;
        bx = bx0; by = by0;
    }
    int x, y;
    int bx, by;
    friend bool operator < (const Node a, const Node b){
        if (a.x != b.x) return a.x < b.x;
        if (a.y != b.y) return a.y < b.y;
        if (a.bx != b.bx) return a.bx < b.bx;
        return a.by < b.by;
    }
};

int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};

queue que;
map inQue;
map dist;

class Solution {
public:
    
    
    int minPushBox(vector>& grid) {
        int n = grid.size(), m = grid[0].size();
        
        while(!que.empty()) que.pop();
        dist.clear();
        inQue.clear();
        
        int ans = -1;
        int px, py, bx, by, tx, ty;
        for (int i = 0; i < n; ++i){
            for(int j = 0; j < m; ++j){
                if (grid[i][j] == 'S') px = i, py = j, grid[i][j] = '.';
                if (grid[i][j] == 'B') bx = i, by = j, grid[i][j] = '.';
                if (grid[i][j] == 'T') tx = i, ty = j, grid[i][j] = '.';
            }
        }
        
        // printf("%d %d\n", px, py);
        // printf("%d %d\n", bx, by);
        // printf("%d %d\n", tx, ty);
        
        que.push(Node(px, py, bx, by));
        inQue[Node(px, py, bx, by)] = true;
        dist[Node(px, py, bx, by)] = 0;
        
        while(!que.empty()){
            int px = que.front().x, py = que.front().y, bx = que.front().bx, by = que.front().by;
            int cur = dist[que.front()], delta = 0;
            
            inQue[que.front()] = false;
            que.pop();
            
            
            
            if (bx == tx && by == ty){
                if (ans == -1 || ans > cur) ans = cur;
                continue;
            }
            
            for (int k = 0; k < 4; ++k){
                delta = 0;
                int nx = px + dx[k], ny = py + dy[k];
                int nbx = bx, nby = by;
                
                if (nx >= n || nx < 0 || ny >= m || ny < 0) continue;
                if (grid[nx][ny] == '#') continue;
                
                if (nx == bx && ny == by){
                    nbx = bx + dx[k];
                    nby = by + dy[k];
                    delta = 1;
                    if (nbx >= n || nbx < 0 || nby >= m || nby < 0) continue;
                    if (grid[nbx][nby] == '#') continue;
                }
                
                Node now = Node(nx, ny, nbx, nby);
                if (dist.count(now) == 0 || dist[now] > cur + delta){
                    
                    dist[now] = cur + delta;
                    // if (delta == 1) printf("> %d %d %d %d => %d\n", nx, ny, nbx, nby, dist[now] );
                    // if (nbx == 3 && nby == 3) printf(">* %d %d %d %d (%d %d %d %d)=> %d %d\n", nx, ny, nbx, nby, px, py, bx,by,delta,dist[now] );
                    if (!inQue[now]){
                        inQue[now] = true;
                        que.push(now);
                    }
                }
            }
        }
        
        return ans;
    }
};