Go: package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	sc.Scan()
	num, _ := strconv.Atoi(sc.Text())
	for i := 0; i < num; i++ {
		sc.Scan()
		in1 := sc.Text()
		sc.Scan()
		in2 := sc.Text()
		countMax(in1, in2)
	}
}

func countMax(in1 string, in2 string) {
	counta := make([][]int, len(in2)+1)
	for i := 0; i < len(in2)+1; i++ {
		for j := 0; j < len(in1)+1; j++ {
			counta[i] = append(counta[i], 0)
		}
	}

	// fmt.Println(counta)
	for a1, v1 := range in1 {
		i1 := a1 + 1
		for a2, v2 := range in2 {
			i2 := a2 + 1
			// fmt.Printf("1:%v 2:%v\n", i1, i2)
			if v1 == v2 {
				counta[i2][i1] = counta[i2-1][i1-1] + 1
				continue
			}
			val := counta[i2-1][i1]
			if val < counta[i2][i1-1] {
				val = counta[i2][i1-1]
			}

			counta[i2][i1] = val
		}
	}
	fmt.Println(counta[len(in2)][len(in1)])
}

C++: import sys
sys.setrecursionlimit(10000)

def calc(x,y):
    i = len(x)
    j = len(y)
    if not d[i][j] == None:
        return d[i][j]
    else:
        if x[-1] == y[-1]:
            tmp = calc(x[:-1],y[:-1])+1
            d[i][j] = tmp
            return tmp
        else:
            tmp = max(calc(x[:-1],y),calc(x,y[:-1]))
            d[i][j] = tmp
            return tmp
        
q = int(input())
for i in range(q):
    x = input()
    y = input()
    d = [[0 if i == 0 or j == 0 else None for i in range(len(y)+1)] for j in range(len(x)+1)]
    print(calc(x,y))

C++: #include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
using namespace std;
int dp[1001][1001];
int solve(string a,string b)
{	
	
	int maxn=0;
	int len1=a.size(),len2=b.size();
	

	for(int i=1;i<=len1;i++)
		for(int j=1;j<=len2;j++)
		{
			if(a[i-1]==b[j-1])
				dp[i][j]=dp[i-1][j-1]+1;
			else 
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);//这个只是表示某个状态的不是最大的，这个是自己设定的
			maxn=max(maxn,dp[i][j]);
		}
		return maxn;
		
		
	
}
int main()
{	int n;
	string a,b;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>a>>b;
		cout<<solve(a,b)<<endl;
	}
	return 0;
}

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

int c[10001][10001];

int llcs(string X, string Y)
{
    //cout << "hhh" << endl;
    //cout << X << " " << Y << endl;
    int m=X.size();
    int n=Y.size();
    //cout << m << " " << n << endl;
    int maxl=0;
    X=' '+X;
    Y=' '+Y;

    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++)
        {
            //cout << i << " " << j << c[i][j] << endl;
            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()
{
    int N;
    cin >> N;
    string X,Y;
    for(int i=0;i<N;i++)
    {
        cin >> X;
        cin >> Y;
        cout << llcs(X,Y) << endl;
    }

    return 0;
}

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

string X, Y;
int q, lx, ly;
int dp[1010][1010];

int main() {
    cin >> q;
    
    for (int i=0; i<q; ++i) {
        cin >> X >> Y;
        lx = X.size();
        ly = Y.size();
        for (int i=0; i<=ly; ++i) dp[i][0] = 0;
        for (int i=0; i<=lx; ++i) dp[0][i] = 0;

        for (int j=1; j<=ly; ++j) {
            for (int k=1; k<=lx; ++k) {
                if (Y[j-1]==X[k-1]) dp[j][k] = dp[j-1][k-1] + 1;
                else dp[j][k] = max(dp[j-1][k], dp[j][k-1]);
            }
        }
        cout << dp[ly][lx] << endl;
    }

    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
void solve(string s, string t){
    int l1=s.size(),l2=t.size();
    vector <vector<int>> dp(l1+10 ,vector <int>(l2+10 ));
    for(int i=0;i<l1;i++){
        for(int j=0;j<l2;j++){
            if(s[i]==t[j]) {
                dp[i+1][j+1] = max(dp[i][j] + 1, dp[i+1][j+1]);
            }else{
                dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1]);
            }
        }
    }
    cout<<dp[l1][l2]<<endl;
}
int main(void){
    int n; cin>>n;
    for(int i=0;i<n;i++){
        string s,t; cin>>s>>t;
        solve(s,t);
    }
}

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

using ll = long long;
#define REP(i,n) for(int i=0; i < (n); ++i)
#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)

#define INF 1e9

int solve(string X, string Y){
  int dp[X.size()+1][Y.size()+1] = {0};
  REP(i, X.size()+1){
    REP(j, Y.size()+1){
      dp[i][j] = 0;
    }
  }
  REP(i, X.size()){
    REP(j, Y.size()){
      if(X[i] == Y[j]){
        dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j]+1);
      }
      dp[i+1][j+1] = max({dp[i+1][j+1], dp[i][j], dp[i][j+1], dp[i+1][j]});
    }
  }
  return dp[X.size()][Y.size()];
}
int main(){
  int q;
  cin >> q;
  while(q--){
    string X, Y;
    cin >> X >> Y;
    cout << solve(X, Y) << endl;
  }
  return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
static const int hoge = 1000;
int C[1000][1000];
int lc(string F, string S){

    fill(C[0],C[hoge],0);
    int m = F.size(), n = S.size();
    int len=0;
    for(int i=0; i<m; i++){
        for (int j = 0; j < n; ++j) {
            if (F[i] == S[j]) {
                if (i - 1 >= 0 && j - 1 >= 0)
                    C[i][j] = C[i - 1][j - 1] + 1;
                else
                    C[i][j] = 1;
            } else if (i - 1 < 0) {
                if(j-1 < 0){
                    C[i][j] = 0;
                }else{
                    C[i][j] = C[i][j - 1];
                }
            }else if(j-1 < 0) {
                C[i][j] = C[i - 1][j];
            }else{
                C[i][j] = max(C[i-1][j], C[i][j - 1]);
            }
            len = max(len, C[i][j]);
        }
    }
    return len;
}

int main() {
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    string ar1,ar2;
    for (int i = 0; i < n; ++i) {
        cin >> ar1 >> ar2;
        cout << lc(ar1,ar2) << 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 + 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<algorithm>
#include<string>

using namespace std;

int lcs (string x, string y) {

    int m, n, c[1001][1001], i, j, maxl = 0;

    m = x.size();
    n = y.size();

    x = ' ' + x;
    y= ' ' + y;

    for (i = 0; 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]);
                }

                maxl = max (maxl c[i][j]);

            }
    }

    return maxl;

}



int main () {

    int N, i;
    string x, y;

    cin >> N;

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

    }

    return 0;

}