目录
——2020年11月8日（周日）——————————————————
周测啦……
——2020年11月9日（周一）——————————————————
搞堆优化的Prim去了……
——2020年11月10日（周二）——————————————————
最小生成树（稀疏图）
以下来源于百度百科：
稀疏图，数据结构中的一种定义图。与之相反的是稠密图。稀疏图的边数远远少于完全图，反之，稠密图的边数接近于或等于完全图。
所以，之前的Prim就是用于稠密图了……
一、Kruskal 求最小生成树
这是之前的笔记
思路
就是对 边 进行操作就可以了！
- 将所有边按权重从小到大排列（O(m log m)）
- 枚举所有边，若边的两点没有连通，就加入这条边。（O(m)）
思路超级简单！算法及其优美！实际效率据说还很高……
用于稀疏图。
答案
#include<bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, m;
int p[N];
//定义数据结构E,方便对边进行操作
struct E{
int a, b, w;
}e[N];
//重定义比较大小
bool operator < (E &a, E &b){
return a.w < b.w;
}
//简洁明了的并查集写法
int find(int x){
return p[x] == x ? p[x] : p[x] = find(p[x]);
}
int main(){
cin >> n >> m;
for(int i = 0; i < m; i ++){
int a, b, w;
cin >> a >> b >> w;
e[i] = {a, b, w};
}
//这里默认从小到大排列，用到“<”的时候会触发重定义的条件
sort(e, e + m);
//这里还用到了并查集！
for(int i = 1; i < n; i ++) p[i] = i;
int res = 0, cnt = 0;
for(int i = 0; i < m; i ++){
int a = e[i].a, b = e[i].b, w = e[i].w;
a = find(a), b = find(b);
//比较祖先，如果不是一个就合并
if(a != b){
p[a] = b;;
res += w;
//这里统计的是边数哦！
cnt ++;
}
}
//边数不够说明无法建立最小生成树！
if(cnt < n - 1) cout << "impossible";
else cout << res;
return 0;
}
二分图
二、染色法 判断二分图
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 2*N;
int n, m;
int cl[N];
//用邻接表来储存……
int ne[M], e[M], h[M], idx = 0;
void add(int a, int b){
ne[idx] = h[a], e[idx] = b, h[a] = idx ++;
}
bool dfs(int u, int c){
cl[u] = c;
//找到所有与之相关的节点
for(int i = h[u]; i != -1; i = ne[i]){
int j = e[i];
//3-c是用来将1变成2,2变成1的啦……1和2代表了不同的颜色，0代表无颜色
//如果没有被染色就染色吧
if(!cl[j]) dfs(j, 3 - c);
//要是染了色的话，而且还与当前节点颜色相同，那就返回错误；一样就不管他，所以这里用else if !
else if(cl[j] == c) return 0;
}
//整个操作下来没问题就返回1
return 1;
}
int main(){
cin >> n >> m;
//邻接表一定不要漏了这句话！
memset(h, -1, sizeof(h));
while(m --){
int a, b;
cin >> a >> b;
//双向图哦！
add(a, b), add(b, a);
}
int flag = 1;
//接下来一个一个点地看
for(int i = 1; i <= n; i ++)
//如果在之前的操作中没有被染色，说明从它开始又是一个新的色块了
if(!cl[i])
//默认某一色块第一个点是1
//如果出了问题会返回0
if(!dfs(i, 1)){
flag = 0;
break;
}
if(flag) cout << "Yes";
else cout << "No";
return 0;
}
三、匈牙利算法
很神奇的算法，可以用 牵红线 的思路去理解，请看之前的笔记
总之这一次我用简单的语言解释一下：
首先，我们给出的图必定是二分图，所以根据二分图的定义，我们可以将所有的点分成两份，做成以下的样子：
-
像这样分成两个点集，左边全是红色，右边全是蓝色，中间的红线代表他们之间的边；
-
遍历所有蓝色的点，一找到有边连着的点就先连上，像这样：
蓝色一号 和 红色一号有边相连，就立即连上
那么 现在我们已经完成一个匹配了！！！
要是出现了当前 蓝点 想要连起来的 红点 已经被连起来了怎么办？这要分两种情况讨论：
-
第一种方案：优先让之前的 蓝点 选其它的 红点 ，
也就是说， 要是 蓝色一号 还有其它出边，那就让 蓝色一号 找另一个红色节点。
像这样：
蓝色一号 要是 还有通向 红色二号 的边的话，那就让 蓝色一号 改为 与红色二号匹配
然后将 红色一号 让给 蓝色二号……
-
第二种方案：让当前蓝点找其他红点
先这样 蓝色一号 其实是没有其他出边了的，
那就 让 蓝色二号 放弃 红色一号 ，然后 去找其它出边。
于是蓝色二号 找到了 红色四号：
那么 现在我们已经完成两个匹配了！！！
像这样一直下去，我们可以一路做到这样的情况：
5.现在迎来了最后一个问题：要是当前蓝点 要的 红点 已经被 占有，并且占有那个红点的 蓝点 已经没有其他出边了怎么办？
通过上图可知： 蓝色五号 只能 通往 红色四号，但是红色四号 已被 蓝色二号 占有且 蓝色二号 没有出边。
也就是说，之前两个 解决方案都失效了……
那么只好放弃这个点了……
这就是为什么要求最大匹配，因为有可能有的点是匹配不上的！
#include<bits/stdc++.h>
using namespace std;
const int N = 510, M = 100010;
int n1, n2, m;
int e[M], ne[M], h[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 x){
for(int i = h[x]; i != -1; i = ne[i]){
//j是与当前蓝点有关联的红点
int j = e[i];
//st在这里就是为了避免某种循环：详细的配图例的例子看程序下面
if(!st[j]){
//只要是对红点进行了操作，都要将它标记起来
st[j] = 1;
//如果那个红点没有被占有 或者 占有那个红点的蓝点还有出路
if(match[j] == 0 || find(match[j])){
//那就将找到的红点匹配给当前蓝点
match[j] = x;
//匹配成功就返回1好了，返回到前面的函数里就代表 "占有那个红点的蓝点还有出路”，返回主函数就说明 匹配好的点又多了一对！
return 1;
}
}
}
//要是所有的出边都找完了都没有找到一个出路，那就是匹配失败了……
//同样有两个意思：返回到前面的函数里就代表 "占有那个红点的蓝点没有出路”，返回主函数就说明 匹配好的并没有多出一对……
return 0;
}
int main(){
cin >> n1 >> n2 >> m;
memset(h, -1 ,sizeof(h));
while(m --){
int a, b;
cin >> a >> b;
add(a, b);
}
int res = 0;
for(int i = 1; i <= n1; i ++){
memset(st, 0, sizeof(st));
if(find(i)) res ++;
}
cout << res;
return 0;
}
中间的图例补充：
假设 蓝色一号、二号 通向红色一号，蓝色二号、三号通向红色二号；
蓝色三号想要红色一号，但是红色一号已经被蓝色二号占有了，那就让蓝色二号去找红色二号，
而红色二号已经被蓝色三号占有了，那么蓝色三号又来找红色一号……
像这样，会陷入红色一号、蓝色二号、红色二号、蓝色三号 轮流寻找的循环，
开了st数组之后，st会记下红色一号已经被找过一轮了，那么后来蓝色三号就不会又来找红色一号了！
解释起来好麻烦……
——2020年11月11日（周三）——————————————————
双十一了哦！不过没有买什么东西啊…………
一、拓扑排序
拓扑序就是，将一个图里的所有的点重新排序，使得所有的点的出边都是指向后面的点的序列。
#include<bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int q[N], d[N];
//用邻接表来储存图
int h[N], e[N], ne[N], idx;
void add( int a, int b){
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
//拓扑序用宽搜来做，具体是每次取出一个入度为0的点，将它的所有出边都删掉，也就是将那些终点的入度减一。
bool topsort(){
int hh = 0, tt = -1;
//先将所有入度为0的点入队
for(int i = 1; i <= n; i ++)
if(!d[i]) q[++ tt] = i;
while(hh <= tt){
int t = q[hh ++];
for(int i = h[t]; i != -1; i = ne[i]){
int j = e[i], d[j] --;
//入度为0说明前面已经不会有点指向这个点了，那就将它入队。
if(d[j] == 0) q[++tt] = j;
}
}
//tt是队尾，当前队伍的长度为tt - 1。如果队伍元素数量不是n个，说明有的点没有被加入到这个拓扑序里，也就是无法形成拓扑序。
return tt == n - 1;
}
int main(){
cin >> n >> m;
memset(h, -1, sizeof h);
for(int i =0; i < m; i ++){
int a, b;
cin >> a >> b;
add(a, b);
d[b] ++;
}
if(topsort()){
for(int i = 0; i <n; i ++)
cout << q[i] << " ";
}
else cout << "-1" <<endl;
return 0;
}
DFS
二、排列数字
链接
复习一下深搜写法：
#include<bits/stdc++.h>
using namespace std;
int n, p[10];
bool b[10];
void D (int u){
//首先写的是终止条件
if(u == n){
for(int j = 0; j < n; j ++ )
cout << p[j] << " ";
cout << endl;
return ;
}
//然后是正常的套娃
for(int i = 1; i <= n; i ++)
if( !b[i] ){
b[i] = 1;
p[u] = i;
D(u + 1);
b[i] = 0;
}
return ;
}
int main(){
cin >> n;
D(0);
return 0;
}
三、n-皇后
然后是这个经典的深搜问题。
#include<bits/stdc++.h>
using namespace std;
const int N = 20;
int n, p[N];
char g[N][N];
bool col[N], dg[N], udg[N];
//具体操作：先遍历 第0行 可以放皇后的所有位置，再遍历 第1行 可以放皇后的位置...依次类推到 第n行。
void D (int u){
if(u == n){
for(int j = 0; j < n; j ++ )
puts(g[j]);
cout << endl;
return ;
}
/* 这里 u+i 以及 n-u+i 分别是 (u,i)所在的对角线(这样的 /) 以及 反对角线(这样的 )
具体推导是： 令 (u, i) 为 在坐标轴上的 (x, y);
(x, y)分别在对角线 y = x + b 以及 反对角线 y = -x + b 上。
坐标轴上的 y=x+b => b=x-y => b=n+x-y (防止出现负数，开数组的时候是从0开始递增的) ；
以及 y=-x+b => b=x+y 。
这样可以得到所在斜线（对角线）与y轴的焦点坐标（0，b）
这时的 b 就是 (u,i) 所在的 对角线(或反对角线）的唯一编号；
这样下来，在同一对角线的所有点都会有一样的唯一编号。
(具体多少不重要u, i 可调换,重要的是确保同一对角线上的点处理后所得到的编号唯一)
*/
/*
对角线上的 u, i 调换后答案是一样的。
不用纠结 对角线和反对角线 和 坐标序号之类的。
不信试一下……
*/
for(int i = 0; i < n; i ++)
if( !col[i] && !dg[u + i] && !udg[n - u + i] ){
g[u][i] = 'Q';
col[i] = dg[u + i] = udg[n - u + i] = 1;
//p[u] 表示第u 行的皇后放在第i位。
p[u] = i;
//然后再次基础上进行深搜
D(u + 1);
//这里p[u]不必还原，因为对下一次的遍历不会产生影响
g[u][i] = '.';
//但是这三个数组一定要还原，不然会影响到接下来的深搜
col[i] = dg[u + i] = udg[n - u + i] = 0;
}
return ;
}
int main(){
cin >> n;
for(int i = 0; i < n; i ++)
for(int j = 0; j < n; j ++)
g[i][j] = '.';
D(0);
return 0;
}
——2020年11月12日（周四）——————————————————
其实n皇后是今天做的啦，断开不太好……
——2020年11月13日（周五）——————————————————
BFS
一、走迷宫
BFS常用来干的事就是可以求出到某一点的最短距离。
题目连接
#include<bits/stdc++.h>
using namespace std;
const int N = 110;
typedef pair<int,int> P;
int m, n;
int g[N][N] , d[N][N];
P q[N * N];
int bfs(){
//hh tt 表示 栈头和栈尾；
int hh = 0 , tt = 0;
q[0] = {0, 0};
memset(d, -1, sizeof(d));
d[0][0] = 0;
//上， 下， 左， 右 四个方向；
int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
while(hh <= tt){
// auto 会根据初始化的内容自动定义变量的类型,这句话等价于 "P t = q[hh ++];"； t是当前所在的点的二维坐标；
auto t = q[hh ++];
for(int i = 0; i <4; i ++){
//x, y 表示原来那个点可以走到的点。
int x = t.first + dx[i], y = t.second + dy[i];
//这个点在地图范围内 且 可以走 且 没有走过的时候；
if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1){
//给新的点定义上新的层数, 也就是到起点的最短可行距离；
d[x][y] = d[t.first][t.second] + 1;
//将新的点入栈；
q[ ++ tt] = {x, y};
}
}
}
//返回终点的距离
return d[n - 1][m - 1];
}
int main(){
cin >> n >> m;
for(int i = 0;i <n; i ++)
for(int j = 0 ; j < m; j ++)
cin >> g[i][j];
cout << bfs() << endl;
return 0;
}
二、八数码
#include<bits/stdc++.h>
using namespace std;
int bfs(string start){
string end = "12345678x";//定义终点的状态
queue<string> q;//要用到一个每个元素为string类型的队列
unordered_map<string, int> d;//距离数组，表示对应状态的距离.可以理解为当前字符串对应一个整数类型的距离
q.push (start);//将start 放到队列里面做起点
d[start] = 0;//起点的距离是0
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
//深搜开始
while(q.size()){
auto t = q.front();
q.pop();
int distance = d[t];
if(t == end) return distance;//假设到终点就结束
//状态转移
int k = t.find('x');//返回x的下标
int x = k / 3, y = k % 3;//找到x的横、纵坐标
for(int i = 0; i < 4; i ++){
int a = x + dx[i], b = y + dy[i];//找到下一个状态的横、纵坐标
if(a >= 0 && a< 3 && b >= 0 && b < 3){//判断下一个位置没有出界
swap(t[k], t[a * 3 + b]);//交换二维坐标
if(!d.count(t)){//如果更新完的t没有被搜到过的话，那么我们就找到了一个新的状态
d[t] = distance + 1;//更新t的距离
q.push(t);//将t入队
}
swap(t[k], t[a * 3 + b]);//别忘了返回状态
}
}
}
return -1;//没找到终点
}
int main(){
string start;
for(int i = 0; i < 9; i ++){
char c;
cin >> c;
start += c;
}//输入字符串
cout << bfs(start) << endl;//bfs求距离
return 0;
}
——2020年11月14日（周六）——————————————————
看了一晚上容器LIST的内置函数，人都傻了……这是成果