Couple Holding Hands Problem in Java

It is very interesting problem frequently asked in interviews of top IT companies like Google, Amazon, TCS, Accenture, etc. By solving the problem, one wants to check the logical ability, critical thinking, and problem-solving skill of the interviewee. So, in this section, we are going to solve couple holding hands problem in Java with different approaches and logic. Also, we will create Java programs for the same.

Problem Statement

In this problem, we have given n number of couples sitting on 2n number of seats (arranged in row) and wants to hold each other's hands. We have to find the minimum number of swaps (exchange of seats) in such a way every couple can sit side by side. We can choose any two people for swap and they can stand up and exchange their seats.

Note: The array must be of even length, otherwise one person will be left out of being a couple.

Let's understand it through examples.

Example 1:

Input: couple = [4, 1, 5, 2]

Output: 1

Explanation: Here, we required only one swap (1 with 5) to make couples, we get [4, 5, 1, 2]. Here, the order of people does not matter. For example, [5, 4, 2, 1] and [4, 5, 1, 2] are the same.

Example 2:

Input: couple = [1, 2, 8, 9]

Output: 0

Explanation: Here, no need to exchange seats, all couples already holds each other's hands.

Solution to the Problem

In order to solve the problem, we will define an integer array row. Array with index represent the couple sitting on i-th seat. People and seats are represented by integers from 0 to 2N-1. The couples are numbered in order, the first pair is (0, 1), the second pair is (2, 3), and so on, and the last pair is (2N- 2, 2N-1).

The initial seat row[i] of these couples is determined by the person who initially sat in the i-th seat.

The problem can be solved in many ways by using union-find, greedy, or cycle decomposition of permutation graph. Let's discuss each in detail.

Solution 1: Using Permutation Graph and Graph Decomposition

The permutation graph theory privileges a given a pair of permutation say G1: (W, X, W, Y, W, Z, Y) and G2: (X, Y, Z, W, W, Y, W). By connecting the edges from G1 to G2, we can represent the pair of permutation by a graph. Based on observation, if at any position [i], we have G1[i]=G2[i], then the vertex should have a self-connected edge.

In order to transform the G2 into G1, we required to perform swapping so that the edges between two vertices can be removed. In simple words, make the vertices as self-connected edges.

If we observe any cycle in the graph, the minimal step to remove all non-self-connected edges for a cycle is edge-1. Therefore, the total number of swaps will be ∑(C_k-1), where C₁, C₂, C₃, …. C_k are the length of the connected components in the graph.

We can also minimize the total number of swaps by decomposing the graph into different cycles so that each cycle become small as possible (Because the number of edges is fixed, but if the more cycles we ended with, the more times #swap is minus by 1).

Steps

First, determine the number of connected parts in the graph. For the same we have used a variable named connectedNumber.

Suppose, all the couples are sit together, in such a case, the number of connected parts is row.length/2.

The variable connectedNumber will incremented by 1 every time when we do a right swap to make a couple. Do the swapping process until the variable connectedNumber becomes equal to row.length/2. So the answer of this problem is row.length/2-connectedNumber .

CoupleHoldingHands1.java

class CoupleHoldingHands1
{
    public int minSwapsCouples()(int[] row) ;
{
        DSU dsu = new DSU(row.length);
        for(int i = 0; i < row.length; i += 2) 
{
            int p1 = row[i];
            int p1Mate = (p1 % 2 == 0) ? p1+1 : p1-1;
            dsu.union(p1, p1Mate);            
            int p2 = row[i+1];
            int p2Mate = (p2 % 2 == 0) ? p2+1 : p2-1;
            dsu.union(p2, p2Mate);
            dsu.union(p1, p2);
        }
        return row.length/2 - dsu.findConnectedPart();
    }
    public static void main(string args[])
    {
        int[] arr={0, 2, 1 3};
        System.out.println(minSwapsCouples());
    }
}
class DSU {
    private int[] parent;
    private int[] rank;
    public DSU(int n) {
        parent = new int[n];
        for(int i = 0; i < n; i++){
            parent[i] = i;
        }
        rank = new int[n];
    }    
    public int find(int x) {
        if(x != parent[x]) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }    
    public void union(int x, int y) {
        int xr = find(x);
        int yr = find(y);
        if(xr == yr) {
            return;
        }else{
            if(rank[xr] < rank[yr]) {
                parent[xr] = yr;
            }else if(rank[xr] > rank[yr]) {
                parent[yr] = xr;
            }else{
                parent[yr] = xr;
                rank[xr]++;
            }
        }
    }
    public int findConnectedPart() {
        int connectedPart = 0;
        for(int i = 0; i < parent.length; i++) {
            if(i == parent[i]) {
                connectedPart++;
            }
        }
        return connectedPart;
    }
}

Output:

Solution 2: Greedy Approach

If we look carefully at the graph (above) there is a greedy approach. There is only one way to decompose the graph in such a way that any swap that helps match at least one couple is a greedy action.

In this approach, we use a HashMap that will compute the position of each person. After that, loop over the row, again. If we found a pair of people do not match, we find the corresponding match is in the position and swap them. We keep performing the greedy action and count the number of swaps.

CoupleHoldingHands2.java

import java.util.*;
import java.lang.*;
public class Solution 
{
    public static int minSwapsCouples(int[] row) 
    {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < row.length; i++) 
        {
            map.put(row[i], i);
        }        
        int swap = 0;
        for(int i = 0; i < row.length; i += 2) 
        {
            int p1 = row[i];
            int p1Mate = (p1 % 2 == 0) ? p1+1: p1-1;
            int p2 = row[i+1];
            if(p1Mate != p2) 
            {
                int temp = row[i+1];
                row[i+1] = row[map.get(p1Mate)];
                row[map.get(p1Mate)] = temp;
                map.put(p2, map.get(p1Mate));
                map.put(p1Mate, i+1);
                swap++;
            }
        }
        return swap;
    }
    public static void main(String args[]) 
    {
      int[] arr={4, 1, 5, 2};
      System.out.println(minSwapsCouples(arr));
    }
}

Output: