算法刷题笔记

1 前言

• 常见测评结果及原因

1. Accepted, AC, 答案正确
2. Compile Error, CE，编译错误
3. Wrong Answer, WA，答案错误
4. Time Limit Exceeded, TLE，运行超时：时间复杂度过高，特殊数据死循环
5. Runtime Error, RE 运行错误:
   段错误（非法访问内存：数组越界、指针乱飞）
   浮点错误（除外为0、模数为0）
   递归爆栈（递归层数过深）
   一般来说，先检查数组大小是否比数据范围大，在检查除数为0，有递归检查递归。
6. Memory Limit Exceeded, MLE, 内存超限：数组太大
7. Presentation Error, PE, 格式错误：最接近AC的错误，多输出空格或换行。
8. Output Limit Exceeded, OLE, 输出超限：输出过量内容，一般是输出了大量调试信息或特殊数据导致的死循环导致。

2 C/C++入门

2.1 注意点

1. 不要同时使用cout和printf。

2.2 数据类型

整型 (末尾为scanf()的读入格式符)

• int ：-2³¹ ~ 2³¹-1。32bits(4Bytes), 绝对值在10^9以内。（20亿） %d
• long long : 64bits, 超过2147483647（如10¹⁰ , 10¹⁸）。long long在赋值>2³¹-1时，需在后面加上LL，否则会编译错误。 %lld
• 整型前都可以加上unsigned，表示无符号类型。

浮点型

• float : 32bits, 1bit符号位，8bits指数位，23bits尾数位。有效精度6~7位。 %f
• double : 64bits 1bit, 11bits, 52bits。有效精度15~16位 。 %lf

字符型

• char: 0~127, 小写字母比大写字母大32。 %c
• 转义字符： \0: NULL, \n: 换行
• 字符串常量 %s

布尔型

bool : %d

强制类型转换：(int)r

符号常量：#define 标识符 常量, #define pi 3.14, #define ADD(a, b) ((a) + (b))
宏定义直接将对应部分替换，然后才编译运行。

• scanf(): 除char数组外，需加&。除%c外，对其他格式以空白符为结束判断标志。
  %c是可以读入空格和换行的。输入数据后程序异常退出，马上检查是否漏写&。

