105 solutions

  • 101
    @ 2021-10-5 13:19:34

    尽管 A + B Problem 是十分经典的入门题目,也希望大家能够在题解区友善交流。 HydroOJ 致力于提供一个友善的交流学习平台,请不要发布误导性题解,谢谢! 您可以给您喜欢的题解投票,让更多的人看到它们。同时,题解的评分也会影响你在排名中的贡献一栏分数。

    我们认为优质的题解需要:代码高亮,简洁而有效的注解,思路清晰,便于理解,无冗长板子,不定义非常用宏。

    • 21
      @ 2021-8-24 13:40:55

      这题很简单,输入 aabb,然后输出他们的和即可。

      #include<iostream> //头文件
      using namespace std; //命名空间
      int main(){ //主函数,程序从这里开始
          int a,b; //定义变量
          cin>>a>>b; //输入
          cout<<a+b<<endl; //输出他们的和
          return 0; //主函数需要返回0
      }
      

      管理大大求过

      • @ 2023-12-31 14:00:33

        这道题应该用long long类型的变量进行存储因为数值范围是10610^6,int存不下,建议改一下

      • @ 2024-1-30 13:44:38

        @。 在大多数编程环境中,int 类型的大小通常为 4 字节(32 位),其范围为 -2,147,483,648 到 2,147,483,647(常见的采用补码表示法)。这是根据 C99 标准中的 INT_MIN(最小值)和 INT_MAX(最大值)来定义的。

    • 19
      @ 2021-10-13 17:00:49

      简单的入门测试题

      本题各种语言的程序写法:(不知道Hydro有没有这些语言

      C

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

      C++

      #include <iostream>
      #include <cstdio>
      
      using namespace std;
      
      int main()
      {
          int a,b;
          cin >> a >> b;
          cout << a+b << endl;
          return 0;
      }
      

      Pascal

      var a, b: longint;
      begin
          readln(a,b);
          writeln(a+b);
      end.
      

      Python2

      s = raw_input().split()
      print int(s[0]) + int(s[1])
      

      Python3

      s = input().split()
      print(int(s[0]) + int(s[1]))
      

      Java

      import java.io.*;
      import java.util.*;
      public class Main {
          public static void main(String args[]) throws Exception {
              Scanner cin=new Scanner(System.in);
              int a = cin.nextInt(), b = cin.nextInt();
              System.out.println(a+b);
          }
      }
      

      JavaScript (Node.js)

      const fs = require('fs')
      const data = fs.readFileSync('/dev/stdin')
      const result = data.toString('ascii').trim().split(' ').map(x => parseInt(x)).reduce((a, b) => a + b, 0)
      console.log(result)
      process.exit() // 请注意必须在出口点处加入此行
      

      Ruby

      a, b = gets.split.map(&:to_i)
      print a+b
      

      PHP

      <?php
      $input = trim(file_get_contents("php://stdin"));
      list($a, $b) = explode(' ', $input);
      echo $a + $b;
      

      Rust

      use std::io;
      
      fn main(){
          let mut input=String::new();
          io::stdin().read_line(&mut input).unwrap();
          let mut s=input.trim().split(' ');
      
          let a:i32=s.next().unwrap()
                     .parse().unwrap();
          let b:i32=s.next().unwrap()
                     .parse().unwrap();
          println!("{}",a+b);
      }
      

      Go

      package main
      
      import "fmt"
      
      func main() {
          var a, b int
          fmt.Scanf("%d%d", &a, &b)
          fmt.Println(a+b)
      }
      

      C# Mono

      using System;
      
      public class APlusB{
          private static void Main(){
              string[] input = Console.ReadLine().Split(' ');
              Console.WriteLine(int.Parse(input[0]) + int.Parse(input[1]));
          }
      }
      

      Visual Basic Mono

      Imports System
      
      Module APlusB
          Sub Main()
              Dim ins As String() = Console.ReadLine().Split(New Char(){" "c})
              Console.WriteLine(Int(ins(0))+Int(ins(1)))
          End Sub
      End Module
      

      Kotlin

      fun main(args: Array<String>) {
          val (a, b) = readLine()!!.split(' ').map(String::toInt)
          println(a + b)
      }
      

      Haskell

      main = do
          [a, b] <- (map read . words) `fmap` getLine
          print (a+b)
      

      Scala

      object Main extends App {
          println(scala.io.StdIn.readLine().split(" ").map(_.toInt).sum)
      }
      

      Perl

      my $in = <STDIN>;
      chomp $in;
      $in = [split /[\s,]+/, $in];
      my $c = $in->[0] + $in->[1];
      print "$c\n";
      

      文言

      施「require('fs').readFileSync」於「「/dev/stdin」」。名之曰「數據」。
      施「(buf => buf.toString().trim())」於「數據」。昔之「數據」者。今其是矣。
      施「(s => s.split(' '))」於「數據」。昔之「數據」者。今其是矣。
      注曰。「「文言尚菜,無對象之操作,故需 JavaScript 之语法」」。
      
      夫「數據」之一。取一以施「parseInt」。名之曰「甲」。
      夫「數據」之二。取一以施「parseInt」。名之曰「乙」。
      
      加「甲」以「乙」。書之。
      
      • @ 2024-1-25 17:08:05

        我的Python3

        print(int(input()) + int(input())
        

        得了(一行代码)

      • @ 2024-2-3 16:55:12

        只要你想就有

    • 11
      @ 2021-3-7 18:45:04
      #include<bits/stdc++.h>//万能头文件
      using namespace std;//使用标准命名空间
      int main()//主函数
      {
      	int a,b;
      	cin>>a>>b;
      	cout<<a+b;
      	return 0;//好习惯
      }
      
      • 6
        @ 2023-8-27 8:30:20

        这题是入门的基础题,可以用很多方法求解,下面是最简单的几种方法,讲解与代码奉上。

        1.普通解法:运用了普通计算机加法计算方法,C与C++代码如下:

        //c语言解法
        #include<cstdio>
        using namespace std;
        int main(){
            int a, b;
            scanf("%d%d", &a, &b);
            printf("%d%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;
        }
        

        2.LCT(Link-Cut Tree)解法:使用动态树来解这题,是较简单难的,不多说,代码奉上::

        #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);
                connect(A,B);
                cut(A,B);
                connect(A,B);
            printf("%d\n",query(A,B)); 
            return 0;
        }
        

        3.树状数组解法:也很“简单”,代码如下:

        #include<iostream>
        #include<cstring>
        using namespace std;
        int lowbit(int a)
        {
            return a&(-a);
        }
        int main()
        {
            int n=2,m=1;
            int ans[m+1];
            int a[n+1],c[n+1],s[n+1];
            int o=0;
            memset(c,0,sizeof(c));
            s[0]=0;
            for(int i=1;i<=n;i++)
            {
                cin>>a[i];
                s[i]=s[i-1]+a[i];
                c[i]=s[i]-s[i-lowbit(i)];
            }
            for(int i=1;i<=m;i++)
            {
                int q=2;
                if(q==1)
                {
                    int x,y;
                    cin>>x>>y;
                    int j=x;
                    while(j<=n)
                    {
                        c[j]+=y;
                        j+=lowbit(j);
                    }
                }
                else
                {
                    int x=1,y=2;//求a[1]+a[2]的和
                    int s1=0,s2=0,p=x-1;
                    while(p>0)
                    {
                        s1+=c[p];
                        p-=lowbit(p);
                    }
                    p=y;
                    while(p>0)
                    {
                        s2+=c[p];
                        p-=lowbit(p);
                    }    
                    o++;
                    ans[o]=s2-s1;
                }
            }
            for(int i=1;i<=o;i++)
                cout<<ans[i]<<endl;
            return 0;
        }
        

        4.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;
        }
        

        5.Dijkstra+STL的优先队列优化:代码如下:

        #include <iostream>
        #include <cstdio>
        #include <cstdlib>
        #include <cmath>
        #include <cctype>
        #include <climits>
        #include <algorithm>
        #include <map>
        #include <queue>
        #include <vector>
        #include <ctime>
        #include <string>
        #include <cstring>
        using namespace std;
        const int N=405;
        struct Edge {
            int v,w;
        };
        vector<Edge> edge[N*N];
        int n;
        int dis[N*N];
        bool vis[N*N];
        struct cmp {
            bool operator()(int a,int b) {
                return dis[a]>dis[b];
            }
        };
        int Dijkstra(int start,int end)
        {
            priority_queue<int,vector<int>,cmp> dijQue;
            memset(dis,-1,sizeof(dis));
            memset(vis,0,sizeof(vis));
            dijQue.push(start);
            dis[start]=0;
            while(!dijQue.empty()) {
                int u=dijQue.top();
                dijQue.pop();
                vis[u]=0;
                if(u==end)
                    break;
                for(int i=0; i<edge[u].size(); i++) {
                    int v=edge[u][i].v;
                    if(dis[v]==-1 || dis[v]>dis[u]+edge[u][i].w) {
                        dis[v]=dis[u]+edge[u][i].w;
                        if(!vis[v]) {
                            vis[v]=true;
                            dijQue.push(v);
                        }
                    }
                }
            }
            return dis[end];
        }
        int main()
        {
            int a,b;
            scanf("%d%d",&a,&b);
            Edge Qpush;
        
            Qpush.v=1;
            Qpush.w=a;
            edge[0].push_back(Qpush);
        
            Qpush.v=2;
            Qpush.w=b;
            edge[1].push_back(Qpush);
        
            printf("%d",Dijkstra(0,2));
            return 0;
        }
        

        6.模拟:模拟人工运算方法,代码如下:

        #include <iostream> 
        #include <cmath>
        using namespace std;
        int fu=1,f=1,a,b,c=0;
        int main()
        {
            cin>>a>>b;
            if(a<0&&b>0)fu=2;
            if(a>0&&b<0)fu=3;
            if(a<0&&b<0)f=-1;
            if(a==0){cout<<b;return 0;}
            if(b==0){cout<<a;return 0;} 
            a=abs(a);
            b=abs(b);
            if(a>b&&fu==3)f=1;
            if(b>a&&fu==3)f=-1;
            if(b>a&&fu==2)f=1;
            if(b<a&&fu==2)f=-1;
            if(fu==1)c=a+b;
            if(fu>1)c=max(a,b)-min(a,b);
            c*=f;
            cout<<c;
            return 0;
        }
        

        7.字典树:代码如下:

        #include<cstdio>
        #include<cstring>
        #include<cstdlib>
        #include<algorithm>
        using namespace std;
        struct node{
            int str[26];
            int sum;
        }s[1000];
        char str1[100];
        int t=0,tot=0,ss=0;
        bool f1;
        void built()
        {
            t=0;
            for(int i=0;i<strlen(str1);i++)
            {
                 if(str1[i]=='-'){
                     f1=true;continue;
                 }
                 if(!s[t].str[str1[i]-'0'])
                 s[t].str[str1[i]-'0']=++tot;
                 t=s[t].str[str1[i]-'0'];
                 s[t].sum=str1[i]-'0';
            }
        }
        int query()
        {
           int t=0;int s1=0;
           for(int i=0;i<strlen(str1);i++)
           {
                   if(str1[i]=='-') continue;
                   if(!s[t].str[str1[i]-'0']) return s1;
                   t=s[t].str[str1[i]-'0'];
                   s1=s1*10+s[t].sum;
           }
           return s1;
        }
        int main()
        {    
          for(int i=1;i<=2;i++)
          {
              f1=false;
              scanf("%s",str1);
            built();
            if(f1)
              ss-=query();
              else ss+=query();
          }
          printf("%d",ss);
          return 0;    
        }
        

        8.二进制:用二进制的计算方法计算,代码如下:

        #include<iostream>
        #include<cstdio>
        #include<cstdlib>
        #include<cmath>
        #include<algorithm>
        using namespace std;
        int main()
        {
            int a,b,s=0,s1=0,i=0,na=0,nb=0;
            cin>>a>>b;
            if(a<=0) na=1,a*=-1;
            while(a!=0)
            {
                if(a%2!=0)
                s+=pow(2,a%2*i);
                a/=2;
                i++;
            }
            i=0;
            if(na==1) s*=-1;
            if(b<=0) nb=1,b*=-1;
            while(b!=0)
            {
                if(b%2!=0)
                s1+=pow(2,b%2*i);
                b/=2;
                i++;
            }
            if(nb==1) s1*=-1;
            cout<<s+s1;;
            return 0;
        }
        

        9.最小生成树:代码如下:

        #include <cstdio>
        #include <algorithm>
        #define INF 2140000000
        using namespace std;
        struct tree{int x,y,t;}a[10];
        bool cmp(const tree&a,const tree&b){return a.t<b.t;}
        int f[11],i,j,k,n,m,x,y,t,ans;
        int root(int x){if (f[x]==x) return x;f[x]=root(f[x]);return f[x];}
        int main(){
            for (i=1;i<=10;i++) f[i]=i;
            for (i=1;i<=2;i++){
                scanf("%d",&a[i].t);
                a[i].x=i+1;a[i].y=1;k++;
            }
            a[++k].x=1;a[k].y=3,a[k].t=INF;
            sort(a+1,a+1+k,cmp);
            for (i=1;i<=k;i++){
                x=root(a[i].x);y=root(a[i].y);
                if (x!=y) f[x]=y,ans+=a[i].t; 
            }
            printf("%d\n",ans);
        }
        

        其他语言解法

        1.Pascal

        var a, b: longint;
        begin
            readln(a,b);
            writeln(a+b);
        end.
        

        2.Python2

        s = raw_input().split()
        print int(s[0]) + int(s[1])
        

        3.Python3

        s = input().split()
        print(int(s[0]) + int(s[1]))
        

        4.Java

        import java.io.*;
        import java.util.*;
        public class Main {
            public static void main(String args[]) throws Exception {
                Scanner cin=new Scanner(System.in);
                int a = cin.nextInt(), b = cin.nextInt();
                System.out.println(a+b);
            }
        }
        

        5.JavaScript (Node.js)

        const fs = require('fs')
        const data = fs.readFileSync('/dev/stdin')
        const result = data.toString('ascii').trim().split(' ').map(x => parseInt(x)).reduce((a, b) => a + b, 0)
        console.log(result)
        process.exit()
        

        6.php

        <?php
        $input = trim(file_get_contents("php://stdin"));
        list($a, $b) = explode(' ', $input);
        echo $a + $b;
        

        以上是我想出来的亿种方法,希望大家点个赞支持一下

        • 4
          @ 2021-11-1 16:48:34

          请大家不要发恶搞题解来误导新手,谢谢!

          Python 题解,输入 aabb,输出 a+ba+b
          提醒一句,Python 需要用 split() 切片,而且要转成 int 型。

          a=input().split()
          print(int(a[0])+int(a[1]))
          
          • @ 2024-1-18 21:02:38

            你可以在定义时就转成int

            a=int(input())
            
        • 3
          @ 2023-6-25 17:53:41

          c++:

          # include <bits/stdc++.h>
          using namespace std;
          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;scanf("%d%d", &a, &b);printf("%d", a + b);return 0;}
          

          python:

          # 加;是个人习惯
          a, b = map(int, input().split());
          print(a + b, end='');
          
          • 3
            @ 2022-12-22 10:49:25
            #include<iostream>
            using namespace std;
            int main()
            {
                int a,b;
                cin>>a>>b;
                cout<<a+b;
            }
            
            • 3
              @ 2022-11-9 21:16:25

              使用 C++ 风格的输入输出

              #include <bits/stdc++.h>//头文件,可以暂时理解为告诉编译器你要拿标准库中的函数来用
              using namespace std;    //如果不想引入整个 std 命名空间,你需要使用 
              int main() {            //std::cin、std::cout、std::endl
                  int a, b;           //定义整形变量 a 和 b,它们可存储的整数范围约为 ±21 亿,
                  cin >> a >> b;      //对于本题的数据范围绰绰有余;从标准输入中读入两个值并赋给 a, b
                  cout << a + b;      //输出结果。你也可以先使用另一个变量存储结果,但在这里没什么意义
                  return 0;           //返回 0 以外的值会让操作系统或在线判题系统认为你的程序异常退出
              }                       //最后的 return 0; 也可以不写,编译器会自动帮你加上正常退出
              

              使用 C 语言风格的输入输出

              #include <bits/stdc++.h>
              using namespace std;
              int main() {
                  int a, b;               //%d 是整形的占位符
                  scanf("%d %d", &a, &b); //输入非字符串时你需要在变量名前面加上取地址符 &
                  printf("%d", a + b);    //输出时不要加 &,否则你的输出会是一个地址而不是你想要的答案
                  return 0;               //其余的部分请看上面的注释
              }
              
              • 2
                @ 2024-1-7 13:23:33

                童鞋们你们好!

                打开这道题,就相当于你们迈出了万里 OI 路的第一步。让我们重视这一步!

                这里提醒同学们:好的代码风格是非常重要的。大家一定要养成良好的代码风格

                来看看我打的代码:

                #include<bits/stdc++.h> //万能头
                using namespace std; //使用std这个命名空间
                
                int main() {
                    int a, b; //1e6 int够用
                    cin >> a >> b; //cin = console+input 标准读入
                    cout << a + b; //cout = console+output 标准输出
                    return 0; //不要忘了一个华丽的结尾
                }
                

                最后想请童鞋们注意:强烈建议cin/cout<</>>符号前后打一个空格!这样能让你的代码更加美观!

                这就是我们万里编程路的第一步。在以后的刷题中,大家会遇到更多的难题。希望大家能不忘初心,砥砺前行! 说歪了

                感谢观看!

                • 2
                  @ 2023-10-3 19:28:15

                  极简版:

                  #include <iostream>
                  using namespace std;
                  int main(){int a,b;cin>>a>>b;cout<<a+b;return 0;}
                  
                  • @ 2024-1-18 21:00:16

                    还有更简洁的

                    # include <bits/stdc++.h>
                    using namespace std;int main() {int a, b;scanf("%d%d", &a, &b);printf("%d", a + b);return 0;}
                    
                • 1
                  @ 2024-2-5 21:13:26

                  这道题想必不用多说了吧,直接附上代码

                  
                  

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

                  
                  
                  • @ 2024-2-14 19:47:31

                    e……你可以复制代码时直接复制,等会如果没有再写仨 `

                • 1
                  @ 2024-1-28 14:00:03

                  题意

                  a+ba+b

                  思路

                  这题不需要思路

                  方法

                  也不需要方法

                  代码

                  #include <iostream> 
                  using namespace std; 
                  int main() { 
                      int a, b; 
                      cin >> a >> b; 
                      cout << a + b << endl; 
                      return 0; 
                  }
                  
                  • 1
                    @ 2024-1-19 13:11:50

                    A + B Probelm 氵到要死

                    C++的入门题吧,输入 aabb,输出a+ba+b

                    #include<bits/stdc++.h>
                    using namespace std;
                    int main(){
                        int a, b;
                        cin >> a >> b;
                        cout << a + b;
                        return 0;
                    }
                    
                    • 1
                      @ 2023-11-3 21:22:55

                      LCT解法

                      #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);
                              connect(A,B);
                              cut(A,B);
                              connect(A,B);
                          printf("%d\n",query(A,B)); 
                          return 0;
                      }
                      
                      • 1
                        @ 2023-9-24 11:48:26

                        A+B Problem

                        题解+思路

                        题解

                        #include <iostream>
                        using namespace std;
                        
                        struct Node
                        {
                            int data;
                            Node *prev;
                            Node *next;
                            Node(int val) : data(val), prev(nullptr), next(nullptr) {}
                        };
                        
                        Node *createList(int num)
                        {
                            Node *head = nullptr;
                            Node *tail = nullptr;
                            while (num > 0)
                            {
                                int digit = num % 10;
                                Node *newNode = new Node(digit);
                                if (head == nullptr)
                                {
                                    head = newNode;
                                    tail = newNode;
                                }
                                else
                                {
                                    newNode->next = head;
                                    head->prev = newNode;
                                    head = newNode;
                                }
                                num /= 10;
                            }
                            return head;
                        }
                        
                        Node *addTwoNumbers(Node *num1, Node *num2)
                        {
                            Node *result = nullptr;
                            Node *current = nullptr;
                            int carry = 0;
                        
                            while (num1 != nullptr || num2 != nullptr || carry != 0)
                            {
                                int sum = carry;
                        
                                if (num1 != nullptr)
                                {
                                    sum += num1->data;
                                    num1 = num1->next;
                                }
                        
                                if (num2 != nullptr)
                                {
                                    sum += num2->data;
                                    num2 = num2->next;
                                }
                        
                                carry = sum / 10;
                                sum %= 10;
                        
                                Node *newNode = new Node(sum);
                        
                                if (result == nullptr)
                                {
                                    result = newNode;
                                    current = newNode;
                                }
                                else
                                {
                                    current->prev = newNode;
                                    newNode->next = current;
                                    current = newNode;
                                }
                            }
                        
                            return result;
                        }
                        
                        void printList(Node *head)
                        {
                            if (head == nullptr)
                            {
                                cout << "Empty list" << endl;
                                return;
                            }
                        
                            while (head != nullptr)
                            {
                                cout << head->data;
                                head = head->next;
                            }
                            cout << endl;
                        }
                        
                        void deleteList(Node *head)
                        {
                            while (head != nullptr)
                            {
                                Node *temp = head;
                                head = head->next;
                                delete temp;
                            }
                        }
                        
                        int main()
                        {
                            int num1 = 12345;
                            int num2 = 6789;
                        
                            Node *list1 = createList(num1);
                            Node *list2 = createList(num2);
                        
                            cout << "Number 1: ";
                            printList(list1);
                        
                            cout << "Number 2: ";
                            printList(list2);
                        
                            Node *sumList = addTwoNumbers(list1, list2);
                        
                            cout << "Sum: ";
                            printList(sumList);
                        
                            deleteList(list1);
                            deleteList(list2);
                            deleteList(sumList);
                        
                            return 0;
                        }
                        

                        思路

                        1. 首先,定义一个双向链表的节点结构体,包含一个整数值和两个指针,分别指向前一个节点和后一个节点。
                        2. 创建两个双向链表,分别表示要相加的两个数字。可以通过遍历输入的整数,从个位开始,逐个创建节点并将其插入链表中。
                        3. 定义一个变量来表示进位,初始值为0。
                        4. 从链表的最后一个节点开始,逐位相加,并将结果存储在新的链表中。具体步骤如下: - 从两个链表的最后一个节点开始,分别取出对应的值,并加上进位。 - 将相加的结果对10取模得到当前位的值,同时更新进位为相加结果除以10的商。 - 创建一个新的节点,将当前位的值存储在该节点中,并将该节点插入到结果链表的头部。 - 分别将两个链表的指针指向上一个节点,继续下一位的相加操作。 - 如果其中一个链表已经遍历完,但另一个链表还有剩余位数,则将剩余位数与进位相加,并将结果插入到结果链表中
                        5. 最后,得到的结果链表即为相加后的结果。
                        • 0
                          @ 2024-2-16 9:02:02

                          #include <bits/stdc++.h> using namespace std;
                          int main() {
                          int a, b;
                          cin >> a >> b;
                          cout << a + b;
                          return 0;
                          }
                          兄啊,这是给若至做的罢(恼

                          • 0
                            @ 2024-2-12 16:41:46

                            很简单,其实输出 a+b 即可。

                            #include<bits/stdc++.h>
                            using namespace std;
                            int main()
                            {
                                int a,b;
                                cin>>a>>b;
                                cout<<a+b;
                                return 0;
                            }
                            
                            • @ 2024-2-16 10:55:36

                              其实需要高精度

                          • 0
                            @ 2024-1-18 20:58:43
                            #include<bits/stdc++.h>
                            using namespace std;
                            struct Plus{
                            long long a,b;
                            void in(){
                            cin>>a>>b;
                            }
                            void out(){
                            cout<<a+b;
                            }
                            };
                            int main(){
                            Plus a_plus_b;
                            a_plus_b.in();
                            a_plus_b.out();
                            return 0;
                            }
                            
                            
                            • 0
                              @ 2024-1-13 10:27:45

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

                              return 0;
                              

                              } 这都不会就过分了啊 👍

                              Information

                              ID
                              56
                              Time
                              1000ms
                              Memory
                              1024MiB
                              Difficulty
                              1
                              Tags
                              # Submissions
                              6540
                              Accepted
                              2840
                              Uploaded By