2022“杭电杯”中国大学生算法设计超级联赛（8）

最新推荐文章于 2025-07-23 09:00:03 发布
原创 最新推荐文章于 2025-07-23 09:00:03 发布 · 338 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

本文解析了2022年“杭电杯”中国大学生算法设计超级联赛第八场的六道题目，包括直线覆盖点、序列翻转、长方形划分等，提供了详细的思路与代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

2022“杭电杯”中国大学生算法设计超级联赛（8）

[题目链接](Search Result (hdu.edu.cn))

D Quel’Thalas

题目大意

在二维平面上，[0,n]*[0,n]的整数点中去掉(0,0)之后，最少需要多少条直线使得每个整数点至少有一条边覆盖。

题解

易得平行于x轴的n条直线和平行于y轴的n条直线即可满足上述条件，且此为最少的直线数量。

代码

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
int t, n;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> t;
    while (t--)
    {
        cin >> n;
        cout << 2 * n << endl;
    }
    return 0;
}

A Theramore

题目大意

有一个01序列，可以任意翻转奇数长度的区间，求能达到的最小字典序。

题解

使用长度为 3 的翻转，那么位置奇偶性相同的位置可以随便换。对奇数位置和偶数位置，分别把 0 放到前面，1 放到后面即可。

代码

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
int t, n, id1, id2;
string s;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> t;
    while (t--)
    {
        cin >> s;
        n = s.size();
        vector<char> v1, v2;
        id1 = id2 = 0;
        for (int i = 0; i < n; i++)
        {
            if (i % 2)
                v1.push_back(s[i]);
            else
                v2.push_back(s[i]);
        }
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
        for (int i = 0; i < n; i++)
        {
            if (i % 2)
                cout << v1[id1++];
            else
                cout << v2[id2++];
        }
        cout << endl;
    }
    return 0;
}

K Stormwind

题目大意

一个n*m的长方形，可以沿水平或竖直方向画若干条线，每条线的两端点都在长方形的边界上。要求
这些线划分出的每个小长方形面积都>=k，求最多可以画几条线。

题解

二分。

checked函数：因为每一个小长方形的面积都需要大于等于k，所以划分的时候应该尽量平均划分，所以只需要求最小的长方形的面积是否大于等于k即可，而最小的长方形的边长就是n / (i + 1)，即长度除以划分的线的数量。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll maxn = 1e2 + 5;
const ll mod = 1e9 + 7;
ll t, n, m, k;
bool checked(ll mid)
{
    ll x, y, j;
    for (ll i = 0; i <= mid; i++)
    {
        j = mid - i;
        x = n / (i + 1), y = m / (j + 1);
        if (x * y >= k)
            return 1;
    }
    return 0;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> t;
    while (t--)
    {
        cin >> n >> m >> k;
        ll l = 0, r = n + m - 2, mid, ans;
        while (l <= r)
        {
            mid = (l + r) / 2;
            if (checked(mid))
            {
                ans = mid;
                l = mid + 1;
            }
            else
                r = mid - 1;
        }
        cout << ans << endl;
    }
    return 0;
}

H Orgrimmar

题目大意

求一棵树的最大分离集的大小，分离集中每个点至多有一条边与分离集中另一个点相连。

题解

树形dp。

定义dp数组中，父节点u及其子节点v的状态：dp[u] [0]表示u不选择；dp[u] [1]表示u选择，v不选择；dp[u] [2]表示u选择，且v选择。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e5 + 5;
const int Max = 0x3f3f3f3f;
int t, n;
vector<int> g[maxn];
int dp[maxn][5];
void dfs(int u, int fa)
{
    int x0 = 0, x1 = 0, x2 = -Max;
    for (auto v : g[u])
    {
        if (v == fa)
            continue;
        dfs(v, u);
        x0 += max({dp[v][0], dp[v][1], dp[v][2]});
        x1 += dp[v][0];
        x2 = max(x2, dp[v][1] - dp[v][0]);
    }
    dp[u][0] = x0;
    dp[u][1] = x1 + 1;
    dp[u][2] = x2 + x1 + 1;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int size(512 << 20);
    __asm__("movq %0, %%rsp\n" ::"r"((char *)malloc(size) + size));
    cin >> t;
    while (t--)
    {
        cin >> n;
        for (int i = 1; i <= n; i++)
            g[i].clear();
        for (int i = 1; i < n; i++)
        {
            int u, v;
            cin >> u >> v;
            g[u].push_back(v);
            g[v].push_back(u);
        }
        dfs(1, 0);
        cout << max({dp[1][0], dp[1][1], dp[1][2]}) << endl;
    }
    exit(0);
}

E Ironforge

题目大意

一条链，每个点上有一个数ai，每条边上有一个质数bi。一开始在某个点上，有一个空背包，走到一个
点上可以把它的质因子放进背包，一条边如果背包里有那个质数就可以走。多组询问求从 x 出发能否走
到 y。

题解

[大佬链接](2022 杭电多校(8) 个人题解 更新至6题 - 知乎 (zhihu.com))

