题目分析
- 题目意思很好理解,需要注意的是虽然一台机器不能同时处理两个任务,但是两台机器可以同时处理两个任务,所以就样例而言,对于第一个任务,可以选择由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 ) O(2^n) O(2n),只能处理较小的 n n n
DP
- 根据上面的分析可以看出,这个问题是通过前面逐渐往后推得最终答案,也就是具有最优子结构的性质,可以使用动态规划,那么怎么进行呢?
- 考虑建立一个二维数组 d p [ i ] [ j ] dp[i][j] dp[i][j]表示处理到第 i i i个作业,A的工作总时间为 j j j,B的工作时间。那么根据 0 − 1 0-1 0−1背包的思想, j j j的枚举范围可以是从0到A可能的总工作时间,枚举这里面的每个 j j j,不停填表,逐步得到答案
- 枚举
j
j
j,注意
j
j
j是
A
A
A的工作总时间,如果
j
<
a
[
i
]
j\lt a[i]
j<a[i],说明
A
A
A不能处理第
i
i
i个作业,也不能不处理,所以只能由
B
B
B处理,那么有
d
p
[
i
]
[
j
]
=
d
p
[
i
−
1
]
[
j
]
+
b
[
i
]
dp[i][j]=dp[i-1][j]+b[i]
dp[i][j]=dp[i−1][j]+b[i];否则,就说明既可以由
A
A
A处理,也可以由
B
B
B处理,取较小者,有
d
p
[
i
]
[
j
]
=
m
i
n
(
d
p
[
i
−
1
]
[
j
−
a
[
i
]
]
,
d
p
[
i
−
1
]
[
j
]
+
b
[
i
]
)
dp[i][j]=min(dp[i-1][j-a[i]], dp[i-1][j]+b[i])
dp[i][j]=min(dp[i−1][j−a[i]],dp[i−1][j]+b[i])
所以状态转移方程为
d p [ i ] [ j ] = { d p [ i − 1 ] [ j ] + b [ i ] j < a [ i ] m i n ( d p [ i − 1 ] [ j − a [ i ] ] , d p [ i − 1 ] [ j ] + b [ i ] ) j ≥ a [ i ] dp[i][j]=\begin{cases} dp[i-1][j]+b[i] &\text{} j\lt a[i] \\ min(dp[i-1][j-a[i]],dp[i-1][j]+b[i]) &\text{} j\geq a[i] \end{cases} dp[i][j]={dp[i−1][j]+b[i]min(dp[i−1][j−a[i]],dp[i−1][j]+b[i])j<a[i]j≥a[i] - 再仔细说一下这个状态转移方程, i i i表示到第几个作业了, j j j表示的是 A A A的工作总时间, d p [ i ] [ j ] dp[i][j] dp[i][j]表示 B B B的工作总时间,那么如果 j < a [ i ] j\lt a[i] j<a[i]说明 A A A工作总时间还没到 a [ i ] a[i] a[i],那么只能让 B B B做 a [ i ] a[i] a[i],那么B现在的总工作时间就是 d p [ i − 1 ] [ j ] + b [ i ] dp[i-1][j]+b[i] dp[i−1][j]+b[i],因为 A A A没工作,所以 j j j不用动;当 j ≥ a [ i ] j\geq a[i] j≥a[i]时,如果让 A A A来做,那么这个时候B的总工作时间应该是多少呢?因为现在是 A A A在做, A A A的工作时间是 j j j,那么B的工作时间就应该是 A A A没做时候的工作时间,也就是 j j j把现在的 a [ i ] a[i] a[i]去掉之后的dp值,即 d p [ i − 1 ] [ j − a [ i ] ] dp[i-1][j-a[i]] dp[i−1][j−a[i]],如果让 B B B来做,分析和第一个状态转移式一样
- 状态转移做完之后,枚举每一个 A A A的工作时间,将它和 B B 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 × ∑ i = 1 n a [ i ] n\times \sum_{i=1}^{n}a[i] n×i=1∑na[i]