Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	n, err := nextInt(sc)
	if err != nil {
		panic(err)
	}
	for i := 0; i < n; i++ {
		strX := nextText(sc)
		strY := nextText(sc)
		fmt.Println(calcLcs(strX, strY))
	}
}

func calcLcs(strX, strY string) int {
	lenX, lenY := len(strX), len(strY)
	memo := make([][]int, lenX+1)
	for i := 0; i < lenX+1; i++ {
		memo[i] = make([]int, lenY+1)
	}

	lcs := 0
	for i := 1; i < lenX+1; i++ {
		for j := 1; j < lenY+1; j++ {
			if strX[i-1] == strY[j-1] {
				memo[i][j] = memo[i-1][j-1] + 1
			} else {
				if memo[i-1][j] > memo[i][j-1] {
					memo[i][j] = memo[i-1][j]
				} else {
					memo[i][j] = memo[i][j-1]
				}
			}
			if memo[i][j] > lcs {
				lcs = memo[i][j]
			}
		}
	}
	return lcs
}

func nextInt(sc *bufio.Scanner) (int, error) {
	sc.Scan()
	return strconv.Atoi(sc.Text())
}

func nextText(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

C++: #include<iostream>
#include<climits>
#include<algorithm>

using namespace std;

int calc_longest_subseq(string, string);

int main() {
	int q;
	cin >> q;
	string msg1, msg2;
	for (int i = 0;i < q;i++) {
		cin >> msg1>>msg2;
		cout << calc_longest_subseq(msg1, msg2) << endl;
	}
}

int calc_longest_subseq(string a, string b) {
	int* last_index = new int[b.length()+1];
	pair<char, int>* sorted_a = new pair<char, int>[a.length()];
	int tmp;
	for (int i = 0;i < a.length();i++) {
		sorted_a[i] = make_pair(a[i], i);
	}
	sort(sorted_a, sorted_a + a.length());
	last_index[0] = -1;
	int count = 0;
	for (int i = 1;i <= b.length();i++) {
		last_index[i] = INT_MAX;
	}
	for (int i = 0;i < b.length();i++) {
		for (int j = count;j >= 0;j--) {
			tmp = upper_bound(sorted_a, sorted_a + a.length(), make_pair(b[i], last_index[j]))-sorted_a;
			if (tmp < a.length()) {
				if (sorted_a[tmp].first == b[i]) {
					last_index[j + 1] = min(last_index[j + 1], sorted_a[tmp].second);
					count = max(j + 1, count);
				}
			}
		}
	}
	return count;

}

C++: #include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;


int main() {
	int n, m, q;
	string a, b;//two sequences
	int M[1001][1001] = { { 0 } };//Memory matrix

	cin >> q;
	for (int l = 0; l < q; l++)
	{
		cin >> a >> b;
		n = a.length();
		m = b.length();
		for (int i = 0; i <= n; i++)
		{
			for (int j = 0; j <= m; j++)
			{
				if (a[i] == b[j])
				{
					M[i + 1][j + 1] = M[i][j] + 1;
				}
				else
				{
					M[i + 1][j + 1] = max(M[i][j + 1], M[i + 1][j]);
				}
			}
		}

		cout << M[n][m] << endl;//The time complexity equals to O (n * m)
	}
	return 0;
}

C++: #include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
#include <functional>
#include <cctype>

using namespace std;

#define REP(i,n) for(int i = 0; i < (int)n; ++i)

string X, Y;

void solve(int x_size, int y_size)
{
	vector< vector<int> > dp(x_size + 1, vector<int>(y_size + 1));

	for(int i = 0; i < x_size; ++i) {
		for(int j = 0; j < y_size; ++j) {
			if(X[i] == Y[j]) {
				dp[i + 1][j + 1] = dp[i][j] + 1;
			}
			else {
				dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j]);
			}
		}
	}

	cout << dp[X.size()][Y.size()] << endl;
}

int main()
{
	int n;
	cin >> n;
	REP(i, n) {
		cin >> X >> Y;
		solve(X.size(), Y.size());
	}
	return 0;
}

