2023第十四届河南省ICPC省赛部分题解

已于 2024-05-19 21:36:20 修改
阅读量1.2k 收藏 22
点赞数 30
文章标签： 算法 数据结构 c++
于 2024-05-18 23:25:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqqzzzhhh123/article/details/139032739
版权 
7a684047-65b5-481c-8550-b8712baed8d0

        

去年大一缺乏体验，今年比赛前心血来潮又V了一把，彻底成为竞赛败犬。。。。

K.连通最小乘积

        签到，贪心搞一下，根据乘法结合分配律优化一下，正数负数相互结合就行。


vector<ll> fu,zheng;
void solve()
{
    int n;
    cin >> n;
    for(int i=1;i<=n;i++){
        int t;cin>>t;
        if(t<=0) fu.push_back(t);
        else zheng.push_back(t);
    }
    sort(zheng.begin(),zheng.end());
    sort(fu.begin(),fu.end());
    ll ans=0;
    int ff=fu.size();
    int zz=zheng.size();
    if(fu.size()==0){
        for(int i=1;i<zheng.size();i++){
            ans+=zheng[0]*zheng[i];
        }
    }
    else if(zheng.size()==0){
        for(int i=fu.size()-2;i>=0;i--){
            ans+=fu[ff-1]*fu[i];
        }
    }
    else{
        ll tt=0;
        ans=0;
        for(int i=0;i<zz;i++){
            tt+=zheng[i];
        }
        for(int i=0;i<ff;i++){
            ans+=tt*fu[i];
        }
    }
    cout<<ans;
}
}

L.行星探索

        也算个签到吧，很裸的二维前缀和，队友很快就A了。膜%%%%

#pragma GCC optimize(3, "Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 2e6 + 7;
const int mod = 998244353;
int s[1010][1010][4];
char p[1010][1010];
void solve()
{
    int n, m, k;
    cin >> n >> m >> k;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            char x;
            cin >> x;
            if (x == 'C')
                s[i][j][1] = 1;
            if (x == 'M')
                s[i][j][2] = 1;
            if (x == 'F')
                s[i][j][3] = 1;
        }

    for (int p = 1; p <= 3; p++)
    {
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                s[i][j][p] += s[i - 1][j][p] + s[i][j - 1][p] - s[i - 1][j - 1][p];
    }
    while (k--)
    {
        int x, y, xx, yy;
        cin >> x >> y >> xx >> yy;
        for (int p = 1; p <= 3; p++)
            cout << s[xx][yy][p] - s[x - 1][yy][p] - s[xx][y - 1][p] + s[x - 1][y - 1][p] << " ";

        cout << "\n";
    }
}

M.二手物品回收

        很一眼的全裸多重背包题，据说因为数据水很多人贪心过（，这里把每个商家看成一组，每组有自己的物品，可以选一些带走，背包容量为k，每次花费体积为1。需要特别注意的是需要严格选择k个，即使亏钱(crazy). 

        复杂度分析的话应该是O(m(k + n))。因为物品总数只有n个。

#include <bits/stdc++.h>
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 1e3 + 10;
const int mod = 998244353;
ll dp[N][N];
int n, m, k;
vector<int> e[N];
ll c[N];
void solve()
{
    cin >> n >> m >> k;
    for (int i = 1; i <= m; i++)
    {
        cin >> c[i];
    }
    for (int i = 1; i <= n; i++)
    {
        int a, b;
        cin >> a >> b;
        e[b].push_back(a);//统计每组数量
    }
    for(int i=0;i<=m;i++){
        for(int j=0;j<=k;j++){
            dp[i][j] = -inf;//初始化为负数
        }
    }
    for (int i = 1; i <= m; i++)
    {
        sort(e[i].rbegin(), e[i].rend());
    }
    dp[0][0] = 0;
    for (int i = 1; i <= m; i++)
    {

        for (int j = k; j >= 0; j--)
        {
            ll sum = 0;
            dp[i][j] = dp[i - 1][j];
            for (int p = 0; p < e[i].size(); p++)
            {
                sum += e[i][p];
                if (p + 1 <= j)
                {
                    dp[i][j] = max(dp[i][j], dp[i - 1][j - p - 1] + sum - c[i]);
                }
            }
        }
    }
    cout << dp[m][k] << '\n';
}

