57. Insert Interval

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].

Example 2:
Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].

This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].

AC代码如下：

// 简洁实现：
/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */




class Solution {
public:


    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {

        vector<Interval> result;

        if( newInterval.start > newInterval.end )
        {
            return intervals;
        }

        int len = intervals.size();

        if( 0 == len )
        {
            result.push_back(newInterval);
            return result;
        }

        for( int i = 0; i < len; i++ )
        {
            if( newInterval.end < intervals[i].start )
            {
               result.push_back( newInterval );

               while( i < len )
               {
                   result.push_back( intervals[i] );
                   i++;
               }

               return result;
            }
            else if( newInterval.start > intervals[i].end )
            {
                result.push_back( intervals[i] );
            }
            else 
            {
                newInterval.start = min( newInterval.start, intervals[i].start );
                newInterval.end = max( newInterval.end, intervals[i].end );

            }
        }

        result.push_back( newInterval );

        return result;

    }
};

// 我的复杂实现：

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */




class Solution {
public:

    inline bool isContains( Interval &src, Interval &dest )
    {
        if( src.start <= dest.start && src.end >= dest.end )
        {
            return true;
        }
        else 
        {
            return false;
        }
    }


    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {

        vector<Interval> result;

        if( newInterval.start > newInterval.end )
        {
            return intervals;
        }

        int len = intervals.size();

        if( 0 == len )
        {
            result.push_back(newInterval);
            return result;
        }

        int pFirst = -1;
        int pLast = -1;
        bool bNeedMerge = true;
        int pInsertPos = -1;
        int left = -1;
        int right = -1;

        int type = 0;
       // cout << len << endl;

        for( int i = 0; i < len; i++ )
        {
           // cout << "i=" << i << ' ' << endl;

            if( isContains( intervals[i], newInterval ) )  //不需要合并
            {
                return intervals;
            }

            if( 0 == i )
            {
                if( newInterval.end < intervals[i].start )
                {
                    bNeedMerge = false;
                    pInsertPos = i;
                    break;
                }
                else if( len - 1 == i )
                {
                    if( newInterval.start > intervals[i].end )
                    {
                        bNeedMerge = false;
                        pInsertPos = len;
                        break;
                    }

                    if( newInterval.start > intervals[ i - 1 ].end && newInterval.end < intervals[i].start )
                    {
                        bNeedMerge = false;
                        pInsertPos = i;
                        break;
                    }

                }

            }
            else if( len - 1 == i )
            {
                if( newInterval.start > intervals[i].end )
                {
                    bNeedMerge = false;
                    pInsertPos = len;
                    break;
                }

                if( newInterval.start > intervals[ i - 1 ].end && newInterval.end < intervals[i].start )
                {
                    bNeedMerge = false;
                    pInsertPos = i;
                    break;
                }

            }
            else 
            {
                if( newInterval.start > intervals[ i - 1 ].end && newInterval.end < intervals[i].start )
                {
                    bNeedMerge = false;
                    pInsertPos = i;
                    break;
                }
            }

            if( newInterval.start >= intervals[i].start && newInterval.start <= intervals[i].end )
            {
                left = intervals[i].start;
                type = 1;

            }
            else if( ( 0 == i && newInterval.start < intervals[i].start ) || ( i > 0 && newInterval.start > intervals[ i - 1 ].end && newInterval.start < intervals[i].start ) )
            {
                type = 2;
                left = newInterval.start;     

            }

            if( 1 == type )
            {
                if( newInterval.end >= intervals[i].start && newInterval.end <= intervals[i].end )
                {
                    right = intervals[i].end;
                }
                else if( -1 == right && i > 0 && newInterval.end > intervals[ i - 1 ].end && newInterval.end < intervals[i].start )
                {
                    right = newInterval.end;
                }


                if( newInterval.end >= intervals[i].start )
                {
                    right = intervals[i].end > newInterval.end ? intervals[i].end : newInterval.end;
                }

            }
            else if( 2 == type )
            {
                if( -1 == right && newInterval.end >= intervals[i].start && newInterval.end <= intervals[i].end )
                {
                    right = intervals[i].end;
                }
                else if( -1 == right && i > 0 && newInterval.end > intervals[ i - 1 ].end && newInterval.end < intervals[i].start )
                {
                    right = newInterval.end;
                }

                if( newInterval.end >= intervals[i].start )
                {
                     right = intervals[i].end > newInterval.end ? intervals[i].end : newInterval.end;
                }


            }


        }

        cout << "type=" <<  type << ' ' << "left=" << left << " right=" << right << endl;

        for( int i = 0; i < len; i++ )
        {
           if( !bNeedMerge )
           {
               if( i == pInsertPos )
               {
                   result.push_back(newInterval);
                   result.push_back( intervals[i] );
               }
               else if( i == len - 1 && pInsertPos == len )
               {
                   result.push_back( intervals[i] );
                   result.push_back(newInterval);
               }
               else
               {
                   result.push_back( intervals[i] );
               }
           }
           else
           {
               if( 1 == type )
               {
                   Interval tmp( left, right );

                   if( intervals[i].start == left )
                   {
                       result.push_back( tmp );
                   }
                  // else if( right >= intervals[i].end || ( right > intervals[i].start && right < intervals[i].end ) )
                   else if( isContains( tmp, intervals[i]) )
                   {
                       continue;
                   }
                   else
                   {
                       result.push_back(intervals[i]);
                   }
               }
               else if( 2 == type )
               {
                   Interval tmp( left, right );
                 //  cout << "11type=2->i=" << i << endl;
                  // static int flag = 0;

                   vector<Interval>::iterator ite = result.begin();
                   bool bfind = false;

                   for( ; ite != result.end(); ++ite )
                   {
                        Interval cur = *ite;

                        if( ( cur.start == left && cur.end == right ) )          
                        {
                            bfind = true;
                            break;
                        }
                   }   

                   if( !bfind && intervals[i].start > left )
                   {
                       result.push_back( tmp );
                       cout << "push once" << endl;
                     //  flag = 1;
                   }
                   else if( isContains( tmp, intervals[i] ) )
                   {
                       continue;
                   }
                   else
                   {
                       result.push_back( intervals[i] );
                       //cout << "22type=2->i=" << i << endl;
                   }

               }

           }

        }
        return result;
    }
};