Codeforces Round 966 (Div. 3) F~H

F. Color Rows and Columns

题目：

你们有 $n$ 个矩形，其中 $i$ 个矩形的宽度为 $a_i$ ，高度为 $b_i$ 。

您可以无限次地执行以下操作：选择一个矩形和其中的一个单元格，然后为其着色。

每次为任意一行或任意一列完全着色，你都可以获得 $1$ 分。您的任务是用尽可能少的操作获得至少 $k$ 分。

假设有一个长方形，宽为 $6$ ，高为 $3$ 。您可以通过对任意 $4$ 列中的所有单元格着色，从而执行 $12$ 次操作，得到 $4$ 分。

数据范围：$1\le n\le 1000,1\le k\le 100$，$1\le a_i,b_i\le 100$，保证所有测试用例中 $n$ 的值之和不超过 $1000$ 。

分析：

考虑动态规划，$dp[i][j]$ 表示从前 $i$ 个矩形中着色得到分数 $j$ 所使用的最小操作次数。

那么时间复杂度是 $O(n{k}^2)$ ，$O(n)$ 枚举矩形，$O(k)$ 枚举 $j$ ，$O(k)$ 枚举当前矩形得到的分数。

那么如果我们能够 $O(1)$ 地得到每个矩形得多少分所需的花费的话，就可以使用 $dp$ 求解。

记 $g[i][j]$ 表示第 $i$ 个矩形取 $j$ 分所需的操作次数，注意到对一个矩形进行操作一定是选择一行或一列数量少的进行着色，将这一行或列着色后，我们不妨令这行或列选择为最边上的行或列，那么着色后，矩形就变为一个更小的矩形，然后可以不断进行上述着色直到整个矩形被涂满。

那么这样对一个矩形来说时间复杂度就是 $O(k)$ 的。

注意：因为将整个矩形涂满的最后一次操作得分是 $2$ ，即涂满了一行和一列，这样使得得分是形如 $1,2,\dots ,a_i+b_i-2,a_i+b_i$ 的，没有 $a_i+b_i-1$ ，因此可能会使得从这 $n$ 个矩形中获得巧合 $k$ 分不行，但能获得 $k+1$ 分的情况。

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 1005, M = 105, inf = 0x3f3f3f3f;

int dp[N][M], g[N][M];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int T;
    cin >> T;
    while(T -- ) {
        int n, K;
        cin >> n >> K;
        vector<array<int, 2>> arr(n + 1);
        for(int i = 1; i <= n; i ++ ) {
            for(int j = 0; j < 2; j ++ ) {
                cin >> arr[i][j];
            }
        }
        for(int i = 0; i <= n; i ++ ) {
            for(int j = 0; j <= K + 1; j ++ ) {
                dp[i][j] = inf;
            }
        }
        for(int i = 1; i <= n; i ++ ) {
            auto [h, w] = arr[i];
            g[i][0] = 0;
            int cost = 0, pos = 0;
            while(true) {
                int tmp = min(h, w);

                cost += tmp;
                g[i][++ pos] = cost;
                if(h == tmp) w -- ;
                else h -- ;
                if(h == 0 || w == 0) {
                    g[i][++ pos] = cost;
                    g[i][pos - 1] = inf;
                    break;
                }
                if(pos > K) break;
            }
            for(int j = pos + 1; j <= K + 1; j ++ ) {
                g[i][j] = inf;
            }
        }

        dp[0][0] = 0;
        for(int i = 1; i <= n; i ++ ) {
            for(int j = 0; j <= K + 1; j ++ ) {
                dp[i][j] = dp[i - 1][j];
                for(int k = 0; k <= j; k ++ ) {
                    if(g[i][k] != inf && dp[i - 1][j - k] != inf) {
                        dp[i][j] = min(dp[i][j], dp[i - 1][j - k] + g[i][k]);
                    }
                }
            }
        }

        int ans = min(dp[n][K], dp[n][K + 1]);
        cout << (ans == inf ? -1 : ans) << '\n';
    }
    return 0;
}

G. Call During the Journey

题目：

你居住的城市由 $n$ 个十字路口和连接几对十字路口的 $m$ 条街道组成。您可以在每条街道上向任一方向行驶。没有两条街道连接同一对交叉路口，也没有一条街道连接一个交叉路口。您可以从任何一个交叉路口到达另一个交叉路口，也可能会经过其他一些交叉路口。

