比赛题目训练系列16 (2021浙江省赛)

最新推荐文章于 2022-04-19 20:44:44 发布

zhezhidashi

最新推荐文章于 2022-04-19 20:44:44 发布

阅读量1.3k

点赞数 4

分类专栏： ACM题目整理

本文链接：https://blog.csdn.net/qq_45812711/article/details/116175572

版权

ACM题目整理专栏收录该内容

76 篇文章 6 订阅

订阅专栏

比赛题目训练系列16 (2021浙江省赛)

训练地址

D. Shortest Path Query

给至多 $10^5$ 个点，至多 $2 * 10^5$ 条双向边（边有权重）. 边有一个限制，就是两个顶点的编号，一个一定是另一个的二进制下的前缀。现在给至多 $10^5$ 个询问，给定两个结点，问两结点之间最短距离是多少.
任意两点之间 $s, t$ 的距离的最小值，等于从 $s$ 到两者所有公共祖先，再到 $t$ 的最小值.
我们先预处理出所有以此节点为 $r o o t$ 的子树构成的子图，跑一遍最短路。这样就处理出了从此节点为根节点的子图的单源最短路.
有一个问题是，跑 $n$ 遍dijkstra，不能每次都初始化vis和d数组。那么用两个时间戳，第一个记录当前点 $v i s [u]$ 是否等于 root，如果相等的话，从 root 到 u 的最短路就找到了。第二个是记录当前点的从 u 到 v. $v i s 2 [v]$ 是否 root. 如果是的话，那就把 $d [v]$ 初始化为 INF.

#include<bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int N = 100010, M = 400010;
int h[N], e[M], ne[M], w[M], idx;
typedef long long ll;
const ll INF = 0x3f3f3f3f3f3f3f3f;
typedef pair<ll, ll> P;
ll d[N], dist[N][20];
int vis[N], vis2[N];
void add(int a, int b, int c)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
int cal(int u, int v)
{
    int cnt = 0;
    while(v > u){
        cnt++;
        v >>= 1;
    }
    return cnt;
}
void dijkstra(int root)
{
    priority_queue<P, vector<P>, greater<P>> que;
    que.push({0, root});
    //这里不要忘记初始化.
    d[root] = 0;
    vis2[root] = root;
    while(que.size()){
        auto p = que.top(); que.pop();
        int u = p.y;
        if(vis[u] == root) continue;
        vis[u] = root;
        dist[u][cal(root, u)] = d[u];
        for(int i = h[u]; i != -1; i = ne[i]){
            int v = e[i];
            if(v < root) continue;
            if(vis2[v] != root){
                d[v] = INF;
                vis2[v] = root;
            }
            if(d[v] > d[u] + w[i]){
                d[v] = d[u] + w[i];
                que.push({d[v], v});
            }
        }
    }
}
int lca(int u, int v)
{
    while(u != v){
        if(u > v) u >>= 1;
        else v >>= 1;
    }
    return u;
}
int Length(int u)
{
    int cnt = 0;
    while(u){
        cnt++;
        u >>= 1;
    }
    return cnt;
}
int main()
{
    int n, m, q;
    scanf("%d%d", &n, &m);

    memset(dist, 0x3f, sizeof dist);
    memset(h, -1, sizeof h);
    for(int i = 1; i <= n; i++){
        dist[i][0] = 0;
    }
    for(int i = 0; i < m; i++){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(b, a, c), add(a, b, c);
    }
    scanf("%d", &q);
    for(int i = 1; i <= n; i++){
        dijkstra(i);
    }
    while(q--){
        int s, t;
        scanf("%d%d", &s, &t);
        ll ans = INF;
        int LA = lca(s, t);
        //printf("*** %d %d %d\n", s, t, LA);
        int l1 = Length(s) - Length(LA), l2 = Length(t) - Length(LA);
        while(LA){
            ans = min(ans, dist[s][l1] + dist[t][l2]);
            LA >>= 1;
            l1++, l2++;
        }
        if(ans == INF) printf("-1\n");
        else printf("%lld\n", ans);
    }
    return 0;
}

F. Fair Distribution

给两个数字 $n, m$ ，一次操作可以对 $n$ 减 1 或者对 $m$ 加1. 问至少需要多少次操作可以让 n 整除 m. 其中 $\le 10^8, m \le 10^8$ ，且有不超过1000次询问.
$\ge m$ 的情况非常显然答案是 $n - m$ . 我们只考虑 $n < m$ 的情况.
我们发现，如果确定了新的 $n$ ，那么对应的 m 的最小变化会唯一确定。
假设 $n$ 减小了 $\in [0, n - 1]$ ，那么 $m$ 应该跑到离 $n - x$ 的倍数最近的地方，即 $(\lceil \frac{m}{n-x} \rceil * (n-x))$ . 令 $i = n - x$ ，则 $\in [1, n]$ . 则 $m$ 对答案的贡献是 $\lceil \frac{m}{i} \rceil * i - i$ . $n$ 对答案的贡献是 $n - i$ .
向上取整转向下取整： $\lceil \frac{m}{n} \rceil = \lfloor \frac{m - 1}{n} \rfloor + 1$ . 因此 $m$ 对答案的贡献是 $\lfloor \frac{m-1}{i} \rfloor * i + i - m$
则最终的答案为 $\lfloor \frac{m-1}{i} \rfloor * i, i \in [1, n]$ . 这个可以用整除分块来写.

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll g(ll m, ll x)
{
    return m / (m / x);
}
int main()
{
    int T;
    scanf("%d", &T);
    while(T--){
        ll n, m;
        scanf("%lld%lld", &n, &m);
        if(m % n == 0){
            printf("0\n");
        }
        else if(n > m){
            printf("%lld\n", n - m);
        }
        else{
            ll res = 1e9;
            for(ll l = 1, r; l <= n; l = r + 1){
                r = min(n, g(m - 1, l));
                if(l <= n) res = min(res, (m - 1) / l * l);
                //printf("%lld %lld\n", l, res);
            }
            printf("%lld\n", n - m + res);
        }

    }
    return 0;
}