将小鼠分配到孔中

共有N个小鼠，并且N个孔成一直线放置。每个孔只能容纳1个鼠标。鼠标可以停留在其位置，从x右移x到x +1，或者从x左移x到x -1。任何这些举动都会消耗1分钟。将鼠标分配到孔中，以使最后一个鼠标进入孔中的时间最小化。

例子：

Input : positions of mice are:
          4 -4 2
        positions of holes are:
          4 0 5
Output :  4
Assign mouse at position x = 4 to hole at 
position x = 4 : Time taken is 0 minutes 
Assign mouse at position x=-4 to hole at 
position x = 0 : Time taken is 4 minutes 
Assign mouse at position x=2 to hole at 
position x = 5 : Time taken is 3 minutes 
After 4 minutes all of the mice are in the holes.
Since, there is no combination possible where
the last mouse's time is less than 4, 
answer = 4.

Input :  positions of mice are:
        -10, -79, -79, 67, 93, -85, -28, -94 
          positions of holes are:
         -2, 9, 69, 25, -31, 23, 50, 78 
Output : 102

使用贪婪策略可以解决此问题。我们可以将每只鼠标放到最近的孔中，以最大程度地减少时间。这可以通过对鼠标和孔的位置进行排序来完成。这使我们可以将第i个鼠标放入孔列表中的相应孔。然后，我们可以找到小鼠与相应孔位置之间的最大差异。

在示例2中，在对两个列表进行排序时，我们发现在位置-79处的鼠标是最后一次花费时间102到达孔23的鼠标。

sort mice positions (in any order)
sort hole positions 

Loop i = 1 to N:
    update ans according to the value 
    of |mice(i) - hole(i)|. It should
    be maximum of all differences.

正确性证明：
令i1 通过案例分析足以表明

max(|i1-j1|, |i2-j2|) <= max(|i1-j2|, |i2-j1|), 
   where '|a - b|' represent absolute value of (a - b)

由于通过归纳法得出的结论是，每个分配都可以通过一系列交换转换为排序的分配，因此这些交换都不会增加跨度。

C++

// C++ program to find the minimum
// time to place all mice in all holes.
#include 
using namespace std;
 
// Returns minimum time required
// to place mice in holes.
int assignHole(int mices[], int holes[],
               int n, int m)
{
     
    // Base Condition
    // No. of mouse and holes should be same
    if (n != m)
        return -1;
     
    // Sort the arrays
    sort(mices, mices + n);
    sort(holes, holes + m);
     
    // Finding max difference between
    // ith mice and hole
    int max = 0;
    for(int i = 0; i < n; ++i)
    {
        if (max < abs(mices[i] - holes[i]))
            max = abs(mices[i] - holes[i]);
    }
    return max;
}
 
// Driver Code
int main()
{
     
    // Position of mouses 
    int mices[] = { 4, -4, 2 };
   
    // Position of holes
    int holes[] = { 4, 0, 5 };
   
    // Number of mouses
    int n = sizeof(mices) / sizeof(mices[0]);
   
    // Number of holes
    int m = sizeof(holes) / sizeof(holes[0]);
   
    // The required answer is returned
    // from the function
    int minTime = assignHole(mices, holes, n, m);
   
    cout << "The last mouse gets into the hole in time:"
         << minTime << endl;
   
    return 0;
}
 
// This code is contributed by Aayush Garg

Java

// Java program to find the minimum time to place
// all mice in all holes.
import java.util.* ;
 
public class GFG
{
    // Returns minimum time required to place mice
    // in holes.
    public int assignHole(ArrayList mice,
                         ArrayList holes)
    {
        if (mice.size() != holes.size())
           return -1;
 
        /* Sort the lists */
        Collections.sort(mice);
        Collections.sort(holes);
 
        int size = mice.size();
 
        /* finding max difference between ith mice and hole */
        int max = 0;
        for (int i=0; i mice = new ArrayList();
        mice.add(4);
        mice.add(-4);
        mice.add(2);
        ArrayList holes= new ArrayList();
        holes.add(4);
        holes.add(0);
        holes.add(5);
        System.out.println("The last mouse gets into "+
         "the hole in time: "+gfg.assignHole(mice, holes));
    }
}

Python3

# Python3 program to find the minimum
# time to place all mice in all holes.
 
# Returns minimum time required
# to place mice in holes.
def assignHole(mices, holes, n, m):
     
    # Base Condition
    # No. of mouse and holes should be same
    if (n != m):
        return -1
     
    # Sort the arrays
    mices.sort()
    holes.sort()
     
    # Finding max difference between
    # ith mice and hole
    Max = 0
     
    for i in range(n):
        if (Max < abs(mices[i] - holes[i])):
            Max = abs(mices[i] - holes[i])
     
    return Max
     
# Driver code   
 
# Position of mouses
mices = [ 4, -4, 2 ]
 
# Position of holes
holes = [ 4, 0, 5 ]
 
# Number of mouses
n = len(mices)
 
# Number of holes
m = len(holes)
 
# The required answer is returned
# from the function
minTime = assignHole(mices, holes, n, m)
 
print("The last mouse gets into the hole in time:", minTime)
 
# This code is contributed by divyeshrabadiya07

C#

// C# program to find the minimum
// time to place all mice in all holes.
using System;
class GFG
{
     
    // Returns minimum time required
    // to place mice in holes.
    static int assignHole(int[] mices, int[] holes,
                   int n, int m)
    {
          
        // Base Condition
        // No. of mouse and holes should be same
        if (n != m)
            return -1;
          
        // Sort the arrays
        Array.Sort(mices);
        Array.Sort(holes);
          
        // Finding max difference between
        // ith mice and hole
        int max = 0;
        for(int i = 0; i < n; ++i)
        {
            if (max < Math.Abs(mices[i] - holes[i]))
                max = Math.Abs(mices[i] - holes[i]);
        }
        return max;
    }
   
  // Driver code    
  static void Main()
  {
     
    // Position of mouses 
    int[] mices = { 4, -4, 2 };
     
    // Position of holes
    int[] holes = { 4, 0, 5 };
     
    // Number of mouses
    int n = mices.Length;
     
    // Number of holes
    int m = holes.Length;
     
    // The required answer is returned
    // from the function
    int minTime = assignHole(mices, holes, n, m);
    Console.WriteLine("The last mouse gets into the hole in time: " + minTime);
  }
}
 
// This code is contributed by divyesh072019

Javascript

    // Javascript program to find the minimum
    // time to place all mice in all holes.
     
    // Returns minimum time required
    // to place mice in holes.
    function assignHole(mices, holes, n, m)
    {
 
        // Base Condition
        // No. of mouse and holes should be same
        if (n != m)
            return -1;
 
        // Sort the arrays
        mices.sort();
        holes.sort();
 
        // Finding max difference between
        // ith mice and hole
        let max = 0;
        for(let i = 0; i < n; ++i)
        {
            if (max < Math.abs(mices[i] - holes[i]))
                max = Math.abs(mices[i] - holes[i]);
        }
        return max;
    }
     
    // Position of mouses
    let mices = [ 4, -4, 2 ];
    
    // Position of holes
    let holes = [ 4, 0, 5 ];
    
    // Number of mouses
    let n = mices.length;
    
    // Number of holes
    let m = holes.length;
    
    // The required answer is returned
    // from the function
    let minTime = assignHole(mices, holes, n, m);
    
    document.write("The last mouse gets into the hole in time:" + minTime);
     
     // This code is contributed by mukesh07.

输出

The last mouse gets into the hole in time: 4