# Solving Leetcode Interviews in Seconds with AI: Cherry Pickup II


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1463" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given a rows x cols matrix grid representing a field of cherries where grid[i][j] represents the number of cherries that you can collect from the (i, j) cell. 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).  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 passes through a cell, It picks up all cherries, and the cell becomes an empty cell. When both robots stay in the same cell, only one takes the cherries. Both robots cannot move outside of the grid at any moment. Both robots should reach the bottom row in 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  

	# Explanation
	Here's the solution to the cherry pickup problem, focusing on efficiency and clarity.

*   **Dynamic Programming:** Utilize dynamic programming to store and reuse the maximum cherries collected from intermediate states (row, robot1's column, robot2's column).
*   **State Definition:** Define the state as `dp[row][col1][col2]`, representing the maximum cherries collected until row `row` with robot 1 at column `col1` and robot 2 at column `col2`.
*   **Base Case & Transition:** Initialize the base cases and iterate through the grid. Calculate the next state by considering all possible movements of both robots.

*   **Runtime Complexity:** O(rows * cols * cols)
*   **Storage Complexity:** O(rows * cols * cols)

	
	# Code
	```python
	def cherryPickup(grid):
    rows = len(grid)
    cols = len(grid[0])

    # dp[row][col1][col2] stores the maximum cherries collected until row 'row'
    # with robot 1 at column 'col1' and robot 2 at column 'col2'.
    dp = {}

    def solve(row, col1, col2):
        if row == rows:
            return 0  # Base case: Reached the end

        if (row, col1, col2) in dp:
            return dp[(row, col1, col2)]

        # Check if the robots are out of bounds
        if not (0 <= col1 < cols and 0 <= col2 < cols):
            return float('-inf')

        # Calculate the cherries collected at the current cells
        cherries = grid[row][col1]
        if col1 != col2:
            cherries += grid[row][col2]

        # Explore all possible moves for both robots
        max_cherries = float('-inf')
        for move1 in [-1, 0, 1]:
            for move2 in [-1, 0, 1]:
                new_col1 = col1 + move1
                new_col2 = col2 + move2
                max_cherries = max(max_cherries, solve(row + 1, new_col1, new_col2))

        # Update DP table and return the result
        dp[(row, col1, col2)] = cherries + max_cherries
        return cherries + max_cherries

    return solve(0, 0, cols - 1)
	```