C.结对编程 

        也算个签到吧，没模数提示有点明显，找到规律就好了，队友又速A了%%%%

#pragma GCC optimize(3, "Ofast")
#include <bits/stdc++.h>
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 1e3 + 10;
const int mod = 998244353;
void solve()
{
    int n;
    cin >> n;
    map<int, int> mp;
    for (int i = 2; i <= n; i++)
    {
        int x;
        cin >> x;
        mp[x]++;
    }
    ll ans = 0;
    for (int i = 1; i <= n; i++)
    {
        int x;
        cin >> x;
        ans += x;
        ans -= 1ll * x * mp[i];
    }
    cout << ans << endl;
}

以上就是23年省赛最签到的几个题了，仍记得全场坐牢的场景（惨。

G.异或解密

        比较诈骗的一个题，玄学复杂度。

        考虑原题式子可以左移可化为 Xi ^ a = Yi 。拆解成二进制可以理解为对于60位中的每一位，都可以使这一位置为 0 或 1 ，贡献与原来数字对应位数为1个数有关。

        比如第j位有p个数包含1，如果a第j位为1，则贡献为 (1<<j) * (n - p),为0时则 *p。那么我们可以考虑爆搜，对于每一位分别置0/1时观察答案,时间复杂度为 O(2的60次方) （雾。

        考虑剪枝，一个比较明显的剪枝是，当前位置0/1后产生的贡献大于可以到达的最大值，则不可以。另一个比较难观察的是，如果当前位后面所有位置为1时是能得到的最大值，如果这个值比要达到的值还要小，就证明不可能。

        到此即可通过本题。

额外注意的一点是过程中可能会爆 int64.


#include <bits/stdc++.h>
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
using ll = long long;
using pii = pair<int, int>;
#define ll __int128_t
const int N = 1e3 + 10;
const int mod = 998244353;
ll d[60];
long long n, S;
long long ans = 1e18;
bool dfs(ll now, ll p, ll res)
{
    if (p == -1)
    {
        if (now == 0)
        {
            ans = res;
            return true;
        }
        return false;
    }
    ll k =  d[p]*(1ll << p);

    if (k <= now&&(now - k) / n<=__int128_t((1ll << p) - 1))
    {
        if (dfs(now - k, p - 1, res))
        {
            return true;
        }
    }
    k = (1ll << p) * (n - d[p]);
    if (k <= now&&(now - k) / n<=__int128_t((1ll << p) - 1))
    {
        return dfs(now - k, p - 1, res + (1ll << p));
    }
    return false;
}
void solve()
{

    cin >> n >> S;
    for (int i = 0; i < n; i++)
    {
        long long x;
        cin >> x;
        for (int j = 0; j < 60; j++)
        {
            if (x >> j & 1)
            {
                d[j]++;
            }
        }
    }

    dfs(S, 59, 0);
    if (ans == 1e18)
    {
        cout << -1 << '\n';
    }
    else
    {
        cout << ans << '\n';
    }
}

A.列车售货员难题

        很好的一道题，使我汗流浃背。。。。

        比较朴素的想法是，枚举所有区间计算答案，但是显然会超时。此时我们注意到m的大小只有100，我们对于m进行优化。考虑枚举区间左端点，对于这个左端点会产生的贡献，考虑从最右端减到最左端，每当丢失一种物品时会产生贡献，而丢失物品的次数不超过m次。我们可以预处理出dp[i][j]表示以i为左端点，j最后一次出现的位置(靠左)是哪里，之后我们可以在O(nm)的枚举中处理出答案。

        到这这题已经差不多了，但是还有一个折磨我许久的问题是如何去重，因为这些区间产生的集合可能是重复的，一个比较经典的写法是使用__int128表示集合，每一位表示对应第i个有没有，最后使用map或set去重即可。我使用了一种哈希异或映射的方法通过本题。

