2022 Hubei Provincial Collegiate Programming Contest题解 A,L

最新推荐文章于 2024-10-14 16:01:29 发布

yycQAQ

最新推荐文章于 2024-10-14 16:01:29 发布

阅读量1.1k

点赞数 37

文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/2301_80477996/article/details/137397127

版权

文章讲述了如何使用贪心策略、最短路径算法（如Floyd）、二分查找和数据结构（如并查集和线段树）解决一个关于无向图遍历的问题，涉及区间操作和激活/阻塞状态的管理。

摘要由CSDN通过智能技术生成

年轻人的第一篇题解，有做的不好的请多指教，A题因为爆了ll罚时爆炸了😡

A. Nucleic Acid Test

~~(pdf题面好少见)~~
大概翻译一下题意是：提供一个带边权的 $n$ 个点 $m$ 条边的无向图和时间 $t$ ，并设置一系列点为核酸检测点（下面简称为s点），核酸检测在 $t$ 秒内有效，位于s点时有效时间重置，且只有在核酸检测有效时才可进入其他点。接下来我们需要找到一个最小的速度 $v$ ，使得存在一种路线可以遍历图中所有点，且路线的起终点都是s点。无法找到合适的速度时，输出-1。

先考虑 $- 1$ 的情况：

注意到题目所给的 $t$ 可以是 $0$ ，显然当 $t$ 为 $0$ 的时候无解（此处为队伍贡献了1个罚时，望周知）
当题目所给无向图不联通时也无解，这里可以用一个并查集来维护图的连通性

首先先考虑贪心，我们要使速度尽可能的小，由于 $v = s / t$ ，其中 $t$ 固定，只有使 $s$ 最小，这里想到最短路，由于我们后面要枚举点对之间的最短路，所以用Floyd算法。

注意到题目要求最小的 $v$ ，不难想到二分，接下来就要考虑怎么check：
题目中要求起终点都要是核酸检测点，所以我们将点对分为两种情况：
s点和s点：起终点满足条件，所以满足 $\frac{f\left [ i \right ] \left [ j \right ]}{t} <=v$ 即可
s点和普通点：有一个点不满足条件，走一个来回就行了，故满足 $\frac{f\left [ i \right ] \left [ j \right ]*2 }{t} <=v$ 即可
两个普通点：无论如何都不能满足条件，直接跳过
我们将满足条件的点对用并查集进行合并，最后再检查所有点是否在一个联通块里面。
(这里 $0\le t \le 1e9$ 且 $v$ 有可能大于1e9，如果把 $t$ 乘到不等式右边会爆long long)

ac代码：

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n , m , k;
double t;
int f[400][400];
map<int , int> mp;
vector<int> sv;
int maxn = 0;
int fa[400];
int find(int x) {
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void insert(int x , int y) {
    int i = find(x) , j = find(y);
    if (i != j) {
        fa[i] = j;
    }
}
int check(int x) {
    int flg = 1;
    for (int i = 1;i <= n;i++) fa[i] = i;
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= n;j++) {
            if (mp[i] ^ mp[j]) {
                if (f[i][j] * 2 / t <= x) {
                    insert(i , j);
                }
            }
            else if (mp[i] || mp[j]) {
                if (f[i][j] / t <= x) {
                    insert(i , j);
                }
            }
        }
    }
    int tmp = 0;
    for (int i = 1;i <= n;i++) {
        if (tmp == 0) tmp = find(i);
        if (find(i) != tmp) flg = 0;
    }
    return flg;
}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m >> k;
    cin >> t;
    memset(f , 0x3f , sizeof(f));
    for (int i = 1;i <= n;i++) fa[i] = i;
    for (int i = 1;i <= m;i++) {
        int u , v , c;
        cin >> u >> v >> c;
        f[u][v] = c;
        f[v][u] = c;
        maxn = max(maxn , c);
        insert(u , v);
    }
    for (int i = 1;i <= k;i++) {
        int x;
        cin >> x;
        mp[x] = 1;
        sv.push_back(x);
    }
    for (int k = 1; k <= n; k++) {
        for (int x = 1; x <= n; x++) {
            for (int y = 1; y <= n; y++) {
                f[x][y] = min(f[x][y] , f[x][k] + f[k][y]);
            }
        }
    }
    int tmp = -1;
    for (int i = 1;i <= n;i++) {
        if (tmp == -1) tmp = find(i);
        if (find(i) != tmp || t == 0) {
            cout << -1 << endl;
            return 0;
        }
    }
    int l = 0 , r = 3e11 + 1;
    while (l < r) {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;
        else l = mid + 1;
    }
    cout << l << endl;
}

