Codeforces Round #595 (Div. 3)【AK】【并查集、数学、dp、差分】

最新推荐文章于 2021-08-27 21:29:08 发布
最新推荐文章于 2021-08-27 21:29:08 发布
阅读量492 收藏
点赞数 1
分类专栏： 贪心 DP动态规划 Codeforces 文章标签： Codeforces 贪心 dp 数学 差分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41730082/article/details/102710496
版权
DP动态规划 同时被 3 个专栏收录
110 篇文章 0 订阅
订阅专栏
Codeforces
41 篇文章 0 订阅
订阅专栏
贪心
35 篇文章 0 订阅
订阅专栏

Codeforces Round #595 (Div. 3)

A. Yet Another Dividing into Teams

  手速题

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
int N, a[305], b[305];
int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &N);
        memset(b, 0, sizeof(b));
        for(int i=1; i<=N; i++)
        {
            scanf("%d", &a[i]);
            b[a[i]]++;
        }
        int ans = 1;
        for(int i=2; i<=100; i++) ans = max(ans, min(b[i], b[i-1]) + 1);
        printf("%d\n", ans);
    }
    return 0;
}

 

B. Books Exchange 

  其实问的就是每个环内的点的个数，岂不是带权并查集维护一下就可以了嘛。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e5 + 7;
int N, root[maxN], siz[maxN];
inline int fid(int x) { return x == root[x] ? x : root[x] = fid(root[x]); }
inline void init()
{
    for(int i=1; i<=N; i++) { root[i] = i; siz[i] = 1; }
}
int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &N);
        init();
        for(int i=1, v; i<=N; i++)
        {
            scanf("%d", &v);
            int fv = fid(v), fu = fid(i);
            if(fv != fu)
            {
                root[fv] = fu;
                siz[fu] += siz[fv];
            }
        }
        for(int i=1; i<=N; i++) printf("%d ", siz[fid(i)]);
        printf("\n");
    }
    return 0;
}

 

C. Good Numbers

  一个被3^{x}的和表示的数是一个good number，但是，每个3^{x}不能超过一个。那么，我们可以去看二进制的表示，很容易发现，我们可以把一个数那三进制表示，但是有的位可能为2个，这时候就是去给前一位+1，然后对后面的所有直接赋值为0即可。

  直接贪心。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
ll x;
int bit[75], top;
inline void solve()
{
    top = 0;
    while(x)
    {
        bit[++top] = x % 3;
        x /= 3;
    }
}
int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%lld", &x);
        memset(bit, 0, sizeof(bit));
        solve();
        if(bit[top] == 2)
        {
            top++;
            bit[top] = 1;
            for(int i=top-1; i>=0; i--) bit[i] = 0;
        }
        else
        {
            int i, j;
            for(i=top-1; i>=1; i--)
            {
                if(bit[i] == 2)
                {
                    bit[i+1]++;
                    for(j=i; j>=1; j--) bit[j] = 0;
                    break;
                }
            }
            for(int k=i+1; k<70; k++)
            {
                if(bit[k] >= 2)
                {
                    bit[k] = 0; bit[k+1]++;
                    if(k == top) top++;
                }
                else break;
            }
        }
        ll ans = 0, tmp = 1LL;
        for(int i=1; i<=top; i++)
        {
            if(bit[i]) ans += bit[i] * tmp;
            tmp = tmp * 3LL;
        }
        printf("%lld\n", ans);
    }
    return 0;
}

 

D. Too Many Segments

  手玩一下，很容易发现，如果我们对左区间升序，然后去看右区间，这时候会发现，我们应该贪心的选择右端点最远到达的，并且左区间还得包含目前的这个点的，那么我们可以去搜索一下。

  现在，D2，N很大，这时候我们肯定得要去优化一下暴力的解法，这里就可以用一下差分来降维了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e5 + 7;
int N, K;
struct node
{
    int r, id;
    node(int b=0, int c=0):r(b), id(c) {}
    friend bool operator < (node e1, node e2) { return e1.r < e2.r; }
};
vector<node> add[maxN], del[maxN];
//multiset<node> add[maxN], del[maxN];
multiset<node> now;
multiset<node>::iterator it;
vector<int> vt;
int main()
{
    scanf("%d%d", &N, &K);
    for(int i=1, l, r; i<=N; i++)
    {
        scanf("%d%d", &l, &r);
        add[l].push_back(node(r, i));
        del[r + 1].push_back(node(r, i));
    }
    for(int i=1; i<=200000; i++)
    {
        int len = (int)add[i].size();
        for(int j=0; j<len; j++) now.insert(add[i][j]);
        len = (int)del[i].size();
        for(int j=0; j<len; j++) now.erase(del[i][j]);
        len = (int)now.size();
        if(len > K)
        {
            int det = len - K;
            while(det)
            {
                it = now.end();
                vt.push_back((--it)->id);
                now.erase(it);
                det--;
            }
        }
    }
    int len = (int)vt.size();
    printf("%d\n", len);
    for(int i=0; i<len; i++) printf("%d ", vt[i]);
    printf("\n");
    return 0;
}

 

E. By Elevator or Stairs?

  DP，其实最短路也就可以了的。

二维DP，第二维的0表示直接走楼梯，第二维的1表示用了电梯，那么就是需要加上c了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e5 + 7;
int N, C;
ll dp[maxN][2], a[maxN], b[maxN];
int main()
{
    scanf("%d%d", &N, &C);
    memset(dp, INF, sizeof(dp));
    dp[1][1] = C;
    dp[1][0] = 0;
    for(int i=1; i<N; i++) scanf("%lld", &a[i]);
    for(int i=1; i<N; i++) scanf("%lld", &b[i]);
    for(int i=2; i<=N; i++)
    {
        dp[i][0] = min(dp[i-1][0], dp[i-1][1]) + a[i-1];
        dp[i][1] = min(dp[i-1][0] + C, dp[i-1][1]) + b[i-1];
    }
    for(int i=1; i<=N; i++) printf("%lld ", min(dp[i][0], dp[i][1]));
    printf("\n");
    return 0;
}

 

F. Maximum Weight Subset

  树形DP（好像有人用一些什么最大权值的独立集给过了，什么操作啊喂！QAQ？）

  题目要找这样的集合，集合内的每个点对相互之间的距离都大于K，并且求其最大的权值。

  其实也就是去求最大权值独立集。

  怎么搞呢？我们可以去处理每个点的向下的间隔，譬如说，我们的间隔为0，是不是代表了我们把目前的这个点给取了，所以开一个二维dp[ i ][ j ]，其中i表示的是结点的序号，j表示的是间隔，于是乎有dp[u][0] = a[u];

  画个图吧：

这时候，我们假设K为2，那么如果我取了1这个结点，是不是代表了是一定不可以取2、3两个结点的，然后以此类推。

  换个角度来看这个问题，我们现在假如要去取1号点，就代表了dp[1][0] = a[1]; 那么，我们还可以怎样的去表示1这号结点的贡献呢？dp[1][1] = dp[1][1] + max(dp[3][0], dp[7][0])，这个等式可以化简一下，dp[1][1] = dp[1][1] + max(dp[3][0], dp[3][1])，这里，“dp[3][1]”就是等同于“dp[7][0]”，因为代表了不去取3这个结点的a[3]，而是改为取7号结点的a[7]。

  所以嘛，在这里，如果我们访问到根为u的子树，dp[u][i]，以及子结点v，dp[v][j]，如果“i + j + 1 > K”就是说明这是我们可以取的结点了，这里的j是需要“+1”的，是因为深度要往上提1了。然后这时候就是去更新答案了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
