权威

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

A+B Problem题解

新用户强烈建议阅读此帖

首先我们要理清思路

1.需要用到什么样的头文件？

2.用什么样的数据范围？

3.思路是什么？

首先题目中的数据范围是1≤a,b≤10^6, 而int 的范围是-2147483648-2147483647 正合题意，所以数据类型可以用int

话不多说，直接上代码

#include<iostream>//导入头文件，iostream里面是标准输入输出流（我说的什么？） 
using namespace std;//使用标准命名空间 
int main(){//主函数，程序的入口 
	int a,b;//创建a,b两个整型变量 
	cin>>a>>b;//输入 a , b 两个变量 
	cout<<a+b; //输出a+b的内容 
	return 0; 
}

本蒟蒻发的第一篇题解，请多多支持喵~~

谁不会这道题？？

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

其实是我不会

禁止发疯！！！

#include<bits/stdc++.h> using namespace std;

int main() { int a,b; cin>>a>>b; cout<<a+b; return 0; }

#include<bits/stdc++.h>//万能头文件
using namespace std;

int main(){
//定义int类型变量a,b
int a;
int b;
//输入变量a,b
scanf("%d",&a);
scanf("%d",&b);
//输出a,b
printf(" %d\n", a + b);
//exit(0); 或 return 0; 结束程序
return 0;
}

#include<bits/stdc++.h>
/*使用iostream库
导入cin和cout函数*/
using namespace std;
/*获取命名空间*/
int main(){//主函数
    int a,b;//定义整数变量
    cin>>a>>b;//输入数据
    cout<<a+b<<endl;//计算并输出数据

    return 0;//结束主函数
}

#include <iostream>
using namespace std;

int countSelections(int n, int m) {
    if (m == 0) return 1;
    if (n <= 0 || m < 0) return 0;
    if (m == 1) return n; // 选1本有n种选法
    
    return countSelections(n - 1, m) + countSelections(n - 2, m - 1);
}

int main() {
    int n, m;
    cin >> n >> m;
    cout << countSelections(n, m) << endl;
    return 0;
}

#include <iostream>
#include <queue>
using namespace std;

// 定义方向数组，表示马可以走的8个方向
const int dx[] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int dy[] = {1, 2, 2, 1, -1, -2, -2, -1};

struct Point {
    int x, y, steps;
    Point(int _x, int _y, int _s) : x(_x), y(_y), steps(_s) {}
};

int main() {
    int rows, cols;
    cin >> cols >> rows; // 注意题目先给列数再给行数
    
    char map[155][155];
    bool visited[155][155] = {false};
    queue<Point> q;
    int start_x, start_y, end_x, end_y;
    
    // 读取地图
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            cin >> map[i][j];
            if (map[i][j] == 'K') {
                start_x = i;
                start_y = j;
            } else if (map[i][j] == 'H') {
                end_x = i;
                end_y = j;
            }
        }
    }
    
    // BFS开始
    q.push(Point(start_x, start_y, 0));
    visited[start_x][start_y] = true;
    
    while (!q.empty()) {
        Point current = q.front();
        q.pop();
        
        // 如果到达终点
        if (current.x == end_x && current.y == end_y) {
            cout << current.steps << endl;
            return 0;
        }
        
        // 尝试8个方向
        for (int i = 0; i < 8; i++) {
            int nx = current.x + dx[i];
            int ny = current.y + dy[i];
            
            // 检查边界
            if (nx < 0 || nx >= rows || ny < 0 || ny >= cols) continue;
            
            // 检查是否已访问或是否是障碍物
            if (visited[nx][ny] || map[nx][ny] == '*') continue;
            
            // 标记为已访问并加入队列
            visited[nx][ny] = true;
            q.push(Point(nx, ny, current.steps + 1));
        }
    }
    
    // 如果无法到达
    cout << "-1" << endl;
    return 0;
}

#include <iostream>
using namespace std;

// 检查数字num是否可以放在(row,col)位置
bool isSafe(int grid[9][9], int row, int col, int num) {
    // 检查行
    for (int d = 0; d < 9; d++) {
        if (grid[row][d] == num) {
            return false;
        }
    }
    
    // 检查列
    for (int r = 0; r < 9; r++) {
        if (grid[r][col] == num) {
            return false;
        }
    }
    
    // 检查3x3小格子
    int boxStartRow = row - row % 3;
    int boxStartCol = col - col % 3;
    for (int r = boxStartRow; r < boxStartRow + 3; r++) {
        for (int d = boxStartCol; d < boxStartCol + 3; d++) {
            if (grid[r][d] == num) {
                return false;
            }
        }
    }
    
    return true;
}

