LeetCode 1463: Cherry Pickup II
Code Review
This initializes all members to zero:
    int map_cherries[70][70][70] = {};

Then you manually initialize the map again:
        std::memset(map_cherries, -1, sizeof(map_cherries));


This is not doing what you think it is doing.
        std::memset(map_cherries, -1, sizeof(map_cherries));

This is initializing every byte to -1. Each integer is probably 4 bytes (or more long). So each byte is being set to -1. Now it happens that in 2's compliment this work (if you set all bytes to -1 then the integer is also -1). But there is no guarantee in the standard that C++ will use 2's compliment as the representation of integers (even if it is very common).

This returns a const inline int!
    const inline int depth_first_search(
        ...
    )

I know it is legal but come on. That's hard to read. If you have to add inline put it first so we can make the return type readable.
    inline const int depth_first_search(...)

Now we can see that the return type is const int. That still does not make that much sense. Just return the an int.
The inline keyword has no functional use to the C++ compiler (the compiler writers stopped believing developers had a good idea about this years ago). So this keyword has no effect on the code being generated. The only reason it is used is when the function is defined in the header file but not in the class it is needed to let the linker know there may be multiple definitions (as it may have been included multiple times). But when the method is part of the class this is redundant as it is automatically inline.
The general consensus is don't use inline unless you need to use inline. The only time you need to use inline is for method definitions in header files where they are not defined as part of the class.
    int depth_first_search(...)


If you don't intend to modify a reference pass it by const reference.
    const inline int depth_first_search(
        std::vector&lt;std::vector&lt;int&gt;&gt; &amp;grid,
         ...
    )

This will prevent mistakes where you accidentally modify the data.

Nice short circuit here.
        if (row == row_length) {
            return 0;
        }

But here: Not sure this will ever happen!
Nice optimization. I like it.
        if (map_cherries[row][left_robot][right_robot] != -1) {
            return map_cherries[row][left_robot][right_robot];
        }

It took me a while to spot this as an optimization. I would add a comment on WHY this is working and how this is a shortcut optimization.

This if statement is a bit complex. I would split it into a couple of statements.
                if (curr_left_robot &gt; -1 and curr_left_robot &lt; col_length and curr_right_robot &gt; -1 and curr_right_robot &lt; col_length) {


                 // You can do in 1 statement if you want.
                 // But I like the use of a function here as it tells you
                 // what the test is and thus documents the code is doing.
                 if (!inBounds(curr_left_robot)) {
                     continue;
                 }
                 if (!inBounds(curr_right_robot)) {
                     continue;
                 }


Sure that's legal.
        return map_cherries[row][left_robot][right_robot] = max_cherries + cherries;

Makes the line very long though.
I would split into three lines;
        // Add cherries in this row to the previous row.            
        cherries += max_cherries;

        map_cherries[row][left_robot][right_robot] = cherries;
        return cherries;