#include <iostream>
#include <vector>
using namespace std;
int rodCutting(int n, vector<int> &price) {
vector<int> dp(n + 1, 0);
for (int len = 1; len <= n; len++) {
for (int cut = 1; cut <= len; cut++) {
dp[len] = max(dp[len], price[cut - 1] + dp[len - cut]);
}
}
return dp[n];
}
int main() {
int n;
cin >> n;
vector<int> price(n);
for (int i = 0; i < n; i++) cin >> price[i];
cout << rodCutting(n, price) << endl;
return 0;
}
// 1. Standard Rod Cutting (Maximum Profit)
int rodCuttingMaxProfit(vector<int>& price, int n) {
vector<int> dp(n+1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
dp[i] = max(dp[i], price[j] + dp[i - j - 1]);
}
}
return dp[n];
}
// 2. Minimum Number of Pieces for Maximum Profit
pair<int, int> rodCuttingMinPieces(vector<int>& price, int n) {
vector<int> dp(n+1, 0), cuts(n+1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
if (dp[i] < price[j] + dp[i-j-1]) {
dp[i] = price[j] + dp[i-j-1];
cuts[i] = 1 + cuts[i-j-1];
}
}
}
return {dp[n], cuts[n]};
}
// 3. Rod Cutting with Cutting Cost
int rodCuttingWithCost(vector<int>& price, int n, int cutCost) {
vector<int> dp(n+1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
int cut = (i == j+1) ? 0 : cutCost; // no cost if no actual cut
dp[i] = max(dp[i], price[j] + dp[i-j-1] - cut);
}
}
return dp[n];
}
// 4. Rod Cutting with Limited Supply of Each Length
int rodCuttingLimitedSupply(vector<int>& price, vector<int>& limit, int n) {
vector<int> dp(n+1, 0);
for (int i = 0; i < price.size(); i++) {
for (int k = 0; k < limit[i]; k++) {
for (int j = n; j >= i+1; j--) {
dp[j] = max(dp[j], price[i] + dp[j - i - 1]);
}
}
}
return dp[n];
}
// 5. Rod Cutting with Exact Number of Pieces
int rodCuttingExactK(vector<int>& price, int n, int K) {
vector<vector<int>> dp(n+1, vector<int>(K+1, INT_MIN));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
for (int k = 1; k <= K; k++) {
if (dp[i-j-1][k-1] != INT_MIN)
dp[i][k] = max(dp[i][k], dp[i-j-1][k-1] + price[j]);
}
}
}
return dp[n][K];
}
// 6. Rod Cutting with Forbidden Cuts
int rodCuttingForbidden(vector<int>& price, int n, unordered_set<int>& forbidden) {
vector<int> dp(n+1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
if (forbidden.count(j+1)) continue;
dp[i] = max(dp[i], price[j] + dp[i - j - 1]);
}
}
return dp[n];
}
// 7. Rod Cutting with Only Allowed Lengths
int rodCuttingAllowed(vector<int>& price, int n, unordered_set<int>& allowed) {
vector<int> dp(n+1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
if (allowed.count(j+1))
dp[i] = max(dp[i], price[j] + dp[i-j-1]);
}
}
return dp[n];
}
// 8. Rod Cutting with Minimum Waste
int rodCuttingMinWaste(vector<int>& requiredLengths, int rodLength) {
vector<int> dp(rodLength+1, INT_MAX);
dp[0] = 0;
for (int len : requiredLengths) {
for (int i = rodLength; i >= len; i--) {
if (dp[i-len] != INT_MAX)
dp[i] = min(dp[i], dp[i-len]);
}
}
for (int i = rodLength; i >= 0; i--) {
if (dp[i] != INT_MAX)
return rodLength - i;
}
return rodLength;
}
Comments
Post a Comment