Go: // AOJ ALDS1_10_C: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_C

package main

import (
	"fmt"
)

func main() {
	var dataNum int
	var s1, s2 string

	fmt.Scanf("%d", &dataNum)

	for i := 0; i < dataNum; i++ {
		fmt.Scanf("%s", &s1)
		fmt.Scanf("%s", &s2)

		lcs := make([][]int, len(s1)+1)
		for j := 0; j < len(s1)+1; j++ {
			lcs[j] = make([]int, len(s2)+1)
		}

		for m, vs1 := range s1 {
			for n, vs2 := range s2 {
				if vs1 == vs2 {
					lcs[m+1][n+1] = lcs[m][n] + 1
				} else if lcs[m+1][n] > lcs[m][n+1] {
					lcs[m+1][n+1] = lcs[m+1][n]
				} else {
					lcs[m+1][n+1] = lcs[m][n+1]
				}
			}
		}

		// Answer
		fmt.Println(lcs[len(s1)][len(s2)])
	}
}

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

C++: #include <iostream>
#include <climits>
#include <string>
using namespace std;
const int MAXSEQ = 1000;
const int INFY = -INT_MAX;

string X, Y;

int max(int m, int n){
    int max = INFY;
    printf("\n");
    return max;
}
int LSCLength(void){
    int m = X.size();
    int n = Y.size();
    int c[m+1][n+1];
    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 = 0; i <= m; i++){
        for (int j = 0; j <= m; j++){
        */
    /*
    if (m > n){
        cout << "will change X =" <<  X << endl;
        swap(m, n);
        swap(X, Y);
        cout << "changed X =" <<  X << endl;
    }*/
    for (int i = 1; i <= m; i++){
        for (int j = 1; j <= n; j++){
            if (X[i-1] == Y[j-1]){
                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];
            }
        }
    }
    int max = INFY;
    //printf("\n");
    /*
    for (int i = 0; i <= m; i++){
        for (int j = 0; j <= n; j++){
            printf("%d ", c[i][j]);
        if (max < c[m][i]) max = c[i][j];
        }
        printf("\n");
    }
    */
    for (int j = 1; j <= n; j++){
        if (max < c[m][j]) max = c[m][j];
    }
    return max;
}

int main(int argc, char* argv[]) {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++){
        cin >> X >> Y;
        cout << LSCLength() << endl;
    }
    return 0;
}