最短路模板
dijikstra 优先队列优化 时间复杂度（nlogn)
用于一个点到其他点的最短距离且为单向路
//N条路,M条边
//输入u v w，表示u->v=w
#include<iostream>
#include<cstring>
#include<queue>
#include<limits.h>
using namespace std;
typedef long long ll;
const int N = 1e5;
typedef pair<ll,ll> PII;
ll pre[N]; // 记录前驱节点
ll dist[N];
ll h[N],e[N],w[N],ne[N],idx;//邻接表
int n,m;
bool st[N];//定义顶点状态，0：没用过；1：用过
void add(ll a,ll b,ll c)//储存边，由a到b长度为c
{
e[idx] = b,w[idx] = c,ne[idx] = h[a],h[a] = idx++;
}
void Dijkstra()
{
for(int i = 1;i <= n; i++)
{
dist[i] = LLONG_MAX;
pre[i] = -1; // 初始化前驱节点为-1
}
for(int i = 0;i <= n; i++)
dist[i] = LLONG_MAX;
dist[1] = 0;
priority_queue<PII,vector<PII>,greater<PII>> heap;//从小到大排列
heap.push({0,1});
while(heap.size())
{
auto t = heap.top();//取出最小距离的两点
heap.pop();
ll distance = t.first,ver = t.second;
//起始点到终点ver的距离为distance
if(st[ver])continue;//ver使用过则继续取出下一个点
st[ver] = true;//否则继续进行并标记为使用过
for(int i = h[ver];i != -1;i = ne[i])//加入与终点连接的边，继续选
{
ll j = e[i];
if(dist[j] > distance + w[i])
{
dist[j] = distance + w[i];
pre[j] = ver; // 更新前驱节点
heap.push({dist[j],j});
}
}
}
}
void printPath(int end)
{
if(end == 1)
{
cout<<"1"<<" "; // 没有前驱节点，即起点
return;
}
printPath(pre[end]); // 递归打印前驱节点
cout<<end << ' ';
}
int main()
{
memset(h,-1,sizeof h);
cin >> n >> m;
while(m--)
{
ll u,v,w;
cin >> u >> v >> w;
add(u,v,w);
}
Dijkstra();
for(int i = 2;i <= n; i++)
{
if(dist[i] == LLONG_MAX)
{
cout <<"到节点"<<i<<"的最短距离无限大" ;
}
else
{
cout <<"到节点"<<i<<"的最短距离为："<<dist[i] << endl;
cout<<"经过的节点：";
printPath(i); // 输出最短路径经过的节点
cout << endl;
}
}
return 0;
}floyd 时间复杂度O(n^3)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 405;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;
ll dis[N][N];
int n, m, q;
void floyd()
{
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
return;
}
int main()
{
cin >> n >> m >> q;
memset(dis, 0x3f, sizeof dis);
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i <= m; i++) {
ll u, v, w; cin >> u >> v >> w;
dis[u][v] = dis[v][u] = min(dis[u][v], w); // 防止出现重边
}
floyd();
// 输出
int s, t;
for (int i = 0; i < q; i++) {
cin >> s >> t;
ll ans = dis[s][t] == INF ? -1 : dis[s][t];
cout << ans << endl;
}
return 0;
}刷题
dfs
买瓜（十四届省赛大学A组真题）
#include <iostream>
#include <algorithm>
using namespace std;
int n, ans = 50; // n 为数字的数量，ans 为答案的初始值（设置为一个较大的值）
long long m, a[50], sum[50]; // m 为目标和，a 为数字数组，sum 为前缀和数组
// 深度优先搜索函数
void dfs(long long S, int pos, int cnt) {
//剪枝
// 如果当前步数已经大于或等于已知的最小步数，则无需继续搜索
if (cnt >= ans) return;
// 如果当前和等于目标和，则更新答案
if (S == m) ans = cnt; //由于比它大的上一步直接返回，所以一旦符合条件一定是更小的
// 如果位置超过数组长度，或当前和超过目标和，或加上剩余数的和仍然小于目标和，则无需继续搜索
if (pos > n || S > m || S + sum[pos] < m) return;
// 不选择当前数字
dfs(S, pos + 1, cnt);
// 选择当前数字
dfs(S + a[pos], pos + 1, cnt);
// 选择当前数字的一半（注意这里需要是整数，所以确保 a[pos] 是偶数）
// 并增加步数，因为使用了除法操作
dfs(S + a[pos] / 2, pos + 1, cnt + 1);
}
int main() {
cin >> n >> m;
// 既然每劈一道重量一分为二，那么直接把需要的质量翻倍，这样可以保证劈完的质量仍是一个整数
m <<= 1;
// 因为需要的质量翻倍，自然读取数字翻倍
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] <<= 1;
}
// 对数字进行降序排序，这样可以优先选择较大的数字
sort(a, a + n, greater<>());
// 计算前缀和数组
for (int i = n - 1; i >= 0; --i) {
sum[i] = sum[i + 1] + a[i];
}
// 从第一个位置开始深度优先搜索
dfs(0, 0, 0);
// 输出答案
if (ans == 50) {
cout << -1 << endl; // 如果ans的值仍然是初始值，说明没有找到解
} else {
cout << ans << endl; // 输出最小步数
}
return 0;
}蓝桥灭鼠先锋（十三届省赛大学A组真题）
#include <iostream>
#include <unordered_map>
#include <cstring>
#include <algorithm>
using namespace std;
int n = 8;
// 使用unordered_map来存储棋盘状态及其对应的胜负结果
unordered_map<string, bool> st; //无序，一个string对应一个是否可行的bool
// 辅助函数：检查当前棋盘状态下是否只有一个'O'
bool check(string str) {
int res = 0;
for (auto c : str) {
if (c == 'O') res++;
}
return res == 1; // 如果只有一个'O'，返回true
}
// 深度优先搜索函数，判断当前玩家是否为必胜态
bool dfs(string str) {
// 如果已经搜索过当前状态，则直接返回结果
if (st.count(str)) return st[str];
// 检查当前状态是否为败态（即只剩下一个'O'）
if (check(str)) {
st[str] = false; // 败态标记为false
return false;
}
// 尝试放一个子
for (int i = 0; i < n; i++) {
if (str[i] == 'X') continue; // 如果当前位置已经被对手占据，则跳过
string t = str;
t[i] = 'X'; // 在当前位置放一个子
if (!dfs(t)) { // 如果对手在下一轮处于败态
st[str] = true; // 当前状态为必胜态
return true;
}
}
// 尝试放两个子
// 注意：这里我们假设只能连续放两个子（相邻的），并且只能放在前三个位置
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
int k = i * 4 + j; // 计算当前两个连续位置的索引
if (str[k] == 'X' || str[k + 1] == 'X') continue; // 如果这两个位置中的任何一个已经被占据，则跳过
string t = str;
t[k] = t[k + 1] = 'X'; // 在这两个位置连续放两个子
if (!dfs(t)) { // 如果对手在下一轮处于败态
st[str] = true; // 当前状态为必胜态
return true;
}
}
}
// 如果所有可能的走法都不能使对手处于败态，则当前状态为败态
st[str] = false;
return false;
}
int main() {
// 初始棋盘状态数组
string be[] = {"XOOOOOOO", "XXOOOOOO", "OXOOOOOO", "OXXOOOOO"};
// 遍历初始棋盘每一种状态下的可能，并输出对应的结果（'L'表示当前玩家必败，'V'表示当前玩家必胜）
for (auto str : be) {
cout << (dfs(str) ? 'L' : 'V');
}
return 0;
}最大的数（十三届国赛大学B组真题）
#include <iostream>
using namespace std;
int a, b; // a 和 b 分别表示可以进行的两种操作的最大次数
string n; // 存储原始数字的字符串
long long ans; // 存储最大可能得到的数字
// 深度优先搜索函数，用于遍历所有可能的操作
void dfs(int x, long long an) // x 表示当前处理的位数，an 表示当前累加得到的数字
{
int t = n[x] - '0'; // 当前位的值（转换为整数）
// 如果当前位不是数字（即字符为 '\0'）
if (n[x] != '\0') // 注意：应该检查 n[x] 是否为 '\0' 而不是 n[x] 是否为 true（因为 n[x] 是一个字符）
{
// 步骤1: 尝试将当前位增加到最大
int c = min(a, 9 - t); // 计算当前位可以增加到最大需要的次数
a -= c; // 减去已经使用的次数
// 递归调用，处理下一位，并将当前位增加到最大
dfs(x + 1, an * 10 + c + t);
// 恢复 a 的值，以便进行其他可能的操作
a += c;
// 步骤2: 尝试将当前位变为 9（如果 b 的次数允许）
if (b > t) // 如果 b 的次数足够将当前位变为 9
{
b -= t + 1; // 减去将当前位变为 9 需要的次数
// 递归调用，处理下一位，并将当前位变为 9
dfs(x + 1, an * 10 + 9);
// 恢复 b 的值，以便进行其他可能的操作
b += t + 1;
}
}
else // 如果当前位是字符串的末尾（即没有更多的位数了）
{
// 更新 ans，取所有可能结果中的最大值
ans = max(ans, an);
}
}
int main()
{
cin >> n >> a >> b; // 输入原始数字、操作 a 的次数和操作 b 的次数
dfs(0, 0); // 从最高位（索引为 0）开始累加
cout << ans; // 输出最大可能得到的数字
return 0;
}飞机降落（十四届省赛大学B组真题）
#include <iostream>
using namespace std;
// 设定任务的最大数量为10（从1到10，共10个任务）
const int max_n = 11;
int N; // 任务的总数
int T[max_n], D[max_n], L[max_n]; // 分别存储每个飞机的最晚下降时间、盘旋时间和下降时间
bool used[max_n]; // 标记任务是否已经被使用
bool ha; // 标记是否找到了满足条件的任务序列
// 深度优先搜索函数，尝试在给定的时间t下安排任务x
void dfs(int x, int t)
{
// 如果已经找到了满足条件的任务序列，则不再继续搜索
if (ha) //剪枝
return;
// 如果已经安排了所有任务，则找到了一个满足条件的任务序列
if (x == N)
{
ha = 1;
return;
}
// 尝试每一个任务
for (int i = 1; i <= N; i++)
{
// 如果任务i尚未被使用，且当前时间t能够安排任务i
if (!used[i] && t <= T[i] + D[i])
{
// 标记任务i为已使用
used[i] = 1;
// 递归调用dfs，尝试安排下一个任务，此时新的开始时间为当前任务i的结束时间（max(t, T[i])）加上延迟时间L[i]
dfs(x + 1, max(t, T[i]) + L[i]);
// 如果找到了满足条件的任务序列，则不再继续搜索
if (ha)
return;
// 回溯，将任务i标记为未使用，以便尝试其他任务
used[i] = 0;
}
}
}
// 解决一个具体的问题
void solve()
{
cin >> N;
for (int i = 1; i <= N; i++)
{
cin >> T[i] >> D[i] >> L[i];
used[i] = 0; // 初始化任务为未使用状态
}
ha = 0; // 初始化标记为未找到满足条件的任务序列
dfs(0, 0); // 从时间0开始尝试安排任务
// 根据是否找到了满足条件的任务序列输出结果
if (ha)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main()
{
int K;
cin >> K;
// 循环处理每个测试用例
while (K--)
{
solve();
}
return 0;
}bfs
扫雷（十三届省赛大学B组真题）
#include <iostream>
#define x first
#define y second
using namespace std;
int n,m;
const int N=103;
int mp[N][N],vis[N][N];
int dy[8]={0,0,-1,-1,-1,1,1,1};
int dx[8]={1,-1,1,0,-1,1,0,-1};
int map[N][N];
void bfs(int x,int y)
{
for(int i=0;i<8;i++)
{
int xd=x+dx[i],yd=y+dy[i];
if(xd>=1&&xd<=n&&yd<=m&&yd>=1)
if(mp[xd][yd]==1) map[x][y]++;
}
}
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>mp[i][j];
}
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
if(mp[i][j]==1)
map[i][j]=9;
else
bfs(i,j);
}
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cout<<map[i][j]<<" ";
}
cout<<endl;
}
return 0;
}岛屿个数（十四届省赛大学B组真题）
#include <bits/stdc++.h>
using namespace std;
const int max_n = 51; // 假设地图的最大行数和列数都是50，所以数组大小设置为51（包括边界）
int M, N; // 地图的行数和列数
string mp[max_n]; // 存储地图数据的二维字符串数组
bool vis[max_n][max_n]; // 用于标记'1'岛屿（已经被访问过的岛屿）
bool used[max_n][max_n]; // 用于标记在逃跑过程中是否走过某个位置
// 定义八个方向（上、下、左、右、左上、右上、左下、右下）
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, 1, 1, -1, -1};
// 用于给'1'岛屿进行染色（即DFS遍历与当前岛屿相连的所有'1'）
void col_bfs(int x, int y)
{
queue<int> qx, qy;
qx.push(x); qy.push(y);
vis[x][y] = 1; // 标记当前位置为已访问
while (!qx.empty())
{
x = qx.front(); qx.pop();
y = qy.front(); qy.pop();
// 遍历四个方向（只考虑上下左右，因为岛屿是连续的）
for (int i = 0; i < 4; i++)
{
int nx = x + dx[i];
int ny = y + dy[i];
// 如果越界、已经被访问过、或者不是'1'岛屿，则跳过
if (nx < 0 || M <= nx || ny < 0 || N <= ny || vis[nx][ny] || mp[nx][ny] == '0') continue;
qx.push(nx); qy.push(ny);
vis[nx][ny] = 1; // 标记新位置为已访问
}
}
}
// 判断从给定的'1'岛屿是否可以逃出去（到达地图的边界）
bool bfs_out(int x, int y)
{
// 初始化used数组为未走过
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
used[i][j] = 0;
queue<int> qx, qy;
qx.push(x); qy.push(y);
used[x][y] = 1; // 标记起始位置为已走过
while (!qx.empty())
{
x = qx.front(); qx.pop();
y = qy.front(); qy.pop();
// 如果到达边界，则返回true
if (x == 0 || x == M - 1 || y == 0 || y == N - 1) return true;
// 遍历八个方向
for (int i = 0; i < 8; i++)
{
int nx = x + dx[i];
int ny = y + dy[i];
// 如果越界、已经走过、或者是'1'岛屿，则跳过
if (nx < 0 || M <= nx || ny < 0 || N <= ny || used[nx][ny] || mp[nx][ny] == '1') continue;
qx.push(nx); qy.push(ny);
used[nx][ny] = 1; // 标记新位置为已走过
}
}
// 如果没有到达边界，则返回false
return false;
}
void solve()
{
cin >> M >> N; // 输入地图的行数和列数
// 读入地图数据
for (int i = 0; i < M; i++)
{
cin >> mp[i];
for (int j = 0; j < N; j++)
vis[i][j] = 0; // 初始化vis数组为未访问
}
int ans = 0; // 用于记录可以逃出去的'1'岛屿数量
//对‘1’进行染色
for(int i=0;i<M;i++)
for(int j=0;j<N;j++)
if(!vis[i][j] && mp[i][j]=='1'){
col_bfs(i,j);
//看看能否逃出
if(bfs_out(i,j)) ans++;
}
cout<<ans<<endl;
}
int main()
{
int t;
cin>>t;
while(t--) solve();
return 0;
}
197
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
