Codeforce 水题报告

最近做了好多CF的题的说，很多cf的题都很有启发性觉得很有必要总结一下，再加上上次写题解因为太简单被老师骂了，所以这次决定总结一下，也发表一下停课一星期的感想= =

Codeforces 261E Maxim and Calculator

描述：有两个变量a和b，初始值为1和0，每次有两种操作，一个是a=a*b，另一个是b++，求有多少个l<a<r能在p步内达到(p<=100,r<1e9)

首先观察到p最大为100，也就是说最大质因数小于p，打表可得一共大概只有300万个数

考虑dp，设dp[i][j]为当b最多为i时最多须多少次才能a=a*b操作达到j状态，可得f[i][j]=min(f[i-1][j],f[i-1][j/i]+1)

时间复杂度O(np)可以解决这个问题

Code：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define maxn 3000001
#define maxq 101
int f[maxn],p[300],id[maxn],n,r,le,num;
bool b[maxn];
int dfs(int x,int y) {
    id[++n]=y;
    for (int i=x;i<=num;i++) {
        if (y*1ll*p[i]>r) break;
        dfs(i,y*p[i]);
    }
    return 0;
}
int main(){
    int le,k;
//    freopen("1.in","r",stdin);
//    freopen("1.out","w",stdout);
    scanf("%d%d%d",&le,&r,&k);
    for (int i=2;i<=k;i++) {
        if (!b[i]) p[++num]=i;
        for (int j=1;j<=num&&i*p[j]<=k;j++) {
            b[i*p[j]]=1;
            if (!(i%p[j])) break;
        }
    }
    dfs(1,1);
    f[1]=0;
    for (int i=2;i<=n;i++) f[i]=300;
    sort(id+1,id+1+n);
    for (int i=1;i<=k;i++) {
        int t=1;
        for (int j=1;j<=n;j++) {
            while (t<=n&&id[t]!=id[j]*i) ++t;
            if (t>n) break;
            f[t]=min(f[t],f[j]+1);
            if ((!b[t])&&(i+f[t]<=k)) b[t]=1;    
        }
    }
    int ans=0;
    for (int i=1;i<=n;i++){
        if (b[i]&&id[i]>=le) ++ans;
    }
    printf("%d\n",ans);
    return 0;
}

Codeforces 335F Buy One, Get One Free

描述：有很多物品，每买一个物品可选择价格比它小的一种物品作为赠品，求买下所有物品，使其花费最小（n<=500000）

这道题很难理解，首先，把所有价格相同的东西归在一起，记免费获得第i个东西所获得的利润为f[i]，做差得g[i],可得g数组一定是单调递减的（每次肯定选最好的比较好啦），然后考虑如何维护g数组，首先记现在处理的物品价格为x共有y个，当前已有m个物品，那么新加入的值是不会影响前面max(0,min(m/2,m+y/2)-y)的值的（因为我要获得更多的利润肯定先用原来获得利润少的机会），接下来我们考虑什么情况下可以更新。

首先当g[i]<y时一定可以直接替换掉，当g[i]>y时，可能存在一种情况，即我支付g[i]元来换取两个x，即多花一个机会获得 2x-g[i]的机会，这样我们就算出了新的g[i]数组，再维护其单调性即可。

Code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<set>
using namespace std;
#define maxn 500100
typedef long long ll;
int a[maxn],n,m;
int b[maxn];
typedef pair<int,int> ii;
#define fi first
#define se second
ii s[maxn];
multiset<int> map;
bool cmp(int x,int y){return x>y;} 
int main(){
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",a+i);
    sort(a+1,a+1+n,cmp);
    int l=0;
    ll ans=0;
    for (int i=1;i<=n;i++) {
        if (a[i]!=a[i-1]) l++;
        s[l].fi=a[i];s[l].se++;
        ans+=a[i];
    }
    n=l;
    int size=0;
    for (int i=1;i<=n;i++) {
        int x=s[i].fi,y=s[i].se;
        int last=size;
        size=min(m,(m+y)>>1);
        int cnt=max(0,size-y);
        for (int j=size-1;j>=cnt;j--)
            if (j<map.size()) b[j]=*map.begin(),map.erase(map.begin());
            else b[j]=0;    
        for (int j=cnt,k=m-j;j<k&&j<size;j++)
            if (b[j]<x) b[j]=x;
            else if (--k<size) b[k]=max(0,2*x-b[j]);
        map.insert(b+cnt,b+size);
        m+=y;
    }

    for (set<int>::iterator it=map.begin();it!=map.end();it++) {ans-=*it;} 
    cout<<ans;
    return 0;
}

