Codeforces Round #715 (Div. 2) CDEF

C. The Sports Festival DP

题目大意：

给你一个序列 \(s\) ，你可以重新排列这个序列，成为一个新序列 \(a\) 。设 \(d_i=max(a_1,..,a_i)-min(a_1,...,a_i)\) ，求最小的 \(d_1+d_2+...+d_n\)

题解：

倒过来想，就是对于一个已经排好的序列，每次选择删掉最大值还是最小值，因为删掉中间的值是不会有影响的。

定义 \(dp[i][j]\) 表示从 \(i\) 到 \(j\) 的最小的值。

然后转移每次只能从 \(dp[i+1][j]\) 转移过来，或者从 \(dp[i][j-1]\) 转移过来。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
typedef long long ll;
ll dp[maxn][maxn],a[maxn];

int main(){
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
    sort(a+1,a+1+n);
    memset(dp,0x3f,sizeof(dp));
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==1) dp[j][j] = 0;
            else dp[j][i+j-1] = min(dp[j+1][i+j-1],dp[j][i+j-2]) + a[i+j-1]-a[j];
        }
    }
    printf("%lld\n",dp[1][n]);
}

D Binary Literature 思维

题目大意：

给你三个长度为 \(2n\) 的 \(01\) 串，让你构造一个长度为 \(3n\) 的 \(01\) 串，并且这个 \(01\) 必须包含这三个 \(01\) 串中至少 2 个作为它的子序列。看样例理解。

题解：

因为长度都为 \(2n\) 的 \(01\) 串，所以要么 \(0\) 的数量大于等于 \(1\) 的数量，要么 \(1\) 的数量大于 \(0\) 的数量，三个串分成两类，所以至少存在两个串属于同一类。

假设：\(A\) 串和 \(B\) 串都是 \(0\) 的数量大于等于 \(1\) 的数量，那么显而易见就是：

\(B\) 开头的 1 全部放入答案，然后找到第一个是 0 的位置存下来
接下来就把 \(A\) 顺序放入答案，如果第 \(i\) 个位置是 0，那么同时 \(B\) 也可以往后移动一格
如果 \(B\) 往后移动到的这个位置是 \(1\) ，那么把 \(B\) 的这一段连续的 1 全部放入答案。
重复2 3 操作

#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int s[3][maxn],ans[maxn],n,num[3];
/*
011001
111010

100110
000101
 */
void solve(int x,int y,int f) {
    int now = 0, pos = 1;
    while (pos <= 2 * n && s[y][pos] == 1) ans[++now] = 1, pos++;
    for (int j = 1; j <= 2 * n; j++) {
        ans[++now] = s[x][j];
        if (s[x][j] == 0) {
            if (pos <= 2 * n) pos++;
            while (s[y][pos] == 1 && pos <= 2 * n) ans[++now] = 1, pos++;
        }
    }
    while (now <= 3 * n) ans[++now] = 0;
    if (f) {
        for (int i = 1; i <= 3 * n; i++) ans[i] ^= 1;
    }
}
bool check(int x,int y){
    if(num[x]>=n&&num[y]>=n) {
        for(int i=1;i<=2*n;i++){
            s[x][i] ^=1;
            s[y][i] ^=1;
        }
        if(num[x]<num[y]) swap(x,y);
        solve(x,y,1);
        return true;
    }
    else if(num[x]<=n&&num[y]<=n){
        if(num[x]>num[y]) swap(x,y);
        solve(x,y,0);
        return true;
    }
    return false;
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        for(int i=0;i<=2;i++){
            num[i] = 0;
            for(int j=1;j<=2*n;j++){
                scanf("%1d",&s[i][j]);
                num[i] += s[i][j];
            }
        }
        bool flag = true;
        for(int i=0;i<=2&&flag;i++){
            for(int j=i+1;j<=2&&flag;j++){
                if(check(i,j)) {
                    flag = false;
                }
            }
        }
        for(int i=1;i<=3*n;i++) printf("%d",ans[i]);
        printf("\n");
    }
}

E Almost Sorted 思维

题目大意：

给你一个排列，定义一个近乎顺序的序列， \(a_{i+1}\geq a_i-1\) 。求这个排列的第 \(k\) 大的近乎顺序排列。

题解：

这个题目其实不是很难，首先你要写一下这个排列，观察这个排列的性质：

以 \(n = 6\) 为例：

1) 1 2 3 4 5 6
2) 1 2 3 4 6 5
3) 1 2 3 5 4 6
4) 1 2 3 6 5 4
5) 1 2 4 3 5 6
6) 1 2 4 3 6 5
7) 1 2 5 4 3 6
8) 1 2 6 5 4 3
9) 1 3 2 4 5 6
10)1 3 2 4 5 6
11)1 3 2 5 4 6
12)1 3 2 6 5 4
13)1 4 3 2 5 6
14)1 4 3 2 6 5
15)1 5 4 3 2 6
16)1 6 5 4 3 2
...

观察这个序列，容易发现：第一个是1 的有 16个，在第一个是1 的情况下第二个是2的有8个，依此类推，容易发现：如果 \(k<=16\) ，那么 \(ans[1] = 1\) ，\(k<=8\) ，那么 \(ans[2]=2\)
对上面的式子总结，可以发现，\(k<2^{n - i - 1}\) ，\(ans[i] = i\)
继续观察，如果 \(n = 6,k = 6\) ，那么：\(ans[1] = 1,ans[2] = 2\) ，然后不确定 \(ans[3]\) ，枚举这个位置是多少，如果是 4 ，那么3 一定紧接着4，但是5 和 6 是没有约束的，所以此时的种类就是 \(2^{n - 4 - 1}\) ，如果之前的一个基数 \(res\)（此时也就是当 \(ans[3] = 3\) ，\(res = 4\)）是小于 k，并且 \(res + 2^{n- 4 - 1}\leq k\) ，那么说明 \(ans[3] = 4,ans[4] = 3\) ，然后再去判断 \(ans[5],ans[6]\)

差不多就是上述的思路，写起来注意一下细节即可。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
typedef long long ll;
int ans[maxn];
ll f[110];

