📂Atcoder

🔖DP 倍增二分思维

2024-08-04 00:01阅读: 725评论: 15推荐: 8

AtCoder Beginner Contest 365

A - Leap Year (abc365 A)

题目大意

给定年份，判断该年是否是闰年。

解题思路

根据闰年的两个条件，注意判断即可。

神奇的代码

 #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 a;
    cin >> a;
    int day = 365;
    if (a % 400 == 0 || (a % 4 == 0 && a % 100 != 0)) {
        day = 366;
    }
    cout << day << '\n';
 
    return 0;
}

B - Second Best (abc365 B)

题目大意

给定 $n$ 个不同的数，问第二大的数的下标。

解题思路

对这 $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<int> a(n);
    for (auto& x : a)
        cin >> x;
    vector<int> id(n);
    iota(id.begin(), id.end(), 0);
    sort(id.begin(), id.end(), [&](int i, int j) { return a[i] < a[j]; });
    cout << id[n - 2] + 1 << '\n';
 
    return 0;
}

C - Transportation Expenses (abc365 C)

题目大意

给定 $n$ 个人的交通费用 $a_i$ ，确定最大补贴额度 $x$ ，使得给每个人的补贴为 $\min(x, a_i)$ ，总补贴额度不超过 $m$ 。

解题思路

很显然， $x$ 越高，总补贴额度越高， $x$ 越低，则补贴额度就越低，两者呈单调性。

因此可以二分 $x$ ，然后计算补贴额度。计算补贴额度就直接 $for$ 循环，求一遍 $\sum \min(x, a_i)$ 即可。

神奇的代码

 #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;
    LL m;
    cin >> n >> m;
    vector<LL> a(n);
    for (auto& i : a)
        cin >> i;
    LL l = 0, r = m + 1;
    if (accumulate(a.begin(), a.end(), 0LL) <= m) {
        cout << "infinite" << '\n';
    } else {
        auto check = [&](LL x) {
            LL sum = 0;
            for (auto i : a)
                sum += min(i, x);
            return sum <= m;
        };
        while (l + 1 < r) {
            LL mid = (l + r) / 2;
            if (check(mid))
                l = mid;
            else
                r = mid;
        }
        cout << l << '\n';
    }
 
    return 0;
}

以下代码不是二分，先假定 $x$ 的取值是 $a_i$ 之中，对 $a_i$ 从小到大遍历，找到最大的，总补贴度不超过 $m$ 的 $a_i$ ，但真正的 $x$ 不一定在 $a_i$ 之中，因为此时还有一些多余的钱，还可以分给每个人，只是达不到 $a_{i+1}$ ，因此剩余钱再均分给剩余人，得到真正的 $x$ 。

神奇的代码

 #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;
    LL m;
    cin >> n >> m;
    vector<int> a(n);
    for (auto& x : a)
        cin >> x;
    sort(a.begin(), a.end());
    LL tot = accumulate(a.begin(), a.end(), 0LL);
    if (tot <= m) {
        cout << "infinite" << '\n';
    } else {
        int id = -1;
        LL remain = 0;
        LL presum = 0;
        for (int i = 0; i < n; ++i) {
            LL sum = presum + 1ll * a[i] * (n - i);
            if (sum <= m) {
                id = i;
                remain = m - sum;
            }
            presum += a[i];
        }
        LL ans = m / n;
        if (id != -1) {
            ans = a[id] + remain / (n - id - 1);
        }
        cout << ans << '\n';
    }
 
    return 0;
}

D - AtCoder Janken 3 (abc365 D)

题目大意

剪刀石头布。

给定青木 $n$ 局的操作，要求确定高桥对应的操作，要求：

每一局高桥要么赢，要么平手。
高桥不能连续两局出同样的手势。

最大化高桥赢的局数。

解题思路

考虑某一局高桥能做出的手势，取决于两个

青木此局的手势，决定了高桥不能输
高桥上一局的手势，确保不会连续两局出同样的手势

由此，为了能够作出决策，我们仅需知道第 $i$ 局和上一局出的手势 $j$ 即可。

设 $dp[i][j]$ 表示考虑前 $i$ 局，第 $i$ 局高桥的手势是 $j$ ，高桥赢的局数的最大值。

转移则考虑高桥当前是赢还是平手（手势不与上一局相同），从 $dp[i-1][*]$ 转移过来即可。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
const int inf = 1e9 + 7;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    string s;
    cin >> n >> s;
    map<char, int> tr{{'R', 0},
                      {'P', 1},
                      {'S', 2}};
    string t = "PSR";
    array<int, 3> dp{0, 0, 0};
    for (auto& c : s) {
        array<int, 3> dp2{-inf, -inf, -inf};
        int pid = tr[c];
        char hashi = t[pid];
        int id = tr[hashi];
        for (int i = 0; i < 3; i++) {
            if (i != id)
                dp2[id] = max(dp2[id], dp[i] + 1);
            if (i != pid)
                dp2[pid] = max(dp2[pid], dp[i]);
        }
        dp2.swap(dp);
    }
    int ans = *max_element(dp.begin(), dp.end());
    cout << ans << '\n';
 
    return 0;
}

E - Xor Sigma Problem (abc365 E)

题目大意

给定 $n$ 个数 $a_i$ ，求 $\sum_{i=1}^{n-1}\sum_{j=i+1}^{n} a_i \oplus a_{i+1} \oplus ... \oplus a_j$

$\oplus$ 是异或操作。

解题思路

朴素做法显而易见的 $O(n^2)$ 。

由于异或操作下，二进制下每一位是相互独立的，因此我们可以考虑每一位的贡献。即考虑 $2^0,2^1,2^2,...,2^31$ 在这 $O(n^2)$ 个异或表达式结果中出现的次数。

$\sum_{i=1}^{n-1}\sum_{j=i+1}^{n} a_i \oplus a_{i+1} \oplus ... \oplus a_j = \sum_{i=0}^{31} 2^i cnt_i$

考虑如何求 $cnt_i$ 。

单独考虑每个数二进制下的第 $k$ 位，如果 $2^k$ 在一个 $a_i \oplus ... \oplus a_j$ 出现过，则这说明这些数的二进制下，第 $k$ 位是 $1$ 的次数是奇数。

因此对于 $k$ ，我们求 $odd_i$ 表示 $a_i$ 在二进制下的第 $k$ 位是不是 $1$ 。然后考虑有多少个区间 $odd$ 和是奇数。

区间异或和区间加法一样，可以表示成两个前缀和相减。因此求 $odd_i$ 的前缀和 $presum_i = odd_1 \oplus odd_2 \oplus ... \oplus odd_i$ ，则 $odd_i \oplus odd_{i+1} \oplus ... \oplus odd_j = presum_j \oplus presum_{i-1}$ 。

因此我们要求有多少对 $(i,j)$ ，满足 $presum_{j} \oplus presum_{i-1} = 1$ ，我们可以枚举 $j$ ，然后对应的 $i$ 的数量。

如果 $presum_j = 1$ ，则 $presum_{i-1} = 0$
如果 $presum_j = 0$ ，则 $presum_{i-1} = 1$
因此我们只需在从小到大枚举 $j$ 时，实时维护 $presum_i = 0$ 和 $presum_i = 1$ 的数量，然后根据 $presum_j$ 的取值，就知道对应的 $i$ 的数量。

得到 $(i,j)$ 对数 $cnt_k$ 后，就得到对于当前的 $k$ ，其对答案的贡献就是 $2^k cnt_k$ 。对所有的 $k$ 累计求和即为答案。

注意上述的求法包括了 $j = i$ 的情况，而题意是 $j > i$ ，所以最后再减去所有数的和即可。

神奇的代码

 #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<int> a(n);
    for (auto& x : a)
        cin >> x;
    LL ans = 0;
    auto solve = [&](int bit) {
        vector<int> odd(n);
        for (int i = 0; i < n; ++i) {
            odd[i] = (a[i] >> bit) & 1;
        }
        for (int i = 1; i < n; ++i) {
            odd[i] = odd[i] ^ odd[i - 1];
        }
        map<int, int> cnt;
        cnt[0] = 1;
        LL sum = 0;
        for (int i = 0; i < n; ++i) {
            sum += cnt[odd[i] ^ 1];
            cnt[odd[i]]++;
        }
        return sum;
    };
    for (int i = 0; i < 32; ++i) {
        ans += (1ll << i) * solve(i);
    }
    ans -= accumulate(a.begin(), a.end(), 0ll);
    cout << ans << '\n';
 
    return 0;
}

