算法 — 无聊的逗

问题描述

　　逗志芃在干了很多事情后终于闲下来了，然后就陷入了深深的无聊中。不过他想到了一个游戏来使他更无聊。他拿出n个木棍，然后选出其中一些粘成一根长的，然后再选一些粘成另一个长的，他想知道在两根一样长的情况下长度最长是多少。

输入格式

　　第一行一个数n，表示n个棍子。第二行n个数，每个数表示一根棍子的长度。

输出格式

　　一个数，最大的长度。

样例输入

4
1 2 3 1

样例输出

3

数据规模和约定

　　n<=15

资源限制

时间限制：1.0s 内存限制：256.0MB

解题思路：

        该题目是一道变相的 0-1 背包问题，可简化为：将输入的树枝分割成两个等和子集。在等和分割的过程中会遇到很多的特殊情况，需要进行分支处理，故代码较为冗长，当然也可以化简，只是笔者鉴于时间较为紧迫而没有化简，见谅！

        在将输入的数组进行求最大等和子集的时候，会遇到以下特殊情况：

• 输入的数组长度小于2，直接返回两个等和子集最大长度为0。
• 输入的数组和为奇数，无法等和分割，可取做法有很多，推荐将数组进行升序排序，后去掉第一个奇数，再进行等和分割；若此时等和分割失败，则在原数组的基础上去掉第二个奇数后再进行等和分割，以此类推 (故该算法实现代码中有较多的标记变量，读者阅读时可以考虑这些标记变量的作用分别是什么)。
• 输入的数组和为偶数，先直接对数组进行等和分割，若成功则直接放回数组和的一半，若失败则对原数组进行升序排序，并去掉第一个偶数，再进行排序，若成功则直接放回和的一半，若失败则在原数组的基础上去掉第二个偶数后再进行等和子集的分割……不断进行下去。
• 输入的数组最大值大于数组总和的一半，无法等和分割。

        该算法的主要思想在于判断是否有等和分割的存在，若 true 则直接放回现数组的和半数即可，不需要另定义变量用于记录等和子集后再求和。首先定义一个二维数组dp[输入树枝数组长度][树枝数组和的一半 + 1]，该数组用于记录树枝数组的下标[0……i]的树枝中是否可以找出和为 j 的组合，若是则 dp[i][j] 计为 true ，否则即为 false 。该数组的初值均为false，接下来便对数组进行遍历操作。首先对于第一列 dp[i][0] 应该都赋值为 true，因为该列的物理意义为对于树枝数组下标为[0……i] 的组合中是否存在一些选择使得选择的树枝长度和为 0，当然只要每一支树枝都不选即可。接下来可以确定的是 dp[0][branchers[0]] 的值应该也为 true，表示选中树枝数组下标为 0 的长度即可达到长度为branchers[0] 的子集，当然是正确的。以此类推便得到该算法。

import java.util.*;
public class Main{
	static int bran(int n, int[] branchers, int[] temp, int sum, int maxVal) {
		int node = 1, key = 0;
		int len = branchers.length, sumTemp = sum;
		if (len < 2){
			return 0;
		}
		Arrays.sort(branchers);
		Arrays.sort(temp);
		if (sum % 2 == 0) {//和为偶数，先求平均不行再去偶
			while (true) {
				sumTemp = sum;
				boolean[][] dp = new boolean[len][sumTemp / 2 + 1];
				key = 0;
				//进行求数组branchers等和二分
				if (node == 1) {//数组长度为n
					for (int i = 0; i < len; i++) {
						dp[i][0] = true;
					}
					dp[0][branchers[0]] = true;
					for (int i = 1; i < len; i++) {
						int num = branchers[i];
						for (int j = 1; j <= sumTemp / 2; j++) {
							if (num <= j) {
								dp[i][j] = dp[i - 1][j] | dp[i - 1][j - num];
							}else {
								dp[i][j] = dp[i - 1][j];
							}
						}
					}
					if (dp[len - 1][sumTemp / 2]) {
						return sumTemp / 2;
					}
				}else {//数组长度为 n - 1
					for (int i = 0; i < len; i++) {
						dp[i][0] = true;
					}
					dp[0][branchers[0]] = true;
					for (int i = 1; i < len; i++) {
						int num = branchers[i];
						for (int j = 1; j <= sumTemp / 2; j++) {
							if (num <= j) {
								dp[i][j] = dp[i - 1][j] | dp[i - 1][j - num];
							}else {
								dp[i][j] = dp[i - 1][j];
							}
						}
					}
					if (dp[len - 1][sumTemp / 2]) {
						return sumTemp / 2;
					}
				}
				
				//数组初始化
				for (int i = 0; i < n; i++) {
					branchers[i] = temp[i];
				}
				//目标数组去偶
				for (int i = 0; i < n; i++) {
					if (branchers[i] % 2 == 0) {
						key++;
					}
					if (key == node) {
						sumTemp -= branchers[i];
						for (;i < n - 1; i++) {
							branchers[i] = branchers[i + 1];
						}
						node++;
					}
				}
				if (len == n) {
					len -= 1;
				}
			}
		}else {//和为奇数，先去奇后再求平均
			while (true) {
				sumTemp = sum;
				key = 0;
				for (int i = 0; i < n; i++) {//数组初始化
					branchers[i] = temp[i];
				}
				for (int i = 0; i < n; i++) {//目标数组去奇
					if (branchers[i] % 2 != 0) {
						key++;
					}
					if (key == node) {
						for (;i < n - 1; i++) {
							branchers[i] = branchers[i + 1];
						}
						node++;
					}
				}
				if (node == 2) {
					len -= 1;
				}
				boolean[][] dp = new boolean[len][sumTemp / 2 + 1];
				//对长度为 n - 1 的目标数组进行等和二分
				for (int i = 0; i < len; i++) {
					dp[i][0] = true;
				}
				dp[0][branchers[0]] = true;
				for (int i = 1; i < len; i++) {
					int num = branchers[i];
					for (int j = 1; j <= sumTemp / 2; j++) {
						if (num <= j) {
							dp[i][j] = dp[i - 1][j] | dp[i - 1][j - num];
						}else {
							dp[i][j] = dp[i - 1][j];
						}
					}
				}
				if (dp[len - 1][sumTemp / 2]) {
					return sumTemp / 2;
				}
				
			}
		}
	}

	public static void main(String[] args) {
		
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int[] branchers = new int[n];
		int[] temp = new int[n];
		int sum = 0, maxVal = 0;
		for (int i = 0; i < n; i++) {
			branchers[i] = scanner.nextInt();
			temp[i] = branchers[i];
			sum += branchers[i];
			maxVal = Math.max(maxVal, branchers[i]);
		}
		int result = bran(n, branchers, temp, sum, maxVal);
		System.out.println(result);
		scanner.close();
	}
}

        该算法的时间复杂度为O()，空间复杂度为O(n)。是一个比较差一点的算法，欢迎同行的指正，感谢！