int N, K, a[205], head[205], cnt, dp[205][205], ans[205];
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
}edge[505];
inline void addEddge(int u, int v)
{
    edge[cnt] = Eddge(head[u], v);
    head[u] = cnt++;
}
void dfs(int u, int fa)
{
    dp[u][0] = a[u];
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(v == fa) continue;
        dfs(v, u);
        memset(ans, 0, sizeof(ans));
        for(int x=0; x<=K+1; x++)
        {
            for(int y=0; y<=K+1; y++)
            {
                if(x + y >= K)
                {
                    ans[min(x, y + 1)] = max(ans[min(x, y + 1)], dp[u][x] + dp[v][y]);
                }
            }
        }
        for(int j=0; j<=K; j++) dp[u][j] = max(dp[u][j], ans[j]);
    }
    dp[u][0] = max(dp[u][0], dp[u][K + 1] + a[u]);
}
inline void init()
{
    for(int i=1; i<=N; i++) head[i] = -1;
    cnt = 0;
}
int main()
{
    scanf("%d%d", &N, &K);
    init();
    for(int i=1; i<=N; i++) scanf("%d", &a[i]);
    for(int i=1, u, v; i<N; i++)
    {
        scanf("%d%d", &u, &v);
        addEddge(u, v); addEddge(v, u);
    }
    dfs(1, 0);
    int ans = 0;
    for(int i=0; i<=K; i++) ans = max(ans, dp[1][i]);
    printf("%d\n", ans);
    return 0;
}

 

  The End

Rating changes for the last round are temporarily rolled back. They will be returned soon.

难得要涨超级多的分的说，什么时候才给我还回来啊！！！