F - Takahashi on Grid (abc365 F)

题目大意

二维网格， $n \times m$ ，每一列有一个连续的空间是空地。每一列的空地必定相交。

回答 $q$ 个问题。

每个问题，给定起点终点，每次可以上下左右走一格，问移动的最小步数。

解题思路

显而易见的朴素做法的时间复杂度为 $O(nq)$ ，即对于每个询问，从 $sx \to sx+1 \to sx+2 \to ... \to tx$ ，一列一列移动。

以下下标 $(x,y)$ 表示第 $x$ 列第 $y$ 行，注意与平时表示的意思不同。

考虑移动过程，其实就两个阶段：

第一阶段，能够直接平行移动，即 $(x, y) \to (x + 1, y)$
第二阶段，不能平行移动了，得上下移动，这时一定有 $(x, y) \to (x, l[x+1])$ 或 $(x, r[x+1])$ 。即抵达下一列的上下两个端点，然后往右边继续移动。

然后这两阶段不断重复。

对于第一阶段，可以通过预处理，在 $O(\log n)$ 的时间内找到平行移动到最右边的边界，即此时会有 $y < l[x + 1]$ 或 $y > r[x + 1]$ ，因此用 $st$ 表预处理 $lmax[i,j]$ 表示列 $[i,j]$ 的 $l$ 的最大值， $rmin[i,j]$ 表示列 $[i,j]$ 的 $r$ 的最小值，通过二分可以找到这个平行移动的边界列。

然后是第二阶段，注意到第二阶段的开始起点只有 $2n$ 个：每列要么是从上端点开始，要么从下端点开始。因此我们可以预处理出，从每个这样的起点出发，到达每一列的代价之类的东西。

具体是怎样的东西呢？注意到从这些端点出发，其实后续的路线就是固定了，所以可以用倍增的方法，预处理出从每个端点出发，走 $2^i$ 步后，抵达到哪个列的上端点或下端点，代价是多少。

这里的一步指的是必须变动 $y$ 的，即经过一次第二阶段，即，如果从 $(x,y)$ 能平行移动则一直平行移动，直到要上下移动才能抵达下一列 $s$ ，这样就称之为一步，从 $x \to s$ ， $y \to l[s]$ 或 $y \to r[s]$ 。

定义了一步后，就可以预处理倍增数组 $run[i][x][0/1]$ 表示从第 $x$ 行的上/下端点，走 $2^i$ 步后抵达的 (列，上/下端点，移动次数)这么个三元组。

然后对于每个询问，通过二分求出第一阶段移动的移动次数，此时抵达到第二阶段的一个起点，再通过倍增数组得到移动到 $(tx, ty)$ 的移动次数。这里可能不能直接到 $(tx, ty)$ ，可能最后再通过第一阶段的平行移动到 $tx$ ，再上下移动到 $ty$ ，加个判断即可。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
// usage:
//   auto fun = [&](int i, int j) { return min(i, j); };
//   SparseTable<int, decltype(fun)> st(a, fun);
// or:
//   SparseTable<int> st(a, [&](int i, int j) { return min(i, j); });
template <typename T, class F = function<T(const T&, const T&)>>
class SparseTable {
  public:
    int n;
    vector<vector<T>> mat;
    F func;
 
    SparseTable(const vector<T>& a, const F& f) : func(f) {
        n = static_cast<int>(a.size());
        int max_log = 32 - __builtin_clz(n);
        mat.resize(max_log);
        mat[0] = a;
        for (int j = 1; j < max_log; j++) {
            mat[j].resize(n - (1 << j) + 1);
            for (int i = 0; i <= n - (1 << j); i++) {
                mat[j][i] = func(mat[j - 1][i], mat[j - 1][i + (1 << (j - 1))]);
            }
        }
    }
 
