LeetCode的medium题集合(C++实现)一

1.Two Sum
Given an array of integers, find two numbers such that they add up to a specific target number.You may assume that each input would have exactly one solution.
For example:Input: $numbers={2, 7, 11, 15}, target=9$
Output:$index1=1, index2=2$. 返回序号在原值上加1，防止为0.
分析：让数组的两的元素之和等于另一个数，可以先将数组排序，利用头尾两指针进行比较，这样时间复杂度为排序的$n\log n$,这里要输出两个元素的索引号，可以将索引号和值构成键值对，并按值大小进行排序。

vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> result;
        vector<pair<int,int> > mid;
        mid.reserve(numbers.size());
        vector<pair<int,int> >::iterator pos;
        vector<pair<int,int> >::iterator end;
        for(int i=0;i<numbers.size();i++)
        {
            mid.push_back(pair<int,int>(i+1,numbers[i]));
        }

        sort(mid.begin(),mid.end(),[&](const pair<int,int> &x, const pair<int,int> &y) -> bool 
        {  
           return x.second <y.second;  
        });
        for(pos=mid.begin(),end=mid.end()-1;pos!=end;)
        {
            if((pos->second+end->second)==target)
            {
               return vector<int>(  
            {min(pos->first, end->first),  
             max(pos->first, end->first)}); 
            }
            else
            {
                if((pos->second+end->second)>target)
                {
                    --end;
                }
                 else
                 {
                     ++pos;
                 }
            }
        }
    }

2.Add Two Numbers
You are given two linked lists representing two non-negative numbers. Add the two numbers and return it as a linked list.

ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        ListNode* mid=new ListNode(0);
        ListNode* tail=mid;
        int check=0,sum=0;
        while(l1!=NULL||l2!=NULL||check!=0)
        {
            int num1=l1==NULL?0:l1->val;
            int num2=l2==NULL?0:l2->val;
            sum=num1+num2+check;
            check=sum/10;
            sum=sum%10;
            tail->next=new ListNode(sum);
            tail=tail->next;
            if(l1!= NULL)l1=l1->next;
            if(l2!= NULL)l2=l2->next;
        }
        return mid->next;
    }

3.Longest Substring Without Repeating Characters
Given a string, find the length of the longest substring without repeating characters.For example, the longest substring without repeating letters for “abcabcbb” is “abc”, the length is 3.
分析：将字符串中的字符逐个插入vector容器中，当遇到相同的字符时，将容器中的该字符及它以前的字符删除，用一个变量记录容器中存在过的最大值。

int lengthOfLongestSubstring(string s) {
        vector<char> sub;
        if(s.size()==0)
        return 0;
        sub.reserve(s.size());
        vector<char>::iterator result;
        int max=0;

        sub.push_back(s[0]);
        for(int i=1;i<s.size();i++)
        {
            result=find(sub.begin(),sub.end(),s[i]);
            if(result==sub.end())
            {
                sub.push_back(s[i]);
            }
            else
            {
               max=(max<sub.size())?sub.size():max;
               if (result == sub.begin())
               {
                sub.erase(result);
               }
            else{ sub.erase(sub.begin(), result+1); }
               sub.push_back(s[i]);
            }
        }
        max=(max<sub.size())?sub.size():max;
        return max;
    }

4.Longest Palindromic Substring
Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.
这是一个动态规划问题，用一个二维bool数组dp[i][j]来记录从s[i]到s[j]组成的子串是否为回文。当$s[i]==s[j]$时，$dp[i][j]=dp[i+1][j-1]$，否则$dp[i][j]=false$.

string longestPalindrome(string s) {
    int len = s.length(), maxbegin = 0, maxlen = 1;
    vector<vector<bool> > dp(len, vector<bool>(len));;
    for (int i = 0; i<len; i++)
        dp[i][i] = true;   //单个字符是回文
    for (int i = 0; i<len - 1; i++)
    {
        if (s[i] == s[i + 1])
        {
            dp[i][i + 1] = true;
            maxbegin = i;
            maxlen = 2;
        }
    }
    for (int i = len - 3; i >= 0; i--)
    {
        for (int j = i + 2; j<len; j++)
        {
            if (s[i] == s[j] && dp[i + 1][j - 1])
            {
                dp[i][j] = true;
                maxbegin = i;
                maxlen = j - i + 1;
            }
        }
    }
    return s.substr(maxbegin, maxlen);
}