2023年省赛真题

2023年省赛真题

试题A：求和

#include <stdio.h>

// 定义主函数main，程序的入口。
int main() {
    // 定义一个long long类型的变量ans，用于存储结果。
    long long ans = 0;

    /* 定义一个for循环，循环变量i从1到20230408（注意：这里使用了整型变量i，而不是long long类型，因为20230408可能超出long long类型的范围）。
     * 在循环体内，将变量ans加上当前循环变量i的值。
     */
    for (int i = 1; i <= 20230408; ++i)
        ans += i;

    /* 使用printf函数输出结果ans。
     * %lld表示输出长整数，即long long类型。
     */
    printf("%lld", ans);
    return 0;
}

?

---

试题B：工作时长?

?

/*
 * 程序从 "2022_work_hours.txt" 文件中读取工作小时数据，并计算2022年度的工作时长。
 * 程序首先检查文件是否打开成功，如果失败则输出 "unknow" 并返回1。
 * 然后，程序使用一个循环来读取文件中的每一行数据。
 * 对于每一行数据，程序将其解析为一个时间字符串，并提取年、月、日、小时、分钟和秒。
 * 如果提取到的年份不等于当前日期，则更新当前日期，并将当前时间索引重置为0。
 * 如果提取到的小时不等于前一个小时，则更新前一个小时的工作时长，并将当前时间索引重置为0。
 * 将提取到的小时、分钟和秒添加到当前时间数组中，并将当前时间索引加1。
 * 如果当前时间索引达到数组长度，则将当前时间数组中的最后一个元素减去第一个元素，得到2022年度的工作时长。
 * 最后，程序关闭文件并输出2022年度的工作时长。
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main() {
    FILE *file = fopen("2022_work_hours.txt", "r");
    if (file == NULL) {
        printf("unknow\n");
        return 1;
    }

    char line[200];
    int work_hours = 0;
    int prev_work_hours = 0;
    int days = 0;
    int current_day = 0;
    int current_time[30];
    int current_time_index = 0;

    while (fgets(line, sizeof(line), file) != NULL) {
        char *time_str = strtok(line, " ");
        char *date_str = strtok(NULL, " ");
        char *hour_str = strtok(NULL, ":");
        char *minute_str = strtok(NULL, ":");
        char *second_str = strtok(NULL, ":");

        int year = atoi(date_str);
        int month = atoi(strtok(NULL, "-"));
        int day = atoi(strtok(NULL, "-"));
        int hour = atoi(hour_str);
        int minute = atoi(minute_str);
        int second = atoi(second_str);

        if (year != current_day) {
            current_day = year;
            days++;
            current_time_index = 0;
        }

        if (hour != prev_work_hours) {
            if (current_time_index > 0) {
                work_hours += current_time[current_time_index - 1] - current_time[current_time_index - 2];
            }
            prev_work_hours = hour;
            current_time_index = 0;
        }

        current_time[current_time_index++] = hour * 3600 + minute * 60 + second;
    }

    if (current_time_index > 0) {
        work_hours += current_time[current_time_index - 1] - current_time[current_time_index - 2];
    }

    fclose(file);

    printf("2022年度工作时长：%d 小时\n", days * 24 * 60 * 60 + work_hours);
    return 0;
}

?

---

?试题C：三国游戏

?

?

?首先，程序引入了<bits/stdc++.h>头文件，用于使用标准库。
? 然后，定义了一个名为using namespace std;，用于简化代码。
?接下来，定义了一个名为ll的无符号长整数类型，并将其与long long类型进行关联。
?定义了一个名为endl的宏，用于在输出中添加换行符。
?定义了一个名为x、y和z的常量，分别表示节点中的三个坐标。
? 定义了一个名为node的结构体，用于存储节点的坐标。
?定义了一个名为cmp1、cmp2和cmp3的比较函数，分别用于比较三个节点的坐标。
?定义了一个名为n的整数变量，用于存储节点的数量。
?定义了一个名为a、b和c的节点数组，分别用于存储三个节点的坐标。
solve()函数用于解决特定问题。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define x first
#define y second
#define pd push_back
const int maxn=1e5+10;

// 定义一个名为node的结构体，用于存储节点的坐标。
struct node
{
    ll x,y,z;
};

// 定义一个名为cmp1的比较函数，用于比较两个节点的横坐标。
bool cmp1(node &a,node &b)
{
   return a.x-(a.y+a.z)>b.x-(b.y+b.z);
}

//定义一个名为cmp2的比较函数，用于比较两个节点的纵坐标。
bool cmp2(node &a,node &b)
{
   return a.y-(a.x+a.z)>b.y-(b.x+b.z);
}

//定义一个名为cmp3的比较函数，用于比较两个节点的竖坐标。

bool cmp3(node &a,node &b)
{
   return a.z-(a.y+a.x)>b.z-(b.y+b.x);
}
int n;
node a[maxn],b[maxn],c[maxn];
void solve()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i].x;
        b[i].x=c[i].x=a[i].x;
    }
    for(int i=1;i<=n;i++)
    {
        cin>>a[i].y;
        b[i].y=c[i].y=a[i].y;
    }
    for(int i=1;i<=n;i++)
    {
        cin>>a[i].z;
        b[i].z=c[i].z=a[i].z;
    }
    sort(a+1,a+n+1,cmp1);
    sort(b+1,b+n+1,cmp2);
    sort(c+1,c+n+1,cmp3);
    ll ans=-1;
    for(ll i=1,x=0,y=0,z=0;i<=n;i++)
    {
        x+=a[i].x;
        y+=a[i].y;
        z+=a[i].z;
        if(x>y+z)
        {
            ans=max(ans,i);
        }
    }
    for(ll i=1,x=0,y=0,z=0;i<=n;i++)
    {
        x+=b[i].x;
        y+=b[i].y;
        z+=b[i].z;
        if(y>x+z)
        {
            ans=max(ans,i);
        }
    }
    for(ll i=1,x=0,y=0,z=0;i<=n;i++)
    {
        x+=c[i].x;
        y+=c[i].y;
        z+=c[i].z;
        if(z>y+x)
        {
            ans=max(ans,i);
        }
    }
    cout<<ans<<endl;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int tn=1;
    //cin>>tn;
    while(tn--)
    {
        solve();
    }
    return 0;
}

?

---

试题D：填充?

/*
 * 首先，定义一个字符数组str，用于存储输入的字符串。
 * 然后，通过scanf函数从标准输入读取一个字符串，并将其存储在str数组中。
 * 接着，定义一个整型变量n，用于存储字符串的长度。
 * 定义一个整型变量count，用于存储问号的个数。
 * 定义两个整型变量left和right，分别用于记录问号左边和右边的字符位置。
 * 定义一个整型变量max_count，用于存储问号的最大个数。
 */
