lzl's blog

Java 笔记 (chapter 02)

Thu, 30 Jan 2025 00:00:00 GMT

接 chapter 1 的 Java 基础知识

Java 基础知识

⭐运算符

运算符介绍

算术运算符 +(正) -(负) +(加) -(减) *(乘) /(除) %(取余) ++(自增) --(自减) +(字符串拼接)
关系运算符 (比较运算符) == $\ \ $ != $\ \ $ < $\ \ $ > $\ \ $ <= $\ \ $ >= $\ \ $ instanceof
逻辑运算符 && $\ \ $ || $\ \ $ & $\ \ $ | $\ \ $ ! $\ \ $ ^ 短路与（&&），短路或（||），逻辑非（!），逻辑与（&），逻辑或（|），^（逻辑异或）
赋值运算符 = $\ \ $ += $\ \ $ -= $\ \ $ *= $\ \ $ /= $\ \ $ %=
位运算符 | $\ \ $ & $\ \ $ >> $\ \ $ << $\ \ $ >>> $\ \ $
三元运算符 a > b ? a : b

:::note 取模本质：a % b = a - a / b * b :::

System.out.println(10 % 3); // 1
System.out.println(-10 % 3); // -1
System.out.println(10 % -3); // 1
System.out.println(-10 % -3); // -1

System.out.println(-10.5 % 3); // -1.5

:::important 观察可发现，结果的正负值与被除数一致；如果a为小数,a%b=a-(int)a/b*b; :::

关于自增自减的细节

// 规则就是使用临时变量
int i = 1;
i = i ++ ; // (1) tmp = i; (2)i = i + 1; (3) i = tmp;
System.out.println(i); // 1 

int i = 1;
i = ++i; // (1)i = i + 1; (2) tmp = i; (3) i = tmp;
System.out.println(i); // 2

逻辑运算和位运算

& $\ \ $ && | $\ \ $ || 除了本来的逻辑判断外,&& 和||在判断过程中有短路的特性, (条件1)&&(条件2) 只要条件1为false,则结果为false,条件2判断式不再执行 (条件1)||(条件2) 只要条件1为true,则结果为true,条件2判断式不再执行

a=1
if((1>2)&&(a++>2))
{
    pass;
}
sout(a);
//a=1
=============================
a=1
if((1<2)||(a++>2))
{   
    pass;
}
sout(a);
//a=1

而逻辑与（&）和逻辑或（&）则没有短路的特性 (条件1)&(条件2) 无论条件1结果为T/F,条件2判断式都会执行 (条件1)|(条件2) 无论条件1结果为T/F,条件2判断式都会执行

a=1
if((1>2)&(a++>2))
{
    pass;
}
sout(a);
//a=2
=============================
a=1
if((1<2)|(a++>2))
{   
    pass;
}
sout(a);
//a=3

赋值运算符 =

顺序从左往右
左侧为变量,右侧可以是变量,表达式,常量值 a=b;a=10-3*2;a=20;
a+=3;等价于a=a+3
复合赋值运算会进行类型转换

byte b=2;
b+=3;
//等价于 b=(byte)b+3;
//如果写b=b+3会报错;

运算符优先级

优先级	符号	名称	结合性（与操作数）	目数	说明
1	.	点	从左至右	双目
	()	圆括号	从左至右
	[]	方括号	从左至右
2	+	正号	从右至左	单目
	-	负号	从右至左	单目
	++	自增	从右至左	单目	前缀增，后缀增
	--	自减	从右至左	单目	前缀减，后缀减
	~	按位取反符	从右至左	单目	适用于整数类型
	!	逻辑非运算符	从右至左	单目	适用于布尔类型
3	*	乘	从左至右	双目
	/	除	从左至右	双目	除号两边是整型数据为整数除法：取商的整数部分，小数部分去掉，不四舍五入
	/	取余	从左至右	双目
4	+	加	从左至右	双目
	-	减	从左至右	双目
5	<<	左移位运算符	从左至右	双目
	>>	右移位运算符	从左至右	双目
	>>>	无符号右移	从左至右	双目
6	<	小于	从左至右	双目
	>	大于	从左至右	双目
	<=	小于或等于	从左至右	双目
	>=	大于或等于	从左至右	双目
	instanceof	确定某对象是否属于指定的类或者子类	从左至右	双目
7	==	等于	从左至右	双目
	!=	不等于	从左至右	双目
8	&	逻辑与	从左至右	双目
9	\|	逻辑或	从左至右	双目
10	^	逻辑异或	从左至右	双目
11	&&	短路与	从左至右	双目
12	\|\|	短路或	从左至右	双目
13	? :	条件运算符	从右至左	三目
14	=	赋值运算符	从右至左	双目
	+= 或者 -= 或者 *= 或者 /= 或者 %= 或者 >>= 或者 <<= 或者>>>= 或者 &= 或者 \|= 或者 ^=	混合赋值运算符	从右至左	双目

单目乘除为关系，逻辑三目后赋值 1点,括号2单目3算术4位移5比较6逻辑7三元8赋值

标识符

大小英文字母，数字下划线和$
数字不能开头
不能包含关键字和保留字
严格区别大小写

保留字：byValue, cast, future, generic, inner, operator, outer, rest, var, goto, const

标识符命名规范

包名：多单词组成时所有字母都小写：aaa.bbb.ccc // com.lzl.spring
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz【大驼峰】
变量名、方法名：多单词组成时，第一个首字母小写，第二个单词开始每个单词首字母大写
常量名：所有字母大写。多单词时每个单词用下划线链接：XXX_YYY_ZZZ

包名 aaa.bbb.ccc com.zbx.stu
类名,接口名 XxxYyyZxx TankShotGame
变量名,方法名 xxxYyyZzz peopleName
常量名 XXX_YYY_ZZZ COLUMN_LONG 列长度 ROW_LONG 行长度

⭐进制表示

二进制 0b 0B 0b1010 $\rightarrow$ 10
八进制 0 011 $\rightarrow$ 9
十进制 10 $\rightarrow$ 10
十六进制 0x 0X 0x11 $\rightarrow$ 17

位运算

~2 按位取反
2&3 按位与
2|3 按位或
>> 算术右移:符号位不变,低位溢出,符号位补溢出的高位
<< 算术左移:符号位不变,低位补0
>>> 逻辑右移,也叫无符号右移:低位溢出,高位补0
<<< 没有这个

原码反码补码

在java当中 随机一个整数默认int,随机一个小数默认double

最高位是符号位 0 正数,1负数
正数: 原码反码补码保持一致
负数: 反码符号位不变其他取反
负数: 补码=反码+1，反码=补码-1 （貌似补码的反码+1是原码）
0: 反码,补码都是0
java没有unsigned 没有无符号数
计算机运算时,以补码方式运算
人类看结果,为原码

+2的原码与及其的补码是一致的 00000000 00000000 00000000 00000010 -3的原码如下： 10000000 00000000 00000000 00000011 -3的反码如下： 11111111 11111111 11111111 11111100 -3的补码如下:
11111111 11111111 11111111 11111101

:::tip 如果给定一个int范围内的二进制数，如何求其十进制为多少？ 解答：细节1 必须要有32位才可能是负数 细节2 负数处理：假设负数是 x ，则 x 的带符号反码 + 1 = (-x)，因此， x 的带符号反码 = (-x)-1，所以 x = （-1）* （x 的带符号反码） - 1 为什么需要 x 的带符号反码来处理？因为 x 的带符号反码的首位是最高位是0，可以按照正数的方式处理 为什么不是 x 的带符号反码 + 1 之后再乘 -1 ，因为如果 x = -2147483648，则（-x）int 范围无法表示 :::

:::note 随堂小测

int i = 66;
System.out.println(++i + i); // 134
double num = 3d; // 正确，3d 表示 double 类型的 3

:::

控制结构

顺序
分支(if else switch)
循环(for,while,do while)
break
continue
return

程序流程控制

顺序控制
分支控制
循环控制

顺序控制

正常的从上往下的程序流程

分支控制

分支控制结构有单分支结构（只有一个 if 结构）、双分支结构（有 if-else 两个结构）、多分支结构（如下面结构所示）以及下一小小小节的嵌套分支结构，再加上switch-case结构的分支结构

if(条件表达式){
    代码块;
}
else if{
    代码块;
}
......
else{
    代码块;
}

多分支最后可以没有else

嵌套分支结构

嵌套分支结构,在一个分支结构当中嵌套了另一个完整的分支结构. 规范:不要超过3层,可读性不好

if(){
    if(){
        //if else
    }else{
        //if else
    }
}else{
    //if else
}

switch-case

switch(表达式){
    case 常量1:   //当...,执行语句
        语句块1:
        break;    //退出switch
    case 常量2:
        语句块2: 
        break;  
    case 常量3:
        语句块3:
        break;
        
        ......    
    case 常量n:
        语句块n: 
        break;
    default:
        default语句块;
        break;  
  
}

switch注意事项

表达式数据类型应该和case之后的常量类型一致，或者是可以自动转换可以相互比较的类型
siwtch(表达式)中表达式的返回值必须是(byte,short,int,char,enum(枚举),String)
case子句的值必须是常量
default子句是可选的，没有匹配的case时，执行default
break语句用来执行完一个case分支后，使程序跳出switch，如果没有break，则会顺序执行到switch结尾（这个时候是不会走case，直接走对应的语句块），除非遇到一个break

:::note 第一点的意思是假设表达式为 char，case子句中是 int，这样是可以的，例子如下：

char c = 'a';
switch(c) {
  case 'a': 
    break;
  case 20:
    break;
  default:
    break;
}

:::

default和break的三种特殊情况

第一种
switch (i) {     
    default:     
         System.out.println("默认");    
    case 1:     
         System.out.println("1");     
    case 2:     
         System.out.println("2");   
    case 3:     
         System.out.println("3");     
} 
当给定义i=1时，输出的结果为： 结果为 1,2,3 
当给定义i=2时，输出的结果为： 结果为 2,3
当给定义i=3时，输出的结果为： 结果为 3
当给定义i=4时，输出的结果为： 结果为 默认，1,2,3

当i匹配到的时候它会走到匹配的位置，而且还会继续运行之后的代码，直到最后位置，当匹配不到是，他会都输出一遍
=========================================
第二种
switch (i) {        
    case 1:     
         System.out.println("1");   
    default:     
         System.out.println("默认");   
    case 2:     
         System.out.println("2");   
    case 3:     
         System.out.println("3");     
} 
当给定义i=1时，输出的结果为： 结果为 1,默认,2,3 
当给定义i=2时，输出的结果为： 结果为 2,3
当给定义i=3时，输出的结果为： 结果为 3
当给定义i=4时，输出的结果为： 结果为  默认,2,3

当i匹配到的时候它会走到匹配的位置，而且还会继续运行之后的代码，直到最后位置，当匹配不到是，他会从default起到以下都输出一遍
===========================================
第三种
switch (i) {        
    case 1:     
         System.out.println("1");     
    case 2:     
         System.out.println("2");   
    case 3:     
         System.out.println("3");   
    default:     
         System.out.println("默认");   
} 
当给定义i=1时，输出的结果为： 结果为 1，2,3，默认 
当给定义i=2时，输出的结果为： 结果为 2,3，默认 
当给定义i=3时，输出的结果为： 结果为 3，默认
当给定义i=4时，输出的结果为： 结果为  默认

当i匹配到的时候它会走到匹配的位置，而且还会继续运行之后的代码，直到最后位置，当匹配不到是，他只会输出default下的语句

循环控制

for循环

循环条件是返回一个boolean值的表达式 i<=10
for(初始化;循环条件;变量迭代)当中的初始化和变量迭代可以写到其他地方

int i=0;
for( ;i<=10; ){
    sout("hello");
    i++;
}

初始化值可以是多个，但类型要求一样，之间用”,“分隔开,变量迭代也一样

for(int i=0,j=1;i<=10;i++,j+=2){

}

for循环顺序

for({1};{2};{3})
{
    {4};
}
执行顺序为1,2,4,3;

for 中 i++ 和 ++i 的区别

i++ ++i 效果一样 :::important ++i数据多的时候比i++更快,因为 i++ 需要临时变量 :::

while循环

初始化变量;
while(循环条件){
    循环体;
    变量迭代;
}

do while循环

初始化变量;
do{
    循环体;
    变量迭代;
} while(循环条件);

break

跳出循环

使用标签时，可以指定跳出那一层循环
label1:是标签，可以随意指定，修改
break label2:跳出label2层，可以指定
尽量不使用标签
break之后没有标签，默认跳出最近的一层

//break 可以使用标签，指定终止那一层
label1:
for (int i = 1; i <= 5; i++) {
    label2:
    for (int j = 1; j <= 3; j++) {
        System.out.println(i + " " + j);
        if (i == 2) {
            // break label1;
            break label2;
        }
    }
}

continue

跳出当前循环，再进行循环,进行下一次的循环判断

continue也可以使用标签，和break用法一致
continue没有标签，跳过最近的循环
continue 的标签也尽量少使用

return

跳出方法，返回值
用在main时，退出程序

第二章暂时讲到这，这章重点为运算符与进制表示

Java 笔记 (chapter 01)

Sun, 26 Jan 2025 00:00:00 GMT

Java历史

1995 v1

Java se $\ \ \ $ 标准版

Java ee $\ \ \ $ 企业版

Java me(Micro Edition) $\ \ \ $ 小型版 $\ \ \ $ 基本不用

Java特点

面向对象
强类型机制，异常处理，垃圾自动回收
跨平台
解释性语言(也有 jvm 中热点代码先编译再执行)

:::tip

Java 的安全性、健壮性和严谨性是强类型语言的一重要体现；
Java的强类型语言对数据类型兼容性的要求比任何语言都要严格；
每个变量有类型，每个表达式有类型，而且每种类型是严格定义的。其次，所有的数值传递，不管是直接的还是通过方法调用经由参数传过去的都要先进行类型相容性的检查；
Java 编译器对所有的表达式和参数都要进行类型相容性的检查以保证类型是兼容的。任何类型的不匹配都是错误的，在编译器完成编译以前，错误必须被改正；
初期你可能发现 Java 的强制类型检查有点繁烦。但是要记住，从长远来说它将帮助你减少程序出错的可能性。 :::

解释性语言 js,Java 编译性语言 c c++

区别

解释性语言，编译后的代码，不能被机器直接执行，需要解释器.
编译性语言,编译后的代码(bin)，可以直接被机器执行

JVM & JDK & JRE 之间的关系

JVM(Java Virtual Machine)

JVM 虚拟计算机，具有指令集并使用不同的存储区域，复制执行指令，管理数据，内存，寄存器，包含在JDK当中
不同的平台，有不同的虚拟机
Java虚拟机机制屏蔽了底层运行平台的差异，实现一次编译，到处运行

JRE介绍

JRE(Java runtime environment Java运行环境)
JRE=JVM + Java核心类库
JRE包含 JVM 和 Java 程序所需要的核心类库

JDK(Java Development Kit)

JDK —— Java开发工具包
JDK = JRE + Java的开发工具(Java Javac Javadoc Javap等)

小结

JDK= JRE + Java开发工具 JRE = JVM+Java核心类库 JDK = JRE ( JVM + 核心类库 ) + Java开发工具

Java执行流程

.java文件(源文件)------>.class文件(字节码文件)------>结果

javac编译

Java装载到JVM执行

Java开发细节

一个Java源文件可以有多个class类,但最多一个public类 一个源文件最多一个public类，其他类不限，可以将main方法写在非public类当中, 然后指定运行非public类，这样入口方法就是非public的main方法

public class HelloWorld {
    //有几个class类 编译之后就有几个.class 文件
    //可以使用Java dog单独运行dog.class或cat.class
    public static void main(String[] args) {
        System.out.println("hello world!");
    }
}
class dog {
    public static void main(String[] args) {
        System.out.println("dog");
    }
}
class cat {
    public static void main(String[] args) {
        System.out.println("cat");
    }
}

:::note 一个文件里面只有一个 public 类，和其他没有修饰词的类

并且这些类里面都可以有main函数，并且可以自己主动调用别的函数的main函数（类名.main） :::

面对不断变化的新世界，我们该如何应对？

如何学习新技术

需求
1. 工作需要
2. 跳槽，对方要求
3. 技术控
能否用传统技术解决？
1. 能解决，但不完美
2. 解决不了

时刻询问自己，新技术到底给我带来了什么优势？

引出我们学习的新技术和知识点
学习新技术或者知识点的基本语句和基本语法（不要考虑细节）
快速入门（基本程序，crud）
开始考虑研究技术的注意事项，使用细节，使用规范，如何优化

优化无止境，技术魅力

转义字符

\t tab
\n 换行
\ 一个\
\" 一个"
\' 一个'
\r 一个回车

回车和换行的区别：回车是把当前光标放到目前的第一行

// 传统编译运行在终端中输出 xxxhh
// 在IDEA中输出xxx
System.out.println("hhhhh\rxxx");

接下来开启基础知识的导航

Java 基础知识

注释

单行 // 多行 /**/

文档注释

/**

* @author lzl~
* @version 1.0
*/

public class demo2_ChangeChar {
    /**
     * @author zbx
     * @version 1.0
     * */
    public static void main(String[] args) {
        System.out.println("demo1\tdemo\tdemo");
    }
}

使用javadoc -d [filename] -xx -yy [javaFile],可以生成一套网页文件形式的文档说明

:::tip 注意 [filename] 表示一个参数，这里参数表示Java文件所在文件夹的名字

[javaFile] 表示 java 源文件 :::

javadoc -d d://temp -xx -yy 当前java源文件 xx yy 指的是使用到的标签，即 author 和 version 等

更多的一定要看以下 javadoc 相关文档

https://www.cnblogs.com/linj7/p/14339381.html

java 规范

部分规范

类、方法的注释，要以javadoc的方式来写
非javadoc的注释，往往是给代码的维护者看的，着重告诉读者为什么这么写，如何修改，注意什么问题等
使用tab操作，实现缩进，默认整体向右边移动，用 shift+tab整体向左移动
运算符和=习惯两边加空格
源文件使用utf-8编码
行宽度不要超过80字符
代码编写次行风格和行尾风格(说的是花括号)

dos 命令

tree [dir]
cls # 清屏
exit # 退出
md
rd
echo
type
del
copy
move

:::tip [dir] 表示文件目录 :::

⭐变量

变量是程序的基本组成单位

类型名称 = 值 int a = 1;

不同的类型占用不同的空间大小 8bit=1byte

变量表示内存中的一个存储区域

变量=变量名+值+数据类型

+号的使用

加号左右两边都是数值时，做加法运算
加号左右两边有一方是字符串时，做拼接运算

public class demo3_var3 {
    public static void main(String[] args) {

        int a = 50;
        int b = 20;
        String s = "hello";

        System.out.println(a + b);
        System.out.println(a + s);
    }
}

结果 70 50hello

数据类型

1,基本数据类型 2,引用数据类型

基本数据类型包括

1数值型,2字符型,3bool型 1.1 byte[1],short[2],int[4],long[8] 1.2 float[4],double[8] 浮点数 = 符号位 + 指数位 + 尾数位 2.1 char[2] 3.1 boolean[1]

引用数据类型包括 1class类,2interface接口,3[]数组

:::note 浮点默认double，要float后面需要加 f :::

整型细节

int n = 1L; // 错误，不能long类型赋值给 int 类型

浮点细节

浮点默认double，要float后面需要加 f

float num = 1.1; // 错误，得 1.1f

浮点数表示：0.512, .512, 512.0f （十进制数形式）5.12e2（科学计数法）

推荐使用 double，精度更高

浮点数陷阱，进行大小判断时要小心

double a = 2.7;
double b = 8.1 / 3;
 // b != 2.7  ×
 // Math.fabs(b - 2.7) < eps √

:::note Java API文档：https://www.matools.com/api/java8 :::

char 细节

char c = 97; // 字符类型可以直接存放一个数字

编码：Unicode（固定两个字节）, ASCII（一个字节）, utf-8（字母1字节，汉字3字节）, GBK（字母1字节，汉字2字节）, gb2312(gb2312<GBK), big5 (繁体中文，台湾，香港)

:::important 接下来这块非常重要，基本数据类型转换和强制类型转换的规则要熟悉 :::

⭐基本数据类型转换

在java当中随机一个整数默认int,随机一个小数默认double 精度小的类型可以自动转换为精度大的类型 char-->int-->long-->float-->double byte-->short-->int-->long-->float-->double

有多种数据类型混合运算时,系统将自动将所有数据转换为精度最大的数据类型,再计算
当将精度大的数据赋值给精度小的数据类型时,会报错,反之会自动转换
(byte,short)和char之间不会相互自动转换
byte,short,char 三者之间可以计算,在计算时首先转换为int类型
boolean不参与转换
自动提升原则:表达式的结果自动提升为操作数当中最大的类型（和第一条意思差不多）

byte b = 10;
char c = b; // 错误，原因 byte 不能自动转成 char
int n = 1;
b = n; // 错误，变量赋值会根据变量类型进行判断
short s = 1;
short s2 = s + b; // 错误，byte, short,char 运算 -> int
byte b1 = 11;
byte b2 = b1 + b; // 错误，全部是某种类型也会变成 int 类型
boolean pass = true;
int num100 = pass; // 错误，boolean 不参与类型的自动转换
byte b4 = 1; 
short s3 = 100;
int num200 = 1;
double num300 = 1.1;
double num500 = b4 + s3 + num200 + num300 // double 类型

:::important 此处知识点很好地体现了Java为何为强类型机制，因为这些类型一旦不对，就会报错 :::

强制类型转换

会造成丢失精度和溢出问题

int n1 = (int) 1.9;
System.out.println("n1 = " + n1);

//溢出
byte b = (byte) 2000;
System.out.println("b = " + b);

结果
n1 = 1
b = -48

数据类型从大到小需要强制转换
强转符合只针对最近的操作数有效,小括号可提高优先级
char可以保存int的常量值,但不能保存int的变量值,需要强转
byte和short类型在运算时,当作int类型处理
byte 和 short 只能保存它们类型范围内常量值

:::note 关于上述第三点：char c = 90 可以，但是 int a = 90; char c = a; 不可 :::

short s = 12; // ok
s = s - 9; // error  int -> short 但是 s -= 9 是正确的
byte b = 10; // ok
b = b + 11; // error int->byte
b = (byte)(b + 11); // ok
char c = 'a'; // ok
int i = 16; // ok
float d = .314F; // ok
double result = c + i + d; // ok float -> double
short t = s + b; // error int -> short

基本数据类型和String类型的转换

基本数据类型转String 基本数据类型+ ""
String类型转基本数据类型 调用parseXXX方法

:::tip 事实上还有更多互相转换的方法 :::

第一章暂时讲到这，这章重点为变量类型这块

第144场双周赛 && 第425场周赛第三、四题

Mon, 25 Nov 2024 00:00:00 GMT

该系列只写每周周赛的第三、四题。使用语言主 JAVA, 副 c++ 。

144 双周赛第三题

题目链接：https://leetcode.cn/problems/zero-array-transformation-iii/

题目大意

有一个长度为 $n$ 的 nums 数组，然后有二维数组 queries ，其中 $queries[i]$=$[l_i,r_i]$

substract 操作：对于任意一个 $[l_i, r_i]$，可以选择在这个区间内每个数至多减 1

现需要你在 queries 删除最多的区间，使得依然可以在剩余的区间里面进行 substract 操作使得 nums 数组最终所有值为 0

数据范围

$1\le n \le 10^5$
$0 \le nums[i] \le 10^5$
$1 \le queries.length \le 10^5$
$queries[i].length == 2$
$0 \le l_i \le r_i \lt n$

题解

差分+贪心

时间复杂度$O(nlogn)$

既然题目要求的是减一，那我反转一下，对一个长度为 $n$，值全为 0 的数组 d 利用 queries 数组进行加 1 操作，也就是 add 操作。

先考虑无解的情况，现在如果对 queries 中的每个区间的每个数都加 1，如果存在有 d[i] < nums[i]，则说明此时无解。

换句话说，如果最后留下的区间，然后对每个区间都利用 add 操作使得最后 d 数组每个数都有 $d[i] \ge nums[i]$ ，则说明留下的这组区间是满足题意的。因此，问题转化为删除最多的区间，对剩下的区间进行 add 操作，使得对一个初始值为 0 的数组最后每一个值都 $的d[i] \ge nums[i]$

由于这里有每个区间都加 1 的操作，自然而言要想到差分，将区间加变成一个 $O(1)$ 的操作。

接下来考虑整体怎么做？

看到这个数据范围，又是区间，可以尝试想一想贪心做法，一般来说可以尝试对区间进行排序，那么按照什么进行排序？左端点还是右端点？既然无论如果 nums[0] 一定会被覆盖住，不妨就就先按照左端点排序，左端点相同的情况下，自然右端点更大更好

排好序之后，从左到右遍历区间，来考虑遍历的过程中会发生什么？

如果当前遍历到区间 $[l_i,r_i]$ 。也就是说当前区间的左端点是 $l_i$，也就是要保证 $d[k] \ge nums[k], k\in[0,l_i-1]$，否则应该提前返回无解的情况，因此需要使用 cur 来维护当前尚未满足 $d[cur] \ge nums[cur]$ 的最小值、
如果 $cur == l_i$，如果此时 $d[cur] >= nums[cur]$，此时的区间并不会丢弃，而是应该放入候选集中，而且只用存右端点的值，并且候选集根据右端点从大到小选择，因此这里使用优先队列来维护候选集。
如果 $cur < l_i$，说明 $d[k], k\in [cur, l_i-1]$ 只能用候选集里面的元素进行覆盖，由于这些候选集里面左端点在区间 $[0,cur-1]$ 之间，因此可以只用对区间 $[cur, t]$ 进行 add 操作（t 是堆顶元素）
这里有个小优化，往 queries 加入区间 [n,n]，然后对于 $cur==l_i$ 的情形，只需要将右端点加入队中即可。因为 step3 最终会在候选集中选择合适的区间。

这个贪心思路的核心思想在于尽可能地使用范围比较大的区间，同时不随便放弃任意一个区间，除非 $t \lt cur$，也就是堆顶元素小于当前处理到的 d 数组位置。

c++代码如下：

const int N = 100010;
int d[N];
class Solution {
public:
    priority_queue<int> Q;
    void init(int n) {
        for (int i = 0; i <= n + 2; i ++ ) d[i] = 0;
    }
    void withdraw(int cur) {
        int t = Q.top(); Q.pop();
        d[cur] ++ ; d[t + 1] -- ;
    }
    int maxRemoval(vector<int>& nums, vector<vector<int>>& queries) {
        int n = nums.size();
        queries.push_back(vector<int>{n, n});
        int m = queries.size();
        init(n);

        sort(queries.begin(), queries.end(), [&](const vector<int>& a, const vector<int>& b) {
            if (a[0] == b[0]) return a[1] > b[1];
            return a[0] < b[0];
        });
        
        int cur = 1; // cur 表示当前 d[cur] 尚未 d[cur] += d[cur - 1];
        int cnt = 0; // cnt 计算需要多少数量的答案
        int q = 0;
        while (q < m) {
            auto &qe = queries[q];
            int l = qe[0], r = qe[1];
            l ++ ; r ++ ;
            while (l > cur) {
                
                while (!Q.empty() && d[cur] + d[cur - 1] < nums[cur - 1]) {
                    if (Q.top() < cur) break;
                    withdraw(cur);
                    cnt ++ ;
                }
                if (d[cur] + d[cur - 1] < nums[cur - 1]) return -1;
                d[cur] += d[cur - 1];
                cur ++ ;
            }
            // l == cur
            Q.push(r);
            q ++ ;
        }
        // 出来 q == m， cur > n
        return m - cnt - 1;
    }
};

java代码如下：

class Solution {
    public int maxRemoval(int[] nums, int[][] queries) {
        int n = nums.length;
        int m = queries.length;
        List<Integer>[] list = new List[n];
        for (int i = 0; i < n; i ++ ) list[i] = new ArrayList<>();
        for (int[] q: queries) list[q[0]].add(q[1]);

        int pre = 0;
        int cnt = 0;
        int[] d = new int[n + 1];
        PriorityQueue<Integer> Q = new PriorityQueue<>(n, (a, b) ->  b - a);
        for (int i = 0; i < n; i ++ ) {
            
            for (Integer j: list[i]) Q.offer(j);
            while (!Q.isEmpty() && pre + d[i] < nums[i]) {
                if (Q.peek() < i) return -1;
                int t = Q.poll();
                d[i] ++ ; d[t + 1] -- ;
                cnt ++ ;
            }
            if (pre + d[i] < nums[i]) return -1;
            pre += d[i];
        }
        return m - cnt;
    }
}

:::tip sort 那里语法一定要是 const vector<int>& a，弄成引用传递，不然会超时 :::

144 双周赛第四题

题目链接：https://leetcode.cn/problems/find-the-maximum-number-of-fruits-collected/description/

题目大意

有一个 $n\times n$ 的二维数组，数组里面每个数都有一个权值。现有三个起点，分别为 $(0,0),(0,n-1),(n-1,0)$，从这三个起点出发只走 $n - 1$ 步，并且最终要达到 $(n-1,n-1)$，在移动过程中可以累加路径上的权值，但是二维数组里面的每个数（权值）只能相加一次。问：满足题意的最大权值之和？

另外：

起点为 $(0,0)$ 只能走 $(i+1,j+1),(i+1,j),(i,j+1)$ 这三个方向
起点为 $(n-1,0)$ 只能走 $(i,j+1),(i-1,j+1),(i+1, j+1)$ 这三个方向
起点为 $(0, n-1)$ 只能走 $(i+1, j),(i+1,j+1),(i+1,j-1)$ 这三个方向

