csps模拟9495凉宫春日的忧郁，漫无止境的八月，简单计算，格式化，真相题解

题面：https://www.cnblogs.com/Juve/articles/11767239.html

94，95的T3都没改出来，是我太菜了。。。

凉宫春日的忧郁：

比较$x^y$和$y!$的大小，如果打高精会T掉

正解：把两个数取log，则$log_2x^y=ylog_2x$，$log_2y!=\sum\limits_{i=1}^{y}log_2i$

然后就A了

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #define int long long
 using namespace std;
 int t,x,y;
 signed main(){
     freopen("yuuutsu.in","r",stdin);
     freopen("yuuutsu.out","w",stdout);
     scanf("%lld",&t);
     while(t--){
         scanf("%lld%lld",&x,&y);
         long double xx=y*log2(x);
         long double yy=0.0;
         for(int i=;i<=y;++i){
             yy+=log2(i);
         }
         if(xx<=yy) puts("Yes");
         else puts("No");
     }
     return ;
 }

漫无止境的八月：

如果满足的话必须保证所有%k同余的位置上的和一样，所以打个map就好了。。。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<unordered_map>
 using namespace std;
 const int MAXN=2e6+;
 int read(){
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){
         if(ch=='-') f=-;
         ch=getchar();
     }
     while(ch>=''&&ch<=''){
         x=(x<<)+(x<<)+ch-'';
         ch=getchar();
     }
     return x*f;
 }
 int n,k,q,a[MAXN],sum[MAXN];
 unordered_map<int,int>mp;
 signed main(){
     freopen("august.in","r",stdin);
     freopen("august.out","w",stdout);
     n=read(),k=read(),q=read();
     for(int i=;i<=n;++i){
         a[i]=read();
         sum[i%k]+=a[i];
     }
     for(int i=;i<k;++i) ++mp[sum[i%k]];
     if(mp[sum[]]==k) puts("Yes");
     else puts("No");
     for(int i=;i<=q;++i){
         int pos=read(),val=read();
         a[pos]+=val;
         --mp[sum[pos%k]];
         sum[pos%k]+=val;
         ++mp[sum[pos%k]];
         if(mp[sum[]]==k) puts("Yes");
         else puts("No");
     }
     return ;
 }
 /*
 5 2 5
 1 1 1 2 1
 3 −1
 1 −1
 3 1
 3 1
 1 −1
 */

简单计算：

$2*\sum\limits_{i=0}^{p}\lfloor\frac{i*q}{p}\rfloor=\sum\limits_{i=0}^{p}\lfloor\frac{i*q}{p}\rfloor+\lfloor\frac{(p-i)*q}{p}\rfloor$

所以原式=$(p+1)*q-\sum\limits_{i=0}^{p}[(p|i*q)?0:1]=(p+1)*q-p+gcd(p,q)$

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define int long long
 using namespace std;
 int t,p,q,ans;
 int gcd(int a,int b){
     return b==?a:gcd(b,a%b);
 }
 signed main(){
     freopen("simplecalc.in","r",stdin);
     freopen("simplecalc.out","w",stdout);
     scanf("%lld",&t);
     while(t--){
         scanf("%lld%lld",&p,&q);
         ans=(p+)*q-p+gcd(p,q);
         printf("%lld\n",ans>>);
     }
     return ;
 }

格式化：