    T get(int from, int to) const { // [from, to]
        assert(0 <= from && from <= to && to <= n - 1);
        int lg = 32 - __builtin_clz(to - from + 1) - 1;
        return func(mat[lg][from], mat[lg][to - (1 << lg) + 1]);
    }
};
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<int> l(n), r(n);
    for (int i = 0; i < n; i++)
        cin >> l[i] >> r[i];
    vector<vector<vector<array<LL, 3>>>> run(
        31, vector<vector<array<LL, 3>>>(
                n, vector<array<LL, 3>>(2, array<LL, 3>{})));
    SparseTable<int> L(l, [&](int i, int j) { return max(i, j); });
    SparseTable<int> R(r, [&](int i, int j) { return min(i, j); });
    auto step = [&](int x, int y) {
        int l = x, r = n;
        while (l + 1 < r) {
            int m = (l + r) / 2;
            if (L.get(x, m) <= y && R.get(x, m) >= y) {
                l = m;
            } else {
                r = m;
            }
        }
        return l + 1;
    };
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < 2; ++j) {
            int x = i, y = (j ? r[i] : l[i]);
            int nxt = step(x, y);
            if (nxt == n) {
                run[0][i][j] = {n, 0, n - i};
            } else if (l[nxt] > y) {
                run[0][i][j] = {nxt, 0, l[nxt] - y + nxt - i};
            } else {
                run[0][i][j] = {nxt, 1, y - r[nxt] + nxt - i};
            }
        }
    }
 
    for (int i = 1; i <= 30; ++i) {
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < 2; ++k) {
                auto [nxt, d, cost] = run[i - 1][j][k];
                if (nxt == n) {
                    run[i][j][k] = {n, 0, cost};
                } else {
                    auto [nnxt, dd, ccost] = run[i - 1][nxt][d];
                    run[i][j][k] = {nnxt, dd, cost + ccost};
                }
            }
        }
    }
 
    auto solve = [&](int sx, int sy, int tx, int ty) -> LL {
        if (sx == tx) {
            return abs(ty - sy);
        }
        if (sx > tx) {
            swap(sx, tx);
            swap(sy, ty);
        }
        int nxt = step(sx, sy);
        if (nxt > tx) {
            return abs(ty - sy) + tx - sx;
        }
        int sign = (sy < l[nxt] ? 0 : 1);
        LL ret = nxt - sx + (sign ? sy - r[nxt] : l[nxt] - sy);
        sx = nxt;
        for (int i = 30; i >= 0; --i) {
            auto [nnxt, dd, ccost] = run[i][sx][sign];
            if (nnxt <= tx) {
                ret += ccost;
                sx = nnxt;
                sign = dd;
            }
        }
        ret += tx - sx + (sign ? abs(ty - r[sx]) : abs(l[sx] - ty));
        return ret;
    };
 
    int q;
    cin >> q;
    while (q--) {
        int sx, sy, tx, ty;
        cin >> sx >> sy >> tx >> ty;
        --sx, --tx;
        LL ans = solve(sx, sy, tx, ty);
        cout << ans << '\n';
    }
 
    return 0;
}

G - AtCoder Office (abc365 G)

题目大意

给定 $n$ 个员工在公司的若干条时间段，回答 $q$ 个问题。

每个问题，询问两个员工 $i,j$ 同时在公司的时间。

解题思路

<++>

神奇的代码

本文作者：~Lanly~

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

posted @ 2024-08-04 00:01 ~Lanly~ 阅读(725) 评论(15) 编辑收藏举报

刷新页面返回顶部

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

公告

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

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

+加关注

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

2025年3月

日

一

二

三

四

五

六

~Lanly~

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

AtCoder Beginner Contest 365

A - Leap Year (abc365 A)

题目大意

解题思路

B - Second Best (abc365 B)

题目大意

解题思路

C - Transportation Expenses (abc365 C)

题目大意

解题思路

D - AtCoder Janken 3 (abc365 D)

题目大意

解题思路

E - Xor Sigma Problem (abc365 E)

题目大意

解题思路

F - Takahashi on Grid (abc365 F)

题目大意

解题思路

G - AtCoder Office (abc365 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 a;
	cin >> a;
	int day = 365;
	if (a % 400 == 0 \|\| (a % 4 == 0 && a % 100 != 0)) {
	day = 366;
	}
	cout << day << '\n';

	return 0;
	}