poj3977(折半搜索)

点击打开题目链接

多数据集，每个数据集给出不超过35个数，求其中非空子集使得该子集数字和的绝对值最小。

如果有多个这样的子集，取元素数目最少的。

最后输出该子集中数字的和的绝对值，以及子集所含元素数目。

35个数，容易想到折半，对半分开搜索，这样的话对于某一半的序列单纯枚举各数选与不选，差不多

就是2^17种，复杂度显然可以接受。

这道题思路就是前一半先搜完(各个元素枚举选与不选两种状态)，然后搜到的各个非空子集可得到

sum,val,num这三个属性，分别表示其中元素和，元素和的绝对值，以及元素数目。不妨放到容器里存起来

然后后面一半再搜索，同样三种属性，不妨记为sum',val',num'。这里使sum'+sum绝对值最小，即要使sum最接近

-sum'，这个可以用二分来实现。寻找到这样的sum后，相应的num也可以取出(我是用HashMap容器，这样两

者就直接映射起来了)。然后，总的子集元素数目即num'+num。这样处理，比较，更新答案。

上面的是主要的思路。其次，还有Java各容器的知识、应用，具体代码如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.TreeSet;

class Reader {
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

	static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
}

public class Main {

	/**
	 * @param args
	 */

	static int n, len1, len2, anum, v, nnum, cnt, l, r, mid, fnum;
	static long ans, sum, val, val1, val2;
	static int num1, num2;
	static long arr[], brr[], crr[], nownum[];
	static HashMap<Long, Integer> hashMap;
	static TreeSet<Long> treeSet;

	private static void dfs1(int nown, int num) {
		if (nown == len1 + 1) {
			if (num == 0)
				return;
			val = Math.abs(sum);
			treeSet.add(sum);
			if ((val < ans) || (ans == val) && (num < anum)) {
				ans = val;
				anum = num;
			}
			if (!hashMap.containsKey(sum))
				hashMap.put(sum, num);
			else {
				v = hashMap.get(sum);
				if (v > num) {
					v = num;
					hashMap.put(sum, v);
				}
			}
			return;
		}
		dfs1(nown + 1, num);
		sum += brr[nown];
		dfs1(nown + 1, num + 1);
		sum -= brr[nown];
	}

	private static void dfs2(int nown, int num) {
		if (nown == len2 + 1) {
			if (num == 0)
				return;
			fnum = find(-sum);
			val1 = Math.abs(sum + nownum[fnum - 1]);
			num1 = num + hashMap.get(nownum[fnum - 1]);
			if ((val1 < ans) || (ans == val1) && (num1 < anum)) {
				ans = val1;
				anum = num1;
			}
			val2 = Math.abs(sum + nownum[fnum]);
			num2 = num + hashMap.get(nownum[fnum]);
			if ((val2 < ans) || (ans == val2) && (num2 < anum)) {
				ans = val2;
				anum = num2;
			}
			return;
		}
		dfs2(nown + 1, num);
		sum += crr[nown];
		dfs2(nown + 1, num + 1);
		sum -= crr[nown];
	}

	private static int find(long num) {
		l = 0;
		r = nnum;
		while (r - l > 1) {
			mid = (l + r) / 2;
			if (nownum[mid] <= num)
				l = mid;
			else
				r = mid;
		}
		return r;
	}

	private static void deal() {
		if (n == 1) {
			System.out.println(Math.abs(arr[1]) + " 1");
			return;
		}
		len1 = n / 2;
		brr = new long[len1 + 1];
		for (int i = 1; i <= len1; i++)
			brr[i] = arr[i];
		len2 = n - len1;
		crr = new long[len2 + 1];
		for (int i = 1; i <= len2; i++)
			crr[i] = arr[len1 + i];
		ans = Math.abs(arr[1]);
		anum = 1;
		sum = 0;
		hashMap = new HashMap<Long, Integer>();
		treeSet = new TreeSet<Long>();
		dfs1(1, 0);
		treeSet.add((long) 0);
		hashMap.put((long) 0, 0);
		nnum = treeSet.size();
		nownum = new long[nnum + 1];
		Iterator<Long> iter = treeSet.iterator();
		cnt = 0;
		while (iter.hasNext()) {
			cnt++;
			nownum[cnt] = iter.next();
		}
		dfs2(1, 0);
		System.out.println(ans + " " + anum);

	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Reader.init(System.in);
		n = Reader.nextInt();
		while (n != 0) {
			arr = new long[n + 1];
			for (int i = 1; i <= n; i++)
				arr[i] = Reader.nextLong();
			deal();
			n = Reader.nextInt();
		}
	}

}