算法<Array Partition I>

最新推荐文章于 2019-09-26 16:16:55 发布
最新推荐文章于 2019-09-26 16:16:55 发布
阅读量504 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Gpwner/article/details/77824669
本文介绍了一种针对数组的特殊配对算法，通过将数组中的2N个元素合理配对，实现每对中较小元素之和的最大化。文章详细阐述了算法原理，并给出了一段简洁高效的Java代码实现。

这个题目的要求是给定一个数组，有2N个元素，将其划分为N对（每一对有两个元素），使得每一对中的最小的元素相加的总和最大，例如：

有一个数组：
s=a1+b1+a2+b2+a3+b(3)+…+an+bn;

我们的目标是将数组划分诸如：
(a1,b1),(a2,b2),(a3,b3),….(an,bn)
然后求：
Sm = min(a1, b1) + min(a2, b2) + … + min(an, bn)
假设对于每一组bi>=ai,Sm(Sm = a1 + a2 + … + an)的最大值就是我们的目标.

定义
1、Sa = a1 + b1 + a2 + b2 + … + an + bn，对于输入的数组来说Sa是一个常数；
2、di = |ai - bi|，Sd = d1 + d2 + … + dn
所以我们可以得到Sa=a1 + a1 + d1 + a2 + a2 + d2 + … + an + an + di = 2Sm + Sd => Sm = (Sa - Sd) / 2

