Couples Holding Hands

Couples Holding Hands - Problem

There are n couples sitting in 2n seats arranged in a row and want to hold hands. The people and seats are represented by an integer array row where row[i] is the ID of the person sitting in the i-th seat.

The couples are numbered in order, the first couple being (0, 1), the second couple being (2, 3), and so on with the last couple being (2n - 2, 2n - 1).

Return the minimum number of swaps so that every couple is sitting side by side. A swap consists of choosing any two people, then they stand up and switch seats.

Input & Output

Example 1 — Basic Mixed Couples

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

› Output: 1

💡 Note: Couples are (0,1) and (2,3). Currently seated as (0,2) and (1,3). Swap positions 1 and 2 to get [0,1,2,3] where couples sit together.

Example 2 — Already Correct

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

› Output: 0

💡 Note: Couples (2,3) and (0,1) are already sitting together in pairs, just in different order. No swaps needed.

Example 3 — Complex Mixing

$ Input: row = [1,4,2,3,5,0]

› Output: 2

💡 Note: Three couples (0,1), (2,3), (4,5) are mixed. Need 2 swaps: swap 4 with 0 to get [1,0,2,3,5,4], then couples sit together.

Constraints

2 ≤ row.length ≤ 60
row.length is even
0 ≤ row[i] < row.length
All elements of row are unique

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is that each swap can fix exactly one couple. The greedy approach works optimally: for each seat pair, if not a couple, immediately swap to fix them. Alternative: model as graph where mixed couples form connected components - each component of size k needs k-1 swaps. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Arrangements

⏱️ Time: O((2n)!) Space: O((2n)!)

Try every possible way to arrange people and calculate swaps needed for each arrangement. This involves generating all permutations and checking which one requires the fewest swaps from the original arrangement.

Greedy Approach - Fix Couples One by One

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

Go through each pair of seats (0,1), (2,3), etc. If a couple is not sitting together, find the partner of the person in the first seat and swap them with the person in the second seat. This greedy approach ensures we make the minimum number of swaps.

Union-Find (Graph Theory Approach)

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

Think of each couple as a node in a graph. If couple A and couple B are mixed up (A's person sitting with B's person), they form an edge. Each connected component of k couples requires k-1 swaps to fix. Count all connected components and sum up (size-1) for each.

Brute Force - Try All Arrangements — Algorithm Steps

Generate all possible permutations of the seating arrangement
For each permutation, check if all couples are sitting together
Calculate the minimum swaps needed to transform original to each valid arrangement
Return the minimum number of swaps found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible ways to arrange people

Check Validity

For each arrangement, check if couples sit together

Count Swaps

Calculate minimum swaps needed from original

Code -

solution.c — C

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

int solution(int* row, int rowSize) {
    int swaps = 0;
    
    // Create position array (assuming person IDs are small)
    int pos[1000];
    for (int i = 0; i < rowSize; i++) {
        pos[row[i]] = i;
    }
    
    for (int i = 0; i < rowSize; i += 2) {
        int person1 = row[i];
        int person2 = row[i + 1];
        
        // Check if they form a couple
        if (person1 / 2 != person2 / 2) {
            // Find partner of person1
            int partner = person1 % 2 == 0 ? person1 + 1 : person1 - 1;
            
            // Find where partner is sitting
            int partnerPos = pos[partner];
            
            // Swap partner with person2
            row[i + 1] = partner;
            row[partnerPos] = person2;
            
            // Update position array
            pos[person2] = partnerPos;
            pos[partner] = i + 1;
            
            swaps++;
        }
    }
    
    return swaps;
}

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

Time & Space Complexity

Time Complexity

⏱️

O((2n)!)

Generating all permutations of 2n people takes (2n)! time

✓ Linear Growth

Space Complexity

O((2n)!)

Need to store all permutations to compare them

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~25 min Avg. Time

1.9K 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