题面
一个数组B，如果有其中一个元素出现的次数大于length(B) div 2，那么该元素就是数组B的主元素，显然数组B最多只有1个主元素,因为数组B有主元素，所以被称为“优美的”。
给出数组A[0..n-1]，问数组A有多少个“优美的”子数组。数组A的子数组是由数组A的连续若干个元素构成的数组。数组A不是直接给出的，而是通过如下公式自动产生的：
for i = 0 to n-1 do
{
A[i] = (seed div 2^16) % m
seed = (seed * 1103515245 + 12345) % 2^31
}
如上公式中: n, seed, m都是输入数据给出的，div是表示整数的整除。^是表示幂运算。
输入格式:
一行，3个整数，n, seed, m。1 <= n <= 100000。 0 <= seed <= 2^31-1。 1 <= m <= 50。
输出格式
一个整数。
样例
输入样例1
5 200 5
输出样例1
8
输入样例2
10 15 3
输出样例2
23
输入样例3
8 12345678 1
输出样例3
36
输入样例4
27 541 50
输出样例4
27
1s,256MB
思路
由题目可以发现主元素在每一个子数组里只有一个。并且m很小，这说明了生成出的A[i]最大值只有m-1那么大。
m最多只有50，所以我们可以枚举每一个元素作为主元素在A数组中出现了多少次，然后最后累加一下答案就ok了。
那么现在问题来的，如何计算一个元素为主元素在A数组用出现了多少次。
不妨设钦定的主元素是x
我们简单地做一个差分，把a[i]==x的位置都设为1，不然就设为-1，然后做出来一个差分数组。
不如举个例子：
a[i]={0,0,1,2,0}
钦定主元素：x=0
那么做出的差分数组：
1 1 -1 -1 1
b[i]={1,2,1,0,1}
那么这个差分数组是什么意思呢？不难发现，如果我们要查询区间[1,3]中的主元素是不是x。将b[3]-b[1-1]就得出了1，这个1的意思是区间[1,3]中（x的个数）与（不是x的个数）的差。明显，如果这个差大于0，就说明这个区间是主元素为x的区间。
那么我们知道这个差分数组的特性了，可以思考，我们枚举这个区间的开头i，那么可不可以快速算出有多少B数组的值与b[i-1]的大于0。
这时候就有了一个办法：我们维护一个可以支持查询kth的数据结构，然后每次直接区间查询[i+1,n]大于b[i-1]的数有多少。时间复杂度为O(nmlog(n))，而且特别难写。那么有没有什么办法可以转换成简单一点的呢？
第一层转换
前面说了，我们要查询大于b[i-1]的数有多少，那么我们可以把B数组的值域都记下来，为vis数组，那么上面样例的vis数组为
vis[0]=1;
vis[1]=3;
vis[2]=1;
同时做一个后缀和 sum数组：
sum[0]=5;
sum[1]=4;
sum[2]=1;
不难发现其实我们查询的大于b[i-1]的数有多少就是，sum[b[i-1]+1]。就不需要查询kth了。
但还有个问题，我们查询完sum数组，开头i往下一个跳，区间就少了一个b[i]，vis[b[i]]要减1，自然，sum数组从开头到b[i]都要减1。
即当i=2时，vis数组应该是这样的
vis[0]=1;
vis[1]=2;
vis[2]=1;
sum数组应该是这样的
sum[0]=4;
sum[1]=3;
sum[2]=1;
这个问题很好解决，我们可以开一个树状数组来维护，每次查询(b[i-1]+1)的值，然后将1至b[i]都减1。
初始化树状数组tree[i]=sum[i]
时间复杂度:O(nmlog(n))，但代码好些了很多。下面会将第二层优化，时间复杂度将优化成O(nm)，是在这个方法的基础上优化的，希望大家先理解这个方法。
代码实现的一些说明：
1、首先，我们写的时候要加上偏移值，因为vis数组下标有可能是负数
2、我实现中的zz的意思是一个指针，指向b[i-1]+1的值，因为我们发现每一次开头i的变化，b[i-1]到b[i]只有可能加1或减1，因为差分数组的特殊性。所以这个(b[i-1]+1)我就用了一个指针来维护。
例如：刚开始b[1-1]为0，zz指向0，a[1]为x，那么b[2-1]就会为1，那么zz就加1，指向1。如果a[2]不为x，那么b[3-1]就会为0，那么zz就减1，指向0。
代码：
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define maxn 400001
const int pyz=100501;
int a[maxn],vis[maxn],b[maxn],sum[maxn],ans,tree[maxn];
int n,SEED,m,Ans;
inline int lowbit(int x)
{return x&-x;}
inline void generate(int n,int SEED,int m){ //生成A数组
for(int i=1;i<=n;i++){
a[i]=(SEED/65536ll)%m;
SEED=(SEED*1103515245ll+12345ll)%2147483648ll;
}
}
inline void add(int p,int val){
while(p<maxn){
tree[p]+=val;
p+=lowbit(p);
}
}
inline void add_(int x,int y,int sum){
add(x,+sum);
add(y+1,-sum);
}
inline int sum_(int p){
ans=0;
while(p!=0){
ans+=tree[p];
p-=lowbit(p);
}
return ans;
}
inline int solve(int x){
b[0]=0;long long ans=0,zz=pyz,begin=0,t,sum=0; //记得要加上偏移值，负数数组存不了
memset(tree,0,sizeof(tree));
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;++i){
if(a[i]==x)b[i]=b[i-1]+1; //计算b数组
else b[i]=b[i-1]-1;
vis[b[i]+pyz]++; //计算vis数组
}
for(int i=pyz*2;i>=1;--i){
sum+=vis[i]; //计算sum数组，后缀和
add_(i,i,sum); //同时更新树状数组tree数组
}
for(int i=1;i<=n;++i){
t=sum_(zz+1); //大于所以要加1
if(a[i]==x)zz++;else zz--; //更改指针的值
ans+=t;add_(1,zz,-1); //更新值
}
return ans;
}
signed main(){
freopen("2828.in","r",stdin);
freopen("2828.out","w",stdout);
scanf("%lld%lld%lld",&n,&SEED,&m);
generate(n,SEED,m);
for(int i=0;i<m;i++){
Ans+=solve(i);
}
printf("%lld
",Ans);
return 0;
}
脸黑，常数大，别人O(nmlog(n))都过了，就我只有73分，不过这也激发了我探究O(nm)复杂度的决心。
第二层优化 时间复杂度O(nm)
辣么，我们现在来讲终究算法，不仅好写，时间复杂度还优。
我们现在来分析树状数组的做法，我们发现每一次指针跳只会一个一个跳，所以实际上树状数组改的很多地方都没有用，可能根本不会查询那里，所以这就导致了时间上的浪费。
既然指针只会一个一个跳，那么我们可以不用树状数组来维护，我们打标记tag，跳到哪，更新到哪。
打tag的方式也很简单，修改自身值的同时，把tag传的下一个去，自身清0。
if(tag[zz]>0)sum[zz]-=tag[zz],tag[zz-1]+=tag[zz],tag[zz]=0;
是不是简单到爆炸！！！
这样通过指针的特殊性，我们把那个log的时间复杂度给省掉了，时间复杂度降为O(nm)。
代码：
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define maxn 200011
const int pyz=100001;
int a[maxn],vis[maxn],b[maxn],sum[maxn],ans,tree[maxn],tag[maxn];
int n,SEED,m,Ans;
inline void generate(int n,int SEED,int m){
for(int i=1;i<=n;i++){
a[i]=(SEED/65536ll)%m;
SEED=(SEED*1103515245ll+12345ll)%2147483648ll;
}
}
inline int solve(int x){
b[0]=0;long long ans=0,zz=pyz;
memset(vis,0,sizeof(vis));memset(tag,0,sizeof(tag));
for(register int i=1;i<=n;++i){
if(a[i]==x)b[i]=b[i-1]+1;
else b[i]=b[i-1]-1;
vis[b[i]+pyz]++; //求vis数组
}
for(register int i=pyz*2;i>=1;--i)sum[i]=sum[i+1]+vis[i]; //求sum数组
for(register int i=1;i<=n;++i){
if(tag[zz]>0)sum[zz]-=tag[zz],tag[zz-1]+=tag[zz],tag[zz]=0; //打tag
ans+=sum[zz+1]; //计算答案
if(a[i]==x)zz++;else zz--;
sum[zz]--;tag[zz-1]++; //更新tag，自身值
}
return ans;
}
signed main(){
freopen("2828.in","r",stdin);
freopen("2828.out","w",stdout);
scanf("%lld%lld%lld",&n,&SEED,&m);
generate(n,SEED,m);
for(int i=0;i<m;++i)Ans+=solve(i);
printf("%lld
",Ans);
return 0;
}
哈哈哈，O(nm)是不是很简单啊。
但
你以为这是极限了吗？
不，事情远远没有你想想那么简单
如果m不是50了怎么办，m是10^9怎么办，会超时哦
第三层扩展性优化，m很大也能做！
时间复杂度O(nsqrt(n))
咳咳，这里只是一个扩展性的做法，针对m很大的做法，当然到这题没有用，不过还是写一下。
首先，第一步，将a[i]离散化，基础步骤
然后，第二步，分类讨论，如果元素出现种数小于sqrt(n)，那么就直接跑上面O(nm)的做法，时间复杂度O(nsqrt(n))
接着，第三步，如果种数大于sqrt(n)，那么就把出现次数小于sqrt(n)的元素为主元素的数组个数找出来，其实就是对于区间长度为[1,2sqrt(n)]的有主元素的子数组都找出来。但是如果，某个区间的主元素是元素x，这个元素x的总出现次数大于sqrt(n)，那么就不加，避免与下面的计算重复。
那么，第四步，剩下的出现次数大于sqrt(n)的元素个数肯定不超过sqrt(n)个，这个简单证明一下就可以了。然后对于这几个元素跑一遍上面说的O(nm)，找子数组个数。
最后，第五步，将全部答案加起来。
嗯~，这就是O(n sqrt(n))的做法。