因为Sa是一个常量，要使得Sm最大的话，我们就要使得Sd最小。
一个数组中如何求的Sd最小呢，假如这个数组是一个已排序的数组：
(a1<=b1<=a2<=b2,那么Sd=(b1-a1)+(b2-a2),下图形象地说明了这点：
这里写图片描述
代码实现：

  public int arrayPairSum(int[] nums) {
        Arrays.sort(nums);
        int result = 0;
        for (int i = 0; i < nums.length; i += 2) {
            result += nums[i];
        }
        return result;
    }
Partition算法详解
chenf1999的博客
08-11 3978
partition算法有着非常重要的应用，这个算法的思想虽然简单，但具体实现的细节却比较多，今天我重点复习了这个算法，本文记录我对这个算法的理解。 文章目录Partition算法解析二分Partition三分Partition二分Partition应用时间复杂度代码三分Partition应用代码 Partition算法解析 二分Partition 快速排序作为非常著名的排序算法，其思想却很简单：每次从数组中选一个数作为pivot，然后将数组划分为2部分，小于等于pivot数的在其左边，大于等于pivot的数
Vitis HLS 学习笔记--变量存储（指令：ARRAY_PARTITION）
hi94的博客
04-22 2845
ARRAY_PARTITION 指令中非常重要，它用于优化数组的存储和访问。该指令可以将一个大数组分割成多个小数组，以提高并行处理能力和减少访问延迟。
LeetCode 561 Array Partition I（数组划分）
nomasp
05-05 8126
翻译原文Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), …, (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as pos
LeetCode 561. Array Partition I
mine_soul的博客
04-24 2096
题目描述： Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), …, (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as
Array Partition I
leetcode 解题思路
08-10 473
Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as poss...
以下是一个通过随机数来测试排序算法运行时间的程序，中间留出了加入排序算法的部分。其中可以通过修改RANDNUM的值来更改测试的数据量： #include <stdio.h> #include <stdlib.h> #include <time.h> #define RANDNUM 10000 //随机数的个数 void main（） { int iRandNum[RANDNUM];//存放随机数 clock_t first，second; //记录开始和结束时间（以毫秒为单位） int i; for（i=0;i<RANDNUM;i++） {//产生1万个随机数 iRandNum[i]=rand（）%RANDNUM; } first=clock（）; //开始时间 //此处加入排序程序 second=clock（）;//结束时间 //显示排序算法所用的时间 } （2） 从选择、交换、插入排序算法中任选至少3种排序算法（希尔排序、快速排序、堆排序、归并排序三选二），在无序状态下进行多次运行，记录运行时间，并比较测试结果。（在相同数组下比较）
06-09
i < n-1; i++) { // Find the minimum element in unsorted array min_idx = i; for (j = i+1; j < n; j++) if (arr[j] < arr[min_idx]) min_idx = j; // Swap the found minimum element with the first ...
``` package oy.tol.tra; import java.util.function.Predicate; public class Algorithms { public static <T extends Comparable<T>> void reverse(T[] array) { int i = 0; int j = array.length - 1; while (i < j) { T temp = array[i]; array[i] = array[j]; array[j] = temp; i++; j--; } } public static <T extends Comparable<T>> void sort(T[] array) { boolean swapped; for (int i = 0; i < array.length - 1; i++) { swapped = false; for (int j = 0; j < array.length - 1 - i; j++) { if (array[j].compareTo(array[j + 1]) > 0) { T temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; swapped = true; } } if (!swapped) break; } } public static <T extends Comparable<T>> int binarySearch(T aValue, T[] fromArray, int fromIndex, int toIndex) { int low = fromIndex; int high = toIndex ; while (low <= high) { int mid = low + (high - low) / 2; int cmp = fromArray[mid].compareTo(aValue); if (cmp < 0) { low = mid + 1; } else if (cmp > 0) { high = mid - 1; } else { return mid; } } return -1; } public static <E extends Comparable<E>> void fastSort(E[] array) { quickSort(array, 0, array.length - 1); } private static <E extends Comparable<E>> void quickSort(E[] array, int begin, int end) { if (begin < end) { int partitionIndex = partition(array, begin, end); quickSort(array, begin, partitionIndex - 1); quickSort(array, partitionIndex + 1, end); } } public static <T> int partition(T[] array, int count, Predicate<T> rule) { if (array == null || count <= 0) { return 0; // No elements to partition } int left = 0; // Pointer for elements that satisfy the rule int right = count - 1; // Pointer for elements that do not satisfy the rule while (left <= right) { // Move the left pointer to the right until an element does not satisfy the rule while (left <= right && rule.test(array[left])) { left++; } // Move the right pointer to the left until an element satisfies the rule while (left <= right && !rule.test(array[right])) { right--; } // Swap elements if pointers have not crossed if (left <= right) { T temp = array[left]; array[left] = array[right]; array[right] = temp; left++; right--; } } // Return the index of the first element that does not satisfy the rule return left; } }```The method partition(T[], int, Predicate<T>) in the type Algorithms is not applicable for the arguments (E[], int, int)Java(67108979)
03-11
private static <E extends Comparable<E>> int partition(E[] array, int begin, int end) { E pivot = array[end]; int i = begin - 1; for (int j = begin; j < end; j++) { if (array[j].compareTo(pivot) ...
#include <stdio.h> #include<stdlib.h> void input(int *&a,int & n); void output(int *a,int n); void swap(int &a, int &b); int Partition(int a[],int low,int high); void QuickSort(int a[],int s,int t); int n; int main () { int i; int *a = NULL; input (a,n); QuickSort(a, 0, n-1) ; free(a); return 0; } void input(int *&a,int & n) { int i; scanf("%d",&n); if((a=(int *) malloc ((n)*sizeof(int)))==NULL) { printf("不能成功分配内存单元\n"); exit(0); } for(i=0;i<n;i++) { scanf("%d",&a[i]); } } void output(int *a,int n) { int i; for(i=0;i<n;i++) { printf("%d ",a[i]); } printf("\n"); } void swap(int &a, int &b) { int t; t=a;a=b;b=t; } /**********定义Partition() 和 QuickSort()函数**********/ /********** Begin **********/ /********** End **********/
最新发布
06-17
#include <stdio.h> // Partition function int partition(int arr[], int low, int high) { int pivot = arr[high]; // 选择最后一个元素作为基准值 int i = (low - 1); // i 指向较小元素的索引 for (int j =...
Array Partition I(leetcode)
Valerie的博客
10-21 361
Array Partition I Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1)...(an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possible.
[LeetCode]561. Array Partition I (数组分区 1)
whl_program的博客
04-25 6556
561. Array Partition IGiven an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), …, (an, bn) which makes sum of min(ai, bi) for all i from 1 to
[leetcode: Python]561. Array Partition I
cyy2learn的博客
05-19 2377
Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), …, (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possibl
561.Array Partition I
就是那个党伟
09-26 194
int cmp1(const void * a,const void * b) { return (*(int*)a-*(int*)b);//a>b 返回正值 } class Solution { public: int arrayPairSum(vector<int>& nums) { /* 冒泡排序...
561. Array Partition I(C语言)
05-10 1385
这道题什么鬼 不应该输出5，[2,3],一组，[1,4]一组么 Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi
561. Array Partition I（LeetCode）
weixin_30858241的博客
04-24 134
Given an array of2nintegers, your task is to group these integers intonpairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as poss...
``` package oy.tol.tra; import java.util.List; import java.util.Objects; /** * A generic and slow Key-Value linear array. */ public class KeyValueArray<K extends Comparable<K>, V> implements Dictionary<K,V> { private Pair<K, V> [] pairs = null; private int count = 0; private int reallocationCount = 0; public KeyValueArray(int capacity) { ensureCapacity(capacity); } public KeyValueArray() { ensureCapacity(20); } @Override public Type getType() { return Type.SLOW; } @SuppressWarnings("unchecked") @Override public void ensureCapacity(int size) throws OutOfMemoryError { if (size < 20) { size = 20; } pairs = (Pair<K,V>[])new Pair[size]; reallocationCount = 0; } @Override public int size() { return count; } @Override public String getStatus() { String toReturn = "KeyValueArray reallocated " + reallocationCount + " times, each time doubles the size\n"; toReturn += String.format("KeyValueArray fill rate is %.2f%%%n", (count / (double)pairs.length) * 100.0); return toReturn; } @Override public boolean add(K key, V value) throws IllegalArgumentException, OutOfMemoryError { if (null == key || value == null) throw new IllegalArgumentException("Person or phone number cannot be null"); for (Pair<K, V> pair : pairs) { // Must not have duplicate keys, so check if key is already in the array. if (pair != null && pair.getKey().equals(key)) { pair.setValue(value); return true; } } if (count >= pairs.length) { reallocate(pairs.length * 2); } if (count < pairs.length) { pairs[count++] = new Pair<>(key, value); return true; } return false; } @Override public V find(K key) throws IllegalArgumentException { if (null == key) throw new IllegalArgumentException("Person to find cannot be null"); for (int counter = 0; counter < count; counter++) { if (pairs[counter] != null && key.equals(pairs[counter].getKey())) { return pairs[counter].getValue(); } } return null; } @Override @java.lang.SuppressWarnings({"unchecked"}) public Pair<K,V> [] toSortedArray() { Pair<K, V> [] sorted = (Pair<K,V>[])new Pair[count]; int newIndex = 0; for (int index = 0; index < count; index++) { if (pairs[index] != null) { sorted[newIndex++] = new Pair<>(pairs[index].getKey(), pairs[index].getValue()); } } Algorithms.fastSort(sorted); return sorted; } @Override public void compress() throws OutOfMemoryError { // Partition nulls to the end of the array int indexOfFirstNull = Algorithms.partition(pairs, count, element -> element == null); // Reallocate to the size of non-null elements reallocate(indexOfFirstNull); } @java.lang.SuppressWarnings("unchecked") private void reallocate(int newSize) throws OutOfMemoryError { reallocationCount++; Pair<K, V> [] newPairs = (Pair<K,V>[])new Pair[newSize]; for (int index = 0; index < count; index++) { newPairs[index] = pairs[index]; } pairs = newPairs; } }```testSlowArray有问题
03-11
<think>好的，我现在要分析用户提供的`KeyValueArray`类代码，看看是否存在问题，特别是用户提到的“testSlowArray有问题”。首先，我需要仔细阅读代码，理解其功能，然后逐一检查可能的问题点。 首先，这个类实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值