## [$AcWing$ $300$. 任务安排$1$](https://www.acwing.com/problem/content/302/)


### 一、题目描述
有 $N$ 个任务排成一个序列 **在一台机器上** 等待执行，它们的顺序不得改变。

机器会把这 $N$ 个任务分成若干批，每一批包含连续的若干个任务。

从时刻 $0$ 开始，任务被分批加工，执行第 $i$ 个任务所需的时间是 $T_i$。

另外，在每批任务开始前，机器需要 $S$ 的启动时间，故执行一批任务所需的时间是启动时间 $S$ 加上每个任务所需时间之和。

一个任务执行后，将在机器中稍作等待，直至该批任务全部执行完毕。

也就是说，**同一批任务将在同一时刻完成**。

每个任务的费用是 **它的完成时刻乘以一个费用系数 $C_i$**。

**请为机器规划一个分组方案，使得总费用最小**。

**输入格式**
第一行包含整数 $N$。

第二行包含整数 $S$。

接下来 $N$ 行每行有一对整数，分别为 $T_i$ 和 $C_i$，表示第 $i$ 个任务单独完成所需的时间 $T_i$ 及其费用系数 $C_i$。

**输出格式**
输出一个整数，表示最小总费用。

**数据范围**
$1≤N≤5000,0≤S≤50,1≤T_i,C_i≤100$

**输入样例**：
```cpp {.line-numbers}
5
1
1 3
3 2
4 3
2 3
1 4
```

**输出样例**：
```cpp {.line-numbers}
153
```

###　二、理解用例

假如这样分组：
<center><img src='https://img2022.cnblogs.com/blog/8562/202202/8562-20220225080930242-1683909927.png'></center>

最佳答案是$153$，我们现在算出来是$163$，很显然这不是最优的办法。

最优的解是这样的：
<center><img src='https://img2022.cnblogs.com/blog/8562/202202/8562-20220228163353376-1223038245.png'></center>

### 二、暴力枚举$MLE$

空间复杂度$O(n^2)$、时间复杂度$O(n^3)$

<center><img src='https://img2022.cnblogs.com/blog/8562/202202/8562-20220225112415345-1173659176.png'></center>

**状态表示**：
- 集合:$f[i][j]$表示前$i$个任务分成$j$组的集合
- 属性:最小费用

**状态计算**：
$$\large f[i][j]=min(f[k][j−1]+(j×s+\sum_{a=1}^{i}t[i])×(\sum_{a=k+1}^ic[i])),k \in [j-1,i)$$


**最后一个不同点**：最后一组，枚举最后一组的起点：可以分为前$k$个机器分为$j−1$组，$k+1 \sim i$个机器是第$j$组

$\displaystyle \sum_{a=1}^i t[i]$和$\displaystyle \sum_{a=k+1}^{i}c[i]$可以用前缀和优化


#### 暴力代码
```cpp {.line-numbers}
#include <bits/stdc++.h>

using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 5010;
int t[N], c[N];
int f[N][N];
int n, s;
/**
 5
1
1 3
3 2
4 3
2 3
1 4

 答案：153

 二维数组：
 5000*5000=25000000

 25000000 * 4byte=100000000 byte = 100000 kb =  100 mb >题目要求的64mb ，所以不出意外：
 MLE了！还没有来的及TLE，先MLE了！看来需要一个一维的状态表示方法！
 */
int main() {
    // 任务个数与启动时间
    cin >> n >> s;

    for (int i = 1; i <= n; i++) {
        cin >> t[i] >> c[i];
        t[i] += t[i - 1]; // t数组自带前缀和
        c[i] += c[i - 1]; // c数组自带前缀和
    }

    /* 1、为什么这样初始化？
      答：看状态转移方程
      f[i][j] = min(f[i][j], f[k][j - 1] + (j * s + t[i]) * (c[i] - c[k]));
      f[i][j]：前i个任务，在j个阶段的场景下，最小的代价值是多少。

      这个k好说，有上面的循环限制了它的范围。
      这个j-1就要小心了，不能小于零吧~，而且，如果等于0是啥意思，也要从现实意义出发进行初始化设置
      j-1=0,也就是说在第0个阶段，第0个阶段就是还没有开始,管你前多少个任务，代价值都应该是0
     */
    memset(f, 0x3f, sizeof f);
    memset(f[0], 0, sizeof f[0]);

    // 2、开始填表
    for (int i = 1; i <= n; i++)                                                      // i个任务
        for (int j = 1; j <= i; j++)                                                  // j个阶段，注意j的上界，一个阶段1个任务是极限，此时i=j
            for (int k = j - 1; k < i; k++)                                           // 最后一个阶段的起点k
                f[i][j] = min(f[i][j], f[k][j - 1] + (s * j + t[i]) * (c[i] - c[k])); // 前缀和 \sum_{a=k+1}^{i}c[a]

    /*
     3、收集答案
     f[n]表示在n个任务,那么划分的分组数量可能是多少呢？是1，2，3，...n,其中1表示全部划归一组,n表示一个任务一组，共n组
    */
    int res = INF;
    for (int i = 1; i <= n; i++) res = min(res, f[n][i]);
    cout << res << endl;
    return 0;
}

```

### 四、优化：费用提前计算

#### 为什么要写暴力?
所有题目拿下来都可以先向暴力的方向去想，然后再进行优化

#### 进一步思考
我们为什么要枚举每一组？是为了得到启动机器的次数进而算费用
我们可以发现，只要我们分一组，后面还未分组的机器一定会增加相应的费用，高兴的是我们现在就可以算出来增加的费用是多少，所以我们只需要提前把这个多出来的费用加上就行了

![](https://dsideal.obs.cn-north-1.myhuaweicloud.com/HuangHai/BlogImages/%7Byear%7D/%7Bmonth%7D/%7Bmd5%7D.%7BextName%7D/20230616080633.png)

**状态表示**：
- 集合:$f[i]$表示前$i$个任务处理完的所有方案的集合 
> 不关心划分成多少个组

- 属性:最小费用

**考虑最后一个不同点**
![](https://dsideal.obs.cn-north-1.myhuaweicloud.com/HuangHai/BlogImages/%7Byear%7D/%7Bmonth%7D/%7Bmd5%7D.%7BextName%7D/20230616081037.png)

假设当前正在思考$f[i]$,它前面的最后一个任务终点$j$在哪里,很明显，$j \in [0,i)$,$i$在最后一组中。

当在$j+1$处创建一个新的分组时，那么后续的所有任务，都将增加$S$的时间，总共的增加时长=$(c[n]-c[j])\times s$


**状态转移方程**：
$$\large f[i]=min(f[j]+(c[i]−c[j])×t[i]+(c[n]−c[j])×s), j \in [0,i)$$

同上$c[i]$和$t[i]$是前缀和。

### 四、$AC$代码
```cpp {.line-numbers}
#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int N = 5010;
int n;   // n个任务
LL s;    // 等待时间
LL c[N]; // 每个任务都有一个花费，   用c[i]来表示,更新概念为前缀和
LL t[N]; // 每个任务都有一个执行时间,用t[i]来表示,更新概念为前缀和
LL f[N]; // 前i个任务，不管划分多少个阶段，最小代价是多少

int main() {
    cin >> n >> s;
    for (int i = 1; i <= n; i++) {
        cin >> t[i] >> c[i];
        t[i] += t[i - 1];
        c[i] += c[i - 1];
    }

    // 初始化
    memset(f, 0x3f, sizeof f);
    f[0] = 0;

    for (int i = 1; i <= n; i++)    // 从小到大枚举每个任务
        for (int j = 0; j < i; j++) // j:前一个批次的最后一个位置
            f[i] = min(f[i], f[j] + t[i] * (c[i] - c[j]) + s * (c[n] - c[j]));
    // 输出
    cout << f[n] << endl;
    return 0;
}
```