A 大地魂力

时间限制 : - MS   空间限制 : - KB 

评测说明 : 1s,256m

问题描述

奶牛贝西认为，要改变世界，就必须吸收大地的力量，贝西把大地的力量称为魂力。要吸取大地的魂力就需要在地上开出洞穴来。
大地可以看成一个数轴，农夫约翰将不断地在大地上的选一个整数点来开一个洞穴，这个洞穴能分别从他左右两边第一个已经开出的洞穴吸取大地之魂力，吸取到的魂力数量等于对应洞穴的坐标。如果某一个方向没有洞穴，那么这个洞穴就无法从这个方向吸收大地之魂力。约翰可以在一个坐标点上开多个洞穴，每次吸收的大地之魂的数量都会累加。
现在按时间先后给出约翰的开洞的操作序列，约翰想知道他一共能吸收多少大地之魂。结果可能很大，你只需要告诉他模10^9+7 之后的结果。

输入格式

一行，5个整数 n, A, B, C, X1。其中n代表操作序列的长度。
由于n比较大，操作序列a将不通过输入数据给出，而是通过下列计算方法：
对于 ，2<=i<=n， Xi = ( A*(Xi-1)2 + B*Xi-1 + C ) mod (109+7)
对于操作序列a，它的第i项ai = (Xi mod n) + 1 1<=i<=n
ai就表示第i次操作打开的洞穴的坐标

输出格式

一个整数，表示计算结果

样例输入

5 2 3 2 3

样例输出

18

提示

操作序列为 4 5 2 3 5
操作1：坐标4位置打洞，吸取魂力0
操作2：坐标5位置打洞，吸取魂力4
操作3：坐标2位置打洞，吸取魂力4
操作4：坐标3位置打洞，吸取魂力6
操作5：坐标5位置打洞，吸取魂力4
总魂力18

n<=6000000 A,B,C,X1<=10^9+7

【题目分析】

对于 a[i]=i 的部分分，答案等于 1+2+……+n-1
对于 n<=1000 的部分分，每次插入之后暴力找前驱后继
对于 n<=100000 的部分分，用 set 维护当前的洞穴集合，每次插入之后用 set 寻找前驱后继
满分做法：把操作序列存起来， 记录下每个坐标点出现的次数， 然后把最后的序列建成链表，
倒着考虑操作，相当于每次删除一个点，直接用链表维护，复杂度 O(n)
/*
操作序列： 7， 2， 10， 9， 4， 9， 10， 4
*/

【参考代码】

#include<cstdio>
#include<cctype> 
#define maxn 6000003
using namespace std;
int n, a, b, c, ans;
int A[maxn], Cnt[maxn];
char buf[1 << 23], *p1 = buf, *p2 = buf, obuf[1 << 23], *O = obuf;  
struct Format {
    int Left, Right;
}List[maxn];
namespace Ironclad_Programming {
    #define R register int
    #define For(i, s, n) for (R i = s; i <= n; ++ i)
    #define ll long long
    #define Getch() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1 ++)
    #define MOD 1000000007
    inline int read() {  
        int x = 0, f = 1; 
        char ch = Getch();  
        while(!isdigit(ch)){if (ch == '-')f = -1; ch = Getch();}  
        while(isdigit(ch))x = x * 10 + (ch ^ 48), ch = Getch();  
        return x * f;  
    }  
    void write(ll x) {  
        if (x > 9) write(x / 10);  
        *O ++ = x % 10 + '0';  
    } 
    void ini() {
        n = read(), a = read(), b = read(), c = read(), A[1] = read();
        For (i, 2, n)
            A[i] = (((ll)a * A[i - 1] % MOD * A[i - 1] % MOD) % MOD + (ll)b * A[i - 1] % MOD + c) % MOD;
        For (i, 1, n) {
            A[i] = A[i] % n + 1;
            ++ Cnt[A[i]];
        }    
    }
    namespace solve {
        int Last = 0;
        void Link() {
            For (i, 1, n)
                if (Cnt[i]) {
                    List[i].Left = Last;
                    List[Last].Right = i;
                    Last = i;
                }
        }
        void Del_Back() {
            for (R i = n; i; -- i) {
                (ans += (List[A[i]].Left + List[A[i]].Right) % MOD) %= MOD;
                if (!(-- Cnt[A[i]])) {
                    List[List[A[i]].Left].Right = List[A[i]].Right;
                    List[List[A[i]].Right].Left = List[A[i]].Left;
                }
            }
        }
        void executive() {
            Link();
            Del_Back();
            write(ans);
        }
    }
    void Main() {
        ini();
        solve::executive();
        fwrite(obuf, O - obuf, 1, stdout);
    }
    #undef R
    #undef For
    #undef ll
    #undef Getch
    #undef MOD
}
int main() {
    Ironclad_Programming::Main();
    return 0;
}