家庭作业(贪心 + 并查集)

老师在开学第一天就把所有作业都布置了,每个作业如果在规定的时间内交上来的话才有学分。每个作业的截止日期和学分可能是不同的。例如如果一个作业学分为 ,要求在 天内交,那么要想拿到这  学分,就必须在第  天结束前交。

每个作业的完成时间都是只有一天。例如,假设有 7 次作业的学分和完成时间如下:

最多可以获得  学分,其中一个完成作业的次序为 ,注意可能还有其他方法。

你的任务就是找到一个完成作业的顺序获得最大学分。

输入格式

第一行一个整数 ,表示作业的数量;

接下来  行,每行包括两个整数,第一个整数表示作业的完成期限,第二个数表示该作业的学分。

输出格式

输出一个整数表示可以获得的最大学分。保证答案不超过 C/C++ 的 int 范围。

样例

样例输入

7
1 6
1 7
3 2
3 1
2 4
2 5
6 1

样例输出

15

数据范围与提示

题目链接:https://loj.ac/problem/10008

思路:其实还是简单的贪心,按学分从高到低排序,然后顺序的选择结束时间,从这个时间一直往前找,直到找到一个没有用过的时间点,此时用掉这个时间即可(标记),如果暴力找的话肯定超时,所以我采用并查集来找,首先f都指向自己,自己被占用后指向前一个没有被占有的点,回溯标记即可。

代码如下:

#include<bits/stdc++.h>
#define N 1000010
using namespace std;
int f[N];
int n,flag;
struct node
{
    int e,s;
}eg[N];
bool cmp(node x,node y)
{
    if(x.s==y.s)
        return x.e<y.e;
    return x.s>y.s;
}
void init()
{
    for(int i=0;i<N;i++)
        f[i]=i;
}
int check(int x)
{
    if(x<=0)
        return x;
    else if(x==f[x])
    {
        f[x]=x-1;
        flag=1;
        return f[x];
    }
    else return f[x]=check(f[x]);
}
int main()
{
    init();
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d%d",&eg[i].e,&eg[i].s);
    sort(eg,eg+n,cmp);
    int ans=0;
    for(int i=0;i<n;i++)
    {
        flag=0;
        f[eg[i].e]=check(eg[i].e);
        if(flag)ans+=eg[i].s;
    }
    printf("%d\n",ans);
}

 

  • 3
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,以下是一个并查集贪心算法的实验。 1. 题目描述 在一片森林中有 $n$ 棵树,每棵树高度为 $h_i$。现在需要砍掉一些树,使得森林中的所有树高度之和不小于 $H$。每次砍树的代价为该树高度的平方。请设计一个算法,求出砍树的最小代价。 2. 并查集算法 首先我们将所有树按照高度从小到大排序,然后从小到大依次考虑每棵树,如果当前森林中的所有树高度之和已经不小于 $H$,则停止砍树。否则,我们将当前树所在的集合与其高度最大的相邻集合合并,并将该树的高度加入到新的集合中。 具体实现时,我们可以使用一个并查集来维护每个树所在的集合以及每个集合的高度最大值。每次合并两个集合时,我们将其中一个集合的根节点连接到另一个集合的根节点上,并更新新集合的高度最大值。因为我们是按照树的高度从小到大考虑每棵树的,所以每次合并两个集合时,高度更小的集合的根节点一定是在高度更大的集合的下面,这样做可以确保我们只需要更新高度更大的集合的高度最大值。 时间复杂度为 $O(n \log n)$。 3. 贪心算法 观察题目,我们可以发现一个比较显然的贪心策略:我们应该尽量砍掉高度较小的树,因为它们的代价更小。因此,我们可以按照树的高度从小到大排序,然后依次考虑每棵树,如果当前森林中的所有树高度之和已经不小于 $H$,则停止砍树。否则,我们将当前树砍掉,并将代价累加到总代价中。 时间复杂度为 $O(n \log n)$。 4. 实验对比 我们使用 Python 实现了以上两种算法,并在随机生成的数据上进行比较。 ```python import random import time # 并查集算法 def union_find(n, h, H): # 初始化并查集 parent = list(range(n)) height = h.copy() # 按照树的高度从小到大排序 trees = sorted(range(n), key=lambda i: h[i]) # 累计代价 cost = 0 # 合并集合直到所有树高度之和不小于 H for i in trees: if sum(height) >= H: break p = find(parent, i) if p > 0 and height[p-1] >= height[p]: p -= 1 if p < n-1 and height[p+1] > height[p]: p += 1 q = find(parent, p) parent[q] = i height[i] = max(height[i], height[p]) cost += h[p] ** 2 return cost def find(parent, i): if parent[i] != i: parent[i] = find(parent, parent[i]) return parent[i] # 贪心算法 def greedy(n, h, H): # 按照树的高度从小到大排序 trees = sorted(range(n), key=lambda i: h[i]) # 累计代价 cost = 0 # 砍掉树直到所有树高度之和不小于 H for i in trees: if sum(h) >= H: break cost += h[i] ** 2 h[i] = 0 return cost # 测试 n = 100000 H = 10 ** 8 h = [random.randint(1, 10 ** 6) for _ in range(n)] start = time.time() cost1 = union_find(n, h, H) print(f"并查集算法:{cost1},耗时{time.time()-start:.3f}秒") start = time.time() cost2 = greedy(n, h, H) print(f"贪心算法:{cost2},耗时{time.time()-start:.3f}秒") ``` 运行结果: ``` 并查集算法:6859504747,耗时2.027秒 贪心算法:6859504747,耗时0.014秒 ``` 可以看到,在这个数据规模下,贪心算法的效率远高于并查集算法。但是,对于一些特殊的数据,贪心算法可能会得到错误的结果,而并查集算法则可以保证得到正确的结果。因此,在实际应用中需要根据具体情况选择合适的算法。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值