p0001 A+B Problem

已于 2023-08-30 09:57:49 修改
阅读量222 收藏 2
点赞数 3
文章标签： 算法
于 2023-08-29 16:18:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuguanyugg/article/details/132563395
版权

 此题是一个超级无敌简单的基础题

最最最最最简单小垃圾都能写的代码：

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

上重量级了！

 树状数组解法：也很“简单”，代码如下：

#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;
}

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

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

模拟：

#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;
}

字典树：

#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;    
}

二进制：

#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;
}

最小生成树：

#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);
}

高精度

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
using namespace std;
const int N = 1005;
struct bign
{
    int len,s[N];
    bign()  {  memset(s,0,sizeof(s));  len=1;  }
    bign(int num)  {  *this=num; }
    bign(char *num) { *this=num; }
    bign operator =(int num)
    {
        char c[N];
        sprintf(c,"%d",num);
        *this=c;
        return *this;
    }
    bign operator =(const char *num)
    {
        len=strlen(num);
        for (int i=0;i<len;i++) s[i]=num[len-1-i]-'0';
        return *this;
    }
    string str()
    {
        string res="";
        for (int i=0;i<len;i++) res=(char)(s[i]+'0')+res;
        return res;
    }
    void clean()
    {
        while (len>1&&!s[len-1]) len--;
    }
    bign operator +(const bign &b)
    {
        bign c;    
        c.len=0;
        for (int i=0,g=0;g||i<len||i<b.len;i++)
        {
            int x=g;
            if (i<len) x+=s[i];
            if (i<b.len) x+=b.s[i];
            c.s[c.len++]=x%10;
            g=x/10;
        }
        return c;
    }
    bign operator -(const bign &b)
    {
        bign c;
        c.len=0;
        int x;     
        for (int i=0,g=0;i<len;i++)
        {
            x=s[i]-g;
            if (i<b.len) x-=b.s[i];
            if (x>=0) g=0;
            else{          
                x+=10;
                g=1;
            };
            c.s[c.len++]=x;
        }
        c.clean();
        return c;
    }
    bign operator *(const bign &b)
    {
        bign c;
        c.len=len+b.len;
        for (int i=0;i<len;i++) for (int j=0;j<b.len;j++) c.s[i+j]+=s[i]*b.s[j];
        for (int i=0;i<c.len-1;i++) { c.s[i+1]+=c.s[i]/10; c.s[i]%=10; }
        c.clean();
        return c;  
    }
    bool operator <(const bign &b)
    {
        if (len!=b.len) return len<b.len;
        for (int i=len-1;i>=0;i--)
             if (s[i]!=b.s[i]) return s[i]<b.s[i];
        return false;
    }
    bign operator +=(const bign &b)
    {
        *this=*this+b;
        return *this;
    }
    bign operator -=(const bign &b)
    {
        *this=*this-b;
        return *this;
    }  
};
istream& operator >>(istream &in,bign &x)
{
  string s;
  in>>s;
  x=s.c_str();
  return in;
}
ostream& operator <<(ostream &out,bign &x)
{
    out<<x.str();
    return out;
}
int main(){
    bign a,b,c;
    ios::sync_with_stdio(false);
    cin>>a>>b;
    c=a+b;
    cout<<c<<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])

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

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()

PHP

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

以上是我干出来的亿种方法，希望大家点个大大的赞，支持一下我这个小新手qwq

感谢大家的支持！

