Minimum cost to delete characters from String A to remove any subsequence as String B

// Java program for the above approach
import java.util.*;

public class GFG {

  // Array for memoization
  static int dp[][][] = new int[101][101][2];

  // Recursive function to calculate
  // the minimum cost using dynamic programming
  static int minCostUtil(String a, int n, String b, int m,
                         int[] c, int removed)
  {

    // Base case reached the end of string
    if (n == 0 || m == 0) {

      // Removed 0 characters
      // return high (+)ve value
      if (removed == 0)
        return 99999;
      return 0;
    }

    // Return pre-calculated value
    if (dp[n][m][removed > 0 ? 1 : 0] != -1)
      return dp[n][m][removed > 0 ? 1 : 0];

    // If characters match return the minimum of
    // 1. Removing the character from A and
    // adding the cost
    // 2. Moving forward to remove some other
    // character and decrease the counter as
    // this character will not be removed.
    if (a.charAt(n - 1) == b.charAt(m - 1)) {
      dp[n][m][removed > 0 ? 1 : 0]
        = Math.min(c[n - 1]
                   + minCostUtil(a, n - 1, b, m,
                                 c, removed),
                   minCostUtil(a, n - 1, b, m - 1,
                               c, removed - 1));
      return dp[n][m][removed > 0 ? 1 : 0];
    }

    // If no match then move through string
    // A and try removing some other
    // character which matches, i.e can be
    // part of the subsequence that is equal to B
    else
      return dp[n][m][removed > 0 ? 1 : 0]
      = minCostUtil(a, n - 1, b, m, c, removed);
  }

  // Function to calculate minimum cost
  static int minCost(String a, String b, int[] c)
  {
    for (int i = 0; i < 101; i++) {
      for (int j = 0; j < 101; j++) {
        for (int k = 0; k < 2; k++) {
          dp[i][j][k] = -1;
        }
      }
    }
    return minCostUtil(a, a.length(), b, b.length(), c,
                       b.length());
  }

  // Driver code
  public static void main(String args[])
  {
    String A = "abccdabccdabccd";
    String B = "bccd";
    int[] arr = { 1, 2,  3,  4,  5,  6,  7, 8,
                 9, 10, 11, 12, 13, 14, 15 };

    System.out.print(minCost(A, B, arr));
  }
}

// This code is contributed by Samim Hossain Mondal.

import java.util.Arrays;

public class Main {
    
    // This function takes in two strings a and b and a vector of integers c
    // It returns the minimum cost of removing m characters
    // from a such that it becomes b
    public static int minCost(String a, String b, int[] c) {
        int n = a.length();
        int m = b.length();
        int removed = m;
        
        // 3D dp array
        int[][][] dp = new int[n+1][m+1][m+1];
        
        // base cases
        for (int[][] i : dp) {
            for (int[] j : i) {
                Arrays.fill(j, Integer.MAX_VALUE);
            }
        }
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= m; k++) {
                    if (i == 0 || j == 0) {
                        if (k == 0) {
                            
                             // if both strings are empty and no characters 
                             // need to be removed, then cost is infinity
                            dp[i][j][k] = Integer.MAX_VALUE;
                        } else {
                            
                            // if either of the strings is empty,
                            // no cost is required to remove any characters
                            dp[i][j][k] = 0;
                        }
                    } else {
                        dp[i][j][k] = Integer.MAX_VALUE;
                    }
                }
            }
        }
        // tabulate the subproblems
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                for (int k = 1; k <= removed; k++) {
                    if (a.charAt(i-1) == b.charAt(j-1)) {
                        
                        // if the characters match, we can either remove
                        // the character from string a or not remove it
                        // the minimum cost is stored in the dp array
                        dp[i][j][k] = Math.min(c[i-1] + dp[i-1][j][k], dp[i-1][j-1][k-1]);
                    } else {
                        
                        // if the characters do not match, we can
                        // only remove the character from string a
                        dp[i][j][k] = dp[i-1][j][k];
                    }
                }
            }
        }
        
        // find the minimum cost of removing m characters from a
        int ans = Integer.MAX_VALUE;
        for (int k = 1; k <= removed; k++) {
            ans = Math.min(ans, dp[n][m][k]);
        }
        return ans == Integer.MAX_VALUE ? -1 : ans;
    }

    // Driver code
    public static void main(String[] args) {
        String A = "abccdabccdabccd";
        String B = "bccd";
        int[] arr = {1, 2, 3, 4, 5,
                     6, 7, 8, 9, 10,
                     11, 12, 13, 14, 15};
        System.out.println(minCost(A, B, arr));
    }
}

// This code is contributed by Shivhack999