#pragma GCC optimize(3, "Ofast")
#include <bits/stdc++.h>
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using ull = unsigned long long;
const int N = 2e5 + 10;
const int mod = 998244353;
const ll os = 1331;
int f[N][110];
mt19937_64 rnd(98275314);

long long gen()
{
	long long x = 0;
	while(x == 0)
		x = rnd();
	return x;
}
void solve()
{
    int n, m;
    cin >> n >> m;
    vector<vector<int>> a(n + 1);
    vector<ll>mp(m + 1);
    for(int i=1;i<=m;i++){
        mp[i] = gen();//每一个都映射一种值
    }
    for (int i = 1; i <= n; i++)
    {
        int k;
        cin >> k;
        a[i].resize(k);
        for (auto &x : a[i])
        {
            cin >> x;
        }
    }
    for (int i = n; i >= 1; i--)
    {
        for (int j = 1; j <= m; j++)
        {
            f[i][j] = f[i + 1][j];
        }
        for (auto x : a[i])
        {
            f[i][x] = i;
        }
    }
    set<ll> s;
    for (int i = 1; i <= n; i++)
    {
        vector<pii> id;
        ll ps = 0;
        for (int j = 1; j <= m; j++)
        {
            if (f[i][j] == 0)
                continue;
            id.push_back({f[i][j], j});
        }
        sort(id.begin(), id.end());
        for (int j = 0; j < id.size(); j++)
        {
            ps ^= mp[id[j].second];
        }
        if(ps)s.insert(ps);//非空
        for (int j = id.size() - 1; j >= 0; j--)
        {
            ps ^= mp[id[j].second];
            if (j > 0 && id[j].first == id[j - 1].first)
                continue;
            if (ps)
                s.insert(ps);
        }
    }
    cout << s.size() << '\n';
}

I.calc

        很nice的一道题，使我思维旋转。

        求方案数，考虑计数dp。但是一看数据范围1e7和7。很合理的想到状压dp+矩阵快速幂优化。

        考虑如何设计状态，k的范围是[1,7]，考虑连续的七个数，用二进制状态表示，根据输入处理出不合法的状态，可以得到1-7的答案，考虑向后递推。每向左移动一位，产生的新的状态判断是否合法，如果合法即可转移。再看对于左移加一，如果合法且上一个丢失的位置与这一位没有冲突，也可以转移，由此可设计出(1<<k) * (1<<k)的转移矩阵，直接转移即可。

#pragma GCC optimize(3, "Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 7;
const int mod = 998244353;
struct Mat
{
    int v[130][130] = {0};
    int x, y;
    Mat() {}
    Mat(int _x, int _y) { x = _x, y = _y; }
    // 清空
    void zero()
    {
        memset(v, 0, sizeof(v));
        x = y = 0;
    }
    // 单位矩阵化
    void ones()
    {
        memset(v, 0, sizeof(v));
        for (int i = 0; i <= x; i++)
        {
            v[i][i] = 1;
        }
    }
    // 乘法
    void Mul(Mat a, Mat b)
    {
        zero();
        x = a.x, y = b.y;
        int c = a.y;
        for (int i = 0; i <= x; ++i)
        {
            for (int j = 0; j <= y; ++j)
            {
                for (int k = 0; k <= c; ++k)
                {
                    v[i][j] += (long long)a.v[i][k] * b.v[k][j] % mod;
                    v[i][j] %= mod;
                }
            }
        }
        return;
    }
    // 打印
    void show()
    {
        for (int i = 1; i <= x; i++)
        {
            for (int j = 1; j <= y; j++)
            {
                cout << v[i][j] << " ";
            }
            cout << '\n';
        }
    }
};
Mat operator*(const Mat &x, const Mat &y)
{
    Mat res;
    res.Mul(x, y);
    return res;
}
Mat ksm(Mat a, long long b)
{
    Mat x = a;
    x.ones();
    while (b)
    {
        if (b & 1)
            x = x * a;
        b >>= 1;
        a = a * a;
    }
    return x;
}
void solve()
{
    int k, n;
    cin >> k >> n;
    vector<int> s(8);
    for (int i = 0; i < k; i++)
    {
        int x;
        cin >> x;
        s[x] = 1;
    }
    vector<int> f(1 << 7);
    for (int i = 0; i < (1 << 7); i++)
    {
        vector<int> a;
        for (int j = 0; j < 7; j++)
        {
            if (i >> j & 1)
            {
                a.push_back(j + 1);
            }
        }
        int ok = 1;
        for (int p = 0; p < a.size(); p++)
        {
            for (int q = p + 1; q < a.size(); q++)
            {
                if (s[a[q] - a[p]])
                    ok = 0;
            }
        }
        f[i] = ok;
    }//预处理合法位置
    if (n <= 7)
    {
        int ans = 0;
        for (int i = 0; i < (1 << n); i++)
        {
            ans += f[i];
        }
        cout << ans - 1<< '\n';
    }
    else
    {
        Mat a(1, (1 << 7) - 1);
        for (int i = 0; i < (1 << 7); i++)
        {
            a.v[1][i] = f[i];
        }
        Mat op(127, 127);
        for (int i = 0; i < (1 << 7); i++)//设计矩阵
        {
            int sp = i;
            int ok = 0;
            if (sp & (1 << 6))
                ok = 1;
            if (ok)
                sp -= (1 << 6);
            sp <<= 1;
            op.v[i][sp] = 1;
            op.v[i][sp | 1] = f[sp | 1] && !(s[7] && ok);//新旧位是否冲突
        }
        
        Mat res = a * ksm(op, n - 7);
        ll ans = 0;
        for(int i=0;i<(1<<7);i++){
            ans += res.v[1][i];
            ans %= mod;
        }
        cout << ans - 1<< '\n';//减去全0方案数
    }
}

