蓝桥周赛题目分享

1. 四个亲戚

在字符串 后加上 即可，答案输出 。

#include 
 using namespace std;
 typedef long long ll;
 int main() {
 cout << "Daiyu'kind'" << '\n';
 return 0;
 }

2. 黛玉泡茶

解题思路 至少斟满 杯茶，为了让林黛玉尽可能的少跑几趟，我们贪心的选择容量最小的杯茶，之后算出杯茶的总容积

#include 
 using namespace std;
 typedef long long ll;
 int main() {
 int n, m, k;
 cin >> n >> m >> k;
 vector a(n);
 for (int i = 0; i < n; ++i) {
 cin >> a[i];
 }
 sort(a.begin(), a.end());
 ll s = 0;
 for (int i = 0; i < k; ++i) {
 s += a[i];
 }
     ll ans = (s - 1) / m + 1;
    cout << ans << endl;
    return 0;
 }

3. 宝玉请安

 #include
 using namespace std;
 void solve() {
    int x1, x2, x3;
    cin >> x1 >> x2 >> x3;
    if (x1 <= x2 && x1 <= x3) {
        cout << max(x2, x3) - x1 << endl;
    } else if (x1 >= x2 && x1 >= x3) {
        cout << x1 - min(x2, x3) << endl;
    } else {
        int y1 = abs(x1 - x2);
        int y2 = abs(x1 - x3);
        if (y1 > y2) {
            swap(y1, y2);
        }
        cout << y1 * 2 + y2 << endl;
    }
 }
 int main() {
    int t;
    cin >> t;
    for (int i = 0; i < t; ++i) {
        solve();
    }
    return 0;
 }

4. 贾母祝寿

因为我们只关心所有元素的绝对值的最大值，所以我们只需要考虑最终数组的最大值和最小值。对于每 个增量查询，第一个元素会受到影响；而对于每个减量查询，最后一个元素会受到影响。因此，第一个 元素将成为最大值，最后一个元素将成为最小值。 最后，我们只需考虑每个查询对第一个和最后一个元素的影响。需要注意的是，有一个特殊的查询会影 响数组中的所有元素，即 。 时间复杂度为 O(N)。

 #include 
 using namespace std;
 typedef long long ll;
 void solve() {
    int n, q;
    cin >> n >> q;
    ll a = 0, b = 0;
    for (int i = 0; i < q; ++i) {
        int t, x, y;
        cin >> t >> x >> y;
        if (t == 1) {
            a += y;
            if (x == n) {
                b += y;
            }
        } else {
            b -= y;
            if (x == n) {
                a -= y;
            }
        }
    }
    cout << max(abs(a), abs(b)) << '\n';
 }
 int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 1;
    while (t--) {
        solve();
    }
    return 0;
 }

5. 清洁客房

 #include
 #define F(i, a, b) for(int i = a ; i <= b ; i ++)
 #define int long long
 using namespace std;
 const int MAXN = 1E5 + 10, MOD = 1E9 + 7;
 int dp[MAXN][4];
 signed main() {
 std::ios::sync_with_stdio(false);
 std::cin.tie(nullptr);
 }
 dp[1][1] = 9;
 F (i, 2, 100000) {
 dp[i][1] = dp[i - 1][1];
 dp[i][2] = (dp[i - 1][1] * 9 % MOD + dp[i - 1][2] * 2 % MOD) % MOD;
 dp[i][3] = (dp[i - 1][2] * 8 % MOD + dp[i - 1][3] * 3 % MOD) % MOD;
 }
 int t; cin >> t;
 while (t --) {
 int n; cin >> n;
 cout << dp[n][3] << '\n';
 }
 return 0;

