Go: package main

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

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 500001), 500000)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func main() {
	fp := os.Stdin
	if len(os.Args) > 1 {
		fp, _ = os.Open(os.Args[1])
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(os.Stdout)

	n := getNextInt(scanner)
	for i := 0; i < n; i++ {
		x := getNextString(scanner)
		y := getNextString(scanner)

		fmt.Fprintln(writer, lcs(x, y))
	}

	writer.Flush()
}

func lcs(x, y string) int {
	lx := len(x)
	ly := len(y)
	dp := make([][]int, lx+1)
	for i := 0; i <= lx; i++ {
		dp[i] = make([]int, ly+1)
	}
	for i := 0; i < lx; i++ {
		for ii := 0; ii < ly; ii++ {
			if x[i] == y[ii] {
				dp[i+1][ii+1] = dp[i][ii] + 1
				continue
			}
			dp[i+1][ii+1] = dp[i][ii+1]
			if dp[i+1][ii] > dp[i+1][ii+1] {
				dp[i+1][ii+1] = dp[i+1][ii]
			}
		}
	}
	return dp[lx][ly]
}

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

int c[1010][1010];

void lcs(char X[], char Y[]){
	int m = strlen(X);
	int n = strlen(Y);
	int i, j;
	for(i = 1;i <= m;i++)
		c[i][0] = 0;
	for(j = 1;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
				c[i][j] = max(c[i - 1][j], c[i][j - 1]);
		}
	}
}

int main(void){
	int q, i;
	char A[1000], B[1000];
	scanf("%d", &q);
	for(i = 0;i < q;i++){
		scanf("%s", A);
		scanf("%s", B);
		lcs(A, B);
		printf("%d\n", c[strlen(A)][strlen(B)]);
	}
	return 0;
}

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

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

string str1, str2;
int dp[1001][1001];

void solve()
{
  REP(i, str1.size())
    if(str1[i] == str2[str2.size() - 1])
      dp[i][str2.size() - 1] = 1;
    else
      dp[i][str2.size() - 1] = 0;
  for(int i = str2.size() - 2; i >= 0; i--)
    if(str1[str1.size() - 1] == str2[i])
      dp[str1.size() - 1][i] = 1;
    else
      dp[str1.size() - 1][i] = dp[str1.size() - 1][i + 1];
  for(int i = str1.size() - 2; i >= 0; i--){
    for(int j = str2.size() - 2; j >= 0; j--){
      if(str1[i] == str2[j])
	dp[i][j] = dp[i + 1][j + 1] + 1;
      else
	dp[i][j] = max(dp[i + 1][j], dp[i][j + 1]);
    }
  }
}
  
int main()
{
  int q;
  cin >> q;
  cin.ignore();
  REP(i, q){
    getline(cin, str1);
    getline(cin, str2);
    fill(&dp[0][0], &dp[1001][0], -1);
    swap(str1, str2);
    solve();
    cout << dp[0][0] << endl;
  }
}

C++: #include <stack>
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
using namespace std;
int gcd(int a, int b)
{
   if (a%b == 0)
   {
       return(b);
   }
   else
   {
       return(gcd(b, a%b));
   }
}
int mod = 1000000000 + 7;
vector<int> v;
class Calc
{
    // 宣言
    long long a;

    public:
        // 素因数分解
        void decompositPrime(long long a);
};

/*
 * 素因数分解
 */
void Calc::decompositPrime(long long n)
{
    // 割る数の初期値
    a = 2;
    // √n ≧ a ( n ≧ a * a ) の間ループ処理
    while (n >= a * a) {
        // a で割り切れたら、a は素因数
        // そして、割られる数を a で割る
        // a で割り切れなかったら、 a を 1 増加させる
        if (n % a == 0) {
            //printf("%d * ", a);
             v.push_back(a);
            n /= a;
        } else {
            a++;
        }
    }
    // 最後に残った n は素因数
    v.push_back(n);
    //printf("%d\n", n);
}

int main(){
    //std::stack<int> stack;
    int n;
    cin >> n;
    for(int i = 0; i < n; i++){
        string a,b;
        cin >> a >> b;
        int asize = a.size();
        int bsize = b.size();
        int mat[asize+1][bsize+1];
        a = " " + a;
        b = " " + b;
        mat[0][0] = 0;
        for(int i = 1; i <= asize; i++){
            mat[i][0] = 0;
        }
        for(int i = 1; i <= bsize; i++){
            mat[0][i] = 0;
        }
        for(int j = 1; j <= asize; j++){
            for(int k = 1; k <= bsize; k++){
                if(a[j] == b[k]){
                    mat[j][k] = mat[j-1][k-1]+1;
                }else{
                    mat[j][k] = max(mat[j-1][k], mat[j][k-1]);
                }
            }
        }
        // for(int i = 0; i <= asize; i++){
        //     for(int j = 0; j <= bsize; j++){
        //         cout << mat[i][j] << " ";
        //     }
        //     cout << endl;
        // }
        cout << mat[asize][bsize] << endl;
    }
    //cout << ans << endl;
    return 0;
}

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

using namespace std;

int main(){
  int Q; cin >> Q;
  for(int q=0;q<Q;++q){
	string s1, s2; cin >> s1 >> s2;
	int dp[1001][1001];
	fill((int*)dp, (int*)dp+1001*1001, 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] = 1 + dp[i][j];
		else dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]);
	  }

	cout << dp[s1.size()][s2.size()] << endl;
  }
}

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

#define MAX 1024

int LCS[MAX][MAX];

int solve(string s1,string s2){
  for(int i=1;i<=s1.length();i++){
    for(int j=1;j<=s2.length();j++){
      if(s1[i-1]==s2[j-1])
	LCS[i][j]=LCS[i-1][j-1]+1;
      else
	LCS[i][j]=max(LCS[i][j-1],LCS[i-1][j]);
    }
  }
  return LCS[s1.length()][s2.length()];
}


int main(){
  string s1, s2;
  int n;
  cin >> n;
  for(int i=0;i<n;i++){
    for(int i=0;i<MAX;i++){
      for(int j=0;j<MAX;j++){
        LCS[i][j] = 0;
      }
    }
    cin>>s1>>s2;
    cout<<solve(s1,s2)<<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];
  int m=x.size();
  int n=y.size();
  int maxl=0;
  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(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;
}

int main(){
  string s1,s2;
  int n;
  cin>>n;
  for(int i=0;i<n;i++){
    cin>>s1>>s2;
    cout<<lcs(s1,s2)<<endl;
  }
  return 0;
}

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];
    int m = X.size();
    int n = Y.size();
    int maxl = 0;
    X = ' ' + X; //X[0]に空白を挿入
    Y = ' ' + Y; //X[0]に空白を挿入
    for(int i = 0; i <= m; i++) c[i][0] = 0;
    for(int j = 0; j <= m; j++) c[0][j] = 0;


    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-1][j], c[i][j-1]);
            }
            maxl = max(maxl, c[i][j]);
        }
    }

    return maxl;
}

int main(){
    string s1, s2;
    int n; cin >> n;
    for(int i = 0; i < n; i++){
        cin >> s1 >> s2;
        cout << lcs(s1, s2) << endl;
    }
    return 0;
}

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

int dp[1005][1005]; //d[i][j]:=s1...siとt1...tjのLCSの長さ

int main(){
    int q;
    string X[150], Y[150];

    cin >> q;
    for(int i=0; i<q; i++){
        cin >> X[i];
        cin >> Y[i];
    }

    for(int i=0; i<q; i++){
        for(int j=0; j<1005; j++) for(int k=0; k<1005; k++) dp[j][k] = 0;

        for(int j=0; j<X[i].size(); j++){
            for(int k=0; k<Y[i].size(); k++){
                if(X[i][j] == Y[i][k]) dp[j+1][k+1] = dp[j][k]+1;
                else dp[j+1][k+1] = max(dp[j][k+1], dp[j+1][k]);
            }
        }
        cout << dp[X[i].size()][Y[i].size()] << endl;
    }
}