前言：本篇博客内容总结自《算法笔记》。文章篇幅太长了，更多的内容请读者点击这一篇：PTA 算法笔记重点总结（二）。

文章目录

1 int 与 long long
2 字符常量
3 最大整数
4 scanf
5 printf
6 getchar 和 putchar
7 typedef
8 常用 math 函数
9 数组
10 gets() 和 puts()
11 string.h 头文件下的常用函数
12 sscanf 与 sprintf
13 引用
14 结构体
15 cin 与 cout
16 浮点数的比较
17 快速读取输入并输出结果
18 测试数据有多组
19 闰年的判断
20 进制转换
21 链表
22 HashTable妙用
23 最大公约数
24 最小公倍数
25 分数的表示和化简
- 25.1 分数的表示
- 25.2 分数的化简
- 25.3 分数的四则运算
- 25.4 分数的输出

1 int 与 long long

题目要求绝对值在 10910^9109 范围以内或32位整数，则定义为 int 型；
题目要求绝对值 101810^{18}1018 范围以内或64位整数，则定义为 long long 型；
此外，对 long long 型赋大于 231−12^{31}-1231−1 的初值时需要在后面加上LL。

long 是 long int 的简写，long long 是 long long int 的简写。在32位机器上，long int 和 int 都是4字节；在64位机器上，long long int 和 long int 都是8字节，而 int 是4字节。

int num;
long long bignum;
long long bignum = 1234567890123456LL;

2 字符常量

0 ~ 9 的 ASCII 码为 48 ~ 57、A ~ Z 的为 65 ~ 90、a ~ z 为 97 ~ 122。

char a = z;     // 错误：编译器会把 z 当作一个变量而不是值
char a = 'z';    // 正确：'z' 表明它是一个字符

由上面的代码可知，字符必须用单引号标注起来，目的是便于区分其为字符变量还是字符常量。赋值等号左边的 a 即为字符变量，右边的 ‘z’ 即为字符常量。

printf("%c %d", a, a); // 该语句输出结果是 z 122

由此可知以 %c 格式输出是字符，以 %d 格式输出是该字符的 ASCII 码值。

3 最大整数

定义最大 int 型正整数的两种方法：本质都是定义值为 232−12^{32} - 1232−1 的变量。

const int INF = (1 << 31) - 1;    // 利用位运算得到最大值
const int INF = 0x3fffffff;        // 直接定义最大的十六进制下的值

记住这里是左移31位，因为 C/C++ 中的数据都是补码，左移32位 INF 就成了-1。

print("%d", INF); // 输出的结果是 2147483647

4 scanf

容易出错的格式符：long long 为 %lld；float 为 %f；double 为 %lf；long double 为 %llf；数组或字符串不需要加取地址运算符(即 &)。

另外 %c 能够读入空格符跟换行符，而 %s 通过空格或换行来识别字符串的结束。

scanf("%s", str);
printf("%s", str);

输入 abcd efg 后输出的是 abcd。

5 printf

在 printf 中，double 型和 float 型的格式符都为 %f，这一点要和 scanf 区分开。long 和 long long 型的格式符分为 %ld 和 %lld。

下面两条语句可以分别输出百分号 “%” 以及反斜杠 “\”：

printf("%%");
printf("\\");

%md：使不足 m 位的 int 型变量以 m 位右对齐输出，高位（左边）用空格补齐；若变量本身超过 m 位则保持原样。

int a = 123, b = 1234567;
printf("%5d\n", a);
printf("%5d\n", b);
// 输出结果为123
1234567

%0md：当变量不足 m 位时用0而不是空格补齐。

int a = 123;
printf("%05d\n", a);
// 输出结果为
00123

%.mf：使浮点数按照“四舍六入五成双”保留 m 位小数输出。

6 getchar 和 putchar

前者读入单个字符，后者输出单个字符。getchar 可以识别并读取换行符。

7 typedef

用来给某一对象取别名。

typedef long long LL;
LL a = 123456789012345LL;

8 常用 math 函数

以下函数返回的均是 double 型的值。

ceil(double x) 返回向上取整后的数；

floor(double x) 返回向下取整后的数；

