2020牛客暑期多校训练营（第一场）

最新推荐文章于 2020-11-12 16:23:52 发布

Zaller

最新推荐文章于 2020-11-12 16:23:52 发布

阅读量319

点赞数

分类专栏：多校

本文链接：https://blog.youkuaiyun.com/Yubing792289314/article/details/107471680

版权

多校专栏收录该内容

19 篇文章

订阅专栏

H. Minimum-cost Flow · 费用流

https://ac.nowcoder.com/acm/contest/5666/H

每次查询都相当于在问：所有的边的容量都为 $\cfrac{u}{v}$ 、且费用流跑出的总流量为 $\cfrac{v}{v}$ 时的最小费用

可以建图时将所有的边的容量都设置为1，这样每次增广路出来的残流固定都是1

预先跑出最大流，

那么跑所有的边的容量都为 $\cfrac{u}{v}$ 的新图时，每次残流都为原来容量为1时的 $\cfrac{u}{v}$ 倍，其最大流就是原来最大流的 $\cfrac{u}{v}$ 倍

如果连新图的最大流都无法达到 $\cfrac{v}{v}$ ，很明显最小费用就不需要求了

如果可以达到，即总流量每次加 $\cfrac{u}{v}$ 后，存在某一个时刻，累加到了 $\cfrac{v}{v}$ ，此时的累加的费用就是答案

并且总费用 = 所有增广路跑出来的残流产生的费用之和，而每次残流的费用 = 所有经过的路上【流量 x 每单位流量产生的费用】之和，已知每次残流固定为1，残流费用之和=总费用

而每次给出的 $(u, v)$ 并不会对图怎么跑产生影响，所有边都是一起扩倍的，不存在某一条边突然不能走的情况，所以可以利用预处理的图，将过程中产生的费用全部存起来，

相当于抛弃寻找增广路的过程，直接统计每次产生的结果

特判最后跑的那一次可能不足 $\cfrac{u}{v}$ 的流量

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 55 + 10;
int n, m, k;

namespace cost_flows { //最小费用最大流板子
    //设定起点和终点
    int st;//起点-源点
    int ed;//终点-汇点

    struct egde {
        int to, next;
        int flow;//剩余流量
        int dis; //花费
    } e[N * 2 * 2];

    int head[N], tot = 1;

    void add(int u, int v, int w, int cost) {//出发点 下一个点 流量 费用
        e[++tot] = {v, head[u], w, cost};
        head[u] = tot;
        e[++tot] = {u, head[v], 0, -cost};
        head[v] = tot;//费用流反相边流量为0 费用是-dis
    }

    queue<int> q;

    int flow[N];//增广路上最小流量
    int inq[N];//是否在队里里 等同于vis
    int last[N];//每个点所连的前一条边的编号
    int dis[N];//到达每个节点的最小花费 即 最短路
    int pre[N];//每个节点的前驱节点

    bool spfa() {
        memset(flow, INF, sizeof(flow));
        memset(dis, INF, sizeof(dis));//注意了 这里是最大值
        memset(inq, 0, sizeof(inq));

        q.push(st);

        dis[st] = 0;
        inq[st] = 1;//在队列中 标记
        pre[ed] = -1;//ok 还没有到达汇点

        while (!q.empty()) {
            int u = q.front();
            q.pop();
            inq[u] = 0;//出队 标记

            for (int i = head[u]; i; i = e[i].next) {
                int v = e[i].to;
                if (dis[v] > dis[u] + e[i].dis && e[i].flow) { //有流量才能松弛
                    dis[v] = dis[u] + e[i].dis;
                    pre[v] = u;
                    last[v] = i;
                    flow[v] = min(flow[u], e[i].flow);

                    if (!inq[v]) {
                        inq[v] = 1;
                        q.push(v);
                    }
                }
            }
        }
        return pre[ed] != -1;//即 没有到达汇点
    }

    ll max_flow, min_cost;


    ll Cost[N];
    int Cnt = 0;

    void MCMF() {// - 费用流主体
        while (spfa()) {//如果有增广路
            int now = ed;
            max_flow += flow[ed];
            min_cost += flow[ed] * dis[ed];
            
            Cost[++Cnt] = flow[ed] * dis[ed];

            while (now != st) {//遍历这条增广路
                //从汇点一直回溯到源点
                e[last[now]].flow -= flow[ed];
                e[last[now] ^ 1].flow += flow[ed];
                now = pre[now];
            }
        }
    }

