AtCoder瞎做第二弹

目录

• ARC 067
  • F - Yakiniku Restaurants
    • 题意
    • 题解
    • 代码
• ARC 068
  • F - Solitaire
    • 题意
    • 题解
    • 代码
• ARC 070
  • E - Narrow Rectangles
    • 题意
    • 题解
    • 总结
    • 代码
  • F - HonestOrUnkind
    • 题意
    • 题解
    • 代码
• ARC 072
  • F - Dam
    • 题意
    • 题解
    • 代码
• ARC 073
  • E - Ball Coloring
    • 题意
    • 题解
    • 代码
  • F - Many Moves
    • 题意
    • 题解
    • 代码
• ARC 075
  • F - Mirrored
    • 题意
    • 题解
    • 代码
• ARC 079
  • F - Namori Grundy
    • 题意
    • 题解
    • 代码

ARC 067

F - Yakiniku Restaurants

题意

$n$ 家饭店，$m$ 张餐票，第 $i$ 家和第 $i+1$ 家饭店之间的距离是 $A_i$ ，在第 $i$ 家饭店用掉第 $j$ 张餐票会获得 $B_{i, j}$ 的好感度，可以从任意一个饭店出发，求好感度减经过的距离和的差的最大值。

$2 \le n \le 5000, 1 \le m \le 200, 1 \le A_{i, j}, B_{i, j} \le 10^9$

题解

做题千万条，看题第一条。

显然我们不会走回头路，那么每次我们选择的一定是一段连续区间 $[l, r]$ 。

考虑每个 $B_{i, j}$ 对于哪些区间有贡献，找到左右第一个比它的 $B_{x, j}, B_{y, j} \ge B_{i, j}$ ，那么它贡献的区间其实就是 $l \in (x, i], r \in [i, y)$ 。

我们利用单调栈算出端点，然后矩形加利用二维差分实现即可。

$\mathcal O(n^2 + nm)$

代码

Submission #5013272

ARC 068

F - Solitaire

题意

有一个双端队列。

首先将 $n$ 个数 $1\sim n$ 从小到大任意前后地添入队列。然后任意前后地弹出队列，求最后弹出来的排列中，第 $k$ 个数为 $1$ 的排列有多少种。

$1 \le k \le n \le 2000$

题解

一开始添完的序列性质显然是将 $1$ 分成两段，左边递减，右边递增。

由于构造合法序列是左右弹元素，那么性质就比较好推了。

• 第 $k$ 个数为 $1$ ；
• 前 $k - 1$ 个数可拆分为至多两个下降子序列；
• 前 $k - 1$ 个数的最小值一定大于后 $n - k$ 个数的最大值。

先考虑最后 $n - k$ 个数的方案，如果我们确定了前 $k$ 个数，那么剩下的 $n - k$ 个数是由一个单调队列弹出来的，除了最后一次只能弹一个，别的每次都有两种选择，所以方案是 $2^{\max(0, n - k - 1)}$ 。

然后前面拆分成至多两个下降子序列，这个和 这道题 是一样的。

我们现在只需要满足第一个限制了，由于第 $k$ 个数是需要最小值，用至多选 $k$ 个和 $k - 1$ 个差分一下即可。

然后利用之前那个题的组合数结论就可以做到 $\mathcal O(n)$ 了。

其实那个组合数有个更优美的形式，也就是 $\displaystyle {n + m \choose m} - {n + m \choose m - 1}$ ，意义明显许多。

代码

Submission #5016238

ARC 070

E - Narrow Rectangles

题意

有 $n$ 个高为 $1$ 的矩形，第 $i$ 个矩形 $y$ 轴范围为 $[i - 1, i]$ ，$x$ 轴范围为 $[l_i, r_i]$ 。

需要横向移动一些矩形，使得所有矩形是连通的（角也算），对于一个矩形，横向移动 $x$ 距离的代价为 $x$ ，求出最小代价。

$1 \le n \le 10^5, 1 \le l \le r \le 10^9$

题解

首先考虑暴力 $dp$ 即令 $f_{i, j}$ 为第 $i$ 层矩形右端点为 $j$ ，前 $i$ 层已经联通所需要的最小代价。

令 $len_i = r_i - l_i$ ，每次只需要两条线段相交即可。转移十分显然：

$$\begin{aligned} f_{i, p} &= |r_i - p| + \min_{p - len_i \le j, p \ge j - len_{i - 1}} f_{i - 1, j} \\ &= |r_i - p| + \min_{j - len_{i - 1} \le p \le j + len_i} f_{i - 1, j} \end{aligned}$$

我们可以把 $f_i$ 看做一个关于 $p$ 的函数，设 $g_i(p) = |r_i - p|$ ，那么形式为：

$$f_i(p) = g_i(p) + \min_{j - len_{i - 1} \le p \le j + len_i} f_{i - 1}(j)$$

不难观察到函数这个图像其实是一个分段一次函数，且斜率从 $-(i - 1), - (i - 2), \cdots, 0, \cdots, i - 2, i - 1$ 递增（拆开重合点）。（不难利用归纳证明）其实也是一个凹函数，最小值在 $k = 0$ 处取得。

那么考虑后面那个 $\min$ 等价于把 $k_x < 0$ 的部分向左平移 $len_{i - 1}$ （因为我们想尽量向右取），$k_x > 0$ 的部分向右平移 $len_i$ ，然后最后全局加上 $g_i$ 就行了。

我们其实可以用 $Splay$ 维护这个凸壳，每次只需要支持区间加一次函数，全局平移即可。

但显然可以更方便地解决，由于最后我们只需要求 $k = 0$ 时候的函数值，我们利用对顶堆维护 $k < 0, k > 0$ 的位置，每次讨论一下插入的绝对值函数的 $0$ 点位置即可。

讨论的时候可以顺便计算一下当前的答案。

总结

对于加绝对值函数，并且取 $\min, \max$ 的 $dp$ 都可以考虑是否存在凸壳，然后通过 线段树/ $Splay$ / 对顶堆 维护这个 $dp$ 值即可。

代码

#include <bits/stdc++.h>

#define For(i, l, r) for (register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for (register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Rep(i, r) for (register int i = (0), i##end = (int)(r); i < i##end; ++i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << (x) << endl

using namespace std;

typedef long long ll;

template<typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, T b) { return b > a ? a = b, 1 : 0; }

inline int read() {
	int x(0), sgn(1); char ch(getchar());
	for (; !isdigit(ch); ch = getchar()) if (ch == '-') sgn = -1;
	for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
	return x * sgn;
}

void File() {
#ifdef zjp_shadow
	freopen ("E.in", "r", stdin);
	freopen ("E.out", "w", stdout);
#endif
}

const int N = 1e5 + 1e3;

int n, l[N], r[N], len[N];

ll tl, tr, ans;

priority_queue<ll> L;
priority_queue<ll, vector<ll>, greater<ll>> R;

int main () {

	File();

	For (i, 1, n = read()) 
		l[i] = read(), r[i] = read(), len[i] = r[i] - l[i];

	L.push(r[1]); R.push(r[1]);
	For (i, 2, n) {
		tl -= len[i - 1]; tr += len[i];
		ll lp = L.top() + tl, rp = R.top() + tr;
		if (lp <= r[i] && r[i] <= rp) 
			L.push(r[i] - tl), R.push(r[i] - tr);
		else if (r[i] >= rp) {
			ans += r[i] - rp; R.pop(); L.push(rp - tl);
			R.push(r[i] - tr); R.push(r[i] - tr);
		} else {
			ans += lp - r[i]; L.pop(); R.push(lp - tr);
			L.push(r[i] - tl); L.push(r[i] - tl);
		}
	}
	printf ("%lld\n", ans);

	return 0;

}

F - HonestOrUnkind

题意

有 $n = a + b$ 个人，其中有 $a$ 个人是诚实的，$b$ 个人是不友好的。每次你可以问 $x$ ： $y$ 是不是一个诚实的人。如果 $x$ 是诚实的，那么一定会回答真正的答案。否则，他会随便告诉你一个结果。（交互库有一定策略地回答。）

现在告诉你 $a, b$ ，你需要确定是否一定能问出来。如果问不出来输出 Impossible 。如果能问出来，需要在 $2n$ 步内问出来。

