Google Kickstart Round A 2021-Rabbit House - algorithm

Question

could anyone tell me what's wrong with my code? I've passed the sample tests, but I couldn't pass both of the actual test cases..
My algorithm is to dfs:
Going from the first element of a matrix till the end, check if the difference between an element and the adjacent upper, lower, left, right is less than or equal to 1
If so then pass
If not then add the minimum number of blocks to either the checking element or the adjacent one to make the difference 1
And increase the count by the minimum number of blocks you added
How to add the minimum number to which element:
Just choose the smaller element the minimum required to make the absolute difference 1
Say for example, you compared aij with the lower one ai+1j:
If you added to the checking element because it was smaller, then recurse again starting at aij+1, aij-1, ai-1j. Because now the difference between aij and ai+1j meets the criteria you need to check if it is so with other adjacent ones
Otherwise recurse starting at ai+1j
Do the stepe above for lower, upper, left, right
6.return count
Here is the problem:
https://codingcompetitions.withgoogle.com/kickstart/round/0000000000436140/000000000068cb14
Problem
Barbara got really good grades in school last year, so her parents decided to gift her with a pet rabbit. She was so excited that she built a house for the rabbit, which can be seen as a 2D grid with R rows and C columns.
Rabbits love to jump, so Barbara stacked several boxes on several cells of the grid. Each box is a cube with equal dimensions, which match exactly the dimensions of a cell of the grid.
However, Barbara soon realizes that it may be dangerous for the rabbit to make jumps of height greater than 1 box, so she decides to avoid that by making some adjustments to the house. For every pair of adjacent cells, Barbara would like that their absolute difference in height be at most 1 box. Two cells are considered adjacent if they share a common side.
As all the boxes are superglued, Barbara cannot remove any boxes that are there initially, however she can add boxes on top of them. She can add as many boxes as she wants, to as many cells as she wants (which may be zero). Help hew determine what is the minimum total number of boxes to be added so that the rabbit's house is safe.
Input
The first line of the input gives the number of test cases, T. T test cases follow.
Each test case begins with a line containing two integers R and C.
Then, R lines follow, each with C integers. The j-th integer on i-th line, Gi,j, represents how many boxes are there initially on the cell located at the i-th row and j-th column of the grid.
Output
For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is the minimum number of boxes to be added so that the rabbit's house is safe.
Limits
Memory limit: 1 GB.
1≤T≤100.
0≤Gi,j≤2⋅106, for all i, j.
Test Set 1
Time limit: 20 seconds.
1≤R,C≤50.
Test Set 2
Time limit: 40 seconds.
1≤R,C≤300.
This is my code in 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;
}
I've passed the sample cases:
Sample
Sample Input
3
1 3
3 4 3
1 3
3 0 0
3 3
0 0 0
0 2 0
0 0 0
Sample Output
Case #1: 0
Case #2: 3
Case #3: 4
but not the actual test cases...any help much appreciated!!

Answer 1

As already indicated in comments, the solution is to start from the highest box, and to set the height value of its neighbours if needed.
A naive implementation is O(n^2).
As suggested in comments, I tried to use a max-heap. However, this solution was not fast enough (TLE) because once the height values of the matrix are updated, the max-heap has to be rebuilt. I might be posible to improve this implementation. I prefered to follow another way.
Finally, I got a fast enough solution by using a std::multiset, with a dedicated comparator.
When the height of a cell is updated, it is removed and reinserted in the multiset, each operation being O(logn).
Global complexity: O(n logn), where n is the number of elements `n = R * C* of the matrix.
#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;
}