codeforce 448 B. XK Segments

最新推荐文章于 2022-05-26 19:50:53 发布
最新推荐文章于 2022-05-26 19:50:53 发布
阅读量400 收藏
点赞数
分类专栏： Algorithm------数学--深思 文章标签： 二分查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37109329/article/details/78655282
版权
解决一个算法问题，找出数组中满足特定条件的有序数对数量。条件涉及元素间的关系及可被特定整数整除的中间数值。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

B. XK Segments
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

While Vasya finished eating his piece of pizza, the lesson has already started. For being late for the lesson, the teacher suggested Vasya to solve one interesting problem. Vasya has an array a and integer x. He should find the number of different ordered pairs of indexes (i, j)such that ai ≤ aj and there are exactly k integers y such that ai ≤ y ≤ aj and y is divisible by x.

In this problem it is meant that pair (i, j) is equal to (j, i) only if i is equal to j. For example pair (1, 2) is not the same as (2, 1).

Input

The first line contains 3 integers n, x, k (1 ≤ n ≤ 105, 1 ≤ x ≤ 109, 0 ≤ k ≤ 109), where n is the size of the array a and x and k are numbers from the statement.

The second line contains n integers ai (1 ≤ ai ≤ 109) — the elements of the array a.

Output

Print one integer — the answer to the problem.

Examples
input 
4 2 1
1 3 5 7
output 
3
input 
4 2 0
5 3 1 7
output 
4
input 
5 3 1
3 3 3 3 3
output 
25
 
   
排序不影响最后的结果，因为求得是多少个，并没有具体到哪个；
 
   
对于某个数a[i],如果他是x的倍数，设为t*x，如果在a[i]~a[j]之间恰好有k个y满足条件，那么a[j]的范围是[(t+k-1)*x,(t+k+1)*x-1],如果他不是x的倍数，设他为kx+b；则a[j]的范围为[(t+k)*x,(t+k+1)*x-1];
 
   
枚举a[i],在此范围内求满足的a[j]个数；
 
   
lower_bound(x,y,z),从地址x到地址y，寻找第一个大于等于z的数，并返回其位置；
 
   
std::ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
加上这两句可以使cin cout快的飞起,和scanf printf相差无几；
 
   
#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdio.h> 
using namespace std;
typedef long long ll;
ll a[100100];
int main()
{
	std::ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	ll n,x,k;
	ll ans=0;
	memset(a,0,sizeof(a));
	cin>>n>>x>>k;
	for (int i=0;i<n;i++)
	cin>>a[i];
	sort(a,a+n);
	for (int i=0;i<n;i++)
	{
	 ll r=x*(k+1+(a[i]-1)/x);
	 ll l=max(x*(k+(a[i]-1)/x),a[i]);
	 ans+=lower_bound(a,a+n,r)-lower_bound(a,a+n,l);
    }
	cout<<ans<<endl;
	return 0;
} 


 
   
 
  
 
 
 


                

        

    

  



    


                



	

		

			

				
					
【codeforce】B. Sort the Array （翻转一次数串使得序列有序）

				
			

			

				

					Nerdant
				

				

					08-27
					
					251
					
				

			

		

		

			
				
Being a programmer, you like arrays a lot. For your birthday, your friends have given you an arrayaconsisting ofndistinctintegers.

Unfortunately, the size ofais too small. You want a bigger ar...

			
		

	



                

            
              



	

		

			

				
					
codeforce1671C. Dolce Vita

				
			

			

				

					突破吧！次元壁
				

				

					04-24
					
					532
					
				

			

		

		

			
				
传送门：誰にだって訳があって、今を生きって
水题碰彩笔，我直接嘤嘤嘤
思路很简单，就是挑着便宜的买，因为所有商品每次涨价幅度一样，所以预算不超，买的方式和上一轮一样；如果超了，不要最贵的。
重点再于实现细节
#pragma GCC diagnostic error "-std=c++11"
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define ll long long
#define Pair pair<int,int>
#d

			
		

	



              


  
              

                


	

		

			

				
					
XK Segments(二分)

				
			

			

				

					MM__1997的博客
				

				

					11-29
					
					1031
					
				

			

		

		

			
				
http://codeforces.com/contest/895/problem/B

















题目大意：
ｎ个数的序列　　问任意　a[i] ~ a[j]（a[j]>=a[i]） 之间能被ｘ整除的的数的个数恰好为ｋ的 (i,j) 有多少种情况






分析：
i和j是任意的只要满足　a[i]>=a[j]　就行　　　

			
		

	





	

		

			

				
					
cfB. XK Segments(二分)

				
			

			

				

					NicoleYWJ的博客
				

				

					12-10
					
					345
					
				

			

		

		

			
				
B. XK Segments


time limit per test
1 second


memory limit per test
256 megabytes


input
standard input


output
standard output



While Vasya finished eating his piece of pizz

			
		

	



		

			
		



	

		

			

				
					
B. XK Segments （二分）

				
			

			

				

					凝望的博客
				

				

					06-01
					
					304
					
				

			

		

		

			
				

题意：给你三个整数，n，x，k。再给你一个大小为 n 的数组a，要你找出不同的下标对 (i,j) 的对数，是其满足：a[i]&amp;amp;lt;=a[j] 且 在 [ a[i] , a[j] ]  内，恰好有k个能被x整除的数。
算法：二分
思路：先sort一下，因为要求的只是下标对数所以sort不影响。1~n 遍历a[i], 对于每一个a[i], 从 a[j]&amp;amp;gt;=a[i] 的范围里，计算得到 最小满...

			
		

	





	

		

			

				
					
Codeforces-895B XK Segments

				
			

			

				

					Uniontake
				

				

					11-27
					
					1025
					
				

			

		

		

			
				
