Codeforces Round #441(Div.2) F High Cry

F. High Cry

time limit per test: 1 second

memory limit per test: 512 megabytes

Disclaimer: there are lots of untranslateable puns in the Russian version of the statement, so there is one more reason for you to learn Russian :)

Rick and Morty like to go to the ridge High Cry for crying loudly — there is an extraordinary echo. Recently they discovered an interesting acoustic characteristic of this ridge: if Rick and Morty begin crying simultaneously from different mountains, their cry would be heard between these mountains up to the height equal the bitwise OR of mountains they've climbed and all the mountains between them.

Bitwise OR is a binary operation which is determined the following way. Consider representation of numbers x and y in binary numeric system (probably with leading zeroes) x = x_k... x₁x₀ and y = y_k... y₁y₀. Then z = x | y is defined following way: z = z_k... z₁z₀, where z_i = 1, if x_i = 1 or y_i = 1, and z_i = 0 otherwise. In the other words, digit of bitwise OR of two numbers equals zero if and only if digits at corresponding positions is both numbers equals zero. For example bitwise OR of numbers 10 = 1010₂ and 9 = 1001₂ equals 11 = 1011₂. In programming languages C/C++/Java/Python this operation is defined as «|», and in Pascal as «or».

Help Rick and Morty calculate the number of ways they can select two mountains in such a way that if they start crying from these mountains their cry will be heard above these mountains and all mountains between them. More formally you should find number of pairs l and r (1 ≤ l < r ≤ n) such that bitwise OR of heights of all mountains between l and r (inclusive) is larger than the height of any mountain at this interval.

Input

The first line contains integer n (1 ≤ n ≤ 200 000), the number of mountains in the ridge.

Second line contains n integers a_i (0 ≤ a_i ≤ 10⁹), the heights of mountains in order they are located in the ridge.

Output

Print the only integer, the number of ways to choose two different mountains.

统计或和>=最大值的区间数；

考虑计算每个数最为最大值时的贡献，因此需要计算满足“该数作为最大值”的区间和满足“或和>=该数”的区间；

第一类区间可以单调栈维护，注意两端点只有一端考虑边界数与选定数相等；

第二类区间，考虑按位计算，注意到对于选定数的任意 0 位，只要区间内任意数该位为 1 即为合法区间；

所以按位拆分后可以转成类似最小全 0 子矩形的问题，用悬线法解决；

然后两类区间容斥一下就行了；

AC GET☆DAZE

 

↓代码

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<queue>
#include<ctime>
#include<map>
#include<set>
#define N 200039
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;
ll num[N],L[N],R[N],l[39][N],r[39][N];
ll sta[N],h,ans;
int main()
{
    ll n,stp,a,b,c;
    scanf("%lld",&n);
    for(a=1;a<=n;a++)
    {
        scanf("%lld",&num[a]);
    }
    for(a=1,h=0,sta[0]=0;a<=n;a++)
    {
        while(num[a]>=num[sta[h]] && h)
        {
            h--;
        }
        L[a]=sta[h],sta[++h]=a;
    }
    for(a=n,h=0,sta[h]=n+1;a>=1;a--)
    {
        while(num[a]>num[sta[h]] && h)
        {
            h--;
        }
        R[a]=sta[h],sta[++h]=a;
    }
    for(a=0;a<30;a++)
    {
        l[a][1]=stp=1;
        for(b=2;b<=n;b++)
        {
            if(((1<<a)&num[b-1])>=1 && ((1<<a)&num[b])==0)
            {
                stp=b;
            }
            if(((1<<a)&num[b])==0)
            {
                l[a][b]=stp;
            }
            else
            {
                l[a][b]=1;
            }
        }
        r[a][n]=stp=n;
        for(b=n-1;b>=1;b--)
        {
            if(((1<<a)&num[b+1])>=1 && ((1<<a)&num[b])==0)
            {
                stp=b;
            }
            if(((1<<a)&num[b])==0)
            {
                r[a][b]=stp;
            }
            else
            {
                r[a][b]=n;
            }
        }
        for(b=1;b<=n && a;b++)
        {
            l[a][b]=max(l[a][b],l[a-1][b]);
            r[a][b]=min(r[a][b],r[a-1][b]);
        }
    }
    for(a=1;a<=n;a++)
    {
        if(l[29][a]-L[a]>1)
        {
            ans+=(R[a]-a)*(l[29][a]-L[a]-1);
        }
        if(R[a]-r[29][a]>1)
        {
            ans+=(a-L[a])*(R[a]-r[29][a]-1);
        }
        if(l[29][a]-L[a]>1 && R[a]-r[29][a]>1)
        {
            ans-=(l[29][a]-L[a]-1)*(R[a]-r[29][a]-1);
        }
    }
    printf("%lld",ans);
    return 0;
}