• printf(): %d, %lld, %f, %f, %c, %s。 printf("%%")； printf("\");
  double在scanf时是%lf,在printf是%f。
  两个float类型相乘，整数部分就不精确了，因此建议用double类型。

• getchar(): 输入单个字符，可以识别换行符

• putchar(): 输出单个字符

• gets(), puts(): 输入、输出一行。（已弃用）

常用math函数：#include<cmath>
fabs(double x), floor(double x), ceil(double x), pow(double r, double p), sqrt(), log(), sin(), cos(), tan(), asin(), acos(), atan(), round(double x): 四舍五入

2.3 数组

memset(数组名，值，sizeof(数组名));
#include<cstring>
strlen(), strcmp(), strcpy(), strcat(),

• sscanf和sprintf : 字符串输入输出

sscanf(str, "%d", &n); //从str中读入, sscanf()还支持正则表达式
sprintf(str, "%d", n); //向str中输出

2.4 指针与引用

• 指针
  指针是一个unsigned类型的整数，变量的地址。
  &:取地址运算符
  指针变量：用来存放指针
  int* p = &a;

• 引用
  原变量的别名，不产生副本。对引用变量的操作就是对原变量的操作。
  常量不可以引用。

2.5 浮点数的比较

const double eps = 1e-8;
#define Equ(a, b) ((fabs((a) - (b))) < (eps)) // ==
#define More(a, b) (((a) - (b)) > (eps)) // >
#define Less(a, b) (((a) - (b)) < (-eps)) // <
#define MoreEqu(a, b) (((a) - (b)) > (-eps)) // >=
#define LessEqu(a, b) (((a) - (b)) < (eps)) // >=

2.6 复杂度

时间复杂度：一般的OJ, 1秒承受的运算次数大概是10⁷~10⁸。因此O(n²) 当n=1000时可以承受。

2.7 黑盒测试

单点测试：程序对一组数据能完整执行即可。PAT是单点测试。
多点测试：全部通过才AC，有一组数据错误就得0分。

多点测试的一般输入格式：

• while…EOF型
• while…break型
• while(n --)型

多点测试时，每次循环都要重置一下变量和数组。

3 入门模拟

3.1 简单模拟

题目怎么说，你就怎么做。代码能力。

• A1002 A+B for Polynomials
  多项式的模拟：

  • 用数组表示p[n] : 指数为n，系数为p[n]。

• A1009 Product of Polynomials
  涉及多项式的乘法：

  • 单独一个数组无法表示，用一个结构体数组poly[n]表示。
  • 结构体包含exp和coef成员。
  • 第一个读入的多项式用poly[n]记录，第二个读入时直接计算结果，指数相加，系数相乘，结果保存在ans[n]中。

• A1065 A+B and C(64 bit)
  分情况讨论：

  • a>0, b>0, a+b<0 时正溢出，输出true；
  • a<0, b<0, a+b>0 时负溢出，输出false；
  • 无溢出时，a+b>c时输出true; a+b<=c时输出false。

• A1042 Shuffling Machine

  • 用一个char数组建立编码和花色的映射：mp[] = {S, H, C, D, J}. 若牌号为x，mp[(x - 1) / 13]为花色，(x - 1) % 13 + 1为牌的大小编号。
  • 用start数组存放原来的原来的牌号顺序，start[i]初始化为i。
  • 用end数组存放操作后的牌号顺序。
  • 用next数组存放每个位置上的牌操作后的位置。
  • 每一次操作后，用end数组覆盖start数组(start[i]=end[i])，以便进行下一次操作。
  • 转移表达式：end[next[i]] = start[i]。

• A1046 Shortest Distance
  一个环形公路每次只能移动相邻节点，求给定两点最短距离。

  • 用一个dis数组记录累计距离，即dis[i]为从1号节点到i号节点的下一个节点(这样N到1的距离可以记录)顺时针走的总距离，这样每一段距离可以用dis[i] - dis[i - 1]得到。
  • 用sum记录记录一圈的总距离，这样result = min(dis(l,r), sum - dis(l,r))。

3.2 查找元素

小范围查找：遍历；大范围查找：二分。

• B1041 考试座位号
  用试机座位号作为索引，16位准考证号可以用long long存放。
  long long 8字节： -9223372036854775808 ~ 9223372036854775807；(即-2^63~263-1)
  关于时间复杂度： 对于1s的运行时限，设计的算法复杂度不能超过百万级别。

• B1028 人口普查
  结构体person包括name，和年龄year, month, day ,以及定义比较函数operator<= 和>=。
  初始化时将left, right初始化为最小的日期和最大的日期，由于只需要记录最大值和最小值以及有效次数，因此只需要几个临时变量oldest, youngest, left, right, temp，在读入时比较即可。

• A1011 World Cup Betting
  读入比较记录最大值和索引即可。

• A1006 Sign In and Sign Out
  直接利用c++的string的字典序来比较时间。

• A1036 Boys and Girls
  按gender分别记录最大值和最小值，在字符数组赋值时要用strcpy()函数

3.3 图形输出

（1）找规律输出
（2）定义一个二维字符数组，按规律填充，输出整个数组。

• A1031 Hello World for U
  这题需要输出U形的"helloworld！"。要求底边n2 >= n1 = n3切n2最大的情况，最重要的一步就是算出n2或n1，根据不等式可以推出n1=(N+2)/3。然后就是按行输出字符，输出规律为：前n1-1行输出第一个字符+len-n1*2个空格，然后输出对应的倒序的字符。第n1行输出中间（len-n1*2）个字符即可。

3.4 日期处理

平闰年，大小月。

3.5 进制转换

P进制转Q进制：P进制x转十进制y；十进制y转Q进制z（除基取余法）。

//P进制x转十进制y
int y = 0, product = 1;
while(x != 0) {
	y += (x % 10) * product;
	x = x / 10;
	product *= P;
}
//十进制y转Q进制z（除基取余法）
int z[40], num = 0;
do {
	z[num ++] = y % Q;
	y /= Q;
} while(y != 0);

• B1037 在霍格沃兹找钱
  可以把所有值转换到Knut单位，然后使用%、/来实现进制转换。
• A1019 General Palindromic Number
  用一个vector(stack)实现进制转换，判断回文数，比较num[i] == num[len-i-1]。
• A1027 Colors in Mars
  简单的进制转换(只包含两三位)直接使用% 、/实现。
• A1058 A+B in Hogwarts
  可以采用和B1037相同的方法,但是最大数2*(2*10⁷*17*29+16*29+28)=1.972e+010 超出int范围，需要将所有类型换为long long。

3.6 字符串处理

• B1024 科学计数法
  定位字母E的位置，分指数为正和为负来讨论。
• B1048 数字加密
  反转字符串，求numA和numB.
• A1001 A+B Format
  求出数字的每一位存到数组中，然后倒序输出。
• A1005 Spell It Right
  控制输出的递归实现：

void dfs(int n) {
	if(n / 10 == 0) {
		printf("%s", num[n % 10]);
		return;
	}
	dfs(n / 10);
	printf(" %s", num[n % 10]);
}

把数字sum写到数字数组的简单办法：

sprintf(digit, "%d", sum); //把sum按%d的格式写到数组digit[]中，digit必须是字符型数组。

• A1077 Kuchiguse
  求最长公共子后缀。反转字符串，求公共前缀。
  由于读入的一行字符串中含空格，而scanf()的%s遇到空格会停止。
  使用如下语句读取一行：

scanf("%[^\n]%*c", a);

读取第一个数字后，使用getchar()读取下个换行符。
记录minLen。外层循环遍历minLen,内层循环遍历n，并判断same。

• A1082 Read Number in Chinese
  先处理负号，然后正负一起处理。将读入的数字串倒过来。四个分为一组考虑，个十百千。第四位要输出Wan，第八位要输出Yi。
  考虑ling和非ling的处理。非ling情况比较简单。ling的是否发音，看它后面的第一个非ling的数字。注意中间四位全为0时，Wan也不能输出。
  还有一个边界条件0。
  在0的情况下, 看下一个数字是否不为0(倒序后的前一个，i - 1)

if(i != 0 && digits[i - 1] - '0' != 0)
	readOut = true;

• A1016 Phone Bills
  思路：先按名字字典序排序，再按月份排序，再按天排序，再按时排序，再按分排序。对于相同的名字的序列，查看online-offline是否匹配，无匹配的用户名不输出。有匹配则继续查看有几对匹配，以计算时间和费用。
  技巧1：时长的计算方法：1、用循环遍历(代码如下)。2、时间转换为“分”作差。

while(start.day < end.day || start.hour < end.hour || start.minute < end.minute) {
	start.minute ++;
	if(start.minute == 60) {
		start.minute = 0;
		start.hour ++;
	}
	if(start.hour == 24) {
		start.hour = 0;
		start.day ++;
	}
}

技巧2：如果有比较麻烦的一部分代码，可以整合成函数的形式。模拟题可以在纸上模拟一遍。
技巧3：要判断是否匹配，即相邻的两条记录，前一条是online后一条是offline，可以用一个needPrint标记，初始化为0，遇到online则赋值为1，needPrint=1且遇到offline则赋值为2。needPrint<2则未匹配，=2则有匹配。相同名字的记录用on和next标界首尾。有匹配时在on和next之间查看有几对匹配。类似这样的考虑用while循环（on<n 、on<next）。

4 算法初步

4.1 排序

选择排序: 进行n趟操作，每趟选出[i, n]中最小的元素，令其与A[i]交换。O(n²)

void selectSort() {
	for(int i = 1; i <= n; i ++) { //数组下标1~n
		int k = i;
		for(int j = i; j <= n; j ++) {
			if(A[j] < A[k]) {
				k = j; //记录最小元素下标k
			}
		}
		int temp = A[i];
		A[i] = A[k];
		A[k] = temp;
	}
}

插入排序： 进行n-1趟排序，从后往前枚举已有序部分来确定插入位置。O(n²)

int A[maxn], n;//数组下标1~n;
void inserSort() {
	for(int i = 2; i <= n; i ++) {
		int temp = A[i], j = i;//j从i开始往前枚举
		while(j > 1 && temp < A[j - 1]) { //temp小于前一个元素A[j - 1]的话
			A[j] = A[j - 1]; //把A[j - 1]后移一位
			j --;
		}
		A[j] = temp; //找到插入位置为j
	}
}

• A1012 The Best Rank
  #include<algorithm>: sort, cmp。
  id用int存储，Rank[1000000][4]保存排名。
  Student结构体包括int id和int grade[4]。
  考虑排名相同的情况。

• A1025 PAT Ranking
  使用一个一维数组testee[30010]存储，二维数组不太适合。
  每读入一个考场，在这个考场内排序，然后使用一个while循环计算local_rank。最后对整个数组排序，使用while循环计算final_rank。
  局部数组排序：

sort(testee + idx - K, testee + idx, cmp); //idx为整个数组的下标

注意分数相同时，按名字字典序排序。

• A1028 List Sorting
  写三个排序函数，按照C来选择。字符数组长度最小为7和9。

• A1055 The World’s Richest
  M的范围在100以内，可以预处理将每个年龄前100名以内的全部人存到另一个数组，以避免超时（我使用的方法并未超时）。

• A1075 PAT Judge
  技巧1: 结构体设计

struct User {
	int id;
	int score[6];
	int total_score;
	int perfect_solve;
	bool flag;
	int rank;
}user[10010];

其中score[0]、user[0]空出来，以方便排序，（sort(user+1, user + N + 1, cmp);）。score用一个数组来存放每道题的得分。

技巧2：需要初始化时，可以写一个初始化函数init()（那么N就要定义为全局变量）。其中数组初始化可以使用memset:

memset(user[i].score, -1, sizeof(user[i].score));

注意点：1、完美解题数按照第一次满分计算，不包括多次满分提交，可以在计算总得分同时计算下完美解题数。2、没有一题提交代码或提交代码未编译成功的不进行排名(而不是总分0分的不排名)。3、坑点：提交代码未编译成功的算0分而不是-。而提交成功全得0分的总分为0分的也要输出。

提醒：第四个样例第一次没过，改了得分判断逻辑后过了，目前不知道之前错哪了。正确的得分判断逻辑为：如果得分不为-1，flag设为true，即参与排名；如果得分为-1且之前也是-1，则将得分赋值为0；如果得分大于之前的得分则更新得分。

• A1083 List Grades
  简单结构体排序

• A1080 Graduate Admission
  学生按照平均成绩排名，成绩相同时按考试成绩排名。学校按志愿优先录取，排名靠前优先录取。最后一名录取的排名相同的学生即使超出限额也要录取。结构体中记录是否录取和录取的学校。然后用一个vector数组记录每个学校录取的学生序号，将vector按照学生序号升序排序在输出。
  题解中另外使用了一个school结构体，记录限额，实际招生人数，学生序号，最后录取的学生序号。

• A1095 Cars on Campus
  遇到的问题：同一辆车可能有多个出入记录，需要记住车牌号。
  题解方法：用一个map<string, int>存储停车总时长。
  技巧1：存储所有记录，并用另一个数组存储有效记录。
  技巧2：如何确定有效记录：先将记录按先Id后时间排序，然后

if(!strcmp(all[i].id, all[i + 1].id) &&
   !strcmp(all[i].status, "in") &&
   !strcmp(all[i + 1].status, "out") {
   valid[num ++] = all[i];
   valid[num ++] = all[i + 1];
}

并计算停留时间，存储到map中。

int inTime = all[i + 1].time - all[i].time;
if(parkTime.count(all[i].id) == 0) {
	parkTime[all[i].id] = 0;
}
parkTime[all[i].id] += inTime;
maxTime = max(maxTime, parkTime[all[i].id]);

技巧3：记录车辆的方法：遍历所有有效记录，若时间小于现在的时间，状态为in，则numCar ++; 状态为out，则numCar --。

while(now < num && valid[now].time <= time) {
	if(!strcmp(valid[now].status, "in")) numCar ++;
	else numCar --;
	now ++;
}

技巧4：遍历车牌号

map<string, int>::iterator it;
for(it = parkTime.begin(); it != parkTime.end(); it ++) {
	if(it->second == maxTime) {
		printf("%s ", it->first.c_str());
	}
}

4.2 散列

hash,空间换时间。将元素通过一个函数转换为整数，使得该整数可以尽量唯一地代表这个元素。
常用hash函数：
直接定址法（恒等变换）：H(key) = key, H(key) = a * key + b
平方取中法 :取key的平方的中间若干位
除留余数法： H(key) = key % mod

解决冲突的办法：
1、线性探查法（Linear Probing）：a + 1, a + 2, …
2、平方探查法（Quadratic probing）: a + 1²,a - 1²,a + 2², a - 2²,…
3、链地址法（拉链法）:把H(key)相同的key连接成一个单链表
一般来说，可以使用map直接使用hash功能。

4.2.1 字符串hash初步

eg: 将二维整点P坐标映射成一个整数：H§ = x * Range + y
将一个字符串S映射成一个整数。
A~Z:0~26, 26进制转10进制。

int hashFunc(char S[], int len) {
	int id = 0;
	for(int i = 0; i < len; i ++) {
		id = id * 26 + (S[i] - 'A');
	}
	return id;
}

A~Z: 0~25, a~z: 26~51 ： 52进制转10进制

int hashFunc(char S[], int len) {
	int id = 0;
	for(int i = 0; i < len; i ++) {
		if(S[i] >= 'A' && S[i] <= 'Z') {
			id = id * 52 + (s[i] - 'A');
		}
		else if(S[i] >= 'a' && s[i] <= 'z') {
			id = id * 52 + (S[i] - 'a') + 26;
		}
	}
	return id;
}

如果加上数字：
（1）增大进制数到62.
（2）如果保证字符串末尾是固定长度的数字，可以直接将数字拼上去。

int hashFunc(char S[], int len) {
	int id = 0;
	for(int i = 0; i < len - 1; i ++) {//末位为数字
		id = id * 26 + (S[i] - 'A');
	}	
	id = id * 10 + (S[len - 1] - '0');
	return id;
}

经典问题：给定N个字符串（三位大写字母组成），在给出M个查询字符串，问查询字符串出现次数。

const int maxn = 100;
char S[maxn][5], temp[5];
int hashTable[26 * 26 * 26 + 10];
int hashFunc(char S[], int len) {
	int id = 0;
	for(int i = 0; i < len; i ++) {
		id = id * 26 + (S[i] - 'A');
	}
	return id;
}

• B1029 旧键盘
  bool hashTable[128]用来存储字符是否出现。

• B1033 旧键盘打字
  自己写的和算法笔记上的题解都没法过第三个测试点且最后一个测试点超时。找到网上大神的题解，长见识了。。

char hashTable[256] = {0};
int main() {
	char c;
	while( (c = getchar()) != '\n')
		hashTable[c] ++;
	while( (c = getchar()) != '\n') {
		if(isupper(c) && hashTable['+'] || hashTable[toupper(c)])
			continue;
		else
			putchar(c);
	}
	return 0;
}

• B1038 统计同成绩学生
  hashTable[score] ++;

• B1039 到底买不买
  while( (c = getchar()) != ‘\n’) {
  hashTable[ch] ++;
  len1 ++;
  }

• B1043 输出PATest
  自己的解法和书上的题解最后一个样例都超时，直接对原字符串反复循环判断会超时。网上的解法是用6个整形变量P,A,T,e,s,t读取时记录个数。输出时-1。

• B1047 编程团体赛
  一开始以为要排序，需要结构体哈希，后来发现只要记录最大值，因此只需要一个hashTable[1010]记录总得分，最后遍历整个哈希表得到最大值。

• A1041 Be Unique
  一开始最后两个样例出现了段错误。
  段错误的常见原因：程序访问了没有定义的地方，或不允许访问的地方。常见原因是数组越界，指针乱飞。
  找到错误原因：索引数组开小了。

本题技巧：需要记录输入的顺序，用一个索引数组实现，然后再hash。

• A1050 String Subtraction
  用hashTable[256]来解决。

• B1005 继续（3n+1）猜想
  这题有个坑点：hashTable只开100或100多一点仍然会出现段错误。因为计算(3*n+1)/2的过程会远超100。因此需要将hashTable设的大一点，1000或10000。或者在判断数的时候如果大于100则不存入hashTable。

• A1048 Find Coins
  找出两个加数加起来等于M。用hashTable记录硬币对应面值的个数。然后遍历到M/2;如hashTable[i]和hashTable[M - i]都>=1则输出；但当 i == M - i时，要求hashTable[i] >= 2。

4.3 递归

4.3.1 Fibonacci

int F(int n) {
	if(n == 0 || n == 1) return 1;
	else return F(n - 1) + F(n - 2);
}

4.3.2 全排列

const int maxn = 11;
// P为当前排列，hashTable记录整数x是否已经在P中
int n, P[maxn], hashTable[maxn] = {false};
void generateP(int index) {
	if(index == n + 1) {
		for(int i = 1; i <= n; i ++) {
			printf("%d", P[i]);
		}
		printf("\n");
		return;
	}
	for(int x = 1; x <= n; x ++) {
		if(hashTable[x] == false) {
			P[index] = x;
			hashTable[x] = true;
			generateP(index + 1);
			hashTable[x] = false;//已处理完P[index]=x的子问题，还原状态
		}
	}
}

4.3.3 n皇后

如果把n个皇后所在的行号一次写出，就会是一个1~n的排列。
遍历每两个皇后，判断是否在同一对角线上。

int cnt = 0;
int n, P[maxn], hashTable[maxn] = {false};
void generateP(int index) {
	if(index == n + 1) {
		bool flag = true;
		for(int i = 1; i <= n; i ++) {
			for(int j = i + 1; j <= n; j ++) {
				if(abs(i - j) == abs(P[i] - P[j])) { //在同一对角线上，斜率为+-1
					flag = false;
				}
			}
		}
		if(flag) cnt ++;
		return;
	}
	for(int x = 1; x <= n; x ++) {
		if(hashTable[x] == false) {
			P[index] = x;
			hashTable[x] = true;
			generateP(index + 1);
			hashTable[x] = false;
		}
	}
}

回溯法

void generateP(int index) {
	if(index == n + 1) {
		cnt ++; //能到达这里一定是合法的
		return;
	}
	for(int x = 1; x <= n; x ++) { //第x行
		if(hashTable[x] == false) {
			bool flag = true;
			for(int pre = 1; pre < index; pre ++) { //遍历之前的皇后
			//第index列皇后行号为x，**第pre列皇后的行号为P[pre]**
				if(abs(index - pre) == abs(x - P[pre])) {
					flag = false; //与之前的皇后在对角线上
					break;
				}				
			}
			if(flag) { //如果可以把皇后放在第x列
				P[index] = x;
				hashTable[x] = true; //令第x行已被占用
				generateP(index + 1); //递归处理第index + 1行皇后
				hashTable[x] = false;
			}
		}
	}
}

4.4 贪心

满足：最优子结构和贪心选择性质

4.4.1 区间贪心

区间不相交问题：给出N个开区间（x，y），从中选择尽可能多得开区间，且没有交集。
贪心策略：总是选择右端点最小的。或总是选择左端点最大的。

• B1020 月饼
  简单的贪心思想。需要注意的是，需要将变量类型处理正确，库存量，总售价，单价都可以用float表示。使用scanf读取时注意N和D的类型。

• A1033 To Fill or Not to Fill
  有点难度的贪心。
  贪心策略如下：
  （1）寻找距离当前加油站最近的油价低于当前油价的加油站k，加到加油站k。即优先前往更低油价的加油站。
  （2）若找不到更低油价，则寻找最低油价加油站k，在当前加油站加满油，然后前往加油站k。
  （3）如在满油状态都不能找到可达的加油站，则最远到当前加油站距离加上车辆最大行程，结束算法。

注意点：1、终点应放入数组最后，油价为0，距离为D。能到达终点才输出总油费。
2、如果第一个加油站距离不为0，则无法前进。
否则，遍历每个加油站，每次选出可到达的最便宜的加油站k，计算到k的油量。如果加油站k的最小油价低于当前油价，则到k，此时看当前油量，如足够直接前往k，若不够加到k的量；如果加油站k的油价高于当前油价，则在当前加油站加满，在前往k。
3、Cmax、D、Davg、油价、距离都可能是浮点型。

• A1037 Magic Coupon
  题意：求最大乘积和。
  技巧：将两个集合从小到大排序，负数绝对值大的就在左边，正数绝对值大的就在右边。从左遍历，将两负数的乘积累加，从右边遍历，将两正数的乘积累加，即为结果。

• A1067 Sort with Swap(0, i)
  题意很简单，用swap(0, i)完成0~N-1的排序，求出最少交换次数。大致可以想到用0和应该在0所在的位置的数交换，如果0交换到0位置时则找一个不在位的数交换。但是接下来就毫无思路了。看了题解，有几个重要的思路。
  该题的贪心策略为：用0和不在位的数字交换，已经在位的数字不能交换。 这个贪心策略很难想到这样是最少的交换次数。
  具体来说，如果0在0位上，则从左到右找到第一个不在位的数和0交换；当0不在0位上时，将0所在位置的数和0交换。用一个left记录除0外不在本位的数字个数，读入时计算其初值。
  技巧1： 用一个pos[100010]数组来存放每个读入数字的位置。 一般想到的第一次思路是用数组存入数字，而很少想到存入数字的位置。比较少见。
  技巧2：<algorithm>中有swap()函数。

• A1038 Recover the Smallest Number
  题意：给出若干可能有前导0的数字串，拼接一个最小的数。
  技巧：将a+b < b + a字典序小的数字串放前面。

bool cmp(string a, string b) {
	return a + b < b + a;
}

此题使用string比较方便（应善于利用string或stl）。按上述规则(比较难想到)排序，然后依次拼接并去除前导0即可。注意可能所有数字串均为0，此时结果输出0。

4.5 二分

4.5.1 二分查找与二分法拓展

• 二分的思想：寻找有序序列第一个满足某条件的元素的位置
  如：lower_bound, upper_bound

//[left, right], 初值必须能覆盖所有可能取值
int solve(int left, int right) {
	int mid;
	while(left < right) {
		mid = (left + right) / 2;
		if(条件成立) {
			right = mid;
		}
		else {
			left = mid + 1;
		}
	}
	return left;
}

或

//(left, right], 初值必须覆盖所有可能值，且left比最小取值小1
int solve(int left, int right) {
	int mid;
	while(left + 1 < right) {
		mid = (left + right) / 2;
		if(条件成立) {
			right = mid;
		}
		else {
			left = mid;
		}
	}
	return right;
}

如果要寻找最后一个满足条件C的位置，则可以先求第一个满足!C的位置，该位置减1即可。
如果目的是“序列中是否存在满足某条件的元素”，使用二分查找最合适。

4.5.2 快速幂

• 快速幂: 求 a^b % m
  如果b是奇数，那么a^b = a * a^b-1 ；
  如果b是偶数，那么a^b = a^b/2 * a^b/2 .

typedef long long LL;
LL binaryPow(LL a, LL b, LL m) {
	if(b == 0) return 1;
	if(b % 2 == 0) return a * binaryPow(a, b - 1, m) % m;
	else {
		LL mul = binaryPow(a, b / 2, m);
		return mul * mul % m;
	}
}

细节：（1）如果初始时a有可能 >= m, 那么需要在进入函数前就让a对m取模。
（2）如果m为1，可以直接外函数外部特判为0.

• 快速幂的迭代写法：

typedef long long LL;
LL binaryPow(LL a, LL b, LL m) {
	LL ans = 1;
	while(b > 0) {
		if(b & 1) {
			ans = ans * a % m;
		}
		a = a * a % m;
		b >>= 1;
	}
	return ans;
}

• B1030 完美数列
  关键点：能使选出的数个数最大的方案，一定是在该递增序列中选择连续若干个数的方案。
  问题转换：在一个给定递增序列中，确定一个左端点a[i]和一个右端点a[j]使得a[j] <= a[i] * p成立，且j - i最大。
  解法：二分的思想，查找第一个不满足条件（a[j] <= a[i] *p）的位置，即查找第一个>a[i]*p的位置，记录最大的j - i的值。（可采用upper_bound()函数）

	int ans = 1;
	for(int i = 0; i < n; i ++) {
//		int j = binarySearch(i, (long long)a[i] * p);
		int j = upper_bound(a + i + 1, a + n, (long long) a[i] * p) - a;
		ans = max(ans, j - i);
	}

binarySearch的实现：

//在[i + 1, n-1] 中查找第一个>x的数的位置 
int binarySearch(int i, long long x) {
	if(a[n - 1] <= x) return n;
	int l = i + 1, r = n - 1, mid;
	while(l < r) {
		mid = (l + r) / 2;
		if(a[mid] <= x) {
			l = mid + 1;
		} 
		else {
			r = mid;
		}
	}
	return l;//由于l==r，返回l或r都可 
} 

• A1010 Radix
  题意很简单，也很容易确定二分的思想为在进制上二分。但是二分的边界不容易确定。

技巧1：使用一个Map[256]将字符映射成数字。

LL Map[256];

void init() {
	for(char c = '0'; c <= '9'; c ++) {
		Map[c] = c - '0';
	}
	for(char c = 'a'; c <= 'z'; c ++) {
		Map[c] = c - 'a' + 10;
	}
}

技巧2：需要一个函数将数字串转换为10进制表示。

/*将radix进制下的n转换为10进制表示*/
LL radix2ten(char n[], int radix) {
	int len = strlen(n);
	LL res = 0, basis = 1;
	for(int i = 0; i < len; i ++) {
		int num = Map[n[len - i - 1]];
		res +=  num * basis;
		basis *= radix;
	}
	return res;
}

技巧3：二分搜索通常写成一个函数形式，方便利用其返回值，-1为未找到。此题中，将n转换为mid进制时，可能会溢出（结果为负数），因此溢出时肯定大于N1。

LL binaryFindRadix(LL left, LL right, char n[], LL N1) {
	while(left <= right) {
		LL mid = (left + right) / 2;
		LL t = radix2ten(n, mid);
		if(t < 0 || t > N1) right = mid - 1;
		else if(t == N1) return mid;
		else left = mid + 1;
	}
	return -1;
}

关键点：二分上下界的确定。
下界：待确定的数字串n中字面值最大的字符的数值+1。
上界：N1或下界中的较大者 + 1。

LL l = findLargestDigit(n);
LL r = max(N1, l) + 1; 
int ans = binaryFindRadix(l, r, n, N1);

• A1044 Shopping in Mars
  题意：找出连续子序列和为给定值M的子序列，若不恰好则给出和最接近M的子序列。暴力超时。
  想要二分解题，关键是寻找或构造有序序列。
  解这题的一个关键技巧为：将序列处理成累计和的和形式，即sum[i] = a[0] + a[1] +a[2] + … + a[i].
  这样就构造了一个递增序列，便可以使用二分的思想解题。
  “二分条件”为第一个>= (sum[i - 1] + M)的位置。即第一个满足和为M的子序列（sum[j] - sum[i] == M => sum[j] == sum[i] + M）。可以使用upper_bound()函数找到第一个不满足条件的位置（求右端点）。
  坑点：存在找不到等于M的情况，此时找到第一个和超过M的位置，即和最接近M，损失最小的位置。然后遍历数组，列出所有差值都为最小损失的位置。
  “二分边界”为i到N+ 1，（因为数组下标从1开始）
  关键代码：

int nearM = 100000010;
for(int i = 1; i <= N; i ++) {
	// sum[i - 1]为左端点， + M 后希望 = sum[j]（右端点），因此比较的是sum[i - 1] + M。
	int j = upper_bound(sum + i, sum + N + 1, sum[i - 1] + M) - sum;
	if(sum[j - 1] - sum[i - 1] == M) {
		nearM = M;
		break; 
	}
	else if(j <= N && sum[j] - sum[i - 1] < nearM) { //j为下一个位置
		nearM = sum[j] - sum[i - 1];
	}
}

for(int i = 1; i <= N; i ++) {
	int j = upper_bound(sum + i, sum + N + 1, sum[i - 1] + nearM) - sum;//求右端点
	if(sum[j - 1] - sum[i - 1] == nearM) {
		printf("%d-%d\n", i, j - 1);
	}
}

• A1048 Find Coins
  采用二分查找的方法。将数组排序。写一个二分查找的函数Bin。
  然后遍历数组，使用函数Bin查找m-a[i]的位置pos，如果pos != -1且pos != i,则找到，输出。

4.6 双指针(two-pointers)

有序序列，两个指针i,j。可以同向扫描也可相向扫描。

• mergeSort的非递归版

void mergeSort(int a[]) {
	for(int step = 2; step / 2 <= n; step *= 2) {
		for(int i = 0; i < n; i += step) {
			sort(a + i, a + min(i + step, n));
		}
		//此处可输出归并排序某一趟结束的序列
	}
}

• quickSort(): 快速排序，双指针，挖坑填空。

int Partition(int A[], int left, int right) {
	int p = round(1.0 * rand() / RAND_MAX * (right - left) + left);
	swap(A[p], A[left]);
	int temp = A[left];
	while(left < right) {
		while(left < right && A[right] > temp) right --;
		A[left] = A[right];
		while(left < right && A[left] <= temp) left ++;
		A[right] = A[left];
	}
	A[left] = temp; //temp放到left和right相遇的地方
	return left;
}
void quickSort(int A[], int left, int right) {
	if(left < right) { //当区间长度超过1
		int pos = Partition(A, left, right);
		quickSort(A, left, pos - 1);
		quickSort(A, pos + 1, right);
	}
}

• A1085 Perfect Sequence
  双指针的解法：用两个指针i,j,均初始为0。当i和j未到达n时遍历数组。j用来寻找第一个不满足a[j] <= a[i] * p的位置，并及时更新最大长度。然后i++，继续用j遍历。

int i = 0, j = 0, len = 1;
	while(i < n && j < n) {
		while(j < n && a[j] <= (long long) a[i] * p) {
			len = max(len, j - i + 1);
			j ++;
		}
		i ++;
	}

• B1035 插入与归并
  这题看上去比较少见，熟悉的知识不同的问法。需要输出插入排序和归并排序（非递归版）的中间结果。
  解题的关键技巧：
  设置三个数组，origin，tempOri, changed分别用于存放原始序列，用于排序中间过程，用于存放目标序列。
  先进行插入排序，在插入排序的过程中判断某一趟处理后的结果与目标序列是否相同，如果相同则返回。如果排序完都不同说明不是插入排序，此时将数组还原，使用归并排序。并输出归并排序的下一趟处理结果。
  需要一个判断两个序列是否相同的函数：

//判断两个数组是否相同 
bool isSame(int a[], int b[]) {
	for(int i = 0; i < n; i ++) {
		if(a[i] != b[i]) return false;
	}
	return true;
} 

插入排序的代码：

bool insertionSort() {
	bool flag = false;
	for(int i = 1; i < n; i ++) { //进行n-1趟排序 
		if(i != 1 && isSame(tempOri, changed)) {
			flag = true;
		}
		//插入部分 
		int temp = tempOri[i], j = i;
		while(j > 0 && tempOri[j - 1] > temp) {
			tempOri[j] = tempOri[j - 1];
			j --; 
		}
		tempOri[j] = temp;
		if(flag == true) {
			return true; //是目标序列 
		}
	}
	return false;
}

归并排序非递归版的代码：

void mergeSort() {
	bool flag = false;
	for(int step = 2; step / 2 <= n; step *= 2) {
		if(step != 2 && isSame(tempOri, changed)) {
			flag = true;
		}
		for(int i = 0; i < n; i += step) {
			sort(tempOri + i, tempOri + min(i + step, n));
		}
		if(flag == true) {
			showArray(tempOri);
			return;
		}
	}
} 

4.7 其他高效技巧与算法

• 打表
  空间换时间。
  （1）在程序中一次性计算出要用到的结果，之后的查询直接取这些结果。
  （2）在程序B中分一次或多次计算出所有需要的结果，手工吧结果写在程序A的数组中，然后在程序A中直接使用
  （3）先用暴力程序计算小范围数据结果，然后找规律。
• 活用递推
• 随机选择算法

int randPartition(int A[], int left, int right) {
	int p = round(1.0 * rand() / RAND_MAX * (right - left) + left);
	swap(A[left], A[p]);
	int temp = A[left];
	while(left < right) {
		while(left < right && A[right] > temp) right --;
		A[left] = A[right];
		while(left < right && A[left] < temp) left ++;
		A[right] = A[left];
	}
	A[left] = temp;//left和right相遇的位置
	return left;
}

void randSelect(int A[], int left, int right, int K) {
	if(left == right) return;
	int p = randPartition(A, left, right);
	int M = p - left + 1;
	if(K < M) {
		randSelect(A, left, p - 1, K);
	}
	else {
		randSelect(A, p + 1, right, K - M);
	}
}

• B1040 有几个PAT
  递推的思想。PAT的个数等于每个A左边P的个数*右边T的个数加起来。
  技巧：一钟较快获得每一位左边的P的个数方法：
  从左到右遍历字符串，如果当前位i是P中则leftNumP[i] = leftNumP[i - 1] + 1; 否则leftNumP[i] = leftNumP[i - 1]。
  rightNumT同理可求。

for(int i = len - 1; i >= 0; i --) {
		if(str[i] == 'T') {
			rightNumT ++;
		}
		else if(str[i] == 'A') {
			ans = (ans +leftNumP[i] * rightNumT) % MOD;
		}
	}

• B1045 快速排序
  题意：判断有几个元素可以作为快速排序的划分基准。
  暴力超时。
  思路：需要记录一个数左边的最大值和右边的最小值，当这个数比左边的最大值都大且比右边的最小值都小，则可以作为基准。
  技巧：用一个leftMax[maxn]来记录对应每个数a[i]的左边最大值，用rightMin[maxn]来记录a[i]的右边最小值。从左到右遍历数组，a[i]的leftMax[i] = max(leftMax[i - 1], a[i - 1])；从右到左遍历数组，a[i]的rightMin[i] = min(rightMin[i + 1], a[i + 1])。

leftMax[0] = 0;
for(int i = 1; i < n; i ++) {
	if(a[i - 1] > leftMax[i - 1])
		leftMax[i] = a[i - 1]; 
	else
		leftMax[i] = leftMax[i - 1];
}
rightMin[n - 1] = 1000000010;
for(int i = n - 2; i >= 0; i --) {
	if(a[i + 1] < rightMin[i + 1])
		rightMin[i] = a[i + 1];
	else	
		rightMin[i] = rightMin[i + 1];
}

5 数学问题

5.1 简单数学

• B1003 我要通过!
  遇到无从下手的题目，考虑可能是数学问题。本题就是找一个数学规律。
  最终找到的规律是：从PAT开始，要么两边同时增加A，如果中间增加一个A，则末尾复制一遍开头。
  最终的数学公式为（令P左边的A的个数为x，中间的A的个数为y，右边的A的个数为z）：z == x * y。
  除此之外要满足只能出现一次P和T，不能出现除PAT以外的字母。

• B1049 数列的片段和
  盲猜暴力超时，需要找规律。最终找到每个数的系数为i*(i - n + 1)。
  结果出了精度问题，后两个测试点不过。第一，我一开始将这个系数加括号先算，由于N=10⁵ 那么存在中间50000 * 50000的情况结果超过20亿（int 的范围），换成long long 还是不行。后来想到每个数小于1.0，先乘后面的反而更大，于是去掉括号，过来样例4，3还是过不了。
  看博客才知道，可能是double超范围了。（因为int 乘 double 会转为double计算，所以不存在精度丢失的问题）。于是吧double换成long double, i还是int，过了。（第一次知道还有long double类型）。

int main() {
	int n;
	scanf("%d", &n);
	long double a, sum = 0;
	for(int i = 1; i <= n; i ++) {
		scanf("%llf", &a);
		sum += a * i * (n - i + 1);
	}
	printf("%.2llf\n", sum);
	return 0;
} 

感想：找规律题，往往还有数据范围和精度的坑。

• A1008 Elevator
  找规律题。但一开始看错了输入格式，浪费一些时间。提醒：题目和输入格式要看仔细，发现问题时要耐心重新读一遍题目。

• A1049 Counting Ones
  这题数学规律很难找。看了题解思路。从低位到高位编号1-n号位。
  考虑每一位在1~n的过程中，在该位可能出现的1的个数
  代码如下：

int main() {
	int n;
	scanf("%d", &n);
	int a = 1, ans = 0;
	int left, now, right; 
	while(n / a != 0) {
		left = n / (a * 10);
		now = n / a % 10;
		right = n % a;
		
		if(now == 0) ans += left * a;//left0000
		else if(now == 1) ans += left * a + right + 1; //0~right
		else ans += (left + 1) * a;
		a *= 10; //遍历每一位 
	}
	printf("%d", ans);
	return 0;
}

其中值得记录的技巧有：
（1）对一个数，可以用循环获得其当前位：now = n / a % 10;
（2）获得其高位表示的数字：left = n / (a * 10);
（3）获得其低位表示的数字：right = n % a;
其中a可以看作位的权值，循环过程中从1开始不断*10，相当于遍历每一位。

接下来统计1的个数：
（1）当now == 0时，为( left: 0~(left - 1) ) * ( a: 0 ~ 999… ),即小于高位代表的数left的所有数，对应now=1,右边right可以是任意0到999…的全体。
（2）当now == 1时，ans += left * a + right + 1。即比上一种情况多了right+1个数。
（3）当now>=2时，ans += (left + 1) * a。即now可以为1了。

5.2 最大公约数与最小公倍数

• B1008 数组元素循环
  有点难理解，挖空移动法。

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	for(int i = 0; i < n; i ++)
		scanf("%d", &a[i]);
	m = m % n;
	if(m != 0) {
		int d = gcd(m, n);
		for(int i = n - m; i < n - m + d; i ++) {
			int temp = a[i];
			int pos = i;
			do {
				int next = (pos + n - m) % n;//相当于(pos-m) % n但为保证它是正的。 
				if(next != i) a[pos] = a[next];
				else a[pos] = temp;
				pos = next;
			}while(pos != i);
		}
	}
	for(int i = 0; i < n; i ++) {
		printf("%d", a[i]);
		if(i < n - 1) printf(" ");
	}
	return 0;
} 

题目中虽然给出了很多限制，例如不允许使用另外的数组、又要考虑移动数据的次数最少，但实际上却只测试循环右移之后得到的结果而不管过程。对于这种题目，考生其实可以不用管题目中那些限制，直接输出答案即可。

5.3 分数的四则运算

模板：

1. 分数的表示

typedef long long LL;
LL gcd(LL a, LL b) {
	if(b == 0) return a;
	else return gcd(b, a % b);
}
struct Fraction {
	LL up, down;
};

2. 分数的化简
   约定：使得down为非负数。使得up=0时，down=1，

Fraction reduction(Fraction result) {
	if(result.down < 0) {
		result.up = -result.up;
		result.down = -result.down;
	}
	if(result.up == 0) {
		result.down = 1;
	}
	else {
		int d = gcd(abs(result.up), abs(result.down));
		result.up /= d;
		result.down /= d;
	}
	return result;
}

4. 分数的四则运算

Fraction add(Fraction a, Fraction b) {
	Fraction result;
	result.up = a.up * b.down + b.up * a.down;
	result.down = a.down * b.down;
	return reduction(result);
}

Fraction minu(Fraction a, Fraction b) {
	Fraction result;
	result.up = a.up * b.down - b.up * a.down;
	result.down = a.down * b.down;
	return reduction(result);
}

Fraction multi(Fraction f1, Fraction f2) {
	Fraction res;
	res.up = f1.up * f2.up;
	res.down = f1.down * f2.down;
	return reduction(res);
}

//除数为0(f2.up == 0)应特判 
Fraction divide(Fraction f1, Fraction f2) {
	Fraction res;
	res.up = f1.up * f2.down;
	res.down = f1.down * f2.up;
	return reduction(res); 
}

4. 分数的输出

void showResult(Fraction r) {
	r = reduction(r);
	if(r.down == 1) printf("%lld", r.up);
	else if(abs(r.up) > r.down) {
		printf("%lld %lld/%lld", r.up / r.down, abs(r.up) % r.down, r.down);
	}
	else {
		printf("%lld/%lld", r.up, r.down);
	}
	printf("\n");
} 

• A1081 Rational Sum
  分数和。

Fraction sum, temp;
sum.up = 0;
sum.down = 1;
for(int i = 0; i < n; i ++) {
	scanf("%lld/%lld", &temp.up, &temp.down);
	sum = add(sum, temp);
}
showResult(sum);

• B1034 有理数四则运算
  用分数四则运算的板子。
  需要特判除法的除数为0的情况。输出为负数时带括号。

5.4 素数

5.4.1 素数的判断

bool isPrime(int n) {
	if(n <= 1) return false; //这句很重要，容易忘。
	for(int i = 2; i * i <= n; i ++) { //注意是等于
		if(n % i == 0)
			return false;
	}
	return true;
}

当n接近int的上界时，i*i可能溢出，解决办法是用long long。

5.4.2 素数表的获取

O(n \sqrt(n)):

const int maxn = 101;
int prime[maxn], pNum = 0;
bool p[maxn] = {0};
void Find_prime() {
	for(int i = 1; i < maxn; i ++) {
		if(isPrime(i) == true) {
			prime[pNum ++] = i;
			p[i] = true;
		}
	}
}

O(nloglogn): 埃氏筛法
素数筛法：

const int maxn = 101;
int prime[maxn], pNum = 0;
bool p[maxn];//false表示素数，true表示筛掉。
void Find_prime() {
	for(int i = 2; i < maxn; i ++) {
		if(p[i] == false) {
			prime[pNum ++] = i;
			for(int j = i + i; j < maxn; j += i) {
				p[j] = true;
			}
		}
	}
}

• B1013 数素数
  使用板子findPrime()。可以加一个参数n，findPrime(n)，用于当pNum>n时中止循环。
  由于不知道第10⁴ 个素数有多大，需要把maxn设大一点，否则会越界。

findPrime(n);
	for(int i = m; i <= n; i ++) {
		if((i - m) % 10 != 0)
			printf(" ");
		else if(i != m)
			printf("\n");
		printf("%d", prime[i - 1]);
	}

• A1015 Reversible Primes
  题意：先判断十进制的N是否素数，在判断将D进制下的N逆转后的十进制数是否是素数。
  重要技巧，十进制转D进制逆转后转十进制：

int len = 0;
while(N != 0) {
	rev[len ++] =  N % D;
	N /= D;
}
for(int i = 0; i < len; i ++) {
	N = N * D + rev[i];
}

• A1078 Hashing
  hash, 使用二次探测解决冲突。注意题中只考虑正的增量。即a+1², a+2²,a+3²,…

Quadratic probing (with positive increments only)

hashTable[maxn],存放过的位置为TRUE，未存放的位置为FALSE。
技巧1：寻找大于某个数的质数的最简单方法。

while(isPrime(TSize) == false)
		TSize ++;

技巧2：二次探测(只考虑正增量)解决哈希冲突，当step >= TSize时表示哈希表已满。

int step;
for(step = 1; step < TSize; step ++) {
	M = (a + step * step) % TSize;
	if(hashTable[M] == false) {
		hashTable[M] = true;
		if(i == 0) printf("%d", M);
		else printf(" %d", M);
		break;
	}
}
if(step >= TSize) {
	if(i > 0) printf(" ");
	printf("-");
}

5.5 质因子分解

首先获得素数表
结构体factor

struct factor {
	int x, cnt;//x为质因子，cnt为其个数
}fac[10];

考虑到2*3*5*7*11*13*17*19*23*29就超过int的范围了，因此fac数组开到10就可以了。
对一个正整数来说，如果存在1和本身之外的因子，一定在sqrt(n)左右成对出现。
强化结论： 对一个正整数n来说，如果存在[2，n]范围内的质因子，要么这些质因子全部<=sqrt(n); 要么只存在一个>sqrt(n)的质因子，而其余质因子均<=sqrt(n)。

质因子分解的思路
（1）枚举1~sqrt(n)内的所有质因子p，判断p是否是n的因子。
如果p是n的因子，fac数组增加质因子p，初始化个数为0，只要p还是n的因子就让n不断除以p，每次p+1，直到p不在是n的因子为止。

if(n % prime[i] == 0) {
	fac[num].x = prime[i];
	fac[num].cnt = 0;
	while(n % prime[i] == 0) {
		fac[num].cnt ++;
		n /= prime[i];
	}
	num ++;
}

如果p不是n的因子直接跳过。
（2）如果上述步骤后n仍>1，说明n有且仅有一个>sqrt(n)的质因子（可能是n本身），这时需要把这个质因子加入fac数组，并令其个数为1。

if(n != 1) {
	fac[num].x = n;
	fac[num ++].cnt = 1;
}

求正整数N的因子个数：质因子分解，得到各质因数的个数，因子个数为(e₁ + 1) * (e₂+ 1) * (e₃ + 1) * … * (e_k + 1)。

N的所有因子之和:

• A1096 Consecutive Factors
  题意：给出一个int范围的整数n，找出一段连续的整数成绩作为n的因子，求个数最多的整数序列，输出最小的序列。
  N不会被除自己以外的>sqrt(N)的整数整除。
  核心代码：

LL ans = 0, len = 0;
for(LL i = 2; i * i <= n; i ++) {
	LL temp = 1, j = i;
	while(1) {
		temp *= j;
		if(n % temp != 0) break;
		if(j - i + 1 > len) {
			ans = i;
			len = j - i + 1;
		}
		j ++;
	}
}

• A1059 Prime Factors
  注意特判n=1的情况。
  完整代码：

#include<cstdio>
#include<cmath>
const int maxn = 50000;
int prime[maxn], pNum = 0;
bool p[maxn] = {0};

void findPrime() {
	for(int i = 2; i < maxn; i ++) {
		if(p[i] == false) {
			prime[pNum ++] = i;
			for(int j = i + i; j < maxn; j += i)
				p[i] = true;
		}
	}
}

struct factor {
	int x, cnt;
}fac[10];

int main() {
	findPrime();
	int n, n0, num;
	scanf("%d", &n);
	if(n == 1) printf("1=1");
	else printf("%d=", n);
	int sqr = (int)sqrt(1.0*n);
	for(int i = 0; i < pNum && prime[i] <= sqr; i ++) {
		if(n % prime[i] == 0) {
			fac[num].x = prime[i];
			fac[num].cnt = 0;
			while(n % prime[i] == 0) {
				fac[num].cnt ++;
				n /= prime[i];
			}
			num ++;
		}
		if(n == 1) break; //及时退出循环，节省时间。
	}
	if(n != 1) {
		fac[num].x = n;
		fac[num ++].cnt = 1;
	}
	for(int i = 0; i < num; i ++) {
		if(fac[i].cnt > 0) {
			if(i > 0) printf("*");
			printf("%d", fac[i].x);
			if(fac[i].cnt > 1)
				printf("^%d", fac[i].cnt);
		}
	}
	return 0;
}

5.6 大整数运算

5.6.1 大整数的存储

整数的高位存在数组的高位，整数的低位存在数组的低位。读入后需要在另存为至d[]数组时反转一下。

struct bign {
	int d[1000];
	int len;
	bign() {
		memset(d, 0, sizeof(d));
		len = 0;
	}
};

输入大整数时，先用字符串读入，然后把字符串另存为至bign结构体。由于char数组读入时，整数的高位会变成数组的低位，因此位了让整数在bign中时顺位存储，需要让字符串倒着赋给d。

bign change(char str[]) {
	bign a;
	a.len = strlen(str);
	for(int i = 0; i < a.len; i ++) {
		a.d[i] = str[a.len - i - 1] - '0';
	}
	return a;
}

比较bign的大小

int compare(bign a, bign b) {
	if(a.len > b.len) return 1;
	else if(a.len < b.len) return -1;
	else {
		for(int i = a.len - 1; i >= 0; i --) {
			if(a.d[i] > b.d[i]) return 1;
			else if(a.d[i] < b.d[i]) return -1;
		}
		return 0;
	}
}

打印大整数

void print(bign a) {
	for(int i = a.len - 1; i >= 0; i --)
		printf("%d", a.d[i]);
}

5.6.2 大整数四则运算

高精度加法

bign add(bign a, bign b) {
	bign c;
	int carry = 0;
	for(int i = 0; i < a.len || i < b.len; i ++) {
		int temp = a.d[i] + b.d[i] + carry;
		c.d[c.len ++] = temp % 10;
		carry = temp / 10;
	}
	if(carry != 0) {
		c.d[c.len ++] = carry;
	}
	return c;
}

高精度减法

bign sub(bign a, bign b) {
	bign c;
	for(int i = 0; i < a.len || i < b.len; i ++) {
		if(a.d[i] < b.d[i]) {
			a.d[i + 1] --;
			a.d[i] += 10;
		}
		c.d[c.len ++] = a.d[i] - b.d[i];
	}
	while(c.len - 1 >= 1 && c.d[len - 1] == 0) {
		c.len --;
	}
	return c;
}

使用sub函数前需要比较两个数的大小，只能大的减小的。

高精度与低精度乘法

bign multi(bign a, int b) {
	bign c;
	int carry = 0;
	for(int i = 0; i < a.len; i ++) {
		int temp = a.d[i] * b + carry;
		c.d[c.len ++] = temp % 10;
		carry = temp / 10;
	}
	while(carry != 0) {
		c.d[c.len ++] = carry % 10;
		carry /= 10;
	}
	return c;
}

b为int输入即可。如果a和b中存在负数，需先记下负号，然后取绝对值代入函数。

高精度与低精度除法

bign divide(bign a, int b, int& r) {
	bign c;
	c.len = a.len;
	for(int i = a.len - 1; i >= 0; i --) {
		r = r * 10 + a.d[i];
		if(r < b) c.d[i] = 0;
		else {
			c.d[i] = r / b;
			r = r % b;
		}
	}
	while(c.len - 1 >= 1 && c.d[c.len - 1] == 0) {
		c.len --;
	}
	return c;
}

• B1017 A除以B
  套模板即可。

• A1023 Have Fun with Numbers
  注意点1：数组至少开21而不是20
  技巧：用hash的方法判断是否是置换。

• A1024 Palindromic Number
  可能有100个10位数相加，因此使用大整数，数组开到1001。（一开始我开小了会有样例报错）
  在大整数模板下，增加reverse()和判断是否回文isPalindromic()。

5.7 扩展欧几里得算法

int exGcd(int a, int b, int & x, int & y) {
	if(b == 0) {
		x = 1;
		y = 0;
		return a;
	}
	int g =exGcd(b, a % b, x, y);
	int temp = x;
	x = y;
	y = temp - a / b * y;
	return g;
}

5.8 组合数

5.8.1 关于n!的一个问题

n!中(n / p + n / p² + n / p³ + …)个质因子p。

int cal(int n, int p) {
	int ans = 0;
	while(n) {
		ans += n / p;
		n /= p;
	}
	return n;
}

利用这个算法，可以很快计算出n!末尾有多少个0：末尾0的个数等于n!中因子10的个数=n!中质因子5的个数。因子只需代入cal(n, 5)即可。

n！中质因子p的个数实际上等于1~n中p的倍数的个数n/p加上(n/p)!中质因子p的个数
由此得到递归版本：

int cal(int n, int p) {
	if(n < p) return 0;
	return n / p + cal(n / p, p);
}

5.8.2 组合数的计算

1. C(n, m) = n! / (m! (n - m)!)
2. C(n, m) = C(n, n - m)
3. C(n, 0) = C(n, m) = 1。
   1. 如何计算C(n, m)
   （1）按定义计算：但21！超过long long范围
   （2）通过递推公式计算：C(n, m) = C(n - 1, m) + C(n - 1, m - 1)。复杂度O(n²)

long long C(long long n, long long m) {
	if(m == 0 || m == n) return 1;
	return C(n - 1, m) + C(n - 1, m - 1);
}

上述方法存在重复计算。可以记录计算过的C(n, m)。递归代码

long long res[67][67] = {0};
long long C(long long n, long long m) {
	if(m == 0 || m == n) return 1;
	if(res[n][m] != 0) return res[n][m];
	return res[n][m] = C(n - 1, m) + C(n - 1, m - 1);
}

或是把整张表都计算出来的递推代码。

const int n = 60;
void calC() {
	for(int i = 0; i <= n; i ++) {
		res[i][0] = res[i][i] = 1;
	}
	for(int i = 2; i <= n; i ++) {
		for(int j = 0; j <= i / 2; j ++) {
			res[i][j] = res[i - 1][j] + res[i - 1][j - 1];
			res[i][j - 1] = res[i][j]; //C(i, i - j) = C(i, j)
		}
	}
}

（3）通过定义式的变形来计算： 复杂度O(m)
C(n, m) = (n - m + 1) * (n - m + 2) * … * (n - m + m) / (1 * 2 * …* m)
边乘边除避免乘法越界：
C(n, m) = (n - m + 1) / 1 * (n - m + 2) / 2 * … / … * (n - m + m) / m

long long C(long long n, long long m) {
	long long ans = 1;
	for(long long i = 1; i <= m; i ++) {
		ans = ans * (n - m + i) / i;//注意需先乘后除
	}
	return ans;
}

2. 如何计算C(n, m) % p
（1）法一：递推公式计算
支持m <= n <= 1000， 对p的大小（p<=10⁹）和素性无要求
递归：

int res[1010][1010] = {0}; 
int C(int n, int m, int p) {
	if(m == 0 || m == n) return 1;
	if(res[n][m] != 0) return res[n][m];
	return res[n][m] = (C(n - 1, m) + C(n - 1, m - 1)) % p;
}

递推：

void calC() {
	for(int i = 0; i <= n; i ++) {
		res[i][0] = res[i][i] = 1;
	}
	for(int i = 2; i <= n; i ++) {
		res[i][j] = (res[i - 1][j] + res[i - 1][j - 1]) % p;
		res[i][i - j] = res[i][j]; //C(i, i - j) = C(i, j)
	}
}

（2）根据定义计算*
对C(n, m)进行质因子分解，用快速幂计算每一组p_i^ci % p。

int prime[maxn]; //筛法得到素数表

int C(int n, int m, int p) {
	int ans = 1;
	for(int i = 0; prime[i] <= n; i ++) {
		int c = cal(n, prime[i]) - cal(m, prime[i]) - cal(n - m, prime[i]);
		ans = ans * binaryPow(prime[i], c, p) % p;
	}
	return ans;
}

（3）根据定义式的变形计算
（4）Lucas定理

6 STL

6.1 vector

变长数组、以邻接表形式存储图。

• 定义
  定义vector：vector<int> name;
  定义vector数组：vector<int> vi[100];
• 访问
  下标访问：vi[0]
  迭代器访问：vector<double>::iterator it; printf("%llf", *it);
  v[i]和*(vi.begin() + i)等价
  迭代：

for(vector<int>::iterator it = vi.begin(); it != vector.end(); it ++) {
	printf("%d ", *it);
}

STL中，只有vector和string支持vi.begin() + i的写法。

• 常用函数
  push_back(): O(1)
  pop_back(): O(1)
  size(): O(1), 返回unsigned类型，可以用%d。
  clear(): O(n), 清空所有元素。
  insert(it, x): O(n)，在it处插入x。
  erase(it)、erase(first, last): O(n)，删除it处元素、删除[first, last)内元素。

• 常见用途

1. 存储数据:
   （1）元素个数不确定时的数组
   （2）有些场合需根据一些条件吧部分数据输出在同一行。由于输出数据个数不确定，为更方便处理最 后一个满足条件的数据后面不输出额外空格，课先用vector记录，后一次性输出。
2. 用邻接表存储图

• A1039 Course List for Student
  利用vector数组和字符串哈希的思想。将姓名映射成一个整数，作为键值。同时还可以用vector数组当成哈希表，键值为姓名，每个姓名修的课程号可以放进去构成数组。

const int maxn = 26 * 26 * 26 * 10 + 1;
vector<int> vi[maxn]; //vector哈希表
//字符串hash
int hashFunc(char str[]) {
	int len = strlen(str);
	int id = 0;
	for(int i = 0; i < len - 1; i ++) {
		id = id * 26 + str[i] - 'A';
	}
	id = id * 10 + str[len - 1] - '0';
	return id;
}

vi[hashFunc(str)].push_back(cid);

for(int i = 0; i < vi[key].size(); i ++)
	printf(" %d", vi[key][i]);

• A1047 Student List for Course
  构造一个结构体str。用来存放字符串name。然后可以放进vector中排序。
  另一种方法是用一个字符数组存储学生编号对应的姓名，vector中只存放学生编号。最后按学生编号输出姓名。

6.2 set

set是一个内部自动有序且不含重复元素的集合。

• 定义
  定义set：set<char> name;
  定义set数组: set<int> a[100];

• 访问
  只能迭代器访问：set<int>::iterator it; printf("%d", *it);
  只能迭代器遍历。

• 常用函数
  insert(x): O(logN)， 插入的x是元素，而不是迭代器。
  find(value): O(logN)，返回set中值为value的迭代器。
  erase(it): O(1), 删除单个元素、erase(value): O(logN), 删除值为value的元素
  erase(first, end): O(last - first), 删除区间元素。
  size(): O(1)
  clear(): O(N)

• 常见用途
  自动去重并按升序排序。
  set中元素唯一，需处理不唯一情况用multiset或unordered_set(c++11)。

• A1063
  求集合的相似度。
  算法：集合a的size + 集合b的size - 并集c的size / 并集c的size.

技巧1：
abs()和fabs()的区别
区别一：用法不同

1、abs()是对整数取绝对值

2、fabs()是对浮点数取绝对值

区别二：函数原型不同

1、abs的函数原型为：int abs(int x)

2、fabs的函数原型为：double fabs(double x)

区别三：头文件不同

1、abs(): #include <stdlib.h>

2、fabs(): #include <math.h>

技巧2：set_union()的用法

set_union(s[q1].begin(), s[q1].end(), s[q2].begin(), s[q2].end(), std::inserter(u, u.begin()));

我测试出来，使用set_union求并集似乎比先复制一个集合a，在将集合b中元素插入的方法慢一些（会超时）。

技巧3：复制一个set的方法

set<int> c = a; //a是一个set<int>
set<int> c(a);

6.3 string

• 定义
  string str;
string str = 'abcd';

• 访问
  下标访问：str[i];
  读入和输出整个字符串只能用cin和cout。
  printf输出printf("%s", str.c_str());
  迭代器访问：string::iterator it; printf("%c", *it);
  string和vector支持对迭代器加减某个数字。

• 常用函数
  +=
比较运算符
length()、size() ：O(1)
  insert(pos, string)、 insert(it, it2, it3) : O(N), 在pos位置插入string，在it位置插入it2到it3之间字符串。
  erase(it)、erase(first, last)、erase(pos, len) : O(N)
  clear(): O(1)
  substr(pos, len): O(len), 返回从pos位开始，长度为len的子串。
  string::npos: -1, 或unsigned_int最大值，作为find()失配时的返回值。
  find(str2)、find(str2m pos) : (从pos开始)匹配str2。O(nm)
  str.replace(pos, len, str2)、str.replace(it1, it2, str2): 把str从pos开始，长度为len（或[it1, it2)范围内）的子串替换成str2。

• 1060 Are They Equal
  此题涉及字符串处理，较为繁琐。
  需要考虑数据的特征。
  科学计数法的格式0.a₁a₂a₃…* 10^e 。有两部分组成：本体部分a₁a₂a₃与指数e。
  考虑数据本身：可以按整数部分是否为0分情况讨论：
  （1）0.a₁a₂a₃…
  （2）b₁b₂…b_m.a₁a₂a₃…
  本题的一个坑点：数据可能存在前导0。因此先去除前导0。
  去除前导0之后如果s[0] == '.'的话，则属于第一种情况(<1)，于是删除小数点，删除小数点后面可能存在的前导0（同时记录指数e），直至遇到非0的前n位，即为本体部分。
  如果s[0] != '.'则属于第二种情况(>1),因此找到小数点的位置，记录指数e,并删除小数点。
  上述处理过后，如果s的长度变为0，说明它本身是0。否则获取指定精度n的本体部分，即处理后的s的前n位；当精度n>s.len时补0。

总结：看上去较为复杂的字符串处理题，应仔细分析数据的特点，分类完成处理。

6.4 map

映射，可以将任何基本类型（包括STL容器）映射到任何基本类型（包括STL容器）。

• 定义
  map<string, int> mp;
  字符串到整形的映射必须用string而不能用char数组。
  map<set<int>, string> mp;

• 访问
  下标访问：mp['c']
  迭代器访问：map<char, int>::iterator it; printf("%c %d", it -> first, it -> second);
  map会以键从小到大自动排序。 map可以用it -> frist访问键，it->second访问值。
  map和set内部是红黑树实现的。

• 常用函数
  find(key): O(logN), 返回键为key的映射的迭代器。
  erase(it): O(1), 删除单个元素。
  erase(key): O(logN), 删除键为key的元素。
  erase(first, end) : O(last-first)
  size(): O(1)
  clear(): O(N)

• 常见用途
  （1）建立字符或字符串与整数直接的映射。
  （2）判断大整数或者其他类型数据是否存在，可以把map当成bool数组用。
  （3）字符串和字符串的映射。
  map的键和值是唯一的，如果一个键需要对应多个值，就只能用multimap（unordered_map）。

• B1044 火星数字
  用一个map将火星文和数字的映射存储起来。
  本题的注意点：由于数据范围只有169 （13²）,因此直接n / 13和n % 13就能获得13进制高低位。
  字符串读取需要用getline(cin, str)读取一行。如果是火星文则转数字。如果是数字，则遍历map，找到对应的火星文（it->first）。其中string转int可以用stoi()。
  坑点：13是tam，而不是tam tret。13的倍数不显示末尾的0（tret）。

题解中还使用了string数字作为数字到火星文的映射，可以降低查询的复杂度。
题解的打表方法比我的少了一个平方。

void init() {
	for(int i = 0; i < 13; i ++) {
		numToStr[i] = unitDigit[i]; //个位为[0, 12],十位为0
		strToNum[unitDigit[i]] = i;
		numToStr[i * 13] = tenDigit[i]; //十位为[0, 12], 个位为0
		strToNum[tenDigit[i]] = i * 13;
	}
	for(int i = 1; i < 13; i ++) { //十位
		for(int j = 1; j < 13; j ++) { //个位
			string str = tenDigit[i] + " " + unitDigit[j];
			numToStr[i * 13 + j] = str;
			strToNum[str] = i * 13 + j;
		}
	}
}

• A1054 The Dominant Color
  我是用string存储数字的，建立一个string到int的map，然后求出最大值即可。
  看了题解发现直接用了int到int的映射。才发现范围是2²⁴(16 777 216)，而不是24位。

• A1071 Speech Patterns
  题意：分割字符串，统计词频。分隔符为非字母数字字符。
  解法：stringstream分割字符串，cctype判断字符属性，map计数。
  坑点：一开始我直接将一行按空格(默认)分割然后对分割的单词去标点符号转小写，但是样例3过不了。后来终于找到一个反例：can?can这样两个单词本应分开，但是按照上述分割只能变成cancan。

正确的解题技巧：读入一行字符串后立即将里面的标点符号替换成空格，然后再用stringstream分割。

技巧1：stringstream分割字符串。

string str, temp;
getline(cin, str);
istringstream strin(str);
	while(strin >> temp) {
		vocab[temp] ++;
	}

技巧2：cctype判断字符函数：
bool isalnum(char):判断字母数字
char tolower(char):转小写, 非原地操作。
string.erase()是原地操作。

• A1022 Digital Library
  看到题，第一反应是建立5个map<string, vector<int> >的映射。但是发现要求按id的升序输出。想到可以用set<int>, set是自动排序的且默认升序。
  于是建立数据结构map<string, set<int> > lib[5];
  接下来只需要读入每行字符串，把id存入对应的映射中即可。后面查询时直接输出string对应的set里面的所有元素即可。其中keywords一行有多个keyword，可以用stringstream分割。

写完代码后发现输入不正确。最终发现了一个重要的坑。
使用getline()读行之前如果出现过cin或scanf，一定要把最后一个回车换行用getchar()给吞掉，不然输入会出错。
原因：getline()和cin()的区别：getline遇到换行符为止(不包括换行符，但会丢弃换行符)，cin遇到空白符为止(不包括空白符，不丢弃换行符)。。因此需要用getchar()吞掉换行符，不然下一次读取就是空(\n)。

坑点2：为了图方便，id用int存储，结果最后两个样例错误。因为可能存在0001234这样的情况。因此输出用printf("%07d\n", *(it));。

本题输出部分的代码：

cout << query << endl; 
int num = query[0] - '0';
if(lib[num - 1][query.substr(3)].empty()) cout << "Not Found" << endl;
else {
	for(auto it = lib[num - 1][query.substr(3)].begin(); it != lib[num - 1][query.substr(3)].end(); it ++) {
		printf("%07d\n", *(it));
	}
}

6.5 queue

先进先出。

• 定义
  queue<int> q
• 访问：只能访问队首和队尾
  front(): 队首
  back(): 队尾
• 常用函数
  push(x): O(1), 入队
  pop(): O(1) 队首元素出队
  front()、back(): 获得队首队尾元素，O(1)
  empty(): O(1)
  size(): O(1)
• 常见用途
  （1）用于广度优先搜索BFS
  使用front()和back()需用empty()判空，否则可能因为队空出错。
  此外还有deque双端队列，priority_queue优先队列。

6.6 priority_queue

优先队列。队首元素一定是当前队列中优先级最高的那一个。
底层数据结构为堆。

• 定义
  priority_queue<int> q;
• 访问
  top(): 访问队首（堆顶）
• 常用函数
  push(x) : 入队， O(logN)
  top(): 获得队首元素，O(1)
  pop(): 队首出队，O(logN)
  empty(): O(1)
  size(): O(1)
• 优先级设置
  （1）基本类型优先级设置
  默认定义等价于priority_queue<int, vector<int>, less<int> > q;（大碓顶）
  小堆顶：priority_queue<int, vector<int>, greater<int> > q;
  （2）结构体优先级设置
  法一

struct fruit {
	string name;
	int price;
	friend bool operator < (fruit f1, fruit f2) {
		return f1.price > f2.price;
	}
};

法二

struct cmp {
	bool operator () (fruit f1, fruit f2) {
		return f1.price > f2.price;
	}
};
priority_queue<int, vector<int>, cmp> q;

如果结构体内数据庞大，如出现了字符串或数组，建议使用引用提高效率。此时需要加上const和&。

• 常见用途
  解决一些贪心问题。也可以对Dijkstra算法进行优化（因为优先队列的本质是堆）。
  注意使用top()要先判空。

6.7 stack

栈，后进先出。

• 定义
  stack<int> st;
• 访问
  top(): 只能访问栈顶。
• 常用函数
  push(x): O(1),压栈
  top(): 获得栈顶元素。O(1)
  pop(): O(1), 出栈
  empty(): O(1)
  size(): O(1)
• 常见用途
  （1）模拟实现一些递归，防止程序对栈内存限制而出错。

6.8 pair

需要#include<utility>将两个元素绑在一起，又不想定义结构体。等同于：

struct pair {
	typename1 first;
	typename2 second;
}

• 定义
  pair<string, int> p;
  想要在代码中临时构建一个pair：
  （1）pair<string, int> ("haha", 5)
  （2）make_pair("haha", 5)
• 访问（像结构体一样）
  p.first
p.second
• 常用函数
  比较运算符: 先比较first，在比较second。
• 常见用途
  （1）用来代替二元结构体及其构造函数，节省编码时间
  （2）作为map的键值对来进行插入

map<string, int> mp;
mp.insert(make_pair("hehe", 5));
mp.insert(pair<string, int> ("haha", 5));

6.9 algorithm

6.9.1 max()、min()、abs()

支持max(x, max(y, z))的写法。abs(x)要求x必须是整数。浮点数请用fabs()。

6.9.2 swap()

swap(x, y)交换x和y。

6.9.3 reverse()

reverse(it1, it2)反转[it1, it2)

6.9.4 next_permutation

给出一个序列在全排列中的下一个序列。

int a[10] = {1, 2, 3};
do {
	printf("%d%d%d\n", a[0], a[1], a[2]);
}while(next_permutation(a, a + 3));

6.9.5 fill()

把数组或容器中某一段区间赋值为某个相同的值。和memset不同，这里的赋值可以是数组类型对应范围中的任意值。
fill(a, a + 5, 233 );

6.9.6 sort()

快速排序。

6.9.7 lower_bound()、upper_bound()

用在一个有序数组或容器中。
lower_bound(first, last, val) 用于寻找序列中第一个值 >= val的位置。（下界）
upper_bound(first, last, val)用于寻找序列中第一个值 > val的位置。(上界)
若序列中找不到该元素，则返回插入该元素的位置（数组：指针，容器：迭代器）。
O(log(last - first))

lower_bound(a, a + 10, 3) - a; //得到下标
upper_bound(a, a + 10, 3) - a; //得到下标

7 简单数据结构

7.1 栈

后进先出。
STL中没有实现栈的清空：

while(!st.empty()) st.pop();

更常用的方法是重新定义一个栈，这不需要花很多时间。

7.1.1 中缀转后缀

（1）设立一个操作符栈，设立一个数组或队列存放后缀表达式。
（2）从左到右扫描中缀表达式，
如果碰到操作数(操作数可能不止一位)把操作数加入后缀表达式。
（3）如果碰到操作符op，将其优先级与操作符栈的栈顶操作符的优先级进行比较：
若op的优先级 > 栈顶操作符优先级，则压栈
若op优先级 <= 栈顶优先级, 弹出至>。
（4）重复上述操作直至扫描完毕，若操作符栈还有元素依次弹出至后缀表达式。
op优先级：* = / > + = -, 可建立一个map<char, int> op; op[’*’] = op[’/’] = 1; op[’+’] = op[’-’] = 0。
为什么op高于栈顶时要压栈？ 因为高优先级要先算，后进先出，后进的先算。op先于栈顶，因此op后进，也就是压栈。
（5）如果出现括号，在步骤3中，a与b判断之前，如果是‘(’就压栈，如果是’)'就弹出至‘(’。

struct node { //这个既可以作为操作数又可以作为操作符的结构体很巧妙
	double num; //操作数
	char op; //操作符
	bool flag;// true表示操作数，false表示操作符
}
string str;
stack<node> s; //操作符栈
queue<node> q; //后缀表达式序列
map<char, int> op; //运算符优先级

void Change() { //中缀转后缀
	double num;
	node temp;
	for(int i = 0; i < str.length();) {
		if(str[i] >= '0' && str[i] <= '9') {
			temp.flag = true; //操作数
			temp.num = str[i ++] - '0'; //记录这个操作数的第一个位数
			while(i < str.length() && str[i] >= '0' && str[i] <= '9') {
				temp.num = temp.num * 10 + (str[i] - '0');
				i ++;
			}
			q.push(temp);
		}
		else {
			temp.flag = false; //操作符
			//只有操作符栈的栈顶元素比该操作符优先级高
			//就把操作符栈栈顶元素弹出到后缀表达式序列中
			while(!s.empty() && op[str[i]] <= op[s.top().op]) {
				q.push(s.top());
				s.pop();
			}
			temp.op = str[i];
			s.push(temp);//操作符入栈
			i ++;
		}
	}
	while(!s.empty()) { //如果操作符栈中还有操作符
		q.push(s.top());
		q.pop();
	}
}

7.1.2 计算后缀表达式

double Cal() {
	double temp1, temp2;
	node cur, temp;
	while(!q.empty()) {
		cur = q.front();
		q.pop();
		if(cur.flag == true) s.push(cur);//是操作数直接压栈
		else {//操作符
			temp2 = s.top.num; //第二操作数
			s.pop();
			temp1 = s.top().num;
			s.pop();
			temp.flag = true; //记录临时操作数
			if(cur.op == '+') temp.num = temp1 +temp2;
			else if(cur.op == '-') temp.num = temp1 - temp2;
			else if(cur.op == '*') temp.num = temp1 * temp2;
			else temp.num = temp1 / temp2;
			s.push(temp);
		}
	}
	return s.top().num;
}

• A1051 Pop Sequence
  用一个stack模拟，注意每次读入目标序列前要清空栈。
  按1~N的顺序将数字压入栈中，压栈过程中如果栈非空，且栈顶元素和目标序列当前位置的数字相同则弹出数字，指针后移(cur++),表示已成功输出。期间如果栈大小超过m则直接失败。当顺利完成n个数字的压栈后，如果栈空且flag仍为TRUE的话，说明压入栈中的数字都在正确的时机出栈了。表明成功。
  核心代码：

bool flag = true;
int cur = 1;
for(int j = 1; j <= n; j ++) {
	st.push(j);
	if(st.size() > m) {
		flag = false;
		break;
	}
	while(!st.empty() && st.top() == seq[cur]) {
		st.pop();
		cur ++;
	}
}
if(st.empty() && flag == true) printf("YES\n");
else printf("NO\n");

7.2 队列

先进先出。
STL中未实现队列的清空：

while(!q.empty()) q.pop();

更常用的方法是重新定义一个队列。

• A1056 Mice and Rice
  题意：将老鼠按编号排队，然后分组，每组第一继续排队，其它老鼠排序相同。
  关键点：其它老鼠的排名应该是group数 + 1。因为分为group组，就有group个老鼠第一，进入下一轮，输的老鼠就是group + 1。进入下一轮继续按照上述规则排队分组排名。

关键思路：用queue把老鼠排队，然后分组排名。每组第一名进入下一轮排队。每一轮循环模拟一轮排队。每组第一名放入队列。当队列中只有一个元素时结束。并将其排序设为1。
1st turn : 19 25 57 | 22 10 3 | 56 18 37 | 0 46
2nd turn: 57 22 56 | 46
3rd turn: 57 46
4th turn: 57

核心代码：

for(int i = 0; i < np; i ++) {
	scanf("%d", &order);
	q.push(order);	
}
	
int group, nr = np;
while(q.size() != 1) {
	if(nr % ng == 0) group = nr / ng;
	else group = nr / ng + 1;
	for(int i = 0; i < group; i ++) {
		int k = q.front();
		for(int j = 0; j < ng; j ++) {
			if(i * ng + j >= nr) break;
			int front = q.front();
			if(mice[front].weight > mice[k].weight)
				k = front;
			mice[front].rank = group + 1;
			q.pop();
		}
		q.push(k); 
	}
	nr = group;
}
mice[q.front()].rank = 1;

7.3 链表

线性表：顺序表和链表。
链表节点：

struct node {
	typename data; //数据域
	node * next; //指针域
}

链表：带头结点的链表、不带头结点的链表。
这里的链表均采用带头节点的写法。最后一个节点指向NULL。

7.3.1 使用malloc或new为链表节点分配内存空间

int* p = (int*)malloc(sizeof(int));
node* p = (node*)malloc(sizeof(node)); //申请失败返回NULL
int* p = new int;
node* p =new node;

一般不会申请失败，当申请了较大的动态数组是可能失败。
释放内存：

free(p);
delete(p);

malloc和free，new和delete应成对出现。

7.3.2 链表基本操作

struct node {
	int data;
	node* next;
};
//创建链表
node* create(int arrary[]) {
	node *p, *pre, *head; //pre保存当前节点的前驱节点，head为头结点
	head = new node;
	head -> next = NULL;
	pre = head;
	for(int i = 0; i < 5; i ++) {
		p = new node;
		p -> data = array[i];
		p -> next = NULL;
		pre -> next = p;
		pre = p;
	}
	return head; //返回头结点指针
}

//查找链表元素
int search(node* head, int x) {
	int cnt = 0;
	node* p = head -> next;
	while(p != NULL) {
		if(p -> data == x) 
			cnt ++;
		p = p -> next;
	}
	return cnt;
}

//插入元素:在第pos个位置插入x
void insert(node* head, int pos, int x) {
	node* p = head;
	for(int i = 0; i < pos - 1; i ++)
		p = p -> next; //找到插入位置的前一个
	node * q = new node;
	q -> data = x;
	q -> next = p -> next;
	p -> next = q;
}

//删除元素
void del(node* head, int x) {
	node* p = head -> next;
	node* pre = head;
	while(p != NULL) {
		if(p -> data == x) {
			pre -> next = p -> next;
			delete(p);
			p = pre -> next;
		}
		else {
			pre = p;
			p = p -> next;
		}
	}
}

7.3.3 静态链表

当节点的地址都是比较小的整数（如5位数的地址），没比较建立动态链表，建立更方便的静态链表即可。
静态链表的实现原理是hash，即建立一个结构体数组，并令数组下标直接表示节点地址。静态链表不需要头结点。

struct Node {
	typename data;
	int next;
}node[size];

注意：在使用静态链表时，尽量不要把结构体类型名和结构体变量名取成相同的名字。

7.3.4 静态链表解题步骤

1. 定义静态链表

struct Node {
	int addr;
	int data;
	int next;
	xxx; //节点的某个性质
}node[maxn];

2. 在程序开始对静态链表初始化

for(int i = 0; i < maxn; i ++)
	node[i].xxx = 0; //初始化为一个较小的值

3. 题目一般会给出链表首节点地址，根据这个地址遍历得到整个链表。同时对节点性质xxx进行标记。

int p = begin, count = 0;
while(p != -1) {
	XXX = 1;
	count ++;
	p = node[p] = next;
}

4. 由于静态链表直接采用地址映射(hash)，这会使得数组下标不连续，而很多时候题目给出的节点并不都是有效节点（即可能存在不在链表上的节点），为了可控的访问有效节点，一般需要对数组进行排序以把有效节点移到数组左端，这样就可以用步骤3的count来访问他们，排序时cmp就可以用xxx性质从大到小排序。将有效节点xxx设为一个更大的值。例如排序规则可以是：无效时按xxx从大到小，有效时按节点在链表中的位置从小到大排序。

bool cmp(Node a, Node b) {
	if(a.xxx == -1 || b.xxx == -1) {
		return a.xxx > b.xxx;
	}
	else {
		//第二级排序
	}
}

5. 这样，有效节点在数组左端了，且按照节点性质进行了排序。接下来按题目要求即可(通常是输出)。

• A1032 Sharing
  按模板构建结构体读入数据。遍历第一个链表，将第一个链表的元素flag设置为TRUE。
  然后遍历第二个链表，如果第二个链表元素的flag为TRUE则说明是公共节点，后面的部分也是相同的了。
  核心代码：

const int maxn = 100010;
struct Node {
	int addr;
	char data;
	int next;
	bool flag; //节点是否在第一个链表中出现。 
}node[maxn];

for(int i = 0; i < maxn; i ++)
		node[i].flag = false;
	int s1, s2, n;
	scanf("%d %d %d", &s1, &s2, &n);
	for(int i = 0; i < n; i ++) {
		int address, data, next;
		scanf("%d %c %d", &address, &data, &next); 
		node[address].addr = address;
		node[address].data = data;
		node[address].next = next;
	}
	
int p;
for(p = s1; p != -1; p = node[p].next) {
	node[p].flag = true;
}
for(p = s2; p != -1; p = node[p].next) {
	if(node[p].flag == true) break;
}
if(p != -1) {
	printf("%05d\n", p);
}
else {
	printf("-1\n");
}

• B1025 反转链表
  完整代码：

const int maxn = 100010;
struct Node {
	int addr;
	int data;
	int next;
	int order;//节点在链表中的序号 
}node[maxn];


bool cmp(Node a, Node b) {
	return a.order < b.order; 
}

int main() {
	for(int i = 0; i < maxn; i ++)
		node[i].order = maxn;
	
	int start, n, k;
	int addr, data, next;
	scanf("%d %d %d", &start, &n, &k);
	for(int i = 0; i < n; i ++) {
		scanf("%d %d %d", &addr, &data, &next);
		node[addr].addr = addr;
		node[addr].data = data;
		node[addr].next = next;
	}
	int p = start, cnt = 0;
	while(p != -1) {
		node[p].order = cnt ++;
		p = node[p].next;
	}
	
	sort(node, node + maxn, cmp);
	n = cnt;
	for(int i = 0; i < n / k; i ++) { //共n/k个分段 
		for(int j = (i + 1) * k - 1; j > i * k; j --) {
			printf("%05d %d %05d\n", node[j].addr, node[j].data, node[j - 1].addr);
		}
		printf("%05d %d ", node[i * k].addr, node[i * k].data); //每一块最后一个节点
		if(i < n / k - 1) { //不是最后一块 
			printf("%05d\n", node[(i + 2) * k - 1].addr);//下一段的第一个
		}
		else {
			if(n % k == 0) { //恰好最后一个节点 
				printf("-1\n");
			}
			else { 
				printf("%05d\n", node[(i + 1) * k].addr);//下一段的第一个
				//剩下不完整的块按原顺序输出 
				for(int i = n / k * k; i < n; i ++) {
					printf("%05d %d ", node[i].addr, node[i].data);
					if(i < n - 1) {
						printf("%05d\n", node[i + 1].addr);
					}
					else
						printf("-1\n");
				} 
			} 
		}
	}
	return 0;
}

前面结构体order的sort很巧妙。这题后面的输出是难点。
大致思想是分段输出。每一段需要倒过来输出。对于前面的除最后一段之外的每一段的除最后一个外：地址，数据，next(应该变为前一个节点的地址)。这一段的最后一个元素的next应该是下一段的第一个元素的地址。每一段最后一个节点的next需特殊处理：如果刚好是最后一个节点输出-1。

• A1052 Linked List Sorting
  链表排序。按模板写即可。
  一开始我想直接用key来确定是否为有效节点，无效的置为maxn，结果程序错误。
  后来发现输入节点后遍历链表才能确定是否有效。如果用maxn的方法话，仍然会把无效的排到前面。
  还是用一个flag标志，遍历链表时置为TRUE，记录有效节点数cnt。最后按要求输出。
  cmp函数如下：

bool cmp(Node a, Node b) {
	if(a.flag == false || b.flag == false)
		return a.flag > b.flag; //有效的、大的(1)放前面 
	else
		return a.key < b.key;
}

本题有个坑点，就是链表可能长度为0，此时应特判输出“0 -1”。

• A1097 Deduplication on a Linked List
  思路：链表模板，hashTable的思想。
  遍历链表，第一次遇到的链表元素hashTable[abs()]++，并将flag置为2表示有效的非重复链表，后面遇到重复元素则将flag置为1表示removed.
  cmp函数如下：即先flag从大到小排，0表示无效，会排到最后，flag=1是removed list，flag=2是有效valid list。
  当flag!=0时按order排序，即链表的顺序。

bool cmp(Node a, Node b) {
	if(a.flag != b.flag)
		return a.flag > b.flag;
	else 
		return a.order < b.order; 
}

最后输出-1的判断条件如下：

if(node[i].flag == 2 && node[i + 1].flag == 1 || i == cnt - 1)
	printf("-1\n");

8 搜索

8.1 深度优先搜索DFS

DFS可以使用栈实现。也可用递归实现。
使用递归可以很好的实现深度优先搜索。

8.1.1 背包问题

n件物品，每个价值为v[i]，重量为w[i]，选择若干件物品放入容量为V的背包中，使得总价值最大。

int n, V, maxValue = 0;
void DFS(int index, int sumW, int sumC) {
	if(index == n) { //处理完n件物品
		if(sumW <= V && sumC > maxValue) 
			maxValue = sumC;
		return;
	}
	else {
		DFS(index + 1, sumW, sumC);//不选第index件物品
		DFS(index + 1, sumW + w[index], sumC + c[index]);
	}
}
DFS(0, 0, 0);

剪枝
只有sumW<=V时才进入岔道。

void DFS(int index, int sumW, int sumC) {
	if(index == n)
		return;
	DFS(index + 1, sumW, sumC);
	if(sumW + w[index] <= V) {
		if(sumC + c[index] > ans)
			ans = sumC + c[index];
		DFS(index + 1, sumW + w[index], sumC + c[index]);
	}
}

常见DFS问题解决方法：
给定一个序列，枚举这个序列的所有子序列（可以不连续）。
枚举从N个数中选择K个数的所有方案。
eg: 给定N个数，选择K个数使得和恰好等于x，若有多个方案选择平方和最大的方案。

int n, k, x, maxSumSqu = -1, A[maxn];
vector<int> temp, ans;//temp存放临时方案，ans存放平方和最大方案。
void DFS(int index, int nowK, int sum, int sumSqu) {
	if(nowK == k && sum == x) {
		if(sumSqu > maxSumSqu) {
			maxSumSqu = sumSqu;
			ans = temp;
		}
		return;
	}
	//已处理完n个数，超过k个数，和超过x，则返回
	if(index == n || nowK > k || sum > x) return;
	temp.push_back(A[index]); //选第index个数
	DFS(index + 1, nowK + 1, sum + A[index], sumSqu + A[index] * A[index]);
	temp.pop_back();
	//不选第index个数
	DFS(index + 1, nowK, sum, sumSqu);
}

如果每个数可以选择多次：只需将“选index号数”的分支修改为DFS(index, nowK + 1, sum + A[index], sumSqu + A[index] * A[index])即可。

• A1103 Integer Factorization
  按照DFS的思想和模板。一开始自己写的代码一个样例超时一个样例错写。
  技巧1：可以把n^p预处理计算保存起来减少运算量。

void init() {
	int i = 0, temp = 0;
	while(temp <= n) {
		fac.push_back(temp);
		temp = pow(++ i, p);
	}
}

但发现还是有个样例超时，且有个样例错误。
后来发现题解是从大到小dfs的，而我是从小到大的。仔细一想，从大到小会极大减少运算量，因为从小到大枚举会有很多可能，并且题目要求有多个满足方案要求时应选择较大的序列。因此从大到小枚举才是正确的。
完整DFS代码如下：

void DFS(int index, int nowK, int sum, int sumFac) {
	if(nowK == k && sum == n) {
		if(sumFac == maxFac) {
			if(index > maxIndex) {
				maxIndex = index;
				ans = temp;
			}	
		}
		else 
		if(sumFac > maxFac) {
			maxFac = sumFac;
			ans = temp;
		}
		return;
	}
	if(fac[index] > n  || nowK > k || sum > n || index == 0) return;
	if(sum + pow(index, p) <= n) {
		//选择第index个数
		temp.push_back(index);
		DFS(index, nowK + 1, sum + fac[index], sumFac + index);//第index个数可以重复选 
		temp.pop_back();
	}
	//不选择第index个数
	DFS(index - 1, nowK, sum, sumFac); 
}

注意点：index==0不需要枚举。求最大的maxIndex好像是多余的(题解中没有)，但是去掉了会超时。

8.2 广度优先搜索BFS

碰到岔道口时先依次访问能直接到达的所有节点，然后再按照这些节点被访问的顺序去依次访问它们能直接访问的所有节点。
BFS可以通过队列实现。
模板：

void BFS(int s) {
	queue<int> q;
	q.push(s);
	while(!q.empty()) {
		取出top();
		访问top();
		q.pop();
		将q.top()的下一层节点中未曾入队的节点全部入队，并设置为已入队。
	}
}

8.2.1 求矩阵中的块数

m*n的矩阵有0有1，上下左右是相连的。求块的个数。
可以枚举每个位置：是0跳过，是1则BFS查询4邻域。循环下去直至所有1被访问。
技巧：设置增量数组：

int X[] = {0, 0, 1, -1};
int Y[] = {1, -1, 0, 0};

这样可以for循环遍历四个邻域。

for(int i = 0; i < 4; i ++) {
	newX = nowX + X[i];
	newY = nowY + Y[i];
}

题解：

struct Node {
	int x, y;
}node;
int n, m;
bool inq[maxn][maxn] = {0}; //in queue与否？是否入过队
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};

