马蹄集 双周赛(2024年7.17~7.28)

目录

动物们

page

赶deadline

迷宫

构造字符串

打字

字母匹配

字符串旋转

矩阵取数

写程序

四柱河内塔

连锁反应

---

动物们

了 难度:黄金时间限制:1秒四占用内存:128 M
有某类动物，可以在农场中待n天，每天最多增加一只动物，第i天到来的动物每天要吃的粮食为ci，现在初始粮食是X，问你在每天动物尽可能多的情况下最多容纳几只动物?注意:第i天到来的动物，可以接纳也可以不接纳，如果接纳了就不可以中途再走了。
格式
输入格式:第-行为 n和X;
第二行为上述 c[i。
输出格式:输出一个整数，表示最多可以容纳的动物数量。

//
// Created by felix on 2024/7/22.
//
//01背包问题
//c[i]*(n-i+1),逆向循环，两层
//最终的方案数，计算出来
#include <bits/stdc++.h>
using namespace std;
int ani[1005], dp[100005], n, x;
int main() {
    cin >> n >> x;
    for (int i = 1; i <= n; i++) {
        cin >> ani[i];
        ani[i] *= (n - i + 1);
    }
    for (int i = 1; i <= n; i++) {
        for (int j = x; j >= ani[i]; j--) // 01背包倒着写, 完全背包顺着写
            dp[j] = max(dp[j], dp[j - ani[i]] + 1);
    }
    cout << dp[x];
    return 0;
}

page

乡 难度:钻石。时间限制:1秒巴占用内存:128 M
一本书的页码是从 1~n 编号的连续整数:1，2，3，…，n。请你求出全部页码中所有单个数字的和。例如第123页，它的和就是1+2+3=6。当n=15，全部页码单个数字的和=1+2+3+4+5+6+7+8+9+(1+0)+(1+1)+(1+2)+(1+3)+(1+4)+(1+5)。
格式
输入格式:一行一个整数 n。
输出格式:一行，代表所有单个数字的和。
样例 1
输入:3456789
输出:96342015
复制
复制

//
// Created by felix on 2024/7/22.
//
//数位DP
//DP
//各个位数有不一样
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 11;
ll f[N][10];

void init() {
    for (int i = 1; i < N; ++i) {
        f[i][0] = f[i - 1][9];
        for (int j = 1; j <= 9; ++j)
            f[i][j] = j * pow(10, i - 1) + f[i][j - 1] + f[i][0];
    }
}

ll dp(int x) {
    vector<int> num;
    int y = x;
    while (x) 
        num.push_back(x % 10), x /= 10;
    ll res = 0;
    for (int i = num.size() - 1; i >= 0; i--) {
        int t = num[i];
        if (!t)
            continue;
        res += f[i + 1][t - 1] + (y % int(pow(10, i)) + 1) * t;
    }
    return res;
}

int main() {
    int n;
    cin >> n;
    init();
    cout << dp(n);
    return 0;
}

赶deadline

乡 难度:钻石。时间限制:1秒四 占用内存:128 M
小码哥有严重的拖延症，因此他经常赶dead1ine(即忙于要完成的任务)。有一天小码哥向你求助，因为要做的事太多了，只能舍弃一些相对不重要的。小码哥共有几项任务，每个任务有重要度; 和需要消耗的时间 t。小码哥现在还有时间工,他希望你帮忙写一个程序判断应该选择完成哪些任务使得完成的任务重要度之和最大。
格式
输入格式:第一行两个整数n(0<n<104)，T(T<2000);
第 2 至 n+1行输入第i项任务的重要度  和完成需要的时间 (0 < ,t;< 1000)。
输出格式:第一行一个整数，完成任务的重要度之和的最大值;第二行若干个由空格隔开的整数，从小到大输出最优选择的任务的序号(从1开始)

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7;
int T, n, w[N], v[N], dp[N], path[N][N], ans[N];

int main() {
    cin >> n >> T;
    for (int i = 1; i <= n; i++) {
        cin >> v[i] >> w[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = T; j >= w[i]; j--) {
            if (dp[j - w[i]] + v[i] > dp[j]) {
                dp[j] = dp[j - w[i]] + v[i];
                path[i][j] = 1;
            }
        }
    }
    cout << dp[T] << endl;
    int i = n, j = T, cnt = 0;
    while (i >= 1 && j) {
        if (path[i][j]) {
            ans[cnt++] = i;
            j -= w[i];
        }
        i--;
    }
    for (int k = cnt - 1; k >= 0; k--) {
        cout << ans[k] << " ";
    }
    return 0;
}

迷宫

少 难度:黄金 时间限制:2秒巴 占用内存:128 M
小码哥和他的手下在维多利亚的迷宫玩耍，小码哥并不喜欢这个项目，于是他决定以最快的速度结束这个项目，这个迷宫可以看作是一个直角坐标系，小码哥在左下，终点在右上点。
小码哥只从,y轴的正方向走，因为这样是理论最快的解，问小码哥有多少种行走方法来最快到达终点。
格式
输入格式:第一行两个整数 m,n 表示迷宫是m行n列;接下来 m 行，每行 n 个数，描述了地图。
0-空地
1-墙(无法通过)
输出格式:一个整数表示答案(mod2333)o

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 3007;
const int mod = 2333;
int n, m, ans, a[N][N], dp[N][N];

int main() {
    cin >> m >> n;
    for (int i = m; i >= 1; i--) {
        for (int j = 1; j <= n; j++) {
            cin >> a[i][j];
        }
    }
    dp[1][1] = 1;
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (!a[i][j]) {
                dp[i][j] += (dp[i - 1][j] + dp[i][j - 1]);
                dp[i][j] %= mod;
            }
        }
    }
    cout << dp[m][n];
    return 0;
}

