Codeforces Educational Codeforces Round 67

時間  2019-12-12
標籤 codeforces educational 简体版
原文   原文鏈接

目錄node

Contest Info

Data：2019.6.30
Solved：4/7c++

Solutions

A. Stickers and Toys

題意：
有\(A\)物品\(s\)個，\(B\)物品\(t\)個，如今將這些物品裝到\(n\)個箱子裏，每一個箱子只有一下三種狀況：數組

  • 只有一個\(A\)物品
  • 只有一個\(B\)物品
  • 有一個\(A\)物品和一個\(B\)物品

如今問你，至少要取多少個箱子，可以保證你最少有一個\(A\)物品和一個\(B\)物品。ui

思路：
根據鴿籠原理，顯然對於\(A\)物品，至少取\(n - s + 1\)個箱子就能夠有一個\(A\)物品。
同理，對於\(B\)物品至少要取\(n - t + 1\)個箱子。
答案就是\(Min(n - s +1, n - t + 1)\)spa

代碼：code

#include <bits/stdc++.h>
using namespace std;
 
int main() {
    int n, s, t;
    int T; scanf("%d", &T);
    while (T--) {
        scanf("%d%d%d", &n, &s, &t);
        int res = max(n - s + 1, n - t + 1);
        printf("%d\n", res);
    }
    return 0;
}

B. Letters Shop

題意：
有一個字符串\(s\)，每次詢問一個字符串\(t\)，問最短的一個\(s\)的前綴使得這個前綴中擁有的字符能夠組成字符串\(t\)。排序

思路一：
能夠維護一個字符個數的前綴和，而後二分。遊戲

代碼一：內存

#include <bits/stdc++.h>
using namespace std;
 
#define N 200010
int n, m, lens, lent;
char s[N], t[N];
int sum[N][27];
int cnt[27];
 
bool ok(int x) {
    for (int i = 0; i < 26; ++i) {
        if (sum[x][i] < cnt[i]) {
            return 0;
        }
    }
    return 1;
}
 
int main() {
    while (scanf("%d", &n) != EOF) {
        memset(sum, 0, sizeof sum);
        scanf("%s", s + 1); lens = strlen(s + 1);
        for (int i = 1; i <= lens; ++i) {
            ++sum[i][s[i] - 'a'];
            for (int j = 0; j < 26; ++j) {
                sum[i][j] += sum[i - 1][j];
            }
        }
        scanf("%d", &m);
        while (m--) {
            scanf("%s", t + 1);  lent = strlen(t + 1);
            memset(cnt, 0, sizeof cnt);
            for (int i = 1; i <= lent; ++i) {
                ++cnt[t[i] - 'a'];
            }
            int l = 1, r = n, res = -1;
            while (r - l >= 0) {
                int mid = (l + r) >> 1;
                if (ok(mid)) {
                    r = mid - 1;
                    res = mid;
                } else {
                    l = mid + 1;
                }
            }
            printf("%d\n", res);
        }
    }
    return 0;
}

思路二：
維護\(s\)串中某類字符的第\(i\)個所在位置，顯然對於\(t\)串中的每類字符有\(x\)個的話，\(s\)串前綴的長度要大於等於這類字符第\(x\)個所在的位置。字符串

代碼二：

#include <bits/stdc++.h>
using namespace std;
 
#define N 200010
int n, m, lens, lent;
char s[N], t[N];
int sum[N][27];
int cnt[27];
 
bool ok(int x) {
    for (int i = 0; i < 26; ++i) {
        if (sum[x][i] < cnt[i]) {
            return 0;
        }
    }
    return 1;
}
 
