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

			
		

	





	

		

			

				
					
基于Simulink的风火水储联合调频系统中储能SOC对ACE影响的技术分析

					
最新发布

				
			

			

				

					04-03
				

			

		

		

			
				
内容概要：本文详细探讨了在Simulink环境中构建的风火水储联合调频系统中，储能系统的荷电状态（SOC）对区域控制偏差（ACE）的影响。文中通过具体案例和MATLAB代码展示了储能系统在不同SOC水平下的表现及其对系统稳定性的作用。同时，文章比较了储能单独调频与风火水储联合调频的效果，强调了储能系统在应对风电波动性和提高系统响应速度方面的重要作用。此外，作者提出了针对SOC变化率的参数整定方法以及多电源协同工作的优化策略，旨在减少ACE波动并确保系统稳定运行。
适合人群：从事电力系统调频研究的专业人士，尤其是熟悉Simulink仿真工具的研究人员和技术人员。
使用场景及目标：适用于希望深入了解储能系统在电力系统调频中作用的研究者和技术人员，目标是通过合理的SOC管理和多电源协同工作，优化调频效果，提高系统稳定性。
其他说明：文章提供了详细的MATLAB代码片段，帮助读者更好地理解和应用所讨论的概念。同时，文中提到的实际案例和仿真结果为理论分析提供了有力支持。


			
		

	





	

		

			

				
					
欧姆龙PLC NJ中大型程序案例：结构化与面向对象编程的深度融合及应用

				
			

			

				

					04-03
				

			

		

		

			
				
内容概要：本文深入探讨了欧姆龙PLC NJ系列中大型程序中结构化编程与面向对象编程的结合及其应用。首先介绍了结构化编程作为程序框架的基础，通过功能块（FB）实现清晰的程序结构和流程控制。接着阐述了面向对象编程的理念，将现实世界的对象映射到程序中，利用类的概念实现模块化和可扩展性。两者结合提高了程序的容错率，增强了程序的稳定性和可维护性。文中通过多个实际案例展示了如何在工业自动化领域中应用这两种编程方法，如电机控制、设备类的创建、异常处理机制、接口实现多态性、配方管理和报警处理等。
适合人群：从事工业自动化领域的工程师和技术人员，尤其是那些希望提升PLC编程技能的人群。
使用场景及目标：适用于需要优化PLC程序结构、提高程序可靠性和可维护性的场合。目标是帮助工程师掌握结构化编程和面向对象编程的技巧，从而写出更加高效、稳定的PLC程序。
其他说明：文章强调了在实际项目中灵活运用两种编程方法的重要性，并提醒读者注意实时性要求高的动作控制应采用结构化编程，而工艺逻辑和HMI交互则更适合面向对象编程。


			
		

	





	

		

			

				
					
matlab与聚类分析

				
			

			

				

					04-03
				

			

		

		

			
				
matlab与聚类分析。根据我国历年职工人数（单位：万人），使用有序样品的fisher法聚类。

			
		

	





	

		

			

				
					
请用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?&#39;X&#39;:&#39;O&#39;);
            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?&#39;X&#39;:&#39;O&#39;);
            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 ? &#39;X&#39; : &#39;O&#39;);
                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 ? &#39;X&#39; : &#39;O&#39;);
                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] != &#39;.&#39; && 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] != &#39;.&#39; && board[0][i] == board[1][i] && board[0][i] == board[2][i]) {
            return true;
        }
    }
    
    // 判断对角线是否有3个相同的棋子
    if(board[0][0] != &#39;.&#39; && board[0][0] == board[1][1] && board[0][0] == board[2][2]) {
        return true;
    }
    
    if(board[0][2] != &#39;.&#39; && 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] = &#39;.&#39;;
        }
    }
    
    int player = 1;  // 玩家1先下
    int row, col;
    while(true) {
        printf("Player %d&#39;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] != &#39;.&#39;) {
            printf("Invalid move. Try again.\n");
            continue;
        }
        
        // 下棋
        board[row][col] = (player == 1) ? &#39;X&#39; : &#39;O&#39;;
        
        // 输出棋盘
        printBoard(board);
        
        // 判断游戏是否结束
        if(isGameOver(board)) {
            printf("Player %d wins!\n", player);
            break;
        }
        
        // 切换玩家
        player = (player == 1) ? 2 : 1;
    }
    
    return 0;
}
```

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

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

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

下面是实现此题的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] != &#39;.&#39;) {
            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] != &#39;.&#39;) {
            return true;
        }
    }
    
    // 检查对角线是否有获胜的情况
    if ((board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != &#39;.&#39;) ||
        (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != &#39;.&#39;)) {
        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，用于检查是否有玩家获胜。遍历棋盘的每一行、每一列和对角线，判断是否有连续相同的字符且不为&#39;.&#39;，如果有，则返回true；否则返回false。

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

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

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值