    void init() {
        tot = 1;
        memset(head, 0, sizeof(head));
        while (!q.empty()) q.pop();
        max_flow = 0;
        min_cost = 0;

        Cnt = 0;
    }
}
using namespace cost_flows;


int main() {
    while (~scanf("%d%d", &n, &m)) {
        init();

        st = 1;
        ed = n;
        for (int i = 1, u, v, c; i <= m; i++) {
            scanf("%d%d%d", &u, &v, &c);
            add(u, v, 1, c);
        }

        MCMF();

        int q;
        ll u, v;
        scanf("%d", &q);
        while (q--) {
            scanf("%lld%lld", &u, &v);
            if (max_flow * u < v) {//如果总容量加起来都达不到1
                puts("NaN");
                continue;
            }

            ll mole = 0;
            ll deno = v;
            for (int i = 1; i <= Cnt; i++) {
                if (v >= u) {
                    v -= u;
                    mole += u * Cost[i];
                } else { // 最后那次不够 u/v 的部分
                    mole += v * Cost[i];
                    break;
                }
            }
            
            ll g = __gcd(mole, deno);
            printf("%lld/%lld\n", mole / g, deno / g);
        }
    }
    return 0;
}

I. 1 or 2 · 带花树

https://ac.nowcoder.com/acm/contest/5666/I

拆边拆点，最后进行边的端点与点的匹配

建图原理见下面这篇博客↓

据说是原题来着：HDUOJ 3551 Hard Problem

#include <bits/stdc++.h>
using namespace std;
const int N = 10000 + 10;
int n, m;

int cnt = 0;//点的编号
vector<int> id[N];//id[i]保存 点i被拆成d[i]个点时 每个点的编号

namespace FlowerTree { // 带花树 一般图最大匹配 O(FlowerTree_n^3)
    int FlowerTree_n;

    // FlowerTree_n 1000
    // 每个节点只能有一个匹配对象
    struct Edge {
        int to, next;
    } e[N];
    int head[N], tot = 1;//tot为边的编号

    int fa[N];//fa[i] 记录i点属于哪一个点为根的花
    int pre[N];//pre[i] i的前驱节点
    queue<int> Q;//int Q[N * N * 2], h, t;//bfs队列 头尾
    int Match[N];//Match[i]标记匹配的对象
    int tim;//lca时间戳
    int Type[N];//Type[i]标记i点的类型 奇节点：1 偶节点：2 没有标记过时为0
    int dfn[N];//每个节点的lca时间戳


    void addEdge(int u, int v) { //建双边
        e[++tot] = {v, head[u]};
        head[u] = tot;
        e[++tot] = {u, head[v]};
        head[v] = tot;
    }

    int find(int x) {
        return fa[x] == x ? x : fa[x] = find(fa[x]);
    }

    int lca(int x, int y) {
        ++tim;
        x = find(x);
        y = find(y);
        while (dfn[x] != tim) {
            dfn[x] = tim;
            x = find(pre[Match[x]]);
            if (y) swap(x, y);
        }
        return x;
    }

    // 开花操作
    // 将奇环缩成一个点 并将原来奇点的点变为偶点 并加入队列中
    void blossom(int x, int y, int p) {
        while (find(x) != p) {
            pre[x] = y;
            y = Match[x];
            if (Type[y] == 2) {
                Type[y] = 1;
                Q.push(y);
            }
            fa[x] = p;
            fa[y] = p;
            x = pre[y];
        }
    }

