Go: ///
// File:  0528.go
// Author: ymiyamoto
//
// Created on Thu Mar 22 01:52:09 2018
//
package main

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

var S, T string
var dp [4001][4001]int

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for {
		scanner.Scan()
		S = scanner.Text()
		if len(S) == 0 {
			return
		}

		scanner.Scan()
		T = scanner.Text()

		for i := range dp {
			for j := range dp[i] {
				dp[i][j] = 0
			}
		}

		dp[0][0] = 0
		for i := range S {
			for j := range T {
				if S[i] == T[j] {
					dp[i+1][j+1] = max(dp[i+1][j], max(dp[i][j+1], dp[i][j]+1))
				} else {
					dp[i+1][j+1] = 0
				}
			}
		}
		var m int
		for i := range dp {
			for j := range dp[i] {
				m = max(m, dp[i][j])
			}
		}
		fmt.Println(m)
	}
}

C++: #include<stdio.h>
#include<string.h>

int main(void){
char str1[4001],str2[4001];
 int i,j,count,len1,len2;
static short dp[4002][4002];

  while(~scanf("%[^\n]%*c",str1)){
    scanf("%[^\n]%*c",str2);

    memset(dp,0,sizeof(dp));

    count=0;

    len1=strlen(str1);
    len2=strlen(str2);

    for(i=0;i<len1;i++){
      for(j=0;j<len2;j++){

	if(str1[i]==str2[j]){
	  dp[i+1][j+1]=dp[i][j]+1;
	  count=count>dp[i+1][j+1]?:dp[i+1][j+1];
	}
	else dp[i+1][j+1]=0;
	
      }
    }
    printf("%d\n",count);
  }

  return 0;
}

C++: #include<iostream>
#include<string>

using namespace std;

int main()
{
	string str,str2;
	
	for(;cin >> str;)
	{
		cin >> str2 ;
		int ans=0;
		if(str.size()>str2.size())
		{
			string a;
			a=str2;
			str2=str;
			str=a;
		}
		
		for(int i=0;i+ans<str.size();i++)
		{
			for(int j=ans+1;i+j<=str.size();j++)
			{
				string se;
				se=str.substr(i,j);
				if(str2.find(se)!=-1)
				{
					if(ans<se.size())
						ans=se.size();
				}
				else
				{
					break ;
				}
			}
		}
		cout << ans << endl;
	}
}

C++: #include <string>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
class SuffixArray {
	void CEB(vector<int> &v, vector<int> &b) {
		int vs = v.size(), bs = b.size();
		fill(b.begin(), b.end(), 0);
		for (int i = 0; i < vs; i++) b[v[i]]++;
		for (int i = 1; i < bs; i++) b[i] += b[i - 1];
	}
	void ISort(vector<int> &v, vector<int> &SA, int mv, vector<int> &b, vector<int> &isL) {
		int vs = v.size(), bs = b.size();
		fill(b.begin(), b.end(), 0);
		for (int i = 0; i < vs; i++) b[v[i]]++;
		int sum = 0;
		for (int i = 0; i < bs; i++) b[i] += sum, swap(sum, b[i]);
		for (int i = 0; i < vs; i++) {
			if (SA[i] > 0 && isL[SA[i] - 1]) SA[b[v[SA[i] - 1]]++] = SA[i] - 1;
		}
	}
	void IISort(vector<int> &v, vector<int> &SA, int mv, vector<int> &b, vector<int> &isL) {
		CEB(v, b);
		for (int i = v.size() - 1; i >= 0; i--) {
			if (SA[i] > 0 && !isL[SA[i] - 1]) SA[--b[v[SA[i] - 1]]] = SA[i] - 1;
		}
	}
	vector<int>SA_IS(vector<int> v, int mv) {
		int vs = v.size();
		if (vs == 1) return vector<int>(1, 0);
		vector<int> isL(vs), b(mv + 1), SA(vs, -1), ord(vs);
		auto isLMS = [&](int x)->bool { return x > 0 && isL[x - 1] && !isL[x]; };
		for (int i = vs - 2; i >= 0; i--) isL[i] = (v[i] > v[i + 1]) || (v[i] == v[i + 1] && isL[i + 1]);
		CEB(v, b);
		for (int i = 0; i < vs; i++) {
			if (isLMS(i)) SA[--b[v[i]]] = i;
		}
		ISort(v, SA, mv, b, isL);
		IISort(v, SA, mv, b, isL);
		int cur = 0;
		for (int i = 0; i < vs; i++) {
			if (isLMS(i)) ord[i] = cur++;
		}
		vector<int> nxv(cur);
		cur = -1;
		int prev = -1;
		for (int i = 0; i < vs; i++) {
			if (!isLMS(SA[i])) continue;
			bool diff = false;
			for (int d = 0; d < vs; d++) {
				if (prev == -1 || v[SA[i] + d] != v[prev + d] || isL[SA[i] + d] != isL[prev + d]) {
					diff = true;
					break;
				}
				else if (d && isLMS(SA[i] + d))break;
			}
			if (diff) cur++, prev = SA[i];
			nxv[ord[SA[i]]] = cur;
		}
		vector<int> reord(nxv.size());
		for (int i = 0; i < vs; i++) {
			if (isLMS(i)) reord[ord[i]] = i;
		}
		vector<int> nxSA = SA_IS(nxv, cur);
		CEB(v, b);
		for (int i = 0; i < SA.size(); i++) SA[i] = -1;
		for (int i = nxSA.size() - 1; i >= 0; i--) {
			SA[--b[v[reord[nxSA[i]]]]] = reord[nxSA[i]];
		}
		ISort(v, SA, mv, b, isL);
		IISort(v, SA, mv, b, isL);
		return SA;
	}
	vector<int>SA_IS(string s) {
		vector<int> v(s.size() + 1);
		for (int i = 0; i < s.size(); i++) v[i] = s[i] + 1;
		return SA_IS(v, *max_element(v.begin(), v.end()));
	}
	vector<int>construct_lcp(string &s, vector<int> &sa) {
		vector<int> lcp, rank(s.size() + 1);
		int n = s.size(), h = 0;
		for (int i = 0; i <= n; i++) rank[sa[i]] = i;
		for (int i = 0; i < n; i++) {
			int j = sa[rank[i] - 1];
			if (h) h--;
			for (; j + h < n && i + h < n; h++) {
				if (s[j + h] != s[i + h]) break;
			}
			lcp[rank[i] - 1] = h;
		}
		return lcp;
	}
public:
	string s;
	vector<int> sa, lcp;
	void init(string &T) {
		s = T;
		sa = SA_IS(s);
		lcp = construct_lcp(s, sa);
	}
	SuffixArray(string &t) { init(t); }
	SuffixArray() {}
	bool contain(string &t) {
		int a = 0, b = s.size();
		while (b - a > 1) {
			int c = (a + b) / 2;
			if (s.compare(sa[c], t.size(), t) < 0) a = c;
			else b = c;
		}
		return s.compare(sa[b], t.size(), t) == 0;
	}
};
string s, t;
int main() {
	while(cin >> s >> t) {
		SuffixArray v(s + "$" + t);
		int ret = 0, e = s.size() + t.size() + 1;
		for(int i = 0; i < e; i++) {
			if((v.sa[i] < sl) != (v.sa[i + 1] < sl)) ret = max(ret, v.lcp[i])
		}
		cout << ret << endl;
	}
}