Codeforces 293B Distinct Paths

描述：n*m的方格图涂色，已知有若干块以涂色，求涂上k种颜色使所有从左上到右下的路径不经过重复的颜色的方案数（n,m<=1000,k<=10）

其实n,m一定小于k否则无解，但10*10还是太大无法搜索怎么办?我们可以发现，涂到现在还未涂到的颜色本质上还是一样的，所以我们在搜索时遇到还没涂过的颜色只需搜一次即可。

这样还是有几个奇怪的点TLE了，那么我们改变一下搜索策略，从右上搜到左下即可（因为所有颜色都是在一条链上的）

Code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int b[13][13],n,m,p,ans,a[13][13],hash[13];
int dfs(int u,int v) {
    if (v==m+1) return dfs(u+1,1);
    if (u==n+1) {++ans;return 1;}
    int sum=0,tmp=0;bool flag=0;
    for (int i=0;i<p;i++) {
        if (a[u][v]&&a[u][v]!=i+1) continue;
        if ((b[u-1][v]&(1<<i))||(b[u][v-1]&(1<<i))) continue;
        hash[i+1]++;
        b[u][v]=b[u][v-1]|b[u-1][v]|(1<<i);
        if (hash[i+1]==1) {
            if (flag) {ans+=tmp;sum+=tmp;}
            else {tmp=dfs(u,v+1);flag=1;sum+=tmp;}
        }else sum+=dfs(u,v+1);
        hash[i+1]--;
    }
    return sum;
}
int main(){
    scanf("%d%d%d",&n,&m,&p);
    if (n+m-1>p) {printf("0\n");return 0;}
    for (int i=1;i<=n;i++) 
        for (int j=1;j<=m;j++) {
            scanf("%d",a[i]+j);
            hash[a[i][j]]++;
        }
    dfs(1,1);
    printf("%d\n",ans);
    return 0;
}

Codeforces 251D Two Sets

描述：两人取n个数，使两个人所有数的异或值的和最大的前提下让某个人的异或值最小，求方案（n<100000）

首先我们可以贪心来做，首先求出所有位的奇偶性，对于奇数两个人的配比一定是1,0，而偶的有可能为0,0或1,1，所以我们让大的偶位数尽量为1，在成立的前提下，再尽量使为奇数的位的1在另一个人的身上，这种判断操作都可以通过高斯消元解异或方程组来解决，然后就行了。

Code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<bitset>
using namespace std;
typedef unsigned long long ll;
#define maxn 100100
#define maxk 64
ll c[maxn];
int cnt[maxk];
vector<int> b;
vector<bitset<maxn> > a;
#define pb push_back
int imp[maxn];
int n;
inline void add(bitset<maxn> A,int B) {
    int m=a.size();
    for (int i=0;i<m;i++) 
        if (A[imp[i]]) A^=a[i],B^=b[i];
    int id=-1;
    for (int i=0;i<n;i++) if (A[i]) {id=i;break;}
    if (id==-1) return ;
    imp[m]=id;
    for (int i=0;i<m;i++) 
        if (a[i][id]) a[i]^=A,b[i]^=B;
    a.pb(A),b.pb(B);
}
int ans[maxn];
int main(){
    scanf("%d",&n);
    for (int i=0;i<n;i++) {
        scanf("%llu",&c[i]);
        for (int j=0;j<62;j++) cnt[j]+=(c[i]>>j)&1;
    }
    for (int i=61;i>=0;i--) {
        if (cnt[i]&&!(cnt[i]&1)) {
            bitset<maxn> t;
            t.reset();
            for (int j=0;j<n;j++) t[j]=(c[j]>>i)&1;
            add(t,1);
        }
    }
    for (int i=61;i>=0;i--) {
        if (cnt[i]&&(cnt[i]&1)) {
            bitset<maxn> t;
            t.reset();
            for (int j=0;j<n;j++) t[j]=(c[j]>>i)&1;
        add(t,0);
        }
    }
    for (int i=0;i<a.size();i++) ans[imp[i]]=b[i];
    for (int i=0;i<n;i++) printf("%d ",2-ans[i]);
    return 0;
}

Codeforces 319D Have You Ever Heard About the Word?

