From d0949b23291bba85aa075ad35bb8a70f8a561576 Mon Sep 17 00:00:00 2001 From: Sree Vidya Date: Sat, 20 Jul 2024 11:05:03 +0530 Subject: [PATCH 1/3] 1547-Minimum-cost-to-cut-a-stick.md --- .../1547-Minimum-cost-to-cut-a-stick.md | 112 ++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md diff --git a/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md b/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md new file mode 100644 index 000000000..2edbd637e --- /dev/null +++ b/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md @@ -0,0 +1,112 @@ +--- +id: minimum-cost-to-cut-a-stick +title: Minimum Cost to Cut a Stick +sidebar_label: 1547 - Minimum Cost to Cut a Stick +tags: [Dynamic Programming, Array, C++] +description: Solve the problem of finding the minimum cost to cut a stick into smaller pieces at specified positions, using dynamic programming. +--- + +## Problem Statement + +### Problem Description + +Given a wooden stick of length `n` units. The stick is labeled from 0 to `n`. For example, a stick of length 6 is labeled as follows: +``` +0 - 1 - 2 - 3 - 4 - 5 - 6 +``` + +- Given an integer array `cuts` where `cuts[i]` denotes a position you should perform a cut at. + +- You should perform the cuts in order, but you can change the order of the cuts as you wish. + +- The cost of one cut is the length of the stick to be cut. The total cost is the sum of costs of all cuts. When you cut a stick, it will be split into two smaller sticks (i.e., the sum of their lengths is the length of the stick before the cut). + +- Return the minimum total cost of the cuts. + +### Example + +**Example 1:** +``` +Input: +n = 7, cuts = [1, 3, 4, 5] + +Output: +16 +``` + +**Explanation:** + +- Using cuts order = [1, 3, 4, 5] as in the input leads to the following scenario: + +- The first cut is done to a rod of length 7 so the cost is 7. + +- The second cut is done to a rod of length 6 (i.e., the second part of the first cut), the third is done to a rod of length 4 and the last cut is to a rod of length 3. + +- The total cost is 7 + 6 + 4 + 3 = 20. + +- Rearranging the cuts to be [3, 5, 1, 4] for example will lead to a scenario with total cost = 16 (as shown in the example photo 7 + 4 + 3 + 2 = 16). + + +### Constraints + +- 2 <= `n` <= 10^6 +- 1 <= `cuts.length` <= min(`n` - 1, 100) +- 1 <= `cuts[i]` <= `n` - 1 +- All the integers in the `cuts` array are distinct. + +## Solution + +### Intuition + +- Sort the cuts in ascending order. +- Use dynamic programming to minimize the cost of cuts. +- Define `dp[i][j]` as the minimum cost to cut the stick between cuts[i-1] and cuts[j-1]. +- Use a bottom-up approach to solve the subproblems and combine them to get the final result. + +### Time Complexity and Space Complexity Analysis + +- **Initialization**: + - Sorting the cuts array takes O(m log m) time, where m is the number of cuts. + - Initializing the `dp` array takes O(m^2) time. + - Overall initialization time complexity is O(m log m + m^2). + +- **DP Table Calculation**: + - Filling the `dp` table involves iterating over all possible subintervals and calculating the minimum cost for each subinterval using nested loops. + - This takes O(m^3) time in the worst case. + +- **Overall Time Complexity**: + - The overall time complexity is O(m^3). + +- **Space Complexity**: + - The `dp` table requires O(m^2) space. + - The space complexity is O(m^2). + +### Code + +#### C++ + +```cpp +class Solution { +public: + int minCost(int n, std::vector& cuts) { + std::sort(cuts.begin(), cuts.end()); + int m = cuts.size(); + std::vector> dp(m + 2, std::vector(m + 2, 0)); + + for (int l = 2; l <= m + 1; l++) { + for (int i = 0; i + l <= m + 1; i++) { + int j = i + l; + dp[i][j] = INT_MAX; + for (int k = i + 1; k < j; k++) { + dp[i][j] = std::min(dp[i][j], dp[i][k] + dp[k][j]); + } + int left = (i == 0) ? 0 : cuts[i - 1]; + int right = (j == m + 1) ? n : cuts[j - 1]; + dp[i][j] += right - left; + } + } + + return dp[0][m + 1]; + } +}; +``` From 43436115310008c8d5fd1af6f9b15b90dbbaabc5 Mon Sep 17 00:00:00 2001 From: Sree Vidya Date: Sat, 20 Jul 2024 12:55:29 +0530 Subject: [PATCH 2/3] Update 1547-Minimum-cost-to-cut-a-stick.md --- .../1500-1599/1547-Minimum-cost-to-cut-a-stick.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md b/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md index 2edbd637e..760f2231f 100644 --- a/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md +++ b/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md @@ -49,9 +49,9 @@ Output: ### Constraints -- 2 <= `n` <= 10^6 -- 1 <= `cuts.length` <= min(`n` - 1, 100) -- 1 <= `cuts[i]` <= `n` - 1 +- 2 <= `n` <= 10^6 +- 1 <= `cuts.length` <= min(`n` - 1, 100) +- 1 <= `cuts[i]` <= `n` - 1 - All the integers in the `cuts` array are distinct. ## Solution From 7da12cf89392b1c3bbaaa43bdcaefce08bdefd1f Mon Sep 17 00:00:00 2001 From: Sree Vidya Date: Sat, 20 Jul 2024 12:58:43 +0530 Subject: [PATCH 3/3] Update 1547-Minimum-cost-to-cut-a-stick.md --- .../1500-1599/1547-Minimum-cost-to-cut-a-stick.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md b/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md index 760f2231f..db31253ed 100644 --- a/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md +++ b/dsa-solutions/lc-solutions/1500-1599/1547-Minimum-cost-to-cut-a-stick.md @@ -66,20 +66,20 @@ Output: ### Time Complexity and Space Complexity Analysis - **Initialization**: - - Sorting the cuts array takes O(m log m) time, where m is the number of cuts. - - Initializing the `dp` array takes O(m^2) time. - - Overall initialization time complexity is O(m log m + m^2). + - Sorting the cuts array takes $O(m log m)$ time, where m is the number of cuts. + - Initializing the `dp` array takes $O(m^3)$ time. + - Overall initialization time complexity is $O(m log m + m^2)$. - **DP Table Calculation**: - Filling the `dp` table involves iterating over all possible subintervals and calculating the minimum cost for each subinterval using nested loops. - - This takes O(m^3) time in the worst case. + - This takes $O(m^3)$ time in the worst case. - **Overall Time Complexity**: - - The overall time complexity is O(m^3). + - The overall time complexity is $O(m^3)$. - **Space Complexity**: - - The `dp` table requires O(m^2) space. - - The space complexity is O(m^2). + - The `dp` table requires $O(m^2)$ space. + - The space complexity is $O(m^2)$. ### Code