41. 缺失的第一个正数
给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。 进阶：你可以实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案吗？ 示例 1：
输入：nums = [1,2,0]
输出：3
示例 2：
输入：nums = [3,4,-1,1]
输出：2
示例 3：
输入：nums = [7,8,9,11,12]
输出：1
提示：
0 <= nums.length <= 300
-231 <= nums[i] <= 231 - 1
解题思路一
1.判断数组中是否包含当前值，
2.如果包含，当前值递增，
3.直到出现第一个不包含的值，
4.返回当前值
Golang
func firstMissingPositive(nums []int) int {
res := 1
for i := 0; i < len(nums); i++ {
flag := false
//判断数组是否包含当前值
for _, v := range nums {
if res == v {
flag = true
}
}
//包含当前值继续递增
if flag {
res++
} else {
//返回第一个不包含的值
return res
}
}
return res
}
Javascript版本
版本一
var firstMissingPositive = function (nums) {
let i = 0, res = 1
while (i < nums.length) {
if (nums.includes(res)) {
res++
}
i++
}
return res
};
版本二
var firstMissingPositive = function (nums) {
let res = 1
while (nums.includes(res)) {
res++
}
return res
};
Python
class Solution(object):
def firstMissingPositive(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
ret = 1
while ret in nums:
ret += 1
return ret
第 n 个 丑数
给你一个整数 n ，请你找出并返回第 n 个 丑数 。 丑数 就是只包含质因数 2、3 和/或 5 的正整数
二、思路分析：
1.2,3,5分别对应指针i2,i3,i5,遍历找到当前指针
2.移动i对于的当前指针，并记录结果
3.找到数组最后一位即是第n个丑数
三、解题代码
Golang
func nthUglyNumber(n int) int {
dp := make([]int, n+1)
dp[1] = 1
i2, i3, i5 := 1, 1, 1
for i := 2; i <= n; i++ {
//计算i对应当前那个指针
x2, x3, x5 := dp[i2]*2, dp[i3]*3, dp[i5]*5
dp[i] = min(min(x2, x3), x5)
if dp[i] == x2 {
i2++
}
if dp[i] == x3 {
i3++
}
if dp[i] == x5 {
i5++
}
}
return dp[n]
}
//由于go语言里面没有min()函数，自己构建一个
func min(a, b int) int {
if a > b {
return b
}
return a
}
javascript
/**
* @param {number} n
* @return {number}
*/
var nthUglyNumber = function (n) {
let i2 = 0,//2对应的指针
i3 = 0,//3对应的指针
i5 = 0,//5对应的指针
dp = [1] //dp数组
for (let i = 1; i < n; i++) {
//计算i对应当前那个指针
let min = Math.min(dp[i2] * 2, dp[i3] * 3, dp[i5] * 5)
//指针分别向前移动
if (min === dp[i2] * 2) i2++
if (min === dp[i3] * 3) i3++
if (min === dp[i5] * 5) i5++
dp[i] = min
}
return dp[dp.length - 1]
};
Python
class Solution(object):
def nthUglyNumber(self, n):
"""
:type n: int
:rtype: int
"""
i2,i3,i5,dp = 0,0,0,[1]
for _ in range(1,n):
# 计算i对应当前那个指针
minMars = min(dp[i2] * 2, dp[i3] * 3, dp[i5] * 5)
# 指针分别向前移动
if minMars == dp[i2] * 2:
i2 = i2+1
if minMars == dp[i3] * 3:
i3 = i3+1
if minMars == dp[i5] * 5:
i5 = i5+1
dp.append(minMars)
return dp[len(dp) - 1]
Typescript
function nthUglyNumber(n: number): number {
let i2:number = 0,//2对应的指针
i3:number = 0,//3对应的指针
i5:number = 0,//5对应的指针
dp:number[] = [1] //dp数组
for (let i = 1; i < n; i++) {
//计算i对应当前那个指针
let min = Math.min(dp[i2] * 2, dp[i3] * 3, dp[i5] * 5)
//指针分别向前移动
if (min === dp[i2] * 2) i2++
if (min === dp[i3] * 3) i3++
if (min === dp[i5] * 5) i5++
dp[i] = min
}
return dp[dp.length - 1]
};
所有子数组的和的最大值
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。 要求时间复杂度为O(n)。
二、思路分析：
动态规划
1.从数组第一个元素开始，分别累加数组的元素
2.当求和到当前元素为负数和时，重新计算下一轮数组和，并记录当前的最大和
3.比较每轮数组和，返回最大值；
三、解题思路
Golang
func maxSubArray(nums []int) int {
res:=nums[0]
for i:=1;i<len(nums) ;i++ {
//求和，小于0时，和等于0，重新求和
nums[i]+=max(nums[i-1],0)
//更新最大记录值
res=max(res,nums[i])
}
return res
}
//由于go语言里面没有max()函数，自己构建一个
func max(a,b int) int{
if a>b{
return a
}
return b
}
其他版本
javascript
/**
* @param {number[]} nums
* @return {number}
*/
var maxSubArray = function (nums) {
//数组长度为1时，返回数组第一个元素
if(nums.length===1) return nums[0]
let dp = nums[0], max = nums[0]
for (let i = 1; i < nums.length; i++) {
//当和小于0时，丢弃这个结果，当前元素重新开始求和
dp = dp > 0 ? dp + nums[i] : nums[i]
//将之前计算的和，求出最大值
max = Math.max(dp, max)
}
return max
};
Python
class Solution(object):
def maxSubArray(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if(len(nums)==1):
return nums[0]
dp,ret = nums[0],nums[0]
for i in range(1,len(nums)):
if dp>0:
dp = dp+nums[i]
else:
dp = nums[i]
ret = max(dp,ret)
return ret
Typescript
function maxSubArray(nums: number[]): number {
//数组长度为1时，返回数组第一个元素
if (nums.length === 1) return nums[0]
let temp:number= nums[0], max:number = nums[0]
for (let i = 1; i < nums.length; i++) {
//当和小于0时，丢弃这个结果，当前元素重新开始求和
temp = temp > 0 ? temp + nums[i] : nums[i]
//将之前计算的和，求出最大值
max = Math.max(temp, max)
}
return max
};
继续加油，欧里给！
