这道题一开始肯定不难想到暴力解法————双for循环。
但是这样的话时间复杂度就来到了O(n^2),n稍微大一点就会超时。

双指针&贪心算法

这道题我们可以使用双指针的方法，让左右指针分别指向数组的左右两端，从而可以表示容器的左右高度以及宽度。
然后根据贪心算法的思想，每次向中间移动最低的的柱子，记录水量，等左右指针相遇则停止。

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Solution {
public:
    int maxArea(vector<int>& height) {
        int n = height.size()-1;
        int i = 0, j = n;
        int sum = 0;
        while(i < j){
            int len = j - i;
            int cur = len * min(height[i], height[j]);
            if(cur > sum){
                sum = cur;
            }
            if(height[i] < height[j]){
                i++;
            }
            else{
                j--;
            }
        }
        return sum;
    }
};

一些思考

在做这道题目的时候，去理解贪心算法是最关键的。
这就像是“木桶效应”，一个木桶能装多少水取决于短的那条边，而不是长的。
那么在这道题目里，如果宽度固定，那么容量就只和相对短的一边有关。如果我们去移动长边，那么容量一定不会有增加的可能，移动短边的话，容量就有概率变大。因此每次移动的时候，移动长边绝对是错误的选择，移动短边则是最优解（但并不代表移动短边后得到的容量比之前大）
一句话概括：我们 i++ 和 j– 都是为了尝试取到更多的水，如果短的边不动的话，取到的水永远不会比上次多。

我们可以看到，当我们输入 Avery Wang 时，
在 cin 的缓冲区里，只有 Avery 被读走了，后面还剩 Wang\n
而下一个将要被读取的位置在 W 这里

为什么 cin >> name; 只读取出 “Avery”?

因为对于字符串 name 来说，>> 默认是 按空白分隔读取 的
也就是说它会：
跳过前导空白
一直读，直到遇到空格、换行、tab为止

为什么 cin >> age; 会失败

在输出结果中，显示的 age 是 0 ，
这是因为 age 是 int，
cin 期待读取到一个整数，
而缓冲区里下一个有效字符是 W ，而不是数字
于是：
cin 无法将 W 解析成 int
从而本次读取失败
fail bit 被设置为 1
所以我们可以看到右边的状态位中，F被点亮了

The worst

一旦 fail bit 被置上，后续所有的 cin 读取都会直接失败！

第一版修复

1
2
3
4
5
6
7
8
9
10
11

int getInteger(const string& prompt) {
    cout << prompt;
    string token;
    cin >> token;   // still a problem
    istringstream iss(token);
    int result;
    char trash;
    if (!(iss >> result) || iss >> trash)
        return getInteger(prompt); // bad recursion
    return result;
}

这里是先把输入读成字符串，再自己解析。
但是仍然存在问题

问题 A

cin >> token 还是只读取一个token
例如我们输入

1

20 lol

那cin >> token 只会读到

1

token = "20"

后面的 lol 还留在原始输入缓冲区里

问题 B

1

return getInteger(prompt);

这个写法叫 递归重试

它的问题是：

• 输入错误很多次，会一层一层递归下去
• 虽然程序里未必立刻出事，但设计上不优雅
• 重试逻辑本来就更适合 while (true) 循环

终版修复

1
2
3
4
5
6
7
8
9
10
11
12
13

int getInteger(const string& prompt) {
    while (true) {
        cout << prompt;
        string line;
        if (!getline(cin, line))
            throw domain_error("...");
        istringstream iss(line);
        int result;
        char trash;
        if (iss >> result && !(iss >> trash))
            return result;
    }
}

这里先用 getline 把整行读出来，
再把这一整行去解析

这里 getline(cin, line) 的意思是： 从 cin 这个输入流里，读取一整行，存到 line 里
函数原型是 getline(输入流, 字符串变量);
它还可以从字符串流读

1
2
3

istringstream iss("hello\nworld");
string line;
getline(iss, line);

cin 与 getline 的区别

cin >> line
读一个 token，遇到空白就停
getline(cin, line)
读一整行，默认遇到换行符 \n 才停，并且会把这个换行符消费掉，但不会放进结果字符串里。

混用 >> 与 getline 出现的 bug

1
2
3
4
5
6

istringstream iss("16.9 Ounces\n Pack of 12");
double amount;
string unit;

iss >> amount;
getline(iss, unit);

我们会发现：
amount 读出来是对的，但 unit 却不是你以为的 “Ounces” 或 “ Ounces”，而是先变成了空字符串

这是因为 >> 和 getline 对“分隔符/空白”的处理方式不同

