LeetCode 2016 45,57,414,413,289,106,105

45 Jump Game II

class Solution {
public:
    int jump(vector<int>& nums)
    {
        int len=nums.size();
        if (len==1) return 0;
        int ans=0,maxPos=0,lastmax=0;
        for(int i=0;i<len-1;i++)
        {
            maxPos=max(maxPos,i+nums[i]);
            if (i==lastmax)
            {
                ans++;
                lastmax=maxPos;
            }
        }
        return ans;
    }
};

57 Insert Interval

class Solution {
public:
    static bool cmp(const struct Interval &x,const struct Interval &y)
    {
        return x.start<y.start;
    }
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval)
    {
        vector<Interval> ans;
        intervals.push_back(newInterval);
        int len=intervals.size();
        sort(intervals.begin(),intervals.end(),cmp);
        for(int i=0;i<len;)
        {
            int j;
            bool flag;
            for(j=i+1;j<len;j++)
            {
                flag=false;
                if (intervals[j].end <= intervals[i].end)
                {
                    flag=true;
                }
                else
                if (intervals[j].start <= intervals[i].end)
                {
                    intervals[i].end=intervals[j].end;
                    flag=true;
                }
                else
                {
                    break;
                }

            }
            ans.push_back(intervals[i]);
            if (flag) i=j+1; else i=j;

        }
        return ans;
    }
};

414 Third Maximum Number

class Solution {
public:
    int thirdMax(vector<int>& nums)
    {
        int len=nums.size();
        set<int> s;
        for(int i=0;i<len;i++)
        {
            s.insert(nums[i]);
        }
        if (s.size()>=3)
        {
            int p=0;
            for(set<int>::reverse_iterator it=s.rbegin();it!=s.rend();it++)
            {
                p++;
                if (p==3)
                {
                    return (*it);
                }
            }
        }
        else
        {
            set<int>::reverse_iterator it=s.rbegin();
            return (*it);
        }
        return 0;
    }
};

413 Arithmetic Slices

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) 
    {
        int ans=0;
        int len=A.size();
        if (len<3) return ans;
        int f[len+10]={0};
        if (A[2]-A[1] == A[1]-A[0]) f[2]=1;
        ans+=f[2];
        for(int i=3;i<len;i++)
        {
            if (A[i]-A[i-1]==A[i-1]-A[i-2])
            { 
                f[i]=f[i-1]+1;
                ans+=f[i];
            }
        }
        return ans;
    }
};

289 Game of Life

class Solution {
public:
    void gameOfLife(vector<vector<int> >& board)
    {
        int dx[8]={0,0,1,-1,-1,1,1,-1};
        int dy[8]={1,-1,0,0,-1,1,-1,1};
        vector<vector<int> >grid = board;
        int row=board.size();
        if (row==0) return;
        int col=board[0].size();
        for(int i=0;i<row;i++)
        {
            for(int j=0;j<col;j++)
            {
                int cnt=0;
                for(int k=0;k<8;k++)
                {
                    int x=dx[k]+i,y=dy[k]+j;
                    if (x>=0 && x<row && y>=0 && y<col)
                    {
                        if(grid[x][y]==1) cnt++;
                    }
                }
                if (cnt<2) board[i][j]=0;
                else
                    if (cnt>3) board[i][j]=0;
                    else
                        if (cnt==3) board[i][j]=1;
            }
        }
        return ;
    }
};

106 Construct Binary Tree from Inorder and Postorder Traversal

class Solution {
public:
    vector<int> post;
    map<int,int> inmap;
     TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
    {
        if (postorder.size()==0 || inorder.size()==0) return NULL;
        inmap.clear();
        for(int i=0;i<inorder.size();i++)
            inmap[inorder[i]]=i;
        post=postorder;
        return constructTree(0,inorder.size()-1,0,post.size()-1);
    }

    TreeNode* constructTree(int inStart,int inEnd,
                            int postStart,int postEnd)
    {
        if (inEnd<inStart || postEnd<postStart) return NULL;
        TreeNode* root = new TreeNode(post[postEnd]);
        int inIndex = inmap[post[postEnd]];
        root->left=constructTree(inStart,inIndex-1,
                                 postStart,postStart+inIndex-inStart-1);
        root->right=constructTree(inIndex+1,inEnd,
                                  postStart+inIndex-inStart,postEnd-1);
        return root;
    }
};

105 Construct Binary Tree from Preorder and Inorder Traversal

class Solution {
public:
    vector<int> pre;
    map<int,int> inmap;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder)
    {
        if (preorder.size()==0 || inorder.size()==0) return NULL;
        inmap.clear();
        for(int i=0;i<inorder.size();i++)
            inmap[inorder[i]]=i;
        pre=preorder;
        return constructTree(0,inorder.size()-1,0,pre.size()-1);
    }

    TreeNode* constructTree(int inStart,int inEnd,
                            int preStart,int preEnd)
    {
        if (inEnd<inStart || preEnd<preStart) return NULL;
        TreeNode* root = new TreeNode(pre[preStart]);
        int inIndex = inmap[pre[preStart]];
        root->left=constructTree(inStart,inIndex-1,
                                 preStart+1,preStart+inIndex-inStart);
        root->right=constructTree(inIndex+1,inEnd,
                                  preStart+inIndex-inStart+1,preEnd);
        return root;
    }
};