吐槽（完跪）：神tmNOIP模拟赛，看到大题头根本高级数据结构什么的想都没想，结果死的很惨，第三题竟然要可持久化线段树，这NOIP我服了。
平均数：
这道题40分相信大家都能拿到，剩下的60分讲真考验思维，首先我们要二分出一个答案，然后关键是怎么检验答案的可行性，首先这数据范围我们肯定是要用nlogn的算法了，可是怎么做呢？树状数组？不可能！因为是小数，况且也没有办法用上树状数组。。。等等，真的不行吗？如果我们把整个区间都减去这个ans的话所得到的每个区间的平均数自然也就少了ans，我们只需要统计出小于零的区间个数即可，这样的话我们可以处理处一个前缀合，这样所有逆序对的数量就是平均值小于当前二分值的区间数量。逆序对最方便的当然是树状数组了，可是它是小数，如果离散化的话应该也可以，但是没有必要，我们可以用另一种办法求逆序对：归并排序。只要我们在merge的时候顺便统计一下有多少左边的比右边的大即可，这题还卡精度。。。最好用long double。
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<iomanip>
#include<cstring>
#include<string>
#include<algorithm>
#include<ctime>
#include<cmath>
using namespace std;
#define eps 1e-5
long double a[200000];
long double c[200000];
long double temp[200000];
long double sum[200000];
long long n,k;
long long ans=0;
void my_merge(int x,int y)
{
int mid=x+y>>1;
int l=x,r=mid+1;
int top=x-1;
while(l<=mid && r<=y)
{
if(sum[l]>sum[r])
{
temp[++top]=sum[r++];
ans+=mid+1-l;
}
else temp[++top]=sum[l++];
}
while(l<=mid) temp[++top]=sum[l++];
while(r<=y) temp[++top]=sum[r++];
for(int i=x;i<=y;i++) sum[i]=temp[i];
}
void gui_sort(int x,int y)
{
if(x>=y) return;
int mid=x+y>>1;
gui_sort(x,mid);
gui_sort(mid+1,y);
my_merge(x,y);
}
bool check(long double x)
{
for(int i=1;i<=n;i++) sum[i]=sum[i-1]+a[i]-x;
ans=0;
gui_sort(0,n);
if(ans>=k) return true;
return false;
}
int main()
{
freopen("ave.in","r",stdin);
freopen("ave.out","w",stdout);
scanf("%lld%lld",&n,&k);
for(int i=1;i<=n;i++)
{
double x;
scanf("%lf",&x);
a[i]=x;
}
long double l=0,r=1000000000;
while(r-l>=eps)
{
long double mid=(l+r)/2.0;
if(check(mid)) r=mid;
else l=mid;
}
double ans=l;
printf("%.4lf",ans);
return 0;
}
涂色游戏：
大量的组合数运算。
首先我们可以想明白一个问题就是只有每一行颜色的数量对下一行有影响，而颜色具体是什么则没有什么关系，所以我们可以搞一个dp[i][j]表示到达第i列涂了j种颜色有多少种方案。
那么我们可以先写一个大致的方程，像这样：dp[i][j]=dp[i-1][k]*trans[k][j];
其中trans为转移常数。
那么我们的目的就明确了：求出来trans[k][j];
首先我们的人物是求出一列放的方案书，这要另一个dp，设f[i][j]为一列到达第i个位置选择j种颜色的方案数目，则f[i][j]=f[i-1][j-1]*(p-j+1)+f[i-1][j]*j。设g[i]=f[n][i],这个东西处理完了之后一列n个元素放i种颜色的方案数就变为了
那么相邻两行的状态转移我们就可以通过枚举两行之间的并集颜色数量来表示，设x为相邻两行颜色数目的并集，则有
这样的话对于70%的数据就可以水过了，那另外的30%呢？我们注意到每次求dp的时候实际上就是两个矩阵相乘，那么我们运用矩阵乘法快速幂就可以通过这道题了。
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<iostream>
#include<iomanip>
#include<ctime>
#include<cmath>
#include<algorithm>
using namespace std;
#define int long long
const int mod=998244353;
long long c[150][150];
long long f[150][150];
long long dp[150][150];
long long ksm(long long x,long long k)
{
long long ans=1;
long long mid=x;
while(k)
{
if(k&1) ans=(ans*mid)%mod;
mid=(mid*mid)%mod;
k>>=1;
}
return ans;
}
struct mat{
long long a[105][105];
}ans,tmp;
int n,m,p,q;
mat operator*(mat a,mat b){
int i,j,k;mat c;
for(i=1;i<=p;i++)
for(j=1;j<=p;j++){
c.a[i][j]=0;
for(k=1;k<=p;k++) c.a[i][j]=(c.a[i][j]+(long long)a.a[i][k]*b.a[k][j])%mod;
}
return c;
}
main()
{
freopen("color.in","r",stdin);
freopen("color.out","w",stdout);
scanf("%d%d%d%d",&n,&m,&p,&q);
for(int i=0;i<=p;i++) c[i][0]=1;
for(int i=1;i<=p;i++)
for(int j=1;j<=i;j++)
c[i][j]=(c[i-1][j-1]+c[i-1][j])%mod;
f[0][0]=1;
for(int i=1;i<=n;i++)
for(int j=1;j<=p;j++)
f[i][j]=(f[i-1][j-1]*(p-j+1)+f[i-1][j]*j)%mod;
for(int j=1;j<=p;j++)
for(int k=1;k<=p;k++){
for(int x=max(q,max(j,k));x<=p;x++)
tmp.a[j][k]=(tmp.a[j][k]+(long long)c[j][j+k-x]*c[p-j][x-j])%mod;
tmp.a[j][k]=(long long)f[n][k]*tmp.a[j][k]%mod*ksm(c[p][k],mod-2)%mod;
// printf("%d ",tmp.a[j][k]);
}
m--;
for(int i=1;i<=p;i++) ans.a[i][i]=1;
while(m)
{
if(m&1) ans=ans*tmp;
tmp=tmp*tmp;m>>=1;
}
long long sum=0;
for(int i=1;i<=p;i++)
for(int j=1;j<=p;j++)
sum=(sum+(long long)f[n][i]*ans.a[i][j])%mod;
cout<<sum;
return 0;
}
序列
orz主席树
抱着noip的心理，再加上根本就不会主席树，这道题只过了暴力分。
这道题我们要想到的是就是要对于一个点要快速找到有多少个区间覆盖这个点，并将小于这个点权值的询问数量加起来。学了主席树后突然觉得好巧妙，我们只要把每一个询问拆分成两个点，一个是入线段树的点，一个是出线段树的点，用主席树的经典思想就是入线段树的点的时间设为l,出线段树的点的时间设为r+1,这样从1到100000插入一边所有的点，入线段树时权值为该询问的值的x的size+1，出线段树时-1，然后我们先对初始序列第i个位置调用一边时间为i的主席树，然后查找1到v[i]的和即可。修改只要先减去之前答案在加入一个新的答案就可以了。
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cmath>
#include<cstring>
#include<string>
#include<iostream>
#include<iomanip>
#include<algorithm>
using namespace std;
struct xianduan
{
xianduan *ls,*rs;
int size;
void* operator new(size_t,xianduan *_,xianduan *__,int ___)
{
static xianduan *mempool,*c;
if(c==mempool)
mempool=(c=new xianduan[1<<15])+(1<<15);
c->ls=_;
c->rs=__;
c->size=___;
return c++;
}
friend xianduan* build_tree(xianduan *o,int x,int y,int pos,int c_size)
{
int mid=x+y>>1;
if(x==y) return new(0x0,0x0,o->size+c_size)xianduan;
if(pos<=mid) return new(build_tree(o->ls,x,mid,pos,c_size),o->rs,o->size+c_size)xianduan;
else return new(o->ls,build_tree(o->rs,mid+1,y,pos,c_size),o->size+c_size)xianduan;
}
friend int query(xianduan *o,int x,int y,int k)
{
if(y<=k) return o->size;
int mid=x+y>>1;
if(k<=mid) return query(o->ls,x,mid,k);
else return o->ls->size+query(o->rs,mid+1,y,k);
}
}*root[200000];
struct change
{
int tim,lei,x;
bool operator <(change b) const
{
return tim<b.tim;
}
}changes[250000];
int top=0;
int a[250000];
int main()
{
freopen("seq.in","r",stdin);
freopen("seq.out","w",stdout);
int n,m,q;
scanf("%d%d%d",&n,&m,&q);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1;i<=m;i++)
{
int l,r,x;
scanf("%d%d%d",&l,&r,&x);
changes[++top].tim=l;
changes[top].lei=1;
changes[top].x=x;
changes[++top].tim=r+1;
changes[top].lei=-1;
changes[top].x=x;
}
sort(changes+1,changes+1+top);
root[0]=new (0x0,0x0,0)xianduan;
root[0]->ls=root[0]->rs=root[0];
int wz=1;
for(int i=1;i<=100000;i++)
{
root[i]=root[i-1];
while(changes[wz].tim==i && wz<=top)
{
root[i]=build_tree(root[i],1,100000,changes[wz].x,changes[wz].lei);
wz++;
}
}
long long ans=0;
for(int i=1;i<=n;i++)
{
ans+=query(root[i],1,100000,a[i]);
}
printf("%d\n",ans);
for(int i=1;i<=q;i++)
{
int p,v;
scanf("%d%d",&p,&v);
p^=ans;
v^=ans;
ans-=query(root[p],1,100000,a[p]);
a[p]=v;
ans+=query(root[p],1,100000,a[p]);
printf("%d\n",ans);
}
return 0;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
