单增栈 维护 子数组最小值 左右边界
lc2281
单调栈+前缀和的前缀和+贡献法
计算数组中所有连续子数组的总力量和：每个子数组的总力量 = 子数组里的最小值 × 子数组的元素和，最后把++所有子数组的总力量相加++
单增栈确定++每个元素作为子数组最小值的左右边界++
结合++前缀和的前缀和快速计算子数组强度总和++
最终累加所有元素的贡献得到结果并取模
class Solution {
public:
int totalStrength(vector<int>& strength)
{
const int MOD = 1'000'000'007;
int n = strength.size();
vector<int> left(n, -1);
vector<int> right(n, n);
stack<int> st;
st.push(-1); // 哨兵，方便计算 left[i]
for (int i = 0; i < n; i++) {
while (st.size() > 1 && ++strength[st.top()] >= strength[i]) {
right[st.top()] = i;++
st.pop();
}
left[i] = st.top();
st.push(i);
}
////////////////////////
long long s = 0; // 前缀和
vector<int> ss(n + 2); // 前缀和的前缀和
for (int i = 1; i <= n; i++) {
s += strength[i - 1];
ss[i + 1] = (ss[i] + s) % MOD;
// 子数组 元素和的元素和
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long l = left[i] + 1, r = right[i] - 1; // [l,r] 左闭右闭
++long long tot = ((i - l + 1) * (ss[r + 2] - ss[i + 1]) - (r - i + 1) * (ss[i + 1] - ss[l])) % MOD;++
ans = (ans + strength[i] * tot) % MOD; // 累加贡献
}
return (ans + MOD) % MOD;
}
};
lc2290
0-1 BFS，双端队列处理网格移动代价
无障碍（代价0）节点入队首、有障碍（代价1）节点入队尾
求解从网格起点到终点的最小障碍移除数量
喵喵dj版(遇到0就addFirst，优先走短路，0-1BFS通过可插双端队列的队首省了优先队列的排序log，极大地优化了时间复杂度
++if (dis[i][j] + g < dis[x][y])++
dis[x][y] = dis[i][j] + g; //update
++g == 0 ? q.emplace_front(x, y) : q.emplace_back(x, y);++
class Solution {
static constexpr int DIRS[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
public:
int minimumObstacles(vector<vector<int>> &grid) {
int m = grid.size(), n = grid[0].size();
vector<vector<int>> dis(m, vector<int>(n, INT_MAX));
dis[0][0] = 0;
deque<pair<int, int>> q;
q.emplace_front(0, 0);
while (!q.empty()) {
auto [i, j] = q.front();
q.pop_front();
for (auto& [dx, dy] : DIRS) {
int x = i + dx, y = j + dy;
if (0 <= x && x < m && 0 <= y && y < n) {
int g = grid[x][y];
++if (dis[i][j] + g < dis[x][y]) {++
dis[x][y] = dis[i][j] + g; //update
++g == 0 ? q.emplace_front(x, y) : q.emplace_back(x, y);++
}
}
}
}
return dis[m - 1][n - 1];
}
};
计算新路径的障碍代价，++若新代价更小则更新最短障碍数++
最后根据位置是否为障碍，将节点分别插入双端队列的队首（空地）或队尾（障碍），以此实现0-1 BFS的核心逻辑