There are N Mice and N holes are placed in a straight line. Each hole can accommodate only 1 mouse. A mouse can stay at his position, move one step right from x to x + 1, or move one step left from x to x -1. Any of these moves consumes 1 minute. Assign mice to holes so that the time when the last mouse gets inside a hole is minimized.
Examples:
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
This problem can be solved using greedy strategy. We can put every mouse to its nearest hole to minimize the time. This can be done by sorting the positions of mice and holes. This allows us to put the ith mice to the corresponding hole in the holes list. We can then find the maximum difference between the mice and corresponding hole position.
In example 2, on sorting both the lists, we find that the mouse at position -79 is the last to travel to hole 23 taking time 102.
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.
Proof of correctness:
Let i1 < i2 be the positions of two mice and let j1 < j2 be the positions of two holes.
It suffices to show via case analysis that
max(|i1-j1|, |i2-j2|) <= max(|i1-j2|, |i2-j1|),
where '|a - b|' represent absolute value of (a - b)
Since it follows by induction that every assignment can be transformed by a series of swaps into the sorted assignment, where none of these swaps increases the span.
C++
#include <bits/stdc++.h>
using namespace std;
int assignHole( int mices[], int holes[],
int n, int m)
{
if (n != m)
return -1;
sort(mices, mices + n);
sort(holes, holes + m);
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;
}
int main()
{
int mices[] = { 4, -4, 2 };
int holes[] = { 4, 0, 5 };
int n = sizeof (mices) / sizeof (mices[0]);
int m = sizeof (holes) / sizeof (holes[0]);
int minTime = assignHole(mices, holes, n, m);
cout << "The last mouse gets into the hole in time:"
<< minTime << endl;
return 0;
}
|
C
#include <stdio.h>
#include<stdlib.h>
int assignHole( int mices[], int holes[],
int n, int m)
{
if (n != m)
return -1;
for ( int i=0;i<n;i++){
for ( int j=i+1;j<n;j++){
if (mices[i]>mices[j]){
int temp=mices[i];
mices[i]=mices[j];
mices[j]=temp;
}
}
}
for ( int i=0;i<m;i++){
for ( int j=i+1;j<m;j++){
if (holes[i]>holes[j]){
int temp=holes[i];
holes[i]=holes[j];
holes[j]=temp;
}
}
}
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;
}
int main()
{
int mices[] = { 4, -4, 2 };
int holes[] = { 4, 0, 5 };
int n = sizeof (mices) / sizeof (mices[0]);
int m = sizeof (holes) / sizeof (holes[0]);
int minTime = assignHole(mices, holes, n, m);
printf ( "The last mouse gets into the hole in time:%d" ,minTime);
return 0;
}
|
Java
import java.util.* ;
public class GFG
{
public int assignHole(ArrayList<Integer> mice,
ArrayList<Integer> holes)
{
if (mice.size() != holes.size())
return - 1 ;
Collections.sort(mice);
Collections.sort(holes);
int size = mice.size();
int max = 0 ;
for ( int i= 0 ; i<size; i++)
if (max < Math.abs(mice.get(i)-holes.get(i)))
max = Math.abs(mice.get(i)-holes.get(i));
return Math.abs(max);
}
public static void main(String[] args)
{
GFG gfg = new GFG();
ArrayList<Integer> mice = new ArrayList<Integer>();
mice.add( 4 );
mice.add(- 4 );
mice.add( 2 );
ArrayList<Integer> holes= new ArrayList<Integer>();
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
def assignHole(mices, holes, n, m):
if (n ! = m):
return - 1
mices.sort()
holes.sort()
Max = 0
for i in range (n):
if ( Max < abs (mices[i] - holes[i])):
Max = abs (mices[i] - holes[i])
return Max
mices = [ 4 , - 4 , 2 ]
holes = [ 4 , 0 , 5 ]
n = len (mices)
m = len (holes)
minTime = assignHole(mices, holes, n, m)
print ( "The last mouse gets into the hole in time:" , minTime)
|
C#
using System;
class GFG
{
static int assignHole( int [] mices, int [] holes,
int n, int m)
{
if (n != m)
return -1;
Array.Sort(mices);
Array.Sort(holes);
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;
}
static void Main()
{
int [] mices = { 4, -4, 2 };
int [] holes = { 4, 0, 5 };
int n = mices.Length;
int m = holes.Length;
int minTime = assignHole(mices, holes, n, m);
Console.WriteLine( "The last mouse gets into the hole in time: " + minTime);
}
}
|
Javascript
<script>
function assignHole(mices, holes, n, m)
{
if (n != m)
return -1;
mices.sort();
holes.sort();
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;
}
let mices = [ 4, -4, 2 ];
let holes = [ 4, 0, 5 ];
let n = mices.length;
let m = holes.length;
let minTime = assignHole(mices, holes, n, m);
document.write( "The last mouse gets into the hole in time:" + minTime);
</script>
|
Output
The last mouse gets into the hole in time: 4
Time Complexity: O(nlog(n))
Auxiliary Space: O(1), since no extra space has been taken.
Last Updated :
01 Sep, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...