CF102411 ICPC 2019-2020 North-Western Russia Regional Contest题解
A Accurate Movement
签到
M Managing Difficulties
签到
B Bad Treap
已知\(y=\sin(x)\)，要求给出数组\(a[n]\)，满足\(\forall i,j\in[1,n],a[i]\neq a[j]\)，都有\(\sin(a[i])\neq \sin(a[j])\)。
这里又一种不怎么玄的写法，就是我们找到一个整数\(x\)，\(sin(x)\)非常非常小并且\(\sin(x)>0\)，这样算，嗯……例如\(sin(2x)\)的时候，\(\sin(2x)=2\sin x \cos x\)，它的值只会有很小的增加\((2\cos x<2)\)。然后就算它扩大了\(2.5\times10^4\)倍之后，仍然都增加不到接近1的位置，那么我们就成功了。然后因为\(\sin x\)关于原点对称，在负半轴把它对称过去，仍然是一个递增序列。
int n;
const int N = 5e4 + 5;
int a[N];
int main(void){
scanf("%d", &n);
double mn = 100;
int id = 1;
for (int i=1;i<=4e4;++i){
if (sin(i) < mn && sin(i) > 0){
mn = sin(i), id = i;
}
}
for (int i=-25000;i<=25000;++i){
a[i + 25000] = i * id;
}
for (int i=0;i<n;++i){
printf(i==n-1?"%d\n":"%d ", a[i]);
}
return 0;
}
不对称过去会wa7，（露西亚，你太baby辣）
I Ideal Pyramid
给定\(n\)个方尖碑，要用一个仰角为45°的金字塔把它们全部覆盖起来，也就是建成金字塔之后，所有的方尖碑都会被它掩盖，高度也不会穿过金字塔，问金字塔应该建在哪里，高度最小为多少。
实际上，所有的四棱锥都可以转化为一个正方形的覆盖，那么题意就转化为了，找到一个最小的正方形，可以包括所有的正方形的集合。这样的话，直接维护正方形集合的上下左右边界（最后得到一个矩形），再按照矩形的中心扩展即可。
int n;
const int N = 1000 + 5;
void solve(){
n = read();
ll x, y, h;
ll L = 1e18, R = -1e18, U = -1e18, D = 1e18;
for (int i=1;i<=n;++i){
x = read(), y = read(), h = read();
L = min(L, x - h), R = max(R, x + h), U = max(U, y + h), D = min(D, y - h);
}
ll a = (L + R) / 2, b = (U + D) / 2, H = max((R - L + 1) / 2, (U - D + 1) / 2);
printf("%lld %lld %lld\n", a, b, H);
}
int main(void){
int T;
// T = read();
T = 1;
while (T--){
solve();
}
return 0;
}
King's Children
有一个\(n\times m\)的网格，里面有最多\(A~to ~Z\)个孩子，king要把这个网格分成若干矩形，要满足：
- 每个矩形必须精确的包括一个孩子
- 每个格子都必须精确的属于1个矩形（也就是矩形不相交的分完整个大网格）
- 包括了\(A\)的矩形的面积尽可能大
数据范围\(1\leq n,m\leq 1000\)
这题可以用悬线法，也可以用单调栈（不如说悬线法就是单调栈的一个子集问题）
算是比较经典的求最大子矩形的问题，然而我不会，下面先介绍一下悬线法。
悬线法
oi-wiki的定义：https://oi-wiki.org/misc/hoverline/
一个简单的题目，简单理解悬线法的过程：
SP1805 Largest Rectangle in a Histogram
https://www.luogu.com.cn/problem/SP1805
首先，\(n\)个矩形就相当于\(n\)条悬线，我们知道最大的面积肯定是由某一个悬线向左右扫过而形成的。那么悬线的扩展，显然的满足某一递推关系，可以帮助我们将复杂度由原来的\(O(N^2)\)变成\(O(N)\)。
定义\(l_i\)为当前的\(i\)位置能扩展到的悬线的最左端，初始时\(l_i=i\)。假设已经处理好了前\(i-1\)个位置的答案，那么当\(h_i\leq h_{i-1}\)时，\(i\)也能扩展到\(i-1\)能扩展到的位置。如果\(h_i\leq h_{l_{i-1}-1}\)时，又可以接着往前扩展……直到扩展到边界，我们就停止。因此对于\(\forall i\)，我们有
while (L[i] > 1 && a[i] <= a[L[i] - 1]) L[i] = L[L[i] - 1];
同样的，假如我们已经处理好\(i+1\)到\(n\)的答案，\(r_i\)也能不断的向右扩展。
while (R[i] < n && a[i] <= a[R[i] + 1]) R[i] = R[R[i] + 1];
那么完整代码：
int n;
const int N = 1e5 + 5;
int a[N], L[N], R[N];
void solve(){
for (int i=1;i<=n;++i){
scanf("%d", &a[i]);
L[i] = R[i] = i;
}
for (int i=1;i<=n;++i){
while (L[i] > 1 && a[i] <= a[L[i] - 1]) L[i] = L[L[i] - 1];
}
for (int i=n;i>=1;--i){
while (R[i] < n && a[i] <= a[R[i] + 1]) R[i] = R[R[i] + 1];
}
ll res = 0;
for (int i=1;i<=n;++i){
res = max(res, 1LL * a[i] * (R[i] - L[i] + 1));
}
printf("%lld\n", res);
}
UVA1619/POJ2796 Feel Good
给出长度为\(n\)的数组\(a[n]\)，找到一个子区间，使得子区间内的最小值与区间内所有元素和的乘积最大，如果有多个答案，输出长度最小的答案，如果仍有多个答案，输出最左端序号最小的答案。
枚举这个最小值，它一旦向左右扩展，就肯定会增加这个乘积的值，这样的话，又变成了一个悬线法求最大子矩形的问题。
数据范围：\(1\leq n \leq 10^5\) 我恨UVA的多组数据和格式
int n;
const int N = 1e5 + 5;
int a[N], L[N], R[N];
ll pre[N];
bool fst = 1;
void solve(){
// n = read();
if (!fst){
puts("");
}
fst = 0;
for (int i=1;i<=n;++i){
a[i] = read();
pre[i] = pre[i - 1] + a[i];
L[i] = R[i] = i;
}
for (int i=1;i<=n;++i){
while (L[i] > 1 && a[i] <= a[L[i] - 1]) L[i] = L[L[i] - 1];
}
for (int i=n;i>=1;--i){
while (R[i] < n && a[i] <= a[R[i] + 1]) R[i] = R[R[i] + 1];
}
ll res = 0;
int aL = 1, aR = 1;
for (int i=1;i<=n;++i){
ll cur = (pre[R[i]] - pre[L[i] - 1]) * a[i];
if (cur > res){
res = cur, aL = L[i], aR = R[i];
}
else if (cur == res){
if (R[i] - L[i] < aR - aL){
aL = L[i], aR = R[i];
}
else if (R[i] - L[i] == aR - aL){
if (L[i] < aL){
aL = L[i], aR = R[i];
}
}
}
}
printf("%lld\n%d %d\n", res, aL, aR);
}
int main(void){
while (~scanf("%d", &n)){
if (n == 0){
puts("");
}
else solve();
}
return 0;
}
最大子矩形：p4147 玉蟾宫
嗯……差不多捏，问题。oiwiki留的课后习题也写了，就不放出来了。
那么正式说K，K题我的思路就是，每个矩形都用悬线法进行选取和填充。但是，由于填充顺序的不同，有极低的概率出现最后有矩形没有被完全填上的情况，因此做一个简单的check，如果填充错误，则随机化顺序，重新填充答案。大概2~3次随机后就不可能出现还没填充的情况了，所以这个复杂度是完全可行的。
代码：
int n, m, sx, sy;
const int N = 1000 + 5;
char s[N][N], ss[N][N];
int U[N], L[N], R[N];
struct node{
char ch;pii cor;
};
vector<node> alp;
bool check(pii s, pii a, pii b){
return (s.xx >= a.xx && s.xx <= b.xx) && (s.yy >= a.yy && s.yy <= b.yy);
}
void putin(char ch, pii cor){
int res = 0; pii r1 = cor, r2 = cor;
for (int j=1;j<=m;++j) U[j] = 0;
for (int i=1;i<=n;++i){
for (int j=1;j<=m;++j){
if (s[i][j] == '.' || s[i][j] == ch){
U[j]++;
}
else{
U[j] = 0;
}
L[j] = R[j] = j;
}
for (int j=1;j<=m;++j){
while (L[j] > 1 && U[j] <= U[L[j] - 1]) L[j] = L[L[j] - 1];
}
for (int j=m;j>=1;--j){
while (R[j] < m && U[j] <= U[R[j] + 1]) R[j] = R[R[j] + 1];
}
for (int j=1;j<=m;++j){
int cur = U[j] * (R[j] - L[j] + 1);
pii c1 = pii(i - U[j] + 1, L[j]), c2 = pii(i, R[j]);
if (cur > res && check(cor, c1, c2)){
res = cur, r1 = c1, r2 = c2;
}
}
}
for (int i=r1.xx;i<=r2.xx;++i){
for (int j=r1.yy;j<=r2.yy;++j){
if (s[i][j] == '.'){
s[i][j] = 'a' + (ch - 'A');
}
}
}
}
void solve(){
for (int i=1;i<=n;++i){
for (int j=1;j<=m;++j){
s[i][j] = ss[i][j];
}
}
int alen = alp.size(), t = alen - 1;
if (alen > 1){
for (int i=0;i<alen-1;++i){
int x = 1 + rand() % t;
swap(alp[x], alp[t]);
t--;
}
}
for (int i=0;i<alp.size();++i){
putin(alp[i].ch, alp[i].cor);
}
}
bool isOK(){
for (int i=1;i<=n;++i){
for (int j=1;j<=m;++j){
if (s[i][j] == '.'){
return false;
}
}
}
return true;
}
int main(void){
srand(time(NULL));
int T;
T = 1;
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
cin >> n >> m;
for (int i=1;i<=n;++i){
for (int j=1;j<=m;++j){
cin >> ss[i][j];
if (ss[i][j] == 'A'){
alp.push_back(node{'A', pii(i, j)});
}
}
}
for (int i=1;i<=n;++i){
for (int j=1;j<=m;++j){
if (ss[i][j] != '.' && ss[i][j] != 'A'){
alp.push_back(node{ss[i][j], pii(i, j)});
}
}
}
do{
solve();
}while(!isOK());
for (int i=1;i<=n;++i){
for (int j=1;j<=m;++j){
cout << s[i][j];
}
cout << endl;
}
return 0;
}
E Equidistant
给出一个树，判断是否有一个结点，满足到所有特殊点的距离相等。
数据范围：\(1\leq m,n\leq 2\times 10^5\)。
这题感觉用多源bfs更简单……嗯……用树形DP试着写写吧。
树形DP 不推荐。。。。
int n, m;
const int N = 2e5 + 5, INF = 1e9 + 10;
bool st[N], ok;
vector<int> ve[N];
int f[N], g[N];
void dfs(int u, int pre){
for (auto to : ve[u]){
if (to == pre) continue;
dfs(to, u);
f[u] = min(f[u], f[to] + 1);
g[u] = max(g[u], g[to] + 1);
}
}
void dfs2(int u, int pre){
if (ok) return;
if (f[u] == g[u]){
if (!ok){
puts("YES");
printf("%d\n", u);
}
ok = true;
return ;
}
int mx1 = -INF, mx2 = -INF, mn1 = INF, mn2 = INF;
if (st[u]){
mx1 = mn1 = 0;
}
for (auto to : ve[u]){
if (f[to] + 1 < mn1){
mn2 = mn1, mn1 = f[to] + 1;
}
else if (f[to] + 1 < mn2){
mn2 = f[to] + 1;
}
if (g[to] + 1 > mx1){
mx2 = mx1, mx1 = g[to] + 1;
}
else if (g[to] + 1 > mx2){
mx2 = g[to] + 1;
}
}
for (auto to : ve[u]){
if (to == pre) continue;
int fto = f[to], gto = g[to];
if (f[u] == f[to] + 1){
f[u] = mn2;
f[to] = min(f[to], mn2 + 1);
}
else{
f[to] = min(f[to], f[u] + 1);
}
if (g[u] == g[to] + 1){
g[u] = mx2;
g[to] = max(g[to], mx2 + 1);
}
else g[to] = max(g[to], g[u] + 1);
dfs2(to, u);
f[u] = mn1, g[u] = mx1;
f[to] = fto, g[to] = gto;
}
}
int main(void){
n = read(), m = read();
for (int i=1;i<=n;++i){
f[i] = INF, g[i] = -INF;
}
int u, v, x;
for (int i=1;i<n;++i){
u = read(), v = read();
ve[u].push_back(v), ve[v].push_back(u);
}
for (int i=1;i<=m;++i){
x = read(), st[x] = true;
f[x] = g[x] = 0;
}
dfs(1, 0);
dfs2(1, 0);
if (!ok){
puts("NO");
}
return 0;
}