描述：给定一个字符串，每次找最小的（同时最小则取最左的）形如XX的变为X，求最后的字符串(len<=50000)

考试的时候看成最大的了= =

首先我们可以发现所有删除x的不同长度一定少于sqrt（len）种同时删除长度为l的区间一定不会重复，那么我们可以枚举长度并对所有长度相同的区间一起处理。

具体来说我们每次对于一个区间l，设定len/l个哨兵，判断相邻两个哨兵的最长公共前缀和后缀之和是否超过l，如果有，则说明存在一种长度为l的删法之和在暴力判断哪些需要删除

这些操作用hash就能解决了，总的时间复杂度为O(nsqrt(n))

Code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 51000
typedef unsigned int uint;
const int base=31;
uint h[maxn],pow[maxn];
char s[maxn],st[maxn];
int b[maxn],n,clo;
inline uint hash(int l,int r) {return h[r]-h[l-1]*pow[r-l+1];}
inline int findf(int l,int r,int x,int y) {
    while (l<=r) {
        int mid=(l+r)>>1;
        if (hash(x-mid+1,x)==hash(y-mid+1,y)) l=mid+1;
        else r=mid-1;
    }
    return r;
}
inline int findb(int l,int r,int x,int y) {
    while (l<=r) {
        int mid=(l+r)>>1;
        if (hash(x,x+mid-1)==hash(y,y+mid-1)) l=mid+1;
        else r=mid-1;
    }
    return r;
}
inline bool check(int l) {
    for (int i=1;i+l<=n;i+=l) {
        int f=findf(0,l,i,i+l);
        int b=findb(0,min(n-i-l+1,l),i,i+l);
        if (f+b-1>=l) return 1;
    }
    return 0;
}
inline void gethash() {for (int i=1;i<=n;i++) h[i]=h[i-1]*base+s[i]-'a';}
inline void work(int l) {
    clo++;
    for (int i=1;i+2*l-1<=n;) {
        if (hash(i,i+l-1)==hash(i+l,i+2*l-1)) {
            for (int j=i;j<=i+l-1;j++) b[j]=clo;
            i+=l;
        }else i++;
    } 
    int cnt=0;
    for (int i=1;i<=n;i++) 
        if (b[i]!=clo) st[++cnt]=s[i];
    for (int i=1;i<=cnt;i++) s[i]=st[i];
    n=cnt;
    s[n+1]=0;
    gethash();
}
int main(){
    scanf("%s",s+1);
    n=strlen(s+1);
    gethash();
    pow[0]=1;
    for (int i=1;i<=n;i++) pow[i]=pow[i-1]*base;
    for (int i=1;i<=n/2;i++) 
        if (check(i)) work(i);
    printf("%s",s+1);
}

Codeforces 280E Sequence Transformation  

描述：给定一个非减数列xi要你求出一个数列yi（a<yi-yi-1<b）使sigma(xi-yi)^2最小（n<=300000,xi,yi<q,1<q,a,b<10^9，yi为实数）

这道题真的很精妙，首先我们考虑一个函数fi(x)为当yi=x时的最小开销。然后我们考虑如何由fi-1推到fi

当i-1=1时，可以清楚的看出，为了使其最小，所有的f2(x)中y1的取值必须向f1的极值点靠近，即把f1的极值点左边集体+a，右边集体+b，再加上函数(x2-x)^2。由导数可得，每个函数一定都会有极值点的，因此所有的推法都能这样干。最终答案就是fn的极值点。

那么方案该怎么求呢？我们可以倒过来推，已经知道yn了，那么其他的数都必须尽量靠近fi的极值点，所以我们记录下所有的极值点即可

在实现方面，我们可以用splay直接维护他的导数，3个懒标记即可维护，我的写法足足比其他人少了1/2~~~

比较注意的是极值点可能不在取值范围内，因此边界问题需要比较详细的讨论

（还有一点就是不知为何我的导数并不是连续的，请会的大神告诉我原因QAQ）

