A - 棋盘问题
题目描述：
在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。
输入格式
输入含有多组测试数据。
每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n <= 8 , k <= n
当为-1 -1时表示输入结束。
随后的n行描述了棋盘的形状：每行有n个字符，其中 # 表示棋盘区域， . 表示空白区域（数据保证不出现多余的空白行或者空白列）。
输出格式
对于每一组数据，给出一行输出，输出摆放的方案数目C （数据保证C<2^31）。
输入样例
2 1
#.
.#
4 4
…#
…#.
.#…
#…
-1 -1
输出样例
2
1
代码详情
主要是考虑插 和 不插 棋子 这两种情况
#include<stdio.h>
#include<string.h>
char s[10][10];
int vis[10], n, k, c, y;
void dfs(int row) {
if (y == k) {
c++;
return ;
}
if(row >= n)return;//判断边界
//在第 i 行插入棋子
for (int j = 0; j < n; j++) {
if (s[row][j] == '#' && vis[j] == 0) {
vis[j] = 1;
y++;
dfs(row + 1);
vis[j] = 0;
y--;
}
}
//不插入棋子
dfs(row+1);
return ;
}
int main(){
while(1) {
scanf("%d%d", &n, &k);
c = 0, y = 0;
if (n == -1 && k == -1)break;
for(int i = 0; i < n; i++){
scanf("%s", s[i]);
}
dfs(0);
printf("%d\n", c);
}
}
B - Perket
题目描述：
你有 NNN 种配料，每种配料有酸度 SSS 和苦度 BBB 。用这些配料做成Perket时，总的酸度为所有配料酸度的乘积，总的苦度是所有配料苦度的和。你至少需要添加一种配料。
为了使口感适中，总的酸度和苦度之差的绝对值应该尽可能小，求这个最小值。
输入格式
第一行 1 个整数 N (1≤N≤10)—— 配料的数量。
接下来 NNN 行每行 2 个整数 Si 和 Bi —— 每种配料的酸度和苦度。如果用所有配料来做Perket，总的酸度和苦度都 ≤10^9 。
输出格式
N 行，每行 1个整数 —— 所求的最小值。
输入样例1
1
3 10
输出样例1
7
输入样例2
2
3 8
5 8
输出样例2
1
输入样例3
4
1 7
2 6
3 8
4 9
输出样例3
1
代码
主要还是和上一题一样，涉及到一个选和不选的问题
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int pl, s[12][2], min = 9999999, n;
void dfs(int t, int x, int y) {
if (t == n) {
if (x==1 && y==0) return ;
else {
if (min > abs(x - y)) min = abs(x-y);
}
return ;
}
dfs(t+1, x, y);
dfs(t+1, x*s[t][0], y+s[t][1]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &s[i][0], &s[i][1]);
}
dfs(0, 1, 0);
printf("%d", min);
}
C - 全排列
题目描述：
给定一个由不同的小写字母组成的字符串，输出这个字符串的所有全排列。 我们假设对于小写字母有 ‘a’ < ‘b’ < … < ‘y’ < ‘z’，而且给定的字符串中的字母已经按照从小到大的顺序排列。
输入格式
输入只有一行，是一个由不同的小写字母组成的字符串，已知字符串的长度在 1 到 6 之间。
输出格式
输出这个字符串的所有排列方式，每行一个排列。要求字母序比较小的排已知 S=s1 s2…sk, T=t1 t2…tk，则 S<T 等价于，存在 p(1≤p≤k)，使得s1=t1,s2=t2,…,sp−1=tp−1,sp<tp 成立。
输入样例
abc
输出样例
abc
acb
bac
bca
cab
cba
代码
说了这么多，其实就是全排列列问题
#include<stdio.h>
#include<string.h>
int book[26];
char s[7], t[7];
void dfs(int step) {
int a = strlen(s);
if (step == a + 1) {
for (int i = 0; i <= 6; i++){
if (t[i] >= 'a' && t[i] <= 'z') {
printf("%c", t[i]);
}
}
printf("\n");
return ;
}
// int i = a - 1;
for (int i = 0; i < a; i++) {
if (book[s[i] - 'a' ] == 0) {
t[step] = s[i];
book[s[i] - 'a' ] = 1;
dfs(step + 1);
book[s[i] - 'a' ] = 0;
}
}
return ;
}
int main() {
scanf("%s", s);
dfs(1);
return 0;
}
D - 自然数拆分
题目描述：
对于任意大于 1 的自然数 n，总是可以拆分成若干个小于 n的自然数之和。
现请你编写程序求出 n的所有拆分。
输入格式
输入文件共一行，包含一个自然数，即要拆分的自然数 n(1≤n≤20)。
输出格式
输出文件有若干行，每行包含一个等式，即代表一种可行的拆分（格式与顺序参见样例）。
输入样例
5
输出样例
5=1+1+1+1+1
5=1+1+1+2
5=1+1+3
5=1+2+2
5=1+4
5=2+3
代码
很经典的dfs回溯
#include<stdio.h>
int n, a[22];
void dfs(int x,int r) {
if (r == 0 && x > 1) {
printf("%d=", n);
for (int i=0; i<(x-1); i++) {
printf("%d+", a[i]);
}
printf("%d\n", a[x-1]);
return ;
}
// 错写成了，i < n，只输出了一列
// n 的话不会刷新，所以只能输出一次，回溯无效
for (int i = 1; i <= r; i++) {
if (i >= a[x-1]) {
a[x] = i;
r -= i;
dfs(x+1, r);
a[x] = 0;
r = r + i;
}
}
return ;
}
int main(){
scanf("%d", &n);
dfs(0, n);
}
E - Prime Ring Problem
题目描述：
输入正整数 n，把整数 1,2,…,n 排成一个环，使得相邻两个整数之和均为素数。输出时，从整数 1 开始逆时针排列。同一个环恰好输出一次。n≤16，保证一定有解。
多组数据，读入到EOF结束。
第 i 组数据输出前加上一行Case i:
相邻两组输出中间加上一个空行。
输入样例
6
8
输出样例
Case 1:
1 4 3 2 5 6
1 6 5 2 3 4
中间空一格
Case 2:
1 2 3 8 5 6 7 4
1 2 5 8 3 4 7 6
1 4 7 6 5 8 3 2
1 6 7 4 3 8 5 2
输出格式提示
行末无空格
最后一个Case输出后不换行
代码
#include<stdio.h>
#include<string.h>
int book[20], a[20], n, q;
int pp[35]= {0,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0};
void dfs(int x) {
if (x == n && pp[a[0] + a[n-1]]) {
printf("\n%d", a[0]);
for (int i = 1; i < n; i++) {
printf(" %d", a[i]);
}
// printf("\n");//
return ;
}
if (x == n)return;
for (int k = 2; k <= n; k++) {
if (!book[k] && pp[a[x-1] + k]) {//再选的时候直接判断是不是素数，节省时间，如果像我刚开始一样 最后才判断，太慢了
book[k] = 1;
a[x] = k;
dfs(x+1);
a[x] = 0;//要不要都无所谓，最后会被覆盖掉
book[k] = 0;
}
}
}
int main() {
while(scanf("%d", &n) != EOF) {
memset(book, 0, sizeof(book));
memset(a, 0, sizeof(a));
if(++q==1) {
printf("Case %d:", q);
} else {
printf("\nCase %d:", q);//拼凑格式
}
a[0] = 1;
dfs(1);
printf("\n");//拼凑格式
}
}
F - Red and Black
题目描述：
有一个长方形的房间，覆盖了正方形的磁砖。每块磁砖的颜色，要么是红色，要么是黑色。一名男子站在一块黑色的磁砖上。他可以从一块磁砖移至相邻四块磁砖中的某一块。但是，他不允许在红色磁砖上移动，他只允许在黑色磁砖上移动。
编写一个程序，使得他允许重复上述的移动，判断他所能到达的黑色磁砖的数量。
输入格式
输入由多个数据集组成。数据集的起始行包含了两个正整数 W 和 H；W 和 H 分别是 x- 和 y- 方向的磁砖数量。W 和 H 不超过 20 。
在数据集中，还有 H 行，每行包含了 W 个字符。每个字符按如下方式表示一块磁砖的颜色。
‘.’ - 一块黑色的磁砖
‘#’ - 一块红色的磁砖
‘@’ - 一名男子，站在一块黑色磁砖上 (在一个数据集中，恰好出现一次)
以包含两个 0 的一行，表示输入结束。
输出格式
对于每个数据集，程序应当输出一行，包含他从初始磁砖所能抵达的磁砖数量 (包括初始磁砖自身)。
输入样例
6 9
…#.
…#
…
…
…
…
…
#@…#
.#…#.
11 9
.#…
.#.#######.
.#.#…#.
.#.#.###.#.
.#.#…@#.#.
.#.#####.#.
.#…#.
.#########.
…
11 6
…#…#…#…
…#…#…#…
…#…#…###
…#…#…#@.
…#…#…#…
…#…#…#…
7 7
…#.#…
…#.#…
###.###
…@…
###.###
…#.#…
…#.#…
0 0
输出样例
45
59
6
13
代码
典型的BFS搜索的例子
#include<stdio.h>
#include<string.h>
struct note {
int x;
int y;
}que[450];
int main() {
int next[4][2] = {0,1,1,0,0,-1,-1,0};
int sx, sy, cnt=1, tx, ty, w, h;
while(1) {
char s[22][22]={0};
int book[22][22]={0};
scanf("%d %d", &w, &h);
// getchar();
if (w ==0 && h == 0)break;
for (int i = 1; i <= h; i++) {
getchar();
for (int j = 1; j <= w; j++) {
scanf("%c", &s[i][j]);
if (s[i][j] == '@') {
sx = i;
sy = j;
}
}
}
book[sx][sy] = 1;
int head = 1;
int tail = 1;
que[tail].x=sx;
que[tail].y=sy;
tail++;
while(head < tail) {
for (int k = 0; k<=3; k++) {
// 向四周走
tx = que[head].x + next[k][0];
ty = que[head].y + next[k][1];
// 判断边界
if (tx <= 0 || tx > h || ty <= 0 || ty > w) continue;
if (book[tx][ty] == 0 && s[tx][ty] == '.') {
book[tx][ty] = 1;//忘记标记了
que[tail].x = tx;
que[tail].y = ty;
tail++;
cnt++;
}
}
head++;
}
printf("%d\n", cnt);
cnt = 1;
}
}
G - Knight Moves
题目描述：
原题来自：POJ 1915
编写一个程序，计算一个骑士从棋盘上的一个格子到另一个格子所需的最小步数。骑士一步可以移动到的位置由下图给出。
输入格式
第一行给出骑士的数量 n。
在接下来的 3n 行中，每 3 行描述了一个骑士。其中，
第一行一个整数 L表示棋盘的大小，整个棋盘大小为 L x L ；
第二行和第三行分别包含一对整数 (x,y)，表示骑士的起始点和终点。假设对于每一个骑士，起始点和终点均合理。
输出格式
对每一个骑士，输出一行一个整数表示需要移动的最小步数。如果起始点和终点相同，则输出 0。
输入样例
3
8
0 0
7 0
100
0 0
30 50
10
1 1
1 1
输出样例
5
28
0
数据范围与提示
对于 100%的数据，有 4≤L≤300，保证 0≤x,y≤L−1.
代码
还是BFS比较简单一点吧
#include<stdio.h>
#include<string.h>//错误原因： 2，第二个点坐标算错了
int next[8][2]={-2,1, -1,2, 1,2, 2,1, 2,-1, 1,-2, -1,-2, -2,-1};
struct note {
int x, y, step;
}que[100005];//错误原因：1，数组开小了，计算错了300*300;
int main() {
int mp[310][310], l, n, sx, sy, fx, fy, book[310][310];
scanf("%d", & n);
while (n--) {
scanf("%d", &l);
scanf("%d%d", &sx, &sy);
scanf("%d%d", &fx, &fy);
/* if (sx==fx && sy==fy) {
printf("0\n");
continue;
}*/
int min = 9999999;
memset(book, 0, sizeof(book));
int flag =0;
int head=1, tail=1;
que[tail].x=sx;
que[tail].y=sy;
que[tail].step = 0;
tail++;
int tx, ty;
while (head < tail) {
if(que[head].x ==fx&& que[head].y==fy)
{
printf("%d\n",que[head].step);
break;
}
for(int k=0; k<8; k++) {
tx = que[head].x + next[k][0];
ty = que[head].y + next[k][1];
//判断边界
if(tx < 0 || tx >= l || ty < 0 || ty >= l)
continue ;
if(!book[tx][ty]) {
book[tx][ty] = 1;
que[tail].step = que[head].step + 1;
que[tail].x = tx;
que[tail].y = ty;
tail ++;
}
if (tx == fx && ty == fy) {
printf("%d\n", que[head].step + 1);
flag = 1;
break;
}
}
if (flag == 1)break;
head++;
}
}
}
H - Oil Deposits
题目描述：
某公司负责探测地下油层，每次处理一个大的矩形区域。先创建一个网格，将土地划分为许多方形块，然后用传感设备分别探测每个地块，以确定该地块是否含有石油。一块含有石油的土地叫做pocket。如果两个pocket边相邻或对角相邻，则它们属于同一油层的一部分。你的工作是确定在一个网格有多少不同的油层。
输入格式
输入包含多组数据。每组数据都以包含m和n的一行开始，m和n是网格中行和列的数量（1 <= m <= 100，1 <= n <= 100），由一个空格分隔。如果m = 0，则表示输入结束。下面是m行，每行有n个字符(不包括行尾字符)。每个字符对应一块土地，要么是“*”，代表没有油，要么是“@”，代表一个pocket。
输出格式
输出网格有多少不同的油层。
输入样例
1 1
*
3 5
@@*
@
@@*
1 8
@@***@
5 5
****@
@@@
@**@
@@@@
@@**@
0 0
输出样例
0
1
2
2
代码
用DFS处理连通块问题， 没有见过这种题，记住了基本上就不怕这种类型的题了
#include<stdio.h>
#include<string.h>
int vis[110][110], m, n, cnt;
char mp[110][110];
int next[8][2] = {-1,0, -1,1, 0,1, 1,1, 1,0, 1,-1, 0,-1, -1,-1};
void dfs(int x, int y) {
// vis[x][y] = 1;
int tx, ty;
for (int k = 0; k < 8; k++) {// 利用循环朝八个方向遍历
//更新变量
tx = x + next[k][0];
ty = y + next[k][1];
//判断边界
if (tx < 1 || tx > m || ty < 0 || ty >= n) continue;
// if (mp[x][y] == '*' || vis[x][y] != 0) continue;
// 这个点必须，没走过 ，并且是油田 ‘@ ’
if (!vis[tx][ty] && mp[tx][ty] == '@') {
vis[tx][ty] = 1;// 标记已经走过了
//向下一个点深搜
dfs(tx, ty);
}
}
return ;
}
int main() {
while (scanf("%d%d", &m, &n) && m && n) {
// getchar();
for(int i = 1; i <= m; i++) {
scanf("%s", mp[i]);// 说明后面要从 第 0 列开始遍历
}
//初始化记号数组 vis
memset(vis, 0, sizeof(vis));
cnt = 0;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < n; j++) {//错误原因： 1，j应该从零开始，因为输入时一次输入一行 默认从第 0 列开始
if (!vis[i][j] && mp[i][j] == '@') {
// vis[i][j] = 1;
dfs(i, j);
cnt++;
}
}
}
printf("%d\n", cnt);
}
}
I - Lake Counting
题目描述：
由于最近的降雨，农夫约翰的农田里形成了不同位置的水塘。农田被表示为一个矩形，它包含了 N x M (1 <= N <= 100; 1 <= M <= 100) 个小方格。每个方格中，要么包含了水 (‘W’)，要么包含了旱地 (’.’)。农夫约翰想要弄清楚，他的农田中形成了多少个水塘。一个水塘是由包含了水的方格连通而成，这里一个方格被视作与周围的全部八个方格相邻。
给出农夫约翰的农田数据图，判断图中有多少个水塘。
输入格式
第一行：两个以空格分隔的整数: N 和 M
第 2…N+1 行：每行 M 个字符，表示农夫约翰的农田中的一行。每个字符要么是 ‘W’ 要么是 ‘.’。字符之间没有空格。
输出格式
第一行：农夫约翰的农田中，水塘的数量。
输入样例
10 12
10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.
输出样例
3
代码
经典， DFS处理连通块问题，跟上一题一样
#include<stdio.h>
#include<string.h>
char mp[110][110];
int m, n, ans, vis[110][110];
int next[][2] = {
{ 1, 0 }, { -1, 0 }, { 0, 1 }, {0,-1},
{ 1, 1 }, { 1, -1 }, { -1, 1 }, {-1,-1}
};
void dfs(int x, int y) {
for (int k = 0; k < 8; k++) {
int tx = x + next[k][0];
int ty = y + next[k][1];
if (tx < 1 || tx > n || ty < 0 || ty >= m) continue ;
if (!vis[tx][ty] && mp[tx][ty] == 'W') {
vis[tx][ty] = 1;
dfs(tx, ty);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%s", mp[i]);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (!vis[i][j] && mp[i][j] == 'W') {
dfs(i, j);
ans++;
}
}
}
printf("%d", ans);
}
J - 二叉树先序遍历
题目描述：
输入一个整数n（n <= 100000），表示二叉树中节点个数，编号为1~n。约定1号节点为二叉树的根节点。然后输入n行，每行包括两个整数，第i行表示编号为i的节点的左子节点和右子节点的编号。如果某个节点没有左子节点，那么对应输行的第一个整数为0；如果某个节点没有右子节点，那么对应行的第二个整数为0。
先序遍历输出此二叉树每个节点的编号，每行输出一个编号。
先序遍历（DLR），是二叉树遍历的一种，也叫做先根遍历、前序遍历、前序周游，可记做根左右。前序遍历首先访问根节点然后遍历左子树，最后遍历右子树。
输入格式
第一行：一个整数n 接下来n行，每行有两个整数
输出格式
输出n行，每行一个整数，表示节点编号。
输入样例
5
2 5
3 4
0 0
0 0
0 0
输出样例
1
2
3
4
5
代码
经典题目，可惜我开始的时候一直没看懂，搜出来一堆二叉树的知识，最后才发现不用二叉树结构
#include<stdio.h>
#include<string.h>
struct p {
int l, r;
}s[100010];
void dfs(int x) {
if (x == 0) {
return ;
}
printf("%d\n", x);
dfs(s[x].l);
dfs(s[x].r);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &s[i].l, &s[i].r);
}
dfs(1);
}
K - 迷宫（一）
题目描述：
一天蒜头君掉进了一个迷宫里面，蒜头君想逃出去，可怜的蒜头君连迷宫是否有能逃出去的路都不知道。
看在蒜头君这么可怜的份上，就请聪明的你告诉蒜头君是否有可以逃出去的路。
输入格式
第一行输入两个整数 n 和 m，表示这是一个 n×m 的迷宫。
接下来的输入一个 n 行 m 列的迷宫。其中 ‘S’ 表示蒜头君的位置，’*‘表示墙，蒜头君无法通过，’.‘表示路，蒜头君可以通过’.'移动，'T’表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，下，左，右）。
输出格式
输出一个字符串，如果蒜头君可以逃出迷宫输出"yes"，否则输出"no"。
数据范围
1≤n,m≤10。
输入样例1
3 4
S**.
…*.
***T
输出样例1
no
输入样例2
3 4
S**.
…
***T
输出样例2
yes
代码
典型的BFS搜索题
#include<stdio.h>
#include<string.h>
char s[12][12];
int book[12][12];
struct note {
int x;
int y;
}que[101];
int main() {
int n, m,sx, sy, head, tail, ex, ey;
int next[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
scanf("%d %d", & n, & m);
getchar() ;
for (int i = 0; i < n; i++) {
scanf("%s", & s[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'S') {
sx = i;
sy = j;
}
if (s[i][j] == 'T') {
ex = i;
ey = j;
}
}
}
int tx, ty, tip = 0;
head = 1; tail = 1;
que[tail].x = sx;
que[tail].y = sy;
tail++;
while (head < tail) {
for (int k = 0; k <= 3; k++) {
//应该加上上一步的x,y 不应该是tail的，因为tail，总是指向下一位
tx = que[head].x + next[k][0];
ty = que[head].y + next[k][1];
//判断是否越界
if (tx < 0 || tx >= n || ty < 0 || ty >= m)
continue;
//判断该点是否是路，是否没有走过
if (book[tx][ty] == 0 && s[tx][ty] == '.') {
book[tx][ty] = 1;
que[tail].x = tx;
que[tail].y = ty;
tail++;
}
if (tx == ex && ty == ey) {
tip = 1;
break;
}
}
if (tip == 1)
break;
head++;
}
if (tip == 1) printf("yes");
else printf("no");
}
L - 马走日
题目描述：
马在中国象棋以日字形规则移动。请编写一段程序，给定n*m大小的棋盘，以及马的初始位置(x，y)，要求不能重复经过棋盘上的同一个点，计算马可以有多少途径遍历棋盘上的所有点。
输入格式
第一行为整数T(T < 10)，表示测试数据组数。每一组测试数据包含一行，为四个整数，分别为棋盘的大小以及初始位置坐标n,m,x,y。(0<=x<=n-1,0<=y<=m-1, m < 6, n < 6)
输出格式
每组测试数据包含一行，为一个整数，表示马能遍历棋盘的途径总数，0为无法遍历一次。
输入样例
1
5 4 0 0
输出样例
32
代码
没有目的地，所以用DFS熟悉一点
#include<stdio.h>
#include<string.h>
int vis[10][10], n, m, x, y, ans, t, p;
int next[][2] = { -2,1, -1,2, 1,2, 2,1, 2,-1, 1,-2, -1,-2, -2,-1};
void dfs(int a, int b, int r) {
if (r == p) {
ans++;
return ;
}
int tx, ty;
for (int k = 0; k < 8; k++) {
tx = a + next[k][0];
ty = b + next[k][1];
if (tx < 0 || tx >=n || ty < 0 || ty >= m) continue;
if (!vis[tx][ty] && r < p) {
vis[tx][ty] = 1;
r++;
dfs(tx, ty, r);
vis[tx][ty] = 0;
r--;
}
}
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d%d%d", &n, &m, &x, &y);
memset(vis, 0, sizeof(vis));
ans = 0;
p = m * n;
// 错误地方，忘了把初始点标记一下
vis[x][y] = 1;
dfs(x, y, 1);
printf("%d\n", ans);
}
}
M - 八皇后问题
题目描述：
努比亚和苏丹没有子女，所以他要从一些有集成资格的继承者中挑选一个出来继承王位。他希望这个继承者足够聪明，所以他准备了一个西洋棋盘，上面的每个格子中均有一个 1−99的数字。他又准备了 8 个皇后棋子。
8 皇后的规则就是不能有任何棋子同行或者同列或者同斜线，在满足这个规则的同时，王位继承者还需要让 8 个皇后所在的位置的数字的和是最大的。
输入格式
输入一个数字 k(k≤20)，代表棋盘的数量。
接下来有 kkk 个棋盘，每个棋盘有 64 个数字，分成 8 行 8 列出入，具体可见样例，每一个数字均小于 100。
输出格式
每一个棋盘对应输出最大的数值， 一共输出 k 行
输入样例
1
1 2 3 4 5 6 7 8
9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32
33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48
48 50 51 52 53 54 55 56
57 58 59 60 61 62 63 64
输出样例
260
代码
也是经典的DFS问题
#include<stdio.h>
#include<string.h>
int mp[10][10], k, lie[10], zheng[40], ci[40], max, a[10], n=8;
void dfs(int x, int r) {
if (r == 0) {//皇后棋子全部用完则停止
int sum=0;
for (int i = 1; i <= n; i++ ) {
sum += a[i];
}
if(sum > max) max = sum;
return ;
}
if(x > n)return;//判断边界
for (int i = 1; i <= n; i++) {
if (!lie[i] && !zheng[x-i+n] && !ci[x+i]) {//同列没有，左上到右下(15斜行)没有，右上到左下没有
//放棋子，标记一下
lie[i] = 1;
xie[x-i+n] = 1;
ci[x+i] = 1;
a[x] = mp[x][i];
r--;//棋子减少一个
dfs(x+1, r);//下一行
//回溯
lie[i] = 0;
xie[x-i+n] = 0;
ci[x+i] = 0;
a[x] = 0;
r++;
}
}
}
int main() {
scanf("%d", & k);
while (k--) {
max = 0;//初始化
memset(lie, 0, sizeof(lie));
memset(zheng, 0, sizeof(zheng));
memset(ci, 0, sizeof(ci));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", & mp[i][j]);
}
}
dfs(1, 8);// 从第一行开始，目前剩余八个皇后棋子
printf("%d\n", max);
}
}
N - 选数
题目描述：
已知 nnn 个整数 x1,x2,⋯ ,xnx_1,x_2,\cdots,x_nx1,x2,⋯,xn，以及一个整数 kkk（k<nk<nk<n）。从 nnn 个整数中任选 kkk 个整数相加，可分别得到一系列的和。例如当 n=4n=4n=4，k=3k=3k=3，444 个整数分别为 333，777，121212，191919 时，可得全部的组合与它们的和为：
3+7+12=22
3+7+19=29
7+12+19=38
3+12+19=34
现在，要求你计算出和为素数共有多少种。
例如上例，只有一种的和为素数：3+7+19=29。
输入格式
输入格式为：n，k（1≤n≤20,k<n）。
x1,x2,⋯ ,xn（1≤xi≤5000000）。
输出格式
输出格式为：一个整数（满足条件的种数）。
输入样例
4 3
3 7 12 19
输出样例
1
代码
#include<stdio.h>
#include<string.h>
#include<math.h>
//普通方法现在我有点写不出来，只能学dalao的不降原则
int a[30], n, k, b[30], cnt, book[30];
int primer(int t) {
int p = sqrt(t);
if(t == 1)return 0;
for(int i = 2; i <= p; i++) {
if (t % i == 0)return 0;
}
return 1;
}
void dfs(int x, int s, int y) {
if (x == k && primer(s)) {
cnt++;
return ;
}
if (x >= k) return;
for(int i = y; i < n; i++) {
if (!book[i]) {
// book[i] = 1;
// s += a[i];
// if (x == k && primer(s)) cnt++;
dfs(x + 1, s + a[i], i + 1);
// s -= a[i];
// book[i] = 0;
}
}
// dfs(x+1, s);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
dfs(0, 0, 0);
printf("%d", cnt);
}
O - 打开灯泡 Switch the Lamp On
需要借助双端搜索BFS
详见 双向搜索
题目描述：
达达是来自异世界的魔女，她在漫无目的地四处漂流的时候，遇到了善良的少女翰翰，从而被收留在地球上。
翰翰的家里有一辆飞行车。
有一天飞行车的电路板突然出现了故障，导致无法启动。
电路板的整体结构是一个R行C列的网格（R,C≤500），如下图所示。
每个格点都是电线的接点，每个格子都包含一个电子元件。
电子元件的主要部分是一个可旋转的、连接一条对角线上的两个接点的短电缆。
在旋转之后，它就可以连接另一条对角线的两个接点。
电路板左上角的接点接入直流电源，右下角的接点接入飞行车的发动装置。
达达发现因为某些元件的方向不小心发生了改变，电路板可能处于断路的状态。
她准备通过计算，旋转最少数量的元件，使电源与发动装置通过若干条短缆相连。
不过，电路的规模实在是太大了，达达并不擅长编程，希望你能够帮她解决这个问题。
注意：只能走斜向的线段，水平和竖直线段不能走。
输入格式
对于每组测试数据，第一行包含正整数R和C，表示电路板的行数和列数。
之后R行，每行C个字符，字符是"/“和”"中的一个，表示标准件的方向。
输出格式
对于每组测试数据，在单独的一行输出一个正整数，表示所需的缩小旋转次数。
如果无论怎样都不能使得电源和发动机之间连通，输出NO SOLUTION。
取值范围
1≤R,C≤500,
1≤T≤5
输入样例
3 5
\/\
\///
/\\
输出样例
1
代码
大佬的代码
#include<iostream>
#include<cstdio>
#include<cstring>
#include<deque>
using namespace std;
const int MAXX=550;
int dis[MAXX][MAXX];
bool vis[MAXX][MAXX],Map[MAXX][MAXX];
int dx[4]={1,-1,1,-1};
int dy[4]={1,-1,-1,1};//此处为了方便
int t,r,c;
char s[MAXX];
inline void init(){
memset(dis,0,sizeof(dis));
memset(vis,0,sizeof(vis));
}
inline bool check(int x,int y){
if(x>=1&&y>=1&&x<=r+1&&y<=c+1)return true;
else return false;
}//检查是否到边界
inline int edge(int x,int xx,int y,int yy){
if((xx<x&&yy<y)||(xx>x&&yy>y))return !Map[min(x,xx)][min(y,yy)];
else return Map[min(x,xx)][min(y,yy)];
}
inline void bfs(){
Map[0][0]=1;
deque< pair < pair<int ,int> ,pair<int ,int > > >q;//二元组队列
pair<int ,int > u=make_pair(0,0);
pair<int ,int > v=make_pair(1,1);
q.push_back(make_pair(u,v));
dis[0][0]=0;
while(!q.empty()){
pair< pair<int ,int > , pair<int ,int > >t=q.front();
q.pop_front();
pair<int ,int >u=t.first;
pair<int ,int >v=t.second;
int xx=u.first;
int yy=u.second;
int x=v.first;
int y=v.second;
if(vis[x][y])continue;//这里保证复杂度O(r*c)
dis[x][y]=dis[xx][yy]+edge(x,xx,y,yy);
vis[x][y]=1;
for(int i=0;i<4;++i){
int xv=x+dx[i];
int yv=y+dy[i];
pair<int ,int >s=make_pair(xv,yv);
if(check(xv,yv)&&!vis[xv][yv]){
if(edge(xv,x,yv,y))q.push_back(make_pair(v,s));
else q.push_front(make_pair(v,s));
}
}
}
}
int main(){
scanf("%d",&t);
while(t--){
init();
scanf("%d%d",&r,&c);
for(int i=1;i<=r;++i){
scanf("%s",s+1);
for(int j=1;j<=c;++j)
if(s[j]=='\\')Map[i][j]=1;//这里有c++的转义字符我么可以这么处理/
else Map[i][j]=0;
}
bfs();
if(vis[r+1][c+1])printf("%d\n",dis[r+1][c+1]);
else printf("NO SOLUTION\n");
}
return 0;
}
609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
