田忌赛马的关键解题思路：

数组arr1元素及排列顺序已定，数组arr2元素已知且可以自由排列。只要arr2数组中存在一种排列顺序能够满足其中任意两元素大于对应arr1中的元素即可win。因此该题的核心点可简化为：求数组arr2的全排列。

数组的全排列

暴力解法固然好想到，面对元素个数较少时也好写出。但面对元素个数过多时就难了。

数组全排列可以通过回溯法生成。

简单思考一下，以[1,2,3]为例。

选定第一个元素[1]。选择第二个元素[1,2]，[1,3]。选定第三个元素，得到两种排列结果：[1,2,3]，[1,3,2]。

重新选定第一个元素[2]。选择第二个元素[2,1]，[2,3]。选定第三个元素，得到：[2,1,3]，[2,3,1]。

重新选定第一个元素[3]。选择第二个元素[3,1]，[3,2]。选定第三个元素，得到：[3,1,2]，[3,2,1]。

可以看到每个步骤中都先满足结果条件（temp.size()==nums.length()）录入结果后，回溯到上一步，重新选择下一个元素。直到数组中的每个元素都被使用过为止。因此回溯法的通用步骤如下：

回溯法步骤

1. 初始化：used数组全为false，临时列表temp为空， permutations用于收集所有排列。
2. 如果temp大小等于3，则加入排列集合。否则，遍历0到2，如果used[i]为false，则选择a[i]，标记used[i]为true，然后递归，然后回溯。

代码实现：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        //输入数组
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int[] arr1 = new int[3];
        int[] arr2 = new int[3];
        for (int i = 0; i < 3; i++) arr1[i] = in.nextInt();
        for (int i = 0; i < 3; i++) arr2[i] = in.nextInt();

        //检查田忌是否能赢
        if (canWin(arr1, arr2)) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }

        in.close();


    }

    public static boolean canWin(int[] king, int[] tian) {
        //生成田忌马匹的所有排列
        List<List<Integer>> permutations = generatePermutation(tian);

        for (List<Integer> per : permutations) {
            if (canWinWithOrder(king, per)) {
                return true;
            }
        }

        return false;

    }

    //检查特定出场顺序下tian是否能赢
    private static boolean canWinWithOrder(int[] king, List<Integer>tianOrder) {
        int winCount = 0;

        //对三场比赛进行比较
        for (int i = 0; i < 3; i++) {
            if (tianOrder.get(i) > king[i]) {
                winCount++;

            }
        }


        return winCount >= 2;
    }


    //生成数组的所有排列
    private static List<List<Integer>> generatePermutation(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(result, new ArrayList<>(), nums, new boolean[nums.length]);
        return result;
    }

    //回溯法生成排列
    private static void backtrack(List<List<Integer>> result, List<Integer> temp,
                                  int[] nums, boolean[] used) {
        //回溯结束条件：当排列数组满了之后停止回溯
        if (temp.size() == nums.length) {
            result.add(new ArrayList<>(temp));
            return;

        }

        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue;

            used[i] = true;
            temp.add(nums[i]);
            backtrack(result, temp, nums, used);
            temp.remove(temp.size() - 1);
            used[i] = false;

        }

    }


}