iss >> amount 做了什么

假设流里一开始是

1
2

16.9 Ounces
 Pack of 12

执行

1

iss >> amount

amount = 16.9
读取位置停在 16.9 后面的那个空格前后附近 的关键位置上

更准确地说，>> 在读 double 时，会把能构成 double 的部分读完，然后停下来，后面的空格/换行还在流里等待后续处理。

马上 getline(iss, unit) 会发生什么

getline 的规则是：
从当前位置开始，一直读到换行符 \n 为止。
它不会像 >> 一样先主动跳过前导空白。这一点特别重要。
所以如果当前位置前面正好残留了一个空格，或者更常见的是残留了一个换行符，那么 getline 可能直接读到“空内容”

最常见的坑

虽然说在CS106L中用的是 istirngstream, 但最常见的坑应该是在 cin 上，原因和 iss 的情况一样

重点1: getline 不会自动跳过前导空白

>>
会先跳过前导空白
getline
不会跳过，它从当前位置直接开始读
所以只要你前面用 >> 留下了换行符，后面紧接一个 getline，就特别容易出问题

修复方法

1
2
3

iss >> amount;
iss.ignore();
getline(iss, unit);

这里加上 iss.ignore(), 再 getline 就可以正常读到”Ounces”

ignore() 的作用

可以把它理解成：
手动丢掉流里当前那个你不想要的字符

在这个例子里，就是把前面 >> 留下的那个分隔字符先扔掉，然后再让 getline 从真正想读的位置开始读

一般情况，ignore()指忽略接下来的1个字符

如果是带参数

1

ignore(n, '\n')

表示 最多忽略 n 个字符，遇到分隔符 \n 时把该分隔符丢掉后停止

size_t

一个 warning 例子

1
2
3
4

string str = "Hello World!";
for (int i = 0; i < str.size(); ++i) {
    cout << str[i] << endl;
}

很多编译器会发出警告：signed / unsigned comparison

为什么会警告

因为：

1. i 是 int，是 signed(有符号)
2. str.size()返回的通常是 size_t，是 unsigned(无符号)

所以这句

1

i < str.size()

本质上是在比较：
有符号整数 VS 无符号整数

size_t 是什么

我们可以简单理解成：专门用开表示“大小、长度、索引”这类永远不会是负数的整数类型
比如：

1. 字符串长度
2. 容器大小
3. 数组下标

优化写法

所以更好的写法是：

1
2
3

for (size_t i = 0; i < str.size(); ++i) {
    cout << str[i] << endl;
}

size_t 带来的 bug

来看这段代码：

1
2
3
4
5
6
7

string chopBothEnds(const string& str) {
    string result = "";
    for (size_t i = 1; i < str.size() - 1; ++i) {
        result += str[i];
    }
    return result;
}

这段代码看上去像是在“去掉首尾字符”
但是当 str 很短的时候
比如 str = “”
那么 str.size() == 0
而 size_t 是无符号数
所以 0 - 1 不会变成 -1，而是会发生下溢，变成一个非常大的数
这就回让循环条件变得很危险

type alias

type alias 叫做 类型别名
例如：

1
2

using map_iterator = std::unordered_map<forward_list<Student>,
                                        unordered_set>::const_iterator;

这表示：
给这个超长的类型名起一个新名字：map_iterator
然后我们就可以写：

1
2

map_iterator begin = studentMap.cbegin();
map_iterator end = studentMap.cend();

它的作用就是 简化
当类型特别长、特别丑、反复出现时，起别名能让代码更可读

auto

如果类型不重要，或者编译器很容易推断出来，就可以用 auto

例如：

1
2

auto begin = studentMap.cbegin();
auto end = studentMap.cend();

这里我们根本不需要死记那个迭代器的完整类型
我们只用关心：它是个能用的 iterator
那交给编译器推断就行

注意事项

1

auto name = "Avery";

这个类型不是 string，而是更接近 C 风格字符串
如果真要写 string，要写：

1

auto betterName1 = string{"Avery"};

auto discards const and references!!!
auto 会丢掉引用和顶层 const

例如：

1
2

const string& s = someString;
auto x = s;

那 x 往往不是 const string&，而是一个新的 string 副本
也就是说：

原来是引用
结果 auto 一推断，变成值拷贝了

如果想保留引用属性，要显式写：

1

auto& x = s;

如果是

1

const auto& x = s;

那么我们不能通过 x 修改 s，只能用 x 引用 s
也就是只读引用
这是遍历大对象并只读时最推荐的写法

