Educational Codeforces Round 112 (Rated for Div

Educational Codeforces Round 112 (Rated for Div. 2)

CodeForces - 1555D Say No to Palindromes

如果一个字符串中不包含长度2以上的回文子串，我们就说这个字符串是漂亮的，现在一个字符串只有a,b,c三个小写字母组成，每次操作可以修改任意一个字母为a,b,c,存在q次询问，每次询问给定区间\([l,r]\),你需要求出将这个区间子串变为漂亮字符串的最小操作数

题解：计数DP+思维（字符串循环节）

我们模拟后发现如果想要使得一个字符串漂亮，那么我们这个字符串的样子应该为：abcabcabc...那么这样的循环节一共有6种，我们只要对于每一种循环节求操作数即可，我们先预处理完后再回答询问即可

状态表示：\(f[i][j]\):对于第i个循环节，将字符串\([1,j]\)修改为漂亮字符串所需的操作数

状态属性：数量

状态转移：

1. 当前字符和循环节上的字符不一样 \(str[i]!=s[i][pos]\),\(f[i][j] = f[i][j-1]+1\)
2. 当前字符和循环节上的字符相同\(str[i]==s[i][pos]\),\(f[i][j] = f[i][j-1]\)

那么对于\([l,r]\)之间的最小操作数，我们只能选择一种循环节将它变成漂亮字符串，那么答案就是\(\sum _{i=1}^{6} {min(f[i][r]-f[i][l-1])}\)

#include <bits/stdc++.h>
#define Zeoy std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0)
#define debug(x) cerr << #x << '=' << x << endl
#define all(x) (x).begin(), (x).end()
#define rson id << 1 | 1
#define lson id << 1
#define int long long
#define mpk make_pair
#define endl '\n'
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int N = 2e5 + 10, M = 4e5 + 10;

string s[6] = {"#abc", "#acb", "#bac", "#bca", "#cab", "#cba"};
int f[6][N];
int n, q;

void solve()
{
    cin >> n >> q;
    string str;
    cin >> str;
    str = " " + str;
    for (int i = 0; i < 6; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            int pos = j % 3;
            if (pos == 0)
                pos = 3;
            if (str[j] != s[i][pos])
                f[i][j] = f[i][j - 1] + 1;
            else
                f[i][j] = f[i][j - 1];
        }
    }
    while (q--)
    {
        int l, r;
        cin >> l >> r;
        int ans = INF;
        for (int i = 0; i < 6; ++i)
            ans = min(ans, f[i][r] - f[i][l - 1]);
        cout << ans << endl;
    }
}
signed main(void)
{
    Zeoy;
    int T = 1;
    // cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}

CodeForces - 1555E Boring Segments

给定\(n\)个区间\([l,r]\)，每个区间都有权值\(w\),又给定\(m\)，求如果若干个区间能够覆盖\([1,m]\),那么成本就是这些区间中的最大权值和最小权值之差，现在保证一定能有区间能够覆盖\([1,m]\),求出覆盖\([1,m]\)成本的最小值

题解：双指针+线段树维护区间覆盖问题+贪心 ： 好题目

1. 我们先来说一说怎么快速计算出成本，并且能够在\(O(n)\)时间内遍历完所有能够覆盖[1,m]的若干线段

我们将区间按照权值升序排列，那么如果\([i,j]\)之间的区间能够覆盖[1,m]，那么它的成本就是\(w_j-w_i\)

我们往往可以使用双指针来解决极值问题，那么在这个问题中，我们发现随着\(j\)指针的后移，\(i\)指针存在单调性，所以我们可以使用双指针来解决问题

1. 那么我们如何检查现在覆盖的区间是否覆盖\([1,m]\)，我们可以利用线段树维护区间最小值，对于每一个区间\([l,r]\)进行区间加1，如果[1,m]区间中的最小值<1,那就说明区间[1,m]没有被覆盖到，否则说明已经覆盖完了，所以我们只需要在进行双指针时进行区间修改即可，然后我们每次只要检查\(seg[1].val.minn\)即可

2. 我们需要注意，在本题中，例如：[1,5],[6,m]这样是不算覆盖m的，只有区间重合才算，所以我们为了解决这个问题，对于[l,r]我们可以在每次修改的时候只修改\([l,r-1]\),那么最后我们建树建立的区间只需要建立\([1,m-1]\)即可

#include <bits/stdc++.h>
#define Zeoy std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0)
#define debug(x) cerr << #x << '=' << x << endl
#define all(x) (x).begin(), (x).end()
#define rson id << 1 | 1
#define lson id << 1
#define int long long
#define mpk make_pair
#define endl '\n'
using namespace std;
typedef unsigned long long ULL;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int N = 3e5 + 10, M = 1e6 + 10;

int n, m;
struct info
{
    int minn;
};
struct node
{
    int l, r, lazy;
    info val;
} seg[M << 2];

info operator+(const info &a, const info &b)
{
    info c;
    c.minn = min(a.minn, b.minn);
    return c;
}

void settag(int id, int tag)
{
    seg[id].val.minn += tag;
    seg[id].lazy += tag;
}

void up(int id)
{
    seg[id].val = seg[lson].val + seg[rson].val;
}

void down(int id)
{
    if (seg[id].lazy == 0)
        return;
    settag(lson, seg[id].lazy);
    settag(rson, seg[id].lazy);
    seg[id].lazy = 0;
}

void build(int id, int l, int r)
{
    seg[id].l = l, seg[id].r = r;
    int mid = l + r >> 1;
    if (l == r)
    {
        seg[id].val.minn = 0;
        return;
    }
    build(lson, l, mid);
    build(rson, mid + 1, r);
    up(id);
}

void modify(int id, int ql, int qr, int val)
{
    int l = seg[id].l, r = seg[id].r;
    if (ql <= l && r <= qr)
    {
        settag(id, val);
        return;
    }
    down(id);
    int mid = (l + r) >> 1;
    if (qr <= mid)
        modify(lson, ql, qr, val);
    else if (ql > mid)
        modify(rson, ql, qr, val);
    else
    {
        modify(lson, ql, qr, val);
        modify(rson, ql, qr, val);
    }
    up(id);
}

struct range
{
    int l, r, w;
    bool operator<(const range &t) const
    {
        return w < t.w;
    }
} a[N];

void solve()
{
    cin >> n >> m;
    build(1, 1, m - 1);
    for (int i = 1; i <= n; ++i)
        cin >> a[i].l >> a[i].r >> a[i].w;
    sort(a + 1, a + n + 1);
    int ans = INF;
    for (int i = 1, j = 1; j <= n; ++j)
    {
        modify(1, a[j].l, a[j].r - 1, 1);
        while (i <= j && seg[1].val.minn > 0)
        {
            ans = min(ans, a[j].w - a[i].w);
            modify(1, a[i].l, a[i].r - 1, -1);
            i++;
        }
    }
    cout << ans << endl;
}
signed main(void)
{
    Zeoy;
    int T = 1;
    // cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}