QLU(SDAS)2025寒假集训（一）题解（ABCDEFGL）

原创 已于 2025-02-18 21:48:10 修改 · 336 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #c++

于 2025-01-15 01:45:58 首次发布

A-CodeForces - 1794A 

思路：我们知道，回文串长度相等的前缀与后缀一定是相反的，利用此性质，暴力查找所给的字符串，当存在某项找不到相反的项时，一定为非回文串。

#include <bits/stdc++.h>
#include <unordered_set>
#define endl '\n'
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, n, a) for (int i = n; i >= a; i--)
#define LL long long
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
using namespace std;

string rs(string str)
{
    string red = str;
    reverse(red.begin(), red.end());
    return red;
}

void solve()
{
    int n;
    cin >> n;
    string s[40];
    rep(i, 1, 2 * n - 2)
        cin >> s[i];
    int num = 0;
    rep(i, 1, 2 * n - 2)
    {
        rep(j, 1, 2 * n - 2)
        {
            if (s[i] == rs(s[j]) && i != j)
            {
                num++;
                break;
            }
        }
    }
    if (num == 2 * n - 2)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
    return;
}

int main()
{
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}

B-AtCoder - dp_b 

思路：我们发现，青蛙到达第 i 块石头的最小费用依赖于它从上一步的石头(i-1, i-2, ... i-K)跳跃过来的最小费用，于是我们考虑用动态规划的做法。设 dp[i] 表示青蛙跳到第 i 块石头的最小费用，从第 i-1 到 i-K 块石头，青蛙都可以跳到第 i 块石头，所以可以有如下状态转移： 设到达第 i 块石头的上一块为第 j 块，则有 dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]))。将 dp[1] 到达第 1 块石头的费用设为 0。由于要求的是最小值，故将 dp 数组初始化为一个很大的数。

#include <bits/stdc++.h>
#include <unordered_set>
#define endl '\n'
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, n, a) for (int i = n; i >= a; i--)
#define LL long long
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
using namespace std;

int n, k;
int h[100005];

int main()
{
    cin >> n >> k;
    rep(i, 1, n)
        cin >> h[i];
    vector<int> dp(n + 1, INT_MAX);
    dp[1] = 0;
    rep(i, 1, n)
    {
        rep(d, 1, k)
        {
            int j = max(i - d, 1);
            dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
        }
    }
    cout << dp[n] << endl;
    return 0;
}

C-CodeForces - 1794B

思路：由于 1 能被所有正整数整除，所以我们首先将数组中所有为 1 的元素加上1，然后遍历数组，当 a[i] 能被 a[i-1] 整除时，让 a[i] 加1。显然操作次数在 2*n 之内。

#include <bits/stdc++.h>
#define endl '\n'
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, n, a) for (int i = n; i >= a; i--)
#define LL long long
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
using namespace std;

int t, n;
int a[10004];

int main()
{
    IOS;
    cin >> t;
    while(t--)
    {
        cin >> n;
        rep(i,1,n)
        {
            cin >> a[i];
            if(a[i]==1)
                a[i]++;
        }
        rep(i,2,n)
        {
            if(a[i]%a[i-1]==0)
                a[i]++;
        }
        rep(i,1,n)
            cout << a[i] << " ";
        cout << endl;
    }
    return 0;
}

D-AtCoder - dp_e 

思路：01背包问题，特殊之处在于本题背包重量最大为1e9，常规的“用 dp[i] 表示背包装前 i 个物品的最大总价值”的做法难以通过。观察发现，背包的总价值 N*v[i] 最大似乎只有1e5，于是我们考虑“用 dp[i] 表示背包装 i 价值的东西的最小重量“的做法，最后只需找出重量 dp[i] 不超过 w 的最大价值即可。初始化 dp 数组为无穷大，dp[0]=0。

#include <bits/stdc++.h>
#include <unordered_set>
#define endl '\n'
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, n, a) for (int i = n; i >= a; i--)
#define LL long long
#define inf 0x3f3f3f3f3f
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
using namespace std;

int N, W;
int w[102], v[102];
int dp[100005];
int ans;

