给定一个盒子大小的数组size[] ，我们的任务是在将较小尺寸的盒子放入较大的盒子后，找到最后剩下的盒子数量。
注意：一个盒子里只能放一个小盒子。
例子：
Input: size[] = {1, 2, 3}
Output: 1
Explanation:
Here, box of size 1 can fit inside box of size 2 and the box of size 2 can fit inside box of size 3. So at last we have only one box of size 3.
Input: size[] = {1, 2, 2, 3, 7, 4, 2, 1}
Output: 3
Explanation:
Put the box of size 1, 2, 3, 4 and 7 together and for the second box put 1 and 2 together. At last 2 is left which will not fit inside anyone. So we have 3 boxes left.
方法：这个想法是按照下面给出的步骤：
- 按升序对给定的数组 size[] 进行排序，并检查当前框大小是否大于下一个框大小。如果是，则减少初始框数。
- 否则，如果当前框大小等于下一个框大小，则检查当前框是否可以容纳在下一个框大小旁边。如果是，则移动当前框指向变量，否则进一步移动下一个指向变量。
下面是上述方法的实现：
C++
// C++ implementation to minimize the
// number of the box by putting small
// box inside the bigger one
#include
using namespace std;
// Function to minimize the count
void minBox(int arr[], int n)
{
// Initial number of box
int box = n;
// Sort array of box size
// in increasing order
sort(arr, arr + n);
int curr_box = 0, next_box = 1;
while (curr_box < n && next_box < n) {
// check is current box size
// is smaller than next box size
if (arr[curr_box] < arr[next_box]) {
// Decrement box count
// Increment current box count
// Increment next box count
box--;
curr_box++;
next_box++;
}
// Check if both box
// have same size
else if (arr[curr_box] == arr[next_box])
next_box++;
}
// Print the result
cout << box << endl;
}
// Driver code
int main()
{
int size[] = { 1, 2, 3 };
int n = sizeof(size) / sizeof(size[0]);
minBox(size, n);
return 0;
} Java
// Java implementation to minimize the
// number of the box by putting small
// box inside the bigger one
import java.util.Arrays;
class GFG{
// Function to minimize the count
public static void minBox(int arr[], int n)
{
// Initial number of box
int box = n;
// Sort array of box size
// in increasing order
Arrays.sort(arr);
int curr_box = 0, next_box = 1;
while (curr_box < n && next_box < n)
{
// Check is current box size
// is smaller than next box size
if (arr[curr_box] < arr[next_box])
{
// Decrement box count
// Increment current box count
// Increment next box count
box--;
curr_box++;
next_box++;
}
// Check if both box
// have same size
else if (arr[curr_box] ==
arr[next_box])
next_box++;
}
// Print the result
System.out.println(box);
}
// Driver code
public static void main(String args[])
{
int []size = { 1, 2, 3 };
int n = size.length;
minBox(size, n);
}
}
// This code is contributed by SoumikMondalPython3
# Python3 implementation to minimize the
# number of the box by putting small
# box inside the bigger one
# Function to minimize the count
def minBox(arr, n):
# Initial number of box
box = n
# Sort array of box size
# in increasing order
arr.sort()
curr_box, next_box = 0, 1
while (curr_box < n and next_box < n):
# Check is current box size
# is smaller than next box size
if (arr[curr_box] < arr[next_box]):
# Decrement box count
# Increment current box count
# Increment next box count
box = box - 1
curr_box = curr_box + 1
next_box = next_box + 1
# Check if both box
# have same size
elif (arr[curr_box] == arr[next_box]):
next_box = next_box + 1
# Print the result
print(box)
# Driver code
size = [ 1, 2, 3 ]
n = len(size)
minBox(size, n)
# This code is contributed by divyeshrabadiya07C#
// C# implementation to minimize the
// number of the box by putting small
// box inside the bigger one
using System;
class GFG{
// Function to minimize the count
public static void minBox(int []arr, int n)
{
// Initial number of box
int box = n;
// Sort array of box size
// in increasing order
Array.Sort(arr);
int curr_box = 0, next_box = 1;
while (curr_box < n && next_box < n)
{
// Check is current box size
// is smaller than next box size
if (arr[curr_box] < arr[next_box])
{
// Decrement box count
// Increment current box count
// Increment next box count
box--;
curr_box++;
next_box++;
}
// Check if both box
// have same size
else if (arr[curr_box] ==
arr[next_box])
next_box++;
}
// Print the result
Console.WriteLine(box);
}
// Driver code
public static void Main(String []args)
{
int []size = { 1, 2, 3 };
int n = size.Length;
minBox(size, n);
}
}
// This code is contributed by Amit KatiyarJavascript
Java
// Java implementation of the
// above approach
import java.util.*;
public class Boxes {
// Function to count the boxes
// at the end
int countBoxes(int[] A) {
// Default value if
// array is empty
int count = -1;
int n = A.length;
// Map to store frequencies
Map map =
new HashMap<>();
// Loop to iterate over the
// elements of the array
for (int i=0; i count) count = val;
}
return count;
}
// Driver Code
public static void main(
String[] args)
{
int[] a = {8, 15, 1, 10, 5, 1};
Boxes obj = new Boxes();
// Function Call
int minBoxes = obj.countBoxes(a);
System.out.println(minBoxes);
}
} 输出
1时间复杂度： O(N*logN) 作为 Arrays.sort() 方法被使用。
辅助空间： O(1)
方法：问题中的关键观察是最小框数与数组中任何元素的最大频率相同。因为其余的元素相互调整。下面是在步骤帮助下的插图：
- 创建一个哈希映射来存储元素的频率。
- 最后，在保持频率后返回元素的最大频率。
下面是上述方法的实现：
Java
// Java implementation of the
// above approach
import java.util.*;
public class Boxes {
// Function to count the boxes
// at the end
int countBoxes(int[] A) {
// Default value if
// array is empty
int count = -1;
int n = A.length;
// Map to store frequencies
Map map =
new HashMap<>();
// Loop to iterate over the
// elements of the array
for (int i=0; i count) count = val;
}
return count;
}
// Driver Code
public static void main(
String[] args)
{
int[] a = {8, 15, 1, 10, 5, 1};
Boxes obj = new Boxes();
// Function Call
int minBoxes = obj.countBoxes(a);
System.out.println(minBoxes);
}
}
输出
2时间复杂度： O(N)
辅助空间： O(N)