Code:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define maxn 300010
struct node{
    double x,y,lz,k,lk,lb;
    node *ch[2],*pre;
    node(double _x,double _y,double _k):x(_x),y(_y),k(_k){lk=lb=lz=0;pre=ch[0]=ch[1]=NULL;}
    inline void update(){
        if (lk||lb) {
            k+=lk;y+=lk*x+lb;
            if (ch[0]) ch[0]->lk+=lk,ch[0]->lb+=lb+ch[0]->lz*lk;
            if (ch[1]) ch[1]->lk+=lk,ch[1]->lb+=lb+ch[1]->lz*lk;
            lk=lb=0;
        }
        if (lz) {
            x+=lz;
            if (ch[0]) ch[0]->lz+=lz;
            if (ch[1]) ch[1]->lz+=lz;
            lz=0;
         }
    }
    inline int d(){return pre->ch[1]==this;}
};
inline void rotate(node *u){
    node *v=u->pre;
    if (v->pre) v->pre->update();
    v->update();u->update();
    if (v->pre) v->pre->ch[v->d()]=u;
    int d=u->d();
    u->pre=v->pre;
    v->pre=u;
    if (u->ch[d^1]) u->ch[d^1]->pre=v;
    v->ch[d]=u->ch[d^1];
    u->ch[d^1]=v;
}
inline void spaly(node *u){u->update();while (u->pre) rotate(u);}
node* search(node *u) {
    if (!u) return 0;
    u->update();
    if (u->y>0) {
        node *ans=search(u->ch[0]);
        return ans?ans:u;
    }
    return search(u->ch[1]);
}
int cut(node *r,node* &l){
    spaly(r);
    l=r->ch[0];
    r->ch[0]=0;
    if (l) l->pre=0;
}
node* rest(node *l){
    if (!l) return 0;
    while (l->ch[1]) l->update(),l=l->ch[1];
    l->update();
    return l;
}
node* link(node *l,node *r){
    if (l==0) return r;if (r==0) return l;
    l=rest(l);
    spaly(l);
    l->ch[1]=r;r->pre=l;
    return l;
}
#define inf 1e10
double c[maxn],ans[maxn],w[maxn];
int main(){
    int n,q,a,b;
    scanf("%d%d%d%d",&n,&q,&a,&b);
    for (int i=1;i<=n;i++) scanf("%lf\n",c+i);
    node *root=new node(q,q*2-2*c[1],2);
    for (int i=2;i<=n;i++) {
        node* r=search(root),*l;
        cut(r,l);
        w[i]=r->x-r->y/r->k;
        if (l)w[i]=max(rest(l)->x,w[i]);
        if (w[i]>=(i-2)*a+1) {
            l=link(l,new node(w[i],0,r->k));r=link(new node(w[i],0,0),r);
            l->lz+=a;r->lz+=b;
            root=link(l,r);
            root->lk+=2;root->lb-=2*c[i];
        }else {
            w[i]=(i-2)*a+1;
            root=link(new node(w[i],0,0),root);
            root->lz+=b;
            root->update();
            root->lk+=2;root->lb-=2*c[i];
        }
    }
    node *r=search(root),*l;
    cut(r,l);
    double x=r->x-r->y/r->k;
    if (l) x=max(rest(l)->x,x);
    if (x<(n-1)*a+1) x=(n-1)*a+1;
    if (x>q) x=q;
    for (int i=n;i;i--) {
        ans[i]=x;
        if (x-a<w[i]) x-=a;
        else if (x-b>w[i]) x-=b;
        else x=w[i];
    }
    double sum=0;
    for (int i=1;i<=n;i++) {
        printf("%.10lf ",ans[i]);sum+=(c[i]-ans[i])*(c[i]-ans[i]);
    }
    printf("\n%lf\n",sum);
    return 0;
}

Codeforces 261D Maxim and Increasing Subsequence

描述：计算一个重复t次的数列an的最长上升子序列（n<=1e5,maxa<=1e5,t<=1e9,n*maxa<=2e7）

考试的时候脑残了想不到正解写了个暴力居然a了= =

首先可以发现当t>=maxa时直接输出an中不同元素的个数即可，那么我们考虑t<=maxa的情况。

首先记第i次aj的最长上升子序列为f[j]，可以发现随着i的增大f[j]肯定是单调不递减的，那么我们可以考虑f[j]是否能增长即可。考虑维护一个g[i] 为所有f[j]>=i的最小a[j]，就可以直接转移并维护了。