pow(double r, double p)：返回 rpr^prp；

sqrt(double x)：返回变量 x 的 算术平方根；

log(double x)：返回变量 x 的以自然对数为底的对数；

sin(double x)、cos(double x)、tan(double x)：返回弧度制变量 x（比如 π4\frac{\pi}{4}4π）的三角函数值；

asin(double x)、acos(double x)、atan(double x)：返回弧度制下变量 x 的反三角函数值；

round(double x)：返回变量 x 四舍五入第一位小数后取整的结果。

9 数组

如果数组比较大（大概 10610^6106 级别），则需要将其定义在主函数外面，否则会使程序异常退出。

定义数组 q，含100个元素，并用 memset 初始化为0：

#include<malloc.h> // malloc 函数的头文件
#include<cstring> // memset 函数的头文件int *q;
q = (int*)malloc(sizeof(int) * 100);
memset(q, 0, sizeof(q));

然后赋值，假设 q[0] = 0。

for(int *a = q + 1; a < q + 100; ++a)
{*a = *(a - 1) + 1;printf("%d\n", *a);
}

上面的循环相当于：

for(int i = 1; i < 100; ++i)
{q[i] = q[i - 1] + 1;printf("%d\n", q[i]);
}

memset 函数使用的是按字节赋值，即对每个字节赋值同样的值，这样组成 int 型的4个字节都会被赋成相同的值。而由于0的二进制补码为全0，-1的二进制补码为全1，赋值其他数则容易出错。如果要对数组赋其他值（例如1）就使用 fill 函数（memset 的执行速度更快）。

另外要注意的是，两个 int 型的指针相减，等价于求两个指针之间相差了几个 int。

10 gets() 和 puts()

gets() 用来输入一行字符串，并将其存放于一维数组中。它以回车符 ‘\n’ 作为输入结束的标志，但要注意它会将换行符作为数组的最后一个元素，即 ‘\0’ 之前。因此在用 scanf 读取完一个整数后，如果要需要使用 gets，需要先用 getchar 接收整数后的换行符，否则会导致 gets 只接受一个换行符。

puts() 用来输出一个字符串，并紧跟一个换行。

在 PAT 的题目中是不能使用 gets 函数的，其等价函数为 fgets，用法如下：

char *fgets(char *str, int n, FILE *stream); // n 是定义的字符数组的长度
// 比如常见的
fgets(str, 100, stdin); // 该语句会读入换行，因此字符数组中的最后一位是 '\n'

使用 cin 和 cout 时用如下语句：

cin.getline(char *str, int n);   // n 是定义的字符数组的长度
getline(cin, string str);       // 或者采用 string 类型的版本

11 string.h 头文件下的常用函数

strlen(字符数组)：该函数返回字符数组中第一个 ‘\0’ 前的字符的个数。

strcmp(字符数组1, 字符数组2)：该函数返回两个字符串大小的比较结果。若前者小于后者返回负整数，等于返回0，大于返回正整数。

strcpy(字符数组1, 字符数组2)：该函数把后者复制给前者，包括结束符 \0。

strcat(字符数组1, 字符数组2)：该函数把后者接到前者后面。

12 sscanf 与 sprintf

sscanf 的作用是把字符数组 str 中的内容以指定的格式写到其他变量中，顺序为从左至右，如：

int n;
double db;
char str1[100] = "2018:3.14,hello", str2[100];
sscanf(str1, "%d:%lf,%s", &n, &db, str2); // 把 str1 的内容按照指定的格式写入 str2 中
printf("n = %d, db = %.2f, str2 = %s\n", n, db, str2);// 输出结果是
n = 2018, db = 3.14, str2 = hello

sprintf 的作用刚好相反，是把其他类型变量写到字符数组 str 中，如：

int n = 12;
double db = 3.1415;
char str1[100], str2[100] = "good";
sprintf(str1, "%d:%.2f,%s", n, db, str2); // 把后面的变量按指定格式写入 str1 中
printf("str1 = %s\n", str1);// 输出结果是
str1 = 12:3.14,good

13 引用

引用产生的是变量的别名，因此常量不可使用引用。

14 结构体