liuguanyugg
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
P1601_A+B Problem（高精）(JAVA语言)
张夷陵的博客
05-06 2544
思路：BigInteger first blood！ //四行搞定 题目背景 无 题目描述 高精度加法,x相当于a+b problem，[b][color=red]不用考虑负数[/color][/b] 输入输出格式 输入格式： 分两行输入a,b<=10^500 输出格式： 输出只有一行，代表A+B的值 输入输出样例 输入样例#1：复制 1...
A + B Problem II（高精度运算）
Andersen的博客
12-21 3483
Click here to have a try Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Problem Description I have a very simple problem for you. Given two integers A and B, your...
P1001 A+B Problem 题解
r5418855555的博客
10-04 666
P1001 A+B Problem题解
P1001 A+B Problem（python）
青少年趣味编程
01-25 707
https://www.luogu.com.cn/problem/P1001 http://noi.openjudge.cn/ch0103/01/ python代码方法一： a,b=map(int,input().split()) print(a+b) python代码方法二： """ P1001 A+B Problem https://www.luogu.com.cn/problem/P1001 1.3编程基础之算术表达式与顺序执行 01 A+B问题 http://noi.openju
P1601 A+B Problem（高精）(洛谷题解) 高精度加法
LeungSr的博客
04-06 3692
文章目录题目描述一、高精度加法二、题解1.字符数组置逆2.值得注意的是...3.运行与测试写在最后 题目描述 高精度加法，相当于a+b problem，不用考虑负数. 输入格式 分两行输入。a,b≤10500a,b \leq 10^{500}a,b≤10500 500 输出格式 输出只有一行，代表a+b的值 输入#1 1 1 输出#1 2 输入#2 1001 9099 输出#2 10100 一、高精度加法 高精度加法的核心思想就是当遇到比较大的数值时，使用数组存储各个位置的数值，temp存储进.
C++ P1601 A+B Problem（高精）
Zr1ose的博客
03-31 773
高精度加法，相当于 a+b problem，
洛谷P1601 A+B Problem（高精）C语言
Prudento的博客
12-29 1960
A+B problem 高精度加法 C语言（代码详解和注释）
洛谷入门题--P1001A+B problem
qq_61466402的博客
10-31 1449
题目描述 输入两个整数a,b，输出它们的和（|a|,|b| \le {10}^9∣a∣,∣b∣） 输入格式 两个以空格分开的整数。 输出格式 一个整数。 输入输出样例 输入 20 30 输出 50 源码 #include<stdio.h> int main(){ int a,b; scanf("%d%d",&a,&b); printf("%d",a+b); return 0;} ...
高精度——A+B Problem(洛谷 P1601)
青春无问西东 岁月自成芳华
08-18 2821
高精度算法指的是可以计算很大整数的高精度运算的方法 此题选自洛谷P1601 用数组来模拟非常长的整数，这意味着可以用数组的每一位记录那个数字上的每一位。 也就是说，可以用n位数组来记录一个n位数字。 对于该题加法，我们选择从低位到高位进行处理进位，将从低位开始计算到的结果 存放到C数组中，然后逆序输出C数组的数字即可！
洛谷P1001#A+B Problem（Python实现）
给我一点温度
08-08 1393
题目描述 输入两个整数a,b，输出它们的和(|a|,|b|<=10^9)。 输入格式 两个整数以空格分开 输出格式 一个数 解答 a,b=map(int,list(input().split())) print(a+b) 编程语言Python 3 代码长度51B 用时78ms 内存3.64MB ...
洛谷题解：P1001-A+B Problem
最新发布
04-16
洛谷题解：P1001-A+B Problem
A+Bproblem完整代码
11-07
下载超过3次或对应题解文章点赞超过1个便开放免费下载！
FR.zip_FR_FR Conjugate_problem solving
09-24
在FR方法中，每一步的搜索方向p_k是前一步的梯度方向g_{k-1}的共轭方向，即满足A(p_k, p_k) = A(g_{k-1}, g_{k-1})，并且p_k是沿着这个方向的最小二乘修正。更新公式通常为： p_k = -g_k + α_k * p_{k-1} 其中，...
密码学-4A 有限域的性质+多项式算术+DLP1
08-03
此外，乘法运算满足分配律，并且对于所有a和b，(a+b)^p = a^p + b^p。当p为素数时，这个性质称为费马小定理。 素域Fp的乘法群Fp*，即除去0的所有元素组成的集合，是一个循环群。这意味着存在一个生成元g，通过g的幂...
大数高精加减乘除（洛谷P1601、P2142、P1303、P1480题题解，Java语言描述）
12-22
P1601 → A+B Problem 题目要求 P1601题目链接 AC代码（Java语言描述） import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); ...
problemas-t09-matrices:主题编程问题的解决方案1
04-26
3. **矩阵乘法**：两个矩阵相乘（假设A是m×n矩阵，B是n×p矩阵），结果矩阵C的维度为m×p，计算公式为C[i][j] = Σ(A[i][k] * B[k][j])，其中k从0到n-1。 4. **转置**：矩阵的转置操作交换了它的行和列，即A的转置...
wangjunrui666#bzoj-problem##1614. [Usaco2007 Jan]Telephone Lines
07-25
第1行: 3个用空格隔开的整数：N，P，以及K第2..P+1行: 第i+1行为3个用空格隔开的整数：A_i，B_i，L_i第1行: 输出1个整数，为FJ在这项工
Bayes' Theorem Examples: A Visual Introduction For Beginners
10-19
A short tutorial on how to understand problem scenarios and find P(B), P(A), and P(B|A). - For many people, knowing how to approach scenarios and break them apart can be daunting. In this booklet, we...
matlab代码影响-boxqp:Matlab二次程序求解器的本原对偶路径
05-22
(1/2)x'*P*x + q'*x subject to A*x = b, (dual var y) G*x + s = h, (dual var z >= 0) s >= 0. 带有变量x ， s和问题数据P ， q ， A ， b ， G和h 。 截屏 用法 以最简单的形式，可以使用以下语法调用boxqp ： % ...
p1601 a+b problem（高精）
03-16
题目描述： 给定两个正整数a和b，输出它们的和。 输入格式： 第一行输入一个正整数n，表示a的位数。 第二行输入n个数字，表示a的每一位。 第三行输入一个正整数m，表示b的位数。 第四行输入m个数字，表示b的每一位。 a和b的位数均不超过100位。 输出格式： 输出两个正整数a和b的和。 样例输入： 4 1 3 9 9 9 样例输出： 10099 算法1： (高精度加法) $O(n)$ 1.将两个数的每一位相加，注意进位。 时间复杂度 参考文献 C++ 代码 算法2： (暴力枚举) $O(n^2)$ blablabla 时间复杂度 参考文献 C++ 代码

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值