Find the Minimum Cost Array Permutation - Practice Coding Problems

Find the Minimum Cost Array Permutation - Problem

You're given an array nums which is a permutation of [0, 1, 2, ..., n - 1]. Your task is to find the optimal arrangement of indices that minimizes a special scoring function.

The score of any permutation perm is calculated as a circular sum:

score(perm) = |perm[0] - nums[perm[1]]| + |perm[1] - nums[perm[2]]| + ... + |perm[n-1] - nums[perm[0]]|

In other words, we're comparing each position in the permutation with the value at the next position (wrapping around to the beginning). Your goal is to find the permutation that minimizes this total cost.

If multiple permutations achieve the same minimum score, return the lexicographically smallest one. This is a classic optimization problem that combines graph theory with dynamic programming!

Input & Output

example_1.py — Python

$ Input: [1, 3, 0, 2]

› Output: [0, 2, 3, 1]

💡 Note: For nums = [1,3,0,2], the optimal permutation is [0,2,3,1]. The score is |0-nums[2]| + |2-nums[3]| + |3-nums[1]| + |1-nums[0]| = |0-0| + |2-2| + |3-3| + |1-1| = 0. This gives the minimum possible score.

example_2.py — Python

$ Input: [0, 1]

› Output: [0, 1]

💡 Note: For nums = [0,1], we try both permutations: [0,1] gives score |0-nums[1]| + |1-nums[0]| = |0-1| + |1-0| = 2. [1,0] gives score |1-nums[0]| + |0-nums[1]| = |1-0| + |0-1| = 2. Both have the same score, so we return the lexicographically smaller [0,1].

example_3.py — Python

$ Input: [0]

› Output: [0]

💡 Note: With only one element, there's only one possible permutation [0], and its score is |0-nums[0]| = |0-0| = 0.

Visualization

Tap to expand

Understanding the Visualization

Model as Graph Problem

Create a complete graph where vertices are positions 0,1,...,n-1 and edge weights are |i - nums[j]|

Apply DP with Bitmask

Use dp[mask][i] to represent the minimum cost to visit all positions in the bitmask, ending at position i

Build Solution Incrementally

For each state, try extending to unvisited positions and update costs optimally

Complete the Cycle

Add the cost to return from the final position back to position 0 to complete the circular requirement

Key Takeaway

🎯 Key Insight: This TSP variant can be solved efficiently using DP with bitmasks, reducing complexity from O(n!) to O(n² × 2ⁿ) while guaranteeing the optimal solution.

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

For each of 2ⁿ possible subsets and n positions, we try n transitions

⚠ Quadratic Growth

Space Complexity

O(n × 2ⁿ)

DP table stores minimum cost for each (mask, position) pair

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 14
nums is a permutation of [0, 1, 2, ..., n - 1]
Time limit: 2 seconds per test case

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

This problem is a variant of the Traveling Salesman Problem. The optimal approach uses dynamic programming with bitmasks to efficiently explore all possible circular arrangements. While brute force tries all n! permutations, DP reduces this to O(n² × 2ⁿ) by avoiding redundant calculations. The key insight is treating this as finding the minimum-cost Hamiltonian cycle in a complete graph.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(n² × 2ⁿ)	O(n × 2ⁿ)	Use DP with bitmasks to efficiently solve this TSP-variant problem
Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible permutations and calculate the score for each

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Define DP state: dp[mask][i] = minimum cost to visit all indices in mask, ending at position i
Initialize: dp[1][0] = 0 (start at position 0 with only position 0 visited)
For each mask and position, try extending to unvisited positions
Handle the circular constraint by connecting back to position 0 at the end
Reconstruct the optimal path to get lexicographically smallest result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Start with dp[1][0] = 0 (only position 0 visited, ending at 0)

Fill DP Table

For each state, try extending to unvisited positions

Calculate Costs

Cost to extend from u to v is |u - nums[v]|

Complete Cycle

Add cost to return from final position back to 0

Code -

solution.c — C

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

typedef struct {
    int mask, pos;
} Pair;

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int* findPermutation(int* nums, int n, int* returnSize) {
    if (n == 1) {
        *returnSize = 1;
        int* result = (int*)malloc(sizeof(int));
        result[0] = 0;
        return result;
    }
    
    int total_masks = 1 << n;
    int** dp = (int**)malloc(total_masks * sizeof(int*));
    Pair** parent = (Pair**)malloc(total_masks * sizeof(Pair*));
    
    for (int i = 0; i < total_masks; i++) {
        dp[i] = (int*)malloc(n * sizeof(int));
        parent[i] = (Pair*)malloc(n * sizeof(Pair));
        for (int j = 0; j < n; j++) {
            dp[i][j] = INT_MAX / 2;
            parent[i][j].mask = -1;
            parent[i][j].pos = -1;
        }
    }
    
    dp[1][0] = 0;
    
    for (int mask = 0; mask < total_masks; mask++) {
        for (int u = 0; u < n; u++) {
            if (!(mask & (1 << u)) || dp[mask][u] == INT_MAX / 2) continue;
            
            for (int v = 0; v < n; v++) {
                if (mask & (1 << v)) continue;
                
                int new_mask = mask | (1 << v);
                int cost = dp[mask][u] + abs_val(u - nums[v]);
                
                if (cost < dp[new_mask][v]) {
                    dp[new_mask][v] = cost;
                    parent[new_mask][v].mask = mask;
                    parent[new_mask][v].pos = u;
                }
            }
        }
    }
    
    int full_mask = (1 << n) - 1;
    int min_cost = INT_MAX / 2;
    int best_end = -1;
    
    for (int i = 1; i < n; i++) {
        int cycle_cost = dp[full_mask][i] + abs_val(i - nums[0]);
        if (cycle_cost < min_cost) {
            min_cost = cycle_cost;
            best_end = i;
        }
    }
    
    int* path = (int*)malloc(n * sizeof(int));
    int path_len = 0;
    int mask = full_mask;
    int curr = best_end;
    
    while (parent[mask][curr].mask != -1) {
        path[path_len++] = curr;
        int prev_mask = parent[mask][curr].mask;
        int prev_curr = parent[mask][curr].pos;
        mask = prev_mask;
        curr = prev_curr;
    }
    
    path[path_len++] = 0;
    
    // Reverse path
    for (int i = 0; i < path_len / 2; i++) {
        int temp = path[i];
        path[i] = path[path_len - 1 - i];
        path[path_len - 1 - i] = temp;
    }
    
    *returnSize = n;
    
    // Cleanup
    for (int i = 0; i < total_masks; i++) {
        free(dp[i]);
        free(parent[i]);
    }
    free(dp);
    free(parent);
    
    return path;
}

int main() {
    int nums[] = {1, 3, 0, 2};
    int n = 4;
    int returnSize;
    
    int* result = findPermutation(nums, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

For each of 2ⁿ possible subsets and n positions, we try n transitions

⚠ Quadratic Growth

Space Complexity

O(n × 2ⁿ)

DP table stores minimum cost for each (mask, position) pair

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 14
nums is a permutation of [0, 1, 2, ..., n - 1]
Time limit: 2 seconds per test case

27.5K Views

Medium Frequency

~35 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler