第一章 基础问题（课堂笔记）

一、调度问题

样例

给定 5 个任务，\(n=5,t_1=9,t_2=2,t_3=5,t_4=3,t_5=1\)，请设计一个调度方案，给出排列 \(i_1,i_2,\dots,i_n\)。

贪心策略求解的两种思路

  1. 从 2 个任务的小规模情况开始研究，发现规律后推广至 \(n\) 个任务
  • 先看前两个任务 \(t_1=9,t_2=2\)，共有 2 种排列：
    \(i_1=1,i_2=2\)，总等待时间为：\(9 + (9+2)=20\)
    \(i_1=2,i_2=1\)，总等待时间为：\(2+(2+9)=13\)

显然任务 2 应该排在前面。不难发现，第一个任务的执行时间会分配给后面每一个任务，必须是时间较短的任务才能是总和最小。
当推广到 \(n\) 个任务时，同理，对于任意两个任务 \(a,b\)，若 \(t_a<t_b\)，则必有 \(i_a<i_b\) 成立。

  • 从而得出方案：将任务按时间从小到大排序即可得到最优排列。
  1. 先有一个猜想，然后证明假设已经找到一个最优解，将这个最优解按照猜想进行调整后，得到的结果不会变差，即说明该猜想正确

  • 先猜想出“可能按任务时间从小到大排序能得到最优解”

  • 假设已有一个最优解，其中有两个任务 \(a,b\)，其中 \(t_a>t_b,i_a<i_b\)

  • 交换这两个任务的位置，答案反而会变小，说明我们的猜想正确。

算法的正确性

通过该例子，了解了思考一个问题的两种普遍适用的思路，以及如何保证思路的正确性。

二、排序问题

1、选择排序

  • 策略：
    共 \(n-1\) 轮操作，第 \(i\) 轮操作的任务，是从待排数据中选出最小值，与位置 \(i(1\le i\le n)\) 的数字进行位置交换。

image

2、冒泡排序

  • 策略：将数列前面看成水面，后面看成水底，共 \(n-1\) 轮操作，第 \(i\) 轮操作的任务，是从水面开始，依次将相邻的2个数进行比较，“轻者上浮，浊者下沉”

image

  • 如果一个排序算法中包含 if (a[j] > a[j+1]) 的语句，那么这个排序算法应该就是冒泡算法。

  • 每次这个 if 语句满足条件，就意味着出现了一个逆序对，需要通过交换这两个数来消除逆序。

  • 与选择排序的比较

    • 选择排序对于输入情况并不敏感，即使输入本身已经排好序，它依然需要一轮一轮地遍历整个待排空间，以确定最小值的位置，循环次数一点不能减少；
    • 冒泡排序则可以在检测到某一轮没有发现逆序对时，立即判断出数组已排序完毕，提前结束循环。
      因此，冒泡排序是比选择排序更优的排序算法。

  • 优化改进

    • 这个过程中，执行交换的次数恰为原数列中的逆序对数。

    • 但不是每次 if 语句判断都一定为真，例如：1 2 3 4 5 9 7 4，每一轮都要从 1 开始，前 5 个数均不是逆序，但确依然要一次次地进行比较，能否把这个情况优化一下呢？

3、插入排序

  • 策略：将工作量集中在对“已排空间”的扩展上，依次将数字插入到“已排”空间内，使得“已排”空间逐步增大，直至 \(n\)。

  • 初始时“已排”空间仅包含第 1 个数。

image

算法的效率

  • 与冒泡排序比较
    • 相同之处：插入排序向后移动的总次数与冒泡排序交换的总次数相等，都是总逆序对数
    • 不同之处：插入排序保证以更高的效率执行 if 判断，对于 1 2 3 4 5 9 7 4，插入排序在前 5 个没有逆序的元素插入时，仅执行一次 if 判断，发现左边第一个元素比自己小后，即可判断前面的元素均与自己不产生逆序，自己位置不变，不会进行多次无用的 if 判断。
      因此，插入排序甚至由于优化后的冒泡排序，是最优秀的 \(O(n^2)\) 的排序算法。

image

当 \(n<50\) 时，插入排序凭借其没有递归调用开销、良好的数据局部性可以更好地利用缓存、代码量小等优势，性能甚至优于 \(O(n\;log\;n)\) 的归并排序和快速排序。

三、贪心实例训练

1、拼数

题目描述

设有 \(n\) 个正整数 \(a_1 \dots a_n\)，将它们联接成一排，相邻数字首尾相接，组成一个最大的整数。

输入格式

第一行有一个整数，表示数字个数 \(n\)。

第二行有 \(n\) 个整数，表示给出的 \(n\) 个整数 \(a_i\)。

输出格式

一个正整数，表示最大的整数

样例输入1

3
13 312 343

样例输出1

34331213

样例输入2

4
7 13 4 246

样例输出2

7424613

说明/提示

对于全部的测试点，保证 \(1 \leq n \leq 20\)，\(1 \leq a_i \leq 10^9\)。

  • 算法设计

  • 正确性证明

  • 参考代码

点击查看代码 
#include<bits/stdc++.h>
using namespace std;
string s[25];
bool cmp(string x,string y) {
    return x+y>y+x;
}
int main() {
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) {
        cin>>s[i];
    }
    sort(s+1,s+n+1,cmp);
    for(int i=1;i<=n;i++) {
        cout<<s[i];
    }
}

2、国王游戏

题目描述

恰逢 H 国国庆，国王邀请 \(n\) 位大臣来玩一个有奖游戏。首先，他让每个大臣在左、右手上面分别写下一个整数，国王自己也在左、右手上各写一个整数。然后，让这 \(n\) 位大臣排成一排，国王站在队伍的最前面。排好队后，所有的大臣都会获得国王奖赏的若干金币，每位大臣获得的金币数分别是：排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数，然后向下取整得到的结果。

国王不希望某一个大臣获得特别多的奖赏，所以他想请你帮他重新安排一下队伍的顺序，使得获得奖赏最多的大臣，所获奖赏尽可能的少。注意，国王的位置始终在队伍的最前面。

输入格式

第一行包含一个整数 \(n\)，表示大臣的人数。

第二行包含两个整数 \(a\) 和 \(b\)，之间用一个空格隔开，分别表示国王左手和右手上的整数。

接下来 \(n\) 行，每行包含两个整数 \(a\) 和 \(b\)，之间用一个空格隔开，分别表示每个大臣左手和右手上的整数。

输出格式

一个整数，表示重新排列后的队伍中获奖赏最多的大臣所获得的金币数。

样例输入1

3 
1 1 
2 3 
7 4 
4 6

样例输出1

2

提示

【输入输出样例说明】

按 \(1\)、\(2\)、\(3\) 这样排列队伍，获得奖赏最多的大臣所获得金币数为 \(2\)；

按 \(1\)、\(3\)、\(2\) 这样排列队伍，获得奖赏最多的大臣所获得金币数为 \(2\)；

按 \(2\)、\(1\)、\(3\) 这样排列队伍，获得奖赏最多的大臣所获得金币数为 \(2\)；

按 \(2\)、\(3\)、\(1\) 这样排列队伍，获得奖赏最多的大臣所获得金币数为 \(9\)；

按 \(3\)、\(1\)、\(2\) 这样排列队伍，获得奖赏最多的大臣所获得金币数为 \(2\)；

按 \(3\)、\(2\)、\(1\) 这样排列队伍，获得奖赏最多的大臣所获得金币数为 \(9\)。

因此，奖赏最多的大臣最少获得 \(2\) 个金币，答案输出 \(2\)。

【数据范围】

对于 \(20\%\) 的数据，有 \(1 \le n \le 10,0 < a,b < 8\)；

对于 \(40\%\) 的数据，有 \(1 \le n \le 20,0 < a,b < 8\)；

对于 \(60\%\) 的数据，有 \(1 \le n \le 100\)；

对于 \(60\%\) 的数据，保证答案不超过 \(10^9\)；

对于 \(100\%\) 的数据，有 \(1 \le n \le 1000,0 < a,b < 10000\)。

  • 算法设计

  • 正确性证明

  • 参考代码

点击查看代码 
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
using LL = long long;
const int N = 1e4 + 7, M = 1e8;
struct Node {int x, y;} g[N];
struct Big {
    LL a[507], len;
    void operator= (int x) { a[len=1] = x; }
    Big operator/ (int x) {
        Big ans = *this;
        LL r = 0;
        for (int i = len; i; --i) {
            ans.a[i] += r * M;
            r = ans.a[i] % x;
            ans.a[i] /= x;
        }
        while (ans.len>1 && !ans.a[ans.len])
            --ans.len;
        return ans;
    }
    bool operator< (const Big &B) const {
        if (len != B.len) return len < B.len;
        for (int i = len; i; --i) 
            if (a[i] != B.a[i]) 
                return a[i] < B.a[i];
        return false;
    }
    void operator= (const Big &B) {
        len = B.len;
        for (int i = 1; i <= len; ++i)
            a[i] = B.a[i];
    }
    void operator*= (int x) {
        ++len;
        for (LL i = 1, c = 0; i <= len; ++i) {
            a[i] = a[i]*x + c;
            c = a[i] / M, a[i] %= M;
        }
        while (len>1 && !a[len]) --len;
    }
    void print() {
        printf("%lld", a[len]);
        for (int i = len-1; i; --i)
            printf("%08lld", a[i]);
    }
} u, v, ans;
int main() {
    int n;
    scanf("%d", &n);
    ++n;
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &g[i].x, &g[i].y);
    sort(g+2, g+n+1, [](Node &a, Node &b){
        return a.x*a.y < b.x*b.y;
    });
    ans = 0, u = g[1].x;
    for (int i = 2; i <= n; ++i) {
        v = u / g[i].y;
        if (ans < v) ans = v;
        u *= g[i].x;
    }
    ans.print();
}
posted @ 2026-03-03 14:39  飞花阁  阅读(68)  评论(0)    收藏  举报
//雪花飘落效果