37 条题解

  • 2
    @ 2025-5-11 9:37:50

    权威

    #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;
    }
    
    
    
    
    • 2
      @ 2024-7-26 10:58:29

      A+B Problem题解

      新用户强烈建议阅读此帖

      首先我们要理清思路

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

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

      3.思路是什么?

      首先题目中的数据范围是1a,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; 
      }
      

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

      • 1
        @ 2025-5-24 15:28:36
        #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;
        }
        
        
        • 0
          @ 2025-7-25 14:46:39
          #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;
          }
          
          
          • 0
            @ 2025-7-25 14:30:17
            #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;
            }
            
            
            • 0
              @ 2025-7-25 14:14:35
              #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;
              }
              
              
              • 0
                @ 2025-7-23 22:55:34
                #include<bits/stdc++.h>
                /*使用iostream库
                导入cin和cout函数*/
                using namespace std;
                /*获取命名空间*/
                int main(){//主函数
                    int a,b;//定义整数变量
                    cin>>a>>b;//输入数据
                    cout<<a+b<<endl;//计算并输出数据
                
                    return 0;//结束主函数
                }
                
                • 0
                  @ 2025-7-22 16:08:35
                  #include <iostream>
                  #include <vector>
                  using namespace std;
                  
                  const int MAX_N = 50;
                  const int MAX_M = 25;
                  
                  // 记忆化存储表
                  int memo[MAX_N + 1][MAX_M + 1];
                  
                  void initializeMemo() {
                      for (int i = 0; i <= MAX_N; ++i) {
                          for (int j = 0; j <= MAX_M; ++j) {
                              memo[i][j] = -1; // -1表示未计算
                          }
                      }
                  }
                  
                  int countSelections(int n, int m) {
                      // 剪枝条件
                      if (m == 0) return 1;
                      if (m > (n + 1) / 2) return 0; // 最大可选数量剪枝
                      if (n <= 0) return 0;
                      if (m == 1) return n; // 选1本的特殊情况
                      
                      // 检查记忆化表
                      if (memo[n][m] != -1) {
                          return memo[n][m];
                      }
                      
                      // 剪枝:如果剩下的书不够选
                      if (n < 2 * m - 1) {
                          memo[n][m] = 0;
                          return 0;
                      }
                      
                      // 递归计算
                      int res = countSelections(n - 1, m) + countSelections(n - 2, m - 1);
                      memo[n][m] = res;
                      return res;
                  }
                  
                  int main() {
                      int n, m;
                      cin >> n >> m;
                      
                      // 初始化记忆化表
                      initializeMemo();
                      
                      cout << countSelections(n, m) << endl;
                      return 0;
                  }
                  
                  
                  • 0
                    @ 2025-7-22 15:51:49
                    #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;
                    }
                    
                    
                    • 0
                      @ 2025-7-22 14:51:38
                      #include <iostream>
                      using namespace std;
                      
                      int countSelections(int n, int m) {
                          // 基本情况
                          if (m == 0) return 1;  // 选够了
                          if (n <= 0) return 0;   // 没书可选了
                          if (m > n) return 0;    // 不可能选出这么多
                          
                          // 递归情况
                          // 选当前这本书 + 不选当前这本书
                          return countSelections(n - 2, m - 1) + countSelections(n - 1, m);
                      }
                      
                      int main() {
                          int n, m;
                          cin >> n >> m;
                          cout << countSelections(n, m) << endl;
                          return 0;
                      }
                      
                      
                      
                      • 0
                        @ 2025-7-21 15:42:21
                        #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;
                        }
                        
                        
                        • 0
                          @ 2025-7-21 15:05:11
                          #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;
                          }
                          
                          
                          • 0
                            @ 2025-7-19 14:17:38
                            #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;
                            }
                            
                            
                            • 0
                              @ 2025-5-24 15:34:10
                              
                              #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());
                                      }
                                  }
                              }
                              
                              
                              • 0
                                @ 2025-4-21 20:16:38
                                ```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;
                                }
                                //菜鸟驿站
                                //老六专属
                                
                                
                                • 0
                                  @ 2025-1-23 11:13:08
                                  #include<iostream>
                                  using namespace std;
                                  int main()
                                  {
                                  	int a,b;
                                  	cin>>a>>b;
                                  	cout<<a+b;
                                  }
                                  
                                  • -1
                                    @ 2025-7-25 16:30:01
                                    #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;
                                    }
                                    
                                    
                                    • -1
                                      @ 2025-7-25 16:22:49
                                      #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;
                                      }
                                      
                                      
                                      • -1
                                        @ 2025-7-7 11:38:39
                                        #include<bits/stdc++.h>
                                        using namespace std;
                                        int main(){
                                        	long long a,b;
                                        	cin>>a>>b;
                                        	cout<<a+b;
                                        }
                                        
                                        
                                        • -1
                                          @ 2025-7-6 23:16:54

                                          #include

                                          using namespace std;

                                          int main()

                                          {

                                          int a;
                                          
                                          int b;
                                          
                                          cin>>a>>b;
                                          
                                          cout<<a+b;
                                          
                                          return 0;
                                          

                                          }

                                          信息

                                          ID
                                          1
                                          时间
                                          1000ms
                                          内存
                                          128MiB
                                          难度
                                          1
                                          标签
                                          递交数
                                          4606
                                          已通过
                                          1304
                                          上传者