Problem:
Score : 100 points

Problem Statement

You are given strings s and t.
Find one longest string that is a subsequence of both s and t.

Notes

A subsequence of a string x is the string obtained by removing zero or more characters from x and concatenating the remaining characters without changing the order.

Constraints

s and t are strings consisting of lowercase English letters.

1 \leq |s|, |t| \leq 3000

Input

Input is given from Standard Input in the following format:

s
t

Output

Print one longest string that is a subsequence of both s and t.
If there are multiple such strings, any of them will be accepted.

Sample Input 1

axyb
abyxb

Sample Output 1

axb

The answer is axb or ayb; either will be accepted.

Sample Input 2

aa
xayaz

Sample Output 2

aa

Sample Input 3

a
z

Sample Output 3

The answer is (an empty string).

Sample Input 4

abracadabra
avadakedavra

Sample Output 4

aaadara

Solution in OCaml (4.02.3) (judge verdict: Time Limit Exceeded)

let longer s1 s2 =
    if List.length s1 >= List.length s2
    then s1
    else s2

let rec update t_i s dp dp_i_j1 dp_i1_j1 =
    match s, dp with
    | s_j :: s', dp_i1_j :: dp' ->
        let dp_i_j =
            if s_j = t_i
            then s_j :: dp_i1_j1
            else longer dp_i1_j dp_i_j1
        in dp_i_j :: update t_i s' dp' dp_i_j dp_i1_j
    | _ -> dp

let rec solve s t dp =
    match t with
    | t_i :: t' -> solve s t' @@ update t_i s dp [] []
    | [] -> dp

let () =
    let s = read_line () |> Str.split (Str.regexp "") |> List.map (fun s -> s.[0]) in
    let t = read_line () |> Str.split (Str.regexp "") |> List.map (fun s -> s.[0]) in
    let rec init n =
        if n = 0 then []
        else [] :: init (n - 1)
    in
    let s_len = List.length s in
    solve s t (init s_len)
    |> (fun ls -> List.nth ls (s_len - 1))
    |> List.rev
    |> List.iter print_char
    ;
    print_newline ()