数据范围

fruits 表示二维数组

$2 \le n = fruits.length=fruits[i].length\le 1000$
$0 \le fruits[i][j] \le 1000$

题解

动态规划

时间复杂度$O(n^2)$

注意到这三个起点到 $(n-1,n-1)$ 都只能走 $n-1$ 步

对于 $(0,0)$，根据题意的走法，只能一直走 $(i+1,j+1)$ 方向才能恰好 $n-1$ 步到达终点
对于 $(n-1,0),(0,n-1)$ 事实上可以将其理解为经典题目数字三角形，甚至比数字三角形更简单，起点和终点方向此处是一致的。

对于该题，三个起点可以分别计算，起点为 $(0,0)$ 的可以提前对角线的权值累加，并且置为 0，那么同时根据题目特性，$(n-1,0),(0,n-1)$ 到达终点的全部路径，除了可能在对角线位置有交集，其余位置没有交集，因此可以独立计算。

而正好后两种情况是可以看作一个数字三角形的题来解，因此使用动态规划求解即可。

代码如下：

class Solution {
    static final int INF = 0x3f3f3f3f;
    int[][] f, g;
    public int maxCollectedFruits(int[][] fruits) {
        int ans = 0;
        int n = fruits.length;

        for (int i = 0; i < n; i ++ ) {
            ans += fruits[i][i];
                System.out.println(fruits[i][i]);
            
            fruits[i][i] = 0;
        }
        f = new int[n][n];
        g = new int[n][n];

        for (int i = 0; i < n; i ++ ) Arrays.fill(f[i], -INF);
        f[n - 1][0] = fruits[n - 1][0];
        for (int i = 1; i < n; i ++ ) { // 列
            for (int j = 0; j < n; j ++ ) { // 行
                if (j - 1 >= 0) f[j][i] = Math.max(f[j][i], f[j - 1][i - 1] + fruits[j][i]);
                f[j][i] = Math.max(f[j][i], f[j][i - 1] + fruits[j][i]);
                if (j + 1 < n) f[j][i] = Math.max(f[j][i], f[j + 1][i - 1] + fruits[j][i]);
            }
        }
        ans += f[n - 1][n - 1];

        for (int i = 0; i < n; i ++ ) Arrays.fill(g[i], -INF);
        g[0][n - 1] = fruits[0][n - 1];
        for (int i = 1; i < n; i ++ ) { // 行
            for (int j = 0; j < n; j ++ ) { // 列
                if (j - 1 >= 0) g[i][j] = Math.max(g[i][j], g[i - 1][j - 1] + fruits[i][j]);
                g[i][j] = Math.max(g[i][j], g[i - 1][j] + fruits[i][j]);
                if (j + 1 < n) g[i][j] = Math.max(g[i][j], g[i - 1][j + 1] + fruits[i][j]);
            }
        }
        ans += g[n - 1][n - 1];
        return ans;
    }
}

:::note 这道题事实上可以通过旋转二维数组做到只计算一次 dp， hh~ :::

第 425 场周赛第三题

题目链接：https://leetcode.cn/problems/minimum-array-sum/description/

题目大意

给定一个整数数组 nums 和三个整数 $k^\prime$,op1,op2 可以对 nums 执行以下操作：

操作1：选择一个下标 i，将 nums[i] 除以 2，并向上取整。可以最多执行该操作 op1 次，并且每个下标最多只能执行一次
操作2：选择一个下标 i，仅当 nums[i] 大于或者等于 $k^\prime$ 时，从 nums[i] 中减去 $k^\prime$ 。最多可以执行该操作 op2 次，并且每个下标最多只能执行一次

两种操作可以应用于同一下标，但每种操作最多只能应用一次。

返回在执行任意次数的操作后，nums 中所有元素的最小可能和

数据范围

$1\le nums.length \le 100$
$0 \le nums[i] \le 10^5$
$0 \le $k^\prime$ \le 10^5$
$0 \le op1,op2 \le nums.length$

题解

动态规划

时间复杂度$O(n\cdot op1 \cdot op2)$

这道题读完题之后，再看数据范围，就感觉可能是动态规划，猜出状态为 $f(i,j,k)$ 表示在数组 $nums[1-i]$ 中最多进行 $j$ 次操作1 和最多进行 $k$ 次操作 2 的所有最小可能和‘

因此，最终答案就是 $f(n, op1, op2)$ ，$n$ 是数组的长度

现在开始进行集合划分，也就是递推关系式的思考。

首先初始化 $f$，也就是说 $f(i,j,k)$ 等于前 $i$ 个元素的和，其中 $f(0,j,k)=0$

考虑特殊情况，如果 $op2=0$，那么就按照 $nums[i]$ 这个数进行集合划分，分为需不需要在 $nums[i]$ 上进行操作 1，因此 $f(i, j, 0) = min{f(i, j,0), f(i-1,j,0), f(i-1,j-1,0)-nums[i]/2}$

如果 $op1=0$，同样也是按照 $nums[i]$ 这个数进行集合划分，分为需不需要在 $nums[i]$ 上进行操作 2，当然也需要满足题目的限制条件: $$ f(i,0,j) = min{f(i,0,j), f(i-1,0,j), f(i-1,0,j-1)-k^\prime} \ , nums[i] \ge k^\prime $$

一般情况下，也就是 $op1>0,op2>0$，同样也是按照 $nums[i]$ 进行集合划分，此时可以同时对 $nums[i]$ 进行操作 1 和操作 2（如果满足条件的话）。首先考虑单独进行操作 1 和操作2，然后再进行操作 1 和操作 2 的组合。如果 $nums[i] \ge 2k^\prime-1$，那么一定是先应用操作 1 再应用操作 2，如果 $k^\prime\le nums[i] \lt 2k^\prime-1$，则必须先应用操作 2 再应用操作 1。因此，递推式如下 $$ f(i,j,k)= min \begin{cases} f(i,j,k) , \ f(i, j-1,k) - nums[i]/2, \ f(i, j,k-1) - k^\prime, \ \ if \ nums[i] \ge k^\prime\ f(i,i-1,j-1) - nums[i]/2-k^\prime, \ \ if \ nums[i] \ge 2*k^\prime-1 \ f(i,i-1,j-1)-k-(nums[i]-k)/2, \ \ if \ k^\prime\le nums[i] \lt 2k^\prime-1 \end{cases} $$

java代码如下

class Solution {
    final int INF = 0x3f3f3f3f;
    int[][][] f;
    public int minArraySum(int[] nums, int kt, int op1, int op2) {

        int n = nums.length;
        f = new int[n + 1][op1 + 1][op2 + 1];

        int t = 0;
        for (int i = 0; i < n; i ++ ) {
            t += nums[i];
            for (int x = 0; x <= op1; x ++ )
                for (int y = 0; y <= op2; y ++ )
                    f[i + 1][x][y] = t;
        }
        for (int i = 1; i <= n; i ++ ) {
            int v = nums[i - 1];
            for (int j = 1; j <= op1; j ++ )
                f[i][j][0] = Math.min(f[i][j][0], Math.min(f[i - 1][j][0], f[i - 1][j - 1][0] - v / 2) + v);
            for (int k = 1; k <= op2; k ++ ) {
                f[i][0][k] = Math.min(f[i][0][k], f[i-1][0][k] + v);
                if (v >= kt) f[i][0][k] = Math.min(f[i][0][k], f[i - 1][0][k - 1] - kt + v);
            }
            for (int j = 1; j <= op1; j ++ )
                for (int k = 1; k <= op2; k ++ ) {
                    f[i][j][k] = Math.min(f[i][j][k], Math.min(f[i - 1][j][k], f[i - 1][j - 1][k] - v / 2) + v);
                    if (v >= kt) f[i][j][k] = Math.min(f[i][j][k], f[i - 1][j][k - 1] - kt + v);
                    if (v >= 2 * kt - 1) f[i][j][k] = Math.min(f[i][j][k], f[i - 1][j - 1][k - 1] - v / 2 - kt + v);
                    if (v >= kt && v < 2 * kt - 1) f[i][j][k] = Math.min(f[i][j][k], f[i - 1][j - 1][k - 1] - kt - (v - kt) / 2 + v);
                }
            
        }
        return f[n][op1][op2];
    }
}

第 425 场周赛第四题

题目链接：https://leetcode.cn/problems/maximize-sum-of-weights-after-edge-removals/description/

题目大意

给定一棵 $n$ 个结点的无向树，结点编号是 $0$~$n-1$ ，给定一个数组 edges，其中 $edges[i]=[u_i, v_i, w_i]$，代表结点 $u_i,v_i$ 之间有一条边。

现在需要你移除零条边或者多条边，使得

每个结点与至多 $k$ 个其他结点有边直接相连，其中 $k$ 是给定的输入
剩余边的权重之和的最大化

求剩余边的权重的最大可能和

数据范围

$2 \le n \le 10^5$
$1 \le k \le n - 1$
$edges.length = n-1$
$edges[i] = 3$
$0 \le edges[i][0] \le n - 1$
$0 \le edges[i][1] \le n - 1$
$1 \le edges[i][2] \le 10^6$
保证edges形成一棵有效的树

题解

树形 dp, 贪心

时间复杂度$O(nlogn)$

题目有说这是一棵无根树，一般情况下会从一个结点开始，让其作为根节点，这里以 0 为根节点。

然后树上的问题很容易找到子问题，我们仔细思考，对于一个以 $r$ 为根结点的树，如果该结点满足题目条件，那么与 $r$ 相关的边肯定不会删除，那么就只需要考虑其孩子结点即可，而以孩子结点为根的子树不影响 $r$ 为根的树，因此，可以考虑使用树形dp来求解。

以 $f(i,0/1)$ 表示以 $i$ 结点为根的子树并且其唯一入度边的状态为 $0/1$（0表示不删除，1表示删除）的最大价值。因此答案为 $f(0,0)$，根节点为 0，根节点没有入度边，因此表示不删除即可。

如果根节点的入度边删除，那么表示其出度边最多只能有 $k-1$ 条。

因此，无非是需要保留的边减少了，这里我们忽略这些细节，就考虑以 $r$ 为根，并且出度边至多只能保留 $k$ 条的最大价值，$f(r,0),f(r,1)$ 的求法是一样的。

首先递归求出 $f(r_1, 0),f(r_2,0),\cdots,f(r_x,0)$, 以及 $f(r_1,1),f(r_2,1),\cdots,f(r_x,1)$

首先，如果 $f(r_y,0) \le f(r_y,1)$ ，换句话说删了 $(r,r_y)$ 这条边比不删好，那何乐而不为，直接删掉，也就是说此时累加 $f(r_y,1)$ 即可

因此，接下来只需要考虑 $f(r_y,0) \gt f(r_y,1)$ 的情况，看下面的 note 便可求解。

:::note 这里我抽象出一个问题：给你一个长度为 $n$ 的两个数组，分别为 $A,B$，其中 $A[i] \gt B[i]$，现在让你至多选 $k$ 个 $A$ 数组里面的数（注意，选了 $A[i]$ 就不能选 $B[i]$)，然后其余选 $B$ 数组里面的数，怎么选累和最大？答：因为这里 $A[i] \gt B[i]$，因此最多选 $k$ 个，那就是选 $k$，除非 $n \lt k$。假设选了 $k$ 个，分别为 $A[1],\cdots,A[k]$，其余选的 $B[k+1],\cdots,B[n]$ 。如果此时从选择的 $k$ 个中挑出 $A[x]$，从其余部分挑出 $B[y]$ ，将其交换到不同集合中去，我们看看累和的变化： $$ \Delta=A[1]+\cdots+A[k]+B[k]+\cdots+B[n]- \ (A[1]+\cdots+A[y]+\cdots+A[k]+B[k+1]+\cdots+B[x]+\cdots+B[n]) = \ A[x] - A[y] + B[y] - B[x] $$ 如果要使得无论怎么交换 $\Delta$ 的值都是减少的，也就是说当 $\Delta\gt 0$ 时，也就是 $A[x]-B[x] \gt A[y] - B[y]$ 时，一定是最优解。因此，如果我们按照 $A[x]-B[x]$ 进行排序，只需要选前 $k$ 个数为 A，后面的为 B, 则一定累和最大。 :::

JAVA代码如下

class Solution {
    int[] h, e, ne, w;
    long[][] f;
    int idx = 0;
    class Node implements Comparable<Node> {
        long x, y; // x 是包含的 y 是不包含的
        @Override
        public int compareTo(Node o) {
            if (x - y == o.x - o.y) return 0;
            return x - y - (o.x - o.y) > 0 ? -1 : 1;
        }
    }

    void add(int a, int b, int c) {
        e[idx] = b;
        w[idx] = c;
        ne[idx] = h[a];
        h[a] = idx ++ ;
    }
    void init(int n) {
        h = new int[n];
        e = new int[n << 1];
        ne = new int[n << 1];
        w = new int[n << 1];
        Arrays.fill(h, -1);
        f = new long[n][2];
        for (int i = 0; i < n; i ++ ) f[i][0] = f[i][1] = -1;
    }
    long dp(int u, int fa, int isIn, int k) {
       if (f[u][isIn] != -1) return f[u][isIn];
        int cnt = 0;
        for (int i = h[u]; i != -1; i = ne[i]) {
            int v = e[i];
            if (v == fa) continue;
            f[v][0] = dp(v, u, 0, k);
            f[v][1] = dp(v, u, 1, k);
           // System.out.println(u + " " + v + " " + w[i]);

            cnt ++ ;
        }
        Node[] tmp = new Node[cnt]; // 必须是局部变量
        for (int i = h[u], j = 0; i != -1; i = ne[i]) {
            int v = e[i];
            if (v == fa) continue;
            tmp[j] = new Node();
            tmp[j].y = f[v][0];
            tmp[j].x = f[v][1] + w[i];
            j ++ ;
        }
        Arrays.sort(tmp, 0, cnt);
        long ans = 0;
        for (int i = 0; i < cnt; i ++ )
            if (i < k - isIn && tmp[i].x > tmp[i].y) ans += tmp[i].x;
            else ans += tmp[i].y;
        return f[u][isIn] = ans;
    }
    public long maximizeSumOfWeights(int[][] edges, int k) {
        int n = edges.length; 
        init(n + 1);
        for (int[] e: edges) {
            add(e[0], e[1], e[2]);
            add(e[1], e[0], e[2]);
        }
        return dp(0, -1, 0, k);
    }
}

:::tip 这几道题中，按照这四道题的顺序，第一、四题是比较苦难的，首先第一个涉及到了贪心，可能不好想，第二个细节比较多。

另外第三题还有一个贪心解，这里暂时不做探究。 :::

mybatis 必知必解

Fri, 25 Oct 2024 00:00:00 GMT

关于mybatis的各种配置信息以及语法之类的，也包含了部分需要的日志、测试单元的写法

Mybatis简介

MyBatis历史

MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github
iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

sql maps 是数据库数据与java数据的映射，也是封装jdbc的过程

DAO：通过mybatis实现

MyBatis特性

MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架

高级映射：满足一对多，多对一的情形
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集

不用写jdbc代码
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录

sql语句在xml或者注解中写vb
MyBatis 是一个半自动的ORM（Object Relation Mapping）框架

jdbc，纯手动；mybatis，需要自己写sql；hiberlate，全自动，sql是生成。ORM，关系对象映射。对象$\leftrightarrow$ 数据

MyBatis下载

MyBatis下载地址

和其它持久化层技术对比

JDBC
- SQL 夹杂在Java代码中耦合度高，导致硬编码内伤 (代码写死了)
- 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
- 代码冗长，开发效率低
Hibernate 和 JPA
- 操作简便，开发效率高
- 程序中的长难复杂 SQL 需要绕过框架
- 内部自动生产的 SQL，不容易做特殊优化
- 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
- 反射操作太多，导致数据库性能下降
MyBatis
- 轻量级，性能出色
- SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
- 开发效率稍逊于HIbernate，但是完全能够接受

搭建MyBatis

开发环境

IDE：idea 2019.2
构建工具：maven 3.5.4
MySQL版本：MySQL 5.7
MyBatis版本：MyBatis 3.5.7

创建maven工程

打包方式：jar

引入依赖

<dependencies>
	<!-- Mybatis核心 -->
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.5.7</version>
	</dependency>
	<!-- junit测试 -->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		<scope>test</scope>
	</dependency>
	<!-- MySQL驱动 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.3</version>
		</dependency>
</dependencies>

创建MyBatis的核心配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息核心配置文件存放的位置是src/main/resources目录下

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE configuration  
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
"http://mybatis.org/dtd/mybatis-3-config.dtd">  
<configuration>  
	<!--设置连接数据库的环境-->  
	<environments default="development">  
		<environment id="development">  
			<transactionManager type="JDBC"/>  
			<dataSource type="POOLED">  
				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>  
				<property name="url" value="jdbc:mysql://localhost:3306/MyBatis"/>  
				<property name="username" value="root"/>  
				<property name="password" value="123456"/>  
			</dataSource>  
		</environment>  
	</environments>  
	<!--引入映射文件-->  
	<mappers>  
		<mapper resource="mappers/UserMapper.xml"/>  
	</mappers>  
</configuration>

创建mapper接口

MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类

package com.atguigu.mybatis.mapper;  
  
public interface UserMapper {  
	/**  
	* 添加用户信息  
	*/  
	int insertUser();  
}

创建MyBatis的映射文件

相关概念：ORM（Object Relationship Mapping）对象关系映射。
对象：Java的实体类对象
- 关系：关系型数据库
- 映射：二者之间的对应关系

Java概念	数据库概念
类	表
属性	字段/列
对象	记录/行

映射文件的命名规则
表所对应的实体类的类名+Mapper.xml
- 例如：表t_user，映射的实体类为User，所对应的映射文件为UserMapper.xml
- 因此一个映射文件对应一个实体类，对应一张表的操作
- MyBatis映射文件用于编写SQL，访问以及操作表中的数据
- MyBatis映射文件存放的位置是src/main/resources/mappers目录下
MyBatis中可以面向接口操作数据，要保证两个一致
mapper接口的全类名和映射文件的命名空间（namespace）保持一致
- mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper  
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
<mapper namespace="com.atguigu.mybatis.mapper.UserMapper">  
	<!--int insertUser();-->  
	<insert id="insertUser">  
		insert into t_user values(null,'张三','123',23,'女')  
	</insert>  
</mapper>

通过junit测试功能

SqlSession：代表Java程序和数据库之间的会话。（HttpSession是Java程序和浏览器之间的会话）
SqlSessionFactory：是“生产”SqlSession的“工厂”
工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象

public class UserMapperTest {
    @Test
    public void testInsertUser() throws IOException {
        //读取MyBatis的核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
        //SqlSession sqlSession = sqlSessionFactory.openSession();
	    //创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交  
		SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //通过代理模式创建UserMapper接口的代理实现类对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
        int result = userMapper.insertUser();
        //提交事务
        //sqlSession.commit();
        System.out.println("result:" + result);
    }
}

此时需要手动提交事务，如果要自动提交事务，则在获取sqlSession对象时，使用SqlSession sqlSession = sqlSessionFactory.openSession(true);，传入一个Boolean类型的参数，值为true，这样就可以自动提交

加入log4j日志功能

加入依赖

<!-- log4j日志 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>

加入log4j的配置文件

log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下
日志的级别：FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试) 从左到右打印的内容越来越详细

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

核心配置文件详解

核心配置文件中的标签必须按照固定的顺序(有的标签可以不写，但顺序一定不能乱)： properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、reflectorFactory、plugins、environments、databaseIdProvider、mappers

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//MyBatis.org//DTD Config 3.0//EN"
        "http://MyBatis.org/dtd/MyBatis-3-config.dtd">
<configuration>
    <!--引入properties文件，此时就可以${属性名}的方式访问属性值-->
    <properties resource="jdbc.properties"></properties>
    <settings>
        <!--将表中字段的下划线自动转换为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>
    <typeAliases>
        <!--
        typeAlias：设置某个具体的类型的别名
        属性：
        type：需要设置别名的类型的全 类名
        alias：设置此类型的别名，且别名不区分大小写。若不设置此属性，该类型拥有默认的别名，即类名
        -->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User"></typeAlias>-->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User" alias="user">
        </typeAlias>-->
        <!--以包为单位，设置改包下所有的类型都拥有默认的别名，即类名且不区分大小写-->
        <package name="com.atguigu.mybatis.bean"/>
    </typeAliases>
    <!--
    environments：设置多个连接数据库的环境
    属性：
	    default：设置默认使用的环境的id
    -->
    <environments default="mysql_test">
        <!--
        environment：设置具体的连接数据库的环境信息
        属性：
	        id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id，表示默认使用的环境 
        -->
        <environment id="mysql_test">
            <!--
            transactionManager：设置事务管理方式
            属性：
	            type：设置事务管理方式，type="JDBC|MANAGED"
	            type="JDBC"：设置当前环境的事务管理都必须手动处理（提交或回滚）
	            type="MANAGED"：设置事务被管理，例如spring中的AOP
            -->
            <transactionManager type="JDBC"/>
            <!--
            dataSource：设置数据源
            属性：
	            type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
	            type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
	            type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
	            type="JNDI"：调用上下文中的数据源
            -->
            <dataSource type="POOLED">
                <!--设置驱动类的全类名-->
                <property name="driver" value="${jdbc.driver}"/>
                <!--设置连接数据库的连接地址-->
                <property name="url" value="${jdbc.url}"/>
                <!--设置连接数据库的用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--设置连接数据库的密码-->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <!-- <mapper resource="UserMapper.xml"/> -->
        <!--
        以包为单位，将包下所有的映射文件引入核心配置文件
        注意：
			1. 此方式必须保证mapper接口和mapper映射文件必须在相同的包下
			2. mapper接口要和mapper映射文件的名字一致
        -->
        <package name="com.atguigu.mybatis.mapper"/>
    </mappers>
</configuration>

默认的类型别名

MyBatis的增删改查

添加

<!--int insertUser();-->
<insert id="insertUser">
	insert into t_user values(null,'admin','123456',23,'男','12345@qq.com')
</insert>

删除

<!--int deleteUser();-->
 <delete id="deleteUser">
     delete from t_user where id = 6
 </delete>

修改

<!--int updateUser();-->
 <update id="updateUser">
     update t_user set username = '张三' where id = 5
 </update>

查询一个实体类对象

<!--User getUserById();-->  
<select id="getUserById" resultType="com.atguigu.mybatis.bean.User">  
	select * from t_user where id = 2  
</select>

查询集合

<!--List<User> getUserList();-->
<select id="getUserList" resultType="com.atguigu.mybatis.bean.User">
	select * from t_user
</select>

注意：
1. 查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射关系
  - resultType：自动映射，用于属性名和表中字段名一致的情况
  - resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况
2. 当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

MyBatis获取参数值的两种方式（重点）

MyBatis获取参数值的两种方式：${}和#{}
${}的本质就是字符串拼接，#{}的本质就是占位符赋值
${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

单个字面量类型的参数

若mapper接口中的方法参数为单个的字面量类型，此时可以使用${}和#{}以任意的名称（最好见名识意）获取参数的值，注意${}需要手动加单引号

<!--User getUserByUsername(String username);-->
<select id="getUserByUsername" resultType="User">
	select * from t_user where username = #{username}
</select>

<!--User getUserByUsername(String username);-->
<select id="getUserByUsername" resultType="User">  
	select * from t_user where username = '${username}'  
</select>

多个字面量类型的参数

若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中
1. 以arg0,arg1...为键，以参数为值；
2. 以param1,param2...为键，以参数为值；
因此只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号。
使用arg或者param都行，要注意的是，arg是从arg0开始的，param是从param1开始的

<!--User checkLogin(String username,String password);-->
<select id="checkLogin" resultType="User">  
	select * from t_user where username = #{arg0} and password = #{arg1}  
</select>

<!--User checkLogin(String username,String password);-->
<select id="checkLogin" resultType="User">
	select * from t_user where username = '${param1}' and password = '${param2}'
</select>

map集合类型的参数

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

<!--User checkLoginByMap(Map<String,Object> map);-->
<select id="checkLoginByMap" resultType="User">
	select * from t_user where username = #{username} and password = #{password}
</select>

@Test
public void checkLoginByMap() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
	Map<String,Object> map = new HashMap<>();
	map.put("usermane","admin");
	map.put("password","123456");
	User user = mapper.checkLoginByMap(map);
	System.out.println(user);
}

实体类类型的参数

若mapper接口中的方法参数为实体类对象时此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号

<!--int insertUser(User user);-->
<insert id="insertUser">
	insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})
</insert>

@Test
public void insertUser() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
	User user = new User(null,"Tom","123456",12,"男","123@321.com");
	mapper.insertUser(user);
}

使用@Param标识参数

可以通过@Param注解标识mapper接口中的方法参数，此时，会将这些参数放在map集合中
1. 以@Param注解的value属性值为键，以参数为值；
2. 以param1,param2...为键，以参数为值；
只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

<!--User CheckLoginByParam(@Param("username") String username, @Param("password") String password);-->
    <select id="CheckLoginByParam" resultType="User">
        select * from t_user where username = #{username} and password = #{password}
    </select>

@Test
public void checkLoginByParam() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
	mapper.CheckLoginByParam("admin","123456");
}

总结

建议分成两种情况进行处理
1. 实体类类型的参数
2. 使用@Param标识参数

MyBatis的各种查询功能

如果查询出的数据只有一条，可以通过
1. 实体类对象接收
2. List集合接收
3. Map集合接收，结果{password=123456, sex=男, id=1, age=23, username=admin}
如果查询出的数据有多条，一定不能用实体类对象接收，会抛异常TooManyResultsException，可以通过
1. 实体类类型的LIst集合接收
2. Map类型的LIst集合接收
3. 在mapper接口的方法上添加@MapKey注解

查询一个实体类对象

/**
 * 根据用户id查询用户信息
 * @param id
 * @return
 */
User getUserById(@Param("id") int id);

<!--User getUserById(@Param("id") int id);-->
<select id="getUserById" resultType="User">
	select * from t_user where id = #{id}
</select>

查询一个List集合

/**
 * 查询所有用户信息
 * @return
 */
List<User> getUserList();

<!--List<User> getUserList();-->
<select id="getUserList" resultType="User">
	select * from t_user
</select>

查询单个数据

/**  
 * 查询用户的总记录数  
 * @return  
 * 在MyBatis中，对于Java中常用的类型都设置了类型别名  
 * 例如：java.lang.Integer-->int|integer  
 * 例如：int-->_int|_integer  
 * 例如：Map-->map,List-->list  
 */  
int getCount();

<!--int getCount();-->
<select id="getCount" resultType="_integer">
	select count(id) from t_user
</select>

查询一条数据为map集合

/**  
 * 根据用户id查询用户信息为map集合  
 * @param id  
 * @return  
 */  
Map<String, Object> getUserToMap(@Param("id") int id);

<!--Map<String, Object> getUserToMap(@Param("id") int id);-->
<select id="getUserToMap" resultType="map">
	select * from t_user where id = #{id}
</select>
<!--结果：{password=123456, sex=男, id=1, age=23, username=admin}-->

查询多条数据为map集合

方法一

/**  
 * 查询所有用户信息为map集合  
 * @return  
 * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取  
 */  
List<Map<String, Object>> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();-->  
<select id="getAllUserToMap" resultType="map">  
	select * from t_user  
</select>
<!--
	结果：
	[{password=123456, sex=男, id=1, age=23, username=admin},
	{password=123456, sex=男, id=2, age=23, username=张三},
	{password=123456, sex=男, id=3, age=23, username=张三}]
-->

方法二

/**
 * 查询所有用户信息为map集合
 * @return
 * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，并且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合
 */
@MapKey("id")
Map<String, Object> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();-->
<select id="getAllUserToMap" resultType="map">
	select * from t_user
</select>
<!--
	结果：
	{
	1={password=123456, sex=男, id=1, age=23, username=admin},
	2={password=123456, sex=男, id=2, age=23, username=张三},
	3={password=123456, sex=男, id=3, age=23, username=张三}
	}
-->

特殊SQL的执行

模糊查询

/**
 * 根据用户名进行模糊查询
 * @param username 
 * @return java.util.List<com.atguigu.mybatis.pojo.User>
 * @date 2022/2/26 21:56
 */
List<User> getUserByLike(@Param("username") String username);

<!--List<User> getUserByLike(@Param("username") String username);-->
<select id="getUserByLike" resultType="User">
	<!--select * from t_user where username like '%${mohu}%'-->  
	<!--select * from t_user where username like concat('%',#{mohu},'%')-->  
	select * from t_user where username like "%"#{mohu}"%"
</select>

其中select * from t_user where username like "%"#{mohu}"%"是最常用的

批量删除

只能使用${}，如果使用#{}，则解析后的sql语句为delete from t_user where id in ('1,2,3')，这样是将1,2,3看做是一个整体，只有id为1,2,3的数据会被删除。正确的语句应该是delete from t_user where id in (1,2,3)，或者delete from t_user where id in ('1','2','3')

/**
 * 根据id批量删除
 * @param ids 
 * @return int
 * @date 2022/2/26 22:06
 */
int deleteMore(@Param("ids") String ids);

<delete id="deleteMore">
	delete from t_user where id in (${ids})
</delete>

//测试类
@Test
public void deleteMore() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
	int result = mapper.deleteMore("1,2,3,8");
	System.out.println(result);
}