通过重写构造函数可以实现对结构体变量的快速初始化，但如果重写过构造函数，就不能不经初始化就定义结构体变量。换句话说，重写构造函数会覆盖掉默认生成的构造函数，为了同时实现两者，需要将默认构造函数手动加上。如：

struct stu
{int id;char gender;// 手动写上默认构造函数，调用该函数就能不经过初始化定义结构体变量stu() {}                   // 重写的构造函数一，调用该函数需要提供一个参数进行初始化stu(char _gender) { gender = _gender; }// 重写的构造函数二，调用该函数需要提供两个参数进行初始化stu(int _id, char _gender)    {id = _id;gender = _gender;}
};

15 cin 与 cout

使用它俩需要加上如下代码：

#include<iostream>
using namespace std;

cin 的输入不指定格式，也不需要加取地址运算符，直接写变量名即可，如：

cin >> n >> db >> c >> str;

如果想要读入一整行，则需要使用 getline 函数，如：

char str[100];
cin.getline(str, 100);
//在 string 容器下为
string str;
getline(cin, str);

cout 的输出运算符是 “<<”，输出空格需要手动加上，如：

cout << n << " " << db << " " << "heihei" << endl;

如果需要控制输出精度，需要加上如下头文件：

#include<iomanip>cout << setiosflags(ios::fixed) << setprecision(2) << 123.4567 << endl;

很麻烦，还是建议使用 scanf 以及 printf。

16 浮点数的比较

不能使用传统的 “==”，因为计算机很难表示出准确的精度，所以需要使用宏定义以及差值判定的方法。

首先定义精度和圆周率（虽然也不知道为啥用到）：

const double eps = 1e-8;        // 精度
const double Pi = acos(-1.0);  // 圆周率

接着书写宏定义：

#define Equ(a, b) ((fabs((a) - (b))) < (eps)) // 相等的宏定义#define More(a, b) (((a) - (b)) > (eps))        // 大于的宏定义#define Less(a, b) (((a) - (b)) < (-eps))       // 小于的宏定义#define More(a, b) (((a) - (b)) >= (eps))      // 大于等于的宏定义#define Less(a, b) (((a) - (b)) <= (-eps))       // 小于等于的宏定义

解释一下上面的宏定义。当两个数的差值在一个绝对值范围之内时（第一条），可以近似的认为这两个数就是相等的，前提是范围足够小，这个范围就是精度。所以假定 a−ba - ba−b 的差值比精度的正值大，则说明 a>ba>ba>b，如果是比精度的负值小，则说明 a<ba<ba<b。大于等于和小于等于以此类推。

17 快速读取输入并输出结果

在 .cpp 所在文件夹下新建 “input.txt”，将要输入的数据复制到 txt 文本中，然后在代码的第一行加上如下语句，就不用手动输入测试数据，而会自动从文本文件中读取输入。

#include<cstdio> // 所必需的头文件freopen("input.txt", "r", stdin);

18 测试数据有多组

利用如下语句实现循环读取多组数据：

while (scanf("%d", &n) != EOF)
{...
}

19 闰年的判断

闰年的判断是：“能被4整除但不能被100整除的数 ”或者 “能被400整除的数”，即：

if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))return 1;
elsereturn 0;

说一下整除的概念：如果 b % a == 0（读作 b 取模 a，整个等式的意思是 b 取模 a 的余数为0）或者说 b / a = k（读作 b 除以 a），其中 k 是一个整数，则说明 b 能被 a 整除，b 是被除数，a 是除数。

20 进制转换

PPP 进制转十进制：
若有 PPP 进制数 x=a1a2⋅⋅⋅anx = a_1a_2···a_nx=a1a2⋅⋅⋅an（无小数部分），aka_kak 表示各个数位上的数，则 xxx 转换为十进制数 yyy 的公式是 y=a1∗Pn−1+a2∗Pn−2+...+an−1∗P+an∗P0y = a_1*P^{n - 1} + a_2*P^{n - 2}+...+a_{n - 1} * P + a_n * P^0y=a1∗Pn−1+a2∗Pn−2+...+an−1∗P+an∗P0，可以用循环实现：