// 数独求解函数
bool solveSudoku(int grid[9][9]) {
    int row, col;
    
    // 检查是否还有空格
    bool isEmpty = false;
    for (row = 0; row < 9; row++) {
        for (col = 0; col < 9; col++) {
            if (grid[row][col] == 0) {
                isEmpty = true;
                break;
            }
        }
        if (isEmpty) {
            break;
        }
    }
    
    // 如果没有空格了，数独已解
    if (!isEmpty) {
        return true;
    }
    
    // 尝试填入数字1-9
    for (int num = 1; num <= 9; num++) {
        if (isSafe(grid, row, col, num)) {
            grid[row][col] = num;
            
            if (solveSudoku(grid)) {
                return true;
            }
            
            // 回溯
            grid[row][col] = 0;
        }
    }
    
    return false;
}

// 打印数独
void printGrid(int grid[9][9]) {
    for (int row = 0; row < 9; row++) {
        for (int col = 0; col < 9; col++) {
            cout << grid[row][col];
            if (col != 8) {
                cout << " ";
            }
            // 九宫格之间加三个空格
            if (col == 2 || col == 5) {
                cout << "   ";
            }
        }
        cout << endl;
        // 九宫格之间加空行
        if (row == 2 || row == 5) {
            cout << endl;
        }
    }
}

int main() {
    int grid[9][9];
    
    // 读取输入
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            cin >> grid[i][j];
        }
    }
    
    if (solveSudoku(grid)) {
        printGrid(grid);
    } else {
        cout << "无解" << endl;
    }
    
    return 0;
}

#include <iostream>
#include <queue>
#include <set>
using namespace std;

void solve() {
    int N;
    cin >> N;
    
    int weights[N];
    for (int i =  0; i < N; i++) {
        cin >> weights[i];
    }
    
    set<int> result;
    queue<int> q;
    q.push(0);  // 初始状态，重量差为0
    
    for (int i = 0; i < N; i++) {
        int current_size = q.size();
        for (int j = 0; j < current_size; j++) {
            int current = q.front();
            q.pop();
            
            // 三种选择：不加砝码、加在左边、加在右边
            int option1 = current;
            int option2 = current + weights[i];
            int option3 = current - weights[i];
            
            if (option1 != 0) result.insert(abs(option1));
            if (option2 != 0) result.insert(abs(option2));
            if (option3 != 0) result.insert(abs(option3));
            
            q.push(option1);
            q.push(option2);
            q.push(option3);
        }
    }
    
    cout << result.size() << endl;
}

int main() {
    solve();
    return 0;
}

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

#include

using namespace std;

int main()

{

int a;

int b;

cin>>a>>b;

cout<<a+b;

return 0;

}

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
#include <ctime>
#include <vector>
#include <sstream>
#include <limits>

class MathUtils {
public:
    static int add(int a, int b) {
        return a + b;
    }
    
    static bool validateInput(int num) {
        return num >= 0 && num <= 10000;
    }
};

class Logger {
private:
    std::string filename;
    
public:
    Logger(const std::string& fname) : filename(fname) {}
    
    void log(const std::string& message) {
        std::ofstream file(filename, std::ios::app);
        if (file.is_open()) {
            time_t now = time(0);
            file << "[" << ctime(&now) << "] " << message << "\n";
        }
    }
    
    std::vector<std::string> readLogs() {
        std::vector<std::string> logs;
        std::ifstream file(filename);
        if (file.is_open()) {
            std::string line;
            while (getline(file, line)) {
                logs.push_back(line);
            }
        }
        return logs;
    }
};

class InputHandler {
public:
    static int getInteger(const std::string& prompt) {
        int value;
        while (true) {
            std::cout << prompt;
            if (std::cin >> value) {
                if (MathUtils::validateInput(value)) {
                    break;
                } else {
                    std::cout << "输入必须在0-10000范围内\n";
                }
            } else {
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                std::cout << "无效输入，请输入整数\n";
            }
        }
        return value;
    }
};

class TestRunner {
public:
    static void runTests() {
        testAddition();
        testInputValidation();
        std::cout << "所有测试通过\n";
    }
    
private:
    static void testAddition() {
        if (MathUtils::add(2, 3) != 5) {
            throw std::runtime_error("加法测试失败");
        }
        if (MathUtils::add(0, 0) != 0) {
            throw std::runtime_error("零加法测试失败");
        }
    }
    
    static void testInputValidation() {
        if (!MathUtils::validateInput(5000)) {
            throw std::runtime_error("输入验证测试失败");
        }
        if (MathUtils::validateInput(-1)) {
            throw std::runtime_error("负输入验证测试失败");
        }
    }
};

void displayMenu() {
    std::cout << "\n===== 高级加法计算器 =====\n";
    std::cout << "1. 计算两个数的和\n";
    std::cout << "2. 查看计算历史\n";
    std::cout << "3. 运行测试\n";
    std::cout << "4. 退出\n";
    std::cout << "选择: ";
}

