单调队列与单调栈

1.单调队列

RMQ（Range Minimum/Maximum Query）问题，是求区间最大值或最小值，即范围最值问题

定义：队内元素保持单调性的队列，队首元素永远是最小值或最大值。

操作：

• ⼊队操作： 队尾⼊队，会把之前破坏单调性的元素都从队尾移出（维护单调性）
• 出队操作： 如果队首元素超出区间范围，就将元素从队首出队
• 元素性质： 队首元素，永远是当前维护区间的（最⼤/最小）值序列中的每⼀个元素，在依次⼊队的过程中，每个元素都入队和出队过

适用问题：

1.滑动窗口的最大/最小值维护

• 队列单调递增，队首元素维护区间的最小值
• 队列单调递减，队首元素维护区间的最大值

代码

void output( vector < int >& arr ) {

    int n = arr .size(), len = 0;

    for ( int i = 0; i < n; i++) {

        len += printf( "%3d" , i);

    }

    printf( "\n" );

    for ( int i = 0; i < len; i++) printf( "-" );

    printf( "\n" );

    for ( int i = 0; i < n; i++) {

        len += printf( "%3d" , arr [ i ] );

    }

    printf( "\n" );

    return ;

}

int main() {

    //k是滑动窗口的长度

    int n, k;

    cin >> k >> n;

    vector < int > arr;

    deque < int > q;

    for ( int i = 0, a; i < n; i++) {

        cin >> a;

        arr.push_back(a);

    }

    output(arr);

    for ( int i = 0; i < n; i++) {

        //违反了单调队列的单调性，从队尾出队

        while (!q.empty() && arr [ q.back() ] > arr [ i ] )q.pop_back();

        q.push_back(i);

        //超过区间->队首出队

        if (i - q.front() == k)q.pop_front();

        printf( "[%d , %d] = arr[%d] = %d\n" ,

            max(i - k + 1, 0), i,

            q.front(), arr [ q.front() ]

        );

    }

    return 0;

}

2.单调栈

定义：栈内元素保持单调性的栈。

操作：

• 入栈：每个元素都要入栈
• 出栈：当要入栈的元素违反了单调栈的单调性，则先将栈顶元素出栈，维护栈的单调性，再入栈
• 单调性与最近关系：单调递增：最近小于关系 单调递减：最近大于关系

适用问题：

1.数组元素的最近大于/小于的求解

• 从数组左侧先入栈，求解数组元素右侧的最近大于/小于关系
• 从数组右侧先入栈，求解数组元素左侧的最近大于/小于关系

代码

void output( vector < int >& arr ) {

    int n = arr .size(), len = 0;

    for ( int i = 0; i < n; i++) {

        len += printf( "%3d" , i);

    }

    printf( "\n" );

    for ( int i = 0; i < len; i++) printf( "-" );

    printf( "\n" );

    for ( int i = 0; i < n; i++) {

        len += printf( "%3d" , arr [ i ] );

    }

    printf( "\n" );

    return ;

}

int main() {

    int n;

    cin >> n;

    vector < int > arr;

    stack < int > s;

    //求最近大于关系，数组两端放入最大值

    //求最近小于关系，数组两端放入最小值

    arr.push_back(-1);

    for ( int i = 0, a; i < n; i++) {

        cin >> a;

        arr.push_back(a);

    }

    arr.push_back(-1);

    //保存左右侧最近大于/小于的值的位置

    vector < int > l(arr.size() + 1), r(arr.size() + 1);

    output(arr);

    //right

    for ( int i = 0, I = arr.size(); i < I; i++) {

        //单调递增栈

        while (!s.empty() && arr [ s.top() ] > arr [ i ] ) {

            r [ s.top() ] = i;

            s.pop();

        }

        s.push(i);

    }

    //left

    while (!s.empty()) s.pop();

    for ( int i = arr.size() - 1; i >= 0; i--) {

        //单调递增栈

        while (!s.empty() && arr [ s.top() ] > arr [ i ] ) {

            l [ s.top() ] = i;

            s.pop();

        }

        s.push(i);

    }

    // output result

    for ( int i = 1; i <= n; i++) {

        printf( "arr[%d] = %d, right : arr[%d] = %d, left : arr[%d] = %d\n" ,

            i, arr [ i ] ,

            r [ i ] , arr [ r [ i ]] ,

            l [ i ] , arr [ l [ i ]]

        );

    }

    return 0;

}