C++: #include <iostream>
#include <string>

int max(int a, int b, int c);

int main(){
    int n;
    std::cin >> n;
    std::string str1;
    std::string str2;
    for(int i=0;i<n;i++){
        std::cin >> str1;
        std::cin >> str2;
        int size1 = str1.size();
        int size2 = str2.size();
        int dp[size1+1][size2+1];
        dp[0][0] = 0;
        for(int j=0;j<=size1;j++){
            dp[j][0] = 0;
        }
        for(int j=0;j<=size2;j++){
            dp[0][j] = 0;
        }

        for(int j=0;j<size1;j++){
            for(int k=0;k<size2;k++){
                if(str1[j]==str2[k]){
                    dp[j+1][k+1] = max(dp[j][k+1],dp[j][k] + 1,dp[j+1][k]);
                }else{
                    dp[j+1][k+1] = max(dp[j][k+1],dp[j][k],dp[j+1][k]);
                }
            }
        }

        std::cout << dp[size1][size2] << std::endl;
    }
    return 0;
}

int max(int a, int b, int c){
    if(a>b){
        if(a>c){
            return a;
        }else{
            return c;
        }
    }else{
        if(b>c){
            return b;
        }else{
            return c;
        }
    }
}

C++: #include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int main(){
    //input
    long long q;
    cin >> q;
    long long i,j,k, m, n;
    string S, T;
    const char *s = NULL, *t = NULL;
    for(k = 1; k <= q; k++){
        cin >> S;
        m = S.length();
        s = S.c_str();
        cin >> T;
        n = T.length();
        t = T.c_str();
        long long dp[m+1][n+1];
        for(i = 0; i<= m; i++){
            dp[i][0] = 0;
        }
        for(j = 0; j <= n; j++){
            dp[0][j] = 0;
        }
        for(i = 1; i <= m; i++){
            for(j = 1; j <= n; j++){
                dp[i][j] = max({dp[i-1][j-1] + (s[i-1]==t[j-1]) , dp[i-1][j], dp[i][j-1]});
            }
        }
        cout<< dp[m][n] << endl;
    }
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define FOR(i,x,n) for(int i=x; i<(n); i++)
#define ALL(n) begin(n),end(n)
#define MOD (1000000007)
#define INF (1e9)
#define INFL (1e12)
 
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
template<class T>using arr=vector<vector<T>>;
template<class T>void pr(T x){cout << x << endl;}
template<class T>void prvec(vector<T>& a){rep(i, a.size()-1){cout << a[i] << " ";} cout << a[a.size()-1] << endl;}
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
 
int main()
{
    int q; cin >> q;
    arr<int> dp(1005, vector<int>(1005, 0));
    string s, t;
    rep(i, q){
        cin >> s >> t;
        int s_l = s.size(), t_l = t.size();
        rep(si, s_l) rep(ti, t_l){
            if(s[si]==t[ti]){
                dp[si+1][ti+1] = max(dp[si][ti]+1, dp[si+1][ti]);
            }else{
                dp[si+1][ti+1] = max(dp[si+1][ti], dp[si][ti+1]);
            }
        }

        pr(dp[s_l][t_l]);
        rep(si, s_l+1) rep(ti, t_l+1) dp[si][ti] = 0;
    }
    return 0;}

C++: #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxx = 1010;
int c[maxx][maxx];

int lcs(char s1[],char s2[]) {
	int m = strlen(s1), n = strlen(s2);
	for (int i = 1; i <= m; i++)
		c[i][0] = 0;
	for (int i = 1; i <= n; i++)
		c[0][i] = 0;

	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (s1[i] == s2[j])
				c[i][j] = c[i - 1][j - 1] + 1;
			else
				c[i][j] = max(c[i - 1][j], c[i][j - 1]);
		}
	}
	return c[m][n];
}
int main()
{
	char s1[maxx], s2[maxx];
	int t;
	scanf("%d", &t);
	for (int i = 0; i < t; i++) {
		scanf("%s %s", s1, s2);
		printf("%d\n", lcs(s1,s2));
	}

	return 0;
}