到这差不多结束了，但还是有点遗憾，再口胡两道已知的题目。

F.实验器材采购

        23年赛时过了这个题，当时是学长写的，据说是一个带修莫队(雾

H.部落冲突

        很裸的半平面交，因为23年赛时没学过用其它麻烦的方法没调出来而感到遗憾（败犬

。。。。不会LateX使我的题解难看。

7a684047-65b5-481c-8550-b8712baed8d0
小爬菜、
关注
  • 30
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
ICPC2023 西安区域赛 题解.pdf
11-09
ICPC2023 西安区域赛 题解 本文档提供了 ICPC2023 西安区域赛的题解，涵盖了五个题目：A - An Easy Geometry Problem、B - Counting Multisets、C - Counting Strings、D - Deep Intervals 和 E - Dominating Point...
2021河南省第十三届ICPC程序设计竞赛题解.pdf
05-30
2021河南省第十三届ICPC程序设计竞赛-题解
河南省第十四届ICPC大学生程序设计竞赛
00后的博客
05-28 1618
有N组物品和一个容量是V的背包。每组物品有若干个，同一组内的物品最多只能选一个。每件物品的体积是vij​，价值是wij​，其中i是组号，j是组内编号。求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。输出最大价值。
河南省第十三届ICPC程序设计竞赛部分题解
wmy0217_的博客
07-23 1024
文章目录牛客重现赛：I-七便士J-甜甜圈L-手动计算 牛客重现赛： https://ac.nowcoder.com/acm/contest/17148 I-七便士 思路：如果全部0相连就输出Yes，否则输出No。因为如果全部0相连，第2个0可以放个硬币然后移到第一个0上，第3个0可以放个硬币然后移到第2个0上…最后有7个硬币。dfs即可。 #include<iostream> using namespace std; int n; string s; void dfs(int x) {
河南省第十四届ICPC大学生程序设计竞赛—C结对编程
tang7mj的博客
03-13 1593
一、信息（题目的有用信息） 公司员工数目 n：范围为1到200,000。 每个员工的上级信息：从2号员工到n号员工，每个员工的直接上级编号。 每个员工的权限值：从1号到n号员工的权限值。 选出的子集人数必须是偶数：才能安排结对编程活动，否则会受到罚款。 计算期望损失的钱数乘以 (2^n - 1)：输出为整数，可能为负值表示赚到钱。 二、分析 树的构建：题目给出的是一个树形结构，根节点为1号员工，其它员工都有一个直接上级。 权限值的作用：在选出的子集中，根据子集的奇偶性，权限值决定了奖励或罚款的金额。 子集的
河南省第十三届ICPC大学生程序设计竞赛 题解
HeartFireY的博客
05-30 1820
河南省第十三届ICPC大学生程序设计竞赛 题解 难的题挺难，简单的也很简单。总体而言题目质量还可以，有许多很新奇的知识点插入。 A. 祝融传火 题目给定n∗mn * mn∗m矩阵以及长宽为h,wh,wh,w的矩形，问是否存在A[x][y],A[x+H−1][y],A[x][y+W−1],A[x+H−1][y+W−1]A[x][y],A[x+H-1][y],A[x][y+W-1],A[x+H-1][y+W-1]A[x][y],A[x+H−1][y],A[x][y+W−1],A[x+H−1][y+W−1]四个点
河南省第十四届ICPC大学生程序设计竞赛—A列车售货员难题
tang7mj的博客
02-25 1127
正确答案展示了一种高效解决复杂问题的方法，它利用了数据预处理、位运算、排序和去重等技术。这种方法不仅解决了问题，也提供了一种对于处理类似问题的通用框架。然而，为了保证代码的可读性和维护性，可能需要对其中的一些高级技巧进行适当的封装和注释。
第 46 届 ICPC 亚洲区域赛(昆明)正式赛试题
04-17
1. **ICPC (国际大学生程序设计竞赛)**：ICPC，全称为International Collegiate Programming Contest，是一项全球性的编程竞赛，旨在测试参赛者在解决问题和算法实现上的能力。 2. **ACM竞赛**：ACM是ICPC的前身，...
2018ICPC沈阳网络赛题解
09-09
这是2018ICPC沈阳网络赛的题解，这是2018ICPC沈阳网络赛的题解
第45届ICPC国际大学生程序设计竞赛亚洲区域赛（沈阳站）题目题解
04-06
本资源为第45届ICPC国际大学生程序设计竞赛亚洲区域赛（沈阳站）题目题解，比赛时长一共五小时，题目为全英文题目，并且在比赛的时候可以使用一切纸质书籍，但禁止使用电子产品，一组三个队员，只允许使用一台电脑，...
【DS】河南省第十三届ICPC大学生程序设计竞赛 J-甜甜圈
weixin_62528401的博客
04-14 747
在用线段树和树状数组之前，先去考虑好我们要维护的是哪个序列，我们需要维护的是序列的什么值。每次操作我们找出最大值的位置，贡献加上该最大值头上有几个，然后把它删除。因为他有两根，因此考虑把两根棒合并成一根，然后维护这一根就行。至于怎么去维护贡献，只需要记录上一次删除的位置即可。这样就可以直接维护了，这题用线段树和也可以做！直接模拟复杂度太高，因此考虑用DS优化。对于第一次删除，上一次删除的位置在n。那就是把这两根棒头对头放着就行。对于这道题，首先需要构造序列。我们考虑用树状数组维护。删除其实就是把1变成0。
2021河南省第十三届ICPC程序设计竞赛(题目.终榜.总结)
热门推荐
风口IT猪的成长录
05-23 1万+
ICPC/ACM完整榜单比赛题目A. 祝融击火B. HoneycombC. Alice and BobD. ConnicE. Dance with stickF. 图像识别G. Elo mountainsH. 焦糖布丁I. 七便士J. 甜甜圈K. 残局L. 手动计算M. 输入输出总结 完整榜单 终榜，今年采用区域赛标准的滚动榜单，还是蛮高级的。 比赛题目 A. 祝融击火 BF四个点判断即可，注意边界问题 B. Honeycomb C. Alice and Bob D. Connic
算法-KMP字符串匹配
xx_xb的博客
07-23 163
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 385
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 642
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 735
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 303
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
2023西安ICPC邀请赛题解
09-15
引用: 这个问题是关于Bob在一个包含1到n的全排列中与Alice进行游戏的题目。Bob需要在操作中避免出现两次相同的第一个数p1。...引用: 对于这个特定题目，如果n=2023，Bob能获胜的次数是(n-1)的阶乘，即2022的阶乘。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小爬菜、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值