/* An instance of this class is for the purpose of providing information
** about longest common subsequences of (any prefixes of) two particular
** strings.  In creating an instance, the client specifies the pair of
** strings of interest, x and y.  Let M and N be the lengths of x and y,
** respectively.  The object is able to do the following:
**
** (1) Print a table showing, for each m<=M and n<=N, the length of any
**     longest common subsequence (LCS) of x[0..m) and y[0..n) (i.e.,
**     the prefixes of x and y of lengths m and n, respectively).
** (2) Answer the question:  For given m<=M and n<=N, what is the length 
**     of an LCS of x[0..m) and y[0..n)?  Of course, the answer to any such
**     question is simply one table entry from (1).)
** (3) Determine, for any m<=M and n<=N, one LCS of x[0..m) and y[0..n).
** (4) Determine, for any m<=M and n<=N, one matching of x[0..m) and y[0..n)
**     that gives rise to an LCS of those two strings.
**
** Author: R. McCloskey, 2015 (modified in April 2019 for purposes of 
**         SE 504 programming assignment)
*/

public class LongComSubseq_504_S19 {

   // instance variables
   // ------------------
   private String x, y;    // the Strings of interest
   private int M, N;       // their lengths (redundant data)
   private int[][] llcs;   // 2-dimensional array storing values of the 
                           // LLCS function applied to x and y.


   // constructor (and supporing method)
   // -----------

   /* Establishes the two given Strings as those that are the focus of
   ** this object.
   */
   public LongComSubseq_504_S19(String s1, String s2)
   {
      x = s1;  y = s2;
      computeLLCS();     // Fill the llcs[][] array with LLCS function values
   }

   /* Constructs and fills llcs[][] so that, for all i in 0..M and j in 0..N
   ** (where M and N are the lengths of x and y), llcs[i][j] = LLCS.i.j, 
   ** which is to say that, upon completion of the method's execution, the 
   ** value of llcs[i][j] is the length of a longest common subsequence of 
   ** x[0..i) and y[0..j).
   */
   private void computeLLCS()
   {
      M = x.length();
      N = y.length();
      llcs = new int[M+1][N+1];

      // fill row zero and column zero with zeros
      for (int j=0; j != N+1; j++) { llcs[0][j] = 0; }
      for (int i=0; i != M+1; i++) { llcs[i][0] = 0; }
      
      int m=1, n=1;
      // loop invariant: (A i,j | 0<=i<m & 0<=j<=N : llcs[i][j] = LLCS.i.j) &
      //                 (A j | 0<=j<n : llcs[m][j] = LLCS.m.j) & 
      //                 1<=m<=M+1 & 0<=n<=N+1
      // bound function: (M+1)*(N+2) - (m*(N+2) + n). 
      while (m != M+1) 
      {
         if (n == N+1) {
            m = m+1; n = 0;  // row m now complete; go to next row
         }
         else if (x.charAt(m-1) == y.charAt(n-1)) {
            llcs[m][n] = llcs[m-1][n-1] + 1;
         }
         else {
            llcs[m][n] = Math.max(llcs[m][n-1], llcs[m-1][n]);
         }
         n = n+1;
      }
   }

   // observers
   // ---------

   /* Returns the maximum of the lengths of common subsequences of x and y.
   */
   public int lengthOfLCS() { return lengthOfLCS(M,N); }

   /* Returns the maximum of the lengths of common subsequence of x[0..m) and
   ** y[0..n) (the prefixes of x and y of lengths m and n, respectively).
   */
   public int lengthOfLCS(int m, int n) { return llcs[m][n]; }

   /* Returns a longest matching of x and y.
   */
   public int[][] longestMatching() { return longestMatching(M,N); }

   /* Returns a longest matching of x[0..m) and y[0..n).
   */
   public int[][] longestMatching(int m, int n) { 
      return new int[2][0];   // STUB!
   }

   /* Returns a longest common subsequence of x and y.
   */
   public String longestCommonSubsequence() 
   {
      return longestCommonSubsequence(M,N); 
   }

   /* Returns a longest common subsequence of x[0..m) and y[0..n)
   **  (the prefix of x of length m and prefix of y of length n).
   */
   public String longestCommonSubsequence(int m, int n) 
   {
      return "?";  // STUB
   }


   /* Prints the values of the LLCS function in a table format.
   */
   public void printLLCSTable() { printLLCSTable(M,N); }

 
   /* Prints the values of the LLCS function in a table format,
   ** but only up to LLCS.(m-1).(n-1).
   */
   public void printLLCSTable(int m, int n) 
   {
      for (int i=m; i!=-1; i--) {
         System.out.printf("%3d", i);
         System.out.print("|");
         for (int j=0; j != n+1; j++) {
            System.out.printf("%3d", llcs[i][j]);
         }
         System.out.println();
      }
      System.out.print("   +");
      printString("---", n+1);
      System.out.println();
      System.out.print("    ");
      for (int j=0; j != n+1; j++) {
         System.out.printf("%3d", j);
      }
      System.out.println(); 
   }


   /* Prints the specified string the specified # of times
   ** (used in printing the LLCS table).
   */
   private void printString(String str, int k)
   {
      for (int j=0; j != k; j++) {
         System.out.print(str);
      }
   }

   private void printMatching(int[][] mat) {
      final int LEN = mat[0].length;
      for (int i=0; i != 2; i++) {
         for (int j=0; j != LEN; j++) {
            System.out.printf("%3d ", mat[i][j]);
         }
         System.out.println();
      }
   }
}