Merge Intervals & *Longest Palindromic Substring & Multiply Strings

(1) Merge Intervals

先对区间按照左边界排序，然后顺序扫描，合并重叠的区间即可。 在原区间数组上操作，不使用额外的空间，但是需要删除多余的区间，这样会移动数组元素。[1]

bool comp(Interval a,Interval b) {
        return a.start < b.start;
    }
    
class Solution {
    
public:
    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;
    }
};

(2) Longest Palindromic Substring 

动态规划，时间复杂度O(n*n)，C++的超时了，Java版本倒是可以过（这不科学！）

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.size()<=1)
            return s;
            
        int n=s.size();
        int maxi,maxj,maxlen=1;
        vector<vector<bool>> dp(n,vector<bool>(n,false));
        
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                if(i>=j)
                    dp[i][j]=true;
        
        for(int len=1;len<n;len++)
            for(int i=0;i+len<n;i++)
            {   
                int j=i+len;
                if(s[i]!=s[j])
                    dp[i][j]=false;
                else
                {
                    dp[i][j]=dp[i+1][j-1];
                    if(dp[i][j] && len+1>maxlen)
                    {
                        maxi=i;
                        maxj=j;
                        maxlen=len+1;
                    }
                }
            }

        return s.substr(maxi,maxlen);
    }
};

另外有O(n)的算法[2]。

(3) Multiply Strings 

先翻转字符串便于从低位开始计算。模拟乘法的运算过程，把中间结果存在data中，最后在考虑data的进位并存到结果字符串里。注意点的就是考虑结果的前置0不要添加进去。[3]

class Solution {
public:
    string multiply(string num1, string num2) {
         reverse(num1.begin(),num1.end());
        reverse(num2.begin(),num2.end());
        int data[10000];
        memset(data,0,sizeof(data));
        int len1=num1.length();
        int len2=num2.length();
        int i,j;
        for(i=0;i<len1;++i)for(j=0;j<len2;++j)
        {
            data[j+i]+=(num1[i]-'0')*(num2[j]-'0');
        }
        int p,temp;
        i=p=0;
        while(i<len1+len2-1||p!=0)
        {
            temp=data[i]+p;
            data[i]=temp%10;
            p=temp/10;
            ++i;
        }
        string result;
        bool flag=0;
        for(;i>=0;--i)
        {
            if(flag==0&&data[i]==0)continue;
            else
            {
                flag=1;
                result+=(char)(data[i]+'0');
            }
        }
        if(flag==0)return "0";
        else return result;
    }
};

参考：

[1] http://www.cnblogs.com/TenosDoIt/p/3714681.html
[2] http://blog.csdn.net/hopeztm/article/details/7932245

[3] http://blog.csdn.net/havenoidea/article/details/12086339