JAVA算法 几个数有几种排列组合

你要是智慧盈通的正在面试请别看!!

 static List<int[]> allSorts = new ArrayList<int[]>();
    public static void main(String[] args) {
        int[] numArray = {1, 2, 3, 4, 5,8};
        permutation(numArray, 0, numArray.length - 1);
        int[][] a = new int[allSorts.size()][]; // 你要的二维数组a
        allSorts.toArray(a);
        int count=0;
        // 打印验证
        for (int i=0; i<a.length; i++) {
            int[] nums = a[i];
            Boolean isShow = true;
            List<Integer> list = new ArrayList<>();
            for (int j=0; j<nums.length; j++) {
                if(j==3&&nums[j]==3){
                    isShow=false;
                    break;
                }
                if(j>1&&nums[j]==2&&nums[j-1]!=4){
                    isShow=false;
                    break;
                }else if(j>1&&nums[j]==4&&nums[j-1]!=2){
                    isShow=false;
                    break;
                }
                list.add(nums[j]);
            }
            if(isShow){
                System.out.println(list);
                count++;
            }
        }
        System.out.println("count"+count);
    }

    public static void permutation(int[] nums, int start, int end) {
        if (start == end) { // 当只要求对数组中一个数字进行全排列时,只要就按该数组输出即可
            int[] newNums = new int[nums.length]; // 为新的排列创建一个数组容器
            for (int i=0; i<=end; i++) {
                newNums[i] = nums[i];
            }
            allSorts.add(newNums); // 将新的排列组合存放起来
        } else {
            for (int i=start; i<=end; i++) {
                int temp = nums[start]; // 交换数组第一个元素与后续的元素
                nums[start] = nums[i];
                nums[i] = temp;
                permutation(nums, start + 1, end); // 后续元素递归全排列
                nums[i] = nums[start]; // 将交换后的数组还原
                nums[start] = temp;
            }
        }
    }
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
语言实现。 可以的,回溯算法是一常用的算法,它通常用于解决组合问题、排列问题和搜索问题等。以下是几个回溯算法的例子,用 Java 语言实现: 1. 八皇后问题 八皇后问题是一个经典的回溯算法问题,它的目标是在一个 8x8 的棋盘上放置 8 个皇后,使得每个皇后都不会互相攻击。以下是 Java 代码实现: public class EightQueens { private static final int N = 8; private static int[] queens = new int[N]; public static void main(String[] args) { solve(); } private static void solve(int row) { if (row == N) { printQueens(); return; } for (int col = ; col < N; col++) { if (isValid(row, col)) { queens[row] = col; solve(row + 1); } } } private static boolean isValid(int row, int col) { for (int i = ; i < row; i++) { if (queens[i] == col || Math.abs(row - i) == Math.abs(col - queens[i])) { return false; } } return true; } private static void printQueens() { for (int i = ; i < N; i++) { for (int j = ; j < N; j++) { if (queens[i] == j) { System.out.print("Q "); } else { System.out.print(". "); } } System.out.println(); } System.out.println(); } } 2. -1 背包问题 -1 背包问题是一个经典的动态规划问题,它的目标是在给定的一组物品中选择一些物品放入一个背包中,使得背包中物品的总价最大,但是不能超过背包的容量。以下是 Java 代码实现: public class Knapsack { private static final int N = 5; private static final int W = 10; private static int[] weights = {2, 2, 6, 5, 4}; private static int[] values = {6, 3, 5, 4, 6}; private static int maxValue = ; private static boolean[] selected = new boolean[N]; public static void main(String[] args) { solve(, , ); System.out.println("Max value: " + maxValue); for (int i = ; i < N; i++) { if (selected[i]) { System.out.print(i + " "); } } } private static void solve(int index, int weight, int value) { if (weight > W) { return; } if (index == N) { if (value > maxValue) { maxValue = value; System.arraycopy(selected, , selected, , N); } return; } selected[index] = true; solve(index + 1, weight + weights[index], value + values[index]); selected[index] = false; solve(index + 1, weight, value); } } 3. 数独问题 数独问题是一个经典的递归回溯问题,它的目标是在一个 9x9 的数独棋盘上填入数字,使得每行、每列和每个 3x3 的子区域中都包含数字 1-9,且每个数字只能出现一次。以下是 Java 代码实现: public class Sudoku { private static final int N = 9; private static int[][] board = { {, , , , , , , , }, {, , , , , , , , }, {, , , , , , , , }, {, , , , , , , , }, {, , , , , , , , }, {, , , , , , , , }, {, , , , , , , , }, {, , , , , , , , }, {, , , , , , , , } }; public static void main(String[] args) { solve(, ); printBoard(); } private static boolean solve(int row, int col) { if (row == N) { return true; } if (col == N) { return solve(row + 1, ); } if (board[row][col] != ) { return solve(row, col + 1); } for (int num = 1; num <= 9; num++) { if (isValid(row, col, num)) { board[row][col] = num; if (solve(row, col + 1)) { return true; } board[row][col] = ; } } return false; } private static boolean isValid(int row, int col, int num) { for (int i = ; i < N; i++) { if (board[row][i] == num || board[i][col] == num) { return false; } } int r = row / 3 * 3; int c = col / 3 * 3; for (int i = r; i < r + 3; i++) { for (int j = c; j < c + 3; j++) { if (board[i][j] == num) { return false; } } } return true; } private static void printBoard() { for (int i = ; i < N; i++) { for (int j = ; j < N; j++) { System.out.print(board[i][j] + " "); } System.out.println(); } } } 以上是三个回溯算法的例子,它们分别是八皇后问题、-1 背包问题和数独问题。这些算法都是经典的算法,可以帮助我们更好地理解回溯算法的思想和应用。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

I'm the future

希望有幸帮到解决问题

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值