Google Kickstart Round A 2021-Rabbit House

Question

谁能告诉我我的代码有什么问题？我已经通过了示例测试，但我无法通过两个实际的测试用例..

我的算法是dfs：

1. 从一个矩阵的第一个元素到最后，检查一个元素与相邻的上、下、左、右的差值是否小于等于1

2. 如果是，则通过 如果不是，则将最小数量的块添加到检查元素或相邻元素中以产生差异 1 并将计数增加您添加的最小块数

3. 如何将最小数量添加到哪个元素： 只需选择产生绝对差异所需的最小元素 1

4. 例如，您将 aij 与较低的 ai+1j 进行了比较： 如果您添加到检查元素是因为它更小，则再次从 aij+1、aij-1、ai-1j 开始递归。因为现在 aij 和 ai+1j 之间的差异符合您需要检查的标准是否与其他相邻的 否则从 ai+1j 开始递归

5. 对下、上、左、右执行上述步骤

6.返回计数

问题出在： https://codingcompetitions.withgoogle.com/kickstart/round/0000000000436140/000000000068cb14

问题 芭芭拉去年在学校取得了很好的成绩，所以她的父母决定送她一只宠物兔子。她非常兴奋，为兔子建造了一个房子，可以看作是一个 R 行 C 列的 2D 网格。

兔子喜欢跳跃，所以芭芭拉在网格的几个单元格上堆放了几个盒子。每个盒子都是一个具有相同尺寸的立方体，它们与网格中一个单元格的尺寸完全匹配。

但是，芭芭拉很快意识到，兔子跳的高度超过 1 格可能很危险，因此她决定通过对房子进行一些调整来避免这种情况。对于每一对相邻的单元格，芭芭拉希望它们的绝对高度差最多为 1 个盒子。如果两个单元格共享一个公共边，则认为它们是相邻的。

由于所有盒子都是强力胶粘的，Barbara 无法移除最初存在的任何盒子，但她可以在它们上面添加盒子。她可以添加任意数量的框，添加任意数量的单元格（可能为零）。帮助他确定要添加的最少盒子总数是多少，这样兔子的房子就安全了。

输入 输入的第一行给出了测试用例的数量，T.T 测试用例紧随其后。

每个测试用例都以包含两个整数 R 和 C 的行开头。

然后，接下来是 R 行，每行都有 C 个整数。第 i 行的第 j 个整数 Gi,j 表示位于网格第 i 行第 j 列的单元格上最初有多少个框。

输出 对于每个测试用例，输出一行包含 Case #x: y，其中 x 是测试用例编号（从 1 开始），y 是要添加的最小盒子数，以便兔子的房子是安全的。

限制 内存限制：1 GB。 1≤T≤100。 0≤Gi,j≤2⋅106，对于所有 i, j。 测试集 1 时间限制：20秒。 1≤R，C≤50。 测试集 2 时间限制：40秒。 1≤R,C≤300。

这是我的 C++ 代码：

#include <iostream>
#include <string>
#include <cstdlib>
#include <vector>

using namespace std;

void solve(vector<vector<int>> &v,
    int ii, int jj,
    int r, int c, int& cnt) {
    if (ii<0 || ii>r - 1 || jj<0 || jj>c - 1) return;
    int ads;
    if (ii + 1 < r) {
        if (abs(v[ii][jj] - v[ii + 1][jj]) > 1) {
            ads = min(abs(v[ii + 1][jj] - v[ii][jj] - 1),
                abs(v[ii + 1][jj] - v[ii][jj] + 1));
                cnt += ads;
            if (v[ii + 1][jj] < v[ii][jj]) {
                v[ii + 1][jj] += ads;
                 solve(v, ii + 1, jj, r, c, cnt);
            }
            else {
                v[ii][jj] += ads;
                solve(v, ii, jj - 1, r, c, cnt);
                solve(v, ii, jj + 1, r, c, cnt);
                solve(v, ii - 1, jj, r, c, cnt);
            }
        }
    }
    if (ii - 1 > -1) {
        if (abs(v[ii][jj] - v[ii - 1][jj]) > 1) {
            ads = min(abs(v[ii - 1][jj] - v[ii][jj] - 1),
                abs(v[ii - 1][jj] - v[ii][jj] + 1));
                cnt += ads;
            if (v[ii - 1][jj] < v[ii][jj]) {
                v[ii - 1][jj] += ads;
                solve(v, ii - 1, jj, r, c, cnt);
            }
            else {
                v[ii][jj] += ads;
                solve(v, ii, jj - 1, r, c, cnt);
                solve(v, ii, jj + 1, r, c, cnt);
                solve(v, ii + 1, jj, r, c, cnt);
            }
        }
    }
    if (jj - 1 > -1) {
        if (abs(v[ii][jj] - v[ii][jj - 1]) > 1) {
            ads = min(abs(v[ii][jj - 1] - v[ii][jj] - 1),
                abs(v[ii][jj - 1] - v[ii][jj] + 1));
                cnt += ads;
            if (v[ii][jj - 1] < v[ii][jj]) {
                v[ii][jj - 1] += ads;
                solve(v, ii, jj - 1, r, c, cnt);
            }
            else {
                v[ii][jj] += ads;
                solve(v, ii, jj + 1, r, c, cnt);
                solve(v, ii - 1, jj, r, c, cnt);
                solve(v, ii + 1, jj, r, c, cnt);
            }
        }
    }
    if (jj + 1 < c) {
        if (abs(v[ii][jj] - v[ii][jj + 1]) > 1) {
            ads = min(abs(v[ii][jj + 1] - v[ii][jj] - 1),
                abs(v[ii][jj + 1] - v[ii][jj] + 1));
                cnt += ads;
            if (v[ii][jj + 1] < v[ii][jj]) {
                v[ii][jj + 1] += ads;
                solve(v, ii, jj + 1, r, c, cnt);
            }
            else {
                v[ii][jj] += ads;
                solve(v, ii, jj - 1, r, c, cnt);
                solve(v, ii - 1, jj, r, c, cnt);
                solve(v, ii + 1, jj, r, c, cnt);
            }
        }
    }
    return;
}

