Problem:
Score : 500 points

Problem Statement

Given are two strings s and t consisting of lowercase English letters. Determine if there exists an integer i satisfying the following condition, and find the minimum such i if it exists.

Let s' be the concatenation of 10^{100} copies of s. t is a subsequence of the string {s'}_1{s'}_2\ldots{s'}_i (the first i characters in s').

Notes

A subsequence of a string a is a string obtained by deleting zero or more characters from a and concatenating the remaining characters without changing the relative order. For example, the subsequences of contest include net, c, and contest.

Constraints

1 \leq |s| \leq 10^5

1 \leq |t| \leq 10^5

s and t consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

s
t

Output

If there exists an integer i satisfying the following condition, print the minimum such i; otherwise, print -1.

Sample Input 1

contest
son

Sample Output 1

10

t = son is a subsequence of the string contestcon (the first 10 characters in s' = contestcontestcontest...), so i = 10 satisfies the condition.

On the other hand, t is not a subsequence of the string contestco (the first 9 characters in s'), so i = 9 does not satisfy the condition.

Similarly, any integer less than 9 does not satisfy the condition, either. Thus, the minimum integer i satisfying the condition is 10.

Sample Input 2

contest
programming

Sample Output 2

-1

t = programming is not a substring of s' = contestcontestcontest.... Thus, there is no integer i satisfying the condition.

Sample Input 3

contest
sentence

Sample Output 3

33

Note that the answer may not fit into a 32-bit integer type, though we cannot put such a case here.

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

#[macro_use]
mod input {

use std;
use std::io;

const SPLIT_DELIMITER: char = ' ';

#[macro_export]
#[allow(unused_macros)]
macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

#[allow(dead_code)]
pub fn input_line_str() -> String {
    let mut s = String::new();
    io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

#[allow(dead_code)]
pub fn p<T>(t: T)
where
    T: std::fmt::Display,
{
    println!("{}", t);
}

#[allow(dead_code)]
pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
where
    T: std::str::FromStr,
{
    let mut v: Vec<Vec<T>> = Vec::new();

    for _ in 0..line {
        let vec_line = input_vector();
        v.push(vec_line);
    }
    v
}

#[allow(dead_code)]
pub fn input_vector<T>() -> Vec<T>
where
    T: std::str::FromStr,
{
    let mut v: Vec<T> = Vec::new();

    let s = input_line_str();
    let split_result = s.split(SPLIT_DELIMITER);
    for z in split_result {
        let buf = match z.parse() {
            Ok(r) => r,
            Err(_) => panic!("Parse Error"),
        };
        v.push(buf);
    }
    v
}

#[allow(dead_code)]
pub fn str2vec(s: &str) -> Vec<char> {
    let mut v: Vec<char> = Vec::new();
    for c in s.chars() {
        v.push(c);
    }
    v
}
}

use input::*;
use std::collections::HashMap;
use std::collections::BTreeSet;

fn main() {
    let mut s = str2vec(&input_line_str());
    let mut t = str2vec(&input_line_str());

    let mut dp = vec![HashMap::new(); s.len()];

    let sets = s.iter().cloned().collect::<BTreeSet<_>>();
    let sett = t.iter().cloned().collect::<BTreeSet<_>>();
    if (&sett - &sets).len() != 0 {
        p(-1);
        return;
    }

    let al = String::from("abcdefghijklmnopqrstuvwxyz");
    for zz in 0..s.len() {
        for z in al.chars() {
            dp[zz].insert(z, 0_usize);
        }
    }
    for (i, _) in s.iter().enumerate() {
        for z in al.chars() {
            if let Some(x) = s.iter().skip(i + 1).position(|&m| m == z) {
                dp[i].insert(z, i + 1 + x);
            } else {
                if let Some(x) = s.iter().position(|&m| m == z) {
                    dp[i].insert(z, x);
                }
            }
        }
    }
    let mut ans:usize = s.iter().position(|&m|m==t[0]).unwrap()+1;
    let mut cur = ans-1;
    for z in t.iter().skip(1) {
        let buf = dp[cur][z];
        println!("{}->{}",cur,buf);
        if cur < buf {
 //           p(buf - cur);
            ans += buf - cur ;
        } else {
   //         p(buf + s.len() - cur);
            ans += buf + s.len() - cur;
        }
        cur = dp[cur][z];
    }
    p(ans);
}