leetcode others...

int maxProfit(vector<int> &prices) {
//Best Time to Buy and Sell Stock  
        if (prices.size() == 0)
        return 0;

    int low = prices[0];
    int profit = 0;

    for (int i = 1; i < prices.size(); ++i)
    {
        low = min(prices[i], low);
        profit = max(profit, prices[i] - low);
    }

    return profit;
    }

public int longestValidParentheses(String s) {
//Longest Valid Parentheses  )()())
    int maxLen = 0, last = -1;
    Stack<Integer> lefts = new Stack<Integer>();
    for (int i=0; i<s.length(); ++i) {
        if (s.charAt(i)=='(') {
            lefts.push(i);
        } else {
            if (lefts.isEmpty()) {
                // no matching left
                last = i;
            } else {
                // find a matching pair
                lefts.pop();
                if (lefts.isEmpty()) {
                    maxLen = Math.max(maxLen, i-last);
                } else {
                    maxLen = Math.max(maxLen, i-lefts.peek());
                }
            }
        }
    }
    return maxLen;
}

vector<int> twoSum(vector<int> &numbers, int target) {
//two sum 	4,4,5,3,2 target=8
        vector<int> result;
		if(numbers.size()==0) return result;
		map<int,set<int>> numMap;
		for(int i=0;i<numbers.size();i++)
		{
			numMap[numbers[i]].insert(i);
		}
		map<int,set<int>>::iterator it;
		set<int>::iterator setIt;
		for(int i=0;i<numbers.size();i++)
		{
			it=numMap.find(target-numbers[i]);
			if(it!=numMap.end())
			{
				for(setIt=it->second.begin();setIt!=it->second.end();setIt++)
				{
					if((*setIt)>i)
					{
						result.push_back(i+1);//index+1 
						result.push_back(*setIt+1);//index+1
						return result;
					}
				}
				
			}
		}
		return result;
}

vector<vector<int> > threeSum(vector<int> &num) {
//3 sum 
        vector<vector<int>> result;
        int n=num.size();
        if(n<=2) return result;
        sort(num.begin(),num.end());
        vector<int> resultItem(3);
        for(int i=0;i<=n-3;i++)
        {
            if(i>0&&num[i]==num[i-1]) continue;
            int target=-num[i];
            int j=i+1;
            int k=n-1;
            while(j<k)
            {
                if(num[j]+num[k]==target)
                {
                    resultItem[0]=num[i];
                    resultItem[1]=num[j];
                    resultItem[2]=num[k];
                    result.push_back(resultItem);
                    j++;
                    k--;
                    while(j<k&&num[j]==num[j-1])
                        j++;
                }
                else if(num[j]+num[k]>target)
                {
                    k--;
                }
                else
                {
                    j++;
                }
            }
        }
        return result;
    }
	
void merge(int A[], int m, int B[], int n) {
//Merge Sorted Array
        int i=m-1;int j=n-1;int k=m+n-1;
        while(i>=0&&j>=0)
        {
            A[k--]=A[i]>B[j]?A[i--]:B[j--];
        }
        while(j>=0)
        {
            A[k--]=B[j--];
        }
        return ;
    }

int removeElement(int A[], int n, int elem) {
//Remove Element
	int len = 0;
	for (int i = 0; i < n; i++)
	{   
		if (A[i] != elem)
			A[len++] = A[i];
	}
	return len;
}

//Merge Intervals
class myComp {
  public:
    bool operator()(const Interval &i1, const Interval &i2) {
      return i1.start < i2.start;
    }
};
class Solution {
public:
    vector<Interval> merge(vector<Interval> &intervals) {
        vector<Interval> result;
        int n=intervals.size();
        if(n==0) return result;
        sort(intervals.begin(),intervals.end(),myComp());
        result.push_back(intervals[0]);
        for(int i=1;i<n;i++)
        {
            if(intervals[i].start>result.back().end)
            {
                result.push_back(intervals[i]);
            }
            else
            {
                result.back().end=max(result.back().end,intervals[i].end);
            }
        }
        return result;
    }
};

//Insert Interval
 vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
            vector<Interval> result;
            if(intervals.size()==0) 
            {
                result.push_back(newInterval);
                return result;
            }
            int i=0;
            while(i<intervals.size()&&intervals[i].end<newInterval.start)
            {
                result.push_back(intervals[i++]);
            }
            result.push_back(newInterval);
            while(i<intervals.size())
            {
                if(intervals[i].start<=result.back().end)
                {
                    result.back().start=min(result.back().start,intervals[i].start);
                    result.back().end=max(result.back().end,intervals[i].end);
                    i++;
                }
                else
                {
                    result.push_back(intervals[i++]);   
                }
            }
            return result;
}

