Go: package main

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

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

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++: #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 = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (s1[i] == s2[j])
                c[i+1][j+1] = c[i][j] + 1;
            else
                c[i+1][j+1] = max(c[i][j+1], c[i + 1][j]);
        }
    }
    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;
}

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

int main(void){
    int q; cin >> q;
    int dp[1001][1001];
    for(int i = 0; i < 1001; i++) dp[0][i] = dp[i][0] = 0;

    for(int i = 0; i < q; i++){
        string a, b; cin >> a >> b;
        int len_a = (int)a.size(), len_b = (int)b.size();
        for(int j = 1; j <= len_a; j++){
            for(int k = 1; k <= len_b; k++){
                if(a[j]==b[k]) dp[j][k] = dp[j-1][k-1] + 1;
                else dp[j][k] = max(dp[j-1][k], dp[j][k-1]);
            }
        }

        cout << dp[len_a][len_b] << '\n';
    }

    return 0;
}

C++: #include "bits/stdc++.h"
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define FOR(i, a) for (auto &i: a)
#define ALL(obj) begin(obj), end(obj)
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define sum(x) accumulate(ALL(x), 0LL)
#define LOWER_BOUND(A, key) distance(A.begin(), lower_bound(ALL(A), key))
#define UPPER_BOUND(A, key) distance(A.begin(), upper_bound(ALL(A), key))

using namespace std;
const int MOD    = (int)(1e9 + 7);
const int INF    = (int)(1e13 + 7);
const double EPS = 1e-14;
const double PI  = acos(-1);

int CEIL(int a, int b) { return (a >= 0 ? (a + (b - 1)) / b : (a - (b - 1)) / b); } //ceil() for int
int mod(int a, int b) { return a >= 0 ? a % b : a - (b * CEIL(a, b)); }             //always return positive num
int bpm(int a, int b) {                                                             //return x^y in order(log(y))
  int res = 1;
  for (a %= MOD; b; a = a * a % MOD, b >>= 1)
    if (b & 1) res = res * a % MOD;
  return res;
}

struct LCS {
private:
  vector<vector<int>> dp;
  string one, two;
  int n1, n2;

public:
  LCS(string &temp1, string &temp2): n1(temp1.size()), n2(temp2.size()) {
    one = temp1;
    two = temp2;
    dp.assign(n1 + 1, vector<int>(n2 + 1, 0));
  }
  int lcs() {
    for (int i = 0; i < n1; i++) {
      for (int j = 0; j < n2; j++) {
        if (one[i] == two[j]) {
          dp[i + 1][j + 1] = max({dp[i][j] + 1, dp[i + 1][j], dp[i][j + 1]});
        } else {
          dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j]);
        }
      }
    }
    return dp[n1][n2];
  }
};

signed main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int n;
  cin >> n;
  rep(_, n) {
    string temp1, temp2;
    cin >> temp1 >> temp2;
    LCS lcs(temp1, temp2);
    cout << lcs.lcs() << endl;
  }
}

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

int main(){
  int n;
  std::cin>>n;
  int B[1500]={0};
  for(int k=0;k<n;k++){
    std::string str1;
    std::string str2;
    std::cin>>str1;
    std::cin>>str2;
    int A[1000][1000]={0};
    /*初期化？*/
    for(int i=0;i<str1.size();i++){
      for(int j=0;j<str2.size();j++){
	if(j==0){
	  if(str1[i]==str2[j]){
	    A[i][j]=1;
	  }
	  if(i>0){
	    A[i][j]=std::max(A[i][j],A[i-1][j]);
	  }
	}
	if(i==0){
	  if(str1[i]==str2[j]){
	    A[i][j]=1;
	  }
	  if(i>0){
	    A[i][j]=std::max(A[i][j],A[i][j-1]);
	  }
	}
      }
    }
    for(int i=1;i<str1.size();i++){
      for(int j=1;j<str2.size();j++){
	if(str1[i]==str2[j]){
	  A[i][j]=A[i-1][j-1]+1;
	}else{
	  A[i][j]=std::max(A[i-1][j],A[i][j-1]);
	}
      }
    }
    B[k]=A[str1.size()-1][str2.size()-1];
  }
  for(int i=0;i<n;i++){
    std::cout<<B[i]<<"\n";
  }
  return 0;
}

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

#define MAX 1000

int lcs(string X, string Y) {
    int c[MAX+1][MAX+1];
    int m = X.size();
    int n = Y.size();
    int i, j;
    int maxlen = 0;
    X = " " + X;
    Y = " " + Y;

    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] == Y[j]) {
                c[i][j] = c[i-1][j-1] + 1;
            }else if( c[i-1][j] >= c[i][j-1] ) {
                c[i][j] = c[i-1][j];
            }else {
                c[i][j] = c[i][j-1];
            }
            maxlen = max(maxlen, c[i][j]);
        }
    }
    return maxlen;
}

int main (void) {
    int N, i;
    string x, y;
    int l[MAX+1];    

    cin >> N;

    for(i = 0 ; i < N ; i++) {
        cin >> x;
        cin >> y;
        l[i] = lcs(x,y);
    }

    for(i = 0 ; i < N ; i++) {
        printf("%d\n", l[i]);
    }

    return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<string>
#include<algorithm>
#include<vector>
#include<cmath>
#include<map>
#include<bitset>
#include<queue>
#include<set>
using namespace std;
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) FOR(i,0,n)
#define MAX 1002
typedef long long ll;

int make(string a, string b){

	int dp[MAX][MAX] = {};
	
	a = ' ' + a;
	b = ' ' + b;

	int len_a = a.size();
	int len_b = b.size();

	FOR(i,1,len_a){
	FOR(j,1,len_b){
	if (a[i]==b[j]) dp[i][j] = 1 + dp[i-1][j-1];
	else dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
	}
	}

	return dp[len_a-1][len_b-1];
} 	
	

int main(){
	int q;
	cin >> q;
	string str1,str2;
	rep(i,q){
	cin >> str1>>str2;
	cout << make(str1,str2) << endl;
	}
	return 0;
}

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

using namespace std;

string s, t;

vector<vector<int>> memo(2000, vector<int>(2000,-1));

//s???i??????????????§???t???j??????????????§?????£?????¨??????LCS
int solve(int i, int j) {
	if (memo[i][j] != -1)return memo[i][j];

	if (i == 0 && j == 0)return (s[0] == t[0]);
	if (i == 0)return memo[i][j] = (bool)(solve(i, j - 1) + (s[i] == t[j]));
	if (j == 0)return memo[i][j] = (bool)(solve(i - 1, j) + (s[i] == t[j]));
	if (s[i] == t[j]) return solve(i - 1, j - 1) + 1;
	return memo[i][j] = max(solve(i - 1, j), solve(i, j - 1));
}

int main() {
	int n;
	cin >> n;
	while (n--) {
		cin >> s >> t;
		memo = vector<vector<int>>(2000, vector<int>(2000,-1));
		cout << solve(s.size() - 1, t.size() - 1) << endl;
	}
}