impl Solution {
    pub fn find_ocurrences(text: String, first: String, second: String) -> Vec<String> {
        let ss = text.split_whitespace().collect::<Vec<&str>>();
        let mut ans = vec![];
        let (size, mut i, mut j) = (ss.len(), 0, 1);

        while i < size && j < size {
            if *ss[i] == first && *ss[j] == second && j + 1 < size {
                ans.push(ss[j + 1].to_string());
                i = j + 1; j = i + 1; continue;
            } else {
                i += 1; j += 1;
            }
        }

        return ans;
    }
}

use std::collections::HashSet;
impl Solution {
    fn dfs(set: &mut HashSet<String>, level: usize, tiles: &String,
           cur: &mut String, used: &mut Vec<bool>) {
        let size = tiles.len();
        if size == level {
            return;
        }
        for i in 0..size {
            if used[i] {
                continue;
            }
            used[i] = true;
            let char = tiles.chars().nth(i).unwrap();
            cur.push(char);
            set.insert(cur.clone());
            Self::dfs(set, level + 1, tiles, cur, used);
            used[i] = false;
            cur.pop();
        }
    }
    pub fn num_tile_possibilities(tiles: String) -> i32 {
        let (mut set, input, mut cur, mut used) =
            (HashSet::new(), tiles.clone(), "".to_string(), vec![false; tiles.len()]);
        Self::dfs(&mut set, 0, &input, &mut cur, &mut used);
        return set.len() as i32;
    }
}

impl Solution {
    pub fn expand(s: String) -> Vec<String> {
        let (mut ans, mut prev) : (Vec<String>, Vec<String>) = (vec![], vec![]);
        let (mut in_brace, mut initialized) = (false, false);
        for c in s.chars() {
            if c == '{' {
                prev = ans.clone(); ans.clear();
                in_brace = true; continue;
            } else if c == '}' {
                in_brace = false;
                if !initialized {
                    initialized = true;
                }
                continue;
            } else if c == ',' {
                continue;
            }

            if in_brace {
                if !initialized {
                    ans.push(c.to_string());
                } else {
                    let mut cur = prev.clone();
                    for i in 0..cur.len() {
                        cur[i].push(c);
                    }
                    for str in cur {
                        ans.push(str);
                    }
                }
            } else {
                if !initialized {
                    ans.push(c.to_string());
                    initialized = true;
                } else {
                    for i in 0..ans.len() {
                        ans[i].push(c);
                    }
                }
            }
        }
        ans.sort();
        return ans;
    }
}