leecode 解题总结：56. Merge Intervals

#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>

using namespace std;
/*
问题:
Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

分析：题目要求归并有重叠部分的区间，这是典型的贪心算法问题。
先对区间进行排序，按照先对区间第一个元素从小到大排序；如果第一个元素仙童，对区间第二个元素从小
到大排序，判断当前区间的右边是否 < 下一个区间的左边，
1】不合并
2】否则，如果当前区间的右边<下一个区间的右边，则更新当前区间右边元素=下一个区间右边元素

输入:
4(区间个数)
1 3 
2 6 
8 10
15 18

2
1 4
1 4

2
1 4
0 4
1
1 3
输出:
1 6,8 10,15 18
1 4
1 3
关键:
1 维护上一次连续重叠区间的end值，如果发现当前区间.star <= end，就更新end为max(end ,当前区间.end)
  否则，就建立一个区间，并更新start和end为当前区间的start和end,因为是该区间不交叉。
2 注意添加最后一个区间
		int start = intervals.at(0).start;
		int end = intervals.at(0).end;
		//记录上一个区间的end,如果当前区间start <= end,则更新end为当前区间.end和end中最大值
		//否则建立一个新的区间
		for(int j = 1 ; j < size ; j++)
		{
			//无需归并，将当前区间压入结果集,例如[1,3]遇到[4,6]
			if(intervals.at(j).start <= end)
			{
				end = max(end , intervals.at(j).end);
			}
			else
			{
				Interval newInterval(start , end);
				result.push_back(newInterval);
				//更新起始值为当前区间起始值，因为是当前区间不重叠
				start = intervals.at(j).start;
				end = intervals.at(j).end;
			}
		}
		//添加最后一个区间
		Interval newInterval(start , end);
		result.push_back(newInterval);
*/



struct Interval {
     int start;
     int end;
     Interval() : start(0), end(0) {}
     Interval(int s, int e) : start(s), end(e) {}
};

bool compare(Interval& in1 , Interval& in2)
{
	if(in1.start != in2.start)
	{
		return in1.start < in2.start;
	}
	else
	{
		return in1.end < in2.end;
	}
}

class Solution {
public:
    vector<Interval> merge(vector<Interval>& intervals) {
		vector<Interval>  result;
        if(intervals.empty())
		{
			return result;
		}
		//如果只有一个元素直接输出结果
		if(intervals.size() == 1)
		{
			return intervals;
		}
		//贪心：先排序
		sort(intervals.begin() , intervals.end() , compare);
		int size = intervals.size();
		int start = intervals.at(0).start;
		int end = intervals.at(0).end;
		//记录上一个区间的end,如果当前区间start <= end,则更新end为当前区间.end和end中最大值
		//否则建立一个新的区间
		for(int j = 1 ; j < size ; j++)
		{
			//无需归并，将当前区间压入结果集,例如[1,3]遇到[4,6]
			if(intervals.at(j).start <= end)
			{
				end = max(end , intervals.at(j).end);
			}
			else
			{
				Interval newInterval(start , end);
				result.push_back(newInterval);
				//更新起始值为当前区间起始值，因为是当前区间不重叠
				start = intervals.at(j).start;
				end = intervals.at(j).end;
			}
		}
		//添加最后一个区间
		Interval newInterval(start , end);
		result.push_back(newInterval);
		return result;
    }
};

void print(vector<Interval>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << result.at(i).start << " "<< result.at(i).end << "," ;
	}
	cout << endl;
}

void process()
{
	 vector<Interval> intervals;
	 int num;
	 Solution solution;
	 vector<Interval> result;
	 int start;
	 int end;
	 while(cin >> num )
	 {
		 intervals.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> start >> end;
			 Interval interval(start , end);
			 intervals.push_back(interval);
		 }
		 result = solution.merge(intervals);
		 print(result);
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}