📂Atcoder

🔖DFS DP set 思维倍增

2024-09-07 22:21阅读: 748评论: 2推荐: 1

AtCoder Beginner Contest 370

A - Raise Both Hands (abc370 A)

题目大意

给出Snuke举的左右手情况，如果只举左手，输出Yes，如果只举右手，输出No，否则输出Invalid。

解题思路

逐一判断即可。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int l, r;
    cin >> l >> r;
    if (l == 1 && r == 0)
        cout << "Yes" << '\n';
    else if (l == 0 && r == 1)
        cout << "No" << '\n';
    else
        cout << "Invalid" << '\n';
 
    return 0;
}

B - Binary Alchemy (abc370 B)

题目大意

给定物品合成成分表 $a_{ij}$ 表示物品 $i$ 和物品 $j$ 合成物品 $a_{ij}$ 。

问物品 $1$ ，依次与 $1,2,3,..N$ 物品合成，问最后的物品。

解题思路

按照题意查表，模拟合成即可。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<vector<int>> a(n);
    for (int i = 0; i < n; i++) {
        a[i].resize(i + 1);
        for (auto& x : a[i]) {
            cin >> x;
            --x;
        }
    }
    int cur = 0;
    for (int i = 0; i < n; ++i) {
        int x = cur, y = i;
        if (x < y)
            swap(x, y);
        cur = a[x][y];
    }
    cout << cur + 1 << '\n';
 
    return 0;
}

C - Word Ladder (abc370 C)

题目大意

给定两个字符串 $s,t$ 。

用最小的次数，使得 $s=t$ ，并且字符串 $x$ 的字典序最小。

操作为，选择 $s_i = c$ ，并且将修改后的 $s$ 放入 $x$ 的末尾。

解题思路

如何次数最小呢？

依次考虑 $s$ 从左到右的每一位 $i$ ，如果 $s_i \neq t_i$ ，那我肯定要 $s_i = t_i$ ，但这是我们此时要进行的操作吗？还是先放一放，改后面的字母后，再改当前位？

由于每次会将修改后的 $s$ 放入 $x$ 的末尾，因此我们要优先考虑首先进行的操作，应该是：即刻进行，还是缓一缓在进行。

如果 $s_i > t_i$ ，那就优先更改当前位，这样改后的 $s$ 的字典序更小。

如果 $s_i < t_i$ ，那就先更改后面位的，最后再改当前位，这样得到的 $x$ 的字典序最小。

这种回溯的感觉，可以用 $DFS$ 实现上述操作。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    string s, t;
    cin >> s >> t;
    vector<string> ans;
    auto dfs = [&](auto dfs, int pos) {
        if (pos == s.size()) {
            return;
        }
        if (s[pos] == t[pos]) {
            dfs(dfs, pos + 1);
        } else if (s[pos] < t[pos]) {
            dfs(dfs, pos + 1);
            s[pos] = t[pos];
            ans.push_back(s);
        } else {
            s[pos] = t[pos];
            ans.push_back(s);
            dfs(dfs, pos + 1);
        }
    };
    dfs(dfs, 0);
    cout << ans.size() << '\n';
    for (auto& i : ans)
        cout << i << '\n';
 
    return 0;
}

D - Cross Explosion (abc370 D)

题目大意

二维网格，初始每个格子有墙。

依次进行 $q$ 次放炸弹的操作，给定每次放炸弹的位置 $(i,j)$ ，如果该位置有墙，则该墙消失。

否则，炸弹会爆炸，会产生十字冲击波，该位置上下左右的各第一个墙都会消失。

问最后还存在的墙的数量。

解题思路

对于第一种情况，直接移除该位置的墙即可。

对于第二种情况，需要找到该列上下、该行左右最近的墙。

墙的数量 $hw \leq 4e5$ ，可以储存每个墙的坐标。

然后对于每行和每列，分别维护 $hset[i]$ 表示第 $i$ 行还有墙的列坐标，是个 $set$ ， $wset[i]$ 表示第 $i$ 列还有墙的行坐标，也是个 $set$ 。

这样，对于一个炸弹 $(i,j)$ ，如果该位置没有墙 $(hset[i].find(j) == hset[i].end())$ ，则需要找到 $< j$ 的最大和 $> j$ 的最小的数字。同理对于 $wset$ 也要找对应的数字，然后 $erase$ 。这样每次操作的复杂度都是 $O(\log)$ ，总的时间复杂度就是 $O(q\log (h + w))$ 。

代码对于没有墙的逻辑是：

$it = hset[i].lower\_bound(j)$ ，由于没有墙，此时一定 $*it > y$ （否则是 $*it == y$ ），如果 $it != hset[i].end()$ ，那么它就是下面的第一个墙（这里认为左上是原点），要毁掉，于是 $it = hset[i].erase(it)$ ， $erase$ 返回值是移除了该 $*it$ 后的下一个元素。
然后要找上面的第一个墙，此时 $it$ 是 $>y$ 的第一个位置（无论刚刚是否 $erase$ 了），因此如果 $it != hset[i].begin()$ ，那么 $prev(it)$ 就是上面的第一个墙，要毁掉，于是 $hset[i].erase(prev(it))$ 。

