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++: /* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   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";
    }
}