所以以后看到 auto，我们要想一下我们要的是值还是引用

pair、tuple、struct

pair

pair 表示一对值

1

auto prices = make_pair(3.4, 5);

这里 prices 的类型是：

1

pair<double, int>

访问方式：

1
2

prices.first
prices.second

tuple

tuple 可以表示多个值

1

auto values = make_tuple(3, 4, "hi");

访问方式

1
2
3

get<0>(values)
get<1>(values)
get<2>(values)

structured binding 结构化绑定

这是 modern C++ 里特别好用的语法
例如：

1

auto [a, b] = prices;

意思是把 pair 里的两个值直接拆出来，分别赋值给 a 和 b

再比如：

1

const auto& [x, y, z] = values;

这里就是把 tuple 里的每一项分别赋值给 x,y,z

struct

如果这些值本来就是“同一个对象的多个属性”，那通常 struct 比 pair/tuple 更清晰

1
2
3
4
5

struct Discount {
    double discountFactor;
    int expirationDate;
    string nameOfDiscount;
};

然后创建对象；

1

auto coupon1 = Discount{0.9, 30, "New Years"};

reference 引用

看这个例子：

1
2
3

string tea = "Ito-En";
string copy = tea;
string& ref = tea;

这里有三种东西：
tea：原对象
copy：拷贝
ref：引用，给 tea 起了个别名

拷贝和引用的区别

拷贝：copy 是独立对象
改变 copy 并不会对 tea 造成影响
引用：ref 就是 tea 的另一个名字
改变 ref，就是在改变 tea

引用不能改绑

1

ref = copy

这不是让 ref 改为引用 copy
而是 把 copy 的内容赋值给 ref 绑定对对象 tea
也就是说，引用一旦绑定，通常就不能重新指向别的对象了

dangling reference 悬空引用

never return references to local variables!
永远不要返回对局部变量的引用！

1
2
3
4

char& firstCharBad(string& s) {
    string local = s;
    return local[0];
}

这里返回的是 local[0] 的引用
但问题是：local 是局部变量
函数一结束 local就销毁了
那么返回出去的引用，就指向了一个不存在的对象
这就是悬空引用

这个引用看起来还能用，实际上已经指向无效内存了。
属于未定义行为

正确写法：

1
2
3

char& firstCharGood(string& s) {
    return s[0];
}

这里返回的是调用者传进来的字符串 s 里的字符引用
只要 s 活着，这个引用就是有效的

uniform initialization 统一初始化

统一初始化也叫花括号初始化

1

vector<int> vec{3, 1, 4, 1, 5, 9};

还有

1
2
3
4
5

Course now{
    "CS106L",
    {13, 30}, {14, 30},
    {"Wang", "Zeng"}
};

这是在用一种统一、现代的方式初始化各种对象
它在 modern C++ 里很常见，尤其配合：
struct
vector
返回值构造

stream直译过来就是“流”

我们可以把它看作是一个数据流动的管道：

数据可以通过键盘输入，流进程序
数据可以通过程序输出，流到屏幕
文件里的数据可以流进程序里
程序里的数据可以流到文件里

常见的stream有 cin 和 cout

ostringstream

ostringstream 是什么

ostringstream 可以拆成两部分看：

output：输出
string stream：字符串流

1

cout << 123;

是把123输出到屏幕

而

1
2

ostringstream oss;
oss << 123;

是把123输出到oss这一个变量里面，最后变成一个字符串

例如

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>
#include <sstream>
using namespace std;

int main() {
    ostringstream oss;
    oss << "age = " << 18;

    string s = oss.str();
    cout << s << endl;
}

输出结果是

1

age = 18

这里不是直接打印到屏幕，而是先“攒”成字符串，再取出来。

这里的oss.str()是ostringstream很关键的一个函数

1

string s = oss.str();

意思是把这个流里面积累的内容全部取出来给字符串s

比如

1
2

ostringstream oss;
oss << "Hello " << "world " << 123;

这时候 oss 里面其实已经存着：Hello world 123了

这个东西的作用就在于 面对处理复杂字符串拼接时更加自然。

ostringstream 的写位置

1
2
3
4
5

ostringstream oss("Ito-En Green Tea");
cout << oss.str() << endl;

oss << "16.9 Ounces";
cout << oss.str() << endl;

这段代码的输出结果是

1
2

Ito-En Green Tea
16.9 Ouncesn Tea

为什么第二行的结果是这样的呢？

因为ostringstream 有一个“写位置”（put pointer）。
它不会默认跳到字符串末尾去追加，而是从当前写位置开始覆盖写。
在这种构造下，写位置一开始在开头，所以会把原来前面的字符覆盖掉。
但是我们可以用ostringstream::ate把初始写位置定位到末尾

