Find maximum volume of a cuboid from the given perimeter and area

Given a perimeter P and area A, the task is to calculate the maximum volume that can be made in form of cuboid from the given perimeter and surface area.

Examples :

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

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

Approach: For a given perimeter of cuboid we have P = 4(l+b+h) —(i), 
for given area of cuboid we have A = 2 (lb+bh+lh) —(ii). 
Volume of cuboid is V = lbh
Volume is dependent on 3 variables l, b, h. Lets make it dependent on only length.

as V = lbh, 
=> V = l (A/2-(lb+lh)) {from equation (ii)} 
=> V = lA/2 – l²(b+h) 
=> V = lA/2 – l²(P/4-l) {from equation (i)} 
=> V = lA/2 – l²P/4 + l³ —-(iii)
Now differentiate V w.r.t l for finding maximum of volume. 
dV/dl = A/2 – lP/2 + 3l²
After solving the quadratic in l we have l = (P – (P²-24A)^1/2) / 12 
Substituting value of l in (iii), we can easily find the maximum volume.

Below is the implementation of the above approach:

C++

// 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

// 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

# 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#

// 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

Javascript

<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>

PHP

<?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
?>

Output

4.14815

Time Complexity: O(logn)  as sqrt function is being used, time complexity of sqrt is logn

Auxiliary Space: O(1)