#include <stdio.h>
#include <string.h>

int main() {
    char str[100];
    scanf("%s", str);
    int n = strlen(str);
    int count = 0;
    int left = 0, right = 0;
    int max_count = 0;

    while (right < n) {
        if (str[right] == '?') {
            if (left == 0) {
                count++;
                left = right + 1;
            }
            right++;
        } else {
            int temp = right - left + 1;
            if (temp > max_count) {
                max_count = temp;
            }
            left++;
            right++;
        }
    }

    printf("%d\n", max_count);
    return 0;
}

?

---

?试题E：翻转?

?

/*
 * 这段C语言代码实现了一个字符串匹配问题。
 * 输入两个字符串T和S，其中T和S的长度不超过1000010。
 * 每个字符串只包含小写字母。
 * 输出字符串T和S中相同的字符数量。
 */
#include <stdio.h>

char T[1000010], S[1000010];

int D, cnt;

int main() {
    for (scanf("%d\n", &D); gets(T + 1), gets(S + 1), D--;) {
        for (int i = 1; S[i]; ++i) {
            if (S[i] == T[i]) continue;
            if (S[i - 1] == S[i] ^ 1 && S[i - 1] == S[i + 1]) S[i] ^= 1, ++cnt;
            else {
                cnt = -1;
                break;
            }
        }
        printf("%d\n", cnt), cnt = 0;
    }
}

运行结果如下：?

?

---

??试题F：子矩阵?

?

?

?

// 引入<bits/stdc++.h>头文件，用于处理大整数运算
#include <bits/stdc++.h>

using namespace std;

int main(){
    // 定义变量m、n、a、b，用于存储大整数
    long long m,n,a,b;
    // 读入大整数n、m、a、b
    cin >> n >> m >> a >> b;
    // 定义二维数组arr，用于存储输入的大整数
    int arr[n][m];
    // 循环读入二维数组arr的元素
    for (int i = 0; i < n; i++){
        for (int j = 0; j < m; j++){
            cin >> arr[i][j];
        }
    }
    // 定义变量sum，用于存储最终结果
    long long sum = 0;
    // 循环读入数组arr的元素，计算sum的值
    for (int i = 0; i < a; i++){
        for (int j = 0; j < b; j++){
            sum +=arr[i][j]*arr[i][j+1] + arr[i+1][j]*arr[i+1][j+1];
        }
    }
    // 输出结果
    cout << sum << endl;
    
    // 返回0，表示程序正常结束
    return 0;
}

?

---

?试题G：互质数的个数??

?

?

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    int count = 0;
    for (int x = 1; x < a; ++x) {
        if (gcd(x, a) == 1) {
            count++;
        }
    }
    printf("%d\n", count % 998244353);
    return 0;
}

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}

---

?试题H：异或和之差??

?

// 引入iostream库，用于输入输出
#include<iostream>
using namespace std;

// 定义变量n、m、l、r，分别表示题目中的数字个数、选中的数字个数、当前选中的数字范围左边界、当前选中的数字范围右边界
int n,m, l, r;

// 定义变量x，表示当前选中的数字
int x;

// 定义常数N，表示最大数字
int const N = 1e7 + 10;

// 定义数组a，用于存储题目中的数字
int a[N];

// 定义数组vis，用于记录每个数字是否被选中
bool vis[N];

// 定义函数judgement，用于判断给定的数字范围中是否存在选中的数字
bool judgement(int l, int r, int x) {
    // 初始化vis数组为false，表示所有数字未被选中
    memset(vis, false, sizeof vis);

    // 如果选中的数字个数为0，则直接返回false，表示没有选中的数字
    if (r - l + 1 == 0) {
        //cout << "no" << endl;
        return false;
    }

    // 遍历选中的数字范围，将选中的数字标记为true
    for (int k = l; k <= r; k++) {
        vis[a[k]] = true;//表示这个数字为选中了
    }

    // 遍历选中的数字范围，判断是否存在选中的数字
    for (int k = l; k <= r; k++) {
        if (vis[a[k] ^ x] == true) {
            cout << (a[k] ^ x) << endl;
            return true;
        }
    }

    // 如果没有找到选中的数字，则返回false
    return false;
}

// 定义main函数，用于主函数的执行
int main() {
    // 读取输入，获取数字个数、选中的数字个数、当前选中的数字
    cin >> n >> m >> x;

    // 读取输入，获取题目中的数字
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }

    // 进入while循环，处理每个题目
    while (m--) {
        // 读取输入，获取当前选中的数字范围左边界、右边界
        cin >> l >> r;

        // 调用judgement函数，判断是否存在选中的数字
        if (judgement(l, r, x)) {
            cout << "yes" << endl;
        }
        else cout << "no" << endl;
    }

    // 返回0，表示程序正常结束
    return 0;
}

---

?试题I：公因数匹配

?

/*
 * 这是一个用于找到两个整数的最大公约数的C语言程序。
 * 首先，程序从用户输入中读取两个整数，并将其存储在数组A中。
 * 然后，程序调用find_gcd函数，传入数组A的第一个元素和第二个元素，以及指向最大公约数的指针。
 * find_gcd函数使用递归方法找到最大公约数。如果b（第二个参数）等于0，那么最大公约数就是a（第一个参数）。
 * 否则，递归调用find_gcd函数，传入b和a除以b的余数。
 * 在主函数中，程序遍历数组A中的所有元素，并检查它们之间的最大公约数。如果找到最大公约数，程序将输出两个元素的索引。
 */
#include <stdio.h>

void find_gcd(int a, int b, int *gcd) {
    if (b == 0) {
        *gcd = a;
    } else {
        find_gcd(b, a % b, gcd);
    }
}

int main() {
    int n, i, j;
    scanf("%d", &n);
    int A[n];
    for (i = 0; i < n; i++) {
        scanf("%d", &A[i]);
    }
    int gcd;
    find_gcd(A[0], A[1], &gcd);
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (gcd == A[j] && A[i] % A[j] == 0) {
                printf("%d %d\n", i, j);
                break;
            }
        }
    }
    return 0;
}

---

??试题J：子树的大小?

?

//（规律 + 递归）
#include <bits/stdc++.h>
using namespace std ;
typedef long long LL ;
void solve()
{
    int n, m, k ;
    LL l, r, res = 1 ;
    cin >> n >> m >> k ;
    l = r = k ;
    while ( 1 )
    {
        r = r * m + 1 ;
        l = (l - 1) * m + 2 ;
        if ( l > n ) break ;
        if ( n < r ) r = n ;
        res += r - l + 1 ;
    }
    cout << res << '\n' ;
}
int main()
{
    ios::sync_with_stdio(false) ;
    cin.tie(0) ;
    cout.tie(0) ;
    int t = 1 ;
    cin >> t ;
    while ( t-- ) solve() ;
    return 0 ;
}