1055. Shortest Way to Form String

From any string, we can form a subsequence of that string by deleting some number of characters (possibly no deletions).

Given two strings source and target, return the minimum number of subsequences of source such that their concatenation equals target. If the task is impossible, return -1.

 

Example 1:

Input: source = "abc", target = "abcbc"
Output: 2
Explanation: The target "abcbc" can be formed by "abc" and "bc", which are subsequences of source "abc".

Example 2:

Input: source = "abc", target = "acdbc"
Output: -1
Explanation: The target string cannot be constructed from the subsequences of source string due to the character "d" in target string.

Example 3:

Input: source = "xyz", target = "xzyxz"
Output: 3
Explanation: The target string can be constructed as follows "xz" + "y" + "xz".

// first opinion is that we can use two pointer , one iterate src, another iterate tar.
// for each tar char, we move j until src[j] == tar[i], if j == src.length, res++, j = 0;
// in this solution, we greedy match as many chars from src to tar as possible which can lead mininum use of src.
// and we can build a set to save all the char in src, if there exists a char from tar which not exists in set, return -1.
public class Solution {
    public int shortestWay(String source, String target) {
        Set<Character> set = new HashSet<>();
        for (int i = 0; i < source.length(); i++)  {
            set.add(source.charAt(i));
        }
        int indexSource = 0, indexTarget = 0, res = 0;
        while (indexTarget < target.length()) {
            if (!set.contains(target.charAt(indexTarget))) {
                return -1;
            }
            while (indexSource < source.length() && source.charAt(indexSource) != target.charAt(indexTarget)) {
                indexSource++;
            }
            if (indexSource == source.length()) {
                res++;
                indexSource = 0;
                continue;
            }
            indexSource++;
            indexTarget++;
        }
        return res + 1;
    }
}

// follow up 1: yes, correct. could u implement it with O 1 space, which mean without set.
// okay. without set, we need a way to make sure there is a char which not in src. we can iterate src completely. if the j not move, then we can return -1.

public int shortestWay(String source, String target) {
    int res = 0, i = 0;
    while (i < target.length()) {
        int originalI = i;
        for (int j = 0; j < source.length(); j++) {
            if (i < target.length() && target.charAt(i) == source.charAt(j)) {
               i++;
            }
        }
        if (i == originalI) return -1;
        res++;
    }
    return res;
}