6. 宝玉与黛玉的考验

 #include 
 using namespace std;
 typedef long long ll;
 void solve() {
 int n, m, k;
 cin >> n >> m >> k;
 string s, t;
 cin >> s >> t;
 vector a(n), b(m);
 for (int i = 0; i < n; ++i) {
 a[i] = s[i] - '0';
 }
 for (int i = 0; i < m; ++i) {
 b[i] = t[i] - '0';
 }
 ll c = 0;
 ll mx = -1e9, mi = 1e9;
 for (int i = 0; i < n; ++i) {
 c += (a[i] == 0);
 if (i - k >= 0) {
 c -= (a[i - k] == 0);
 }
 if (i >= k - 1) {
 mx = max(c, mx);
 mi = min(c, mi);
 }
 }
 ll tg = 0, ans = 0;
for (int i = 0; i < m; ++i) {
        tg += (b[i] == 0);
        if (i - k >= 0) {
            tg -= (b[i - k] == 0);
        }
        if (i >= k - 1) {
            if (2 * tg > k) {
                ans = max(ans, 1LL * k * tg + 1LL * mi * (k - 2 * tg));
            } else {
                ans = max(ans, 1LL * k * tg + 1LL * mx * (k - 2 * tg));
            }
        }
    }
    cout << ans << '\n';
 }
 int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 1;
    while (t--) {
        solve();
    }
    return 0;
 }

7.小鸡变鸡腿

 #include
 #define F(i, a, b) for(int i = a ; i <= b ; i ++)
 #define int long long
 using namespace std;
 const int UP = 1E18;
 int calc(int n) {
 int res = 1, x = n;
 for (int i = 2; i * i <= n; i ++) {
 if (n % i == 0) {
 int cnt = 0;
 while (n % i == 0) {
 n /= i;
 cnt ++ ;
 }
 if (UP / (cnt * x + 1) <= res) return UP; 
res = res * (cnt * x + 1);
 }
 }
 if (n > 1) {
 if (UP / (x + 1) <= res) return UP;
 res = res * (x + 1);
 }
 return res;
 }
 signed main() {
 std::ios::sync_with_stdio(false);
 std::cin.tie(nullptr);
 sets;
 mapmp;
 int MA = -1;
 F (i, 1, 30030) { 
int cnt = calc(i);
 if (cnt > MA) {
 MA = cnt; s.insert(cnt);
 mp[cnt] = i;
 }
 }
int t; cin >> t;
 while (t --) {
 int K; cin >> K;
 auto n = s.lower_bound(K);
 cout << mp[*n] << '\n';    
}
 return 0;
 }

8.赏花宴

 #include 
 #define int long long
 using namespace std;
 const int N = 1e5 + 10;
 struct node{
 int k, id, ans;
 bool operator < (const node &x) const {
 
        if (k == x.k) return id < x.id;
        return k < x.k;
    }
 }Q[N];
 bool cmp(node a, node b) {
    return a.id < b.id;
 }
 int n, q, a[N];
 signed main() {
    cin >> n >> q;
    for (int i = 1 ; i <= n ; i ++) cin >> a[i];
    for (int i = 1 ; i <= q ; i ++) {
        cin >> Q[i].k;
        Q[i].id = i; // 记录原始询问顺序
    }
    sort(a + 1 , a + 1 + n); // 对已有的头饰编号排序
    sort(Q + 1, Q + 1 + q); // 对询问按照 k 值排序
    int pre = 0, j = 1, sum = 0; // pre 记录上一个已有的头饰编号，j 指向当前处理的询问，
sum 记录累计的缺失编号数量
    for (int i = 1 ; i <= n ; i ++) {
        int cha = a[i] - pre - 1; // 计算当前编号与上一个编号之间的缺失数量
        if (cha < 0) continue ; // 如果 cha < 0，说明当前编号小于等于上一个编号（可能是重
复的），直接跳过
        // 如果当前缺失的数量 cha 大于等于当前询问 k，则可以直接计算出答案
        if (Q[j].k <= cha) {
            Q[j].ans = pre + Q[j].k; // 计算答案
            Q[j].k = 0; // 标记该询问已处理
            j ++; // 处理下一个询问
            i --; // 因为当前编号 a[i] 还没有处理完，所以 i--，下次循环继续处理
            //Q[j].k -= sum; // 这行代码是多余的，因为 sum 还没更新，不需要减去
            continue ;
        }
        // 如果当前缺失的数量 cha 小于当前询问 k，则更新 k 和 sum
        Q[j].k -= cha; // 更新 k
        sum += cha; // 更新 sum
        pre = a[i]; // 更新 pre
    }
    // 处理剩余的询问，这些询问对应的丫鬟编号都大于最大的已知头饰编号
    if (Q[j].k > 0) Q[j].ans = pre + Q[j].k, j ++; // 处理第一个剩余的询问
    for (int i = j ; i <= q ; i ++) {
        Q[i].ans = pre + Q[i].k; // 处理剩余的询问。这里不需要减去 sum，因为 sum 只记录
到最后一个 a[i] 为止的缺失数量，而剩余的询问的编号都大于 a[n]
    }
    sort(Q + 1, Q + 1 + q, cmp); // 按照原始询问顺序排序
    for(int i = 1 ; i <= q ; i ++) cout << Q[i].ans << "\n";
    return 0;
 }

