工作分配問題（回溯法）

工作分配問題
設有n件工作要分配給n個人去完成，將工作i分配給第j個人所需費用爲 。試設計一個算法，爲每個人分配1件不同的工作，並使總費用達到最小。

package ustc.test;

import java.util.Scanner;

public class distribution {
    static int n = 0;
    static int cost = 0;
    static int[] x = new int[100];
    static int[][] c = new int[100][100];

    public static void main(String[] args){
        System.out.println("設置工作（人數）：");
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        System.out.println("設置費用：");
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= n; j++){
                c[i][j] = in.nextInt();
                x[j] = 0;
            }
            cost += c[i][i];
        }
        work(1, 0);
        System.out.println("費用最小爲：" + cost);
    }
    //
    public static void work(int i, int count){
        if(i > n && count < cost ){
            cost = count;
            return ;
        }
        if(count < cost){
            for(int j = 1; j <= n; j++){
                if(x[j] == 0){
                    x[j] = 1;
                    work(i + 1, count + c[i][j]);
                    x[j] = 0;
                }
            }
        }
    }
}

由於每個人都必須分配到工作，在這裏可以建一個二維數組c[i][j]，用以表示i號工人完成j號工作所需的費用。給定一個循環，從第1個工人開始循環分配工作，直到所有工人都分配到。爲第i個工人分配工作時，再循環檢查每個工作是否已被分配，沒有則分配給i號工人，否則檢查下一個工作。可以用一個一維數組x[j]來表示第j 號工作是否被分配，未分配則x[j]=0，否則x[j]=1。利用回溯思想，在工人循環結束後回到上一工人，取消此次分配的工作，而去分配下一工作直到可以分配爲止。這樣，一直回溯到第1個工人後，就能得到所有的可行解。在檢查工作分配時，其實就是判斷取得可行解時的二維數組的一下標都不相同，二下標同樣不相同。

樣例分析：
給定3件工作，i號工人完成j號工作的費用如下：
10 2 3
2 3 4
3 4 5
那麼在這裏，用回溯法的思想就是，首先分配的工作是：
10:c[1][1] 3:c[2][2] 5:c[3][3] count=18;

此時，所有工人分配結束，然後回溯到第2個工人重新分配： 

10:c[1][1] 4:c[2][3] 4:c[3][2] count=18;

第2個工人已經回溯到n，再回溯到第1個工人重新分配： 

2:c[1][2] 2:c[2][1] 5:c[3][3] count=9;

回溯到第2個工人，重新分配： 

2:c[1][2] 4:c[2][3] 3:c[3][1] count=9;

再次回溯到第1個工人，重新分配： 

3:c[1][3] 2:c[2][1] 4:c[3][2] count=9;

回溯到第2個工人，重新分配： 

3:c[1][3] 3:c[2][2] 3:c[3][1] count=9;

這樣，就得到了所有的可行解。而我們是要得到最少的費用，即可行解中和最小的一個，故需要再定義一個全局變量cost表示最終的總費用，初始cost爲c[i][i]之和，即對角線費用相加。在所有工人分配完工作時，比較count與cost的大小，如果count小於cost,證明在回溯時找到了一個最優解，此時就把count賦給cost。 
到這裏，整個算法差不多也快結束了，已經能得到最終結果了。但考慮到算法的複雜度，這裏還有一個剪枝優化的工作可以做。就是在每次計算局部費用變量count的值時，如果判斷count已經大於cost，就沒必要再往下分配了，因爲這時得到的解必然不是最優解。