题解

首先我们考虑什么时候是 Impossible ，显然当 $b \ge a$ 的时候，$b$ 可以很好的隐藏在 $a$ 中。因为问任意一个人，$b$ 都可以根据 $a$ 的决策，来颠倒黑白。只有当 $a$ 超过 $n$ 的一半的时候，我们问任意一个人都可以根据 $\text{Y, N}$ 中较多的那项确定类别。

接下来，我们不难想到一个乱搞。就是一开始随机问几个人，然后问所有人他的类别，就可以确定类别了。如果是老实人，然后就可以一遍问它就能得到所有人的类别了。我们打乱一下询问顺序，那么这样期望下是 $3n$ 的。

我们其实可以继续优化一下乱搞，加上如下几个优化：

• 如果问出当前人的类别，之前回答类别不同的人，肯定不是老实人，之后我们全都跳过不问即可。
• 如果我们当前问的 $\text{Y, N}$ 其中较多的那个个数，大于剩下没有确定的不友好的人数，就可以确定这个人的类别了。
• 如果当前只剩下友好/不友好，我们就可以直接不问，然后确定即可。

期望应该是 $1.5n$ 的？然后全都加上。。就可以过啦qwq（我也是交了十几发才艹过的。。）

---

显然有确定性做法，我们需要基于这样一个结论，如果 $x$ 说 $y$ 是不友好的，那么 $x, y$ 肯定不可能同时是诚实的，如果我们忽略他们，剩下的老实人个数仍然大于一半。

我们用个栈，把每个人放进去，如果栈顶这个人说当前这个人是不友好的，我们把栈顶弹出，然后忽略他们。

然后最后剩下了 $a_0, \cdots, a_{k - 1}$ 其中每个 $a_i$ 都说 $a_{i + 1}$ 是诚实的，那么显然 $a_{k - 1}$ 一定是诚实的。为什么呢？因为其中一定有个人是老实人，那么在它后面的所有人一定都是老实人，那么最后一个人必是老实人。

然后我们就可以在稳定的 $2n$ 次里问出所有人的类别啦。（好妙啊～）

代码

放个瞎JB乱搞。

ARC 072

F - Dam

题意

有一个容量为 $L$ 的水库，每天晚上可以放任意体积的水。每天早上会有一定温度和体积的水流入水库，且要保证流入水之后水的总体积不能超过 $L$ 。令体积分别为 $V_1,V_2$ ，温度分别为 $t_1,t_2$ 的水混合后的温度为 $\displaystyle \frac {V_1 * t_1 + V_2 * t_2} {V_1 + V_2}$ 。初始水库为空。现给出 $n$ 天流入水的体积和温度，分别最大化每一天中午水库满容量时的水温。

$1 \le n \le 5 \times 10^5$

题解

一道很有意思的题~

我们可以发现两个性质：

1. 当前水温小于以前水温时必然会拉低总水温，所以一定会和前面的水混合，直接向前不断合并即可。
2. 当前水温大于前面时，直接将前面舍弃可以得到更高的温度，但要求总量必须为 $L$ ，这样有可能出现不够加满水坝的情况，因此还要保留一段。

我们利用一个单调队列（队列中的元素队首到队尾按 $t$ 单调递增），每次当前体积 $>L$ 我们不断弹掉队首，使得体积变小。然后队尾温度比队尾前一个低，我们就合并，直至不能合并即可。

至于为什么是对的呢？你可以考虑把每个水看做一个向量，我们相当于看向量和的斜率，我们其实就是需要贪心地维护一个下凸壳，本质上是一样的。

代码

Submission #5206287

ARC 073

E - Ball Coloring

题意

有 $n$ 个盒子，每个盒子里面有两个球，分别写了一个数字 $x_i, y_i$ 。现在需要把每个盒子其中的一个球染成红色，另外一个染成蓝色。

令 $R_{\max}$ 为红球数字最大值，其他的同理，求 $(R_{\max} - R_{\min})(B_{\max} - B_{\min})$ 的最小值。

$n \le 2 \times 10^5$

题解

脑子是个好东西，我也想要一个QAQ

