POJ1015 Jury Compromise

• 题目大意
  选择陪审团。多组输入，从n个人中选取m个人。每个人都有d和p两个数字 ，D(J)=sum(dk),P(J)=sum(pk).选取标准：minimal |D(J)-P(J)|.如果最终答案有多个一样的，那么再在其中选取maximizes|D(J)+P(J)|。
  $Description$
  In Frobnia, a far-away country, the verdicts in court trials are determined by a jury consisting of members of the general public. Every time a trial is set to begin, a jury has to be selected, which is done as follows. First, several people are drawn randomly from the public. For each person in this pool, defence and prosecution assign a grade from 0 to 20 indicating their preference for this person. 0 means total dislike, 20 on the other hand means that this person is considered ideally suited for the jury.
  Based on the grades of the two parties, the judge selects the jury. In order to ensure a fair trial, the tendencies of the jury to favour either defence or prosecution should be as balanced as possible. The jury therefore has to be chosen in a way that is satisfactory to both parties.
  We will now make this more precise: given a pool of n potential jurors and two values di (the defence’s value) and pi (the prosecution’s value) for each potential juror i, you are to select a jury of m persons. If J is a subset of {1,…, n} with m elements, then D(J ) = sum(dk) k belong to J
  and P(J) = sum(pk) k belong to J are the total values of this jury for defence and prosecution.
  For an optimal jury J , the value |D(J) - P(J)| must be minimal. If there are several jurys with minimal |D(J) - P(J)|, one which maximizes D(J) + P(J) should be selected since the jury should be as ideal as possible for both parties.
  You are to write a program that implements this jury selection process and chooses an optimal jury given a set of candidates.
  $Input$
  The input file contains several jury selection rounds. Each round starts with a line containing two integers n and m. n is the number of candidates and m the number of jury members.
  These values will satisfy 1<=n<=200, 1<=m<=20 and of course m<=n. The following n lines contain the two integers pi and di for i = 1,…,n. A blank line separates each round from the next.
  The file ends with a round that has n = m = 0.
  $Output$
  For each round output a line containing the number of the jury selection round (‘Jury #1’, ‘Jury #2’, etc.).
  On the next line print the values D(J ) and P (J ) of your jury as shown below and on another line print the numbers of the m chosen candidates in ascending order. Output a blank before each individual candidate number.
  Output an empty line after each test case.
  $Hint$
  If your solution is based on an inefficient algorithm, it may not execute the allotted time.
• 题目分析
  错误思路：设dp[i][j]为前i个人选出了j个人的差的最小值，那么只需要从dp[i-1] [j]和dp[i-1][j-1]考虑转移就行了，分别是选当前和不选当前的情况。然后最后输出dp[n][m]。
  然而，存在这样一种类型的数据：在这个范围内没有被选到，而在下一个范围内却被选到了。【打破了dp的原则：最优子结构和无后效性。】
  正确思路：将dp[i][j]表示选了第i个人当前差值为j时的和最大值。
  其中用到了修正值的概念。修正值，防止出现负数下标的。因为相减时可能会出现负数。修正后会回避下标负数问题，使得区间整体平移，从[-400,400]映射到[0,800]。
• 代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
	
	static int path[][],n,m,key=0,d,p;
	static int dp[][],di[],pi[];
	
	public static void main(String[] args) throws IOException {
		
		InputStream input=System.in;
		OutputStream output=System.out;
		InputReader in=new InputReader(input);
		PrintWriter out=new PrintWriter(output);
		
		dp=new int [30][1010];//dp[i][j]表示选了第i个人当前差值为j时的和最大值。
		path =new int [30][1010];//path[i][j]表示选了第i个人当前差值为j时对应和值最大值前一个人的编号
		di=new int [210];
		pi=new int [210];
		int []id=new int [30];
		while(true) {
			n=in.nextInt();m=in.nextInt();
			if(n==0&&m==0) break ;
			out.printf("Jury #%d\n", ++key);
			init();
			for(int i=1;i<=n;i++) {
				p=in.nextInt();
				d=in.nextInt();
				di[i]=p-d;pi[i]=p+d;
			}
			int M=20*2*m+1;
			int S=20*m;//修正值fix，防止出现负数下标的。相减时可能会出现负数。
			dp[0][S]=0;
			for(int i=1;i<=m;i++) {
				//k 的最大取值范围是[-Min, Min], 但是数组不能表示负数， 因此将数组向右平移 Min，得到[0, 2*Min]
				for(int k=0;k<=S*2;k++) {//	之前没有注意到修正值这个问题 就出现了负数下标。
					if(dp[i-1][k]>=0) {//代表k这个差值存在
						for(int j=1;j<=n;j++) {
							//对n个人进行遍历，如果这个人没有被选过，而且选了这个人之后和值比之前的大，那么久选它。
							if(select(i-1,k,j) &&dp[i-1][k]+pi[j]>dp[i][k+di[j]]) {
								dp[i][k+di[j]]=dp[i-1][k]+pi[j];//更新数据
								path[i][k+di[j]]=j;
							}
						}
					}
				}
			}
			//到了这一步，dp已经处理完成了。接下来处理 输出 的问题。
			int k;
			//要选辩控差值最小的，所求k就是所选m个人辩控差值最小的：从区间重心两边寻找最近点即可找到差值最小的状态。
			for(k=0;k<=S;k++) {
				if(dp[m][S-k]>=0 || dp[m][S+k]>=0) break;
			}
			//算控辩方总分的时候，其实是数学问题。
			int div=(dp[m][S-k]>dp[m][S+k])?(S-k):(S+k); //找最合理答案=记录差值（即差值最小，和值最大）
			int D=(dp[m][div]-div+S)/2;//控方总分
			int P=(dp[m][div]+div-S)/2;//辩方总分
			out.printf("Best jury has value %d for prosecution and value %d for defence:\n", P, D);
	        int i,j;
			for(i=0,j=m,k=div;i<m;++i){
	            id[i] = path[j][k];
	            k -= di[id[i]];
	            j--;
	        }
	        Arrays.sort(id,0,m);
	        for(i=0;i<m;++i)
	        	out.printf(" %d", id[i]);
	        out.println("\n\n");
		}
		out.close();
	}
	static void init() {
		for(int i=0;i<=21;i++) {
			for(int j=0;j<=810;j++) {
				path[i][j]=0;
				dp[i][j]=-1;
			}
		}
	}
	static boolean select(int j,int k,int i) {
		//检查这个人是否已经被选过了。
		while(j>0&&path[j][k]!=i) {
			k-=di[path[j][k]];
			j--;
		}
		if(j==0) return true;
		return false;
	}
	static void solve() {
		int n=21;
	}
	static class node implements Comparable<node>{
		int d,p,cut,sum;
		public node(int d,int p) {
			this.d=d;this.p=p;
			cut=(d-p);
			sum=d+p;
		}
		public int compareTo(node o) {
			return cut-o.cut;
		}
	}
	static class InputReader{
		public BufferedReader reader;
		public StringTokenizer tokenizer;
		public InputReader(InputStream stream) {
			reader=new BufferedReader(new InputStreamReader(stream));
			tokenizer=null;
		}
		String next() {
			while(tokenizer==null|| !tokenizer.hasMoreTokens()) {
				try {
					tokenizer =new StringTokenizer(reader.readLine());
				}catch(IOException e) {
					throw new RuntimeException (e);
				}
			}
			return tokenizer.nextToken();
		}
		String nextLine() throws IOException{
			return reader.readLine();
		}
		int nextInt() {
			return Integer.parseInt(next());
		}
	}
}
/*
4 2 
1 2 
2 3 
4 1 
6 2 
0 0 

Jury #1 
Best jury has value 6 for prosecution and value 4 for defence: 
 2 3 
*/