问题:
给定多个不重合的间隔(interval),比如 [3, 8] [ 12, 17] [22, 29], 然后插入一个新的间隔, 比如 [ 5, 15], 求最后不重合的间隔。比如,起初的不重合间隔变成 [3, 17] [22, 29].
分析:
首先,我们要知道怎么确定两个间隔是重合的。比如[1, 5] [3, 7] 是重合的,[1, 5] [6, 7] 是不重合的。那么,观察后发现,如果两个间隔的起始值的最大值小于两个间隔的结束值的最小值,那么,这两个间隔一定重合。代码如下:
/*
* s1: start point of interval 1
* e1: end point of interval 1
* s2: start point of interval 2
* e2: end point of interval 2
*/
public boolean overlap(int s1, int e1, int s2, int e2) {
return Math.max(s1, s2) < Math.min(e1, e2);
}
假定给定的间隔按照起始值已经排序了,就是说第一个间隔的起始值是所有间隔起始值中最小的,最后一个间隔的起始值是所有间隔起始值中最大的。当插入一个新的间隔时,我们只需要判断它是否和每一个间隔相交,如果不相交,保持不变,如果相交,则把新的间隔求出来,再继续和后面的间隔进行判断。代码如下:
public class Test {
//check whether the two intervals intersect
public boolean overlap(Interval i1, Interval i2) {
return Math.max(i1.start, i2.start) < Math.min(i1.end, i2.end);
}
//add the new interval to the interval list and return a new interval list without overlapping
public ArrayList<Interval> add(ArrayList<Interval> list, Interval interval) {
ArrayList<Interval> newList = new ArrayList<Interval>();
int i = 0;
while (i < list.size()) {
//no intersection
if (overlap(list.get(i), interval) == false) {
newList.add(list.get(i));
i++;
} else {
//get the new interval
while (i < list.size() && overlap(list.get(i), interval) == true) {
int start = Math.min(list.get(i).start, interval.start);
int end = Math.max(list.get(i).end, interval.end);
interval = new Interval(start, end);
i++;
}
newList.add(interval);
}
}
return newList;
}
public static void main(String[] args) {
ArrayList<Interval> list = new ArrayList<Interval>();
list.add(new Interval(3, 8));
list.add(new Interval(22, 29));
list.add(new Interval(12, 17));
list.add(new Interval(40, 47));
Collections.sort(list);
Interval interval = new Interval(40, 48);
Test test = new Test();
ArrayList<Interval> newList = test.add(list, interval);
for(Interval inter : newList) {
System.out.println("[" + inter.start + ", " + inter.end + "]");
}
}
}
class Interval implements Comparable<Interval>{
int start;
int end;
Interval(int start, int end) {
this.start = start;
this.end = end;
}
public int compareTo(Interval o) {
if (start > ((Interval)o).start ||
(start == ((Interval)o).start && end > ((Interval)o).end)) {
return 1;
} else if (start == ((Interval)o).start && end == ((Interval)o).end) {
return 0;
}
return -1;
}
}
Another solution
/**
* Definition for an interval.
* public class Interval {
* int start;
* int end;
* Interval() { start = 0; end = 0; }
* Interval(int s, int e) { start = s; end = e; }
* }
*/
public class Solution {
public ArrayList<Interval> insert(ArrayList<Interval> intervals, Interval newInterval) {
ArrayList<Interval> listAfterMerged = new ArrayList<Interval>();
if (intervals == null || intervals.size() == 0) {
listAfterMerged.add(newInterval);
return listAfterMerged;
}
boolean isAdded = false;
for (int i = 0; i < intervals.size(); i++) {
Interval interv = intervals.get(i);
if (isAdded == false) {
if (interv.start < newInterval.start) {
addInterval(listAfterMerged, interv);
} else {
addInterval(listAfterMerged, newInterval);
isAdded = true;
addInterval(listAfterMerged, interv);
}
} else {
addInterval(listAfterMerged, interv);
}
}
if (isAdded == false) {
addInterval(listAfterMerged, newInterval);
}
return listAfterMerged;
}
public void addInterval(ArrayList<Interval> listAfterMerged, Interval newInterval) {
if (listAfterMerged.size() == 0) {
listAfterMerged.add(newInterval);
}
Interval interv = listAfterMerged.get(listAfterMerged.size() - 1);
if (interv.end >= newInterval.start) {
interv.end = (int) Math.max(interv.end, newInterval.end);
} else {
listAfterMerged.add(newInterval);
}
}
boolean isOverlap(Interval i1, Interval i2) {
if (Math.max(i1.start, i2.start) <= Math.min(i1.end, i2.end)) return true;
return false;
}
}
转载请注明出处:http://blog.csdn.net/beiyeqingteng