网易双核CPU，0-1背包，动态规划，将数组分为两部分，使得这两部分和最接近，

将数组分为两部分，使得这两部分和最接近，返回这两部分的差值

将数组分为两部分，使得两部分的和最接近，返回两部分的差值。

例如：int[] array={1,0,1,7,2,4}，分为两部分为{1,0,1,2,4}，{7}，差值为1。

动态规划的解法。求得array的和sum，问题转化为：在array中选取若干个元素，使得这些元素的和<=sum/2，且是最接近sum/2的元素集合。开一个数组：int[][]dp=new int[length+1][sum/2+1]

状态方程：dp[i][j]=Max(f[i-1][j-array[i]]+array[i],f[i-1][j])

解释：dp[i][j]表示array中i个元素的和<=j，且是最接近j的元素集合。dp[i-1][j-array[i]]表示array中i-1个元素的和最接近j-array[i]，所以dp[i][j]应该是[i-1][j-array[i]]+array[i]和f[i-1][j]中最大的那个。0-1背包问题。

public class Main {
	public static void main(String[] args) {
		int[] array = { 1, 0, 1, 7, 2, 4, 1 };
		System.out.println(getMaxDiff(array));
	}

	public static int getMaxDiff(int[] arr) {
		int len = arr.length;
		int sum = 0;
		for (int i = 0; i < len; i++)
			sum += arr[i];
		// dp[i][j]表示i个元素装容量为j的背包能装的最大容量
		int[][] dp = new int[len + 1][sum / 2 + 1];
		for (int i = 0; i < len; i++)
			for (int j = 1; j <= sum / 2; j++) {
				dp[i + 1][j] = dp[i][j];
				if (arr[i] <= j && dp[i][j - arr[i]] + arr[i] > dp[i][j]) {
					dp[i + 1][j] = dp[i][j - arr[i]] + arr[i];
				}
			}
		return sum - 2 * dp[len][sum / 2];
	}
}

网易双核CPU

一种双核CPU的两个核能够同时的处理任务，现在有n个已知数据量的任务需要交给CPU处理，假设已知CPU的每个核1秒可以处理1kb，每个核同时只能处理一项任务。n个任务可以按照任意顺序放入CPU进行处理，现在需要设计一个方案让CPU处理完这批任务所需的时间最少，求这个最小的时间。

输入描述:
输入包括两行：
第一行为整数n(1 ≤ n ≤ 50)
第二行为n个整数length[i](1024 ≤ length[i] ≤ 4194304)，表示每个任务的长度为length[i]kb，每个数均为1024的倍数。
输出描述:
输出一个整数，表示最少需要处理的时间
输入例子:
5
3072 3072 7168 3072 1024
输出例子:
9216

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int sum = 0;
		int arr[] = new int[n];

		for (int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
			arr[i] /= 1024;
			sum += arr[i];
		}
		int[][] dp = new int[n + 1][sum / 2 + 1];
		// 01背包问题。将数组划分为两部分，
		// 要求两部分的和的之差绝对值最小。
		for (int i = 0; i < n; i++)
			for (int j = 1; j <= sum / 2; ++j) {
				dp[i + 1][j] = dp[i][j];
				if (arr[i] <= j && dp[i][j - arr[i]] + arr[i] > dp[i][j]) {
					dp[i + 1][j] = dp[i][j - arr[i]] + arr[i];
				}

			}
		System.out.println((sum - dp[n][sum / 2]) * 1024);
	}
}

优化版

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int sum = 0;
		int arr[] = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
			arr[i] /= 1024;
			sum += arr[i];
		}
		int dp[] = new int[sum / 2 + 1];
		// 01背包问题。将数组划分为两部分，
		// 要求两部分的和的之差绝对值最小。
		for (int i = 0; i < n; i++)
			for (int j = sum / 2; j >= arr[i]; --j