leet561. 数组拆分 I & 快排 & python sum() & sorted()&切片

题目：

给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从 1 到 n 的 min(ai, bi) 总和最大。

返回该 最大总和 。

 

示例 1：

输入：nums = [1,4,3,2]
输出：4
解释：所有可能的分法（忽略元素顺序）为：
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
所以最大总和为 4
示例 2：

输入：nums = [6,2,6,5,1,2]
输出：9
解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9
 

提示：

1 <= n <= 104
nums.length == 2 * n
-104 <= nums[i] <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/array-partition-i
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

思路一：暴力法

思路二：先排序，后处理

为了理解这种方法，让我们从不同的角度来看待问题。我们需要形成数组元​​素的配对，使得这种配对中最小的总和最大。因此，我们可以查看选择配对中最小值的操作，比如 (a,b) 可能会产生的最大损失 a-b(如果 a > b)。

如果这类配对产生的总损失最小化，那么总金额现在将达到最大值。只有当为配对选择的数字比数组的其他元素更接近彼此时，才有可能将每个配对中的损失最小化。

考虑到这一点，我们可以对给定数组的元素进行排序，并直接按排序顺序形成元素的配对。这将导致元素的配对，它们之间的差异最小，从而导致所需总和的最大化。

可参考：https://leetcode-cn.com/problems/array-partition-i/solution/minshu-dui-bi-shi-you-xu-shu-lie-shang-xiang-lin-y/

 

拓展：

快排算法

https://blog.csdn.net/liuchen1206/article/details/6954074

python ： sum()   sorted()  切片 知识点介绍

Python sorted() 函数

 

描述

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法

sorted 语法：

sorted(iterable, cmp=None, key=None, reverse=False)

参数说明：

• iterable -- 可迭代对象。
• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值

返回重新排序的列表。

Python sum() 函数

 

描述

sum() 方法对序列进行求和计算。

语法

以下是 sum() 方法的语法:

sum(iterable[, start])

参数

• iterable -- 可迭代对象，如：列表、元组、集合。
• start -- 指定相加的参数，如果没有设置这个值，默认为0。

返回值

返回计算结果。

实例

以下展示了使用 sum 函数的实例：

>>>sum([0,1,2]) 3 >>> sum((2, 3, 4), 1) # 元组计算总和后再加 1 10 >>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2 12

---

切片的概念

切片是Python序列的重要操作之一，适用于列表、元组、字符串、range对象等类型。切片使用2个冒号分隔的3个数字来完成：第一个数字表示切片的开始位置，默认为0，第二个数字表是切片的截止（但不包含）位置（默认为列表长度），第三个数字表示切片的步长(默认为1)，当步长省略时，顺便可以省略最后一个冒号。

可以使用切片来截取列表中的任何部分，得到一个新列表，也可以通过切片来修改和删除列表中部分元素，甚至可以通过切片操作为列表对象增加元素。与使用下标访问列表元素不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。

aList=[3,4,5,6,7,9,11,13,15,17]
print(aList[::])  #[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
print(aList[::-1])  #[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
#加了负号，就是一个逆向输出
print(aList[::2])  # [3, 5, 7, 11, 15]
#以步长为2进行输出，输出下标依次为0 2 4 6
print(aList[1::2])  #[4, 6, 9, 13, 17],从一开始步长为2
print(aList[3::])  #[6, 7, 9, 11, 13, 15, 17]
print(aList[3:6])  #省略的是步长，而且不包括下标为6的元素   #[6, 7, 9]

python 切片 可参考：

https://blog.csdn.net/xpresslink/article/details/77727507

https://blog.csdn.net/sinat_28576553/article/details/84404653

 

源码：

void quickSort(int * nums , int l, int r){
  //首先判断l 是否小于 r
  if(l<r){
    //初始化 i,j, base 基准
    int i = l,j = r,base=nums[l];
    //从左侧找比基准大的数据，从右侧找比基准小的数据
    while(i < j){
      //从右侧找比基准小的数据
      while(i<j && nums[j] >= base ) j--;
      //循环结束，判定是否找到数据
      if(i < j ){
        nums[i++] = nums[j];
      }
      //从左侧找比基准大的数据
      while(i <j && nums[i] <= base) i++;
      if( i < j){
        nums[j--] = nums[i];
      }

    }
    //判断结束后，赋值操作，并且递归两个字区间
    nums[i] = base;
    quickSort(nums,l,i-1);
    quickSort(nums,j+1,r);

  }

}
int arrayPairSum(int* nums, int numsSize){
  //先排序
  quickSort(nums,0,numsSize-1);
  //每间隔一个元素取一个
  int i=0;
  int sum =0;
  while(i<numsSize){
    sum+=nums[i];
    i+=2;
  }
  return sum;
}

 

####牛逼的python 一行代码
class Solution:
    def arrayPairSum(self,nums) -> int :
      return sum(sorted(nums)[::2])