2022CSP完善程序

最新推荐文章于 2024-10-18 22:34:44 发布

一个普普通通的盆栽

最新推荐文章于 2024-10-18 22:34:44 发布

阅读量1k

点赞数 33

文章标签： c++ 算法数据结构

本文链接：https://blog.csdn.net/lb201205/article/details/140511403

版权

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

①处应填（）
A. n % i == 0
B. n % i == 1
C. n % (i-1) == 0
D. n % (i-1) == 1
②处应填（）
A. n / fac[k]
B. fac[k]
C. fac[k]-1
D. n / (fac[k]-1)
③处应填（）
A. (i-1) * (i-1) == n
B. (i-1) * i == n
C. i * i == n
D. i * (i-1) == n
④处应填（）
A. n-i
B. n-i+1
C. i-1
D. I
⑤处应填（）
A. n / fac[k]
B. fac[k]
C. fac[k]-1
D. n / (fac[k]-1)

35、【答案】A【解析】判断 i 是 n 的一个因数，则加入数组 fac 中，因此判断条件为

36、【答案】B【解析】当前数组 fac 存储的是小于平方根的所有因数，按顺序输出即可。

37、【答案】C【解析】特判，如果是完全平方数 i * i == n，则输出算术平方根 i。

38、【答案】D【解析】如果是完全平方数 i * i == n，则输出算术平方根 i。

39、【答案】A【解析】从小到大输出大于算术平方根的因数，因此需要倒序枚举小于算术平方根的因数 fac[k]，输出对应的另一个因数 n / fac[k]

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

①处应填（）
A. image[r][c] == prev_color
B. image[r][c] != prev_color
C. image[r][c] == new_color
D. image[r][c] != new_color
②处应填（）
A. image[cur.r+1][cur.c] = new_color
B. image[cur.r][cur.c] = new_color
C. image[cur.r][cur.c+1] = new_color
D. image[cur.r][cur.c] = prev_color
③处应填（）
A. Point(pt.r, pt.c)
B. Point(pt.r, pt.c+1)
C. Point(pt.r+1, pt.c)
D. Point(pt.r+1, pt.c+1)
④处应填（）
A. prev_color = image[p.r][p.c]
B. new_color = image[p.r][p.c]
C. image[p.r][p.c] = prev_color
D. image[p.r][p.c] = new_color
⑤处应填（）
A. queue.push( p )
B. queue.push(pt)
C. queue.push(cur)
D. queue.push(Point(ROWS,COLS))

40、【答案】A【解析】判断 image[r][c]为旧颜色 prev_color 时，需要更新颜色，因此选 A。

41、【答案】B【解析】将起点位置 image[cur.r][cur.c]更新颜色，选 B。

42、【答案】C【解析】上下左右四个相邻点，可以发现少了点(pt.r+1, pt.c)。

43、【答案】D【解析】将当前位置 image[p.r][p.c]更新颜色，选 D。

44、【答案】A【解析】如果 p 点符合要求，则将 p 点加入队列，选 A。

【题目考点】

1. 广搜连通块问题

2. auto关键字

使用auto关键字可以让编译器自动确定声明的变量的类型。
例：auto p = 3.2（auto在这里相当于double）
例：vector<int> vec; auto it = vec.begin();(auto在这里相当于vector<int>::iterator)

3. for冒号

遍历一个可迭代对象中的所有元素。可迭代对象可以为：数组或vector、list等stl容器。
for(元素类型变量名 : 可迭代对象)
元素类型为可迭代对象中元素的类型。可以写auto来自动设置元素类型。
取到的变量是值，改变该变量不会改变可迭代对象中元素的值。
for(元素类型 &变量名 : 可迭代对象)
取到的变量是引用，改变该变量会改变可迭代对象中元素的值。