Educational Codeforces Round 143 (Rated for Div. 2) 感想

qq_29361081

已于 2023-02-18 13:33:11 修改

阅读量409

点赞数 1

分类专栏：感想栏文章标签：算法 c++ 数据结构

于 2023-02-17 17:24:21 首次发布

本文链接：https://blog.csdn.net/qq_29361081/article/details/129089600

版权

感想栏专栏收录该内容

5 篇文章 0 订阅

订阅专栏

感想

感觉比力扣难好多（，最终结果4/7，其实说不定E也能做，但因为我没发现a == b == c这种神奇错误浪费了一个小时。
~~什么时候写算法题能又快又好啊。~~

A. Two Towers

1.题目内容

题目地址

2.个人思路：

假设一个柱子（塔）的方块全部移动到另一个柱子（塔）上，如果两个柱子都是符合条件的，那么就有两种可能
1.新柱子也是符合条件不存在连续不同的。
2.新柱子只有最初连接的方块颜色相同（eg. rbrbr和rbrbr）合并。

实际上就是将两个字符串合并，如果新字符串有超过一个的连续相同就不满足条件，反之就可以。

3.代码：

ll t, n, m, cnt[100005];
string s1, s2;
 
int main() {
    cin >> t;
    while (t--) {
        cin >> n >> m;
        cin >> s1 >> s2;
        int cnt = 0;
        string s3 = s1;
        for (int i = 0; i < s2.size(); i++) {
            s3 += s2[m - i - 1];
        }
        for (int i = 0; i < s3.size() - 1; i++) {
            if (s3[i] == s3[i + 1]) cnt++;
        }
        cout << ((cnt > 1) ? "NO\n" : "YES\n");
    }
    return 0;
}

B、Ideal Point

1.题目内容

题目地址

2.个人思路：

这里有一个结论就是，如果所有包含k的区间都加上后k不是唯一的最大值，那么它就一定不会是唯一的最大值。

原因也很简单，如果存在一个x >= k 那么如果想减小这个x，就一定会减小k，因为每一个区间一定包含k，所以结论成立。
另外加上不包含k的区间对让k成为唯一最大值毫无意义，所以无视即可。

在代码实现中，只需要计算最大值和最大值的数量，然后与k进行比较即可。

3.代码：

struct com {
    ll f;
    ll to;
    ll u;
    bool operator < (const com& b) const {
        if (f == b.f) return to > b.to;
        return f < b.f;
    }
};

ll t, n, k;
vector<com> lis;
 
int main() {
    cin >> t;
    while (t--) {
        cin >> n >> k;
        int arr[55] = { 0 };
        for (int i = 1; i <= 50; i++) arr[i] = 0;
        lis.clear();
        int max = 0, mn = 0;
        for (int i = 1; i <= n; i++) {
            int a, b;
            cin >> a >> b;
            if (a <= k && b >= k) {
                lis.push_back({ a, b, 0 });
            }
        }
        for (int i = 0; i < lis.size(); i++) {
            int x = lis[i].f, y = lis[i].to;
            for (int j = x; j <= y; j++) {
                arr[j]++;
            }
        }
        for (int i = 1; i <= 50; i++) {
            if (arr[i] > max) {
                mn = 1;
                max = arr[i];
            }
            else if (arr[i] == max) {
                mn++;
            }
        }
        if (mn == 1 && max == arr[k]) {
            cout << "YES\n";
        }
        else cout << "NO\n";
    }
    
    return 0;
}

C、Tea Tasting

1.题目内容

题目地址

2.个人思路：

前缀和 + 二分查找 + 差分
考虑每个人能完整喝bi口茶的次数，然后加上他喝剩下的次数就是答案。
首先找到第i个茶在哪个人身上喝完，设喝完的人为x，那么就是利用二分查找找到第一个大于等于ai的sum[x] - sum[i - 1]的位置
如果是等于ai，那么[i, x]的所有人完整喝茶次数+1
如果是大于ai，那么[i, x - 1]的所有人完整喝茶次数+1，x处的人加上剩下的茶叶毫升数。

最后每个人的茶叶饮用量就是 bi * 茶叶饮用次数 *+ 喝掉的剩余茶叶数。
可以使用差分数组处理区间加一，总的时间复杂度为O（nlogn）

3.代码：

struct com {
    ll f;
    ll to;
    ll u;
    bool operator < (const com& b) const {
        if (f == b.f) return to > b.to;
        return f < b.f;
    }
};

ll t, n, a[200005], b[200005], sum[200005], c[200005], ans[200005], x[200005];
vector<com> lis;
 
int main() {
    cin >> t;
    while (t--) {
        cin >> n;
        c[0] = 0;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
            c[i] = 0;
            ans[i] = 0;
            x[i] = 0;
        }
        for (int i = 1; i <= n; i++) {
            cin >> b[i];
            sum[i] = sum[i - 1] + b[i];
        }
        for (int i = 1; i <= n; i++) {
            int l = i, r = n, mid = (l + r) >> 1;
            while (l < r) {
                mid = (l + r) >> 1;
                if (a[i] > sum[mid] - sum[i - 1]) {
                    l = mid + 1;
                }
                else r = mid;
            }
            mid = l;
            if (sum[mid] - sum[i - 1] > a[i]) {
                ans[mid] += a[i] - (sum[mid - 1] - sum[i - 1]);
                c[i - 1] += 1;
                c[mid - 1] -= 1;
            }
            else {
                c[i - 1] += 1;
                c[mid] -= 1;
            }
        }
        for (int i = 1; i <= n; i++) {
            x[i] = c[i - 1] + x[i - 1];
            ans[i] += x[i] * b[i];
            cout << ans[i] << " ";
        }
        cout << "\n";
    }
    
    return 0;
}

D. Triangle Coloring

1.题目内容

题目地址

2.个人思路：

其实题还挺简单的，卡了我半天的居然是 a == b == c这种谜之代码。
首先是染色的问题，每个三角内显而易见的最佳染色方式是1 + 2，这样子一定可以保证能得到三条边的两条（你也不可能同时获得三条），然后是获取这个三角形内的最大值和获得最大值的种类数，有四种情况，

三边相等，随便选，三种可能。
两边相等，第三边大于两边，最优是第三边+任意一边，两种可能。
两边相等，第三边小于于两边，最优是两个相等边，一种可能。
三边不等，一种可能。

获取了每个三角形内的可能性之后，考虑n个点选取n/2个来染一个红，另外n/2染一个蓝，所以还需要另外乘以C（n/2， n）。这个可以用逆元+快速幂处理。然后最终答案就出来了。

3.代码：

ll n, ans = 1, p = 998244353;
ll inf[300005], m1[300005];
ll arr[300005];

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

ll cal(int x, int y) {
    return (m1[x] * inf[y] % p) * inf[x - y] % p;
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> arr[i];
    }
    m1[0] = inf[0] = 1;
    for (int i = 1; i <= n / 3; i++) {
        m1[i] = m1[i - 1] * i % p;
        inf[i] = inf[i - 1] * qp(i, p - 2) % p;
    }

    for (int i = 1; i <= n / 3; i++) {
        int a = arr[i * 3], b = arr[i * 3 - 1], c = arr[i * 3 - 2];
        if (a == b && b == c) ans = (ans * 3) % p;
        else if (a == b && c > b) ans = (ans * 2) % p;
        else if (c == b && a > b) ans = (ans * 2) % p;
        else if (a == c && b > c) ans = (ans * 2) % p;
    }
    cout << (ans * cal(n / 3, n / 6)) % p;
    return 0;
}

E. Explosions?

场下写的，也许以后的以后某一天我能写出来五个题，也许吧。

1.题目内容

题目地址

2.个人思路：

~~还得是单调栈。~~
单调栈+dp
本题要求获取最少魔力量，首先，只要爆炸的魔力大于目标怪物，那么目标怪物以他为中心向左向右递减的所有怪物全部都会被轰炸。所以有两个结论

消耗轰炸中心的怪物血量无意义
普通魔法只需要用来让序列变成一个以目标为中心向两侧严格递减的序列即可。

然后分别获取两侧就是获取小于等于第i个怪物的hi - 距离的怪物坐标x和y，使用这里单调栈处理这个问题。
之所以要获取这两个数据，是因为x和y之间的数字可以直接算出来，而x，y之外的就不可以。需要用dp进行状态转移。

dp的转移方程是 dp[i] = dp[a] + [i, a]变成递减序列的代价，也就是求一个
max(arr[i] - i + a, 0)到 arr[i] 的和。
需要左右两边各进行一次。

然后最终的结果就是 arr[i] + dp[i]左侧 + dp[i]右侧。

3.代码：

ll t, n, arr[300005], sum[300005];
ll gui[300005][2], dp[300005][2];

ll cal(ll x) {
    return (x * (x + 1)) / 2;
}

int main() {
    cin >> t;
    while (t--) {
        cin >> n;
        ll ans = (ll)1e12;
        for (int i = 1; i <= n; i++) {
            cin >> arr[i];
            sum[i] = sum[i - 1] + arr[i];
            gui[i][1] = n + 1;
            dp[i][0] = dp[i][1] = 0;
            gui[i][0] = 0;
        }
        dp[n + 1][0] = dp[n + 1][1] = 0;
        stack<int> sin[2];
        for (int i = n; i > 0; i--) {
        //这里的两个取最大值是无效的
            while (!sin[0].empty() && (arr[i] <= max(arr[sin[0].top()] - (sin[0].top() - i), 0ll))) {
                gui[sin[0].top()][0] = i;
                sin[0].pop();
            }
            sin[0].push(i);
        }
        for (int i = 1; i <= n; i++) {
            while (!sin[1].empty() && (arr[i] <= max(arr[sin[1].top()] - (i - sin[1].top()), 0ll))) {
                gui[sin[1].top()][1] = i;
                sin[1].pop();
            }
            sin[1].push(i);
        }
        for (int i = 1; i <= n; i++) {
            int a = gui[i][0], j = n - i + 1, b = gui[j][1];
            dp[i][0] = dp[a][0] + (sum[i] - sum[a] - (cal(arr[i]) - cal(max(arr[i] - i + a, 0ll))));
            dp[j][1] = dp[b][1] + (sum[b - 1] - sum[j - 1] - (cal(arr[j]) - cal(max(arr[j] - b + j, 0ll))));
        }
        for (int i = 1; i <= n; i++) {
            ans = min(dp[i][0] + dp[i][1] + arr[i], ans);
        }
        cout << ans << "\n";
    }
    return 0;
}