我的BFS板子

struct node{/*略*/};//表示一个状态
std::map<node,bool>vis;//判断每个状态是否已访问过
std::queue<node>q;//BFS扩展队列
//BFS主代码
q.push(start_node); //初始节点入队
vis[start_node] = 1;
while (!q.empty())
{node head = q.front(); //去队首元素进行拓展q.pop();for (int i : directions) //遍历每一种拓展方式{node new = move(head, i); //求新的状态if (!valid(new) || vis[new])continue; //如果新状态不合要求，即出界（不合逻辑）或已访问过//做题q.push(new); //新节点入队vis[new] = 1;}
}

以上的代码中有很多地方使用了伪代码，或者说，不是我们实际编写的形式。下面给出一个具体实现：

struct node
{int x, y;                                                //坐标int step;                                                //到此的步数node(int x, int y, int step) : x(x), y(y), step(step) {} //构造函数
};
int n, m;                                               //迷宫大小
bool vis[max_n][max_m];                                 //标记是否已访问
bool can_walk[max_n][max_m];                            //标记是否可走
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; //四个方向
std::queue<node> q;                                     //BFS队列
bool pan(int x, int y)                                  //判断(x,y)是否合法
{return x >= 1 && x <= n && y >= 1 && y <= m && can_walk[x][y];
}
int bfs(int sx, int sy, int tx, int ty) //从(sx,sy)出发到(tx,ty)，返回最少步数，无解则为-1
{if (!can_walk[sx][sy]) //如果一开始就在墙里，无解return -1;q.push(node(sx, sy, 0)); //初始位置入队vis[sx][sy] = 1;while (!q.empty()){node head = q.front(); //取队首元素q.pop();if (head.x == tx && head.y == ty) //如果到达终点return head.step;for (int i = 0; i < 4; i++){int xx = head.x + dx[i], yy = head.y + dy[i]; //尝试向四个方向移动if (!pan(xx, yy) || vis[xx][yy])continue;q.push(node(xx, yy, head.step + 1)); //新节点入队vis[xx][yy] = 1;}}return -1; //如果走过所有可行解点了，仍然没到达终点，无解
}

用BFS的思想理解dijkstra

water_lift这个垃圾至今不会SPFA
这里指的是堆优化的版本。
首先起点入队。每次在队列中取最短路长度最小的，对所有从该点出发出边到达的点进行松弛并加入队列。这就是堆优化版dijkstra的算法轮廓。
下面是一个大量使用了STL的dijkstra，很慢，但是能A掉P3371 【模板】单源最短路径（弱化版）

#include<bits/stdc++.h>
#define inf INT_MAX
using namespace std;
int n,m,s;
struct edge{int to,dis;edge(int a,int b):to(a),dis(b){}
};
vector<edge>edges;
vector<int>G[10003];
void add_edge(int u,int v,int w){edges.push_back(edge(v,w));G[u].push_back(edges.size()-1);
}
struct node{int p,dis;node(int a,int b):p(a),dis(b){}
};
bool operator< (node a,node b){return a.dis>b.dis;
}
priority_queue<node>q;
int d[10003];
bool u[10003];
int main(){cin>>n>>m>>s;for(int i=1;i<=m;i++){int u,v,w;cin>>u>>v>>w;add_edge(u,v,w);}fill(d+1,d+n+1,inf);d[s]=0;q.push(node(s,0));while(!q.empty()){node x=q.top();q.pop();//cout<<x.p<<' '<<x.dis<<endl;if(u[x.p])continue;u[x.p]=1;for(int i=0;i<G[x.p].size();i++){edge e=edges[G[x.p][i]];//cout<<'\t'<<e.to<<' '<<d[e.to]<<"->";d[e.to]=min(d[e.to],d[x.p]+e.dis);//cout<<d[e.to]<<endl;q.push(node(e.to,d[e.to]));}}for(int i=1;i<=n;i++){cout<<d[i]<<' ';}
}

U64942 【常数PK】#2 单源最短路
在此给出一个神奇的题目，用以测试算法优越性。具体来说，就是按照运行时间得分。具体请见题目内描述。
下面是目前得分最高(9525分)的代码(by __Seniorious__):

// luogu-judger-enable-o2
// luogu-judger-enable-o2
#include<cctype>
#include<cstdio>
#include<queue>
const int BUF=8000000;
char Buf[BUF],*buf=Buf;
struct edge{int nxt,to,val;
};
edge t[700010];
int fis[200010],n,m,s,cnt,di[200010],s_,e_,c_;
bool is_vis[200010];
inline void add(int _s,int _e,int _c){t[++cnt].nxt=fis[s_],fis[s_]=cnt,t[cnt].to=e_,t[cnt].val=c_;
}
struct node{int dis,num;inline bool operator<(const node &p)const{return dis>p.dis;}
};
std::priority_queue<node,std::vector<node> >h;
inline void read(int &x){for(x=0;!std::isdigit(*buf);++buf);for(;std::isdigit(*buf);x=x*10+*buf-'0',++buf);
}
int main(){//freopen("tst","r",stdin);fread(buf,1,BUF,stdin);read(n),read(m),read(s);for(int i=1;i<=m;++i){read(s_),read(e_),read(c_);add(s_,e_,c_);}for(int i=1;i<=n;++i)di[i]=2147483647;di[s]=0;h.push(node{0,s});while(!h.empty()){node QwQ=h.top();h.pop();int qwq=QwQ.num;if(is_vis[qwq])continue;is_vis[qwq]=1;for(int j=fis[qwq];j;j=t[j].nxt){int f=t[j].to;if(t[j].val+di[qwq]<di[f]){di[f]=t[j].val+di[qwq];h.push(node{di[f],f});}}}for(int i=1;i<=n;++i)printf("%d ",di[i]);printf("\n");return 0;
}

一些题解

P1451 求细胞数量

算法：BFS

从每个非0格BFS，把遇到的所有非0格都变为0。

#include <bits/stdc++.h>
using namespace std;
int m, n;
char mat[101][101];
struct node
{int x, y;node(int x, int y) : x(x), y(y) {}
};
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
bool pan(int x, int y)
{return x >= 1 && x <= m && y >= 1 && y <= n;
}
int ans;
int main()
{cin >> m >> n;for (int i = 1; i <= m; i++){for (int j = 1; j <= n; j++){cin>>mat[i][j];}}for (int i = 1; i <= m; i++){for (int j = 1; j <= n; j++){if (mat[i][j] == '0')continue;ans++;queue<node> q;q.push(node(i, j));mat[i][j] = '0';while (!q.empty()){node h = q.front();q.pop();for (int k = 0; k < 4; k++){int xx = h.x + dx[k], yy = h.y + dy[k];if (!pan(xx, yy) || mat[xx][yy] == '0')continue;q.push(node(xx, yy));mat[xx][yy] = '0';}}}}cout << ans;
}

P1443 马的遍历

算法：BFS

从(1, 1)
开始BFS，第一次到达某个点的步数就是最少步数。

#include <bits/stdc++.h>using namespace std;
typedef pair<int, int> pos;
int n, m, x, y;
const int dx[8] = {1, 2, 2, 1, -1, -2, -2, -1}, dy[8] = {2, 1, -1, -2, -2, -1, 1, 2};
inline bool ck(int x, int y)
{return x >= 1 && x <= n && y >= 1 && y <= m;
}
queue<pos> q;
int d[401][401];
int main()
{cin >> n >> m >> x >> y;pos h = pos(x, y);q.push(h);memset(d, -1, sizeof(d));d[x][y] = 0;while (!q.empty()){pos i = q.front();q.pop();for (int r = 0; r < 8; r++){int xx = i.first + dx[r], yy = i.second + dy[r];if (ck(xx, yy) && d[xx][yy] == -1){q.push(pos(xx, yy));d[xx][yy] = d[i.first][i.second] + 1;}}}for (int i = 1; i <= n; i++){for (int j = 1; j <= m; j++){cout << left << setw(5) << d[i][j];}cout << endl;}
}

P1162 填涂颜色

算法：DFS, BFS，flood fill

有点毒瘤。从边界往里推，如果是空白就删掉，剩下的就是图形。

#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pos;
int n;
int in[31][31], co[31][31];
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
queue<pos> q;
bool ck(int x, int y)
{return x >= 1 && x <= n && y >= 1 && y <= n;
}
void bfs(int x, int y)
{pos i = pos(x, y);q.push(i);while (!q.empty()){pos p = q.front();q.pop();co[p.first][p.second] = 1;for (int d = 0; d < 4; d++){int xx = p.first + dx[d], yy = p.second + dy[d];if (ck(xx, yy) && in[xx][yy] == 0 && co[xx][yy] == 0){q.push(pos(xx, yy));}}}
}
int main()
{cin >> n;for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++){cin >> in[i][j];}}for (int i = 1; i <= n - 1; i++){if (in[1][i] == 0 && co[1][i] == 0)bfs(1, i);if (in[i][n] == 0 && co[i][n] == 0)bfs(i, n);if (in[n][n - i + 1] == 0 && co[n][n - i + 1] == 0)bfs(n, n - i + 1);if (in[n - i + 1][1] == 0 && co[n - i + 1][1] == 0)bfs(n - i + 1, 1);}for (int i = 1; i <= n; i++){for (int j = 1; j <= n; j++){if (in[i][j] == 0 && co[i][j] == 0)cout << 2;elsecout << in[i][j];cout << ' ';}cout << endl;}
}

