Codestin Search App

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(n + m*n)

O(n) to build position map, then O(m*n) for finding positions in worst case where we scan all positions for each target character

✓ Linear Growth

Space Complexity

O(n)

Space for storing all character positions in hash map

⚡ Linearithmic 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
✓ 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)	O(m * n)	O(1)	For each character in target, scan source from beginning to find matches

Two Pointers with Character Indexing — Algorithm Steps

Build a hash map where each character maps to list of its positions in source
Initialize subsequence count to 1 and current source position to -1
For each character in target, find its next occurrence after current position
If found, update current position; otherwise increment count and restart
Return count if all characters can be matched

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Index

Create position mapping for each character

Track Position

Maintain current position pointer in source

Find Next

Use index to find next occurrence efficiently

Reset When Needed

Start new subsequence when no next occurrence found

Code -

solution.c — C

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

#define MAX_CHARS 256
#define MAX_POSITIONS 1000

typedef struct {
    int positions[MAX_POSITIONS];
    int count;
} CharPositions;

int numDistinctSubsequences(char* source, char* target) {
    int sourceLen = strlen(source);
    int targetLen = strlen(target);
    
    if (targetLen == 0) return 0;
    if (sourceLen == 0) return -1;
    
    CharPositions charPos[MAX_CHARS] = {0};
    
    for (int i = 0; i < sourceLen; i++) {
        unsigned char c = (unsigned char)source[i];
        if (charPos[c].count < MAX_POSITIONS) {
            charPos[c].positions[charPos[c].count++] = i;
        }
    }
    
    for (int i = 0; i < targetLen; i++) {
        unsigned char c = (unsigned char)target[i];
        if (charPos[c].count == 0) {
            return -1;
        }
    }
    
    int result = 1;
    int currentPos = -1;
    
    for (int i = 0; i < targetLen; i++) {
        unsigned char c = (unsigned char)target[i];
        CharPositions* positions = &charPos[c];
        
        int nextPos = -1;
        for (int j = 0; j < positions->count; j++) {
            if (positions->positions[j] > currentPos) {
                nextPos = positions->positions[j];
                break;
            }
        }
        
        if (nextPos == -1) {
            result++;
            currentPos = positions->positions[0];
        } else {
            currentPos = nextPos;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m*n)

O(n) to build position map, then O(m*n) for finding positions in worst case where we scan all positions for each target character

✓ Linear Growth

Space Complexity

O(n)

Space for storing all character positions in hash map

⚡ Linearithmic 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

Two Pointers with Character Indexing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler