任务分配（回溯法）以及与分支限界法区别

一、问题描述：

设有 n 件工作分配给 n 个人。将工作 i 分配给 j 个人所需的费用为  。试设计一个算法，为每个人都分配 1 件不同的工作，并使得总费用最小。

下面这个表格就是代表成本：

人员	任务1	任务2	任务3	任务4
1	9	2	7	8
2	6	4	3	7
3	5	8	1	8
4	7	6	9	4

 未优化之前

情况①：cost大于mincost；表示当前累计的费用已经大于已知的最小值，没有继续下去的意义了，费用只会再变大。

情况②：i< n；表示当前分配进展的深度还未到达“叶子结点”（即所有的工作还未分配完）；继续进行相应的分配工作。

情况③：t == n；表示当前分配进展的深度达到了“叶子结点”（即所有的工作已经分配完了）；此时比较cost和mincost的值，mincost取其中的最小值。

//解空间为子集树
#include<iostream>
#include<cstring>
using namespace std;
#define INF 0x3f3f3f3f
#define MAXN 21
int n=4;//任务数量
//第i个人执行第j个任务的成本
int c[MAXN][MAXN]={{0},{0,9,2,7,8},{0,6,4,3,7},{0,5,8,1,8},{0,7,6,9,4}};
int x[MAXN];//临时解
int cost=0;//临时解的成本
int bestx[MAXN];//最优解
int mincost=INF;//最优解的成本
bool worker[MAXN];//worker[j]表示任务j是否已分配人员
 
void dfs(int i){
    if(i>n){
        if(cost<mincost){
            mincost=cost;
            for(int k=1;k<=n;k++){
                bestx[k]=x[k];
            }
        }
    }
    else{
        for(int j=1;j<=n;j++){ //为人员i试探任务j，从1到n
            if(!worker[j]){ //任务j还未分配
                worker[j]=true;
                cost+=c[i][j];
                x[i]=j;
                dfs(i+1);
                //回溯
                worker[j]=false;
                cost-=c[i][j];
                x[i]=0;
            }
        }
    }
}
 
int main()
{
    memset(worker,false,sizeof(worker));//任务还未分配
    dfs(1);
    cout<<"最优方案："<<endl;
    for(int k=1;k<=n;k++){
        cout<<"第"<<k<<"个人安排任务"<<bestx[k]<<endl;
    }
    cout<<"总成本为："<<mincost<<endl;
}

 它的状态树是一个排列树，有点繁琐，所以要进行优化

优化代码 ：dfs+剪枝

 ①对于micost的初始值设置进行优化：

在上述代码中，mincost的初值被设置为一个足够大的数，这样使得在实际使用的过程中，mincost是在出现第一个可行解时取其值作为自己的值再利用 if(cost>mincost||i>n) 来筛选不用再继续下去的分配；为了提高其筛选效率，我们可以通过将mincost的初值直接赋予一个可行解再进行分配工作，这样 if(cost>mincost||i>n)  语句就不用等到出现第一个可行解再起作用了；那么我们如何在不通过运算就可以找到一个可行解呢？

②对于分配方式的筛选机制进行了优化：

我们将c二维数组的每一行数据的最小值存储在一个一维数组a中（即完成某一工作的最小花费），当分配到某一个工作时，我们将 cost累计加上剩余未分配工作对应行在一维数组a中存储的最小值，如果得到cost 值大于 mincost,则说明这条分配线路不会得到更优的解。

#include<iostream>
using namespace std;
#define INF 0x3f3f3f3f
#define MAXN 21
int n = 4;//任务数量
//第i个人执行第j个任务的成本
int c[MAXN][MAXN] = { {0},{0,9,2,7,8},{0,6,4,3,7},{0,5,8,1,8},{0,7,6,9,4} };
int x[MAXN];//临时解
int cost = 0;//临时解的成本
int bestx[MAXN];//最优解
int mincost = INF;//最优解的成本
bool worker[MAXN];//worker[j]表示任务j是否已分配人员
int a[100]; //它用来储存每行最小值
void dfs(int i)
{
    if (cost + a[i] > mincost)
    {
        return;
    }
    if (i > n) {
        if (cost < mincost) {
            mincost = cost;
            for (int k = 1;k <= n;k++) {
                bestx[k] = x[k];
            }
        }
    }
    else {
        for (int j = 1;j <= n;j++)
        { //为人员i试探任务j，从1到n
            if (!worker[j]) 
            { //任务j还未分配
                worker[j] = true;
                cost += c[i][j];
                x[i] = j;
                //cout << cost<<" ";
                dfs(i + 1);//回溯
                worker[j] = false;
                cost -= c[i][j];
                x[i] = 0;
            }
        }
    }
}

int main()
{
    memset(worker, false, sizeof(worker));//任务还未分配
    for (int i = 1;i <= n;i++)
    {
        mincost += c[i][i];
    }
    for (int i = 1;i <= n;i++) 
    {//初始化a数组
        int minvalue = c[i][1];
        for (int j = 1;j <= n;j++) 
        {//找出每一行的最小值
            if (c[i][j] < minvalue)
                minvalue = c[i][j];
        }
        a[i] = minvalue;
    }
    for (int i = n - 1;i >= 1;i--)
        a[i] += a[i + 1];
    dfs(1);
    cout << endl<<"最优方案：" << endl;

    for (int k = 1;k <= n;k++) 
    {
        cout << "第" << k << "个人安排任务" << bestx[k] << endl;
    }
    cout << "总成本为：" << mincost << endl;
}

 

分支限界法与回溯法的异同

方法	目标	对解空间树的搜索方式	结点存储特性	数据结构	应用
分支限界法	找出满足约束条件的一个解或特定意义下的最优解	广度优先搜索	每一个活结点只有一次机会成为扩展结点。	队列 优先队列	求解最优化问题
回溯法	找出满足约束条件的所有解	深度优先搜索	活结点的所有可行子结点被遍历后才被从栈中弹出	堆栈 数组	求解组合数组较大的问题。

方法	解空间树	算法框架	相同点	存储空间
分支限界法	看情况	（1）队列式分支限界法 （2）优先队列式分支限界法	都是一种在问题的解空间树的搜索问题的算法	大
回溯法	子集树和排列树	（1）递归回溯 （2）迭代回溯 （3）子集树算法框架 （4）排列树算法框架	都是一种在问题的解空间树的搜索问题的算法	小

另一篇关于分支限界法的博客https://blog.csdn.net/lxy994/article/details/124741265