ate 可以理解成 at end

1
2
3

ostringstream oss("Ito-En Green Tea", ostringstream::ate);
oss << " 16.9 Ounces";
cout << oss.str() << endl;

这样结果就会是:

1

Ito-En Green Tea 16.9 Ounces

istringstream

istringstream 是什么

同样istringstream可以分为两部分：

input：输入

string stream：字符串流

1
2
3
4
5

string s = "123";
istringstream iss(s);

int x;
iss >> x;

这里不是键盘输入，而是字符串 “123” 充当了输入源。
它的读取方式和 cin 很像，
所以可以把它理解成“假装这个字符串是键盘输入”

istringstream 的读位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>
#include <sstream>
using namespace std;

int main() {
    string line = "101 Jinyao 18";
    istringstream iss(line);

    int id, age;
    string name;

    iss >> id >> name >> age;

    cout << id << "\n";
    cout << name << "\n";
    cout << age << "\n";

    return 0;
}

这段代码的输出结果是：

1
2
3

101
Jinyao
18

它内部有一个读指针，读一次，就往后走一次。

istringstream 用 >> 读取时，一般会在这几种情况停下：

第一种：遇到空白字符

空格、换行、tab

第二种：遇到不符合当前类型格式的字符

比如你在读 int，结果遇到了字母

第三种：读到字符串结尾

也就是没有更多内容了

例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>
#include <sstream>
using namespace std;

int main() {
    istringstream iss("123 abc 45");

    int x;
    string s;
    int y;

    iss >> x;   // 读到 123，遇到空格停
    iss >> s;   // 读到 abc，遇到空格停
    iss >> y;   // 读到 45，读到结尾停

    cout << x << "\n" << s << "\n" << y << endl;
}

这里三次停止分别是：

第一次：遇到空格停
第二次：遇到空格停
第三次：遇到字符串结尾停

stringToIntegerTest

现在我们来编写一个把字符串转化成整数的函数：

1
2
3
4
5
6

int stringToInteger(const string& s){
    istringstream iss(s);
    int result;
    iss >> result;
    return result;
}

如果我们在这里输入的不是数字的话，该程序的结果就会是一个垃圾值，
但是如果我们输入的字符串开头可被读取整数，例如 123a ，那么程序就会读取123，然后结果就是123了。

Four bits状态位

Good bit

Ready for read/write
stream就绪，可执行读写操作
表示stream无错误，可以正常读写

Fail bit

previous operation failed, all future operations frozen
上一次操作失败，后续所有操作被冻结
通常是格式错误、输入不匹配等可恢复错误

EOF bit

previous operation reached the end of buffer content
上一次操作已到达缓冲区内容末尾
表示读取到了stream的末尾(End of File)

Bad bit

external error,likely irrecoverable
发生外部错误，通常不可恢复
多位硬件/系统级错误（如磁盘故障、stream断开）

buffer stream

buffer stream 是什么

buffer stream ：characters are stored in an intermediate buffer before being moved to the external source
带缓冲的流：字符在被转移到外部数据源之前，会先存储在中间缓冲区

buffer stream 的工作流程

1

cout << "hello";

“hello”会先写进cout的缓冲区
当满足以下条件时，缓冲区才会被刷新（flush），把字符真正输出到控制台

1. 缓冲区被写满
2. 程序执行到 endl ，或者手动调用 flush()
3. 程序正常结束
4. 输入流（cin）被触发（会自动刷新cout缓冲区）

为什么要用 buffer

直接频繁地向控制台进行 IO 操作，会非常慢，用缓冲区可以把多次小操作合并成一次大操作，从而大幅提升程序的运行效率

manipulators

有些操纵符插入到流中，会改变流的行为,
这里我们直接通过代码展示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    // endl ：插入换行符并刷新流
    cout << "Hello" << endl << "World" << endl; // 换行+刷新
    
    // boolalpha ：以 true/false 字符串形式输出布尔值
    cout << boolalpha << true << " " << false << endl; // 输出 true false
    
    // hex ：以十六进制格式输出数字
    cout << hex << 255 << endl; // 输出 ff（十六进制）
    
    // setprecision ：调整输出数字的精度
    cout << setprecision(3) << 3.14159 << endl; // 输出 3.14（3位有效数字）
    cout << fixed << setprecision(2) << 3.14159 << endl; // 输出 3.14（小数点后2位）
    
    return 0;
}

汉诺塔由三根柱子（分别用A、B、C表示）和n个大小互不相同的空心盘子组成。一开始n个盘子都摞在柱子A上，大的在下面，小的在上面，形成了一个塔状的锥形体。
对汉诺塔的一次合法的操作是指：从一根柱子的最上层拿一个盘子放到另一根柱子的最上层，同时要保证被移动的盘子一定放在比它更大的盘子上面（如果移动到空柱子上就不需要满足这个要求）。我们可以用两个字母来描述一次操作：第一个字母代表起始柱子，第二个字母代表目标柱子。例如，AB就是把柱子A最上面的那个盘子移到柱子B。汉诺塔的游戏目标是将所有的盘子从柱子A移动到柱子C上面。
计算汉诺塔移动所需要的最少步骤数。

输入格式

输入一个整数n（1≤n≤30），代表盘子的个数。

输出格式

输出每一步操作的方法，最后输出一个数，这个数表示移动的次数。我们保证答案不会超过10的18次方。

输入输出样例 #1

输入 #1

1

1

输出 #1

1
2

Move disk 1 from A to C
1

输入输出样例 #2

输入 #2

1

2

输出 #2

1
2
3
4

Move disk 1 from A to B
Move disk 2 from A to C
Move disk 1 from B to C
3

思路

这里我们先约定一下，要被执行操作的圆盘所在柱子的编号为$source$，目标柱子的编号为$target$，而另外一个柱子的编号为$temp$。

我们从$n=1$开始分析：

• 此时，只需要把唯一的圆盘从$source$移动到$target$即可。
• 步数为$1$。

$n=2$时：

• 先把$1$从$source$移动到$temp$。
• 再把$2$从$source$移动到$target$。
• 最后把$1$从$temp$移动到$target$。
• 步数为$3$。

$n=3$时：

• 先把除了$3$以外的圆盘从$source$移动到$temp$。
• 再把$3$从$source$移动到$target$。
• 最后把剩余的圆盘从$temp$移动到$target$。
• 步数为$3+1+3=7$。

好，我们来找一下规律：
是不是对于$n$个圆盘，我们可以先把除了$n$以外的圆盘从$source$移动到$temp$，再把$n$从$source$移动到$target$，最后把剩余的圆盘从$temp$移动到$target$？一共就这大的三步，而且第一步和最后一步的步数相同，第二步的步数为$1$。

对于第一步和最后一步，不就等效于$n-1$个圆盘的移动步数吗？
因为$n$始终在最下面，不会影响到其他圆盘的移动。我们在分析$n-1$个圆盘的移动步数时，就可以直接忽略掉$n$。

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
using namespace std;

void hanoi(int n, char source, char temp, char target) {
    if (n == 1) {
        cout << "Move disk 1 from " << source << " to " << target << endl;
        return;
    }
    //将除了n以外的圆盘从source移动到temp
    hanoi(n-1, source, target, temp);
    //将n从source移动到target
    cout << "Move disk " << n << " from " << source << " to " << target << endl;
    //将剩余的圆盘从temp移动到target
    hanoi(n-1, temp, source, target);
}
int main() {
    int n;
    cin >> n;
    //假设柱子用A、B、C表示
    hanoi(n, 'A', 'B', 'C');
    return 0;
}

一些思考

如果你每次学完汉诺塔问题，过一段时间后就又写不出来了。这在一定程度上不是你的问题，汉诺塔问题有它的特殊性。
特殊点在于“不可人脑模拟”
一般人的大脑无法模拟汉诺塔问题中的的全部移动过程（格式大于等于4就不行）。
这会导致人的心里非常没底。
由于无法模拟，
所以只能把希望全部放在子问题的定义和描述上。只能通过子问题的定义和描述来解决问题。

贪心算法，顾名思义，就是采取贪心的策略去解决或者优化问题。其主要思想是：保证每次操作都是局部的最优解，从而得到全局最优解。（但其实从字面上来看，贪心显然不是一个好词，他仅仅局限于当下，而不是去纵观全局，因此，有时候贪心算法并不能得到全局最优解。）

贪心算法的思路

我们首先肯定是要确定我们的贪心目标，比如性价比最高的商品，或者最短的时间，或者最少的钱。然后，我们按照这个目标，一步一步的进行贪心选择，直到我们达到目标。

贪心算法的应用

背包问题洛谷P2240

这里还是把题目写出来吧

题目描述

阿里巴巴走进了装满宝藏的藏宝洞。藏宝洞里面有 $N(N \le 100)$ 堆金币，第 $i$ 堆金币的总重量和总价值分别是 $m_i,v_i(1\le m_i,v_i \le 100)$。阿里巴巴有一个承重量为 $T(T \le 1000)$ 的背包，但并不一定有办法将全部的金币都装进去。他想装走尽可能多价值的金币。所有金币都可以随意分割，分割完的金币重量价值比（也就是单位价格）不变。请问阿里巴巴最多可以拿走多少价值的金币？

输入格式

第一行两个整数 $N,T$。

接下来 $N$ 行，每行两个整数 $m_i,v_i$。

输出格式

一个实数表示答案，输出两位小数

输入输出样例 #1

输入 #1

1
2
3
4
5

4 50
10 60
20 100
30 120
15 45

输出 #1

1

240.00

思路

注意到题目说了，所有金币都可以随意分割，分割完的金币重量价值比不变。因此，我们可以先对金币按照价值从小到大排序，然后从后往前遍历（为什么不从大到小排序呢？因为sort()函数默认是从小到大排序的，我比较懒），如果当前的金币的重量小于等于背包的容量，我们就把它装进去，并更新背包的容量和价值。如果当前的金币的重量大于背包的容量，我们就停止装了，因为装不下了。

这里我们使用结构体来打包金币的信息，包括重量和价值以及性价比。
然后要写一个排序函数来告诉sort()函数我们要按照结构体中的价值进行排序。

1
2
3
4
5
6
7
8
9

struct Item {
    int weight;
    int value;
    double ratio;
};

bool cmp(Item a, Item b) {
    return a.ratio > b.ratio;
}

感觉这一步应该是最关键的，也是最麻烦的（对于一个rookie来说）。

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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

struct Item {
    int weight;
    int value;
    double ratio;
};

bool cmp(Item a, Item b) {
    return a.ratio > b.ratio;
}

int main() {
    int N, T;
    cin >> N >> T;
    vector<Item> items(N);
    for (int i = 0; i < N; i++) {
        cin >> items[i].weight >> items[i].value;
        items[i].ratio = (double)items[i].value / items[i].weight;
    }
    sort(items.begin(), items.end(),cmp);
    double total = 0.0;
    for (int i = 0; i < N && T > 0; i++) {
        if (items[i].weight <= T) {
            total += items[i].value;
            T -= items[i].weight;
        } else {
            total += items[i].ratio * T;
            T = 0;
        }
    }
    printf("%.2f\n", total);
    return 0;
}

题目描述

棋盘上 $A$ 点有一个过河卒，需要走到目标 $B$ 点。卒行走的规则：可以向下、或者向右。同时在棋盘上 $C$ 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。

棋盘用坐标表示，$A$ 点 $(0, 0)$、$B$ 点 $(n, m)$，同样马的位置坐标是需要给出的。

现在要求你计算出卒从 $A$ 点能够到达 $B$ 点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。

输入格式

一行四个正整数，分别表示 $B$ 点坐标和马的坐标。

输出格式

一个整数，表示所有的路径条数。

输入输出样例 #1

输入 #1

1

6 6 3 3

输出 #1

1

6

说明/提示

对于 $100 %$ 的数据，$1 \le n, m \le 20$，$0 \le$ 马的坐标 $\le 20$。

大概思路

这里我们先忽略马的控制点，只讨论卒从A点运动到B点的路径条数。

不难发现，如果B点与A点在同一条直线上，那么卒的路径就只有一条。

现在假设B点坐标为$(1,1)$,那路径是不是有两条？一个是先向下再向右，另一个是先向右再向下。

如果B点坐标为$(1,2)$,那路径有多少条？
自己画一下，是不是有三条？

B点坐标为$(2,1)$呢？

欸，这时我们可以发现一个规律：

如果B点坐标为$(x,y)$,那么卒的路径条数为他到$(x-1,y)$的路径条数加上他到$(x,y-1)$的路径条数。

有没有发现这很像我们在高中时做的数学概率题目？我们只需要每次考虑结果的上一步。

那么此时的代码应该是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

int main() {
    long long n, m, x, y;
    cin >> n >> m >> x >> y;
    long long a[30][30] = {0};
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            if(i == 0 && j == 0){
                continue;
            }
            if(i == 0 || j == 0){
                a[i][j] = 1;
            }
            else{
                a[i][j] = a[i-1][j] + a[i][j-1];
            }
        }
    }
    cout << a[n][m] << endl;
    return 0;
}

好，下面我们再把马的控制点考虑进来

首先肯定要标记出马的控制点，我们可以先把二维数组中所有的元素都赋值为1，然后再手动把马的控制点的坐标标记为0（听起来有点苕）。
另外，要注意马的控制点是否在棋盘上面！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

