HNU-算法设计与分析-作业4

最新推荐文章于 2024-10-03 23:25:47 发布

甘晴void

最新推荐文章于 2024-10-03 23:25:47 发布

阅读量643

点赞数 17

分类专栏： # 【3.1】算法设计与分析（AD）文章标签：算法湖南大学 HNU

本文链接：https://blog.csdn.net/qq_39480177/article/details/138928172

版权

【3.1】算法设计与分析（AD）专栏收录该内容

14 篇文章 2 订阅

订阅专栏

第四次作业【贪心算法】

在这里插入图片描述

文章目录

- 第四次作业【贪心算法】

<1> 算法分析题4-1 会场安排问题

▲问题重述

假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。设计一个有效的贪心算法进行安排。（这个问题实际上是著名的图着色问题。若将每一个活动作为图的一个顶点，不相容活动间用边相连。使相邻顶点着有不同颜色的最小着色数，相应于要找的最小会场数。）对于给定的k个待安排的活动，计算使用最少会场的时间表。

Input
输入数据的第一行有1 个正整数k（k≤10000），表示有k个待安排的活动。接下来的k行中，每行有2个正整数，分别表示k个待安排的活动开始时间和结束时间。时间以0 点开始的分钟计。

Output
输出一个整数，表示最少会场数。

Sample Input
5
1 23
12 28
25 35
27 80
36 50
Sample Output
3

▲想法

先按照开始时间递增排序，若开始时间相同则按照结束时间递增排序。每次都优先安排序号靠前的活动，除非不相容，一遍扫完之后再扫第二遍，同时开第二个会场，直至所有活动都被安排。

▲代码

// -*- coding:utf-8 -*-

// File    :   4-1 会场安排问题.cpp
// Time    :   2023/12/29
// Author  :   wolf

#include <algorithm>
#include <iostream>

using namespace std;
struct activity
{
    int start;
    int end;
    bool if_arrange;
} a[10001];

bool cmp(struct activity a, struct activity b)
{
    if (a.start < b.start)
        return 1;
    else if (a.start == b.start)
    {
        if (a.end <= b.end)
            return 1;
    }
    return 0;
}

int main()
{
    int k;
    cin >> k;
    for (int i = 0; i < k; i++)
    {
        cin >> a[i].start >> a[i].end;
        a[i].if_arrange = 0;
    }
    sort(a, a + k, cmp);
    int ok_num = 0;  // 已安排成功的会场数量
    int now_end = 0; // 当前安排的活动的结尾时间
    int ans = 0;     // 要开的会场数目
    while (ok_num < k)
    {
        now_end = 0;
        ans++;
        for (int i = 0; i < k; i++)
        {
            if (a[i].if_arrange == 0)
            {
                if (a[i].start >= now_end) // 相容，可加入
                {
                    a[i].if_arrange = 1;
                    ok_num++;
                    now_end = a[i].end;
                }
            }
        }
    }
    cout << ans << endl;
    return 0;
}

▲验证

测试数据一（样例）

输入

输出

测试数据二

输入

输出

测试数据三

输入

输出

<2> 算法实现题4-9 虚拟汽车加油问题

▲问题重述

问题描述：一辆汽车加满油后可行驶n公里。旅途中有若干个加油站。设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少。对于给定的n(n <= 5000)和k(k <= 1000)个加油站位置，编程计算最少加油次数。并证明算法能产生一个最优解。

算法设计：对于给定的n和k个加油站的位置，计算最少的加油次数。

数据输入：第一行有两个正整数n和k，表示汽车加油后可行驶n km，且旅途中有k个加油站。接下来的一行中，有k+1个整数，表示第k个加油站和第k-1个加油站之间的距离。
结果输出：将计算的最少加油次数输出，如果无法到达目的地，则输出“No Solution”。

▲想法

对于到达每一个加油站时的处理：如果目前的油够到达下一站，就不再加油了，把油留到后面加，如果目前的油不够到达。

▲代码

// -*- coding:utf-8 -*-

// File    :   4-9 虚拟汽车加油问题.cpp
// Time    :   2023/12/29
// Author  :   wolf

#include <iostream>

using namespace std;

int main()
{
    int n, k, temp;
    cin >> n >> k;
    int rest_oil = n;
    cin >> temp; // 读入第一个加油站，不做处理
    int ans = 0;
    for (int i = 0; i < k; i++)
    {
        int now_input;
        cin >> now_input;
        if (now_input > n)
        {
            cout << "No Solution" << endl;
            return 0;
            // 到下一加油站的距离超过加满油能行驶的距离，时不可行的。
        }
        if (rest_oil - now_input >= 0)
        {
            rest_oil -= now_input;
        }
        else
        {
            rest_oil = n;
            rest_oil -= now_input;
            ans++;
        }
    }
    cout << ans << endl;

    return 0;
}

▲验证

输入

7 7
1 2 3 4 5 1 6 6

输出

<3> 算法实现题4-13 非单位时间任务安排问题

▲问题重述：

问题描述和要求
具有截止时间和误时惩罚的任务安排问题可描述如下：
（1）给定 n 个任务的集合 S={1,2,…,n}；
（2）完成任务 i 需要 ti时间，1≤i≤n；
（3）任务 i 的截止时间 di，1≤i≤n，即要求任务 i 在时间 di之前结束；
（4）任务 i 的误时惩罚 wi，1≤i≤n，即任务 i 未在时间 di之前结束将招致 wi 的惩罚；若按时完成则无惩罚。

算法设计：设计一个贪心选择思想与动态规划思想相结合的算法，解决以上任务安排问题，确定 S 的一个最优时间表，使得总误时惩罚达到最小。