P1506 拯救oibh总部

算法：DFS, BFS，flood fill

思路和上题一致。从边界往里推，遇到空白格子就删掉，最后数没被删掉的空白格子。

#include <bits/stdc++.h>
using namespace std;
int n, m;
bool wall[501][501];
bool vis[501][501];
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
struct node
{int x, y;node(int x, int y) : x(x), y(y) {}
};
bool valid(int x, int y)
{return x >= 1 && x <= n & y >= 1 && y <= m && !wall[x][y] && !vis[x][y];
}
void bfs(node s)
{queue<node> q;q.push(s);vis[s.x][s.y] = 1;while (!q.empty()){node head = q.front();q.pop();for (int i = 0; i < 4; i++){int xx = head.x + dx[i], yy = head.y + dy[i];if (!valid(xx, yy))continue;q.push(node(xx, yy));vis[xx][yy] = 1;}}
}
int main()
{cin >> n >> m;for (int i = 1; i <= n; i++){for (int j = 1; j <= m; j++){char c;cin >> c;if (c == '0')wall[i][j] = 0;elsewall[i][j] = 1;}}for (int i = 1; i <= m - 1; i++){if (valid(1, i))bfs(node(1, i));if (valid(n, m - i + 1))bfs(node(n, m - i + 1));}for (int i = 1; i <= n - 1; i++){if (valid(i, m))bfs(node(i, m));if (valid(n - i + 1, 1))bfs(node(n - i + 1, 1));}int ans = 0;for (int i = 1; i <= n; i++){for (int j = 1; j <= m; j++){if (valid(i, j))ans++;}}cout << ans << endl;
}

P1144 最短路计数

算法：dijkstra

跑dijkstra即可。关于计数，就是如果新方案和原方案的长度一样，那么就累加。累加时注意不能只加一，要把上一个节点的值都加上（不理解的可以看代码）。

#include <bits/stdc++.h>
using namespace std;
int n, m;
const int nmax = 1000001, mmax = 2000001, mod = 100003;
int fir[nmax], to[mmax], nxt[mmax], ecnt;
void add_edge(int u, int v)
{to[++ecnt] = v;nxt[ecnt] = fir[u];fir[u] = ecnt;
}
bool vis[nmax];
int dis[nmax];
int cnt[nmax];
int main()
{cin >> n >> m;for (int i = 1; i <= m; i++){int x, y;cin >> x >> y;add_edge(x, y);add_edge(y, x);}memset(dis, -1, sizeof(dis));queue<int> q;cnt[1] = 1;dis[1] = 0;q.push(1);while (!q.empty()){int h = q.front();q.pop();if (vis[h])continue;vis[h] = 1;for (int e = fir[h]; e; e = nxt[e]){if (vis[to[e]])continue;if (dis[to[e]] == -1){dis[to[e]] = dis[h] + 1;cnt[to[e]] = cnt[h] % mod;}else{if (dis[h] + 1 > dis[to[e]])continue;else if (dis[h] + 1 == dis[to[e]])cnt[to[e]] = (cnt[to[e]] + cnt[h]) % mod;elsedis[to[e]] = dis[h] + 1, cnt[to[e]]++;}q.push(to[e]);}}for (int i = 1; i <= n; i++){cout << cnt[i] << '\n';}
}

U68862 _GC滑迷宫（其实数据还是很蒻

算法：BFS

仍按迷宫问题思路即可，注意拓展时要while到墙。