long long n, m, x, y;
cin >> n >> m >> x >> y;
long long a[30][30] = {0};
for (int i = 0; i <= n; i++) {
    for (int j = 0; j <= m; j++) {
        a[i][j] = 1;
    }
}
a[x][y] = 0;
if(x + 2 <= n && y - 1 >= 0){
    a[x+2][y-1] = 0;
}
if(x + 2 <= n && y + 1 <= m){
    a[x+2][y+1] = 0;
}
if(x - 2 >= 0 && y - 1 >= 0){
    a[x-2][y-1] = 0;
}
if(x - 2 >= 0 && y + 1 <= m){
    a[x-2][y+1] = 0;
}
if(x - 1 >= 0 && y - 2 >= 0){
    a[x-1][y-2] = 0;
}
if(x - 1 >= 0 && y + 2 <= m){
    a[x-1][y+2] = 0;
}
if(x + 1 <= n && y - 2 >= 0){
    a[x+1][y-2] = 0;
}
if(x + 1 <= n && y + 2 <= m){
    a[x+1][y+2] = 0;
}

然后在遍历数组的时候，如果数组元素为0，即遇到马的控制点，就要跳过这个点，不进行路径计数。

1
2
3
4
5
6
7
8
9
10

for (int i = 0; i <= n; i++) {
    for (int j = 0; j <= m; j++) {
        if(i == 0 && j == 0){
            continue;
        }
        if(a[i][j] == 0){
            continue;
        }
    }
}

我们接着用相同的方法找一下规律，
当B点在第一列或者第一行时，他的路径条数等于他的上面或者左边的路径条数。

1
2
3
4
5
6

if(i == 0){
    a[i][j] = a[i][j-1];
}
else if(j == 0){
    a[i][j] = a[i-1][j];
}

当B点在第一列或者第一行以外时，他的路径条数等于他的上面或者左边的路径条数加上他的左上角的路径条数。

1
2
3

else{
    a[i][j] = a[i-1][j] + a[i][j-1];
}

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

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

int main() {
    long long n, m, x, y;
    cin >> n >> m >> x >> y;
    long long a[30][30] = {0};
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            a[i][j] = 1;
        }
    }
    a[x][y] = 0;
    if(x + 2 <= n && y - 1 >= 0){
        a[x+2][y-1] = 0;
    }
    if(x + 2 <= n && y + 1 <= m){
        a[x+2][y+1] = 0;
    }
    if(x - 2 >= 0 && y - 1 >= 0){
        a[x-2][y-1] = 0;
    }
    if(x - 2 >= 0 && y + 1 <= m){
        a[x-2][y+1] = 0;
    }
    if(x - 1 >= 0 && y - 2 >= 0){
        a[x-1][y-2] = 0;
    }
    if(x - 1 >= 0 && y + 2 <= m){
        a[x-1][y+2] = 0;
    }
    if(x + 1 <= n && y - 2 >= 0){
        a[x+1][y-2] = 0;
    }
    if(x + 1 <= n && y + 2 <= m){
        a[x+1][y+2] = 0;
    }
    
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            if(i == 0 && j == 0){
                continue;
            }
            if(a[i][j] == 0){
                continue;
            }
            if(i == 0){
                a[i][j] = a[i][j-1];
            }
            else if(j == 0){
                a[i][j] = a[i-1][j];
            }
            else{
                a[i][j] = a[i-1][j] + a[i][j-1];
            }
        }
    }
    cout << a[n][m] << endl;
    return 0;
}

递归函数，简单来说就是函数自己调用自己。可能有点抽象，那我们直接上代码吧。

现在我们要写一个等差数列的函数，首项是1，公差是3，怎么用递归函数来实现呢？

首先，我们定义的这个函数很显然有返回值，然后再观察等差数列的性质：后一项与前一项的差等于公差。我们先写一个大概的函数框架：

1
2
3
4
5

int f(int n){
    int result;
    result = f(n-1) + 3;
    return result;
}

我们先来举个例子，要求第四项是多少，我们就要知道第三项是多少，以此类推……直到我们要知道第一项是多少。好，然后我们要怎么知道第一项是多少呢？如果你还类推那你可能不适合学递归函数。直接给他一个首项啊！

所以完整的递归函数代码如下：

1
2
3
4
5
6
7
8
9
10

int f(int n){
    int result;
    if(n == 1){
        result = 1;
    }
    else{
        result = f(n-1) + 3;
    }
    return result;
}   

递归函数的缺陷

