超级码力在线编程大赛初赛 第1场 3.大楼间穿梭 单调栈，DP

超级码力在线编程大赛初赛 第1场 3.大楼间穿梭 单调栈，DP

题意

一座城市有(n) 座高楼在城市的水平线上，楼高(h[i]) 。蜘蛛侠要从第一座楼开始到第(n) 座楼，蜘蛛侠有两种选择

• 花费(x) ,选择跳到第(i+1) 或者第(i+2) 座楼
• 花费(y) ,选择跳到接下来的(k) 座楼中，第一个不小于当前楼的楼

问最小的花费

分析

很明显是简单的决策型(dp) ，(dp[i]) 表示从第(i)座楼开始跳到第(n) 座楼的最小花费，很容易写出转移方程

[dp[i] = min(min(dp[i+1],dp[i+2])+x),dp[pos]+y) ]

所以问题变成了怎么快速计算出(pos) ，相当于快速计算出数组中第一个比当前大的位置，很明显可以用单调栈的性质预处理出(next) 数组，具体只需维护一个单调递减的单调栈。

(dp) 过程可以用记忆化搜索实现，提交了一直(wa) ,后来发现初始化(dp) 数组不能用(0)

代码

ll dp[100005];
int nxt[100005];

class Solution {
public:
    void init(vector<int>& h) {
        stack<int> st;
        for (int i = 0; i < h.size(); i++) nxt[i] = 1e8 + 5, dp[i] = 1e16;
        for (int i = 0; i < h.size(); i++) {
            while (!st.empty() && h[i] >= h[st.top()]) {
                nxt[st.top()] = i;
                st.pop();
            }
            st.push(i);
        }
    }
    ll dfs(int cur, int k, int x, int y, vector<int>& h) {
        if (cur == h.size() - 1) return 0;
        else if (cur >= h.size()) return 1e18;
        if (dp[cur] != 1e16) return dp[cur];
        ll res1 = min(dfs(cur + 1, k, x, y, h), dfs(cur + 2, k, x, y, h)) + y;
        ll res2 = 1e16;
        int pos = nxt[cur];
        if (pos - cur <= k && pos <= h.size() - 1)  res2 = dfs(pos, k, x, y, h) + x;
        return dp[cur] = min(res1, res2);
    }
    long long shuttleInBuildings(vector<int>& heights, int k, int x, int y) {
        init(heights);
        return dfs(0, k, x, y, heights);
    }
};