Optimal Strategy for a Game | Set 3

/*package whatever //do not write package name here */
import java.util.*;

class GFG {

  static class Pair<K, V> {
    K key;
    V value;

    public Pair(K first, V second)
    {
      this.key = first;
      this.value = second;
    }
  }

  // Calculates the maximum score
  // possible for P1 If only the
  // bags from beg to ed were available
  static Pair<Integer, String>
    maxScore(int []money, int beg, int ed)
  {

    // Length of the game
    int totalTurns = money.length;

    // Which turn is being played
    int turnsTillNow
      = beg + ((totalTurns - 1) - ed);

    // Base case i.e last turn
    if (beg == ed) {

      // if it is P1's turn
      if (turnsTillNow % 2 == 0)
        return new Pair<Integer, String>(
        money[beg], "L");

      // if P2's turn
      else
        return new Pair<Integer, String>(0, "L");
    }

    // Player picks money from
    // the left end
    Pair<Integer, String> scoreOne
      = maxScore(money, beg + 1, ed);

    // Player picks money from
    // the right end
    Pair<Integer, String> scoreTwo
      = maxScore(money, beg, ed - 1);

    if (turnsTillNow % 2 == 0) {

      // if it is player 1's turn then
      // current picked score added to
      // his total. choose maximum of
      // the two scores as P1 tries to
      // maximize his score.
      if (money[beg] + scoreOne.key
          > money[ed] + scoreTwo.key) {
        return new Pair<Integer, String>(money[beg] + scoreOne.key,"L" + scoreOne.value);
      }
      else
        return new Pair<Integer, String>(
        money[ed] + scoreTwo.key,
        "R" + scoreTwo.value);
    }

    // if player 2's turn don't add
    // current picked bag score to
    // total. choose minimum of the
    // two scores as P2 tries to
    // minimize P1's score.
    else {

      if (scoreOne.key < scoreTwo.key)
        return new Pair<Integer, String>(
        scoreOne.key, "L" + scoreOne.value);
      else
        return new Pair<Integer, String>(
        scoreTwo.key + 110,
        "R" + scoreTwo.value);
    }


  }

  public static void main(String[] args)
  {
    int[] ar = { 10, 80, 90, 30 };

    int arraySize = ar.length;

    int []bags = new int[arraySize];

    // Function Calling
    Pair<Integer, String> ans
      = maxScore(bags, 0, bags.length - 1);
    System.out.println(ans.key + " " + ans.value);
  }
}

// This code is contributed by aadityaburujwale.

// Java Implementation
public class Main
{
    static int maxSize = 3000;
      
    // dp(i, j) is the best
    // score possible if only
    // the bags from i, j were
    // present.
    static int[][] dp = new int[maxSize][maxSize];
   
    // leftBag(i, j) is 1 if in the
    // optimal game the player picks
    // the leftmost bag when only the
    // bags from i to j are present.
    static boolean[][] leftBag = new boolean[maxSize][maxSize];
  
    // Function to calculate the maximum
    // value
    static int maxScore(int[] money)
    {
      
        // we will fill the dp table
        // in a bottom-up manner. fill
        // all states that represent
        // lesser number of bags before
        // filling states that represent
        // higher number of bags.
        // we start from states dp(i, i)
        // as these are the base case of
        // our DP solution.
        int n = money.length;
        int totalTurns = n;
  
        // turn = 1 if it is player 1's
        // turn else 0. Who gets to pick
        // the last bag(bottom-up so we
        // start from last turn)
        boolean turn = (totalTurns % 2 == 0) ? false : true;
  
        // if bag is picked by P1 add it
        // to the ans else 0 contribution
        // to score.
        for (int i = 0; i < n; i++) {
            dp[i][i] = turn ? money[i] : 0;
            leftBag[i][i] = true;
        }
  
        // 2nd last bag is picked by
        // the other player.
        turn = !turn;
  
        // sz represents the size
        // or number of bags in
        // the state dp(i, i+sz)
        int sz = 1;
  
        while (sz < n) {
  
            for (int i = 0; i + sz < n; i++) {
                int scoreOne = dp[i + 1][i + sz];
                int scoreTwo = dp[i][i + sz - 1];
  
                // First player
                if (turn) {
                    dp[i][i + sz] = Math.max(money[i] + scoreOne, money[i + sz] + scoreTwo);
  
                    // if leftBag has more profit
                    if (money[i] + scoreOne > money[i + sz] + scoreTwo)
                        leftBag[i][i + sz] = true;
  
                    else
                        leftBag[i][i + sz] = false;
                }
  
                // second player
                else {
                    dp[i][i + sz] = Math.min(scoreOne, scoreTwo);
  
                    if (scoreOne < scoreTwo)
                        leftBag[i][i + sz] = true;
  
                    else
                        leftBag[i][i + sz] = false;
                }
            }
  
            // Give turn to the
            // other player.
            turn = !turn;
  
            // Now fill states
            // with more bags.
            sz++;
        }
  
        return dp[0][n - 1];
    }
  
    // Using the leftBag matrix,
    // generate the actual game
    // moves that lead to the score.
    static String getMoves(int n)
    {
        String moves = "";
        int left = 0, right = n - 1;
  
        while (left <= right) {
  
            // if the bag is picked from left
            if (leftBag[left][right]) {
                moves = moves + 'L';
                left++;
            }
  
            else {
                moves = moves + 'R';
                right--;
            }
        }
        return moves;
    }
    
    public static void main(String[] args) {
        for(int i = 0; i < maxSize; i++)
        {
            for(int j = 0; j < maxSize; j++)
            {
                dp[i][j] = 0;
                leftBag[i][j] = false;
            }
        }
        int[] ar = { 10, 80, 90, 30 };
        int arraySize = ar.length;
      
        int[] bags = ar;
        int ans = maxScore(bags);
      
        System.out.print(ans + " " + getMoves(bags.length));
    }
}

// This code is contributed by divyes072019.