LeetCode 2016 313,264,95,224,279,275,274

313 Super Ugly Number

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes)
    {
        vector<long long int> cnt(primes.size(),0);
        vector<long long int> result(n,0);
        result[0]=1;
        for(int i=1;i<n;i++)
        {
            long long int curVal=LONG_LONG_MAX;
            for(int j=0;j<primes.size();j++)
                curVal=min(curVal,primes[j]*result[cnt[j]]);
            result[i]=curVal;
            for(int j=0;j<primes.size();j++)
                if (primes[j]*result[cnt[j]]==curVal)
                    cnt[j]++;
        }
        return result[n-1];
    }
};

264 Ugly Number II

法一： 优先队列实现小根堆+set判断重复

class Solution {
public:
    long long int nthUglyNumber(long long int n)
    {
        priority_queue<long long int, vector<long long int>, greater<long long int> > q;
        set<long long int> flag;
        q.push(1);
        flag.insert(1);
        if (n==1) return q.top();
        for(long long int i=1;i<n;i++)
        {
            long long int minVal= q.top();
            q.pop();
            long long int num2=minVal*2,num3=minVal*3,num5=minVal*5;
            if (flag.find(num2)==flag.end())
            {
                q.push(num2);
                flag.insert(num2);
            }
            if (flag.find(num3)==flag.end())
            {
                q.push(num3);
                flag.insert(num3);
            }
            if (flag.find(num5)==flag.end())
            {
                q.push(num5);
                flag.insert(num5);
            }
        }
        return q.top();
    }
};

法二：使用set和lower_bound

class Solution {
public:
    int nthUglyNumber(int n)
    {
        set<long long int> ugly;
        ugly.insert(1);
        long long int minUgly=0;
        for(int i=1;i<=n;i++)
        {
            minUgly=*ugly.lower_bound(minUgly+1);
            ugly.insert(minUgly*2);
            ugly.insert(minUgly*3);
            ugly.insert(minUgly*5);
        }
        return minUgly;
    }
};

95 Unique Binary Search Trees II

class Solution {
public:
    vector<TreeNode*> generateTrees(int n)
    {
        vector<TreeNode*> result;
        if(n==0) return result;
        return bisearch(1,n);
    }

    vector<TreeNode*> bisearch(int s,int e)
    {
        if(s>e) return vector<TreeNode*>(1,NULL);
        vector<TreeNode*> result;
        for(int i=s;i<=e;i++)
        {
            vector<TreeNode*> left,right;
            left=bisearch(s,i-1);
            right=bisearch(i+1,e);
            for(int m=0;m<left.size();m++)
                for(int n=0;n<right.size();n++)
                {
                    TreeNode* root=new TreeNode(i);
                    root->left=left[m];
                    root->right=right[n];
                    result.push_back(root);
                }
        }
        return result;
    }
};

224 Basic Calculator

class Solution {
public:
    bool isDigits(char c)
    {
        if (c>='0' && c<='9') return true;
        return false;
    }
    int compute(stack<int>& operands, stack<char>& operators)
    {
        int ans=0;
        int num1=operands.top();
        operands.pop();
        int num2=operands.top();
        operands.pop();
        if (operators.top()=='+') ans=num1+num2;
        else
            if (operators.top()=='-') ans=num1-num2;
        operators.pop();
        operands.push(ans);
    }
    int calculate(string s)
    {
        stack<int> operands;
        stack<char> operators;
        s='('+s+')';
        for(int i=s.size()-1;i>=0;)
        {
            if (s[i]==')' || s[i]=='+' || s[i]=='-')
            {
                operators.push(s[i]);
                i--;
            }
            else if (isDigits(s[i]))
            {
                int j=i;
                for(;j>=0 && isDigits(s[j]);j--);
                operands.push(atoi(s.substr(j+1,i-j+1).c_str()));
                i=j;
            }
            else if (s[i]=='(')
            {
                while (operators.top()!=')')
                {
                     compute(operands,operators);
                }
                operators.pop();
                i--;
            }
            else i--;
        }
        return operands.top();
    }
};

279 Perfect Squares

class Solution {
public:
    int numSquares(int n)
    {
        if (n==0) return 0;
        vector<int> per;
        int f[n+5]={0};
        f[1]=1;
        for(int i=2;i<=n;i++)
        {
            int minV=INT_MAX;
            int j=1;
            while (j*j<=i)
            {
                if (j*j==i)
                {
                    minV=1;break;
                }
                minV=min(minV,f[i-j*j]+1);
                j++;
            }
            f[i]=minV;
        }
        return f[n];
    }
};

275 H-Index II

法一：使用递归，来回传参数，太麻烦，不够简洁

class Solution {
public:
    int ans=-INT_MAX;
    int len;
    int hIndex(vector<int>& citations)
    {
        len=citations.size();
        if (len==0) return 0;
        binarySearch(0,len-1,citations);
        return ans;
    }
    void binarySearch(int left,int right,vector<int>& citations)
    {
        if (left>right) return ;
        int mid=(right-left)/2+left;
        int m=min(citations[mid],len-mid);
        if (m>ans) ans=m;
        if (citations[mid]>len-mid) binarySearch(left,mid-1,citations);
        else binarySearch(mid+1,right,citations);
        return ;
    }
};

法二：不使用递归，不用来回传参数，也不用记录最大值。

class Solution {
public:
    int hIndex(vector<int>& citations)
    {
        int len=citations.size();
        if (len==0) return 0;
        int left=0,right=len;
        while (left<right)
        {
            int mid=(right-left)/2+left;
            if (citations[mid]>=len-mid) right=mid;
            else left=mid+1;
        }
        return len-right;
    }
};

274 H-Index

class Solution {
public:
    int hIndex(vector<int>& citations)
    {
        if (citations.size()==0) return 0;
        int ans=-INT_MAX;
        sort(citations.begin(),citations.end());
        for(int i=citations.size()-1;i>=0;i--)
        {
            //cout<<"i= "<<i<<",count= "<<citations.size()-i<<endl;
            //cout<<"value= "<<citations[i]<<endl;
            int tmp;
            if (citations.size()-i<citations[i])
                tmp = citations.size()-i;
            else tmp=citations[i];
            if (tmp>ans) ans=tmp;
        }
        return ans;
    }
};