Codeforces Round 813 (Div. 2) （D：二分+贪心E1容斥 E2树状数组）

最新推荐文章于 2024-08-18 12:51:45 发布
最新推荐文章于 2024-08-18 12:51:45 发布
阅读量367 收藏 7
点赞数 11
文章标签： codeforce 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61657632/article/details/136718590
版权
文章讨论了四个C++编程题目，涉及数组操作（排序、查找特定值的位置）、数论（相邻数互质、LCM），以及优化问题（如最小值调整、最大值路径、容斥原理应用）。解题策略包括排序、二分搜索、利用数据结构（如set）等。
摘要由CSDN通过智能技术生成

A:最小的k个数一定是1到k

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10,M=2*N,mod=1e9+7;
#define int long long
typedef long long LL;
typedef pair<int, int> PII;
typedef unsigned long long ULL;
using node=tuple<int,int,int>;
const long long inf=1e18;
 
int n,m,k;
int a[N];

void solve(){
    cin>>n>>k;
    int s=0;
    for(int i=1;i<=n;i++) cin>>a[i];
    sort(a+1,a+1+k);
    for(int i=1;i<=k;i++)
    {
        s+=(a[i]>k);
    }
    cout<<s<<"\n";
    
}
signed main()
{
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    int t=1;
    int cnt=0;
    cin>>t;
    while(t--) solve();
    return 0;
}

B：

相邻的两个数互质，所以lcm=x*(x-1)

所以直接交换相邻两个数即可

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10,M=2*N,mod=1e9+7;
#define int long long
typedef long long LL;
typedef pair<int, int> PII;
typedef unsigned long long ULL;
using node=tuple<int,int,int>;
const long long inf=1e18;
 
int n,m,k;
int a[N];

void solve(){
    cin>>n;

    if(n%2==0){
        for(int i=1;i<=n;i+=2){
            cout<<i+1<<" "<<i<<" ";
        }
    }
    else{
        cout<<1<<" ";
        for(int i=2;i<=n;i+=2){
            cout<<i+1<<" "<<i<<" ";
        }
    }
    cout<<"\n";
    
}
signed main()
{
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    int t=1;
    int cnt=0;
    cin>>t;
    while(t--) solve();
    return 0;
}

C：

固定的如果a[i]<a[i+1]一定要改变，这会导致两个情况，且前缀都会变成0

后面的a[i]变成0，导致原本 a[i-1]<=a[i] 变成a[i-1]>0

或者 a[i]变成0 导致原本a[i]>a[i+1] 变成0<=a[i+1]

所以拿个set存已经变成0的数，

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10,M=2*N,mod=1e9+7;
#define int long long
typedef long long LL;
typedef pair<int, int> PII;
typedef unsigned long long ULL;
using node=tuple<int,int,int>;
const long long inf=1e18;
 
int n,m,k;
int a[N];

void solve(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    map<int,int> mp;
    for(int i=1;i<=n;i++)
    {
        mp[a[i]]=i;
    }
    int mx=1;
    set<int> st; 
    for(int i=1;i<n;i++)
    {
        if((a[i]>a[i+1]&&!st.count(a[i])) ||
        (st.count(a[i+1])&&!st.count(a[i])))
        {
         
            if(mp[a[i]]>=mx)
            {
                while(mx<=mp[a[i]])
                {
                   // cout<<a[mx]<<"\n";
                    st.insert(a[mx]);
                    mx++;
                }
            }
        }
    }


    cout<<st.size()<<"\n";
}
signed main()
{
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    int t=1;
    int cnt=0;
    cin>>t;
    while(t--) solve();
    return 0;
}

D：手玩一下，最大值的最短路径只有两个情况

第一种直接就是相邻两个点的最小值，或者通过一个最小点来到达，构成三元环

最大化最小值二分，然后统计前缀和后缀小于当前答案的最小点，这些点都要改变

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10,M=2*N,mod=1e9+7;
#define int long long
typedef long long LL;
typedef pair<int, int> PII;
typedef unsigned long long ULL;
using node=tuple<int,int,int>;
const long long inf=1e18;
 
