区间重合判断

最新推荐文章于 2022-04-24 10:16:32 发布
最新推荐文章于 2022-04-24 10:16:32 发布
阅读量1.3k 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wy5761/article/details/8964179
版权

l  方法一

1 对N个无序的目标区间进行排序

2 顺序判断源区间是否在目标区间内

bool isOverlap([x, y], [x1, y1][x2,y2]...[xn,yn])

{

         //以x为key进行升序排序，排序后x1<=x2<=x3<=..<=xn

         sort([x1,y1][x2,y2]...[xn,yn]);

         flg=0;

         lastEnd=x1;

         for (i=1;i<=n; i++)

         {

                   if(flg==0)

                   {

                            //进入包含源区间的低端的目标区间

                            if(xi<=x && yi>=x)

                            {

                                     flg = 1;

                                     lastEnd= max(lastEnd, yi);

                            }

                   }

                   else

                   {

                            //判断区间是否中断

                            if(xi > lastEnd)

                                     break;

                            lastEnd= max(lastEnd, yi);

                            //判断是否是源区间高端所在的目标区间

                            if(xi<=y && yi>=y)

                            {

                                     flg = 2;

                                     break;

                            }

                           

                   }

        }

return (flg == 2);

}

         时间复杂度：排序O(nlogn)+ 遍历O(n)

 

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>

/*
	输入：
	3 5        //第一行两个整数表示源区间
	5          //第二行一个整数表示目标区间个数n
	1 2       //接下来n行表示目标区间
	2 3
	3 5
	6 7
	7 8
	输出：
	true or false
*/
typedef struct  _elemType {
	int x, y;
}ElemType;

#define  N   50   //最大区间数
#define LEN 100 //区间最大长度
#define MAX(a, b) ((a)>=(b)?(a):(b))

int comFun(const void *a, const void *b)
{
	const ElemType *p1 = static_cast<const ElemType *>(a);
	const ElemType *p2 = static_cast<const ElemType *>(b);
	return (p1->x - p2->x);
}

bool isOverlap(int x, int y, const ElemType *p, int n)
{
	int flg=0;
	int lastEnd=p[0].y;

	for (int i=0; i<n; i++)
	{
		if (flg == 0)
		{
			//找到包含源区间低端的目标区间
			if (x>=p[i].x && x <=p[i].y)
			{
				flg = 1;
				lastEnd = MAX(lastEnd, p[i].y);
			}
		}
		else
		{
			//判断区间是否中断
			if (p[i].x > lastEnd)
				break;
			lastEnd = MAX(lastEnd, p[i].y);
			//if (y>=p[i].x && y<=p[i].y)
			//if (y<=p[i].y)  
			if (y<=lastEnd)
			{
				flg = 2;
				break;
			}
		}
	}
	return (flg == 2);
}

void main()
{
	int x, y;
	while(scanf("%d%d", &x ,&y) != EOF)
	{
		int n;
		scanf("%d", &n);
		ElemType des[N];
		int i=0;
		while (i<n)
		{
			scanf("%d%d", &des[i].x, &des[i].y);
			i++;
		}
		qsort(des, n, sizeof(ElemType), comFun);
		//test qort
		/*printf("\n");
		for (i=0; i<n; i++)
			printf("%d %d\n", des[i].x, des[i].y);
		*/
		bool ret = isOverlap(x, y, des, n);
		printf("%s\n", ret?"true":"false");
	}
}

l  方法二

空间换时间

假设区间的最大长度为n，用一个int数组A[n]来表示区间，A[i] (1<=i<=n)表示区间，即区间[i, i+1]上长度为1的一个子区间，如果A[i]为零表示该子区间不包含在目标区间中，否则A[i]包含在目标区间中。更好的表达是：把N个无序的目标区间逐个投影到坐标轴上，然后遍历元区间所在的坐标轴部分，如果全为1表示，源区间包含在目标区间中。

bool isOverlap([x, y], [x1, y1][x2,y2]...[xn,yn])

{

         int A[n] = {0};

         for (i=1;i<=n; i++)

         {

                   A[xi– yi] = 1;

         }

         for (i=x;i<=y; i++)

                   if(A[i]==0)

                            return0;

         return 1;

}

