力扣每日一题_2022_01

目录

• 344. 反转字符串
• 字符串
• Solution
• 334. 递增的三元子序列
• 贪心算法 #数组
  • Solution
• 70. 爬楼梯
  • Solution
• 53. 最大子数组和
  • Solution
• 747. 至少是其他数字两倍的最大数
  • Solution
• 1220. 统计元音字母序列的数目
  • Solution

---

344. 反转字符串

字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

提示：

• 1 <= s.length <= 10<sup>5</sup>
• s[i] 都是 码表中的可打印字符

Solution

func reverseString(s []byte)  {
    left := 0
    right := len(s)-1
 
    for left < right {
        s[left],s[right] = s[right],s[left]
        left++
        right--
    }
}

334. 递增的三元子序列

贪心算法 #数组

给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。

如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [1,2,3,4,5]
输出：true
解释：任何 i < j < k 的三元组都满足题意

示例 2：

输入：nums = [5,4,3,2,1]
输出：false
解释：不存在满足题意的三元组

示例 3：

输入：nums = [2,1,5,0,4,6]
输出：true
解释：三元组 (3, 4, 5) 满足题意，因为 nums[3] == 0 < nums[4] == 4 < nums[5] == 6

提示：

• 1 <= nums.length <= 5 * 10<sup>5</sup>
• -2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1

进阶：你能实现时间复杂度为 O(n) ，空间复杂度为 O(1) 的解决方案吗？

Solution

#贪心算法

func increasingTriplet(nums []int) bool {
    small,mid := math.MaxInt32,math.MaxInt32
 
    for _,num := range nums {
        if num <= small {
            small = num
        } else if num <= mid {
            mid = num
        } else {
            return true
        }
    }
    return false
}

---

70. 爬楼梯

Difficulty: **假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定 n 是一个正整数。 示例 1： 输入： 2 输出： 2 解释： 有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶 示例 2： 输入： 3 输出： 3 解释： 有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶 **

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

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

注意：给定 n 是一个正整数。

示例 1：

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

示例 2：

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

Solution

#动态规划

func climbStairs(n int) int {
    if n <= 2 {
        return n
    }
    pre1,pre2 := 2,1
 
    for i := 2; i < n; i++ {
        cur := pre1 + pre2
        pre2 = pre1
        pre1 = cur
    }
    return pre1
}

---

53. 最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

• 1 <= nums.length <= 10<sup>5</sup>
• -10<sup>4</sup> <= nums[i] <= 10<sup>4</sup>

进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

Solution

#动态规划

func maxSubArray(nums []int) int {
    sum := nums[0]
    for i := 1; i < len(nums); i++ {
        if nums[i] + nums[i-1] > nums[i] {
            nums[i] += nums[i-1]
        }
        if  nums[i] > sum {
            sum = num[i]
        }
    }  
    return sum
}

---

747. 至少是其他数字两倍的最大数

给你一个整数数组 nums ，其中总是存在 唯一的 一个最大整数 。

请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。如果是，则返回 最大元素的下标 ，否则返回 -1 。

示例 1：

输入：nums = [3,6,1,0]
输出：1
解释：6 是最大的整数，对于数组中的其他整数，6 大于数组中其他元素的两倍。6 的下标是 1 ，所以返回 1 。

示例 2：

输入：nums = [1,2,3,4]
输出：-1
解释：4 没有超过 3 的两倍大，所以返回 -1 。

示例 3：

输入：nums = [1]
输出：0
解释：因为不存在其他数字，所以认为现有数字 1 至少是其他数字的两倍。

提示：

• 1 <= nums.length <= 50
• 0 <= nums[i] <= 100
• nums 中的最大元素是唯一的

Solution

func dominantIndex(nums []int) int {
    m1, m2 := -1,-1
    index := -1
    for i,num := range nums {
        if num > m1 {
            m2 = m1
            m1 = num
            index = i
        } else if num > m2 {
            m2 = num
        }
    }
 
    if m1 >= m2 * 2 {
        return index
    } else {
        return -1
    }
}

1220. 统计元音字母序列的数目

给你一个整数 n，请你帮忙统计一下我们可以按下述规则形成多少个长度为 n 的字符串：

• 字符串中的每个字符都应当是小写元音字母（'a', 'e', 'i', 'o', 'u'）
• 每个元音 'a' 后面都只能跟着 'e'
• 每个元音 'e' 后面只能跟着 'a' 或者是 'i'
• 每个元音 'i' 后面 不能 再跟着另一个 'i'
• 每个元音 'o' 后面只能跟着 'i' 或者是 'u'
• 每个元音 'u' 后面只能跟着 'a'

由于答案可能会很大，所以请你返回 模 10^9 + 7 之后的结果。

示例 1：

输入：n = 1
输出：5
解释：所有可能的字符串分别是："a", "e", "i" , "o" 和 "u"。

示例 2：

输入：n = 2
输出：10
解释：所有可能的字符串分别是："ae", "ea", "ei", "ia", "ie", "io", "iu", "oi", "ou" 和 "ua"。

示例 3：

输入：n = 5
输出：68

提示：

• 1 <= n <= 2 * 10^4

Solution

以a为例，当a作为尾巴时，及ea、ia、ua，所以是$c[1] + c[2] + c[4]$
总的就是：
$nc = [c[1] + c[2] + c[4], c[0] + c[2], c[1] + c[3], c[2], c[2] + c[3]]$

#DFA

const MOD int = 1e9 + 7
func countVowelPermutation(n int) int {
    a,e,i,o,u := 1,1,1,1,1
    for k := 2; k <= n; k++ {
        a,e,i,o,u = (e+i+u)%MOD,(a+i)%MOD,(e+o)%MOD,i,(i+o)%MOD
    }
    return (a+e+i+o+u) % MOD
}

class Solution {
public:
    int countVowelPermutation(int n) {
        const int M = 1e9 + 7;
        long a = 1, e = 1, i = 1, o = 1, u = 1;
 
        for (int k = 2; k <= n; k++) {
            long aa = (e+i+u) % M;
            long ee = (a+i) % M;
            long ii = (e+o) % M;
            long oo = i;
            long uu = (o+i) % M;
 
            a = aa;
            e = ee;
            i = ii;
            o = oo;
            u = uu;
        }
        return (a+e+i+o+u) % M;
    }
};