请你设计一个支持对其元素进行增量操作的栈。
实现自定义栈类 CustomStack ：
CustomStack(int maxSize)：用 maxSize 初始化对象，maxSize 是栈中最多能容纳的元素数量。
void push(int x)：如果栈还未增长到 maxSize ，就将 x 添加到栈顶。
int pop()：弹出栈顶元素，并返回栈顶的值，或栈为空时返回 -1 。
void inc(int k, int val)：栈底的 k 个元素的值都增加 val 。如果栈中元素总数小于 k ，则栈中的所有元素都增加 val 。
示例：
输入：
"CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"
\[3\],\[1\],\[2\],\[\],\[2\],\[3\],\[4\],\[5,100\],\[2,100\],\[\],\[\],\[\],\[\]
输出：
null,null,null,2,null,null,null,null,null,103,202,201,-1
解释：
CustomStack stk = new CustomStack(3); // 栈是空的 []
stk.push(1); // 栈变为 [1]
stk.push(2); // 栈变为 [1, 2]
stk.pop(); // 返回 2 --> 返回栈顶值 2，栈变为 [1]
stk.push(2); // 栈变为 [1, 2]
stk.push(3); // 栈变为 [1, 2, 3]
stk.push(4); // 栈仍然是 [1, 2, 3]，不能添加其他元素使栈大小变为 4
stk.increment(5, 100); // 栈变为 [101, 102, 103]
stk.increment(2, 100); // 栈变为 [201, 202, 103]
stk.pop(); // 返回 103 --> 返回栈顶值 103，栈变为 [201, 202]
stk.pop(); // 返回 202 --> 返回栈顶值 202，栈变为 [201]
stk.pop(); // 返回 201 --> 返回栈顶值 201，栈变为 []
stk.pop(); // 返回 -1 --> 栈为空，返回 -1
提示：
1 <= maxSize, x, k <= 1000
0 <= val <= 100
每种方法 increment，push 以及 pop 分别最多调用 1000 次
模拟栈
cpp
class CustomStack {
public:
vector<int> stk;
int top;
CustomStack(int maxSize) {
stk.resize(maxSize);
top = -1;
}
void push(int x) {
if(top != stk.size()-1){
top++;
stk[top] = x;
}
}
int pop() {
if(top == -1){
return -1;
}
top--;
return stk[top+1];
}
void increment(int k, int val) {
int lim = min(k, top+1);
for(int i = 0; i < lim; i++){
stk[i] += val;
}
}
};时间复杂度：初始化（构造函数）、push 操作和 pop 操作的渐进时间复杂度为 O(1)，inc 操作的渐进时间复杂度为 O(k)。
空间复杂度：这里用到了一个长度为 maxSize 的数组作为辅助空间，渐进空间复杂度为 O(maxSize)。
使用vector来模拟栈的过程，区别在于我们不用真正的推出元素，只需将top--，总体过程相对简单。
使用差分优化(延迟更新)
cpp
class CustomStack {
public:
vector<int> stk, add;
int top;
CustomStack(int maxSize) {
stk.resize(maxSize);
add.resize(maxSize);
top = -1;
}
void push(int x) {
if(top != stk.size()-1){
top++;
stk[top] = x;
}
}
int pop() {
if(top == -1){
return -1;
}
int ans = stk[top] + add[top];
if(top > 0){
add[top-1] += add[top];
}
add[top] = 0;
top--;
return ans;
}
void increment(int k, int val) {
int lim = min(k-1, top);
if(lim >= 0){
add[lim] += val;
}
}
};时间复杂度：所有操作的渐进时间复杂度均为 O(1)。
空间复杂度：这里用到了两个长度为 maxSize 的数组作为辅助空间，渐进空间复杂度为 O(maxSize)。
我们可以发现在increment函数中，我们第一种方法采用的是选择每次调用这个函数，就将前k个值进行增量。那既然都要增量，我们可不可以先统计完增量，然后再需要pop栈顶值的时候，再把增量加给需要pop的元素呢。比如说我们要将前k个数增加100次val，那么就要循环100k次，那么我们可以统计一共前k个数要增加100，那么最后将前k个数都添加100，或许只需要循环k次，甚至更少呢？
所以我们采用延迟更新的思想，将增量储存在一个动态数组add中，在每次计算增量的时候，我们只需要计算add[k-1]的增量（如果k-1小于top的话）。那么我们如何运用add呢，我们会发现我们只有在pop的时候，我们弹出的栈顶元素值时，需要增量和原来的栈顶元素相加。也就是int ans = stk[top] + add[top];。这时候add[top]的增量被使用了，我们就将他传递给add[top-1]，对应代码add[top-1] += add[top];。
举个例子，比如说我们进行了两次increment操作，第一次将前k+1个元素增加val1，也就是add[k]=val1。第二次将前k+3个元素增加了val2，也就是add[k+2]=val2，那么他们共同覆盖的范围是不是前k+1个元素，那么也就是说，前k+1个元素增量是val1+val2，在第k+2到k+3个元素，增量是val2。这时候假设我们进行三次pop()操作，那么stk[k+2] += add[k+2]，然后add[k+2]将增量传给add[k+1]（使用+=），这时候stk[k+1] += add[k+1]，依旧是加上val2。
这时候我们再将add[k+1]传给add[k]，这时候add[k]就是val1+val2，也就是两次increment操作共同覆盖的区域，正好符合我们上面讲到的前k+1个元素的增量是val1+val2。
使用完增量后，记得将add[top]设为0，然后让top--。