9.宝玉出行

 #include 
 using namespace std;
 typedef long long ll;
 template  struct LazySegmentTree {
    const int n;
    std::vector info;
    std::vector tag;
    LazySegmentTree(int n)
        : n(n), info(4 << (int)std::log2(n)), tag(4 << (int)std::log2(n)) {}
    LazySegmentTree(std::vector init) : LazySegmentTree(init.size()) {
        std::function build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void apply(int p, const Tag &v) {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        push(p);
        return rangeQuery(2 * p, l, m, x, y) +
               rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    void rangeApply(int p, int l, int r, int x, int y, const Tag &v) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        int m = (l + r) / 2;
        push(p);
        rangeApply(2 * p, l, m, x, y, v);
        rangeApply(2 * p + 1, m, r, x, y, v);
        pull(p);
    }
    void rangeApply(int l, int r, const Tag &v) {
        return rangeApply(1, 0, n, l, r, v);
    }
    template 
    int findFirst(int p, int l, int r, int x, int y, F pred) {
        if (l >= y || r <= x || !pred(info[p])) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int m = (l + r) / 2;
        push(p);
        int res = findFirst(2 * p, l, m, x, y, pred);
        if (res == -1) {
            res = findFirst(2 * p + 1, m, r, x, y, pred);
        }
        return res;
    }
    template  int findFirst(int l, int r, F pred) {
        return findFirst(1, 0, n, l, r, pred);
    }
 };
 struct Tag {
    ll add;
    Tag(int _rev = 0) : add{_rev} {}
    void apply(const Tag &t) {
        add += t.add;
    }
 };
 struct Info {
    int len;
    long long sum;
    long long mx;
    Info() : len(1), sum(0), mx(0) {}
    Info(long long v, int x) : len(x), sum(v), mx(v) {}
    void apply(const Tag &t) {
        sum += t.add * len;
        mx += t.add;
    }
 };
 Info operator+(const Info &a, const Info &b) {
    Info c;
    c.len = a.len + b.len;
    c.sum = a.sum + b.sum;
    c.mx = max(a.mx, b.mx);
    return c;
 }
 void solve() {
    int n, d;
    cin >> n >> d;
    string s;
    cin >> s;
    vector init(n);
    int c = 0;
    for (int i = 0; i < n; ++i) {
        c += (s[i] == '1');
        if (i >= d) {
            c -= (s[i - d] == '1');
        }
        init[i] = {c, 1};
    }
    LazySegmentTree seg(init);
    int q;
    cin >> q;
    while (q--) {
        int op, x;
        cin >> op >> x;
        if (op == 1) {
            x--;
            if (s[x] == '1') {
                int r = min(x + d - 1, n - 1);
                seg.rangeApply(x, r + 1, -1);
                s[x] = '0';
            } else {
                int r = min(x + d - 1, n - 1);
                seg.rangeApply(x, r + 1, 1);
                s[x] = '1';
            }
        } else {
            int mx = seg.rangeQuery(0, n).mx;
            if (mx <= x) {
                cout << -1 << '\n';
                continue;
            }
            auto pred = [&](const Info &node) {
                return node.mx > x;
            };
            int j = seg.findFirst(0, n, pred);
            cout << j + 1 << '\n';
        }
    }
 }
 int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    cout << setiosflags(ios::fixed) << setprecision(10);
    int t = 1;
    while (t--) {
        solve();
    }
    return 0;
 }