Codeforces Round #703 (Div. 2) (A~E)
A. Shifting Stacks
题目链接
题目大意
给定 \(N\) 个土堆，第 \(i\) 个土堆有 \(Ai\) 个木块
你可以将第 \(i\) 个土堆的木块转移至第 \(i + 1\) 个土堆
问能否使土堆的木块数量构成上升序列
解题思路
贪心
最优的构造方法即令土堆的木块数一次为 $0 , 1 , 2 , 3 ... $
定义 \(sum[i]\) 为 \(ai\) 的前缀和，那么只要判断是否每个前缀和都满足 \(sum[i] >= (i - 1) × i / 2\)
AC_Code
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e2 + 10;
int n , a[N] , sum[N];
signed main()
{
int T = 1;
cin >> T;
while(T --)
{
cin >> n;
for(int i = 1 ; i <= n ; i ++) cin >> a[i] , sum[i] = sum[i - 1] + a[i];
bool ok = true;
for(int i = 1 ; i <= n ; i ++)
{
if(sum[i] - (i - 1) * i / 2 < 0) {
ok = false ; break ;
}
}
if(ok) cout << "YES\n";
else cout << "NO\n";
}
return 0;
}
B. Eastern Exhibition
题目链接
题目大意
二维平面上给定 \(n\) 个点，问存在多少个整数坐标点使得这些点到 \(n\) 个点的曼哈顿距离总和最小
解题思路
如果是一维直线，那么这些点只会存在于横坐标 \(x\) 的中位数之间，或者纵坐标 \(y\) 的中位数之间
那么满足条件的点个数即为 横坐标 \(x\) 的中位数之间的长度 或 纵坐标 \(y\) 的中位数之间的长度
拓展到二维这些点的个数即为横坐标 \(x\) 的中位数之间的长度 \(×\) 纵坐标 \(y\) 的中位数之间的长度
当 \(n\) 为奇数时，\(x\) 的中位数只有 \(1\) 个，\(y\) 的中位数只有 \(1\) 个，所以答案为 \(1\)
当 \(n\) 为偶数时，答案即是 \(x\) 的中位数之间的长度 \(×\) \(y\) 的中位数之间的长度
AC_Code
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e3 + 10;
int n , x[N] , y[N];
signed main()
{
int T = 1;
cin >> T;
while(T --)
{
cin >> n;
for(int i = 1 ; i <= n ; i ++) cin >> x[i] >> y[i];
sort(x + 1 , x + 1 + n) , sort(y + 1 , y + 1 + n);
if(n & 1) cout << 1 << '\n';
else cout << (x[n / 2 + 1] - x[n / 2] + 1) * (y[n / 2 + 1] - y[n / 2] + 1) << '\n';
}
return 0;
}
C1&C2.Guessing the Greatest
题目链接
题目大意
交互问题
有一个序列，每次你可以询问区间 \([L , R]\) 的次大值的位置
要求在 \(20\) 次询问内找出最大值的位置
解题思路
对于区间 \([L , R]\) 的次大值位置为 \(pos\)
那么最大值必然只出现在区间 \([L , pos - 1]\) 或区间 \([pos + 1 , R]\)
于是可以再次询问区间 \([L , pos]\) 的次大值位置判断最大值是位于区间 \([L , pos-1]\) 还是区间 \([pos +1 , R]\)
当 \(query([L , pos]) = pos\) , 且 \(pos != 1\) 时，最大值处于区间 \([L , pos - 1]\)
此时可以令 \(R = pos - 1\) , 并二分最大值的位置 \(mid\)
如果 \(query([mid , pos]) = pos\) ，则可以确定最大值位于区间 \([mid , pos]\) , 于是舍弃 \([l , mid - 1]\)
否则可以确定最大值不位于区间 \([mid , pos]\) , 于是二分的区间改为 \([l , mid - 1]\)
否则最大值位于区间 \([pos +1 , R]\) , 操作大致同上
AC_Code
#include<bits/stdc++.h>
using namespace std;
int n , x;
int query(int l , int r)
{
cout << "? " << l << " " << r << '\n';
cin >> x;
return x;
}
signed main()
{
cin >> n;
int l = 1 , r = n , res = 0;
int pos = query(1 , n);
if(pos != 1 && query(1 , pos) == pos)
{
l = 1 , r = pos - 1;
while(l <= r)
{
int mid = l + r >> 1;
if(query(mid , pos) == pos) res = mid , l = mid + 1;
else r = mid - 1;
}
}
else
{
l = pos + 1 , r = n;
while(l <= r)
{
int mid = l + r >> 1;
if(query(pos , mid) == pos) res = mid , r = mid - 1;
else l = mid + 1;
}
}
cout << "! " << res << '\n';
return 0;
}
D. Max Median
题目链接
题目大意
给定一个序列，要求选出一个长度大于等于 \(k\) 的连续子序列
使得该序列的中位数最大
问最大中位数是多少？
解题思路
二分中位数 \(x\)
将序列中大于等于它的数变为 \(1\) ，小于它的数变为 \(0\)
假设选出的序列长度 \(len\) ， 序列中 1 的个数为 \(cnt\)
那么当 \(cnt - 1 >= len / 2\) 时，返回 \(true\)
这里解释下两个问题 ：
- 为什么式子左边是 \(cnt - 1\) 而不是 \(cnt\)?
- 为什么不是 \(cnt - 1 = len / 2\) 而是 \(cnt - 1 >= len / 2\)
q1. \(cnt - 1\) 是因为序列中的某个 \(1\) 得作为 x 本身
q2. 因为当 \(cnt - 1 > len / 2\) 时，必然存在一个大于 \(x\) 的数满足 \(cnt - 1 = len / 2\)，所以需要返回 \(true\) 以向上改变二分区间
我们可以枚举区间右端点，并选定左端点以使式子的结果为 \(true\)
定义 \(sum[i]\) 为序列的前缀和，\(L\) 为当前区间的左端点 \(-1\) , \(R\) 为当前区间的右端点
那么 \(cnt = sum[R] - sum[L]\) , \(len = R - L\)
于是式子可以转变为 \(sum[R] - sum[L] - 1 >= (R - L) / 2\)
通过移项 ，式子可变为 \(2 × sum[R] - R - 2 >= 2 × sum[L] - L\)
因为 \(R\) 是我们枚举的 , 所以 \(R、sum[R]\) 都可认为常数
为了让不等式成立，我们需要让不等号右边的式子尽可能小
所以我们要取 \(mi\) \(=\) \(min∑(2 * sum[i] - i) , i ∈[1 , i - k]\)
因为每枚举一个右端点，只会出现一个新的可以选择的左端点 \(i-k\)
所以 \(mi\) 对于每一个右端点只要 \(O1\) 就可以得到了
注意：
得到了 \(mi\) 我们不能直接改写式子为 \(2 × sum[R] - R - 2 >= mi\)
因为 \((4 - 1) / 2 = 1\) 而不是 \(1.5\)
所以我们还要维护两个变量分别代表 \(sum[L]\) 和 \(L\)
AC_Code
#include<bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int n , m , k , a[N] , b[N] , sum[N];
bool check(int x)
{
int mi = 1e9 , pre = 1e9 , pos = -1e9;
for(int i = 1 ; i <= n ; i ++)
{
if(a[i] >= x) b[i] = 1;
else b[i] = 0;
sum[i] = sum[i - 1] + b[i];
if(i - k >= 0 && mi >= 2 * sum[i - k] - (i - k))
{
mi = 2 * sum[i - k] - (i - k);
pos = i - k;
pre = sum[i - k];
}
if(sum[i] - pre - 1 >= (i - pos) / 2) return true;
}
return false;
}
signed main()
{
cin >> n >> k ;
for(int i = 1 ; i <= n ; i ++) cin >> a[i];
int l = 1 , r = n , res = 0;
while(l <= r)
{
int mid = l + r >> 1;
if(check(mid)) l = mid + 1 , res = mid;
else r = mid - 1;
}
cout << res << '\n';
return 0;
}
E. Paired Payment
题目链接
题目大意
给定一张包含 \(N\) 个点，\(M\) 条边的无向图，每条边都有它的权值 \(w\) \((1 <= w <= 50)\)
每次从一个节点出发，都必须走完两条边才能停下(中间经过的点不算到达过)
途中的花费为两条边权值的和的平方
问节点 \(1\) 出发到达每个点所需的最小花费分别为多少
解题思路
很多人用暴力的做法居然没有 \(fst\) ？这就很神奇 \(hhh\)
update： 大数据貌似在 \(fst\) 之后才加上
定义 \(ans[i]\) 表示从节点 \(1\) 出发到达节点 \(i\) 的最小花费
定义 \(dis[w][i]\) 表示从某个点 \(x\) 走了 一条权值为 w 的边 到达节点 \(i\) ，而 \(dis[w][i] = min(ans[x])\)
假设当前节点为 \(u\) , 它的相邻节点为 \(v\) , 它们之间的边权为 \(w\)
那么不难得到
dis[w][v] = min(dis[w][v] , ans[u]);for(int j = 1 ; j <= 50 ; j ++) ans[v] = min(ans[v] , dis[j][u] + (j + w) * (j + w));所以跑 \(dijkstra\) 时只要边权被更新我们就把该点入队
但是传统的 \(dijkstra\) 在一个点入队后就会被打上标记从此不能再入队了
而这里我们显然是需要一个点重复入队才能保证答案的最优
如果选择重复入队就会使得复杂度爆炸？那怎么办呢？
我们可以统计每个点入队的次数，当次数大于 \(50\) 时就不再入队
这样可行是因为 \(dis\) 是由 \(ans\) 更新 , \(ans\) 是由 \(ans\) 和 边权 更新
而边权最大只有 \(50\) , \(50\) 次入队足够让 \(ans\) 由所有的边权更新一遍了
AC_Code
#include<bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 2e5 + 10;
struct node{
int dis , pos;
bool operator <( const node &x )const{
return x.dis < dis;
}
};
struct Edge{
int to , w , nex;
}edge[N << 1];
int head[N], dis[51][N] , tot , vis[N] , n , m , s , ans[N];
inline void add_edge(int u , int v , int d)
{
edge[++ tot].w = d;
edge[tot].to = v;
edge[tot].nex = head[u];
head[u] = tot;
}
inline void dijkstra(int s)
{
for(int i = 1 ; i <= n ; i ++) for(int j = 1 ; j <= 50 ; j ++) ans[i] = dis[j][i] = inf;
ans[s] = 0;
priority_queue <node> que;
que.push(node{0 , s});
while(!que.empty())
{
node tmp = que.top();
que.pop();
int u = tmp.pos , d = tmp.dis ;
if(vis[u] > 50) continue;
vis[u] ++;
for(int i = head[u] ; i ; i = edge[i].nex)
{
int v = edge[i].to , w = edge[i].w;
for(int j = 1 ; j <= 50 ; j ++)
{
int cost = dis[j][u] + (j + w) * (j + w);
if(cost < ans[v])
{
ans[v] = cost;
if(vis[v] <= 50) que.push(node{ans[v] , v});
}
}
if(dis[w][v] > ans[u])
{
dis[w][v] = ans[u];
if(vis[v] <= 50) que.push(node{dis[w][v] , v});
}
}
}
}
signed main()
{
cin >> n >> m;
for(int i = 1 ; i <= m ; i ++)
{
int u , v , w;
cin >> u >> v >> w;
add_edge(u , v , w);
add_edge(v , u , w);
}
dijkstra(1);
for(int i = 1 ; i <= n ; i ++)
{
if(ans[i] == inf) ans[i] = -1;
cout << ans[i] << " ";
}
return 0;
}
