腾讯精选50题—Day8题目62,70,78

腾讯精选50题—Day8题目62,70,78

  今天是刷题的第八天，冲鸭~~

1. 题目62 不同路径

(1) 题目描述

(2) 思路

  解法1：动态规划；
  解法2：组合公式，机器人从起始点到达终止点一共有两种操作——向下和向右，迷宫为m*n，那么向下的操作一共有m-1次，向右的操作一共有n-1次，一共有m+n-2次操作，转换为求：
$$C_{m+n-2}^{m-1}$$

(3) 题解

  解法1：动态规划

class Solution {
public:
    int uniquePaths(int m, int n) {

        vector<vector<int>> laby(m, vector<int>(n, 0));
        
        for (int i = 0; i < m; i++)
        {
            laby[i][0] = 1;
        }
        for (int i = 0; i < n; i++)
        {
            laby[0][i] = 1;
        }
        for (int i = 1; i < m; i++)
        {
            for (int j = 1; j < n; j++)
            {
                laby[i][j] = laby[i - 1][j] + laby[i][j - 1];
            }
        }
        return laby[m - 1][n - 1];
        
    }
};

结果：

时间复杂度：$O(mn)$
空间复杂度：$O(mn)$

  解法2：组合公式（result需要用long long int存）

class Solution {
public:
    int uniquePaths(int m, int n) {

        int par1 = m + n - 2;
        int mon1 = m - 1;
        long long int result = 1;

        for (int i = 1; i < n; i++)
        {
            result = result * (m + i - 1)/ i;
        }
        return result;
    }
};

结果：

时间复杂度：$O(n)$
空间复杂度：$O(1)$

2. 题目70 爬楼梯

(1) 题目描述

(2) 思路

  两种思路，第一个是递归，递推关系式为：
$$f(x)=f(x-1)+f(x-2),x>1$$但因为时间复杂度过高…运行超时；第二种思路是分析数据的产生，假设0号位和1号位都为1，那么到达2号位一共两种方法(1+1或者2)，到达3号位的方法数相当于2号位和1号位之和，依此类推。

(3) 题解

class Solution {
public:
    int climbStairs(int n) {

        int pre1 = 1;
        int pre2 = 1;
        int result = 0;

        if (n <= 1)
            return 1;

        for (int i = 2; i <= n; i++)
        {
            result = pre1 + pre2;
            pre1 = pre2;
            pre2 = result;
        }
        return result;
    }
};

结果：

时间复杂度：$O(n)$
空间复杂度：$O(1)$

3. 题目78 子集

(1) 题目描述

(2) 思路

  思路1：巧妙使用位运算。
  思路2：递归

(3) 题解

思路1：

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<int> temp;
        vector<vector<int>> result;
        int len = nums.size();

        for (int mask = 0; mask < (1 << len); mask++)
        {
            temp.clear();
            for (int i = 0; i < len; i++)
            {
                if (mask & (1 << i))
                {
                    temp.push_back(nums[i]);
                }
            }
            result.push_back(temp);
        }
        return result;

    }
};

结果：

时间复杂度：$O(n\ast 2^n)$
空间复杂度：$O(n)$

思路2：递归

class Solution {
public:
    vector<int> temp;
    vector<vector<int>> result;

    vector<vector<int>> subsets(vector<int>& nums) {
        
        int len = nums.size();
        dfs(0, len, nums);
        return result;
    }
    void dfs(int k, int n, vector<int>& nums)
    {
        if (k == n)
        {
            result.push_back(temp);
            return;
        }
        temp.push_back(nums[k]);
        dfs(k + 1, n, nums);
        temp.pop_back();
        dfs(k + 1, n, nums);
    }
};

结果：

时间复杂度：$O(n\ast 2^n)$
空间复杂度：$O(n)$ （包含辅助数组n和栈空间n）