题目

一家剧院计划在秋季的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