Maximum number of pair reductions possible on a given triplet

Given a triplet of integers (A, B, C), the task is to count the maximum number of decrements by 1 that can be performed on positive pairs of the given triplet.

Examples:

Input: A = 4, B = 3, C = 2
Output: 4
Explanation:
Operation 1: Reduce the pair (4, 3). Therefore, the triplet reduces to {3, 2, 2}.
Operation 2: Reduce the pair (3, 2). Therefore, the triplet reduces to {2, 1, 2}.
Operation 3: Reduce the pair (2, 2). Therefore, the triplet reduces to {1, 1, 1}.
Operation 3: Reduce the pair (1, 1). Therefore, the triplet reduces to {0, 0, 1}.
No further operations are possible.

Input: A = 7, B = 9, C = 6
Output: 11

Approach: The idea is to use Greedy Approach to solve the problem. Follow the steps below to solve the problem:

• Store the triplet in an array.
• Initialize a variable, say count, to store the maximum possible reductions that can be performed on the triplet.
• Iterate a loop until the first two array elements are reduced to 0 and perform the following operations:
  • Sort the array in increasing order.
  • Pick the two maximum array elements and reduce them by 1.
  • Increment count by 1.
• Print the value of count as the required answer.

Below is the implementation of the above approach:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to count the maximum
// number of pair reductions
// possible on a given triplet
void maxOps(int a, int b, int c)
{

    // Convert them into an array
    int arr[] = { a, b, c };

    // Stores count of operations
    int count = 0;

    while (1) {

        // Sort the array
        sort(arr, arr + 3);

        // If the first two array
        // elements reduce to 0
        if (!arr[0] && !arr[1])
            break;

        // Apply the operations
        arr[1] -= 1;
        arr[2] -= 1;

        // Increment count
        count += 1;
    }

    // Print the maximum count
    cout << count;
}

// Driver Code
int main()
{
    // Given triplet
    int a = 4, b = 3, c = 2;
    maxOps(a, b, c);
    return 0;
}

// This code is contributed by subhammahato348.

// Java program for the above approach
import java.util.*;
class GFG
{

  // Function to count the maximum
  // number of pair reductions
  // possible on a given triplet
  static void maxOps(int a, int b, int c)
  {

    // Convert them into an array
    int arr[] = { a, b, c };

    // Stores count of operations
    int count = 0;
    while (1 != 0) 
    {

      // Sort the array
      Arrays.sort(arr);

      // If the first two array
      // elements reduce to 0
      if (arr[0] == 0 && arr[1] == 0)
        break;

      // Apply the operations
      arr[1] -= 1;
      arr[2] -= 1;

      // Increment count
      count += 1;
    }

    // Print the maximum count
    System.out.print(count);
  }

  // Driver Code
  public static void main(String[] args)
  {
    
    // Given triplet
    int a = 4, b = 3, c = 2;
    maxOps(a, b, c);
  }
}

// This code is contributed by code_hunt.

# Python3 program for the above approach

# Function to count the maximum
# number of pair reductions
# possible on a given triplet
def maxOps(a, b, c):
  
  # Convert them into an array
  arr = [a, b, c]
  
  # Stores count of operations
  count = 0

  while True:
    
    # Sort the array 
    arr.sort()
    
    # If the first two array
    # elements reduce to 0
    if not arr[0] and not arr[1]:
      break
      
    # Apply the operations
    arr[1] -= 1
    arr[2] -= 1
    
    # Increment count
    count += 1
    
  # Print the maximum count
  print(count)

# Given triplet
a, b, c = 4, 3, 2
maxOps(a, b, c)

// C# program for the above approach
using System;
class GFG
{

  // Function to count the maximum
  // number of pair reductions
  // possible on a given triplet
  static void maxOps(int a, int b, int c)
  {

    // Convert them into an array
    int[] arr = { a, b, c };

    // Stores count of operations
    int count = 0;
    while (1 != 0) 
    {

      // Sort the array
      Array.Sort(arr);

      // If the first two array
      // elements reduce to 0
      if (arr[0] == 0 && arr[1] == 0)
        break;

      // Apply the operations
      arr[1] -= 1;
      arr[2] -= 1;

      // Increment count
      count += 1;
    }

    // Print the maximum count
    Console.WriteLine(count);
  }

// Driver Code
public static void Main(String[] args)
{
    // Given triplet
    int a = 4, b = 3, c = 2;
    maxOps(a, b, c);
}
}

// This code is contributed by susmitakundugoaldanga.

<script>

// JavaScript program for the above approach

// Function to count the maximum
// number of pair reductions
// possible on a given triplet
function maxOps(a, b, c)
{

    // Convert them into an array
    let arr = [ a, b, c ];

    // Stores count of operations
    let count = 0;

    while (1) {

        // Sort the array
        arr.sort();

        // If the first two array
        // elements reduce to 0
        if (!arr[0] && !arr[1])
            break;

        // Apply the operations
        arr[1] -= 1;
        arr[2] -= 1;

        // Increment count
        count += 1;
    }

    // Print the maximum count
    document.write(count);
}

// Driver Code
    // Given triplet
    let a = 4, b = 3, c = 2;
    maxOps(a, b, c);


// This code is contributed by Surbhi Tyagi.

</script>

4

Time Complexity: O(log n), where n is the maximum value among a, b, and c, as the number of pair reductions required to reduce the two largest numbers to 0 is proportional to log n.
Auxiliary Space: O(1)