Wuliwuliii
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #595 (Div. 3)
C_Dreamy的博客
07-11 213
Yet Another Dividing into Teams 给出 n 互不相同的数，如果 | a[i]-a[j] |==1,那么他们不能再同一组，问最少分几组 int n,m,t; int i,j,k; int a[101]; int main() { IOS; rush(){ cin>>n; for(i=1;i<=n;i++) cin>>a[i]; sort(a+..
Codeforces Round #595 (Div. 3)(A,B,C,D,E（dp））
ccsu_deer
10-23 646
B2. Books Exchange (hard version) 题目说，输入的是一个排列，那么每个数（1~n）都会出现，那么每个数都会出现在一个简单环中，bfs处理一下这些点在所在环的数量即可。。 #include<bits/stdc++.h> #define rep(i,a,b) for(int i=a;i<=(b);++i) #define mem(a,x) mem...
Codeforces Round #595 (Div. 3) - BenFromHRBUST
BenFromHRBUST的CSDN博客
02-10 131
Codeforces Round #595 (Div. 3) 比赛传送门 A - Yet Another Dividing into Teams Code #include <bits/stdc++.h> using namespace std; typedef long long ll; #define rep(i,a,b) for(int i=(a);i<=(b)...
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，只需要找度为222的点即可 如果一条边两个顶点的度都为222，我们可以用并查集判断两点是否在一个子图里 用并查集判断两...
codeforces round 962 (div. 3).docx
最新发布
07-29
Codeforces Round 962 (Div. 3) 是一场编程竞赛，其中包含了多个编程题目，每个题目都有其独特的挑战和解题思路。以下是对该竞赛中部分题目的简要介绍及解题思路概述： A题: Legs 题意： 一只鸡有2条腿，一头奶牛有...
Codeforces Round #595 (Div. 3) C. Good Numbers
solego’s blog
10-23 126
数学太差自闭了。 题意： 给一个数n，问你大于等于n的数中，可以拆分成3的幂之和的最小的数，其中每个幂最多出现一次 题解： 先将n分解成三进制，然后观察，当某位出现2的时候，我们需要从大于这位的幂开始寻找一位出现0次的幂，将其改成1，同时将小于这个幂出现次数被改成1的幂的出现次数全部改成0 如：，3^0这个幂出现次数为2，那么从该幂开始寻找一个幂出现次数为0，那么就是3^3将其换成1...
第六次训练：Codeforces Round #595 (Div. 3)
qq_45980336的博客
07-11 173
1.Codeforces Round #595 (Div. 3) C1 题意：给定一个数n，求一个不小于n的数，并且这个数能够表示为3的幂的和的形式，并且3每一次幂都只能出现一次。 　　先按幂从小到大顺序累加3的次方，当大于等于n时看能不能减去一些已经加上的3的幂，以得到最小的值。注意，需要从大往小减，以保证最小。（因为累加x的1、2、3、、、n次方会小于x的n+1次方） #include<iostream> #include<iomanip> #include<fstrea
Codeforces Round #595 (Div. 3) C2. Good Numbers (hard version)
旺崽的博客
10-23 3072
C2. Good Numbers (hard version) The only difference between easy and hard versions is the maximum value of n. You are given a positive integer number n. You really love good numbers so you want to fin...
Codeforces Round #595 (Div. 3) D题
不知所云的博客
10-23 361
Too Many Segments (hard version) The only difference between easy and hard versions is constraints. You are given n segments on the coordinate axis OX. Segments can intersect, lie inside each other an...
Codeforces Round #595 (Div. 3) 题解 C 3进制 E 简单dp
qq_40423146的博客
10-23 122
B2 n=2e5 dfs连通分量/并查集 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=1e6+5; #define rep(i,a,n) for(int i=a;i<=n;i++) ll q,n,x,to[maxn],vis[maxn],num[maxn]; v...
Codeforces Round #595 (Div. 3) E. By Elevator or Stairs?
冷漠然的博客
10-23 480
题意 n层楼，a[i] (0<i<n)表示从 i 楼到 i + 1 楼走楼梯的时间，b[i] (0<i<n)表示从 i 楼到 i + 1 楼乘电梯的时间，其中每一次乘电梯需要等待 k 时间，楼梯和电梯一次均可上从 x 楼上升到 y 楼 ( y != x )，即一次可以通过楼梯或电梯上升任意层数 。求从1楼到 1 ~ n 层楼所需要的最短时间 思路 dp题：二维数组dp[i]...
补题：Codeforces Round #595 (Div. 3)
小白菜的博客
01-24 124
比赛入口 D MEX maximizing 做法：题意是可以让数组里的一个数+x或者-x，找到最小的没有出现过的数字。做法就是…竟然是对x取模！用一个ans维护答案，如果当前ans%x没有出现过或者以前用完了，那么这时就输出ans，妙啊妙啊 代码： #include<bits/stdc++.h> #define fio ios::sync_with_stdio(false);cin.t...
Codeforces Round #595 (Div. 3) 题解
pursuit的博客
08-27 219
文章目录A. Yet Another Dividing into TeamsB1,B2. Books Exchange (easy and hard version)C1,C2.Good Numbers (easy and hard version)D1,D2. Too Many Segments (easy and hard version)E. By Elevator or Stairs?F. Maximum Weight Subset A. Yet Another Dividing into Team
codeforces round #828 (div. 3)
06-06
### 回答1： 好的，以下是关于Codeforces Round #828 (Div. 3)的一些信息： Codeforces Round #828 (Div. 3)是Codeforces网站上的一场编程竞赛，属于Div. 3级别的比赛。该比赛于2022年3月1日 15:35 (UTC)开始，比赛时长为2个小时。该比赛共包含7道题目，分值分别为500, 1000, 1500, 1750, 2000, 2250和2500。比赛时参赛者需要在规定时间内解决尽可能多的题目，并尽快提交正确答案。比赛结束后，Codeforces会根据参赛者的提交情况和答案正确性进行排名和评分。 参赛者需要在Codeforces网站上注册账号才能参加比赛，比赛期间可以使用任何编程语言来解决题目。此外，Codeforces还提供了实时排名和讨论区等功能，方便参赛者进行交流和比赛情况的了解。 祝愿所有参赛者在比赛中取得好成绩！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wuliwuliii

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值