初级算法——动态规划、设计问题

动态规划：

1.爬楼梯

（1）递归

这种超时了QAQ

class Solution {
public:
    int climbStairs(int n) {
        if (n == 1)return 1;
        if (n == 2) return 2;
        return climbStairs(n - 1) + climbStairs(n - 2);
    }
};

（2）尾递归

class Solution {
public:
    int climbStairs(int n) {
        return fib(n, 1, 1);
    }
    int fib(int n, int a, int b)
    {
        if (n <= 1)
            return b;
        return fib(n - 1, b, a + b);
    }
};

（3）迭代

class Solution {
public:
    int climbStairs(int n) {
        int q = 0, p = 0, r = 1;
        for (int i = 0; i < n; ++i)
        {
            q = p;
            p = r;
            r = p + q;
        }
        return r;
    }

};

2.买卖股票的最佳时机

（1）动态规划

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>>dp(len, vector<int>(2, 0));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < len; i++)
        {
            dp[i][0] = max(dp[i - 1][1] + prices[i], dp[i - 1][0]);
            dp[i][1] = max(dp[i - 1][1], -prices[i]);
        }
        return dp[len - 1][0];
    }
};

（2）暴力for循环（超时了）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxprofit = 0, profit = 0;
        for (int i = 0; i < prices.size() - 1; ++i)
        {
            for (int j = i + 1; j < prices.size(); ++j)
            {
                profit = prices[j] - prices[i];
                if (profit > maxprofit)
                {
                    maxprofit = profit;
                }
            }
        }
        return maxprofit;
    }
};

（3）寻找历史最低价

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxprofit = 0, minprice = 1e9;
        for (auto it : prices)
        {
            maxprofit = max(maxprofit, it - minprice);
            minprice = min(it, minprice);
        }
        return maxprofit;
    }
};

3.最大子序和

（1）动态规划

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int pre = 0;
        int maxp = nums[0];
        for (auto v : nums)
        {
            pre = max(v + pre, v);
            maxp = max(maxp, pre);
        }
        return maxp;
    }
};

4.打家劫舍

（1）动态规划

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.empty())return 0;
        int len = nums.size();
        if (len == 1)
        {
            return nums[0];
        }
        vector<int>dp(len, 0);
        if (len == 2)
        {
            return max(nums[0], nums[1]);
        }
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for (int i = 2 ;i <len;++i)
        {
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[len - 1];
    }
};

（2）滚动数组

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.empty())return 0;
        int len = nums.size();
        if (len == 1)
        {
            return nums[0];
        }
        if (len == 2)
        {
            return max(nums[0], nums[1]);
        }
        int n = nums[0];
        int m = max(nums[0], nums[1]);
        for (int i = 2 ;i <len;++i)
        {
            int temp = m;
            m = max(n + nums[i], m);
            n = temp;

        }
        return m;
    }
};

设计问题：

1.打乱数组

（1）洗牌算法

class Solution {
public:
    Solution(vector<int>& nums) {
        data = nums;
    }

    vector<int> reset() {
        return data;
    }

    vector<int> shuffle() {
        vector<int>shuffling(data);
        for (int i = 0; i < shuffling.size(); ++i)
        {
            swap(shuffling[i], shuffling[rand() % (i + 1)]);
        }
        return shuffling;
    }
    vector<int>data;
};

2.最小栈

（1）辅助栈

利用辅助栈存取最小值

class MinStack {
public:
    stack<int>x_stack;
    stack<int>min_stack;
    MinStack() {
        this->min_stack.push(INT_MAX);
    }

    void push(int val) {
        this->x_stack.push(val);
        this->min_stack.push(min(min_stack.top(), val));
    }

    void pop() {
        this->x_stack.pop();
        this->min_stack.pop();
    }

    int top() {
        return x_stack.top();
    }

    int getMin() {
        return min_stack.top();
    }
};