Something learned from leetcode （3）

41.Merge有序单链表
Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
递归解法：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 ==NULL)
        return l2;
        if(l2 ==NULL)
        return l1;

        if(l1->val <= l2->val)
        {
            l1->next=mergeTwoLists(l1->next,l2);
            return l1;
        }

        else
        l2->next=mergeTwoLists(l2->next,l1);
        return l2;

    }

非递归解法：
设置一个head节点，省去单独处理原来的头结点。
head
list1: 1–>3–>6
list2: 2–>5
l1 l2谁小把谁挂到新链表上

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode head(INT_MIN);
        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;

        }

        if(l1)
        p->next=l1;
        else
        p->next=l2;


        return head.next;   //head是一个节点，而不是指针。注意取next的方式
    }

from 21. Merge Two Sorted Lists
42.链表是否有环
快慢指针的典型应用有两种
1.检测是否成环
快慢指针中的快慢指的是移动的步长，即每次向前移动速度的快慢。例如可以让快指针每次沿链表向前移动2，慢指针每次向前移动1次。
让快慢指针从链表头开始遍历，快指针向前移动两个位置，慢指针向前移动一个位置;如果快指针到达NULL，说明链表以NULL为结尾，不是循环链表。如果 快指针追上慢指针，则表示出现了循环。
2.在有序链表中寻找中位数
快指针的移动速度是慢指针移动速度的2倍，因此当快指针到达链表尾时，慢指针到达中点。程序还要考虑链表结点个数的奇偶数因素。

bool hasCycle(ListNode *head) {

        if(head==NULL || head->next ==NULL)
        return false;

        ListNode* fast=head;
        ListNode* slow=head;

        fast=fast->next->next;
        slow=slow->next;

        while(true)
        {

            if(fast ==NULL || fast->next ==NULL)
            return false;

            if(fast ==slow || fast->next==slow)
            return true;

            fast=fast->next->next;
        slow=slow->next;

        }

    }

from 141. Linked List Cycle
43.找单链表环起点
Given a linked list, return the node where the cycle begins. If there is no cycle, return null
基于上题快慢指针找环，fast与slow相遇（fast==slow）时停止。将其中一个指向起点，两个指针每次同时向前移动一步，再次相遇时即为环起点。

    ListNode *detectCycle(ListNode *head) {

        if(head==NULL || head->next ==NULL)
        return NULL;

        ListNode* fast=head;
        ListNode* slow=head;

        fast=fast->next->next;
        slow=slow->next;

        while(true)
        {
            if(fast==NULL || fast->next ==NULL)
            return NULL;


            if(fast ==slow)  //区别与找环时的fast可以追上slow，此处一定要相遇
            break;

        fast=fast->next->next;
        slow=slow->next;

        }

        slow=head;


        while(slow !=fast){
            slow=slow->next;
            fast=fast->next;
        }

        return slow;


    }

from 142. Linked List Cycle II
44.二叉树路径
Path sum I: 是否存在根到叶子的路径使得加和等于指定值。
递归完成

bool hasPathSum(TreeNode* root, int sum) {
        if(root==NULL)
        return false;

    else if( root->left ==NULL && root->right==NULL && root->val==sum)
        return true;


    else return hasPathSum(root->left, sum-(root->val)) || hasPathSum(root->right, sum-(root->val));
    }

PathSum II : 给出I中符合条件的路径 如 {[1,2,3],[1,3,2]}

vector<vector<int>> pathSum(TreeNode* root, int sum) {
     vector <int> temp;
        vector<vector<int>> res;
        doPathSum(root,sum,res,temp);


        return res;
    }
//----------------------
void doPathSum(TreeNode *root, int sum,  vector<vector<int>> &res, vector<int> temp)
    {
        if(!root)
            return;

        temp.push_back(root->val);


        if(root->left ==NULL && root->right==NULL && root->val==sum)
            res.push_back(temp);

       doPathSum(root->left,sum-root->val,res,temp);

        doPathSum(root->right,sum-root->val,res,temp);

       temp.pop_back();  //删除vector最后的元素


    }

Path Sum III, 不用满足root到leaf， 是否存在向下的路径和等于指定值