L. Chtholly and the Broken Chronograph

大概翻译一下题意：给定 $n$ 个数和它们对应的激活状态，实现一个数据结构，满足以下四个操作：

1 x 使第x个数阻塞
2 x 使第x个数激活
3 l r x 将 $\left [ l,r \right ] 内s_{i}=1$ 的数加上x
4 l r 输出 $\left [ l,r \right ]$ 内所有数的和

一眼线段树，对于区间加操作，我们需要维护 $\left [ l,r \right ]$ 之间激活的数的个数 $c n t$ ，每次只要对目标区间的和加上 $x * c n t$ ，这段对应的代码为tr[p].sum += k * (tr[p].r - tr[p].l + 1 - tr[p].cnt);(这里 $c n t$ 对应的是 $\left [ l,r \right ]$ 之间阻塞的数的个数，思路一样)。

阻塞和激活只要注意pushdown操作即可，不难实现。

ac代码：

#include <bits/stdc++.h>
#define lc p << 1
#define rc p << 1 | 1
#define int long long
using namespace std;
const int N = 1e5 + 100;

struct node
{
    int l , r , sum , add , cnt;
} tr[N * 4];
int n , m , a[N] , s[N];

void pushup(int p)
{
    tr[p].sum = tr[lc].sum + tr[rc].sum; 
    tr[p].cnt = tr[lc].cnt + tr[rc].cnt;//0激活 1阻塞
}
void pushups(int p) {
    tr[p].cnt = tr[lc].cnt + tr[rc].cnt;//0激活 1阻塞
}
void pushdown(int p)
{
    int ad = tr[p].add;
    tr[p].add = 0;
    tr[lc].sum += ad * (tr[lc].r - tr[lc].l + 1 - tr[lc].cnt);
    tr[lc].add += ad; //
    tr[rc].sum += ad * (tr[rc].r - tr[rc].l + 1 - tr[rc].cnt);
    tr[rc].add += ad; //
}
void build(int p , int x , int y)
{
    tr[p] = node{ x, y, a[x], 0 ,s[x] };
    if (tr[p].l == tr[p].r)
        return;
    int m = tr[p].l + tr[p].r >> 1;
    build(lc , x , m);
    build(rc , m + 1 , y);
    pushup(p);
}
void add(int p , int x , int y , int k)
{
    if (x <= tr[p].l && tr[p].r <= y) {
        tr[p].sum += k * (tr[p].r - tr[p].l + 1 - tr[p].cnt);
        tr[p].add += k;
        return;
    }
    pushdown(p);
    int m = tr[p].r + tr[p].l >> 1;
    if (x <= m)
        add(lc , x , y , k);
    if (y > m)
        add(rc , x , y , k);
    pushup(p);
}
int sum(int p , int x , int y)
{
    if (x <= tr[p].l && tr[p].r <= y) {

        return tr[p].sum;
    }
    int m = tr[p].l + tr[p].r >> 1;
    pushdown(p);
    int s = 0;
    if (x <= m)
        s += sum(lc , x , y);
    if (y > m)
        s += sum(rc , x , y);
    return s;

}
void actived(int p , int x) {
    if (x == tr[p].l && x == tr[p].r) {
        tr[p].cnt = 0;
        return;
    }
    pushdown(p);
    int mid = tr[p].l + tr[p].r >> 1;
    if (x <= mid) actived(lc , x);
    if (x > mid) actived(rc , x);
    pushup(p);

}
void blocked(int p , int x) {
    if (x == tr[p].l && x == tr[p].r) {
        tr[p].cnt = 1;
        return;
    }
    pushdown(p);
    int mid = tr[p].l + tr[p].r >> 1;
    if (x <= mid) blocked(lc , x);
    if (x > mid) blocked(rc , x);
    pushup(p);
}
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m;
    int opt , x , y , k;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    for (int i = 1;i <= n;i++) {
        cin >> s[i];
        s[i] ^= 1;
    }

    build(1 , 1 , n);
    while (m--) {
        int op;
        cin >> op;
        if (op == 1) {
            int x;
            cin >> x;
            blocked(1 , x);
        }
        else if (op == 2) {
            int x;
            cin >> x;
            actived(1 , x);
        }
        else if (op == 3) {
            int l , r , x;
            cin >> l >> r >> x;
            add(1 , l , r , x);
        }
        else if (op == 4) {
            int l , r;
            cin >> l >> r;
            cout << sum(1 , l , r) << endl;
        }
    }
}