令全局 $x_i, y_i$ 最大值为 $A_{\max}$ ，最小值为 $A_{\min}$ 。显然 $R_{\max}, B_\max$ 其中一个需要取到 $A_\max$ ，$\min$ 同理。

我们考虑分两种情况讨论。

• 最大值和最小值被两边分别取到了。

  不妨令 $R_\max = A_\max, B_\min = A_\min$ ，那么我们显然需要最小化 $B_\max$ ，最大化 $R_\min$ 。

  那么显然对于每个盒子，我们把较小的那个给 $B$ ，较大的给 $R$ ，显然是最优的。

• 最大值和最小值都给一边取到了。

  不妨令 $R_\max = A_\max, R_\min = A_\min$ ，那么我们就需要最小化 $B_\max - B_\min$ 。

  我们考虑从小到大枚举 $B_\min$ ，然后动态维护 $B_\max$ 的最小值。

  如果当且 $B_\min = A_\min$ ，我们显然 $B_\max$ 取到所有的 $\min\{x_i, y_i\}$ 的最大值是最优的。

  然后我们每次把 $B_\min$ 变大，也就是翻转 $B_\min$ 的颜色，随便维护一下最值即可。

$\mathcal O(n \log n)$

代码

Submission #5212035

F - Many Moves

题意

一个长为 $n$ 的数轴，一开始上面有两个盒子在 $A, B$ ，有 $q$ 次要求，每次给出一个坐标 $x_i$ ，需要把其中一个盒子移到 $x_i$ ，问最少移动的距离和。

$1 \le n, q \le 2 \times 10^5$

题解

唯一一道自己做出来的 $F$ TAT 虽然很水。

假设当前处理第 $p$ 个要求。考虑 $dp$ ，设 $f_{i, j}$ 为当前两个盒子分别在 $i, j$ 的最少距离和，转移显然。

但显然每次我们有个盒子的位置一定在 $x_{p - 1}$ ，我们只需要记 $f_i$ 为其中一个盒子在 $x_{p - 1}$ ，另外一个在 $i$ 的最少距离和。

显然一次我们不会同时移动两个盒子，这样一定不优。

• $i \not = x_{p - 1}$ ，显然不动 $i$ ，动 $x_{p - 1}$ 即可，所以有 $f'_i = f_i + |x_p - x_{p - 1}|$ 。
• 对于 $i = x_{p - 1}$ 我们考虑枚举上次的另外一个位置 $j$ ，那么有 $f_{x_{p - 1}} = \min_{j} \{f_j + |x_p - j|\}$ 。

直接实现是 $\mathcal O(n^2)$ 的，对于第一个转移就是全局加，对于第二个转移拆绝对值，然后维护 $f_i \pm i$ 的最小值即可。

都可以用线段树实现 $\mathcal O(n \log n)$ 。

代码

Submission 5230528

ARC 075

F - Mirrored

题意

定义 $rev(n)$ 为将 $n$ 的十进制位翻转的结果，例如 $rev(123) = 321, rev(4000) = 4$ 。

给定正整数 $D$ ，求有多少个 $N$ 满足 $rev(N) = N + D$ 。

$1 \le D < 10^9$

题解

考虑固定长度为 $L + 1$ ，假设从低到高每一位分别是 $b_i$ ，那么其实就是

$$\begin{aligned} rev(N ) - N &= \sum_{i = 0}^{L} (10^{L - i} - 10^i) b_i\\ &= \sum_{i = 0}^{\lfloor \frac L2\rfloor} (10^{L - i} - 10^i) (b_i - b_{L - i}) \end{aligned}$$

我们等价求把 $0 \sim \lfloor \frac L2\rfloor$ 的每个 $v_i = 10^{L - i} - 10^i$ 乘上 $-9 \sim 9$ 和为 $D$ 的方案数。（对于每个 $-9 \sim 9$ 对应了两个数的一种组合）。

直接 $dfs$ 可能会 TLE ，考虑利用性质优化，我们观察到：

$$v_i > \sum_{j = i + 1}^{\lfloor \frac L2\rfloor} 9 v_j$$

那么意味着如果我们确定前 $i$ 位，组合出来的数与 $D$ 相差 $v_i$ 时，显然是以后无论如何也无法恢复的。

