102 条题解

  • 12
    @ 2023-5-13 16:33:18

    任何一个伟大的梦想,都有一个微不足道的开始。

    但这个微不足道的开始可就不要抄题解了哟~

    #include<iostream>
    using namespace std;
    int a,b;
    int main(){
    	scanf("%d%d",&a,&b);
    	printf("%d",a+b);
    	return 0;
    }
    
  • 0
    @ 2023-11-19 16:21:28
    #include<iostream>
    using namespace std;
    int a,b;
    int main(){
    	scanf("%d%d",&a,&b);
    	printf("%d",a+b);
    	return 0;
    }
    
    • 0
      @ 2023-11-19 16:21:19
      #include<iostream>
      using namespace std;
      int a,b;
      int main(){
      	scanf("%d%d",&a,&b);
      	printf("%d",a+b);
      	return 0;
      }
      
      • 0
        @ 2023-10-21 9:07:46

        5

        • 0
          @ 2023-10-21 9:07:43

          4

          • 0
            @ 2023-10-21 9:07:32

            1

            • -1
              @ 2023-10-21 16:20:43

              终于可以写一份A+B这么难的题的题解了。

              咦?竟然没有人写LCT的题解?

              Link-Cut Tree 会很伤心的!

              ORZ为了不让LCT伤心于是我来一份LCT的A+B题解吧!

              送上代码:`

              #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;
              }
              
              
              
              • -2
                @ 2023-10-21 9:10:00

                10

                • -2
                  @ 2023-10-21 9:09:53

                  8

                  • -2
                    @ 2023-10-21 9:09:50

                    7

                    • -2
                      @ 2023-10-21 9:09:46

                      6

                      • -2
                        @ 2023-10-21 9:07:40

                        3

                        • -2
                          @ 2023-10-21 9:07:37

                          2

                          • -2
                            @ 2023-10-21 9:07:21

                            f

                            • -2
                              @ 2023-10-21 9:07:14

                              f

                              • -2
                                @ 2023-7-9 16:49:49
                                #include<bits/stdc++.h>
                                using namespace std;
                                int main(){
                                    int a;
                                    int b;
                                    cin>>a>>b;
                                    cout<<a+b;
                                     return 0;
                                }
                                
                                
                                • -2
                                  @ 2023-7-7 15:29:44

                                  #include<bits/stdc++.h> using namespace std; int main(){ cout<<1+3; return 0; }

                                  • -2
                                    @ 2023-6-3 9:49:08

                                    #include using namespace std; int a,b; int main(){ scanf("%d%d",&a,&b); printf("%d",a+b); return 0; }

                                    • -2
                                      @ 2023-5-27 8:46:09

                                      image

                                      信息

                                      ID
                                      1
                                      时间
                                      1000ms
                                      内存
                                      256MiB
                                      难度
                                      10
                                      标签
                                      递交数
                                      1057
                                      已通过
                                      359
                                      上传者