Go: package main

import "fmt"

func initialize_grid(width int,height int)[][]int{
	var grid [][]int
	for i:=0;i<height+1;i++{
		var grid_row  []int
		for j:=0;j<width+1;j++{
			grid_row = append(grid_row,0)
		}
		grid = append(grid,grid_row[:])
	}
	return grid
}

func ma(x int,y int)int{
	if x >= y{
		return x
	}else{
		return y
	}
}

func main()  {
	//Take input
	var num int
	var st1,st2 string
	var string_pairs [][]string
	fmt.Scan(&num)
	for i:=0;i<num;i++{
		var string_pair []string
		fmt.Scan(&st1)
		fmt.Scan(&st2)
		string_pair = append(string_pair,st1,st2)
		string_pairs = append(string_pairs,string_pair)
	}
	//DP
	//initialize grid
	for i:=0;i<num;i++{
		string_1 := string_pairs[i][0]
		string_2 := string_pairs[i][1]

		dp := initialize_grid(len(string_2),len(string_1))

		for j:=1;j<len(string_1)+1;j++{
			for k:=1;k<len(string_2)+1;k++{
				if string_1[j-1] == string_2[k-1]{
					dp[j][k] = dp[j-1][k-1] + 1
				}else{
					dp[j][k] = ma(dp[j-1][k],dp[j][k-1])
				}
			}
		}
		fmt.Println(dp[len(string_1)][len(string_2)])
	}
}

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 <= m;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
				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>
#include <string>
#include <cmath>
using namespace std;

int main(){
  int q;
  cin >> q;
  for(int m=0; m<q; m++){
    string wordx, wordy;
    cin >> wordx >> wordy;
    int L[1000][1000]={0};
    
    for(int j=0; j<wordy.size(); j++){
      for(int i=0; i<wordx.size(); i++){
	if(wordx[i]==wordy[j]){
	  L[i][j] = 1+L[i-1][j-1];
	}
	else{
	  L[i][j] = max(L[i][j-1], L[i-1][j]);
	}
      }
    }
    cout << L[wordx.size()-1][wordy.size()-1] << endl;
    
    
  }
}

C++: #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;

int solve() {
    string x, y;
    cin >> x >> y;
    vector<vector<int>> dp(x.size() + 1, vector<int>(y.size() + 1, 0));

    for (int i = 1; i <= x.size(); i++) {
        for (int j = 1; j <= y.size(); j++) {
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            if (x[i - 1] == y[j - 1]) {
                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
            }
        }
    }

    return dp[x.size()][y.size()];
}

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cout << solve() << endl;
    }
}

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

}