Shortest possible combination of two strings

// Java program to print supersequence of two
// strings 
public class GFG_1 {
    
    String a , b;
    
    // Prints super sequence of a[0..m-1] and b[0..n-1] 
    static void printSuperSeq(String a, String b)
    {
        int m = a.length(), n = b.length();
        int[][] dp = new int[m+1][n+1];
     
        // Fill table in bottom up manner
        for (int i = 0; i <= m; i++)
        {
            for (int j = 0; j <= n; j++)
            {
               // Below steps follow above recurrence
               if (i == 0)
                   dp[i][j] = j;
               else if (j == 0 )
                   dp[i][j] = i;
               else if (a.charAt(i-1) == b.charAt(j-1))
                    dp[i][j] = 1 + dp[i-1][j-1];
               else
                    dp[i][j] = 1 + Math.min(dp[i-1][j], dp[i][j-1]);
            }
        }
     
       // Create a string of size index+1 to store the result
       String res = "";
     
       // Start from the right-most-bottom-most corner and
       // one by one store characters in res[]
       int i = m, j = n;
       while (i > 0 && j > 0)
       {
          // If current character in a[] and b are same,
          // then current character is part of LCS
          if (a.charAt(i-1) == b.charAt(j-1))
          {
              // Put current character in result
              res = a.charAt(i-1) + res;
     
              // reduce values of i, j and indexes
              i--;
              j--;
          }
     
          // If not same, then find the larger of two and
          // go in the direction of larger value
          else if (dp[i-1][j] < dp[i][j-1])
          { 
              res = a.charAt(i-1) + res;
              i--;  
          }
          else
          {
              res = b.charAt(j-1) + res; 
              j--; 
          }
       }
     
       // Copy remaining characters of string 'a'
       while (i > 0)
       {
           res = a.charAt(i-1) + res;
           i--;
       }
     
       // Copy remaining characters of string 'b'
       while (j > 0)
       {
           res = b.charAt(j-1) + res;   
           j--; 
       }
     
       // Print the result
       System.out.println(res);
    }
     
    /* Driver program to test above function */
    public static void main(String args[])
    {
      String a = "algorithm";
      String b = "rhythm";
      printSuperSeq(a, b);
      
    }
}
// This article is contributed by Sumit Ghosh

// Java implementation to find shortest string for
// a combination of two strings
import java.util.ArrayList;
public class GFG_2 {
         
    // Vector that store the index of string a and b
    static ArrayList<Integer> index_a = new ArrayList<>();
    static ArrayList<Integer> index_b = new ArrayList<>();
     
    // Subroutine to Backtrack the dp matrix to
    // find the index vector traversing which would
    // yield the shortest possible combination
    static void index(int dp[][], String a, String b,
               int size_a, int size_b)
    {
        // Clear the index vectors
        index_a.clear();
        index_b.clear();
     
        // Return if either of a or b is reduced
        // to 0
        if (size_a == 0 || size_b == 0)
            return;
     
        // Push both to index_a and index_b with
        // the respective a and b index
        if (a.charAt(size_a - 1) == b.charAt(size_b - 1)) {
            index(dp, a, b, size_a - 1, size_b - 1);
            index_a.add(size_a - 1);
            index_b.add(size_b - 1);
        } else {
            if (dp[size_a - 1][size_b] > dp[size_a]
                                        [size_b - 1]) {
                index(dp, a, b, size_a - 1, size_b);
            } else {
                index(dp, a, b, size_a, size_b - 1);
            }
        }
    }
     
    // function to combine the strings to form
    // the shortest string
    static void combine(String a, String b, int size_a,
                 int size_b)
    {
     
        int[][] dp = new int[100][100];
        String ans = "";
        int k = 0;
     
        // Store the increment of diagonally
        // previous value if a[i-1] and b[j-1] are
        // equal, else store the max of dp[i][j-1]
        // and dp[i-1][j]
        for (int i = 1; i <= size_a; i++) {
            for (int j = 1; j <= size_b; j++) {
                if (a.charAt(i - 1) == b.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i][j - 1],
                                   dp[i - 1][j]);
                }
            }
        }
     
        // Get the Lowest Common Subsequence
        int lcs = dp[size_a][size_b];
     
        // Backtrack the dp array to get the index
        // vectors of two strings, used to find
        // the shortest possible combination.
        index(dp, a, b, size_a, size_b);
     
        int i, j = i = k;
     
        // Build the string combination using the
        // index found by backtracking
        while (k < lcs) {
            while (i < size_a && i < index_a.get(k)) {
                ans += a.charAt(i++);
            }
     
            while (j < size_b && j < index_b.get(k)) {
                ans += b.charAt(j++);
            }
     
            ans = ans + a.charAt(index_a.get(k));
            k++;
            i++;
            j++;
        }
     
        // Append the remaining characters in a
        // to answer
        while (i < size_a) {
            ans += a.charAt(i++);
        }
     
        // Append the remaining characters in b
        // to answer
        while (j < size_b) {
            ans +=  b.charAt(j++);
        }
     
        System.out.println(ans);
    }
     
     
    /* Driver program to test above function */
    public static void main(String args[])
    {
      String a = "algorithm";
      String b = "rhythm";
      combine(a, b, a.length(),b.length());
      
    }
}
// This article is contributed by Sumit Ghosh