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 Common Lisp (SBCL 1.1.14) (judge verdict: Accepted)

(defun lcs (str1 str2 &key (backtrace nil))
  (let* ((dp-table (make-array (list (1+ (length str1)) (1+ (length str2)))
                               :initial-element 0 :element-type 'fixnum)))
    (loop :for k :from 1 :upto (length str1)
          :do(loop :for l :from 1 :upto (length str2)
                   :do (setf (aref dp-table k l) (max (aref dp-table (1- k) l)
                                                      (aref dp-table k (1- l))
                                                      (if (char= (aref str1 (1- k))
                                                                 (aref str2 (1- l)))
                                                          (1+ (aref dp-table (1- k) (1- l)))
                                                          0)))))
    (if backtrace
        (let* ((ret nil)
               (mem (length str2)))
          (loop :for k :from (length str1) :downto 1
                :do(loop :for l :from mem :downto 1
                         :always (= (aref dp-table k l)
                                    (aref dp-table k mem))
                         :never (if (and (not (= (aref dp-table k l) (aref dp-table (1- k) l)))
                                         (not (= (aref dp-table k l) (aref dp-table k (1- l)))))
                                    (progn (push l ret) (setf mem (1- l))))))
          (concatenate 'String (loop :for k :in ret :collect (aref str2 (1- k)))))
        dp-table)))
(princ (lcs (read-line) (read-line) :backtrace t))