【BZOJ3745】Norma [分治]

Norma

Time Limit: 20 Sec  Memory Limit: 64 MB
[Submit][Status][Discuss]

Description

　　

Input

　　第1行，一个整数N；

　　第2~n+1行，每行一个整数表示序列a。

Output

　　输出答案对10^9取模后的结果。

Sample Input

　　4
　　2
　　4
　　1
　　4

Sample Output

　　109

HINT

　　N <= 500000
　　1 <= a_i <= 10^8

Solution

 \begin {align}
 &基本思路，考虑分治，统计对于左端点在[L,mid]，右端点在[mid+1，R]的区间贡献：\\
 \\
 &枚举在[L, mid]中的点i，[mid+1,R]中的点a、b，\\
 &保证min[i,mid]≤min[mid+1,a]\\
 &并且max[i,mid]≥max[mid+1,b] \\
 &然后[mid+1,R]就被分成了三部分：[mid+1,a],[a+1,b],[b+1,R]，(假设a<b)，\\
 \\
 &我们考虑分别对三个部分计算贡献：(max=max[i,mid], min=min[i,mid])\\
 &①.[mid+1,a]:Ans=max*min*\sum_{j=mid+1}^{a}(j-i+1) \\
 &②.[a+1,b]:Ans=max*\sum_{j=a+1}^{b}(min[a+1,j]*(j-i+1)) \\
 &③.[b+1,R]:Ans=\sum_{j=b+1}^{R}( max[b+1,j]*min[b+1,j]*(j-i+1)) \\
 \\
 &这时候，显然①可求了。我们继续推导(把(j-i+1)拆开)，显然有：\\
 &②=max*\sum_{j=a+1}^{b}min[a+1,j]*j-max*\sum_{j=a+1}^{b}min[a+1,j]*(i-1)\\
 &③=\sum_{j=b+1}^{R}max[b+1,j]*min[b+1,j]*j-\sum_{j=b+1}^{R}max[b+1,j]*min[b+1,j]*(i-1)\\
 \\
 &显然此时②中的\sum_{j=a+1}^{b}min[a+1,j]*j、\sum_{j=a+1}^{b}min[a+1,j]是可以O(len)预处理的，\\
 &③中的\sum_{j=b+1}^{R}max[b+1,j]*min[b+1,j]*j、\sum_{j=b+1}^{R}max[b+1,j]*min[b+1,j]也可以O(len)预处理。\\
 \\
 &显然，若b<a类似。所以我们分治一下即可。\\
 \\
 &\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:\:——BearChild

 \end {align}

BZOJ3745.md

　　

Code

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 using namespace std;
 typedef long long s64;

 const int ONE = ;
 const int MOD = 1e9;
 const int INF = ;

 int get()
 {
         int res = , Q = ; char c;
         while( (c = getchar()) <  || c > )
             if(c == '-') Q = -;
         if(Q) res = c - ;
         while( (c = getchar()) >=  && c <= )
             res = res *  + c - ;
         return res * Q;
 }

 int n;
 int val[ONE];
 int Ans;

 void Modit(int &a)
 {
         if(a < ) a += MOD;
         if(a >= MOD) a -= MOD;
 }

 struct power
 {
         int Min, MinI;
         int Max, MaxI;
         int MinMax, MinMaxI;

         friend power operator -(power a, power b)
         {
             power c;
             Modit(c.Min = a.Min - b.Min),
             Modit(c.MinI = a.MinI - b.MinI),
             Modit(c.Max = a.Max - b.Max),
             Modit(c.MaxI = a.MaxI - b.MaxI),
             Modit(c.MinMax = a.MinMax - b.MinMax),
             Modit(c.MinMaxI = a.MinMaxI - b.MinMaxI);
             return c;
         }
 }A[ONE];

 int Sum(int a, int b)
 {
         return (s64)(a + b) * (b - a + ) /  % MOD;
 }

 void Solve(int L, int R)
 {
         if(L == R)
         {
             Modit(Ans += (s64)val[L] * val[R] % MOD * );
             return;
         }

         int mid = L + R >> ;

         int minn = INF, maxx = -INF;
         A[mid] = (power){, , , , , };

         for(int j = mid + ; j <= R; j++)
         {
             minn = min(minn, val[j]), maxx = max(maxx, val[j]),
             Modit(A[j].Min = A[j - ].Min + minn),
             Modit(A[j].MinI = A[j - ].MinI + (s64)minn * j % MOD),
             Modit(A[j].Max = A[j - ].Max + maxx),
             Modit(A[j].MaxI = A[j - ].MaxI + (s64)maxx * j % MOD),
             Modit(A[j].MinMax = A[j - ].MinMax + (s64)minn * maxx % MOD),
             Modit(A[j].MinMaxI = A[j - ].MinMaxI + (s64)minn * maxx % MOD * j % MOD);
         }

         minn = INF, maxx = -INF;
         int a = mid, b = mid;
         power del;

         for(int i = mid; i >= L; i--)
         {
             minn = min(minn, val[i]), maxx = max(maxx, val[i]);
             while(minn <= val[a + ] && a +  <= R) a++;
             while(maxx >= val[b + ] && b +  <= R) b++;
             if(a <= b)
             {
                 Modit(Ans += (s64)maxx * minn % MOD * Sum(mid +  - i + , a - i + ) % MOD);
                 del = A[b] - A[a];
                 Modit(Ans += (s64)maxx * del.MinI % MOD - (s64)maxx * del.Min % MOD * (i - ) % MOD);
                 del = A[R] - A[b];
                 Modit(Ans += (s64)del.MinMaxI - (s64)del.MinMax * (i - ) % MOD);
             }
             else
             {
                 Modit(Ans += (s64)maxx * minn % MOD * Sum(mid +  - i + , b - i + ) % MOD);
                 del = A[a] - A[b];
                 Modit(Ans += (s64)minn * del.MaxI % MOD - (s64)minn * del.Max % MOD * (i - ) % MOD);
                 del = A[R] - A[a];
                 Modit(Ans += (s64)del.MinMaxI - (s64)del.MinMax * (i - ) % MOD);
             }
         }

         Solve(L, mid), Solve(mid + , R);

 }

 int main()
 {
         n = get();
         for(int i = ; i <= n; i++)
             val[i] = get();
         Solve(, n);
         printf("%d", Ans);
 }