Shortest Way to Form String - Practice Coding Problems

Shortest Way to Form String - Problem

Imagine you have a source cookbook and you want to create a target recipe by copying ingredients in order from the cookbook pages. You can flip through the cookbook multiple times, but you must follow the ingredient order on each page.

Given two strings source and target, find the minimum number of passes through the source string needed to form the target string as a concatenation of subsequences.

A subsequence maintains the original character order but allows skipping characters. For example, "ace" is a subsequence of "abcde", but "aec" is not.

Goal: Return the minimum number of subsequences of source that concatenate to form target. If impossible, return -1.

Example: If source = "abc" and target = "abcbc", we need 2 passes: "abc" + "bc" = "abcbc"

Input & Output

example_1.py — Basic Case

$ Input: source = "abc", target = "abcbc"

› Output: 2

💡 Note: We need 2 subsequences: "abc" (taking all characters) + "bc" (skipping 'a'). Total: "abc" + "bc" = "abcbc"

example_2.py — Impossible Case

$ Input: source = "abc", target = "aabbcc"

› Output: -1

💡 Note: Source contains only one 'a', but target needs two 'a's. Since we can't create multiple copies of the same character from a single source, it's impossible.

example_3.py — Greedy Optimization

$ Input: source = "xyz", target = "xzyxz"

› Output: 3

💡 Note: First pass: "xz" (skip 'y'), second pass: "y", third pass: "xz" again. We get "xz" + "y" + "xz" = "xzyxz"

Visualization

Tap to expand

Understanding the Visualization

Index the Cookbook

Create a quick-reference index showing where each ingredient appears

Greedy Reading

For each needed ingredient, find the next occurrence in the current reading

New Reading When Needed

When an ingredient isn't available ahead, start a fresh reading

Count Total Readings

The number of readings equals the minimum subsequences needed

Key Takeaway

🎯 Key Insight: Pre-indexing character positions + binary search + greedy collection strategy minimizes the number of source readings required to form any target sequence.

Time & Space Complexity

Time Complexity

⏱️

O(m * n)

For each character in target (m), we might scan the entire source (n) in worst case

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables for tracking positions

✓ Linear Space

Constraints

1 ≤ source.length, target.length ≤ 1000
source and target consist of lowercase English letters
Follow-up: Can you optimize for the case where the same source is queried with multiple different targets?

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses binary search on pre-indexed character positions to achieve O(n + m*log n) time complexity. We build a position mapping for each character in the source, then for each target character, use binary search to find the next available position. This greedy strategy minimizes subsequences by maximizing characters taken per pass.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Sequential Matching)	O(m * n)	O(1)	For each character in target, scan source from beginning to find matches
Two Pointers with Character Indexing	O(n + m*n)	O(n)	Use character position mapping to efficiently find next occurrences
Binary Search Optimization	O(n + m*log n)	O(n)	Use binary search on pre-indexed positions for O(log n) character lookups

Brute Force (Sequential Matching) — Algorithm Steps

Initialize result count to 1 and source pointer to 0
For each character in target, scan source from current position
If character found, move source pointer forward
If character not found, increment count and reset source pointer
Return count if all characters matched, -1 otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with source pointer at beginning, subsequence count = 1

Match Characters

For each target character, scan forward in source

Reset on Miss

When character not found, increment count and reset pointer

Continue

Repeat until all target characters are matched

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

int numDistinctSubsequences(char* source, char* target) {
    int sourceLen = strlen(source);
    int targetLen = strlen(target);
    
    if (sourceLen == 0 || targetLen == 0) {
        return targetLen == 0 ? 0 : -1;
    }
    
    bool sourceChars[256] = {false};
    for (int i = 0; i < sourceLen; i++) {
        sourceChars[(unsigned char)source[i]] = true;
    }
    
    for (int i = 0; i < targetLen; i++) {
        if (!sourceChars[(unsigned char)target[i]]) {
            return -1;
        }
    }
    
    int result = 1;
    int sourceIdx = 0;
    
    for (int i = 0; i < targetLen; i++) {
        char targetChar = target[i];
        bool found = false;
        
        while (sourceIdx < sourceLen) {
            if (source[sourceIdx] == targetChar) {
                found = true;
                sourceIdx++;
                break;
            }
            sourceIdx++;
        }
        
        if (!found) {
            result++;
            sourceIdx = 0;
            while (sourceIdx < sourceLen && source[sourceIdx] != targetChar) {
                sourceIdx++;
            }
            if (sourceIdx == sourceLen) {
                return -1;
            }
            sourceIdx++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n)

For each character in target (m), we might scan the entire source (n) in worst case

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables for tracking positions

✓ Linear Space

Constraints

1 ≤ source.length, target.length ≤ 1000
source and target consist of lowercase English letters
Follow-up: Can you optimize for the case where the same source is queried with multiple different targets?

89.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Sequential Matching) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler