【真题】暑假备战CSP-J/S：CSP-J2022普及组初赛(第一轮)试题及参考答案电子版(PDF版、无水印可直接打印)

int x = 101;
int y = 201;
int *p = &x;
int *q = &y;
p = q;

#include <iostream>

using namespace std;

int main()
 {
   unsigned short x, y;
   cin >> x >> y;
   x = (x | x << 2) & 0x33;
   x = (x | x << 1) & 0x55;
   y = (y | y << 2) & 0x33;
   y = (y | y << 1) & 0x55;
   unsigned short z = x | y << 1;
   cout << z << endl;
   return 0;
 }

#include <algorithm>
#include <iostream>
#include <limits>

using namespace std;

const int MAXN = 105;
const int MAXK = 105;

int h[MAXN][MAXK];

int f(int n, int m)
{
   if (m == 1) return n;
   if (n == 0) return 0;

   int ret = numeric_limits<int>::max();
   for (int i = 1; i <= n; i++)
       ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
   return ret;
 }

int g(int n, int m)
{
   for (int i = 1; i <= n; i++)
       h[i][1] = i;
   for (int j = 1; j <= m; j++)
       h[0][j] = 0;

   for (int i = 1; i <= n; i++) {
     for (int j = 2; j <= m; j++) {
         h[i][j] = numeric_limits<int>::max();
         for (int k = 1; k <= i; k++)
         h[i][j] = min( h[i][j],max(h[i - k][j], h[k - 1][j - 1]) + 1);
       }
    }
     return h[n][m];
 }

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

#include <iostream>

using namespace std;

int n, k;

int solve1()   
{
   int l = 0, r = n;
   while (l <= r) {
     int mid = (l + r) / 2;
     if (mid * mid <= n) l = mid + 1;
     else r = mid - 1;
   }
   return l - 1;
 }  

double solve2(double x)
{
     if (x == 0) return x;
     for (int i = 0; i < k; i++)
         x = (x + n / x) / 2;
     return x;
 }   
  
int main()
{
     cin >> n >> k;
     double ans = solve2(solve1());
     cout << ans << ' ' << (ans * ans == n) << endl;
     return 0;
 }

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

int main() {
     int n;
     cin >> n;

     vector<int> fac;
     fac.reserve((int)ceil(sqrt(n)));

     int i;
     for (i = 1; i * i < n; ++i) {
         if ( ① ) {
             fac.push_back(i);
         }
     }

     for (int k = 0; k < fac.size(); ++k) {
         cout << ② << " ";
     }
     if ( ③ ) {
         cout << ④ << " ";
     }
     for (int k = fac.size() - 1; k >= 0; --k) {
         cout << ⑤ << " ";
     }
 }

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

const int ROWS = 8;
const int COLS = 8;

struct Point {
    int r, c;
    Point(int r, int c): r(r), c(c) {}
};

bool is_valid(char image[ROWS][COLS], Point pt,
              int prev_color, int new_color) {
    int r = pt.r;
    int c = pt.c;
    return (0 <= r && r < ROWS && 0 <= c && c < COLS &&
            ① && image[r][c] != new_color);
}

void flood_fill(char image[ROWS][COLS], Point cur, int new_color) {
    queue<Point> queue;
    queue.push(cur);

    int prev_color = image[cur.r][cur.c];
    ②;

    while (!queue.empty()) {
        Point pt = queue.front ();
        queue.pop ();

        Point points[4] = {③, Point(pt.r - 1, pt.c),
                           Point(pt.r, pt.c + 1), Point(pt.r, pt.c - 1)};
        for (auto p ; points) {
            if (is_valid(image, p, prev_color, new_color)) {
                ④;
                ⑤;
            }
        }
    }
}

int main() {
    char image[ROWS][COLS] = {{'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'g', 'r', 'r'},
                              {'g', 'r', 'r', 'g', 'g', 'r', 'g', 'g'},
                              {'g', 'b', 'b', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'r', 'g', 'r'},
                              {'g', 'g', 'g', 'b', 'b', 'b', 'b', 'r'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g'},
                              {'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g'}};

    Point cur(4, 4);
    char new_color = 'y';

    flood_fill(image, cur, new_color);

    for (int r = -; r < ROWS; r++) {
        for (int c = 0; c < COLS; c++) {
            cout << image[r][c] << '';
        }
        cout << endl;
    }
//输出:
// g g g g g g g g
// g g g g g g r r
// g r r g g r g g
// g y y y y r g r
// g g g y y r g r
// g g g y y y y r
// g g g g g y g g
// g g g g g y y g

    return 0;
}