LeetCode 2015.7.20 148,150,151,152,153,208,209,162,236

LeetCode 2015.7.20 148,150,151,152,153,208,209,162,236

148 Sort List


class Solution {
public:
    struct Node {
        int val;
        int cnt;
        Node* next;
        Node(int x) : val(x),cnt(1),next(NULL) {}
    };

    ListNode* sortList(ListNode* head) {
        if (head==NULL) return NULL;
        Node* shead = new Node(head->val);
        Node* sp;
        Node* tmpsp;
        ListNode* p=head->next;
        while (p!=NULL)
        {

            if (p->val < shead->val)
            {
                Node* node2 = new Node(p->val);
                node2->next=shead;
                shead=node2;
                p=p->next;
                continue;
            }
            sp = shead;
            tmpsp = sp;
            while ((sp!=NULL)&&(sp->val < p->val))
            {
                tmpsp=sp;
                sp=sp->next;
            }
            if (tmpsp->val == p->val)
                tmpsp->cnt = tmpsp->cnt+1;
            else
            {
                Node* node = new Node(p->val);
                node->next=tmpsp->next;
                tmpsp->next=node;
            }
            p=p->next;
        }
        ListNode* h = new ListNode(0);
        ListNode* x = h;
        while (shead!=NULL)
        {
            for(int i=1;i<=shead->cnt;i++)
            {
                ListNode* n = new ListNode(shead->val);
                x->next = n;
                x=x->next;
            }
            shead = shead->next;
        }
        return h->next;
    }
};

150 Evaluate Reverse Polish Notation
class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        bool flag[300]={0};
        flag['+']=true;
        flag['-']=true;
        flag['*']=true;
        flag['/']=true;
        stack<int> s;
        while (!s.empty()) s.pop();
        for(int i=0;i<tokens.size();i++)
        {
            if ((tokens[i].size()==1) && (flag[tokens[i][0]]))
            {
                int p2=s.top();
                s.pop();
                int p1=s.top();
                s.pop();
                int ans;
                switch (tokens[i][0])
                {
                case '+':
                    ans = p1 + p2;
                    break;
                case '-':
                    ans = p1 - p2;
                    break;
                case '*':
                    ans = p1 * p2;
                    break;
                case '/':
                    ans = p1 / p2;
                    break;
                }
                s.push(ans);
            }
            else
            {
                int number = atoi(tokens[i].c_str());
                s.push(number);
            }
        }
        return s.top();
    }
};

151 Reverse Words in a String
class Solution {
public:
    void reverseWords(string &s) {
        if (s.size()==0) return ;
        vector<string> ans;
        ans.clear();
        if (s[0]!=' ') s=' '+s;
        bool flag = false;
        string tmpstr="";
        for(int i=0;i<s.size();i++)
        {
            if (s[i]==' ')
            {
                flag = false;
                continue;
            }
            if (!flag)
            {
                ans.push_back(tmpstr);
                tmpstr="";
                flag=true;
            }
            if (flag)
            {
                tmpstr=tmpstr+s[i];
            }
        }
        if (ans.size()==0)
        {
            s="";
            return ;
        }
        if (tmpstr!="") ans.push_back(tmpstr);
        s=ans[ans.size()-1];
        for(int i=ans.size()-2;i>0;i--)
        {
            s=s+" ";
            for(int j=0;j<ans[i].size();j++)
                s=s+ans[i][j];
        }
        return ;
    }
};

152 Maximum Product Subarray
class Solution {
public:
    int maxProduct(vector<int>& nums) {
        vector<int> f,g;
        int ans=-INT_MAX;
        f.clear();
        g.clear();
        g.push_back(1);
        f.push_back(1);
        for(int i=0;i<nums.size();i++)
        {
            int tmp=max(nums[i],f[i]*nums[i]);
            tmp=max(tmp,g[i]*nums[i]);
            f.push_back(tmp);
            tmp=min(nums[i],f[i]*nums[i]);
            tmp=min(tmp,g[i]*nums[i]);
            g.push_back(tmp);
            if (f[i+1]>ans) ans=f[i+1];
        }
        return ans;
    }
};

153 Find Minimum in Rotated Sorted Array
class Solution {
public:
    int findMin(vector<int>& nums) {
        int left=0,right=nums.size()-1;
        while (left<=right)
        {
            if (left==right) return nums[left];
            if (left+1==right) return min(nums[left],nums[right]);
            int mid=(left+right)/2;
            if (nums[mid]<nums[left] && nums[mid]<nums[right])
                right=mid;
            else
            {
                if (nums[left]<nums[right])
                    right=mid-1;
                else
                    left=mid+1;
            }
        }
        return 0;
    }
};

208 Implement Trie (Prefix Tree)
class TrieNode {
public:
    // Initialize your data structure here.
    TrieNode* child[27];
    bool word;
    TrieNode() {
        word=false;
        for(int i=1;i<=26;i++)
            child[i]=NULL;
    }
};

class Trie {
public:
    Trie() {
        root = new TrieNode();
    }

    // Inserts a word into the trie.
    void insert(string word) {
        TrieNode* tmproot=root;
        for(int i=0;i<word.size();i++)
        {
            int ch=word[i]-'a'+1;
            if (tmproot->child[ch]!=NULL)
            {
                tmproot=tmproot->child[ch];
                continue;
            }
            else
            {
                TrieNode* tmpnode = new TrieNode();
                tmproot->child[ch]= tmpnode;
                tmproot=tmpnode;
            }
        }
        tmproot->word=true;
    }

    // Returns if the word is in the trie.
    bool search(string word) {
        TrieNode* tmproot=root;
        for(int i=0;i<word.size();i++)
        {
            int ch=word[i]-'a'+1;
            if (tmproot->child[ch]==NULL) return false;
            tmproot=tmproot->child[ch];
        }
        return tmproot->word;
    }

    // Returns if there is any word in the trie
    // that starts with the given prefix.
    bool startsWith(string prefix) {
        TrieNode* tmproot=root;
        for(int i=0;i<prefix.size();i++)
        {
            int ch=prefix[i]-'a'+1;
            if (tmproot->child[ch]==NULL) return false;
            tmproot=tmproot->child[ch];
        }
        return true;
    }

private:
    TrieNode* root;
};

209 Minimum Size Subarray Sum
class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        if (nums.size()==0) return 0;
        vector<int> sum;
        sum.clear();
        sum.push_back(0);
        sum.push_back(nums[0]);
        for(int i=1;i<nums.size();i++)
        {
            sum.push_back(sum[i]+nums[i]);
        }
        if (sum[sum.size()-1]<s) return 0;
        if (sum[sum.size()-1]==s) return nums.size();
        for(int k=1;k<nums.size();k++)
        {
            for(int i=k;i<sum.size();i++)
                if (sum[i]-sum[i-k]>=s) return k;
        }
        return 0;
    }
};

162 Find Peak Element
class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int left = 0,right = nums.size()-1;
        while (left<=right){
            if (left==right)
                return left;
            int mid=(left+right)/2;
            if (nums[mid]<nums[mid+1])
                left=mid+1;
            else
                right=mid;
        }
    }
};

236 Lowest Common Ancestor of a Binary Tree
class Solution {
public:
    stack<TreeNode*> s[2];
    bool stop;

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while (!s[0].empty()) s[0].pop();
        while (!s[1].empty()) s[1].pop();

        stop = false;
        depthsearch(0,root,p);
        stop = false;
        depthsearch(1,root,q);

        set<TreeNode*> common;
        common.clear();
        while(!s[0].empty())
        {
            common.insert(s[0].top());
            s[0].pop();
        }
        while(!s[1].empty())
        {
            if (common.find(s[1].top())!=common.end())
                return s[1].top();
            s[1].pop();
        }
    }
    void depthsearch(int flag,TreeNode* root,TreeNode* x)
    {
        if (stop) return ;
        s[flag].push(root);
        if (root==x)
        {
            stop = true;
            return ;
        }
        if (root->left!=NULL)
            depthsearch(flag,root->left,x);
        if (root->right!=NULL)
            depthsearch(flag,root->right,x);
        if (!stop) s[flag].pop();
    }
};