int main() {
    Logger logger("calculator.log");
    
    while (true) {
        displayMenu();
        int choice;
        std::cin >> choice;
        
        try {
            switch (choice) {
                case 1: {
                    int a = InputHandler::getInteger("输入第一个数: ");
                    int b = InputHandler::getInteger("输入第二个数: ");
                    int result = MathUtils::add(a, b);
                    
                    std::ostringstream oss;
                    oss << a << " + " << b << " = " << result;
                    logger.log(oss.str());
                    
                    std::cout << "结果: " << oss.str() << "\n";
                    break;
                }
                case 2: {
                    auto logs = logger.readLogs();
                    std::cout << "\n=== 计算历史 ===\n";
                    for (const auto& log : logs) {
                        std::cout << log << "\n";
                    }
                    break;
                }
                case 3:
                    TestRunner::runTests();
                    break;
                case 4:
                    return 0;
                default:
                    std::cout << "无效选择\n";
            }
        } catch (const std::exception& e) {
            std::cerr << "错误: " << e.what() << "\n";
            logger.log(std::string("错误: ") + e.what());
        }
    }
}

```cpp
#include <bits/stdc++.h>
using namespace std;
#define LL long long
const int N = 1e5 + 10;
const int INF = 0x3f3f3f3f;
string a1 , b1;
int a[500] , b[500] , c[500];
int main()
{
    cin >> a1 >> b1;
    int lena = a1.size();
    int lenb = b1.size();
    for ( int i = 0 ; i < lena ; i++ )
	{
        a[ lena - i ] = a1[i] - '0';
    }
    for ( int i = 0 ; i < lenb ; i++ )
	{
        b[ lenb - i ] = b1[i] - '0';
    }
    int lenc = 1 , x = 0;
    while  ( lenc <= lena || lenc <= lenb )
	{
        c[lenc] = a[lenc] + b[lenc] + x;
        x = c[lenc] / 10;
        c[lenc] = c[lenc] % 10;
        lenc++;
    }
    if ( x > 0 )
	{
       c[lenc] = x;
    }
    else
	{
       lenc--;
    }
    for ( int i = lenc ; i >= 1 ; i-- )
	{
        cout << c[i];
	}
    cout << endl;
	return 0;
}
//菜鸟驿站
//老六专属

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

#include <iostream>
using namespace std;

int min_choices(int N) {
    int choices = 0;
    while (N > 0) {
        if (N % 2 == 1) {  // 如果是奇数
            if (N != 1) {   // 不是最后一个苹果
                choices++;
            }
            // 选择拿走(n-1)/2，这样剩下的苹果数就是n/2（向下取整）
            N = N / 2;
        } else {
            // 偶数直接拿一半
            N = N / 2;
        }
    }
    return choices;
}

int main() {
    int T;
    cin >> T;
    
    for (int i = 0; i < T; i++) {
        int N;
        cin >> N;
        cout << min_choices(N) << endl;
    }
    
    return 0;
}

#include <iostream>
using namespace std;

int calculate_choices(int N) {
    int choices = 0;
    while (N > 0) {
        if (N % 2 == 1 && N != 1) {  // 如果是奇数且不是最后一个苹果
            choices++;
        }
        N /= 2;
    }
    return choices;
}

int main() {
    int T;
    cin >> T;
    
    for (int i = 0; i < T; i++) {
        int N;
        cin >> N;
        cout << calculate_choices(N) << endl;
    }
    
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

const int MAX_N = 1000000;
long long tree[MAX_N];

int main() {
    int N;
    long long M;
    cin >> N >> M;
    
    long long max_height = 0;
    for (int i = 0; i < N; i++) {
        cin >> tree[i];
        if (tree[i] > max_height) {
            max_height = tree[i];
        }
    }
    
    long long left = 0;
    long long right = max_height;
    long long result = 0;
    
    while (left <= right) {
        long long mid = (left + right) / 2;
        long long total = 0;
        
        for (int i = 0; i < N; i++) {
            if (tree[i] > mid) {
                total += tree[i] - mid;
            }
        }
        
        if (total >= M) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    cout << result << endl;
    
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int N;
    cin >> N;
    
    int cards[100]; // 存储每堆纸牌数量
    int sum = 0;    // 纸牌总数
    
    for (int i = 0; i < N; i++) {
        cin >> cards[i];
        sum += cards[i];
    }
    
    int average = sum / N; // 计算平均值
    int moves = 0;        // 移动次数
    int diff = 0;         // 当前堆与平均值的差值
    
    for (int i = 0; i < N; i++) {
        // 计算当前堆与平均值的差值
        diff = cards[i] - average;
        
        // 如果差值不为0，则需要移动
        if (diff != 0) {
            moves++;
            // 将差值传递给下一堆
            cards[i+1] += diff;
        }
    }
    
    cout << moves << endl;
    
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

int main() {
    int N, m;
    cin >> N >> m;
    
    int v[25]; // 物品价格
    int w[25]; // 物品重要度
    int dp[30001] = {0}; // 动态规划数组，初始化为0
    
    for (int i = 0; i < m; i++) {
        cin >> v[i] >> w[i];
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = N; j >= v[i]; j--) {
            dp[j] = max(dp[j], dp[j - v[i]] + v[i] * w[i]);
        }
    }
    
    cout << dp[N] << endl;
    
    return 0;
}