int main()
{
    IOS;
    cin >> N >> W;
    rep(i, 1, N)
        cin >> w[i] >> v[i];
    memset(dp, inf, sizeof(dp));
    dp[0] = 0;
    rep(i, 1, N)
    {
        per(j, 1e5, v[i])
        {
            dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
            if (dp[j] <= W)
                ans = max(ans, j);
        }
    }
    cout << ans;
    return 0;
}

E-CodeForces - 1802A 

思路：贪心地思考，先每秒都点赞，再每秒取消点赞，就是每秒可能的最大点赞数。上一秒点完赞，下一秒马上取消，就是每秒可能的最小点赞数。

#include <bits/stdc++.h>
#include <unordered_set>
#define endl '\n'
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, n, a) for (int i = n; i >= a; i--)
#define LL long long
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
using namespace std;

int t, n;

int main()
{
    cin >> t;
    while (t--)
    {
        cin >> n;
        int z = 0, q = 0;
        int b;
        rep(i,1,n)
        {
            cin >> b;
            if (b > 0)
                z++;
            else
                q++;
        }
        int num = 0;
        rep(i,1,z)
        {
            num++;
            cout << num << " ";
        }
        rep(i,1,n-z)
        {
            num--;
            cout << num << " ";
        }
        cout << endl;
        int ans = 0;
        while(n--)
        {
            if(z>0)
            {
                ans++;
                z--;
                cout << ans << " ";
            }
            if(q>0)
            {
                ans--;
                q--;
                cout << ans << " ";
            }
        }
        cout << endl;
    }
    return 0;
}

F-洛谷 - P1083

思路：将每个订单暴力模拟的方法显然会超时。观察发现，有问题的订单的位置关于能顺序完成的订单的个数似乎具有某种单调性，于是我们考虑对问题订单使用二分答案：条件函数 p(int mid) 就是在判断能否做 mid 个订单，只需利用差分模拟实现即可。

#include <bits/stdc++.h>
#include <unordered_set>
#define endl '\n'
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, n, a) for (int i = n; i >= a; i--)
#define LL long long
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
using namespace std;
 
int n, m;
int r[1000006], d[1000006], s[1000006], t[1000006];
int dr[1000006];
 
bool p(int mid)
{
    rep(i, 1, n)
        dr[i] = r[i] - r[i - 1];
    rep(i,1,mid)
        dr[s[i]] -= d[i], dr[t[i] + 1] += d[i];
    int tmsr = 0;
    rep(i,1,n)
    {
        tmsr += dr[i];
        if(tmsr<0)
            return 1;
    }
    return 0;
}
 
int main()
{
    cin >> n >> m;
    rep(i,1,n)
    {
        cin >> r[i];
        dr[i] = r[i] - r[i - 1];
    }
    rep(i,1,m)
        cin >> d[i] >> s[i] >> t[i];
    rep(i,1,m)
        dr[s[i]] -= d[i], dr[t[i] + 1] += d[i];
    int sr = 0;
    bool flag = 0;
    rep(i,1,n)
    {
        sr += dr[i];
        if(sr<0)
        {
            flag = 1;
            break;
        }
    }
    if(flag==0)
        cout << 0;
    else
    {
        LL l = 1, r = 1e6 + 5, ans = 0;
        while (l <= r)
        {
            int mid = l + (r - l) / 2;
            if (p(mid))
                ans = mid, r = mid - 1;
            else
                l = mid + 1;
        }
        cout << -1 << endl << ans;
    }
    return 0;
}

G-CodeForces - 1802B

思路： 在遇到 2 之前，我们无法得知新买的豚鼠的性别，所以必须把每个豚鼠单独关起来，当遇到2时，我们可以确认已买的所有豚鼠的性别，于是贪心地假定其性别分布可使得笼子的数量最大化，具体地，当只有 1 只是异性时所需的笼子数量最大。

#include <bits/stdc++.h>
#include <unordered_set>
#define endl '\n'
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, n, a) for (int i = n; i >= a; i--)
#define LL long long
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
using namespace std;

int t, n, ans;

