突击战（Commando War, UVa 11729）

突击战（Commando War, UVa 11729）

你有n个部下，每个部下需要完成一项任务。第i个部下需要你花Bi分钟交待任务，然后他会立刻独立地、无间断地执行Ji分钟后完成任务。你需要选择交待任务的顺序，使得所有任务尽早执行完毕（即最后一个执行完的任务应尽早结束）。注意，不能同时给两个部下交待任务，但部下们可以同时执行他们各自的任务。
【输入格式】
输入包含多组数据，每组数据的第一行为部下的个数N（1≤N≤1 000）；以下N行每行两个正整数B和J（1≤B≤10 000，1≤J≤10 000），即交待任务的时间和执行任务的时间。输入结束标志为N=0。
【输出格式】
对于每组数据，输出所有任务完成的最短时间。
【样例输入】

3
2 5
3 2
2 1
3
3 3
4 4
5 5
0

【样例输出】

Case 1: 8
Case 2: 15

思路1：

直觉告诉我们，执行时间较长的任务应该先交待。于是想到这样一个贪心算法：按照J从大到小的顺序给各个任务排序，然后依次交待。

源代码1：

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;

struct Job {
  int j, b;
  bool operator < (const Job& x) const {    //运算符重载。不要忘记const修饰符
    return j > x.j;
  }
};

int main() {
  int n, b, j, kase = 1;
  while(scanf("%d", &n) == 1 && n) {
    vector<Job> v;
    for(int i = 0; i < n; i++) {
      scanf("%d%d", &b, &j); v.push_back((Job){j,b});
    }
    sort(v.begin(), v.end());               //使用Job类自己的 < 运算符排序
    int s = 0;
    int ans = 0;
    for(int i = 0; i < n; i++) {
      s += v[i].b;              //当前任务的开始执行时间
      ans = max(ans, s+v[i].j); //更新任务执行完毕时的最晚时间
    }
    printf("Case %d: %d\n", kase++, ans);
  }
  return 0;
}

上述代码直接交上去就可以通过测试了。
可是为什么这样做是对的呢？假设我们交换两个相邻的任务X和Y（交换前X在Y之前，交换后Y在X之前），不难发现其他任务的完成时间没有影响，那么这两个任务呢？
情况一：交换之前，任务Y比X先结束，如图1-1（a）所示。不难发现，交换之后X的结束时间延后，Y的结束时间提前，最终答案不会变好。
情况二：交换之前，X比Y先结束，因此交换后答案变好的充要条件是：交换后X的结束时间比交换前Y的结束时间早（交换后Y的结束时间肯定变早了），如图1-1（b）所示。这个条件可以写成B[Y]+B[X]+J[X]

笔者思路2：

123456……

源代码2：

#include <cstdio>
#include <algorithm>  //sort的使用 //sort(B, B+N);//排序交待任务的时间 完成第-%d-个任务所需要的时间
using namespace std;

int B[1000], J[1000];

int main()
{
    int N;
    int i, j, k;
    int number = 0;
    int time = 0;
    while (scanf("%d",&N) == 1)
    {
        if(N == 0)
            return 0;
        for (i = 0; i < N; i++)
        {
            scanf("%d", &B[i]);
            scanf("%d", &J[i]);
        }
        for (i = 0; i < N; i++)
        {
            for (j = 0; i + j < N - 1; j++)
            {
                if(J[j] < J[j + 1])
                {
                    int temp = J[j];
                    J[j] = J[j + 1];
                    J[j + 1] = temp;
                    temp = B[j];
                    B[j] = B[j + 1];
                    B[j + 1] = temp;
                }
            }
        }
        for (i = 1; i < N; i++)
        {
            B[i] = B[i] + B[i-1];
        }
        time = B[0] + J[0];
        for (i = 0; i < N; i++)
        {
            if(B[i] + J[i] > time)
                time = B[i] + J[i];
        }
        for (i = 0; i < N; i++)
        {
            printf("完成前-%d-个任务所需要的时间: %d\n", i + 1, B[i] + J[i]);
        }
        number++;
        printf("Case %d: %d\n", number, time);
    }
    return 0;
}

输入：
3
0
输出：
完成前-1-个任务所需要的时间: 2
完成前-2-个任务所需要的时间: 5
完成前-3-个任务所需要的时间: 7
Case 1: 8