Go: package main

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"os"
	"strconv"
	"strings"
)

const N = 1001

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func lcs(x, y string) int {
	var c [N][N]int
	m := len(x)
	n := len(y)
	var maxl int

	x = " " + x
	y = " " + y

	for i := 1; i <= m; i++ {
		for 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-1][j], c[i][j-1])
			}
			maxl = max(maxl, c[i][j])
		}
	}
	return maxl
}

func answer(reader io.Reader) string {
	sc := bufio.NewScanner(reader)
	sc.Split(bufio.ScanWords)

	sc.Scan()
	q, _ := strconv.Atoi(sc.Text())

	var out bytes.Buffer
	for i := 0; i < q; i++ {
		sc.Scan()
		s1 := sc.Text()
		sc.Scan()
		s2 := sc.Text()
		out.WriteString(fmt.Sprintf("%d\n", lcs(s1, s2)))
	}
	return strings.TrimRight(out.String(), "\n")
}

func main() {
	fmt.Println(answer(os.Stdin))
}

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;
}

C++: #include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#define MAX_N 1000

int solve(std::string s,std::string t){
        int dp[MAX_N][MAX_N];
        memset(dp,0,sizeof(dp));
        int n,m;
        n=s.size(),m=t.size();
        for(int i=0;i<n;i++){
                for(int j=0;j<m;j++){
                        if(s[i]==t[j])
                                dp[i+1][j+1]=dp[i][j]+1;
                        else
                                dp[i+1][j+1]=std::max(dp[i][j+1],dp[i+1][j\
]);
                }
        }
        return dp[n][m];
}

int main(){
        int q;
        std::cin>>q;
        for(int i=0;i<q;i++){
                std::string s,t;
                std::cin >> s>>t;
                std::cout << solve(s,t) << std::endl;
        }
        return 0;
}