Make Two Arrays Equal by Reversing Subarrays

Make Two Arrays Equal by Reversing Subarrays - Problem

Can you transform one array into another using only reversal operations?

You are given two integer arrays of equal length: target and arr. Your goal is to determine whether you can make arr identical to target by performing a series of subarray reversals.

In each operation, you can:
• Select any non-empty contiguous subarray of arr
• Reverse all elements in that subarray
• Repeat this process any number of times

For example, if arr = [1,2,3,4], you could reverse the subarray [2,3] to get [1,3,2,4].

Return: true if you can make arr equal to target, or false otherwise.

Input & Output

example_1.py — Basic case

$ Input: target = [1,2,3,4], arr = [2,4,1,3]

› Output: true

💡 Note: We can transform arr to target: [2,4,1,3] → reverse [4,1] → [2,1,4,3] → reverse [2,1] → [1,2,4,3] → reverse [4,3] → [1,2,3,4]

example_2.py — Impossible case

$ Input: target = [7], arr = [4]

› Output: false

💡 Note: arr contains different elements than target, so no amount of reversals can make them equal

example_3.py — Duplicate elements

$ Input: target = [3,7,9], arr = [3,7,11]

› Output: false

💡 Note: Arrays have different elements (9 vs 11), so transformation is impossible

Constraints

target.length == arr.length
1 ≤ target.length ≤ 1000
1 ≤ target[i] ≤ 1000
1 ≤ arr[i] ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with arr=[2,4,1,3] and target=[1,2,3,4]

Count Elements

Count frequency: both have one each of 1,2,3,4

Verify Match

Since frequencies match, transformation is possible

Key Takeaway

🎯 Key Insight: Since subarray reversals can achieve any permutation, we only need to verify that both arrays contain identical elements with matching frequencies!

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a frequency counting approach in O(n) time. The key insight is that reversing subarrays can achieve any permutation, so we only need to verify both arrays contain the same elements with same frequencies. Use a hash map to count elements efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Frequency Count (Optimal)	O(n)	O(n)	Count elements from both arrays in a single pass using increment/decrement
Sorting + Comparison	O(n log n)	O(log n)	Sort both arrays and compare element by element
Two-Pass Frequency Count	O(n)	O(n)	Count frequencies in both arrays separately, then compare
Brute Force Simulation	O(n! × n²)	O(n! × n)	Try all possible sequences of subarray reversals until target is found

One-Pass Frequency Count (Optimal) — Algorithm Steps

Initialize a single frequency map
For each element in arr, increment its count in the map
For each element in target, decrement its count in the map
Check if all counts are zero (or map is empty)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Map

Start with empty frequency map

Process Elements

For each position: increment arr[i], decrement target[i]

Check Balance

All counts should be zero if arrays are equivalent

Code -

solution.c — C

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

bool canBeEqual(int* target, int targetSize, int* arr, int arrSize) {
    if (targetSize != arrSize) return false;
    
    // Using array-based counting for better performance in C
    int freq[1001] = {0}; // Assuming values in range [0, 1000]
    
    // Process both arrays simultaneously
    for (int i = 0; i < arrSize; i++) {
        freq[arr[i]]++;      // Increment for arr
        freq[target[i]]--;   // Decrement for target
    }
    
    // Check if all frequencies are zero
    for (int i = 0; i <= 1000; i++) {
        if (freq[i] != 0) return false;
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both arrays simultaneously

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique elements

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~8 min Avg. Time

892 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

One-Pass Frequency Count (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler