《LeetCode零基础指南》(第四讲) 一维数组

33. 搜索旋转排序数组

这道题直接的思路当然就是暴力循环。但是细想，他是一个有单调性的数组呀，我们可不能辜负了题目这样的良苦用心。

旋转后的数组放在坐标里长这样。我们可以很明显的发现他总体一定只有两种情况：目标值在左边和在右边（先暂时不考虑不存在的情况）然后依此我们就可以把这个旋转数组当成两个正常数组来看，两边的分界就是是否所有的元素都大于或都小于数组中第一个元素

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l=0,r=nums.size()-1;
        bool st=target>=nums[0];//true在左半段，false在右半段
        while(l<r) {
            int mid=l+r+1>>1;
            if(nums[mid]<=target) {
                if(st&&nums[mid]<nums[0]) {
                    //当目标值在左半段，中间值在右半段，就让右端点等于中间值减一
                    r=mid-1;
                }
                else {
                    l=mid;
                }
            }
            else {
                if(!st&&nums[mid]>=nums[0]) {
                    l=mid+1;
                }
                else {
                    r=mid-1;
                }
            }
        }
        if(l>nums.size()-1) return -1;
        else if(nums[l]==target) return l;
        return -1;
    }
};

81. 搜索旋转排序数组 II

和上一道题总体的思路一样，但是因为这道题没有保证所有值不同，所以就可能出现这种情况

（红色线段表示数组中的值）也就是说可能会出现前面几个数字和最后几个数字是一样的，这样我们用第一个值做分界值就有点不合适了。那么怎么办呢？索性就把最后几个数字都去掉吧

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int l=0,r=nums.size()-1;
        while(r>=0&&nums[r]==nums[0]) r--;
        //和上一道题一样，只是这里最后一个（几个）数可能和最前面一个（几个）数字一样，所以要先把后面的去掉
        bool st=target>=nums[0];//true在左半段，false在右半段
        while(l<r) {
            int mid=l+r+1>>1;
            cout<<mid<<endl;
            if(nums[mid]<=target) {
                if(st&&nums[mid]<nums[0]) {
                    r=mid-1;
                }
                else {
                    l=mid;
                }
            }
            else {
                if(!st&&nums[mid]>=nums[0]) {
                    l=mid+1;
                }
                else {
                    r=mid-1;
                }
            }
        }
        if(l>nums.size()-1) return false;
        else if(nums[l]==target) return true;
        return false;
    }
};

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

没有重复值的旋转数组？那么还是第一题的图。最小值就是一二段的分界点，和第一个值比较二分。

class Solution {
public:
    int findMin(vector<int>& nums) {
        int l=0;
        int r=nums.size()-1;
        while(l<r)
        {
            int mid=l+r>>1;
            if(nums[mid]<nums[0]) r=mid;
            else l=mid+1;
        }
        if(nums[r]>nums[0]) return nums[0];
        return nums[l];
    }
};

70. 爬楼梯

裸的斐波那契问题

class Solution {
public:
    int f[110]={0};
    int cul(int n)
    {
        if(f[n]||n==0) return f[n];
        return f[n]=cul(n-1)+cul(n-2);
    }
    int climbStairs(int n) {
        f[1]=1,f[2]=2;
        return cul(n);
    }
};

509. 斐波那契数

斐波那契数列：a[i]=a[i-1]+a[i-2]

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

1137. 第 N 个泰波那契数

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

2006. 差的绝对值为 K 的数对数目

不用什么华丽丽的方法，暴力循环

int countKDifference(int* nums, int numsSize, int k){
    int cnt=0;
    for(int i=0;i<numsSize;i++) {
        for(int j=i;j<numsSize;j++) {
            if(abs(nums[i]-nums[j])==k) cnt++;
        }
    }
    return cnt;
}

LCP 01. 猜数字

一一比对即可

class Solution {
public:
    int game(vector<int>& guess, vector<int>& answer) {
        int ans=0;
        for(int i=0;i<guess.size();i++) {
            if(guess[i]==answer[i]) ans++;
        }
        return ans;
    }
};

LCP 06. 拿硬币

有点小贪心把，能拿俩一定拿俩，如果最后还剩一个，那么再加一

class Solution {
public:
    int minCount(vector<int>& coins) {
        int ans=0;
        for(auto t:coins) {
            if(t%2) ans++;
            ans+=t/2;
        }
        return ans;
    }
};