每分钟，你都可以在路口 $u_i$ 登上一辆公交车，行驶 $l_{i1}$ 分钟到达路口 $v_i$ 。相反，您可以在 $l_{i1}$ 分钟内从十字路口 $v_i$ 到达十字路口 $u_i$ 。您只能在交叉路口上下车。只有当您正在某个交叉路口时，才能在该交叉路口登上公共汽车。

您也可以沿着每条街道步行，这需要 $l_{i2}>l_{i1}$ 分钟。

您可以在十字路口停车。

您住在路口编号 $1$ 。今天您在时间 $0$ 起床，在路口编号 $n$ 安排了一个重要活动，您必须在时间 $t_0$ 之前到达。你还计划打一个电话，通话时间为 $t_1$ 至 $t_2$ 分钟（ $t_1<t_2<t_0$ ）。

通话期间，您不能乘坐公共汽车，但可以沿任何街道行走、停靠站点或待在家里。您可以在 $t_1$ 分钟下车，在 $t_2$ 分钟再次上车。

因为您想保证充足的睡眠，所以您开始好奇–您可以多晚出门，以便有时间讲电话，同时还不会在活动中迟到？

数据范围：
$2\le n\le 10^5,1\le m\le 10^5$

$1\le t_1<t_2<t_0\le 10^9$

$1\le u_i,v_i\le n$, $u_i\ne v_i$, $1\le l_{i1}<l_{i2}\le 10^9$

输出

对于每个测试用例，输出一个整数–您离开家的最晚时间，以便有时间讲电话而不会迟到。如果您不能按时到达活动地点，则输出 -1。

分析：

二分 $+$ $Dijkstra$ 求最短路，求最短路处理一下 $t_1,t_2$ 时间只能走路即可。

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 100010;
const ll inf = 1e18;

vector<array<int, 3>> adj[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int T;
    cin >> T;
    while(T -- ) {
        ll n, m, t0, t1, t2;
        cin >> n >> m >> t0 >> t1 >> t2;
        for(int i = 1; i <= n; i ++ ) adj[i].clear();
        for(int i = 0; i < m; i ++ ) {
            int u, v, l1, l2;
            cin >> u >> v >> l1 >> l2;
            adj[u].push_back({v, l1, 0});
            adj[u].push_back({v, l2, 1});
            adj[v].push_back({u, l1, 0});
            adj[v].push_back({u, l2, 1});
        }

        vector<ll> dist(n + 1, inf);
        vector<bool> vis(n + 1, false);
        auto check = [&](int mid) -> ll {
            for(int i = 1; i <= n; i ++ ) dist[i] = inf, vis[i] = false;
            dist[1] = mid;
            priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> que;
            que.push({dist[1], 1});
            while(que.size()) {
                auto [dis, u] = que.top();
                que.pop();
                if(vis[u]) continue;
                vis[u] = true;

                for(auto [v, w, type] : adj[u]) {
                    if(type == 0) {
                        if(dis >= t2 || dis + w <= t1) {
                            dist[v] = min(dist[v], dist[u] + w);
                            que.push({dist[v], v});
                        } else {
                            dist[v] = min(dist[v], t2 + w);
                            que.push({dist[v], v});
                        }
                    } else {
                        dist[v] = min(dist[v], dist[u] + w);
                        que.push({dist[v], v});
                    }
                }
            }

            return dist[n];
        };

        int l = -1, r = t0 - 1;
        while(l < r) {
            int mid = (l + r + 1) >> 1;
            if(check(mid) <= t0) l = mid;
            else r = mid - 1;
        }

        cout << l << '\n';
    }
    return 0;
}

H. Ksyusha and the Loaded Set

题目：

Ksyusha 决定创办一家游戏开发公司。为了在众多竞争者中脱颖而出并获得成功，她决定编写自己的游戏引擎。引擎必须支持最初由 $n$ 个不同的整数 $a_1,a_2,\dots ,a_n$ 组成的集合。

该集合将依次进行 $m$ 次操作。这些操作可以是以下类型：

• 将元素 $x$ 插入集合；
• 从集合中移除元素 $x$ ；
• 报告集合的 $k$ 负载。

例如，集合 { 3 , 4 , 6 , 11 } \{3, 4, 6, 11\} {3,4,6,11} 的 $3$ 负载为 $7$ ，因为集合中没有整数 $7,8,9$ ，也没有更小的值适合。

Ksyusha 忙于管理任务，所以你必须编写引擎。实现对所述操作的有效支持。

数据范围：
$1\le n\le 2\cdot 10^5$

$1\le a_1<a_2<\dots <a_n\le 2\cdot 10^6$

$1\le m\le 2\cdot 10^5$

