Ninja's training

// Bruth Force Approach -> Recursion + Memoization
// TC - O(2^N)
// SC - O(N)   Stack Space


import java.util.*;

public class Solution {
    public static int ninjaTraining(int n, int points[][]) {

        // Write your code here..
        int[][] dp = new int[n][4];
        for (int[] x : dp) {
            Arrays.fill(x, -1);
        }
        return helper(n-1, points, 0, dp);
    }

    public static int helper
    (
        int n, 
        int[][] points, 
        int check,
        int[][] dp
    ) {
        if (n < 0) {
            return 0;
        }

        if (dp[n][check] != -1) {
            return dp[n][check];
        }
        int first = 0;
        int second = 0;
        int third = 0;
        if (check != 1) {
            first = points[n][0] + helper(n-1, points, 1, dp);
        }
        if (check != 2) {
            second = points[n][1] + helper(n-1, points, 2, dp);
        }
        if (check != 3) {
            third = points[n][2] + helper(n-1, points, 3, dp);
        }

        return dp[n][check] = Math.max(first, Math.max(second, third));

    }

}