int main() {
        // your code goes here
        int t;
        cin>>t;
        int r, c, m;
        for (int i = 0; i < t; i++) {
            cin >> r >> c;
            vector<vector<int>> v(r,vector<int>(c,0));
            for (int j=0;j<r;j++){
                for (int k=0;k<c;k++){
                    cin>>m;
                    v[j][k]=m;
                }
            }
            int cnt=0;
            for (int j=0;j<r;j++){
                for (int k=0;k<c;k++){
                    solve(v,j,k,r,c,cnt);
                }
            }
            cout << "Case #" << i + 1 << ": " << cnt<<endl;
        }
        return 0;
}

我已经通过了示例案例： 样本 样本输入 3 1 3 3 4 3 1 3 3 0 0 3 3 0 0 0 0 2 0 0 0 0 样本输出 案例#1：0 案例#2：3 案例#3：4

但不是实际的测试用例...非常感谢任何帮助！

Answer 1

正如在 cmets 中已经指出的那样，解决方案是从最高的盒子开始，并在需要时设置其邻居的高度值。

简单的实现是 O(n^2)。

按照 cmets 中的建议，我尝试使用最大堆。然而，这个解决方案不够快（TLE），因为一旦更新了矩阵的高度值，就必须重建最大堆。我可能会改进这个实现。我更喜欢另一种方式。

最后，我通过使用带有专用比较器的std::multiset 获得了足够快的解决方案。

当一个单元格的高度被更新时，它会被移除并重新插入到多重集中，每个操作都是 O(logn)。

全局复杂度：O(n logn)，其中n 是矩阵的元素数 `n = R * C*。

#include <iostream>
#include <string>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <set>
#include <iterator>

struct Coord {
    int x;
    int y;
    friend std::ostream& operator<<(std::ostream& os, const Coord& c) {
        os << "(" << c.x << ", " << c.y << ")";
        return os;
    }
};

long long int solution (std::vector<std::vector<int>>& heights, int R, int C) {
    std::vector<Coord> depl = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    long long int count = 0;
    auto Comp = [&heights] (const Coord& c0, const Coord& c1) {
        if (heights[c0.x][c0.y] == heights[c1.x][c1.y]) {
            if (c0.x == c1.x) return (c0.y < c1.y);
            return (c0.x < c1.x);
        }
        return heights[c0.x][c0.y] > heights[c1.x][c1.y];
    };
    
    std::multiset<Coord, decltype(Comp)> Cells (Comp);
    for (int i = 0; i < R; ++i) {
        for (int j = 0; j < C; ++j) {
            Cells.insert ({i, j});
        }
    }

    auto isValid = [&] (int i, int j) {
        return (i >= 0) && (i < R) && (j >= 0) && (j < C);
    };
    
    while (Cells.size() > 1) {
        auto n = Cells.size();
        auto top = Cells.begin();
        auto pivot = *top;
        int h_ref = heights[pivot.x][pivot.y];
        Cells.erase (top);
        
        for (auto& d: depl) {
            int x = pivot.x + d.x;
            int y = pivot.y + d.y;
            if (!isValid(x, y)) continue;
            int h = heights[x][y];
            if (h <= h_ref - 2) {
                count += h_ref - h - 1;
                Cells.erase({x, y});
                heights[x][y] = h_ref - 1;
                Cells.insert({x, y});
            }
        }
    }
    return count;
}

int main() {
    std::ios_base::sync_with_stdio(false); 
    std::cin.tie(NULL); 
    std::cout.tie(0);
    int nt;
    std::cin >> nt;
    for (int t = 1; t <= nt; t++) {
        int R, C;
        std::cin >> R >> C;
        std::vector<std::vector<int>> v(R, std::vector<int>(C));
        for (int j = 0; j < R; j++) {
            for (int k = 0; k < C; k++) {
                int m;
                std::cin >> m;
                v[j][k] = m;
            }
        }
        auto cnt = solution (v, R, C);
        std::cout << "Case #" << t << ": " << cnt << std::endl;
    }
    return 0;
}