atcoder abc370(dp，基环树/森林，倍增)

最新推荐文章于 2024-09-14 20:30:05 发布

'eiyuu

最新推荐文章于 2024-09-14 20:30:05 发布

阅读量472

点赞数 6

文章标签：算法

本文链接：https://blog.csdn.net/2201_75845839/article/details/142070258

版权

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    if(a == 1 && b == 0) cout << "Yes" << endl;
    else if(a == 0 && b == 1) cout << "No" << endl;
    else cout << "Invalid" << endl;
    return 0;
}

B - binary aichemy

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<vector<int>> a((n + 1), vector<int>(n + 1));
    for(int i = 1; i <= n; i ++ ) {
        for(int j = 1; j <= i; j ++ ) {
            cin >> a[i][j];
        }
    }

    int val = 1;
    for(int i = 1; i <= n; i ++ ) {
        if(val >= i) val = a[val][i];
        else val = a[i][val];
    }
    cout << val;
    return 0;
}

C - word ladder

问题：

思路：先从前往后把字典序变小的字符改变，再从后向前把字典序变大的字符改变，由于数据范围很小，两个while即可

代码：

#include <bits/stdc++.h>

using namespace std;

string a, b;

bool cmp(int x, int y) {
    if(x < y) return b[x] < a[x];
    if(x > y) return b[y] < a[y];
}

int main() {
    cin >> a >> b;
    a = a;
    b = b;
    int n = a.length();
    vector<string> ans;
    bool flag = true;
    while(flag) {
        flag = false;
        for(int i = 0; i < n; i ++ ) {
            if(a[i] > b[i]) {
                flag = true;
                a[i] = b[i];
                ans.push_back(a);
            }
        }
    }
    
    flag = true;
    while(flag) {
        flag = false;
        for(int i = n - 1; i >= 0; i -- ) {
            if(a[i] != b[i]) {
                flag = true;
                a[i] = b[i];
                ans.push_back(a);
            }
        }
    }
    
    cout << ans.size() << endl;
    for(auto t: ans) cout << t << endl;
    return 0;
}

D - Cross Explosion

问题：

思路：用vector<set<int>> 存储每一行/列中没有被爆破掉的点，在查询时用二分查询第一个大于和第一个小于被查询的点

代码：runtime error中

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main() {
    int n, m, q;
    cin >> n >> m >> q;
    
    vector<set<int>> row(n + 2), col(m + 2);
    vector<vector<bool>> st((n + 1), vector<bool>(m + 1));
    for(int i = 0; i <= n; i ++ ) {
        for(int j = 0; j <= m; j ++ ) {
            row[i].insert(j);
            col[j].insert(i);
        }
    }

    ll ans = 0;
    while(q -- ) {
        int a, b;
        cin >> a >> b;
        if(!st[a][b]) {
            ans ++;
            st[a][b] = true;
            row[a].erase(b);
            col[b].erase(a);
        } else {
            auto it = row[a].lower_bound(b);
            if(it != row[a].end()) {
                ans ++;
                row[a].erase(*it);
                col[*it].erase(a);
                st[a][*it] = true;
            }

            it --;
            if(it != row[a].begin()) {
                ans ++;
                row[a].erase(*it);
                col[*it].erase(a);
                st[a][*it] = true;
            }

            it = col[b].lower_bound(a);
            if(it != col[b].end()) {
                ans ++;
                col[b].erase(*it);
                row[*it].erase(b);
                st[*it][b] = true;
            }

            it --;
            if(it != col[b].begin()) {
                ans ++;
                col[b].erase(*it);
                row[*it].erase(b);
                st[*it][b] = true;
            }
        }
    }
    cout << n * m - ans;
    return 0;
}

E avoid k partition

问题：

思路：动态规划

首先很容易想到两重循环动态规划的写法

for(int i = 1; i <= n; i ++ ) {
        for(int j = 0; j < i; j ++ ) {
            if(a[i] - a[j] != k) dp[i] += dp[j];
        }
}

设dp[i]表示以i结尾的各子段和不等于k的划分方法的集合

dp[0]初始化为1，以后的所有状态都由dp[0]转移, 对于所有小于i的j，如果j，i的子段和不等于k，那么对于dp[i]就可以加上dp[j]

注意到第二层循环实际上是所有满足条件的dp[j](j < i)的和，因此优化在这一层循环上做文章

如果不考虑分段的条件，只考虑分段的数量，那么dp[i]实际上就等于dp[i - 1], 再用上一轮所有合法解，减去这一轮判掉的所有不合法解

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll mod = 998244353;

ll qmi(ll a, ll b) {
    ll res = 1;
    while(b) {
        if(b & 1) (res *= a) %= mod;
        (a *= a) %= mod;
        b >>= 1;
    }
    return res;
}

