LA4850 - Installations

最新推荐文章于 2020-06-09 20:43:07 发布

原创最新推荐文章于 2020-06-09 20:43:07 发布 · 770 阅读

0 ·

CC 4.0 BY-SA版权

贪心专栏收录该内容

4 篇文章

订阅专栏

本文探讨了电信服务工程师的任务调度问题，通过定义任务的完成时间和截止期限之间的惩罚值来衡量任务超时的程度，并提出了一种算法来最小化两个最大惩罚值之和。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

In the morning, service engineers in a telecom company receive a list of jobs which they must serve today. They install telephones, internet, ipTVs, etc and repair troubles with established facilities. A client requires a deadline when the requested job must be completed. But the engineers may not complete some jobs within their deadlines because of job overload. For each job, we consider, as a penalty of the engineer, the difference between the deadline and the completion time. It measures how long the job proceeds after its deadline. The problem is to find a schedule minimizing the sum of the penalties of the jobs with the two largest penalties.

A service engineer gets a list of jobs J_i with a serving time s_i and a deadline d_i. A job J_i needs time s_i, and if it is completed at time C_i, then the penalty of J_i is defined to be max{0, C_i - d_i}. For convenience, we assume that the time t when a job can be served is 0 $\le$ t < $\infty$ and s_i and d_i are given positive integers such that 0 < s_i $\le$ d_i. The goal is to find a schedule of jobs minimizing the sum of the penalties of the jobs with the two largest penalties.

For example, there are six jobs J_i with the pair (s_i, d_i) of the serving time s_i and the deadline d_i, i = 1,..., 6, where (s₁, d₁) = (1, 7), (s₂, d₂) = (4, 7), (s₃, d₃) = (2, 4), (s₄, d₄) = (2, 15), (s₅, d₅) = (3, 5), (s₆, d₆) = (3, 8). Then Figure 1 represents a schedule which minimizes the sum of the penalties of the jobs with the two largest penalties. The sum of the two largest penalties of an optimal schedule is that of the penalties of J₂ and J₆, namely 6 and 1, respectively, which is equal to 7 in this example.

$\epsfbox{p4850.eps}$

Figure 1. The optimal schedule of the example

Input

Your program is to read from standard input. The input consists of T test cases. The number of test cases T is given on the first line of the input. The first line of each test case contains an integer n ( 1 $\le$ n $\le$ 500), the number of the given jobs. In the next n lines of each test case, the i-th line contains two integer numbers s_i and d_i, representing the serving time and the deadline of the job J_i, respectively, where 1 $\le$ s_i $\le$ d_i $\le$ 10, 000.

Output

Your program is to write to standard output. Print exactly one line for each test case. The line contains the sum of the penalties of the jobs with the two largest penalties.

The following shows sample input and ouput for three test cases.

Sample Input

Sample Output

7
0
14

只想到最大惩罚值用贪心，不知道两个怎么搞，也是看了别人的题解，分析问题的思维好欠缺啊。
首先还是贪心，然后分三种情况讨论分析
1.所有惩罚值为0.答案就是0
2.有一个有惩罚值，答案就是该惩罚值。
3有两个以上的惩罚值，我们假设最大为max1，次大为max2，就会有两个下标为xb1,xb2.
会把任务划分成三段


我们试着移动任务：
（1）从1找一个任务移动到2执行，则xb2所对应的惩罚值不变，xb1所对应的惩罚值增加。
（2）从2找一个任务移动到3执行，则xb1所对应的惩罚值不变，xb2所对应的惩罚值增加。
（3）从1找一个任务移动到3执行，虽然最大惩罚值会增大，但是则xb2所对应的惩罚值和xb1所对应的惩罚值减小。也就说最大惩罚值增大，次大惩罚值有可能减小。总和也就有可能减小。分析可以发现，最好也就是移动任务到xb2后面第一个。
所以我们只要枚举（3）情况就可以了。
#include <iostream>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <cmath>
using namespace std;
typedef long long ll;
const int MAXN = 510;
int n;
struct node
{
    int s, d;
}g[MAXN];
bool cmp(node a, node b)
{
    return a.d<b.d;
}
int work()
{
    int ans;
    sort(g,g+n,cmp);
    int i, j, xb1=-1, xb2=-1, sum = 0, max1=0, max2=0;
    /*for(i=0; i<n; i++)
    {
        printf("%d %d\n",g[i].s,g[i].d);
    }*/
    for(i=0; i<n; i++)
    {
        sum += g[i].s;
        int temp = max(sum - g[i].d,0);
        if(temp>max1)
        {
            max2 = max1;
            max1 = temp;
            xb1 = xb2; xb2 = i;
        }else if(temp>max2)
        {
            max2 = temp;
            xb1 = xb2; xb2 = i;
        }
    }
    ans = max1 + max2;
    for(i=0; i<=xb1; i++) // 枚举移动的工作
    {
        //每次都要初始化
        sum = max1 = max2 = 0;
        for(j=0; j<n; j++)
        {
            if(j==i)continue;//跳过所选的工作
            sum += g[j].s;
            int temp = max(sum - g[j].d,0);
            if(temp>max1)
            {
                max2 = max1;
                max1 = temp;

            }else if(temp>max2)
            {
                max2 = temp;
            }
            if(j==xb2) //把移动的工作放入xb2后面
            {
                sum += g[i].s;
                int temp = max(sum - g[i].d,0);
                if(temp>max1)
                {
                    max2 = max1;
                    max1 = temp;

                }else if(temp>max2)
                {
                    max2 = temp;
                }
            }
        }
        //cout<<i<<" "<<max1+max2<<endl;
        ans = min(ans, max1 + max2); //选择最优解
    }
    return ans;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0; i<n; i++)
        {
            scanf("%d%d",&g[i].s,&g[i].d);
        }
        printf("%d\n",work());
    }
    return 0;
}