Form Array by Concatenating Subarrays of Another Array

Form Array by Concatenating Subarrays of Another Array - Problem

You are given a 2D integer array groups of length n. You are also given an integer array nums.

You are asked if you can choose n disjoint subarrays from the array nums such that the ith subarray is equal to groups[i] (0-indexed), and if i > 0, the (i-1)th subarray appears before the ith subarray in nums (i.e. the subarrays must be in the same order as groups).

Return true if you can do this task, and false otherwise.

Note: The subarrays are disjoint if and only if there is no index k such that nums[k] belongs to more than one subarray. A subarray is a contiguous sequence of elements within an array.

Input & Output

Example 1 — Basic Match

$ Input: groups = [[1,-1,-1],[3,-2,0]], nums = [1,-1,0,1,-1,-1,3,-2,0]

› Output: true

💡 Note: Can choose subarrays [1,-1,-1] at indices 3-5 and [3,-2,0] at indices 6-8. Both groups found in order.

Example 2 — No Valid Arrangement

$ Input: groups = [[1,-1,-1],[3,-2,0]], nums = [1,-1,0,1,-1,-1,3,-2,0]

› Output: true

💡 Note: Can choose subarrays [1,-1,-1] at indices 3-5 and [3,-2,0] at indices 6-8. Both groups found in order.

Example 3 — Single Group

$ Input: groups = [[1,2]], nums = [1,2,3,4]

› Output: true

💡 Note: Single group [1,2] found at indices 0-1.

Constraints

1 ≤ groups.length ≤ 1000
1 ≤ groups[i].length ≤ 10
1 ≤ nums.length ≤ 10³
-10⁷ ≤ nums[i], groups[i][j] ≤ 10⁷

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 f Facebook 8

The key insight is to use greedy sequential matching - for each group, find the first occurrence starting from the current position. The greedy approach works optimally here because we only care about finding groups in order, not finding the best possible arrangement. Time: O(n×m), Space: O(1).

Common Approaches

✓ Brute Force - Try All Positions

⏱️ Time: O(n^m) Space: O(m)

For each group, try all possible positions in nums where it could match. Use recursion with backtracking to explore all combinations of disjoint subarrays.

Greedy Sequential Matching

⏱️ Time: O(n * m) Space: O(1)

Use a greedy approach to match groups sequentially. For each group, find the first occurrence in nums starting from the current position, then move to the next position after the match.

Brute Force - Try All Positions — Algorithm Steps

Try each position in nums for first group
Recursively try remaining groups after current match
Backtrack if no valid arrangement found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Group 1

Test all possible positions for first group

Recurse

For each match, try remaining groups

Backtrack

If no solution found, try next position

Code -

solution.c — C

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

bool backtrack(int** groups, int* groupSizes, int numGroups, int* nums, int numsSize, int groupIdx, int startPos) {
    if (groupIdx == numGroups) {
        return true;
    }
    
    int* currentGroup = groups[groupIdx];
    int groupLen = groupSizes[groupIdx];
    
    for (int i = startPos; i <= numsSize - groupLen; i++) {
        bool matches = true;
        for (int j = 0; j < groupLen; j++) {
            if (nums[i + j] != currentGroup[j]) {
                matches = false;
                break;
            }
        }
        
        if (matches) {
            if (backtrack(groups, groupSizes, numGroups, nums, numsSize, groupIdx + 1, i + groupLen)) {
                return true;
            }
        }
    }
    
    return false;
}

bool solution(int** groups, int* groupSizes, int numGroups, int* nums, int numsSize) {
    return backtrack(groups, groupSizes, numGroups, nums, numsSize, 0, 0);
}

int parseNumber(const char* str, int* pos) {
    int sign = 1;
    int num = 0;
    
    if (str[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    
    while (*pos < strlen(str) && isdigit(str[*pos])) {
        num = num * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    
    return sign * num;
}

int** parseGroups(const char* line, int* groupSizes, int* numGroups) {
    int** groups = malloc(1000 * sizeof(int*));
    *numGroups = 0;
    
    int len = strlen(line);
    int i = 1; // Skip opening bracket
    
    while (i < len - 1) {
        if (line[i] == '[') {
            groups[*numGroups] = malloc(10 * sizeof(int));
            int groupSize = 0;
            i++; // Skip opening bracket
            
            while (i < len && line[i] != ']') {
                if (isdigit(line[i]) || line[i] == '-') {
                    groups[*numGroups][groupSize++] = parseNumber(line, &i);
                } else {
                    i++;
                }
            }
            
            groupSizes[*numGroups] = groupSize;
            (*numGroups)++;
            i++; // Skip closing bracket
        } else {
            i++;
        }
    }
    
    return groups;
}

int* parseNums(const char* line, int* numsSize) {
    int* nums = malloc(1000 * sizeof(int));
    *numsSize = 0;
    
    int len = strlen(line);
    int i = 1; // Skip opening bracket
    
    while (i < len - 1) {
        if (isdigit(line[i]) || line[i] == '-') {
            nums[(*numsSize)++] = parseNumber(line, &i);
        } else {
            i++;
        }
    }
    
    return nums;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int* groupSizes = malloc(1000 * sizeof(int));
    int numGroups;
    int** groups = parseGroups(line1, groupSizes, &numGroups);
    
    int numsSize;
    int* nums = parseNums(line2, &numsSize);
    
    bool result = solution(groups, groupSizes, numGroups, nums, numsSize);
    printf("%s\n", result ? "true" : "false");
    
    // Free memory
    for (int i = 0; i < numGroups; i++) {
        free(groups[i]);
    }
    free(groups);
    free(groupSizes);
    free(nums);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^m)

For each of m groups, we try up to n positions in nums

✓ Linear Growth

Space Complexity

O(m)

Recursion stack depth equals number of groups

✓ Linear Space

32.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler