[POJ1456]Supermarket(贪心 + 优先队列 || 并查集)

传送门

1.贪心 + 优先队列

按照时间排序从前往后

很简单不多说

——代码

 1 #include <queue>
 2 #include <cstdio>
 3 #include <iostream>
 4 #include <algorithm>
 5 #define N 10001
 6
 7 int n, t, ans;
 8 std::priority_queue <int, std::vector <int>, std::greater <int> > q;
 9
10 struct node
11 {
12     int a, b;
13 }p[N];
14
15 inline int read()
16 {
17     int x = 0, f = 1;
18     char ch = getchar();
19     for(; !isdigit(ch); ch = getchar()) if(ch == ‘-‘) f = -1;
20     for(; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - ‘0‘;
21     return x * f;
22 }
23
24 inline bool cmp(node x, node y)
25 {
26     return x.b < y.b;
27 }
28
29 int main()
30 {
31     int i, j;
32     while(~scanf("%d", &n))
33     {
34         t = 1;
35         ans = 0;
36         while(!q.empty()) q.pop();
37         for(i = 1; i <= n; i++) p[i].a = read(), p[i].b = read();
38         std::sort(p + 1, p + n + 1, cmp);
39         for(i = 1; i <= n; i++)
40         {
41             if(t <= p[i].b)
42             {
43                 t++;
44                 ans += p[i].a;
45                 q.push(p[i].a);
46             }
47             else if(t == p[i].b + 1 && q.top() < p[i].a)
48             {
49                 ans += p[i].a - q.top();
50                 q.pop();
51                 q.push(p[i].a);
52             }
53         }
54         printf("%d\n", ans);
55     }
56     return 0;
57 }

2.并查集

很难想

按照价格从大到小排序

如果当前的那一天没有被占用,那么就用当前那一天,如果当前那一天被占用了,就用上一天,如果还被占用,再往前

其实这就是暴力过程

可以用并查集优化,当前天被占用时用并查集连接上一天,如果根指向0,就表明前面的天都被占用了,也就不用加

具体看代码

——代码

 1 #include <cstdio>
 2 #include <iostream>
 3 #include <algorithm>
 4 #define N 10001
 5
 6 int n, ans;
 7 int f[N];
 8
 9 struct node
10 {
11     int a, b;
12 }p[N];
13
14 inline bool cmp(node x, node y)
15 {
16     return x.a > y.a;
17 }
18
19 inline int find(int x)
20 {
21     return x == f[x] ? x : f[x] = find(f[x]);
22 }
23
24 inline int read()
25 {
26     int x = 0, f = 1;
27     char ch = getchar();
28     for(; !isdigit(ch); ch = getchar()) if(ch == ‘-‘) f = -1;
29     for(; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - ‘0‘;
30     return x * f;
31 }
32
33 int main()
34 {
35     int i, x;
36     while(~scanf("%d", &n))
37     {
38         ans = 0;
39         for(i = 1; i < N; i++) f[i] = i;
40         for(i = 1; i <= n; i++) p[i].a = read(), p[i].b = read();
41         std::sort(p + 1, p + n + 1, cmp);
42         for(i = 1; i <= n; i++)
43         {
44             x = find(p[i].b);
45             if(x)
46             {
47                 f[x] = x - 1;
48                 ans += p[i].a;
49             }
50         }
51         printf("%d\n", ans);
52     }
53     return 0;
54 }

时间: 2024-10-15 18:05:29

[POJ1456]Supermarket(贪心 + 优先队列 || 并查集)的相关文章

poj 1827 A Bunch Of Monsters 贪心(并查集优化)

Description Background Jim is a brave explorer. One day, he set out for his next destination, a mysterious hill. When he arrived at the foot of the hill, he was told that there were a bunch of monsters living in that hill, and was dissuaded from cont

C - Justice(优先队列+并查集)

Put simply, the Justice card represents justice, fairness, truth and the law. You are being called to account for your actions and will be judged accordingly. If you have acted in a way that is in alignment with your Higher Self and for the greater g

POJ 1456 Supermarket 区间问题并查集||贪心

F - Supermarket Time Limit:2000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Practice POJ 1456 Appoint description:  System Crawler  (2015-11-30) Description A supermarket has a set Prod of products on sale. It earns a p

poj 1456(贪心、并查集)

Supermarket Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 15416   Accepted: 6941 Description A supermarket has a set Prod of products on sale. It earns a profit px for each product x∈Prod sold by a deadline dx that is measured as an in

优先队列 + 并查集 + 字典树 + 树状数组 + 线段树 + 线段树点更新 + KMP +AC自动机 + 扫描线

这里给出基本思想和实现代码 . 优先队列 : 曾经做过的一道例题       坦克大战 1 struct node 2 { 3 int x,y,step; 4 friend bool operator <(node s1,node s2) // 定义结构体 的时候 这个 就是 用于 优先队列的 基准排序 5 { 6 return s1.step>s2.step; // 步数小的 在上 为小顶堆 7 } 8 }; 9 priority_queue<node>Q; // 优先队列的结构

【南开OJ2264】节操大师(贪心+二分+并查集/平衡树)

好久没更新了,今天就随便写一个吧 题目内容 MK和他的小伙伴们(共n人,且保证n为2的正整数幂)想要比试一下谁更有节操,于是他们组织了一场节操淘汰赛.他们的比赛规则简单而暴力:两人的节操正面相撞,碎的一方出局,而没碎的一方晋级(脑补一下端午节的碰鸡蛋游戏>_<).最后经过数轮淘汰决出冠军"节操大师". 通过理性的研究,你测算出他们的节操值分别为1,2,...,n,我们不妨称这个值为"硬度"吧.同时你又测出了一个节操常数k:当两个硬度相差超过k的节操相撞时

POJ1456 Supermarket 贪心

贪心策略:一定先卖价值最大的,然后考虑卖当前的物品,卖的日期越靠后,越优,可以为以后的物品提供机会 #include <stdio.h> #include <string.h> #include <algorithm> using namespace std; const int N=1e4+5; struct Node{ int v,d; bool operator<(const Node &rhs)const{ return v>rhs.v; }

最小生成树算法汇总 (普里姆 &amp;&amp; 克鲁斯卡尔与并查集结合)

最小生成树: 今天研究了一下最小生成树,感觉最小生成树算法与最短路算法 相差不大,从Prim 与 Dijskrs算法可以看出 最小生成树即最小权重生成树,主要适用于 N个点之间 构造N-1线路,使N个点之间任意两点之间都可到达, 但是N个点之间 不构成回路,并且这N-1条线路的权重之和最小即 消耗最小. 注意:在构造最小生成树,加入新的节点时,不仅要保证权重最小,首要条件是 不能构成回路. 以图示为例,构造最小生成树 (一)普里姆   以下步骤 (二) 克鲁斯卡尔 最终的最小生成树 和 普里姆一

hdu-1863畅通工程 最小生成树克鲁斯卡尔算法kruskal(并查集实现)

畅通工程 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 16994    Accepted Submission(s): 7134 Problem Description 省政府"畅通工程"的目标是使全省任何两个村庄间都可以实现公路交通(但不一定有直接的公路相连,只要能间接通过公路可达即可).经过调查评估,得到的统计表中列出