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)

use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
  let stdin = stdin();
  let stdin = stdin.lock();
  let token: String = stdin
    .bytes()
    .map(|c| c.expect("failed to read char") as char)
    .skip_while(|c| c.is_whitespace())
    .take_while(|c| !c.is_whitespace())
    .collect();
  token.parse().ok().expect("failed to parse token")
}

pub fn read_n<T: FromStr>(n: usize) -> Vec<T> {
  read_n_logic::<T>(n, vec![])
}

pub fn read_n_logic<T: FromStr>(n: usize, mut a: Vec<T>) -> Vec<T> {
  match n {
    0 => a,
    _ => {
      a.push(read::<T>());
      read_n_logic(n - 1, a)
    }
  }
}

use std::cmp::{max, min};
use std::collections::HashMap;

fn main() {
  let s: String = read();
  let t: String = read();
  let mut dist: HashMap<char, Vec<i64>> = HashMap::new();

  for (i, c) in s.chars().enumerate() {
    if dist.contains_key(&c) {
      let current = dist.get_mut(&c).unwrap();
      current.push(i as i64);
    } else {
      dist.insert(c, vec![i as i64]);
    }
  }

  let mut ans: i64 = 0;
  let mut prev_idx = -1;

  for (i, c) in t.chars().enumerate() {
    if dist.contains_key(&c) {
      let target_vec = dist.get_mut(&c).unwrap();
      if i == 0 {
        prev_idx = target_vec[0];
        continue;
      }

      let mut current_idx = -1;
      for i in target_vec.clone() {
        if prev_idx < i {
          current_idx = i;
          break;
        }
      }

      if current_idx == -1 {
        ans += s.len() as i64;
        prev_idx = target_vec[0];
      } else {
        prev_idx = current_idx;
      }
    } else {
      ans = -1;
      break;
    }
  }

  ans += s.len() as i64;
  ans -= s.len() as i64 - prev_idx - 1;


  println!("{}", ans);

}