(C卷,200分)- 贪心歌手（Java & JS & Python & C）

题目描述

一个歌手准备从A城去B城参加演出。

1. 按照合同，他必须在 T 天内赶到
2. 歌手途经 N 座城市
3. 歌手不能往回走
4. 每两座城市之间需要的天数都可以提前获知。
5. 歌手在每座城市都可以在路边卖唱赚钱。

   经过调研，歌手提前获知了每座城市卖唱的收入预期：
   如果在一座城市第一天卖唱可以赚M，后续每天的收入会减少D（第二天赚的钱是 M – D，第三天是 M – 2D …）。如果收入减少到 0 就不会再少了。

6. 歌手到达后的第二天才能开始卖唱。如果今天卖过唱，第二天才能出发。

贪心的歌手最多可以赚多少钱？

输入描述

第一行两个数字 T 和 N，中间用空格隔开。

• T 代表总天数，0 < T < 1000
• N 代表路上经过 N 座城市，0 < N < 100

第二行 N+1 个数字，中间用空格隔开。代表每两座城市之间耗费的时间。

• 其总和 ≤ T。

接下来 N 行，每行两个数字 M 和 D，中间用空格隔开。代表每个城市的输入预期。

• 0 < M < 1000
• 0 < D < 100

输出描述

一个数字。代表歌手最多可以赚多少钱。以回车结束。

用例

题目解析

本题歌手必须从A到B，因此输入的第二行各个城市间的花费的路程时间之和roadCost是必须的，即可用于卖唱赚钱的时间 remain 为 T – roadCost。

我们需要规划 remain 时间，合理分配给各个城市，保证时间分配方案能够赚的钱最多。

按照题目意思，每个城市停留的第一天赚m钱，后面每天减少d，

每个城市停留Y天，那么这Y天中赚的钱是严格递减的，且最后一天（第Y天）赚的钱最少

假设歌手目前在X市

• 如果前面城市没有用完remain时间，那么当天可以停留在X市卖唱赚钱
• 如果前面城市已经用完remain时间，那么此时需要比较：

1. 歌手选择在X市当天停留卖唱可以赚的钱 x
2. 歌手前面时间中某天赚的最少的钱 y，由于每个城市停留天数中最后一天赚的钱最少，因此这里的y必然是前面某个城市最后一天赚的钱
    

   如果 x > y，则我们应该将前面赚 y 钱的时间，空闲出来，用于当天赚 x 元，这种替换逻辑，不会改变歌手的行程顺序

   如果 x <= y，则X市就没有必要待下去了，因为继续待下去赚的钱只会比x少

上面逻辑中，在前面城市（前面时间）中找一个最小赚的钱，非常适合使用优先队列。因此我们可以使用优先队列记录已经赚的钱（按天），如果当天停留会超出remain限制，那么就取出优先队列中最小赚的钱，和当天停留可以赚的钱比较，如果当天停留可以赚更多钱，则弹出优先队列中最小赚的钱（含义是：将赚最少钱的那天时间空出来）。

JS算法源码

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
  const [t, n] = (await readline()).split(" ").map(Number);

  const roadCost = (await readline())
    .split(" ")
    .map(Number)
    .reduce((a, b) => a + b);

  const mds = [];
  for (let i = 0; i < n; i++) {
    mds.push((await readline()).split(" ").map(Number));
  }

  // remain是刨去必要的路程时间后，剩余可以用于赚钱的时间
  const remain = t - roadCost;

  // 如果没有剩余时间可以用，则赚不到钱
  if (remain <= 0) {
    console.log(0);
    return;
  }

  // 优先队列（降序数组）记录赚到的钱, 即数组尾巴是某天赚的最少的钱
  const pq = [];

  // 第一天卖唱可以赚m，后续每天的收入会减少d
  for (let [m, d] of mds) {
    // 只要在当前城市还有钱赚，那么就继续待
    while (m > 0) {
      // 只有remain天可以赚钱，超出的时间不能赚钱，因此需要比较超出的时间赚的钱m，和前面时间中赚的最少的钱pq.at(-1)
      if (pq.length >= remain) {
        // pq.at(-1)只可能是某座城市停留的最后一天的赚的钱，因为每座城市都是停留的最后一天赚的钱最少
        if (m > pq.at(-1)) {
          // 如果当前城市当天赚的钱m，比前面天里面赚的最少的pq.at(-1)多，那么就赚pq.at(-1)钱的那天时间节约下来，给当天用
          pq.pop();
        } else {
          // 如果当前城市当天赚的钱m，比前面天里面赚的最少的pq.at(-1)还少，则当前城市继续待下去赚的钱只会更少，因此没必要呆下去了
          break;
        }
      }

      // 如果所有城市停留时间没有超出remain天，或者当天是超出的时间，但是比前面赚的最少的一天的赚的更多，则赚m更优
      pq.push(m);
      pq.sort((a, b) => b - a);

      //  每天收入减少d
      m -= d;
    }
  }

  const ans = pq.reduce((a, b) => a + b);
  console.log(ans);
})();

Java算法源码

import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
  static int t;
  static int n;
  static int roadCost;
  static int[][] mds;

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    t = sc.nextInt();
    n = sc.nextInt();

    // roadCost是A~B城市必需的路程时间
    roadCost = 0;
    for (int i = 0; i < n + 1; i++) {
      roadCost += sc.nextInt();
    }

    mds = new int[n][2];
    for (int i = 0; i < n; i++) {
      mds[i][0] = sc.nextInt();
      mds[i][1] = sc.nextInt();
    }

    System.out.println(getResult());
  }

  public static int getResult() {
    // remain是刨去必要的路程时间后，剩余可以用于赚钱的时间
    int remain = t - roadCost;

    // 如果没有剩余时间可以用，则赚不到钱
    if (remain <= 0) {
      return 0;
    }

    // 优先队列（小顶堆）记录赚到的钱, 即堆顶是某天赚的最少的钱
    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> a - b);

    for (int[] md : mds) {
      // 第一天卖唱可以赚m，后续每天的收入会减少d
      int m = md[0];
      int d = md[1];

      // 只要在当前城市还有钱赚，那么就继续待
      while (m > 0) {
        // 只有remain天可以赚钱，超出的时间不能赚钱，因此需要比较超出的时间赚的钱m，和前面时间中赚的最少的钱pq.peek
        if (pq.size() >= remain) {
          // pq.peek只可能是某座城市停留的最后一天的赚的钱，因为每座城市都是停留的最后一天赚的钱最少
          if (m > pq.peek()) {
            // 如果当前城市当天赚的钱m，比前面天里面赚的最少的pq.peek多，那么就赚pq.peek钱的那天时间节约下来，给当天用
            pq.poll();
          } else {
            // 如果当前城市当天赚的钱m，比前面天里面赚的最少的pq.peek还少，则当前城市继续待下去赚的钱只会更少，因此没必要呆下去了
            break;
          }
        }

        // 如果所有城市停留时间没有超出remain天，或者当天是超出的时间，但是比前面赚的最少的一天的赚的更多，则赚m更优
        pq.add(m);

        //  每天收入减少d
        m -= d;
      }
    }

    return pq.stream().reduce(Integer::sum).orElse(0);
  }
}

Python算法源码

import heapq

# 输入获取
t, n = map(int, input().split())
roadCost = sum(map(int, input().split()))
mds = [list(map(int, input().split())) for _ in range(n)]


# 算法入口
def getResult():
    # remain是刨去必要的路程时间后，剩余可以用于赚钱的时间
    remain = t - roadCost

    # 如果没有剩余时间可以用，则赚不到钱
    if remain <= 0:
        return 0

    # 优先队列（小顶堆）记录赚到的钱, 即堆顶是某天赚的最少的钱
    pq = []
    # 第一天卖唱可以赚m，后续每天的收入会减少d
    for m, d in mds:
        # 只要在当前城市还有钱赚，那么就继续待
        while m > 0:
            # 只有remain天可以赚钱，超出的时间不能赚钱，因此需要比较超出的时间赚的钱m，和前面时间中赚的最少的钱pq[0]
            if len(pq) >= remain:
                # pq[0]只可能是某座城市停留的最后一天的赚的钱，因为每座城市都是停留的最后一天赚的钱最少
                if m > pq[0]:
                    # 如果当前城市当天赚的钱m，比前面天里面赚的最少的pq[0]多，那么就赚pq[0]钱的那天时间节约下来，给当天用
                    heapq.heappop(pq)
                else:
                    # 如果当前城市当天赚的钱m，比前面天里面赚的最少的pq[0]还少，则当前城市继续待下去赚的钱只会更少，因此没必要呆下去了
                    break

            # 如果所有城市停留时间没有超出remain天，或者当天是超出的时间，但是比前面赚的最少的一天的赚的更多，则赚m更优
            heapq.heappush(pq, m)

            # 每天收入减少d
            m -= d

    return sum(pq)


# 算法调用
print(getResult())

C算法源码

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    return *((int *) b) - *((int *) a);
}

int main() {
    int t, n;
    scanf("%d %d", &t, &n);

    // roadCost是A~B城市必需的路程时间
    int roadCost = 0;
    for (int i = 0; i < n + 1; i++) {
        int cost;
        scanf("%d", &cost);
        roadCost += cost;
    }

    // remain是刨去必要的路程时间后，剩余可以用于赚钱的时间
    int remain = t - roadCost;

    // 如果没有剩余时间可以用，则赚不到钱
    if (remain <= 0) {
        puts("0");
        return 0;
    }

    // 优先队列（降序数组）记录赚到的钱, 即数组尾巴是某天赚的最少的钱
    int pq[remain + 1];
    int pq_size = 0;

    for (int i = 0; i < n; i++) {
        // 第一天卖唱可以赚m，后续每天的收入会减少d
        int m, d;
        scanf("%d %d", &m, &d);

        // 只要在当前城市还有钱赚，那么就继续待
        while (m > 0) {
            // 只有remain天可以赚钱，超出的时间不能赚钱，因此需要比较超出的时间赚的钱m，和前面时间中赚的最少的钱pq.peek
            if (pq_size >= remain) {
                // pq.peek只可能是某座城市停留的最后一天的赚的钱，因为每座城市都是停留的最后一天赚的钱最少
                if (m > pq[pq_size - 1]) {
                    // 如果当前城市当天赚的钱m，比前面天里面赚的最少的pq.peek多，那么就赚pq.peek钱的那天时间节约下来，给当天用
                    pq_size--;
                } else {
                    // 如果当前城市当天赚的钱m，比前面天里面赚的最少的pq.peek还少，则当前城市继续待下去赚的钱只会更少，因此没必要呆下去了
                    break;
                }
            }

            // 如果所有城市停留时间没有超出remain天，或者当天是超出的时间，但是比前面赚的最少的一天的赚的更多，则赚m更优
            pq[pq_size++] = m;
            qsort(pq, pq_size, sizeof(int), cmp);

            //  每天收入减少d
            m -= d;
        }
    }

    int ans = 0;
    for (int i = 0; i < pq_size; i++) {
        ans += pq[i];
    }

    printf("%dn", ans);

    return 0;
}