int y = 0, product = 1;        // product 在循环中会不断乘 P，得到P、P^2、P^3...
while (x != 0)
{y = y + (x % 10) * product; // x % 10 是为了每次获取 x 的个位数x = x / 10;                 // 去掉 x 的个位product = product * P;
}

还有一种方法：假如 x=a1a2⋅⋅⋅anx = a_1a_2···a_nx=a1a2⋅⋅⋅an 依次存放于下标从0开始的数组 d 中，即 d[0]=a1,d[1]=a2d[0] = a_1, d[1] = a_2d[0]=a1,d[1]=a2 等等，换句话说，数的高位存放于数组的低位，则可以按照如下算法求出其对应的十进制数 yyy：

int y = 0;
for (int i = 0; i < d.length(); ++i)y = y * p + d[i];

这一算法很类似于读入用字符串表示的数字，然后将其转成整数的过程，只不过此时的 p = 10。

十进制转 PPP 进制数：
将十进制数 y 转换为 Q 进制数 z 采用除基取余法。将待转换数除以 Q，得到的余数作为低位存储在数组中，而商则继续除以 Q 并重复进行上面的操作，直到商为0为止，然后将所有位从高到低输出就可以得到 z：

int z[40], num = 0;     // 数组 z 存放 Q 进制数 y 的每一位，num 为位数
do {z[num++] = y % Q;    // 除基取余y = y / Q;
} while(y != 0);       // 当商不为0时进行循环，注意别漏了这里的分号

上述代码中使用 do…while 语句而不是 while 语句的原因是：如果十进制数 y 恰好等于0，使用 while 语句将使循环直接跳出，导致结果出错，而正确结果应是数组 z 中存放了 z[0] = 0。

21 链表

当元素个数小于 10510^5105 时使用静态链表，定义的时候注意不要把结构体类型名和结构体变量名取成相同的名字。

// 定义静态链表
struct Node
{   // Node是结构体类型名typename data;    // 数据域int next;         // 指针域，也即下一个元素的数组下标
} node[size];       // node 是数组名，也即结构体变量名

22 HashTable妙用

如果要统计一个字符串中所有字符各自出现的次数或者是否出现过，可以利用 HashTable 数组，如下所示。因为所有的字符都有唯一的 ASCII 码，因此可以将它们的 ASCII 码当作数组下标（索引）来使用。

int hashTable[128] = {0};
bool hashTable[128] = {false};

但是要注意的是，这样定义只适用于初始值为全0或全 false 的数组，一旦你想尝试以下的做法就会发现除了 hashTabel[0] 被赋值成功外其他仍然为全0或全 false。原因在于数组初始化时，若列表中的元素个数小于指定的数组长度时，不足的元素补以默认值。而在 C/C++ 中默认值是0和 false。

int hashTable[128] = {1};
bool hashTable[128] = {true};

可以使用 memset 函数来实现赋值非0和 true，例如下面的代码：

// 初始化 bool 型数组，赋值 true 实际上是赋值1
bool hashTable[128];
memset(hashTable, true, sizeof(hashTable));
// 初始化字符数组
char hashTable[128];
memset(hashTable, 'a', sizeof(hashTable));

但 memset 也只能用于字符数组或者 bool 型数组的初始化，因为它们的每一个元素都只占用一个字节。memset 的功能是对数组的每一个字节进行 ASCII 赋值，所以对非字符数组或非 bool 型数组进行非0赋值或初始化时不能用 memset 函数，只能循环处理/定义时初始化。例如经过下面的语句后，hashTable 数组的每个元素的二进制码为 0x01 01 01 01（16进制下的32位二进制），即为十进制的16843009。

int hashTable[128];
memset(hashTable, 1, sizeof(hashTable));

23 最大公约数

两个整数 a 和 b 的公约数（公因数）中最大的那个称为最大公约数，一般用 gcd(a, b) 来表示，常用求解方法为欧几里得算法（辗转相除法），其基本原理是 gcd(a, b) = gcd(b, a % b)。

证明：

