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 Go (1.6) (judge verdict: Accepted)

package main

import (
	"fmt"
)

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

const (
	A = iota
	B
	C
)

func main() {
	var s, t string
	fmt.Scan(&s, &t)
	S, T := len(s), len(t)

	dp := make([][]int, S+1)
	for i := 0; i <= S; i++ {
		dp[i] = make([]int, T+1)
	}

	grid := make([][]int, S+1)
	for i := 0; i <= S; i++ {
		grid[i] = make([]int, T+1)
	}

	for i := 1; i <= S; i++ {
		for j := 1; j <= T; j++ {
			if dp[i-1][j] > dp[i][j] {
				dp[i][j] = dp[i-1][j]
				grid[i][j] = A
			}
			if dp[i][j-1] > dp[i][j] {
				dp[i][j] = dp[i][j-1]
				grid[i][j] = B
			}
			if s[i-1] == t[j-1] {
				if dp[i-1][j-1]+1 > dp[i][j] {
					dp[i][j] = dp[i-1][j-1] + 1
					grid[i][j] = C
				}
			}
		}
	}
	var i, j int
	i = S
	j = T
	out := ""
	for i != 0 && j != 0 {
		switch grid[i][j] {
		case A:
			i--
		case B:
			j--
		case C:
			out += string(s[i-1])
			i--
			j--
		}
	}
	for i := len(out) - 1; i >= 0; i-- {
		fmt.Printf("%c", out[i])
	}
	fmt.Println()
}