Insert Interval & *Regular Expression Matching & Binary Tree Maximum Path Sum

(1) Insert Interval 

利用merge intervals的成果：

bool comp(Interval a,Interval b) {
        return a.start < b.start;
    } 

class Solution {
private:
    vector<Interval> merge(vector<Interval> &intervals) {
        
        sort(intervals.begin(), intervals.end(), comp);
        
        if(intervals.size()<=1)
            return intervals;
        
        vector<Interval>::iterator t1=intervals.begin(),t2=t1+1;
        
        while(t1!=intervals.end() && t2!=intervals.end())
        {
            if(t1->end >= t2->start)
            {
                t1->end= max(t1->end,t2->end);
                t2++;    
            }
            else
            {
                t1=intervals.erase(t1+1,t2);
                t2=t1+1;
            }
        }
        
        if(t1!=intervals.end())
            intervals.erase(t1+1,t2);
        
        return intervals;
    }

public:
    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
        intervals.push_back(newInterval);
        
        return merge(intervals);
    }
};

(2) Regular Expression Matching 

对于S[i]和P[j]：
如果P[j+1]!='*'，S[i] == P[j]=>匹配下一位(i+1, j+1)，S[i]!=P[j]=>匹配失败；
如果P[j+1]=='*'，S[i]==P[j]=>匹配下一位(i+1, j+2)或者(i, j+2)，S[i]!=P[j]=>匹配下一位(i,j+2)。
匹配成功的条件为S[i]=='\0' && P[j]=='\0'。[1]

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        if(*p=='\0')
            return *s=='\0';
        
        if(*(p+1)=='*')
        {
            while(*s!='\0' && (*s==*p || *p=='.'))
            {
                if(isMatch(s,p+2))
                    return true;
                s++;
            }
            return isMatch(s,p+2);
        }
        else
        {
            if(*s!='\0' && (*s==*p || *p=='.'))
                return isMatch(s+1,p+1);
        }
        return false;
    }
};

(3) Binary Tree Maximum Path Sum

递归计算每个节点的Maximum Path Sum：[2]

class Solution {
private:
    int recursive(TreeNode *root, int &Max) {
        if(root==NULL)
            return 0;
        
        int leftMax=recursive(root->left,Max);
        int rightMax=recursive(root->right,Max);
        int rootMax=leftMax+root->val+rightMax;
        int RootToParentMax=max(root->val,max(leftMax,rightMax)+root->val);
        Max=max(Max,max(rootMax,RootToParentMax));
        return RootToParentMax;
    }

public:
    int maxPathSum(TreeNode *root) {
        int Max=-32767;
        recursive(root,Max);
        return Max;
    }
};

参考：

[1] http://blog.csdn.net/pickless/article/details/9043389

[2] http://blog.csdn.net/fightforyourdream/article/details/16894069