/**
    题意:输入n,x,k; 和一个 n 长度的 序列 , 一个二元组的定义如下(i,j) 满足 ai<= y <= aj, 使得y|x的y个数为k个(y为[ai,aj]闭区间的整数)
        注意 (i,j) != (j,i) 如果 i!=j的情况下,求出满足这样的二元组的个数
    题解:因为仅仅是求得个数,先排序,
        枚举每一个元素,对每一元素ai,求得 y1

			
		

	





	

		

			

				
					
CodeForce 1354 D. Multiset【二分】

				
			

			

				

					weixin_51546928的博客
				

				

					05-26
					
					153
					
				

			

		

		

			
				
题目链接
  想到的第一种做法是用树状数组维护每个数出现次数的前缀和。插入某个数就比较简单，树状数组单点修改即可。删除第kkk个数的话就要先二分prefi>=kpref_i >= kprefi​>=k的位置，换句话说：找到一个最小的数valvalval使得∑i=1valcnti  ≥  k\sum_{i=1}^{val}cnt_i \; ≥ \; k∑i=1val​cnti​≥k，然后val的出现次数−1-1−1，这个复杂度带两个logloglog，904ms.
#include<i

			
		

	





	

		

			

				
					
codeforce1679C. Rooks Defenders

				
			

			

				

					突破吧！次元壁
				

				

					05-22
					
					497
					
				

			

		

		

			
				
传送门：线段树也不过如此

这标准线段树模板题，但是多年没碰线段树，现在已经基本不会写了T^T
首先是创建线段树。
线段树是个满二叉树，如果从长度为n的数组上生成线段树，那么树节点个数m满足
m≤2q+1−1
 m \le 2^{q+1} - 1
m≤2q+1−1
其中2q>n∧2q−1<n2^q > n \land  2^{q-1} < n2q>n∧2q−1<n
此外对于满二叉树来说，假设当前节点编号为n,则left node编号为2n2n2n,right node编号

			
		

	





	

		

			

				
					
codeforce1651C. Fault-tolerant Network

				
			

			

				

					突破吧！次元壁
				

				

					04-04
					
					978
					
				

			

		

		

			
				
传送门：四月は君の嘘
现在有两排电脑，a之间相互可达的，b之间相互可达，但是a，b之间不相连

每个电脑有自己的值，将电脑ai，bj相连，花费abs(a[i]-b[j])。现在求将a，b两排电脑组成有容错网络的最小花费。
其中有容错网络指，a或b中任意一台电脑断开与其他电脑的连接，其余电脑之间仍然保持连接

首先我们随意连接序列a和b中两个点。设aia_{i}ai​和bjb_{j}bj​相连；apa_{p}ap​和bqb_{q}bq​相连，组成网络如图所展示
对于这样的网络，不难看出断开[a0,ai][a_

			
		

	





	

		

			

				
					
CodeForces 895B XK Segments

				
			

			

				

					知与谁i的博客
				

				

					11-28
					
					596
					
				

			

		

		

			
				
题目链接：http://codeforces.com/problemset/problem/895/B

题意：给定n个数，从这些数中找到一个序列(i,j)，使得[a[i],a[j]]中恰好有k个数是x的倍数，求一共有多少个序列（PS：对于序列来说i，j的关系是无序的，也就是说可以i&lt;j || i &gt;= j）

思路：把n个数从小到大排序，然后求出大于等于a[i]的第一个x的倍数p，然...

			
		

	





	

		

			

				
					
codeforces895B XK segments

				
			

			

				

					LiRewriter的博客
				

				

					12-15
					
					330
					
				

			

		

		

			
				
蛮有趣的一道题。 
先来说说题意，大概是：对一个数组a，定义符合条件的二元组(i,j)(i, j)表示恰好存在kk个整数，满足ai≤y≤aja_i \leq y \leq a_j且yy为xx的倍数，求符合条件的二元组数量。一上来有些懵逼，不妨先找找规律。 
我们知道，假定存在kk个这样的整数，那么首先[L,L+(k−1)∗x][L, L + (k - 1) * x]一定是符合条件的一个区间，然后考虑

			
		

	





	

		

			

				
					
#448 div.2 B.XK Segments

				
			

			

				

					ac_blood的博客
				

				

					11-29
					
					395
					
				

			

		

		

			
				
While Vasya finished eating his piece of pizza, the lesson has already started. For being late for the lesson, the teacher suggested Vasya to solve one interesting problem. Vasya has an array a and

			
		

	





	

		

			

				
					
【CodeForces】895B. XK Segments 题解

				
			

			

				

					Drmon.的博客
				

				

					04-07
					
					290
					
				

			

		

		

			
				
题目来自于：CodeForces - 895B 

首先按照题意：
第一行输入三个数字，分别是：
1.第二行需要输入多少个元素；
2.每两个元素所对应的区间要处以的数，判断是否等于0；
3.区间里的元素应该等于0的数量。
然后，第二行输入对应的元素。
我直接试了一下两个for，O(n^2)的复杂度 超时了。
所以这道题的关键点在于：理解题意，如何统计，以及降低时间复杂度。
这里我们可以先排序，然后...

			
		

	





	

		

			

				
					
Codeforces Round #448 (Div. 2) B. XK Segments  排序+二分

				
			

			

				

					床前明月光
				

				

					11-27
					
					506
					
				

			

		

		

			
				
题意：
问某种 i-j 对的个数； i-j 对满足
枚举 i j ，当 ai 


思路：
我们可以知道，朴素算法就是枚举 ij  这里明显超时，
我们要注意到这里的限制条件： ai 
排序后，对每个 a[i] ,我们就会想，另一个满足条件边界是啥？ 然后解法就来了，我们根据 恰好k个 x的倍数，然后可以知道满足条件的右边界的大小范围
这样的话 可用lower_bound （lo

			
		

	





	

		

			

				
					
codeforces 895B XK Segments 思维 二分

				
			

			

				

					黑码
				

				

					12-13
					
					588
					
				

			

		

		

			
				
While Vasya finished eating his piece of pizza, the lesson has already started. For being late for the lesson, the teacher suggested Vasya to solve one interesting problem. Vasya has an array a and int

			
		

	





	

		

			

				
					
《数据结构》（02331）基础概念

					
最新发布

				
			

			

				

					04-01
				

			

		

		

			
				
内容概要：本文档《数据结构》（02331）第一章主要介绍数据结构的基础概念，涵盖数据与数据元素的定义及其特性，详细阐述了数据结构的三大要素：逻辑结构、存储结构和数据运算。逻辑结构分为线性结构（如线性表、栈、队列）、树形结构（涉及根节点、父节点、子节点等术语）和其他结构。存储结构对比了顺序存储和链式存储的特点，包括访问方式、插入删除操作的时间复杂度以及空间分配方式，并介绍了索引存储和散列存储的概念。最后讲解了抽象数据类型（ADT）的定义及其组成部分，并探讨了算法分析中的时间复杂度计算方法。
适合人群：计算机相关专业学生或初学者，对数据结构有一定兴趣并希望系统学习其基础知识的人群。
使用场景及目标：①理解数据结构的基本概念，掌握逻辑结构和存储结构的区别与联系；②熟悉不同存储方式的特点及应用场景；③学会分析简单算法的时间复杂度，为后续深入学习打下坚实基础。
阅读建议：本章节内容较为理论化，建议结合实际案例进行理解，尤其是对于逻辑结构和存储结构的理解要深入到具体的应用场景中，同时可以尝试编写一些简单的程序来加深对抽象数据类型的认识。

			
		

	





	

		

			

				
					
【工业自动化】施耐德M580 PLC系统架构详解：存储结构、硬件配置与冗余设计

				
			

			

				

					04-01
				

			

		

		

			
				
内容概要：本文详细介绍了施耐德M580系列PLC的存储结构、系统硬件架构、上电写入程序及CPU冗余特性。在存储结构方面，涵盖拓扑寻址、Device DDT远程寻址以及寄存器寻址三种方式，详细解释了不同类型的寻址方法及其应用场景。系统硬件架构部分，阐述了最小系统的构建要素，包括CPU、机架和模块的选择与配置，并介绍了常见的系统拓扑结构，如简单的机架间拓扑和远程子站以太网菊花链等。上电写入程序环节，说明了通过USB和以太网两种接口进行程序下载的具体步骤，特别是针对初次下载时IP地址的设置方法。最后，CPU冗余部分重点描述了热备功能的实现机制，包括IP通讯地址配置和热备拓扑结构。
适合人群：从事工业自动化领域工作的技术人员，特别是对PLC编程及系统集成有一定了解的工程师。
使用场景及目标：①帮助工程师理解施耐德M580系列PLC的寻址机制，以便更好地进行模块配置和编程；②指导工程师完成最小系统的搭建，优化系统拓扑结构的设计；③提供详细的上电写入程序指南，确保程序下载顺利进行；④解释CPU冗余的实现方式，提高系统的稳定性和可靠性。
其他说明：文中还涉及一些特殊模块的功能介绍，如定时器事件和Modbus串口通讯模块，这些内容有助于用户深入了解M580系列PLC的高级应用。此外，附录部分提供了远程子站和热备冗余系统的实物图片，便于用户直观理解相关概念。

			
		

	





	

		

			

				
					
某型自动垂直提升仓储系统方案论证及关键零部件的设计.zip

				
			

			

				

					04-01
				

			

		

		

			
				
某型自动垂直提升仓储系统方案论证及关键零部件的设计.zip

			
		

	





	

		

			

				
					
请用c++语言写一下codeforce中C.Tic-tac-toe这道题的代码

				
			

			

				

					09-12
				

			

		

		

			
				
### 回答1：

#include <stdio.h>
int main(){
    //定义一个3*3的数组用来存储棋盘
    int board[3][3]={0};
    int x,y,turn=1;
    while (1){
        //打印棋盘
        printf("当前棋盘：\n");
        for (x=0;x<3;x++){
            for (y=0;y<3;y++){
                printf("%d ",board[x][y]);
            }
            printf("\n");
        }
        //根据turn的值来判断谁轮到落子
        if (turn==1){
            printf("轮到X落子，请输入落子的位置(x y)：");
        }else {
            printf("轮到O落子，请输入落子的位置(x y)：");
        }
        scanf("%d %d",&x,&y);
        //将落子位置的值设置为对应的值
        board[x][y] = turn;
        //改变轮到谁落子
        turn = -turn;
        //判断谁赢了
        if (board[0][0]==board[1][1] && board[1][1]==board[2][2] && board[2][2]!=0){
            printf("游戏结束，获胜者是%c\n",board[0][0]==1?'X':'O');
            break;
        }
        if (board[2][0]==board[1][1] && board[1][1]==board[0][2] && board[0][2]!=0){
            printf("游戏结束，获胜者是%c\n",board[2][0]==1?'X':'O');
            break;
        }
        for (x=0;x<3;x++){
            if (board[x][0]==board[x][1] && board[x][1]==board[x][2] && board[x][2]!=0){
                printf("游戏结束，获胜者是%c\n", board[x][0] == 1 ? 'X' : 'O');
                break;
            }
            if (board[0][x]==board[1][x] && board[1][x]==board[2][x] && board[2][x]!=0){
                printf("游戏结束，获胜者是%c\n", board[0][x] == 1 ? 'X' : 'O');
                break;
            }
        }
    }
    return 0;
}  

### 回答2：
为了回答这个问题，需要提供题目的具体要求和规则。由于提供的信息不够具体，无法为您提供准确的代码。但是，我可以给您一个简单的Tic-tac-toe游戏的示例代码，供您参考：

```c
#include <stdio.h>
#include <stdbool.h>

// 判断游戏是否结束
bool isGameOver(char board[][3]) {
    // 判断每行是否有3个相同的棋子
    for(int i = 0; i < 3; i++) {
        if(board[i][0] != '.' && board[i][0] == board[i][1] && board[i][0] == board[i][2]) {
            return true;
        }
    }
    
    // 判断每列是否有3个相同的棋子
    for(int i = 0; i < 3; i++) {
        if(board[0][i] != '.' && board[0][i] == board[1][i] && board[0][i] == board[2][i]) {
            return true;
        }
    }
    
    // 判断对角线是否有3个相同的棋子
    if(board[0][0] != '.' && board[0][0] == board[1][1] && board[0][0] == board[2][2]) {
        return true;
    }
    
    if(board[0][2] != '.' && board[0][2] == board[1][1] && board[0][2] == board[2][0]) {
        return true;
    }
    
    return false;
}

// 输出棋盘
void printBoard(char board[][3]) {
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            printf("%c ", board[i][j]);
        }
        printf("\n");
    }
}

int main() {
    char board[3][3];
    // 初始化棋盘
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            board[i][j] = '.';
        }
    }
    
    int player = 1;  // 玩家1先下
    int row, col;
    while(true) {
        printf("Player %d's turn:\n", player);
        printf("Row: ");
        scanf("%d", &row);
        printf("Column: ");
        scanf("%d", &col);
        
        // 判断输入是否合法
        if(row < 0 || row >= 3 || col < 0 || col >= 3 || board[row][col] != '.') {
            printf("Invalid move. Try again.\n");
            continue;
        }
        
        // 下棋
        board[row][col] = (player == 1) ? 'X' : 'O';
        
        // 输出棋盘
        printBoard(board);
        
        // 判断游戏是否结束
        if(isGameOver(board)) {
            printf("Player %d wins!\n", player);
            break;
        }
        
        // 切换玩家
        player = (player == 1) ? 2 : 1;
    }
    
    return 0;
}
```

这段代码实现了一个简单的命令行下的Tic-tac-toe游戏。玩家1使用'X'棋子，玩家2使用'O'棋子。玩家依次输入行和列，下棋后更新棋盘，并判断游戏是否结束。当游戏结束时，会输出获胜者并结束游戏。  

### 回答3：
题目要求实现一个井字棋游戏的判断胜负函数。给定一个3x3的井字棋棋盘，用C语言编写一个函数，判断当前是否存在某个玩家获胜或者平局。

题目要求代码中定义一个3x3的字符数组board来表示棋盘，其中 'X' 表示玩家1在该位置放置了一个棋子， 'O' 表示玩家2在该位置放置了一个棋子， '.' 表示该位置没有棋子。

下面是实现此题的C语言代码：

```c
#include <stdio.h>
#include <stdbool.h>  // 用于使用bool类型

bool checkWin(char board[3][3]) {
    // 检查每一行是否有获胜的情况
    for (int row = 0; row < 3; row++) {
        if (board[row][0] == board[row][1] && board[row][1] == board[row][2] && board[row][0] != '.') {
            return true;
        }
    }
    
    // 检查每一列是否有获胜的情况
    for (int col = 0; col < 3; col++) {
        if (board[0][col] == board[1][col] && board[1][col] == board[2][col] && board[0][col] != '.') {
            return true;
        }
    }
    
    // 检查对角线是否有获胜的情况
    if ((board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != '.') ||
        (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != '.')) {
        return true;
    }
    
    return false;  // 没有获胜的情况
}

int main() {
    char board[3][3];  // 存储棋盘状态
    
    // 读取棋盘状态
    for (int i = 0; i < 3; i++) {
        scanf("%s", board[i]);
    }
    
    // 调用检查胜负的函数，并输出结果
    if (checkWin(board)) {
        printf("YES\n");
    } else {
        printf("NO\n");
    }
    
    return 0;
}
```

这个程序中定义了一个函数checkWin，用于检查是否有玩家获胜。遍历棋盘的每一行、每一列和对角线，判断是否有连续相同的字符且不为'.'，如果有，则返回true；否则返回false。

在主函数main中，首先定义一个3x3的字符数组board，然后通过循环从标准输入中读取棋盘状态。接着调用checkWin函数进行胜负判断，并根据结果输出"YES"或者"NO"。最后返回0表示程序正常结束。

请注意，该代码只包含了检查胜负的功能，并没有包含其他如用户输入、判断平局等功能。如果需要完整的游戏代码，请告知具体要求。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值