Go: package main

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

type Position struct {
	X int
	Y int
}

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 {
	return lcs(strX, strY, Position{0, 0}, make(map[Position]int))
}

func lcs(strX string, strY string, position Position, memo map[Position]int) int {
	if position.X >= len(strX) || position.Y >= len(strY) {
		return 0
	}
	if v, ok := memo[position]; ok {
		return v
	}
	if strX[position.X] == strY[position.Y] {
		result := lcs(strX, strY, Position{position.X + 1, position.Y + 1}, memo)
		memo[position] = result + 1
		return memo[position]
	} else {
		result1 := lcs(strX, strY, Position{position.X + 1, position.Y}, memo)
		result2 := lcs(strX, strY, Position{position.X, position.Y + 1}, memo)
		var result int
		if result1 > result2 {
			result = result1
		} else {
			result = result2
		}
		memo[position] = result
		return result
	}
}

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 <cstdio>
#include <cmath>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

// Dynamic Programming - LCS

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);

    int q;
    cin >> q;

    for (int _ = 0; _ < q; ++_) {
        string s1, s2;
        cin >> s1 >> s2;

        const int s1_size = s1.size();
        const int s2_size = s2.size();
        vector<vector<int>> dp(s1_size + 1);
        for (int i = 0; i < s1_size + 1; ++i) dp[i].resize(s2_size + 1, 0);

        for (int i = 0; i < s1_size; ++i) {
            for (int j = 0; j < s2_size; ++j) {
                if (s1[i] == s2[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[s1_size][s2_size] << "\n";
    }

    cout << flush;
    return 0;
}

C++: #include<stdio.h>
#include<string.h>
#define MAX 1001
??
int LCSLength(char [], char []);
??
int main()
{
????int i, q, Z[MAX];
????char X[MAX], Y[MAX];
??
????scanf("%d", &q);
????for(i=0; i<q; i++)
????????{
????????????scanf("%s", X);
????????????scanf("%s", Y);
????????????Z[i] = LCSLength(X, Y);
????????}
??
????for(i=0; i<q; i++)
????????{
????????????printf("%d\n", Z[i]);
????????}
????
????return 0;
}
??
int LCSLength(char X[], char Y[])
{
????int i, j, c[MAX][MAX];
????int m = strlen(X);
????int n = strlen(Y);
??
????for(i=1; i<=m; i++) c[i][0] = 0;
????for(j=0; j<=n; j++) c[0][j] = 0;
??
????for(i=1; i<=m; i++)
????????{
????????????for(j=1; j<=n; j++)
????????{
????????????if(X[i-1] == Y[j-1]) c[i][j] = c[i-1][j-1] + 1;
????????????else if(c[i-1][j-1] >= c[i][j-1]) c[i][j] = c[i-1][j];
????????????else c[i][j] = c[i][j-1];
????????}
????????}
??????
????return c[m][n];
}

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

using namespace std;

string  X,Y;
int q;

int do_dp(int ax,int ay){
  int dp[ax + 100][ay + 100] = {0};
  
  for(int i = 0;i < ax;i++){
    if(X[i] == Y[0]) dp[i][0] = 1;
    if(i > 0) dp[i][0] = max(dp[i][0],dp[i - 1][0]);
  }
  
  for(int j = 0;j < ay;j++){
    if(X[0] == Y[j]) dp[0][j] = 1;
    if(j > 0) dp[0][j] = max(dp[0][j],dp[0][j - 1]);
  }

  for(int i = 1;i < ax;i++){
    for(int j = 1;j < ay;j++){
      if(X[i] == Y[j]){
	dp[i][j] = dp[i - 1][j - 1] + 1;
      }else{
	dp[i][j] = max(dp[i - 1][j],dp[i][j - 1]);
      }
    }
  }
  
  for(int i = 0;i < ax;i++){
    for(int j = 0;j < ay;j++){
      cout << dp[i][j] << " ";
    }
    cout << '\n';
  }
  
  return dp[ax - 1][ay - 1];
}

int main(){
  string str;
  
  cin >> q;
  
  int A[q];
  
  for(int i = 0;i < q;i++){
    cin >> X;
    cin >> Y;
    //cout << X.size() << " " << Y.size() << '\n';
    A[i] = do_dp(X.size(),Y.size());
  }
  
  for(int i = 0;i < q;i++){
    cout << A[i] << '\n';
  }
  
  return 0;
}

C++: #include <iostream>
#include <string>
#define int long long
//#define _DEBUG
using namespace std;
string sa, sb;
int T[1009][1009];
int solve(){
    int sal = sa.length(), sbl = sb.length();
    for(int a=0; a<=sal; a++){
        for(int b=0; b<=sbl; b++){
            if(a==0 || b==0){
                T[a][b] = 0;
            }else if(sa[a-1] == sb[b-1]){
                T[a][b] = 1 + T[a-1][b-1];
            }else{
                T[a][b] = max(T[a][b-1], T[a-1][b]);
            }
        }
    }
    return T[sal][sbl];
}
signed main(){
    int N;
    cin >> N;
    for(int i=0; i<N; i++){
        cin >> sa >> sb;
        cout << solve() << endl;
    }
}

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

static const int n = 1000;

int lcs(string X, string Y) {
	int c[n + 1][n + 1]; //　XiとYjのLCSの長さとする２次元配列
	int m = int(X.length());
	int n = int(Y.length());
	X =' '+X;
	Y =' '+Y;
	int maxl = 0;
	//初期化
	for (int i = 0;i<=m;i++) {
		c[i][0] = 0;
	}
	for (int j = 1;j<= n; j++) {
		c[0][j] = 0;
	}

	//Xｍ－１とYｎ、XmとYn-1どちらが長いかを調べる
	for (int i = 1; i <= m;i++) {
		for (int j = 1; j <= n;j++) {
			if (X[i] == Y[j]){
			   c[i][j] = c[i - 1][j - 1] + 1; 
			} 
			else{
			    c[i][j]= max( c[i][j - 1],c[i-1][j]);
            }
			maxl = max(maxl,c[i][j]);
		}
	}

	return maxl;
}

int main() {
	int n; cin >> n;
	string S1, S2;

	for (int i = 0;i<n;i++) {
		cin >> S1 >> S2;
		cout << lcs(S1, S2) << endl;
	}
	return 0;

}

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

int main() {
    int n,mat[MAX][MAX];
    string s1,s2;
    cin >> n;
    for(int k=0;k<n;k++) {
        cin >> s1 >> s2;
        for(int i = 0; i < s1.size(); i++) {
            for(int j = 0; j < s2.size(); j++) {
                mat[i + 1][j + 1] = (s1[i] == s2[j] ? mat[i][j] + 1 : max(mat[i][j + 1], mat[i + 1][j]));
            }
        }
        cout << mat[s1.size()][s2.size()] << endl;
    }
}

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

static const int SIZE = 1000;

int max(int a, int b){
    return (a > b ? a : b);
}

void lcs(char *x, char *y){
    int dp[SIZE+1][SIZE+1];
    int xl,yl,res=0;
    
    xl = strlen(x);
    yl = strlen(y);

    for(int i=0; i<=xl; i++) dp[i][0] = 0;
    for(int i=0; i<=yl; i++) dp[0][i] = 0;


    for(int i=1; i<=xl; i++){
        for(int j=1; j<=yl; j++){
            if(x[i-1] == y[j-1]){
                dp[i][j] = dp[i-1][j-1]+1;
            }
            else dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
        }
    }

    cout<<dp[xl][yl]<<endl;
}

int main(){
    char x[SIZE],y[SIZE];
    int n;
    cin>>n;
    for(int i=0; i<n; i++){
        cin>>x>>y;
        lcs(x,y);
    }

    return 0;
}

C++: #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
static const int N = 1000;

void lcs(string *x, string y){
  int c[N + 1][N + 1], max = 0, i, j;
  int m = x.size;
  int n = y.size;

  x = ' ' + x;
  y = ' ' + y;
 
  for(i = 1; i <= m; i++) c[i][0] = 0;
  for(i = 1; i <= n; i++) c[0][i] = 0;

  for(i = 1; i <= m; i++){
    for(j = 1; j <= m; j++){
      if(x[i] == y[j]) c[i][j] = c[i - 1][j - 1] + 1;
      else c[i][j] = max(c[i - 1][j - 1], c[i][j - 1]);
      max = max(max, c[i][j]);
    }
  }
  return max;
}

int main(){
  string x, y;
  int q, i;

  cin >> q;
  
  for(i = 0; i < q; i++){
    cin >> x >> y;
    cout << lcs(x, y) << endl;
  }
  return 0;
}