一个贪心，肯定是先选对容量有贡献的，即格式化后容量增加的，再选容量不增的，再选容量减少的，对于容量增加的，内部按格式化前从小到大排序，对于容量减小的，内部按格式化后的从大到小排序，然后check即可

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define int long long
 using namespace std;
 const int MAXN=1e6+;
 int n,ans=0x3f3f3f3f3f3f3f3f,l,r;
 struct node{
     int pre,now,w;
     friend bool operator < (node p,node q){
         if(p.w>&&q.w>){
             return p.pre<q.pre;
         }
         if(p.w<&&q.w<){
             return p.now>q.now;
         }
         if(p.w==&&q.w==){
             return p.pre>q.pre;
         }
         if(p.w==){
             return q.w<;
         }
         if(q.w==){
             return p.w>;
         }
         if(p.w>&&q.w<) return ;
         if(p.w<&&q.w>) return ;
         return ;
     }
 }a[MAXN];
 bool check(int val){
     for(int i=;i<=n;++i){
         if(a[i].pre>val) return ;
         val-=a[i].pre,val+=a[i].now;
     }
     return ;
 }
 signed main(){
     freopen("reformat.in","r",stdin);
     freopen("reformat.out","w",stdout);
     scanf("%lld",&n);
     for(int i=;i<=n;++i){
         scanf("%lld%lld",&a[i].pre,&a[i].now);
         r+=a[i].pre;
         a[i].w=a[i].now-a[i].pre;
     }
     sort(a+,a+n+);
     while(l<r){
         int mid=(l+r)>>;
         if(check(mid)) ans=min(ans,mid),r=mid;
         else l=mid+;
     }
     printf("%lld\n",ans);
     return ;
 }

真相：

我好弱啊，我太菜了

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 using namespace std;
 const int MAXN=1e6+;
 int t,n,sta[MAXN],top=,tru[MAXN],sum0[MAXN],sum1[MAXN],f[MAXN],g[MAXN];
 struct node{
     int opt,val;
 }a[MAXN];
 bool flagg=;
 int calc(int p){
     return (p-!=)?(p-):n;
 }
 vector<int>v[MAXN];
 signed main(){
     freopen("truth.in","r",stdin);
     freopen("truth.out","w",stdout);
     scanf("%d",&t);
     while(t--){
         top=flagg=;
         scanf("%d",&n);
         for(int i=;i<=n;++i){
             char op[];
             scanf("%s",op);
             if(op[]=='+'){
                 a[i].opt=;
             }else if(op[]=='-'){
                 a[i].opt=;
             }else{
                 a[i].opt=;
                 scanf("%d",&a[i].val);
                 flagg=;
                 sta[++top]=i;
             }
         }
         if(!flagg){
             bool now=;
             for(int i=;i<=n;++i){
                 if(now==){
                     if(a[i].opt==){
                         now=;
                     }else now=;
                 }else{
                     if(a[i].opt==){
                         now=;
                     }else now=;
                 }
             }
             if(now==) puts("consistent");
             else puts("inconsistent");
             continue;
         }else{
             bool flag=;
             for(int i=;i<=top;++i){
                 int yy=sta[i];
                 ++sum1[yy];
                 int p=yy;
                 bool now=;
                 while(a[calc(p)].opt!=){
                     p=calc(p);
                     if(now==){
                         if(a[p].opt==) now=;
                         else now=;
                     }else{
                         if(a[p].opt==) now=;
                         else now=;
                     }
                     sum1[yy]+=now;
                 }
                 p=yy;
                 now=;
                 while(a[calc(p)].opt!=){
                     p=calc(p);
                     if(now==){
                         if(a[p].opt==) now=;
                         else now=;
                     }else{
                         if(a[p].opt==) now=;
                         else now=;
                     }
                     sum0[yy]+=now;
                 }
             }
             int num=;
             for(int i=;i<=top;++i){
                 f[a[sta[i]].val]+=sum0[sta[i]];
                 g[a[sta[i]].val]+=sum1[sta[i]];
                 num+=sum0[sta[i]];
             }
             for(int i=;i<=n;++i){
                 num-=f[i];
                 num+=g[i];
                 if(num==i){
                     flag=;
                     break;
                 }
                 num-=g[i];
                 num+=f[i];
             }
             if(flag) puts("consistent");
             else puts("inconsistent");
             for(int i=;i<=top;++i){
                 f[a[sta[i]].val]=g[a[sta[i]].val]=;
                 sum0[sta[i]]=sum1[sta[i]]=;
             }
         }
     }
     return ;
 }
 /*
 1
 3
 $ 0
 -
 -

 */