数据输入：首先输入一个正整数 n 表示任务的个数。接下来的 n 行中，每行输入三个整数，分别代表相应任务需要的时间 ti，截止时间 di，以及误时惩罚 wi。

结果输出：输出任务安排结果以及总的误时惩罚。

案例：

▲想法

首先将仍无依照其截止时间非递减排序

设对于任务1，2，……，i。截止时间为d的最小误时惩罚为p[i][d]，则p[i][d]符合最优子结构性质，且有递推式

p[i][d] = min{ p[i-1][d] + w[i], p[i-1][min{d,d[i]} - t[i]] }

边界条件有：

考虑p[1][d]

对于 t[1] <= d 时，截止时间大于完成任务的时间，而且只有一个任务，该任务是可以完成的，所以没有惩罚。

对于 t[1] > d 时，由于第一个工作无法完成，必然导致惩罚，罚时为w[1]。

▲代码

// -*- coding:utf-8 -*-

// File    :   4-13 非单位时间任务安排问题.cpp
// Time    :   2023/12/30
// Author  :   wolf

#include <algorithm>
#include <iostream>

using namespace std;
int const MAXINT = 99999;
struct task
{
    int t; // cost time
    int d; // deadline
    int w; //  weight
} task[1000];

bool cmp(struct task a, struct task b)
{
    return a.d < b.d;
}

int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> task[i].t >> task[i].d >> task[i].w;
    }
    sort(task, task + n, cmp);
    int maxd = task[n - 1].d;
    int dp[n][maxd + 1]; // dp[i][j] 到第i个任务，截止时间为j时的最小惩罚
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j <= maxd; j++)
        {
            dp[i][j] = MAXINT;
        }
    }
    for (int j = 0; j <= maxd; j++)
    {
        if (j < task[0].d)
            dp[0][j] = task[0].w;
        else
            dp[0][j] = 0;
    }
    for (int i = 1; i < n; i++)
    {
        for (int j = 0; j <= maxd; j++)
        {
            int drop = dp[i - 1][j] + task[i].w;
            dp[i][j] = drop;
            if (min(j, task[i].d) - task[i].t >= 0)
            {
                int fetch = dp[i - 1][min(j, task[i].d) - task[i].t];
                dp[i][j] = min(drop, fetch);
            }
        }
    }
    cout << dp[n - 1][maxd] << endl;
    // for (int i = 0; i < n; i++)
    // {
    //     for (int j = 0; j <= maxd; j++)
    //     {
    //         cout << dp[i][j] << " ";
    //     }
    //     cout << endl;
    // }

    return 0;
}

▲验证

<4> 算法实现题4-14 多元Huffman编码问题

▲想法

（1）求最大费用时只需将石堆排列后从大到小，两两进行合并即可。
（2）求最小费用时，将石堆排列后，每次合并的石堆数为K堆。但有时会出现特例，即每次合并K堆，最后一次合并时无法以K堆进行合并，这样合并的结果就不是最小费用了。所以就要先判断原总堆数是否能使每次合并的堆数都为K堆，如果不能的话就要在原堆数前面加上 X 个“0”堆来补齐缺少的堆数.。
例如共7堆最大合并5堆：
石子堆：45 13 12 5 9 22 16
这时排序后：5 9 12 13 16 22 45
如果先合并前5堆，这样结果就为177
如果补零的话，得到 0 0 5 9 12 13 16 22 45，这时正好每次都合并5堆，最后合并为1堆，这时结果为148

编程思路：

（1）分别创建一个递增的优先队列和一个递减的优先队列。创建队列的优点是可以对数字自动排序、取数等一些操作方便，如q.top();表示取队首元素。
（2）对于递增队列：① 先判断是否需要加“0”堆，需要就加；② 只要队列中的元素个数大于1（等价于队列中还至少有k堆石子，当然剩余石子堆数为k的整数倍），就对队列前k个元素进行处理。每次将队首加入到sum中，加完后就把队首弹出队列，继续处理下一个队首，直至处理了k个队首（即合并了k堆石子）。得到n个sum后，将sum累加起来，得到的就是最小费用。
（3）对于递减队列：方法同二，只是这里是连续处理2个队首。

▲代码

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n, k, x;                                       // x为每堆石子数
    long long sum1 = 0, sum2 = 0;                      // sum1、sum2分别为最小总费用和最大总费用
    priority_queue<int, vector<int>, greater<int>> q1; // 创建递增的优先队列
    priority_queue<int, vector<int>, less<int>> q2;    // 创建递减的优先队列
    cin >> n >> k;
    for (int i = 0; i < n; i++) // 输入每堆石子数并压入优先队列中
    {
        cin >> x;
        q1.push(x);
        q2.push(x);
    }
    while (q1.size() % (k - 1) != 1) // 判断q1能否每次合并k堆且恰好合并完
        q1.push(0);                  // 不能合并完，就要压入“0”
    while (q1.size() > 1)
    {
        long long sum = 0;
        for (int i = 0; i < k; i++) // 每次都是队首前k堆合并
        {
            sum += q1.top(); // 前k堆每堆的费用加入到临时变量sum中
            q1.pop();        // 队首的这堆石子合并后，将它弹出队列
        }
        sum1 += sum;  // 将前k堆的费用加入到总费用中
        q1.push(sum); // 这个前k堆的费用压入队列中
    }

    while (q2.size() > 1)
    {
        long long sum = 0;
        for (int i = 0; i < 2; i++)
        {
            sum += q2.top();
            q2.pop();
        }
        sum2 += sum;
        q2.push(sum);
    }
    cout << sum2 << " " << sum1 << endl;
    return 0;
}

▲验证

输入