int pathSum(TreeNode* root, int sum) {
        int res=0;


        if(root==NULL)
            return 0;

        dfs(root,sum,res);

        return res;
    }

    void doPathSum(TreeNode *root,int sum, int &res)
    {

        if(!root)
            return;
       // temp.push_back(root->val);

        if(root->val==sum)
        {res++;

        }
        doPathSum(root->left,sum-(root->val),res);

        doPathSum(root->right,sum-(root->val),res);

     //   temp.pop_back();

    }



    void dfs(TreeNode* root,int sum,int &res){
        if(root==NULL)
            return;
        stack<TreeNode*> s;
        s.push(root);
        TreeNode *p=s.top();
        while(!s.empty())
        {
            p=s.top();
            doPathSum(p,sum,res);
            s.pop();
            if(p->right)
            s.push(p->right);
            if(p->left)
            s.push(p->left);
        }


    }

from 112. Path Sum，113.Path Sum II, 437.Path Sum III
45. k sum问题

(1) 2 sum问题
数组中找出两个元素，和等于sum。要求给出所有结果（不重复）。
编程之美双指针法：
前提：数组有序，排序
若nums[head]+nums[tail]== sum, 保存结果且head++, tail--
若nums[head]+nums[tail]<sum，head++ 
若nums[head]+nums[tail]>sum, tail--
此时结果有重复，需要去重。两种去重技巧set唯一性和vector unique。

(2)3 sum问题转化为2 sum解决，排序后对于nums[0]，只需在后边找到2 sum等于-nums[0]的结果。依次处理 nums[1]... nums[n]。
**重要:** a b c d e 中，后边的元素不用考虑之前的元素
例如 对于b，只需考虑 c d e中的 2 sum，因为 ac ad  ae在 a的2 sum中已经考虑。

vector<vector<int>> threeSum(vector<int>& nums) {
        set<vector<int>> res;

        if(nums.size()<3)
            return vector<vector<int>>(res.begin(),res.end());
        sort(nums.begin(),nums.end());

    threeeTo2Sum(res,nums,0);
//    sort(res.begin(),res.end());
//vector<vector<int >>::iterator  //iter=unique(res.begin(),res.end());  
//unique把vector中重复元素放入vector结尾，并返回一个迭代器指向重复元素开始处。输入3 2 1 1 2 3，它的输出是1 2 3 2 3 3
//    res.erase(iter,res.end());  删除重复元素
        vector<vector<int>> ok(res.begin(),res.end());
        return ok;
    }
void threeeTo2Sum(set<vector<int>> &res, vector<int> &nums,int sum)
{
    for(int i=0;i<nums.size()-2;i++)
    {
        int top=i+1,tail=nums.size()-1;
        while(top<tail)
        {
            if(nums[top]+nums[tail]+nums[i]==sum)
            {
                vector <int> temp;
                temp.push_back(nums[i]);
                temp.push_back(nums[top]);
                temp.push_back(nums[tail]);
                res.insert(temp);
                top++;
                tail--;
                continue;
            }

            if(nums[top]+nums[tail]+nums[i]<sum)
                top++;
            else
                tail--;

        }
    }
}

去重代价非常高，leetcode ac时间超过500ms，使用另一种方法过滤重复对象：

vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;

        if(nums.size()<3)
            return vector<vector<int>>(res.begin(),res.end());
        sort(nums.begin(),nums.end());

    threeTo2Sum(res,nums,0);


        return res;
    }

   void threeTo2Sum(vector<vector<int>> &res, vector<int> &nums,int sum){
    for(int i=0;i<nums.size()-2;)
    {
        int top = i+1, tail = nums.size()-1;
            while(top<tail)
            {
                if(nums[i]+nums[top]+nums[tail]==sum)
                {
                    res.push_back({nums[i], nums[top], nums[tail]});
                    top++;
                    tail--;
                    while ((top < tail) && nums[top] == nums[top - 1]) top++;
                    while ((top < tail) && nums[tail] == nums[tail + 1]) tail--;
                }



               else if(nums[i]+nums[top]+nums[tail]<sum)
                {  //坑，调了两小时。一定要else if，若使用if，等于sum的情况会继续执行最下边的else语句块。
                    top++;
                    while(  (top<tail) && nums[top]==nums[top-1]) top++;
                }


                else
                {
                    tail--;
                    while(  (top<tail) && nums[tail]==nums[tail+1]) tail--;

                }
            }

        i++;
        while((i < nums.size()) && nums[i]==nums[i-1]) i++;



    }

}

from 15. 3Sum

46.单链表删除倒数第N个节点
输入：list: 1->2->3->4->5, and n = 2
输出：1->2->3->5
双指针一次遍历
1.pre向前移动n次，cur不动
2.若此时pre指向结尾空指针，则要删除的是头结点，返回head->next
3.同时向前移动pre和cur，pre指向最后一个节点时停止，此时cur指向要删除节点的上一个节点

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* pre=head;
        ListNode* cur=head;

        for(int i=0;i<n;i++)
        {
            pre=pre->next;
        }

        if(pre==NULL)
            return head->next;
        while( (pre->next) != NULL)
        {
            pre=pre->next;
            cur=cur->next;
        }
        cur->next=cur->next->next;

        return head;

    }

from 19. Remove Nth Node From End of List
47.括号匹配
遇到左括号入栈 ，遇到右括号 有两种情况：1. 此时栈空，返回不匹配 2. 栈顶元素是否是其对应的左括号，不是则不匹配。
栈顶元素必须把来的右括号消掉。

bool isValid(string s) {
        stack<char> a;
    if(s.size())
    {
        for(int i=0;i<s.size();i++)
        {
            if(s[i]=='(' || s[i]=='[' || s[i]=='{')
            a.push(s[i]);

            if(s[i]==')')
            {
                if(a.empty())
                    return false;
               else if(a.top()=='(')
                    a.pop();
                else
                    return false;
            }

            if(s[i]==']')
            {
                if(a.empty())
                    return false;
                else if(a.top()=='[')
                    a.pop();
                else
                    return false;
            }

            if(s[i]=='}')
            {
                if(a.empty())
                    return false;
              else  if(a.top()=='{')
                    a.pop();
                else
                    return false;
            }



        }
        if(a.empty())
        return true;
        else
            return false;

    }
           return true; 

    }

from 20. Valid Parentheses
48.最大连续子序列乘积
[2,3,-2,4]中 连续子序列[2,3]乘积最大
一次遍历做法： 访问到该节点时，以该节点为结尾的子序列乘积最大值 要么是该点本身，要么是该点乘以上一个节点的子序列最大值。 考虑负负得正，可能存在该点为负数，乘以上一个点最小值（负数）得到最大的可能，故还应保存每个点的乘积最小值。

int maxProduct(vector<int>& nums) {
            if(nums.size()==0)
            return 0;
        int maxArr[nums.size()]={nums[0]};
        int minArr[nums.size()]={nums[0]};
        int res=maxArr[0];


        for(int i=1;i<nums.size();i++)
        {
            maxArr[i]=max(nums[i],max(nums[i]*maxArr[i-1],nums[i]*minArr[i-1]));
            minArr[i]=min(nums[i],min(nums[i]*maxArr[i-1],nums[i]*minArr[i-1]));

            if(maxArr[i]>res)
            res=maxArr[i];
        }

        return res; 

    }

此思路同样可以应用与求最大子序列和(53. Maximum Subarray)
from 152. Maximum Product Subarray
49.背包问题(01)-动态规划
n个物品，从最后一个n-1开始考虑一直到0
（dp[i][j]表示当容量为j时，0-i号物品背包问题的最大价值）
若n-1能放进背包，该问题转化为子问题dp[n-1][j]=max(dp[n-1-1][j],dp[n-1-1][j-weight[n-1]]+value[n-1]) ，分别对应n-1号物品放不放进背包，比较他们的最大值。
边界条件为dp[0][j]的情况，此时能直接给出答案，若空间足够dp[0][j]=value[0],否则等于0。

使用一个二维数组存储中间结果，防止重复计算。

#include <iostream>
using namespace std;
int weight[] = {2,3,1,4,6,5};  
int value[] =  {5,6,5,1,19,7};
int capacity = 10;

int dp[500][500];//保存中间结果
//二维数组传参时不同于一维数组，形参中要指定数组范围
//如int zeroOnePack(int i,int j,int dp[500][500]){...}

int zeroOnePack(int i,int j){
    if(j<0)
    return 0;
    if(dp[i][j]!=-1)
    {return dp[i][j];}

    if(i==0)
    {
        if(weight[i]<=j)
        return value[i];
        else
        return 0;
    }
    if(j>=weight[i])
    {
    dp[i][j]=max(zeroOnePack(i-1,j),zeroOnePack(i-1,j-weight[i])+value[i]);
    return dp[i][j];
    }

    return zeroOnePack(i-1,j);
}
int main(){
for(auto&i:dp) //二维数组遍历，使用引用可修改数组的值
for(auto&j:i)   
j=-1;
cout<<zeroOnePack(sizeof(weight)/sizeof(int)-1,capacity)<<endl;;
}