Code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
#define maxn 101000
int b[maxn],a[maxn],f[maxn];
int main(){
    int k,n,t,maxb;
    scanf("%d%d%d%d",&k,&n,&maxb,&t);
    while (k--) {
        for (int i=1;i<=n;i++) scanf("%d",b+i);
        if (t>=maxb) {
            sort(b+1,b+1+n);
            printf("%d\n",unique(b+1,b+1+n)-b-1);
            continue;
        }
        memset(f,0,sizeof(f));
        memset(a,0x3f,sizeof(a));
        a[0]=0;
        for (int i=1;i<=t;i++) {
            for (int j=1;j<=n;j++) {
                while (a[f[b[j]]]<b[j]) {a[f[b[j]]]=min(a[f[b[j]]],b[j]);f[b[j]]++;}
                a[f[b[j]]]=min(a[f[b[j]]],b[j]);
            }
        }
        int ans=0;
        for (int i=1;i<=maxb;i++) ans=max(ans,f[i]);
        printf("%d\n",ans);
    }
    return 0;
}

Codeforces 235D Graph Game

描述：在一个n点n边的图上每次随机删一个点并ans+=当前联通块的大小，递归下去，求ans的期望(n<=3000)

可以记f[i][j]为删掉i点时i与j连通的概率，那么ans=sigma（f[i][j]）了（clj太***了啊这个根本想不到啊啊啊），然后考虑怎么求f[i][j]。

先考虑树的情况，可以得出联通的概率为1/dist（i，j）（因为不在路径上的点删掉与否是无关的，所以只有那dist(i,j)个）是有用的。

若两点路径没经过环同树的情况，否则记环外路径为x，环两侧路径为y,z则答案为1/(x+y)+1/(x+z)+1/(x+y+z)（由容斥原理可得）

N次dfs即可，时间复杂度为O(n^2)

Code:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 4010
struct edges{int to,next;}edge[maxn*2];
int next[maxn],l;
inline void addedge(int x,int y){
    edge[++l]=(edges){y,next[x]};next[x]=l;
    edge[++l]=(edges){x,next[y]};next[y]=l;
}
bool flag;
bool dis[maxn],b[maxn];
int s[maxn],cnt,tot;
int dfs1(int u,int pre) {
    b[u]=1;
    for (int i=next[u];i;i=edge[i].next) {
        if (!b[edge[i].to]) {
            s[++cnt]=edge[i].to;
            dfs1(edge[i].to,u);
            if (flag) return 0;
            cnt--;
        }else if (edge[i].to!=pre&&cnt) {
            while (cnt&&s[cnt]!=edge[i].to) dis[s[cnt--]]=1,tot++;
            flag=1;
            dis[s[cnt]]=1;tot++;
        }
    }
}
double ans=0;
int dfs(int u,int dist,int cnt) {
    b[u]=1;
    ans+=1.0/dist;
    if (cnt>1) {
        ans+=1.0/(dist+tot-cnt*2+2);
        ans-=1.0/(dist+tot-cnt);
    }
    for (int i=next[u];i;i=edge[i].next) 
        if (!b[edge[i].to]) dfs(edge[i].to,dist+1,cnt+dis[edge[i].to]);
}
int main(){
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++) {
        int x,y;
        scanf("%d%d",&x,&y);
        x++,y++;
        addedge(x,y);
    }
    s[cnt=1]=1;
    dfs1(1,0);
    memset(b,0,sizeof(b));
    for (int i=1;i<=n;i++) {memset(b,0,sizeof(b));dfs(i,1,dis[i]);}
    printf("%.9lf",ans);
    return 0;
}

Codeforces 226E More Queries to Array

描述：给定一个数组a以及两种操作：1.将l~r设为x 2.询问l~r中sigma a[i]*(i-l+1)^k （n<1e5,k<=5）

直接把询问拆开来可以发现只需维护a[i]*l的0到5次方即可，线段树维护就可以了

因为一点小小的溢出导致查了好久= =，以后打还是得注意多mod一下

Code:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define maxn 101000
typedef long long ll;
struct node {
    int l,r;ll lz,s[6];
}t[maxn*8];
const ll mod=1000000007ll;
#define lc (x<<1)
#define rc (lc^1)
#define mid ((l+r)>>1)
#define ni3 333333336
#define ni5 400000003
inline ll pow(ll x,int mi) {
    if (mi==0) return x;
    if (mi==1) return (1+x)*(x)/2%mod;
    if (mi==2) return pow(x,1)%mod*(2*x+1)%mod*ni3%mod;
    if (mi==3) return pow(x,1)*pow(x,1)%mod;
    if (mi==4) return pow(x,2)*((x*3%mod*x%mod+x*3%mod-1)%mod)%mod*ni5%mod;
    if (mi==5) return pow(x,3)*((x*2%mod*x%mod+x*2%mod-1)%mod)%mod*ni3%mod;
}
inline ll quick(int l,int r,int  mi) {return (pow(r,mi)-pow(l-1,mi)+mod)%mod;}
inline void update(int x) {
    if (t[x].lz!=-1) {
        for (int i=0;i<=5;i++) t[x].s[i]=t[x].lz*quick(t[x].l,t[x].r,i)%mod;
        return ;
    }
    for (int i=0;i<=5;i++) t[x].s[i]=(t[lc].s[i]+t[rc].s[i])%mod;
}
inline void pushback(int x) {
    if (t[x].lz==-1) return ;
    t[lc].lz=t[rc].lz=t[x].lz;
    update(lc);update(rc);
    t[x].lz=-1;
}
int a[maxn];
void build(int x,int l,int r) {
    t[x].l=l,t[x].r=r;t[x].lz=-1;
    if (l==r) {t[x].lz=a[l];update(x);return ;}
    build(lc,l,mid);build(rc,mid+1,r);
    update(x);
    return ;
}
void set(int x,int x1,int y1,int z) {
    int l=t[x].l,r=t[x].r;
    if (l>y1||r<x1) return ;
    if (x1<=l&&r<=y1) {t[x].lz=z;update(x);return;}
    pushback(x);
    set(lc,x1,y1,z);set(rc,x1,y1,z);
    update(x);
    return ;
}
ll que(int x,int x1,int y1,int z) {
    int l=t[x].l,r=t[x].r;
    if (l>y1||r<x1) return 0;
    if (x1<=l&&r<=y1) return t[x].s[z];
    pushback(x);
    return (que(lc,x1,y1,z)+que(rc,x1,y1,z))%mod;
}
inline int power(int x,int y){
    ll ans=1;
    for (int i=1;i<=y;i++) (ans*=x)%=mod;
    return ans;
}
inline ll que(int l,int r,int k) {
    int x=1-l;
    if (k==0) return que(1,l,r,0);
    if (k==1) return ((que(1,l,r,1)+que(1,l,r,0)*power(x,1)%mod)%mod+mod)%mod;
    if (k==2) return ((que(1,l,r,2)+que(1,l,r,1)*power(x,1)%mod*2%mod+que(1,l,r,0)*power(x,2)%mod)%mod+mod)%mod;
    if (k==3) return ((que(1,l,r,3)+que(1,l,r,2)*power(x,1)%mod*3%mod+que(1,l,r,1)*power(x,2)%mod*3%mod+que(1,l,r,0)*power(x,3)%mod)%mod+mod)%mod;
    if (k==4) return ((que(1,l,r,4)+que(1,l,r,3)*power(x,1)%mod*4%mod+que(1,l,r,2)*power(x,2)%mod*6%mod+que(1,l,r,1)*power(x,3)%mod*4%mod+que(1,l,r,0)*power(x,4)%mod)%mod+mod)%mod;
    if (k==5) return ((que(1,l,r,5)+que(1,l,r,4)*power(x,1)%mod*5%mod+que(1,l,r,3)*power(x,2)%mod*10%mod+que(1,l,r,2)*power(x,3)%mod*10%mod+que(1,l,r,1)*power(x,4)%mod*5%mod+que(1,l,r,0)*power(x,5)%mod)%mod+mod)%mod;
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    build(1,1,n);
    while (m--){
        int l,r,x;char opt[2];
        scanf("%s%d%d%d",opt,&l,&r,&x);
        switch(opt[0]) {
            case '=':
                set(1,l,r,x);
                break;
            case '?':
                printf("%lld\n",que(l,r,x));
                break;
        }
    }
    return 0;
}

2000个字刚好= =

总结一下吧，cf还是有很多题特别精妙的，没有像某些省选题那么裸，写完这几道题之后感觉自己整个人都不一样了。还是很推荐去刷这几题的

这次终于特别认真的写了一次题解，自己感觉加深了对题目的认识还是挺不错的，后面还有几道code jam的找机会再来写一下

停课一个星期了，感觉自己整个人都特别的颓废，还是读书比较让人提得起精神，不过既然离省选还有一个月，就应该充分利用这一个月的时间来学习一些东西。

这一季要追6部番= =还是挺累的，不过想弃哪部都舍不得啊，不补旧番了吧

这周末好多比赛啊= =，争取都找时间参加一下吧= =

好了瞎说胡扯完了，改题去了