Codeforces Round #703 (Div. 2)（A ~ F）超高质量题解【每日亿题2 / 19】

整理的算法模板合集： ACM模板

点我看算法全家桶系列！！！

实际上是一个全新的精炼模板整合计划

---

A. Shifting Stacks

Translation

你有 $n$ 堆积木。第 $i$ 个堆栈包含 $h_i$ 块，它的高度是这堆积木的数量。在一次移动中，你可以从第 $i$ 个堆栈中取出一个积木（如果至少有一个积木的话）并将其放入第 $i+1$ 个堆积木中。问你能否将让积木的高度序列严格递增？

注意，堆栈的数量始终保持不变，也就是说哪怕这堆里没有积木了，这个堆也不会消失。

Solution

签到题 ~

很明显我们只需要构造出一个 $0,1,2,\cdots n+好多$ 的序列即可，就是前面的都堆到最后面，中间不够的话也可以借给他，然后就没了 ~

AC Code

#include 
#include 
#include 
#include 
#include 

using namespace std;
typedef long long ll;
typedef int itn;
const int N = 2e5 + 7;
const ll INF = 4e18;
 

int n, m, t;
int a[N], b, k1, k2;


bool solve()
{
     
    ll ans = 0;
    
    scanf("%d", &n);
    for(int i = 1;i <= n; ++ i) {
     
        scanf("%d", &a[i]);
    }
    int x = 0;
    for(int i = 1; i <= n; ++ i, x ++ ) {
     
        if(a[i] > x) {
     
            ans += a[i] - x;
            a[i] = x;
        }
        else {
     
            ll tmp = x - a[i];
            if(ans < tmp) {
     
                puts("NO");
                return ;
            }
            else ans -= tmp;
        }
    }
    puts("YES");
}

int main()
{
     
    scanf("%d", &t);
    while(t -- ) {
     
        solve();
    }
}

B - Eastern Exhibition

Problem

Translation

你和你的朋友住在 $n$ 个房子里（？）。每个房子都位于一个二维的平面上，在一个点上有整数坐标。同一地点可能有好多个不同的房子挤一块（）。市长问你展览馆要建到哪里，请你输出所有房子到这个展览馆的距离最近的点的数量（必须是整数点），注意展览馆同样可以建在其他房子头上（雾）。定义两点 $(x_1,y_1)$ 和 $(x_2,y_2)$ 之间的距离为 $|x_1-x_2|+|y_1-y_2|$。

Solution

签到题 ~

很明显这就是中位数的板子题，但是它把一维拓展到了二维，但是没什么区别

首先考虑一维怎么算，首先若 $n$ 是奇数，很明显答案就一定是 $1$，中位数固定了。

若是偶数，那么中间的那两个点之间的坐标都可以建（包括两个点，因为可以建到房子头上），那么对于二维来说，就是这个矩形里的所有的点都可以建呗，就乘起来 ~ 没了…

AC Code

#include 
#include 
#include 
#include 
#include 

using namespace std;
typedef long long ll;
typedef int itn;
const int N = 2e4 + 7;
const ll INF = 4e18;

 

int n, m, t;

int x[N], y[N];

void solve()
{
     
    scanf("%d", &n);
    for(int i = 1; i <= n; ++ i) {
     
        scanf("%d%d", &x[i], &y[i]);
    }
    sort(x + 1, x + 1 + n);
    sort(y + 1, y + 1 + n);
    ll numx = x[n / 2 + 1] - x[n / 2] + 1;
    ll numy = y[n / 2 + 1] - y[n / 2] + 1;
    if(n & 1)
        printf("1\n");
    else printf("%lld\n", numx * numy);
}

int main()
{
     
    scanf("%d", &t);
    while(t -- ) {
     
        solve();
    }
}

C1 - Guessing the Greatest (easy version)

C2 - Guessing the Greatest (hard version)

直接写的正解，然后这两题就一样了，所以就放一块了 ~

先睡觉

题解待更…

AC Code

#include 
#include 
#include 
#include 
#include 

using namespace std;
typedef long long ll;
typedef int itn;
const ll INF = 4e18;


inline int read()
{
     
	int re=0,k=1;char ch=getchar();
	while(ch>'9'||ch<'0'){
     if(ch=='-')k=-1;ch=getchar();}
	while(ch<='9'&&ch>='0'){
     re=re*10+ch-48;ch=getchar();}
	return re*k;
}

int n, m, t, p;

int ask(int l, int r)
{
     
    if(l == r) return -1;
    printf("? %d %d\n", l, r);
    fflush(stdout);
    int res;
    scanf("%d", &res);
    return res;
}

bool check(int l, int r)
{
     
    return ask(l, r) == p;
}

void solve()
{
     
    scanf("%d", &n);
    p = ask(1, n);
    int l, r, mid;
    if(ask(p, n) == p) {
     
        l = p;
        r = n;
        while(l <= r) {
     
            mid = (l + r) >> 1;
            if(check(p, mid)) {
     
                r = mid - 1;
            }
            else l = mid + 1;
        }
        printf("! %d\n", l);
        fflush(stdout);
    }
    else {
     
        l = 1;
        r = p;
        while(l <= r) {
     
            mid = (l + r) >> 1;
            if(check(mid, p)) {
     
                l = mid + 1;
            }
            else r = mid - 1;
        }
        printf("! %d\n", r);
        fflush(stdout);
    }
}

int main()
{
     
    solve();
}

D - Max Median

题解待更…

AC Code

#include 
#include 
#include 
#include 
#include 

using namespace std;
typedef long long ll;
typedef int itn;
const int N = 2e5 + 7;
const int INF = N * 10;
  
int n, m, t, k;
int a[N], b, k1, k2;
itn sum[N];

bool check(int mid)
{
     
    int minn = INF;
    for(int i = 1; i <= n; ++ i) {
     
        int val;
        if(a[i] >= mid) val = 1;
        else val = -1;
        sum[i] = sum[i - 1] + val;
        if(i >= k)
            minn = min(minn, sum[i - k]);
        if(minn < sum[i]) return true;
    }
    return false;
}


void solve()
{
     
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; ++ i) {
     
        scanf("%d", &a[i]);
    }
    int l = 1, r = n, ans;
    while(l <= r) {
     
        int mid = l + r >> 1;
        if(check(mid)) l = mid + 1, ans = mid;
        else r = mid - 1;
    }
    printf("%d\n", ans);
}

int main()
{
     
    solve();
}

E - Paired Payment

Translation

有 $n$ 城市和 $m$ 条无向边。形成一个无向加权图但不保证连通。每条边都有一个权值 $w$，政府制定了一项新的法律：你从一个城市出发，一次必须连续走两条路才能到达另一个城市，假设从 $a$ 到 $b$ ，再从 $b$ 到 $c$ ，相当于仅从 $a$ 走到了 $c$ ，中间城市仅路过不到达，花费的金额为 $(w_{ab}+w_{bc}{)}^2$。问从起点 $1$ 开始到其余所有点的最小花费，若无法到达输出 -1 。

$2\le n\le 10^5,1\le m\le min(\frac{n\cdot (n-1)}{2},2\cdot 10^5)$

对于每一条边（保证无重边）

$1\le v_i,u_i\le n,1\le w_i\le 50,u_i\ne v_i$

Solution

很明显就是一个最短路问题，看上去直接跑一个 Dijkstra 就行了。但是本题特殊就特殊在行走的方式不同。这里每一条直接连通的边并不能直接到达，每次行动必须有一个中间城市作为跳板，且花费为 $(w_{ab}+w_{bc}{)}^2$，看上去好像没法做，因为如果直接暴力连边，那么对于每一条边来说，需要与它下一条边组合起来再连接，时间复杂度光连边就需要 $O(n^2)$ …

一步一步来，首先给你的直接相连的边是一定要连起来的，但是肯定不是 Dijkstra 中可以走的边，所以 “经典” 思路，我们要把他们连到虚拟映射点上把他们区分开，具体怎么映射现在还不知道。因为不能暴力连边，点数很大，所以我们考虑一下能不能预处理出一张可以直接转移的图来跑最短路，我们来分析一下边和点的性质。

根据题意，我们一次移动需要跳过一个城市，所以对于每一个城市（点）来说只有两个状态，一个是作为中间节点，被跳过去，一个是作为终点，到达，所以我们可以朝着这个方向思考如何分别表示这两个状态。由于我们每次只输入一条边，也就意味着我们知道当前这条边的权值，但是不知道下一条边（下一层）的权值，也不知道上一条边（上一层）的权值，好像没法玩了，但是如果你仔细读题就会发现， $w\le 50$ ！哦，那没事了。 也就是说我们一共只有 $50$ 种情况，我们就可以将这 $50$ 种边全部连起来，连的时候分别分配一个虚拟节点，然后算出它们的这一整条路（两条拼一块）的实际权值（连了不一定用嘛）。我们在转移的时候只需要从虚拟起点出发经过题目中给定的路线在虚拟图中的映射最终到达虚拟终点即可。这就是解题的大致思路。

解释一下就是：我们假设当前边为 $(x,y,w)$ ，我们现在要给他建图，那么对于这条边的两端 $x$ 和 $y$，一共只有两种情况：

情况一：点 $x$ 作为中间结点，上一层 $a$ 跳过 $x$ 到达 $y$

情况二：点 $x$ 作为上一次转移的终点同时也是这一次转移的起点，跳过 $y$ 到达下一层 $b$

分别来分析：

对于情况一，我们现在已知从 $x$ 到 $y$ 的边的权值 $w$ ，不知道从 $a$ 到 $x$ 的权值，那么我们就可以先枚举 $1\to 50$ 作为从 $a$ 到 $x$ 的权值，这样我们现在已知的信息为：上一层到中间节点 $x$ 的距离， $x$ 到终点 $y$ 的距离。

对于情况二，我们现在已知从 $x$ 到 $y$ 的边的权值 $w$ ，不知道从 $y$ 到 $b$ 的权值，那么我们同样枚举 $1\to 50$ 作为从 $y$ 到 $b$ 的权值，这样我们现在已知的信息为： $x$ 到中间节点 $y$ 的距离， $y$ 到下一层终点 $b$ 的距离。

所以考虑如何根据这些已知条件的同性设计出一个 hash映射函数来得到虚拟点的下标，就是一个很经典的 hash，我们知道每个节点的下标 $x$，和权值 $w$，我们可以令 $hash=x\times p+w$。我们设中间节点的 $w$ 为边的权值，终点的 $w$ 为 $0$ 。就好像是上半段往下半段匹配一样，因为每一半段都只有自己的权值大小，我们就按照这个性质去设计。

这样我们就得到了建图代码：

void add(itn x, int y, int w)
{
     
    __add(Hash(x, 0), Hash(y, w), 0);
    for(int i = 1; i <= 50; ++ i) {
     
        __add(Hash(x, i), Hash(y, 0), (i + w) * (i + w));
    }
}

这样我们转移的时候，对于情况二，从边 $(x,y,w1)$ 开始，从 $Hash(x,0)$ 经过 $Hash(y,w1)$ （权值为 $0$），这里的 $Hash(y,w1)$ 的hash值等于下一条边 $(k,z，w2)$ 的中间结点枚举到的 $w1$ ，即 $Hash(k,w1)$（题中给的路线）也就是 $y=k$，然后从 $Hash(k,w1)$ 到 $Hash(z,0)$，权值为已经预处理好的 $(w1+w2{)}^2$。

至于这里hash里的 $p$ ，取一个大于 $50$ 的质数就行了，不要太大，大了会RE

建完图以后，我们只需要从起点 $1$ 的虚拟映射点出发跑一遍 Dijkstra ，最终每个点的最短路就是每个点的虚拟映射的 dist 。

最后注意一共 $m\le 2\times 10^5$，每条边需要连 $52\times 2=104$，总边数为 $2\times 10^7+8$，前向星开不下，所以改成 vector 存边就行了

AC Code

#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int N = 1e7 + 7, M = 1e7 + 7, mod = 1e9 + 7, INF = 0x3f3f3f3f;
typedef long long ll;
typedef int itn;
typedef pair<int, int> PII;

int n, m, k, t;
int dist[M];

typedef struct
{
     
    itn y, w;
}edge;

vector<edge>G[M];

int Hash(int x, int w)
{
     
    return x * 57 + w;
}

void __add(int x, int y, int w)
{
     
    G[x].push_back((edge){
     y, w});
}

void add(itn x, int y, int w)
{
     
    __add(Hash(x, 0), Hash(y, w), 0);
    for(int i = 1; i <= 50; ++ i) {
     
        __add(Hash(x, i), Hash(y, 0), (i + w) * (i + w));
    }
}

void dijkstra(int S)
{
     
    memset(dist, 0x3f, sizeof dist);
    dist[S] = 0;
    priority_queue<PII, vector<PII>, greater<PII> >q;
    q.push({
     0, S});
    while(q.size()) {
     
        itn x = q.top().second;
        int d = q.top().first;
        q.pop();
        if(d != dist[x]) continue;

        for(auto it : G[x]) {
     
            itn y = it.y, w = it.w;
            if(dist[y] > d + w) {
     
                dist[y] = d + w;
                q.push({
     dist[y], y});
            }
        }
    }
}

int main()
{
     
    //init();
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; ++ i) {
     
        int x, y, w;
        scanf("%d%d%d", &x, &y, &w);
        add(x, y, w);
        add(y, x, w);
    }
    dijkstra(Hash(1, 0));
    for(int i = 1; i <= n; ++ i) {
     
        if(dist[Hash(i, 0)] == INF)  dist[Hash(i, 0)] = -1;
        printf("%d ", dist[Hash(i, 0)]);
    }
    puts("");
    return 0;
}

F - Pairs of Paths

待更…