$1\le x,k\le 2\cdot 10^6$

输出

对于每个测试用例，输出 "？" 类型操作的答案。

分析：

使用线段树，记数 $x$ 到后一个数 $y$ 之间的距离，线段树上取距离的 $max$ ，那么可以用线段树上二分取第一个距离大于等于 $k$ 的数。

#include<bits/stdc++.h>
using namespace std;

const int N = 4e5 + 10, inf = 4e6 + 5;

int n, m;

struct Node {
    int l, r;
    int v1, v2;
}tr[N << 2];

void pushup(Node &u, Node &l, Node &r) {
    u.v1 = l.v1 + r.v1;
    u.v2 = max(l.v2, r.v2);
}

void pushup(int u) {
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

void build(int u, int l, int r) {
    if(l == r) {
        tr[u] = {l, r, 0, 0};
    } else {
        tr[u] = {l, r};
        int mid = (l + r) >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void update(int u, int x, int v1, int v2) {
    if(tr[u].l == tr[u].r) {
        tr[u].v1 = v1, tr[u].v2 = v2;
    } else {
        int mid = (tr[u].l + tr[u].r) >> 1;
        if(x <= mid) update(u << 1, x, v1, v2);
        else update(u << 1 | 1, x, v1, v2);
        pushup(u);
    }
}

int query(int u, int l, int r) {
    if(l <= tr[u].l && tr[u].r <= r) {
        return tr[u].v1;
    } else {
        int res = 0;
        int mid = (tr[u].l + tr[u].r) >> 1;
        if(l <= mid) res += query(u << 1, l, r);
        if(r > mid) res += query(u << 1 | 1, l, r);
        return res;
    }
}

int query_p1(int u, int val) {
    if(tr[u].l == tr[u].r) {
        return tr[u].l;
    } else {
        if(tr[u << 1].v1 >= val) return query_p1(u << 1, val);
        else {
            return query_p1(u << 1 | 1, val - tr[u << 1].v1);
        }
    }
}

int query_(int u, int k) {
    if(tr[u].l == tr[u].r) {
        return (tr[u].v2 >= k ? tr[u].l : -1);
    } else {
        if(tr[u << 1].v2 >= k) return query_(u << 1, k);
        else return query_(u << 1 | 1, k);
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int T;
    cin >> T;
    while(T -- ) {
        cin >> n;
        vector<int> a(n);
        for(int i = 0; i < n; i ++ ) cin >> a[i];
        cin >> m;
        vector<pair<int, int>> opt(m);
        for(int i = 0; i < m; i ++ ) {
            int x;
            string s;
            cin >> s >> x;
            if(s[0] == '+') opt[i] = {0, x};
            else if(s[0] == '-') opt[i] = {1, x};
            else opt[i] = {2, x};
        }

        vector<int> arr;
        arr.push_back(0), arr.push_back(inf);
        for(auto x : a) arr.push_back(x);
        for(auto [type, x] : opt) {
            if(type != 2) {
                arr.push_back(x);
            }
        }
        sort(arr.begin(), arr.end());
        arr.erase(unique(arr.begin(), arr.end()), arr.end());

        build(1, 0, (int)arr.size() - 1);
        update(1, 0, 1, inf), update(1, (int)arr.size() - 1, 1, 0);
        for(auto x : a) {
            int pos = lower_bound(arr.begin(), arr.end(), x) - arr.begin();
            int val = query(1, 0, pos - 1);
            int p1 = query_p1(1, val), p2 = query_p1(1, val + 1);
            update(1, p1, 1, x - arr[p1] - 1), update(1, pos, 1, arr[p2] - x - 1);
        }
        for(auto [type, x] : opt) {
            if(type == 0) {
                int pos = lower_bound(arr.begin(), arr.end(), x) - arr.begin();
                int val = query(1, 0, pos - 1);
                int p1 = query_p1(1, val), p2 = query_p1(1, val + 1);
                update(1, p1, 1, x - arr[p1] - 1), update(1, pos, 1, arr[p2] - x - 1);
            } else if(type == 1) {
                int pos = lower_bound(arr.begin(), arr.end(), x) - arr.begin();
                update(1, pos, 0, 0);
                int val = query(1, 0, pos - 1);
                int p1 = query_p1(1, val), p2 = query_p1(1, val + 1);
                update(1, p1, 1, arr[p2] - arr[p1] - 1);
            } else {
                cout << arr[query_(1, x)] + 1 << ' ';
            }
        }
        cout << '\n';
    }
    return 0;
}