METHOD: Max_ pair_ reductions

APPROACH:

This algorithm sorts the input triplet in descending order and then repeatedly subtracts the smaller of the first two values from both of them until one of them becomes zero. The number of reductions performed in each step is added to a counter. Once one of the values becomes zero, the algorithm adds the remaining value to the counter and returns it as the maximum number of pair reductions possible

ALGORITHM:

1.Create a list containing the values of A, B, and C.
2.Sort the list in decreasing order.
3.Initialize a count variable to 0.
4.While the first two elements of the list are positive, perform the following operations:
a. Find the minimum of the first two elements.
b. Subtract the minimum from both elements.
c. Increment the count variable by the minimum.
d. Sort the list in decreasing order.
5.Return the count variable plus the value of the remaining element of the list.

#include <algorithm>
#include <iostream>

using namespace std;

int max_pair_reductions(int A, int B, int C)
{
    int triplet[] = { A, B, C };
    sort(triplet, triplet + 3, greater<int>());
    int count = 0;

    while (triplet[0] > 0 && triplet[1] > 0) {
        int min_val = min(triplet[0], triplet[1]);
        triplet[0] -= min_val;
        triplet[1] -= min_val;
        count += min_val;
        sort(triplet, triplet + 3, greater<int>());
    }

    return count + triplet[2];
}

int main()
{
    int A = 4;
    int B = 3;
    int C = 2;
    cout << max_pair_reductions(A, B, C)
         << endl; // Output: 4
    return 0;
}

import java.util.Arrays;

public class MaxPairReductions {

    // Function to calculate the maximum pair reductions
    static int maxPairReductions(int A, int B, int C) {
        int[] triplet = { A, B, C }; // Create an array to hold the values A, B, and C
        Arrays.sort(triplet); // Sort the array in ascending order
        int count = 0; // Initialize a counter for reductions

        // Continue reducing pairs until both A and B are greater than 0
        while (triplet[2] > 0 && triplet[1] > 0) {
            int minVal = Math.min(triplet[2], triplet[1]); // Find the minimum value between triplet[2] and triplet[1]
            triplet[2] -= minVal; // Reduce triplet[2] by minVal
            triplet[1] -= minVal; // Reduce triplet[1] by minVal
            count += minVal; // Increment the reduction count
            Arrays.sort(triplet); // Sort the array again to maintain ascending order
        }

        return count + triplet[0]; // Return the total count plus the remaining value in triplet[0]
    }

    public static void main(String[] args) {
        int A = 4;
        int B = 3;
        int C = 2;
        System.out.println(maxPairReductions(A, B, C)); // Output: 4
    }
}

def max_pair_reductions(A, B, C):
    triplet = [A, B, C]
    triplet.sort(reverse=True)
    count = 0
    while triplet[0] > 0 and triplet[1] > 0:
        min_val = min(triplet[0], triplet[1])
        triplet[0] -= min_val
        triplet[1] -= min_val
        count += min_val
        triplet.sort(reverse=True)
    return count + triplet[2]

A = 4
B = 3
C = 2
print(max_pair_reductions(A, B, C))  # 4

using System;
using System.Linq;

class Program
{
    // Function to find the maximum number of reductions in a triplet
    static int MaxPairReductions(int A, int B, int C)
    {
        // Create an array to store the triplet values
        int[] triplet = { A, B, C };

        // Sort the triplet in descending order
        Array.Sort(triplet, (x, y) => y.CompareTo(x));
        
        // Initialize a variable to count the number of reductions
        int count = 0;

        // Continue reducing pairs while the two largest elements are positive
        while (triplet[0] > 0 && triplet[1] > 0)
        {
            // Find the minimum value between the two largest elements
            int minVal = Math.Min(triplet[0], triplet[1]);

            // Subtract the minimum value from both elements
            triplet[0] -= minVal;
            triplet[1] -= minVal;

            // Increase the reduction count
            count += minVal;

            // Re-sort the triplet to maintain the descending order
            Array.Sort(triplet, (x, y) => y.CompareTo(x));
        }

        // Add the remaining value to the count
        return count + triplet[2];
    }

    static void Main()
    {
        // Input values
        int A = 4;
        int B = 3;
        int C = 2;

        // Call the function and print the result
        Console.WriteLine(MaxPairReductions(A, B, C)); // Output: 4
    }
}

function max_pair_reductions(A, B, C)
{
    let triplet = [ A, B, C ];
    triplet.sort();
    triplet.reverse();
    let count = 0;

    while (triplet[0] > 0 && triplet[1] > 0) {
        let min_val = Math.min(triplet[0], triplet[1]);
        triplet[0] -= min_val;
        triplet[1] -= min_val;
        count += min_val;
        triplet.sort();
        triplet.reverse();
    }

    return count + triplet[2];
}

let A = 4;
let B = 3;
let C = 2;
document.write(max_pair_reductions(A, B, C)); // Output: 4
  

4

The time complexity of this algorithm is O(log n), where n is the maximum value of A, B, and C. The space complexity is O(1), as the algorithm only uses a fixed amount of memory for the input triplet, counter, and some temporary variables.

rohitsingh07052

Follow

Improve

Article Tags :

• Greedy
• Sorting
• Mathematical
• DSA

Practice Tags :

• Greedy
• Mathematical
• Sorting