ZOJ 3331 Process the Tasks 双塔Dp

用dp[i][j]表示当前安排好了前i个任务，且机器A和机器B完成当前分配到的所有任务的时间差为j
（这里j可正可负，实现的时候需要加个offset）时，完成这些任务的最早时间。
然后根据j的正负，分别考虑任务i+1的两种分配方法。比如j大于0，A比B后空闲，
这个时候如果再把任务分配给A的话，B空闲知道A开始处理i+1的这段时间，B是不能安排任务的，
也就是说可以看成是非空闲的状态，于是下一个状态的A和B时间差就是i+1任务的长度。

就根据这个思路分几个情况进行处理，可以知道j这维不会超过100（就是上面这个原因），整个程序是100^2的复杂度。

　　

Source Code:

//用dp[i][dt]表示当前安排好了前i个任务，且机器A和机器B完成当前分配到的所有任务的时间差为dt



//#pragma comment(linker, "/STACK:16777216") //for c++ Compiler

#include <stdio.h>

#include <iostream>

#include <fstream>

#include <cstring>

#include <cmath>

#include <stack>

#include <string>

#include <map>

#include <set>

#include <list>

#include <queue>

#include <vector>

#include <algorithm>

#define Max(a,b) (((a) > (b)) ? (a) : (b))

#define Min(a,b) (((a) < (b)) ? (a) : (b))

#define Abs(x) (((x) > 0) ? (x) : (-(x)))

#define MOD 1000000007

#define pi acos(-1.0)



using namespace std;



typedef long long           ll      ;

typedef unsigned long long  ull     ;

typedef unsigned int        uint    ;

typedef unsigned char       uchar   ;



template<class T> inline void checkmin(T &a,T b){if(a>b) a=b;}

template<class T> inline void checkmax(T &a,T b){if(a<b) a=b;}



const double eps = 1e-7      ;

const int N = 210            ;

const int M = 1100011*2      ;

const ll P = 10000000097ll   ;

const int MAXN = 10900000    ;

const int INF = 0x3f3f3f3f   ;

const int offset = 100       ;



int dp[100][200], dt;

int ta[100], tb[100];

int n;



int main () {

    std::ios::sync_with_stdio (false);

    int i, j, t, k, u, v, numCase = 0;

    cin >> t;

    while (t--) {

        cin >> n;

        for (i = 1; i <= n; ++i) {

            cin >> ta[i] >> tb[i];

        }

        memset (dp, 0x3f, sizeof(dp));

        dp[0][0 + offset] = 0;



        for (i = 1; i <= n; ++i) {

            for (dt = -99; dt <= 99; ++dt) {

                if (dp[i - 1][dt + offset] == INF)   continue;

                

                if (dt < 0) {   // B 机器人的工作时间更长

                    checkmin (dp[i][-tb[i] + offset],       dp[i - 1][dt + offset] + tb[i]);             //放在B上面（继续由机器人B加工

                    checkmin (dp[i][dt + ta[i] + offset],   dp[i - 1][dt + offset] + Max(0, ta[i] + dt));//放在A上面，继续让机器人A加工

                } else {        // A 机器人的工作时间更长

                    checkmin (dp[i][ta[i] + offset],        dp[i - 1][dt + offset] + ta[i]);             //放在A上面，继续让机器人A加工

                    checkmin (dp[i][dt - tb[i] + offset],   dp[i - 1][dt + offset] + Max(0, tb[i] - dt));//放在B上面，继续由机器人B加工

                }

            }

        }



        int res = INF;

        for(dt = -99; dt <= 99; ++dt){

            checkmin (res, dp[n][dt + offset]);

        }

        cout << res << endl;

    }

    return 0;

}