[LintCode] Nuts & Bolts Problem

Given a set of n nuts of different sizes and n bolts of different sizes. There is a one-one mapping between nuts and bolts. Comparison of a nut to another nut or a bolt to another bolt is not allowed. It means nut can only be compared with bolt and bolt can only be compared with nut to see which one is bigger/smaller.

We will give you a compare function to compare nut with bolt.

 

Example

Given nuts = ['ab','bc','dd','gg'], bolts = ['AB','GG', 'DD', 'BC'].

Your code should find the matching bolts and nuts.

one of the possible return:

nuts = ['ab','bc','dd','gg'], bolts = ['AB','BC','DD','GG'].

we will tell you the match compare function. If we give you another compare function.

the possible return is the following:

nuts = ['ab','bc','dd','gg'], bolts = ['BC','AA','DD','GG'].

So you must use the compare function that we give to do the sorting.

The order of the nuts or bolts does not matter. You just need to find the matching bolt for each nut.

Solution 1. O(n) runtime, O(n) space, assuming the nut to bolt mapping is a simple String comparison.

1. create a hashmap from each nut to its index;

2.  iterate through all bolts and check if each bolt exists in the hashmap. If it does, simply sets nuts[i] to bolt[i].

This is a solution for a simplified version of this problem. If we are guranteed of a 1 to 1 mapping and this mapping is simply a

string match, then we can simply copy one array to the other array.

To the original problem which only provides us an abstract compare method. The mapping relation is hid from us, so we can't 

make any assumptions about this mapping in our algorithm.

Solution 2. O(n*logn) runtime

The goal is to sort both nuts and bolts arrays so they match at all indices. The simpliest way is sort both arrays separately. But this 

approach is not viable since comparison inside one array is forbidden. 

Comparison between nut and bolt is allowed and there is a one to one mapping between nut and bolt. So we can use quick sort 

to sort both arrays at the same time.

1.  pick the first bolt bolt[0] as pivot value to partition the array of nuts, return the index of nut which maps to bolt[0];

　  This nut is already in its sorted position based on pivot bolt[0];

2.  use the returned nut index pivotIdx to get nuts[pivotIdx] as pivot to partition the array of bolts;

 　 bolts[pivotIdx] will be in its sorted position after partition. 

3.   repeat the above partition for both the left and right partition of nuts and bolts arrays until all nuts and bolts are matched.

/**
 * public class NBCompare {
 *     public int cmp(String a, String b);
 * }
 * You can use compare.cmp(a, b) to compare nuts "a" and bolts "b",
 * if "a" is bigger than "b", it will return 1, else if they are equal,
 * it will return 0, else if "a" is smaller than "b", it will return -1.
 * When "a" is not a nut or "b" is not a bolt, it will return 2, which is not valid.
*/
public class Solution {
    public void sortNutsAndBolts(String[] nuts, String[] bolts, NBComparator compare) {
        if(nuts == null || nuts.length == 0 || bolts == null || bolts.length == 0) {
            return;
        }
        quickSortRecur(nuts,  bolts, 0, nuts.length - 1, compare);
    }
    private void quickSortRecur(String[] nuts, String[] bolts, int start, int end, NBComparator compare) {
        if(start < end) {
            //choose the first bolt as pivot to partition nuts
            int pivot = partition(nuts, start, end, bolts[start], compare);
            //use the nut of position pivot as pivot to partition bolts
            partition(bolts, start, end, nuts[pivot], compare);
            
            quickSortRecur(nuts, bolts, start, pivot - 1, compare);
            quickSortRecur(nuts, bolts, pivot + 1, end, compare);
        }
    }
    private int partition(String[] str, int start, int end, String pivot, NBComparator compare) {
        //swap the first element with the element that is equal to pivot
        for(int i = start; i <= end; i++) {
            if(compare.cmp(str[i], pivot) == 0 || compare.cmp(pivot, str[i]) == 0) {
                swap(str, i, start);
                break;
            }
        }
        //use the newly swapped element as pivot(the same string with the parameter pivot)
        //to partition str
        int i = start + 1; 
        for(int j = start + 1; j <= end; j++) {
            if(compare.cmp(str[j], pivot) == -1 || compare.cmp(pivot, str[j]) == 1) {
                swap(str, i, j);
                i++;
            }
        }
        //final swap to put element of value pivot into its sorted position
        swap(str, start, i - 1);
        return i - 1;
    }
    private void swap(String[] str, int idx1, int idx2) {
        String temp = str[idx1];
        str[idx1] = str[idx2];
        str[idx2] = temp;
    }
};

Related Problems

Sort Integers II