Initializing std::memset

Question

I'm using std::memset to solve a LeetCode problem copied here. Currently, map_cherries has been initialized as:

map_cherries[70][70][70] = {}
...
std::memset(map_cherries, -1, sizeof(map_cherries));

Is there a way to set up dimensions and values of map_cherries at the same time, or maybe any better/alternative way to do that? Thank you!

Problem

Given a rows x cols matrix grid representing a field of cherries. Each cell in grid represents the number of cherries that you can collect.

You have two robots that can collect cherries for you, Robot #1 is located at the top-left corner (0,0) , and Robot #2 is located at the top-right corner (0, cols-1) of the grid.

Return the maximum number of cherries collection using both robots by following the rules below:

• From a cell (i,j) , robots can move to cell (i+1, j-1) , (i+1, j) or (i+1, j+1) .
• When any robot is passing through a cell, It picks it up all cherries, and the cell becomes an empty cell (0).
• When both robots stay on the same cell, only one of them takes the cherries.
• Both robots cannot move outside of the grid at any moment.
• Both robots should reach the bottom row in the grid.

Example 1:

Input: grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]]
Output: 24

Explanation: Path of robot #1 and #2 are described in color green and blue respectively.
Cherries taken by Robot #1, (3 + 2 + 5 + 2) = 12 .

Cherries taken by Robot #2, (1 + 5 + 5 + 1) = 12 . Total of cherries: 12 + 12 = 24 .

Example 2:

Input: grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]]

Output: 28

Explanation: Path of robot #1 and #2 are described in color green and blue respectively.
Cherries taken by Robot #1, (1 + 9 + 5 + 2) = 17 .

Cherries taken by Robot #2, (1 + 3 + 4 + 3) = 11 .

Total of cherries: 17 + 11 = 28 .

Constraints:

• rows == grid.length
• cols == grid[i].length
• 2 <= rows, cols <= 70
• 0 <= grid[i][j] <= 100

Attempt

#include <cstdint>
#include <vector>
#include <cstring>

struct Solution {
    int map_cherries[70][70][70] = {};

    int cherryPickup(std::vector<std::vector<int>>& grid) {
        std::memset(map_cherries, -1, sizeof(map_cherries));
        const std::size_t row_length = grid.size();
        const std::size_t col_length = grid[0].size();
        return depth_first_search(grid, row_length, col_length, 0, 0, col_length - 1);
    }

private:
    int depth_first_search(
        std::vector<std::vector<int>>& grid,
        const std::size_t row_length,
        const std::size_t col_length,
        int row,
        int left_robot,
        int right_robot
    ) {
        if (row == row_length) {
            return 0;
        }

        if (map_cherries[row][left_robot][right_robot] != -1) {
            return map_cherries[row][left_robot][right_robot];
        }

        int max_cherries = 0;

        for (int left = -1; left < 2; left++) {
            for (int right = -1; right < 2; right++) {
                const int curr_left_robot = left_robot + left;
                const int curr_right_robot = right_robot + right;

                if (curr_left_robot > -1 and curr_left_robot < col_length and curr_right_robot > -1 and curr_right_robot < col_length) {
                    max_cherries = std::max(max_cherries, depth_first_search(
                                                grid,
                                                row_length,
                                                col_length,
                                                row + 1,
                                                curr_left_robot,
                                                curr_right_robot
                                            ));
                }
            }
        }

        int total_cherries = grid[row][left_robot];

        if (left_robot != right_robot) {
            total_cherries += grid[row][right_robot];
        }

        total_cherries += max_cherries;
        return map_cherries[row][left_robot][right_robot] = total_cherries;
    }
};

Inputs

[[3,1,1],[2,5,1],[1,5,5],[2,1,1]]
[[1,0,0,3],[0,0,0,3],[0,0,3,3],[9,0,3,3]]
[[1,10,0,3,86,40],[0,0,0,3,86,40],[0,0,3,3,86,40],[9,0,3,3,86,40], [1,0,40,3,86,40],[0,22,0,3,86,40],[99,0,3,3,86,40],[9,0,3,3,86,40]]

Outputs

24
22
819

References

• Problem

• Discuss

• Solution

Answer 1

One way would be like this:

auto map_cherries = std::vector(70, std::vector(70, std::vector(70, -1)));

Only works starting from c++17.