用java写一个任务数与人数相等的蛮力法解决任务分配问题并配注释

好的，这是一个任务分配问题，给定 $n$ 个任务和 $n$ 个人，每个人可以完成一个任务，每个任务需要一个人来完成，如何分配任务，使得完成所有任务的时间最短？

一种蛮力法是枚举所有可能的任务分配方案，计算出完成所有任务的时间，然后找到时间最短的方案。具体实现如下：

import java.util.Scanner;

public class TaskAssignment {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] times = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                times[i][j] = scanner.nextInt();
            }
        }
        int[] perm = new int[n];
        for (int i = 0; i < n; i++) {
            perm[i] = i;
        }
        int minTime = Integer.MAX_VALUE;
        int[] bestPerm = new int[n];
        do {
            int time = 0;
            for (int i = 0; i < n; i++) {
                time += times[i][perm[i]];
            }
            if (time < minTime) {
                minTime = time;
                System.arraycopy(perm, 0, bestPerm, 0, n);
            }
        } while (nextPermutation(perm));
        System.out.println("最短时间为：" + minTime);
        System.out.println("最佳任务分配方案为：");
        for (int i = 0; i < n; i++) {
            System.out.println("任务 " + (i + 1) + " 分配给了人 " + (bestPerm[i] + 1));
        }
    }
    
    // 计算下一个排列，用于枚举所有任务分配方案
    private static boolean nextPermutation(int[] array) {
        int i = array.length - 2;
        while (i >= 0 && array[i] >= array[i + 1]) {
            i--;
        }
        if (i < 0) {
            return false;
        }
        int j = array.length - 1;
        while (array[j] <= array[i]) {
            j--;
        }
        swap(array, i, j);
        reverse(array, i + 1, array.length - 1);
        return true;
    }
    
    // 交换数组中的两个元素
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    
    // 将数组中的一段元素反转
    private static void reverse(int[] array, int begin, int end) {
        while (begin < end) {
            swap(array, begin++, end--);
        }
    }
}

代码中，`times[i][j]` 表示第 $i$ 个人完成第 $j$ 个任务所需的时间。`perm` 数组存储当前任务分配方案，初始为 $[0, 1, \cdots, n-1]$。`nextPermutation` 方法计算下一个排列，用于枚举所有任务分配方案。`swap` 方法交换数组中的两个元素，`reverse` 方法将数组中的一段元素反转。在每次枚举完一个任务分配方案后，计算完成所有任务需要的时间，如果时间更短，则更新最短时间和最佳任务分配方案。

注意，这种蛮力法的时间复杂度为 $O(n!)$，当 $n$ 很大时，不适用于实际应用。