int main() {
    while (scanf("%d", &n) != EOF) {
        memset(sum, 0, sizeof sum);
        scanf("%s", s + 1); lens = strlen(s + 1);
        for (int i = 1; i <= lens; ++i) {
            ++sum[i][s[i] - 'a'];
            for (int j = 0; j < 26; ++j) {
                sum[i][j] += sum[i - 1][j];
            }
        }
        scanf("%d", &m);
        while (m--) {
            scanf("%s", t + 1);  lent = strlen(t + 1);
            memset(cnt, 0, sizeof cnt);
            for (int i = 1; i <= lent; ++i) {
                ++cnt[t[i] - 'a'];
            }
            int l = 1, r = n, res = -1;
            while (r - l >= 0) {
                int mid = (l + r) >> 1;
                if (ok(mid)) {
                    r = mid - 1;
                    res = mid;
                } else {
                    l = mid + 1;
                }
            }
            printf("%d\n", res);
        }
    }
    return 0;
}

C. Vasya And Array

題意：
要求構造一個數列\(a_1, \cdots, a_n\)，使得知足\(m\)個限制。
限制有兩種類型：

  • 1 l r 表示\([l, r]\)範圍內的數是非降序的
  • 0 l r 表示\([l, r]\)範圍內的數不是非降序的

給出構造結果，或者輸出‘NO’表示不存在這樣的數列。

思路：
顯然非降序的\([l, r]\)，咱們能夠全都賦爲\(1\)，可是最後一位能夠不用賦爲\(1\)。
而後將沒有賦爲\(1\)的地方降序賦值。
再考慮不是非降序的，只要知足這個區間內存在一個\(i\)知足\(a_i > a_{i + 1}\)便可。
只要check一下這些限制的區間內是否有這樣一對便可。
不然輸出'NO'

由於沒考慮這樣的對在最後一位的狀況被HACK了。

代碼：

#include <bits/stdc++.h>
using namespace std;
 
#define N 1010
int n, m;
int s[N];
struct node {
    int t, l, r;
    node() {}
    void scan() {
        scanf("%d%d%d", &t, &l, &r);
    }
}a[N];
 
bool ok(int l, int r) {
    for (int i = l; i <= r; ++i) {
        if (s[i] == 0) {
            return 1;
        }
    }
    return 0;
}
 
bool check(node a) {
    if (a.t == 1) {
        for (int i = a.l + 1; i <= a.r; ++i) {
            if (s[i - 1] > s[i]) {
                return 0;
            }
        }
        return 1;
    } else {
        for (int i = a.l + 1; i <= a.r; ++i) {
            if (s[i - 1] > s[i]) {
                return 1;
            }
        }
        return 0;
    }
}
 
void work() {
    memset(s, 0, sizeof s);
    for (int i = 1; i <= m; ++i) {
        if (a[i].t == 1) {
            ++s[a[i].l];
            --s[a[i].r];
        }
    }
    for (int i = 1; i <= n; ++i) s[i] += s[i - 1];
    for (int i = 1; i <= n; ++i) {
        if (s[i]) s[i] = 1;
    }
    for (int i = 1; i <= m; ++i) {
        if (a[i].t == 0) {
            if (!ok(a[i].l, a[i].r)) {
                puts("NO");
                return;
            }
        }
    }
    int cnt = n;
    for (int i = 1; i <= n; ++i) {
        if (s[i] == 0) {
            s[i] = cnt;
            --cnt;
        }
    }
    for (int i = 1; i <= m; ++i) {
        if (!check(a[i])) {
            puts("NO");
            return;
        }
    }
    puts("YES");
    for (int i = 1; i <= n; ++i) printf("%d%c", s[i], " \n"[i == n]);
}
 
int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        for (int i = 1; i <= m; ++i) {
            a[i].scan();
        }   
        work();
    }
    return 0;
}

D. Subarray Sorting

題意：
給出兩個數組\(a_1, \cdots, a_n\), \(b_1, \cdots, b_n\)，能夠將\(a\)數組進行不限次數的區間排序，問可以變成\(b\)數組。

思路：
考慮從左往右移動\(a\)中的數使得知足\(a_i = b_i\), 咱們發現對於咱們須要的\(a_i\)，它能移動過來當且僅當它以前不存在比它小的數，
權值線段樹維護一下便可。

代碼:

#include <bits/stdc++.h>
using namespace std;
 
