Encuentre el volumen máximo de un paralelepípedo a partir del perímetro y el área dados

Dado un perímetro P y un área A, la tarea es calcular el volumen máximo que se puede hacer en forma de paralelepípedo a partir del perímetro y el área de superficie dados.

Ejemplos: 

Input: P = 24, A = 24
Output: 8

Input: P = 20, A = 14
Output: 3

Enfoque: Para un perímetro dado de un cuboide tenemos P = 4(l+b+h) —(i), 
para un área dada de un cuboide tenemos A = 2 (lb+bh+lh) —(ii). 
El volumen del cuboide es V = lbh El
volumen depende de 3 variables l, b, h. Hagamos que dependa solo de la longitud.

como V = lbh, 
=> V = l (A/2-(lb+lh)) {de la ecuación (ii)} 
=> V = lA/2 – l ² (b+h) 
=> V = lA/2 – l ² (P/4-l) {de la ecuación (i)} 
=> V = lA/2 – l ² P/4 + l ³ —-(iii)
Ahora diferencie V wrt l para encontrar el volumen máximo. 
dV/dl = A/2 – lP/2 + 3l ² 
Después de resolver la cuadrática en l tenemos l = (P – (P ² -24A) ^1/2 ) / 12 
Sustituyendo el valor de l en (iii), podemos encontrar fácilmente el volumen máximo.

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

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// function to return maximum volume
float maxVol(float P, float A)
{
    // calculate length
    float l = (P - sqrt(P * P - 24 * A)) / 12;
 
    // calculate volume
    float V = l * (A / 2.0 - l * (P / 4.0 - l));
 
    // return result
    return V;
}
 
// Driver code
int main()
{
    float P = 20, A = 16;
   
    // Function call
    cout << maxVol(P, A);
 
    return 0;
}

// Java implementation of the above approach
import java.util.*;
 
class Geeks {
 
    // function to return maximum volume
    static float maxVol(float P, float A)
    {
        // calculate length
        float l
            = (float)(P - Math.sqrt(P * P - 24 * A)) / 12;
 
        // calculate volume
        float V
            = (float)(l * (A / 2.0 - l * (P / 4.0 - l)));
 
        // return result
        return V;
    }
 
    // Driver code
    public static void main(String args[])
    {
        float P = 20, A = 16;
       
        // Function call
        System.out.println(maxVol(P, A));
    }
}
 
// This code is contributed by Kirti_Mangal

# Python3 implementation of the
# above approach
from math import sqrt
 
# function to return maximum volume
 
 
def maxVol(P, A):
 
    # calculate length
    l = (P - sqrt(P * P - 24 * A)) / 12
 
    # calculate volume
    V = l * (A / 2.0 - l * (P / 4.0 - l))
 
    # return result
    return V
 
 
# Driver code
if __name__ == '__main__':
    P = 20
    A = 16
     
    # Function call
    print(maxVol(P, A))
 
# This code is contributed
# by Surendra_Gangwar

// C# implementation of the above approach
using System;
 
class GFG {
 
    // function to return maximum volume
    static float maxVol(float P, float A)
    {
        // calculate length
        float l
            = (float)(P - Math.Sqrt(P * P - 24 * A)) / 12;
 
        // calculate volume
        float V
            = (float)(l * (A / 2.0 - l * (P / 4.0 - l)));
 
        // return result
        return V;
    }
 
    // Driver code
    public static void Main()
    {
        float P = 20, A = 16;
        
        // Function call
        Console.WriteLine(maxVol(P, A));
    }
}
 
// This code is contributed
// by Akanksha Rai

<?php
// PHP implementation of the above approach
 
// function to return maximum volume
function maxVol($P, $A)
{
    // calculate length
    $l = ($P - sqrt($P * $P - 24 * $A)) / 12;
 
    // calculate volume
    $V = $l * ($A / 2.0 - $l *
              ($P / 4.0 - $l));
 
    // return result
    return $V;
}
 
// Driver code
$P = 20;
$A = 16;
 
// Function call
echo maxVol($P, $A);
 
// This code is contributed by mits
?>

<script>
// javascript implementation of the above approach
 
 
// function to return maximum volume
function maxVol( P,  A)
{
 
    // calculate length
    let l = (P - Math.sqrt(P * P - 24 * A)) / 12;
 
    // calculate volume
    let V = l * (A / 2.0 - l * (P / 4.0 - l));
 
    // return result
    return V;
}
 
// Driver code
    let P = 20, A = 16;
   
    // Function call
    document.write(maxVol(P, A).toFixed(5));
        
// This code is contributed by aashish1995
 
</script>

4.14815

Complejidad de tiempo: O(√ n) ya que se está utilizando la función sqrt

Espacio Auxiliar: O(1)