POJ 2970 The lazy programmer(优先队列+贪心)


Language:
Default

The lazy programmer

Time Limit: 5000MS   Memory Limit: 65536K
Total Submissions: 1566   Accepted: 386

Description

A new web-design studio, called SMART (Simply Masters of ART), employs two people. The first one is a web-designer and an executive director at the same time. The second one is a programmer. The director is so a nimble guy that the studio has already
got N contracts for web site development. Each contract has a deadline di.

It is known that the programmer is lazy. Usually he does not work as fast as he could. Therefore, under normal conditions the programmer needs bi of time to perform the contract number i. Fortunately, the guy is very greedy for money. If
the director pays him xi dollars extra, he needs only (bi ? ai xi) of time to do his job. But this extra payment does not influent other contract. It means that
each contract should be paid separately to be done faster. The programmer is so greedy that he can do his job almost instantly if the extra payment is (bi ? ai) dollars for the contract number i.

The director has a difficult problem to solve. He needs to organize programmer’s job and, may be, assign extra payments for some of the contracts so that all contracts are performed in time. Obviously he wishes to minimize the sum of extra payments. Help
the director!

Input

The first line of the input contains the number of contracts N (1 ≤ N ≤ 100 000, integer). Each of the next N lines describes one contract and contains integer numbers aibidi (1
≤ aibi ≤ 10 000; 1 ≤ di ≤ 1 000 000 000) separated by spaces.

Output

The output needs to contain a single real number S in the only line of file. S is the minimum sum of money which the director needs to pay extra so that the programmer could perform all contracts in time. The number must
have two digits after the decimal point.

Sample Input

2
20 50 100
10 100 50

Sample Output

5.00

Source

Northeastern Europe 2004, Western Subregion

/*

题意:有n个任务要完成,每个任务有属性 a,b,d
	 分别代表  额外工资,完成时间,结束时间。
	 如果不给钱,那么完成时间为b,给x的额外工资,那么完成时间b变成 b-a*x

  求在所有任务在各自最后期限前完成所需要给的最少的钱

思路:先把任务按照结束之间排序,然后依次完成每个任务,如果这个任务无法完成
      那么在前面(包括这个)任务中找到a属性最大的任务(可以再给他钱的前提),
      给钱这个腾出时间来完成当前这个任务,而这个可以用优先队列维护

*/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<set>
#include<map>

#define L(x) (x<<1)
#define R(x) (x<<1|1)
#define MID(x,y) ((x+y)>>1)

#define eps 1e-8
typedef __int64 ll;

#define fre(i,a,b)  for(i = a; i <b; i++)
#define free(i,b,a) for(i = b; i >= a;i--)
#define mem(t, v)   memset ((t) , v, sizeof(t))
#define ssf(n)      scanf("%s", n)
#define sf(n)       scanf("%d", &n)
#define sff(a,b)    scanf("%d %d", &a, &b)
#define sfff(a,b,c) scanf("%d %d %d", &a, &b, &c)
#define pf          printf
#define bug         pf("Hi\n")

using namespace std;

#define INF 0x3f3f3f3f
#define N 100005

struct stud{
  int a,b,d;
  double money;
  bool operator<(const stud b) const
  {
  	return a<b.a;
  }

}f[N];

int cmp(stud x,stud y)
{
	return x.d<y.d;
}

priority_queue<stud>q;

int n;

int main()
{
	int i,j;
	while(~scanf("%d",&n))
	{
		for(i=0;i<n;i++)
			{
				scanf("%d%d%d",&f[i].a,&f[i].b,&f[i].d);
			    f[i].money=0;   //已经给这个任务的钱
			}
	    sort(f,f+n,cmp);

	    while(!q.empty()) q.pop();
	    double ans,day;
	    ans=day=0;
	    stud cur;
	    for(i=0;i<n;i++)
		{
			q.push(f[i]);
			day+=f[i].b;
			while(day>f[i].d)
			{
				cur=q.top();
				q.pop();
				double temp=(double)(day-f[i].d)/cur.a; //完成这个任务需要给cur任务的钱
				if(temp+cur.money<(double)cur.b/cur.a)   //如果这个钱加上已经给的钱小于可以给他的钱
				{
					day-=temp*cur.a;
					cur.money+=temp;
					ans+=temp;
					q.push(cur);
					break;
				}
				else
				{
					temp=((double)cur.b/cur.a-cur.money);
					day-=temp*cur.a;
					ans+=temp;
				}
			}
		}

		printf("%.2f\n",ans);
	}
  return 0;
}

Language:
Default

The lazy programmer

Time Limit: 5000MS   Memory Limit: 65536K
Total Submissions: 1566   Accepted: 386

Description

A new web-design studio, called SMART (Simply Masters of ART), employs two people. The first one is a web-designer and an executive director at the same time. The second one is a programmer. The director is so a nimble guy that the studio has already
got N contracts for web site development. Each contract has a deadline di.

It is known that the programmer is lazy. Usually he does not work as fast as he could. Therefore, under normal conditions the programmer needs bi of time to perform the contract number i. Fortunately, the guy is very greedy for money. If
the director pays him xi dollars extra, he needs only (bi ? ai xi) of time to do his job. But this extra payment does not influent other contract. It means that
each contract should be paid separately to be done faster. The programmer is so greedy that he can do his job almost instantly if the extra payment is (bi ? ai) dollars for the contract number i.

The director has a difficult problem to solve. He needs to organize programmer’s job and, may be, assign extra payments for some of the contracts so that all contracts are performed in time. Obviously he wishes to minimize the sum of extra payments. Help
the director!

Input

The first line of the input contains the number of contracts N (1 ≤ N ≤ 100 000, integer). Each of the next N lines describes one contract and contains integer numbers aibidi (1
≤ aibi ≤ 10 000; 1 ≤ di ≤ 1 000 000 000) separated by spaces.

Output

The output needs to contain a single real number S in the only line of file. S is the minimum sum of money which the director needs to pay extra so that the programmer could perform all contracts in time. The number must
have two digits after the decimal point.

Sample Input

2
20 50 100
10 100 50

Sample Output

5.00

Source

Northeastern Europe 2004, Western Subregion

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-11 07:10:56

POJ 2970 The lazy programmer(优先队列+贪心)的相关文章

poj 2970 The lazy programmer 优先队列

题目链接:http://poj.org/problem?id=2970 先按deadline升序排 然后一件事一件事处理 这里需要[维护]已经过去的事情和当前这件事情中a值最大的项 这里就用到优先队列 时间不够的 就通过增大前面及当前的某件事的x值来补 这题卡精度 原来那种姿势不知道怎么就wa了 辛苦改成这种姿势以后 一开始在sum那里是整型过不了 然后改成double就过了 究其原因 应该也是[类型转换没有四舍五入] 导致精度损失 以后在除的地方 除了记得强制类型转换 还得考虑精度的问题 #i

SPOJ 417 The lazy programmer(贪心)

417. The lazy programmer Problem code: LAZYPROG A new web-design studio, called SMART (Simply Masters of ART), employs two people. The first one is a web-designer and an executive director at the same time. The second one is a programmer. The directo

poj 2970 优先队列

先按di排序,(从小到大).然后依次完成合同,若发现第i个合同无法在截止日期前完成,便从之前已经完成的任务中选一个aj最大的合同,付钱来使得这个合同尽快完成. #include<cstring> #include<cstdio> #include<iostream> #include<queue> #include<algorithm> using namespace std; struct node { int q; int w; bool o

POJ 3069 Saruman&#39;s Army (贪心)

题目大意:直线上有N个点,点i的位置是Xi,从这N个点中选取若干,给他们加上标记,对每一个点,其距离为R以内的区域内必须有被标记的点.求至少需要多少个点被标记. 题目思路:设最左边的点:点p的坐标为x,那么离其距离为R的点的坐标为(x+R),我们应该标记的点应为坐标最接近且小于等于(x+R)的点p,则此时[x,p+R]范围内点点均被标记.依次进行下去,直到包含所有点为止. #include<stdio.h> #include<queue> #include<iostream&

POJ 3253 Fence Repair (优先队列)

POJ 3253 Fence Repair (优先队列) Farmer John wants to repair a small length of the fence around the pasture. He measures the fence and finds that he needsN (1 ≤ N ≤ 20,000) planks of wood, each having some integer lengthLi (1 ≤ Li ≤ 50,000) units. He the

POJ 3069 Saruman&#39;s Army (简单贪心)

Saruman's Army Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 5343   Accepted: 2733 Description Saruman the White must lead his army along a straight path from Isengard to Helm's Deep. To keep track of his forces, Saruman distributes se

hdu 4544 湫湫系列故事——消灭兔子 优先队列+贪心

将兔子的血量从小到大排序,箭的威力也从小到大排序, 对于每只兔子将威力大于血量的箭加入队列,写个优先队列使得出来数位价钱最少.. #include<stdio.h> #include<queue> #include<algorithm> #include<iostream> #include<functional> using namespace std; const int maxn=100010; struct tt { int d; int

poj 3253 Fence Repair(优先队列+哈夫曼树)

题目地址:POJ 3253 哈夫曼树的结构就是一个二叉树,每一个父节点都是两个子节点的和.这个题就是可以从子节点向根节点推. 每次选择两个最小的进行合并.将合并后的值继续加进优先队列中.直至还剩下一个元素为止. 代码如下: #include <iostream> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> #include <cty

ZOJ-3410Layton&#39;s Escape(优先队列+贪心)

Layton's Escape Time Limit: 2 Seconds      Memory Limit: 65536 KB Professor Layton is a renowned archaeologist from London's Gressenheller University. He and his apprentice Luke has solved various mysteries in different places. Unfortunately, Layton