源滚滚编程

题目句子是一个单词列表，列表中的单词之间用单个空格隔开，且不存在前导或尾随空格。每个单词仅由大小写英文字母组成（不含标点符号）。例如，“Hello World”、“HELLO” 和 “hello world hello world” 都是句子。给你一个句子 s​​​​​​ 和一个整数 k​​​​​​ ，请你将 s​​ 截断 ​，​​​使截断后的句子仅含 前 k​​​​​​ 个单词。返回 截断 s​​​​​​ 后得到的句子。示例 1：输入：s = "Hello how are you Contest

方法1：快速幂计算借用的别人的，非原创，这里的快速幂计算我也还没搞得太明白func superPow(a int, b []int) int { res := 1 // 实现内部函数 // 快速幂计算 x^n qpow := func(x, n int) int { res := 1 x %= 1337 for n > 0 { if (n & 1) == 1 { res = (res * x) % 1337 } x = (x * x) % 1

方法1：动态规划// 方法1：动态规划func climbStairs1(n int) int { if n < 2 { return 1 } // n为0和1的时候，需要爬的楼梯步数 var dp = []int{1, 1} // 动态规划 for i := 2; i <= n; i += 1 { dpTemp := dp[i-1] + dp[i-2] dp = append(dp, dpTemp) } // 返回n return dp[n]}

方法1：分而治之// 方法1：分而治之func isSymmetric(root *TreeNode) bool { // 如果是空，则是 if root == nil { return true } // 定义递归函数，判断是否为镜像 var isMirror func(left *TreeNode, right *TreeNode) bool isMirror = func(left *TreeNode, right *TreeNode) bool { // 如果左子树和右子

方法1：分而治之// 方法1：分而治之func isSameTree(p *TreeNode, q *TreeNode) bool { // 如果都存在，但是值不同，没必要继续递归了，肯定不同 if p != nil && q != nil && p.Val != q.Val { return false } // 如果都是null，相同 if p == nil && q == nil { return true // 非常重要：递归

方法1：分而治之// 方法1：分而治之func invertTree(root *TreeNode) *TreeNode { // 根节点空了 if root == nil { return nil } return &TreeNode{ Val: root.Val, Left: invertTree(root.Right), // 左子树翻转为右子树 Right: invertTree(root.Left), // 右子树翻转为左子树 }}...

方法1：分而治之func guess(mid int) int { return 0}// 方法1：分分而治之func guessNumber(n int) int { var result int // 定义递归函数 // 参数1：最小值 // 参数2：最大值 var recursive func(int, int) int recursive = func(low int, high int) int { // 最小值大于最大值，找完了 if low > high

方法1：深度优先遍历// 方法1：深度优先遍历func hasPathSum(root *TreeNode, targetSum int) bool { // 如果根节点不存在，则返回false if root == nil { return false } // 定义返回结果，默认返回fasle var result = false // 深度优先遍历递归算法 var dfs func(*TreeNode, int) dfs = func(node *TreeNode, s

方法1：递归版// 方法1：递归版中序遍历func inorderTraversal1(root *TreeNode) []int { // 创建数组，用于存放结果 var result []int // 创建递归函数，用于实现递归遍历，通过中序遍历生成数组 var recursive func(node *TreeNode) recursive = func(node *TreeNode) { if node == nil { return } // 中序遍历：左

方法1：广度优先算法func levelOrder(root *TreeNode) [][]int { // 创建一个数组，存放结果 var result [][]int // 如果节点不存在，直接返回空数组 if root == nil { return result } // 创建一个队列，存放节点和所在的层级 [[节点，层级]] type Element struct { Node *TreeNode Level int } var queue []Elemen

方法1：广度优先遍历// 方法1：使用广度优先遍历func minDepth(root *TreeNode) int { // 如果传进来的节点是空，返回0 if root == nil { return 0 } // 创建一个队列，存放节点和层数 [[node, int]] type floor struct { Node *TreeNode Floor int } var queue []floor queue = append(queue, floor{ N

解题方法1// 方法1：二叉树深度优先遍历，记录每个叶子节点的深度，求最大值func maxDepth(root *TreeNode) int { // 定义一个变量，记录最大深度 var maxDepthNum = 0 // 定义一个深度优先遍历的内部方法，传递节点和楼层 var getMaxDepth func(*TreeNode, int) getMaxDepth = func(node *TreeNode, floor int) { // 如果节点不存在，则返回 if no

方法1// 方法1// 滑动窗口方法。利用两个指针组成滑动窗口，保证每次窗口都不包含重复元素。// 记录每个窗口的长度，返回最大的窗口长度，也就是最长不重复子串。func lengthOfLongestSubstring(s string) int { // 定义左指针，右指针，滑动窗口最大长度 var left = 0 var right = 0 var windowMaxLength = 0 // 创建字典，用于存放已经遍历过的字符，用以辅助判断新的字符是否重复 var map

方法1// 方法1：婚姻介绍所匹配法func twoSum1(nums []int, target int) []int { // 创建一个字典（婚姻介绍所） var mapSearch = map[int]int{} // 遍历数组（来相亲的人队列） for k, v := range nums { // 取出当前元素（相亲的人） // 计算它要找的元素： 目标值 - 当前元素值（相亲的人要找的相亲对象） search := target - v // 判断字典中是否

方法1// 解决方法1// 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。// 有效字符串需满足：// 左括号必须用相同类型的右括号闭合。// 左括号必须以正确的顺序闭合。func isValid1(s string) bool { // 如果是奇数个，肯定是错的 if len(s) == 1 { return false } // 把切片当栈用 var stack []string // 遍历字符串 for _,

方法1：利用mappackage leetcode// 方法1：字典func intersection(nums1 []int, nums2 []int) []int { // 创建字典 var mapValue map[int]bool = make(map[int]bool) // 将数组1的值作为字典的键存储，字典的值为true for _, v := range nums1 { mapValue[v] = true } // 创建结果数组 var result []in

解决方案1package leetcode/** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */func hasCycle(head *ListNode) bool { // 定义两个指针，一个快，一个慢。 var p1 = head var p2 = head // 循环遍历节点 for p1 != nil &amp

解法1package leetcode/** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */func deleteDuplicates(head *ListNode) *ListNode { // 创建一个指针，指向节点的头部 // 注意：这个指针，就是head自身 var pointer = head // 当前节点不