CodeChef - COUNTARI FTT+分块

Arithmetic Progressions

Given N integers A₁, A₂, …. A_N, Dexter wants to know how many ways he can choose three numbers such that they are three consecutive terms of an arithmetic progression.

Meaning that, how many triplets (i, j, k) are there such that 1 ≤ i < j < k ≤ Nand A_j - A_i = A_k - A_j.

So the triplets (2, 5, 8), (10, 8, 6), (3, 3, 3) are valid as they are three consecutive terms of an arithmetic
progression. But the triplets (2, 5, 7), (10, 6, 8) are not.

Input

First line of the input contains an integer N (3 ≤ N ≤ 100000). Then the following line contains N space separated integers A₁, A₂, …, A_N and they have values between 1 and 30000 (inclusive).

Output

Output the number of ways to choose a triplet such that they are three consecutive terms of an arithmetic progression.

Example

Input:
10
3 5 3 6 3 4 10 4 5 2

Output:
9

Explanation

The followings are all 9 ways to choose a triplet

1 : (i, j, k) = (1, 3, 5), (Ai, Aj, Ak) = (3, 3, 3)
2 : (i, j, k) = (1, 6, 9), (Ai, Aj, Ak) = (3, 4, 5)
3 : (i, j, k) = (1, 8, 9), (Ai, Aj, Ak) = (3, 4, 5)
4 : (i, j, k) = (3, 6, 9), (Ai, Aj, Ak) = (3, 4, 5)
5 : (i, j, k) = (3, 8, 9), (Ai, Aj, Ak) = (3, 4, 5)
6 : (i, j, k) = (4, 6, 10), (Ai, Aj, Ak) = (6, 4, 2)
7 : (i, j, k) = (4, 8, 10), (Ai, Aj, Ak) = (6, 4, 2)
8 : (i, j, k) = (5, 6, 9), (Ai, Aj, Ak) = (3, 4, 5)
9 : (i, j, k) = (5, 8, 9), (Ai, Aj, Ak) = (3, 4, 5)

题解：

　　　　考虑分块，分成block块

　　　　假设三个点都在同一块，那么我们就在一块内暴力，复杂度block * ( n/block)  * (n/block)

　　　　假设其中两个点在同一块，那么枚举其中一块的两个点算答案，block * n/block * n/block

　　·　　假设三个点都不在同一块，枚举中间点属于的那一块 剩下左边和右边进行 FFT， 复杂度block * （n*logn）

　　　　

#include<bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
#define ls i<<1
#define rs ls | 1
#define mid ((ll+rr)>>1)
#define pii pair<int,int>
#define MP make_pair
typedef long long LL;
typedef unsigned long long ULL;
const long long INF = 1e18+1LL;
const double pi = acos(-1.0);
const int N = 3e5+, M = 1e6+, mod = 1e9+,inf = 2e9;

struct Complex {
    double r , i ;
    Complex () {}
    Complex ( double r , double i ) : r ( r ) , i ( i ) {}
    Complex operator + ( const Complex& t ) const {
        return Complex ( r + t.r , i + t.i ) ;
    }
    Complex operator - ( const Complex& t ) const {
        return Complex ( r - t.r , i - t.i ) ;
    }
    Complex operator * ( const Complex& t ) const {
        return Complex ( r * t.r - i * t.i , r * t.i + i * t.r ) ;
    }
} ;

void FFT ( Complex y[] , int n , int rev ) {
    for ( int i =  , j , t , k ; i < n ; ++ i ) {
        for ( j =  , t = i , k = n >>  ; k ; k >>=  , t >>=  ) j = j <<  | t &  ;
        if ( i < j ) swap ( y[i] , y[j] ) ;
    }
    for ( int s =  , ds =  ; s <= n ; ds = s , s <<=  ) {
        Complex wn = Complex ( cos ( rev *  * pi / s ) , sin ( rev *  * pi / s ) ) , w (  ,  ) , t ;
        for ( int k =  ; k < ds ; ++ k , w = w * wn ) {
            for ( int i = k ; i < n ; i += s ) {
                y[i + ds] = y[i] - ( t = w * y[i + ds] ) ;
                y[i] = y[i] + t ;
            }
        }
    }
    if ( rev == - ) for ( int i =  ; i < n ; ++ i ) y[i].r /= n ;
}
Complex s[N],t[N];

LL cnt[][];
int a[N];
int n,block,pos[N];
LL vis[N];
int main() {
    while(scanf("%d",&n)!=EOF) {
        block = ;
        for(int i = ; i <= n; ++i)
            pos[i] = (i-)/block + ;
        int mx = -;
        for(int i = ; i <= pos[n]; ++i)
        for(int j = ; j <= ; ++j) cnt[i][j] = ;
        for(int i = ; i <= n; ++i) {
            scanf("%d",&a[i]);
            mx = max(mx,a[i]);
            cnt[pos[i]][a[i]]++;
        }

        for(int i = ; i <= mx; ++i) {
            for(int j = ; j <= pos[n]; ++j) {
                cnt[j][i] += cnt[j-][i];
            }
        }
        int len = ;
        while(len <= *mx) len<<=;
        LL ans = ;
        for(int k = ; k <= pos[n]; ++k) {
            for(int i = (k-)*block + ; i <= min(k*block,n); ++i) {
                for(int j = i + ; j <= min(k*block,n); ++j) {
                    if(*a[i] - a[j] >=  && *a[i] - a[j] <= mx)
                        ans += cnt[k-][*a[i] - a[j]] + vis[*a[i]-a[j]];
                    if(*a[j] - a[i] >=  &&  *a[j] - a[i] <= mx)
                        ans += cnt[pos[n]][*a[j] - a[i]] - cnt[k][*a[j] - a[i]];
                }
                vis[a[i]] += ;
            }
            for(int i = (k-)*block + ; i <= min(k*block,n); ++i) {
                vis[a[i]] = ;
            }

            for(int j = ; j <= mx; ++j)
                s[j] = Complex(cnt[k-][j],);
            for(int j = mx+; j < len; ++j) s[j] = Complex(,);

            for(int j = ; j <= mx; ++j)
                t[j] = Complex(cnt[pos[n]][j] - cnt[k][j] , );
            for(int j = mx+; j < len; ++j) t[j] = Complex(,);

            FFT(s,len,);FFT(t,len,);
            for(int j = ; j < len; ++j) s[j] = s[j] * t[j];
            FFT(s,len,-);

            for(int j = ; j <= mx; ++j) {
                LL tmp = (LL)(s[*j].r + 0.5);
                ans += tmp*(cnt[k][j] - cnt[k-][j]);
            }
        }
        printf("%lld\n",ans);

    }
    return ;
}