int n,m,k;
int a[N];
void solve()
{
    //inf inf 84
    //d(1,2)=d(1,3)+d(2,3)=84+84
    //最大值一定是在相邻两个点之间
    //或者经过一个最小的点做中间点
    //min(2*{a1-an},min(l,r);
   cin>>n>>k;
   int now=0;
   multiset<int> st;
   for(int i=1;i<=n;i++)
   {
       cin>>a[i];
        st.insert(a[i]);
   }
   //枚举相邻点，改变比当前边小的点
   //min(a[l],a[r])>=2*a[x]
   auto check=[&](int x)
   {
       vector<int> l(n+10),r(n+10);
       for(int i=1;i<=n;i++){
           if(a[i]*2<x) l[i]++;
           l[i]+=l[i-1];
       }
       for(int i=n;i>=1;i--){
           if(a[i]*2<x) r[i]++;
           r[i]+=r[i+1];
       }
       int mn=inf;
       for(int i=1;i<n;i++)
       {
           int cnt=0;
           if(a[i]<x) cnt++;
           if(a[i+1]<x) cnt++;
           cnt+=l[i-1]+r[i+2];
           mn=min(mn,cnt);

       }
       return mn<=k;
   };

    int l=0,r=1e9;
    while(l<r){
        int mid=l+r+1>>1;
        if(check(mid)) l=mid;
        else r=mid-1;
    }
    cout<<l<<"\n";
}

signed main()
{
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    int t=1;

    cin>>t;
    while(t--) solve();
}

E：

考虑容斥原理

答案等于l到r选三个点-lcm(i,j,k)<=2k-  lcm(i,j,k)<=k

为啥只能是k的倍数，因为k是最大的，且lcm一定是k的倍数

lcm(i,j,k)=k,说明i,j是k的因子

lcm(i,j,k)<=2*k只有两种情况 （3，4，6） （6，10，15）两种情况

对于E1直接枚举即可

且由于lcm(i,j,k)<=2k-  lcm(i,j,k)<=k 没有交集，所以直接减掉即可

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10,M=2*N,mod=1e9+7;
#define int long long
typedef long long LL;
typedef pair<int, int> PII;
typedef unsigned long long ULL;
using node=tuple<int,int,int>;
const long long inf=1e18;
 
int n,m,k;
int a[N];
int C(int x){
    return x*(x-1)/2*(x-2)/3;
}
void solve()
{
    int l,r;
   //lcm(i,j,k)<3k
   //lcm(i,j,k)=k lcm(i,j,k)=2*k
   //lcm(i,j)=2*k
   cin>>l>>r;
   int res=C(r-l+1);
   int ans=0;
   for(int i=l+2;i<=r;i++){
		int cnt=0;
		for(int j=1;j<=i/j;j++) 
		{
			if(i%j==0) 
			{
				if(j>=l) ++cnt;
				if(j!=1&&j*j!=i&&i/j>=l) ++cnt;//不算自己 
			}
		}
		ans+=(cnt-1)*cnt>>1;
		if(i%6==0&&(i>>1)>=l) ++ans;
		if(i%15==0&&(i<<1)/5>=l) ++ans;
     
   }
   cout<<res-ans<<"\n";
}

signed main()
{
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    int t=1;

    cin>>t;
    while(t--) solve();
}

E2

对于E2，数最多200000

所以考虑直接离线每个询问

考虑lcm(i,j,k)=k

考虑直接素数筛？类似方法直接找每个数的因子，

对于 1 2 3 4 6 12

举例子，对于r=12 ,如果当前l是2，那么可以选择3 4 6

r=12当前l是4 可以选择 6

当然自身不算，所以预处理每个数的因子的贡献，按顺序加即可

对于lcm(i,j,k)=2*k

lcm(i,j,k)<=2*k只有两种情况 （3，4，6） （6，10，15）两种情况

比如(3,4,6,)贡献是啥呢

r/6 -(l-1)/3

等于r能构造的6个倍数，减掉这个(1,l-1)中不能用的3的倍数就是答案了

因为对于范围里面的6的倍数都会有一个l里面的3的倍数符合条件

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10,M=2*N,mod=1e9+7;
#define int long long
typedef long long LL;
typedef pair<int, int> PII;
typedef unsigned long long ULL;
using node=tuple<int,int,int>;
const long long inf=1e18;
 
int n,m,k;
int a[N];
vector<int> g[N];
struct qu{
    int l,r,id;
	bool operator <(qu x) const{
		return r^x.r?r<x.r:l<x.l;
	}
}q[N];
struct ptt{
    int lt,rt,val;
}p[5000010];
int tr[N];

int lowbit(int x){
    return x&-x;
}
void add(int x,int y){
	for(int i=x;i<=200000;i+=lowbit(i))
		tr[i]+=y;
}
int sum(int x){
	long long res=0;
	if(x<=0) return 0;
	for(int i=x;i>=1;i-=lowbit(i)) res+=tr[i];
	return res;
}
void solve()
{
    
}
int ans[N];
int C(int x){
    return x*(x-1)*(x-2)/6;
}
signed main()
{
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    int t=1;
    int cnt=0;
    cin>>t;
    int n=200000;
	for(int i=1;i<=n;i++)
		for(int j=(i<<1);j<=n;j+=i)
			g[j].push_back(i);//预处理因数
	for(int i=1;i<=n;i++)
		for(int j=0;j<(int)g[i].size()-1;j++)
			p[++cnt].lt=g[i][j],p[cnt].rt=i,p[cnt].val=g[i].size()-j-1;
            
	for(int i=1;i<=t;i++)
		cin>>q[i].l>>q[i].r,q[i].id=i;
	sort(q+1,q+t+1); 
	int now=1;
	for(int i=1;i<=t;i++){
		while(now<=cnt&&p[now].rt<=q[i].r) 
			add(p[now].lt,p[now].val),now++;
		ans[q[i].id]=1ll*(q[i].r-q[i].l+1)*(q[i].r-q[i].l)*(q[i].r-q[i].l-1)/6-
		max(0ll,q[i].r/6-(q[i].l-1)/3)
		-max(0ll,q[i].r/15-(q[i].l-1)/6)
		-sum(q[i].r)+sum(q[i].l-1);
            //3 4 6
	}
	for(int i=1;i<=t;i++)
		cout<<ans[i]<<'\n';
}