讲的超级清楚！！！太牛了！！！

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 5;
int t, n, m;
int a[maxn], b[maxn];
int l[maxn], r[maxn], minp[maxn];
vector<int> pos[maxn];
void init()
{
    for (int i = 1; i <= 200000; i++)
        pos[i].clear();
    for (int i = 1; i <= n; i++)
    {
        while (a[i] > 1)
        {
            int p = minp[a[i]];
            while (a[i] % p == 0)
                a[i] /= p;
            pos[p].push_back(i);
        }
    }
}
bool checked(int p, int l, int r)
{
    if (pos[p].size() == 0)
        return 0;
    return upper_bound(pos[p].begin(), pos[p].end(), r) - lower_bound(pos[p].begin(), pos[p].end(), l);
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    for (int i = 2; i <= 200000; i++)
    {
        if (minp[i])
            continue;
        for (int j = i; j <= 200000; j += i)
            if (!minp[j])
                minp[j] = i;
    }
    cin >> t;
    while (t--)
    {
        cin >> n >> m;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        for (int i = 1; i < n; i++)
            cin >> b[i];
        init();
        for (int i = n; i >= 1; i--)
        {
            r[i] = i;
            while (r[i] < n && checked(b[r[i]], i, r[i]))
            {
                r[i] = r[r[i] + 1];
            }
        }
        for (int i = 1; i <= n; i++)
        {
            l[i] = i;
            if (i > 1 && r[i - 1] >= i)
            {
                if (checked(b[i - 1], i, r[i]))
                {
                    l[i] = l[i - 1];
                    r[i] = r[i - 1];
                }
            }
            else
            {
                bool flag = 1;
                while (flag)
                {
                    flag = 0;
                    while (l[i] > 1 && checked(b[l[i] - 1], l[i], r[i]))
                    {
                        flag = 1;
                        l[i] = l[l[i] - 1];
                    }
                    while (r[i] < n && checked(b[r[i]], l[i], r[i]))
                    {
                        flag = 1;
                        r[i] = r[r[i] + 1];
                    }
                }
            }
        }
        for (int i = 1; i <= m; i++)
        {
            int x, y;
            cin >> x >> y;
            if (y >= l[x] && y <= r[x])
                cout << "Yes" << endl;
            else
                cout << "No" << endl;
        }
    }
    return 0;
}

G Darnassus

题目大意

给出一个排列p，把每个位置视为点，建一个无向图，i，j之间的边权为|i-j|*|pi-pj|。求这个图的最小生成树。

题解

依次连接i和i+1，每条边的边权等于|p[i+1]-p[i]|<=n-1（因为p数组是排列），且有n-1条，因此最小生成树中的每条边的边权一定<=n-1。

