Go: package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	n, err := nextInt(sc)
	if err != nil {
		panic(err)
	}
	for i := 0; i < n; i++ {
		strX := nextText(sc)
		strY := nextText(sc)
		fmt.Println(calcLcs(strX, strY))
	}
}

func calcLcs(strX, strY string) int {
	lenX, lenY := len(strX), len(strY)
	memo := make([][]int, lenX+1)
	for i := 0; i < lenX+1; i++ {
		memo[i] = make([]int, lenY+1)
	}

	lcs := 0
	for i := 1; i < lenX+1; i++ {
		for j := 1; j < lenY+1; j++ {
			if strX[i-1] == strY[j-1] {
				memo[i][j] = memo[i-1][j-1] + 1
			} else {
				if memo[i-1][j] > memo[i][j-1] {
					memo[i][j] = memo[i-1][j]
				} else {
					memo[i][j] = memo[i][j-1]
				}
			}
			if memo[i][j] > lcs {
				lcs = memo[i][j]
			}
		}
	}
	return lcs
}

func nextInt(sc *bufio.Scanner) (int, error) {
	sc.Scan()
	return strconv.Atoi(sc.Text())
}

func nextText(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

C++: /* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   main.cpp                                           :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: monoue <marvin@student.42.fr>              +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2020/04/22 12:30:15 by monoue            #+#    #+#             */
/*   Updated: 2020/04/30 08:16:32 by monoue           ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include <bits/stdc++.h>

/* #include <boost/multi_array.hpp> */
/* #include <boost/optional.hpp> */
/* #include <boost/range/irange.hpp> */
/* #include <boost/range/algorithm.hpp> */
/* #include <boost/range/adaptors.hpp> */
/* #include <boost/multiprecision/cpp_int.hpp> */
/* #include <boost/algorithm/string/classification.hpp> // is_any_of */
/* #include <boost/algorithm/string/split.hpp> */
/* #include <boost/algorithm/string/join.hpp> */
/* #include <boost/algorithm/string/replace.hpp> */
/* #include <boost/math/tools/minima.hpp> */
/* namespace adaptor = boost::adaptors; */
/* using boost::math::tools::brent_find_minima; */
/* using boost::irange; */
/* using boost::algorithm::join; */
/* using boost::algorithm::split; */
/* using boost::algorithm::replace_all; */
/* using boost::multiprecision::cpp_int; */

#define MOD 1000000007;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rrep(i, n) for (int i = (n); i >= 0; --i)

using namespace std;
using ll = long long;
using P = pair<int, int>;
static const int	N = 1000;

// TOP
void	Main()
{
	int n;
	cin >> n;

	rep(i, n)
	{
		string	sa, sb;
		cin >> sa >> sb;
		sa = ' ' + sa;
		sb = ' ' + sb;
		int	la, lb;
		la = sa.size();
		lb = sb.size();

		vector<vector<int>>	V(la + 1, vector<int>(lb + 1));
		rep2(i, 1, la)
		{
			rep2(j, 1, lb)
			{
				if (sa.at(i) == sb.at(j))
					V.at(i).at(j) = V.at(i - 1).at(j - 1) + 1;
				else
					V.at(i).at(j) = max(V.at(i - 1).at(j), V.at(i).at(j - 1));
			}
		}
		cout << V.at(la - 1).at(lb - 1) << endl;
	}
}
// END

int		main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	Main();
}

C++: #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;
	Y = " " + Y;
	for(int i = 0; i <= m; i++) c[i][0] = 0;
	for(int j = 0; 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 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<stdio.h>
//#include<cstdlib>
#include<cstring>

#define MAX_LEN 1000

int c[MAX_LEN+1][MAX_LEN+1]; // length of longest common subsequence

void p(){
    printf("\ntest\n");
}

int max(int a, int b){
    return a > b ? a : b;
}

int LCS(char *s1, char *s2){
    int i, j,   l, m;
    l = strlen(s1);
    m = strlen(s2);
    //printf("l:%d m:%d", l, m);
    
    for (i = 0; i < l; i++) {
        c[i][0] = 0;
     }
    
    for (j = 0; j < m; j++) {
        c[0][j] = 0;
    }
    
    
    for (i = 1; i < l+1; i++) {
        for (j = 1; j < m+1; j++) {
            if (s1[i-1] == s2[j-1]) {
                c[i][j] = c[i-1][j-1] + 1;
            }else{
                c[i][j] = max(c[i][j-1], c[i-1][j]);
            }
            //printf("c[%d][%d]:%d\n", i, j, c[i][j]);
        }
    }
    
    
    return c[l][m];
}

int main(){
    int i, n;
    char s1[MAX_LEN+1], s2[MAX_LEN+1];
    
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        scanf(" %s", s1);
        scanf(" %s", s2);
        //printf("%s\n%s\n", s1, s2);
        printf("%d\n", LCS(s1, s2));
    }
    
    return 0;
}

C++: #include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
int p[1001][1001]={0};
int main(){
int i,j,q,e,l,z,m,u,n;
char s[2001],c[2001];
cin>>q;
for(e=0;e<q;e++){
scanf("%s %s",s,c);
l=strlen(s);
z=strlen(c);

for(i=0;i<=l;i++){
	for(j=0;j<=z;j++){
		p[i][j]=0;
	}
}
n=0;
for(i=1;i<=z;i++){
	for(j=1;j<=l;j++){
		if(c[i-1]==s[j-1])p[j][i]=p[j-1][i-1]+1;
		else p[j][i]=p[j][i-1];
	}
}
cout<<p[l][z]<<endl;
}
return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
using lint = int64_t;
#define rep(i, n) for(int i=0; i<(n); ++i)
#define all(v)    begin(v), end(v)
#define in        []{lint n; cin>>n; return n;}()


#define LCS longest_common_subsequence
int longest_common_subsequence( const string S, const string T ) {
    vector<vector<int>> dp( S.size()+1, vector<int>(T.size()+1, 0) );

    rep( s, S.size() ) {
    rep( t, T.size() ) {
        dp[s+1][t+1] = S[s] == T[t] ?
            dp[s][t] + 1 :
            max( dp[s][t+1], dp[s+1][t] );
    }
    }

    return dp[S.size()][T.size()];
}

int main() { cin.tie(0); ios::sync_with_stdio(false);
    int N = in;
    rep( _, N ) {
        string S, T; cin >> S >> T;
        cout << LCS( S, T ) << "\n";
    }
}