【算法】一道邏輯題引出的全排列算法，使用代碼模擬邏輯求解邏輯題的示例

題目

一家劇院計劃在秋季的7周內上演7個劇目，它們是F、G、J、K、O、R、S。每週上演一個劇目，每個劇目恰好演出一週。劇目的安排必須滿足以下條件：
（1）G必須在第三週上演。
（2）O和S不能連續演出。
（3）K必須安排在J和S之前上演。
（4）F和J必須安排在連續的兩週中演出。

1、對於任何一種可接受的安排，以下哪項一定爲真？
A：F被安排在K之後的某一週。
B：G恰好被安排在O之前的那一週。
C：J被安排在第一週。
D：R被安排在第二週或第七週。
答案：ABD

2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
A：J、S
B：O、R
C：O、R、S
D：K、O、R
答案：A

3、如果把R安排在第五週，把O安排在第二週，則可供選擇的安排方式有
A：2種
B：3種
C：5種
D：6種
答案：A

4、如果把S安排在第六週，那麼必須把R安排在哪一週？
A：第二週
B：第四周
C：第五週
D：第七週
答案：AB

5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
A：把F安排在O之前
B：K被安排在G之前的某一週。
C：R被安排在第一週或第二週。
D：S恰好安排在K之後的那一週。
答案：ABCD

分析

從題幹可以得知：
1. 有7個元素，分別將這7個元素放到對應的7個格子中
2. 這7個元素還有一些條件，條件如下：
3. G元素必須在第三個格子中
4. O元素和S元素不能連續，兩個元素間距必須大於1
5. K元素的位置必須在J和S元素之前，J和S元素先後不影響，K必須在前
6. F元素和J元素的位置必須相鄰或間隔一個位置

條件1可以轉換爲：有7個人排隊，第1個人有7個位置可以選擇，第2個人有剩下的6個位置可以選擇，最後1個人只有1個位置沒得選，7 ！ = 5040（種）

之後的條件可以藉助集合和元素下標，判斷即可

全排列的遞歸算法

public class Permutation {

    @Test
    public void main() {

        //初始化集合
        List<String> week = init();

        //獲取集合的全排列的集合
        List<List<String>> lists = permutation(week);

        System.out.println("一共有：" + lists.size() + "種");

        //輸出集合
        print(lists);
    }


    public List<String> init() {
        //7個劇目的排列
        List<String> list = new LinkedList<>();
        //F、G、J、K、O、R、S
        list.add("F");
        list.add("G");
        list.add("J");
        list.add("K");
        list.add("O");
        list.add("R");
        list.add("S");

        return list;
    }


    public List<List<String>> permutation(List<String> list) {
        List<List<String>> lists = new LinkedList<>();
        recursion(list, 0, list.size() - 1, lists);
        return lists;
    }


    public void recursion(List<String> in, int p, int q, List<List<String>> out) {
        if (p == q) {
            //最後一個元素不能交換，全排列生成
            out.add(new LinkedList<>(in));
        } else {
            //依次將後面的元素交換到待放入的位置，直到最後一個元素放入
            for (int i = p; i <= q; i++) {
                //交換
                Collections.swap(in, p, i);
                //遞歸
                recursion(in, p + 1, q, out);
                //還原這一次的交換
                Collections.swap(in, p, i);
            }
        }
    }


    public void print(List<List<String>> list) {
        list.forEach(l -> {
            l.forEach(e -> System.out.print(e + " "));
            System.out.println();
        });
        System.out.println();
    }
}

一共5040種，有了這些排列後就可以進行後面四個條件進行判斷

題幹

/**
 * （1）G必須在第三週上演。
 * （2）O和S不能連續演出。
 * （3）K必須安排在J和S之前上演。
 * （4）F和J必須安排在連續的兩週中演出。
 *
 * @param lists
 * @return
 */
public List<List<String>> check0(List<List<String>> lists) {
    return lists.stream().filter(list ->
            //（1）G必須在第三週上演。
            ((list.indexOf("G") + 1) == 3) &&
                    //（2）O和S不能連續演出。
                    (Math.abs(list.indexOf("O") - list.indexOf("S")) != 1) &&
                    //（3）K必須安排在J和S之前上演。
                    (list.indexOf("K") < list.indexOf("J")) &&
                    (list.indexOf("K") < list.indexOf("S")) &&
                    //（4）F和J必須安排在連續的兩週中演出。
                    (Math.abs(list.indexOf("F") - list.indexOf("J")) == 2)
    ).collect(Collectors.toList());
    /*
    一共有：50種
    K J G F O R S
    K J G F S R O
    K F G J O R S
    K F G J S R O
    K O G F R J S
    K O G F S J R
    K O G J R F S
    K O G J S F R
    K O G R J S F
    K O G R F S J
    K O G S J R F
    K O G S F R J
    K R G F O J S
    K R G F S J O
    K R G O F S J
    K R G O J S F
    K R G J O F S
    K R G J S F O
    K R G S J O F
    K R G S F O J
    K S G F O J R
    K S G F R J O
    K S G O F R J
    K S G O J R F
    K S G R F O J
    K S G R J O F
    K S G J O F R
    K S G J R F O
    O K G J R F S
    O K G J S F R
    O K G F R J S
    O K G F S J R
    O K G R F S J
    O K G R J S F
    O K G S F R J
    O K G S J R F
    O R G K F S J
    O R G K J S F
    O R G F K J S
    R K G J O F S
    R K G J S F O
    R K G O J S F
    R K G O F S J
    R K G F O J S
    R K G F S J O
    R K G S F O J
    R K G S J O F
    R O G K J S F
    R O G K F S J
    R O G F K J S
     */
}

第一問

/**
 * 1、對於任何一種可接受的安排，以下哪項一定爲真？
 * A：F被安排在K之後的某一週。
 *
 * @param lists
 * @return 滿足選項的排列集合
 */
public List<List<String>> quest1_A(List<List<String>> lists) {
    return lists.stream().filter(list -> list.indexOf("F") > list.indexOf("K")).collect(Collectors.toList());
    /*
    一共有：48種
    K J G F O R S
    K J G F S R O
    K F G J O R S
    K F G J S R O
    K O G F R J S
    K O G F S J R
    K O G J R F S
    K O G J S F R
    K O G R J S F
    K O G R F S J
    K O G S J R F
    K O G S F R J
    K R G F O J S
    K R G F S J O
    K R G O F S J
    K R G O J S F
    K R G J O F S
    K R G J S F O
    K R G S J O F
    K R G S F O J
    K S G F O J R
    K S G F R J O
    K S G O F R J
    K S G O J R F
    K S G R F O J
    K S G R J O F
    K S G J O F R
    K S G J R F O
    O K G J R F S
    O K G J S F R
    O K G F R J S
    O K G F S J R
    O K G R F S J
    O K G R J S F
    O K G S F R J
    O K G S J R F
    O R G K F S J
    O R G K J S F
    R K G J O F S
    R K G J S F O
    R K G O J S F
    R K G O F S J
    R K G F O J S
    R K G F S J O
    R K G S F O J
    R K G S J O F
    R O G K J S F
    R O G K F S J
     */
}

/**
 * 1、對於任何一種可接受的安排，以下哪項一定爲真？
 * B：G恰好被安排在O之前的那一週。
 *
 * @param lists
 * @return 滿足選項的排列集合
 */
public List<List<String>> quest1_B(List<List<String>> lists) {
    return lists.stream().filter(list -> list.indexOf("O") - list.indexOf("G") == 1).collect(Collectors.toList());
    /*
    一共有：6種
    K R G O F S J
    K R G O J S F
    K S G O F R J
    K S G O J R F
    R K G O J S F
    R K G O F S J
     */
}

/**
 * 1、對於任何一種可接受的安排，以下哪項一定爲真？
 * C：J被安排在第一週。
 *
 * @param lists
 * @return 滿足選項的排列集合
 */
public List<List<String>> quest1_C(List<List<String>> lists) {
    return lists.stream().filter(list -> list.indexOf("J") == 0).collect(Collectors.toList());
    //一共有：0種
}

/**
 * 1、對於任何一種可接受的安排，以下哪項一定爲真？
 * D：R被安排在第二週或第七週。
 *
 * @param lists
 * @return 滿足選項的排列集合
 */
public List<List<String>> quest1_D(List<List<String>> lists) {
    return lists.stream().filter(list -> list.indexOf("R") == 1 || list.indexOf("R") == 6).collect(Collectors.toList());
    /*
    一共有：17種
    K O G F S J R
    K O G J S F R
    K R G F O J S
    K R G F S J O
    K R G O F S J
    K R G O J S F
    K R G J O F S
    K R G J S F O
    K R G S J O F
    K R G S F O J
    K S G F O J R
    K S G J O F R
    O K G J S F R
    O K G F S J R
    O R G K F S J
    O R G K J S F
    O R G F K J S
     */
}

第二問

/**
 * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
 *
 * @param lists
 * @return
 */
public List<List<String>> quest2_init(List<List<String>> lists) {
    return lists.stream().filter(list -> list.indexOf("F") == 4).collect(Collectors.toList());
}

/**
 * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
 * A：J、S
 *
 * @param lists
 * @return
 */
public List<List<String>> quest2_A(List<List<String>> lists) {
    return quest2_init(lists).stream().filter(list -> list.indexOf("J") == 6 || list.indexOf("S") == 6).collect(Collectors.toList());
    /*
    一共有：12種
    K O G R F S J
    K O G S F R J
    K R G O F S J
    K R G S F O J
    K S G O F R J
    K S G R F O J
    O K G R F S J
    O K G S F R J
    O R G K F S J
    R K G O F S J
    R K G S F O J
    R O G K F S J
     */
}

/**
 * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
 * B：O、R
 *
 * @param lists
 * @return
 */
public List<List<String>> quest2_B(List<List<String>> lists) {
    return quest2_init(lists).stream().filter(list -> list.indexOf("O") == 6 || list.indexOf("R") == 6).collect(Collectors.toList());
    //一共有：0種
}

/**
 * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
 * C：O、R、S
 *
 * @param lists
 * @return
 */
public List<List<String>> quest2_C(List<List<String>> lists) {
    return quest2_init(lists).stream().filter(list -> list.indexOf("O") == 6 ||
            list.indexOf("R") == 6 || list.indexOf("S") == 6).collect(Collectors.toList());
    //一共有：0種
}

/**
 * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
 * D：K、O、R
 *
 * @param lists
 * @return
 */
public List<List<String>> quest2_D(List<List<String>> lists) {
    return quest2_init(lists).stream().filter(list -> list.indexOf("K") == 6 ||
            list.indexOf("O") == 6 || list.indexOf("R") == 6).collect(Collectors.toList());
    //一共有：0種
}

第三問

/**
 * 3、如果把R安排在第五週，把O安排在第二週，則可供選擇的安排方式有
 *
 * @param lists
 * @return
 */
public List<List<String>> quest3_init(List<List<String>> lists) {
    return lists.stream().filter(list -> list.indexOf("R") == 4 && list.indexOf("O") == 1).collect(Collectors.toList());
    /*
    一共有：2種
    K O G F R J S
    K O G J R F S
    */
}

第四問

/**
 * 4、如果把S安排在第六週，那麼必須把R安排在哪一週？
 *
 * @param lists
 * @return
 */
public List<List<String>> quest4_init(List<List<String>> lists) {
    return lists.stream().filter(list -> list.indexOf("S") == 5).collect(Collectors.toList());
    /*
    一共有：12種
    K O G R J S F
    K O G R F S J
    K R G O F S J
    K R G O J S F
    O K G R F S J
    O K G R J S F
    O R G K F S J
    O R G K J S F
    R K G O J S F
    R K G O F S J
    R O G K J S F
    R O G K F S J
     */
}

第五問

/**
 * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
 *
 * @param lists
 * @return
 */
public List<List<String>> quest5_init(List<List<String>> lists) {
    return lists.stream().filter(list -> list.indexOf("J") - list.indexOf("O") == 1).collect(Collectors.toList());
}

/**
 * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
 * A：把F安排在O之前
 *
 * @param lists
 * @return
 */
public List<List<String>> quest5_A(List<List<String>> lists) {
    return quest5_init(lists).stream().filter(list -> list.indexOf("O") - list.indexOf("F") > 0).collect(Collectors.toList());
    /*
    一共有：6種
    K R G F O J S
    K R G S F O J
    K S G F O J R
    K S G R F O J
    R K G F O J S
    R K G S F O J
    */
}

/**
 * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
 * B：K被安排在G之前的某一週。
 *
 * @param lists
 * @return
 */
public List<List<String>> quest5_B(List<List<String>> lists) {
    return quest5_init(lists).stream().filter(list -> list.indexOf("G") - list.indexOf("K") > 0).collect(Collectors.toList());
    /*
    一共有：9種
    K R G F O J S
    K R G O J S F
    K R G S F O J
    K S G F O J R
    K S G O J R F
    K S G R F O J
    R K G O J S F
    R K G F O J S
    R K G S F O J
     */
}

/**
 * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
 * C：R被安排在第一週或第二週。
 *
 * @param lists
 * @return
 */
public List<List<String>> quest5_C(List<List<String>> lists) {
    return quest5_init(lists).stream().filter(list -> list.indexOf("R") == 0 || list.indexOf("R") == 1).collect(Collectors.toList());
    /*
    一共有：6種
    K R G F O J S
    K R G O J S F
    K R G S F O J
    R K G O J S F
    R K G F O J S
    R K G S F O J
     */
}

/**
 * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
 * D：S恰好安排在K之後的那一週。
 *
 * @param lists
 * @return
 */
public List<List<String>> quest5_D(List<List<String>> lists) {
    return quest5_init(lists).stream().filter(list -> list.indexOf("S") - list.indexOf("K") == 1).collect(Collectors.toList());
    /*
    一共有：3種
    K S G F O J R
    K S G O J R F
    K S G R F O J
     */
}

全部代碼

package cn;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

public class Permutation {
    @Test
    public void main() {

        //初始化集合
        List<String> week = init();

        //獲取集合的全排列的集合
        List<List<String>> lists = permutation(week);

        //從全排列中找出滿足題乾的集合
        System.out.println("題幹");
        List<List<String>> lists0 = check0(lists);
        print(lists0);

        List<List<String>> result;//滿足的全排列
        //第一題
        System.out.println("1、對於任何一種可接受的安排，以下哪項一定爲真？");
        System.out.println("1、A：F被安排在K之後的某一週。");
        result = quest1_A(lists0);
        print(result);

        System.out.println("1、B：G恰好被安排在O之前的那一週。");
        result = quest1_B(lists0);
        print(result);

        System.out.println("1、C：J被安排在第一週。");
        result = quest1_C(lists0);
        print(result);

        System.out.println("1、D：R被安排在第二週或第七週。");
        result = quest1_D(lists0);
        print(result);

        //第二題
        System.out.println("2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？");
        System.out.println("2、A：J、S");
        result = quest2_A(lists0);
        print(result);

        System.out.println("2、B：O、R");
        result = quest2_B(lists0);
        print(result);

        System.out.println("2、C：O、R、S");
        result = quest2_C(lists0);
        print(result);

        System.out.println("2、D：K、O、R");
        result = quest2_D(lists0);
        print(result);

        //第三題
        System.out.println("3、如果把R安排在第五週，把O安排在第二週，則可供選擇的安排方式有");
        result = quest3_init(lists0);
        print(result);

        //第四題
        System.out.println("4、如果把S安排在第六週，那麼必須把R安排在哪一週？");
        result = quest4_init(lists0);
        print(result);

        //第五題
        System.out.println("5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？");
        System.out.println("5、A：把F安排在O之前");
        result = quest5_A(lists0);
        print(result);

        System.out.println("5、B：K被安排在G之前的某一週。");
        result = quest5_B(lists0);
        print(result);

        System.out.println("5、C：R被安排在第一週或第二週。");
        result = quest5_C(lists0);
        print(result);

        System.out.println("5、D：S恰好安排在K之後的那一週。");
        result = quest5_D(lists0);
        print(result);
    }

    /**
     * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest5_init(List<List<String>> lists) {
        return lists.stream().filter(list -> list.indexOf("J") - list.indexOf("O") == 1).collect(Collectors.toList());
    }

    /**
     * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
     * A：把F安排在O之前
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest5_A(List<List<String>> lists) {
        return quest5_init(lists).stream().filter(list -> list.indexOf("O") - list.indexOf("F") > 0).collect(Collectors.toList());
        /*
        一共有：6種
        K R G F O J S
        K R G S F O J
        K S G F O J R
        K S G R F O J
        R K G F O J S
        R K G S F O J
        */
    }

    /**
     * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
     * B：K被安排在G之前的某一週。
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest5_B(List<List<String>> lists) {
        return quest5_init(lists).stream().filter(list -> list.indexOf("G") - list.indexOf("K") > 0).collect(Collectors.toList());
        /*
        一共有：9種
        K R G F O J S
        K R G O J S F
        K R G S F O J
        K S G F O J R
        K S G O J R F
        K S G R F O J
        R K G O J S F
        R K G F O J S
        R K G S F O J
         */
    }

    /**
     * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
     * C：R被安排在第一週或第二週。
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest5_C(List<List<String>> lists) {
        return quest5_init(lists).stream().filter(list -> list.indexOf("R") == 0 || list.indexOf("R") == 1).collect(Collectors.toList());
        /*
        一共有：6種
        K R G F O J S
        K R G O J S F
        K R G S F O J
        R K G O J S F
        R K G F O J S
        R K G S F O J
         */
    }

    /**
     * 5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
     * D：S恰好安排在K之後的那一週。
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest5_D(List<List<String>> lists) {
        return quest5_init(lists).stream().filter(list -> list.indexOf("S") - list.indexOf("K") == 1).collect(Collectors.toList());
        /*
        一共有：3種
        K S G F O J R
        K S G O J R F
        K S G R F O J
         */
    }


    /**
     * 4、如果把S安排在第六週，那麼必須把R安排在哪一週？
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest4_init(List<List<String>> lists) {
        return lists.stream().filter(list -> list.indexOf("S") == 5).collect(Collectors.toList());
        /*
        一共有：12種
        K O G R J S F
        K O G R F S J
        K R G O F S J
        K R G O J S F
        O K G R F S J
        O K G R J S F
        O R G K F S J
        O R G K J S F
        R K G O J S F
        R K G O F S J
        R O G K J S F
        R O G K F S J
         */
    }


    /**
     * 3、如果把R安排在第五週，把O安排在第二週，則可供選擇的安排方式有
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest3_init(List<List<String>> lists) {
        return lists.stream().filter(list -> list.indexOf("R") == 4 && list.indexOf("O") == 1).collect(Collectors.toList());
        /*
        一共有：2種
        K O G F R J S
        K O G J R F S
        */
    }

    /**
     * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest2_init(List<List<String>> lists) {
        return lists.stream().filter(list -> list.indexOf("F") == 4).collect(Collectors.toList());
    }

    /**
     * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
     * A：J、S
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest2_A(List<List<String>> lists) {
        return quest2_init(lists).stream().filter(list -> list.indexOf("J") == 6 || list.indexOf("S") == 6).collect(Collectors.toList());
        /*
        一共有：12種
        K O G R F S J
        K O G S F R J
        K R G O F S J
        K R G S F O J
        K S G O F R J
        K S G R F O J
        O K G R F S J
        O K G S F R J
        O R G K F S J
        R K G O F S J
        R K G S F O J
        R O G K F S J
         */
    }

    /**
     * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
     * B：O、R
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest2_B(List<List<String>> lists) {
        return quest2_init(lists).stream().filter(list -> list.indexOf("O") == 6 || list.indexOf("R") == 6).collect(Collectors.toList());
        //一共有：0種
    }

    /**
     * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
     * C：O、R、S
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest2_C(List<List<String>> lists) {
        return quest2_init(lists).stream().filter(list -> list.indexOf("O") == 6 ||
                list.indexOf("R") == 6 || list.indexOf("S") == 6).collect(Collectors.toList());
        //一共有：0種
    }

    /**
     * 2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
     * D：K、O、R
     *
     * @param lists
     * @return
     */
    public List<List<String>> quest2_D(List<List<String>> lists) {
        return quest2_init(lists).stream().filter(list -> list.indexOf("K") == 6 ||
                list.indexOf("O") == 6 || list.indexOf("R") == 6).collect(Collectors.toList());
        //一共有：0種
    }

    /**
     * 1、對於任何一種可接受的安排，以下哪項一定爲真？
     * A：F被安排在K之後的某一週。
     *
     * @param lists
     * @return 滿足選項的排列集合
     */
    public List<List<String>> quest1_A(List<List<String>> lists) {
        return lists.stream().filter(list -> list.indexOf("F") > list.indexOf("K")).collect(Collectors.toList());
        /*
        一共有：48種
        K J G F O R S
        K J G F S R O
        K F G J O R S
        K F G J S R O
        K O G F R J S
        K O G F S J R
        K O G J R F S
        K O G J S F R
        K O G R J S F
        K O G R F S J
        K O G S J R F
        K O G S F R J
        K R G F O J S
        K R G F S J O
        K R G O F S J
        K R G O J S F
        K R G J O F S
        K R G J S F O
        K R G S J O F
        K R G S F O J
        K S G F O J R
        K S G F R J O
        K S G O F R J
        K S G O J R F
        K S G R F O J
        K S G R J O F
        K S G J O F R
        K S G J R F O
        O K G J R F S
        O K G J S F R
        O K G F R J S
        O K G F S J R
        O K G R F S J
        O K G R J S F
        O K G S F R J
        O K G S J R F
        O R G K F S J
        O R G K J S F
        R K G J O F S
        R K G J S F O
        R K G O J S F
        R K G O F S J
        R K G F O J S
        R K G F S J O
        R K G S F O J
        R K G S J O F
        R O G K J S F
        R O G K F S J
         */
    }

    /**
     * 1、對於任何一種可接受的安排，以下哪項一定爲真？
     * B：G恰好被安排在O之前的那一週。
     *
     * @param lists
     * @return 滿足選項的排列集合
     */
    public List<List<String>> quest1_B(List<List<String>> lists) {
        return lists.stream().filter(list -> list.indexOf("O") - list.indexOf("G") == 1).collect(Collectors.toList());
        /*
        一共有：6種
        K R G O F S J
        K R G O J S F
        K S G O F R J
        K S G O J R F
        R K G O J S F
        R K G O F S J
         */
    }

    /**
     * 1、對於任何一種可接受的安排，以下哪項一定爲真？
     * C：J被安排在第一週。
     *
     * @param lists
     * @return 滿足選項的排列集合
     */
    public List<List<String>> quest1_C(List<List<String>> lists) {
        return lists.stream().filter(list -> list.indexOf("J") == 0).collect(Collectors.toList());
        //一共有：0種
    }

    /**
     * 1、對於任何一種可接受的安排，以下哪項一定爲真？
     * D：R被安排在第二週或第七週。
     *
     * @param lists
     * @return 滿足選項的排列集合
     */
    public List<List<String>> quest1_D(List<List<String>> lists) {
        return lists.stream().filter(list -> list.indexOf("R") == 1 || list.indexOf("R") == 6).collect(Collectors.toList());
        /*
        一共有：17種
        K O G F S J R
        K O G J S F R
        K R G F O J S
        K R G F S J O
        K R G O F S J
        K R G O J S F
        K R G J O F S
        K R G J S F O
        K R G S J O F
        K R G S F O J
        K S G F O J R
        K S G J O F R
        O K G J S F R
        O K G F S J R
        O R G K F S J
        O R G K J S F
        O R G F K J S
         */
    }


    /**
     * （1）G必須在第三週上演。
     * （2）O和S不能連續演出。
     * （3）K必須安排在J和S之前上演。
     * （4）F和J必須安排在連續的兩週中演出。
     *
     * @param lists
     * @return
     */
    public List<List<String>> check0(List<List<String>> lists) {
        return lists.stream().filter(list ->
                //（1）G必須在第三週上演。
                ((list.indexOf("G") + 1) == 3) &&
                        //（2）O和S不能連續演出。
                        (Math.abs(list.indexOf("O") - list.indexOf("S")) != 1) &&
                        //（3）K必須安排在J和S之前上演。
                        (list.indexOf("K") < list.indexOf("J")) &&
                        (list.indexOf("K") < list.indexOf("S")) &&
                        //（4）F和J必須安排在連續的兩週中演出。
                        (Math.abs(list.indexOf("F") - list.indexOf("J")) == 2)
        ).collect(Collectors.toList());
        /*
        一共有：50種
        K J G F O R S
        K J G F S R O
        K F G J O R S
        K F G J S R O
        K O G F R J S
        K O G F S J R
        K O G J R F S
        K O G J S F R
        K O G R J S F
        K O G R F S J
        K O G S J R F
        K O G S F R J
        K R G F O J S
        K R G F S J O
        K R G O F S J
        K R G O J S F
        K R G J O F S
        K R G J S F O
        K R G S J O F
        K R G S F O J
        K S G F O J R
        K S G F R J O
        K S G O F R J
        K S G O J R F
        K S G R F O J
        K S G R J O F
        K S G J O F R
        K S G J R F O
        O K G J R F S
        O K G J S F R
        O K G F R J S
        O K G F S J R
        O K G R F S J
        O K G R J S F
        O K G S F R J
        O K G S J R F
        O R G K F S J
        O R G K J S F
        O R G F K J S
        R K G J O F S
        R K G J S F O
        R K G O J S F
        R K G O F S J
        R K G F O J S
        R K G F S J O
        R K G S F O J
        R K G S J O F
        R O G K J S F
        R O G K F S J
        R O G F K J S
         */
    }

    /**
     * 初始化劇目
     *
     * @return
     */
    public List<String> init() {
        //7個劇目的排列
        List<String> list = new LinkedList<>();
        //F、G、J、K、O、R、S
        list.add("F");
        list.add("G");
        list.add("J");
        list.add("K");
        list.add("O");
        list.add("R");
        list.add("S");

        return list;
    }

    /**
     * 全排列算法
     *
     * @param list 其中的一個排列方式
     * @return 所有的全排列的集合
     */
    public List<List<String>> permutation(List<String> list) {
        List<List<String>> lists = new ArrayList<>();
        recursion(list, 0, list.size() - 1, lists);
        return lists;
    }

    public void recursion(List<String> in, int p, int q, List<List<String>> out) {
        if (p == q) {
            //最後一個元素不能交換，全排列生成
            out.add(new LinkedList<>(in));
        } else {
            //依次將後面的元素交換到待放入的位置，直到最後一個元素放入
            for (int i = p; i <= q; i++) {
                //交換
                Collections.swap(in, p, i);
                //遞歸
                recursion(in, p + 1, q, out);
                //還原這一次的交換
                Collections.swap(in, p, i);
            }
        }
    }

    public void print(List<List<String>> list) {
        System.out.println("一共有：" + list.size() + "種");
        list.forEach(l -> {
            l.forEach(e -> System.out.print(e + " "));
            System.out.println();
        });
        System.out.println();
    }
}

輸出

題幹
一共有：50種
K J G F O R S
K J G F S R O
K F G J O R S
K F G J S R O
K O G F R J S
K O G F S J R
K O G J R F S
K O G J S F R
K O G R J S F
K O G R F S J
K O G S J R F
K O G S F R J
K R G F O J S
K R G F S J O
K R G O F S J
K R G O J S F
K R G J O F S
K R G J S F O
K R G S J O F
K R G S F O J
K S G F O J R
K S G F R J O
K S G O F R J
K S G O J R F
K S G R F O J
K S G R J O F
K S G J O F R
K S G J R F O
O K G J R F S
O K G J S F R
O K G F R J S
O K G F S J R
O K G R F S J
O K G R J S F
O K G S F R J
O K G S J R F
O R G K F S J
O R G K J S F
O R G F K J S
R K G J O F S
R K G J S F O
R K G O J S F
R K G O F S J
R K G F O J S
R K G F S J O
R K G S F O J
R K G S J O F
R O G K J S F
R O G K F S J
R O G F K J S

1、對於任何一種可接受的安排，以下哪項一定爲真？
1、A：F被安排在K之後的某一週。
一共有：48種
K J G F O R S
K J G F S R O
K F G J O R S
K F G J S R O
K O G F R J S
K O G F S J R
K O G J R F S
K O G J S F R
K O G R J S F
K O G R F S J
K O G S J R F
K O G S F R J
K R G F O J S
K R G F S J O
K R G O F S J
K R G O J S F
K R G J O F S
K R G J S F O
K R G S J O F
K R G S F O J
K S G F O J R
K S G F R J O
K S G O F R J
K S G O J R F
K S G R F O J
K S G R J O F
K S G J O F R
K S G J R F O
O K G J R F S
O K G J S F R
O K G F R J S
O K G F S J R
O K G R F S J
O K G R J S F
O K G S F R J
O K G S J R F
O R G K F S J
O R G K J S F
R K G J O F S
R K G J S F O
R K G O J S F
R K G O F S J
R K G F O J S
R K G F S J O
R K G S F O J
R K G S J O F
R O G K J S F
R O G K F S J

1、B：G恰好被安排在O之前的那一週。
一共有：6種
K R G O F S J
K R G O J S F
K S G O F R J
K S G O J R F
R K G O J S F
R K G O F S J

1、C：J被安排在第一週。
一共有：0種

1、D：R被安排在第二週或第七週。
一共有：17種
K O G F S J R
K O G J S F R
K R G F O J S
K R G F S J O
K R G O F S J
K R G O J S F
K R G J O F S
K R G J S F O
K R G S J O F
K R G S F O J
K S G F O J R
K S G J O F R
O K G J S F R
O K G F S J R
O R G K F S J
O R G K J S F
O R G F K J S

2、如果把F安排在第五週上演，以下哪項正確地列出了所有可以安排在第七週上演的劇目？
2、A：J、S
一共有：12種
K O G R F S J
K O G S F R J
K R G O F S J
K R G S F O J
K S G O F R J
K S G R F O J
O K G R F S J
O K G S F R J
O R G K F S J
R K G O F S J
R K G S F O J
R O G K F S J

2、B：O、R
一共有：0種

2、C：O、R、S
一共有：0種

2、D：K、O、R
一共有：0種

3、如果把R安排在第五週，把O安排在第二週，則可供選擇的安排方式有
一共有：2種
K O G F R J S
K O G J R F S

4、如果把S安排在第六週，那麼必須把R安排在哪一週？
一共有：12種
K O G R J S F
K O G R F S J
K R G O F S J
K R G O J S F
O K G R F S J
O K G R J S F
O R G K F S J
O R G K J S F
R K G O J S F
R K G O F S J
R O G K J S F
R O G K F S J

5、如果O恰好被安排在J之前的那一週，以下哪項一定爲真？
5、A：把F安排在O之前
一共有：6種
K R G F O J S
K R G S F O J
K S G F O J R
K S G R F O J
R K G F O J S
R K G S F O J

5、B：K被安排在G之前的某一週。
一共有：9種
K R G F O J S
K R G O J S F
K R G S F O J
K S G F O J R
K S G O J R F
K S G R F O J
R K G O J S F
R K G F O J S
R K G S F O J

5、C：R被安排在第一週或第二週。
一共有：6種
K R G F O J S
K R G O J S F
K R G S F O J
R K G O J S F
R K G F O J S
R K G S F O J

5、D：S恰好安排在K之後的那一週。
一共有：3種
K S G F O J R
K S G O J R F
K S G R F O J