int main() {
    ll n, k;
    cin >> n >> k;
    vector<ll> a(n + 1);
    vector<ll> dp(n + 1);
    for(int i = 1; i <= n; i ++ ) {
        cin >> a[i];
        a[i] += a[i - 1];
    }
    
    dp[0] = 1;
    /*for(int i = 1; i <= n; i ++ ) {
        for(int j = 0; j < i; j ++ ) {
            if(a[i] - a[j] != k) dp[i] += dp[j];
        }
    }*/
    map<ll, ll> ma;
    ma[0] ++;
    ll tot = 1;
    //tot 是上一轮循环中所有不等于k的分段方法和
    for(int i = 1; i <= n; i ++ ) {
        //ll tot = qmi(2, i - 1);
        (dp[i] += tot - ma[a[i] - k] + mod) %= mod;//从所有合法方案中减去不合法方案
        (ma[a[i]] += dp[i]) %= mod;//维护的是所有dp[i](i < j)的和，且前缀和为a[i]
        (tot += dp[i]) %= mod;//维护的是所有dp[i](i < j)的和，是目前为止对于j来说的所有合法方案
    }
    cout << dp[n];
    return 0;
}

这里的tot与ma存的都是上一轮结束后的状态，与背包问题一维优化思想一致.

F cake division

思路：这一题乍一看很简单，结果求最小值的max，直接二分答案，重点是check函数怎么写

当我们二分出一个值mid之后，我们划分的每一段都不能小于这个值(除非该值本身非法),又由于划分的数量有要求，即k段，因此我们应该贪心的使我们划分的每一段在不小于mid的前提下最小，这样处理完每个点之后实际上会形成一张图，

(当然可能是多张图。另外，假设i 点最后处理到的点是j点，由于下一次划分要从j + 1开始，因此我们可以直接设置i 点应该跳到j + 1，以此简化处理)

因此，由于必须划分k段，我们可以在判断最后一段合法之后把剩余部分接到最后一段上，这样不会影响最小值(我们只需要知道这一点，没有必要在写代码时接上最后一段)。同时，由于处理的蛋糕是个环，因此要破环为链(acwing能量项链)。在check时，如何判断一个划分合法呢,首先为划分设置一个哨兵，将a[2 * n + 1](前缀和数组)设为1e18,然后当我们枚举划分起点，如果从某个点开始跳k步后仍然没有走出一个环的距离，即end pos <= i + n那么就认为这段划分合法, 在这里，枚举要枚举n个起点，每个起点都要走k步，时间复杂度是 nk显然超时，但是第二层循环可以用倍增优化(acwing祖孙询问)，在这里的倍增容易出错的点就是上限设置以及循环顺序：

void init(ll m) {
    for(int i = 1; i <= 2 * n + 1; i ++ ) {
        for(int j = 0; j <= 19; j ++ ) {
            dp[i][j] = 2 * n + 1;
        }
    }
    
    for(int i = 1; i <= n * 2; i ++ ) {
        int l = i, r = 2 * n;
        while(l < r) {
            int mid = l + r >> 1;
            if(a[mid] - a[i - 1] >= m) r = mid;
            else l = mid + 1;
        }
        dp[i][0] = l + 1;
    }
        
    for(int j = 1; j <= 19; j ++ ) {
        for(int i = 1; i <= 2 * n + 1; i ++ ) {
            dp[i][j] = dp[dp[i][j - 1]][j - 1];
        }
    }
}

dp[0 ~ 2 * n + 1][0 ~ x] = 2 * n + 1这个初始化锁定了上限,2 * n + 1是上限的下一个点

于是时间复杂度被优化成了n logk

再看第二问，实际上就是在遍历倍增的同时，记录下哪个点的end pos > n + i

代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const ll mod = 998244353;
const ll N = 2e5 + 10;

ll a[N * 2];
ll dp[N * 2][20];
ll n, k;

void getdp(ll m) {
    for(int i = 1; i <= 2 * n + 1; i ++ ) {
        for(int j = 0; j <= 19; j ++ ) {
            dp[i][j] = 2 * n + 1;
        }
    }
    
    for(int i = 1; i <= n * 2; i ++ ) {
        int l = i, r = 2 * n;
        while(l < r) {
            int mid = l + r >> 1;
            if(a[mid] - a[i - 1] >= m) r = mid;
            else l = mid + 1;
        }
        dp[i][0] = l + 1;
    }
        
    for(int j = 1; j <= 19; j ++ ) {
        for(int i = 1; i <= 2 * n + 1; i ++ ) {
            dp[i][j] = dp[dp[i][j - 1]][j - 1];
        }
    }
}


bool check(ll m) {
    getdp(m);
    for(int i = 1; i <= n; i ++ ) {
        int pos = i;
        for(int j = 0; j <= 19; j ++ ) {
            if(k >> j & 1) {
                pos = dp[pos][j];
            }                
        }
        if(pos <= n + i) return true;
    }
    return false;
}


int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n >> k;
    a[2 * n + 1] = 1e18;
    ll minv = 1e18;
    for(int i = 1; i <= n; i ++ ) {
        cin >> a[i];
        minv = min(minv, a[i]);
    }
    for(int i = n + 1; i <= 2 * n; i ++ ) a[i] = a[i - n];
    for(int i = 1; i <= 2 * n; i ++ ) a[i] += a[i - 1];
    
    ll l = minv, r = a[2 * n];
    while(l < r) {
        ll mid = l + r + 1 >> 1;
        if(check(mid)) l = mid;
        else r = mid - 1;
    }
    cout << l << " ";
    
    getdp(l);
    ll ans = 0;
    for(int i = 1; i <= n; i ++ ) {
        int pos = i;
        for(int j = 0; j <= 19; j ++ ) {
            if(k >> j & 1) {
                pos = dp[pos][j];
            }                
        }
        if(pos > n + i) ans ++;
    }
    cout << ans;
    return 0;
}