数组分割

有一个元素个数为2n的数组a,找出这样数量相等(均为n个元素)的两个子数组a1,a2, 使a1中所有元素的和sum1与a2中所有元素的和sum2的差值最小,即|sum1-sum2|最小


1. 如果是正整数数组,可以用背包的思想,进行动态规划

可以把问题转化为找到一个n个元素的子数组,使其和最接近于sum/2, 其中sum是数组a的元素之和。

f[v][s] v表示放入v个元素,s表示这v个元素之和。f[v][s] = 1表示,方案可行;0表示,方案不可行。


int segArray(int *a, int n) {
    int len = n/2;
    vector<vector<int> > f(len);
    int sum = 0;
    for (int i = 0; i < n; ++i)
        sum += a[i];

    int S = sum/2;
    for (int i = 0; i < len ; ++i)
        f[i].resize(S,0);

    f[0][0] = 1;

    for (int i = 0; i < n; ++i) {
        for (int v = min(len,i+1); v >=1; --v) {
            for (int s = a[i] ; s <= S; ++s) {
                if (f[v-1][s-a[i]])
                    f[v][s] = 1;
            }
        }
    }

    for (int i = S; i >=0; --i)
        if (f[len][i])
            return i;
}


2. 如果是任意的整数,例如,可能出现负数。’

http://www.cnblogs.com/nanduo/archive/2009/06/29/1513035.html

/*

    有两个数组a,b,大小都为n,数组元素的值任意整形数,无序;
    要求:通过交换a,b中的元素,使[数组a元素的和]与[数组b元素的和]之间的差最小。

*/

/*
    求解思路:

    当前数组a和数组b的和之差为
    A = sum(a) - sum(b)

    a的第i个元素和b的第j个元素交换后,a和b的和之差为
    A' = sum(a) - a[i] + b[j] - (sum(b) - b[j] + a[i])
           = sum(a) - sum(b) - 2 (a[i] - b[j])
           = A - 2 (a[i] - b[j])

(主要看这个式子,A>0, 则a[i]-b[j]在0~~A之间,当越接近A/2时,差异就越小)
    设x = a[i] - b[j]

    |A| - |A'| = |A| - |A-2x|

    假设A > 0,

    当x 在 (0,A)之间时,做这样的交换才能使得交换后的a和b的和之差变小,x越接近A/2效果越好,

    如果找不到在(0,A)之间的x,则当前的a和b就是答案。

    所以算法大概如下:

    在a和b中寻找使得x在(0,A)之间并且最接近A/2的i和j,交换相应的i和j元素,重新计算A后,重复前面的步骤直至找不到(0,A)之间的x为止。


*/


int test(float a[], float b[], int n)
 {
     float sumA, sumB; //sumA为数组a总和,sumB为数组b总和
     float sum_diff, num_diff; //sum_diff为a,b总和差, num_diff为a,b中各选的两个数之差
     float temp1, temp2;    //temp1为 每轮sum_diff/2, temp2为每轮所选两个数之差于temp1最接近的那个
     int i, j;
     float temp; //用于对调a,b间数
     int tempi, tempj;    //每轮所选两个数之差于temp1最接近的那组数
     unsigned int flag_sum = 0, flag_num = 0;  //flag_sum为1, sumA大于sumB; flag_num为1, 此轮存在两个数之差小于sum_diff
 
 
         
 
     while(1){
 
         //算出a,b数组和
         sumA = 0;
         sumB = 0;
         for(i=0;i < n;i++)
         {
             sumA += a[i];
             sumB += b[i];
         }
 
         if(sumA >= sumB){
             sum_diff = sumA - sumB;
             flag_sum = 1;
         }
         else
             sum_diff = sumB - sumA;    
     
         temp1 = sum_diff/2;
         temp2 = temp1;
         tempi = 0;
         tempj = 0;    
     
         //找出a,b间差值最接近sum_diff/2的那一对数
         if(flag_sum == 1){    //sumA > sumB
             for(i=0; i < n; i++)
                 for(j=0; j < n; j++)
                 
                     if(a[i] > b[j]){
                         num_diff = a[i] - b[j];
                         if(num_diff < sum_diff){
                             flag_num =1;
                             if(num_diff >= temp1){
                                 if(num_diff-temp1 < temp2){
                                     temp2 = num_diff-temp1;
                                     tempi = i;
                                     tempj = j;
                                 }
                             }
                             else{
                                 if(temp1 - num_diff < temp2){
                                     temp2 = temp1 - num_diff;
                                     tempi = i;
                                     tempj = j;
                                 }
                             }
                         }
                     }
         }
         else{
             for(i=0; i < n; i++)
                 for(j=0; j < n; j++)
                 
                     if(a[i] < b[j]){
                         num_diff = b[j] - a[i];
                         if(num_diff < sum_diff){
                             flag_num =1;
                             if(num_diff >= temp1){
                                 if(num_diff-temp1 < temp2){
                                     temp2 = num_diff-temp1;
                                     tempi = i;
                                     tempj = j;
                                 }
                             }
                             else{
                                 if(temp1 - num_diff < temp2){
                                     temp2 = temp1 - num_diff;
                                     tempi = i;
                                     tempj = j;
                                 }
                             }
                         }
                     }
         }
 
         if(flag_num == 0)
             break;
 
         temp = a[tempi];
         a[tempi] = b[tempj];
         b[tempj] = temp;
     
         flag_num = 0;
         flag_sum = 0;
     }
         
     for(i=0; i < n;i++)
         printf("%f\t",a[i]);
 
     printf("\n");
 
     for(i=0; i < n;i++)
         printf("%f\t",b[i]);
 
     printf("\n");    
     
     return 0;
 }
 
 
 int main(int argc, char *argv[])
 {
 
     float a[3] = {4,5,12};
     float b[3] = {1,2,3};
 
     test(a, b, 3);
 
     return 0;
 }



