带有解释答案的 leetcode 求和挑战？？？

两个总和：

这是我们正在寻找索引的第二种类型的问题，因此不需要排序。你想要做的是遍历数组，并尝试找到两个总和为 a 的整数 目标 价值。大多数时候，在这样的问题中，使用字典（hastable）会有所帮助。您尝试在字典中记录您的观察结果，并在获得结果后使用它。

注意：尽量使用舒适 枚举 因为它有时会超出新手的舒适区。 枚举 在很多问题上都派上用场（我的意思是，如果你当然想要更简洁的代码）。如果我必须选择三个我一开始不习惯的内置函数/方法并且发现它们非常有用，我可能会说 枚举 , 压缩 和 放 .

解决方案：

在这个问题中，您初始化一个字典 ( 见过 ）。这本字典将记录数字（如 钥匙 ) 和索引 (如 价值 ）。所以，你检查你的数组（线 #1 ）使用 枚举 它为您提供数组中元素的索引和值。作为一个例子，让我们做 数字 = [2,3,1] 和 目标 = 3 .假设你在索引 我 = 0 和 值 = 2 ，好的？你需要找到 值 = 1 完成问题，意义， 目标 - 2 = 1 . 1 这里是 其余的 .

自从 剩余+价值=目标 ，一旦你找到它，你就完成了，对吧？所以当遍历数组时，你计算 其余的 并检查是否 其余的 在里面 见过 字典（行 #3 ）。

如果是，你就完成了！你是当前号码，其余来自 见过 会给你输出（线 #4 ）。

否则，您将当前号码添加到字典中（行 #5 ) 因为这将是一个 其余的 （可能）假设至少有一个答案实例，您将来会看到一个数字。

 类解决方案：  
 def twoSum(self, nums: List[int], target: int) -> List[int]:  
 见过={}  
 对于 i，枚举中的值（nums）：#1  
 剩余 = 目标 - nums[i] #2  
             
 如果留在看到：#3  
 返回 [i, seen[remaining]] #4  
 别的：  
 看到[价值] = 我 #5

3 总和：

给定一个整数数组 nums，返回所有三元组 [nums[i]，nums[j]，nums[k]] 这样 我！= j , 我！= k ，和 j != k ，和 数字[i] + 数字[j] + 数字[k] == 0 .

请注意，解决方案集不得包含重复的三元组。

示例 1：

**输入：** 数字 = [-1,0,1,2,-1,-4]  
 **输出：** [[-1,-1,2],[-1,0,1]]  
 **解释：**   
 数字 [0] + 数字 [1] + 数字 [2] = (-1) + 0 + 1 = 0。  
 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0。  
 数字 [0] + 数字 [3] + 数字 [4] = (-1) + 2 + (-1) = 0。  
 不同的三元组是 [-1,0,1] 和 [-1,-1,2]。  
 请注意，输出的顺序和三元组的顺序无关紧要。

示例 2：

**输入：** 数字 = [0,1,1]  
 **输出：** []  
 **解释：** 唯一可能的三元组总和不等于 0。

示例 3：

**输入：** 数字 = [0,0,0]  
 **输出：** [[0,0,0]]  
 **解释：** 唯一可能的三元组总和为 0。

约束：

3 <= nums.length <= 3000
-105 <= 数字[i] <= 105

我们在前面解决了两个和问题文章，并且这个问题在某些方面是二和问题的延续。所以，如果你还没有解决二和问题，我们建议你这样做，因为它会帮助你更好地理解三和问题。

给定一个整数数组 nums，返回给定数组 nums[i]、nums[j]、nums[k] 中的所有三元组，使得 i != j、i != k、j != k 和 nums [i] + 数字 [j] + 数字 [k] == 0。

注意： 解决方案集不得包含重复的三元组。

例子

示例 1：

**输入：** 数字 = [-1,0,1,2,-1,-4]  
 **输出：** [[-1,-1,2],[-1,0,1]]

示例 2：

**输入：** 数字 = [0]  
 **输出：** []

解决方案

让我们试着理解问题陈述。问题陈述的第一部分很清楚，我们被要求找出给定数组中总和为零的所有三元组。三元组只不过是给定数组中的一组三个数字。例如，如果 nums=[1,2, 3,4] 是给定的数组，则 [1,2,3] [2,3,4] [1,3,4] 等是它的三元组。

条件 i != j、i != k 和 j != k 是什么意思？

这意味着我们不允许在三元组中重用数组中的任何数字。例如，对于给定的数组 nums = [1,2,3,4]，三元组 [1,1,1] 或 [1,1,2] 或 [1,2,2] 等不被视为有效三元组。

我们需要考虑的最后一个条件是我们的最终结果中不能有重复的三元组。示例如果 [-2,-2,0,2] 是给定数组，我们只能考虑索引 0、2、3 中的 [-2,0,2] 和索引中的 [-2,0,2] 之一1, 2, 3 在我们的最终结果中。

与以前的方法相比，我们可以对给定的数组进行排序并使用三指针方法来提高解决方案的时间复杂度。

这个想法是先对数组进行排序，然后运行两个循环来处理三元组。我们固定外循环并将内循环的两个指针（索引）向内移动以得到结果。

这个算法背后的直觉很简单，当我们对数组进行排序时，所有重复的元素都被组合在一起。如果我们在处理三元组时使用左右两个指针来遍历数组，我们可以很容易地避免由于这些重复元素而出现的重复三元组。

例如 nums = [-2, 1, -3, 5, -3, 5] 是给定的数组，当我们对这个数组进行排序时，我们得到： nums = [-3, -3, -2, 1, 5, 5]。如您所见，所有重复的元素 [-3, -3] 和 [5,5] 都组合在一起。如果要考虑所有这些重复元素，则会产生重复的三元组，例如 [-3, -2, 5] 和 [-3, -2, 5]。如果我们使用两个指针从两侧（一个从开始，一个从结束）遍历数组，我们可以很容易地避免这种情况。我们只处理第一个元素并跳过它之后出现的所有重复元素。

对于给定的输入数组数字大小为 n 这种方法执行以下步骤：

第一步是对给定的数组 nums 进行排序。通过跳过会导致重复三元组的某些数字，对数组进行排序有助于我们使用循环识别重复的三元组。这有助于我们避免使用哈希图来识别重复项（如解决方案 1 ）在那里通过提高空间复杂度（继续阅读以了解如何跳过重复的三元组）。此外，对数组进行排序有助于根据总和是小于还是大于 0 有效地增加/减少我们的索引变量。
接下来我们需要两个循环。外环指数 num1Idx 表示三元组中第一个元素的索引。内循环包含两个索引 num2Idx 和 num3Idx 分别表示第 2 个和第 3 个三元组元素的索引。
最初 num1Idx 指向给定数组中的第一个元素，并且 num2Idx , num3Idx 指向给定数组中的第二个和最后一个元素。我们修复了外循环索引 num1Idx 并向内移动两个内部循环索引 num3Idx > num2Idx .一旦条件 num3Idx > num2Idx 为假我们停止内循环并增加外循环索引 num1Idx , 也更新 num2Idx 和 num3Idx , num2Idx = num1Idx +1 和 num3Idx =n-1。
取一个变量和存储三元组总和。和 = 数字 [ num1Idx ] + 数字 [ num2Idx ] + 数字 [ num3Idx ]。现在有三种可能： 一个。 如果和等于 0 我们将其添加到我们的结果中。湾。如果和大于 0 我们需要减小总和值使其等于 0，所以我们递减 num3Idx 指数。 C。如果和小于 0 我们需要增加 sum 值使其等于 0，所以我们递增 num2Idx 指数。
内循环应该运行只要 num3Idx > num2Idx 对于外循环的每次迭代 . 一旦处理了所有三元组组合，我们就会返回结果。
上述 4 个步骤确保我们找到所有和等于 0 的三元组。但它也会将重复项添加到结果数组中。要跳过重复的三元组，我们需要在算法中添加两个条件，一个在外循环中，一个在内循环中。在外循环 如果 nums[num1Idx] == nums[num1Idx-1] 即如果当前 num1Idx 值与前一个数字相同（ num1Idx -1）我们跳过当前数字（我们不必考虑当前数字来计算我们的结果）。此条件确保我们跳过数组左侧的所有重复项。类似地跳过数组右侧的所有数字，一旦我们找到一个总和为零的三元组，我们就会继续递减 num3Idx 直到数字[ num3Idx ] != 数字[ num3Idx +1]（在内部循环中）。

7. 模拟

为了更清楚地说明这一点，让我们通过模拟来理解这个算法。

考虑给你下面的输入数组数字大小 n = 5：

第一步是对给定的数组进行排序。排序后数字将会：

迭代 1

对于外循环的第一次迭代 num1Idx = 0, num2Idx = num1Idx + 1 = 1 和 num3Idx = n-1 = 4。如下图所示：

现在我们计算当前数组元素的总和 num1Idx , num2Idx 和 num3Idx .

和 = 数字 [ num1Idx ] + 数字 [ num2Idx ] + 数字 [ num3Idx ]

和 = 数字 [0] + 数字 [1] + 数字 [4] = (-1) + (-1) + 2 = 0

正如您所看到的当前值 num1Idx , num2Idx 和 num3Idx sum = 0，所以我们把它加到我们的结果 .所以结果 = [[-1, -1, 2]] 也递减 num3Idx .无需在内部循环中进行重复检查，因为 num3Idx 是数组中的最后一个元素。

现在索引变量的更新值为 num1Idx = 0, num2Idx = 1 和 num3Idx = 3。

再次计算总和，

和 = 数字 [0] + 数字 [1] + 数字 [3] = (-1) + (-1) + 1 = -1。

Sum 小于 0，所以我们递增 num2Idx .

现在和 = 数字 [0] + 数字 [2] + 数字 [3] = (-1) + 0 + 1 = 0。Sum 等于 0，所以我们将当前的三元组 [-1, 0, 1] 添加到结果中并递减 num3Idx .还要在内循环中进行重复检查，数字 [ num3Idx ] != 数字 [ num3Idx +1]，因此当前值不可能重复 num3Idx ，因此不需要递减 num3Idx 更远。

索引变量的更新值为 num1Idx = 0, num2Idx = 2 和 num3Idx = 2. 如您所见 num2Idx 等于 num3Idx ，所以我们停止内循环并增加外循环索引 num1Idx 由 1。

迭代 2

对于外循环的第二次迭代，索引的更新值为 num1Idx =1, num2Idx = num1Idx +1=2 和 num3Idx = n-1 = 5–1 = 4。

由于价值 num1Idx 与上一次迭代相同 num1Idx 值，如果再次考虑这个值，我们最终会得到重复的三元组。因此我们需要跳过当前 num1Idx , 所以递增 num1Idx .

现在 num1Idx = 2, num2Idx = 3 和 num3Idx = 4。

和和 = 数字 [2] + 数字 [3] + 数字 [4] = 0 + 1 + 2 = 3 大于0，所以我们递减 num3Idx .

再次 num2Idx 等于 num3Idx ，因此我们停止了内部循环，也到达了数组的末尾，所以我们停止了算法并返回结果。

**班级** 解决方案（对象）：  
  
    **定义** 三和（自我，数字）：  
  
 # 对给定的数组进行排序  
  
 nums.sort()  
  
 结果 = []  
        **为了** num1Idx **在** xrange(len(nums) - 2):  
  
 # 从左边跳过所有重复项  
 # num1Idx>0 确保仅从第二个元素开始进行此检查  
  
            **如果** num1Idx > 0 **和** nums[num1Idx] == nums[num1Idx - 1]：  
                **继续**  
 (num2Idx, num3Idx) = (num1Idx + 1, len(nums) - 1)  
  
            **尽管** num2Idx < num3Idx：  
 总和 = nums[num1Idx] + nums[num2Idx] + nums[num3Idx]  
  
                **如果** 总和 == 0：  
  
 # 将三元组添加到结果中  
  
 result.append((nums[num1Idx], nums[num2Idx],  
 数字[num3Idx]))  
  
 num3Idx -= 1  
  
 # 从右边跳过所有重复项  
  
                    **尽管** num2Idx < num3Idx **和** 数字[num3Idx] \  
 == 数字[num3Idx + 1]：  
 num3Idx -= 1  
                **小精灵** 总和 > 0：  
  
 # 递减 num3Idx 以减少总和值  
  
 num3Idx -= 1  
                **别的** ：  
  
 # 增加 num2Idx 以增加总和值  
  
 num2Idx += 1  
        **返回** 结果

复杂性分析

时间复杂度：O(n²)

对输入数组进行排序的时间复杂度为 O(n log n) + O(n²)，因为对于两个循环。所以总的时间复杂度是O(n²)。

空间复杂度：O(1)

添加两个数字：

给你两个非空表示两个非负整数的链表。数字存储在 相反的顺序 ，并且它们的每个节点都包含一个数字。将两个数字相加并将总和作为链表返回。

您可以假设这两个数字不包含任何前导零，除了数字 0 本身。

示例 1：

**输入：** l1 = [2,4,3], l2 = [5,6,4]  
 **输出：** [7,0,8]  
 **解释：** 342 + 465 = 807。

示例 2：

**输入：** l1 = [0]，l2 = [0]  
 **输出：** [0]

示例 3：

**输入：** l1 = [9,9,9,9,9,9,9]，l2 = [9,9,9,9]  
 **输出：** [8,9,9,9,0,0,0,1]

约束：

每个链表的节点数在范围内 [1, 100] .
0 <= 节点.val <= 9
保证该列表表示一个没有前导零的数字。

解决方案：

方法：初等数学直觉

使用变量跟踪进位并从包含最低有效数字的列表头部开始模拟逐位求和。

图 1. 两个数字相加的可视化： 342 + 465 = 807342+465=807 .
每个节点都包含一个数字，并且这些数字以相反的顺序存储。

leetcode.com

算法

就像你在一张纸上将两个数字相加一样，我们首先将最低有效数字相加，即 l1 的头部 l 1 和 l2 l 2. 由于每个数字都在 0 \ldots 90…9 的范围内，因此将两个数字相加可能会“溢出”。例如 5 + 7 = 125+7=12。在这种情况下，我们将当前数字设置为 22 并带入进位 = 1 携带 =1 到下一次迭代。携带携带必须是 00 或 11，因为两位数（包括进位）的最大可能和是 9 + 9 + 1 = 199+9+1=19。

伪代码如下：

将当前节点初始化为返回列表的虚拟头。
初始化进位为 00。
遍历列表 l1 l 1 和 l2 l 2 直到你到达两端并且 crary 是 00。
设置 x X 到节点 l1l1 的值。如果 l1 l 1 已经到达 l1 的末尾 l 1，设置为 00。
设置 y 是的到节点 l2l2 的值。如果 l2 l 2 已到 l2 的末尾 l 2、设置为00。
设置总和 = x + y + 进位和 = X + 是的 + 携带 .
更新进位 = sum / 10 携带 = 和 /10。
创建一个数字值为 (sum \bmod 10)( 和 mod10) 并将其设置为当前节点的下一个，然后将当前节点推进到下一个。
推进两个 l1 l 1 和 l2 l 2.
返回虚拟头的下一个节点。

请注意，我们使用虚拟头来简化代码。如果没有虚拟头，您将不得不编写额外的条件语句来初始化头的值。

请特别注意以下情况：

测试用例Explanationl1=[0,1] l 1=[0,1]
l2=[0,1,2] l 2=[0,1,2]当一个列表比另一个长时.l1=[] l 1=[]
l2=[0,1] l 2=[0,1]当一个列表为空时，表示一个空列表。l1=[9,9] l 1=[9,9]
l2=[1] l 2=[1]总和最后可能有一个额外的进位，这很容易忘记。

执行 Python：

 类解决方案：  
 def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:  
 dummyHead = ListNode(0)  
 curr = dummyHead  
 进位 = 0  
 而 l1 != None 或 l2 != None 或进位 != 0：  
 l1Val = l1.val if l1 else 0  
 l2Val = l2.val if l2 else 0  
 columnSum = l1Val + l2Val + 进位  
 进位 = columnSum // 10  
 newNode = ListNode(columnSum % 10)  
 curr.next = newNode  
 当前=新节点  
 l1 = l1.next if l1 else None  
 l2 = l2.next if l2 else None  
 返回 dummyHead.next

复杂性分析

时间复杂度：O(\max(m, n)) ○ （最大限度（米 , n ））。假设 m 米和 n n 表示l1的长度 l 1 和 l2 l 2分别，上面的算法迭代最多\max(m,n)max( 米 , n ) 次。
空间复杂度：O(\max(m, n)) ○ （最大限度（米 , n ））。新列表的长度最多为 \max(m,n) + 1max( 米 , n )+1。

4 我是：

给定一个数组 数字 的 n 整数，返回 所有的数组 ** 独特的** 四胞胎 [nums[a]，nums[b]，nums[c]，nums[d]] 这样：

0 <= a, b, c, d < n
一个 , b , C ，和 d 是 清楚的 .
nums[a] + nums[b] + nums[c] + nums[d] == 目标

您可以返回答案 任何订单 .

示例 1：

**输入：** 数字 = [1,0,-1,0,-2,2]，目标 = 0  
 **输出：** [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

**输入：** 数字 = [2,2,2,2,2]，目标 = 8  
 **输出：** [[2,2,2,2]]

约束：

1 <= nums.length <= 200
-109 <= 数字[i] <= 109
-109 <= 目标 <= 109

解决方案

这个问题是后续的 3总和，所以如果你还没有，请先看看这个问题。 4Sum 和 3Sum 非常相似；不同之处在于我们正在寻找独特的四胞胎而不是三胞胎。

如您所见，3Sum 只是将 Two Sum 包装在一个外循环中。因为它遍历每个值 v ，它找到总和等于的所有对 目标-v 使用以下方法之一：

二和使用哈希集来检查匹配值。
二和二在排序数组中使用两个指针模式。

按照类似的逻辑，我们可以通过将 3Sum 包装在另一个循环中来实现 4Sum。但是等等——有一个问题。如果面试官要求你解决 4Sum，他们可以跟进 5Sum、6Sum 等。他们此时真正期待的是 kSum 解决方案。因此，我们将在这里重点介绍一个通用的实现。

方法 1：两个指针

直觉

两个指针模式需要对数组进行排序，所以我们首先这样做。此外，如果对数组进行排序，则更容易处理重复项：重复值彼此相邻且易于跳过。

对于 3Sum，我们在一个循环中枚举每个值，并对数组的其余部分使用两个指针模式。对于 kSum，我们将有 k - 2 嵌套循环枚举所有组合 k - 2 价值观。

1 / 10

算法

我们可以实现 k - 2 使用递归循环。我们将通过起点和 ķ 作为参数。什么时候 k == 2 ，我们将调用 二和 ，终止递归。

对于主要功能：

对输入数组进行排序 数字 .
称呼 总和 和 开始 = 0 , k = 4 ，和 目标 ，并返回结果。
为了 总和 功能：
在开始时 总和 函数，我们将检查三个条件：

我们已经用完了可供选择的数字吗？
剩余的最小数是否大于 目标/k ?
如果是这样，那么任何 ķ 我们选择的数字会太大。
剩余的最大数是否小于 目标/k ?
如果是这样，那么任何 ķ 我们选择的数字太小了。

如果这些条件中的任何一个为真，则无需继续，因为剩余元素的任何组合都不能相加 目标 .
如果 ķ 等于 2 ，称呼 二和 并返回结果。
迭代 一世 通过数组从 开始 ：
如果当前值与之前的值相同，则跳过它。
递归调用 总和 和 开始 = 我 + 1 , k = k - 1 ，和 目标 - nums[i] .
对于每个返回 子集 价值观：
包括当前值 数字[i] 进入 子集 .
添加 子集 结果 资源 .
返回结果 资源 .
为了 二和 功能：
设置低指针 罗 至 开始 , 和高指针 你好 到最后一个索引。
虽然低指针小于高指针：
如果总和 数字[它] 和 数字[zh] 小于 目标 ，增量 罗 .
也增加 罗 如果该值与 for 相同 低 - 1 .
如果总和大于 目标 , 递减 你好 .
也减量 你好 如果该值与 for 相同 嗨 + 1 .
否则，我们找到了一对：
将其添加到结果中 资源 .
递减 你好 并增加 罗 .
返回结果 资源 .

类解决方案：
deffourSum(self, nums: List[int], target: int) -> List[List[int]]:

def kSum(nums: List[int], target: int, k: int) -> List[List[int]]:
水库= []

如果我们已经用完了要添加的数字，则返回 res。

如果不是数字：
返回资源

有 k 个剩余值要添加到总和中。这

这些值的平均值至少是目标 // k。

平均值 = 目标 // k

如果是最小值，我们不能得到目标的总和

in nums 大于 target // k 或者如果最大

nums 中的值小于目标 // k。

如果 average_value < nums[0] 或 nums[-1] < average_value：
返回资源

如果 k == 2：
return twoSum(nums, target)

对于我在范围内（len（nums））：
如果 i == 0 或 nums[i - 1] != nums[i]：
对于 kSum(nums[i + 1:], target - nums[i], k - 1) 中的子集：
res.append([nums[i]] + 子集)

返回资源 def twoSum(nums: List[int], target: int) -> List[List[int]]:
水库= []
s = 设置（）

对于我在范围内（len（nums））：
如果 len(res) == 0 或 res[-1][1] != nums[i]:
如果目标 - s 中的 nums[i]：
res.append([目标 - nums[i], nums[i]])
s.add(nums[i])

返回资源 nums.sort()
返回 kSum(nums, 目标, 4)

复杂性分析

时间复杂度：O(n^{k — 1}) ○ ( nk −1) 或 O(n³) ○ ( n 3) 对于 4Sum。我们有 k - 2 ķ -2 循环迭代 n n 元素，和 二和 是 O(n) ○ ( n ）。
请注意，对于 k > 2 ķ >2，对数组进行排序不会改变整体时间复杂度。
空间复杂度：O(n) ○ ( n ) 用于哈希集。递归所需的空间不会超过 O(n) ○ ( n ）。

3 和最接近：

给定一个整数数组 数字 长度 n 和一个整数 目标 , 找到三个整数 数字 这样总和最接近 目标 .

返回 三个整数之和 .

您可以假设每个输入都只有一个解决方案。

示例 1：

**输入：** 数字 = [-1,2,1,-4]，目标 = 1  
 **输出：** 2  
 **解释：** 最接近目标的和是 2。（-1 + 2 + 1 = 2）。

示例 2：

**输入：** 数字 = [0,0,0]，目标 = 1  
 **输出：** 0

约束：

3 <= nums.length <= 1000
-1000 <= 数字[i] <= 1000
-104 <= 目标 <= 104

解决方案：

方法：简单的两个指针

 def threeSumClosest(self, nums, target):  
 差异，n = float（“-inf”），len（nums）  
      
 nums.sort()  
      
 对于范围内的 i (n)：  
 低，高 = i+1，n-1  
 而低<高：  
 总计 = nums[i] + nums[low] + nums[high]  
 diff = total if abs(total-target) < abs(diff-target) else diff  
 如果总计 < 目标：  
 低 += 1  
 elif 总计 > 目标：  
 高 -= 1  
 别的：  
 返回差异  
                  
 返回差异

在 YouTube 上关注我： http://www.youtube.com/c/TemotecLearningAcademy/?sub_confirmation=1

在 Medium 上关注我： https://medium.com/@temoteclearningacademy

跟随我在知乎上： https://temotecacademy.quora.com/?invite_code=ZIeeqxfcztMR4vRITASN

在 LinkedIn 上关注我：

https://www.linkedin.com/in/temotec-learning-academy-0a615a17a/