    bool Aug(int st) { //从没有匹配的u点开始bfs找增广路 将其标记为A类点
        memset(Type, 0, sizeof Type);
        memset(pre, 0, sizeof pre);

        for (int i = 1; i <= FlowerTree_n; i++) {
            fa[i] = i;
        }

        while (!Q.empty())Q.pop();

        Q.push(st);
        Type[st] = 1;//标记为奇点

        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();

            for (int i = head[u]; i; i = e[i].next) {
                int v = e[i].to;
                //如果遇到了偶节点 就忽略不管
                if (find(u) == find(v) || Type[v] == 2) continue;

                // 如果这个点没有被匹配过 说明找到了一条增广路
                // 因为队列里存的都是奇点 所以找到的那个没有匹配过的点肯定是偶点
                if (!Type[v]) {
                    Type[v] = 2;
                    pre[v] = u;

                    if (!Match[v]) {
                        // 找到now之前的那个节点x 将原先匹配过的x匹配现在的节点
                        // 让原来匹配的那个节点重新找别人匹配
                        for (int now = v, x; now; now = x) {
                            x = Match[pre[now]];
                            Match[now] = pre[now];
                            Match[pre[now]] = now;
                        }
                        return true;
                    }

                    //如果有匹配 则v是偶点 将v匹配的对象放入队列中
                    Type[Match[v]] = 1;
                    //Q[t++] = Match[v];
                    Q.push(Match[v]);
                } else if (Type[v] == 1) {
                    // 如果找到的点是奇点 即 找到环了
                    // 就进行开花操作
                    int p = lca(u, v);
                    blossom(u, v, p);
                    blossom(v, u, p);

                }
            }
        }
        return false;
    }

    void init() {
        memset(Match, 0, sizeof Match);
        memset(head, 0, sizeof head);
        memset(dfn, 0, sizeof dfn);

        tim = 0;
        tot = 1;
    }

}
using namespace FlowerTree;
int d[N];

int main() {
    ios::sync_with_stdio(false);

    while (2 == scanf("%d%d", &n, &m)) {
        init();
        cnt = 0;

        for (int i = 1; i <= n; i++) {
            scanf("%d", &d[i]);
            //拆点 给拆出来的每个点都赋上编号
            for (int j = 0; j < d[i]; j++) {
                id[i].push_back(++cnt);
            }
        }

        for (int i = 1, u, v; i <= m; i++) {
            scanf("%d%d", &u, &v);

            int x = ++cnt;//将边的拆成两个点 e(x,y)
            //将其两个端点x、y和u、v所有拆出来的点相连
            for (int j = 0; j < d[u]; j++) {
                addEdge(id[u][j], x);
            }
            int y = ++cnt;
            for (int j = 0; j < d[v]; j++) {
                addEdge(id[v][j], y);
            }

            addEdge(x, y);//补上这条边
            //其实就是 点与边的端点 进行匹配
        }
        FlowerTree_n = cnt;

        int res = 1;
        for (int i = 1; i <= FlowerTree_n; i++) {
            if (!Match[i]) {
                res &= Aug(i);
            }
        }

        if (res) {
            puts("Yes");
        } else {
            puts("No");
        }

        for (int i = 1; i <= n; i++) {
            id[i].clear();
        }
    }
    return 0;
}

J. Easy Integration

https://ac.nowcoder.com/acm/contest/5666/J
$\int_{0}^{1} (x-x^2)^n\, dx=\int_{0}^{1}x^n(1-x)^n\,dx\\=\int_0^1\frac{(1-x)^n}{n+1}\,d(x^{n+1})=\cfrac{(1-x)^nx^{n+1}}{n+1}\bigg|^1_0-\int_0^1x^{n+1}\,d(\frac{(1-x)^n}{n+1}) \\=-\int_0^1-\frac{n}{n+1}x^{n+1}(1-x)^{n-1}\,dx =\frac{n}{n+1}\int_0^1 x^{n+1}(1-x)^{n-1}\,dx$
同理可得
$\int_0^1 x^{n+1}(1-x)^{n-1}dx=\frac{n+1}{n+2}\int_0^1 x^{n+2}(1-x)^{n-2}dx$
因此
$\int_{0}^{1} (x-x^2)^n\, dx=\frac{n!}{(n+1)(n+2)...(2n)}\int_0^1x^{2n}\,dx=\cfrac{(n!)^2}{(2n+1)!}$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 998244353;

const int N = 2e6 + 100;
ll qpow(ll a, ll b) {
    a %= mod;
    ll res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        b >>= 1;
        a = a * a % mod;
    }
    return res;
}

ll fac[N], inv[N];

void init(int n) {
    fac[0] = inv[0] = 1;
    for (int i = 1; i <= n; ++i) {
        fac[i] = fac[i - 1] * i % mod;
        inv[i] = inv[i - 1] * qpow(i, mod - 2) % mod;
    }
}

int n;

int main() {
    ios::sync_with_stdio(false);
    init(2000000);
    while (~scanf("%d", &n)) {
        printf("%lld\n", qpow(fac[2 * n + 1] * inv[n] % mod * inv[n] % mod, mod - 2) % mod);
    }
    return 0;
}