动态设置表名

只能使用${}，因为表名不能加单引号

/**
 * 查询指定表中的数据
 * @param tableName 
 * @return java.util.List<com.atguigu.mybatis.pojo.User>
 * @date 2022/2/27 14:41
 */
List<User> getUserByTable(@Param("tableName") String tableName);

<!--List<User> getUserByTable(@Param("tableName") String tableName);-->
<select id="getUserByTable" resultType="User">
	select * from ${tableName}
</select>

添加功能获取自增的主键

使用场景
t_clazz(clazz_id,clazz_name)
- t_student(student_id,student_name,clazz_id)
1. 添加班级信息
2. 获取新添加的班级的id
3. 为班级分配学生，即将某学的班级id修改为新添加的班级的id
在mapper.xml中设置两个属性
useGeneratedKeys：设置使用自增的主键
- keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中

/**
 * 添加用户信息
 * @param user 
 * @date 2022/2/27 15:04
 */
void insertUser(User user);

<!--void insertUser(User user);-->
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
	insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})
</insert>

//测试类
@Test
public void insertUser() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
	User user = new User(null, "ton", "123", 23, "男", "123@321.com");
	mapper.insertUser(user);
	System.out.println(user);
	//输出：user{id=10, username='ton', password='123', age=23, sex='男', email='123@321.com'}，自增主键存放到了user的id属性中
}

自定义映射resultMap

resultMap处理字段和属性的映射关系

resultMap：设置自定义映射
属性：
- id：表示自定义映射的唯一标识，不能重复
- type：查询的数据要映射的实体类的类型
- 子标签：
- id：设置主键的映射关系
  - result：设置普通字段的映射关系
  - 子标签属性：
  - property：设置映射关系中实体类中的属性名
    - column：设置映射关系中表中的字段名
若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射，即使字段名和属性名一致的属性也要映射，也就是全部属性都要列出来

<resultMap id="empResultMap" type="Emp">
	<id property="eid" column="eid"></id>
	<result property="empName" column="emp_name"></result>
	<result property="age" column="age"></result>
	<result property="sex" column="sex"></result>
	<result property="email" column="email"></result>
</resultMap>
<!--List<Emp> getAllEmp();-->
<select id="getAllEmp" resultMap="empResultMap">
	select * from t_emp
</select>