设 a=kb+ra = kb + ra=kb+r，k 和 r 分别为 ab\frac{a}{b}ba 的商和余数，则有 r=a−kb=a%br = a - kb = a \% br=a−kb=a%b。
设 d 为 a 和 b 的任一公约数，因为 rd=a−kbd=ad−kbd\frac{r}{d} = \frac{a - kb}{d} = \frac{a}{d}-k \frac{b}{d}dr=da−kb=da−kdb 是一个整数，所以 d 也是 r 的约数，即 d 是 b 和 r 的公约数。
又因为 r = a % b，所以 d 是 b 和 a % b 的公约数，由 d 的任意性可知 a 和 b 的公约数都是 b 和 a % b 的公约数。
同理可证 b 和 a % b 的公约数都是 a 和 b 的公约数，因此 gcd(a, b) = gcd(b, a % b)。

由上面这个定理可知，如果 a < b，那么定理的结果就是将 a 和 b 交换；如果 a > b，通过这个定理可以使数据规模快速减小。利用递归式可以实现欧几里得算法，递归的边界为 b == 0，代码如下：

int gcd(int a, int b)
{if (b == 0) return a;else return gcd(b, a % b);
}
// 或者简洁点
int gcd(int a, int b)
{return !b ? a : gcd(b, a % b);
}

24 最小公倍数

两个整数 a 和 b 的公倍数中最小的那个称为最小公倍数，它在最大公约数的基础上求得，一般用 lcm(a, b) 来表示，其中 lcm(a, b) = a * b / d。由于 a * b 在实际计算时有可能溢出，因此更恰当的写法是 a / d * b。

25 分数的表示和化简

25.1 分数的表示

首先用结构体来存储分数：

要注意的是，由于分数的乘法和除法的过程中可能使分子或分母超过 int 型表示范围，因此一般情况下，分子和分母应当使用 long long 型来存储。

struct Fraction // 分数结构体
{long long up, down; // 分别表示分子和分母
};

约定三个规则：

down 为非负数。若分数是负数，令分子 up 为负数即可；
如果分数为0，则分子为0，分母为1；
分子和分母没有除了1以外的公约数。

25.2 分数的化简

分三步：

如果分母为负数，令分子 up 和分母 down 变为相反数；
如果分子 up 为0，令分母 down 为1；
约分：求出 up 的绝对值和 dwon 的绝对值的最大公约数 d，然后令分子分母同时除以 d。

Fraction reduction(Fraction result)
{if (result.down < 0)            // 分母为负，分子分母变相反数{result.up = -result.up;result.down = -result.down;}else if (result.up == 0)         // 分子为0，分母变1result.down = 1;else {  // 约分int d = gcd(abs(result.up), abs(result.down));    // 求分子分母的最大公约数result.up = result.up / d;                       // 约去最大公约数result.down = result.down / d;}return result;
}

25.3 分数的四则运算

加法公式：result=f1.up∗f2.down+f2.up∗f1.downf1.down∗f2.downresult = \frac{f1.up * f2.down + f2.up * f1.down}{f1.down * f2.down}result=f1.down∗f2.downf1.up∗f2.down+f2.up∗f1.down
减法公式：result=f1.up∗f2.down−f2.up∗f1.downf1.down∗f2.downresult = \frac{f1.up * f2.down - f2.up * f1.down}{f1.down * f2.down}result=f1.down∗f2.downf1.up∗f2.down−f2.up∗f1.down
乘法公式：result=f1.up∗f2.upf1.down∗f2.downresult = \frac{f1.up * f2.up}{f1.down * f2.down}result=f1.down∗f2.downf1.up∗f2.up
除法公式：result=f1.up∗f2.downf1.down∗f2.upresult = \frac{f1.up * f2.down}{f1.down * f2.up}result=f1.down∗f2.upf1.up∗f2.down

Fraction add(Fraction f1, Fraction f2)       // 分数加法
{Fraction result;result.up = f1.up * f2.down + f2.up * f1.down;result.down = f1.down * f2.down;return reduction(result);             // 返回化简后的结果
}Fraction minus(Fraction f1, Fraction f2)   // 分数减法
{Fraction result;result.up = f1.up * f2.down - f2.up * f1.down;result.down = f1.down * f2.down;return reduction(result);              // 返回化简后的结果
}Fraction multiply(Fraction f1, Fraction f2)     // 分数乘法
{Fraction result;result.up = f1.up * f2.up;result.down = f1.down * f2.down;return reduction(result);              // 返回化简后的结果
}Fraction divide(Fraction f1, Fraction f2)  // 分数除法
{Fraction result;result.up = f1.up * f2.down;result.down = f1.down * f2.up;return reduction(result);              // 返回化简后的结果
}

