X and Y to S and T

Author: jsiek

lectures/DNA-alignment.md

@@ -146,6 +146,111 @@ score for the rest, then add in the score for the current choice.
 
 Return the max of all the choices.
 
+
+```
+Result align(String S, String T) {
+  if (S.length() == 0 && T.length() == 0) {
+    return Result(0);
+  } else if (S.length() == 0) {
+    rest = align(S, T.substring(0, T.length()-1));
+    return Result(rest.score - 1, Direction.LEFT)
+  } else if (T.length() == 0) {
+    rest = align(S.substring(0, S.length()-1), T);
+    return Result(rest.score - 1, Direction.UP)
+  } else {
+    char s = S.charAt(S.length() - 1);
+    char t = T.charAt(T.length() - 1);
+    // option 1: line up
+    rest1 = align(S.substring(0, S.length()-1),
+                  T.substring(0, T.length()-1));
+    option1 = rest1.score + match(s, t);
+    best_score = option1;
+    best_direction = DIAGONAL;
+    // option 2: gap on top (S)
+    rest2 = align(S, T.substring(0, T.length()-1));
+    option2 = rest2.score - 1;
+    if (option2 > best_score) {
+      best_score = option2;
+      best_direction = LEFT;
+    }
+    // option 3: gap on bottom (T)
+    rest3 = align(S.substring(0, S.length()-1), T);
+    option3 = rest3.score - 1;
+    if (option3 > best_score) {
+      best_score = option3;
+      best_direction = UP;
+    }
+    return Result(best_score, best_direction);
+  }
+}
+```
+
+Memoize
+```
+void put_2D(HashMap<String, HashMap<String, Result> > R,
+       String S, String T) {
+    if (R.contains(S)) {
+      R.get(S).put(T, result);
+    } else {
+      R.put(S, new HashMap<String,Result>());
+      R.get(S).put(T, result);
+    }
+}
+
+
+Result align(String S, String T,
+             HashMap<String, HashMap<String, Result> > R)
+{
+  if (R.contains(S) and R.get(S).contains(T)) {
+    return R.get(S).get(T);
+  }
+  
+  if (S.length() == 0 && T.length() == 0) {
+    result = Result(0);
+    put_2D(R, S, T);
+    return result;
+  } else if (S.length() == 0) {
+    rest = align(S, T.substring(0, T.length()-1), R)
+    result = Result(rest.score - 1, Direction.LEFT);
+    put_2D(R, S, T);
+    return result;
+  } else if (T.length() == 0) {
+    rest = align(S.substring(0, S.length()-1), T, R);
+    result = Result(rest.score - 1, Direction.UP)
+    put_2D(R, S, T);
+    return result;
+  } else {
+    char s = S.charAt(S.length() - 1);
+    char t = T.charAt(T.length() - 1);
+    // option 1: line up
+    rest1 = align(S.substring(0, S.length()-1),
+                  T.substring(0, T.length()-1), R);
+    option1 = rest1.score + match(s, t);
+    best_score = option1;
+    best_direction = DIAGONAL;
+    // option 2: gap on top (S)
+    rest2 = align(S, T.substring(0, T.length()-1), R);
+    option2 = rest2.score - 1;
+    if (option2 > best_score) {
+      best_score = option2;
+      best_direction = LEFT;
+    }
+    // option 3: gap on bottom (T)
+    rest3 = align(S.substring(0, S.length()-1), T, R);
+    option3 = rest3.score - 1;
+    if (option3 > best_score) {
+      best_score = option3;
+      best_direction = UP;
+    }
+    result = Result(best_score, best_direction);
+    put_2D(R, S, T);
+    return result;
+  }
+}
+```
+
+
+
 ## Subproblem identification
 
 Instead of using the entire rest of S and T as the inputs to the

lectures/more-dynamic-programming.md

@@ -12,10 +12,10 @@ Here's the resulting table, which contains the solution for how to
 best align the two strings and every pair of prefixes of them.
 
 
-          Y =            G     G     A
+          T =            G     G     A
           j =      0  |  1  |  2  |  3
               --------------------------
-        X i = 0 |  0  |I:-1 |I:-2 |I:-3
+        S i = 0 |  0  |I:-1 |I:-2 |I:-3
           G   1 |D:-1 |M:2  |M:1  |I:0
           A   2 |D:-2 |D:1  |M:0  |M:3
           A   3 |D:-3 |D:0  |I:-1 |D:2
@@ -28,11 +28,11 @@ To obtain the best alignment, start at the bottom-right corner
 (row 3, column 3) and consult the choice that was made.
 
 The choice was D (delete), so that corresponds to aligning
-the last letter in X with a gap:
+the last letter in S with a gap:
 
          Partial Solution      Remaining Strings
-    X    A                     GA
-    Y    _                     GGA
+    S    A                     GA
+    T    _                     GGA
 
 To get the rest of the solution, we move up one cell because the
 choice was D (delete).
@@ -42,33 +42,33 @@ corresponds to aligning the last letter of each of the remaining
 strings (A and A).
 
          Partial Solution      Remaining Strings
-    X    AA                    G
-    Y    A_                    GG
+    S    AA                    G
+    T    A_                    GG
 
 To get the rest of then solution, we move diagonally up and left
 because the choice was M (match/mismatch).
 
 The choice in row 1, column 2 was M (match/mismatch).
 
          Partial Solution      Remaining Strings
-    X    GAA
-    Y    GA_                   G
+    S    GAA
+    T    GA_                   G
 
 Again we move diagonally up and left.
 
 The choice in row 0, column 1 is I (insert), so we align
-the letter G from Y with a gap.
+the letter G from T with a gap.
 
          Partial Solution      Remaining Strings
-    X    _GAA                  
-    Y    GGA_                  
+    S    _GAA                  
+    T    GGA_                  
 
 Because we did an insert, we move to the left one cell.
 
-So the best alignment of the strings X and Y is:
+So the best alignment of the strings S and T is:
 
-    X    _GAA
-    Y    GGA_
+    S    _GAA
+    T    GGA_
 	     -1 2 2 -1 = 2
 
 Summary: