【每天一题ACM】可重复组合数的实现，求解素数解组合Prime Solutions

先看题目：

Prime Solutions

       以下是一段中學時代的慘痛回憶…每當學到排列組合的單元時，最痛苦的不是分析題目，也不是帶錯公式或計算錯誤，而是所謂的「苦工題」，以下這題是個例子:

給定正整數N與S，求出方程式(1)的所有質數解(全為質數)。

遇到這題，通常只能硬著頭皮將每一組以「土法煉鋼」的方式一一列出，然而到了大學修過程式設計與演算法課，俾使我們能在電腦上撰寫程式輕鬆解決此問題。

 

INPUT

第一行一樣為測資個數

每一行輸入正整數與正整數，N與S之間相隔一個空白鍵。

(提示: 計算之前先考慮方程式有沒有解可以加速程式執行。)

 

OUTPUT

N個質數相加剛好等於S有哪些可能的組合，質數可以重複,但請由小到大排列，若無解(例如100個質數相加等於23無解)則輸出0，解可能不只一組，若有多組解時，靠左邊的數字較小的那組解則優先輸出，請參照SAMPLE OUTPUT。每一筆測資的輸出之間也換一行。

 

SAMPLE INPUT

4

2 5

100 23

3 8

4 25

SAMPLE OUTPUT

2 3

0

2 3 3

2 2 2 19  

2 3 3 17

2 3 7 13

2 5 5 13

2 5 7 11 

---------------分割线---------------

首先先来解释一下题目，首先input第一行的4是资料的笔数，之后的2 5代表  5以内的质数取2个相加等于5，5以内的质数有 2、3，2+3=5所以输出2 3。

本题主要考验的是质数的求解（简单）以及可重复排列数的实现（时间复杂度较大）

根据题目需要，可以大概得到这样一个流程：

关键的难点在于可重复排列数，其思路是设定一个标签来标记当前的位置，循环+递归。同时附加从大到小或者从小到大排列能够节省大量的运算时间。

下面来看代码：

    /** 
    * @Title: getCombination 
    * @Description: 递归取得可重复排列数
    * @throws 
    */
    private void getCombination(ArrayList<Integer> arr, int n, int begin, ArrayList<Integer> rs, int index) {
        if (n == 0) {
            rsList.add(rs);
            return;
        }
        for (int i = 0; i < arr.size(); i++) {

            if (index == 0 || arr.get(i) >= rs.get(index - 1)) {
                rs.set(index, arr.get(i));
                getCombination(arr, n - 1, i + 1, clone(rs), index + 1);
            }
        }
    }

    /**
     * @Description: 得到质数表
     */
    private ArrayList<Integer> getAllPrimeNum(int num) {
        ArrayList<Integer> primeNums = new ArrayList<>();
        for (int i = 2; i <= num; i++) {
            if (isPrimeNumber(i))
                primeNums.add(i);
        }
        return primeNums;
    }

    /**
     * @Title: isPrimeNumber
     * @Description: 判断是否是质数
     */
    public boolean isPrimeNumber(int number) {
        if (number <= 1)
            return false;
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0)
                return false;
        }
        return true;
    }

    /** 
    * @Title: isEquals 
    * @Description: 判断arr所有数的和是否等于sum
    */
    public boolean isEquals(ArrayList<Integer> arr, int sum) {
        int temp = 0;
        for (int num : arr) {
            temp += num;
        }
        return sum == temp;
    }

/**
     * @Title: sort
     * @Description: 无聊的排序而已，按照hashCode排序
     */
    public void sort(ArrayList<ArrayList<Integer>> rs) {
        for (int i = 0; i < rs.size(); i++) {
            for (int j = i + 1; j < rs.size(); j++) {
                if (rs.get(i).hashCode() > rs.get(j).hashCode()) {
                    ArrayList<Integer> temp = rs.get(i);
                    rs.set(i, rs.get(j));
                    rs.set(j, temp);
                }
            }
        }
    }

/** 
    * @Title: primeSolution 
    * @Description: 程序主逻辑
    */
    public ArrayList<ArrayList<Integer>> primeSolution(int n, int num) {
        ArrayList<Integer> arr = getAllPrimeNum(num);
        ArrayList<Integer> temp = getAllPrimeNum(n);
        ArrayList<ArrayList<Integer>> okList = new ArrayList<>();

        while (temp.size() < n) {
            temp.add(0);
        }
        if ((!isHasResult(arr, num, n)) && n > arr.size())
            return null;

        getCombination(arr, n, 0, temp, 0);
        for (ArrayList<Integer> rs : rsList) {
            if (isEquals(rs, num) && rs.size() == n) {
                okList.add(rs);
            }
        }
        return okList;
    }

完整代码如下：

import java.util.ArrayList;
import java.util.Scanner;

/**
 * @author lcc 957109587@qq.com
 * @version 2016年3月9日 下午9:00:43
 * @Description
 */
public class PrimeSolutions {
    static ArrayList<ArrayList<Integer>> rsList = new ArrayList<>();

    public static void main(String[] args) {
        @SuppressWarnings("resource")
        Scanner scan = new Scanner(System.in);
        ArrayList<ArrayList> okList = new ArrayList<>();
        PrimeSolutions primeSolutions = new PrimeSolutions();
        int runtimes = scan.nextInt();
        for (int i = 0; i < runtimes; i++) {
            int n = scan.nextInt();
            int num = scan.nextInt();
            okList.add(primeSolutions.primeSolution(n, num));
        }
        for (int j = 0; j < okList.size(); j++) {
            if (okList.get(j) == null) {
                System.out.println(0);
            } else {
                primeSolutions.outPut(okList.get(j));
            }
            if (j < okList.size() - 1) {
                System.out.println();
            }
        }
    }

    /** 
    * @Title: primeSolution 
    * @Description: 程序主逻辑
    */
    public ArrayList<ArrayList<Integer>> primeSolution(int n, int num) {
        ArrayList<Integer> arr = getAllPrimeNum(num);
        ArrayList<Integer> temp = getAllPrimeNum(n);
        ArrayList<ArrayList<Integer>> okList = new ArrayList<>();

        while (temp.size() < n) {
            temp.add(0);
        }
        if ((!isHasResult(arr, num, n)) && n > arr.size())
            return null;

        getCombination(arr, n, 0, temp, 0);
        for (ArrayList<Integer> rs : rsList) {
            if (isEquals(rs, num) && rs.size() == n) {
                okList.add(rs);
            }
        }
        return okList;
    }

    /** 
    * @Title: getCombination 
    * @Description: 递归取得可重复排列数
    * @throws 
    */
    private void getCombination(ArrayList<Integer> arr, int n, int begin, ArrayList<Integer> rs, int index) {
        if (n == 0) {
            rsList.add(rs);
            return;
        }
        for (int i = 0; i < arr.size(); i++) {

            if (index == 0 || arr.get(i) >= rs.get(index - 1)) {
                rs.set(index, arr.get(i));
                getCombination(arr, n - 1, i + 1, clone(rs), index + 1);
            }
        }
    }

    /** 
    * @Title: clone 
    * @Description: 深拷贝List
    */
    private ArrayList<Integer> clone(ArrayList<Integer> rs) {
        ArrayList<Integer> tocopy = new ArrayList<>();
        for (int num : rs) {
            int temp = num;
            tocopy.add(temp);
        }
        return tocopy;
    }

    /** 
    * @Title: isHasResult 
    * @Description: 判断是否有结果条件之一
    */
    public boolean isHasResult(ArrayList<Integer> arr, int num, int n) {
        for (int temp : arr) {
            if (temp * n == num) {
                return true;
            }
        }
        return false;
    }

    /** 
    * @Title: isEquals 
    * @Description: 判断arr所有数的和是否等于sum
    */
    public boolean isEquals(ArrayList<Integer> arr, int sum) {
        int temp = 0;
        for (int num : arr) {
            temp += num;
        }
        return sum == temp;
    }

    /**
     * @Description: 得到质数表
     */
    private ArrayList<Integer> getAllPrimeNum(int num) {
        ArrayList<Integer> primeNums = new ArrayList<>();
        for (int i = 2; i <= num; i++) {
            if (isPrimeNumber(i))
                primeNums.add(i);
        }
        return primeNums;
    }

    /**
     * @Title: isPrimeNumber
     * @Description: 判断是否是质数
     */
    public boolean isPrimeNumber(int number) {
        if (number <= 1)
            return false;
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0)
                return false;
        }
        return true;
    }

    /**
     * @Title: sort
     * @Description: 无聊的排序而已，按照hashCode排序
     */
    public void sort(ArrayList<ArrayList<Integer>> rs) {
        for (int i = 0; i < rs.size(); i++) {
            for (int j = i + 1; j < rs.size(); j++) {
                if (rs.get(i).hashCode() > rs.get(j).hashCode()) {
                    ArrayList<Integer> temp = rs.get(i);
                    rs.set(i, rs.get(j));
                    rs.set(j, temp);
                }
            }
        }
    }

    /**
     * @Description: 按照格式输出rs
     */
    public void outPut(ArrayList<ArrayList<Integer>> rs) {
        sort(rs);
        for (int i = 0; i < rs.size(); i++) {
            for (int temp : rs.get(i))
                System.out.print(temp + " ");
            System.out.println();
        }
    }
}

欢迎指正！