若字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用_），实体类中的属性名符合Java的规则（使用驼峰）。此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系
1. 可以通过为字段起别名的方式，保证和实体类中的属性名保持一致
```

<select id="getAllEmp" resultType="Emp">
	select eid,emp_name empName,age,sex,email from t_emp
</select>
```
2. 可以在MyBatis的核心配置文件中的setting标签中，设置一个全局配置信息mapUnderscoreToCamelCase，可以在查询表中数据时，自动将_类型的字段名转换为驼峰，例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为userName。核心配置文件详解
<settings> <setting name="mapUnderscoreToCamelCase" value="true"/> </settings> ```

多对一映射处理

查询员工信息以及员工所对应的部门信息

public class Emp {  
	private Integer eid;  
	private String empName;  
	private Integer age;  
	private String sex;  
	private String email;  
	private Dept dept;
	//...构造器、get、set方法等
}

级联方式处理映射关系

<resultMap id="empAndDeptResultMapOne" type="Emp">
	<id property="eid" column="eid"></id>
	<result property="empName" column="emp_name"></result >
	<result property="age" column="age"></result>
	<result property="sex" column="sex"></result>
	<result property="email" column="email"></result>
	<result property="dept.did" column="did"></result>
	<result property="dept.deptName" column="dept_name"></result>
</resultMap>
<!--Emp getEmpAndDept(@Param("eid")Integer eid);-->
<select id="getEmpAndDept" resultMap="empAndDeptResultMapOne">
	select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid}
</select>

使用association处理映射关系

association：处理多对一的映射关系
property：需要处理多对的映射关系的属性名
javaType：该属性的类型

<resultMap id="empAndDeptResultMapTwo" type="Emp">
	<id property="eid" column="eid"></id>
	<result property="empName" column="emp_name"></result>
	<result property="age" column="age"></result>
	<result property="sex" column="sex"></result>
	<result property="email" column="email"></result>
	<association property="dept" javaType="Dept">
		<id property="did" column="did"></id>
		<result property="deptName" column="dept_name"></result>
	</association>
</resultMap>
<!--Emp getEmpAndDept(@Param("eid")Integer eid);-->
<select id="getEmpAndDept" resultMap="empAndDeptResultMapTwo">
	select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid}
</select>

分步查询

1. 查询员工信息

select：设置分布查询的sql的唯一标识（namespace.SQLId或mapper接口的全类名.方法名）
column：设置分步查询的条件

//EmpMapper里的方法
/**
 * 通过分步查询，员工及所对应的部门信息
 * 分步查询第一步：查询员工信息
 * @param  
 * @return com.atguigu.mybatis.pojo.Emp
 * @date 2022/2/27 20:17
 */
Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);

<resultMap id="empAndDeptByStepResultMap" type="Emp">
	<id property="eid" column="eid"></id>
	<result property="empName" column="emp_name"></result>
	<result property="age" column="age"></result>
	<result property="sex" column="sex"></result>
	<result property="email" column="email"></result>
	<association property="dept"
				 select="com.atguigu.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
				 column="did"></association>
</resultMap>
<!--Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);-->
<select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
	select * from t_emp where eid = #{eid}
</select>

2. 查询部门信息

//DeptMapper里的方法
/**
 * 通过分步查询，员工及所对应的部门信息
 * 分步查询第二步：通过did查询员工对应的部门信息
 * @param
 * @return com.atguigu.mybatis.pojo.Emp
 * @date 2022/2/27 20:23
 */
Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);

<!--此处的resultMap仅是处理字段和属性的映射关系-->
<resultMap id="EmpAndDeptByStepTwoResultMap" type="Dept">
	<id property="did" column="did"></id>
	<result property="deptName" column="dept_name"></result>
</resultMap>
<!--Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);-->
<select id="getEmpAndDeptByStepTwo" resultMap="EmpAndDeptByStepTwoResultMap">
	select * from t_dept where did = #{did}
</select>

一对多映射处理

public class Dept {
    private Integer did;
    private String deptName;
    private List<Emp> emps;
	//...构造器、get、set方法等
}

collection

collection：用来处理一对多的映射关系
ofType：表示该属性对饮的集合中存储的数据的类型

<resultMap id="DeptAndEmpResultMap" type="Dept">
	<id property="did" column="did"></id>
	<result property="deptName" column="dept_name"></result>
	<collection property="emps" ofType="Emp">
		<id property="eid" column="eid"></id>
		<result property="empName" column="emp_name"></result>
		<result property="age" column="age"></result>
		<result property="sex" column="sex"></result>
		<result property="email" column="email"></result>
	</collection>
</resultMap>
<!--Dept getDeptAndEmp(@Param("did") Integer did);-->
<select id="getDeptAndEmp" resultMap="DeptAndEmpResultMap">
	select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did}
</select>

分步查询

1. 查询部门信息

/**
 * 通过分步查询，查询部门及对应的所有员工信息
 * 分步查询第一步：查询部门信息
 * @param did 
 * @return com.atguigu.mybatis.pojo.Dept
 * @date 2022/2/27 22:04
 */
Dept getDeptAndEmpByStepOne(@Param("did") Integer did);

<resultMap id="DeptAndEmpByStepOneResultMap" type="Dept">
	<id property="did" column="did"></id>
	<result property="deptName" column="dept_name"></result>
	<collection property="emps"
				select="com.atguigu.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
				column="did"></collection>
</resultMap>
<!--Dept getDeptAndEmpByStepOne(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepOne" resultMap="DeptAndEmpByStepOneResultMap">
	select * from t_dept where did = #{did}
</select>

2. 根据部门id查询部门中的所有员工

/**
 * 通过分步查询，查询部门及对应的所有员工信息
 * 分步查询第二步：根据部门id查询部门中的所有员工
 * @param did
 * @return java.util.List<com.atguigu.mybatis.pojo.Emp>
 * @date 2022/2/27 22:10
 */
List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);

<!--List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepTwo" resultType="Emp">
	select * from t_emp where did = #{did}
</select>

延迟加载

分步查询的优点：可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息：
lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
- aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载
此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType="lazy(延迟加载)|eager(立即加载)"

<settings>
	<!--开启延迟加载-->
	<setting name="lazyLoadingEnabled" value="true"/>
</settings>

@Test
public void getEmpAndDeptByStepOne() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	Emp emp = mapper.getEmpAndDeptByStepOne(1);
	System.out.println(emp.getEmpName());
}

关闭延迟加载，两条SQL语句都运行了
开启延迟加载，只运行获取emp的SQL语句

@Test
public void getEmpAndDeptByStepOne() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	Emp emp = mapper.getEmpAndDeptByStepOne(1);
	System.out.println(emp.getEmpName());
	System.out.println("----------------");
	System.out.println(emp.getDept());
}

开启后，需要用到查询dept的时候才会调用相应的SQL语句

fetchType：当开启了全局的延迟加载之后，可以通过该属性手动控制延迟加载的效果，fetchType="lazy(延迟加载)|eager(立即加载)"

<resultMap id="empAndDeptByStepResultMap" type="Emp">
	<id property="eid" column="eid"></id>
	<result property="empName" column="emp_name"></result>
	<result property="age" column="age"></result>
	<result property="sex" column="sex"></result>
	<result property="email" column="email"></result>
	<association property="dept"
				 select="com.atguigu.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
				 column="did"
				 fetchType="lazy"></association>
</resultMap>

动态SQL

Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题

if

if标签可通过test属性（即传递过来的数据）的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行
在where后面添加一个恒成立条件1=1
这个恒成立条件并不会影响查询的结果
- 这个1=1可以用来拼接and语句，例如：当empName为null时
- 如果不加上恒成立条件，则SQL语句为select * from t_emp where and age = ? and sex = ? and email = ?，此时where会与and连用，SQL语句会报错
  - 如果加上一个恒成立条件，则SQL语句为select * from t_emp where 1= 1 and age = ? and sex = ? and email = ?，此时不报错

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
	select * from t_emp where 1=1
	<if test="empName != null and empName !=''">
		and emp_name = #{empName}
	</if>
	<if test="age != null and age !=''">
		and age = #{age}
	</if>
	<if test="sex != null and sex !=''">
		and sex = #{sex}
	</if>
	<if test="email != null and email !=''">
		and email = #{email}
	</if>
</select>

where

where和if一般结合使用：
若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
- 若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and/or去掉

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
	select * from t_emp
	<where>
		<if test="empName != null and empName !=''">
			emp_name = #{empName}
		</if>
		<if test="age != null and age !=''">
			and age = #{age}
		</if>
		<if test="sex != null and sex !=''">
			and sex = #{sex}
		</if>
		<if test="email != null and email !=''">
			and email = #{email}
		</if>
	</where>
</select>

注意：where标签不能去掉条件后多余的and/or

<!--这种用法是错误的，只能去掉条件前面的and/or，条件后面的不行-->
<if test="empName != null and empName !=''">
emp_name = #{empName} and
</if>
<if test="age != null and age !=''">
	age = #{age}
</if>

trim

trim用于去掉或添加标签中的内容
常用属性
- prefix：在trim标签中的内容的前面添加某些内容
- suffix：在trim标签中的内容的后面添加某些内容
- prefixOverrides：在trim标签中的内容的前面去掉某些内容
- suffixOverrides：在trim标签中的内容的后面去掉某些内容
若trim中的标签都不满足条件，则trim标签没有任何效果，也就是只剩下select * from t_emp

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
	select * from t_emp
	<trim prefix="where" suffixOverrides="and|or">
		<if test="empName != null and empName !=''">
			emp_name = #{empName} and
		</if>
		<if test="age != null and age !=''">
			age = #{age} and
		</if>
		<if test="sex != null and sex !=''">
			sex = #{sex} or
		</if>
		<if test="email != null and email !=''">
			email = #{email}
		</if>
	</trim>
</select>

//测试类
@Test
public void getEmpByCondition() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
	List<Emp> emps= mapper.getEmpByCondition(new Emp(null, "张三", null, null, null, null));
	System.out.println(emps);
}

choose、when、otherwise

choose、when、 otherwise相当于if...else if..else
when至少要有一个，otherwise至多只有一个

<select id="getEmpByChoose" resultType="Emp">
	select * from t_emp
	<where>
		<choose>
			<when test="empName != null and empName != ''">
				emp_name = #{empName}
			</when>
			<when test="age != null and age != ''">
				age = #{age}
			</when>
			<when test="sex != null and sex != ''">
				sex = #{sex}
			</when>
			<when test="email != null and email != ''">
				email = #{email}
			</when>
			<otherwise>
				did = 1
			</otherwise>
		</choose>
	</where>
</select>

@Test
public void getEmpByChoose() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
	List<Emp> emps = mapper.getEmpByChoose(new Emp(null, "张三", 23, "男", "123@qq.com", null));
	System.out.println(emps);
}

相当于if a else if b else if c else d，只会执行其中一个

foreach

属性：
collection：设置要循环的数组或集合
- item：表示集合或数组中的每一个数据
- separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如,
- open：设置foreach标签中的内容的开始符
- close：设置foreach标签中的内容的结束符

批量删除

<!--int deleteMoreByArray(Integer[] eids);-->
<delete id="deleteMoreByArray">
	delete from t_emp where eid in
	<foreach collection="eids" item="eid" separator="," open="(" close=")">
		#{eid}
	</foreach>
</delete>

@Test
public void deleteMoreByArray() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
	int result = mapper.deleteMoreByArray(new Integer[]{6, 7, 8, 9});
	System.out.println(result);
}

批量添加

<!--int insertMoreByList(@Param("emps") List<Emp> emps);-->
<insert id="insertMoreByList">
	insert into t_emp values
	<foreach collection="emps" item="emp" separator=",">
		(null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
	</foreach>
</insert>

@Test
public void insertMoreByList() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
	Emp emp1 = new Emp(null,"a",1,"男","123@321.com",null);
	Emp emp2 = new Emp(null,"b",1,"男","123@321.com",null);
	Emp emp3 = new Emp(null,"c",1,"男","123@321.com",null);
	List<Emp> emps = Arrays.asList(emp1, emp2, emp3);
	int result = mapper.insertMoreByList(emps);
	System.out.println(result);
}

SQL片段

sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入
声明sql片段：<sql>标签

<sql id="empColumns">eid,emp_name,age,sex,email</sql>

引用sql片段：<include>标签

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
	select <include refid="empColumns"></include> from t_emp
</select>

MyBatis的缓存

MyBatis的一级缓存

一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问
使一级缓存失效的四种情况：
1. 不同的SqlSession对应不同的一级缓存
2. 同一个SqlSession但是查询条件不同
3. 同一个SqlSession两次查询期间执行了任何一次增删改操作
4. 同一个SqlSession两次查询期间手动清空了缓存

MyBatis的二级缓存

二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取
二级缓存开启的条件
1. 在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true，不需要设置
2. 在映射文件中设置标签<cache />
3. 二级缓存必须在SqlSession关闭或提交之后有效
4. 查询的数据所转换的实体类类型必须实现序列化的接口
使二级缓存失效的情况：两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

二级缓存的相关配置

在mapper配置文件中添加的cache标签可以设置一些属性
eviction属性：缓存回收策略
LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。
- FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。
- SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
- WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
- 默认的是 LRU
flushInterval属性：刷新间隔，单位毫秒
默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句（增删改）时刷新
size属性：引用数目，正整数
代表缓存最多可以存储多少个对象，太大容易导致内存溢出
readOnly属性：只读，true/false
true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
- false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false

MyBatis缓存查询的顺序

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用
如果二级缓存没有命中，再查询一级缓存
如果一级缓存也没有命中，则查询数据库
SqlSession关闭之后，一级缓存中的数据会写入二级缓存

整合第三方缓存EHCache（了解）

添加依赖

<!-- Mybatis EHCache整合包 -->
<dependency>
	<groupId>org.mybatis.caches</groupId>
	<artifactId>mybatis-ehcache</artifactId>
	<version>1.2.1</version>
</dependency>
<!-- slf4j日志门面的一个具体实现 -->
<dependency>
	<groupId>ch.qos.logback</groupId>
	<artifactId>logback-classic</artifactId>
	<version>1.2.3</version>
</dependency>

各个jar包的功能

jar包名称	作用
mybatis-ehcache	Mybatis和EHCache的整合包
ehcache	EHCache核心包
slf4j-api	SLF4J日志门面包
logback-classic	支持SLF4J门面接口的一个具体实现

创建EHCache的配置文件ehcache.xml

名字必须叫ehcache.xml

<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <!-- 磁盘保存路径 -->
    <diskStore path="D:\atguigu\ehcache"/>
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

设置二级缓存的类型

在xxxMapper.xml文件中设置二级缓存类型

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

加入logback日志

存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志。创建logback的配置文件logback.xml，名字固定，不可改变

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!-- 指定日志输出的位置 -->
    <appender name="STDOUT"
              class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志输出的格式 -->
            <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
        </encoder>
    </appender>
    <!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="DEBUG">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT" />
    </root>
    <!-- 根据特殊需求指定局部日志级别 -->
    <logger name="com.atguigu.crowd.mapper" level="DEBUG"/>
</configuration>

EHCache配置文件说明

属性名	是否必须	作用
maxElementsInMemory	是	在内存中缓存的element的最大数目
maxElementsOnDisk	是	在磁盘上缓存的element的最大数目，若是0表示无穷大
eternal	是	设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds、timeToLiveSeconds判断
overflowToDisk	是	设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
timeToIdleSeconds	否	当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
timeToLiveSeconds	否	缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
diskSpoolBufferSizeMB	否	DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区
diskPersistent	否	在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false
diskExpiryThreadIntervalSeconds	否	磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
memoryStoreEvictionPolicy	否	当内存缓存达到最大，有新的element加入的时候，移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出

MyBatis的逆向工程

本质：代码生成器

正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。Hibernate是支持正向工程的
逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：
Java实体类
- Mapper接口
- Mapper映射文件

创建逆向工程的步骤

添加依赖和插件

<dependencies>
	<!-- MyBatis核心依赖包 -->
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.5.9</version>
	</dependency>
	<!-- junit测试 -->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.13.2</version>
		<scope>test</scope>
	</dependency>
	<!-- MySQL驱动 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>8.0.27</version>
	</dependency>
	<!-- log4j日志 -->
	<dependency>
		<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>1.2.17</version>
	</dependency>
</dependencies>
<!-- 控制Maven在构建过程中相关配置 -->
<build>
	<!-- 构建过程中用到的插件 -->
	<plugins>
		<!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
		<plugin>
			<groupId>org.mybatis.generator</groupId>
			<artifactId>mybatis-generator-maven-plugin</artifactId>
			<version>1.3.0</version>
			<!-- 插件的依赖 -->
			<dependencies>
				<!-- 逆向工程的核心依赖 -->
				<dependency>
					<groupId>org.mybatis.generator</groupId>
					<artifactId>mybatis-generator-core</artifactId>
					<version>1.3.2</version>
				</dependency>
				<!-- 数据库连接池 -->
				<dependency>
					<groupId>com.mchange</groupId>
					<artifactId>c3p0</artifactId>
					<version>0.9.2</version>
				</dependency>
				<!-- MySQL驱动 -->
				<dependency>
					<groupId>mysql</groupId>
					<artifactId>mysql-connector-java</artifactId>
					<version>8.0.27</version>
				</dependency>
			</dependencies>
		</plugin>
	</plugins>
</build>

创建MyBatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbc.properties"/>
    <typeAliases>
        <package name=""/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name=""/>
    </mappers>
</configuration>

创建逆向工程的配置文件

文件名必须是：generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
    targetRuntime: 执行生成的逆向工程的版本
    MyBatis3Simple: 生成基本的CRUD（清新简洁版）
    MyBatis3: 生成带条件的CRUD（奢华尊享版）
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="123456">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.atguigu.mybatis.pojo" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.atguigu.mybatis.mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.atguigu.mybatis.mapper" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

执行MBG插件的generate目标

如果出现报错：Exception getting JDBC Driver，可能是pom.xml中，数据库驱动配置错误
dependency中的驱动
- mybatis-generator-maven-plugin插件中的驱动
- 两者的驱动版本应该相同
执行结果

QBC

查询

selectByExample：按条件查询，需要传入一个example对象或者null；如果传入一个null，则表示没有条件，也就是查询所有数据
example.createCriteria().xxx：创建条件对象，通过andXXX方法为SQL添加查询添加，每个条件之间是and关系
example.or().xxx：将之前添加的条件通过or拼接其他条件

@Test public void testMBG() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	EmpExample example = new EmpExample();
	//名字为张三，且年龄大于等于20
	example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(20);
	//或者did不为空
	example.or().andDidIsNotNull();
	List<Emp> emps = mapper.selectByExample(example);
	emps.forEach(System.out::println);
}

增改

updateByPrimaryKey：通过主键进行数据修改，如果某一个值为null，也会将对应的字段改为null
mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"456@qq.com",3));
updateByPrimaryKeySelective()：通过主键进行选择性数据修改，如果某个值为null，则不修改这个字段
mapper.updateByPrimaryKeySelective(new Emp(2,"admin2",22,null,"456@qq.com",3));

分页插件

分页插件使用步骤

添加依赖

<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>5.2.0</version>
</dependency>

配置分页插件

在MyBatis的核心配置文件（mybatis-config.xml）中配置插件

<plugins>
	<!--设置分页插件-->
	<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

分页插件的使用

开启分页功能

在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能
pageNum：当前页的页码
pageSize：每页显示的条数

@Test
public void testPageHelper() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	//访问第一页，每页四条数据
	PageHelper.startPage(1,4);
	List<Emp> emps = mapper.selectByExample(null);
	emps.forEach(System.out::println);
}

分页相关数据

方法一：直接输出

@Test
public void testPageHelper() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	//访问第一页，每页四条数据
	Page<Object> page = PageHelper.startPage(1, 4);
	List<Emp> emps = mapper.selectByExample(null);
	//在查询到List集合后，打印分页数据
	System.out.println(page);
}

分页相关数据：

Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=8, pages=2, reasonable=false, pageSizeZero=false}[Emp{eid=1, empName='admin', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=2, empName='admin2', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=3, empName='王五', age=12, sex='女', email='123@qq.com', did=3}, Emp{eid=4, empName='赵六', age=32, sex='男', email='123@qq.com', did=1}]

方法二使用PageInfo

在查询获取list集合之后，使用PageInfo<T> pageInfo = new PageInfo<>(List<T> list, intnavigatePages)获取分页相关数据
list：分页之后的数据
- navigatePages：导航分页的页码数

@Test
public void testPageHelper() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	PageHelper.startPage(1, 4);
	List<Emp> emps = mapper.selectByExample(null);
	PageInfo<Emp> page = new PageInfo<>(emps,5);
	System.out.println(page);
}

分页相关数据：

PageInfo{
pageNum=1, pageSize=4, size=4, startRow=1, endRow=4, total=8, pages=2, 
list=Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=8, pages=2, reasonable=false, pageSizeZero=false}[Emp{eid=1, empName='admin', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=2, empName='admin2', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=3, empName='王五', age=12, sex='女', email='123@qq.com', did=3}, Emp{eid=4, empName='赵六', age=32, sex='男', email='123@qq.com', did=1}], 
prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=2, navigatepageNums=[1, 2]}

其中list中的数据等同于方法一中直接输出的page数据

常用数据：

pageNum：当前页的页码
pageSize：每页显示的条数
size：当前页显示的真实条数
total：总记录数
pages：总页数
prePage：上一页的页码
nextPage：下一页的页码
isFirstPage/isLastPage：是否为第一页/最后一页
hasPreviousPage/hasNextPage：是否存在上一页/下一页
navigatePages：导航分页的页码数
navigatepageNums：导航分页的页码，[1,2,3,4,5]

云智研发笔试

Wed, 04 Sep 2024 00:00:00 GMT

由于笔试是全屏，所以只提供思路

第一题

题意描述

有 $t$ 个样例

给你一个长度为 $n$ 的整数序列，问有多少对下标 $(i,j), i \lt j$ 满足 $a[i] + a[j] = a[i] \oplus a[j]$

数据范围

$1 \le t \le 100$
$1 \le n \le 10^3$
$1 \le \sum n \le 10^3$
$a_i \ge 1$

题解

枚举

时间复杂度 $O(n^2)$

枚举 $(i,j)$ 二元组，满足条件便累加

代码如下

暂无

第二题

题意描述

给你三个数，分别是 $n, m, k$ ，分别表示有 $n$ 个人，这 $n$ 个人的编号为 $1-n$，有 $m$ 个苹果，小明是编号是 $k$ 。

现在我们需要分配苹果，每个人至少分配一个，并且要保证相邻的两个人分配的苹果相差不能大于 $1$，求所有分配方案中，小明能分配到的最大苹果数量。

数据范围

$1 \le n \le 10^5$
$1 \le n \le m \le 10^9$
$1 \le k \le n$

题解

二分

时间复杂度 $O(logm)$

假设我们知道小明拥有的苹果数，想要尽可能小明拥有的苹果数多，那么其他的的苹果数就尽可能少，同时需要满足相邻编号的人苹果数最多相差 $1$。

根据贪心性质，小明最多，编号左右两边按 1 递减，就好像一个单峰（山峰）一样。比如，小明 k = 3, n = 4, （1 2 3 2 1）的数据呈现是一个单峰

另外要注意，如果递减的过程中发现会 $\le 0$，此时需要分配苹果数为 $1$ （满足最少分配一个苹果的条件）

同时，也可以发现一个性质，如果小明分配的苹果越多，通过这种方式分配，可能苹果数不够，而小明分配的苹果越少，那么最后需要的苹果数可能是小于等于总苹果数的，如果是小于，我们把剩余的苹果从端点慢慢开始分配即可。比如：（1 2 3 2 1）剩余 4 -> (2, 2, 3, 2, 1) 剩余 3 -> …… -> (2, 3, 3, 3, 2) 剩余 0

综上，得到一个结果，可以通过二分小明的苹果数量，范围为 $[1,m]$，然后计算一下通过贪心方式分配需要多少苹果，如果需要的苹果小于等于苹果总数，则舍弃左半区间，否则舍弃右半区间

代码如下

暂无

第三题

题目大意

由于长度为 $n$ 的字符串，只包含小写字母，求有多少个连续子串，其包含 $r$ 和 $e$，但是不包含 $d$

数据范围

$n \le 30000$

题解

尺取

时间复杂度 $O(n)$

从前往后扫描，设 $p$ 记录第 $0$ 个位置（下标从 $1$ 开始），或者当前遍历的位置，左边第一个 $d$ 的下标。设 $r,e$ 分别记录从 $p + 1$ 开始 $r,e$ 字符分别出现的最后位置。

如果当前 $r,e$ 字符全部遍历到了，并且没有遍历到 $d$，那么以当前下标为最后一个字符串的所有满足题意的连续字串数量为 $min(r,e) - p$

如果当前遍历到了 $d$，那么更新一下 $p, r, e$ 的值，因为后面的满足题意的字符一定不会包含当前字符。

代码如下

暂无

:::tip 注意开 long :::

写在最后，题目不难，但是第二题第三题注意开 long

华为笔试

Wed, 28 Aug 2024 00:00:00 GMT

题比较简单。第一题：7min，第二题：13min，第三题：30min

第一题

题意描述

一行输入，输入是有 $n$ 个数字，每个数字按照空格隔开。注意：$n$ 在输入并未给出。

然后他有个这样的题意：每个数字都是一只老鼠的编号，它们发现有一个地洞，那么这些老鼠就按照输入的数字编号钻到地洞去，然后如果碰到有重复的编号，说明这只老鼠就在以其它上面的老鼠都需要出来，然后当前编号的老鼠再跳进去，到最后所有的老鼠都要出来。问：老鼠出地洞序列

比如：输入：1 2 3 1 3 3 1，则输出为 3 2 1 3 3 1 1。解释：首先 1 2 3 老鼠入洞，然后碰到 1 ，说明按照 3 2 1 顺序出洞，然后老鼠 1 3 再入洞；碰到 3 ，按照 3 顺序出洞，然后老鼠 3 再入洞；碰到 1，按照 3 1 顺序出洞，老鼠 1 入洞。最后都要出洞，老鼠 1 再出洞。

数据范围

$1 \le n \le 10^5$
$1 \le A_i \le 10^5$

题解

栈

时间复杂度 $O(n)$

其实按照题意已经知道是栈了，洞就是一个栈，满足先进后出的规则

代码如下

#include <iostream>
#include <cstring>

using namespace std;

const int N = 10010;

int n;
int q[N], stk[N], tt = 0;
bool in_stk[N];

int main() {

    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    
    int x; 
    int flag = 0;
    while (~scanf("%d", &x)) {
        if (in_stk[x]) {
            while (in_stk[x]) {
                int y = stk[-- tt];
                in_stk[y] = false;
                if (flag ++ ) putchar(' ');
                printf("%d", y);
            }
        } 
        stk[tt ++ ] = x;
        in_stk[x] = true;
    }

    while (tt > 0) {
        if (flag ++ ) putchar(' ');
        printf("%d", stk[-- tt]);
    }
}

第二题

题意描述

给你一个长度为 $n$ 的数组，然后一个大小为 $interval$ 的时间间隔。

求：在数组里面任取一个数 $x$，然后有一个集合 ${x+ interval*k, k \ge 0}$ 的集合，那么说明数组里面有 $y$ 个数在这个集合里面，求最大的 $y$ 对应的 $x$，如果两个 $x$ 值的 $y$ 相等，则求最小的 $x$

数据范围

$1 \le n \le 10^5$
$0 \le x \le 10^9$
$0 \le interval \le 10^5$

题解

思维

时间复杂度 $O(nlogn)$

第一步预处理 $h$ 数组，$h[i]$ 表示数组里面的数对 $interval$ 取模后有多少个值为 $i$

第二步，有序离散化。因为对于重复值，只需要计算一次。同时使用哈希表记录下每个数出现了多少次

第三步，从小到大枚举有序离散化后的数组，那么对于当前值 $x$， $y$ 一定是等于 $h[x % interval]$ 的数量。同时在最后 $h[x % interval]$ 要更新，减去原数组里面 $x$ 的数量。因为 $h[i]$ 只是保证了取模后的值为 $i$ 的数量，但是对于一个 $x$ 而言，我们需要的不仅仅是取模要相等，而且要保证 $\ge x$

:::warning 因为这题 interval 可能为 0，因此需要特判 :::

代码如下

#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>
#include <vector>

using namespace std;

const int N = 100010;

int q[N];
int n;
int delta;
int h[N];

unordered_map<int, int> um;
vector<int> alls;

int main() {

    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) {
        scanf("%d", &q[i]);
        alls.push_back(q[i]);
        um[q[i]] ++ ;
    }
    scanf("%d", &delta);

    sort(alls.begin(), alls.end());
    alls.erase(unique(alls.begin(), alls.end()), alls.end());

    int m = alls.size();

    if (delta == 0) {
        int res = 0, cnt = 0;
        for (auto &u: alls)
            if (um[u] > cnt) {
                res = u, cnt = um[u];
            }
        printf("%d", res);
    } else {
        for (int i = 0; i < n; i ++ )
            h[q[i] % delta] ++ ;
        
        int res = -1, cnt = 0;
        for (int i = 0; i < m; i ++ ) {
            int t = alls[i] % delta;
            if (h[t] > cnt) {
                res = alls[i], cnt = h[t];
            }
            h[t] -= um[alls[i]];
        }
        printf("%d", res);
    }
    return 0;
    
}

第三题

题目大意

给你一个长度为 $n$ 的时间区间 $[left_i, right_i]$，表示会议从 $left_i$ 开始，$right_i$ 天结束。如果小明在其中一天参加会议，那么就算小明参加了这场会议，但是小明每天最多只能参加 $k$ 场会议。问：小明最多能参加多少场会议？

数据范围

$1\le n \le 10^4$
$1 \le k \le 10$
$0 \le left_i \le right_i \le 10^8$

题解

贪心

时间复杂度 $O(n^2logn)$

贪心策略：按照 $left_i$ 从小达到，若 $left_i$ 则按照区间长度从小到大选择。如果发现 $left_i$ 这天已经被占满了，则更新区间为 $[left_i+1,right_i]$。

:::note 证明：假设贪心解为集合 $S_1$，最优解为 $S_2$

则有 $|S_1| \le |S_2|$

另外，对于集合 $S_1$ 和 $S_2$ 中的每个区间，都有一个生效的天数，因此，分别对 $S_1$ 和 $S_2$ 按照生效天数排序，如果生效天数相等，则按照右端点从小到大排序。

经过排序后，贪心解存在有第一个和最优解不同的区间，如果 $vaild_i \lt vaild_j$ ，（其中 $valid_i,valid_j$ 分别为贪心解和最优解的有效值，也即是区间中第几天去参加的会议。）那么现在可以将当前区间加入到 $S_2$ 中。

如果 $valid_i = valid_j$，说明可以将贪心解的该区间把最优解的该区间给替换掉。

如果 $valid_i \gt valid_j$，这种情况与贪心策略相矛盾

综上，最优解能通过添加区间或者替换区间的方式变成最优解，说明 $|S_2| \le |S_1|$

因此，$|S_1|=|S_2|$ :::

贪心证明如若有误，欢迎批评指正

这个贪心策略用优先队列维护即可。

代码如下

#include <iostream>
#include <cstring>
#include <queue>
#include <vector>
#include <unordered_map>

using namespace std;

const int N = 10010;


struct Node {
    int l, r, len;
    Node() {};
    Node(int a, int b, int c) {
        l = a, r = b, len = c;
    }
    bool operator < (const Node& a) const {
        if (a.l == l) return len > a.len;
        return l > a.l;
    }
};

priority_queue<Node> Q;
unordered_map<int, int> cnt;

int main() {

    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    int n, k; scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i ++ ) {
        int l, r; scanf("%d%d", &l, &r);
        Q.push({l, r, r - l + 1});
    }

    int res = 0;
    while (Q.size()) {
        auto q = Q.top(); Q.pop();
     //   cout << q.l << ' ' << q.r << ' ' << q.len << endl;
        if (cnt[q.l] >= k) {
            if (q.l < q.r) Q.push({q.l + 1, q.r, q.len - 1});
            continue;
        }
        cnt[q.l] ++ ;
        res ++ ;
    }
    printf("%d", res);
    
}

:::TIP 如果 $n=10000$,$k=1$,区间都是$[1,1000000000]$ 那么，很明显这个时间复杂度就是 $O(n^2logn)$ :::

写在最后，第三题有$O(n^2)$ 或者以下做法欢迎讨论

深信服笔试

Sat, 24 Aug 2024 00:00:00 GMT

:::important 第二题难度加倍，操作数有 6 种，黑科技过了。。第三题编辑距离，真离谱，都怀疑数据有问题了，我考完去力扣过了，但是笔试硬是没过！！！🤬

由于笔试不支持在 IDE 上编辑，因此暂不给出代码 :::

第一题

题意描述

给你一个字符串，如果有连续的超过三个重复的字符，删掉至小于 3 个，且每次至少删除 3 个重复字符，如果删完之后依然有连续的超过三个重复的字符，则继续利用删除规则删掉至小于 3 个

数据范围

无

解法

栈

时间复杂度 $O(n)$

设置两个栈，一个是字符栈，一个是对应字符数量栈

一次遍历字符串，如果 $s[i] != s[i - 1]$

如果 $3$ 整除栈顶字符数量，那么此时取出栈顶元素即可
- 如果此时的栈顶字符等于 $s[i]$，就将栈顶元素的数量加一即可
- 否则将 $s[i]$ 加入栈中即可
如果 3 不整数栈顶字符数量，直接将 $s[i]$ 加入栈中即可

最后注意判断栈顶字符数量是否大于等于 3 即可

代码如下

暂无

:::warning 下题暂未给出思路以及代码，等复习一手正则表达式 :::

第二题

题意描述

正则表达式字符串匹配。给你一个字符串 $s$ 和一个字符匹配串 $p$，问 $p$ 是否匹配 $s$ ？

其中 $p$ 可能出现的字符为: ^,?,+,*, . ,$

:::note 本场最难的一题 :::

数据范围

字符串长度小于等于 $100$

解法

动态规划

时间复杂度 $O(nm)$

在看了相关语法后，在此题中，字符 ^ 只能出现在第一个位置，且 ^ 的后面不能是 +, * , ?。那么剩下的还有 ^, ., $ 以及字母，无论 ^ 后面是什么，都以其后面的为主，因此最开头出现 ^ 直接删掉即可，如果中间或者末尾出现 ^ ，直接返回 false 即可。

同理，$ 也是一样，其只能出现在末尾位置，如果 $ 出现在中间位置，则直接返回 false；$ 前面同样也不能是 +, *, ?，剩下的^, ., $ 以及字母，都是以前一个字符为主，因此同样可以删掉最后一个 $ 即可

综上，经过处理后，字符匹配串里面只会有 ? + * . ，这其实就跟力扣的正则表达式差不多了，就是需要多判断两个字符和多一点转移。

代码如下

暂无

第三题

题目大意

有 $T$ 组数组，每个数据给你两个字符串 $s, p$

这两个字符串都是 DNA 链，也就是说只有 AGCT 四种字符。

$DNA$ 链有可能发生替换、删除和增加

换句话说，这题就是求编辑距离

:::note 但是就是不对，我都怀疑他的三种操作根本不是编辑距离的三种操作了，或者题目数据有问题 :::

数据范围

字符串长度 $\le 100$

题解

动态规则

时间复杂度 $O(nm)$

设 $f(i,j)$ 为 $s[1-i]$ 和 $p[1-j]$ 的编辑距离，因此 $f(i,j)$ 的计算公式为

$$ f(i,j)= \begin{cases} min{f(i,j-1)+1, f(i-1,j)+1, f(i-1,j-1)+1}, & \text{if } s[i]\neq p[j] \ min{f(i,j-1)+1, f(i-1,j)+1, f(i-1,j-1)}, & \text{if } s[i]=p[j]
\end{cases} $$

代码如下

暂无

第四题

题目大意

有 $T$ 个样例，对于每个样例：

有一个长度为 $n$ 的序列,接下来给你 $n$ 行数据，让你求这个序列

每行有两个整数，第一个整数为 $a$，$a$ 是反转序列中的一个数；第二个整数为 $b$，表示在反转序列中 $a$ 的下一个数在第 $b$ 行。如果在反转序列中，$a$ 是最后一个数，则 $b=0$

数据范围

$T \le 10$
$n \le 10^6$

题解

单链表

$O(nT)$

由于在反转序列中，出了第一个数外，其他数都是上一个数指向其位置。

例如：

$n = 3$
序列为 $[2,4,1] $
反转序列为 $[1,4,2]$
$n$行输入数据为:
$4 \ \ 3$
$1 \ \ 1$
$2 \ \ 0$

可以发现除了第 $2$ 个数据，其余行的数都有指向的，因此，第 $2$ 行数据就是单链表的头结点，$a_i$ 表示数据域，$b_i$ 表示指针域，$b=0$，表示 NULL 值。

因此，只需要找到头结点，然后单链表遍历即可，最后输出反转后的链表。

代码如下

暂无

吐槽

题目的确有的不是很规范。

Atcoder ABC367 F 学到新东西啦！！

Thu, 22 Aug 2024 00:00:00 GMT

Rearrange Query

题目大意

给你两个长度为 $N$ 的数组，分别为 $A$ 和 $B$，有 $Q$ 个询问，每个询问有四个值，分别为 $l, r, L, R$，问 $A[l-r],B[L-R]$ 的多重集是否相等。

题目链接：https://atcoder.jp/contests/abc367/tasks/abc367_f

数据范围

$1 \le N,Q \le 2\times10^5$
$1 \le A_i, B_i \le N$
$1 \le l \le r \le N$
$1 \le L \le R \le N$

题解

使用 Zobrist哈希 判断，具体操作如下：

取两个较大值 $L,MOD$
给 $1$ 到 $N$ 的每个值都映射到一个 $[0, L - 1]$ 里面的数，比如 $$
根据随机好的值求 $A$ 和 $B$ 的前缀值，比如 $S_A(r) = (\sum_{i=1}^r random[A[i]]) % MOD$
根据前缀和判断两多重集是否相等，如果值不相等为 no-instance，如果相等，则至少有 $1-\frac{1}{L}$的概率认为其为yes-instance，因此对于一个具有 $Q$ 次询问的题，通过测试的概率为有 $(1-\frac{1}{L})^Q$（可能有误）

因此，建议 $L$ 取 $2^{45}$ 或者 $10^{13}$ ，$MOD$ 取 $2^{61}-1$

拓展

如果不是求多重集合，而是求集合呢？？更简单了，那么就不是求前缀和，而是求前缀异或，同时也不需要 $MOD$ 了

#include <iostream>
#include <cstring>
#include <algorithm>
#include <random>

using namespace std;

random_device rd;
mt19937_64 gen(rd());

using LL = long long;


const int N = 200010;
const LL L = 1e13, MOD = (1ll << 61) - 1;

LL h[N];
LL A[N], B[N];


LL g(LL x) {
    return (x % MOD + MOD) % MOD;
}

int main() {

    // freopen("../in.txt", "r", stdin);
    // freopen("../out.txt", "w", stdout);
    int n, q; scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i ++ ) h[i] = gen() % L;

    for (int i = 1; i <= n; i ++ ) {
        int x; scanf("%d", &x);
        A[i] = (A[i - 1] + h[x]) % MOD;
    }
    for (int i = 1; i <= n; i ++ ) {
        int x; scanf("%d", &x);
        B[i] = (B[i - 1] + h[x]) % MOD;
    }

    while (q -- ) {
        int l, r, L, R; scanf("%d%d%d%d", &l, &r, &L, &R);
        if (g(A[r] - A[l - 1]) == g(B[R] - B[L - 1])) puts("Yes");
        else puts("No");
    }
    
    return 0;
}

:::note 证明自行查阅资料 :::

[SDOI2009] HH的项链

题目大意

给你一个长度为 $n$ 的数组 $A$，给你 $q$ 个询问。每个询问有两个整数 $l, r$，问 $A$ 数组中区间 $[l,r]$ 的集合个数

题目链接：https://www.luogu.org/problemnew/show/P1972

数据范围

$1\le n, q \le 10^6$
$1 \le A_i \le 10^9$
$1 \le l,r \le n$

题解

离线+树状数组

时间复杂度 $O(nlogn)$

第一步，首先把所有的询问存储下来，然后根据右端点排序

第二步，记录项链中每个贝壳其左边第一个相同种类的下标

第三步，把所有贝壳的种类的贡献都放在最右边的贝壳中

第四步，处理询问，按照右端点从大到小来处理，如果此时的右端点是大于上一轮右端点，也就意味着当前右端点的后面部分已经没用了，所有需要更新。更新的原则是：1. 转移贡献，根据第二步计算的当前贝壳其左边第一个相同种类的下标贡献+1，当前贝壳贡献减一

第五步，当前询问的答案是 $query(r) - query(l - 1)$

代码如下

#include <iostream>
#include <unordered_map>
#include <algorithm>
#include <map>

#define lowbit(x) ((x) & (-x))

using namespace std;

typedef tuple<int, int, int> TIII;

const int N = 1000010;

int tr[N];
int n, q; 
TIII arr[N];
int color[N];
int res[N];
int pre[N];
map<int, int> um;

void add(int x, int val) {
    for (int i = x; i <= n; i += lowbit(i)) tr[i] += val;
}

int query(int r) {

    int res = 0;
    for (int i = r; i; i -= lowbit(i)) res += tr[i];
    return res;
}

int main() {
    
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &color[i]);
    
    for (int i = 1; i <= n; i ++ ) {
        if (um.count(color[i])) {
            add(um[color[i]], -1);
            pre[i] = um[color[i]];
        }
        add(i, 1);
        um[color[i]] = i;
    }
    
    scanf("%d", &q);
    for (int i = 1; i <= q; i ++ ) {
        int x, y; scanf("%d%d", &x, &y);
        arr[i] = {y, x, i};
    }

    sort(arr + 1, arr + 1 + q);
    reverse(arr + 1, arr + 1 + q);

    int last = n;
    for (int i = 1; i <= q; i ++ ) {
        auto [r, l, id] = arr[i];
        while (last > r) {
            if (pre[last]) {
                add(pre[last], 1);
            }
            add(last, -1);
            last -- ;
        }
        res[id] = query(r) - query(l - 1);
    }

    for (int i = 1; i <= q; i ++ ) printf("%d\n", res[i]);
    return 0;
}

:::note hh，其实可以算左端点的贡献，按照左端点排序，应该更简洁 :::

美团技术笔试第二场

Sun, 18 Aug 2024 00:00:00 GMT

好久没写题了，就 A 了两题。。

第一题

题意描述

有 $T$ 组测试用例，每次测试用例给你一个 $n$，让你求一个数 $m$，使得最大公因数 $gcd(n,m)$ 为素数

数据范围

大概是 $T \le 100$ ， $2 \le n \le 100000$

解法

线性筛 + 枚举

时间复杂度 $O(n + T\frac{n}{ln n})$

首先用线性筛求出所有的素数，然后枚举所有素数，看是否是 $n$ 的约数

代码如下

#include <iostream>
#include <cstring>

using namespace std;

const int N = 100010;

int p[N], cnt = 0;
bool st[N];

void init(int n) {

    for (int i = 2; i <= n; i ++ ) {
        if (!st[i]) p[cnt ++ ] = i;
        for (int j = 0; i <= n / p[j]; j ++ ) {
            st[i * p[j]] = true;
            if (i % p[j] == 0) break;
        }
    }
}

void solve() {
    int n; scanf("%d", &n);
  //  cout << cnt << endl;
    for (int i = 0; p[i] <= n; i ++ ) 
        if (n % p[i] == 0) {
            printf("%d\n", p[i]);
            break;
        }
}

int main() {

    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);

    init(N - 1);
    int T; scanf("%d", &T);
    while (T -- ) {
        solve();
    }
}

:::tip hh，事实上线性筛本质上就是用一个合数的最小素数因数将该合数筛掉，因此只需要保存每个数的最小素数因子即可。所以最后的枚举多此一举，时间复杂度应该为 $O(n+T)$ :::

第二题

题意描述

给你一个长度为 $n$ 的数组，然后你可以执行无限次以下操作

选择数组下标不同的两个数 $a_i,a_j$，使得数组中 $a_i \rightarrow a_i - 1$，$a_j \rightarrow a_j+1$

求使得使得这个数组极差最小的最少操作数

:::note 极差：数组中最大值和最小值之差 :::

数据范围

$n \le 100000$
$1 \le a_i \le 10^9$

解法

思维

时间复杂度 $O(nlogn)$

可以想象这个数组极差最小是多少？一定是 $0$ 或者 $1$

假设此时极差不为 $0$ 或者 $1$，也就是最大值 $a_{max}$ 和最小值 $a_{min}$ 之差 $\ge 2$ ，那么此时可以通过一次操作将这两个数的差降到 $0$ 或者 $1$。如果进行了此次调整，极差仍然不为 $0$ 或者 $1$，继续执行改步骤即可

另外，假设 $S = \sum a_i$ ，由于每次操作都有一个数减一，一个数加一，因此每次操作 $S$ 不变。

因此，如果 $S % n = 0$，说明最后极差一定为 $0$，且每个数都为 $S / n$；如果 $S % n \neq 0$，说明最后极差一定为 $1$，且有 $S % n$ 个数为 $\frac{S}{n} + 1$ ，$n - S % n$ 个数为 $S / n$

根据贪心性质，将数组从大到小排序，前面 $S % n$ 个数变成 $\frac{S}{n} + 1$ 和后面的$n - S % n$ 个数变成 $S / n$ 需要操作数为 $res$

最终答案就是 $res / 2$

代码如下

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010;

int q[N];
int n; 

int main() {

    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);


    scanf("%d", &n);
    LL sum = 0;
    for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]), sum += q[i];
    sort(q, q + n);
    reverse(q, q + n);
    LL t1 = sum / n, t2 = sum % n;

    LL res = 0;
    for (int i = 0; i < n; i ++ )
        if (i < t2) res += abs(q[i] - t1 - 1);
        else res += abs(q[i] - t1);
    printf("%lld\n", res / 2);

}

:::caution 注意开 long long :::

:::warning 下题暂未给出代码，仅给出目前思路，等 A 了之后再上传 :::

第三题

题目大意

给你一个长度为 $n$ 的数组，其数组之和为$\sum a_i$，然后接下来有两个人顺序执行两个操作

小红先选择一段区间 $[l,r]$，对该区间的每个数都乘 $k$，小红希望选择的区间能够让最后的 $sum$ 尽可能大
小明再选择一段区间 $[l,r]$，对该区间的每个数都乘 $k$，小明希望选择的区间能够让最后的 $sum$ 尽可能小

问：在经过这两个操作之后，$sum$ 的值为多少？

数据范围

$1\le n \le 1000$
$-10^5 \le k \le 10^5$
$-10^5 \le a_i \le 10^5$

解法

问题一 假设最开始的数组累和为 $sum$，修改的区间是 $[l,r]$，将其每个值都乘 $k$，最后的 $sum_c$ 是多少？

答：$sum_c = sum + (k - 1) * \sum_{i=l}^r a_i$

问题二 $sum$ 值难道不是取最大值或者最小值吗？

答：这里显然不是，$sum$ 是在题目限定下一个确切的值。

假设小红已经做出选择，根据问题一，小明只需要找一个最大或者最小的连续字段和便可。因此，小红要想最后的 $sum$ 取最大值，是所有区间里面，最后的 $sum$ 最大的区间

暴力

时间复杂度 $O(n^3)$

根据上述分析，有一个很暴力的解法就是枚举小红选择的区间，然后小明对每个修改后的数组求一遍最大或者最小子段和，然后所有区间能求得的最大值就是 $sum$

线段树优化

---Update: 2024-08-28 :::important hh，这题事实上线段树就解决了，下面的分析完全不需要。暴力枚举小红的区间，然后每个区间乘 $k$，线段树可以 $logn$ 更新；然后求最大/小连续子区间也可以线段树求。

数据结构太弱了 ~ :::

时间复杂度 $O(n^2 logn)$

首先先把特殊情况去掉，如果 $k = 1$ ，则无论怎么样，$sum$ 的值都不会变，因此情况分为 $k > 1$ 和 $k < 1$；以下分析只考虑 $k > 1$ 的情况， $k < 1$ 的分析类似。

上面这个暴力的时间复杂度问题在于枚举了小红选择的所有区间，并且小红和小明最后所选的区间也没有任何联系，那么能否优化这部分？

答案是肯定的。我们仔细想一想，小红和小明选择的区间是否存在交叉的情况

:::tip 区间A: [1,5]，区间B:[2,6]。区间 A B 表示交叉，如果 A 完全包含 B 或者 B 完全包含 A，不表示交叉；同时，A 和 B 没有交集也表示不交叉。 :::

假设最后选择中，小红和小明选择的区间是由交叉部分的，如果交叉部分的和的值是等于 0 的，无论是小红还是小明，加上这个区间都没有意义，相当于两人的选择是没有交集的；如果交叉部分的和的值是大于 0 的，那么对于小明来说，不选择这个区间比选择这个区间更优，因此可以去掉这个区间；如果交叉部分的和的值是小于 0 的，那么对于小红来说，这部分区间反而给小明利用了，因此不选择这部分区间比选择这部分区间更优

综上，小红小明最终选择的两区间，一定是不交叉的。（注意可以是包含关系）

因此这里分为三种情况考虑：

假设同样枚举小红区间为 $[l,r]$

小红与小明区间没有交集

小明则无非是选择 $[1,l-1]$ 或者 $[r + 1, n]$ 的最小子段和
小明区间完全包含小红区间

小明无非就是选择以 $[1,l-1]$ 中以 $l-1$ 为终点的最小子段和的区间以及 $[r + 1, n]$ 中以 r + 1 为起点的最小子段和的区间以及 $[l,r]$
小红区间完全包含小明区间

$[l,r]$ 区间的最小字段和

可以看到上述 1、2 好求，但是 3 目前只能想到用线段树来维护，因此每次求这个区间最小字段和的时间复杂度为 $O(logn)$

写在最后，第三题有更好的解法欢迎讨论

吐槽

我太菜了，果然只有对算法融会贯通才能写出第三题嘛 ┭┮﹏┭┮

与树相关

Sun, 30 Jun 2024 00:00:00 GMT

树的直径

树的直径必须边

对于任意一条直径 $a_0,a_1,\cdots,a_k$ ，假设找到最大的 $left$ $a_{left}$ 可以替换 $a_0,a_1,\cdots,a_{left}$ 的部分，最小的 $right$ $a_{right}$ 可以替换 $a_{right},\cdots,a_k$ 部分，那么 $right - left$ 就是必须边

网络流

Thu, 25 Apr 2024 00:00:00 GMT

概念

流网络$G=(V,E)$：一个有向图，有源点和汇点，每条边上的权值为流量，表示这条边每次能通过的最大流量。就好比有水从源点源源不断地流向汇点，在这个过程中，水会流向多个管道，但是每条管道都会有流量限制。不考虑反向边。如果有反向边，也可以通过加点的方式变成没有反向边。

可行流 $f$ ：满足 1. 容量限制 $0\le f(u,v) \le c(u,v)$，2. 流量守恒（除了源点和汇点之外，其余所有点都不存储流）$v,x \in {V / {s,t} } \ \ \sum_{(v,x)\in E} f(v,x) = \sum_{(x,v)\in E} f(x,v)$ 。这里不考虑反向边。$|f|$ 表示从源点到汇点的流量值是多少，或者说速率。$|f|=\sum_{(s,v)\in E}f(s,v) - \sum_{(v,s) \in E}f(v,s)$ ，简单地说就是源点往外流的流量减去往源点流的流量。

最大流 ：所有可行流中流量值最大的可行流，也就是最大可行流

残留网络$G_f$：残留网络是针对流网络的某一条可行流来说的，残留网络里面的点是原网络的点集，残留网络的边集是原来网络里面的边集和反向边集，权值的定义为： $$ c^\prime(u,v) \left{ \begin{aligned} &c(u,v)-f(u,v) & (u,v)\in E \ &f(u,v) & (v,u) \in E \ \end{aligned} \right. $$ 残留网络可能也有可行流 $f^\prime$ ，原网络的可行流+残留网络的可行流也是原图的可行流，因此 $|f+f^\prime|=|f|+|f^\prime|$ 可行流相加等价于边相同方向则权值累加，边相反则原图边减去残留网络边的权值

$f+f^\prime$ 是否是原图可行流？判断是否满足容量限制和流量守恒即可

残留网络里面没有可行流，原网络可行流一定是最大流

增广路径：在残留网络里面，沿着容量大于 $0$ 的边走，如果能走到终点，则这条路径被称为增广路径

割：将点集 $V$ 分成 $S$ 和 $T$ 两个子集，使得 $S\cup T = V$ 并且 $S \cap T = \emptyset$ ，$s \in S$，$t \in T$ 。换句话说，把点集分成不重的两个部分，源点在 $S$ 集中，汇点在 $T$ 集中，划分的这个结果称为图中的一个割。点集不一定连通。任意图一共有 $2^{n-2}$ 个割

割的容量$c(S,T)$：指的是划分后的 $S$ 集中点到 $T$ 集中的边的权值之和

最小割：所有割中容量最小的割

割的流量$f(S,T)$：割的流量是对一个可行流来说的，就是 $S$ 到 $T$ 的边的所有可行流值减去 $T$ 到 $S$ 的边的所有可行流值

割的性质

任意一个割$[S,T]$和任意一个流$f$，一定有 $f(S,T) \le c(S,T)$
任意一个割$[S,T]$和任意一个流$f$，一定有 $f(S,T) = |f|$ 直观地思考一下，$s$ 流到 $t$ 的容量等价于 $S$ 流到 $T$ 的净流量

稍微证明：设 $f(X,Y) = \sum_{u\in X}\sum_{v \in Y} f(u,v) - \sum_{u\in X}\sum_{v \in Y} f(v,u)$ 那么，有$f(X,Y) = -f(Y,X)$，$f(X,X)=0$，如果，$X\cap Y = \emptyset$，$f(Z,X\cup Y)=f(Z,X)+f(Z,Y)$，同样地 $f(X\cup Y,Z)=f(X,Z)+f(Y,Z)$ 因此，$f(S,V)=f(S,S)+f(S,T)$，也就是 $f(S,T)=f(S,V)$ 从而有 $$ f(S,T)=f({s},V)+f(S-{s}, V) $$ 由于 $S - {s}$ 集合不包含源点 $s$ 和汇点 $t$，根据流量守恒，$f(S-{s},V)=0$ 因此 $f(S,T)=f({s},V)=|f|$

推论3. 任意一个割$(S,T)$和任意一个流$f$，有 $|f| \le c(S,T)$

从而得知：最大流 $\le$ 最小割

最大流最小割定理： （1）可行流 $f$ 是最大流（2）可行流 $f$ 的残留网络中不存在增广路（3）存在某个割 $[S,T]$ ，$|f|=c(S,T)$ 三个条件两两等价

证明：（1）$\Longrightarrow$ （2）。可以用反证法证明，如果存在增广路，那么这个残留网络的可行流 $|f^\prime| \gt 0$ ，因此 $f+f^\prime$ 是一个更大的可行流，这与 $f$ 是最大流矛盾

（3）$\Longrightarrow$ （1）。根据上面的推论3，最大流 $\le c(S,T)$ ，而又因为有 $|f| = c(S,T)$ ，因此最大流 $\le |f|$ ，又根据定义 $|f| \le$ 最大流。从而，存在有某个割 $[S,T]$，$|f|=c(S,T)$ ，那么 $f$ 是最大流。从这里还能发现一个隐含的等于，由于最大流 $\le$ 最小割，又有最小割 $\le c(S,T) = |f| \le$ 最大流。因此，最大流=最小割

（2）$\Longrightarrow$（3）。用构造来证明，就是在残留网络中不存在增广路能否构造出一个割，使得 $|f|=c(S,T)$。我们构造 $S$ 为在 $G_f$ 中沿着容量大于 0 的边所有能走到的点，$T = V - S$，这样子 $s\in S$，$t\in T$ 是一个合法的割。注意：割虽然是根据残留网络构造，但是划分里面的边还是原网络里面的边。

对于 $x \in S, y \in T$，如果 $(x,y) \in E$ ，那么 $f(x,y)=c(x,y)$，因为从构造角度来看，在残留网络中 $(x,y)$ 的权值为 $c(x,y)-f(x,y)$，如果这个值是大于0，则 $y \notin T$ ，这与划分矛盾。同样地，对于 $a\in T, b \in S$，如果 $(a,b) \in E$，那么 $f(a,b)=0$，因为从构造的角度来看，在残留网络中，如果 $f(a,b) \gt 0$ ，那么其建立的反向边 $f(b,a)=f(a,b) > 0$ ，则 $a \notin T$ ，这与划分矛盾。

从而 $|f|=f(S,T)=\sum_{u\in S}\sum_{v \in T} f(u,v) - \sum_{u\in S}\sum_{v \in T} f(v,u) = \sum_{u\in S}\sum_{v \in T} f(u,v) = \sum_{u\in S}\sum_{v \in T} c(u,v)$

算法

无论什么算法，都逃不过 FF 方法，也就是

找增广路径
更新残留网络似乎有 ISAP 算法可替代，HLPP 算法优化很大，常用背 dinic 算法即可

EK 算法

时间复杂度 $O(nm^2)$，处理 1000~10000 的网络没有问题代码如下：

#include <iostream>
#include <cstring>

using namespace std;

const int N = 1010, M = 20010, INF = 0x3f3f3f3f;

int n, m, S, T;
int h[N], e[M], ne[M], f[M], idx = 0;
bool st[N];
int d[N], q[N], pre[N];

void add(int a, int b, int c) {
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int bfs() {
    memset(st, 0, sizeof st);
    int hh = 0, tt = 0;
    q[0] = S; st[S] = true; d[S] = INF;
    
    while (hh <= tt) {
        int u = q[hh ++ ];
        for (int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];
            if (!st[v] && f[i]) {
                st[v] = true;
                d[v] = min(d[u], f[i]);
                pre[v] = i;
                if (v == T) return true;
                q[++ tt] = v;
            }
        }
    }
    return false;
}

int EK() {
    
    int ans = 0;
    while (bfs()) {
        ans += d[T];
        for (int i = T; i != S; i = e[pre[i] ^ 1])
            f[pre[i]] -= d[T], f[pre[i] ^ 1] += d[T];
    }
    return ans;
}

int main() {
    
    memset(h, -1, sizeof h);
    
    cin >> n >> m >> S >> T;
    while (m -- ) {
        int a, b, c; cin >> a >> b >> c;
        add(a, b, c), add(b, a, 0);
    }
    
    cout << EK() << endl;
    return 0;
}

dinic 算法

时间复杂度 $O(n^2m)$ ，处理 10000 ~ 100000 的网络没有问题

思路：

bfs 建立分层图
dfs 找出所有能增广的路径代码如下：

#include <iostream>
#include <cstring>

using namespace std;

const int N = 10010, M = 200010, INF = 0x3f3f3f3f;

int n, m, S, T;
int h[N], e[M], ne[M], f[M], idx = 0;
int q[N], d[N], cur[N];

void add(int a, int b, int c) {
    e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

bool bfs() {
    int hh = 0, tt = 0;
    memset(d, 0, sizeof d);
    d[S] = 1, q[0] = S, cur[S] = h[S];
    
    while (hh <= tt) {
        int u = q[hh ++ ];
        for (int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];
            if (!d[v] && f[i]) {
                d[v] = d[u] + 1;
                cur[v] = h[v];
                if (v == T) return true;
                q[++ tt] = v;
            }
        }
    }
    return false;
}

int find(int u, int limit) {
    
    if (u == T) return limit;
    
    int flow = 0;
    for (int i = cur[u]; ~i && flow < limit; i = ne[i]) {
        cur[u] = i;
        int v = e[i];
        if (d[v] == d[u] + 1 && f[i]) {
            int t = find(v, min(f[i], limit - flow));
            if (!t) d[v] = 0;
            flow += t, f[i] -= t, f[i ^ 1] += t;
        }
    }
    return flow;
}

int dinic() {
    int r = 0, flow;
    while (bfs()) while (flow = find(S, INF)) r += flow;
    
    return r;
}

int main() {
    
    memset(h, -1, sizeof h);
    
    cin >> n >> m >> S >> T;
    
    while (m -- ) {
        int a, b, c; cin >> a >> b >> c;
        add(a, b, c); add(b, a, 0);
    }
    
    cout << dinic() << endl;
    return 0;
}

最大流模型

二分图模型

二分图最大匹配

二分图的最大匹配可以转化成一个网络流问题，时间复杂度为 $O(m\sqrt n)$

建图思路为：首先考虑一个源点 $S$ 和汇点 $T$，然后对于 $V_1$ 集中的点，每个点最多只会选择一次进行匹配，因此可以把 $S$ 和 $V_1$ 集中的每个点连接一条容量为 $1$ 的边，表示这条边对应的点要么不选，要么只选一次；然后对于 $V_2$ 集中的点，同样也最多只会选择一次进行匹配，因此可以将每个点向汇点连接一条容量为 $1$ 的边；最后原来 $V_1$ 和 $V_2$ 中的边都设置容量为 $1$ 。最后对这个转化后的图求得的最大流就是二分图最大匹配

证明：首先证明二分图的一个匹配可以转化为新图中的一个可行流。显然满足流量守恒和容量限制。其次证明新图中的一个整数可行流也可以转化成二分图的一个匹配。对于一个可行流，由于容量限制， $V_1$ 的出度一定要么是0，要么是 1，$V_2$ 的入度要么是 0 要么是 1，并且 $V_1$ 出度为 1 的点一定流向 $V_2$ 入度为 1 的点，这些流量为 1 的边就是一个匹配

二分图多重匹配

二分图的多重匹配指的是每个点可以多次匹配，但是有上限，或者说限制了每个点最多和多少条匹配边相关联

这个建图思路和上面类似，首先建立源点和汇点，然后源点连接一个点集，容量为点集 $V_1$ 能够匹配上限，点集 $V_2$ 连接汇点，容量为能够匹配上限。中间 $V_1$ 到 $V_2$ 的边按照原图连接，不过容量为题目所限制的

上下界可行流

无源汇

无源汇上下界可行流可以做一个转化变成一个正常最大流的一个限制 $(G,f) \Longrightarrow (G^\prime, f^\prime)$

简单来说，对于上下界可行流中的边可行流限制 $c_L(u,v) \le f(u,v) \le c_U(u,v)$ ，不等式两边减去其下界可得$0 \le f(u,v) \le c_U(u,v) - c_L(u,v)$ ，这样就变成了正常的最大流的容量限制。显现这个是满足容量限制的，但是不满足流量守恒。

假设存在这样的上下界可行流，那么对原网络进行转化后，每条边的流量要减去这条边的容量下界，因此此时不一定满足流量守恒。单从某个点来说，原网络的流量守恒有 $\sum_{v\in V} C(x,v) = \sum_{v\in V}C(v,x)$ ，但是由于这里的容量变小了，令 $C_I = \sum_{c\in V} C^\prime(v,x),C_O = \sum_{c\in V} C^\prime(x,v)$ ，也就是说 $\sum_{v\in V} C(x,v) - C_O \neq \sum_{v\in V}C(v,x) - C_I$ 时，流量不守恒，我们需要执行操作使其守恒，也就是说，如果 $C_I \gt C_O$，需要从源点 $S$ 连接一条到点 $x$ 的一条容量为 $C_I-C_O$ 的边，否则从 $x$ 连接到一条到汇点 $T$ 的一条容量为 $C_O - C_I$ 的边，最后判断其最大流在其新建边上是否满流即为存在上下界可行流。

此建图方案是否可行等价于证明原网络的可行流可以变成新网络的最大流，新网络的最大流且满流是否可以还原成原网络的可行流。

有源汇

有源汇与无源汇的最大的区别在于有源汇中的源点和汇点流量是不守恒的，因此，此处的处理方法为汇点连接源点一条容量为无穷大的边，这样一定是满足流量限制且是无源汇的。

通过这样的转化后，要想判断是否有源汇上下界可行流，就判断新图是否满流，那么如何求这样的最大可行流呢？

有一个想当然的思路是：当进行对新图进行一遍dinic 算法之后，然后判断满流是否有可行流。再在这个新图上，把新加的原图中汇点到源点容量为正无穷的边删掉，再做一遍从原图中源点到汇点的dinic算法。如果求最小可行流就是最后做一遍汇点到源点的dinic算法，并减去即可。

这个方法从策略上是正确的，但是要注意从逻辑上区分，只是我们在这里恰好能做。

证明：$(G,f)\iff (G^\prime,f^\prime)$

对于原图任意的可行流，可以变成新图的一个满流。$(G,f_0)\Longrightarrow (G^\prime, f_0^\prime)$

做题细节 注意：有源汇上下界分为最小流和最大流，另外最终的可行流流量可能为负数，假如 $S->T$ 的流量为 0，$T->S$ 的流量为 10，$S->T$ 的最小流就是 $-10$ 对于最大流和最小流，都是要建立一条汇点到源点容量为无穷大的边，然后跑完第一次dinic算法之后，判断其是否满流。注意，这个时候如果我们还原成原图的可行流，其中的可行流流量是多少？就是新加的汇点到源点中残余网路反向边的容量，这个时候把这个汇点到源点的边删除。从原来的源点跑汇点就是最大流，从源点的汇点跑到源点就是最小流。

多源汇最大流

思路和最短路是思路是一样的，建立超级源点和超级汇点，其容量为无穷大即可。

关键边

最大流的关键边是如果我们把这条边的容量上界提升，那么最大流增加。求解最大流关键边的步骤：

先应用 dinic 算法求解最大流，那么残余网络正向边的容量为 0 的边可能是关键边
分别对源点和汇点应用 dfs。对于源点来说，找到这个点只走残余网络正向边容量大于 0 的边能到的点；对于汇点来说，通过反向边遍历，限制是其对应的正向边的容量大于 0，找到所有能遍历到的点
枚举所有满流的边，如果源点能走到它且汇点也能走到它，那么这就是关键边

利用网络流进行判断

最小化最大值类型
判断是否可行

拆点技巧

如果某些题对点具有限制，那么便可以进行拆点

最小割模型

割：$[S,T]$ 割的流量：$f(S,T)$ 割的容量：$c(S,T)$

最大权闭合图

闭合图是对于有向图来说的，也就是$G(V,E)$ 中的一个点集，这个点集相关的所有边，不能从点集里面指向点集外面，如下图红色圈内所示

点集加上点集内部的边被称为原图的一个闭合子图，那么最大权闭合子图就是点的权值之和最大的闭合子图

做法就是转化成最小割模型，首先将其转化成流网络，如下图所示

可以证明原图的一个闭合子图对应流网络的一个割对于这个问题本身有个简单割的概念：指的是所有的割边一定是和源点或者汇点相连，现在简单割是所有割的子集

最小割一定是简单割。因为最大流最小割定理，最小割一定是有限值，而且中间的边都是无穷，因此最小割一定是简单割

现需要证明 闭合子图对应一个简单割 假设有闭合子图 $V^\prime$，其对应的割 $[S,T]$，其中 $S = V^\prime +{s}, T = V - S$ ，因为 $V^\prime$ 是所有出边都是在 $V^\prime$ 里面，因此，割边不存在容量为无穷的边，因此这个闭合子图对应一个简单割

数量关系：$c[S,T]=c[V^\prime,{t}]+c[{s},\overline{V^\prime}]=\sum_{v\in {V^\prime} ^-}{(-w_v)} + \sum_{v\in {\overline{V}^\prime}^+}w_v$ 又闭合子图的权值之和为 $W(V^\prime)=\sum_{v\in {V^\prime} ^+}{(w_v)} - \sum_{v\in {V^\prime}^-}(-w_v)$ 因此，$c[S,T]+W(V^\prime)=$ 所有的正权值之和由于等式右边是定值，所有要想 $W(V^\prime)$ 最大，$c[S,T]$ 得最小，等价于求最小割

方案最大闭合子图就是 $S$ 通过残余网络能到的所有点

最大密度子图

在无向图里面选择一些点和一些边，这个点集都是在边里面的，其密度为 $\frac{|E^\prime|}{|V^\prime|}$ ，求密度最大的子图

这个一般是 [[最短路模型#0/1 分数规划]] 问题，因此二分一个 $mid$ ，因此如果存在 $\frac{|E^\prime|}{|V^\prime|} > mid$ ，也就是 $mid * |V^\prime| - |E^\prime| < 0$ 因此相当于是求 $mid * |V^\prime| - |E^\prime|$ 的最小值，如果其小于 0 ，等价于存在 $\frac{|E^\prime|}{|V^\prime|} > mid$

拓展事实上这个问题可以转化成最大权闭合图，根据选择的边其相应的点一定要选择，可以将边也看作点，不过要求的是是否存在 $|E^\prime| - mid * |V^\prime|$ 的最大值大于 0，这样才等价于最大权

有这样一个性质：如果选择了一些点，其内部边一定全部选择才能使其密度最大，因此可以得到其计算公式： $$ mid * |V^\prime| - |E^\prime| = \sum_{v \in V^\prime} mid - \frac{\sum_{v\in V^\prime}d_v - c[v^\prime,\overline{v}^\prime]}{2} $$ 边的计算方法就是其点的度数之和减去割的容量除2，因为是在无向图中。这样就和割关联起来

等式变形： $$ mid * |V^\prime| - |E^\prime| = \frac{1}{2}(\sum_{v\in V^\prime} (2mid - d_v) + c[v^\prime,\overline{v}^\prime]) $$ 但是问题在于左边这项怎么处理，其是通过每个点都向汇点连接一条容量是 $2mid-d_v$ 的边，原图内部边容量为 1，然后源点向每个点连接一条容量为 1 的边。

但是这里出现了另外一个问题，就是 $2*mid-d_v$ 可能小于0，因此这里有个策略是源点连接所有点的边的容量和所有点连接汇点的边的容量都加上一个偏移量 $U$ ，但是，注意，不是所有图都能这样子加，这是因为这个问题的特殊性。

可以计算，最后 $c[S,T]=Un + 2 mid |V^\prime|-2|E^\prime|$ 因此，求出变化后的流网络的最小割之后，其原网络的最小割为 $\frac{c[S,T] - U*n}{2}$

如果有边权怎么办？ 就是每条边有大于 0 的权值，区别在于 $|E^\prime|$ 的计算，其中 $d_v$ 不再是每个点的度，而是与其相关所有边的权值之和

如果同时有点权和边权怎么办？一般来说，如果同时存在会最大化 $\frac{|E^\prime|+|V^\prime|}{|V^\prime|}$ ，等价于最小化 $$ mid*|V^\prime|-|V^\prime|-|E^\prime|=\frac{1}{2}(\sum_{v\in V^\prime} (2mid - 2p_i- d_v) + c[v^\prime,\overline{v}^\prime]) $$ 和上面比较不过是稍微修改了下流网络的权值

方案最大密度子图的方案为：$S$ 通过残余网络能到的所有点

最小权点覆盖集

假设所有点权值非负，求总权值之和最小的点覆盖集这在一般图中是 NP-hard ，但是在二分图中不是

建图：二分图原图连接的边的容量为无穷大，源点到左部集的边的容量为对应点的权值，右部集到汇点的边的容量为对应点的权值

可以证明：一个简单割对应一个点覆盖集

同样：也可以看出一个割的容量对应了一个点覆盖集的权值之和，因此，求二分图的最小权点覆盖就等价于求新图的最小割

求方案：首先根据最大流求出 $S$ 和 $T$ 集合，然后求割边，已经割边是最小割，要么源点是 $S$ ，要么汇点是 $T$ ，因此

最大权独立集合

注意：权值如果有非负那么提前把非负的点提前选上在二分图中，最大权独立集 = 所有点的总权值 - 最小权点覆盖

假设点集 $V$ ，点覆盖集为 $V_1$ ，补集 $V_2=V-V_1$ 是独立集证明反证法：假设 $V_2$ 中 $v_1,v_2$ 有边，说明这条边里面没有被覆盖，因此与假设矛盾
假设有独立集 $V_2$ ，$V_1 = V - V_2$ 一定是点覆盖集证明反证法：假设 $V_1$ 不是点覆盖集，那么一定存在一条边 $(v_1,v_2)$ 没有被覆盖，或者说任意两点不在 $V_1$ 中，因此其都在 $V_2$ 中，与 $V_2$ 是独立集矛盾

做题思路

构造流网络
证明简单割和原图可行方案一一对应
思考数量关系

费用流模型

费用流--所有最大可行流中费用最小/最大值：$\sum f(u,v)w(u,v)$

Q：图 $G$ 有最大流，是否一定有最小费用最大流？A：一定有

把 EK 算法中的 bfs 换成 spfa 即可求出费用流一般情况下，要保证没有负权回路
假设正向边的费用是 $w(u,v)$，那么反向边的费用为 $-w(v,u)$ 只要原图没有负权回路，那么残留网络求最短路就没有负权回路

如果有负环回路，需要消圈法去解决

二分图最优匹配

敬请期待

无源汇有上下界最小费用可行流

敬请期待

图论小知识点

Mon, 15 Apr 2024 00:00:00 GMT

欧拉路径与欧拉回路

注意：所有边连通且可以存在孤立点 在无向图中，

一个图存在欧拉路径的充分必要条件：度数为奇数的点只能有 0 个或者两个
一个图存在欧拉回路的充分必要条件：度数为奇数的点只能为 0 个

在有向图中，

一个图存在欧拉路径的充分必要条件：要么所有点的入度等于出度，要么除了两个点之外，其余所有点的出度等于入度，剩余的两个点：一个满足于入度比出度多1（终点），一个满足出度比入度多1（起点）。
一个图存在欧拉回路的充分必要条件：所有点的入度等于出度

证明

必要条件：无论是有向图还是无向图的必要条件证明都是从以下思路出发，首先对于图中的一笔画问题，肯定是有一个起点和终点，那么除了起点和终点，其余所有点都需要先进来再出去，然后对于起点来说可以没有过来的点，对于终点来说可以没有可以去的点。对于回路来说，就是所有点都需要进去和出去。

充分条件：通过给出一种构造方案来进行证明

构造方案：

dfs(u) {
	for  u 的所有边
		 dfs() // 扩展
	seq <- u // u 加入到路径序列中
}

此构造方案为欧拉路径的逆序，正如下图中的 $(b)$，首先从一个奇数点（起点，如果奇数点为0，则任意点）一直往后遍历，由于中间点的度数是偶数，因此遍历到中间点一定可以再去下一条边，直到回到起点（如果是欧拉回路，一定是起点），或者某个点的度为奇数（终点）。然后就是回溯，在回溯的过程中保存欧拉回路/路径的点，然后如果碰到了没有遍历完的点，则继续遍历，因此此时已经没有终点，所以最终一定会回到这个点，这样就相当于在此处有一个环，也可以通过逆序的方式将其欧拉路径融合起来。从而所得欧拉路径就是一个终点到起点的欧拉路径逆序。

注意使用邻接表存储时，假设图是一个有 $m$ 条边的自环，正如下图中的$(a)$，事实上，时间复杂度是 $O(m^2)$ 的，如果是邻接矩阵就是 $O(nm)$ 的时间复杂度。因此，在 $m$ 比较大的时候，可以选择直接删除一条边来降低时间复杂度为 $O(n+m)$

事实上，在随机数据上，这个时间复杂度还是挺快的。

另外，在删边方面，有向图删边直接就删除了，但是在无向图里面，由于是加入了正反两条边，因此，根据链式前向星的特性，$i$ 所对应的反边在 $i \oplus 1$

欧拉回路

判断欧拉回路

有向图

// 在添加边的时候注意计算入度和出度即可
for (int i = 1; i <= n; i ++ )
    if (din[i] != dout[i]) {
        puts("NO");
        return 0;
    }

无向图

// 在添加边的时候同样可以计算入度和出度，而且只需要计算一次即可
// 因此一条边要么是作入度要么作出度
// 相较于某个点来说，只需要作入度和作出度的总共次数为偶数即可
// 因为我们没必要在建立反向边的时候也更新入度和出度
// 否则其判断方式为 din[i] & 1
// 如果只考虑无向边，则计算度然后用度判断即可
for (int i = 1; i <= n; i ++ )
    if (din[i] + dout[i] & 1) { // 或者 d[i] & 1
        puts("NO");
        return 0;
	}

求欧拉回路方案

注意：如果是求欧拉路径，对于有向图来说，初始点一定是出度数-入度数=1的点；对于无向图来说，初始点一定是度数为奇数两个点中的一个点。

边方案

边标记

/*
这里只是把用过的边进行标记，但是并没有删除
对于上述说的情形，事实上这个这个复杂度是 O(m^2)
*/
void dfs(int u) {
    
    for (int i = h[u]; ~i; i = ne[i]) {

        if (used[i]) continue;
        used[i] = true;
        // 如果不是无向图，下面这行删掉
        if (type == 1) used[i ^ 1] = true; 
        dfs(e[i]);
        
        int t = i + 1;
        if (type == 1) {
            t = i / 2 + 1;
            if (i & 1) t = -t;
        }
        path[++ cnt] = t;
    }
}

删边优化

/*
注意在for循环中，后面是 i = h[u]，表示每次只使用当前可用的边
如果不加入此优化，复杂度最坏可为 O(m^2)
*/
void dfs(int u) {
	
    for (int i = h[u]; ~i; i = h[u]) {

        h[u] = ne[i];
        if (used[i]) continue;
        if (type == 1) used[i ^ 1] = true;

        dfs(e[i]);

        int t = i + 1;
        if (type == 1) {
            t = i / 2 + 1;
            if (i & 1) t = -t;
        }
        path[++ cnt] = t;
    }
}

点方案

2-SAT

建图

对于任意一个布尔变量，拆成两个点，分别为 $x_i$ 和 $\neg x_i$ 若给定一个 $x_i \vee x_j$ ，建造两条边，分别为 $\neg x_i \rightarrow x_j$ 和 $\neg x_j \rightarrow x_i$ ，如果 $x_i,\neg x_i$ 出现同一个强连通分量里面，说明这个逻辑表达式有矛盾，如果没有遍历每个点，对于 $x_i,\neg x_i$ 来说，谁的 id 值越小，就取值哪个

但是题目不一定是给出 $x_i \vee x_j$ ，有可能是 $a\rightarrow b$ 或者 $a=1/0$ ，对于 $a = 1$ ，可以转化成 $a \vee a$

树与图的存储

Sun, 14 Apr 2024 00:00:00 GMT

树与图的存储

树是一种特殊的图，与图的存储方式相同。对于无向图中的边(a,b)，存储两条有向边$a\rightarrow b, b \rightarrow a$。因此我们可以只考虑有向图的存储。

邻接矩阵 g[a][b] 存储边$a\rightarrow b$
邻接表

// 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点
int h[N], e[N], ne[N], idx;
// 另外可以使用栈把所有可开辟空间存储起来，然后每次 add 的时候就从栈顶取空间，删除则把空间加入栈中 一般来说只有大量删除的时候才使用栈式的空间开辟

// 添加一条边a->b
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

// 初始化
idx = 0;
memset(h, -1, sizeof h);

链式前向星的作用

i 的反向边是 i ^ 1
有向图中 $i$ 是表示第 $i + 1$ 条插入的边，无向图中 $i$ 是第 $i / 2 + 1$ 条插入的边

连通分量

Thu, 11 Apr 2024 00:00:00 GMT

有向图的强连通分量（SCC）

概念

有向图的连通分量：对于分量中任意两点 $u,v$ ，必然可以从 $u$ 走到 $v$，且从 $v$ 走到 $u$

强连通分量：极大连通分量，也就是在这个连通分量里面任意加入一个点都不满足连通分量的定义

有向图的强连通分量的作用：将有向图的强连通分量进行缩点，进而转化成有向无环图（DAG），也就是拓扑图，方便使用递推求最短/长路

注意，以下所表示的双亲或者孩子都是从 dfs 序树来说明树枝边：如下图所示，$dfn[u] = dfn[v]+1$，说明 $v \rightarrow u$ 是树枝边，这意味着 dfs 过程中，遍历了点 $v$ 之后就立马遍历 $u$ ，如下图绿色的边

前向边：如下图所示，假设 $dfn[u]=dfn[v]+1$，$u^\prime$ 是 $u$ 的后代，那么 $v \rightarrow u^\prime$是前向边，正如图中紫色的点，这也意味着这条边是在回溯的时候遍历的

后向边：如下图所示，假设 $v^\prime$ 是 $v$ 的后代，则 $v^\prime \rightarrow v$ 是后向边，正如图中青色的边

横叉边：如下图所示，当 $u$ 不是 $v$ 的孩子且 $dfn[u] < dfn[v]$ 时，说明有一条 $v\rightarrow u$ 的横叉边，正如图中红色边所示

求解强连通分量 由于我们从某个点出发，不一定能够一直遍历所有点，因此要遍历所有结点，才能够完整地求该图的强连通分量。另外，从某个点开始求各个强连通分量，这里的所有点，一定是不重不漏地属于某个强连通分量。

从某个点出发，那么其所在的强连通分量的示意图一定是上图所示。在 dfs 的过程中，$dfn[u]=low[u]$ 的点一定是强连通分量在 dfs 序树上的根。

其中 $dfn[u]$ 表示点 $u$ 的时间戳，$low[u]$ 表示从$u$能够遍历到没有在某个强连通分量的时间戳的最小值。

那么，为什么 $dfn[u]=low[u]$ 是判断出某个强连通分量的重要依据？首先，先来看算法特性，在求强连通分量的过程中，我们假设是有一个递归最后的强连通分量，那么根据时间戳来说，我们最后回溯到 $u$ 的时候，其后面遍历的所有点一定是强连通分量里面的所有点，因此，每当遍历一个新点的时候，我们选择使用栈来保存每个点

然后就是正常的 dfs 来遍历每个点，如果我们可以往下遍历，那么其孩子能够到的最小时间戳，也是当前点能到的时间戳，如果是可以走到一个已经遍历的点，那么这个点有着一个有效或者无效的概念，区别在于是否在栈中，如果是前向边，有效或者无效没有意义，因为 $low$ 值不会更新；如果是后向边，首先这个点一定是在栈中，然后同时其 $low$ 值也可更新；如果是横叉边，那么如果所对应的点不在栈中，说明这个点已经作为某个强连通分量中的点出栈了，如果在栈中，则说明其 $low$ 值一定可以更新。因为横叉过去的那个点$v$其不会出栈的理由在于 $low[v] \lt dfn[v]$ ，同理 $low[v]$ 这个点没有出栈的理由也是在于 $low[low[v]] < dfn[low[v]]$，如此往上，定会走到 $(u,v)$ 的一个公共祖先，因此可以发现 $u \rightarrow v$ ，也可以 $v \rightarrow u$ 。综合起来就是如果判断的是时间戳比较小的，如果它在栈中，就可以更新 $low$ 值。

从而，无法更新也就意味着这个强连通分量的 dfs 序根找到了

代码如下：

/* 
    // 求强连通分量
    for (int i = 1; i <= n; i ++ )
        if (!dfn[i])
            tarjan(i);
*/
void tarjan(int u) {
    dfn[u] = low[u] = ++ timestamp;
    stk[top ++ ] = u, in_stk[u] = true;
    
    for (int i = h[u]; ~i; i = ne[i]) {
        int v = e[i];
        if (!dfn[v]) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        } else if (in_stk[v]) low[u] = min(low[u], dfn[v]);
    }
    
    if (low[u] == dfn[u]) {
        ++ scc_cnt;
        int p;
        do {
            p = stk[ -- top];
            in_stk[p] = false;
            id[p] = scc_cnt;
        } while (p != u);
    }
}

拓展

使得任意一个图变成强连通分量需要加的最少边数？首先对这个图进行 tarjan 缩点

如果这个图本身是强连通分量，那么就不需要加
如果这个图不是强连通分量，那么对其缩点后一定是多个拓扑图，假设入度为 0 的点的数量为 $din$，出度为 0 的点的数量为 $dout$ ，那么最少需要加入 $max(din, dout)$ 条边就能变成强连通图，正如下图所示

无向图的双连通分量（DCC）

双连通分量分为点双连通分量（v-DCC）和边双连通分量（e-DCC）

无向图的边双连通分量的作用：将无向图的边双连通分量进行缩点，进而转化成一棵树

概念

桥：桥为无向图中的一类特殊的边，删除这条边之后，图不再连通，我们称这样的边为桥

边双连通分量：极大的不含有桥的连通块就称这个连通块为边连通分量，换句话说，这样的图里面任意两点之间都有两条不相交的路径（点可以相交）

割点：如果在图中把某个点以及它相关的边删掉，整个图不连通了，就称这个点为这个图的一个割点

点双连通分量：极大的不包含割点的连通块，我们称为点双连通分量

每个割点至少属于两个连通分量

两个割点之间的边不一定是桥，一个桥之间的两个端点也不一定是割点，割点和桥之间并没有什么关系

点双连通分量不一定是边双连通分量，边双连通分量不一定是点双连通分量

求解

边双连通分量

求解边双连通分量事实上和求有向图的强连通分量思路差不多，要注意的两点就是找桥和由于链式前向星的建图特性，我们不能通过建立的反向边往上遍历，或者说更新 $low[u]$ ，因为本质上这是一条边。

如何找桥？当遍历到某个，然后我们不能回到这个点的父亲结点的时候，说明这两个点连接的边是桥，从父亲角度来说，也就是 $low[u] < low[v]$ 的时候，当前这条边是桥

如果判断反向边？如果之前遍历的边的下标为 $from$，那么这里就不能通过 $from \oplus 1$ 来遍历或者说更新 $low[u]$

注意：由于无向图中不会存在横叉边，所以 in_stk 数组本质上是可以省略的

代码如下：

int h[N], e[M << 1], ne[M << 1], idx = 0;
int n, m;
vector<pair<int, int>> bridge;
int d[N];
int dfn[N], low[N], timestamp = 0;
int stk[N], tt = 0;
int id[N], dcc_cnt = 0;

void tarjan(int u, int from) {
    dfn[u] = low[u] = ++ timestamp;
    stk[tt ++ ] = u;
    
    for (int i = h[u]; ~i; i = ne[i]) {
        int v = e[i];
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[u] < low[v]) {
                bridge.push_back({u, v});
                // 这里可以把图保存下来，也可以标记边
            }
        } else if (i != (from ^ 1)) low[u] = min(low[u], dfn[v]);
    }
    
    if (dfn[u] == low[u]) {
        ++ dcc_cnt;
        int y;
        do {
            y = stk[-- tt];
            id[y] = dcc_cnt;
        } while (y != u);
    }
}

注意：在使用 from^1 != i 判断的时候一定要保证同时建立双向边

点双连通分量

求割点

对于一条边 $(x,y)$ ，有 $dfn[x] < dfn[y]$ ，对于 $low[y] \ge dfn[x]$，有

如果 $x$ 不是根节点，那么 $x$ 是割点
如果 $x$ 是根节点，至少有两个子结点 $y_i$ 使得 $low[y_i] \ge dfn[x]$

代码如下：

/*
遍历注意设置全局根节点
for (root = 0; root < n; root ++ )
    if (!dfn[root]) 
        tarjan(root);
*/
int n, m, root;
int h[N], e[M], ne[M], idx = 0;
int dfn[N], low[N], timestamp = 0;
vector<int> point; // 存放割点

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void tarjan(int u) {
    dfn[u] = low[u] = ++ timestamp;
    
    int cnt = 0;
    for (int i = h[u]; ~i; i = ne[i]) {
        int v = e[i];
        if (!dfn[v]) {
            tarjan(v);
            if (dfn[u] <= low[v]) cnt ++ ;
            low[u] = min(low[u], low[v]);
        } else low[u] = min(low[u], dfn[v]);
    }
    if (cnt + (root != u) > 1) point.push_back(u)// u 是割点
}

求点双连通分量

点双连通分量的缩点方案是：1. 割点单独作为一个点。 2. 从每个 V-DCC 向其所包含的每个割点连边对其进行缩点之后，图中点的数量等于所有连通分量的数量+割点的数量

注意：求点连通分量是要把割点存进去的，一个割点可能在多个不同的连通分量中。

代码如下：

/* 预处理
        for (int i = 1; i <= dcc_cnt; i ++ ) dcc[i].clear();
        memset(dfn, 0, sizeof dfn);
        memset(h, -1, sizeof h);
        memset(cut, 0, sizeof cut);
        dcc_cnt = timestamp = tt = idx = 0;
*/  
/* 求点双连通分量
        for (root = 1; root <= n; root ++ )
            if (!dfn[root])
                tarjan(root);
*/                
/* 求每个点双连通分量里面有多少个割点
        for (int i = 1; i <= dcc_cnt; i ++ ) {
            int cnt = 0;
            for (auto &u: dcc[i])
                if (cut[u]) cnt ++ ;
        }
*/
int root;
int h[N], e[N], ne[N], idx = 0;
int dfn[N], low[N], timestamp;
vector<int> dcc[N];
int dcc_cnt;
int stk[N], tt = 0;
bool cut[N];

void tarjan(int u) {
    
    dfn[u] = low[u] = ++ timestamp;
    stk[tt ++ ] = u;
    
    if (root == u && h[u] == -1) {
        
        ++ dcc_cnt;
        dcc[dcc_cnt].push_back(u);
        return ;
    }
    int cnt = 0;
    for (int i = h[u]; ~i; i = ne[i]) {
        int v = e[i];
        if (!dfn[v]) {
            tarjan(v);
            low[u] = min(low[v], low[u]);
            if (dfn[u] <= low[v]) {
                cnt ++ ;
                if (root != u || cnt > 1) cut[u] = true;
                ++ dcc_cnt;
                int y;
                do {
                    y = stk[-- tt];
                    dcc[dcc_cnt].push_back(y);
                } while (y != v);
                dcc[dcc_cnt].push_back(u);
            } 
        } else low[u] = min(low[u], dfn[v]);
    }
}

组合数学

Tue, 09 Apr 2024 00:00:00 GMT

基础

排列

从 $n$ 个不同的物品中不重复地取出 $r$ 个，排列数 $P_n^r = n!/(n-r)!$
从 $n$ 个不同的物品中可重复地取出 $r$ 个，排列数为 $n^r$
圆排列的排列数：从 $n$ 个元素中选 $r$ 个的圆排列的排列数为 $\frac{P_n^r}{r}=\frac{n!}{r(n-r)!}$
$S$ 是一个多重集，有 $k$ 个不同的元素，每个元素都有无穷重复个数，那么 $S$ 的 $r$ 排列个数为 $k^r$
$S$ 是一个多重集，有 $k$ 个不同的元素，每个元素的重数分别为 $n_1,\cdots,n_k$，$n=n_1+n_2+\cdots+n_k$，则 $S$ 的 $n$ 排列的个数为 $\frac{n!}{n_1!n_2! \cdots n_k!}$

组合

从 $n$ 个不同物品中选 $r$ 个元素的组合为 $C_n^r$
$S$ 是一个多重集，有 $k$ 个不同的元素，每个元素都有无穷个，$S$ 的 $r$ 组合的个数为 $C_{r+k-1}^{k-1}$ 可以不定方程隔板法证明

求组合数

利用公式 $C_a^b = C_{a-1}^b + C_{a - 1}^{b-1}$ 数据范围 $a,b \le 2000$ 左右代码如下

void init() {
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j <= i; j ++ ) {
            if (!j) C[i][j] = 1;
            else C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
        }
}

利用公式 $C_a^b = \frac{a!}{b!(a-b)!}$ ，因此可以预处理阶乘和取除法的模所需逆元数据范围大概在 $10^5$ 左右注意：模数得是素数代码如下：

/*
使用：C_a^b = fact[a] * inv[b] * inv[a - b]
*/
int fact[N];
int inv[N];

int kpow(int a, int k, int m) {
    int res = 1;
    while (k) {
        if (k & 1) res = 1ll * res * a % m;
        k >>= 1;
        a = 1ll * a * a % m;
    }
    return res;
}

void init() {
    inv[0] = fact[0] = 1;
    for (int i = 1; i < N; i ++ )
        fact[i] = 1ll * fact[i - 1] * i % MOD, inv[i] = kpow(fact[i], MOD - 2, MOD);
}

Lucas 定理，$p$ 为素数，使用限制 $a \ge p$ 时间复杂度 $O(n)$ $$ C_a^b \equiv C_{a \ mod \ p} ^ {b \ mod \ p} * C_{a / p} ^ {b / p} (mod \ p) $$ 可以证明：先将 a, b 分别写成 p 进制 $$ a = a_0 + a_1p + a_2p^2 + \cdots + a_kp^k $$

$$ b = b_0 + b_1p + b_2p^2 + \cdots + b_kp^k $$ 由于 $(1+x)^p=1 + C_p^1x + C_p^2x^2 + \cdots + C_p^px^p$，而 p 又是质数，因此 $(1+x)^p \equiv 1 + x^p (mod \ p)$ 同理，也可知 $(1+x)^{p^k} \equiv 1 + x^{p^k} (mod \ p)$ ，其中 $k \ge 1$ 可以利用生成函数证明，由于 $$ (1 + x)^a = (1+x)^{a_0 + a_1p + a_2p^2 + \cdots + a_kp^k} = (1 + x)^{a_0}((1+x)^p)^{a_1} \cdots ((1+x)^{p^k})^{a_k} $$ 故 $$ (1 + x)^a \equiv (1+x)^{a_0}(1+x^p)^{a_1}\cdots (1+x^{p^k})^{a_k} (mod \ p) $$ 左边关于 $x^b$ 的系数为 $C_a^b$ ，右边关于 $x_b$ 即 $x^{b_0 + b_1p + b_2p^2 + \cdots + b_kp^k}$ 为 $$ C_{a_0}^{b_0}C_{a_1}^{b_1}\cdots C_{a_k}^{b_k} $$ 由于 $b \ mod \ p = b_0, a \ mod \ p = a_0$ ，故 $C_{a_0}^{b_0} = C_{a \ mod \ p} ^ {b \ mod \ p}$ 又 $a / p = a_1 + a_2p^1 + \cdots + a_kp^{k-1}$，$b / p = b_1 + b_2p^1 + \cdots + b_kp^{k-1}$ 由上述求解 $C_a^b$ 的过程同理可得 $C_{a / p}^{b / p} = C_{a_1}^{b_1}\cdots C_{a_k}^{b_k}$ 因此原命题得证

计算利用lucas计算组合数步骤：（1）线性筛；（2）lucas递归计算；（3）利用质因数的指数求$C_a^b$，其中 $a,b<p$ ，特判 $a<b$ 时组合数为 0，求质因数的指数使用阶乘的质因数分解

高精度算 $C_a^b$ ，所需知识点：[[数论&线性代数#阶乘质因数分解]] ；然后利用高精度算乘法时间复杂度 $n \le 30000$ ，差不多是比较极限代码如下：

int h[N];
int p[N], cnt = 0;
bool st[N];
// 欧拉筛
void get_euler(int n) {
    
    for (int i = 2; i <= n; i ++ ) {
        if (!st[i]) p[cnt ++ ] = i;
        for (int j = 0; i <= n / p[j]; j ++ ) {
            st[i * p[j]] = true;
            if (i % p[j] == 0) break;
        }
    }
}
// 阶乘质因数分解
void divide(int n, int type) {
    
    for (int i = 0; p[i] <= n; i ++ ) {
        int sum = 0;
        for (int j = n / p[i]; j; j /= p[i]) sum += j;
        h[p[i]] += type * sum;
    }
} 

vector<int> mul(vector<int> &a, int b) {
    vector<int> c;
    for (int i = 0, t = 0; t || i < a.size(); i ++ ) {
        if (i < a.size()) t += b * a[i];
        c.push_back(t % 10);
        t /= 10;
    }
    return c;
}

组合计数

递推法，也就是dp状态设计
隔板法经典应用 $x_1+x_2+\cdots+x_k = n$ 有多少组正整数解，其中的等式可以变成不等式，然后如果 $x_i \ge 0$ ，则可以利用 $y_i=x_i+1,\sum{y_i}=n+k$ 的映射来计算
抽屉法通常和整数求余进行结合，把余数用抽屉来处理
特殊数列，卡特兰数

容斥原理

容斥原理计算公式：

集合 $S$ 中不具有性质 $P_1,P_2,\cdots,P_n$ 的对象个数为 $$ |\overline{A_1} \cap \overline{A_2} \cap \cdots \cap \overline{A_n}|=|S|-\sum|\overline{A_i}| + \sum|\overline{A_i}\cap \overline{A_j}| + \cdots + (-1)^n|\overline{A_1}\cap \cdots \overline{A_n}| $$
集合 $S$ 中至少具有性质 $P_1,P_2,\cdots,P_n$ 之一的对象个数为 $$ |A_1\cup A_2 \cup \cdots \cup A_n| = \sum|A_i| - \sum|A_i \cap A_j| + \cdots (-1)^{n+1}|A_1\cap A_2 \cap \cdots A_n| $$

卡特兰数 Catalan 数

Catalan 数是一个数列，定义为 $C_n = \frac{1}{n+1}C_{2n}^n$ 卡特兰数：$1,1,2,5,14,42,132,429,1430,4862,16796$

计算公式

$C_n=\frac{1}{n+1}C_{2n}^n = C_{2n}^n - C_{2n}^{n+1}$ 该计算公式从一个基本模型中推导：把 $n$ 个 $1$ 和 $n$ 个 $0$ 排成一行，使得这一行的任意前 $k$ 个数中的 $1$ 的数量总是大于等于 $0$ 的数量
递推 $C_n=C_0C_{n-1}+C_1C_{n-2}+\cdots+C_{n-1}C_0$ ，$C_0=1$
$C_n = \frac{4n-2}{n+1}C_{n-1}, C_0=1$ 当 $n\le 500$ 时，可以使用公式 $2$，比较大就需要 $1，3$ 公式

应用

棋盘问题
括号问题
出栈序列问题
二叉树问题
三角剖分问题有 $n+1$ 条边的凸多边形区域，在内部插入不相交的对角线，把凸多边形划分为多个三角形

二叉树问题

$n$ 个点形成的所有二叉树共有多少叶子数量？ 解答：对于每棵有 $n$ 结点，有 $g(n)$ 个叶子的二叉树，将其叶子删掉，将会得到 $g(n)$ 个 $n-1$ 结点的二叉树。而一个 $n - 1$ 结点的二叉树有 $n$ 个位置可以插入叶子，因此每棵 $n-1$ 结点的树被得到了 $n$ 次，因此 $f(n-1)n=g(n) = C_{2n-2}^{n-1}$

博弈论

Nim 游戏

Nim 游戏：当一堆石子的数量异或值为 0 时，则为必败态，也即异或值不为 0 时，为必胜态

证明：前置：必胜态转移的必败态只需要某种取法能转移到必败态即可，而必胜态转移到必败态需要无论此时如何操作，下一步转移一定是必败态

1、首先证明，必胜态一定存在一种方式能转移为必败态设一堆石子的数量为 $a_1, a_2, \cdots, a_n$，由必胜态可知， $a_1 \oplus a_2 \oplus \cdots \oplus a_n = k \neq 0$, 因此$k$ 一定有高位 1 在第 $bit$ 位，那么一定存在 $a_i$ 的 $bit$ 位为 1。可以证明，若 {$a_i$} 中不存在 $bit$ 为 1，那么这些数异或的值 $k$ 的 $bit$ 位也一定不为 1，矛盾。

因此，我们可以将 $a_i^{\prime} = a_i \oplus k$ ，由于 $k$ 的 $bit$ 位以上的位数为 $0$，因此，$a_i^\prime < a_i$ ，即在第 $i$ 堆取走 $a_i - a_i^\prime$ 个石子，那么此时所有石子数量异或值为 $a_1 \oplus a_2 \oplus \cdots a_i^{\prime} \cdots \oplus a_n = a_1 \oplus a_2 \oplus \cdots a_i\oplus k \cdots \oplus a_n = k \oplus k = 0$，这样就由必胜态转移为必败态

2、然后证明，必败态无论如何操作都会转移为必胜态，即证，无论从哪堆石子拿石子，一定会使得其异或值不为 0

反证法：假设在 $a_i$ 中拿 $a_i - a_i^{\prime} \gt 0$ 个石子，有 $a_1 \oplus a_2 \oplus \cdots a_i^{\prime} \cdots \oplus a_n = k^{\prime} = 0$ 那么 $k \oplus k^{\prime} = a_i \oplus a_i^{\prime} = 0$，也就是说 $a_i = a_i^{\prime}$，这与假设不符，因此这样就相当于没有拿石子，矛盾。

证毕

概念

公平组合游戏

若一个游戏满足：

由两名玩家交替行动；
在游戏进程的任意时刻，可以执行的合法行动与轮到哪名玩家无关；
不能行动的玩家判负；则称该游戏为一个公平组合游戏。 NIM博弈属于公平组合游戏，但城建的棋类游戏，比如围棋，就不是公平组合游戏。因为围棋交战双方分别只能落黑子和白子，胜负判定也比较复杂，不满足条件2和条件3。

有向图游戏

给定一个有向无环图，图中有一个唯一的起点，在起点上放有一枚棋子。两名玩家交替地把这枚棋子沿有向边进行移动，每次可以移动一步，无法移动者判负。该游戏被称为有向图游戏。 任何一个公平组合游戏都可以转化为有向图游戏。具体方法是，把每个局面看成图中的一个节点，并且从每个局面向沿着合法行动能够到达的下一个局面连有向边。

Mex 运算

设S表示一个非负整数集合。定义$mex(S)$为求出不属于集合S的最小非负整数的运算，即： $mex(S) = min{x}$, $x$属于自然数，且$x$不属于$S$ 比如：$mex({0,1,2,4,5})=3, mex({1,4,5,6})=0$

SG 函数

在有向图游戏中，对于每个节点$x$，设从$x$出发共有$k$条有向边，分别到达节点$y_1, y_2, …, y_k$，定义$SG(x)$为$x$的后继节点$y_1, y_2, …, y_k$ 的$SG$函数值构成的集合再执行$mex(S)$运算的结果，即： $$SG(x) = mex({SG(y_1), SG(y_2), …, SG(y_k)})$$ 特别地，整个有向图游戏$G$的$SG$函数值被定义为有向图游戏起点$s$的$SG$函数值，即$SG(G) = SG(s)$。

有向图游戏的和

设$G_1, G_2, …, G_m$ 是$m$个有向图游戏。定义有向图游戏$G$，它的行动规则是任选某个有向图游戏$Gi$，并在$Gi$上行动一步。$G$被称为有向图游戏$G_1, G_2, …, G_m$的和。有向图游戏的和的$SG$函数值等于它包含的各个子游戏$SG$函数值的异或和，即： $$SG(G) = SG(G_1) \oplus SG(G_2) \oplus … \oplus SG(G_m)$$

定理

有向图游戏的某个局面必胜，当且仅当该局面对应结点的$SG$函数值大于0
有向图游戏的某个局面必败，当且仅当该局面对应结点的$SG$函数值等于0

二分图

Fri, 05 Apr 2024 00:00:00 GMT

判断二分图

一个图是二分图当且仅当这个图可以被2-染色，也就是图中不含奇数环

时间复杂度：$O(n)$

特点：无向图，图中可能存在重边和自环。

算法流程：

从前往后遍历每个结点，如果有结点未染色，则对其进行 dfs 判断 1.1 如果dfs判断其有奇数环，则说明该图不是二分图 dfs部分：参数：当前结点，当前结点颜色
1. 遍历与当前结点相连的结点 1.1 如果未被染色，则对其进行dfs染色，如果对其染色后存在奇数环，返回false 1.2 如果进行了然后，则判断当前结点和相连的结点的颜色是否一致，如果是则说明存在奇数环，返回false 1.3 如果上述情况都没有返回false，则返回true 代码如下：

int h[N], e[N << 1], ne[N << 1], idx = 0;
int st[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

// dfs 判断
bool dfs(int u, int c) {
    
    st[u] = c;
    for (int i = h[u]; ~i; i = ne[i]) {
        int v = e[i];
        if (!st[v]) {
            if (!dfs(v, 3 - c)) return false;
        } else if (st[v] == st[u]) return false;
    }
    return true;
}
// 有可能这个图不连通，所以需要每个都遍历
bool flag = true;
for (int i = 1; i <= n; i ++ )
    if (!st[i] && !dfs(i, 1)) {
        flag = false;
        break;
    }

二分图最大匹配

匈牙利算法

时间复杂度：$O(nm)$

特点：二分图，其中左半部包含 $n_1$个点（编号 1∼$n_1$），右半部包含 $n_2$ 个点（编号 1∼$n_2$），二分图共包含 $m$ 条边。

交替路：未匹配边$\rightarrow$匹配边$\rightarrow \cdots$ $\rightarrow$ 未匹配边这样的交替路径 增广路径：交替路的两端端点是未匹配点

二分图的最大匹配等价于当前匹配无增广路径

因此，我们的算法策略就是不断地寻找增广路径，算法流程如下：

对于某个未匹配的点$v$来说，遍历其所有相邻点 $v$ 1.1 如果这个点没有被遍历过 2.1 如果这个点没有被匹配，则 $match[v] = u$，返回true 2.2 如果这个点有被匹配，那么继续去判断 $match[v]$ 开始的增广路径，如果找到了，也是将 $match[v] = u$ ，返回true
如果上述操作未能找到增广路径，则返回 false

注意：

在寻找增广路径的过程中，点遍历过了设置为 true，是否对后续没影响？是的，首先在寻找的过程中不应该找遍历过的点，然后如果当前点确实没找到增广路径，说明此处的匹配只能如此匹配，因此后边再遍历它也没有效果
找每个点的匹配时，要注意初始化 st 访问状态

代码如下：

const int N = 100010;

int h[N], e[N], ne[N], idx = 0;
int match[N];
bool st[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

bool find(int u) {
    
    for (int i = h[u]; ~i; i = ne[i]) {
        int v = e[i];
        if (!st[v]) {
            st[v] = true;
            if (!match[v] || find(match[v])) {
                match[v] = u;
                return true;
            }
        }
    }
    return false;
}

/*
寻找最大匹配
int res = 0;
for (int i = 1; i <= n1; i ++ ) {
    memset(st, false, sizeof st);
    if (find(i)) res ++ ;
}
/*

二分图匹配的必须边和可行边

完备匹配

完备匹配指的是二分图里的任意一个顶点都是匹配边相关联

那么，在完备匹配中，一条边 $(x,y)$ 是必须边，当且仅当同时满足以下条件：

在当前这个完备匹配下，$(x,y)$ 是匹配边
在当前这个完备匹配下，去掉 $(x,y)$ 这条边之后，不能再找一条增广路，其起点是 $x$，终点是 $y$

因此，对于完备匹配求必须边有个暴力的做法，就是先求一遍匈牙利算法得到完备匹配，然后枚举每一个匹配，将其删掉，再做一次求增广路，看是否能找到一条增广路，找不到说明这条边是必须边

在完备匹配中，一条边 $(x,y)$ 是可行边，当且仅当满足以下两个条件之一：

$(x,y)$当前是匹配边
$(x,y)$ 是非匹配边，设当前 $x$ 与 $u$ 匹配， $y$ 与 $v$ 匹配，连接边 $(x,y)$ 后，结点 $u,v$ 失配，因此必须找到一条从 $u$ 到 $v$ 的增广路，来保证最大匹配不变

那么，在一个完备匹配中判定所有的必须边和可行边有一个通用算法：

构造新的有向图：把非匹配边看作左部到右部的有向边，匹配边看作从右部到左部的有向边来构造新图。
求新图的强连通分量
$(x,y)$ 是原图的必须边，说明 $x,y$ 当前是匹配边，并且 $x,y$ 在新图中属于不同的强连通分量
$(x,y)$ 是原图的可行边，$(x,y)$ 当前匹配边或者 $x,y$ 两点在新图中属于相同的强连通分量

一般最大匹配

那么，事与愿违，一般情况下，二分图的最大匹配大多是非完备匹配，那么这种情况下就需要借助 [[网络流]]

若 $z$ 是当前右部非匹配点，$(u,v)$ 是匹配边，则 $(z,T)$ 的容量为 $1$，$(v,T)$ 的反向边的容量一定是 $1$。因此，如果二分图中 $u$ 到 $z$ 有增广路，那么其残留网络上 $u$ 能到达 $z$ ，进而到达 $v$，即 $(u,v)$ 在一个强连通分量当中

因此，必须边的判定条件：$(x,y)$ 流量为 $1$，并且 $x, y$ 两点在残留网络中属于不同的强连通分量可行边的判定条件：$(x,y)$ 流量为 $1$，或者 $x,y$ 两点才残留网络中属于相同的强连通分量

最小点覆盖、最大独立集、最小路径点覆盖（最小路径重复点覆盖）

最大匹配数=最小点覆盖=总点数-最大独立集=总点数-最小路径覆盖

最小点覆盖

最小点覆盖：给你一个任意图，从中选出最少的点，使得每条边至少有一个端点是被选出来的。

![[]] 这里要加图

在二分图中，最小点覆盖是等于最大匹配数的

证明：设 $A$ 为最小点覆盖，$B$ 为最大匹配数，因此等价于证明 $A=B$ 先证明 $A \ge B$ 由于二分图中最大匹配数里面的边都是没有交点的，因此要想覆盖所有边，必然匹配里面所有点都至少要选上，因此 $A \ge B$

然后证明这个等号是可以成立的，通过构造方案来证明

求最大匹配
从左部每个非匹配点出发，做一遍增广标记所有经过的点左部所有未被标记的点 + 右部所有被标记的点就是一个最小点覆盖方案首先证明这个和是为最大匹配数，假设为 $m$
左部所有非匹配点一定被标记
右部所有非匹配点一定未被标记（否则为增广路，与最大匹配矛盾）、
对于匹配边，左右两点要么同时标记要么同时不被标记根据这三个性质，左部所有未被标记的点一定是匹配点，右部所有被标记的点也一定是匹配点，右部的匹配点可以分为有标记的和未被标记的，再根据第三条性质，选择点的数量一定是最大匹配数，同时也证明了匹配边一定被这些点覆盖。剩下的就是要证明
左部非匹配点 ---- 右部匹配点连接的边是否被覆盖
左部匹配点 ---- 右部非匹配点连接的边是否被覆盖
左部非匹配点 ---- 右部非匹配点连接的边是否被覆盖第三种情况与最大匹配数矛盾，因此不存在这种情况。第一种情况，由于我们是从左部非匹配点出发，那么和右部匹配点连接的边一定是被标记的，而由于我们选择了右部所有被标记的点，因此这样的边能被覆盖。第二种情况，由于又不非匹配点一定是未被标记的，因此其连接的左部匹配点一定也未被标记，因为标记的过程从未匹配点出发，最后也能够到非匹配点，这样的话会有增广路径，这与最大匹配不符。因此，这样的左部匹配点一定是未被标记的，由于左部选择的是未被标记的匹配点，因此，这样的边也能覆盖。

综上：二分图中，最小点覆盖=最大匹配数。

最大独立集

最大独立集：从一个任意图中，选出最多的点，使得选出的点之间没有边最大团：从一个任意图中，选出最多的点，任意两点之间都有边补图：在图论中，一个图的补图是一个图跟图 $G$ 有相同的点，而且这些点之间有边相连当且仅当在 $G$ 里面他们没有边相连。因此，独立集的补图就是团

在二分图中，求最大独立集$\iff$ 去掉最少的点将所有边都破坏掉 $\iff$ 找最小点覆盖 $\iff$ 找最大匹配数

最小路径点覆盖

最小路径点覆盖：简称最小路径覆盖，针对有向无环图来说，用最少的互不相交的路径（路径里点不重复）将所有点覆盖，求最少路径数

思路：拆点假设原图中有 $1-n$个点，设置 $1^\prime - n^\prime$ 个新点，$(i,j)$ 的边变成$(i, j^\prime)$，这样整个图就变成了一个二分图。最后，原图最小路径覆盖就是 $n - m$，其中 $m$ 为新图的最大匹配数。

证明首先来看在原图中的每条路径，转化到新图中是怎么样子的，比如：$a->b->c$ 。由于在一个路径点覆盖的方案当中，每个点都只出现一次，然后一定每个点都出现，因此，路径上的每个点在新图中每个点最多一个入度和一个出度。对于只有出度没有入度的点，说明是路径起点；只有入度没有出度的点，说明是路径终点，因此下面的等价关系正确。

原图中的路径 $\iff$ 新图匹配边
原图中的路径终点 $\iff$ 新图左部非匹配点因此，求最少路径数也可以说是求最少路径终点数 $\iff$ 求最少左部非匹配点数 $\iff$ 求左部最大匹配点数 $\iff$ 找最大匹配数

最小路径重复点覆盖

如果在最小路径点覆盖的基础上放开限制，也即是说点和边是可以相交的，那么将所有点覆盖的路径数是多少？

思路：

求传递闭包 $G^\prime$
在 $G^\prime$ 上求最小路径覆盖证明思路就是两个集合是等价的，或者说可以转化原图所有的最小路径重复点覆盖集合 $\iff$ 新图所有最小路径点覆盖集合

对于任意的最小路径重复点覆盖集合，这样的集合一定是多条路径组合成，第一条路径不考虑，如果第 $i(i>1)$ 条路径上有之前重复的点，我们就将其跳过，如果是起点重复，起点就不考虑，不可能有一条路径所有点都被遍历过，否则这条路径有不有都无所谓，也不满足最小的限制。因此，对于原图中的任意最小路径重复点覆盖集合，都可以变成新图中最小路径覆盖集合。

而对于新图中所有最小路径点覆盖集合，也一定是有多条路径存在，那么可以查看路径中每条边，如果这条边在原图中并不存在，则还原成原图中的路径即可，因为是传递闭包，一定至少有一条路径，由于新图的最小路径点覆盖集合本质上已经覆盖了所有点，因此，对于还原的新边也只会出现重复出现的点，从而是满足要求的。

应用

DAG 上的一个点集，任意两点之间无路径，求这个点集最多的点的数量

生成树模型

Fri, 05 Apr 2024 00:00:00 GMT

prim 算法

时间复杂度：$O(n^2)$

特点：无向图，图中可能存在重边和自环，边权可能为负数。

假设已选择的点在集合 $V_1$，尚未选择的点在集合 $V_2$ 算法流程：

从 $V_2$ 中任意选择一个点 $v$，放入 $V_1$ ，然后更新集合 $V_1$ 到集合 $V_2$ 里面所有点的最小距离 $d$
然后依然从 $V_2$ 中选择点，但此时是选择 $d$ 值最小的点 2.1 如果这个时候选择的点的 $d$ 值是无穷大，说明没有最小生成树 2.2 如果没有 step 2.1，则将当前点放入 $V_1$，然后更新权值 cnt 2.3 更新集合 $V_1$ 到集合 $V_2$ 里面所有点的最小距离 $d$
重复 step 2 共 $n - 1$ 次

代码如下：

/*
存图：邻接矩阵
    while (m -- ) {
        int x, y, z; cin >> x >> y >> z;
        g[x][y] = g[y][x] = min(g[x][y], z);
    }
*/

const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int g[N][N], d[N]; // d 数组表示 V1 到 V2 所有点的最小值 
bool st[N]; // st 用来区别 V1:true 和 V2:false 集合

int prim() {
    
    memset(d, 0x3f, sizeof d);
    d[1] = 0; // 这里可以强行选择初始点 1，d[1] = 0 对答案累加也没有影响

    int cnt = 0;
    for (int i = 0; i < n; i ++ ) {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || d[j] < d[t])) t = j;
        
        // 如果选择的点没有跟集合 V1 的点直接相连，则说明没有最小生成树
        if (d[t] == INF) return INF;
        
        cnt += d[t];
        st[t] = true;
        
        for (int j = 1; j <= n; j ++ )
            d[j] = min(d[j], g[t][j]);
    }
    return cnt;
}

kruskal 算法

时间复杂度：$O(mlogm)$

特点：无向图，图中可能存在重边和自环，边权可能为负数。

图的存储：结构体存边，按照权值可比较

算法流程：

对边从小到大进行排序
然后从前往后遍历每条边 2.1 如果两点在一个集合，则跳过这条边 2.2 否则，加入这条边，然后把两个点的集合存到一起
最后判断并查集是否只有一个根，是则最后计算的权值是正确的，否则说明无最小生成树

代码如下：


const int N = 200010, INF = 0x3f3f3f3f;

struct edge {
    int from, to, w;
    bool operator < (const edge& a) const {
        return w < a.w;
    }
} g[N];
int n, m;
int fa[N];

// 并查集
int get(int x) {
    if (fa[x] != x) fa[x] = get(fa[x]);
    return fa[x];
}

int kruskal() {
    sort(g, g + m); 
    for (int i = 1; i <= n; i ++ ) fa[i] = i;
    
    int res = 0;
    for (int i = 0; i < m; i ++ ) {
        int a = get(g[i].from), b = get(g[i].to);
        if (a == b) continue;
        res += g[i].w;
        fa[a] = b;
    }
    
    int cnt = 0;
    for (int i = 1; i <= n; i ++ ) cnt += fa[i] == i;
    
    return cnt > 1 ? INF : res;
}

次小生成树

定理

对于一个无向图，如果存在最小生成树和（严格）次小生成树，那么对于任意一棵最小生成树，都存在一棵（严格）次小生成树，使得这两棵树只有一条边不同

那么根据这里定理，假设已经利用 kruskal 算法求出最小生成树的所有边集，那么严格次小生成树一定是有一条边与最小生成树的一条边不同，因此，我们可以从未选择的边从小到大枚举，如果将生成树的某条边替换成这条边能得到的权值是最小的，那么便是次小生成树。

在考虑每一条未选择的边的时候，如果把这条边加上，一定是会形成一个环，因此，我们需要考虑从这个环上面寻找一条最大且不等于这条添加的边的权值的边将其删掉，这样得到的树才可能是次小生成树。

在这里面，问题转化成立寻找一个环里面最大值和次大值，

求一个环里面的最大值和次大值有两个方案：

让任意一个点作根，记录这个点到其任意孩子的最大值和次大值，从而假设未选择的边是 $(a,b)$ , 那么最小生成树一定有一条路径 $(a,b)$ ，因此从 $a$ 为根节点到 $b$ 的最大值和次大值能预处理出来，然后在枚举每一条未选择的边的时候进行计算。
利用 lca 进行计算，假设树根已经确定好了，那么 $(a,b)$ 一定有公共祖先，那么公共祖先到 $a$ 或者 $b$ 的最小值和次小值可以预处理，进而，$a$ 到 $b$ 的最小值和次小值可以计算

生成树的个数

矩阵树定理

构建拉普拉斯矩阵 $C$，计算是通过图的度对角矩阵减去图的邻接矩阵
拉普拉斯矩阵任意一个主子式的行列式值都等于生成树的数量

最小生成树的个数

定理

最小生成树的权值以及相同权值的个数的边的数量是一致的
在每次处理完相同权值的边，无论这些权值相同的边怎么选择，最终此时图的连通块数量及其状态是一致的（意思是不仅连通块数量一样，而且连通块对应的点也是一样的）根据定理2，我们在每次处理完一类权值相同的边之后，都可能把这些连通块进行缩点（根据并查集），之后根据乘法原理求最小生成树的数量。注意：此做法要求相同权值的边的数量很少

矩阵树定理

如果相同权值的点太多，这题便需要用到矩阵树定理进行优化。根据定理2，当我们处理到某一类权值相同的边权的时候，这个时候的连通块数量是相同的，并且此时同样要处理权值相同的一类边，因此可以将其理解为求生成树的个数，这样就完美利用到了矩阵树定理。最后利用乘法原理计算答案即可。

最短路模型

Tue, 26 Mar 2024 00:00:00 GMT

单源最短路

朴素版 dijkstra

时间复杂度：$O(n^2)$ 限制：图中可能存在重边和自环，所有边权均为正值。应用：一般应用于点的数量不多，边的数量比较多，也就是稠密图 算法流程：

初始化 dist 数组，源点设置为 0
在所有的 dist 数组中找到一个没有更新过的点(!st[j])，且 dist 的值最小的下标 p，并设置 st[p]=true
遍历 p 的所有出度边，更新 dist 数组
重复 step 2 和 step 3 共 n - 1 次

代码如下：

/*
图的预处理
memset(g, 0x3f, sizeof g);
for (int i = 0; i < N; i ++ ) g[i][i] = 0;

读入边时的处理
g[u][v] = min(g[u][v], w);
*/

const int N = 510, INF = 0x3f3f3f3f;

int n, m; 
int g[N][N], dist[N];
bool st[N];

int dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    for (int i = 0; i < n; i ++ ) {
        int p = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (p == -1 || dist[p] > dist[j])) p = j;
        st[p] = true;
        
        for (int j = 1; j <= n; j ++ )
            if (dist[p] + g[p][j] < dist[j])
                dist[j] = dist[p] + g[p][j];
    }
    return dist[n] == INF ? -1 : dist[n];
}

堆优化的 dijkstra

时间复杂度：$O(mlogn)$ 限制：图中可能存在重边和自环，所有边权均为正值。应用：一般应用于稀疏图中算法流程：

同样地，初始化 dist 数组，源点设置为0，并且以 {dist值，点的下标} 放入小根堆中
从小根堆中取出堆顶，判断堆头的点是否已经遍历(st[id])，是则继续取出堆顶，否则将该点设置为 st[id]=true
遍历该点的所有边，如果满足三角不等式 dist[v] > dist[id]+w[i] 则更新 dist[v] 的值，然后将其压入堆中
重复 step 2 和 step 3，直到堆为空

代码如下：

/*
图的存储：链式前向星
注意初始化 h 数组为 -1
*/

const int N = 150010, INF = 0x3f3f3f3f;

typedef pair<int, int> PII;

int n, m;
int h[N], e[N], ne[N], w[N], idx = 0;
int dist[N];
bool st[N];

int dijkstra() {
    priority_queue<PII, vector<PII>, greater<PII>> Q;
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    Q.push({0, 1});
    
    while (Q.size()) {
        auto [val, id] = Q.top(); Q.pop();
        if (st[id]) continue;
        st[id] = true;
        
        for (int i = h[id]; ~i; i = ne[i]) {
            int v = e[i];
            if (dist[v] > dist[id] + w[i]) {
                dist[v] = dist[id] + w[i];
                Q.push({dist[v], v});
            }
        }
    }
    return dist[n] == INF ? -1 : dist[n];
}

bellman-ford 算法

时间复杂度：$O(nm)$ 特点：图中可能存在重边和自环， 边权可能为负数。图中可能 存在负权回路 。应用：最多走 $k$ 条边的最短路，判断回路中是负权回路算法流程：

初始化 d 数组为无穷大，然后源点的值设置为 0
遍历每条边，满足三角不等式 $d[from] + w < d[v]$ ，做一次松弛操作
重复 step 2 一共 $n - 1$ 次，如果边权没负数，则此时已求出最短路；如果边权有负数，再重复一遍 step 2，判断 d 数组有无变化，有则说明存在负权回路 注意：
如果是指明最多 k 条边的最短路，则松弛操作只能用上一轮的结果；还有松弛操作是用 d[y]=backup[x] + w 可能更新多次不会改变遍历多条边？不是，你只能让从上一轮到这一轮的答案更小，并不会多更新边
另外，如果是判断源点到某汇点是否有最短路，不能直接判断是否等于INF，而是用是否大于 INF / 2来判断
再注意，如果是有负权边，则没有最短路径不能返回 -1，因为 -1 可能是答案代码如下：

const int N = 10010;
const int INF = 0x3f3f3f3f;

int n, m, k;
struct Node {
    int a, b, w;
} g[N];
int d[N], backup[N];

int bellman_ford() {

    memset(d, 0x3f, sizeof d);
    d[1] = 0;
    for (int i = 0; i < k; i ++ ) {

        memcpy(backup, d, sizeof backup);
        for (int j = 0; j < m; j ++ ) {
            int x = g[j].a, y = g[j].b, w = g[j].w;
            if (d[y] > backup[x] + w)
                d[y] = backup[x] + w;
        }

    }
    if (d[n] > INF / 2) return -1;
    return d[n];
}

spfa 算法

最坏时间复杂度：$O(nm)$

特点：图中可能存在重边和自环， 边权可能为负数。图中可能 存在负权回路 。应用：判断回路中是否有负权回路

spfa 算法本质上是优化了 bellman-ford 算法，因为 bellman-ford 算法是每次暴力枚举所有的边然后无差别松弛，但是事实上只有更新过的点对其进行松弛才有意义。因此，spfa做得优化就是使用队列存储进行过松弛的点，然后利用这些点再进行更新。

注意：

st[i] 表示点 $i$ 是否在队列里面
然后使用的是循环队列，因为每个点可能不止入队，出队一次，但是里面最多是有 $n$ 个点，所以循环队列最优

代码如下：

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], w[N], q[N], d[N], idx, hh = 0, tt = 0;
bool st[N]; 

int spfa() {
    
    memset(d, 0x3f, sizeof d);
    d[1] = 0, q[0] = 1, st[1] = true;
    int hh = 0, tt = 1;
    
    while (hh != tt) {
        int t = q[hh ++ ];
        if (hh == N - 1) hh = 0;
        st[t] = false;
        
        for (int i = h[t]; ~i; i = ne[i]) {
            int v = e[i];
            if (d[t] + w[i] < d[v]) {
                d[v] = d[t] + w[i];
                if (!st[v]) {
                    q[tt ++ ] = v;
                    if (tt == N - 1) tt = 0;
                    st[v] = true;
                }
            }
        }
    }
    return d[n];
}

spfa 判断负环

判断负环重要的环节就是判断一个点被松弛的次数是否 $\ge n$，或者最短路里的边数 $\ge n$ ，因此在原来spfa算法的基础上，加入 cnt 数组来记录即可

注意：

如果只是判断负环，那么由于图可能不连通，所以初始化需要把所有点都加入到队列里面，然后每个点的 d 值都为 $0$，这个就好比加入了一个超级源点，然后超级源点连接了图中每一个点，且权值为 $0$
注意，d 数组在松弛的过程中不可不更新

int n, m; 
int h[N], e[N], ne[N], w[N], idx = 0;
int d[N], cnt[N], q[N], hh = 0, tt = 0;
bool st[N];

bool spfa() {
    
    for (int i = 1; i <= n; i ++ ) {
        st[i] = true;
        q[tt ++ ] = i;
    }
    
    while (hh != tt) {
        int u = q[hh ++ ];
        if (hh == N - 1) hh = 0;
        
        st[u] = false;
        for (int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];
            if (d[u] + w[i] < d[v]) {
                d[v] = d[u] + w[i];
                cnt[v] = cnt[u] + 1;
                if (cnt[v] >= n) return true;
                if (!st[v]) {
                    st[v] = true;
                    q[tt ++ ] = v;
                    if (tt == N - 1) tt = 0;
                }
            }
        }
    }
    return false;
}

spfa 找正环例题

spfa 找正环的广度比我想象的还要广：比如货币兑换，点的权值变化是 $x_j = (x_i - C_i )* R_i$ ，判断是否有正环。这得益于 spfa 只要松弛了就需要继续更新其他点。所以，彻底理解spfa的机制还是非常有价值的

0/1 分数规划

形如 $\frac{\sum{f_i}}{\sum{w_i}}$ 的式子的最大值或者最小值，可以使用 [[二分&三分#二分]] + [[#spfa 判断负环]] 来求解

对于这样的问题，我们统一使用 0/1 规划求解，首先二分答案为 $mid$，然后假设存在一个环 $\frac{\sum{f_i}}{\sum{w_i}} \gt mid$ ，那么其答案一定在 $[mid,r]$ 之间；如果对于任意的环，都使得 $\frac{\sum{f_i}}{\sum{w_i}} \lt mid$ ，那么答案肯定在 $[l,mid]$ 之间。

首先对于 $\frac{\sum{f_i}}{\sum{w_i}} \gt mid$，我们做一些转化 $$ \frac{\sum{f_i}}{\sum{w_i}} \gt mid \iff \sum (f_i - mid * w[i]) \gt 0 $$ 换句话说，判断一个环是否存在有 $\frac{\sum{f_i}}{\sum{w_i}} \gt mid$ 等价于判断对边权进行修改后的图是否存在有正环。

注意，为什么不用 $\frac{\sum{f_i}}{\sum{w_i}} \lt mid$ 做判断，其原因就在于我们要对于 任意的环，而我们没有判断任意环都是负环的做法。

因此，对于 $0/1$ 规划的问题，一定要从存在的前缀的不等式那边找环

多源最短路

Floyd 算法

时间复杂度：$O(n^3)$

特点：可以同时计算任意两点之间的最短距离。图中可能存在重边和自环，边权可能为负数。

floyd 算法的思路基于动态规划：$g(k,i,j)$ 表示只通过前 $k$ 个点进行松弛，点 $i$ 到点 $j$ 的最短路径。

转移：对于 $g(k,i,j)$ 来说，值从两种情况得到，一种是 $i$ 到 $j$ 的最短路径没有包含 $k$，一种是包含了 $k$。对于第一种情况，就是 $g(k-1,i,j)$，对于第二中情况，我们知道 $k$ 一定是 $i$ 到 $j$ 路径上的某个点，所以此时将路径 $(i,j)$ 分成 $(i,k),(k,j)$ 两部分，另外在这两部分里面都是没有包含 $k$ 的，最多是 $k-1$。因此，$g(k,i,j)=min(g(k-1,i,j),g(k-1,i,k)+g(k-1,k,j))$。

滚动数组：可以看到 $g(k,i,j)$ 的转移之和上一轮的结果有关，因此去掉一维就是 $g(i,j)=min(g(i,j),g(i,k)+g(k,j))$ ，由于 $g(k,i,k)=g(k-1,i,k),g(k,k,j)=g(k-1,k,j)$ 直接去掉一维是等价的

初始化：最开始的 $g$ 值表示没有松弛的时候，也就是原图初始的样子。

代码如下：

int g[N][N];

void Floyd() {
    
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}

//初始化
while (m -- ) {
    int x, y, z; cin >> x >> y >> z;
    g[x][y] = min(g[x][y], z);
}

// 判断结果
if (g[x][y] > 0x3f3f3f3f / 2) puts("impossible");
else cout << g[x][y] << endl;

传递闭包

传递闭包说到底就是值任意两个点的可达性，比如说 A 能到 B，B 能到 C，那么 A 就能到 C。可以使用 Floyd 求传递闭包

for (int k = 1; k <= n; k ++ )
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= n; j ++ )
			g[i][j] |= g[i][k] && g[k][j];

拓展假设 g[i][j] 表示 $i > j$ 的情形，如果根据传递闭包判断每个人的排名是否已经确定？？答：如果一个人的排名已经确定，小于这个人的人数+大于这个人的人数一定等于 n - 1

最小环问题

给定一张无向图，求图中一个至少包含 $3$ 个点的环，环上的节点不重复，并且环上的边的长度之和最小。

解答我们知道，所有至少有 $3$ 个点的环，一定有一个编号最大的点 $k$ ，然后我们可以枚举这个点附近的两个点 $i,j（i<k, j<k)$ ，那么 $(i,k)$ 和 $(k,j)$ 的长度我们是已知的，那么问题就变成要求 $(i,j)$ 之间的最短路且不经过 $\ge k$ 的点。

那么这就能联想 floyd 的动态规划表 $f(k,i,j)$ 求的是只考虑前 $k$ 个点 $(i,j)$ 的最短路，因此，求解最小环的长度便可以在求 floyd 的过程中求解出来。

那么如果是求解一条最小环呢，也就是一个最小环的方案，这个同样也可以在求的过程中，一旦求出当前最小的环，然后把方案求解出来。因此，我们只需要求解 $(i,j)$ 的最短路的方案即可。

在求 $(i,j)$ 的最短路方案的时候，不需要还原滚动数组，因为最短路还是满足一个三角不等式的 $d(i,j) \le d(i,k)+ d(k,j)$ 的，不妨假设 $pre(i,j)=k$，表示 $d(i,j)$ 是从中间点 $k$ 转移的，那么一定是有 $d(i,k)$ 和 $d(k,j)$ 的路径不重复的。因此，如果在当前有 $d(i,j)=d(i,k)+d(k,j)$，那么 $(i, ... ,k, ..., j)$ 是可行方案。

代码如下：

/*
数据结构和求路径函数
注意这里不能使用 f[i][j]==g[i][j] 来判断(i,j)中间是否有其他的点
int g[N][N], f[N][N], pre[N][N];
int path[N], cnt = 0;

void get_path(int i, int j) {
    if (!pre[i][j]) return ;
    
    get_path(i, pre[i][j]);
    path[cnt ++ ] = pre[i][j];
    get_path(pre[i][j], j);
}
*/

int res = INF;
for (int k = 1; k <= n; k ++ ) {
    
    if (k > 2) {
        for (int i = 1; i < k; i ++ )
            for (int j = i + 1; j < k; j ++ )
                if (1ll * f[i][j] + g[i][k] + g[k][j] < res) {
                    res = f[i][j] + g[i][k] + g[k][j];
                    cnt = 0;
                    path[cnt ++ ] = k; path[cnt ++ ] = i;
                    get_path(i, j);
                    path[cnt ++ ] = j;
                }
                
    }
    
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (f[i][k] + f[k][j] < f[i][j]) {
                pre[i][j] = k;
                f[i][j] = f[i][k] + f[k][j];
            }
    
}
if (res != INF) {
    for (int i = 0; i < cnt; i ++ ) cout << path[i] << ' ';
    cout << endl;
} else puts("No solution.");

两点之间恰好经过 $k$ 条边的最短路

这个稍微和 Floyd 有点不一样，因为状态的设置不一样。$f(k, i, j)$ 表示从 $i$ 走到 $j$ 恰好经过 $k$ 条边的最短路，假设我们已经计算好了 $f(a,i,j)$ 和 $f(b,i,j)$ ，怎么计算 $f(a+b, i,j)$ ?

那么根据集合进行划分，$i$ 走了 $a$ 条边到达的是 $k$，因此 $f(a+b, i,j) = min_{k\in [1,n]}{f(a,i,k)+f(b,k,j)}$

由于这个问题是可以重复经过一些点，因此 $f(a,i,k)$ 和 $f(b,k,j)$ 之间路径互不影响，而且根据公式来看这个式子具有结合律。因此，可以尝试使用矩阵快速幂来加速计算。

代码如下：

matrix mul(matrix a, matrix b) {
    matrix c;
    memset(c.m, 0x3f, sizeof c.m);
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                c.m[i][j] = min(1ll * c.m[i][j], 1ll * a.m[i][k] + b.m[k][j]);
    return c;
}
// 这里初始的res是任意两个点都不能到达，除了自己到自己最短路是 0
matrix kpow(matrix a, int k) {
    matrix res;
    memset(res.m, 0x3f, sizeof res.m);
    for (int i = 1; i <= n; i ++ ) res.m[i][i] = 0;
    while (k) {
        if (k & 1) res = mul(res, a);
        a = mul(a, a);
        k >>= 1;
    }
    return res;
}

单源最短路应用

乘积最大值

假如有一个图，边权 $0 <w \le 1$，然后求点 $A$ 到 $B$ 的权值最大乘积。为什么这个可以直接用变形的 dijkstra 求解？因为 $log(w_1\cdots w_k) = log(w_1)+\cdots+log(w_k)$ ，再加上 $w$ 的范围如此，所以 $log(w_i) \le 0$ ，这个问题就转化成了求 $\sum_{i=1}^klog(w_i)$ 的最大值，也就是 $-\sum_{i=1}^k-log(w_i)$ 的最大值，也就是 $\sum_{i=1}^k-log(w_i)$ 的最小值。由于 $-log(w_i) \ge 0$ ，这就等价于 dijkstra 算法流程。

如果是有 $w>1$ 情况咋办，可能就需要 spfa 来进行求解。

如果是有 $w \le 0$ 的情况，这个就暂时不清楚了

超级源点（虚拟点）

有些题可能需要超级源点连接所有的点（比如差分约束问题），有些题可能需要一个超级源点连接部分点（比如：多源最短路径问题）

求经过某个点的最小正环

首先从这个点出发，待到这个点更新了其他点，将这个点的最小距离更新为无穷大，因为一开始本质上是求从这个点到其他点的最短路，因此该操作也会求得经过这个点的最小正环

建反图

如果要求任意点到某个点的最短路，建立反图是不错的选择

差分约束

差分约束的作用有二

求某个特殊不等式组的一组可行解
求所有点最大值或最小值

求某个特殊不等式组的可行解

特殊不等式组：诸如 $x_i \le x_j + C_{ij}$ 或者 $x_i \ge x_j + C_{ij}$ 的不等式组我们可以将这样的不等式组转化成一个单源最短路问题，以 $x_i \le x_j + C_{ij}$ 为例：

对每个不等式 $x_i \le x_j + C_{ij}$，转化成一条 $x_j$ 到 $x_i$ 的边，权值为 $C_{ij}$ 的一条边
找一个超级源点，使得该源点一定可以遍历到所有边
从源点求一遍单源最短路
1. 结果1：如果存在负环，则不等式组无解
2. 结果2：如果没有负环，则从源点到每个点的最短路径就是一组可行解

正确性分析：

对于第一点，对于不等式 $x_i \le x_j + C_{ij}$，转化成边之后，根据最短路的结果一定有 $dist[x_i] \le dist[x_j] + C_{ij}$ ，因为如果有 $dist[x_i] \gt dist[x_j] + C_{ij}$ ，则说明 $dist[x_i]$ 还能再更新，这与最短路的结果相矛盾
至于为什么要找超级源点？因为如果只是随便从某一个点出发，由于这个图可能不连通，或者到不了某些点，导致在图的遍历过程中并未有访问所有边，因为从第一点来说，我们是要访问所有边，而不是所有点，因此建立一个超级源点十分有必要
如果存在负环，为什么不等式无解？可以从建立边的流程出发，首先在图中有环，说明在不等式也有个类似的“环”，不妨假设 $$ x_1 \le x_2 + C_1 , x_2 \le x_3 + C_2, \cdots , x_k \le x_1 + C_k $$ 这在图中等价一个环，然后假设这个环是负环，也就是 $C_1+\cdots+C_k < 0$ ，将这个不等式合并会发生什么？ $$ x_1 \le x_2 + C_1 \le x_3 + C_1 + C_2 \le \cdots \le x_1 + C_1 + \cdots C_k $$ 然后再消掉 $x_1$，发现 $C_1+\cdots+C_k \ge 0$ ，这与之前的假设矛盾，因此无解。

拓展刚刚讨论了 $x_i \le x_j + C_{ij}$ 不等式组的可行解求法，那么如果是 $x_i \ge x_j + C_{ij}$ 该如何处理呢？事实上，前两步是一样的，也是建图加找超级源点，但是后面就不是寻找最短路了，而是寻找最长路，然后判断有没有解也是判断有无正环

求所有点最大值或最小值

事实上，要想求最大值或者最小值，还需要有 $x_i \le C_i$ 或者 $x_i \ge C_i$ 的约束。同样地，这也是可以转化成最短路和最长路模型。

建图（与上述可行解建图相同）
超级源点满足 $x_i\le C_i$ 或 $x_i \ge C_i$ 的建图，也就是 $x_i \le x_0 + C_i$
结论：如果求的是最大值（$\le$)，应该求最短路；如果是求最小值（$\ge$），应该求最长路

正确性分析：以求 $x_i$ 的最大值为例子：从任意一个点 $x_i$ 出发，都可以构成任意多个不等式链 $x_i \le x_j + C_1 \le x_k + C_1 + C_2 \cdots \le C_1 + C_2 + \cdots$ ，每从图上走过一条路径都是等价于这样的一个不等式。因此这样每个点都有很多这样的上界，最终 $x_i$ 的最大值就是这些上界的最小值。

最短路数量与次短路数量问题

由于根据dijkstra算法的更新特性，最后更新完毕的路线一定是一个拓扑图，因此我们可以从 dp 的角度出发，$dist[i]$ 表示 $1-i$ 的最小路径，$cnt[i]$ 表示 $1-i$ 中最短路径的条数。

同样地，次短路最后更新完毕的路线也是这样的拓扑图。我们先看次短路怎么来的，首先肯定也是和最短路类似，我们可以枚举它可能的上一个结点，那么它可能从上一个结点的最短路转移过来，只要转移过来的值不等于当前点的最短路即可，当然也可能从一个结点的次短路转移过来，如果是从次短路转移过来，那么这个肯定就不是等于当前点的最短路。

代码如下：

void dijkstra() {
    for (int i = 1; i <= n; i ++ ) 
        for (int j = 0; j < 2; j ++ )
            d[i][j] = INF, st[i][j] = false, f[i][j] = 0;
            
    d[S][0] = 0, f[S][0] = 1;
    priority_queue<Node, vector<Node>, greater<Node>> Q;
    Q.push({0, S, 0});
    
    while (Q.size()) {
        auto [val, u, type] = Q.top(); Q.pop();
        if (st[u][type]) continue;
        st[u][type] = true;
        
        for (int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];
            if (d[v][0] > d[u][type] + w[i]) {
                d[v][1] = d[v][0]; f[v][1] = f[v][0]; Q.push({d[v][1], v, 1});
                d[v][0] = d[u][type] + w[i];
                f[v][0] = f[u][type];
                Q.push({d[v][0], v, 0});
            } else if (d[v][0] == d[u][type] + w[i]) f[v][0] += f[u][type];
            else if (d[v][1] > d[u][type] + w[i]) {
                d[v][1] = d[u][type] + w[i];
                f[v][1] = f[u][type];
            } else if (d[v][1] == d[u][type] + w[i]) f[v][1] += f[u][type];
        }
    }
}

数论和线性代数

Mon, 23 Oct 2023 00:00:00 GMT

数论

快速幂

快速幂主要是能在 $O(log k)$ 的时间复杂度求解 $a^k % m$ 。其思路在于任何一个数都可以写成以下形式 $k=2^{c_1} + 2^{c_2} + \cdots + 2^{c_y}$ 。{$c_i$} 序列是严格单调递增的。因此 $a^k \ % \ m$ 可以写成 $a^{2^{c_1} + 2^{c_2} + \cdots + 2^{c_y}} \ % \ m$ ，从而一步一步往下计算 $a^{2^{c_i}}$ ，最多计算 $logk$ 次即可。

核心代码如下：

int kpow(int a, int k, int m) {
    
    a %= m;
    int ans = 1 % m;
    while (k) {
        if (k & 1) ans = (LL) ans * a % m;
        k >>= 1;
        a = (LL) a * a % m;
    }
    return ans;
}

龟速乘

龟速乘主要是 $O(logb)$ 的时间内计算 $ab$，这种计算方法主要应用在 $ab$会爆掉 long long 的情况下，思路和快速幂一致，也是利用 $b$ 的二进制拆分。

核心代码如下：

LL kmul(LL x, LL y, LL m) {
    LL ans = 0;
    while (y) {
        if (y & 1) ans = (ans + x) % m;
        x = (x + x) % m;
        y >>= 1;
    }
    return ans;
}

素数筛

首先来看 1-N 中有多少个素数，也就是 $\pi(N) \approx \frac{N}{lnN}$ 。当 $N=1e6$ 时，$\pi(N)=78498$ ; 当 $N=1e7$ 时，$\pi(N)=664579$。了解在什么范围内有多少素数，有利于掌握相应的时间复杂度。

下面给出三种筛法（杜教筛以后学到再说）

埃式筛时间复杂度为 $O(nloglogn)$ 。核心代码如下：

int primes[N], cnt = 0;
bool st[N];

void get_primes(int n) {
    cnt = 0;
    memset(st, false, sizeof st);
    
    for (int i = 2; i <= n; i ++ ) {
        if (st[i]) continue;
        primes[cnt ++ ] = i;
        for (int j = i + i; j <= n; j += i)
            st[j] = true;
    }
}

线性筛时间复杂度为 $O(n)$。核心思路在于利用每个数的最小质数将其筛掉核心代码如下：

int primes[N], cnt = 0;
bool st[N];

void get_primes(int n) {
    cnt = 0;
    memset(st, 0, sizeof st);
    
    for (int i = 2; i <= n; i ++ ) {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; i <= n / primes[j]; j ++ ) {
            st[i * primes[j]] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

杜教筛时间复杂度为 $O(n^\frac{2}{3})$ 。

素数判定

试除法

时间复杂度：$\mathcal{O}(\sqrt{n})$ 当 $n \le 10^{12}$ 时，足够判断代码如下：

bool is_prime(int x) {
    
    if (x == 1) return false;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0) return false;
    return true;
}

另外，这个方法还可以加快速度，根据[[#唯一分解定理]]，只需要使用 $[2,\sqrt n]$ 里面的素数来判断即可。因此，这里有个策略是利用线性筛提前预处理好前 $\sqrt n$ 的所有素数，但由于时间和空间限制，这个 $n$ 的范围最大是 $n \le 10^{14}$ 代码如下：

bool is_prime(int x) {
    
    if (x == 1) return false;
    for (int i = 0; prime[i] <= x / prime[i]; i ++ )
        if (x % prime[i] == 0) return false;
    return true;
}

Miller-Rabin 算法

费马小定理

设 $n$ 是素数，$a$ 是正整数且与 $n$ 互素，那么有 $a^{n-1} \equiv 1(\text{mod}\ n)$

费马小定理目前作用有二：1. 这个是判断素数的必要条件；2.同余求逆

对于应用一：要判断 $n$ 是否为素数，可以随机 $a$ 来判断 $a^{n-1}$ 模 $n$ 是否为 1，如果不为 1 ，一定不是素数，如果为 $1$ ，可能是素数。因为一定有一些数（Carmichael 数）满足该式子，但是不为素数。但是这种数出现的概率不大。

对于应用二：由于 $a * a^{n-2} \equiv 1(\text{mod} \ n)$ ，因此 $a^{n-2}$ 是在 $a$ 与 $n$ 互素下同余 $n$ 的关于 $a$ 的逆元。注意这个后缀很重要，如果不互素，得使用扩展欧几里得

二次探测定理

如果 $p$ 是一个奇素数，且 $e \ge 1$，则方程 $x^2 \equiv 1 (\text{mod} \ p^e)$ 仅有两个解：$x=1$ 和 $x=-1$ 。当 $e=1$ 时，方程 $x^2 \equiv 1(\text{mod} \ p)$ 仅有两个解 $x=1$ 和 $x=p-1$ 把 $x=1$ 和 $x=p-1$ 称为“$x$ 对模 $p$ 来说 $1$ 的平凡平方根”

我们利用其逆否命题：对于方程 $x^2 \equiv 1(\text{mod} \ n)$ ，（注意 $n$ 不一定是奇素数），如果对模 $n$ 存在 $1$ 的非平凡平方根，则 $n$ 不可能是奇素数或者奇素数的幂

根据上面两个定理，可设计 Miller-Rabin 算法

如果 $n == 1$ ，不是素数
如果 $n==2$ ，是素数
如果 $n%2 == 0$，不是素数
那么剩下的就是 $n\gt 2$ ，且 $n$ 是奇数，来判断其是否为素数
1. 首先随机 $a$ ，判断 $a^{n-1}$ 模$n$ 是否为 1，不是则说明不是素数
2. 等于 1 的话利用二次探测定理继续判断，因此此时 $n-1$ 是偶数，所以有方程 ${a^{\frac{n-1}{2}\cdot 2} } \equiv 1(\text{mod} \ n)$ ，所以可以判断 $a^{\frac{n-1}{2}}$ 是否为 $1$ 或者 $n-1$ ，不是则说明不为素数，是则继续判断直到 $\frac{n-1}{2^t}$ 为奇数

代码中对 4.2 的利用不太一样，是直接对 $n -1$ 除到一个奇数，然后从这个奇数开始算到 $n-1$，如果都满足二次探测定理，最后则判断其是否满足费马小定理

只考虑 int 时间复杂度：$O(klog^3 n)$ ，出错的概率为 $2^{-s}$ 代码如下：

#include <random>
random_device rd;
mt19937 gen(rd());

int kpow(int a, int k, int m) {
    
    a %= m;
    int ans = 1;
    while (k) {
        if (k & 1) ans = (LL) ans * a % m;
        k >>= 1;
        a = (LL) a * a % m;
    }
    return ans;
}

bool witness(int a, int n) {
    int u = n - 1, t = 0;
    while ((u & 1) == 0) u >>= 1, t ++ ;
    int x1, x2;
    x1 = kpow(a, u, n);
    for (int i = 0; i < t; i ++ ) {
        x2 = kpow(x1, 2, n);
        if (x2 == 1 && x1 != 1 && x1 != n - 1) return true;
        x1 = x2;
    }
    if (x1 != 1) return true;
    return false;
}

bool miller_rabin(int n, int s) {
    
    if (n < 2) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;
    // i < min(s, n)，因为随机数取的是 [1,n-1]，当 s > n 时没啥意义
    for (int i = 0; i < s && i < n; i ++ ) {
        int a = gen() % (n - 1) + 1;
        if (witness(a, n)) return false;
    }
    return true;
}

考虑到 long long 的乘法会溢出的情况下需要使用龟速乘，时间复杂度为：$O(klog^4 n)$ 。

分解质因数

唯一分解定理

任何 $n\ge 2$ 的整数都可以分解成若干个质数乘积。也就是说 $$ n = p_1^{x_1}p_2^{x_2}p_3^{x_3}\dots p_k^{x_k} $$

质因数分解

思路：首先利用一个数 $n$ 的质因数中大于 $\sqrt n$ 的最多只有一个的特性，只需要枚举到 $\sqrt n$ 的情形就行，枚举的过程中，$n$ 可以通过枚举到的质因数逐渐变小，最后退出循环后，只要 $n$ 仍旧大于 1，说明这是剩下来的那个质因数。时间复杂度：$\mathcal{O}(\sqrt{n})$ 代码如下：

void divide(int x) {
    for (int i = 2; i <= x / i; i ++ ) {
        int cnt = 0;
        while (x % i == 0) cnt ++ , x /= i;
        if (cnt) cout << i << ' ' << cnt << endl;
    }
    if (x > 1) cout << x << ' ' << 1 << endl;
}

另外，当 $n$ 的范围不是很大的时候，也就是 $10^7$ 左右的时候，可以通过只枚举素数来加快速度。时间复杂度大概是 $\mathcal{O}(\sqrt{\frac{n}{ln n}})$

代码如下：

void divide(int n) {
    
    for (int i = 0; primes[i] <= n / primes[i]; i ++ ) {
        int cnt = 0;
        while (n % primes[i] == 0) cnt ++ , n /= primes[i];
        if (cnt > 0) {
            cout << primes[i] << ' ' << cnt << endl;
        }
    }
    if (n > 1) cout << n << ' ' << 1 << endl;
}

另外，如果要存的话，使用差不多 100 大小的数组就能存，因为对于 int 型的数质因数最多有十几个，一个因数的个数最多有三十几个

pollard_rho 启发式方法分解质因数

阶乘相关

勒让德定理

在正数 $n!$ 的质因数分解中，质数 $p$ 的指数记作 $v_p(n!)$ ，则$$v_p(n!)=\sum_{k\ge 1}\lfloor \frac{n}{p_k} \rfloor$$

阶乘质因数分解

思路就是唯一分解定理和勒让德定理的应用。时间复杂度在 $O(n)$ 左右。代码如下：

// 首先是找质数，根据上面的线性筛

// 然后就是勒让德计算
for (int i = 0; i < cnt; i ++ ) {
        int cnt = 0;
        for (int k = n / primes[i]; k > 0; k /= primes[i]) cnt += k;
        cout << primes[i] << ' ' << cnt << endl;
    }

威尔逊定理

若 $p$ 为素数，则 $p$ 可以整除 $(p-1)!+1$ 威尔逊定理四种表示方法：

$((p-1)!+1)\text{mod} \ p = 0$
$(p-1)!\text{mod} \ p = p-1$
$(p-1)!=pq - 1$ ，$q$ 为正整数
$(p-1)!\equiv -1(\text{mod} \ p)$ 核心记住第一点

约数

约数相关性质

约数个数根据唯一分解定理，约数个数 $f(n)=(x_1+1)(x_2+2)\cdots*(x_k+1)$ 那么前 $n$ 个数的约数个数之和怎么算呢，可以根据第 $i$ 个数在 $1-n$ 中是多少个数的约数，也就是 $\frac{n}{i}$ 个，因此 $\sum f(i) = nln n$ 大概是这个量级。这对分析时间复杂度有帮助。
约数之和一个数所有约数之和为 $\text{sum}=(1+p_1^1 + \cdots + p_1^{x_1}) * (1+p_2^1 + \cdots + p_2^{x_1}) * \cdots * (1+p_k^1 + \cdots + p_k^{x_k})$ ，这个很容易证明，根据乘法分配法，最后加法分隔开的每个数，都是从每个括号里面选择一个数进行相乘，这样刚好就枚举了所有的约数可能。代码如下：
```
// 第一步分解质因数
int ans = 1;
for (auto [u, v]: um) {
 int p = 1, t = 0;
 for (int i = 0; i <= v; i ++ ) t = (t + p) % MOD, p = 1ll * p * u % MOD;
 ans = 1ll * ans * t % MOD;
}
```
最多的约数个数在 int 范围内，约数个数最多的数大概有 1600 个约数。这对分析时间复杂度相当有帮助。
快速求出所有约数首先第一步，对数先进行质因数分解，然后 dfs 求得所有约数，根据上述的最多约数个数为 1600 个左右，因此 dfs 的时间一般来说是小于质因数分解的速度的。因此，求所有约数的时间极限变成了如何快速求质因数分解。[[#质因数分解]] 其中，dfs 代码为
```
void dfs(int cur, int val) {
if (cur >= idx) {
 res.push_back(val);
 return ;
}
for (int i = 0, t = 1; i <= c[cur]; i ++ , t *= p[cur])
 dfs(cur + 1, val * t);
```

} ```

最大公约数

欧几里得算法

时间复杂度：$O((log_2a)^3)$ 最大公约数的公式 $gcd(a, b)=gcd(b, a % b)$ 证明：设 $d$ 为 $a, b$ 的任意一个约数，那么 $d$ 也为 $b, a% b$ 的约数。显然，$d$ 是 $b$ 的约数成立，由于 $a % b = a - \lfloor \frac{a}{b} \rfloor * b$ ，根据 $(a \pm b) % d = (a % d \pm b % d) % d$ 。因此，$d$ 也是 $a % b$ 的约数。那么如果 $d^\prime$ 是 $gcd(a,b)$ 的最大公约数，则 $d^\prime$ 也是 $gcd(b,a % b)$ 的最大公约数。设 $d$ 为 $b, a % b$ 的任意一个约数，那么 $d$ 也是 $a, b$ 的约数。显然， $d$ 是 $b$ 的约数成立，由于 $a = a % b + \lfloor \frac{a}{b} \rfloor * b$ 。根据同余公式，则 $d$ 也是 $a$ 的约数。同理，$b, a % b$ 的最大公约数也是 $a, b$ 的最大公约数。综上：$gcd(a,b)=gcd(b,a%b)$。

代码如下：

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

拓展 $gcd(a_1,a_2,a_3,\cdots,a_n)=gcd(a_1,a_2-a_1,\cdots,a_n-a_{n-1})$ 根据此公式，序列的区间 $gcd$ 等价于序列差分数组的 $gcd$

更相减损法

时间复杂度 $max(a,b)$ $gcd(a,b)=gcd(a, a-b)=gcd(b, a-b)$ 因此一般使用 $stein$ 算法

stein 算法

如果 $a,b$ 都是偶数 $gcd(a, b) = 2*gcd(a/2,b/2)$ 如果 $a,b$ 其中一个为奇数，根据 $gcd(kx,y)=gcd(x,y)$ 如果 $x,y$ 互质，因此此处 $k$ 取 $2$，则有 $gcd(a,b)=gcd(a/2,b)$，这里适用高精度，但是建议py

裴蜀定理

如果 $a$ 和 $b$ 均为整数，则有整数 $x$ 和 $y$ 使 $ax+by=gcd(a,b)$

因此，有推论：当 $a,b$ 互素时，有整数 $x$ 和 $y$ 使得 $ax+by=1$

线性丢番图方程

根据[[#裴蜀定理]] ，方程 $ax+by=c$ 有整数解的充要条件是 $gcd(a,b)$ 是 $c$ 的倍数。假设 $(x_0,y_0)$ 是一组特解，所有通解可以表示为 $x=x_0+(b/d)n,y=y_0-(a/d)n$，$n$ 为任意整数

扩展欧几里得求二元线性丢番图的特解

首先利用扩展欧几里得求方程 $ax+by=gcd(a,b)$ 的特解，代码如下

LL exgcd(LL a, LL b, LL &x, LL &y) {
    if (b == 0) {
        x = 1, y = 0;
        return a;
    }
    LL d = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}

那么可以根据这个来求 $ax+by=c$ 的特解

判断 $c$ 是否整数 $gcd(a,b)$
求$ax+by=gcd(a,b)$ 的特解 $(x_0, y_0)$
在 $ax_0+by_0=gcd(a,b)$ 两边乘 $c / gcd(a,b)$ ，可得特解为 $(x_0^\prime, y_0^\prime)=(x_0 * c / gcd(a,b), y_0 * c / gcd(a,b)$
通解为 $x=x_0^\prime + (b/d)n, y=y_0^\prime-(a/d)n$，其中 $d=gcd(a,b)$

同余

$a\equiv b (\text{mod} \ m)$ 称为 $a$ 和 $b$ 同余同余可以转化成等式存在 $k$，使得 $a = b + mk$

一元线性同余方程

求解 $ax\equiv b (\text{mod} \ m)$ ，这个同余方程等价于二元丢番图方程，方程有解

定理设 $a,b$ 和 $m$ 是整数，$m>0,gcd(a,m)=d$。若 $d$ 不能整除 $b$，则 $ax \equiv b (\text{mod} \ m)$ 无解；若 $d$ 能够整除 $b$ ，则 $ax \equiv b (\text{mod} \ m)$ 有 $d$ 个模 $m$ 不同余的解

推论 $a,m$ 互素，线性同余方程 $ax \equiv b (\text{mod} \ m)$ 有唯一的模 $m$ 不同余的解。

逆

给定整数 $a$，且满足 $gcd(a,m)=1$，则 $ax \equiv 1 (\text{mod} \ m)$ 的一个解为 $a$ 模 $m$ 的逆，记为 $a^{-1}$

求逆

[[#费马小定理]]，$m$ 是素数，且 $a,m$ 互素，求 $a^{m-2} % m$
扩展欧几里得，$a,m$ 互素
递推求逆 $i=1,inv[i]=1;$ $i>1$ 时，假设 $p/i=k$，余数是 $r$，则 $k*i+r\equiv 0 (\text{mod} \ p)$ 因此 $r^{-1}i^{-1}ki+r^{-1}i^{-1}r\equiv 0 (\text{mod} \ p)$ 等价于 $r^{-1} k + i^{-1} \equiv 0 (\text{mod} \ p)$ 移项 $i^{-1} \equiv -r^{-1}k(\text{mod} \ p)$ 等价于 $i^{-1} \equiv (p-p/i)r^{-1}(\text{mod} \ p)$ $inv[i]=(p-p/i)*inv[p%i] % p$

逆可以用来求解同余方程，若$gcd(a,m)=1$，上边的同余方程可以适用下面的式子来求解 $x\equiv a^{-1}b(\text{mod} \ m)$，在模 $m$ 下有唯一解

定理设 $p$ 是素数，正整数 $a$ 是其自身的逆，当且仅当 $a\equiv 1 (\text{mod} \ p)$ 或者 $a\equiv -1 (\text{mod} \ p)$ 正如[[#二次探测定理]]

除法取模 $(a/b) % m = (a/b * b*b^{-1}) % m = (ab^{-1}) % m$

中国剩余定理

假设有 $m_1,m_2,\cdots, m_n$ 两两互质 ，且 $$ x \equiv a_i(mod \ m_i) $$ 那么该方程有一个通用解设 $M = m_1 * m_2 * \cdots * m_n$ , $M_i = M / m_i$ 因此 $M_i$ 一定与 $m_i$ 互质，故M, M设 $M_i^{-1}$ 为 $M_i$ 模 $m_i$ 的逆元因此可以构造答案 $$ x \equiv a_1 * M_1 * M_1^{-1} + a_2 * M_2 * M_2^{-1} + \cdots + a_n * M_n * M_n^{-1} (\text{mod} \ M) $$ 可以验证此 $x$ 成立

拓展

中国剩余定理的拓展，因为剩余定理求解公式需要满足两两互质的强限制，因此需要更一般的解法

解法: 由于 $x \equiv a_i(mod \ m_i)$ 等价于 $x = k_i * m_i + a_i$ , 其中 $k_i$ 是系数我们可取前两个等式考虑即 $x = k_1 * m_1 + a_1$ , $x = k_2 * m_2 + a_2$ ，合并得 $$ k_1 * m_1 + a_1 = k2 * m_2 + a_2 $$ 整理得 $$ k_1 * m_1 - k2 * m_2 = a_2 - a_1 $$ 根据裴蜀定理, 要想有整数解，则 $a_2 - a_1$ 为 $(m_1,m_2)$ 的倍数故可根据扩展欧几里得求出特解 $k_1^{\prime}, k_2^{\prime}$ 因此可得通解 ${k_1^{\prime}\frac{c}{d} + k * \frac{m_2}{(m_1,m_2)}, -k_2^{\prime}\frac{c}{d} + k * \frac{m_1}{(m_1,m_2)}}$，其中 k 是系数带入到求解 $x$ 的式子中得 $$ x = (k_1^{\prime}\frac{c}{d} + k * \frac{m_2}{(m_1,m_2)}) * m_1 + a_1 $$ 整理得 $$ x = [m_1,m_2] * k + a_1 + k_1^{\prime} * m_1\frac{c}{d} $$ 可以发现，这是一个与 $x = k_i * m_i + a_i$ 类似的式子，因此，便可以通过这种方式求解 $x$ 细节注意：$a_2 - a_1$ 的计算可以写成 $(a_2 - a_1 % m_2 + m_2) % m_2$；计算 $k_1^{\prime} * m_1*\frac{c}{d}$ 分开求，可能爆 long long；最后计算 $a_1+k_1^\prime * m_1$ 最后对 $[m_1,m_2]$ 取模；核心思想在于在这个过程中，让值变得更小

LL calc() {
    
    LL a1 = a[1], m1 = m[1];
    for (int i = 2; i <= n; i ++ ) {
        LL a2 = a[i], m2 = m[i];
        LL a = a1, b = a2, c = (m2 - m1 % a2 + a2) % a2;
        LL x, y;
        LL d = exgcd(a, b, x, y);
        if (c % d) return -1;
        // b0 的计算也可以龟速乘
        LL k = b / d, b0 = (c / d * x % k + k) % k;
        LL ans = a1 * k;
        // 下面这行可能爆longlong 不行就龟速乘
        m1 = (a1 * b0 % ans + m1) % ans;
        a1 = ans;
    }
    return m1;
}

BSGS 算法

问题描述：若 $gcd(a,p)=1$，求 $a^t \equiv b (\text{mod} \ p)$ 求最小非负正整数解 $t$

根据欧拉定理，$a^{\phi(p)} \equiv 1 (\text{mod} \ p)$ ，$a^t \equiv a^{t \ \text{mod} \ \phi(p)} (\text{mod} \ p)$ 因此，最小的 $t \in [0,\phi(p)-1]$ 在计算的时候可以稍微扩大成 $[0,p]$，避免计算欧拉函数

枚举是利用分块的思想，首先将这个区间分成 $\sqrt p$ 段，令 $k=\lfloor \sqrt p \rfloor + 1 \gt \sqrt p$ ，$t = kx - y$ ，为了让 $t$ 能够取到 $[0,p]$ 中的所有数，可以设置 $x \in [1,k], y \in [0,k-1]$ ，这样 $t \in [1,k^2]$ ，因为 $k^2 \gt p$ 。注意，0特判即可

原式可变形为 $a^{kx} \equiv b \cdot a^y (\text{mod} \ p)$，也就是说，枚举 $x$ 的时候，判断是否有对应的 $y$ 使其同余 $p$ 相等

欧拉函数

$1-N$ 中与 $N$ 互质的数的个数被称为欧拉函数，记为 $\phi(N)$ 欧拉函数的计算公式为： $$ \phi(N) = N \times \frac{p_1 - 1}{p_1} \times \cdots \times \frac{p_k - 1}{p_k} $$ 这里提到另外一个本人想到的公式，设 $p$ 为小于 $N$ 的约数，记 $\phi^p(N)$ 为 $x \in [1,N]$ 中 $gcd(x, N) = p$ 的 $x$ 的个数。其计算公式为： $$ \phi^p(N) = \phi(\frac{N}{p}) $$ 欧拉函数计算公式证明：证明思路是计算 $1-N$ 中有多少数是 $N$ 的合数，最后用 $N$ 减去这个结果即可。那么 $1-N$ 中有多少是 $N$ 的合数可以根据唯一分解定理计算，一个数是 $N$ 的合数，一定是 $p_1,p_2, \cdots ,p_k$ 的倍数，因此可以通过计算 $1-N$ 中有多少数是这些数的倍数，减掉即可。即：$N - (\frac{N}{p_1} + \cdots + \frac{N}{p_k})$ 。但是，这样还不行，因为像 $p_1 \times p_2$ 的倍数其实被删掉了两次，要重新加回来，这也是通过容斥原理来计算。因此，最终得到的公式为上述公式。

线性筛求欧拉函数

欧拉函数可以用筛素数的写法来计算欧拉函数，线性筛的本质是用一个数的最小质数将其筛掉，那么便可以思考一个数的欧拉函数值是否可以通过其最小质数和其相应约数计算得到。

首先，对于 $n$ 为质数，那么 $\phi(n)$ 为 $n-1$。

然后思考线性筛的过程，如果 $i % primes[j] == 0$ 时，会发生什么，对于 $iprimes[j]$ 来说，$primes[j]$ 就是它的最小质数，但是事实上此时 $primes[j]$ 是$i$ 的约数了，根据欧拉函数与指数没有关系，假设，$\phi(i) = i * x$，那么 $\phi(iprimes[j]) = i * primes[j] * x = primes[j] * phi(i)$。

如果 $i % primes[j] != 0$ 时，则说明 $i$ 的质因数分解中原来没有 $primes[j]$，此时 $phi(i) = ix$，那么 $phi(iprimes[j])=i * primes[j] * \frac{primes[j] - 1}{primes[j]} * x = (primes[j] - 1) * phi(i)$ 。

核心代码如下：

oid get_euler(int n) {

    for (int i = 2; i <= n; i ++ ) {
        if (!st[i]) {
            primes[cnt ++ ] = i;
            phi[i] = i - 1;
        }
        for (int j = 0; i <= n / primes[j]; j ++ ) {
            st[i * primes[j]] = true;
            if (i % primes[j] == 0) {
                phi[i * primes[j]] = phi[i] * primes[j];
                break;
            }
            phi[i * primes[j]] = phi[i] * (primes[j] - 1);
        }
    }
}

欧拉定理

设 $a,m \in N^+$, 且 $gcd(a,m)=1$，$\phi(x)$ 为欧拉函数，有 $$ a^{\phi(m)} \equiv 1 (\text{mod} \ m) $$

欧拉降幂

$$ a^b \equiv
\begin{cases}
a^{b % \phi(m)} &\quad gcd(a,m)=1\
a^b &\quad b < \phi(m) \
a^{b % \phi(m) + \phi(m)} &\quad b \ge \phi(m) \
\end{cases} \qquad (\text{mod \ m}) $$

莫比乌斯反演

莫比乌斯函数

根据[[#唯一分解定理]]

若 $F(n)=\sum_{n | d} f(d)$，则 $f(n)=\sum_{n|d} \mu (\frac{d}{n})F(d)$

线性代数

矩阵快速幂

这里提供矩阵快速幂的模板。

struct matrix { int m[N][N]; };

matrix operator * (const matrix& a, const matrix& b) {
    matrix c;
    memset(c.m, 0, sizeof c.m);
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j < N; j ++ )
            for (int k = 0; k < N; k ++ )
                c.m[i][j] = (c.m[i][j] + 1ll * a.m[i][k] * b.m[k][j] % mod) % mod;
    return c;
}

matrix pow_matrix(matrix a, int k) {
    matrix ans;
    memset(ans.m, 0, sizeof ans);
    for (int i = 0; i < N; i ++ ) ans.m[i][i] = 1;
    while (k) {
        if (k & 1) ans = ans * a;
        k >>= 1;
        a = a * a;
    }
    return ans;
}

这个模板是相当不错的，矩阵乘里面的 $N$, mod 可以不是常量，可以在事后输入。

矩阵快速幂的应用

对于 $f(n)=f(1)+f(2)+\cdots+f(n-1) + c$ 这样的递推式子，容易构造矩阵 $$ \begin{pmatrix} f(n) & f(n-1) & \cdots & f(2) \ \end{pmatrix} = \begin{pmatrix} f(n-1) & f(n-2) & \cdots & f(1) \ \end{pmatrix} A $$ 其中，矩阵 $A$ 就是根据递推式构造的矩阵有的时候，递推式就是根据动态规划转移式子得来，有的时候隐藏的很深，需要去发现去设计

高斯消元

在高斯消元的过程中，我们需要对判断最终的结果是唯一解？多解还是无解？这里有一个通用的判断方式（$n,m$关系未知，$m$ 行 $n$ 列）

	// 首先判断在进行了多次处理后 最后 row ~ m 行的最后一列是否全为 0，不是则为无解
    for (int i = row; i <= m; i ++ )
        if (a[i][n + 1]) return 0;
    // row - 1 表示秩的大小，显然秩为 n 的时候为唯一解
    if (row == n + 1) return 1;
    return 2;

时间复杂度 $O(nm^2)$，其中 $n,m$ 分别为行列

高斯消元求解线性方程组

代码如下：

/*
输出解 注意 0 的判断
for (int i = 1; i <= n; i ++ )
    printf("%.3f ", fabs(a[i][n + 1]) < eps ? 0.000 : a[i][n + 1]);
*/
// 0 无解 1 唯一解 2 无穷解
int guass() {
    
    int row, col;
    for (col = 1, row = 1; col <= n; col ++ ) {
        int t = row;
        for (int i = row + 1; i <= n; i ++ )
            if (fabs(a[i][col]) > fabs(a[t][col]))
                t = i;
        
        if (fabs(a[t][col]) < eps) continue;
        for (int i = col; i <= n + 1; i ++ ) swap(a[t][i], a[row][i]);
        for (int i = n + 1; i >= col; i -- ) a[row][i] /= a[row][col];
        
        for (int i = 1; i <= n; i ++ )
            if (i != row && fabs(a[i][col]) > eps) {
                for (int j = n + 1; j >= col; j -- ) a[i][j] -= a[row][j] * a[i][col];
            }
        
        row ++ ;
    }
    if (row <= n) {
        for (int i = row; i <= n; i ++ )
            if (fabs(a[i][n + 1]) > eps) return 0;
        return 2;
    }
    return 1;
}

高斯消元求解异或线性方程组

代码如下：

int guass() {
    
    int col, row;
    for (col = row = 1; col <= n; col ++ ) {
        int t = row;
        for (int i = row + 1; i <= n; i ++ )
            if (a[i][col] > a[t][col]) t = i;
       
        if (a[t][col] == 0) continue;
        for (int i = col; i <= n + 1; i ++ ) swap(a[t][i], a[row][i]); 
        
        for (int i = 1; i <= n; i ++ )
            if (i != row && a[i][col] == 1) {
                for (int j = n + 1; j >= col; j -- )
                    a[i][j] ^= a[row][j];
            }
        row ++ ; 
    }

    if (row <= n) {
        for (int i = row; i <= n; i ++ )
            if (a[i][n + 1] > 0) return 0;
        return 2;
    }
    return 1;
}

高斯消元求解模运算线性方程组

代码如下

// 注意这里是 模 3 的写法，如果是其他的模，需要求逆
// 以下如果是模 p 的话，则 3 改为 p
void gauss() {

    int col, row;
    for (col = row = 0; col < n; col ++ ) {
        int t = row;
        for (int i = row + 1; i < n; i ++ )
            if (a[i][col] > a[t][col]) t = i;
        if (a[t][col] == 0) continue;//print();
        for (int i = col; i <= n; i ++ ) swap(a[t][i], a[row][i]);
        // 此处需要求逆，其中 2 替换为 a[row][col]对于 p 的逆
        // 这个 if 需要去掉
        if (a[row][col] == 2) {
            for (int i = n; i >= col; i -- ) a[row][i] = (a[row][i] * 2) % 3;
        }
        for (int i = 0; i < n; i ++ )
            if (i != row && a[i][col]) {
                for (int j = n; j >= col; j -- ) 
                    a[i][j] = (a[i][j] + (3 - a[i][col]) * a[row][j]) % 3;
            }
        row ++ ;
        
    }
}

线性基

迭代构造线性基

时间复杂度 $O(nm)$，其中 $m$ 为 $n$ 个数里面的最大位数，在 long long 范围内等价于 $O(64n)$

代码如下：

LL base[63]; // 存储线性基
bool zero = false; // 查看是否这组数据里面能否出现 0 

void insert(LL x) {
    
    for (int i = 62; i >= 0; i -- ) {
        if (x >> i == 1) {
            if (base[i] == 0) {base[i] = x; return ;}
            else x = x ^ base[i];
        } 
    }
    zero = true;
}

LL qmax() {
    LL res = 0;
    for (int i = 62; i >= 0; i -- )
        res = max(res, res ^ base[i]);
    return res;
}