#include <bits/stdc++.h>
using namespace std;
int n, m, sx, sy;
bool mat[501][501];
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
struct pos
{int x, y, step;pos(int x, int y, int step) : x(x), y(y), step(step) {}
};
queue<pos> q;
bool vis[501][501];
inline bool pan(int x, int y)
{return x >= 1 && x <= n && y >= 1 && y <= m && mat[x][y] == 0;
}
bool out(int x, int y)
{return (x == 1 || x == n || y == 1 || y == m) && mat[x][y] == 0;
}
int main()
{cin >> n >> m;for (int i = 1; i <= n; i++){for (int j = 1; j <= m; j++){cin >> mat[i][j];}}cin >> sx >> sy;if(mat[sx][sy]){cout<<-1;return 0;}if(out(sx,sy)){cout<<0;return 0;}q.push(pos(sx, sy, 0));vis[sx][sy] = 1;while (!q.empty()){pos h = q.front();q.pop();// cout << h.x << ' ' << h.y << endl;if (out(h.x, h.y)){cout << h.step - 1;return 0;}for (int i = 0; i < 4; i++){int xx = h.x, yy = h.y;while (pan(xx + dx[i], yy + dy[i])){xx += dx[i];yy += dy[i];}if ((xx == h.x && yy == h.y) || vis[xx][yy])continue;vis[xx][yy] = 1;q.push(pos(xx, yy, h.step + 1));}}cout << -1;
}

UVA532 Dungeon Master

算法：BFS

三维迷宫。

#include <bits/stdc++.h>
using namespace std;
int l, n, m;
struct pos
{int z, x, y, step;pos(int z, int x, int y, int step) : z(z), x(x), y(y), step(step) {}
};
int sz, sx, sy;
int tz, tx, ty;
bool mat[31][31][31];
bool vis[31][31][31];
const int dz[6] = {1, 0, 0, -1, 0, 0},dx[6] = {0, 1, 0, 0, -1, 0},dy[6] = {0, 0, 1, 0, 0, -1};
bool pan(int z, int x, int y)
{return z >= 1 && z <= l && x >= 1 && x <= n && y >= 1 && y <= m && mat[z][x][y] == 0;
}
int main()
{while (true){cin >> l >> n >> m;if (l == 0 && n == 0 && m == 0)break;for (int k = 1; k <= l; k++){for (int i = 1; i <= n; i++){for (int j = 1; j <= m; j++){char c;cin >> c;if (c == '.')mat[k][i][j] = 0;else if (c == '#')mat[k][i][j] = 1;else if (c == 'S'){mat[k][i][j] = 0;sz = k;sx = i;sy = j;}else if (c == 'E'){mat[k][i][j] = 0;tz = k;tx = i;ty = j;}else{cin >> c;}vis[k][i][j] = 0;}}}queue<pos> q;q.push(pos(sz, sx, sy, 0));vis[sz][sx][sy] = 1;bool flag = 1;while (!q.empty()){pos head = q.front();q.pop();if (head.z == tz && head.x == tx && head.y == ty){cout << "Escaped in " << head.step << " minute(s).\n";flag = 0;break;}for (int i = 0; i < 6; i++){int zz = head.z + dz[i], xx = head.x + dx[i], yy = head.y + dy[i];if (!pan(zz, xx, yy))continue;if (vis[zz][xx][yy])continue;q.push(pos(zz, xx, yy, head.step + 1));vis[zz][xx][yy] = 1;}}if (flag)cout << "Trapped!\n";}
}

P1379 八数码难题

算法：BFS

从初始状态开始，做BFS即可，每次转移时枚举空白格子的四个方向。

#include <bits/stdc++.h>
using namespace std;
int n;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
queue<int> q;
map<int, int> d;
bool valid(int x, int y)
{return x >= 0 && x <= 2 && y >= 0 && y <= 2;
}
int main()
{cin >> n;q.push(n);d[n] = 0;while (!q.empty()){int head = q.front();q.pop();if (head == 123804765)break;int state[3][3], x, y;int f = head;for (int i = 2; i >= 0; i--){for (int j = 2; j >= 0; j--){state[i][j] = f % 10;f /= 10;if (!state[i][j])x = i, y = j;}}for (int i = 0; i < 4; i++){int xx = x + dx[i], yy = y + dy[i];int st = 0;if (!valid(xx, yy))continue;swap(state[x][y], state[xx][yy]);for (int i = 0; i < 3; i++){for (int j = 0; j < 3; j++){st = st * 10 + state[i][j];}}if (!d.count(st)){d[st] = d[head] + 1;q.push(st);}swap(state[x][y], state[xx][yy]);}}cout << d[123804765] << endl;
}

UVA10603 倒水问题 Fill

算法：BFS or dijkstra

设水杯内水量为状态，倒水为转移，维护答案即可。当然也可以认为是dijkstra。

#include <bits/stdc++.h>
using namespace std;
int t;
struct node
{int v[3], dis;node(int a, int b, int c, int d){v[0] = a;v[1] = b;v[2] = c;dis = d;}
};
bool operator<(node x, node y)
{return x.dis > y.dis;
}
int c[3], d;
bool vis[201][201];
int dis[201][201];
int ans[201];
int main()
{cin >> t;while (t--){cin >> c[0] >> c[1] >> c[2] >> d;memset(vis, 0, sizeof(vis));memset(ans, -1, sizeof(ans));memset(dis, -1, sizeof(dis));priority_queue<node> q;q.push(node(0, 0, c[2], 0));dis[0][0] = 0;vis[0][0] = 1;while (!q.empty()){node head = q.top();q.pop();// if(vis[head.v[0]][head.v[1]])continue;// vis[head.v[0]][head.v[1]]=1;for (int i = 0; i < 3; i++){if (ans[head.v[i]] == -1)ans[head.v[i]] = head.dis;elseans[head.v[i]] = min(ans[head.v[i]], head.dis);}for (int i = 0; i < 3; i++){for (int j = 0; j < 3; j++){if (i == j)continue;int amount = min(head.v[i], c[j] - head.v[j]);node x = head;x.v[i] -= amount;x.v[j] += amount;x.dis += amount;if (vis[x.v[0]][x.v[1]])continue;if (dis[x.v[0]][x.v[1]] == -1 || dis[x.v[0]][x.v[1]] > x.dis){dis[x.v[0]][x.v[1]] = x.dis;vis[x.v[0]][x.v[1]] = 1;q.push(x);}}}}for (; d >= 0; d--){if (ans[d] >= 0){cout << ans[d] << ' ' << d << endl;break;}}}
}