南岸以南南岸哀
关注
  • 11
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Codeforces Round 961 (Div. 2)：深度解析与实战技巧.pdf
07-25
### Codeforces Round 961 (Div. 2)：深度解析与实战技巧 #### 引言 Codeforces 是一个国际知名的在线编程竞赛平台，它汇聚了来自世界各地的编程爱好者和专业人士。每一轮比赛都旨在测试参赛者的算法思维、编程...
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
今天CF被D恶心到了，写个题解重新整理下思路，（20开始想，25写完暴力代码，1.30才过，优化后的。。 核心思路就是在暴力的基础上进行组合数等差加速。 C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层...
Codeforces Round #813 (Div. 2)
m0_62289613的博客
08-16 368
Codeforces Round #813 (Div. 2)
Codeforces Round #803 (Div. 2)
weixin_51176105的博客
06-29 289
A. XOR Mixup 只能说很亲切，水题 就是自己dev又卡bug了，tnnd B. Rising Sand B. Rising Sand读完之后，感觉非常nt，然后写完交了一次，wa，然后发现忘了特判k=1 C. 3SUM Closure C. 3SUM Closure比较有意思，就是说，有一个数组，里面任选ijk三个下标，他们的数组对用数的和，要还在数组内，就是一个好数组，然后问你数组是不是，一开始想的是，排个序，看看前三个数的和 和后三个数的和是不是都在数组里面就可以，然后发现不对劲，因为开头和结
Codeforces Round#722 div.1+div.2题解
月阁
05-26 625
div.2-A. Eshag Loves Big Arrays 题目大意 给定序列 aaa ,每次可以选择其中一些数，删除其中大于这些数平均值的数，求最多可以删除多少数。 题解 每次选择最小的数 xxx 和其他任意大于 xxx 的数 yyy ，则必定可以删除 yyy。因此最后只剩下最小的数不会被删除。 参考代码 #include<bits/stdc++.h> using namespace std; const int MAXN=110; int a[MAXN]; int main()
Codeforces Round#728 div.1+div.2题解
月阁
06-26 2846
视频讲解：TBD A. Arithmetic Array 题目大意 题解 参考代码 A. Arithmetic Array 题目大意 题解 参考代码 A. Arithmetic Array 题目大意 题解 参考代码 D. Tree Array 题目大意 题解 考虑一对逆序数对 (i,j)(i<j,ai>aj)(i,j)(i < j,a_i>a_j)(i,j)(i<j,ai​>aj​) 出现的概率 Pi,jP_{i,j}Pi,j​，则易得总期望 E=∑i=1n∑
Codeforces Round #744 (Div. 3) a-e2
Fox_xx的博客
10-03 212
Codeforces Round #744A Casimir's String SolitaireB Shifting SortC TicksD Productive MeetingE1 Permutation Minimization by DequeE2 Array Optimization by Deque A Casimir’s String Solitaire 题目 题意 有个只有A,B,C的字符串 每次删去一个A和B 或者 删去一个B和C 问能否删除完 思路 计算A+C==B 能相等就说明能删
Codeforces Round #744 (Div. 3)部分题解(A ~ E2)
Mr.RainsdRop的胡思乱想
10-02 504
目录前言 前言 首先，是犯下了懒惰之罪的Mr.RainsdRop。 自以为连续日更很了不起，向外宣称自己是一个日更博主。大家不知道，当《废柴日记1：Python与C++中关于随机数的那些事》写到最后的时候，电脑仅仅剩下20%的电量，而文章还有至少一段没写。当时的Mr.RainsdRop闭上眼睛，看到的便是已然成神的 God Jun 。 God Jun 说：“你的电脑将会供你发完博客。你只可到这里，不可越过。” 然而，Mr.RainsdRop却逐渐忘记了神对他的恩赐，开始周更，开始拖更。 于是神降下
Codeforces Round #617 (Div. 3)(E1,E2(最长反链),F（思维dfs贪心）)
ccsu_deer
02-05 315
E1. String Coloring (easy version) O(n)做法 适合n<=1e5 可惜答案是n<=200 题意：现在有一个小写的字符串，你可以将每一位的字符染成两种颜色的其中一种， 现在不同颜色的字符串才能互相交换位置，现要交换字符串使得 字符串是按升序的 输出染色的方案，没有的话输出No 做法：O(26*n) 暴力即可 #include<bi...
Codeforces Round #744(Div.3)(A~E2)
dabaitutunaitang的博客
10-03 163
目录 A - Casimir’s String Solitaire(思维+水题) B - Shifting Sort (暴力) C - Ticks (暴力+思维) D - Productive Meeting(贪心+思维+优先队列) E1. Permutation Minimization by Deque(双端队列+水题) E2. Array Optimization by Deque(贪心+离散化+树状数组) A - Casimir’s String Solitaire(思维+水题)
Codeforces Round #744 (Div. 3)(A-E2)
weixin_49824291的博客
10-01 225
首先,庆祝自己上了绿名 A. Casimir’s String Solitaire 题目描述: 一个字符串包括A,B,C三种字符,有俩种操作可以选择 1.删除一个A和一个B 2.删除一个B和一个C 问最后能不能将这个字符串清空 思路: 统计A,B,C的数量为a,b,c,b=a+c则YES,否则NO #include<bits/stdc++.h> using namespace std; #define int long long signed main(){ int t; cin&gt
Codeforces Round #627 (Div. 3) D. Pair of Topics（二分，思维）
01-03
### Codeforces Round #627 (Div. 3) D. Pair of Topics（二分，思维） #### 题目背景与概述 本题目来自Codeforces Round #627 (Div. 3)，编号为D的题目“Pair of Topics”，这是一道结合了二分搜索与逻辑思维的...
codeforces round 961 (div. 2)
07-25
### Codeforces Round 961 (Div. 2) A题解析 #### 题目背景 Codeforces Round 961 (Div. 2) 是一场针对中级水平程序员的编程竞赛，通常会包含几个不同难度级别的题目。A题作为入门级题目，旨在测试参赛者的基础算法...
Educational Codeforces Round 83 (Rated for Div. 2) D. Count the Arrays（组合数学）
01-03
题目 "Educational Codeforces Round 83 (Rated for Div. 2) D. Count the Arrays" 描述了一个涉及组合数学的算法问题。在这个问题中，参与者需要计算满足特定条件的数组的数量。虽然具体的数组条件没有在给定的文件...
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
sjsjs11的博客
08-14 388
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
笔记分享: 香港中文大学CSCI5610高级数据结构——最邻近查询
最新发布
qq_64091900的博客
08-18 495
香港中文大学CSCI5610高级数据结构
链表 19.删除链表的倒数第N个节点 双指针
qq_64633597的博客
08-14 203
return head 和return dummy.next 的区别，若删除的是头节点，则头节点还需要更新，题目中给的头节点就不能用了。而dummy作为虚拟头节点，永远是头节点的上一位，即使head发生变化，仍然是dummy.next。fast走n+1步，是为了和slow保持n+1个位置，此时fast移动至空节点，slow与fast位置差n+1节点，那slow再往后移动一位，就是需要删除的倒数第n个节点，即目标节点。倒数第几个，翻过来看即正数第几个。
数据结构之排序（下）
qq_74336191的博客
08-15 635
​ 嗨！小伙伴们，咱们又见面啦，在上一篇数据结构之排序（上）中，我们学习了直接插入排序、冒泡排序和希尔排序，今天我们继续学习排序这一块，准备好了吗？Ready Go ! ! ! ​
codeforces round #792 (div. 1 + div. 2)
06-06
codeforces round #792 (div. 1 + div. 2) 是 Codeforces 竞赛平台上的一场比赛，包括两个级别：div. 1 和 div. 2。这场比赛通常会有多个问题需要参赛者解决，每个问题都有不同的难度等级。参赛者需要在规定的时间内提交他们的解决方案，然后等待评测结果。最终，根据参赛者的得分和排名，评选出获胜者。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值