时间复杂度O(n) 空间复杂度O(n)

#include <stdio.h>

/*
	输入：
	3 5        //第一行两个整数表示源区间
	5          //第二行一个整数表示目标区间个数n
	1 2       //接下来n行表示目标区间
	2 3
	3 5
	6 7
	7 8
	输出：
	true or false
*/
typedef struct  _elemType {
	int x, y;
}ElemType;

#define  N   50   //最大区间数
#define LEN 100 //区间最大长度

bool isOverlap(int x, int y, const ElemType *p, int n)
{
	int A[LEN] = {0};
	int i;
	for (i=0; i<n; i++)
	{
		for (int j=p[i].x; j<p[i].y; j++)
			A[j] = 1;
	}
	for (i=x; i<=y; i++)
		if (A[i] == 0)
			return 0;
	return 1;
}

void main()
{
	int x, y;
	while(scanf("%d%d", &x ,&y) != EOF)
	{
		int n;
		scanf("%d", &n);
		ElemType des[N];
		int i=0;
		while (i<n)
		{
			scanf("%d%d", &des[i].x, &des[i].y);
			i++;
		}
		
		bool ret = isOverlap(x, y, des, n);
		printf("%s\n", ret?"true":"false");
	}
}

 

l  方法三

把方法二中的int数组换成位图，一个位表示一个单位长度为1的子区间，进一步降低空间复杂度

bool isOverlap([x, y], [x1, y1][x2,y2]...[xn,yn])

{

         int A[(n+31)/32]= {0};

         for (i=1;i<=n; i++)

         {

                   A[xi– yi] = 1;

         }

         for (i=x;i<=y; i++)

                   if(A[i]==0)

                            return0;

         return 1;

}

时间复杂度O(n) 空间复杂度O(n)

 

#include <stdio.h>

/*
	输入：
	3 5        //第一行两个整数表示源区间
	5          //第二行一个整数表示目标区间个数n
	1 2       //接下来n行表示目标区间
	2 3
	3 5
	6 7
	7 8
	输出：
	true or false
*/
typedef struct  _elemType {
	int x, y;
}ElemType;

#define  N   50   //最大区间数
#define LEN 100 //区间最大长度
#define  BITMASK 32
#define set_bit(a, n) (a[n/BITMASK] |= (1 << n%BITMASK))
#define read_bit(a, n) (a[n/BITMASK] & (1<<n%BITMASK))

bool isOverlap(int x, int y, const ElemType *p, int n)
{
	int A[(LEN+31)/32] = {0};
	int i;
	for (i=0; i<n; i++)
	{
		for (int j=p[i].x; j<p[i].y; j++)
			set_bit(A, j);
	}
	for (i=x; i<=y; i++)
		if (read_bit(A, i) == 0)
			return 0;
	return 1;
}

void main()
{
	int x, y;
	while(scanf("%d%d", &x ,&y) != EOF)
	{
		int n;
		scanf("%d", &n);
		ElemType des[N];
		int i=0;
		while (i<n)
		{
			scanf("%d%d", &des[i].x, &des[i].y);
			i++;
		}
		
		bool ret = isOverlap(x, y, des, n);
		printf("%s\n", ret?"true":"false");
	}
}

l  方法四

用目标区间来消减源区间，遍历完目标区间，如果把源区间消减完，则源区间在目标区间内。比较麻烦的一点是，可能会把源区间分成多个区间。

为方便出来，可以用链表来表示源区间，这样分离出一个区间就添加一个节点，如果某个区间被消减了，就删除相应的节点。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/*
	输入：
	3 5        //第一行两个整数表示源区间
	5          //第二行一个整数表示目标区间个数n
	1 2       //接下来n行表示目标区间
	2 3
	3 5
	6 7
	7 8
	输出：
	true or false
*/
typedef struct  _elemType {
	int x, y;
}ElemType;

#define  N   50   //最大区间数
#define LEN 100 //区间最大长度



