编程之美——2.19 区间重合判断

/**

 * 给定一个源区间[x, y](y >= x)和N个无序的目标区间[x1, y1], [x2, y2], …, [xn, yn], 判断源区间[x, y]是不是在目标区间内

 * eg, 给定一个源区间[1, 6]和一组无序的目标区间[2, 3][1, 2][3, 9], 即可认为[1, 6]在区间[2, 3][1, 2][3, 9]内(因为目标区间合并之后, 实质为[1, 9])

 */

#include <stdio.h>

struct Area {

int begin;

int end;

};

void FastSort(struct Area *interval, int begin, int end) {

int i, j;

struct Area temp;

if (begin >= end)

return ;

i = begin;

j = end;

temp = interval[i];

while(i < j) {

while(i < j && temp.begin <= interval[j].begin) {

if (temp.begin == interval[j].begin) {

if (interval[j].end >= temp.end)

–j;

else

break;

} else {

–j;

}

}

interval[i] = interval[j];

while(i < j && temp.begin >= interval[i].begin) {

if (temp.begin == interval[i].begin) {

if (interval[i].end <= temp.end)

++i;

else

break;

} else {

++i;

}

}

interval[j] = interval[i];

}

interval[i] = temp;

FastSort(interval, begin, i – 1);

FastSort(interval, i + 1, end);

}

/**

 * 法一: 首先我想到的方法是将目标区间的序列中的区间合并起来, 尽可能合并所有的区间, 当剩余的区间无法合并之后, 遍历目标区间, 然后判断源区间是否在其中的某个目标区间中.

 * 首先对目标区间进行排序操作, 以x坐标为主关键字进行排序, 当x坐标相同时, 再以y坐标为关键字进行排序.

 * 当源区间在目标区间中时, 返回1; 不在返回0

 * 复杂度分析: 采用快速排序, 时间复杂度为O(N * logN), 然后遍历一次区间序列, 将可以合并的区间合并, 同时判断该区间是否包含源区间, 时间复杂度为O(N), 因此总的时间复杂度为O(N + N * logN).

 * 书中给出的解法二与我的方法类似, 首先给序列排序, 然后合并, 然后查找, 但是书中的方法是将合并与查找的过程分开了, 增加了时间复杂度.

 * 在我的算法中遍历时, 从第一个区间开始合并, 当合并到与下一个区间不相邻时, 判断合并到现在的区间是否包含目标区间:

 * 若包含, 返回1; 

 * 若未包含, 则判断目标区间是否与合并区间交叉存在(即 area.begin <= source.begin <= area.end, source.end > area.end), 若是, 返回1.

 * 若未包含且不交叉存在, 则给area赋值为序列中的下一个区间, 重新开始合并判断.

 */

int Judgement(struct Area *destination, struct Area source, int N){

struct Area area;

int i = 0;

FastSort(destination, 0, N – 1);

area.begin = destination[0].begin;

area.end = destination[0].end;

i = 1;

while(i < N) {

while(i < N && area.end >= destination[i].begin) {

if (area.end < destination[i].end)

area.end = destination[i].end;

++i;

}

if (area.begin <= source.begin && area.end >= source.end)

return 1;

if (area.begin <= source.begin && source.begin <= area.end && source.end > area.end)

return 0;

if (i < N) {

area.begin = destination[i].begin;

area.end = destination[i].end;

}

}

return 0;

}

int main() {

//struct Area destination[] = {{2, 3}, {1, 2}, {3, 9}};

//struct Area destination[] = {{2, 3}, {1, 2}, {3, 9}, {1, 2}, {3, 5}};

struct Area destination[] = {{2, 3}, {1, 2}, {4, 9}};

struct Area source = {1, 6};

printf(“%d\n”, sizeof(destination) / sizeof(struct Area));

if (Judgement(destination, source, sizeof(destination) / sizeof(struct Area)))

printf(“源区间在目标区间中\n”);

else

printf(“源区间不在目标区间中\n”);

return 0;

}

    原文作者:mxk19930509
    原文地址: https://blog.csdn.net/u011387543/article/details/81013242
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