Printing Longest Common Subsequence

// Dynamic Programming implementation
// of LCS problem in C#
using System;

class GFG {
    // Returns length of LCS for X[0..m-1], Y[0..n-1]
    static void lcs(String X, String Y, int m, int n)
    {
        int[, ] L = new int[m + 1, n + 1];

        // Following steps build L[m+1][n+1] in
        // bottom up fashion. Note that L[i][j]
        // contains length of LCS of X[0..i-1]
        // and Y[0..j-1]
        for (int i = 0; i <= m; i++) {
            for (int j = 0; j <= n; j++) {
                if (i == 0 || j == 0)
                    L[i, j] = 0;
                else if (X[i - 1] == Y[j - 1])
                    L[i, j] = L[i - 1, j - 1] + 1;
                else
                    L[i, j] = Math.Max(L[i - 1, j],
                                       L[i, j - 1]);
            }
        }

        // Following code is used to print LCS
        int index = L[m, n];
        int temp = index;

        // Create a character array
        // to store the lcs string
        char[] lcs = new char[index + 1];

        // Set the terminating character
        lcs[index] = '\0';

        // Start from the right-most-bottom-most corner
        // and one by one store characters in lcs[]
        int k = m, l = n;
        while (k > 0 && l > 0) {
            // If current character in X[] and Y
            // are same, then current character
            // is part of LCS
            if (X[k - 1] == Y[l - 1]) {
                // Put current character in result
                lcs[index - 1] = X[k - 1];

                // reduce values of i, j and index
                k--;
                l--;
                index--;
            }

            // If not same, then find the larger of two and
            // go in the direction of larger value
            else if (L[k - 1, l] > L[k, l - 1])
                k--;
            else
                l--;
        }

        // Print the lcs
        Console.Write("LCS of " + X + " and " + Y + " is ");
        for (int q = 0; q <= temp; q++)
            Console.Write(lcs[q]);
    }

    // Driver program
    public static void Main()
    {
        String X = "AGGTAB";
        String Y = "GXTXAYB";
        int m = X.Length;
        int n = Y.Length;
        lcs(X, Y, m, n);
    }
}

// This code is contributed by Sam007

using System;
using System.Collections.Generic
namespace LongestCommonSubsequence
{

public class GFG{

        static void Main(string[] args)
        {
            string a = "AGGTAB";
            string b = "GXTXAYB";
            Console.WriteLine(LCS(a, b));
        }

        // Utility function to reverse a string
        static string Reverse(string str)
        {
            char[] charArray = str.ToCharArray();
            Array.Reverse(charArray);
            return new string(charArray);
        }

        // Utility function to return the larger string
        static string MaxStr(string a, string b)
        {
            return a.Length > b.Length ? a : b;
        }

        // Main function that returns the LCS
        static string LCS_Core(string a, string b, Dictionary<string, string> dp, Dictionary<string, int> vs)
        {
            int n_a = a.Length;
            int n_b = b.Length;

            // Base case
            if (n_a == 0 || n_b == 0)
            {
                return "";
            }

            // dp index to access the dp dictionary
            string dp_i = a + "," + b;

            // ans points to the memory location in the dp
            // dictionary in which the solution string will be stored
            string ans;
            if (dp.TryGetValue(dp_i, out ans))
            {
                // If visited return solution from memory
                return ans;
            }

            // If not visited, set the visit value to be one
            // (meaning it's now visited)
            vs[dp_i] = 1;

            // If the last two characters match
            if (a[n_a - 1] == b[n_b - 1])
            {
                // Add this character to the solution string
                ans = a[n_a - 1] + LCS_Core(a.Substring(0, n_a - 1), b.Substring(0, n_b - 1), dp, vs);
                dp[dp_i] = ans;
                return ans;
            }

            // Return longest string
            ans = MaxStr(LCS_Core(a.Substring(0, n_a - 1), b, dp, vs), LCS_Core(a, b.Substring(0, n_b - 1), dp, vs));
            dp[dp_i] = ans;
            return ans;
        }

        static string LCS(string a, string b)
        {
            Dictionary<string, string> dp = new Dictionary<string, string>();
            Dictionary<string, int> vs = new Dictionary<string, int>();

            string ans = LCS_Core(a, b, dp, vs);

            // Reverse the obtained result
            return Reverse(ans);
        }
    }
}