#define N 300010
int n, a[N], b[N];
int cnt[N], nx[N], f[N];
 
struct SEG {
    int a[N << 2];
    void build(int id, int l, int r) {
        a[id] = 1e9;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
    }
    void update(int id, int l, int r, int pos, int x) {
        if (l == r) {
            a[id] = x;
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(id << 1, l, mid, pos, x);
        else update(id << 1 | 1, mid + 1, r, pos, x);
        a[id] = min(a[id << 1], a[id << 1 | 1]);
    }
    int query(int id, int l, int r, int ql, int qr) {
        if (ql > qr) return 1e9;
        if (l >= ql && r <= qr) {
            return a[id];
        }
        int mid = (l + r) >> 1;
        int res = 1e9;
        if (ql <= mid) res = min(res, query(id << 1, l, mid, ql, qr));
        if (qr > mid) res = min(res, query(id << 1 | 1, mid + 1, r, ql, qr));
        return res;
    }
}seg;
 
bool work() {
    for (int i = 1; i <= n; ++i) {
        cnt[i] = 0;
    }
    for (int i = 1; i <= n; ++i) {
        ++cnt[a[i]];
        --cnt[b[i]];
    }
    for (int i = 1; i <= n; ++i) {
        if (cnt[i] != 0) {
            return 0;
        }
    }
    seg.build(1, 1, n);
    for (int i = n; i >= 1; --i) {
        nx[i] = n + 1;
    }
    for (int i = n; i >= 1; --i) {
        f[i] = nx[a[i]];
        nx[a[i]] = i;
    }
//  for (int i = 1; i <= n; ++i) {
//      printf("%d %d\n", i, nx[i]);
//  }
    for (int i = 1; i <= n; ++i) {
        seg.update(1, 1, n, i, nx[i]);
    }
    for (int i = 1; i <= n; ++i) {
        if (seg.query(1, 1, n, 1, b[i] - 1) < nx[b[i]]) return 0;
        nx[b[i]] = f[nx[b[i]]];
        seg.update(1, 1, n, b[i], nx[b[i]]);
    }
    return 1;
}
 
int main() {
    int T; scanf("%d", &T);
    while (T--) {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i) {
            scanf("%d", a + i);
        }
        for (int i = 1; i <= n; ++i) {
            scanf("%d", b + i);
        }
        puts(work() ? "YES" : "NO");
    }
    return 0;
}

E. Tree Painting

題意：
有一種樹上游戲，剛開始每一個點爲黑點，第一次能夠先選擇一個點染白，以後每一次均可以選擇一個與白點相鄰的黑點將其染白，得到的分數爲這個黑點所在的由黑點構成的連通塊大小。
問在最優策略下得到的最大分數是多少？

思路：
考慮到根固定的話，選擇的固定的，即每次從根往下取，而不是隔層取。
樹形DP便可。

代碼：

#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
#define N 200010
int n;
vector <vector<int>> G;
int fa[N], sze[N];
ll f[N], g[N], res; 
void DFS(int u) {
    sze[u] = 1;
    f[u] = 0;
    for (auto v : G[u]) if (v != fa[u]) {
        fa[v] = u;
        DFS(v);
        sze[u] += sze[v];
        f[u] += f[v];
    }
    f[u] += sze[u]; 
}
 
void DFS2(int u) {
    if (u == 1) {
        g[u] = 0;
    } else {
        g[u] = g[fa[u]] + f[fa[u]] - f[u] - sze[u] + n - sze[fa[u]];   
        res = max(res, f[u] + g[u] - sze[u] + n);
    }
    for (auto v : G[u]) if (v != fa[u]) {
        DFS2(v);
    }
}
 
int main() {
    while (scanf("%d", &n) != EOF) {
        G.clear(); G.resize(n + 1);
        for (int i = 1, u, v; i < n; ++i) {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        DFS(1);
        res = f[1];
        DFS2(1);
        printf("%lld\n", res);
    }
    return 0;
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程