# Solving Leetcode Interviews in Seconds with AI: Maximum Multiplication Score


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3290" 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 an integer array a of size 4 and another integer array b of size at least 4. You need to choose 4 indices i0, i1, i2, and i3 from the array b such that i0 < i1 < i2 < i3. Your score will be equal to the value a[0] * b[i0] + a[1] * b[i1] + a[2] * b[i2] + a[3] * b[i3]. Return the maximum score you can achieve.   Example 1:  Input: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7] Output: 26 Explanation: We can choose the indices 0, 1, 2, and 5. The score will be 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26.  Example 2:  Input: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4] Output: -1 Explanation: We can choose the indices 0, 1, 3, and 4. The score will be (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1.    Constraints:  a.length == 4 4 <= b.length <= 105 -105 <= a[i], b[i] <= 105  

	# Explanation
	Here's the solution to find the maximum score, along with an explanation of the approach:

**High-Level Approach**

*   **Dynamic Programming:** Utilize dynamic programming to store and reuse intermediate results. The state `dp[i][j]` represents the maximum score achievable using the first `i` elements of `a` and the first `j` elements of `b`.
*   **State Transition:** For each element `b[j]`, we have two choices: either include it in the score or exclude it. If we include it, the score is `a[i-1] * b[j] + dp[i-1][j-1]`. If we exclude it, the score is `dp[i][j-1]`. We take the maximum of these two scores.
*   **Base Case:** `dp[0][j]` is 0 for all `j` because if we haven't used any elements from `a`, the score is always 0.

**Complexity Analysis**

*   Runtime Complexity: O(a.length * b.length) which simplifies to O(b.length) since a.length is constant 4.
*   Storage Complexity: O(a.length * b.length) which simplifies to O(b.length) since a.length is constant 4.

	
	# Code
	```python
	def max_score(a, b):
    """
    Calculates the maximum score achievable by selecting 4 indices from array b
    and multiplying them with elements from array a.

    Args:
        a (list of int): An array of integers of size 4.
        b (list of int): An array of integers of size at least 4.

    Returns:
        int: The maximum score achievable.
    """

    n = len(a)
    m = len(b)

    dp = [[0] * (m + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        for j in range(i, m + 1):
            dp[i][j] = dp[i][j - 1]  # Exclude b[j-1]
            dp[i][j] = max(dp[i][j], a[i - 1] * b[j - 1] + dp[i - 1][j - 1])  # Include b[j-1]

    return dp[n][m]
	```