C++: #include <bits/stdc++.h>
using namespace std;
int dp[4001][4001];
int main(){
	string a,b;
	while(true){
		cin>>a>>b;
		if(cin.eof())	return 0;
		memset(dp,0,sizeof(dp));
		int ans=0;
		for(int i=0;i<(int)a.size();i++){
			for(int j=0;j<(int)b.size();j++){
				if(a[i]==b[j]){
					if(i*j==0)	dp[i][j]=1;
					else 	dp[i][j]=dp[i-1][j-1]+1;
					ans=max(ans,dp[i][j]);
				}
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}

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

int dp[4005][4005];

int main() {
	string s;
	while (cin >> s) {
		string sa;
		cin >> sa;
		for (int i = 0; i < 4003; i++)
			for (int j = 0; j < 4003; j++)dp[i][j] = 0;
		s.push_back('@');
		int ans = 0;
		for (int i = 0; i < s.size(); i++) {
			for (int j = 0; j < sa.size(); j++) {
				int a = s.size();
				int I = min(a-1, i + j);
				if (s[I] == sa[j]) {
					dp[I][j + 1] = dp[I-1][j] + 1;
					ans = max(ans, dp[I][j + 1]);
				}
				else dp[I][j + 1] = 0;
			}
		}
		cout << ans << endl;
	}
	return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <climits>
#include <string>
#include <vector>
#include <cstdlib>
#include <cmath>

using namespace std;

#define rep(i, n)      for (int i=0; i<int(n); i++)
#define rep3(i, s, n)  for (int i=int(s); i<int(n); i++)
#define rev_rep(i, n)  for (int i=int(n)-1; i>=0; i-=1)

string s;
string t;
int dp[4010][4010];
int main() {
  while (cin >> s >> t) {
  int s_len = s.length(), t_len = t.length();
  rep(i, s_len+1) {
    rep(j, t_len+1) {
      dp[i][j] = 0;
    }
  }
  rep(i, s_len) {
    rep(j, t_len) {
      if (s[i] == t[j]) dp[i+1][j+1] = dp[i][j] + 1;
      else              dp[i+1][j+1] = 0;
    }
  }
  int ans = 0;
  rep(i, s_len+1) {
    rep (j, t_len+1) {
      ans = max(ans, dp[i][j]);
    }
  }
  cout << ans << "\n";
  }
  return 0;
}

C++: #include <cstdio>
#include <cstring>

int main(void){
  char ra[4005]={0};
  char rb[4005]={0};
  while(scanf("%s%s",ra,rb)!=EOF){
    int alen=strlen(ra);
    int blen=strlen(rb);
    //printf("%d\n%d\n",alen,blen);
    int i=0;
    int j=0;
    int k=0;
    int h=0;
    int km=0;
    int ans=0;
    for(i=-blen+1;i<alen;i++){
      k=(alen-i<blen)?alen-i:blen;
      h=(i<0)?-i:0;
      km=0;
      for(j=h;j<k;j++){
	if(ra[j]==rb[i+j]){
	  km++;
	}
	else{
	  ans=(ans<km)?km:ans;
	  km=0;
	}
      }
    }
    printf("%d\n",ans);
  }
  return 0;
}