Check Array Formation Through Concatenation

Check Array Formation Through Concatenation - Problem

You are given an array of distinct integers arr and an array of integer arrays pieces, where the integers in pieces are distinct. Your goal is to form arr by concatenating the arrays in pieces in any order. However, you are not allowed to reorder the integers in each array pieces[i].

Return true if it is possible to form the array arr from pieces. Otherwise, return false.

Input & Output

Example 1 — Basic Case

$ Input: arr = [85], pieces = [[85]]

› Output: true

💡 Note: Single piece [85] exactly matches the target array [85]

Example 2 — Multiple Pieces

$ Input: arr = [15,88], pieces = [[88],[15]]

› Output: true

💡 Note: Can rearrange pieces: [15] + [88] = [15,88] matches target

Example 3 — Impossible Case

$ Input: arr = [49,18,16], pieces = [[16,18,49]]

› Output: false

💡 Note: Piece [16,18,49] cannot be reordered to match [49,18,16]

Constraints

1 ≤ pieces.length ≤ arr.length ≤ 100
sum(pieces[i].length) == arr.length
1 ≤ pieces[i].length ≤ arr.length
1 ≤ arr[i], pieces[i][j] ≤ 100
The integers in arr are distinct
The integers in pieces are distinct

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 8

The key insight is to use the first element of each piece as a unique identifier. Since all integers are distinct, we can create a hash map mapping first elements to their pieces. Best approach is hash map lookup with Time: O(n), Space: O(p).

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × m) Space: O(m)

Try every possible ordering of the pieces array and check if concatenating them produces the target array. This involves generating all permutations and comparing each result.

Hash Map Lookup

⏱️ Time: O(n) Space: O(p)

Create a hash map where the first element of each piece maps to the piece itself. Then traverse the target array and use the hash map to find matching pieces.

Brute Force - Try All Permutations — Algorithm Steps

Generate all permutations of pieces
For each permutation, concatenate all arrays
Check if result equals target arr

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

Target array [85,15] and pieces [[85],[15]]

Try Permutation 1

[[85],[15]] → [85,15] ✓ Match!

Result

Found valid arrangement, return true

Code -

solution.c — C

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

bool solution(int* arr, int arrSize, int** pieces, int* pieceSizes, int piecesSize) {
    if (arrSize == 0) return piecesSize == 0;
    if (piecesSize == 0) return arrSize == 0;
    
    // Create a map from value to piece index and position within piece
    // Since values are distinct, we can use a simple approach
    int* valueToPiece = (int*)malloc(100001 * sizeof(int));
    int* valueToPos = (int*)malloc(100001 * sizeof(int));
    
    // Initialize with -1 (not found)
    for (int i = 0; i < 100001; i++) {
        valueToPiece[i] = -1;
        valueToPos[i] = -1;
    }
    
    // Build the mapping
    for (int i = 0; i < piecesSize; i++) {
        for (int j = 0; j < pieceSizes[i]; j++) {
            int val = pieces[i][j];
            if (val >= 0 && val < 100001) {
                valueToPiece[val] = i;
                valueToPos[val] = j;
            }
        }
    }
    
    // Check if all values in arr exist in pieces
    for (int i = 0; i < arrSize; i++) {
        int val = arr[i];
        if (val < 0 || val >= 100001 || valueToPiece[val] == -1) {
            free(valueToPiece);
            free(valueToPos);
            return false;
        }
    }
    
    // Now check if we can form arr by concatenating pieces
    bool* used = (bool*)calloc(piecesSize, sizeof(bool));
    int i = 0;
    
    while (i < arrSize) {
        int val = arr[i];
        int pieceIdx = valueToPiece[val];
        int posInPiece = valueToPos[val];
        
        // If this piece is already used, it's impossible
        if (used[pieceIdx]) {
            free(valueToPiece);
            free(valueToPos);
            free(used);
            return false;
        }
        
        // If this value is not at the start of its piece, it's impossible
        if (posInPiece != 0) {
            free(valueToPiece);
            free(valueToPos);
            free(used);
            return false;
        }
        
        // Mark this piece as used
        used[pieceIdx] = true;
        
        // Check if the entire piece matches the corresponding part of arr
        for (int j = 0; j < pieceSizes[pieceIdx]; j++) {
            if (i + j >= arrSize || arr[i + j] != pieces[pieceIdx][j]) {
                free(valueToPiece);
                free(valueToPos);
                free(used);
                return false;
            }
        }
        
        // Move to the next piece
        i += pieceSizes[pieceIdx];
    }
    
    free(valueToPiece);
    free(valueToPos);
    free(used);
    return true;
}

int parseArray(char* str, int* arr) {
    int count = 0;
    int len = strlen(str);
    int i = 1; // Skip '['
    
    while (i < len && str[i] != ']') {
        if (str[i] == ',' || str[i] == ' ') {
            i++;
            continue;
        }
        
        int num = 0;
        bool negative = false;
        if (str[i] == '-') {
            negative = true;
            i++;
        }
        
        while (i < len && str[i] >= '0' && str[i] <= '9') {
            num = num * 10 + (str[i] - '0');
            i++;
        }
        
        arr[count++] = negative ? -num : num;
    }
    
    return count;
}

int parse2DArray(char* str, int** pieces, int* pieceSizes) {
    int count = 0;
    int len = strlen(str);
    int i = 1; // Skip first '['
    
    while (i < len && str[i] != ']') {
        if (str[i] == ',' || str[i] == ' ') {
            i++;
            continue;
        }
        
        if (str[i] == '[') {
            // Found start of a piece
            int start = i;
            int bracketCount = 0;
            
            // Find the matching ']'
            while (i < len) {
                if (str[i] == '[') bracketCount++;
                if (str[i] == ']') bracketCount--;
                i++;
                if (bracketCount == 0) break;
            }
            
            // Extract this piece
            char pieceStr[1000];
            int pieceLen = i - start;
            strncpy(pieceStr, str + start, pieceLen);
            pieceStr[pieceLen] = '\0';
            
            pieces[count] = (int*)malloc(1000 * sizeof(int));
            pieceSizes[count] = parseArray(pieceStr, pieces[count]);
            count++;
        } else {
            i++;
        }
    }
    
    return count;
}

int main() {
    char line1[10000], line2[10000];
    
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    static int arr[1000];
    int arrSize = parseArray(line1, arr);
    
    static int* pieces[1000];
    static int pieceSizes[1000];
    int piecesSize = parse2DArray(line2, pieces, pieceSizes);
    
    bool result = solution(arr, arrSize, pieces, pieceSizes, piecesSize);
    printf(result ? "true\n" : "false\n");
    
    // Free allocated memory
    for (int i = 0; i < piecesSize; i++) {
        free(pieces[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × m)

n! permutations of pieces, each taking O(m) time to concatenate and compare where m is total elements

✓ Linear Growth

Space Complexity

O(m)

Space to store concatenated arrays during comparison

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

920 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 Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler