8 条题解

  • 10
    @ 2023-8-11 13:33:59

    一种很新的代码

    #include<bits/stdc++.h>
    using namespace std;
    int add(int a,int b)
    {
    	if (!a) return b;
    	return add((a&b)<<1,a^b);
    }
    int main()
    {
    	int a,b;
    	cin>>a>>b;
    	cout<<add(a,b);
    	return 0;
    }
    
    • 4
      @ 2023-5-25 18:00:48

      A+B Problem 那么难的题目,我们怎么可能会做呢?只能用 Python 逝世了。

      a,b=map(int,input().split())
      print(a+b)
      
      • @ 2023-5-28 13:48:29

        sto zjs orz\texttt{sto zjs orz}

    • 4
      @ 2023-4-8 14:35:46
      //一颗资瓷区间加、区间翻转、区间求和的Splay
      #include <bits/stdc++.h>
      #define ll long long
      #define N 100000
      using namespace std;
      int sz[N], rev[N], tag[N], sum[N], ch[N][2], fa[N], val[N];
      int n, m, rt, x;
      void push_up(int x){
          sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + 1;
          sum[x] = sum[ch[x][1]] + sum[ch[x][0]] + val[x];
      }
      void push_down(int x){
          if(rev[x]){
              swap(ch[x][0], ch[x][1]);
              if(ch[x][1]) rev[ch[x][1]] ^= 1;
              if(ch[x][0]) rev[ch[x][0]] ^= 1;
              rev[x] = 0;
          }
          if(tag[x]){
              if(ch[x][1]) tag[ch[x][1]] += tag[x], sum[ch[x][1]] += tag[x];
              if(ch[x][0]) tag[ch[x][0]] += tag[x], sum[ch[x][0]] += tag[x];
              tag[x] = 0;
          }
      }
      void rotate(int x, int &k){
          int y = fa[x], z = fa[fa[x]];
          int kind = ch[y][1] == x;
          if(y == k) k = x;
          else ch[z][ch[z][1]==y] = x;
          fa[x] = z; fa[y] = x; fa[ch[x][!kind]] = y;
          ch[y][kind] = ch[x][!kind]; ch[x][!kind] = y;
          push_up(y); push_up(x);
      }
      void splay(int x, int &k){
          while(x != k){
              int y = fa[x], z = fa[fa[x]];
              if(y != k) if(ch[y][1] == x ^ ch[z][1] == y) rotate(x, k);
              else rotate(y, k);
              rotate(x, k);
          }
      }
      int kth(int x, int k){
          push_down(x);
          int r = sz[ch[x][0]]+1;
          if(k == r) return x;
          if(k < r) return kth(ch[x][0], k);
          else return kth(ch[x][1], k-r);
      }
      void split(int l, int r){
          int x = kth(rt, l), y = kth(rt, r+2);
          splay(x, rt); splay(y, ch[rt][1]);
      }
      void rever(int l, int r){
          split(l, r);
          rev[ch[ch[rt][1]][0]] ^= 1;
      }
      void add(int l, int r, int v){
          split(l, r);
          tag[ch[ch[rt][1]][0]] += v;
          val[ch[ch[rt][1]][0]] += v;
          push_up(ch[ch[rt][1]][0]);
      }
      int build(int l, int r, int f){
          if(l > r) return 0;
          if(l == r){
              fa[l] = f;
              sz[l] = 1;
              return l;
          }
          int mid = l + r >> 1;
          ch[mid][0] = build(l, mid-1, mid);
          ch[mid][1] = build(mid+1, r, mid);
          fa[mid] = f;
          push_up(mid);
          return mid;
      }
      int asksum(int l, int r){
          split(l, r);
          return sum[ch[ch[rt][1]][0]];
      }
      int main(){
          //总共两个数
          n = 2;
          rt = build(1, n+2, 0);//建树
          for(int i = 1; i <= n; i++){
              scanf("%d", &x);
              add(i, i, x);//区间加
          }
          rever(1, n);//区间翻转
          printf("%d\n", asksum(1, n));//区间求和
          return 0;
      }
      
    • 2
      @ 2023-5-13 13:24:40

      区间DP

      #include<bits/stdc++.h>
      using namespace std;
      int f[305][305],a[305],sum[305];
      int main(){
      	int n;
      	n=2;//两堆果子
      	for(int i=1;i<=n;i++){
      		scanf("%d",&a[i]);
      		sum[i]+=sum[i-1]+a[i];//前缀和加快速度
      	}
      	for(int l=1;l<=n;l++){//注意,按照合并的堆数循环
      		for(int i=1;i<=n-l+1;i++){//小心越界
      			int j=l+i-1;//j通过i,l得到
      			if(i!=j)f[i][j]=INT_MAX;//设为最大(初始化)
      			for(int k=i;k<j;k++){//枚举中间点
      				f[i][j]=min(f[i][k]+f[k+1][j]+sum[j]-sum[i-1],f[i][j]);//转移方程
      			}
      		}
      	}
      	printf("%d\n",f[1][n]);//输出
      	return 0;
      }
      
    • 0
      @ 2025-10-5 21:24:28

      世界上最难的题目

      #pragma GCC optimize(2)
      #pragma GCC optimize(3)
      #pragma GCC optimize("Ofast")
      #pragma GCC optimize("inline")
      #pragma GCC optimize("-fgcse")
      #pragma GCC optimize("-fgcse-lm")
      #pragma GCC optimize("-fipa-sra")
      #pragma GCC optimize("-ftree-pre")
      #pragma GCC optimize("-ftree-vrp")
      #pragma GCC optimize("-fpeephole2")
      #pragma GCC optimize("-ffast-math")
      #pragma GCC optimize("-fsched-spec")
      #pragma GCC optimize("unroll-loops")
      #pragma GCC optimize("-falign-jumps")
      #pragma GCC optimize("-falign-loops")
      #pragma GCC optimize("-falign-labels")
      #pragma GCC optimize("-fdevirtualize")
      #pragma GCC optimize("-fcaller-saves")
      #pragma GCC optimize("-fcrossjumping")
      #pragma GCC optimize("-fthread-jumps")
      #pragma GCC optimize("-funroll-loops")
      #pragma GCC optimize("-fwhole-program")
      #pragma GCC optimize("-freorder-blocks")
      #pragma GCC optimize("-fschedule-insns")
      #pragma GCC optimize("inline-functions")
      #pragma GCC optimize("-ftree-tail-merge")
      #pragma GCC optimize("-fschedule-insns2")
      #pragma GCC optimize("-fstrict-aliasing")
      #pragma GCC optimize("-fstrict-overflow")
      #pragma GCC optimize("-falign-functions")
      #pragma GCC optimize("-fcse-skip-blocks")
      #pragma GCC optimize("-fcse-follow-jumps")
      #pragma GCC optimize("-fsched-interblock")
      #pragma GCC optimize("-fpartial-inlining")
      #pragma GCC optimize("no-stack-protector")
      #pragma GCC optimize("-freorder-functions")
      #pragma GCC optimize("-findirect-inlining")
      #pragma GCC optimize("-fhoist-adjacent-loads")
      #pragma GCC optimize("-frerun-cse-after-loop")
      #pragma GCC optimize("inline-small-functions")
      #pragma GCC optimize("-finline-small-functions")
      #pragma GCC optimize("-ftree-switch-conversion")
      #pragma GCC optimize("-foptimize-sibling-calls")
      #pragma GCC optimize("-fexpensive-optimizations")
      #pragma GCC optimize("-funsafe-loop-optimizations")
      #pragma GCC optimize("inline-functions-called-once")
      #pragma GCC optimize("-fdelete-null-pointer-checks")
      #include<iostream>
      #include<cstring>
      #include<cstdio>
      #include<cstring>
      using namespace std;
      struct node 
      {
          int data,rev,sum;
          node *son[2],*pre;
          bool judge();
          bool isroot();
          void pushdown();
          void update();
          void setson(node *child,int lr);
      }lct[233];
      int top,a,b;
      node *getnew(int x)
      {
          node *now=lct+ ++top;
          now->data=x;
          now->pre=now->son[1]=now->son[0]=lct;
          now->sum=0;
          now->rev=0;
          return now;
      }
      bool node::judge(){return pre->son[1]==this;}
      bool node::isroot()
      {
          if(pre==lct)return true;
          return !(pre->son[1]==this||pre->son[0]==this);
      }
      void node::pushdown()
      {
          if(this==lct||!rev)return;
          swap(son[0],son[1]);
          son[0]->rev^=1;
          son[1]->rev^=1;
          rev=0;
      }
      void node::update(){sum=son[1]->sum+son[0]->sum+data;}
      void node::setson(node *child,int lr)
      {
          this->pushdown();
          child->pre=this;
          son[lr]=child;
          this->update();
      }
      void rotate(node *now)
      {
          node *father=now->pre,*grandfa=father->pre;
          if(!father->isroot()) grandfa->pushdown();
          father->pushdown();now->pushdown();
          int lr=now->judge();
          father->setson(now->son[lr^1],lr);
          if(father->isroot()) now->pre=grandfa;
          else grandfa->setson(now,father->judge());
          now->setson(father,lr^1);
          father->update();now->update();
          if(grandfa!=lct) grandfa->update();
      }
      void splay(node *now)
      {
          if(now->isroot())return;
          for(;!now->isroot();rotate(now))
          if(!now->pre->isroot())
          now->judge()==now->pre->judge()?rotate(now->pre):rotate(now);
      }
      node *access(node *now)
      {
          node *last=lct;
          for(;now!=lct;last=now,now=now->pre)
          {
              splay(now);
              now->setson(last,1);
          }
          return last;
      }
      void changeroot(node *now)
      {
          access(now)->rev^=1;
          splay(now);
      }
      void connect(node *x,node *y)
      {
          changeroot(x);
          x->pre=y;
          access(x);
      }
      void cut(node *x,node *y)
      {
          changeroot(x);
          access(y);
          splay(x);
          x->pushdown();
          x->son[1]=y->pre=lct;
          x->update();
      }
      int query(node *x,node *y)
      {
          changeroot(x);
          node *now=access(y);
          return now->sum;
      }
      int main()
      {
          scanf("%d%d",&a,&b);
          node *A=getnew(a);
          node *B=getnew(b);
          //连边 Link
              connect(A,B);
          //断边 Cut
              cut(A,B);
          //再连边orz Link again
              connect(A,B);
          printf("%d\n",query(A,B)); 
          return 0;
      }
      
      • 0
        @ 2023-3-9 19:29:59

        本题代码:

        C

        #include<stdio.h>
        int main()
        {
        	int a,b;
        	scanf("%d%d",&a,&b);
        	printf("%d",a+b);
        	return 0;
        }
        

        C++

        #include<bits/stdc++.h>
        using namespace std;
        int main()
        {
        	int a,b;
        	cin>>a>>b;
        	cout<<a+b;
        	return 0;
        }
        

        Python

        a,b=map(int,input().split())
        print(a+b)
        
        • -1
          @ 2024-1-25 17:19:02

          c++🚀️ (头文件都会吧) { int a,b; cin >> a >> b; cout << a+b << endl; } //so easy;

          • -4
            @ 2023-12-15 19:30:32
            #include<bits/stdc++.h>
            using namespace std;
            int main(){
            	int a,b;
            	cin>>a>>b;
            	cout<<a+b;
            	exit(114514);
            }
            如果这样提交会发生什么
            
            • 1

            信息

            ID
            1
            时间
            1000ms
            内存
            64MiB
            难度
            1
            标签
            (无)
            递交数
            720
            已通过
            370
            上传者