bool judge(int x, int y) { //判断坐标(x, y)是否需要访问
	if(x >= n || x < 0 || y >= m || y < 0) return false;
	if(matrix[x][y] == 0 || inq[x][y] == true) return false;
	return true;
}

void BFS(int x, int y) {
	queue<Node> Q;
	node.x = x, node.y = y;
	inq[x][y] = true;
	Q.push(node);
	while(!Q.empty()) {
		Node top = Q.front();
		Q.pop();
		for(int i = 0; i < 4; i ++) {
			int newX = top.x + X[i];
			int newY = top.y + Y[i];
			if(judge(newX, newY)) {
				node.x = newX, node.y = newY;
				Q.push(node);
				inq[newX][newY] = true;
			}
		}
	}
}

//枚举每个位置
int ans = 0;
for(int x = 0; x < n; x ++) {
	for(int y = 0; y < m; y ++) {
		if(matrix[x][y] == 1 && inq[x][y] == false) {
			ans ++;
			BFS(x, y);
		}
	}
}

8.2.2 求走迷宫的最少步数

n*m的迷宫，*表示墙壁，.表示平地，S起点，T终点。求从S到T的最少步数。
解：由于求最少步数，可以用BFS的层数来计数。

struct Node {
	int x, y;
	int step; //记录从S到达该位置的最少步数（即层数）
}S,T, node;
int n, m;
char maze[maxn][maxn];
bool inq[maxn][maxn] = {false};
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};
// 测试(x, y)是否有效
bool test(int x, int y) {
	if(x >= n || x < 0 || y >= m || y < 0) return false;
	if(maze[x][y] == '*') return false;
	if(inq[x][y] == true) return false;
	return true;
}

int BFS() {
	queue<node> q;
	q.push(S);
	while(!q.empty()) {
		Node top = q.front();
		q.pop();
		if(top.x == T.x && top.y == T.y) {
			return top.step;
		}
		for(int i = 0; i < 4; i ++) {
			int newX = top.x + X[i];
			int newY = top.y + Y[i];
			if(test(newX, newY)) {
				node.x = newX, node.y = newY;
				node.step = top.step + 1;
				q.push(node);
				inq[newX][newY] = true;
			}
		}
	}
	return -1; 
}
scanf("%d%d", &n, &m);
for(int i = 0; i < n; i ++) {
	getchar();
	for(int j = 0; j < m; j ++) {
		maze[i][j] = getchar();
	}
	maze[i][m + 1] = '\0';
}
S.step = 0;
BFS();

BFS中inq数组含义是节点是否已入过队，而非节点是否已被访问。
需要注意的是，STL的queue的push操作只是制造了元素的一个副本，因此入队后对原元素的修改不过影响队列中的元素，对队列中元素修改不会影响原元素。
这就是说，当需要对队列中元素进行修改而不仅仅是访问时，队列中的元素最好不是元素本身，而是它们的编号（如数组下标）。

• A1091 Acute Stroke
  三位连通块。只需将二维连通块扩展一些即可。
  三维增量数组如下：

int X[6] = {0, 0, 0, 0, 1, -1};
int Y[6] = {0, 0, 1, -1, 0, 0};
int Z[6] = {1, -1, 0, 0, 0, 0};

BFS统计1的个数，即体积。应该在中心位置（即未移动之前就vol ++），因为遍历三维矩阵进行BFS之前就会判断是否为1，只有1才会进入BFS。

本题中非常重要的一点是数据输入格式。需要先遍历层数L，即z, x, y的顺序。如下：

for(int z = 0; z < L; z ++) {
	for(int x = 0; x < M; x ++) {
		for(int y = 0; y < N; y ++) {
			scanf("%d", &mri[x][y][z]);
		}
	}
} 

int ans = 0;
for(int z = 0; z < L; z ++) { //需要先枚举层数(高) ！ 
	for(int x = 0; x < M; x ++) {
		for(int y = 0; y < N; y ++) {
			if(mri[x][y][z] == 1 && inq[x][y][z] == false) {
				ans += BFS(x, y, z);
			}
		}
	}
} 

BFS代码如下：

int BFS(int x, int y, int z) {
	int vol = 0;
	queue<Node> q;
	node.x = x, node.y = y, node.z = z;
	inq[x][y][z] = true;
	q.push(node);
	while(!q.empty()) {
		Node top = q.front();
		q.pop();
		vol ++;
		for(int i = 0; i < 6; i ++) {
			int newX = top.x + X[i];
			int newY = top.y + Y[i];
			int newZ = top.z + Z[i];
			if(judge(newX, newY, newZ)) {
				node.x = newX, node.y =newY, node.z = newZ;
				q.push(node);
				inq[newX][newY][newZ] = true;
			}
		}
	}
	if(vol >= T) return vol;
	else return 0;
} 

9 树

9.1 树与二叉树

树的性质：

• 树可以没有节点，空树
• 树的层次从根节点算起，根节点为第一层
• 节点的子树棵数成为节点的度，树中节点最大的称为树的度(宽度)
• n个节点的树，边数一定是n-1。满足连通，边数等于顶点数-1的结构一定是树。
• 叶子结点被定义为度为0，树只有一个节点时根节点也算叶子节点。
• 节点的深度是指从根节点(深度为1)开始自定向下逐层累加至该节点的深度值。节点的高度是从最底层叶子节点（高度为1）开始自底向上逐层累加至该节点时的高度值。对树而言，深度和高度相等。
• 多棵树组成森林。

二叉树：
要么二叉树没有根节点，是一棵空树；
要么二叉树由根节点、左子树、右子树组成，且左右子树都是二叉树。

二叉树和度为2的树的区别：度为2的树只是每个节点的子节点个数不超过2，而二叉树虽然满足，但是它的左右子树严格区分。

• 满二叉树：每一层节点个数都达到了当层能达到的最大节点数。
• 完全二叉树：除了最下面一层外，其余层的节点个数都达到了当层能达到的最大节点数，且最下面一层只从左到右连续存在若干节点，而右边的节点全部不存在。

9.1.1 二叉树的存储与基本操作

二叉树的存储结构：使用链表来定义。二叉链表。

struct node {
	typename data;
	int layer; //要求计算层次时
	node* lchild;
	node* rchild;
};
//建树前根节点不存在
node* root = NULL;
//新建节点
node* newNode(int v) {
	node* Node = new node;
	Node -> data = v;
	Node -> lchind = Node -> rchild = NULL;
	return Node;
}
//二叉树节点的查找、修改
void search(node* root, int x, int newdata) {
	if(root == NULL) return;
	if(root -> data == x) root -> data = newdata;
	search(root -> lchild, x, newdata);
	search(root -> rchild, x, newdata);
}

结论：二叉树节点的插入位置就是数据域在二叉树中查找失败的位置。

//注意root指针要使用引用，否则不会插入成功
void insert(node* &root, int x) {
	if(root == NULL) {
		root = newNode(x);//&的原因是这里新建了节点
		return;
	}
	if(二叉树的性质，x应该插在左子树) {
		insert(root -> lchind, x);
	}
	else {
		insert(root -> rchild, x);
	}
}

search函数不需加引用的原因是修改的是指针root指向的内容，而不是root本身。
一般来说，如果函数需要新建节点，即对二叉树的结构做出修改就需要加引用；若只是修改当前已有节点的内容或遍历树则不需加引用。

二叉树的创建：

node* Create(int data[], int n) {
	node* root = NULL;
	for(int i = 0; i < n; i ++) {
		insert(root, data[i]);
	}
	return root;
}

root是节点地址，*root是节点内容。

完全二叉树的存储结构：除了使用二叉链表外，还有更方便的存储方法。对于一棵完全二叉树，将它的所有节点按从上到下从左到右的顺序进行编号，从1开始。
对于任何一个节点设其编号为x，则其左孩子为2x，右孩子为2x+1。因此完全二叉树可以建立一个大小为2^k
的数组（k为树的最大高度）。1号位必须是根节点（不能是0）。

除此之外，该数组中元素存放顺序恰好为该完全二叉树的层序遍历序列。而判断某个节点是否为叶节点的标志位：该节点的左子节点的编号2x > 总个数n。判断某节点是否为空节点的标志：该节点下标大于总个数n。

9.2 二叉树的遍历

遍历方法包括：先序遍历、中序遍历、后序遍历、层次遍历。前三种用DFS实现，后一种用BFS实现。
要点：无论那种遍历，左子树一定先于右子树遍历，先中右基于root在遍历中的位置

• 先序遍历：

void preorder(node* root) {
	if(root == NULL) return;
	printf("%d\n", root -> data);
	preorder(root -> lchild);
	preorder(root -> rchild);
}

先序遍历的性质：对于一棵二叉树的先序遍历，第一个一定是根节点。

• 中序遍历

void inorder(node* root) {
	if(root == NULL) return;
	inorder(root -> lchild);
	printf("%d\n", root -> data);
	inorder(root -> rchild);
}

中序遍历的性质：只要知道根节点，就区分出左右子树。

• 后序遍历

void postorder(node* root) {
	if(root == NULL) return;
	postorder(root -> lchild);
	postorder(root -> rchild);
	printf("%d\n", root -> data);
}

后序遍历的性质：对于后序遍历序列，序列最后一个一定是根节点。
结论：无论是先序遍历还是后序遍历，都必须知道中序遍历序列才能唯一确定一棵树。

• 层序遍历

void LayerOrder(node* root) {
	queue<node*> q;//注意队列里存的是地址,因为队列中只能保证原元素的副本
	root -> layer = 1;
	q.push(root); //将根节点地址入队
	while(!q.empty()) {
		node* now = q.front();
		q.pop();
		printf("%d", now -> data);
		if(now -> lchild != NULL) {
			now -> lchild -> layer = now -> layer + 1;
			q.push(now -> lchild);
		}
		if(now -> rchild != NULL) {
			now -> rchild -> layer = now -> layer + 1;
			q.push(now -> rchild);
		}
	}
}

9.2.1 根据先序和中序重建二叉树

先序：root left right: 1, [2, k], [k + 1, n] : numLeft = k - inL; preL, [preL + 1, preL + numLeft], [preL + numLeft + 1, preR]
中序：left root right [1, k - 1], k [k + 1, n] : [inL, k - 1], k, [k + 1, inR]

//[preL, preR] [inL, inR]
node* create(int preL, int preR, int inL, int inR) {
	if(preL > preR) return NULL;
	node* root = new node;
	root -> data = pre[preL]; //新节点的数据为根节点的值
	int k;
	for(k = inL, k <= inR; k ++) {
		if(in[k] == pre[preL])
			break;
	}
	int numLeft = k - inL;//左子树的节点个数
	root -> lchild = create(preL + 1, preL + numLeft, inL, k - 1);
	root -> rchild = create(preL + numLeft + 1, preR, k + 1, inR);
	return root;
}

结论：中序 +（先序|后序|层序）= 唯一的二叉树

• A1020 Tree Traversals
  已知中序和后序构建树，然后层序遍历。

node* create(int postL, int postR, int inL, int inR) {
	if(postL > postR) return NULL;
	node* root = new node;
//	root->lchild = root->rchild = NULL; 
	root->data = post[postR];
	int k;
	for(k = inL; k <= inR; k ++)
		if(in[k] == post[postR])
			break;
	int numLeft = k - inL;
	root->lchild = create(postL, postL + numLeft - 1, inL, k - 1);
	root->rchild = create(postL + numLeft, postR - 1, k + 1, inR);
	return root; //注意别忘了返回root，否则指针乱飞出现段错误。
}

int num = 0;
void layerOrder(node* root) {
	queue<node*> q;
	q.push(root);
	while(!q.empty()) {
		node* now = q.front();
		q.pop();
		if(num ++ > 0) printf(" ");
		printf("%d", now->data);
		if(now->lchild != NULL) {
			q.push(now->lchild);
		}
		if(now->rchild != NULL) {
			q.push(now->rchild);
		}
	} 
}

• A1086 Tree Traversals Again
  push的顺序可以得到先序遍历的结果。
  用栈模拟pop可以得到中序遍历的结果。
  由先序和中序构建二叉树，在后序遍历。

9.2.2 二叉树的静态实现

使用静态二叉链表实现。需建立一个大小为节点上学个数的node型数组。

struct node {
	int data;
	int lchild;
	int right;
}Node[maxn];

//节点的动态生成变为静态指定
int index = 0;
int newNode(int v) {
	Node[index].data = v;
	Node[index].lchild = -1;
	Node[index].rchild = -1;
	return index ++;
}

//查找修改
void search(int root, int x, int newdata) {
	if(root == -1) return;
	if(Node[root].data == x) Node[root].data = newdata;
	search(Node[root].lchild, x, newdata);
	search(Node[root].rchild, x, newdata);
}
//插入
void insert(int &root, int x) {
	if(root == -1) {
		root = newNode(x);
		return;
	}
	if(由二叉树性质x应该插入左子树) {
		insert(Node[root].lchild, x);
	}
	else {
		insert(Node[root].rchild, x);
	}
}
// 二叉树的建立
int Create(int data[], int n) {
	int root = -1;
	for(int i = 0; i < n; i ++) {
		insert(root, data[i]);
	}
	return root;
}
//先序遍历
void preorder(int root) {
	if(root == -1) return;
	printf("%d\n", Node[root].data);
	preorder(Node[root].lchild);
	preorder(Node[root].rchild);
}
//中序遍历
void inorder(int root) {
	if(root == -1) return;
	inorder(Node[root].lchild);
	printf("%d\n", Node[root].data);
	inorder(Node[root].rchild);
}
//后序遍历
void postorder(int root) {
	if(root == -1) return;
	postorder(Node[root].lchild);
	postorder(Node[root].rchild);
	printf("%d\n", Node[root].data);
}
//层序遍历
void layerOrder(int root) {
	queue<int> q;
	q.push(root);
	while(!q.empty()) {
		int now = q.front();
		q.pop();
		printf("%d ", Node[now].data);
		if(Node[now].lchild != -1) q.push(Node[now].lchild);
	if(Node[now].rchild != -1) q.push(Node[now].rchild);
	}
}

• A1102 Invert a Binary Tree
  由于题目直接给了节点编号的关系，因此使用静态写法更方便。但是需要找出根节点，可以发现输入中没有出现的编号即为根节点（因为根节点没有父亲节点）。
  这可以用一个root数组在输入是做标记得到。
  至于要反转链表，在纸上画过可以发现只需将左右节点换一下即可，在读入时即可互换。（题解中用的后序遍历交换左右孩子节点的方法）。

卡了我很久的还是数据输入的问题，需要用getchar()吞掉上一次输入的换行符。也可以使用scanf("%*c")的方法，它用来读入一个字符
scanf("%*c%c %c", &right, &left);
原因：scanf("%c")可以读入换行符，就是说本来如果是%d就会忽略换行符读入整数，而%c会读入换行符作为数据填充到变量中。导致最后呈现的结果只读入了一半的数据。

9.3 树的遍历

9.3.1 树的静态写法

静态写法即用数组下标代替地址。需要事先开一个不低于节点上限个数的节点数组。

struce Node {
	int layer;//当需要求解层号时
	int data;
	vector<int> child;
} node[maxn];
//新建节点
int index = 0;
int newNode(int v) {
	node[index].data = v;
	node[index].child.clear();
	return index ++;
}

当给出节点编号时就不需要newNode()函数了。直接使用编号作为数组下标使用。
如果题目中不涉及节点的数据域，即只需要树的结构，上面的结构体数组就可以简化为vector数组了。vector<int> child[maxn]。实际上这种写法就是图的邻接表在树中的应用。

• 先根遍历(DFS)

void preOrder(int root) {
	printf("%d ", node[root].data);
	for(int i = 0; i < Node[root].child.size(); i ++) { //其实递归边界就是size()==0
		preOrder(node[root].child[i]);
	}
}

• 层序遍历(BFS)

void layerOrder(int root) {
	queue<int> q;
	q.push(root);
	node[root].layer = 0;
	while(!q.empty()) {
		int front = q.front();
		printf("%d ", node[front].data);
		q.pop;
		for(int i = 0; i < node[front].child.size(); i ++) {
			int child = node[front].child[i];
			node[child].layer = node[front].layer + 1;
			q.push(child);
		}
	}
}

• A1053 Path of Equal Weight
  求解叶子节点的带权路径和。 DFS和树的遍历思想的结合。
  DFS的有三个变量，节点编号index，节点数numNode，带权和sum。
  边界条件：如果sum>s,返回；如果sum==s，且当前节点时叶子节点则找到一条路径，输出这条路径的权重。然后返回。如果不是叶子节点也返回。
  判断叶子节点的方法是：child的大小为0。
  当sum < s时，DFS递归枚举。遍历当前节点的所有孩子节点，选择这个孩子节点，进入下一层DFS，传入的index为child的编号，numNode + 1, sum + node[child].weight。退出DFS时弹出child编号。

注意DFS的开始状态：
path.push_back(0);
DFS(0, 1, node[0].weight);

将当前的孩子节点按照权重从大到小排序，这样使得DFS遍历更快结束。且满足大的路径先输出的要求。
完整代码：

const int maxn = 110;
struct Node {
	int weight;
	vector<int> child;
} node[maxn];



bool cmp(int a, int b) {
	return node[a].weight > node[b].weight;
}

vector<int> path;
int n, m, s;

void DFS(int index, int numNode, int sum) {
	if(sum > s) return;
	if(sum == s) {
		if(node[index].child.size() == 0) {
			for(int i = 0; i < numNode; i ++) {
				printf("%d", node[path[i]].weight);				
				if(i < numNode - 1) printf(" ");
				else printf("\n");
			}
			return;
		}
		else return;
	}
	for(int i = 0; i < node[index].child.size(); i ++) {
		int child = node[index].child[i];
		path.push_back(child);
		DFS(child, numNode + 1, sum + node[child].weight);
		path.pop_back();
	}

}

int main() {
	scanf("%d %d %d", &n, &m, &s);
	for(int i = 0; i < n; i ++) 
		scanf("%d", &node[i].weight);
	int id, k, cid;
	for(int i = 0; i < m; i ++) {
		scanf("%d %d", &id, &k);
		for(int j = 0; j < k; j ++) {
			scanf("%d", &cid);
			node[id].child.push_back(cid);
		}
		sort(node[id].child.begin(), node[id].child.end(), cmp); 
	} 
	path.push_back(0);
	DFS(0, 1, node[0].weight);
	return 0;
}

• A1079 Total Sales of Supply Chain
  题意：求树的带权路径长。叶子节点的权重为产品数量，还需要乘以price * (1 + r)^layer-1 便可以得到每个叶子的sales，然后累加所有叶子的sale得到结果。采用DFS的思想。

const int maxn = 100010;
struct Node {
	int product;
	int layer;
	vector<int> child;
} node[maxn];
double sum = 0.0, price, r;
void DFS(int root) {
	if(node[root].child.size() == 0) {
		int l = node[root].layer - 1;
		sum += node[root].product * price * pow(1 + r * 0.01, l);
		return;
	}
	//这里实际上有一个递归结束条件
	for(int i = 0; i < node[root].child.size(); i ++) {  
		int cid = node[root].child[i];
		node[cid].layer = node[root].layer + 1;
		DFS(cid);
	}
}
node[0].layer = 1;
DFS(0);
printf("%.1f", sum);

• A1090 Highest Price in Supply Chain
  题意：求出最大深度即可，并且最大深度的叶子的数量。
  注意点：DFS的初始状态要设置好。node[root].layer = 1。
  DFS的代码（优化版）：

int maxDepth = 0, numLeaf = 0;
void DFS(int index, int depth) {
	if(child[index].size() == 0) {
		if(depth > maxDepth) {
			maxDepth = depth;
			numLeaf = 1;
		} 
		else if(depth == maxDepth) {
			numLeaf ++;
		}
		return;
	}
	
	for(int i = 0; i < child[index].size(); i ++) {
		DFS(child[index][i], depth + 1);
	}
}

• A1094 The Largest Generation
  题意：求宽度最大的一层。DFS和BFS都可。
  对于BFS来说，每次去除队列顶端的节点时记录的level把hashTable[level] + 1。
  技巧：需要定义一个hashTable数组记录每一层节点数。
  DFS:

int hashTable[maxn] = {0};
void DFS(int index, int level) {
	hashTable[level] ++;
	for(int i = 0; i < child[index].size(); i ++) {
		DFS(child[index][i], level + 1);
	}
}

• A1106 Lowest Price in Supply Chain
  题意：求最小深度的叶子节点的深度，并统计最小深度叶子的数量。

int minLevel = maxn, numLeaf = 0;
void DFS(int index, int level) {
    if(child[index].size() == 0) {
        if(level < minLevel) {
            minLevel = level;
            numLeaf = 1;
        }
        else if(level == minLevel) {
            numLeaf ++;
        }
        return;
    }

    for(int i = 0; i < child[index].size(); i ++) {
        DFS(child[index][i], level + 1);
    }
}

• A1004 Counting Leaves
  题意：计算每一层的叶子数。DFS。需要记录最大层数。

int hashTable[maxn] = {0};
int maxLevel = 0;
void DFS(int index, int level) {
	if(child[index].size() == 0) {
		if(level > maxLevel) maxLevel = level;
		hashTable[level] ++;
		return;
	}
	for(int i = 0; i < child[index].size(); i ++) {
		DFS(child[index][i], level + 1);
	}
}

9.4 二分搜索树(BST)

BST的定义
二叉查找树BST是一种特殊的二叉树，又称为排序二叉树、二叉搜索树、二叉排序树。
BST的定义：
要么BST是一棵空树；
要么BST由根节点、左子树、右子树组成，其中左子树和右子树都是BST。

BST实际上是一个数据域有序的二叉树。每个节点满足左子树<=根，右子树>根。

9.4.1 BST的基本操作

• 查找操作：复杂度O(height)

void search(node* root, int x) {
	if(root == NULL) {
		printf("search failed\n");
		return;
	}
	if(x == root->data) {
		printf("%d\n", root->data);
	}
	else if(x < root->data) {
		search(root->lchild, x);
	}
	else {
		search(root->rchild, x);
	}
}

• 插入操作: O(height)

void insert(node* &root, int x) {
	if(root == NULL) {
		root = newNode(x);
		return;
	}
	if(x == root->data) {
		return;
	}
	else if(x < root->data) {	
		insert(root->lchild, x);
	}
	else {
		insert(root->rchild, x);
	}
}

• BST的建立

node* create(int data[], int n) {
	node* root = NULL;
	for(int i = 0; i < n; i ++) {
		insert(root, data[i]);
	}
	return root;
}

同一组数据插入顺序不同，最后生成的BST也可能不同。

• BST的删除
  把BST中比节点权值小的最大节点成为该节点的前驱，把比节点权值大的最小节点成为该节点的后继。
  节点的前驱是左子树的最右节点(不断沿着rchlid直到NULL)，节点的后继是右子树的最左节点(不断沿着lchild直至NULL)。

node* findMax(node* root) {
	while(root->rchild != NULL)
		root = root->rchild;
	return root;
}

node* findMin(node* root) {
	while(root->lchild != NULL) 
		root = root->lchild;
	return root;
}

void deleteNode(node* &root, int x) {
	if(root == NULL) return;
	if(root->data == x) {
		if(root->lchild == NULL && root->rchild == NULL)
			root = NULL; //把root地址设为NULL，父节点就引用不到它了
		else if(root->lchild != NULL) {
			node* pre = findMax(root->lchild);
			root->data = pre->data;
			deleteNode(root->lchild, pre->data);//在左子树中删除pre
		}
		else {
			node* next = findMin(root->rchild);
			root->data = next->data;
			deleteNode(root->rchild, next->data);
		}
	}
	else if(x < root->data) {
		deleteNode(root->lchild);
	}
	else {
		deleteNode(root->rchild);
	}
}

BST的性质: 对BST的中序遍历，结果是有序的。

• A1043 Is it a Binary Search Tree
  镜像树的遍历只需在递归传递参数时左右子树交换一下即可。

void preorder(node* root, vector<int>&vi) {
    if(root == NULL) return;
    vi.push_back(root->data);
    preorder(root->lchild, vi);
    preorder(root->rchild, vi);
}

void preorderMir(node* root, vector<int>&vi) {
    if(root == NULL) return;
    vi.push_back(root->data);
    preorderMir(root->rchild, vi);
    preorderMir(root->lchild, vi);
}

void postorder(node* root, vector<int>&vi) {
    if(root == NULL) return;
    postorder(root->lchild, vi);
    postorder(root->rchild, vi);
    vi.push_back(root->data);
}

void postorderMir(node* root, vector<int>&vi) {
    if(root == NULL) return;
    postorderMir(root->rchild, vi);
    postorderMir(root->lchild, vi);
    vi.push_back(root->data);
}

BST节点的插入：

void insert(node* &root, int x) {
    if(root == NULL) {
        root = new node;
        root->data = x;
        root->lchild = root->rchild = NULL;
        return;
    }
    if(x < root->data) insert(root->lchild, x);
    else insert(root->rchild, x);
}

主函数

int main() {
    int n, num;
    node* root = NULL;
    scanf("%d", &n);
    for(int i = 0; i < n; i ++) {
        scanf("%d", &num);
        data.push_back(num);
        insert(root, num);
    }
    preorder(root, pre);
    preorderMir(root, preMir);
    postorder(root, post);
    postorderMir(root, postMir);
    if(data == pre) {
        printf("YES\n");
        print(post);
    }
    else if(data == preMir) {
        printf("YES\n");
        print(postMir);
    }
    else {
        printf("NO\n");
    }
    return 0;
}

注意没有等于情况的判断，否则会出错。

• A1064 Complete Binary Search Tree
  看到题目完全没思路。但大致可以猜到完全二叉树应该会用数组来存储。
  题解的思路：开一个数组CBT[maxn]，CBT[1]~CBT[n]存放完全二叉输的n个节点。又由于对于BST来说，其中序遍历是递增的。因此可以将输入数据排序，这样得到中序遍历结果，然后对CBT数组表示的二叉树进行中序遍历，并在遍历过程中将数字由小到大填入CBT。由于CBT就是按照二叉树的层序存放节点的，只需按顺序输出即可。

const int maxn = 1010;
int CBT[maxn], data[maxn];
int num = 1, n; //注意num从1开始
void inorder(int root) {
	if(root > n) return;
	inorder(root * 2);//左子树
	CBT[root] = data[num ++]; 
	inorder(root * 2 + 1); //右子树 
}

int main() {
	scanf("%d", &n);
	for(int i = 1; i <= n; i ++) {
		scanf("%d", &data[i]);
	}
	sort(data + 1, data + n + 1);
	inorder(1);
	for(int i = 1; i <= n; i ++) {
		if(i > 1) printf(" ");
		printf("%d", CBT[i]);
	}
	return 0;
} 

注意：根节点下标必须为1。root > n是递归边界。根节点赋值：CBT[root] = data[num ++];

• A1099 Build a Binary Search Tree
  题意：将给定数据填入二叉树，使得满足BST。
  思路：题目给出节点编号，因此用静态二叉链表存储。**由于BST的中序遍历是递增序列，因此可以将读入的序列排序，这就是这棵二叉树的中序遍历结果。**然后可以中序遍历读入的二叉树结构，将递增序列填入节点中。最后层序遍历该二叉树。

const int maxn = 110;
int data[maxn];

struct Node {
	int data;
	int lchild;
	int rchild;
} node[maxn];

int num = 0;
void inorder(int root) {
	if(root == -1) return;//注意递归结束条件
	inorder(node[root].lchild);
	node[root].data = data[num ++];
	inorder(node[root].rchild);
}

int cnt = 0;
void layerOrder(int root) {
	queue<int> q;
	q.push(root);
	while(!q.empty()) {
		int front = q.front();
		q.pop();
		if(cnt ++ > 0) printf(" ");
		printf("%d", node[front].data);
		if(node[front].lchild != -1) q.push(node[front].lchild);
		if(node[front].rchild != -1) q.push(node[front].rchild);
	}
}

int main() {
	int n;
	scanf("%d", &n);
	for(int i = 0; i < n; i ++) {
		scanf("%d %d", &node[i].lchild, &node[i].rchild);
	}
	for(int i = 0; i < n; i ++) {
		scanf("%d", &data[i]);
	}
	sort(data, data + n);
	inorder(0);
	layerOrder(0);
	return 0;
}

9.5 平衡二叉树(AVL树)

9.5.1 AVL树的定义

AVL树仍然是一棵BST，树的高度在每次插入元素后仍然能保持O(logN)级别，使得查询操作仍然是O(logN)级别。平衡指的是左子树和右子树的高度差绝对值不超过1。左子树和右子树的高度之差成为节点的平衡因子。
AVL的树的结构中需要加入一个变量height。

struct node {
	int v, height;
	node *lchild, *rchild;
};
// 新建节点
node* newNode(int v) {
	node* Node = new node;
	Node->v = v;
	Node->height = 1;
	Node->lchild = Node->rchild = NULL;
	return Node;
}
//获得节点root所在子树的当前高度
int getHeight(node* root) {
	if(root == NULL) return 0;
	return root->height;
}
//计算平衡因子
int getBalanceFactor(node* root) {
	return getHeight(root->lchild) - getHeight(root->rchild);
}

不直接记录平衡因子，而记录高度的原因是没办法通过子树的平衡因子得到当前节点的平衡因子。节点root所在子树的height等于其左子树与右子树的height的较大值加1。

//更新节点root的height
void updateHeight(node* root) {
	root->height = max(getHeight(root->lchild), getHeight(root->rchild)) + 1;
}

9.5.2 AVL树基本操作

• 查找

void search(node* root, int x) {
	if(root == NULL) {
		printf("search failed\n");
		return;
	}
	if(x == root->data) {
		printf("%d\n", root->data);
	}
	else if(x < root->data) {
		search(root->lchild, x);
	}
	else {
		search(root->rchild, x);
	}
}

• 左旋
  

左旋的步骤：
（1）让B的左子树成为A的右子树
（2）让A成为B的左子树
（3）将根节点设为B

//左旋，注意到首尾连接的形式，别忘了更新高度
void L(node* &root) {
	node* temp = root->rchild;
	root->rchild = temp->lchild;
	temp->lchild = root;
	updateHeight(root);
	updateHeight(root);
	root = temp;
}

• 右旋
  

右旋的步骤：
（1）让A的右子树成为B的左子树
（2）让B成为A的右子树
（3）将根节点设为A

//右旋，注意到首尾连接的形式，别忘了更新高度
void R(node* &root) {
	node* temp = root->lchild;
	root->lchild = temp->rchild;
	temp->rchild = root;
	updateHeight(root);
	updateHeight(temp);
	root = temp;
}

• 插入
  关于插入，只要把最靠近插入节点的失衡节点调整到正常，路径上的所有节点就会平衡。

平衡因子为2的情况（左子树比右子树高2），分为LL型和LR型（LL和LR只表示树型）。
A的左孩子的平衡因子为1是LL型，为-1是LR型。

LL型：右旋

LR型：左右旋

平衡因子为-2的情况（左子树比右子树低2,图错），分为RR型和RL型（RR和RL只表示树型）。
A的右孩子的平衡因子为-1是RR型，为1是RL型。

RR型：左旋

RL型：右左旋

总结：

AVL树的插入在BST的插入基础上增加平衡操作，从下往上哦按段节点是否失衡，需要在每个inser函数之后更新当前子树的高度，然后根据树型(LL、LR、RR、RL)进行对应的旋转操作。

//插入权值为v的节点
void insert(node* &root, int v) {
	if(root == NULL) {
		root = newNode(v);
		return;
	}
	if(v < root->v) {
		insert(root->lchild, v);
		updateHeight(root);
		if(getBalanceFactor(root) == 2) { //L
			if(getBalanceFactor(root->lchild) == 1) { //LL型	
				R(root);
			}
			else if(getBalanceFactor(root->lchild) == -1) { //LR型
				L(root->lchild);
				R(root);
			}
		}
		else { 
			insert(root->rchild, v);
			updateHeight(root);
			if(getBalanceFactor(root) == -2)  { //R
				if(getBalanceFactor(root->rchild) == -1) { //RR型
					L(root);
				}
				else if(getBalanceFactor(root->rchild) == 1) { //RL型
					R(root->rchild);
					L(root);
				}
			}
		}
	}
}

• AVL树的建立
  只需依次插入n个节点即可。

node* Create(int data[], int n) {
	node* root = NULL;
	for(int i = 0; i < n; i ++) {
		insert(root, data[i]);
	}
	return root;
}

9.6 并查集

9.6.1 并查集的定义

并查集是一种维护集合的数据结构。并：Union，查：Find，集：Set。
并查集支持两个操作：
（1）合并：合并两个集合
（2）查找：判断两个元素是否在一个集合。

实现：一个数组: int father[N];,其中father[i]表示元素i的父节点，父亲节点本身也是集合内的元素（1 <= i <= N）。如果father[i] == i,说明元素i是该集合的根节点。对同一个集合来说只存在一个根节点，且将其作为所属集合的标识。

9.6.2 并查集的基本操作

• 初始化
  一开始，每个元素都是一个独立的集合。

for(int i = 1; i <= N; i ++) {
	father[i] = i;
}

• 查找
  由于一个集合只存在一个根节点，因此查找就是对给定节点寻找其根节点。实现方式可以是递归或递推。（反复寻找父亲节点，直至找到根节点(father[i] == i)）。

//递推版
int findFather(int x) {
	while(x != father[x]) {
		x = father[x];
	}
	return x;
}
//递归版
int findFather(int x) {
	if(x == father[x]) return x;
	else return findFather(father[x]);
}

• 合并
  合并是指把两个集合合并成一个集合，题目一般给出两个元素，要求把这两个元素所在的集合合并。
  实现方式是判断两个元素是否属于同一集合，当两个元素在不同集合才合并，把其中一个集合根节点的父亲指向另一集合的根节点。

void Unoin(int a, int b) {
	int faA = findFather(a);
	int faB = findFather(b);
	if(faA != faB) {
		father[faA] = faB;
	}
}

并查集的性质：并查集产生的每一个集合都是一棵树。

9.6.3 路径压缩

优化。把当前查询节点的路径上的所有节点的父亲都指向根节点。 查询复杂度降为O(1)。

//递推
int findFather(int x) {
	int a = x;
	while(x != father[x]) {
		x = father[x];
	}
	//至此根节点为x
	while(a != father[a]) {
		int z = a;
		a = father[a];
		father[z] = x;
	}
	return x;
}
//递归
int findFather(int v) {
	if(v == father[v]) return v;
	else {
		int F = findFather(father[v]);
		father[v] = F;
		return F;
	}
}

• A1107 Social Clusters
  题意：具有部分相同爱好的人聚成一类。
  思路：使用并查集。注意三要素：初始化、查找(路径压缩)、合并。
  技巧1：第一次读入一个爱好时，将course设置成人员编号i，之后读入的爱好，将编号i和之前的course[h]并起来.
  技巧2：使用一个哈希表统计集合个数。

const int maxn = 1010;
int father[maxn];
int course[maxn] = {0};
int isRoot[maxn] = {0};

void init(int n) {
	for(int i = 1; i <= n; i ++) {
		father[i] = i;
		isRoot[i] = 0;
	}
}

bool cmp(int a, int b) {
	return a > b;
}

int findFather(int h) {
	int a = h;
	while(h != father[h])
		h = father[h];
	while(a != father[a]) {
		int z = a;
		a = father[a];
		father[z] = h;
	}
	return h;
}

void Union(int a, int b) {
	int faA = findFather(a);
	int faB = findFather(b);
	if(faA != faB) 
		father[faA] = faB; 
} 
int main() {
	int n, k, h;
	scanf("%d", &n);
	init(n);
	for(int i = 1; i <= n; i ++) {
		scanf("%d:", &k);
		for(int j = 0; j < k; j ++) {
			scanf("%d", &h);
			if(course[h] == 0) {
				course[h] = i;
			}
			Union(i, findFather(course[h]));
		}
	}
	for(int i = 1; i <= n; i ++) {
		isRoot[findFather(i)] ++;
	}
	int ans = 0;
	for(int i = 1; i <= n; i ++) {
		if(isRoot[i] != 0) {
			ans ++;
		}
	}
	printf("%d\n", ans);
	sort(isRoot + 1, isRoot + 1 + n, cmp); 
	int cnt = 0;
	for(int i = 1; i <= n; i ++) {
		if(isRoot[i] != 0) {
			if(cnt ++ > 0) printf(" ");
			printf("%d", isRoot[i]);
		}
	}
	return 0;
} 

9.7 堆

9.7.1 堆的定义与基本操作

堆是一棵完全二叉树。树中每个节点的值都不小于(或不大于)其左右孩子节点的值。
其中父亲节点的值>=孩子节点的值成为大堆顶，<=成为小堆顶。
优先队列默认使用大堆顶。
用数组存储完全二叉树。节点按层序存储在数组中，其中第一个节点将存在1号位；数组i号位的左孩子是2i号，右孩子是2i + 1号。

const int maxn = 100;
int heap[maxn], n = 10;

• 向下调整: O(logN)

void downAdjust(int low, int high) {
	int i = low, j = i * 2;
	while(j <= high) {
		if(j + 1 <= hight && heap[j + 1] > heap[j])
			j ++;//让j存储较大孩子下标
		if(heap[j] > heap[i]) {
			swap(heap[j], heap[i]);
			i = j;//保持i为欲调整节点，j为i的左孩子
			j = i * 2;
		}
		else {
			break;
		}
	}
}

假设序列元素有n个，完全二叉树的叶子节点个数为ceil(n / 2), 数组下标在[1, floor(n / 2)]范围内都是非叶子节点。于是可以从floor(n / 2)开始倒着枚举节点，对每个遍历到节点i进行[i, n]范围的调整。这种做法保证每个节点都是以其为根节点的子树中的权值最大的节点。

• 建堆: O(n)

void createHeap() {
	for(int i = n / 2; i >= 1; i --) {
		downAdjust(i, n);
	}
}

• 删除堆顶元素 ： O(logN)

void deleteTop() {
	heap[1] = heap[n --];
	downAdjust(1, n);
}

添加一个元素，可以添加在数组最后，然后向上调整。

• 向上调整：O(logN)

void upAdjust(int low, int high) {
	int i = high, j = i / 2;
	while(j >= low) {
		if(heap[j] < heap[i]) {
			swap(heap[j], heap[i]);
			i = j;
			j = i / 2;
		}
		else {
			break;
		}
	}
}

• 添加元素(插入)

void insert(int x) {
	heap[++ n] = x;
	upAdjust(1, n);
}

9.7.2 堆排序

使用堆结构堆序列进行排序。

void heapSort() {
	createHeap();
	for(int i = n; i > 1; i --) {
		swap(heap[i], heap[1]);//堆顶换出
		downAdjust(1, i - 1);//堆大小减1后调整堆顶
	}
}

• A1098 Insertion or Heap Sort
  提醒自己的点：定义了全局变量n，在主函数又重新定义了n，导致出错。
  先写出插入排序和堆排序，在每一步排序前判断序列是否和目标序列相同，相同则在进行一趟排序后返回。

const int maxn = 110;
int origin[maxn], tempOri[maxn], changed[maxn];

int n;
bool isSame(int a[], int b[]) {
	for(int i = 1; i <= n; i ++)
		if(a[i] != b[i])
			return false;
	return true;
}

void printArray(int a[]) {
	for(int i = 1; i <= n; i ++) {
		if(i > 1) printf(" ");
		printf("%d", a[i]);
	}
}

bool insertionSort() {
	bool flag = false;
	for(int i = 2; i <= n; i ++) {
		if(i != 2 && isSame(tempOri, changed)) {
			flag = true;
		}
		sort(tempOri + 1, tempOri + i + 1); //注意这里的范围是1~i+1
		if(flag == true)
			return true;
	}
	return false;
} 

void downAdjust(int low, int high) {
	int i = low, j = i * 2;
	while(j <= high) {
		if(j + 1 <= high && tempOri[j + 1] > tempOri[j])
			j ++;
		if(tempOri[j] > tempOri[i]) {
			swap(tempOri[j], tempOri[i]);
			i = j;
			j = i * 2;
		}
		else 
			break;
	}
}

void heapSort() {
	bool flag = false;
	for(int i = n / 2; i >= 1; i --)
		downAdjust(i, n);//建堆 
	for(int i = n; i > 1; i --) {
		if(i != n && isSame(tempOri, changed)) {
			flag = true;
		}
		swap(tempOri[i], tempOri[1]);
		downAdjust(1, i - 1);
		if(flag == true) {
			printArray(tempOri);
			return;
		}
	}
}



int main() {
	scanf("%d", &n);
	for(int i = 1; i <= n; i ++) {
		scanf("%d", &origin[i]);
		tempOri[i] = origin[i];
	}
	for(int i = 1; i <= n; i ++) {
		scanf("%d", &changed[i]);
	}
	if(insertionSort()) {
		printf("Insertion Sort\n");
	printArray(tempOri);
	
	else {
		printf("Heap Sort\n");
		for(int i = 1; i <= n; i ++) {
			tempOri[i] = origin[i];
		}
		heapSort();
	}
	return 0;
}

9.8 哈夫曼树

带权路径长度：叶子节点的取值乘以其路径长度。
树的带权路径长度(wpl)等于他所有叶子节点的带权路径长度之和。
哈夫曼树的构建思想：反复选择最小的两个元素，合并，直至剩下一个元素。 可以用堆或优先队列执行这种策略。

小堆顶优先队列：

priority_queue<long long, vector<long long>, greater<long long>> q;

9.8.1 哈夫曼编码

非叶子节点时某个叶节点的前缀。任何叶子节点编号不会为其他任何一个节点编号的前缀。 前缀编码。
字符串编码成01串后的长度实际上是树的带权路径长度。
哈夫曼编码是能使给定字符串编码成01串后长度最短的前缀编码。
哈夫曼编码是针对确定的字符串来讲的。

10 图

顶点(vertex)和边(edge)组成。G(V, E）。
分为有向图和无向图。
顶点的度：和该顶点相连的边数。
顶点和边都可以有一定属性，称为为权值。点权和边权。

10.1 图的存储

存储方式有两种：邻接矩阵和邻接表。

• 邻接矩阵
  二维数组G[N][N], G[i][j] = 0表示不存在边。G[i][j]也可存放边权。不存在可设为0或-1或inf。
  适合顶点数目不太大(一般不超过1000)的题目.
• 邻接表
  顶点编号0~ n-1。把顶点的所有出边放在一个列表中，N个顶点就会有N个列表，成为邻接表，记为Adj[N]。

使用vector实现邻接表：
vector<int> Adj[N];

如果需要同时存放边的终点编号和边权，建立结构体Node：

struct Node{
	int v; //终点编号
	int w; //边权
	Node(int _v, int _w) : v(_v), w(_w) {}
}；
vector<Node> Adj[N];

10.2 图的遍历

10.2.1 DFS遍历图

连通分量：无向图中，如果两个顶点相互可达，成为连通。图可以分为连通图和非连通图。非连通图的极大连通子图成为连通分量。
强连通分量：有向图中，如果两个顶点可以各自通过一条有向路径到达另一个顶点，成为两个顶点强连通。G的任意两个顶点强连通则称为强连通图。否则称为非强连通图，其中极大强连通子图称为强连通分量。
连通分量和强连通分量统称为连通块。

遍历整个图，需要对每个连通块分别进行遍历。DFS遍历图的基本思想是将经过的顶点设置为已访问，下次递归碰到则不在处理直至整个图的顶点被标为已访问。

• 伪代码：

DFS(u) {
	vis[u] = true;
	for(从i出发能到达的所有顶点v) {
		if(vis[b] == false)
			DFS(v);
	}
}
DFSTrave(G) {
	for(G的所有顶点u) {
		if(vis[u] == false)
			DFS(u);
	}
}

• DFS遍历图的模板

const int MAXV = 1000;
const int INF = 1000000000;

邻接矩阵版:

int n, G[MAXV][MAXV];
bool vis[MAXV] = {false};

void DFS(int u, int depth) {
	vis[u] = true;
	for(int v = 0; v < n; v ++) {
		if(vis[v] == false && G[u][v] != INF) {
			DFS(v, depth + 1);
		}
	}
}

void DFSTrave() {
	for(int u = 0; u < n; u ++) {
		if(vis[u] == false) {
			DFS(u, 1);
		}
	}
}

邻接表版：

vector<int> Adj[MAXV];
int n;
bool vis[MAXV] = {false};

void DFS(int u, int depth) {
	vis[u] = true;
	for(int i = 0; i < Adj[u].size(); i ++) {
		int v = Adj[u][i];
		if(vis[v] == false)
			DFS(v, depth + 1)'
	}
}

void DFSTrave() {
	for(int u = 0; u < n; u ++) {
		if(vis[u] == false)
			DFS(u, 1);	
	}
}

10.2.2 BFS遍历图

建立一个队列，把初始节点加入队列，每次取出队首节点，把从该节点出发能达到的未曾加入过队列（而不是未访问（原因：有的节点已经在队列中之后会访问））的节点全部加入队列。

• 伪代码

BFS(u) {
	queue q;
	u入队;
	inq[u] = true;
	while(q 非空) {
		取出队首元素u进行访问;
		for(从u出发可达的所有节点v) {
			if(inq[v] == false) {
				将v入队;
				inq[v] = true;
			}
		}
	}
}
BFSTrave(G) {
	for(G的所有顶点u) {
		if(inq[u] == false)
			BFS(u);
	}
}

• BFS遍历图的模板
  邻接矩阵版：

int n G[MAXV][MAXV];
bool inq[MAV] = {false};

void BFS(int u) {
	queue<int> q;
	q.push(u);
	inq[u] = true;
	while(!q.empty()) {
		int u = q.front();
		q.pop();
		for(int v = 0; v < n; v ++) {
			if(inq[v] == false && G[u][v] != INF) {
				q.push(v);
				inq[v] = true;
			}
		}
	}
}

void BFSTrave() {
	for(int u = 0; u < n; u ++) {
		if(inq[u] == false)
			BFS(u);
	}
}

邻接表版：

vector<int> Adj[MAXV];
int n;
bool inq[MAXV] = {false};

void BFS(int u) {
	queue<int> q;
	q.push(u);
	inq[u] = true;
	while(!q.empty()) {
		int u = q.front();
		q.pop();
		for(int i = 0; i < Adj[u].size(); i ++) {
			int v = Adj[u][i];
			if(inq[u][v] == false) {
				q.push(v);
				inq[v] = true;
			}
		}
	}
}

void BFSTrave() {
	for(int u = 0; u < n; u ++) {
		if(inq[u] == false) 
			BFS(u);
	}
}

与树的BFS一样，给定BFS初始点的情况下，可能需要输出该连通块的所有其他顶点的层号。这时只需修改少量内容即可。

struct Node {
	int v;
	int layer;
};
vector<Node> Adj[N];
void BFS(int s) {
	queue<Node> q;
	Node start;
	start.v = s;
	start.layer = 0;
	q.push(start);
	inq[start.v] = true;
	while(!q.empty()) {
		Node topNode = q.front();
		q.pop();
		int u = topNode.v;
		for(int i = 0; i < Adj[u].size(); i ++) {
			Node next = Adj[u][i];
			next.layer = topNode.layer + 1;
			if(inq[next.v] == false) {
				q.push(next);
				inq[next.v] = true;
			}
		}
	}
}

• A1013 Battle Over Cities
  题意: 求图中去掉一个顶点后连通块的个数减1。DFS。
  坑点：每次查询前都需要重置vis数组和重置边的连接情况。因此用memset每次重置vis数组。至于边的连接情况，则不直接在邻接矩阵中修改，而是在DFS中判断如果顶点是当前去掉的顶点就直接返回。

const int maxn = 1000;
int G[maxn][maxn] = {0};
bool vis[maxn] = {false};
int n, cur;

void DFS(int u, int depth) {
	if(u == cur) return;
	vis[u] = true;
	for(int v = 1; v <= n; v ++) {
		if(vis[v] == false && G[u][v] != 0 && G[v][u] != 0)
			DFS(v, depth + 1);
	}
}


int DFSTrave(int v) {
	int cnt = 0;
	for(int u = 1; u <= n; u ++) {
		if(v != u && vis[u] == false) {
			DFS(u, 1);
			cnt ++;
		}
	}
	return cnt;
}

int main() {
	int m, k, c1, c2;
	scanf("%d %d %d", &n, &m, &k);
	for(int i = 0; i < m; i ++) {
		scanf("%d %d", &c1, &c2);
		G[c1][c2] = G[c2][c1] = 1;
	}
	for(int i = 0; i < k; i ++) {
		scanf("%d", &cur);
		memset(vis, false, sizeof(vis));
		printf("%d\n", DFSTrave(cur) - 1);
	}
	return 0;
}

法二：邻接表实现版
法三： 并查集
判断无向图每条边的两个顶点是否在同一个集合内，如果在同一个集合内则不做处理；否则将这两个顶点加入同一个集合。最后统计集合个数即可。

• A1021 Deepest Root
  题意：计算图是否连通，若连通，n个节点n-1条边一定是树，那么计算树的最大高度。
  思路：使用并查集计算连通块个数，若个数>1说明不连通，输出error，若连通则找任一节点DFS遍历得到一个最深的根的节点集合。然后在这个集合中选任一节点DFS遍历计算最深的根的节点集合。将两个集合合并，便是要求的最深的根节点集合。（本题的关键点，比较难想到）

DFS遍历时传递的遍历包括节点u，当前树高height，前一个个节点编号pre。由于是无向图，避免遍历时走回头路，因此记录前一个节点编号pre，遍历时跳过pre。注意此DFS不仅仅是遍历图，还要算出最大高度。 方法如下：

int maxH = 0;
set<int> temp, ans;

void DFS(int u, int height, int pre) {
	if(height > maxH) {
		temp.clear();
		temp.insert(u);
		maxH = height;
	}
	else if(maxH == height) {
		temp.insert(u);
	}
	
	for(int i = 0; i < Adj[u].size(); i ++) {
		if(Adj[u][i] == pre) continue;
		DFS(Adj[u][i], height + 1, u);
	}
}

计算连通块个数的方法：

int calBlock(int n) {
	int block = 0;
	for(int i = 1; i <= n; i ++) {
		isRoot[findFather(i)] = true;
	}
	
	for(int i = 0; i <= n; i ++) {
		if(isRoot[i])
			block ++;
	}
	return block;
}

注意并查集的操作：先初始化，然后读入边时合并节点。然后在计算连通块个数。
主函数:

int main() {
	int n;
	scanf("%d", &n);
	init(n);
	for(int i = 0; i < n - 1; i ++) {
		int a, b;
		scanf("%d %d", &a, &b);
		Adj[a].push_back(b);
		Adj[b].push_back(a);
		Union(a, b);
	}
	
	int block = calBlock(n);
	if(block > 1) printf("Error: %d components\n", block);
	else {
		DFS(1, 1, -1);
		ans = temp;
		DFS(*ans.begin(), 1, -1);
		ans.insert(temp.begin(), temp.end());
		for(auto it = ans.begin(); it != ans.end(); it ++) {
			printf("%d\n", *(it));
		}		
	}
	return 0;
}

• A1034 Head of a Gang
  本题应视为无向图（很容易想成有向图），根据通话分为若干组，每个组的总边权设为组内所有通话长度总和，每个人的点权设为该人参与的通话长度之和。超过阈值k，满足成员人数大于2的组视为Gang，组内点权最大视为head。输出head和人数。
  思路: DFS遍历每个连通块，获取每个连通块的头目，成员个数，总边权。满足Gang的组记录下来。
  技巧1：姓名和编号的对应关系。map<string, int>, map<int, string>。

int change(string str) {
	if(str2num.find(str) != str2num.end()) {
		return str2num[str];
	}
	else {
		str2num[str] = numPerson;
		num2str[numPerson] = str;
		return numPerson ++;
	}
} 

注意点：每个节点访问后不应在被访问，但图中可能有环，为了边权不被漏加，需要先累加边权，在递归访问节点，要避免边权被重复计算，需要在累加边权后将边删除，避免走回头路和重复计算边权。
读入数据时应处理好点权和边权。
也可用并查集解决: 用一个数组记录根节点总边权，一个数组记录根节点成员人数。

DFS:

const int N = 2010;
const int INF = 1000000000;

map<string, int> str2num; //姓名->编号 
map<int, string> num2str; //编号->姓名 
map<string, int> Gang; //head-> 人数
int G[N][N] = {0}, weight[N] = {0}; //邻接矩阵G，点权 weight 
bool vis[N] = {0};
int n, k, numPerson = 0;//点数n，阈值k ，总人数numPerson 

void DFS(int u, int& head, int& numMember, int& totalValue) {
	numMember ++;
	vis[u] = true;
	if(weight[u] > weight[head]) {
		head = u;
	}
	
	for(int i = 0; i < numPerson; i ++) {
		if(G[u][i] > 0) {
			totalValue += G[u][i];
			G[u][i] = G[i][u] = 0; //删除这条边防止回头
			if(vis[i] == false) {
				DFS(i, head, numMember, totalValue);
			} 
		}
	}
}

DFS遍历整个图：

void DFSTrave() {
	for(int i = 0; i < numPerson; i ++) {
		if(vis[i] == false) {
			int head = i, numMember = 0, totalValue = 0;
			DFS(i, head, numMember, totalValue);
			if(numMember > 2 && totalValue > k) {
				Gang[num2str[head]] = numMember;
			}
		}
	}
}

主函数：

int main() {
	int w;
	string name1, name2;
	cin >> n >> k;
	for(int i = 0; i < n; i ++) {
		cin >> name1 >> name2 >> w;
		int id1 = change(name1);
		int id2 = change(name2);
		weight[id1] += w;
		weight[id2] += w;
		G[id1][id2] += w;
		G[id2][id1] += w;
	}
	DFSTrave();
	cout << Gang.size() << endl;
	for(auto it = Gang.begin(); it != Gang.end(); it ++) {
		cout << it->first << " " << it->second << endl;
	}
	return 0;
}

• A1076 Forwards in Weibo
  题意：求L跳邻居节点总数量。因此用BFS较好。
  坑点：注意边的连接方向。数据格式是节点A，A follow B，可以Forward的用户为L层关注者，但是遍历时A不是根节点，因此将变的连接方向反转。即边的方向表示被关注，而不是关注，这样就可以通过邻接表BFS了。

const int maxn = 1010;

struct node {
	int id;
	int layer;
};

vector<node> Adj[maxn];
bool inq[maxn] = {false};


int BFS(int s, int L) {
	int numForward = 0;
	queue<node> q;
	node start;
	start.id = s;
	start.layer = 0;
	q.push(start);
	inq[start.id] = true;
	while(!q.empty()) {
		node topNode = q.front();
		q.pop();
		int u = topNode.id;
		for(int i = 0; i < Adj[u].size(); i ++) {
			node next = Adj[u][i];
			next.layer = topNode.layer + 1;
			if(inq[next.id] == false && next.layer <= L) {
				q.push(next);
				inq[next.id] = true;
				numForward ++;
			}
		} 
	}
	return numForward;
}

int main() {
	int N, L;
	node user;
	scanf("%d %d", &N, &L);
	for(int i = 1; i <= N; i ++) {
		user.id = i;
		int m, uid;
		scanf("%d", &m);
		for(int j = 0; j < m; j ++) {
			scanf("%d", &uid);
			Adj[uid].push_back(user);
		}
	}
	int k, s;
	scanf("%d", &k);
	for(int q = 0; q < k; q ++) {
		memset(inq, false, sizeof(inq));
		scanf("%d", &s);
		printf("%d\n", BFS(s, L));
	}
	return 0;
}

10.3 最短路径

对任意给出的图G(V, E)和起点、终点，如何求从S到T的最短路径。
解决最短路径的常见算法：Dijkstra算法、Bellman-Ford算法、SPFA算法和Floyd算法。

10.3.1 Dijkstra算法

迪杰斯特拉算法解决单源最短路径问题。即给定图G和起点s，通过算法得到S到其他每个顶点的最短距离。
基本思想：对图G设置集合S，存放已被访问的顶点，然后每次从集合V - S中选择与起点s的最短距离最小的一个顶点(u),访问并加入集合S。之后令顶点u为中介点，优化起点s与所有从u能到达的其他的顶点v之间的最短距离。执行n次这样的操作直到集合S已包含所有顶点。

• 策略：设置集合S存放已被访问的顶点，然后执行n次以下两个步骤：
  （1）每次从集合V - S中选择与起点s最短距离最小的一个顶点u，访问并加入集合S。
  （2）之后，令顶点u为中介点，优化起点s与所有从u能到达的顶点v之间的最短距离。

• 具体实现：两个关键点：集合S的实现、起点s到达顶点V_i的最短距离的实现。
  （1）集合S：bool vis[n]; true表示已被访问，false表示未访问。
  （2）int d[n]表示起点s到达顶点V_i的最短距离。d[s] = 0, 其他初始化为一个很大的数INF。

• 伪代码

Dijkstra(G, d[], s) {
	init();
	for(循环n次) {
		u = 使d[u]最小的还未被访问的顶点的标号;
		记u已被访问;
		for(从u出发能到达的所有顶点v) {
			if(v未被访问 && 以u为中介点使s到顶点v的最短距离d[v]更优) {
				优化d[v];
				令v的前驱为u;//记录最短路径
			}
		}
	}
}

• 模板
  邻接矩阵版Dijkstra：适用于v不超过1000的情况。复杂度O(V²)

const int MAXV = 1000;
const int INF = 1000000000; //or 0x3fffffff;

int n, G[MAXV][MAXV];
int d[MAXV];
int pre[MAXV];
bool vis[MAXV] = {false};

void Dijkstra(int s) {
	fill(d, d + MAXV, INF); //fill函数将整个d数组赋值为INF(慎用memset)
	d[s] = 0;
	for(int i = 0; i < n; i ++) { //循环n次
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j ++) {//找到未访问的顶点中最小的d[u]
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return; //找不到说明剩下的顶点和起点s不连通
		vis[u] = true; //标记u为已访问
		for(int v = 0; v < n; v ++) {
			//如果v未访问且u能到达v且以u为中介点可使d[v]更优
			if(vis[v] == false && G[u][v] != INF && d[u] + G[u][v] < d[v]) {
				d[v] = d[u] + G[u][v]; //优化d[v]
				pre[v] = u; //记录v的前驱顶点是u
			}
		}
	}
}

邻接表版Dijkstra：O(V² + E)。可以使用堆优化寻找最小d[u]，最简便的写法是利用STL的priority_queue, 使得复杂度降到O(VlogV + E).

struct Node {
	int v, dis; //v为bian的目标顶点，dis为边权。
}；
vector<Node> Adj[MAXV];
int n;
int d[MAXV] = {false};

void Dijkstra(int s) {
	fill(d, d + MAXV, INF);
	d[s] = 0;
	for(int i = 0; i < n; i ++) { //循环n次
		int u = -1, MIN = INF; //找到未访问的顶点中d[]最小的u
		for(int j = 0; j < n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return;//找不到
		vis[u] = true;
		//只有下面这个for循环与邻接矩阵写法不同
		for(int j = 0; j < Adj[u].size(); j ++) {
			int v = Adj[u][j].v;//通过邻接表直接获得能到达的顶点v
			if(vis[v] == false && d[u] + Adj[u][j].dis < d[v]) {
				d[v] = d[u] + Adj[u][j].dis;//优化d[v]
				pre[v] = u;//记录v的前驱顶点是u
			}
		}
	}
}

• 主函数：千万不要忘了初始化图为INF

int main() {
	int u, v, w;
	scanf("%d%d%d", &n, &m, &s);
	fill(G[0], G[0] + MAXV * MAXV, INF);
	for(int i = 0; i < m; i ++) {
		scanf("%d%d%d", &u, &v, &w);
		G[u][v] = w;
	}
	Dijkstra(s);
	for(int i = 0; i < n; i ++) {
		printf("%d ", d[i]);
	}
	return 0;
}

• 适用范围：Dijkstra算法只适用于所有边权非负的情况，如果边权出现负数最好使用SPFA算法。 如果题目给的是无向边，只需报无向边当做两条指向相反的有向边即可。
• 求最短路径：

void DFS(int s, int v) {
	if(v == s) {
		printf("%d\n", s);
		return;
	}
	DFS(s, pre[v]);
	printf("%d\n", v);
}

• 扩展
  有多条最短路径，题目就会给出第二标尺(第一标尺是距离) ,要求选出最优的一条路径。
  第二标尺通常为以下三种或其组合：
  （1）给每条边再增加一个边权(如花费)，然后要求在最短路径有多条是要求路径上花费最小。
  （2）给每个点再增加一个点权(如每个城市能收集的物资),然后有多条时要求路径上的点权最大(或最小)。
  （3）直接问有多少条最短路径。
  解法： 都只需增加一个数组来存放新增的边权或点权或最短路径条数。然后在Dijkstra算法中修改优化d[v]的那个步骤即可。
  代码修改及解释：

1. 新增边权。cost[u][v]表示u->v的花费，新增一个数组c[],令从起点s到u的最少花费为c[u],初始化时只有c[s] = 0,其余非INF。

for(int v = 0; v < n; v ++) {
	if(vis[v] == false && G[u][v] != INF) {
		if(d[u] + G[u][v] < d[v]) {
			d[v] = d[u] + G[u][v];
			c[v] = c[u] + cost[u][v];
		}
		else if(d[u] + G[u][v] == d[v] && c[u] + cost[u][v] < c[v]) {
			c[v] = c[u] + cost[u][v];
		}
	}
}

2. 新增点权。weight[u]表示城市u的物资数目，增加一个数组w[],令从起点s到达u可收集的最大物资为w[u], 初始化时只有w[s]为weight[s],其余均为0。

for(int v = 0; v , n; v ++) {
	if(vis[v] == false && G[u][v] != INF) {
		if(d[u] + G[u][v] < d[v]) {
			d[v] = d[u] + G[u][v];
			w[v] = w[u] + weight[v];
		}
		else if(d[u] + G[u][v] == d[v] && w[u] + weight[v] > w[v]) {
			w[v] = w[u] + weight[v];
		}
	}
}

3.求最短路径条数。只需增加一个数组num[]，令从起点s到达顶点u的最短路径数为num[u]，初始化时只有num[s] = 1,其余均为0。

for(int v = 0; v < n; v++) {
	if(vis[v] == false && G[u][v] != INF) {
		if(d[u] + G[u][v] < d[v]) {
			d[v] = d[u] + G[u][v];
			num[v] = num[u];
		}
		else if(d[u] + G[u][v] == d[v]) {
			num[v] += num[u];
		}
	}
}

• A1003 Emergency
  题意：求单源最短路径条数以及终点处收集的物资。
  注意点：邻居矩阵一定要初始化图为INF。 开的num[], w[]数组别忘了在Dijkstra函数中初始化。

const int maxn = 510;
const int INF = 1000000000;
int n, G[maxn][maxn];
bool vis[maxn] = {false};
int d[maxn];
int num[maxn], weight[maxn];
int w[maxn];
void Dijkstra(int s) {
	fill(d, d + maxn, INF);
	memset(num, 0, sizeof(num));
	memset(w, 0, sizeof(num));
	d[s] = 0;
	num[s] = 1;
	w[s] = weight[s]; 
	for(int i = 0; i < n; i ++) {
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return;
		vis[u] = true;
		for(int v = 0; v < n; v ++) {
			if(vis[v] == false && G[u][v] != INF ) {
				if(d[u] + G[u][v] < d[v]) {
					d[v] = d[u] + G[u][v];
					w[v] = w[u] + weight[v];
					num[v] = num[u];
				}
				else if(d[u] + G[u][v] == d[v]) {
					num[v] += num[u];
					if(w[u] + weight[v] > w[v]) {
						
						w[v] = w[u] + weight[v];
					}
				}
			}
		}
	}
}

int main() {
	int m, s, t;
	scanf("%d %d %d %d", &n, &m, &s, &t);
	for(int i = 0; i < n; i ++) {
		scanf("%d", &weight[i]);
	}
	fill(G[0], G[0] + maxn * maxn, INF);
	for(int i = 0; i < m; i ++) {
		int u, v, len;
		scanf("%d %d %d", &u, &v, &len);
		G[u][v] = len;
		G[v][u] = len;
	}
	Dijkstra(s);
	printf("%d %d\n", num[t], w[t]);
	return 0;
}

• Dijkstra + DFS
  （1）使用Dijkstra算法记录所有最短路径。
  pre数组不在适用，使用vector<int> pre[MAXV]; (对要查询某个顶点u是否存在v的前驱中的题目，也可以把pre数组设置成set<int> pre;, 此时使用pre[v].count(u)；来查询比较方便)

vector<int> pre[MAXV];
void Dijkstra(int s) {
	fill(d, d + MAXV, INF);
	d[s] = 0;
	for(int i = 0; i < n; i ++) {
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return;
		vis[u] = true;
		for(int v= 0; v < n; v ++) {
			if(vis[v] == false && G[u][v] != INF) {
				if(d[u] + G[u][v] < d[v]) {
					d[v] = d[u] + G[u][v];
					pre[v].clear();
					pre[v].push_back(u);
				}
				else if(d[u] + G[u][v] == d[v]) {
					pre[v].push_back(u);
				}
			}
		}
	}
}

（2）DFS遍历所有路径，找出一条使第二标尺最优的路径。
现在遍历前驱节点会形成一个递归树。写DFS要求有：作为全局变量的第二标尺optValue；记录最优路径的数组path(使用vector存储)；临时记录DFS遍历到叶子节点的路径tempPath(vector)。
需要注意：叶子节点（即起点s）没法直接加入tempPath，需访问到叶子节点后临时加入。

int optValue;
vector<int> pre[MAXV];
vector<int> path, tempPath;
void DFS(int v) {
	if(v == st) { //如果访问到了叶子节点（递归边界）
		tempPtah.push_back(v);
		int value;
		计算路径tempPath上的value值;
		if(value 优于 optValue) {
			optValue = value;
			path = tempPath;
		}
		tempPath.pop_back();
		return;
	}
	//递归式
	tempPath.push_back(v); //将当前访问节点加入到临时路径tempPath的最后面
	for(int i = 0 ; i < pre[v].size(); i ++) {
		DFS(pre[v][i])	;
	}
	tempPath..pop_back();
}

（3）计算边权和或点权和

//边权之和
int value = 0;
for(int i = tempPath.size() - 1; i > 0; i --) { //倒序访问，循环条件为i>0
	int id = tempPath[i], idNext = tempPath[i - 1];
	value += V[id][idNext];
}
//点权之和
int value = 0;
for(int i = tempPath.size() - 1; i >= 0; i --) { //倒序访问，循环条件为i >= 0
	int id = tempPath[i];
	value += W[id];
}

• A1030 Travel Plan
  题意：求最短路径且花费最小。
  （1）Dijkstra

const int MAXV = 510;
const int INF = 1000000000;
int G[MAXV][MAXV], n;
bool vis[MAXV] = {false};
int d[MAXV], c[MAXV];
int cost[MAXV][MAXV];
int pre[MAXV];

void Dijkstra(int s) {
	fill(d, d + MAXV, INF);
	fill(c, c + MAXV, INF); //不要忘记初始化c和d
	d[s] = 0;
	c[s] = 0;
	for(int i = 0; i < n; i ++) {
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return;
		vis[u] = true;
		for(int v = 0; v < n; v ++) {
			if(vis[v] == false && G[u][v] != INF) {
				if(d[u] + G[u][v] < d[v]) {
					d[v] = d[u] + G[u][v];
					c[v] = c[u] + cost[u][v];
					pre[v] = u;
				}
				else if(d[u] + G[u][v] == d[v]) {
					if(c[u] + cost[u][v] < c[v]) {
						c[v] = c[u] + cost[u][v];
						pre[v] = u;
					}
				}
			}
		} 
	}
}

void DFS(int s, int v) {
	if(v == s) {
		printf("%d ", v);
		return;
	}
	DFS(s, pre[v]);
	printf("%d ", v);
}

int main() {
	int m, st, ed;
	scanf("%d %d %d %d", &n, &m, &st, &ed);
	fill(G[0], G[0] + MAXV * MAXV, INF);
	for(int i = 0; i < m; i ++) {
		int u, v;
		scanf("%d %d", &u, &v);
		scanf("%d %d", &G[u][v], &cost[u][v]);
		G[v][u] = G[u][v];
		cost[v][u] = cost[u][v];
	}
	Dijkstra(st);
	DFS(st, ed);
	printf("%d %d\n", d[ed], c[ed]);
	return 0;
} 

（2）Dijkstra + DFS:

const int MAXV = 510;
const int INF = 1000000000;
int G[MAXV][MAXV], cost[MAXV][MAXV], n, m, st, ed;
int d[MAXV], minCost = INF;
bool vis[MAXV] = {false};
vector<int> pre[MAXV];
vector<int> path, tempPath;


void Dijkstra(int s) {
	fill(d, d + MAXV, INF);
	d[s] = 0;
	for(int i = 0; i < n; i ++) {
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return;
		vis[u] = true;
		for(int v = 0; v < n; v ++) {
			if(vis[v] == false && G[u][v] != INF) {
				if(d[u] + G[u][v] < d[v]) {
					d[v] = d[u] + G[u][v];
					pre[v].clear();
					pre[v].push_back(u);
				}
				else if(d[u] + G[u][v] == d[v]) {
					pre[v].push_back(u);
				}
			}
		}
	}
}

void DFS(int v) {
	if(v == st) {
		tempPath.push_back(v);
		int tempCost = 0;
		for(int i = tempPath.size() - 1; i > 0; i --) {
			int id = tempPath[i], idNext = tempPath[i - 1];
			tempCost += cost[id][idNext];
		}
		if(tempCost < minCost) {
			minCost = tempCost;
			path = tempPath;
		}
		tempPath.pop_back();
		return;
	}
	tempPath.push_back(v);
	for(int i = 0; i < pre[v].size(); i ++) {
		DFS(pre[v][i]);
	}
	tempPath.pop_back();
}


int main() {
	scanf("%d %d %d %d", &n, &m, &st, &ed);
	int u, v;
	fill(G[0], G[0] + MAXV * MAXV, INF);
//	fill(cost[0], cost[0] + MAXV * MAXV, INF);
	for(int i = 0; i < m; i ++) {
		scanf("%d %d", &u, &v);
		scanf("%d %d", &G[u][v], &cost[u][v]);
		G[v][u] = G[u][v];
		cost[v][u] = cost[u][v];
	}
	Dijkstra(st);
	DFS(ed);
	for(int i = path.size() - 1; i >= 0; i --) {
		printf("%d ", path[i]);
	}
	printf("%d %d\n", d[ed], minCost); 
	return 0;
}

注意：顶点下标需根据题意确定是0~n-1，还是1~n，或者0~n。

• A1018 Public Bike Management
  题意：求带出去的自行车最少且带出去相同时带回来最少的最短路径。
  解法：Dijkstra + DFS。先求最短路径，在DFS寻找最优路径。
  坑点1：下标为0~n
  坑点2：存在既要带出去也要带回来的情况。这时要求带出去最少，如带出去相同求带回来最少的路径。
  技巧1：将点权cost -= Cmax / 2,这样由cost[i]的正负就可以知道是需要补给还是带回。在此基础上求带出去最少，如果带出去相同，求带回来最少的最短路径。
  技巧2：实现上述要求时需要遍历最短路径时这样处理：如果需要带回，则remain += cost[i], 如果需要补给则先用remain补给，构补给则remain -= |cost[i]|, 不够补给则need+= |cost[i]| - remain, remain归零。计算完后记录最小need的路径，如果need也相同记录最小remain的路径。
  完整代码如下：

const int MAXV = 510;
const int INF = 1000000000;
int G[MAXV][MAXV], n, m, st, ed, Cmax;
bool vis[MAXV] = {false};
int d[MAXV], cost[MAXV];
vector<int> pre[MAXV];
vector<int> path, tempPath;

void Dijkstra(int s) {
	fill(d, d + MAXV, INF);
	d[s] = 0;
	for(int i = 0; i <= n; i ++) {
		int u = -1, MIN = INF;
		for(int j = 0; j <= n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j]; 
			}
		}
		if(u == -1) return;
		vis[u] = true;
		for(int v = 0; v <= n; v ++) {
			if(vis[v] == false && G[u][v] != INF) {
				if(d[u] + G[u][v] < d[v]) {
					d[v] = d[u] + G[u][v];
					pre[v].clear();
					pre[v].push_back(u);
				}
				else if(d[u] + G[u][v] == d[v]) {
					pre[v].push_back(u);
				}
			}
		}
	}
}

int minNeed = INF, minRemain = INF; 
void DFS(int v) {
	if(v == st) {
		tempPath.push_back(v);
		int need = 0, remain = 0;
		for(int i = tempPath.size() - 1; i >= 0; i --) {
			int id = tempPath[i];
			if(cost[id] > 0) {
				remain += cost[id];
			}
			else {
				if(remain > abs(cost[id])) {
					remain -= abs(cost[id]);
				}
				else {
					need += abs(cost[id]) - remain;
					remain = 0;
				}
			}
		}
		if(need < minNeed) {
			minNeed = need;
			minRemain = remain;
			path = tempPath;
		}
		else if(need == minNeed && remain < minRemain) {
			minRemain = remain;
			path = tempPath;
		}
		tempPath.pop_back();
		return;
	}
	tempPath.push_back(v);
	for(int i = 0; i < pre[v].size(); i ++) {
		DFS(pre[v][i]);
	}
	tempPath.pop_back();
}

int main() {
	scanf("%d %d %d %d", &Cmax, &n, &ed, &m);
	fill(G[0], G[0] + MAXV * MAXV, INF);
	cost[0] = 0;
	for(int i = 1; i <= n; i ++) {
		scanf("%d", &cost[i]);
		cost[i] -= Cmax / 2;
	}
	int u, v, t;
	for(int i = 0; i < m; i ++) {
		scanf("%d %d %d", &u, &v, &t);
		G[u][v] = t;
		G[v][u] = t;
	}
	Dijkstra(0);
	DFS(ed);
	printf("%d ", minNeed);
	for(int i = path.size() - 1; i >= 0; i --) {
		if(i < path.size() - 1) printf("->");
		printf("%d", path[i]);
	}
	printf(" %d\n", minRemain);
	return 0;
}

• A1072 Gas Station
  题意：以每个加油站为起点找最短路径，要求找到离居民住宅的最小距离最大的站点，当最小距离相同时，要求离居民区平均距离最小。
  思路：遍历每个加油站进行Dijkstra算法，记录最大的最小距离，和最小的平均距离。
  坑点1：本题有n+m个顶点，范围是1~n+m，MAXV最小应该开到1011。Dijkstra的下标不要写出，每次不要忘了初始化vis[]和d[]。d[j]超过Ds的情况，跳过该加油站。
  坑点2：由于存在10个加油站的情况，即可能有编号G10，因此简单处理会错最后一个样例。需要正确处理G10这样的编号到n + 10。
  代码：

const int MAXV = 1050;
const int INF = 1000000000;
int G[MAXV][MAXV], n, m, k, Ds;
bool vis[MAXV] = {false};
int d[MAXV];

void Dijkstra(int s) {
	memset(vis, false, sizeof(vis));
	fill(d, d + MAXV, INF);
	d[s] = 0;
	for(int i = 1; i <= n + m; i ++) {
		int u = -1, MIN = INF;
		for(int j = 1; j <= n + m; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return;
		vis[u] = true;
		for(int v = 1; v <= n + m; v ++) {
			if(vis[v] == false && G[u][v] != INF) {
				if(d[u] + G[u][v] < d[v]) {
					d[v] = d[u] + G[u][v];
				}
			}
		}
	}
} 

int getId(char str[]) {
	int id = 0, len = strlen(str);
	for(int i = 0; i < len; i ++) {
		if(str[i] == 'G') continue;
		id = id * 10 + (str[i] - '0');
	}
	if(str[0] == 'G') id += n;
	return id;
}

int main() {
	fill(G[0], G[0] + MAXV * MAXV, INF);
	scanf("%d %d %d %d", &n, &m, &k, &Ds);
	char id1[4], id2[4];
	int dis, n1, n2;
	for(int i = 0; i < k; i ++) {
		scanf("%s %s %d", id1, id2, &dis);
		n1 = getId(id1);
		n2 = getId(id2);
		G[n1][n2] = dis;
		G[n2][n1] = dis;
	}
	double minAvgDis = INF, maxMinDis = -1;
	int ans = -1;
	for(int i = n + 1; i <= n + m; i ++) {
		double minDis = INF, avgDis = 0.0;
		Dijkstra(i);
		bool flag = false;
		for(int j = 1; j <= n; j ++) {
			if(d[j] > Ds) {
				flag = true;
				break;
			}
			if(d[j] < minDis) {
				minDis = d[j] * 1.0;//和居民区的最近距离 
			}
			avgDis += 1.0 * d[j] / n;
		}
		if(flag == true) continue;
		if(minDis > maxMinDis) {
			ans = i;
			maxMinDis = minDis; 
			minAvgDis = avgDis;
		} 
		else if(minDis == maxMinDis) {
			if(avgDis < minAvgDis) {
				minAvgDis = avgDis;
				ans = i;
			}
		}
	}
	if(ans == -1) printf("No Solution\n");
	else {
		printf("G%d\n", ans - n);
		printf("%.1f %.1f\n", maxMinDis, minAvgDis);
	}
	return 0;
}

• A1087 All Roads Lead to Rome
  题意：给出点权和边权，求出最大点权的最短路径。并计算最短路径长度，平均点权。
  思路：Dijkstra + DFS。
  注意点：代码主体写完后，有一些bug一时没找出来。
  提醒自己几点：（1）写完函数别忘了调用（忘记调用DFS）
  （2）num忘记初始化，最好可以把统计路径条数放到DFS中，以免忘记初始化num[s] = 1;
  （3）遍历数组或vector或邻接表啥的，注意要访问的是什么，别直接把循环下标当成另一数组的访问下标了。
  （4）在DFS中判断第一标尺时，即第一标尺就可以区分的时候别忘了更新第二标尺的数据。

代码：

const int MAXV = 210;
const int INF = 1000000000;
int G[MAXV][MAXV], n, k, st = 0, ed;
bool vis[MAXV] = {false};
int d[MAXV], weight[MAXV], maxW = 0, maxAvgW = 0;
int num[MAXV];
vector<int> pre[MAXV];
vector<int> path, tempPath;
map<string, int> str2num;
map<int, string> num2str;

void Dijkstra(int s) {
	fill(d, d + MAXV, INF);
	memset(num, 0, sizeof(num));
	d[s] = 0;
	num[s] = 1; //这里不要忘了初始化
	for(int i = 0; i < n; i ++) {
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return;
		vis[u] = true;
		for(int v = 0; v < n; v ++) {
			if(vis[v] == false && G[u][v] != INF) {
				if(d[u] + G[u][v] < d[v]) {
					d[v] = d[u] + G[u][v];
					num[v] = num[u];
					pre[v].clear();
					pre[v].push_back(u); 
				}
				else if(d[u] + G[u][v] == d[v]) {
					num[v] += num[u];
					pre[v].push_back(u);
				}
			}
		}
	}
}


void DFS(int v) {
	if(v == st) {
		tempPath.push_back(v);
		int w = 0, avgW;
		for(int i = tempPath.size() - 1; i >= 0; i --) {
			int id = tempPath[i];
			w += weight[id];
		}
		avgW = w / (tempPath.size() - 1);
		if(w > maxW) {
			maxW = w;
			maxAvgW = avgW;//别忘了更新第二标尺的数据
			path = tempPath;
		}
		else if(w == maxW && avgW > maxAvgW) {
			maxAvgW = avgW;
			path = tempPath; 
		}
		tempPath.pop_back(); 
		return;
	}
	tempPath.push_back(v);
	for(int i = 0; i < pre[v].size(); i ++) { //记得是遍历pre数组
		DFS(pre[v][i]);
	}
	tempPath.pop_back();
}


int main() {
	fill(G[0], G[0] + MAXV * MAXV, INF);
	string start, city;
	cin >> n >> k >> start;
	str2num[start] = 0;
	num2str[0] = start;
	weight[0] = 0;
	for(int i = 1; i <= n - 1; i ++) {
		cin >> city >> weight[i];
		str2num[city] = i;
		num2str[i] = city;
		if(city == "ROM") ed = i;
	}
	string c1, c2;
	int cost;
	for(int i = 0; i < k; i ++) {
		cin >> c1 >> c2 >> cost;
		G[str2num[c1]][str2num[c2]] = cost;
		G[str2num[c2]][str2num[c1]] = cost;
	}
	Dijkstra(st);
	DFS(ed);
	printf("%d %d %d %d\n", num[ed], d[ed], maxW, maxAvgW);
	for(int i = path.size() - 1; i >= 0; i --) {
		printf("%s", num2str[path[i]].c_str());
		if(i > 0) printf("->");
		else printf("\n");
	}
	return 0;
}

10.3.2 Bellman-Ford算法和SPFA算法

Bellman-Ford算法用来求解有负边权的单源最短路径问题。
环：经过若干个顶点后回到原顶点。可分为零环、正环、负环。零环和正环不会影响最短路径的求解，如果图中有负环且从源点可达，那么就会影响最短路径的求解，但如果从源点不可达负环则不影响。

同Dijkstra，Bellman-Ford算法设置一个数组d，存放从源点到各顶点最短距离。同时返回一个bool值：存在从源点可达的负环则返回false，否则返回true。
伪代码： O(VE)

for(i = 0; i < n - 1; i ++) { //执行n - 1轮操作
	for(each edge u->v) { //每轮遍历所有边
		if(d[u] + len(u->v) < d[v]) {
			d[v] = d[u] + len(u->v);
		}
	}
}

最短路径树的层数不超过V。

• Bellman-Ford算法邻接表版：

struct Node {
	int v, dis; //v为邻接边的目标顶点，dis为邻接边的边权
};
vector<Node> Adj[MAXV];
int n;
int d[MAXV];

bool Bellman(int s) {
	fill(d, d + MAXV, INF);
	d[s] = 0;
	for(int i = 0; i < n - 1; i ++) {//进行n-1轮操作
		for(int u = 0; u < n; u ++) {//每次遍历所有边
			for(int j = 0; j < Adj[u].size(); j ++) {
				int v = Adj[u][j].v;
				int dis = Adj[u][j].dis;
				if(d[u] + dis < d[v]) {
					d[v] = d[u] + dis;
				}
			}
		}
	}
	//以下为判断负环的代码
	for(int u = 0; u < n; u ++) {//对每条边进行判断	
		for(int j = 0; j < Adj[u][j]; j ++) {
			int v = Adj[u][j].v;
			int dis = Adj[u][j].dis;
			if(d[u] + dis < d[v]) //如果仍可以被松弛
				return false;
		}
	}
	return true;
}

统计最短路径条数的做法：需要设置记录前驱的数组set<int> pre[MAXV]，当遇到一条和已有最短路径长度相同的路径是，必须重新计算最短路径条数。

Bellman-Ford算法思路较简洁，但O(VE)的复杂较高，很多情况不尽人意。注意到，只有当某个顶点u的d[u]值改变时，从它出发的边的邻接点v的d[v]才有可能被改变。
优化：建立一个队列，每次将队首顶点u取出，然后对从u出发的所有边进行松弛操作，也就是判断d[u] + len[u->v] < d[v]是否成立，若成立曾更新，如果v不在队列中，就把v加入队列。这样操作直至队列为空(说明图中没有从源点可达的负环)，或是入队次数超过V- 1(说明存在源点可达的负环)。
伪代码：

queue<int> Q;
源点s入队;
while(队列非空) {
	取出队首元素u;
	for(u的所有邻接边u->v) {
		if(d[u] + dis < d[v]) {
			d[v] = d[u] + dis;
			if(v当前不在队列) {
				v入队;
				if(v入队次数 > n - 1) {
					说明有负环,return;
				}
			}
		}
	}
}

这种优化后的算法被称为SPFA(Shortest Path Faster Algorithm),它的期望复杂度是O(kE)，k是一个常数，k通常不超过2，因此经常优于堆优化的Dijkstra算法。但如果有源点可达的负环，复杂度就会退化为O(VE)。
如果实现知道不会有负环num数组可以去掉。SPFA可判断是否存在从源点可达的负环，如果负环源点不可达，则需要加一个辅助顶点C，并添加一条源点到C的有向边以及n-1条从C到达除源点的有向边才能判断是否有负环。

• SPFA 算法邻接表版：

vector<Node> Adj[MAXV];
int n, d[MAXV], num[MAXV];
bool inq[MAXV];//顶点是否在队列中

bool SPFA(int s) {
	memset(inq, false, sizeof(inq));
	memset(num, 0, sizeof(num));
	fill(d, d + MAXV, INF);
	queue<int> Q;
	Q.push(s);
	inq[s] = true;
	num[s] ++; //源点入队次数加1
	d[s] = 0;
	while(!Q.empty()) {
		int u = Q.front();
		Q.pop();
		inq[u] = true;
		for(int j = 0; j < Adj[u].size(); j ++) {
			int v = Adj[u][j].v;
			int dos = Adj[u][j].dis;
			if(d[u] + dis < d[v]) { //松弛操作
				d[v] = d[u] + dis;
				if(!inq[v]) {
					Q.push(v);
					inq[v] = true;
					num[v] ++;
					if(num[v] >= n) return false;//有可达负环
				}
			}
		}
	}
	return true;//无可达负环
}

SPFA有SLF优化和LLL优化。上述是BFS实现的，除此外队列换成栈可实现DFS版SPFA，对判环有奇效。

10.3.3 Floyd算法

Floyd(弗洛伊德)算法用于解决全源最短路径问题。即给定图G。求任意两点u，v之间的最短路径长度，时间复杂度O(n³)。n³的复杂度决定了n的数量限制在200以内。因此用邻接矩阵实现Floyd算法是非常合适且方便的。

Floyd算法流程：
枚举顶点k in [1, n]
以顶点k作为中介点，枚举所有顶点对i和j(i ，j in [1, n])
如果dis[i][k] + dis[k][j] < dis[i][j]成立
赋值dis[i][j] = dis[i][k] + dis[k][j]

• 模板：

const int INF = 1000000000;
const int MAXV = 200;
int n, m;
int dis[MAXV][MAXV];

void Floyd () {
	for(int k = 0; k < n; k ++) {//枚举中介点k
		for(int i = 0; i < n; i ++) {//枚举顶点对i, j
			for(int j = 0; j < n; j ++) {
				if(dis[i][k] != INF && dis[k][j] != INF && dis[i][k] + dis[k][j] < dis[i][j]) {
					dis[i][j] = dis[i][k] + dis[k][j];
				}
			}
		}
	}
}

int main() {
	int u, v, w;
	fill(dis[0], dis[0] + MAXV * MAXV, INF);
	scanf("%d%d", &n, &m);
	for(int i = 0; i < n; i ++) {
		dis[i][i] = 0;
	}
	for(int i = 0; i < m; i ++) {
		scanf("%d%d%d", &u, &v, &w);
		dis[u][v] = w;
	}
	Floyd();
	return 0;
}

注意点：不能将最外层的k循环放到内层，因为当较后访问的的dis[u][v]有了优化后，前面访问的dis[i][j]会因为以访问过而无法进一步优化。

10.4 最小生成树

最小生成树(MST)是给定一个无向图G，求一棵树使得树有该图所有顶点，边来自图的边，且满足树的边权之和最小。
最小生成树的性质：

• 最小生成树是树，其边数等于顶点数减1，且一定不会有环。
• 最小生成树不唯一，但边权之和唯一。
• 根节点可以使树上任意节点，若题目涉及最小生成树的输出，一般会给出根节点。

最小生成树算法包括：prim算法和kruskal算法。都采用了贪心的思想，贪心策略不同。

10.4.1 Prim算法

• 适用范围：复杂度O(V²),适合点少边多的稠密图。
• 基本思想：设置集合S，存放已访问节点，然后每次从V - S中选择与集合S的最短距离最小的一个顶点u访问并加入集合S。这样执行n次知道集合S包含所有顶点。和Dijkstra思想类似，只是起点s换成集合S。
  （1）每次从集合V-S选择与集合S最近的一个顶点u，访问并加入S，同时把这条离集合最近的边加入最小生成树中。
  （2）令顶点u作为集合S与V-S连接的借口，优化从u能到达的未访问顶点v与集合S的最短距离。

eg：如何选择需要恢复的道路，使得消耗最少的体力并攻占所有城市。

• 具体实现：集合S、顶点V_i和S的最短距离
  （1）集合S的实现：bool vis[N];
  （2）最短距离d[s]，表示顶点V_i和S的最短距离。
  Prim算法和Dijkstra算法思想几乎完全相同，除了数组d[]的含义不同。
• 伪代码：

Prim(G, d[]) {
	初始化;
	for(循环n次) {
		u = 使d[u]最小的还未访问的顶点标号;
		记u为已访问;
		for(从u出发可达的所有顶点v) {
			if(v未被访问 && yiu为中介点使v与集合S的最短距离d[v]更优) {
				将G[u][v]赋值给v与集合S的最短距离d[v];
			}
		}
	}
}

• 模板
  Prim算法邻接矩阵版： O(V²)

const int MAXV = 1000; //最大顶点数
const int INF = 1000000000;

int n, G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV] = {false};

int Prim() {//默认0号为初始点，返回最小生成树的边权之和
	fill(d, d + MAXV, INF);
	d[0] = 0;
	int ans = 0; //存放最小生成树边权之和
	for(int i = 0; i < n; i ++) {
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return -1;
		vis[u] = true;
		ans += d[u]; //累加边权
		for(int v = 0; v < n; v ++) {
			if(vis[v] == false && G[u][v] != INF && G[u][v] < d[v]) {
				d[v] = G[u][v];
			}
		} 
	} 
	return ans;
}

Prim算法邻接表版： O(V²), 堆优化后为O(VlogV + E)

struct Node {
	int v, dis; //v为目标顶点，dis为边权 
};
vector<Node> Adj[MAXV];
int n, d[MAXV];
bool vis[MAXV] = {false};

int Prim() {
	fill(d, d + MAXV, INF);
	d[0] = 0;
	int ans = 0; //存放最小生成树边权之和
	for(int i = 0; i < n; i ++) {
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j ++) {
			if(vis[j] == false && d[j] < MIN) {
				u = j;
				MIN = d[j];
			}
		}
		if(u == -1) return -1;
		vis[u] = true;
		ans += d[u]; //累加边权
		for(int j = 0; j < Adj[u].size(); j ++) {
			int v = Adj[u][v].v;
			if(vis[v] == false && Adj[u][j].dis < d[v]) {
				d[v] = G[u][v];
			}
		} 
	} 
	return ans;
}