在 JavaScript 中,将一个数组分割为多个子数组是一项常见的数据处理操作。可以通过多种方式实现这一功能,包括使用 `slice()` 方法、`for` 循环结合 `push()` 方法等[^1]。 ### 使用 `slice()` 方法进行分块 `slice(start, end)` 方法可以提取数组中从 `start` 索引开始(包含)到 `end` 索引结束(不包含)的元素,并返回一个新的数组。通过循环控制每次切割的起始位置,可以将原数组按指定长度拆分为多个子数组: ```javascript function splitArrayIntoChunks(array, chunkSize) { const result = []; for (let i = 0; i < array.length; i += chunkSize) { result.push(array.slice(i, i + chunkSize)); } return result; } // 示例用法 const originalArray = [1, 2, 3, 4, 5, 6, 7, 8, 9]; const chunkedArray = splitArrayIntoChunks(originalArray, 4); console.log(chunkedArray); // [[1, 2, 3, 4], [5, 6, 7, 8], [9]] ``` 该方法利用了 `slice()` 的特性,在不影响原始数组的前提下生成新的子数组集合[^3]。 --- ### 使用 `reduce()` 实现简洁写法 除了传统的 `for` 循环结构外,还可以使用函数式编程的方法如 `reduce()` 来实现更简洁的代码逻辑: ```javascript function splitWithReduce(arr, size) { return arr.reduce((acc, _, index) => { if (index % size === 0) { acc.push(arr.slice(index, index + size)); } return acc; }, []); } // 示例调用 const nums = [1, 2, 3, 4, 5, 6, 7, 8]; const grouped = splitWithReduce(nums, 3); console.log(grouped); // [[1, 2, 3], [4, 5, 6], [7, 8]] ``` 此方法通过遍历数组并判断索引是否为块大小的倍数来决定是否创建新子数组,适用于需要链式表达或简化代码结构的场景[^2]。 --- ### 使用 `Array.from()` 构造器生成分组 另一种现代写法是使用 `Array.from()` 配合映射函数,根据目标子数组的数量构造出最终结果: ```javascript function chunkWithArrayFrom(array, size) { return Array.from({ length: Math.ceil(array.length / size) }, (_, i) => array.slice(i * size, (i + 1) * size) ); } // 示例调用 const data = [10, 20, 30, 40, 50, 60]; const chunks = chunkWithArrayFrom(data, 2); console.log(chunks); // [[10, 20], [30, 40], [50, 60]] ``` 这种方法利用了 `Array.from()` 可以根据类数组对象生成新数组的能力,并结合 `slice()` 完成分段逻辑[^3]。 --- ### 总结与适用场景 - **`slice()` + `for` 循环**:适合大多数基础场景,语法清晰直观。 - **`reduce()` 写法**:适合函数式编程风格项目,代码简洁但可读性略差。 - **`Array.from()` 方式**:适合需要基于计算长度动态生成子数组的情况。 选择合适的方式应根据具体需求,例如对性能的要求、代码可维护性以及开发者的习惯等因素综合考虑[^2]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值