Codeforces Round 933 (Div. 3)

A. Rudolf and the Ticket

思路：

• 按照题意，暴力枚举

时间复杂度：\(O(nm)\)

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;

    std::vector<int> a(n), b(m);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i];
    }
    for (int i = 0; i < m; i++) {
        std::cin >> b[i];
    }

    int ans = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (a[i] + b[j] <= k) {
                ans++;
            }
        }
    }
    std::cout << ans << "\n";
}

B. Rudolf and 121

思路：

• 每次对于一个元素的两边进行-1操作，对当前这个元素进行-2操作
• 这个操作可以转换一下，因为最终序列的值要让它都为0，那么我们可以直接从前往后线性枚举，每次对于第i位，直接减去a[i]，第i + 1位，直接减去2 * a[i]，对于i + 2位，减去a[i]，只要枚举过程中出现一个元素不为0，那么一定不行，因为它无法达到全部为0的状态

时间复杂度：\(O(n)\)

void solve() {
    int n;
    std::cin >> n;

    std::vector<int> a(n);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i];
    }

    for (int i = 0; i < n; i++) {
        if (a[i] < 0 || (i + 2 >= n && a[n - 1] != 0)) {
            std::cout << "NO\n";
            return ;
        }
        if (a[i] > 0) {
            a[i + 2] -= a[i];
            a[i + 1] -= 2 * a[i];
            a[i] = 0;
        }
    }
    std::cout << "YES\n";
}

C. Rudolf and the Ugly String

思路：

• 需要关注的字符串种类只可能有pie，map，mapie，其他样式的字符串，就算出现也对于答案没有影响
• 每当出现一个pie或者map，那么我们就需要删除一个字符，去破坏这个字符串，那么ans += 1
• 而当出现一个mapie的时候，只需要删除一个字符，但统计map和pie的时候多统计了一次，所以ans -= 1

时间复杂度：

void solve() {
    int n;
    std::cin >> n;

    std::string s;
    std::cin >> s;

    int ans = 0;
    for (int i = 0; i < n; i++) {
        if (i + 3 <= n && s.substr(i, 3) == "map") {
            ans++;
        }
        if (i + 3 <= n && s.substr(i, 3) == "pie") {
            ans++;
        }
        if (i + 5 <= n && s.substr(i, 5) == "mapie") {
            ans--;
        }
    }
    std::cout << ans << "\n";
}

D. Rudolf and the Ball Game

思路：

• 直接设状态 \(dp_{ij}\) 为经过第 \(i\) 轮后，\(j\) 的位置
• 最开始，\(c\) 不为 \(1\)，我们就顺时针走，当 \(c\) 不为 \(0\)，我们就逆时针走，然后每一轮走完就更新当前状态，最后输出那些点是可能的位置

时间复杂度：\(O(nm)\)

void solve() {
    int n, m, x;
    std::cin >> n >> m >> x;

    std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n));
    dp[0][x - 1] = true;
    for (int i = 1; i <= m; i++) {
        int r;
        char c;
        std::cin >> r >> c;
        if (c == '1') {
            for (int j = 0; j < n; j++) {
                dp[i][j] |= dp[i - 1][(j + r) % n];
            }
        } else if (c == '0') {
            for (int j = 0; j < n; j++) {
                dp[i][j] |= dp[i - 1][(j - r + n) % n];
            }
        } else {
            for (int j = 0; j < n; j++) {
                dp[i][j] |= dp[i - 1][(j + r) % n];
                dp[i][j] |= dp[i - 1][(j - r + n) % n];
            }
        }
    }
    int cnt = std::count(dp[m].begin(), dp[m].end(), 1);
    std::cout << cnt << "\n";
    for (int i = 1; i <= n; i++) {
        if (dp[m][i - 1]) {
            std::cout << i << " ";
        }
    }
    std::cout << "\n";
}

E. Rudolf and k Bridges

思路：

• 用 \(dp_{ij}\) 来统计每一行的满足条件的最小的和，这里满足条件就是求在一个长度小于等于 \(d\) 的区间里的最小值，然后 \(dp\) 一下，求在这个区间里的最小值之和。
• 然后用一个数组记录最小总和，最后暴力求连续的 \(k\) 行的最小和

时间复杂度：\(O(n^3)\)

constexpr i64 inf = 1LL << 60;

void solve() {
    int n, m, k, d;
    std::cin >> n >> m >> k >> d;

    std::vector<i64> w(n);
    for (int i = 0; i < n; i++) {
        std::vector<i64> a(m + 1), dp(m + 1);
        for (int j = 1; j <= m; j++) {
            std::cin >> a[j];
        }
        std::deque<int> q;
        q.push_back(1);
        dp[1] = 1;
        for (int j = 2; j <= m; j++) {
            while (q.size() && j - q.front() - 1 > d) q.pop_front();
            dp[j] = dp[q.front()] + a[j] + 1;
            while (q.size() && dp[j] <= dp[q.back()]) q.pop_back();
            q.push_back(j);
        }
        w[i] = dp[m];
    }
    i64 ans = inf;
    for (int i = 0; i + k - 1 < n; i++) {
        ans = std::min(ans, std::accumulate(w.begin() + i, w.begin() + k + i, 0LL));
    }
    std::cout << ans << "\n";
}