Minimum Adjacent Swaps to Alternate Parity

Minimum Adjacent Swaps to Alternate Parity - Problem

Array Greedy Medium

You are given an array nums of distinct integers. In one operation, you can swap any two adjacent elements in the array.

An arrangement of the array is considered valid if the parity of adjacent elements alternates, meaning every pair of neighboring elements consists of one even and one odd number.

Return the minimum number of adjacent swaps required to transform nums into any valid arrangement. If it is impossible to rearrange nums such that no two adjacent elements have the same parity, return -1.

Input & Output

Example 1 — Basic Valid Case

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

› Output: 3

💡 Note: We have 2 evens (4,2) and 2 odds (3,1). We can arrange as [1,4,3,2] (odd-even-odd-even) with 3 adjacent swaps: 3↔1, 1↔4, 4↔3.

Example 2 — Already Alternating

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

› Output: 0

💡 Note: Array already alternates: odd-even-odd-even. No swaps needed.

Example 3 — Impossible Case

$ Input: nums = [1,3,5,7]

› Output: -1

💡 Note: All numbers are odd. Cannot create alternating parity pattern.

Constraints

1 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
All integers in nums are distinct

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is that only two valid patterns exist: even-odd-even... or odd-even-odd... We can try both patterns greedily and choose the minimum. Best approach is greedy pattern matching. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Arrangements

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

Generate every possible arrangement of the array, check if it's valid (alternating parity), and count the minimum adjacent swaps needed from the original array.

Greedy Pattern Matching

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

Since only two valid patterns exist (even-odd-even... or odd-even-odd...), we can try both patterns greedily and pick the one requiring fewer swaps.

Brute Force - Try All Arrangements — Algorithm Steps

Generate all permutations of the array
Check each permutation for alternating parity
Count adjacent swaps needed to reach each valid arrangement
Return minimum swaps found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of the array

Check Validity

Test each arrangement for alternating parity

Count Swaps

Calculate adjacent swaps needed for valid arrangements

Code -

solution.c — C

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

int isValid(int* arr, int n) {
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] % 2 == arr[i+1] % 2) return 0;
    }
    return 1;
}

int countSwaps(int* original, int* target, int n) {
    int* arr = malloc(n * sizeof(int));
    memcpy(arr, original, n * sizeof(int));
    int swaps = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] != target[i]) {
            int j = i + 1;
            while (j < n && arr[j] != target[i]) j++;
            while (j > i) {
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
                swaps++;
                j--;
            }
        }
    }
    free(arr);
    return swaps;
}

void generatePermutations(int* nums, int n, int start, int* minSwaps, int* original) {
    if (start == n) {
        if (isValid(nums, n)) {
            int swaps = countSwaps(original, nums, n);
            if (swaps < *minSwaps) *minSwaps = swaps;
        }
        return;
    }
    for (int i = start; i < n; i++) {
        int temp = nums[start];
        nums[start] = nums[i];
        nums[i] = temp;
        generatePermutations(nums, n, start + 1, minSwaps, original);
        temp = nums[start];
        nums[start] = nums[i];
        nums[i] = temp;
    }
}

int solution(int* nums, int n) {
    int* original = malloc(n * sizeof(int));
    memcpy(original, nums, n * sizeof(int));
    int minSwaps = INT_MAX;
    generatePermutations(nums, n, 0, &minSwaps, original);
    free(original);
    return minSwaps == INT_MAX ? -1 : minSwaps;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[100], n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

Generate n! permutations, each requiring O(n²) swaps to calculate

⚠ Quadratic Growth

Space Complexity

O(n)

Store current permutation and track swaps

⚡ Linearithmic Space

23.0K 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 Arrangements — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler