每日刷题 Day05

题一：最后一个单词的长度
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。

示例 1：
输入：s = “Hello World”
输出：5
示例 2：
输入：s = " fly me to the moon "
输出：4
示例 3：
输入：s = “luffy is still joyboy”
输出：6

提示：
1 <= s.length <= 104
s 仅有英文字母和空格 ’ ’ 组成
s 中至少存在一个单词

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/length-of-last-word

思路：从前往后寻找并不方便，故从后往前遍历字符串，计算最后一个单词的长度。

class Solution {
public:
    int lengthOfLastWord(string s) {
        int len=0;
        int i=s.size()-1;
        while(i>=0){
            if(s[i]==' ')
                i--;    //先确定最后一个单词的末尾位置    
            else
                break;
        }
        for(;i>=0;i--){
            if(s[i]!=' ')
                len++;
            else
                break;
        }
        return len;
    }
};

题二：爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。

示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/climbing-stairs

思路：爬n阶楼梯的方法数，就等于爬n-1阶楼梯的方法数和爬n-2阶楼梯方法数的和。故相当于斐波那契数列，设f(0)=1,f(1)=1,f(n)=f(n-2)+f(n-1)。

class Solution {
public:
    //利用动态规划,相当于斐波纳契数列
    int climbStairs(int n) {
        std::vector<double> nums(n+1);
        for(int i=0;i<=n;i++){
            if(i==0||i==1){
                nums[i]=1;
            }
            else{
                nums[i]=nums[i-2]+nums[i-1];
            }
            
        }
        return nums[n];
    }
};

题三：合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
示例 3：
输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

提示：
nums1.length ==m+n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-109 <= nums1[i], nums2[j] <= 109

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-sorted-array

思路：将nums2数组复制到nums1数组末尾，再利用冒泡排序，进行非递减排序

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i=0,j=0;
        int temp;
        for(i=m;i<m+n&&j<n;i++){    //将nums2数组中的元素复制到nums1数组的末尾
            nums1[i]=nums2[j];
            j++;
        }
        int visit=0;
        //使用冒泡排序的思路
        for(i=0;i<m+n-1;i++){       //最多执行m+n-1次可完成排序
            for(j=0;j<m+n-1-i;j++){         //最后i个位置固定了，不用再考虑
                if(nums1[j+1]<nums1[j]){
                    visit=1;   //visit=1表示发生了位置交换
                    temp=nums1[j];
                    nums1[j]=nums1[j+1];
                    nums1[j+1]=temp;  
                }
            }
			//若一轮下来，没有两个数发生位置交换，则表示已排序完成，退出循环
            if(visit==0)   
                break;
            else        //否则重置flag，进行下一次循环
                visit=0;
        }
    }
};