cut_rod.cpp File Reference

Implementation of cutting a rod problem. More...

`#include <array>`
`#include <cassert>`
`#include <climits>`
`#include <iostream>`
Include dependency graph for cut_rod.cpp:

## Namespaces

| dynamic_programming
| Dynamic Programming algorithms.
| cut_rod
| Implementation of cutting a rod problem.

## Functions

template<size_t T>
int | dynamic_programming::cut_rod::maxProfitByCuttingRod (const std::array< int, T > &price, const uint64_t &n)
| Cuts the rod in different pieces and stores the maximum profit for each piece of the rod. More...
static void | test ()
| Function to test above algorithm. More...
int | main ()
| Main function. More...

## Detailed Description

Implementation of cutting a rod problem.

Given a rod of length n inches and an array of prices that contains prices of all pieces of size<=n. Determine the maximum profit obtainable by cutting up the rod and selling the pieces.

### Algorithm

The idea is to break the given rod into every smaller piece as possible and then check profit for each piece, by calculating maximum profit for smaller pieces we will build the solution for larger pieces in bottom-up manner.

Author
  Anmol
  Pardeep

## Function Documentation

## main()

int main | ( | void |  | ) |

Main function.

Returns
  0 on exit

{
// Testing
test();
return 0;
}
test
static void test()
Function to test above algorithm.
Definition: cut_rod.cpp:71
Here is the call graph for this function:

## maxProfitByCuttingRod()

template<size_t T>

int dynamic_programming::cut_rod::maxProfitByCuttingRod | ( | const std::array< int, T > & | price,
|  | const uint64_t & | n
| ) |  |

Cuts the rod in different pieces and stores the maximum profit for each piece of the rod.

Template Parameters

  T | size of the price array

Parameters

  n | size of the rod in inches
  price | an array of prices that contains prices of all pieces of size<=n

Returns
  maximum profit obtainable for

Parameters

  n | inch rod.

{
int *profit =
new int[n + 1]; // profit[i] will hold maximum profit for i inch rod
profit[0] = 0; // if length of rod is zero, then no profit
// outer loop will select size of rod, starting from 1 inch to n inch rod.
// inner loop will evaluate the maximum profit we can get for i inch rod by
// making every possible cut on it and will store it in profit[i].
for (size_t i = 1; i <= n; i++) {
int q = INT_MIN;
for (size_t j = 1; j <= i; j++) {
q = std::max(q, price[j - 1] + profit[i - j]);
}
profit[i] = q;
}
const int16_t ans = profit[n];
delete[] profit;
return ans; // returning maximum profit
}
ans
ll ans(ll n)
Definition: matrix_exponentiation.cpp:91
std::max
T max(T... args)
Here is the call graph for this function:

## test()

static void test | ( |  | ) |

static

Function to test above algorithm.

Returns
  void

{
// Test 1
const int16_t n1 = 8; // size of rod
std::array<int32_t, n1> price1 = {1,2,4,6,8,45,21,9}; // price array
const int64_t max_profit1 =
dynamic_programming::cut_rod::maxProfitByCuttingRod(price1, n1);
const int64_t expected_max_profit1 = 47;
assert(max_profit1 == expected_max_profit1);
std::cout << "Maximum profit with " << n1 << " inch road is " << max_profit1
<< std::endl;
// Test 2
const int16_t n2 = 30; // size of rod
std::array<int32_t, n2> price2 = {
1, 5, 8, 9, 10, 17, 17, 20, 24, 30, // price array
31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
const int64_t max_profit2=
dynamic_programming::cut_rod::maxProfitByCuttingRod(price2, n2);
const int32_t expected_max_profit2 = 90;
assert(max_profit2 == expected_max_profit2);
std::cout << "Maximum profit with " << n2 << " inch road is " << max_profit2
<< std::endl;
// Test 3
const int16_t n3 = 5; // size of rod
std::array<int32_t, n3> price3 = {2,9,17,23,45}; // price array
const int64_t max_profit3 =
dynamic_programming::cut_rod::maxProfitByCuttingRod(price3, n3);
const int64_t expected_max_profit3 = 45;
assert(max_profit3 == expected_max_profit3);
std::cout << "Maximum profit with " << n3 << " inch road is " << max_profit3
<< std::endl;
}
std::array
std::cout
dynamic_programming::cut_rod::maxProfitByCuttingRod
int maxProfitByCuttingRod(const std::array< int, T > &price, const uint64_t &n)
Cuts the rod in different pieces and stores the maximum profit for each piece of the rod.
Definition: cut_rod.cpp:44
std::endl
T endl(T... args)
Here is the call graph for this function: