试管架问题

给定墙壁w的长度和长度分别为m和n的架子，请找到要使用的每种架子的数量以及最佳解决方案中的剩余空白空间，以使空白空间最小。两个架子中较大的一个比较便宜，因此是首选。但是，成本是次要的，首要任务是最小化墙壁上的空白空间。

例子：

Input : w = 24 m = 3 n = 5
Output : 3 3 0
We use three units of both shelves
and 0 space is left.
3 * 3 + 3 * 5 = 24
So empty space  = 24 - 24 = 0
Another solution could have been 8 0 0
but since the larger shelf of length 5
is cheaper the former will be the answer.

Input : w = 29 m = 3 n = 9 
Output : 0 3 2
0 * 3 + 3 * 9 = 27
29 - 27 = 2

Input : w = 24 m = 4 n = 7 
Output : 6 0 0
6 * 4 + 0 * 7 = 24
24 - 24 = 0

一种简单而有效的方法是尝试适合墙壁长度的所有可能的搁板组合。
为了实现这种方法，并从0开始就限制了较大的架子比较小的架子便宜，我们不增加较大类型的架子，直到它们适合为止。对于每种情况，我们都计算出空白空间，最后存储该值以最小化空白空间。如果两种情况下的空白空间相同，我们更喜欢没有更大架子的情况。

下面是它的实现。

C++

// C++ program to find minimum space and units
// of two shelves to fill a wall.
#include 
using namespace std;
 
void minSpacePreferLarge(int wall, int m, int n)
{
    // for simplicity, Assuming m is always smaller than n
    // initializing output variables
    int num_m = 0, num_n = 0, min_empty = wall;
 
    // p and q are no of shelves of length m and n
    // rem is the empty space
    int p = wall/m, q = 0, rem=wall%m;
      num_m=p;
      num_n=q;
      min_empty=rem;
    while (wall >= n) {
        // place one more shelf of length n
        q += 1;
        wall = wall - n;
          // place as many shelves of length m
        // in the remaining part
        p = wall / m;
        rem = wall % m;
 
        // update output variablse if curr
        // min_empty <= overall empty
        if (rem <= min_empty) {
            num_m = p;
            num_n = q;
            min_empty = rem;
        }
    }
 
    cout << num_m << " " << num_n << " "
         << min_empty << endl;
}
 
// Driver code
int main()
{
    int wall = 29, m = 3, n = 9;
    minSpacePreferLarge(wall, m, n);
 
    wall = 76, m = 1, n = 10;
    minSpacePreferLarge(wall, m, n);
    return 0;
}

Java

// Java program to count all rotation
// divisible by 4.
 
public class GFG {
    static void minSpacePreferLarge(int wall, int m, int n)
    {
        // For simplicity, Assuming m is always smaller than n
        // initializing output variables
        int num_m = 0, num_n = 0, min_empty = wall;
 
        // p and q are no of shelves of length m and n
        // rem is the empty space
        int p = wall/m, q = 0, rem=wall%m;
          num_m=p;
          num_n=q;
          min_empty=rem;
        while (wall >= n) {
            q += 1;
            wall = wall - n;
            // place as many shelves of length m
            // in the remaining part
            p = wall / m;
            rem = wall % m;
 
            // update output variablse if curr
            // min_empty <= overall empty
            if (rem <= min_empty) {
                num_m = p;
                num_n = q;
                min_empty = rem;
            }
 
            // place one more shelf of length n
            q += 1;
            wall = wall - n;
        }
        System.out.println(num_m + " " + num_n + " " + min_empty);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int wall = 24, m = 3, n = 5;
        minSpacePreferLarge(wall, m, n);
 
        wall = 24;
        m = 4;
        n = 7;
        minSpacePreferLarge(wall, m, n);
    }
}
 
// This code is contributed by Saket Kumar

Python

def minSpacePreferLarge(w, m, n):
 
    # initialize result variables
    num_m = 0
    num_n = 0
    rem = w
 
    # p and q are no of shelves of length m &
    # n respectively. r is the remainder uncovered
    # wall length
    p = wall//m
    q = 0
    rem=wall%m;
      num_m=p;
      num_n=q;
      min_empty=rem;
    while (w >= n):
        q += 1;
        wall = wall - n;
        p = w // m
        r = w % m
        if (r <= rem):
            num_m = p
            num_n = q
            rem = r
        q += 1
        w -= n
    print( str(int(num_m)) + " " + str(num_n) + " " + str(rem))
 
# Driver code
w = 24
m = 3
n = 5
minSpacePreferLarge(w, m, n)
 
w = 24
m = 4
n = 7
minSpacePreferLarge(w, m, n)

C#

// C# program to count all rotation
// divisible by 4.
using System;
 
class GFG {
    static void minSpacePreferLarge(int wall, int m, int n)
    {
        // For simplicity, Assuming m is always smaller than n
        // initializing output variables
        int num_m = 0, num_n = 0, min_empty = wall;
 
        // p and q are no of shelves of length m and n
        // rem is the empty space
        int p = wall/m, q = 0, rem=wall%m;
          num_m=p;
          num_n=q;
          min_empty=rem;
 
        while (wall >= n) {
           
            q += 1;
            wall = wall - n;
            // place as many shelves of length m
            // in the remaining part
             
            p = wall / m;
            rem = wall % m;
 
            // update output variablse if curr
            // min_empty <= overall empty
            if (rem <= min_empty) {
                num_m = p;
                num_n = q;
                min_empty = rem;
            }
 
            // place one more shelf of length n
            q += 1;
            wall = wall - n;
        }
        Console.WriteLine(num_m + " " + num_n + " " + min_empty);
    }
 
    // Driver code
    static public void Main()
    {
        int wall = 24, m = 3, n = 5;
        minSpacePreferLarge(wall, m, n);
 
        wall = 24;
        m = 4;
        n = 7;
        minSpacePreferLarge(wall, m, n);
    }
}
 
// This code is contributed by Tushil.

PHP

= $n)
    {
        $q += 1;
        $wall = $wall - $n;
        // place as many shelves of length m
        // in the remaining part
        $p = $wall / $m;
        $rem = $wall % $m;
 
        // update output variablse if curr
        // min_empty <= overall empty
        if ($rem <= $min_empty)
        {
            $num_m = $p;
            $num_n = $q;
            $min_empty = $rem;
        }
 
        // place one more shelf of length n
        $q += 1;
        $wall = $wall - $n;
    }
 
    echo $num_m , " ", $num_n , " ",
        $min_empty ,"\n";
}
 
    // Driver code
    $wall = 24;
    $m = 3;
    $n = 5;
    minSpacePreferLarge($wall, $m, $n);
 
    $wall = 24;
    $m = 4;
    $n = 7;
    minSpacePreferLarge($wall, $m, $n);
 
 
// This code is contributed by ajit.
?>

输出

0 3 2
6 7 0