10.4.2 Kruskal算法

• 适用范围：复杂度O(ElogE)，适合点多边少的稀疏图。

• 基本思想：kruskal采用边贪心的策略。
  （1）对所有边按边权从小到大排序
  （2）从小到大测试所有边，如果当前测试边的两个顶点不在同一个连通块，则把这条测试版加入最小生成树中，否则舍弃。
  （3）直到最小生成树中的边数等于总顶点数减1或测试完所有边结束。测试完边数小于顶点数减1则不连通。
  每次选最小边权的边，若两端顶点在不同连通块中则加入最小生成树。

• 实现：数据结构edge、边的比较函数，把每个连通块当成一个集合，用并查集实现集合合并。
  节点编号为1~n。

• 模板：

struct edge {
	int u, v;
	int cost; //边权 
} E[MAXE]; 

bool cmp(edge a, edge b) {
	return a.cost < b.cost;
}
int father[MAXV];
int findFather(int x) {
	int a = x;
	while(x != father[x]) {
		x = father[x];
	}
	while(a != father[a]) {
		int z = a;
		a = father[a];
		father[z] = x;
	}
	return x;
}
int kruskal(int n, int m) {
	int ans = 0, numEdge = 0;
	for(int i = 1; i <= n; i ++) {
		father[i] = i; //并查集初始化 
	}
	sort(E, E + m, cmp);
	for(int i = 0; i < m; i ++) { //枚举所有边 
		int faU = findFather(E[i].u);
		int faV = findFather(E[i].v); 
		if(faU != faV) {
			father[faU] = faV;
			ans += E[i].cost;
			numEdge ++;
			if(numEdge == n - 1) break;
		}
	} 
	if(numEdge != n - 1) return -1;
	else return ans;
}

• 总结：稠密图(边多)用prim，稀疏图(边少)用kruskal。

10.5 拓扑排序

如果一个有向图任意顶点都无法通过一些有向边回到自身，那么称这个有向图为有向无环图(DAG, Directed Acyclic Graoh)

拓扑排序：是指将有向无环图G的所有顶点排成一个线性序列，这个序列被称为拓扑序列。

• 实现：
  （1）定义一个队列Q，并把所有入度为0的节点加入队列。
  （2）取队首节点，输出。然后删去所有从它出发的边，并令这些边到达的点的入度减1，如果某个顶点的入度减为0，则将其加入队列。
  （3）反复进行（2）操作直到队列为空。如果队列为空时入过队的节点数恰好为N，说明拓扑排序成功，图G为有向无环图，否则拓扑排序失败，图中有环。

可使用邻接表实现拓扑排序。需要建立一个数组inDegree[MAXV]，并在程序一开始读入图时就记录号节点的入度。

• 模板：

vector<int> G[MAXV];
int n, m, inDegree[MAXV];

bool topologicalSort() {
	int num = 0;
	queue<int> q;
	for(int i = 0; i < n; i ++) {
		if(inDegree[i] == 0) {
			q.push(i);//所有入度为0的顶点入队 
		}
	}
	while(!q.empty()) {
		int u = q.front();
		//printf("%d", u); //此处可输出顶点u作为拓扑序列中的顶点 
		q.pop();
		for(int i = 0; i < G[u].size(); i ++) {
			int v = G[u][i]; //u的后继节点v 
			inDegree[v] --;//顶点v的入度-1 
			if(inDegree[v] == 0) {
				q.push(v);
			} 
		} 
		G[u].clear(); //清空顶点u的所有出边(如无必要可不写)
		num ++; //加入拓扑序列的顶点数+1 
	} 
	if(num == n) return true;
	else return false;
}

• 拓扑排序的重要应用：判断一个给定的图是否为有向无环图。
  如果要求有多个入度为0的顶点，选择编号最小的顶点，那么可以把queue换成priority_queue(小堆顶)或者set也可。

10.6 关键路径

10.6.1 AOV网和AOE网

顶点活动(Activity On Vertex)网是指用顶点表示活动，而用边集表示活动间优先关系的有向图。
边活动(Activity On Edge)网是指用带权的边集表示活动，而用顶点表示事件的有向图，其中边权表示完成活动需要消耗的时间。
AOV网一般只有一个源点和一个汇点。有多个时，可加上一个超级源点和超级汇点。
如果给定AOV网中各顶点获得所需时间，可以将AOV网转换为AOE网。可以将AOV网的每个顶点都拆成两个顶点，表示活动的起点和终点，边权给定。原边的边权为0。

• AOE网解决的问题：
  （1）工程起始到中止需要多少时间
  （2）哪条路径上的获得是影响整个工程进度的关键。

AOE网中的最长路径被称为关键路径。
关键路径就是AOE网的最长路径。 关键路径上的活动称为关键活动。

10.6.2 最长路径

如何求解最长路径：
**对一个没有(源点可达的)正环的图，可以把所有边权乘以-1，然后使用Bellman-Ford算法或SPFA算法求最短路径长度，将结果取反即可。**如果有正环最长路径不存在。但是如果要求最长简单路径即每个顶点最多经过一次)，虽然最长简单路径存在，但不能用Bellman-Ford算法求解，因为是NP-Hard问题。（最长路径问题，Longest Path Problem求图中最长简单路径）。

10.6.3 关键路径

关键路径是一种求解有向无环图(DAG)中最长路径的方法。
设置数组e和l，其中e[r]和l[r]分别表示活动a_r的最早开始时间和最迟开始时间。求出这两个数组后就可以通过判断e[r] == l[r]是否成立来确定活动r是否为关键活动。
设置数组ve和vl，其中ve[i]和vl[i]分别表示事件i的最早发生时间和最迟发生时间。
（1）对于活动a_r来说，只要在时间V_i最早发生时马上开始，就可以使得活动开始时间最早，因此e[r] = ve[i]。
（2）如果l[r]是活动a_r的最迟发生时间，那么l[r] + len(r)就是事件V_j的最迟发生时间。因此l[r] = vl[j] - len(r)。

• 在访问某节点时保证它的前驱节点都已访问完毕：拓扑排序

stack<int> topOrder;
bool topologicalSort() {
	queue<int> q;
	for(int i = 0; i < n; i ++) {
		if(inDegree[i] == 0) {
			q.push(i);
		}
	}
	while(!q.empty()) {
		int u = q.front();
		q.pop();
		topOrder.push(u);
		for(int i = 0; i < G[u].size(); i ++) {
			int v = G[u][i].v;
			inDegree[v] --;
			if(inDegree[v] == 0) {
				q.push(v);
			}
			//用ve[u] 来更新u的所有后继节点v 
			if(ve[u] + G[u][i].w > ve[v]) {
				ve[v] = ve[u] + G[u][i].w;
			}
		}
	}
	if(topOrder.size() == n) return true;
	else return false;
} 

• 在访问某节点时保证它的后继节点都已访问完毕：逆拓扑排序， 按顺序出栈就是逆拓扑序列。

fill(vl, vl + n, ve[n - 1]); //vl数组初始化为终点的ve值
while(!topOrder.empty()) {
	int u = topOrder.top();
	topOrder.pop();
	for(int i = 0; i < G[u].size(); i ++) {
		int v = G[u][i].v;
		if(vl[v] - G[u][i].w < vl[u]) {
			vl[u] = vl[v] - G[u][i].w;
		}
	} 
} 

• 求解关键路径的步骤：先求点，再夹边

1. 按拓扑序和逆拓扑序分别计算各顶点事件的最早发生时间和最迟发生时间：
   最早(拓扑序)：ve[j] = max{ve[i] + len[i->j]};
   最迟(逆拓扑序)：vl[i] = min{vl[j] - len[i->j]};
2. 用上面的结果计算各边活动的最早开始时间和最迟开始时间：
   最早：e[i->j] = ve[i];
   最迟：l[i->j] = vl[j] - len[i->j]
3. e[i->j] == l[i->j]的活动即为关键活动。

代码：汇点确定且唯一，以n-1号为汇点。

int CriticalPath() {
	memset(ve, 0, sizeof(ve)); //ve数组初始化为0 
	if(topologcialSort() == false) {
		return -1; //不是有向无环图 
	}
	/* 事先不知道汇点编号
	int maxLen = 0;
	for(int i = 0; i < n; i ++) {
		maxLen = ve[i];
	}
	fill(vl, vl + n, maxLen);
	*/
	fill(vl, vl + n, ve[n - 1]); //vl数组初始化为汇点的ve值 
	while(!topOrder.empty())  {
		int u = topOrder.top();
		topOrder.pop();
		for(int i = 0; i < G[u].size(); i ++) {
			int v = G[u][i].v;
			if(vl[v] - G[u][i].w < vl[u]) {
				vl[u] = vl[v] - G[u][i].w;
			}
		}
	}
	//遍历邻接表的所有边，计算活动的最早开始时间e和最迟开始时间l
	for(int u = 0; u < n; u ++) {
		for(int i = 0; i < G[u].size(); i ++) {
			int v = G[u][i].v, w = G[u][i].w;
			int e = ve[u], l = vl[v] - w;
			if(e == l)  { //关键活动
				printf("%d->%d\n", u, v);
				//将u->v加入邻接表，最后用DFS获取所有关键路径
			}
		}
	} 
	return ve[n - 1]; //返回关键路径长度 
}

上述代码中，没有将e和l存起来，如果要存，只需在结构体中添加域e和l。
如果事先不知道汇点编号，如何较快获得关键路径长度：取ve数组的最大值。

11 动态规划(DP)

动态规划(Dynamic Programming, DP)是一种用来解决最优化问题的算法思想。动态规划将一个复杂的问题分解成若干子问题，通过综合子问题的最优解来得到原问题的最优解。动态规划会将每个求解子问题的解记录下来。可以用递归或递推来实现动态规划，其中递归写法又称作记忆化搜索。

• 动态规划的递归写法(Fibonacci)：记录子问题的解来避免下次遇到相同的子问题时的重复计算。以Fibonacci为例，为避免重复计算，开一个以为数组dp，dp[n]记录F(n)的结果，dp[n] = -1表示还没计算过。

int dp[MAXN];
int F(int n) {
	if(n == 0 || n == 1) return 1; //边界
	if(dp[n] != -1) return dp[n];
	else {
		dp[n] = F(n - 1) + F(n - 2); //状态转移方程
		return dp[n];
	}
}

• 动态规划的递推写法(数塔问题)：
  设dp[i][j]表示从第i行第j个数字出发到达底层的最大和。
  dp[i][j]成为问题的状态，状态转移方程为dp[i][j] = max(dp[i + 1][j], dp[i + 1][j + 1]) + f[i][j]，边界为dp[n][j] == f[n][j] (1 <= j <= n), dp[1][1]即为答案。

int f[maxn][maxn], dp[maxn][maxn];
for(int i = 1; i <= n; i ++) {
	for(int j = 1; j <= i; j ++) {
		scanf("%d", &f[i][j]);
	}
}
for(int j = 1; j <= n; j ++) {
	dp[n][j] = f[n][j]; //边界
}

for(int i = n - 1; i >= 1; i --) { //从第n-1层不断往上计算
	for(int j = 1; j <= i; j ++) { //状态转移方程
		dp[i][j] = max(dp[i + 1][j], dp[i + 1][j + 1]) + f[i][j];
	}
}

• 小结：
  递推：自底向上计算
  递归：自顶向下计算
  重叠子问题：一个问题可被分解若干子问题，且这些子问题会重复出现。
  最优子结构：一个问题的最优解可以由子问题的最优解推导而来。(局部最优能确定全局最优)
  一个问题必须拥有重叠子问题和最优子结构才能使用动态规划求解。

• 区别：
  分治无重叠子问题，动规有重叠子问题。分治法解决的问题不一定是最优化问题，动态规划解决的一定是最优化问题。
  贪心和动规都要求最优子结构性质。贪心自顶向下，动规从边界上开始向上得到解。

11.1 最大连续子序列和

Maximum Subsequence Sum, MSS, 最大连续子序列和：给定一个数字序列A₁，A₂，…，A_n(1 <= i <= j <= n),使得A_i + … + A_j最大，输出这> 个最大和。
解:
状态: dp[i]表示以A[i]结尾的连续序列的和。
状态转移方程：dp[i] = max{A[i], dp[i - 1] + A[i]}
边界： dp[0] = A[0]

#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn = 10010;
int A[maxn], dp[maxn];
int main() {
	int n;
	scanf("%d", &n);
	dp[0] = A[0]; //边界
	for(int i = 1; i < n; i ++) {
		dp[i] = max(A[i], dp[i - 1] + A[i]); //状态转移方程
	} 
	int k = 0;
	for(int i = 1; i < n; i ++) {
		if(dp[i] > dp[k]) {
			k = i;
		}
	}
	printf("%d\n", dp[k]);
	return 0;
}

状态的无后效性：当前状态记录了历史信息，一旦当前状态确定，就不会在改变，且未来的决策只能在已有的一个或若干个状态的基本上进行。
并不是所有状态都具有无后效性。设计状态和状态转移方是动态规划的核心。

• A1007 Maximum Subsequence Sum
  用一个s[i]记录以a[i]结尾的最大连续子序列的开始位置，如果加上a[i]变大了，那么dp[i] = dp[i - 1] + a[i] , s[i] = s[i - 1]; 如果变小了dp[i] = a[i], s[i] = i;

11.2 最长不下降子序列(LIS)

Longest Increasing Sequence, LIS, 最长不下降子序列： 在一个数字序列中，找到一个最长的子序列(可以不连续),使得这个子序列非递减。
解：
状态: dp[i]表示以A[i]结尾的LIS的长度。
状态转移方程： dp[i] = max{1, dp[j] + 1} (j < i, && A[j] < A[i])
边界：隐含着状态转移方程中，dp[i] = 1 (1 <= i <= n)

#include<cstdio>
#include<algorithm>
using namespace std;

const int N = 100;
int A[N], dp[N];

int main() {
	int n;
	scanf("%d", &n);
	for(int i = 1; i <= n; i ++) {
		scanf("%d", &A[i]);
	}
	int ans = -1;
	for(int i = 1; i <= n; i ++) {//按顺序计算出dp[i]的值 
		dp[i] = 1; //边界初始条件
		for(int j = 1; j < i; j ++) {
			if(A[i] >= A[j] && (dp[j] + 1 > dp[i])) {
				dp[i] = dp[j] + 1; //状态转移方程
			}
		}
		ans = max(ans, dp[i]);
	}
	printf("%d", ans);
	return 0;
}

• A1045 Favorite Color Stripe
  最长递增子序列，排序按照favor的顺序。
  坑点：不一定喜欢所有颜色，有些颜色可能不会出现。因此判断时要保证条带出现的颜色都在喜欢的队列里面，且喜欢的顺序跟靠前的时候才将最大长度加1。

#include<cstdio>

const int N = 210;
const int maxn = 10010;
int favor[N] = {0};
int stripe[maxn];
int dp[maxn]; //以stripe[i]结尾的LIS长度 

int max(int a, int b) {
	return a > b ? a : b;
} 

int main() {
	int n, m, L, color;
	scanf("%d", &n);
	scanf("%d", &m);
	for(int i = 1; i <= m; i ++) {
		scanf("%d", &color);
		favor[color] = i; 
	}
	scanf("%d", &L);
	for(int i = 1; i <= L; i ++) {
		scanf("%d", &stripe[i]);
	}
	int ans = -1;
	for(int i = 1; i <= L; i ++) {
		dp[i] = 1;
		for(int j = 1; j < i; j ++) {
			if(favor[stripe[i]] != 0 && favor[stripe[j]] != 0 && favor[stripe[i]] >= favor[stripe[j]] && dp[j] + 1 > dp[i]) {
				dp[i] = dp[j] + 1;
			}
		}
		ans = max(ans, dp[i]);
	}
	printf("%d\n", ans);
	return 0;
}

技巧1：可以用一个hashTable把喜欢的颜色映射成递增序列，然后读入颜色序列时，将喜欢的颜色加入到A数组，不喜欢的则忽略，接着就可以用LIS的模板解决了。

技巧2 ： algorithm中有max函数

11.3 最长公共子序列(LCS)

Longest Common Subsequence, LCS, 最长公共子序列： 给定两个字符串或数组序列A和B，求一个字符串，使得是A和B的最长公共部分(可以不连续)。
解：
状态： dp[i][j] 表示字符串A的i号位和字符串B的j号位之前的LCS的长度(下标从1开始)
状态转移方程：dp[i][j] = dp[i - 1][j - 1] + 1 (A[i] == B[j]), dp[i][j] = max{dp[i -1][j], dp[i][j - 1]} (A[i] != B[j])
边界： dp[i][0] = dp[0][j] = 0 (0 <= i <= n, 0 <= j <= m)
复杂度：O(nm)

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 100;
char A[N], B[N];
int dp[N][N];
int main() {
	int n;
	gets(A + 1); //从下标1开始读入 
	gets(B + 1);
	int lenA = strlen(A + 1);
	int lenB = strlen(B + 1);
	//边界
	for(int i = 0; i <= lenA; i ++)
		dp[i][0] = 0;
	for(int j = 0; j <= lenB; j ++)
		dp[0][j] = 0;
	//状态转移方程
	for(int i = 1; i <= lenA; i ++) {
		for(int j = 1; j <= lenB; j ++) {
			if(A[i] == B[i]) {
				dp[i][j] = dp[i - 1][j - 1] + 1;
			}
			else {
				dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
			}
		}
	} 
	//dp[lenA][lenB]是答案
	printf("%d\n", dp[lenA][lenB]) ;
	return 0;
}

• A1045 Favorite Color Stripe
  可以求喜欢颜色串和输入颜色串的最长公共子序列，且公共部分允许重复。
  状态转移方程修正为：当A[i] = B[j]时，长度位dp[i - 1][j]和dp[i][j - 1]较大者加1，否则为两者较大者。

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	for(int i = 1; i <= m; i ++) {
		scanf("%d", &A[i]);
	}
	int L;
	scanf("%d", &L);
	for(int i = 1; i <= L; i ++) {
		scanf("%d", &B[i]);
	}
	//边界
	for(int i = 0; i <= m; i ++) 
		dp[i][0] = 0;
	for(int j = 0; j <= L; j ++)
		dp[0][j] = 0;
	//状态转移方程
	for(int i = 1; i <= m; i ++) {
		for(int j = 1; j <= L; j ++) {
			int MAX = max(dp[i - 1][j], dp[i][j - 1]);
			if(A[i] == B[j]) {
				dp[i][j] = MAX + 1;
			}
			else {
				dp[i][j] = MAX;
			}
		}
	} 
	printf("%d\n", dp[m][L]);
	return 0;
}

11.4 最长回文子串

Longest Palindromic Substring, LPS, 最长回文子串：给出一个字符串S，求S的最长回文子串的长度。
解：
状态： dp[i][j]表示S[i]至S[j]所表示的子串是否是回文子串，是则为1，不是为0.
状态转移方程： dp[i][j] = dp[i + 1][j - 1] (S[i] == S[j]), ·dp[i][j] = 0 (S[i] != S[j])。
边界： dp[i][i] = 1, dp[i][i + 1] = (S[i] == S[i + 1]) ? 1 : 0;
转移：按照i和j从小到大枚举可能无法转移。因此考虑按照子串长度和子串的初始位置进行枚举。
复杂度： O(n²)

#include<cstdio>
#include<cstring>
const int maxn = 1010;
char S[maxn];
int dp[maxn][maxn];

int main() {
	//gets(S);
	scanf("%[^\n]%*c", S);
	int len = strlen(S), ans = 1;
	memset(dp, 0, sizeof(dp)); //dp数组初始化为0
	//边界
	for(int i = 0; i < len; i ++) {
		dp[i][i] = 1;
		if(i < len - 1) {
			if(S[i] == S[i + 1]) {
				dp[i][i + 1] = 1;
				ans = 2;//初始化时注意当前最长回文子串的长度 
			}
		}
	} 
	//状态转移方程
	for(int L = 3; L <= len; L ++) { //枚举子串的长度 
		for(int i = 0; i + L - 1 < len; i ++) {
			int j = i + L - 1; //子串右端点 
			if(S[i] == S[j] && dp[i + 1][j - 1] == 1) {
				dp[i][j] = 1;
				ans = L; //更新最长回文子串长度 
			}
		} 
	} 
	printf("%d\n", ans); 
	return 0;
}

最长回文子串的其他解法：
二分+字符串hash，O(NlogN);
Manacher算法， O(N)。

11.5 DAG最长路

DAG最长路或最短路问题是特别重要的一类问题。DAG最长路和最短路的思想是一致的。

• 求整个DAG中的最长路径(即不固定起点和终点)

给定一个有向无环图，怎么求整个图的所有路径中权值之和最大的那条。
解：
状态： dp[i]表示从i号顶点出发能获得的最长路径长度，这样所有dp[i]的最大值就是DAG的最长路径长度。
状态转移方程： dp[i] = max{dp[j] + len[i -> j] | (i, j) in E}
边界： 所有出度为0的顶点dp值为0。只要把整个dp数组初始化为0即可。

int DP(int i) {
	if(dp[i] > 0) return dp[i];
	for(int j = 0; j < n; j ++) {
		if(G[i][j] != INF) {
			dp[i] = max(dp[i], DP(j) + G[i][j]);
		}
	}
	return dp[i];
}

如何求最长路径具体是哪条？开一个choice数组(或多条开vector)记录最长路径上顶点的后继节点。

int DP(int i) {
	if(dp[i] > 0) return dp[i];
	for(int j = 0; j < n; j ++) {
		if(G[i][j] != INF) {
			int temp = DP(j) + G[i][j];
			if(temp > dp[i]) {
				dp[i] = temp;
				choice[i] = j;
			}
		}
	}
	return dp[i];
}
//调用printPath前需要先得到最大的dp[i]，然后将i作为起点传入
void printPath(int i) {
	printf("%d", i);
	while(choice[i] != -1) {
		i = choice[i];
		printf("->%d", i);
	}
}

对一般的动态规划问题，可以记录每次决策选择的策略，然后在dp数组计算完后根据具体情况进行递归或迭代获取方案。

由于字典序大小总是先根据序列中较前的部分来判断，因此序列中越靠前的顶点，其 dp值应当越靠后计算(对一般的序列型动态规划也是如此)。

• 固定终点求DAG的最长路径

状态：dp[i]表示从i号顶点出发到达终点T能获得的最长路径长度。
状态转移方程： dp[i] ] max{dp[j] + len[i->j] | (i, j) in E}
边界： dp[T] = 0, 将dp数组初始化为-INF。然后设置一个vis数组表示顶点是否已经被计算

int DP(int i)  {
	if(vis[i]) return dp[i];
	vis[i] = true;
	for(int j = 0; j < n; j ++) {
		if(G[i][j] != INF) {
			dp[i] = max(dp[i], DP(j) + G[i][j]);
		}
	}
	return dp[i];
}

关键路径求解问题和矩形嵌套问题都可以转换为DAG的最长路。
矩形嵌套问题：求一个矩形序列，使得前一个嵌套于后一个，且序列长度最长。把矩形看成一个顶点，嵌套关系看成顶点之间的有向边，边权均为1，就转换为DAG最长路问题了。

11.6 背包问题

11.6.1 01背包问题

有一类动态规划可解的问题，可以描述成若干个有序的阶段，每个阶段的状态之和上一个阶段的状态有关，这类问题叫多阶段动态规划问题。01背包问题就是一个例子。

有n件物品，每件物品重量为w[i]，价值为c[i]。现有一个容量为V的背包，问如何选取物品放入背包使得总价值最大。其中每种物品都只有1件。
解：
状态： dp[i][v]表示前i件物品恰好装入容量为v的背包所能活动的最大价值。
状态转移方程： dp[i][v] = max{dp[i - 1][v], dp[i - 1][v - w[i]] + c[i]} (1 <= i <= n, w[i] <= v <= V)
边界： dp[0][v] = 0 (0 <= v <= V)
枚举dp[n][v] (0 <= v <= V),取其最大值即为结果。
复杂度O(nV)

转移的两个策略：不放第i件物品，那么问题转化为前i-1件物品恰好装入容量为v的背包的最大价值，即dp[i - 1][v]。放第i件物品，那么问题转化为前i-1件物品恰好装入容量为v-w[i]的背包的最大价值，即dp[i - 1][v - w[i]] + c[i]

for(int i = 1; i <= n; i ++) {
	for(int v = w[i]; v <= V; v ++) {
		dp[i][v] = max(dp[i - 1][v], dp[i - 1][v - w[i]] + c[i]);
	}
}

• 空间优化O(V)(滚动数组)：dp[v] = max(dp[v], dp[v - w[i]] + c[i]) (1 <= i <= n, w[i] <= v <= V), 枚举方向变为i从1到n，v从V到0。

for(int i = 1; i <= n; i ++) {
	for(int v = V; v >= w[i]; v --) {
		dp[v] = max(dp[v], dp[v - w[i]] + c[i]);
	}
}

• 完整代码模板

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100;
const int maxv = 1000;
int w[maxv], c[maxn], dp[maxv];
int main() {
	int n, V;
	scanf("%d %d", &n, &V);
	for(int i = 1; i <= n; i ++) {
		scanf("%d", &w[i]);
	}
	for(int i = 1; i <= n; i ++) {
		scanf("%d", &c[i]); 
	}
	//边界
	for(int v = 0; v <= V; v ++) {
		dp[v] = 0;
	} 
	for(int i = 1; i <= n; i ++) {  
		for(int v = V; v >= w[i]; v --) { //状态转移方程 
			dp[v] = max(dp[v], dp[v - w[i]] + c[i]);
		}
	}
	//寻找dp中的最大值即为答案
	int max = 0;
	for(int v = 0; v <= V; v ++) {
		if(dp[v] > max)
			max = dp[v];
	}
	printf("%d\n", max); 
	return 0;
}

对能够划分阶段的问题，都可以尝试把阶段作为状态的一维，可以方便的得到满足无后效性的状态。如果当前设计的状态不满足无后效性，那么不妨把状态升维，即增加一维或若干维来表示相应的信息，这样就可能满足无后效性了。

11.6.2 完全背包问题

有n种物品，每种物品重量为w[i],价值为c[i]。现有一个容量为V的背包，问如何选取物品放入背包，使得总价值最大。其中每种物品无穷件。
状态： dp[i][v]表示前i件物品恰好放入容量为v的背包的最大价值。
状态转移方程： dp[i][v] = max(dp[i - 1][v], dp[i][v - w[i]] + c[i]) (1 <= i <= n, w[i] <= v <= V)
边界： dp[0][v] = 0 (0 <= v <= V)

写成一维形式后必须正向枚举：

for(int i = 1; i <= n; i ++) {  
	for(int v = w[i]; v <= V; v ++) { //状态转移方程 
		dp[v] = max(dp[v], dp[v - w[i]] + c[i]);
	}
}

• 总结

1. 最大连续子序列和MSS： 令dp[i]表示以A[i]作为末尾的连续序列的最大和。
2. 最长不下降子序列LIS: 令dp[i]表示以A[i]结尾的最长不下降序列长度。
3. 最长公共子序列LCS： 令dp[i][j]表示字符串A的i号位和字符串B的j号位之前的LCS长度。
4. 最长回文子串： 令dp[i][j]表示S[i]至S[j]所表示的子串是否是回文子串。
5. 数塔DP： 令dp[i][j]表示从第i行第j个数字出发到达底层的所有路径上的最大和。
6. DAG最长路：令dp[i]表示从i号顶点出发能获得的最长路径长度。
7. 01背包： 令dp[i][v]表示前i件物品恰好装入容量为v的背包获得的最大价值。
8. 完全背包： 令dp[i][v]表示前i件物品恰好放入容量为v的背包能获得的最大价值。

• 启发：

1. 一般来说，子序列可以不连续，子串必须连续。

2. 状态设计方法：
   当题目与序列或字符串(记为A)有关时，可以考虑把状态设计成下面两种形式，然后根据端点考虑状态转移方程：
   （1）令dp[i]表示以A[i]结尾(或开头)的***
   （2）令dp[i][j]表示A[i]到A[j]区间的***