bool isOverlap(int x, int y, const ElemType *p, int n)
{
	typedef struct _tempType {
		ElemType region;
		struct _tempType *next;
	}TempType;
	TempType *head = (TempType *)malloc(sizeof(TempType));
	TempType *q, *t, *pre;
	head->region.x = x;
	head->region.y = y;
	head->next = NULL;

	int i;
	for (i=0; i<n; i++)
	{
		q = head, t=NULL, pre=head;
		while (q)
		{
			//目标区间在源区间的中间  --> 分割区间
			if (p[i].x > q->region.x && p[i].y < q->region.y)
			{
				t = (TempType *)malloc(sizeof(TempType));
				t->region.x = q->region.x;
				t->region.y = p[i].x;
				q->region.x = p[i].y;
				t->next = head;
				head = t;
			}
			//目标区间在源区间之外
			else if (p[i].y <= q->region.x || p[i].x >= q->region.y)
			{
				; //nothing tobe done
			}
			else 
			{
				//分割左边
				if (p[i].y <= q->region.y)
					q->region.x = p[i].y;
				else
					q->region.y = p[i].x;
			}
			t = NULL;
			if (q->region.x >= q->region.y)
			{
				t = q;
			}
			
			if (t)
			{
				q = q->next;
				free(t);
				if (t == head)
				{					
					head = NULL;
				}
				else
				{
					pre->next = q;
				}
			}
			else
			{
				pre = q;
				q = q->next;
			}
		}
		if (head == NULL)
			return 1;
	}
	t = head;
	while (t)
	{
		TempType *temp = t;
		t = t->next;
		free(temp);
	}
	return (head == NULL);

}

void main()
{
	int x, y;
	while(scanf("%d%d", &x ,&y) != EOF)
	{
		int n;
		scanf("%d", &n);
		ElemType des[N];
		int i=0;
		while (i<n)
		{
			scanf("%d%d", &des[i].x, &des[i].y);
			i++;
		}
		
		bool ret = isOverlap(x, y, des, n);
		printf("%s\n", ret?"true":"false");
	}
}


