151. 颠倒字符串中的单词 Reverse Words In A String

给你一个字符串 s ，颠倒字符串中单词的顺序。

单词是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词分隔开。

返回单词顺序颠倒且单词之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"

示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：颠倒后的字符串中不能存在前导空格和尾随空格。

示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，颠倒后的字符串需要将单词间的空格减少到仅有一个。

提示：

1 <= s.length <= 104
s 包含英文大小写字母、数字和空格 ' '
s 中 至少存在一个 单词

进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的原地解法。

代码1： string库函数

package main

import (
	"fmt"
	"strings"
)

func reverseWords(s string) string {
	var res []string
	words := strings.Split(s, " ")
	for i, j := 0, len(words)-1; i < j; i, j = i+1, j-1 {
		words[i], words[j] = words[j], words[i]
	}
	for _, str := range words {
		str = strings.TrimSpace(str)
		if str != "" {
			res = append(res, str)
		}
	}
	return strings.Join(res, " ")
}

func main() {
	fmt.Println(reverseWords("the sky is blue"))
	fmt.Println(reverseWords("  hello world  "))
	fmt.Println(reverseWords("a good   example"))
}

代码2： bytes缓冲区

package main

import (
	"bytes"
	"fmt"
)

func reverseWords(s string) string {
	n := len(s)
	i := 0
	words := make([]string, 0, n/3)
	for i < n {
		for i < n && s[i] == ' ' {
			i++
		}
		if i == n {
			break
		}
		j := i + 1
		for j < n && s[j] != ' ' {
			j++
		}
		words = append(words, s[i:j])
		i = j
	}
	for i, j := 0, len(words)-1; i < j; i, j = i+1, j-1 {
		words[i], words[j] = words[j], words[i]
	}
	var buf bytes.Buffer
	for i, s := range words {
		if i > 0 {
			buf.WriteByte(' ')
		}
		buf.WriteString(s)
	}
	return buf.String()
}

func main() {
	fmt.Println(reverseWords("the sky is blue"))
	fmt.Println(reverseWords("  hello world  "))
	fmt.Println(reverseWords("a good   example"))
}

输出：

blue is sky the
world hello
example good a

152. 乘积最大子数组 Maximum Product Sub-Array

给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

测试用例的答案是一个 32位 整数。

子数组 是数组的连续子序列。

示例 1:

输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:

输入: nums = [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

提示:

1 <= nums.length <= 2 * 10^4
-10 <= nums[i] <= 10
nums 的任何前缀或后缀的乘积都保证是一个 32位 整数

代码：

package main

import "fmt"

func maxProduct(nums []int) int {
	n := len(nums)
	if n == 0 {
		return 0
	}
	dpMax := make([]int, n) // 以 i 位置结尾的子数组的最大乘积
	dpMin := make([]int, n) // 以 i 位置结尾的子数组的最小乘积

	dpMax[0], dpMin[0] = nums[0], nums[0]
	for i := 1; i < n; i++ {
		if nums[i] >= 0 {
			dpMax[i] = max(dpMax[i-1]*nums[i], nums[i])
			dpMin[i] = -max(-dpMin[i-1]*nums[i], -nums[i])
		} else {
			dpMax[i] = max(dpMin[i-1]*nums[i], nums[i])
			dpMin[i] = -max(-dpMax[i-1]*nums[i], -nums[i])
		}
	}

	// 返回 dpMax 数组中的最大值
	res := dpMax[0]
	for i := 1; i < n; i++ {
		if dpMax[i] > res {
			res = dpMax[i]
		}
	}
	return res
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func main() {
	nums := []int{2, 3, -2, 4}
	fmt.Println(maxProduct(nums))
	nums = []int{-2, 0, -1}
	fmt.Println(maxProduct(nums))
}

输出：

6
0

最大值、最小值函数的相互替用，如已有：

func max(x, y int) int {
   if x > y {
       return x
   }
   return y
}

用max()求a,b的最小值：

Min := -max(-a, -b)

反之亦然： Max = -min(-a, -b)