Go: package main

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

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

/*********************************************************************
長さmの列X_(m)と長さnの列Y_(n)の最長共通部分列LCSは、
	(1)X[m] == Y[n]ならば、X_(m-1)とY_(n-1)のLCSにX[m]を繋げたもの
	(2)X[m] != Y[n]ならば、X_(m-1)とY_(n)のLCSもしくはX_(m)とY_(n-1)のLCS
	のいずれかのうち長い方

c[m+1][n+1]：c[i][j]にX_(i)とY_(j)のLCSの長さを格納する二次元配列
*********************************************************************/

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	n, _ := strconv.Atoi(scanner.Text())
	for i := 0; i < n; i++ {
		scanner.Scan()
		s1 := scanner.Text()
		scanner.Scan()
		s2 := scanner.Text()
		s1, s2 = s1 + " ", s2 + " "
		c := make([][]int, len(s1))
		for i := range c {
			c[i] = make([]int, len(s2))
		}

		LCS := 0

		for i := 1; i < len(s1); i++ {
			for j := 1; j < len(s2); 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])
				}
				LCS = max(LCS, c[i][j])
			}
		}
		fmt.Println(LCS)
	}
}

C++: import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        String X = null, Y = null;
        int[][] dp = new int[1001][1001];

        int q = sc.nextInt();

        for (int i = 0; i < q; ++i) {
            X = sc.next();
            Y = sc.next();
            for (int x = 0; x < X.length(); ++x) {
                for (int y = 0; y < Y.length(); ++y) {
                    if (X.charAt(x) == Y.charAt(y)) {
                        dp[x + 1][y + 1] = dp[x][y] + 1;
                    }
                    else {
                        if (dp[x + 1][y] > dp[x][y + 1]) {
                            dp[x + 1][y + 1] = dp[x + 1][y];
                        }
                        else {
                            dp[x + 1][y + 1] = dp[x][y + 1];
                        }
                    }
                }
            }
            System.out.printf("%d\n", dp[X.length()][Y.length()]);
        }
    }
}

C++: #include <iostream>

using namespace std;

static const int N = 1000;

int lcs(string x, string y)
{
    int dp[N + 1][N + 1];
    int m = x.length();
    int n = y.length();
    x = ' ' + x;
    y = ' ' + y;

    for (int i = 1; i <= m; i++)
        dp[i][0] = 0;
    for (int i = 1; i <= n; i++)
        dp[0][i] = 0;

    int res = 0;
    for (int i = 1; i <= m; i++)
    {
        for (int j = 1; j <= n; 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]);
        }
    }

    return dp[m][n];
}

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

C++: #include<iostream>
#include<string>
#include<algorithm>
#include<queue>
using namespace std;
int memo[1010][1010];
string x,y,q;
int lcs(int xn,int yn){//Y[yn]とX[xn]を比較
    if(memo[xn][yn]!=-1)return memo[xn][yn];
	else if(xn==0 || yn==0)return 0;
	else if(x[xn]==y[yn])return memo[xn][yn] = lcs(xn-1,yn-1)+1;
	else  return memo[xn][yn] = max(lcs(xn,yn-1),lcs(xn-1,yn));
}
 
 
int main(){
    int q;
    cin >> q;
    for(int ds=0; ds<q; ds++){
 
        cin >> x >> y;
        for(int i=0; i<=x.size(); i++){
            for(int j=0; j<=y.size(); j++)memo[i][j]=-1;
        }
        //memset(memo, -1, sizeof(memo));
         
        cout << lcs(x.size(),y.size()) << endl;
 
    }
    return 0;
}

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][ay] = {};
  
  for(int i = 0;i < ax;i++){
    if(X[i] == Y[0]) dp[i][0] = 1;
    else dp[i][0] = max(dp[i][0],dp[i - 1][0]);
  }
  
  for(int j = 1;j < ay;j++){
    if(X[0] == Y[j]) dp[0][j] = 1;
    else 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;
    A[i] = do_dp(X.size(),Y.size());
  }
  
  for(int i = 0;i < q;i++){
    cout << A[i] << '\n';
  }
  
  return 0;
}

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

using namespace std;

int lcs(string s, string t) {
  int n = s.length();
  int m = t.length();
  s = " " + s;
  t = " " + t;
  // dp[i][j] := sのi文字目, tのj文字目まで見たときの LCS
  vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
  for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= m; j++) {
      if (s[i] == t[j]) {
        dp[i][j] = dp[i - 1][j - 1] + 1;
      } else {
        dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
      }
    }
  }
  return dp[n][m];
}

int main() {
  int q;
  cin >> q;

  while (q--) {
    string s, t;
    cin >> s >> t;
    cout << lcs(s, t) << endl;
  }
  return 0;
}

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

static const int N = 1000;

int las(string x, string y) {
int c[N + 1][N + 1];
int m = x.size();
int n = y.size();
int mail = 0;
x = ' ' + x;
y = ' ' + y;
for ( int i = 1; i<= m; i++ ) c[i][0] = 0;
for ( int j = 1; j <= n; 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 mail;
}

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

C++: #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ll long long int
const int INF = 2147483647;

using namespace std;

int dp[1001][1001] = {};
int main()
{
  int q;
  cin >> q;
  REP(i, q)
  {
    string x, y;
    cin >> x >> y;

    REP(i, x.length() + 1)
    {
      dp[i][0] = 0;
    }
    REP(j, y.length() + 1)
    {
      dp[0][j] = 0;
    }

    FOR(i, 1, x.length() + 1)
    {
      FOR(j, 1, y.length() + 1)
      {
        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 - 1], max(dp[i][j - 1], dp[i - 1][j]));
      }
    }
    cout << dp[x.length()][y.length()] << endl;
  }
}

C++: #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;

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

#include <bits/stdc++.h>
using namespace std;

int main(){
  
  int n;
  cin>>n;
  
  int a,b;
  string x,y;
  while(n--){
    cin>>x>>y;
    a=x.size();
    b=y.size();
    int vec[a+1][b+1];
    rep(i,a+2) vec[i][0]=0;
    rep(i,b+2) vec[0][i]=0;
    for(int i=1;i<a+1;i++){
      for(int j=1;j<b+1;j++){
        if(x[i-1]==y[j-1]) vec[i][j]=vec[i-1][j-1]+1;
        else vec[i][j]=max(vec[i][j-1],vec[i-1][j]);
      }
    }
    cout<<vec[a][b]<<endl;
  }
      
  return 0;
}