Is there an efficient algorithm that could do this? - algorithm

Question

I have two lists of integers of equal length, each with no duplicates, and I need to map them to each other based on the (absolute value) of their differences, where nothing could be switched in the output to make the totaled differences of all pair smaller. The 'naive' approach I could think of would run would be this (in condensed C#, but I think it's pretty easy to get):
Dictionary<int, int> output;
List<int> list1, list2;
while(!list1.Empty) //While we haven't arranged all the pairs
{
int bestDistance = Int32.MaxValue; //best distance between numbers so far
int bestFirst, bestSecond; //best numbers so far
foreach(int i in list1)
{
foreach(int j in list2)
{
int distance = Math.Abs(i - j);
//if the distance is better than the best so far, make it the new best
if(distance < bestDistance)
{
bestDistance = distance;
bestFirst = i;
bestSecond = j;
}
}
}
output[bestFirst] = bestSecond; //add the best to dictionary
list1.Remove(bestFirst); //remove it from the lists
list2.Remove(bestSecond);
}
Essentially, it just finds the best pair, removes it, and then repeates until it's done. But this runs in cubic time, if I see it correctly, and would take incredibly long for large lists. Is there any faster way to do this?

Answer 1

This is less trivial than my initial hunch suggested. The key to keeping this O(N log(N)) is to work with sorted lists, and search for the "pivot" element in the second sorted list with the smallest difference to the first element in the first sorted list.
Thus the steps to take become:
Sort both input lists
Find the pivot element in the second sorted list
Return this pivot element together with the first element of the first sorted list
Keep track of the element index left to the pivot and right to the pivot
Iterate the first list in sorted order, returning either the left or right element, depending on which difference is smallest and adjusting the left and right indexes.
As in (c# example):
public static IEnumerable<KeyValuePair<int, int>> FindSmallestDistances(List<int> first, List<int> second)
{
Debug.Assert(first.Count == second.Count); // precondition.
// sort the input: O(N log(N)).
first.Sort();
second.Sort();
// determine pivot: O(N).
var min_first = first[0];
var smallest_abs_dif = Math.Abs(second[0] - min_first);
var pivot_ndx = 0;
for (int i = 1; i < second.Count; i++)
{
var abs_dif = Math.Abs(second[i] - min_first);
if (abs_dif < smallest_abs_dif)
{
smallest_abs_dif = abs_dif;
pivot_ndx = i;
}
};
// return the first one.
yield return new KeyValuePair<int, int>(min_first, second[pivot_ndx]);
// Iterate the rest: O(N)
var left = pivot_ndx - 1;
var right = pivot_ndx + 1;
for (var i = 1; i < first.Count; i++)
{
if (left >= 0)
{
if (right < first.Count && Math.Abs(first[i] - second[left]) > Math.Abs(first[i] - second[right]))
yield return new KeyValuePair<int, int>(first[i], second[right++]);
else
yield return new KeyValuePair<int, int>(first[i], second[left--]);
}
else
yield return new KeyValuePair<int, int>(first[i], second[right++]);
}
}