构造字符串

乡 难度:黄金时间限制:1秒四 占用内存:128 M
用 a，b，c三种元素构造一个长度为n的字符串，要求:这个字符串中不能有三个相邻的元素，元素值相同，即aaa，这种数列不可以出现;
问可以构造出多少种符合条件的字符串?
格式
输入格式:输入一个数 f,表示 f组数据;
每组数据输入一个n，占一行。
输出格式:输出一个数，表示符合条件的字符串的数量(结果取余 1e9+7)。

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int mod = 1e9 + 7;
int f, n, dp[100005][2];

signed main() {
    dp[1][0] = 0, dp[1][1] = 3;
    for (int i = 2; i <= 100000; i++) {
        dp[i][0] = dp[i - 1][1];
        dp[i][1] = 2 * (dp[i - 1][0] + dp[i - 1][1]) % mod;
    }

    cin >> f;
    while (f--) {
        cin >> n;
        cout << (dp[n][0] + dp[n][1]) % mod << endl;
    }

    return 0;
}

打字

难度:白银巴 占用内存:128 M时间限制:1秒
输入n及一串长度为n的目标字符串，有两种操作得到目标字符串:1.一个一个添加字符，直到添加完为止;
2.复制前面已经添加的字符，把复制的添加到后面(仅能执行一次)，然后继续添加字符，直到添加完。
问最少需要多少步骤，把字符添加完?
格式
输入格式:第一行为一个正整数n;第二行为字符串(仅包含小写字母)。
输出格式:一个整数即答案

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    string s;
    cin >> n >> s;
    for (int i = n / 2; i > 0; i--) {
        if (s.substr(0, i) == s.substr(i, i)) {
            cout << n - i + 1;
            return 0;
        }
    }
    cout << n;
    return 0;
}

字母匹配

难度:黄金。时间限制:1秒四占用内存:128M
小码哥有一个字符串8。
现在他想请你判断有多少对(,y)满足 sæ|=sy|,其中可以等于 y。
注意、(æ,y)和(y,)是不相同的一对。
格式
输入格式:第一行一个字符串 S，长度小于等于 1e5，包含ASCII码从33到125的所有字符
输出格式:按题目要求输出一行一个整数，表示(,y)的对数。

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

