写在前边
链接：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}), 所以我们对于枚举到的每一座山只需要判断目前拥有的高度(sumlimits_{k = 1}^i h[k])是否能构造出(need)即可，即(sumlimits_{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 '
'
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 '
'
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
", (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 '
'
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
", 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 '
'
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;
}