备考蓝桥杯（26）漏掉的账单明细，（遍历所有情况）（java实现）(exforward)

package pers.robert.lanqiaobeizhenti129;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

/**
 * 27.漏掉的账目明细
某财务部门结账时发现总金额不对头。很可能是从明细上漏掉了某1笔或几笔。
如果已知明细账目清单，能通过编程找到漏掉的是哪1笔或几笔吗？
如果有多种可能，则输出所有可能的情况。
我们规定：用户输入的第一行是：有错的总金额。
接下来是一个整数n，表示下面将要输入的明细账目的条数。
再接下来是n行整数，分别表示每笔账目的金额。
要求程序输出：所有可能漏掉的金额组合。每个情况1行。金额按照从小到大排列，中间用空格分开。
比如：
用户输入：
6
5
3
2
4
3
1
表明：有错的总金额是6；明细共有5笔。
此时，程序应该输出：
1 3 3
1 2 4
3 4
为了方便，不妨假设所有的金额都是整数；每笔金额不超过1000，金额的明细条数不超过100。

 * @author Robert
 *
 */
public class The027MissingAccountDetailDemo2 {
	 static Set<List<Integer>> sets = new LinkedHashSet<List<Integer>>();    // 保存记录   
	    // 得到漏掉的总金额   
	    public static int sum(int[] d){  
	        int leak = 0;  
	        for(int i=0;i<d.length;i++){  
	            leak += d[i];  
	        }  
	        return leak;  
	    }  
	    // 修改b元素遇2进位   
	    public static void modify(int[] b){  
	        b[b.length-1]++;  
	        for(int i=b.length-1;i>0;i--){  
	            if(b[i]>1){  
	                b[i] = 0;  
	                b[i-1]++;  
	            }  
	        }  
	    }  
	    // 检测b是否全111111...   
	    public static boolean check(int[] b){  
	        boolean flag = true;  
	        for(int i=0;i<b.length;i++){  
	            if(b[i]==0){  
	                flag = false;  //存在0，返回false,
	                break;  
	            }  
	        }  //不存在0，返回true
	        return flag;  
	    }  
	    public static void calc(int le,int[] d,int[] b){  
	    	if(check(b)){  //检测b是否全为1，如果是，为true，说明全部情况被分配过，但也漏掉了所有东西都选上这一种可能
	            return;  
	        }  
	        int sum = 0;  
	        for(int i=d.length-1;i>=0;i--){  
	            if(b[i]!=0){  
	                sum += d[i];  
	            }  
	        }  
	        if(sum==le){  
	            List<Integer> lis = new ArrayList();  
	            for(int i=0;i<d.length;i++){  
	                if(b[i]!=0){  
	                    lis.add(d[i]);  
	                }  
	            }  
	            sets.add(lis);  
	            //lis.clear();   
	        }  
	        modify(b);  
	        calc(le,d,b);  
	    }  
	    // 输出结果   
	    public static void print(){  
	        Iterator<List<Integer>> iter = sets.iterator();  
	        while(iter.hasNext()){  
	            Iterator<Integer> iter2 = iter.next().iterator();  
	            while(iter2.hasNext()){  
	                System.out.print(iter2.next()+" ");  
	            }  
	            System.out.println();  
	        }  
	    }  
	    public static void main(String[] args){  
	        Scanner scan = new Scanner(System.in);  
	        int err = scan.nextInt();  
	        int n = scan.nextInt();  
	        int[] d = new int[n];  
	        for(int i=0;i<n;i++){  
	            d[i] = scan.nextInt();  
	        }  
	        Arrays.sort(d); //排序 
	        int le = sum(d) - err;  // 得到漏掉的总金额   
	        int[] b = new int[d.length];    // 初始为全零 作为标记,记录数字是否使用 0为未使用 1为已经使用   
	        calc(le,d,b);  
	        System.out.println("输出结果:");  
	        print();  
	    }  

}

分析：

    // 修改b元素遇2进位   
	    public static void modify(int[] b){  
	        b[b.length-1]++;  
	        for(int i=b.length-1;i>0;i--){  
	            if(b[i]>1){  
	                b[i] = 0;  
	                b[i-1]++;  
	            }  
	        }  
	    }  

f方法二：

package pers.robert.lanqiaobeizhenti129;

import java.util.Scanner;
import java.util.Vector;
import java.util.concurrent.PriorityBlockingQueue;

/**
 * 27.漏掉的账目明细
某财务部门结账时发现总金额不对头。很可能是从明细上漏掉了某1笔或几笔。
如果已知明细账目清单，能通过编程找到漏掉的是哪1笔或几笔吗？
如果有多种可能，则输出所有可能的情况。
我们规定：用户输入的第一行是：有错的总金额。
接下来是一个整数n，表示下面将要输入的明细账目的条数。
再接下来是n行整数，分别表示每笔账目的金额。
要求程序输出：所有可能漏掉的金额组合。每个情况1行。金额按照从小到大排列，中间用空格分开。
比如：
用户输入：
6
5
3
2
4
3
1
表明：有错的总金额是6；明细共有5笔。
此时，程序应该输出：
1 3 3
1 2 4
3 4
为了方便，不妨假设所有的金额都是整数；每笔金额不超过1000，金额的明细条数不超过100。
 * @author Robert
 *
 */
public class The027MissingAccountDetailDemo1_question {
//该实现类需要自己实现一个继承了 Comparator 接口的类， 在插入资源时会按照自定义的排序规则来对资源数组进行排序。 其中值大的排在数组后面 ，取值时从数组投开始取
	public static String elementOfPriorityBlockingQueue(int array[],boolean used[]) {
		PriorityBlockingQueue<Integer>priorityBlockingQueue=new PriorityBlockingQueue<Integer>();
		for (int i = 0; i < used.length; i++) {
			if(used[i]==true){
				priorityBlockingQueue.add(array[i]);
			}
		}
		StringBuffer sb=new StringBuffer();
		while (!priorityBlockingQueue.isEmpty()) {
			sb.append(priorityBlockingQueue.poll());
		}
		return sb.toString();
	}
	//函数入口：exeForward(priorityBlockingQueue,array, used, 0, 0, tSum);
	public static void exeForward(PriorityBlockingQueue<String> priorityBlockingQueue,int array[],boolean used[],int index,int sum,int tSum) {
		if(sum>tSum){
			return;
		}
		if(sum==tSum){
			String string=elementOfPriorityBlockingQueue(array, used);
			if(!priorityBlockingQueue.contains(string)){
				priorityBlockingQueue.add(string);
			}
			return;
		}
		if(index<=array.length-1){///全排列
			for (int i = 0; i <=1; i++) {
				used[index]=(i==0?false:true);
				sum+=array[index]*i;
				exeForward(priorityBlockingQueue,array, used, index+1, sum, tSum);
				sum-=array[index]*i;
				used[index]=(i==1?false:true);
			}
		}else {
			return;
		}
	}
	public static void main(String[] args) {
		int tSum;
		int n;
		Vector<Integer>vector=new Vector<Integer>();
		Scanner scanner=new Scanner(System.in);
		PriorityBlockingQueue<String>priorityBlockingQueue=new PriorityBlockingQueue<String>();
		//这里是指现有的错误总额
		tSum=scanner.nextInt();
		//条数
		n=scanner.nextInt();
		int array[]=new int[n];
		boolean used[]=new boolean[n];
		tSum*=(-1);
		for (int i = 0; i < n; i++) {
			array[i]=scanner.nextInt();
			tSum+=array[i];
		}
		//下面tSum是指缺了多少钱
		exeForward(priorityBlockingQueue,array, used, 0, 0, tSum);
		while (!priorityBlockingQueue.isEmpty()) {
			String string=priorityBlockingQueue.poll();//poll() 检索并移除此队列的头，或返回 null如果队列为空。 //不停的从队头移出元素
			for (int i = 0; i < string.length(); i++) {
				System.out.print(string.charAt(i));
				if(i!=string.length()-1){
					System.out.print(" ");
				}
			}
			System.out.println();
		}
	}
}