import java.util.ArrayList;


public class Main {
        // 计算最大素数伴侣对数
        static public int countMaxPrimerPairs(Input input) {
                if (input.size() == 0) {
                        return 0;
                }

                int nPairs = 0;
                int record = 0;
                for (int i = 0; i < input.size(); i++) {
                        for (int j = i+1; j < input.size(); j++) {
                                record = testPairs(input.get(i,j)) + 
                                                countMaxPrimerPairs(input.delete(i,j));
                                if (nPairs < record) {
                                        nPairs = record;
                                }
                        }
                }

                return nPairs;
        }

        // 测试一个数据对是否是素数伴侣
        static public int testPairs(Pair p) {
                int n = p.x + p.y;
                System.out.println(p);
                if (isPrimer(n)) {
                        return 1;
                }

                return 0;
        }

        // 判断一个数是否是质数
        static private boolean isPrimer(int n) {
                if (n==2 || n==3 || n==5) return true;

                if (n%2 == 0) return false;

                int sqrtV = (int) Math.sqrt(n);
                for (int i=3; i<sqrtV; i=i+2) {
                        if (n%i == 0) {
                                return false;
                        }
                }

                return true;
        }

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                Input input = new Input();
                input.add(2);
                input.add(3);
                input.add(4);
                input.add(5);

                int n = countMaxPrimerPairs(input);
                System.out.println(n);
        }

}

/**
 * 记录输入的参数信息
 * @author Zz
 *
 */
class Input {
        private ArrayList<Integer> arrayList;

        public Input() {
                arrayList = new ArrayList<>();
        }

        public Input(ArrayList<Integer> list) {
                arrayList = new ArrayList<>(list);
        }

        /**
         * 添加元素
         * @param a
         */
        public void add(int a) {
                arrayList.add(new Integer(a));
        }

        /**
         * 获得相应位置的元素
         * @param i 第i个位置
         * @param j 第j个位置
         * @return Pair
         */
        public Pair get(int i, int j) {
                return new Pair(arrayList.get(i).intValue(), 
                                arrayList.get(j).intValue());
        }

        public int size() {
                return arrayList.size();
        }

        public Input delete(int i, int j) {
                // 使用浅复制，具体数值在内存中只存在一份
                @SuppressWarnings("unchecked")
                ArrayList<Integer> list = (ArrayList<Integer>) arrayList.clone();
                list.remove(i);
                list.remove(j-1);  // 第一个移除，使得所有的元素都向前移动了一个位置
                Input input = new Input(list);

                return input;
        }
}


/**
 * 用来记录配对点的信息
 * @author Zz
 *
 */
class Pair {
        public final int x;
        public final int y;

        public Pair(int a, int b) {
                x = a;
                y = b;
        }

        public String toString() {
                return "(" + x + "," + y + ")";
        }
}

public class Main {
        private static Hashtable<String, Integer> table;
        
        static public void initTable() {
                table = new Hashtable<String, Integer>();
        }
        
        /**
         * 计算最大素数伴侣对数
         * @param input 
         * @param level 标记递归中具体的层次
         * @return
         */
        static public int countMaxPrimerPairs(Input input, int level) {
                if (input.size() == 0) {
                        return 0;
                }
                
                int nPairs = 0;
                int record = 0;
                Pair pair;
                int testResult;
                
                for (int i = 0; i < input.size(); i++) {
                        for (int j = i+1; j < input.size(); j++) {
                                pair = input.get(i, j);
                                                                
                                if (table.containsKey(pair.toString())) {
                                        testResult = table.get(pair.toString());
                                } else {
                                        for (int k=0; k<level; ++k) System.out.print("\t");
                                        testResult = testPairs(pair);
                                        table.put(pair.toString(), new Integer(testResult));
                                }
                                
                                record = testResult + 
                                                countMaxPrimerPairs(input.delete(i,j), level+1);
                                if (nPairs < record) {
                                        nPairs = record;
                                }
                        }
                }
                
                for (int k=0; k<level; ++k) {
                        System.out.print("\t");
                }
                System.out.println("return " + nPairs);
                return nPairs;
        }
        
        // 测试一个数据对是否是素数伴侣
        static public int testPairs(Pair p) {
                   ...
        }
        
        // 判断一个数是否是质数
        static private boolean isPrimer(int n) {
                     ...
        }
        
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                initTable();
                
                     ...
        }

}