算法课第四章（贪心）课后习题

4-1：一辆虚拟汽车在加满油之后可以行驶 n km。旅途中有 k 个加油站。设计一个有效算法，使得沿途加油的次数最少。终端输入正整数 n 和 k，表示汽车加满油后可行驶 n km，且旅途中有 k 个加油站。接下来输入 k+1个整数，表示第 k 个加油站与第 k-1个加油站之间的距离。第 0 个加油站表示出发地，汽车已加满油。第 k+1个加油站表示目的地。

思路：

  这道题的解题思路是贪心算法。我们需要找到一种最优策略，使得沿途加油的次数最少。

  首先，我们需要遍历所有的加油站之间的距离，计算它们的总和。然后，我们将总距离与汽车加满油后能行驶的最大距离n进行比较。

  如果总距离小于等于n，说明汽车可以直接行驶到终点，不需要加油，所以加油次数为0。

  如果总距离大于n，说明汽车无法直接行驶到终点，需要在途中加油。我们可以采用贪心策略：在每个加油站之前都尽可能多地行驶，直到无法到达下一个加油站为止，然后在当前加油站加油。具体实现上，我们可以使用一个循环来遍历所有的加油站，累计当前行驶的距离。当累计距离超过了n时，表示无法到达下一个加油站，这时我们将当前加油站作为加油点，并将累计距离重置为0，继续下一轮的行驶。  最后，统计加油的次数即可。

程序代码：

#include<iostream>

using namespace std;
const int N = 1010;
int main()
{
    int n;
    int k;
    int tem[N];
    int judge;
    cout<<"输入汽车满油能跑的距离n:";
    cin>>n;
    cout<<endl;
    cout<<"输入加油站的个数k:";
    cin>>k;
    cout<<endl;
    for(int i=0;i<k+1;i++)
    {
        while(true)
        {
            cout<<"输入第"<<i<<"到"<<i+1<<"段的距离:";
              cin>>judge;
        if(judge < n)
        {
            tem[i] = judge;
            break;
        }
        else
        {
            cout<<"距离大于汽车能行驶的最大距离，请重新输入"<<endl;
            }
        }

    }

    int sum,j;
    sum=0;
    j=0;
    int record=0;
    for(int i=j;i<k;i++)
     {
         sum+= tem[i];
         if(sum>n)
         {
             //在超过汽车最大行驶距离时才进行加油，并将累计距离重置为当前加油站的距离
             j=i;
             record++;
             sum = tem[i];
             cout<<"汽车在第"<<j<<"个加油站加了油"<<endl;
         }
     }

     cout<<"汽车加了"<<record<<"次油"<<endl;

}

结果：

 

题目：

4-2：设x1,x2,…,xn是实直线上的n 个点。用固定长度的闭区间覆盖这n 个点，至少需要多少个这样的固定长度闭区间?对于给定的实直线上的n个点和闭区间的长度k，设计解此问题的有效算法，计算覆盖点集的最少区间数。 

思路：

   使用贪心算法来解决,首先，我们需要对给定的n个点进行排序，以便按照从左到右的顺序处理。

  接下来，我们可以从最左边的点开始，选择一个闭区间覆盖第一个点，并尽可能向右覆盖更多的点。具体做法是不断向右移动闭区间的起始位置，直到覆盖到第一个无法被当前闭区间覆盖的点为止。

    一旦找到了这样的位置，我们就需要增加一个新的闭区间来覆盖该点。然后，我们将新的闭区间的起始位置设置为当前点的位置，并继续向右寻找下一个需要覆盖的点。重复上述过程，直到所有的点都被覆盖。

     最后，我们统计所使用的闭区间的数量即可。

完整代码：

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int main()
{
    int n, k;
    cout << "输入点的数量n: ";
    cin >> n;

    vector<int> points(n);

    cout << "输入点的位置: ";
    for (int i = 0; i < n; ++i) {
        cin >> points[i];
    }

    cout << "输入闭区间的长度k: ";
    cin >> k;

    sort(points.begin(), points.end());

    int record = 0;

    for(int i=0; i<n; i++)
    {
        int start = points[i];
        int End = start+k;
        record++;
        cout<<"第"<<record<<"个区间包括:";
        while(points[i]<=End)
        {
            i++;
            cout<<i<<" ";
        }
        cout<<endl;
    }
    cout << "覆盖点集的最少区间数为: " << record <<endl;

    return 0;
}

结果：

 

题目：

4-3：【数列极差】问题描述：在黑板上写了N个正整数作成的一个数列，进行如下操作：每一次擦去其中的两个数a和b，然后在数列中加入一个数a*b+1，如此下去直至黑板上剩下一个数，在所有按这种操作方式最后得到的数中，最大的max，最小的为min，则该数列的极差定义为M=max-min。

思路：

最大值max： （数列中最大两个数相乘+1）之和。

最小值min：（数列中最小值和最大值相乘+1 ）之和。

完整代码：

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int N = 1010;
int Maxm(vector<int>& points, int n);
int Minm(vector<int>& points, int n);
int main()
{
    int n, k;
    cout << "输入正整数数列的数量n: ";
    cin >> n;

    vector<int> points(n);

    cout << "正整数数列: ";
    for (int i = 0; i < n; ++i) {
        cin >> points[i];
    }
    cout << Maxm(points, n) << endl;
    cout << Minm(points, n) << endl;
    int M = Maxm(points, n) - Minm(points, n);
    cout << "数列极差结果为: " << M << endl;

    return 0;
}

int Maxm(vector<int>& points, int n)
{
    sort(points.begin(), points.end());

    int sum = 0;
    if (n % 2 == 0)
    {
        for (int i = n - 1; i >= 0; i = i - 2)
            sum += points[i] * points[i - 1] + 1;

    }
    else
    {
        for (int i = n - 1; i >= 1; i = i - 2)
            sum += points[i] * points[i - 1] + 1;
        sum += points[0];
    }
    return sum;
}

int Minm(vector<int>& points, int n)
{
    sort(points.begin(), points.end());
    int sum = 0;
    if (n % 2 == 0)
    {
        for (int i = 0, j = n - 1; i <= (n / 2 - 1); i = i + 1, j = j - 1)
            sum += points[i] * points[j] + 1;


    }
    else
    {
        for (int i = 0, j = n - 1; i <= (n / 2 - 1); i = i + 1, j = j - 1)
            sum += points[i] * points[j] + 1;
        sum += points[n / 2];
    }
    return sum;
}

结果：