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: Accepted)

#[allow(unused_macros)]
macro_rules! input {
    ( $($t:ty),* ) => {{
        let mut s = String::new();
        std::io::stdin().read_line(&mut s);
        let mut splits = s.trim().split_whitespace();
        ($( { splits.next().unwrap().parse::<$t>().unwrap() },)*)
    }}
}

use std::collections::HashMap;
use std::collections::BTreeSet;
use std::collections::BTreeMap;


use std::fmt::Display;
pub fn print_vec<T: Display>(v: &Vec<T>, prefix: &str, suffix: &str) {
    if v.is_empty() {
        println!("[]");
        return;
    }
    print!("{}", prefix);
    print!("{}", v[0]);
    for i in 1..v.len() {
        print!(" {}", v[i]);
    }
    println!("{}", suffix);
}

#[allow(unused_must_use)]
#[allow(unused_variables)]
fn solve() {
    let (s,) = input!(String);
    let (t,) = input!(String);

    let slen = s.len();

    let mut ss = s.clone();

    ss.push_str(&s);

    let mut next_char: HashMap<(usize, char, char), usize> = HashMap::new();
    // let chs = HashMap::new();

    let mut cindex = HashMap::new();

    for (i, c) in ss.char_indices() {
        let v = cindex.entry(c).or_insert(vec![]);
        (*v).push(i);
    }

    for (i, c) in s.char_indices() {
        for &key in cindex.keys() {
            if let Some(v) = cindex.get(&key) {
                match v.binary_search(&i) {
                    Ok(next) => {
                        next_char.insert((i, c, key), v[next + 1]);
                    },
                    Err(next) => {
                        next_char.insert((i, c, key), v[next]);
                    }
                    //     if i <= next {
                    //         next_char.insert((i, c, key), next - i);
                    //     } else {
                    //         next_char.insert((i, c, key), i + slen - next);
                    //     }
                    // }
                }
            }
        }
    }

    let first = t.chars().nth(0).unwrap();
    if let None =  s.find(first) {
        println!("-1");
        return;
    }
    let mut index = s.find(first).unwrap();
    let mut current = first;
    let mut ans = index;

    for (i, c) in t.char_indices().skip(1) {
        if let Some(&ind) = next_char.get(&(index % slen, current, c)) {
            if index < ind {
                ans += ind - index;
            } else {
                ans += slen + ind - index;
            }
            index = ind;
            current = c;
        } else {
            println!("-1");
            return;
        }
    }

    println!("{}", ans + 1);
}

fn main() {
    solve();
}