同理的思路处理 $wset$ 即可。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int h, w, q;
    cin >> h >> w >> q;
    vector<int> hh(h), ww(w);
    iota(hh.begin(), hh.end(), 0);
    iota(ww.begin(), ww.end(), 0);
    vector<set<int>> hset(h), wset(w);
    for (int i = 0; i < h; i++) {
        hset[i].insert(ww.begin(), ww.end());
    }
    for (int i = 0; i < w; i++) {
        wset[i].insert(hh.begin(), hh.end());
    }
    while (q--) {
        int x, y;
        cin >> x >> y;
        --x, --y;
        auto it = hset[x].lower_bound(y);
        if (it != hset[x].end() && *it == y) {
            hset[x].erase(y);
            wset[y].erase(x);
        } else {
            if (it != hset[x].end()) {
                wset[*it].erase(x);
                it = hset[x].erase(it);
            }
            if (it != hset[x].begin()) {
                it = prev(it);
                wset[*it].erase(x);
                hset[x].erase(it);
            }
            it = wset[y].lower_bound(x);
            if (it != wset[y].end()) {
                hset[*it].erase(y);
                it = wset[y].erase(it);
            }
            if (it != wset[y].begin()) {
                it = prev(it);
                hset[*it].erase(y);
                wset[y].erase(it);
            }
        }
    }
    int cnt = 0;
    for (int i = 0; i < h; i++) {
        cnt += hset[i].size();
    }
    cout << cnt << '\n';
 
    return 0;
}

E - Avoid K Partition (abc370 E)

题目大意

给定一个数组 $a$ ，划分成若干个子区间，使得没有子区间的和为 $k$ 。

求划分方案数。

解题思路

朴素 $dp$ 就是设 $dp[i]$ 表示前 $i$ 段划分满足条件的方案数。

转移则枚举最后一次的区间，然后 $dp[i] = \sum_{1 \leq j \leq n, sum[j+1..i] \neq k} dp[j]$ 。

复杂度显然是 $O(n^2)$ 的。

棘手在条件 $sum[j+1..i] \neq k$ 上，如果没有这个条件，这个转移其实就是一个前缀和，用前缀和优化即为 $O(n)$ 。

我们用前缀和相减代替区间和，即 $sum[j+1..i] = sum[i] - sum[j]$ ，转移式即为 $dp[i] = \sum_{1 \leq j \leq i, sum[i] - sum[j] \neq k} dp[j]$ 。

换句话说，我们要对 $sum[j] \neq sum[i] - k$ 的 $dp[j]$ 求和，这是个非常稀疏的条件，即如果设 $cnt[i] = \sum_{sum[j] = i} dp[j]$ ，即前缀和为 $i$ 的 $dp$ 值，那上述转移式可改写成 $dp[i] = \sum_{1 \leq j < i} dp[j] - cnt[sum[i] - k]$ 。

即一个前缀和与一个数的差值，这样转移就是 $O(1)$ 了，因此维护一个 $dp$ 前缀和 $\sum_{1 \leq j < i} dp[j]$ 以及前缀和的 $dp$ 和 $cnt[i] = \sum_{sum[j] = i} dp[j]$ 即可。

时间复杂度就是 $O(n \log n)$ 。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
const int mo = 998244353;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    LL k;
    cin >> n >> k;
    vector<int> a(n);
    for (auto& x : a)
        cin >> x;
    map<LL, int> cnt;
    cnt[0] = 1;
    LL presum = 0;
    int precnt = 1;
    int ans = 0;
    for (auto& i : a) {
        presum += i;
        ans = (precnt - cnt[presum - k] + mo) % mo;
        cnt[presum] = (cnt[presum] + ans) % mo;
        precnt = (precnt + ans) % mo;
    };
    cout << ans << '\n';
 
    return 0;
}

F - Cake Division (abc370 F)

题目大意

给定一个环形数组，划分为 $k$ 段，使得每段和的最小值最大。

在该最大值的各种划分方案中，求有多少位置，在所有划分方案中都不被分开。

解题思路

如果我们确定了这个每段和的最小值 $x$ ，且是一个链的情况，我们有个贪心的策略：从第一个数开始往右延伸，直到第一个不小于 $x$ 的位置 $y$ ，有 $sum[1..y] \geq x, sum[1..y-1] < x$ ，它们就是一段，我们定义 $f(1) = y + 1$ ，如果不存在可行的话， $f(1) = n + 1$ 。 $f(1) = y + 1$ 表示分了一段区间 $[1,y+1)$ 。如果能往复能分成 $k$ 段则可行。时间复杂度是 $O(n)$ 或 $O(k \log n)$ 。后者就是二分来找到每一段的最右端。