int main()
{
    cin >> t;
    while (t--)
    {
        int n;
        cin >> n;
        int cnt = 0;
        int n1 = 0, n2 = 0;
        ans = 0;
        rep(i, 1, n)
        {
            int b;
            cin >> b;
            if (b == 1)
                cnt++;
            else if (b == 2)
            {
                if (n2 != 0)
                    n1 += cnt;
                else if (n2 == 0 && cnt != 0)
                {
                    n1 = cnt - 1;
                    n2 = 1;
                }
                cnt = 0;
            }
            int num = (n1 + 1) / 2 + (n2 + 1) / 2 + cnt;
            ans = max(ans, num);
        }
        cout << ans << endl;
    }
    return 0;
}

L-洛谷 - P1536 

思路：我们可将已有道路相互连接（无论直接间接）的城镇看作一个集合，然后只需求出这样的集合的个数 ans ，将这些集合合并成一个相互连接的大集合至少需要 ans-1 条路。考虑用并查集来解决，集合的个数等于是祖宗的元素的个数。

#include <bits/stdc++.h>
#include <unordered_set>
#define endl '\n'
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, n, a) for (int i = n; i >= a; i--)
#define LL long long
#define inf 0x3f3f3f3f3f
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
using namespace std;

int fa[1003];

int find(int x)
{
    if(x!=fa[x])
        fa[x]=find(fa[x]);
    return fa[x];
}

void unite(int x, int y)
{
    fa[find(x)] = find(y);
}

