最大化给定表达式的值

给定三个非零整数a ， b和c 。任务是通过以任意顺序在它们之间添加加法和乘法符号来找到可能的最大值。
注意：允许重新排列整数，但必须使用一次加法和乘法符号。也可以根据需要在等式之间放置大括号。
例子：

Input: a = 2, b = 1, c = 4 
Output: 12 
(1 + 2) * 4 = 3 * 4 = 12
Input: a = 2, b = 2, c = 2 
Output: 8 
(2 + 2) * 2 = 4 * 2 = 8 
 

方法：要解决此问题，可以选择生成所有可能性并对其进行计算以获取最大值的方法，但是这种方法效率不高。利用给定条件的优势，整数可以重新排列并强制使用每个数学符号(+，*)。下面列出了总共要解决的四种情况：

1. 所有三个整数均为非负数：为此，只需将两个较小的整数相加，然后将其结果乘以最大整数即可。
2. 一个整数为负，其余两个为正：将两个正整数相乘并将其结果加到负整数中。
3. 两个整数为负数，一个为正数：由于两个负数的乘积为正数，请将两个负整数相乘，然后将其结果加到正整数上。
4. 这三个都是负整数：将两个最大的整数相加，然后乘以最小的一个。情况3- ：(总和-最小)*最小

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the maximum result
int maximumResult(int a, int b, int c)
{
 
    // To store the count of negative integers
    int countOfNegative = 0;
 
    // Sum of all the three integers
    int sum = a + b + c;
 
    // Product of all the three integers
    int product = a * b * c;
     
    // To store the smallest and the largest
    // among all the three integers
    int largest = max(a,max(b,c));
    int smallest = min(a,min(b,c) );
       
     
    // Calculate the count of negative integers
    if (a < 0)
        countOfNegative++;
    if (b < 0)
        countOfNegative++;
    if (c < 0)
        countOfNegative++;
 
    // Depending upon count of negatives
    switch (countOfNegative) {
 
    // When all three are positive integers
    case 0:
        return (sum - largest) * largest;
 
    // For single negative integer
    case 1:
        return (product / smallest) + smallest;
 
    // For two negative integers
    case 2:
        return (product / largest) + largest;
 
    // For three negative integers
    case 3:
        return (sum - smallest) * smallest;
    }
}
 
// Driver Code
int main()
{
    int a=-2,b=-1,c=-4;
    cout << maximumResult(a, b, c);
 
    return 0;
}
// This code contributed by Nikhil

Java

// Java implementation of the approach
class GFG
{
     
// Function to return the maximum result
static int maximumResult(int a, int b, int c)
{
 
    // To store the count of negative integers
    int countOfNegative = 0;
 
    // Sum of all the three integers
    int sum = a + b + c;
 
    // Product of all the three integers
    int product = a * b * c;
 
    // To store the smallest and the largest
    // among all the three integers
    int largest = (a > b) ? ((a > c) ? a : c) :
                            ((b > c) ? b : c);
    int smallest= (a

---

Python3

# Python3 implementation of the approach
 
# Function to return the maximum result
# Python3 implementation of the approach
 
# Function to return the maximum result
def maximumResult(a, b, c):
 
    # To store the count of negative integers
    countOfNegative = 0
 
    # Sum of all the three integers
    Sum = a + b + c
 
    # Product of all the three integers
    product = a * b * c
 
    # To store the smallest and the
    # largest among all the three integers
    largest = max(a, b, c)
    smallest = min(a, b, c)
 
    # Calculate the count of negative integers
    if a < 0:
        countOfNegative += 1
    if b < 0:
        countOfNegative += 1
    if c < 0:
        countOfNegative += 1
 
    # When all three are positive integers
    if countOfNegative == 0:
        return (Sum - largest) * largest
 
    # For single negative integer
    elif countOfNegative == 1:
        return (product // smallest) + smallest
 
    # For two negative integers
    elif countOfNegative == 2:
        return (product // largest) + largest
 
    # For three negative integers
    elif countOfNegative == 3:
        return (Sum - smallest) * smallest
 
# Driver Code
if __name__ == "__main__":
 
    a, b, c = -2, -1, -4
    print(maximumResult(a, b, c))

C#

// C# implementation of the approach
using System;
 
class GFG
{
     
// Function to return the maximum result
static int maximumResult(int a, int b, int c)
{
 
    // To store the count of negative integers
    int countOfNegative = 0;
 
    // Sum of all the three integers
    int sum = a + b + c;
 
    // Product of all the three integers
    int product = a * b * c;
 
    // To store the smallest and the largest
    // among all the three integers
    int largest = (a > b) ? ((a > c) ? a : c) :
                            ((b > c) ? b : c);
    int smallest=(a

---

Javascript

// JavaScript implementation of the approach
 
// Function to return the maximum result
function maximumResult(a, b, c)
{
 
    // To store the count of negative integers
    let countOfNegative = 0;
 
    // Sum of all the three integers
    let sum = a + b + c;
 
    // Product of all the three integers
    let product = a * b * c;
     
    // To store the smallest and the largest
    // among all the three letegers
    let largest = Math.max(a,Math.max(b,c));
    let smallest = Math.min(a,Math.min(b,c) );
         
    // Calculate the count of negative integers
    if (a < 0)
        countOfNegative++;
    if (b < 0)
        countOfNegative++;
    if (c < 0)
        countOfNegative++;
 
    // Depending upon count of negatives
    switch (countOfNegative) {
 
    // When all three are positive integers
    case 0:
        return (sum - largest) * largest;
 
    // For single negative integer
    case 1:
        return (product / smallest) + smallest;
 
    // For two negative integers
    case 2:
        return (product / largest) + largest;
 
    // For three negative integers
    case 3:
        return (sum - smallest) * smallest;
    }
}
 
// Driver Code
 
    let a = -2, b = -1, c = -4;
    document.write(maximumResult(a, b, c));
 
// This code is contributed by Surbhi Tyagi.

输出：

12