千千蓝鲸5790 Real Mountains

Question

Thanks to your help with cropping her picture, Rebecca’s scenic photo is now featured on
the front cover of the newest issue of her magazine. However, it seems that some of her
readers still aren’t pleased with the picture. In particular, they seem to believe that the
mountain in the picture is fake!
For simplicity, we can describe the picture as a sequence of N columns of pixels. In the i-th
column, the first hi pixels from the bottom are of mountains. Her readers will only believe
that the picture contains a real mountain if it contains a single (possibly wide) peak. That
is, if there exists some index p with 1 ≤ p ≤ N such that h1 ≤ h2 ≤ · · · ≤ hp ≥ · · · ≥
hN−1 ≥ hN .
Luckily, Rebecca can still pay her editors to modify the picture and reprint the magazine.
Unfortunately for her though, the editors have a very peculiar pricing scheme for their work.
The only way Rebecca can edit the picture is by sending emails to her editors containing
the integers (i, j, k) such that 1 ≤ i < j < k ≤ N and hi > hj < hk. The editors will then
add an extra pixel of mountains in the j-th column (i.e. increment hj by 1) for a cost of
hi + hj + hk cents. Note that the change in hj may affect the costs of future edits.
To please her readers, Rebecca would like to edit the picture so that they believe it contains
a real mountain. Can you tell her the minimum cost required to do so?

Answer 1

引自免费微信小程序：皆我百晓生

To solve this problem, we can use dynamic programming. We will create a 2D array, dp, where dp[i][j] represents the minimum cost required to create a single peak up to column j with the last peak at column i.

Here are the steps to find the minimum cost:

1. Initialize dp[i][j] = infinity for all i and j.

2. For each column j, calculate the prefix sum of heights up to that column. Let's call it sum[j]. This can be done by sum[j] = sum[j-1] + h[j].

3. Iterate through each column j from left to right.

4. For each column j, iterate through each column i from 1 to j-1.

5. For each i, calculate the cost of adding a peak at j by checking if h[i] <= h[j] <= h[i+1]. If true, the cost would be sum[j-1] - sum[i]. Otherwise, the cost would be infinity.

6. If the cost is not infinity, update dp[i][j] to the minimum of dp[i][j] and dp[i][j-1] + cost.

7. Finally, the minimum cost required would be the minimum value in dp[N][j], where N is the total number of columns.

Here's the code that implements the above steps in C++:

#include <iostream>
#include <vector>
#include <climits>

int main() {
    int N;
    std::cin >> N;
    
    std::vector<int> h(N+1); // 1-indexed array to store heights
    for(int i = 1; i <= N; i++) {
        std::cin >> h[i];
    }
    
    std::vector<std::vector<int>> dp(N+1, std::vector<int>(N+1, INT_MAX));
    
    std::vector<int> sum(N+1, 0); // prefix sum of heights
    for(int j = 1; j <= N; j++) {
        sum[j] = sum[j-1] + h[j];
    }
    
    for(int j = 1; j <= N; j++) {
        dp[j][j] = 0; // Cost to create a single peak at column j with the last peak at column j is zero
        for(int i = 1; i < j; i++) {
            int cost = (h[i] <= h[j] && h[j] <= h[i+1]) ? (sum[j-1] - sum[i]) : INT_MAX;
            if(cost != INT_MAX) {
                dp[j][j] = std::min(dp[j][j], dp[i][j-1] + cost);
            }
        }
    }
    
    int minCost = INT_MAX;
    for(int j = 1; j <= N; j++) {
        minCost = std::min(minCost, dp[N][j]);
    }
    
    std::cout << minCost << std::endl;
    
    return 0;
}

Please note that this code includes the necessary input reading code for N and the heights of the columns. Make sure to modify the code accordingly to read the input properly.

I hope this helps! Let me know if you have any further questions.