那么每一步其实我们的填法从 $18$ 降低到只有 $2$ 种了。

我们需要枚举的长度应该是 $L_D \sim 2L_D$ （ $L_D$ 为 $D$ 十进制的长度），因为我们加减的范围应该是刚好 $L_D$ 的，超过 $2L_D$ 加减最小数已经超过了 $D$ 显然无法得到。

有科学的复杂度为

$$\begin{aligned} \mathcal O(\sum_{i = L_D}^{2L_D} 2^{\lfloor \frac i 2\rfloor}) &= \mathcal O(2^{L_D}) = \mathcal O(2^{\log_{10} D})\\ &= \mathcal O(2^{\frac{\log_2 D}{\log_2{10}}}) = \mathcal O(D^{\log_{10} 2}) \approx \mathcal O(D^{0.3010}) \end{aligned}$$

跑的挺快的。

代码

#include <bits/stdc++.h>

#define For(i, l, r) for (register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for (register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Rep(i, r) for (register int i = (0), i##end = (int)(r); i < i##end; ++i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << (x) << endl

using namespace std;

typedef long long ll;

template<typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, T b) { return b > a ? a = b, 1 : 0; }

inline int read() {
	int x(0), sgn(1); char ch(getchar());
	for (; !isdigit(ch); ch = getchar()) if (ch == '-') sgn = -1;
	for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
	return x * sgn;
}

void File() {
#ifdef zjp_shadow
	freopen ("F.in", "r", stdin);
	freopen ("F.out", "w", stdout);
#endif
}

int D, len, up;

ll Pow[20], v[20];

int Pool[20], *d = Pool + 10;

ll Dfs(ll cur, int dep) {
	if (dep == up) return !cur;
	int t = cur / v[dep]; ll res = 0;
	For (i, t - 1, t + 1) if (abs(i) <= 9 && abs(cur - i * v[dep]) < v[dep])
		res += (d[i] - (i >= 0 && !dep)) * Dfs(cur - i * v[dep], dep + 1);
	return res;
}

int main () {

	File();

	for (int tmp = (D = read()); tmp; tmp /= 10) ++ len;

	Pow[0] = 1;
	For (i, 1, 18) 
		Pow[i] = 10ll * Pow[i - 1];

	Rep (i, 10) Rep (j, 10) ++ d[i - j];

	ll ans = 0;
	For (i, len, len << 1) {
		For (j, 0, up = i >> 1)
			v[j] = Pow[i - j - 1] - Pow[j];
		ans += (i & 1 ? d[0] : 1) * Dfs(D, 0);
	}
	printf ("%lld\n", ans);

	return 0;

}

ARC 079

F - Namori Grundy

题意

给你一个 $n$ 个点的有向环套树，需要对于每个点定取值 $a_i \ge 0$ ，满足。

• 对于所有边 $(i, j)$ 有 $a_i \not = a_j$ 。
• 对于 $0 \le x < a_i$ 都存在至少一条边 $(i, j)$ 使得 $a_j = x$ 。

问是否存在一种合法方案。

$2 \le n \le 2 \times 10^5$

题解

其实操作本质上其实就是个 $\mathrm{mex}$ ，对于树上的 $\mathrm{mex}$ ，每个节点的值应该是确定的。

需要考虑环，处理完所有环上节点的子树，就得出了每个环上节点的取值下界 $b_i$ 。

1. 所有 $b_i$ 相同且环长度为偶数：我们隔一个数就把当前数加 $1$ 即可。

2. 所有 $b_i$ 相同且环长度为奇数：那么隔一加一的就不行了，其实不难发现这样无法构造出合法方案。

3. 存在有 $b_i$ 不同：找到 $b_i$ 最小的点 $v$ 把它 $+1$ ，然后依次考虑 $u \to v$ 然后如果 $b_u = b_v + 1$ 那么我们继续操作即可，不难发现这样操作一定会在某点停止不会绕圈。

这样我们就在 $\mathcal O(n)$ 的时间内判断出来了。

代码

Submissions 5475398

__EOF__

本文作者：zjp_shadow
本文链接：https://www.cnblogs.com/zjp-shadow/p/10730876.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！