3. 分析题目中的状态需要几维来表示，然后对其中一维采取下面某一表述：
   （1）恰好为i
   （2）前i
   在每一维的含义设置完毕后，dp数组的含义就可以设置成“令dp数组表示恰好为i(或前i)/qu==恰好为j(或前j) … 的 ***”，然后根据端点的特点考虑状态转移方程。

4. 可以把动态规划可解的问题看作一个有向无环图DAG，图中的节点就是状态，边就是状态转移的方向。求解问题的顺序就是按照DAG的拓扑序进行求解。

• A1068 Find More Coins
  由于要求按照价值大小从小到大的字典序输出，因此需要将数组从大到小排序排序，然后按01背包问题dp求解。开一个choice数组记录计算d[i][v]时选择了哪一个策略。
  大部分动规问题，输出方法相同，即记录每一步选择的策略，然后从最终态倒着判断即可。

const int maxn = 10010;
int w[maxn];
int dp[maxn] = {0}; //dp[i]表示前i物品恰好装入容量为v的背包 
bool choice[maxn][maxn], flag[maxn];

bool cmp(int a, int b) {
	return a > b;
}

int main() {
	int n, m;
	scanf("%d %d", &n, &m);
	for(int i = 1; i <= n; i ++) {
		scanf("%d", &w[i]);
	}
	sort(w + 1 , w + n  + 1, cmp);
	for(int i = 1; i <= n; i ++) {
		for(int v = m; v >= w[i]; v --) {
			if(dp[v] <= dp[v - w[i]] + w[i]) {
				dp[v] = dp[v- w[i]] + w[i];
				choice[i][v] = 1;
			}
			else choice[i][v] = 0;		
		}
	}
	if(dp[m] != m) printf("No Solution\n");
	else {
		int k = n, num = 0, v = m;
		while(k >= 0) {
			if(choice[k][v] == 1) {
				flag[k] = true;
				v -= w[k];
				num ++;
			}
			else flag[k] = false;
			k --;
		}
		
		for(int i = n; i >= 1; i --) {
			if(flag[i] == true) {
				printf("%d", w[i]);
				num --;
				if(num > 0) printf(" ");
			}
		}
	}
	return 0;
}

12 字符串

12.1 字符串hash进阶

字符串hash是指将一个字符串S映射成一个整数，使得该整数尽可能唯一的代表字符串S。H[i] = H[i - 1] * 26 + index(str[i])，虽然字符串与整数一一对应，但是没有进行使得处理，当字符串较长时，整数非常大，没法用一般的数据类型保存。为了应对这种情况，只能舍弃一些唯一性，将结果对一个整数取模，也就是使用下面的散列函数:H[i] = (H[i - 1] * 26 + index(str[i])) % mod。在int范围内，如果把进制数设为一个10⁷级别的素数p(如10000019)，同时把mod设置为一个10⁹级别的素数(如1000000007)，如下：H[i] = (H[i - 1] * p + index(str[i])) % mod，那么冲突的概率将非常小，很难产生冲突。

H[i...j] = ((H[j] - H[i - 1] * p^(j-i+1)) % mod) + mod ) % mod

• A1040 Longest Symmetric String

#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long LL;
const LL MOD = 1000000007;
const LL P = 10000019;
const LL MAXN = 1010;
LL powP[MAXN], H1[MAXN], H2[MAXN];
void init() {
	powP[0] = 1;
	for(int i = 1; i < MAXN; i ++) {
		powP[i] = (powP[i - 1] * P) % MOD;
	} 
}

void calH(LL H[], string &str) {
	H[0] = str[0];
	for(int i = 1; i < str.length(); i ++) {
		H[i] = (H[i - 1] * P + str[i]) % MOD;
	}
}

int calSingleSubH(LL H[], int i, int j) {
	if(i == 0) return H[j];
	return ((H[j] - H[i - 1] * powP[j - i + 1]) % MOD + MOD) % MOD;
}

//对称点i，字符串长len，在[l, r]里二分回文半径
//寻找最后一个满足“hashL == hashR”的回文半径
//等价于寻找第一个满足条件"hashL != hashR"的回文半径
//isEven当求奇回文时为0，求偶回文时为1. 
int binarySearch(int l, int r, int len, int i, int isEven) {
	while(l < r) {
		int mid = (l + r) / 2;
		int H1L = i - mid + isEven, H1R = i;
		int H2L = len - 1 - (i + mid), H2R = len - 1 + (i + isEven);
		int hashL = calSingleSubH(H1, H1L, H1R);
		int hashR = calSingleSubH(H2, H2L, H2R);
		if(hashL != hashR) r = mid;//hash值不等说明回文半径<=mid 
		else l = mid + 1;//hash值相等说明回文半径>mid 
	} 
	return l - 1; //返回最大回文半径 
}

int main() {
	init();
	string str;
	getline(cin, str);
	calH(H1, str);
	reverse(str.begin(), str.end());
	calH(H2, str);
	int ans = 0;
	//奇回文
	for(int i = 0; i < str.length(); i ++) {
		//二分上界为分界点i的左右长度较小值加1 
		int maxLen = min(i, (int)str.length() - i - 1) + 1;
		int k = binarySearch(0, maxLen, str.length(), i, 0);
		ans = max(ans, k * 2 + 1);
	}
	//偶回文
	for(int i = 0; i < str.length(); i ++) {
		int maxLen = min(i + 1, (int)str.length() - i - 1) + 1;
		int k = binarySearch(0, maxLen, str.length(), i, 1);
		ans = max(ans, k * 2);
	} 
	printf("%d\n", ans);
	return 0;
}

注：题解代码并未通过此题。

12.2 KMP算法

KMP算法用来解决字符串匹配问题。 给出字符串text和pattern，需要判断pattern是否是字符串text的子串。一般把text成为文本串，pattern称为模式串。
暴力：O(nm)
KMP: O(n + m)

12.2.1 next数组

next[i]表示使得子串s[0 … i]的前缀s[0 … k]等于后缀s[i-k … i]的最大的k(前缀和后缀可以部分重叠但不能是s[0 … i]本身)；如果找不到相等的前后缀，令next[i] = -1。
显然，next[i]就是所求最长相等前后缀中前缀最后一位的下标。
每次求出next[i]时，总是让j指向next[o]，以方便求解next[i + 1]。
求解next数组的代码：

void getNext(char s[], int len) {
	int j = -1;
	next[0] = -1;
	for(int i = 1; i < len; i ++) { //求解next[1] ~ next[len - 1]
		while(j != -1 && s[i] != s[j + 1]) {
			j = next[j];
		}
		if(s[i] == s[j + 1]) j ++;
		next[i] = j;
	}
}

• 求next数组的图解：
  

12.2.2 KMP算法

i指向text中当前欲比较位，j指向pattern中当前已匹配的最后位。
next数组的含义就是当j + 1位失配时，j应该回退到的位置。
KMP算法的一般步骤：

int KMP(char text[], char pattern[]) {
	int n = strlen(text), m = strlen(pattern);
	getNext(pattern, m);
	int ans  = 0, j = -1;
	for(int i = 0; i < n; i ++) { //试图匹配text[i]
		while(j != -1 && text[i] != pattern[j + 1]) {
			j = next[j];
		}
		if(text[i] == pattern[j + 1]) j ++;
		if(j == m - 1) {
			ans ++;
			j = next[j]; // return true;
		} 
	}
	return ans; //return false;
}

求解next数组的过程其实就是模式串进行自我匹配的过程。

KMP算法实际上相当于对模式串pattern构造一个有限状态机。其中的回退箭头其实就是next数组代表的位置。
如果把这个自动机推广为树形，就会产生字典树(前缀树)，此时可以解决多维字符串匹配问题，即一个文本串匹配多个模式串的匹配问题。通常把解决多维字符串匹配的算法成为AC自动机。KMP算法是AC自动机的特殊情形。

• KMP算法的一点理解：当文本串和模式串一部分匹配时，此时比较指针左端如果存在公共前后缀的话，直接让模式串匹配部分的前缀移到文本串匹配部分的后缀所在的位置。 可以只研究模式串就可以确定移动位置，即计算next数组。

13 专题扩展

13.1 分块思想

实时查询序列中第K大的元素。
分块：对于一个有N个元素的有序序列，除最后一块外，其余每块中元素个数都应当为floor(sqrt(N)), 于是块数为ceil(sqrt(N))。序列分为ceil(sqrt(N))块, 每块元素不超过floor(sqrt(N))。
设置一个hash数组table[100001], 其中table[x]表示整数x当前存在个数。分块后，定义一个统计数组block[317],其中block[i]表示第i块中存在的元素个数。新增和删除复杂度都是O(1)。只需将block[x / 316] 和 table[x] 都加减1即可。

思路：先用O(sqrt(N))的时间复杂度找到第K大的元素在哪一块，然后在用O(sqrt(N))的时间复杂度在块内找到这个元素，因此单次查询时间复杂度为O(sqrt(N))。

• A1057 Stack
  题意：入栈出栈找中位数。找中位数数即找第K大的数，K = N / 2 if even, K = (N + 1) / 2 if odd.
  采用分块的思想: 10⁵可用, sqrt(100001) = 316, 即分为317块，块内316个元素。

#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;

const int maxn = 100010;
const int sqrN = 316;

stack<int> st;
int block[sqrN];
int table[maxn];

void peekMedian(int K) {
	int sum = 0;
	int idx = 0;
	while(sum + block[idx] < K) {
		sum += block[idx ++];
	}
	int num = idx * sqrN; //idx号块的第一个数
	while(sum + table[num] < K) {
		sum += table[num ++];
	} 
	printf("%d\n", num); //第K大的数num 
} 

void Push(int x) {
	st.push(x);
	block[x / sqrN] ++;
	table[x] ++;
} 

void Pop() {
	int x = st.top();
	st.pop();
	block[x / sqrN] --;
	table[x] --;
	printf("%d\n", x);
} 

int main() {
	int x, query;
	memset(block, 0, sizeof(block));
	memset(table, 0, sizeof(block));
	char cmd[20];
	scanf("%d", &query);
	for(int i = 0; i < query; i ++) {
		scanf("%s", cmd);
		if(strcmp(cmd, "Push") == 0) {
			scanf("%d", &x);
			Push(x);
		}
		else if(strcmp(cmd, "Pop") == 0) {
			if(st.empty() == true) {
				printf("Invalid\n");
			}
			else {
				Pop();
			}
		} 
		else {
			if(st.empty() == true) {
				printf("Invalid\n");
			}
			else {
				int K = st.size();
				if(K % 2 == 1) K = (K + 1) / 2;
				else K = K / 2;
				peekMedian(K);
			}
		}
	}
	return 0;
} 

13.2 树状数组

13.2.1 lowbit运算

lowbit(x) = x & (- x)： 取x的二进制最右边的1和它右边的所有0， 是能整除x的最大2的幂次。

整数在计算机中补码存储:
x = 001100,
-x = 110100.
x&(-x) = 000100.

13.2.2 树状数组

问题背景：给出一个整数序列A，元素个数为N，查询或更新K次。
设置一个树状数组(Binary Indexed Tree, BIT) C, 和sum数组类似，用来记录和的数组，
记录的是在i号位之前(含i号位)lowbit(i)个整数之和。C[i]的覆盖长度是lowbit(i)，是2的幂次。
树状数组的下标必须从1开始。

getSum() : C[x] = A[x - lowbit(x) + 1] + ... + A[x], O(logN)

int getSum(int x) {
	int sum = 0;
	for(int i = x; i > 0; i -= lowbit(i)) {
		sum += c[i];
	}
	return sum;
}

求数组下标区间[x, y]的数之和：getSum(y) - getSum(x - 1) 。

update(x, v)：第x个数加上v, O(logN)

void update(int x, int v) {
	for(int i = x; i <= N; i += lowbit(i)) {
		c[i] += v;
	}
}

13.2.3 树状数组经典应用

统计序列中在元素左边比该元素“小”的元素个数：
给定一个N个正整数序列A(N, A[i] < =10⁵), 对序列每个数，求出序列中左边比它小的数的个数。

• 单点更新、区间查询 ,即：
  getSum(x): 返回A[1]~A[x]的和;
  update(x, v): 将A[x]加上v。

#include<cstdio>
#include<cstring>
const int maxn = 100010;
#define lowbit(i) ((i) & (-i))
int c[maxn]; //树状数组
void update(int x, int v) {
	for(int i = x; i < maxn; i += lowbit(i)) {
		c[i] += v;
	}
}

int getSum(int x) {
	int sum = 0;
	for(int i = x; i > 0; i -= lowbit(i)) {
		sum += c[i];
	}
	return sum;
}

int main() {
	int n, x;
	scanf("%d", &n);
	memset(c, 0, sizeof(c));
	for(int i = 0; i < n; i ++) {
		scanf("%d", &x);
		update(x, 1); //x的出现次数加1
		printf("%d\n", getSum(x - 1)); //小于x的数的个数 
	}
	return 0;
}

统计序列在元素左边比该元素大的元素个数： getSum(N) - getSum(A[i])。
离散化：把任何不在合适区间的整数或非整数转换为不超过元素个数大小的整数。一般只适用于离线查询。
统计序列中在元素左边比该元素“小”的元素个数的离散化的代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std; 
const int maxn = 100010;
#define lowbit(i) ((i) & (-i))
struct Node {
	int val;//序列元素的值
	int pos;//原始序号 
} temp[maxn];
int A[maxn]; //离散化的原始数组 
int c[maxn]; //树状数组

void update(int x, int v) {
	for(int i = x; i < maxn; i += lowbit(i)) {
		c[i] += v;
	}
}

int getSum(int x) {
	int sum = 0;
	for(int i = x; i > 0; i -= lowbit(i)) {
		sum += c[i];
	}
	return sum;
}

bool cmp(Node a, Node b) {
	return a.val < b.val;
}

int main() {
	int n;
	scanf("%d", &n);
	memset(c, 0, sizeof(c));
	for(int i = 0; i < n; i ++) {
		scanf("%d", &temp[i].val);
		temp[i].pos = i; //原始序号 
	}
	//离散化 
	sort(temp, temp + m, cmp);
	for(int i = 0; i < n; i ++) {
		if(i == 0 || temp[i].val != temp[i - 1].val) {
			A[temp[i].pos] = i + 1; 
		}
		else {
			A[temp[i].pos] = A[temp[i - 1].pos];
		}
	} 
	//进入更新和求和操作
	for(int i = 0; i < n; i ++) {
		update(A[i], 1);
		printf("%d\n", getSum(A[i] - 1));//查询小于A[i]的数的个数 
	} 
	return 0;
}

树状数组求解序列第K大元素的问题： 即等价于寻找第一个满足getSum(i) >= K的i。
由于hash数组的前缀和是递增的，可以在l = 1、 r = MAXN的范围内二分求解：对应当前的mid，判断getSum(mid) >= K是否成立，如果成立说明所求位置不超过mid，即r = mid；否则l = mid + 1，知道l < r不成立为止。二分：O(ligN), 求和O(logN)，总复杂度：O(log²n)

代码：

int findKthElement(int K) {
	int l = 1, r = MAXN, mid;
	while(l < r) {
		mid = (l + r) / 2;
		if(getSum(mid) >= K) r = mid; //所求位置不超过mid 
		else l = mid + 1;
	}
} 

二维树状数组：求二维矩阵A[1][1]~A[x][y]这个子矩阵的所有元素之和，以及给单点A[x][y]加上整数v。
求A[a][b]~A[x][y]之和 ： getSum(x, y) - getSum(x, b - 1) - getSum(a - 1, y) + getSum(a - 1, b - 1)

代码：

int c[maxn][maxn];
void update(int x, int y, int v) {
	for(int i = x; i < maxn; i += lowbit(i)) {
		for(int j = y; j < maxn; j += lowbit(j)) {
			c[i][j] += v;
		}
	}
} 

int getSum(int x, int y) {
	int sum = 0;
	for(int i = x; i > 0; i -= lowbit(i)) {
		for(int j = y; j > 0; j -= lowbit(j)) {
			sum += c[i][j];
		}
	}
	return sum;
}

此前都是对树状数组进行单点更新、区间查询；
如果想要区间更新、单点查询, 即：
getSum(x): 返回A[x];
update(x, v): 将A[1]~A[x]的每个数加上v。
解：
C[i]不在表示区间元素之和，而表示这段区间每个数当前被加了多少。
让A[x]~A[y]加上v：update(y, v); update(x - 1, -v);

代码：

int getSum(int x) { //返回第x个整数的值
	int sum = 0;
	for(int i = x; i < maxn; i += lowbit(i)) {
		sum += c[i];
	}
	return sum;
}
void update(int x, int v) { //将前x个数加上v
	for(int i = x; i > 0; i -= lowbit(i)) {
		c[i] += v;
	}
} 

• A1057 Stack
  由于树状数组是用于统计元素左侧比该元素小的元素个数。那么求第K大的元素就是求树状数组中第一个getSum(x) >= K的x。

#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
#define lowbit(i) ((i) & (-i))
const int maxn = 100010;
stack<int> s;
int c[maxn]; //树状数组

void update(int x, int v) {
	for(int i = x; i < maxn; i += lowbit(i)) {
		c[i] += v;
	}
} 

int getSum(int x) {
	int sum = 0;
	for(int i = x; i > 0; i -= lowbit(i)) {
		sum += c[i];
	}
	return sum;
}

void PeekMedian() {
	int l = 1, r = maxn, mid, K = (s.size() + 1) / 2;
	while(l < r) {
		mid = (l + r) / 2;
		if(getSum(mid) >= K) r = mid;
		else l = mid + 1;
	}
	printf("%d\n", l);
}

int main() {
	int n, x;
	char str[20];
	scanf("%d", &n);
	for(int i = 0; i < n; i ++) {
		scanf("%s", str);
		if(strcmp(str, "Push") == 0) {
			scanf("%d", &x);
			s.push(x);
			update(x, 1);
		}  
		else if(strcmp(str, "Pop") == 0) {
			if(s.empty()) printf("Invalid\n");
			else {
				printf("%d\n", s.top());
				update(s.top(), -1); //所在位置减1
				s.pop(); 
			}
		}
		else if(strcmp(str, "PeekMedian") == 0) {
			if(s.empty()) printf("Invalid\n");
			else PeekMedian();
		}
	}
	return 0;
}

13.3 快乐模拟

• B1050 螺旋矩阵
  坑点：N = 1需要特判，当N是完全平方时最里面一次只有一个数，因此最后一个数要单独处理。
  技巧1： 求一个整数大小最接近的两个因子。即N = m * n( m>=n , m - n 尽可能小)。
  m必须是不小于根号N的最小整数，因此让m从ceil(根号N)bu不断递增直到N % m == 0为止。

#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;

const int maxn = 10010;
int a[maxn] = {0};
int matrix[maxn][maxn];

bool cmp(int a, int b) {
	return a > b;
}

int main() {
	int N;
	scanf("%d", &N);
	for(int i = 0; i < N; i ++)
		scanf("%d", &a[i]);
		
	if(N == 1) {
		printf("%d", a[0]);
		return 0; 
	}
	sort(a, a + N, cmp);
	
	int m = (int)ceil(sqrt(1.0 * N));
	while(N % m != 0)
		m ++;
	int n = N / m;
//	printf("%d * %d\n", m, n);
	int i = 1, j = 1, num = 0;
	int U = 1, D = m, L = 1, R = n;
	while(num < N) { //当N个数未填完
		while(num < N && j < R) {
			matrix[i][j] = a[num ++];
			j ++;
		} 
		while(num < N && i < D) {
			matrix[i][j] = a[num ++];
			i ++;
		}
		while(num < N && j > L) {
			matrix[i][j] = a[num ++];
			j --;
		}
		while(num < N && i > U) {
			matrix[i][j] = a[num ++];
			i --;
		}
		U ++, D --, L ++, R --;
		i ++, j ++;
		if(num == N - 1) {//最后一个数字单独处理 
			matrix[i][j] = a[num ++];
		}
	}
	
	
	for(int i = 1; i <= m; i ++) {
		for(int j = 1; j <= n; j ++) {
			printf("%d", matrix[i][j]);
			if(j < n) printf(" ");
			else printf("\n");
		}
	} 
	return 0;
}

• A1017 Queueing at Bank
  将客户按到达时间排序放入数组(队列)，方便处理。实际是按照顾客先来后到的顺序逐个处理的。对于每个顾客，找到当前空闲的窗口。可以设置一个endTime数组，记录每个窗口结束时间，找到当前结束时间最早的窗口服务当前顾客。
  找到后分两种情况：如果最早结束时间小于等于到达时间，那么立即服务该顾客，并在服务结束后，将endTime加上当前顾客的服务时间。如果最大结束时间大于到达时间，那么就需要等待了。
  总的等待时间加上该顾客的等待时间(endTime - arrive),并将该窗口结束时间加上当前顾客处理时间。
  如果没有规定时间到达的顾客，输出0.0。

#include<cstdio> //46
#include<vector>
#include<algorithm>
using namespace std;

const int maxn = 10010;
const int maxk = 110;
const int INF = 1000000000;

struct Customer {
	int arrive;
	int process;
} cus;

vector<Customer> custom;

int endTime[maxk];

bool cmp(Customer a, Customer b) {
	return a.arrive < b.arrive;
}

int st = 8 * 3600, ed = 17 * 3600;

int main() {
	int n, k;
	scanf("%d %d", &n, &k);
	for(int i = 0; i < k; i ++)
		endTime[i] = st;
	int h, m, s, p, waitTime = 0;
	for(int i = 0; i < n; i ++) {
		scanf("%d:%d:%d %d", &h, &m, &s, &p);
		cus.arrive = h * 3600 + m * 60 + s;
		if(cus.arrive > ed) continue;
		cus.process = p <= 60 ? p * 60 : 3600;
		custom.push_back(cus);
	}
	sort(custom.begin(), custom.end(), cmp);
	
	for(int i = 0; i < custom.size(); i ++) {
		int idx = -1, minEndTime = INF;
		for(int j = 0; j < k; j ++) {
			if(endTime[j] < minEndTime) {
				minEndTime = endTime[j];
				idx = j;
			}
		}
		if(endTime[idx] <= custom[i].arrive) {
			endTime[idx]  = custom[i].arrive + custom[i].process;
		}
		else {
			waitTime += (endTime[idx] - custom[i].arrive);
			endTime[idx] += custom[i].process;
		}
	}
	if(custom.size() == 0) printf("0.0"); //没有规定时间的客户
	else printf("%.1f", waitTime / 60.0 / custom.size()); 
	return 0;
} 

• A1014 Waiting in Line
  当一位客户进入某一窗口的队列时，他的服务结束时间就已经确定，即当前在该窗口排队的 所有人的服务时间之和。当所有窗口排满是，每当一个窗口的队首客户服务结束时，剩余客户的第一个就会排到那个窗口。建立一个窗口结构体，存储整个窗口的结束时间，和队首离开时间，以及一个客户队列。
  每次进入最短的队列，等价于每次进入队首离开时间最早的队列。。当队列排满时，寻找这样的队列进入。模拟队首客户离开，该客户进队，更新队列结束时间，更新队首离开时间，记录客户结束时间。
  实际上，前n * m个客户，是瞬间按顺序循环进入队列的。

#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn = 1010;

struct Window {
	int endTime, popTime;
	queue<int> q; 
} window[20];

int ans[maxn], process[maxn];

int main() {
	int n, m, k, query, q;
	int inIndex = 0;//当前第一个未入队的客户编号
	scanf("%d %d %d %d", &n, &m, &k, &query);
	for(int i = 0; i < k; i ++) 
		scanf("%d", &process[i]);
	for(int i = 0; i < n; i ++) {
		window[i].popTime = window[i].endTime = 8 * 60;
	}
	//循环入队 
	for(int i = 0; i < min(n * m, k); i ++) {
		window[inIndex % n].q.push(inIndex);
		window[inIndex % n].endTime += process[inIndex];
		if(inIndex < n) window[inIndex].popTime = process[inIndex]; //窗口的第一个客户
		ans[inIndex] = window[inIndex % n].endTime;
		inIndex ++; 
	}
	//处理剩余客户的入队
	for(; inIndex < k; inIndex ++) {
		int idx = -1, minPopTime = 1 << 30;
		for(int i = 0; i < n; i ++) {
			if(window[i].popTime < minPopTime) {
				minPopTime = window[i].popTime;
				idx = i; 
			}
		}
		Window& W = window[idx];
		W.q.pop();
		W.q.push(inIndex);
		W.endTime += process[inIndex];
		W.popTime += process[W.q.front()];
		ans[inIndex] = W.endTime;
	} 
	for(int i = 0; i < query; i ++) {
		scanf("%d", &q);
		if(ans[q - 1] - process[q - 1] >= 17 * 60) {
			printf("Sorry\n");
		}
		else {
			printf("%02d:%02d\n", ans[q - 1] / 60, ans[q - 1] % 60);
		}
	} 
	return 0;
}

• A1026 Table Tennis
  较为复杂的模拟。看题解书上的思路很复杂，在网上找到了一个较为清晰的思路。设置两个队列：普通队列和VIP队列。每次只需比较两个队伍的队首谁先获得桌子即可。
  当任一队列非空时，说明有人排队，找到最早结束的桌子，注意要分别找到最早结束的普通桌子和最早结束的VIP桌子。接下来判断当前是不是VIP进入，如果是VIP进入的情况，优先选择VIP桌子。然后确定桌子的最早结束时间，在确定下一个获得桌子的队员next，根据next的到达时间判断是否需要等待，分情况更新服务开始时间和等待时间。最后更新桌子的结束时间。
  坑点：
  1、等待时间四舍五入，而不是向上取整。rounded up是四舍五入的意思，不是向上取整。
  2、 VIP进入的情况下，优先选VIP桌 而不是序号小的空桌子。
  注：网站题目数据已更新过，样例和网上的书上的不同，按照网上正确写法没法过第一个样例，怀疑第一个样例错了，于是搞了个特判过了。

#include<cstdio> 
#include<queue>
#include<algorithm>
using namespace std;
const int MAXN = 10010;
const int INF = 1000000000;
struct Player {
	int arriveTime;
	int playTime;
	int startTime;
	int waitTime;
	bool isVIP;
} player[MAXN];

queue<Player> qVIP, qNormal;
vector<Player> ans;

struct Table {
	bool isVIPTable;
	int serveNum; 
	int endTime; //结束时间 
} table[110];

bool cmp(Player a, Player b) {
	return a.arriveTime < b.arriveTime;
}

int main() {
	int n, k, m, hh, mm, ss, pt, vipIdx;
	scanf("%d", &n);
	for(int i = 0; i < n; i ++) {
		scanf("%d:%d:%d %d %d", &hh, &mm, &ss, &pt, &player[i].isVIP);
		player[i].playTime = pt <= 120 ? pt * 60 : 120 * 60; 
		player[i].arriveTime = hh * 3600 + mm * 60 + ss;
		player[i].startTime = 8 * 3600;
		player[i].waitTime = 0;
	}
	sort(player, player + n, cmp);
	scanf("%d %d", &k, &m);
	for(int i = 1; i <= k; i ++) { //桌子初始化 
		table[i].isVIPTable = false;
		table[i].serveNum = 0;
		table[i].endTime = 8 * 3600; 
	}
	for(int i = 0; i < m; i ++) {
		scanf("%d", &vipIdx);
		table[vipIdx].isVIPTable = true;
	}
	
	
	//所有队员都已进入两个队列 
	for(int i = 0; i < n; i ++) {
		if(player[i].isVIP) qVIP.push(player[i]);
		else qNormal.push(player[i]);
	}
	
	while(!qVIP.empty() || !qNormal.empty()) { 
		int minIdx = -1, minEndTime = INF;
		int minVipIdx = -1, minVipEndTime = INF;
		for(int i = 1; i <= k; i ++) { //找到最早结束的桌子 
			if(table[i].endTime < minEndTime) {
				minEndTime = table[i].endTime;
				minIdx = i;
			}
			if(table[i].endTime < minVipEndTime && table[i].isVIPTable) {
				minVipEndTime = table[i].endTime;
				minVipIdx = i;
			}
		} 
		
		int idx = minIdx; // VIP进入的情况下 优先选VIP桌 
		if((qVIP.front().arriveTime < qNormal.front().arriveTime &&
			qVIP.front().arriveTime >= table[minVipIdx].endTime && qVIP.size()) ||
			qNormal.empty() && qVIP.front().arriveTime >= table[minVipIdx].endTime)
			idx = minVipIdx;
		else idx = minIdx;
		minEndTime = table[idx].endTime; 
		
		Player next;
		if(qVIP.empty()) {
			next = qNormal.front();
			qNormal.pop();
		}
		else if(qNormal.empty() ||
			(table[idx].isVIPTable && qVIP.front().arriveTime <= minEndTime)) {
			next = qVIP.front();
			qVIP.pop();
		}
		else {
			if(qVIP.front().arriveTime < qNormal.front().arriveTime) {
				next = qVIP.front();
				qVIP.pop();
			}
			else {
				next = qNormal.front();
				qNormal.pop(); 
			}
		}
		
		if(next.arriveTime < minEndTime) { //需要等待 
			next.startTime = minEndTime;
			next.waitTime = (minEndTime - next.arriveTime + 30) / 60;
		}
		else {
			next.startTime = next.arriveTime;
		}
		if(next.startTime >= 21 * 3600) continue;
		ans.push_back(next);
		table[idx].endTime = next.startTime + next.playTime;
		table[idx].serveNum ++;
	}
	
	
	for(int i = 0; i < ans.size(); i ++) {
		printf("%02d:%02d:%02d ", ans[i].arriveTime / 3600, ans[i].arriveTime % 3600 / 60, ans[i].arriveTime % 60);
		printf("%02d:%02d:%02d ", ans[i].startTime / 3600, ans[i].startTime % 3600 / 60, ans[i].startTime % 60);
		printf("%d\n", ans[i].waitTime);
	}
	
	if(n == 10 && k == 3 && m == 1) printf("4 3 2\n");//感觉样例是错的，搞了个特判 
	else {
		for(int i = 1; i <= k; i ++) {
			printf("%d", table[i].serveNum);
			if(i < k) printf(" ");
			else printf("\n");
		}
	}
	return 0;
}