目录
——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的内置函数,人都傻了……这是成果