目录
连通性模型
1112. 迷宫
一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由 n∗n 的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。
同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。
如果起点或者终点有一个不能通行(为#)，则看成无法办到。
注意：A、B不一定是两个不同的点。
输入格式
第1行是测试数据的组数 k，后面跟着 k 组输入。
每组测试数据的第1行是一个正整数 nn，表示迷宫的规模是 n∗n 的。
接下来是一个 n∗n 的矩阵，矩阵中的元素为.或者#。
再接下来一行是 4 个整数 ha,la,hb,lb，描述 A 处在第 ha 行, 第 la 列，B 处在第 hb 行, 第 lb 列。
注意到 ha,la,hb,lb 全部是从 0 开始计数的。
输出格式
k行，每行输出对应一个输入。
能办到则输出“YES”，否则输出“NO”。
数据范围
1≤n≤100
输入样例：
2
3
.##
..#
#..
0 0 2 2
5
.....
###.#
..#..
###..
...#.
0 0 4 0
输出样例:
YES
NO
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n;
int xa, xb, ya, yb;
char g[N][N];
bool st[N][N];
int dist[N][N];
int dx[4] = {0, 0, -1, 1}, dy[4] = {1, -1, 0, 0};
bool dfs(int x, int y)
{
if (g[x][y] == '#') return false;
if (x == xb && y == yb) return true;
st[x][y] = true;
for (int i = 0; i < 4; i ++)
{
int a = x + dx[i], b = y + dy[i];
if (a < 0 || a >= n || b < 0 || b >= n) continue;
if (st[a][b]) continue;
if (dfs(a, b)) return true;
}
return false;
}
int main()
{
int t;
cin >> t;
while (t --)
{
cin >> n;
for (int i = 0; i < n; i ++) scanf("%s", g[i]);
cin >> xa >> ya >> xb >> yb;
memset(st, 0, sizeof st); //多组数据记得初始化st数组
if (dfs(xa, ya)) cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
}1113. 红与黑
有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。
你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。
请写一个程序，计算你总共能够到达多少块黑色的瓷砖。
输入格式
输入包括多个数据集合。
每个数据集合的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量。
在接下来的 HH 行中，每行包括 W 个字符。每个字符表示一块瓷砖的颜色，规则如下
1）‘.’：黑色的瓷砖；
2）‘#’：红色的瓷砖；
3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。
当在一行中读入的是两个零时，表示输入结束。
输出格式
对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。
数据范围
1≤W,H≤20
输入样例：
6 9
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
0 0
输出样例：
45
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int n, m;
char g[N][N];
bool st[N][N];
int dx[4] = {0, -1, 0, 1}, dy[4] = {-1, 0, 1, 0};
int dfs(int x, int y)
{
int cnt = 1;
st[x][y] = true;
for (int i = 0; i < 4; i ++)
{
int a = x + dx[i], b = y + dy[i];
if (a < 0 || a >= n || b < 0 || b >= m) continue;
if (st[a][b]) continue;
if (g[a][b] == '#') continue;
cnt += dfs(a, b);
}
return cnt;
}
int main()
{
while (cin >> m >> n, n || m)
{
for (int i = 0; i < n; i ++)
scanf("%s", g[i]);
int x, y;
for (int i = 0; i < n; i ++)
for (int j = 0; j < m; j ++)
if (g[i][j] == '@')
{
x = i;
y = j;
}
memset(st, 0, sizeof st);
printf("%d\n", dfs(x, y));
}
return 0;
}搜索顺序
1116. 马走日
马在中国象棋以日字形规则移动。
请编写一段程序，给定 n∗m 大小的棋盘，以及马的初始位置 (x，y)，要求不能重复经过棋盘上的同一个点，计算马可以有多少途径遍历棋盘上的所有点。
输入格式
第一行为整数 T，表示测试数据组数。
每一组测试数据包含一行，为四个整数，分别为棋盘的大小以及初始位置坐标 n,m,x,y。
输出格式
每组测试数据包含一行，为一个整数，表示马能遍历棋盘的途径总数，若无法遍历棋盘上的所有点则输出 0。
数据范围
1≤T≤9,
1≤m,n≤99,
1≤n×m≤28,
0≤x≤n−1,
0≤y≤m−1
输入样例：
1
5 4 0 0
输出样例：
32
#include <bits/stdc++.h>
using namespace std;
const int N = 15;
int n, m;
int ans;
bool st[N][N];
int dx[8] = {2, 2, -2, -2, 1, 1, -1, -1};
int dy[8] = {1, -1, 1, -1, 2, -2, 2, -2};
void dfs(int x, int y, int cnt)
{
if (cnt == n * m)
{
ans ++;
return;
}
st[x][y] = true; //与恢复现场位置对应
for (int i = 0; i < 8; i ++)
{
int a = x + dx[i], b = y + dy[i];
if (a < 0 || a >= n || b < 0 || b >= m) continue;
if (st[a][b]) continue;
dfs(a, b, cnt + 1);
}
st[x][y] = false;
}
int main()
{
int t;
cin >> t;
while (t --)
{
int x, y;
cin >> n >> m >> x >> y;
memset(st, 0, sizeof st); //多组数据记得初始化
ans = 0;
dfs(x, y, 1);
printf("%d\n", ans);
}
return 0;
}1117. 单词接龙
单词接龙是一个与我们经常玩的成语接龙相类似的游戏。
现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”， 每个单词最多被使用两次。
在两个单词相连时，其重合部分合为一部分，例如 beast 和 astonish ，如果接成一条龙则变为 beastonish。
我们可以任意选择重合部分的长度，但其长度必须大于等于1，且严格小于两个串的长度，例如 at 和 atide 间不能相连。
输入格式
输入的第一行为一个单独的整数 n 表示单词数，以下 n 行每行有一个单词（只含有大写或小写字母，长度不超过20），输入的最后一行为一个单个字符，表示“龙”开头的字母。
你可以假定以此字母开头的“龙”一定存在。
输出格式
只需输出以此字母开头的最长的“龙”的长度。
数据范围
n≤20，
单词随机生成。
输入样例：
5
at
touch
cheat
choose
tact
a
输出样例：
23
提示
连成的“龙”为 atoucheatactactouchoose。
substr(size_type _Off = 0,size_type _Count = npos)
一种构造string的方法
形式 ： s.substr(pos, len)
返回值： string，包含s中从pos开始的len个字符的拷贝（pos的默认值是0，len的默认值是s.size() - pos，即不加参数会默认拷贝整个s）
异常 ：若pos的值超过了string的大小，则substr函数会抛出一个out_of_range异常；若pos+n的值超过了string的大小，则substr会调整n的值，只拷贝到string的末尾
注意：string类型用cin读入
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int n;
int g[N][N];
string word[N];
int ans;
int used[N]; //记录使用次数
void dfs(string dragon, int last)
{
ans = max(ans, (int)dragon.size());
used[last] ++;
for (int i = 0; i < n; i ++)
if (g[last][i] && used[i] < 2)
dfs(dragon + word[i].substr(g[last][i]), i);
used[last] --;
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++) cin >> word[i];
char start;
cin >> start;
for (int i = 0; i < n; i ++)
for (int j = 0; j < n; j ++)
{
string a = word[i], b = word[j];
for (int k = 1; k < min(a.size(), b.size()); k ++)
if (a.substr(a.size() - k, k) == b.substr(0, k))
{
g[i][j] = k;
break;
}
}
for (int i = 0; i < n; i ++)
if (word[i][0] == start)
dfs(word[i], i);
cout << ans;
return 0;
}1118. 分成互质组
给定 n 个正整数，将它们分组，使得每组中任意两个数互质。
至少要分成多少个组？
输入格式
第一行是一个正整数 n。
第二行是 n 个不大于10000的正整数。
输出格式
一个正整数，即最少需要的组数。
数据范围
1≤n≤10
输入样例：
6
14 20 33 117 143 175
输出样例：
3
#include <bits/stdc++.h>
using namespace std;
const int N = 15;
int n;
int p[N];
int ans = N;
int g[N][N];
bool st[N];
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}
bool check(int g[], int x, int end)
{
for (int i = 0; i < end; i ++)
if (gcd(g[i], x) > 1) return false;
return true;
}
//当前要放在哪个分组；要放在该分组的第几个位置；从哪个位置开始选择元素【组合套路(定一个遍历顺序)】；当前已分组完毕的元素个数
void dfs(int gr, int gc, int start, int cnt)
{
if (gr >= ans) return;
if (cnt == n) ans = gr;
bool flag = true; //从start开始找，是否有元素不能放到gr组中
for (int i = start; i < n; i ++)
if (!st[i] && check(g[gr], p[i], gc))
{
st[i] = true;
g[gr][gc] = p[i];
dfs(gr, gc + 1, start + 1, cnt + 1);
st[i] = false;
flag = false;
}
if (flag) dfs(gr + 1, 0, 0, cnt);
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++) cin >> p[i];
dfs(1, 0, 0, 0);
cout << ans;
return 0;
}剪枝与优化
- 优化搜索顺序（优先搜索分支节点较少的节点）
- 排除等效冗余
- 可行性剪枝
- 最优化剪枝
- 记忆化搜索（DP）
165. 小猫爬山
翰翰和达达饲养了 N 只小猫，这天，小猫们要去爬山。
经历了千辛万苦，小猫们终于爬上了山顶，但是疲倦的它们再也不想徒步走下山了（呜咕>_<）。
翰翰和达达只好花钱让它们坐索道下山。
索道上的缆车最大承重量为 W，而 N 只小猫的重量分别是 C1、C2……CN。
当然，每辆缆车上的小猫的重量之和不能超过 W。
每租用一辆缆车，翰翰和达达就要付 1 美元，所以他们想知道，最少需要付多少美元才能把这 N 只小猫都运送下山？
输入格式
第 1 行：包含两个用空格隔开的整数，N 和 W。
第 2..N+1 行：每行一个整数，其中第 i+1i+1 行的整数表示第 ii 只小猫的重量 Ci。
输出格式
输出一个整数，表示最少需要多少美元，也就是最少需要多少辆缆车。
数据范围1≤N≤18,
1≤Ci≤W≤108
输入样例：
5 1996
1
2
1994
12
29
输出样例：
2
优先搜索重量更大的小猫，减少搜索树的分支
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int n, m;
int w[N];
int sum[N];
int ans = N;
void dfs(int u, int k) //第u只小猫，并且已用了k个缆车
{
if (k >= ans) return; //最优化剪枝
if (u == n)
{
ans = k;
return;
}
for (int i = 0; i < k; i ++)
if (sum[i] + w[u] <= m) //可行性剪枝
{
sum[i] += w[u];
dfs(u + 1, k);
sum[i] -= w[u];
}
sum[k] = w[u];
dfs(u + 1, k + 1);
sum[k] = 0;
}
int main()
{
cin >> n >> m;
for (int i = 0; i < n; i ++) scanf("%d", &w[i]);
sort(w, w + n, greater<int>()); //优化搜索顺序
dfs(0, 0);
cout << ans;
return 0;
}166. 数独
数独 是一种传统益智游戏，你需要把一个 9×9 的数独补充完整，使得数独中每行、每列、每个 3×3 的九宫格内数字 1∼9 均恰好出现一次。
请编写一个程序填写数独。
输入格式
输入包含多组测试用例。
每个测试用例占一行，包含 81 个字符，代表数独的81 个格内数据（顺序总体由上到下，同行由左到右）。
每个字符都是一个数字（1−9）或一个 .（表示尚未填充）。
您可以假设输入中的每个谜题都只有一个解决方案。
文件结尾处为包含单词 end 的单行，表示输入结束。
输出格式
每个测试用例，输出一行数据，代表填充完全后的数独。
输入样例：
4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......
......52..8.4......3...9...5.1...6..2..7........3.....6...1..........7.4.......3.
end
输出样例：
417369825632158947958724316825437169791586432346912758289643571573291684164875293
416837529982465371735129468571298643293746185864351297647913852359682714128574936
#include <bits/stdc++.h>
using namespace std;
const int N = 9, M = 1 << N;
//row, col, cell分别存储行、列、方格对应的二进制数，表示1~9数字的状态，0表示已用，1表示未用
int ones[M], maps[M];//预处理ones记录该二进制数中有几个1, maps该二进制数对应的可以填哪个数
int row[N], col[N], cell[3][3];
char str[100];
int init() //初始化，将每一行、列、3*3方格都置为9个1，表示每个数字都可以使用
{
for (int i = 0; i < N; i ++)
row[i] = col[i] = (1 << N) - 1;
for (int i = 0; i < 3; i ++)
for (int j = 0; j < 3; j ++)
cell[i][j] = (1 << N) - 1;
}
//is_set = true则在x, y填上数t+1, 否则则把x,y处的数字删掉, t是0-8
void draw(int x, int y, int t, bool is_set)
{
if (is_set) str[x * N + y] = '1' + t;
else str[x * N + y] = '.';
int v = 1 << t;
if (!is_set) v = -v;
row[x] -= v;
col[y] -= v;
cell[x / 3][y / 3] -= v;
}
int lowbit(int x)
{
return x & -x;
}
//返回当前位置可能的选择的数值（只有行列方格都为1才能填）
int get(int x, int y)
{
return row[x] & col[y] & cell[x / 3][y / 3];
}
//cnt记录还有几个空格未填
bool dfs(int cnt)
{
if (!cnt) return true;
//搜索顺序优化
//找出可以填的数字选择最少的开始，使搜索树的分支数量少
int minv = 10;
int x, y;
for (int i = 0; i < N; i ++)
for (int j = 0; j < N; j ++)
if (str[i * N + j] == '.')
{
int state = get(i, j);
if (ones[state] < minv)
{
minv = ones[state];
x = i, y = j;
}
}
int state = get(x, y);
for (int i = state; i; i -= lowbit(i))
{
int t = maps[lowbit(i)];
draw(x, y, t, true);
if (dfs(cnt - 1)) return true;
draw(x, y, t, false);
}
return false;
}
int main()
{
for (int i = 0; i < N; i ++) maps[1 << i] = i;
for (int i = 0; i < 1 << N; i ++)
for (int j = 0; j < N; j ++)
ones[i] += i >> j & 1;
while (cin >> str, str[0] != 'e')
{
init();
int cnt = 0;
for (int i = 0; i < N; i ++)
for (int j = 0; j < N; j ++)
if (str[i * N + j] != '.')
{
int t = str[i * N + j] - '1'; //记得减一与draw函数对应
draw(i, j, t, true);
}
else cnt ++;
dfs(cnt);
puts(str);
}
return 0;
}167. 木棒
乔治拿来一组等长的木棒，将它们随机地砍断，使得每一节木棍的长度都不超过 50 个长度单位。
然后他又想把这些木棍恢复到为裁截前的状态，但忘记了初始时有多少木棒以及木棒的初始长度。
请你设计一个程序，帮助乔治计算木棒的可能最小长度。
每一节木棍的长度都用大于零的整数表示。
输入格式
输入包含多组数据，每组数据包括两行。
第一行是一个不超过 64 的整数，表示砍断之后共有多少节木棍。
第二行是截断以后，所得到的各节木棍的长度。
在最后一组数据之后，是一个零。
输出格式
为每组数据，分别输出原始木棒的可能最小长度，每组数据占一行。
数据范围
数据保证每一节木棍的长度均不大于 50。
输入样例：
9
5 2 1 5 2 1 5 2 1
4
1 2 3 4
0
输出样例：
6
5
#include <bits/stdc++.h>
using namespace std;
const int N = 70;
int n;
int h[N];
int sum, length;
bool st[N];
//u表示第几组，cur表示当前组已有长度，start表示从第几个木棍开始
bool dfs(int u, int cur, int start)
{
if (u * length == sum) return true; //即全部分配成功
if (cur == length) return dfs(u + 1, 0, 0);//当前组已经满了，递归新的一组（下一组），注意return
for (int i = start; i < n; i ++)
{
if (st[i] || cur + h[i] > length) continue; //该木棍已经使用或者该木棍长度过大
st[i] = true;
if (dfs(u, cur + h[i], i)) return true; //将该木棍加入递归
st[i] = false;
if (!cur) return false; //头剪枝 若第一根就失败那么全都不行
if (cur + h[i] == length) return false; //尾剪枝 若最后一根失败那么也不行
//排除等效冗余
int j = i;
while (j < n && h[j] == h[i]) j ++; //如果后面的与当前木棍长度相同（因为当前棍匹配失败）
//则该棍也失败那么直接跳过
i = j - 1;
}
return false;
}
int main()
{
while (cin >> n, n)
{
sum = 0; //多组数据 初始化
memset(st, 0, sizeof st);
for (int i = 0; i < n; i ++)
{
scanf("%d", &h[i]);
sum += h[i]; //记录所有木棍总长度
}
//优化搜索顺序 减少分支
sort(h, h + n, greater<int>()); //将木棍从大到小排序
length = 1; //将木棒大小从1开始遍历 找到第一个可行解，即为所求最小值
while (true)
{
if (sum % length == 0 && dfs(0, 0, 0)) //易得sum%length==0
{
cout << length << endl;
break;
}
length ++;
}
}
return 0;
}168. 生日蛋糕
7 月 17 日是 Mr.W 的生日，ACM-THU 为此要制作一个体积为Nπ 的M 层生日蛋糕，每层都是一个圆柱体。
设从下往上数第 i 层蛋糕是半径为 Ri，高度为 Hi 的圆柱。
当 i<M 时，要求 Ri>Ri+1 且 Hi>Hi+1。
由于要在蛋糕上抹奶油，为尽可能节约经费，我们希望蛋糕外表面（最下一层的下底面除外）的面积 Q 最小。
令 Q=Sπ ，请编程对给出的N 和M，找出蛋糕的制作方案（适当的Ri 和 Hi 的值），使 S 最小。
除 Q 外，以上所有数据皆为正整数。
输入格式
输入包含两行，第一行为整数 N，表示待制作的蛋糕的体积为 Nπ。
第二行为整数 M，表示蛋糕的层数为 M。
输出格式
输出仅一行，是一个正整数 S（若无解则 S=0）。
数据范围
1≤N≤10000,
1≤M≤20
输入样例：
100
2
输出样例：
68
#include <bits/stdc++.h>
using namespace std;
const int N = 25, INF = 1e9;
int n, m;
int mins[N], minv[N];
int R[N], H[N]; //记录每一层r和h
int ans = INF;
//当前层u，已经累加的体积和v,已经累加的面积和s
void dfs(int u, int v, int s)
{
if (v + minv[u] > n) return;
if (s + mins[u] >= ans) return; //最优性剪枝
if (s + 2 * (n - v) / R[u + 1] >= ans) return;
if (!u)
{
if (n == v) ans = s;
return ;
}
//优化搜索顺序
for (int r = min(R[u + 1] - 1, (int)sqrt(n - v)); r >= u; r --)
for (int h = min(H[u + 1] - 1, (n - v) / r / r); h >= u; h --)
{
int t = 0;
if (u == m) t = r * r;
R[u] = r, H[u] = h;
dfs(u - 1, v + r * r * h, s + 2 * r * h + t);
}
}
int main()
{
cin >> n >> m;
for (int i = 1; i <= m; i ++)
{
minv[i] = minv[i - 1] + i * i * i;
mins[i] = mins[i - 1] + 2 * i * i;
}
R[m + 1] = H[m + 1] = INF;
dfs(m, 0, 0);
if (ans == INF) ans = 0;
cout << ans << endl;
return 0;
}
1200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