25.4 分数的输出

四个注意点：

输出前先化简；
若分母 down 为1，说明其是整数。视题目而定要不要省略分母；
分子 up 的绝对值大于分母 down 时，说明其为假分数，需要按带分数的形式输出。整数部分为 r.up / r.down（因为 r.up 可能为负数，故用除法可以保证负号给到假分数的整数部分），分子部分为 abs(r.up) % r.down，分母部分不变；
以上均不满足时说明分数 r 是真分数，按原样输出即可。

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);elseprintf("%lld / %lld", r.up, r.down);    // 真分数
}

希望本篇博客能对你有所帮助，也希望看官能动动小手点个赞哟~~。

OJ 刷题必备知识总结（一）相关推荐

LeetCode 牛客网 C++ 算法刷题必备基础知识
LeetCode 牛客网 C++ 算法刷题必备基础知识 {ignore} 文章目录 LeetCode 牛客网 C++ 算法刷题必备基础知识 {ignore} main综合模板数组排序库字符串库 ...
各大OJ刷题平台汇总
前言想成为一名高级工程师,算法还是要有的,至少在入门编程和进入公司之前都是必备的.刷题也可以很好的锻炼动手能力和逻辑思维,今天就给大家介绍一些知名的在线刷题平台,都是干货哦! 力扣(leetcode ...
程序员跳槽面试刷题必备，微软工程师放大招！| 程序员硬核评测
整理 | 一一出品 | AI科技大本营(ID:rgznai100) 春节刚过,年终奖收入囊中,属于工程师们一年一度的跳槽季也来了. 跳槽后薪水翻倍自然爽歪歪,但最怕的是面试翻车,那就悲剧了.可想而知 ...
JAVA最常用容器、API(全是干货，刷题必备高效工具！)
包含众多资源,都是自己两年间自己总结的,都是非常非常常用的.有各大容器.以及配套工具类的讲解,还有常用API,以及JAVA8中的Lambda.函数式接口,全文很长,全是干货,刷题必备!请参看目录阅读! ...
python oj刷题网站_程序员常用的刷题网站
1.Lintcode Lintcode.com--LintCode网站是国内较大的在线编程&测评网站.此网站提供各大IT公司的算法面试题类型,行分门别类,由简单到中等,再到难,便于不同水平的程 ...
python oj刷题网站_中小学计算机竞赛去哪里刷题？橙旭园OJ系统上线啦！
原标题:中小学计算机竞赛去哪里刷题?橙旭园OJ系统上线啦! 相信许多人在学习完编程之后都会茫然,感觉自己无所不能,但是当敲代码时却大脑一片空白.在这里向大家介绍练习和提高代码水平的新姿势--橙旭园OJ ...
leetcode c程序总提示主函数_帅气中国小哥出“大招”，程序员跳槽面试刷题必备...
整理 | 一一出品 | AI科技大本营春节刚过,年终奖收入囊中,属于工程师们一年一度的跳槽季也来了. 跳槽后薪水翻倍自然爽歪歪,但最怕的是面试翻车,那就悲剧了.可想而知,想要跳槽或者为春招准备的毕 ...
帅气中国小哥出“大招”，程序员跳槽面试刷题必备
整理 | 一一出品 | AI科技大本营春节刚过,年终奖收入囊中,属于工程师们一年一度的跳槽季也来了. 跳槽后薪水翻倍自然爽歪歪,但最怕的是面试翻车,那就悲剧了.可想而知,想要跳槽或者为春招准备的毕 ...
帅气中国小哥出“大招”，程序员跳槽面试刷题必备vscode-leetcode
转载自:https://blog.csdn.net/dQCFKyQDXYm3F8rB0/article/details/87658008 整理 | 一一出品 | AI科技大本营春节刚过,年终奖收入 ...

OJ 刷题必备知识总结（一）