Skip to content
Related Articles

Related Articles

Improve Article

Minimize positive product of two given numbers by at most N decrements

  • Last Updated : 28 Apr, 2021

Given three integers X, Y, and N, the task is to find the minimum possible positive product of X and Y that can be obtained by decreasing either the value of X or Y by 1 at most N times.

Examples:

Input: X = 5, Y= 6, N = 4
Output: 6
Explanation:
Decrease the value of X by 4, X = 5 – 4 = 1 and Y = 6.
Therefore, the minimized product = X * Y = 1 * 6 = 6

Input: X = 49, Y = 4256, N = 10
Output: 165984

Approach: The given problem can be solved based on the following observations:



If X ≤ Y: Reducing X minimizes the product. 
If Y ≤ X: Reducing Y minimizes the product.

Mathematical Proof:
If (X – 2) * Y < (X – 1) * (Y – 1) 
=> X * Y – 2 * Y < X * Y – X – Y + 1 
=> – 2 × Y < -X – Y + 1 
=> Y > X – 1

Follow the steps below to solve the problem:

  • If X ≤ Y: Follow the steps below: 
    • If N < X: Print Y * (X – N) as the answer as reducing X minimizes the product.
    • Otherwise, reduce X to 1 and reduce the remaining N from Y to minimize the product. Therefore, print Y – max(1, N – X + 1)) as the required minimized product.
  • Otherwise, if N < Y, print X * (Y – N) as the minimized product. If N ≥ Y, reduce Y to 1 and print max(X – (N – Y + 1), 1) as the minimized product.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to minimize
// the product of two numbers
int minProd(int X, int Y,
            int N)
{
    if (X <= Y) {
 
        if (N < X)
 
            // Reducing X, N times,
            // minimizes the product
            return (X - N) * Y;
        else {
 
            // Reduce X to 1 and reduce
            // remaining N from Y
            return max(Y - (N - X + 1), 1);
        }
    }
 
    if (Y >= N)
 
        // Reducing Y, N times,
        // minimizes the product
        return (Y - N) * X;
 
    // Reduce Y to 1 and reduce
    // remaining N from X
    return max(X - (N - Y + 1), 1);
    ;
}
 
// Driver Code
int main()
{
    int X = 47, Y = 42, N = 167;
    cout << minProd(X, Y, N);
}
Java



// Java program to implement
// the above approach
import java.io.*;
 
class GFG{
 
// Function to minimize
// the product of two numbers
static int minProd(int X, int Y,
                   int N)
{
    if (X <= Y)
    {
        if (N < X)
   
            // Reducing X, N times,
            // minimizes the product
            return (X - N) * Y;
        else
        {
             
            // Reduce X to 1 and reduce
            // remaining N from Y
            return Math.max(Y - (N - X + 1), 1);
        }
    }
   
    if (Y >= N)
   
        // Reducing Y, N times,
        // minimizes the product
        return (Y - N) * X;
   
    // Reduce Y to 1 and reduce
    // remaining N from X
    return Math.max(X - (N - Y + 1), 1);
}
   
// Driver Code
public static void main (String[] args)
{
    int X = 47, Y = 42, N = 167;
     
    System.out.println(minProd(X, Y, N));
}
}
 
// This code is contributed by code_hunt
Python3



# Python3 program to implement
# the above approach
 
# Function to minimize
# the product of two numbers
def minProd(X, Y, N):
    if (X <= Y):
 
        if (N < X):
 
            # Reducing X, N times,
            # minimizes the product
            return (X - N) * Y
        else:
 
            # Reduce X to 1 and reduce
            # remaining N from Y
            return max(Y - (N - X + 1), 1)
 
    if (Y >= N):
 
        # Reducing Y, N times,
        # minimizes the product
        return (Y - N) * X
 
    # Reduce Y to 1 and reduce
    # remaining N from X
    return max(X - (N - Y + 1), 1)
 
# Driver Code
if __name__ == "__main__":
    X = 47
    Y = 42
    N = 167
    print (minProd(X, Y, N))
 
# This code is contributed by Chitranayal
C#



// C# program to implement
// the above approach
using System;
class GFG{
 
// Function to minimize
// the product of two numbers
static int minProd(int X,
                   int Y, int N)
{
  if (X <= Y)
  {
    if (N < X)
 
      // Reducing X, N times,
      // minimizes the product
      return (X - N) * Y;
    else
    {
      // Reduce X to 1 and reduce
      // remaining N from Y
      return Math.Max(Y - (N -
                      X + 1), 1);
    }
  }
 
  if (Y >= N)
 
    // Reducing Y, N times,
    // minimizes the product
    return (Y - N) * X;
 
  // Reduce Y to 1 and reduce
  // remaining N from X
  return Math.Max(X - (N -
                  Y + 1), 1);
}
   
// Driver Code
public static void Main(String[] args)
{
  int X = 47, Y = 42, N = 167;
  Console.WriteLine(minProd(X, Y, N));
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript program to implement
// the above approach
 
// Function to minimize
// the product of two numbers
function minProd(X, Y, N)
{
    if (X <= Y)
    {
        if (N < X)
    
            // Reducing X, N times,
            // minimizes the product
            return (X - N) * Y;
        else
        {
              
            // Reduce X to 1 and reduce
            // remaining N from Y
            return Math.max(Y - (N - X + 1), 1);
        }
    }
    
    if (Y >= N)
    
        // Reducing Y, N times,
        // minimizes the product
        return (Y - N) * X;
    
    // Reduce Y to 1 and reduce
    // remaining N from X
    return Math.max(X - (N - Y + 1), 1);
}
 
// Driver Code
let X = 47, Y = 42, N = 167;
  
document.write(minProd(X, Y, N));
 
// This code is contributed by target_2
 
</script>
Output: 
1
 
Time Complexity: O(1)
Auxiliary Space: O(1)
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.



My Personal Notes
arrow_drop_up
Previous
Gigabit Passive Optical Networks (GPON) Fundamentals
Next

Number of pairs whose product is a power of 2
Recommended Articles
Page :
Minimize increments or decrements required to make sum and product of array elements non-zero
09, Nov 20
Minimize increments or decrements by 2 to convert given value to a perfect square
29, Oct 20
Minimum number of increment / decrements required to be performed on one of the two given numbers to make them non-coprime
26, Jul 21
Minimize subarray increments/decrements required to reduce all array elements to 0
17, Sep 20
Minimize cost of increments or decrements such that same indexed elements become multiple of each other
26, Feb 21
Minimize product of two scores possible by at most M reductions
02, Aug 21
Maximize absolute difference between X and Y by at most N decrements
27, Oct 20
Maximize length of longest subarray consisting of same elements by at most K decrements
03, Jan 21
Count ways to obtain triplets with positive product consisting of at most one negative element
18, Jan 21
Generate an array with K positive numbers such that arr[i] is either -1 or 1 and sum of the array is positive
16, May 21
Find prime factors of Z such that Z is product of all even numbers till N that are product of two distinct prime numbers
28, Jun 21
Minimize sum of absolute differences of same-indexed elements of two given arrays by at most one replacement
16, May 21
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Minimize the cost of selecting two numbers whose product is X
08, Apr 20
Find the last positive element remaining after repeated subtractions of smallest positive element from all Array elements
10, Sep 21
Minimize sum of K positive integers with given LCM
04, Dec 20
Check if a number can be represented as product of two positive perfect cubes
14, Apr 21
Minimize maximum array element by splitting array elements into powers of two at most K times
25, May 21
Find the missing digit in given product of large positive integers
27, Aug 21
Nth positive number whose absolute difference of adjacent digits is at most 1
30, Apr 20
Smallest positive integer K such that all array elements can be made equal by incrementing or decrementing by at most K
15, Jan 21
Minimize maximum array element possible by at most K splits on the given array
31, Mar 21
Minimize the sum of product of two arrays with permutations allowed
23, Dec 16
Minimize product of first N - 1 natural numbers by swapping same positioned bits of pairs
16, Oct 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
madarsh986
@madarsh986
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox