Codeforces Round #703 (Div. 2) A、B、D、E题解

写在前边

链接：Codeforces Round #703 (Div. 2)
这次的交互题是真不会做。

A. Shifting Stacks

链接：A题链接

题目大意:

有$n$摞高度分别为$h_i$的山，现在我们可以从每次从第$i$座山移动高度为$1$的移到$i + 1$座山上，问是否可以形成一个严格单调递增的山脉。

思路：

贪心的想我们一直挪山，让第一座山高度为$0$，第二座山高度为$1$，第三座山高度为为$2$，依次类推就可以了，这样形成$1,2,3,...,i$座山的总需要的高度就是$need = \cfrac{i(i-1)}{2}$, 所以我们对于枚举到的每一座山只需要判断目前拥有的高度$\sum\limits_{k = 1}^i h[k]$是否能构造出$need$即可，即$\sum\limits_{k = 1}^i h[k] > \cfrac{i(i-1)}{2}$

代码:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <map>
#include <cstring>

//#pragma GCC optimize(2)
//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;

const int Mod = 10000007;

const int N = 110;
LL h[N];

void solve() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%lld", &h[i]);
    LL sum = 0, need = 0;
    for (int i = 0; i < n; i++) {
        need += i;
        sum += h[i];
        if (sum < need) {
            puts("NO");
            return;
        }
    }
    puts("YES");
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t); 
    while (t--) {
        solve();
    }

    return 0;
}

B. Eastern Exhibition

链接：B题链接

题目大意:

给定一堆$(x，y)$,两点距离定义为$|x_2 - x_1| + |x_2 - x_1|$，现在需要选取有多少个点到每个点之和最小。

思路：

首先想到$|x_2 - x_1|$与$|x_2 - x_1|$坐标的距离互不影响,于是就可以转化成先求一维，然后利用乘法原理相乘就是结果。
对于一维，就是经典的货仓选址了，排个序，对于奇数个点，那么就中位数唯一，如果是偶数，那么可以选择两个中位数以及之间任意位置即可，即$[\cfrac{n}{2}, \cfrac{n}{2} + 1]$

代码:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <map>
#include <cstring>

//#pragma GCC optimize(2)
//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;

const int Mod = 10000007;

const int N = 1010;
int x[N], y[N];

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

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t); 
    while (t--) {
        solve();
    }

    return 0;
}

D. Max Median

链接：D题链接

题目大意:

给定一个数组长度为$n$的数组$a$，求长度为至少$k$的子数组的最大中位数。

思路：

参考博客:随处可见的阿宅
枚举一个最大的中位数明显可以用二分来优化，然后再检查其合理性，二分枚举一个$x$,检查其合理性即检查它是否为中位数的时候可以有一个技巧，即构造一个序列，让$\geq x$的数
为$1$，让$\leq x$的数为$-1$，那么这样来说，如果某一长度至少为$k$子段和大于$0$，那么$x$就是这个子段的中位数，很神奇，那么这里可以用前缀和优化，剩下的就是枚举长度至少为$k$的前缀和了，所以剩下的任务就是找一个$i \geq k$以及$j \in [1, i - k]$，且满足$s[i] - s[j] > 0$，而对于$s[j]$我们仅需要维护那个最小的前缀即可。

代码:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <map>
#include <cstring>

//#pragma GCC optimize(2)
//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;

const int Mod = 10000007;

const int N = 2e5 + 10;
int a[N], b[N], minpref[N]; 
int n, k;

bool check(int x) {
    for (int i = 1; i <= n; i++) b[i] = (a[i] >= x ? 1 : -1);
    for (int i = 1; i <= n; i++) b[i] += b[i - 1];
    for (int i = 1; i <= n; i++) minpref[i] = min(minpref[i - 1], b[i]);
    for (int i = k; i <= n; i++) {
        if (b[i] - minpref[i - k] > 0) 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 + 1;
    while (l < r) {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    
    printf("%d\n", l);
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    solve();

    return 0;
}

E - Paired Payment

链接：E题链接

题目大意:

最短路问题，只不过是一次只能走两步，不能一次一步走，比如a->b->c,那么就是a->c，花费是$(w_{ab} + w_{bc})^2$

思路：

参考博客:随处可见的阿宅
两天了，终于悟了，其实暴力跑单源最短路就可以，比如从$a->b->c$ ($a, b, c$指点集，不是具体的点)，那么就是从$a$搜到最短的$b$，然后再从$b$搜到最短的$c$，就是两重循环，然后看大佬一个很重要的优化就是，当$b$作为中间点的时候，我们可以维护一个$a->b$的最短路径，这样由于边权最大就是$50$，所以最坏情况下更新次数也不会超过$50$的，那么这题就终于这么过了。

代码:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <map>
#include <cstring>
#include <queue>

//#pragma GCC optimize(2)
//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;

const int Mod = 10000007;

const int N = 1E5 + 10, M = 4 * N;
int h[N], e[M], ne[M], w[M], idx;
int dist[N], mindist[N];
bool st[N];

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void Dijkstra() {
    priority_queue<PII, vector<PII>, greater<PII> > heap;
    heap.push({0, 1});
    memset(dist, 0x3f, sizeof dist), memset(mindist, 0x3f, sizeof mindist);
    dist[1] = 0;

    while (heap.size()) {
        auto t = heap.top();
        heap.pop();
        int var = t.second, cost = t.first;
        
        if (st[var]) continue;
        st[var] = true;

        for (int i = h[var]; i != -1; i = ne[i]) {
            int var1 = e[i], cost1 = w[i];
            if (mindist[var1] > cost1) {
                for (int j = h[var1]; j != -1; j = ne[j]) {
                    int var2 = e[j], cost2 = w[j];
                    if (dist[var2] > (cost2 + cost1) * (cost2 + cost1) + cost) {
                        dist[var2] = (cost2 + cost1) * (cost2 + cost1) + cost;
                        heap.push({dist[var2], var2});
                    }
                }
                mindist[var1] = cost1;
            }
        }
    }
}

void solve() {
    int n, m;
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    for (int i = 1; i <= m; i++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c);
    }

    Dijkstra();

    for (int i = 1; i <= n; i++) {
        if (dist[i] == 0x3f3f3f3f) printf("%d ", -1);
        else printf("%d ", dist[i]);
    }
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    solve();
    return 0;
}