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[],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 ;
 }
 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=;i<=k;i++) {
         if (!b[i]) p[++num]=i;
         for (int j=;j<=num&&i*p[j]<=k;j++) {
             b[i*p[j]]=;
             if (!(i%p[j])) break;
         }
     }
     dfs(,);
     f[]=;
     for (int i=;i<=n;i++) f[i]=;
     sort(id+,id++n);
     for (int i=;i<=k;i++) {
         int t=;
         for (int j=;j<=n;j++) {
             while (t<=n&&id[t]!=id[j]*i) ++t;
             if (t>n) break;
             f[t]=min(f[t],f[j]+);
             if ((!b[t])&&(i+f[t]<=k)) b[t]=;
         }
     }
     int ans=;
     for (int i=;i<=n;i++){
         if (b[i]&&id[i]>=le) ++ans;
     }
     printf("%d\n",ans);
     return ;
 }

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=;i<=n;i++) scanf("%d",a+i);
     sort(a+,a++n,cmp);
     int l=;
     ll ans=;
     for (int i=;i<=n;i++) {
         if (a[i]!=a[i-]) l++;
         s[l].fi=a[i];s[l].se++;
         ans+=a[i];
     }
     n=l;
     int size=;
     for (int i=;i<=n;i++) {
         int x=s[i].fi,y=s[i].se;
         int last=size;
         size=min(m,(m+y)>>);
         int cnt=max(,size-y);
         for (int j=size-;j>=cnt;j--)
             if (j<map.size()) b[j]=*map.begin(),map.erase(map.begin());
             else b[j]=;
         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(,*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 ;
 }

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[][],n,m,p,ans,a[][],hash[];
 int dfs(int u,int v) {
     if (v==m+) return dfs(u+,);
     if (u==n+) {++ans;return ;}
     int sum=,tmp=;bool flag=;
     for (int i=;i<p;i++) {
         if (a[u][v]&&a[u][v]!=i+) continue;
         if ((b[u-][v]&(<<i))||(b[u][v-]&(<<i))) continue;
         hash[i+]++;
         b[u][v]=b[u][v-]|b[u-][v]|(<<i);
         if (hash[i+]==) {
             if (flag) {ans+=tmp;sum+=tmp;}
             else {tmp=dfs(u,v+);flag=;sum+=tmp;}
         }else sum+=dfs(u,v+);
         hash[i+]--;
     }
     return sum;
 }
 int main(){
     scanf("%d%d%d",&n,&m,&p);
     if (n+m->p) {printf("0\n");return ;}
     for (int i=;i<=n;i++)
         for (int j=;j<=m;j++) {
             scanf("%d",a[i]+j);
             hash[a[i][j]]++;
         }
     dfs(,);
     printf("%d\n",ans);
     return ;
 }

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=;i<m;i++)
         if (A[imp[i]]) A^=a[i],B^=b[i];
     int id=-;
     for (int i=;i<n;i++) if (A[i]) {id=i;break;}
     if (id==-) return ;
     imp[m]=id;
     for (int i=;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=;i<n;i++) {
         scanf("%llu",&c[i]);
         for (int j=;j<;j++) cnt[j]+=(c[i]>>j)&;
     }
     for (int i=;i>=;i--) {
         if (cnt[i]&&!(cnt[i]&)) {
             bitset<maxn> t;
             t.reset();
             for (int j=;j<n;j++) t[j]=(c[j]>>i)&;
             add(t,);
         }
     }
     for (int i=;i>=;i--) {
         if (cnt[i]&&(cnt[i]&)) {
             bitset<maxn> t;
             t.reset();
             for (int j=;j<n;j++) t[j]=(c[j]>>i)&;
         add(t,);
         }
     }
     for (int i=;i<a.size();i++) ans[imp[i]]=b[i];
     for (int i=;i<n;i++) printf("%d ",-ans[i]);
     return ;
 }

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=;
 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-]*pow[r-l+];}
 inline int findf(int l,int r,int x,int y) {
     while (l<=r) {
         int mid=(l+r)>>;
         if (hash(x-mid+,x)==hash(y-mid+,y)) l=mid+;
         else r=mid-;
     }
     return r;
 }
 inline int findb(int l,int r,int x,int y) {
     while (l<=r) {
         int mid=(l+r)>>;
         if (hash(x,x+mid-)==hash(y,y+mid-)) l=mid+;
         else r=mid-;
     }
     return r;
 }
 inline bool check(int l) {
     for (int i=;i+l<=n;i+=l) {
         int f=findf(,l,i,i+l);
         int b=findb(,min(n-i-l+,l),i,i+l);
         if (f+b->=l) return ;
     }
     return ;
 }
 inline void gethash() {for (int i=;i<=n;i++) h[i]=h[i-]*base+s[i]-'a';}
 inline void work(int l) {
     clo++;
     for (int i=;i+*l-<=n;) {
         if (hash(i,i+l-)==hash(i+l,i+*l-)) {
             for (int j=i;j<=i+l-;j++) b[j]=clo;
             i+=l;
         }else i++;
     }
     int cnt=;
     for (int i=;i<=n;i++)
         if (b[i]!=clo) st[++cnt]=s[i];
     for (int i=;i<=cnt;i++) s[i]=st[i];
     n=cnt;
     s[n+]=;
     gethash();
 }
 int main(){
     scanf("%s",s+);
     n=strlen(s+);
     gethash();
     pow[]=;
     for (int i=;i<=n;i++) pow[i]=pow[i-]*base;
     for (int i=;i<=n/;i++)
         if (check(i)) work(i);
     printf("%s",s+);
 }

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[],*pre;
     node(double _x,double _y,double _k):x(_x),y(_y),k(_k){lk=lb=lz=;pre=ch[]=ch[]=NULL;}
     inline void update(){
         if (lk||lb) {
             k+=lk;y+=lk*x+lb;
             if (ch[]) ch[]->lk+=lk,ch[]->lb+=lb+ch[]->lz*lk;
             if (ch[]) ch[]->lk+=lk,ch[]->lb+=lb+ch[]->lz*lk;
             lk=lb=;
         }
         if (lz) {
             x+=lz;
             if (ch[]) ch[]->lz+=lz;
             if (ch[]) ch[]->lz+=lz;
             lz=;
          }
     }
     inline int d(){return pre->ch[]==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^]) u->ch[d^]->pre=v;
     v->ch[d]=u->ch[d^];
     u->ch[d^]=v;
 }
 inline void spaly(node *u){u->update();while (u->pre) rotate(u);}
 node* search(node *u) {
     if (!u) return ;
     u->update();
     if (u->y>) {
         node *ans=search(u->ch[]);
         return ans?ans:u;
     }
     return search(u->ch[]);
 }
 int cut(node *r,node* &l){
     spaly(r);
     l=r->ch[];
     r->ch[]=;
     if (l) l->pre=;
 }
 node* rest(node *l){
     if (!l) return ;
     while (l->ch[]) l->update(),l=l->ch[];
     l->update();
     return l;
 }
 node* link(node *l,node *r){
     if (l==) return r;if (r==) return l;
     l=rest(l);
     spaly(l);
     l->ch[]=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=;i<=n;i++) scanf("%lf\n",c+i);
     node *root=new node(q,q*-*c[],);
     for (int i=;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-)*a+) {
             l=link(l,new node(w[i],,r->k));r=link(new node(w[i],,),r);
             l->lz+=a;r->lz+=b;
             root=link(l,r);
             root->lk+=;root->lb-=*c[i];
         }else {
             w[i]=(i-)*a+;
             root=link(new node(w[i],,),root);
             root->lz+=b;
             root->update();
             root->lk+=;root->lb-=*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-)*a+) x=(n-)*a+;
     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=;
     for (int i=;i<=n;i++) {
         printf("%.10lf ",ans[i]);sum+=(c[i]-ans[i])*(c[i]-ans[i]);
     }
     printf("\n%lf\n",sum);
     return ;
 }

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=;i<=n;i++) scanf("%d",b+i);
         if (t>=maxb) {
             sort(b+,b++n);
             printf("%d\n",unique(b+,b++n)-b-);
             continue;
         }
         memset(f,,sizeof(f));
         memset(a,0x3f,sizeof(a));
         a[]=;
         for (int i=;i<=t;i++) {
             for (int j=;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=;
         for (int i=;i<=maxb;i++) ans=max(ans,f[i]);
         printf("%d\n",ans);
     }
     return ;
 }

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*];
 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]=;
     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 ;
             cnt--;
         }else if (edge[i].to!=pre&&cnt) {
             while (cnt&&s[cnt]!=edge[i].to) dis[s[cnt--]]=,tot++;
             flag=;
             dis[s[cnt]]=;tot++;
         }
     }
 }
 double ans=;
 int dfs(int u,int dist,int cnt) {
     b[u]=;
     ans+=1.0/dist;
     if (cnt>) {
         ans+=1.0/(dist+tot-cnt*+);
         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+,cnt+dis[edge[i].to]);
 }
 int main(){
     int n;
     scanf("%d",&n);
     for (int i=;i<=n;i++) {
         int x,y;
         scanf("%d%d",&x,&y);
         x++,y++;
         addedge(x,y);
     }
     s[cnt=]=;
     dfs1(,);
     memset(b,,sizeof(b));
     for (int i=;i<=n;i++) {memset(b,,sizeof(b));dfs(i,,dis[i]);}
     printf("%.9lf",ans);
     return ;
 }

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[];
 }t[maxn*];
 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==) return x;
     if (mi==) return (+x)*(x)/%mod;
     if (mi==) return pow(x,)%mod*(*x+)%mod*ni3%mod;
     if (mi==) return pow(x,)*pow(x,)%mod;
     if (mi==) return pow(x,)*((x*%mod*x%mod+x*%mod-)%mod)%mod*ni5%mod;
     if (mi==) return pow(x,)*((x*%mod*x%mod+x*%mod-)%mod)%mod*ni3%mod;
 }
 inline ll quick(int l,int r,int  mi) {return (pow(r,mi)-pow(l-,mi)+mod)%mod;}
 inline void update(int x) {
     if (t[x].lz!=-) {
         for (int i=;i<=;i++) t[x].s[i]=t[x].lz*quick(t[x].l,t[x].r,i)%mod;
         return ;
     }
     for (int i=;i<=;i++) t[x].s[i]=(t[lc].s[i]+t[rc].s[i])%mod;
 }
 inline void pushback(int x) {
     if (t[x].lz==-) return ;
     t[lc].lz=t[rc].lz=t[x].lz;
     update(lc);update(rc);
     t[x].lz=-;
 }
 int a[maxn];
 void build(int x,int l,int r) {
     t[x].l=l,t[x].r=r;t[x].lz=-;
     if (l==r) {t[x].lz=a[l];update(x);return ;}
     build(lc,l,mid);build(rc,mid+,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 ;
     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=;
     for (int i=;i<=y;i++) (ans*=x)%=mod;
     return ans;
 }
 inline ll que(int l,int r,int k) {
     int x=-l;
     if (k==) return que(,l,r,);
     if (k==) return ((que(,l,r,)+que(,l,r,)*power(x,)%mod)%mod+mod)%mod;
     if (k==) return ((que(,l,r,)+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod)%mod+mod)%mod;
     if (k==) return ((que(,l,r,)+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod)%mod+mod)%mod;
     if (k==) return ((que(,l,r,)+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod)%mod+mod)%mod;
     if (k==) return ((que(,l,r,)+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod*%mod+que(,l,r,)*power(x,)%mod)%mod+mod)%mod;
 }
 int main(){
     int n,m;
     scanf("%d%d",&n,&m);
     for (int i=;i<=n;i++) scanf("%d",&a[i]);
     build(,,n);
     while (m--){
         int l,r,x;char opt[];
         scanf("%s%d%d%d",opt,&l,&r,&x);
         switch(opt[]) {
             case '=':
                 set(,l,r,x);
                 break;
             case '?':
                 printf("%lld\n",que(l,r,x));
                 break;
         }
     }
     return ;
 }

2000个字刚好= =

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

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

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

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

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

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