算法设计与分析3-1 独立任务最优调度问题

题目分析

• 题目意思很好理解，需要注意的是虽然一台机器不能同时处理两个任务，但是两台机器可以同时处理两个任务，所以就样例而言，对于第一个任务，可以选择由A或B来做，第二个任务也可以选择A或B，所以就形成了最简单的暴力搜索的思路

暴力搜索

• 所谓暴力，就是最简单最朴素的方法，那么就这道题而言，我们可以考虑从前往后一个一个搜索，要么A做，要么B做，那么怎么表示同时做呢？可以使用两个变量储存A和B已经工作的时间，最后答案显然是它们之间的较大者，如果找到最后一个作业，那么更新答案，最后找到最小解，程序如下

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 100;
const double eps = 1e-6;
int Data[MAXN];
int a[MAXN];
int b[MAXN];
int num;
int ans = INF;
void dfs(int i, int n, int a_now, int b_now, int now){
    
    
    if(i == n){
    
    
        ans = min(ans, now);
        return;
    }
    // num++;
    a_now += a[i];
    now = max(a_now, b_now);
    dfs(i + 1, n, a_now, b_now, now);
    a_now -= a[i];//回溯

    b_now += b[i];
    now = max(a_now, b_now);
    dfs(i + 1, n, a_now, b_now, now);
    b_now -= b[i];
}
int main(){
    
    
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
    int n;
    cin >> n;
    for(int i=1;i<=n;i++) cin >> a[i];
    for(int i=1;i<=n;i++) cin >> b[i];
    dfs(1, n+1, 0, 0, 0);
    cout << ans;
    return 0;
}

• 由于这相当于建立一颗二叉树，可以打印递归次数，显然时间复杂度是$O(2^n)$，只能处理较小的$n$

DP

• 根据上面的分析可以看出，这个问题是通过前面逐渐往后推得最终答案，也就是具有最优子结构的性质，可以使用动态规划，那么怎么进行呢？
• 考虑建立一个二维数组$dp[i][j]$表示处理到第$i$个作业，A的工作总时间为$j$，B的工作时间。那么根据$0-1$背包的思想，$j$的枚举范围可以是从0到A可能的总工作时间，枚举这里面的每个$j$，不停填表，逐步得到答案
• 枚举$j$，注意$j$是$A$的工作总时间，如果$j<a[i]$，说明$A$不能处理第$i$个作业，也不能不处理，所以只能由$B$处理，那么有$dp[i][j]=dp[i-1][j]+b[i]$；否则，就说明既可以由$A$处理，也可以由$B$处理，取较小者，有$dp[i][j]=min(dp[i-1][j-a[i]],dp[i-1][j]+b[i])$
  所以状态转移方程为
  $$dp[i][j]=\{\begin{array}{ll}dp[i-1][j]+b[i]& j<a[i]\\ min(dp[i-1][j-a[i]],dp[i-1][j]+b[i])& j\ge a[i]\end{array}$$
• 再仔细说一下这个状态转移方程，$i$表示到第几个作业了，$j$表示的是$A$的工作总时间，$dp[i][j]$表示$B$的工作总时间，那么如果$j<a[i]$说明$A$工作总时间还没到$a[i]$，那么只能让$B$做$a[i]$，那么B现在的总工作时间就是$dp[i-1][j]+b[i]$，因为$A$没工作，所以$j$不用动；当$j\ge a[i]$时，如果让$A$来做，那么这个时候B的总工作时间应该是多少呢?因为现在是$A$在做，$A$的工作时间是$j$，那么B的工作时间就应该是$A$没做时候的工作时间，也就是$j$把现在的$a[i]$去掉之后的dp值，即$dp[i-1][j-a[i]]$，如果让$B$来做，分析和第一个状态转移式一样
• 状态转移做完之后，枚举每一个$A$的工作时间，将它和$B$的工作时间对比取大的，更新答案(对于取大的这个分析在搜索那一块做过了，不再赘述)，最后答案取最小值

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 100;
const double eps = 1e-6;
int Data[MAXN];
int a[MAXN], b[MAXN];
int dp[500][1000];
int main(){
    
    
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    int n;
    int maxn = 0;
    cin >> n;
    for(int i=1;i<=n;i++){
    
    
        cin >> a[i];
        maxn += a[i];
    }
    for(int i=1;i<=n;i++) cin >> b[i];
    for(int i=1;i<=n;i++){
    
    
        for(int j=0;j<=maxn;j++){
    
    
            if(j < a[i]){
    
       
                dp[i][j] = dp[i - 1][j] + b[i];
            }else{
    
    
                dp[i][j] = min(dp[i - 1][j - a[i]], dp[i - 1][j] + b[i]);
            }
        }
    }
    int ans = INF;
    for(int i=0;i<=maxn;i++){
    
    
        if(i < dp[n][i]){
    
    
            ans = min(ans, dp[n][i]);
        }else{
    
    
            ans = min(ans, i);
        }
    }
    cout << ans;
    return 0;
}

• 时间复杂度显然为$$n\times \sum _{i=1}^{n}a[i]$$