容易发现这个 $x$ 与是否可行具有单调性： $x$ 越大，越难可行， $x$ 越小，越容易可行。因此可以通过二分找到这个 $x$ 。

然后考虑环的情况，一种处理方法是考虑每个起点，每个起点都做一次上述验证，如果存在一个起点满足上述要求则可行。这样验证的复杂度是 $O(nk\log n)$ 。

如何优化呢？

由于环形，我们拆成链，然后复制一份。注意到以每个位置 $i$ 为起点，计算 $f(i)$ 的值，可以通过 $O(n)$ 的滑动窗口得到 $f$ 。这就是分一段的区间，而如果分两段就是 $f(f(x))$ 。注意到只要起点固定，它会延伸到哪里也固定了，不同段之间也相互独立。因此函数可以简单的复合起来，相比于一次一次分，优化方向就是以倍增的形式分段。

即二分了 $x$ 后，预处理倍增数组 $up[i][j]$ 表示从 $i$ 开始，分了 $2^j$ 段后的右边界 $y$ ，即 $[i,y)$ 包含了满足题意的 $2^j$ 段。只要 $y - i \leq n$ ，那么从 $i$ 开始就可行的。通过倍增数组来分 $k$ 段，每个起点的验证复杂度就降为 $O(\log k)$ 。

最后求有多少位置是不会被断开的，就在枚举起点的时候，如果不可行，那么该起点与上一个数之间就不能断开（断开了就是以该数为起点，经求得是不可行的），因此后者就是不可行的起点数量。

总的时间复杂度就是 $O(n\log nk)$

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, k;
    cin >> n >> k;
    vector<int> a(n + n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        a[i + n] = a[i];
    }
    int N = n + n;
    int l = 1, r = 2e9 + 8;
    auto check = [&](int x) {
        vector<array<int, 20>> up(N + 2);
        up[N][0] = N + 1;
        up[N + 1][0] = N + 1;
        queue<int> windows;
        int r = 0;
        int sum = 0;
        for (int i = 0; i < N; ++i) {
            while (r < N && sum < x) {
                windows.push(a[r]);
                sum += a[r];
                ++r;
            }
            if (sum < x)
                up[i][0] = N + 1;
            else
                up[i][0] = r;
 
            sum -= windows.front();
            windows.pop();
        };
        for (int i = 1; i < 20; ++i)
            for (int j = 0; j < N + 2; ++j) {
                up[j][i] = up[up[j][i - 1]][i - 1];
            }
        int cnt = 0;
        for (int i = 0; i < n; ++i) {
            int pos = i;
            for (int j = 0; j < 20; ++j) {
                if ((k >> j) & 1) {
                    pos = up[pos][j];
                }
            }
            if (pos <= i + n) {
                ++cnt;
            }
        }
        return cnt;
    };
    while (l + 1 < r) {
        int mid = l + (r - l) / 2;
        if (check(mid))
            l = mid;
        else
            r = mid;
    }
    int cnt = check(l);
    cout << l << ' ' << n - cnt << '\n';
 
    return 0;
}

G - Divisible by 3 (abc370 G)

题目大意

如果一个数是好的，说明它的因子和能被 $3$ 整除。

给定 $n,m$ ，问一个长度为 $m$ 的数组 $a$ 的数量，满足其各数的乘积不超过 $n$ ，且是好数。

解题思路

<++>

神奇的代码

本文作者：~Lanly~

本文链接：https://www.cnblogs.com/Lanly/p/18402239

posted @ 2024-09-07 22:21 ~Lanly~ 阅读(748) 评论(2) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

昵称：~Lanly~ 园龄：8年3个月粉丝：300 关注：55

昵称： ~Lanly~
园龄： 8年3个月
粉丝： 300
关注： 55

+加关注

指尖跃动的换行符，是我此生不变的信仰。|

2025年3月

日

一

二

三

四

五

六

~Lanly~

指尖跃动的换行符，是我此生不变的信仰。

AtCoder Beginner Contest 370

A - Raise Both Hands (abc370 A)

题目大意

解题思路

B - Binary Alchemy (abc370 B)

题目大意

解题思路

C - Word Ladder (abc370 C)

题目大意

解题思路

D - Cross Explosion (abc370 D)

题目大意

解题思路

E - Avoid K Partition (abc370 E)

题目大意

解题思路

F - Cake Division (abc370 F)

题目大意

解题思路

G - Divisible by 3 (abc370 G)

题目大意

解题思路

公告

我的标签

随笔分类

随笔档案

友情链接

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	#include <bits/stdc++.h>
	using namespace std;
	using LL = long long;

	int main(void) {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int l, r;
	cin >> l >> r;
	if (l == 1 && r == 0)
	cout << "Yes" << '\n';
	else if (l == 0 && r == 1)
	cout << "No" << '\n';
	else
	cout << "Invalid" << '\n';

	return 0;
	}