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.

Analysis: http://www.geeksforgeeks.org/nuts-bolts-problem-lock-key-problem/

There is a solution to this problem in O(nlgn) that works even if you can't compare two nuts or two bolts directly. That is without using a scale, or if the differences in weight are too small to observe.

It works by applying a small variation of randomised quicksort as follows:

Pick a random bolt b.
Compare bolt b with all the nuts, partitioning the nuts into those of size less than b and greater than b.
Now we must also partition the bolts into two halves as well and we can't compare bolt to bolt. But now we know what is the matching nut n to b. So we compare n to all the bolts, partitioning them into those of size less than n and greater than n.
The rest of the problem follows directly from randomised quicksort by applying the same steps to the lessThan and greaterThan partitions of nuts and bolts.

从这题得到的启发：如果一个本需要用O(N^2)来解决的问题，而被要求用更低的复杂度，应该想到需要减少compare的次数，怎么减少? partiton.

 /**
  * 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) {
         // write your code here
         if (nuts == null || bolts == null || nuts.length != bolts.length || compare == null) return;
         helper(nuts, bolts, , nuts.length - , compare);
     }

     public void helper(String[] nuts, String[] bolts, int start, int end, NBComparator c) {
         if (start < end) {
             int p = partition(nuts, bolts, start, end, c);
             helper(nuts, bolts, start, p - , c);
             helper(nuts, bolts, p + , end, c);
         }
     }

     public int partition(String[] nuts, String[] bolts, int start, int end, NBComparator compare) {
         int p = start;
         for (int i = start; i < end; i++) {
             if (compare.cmp(nuts[i], bolts[end]) < ) {
                 swap(nuts, p, i);
                 p++;
             } else if (compare.cmp(nuts[i], bolts[end]) == ) {
                 swap(nuts, i, end);
                 i--;
             }
         }

         swap(nuts, p, end);

         int k = start;
         for (int i = start; i < end; i++) {
             if (compare.cmp(nuts[p], bolts[i]) > ) {
                 swap(bolts, k, i);
                 k++;
             } else if (compare.cmp(nuts[p], bolts[i]) == ) {
                 swap(bolts, i, end);
                 i--;
             }
         }
         swap(bolts, k, end);

         return k;
     }

     public void swap(String[] arr, int i, int j) {
         String temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;
     }
 };