Distribuya los objetos blancos y negros en grupos máximos bajo ciertas restricciones

 Dados W objetos blancos y B objetos negros y un número D, la tarea es encontrar si es posible distribuir los objetos blancos y negros en el número máximo de grupos tal que cada grupo contenga al menos uno de cada tipo de objeto y el diferencia entre el número de objetos de diferentes tipos en cada grupo no exceda D.

Ejemplos:

Entrada: W=2, B=5, D=2
Salida:
SI
Explicación:
La distribución puede ser de la siguiente manera: {W, B, B, B} y {W, B, B}.
Cada grupo contiene al menos una W y al menos una B, y la diferencia en cada grupo no excede a D.

Entrada: W=2, B=7, D=2
Salida:
NO

Aproximación: El número máximo de grupos posibles es min(W, B). Consideremos, W<B , entonces, puede haber como máximo W grupos, y en cada grupo solo hay un W . El número máximo de B en cada grupo será D+1 . Por lo tanto, el valor máximo de B debe ser menor que W*(D+1). Esta es la única condición necesaria. Siga los pasos a continuación para resolver el problema:

• Si W es mayor que B , intercambie W y B . (El intercambio no altera la respuesta)
• Compruebe si B es mayor que W*(D+1) , escriba NO.
• De lo contrario, escriba SÍ.

A continuación se muestra la implementación del enfoque anterior:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to check if it is possible to distribute W and B
// into maximum groups possible
void isPossible(int W, int B, int D)
{
    // If W is greater than B, swap them
    if (W > B)
        swap(W, B);
    // Distribution is not possible
    if (B > W * (D + 1))
        cout << "NO" << endl;
    // Distribution is possible
    else
        cout << "YES" << endl;
}
// Driver code
int main()
{
    // Input
    int W = 2;
    int B = 5;
    int D = 2;
 
    // Function call
    isPossible(W, B, D);
    return 0;
}

// Java program for the above approach
import java.io.*;
 
class GFG
{
 
  // Function to check if it is possible to distribute W
  // and B
  // into maximum groups possible
  public static void isPossible(int W, int B, int D)
  {
 
    // If W is greater than B, swap them
    if (W > B) {
      int temp = W;
      W = B;
      B = temp;
    }
 
    // Distribution is not possible
    if (B > W * (D + 1))
      System.out.println("NO");
     
    // Distribution is possible
    else
      System.out.println("YES");
  }
 
  // Driver code
  public static void main(String[] args)
  {
 
    // Input
    int W = 2;
    int B = 5;
    int D = 2;
 
    // Function call
    isPossible(W, B, D);
     
  }
}
 
 // This code is contributed by Potta Lokesh

# Python 3 program for the above approach
 
# Function to check if it is possible to distribute W and B
# into maximum groups possible
def isPossible(W, B, D):
    # If W is greater than B, swap them
    if (W > B):
        temp = W
        W = B
        B = temp
         
    # Distribution is not possible
    if (B > W * (D + 1)):
        print("NO")
    # Distribution is possible
    else:
        print("YES")
 
# Driver code
if __name__ == '__main__':
    # Input
    W = 2
    B = 5
    D = 2
 
    # Function call
    isPossible(W, B, D)
     
    # This code is contributed by bgangwar59.
    

// C# program for the above approach
using System;
 
class GFG {
 
    // Function to check if it is possible to distribute W
    // and B
    // into maximum groups possible
    static void isPossible(int W, int B, int D)
    {
 
        // If W is greater than B, swap them
        if (W > B) {
            int temp = W;
            W = B;
            B = temp;
        }
 
        // Distribution is not possible
        if (B > W * (D + 1))
            Console.WriteLine("NO");
 
        // Distribution is possible
        else
            Console.WriteLine("YES");
    }
 
    // Driver code
    public static void Main()
    {
 
        // Input
        int W = 2;
        int B = 5;
        int D = 2;
 
        // Function call
        isPossible(W, B, D);
    }
}
 
// This code is contributed by rishavmahato348.

<script>
      // JavaScript program for the above approach
 
      // Function to check if it is possible to distribute W and B
      // into maximum groups possible
      function isPossible(W, B, D)
      {
       
          // If W is greater than B, swap them
          if (W > B)
          {
              let temp = W;
              W = B;
              B = temp;
          }
           
          // Distribution is not possible
          if (B > W * (D + 1))
              document.write("NO");
               
          // Distribution is possible
          else
              document.write("YES");
      }
      // Driver code
 
      // Input
      let W = 2;
      let B = 5;
      let D = 2;
 
      // Function call
      isPossible(W, B, D);
 
// This code is contributed by Potta Lokesh
  </script>

YES

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)