行云_
关注
专栏目录
C语言怎么算区间重叠部分,区间重合判断(C语言实现)
weixin_35900054的博客
05-20 1365
问题描述：给定一个源区间[x,y](y>=x)和N个无序的目标区间[x1,y1],[x2,y2],[x3,y3],......[xN,yN],判断源区间[x,y]是不是在目标区间内？例如给定源区间[1,6]和一组无序的目标区间[2,3],[1,2],[2,9],[3,4],即可认为区间[1,6]在区间[2,3],[1,2],[2,9],[3,4]内。解决方法：1.首先对无序的目标区间进行从小...
【编程之美】区间重合判断（线段树）
小田的专栏
08-04 8115
一，问题：        1. 给定一个源区间[x,y]和N个无序的目标区间[x1,y1] [x2,y2] ... [xn,yn]，判断源区间[x,y]是不是在目标区间内。        2. 给定一个窗口区域和系统界面上的N个窗口，判断这个窗口区域是否被已有的窗口覆盖。 二，解法：        问题一：                   先用区间的左边界值对目标区间进行排序
区间重合判定
Jarvan_Song的博客
08-30 1294
区间重合判定
区间重合判断 java_java判断多个区间是否有重合
最新发布
06-08
要判断多个区间是否有重合，可以按照起始点排序并逐一比较。以下是一个 Java 代码示例： ```java public class Interval { int start; int end; public Interval(int start, int end) { this.start = start; ...
［算法］区间重合判断
绝知此事要躬行
09-01 6562
题目描述： 给定一个源区间 ［x,y］和N个无序的目标区间[x1,y1],[x2,y2],...[xn,y,],判断给定的源区间［x,y］在不在目标区间内。 例如：给定源区间［1 6］和目标区间［1 2］［2 4］［4 9］即可认为区间［1 6］在目标区间内，因为源区间的并集为［1 9 ］. 试想一下，现在在这样的一个目标区间的集合， 需要频繁地去查询一个区间是否在该集合中。那么怎么样才
【编程之美】区间重合判断
JimmyCai0101的专栏
04-26 971
题目如下：给定一个源区间[x,y]和N个无序的目标区间[x1,y1] [x2,y2] ... [xn,yn]，判断源区间[x,y]是不是在目标区间内。
区间重合判断问题
送故事的妖怪
09-07 840
区间重合判断问题 问题描述:给定一个区间[x,y]和N个无序的目标区间[x1,y1][x2,y2]…[xn,yn]，判断源区间[x,y]是不是在目标区间内（即判断[x,y]属于目标区间的并集是否成立）。详细题目：《编程之美》章节2.19
区间重叠判断
Siegfried的博客
03-18 245
如何判断两个时间段， 两个线条是否重叠： min(A[startIndex], B[startIndex]) < max(A[endIndex], B[endIndex])
编程之美-2.19-区间重合判断
weixin_30644369的博客
07-15 196
1. 简述 给定一个源区间[x,y] (y>=x)和N个无序目标区间[x1,y1][x2,y2][x3,y3]...[xn][yn]，判断[x,y]是否在目标区间内。 2. 思路 这个比较简单，合并目标区间，判断源区间是否在目标区间内即可。具体过程如下：第一步，先把目标区间排序。 第二步，从第一个区间开始，遍历首先找到一个[xi,yi]，使得 x[i]...
编程之美区间重合判断
继续微笑lsj
09-19 2236
一，问题：     1. 给定一个源区间[x,y]和N个无序的目标区间[x1,y1] [x2,y2] ... [xn,yn]，判断源区间[x,y]是不是在目标区间内。      2. 给定一个窗口区域和系统界面上的N个窗口，判断这个窗口区域是否被已有的窗口覆盖。 编程之美的解法：首先利用快排没，将区间按照从小到大排序，[2,3][1,2][3,9]-》[1,2][2,3][3,9
编程之美 2.19 区间重合判断
decode
03-28 566
题目大意： 给定源区间[x, y] (x
编程之美——2.19 区间重合判断
Solidfish的专栏
09-16 3094
将区间按照x来排序（递增），然后依次判断目标区间的起始位置是否在这些区间上，例如判断区间 [a,b] 是否在区间 [c,d] , [e,f]之中，我们可以分析c d，e f的关系，按照之前所述的方法排好序之后[c,d] , [e,f]要么相交，要么相离。如果相交，那么e=d。由此可以看到只要判断a是否在 [c, d]之间就好，如果在就将a增加到d，然后循环判断，知道所有区间都被遍历一遍，如果所有区
计算两个区间是否重合 以及重合长度
weixin_43651292的博客
07-26 1799
Meeting Scheduler 一个很好的计算两个区间是否重合的方式,并可以计算重合点数据区间长度 计算头的最大值, 尾的最小值即可 int ibegin = slots1[i][0], iend = slots1[i][1], jbegin = slots2[j][0], jend = slots2[j][1]; int head = max(ibegin,jbegin), tail = min(iend,jend); tail-head ...
9、区间重合判断
llianlianpay的博客
04-17 1310
区间重合判断 给你一个target线段，判断它是否被已给出的一些线段所包含。 先排序，再将目标区间合并为一个或多个更大的区间，最后判断这些大区间是否可以覆盖源区间。 排序使用快速排序，排序后进行合并，例如比较y0和x1的大小可以判断两个相邻的目标区间是否有交集，如果有交集合并为一个大的区间。 最后再查找，看是否有满足 x &lt;= xi &amp;&amp; y &lt;...
「算法学习」：区间合并，多区间重合合并
老古懂的博客
04-24 1340
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。 题目来源：力扣（LeetCode） 输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]] 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]. 算法思想：首先对区间数组依照左闭合
区间重叠判断算法
热门推荐
romandion的专栏
05-10 1万+
一、背景     在一次业务开发中，发现有一种数据，每天都会有一个值，不论是否是节假日。由于这个值的变化频率比较低，导致会有连续的N个日期，值是相同的。于是，就想将这些值合并。比如原来的结构是二元组DATA(Value , Date)，合并成三元组DATA(Value , BeginDate , EndDate)。    合并完原始数据后，生成三元组DATA1，还要和已经存在的三元组DATA2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值