woj 1575

戳这里：1575

题意：直线上排列着N个信号发射器，每个信号发射器被激活后将会使得影响范围内的所有发射器都被激活。询问激活任意一个发射器后被激活的发射器数最大是多少。

官方题解：可能会存在环的情况，考虑按坐标排序后i < j < k，j激活了k，然后k再激活i。但是这样可以转化为直接激活k的方案。所以无影响。 于是可以用dp求解。dp[i] = max( dp[j] + 1 )， position[j] + R[i] >= position[i]，用单调队列优化时间复杂度为O(n)。 向左右分别dp一遍。最后统计答案的最大值。

也是当时 whu 邀请赛现场没做出来的一道题。回来看了看题解，感觉题解并没有考虑到所有情况，比如 在第 i 个信号发射器左边有两坨互不影响的信号发射器群，且第 i 个信号发射器的影响范围能够覆盖到这两坨时，此时如果直接用单调队列优化，则只能选取两坨中信号发射器最多的一坨作为构成最优解的前驱（实际上应该两坨都选才对）

感觉题解无法解决这种情况，于是乎我就开始瞎搞...期间 WA 了几发，最后一次交之前感觉没有 AC 可能性了，但是把瞎搞的代码交上去后竟然 AC 了了了了了......!!!

我的做法是：尽可能的延长信号发射器的影响范围，延长标准是其它 完全覆盖了该信号发射器的影响范围的信号发射器（的影响范围），这样就能让左边有两坨互不影响的信号发射器群合为一坨，dp[ i ] 就好办了

#include "bits/stdc++.h"
using namespace std;
//dp[i] = max(dp[j] + 1);
int N;
long long pos[1000010];
int r[1000010], r_1[1000010], r_2[1000010];
int dp_1[1000010], dp_2[1000010];

struct
{
    long long index;
    int value;
}q[1000010], tmp;
int front, rear;

int main()
{
    while(scanf("%d", &N) != EOF) {
        //初始化
        memset(dp_1, 0, sizeof(int) * (N + 1));
        memset(dp_2, 0, sizeof(int) * (N + 1));
        int i, x;
        //输入
        int MostLongRadius = 0;
        for(i = 1; i <= N; ++i) {
            scanf("%d%d", &x, &r[i]);
            MostLongRadius -= x;
            r_2[i] = max(r[i], MostLongRadius);
            MostLongRadius = r_2[i];
            pos[i] = pos[i - 1] + x;
        }
        MostLongRadius = r[N];
        for(i = N - 1; i >= 1; --i) {
            MostLongRadius -= (pos[i + 1] - pos[i]);
            r_1[i] = max(r[i], MostLongRadius);
            MostLongRadius = r_1[i];
        }
        //预处理出因为没有前驱而不能进行单调队列优化的状态
        dp_1[1] = 0;
        //从有前驱的状态开始 dp
        front = rear = 1;
        for(i = 2; i <= N; ++i) {
            tmp.value = dp_1[i - 1];
            tmp.index = pos[i - 1];
            for( ; front < rear && tmp.value > q[rear - 1].value; --rear);
            q[rear++] = tmp;
            for( ; front < rear && pos[i] - tmp.index > r_1[i]; ++front);
            if(front != rear) {
                dp_1[i] = q[front].value + 1;
            }
            else {
                dp_1[i] = 0;
            }
        }
        int res = 0;
        //预处理出因为没有前驱而不能进行单调队列优化的状态
        dp_2[N] = 0;
        //从有前驱的状态开始 dp
        front = rear = 1;
        for(i = N - 1; i >= 1; --i) {
            tmp.value = dp_2[i + 1];
            tmp.index = pos[i + 1];
            for( ; front < rear && tmp.value > q[rear - 1].value; --rear);
            q[rear++] = tmp;
            for( ; front < rear && tmp.index - pos[i] > r_2[i]; ++front);
            if(front != rear) {
                dp_2[i] = q[front].value + 1;
            }
            else {
                dp_2[i] = 0;
            }
            res = max(res, dp_1[i] + dp_2[i] + 1);
        }
        printf("%d
", res);
    }
}