string s;
map<char, int> mp;
map<char, int>::iterator it;
int sum;

int main() {
    cin >> s;
    for (int i = 0; i < s.size(); i++) {
        mp[s[i]]++;
    }
    for (it = mp.begin(); it != mp.end(); it++) {
        sum += it->second * it->second;
    }
    cout << sum;
    return 0;
}

字符串旋转

难度:白银时间限制:3秒四占用内存:250M
实现一个函数，可以左旋字符串中的k个字符
格式
输入格式:第一行输入一个非空字符串(只包含小写字母)，长度不大于1000;第二行输入一个非负整数(小于字符串的长度)，表示旋转几个字符,
输出格式:一个旋转后的字符串。
样例 1
输入:abcd
输出:bcda
 

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 1007;
int k;
char str[N];

char* LeftRotate(char *str, int k) {
    int len = strlen(str);
    while (k--) {
        char temp = str[0];
        for (int i = 1; i < len; i++) {
            str[i - 1] = str[i];
        }
        str[len - 1] = temp;
    }
    return str;
}

int main() {
    cin >> str >> k;
    cout << LeftRotate(str, k);
    return 0;
}

矩阵取数

难度:钻石 时间限制:1秒巴 占用内存:128 M
给定n*m 的矩阵 A，和一个整数k，要求每行只能选取不超过一半的元素，且总的选择元素的和要是k的倍数，求满足条件的和的最大值，
格式
输入格式:第一行为n，m，k;后 n 行为所述的矩阵。
输出格式:输出仅一行，为所求答案。

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;

int n, m, mod, ans, INF = 0x3f3f3f3f;
int a[75][75], dp[75][75][75];

int main() {
    cin >> n >> m >> mod;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> a[i][j];
        }
    }
    memset(dp, -INF, sizeof(dp));
    dp[0][0][0] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (j == 1) {
                for (int k = 0; k <= m / 2; k++) {
                    for (int l = 0; l < mod; l++) {
                        dp[i][0][l] = max(dp[i][0][l], dp[i - 1][k][l]);
                    }
                }
            }
            for (int k = m / 2 - 1; k >= 0; k--) {
                for (int l = 0; l < mod; l++) {
                    dp[i][k + 1][(l + a[i][j]) % mod] =
                        max(dp[i][k + 1][(l + a[i][j]) % mod], dp[i][k][l] + a[i][j]);
                }
            }
        }
    }
    for (int j = 0; j <= m / 2; j++) {
        ans = max(ans, dp[n][j][0]);
    }
    cout << ans;
    return 0;
}

写程序

难度:钻石◎时间限制:1秒巴占用内存:128M
有n个程序员，每个程序员都可以写任意行代码，总共要编写m行代码，这行代码可以由多个程序员来编写。但是第i个程序员在一行代码中会出现ai个bug。现在希望知道有多少种方案能使得这m行代码中的bug 的数量不超过6个。
两个方案不同当且仅当某个程序员编写的代码量(行数)不同。
格式
输入格式:第一行四个数 n,m,b,mod ，第二行为 a[i]。
输出格式:输出一行一个整数，表示 m 行代码 bug 数量小于b的方案数对 mod取模后的答案

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 507;
int a[N], dp[N][N], n, m, b, mod, ans;

int main() {
    cin >> n >> m >> b >> mod;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    dp[0][0] = 1;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            for (int k = a[i]; k <= b; k++) {
                dp[j][k] = (dp[j][k] + dp[j - 1][k - a[i]]) % mod;
            }
        }
    }
    for (int i = 0; i <= b; i++) {
        ans = (ans + dp[m][i]) % mod;
    }
    cout << ans;
    return 0;
}

四柱河内塔

少难度:黄金时间限制:1秒四 占用内存:128 M
河内塔问题:有三个柱子，编号为1，2，3;在编号为1的柱子上有几个大小不同圆盘，圆盘从小到大，从上到下堆叠，你只可以移动一个柱子上最上面的圆盘。
现在你需要将编号为1的柱子上的圆盘移到3柱子上，顺序不变;注意:你在移动过程中，不可以将大的圆盘放在小圆盘上，你一次只可以移动一个盘子;
现在有一个4个柱子的河内塔，在规则不变的情况下，问最少需要移动多少次才能把盘子从1号柱子移到4号柱子上。
格式
输入格式:一个整数 f，表示n取(1,f)的 f种情况。
输出格式:输出 f行，表示当n分别取(1,f)的情况下，需要的最少移动次数。

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;

int f, dp[55], INF = 0x3f3f3f3f;

int main() {
    cin >> f;
    memset(dp, INF, sizeof(dp));
    dp[0] = 0, dp[1] = 1, dp[2] = 3;
    cout << 1 << endl << 3 << endl;
    for (int x = 3; x <= f; x++) {
        for (int k = 1; k < x; k++) {
            if (dp[x] > 2 * dp[x - k] + pow(2, k) - 1) {
                dp[x] = 2 * dp[x - k] + pow(2, k) - 1;
            }
        }
        cout << dp[x] << endl;
    }
    return 0;
}

连锁反应

时间限制:1秒巴占用内存:128 M了难度:钻石
小码哥在玩一个5x5的棋盘游戏，棋盘上有25个棋子，棋子有黑白两面，初始棋子无规则的正反放置在棋盘上，白用1表示，黑用0表示;
每一次玩家可以改变一个棋子的正反，但是由于有连锁反应，这个棋子的上下左右4个棋子会跟着转变其正反，即0变1，1变0;
小码哥想要知道需要多少步才能使棋盘上的棋子全部变为1;
但是如果需要的步数超过6步(小码哥没有那么多耐心等你算出来)，或者，没有办法使棋子全部变为1，你需要告诉小码哥。
格式
输入格式:第一行有一个正整数 n，代表数据中共有 n个棋盘游戏的初始状态;以下若干行数据分为n 组，每组数据有5行，每行5个数字0/1。每组数据描述了一个棋盘的初始状态。各组数据间用一个空行分隔。

//
// Created by felix on 2024/7/24.
//
#include <bits/stdc++.h>
using namespace std;

int n, ans;
char a[7][7], b[7][7];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};

void turn(int x, int y) {
    b[x][y] ^= 1;
    for (int i = 0; i < 4; i++) {
        if (x + dx[i] >= 0 && x + dx[i] < 6 && y + dy[i] >= 0 && y + dy[i] < 6) {
            b[x + dx[i]][y + dy[i]] ^= 1;
        }
    }
}

int main() {
    cin >> n;
    while (n--) {
        ans = 0x3f3f3f3f;
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 5; j++) {
                cin >> a[i][j];
            }
        }
        for (int op = 0; op < 32; op++) {
            int cnt = 0;
            for (int i = 1; i <= 5; i++) {
                for (int j = 1; j <= 5; j++) {
                    b[i][j] = a[i][j];
                }
            }
            for (int i = 1; i <= 5; i++) {
                if (op & (1 << (i - 1))) {
                    turn(1, i);
                    cnt++;
                }
            }
            for (int i = 2; i <= 5; i++) {
                for (int j = 1; j <= 5; j++) {
                    if (b[i - 1][j] == '0') {
                        turn(i, j);
                        cnt++;
                    }
                }
            }
            bool flag = true;
            for (int i = 1; i <= 5; i++) {
                if (b[5][i] == '0') {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                ans = min(ans, cnt);
            }
        }
        if (ans > 6) {
            cout << -1 << endl;
        } else {
            cout << ans << endl;
        }
    }
    return 0;
}