3.5《LeetCode零基础指南》第二三讲学习反思

一、

1492. n 的第 k 个因子

难度中等22收藏分享切换为英文接收动态反馈

给你两个正整数 n 和 k 。

如果正整数 i 满足 n % i == 0 ，那么我们就说正整数 i 是整数 n 的因子。

考虑整数 n 的所有因子，将它们 升序排列 。请你返回第 k 个因子。如果 n 的因子数少于 k ，请你返回 -1 。

解法略。

---------------------------------------------------------------------------------------------------------------------------------

二、

367. 有效的完全平方数

难度简单350收藏分享切换为英文接收动态反馈

给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

进阶：不要 使用任何内置的库函数，如  sqrt 。

思路：平方数应该想到牛顿迭代法

假设求num为完全平方数，设一个数为x，此时x为num，再将以下数进行反复求Xi+1即可得到根号num。

class Solution {
public:
    bool isPerfectSquare(int num) {
        if(num>=2147483647)return false;
        double ret1=(num+1)/2,ret0=ret1;
        while(ret1==ret0)
        {
            ret1=(ret0+num/ret0)/2;
            if((int)ret0==(int)ret1&&(int)ret1*(int)ret1==num)
            {
                return true;
            }
            if((int)ret0==(int)ret1&&(int)ret1*(int)ret1!=num)
            {
                return false;
            }
            ret0=ret1;
        }
        return false;
    }
};

时间复杂度为O（logn）

空间为O（1）

---------------------------------------------------------------------------------------------------------------------------------

三、

33. 搜索旋转排序数组

难度中等1887

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

示例 3：

输入：nums = [1], target = 0
输出：-1

提示：

• 1 <= nums.length <= 5000
• -10^4 <= nums[i] <= 10^4
• nums 中的每个值都 独一无二
• 题目数据保证 nums 在预先未知的某个下标上进行了旋转
• -10^4 <= target <= 10^4

进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？

思路：本题采用二分搜索，无论从那里切一刀，都可以发现有一个数组必定有序，有一个必定无序或只有一个元素，这样我们就可以从中间切开。如果第一个数和比中间的数小，则前半数组为有序，后半为无序，若目标数大于第一数小于中间数，则在牵前数组找，若不在这个范围，则可以确定目标数大于中间数，为使得中间数为目标数，只要将中间数向中间移动，移动的方式可以将mid+1，中间数会向右移动，若中间数等于目标数，返回下标即可；同理右边。

class Solution {
public:
int search(vector<int>& nums, int target)
{
    int n=(int)nums.size();
    if(n==0)
        return -1;
    if(n==1)
    {
        if(nums[0]==target)return 0;
        else return -1;
    }
    int start=0,end=n-1;
    while(start<=end)
    {
        int mid=(start+end)/2;
        if(nums[mid]==target)
            return mid;
        if(nums[start]<=nums[mid])
        {
            if(nums[start]<=target&&target<nums[mid])
            {
                end=mid-1;
            }
            else if (target > nums[mid] || target < nums[start])
            {
                start=mid+1;
            }
        }
        else
        {
            if(nums[mid]<target&&target<=nums[end])
            {
                start=mid+1;
            }
             else if (target < nums[mid] || target > nums[end])
            {
                end=mid-1;
            }
        }
    }
    return -1;
}
};

---------------------------------------------------------------------------------------------------------------------------------

四、

81. 搜索旋转排序数组 II

难度中等552

已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

你必须尽可能减少整个操作步骤。

示例 1：

输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true

示例 2：

输入：nums = [2,5,6,0,0,1,2], target = 3
输出：false

提示：

• 1 <= nums.length <= 5000
• -104 <= nums[i] <= 104
• 题目数据保证 nums 在预先未知的某个下标上进行了旋转
• -104 <= target <= 104

进阶：

• 这是 搜索旋转排序数组 的延伸题目，本题中的 nums  可能包含重复元素。
• 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

思路：参考上面代码，若中间数和开头start相同，start++，跳过开头数进入下一个数，为什么？

因为开头数一定是又数更大的右侧转移过来的，若开头数和中间数相同，意味着中间数后所有的数都等于中间数等于开头数，删除开头数后对整体结果不影响。

class Solution {
public:
    bool search(vector<int>& nums, int target) {
            int n=(int)nums.size();
    if(n==0)
        return false;
    if(n==1)
    {
        if(nums[0]==target)return true;
        else return false;
    }
    int start=0,end=n-1;
    while(start<=end)
    {
        int mid=(start+end)/2;
        if(nums[mid]==target)
            return true;
        if(nums[start]==nums[mid])
        {
            start++;
            continue;
        }
        if(nums[start]<=nums[mid])
        {
            if(nums[start]<=target&&target<nums[mid])
            {
                end=mid-1;
            }
            else if (target > nums[mid] || target < nums[start])
            {
                start=mid+1;
            }
        }
        else
        {
            if(nums[mid]<target&&target<=nums[end])
            {
                start=mid+1;
            }
             else if (target < nums[mid] || target > nums[end])
            {
                end=mid-1;
            }
        }
    }
    return false;
    }
};

---------------------------------------------------------------------------------------------------------------------------------

五、

153. 寻找旋转排序数组中的最小值

难度中等679

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

• 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
• 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。

示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

• n == nums.length
• 1 <= n <= 5000
• -5000 <= nums[i] <= 5000
• nums 中的所有整数 互不相同
• nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

class Solution {
public:
int findMin(vector<int>& nums) {
        int n=nums.size();
        if(n==1)return nums[0];
        int start=0,end=n-1;
        while(start<end)
        {
            int mid=(start+end)/2;
            if(nums[mid]>nums[end])
            {
                start=mid+1;
            }
            else
            {
                end=mid;
            }
        }
        return nums[start];
    }
};

---------------------------------------------------------------------------------------------------------------------------------

六、

70. 爬楼梯

难度简单2234

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

思路：简单的动规，爬上第n阶=第n-1阶走1阶+第n-2阶走2阶；

class Solution {
public:
    int climbStairs(int n) {
        int a[n+1];
        a[0]=1;
        a[1]=1;
        for(int i=2;i<=n;i++)
        {
            a[i]=a[i-1]+a[i-2];
        }
        return a[n];

    }
};

---------------------------------------------------------------------------------------------------------------------------------

七、

509. 斐波那契数

难度简单409

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

思路：同上题

class Solution {
public:
    int fib(int n) {
        if(n==0)return 0;
        int dp[n+1];
        dp[0]=0;
        dp[1]=1;
        for(int i=2;i<n+1;i++)
        {
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
};

---------------------------------------------------------------------------------------------------------------------------------

八、

1137. 第 N 个泰波那契数

难度简单183

泰波那契序列 Tn 定义如下： 

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2

给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

示例 1：

输入：n = 4
输出：4
解释：
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4

示例 2：

输入：n = 25
输出：1389537s

思路：简单题

class Solution {
public:
    int tribonacci(int n) {
        if(n==0)return 0;
        if(n==1)return 1;
        int dp[n+1];
        dp[0]=0;
        dp[1]=1;
        dp[2]=1;
        for(int i=3;i<n+1;i++)
        {
            dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
        }
        return dp[n];
    }
};

---------------------------------------------------------------------------------------------------------------------------------