//Merge Two Sorted Lists
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(!l1) return l2;
        if(!l2) return l1;
        ListNode* head=NULL;
        if(l1->val>l2->val)
        {
            head=l1;
            l1=l1->next;
        }
        else
        {
            head=l2;
            l2=l2->next;
        }
        ListNode* p=head;
        while(l1&&l2)
        {
            if(l1->val>l2->val)
            {
                p->next=l1;
                l1=l1->next;
            }
            else
            {
                p->next=l2;
                l2=l2->next;
            }
            p=p->next;
        }
        while(l1)
        {
            p->next=l1;
            l1=l1->next;
            p=p->next;
        }
        while(l2)
        {
            p->next=l2;
            l2=l2->next;
            p=p->next;
        }
        return head;
}
//a recursive solution  Merge Two Sorted Lists
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) 
{
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
	if(!l1) return l2;
	if(!l2) return l1;
	
	ListNode* head=NULL;
	if(l1->val>l2->val)
	{
		head=l1;
		head->next=mergeTwoLists(l1->next,l2);
	}
	else
	{
		head=l2;
		head->next=mergeTwoLists(l1,l2->next);
	}
	return head;
}

//Remove Nth Node From End of List
ListNode *removeNthFromEnd(ListNode *head, int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(!head||n<=0) return head;
        
        int len=0;
        int first=head;
        int second=NULL;
        while(first)
        {
            len++;
            if(len==n+1)
            {
                second=head;
            }
            else if(len>n+1)
            {
                second=second->next;
            }
            first=first->next;
        }
        
        if(len==n) 
        {
            ListNode* temp=head;
            head=head->next;
            free(temp);
        }
        else
        {
            ListNode* temp=second->next;
            second->next=temp->next;
            free(temp);
        }
        return head;
    }
	
	//Add Two Numbers  (2 -> 4 -> 3) + (5 -> 6 -> 4)
	 ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(!l1) return l2;
        if(!l2) return l1;
        
        int carry=0;
        int num1=0;
        int num2=0;
        ListNode* head=NULL;
        ListNode* p=NULL;
        while(l1||l2||carry!=0)
        {
            num1=0;
            num2=0;
            if(l1)
            {
                num1=l1->val;
                l1=l1->next;
            }
            if(l2)
            {
                num2=l2->val;
                l2=l2->next;
            }
            int sum=num1+num2+carry;
            carry=sum/10;
            sum%=10;
            ListNode* node=new ListNode(sum);
            if(!head)
            {
                head=node;
                p=node;
            }
            else
            {
                p->next=node;
                p=p->next;
            }  
        }
        return head;
    }
	
	//Swap Nodes in Pairs
ListNode *swapPairs(ListNode *head) 
{
	if(!head||!head->next) return head;
	
	ListNode* second=head;
	ListNode* first=head->next;
	
	ListNode* next=first->next;
	first->next=second;
	second->next=swapPairs(next);
	return first;
}
//Partition List
 ListNode *partition(ListNode *head, int x) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(!head) return head;
        ListNode* p=head;
        ListNode* head1=NULL;
        ListNode* tail1=NULL;
        ListNode* head2=NULL;
        ListNode* tail2=NULL;
        while(p)
        {
            if(p->val<x)
            {
                if(!head1)
                {
                    head1=p;
                    tail1=p;
                }
                else
                {
                    tail1->next=p;
                    tail1=tail1->next;
                }
            }
            else
            {
                if(!head2)
                {
                    head2=p;
                    tail2=p;
                }
                else
                {
                    tail2->next=p;
                    tail2=tail2->next;
                }
            }
            p=p->next;
        }
    	if(tail1) tail1->next=NULL;
		if(tail2) tail2->next=NULL;

        if(head1)
        {
            tail1->next=head2;
            return head1;
        }
        else
        {
            return head2;
        }
    }
	
	int lengthOfLastWord(const char *s) {//Length of Last Word
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(!s) return 0;
        int lastlen=0;
        int currentlen=0;
        while(*s)
        {
            if(*s==' ')
            {
                if(currentlen!=0)
                {
                    lastlen=currentlen;
                }
                currentlen=0;
            }
            else
            {
                currentlen++;
            }
            s++;
        }
        if(currentlen!=0)
        {
            lastlen=currentlen;
        }
        return lastlen;
    }