这里我们引入斐波那契数列的问题，我们知道斐波那契数列的特点是：f(n) = f(n-1) + f(n-2)，其中f(1) = 1，f(2) = 1。
用脑子思考模拟一下刚才学的递归函数，你会发现，这个函数的缺陷在于它会重复计算相同的子问题，导致效率低下。

怕你不明白，我们来看看：
假设你要求f(5),你是不是要先计算f(4)和f(3)呢？，你求f(4)的时候又要计算f(3)和f(2),OK,这里就可以看到，我们重复计算了f(3)，如果你自己用递归函数在编译器里运行，当n足够大的时候，你会发现到后面要花很长时间才会算出一项。

递推算法

那怎么办呢？我们可以用另一种方法，叫做“递推算法”，简单一点，就是我们可以用for循环计算每一项，然后把结果存入数组，这样就不用重复计算了。

1
2
3
4
5
6
7
8
9

int f(int n){
    int a[1000] = {0};
    a[1] = 1;
    a[2] = 1;
    for(int i=3;i<=n;i++){
        a[i] = a[i-1] + a[i-2];
    }
    return a[n];
}

你可能有疑问：

1.为什么要先定义数组里的元素都为0呢？

因为如果不定义的话，空数组里的元素是不知道的，是随机的的，也就是垃圾值，有时候会影响结果。

2.a[0]怎么不用？

只是为了方便计算，我们把数组的下标从1开始，所以a[0]是没有用的。

总结

递归适合表达能够被拆成相同子问题的结构，但它不一定比循环更高效。如果递归过程中重复计算相同的子问题，运行时间会明显增加。递推算法可以从已知结果出发逐步计算后续结果，避免这里的重复计算。

怕你不懂，下一次我们找几道题目来练习一下。

概述

在CS50的第三周，我们主要了解到了三种算法：冒泡排序（bubble sort），选择排序（selection sort），以及归并排序（merge sort），还有递归的思想，并且对时间复杂度有了一个大概的了解。下面我们来总结一下这三种算法的特点以及代码实现。

btw，其实在C++中，我们不用自己实现排序算法，因为C++已经内置了排序函数，也就是std::sort()，并且sort()使用的是快速排序算法，其时间复杂度为O(nlogn)。

冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。主要思想是通过对相邻元素进行比较和交换，使得较大的元素逐渐向上移动，直到最后一个元素。

特点

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)
• 稳定性：稳定

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>

void bubble_sort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

选择排序（Selection Sort）

选择排序是一种简单直观的排序算法。主要思想是通过遍历数组，找到最小的元素，将其放在数组的第一个位置，然后再从剩下的元素中找到最小的元素，将其放在数组的第二个位置，以此类推。

特点

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)
• 稳定性：不稳定

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stdio.h>

void selection_sort(int arr[], int n) {
    int i, j, min_idx;
    for (i = 0; i < n - 1; i++) {
        min_idx = i;
        for (j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }    
        int temp = arr[i];
        arr[i] = arr[min_idx];
        arr[min_idx] = temp;
    }
}

归并排序（Merge Sort）

归并排序是一种分治法的排序算法。主要思想是将数组分成两半，分别排序，然后再将排序好的两半合并成一个有序数组。

特点

• 时间复杂度：O(nlogn)
• 空间复杂度：O(n)
• 稳定性：稳定

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <stdio.h>

void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++) {
        L[i] = arr[l + i];
    }    
    for (j = 0; j < n2; j++) {
        R[j] = arr[m + 1 + j];
    }    
    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }    
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }    
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void merge_sort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        merge_sort(arr, l, m);
        merge_sort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

总结

在Week3视频的最后，David通过动画演示直观地展现了三种排序算法的过程，可以很清晰地看到归并排序的时间是最快的，这主要是因为归并排序的分治法的思想，使得它可以将数组分成两半，分别排序，然后再将排序好的两半合并成一个有序数组，这样就使得时间复杂度降低到O(nlogn)。而选择排序和冒泡排序的时间复杂度都为O(n^2)，这主要是因为它们的比较和交换操作，使得它们的效率较低。
其实在写函数的时候，我们也可以利用递归思想，也就是分治法来优化代码，同样来自David，例如我们要写一个打印Mario里的砖块（阶梯型）的函数，我们可以这样思考：每次打印下一层时，其实就是比上一层砖块多了一个砖块。让我们来看看下面的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void draw(int n)
{
    if (n <= 0)
    {
        return;
    }

    draw(n - 1);

    for (int i = 0; i < n; i++)
    {
        printf("#");
    }
    printf("\n");
}