int main() {
    f[0] = 1;
    for (int i = 1; i <= 61; i++) f[i] = f[i - 1] * 2;
    int T;
    scanf("%d",&T);
    while(T--){
        ll n, k;
        scanf("%lld%lld", &n, &k);
        int pos = -1;
        for (int i = 1; i < n; i++) {
            if (n - i - 1 >= 61) continue;
            if (f[n - i - 1] < k) {
                pos = i;
                break;
            }
        }
        if(n - 1<=60 && f[n-1]<k) {
            printf("-1\n");
            continue;
        }
        if (pos == -1) {
            for (int i = 1; i <= n; i++) ans[i] = i;
        } else {
            ll res = 0;
            for (int i = 1; i < pos; i++) ans[i] = i;
            while (pos <= n) {
                for (int i = pos; i <= n; i++) {
                    ll tmp = 1;
                    if (n - i - 1 >= 0) tmp = f[n - i - 1];
                    if (res < k && res + tmp >= k) {
                        int x = pos;
                        for (int j = i; j >= x; j--) ans[pos++] = j;
                        break;
                    } else res += tmp;
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            printf("%d",ans[i]);
            if(i==n) printf("\n");
            else printf(" ");
        }
    }
}

F. Complete the MST 思维

题目大意：

你有一张完全图，给了你一部分边 \((u,v,w)\) ，要求你把剩下的边的权值赋值，使得这个完全图的所有边的权值异或为 \(0\) ，定义这棵树的丑陋程度为这棵树的最小生成树的所有边的权值之和，求这棵树最小的丑陋程度是多少？

题解：

很容易发现，最后的边只有一条等于存在的边的异或值，剩下都是 \(0\)
用一个 \(set\) 存下 \([1,n]\) 所有的点，然后每次取出一个点 \(x\)，然后枚举每一个在 \(set\) 里面的点 \(y\)，如果与里面的点有边相连，则把这条边存下来，如果没有，则说明说明可以连一条权值为 0 的边，那么直接将这个点从 \(set\) 里面拿出来，放入这棵树中
最后再判断存下的边，还需要多少条才能构建这棵树
假设上述操作构建了 \(x\) 棵树，那么接下来还需要 \(x - 1\) 条边。
所以如果 \(n*(n-1)/2 - m > (n - 1) - (x - 1)\) ，那么就说明之前使用权值为 0 这条边构建的树是可以。
接下来要让 \(x\) 棵树变成1棵，已经是不能使用权值为0的了，因为遍历完所有的点之后，无法使用权值权值为 0 的边让他们连接起来，就说明已经是这些点只能用有权值的边相连。
然后求出 \(x\) 个点的最小生成树即可。
最后如果 \(n*(n - 1)/2 - m \leq (n - 1) - (x - 1)\) ，那么就必须让一条权值为 0 的边变成 \(cur\) (\(cur\) 为给定的所有的边的权值的异或和) ，但是可能之后选择的边会更优，所以要进行比对。
怎么比对呢？首先我们要明白比对什么？因为前面权值为0的边应该要有一个替换为 \(cur\) ，但是可能这条边不替换成 \(cur\) 而是替换成之后已有的连边可能更优。所以我们是要比对每一条0边是把这个长度换成 \(cur\) 更优还是等价替换成之后已经给出来的边更优。
那这样怎么写呢？我只需要看是否存在一条权值 \(w\) 小于 \(cur\) 的边，使得两个由 \(0\) 边连接起来的点连通即可，找到最小的 \(w\) 即可。
因为第 \(7\) 步是使用的给定的边合并出来的，所以要把这些边排除。
单独使用一个并查集只将第 \(7\) 步并起来的点合并，然后遍历给定的边，判断是否存在两个点使得两个不在同一棵树的两个点合并。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
typedef long long ll;
struct node{
    int u,v;
    long long w;
    node(int u=0,int v=0,long long w=0):u(u),v(v),w(w){}
}e[maxn];
bool cmp(node a,node b) {
    return a.w < b.w;
}
set<int>st;
int fa[maxn],ah[maxn];
queue<int>que;
map<int,int>mp[maxn];
void bfs(int x) {
    while (!que.empty()) que.pop();
    que.push(x), st.erase(x);
    while (!que.empty()) {
        int u = que.front();
        que.pop();
        vector<int> rm;
        for (auto now:st) {
            if (!mp[u].count(now)) {
                rm.push_back(now);
                fa[now] = x;
                que.push(now);
            }
        }
        for (auto now:rm) st.erase(now);
    }
}
int findx(int x) {
    return x == fa[x] ? x : fa[x] = findx(fa[x]);
}
int findah(int x) {
    return x == ah[x] ? x : ah[x] = findah(ah[x]);
}
bool Unite(int x,int y) {
    x = findx(x), y = findx(y);
    if (x == y) return false;
    fa[x] = y;
    return true;
}
int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        e[i] = node(u, v, w);
        mp[u][v] = 1, mp[v][u] = 1;
    }
    int cnt_tree = 0;
    for (int i = 1; i <= n; i++) st.insert(i), fa[i] = i, ah[i] = i;
    for (int i = 1; i <= n; i++) {
        if (fa[i] == i) {
            ++cnt_tree;
            bfs(i);
        }
    }
    sort(e + 1, e + 1 + m, cmp);
    ll res = 0, cur = 0;
    for (int i = 1; i <= m; i++) cur ^= e[i].w;
    for (int i = 1; i <= m; i++) {
        int u = e[i].u, v = e[i].v, w = e[i].w;
        if (Unite(u, v)) {
            res += w;
            u = findah(u), v = findah(v);
            if (u != v) ah[u] = v;
        }
    }
//    printf("!!! res = %lld cnt = %d\n",res,cnt_tree);
    if (1ll * n * (n - 1) / 2 - m > (n - 1) - (cnt_tree - 1)) printf("%lld\n", res);
    else {
        for (int i = 1; i <= m; i++) {
            int u = e[i].u, v = e[i].v, w = e[i].w;
            int fu = findah(u), fv = findah(v);
            if (fu != fv) cur = min(cur, 1ll * w);
        }
        res += cur;
        printf("%lld\n", res);
    }
}

posted @ 2021-04-18 21:41 EchoZQN 阅读(67) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

EchoZQN

Codeforces Round #715 (Div. 2) CDEF