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 Rust (1.42.0) (judge verdict: Accepted)

use std::io;
use std::str::FromStr;
use std::cmp::max;

type Pair = (usize, usize);

fn input_char_vec() -> Vec<char> {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    line.trim().chars().collect()
}

fn main() {
    let s = input_char_vec();
    let t = input_char_vec();
    let mut dp = vec![vec![0; t.len() + 1]; s.len() + 1];
    let mut prev: Vec<Vec<Pair>> = vec![vec![(0, 0); t.len() + 1]; s.len() + 1];
    for i in 0..s.len() {
        for j in 0..t.len() {
            if s[i] == t[j] {
                dp[i+1][j+1] = dp[i][j] + 1;
                prev[i+1][j+1] = (i, j);
            } else {
                if dp[i][j+1] > dp[i+1][j] {
                    dp[i+1][j+1] = dp[i][j+1];
                    prev[i+1][j+1] = (i, j+1);
                } else {
                    dp[i+1][j+1] = dp[i+1][j];
                    prev[i+1][j+1] = (i+1, j);
                }
            }
        }
    }
    let mut i = s.len();
    let mut j = t.len();
    let mut ans: Vec<char> = Vec::new();
    while (i, j) != (0, 0) {
        // println!("{}, {}, {:?}", i, j, prev[i][j]);
        let pre_i = prev[i][j].0;
        let pre_j = prev[i][j].1;
        if pre_i < i && pre_j < j {
            ans.push(s[pre_i]);
        }
        i = pre_i;
        j = pre_j;
    }
    // println!("{:?}", dp);
    ans.reverse();
    for c in ans {
        print!("{}", c);
    }
    println!();
}