边权为|i-j|*|pi-pj|，意味着|i-j|和|pi-pj|必有至少一个<=sqrt(n-1)，因此需要找到所有这样的边，然后使用Kruskal 算法求出最小生成树即可。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e4 + 5;
const int maxm = 5e7 + 5;
int t, n, cnt, num, ans;
ll res;
int a[maxn], pos[maxn], head[maxn];
int f[maxn], r[maxn];
struct Edge
{
    int u, v, next;
} e[maxm];
void init()
{
    cnt = res = ans = 0;
    num = sqrt(n);
    memset(head, -1, sizeof head);
    memset(r, 0, sizeof r);
    for (int i = 1; i <= n; i++)
        f[i] = i;
}
int find(int i)
{
    if (f[i] == i)
        return i;
    return f[i] = find(f[i]);
}
void unionn(int i, int j)
{
    int i_fa = find(i);
    int j_fa = find(j);
    if (i_fa != j_fa)
    {
        if (r[i_fa] < r[j_fa])
            swap(i_fa, j_fa);
        f[j_fa] = i_fa;
        if (r[i_fa] == r[j_fa])
            r[i_fa]++;
    }
}
void add(int u, int v, int w)
{
    e[cnt].u = u;
    e[cnt].v = v;
    e[cnt].next = head[w];
    head[w] = cnt++;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> t;
    while (t--)
    {
        cin >> n;
        init();
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
            pos[a[i]] = i;
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = i + 1; j <= n && j <= i + num; j++)
            {
                int w = abs(i - j) * abs(a[i] - a[j]);
                if (w < n)
                    add(i, j, w);
            }
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = i + 1; j <= n && j <= i + num; j++)
            {
                int w = abs(i - j) * abs(pos[i] - pos[j]);
                if (w < n)
                    add(pos[i], pos[j], w);
            }
        }
        for (int i = 0; i <= n - 1; i++)
        {
            for (int j = head[i]; j != -1; j = e[j].next)
            {
                int u = e[j].u, v = e[j].v;
                if (find(u) == find(v))
                    continue;
                unionn(u, v);
                res += i;
                if (++ans == n - 1)
                    break;
            }
            if (ans == n - 1)
                break;
        }
        cout << res << endl;
    }
    return 0;
}
Troyyee
关注
2022“杭电杯”中国大学生算法设计超级联赛（1）题解
qq_64102892的博客
07-21 37
那么对于一个物品(v,w)(v,w)(v,w)，转移为f[i][j][k]=f[i−1][j][k]∣f[i−1][jxorv][k−v]f[i][j][k]=f[i-1][j][k]|f[i-1][j\xor\v][k-v]f[i][j][k]=f[i−1][j][k]∣f[i−1][jxorv][k−v]②没有取第i件物品，f[i][j][k]=f[i-1][j][k]
2022“杭电杯”中国大学生算法设计超级联赛 （1) 杭电多校第一场 2 3 4 5 8 12
qq_34832548的博客
07-20 1805
读取每一位，若为0则表示不通过该墙，若为1则表示可以通过该墙，并且把不能通过的墙进行标记，然后在后续的dfs中查找是否存在上述条件中可以到达终点的情况，若存在就把当前情况中的1（二进制看）记录一个最小值，最后输出即可，需要注意的是偏移的位置处理。因为数据很小，所以可以用暴力搜索的方法解决，不妨用二进制的方式遍历每一种可能，从0开始到。因为时求最大的异或和，所以我们可以用是否存在作为DP的结果。其中i表示前i个物品，j表示异或和，k表示当前的体积。给你体积和价值，问你当背包装满时最大异或和时多少。......
2022“杭电杯”中国大学生算法设计超级联赛（8）（1,4,8,11）
yu_yang10的博客
08-21 468
蒟蒻第8场
2022“杭电杯”中国大学生算法设计超级联赛（8）题解报告
m0_66388127的博客
08-31 389
2022“杭电杯”中国大学生算法设计超级联赛（8）题解报告
2022“杭电杯”中国大学生算法设计超级联赛（8）题解
qiandixiaoyuer的博客
08-22 346
杭电暑假多校第8场 第1，4，11题题解
2022“杭电杯”中国大学生算法设计超级联赛训练日志
qq_43003147的博客
07-24 834
点石成我的训练日志
2022“杭电杯”中国大学生算法设计超级联赛（2）
08-28
杭电杯联赛的算法资料，适用于正在参加算法类比赛的人员或即将参加算法的人员，算法设计、快速编程和自我调试。这是所有比赛都必须的： 给定一个问题，需要很快地设计出算法，很快地编写出程序，并且在整个算法设计...
2022“杭电杯”中国大学生算法设计超级联赛
08-28
杭电杯联赛的算法资料，适用于正在参加算法类比赛的人员或即将参加算法的人员，算法设计、快速编程和自我调试。这是所有比赛都必须的： 给定一个问题，需要很快地设计出算法，很快地编写出程序，并且在整个算法设计...
2022“杭电杯”中国大学生算法设计超级联赛（10）
08-28
杭电杯联赛的算法资料，适用于正在参加算法类比赛的人员或即将参加算法的人员，算法设计、快速编程和自我调试。这是所有比赛都必须的： 给定一个问题，需要很快地设计出算法，很快地编写出程序，并且在整个算法设计...
杭电多校-Darnassus-(最小生成树本质+预处理+链式向前星)
m0_52398496的博客
08-13 379
就是给你一个数组全排列，任意两点间的距离是abs(i-j)*abs(p[i]-p[j])。现在问你所有点联通起来的最小花费。
2022杭电多校八 1007-Darnassus（kruscal）
AC__dream的博客
08-14 326
给出一个排列p，把每个位置视为点，建一个无向图，i，j之间的边权为|i-j|*|pi-pj|。求这个图的最小生成树。
2022 年杭电多校第八场补题记录
m0_52048145的博客
08-12 929
2022 年杭电多校第八场补题记录
2022杭电多校8 Darnassus（最小生成树）
weixin_54562114的博客
08-14 368
解题思路：求这个图的生成树，最简单的方法就是相邻两个点相连，这样每条边的权值为|p[i]-p[j]|
枚举右，维护左基础篇
最新发布
m0_68367618的博客
07-23 352
本文总结了力扣题单中基于双变量问题的通用解法模板。核心思路是：通过维护已遍历区间（使用哈希表、集合或滑动窗口），枚举未遍历区间来优化双变量问题。
力扣-300.最长递增子序列
weixin_46878941的博客
07-22 445
小结：注意最长递增子序列可能不包含最后一个值，所以要用一个变量记录。
数组题目总结 前缀和草稿
weixin_47868976的博客
07-21 636
前缀和数组用于快速 频繁地计算一个索引区间内的元素之和！（还有么？深入说说！例题303要是没学过 前缀和那也简单 就累加呗！这个解法每次调用 sumRange 函数时，都要进行一次 for 循环遍历，时间复杂度为ONO(N)，而 sumRange 的调用频率可能非常高，所以这个算法的效率很低。正确的解法是使用前缀和技巧进行优化，使得 sumRange 函数的时间复杂度为O1(上面代码换成cpp！一维的很容易理解！类比一维求区间和。
【爱创大师】【算法】算法中的博弈论
weixin_56334307的博客
07-21 249
"石头剪刀布"作为全球通用的决策游戏，其历史可追溯至汉代《手势令》，而现代意义下的博弈论分析始于约翰·纳什1950年的均衡理论。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值