int main()
{
    IOS;
    while(1)
    {
        int n,m;
        cin >> n;
        if(n==0)
            break;
        cin >> m;
        rep(i,1,n)
            fa[i]=i;
        while(m--)
        {
            int c1,c2;
            cin >> c1 >> c2;
            unite(c1,c2);
        }
        int ans=0;
        rep(i,1,n)
        {
            if(find(i)==i)
                ans++;
        }
        cout << ans-1 << endl;
    }
    return 0;
}
QLU新生赛02题解
qq_43813373的博客
01-09 1345
D #include<iostream> #include<algorithm> using namespace std; int main(){ long long n; cin>>n; long long a[3]; while(n--){ long long sum=0; cin>>a[0]>>a[1]>&gt...
BUFFALO巴法洛HD-QLU3_R5 系列用户手册.pdf
07-11
BUFFALO巴法洛HD-QLU3_R5 系列用户手册.pdf 是一份关于 BUFFALO 巴法洛 HD-QLU3_R5 系列硬盘的用户手册，它提供了关于该硬盘的使用、维护和故障排除等方面的详细信息。 首先，在“推荐使用”部分，手册中提到使用 ...
QLU(SDAS)2025寒假集训（二）题解（ABCDEFJ）
LLCHS的博客
01-17 451
思路：观察题目，发现我们需要构造如下数据关联：产地与其所产多种水果品种的关联，某个产地的某种水果与其数量的关联。我们都可以使用map轻松实现：前者产地为键，存有该产地水果品种的vector为值；后者关联产地与品种的pair为键，该产地此品种水果的数量为值。观察发现，有问题的订单的位置关于能顺序完成的订单的个数似乎具有某种单调性，于是我们考虑对问题订单使用。地思考，机器猫在闯关过程中可能损失的最多血量，将其加上1即为所求。思路：观察发现，所有满足条件的连续正整数段互不重叠，考虑使用。
QLU(SDAS)2025寒假集训（三）题解（ABC）
LLCHS的博客
01-20 247
思路：观察发现，如果第一个字符是 1，那么我们所要做的就是寻找一个从第二个字符开始的子串，使得删去这个子串后总分数最大。我们可以先去掉开头的 0，然后枚举串的长度，寻找被删除后总分数最大子串即可。思路：观察发现，交换次数只取决于种类的分布：如果存在某个种类只拥有一个元素，则必定不可能成功，拥有偶数个元素的种类的最小交换次数为种类数 kn[i] 除 2 ，奇数则为 (kn[i]+1)/2。思路：观察发现，影响每次拆几包的关键是上一次煮汤圆可能剩下的汤圆个数。
QLU寒假训练赛题解合集
康宇的博客
01-16 386
为了节省版面： 1.所有寒假训练赛题解都集中在这一篇里 2.所有题解代码都可以直接点击题目链接查看 0115 A题：签到，输出n+1 B题：签到，从左端点向右找一段和小于0的区间，再从右往左找 C题：暴力枚举，for a in [sqrt(n),1]，1e6数量级从头跑一遍 D题：字典树，递归。蛮有嚼头。 首先从30位到1位建立一颗字典树 然后从根节点开始思考这个问题： 现在所有的节点被分成了30...
QLU_凉脾的比赛题解
ミ渴望ヽ不可及ゞ的博客
01-30 296
之前都是只补的没有做出来的题目的题解，但是这次想着也把做出来的题目的题解也放上来，索然题目都不难，也算是记录一下自己的学习历程吧 QAQ 题目A - DRM MessagesB - Game of Throwns A - DRM Messages 题目大意： 把一个输入的字符串进行解密处理，处理的步骤： 一：划分，把字符串从中间分为两段。 二：旋转，对于每一半，通过将每个字符的值相加（A=0...
QLU—寒假第一次训练
curry___的博客
01-17 374
A - Classy Numbers（数位dp） Let's call some positive integer classy if its decimal representation contains no more than 33 non-zero digits. For example, numbers 44, 200000200000, 1020310203 are classy a...
2018QLU_ACM迎新赛部分题解
康宇的博客
11-27 537
问题 A: 约数个数 题目描述 p^ q 表示p的q次方，正整数M可以分解为M=(p1 ^ a1 )(p2 ^ a2)(p3 ^ a3)……(pn ^ an)的形式，其中p1，p2……pn为质数(大于1并且只能被1和自身整除的数叫做质数)。a1，a2……an为整数。例如18=(2 ^ 1) (3 ^ 2)，45=(3 ^ 2)(5 ^ 1)。 给出n和一个质数g，以及正整数M分解后的形式，求M的所...
qlu 2024集训队新生积分赛第一场 ABC解题
灰喜鹊的羽毛
10-23 389
qlu 2024集训队新生积分赛第一场 ABC题目的解析和我脑子抽筋的笑点解析。
2018QLU-ACM新生赛部分题解及赛后心得
qq_24471135的博客
11-27 762
Problem A约数个数 题目描述 p^q 表示p的q次方，正整数M可以分解为M=(p1^ a1) * (p2^ a2) * (p3^ a3)……(pn^ an)的形式，其中p1，p2……pn为质数(大于1并且只能被1和自身整除的数叫做质数)。a1，a2……an为整数。例如18=(2^1) * (3^2) ，45=(3^2) * (5^1)。 给出n和一个质数g，以及正整数M分解后的形式，求M的...
2024年Qlu积分赛题解(1)
jiashunAh的博客
10-30 707
先考虑特殊情况，l = 1,或者 r = n时，若l = 1 ,r = n同时满足，则不许要关闭即总时间为0，若 l = 1,r!若 l <= pos <= r 时，pos应先到达距离l或者r最近的那个在及取得min（pos - l，r - pos），然后在移动回去，r - l 即。里的map，（哈希表），先将a,e,o,u,i,y这四个字母存起来，当访问到a,e,o,u,i,y时就从此时往后找元音字母。//如果当前时间大于第k个学生所能等的时间。若pos <= l时，pos移动到l，在移动到r，即。
BUFFALO巴法洛HD-QLU3_R5 系列快速说明书.pdf
07-11
首先，BUFFALO巴法LO HD-QLU3_R5系列是一款高性能的外部硬盘，设计用于满足用户对大容量存储和高效数据传输的需求。该系列可能包括不同容量的硬盘，如1TB、2TB、4TB等，以适应不同用户的数据存储需求。这些硬盘通常...
LeetCode热题100--70. 爬楼梯--简单
2301_80071187的博客
12-20 211
这道题考察爬楼梯问题，每次可以爬1或2个台阶，求爬到n阶的不同方法数。采用动态规划解法，初始化dp数组，dp[0]=1，dp[1]=1。对于i≥2，dp[i]=dp[i-1]+dp[i-2]，即当前台阶的方法数等于前两个台阶方法数之和。最终返回dp[n]即为结果。该解法时间复杂度O(n)，空间复杂度O(n)。
智驾空间智能、物理智能、世界模型相关的最新论文和开源算法链接
Bonaventure的博客
12-16 1036
这些资源涵盖了2025年自动驾驶领域的前沿研究，从空间推理到物理建模和世界模拟，提供了丰富的开源工具和理论框架。建议用户通过链接深入探索论文和代码，以应用于实际项目或进一步研究。如果您需要更详细的解读或特定应用建议，请随时补充信息！
【算法笔记】AC自动机
u012559967的专栏
12-19 722
AC自动机: AC自动机是一种高效的多模式字符串匹配算法，它巧妙地将 Trie树的字典结构与 KMP算法的失配指针思想相结合，能同时在一段文本中查找多个模式串的所有出现位置，广泛应用于敏感词过滤、生物信息学序列分析等领域。在字符串匹配领域，我们会遇到两类问题：单模式匹配：给定一个文本字符串和一个模式字符串，判断模式字符串是否出现在文本字符串中。《【算法笔记】KMP算法》多模式匹配：给定一个文本字符串和多个模式字符串，判断所有模式字符串是否出现在文本字符串中。解决方案：AC自动机算法。
(leetcode) 力扣100 15轮转数组（环状替代）
qq_62235017的博客
12-18 989
我们利用这个过程，首先计算需要多少个从起点走回起点的圈数（count，为数组长度与步数的最大公约数，具体推推导后面会给），然后再遍历每一圈，通过创建一个临时变量（current,next，类似于指针的作用），来存储需要移动的变量将其移动到下一个位置，而下一个位置变为信的需移动变量，直到走完当前圈数。我们可以把数组想象一个圆圈，如果我们每次固定步数前进，肯定会在有限圈数回到出发点，这个过程中，有可能会遍历完数组所有数，有可能遍历有限数。这句话的意思是：在这个游戏中，你启动一次任务，只能覆盖到。
Leetcode 79 最佳观光组合
im_AMBER的博客
12-17 580
每个元素只遍历一次只用了两个变量O(n)O(1)公式拆分是核心：将原得分公式拆分为，把双变量问题转化为单变量的遍历问题。贪心维护最优值：遍历j时，用best维护之前所有i < j中的最大值，这样每一步只需要 O (1) 计算，整体时间复杂度是 O (n)。遍历顺序：因为要求i < j，所以从j=1开始遍历，先计算当前j的得分，再更新best（避免 j 自己和自己配对）。
力扣刷题笔记-组合总和
最新发布
qq_42622072的博客
12-21 496
比如candidates = [2,3,6,7], target = 7的时候，第一次先选一个数2，把2加入到path中，这时还没有达到target的值，可以再选一个数，这时还是可以按顺序选[2,3,6,7]中的所有数，做循环尝试，可以就再选2试试，这时path中已经有[2，2]了，和还是没达到target，还可以继续加数，再加一个2试试，最后发现[2，2，2]后面再加数已经不行了，加任何数都走不通了，那么就会把最后加进去的那个 2 踢掉，回到 [2, 2] ，然后在这一层尝试别的选择。
算法基础（背包问题）-完全背包
2401_87986548的博客
12-20 786
本文介绍了完全背包问题的三种典型应用场景及解法。首先通过牛客网模板题讲解基础完全背包的两种状态（不超过容量和恰好装满），给出状态转移方程和初始化技巧。其次以洛谷P1616为例展示完全背包在采药问题中的简单应用。最后通过P2918和P5662两道题，分别演示了完全背包在"至少重量"限制和动态规划与贪心结合的场景下的解法。所有解法均包含状态表示、转移方程、初始化和空间优化思路，并附参考代码实现。文章通过具体题目展现了完全背包问题的灵活应用和变通解法。
BUFFALO HD-QLU3_R5 用户手册：USB硬盘设置与维护指南
BUFFALO巴法洛HD-QLU3_R5系列是一款高性能的USB硬盘驱动器，用户手册主要分为六个部分，为用户提供全面的操作指导： 1. **布局**：这一部分详细介绍产品的物理结构，包括LED指示灯和各种连接接口的位置，帮助用户...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值