回溯法-工作分配

最新推荐文章于 2021-11-13 16:52:41 发布
最新推荐文章于 2021-11-13 16:52:41 发布
阅读量6k 收藏 29
点赞数 4
分类专栏： 算法设计 文章标签： 算法 优化 回溯
ACM中的工作分配问题是一个典型的回溯问题，利用回溯思想能很准确地得到问题的解。下面就这个问题好好分析下。 

问题描述： 
    设有n件工作分配给n个人。为第i个人分配工作j所需的费用为c[i][j] 。试设计一个算法，计算最佳工作分配方案，为每一个人都分配1 件不同的工作，并使总费用达到最小。 

解题思路： 
    由于每个人都必须分配到工作，在这里可以建一个二维数组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 

    假定一个变量count表示工作费用总和，初始为0，变量i表示第i号工人，初始为1。n表示总的工作量，这里是取3。c[i][j]表示i号工人完成j号工作的费用，x[j]表示j号工作是否被分配。算法如下：  

  
  

   
   void
   
    work
   
   (
   
   int
   
    i
   
   ,
   
   int
   
    count
   
   ){
   
     
  
  

  
  

   
     
   
   if
   
   (
   
   i
   
   >
   
   n
   
   )
   
     
  
  

  
  

   
       
   
   return
   
    
   
   ;
   
     
  
  

  
  

   
     
   
   for
   
   (
   
   int
   
    j
   
   =
   
   1
   
   ;
   
   j
   
   <=
   
   n
   
   ;
   
   j
   
   ++)
   
     
  
  

  
  

   
       
   
   if
   
   (
   
   x
   
   [
   
   j
   
   ]
   
    
   
   ==
   
    
   
   0
   
   ){
   
     
  
  

  
  

   
         x
   
   [
   
   j
   
   ]
   
    
   
   =
   
    
   
   1
   
   ;
   
     
  
  

  
  

   
         work
   
   (
   
   i
   
   +
   
   1
   
   ,
   
   count
   
   +
   
   c
   
   [
   
   i
   
   ][
   
   j
   
   ]);
   
     
  
  

  
  

   
         x
   
   [
   
   j
   
   ]
   
    
   
   =
   
    
   
   0
   
   ;
   
     
  
  

  
  

   
       
   
   }
   
     
  
  

  
  

   
   }
   
     
 那么在这里，用回溯法的思想就是，首先分配的工作是： 
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，就没必要再往下分配了，因为这时得到的解必然不是最优解。 

测试代码： 
#include<iostream>  
using namespace std;  
  
int n,cost=0;  
int x[100],c[100][100];  
  
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;    
         }  
}  
  
int main(){  
    cin>>n;  
    for(int i=1;i<=n;i++){  
      for(int j=1;j<=n;j++){  
        cin>>c[i][j];  
        x[j] = 0;    
      }  
      cost+=c[i][i];    
    }  
    work(1,0);  
    cout<<cost<<endl;  
    system("pause");  
    return 0;  
} 


//工作分配问题
/*
3
10 2 3
2 3 4
3 4 5
*/
#include <iostream>
#include <algorithm>
using namespace std;

int table[21][21],n,best,r[21];

int compute(int k)
{
    int temp=0,i;
    for(i=1;i<=k;i++)
        temp+=table[i][r[i]];
    return temp;
}

void search(int k)
{
    if(k==n)
    {
        int temp=compute(n);
        if(temp<best)
            best=temp;
        return;
    }
    for(int i=k;i<=n;i++)
    {
        swap(r[i],r[k]);
        if(compute(k) < best)
            search(k+1);
        swap(r[i],r[k]);
    }
}

int main()
{
    int i,j;
    while(cin>>n,n)
    {
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                cin>>table[i][j];
        for(i=1;i<=n;i++)
            r[i]=i;
        best=INT_MAX;
        search(1);
        cout<<best<<endl;
    }
    return 0;
}



运行过程说明： jobAssignBacktrack.exe
输入源数据文件路径+文件名
在同目录下可以查看输出文件output.txt
★问题描述 有n份作业分配给n个人去完成，每人完成一份作业。假定第i个人完成第j份作业需要花费cij时间，cij>0,1≦i,j≦n。试设计一个回溯算法，将n份作业分配给n个人完成，使得总花费时间最短。
★格式输入 由文件input.txt给出输入数据。第一行有1 个正整数n (1≤n≤100)。
接下来的n行，每行n个数，表示工作费用。
★格式输出 将计算出的结果输出到文件output.txt。
★示例输入输出 5
50 87 62 56 92 
43 22 98 57 36 
1 5 97 96 43 
58 62 27 73 27 
60 71 38 71 95
144
工人： 1 执行任务： 4
工人： 2 执行任务： 2
工人： 3 执行任务： 1
工人： 4 执行任务： 5
工人： 5 执行任务： 3
★算法设计（包括算法设计过程中相关内容的说明、数据结构的选择、 算法详细描述及算法分析）：
●1.设计说明：
算法中使用job[i]记录作业i是否已被分配，若被分配则置1，不必再搜索其分支；、
assign(int k,unsigned int cost) cost用来记录当前作业分配的开销，作为参数传递给下一层递归调用。
●2.算法设计：
●2.1数据结构：
#define N 100 //N表示最大任务数和工人数
int c[N][N]; //c[i][j] 表示工人i执行作业j所用的时间
unsigned int mincost = 65535; //设置的初始值,大于可能的费用
int task[N], //当前作业分配情况: 工人i执行task[i] 
bestSolution[N], //最优作业分配情况: 工人i执行作业bestSolution[i]
job[N]; //记录作业是否已被分配给工人，1表示已分配，0为分配
int njob; //实际工作、工人数
主要操作：
void input(int& njob, int c[][N]); //读入工人、作业数njob，开销矩阵c[][N]
//初始化task,bestSolution,job,读入工人、作业数njob，开销矩阵c[][N]
void initData(int* task, int* bestSolution, int* job, int& njob, int c[][N]);
void assign(int k,unsigned int cost); //为工人k分配作业，cost：当前作业分配后的花费
//输出结果：mincost、作业分配情况
void outputResult(int minCost,int njob, int* bestSolution);
●2.2算法描述：
void assign(int k,unsigned int cost) //为工人k分配作业，cost：当前作业分配后的花费
{
int i;
if(k > njob && cost < mincost) //搜索至叶节点，判断是否更优
{
mincost = cost;
for(i=1; i<=njob; i++)
bestSolution[i] = task[i];
}
else
{
for(i=1;i<=njob;i++) 
{ 
if(job[i]==0 && cost+c[k][i])//约束函数，job[i]==0则为被分配
{
job[i] = 1; task[k] = i;
assign(k+1,cost+c[k][i]);
job[i] = 0; task[k] = 0;
}
}
}
}
●2.3算法分析
本算法的最坏时间复杂度为：O(n!)
最坏空间复杂度为：O(n)
 

  
  

   
   

    
    

     
     [c-sharp] 
     
     view plain
     
     copy
     
     print
     
     ?
     
     

    
    

   
   

   
   
  1. //=======================================================================  
  2. //jobAssign.cpp  
  3. //将n份作业分配给n个人完成，使得总花费时间最短,回溯法  
  4. //by leo  
  5. //5.13.2011  
  6. //=======================================================================  
  7. #include <iostream>  
  8. #include<fstream>  
  9. #include<string>  
  10. using namespace std;  
  11. //-----------------------------------------------------------------------  
  12. #define N 100                 //N表示最大任务数和工人数  
  13. int c[N][N];                  //c[i][j] 表示工人i执行作业j所用的时间  
  14. unsigned int mincost = 65535; //设置的初始值,大于可能的费用  
  15. int task[N],                  //当前作业分配情况:工人i 执行task[i]  
  16.     bestSolution[N],          //最优作业分配情况: 工人i执行作业bestSolution[i]  
  17.     job[N];                   //记录作业是否已被分配给工人，1表示已分配，0为分配  
  18. int njob;                     //实际工作、工人数  
  19. //-----------------------------------------------------------------------  
  20. void input(int& njob, int c[][N]);    //读入工人、作业数njob，开销矩阵c[][N]  
  21.                                       //初始化task,bestSolution,job,读入工人、作业数njob，开销矩阵c[][N]  
  22. void initData(int* task, int* bestSolution, int* job, int& njob, int c[][N]);  
  23. void assign(int k,unsigned int cost); //为工人k分配作业，cost：当前作业分配后的花费  
  24.                                       //输出结果：mincost、作业分配情况  
  25. void outputResult(int minCost,int njob, int* bestSolution);  
  26. //-----------------------------------------------------------------------  
  27. void main()  
  28. {  
  29.     initData(task, bestSolution, job, njob, c);  
  30.     assign(1,0); //从任务1开始分配  
  31.     outputResult(mincost, njob,bestSolution);  
  32.     system("pause");  
  33. }  
  34. //-----------------------------------------------------------------------  
  35. //读入工人、作业数njob，开销矩阵c[][N]  
  36. //-----------------------------------------------------------------------  
  37. void input(int& njob, int c[][N])  
  38. {  
  39.     string str;  
  40.     cout << "Please input the input file name"  
  41.          << "(input_assign04_00.txt~input_assign04_05.txt):/n";  
  42.     cin >> str;  
  43.     ifstream fin(str.c_str());  
  44.     if(!fin)  
  45.     {  
  46.         cout << "no such file,please check the file name!" <<endl;  
  47.         exit(0);  
  48.     }     
  49.     fin>>njob;      
  50.     for(int i = 1; i <= njob; i++)  
  51.         for (int j = 1; j <= njob; j++)  
  52.             fin >> c[i][j];  
  53. }  
  54. //-----------------------------------------------------------------------  
  55. //初始化task,bestSolution,job,读入工人、作业数njob，开销矩阵c[][N]  
  56. //-----------------------------------------------------------------------  
  57. void initData(int* task, int* bestSolution, int* job, int& njob, int c[][N])  
  58. {  
  59.     input(njob,c);  
  60.     for(int k =0; k <= njob; k++)  
  61.     {  
  62.         job[k] = 0;  
  63.         task[k]   = 0;   
  64.         bestSolution[k]   = 0;   
  65.     }     
  66. }  
  67. //-----------------------------------------------------------------------  
  68. //为工人k分配作业，cost：当前作业分配后的花费  
  69. //-----------------------------------------------------------------------  
  70. void assign(int k,unsigned int cost)  
  71. {  
  72.     int i;  
  73.     if(k > njob && cost < mincost)  
  74.     {  
  75.         mincost = cost;  
  76.         for(i=1; i<=njob; i++)  
  77.             bestSolution[i] = task[i];  
  78.     }  
  79.     else  
  80.     {  
  81.         for(i=1;i<=njob;i++)      
  82.         {                     
  83.             if(job[i]==0 && cost+c[k][i])  
  84.             {  
  85.                 job[i] = 1; task[k] = i;  
  86.                 assign(k+1,cost+c[k][i]);  
  87.                 job[i] = 0; task[k] = 0;  
  88.             }  
  89.         }  
  90.     }  
  91. }  
  92. //-----------------------------------------------------------------------  
  93. //输出结果：mincost、作业分配情况  
  94. //-----------------------------------------------------------------------  
  95. void outputResult(int minCost,int njob, int* bestSolution)  
  96. {  
  97.     cout<<"最小总费用:"<<mincost<<endl;  
  98.     for(int i=1; i<= njob;i++)  
  99.         cout<< "工人： "<< i <<" 执行任务： "<< bestSolution[i]  <<endl;   
  100.   
  101.     ofstream fout("output.txt");  
  102.     fout<<mincost<<endl;  
  103.     for(int j=1; j<= njob;j++)  
  104.         fout<< "工人： "<< j <<" 执行任务： "<< bestSolution[j]  <<endl;   
  105.   
  106. }  
  107. //=======================================================================  
  108.    

  
  
 
 
以下的代码稍作改变，用于c[i][j]表示作业i由工人j完成的情况

  
  

   
   

    
    

     
     [c-sharp] 
     
     view plain
     
     copy
     
     print
     
     ?
     
     

    
    

   
   

   
   
  1. //=======================================================================  
  2. //jobAssign.cpp  
  3. //将n份作业分配给n个人完成，使得总花费时间最短,回溯法  
  4. //by leo  
  5. //5.13.2011  
  6. //=======================================================================  
  7. #include <iostream>  
  8. #include<fstream>  
  9. #include<string>  
  10. using namespace std;  
  11. //-----------------------------------------------------------------------  
  12. #define N 100                 //N表示最大任务数和工人数  
  13. int c[N][N];                  //c[i][j] 表示作业i由人j执行所做的时间  
  14. unsigned int mincost = 65535; //设置的初始值,大于可能的费用  
  15. int task[N],                  //当前作业分配情况:i由工人task[i]执行  
  16.     bestSolution[N],          //最优作业分配情况: i由工人bestSolution[i]执行  
  17.     worker[N];                //记录工人是否已被分配作业  
  18. int njob;                     //实际工作、工人数  
  19. //-----------------------------------------------------------------------  
  20. //读入工人、作业数njob，开销矩阵c[][N]  
  21. //-----------------------------------------------------------------------  
  22. void input(int& njob, int c[][N])  
  23. {  
  24.     string str;  
  25.     cout << "Please input the input file name"  
  26.          << "(input_assign02_00.txt~input_assign02_01.txt):/n";  
  27.     cin >> str;  
  28.     ifstream fin(str.c_str());  
  29.     if(!fin)  
  30.     {  
  31.         cout << "no such file,please check the file name!" <<endl;  
  32.         exit(0);  
  33.     }     
  34.     fin>>njob;      
  35.     for(int i = 1; i <= njob; i++)  
  36.         for (int j = 1; j <= njob; j++)  
  37.             fin >> c[i][j];  
  38. }  
  39. //-----------------------------------------------------------------------  
  40. //读入工人、作业数njob，开销矩阵c[][N]  
  41. //-----------------------------------------------------------------------  
  42. void initData(int* task, int* bestSolution, int* worker, int& njob, int c[][N])  
  43. {  
  44.     input(njob,c);  
  45.     for(int k =0; k <= njob; k++)  
  46.     {  
  47.         //设置每个人任务由不同工人承担时的费用及全局数组的初值  
  48.         worker[k] = 0;  
  49.         task[k]   = 0;   
  50.         bestSolution[k]   = 0;   
  51.     }     
  52. }  
  53. //-----------------------------------------------------------------------  
  54. //测试：输出c[][N]  
  55. //-----------------------------------------------------------------------  
  56. void outputInitData(int c[][N])  
  57. {  
  58.     for(int i = 1; i <= njob; i++)  
  59.     {  
  60.         for (int j = 1; j <= njob; j++)  
  61.             cout << c[i][j] <<" ";  
  62.         cout<<endl;  
  63.     }  
  64. }  
  65. //-----------------------------------------------------------------------  
  66. //k: 当前要分配的任务，cost：当前作业分配后的花费  
  67. //-----------------------------------------------------------------------  
  68. void assign(int k,unsigned int cost)  
  69. {  
  70.     int i;  
  71.     if(k > njob && cost < mincost)  
  72.     {  
  73.         mincost = cost;  
  74.         for(i=1; i<=njob; i++)  
  75.             bestSolution[i] = task[i];  
  76.     }  
  77.     else  
  78.     {  
  79.         for(i=1;i<=njob;i++)    //分配任务k  
  80.         {                     
  81.             if(worker[i]==0 && cost+c[k][i])  
  82.             {  
  83.                 worker[i] = 1; task[k] = i;  
  84.                 assign(k+1,cost+c[k][i]);  
  85.                 worker[i] = 0; task[k] = 0;  
  86.             }  
  87.         }  
  88.     }  
  89. }  
  90. //-----------------------------------------------------------------------  
  91. //输出结果：mincost、任务分配情况  
  92. //-----------------------------------------------------------------------  
  93. void outputResult(int minCost,int njob, int* bestSolution)  
  94. {  
  95.     cout<<"最小总费用:"<<mincost<<endl;  
  96.     for(int i=1; i<= njob;i++)  
  97.         cout<< "任务："<< i <<" 由工人："<< bestSolution[i] << "执行 " <<endl;   
  98. }  
  99. //-----------------------------------------------------------------------  
  100. void main()  
  101. {  
  102.     initData(task, bestSolution, worker, njob, c);  
  103.     assign(1,0); //从任务1开始分配  
  104.     outputResult(mincost, njob,bestSolution);  
  105.     for(int i = 1; i <= njob; i++)  
  106.         cout << bestSolution[i] << " ";  
  107.     cout <<endl;  
  108. }  
  109. //=======================================================================  
  110.    
bojue__123
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
北京工业大学--算法作业5--分支界限法--任务分配--Java
12-12
北京工业大学--算法作业5--分支界限法--任务分配--Java 有n份作业分配给n个人去完成，每人完成一份作业。假定第i个人完成第j份作业需要花费cij时间， cij>0,1≦i,j≦n。试设计一个回溯算法，将n份作业分配给n个人完成，使得总花费时间最短。 请用分支界限法解决此问题。
回溯法求解：工作分配问题
坤舆湖畔的万某某的博客
12-18 2627
利用回溯法求解工作分配问题，对思路进行了详解，并给出了相应的优化方案，代码举例，优化前后对照！
回溯法 解 作业分配问题
生无涯的一亩三分地
05-24 8256
回溯法 解 作业分配问题
工作分配问题【回溯算法】
热门推荐
m0_46308522的博客
12-17 1万+
工作分配问题【回溯算法】
算法第四次作业-分支限界法求解作业分配问题
小红花yu
11-30 8578
一、运行环境： Win7、Spyder、Python3.7 二、运行过程说明: 数据文件格式：输入数据来源于文件，input_assign04_0*.dat。文件内是n*n矩阵的元素，每行的元素代表每个工人完成该任务所需要的时间，每列代表某个工人完成每个工作需要的时间，读出的数据放在嵌套了列表的列表matrix中。 输入格式： 在Spyder中运行程序，输入测试数据集文件编号。...
回溯法之工作分配问题.zip
07-10
回溯法之工作分配问题，直接可运行，python
北京工业大学--算法作业4--回溯算法--任务分配--Java
12-12
北京工业大学--算法作业4--回溯算法--任务分配--Java 有n份作业分配给n个人去完成，每人完成一份作业。假定第i个人完成第j份作业需要花费cij时间， cij>0,1≦i,j≦n。试设计一个回溯算法，... 请用回溯法解决此问题。
回溯法 工作分配问题
04-21
★问题描述：设有n件工作分配给n个人。将工作i分配给第j个人所需的费用为cij。试设计一个算法，为每一个人都分配1件不同的工作，并使总费用达到最小。 ★算法设计：设计一个算法，对于给定的工作费用，计算最佳工作...
回溯法工作分配
11-25
N个人要完成N件工作，每个人完成工作的花费不同，利用回溯法设计出最优分配
C++ 回溯法解决作业分配问题
04-22
C++回溯法解决作业分配问题 包含了代码、算法分析、测试文件和结果，非常详尽，值得拥有！
n个工人作业分配问题回溯算法python实现-有解析过程
03-12
n个作业分配给n个人，这是有解析过程的一版，无解析过程的一版，请进入个人主页下载。18级学姐自主完成的算法作业，呕心沥血，基于四舍五入等于0基础的python实现，如果在语言规范上存在不足，那就。就憋着！哈哈哈哈哈，代码仅供参考，自己亲自码代码更酸爽！
算法第四次作业-回溯法求解作业分配问题
小红花yu
11-30 3586
一、运行环境： Win7、Spyder、Python3.7 二、运行过程说明: 数据文件格式：输入数据来源于文件，input_assign04_0*.dat。文件内是n*n矩阵的元素，每行的元素代表每个工人完成该任务所需要的时间，每列代表某个工人完成每个工作需要的时间，读出的数据放在嵌套了列表的列表matrix中。 输入格式： 在Spyder中运行程序，输入测试数据集文件编号。 或...
作业分配问题——分支限界
努力笨小孩的博客
11-13 1496
问题描述：有n份作业分配给n个人去完成，每人完成一份作业。假定第i个人完成第j份作业需要花费cij时间， cij>0,1≦i,j≦n。 参考内容 import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.*; public class Branch_Bound { static int[][] cost ;//每个工人执行每项工作所花的时间
作业分配问题-回溯法-Python3
Growth Diary
05-08 4045
题目要求：       有n份作业分配给n个人去完成，每人完成一份作业。假定第i个人完成第j份作业需要花费cij时间， cij&gt;0,1≦i,j≦n。试设计一个回溯算法，将n份作业分配给n个人完成，使得总花费时间最短。 题目分析：         由于每个人都必须分配到工作，在这里可以建一个二维数组C[k][i]，用以表示k号工人完成i号工作所需的费用。给定一个循环，从第1个工人开始循...
工作分配 回溯算法
weixin_43853811的博客
06-05 677
设有n件工作分配给n个人。将工作i分配给第j个人所需的费用为Cij。试用用排列树结构设计一个算法，为每个人都分配1件不同的工作，并使得总费用达到最小。 使用c[i][j]表示将工作 i 分配给第 j 个人所需的费用 使用sign[j]表示第 j 个人是否分配工作，用 0/1 表示 best表示最优费用，temp表示当前费用 约束条件为：temp+c[i][j]<best && sign[j]==0 #include<iostream> /* 此例为： n = 3 c[i][
zzuli OJ 1118:小明的调查作业
qq_29989211的博客
10-17 578
小明的老师布置了一份调查作业，小明想在学校中请一些同学一起做一项问卷调查，聪明的小明为了实验的客观性，想利用自己的计算机知识帮助自己。他先用计算机生成了N个1到1000之间的随机整数（0<N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。 输入...
个人作业
zhangrongling的专栏
04-19 163
头文件 #include   using namespace std; class Array_max { public: void set_value(); void max_value(); void show_value();   private: int array[10]; int max; }; 源代码#include #include #in
作业分配问题之回溯算法
连正的博客
12-01 2990
1 问题描述 有n份作业分配给n个人去完成，每人完成一份作业。假定第i个人完成第j份作业需要花费cij时间， cij&gt;0,1≦i,j≦n。试设计一个回溯算法，将n份作业分配给n个人完成，使得总花费时间最短。 2 算法实现 import java.io.*; import java.util.*; public class Demo { public int n; /...
算法篇-10-回溯法-工作分配&世界名画监视
渣渣
12-27 3352
本系列所有代码https://github.com/YIWANFENG/Algorithm-github 工作分配 n个工作分给n个人，将i工作给j号人所需费用为c[i][j],设计一算法为每人分配一工作，并且耗费最小。 算法思路分析与相关公式： 这题也是一简单的排列树问题，方式类似于旅行售货员问题，不同之处在于这里不需要判断是否有回路，所以变得更简单了。   程序源代码：
回溯法——工作分配问题
最新发布
05-27
工作分配问题是指将 n 个工作分配给 n 个人完成，每个人只能完成一个工作，每个工作需要一定的时间和费用。现在要求在满足每个工作都被分配的...最后，回溯法的时间复杂度是指数级的，因此只适用于工作数较小的情况。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值