CodeForces1715
Crossmarket
解析：
题目大意
有一个 \(n \times m\) 的空间，Stanley 需要从左上角到右下角；Megan 则需要从左下角到右上角。两人可以耗费 \(1\) 能量到达相邻的格子。
为了加快到达的速度， Megan 会在经过的所有格子留下传送门，两人可以耗费 \(1\) 能量通过任意传送门通往任意有传送门的位置。
求两人均到达目的地耗费的最小总能量。
思路：
首先发现 Megan 不可能用传送门，因为这样折返最多让 Stanley 能够早点用传送门，但 Stanley 没走的路其实是让 Megan 走的，总能量并不优，正确的做法是 Megan 直接从左下，经过左上走到右上，而 Stanley 选择 \(n,m\) 中较大的边传送。
答案是 \(n-m-2\) （Megan 的能量）+ \(\min(n,m)\) （Stanley 的能量）。
code
#include <bits/stdc++.h>
using namespace std;
int n, m;
int solve ()
{
scanf ("%d%d", &n, &m);
if (n == 1 && m == 1) return 0;
if (n < m) swap (n, m);
return (n + m - 2) + m;
}
signed main()
{
int t = read ();
while (t--) printf ("%d\n", solve ());
return 0;
}
Beautiful Array
解析：
题目大意：
给定四个整数 \(n,k,b,s\)，要求构造一个长度为 \(n\) 的序列 \(a\)，使得 \(s=\sum\limits_{i=1}^na_i\) 且 \(b=\sum\limits_{i=1}^n\lfloor\frac{a_i}{k}\rfloor\)（\(a_i\) 必须为非负整数）。如果有多组解，输出任意一组解。对于无解的情况，输出 -1。
思路：
大力构造，考虑总和 \(s\) 能凑出来的最大的 \(b\) 其实是 \(\frac{s}{k}\) ，感性理解就是我前面 \(n-1\) 个 \(a_i\) 都取 \(k\)，最后剩了多少都给 \(a_n\)，可以证明不存在更优的构造方案。
总和 \(s\) 可以构造的最小值可以类似考虑，我先给 \(n\) 个 \(a_i\) 都分 \(k-1\)，那剩下的数不管放哪都会造成贡献了，那直接随便找一个放在一起就行了，因为我需要尽量不破坏其他 \(k-1\)，可以证明这样凑出来的是最小的。
考虑现在判断了无解，构造方案可以参考最小值的构造，我先给 \(a_1\) 分 \(b\times k\)，剩下的每次按照 \(k-1\) 分给 \(1-n\) 所有数，直到分完为止。
code：
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int INF = 0x3f3f3f3f;
inline int read ()
{
int x = 0, f = 1;
char ch = getchar ();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
return x * f;
}
int n, k, b, s;
void solve ()
{
n = read (), k = read (), b = read (), s = read ();
int r = s / k, l = 0, sum = 0;
for (int i = 1; i < n; i++) sum += k - 1;
l = (s - sum) / k;
if (b < l || b > r) { printf ("-1\n"); return ; }
printf ("%lld ", min (s, k * (b + 1) - 1));
s -= min (s, k * (b + 1) - 1);
for (int i = 2; i <= n; i++)
{
if (s >= k - 1) { printf ("%lld ", k - 1); s -= (k - 1); }
else { printf ("%lld ", s); s -= s; }
}
printf ("\n");
}
signed main()
{
int t = read ();
while (t--) solve ();
return 0;
}
Monoblock
解析：
题目大意
我们定义连续连续极长且都是一个相同的数的子段被称为一个“块”。一个序列的连续极长的块的个数表示为 \(g(1,n)\)。
给定一个长度 \(n\) 的序列和 \(m\) 次询问。对于每次询问，有两个数 \(i,x\)，先将 \(a_i\) 改为 \(x\)，然后输出 \(\sum\limits_{l=1}^n\sum\limits_{r=l}^ng(l,r)\)，其中 \(g(l,r)\) 表示 \(a_{l\sim r}\) 的“块”数。
思路：
诈骗题，第一眼发现什么数据结构都不能很好维护，就去看D了，切了D回来也秒了，事实证明这是个错误的决定（如果先写D排名能提好几百）。
首先观察到可以数组直接统计维护。
首先注意到一个序列的块的个数实际上等价于元素个数-有多少个数与前一个数的值相同，前者又等价于序列长度，可以直接维护，后者相当于考虑先找出来整个序列这样的数出现的位置，设其中一个数 \(a_i\) 和 \(a_{i-1}\) 值相同，那么包括这两个元素的子序列都会有一个 \(-1\) 的贡献，这样的子序列要求左端点 \(l\) 在 \(l\in[1,i-1]\)，右端点 \(r\) 在 \(r\in[i,n]\) 之间，这样的子序列的个数有 \((i-1)\times(n-i+1)\) 个。
原问题转化为 \(\sum\text{所有子序列长度}-\sum{\text{所有贡献}}\)，可以分开维护，前者直接 \(\mathcal O(1)\) 算，后者开个数组维护每个位置对答案的贡献是 \(0\) 还是 \(-(i-1)\times (n-i+1)\)，单点改就直接改当前位置的数组值就行。
然后随便记个 \(sum\) 就解决了。
code
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 10;
typedef pair <int, int> pii;
inline int read ()
{
int x = 0, f = 1;
char ch = getchar ();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
return x * f;
}
int n, q;
int a[N];
int c[N], sum, sum2;
void solve (int x) { if (a[x] == a[x - 1]) c[x] = (x - 1) * (n - x + 1); else c[x] = 0; }
signed main()
{
n = read (), q = read ();
for (int i = 1; i <= n; i++) a[i] = read ();
for (int i = 2; i <= n; i++) solve (i);
for (int i = 1; i <= n; i++) sum += c[i], sum2 += (1 + i) * i / 2;
while (q--)
{
int x = read (), y = read ();
a[x] = y;
sum -= c[x]; sum -= c[x + 1];
solve (x), solve (x + 1);
sum += c[x]; sum += c[x + 1];
printf ("%lld\n", sum2 - sum);
}
return 0;
}
2+ doors
解析：
题目大意：
Narrator有一个长度为 \(n\) 的整数数组 \(a\) ，但是他只会告诉你 \(n\) 的大小和 \(q\) 个要求，每个要求包括三个整数 \(i,j,x\) ，要求满足 \(a_i\mid a_j = x\)，其中 \(|\) 表示按位或运算
找到满足所有要求的字典序最小的数组 \(a\)。数据保证有解。
思路：
大套路题，首先套路的发现每一个二进制位互补影响，可以分开考虑，原问题变成给你 \(q\) 个限制，每个限制要求 \(a_i|a_j\in{0,1}\)。
考虑字典序最小，我们需要让尽量前面的数分配 \(0\) 这样一定最优，我们考虑跟 \(a_1\) 有关的 \(q_1\) 个限制，如果 \(\exist i,j|(a_1|a_i=1,a_1|a_j=1\and a_i|a_j=0)\)，那么必有 \(a_i,a_j\) 为 \(0\)，\(a_1\) 为 \(1\)，否则让 \(a_1=0\)，\(\forall i|(a_1|a_i=0)\)，令 \(a_i=1\) 一定最优。
那么考虑先把当前二进制位满足 \(a_i|a_j=0\) 的 \(i,j\) 强制为 \(0\)，然后从 for 1 -> n 检索每一个 \(i\)，如果 \(\exist j,j\in[i,n]\and a_j=0\)，那么 \(a_i=1\)，否则让有条件限制的都取1即可。
时间复杂度 \(\mathcal O(V(n+q))\)，其中 \(V\) 取到 \(\log x\)。
code：
#include <bits/stdc++.h>
#define int long long
#define eb emplace_back
#define fi first
#define se second
#define mk make_pair
using namespace std;
const int N = 2e5 + 10;
const int INF = LLONG_MAX;
typedef pair <int, int> pii;
inline int read ()
{
int x = 0, f = 1;
char ch = getchar ();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
return x * f;
}
int n, m;
vector <pii> vec[N];
struct node {
int x, y, k;
} s[N];
int a[32][N];
signed main()
{
n = read (), m = read (); int mn = INF, mx = 0;
for (int i = 1; i <= m; i++)
{
s[i].x = read (), s[i].y = read (), s[i].k = read ();
if (s[i].x > s[i].y) swap (s[i].x, s[i].y);
vec[s[i].x].eb (mk(s[i].y, s[i].k));
mx = max (mx, s[i].k);
}
if (mx == 0) { while (n--) printf ("0 "); return 0; } // 场上最终挂掉的特判，挂因是0之间忘加空格了
memset (a, -1, sizeof (a));
for (int i = 31; i >= 0; i--)
{
for (int j = 1; j <= m; j++)
{
if (!((s[j].k >> i) & 1)) a[i][s[j].x] = 0, a[i][s[j].y] = 0;
if (s[j].x == s[j].y) a[i][s[j].x] = (s[j].k >> i) & 1;
}
for (int j = 1; j <= n; j++)
{
if (a[i][j] != -1)
{
if (a[i][j] == 0)
for (int k = 0; k < vec[j].size (); k++)
if (((vec[j][k].se >> i) & 1) == 1) a[i][vec[j][k].fi] = 1;
continue;
}
for (int k = 0; k < vec[j].size (); k++)
if (a[i][vec[j][k].fi] == 0 && ((vec[j][k].se >> i) & 1) == 1) { a[i][j] = 1; break; }
if (a[i][j] == 1) continue;
a[i][j] = 0;
for (int k = 0; k < vec[j].size (); k++)
if (((vec[j][k].se >> i) & 1) == 1) a[i][vec[j][k].fi] = 1;
}
}
for (int i = 1; i <= n; i++)
{
int sum = 0;
for (int j = 31; j >= 0; j--) sum += (a[j][i] << j);
printf ("%lld ", sum);
}
return 0;
}
Long Way Home
解析：
题目大意：
有 \(n\) 座城市，城市间有 \(m\) 条双向道路，通过第 \(i\) 条道路需要花费 \(w_i\) 的时间，任意两个城市之间都有航班，乘坐城市 \(u\) 和 \(v\) 之间的航班需要花费 \((u-v)^2\) 的时间，但最多乘坐 \(k\) 次航班。
现在请对于任意城市 \(i(1 \le i \le n)\)，求出从城市 \(1\) 出发，到达城市 \(i\) 所需要的最短时间。
思路：
大力 dp+dijkstra，场上想到了怎么设 dp 状态，但碍于时间没想出来，或许也是板子不熟吧，按理讲应该能一眼切的。
发现 \((u-v)^2\) 是斜率优化的板子，而 \(k\) 实际上就是一个常数，这告诉我们只需要做 \(k\) 次 \(dp\)。
我们考虑设 \(dp_{i,j}\) 表示从 \(1\) 到 \(i\) 飞了 \(j\) 次的最小距离，那么有：
\[dp_{i,j}=\min_{k=1}^n dp_{k,j-1}+(k-i)^2 \]把这个东西化简一下：
\[dp_{i,j}=\min_{k=1}^n dp_{k,j-1}+k^2-2ik+i^2\\ dp_{i,j}-i^2=\min_{k=1}^n dp_{k,j-1}+k^2-2ik \]那就是个斜率优化板子，我们考虑设 \(-2k\) 为 \(k\)，\(k^2+dp_{k,j-1}\) 为 \(b\)，那么维护一下下凸壳即可。
每次乘坐完飞机都跑一个dijkstra更新一下即可。
code：
#include <bits/stdc++.h>
#define int long long
#define fi first
#define se second
#define mk make_pair
using namespace std;
const int N = 1e5 + 10;
const int K = 20 + 10;
const int INF = 0x3f3f3f3f;
typedef pair <int, int> pii;
inline int read ( )
{
int x = 0, f = 1;
char ch = getchar ( );
while (ch < '0' || ch > '9') {if (ch == '-') f = - 1; ch = getchar ( );}
while (ch >= '0' && ch <='9') {x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar ( );}
return x * f;
}
int n, m, k;
struct edge {
int ver, nxt, val;
} e[N << 1];
int head[N], tot;
void add_edge (int u, int v, int w) { e[++tot] = (edge) {v, head[u], w}; head[u] = tot; }
int dp[K][N];
bool vis[N];
int h, t;
struct node {
int k, b, i;
double x, y;
} l[N];
inline double calc(node x, node y) { return double(y.b - x.b) / double(x.k - y.k); }
void dijkstra (int s, int x)
{
priority_queue <pii> que;
memset (vis, 0, sizeof (vis));
for (int i = 1; i <= n; i++) if (dp[x][i] != INF) que.push (mk (-dp[x][i], i));
while (!que.empty ())
{
int u = que.top ().second; que.pop ();
if(vis[u]) continue;
vis[u] = true;
for (int i = head[u]; i; i = e[i].nxt)
{
int v = e[i].ver;
if (dp[x][v] > dp[x][u] + e[i].val)
{
dp[x][v] = dp[x][u] + e[i].val;
que.push (mk (-dp[x][v], v));
}
}
}
}
signed main()
{
n = read (), m = read (), k = read ();
for (int i = 1; i <= m; i++)
{
int u = read (), v = read (), w = read ();
add_edge (u, v, w);
add_edge (v, u, w);
}
memset (dp[0], 0x3f, sizeof (dp[0]));
dp[0][1] = 0;
for (int s = 0; s <= k; s++)
{
if (s)
{
h = 1; t = 0;
for (int i = 1; i <= n; i++)
{
if (dp[s - 1][i] == INF) continue;
node now = (node) { -2 * i, i * i + dp[s - 1][i], i, -INF, INF};
while (h <= t && calc (l[t], now) <= l[t].x) t--;
if (h <= t) l[t].y = now.x = calc (l[t], now);
l[++t] = now;
}
for (int i = 2; i <= n; i++)
{
while (h <= t && l[h].y < i) h++;
int k = l[h].i;
dp[s][i] = dp[s - 1][k] + (k - i) * (k - i);
}
for (int i = 1; i <= n; i++) dp[s][i] = min (dp[s - 1][i], dp[s][i]);
}
dijkstra (1, s);
}
for (int i = 1; i <= n; i++) printf ("%lld ", dp[k][i]);
return 0;
}
6
解析：
题目大意：
思路：
交互&人类智慧题，不会，咕了
code：