I - Lake Counting
由于最近的降雨，农夫约翰的农田里形成了不同位置的水塘。农田被表示为一个矩形，它包含了 N x M (1 <= N <= 100; 1 <= M <= 100) 个小方格。每个方格中，要么包含了水 ('W')，要么包含了旱地 ('.')。农夫约翰想要弄清楚，他的农田中形成了多少个水塘。一个水塘是由包含了水的方格连通而成，这里一个方格被视作与周围的全部八个方格相邻。
给出农夫约翰的农田数据图，判断图中有多少个水塘。
输入
* 第一行：两个以空格分隔的整数: N 和 M
* 第 2..N+1 行：每行 M 个字符，表示农夫约翰的农田中的一行。每个字符要么是 'W' 要么是 '.'。字符之间没有空格。
输出
* 第一行：农夫约翰的农田中，水塘的数量。
示例输入
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
提示
输出细节：
有 3 个水塘：一个位于左上方，一个位于左下方，还有一个位于右边。
Sponsor
#include <iostream>
#include <vector>
using namespace std;
//深度优先搜索,从x,y这一点向周围八个点搜索
void DFS(vector<vector<char> >& g,int n,int m,int x,int y)
{
//每次向周围搜索前，先将x,y这点置为'.',可以理解为遍历过就当作是干地，下次不再遍历
g[x][y] = '.';
//向周围八个点开始搜索
for (int i = -1; i <= 1; i++) //i = -1的意思是，从(x,y)点的最左边开始搜索
{
for (int j = -1; j <= 1; j++) //j = -1 的意思是，从(x,y)点的最上边开始搜索
{
//先判断是否超过范围，再判断是否是水池‘W’，如果是，则以这一点继续深搜
if (x + i >= 0 && x + i < n && y + j >= 0 && y + j < m && g[x + i][y + j] == 'W')
DFS(g, n, m, x + i, y + j);
}
}
}
//求水洼数量
int LakeCounting(vector<vector<char> >& g,int n,int m)
{
int res = 0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
if (g[i][j] == 'W')
{
DFS(g,n,m,i,j); //这里的DFS调用相当于搜索极大连通图，DFS里面的是小连通图
++res; //极大连通图的数量就是水洼的数量
}
}
}
return res;
}
int main()
{
int n = 0, m = 0;
cin >> n >> m;
vector<vector<char> > g(n);
//输入
for (int i = 0; i < n; i++)
{
g[i].resize(m);
for (int j = 0; j < m; j++)
cin >> g[i][j];
}
//输出的
cout << LakeCounting(g,n,m) << endl;
return 0;
}
A - 棋盘问题
在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。
Input
输入含有多组测试数据。
每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n <= 8 , k <= n
当为-1 -1时表示输入结束。
随后的n行描述了棋盘的形状：每行有n个字符，其中 # 表示棋盘区域， . 表示空白区域（数据保证不出现多余的空白行或者空白列）。
Output
对于每一组数据，给出一行输出，输出摆放的方案数目C （数据保证C<2^31）。
Sample Input
2 1 #. .# 4 4 ...# ..#. .#.. #... -1 -1
Sample Output
2 1
#include <iostream>
using namespace std;
int visited[10];
char a[10][10];
int cnt ,num,n,k;
void dfs(int r)
{
if(num == k) //如果棋子数达到k，那么计数器加一，并返回。
{
cnt++;
return;
}
if(r >= n) return;//判断边界。
for(int j = 0;j < n; j++)
{
if(!visited[j] && a[r][j] == '#')//如果符合条件，则该位置可放棋子。
{
visited[j] = 1;
num++; //标记为已访问，棋子数加一。
dfs(r+1);//深搜下一行
visited[j] = 0;//如果深搜失败或者棋子数目够了，则撤销标记。
num--;
}
}
dfs(r+1);//该行已经有棋子，深搜下一行。
}
int main(){
while(cin>>n>>k&&n != -1&&k != -1)
{
for(int i = 0; i < n; i++)
for(int j = 0 ; j < n; j++)
cin>>a[i][j];
cnt = num = 0;//别忘记每次都要初始化，这是多样例题。
dfs(0);//从第一行开始深搜。
cout<<cnt<<endl;
}
return 0;
}
B - Perket
你有 NN 种配料，每种配料有酸度 SS 和苦度 BB 。用这些配料做成Perket时，总的酸度为所有配料酸度的乘积，总的苦度是所有配料苦度的和。你至少需要添加一种配料。
为了使口感适中，总的酸度和苦度之差的绝对值应该尽可能小，求这个最小值。
输入
第一行 11 个整数 N \ (1\le N\le 10)N (1≤N≤10) —— 配料的数量。
接下来 NN 行每行 22 个整数 S_iSi 和 B_iBi —— 每种配料的酸度和苦度。如果用所有配料来做Perket，总的酸度和苦度都 \le 10^9≤109 。
输出
NN 行，每行 11 个整数 —— 所求的最小值。
Sample Input 1 Sample Output 1
Sample Input 2 Sample Output 2
Sample Input 3 Sample Output 3
#include<bits/stdc++.h>
#define REP(i, a, b) for(int i = (a); i <= (b); ++ i)
#define REP(j, a, b) for(int j = (a); j <= (b); ++ j)
#define PER(i, a, b) for(int i = (a); i >= (b); -- i)
using namespace std;
const int maxn = 1e5 + 5;
template <class T>
inline void rd(T &ret) {
char c;
ret = 0;
while ((c = getchar()) < '0' || c > '9');
while (c >= '0' && c <= '9') {
ret = ret * 10 + (c - '0'), c = getchar();
}
}
struct node {
int sweet, sour;
}p[maxn];
int n,ans=0x3f3f3f3f;
void dfs(int cur, int totsweet, int totsour) {
if (cur > n) {
if (totsweet == 0)return;
if (abs(totsweet-totsour) < ans)ans = abs(totsweet - totsour);
return;
}
dfs(cur + 1, totsweet + p[cur].sweet, totsour*p[cur].sour);
dfs(cur + 1, totsweet, totsour);
return;
}
int main()
{
rd(n);
REP(i, 1, n) {
scanf("%d%d", &p[i].sour, &p[i].sweet);
}
dfs(1, 0, 1);
cout << ans << endl;
return 0;
}
C - 全排列
给定一个由不同的小写字母组成的字符串，输出这个字符串的所有全排列。 我们假设对于小写字母有 'a' < 'b' < ... < 'y' < 'z'，而且给定的字符串中的字母已经按照从小到大的顺序排列。
输入格式
输入只有一行，是一个由不同的小写字母组成的字符串，已知字符串的长度在 11 到 66 之间。
输出格式
输出这个字符串的所有排列方式，每行一个排列。要求字母序比较小的排列在前面。字母序如下定义：
已知 S = s_1s_2...s_k, T = t_1t_2...t_kS=s1s2...sk,T=t1t2...tk，则 S < TS<T 等价于，存在 p (1 \le p \le k)p(1≤p≤k)，使得 s_1 = t_1, s_2 = t_2, ..., s_{p - 1} = t_{p - 1}, s_p < t_ps1=t1,s2=t2,...,sp−1=tp−1,sp<tp 成立。
Sample Input
abc
Sample Output
abc acb bac bca cab cba
#include<bits/stdc++.h>
using namespace std;
int main()
{
char s[66];
cin>>s;
do{
for(int i=0;i<strlen(s);i++)
cout<<s[i];
cout<<endl;
}while(next_permutation(s,s+strlen(s)));
return 0;
}
D - 自然数拆分
对于任意大于 11 的自然数 nn，总是可以拆分成若干个小于 nn 的自然数之和。
现请你编写程序求出 nn 的所有拆分。
输入格式
输入文件共一行，包含一个自然数，即要拆分的自然数 n(1 \le n \le 20)n(1≤n≤20)。
输出格式
输出文件有若干行，每行包含一个等式，即代表一种可行的拆分（格式与顺序参见样例）。
Sample Input
5
Sample Output
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
#include<cstdio>
using namespace std;
int n;
int old[50];
void dfs(int sum,int cur){
if(sum>n) return;
if(sum==n){
printf("%d=",n);
for(int i=1;i<cur;i++){
printf("%d+",old[i]);
}
printf("%d\n",old[cur]);
return;
}
for(int i=old[cur];i<n;i++){
old[cur+1]=i;//这个值就是下一层递归时所用到的i的起始值，这里old数组记录下来
dfs(sum+i,cur+1);//进入到下一层递归
}
}
int main(){
scanf("%d",&n);
old[0]=1;
dfs(0,0);
return 0;
}
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 4Case 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 <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
using namespace std;
int n;
int ans[40];
bool vis[40];
void pr()
{
for(int i = 1; i <= n - 1; i++)
{
cout << ans[i] << ' ';
}
cout << ans[n] << endl;
}
bool isPrime(int x)
{
bool flag = true;
for(int i = 2; i <= sqrt(x); i++)
{
if(x % i == 0)
flag = false;
}
return flag;
}
void dfs(int step)
{
if(step > n && isPrime(ans[1] + ans[n]))
{
pr();
return ;
}
for(int i = 2; i <= n; i++)
{
ans[step] = i;
if(vis[i] || isPrime(ans[step] + ans[step - 1]) == 0)
continue;
vis[i] = 1;
dfs(step + 1);
vis[i] = 0;
}
}
int main()
{
int j = 1;
while(cin >> n)
{
if(j >= 2)
cout << endl;
memset(ans, 0, sizeof ans);
memset(vis, 0, sizeof vis);
printf("Case %d:\n", j);
j++;
vis[1] = 1;
ans[1] = 1;
dfs(2);
}
return 0;
}
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
#include<stdio.h>
#include<string.h>
int next[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
char a[30][30];
int book[30][30];
int i,j,w,h,x,y,s;
void dfs(int x,int y);
int main()
{
while(scanf("%d%d",&w,&h)!=EOF)
{
memset(a,0,sizeof(a));
memset(book,0,sizeof(book));
s=1;
for(i=0;i<h;i++)
scanf("%s",a[i]);
if(w==0&&h==0)
break;
for(i=0;i<h;i++)
for(j=0;j<w;j++)
if(a[i][j]=='@')
{
x=i;y=j;
}
dfs(x,y);
printf("%d\n",s);
}
}
void dfs(int x,int y)
{
int k,tx,ty;
for(k=0;k<4;k++)
{
tx=x+next[k][0];
ty=y+next[k][1];
if(tx>=0&&tx<h&&ty>=0&&ty<w&&book[tx][ty]==0&&a[tx][ty]=='.')
{
s++;
book[tx][ty]=1;
dfs(tx,ty);
}
}
}
G - Knight Moves
题目描述
原题来自：POJ 1915
题目描述
原题来自：POJ 1915
编写一个程序，计算一个骑士从棋盘上的一个格子到另一个格子所需的最小步数。骑士一步可以移动到的位置由下图给出。
输入格式
第一行给出骑士的数量 nn。
在接下来的 3n3n 行中，每 33 行描述了一个骑士。其中，
- 第一行一个整数 LL 表示棋盘的大小，整个棋盘大小为 L\times LL×L；
- 第二行和第三行分别包含一对整数 (x,y)(x,y)，表示骑士的起始点和终点。假设对于每一个骑士，起始点和终点均合理。
输出格式
对每一个骑士，输出一行一个整数表示需要移动的最小步数。如果起始点和终点相同，则输出 00。
样例
样例
Input Output
数据范围与提示
对于 100\%100% 的数据，有 4\le L\le 3004≤L≤300，保证 0\le x,y\le L-10≤x,y≤L−1
#include <bits/stdc++.h>
using namespace std;
int xx[]={-2,-2,-1,-1,1,1,2,2};
int yy[]={-1,1,-2,2,-2,2,-1,1};
int vis[300][300];
struct Node{
int x;
int y;
int cnt;
};
int main(){
int n,L;
cin>>n;
int sx,sy,fx,fy;
for(int i=0;i<n;i++){
memset(vis,0,sizeof(vis));
cin>>L;
cin>>sx>>sy;
cin>>fx>>fy;
queue <Node> q;
q.push((Node){sx,sy,0});
while(!q.empty()){
if(q.front().x==fx&&q.front().y==fy){
cout<<q.front().cnt<<endl;
break;
}
for(int i=0;i<8;i++){
int dx=q.front().x+xx[i];
int dy=q.front().y+yy[i];
if(dx>=0&&dx<L&&dy>=0&&dy<L&&!vis[dx][dy]){
q.push((Node){dx,dy,q.front().cnt+1});
vis[dx][dy]=1;
}
}
q.pop();
}
}
return 0;
}
H - Oil Deposits
某公司负责探测地下油层，每次处理一个大的矩形区域。先创建一个网格，将土地划分为许多方形块，然后用传感设备分别探测每个地块，以确定该地块是否含有石油。一块含有石油的土地叫做pocket。如果两个pocket边相邻或对角相邻，则它们属于同一油层的一部分。你的工作是确定在一个网格有多少不同的油层。
Input
输入包含多组数据。每组数据都以包含m和n的一行开始，m和n是网格中行和列的数量（1 <= m <= 100，1 <= n <= 100），由一个空格分隔。如果m = 0，则表示输入结束。下面是m行，每行有n个字符(不包括行尾字符)。每个字符对应一块土地，要么是“*”，代表没有油，要么是“@”，代表一个pocket。
Output
输出网格有多少不同的油层。
Sample Input
1 1
*
3 5
*@*@*
**@**
*@*@*
1 8
@@****@*
5 5
****@
*@@*@
*@**@
@@@*@
@@**@
0 0Sample Output
0
1
2
2
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int n,m;
//int vis[105][105];
char yard[105][105];
int check(int p,int q)
{
if(p<0 || p>=n || q<0 || q>=m)
return 0;
// if(vis[p][q]==1)
// return 0;
if(yard[p][q]=='@')
return 1;
return 0;
}
void dfs(int x,int y)
{
// vis[x][y]=1;
yard[x][y]='*';
for(int dx=-1;dx<=1;dx++){
for(int dy=-1;dy<=1;dy++){
int nx=x+dx,ny=y+dy;
if(check(nx,ny)){
dfs(nx,ny);
}
}
}
}
int main()
{
while(scanf("%d %d",&n,&m)!=EOF){
getchar();int summ=0;
if(n==0&&m==0) break;
// memset(vis,0,sizeof(vis));
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cin>>yard[i][j];
}
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(yard[i][j]=='@'){
dfs(i,j);
summ++;
}
}
}
printf("%d\n",summ);
}
return 0;
}J - 二叉树先序遍历
输入一个整数n（n <= 100000），表示二叉树中节点个数，编号为1~n。约定1号节点为二叉树的根节点。然后输入n行，每行包括两个整数，第i行表示编号为i的节点的左子节点和右子节点的编号。如果某个节点没有左子节点，那么对应输行的第一个整数为0；如果某个节点没有右子节点，那么对应行的第二个整数为0。
先序遍历输出此二叉树每个节点的编号，每行输出一个编号。先序遍历（DLR），是二叉树遍历的一种，也叫做先根遍历、前序遍历、前序周游，可记做根左右。前序遍历首先访问根节点然后遍历左子树，最后遍历右子树。
Input
第一行：一个整数n 接下来n行，每行有两个整数
Output
输出n行，每行一个整数，表示节点编号。
Sample Input
5 2 5 3 4 0 0 0 0 0 0
Sample Output
1 2 3 4 5
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAX=1e5+10;
int vis[MAX];
int r[MAX];
int l[MAX];
int b[MAX];
int cnt=1;
void dfs(int t){
b[cnt++]=t;
if(l[t]){
dfs(l[t]);
}
if(r[t]){
dfs(r[t]);
}
}
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>l[i]>>r[i];
}
dfs(1);
for(int i=1;i<cnt;i++){
cout<<b[i]<<endl;
}
return 0;
}
K - 迷宫（一）
一天蒜头君掉进了一个迷宫里面，蒜头君想逃出去，可怜的蒜头君连迷宫是否有能逃出去的路都不知道。
看在蒜头君这么可怜的份上，就请聪明的你告诉蒜头君是否有可以逃出去的路。
输入格式
第一行输入两个整数 nn 和 mm，表示这是一个 n \times mn×m 的迷宫。
接下来的输入一个 nn 行 mm 列的迷宫。其中
'S'表示蒜头君的位置，'*'表示墙，蒜头君无法通过，'.'表示路，蒜头君可以通过'.'移动，'T'表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，下，左，右）。输出格式
输出一个字符串，如果蒜头君可以逃出迷宫输出
"yes"，否则输出"no"。数据范围
1 \le n, m \le 101≤n,m≤10
Sample Input 3 4 S**. ..*. ***T
Sample Output
no
Sample Input 2
3 4 S**. .... ***T
Sample Output 2
yes
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<map>
#include<set>
#include<string>
#include<stack>
#include<queue>
#include<vector>
#include<math.h>
using namespace std;
typedef long long int ll;
const int maxn=300;
const int inf=1e7;
int n,m;
char dt[15][15];
int vis[15][15];
int flag=0;
int dir[4][2]={{1,0},{-1,0},{0,-1},{0,1}};
bool pd(int x,int y)//判断路是否能走
{
return x>=1&&x<=n&&y>=1&&y<=m&&dt[x][y]!='*'&&vis[x][y]==0;
}
void dfs(int x,int y)
{
if(dt[x][y]=='T')//终点就退出
{
flag=1;
return ;
}
if(!pd(x,y)) return ;
vis[x][y]=1;
for(int i=0;i<4;i++)
{
int nx=x+dir[i][0];
int ny=y+dir[i][1];
dfs(nx,ny);
}
return ;
}
int main()
{
int sx,sy;
cin>>n>>m;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>dt[i][j];
if(dt[i][j]=='S')
{
sx=i;
sy=j;
}
}
}
dfs(sx,sy);
if(flag==1) cout<<"yes"<<endl;
else cout<<"no"<<endl;
}
L - 马走日
马在中国象棋以日字形规则移动。请编写一段程序，给定n*m大小的棋盘，以及马的初始位置(x，y)，要求不能重复经过棋盘上的同一个点，计算马可以有多少途径遍历棋盘上的所有点。
Input
第一行为整数T(T < 10)，表示测试数据组数。每一组测试数据包含一行，为四个整数，分别为棋盘的大小以及初始位置坐标n,m,x,y。(0<=x<=n-1,0<=y<=m-1, m < 6, n < 6)
Output
每组测试数据包含一行，为一个整数，表示马能遍历棋盘的途径总数，0为无法遍历一次。
Sample Input
1 5 4 0 0
Sample Output
32
#include <iostream>
#include <cstring>
using namespace std;
const int N = 11;
int vis[N][N], n, m, x0, y0, nm, ans = 0;
int dir[8][2] = {{1,2},{-1,2},{1,-2},{-1,-2},{2,1},{2,-1},{-2,1},{-2,-1}};
void dfs(int x, int y, int steps) {
if (steps == nm) {
ans++;
return;
} else {
for (int i = 0; i < 8; ++i) {
int tmpx = x + dir[i][0];
int tmpy = y + dir[i][1];
if (tmpx >= 0 && tmpy >= 0 && tmpx < n && tmpy < m && !vis[tmpx][tmpy]) {
vis[tmpx][tmpy] = 1;
dfs(tmpx, tmpy, steps + 1);
vis[tmpx][tmpy] = 0;
}
}
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(vis, 0, sizeof(vis));
scanf("%d%d%d%d", &n, &m, &x0, &y0);
nm = n * m, ans = 0;
vis[x0][y0] = 1;
dfs(x0, y0, 1);
printf("%d\n", ans);
}
return 0;
}M - 八皇后问题
努比亚和苏丹没有子女，所以他要从一些有集成资格的继承者中挑选一个出来继承王位。他希望这个继承者足够聪明，所以他准备了一个西洋棋盘，上面的每个格子中均有一个 1-991−99 的数字。他又准备了 88 个皇后棋子。
88 皇后的规则就是不能有任何棋子同行或者同列或者同斜线，在满足这个规则的同时，王位继承者还需要让 88 个皇后所在的位置的数字的和是最大的。
输入格式
输入一个数字 k(k\leq 20)k(k≤20)，代表棋盘的数量。
接下来有 kk 个棋盘，每个棋盘有 6464 个数字，分成 88 行 88 列出入，具体可见样例，每一个数字均小于 100100。
输出格式
每一个棋盘对应输出最大的数值， 一共输出 kk 行。
Sample Input
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
Sample Output
260
#include <bits/stdc++.h>
using namespace std;
int mp[10][10];
int lie[10];
int rl[30];
int lr[30];
int MAX=-1;
int sum=0;
void dfs(int t){
if(t>8){
MAX=max(MAX,sum);
return ;
}
for(int i=1;i<=8;i++){
if(!lie[i]&&!rl[t+i]&&!lr[i-t+8]){
lie[i]=1;
rl[t+i]=1;
lr[i-t+8]=1;
sum+=mp[t][i];
dfs(t+1);
sum-=mp[t][i];
lie[i]=0;
rl[t+i]=0;
lr[i-t+8]=0;
}
}
}
int main(){
int k;
cin>>k;
while(k--){
MAX=-1;
sum=0;
memset(lie,0,sizeof(lie));
memset(rl,0,sizeof(lie));
memset(lr,0,sizeof(lie));
for(int i=1;i<=8;i++){
for(int j=1;j<=8;j++){
cin>>mp[i][j];
}
}
dfs(1);
cout<<MAX<<endl;
}
return 0;
}N - 选数
已知 nn 个整数 x_1,x_2,\cdots,x_nx1,x2,⋯,xn，以及一个整数 kk（k<nk<n）。从 nn 个整数中任选 kk 个整数相加，可分别得到一系列的和。例如当 n=4n=4，k=3k=3，44 个整数分别为 33，77，1212，1919 时，可得全部的组合与它们的和为：
3+7+12=223+7+12=22
3+7+19=293+7+19=29
7+12+19=387+12+19=38
3+12+19=343+12+19=34
现在，要求你计算出和为素数共有多少种。
例如上例，只有一种的和为素数：3+7+19=293+7+19=29。
输入格式
输入格式为：nn，kk（1 \le n \le 20,k<n1≤n≤20,k<n）。
x_1,x_2,\cdots,x_nx1,x2,⋯,xn（1 \le x_i \le 50000001≤xi≤5000000）。
输出格式
输出格式为：一个整数（满足条件的种数）。
Sample Input
4 3 3 7 12 19
Sample Output
1
#include<iostream>
#include<math.h>
using namespace std;
int x[20],n,k;//依照题目所设
bool isprime(int n){//判断是否质数
int s=sqrt(double(n));
for(int i=2;i<=s;i++){
if(n%i==0)return false;
}
return true;
}
int rule(int choose_left_num,int already_sum,int start,int end){//choose_left_num为剩余的k，already_sum为前面累加的和，start和end为全组合剩下数字的选取范围；调用递归生成全组合，在过程中逐渐把K个数相加，当选取的数个数为0时，直接返回前面的累加和是否为质数即可
if(choose_left_num==0)return isprime(already_sum);
int sum=0;
for(int i=start;i<=end;i++){
sum+=rule(choose_left_num-1,already_sum+x[i],i+1,end);
}
return sum;
}
int main(){
cin>>n>>k;
for(int i =0;i<n;i++)cin>>x[i];
cout<<rule(k,0,0,n-1);//调用递归解决问题
}O - 打开灯泡 Switch the Lamp On
达达是来自异世界的魔女，她在漫无目的地四处漂流的时候，遇到了善良的少女翰翰，从而被收留在地球上。
翰翰的家里有一辆飞行车。
有一天飞行车的电路板突然出现了故障，导致无法启动。
电路板的整体结构是一个R行C列的网格（R,C≤500），如下图所示。
每个格点都是电线的接点，每个格子都包含一个电子元件。
电子元件的主要部分是一个可旋转的、连接一条对角线上的两个接点的短电缆。
在旋转之后，它就可以连接另一条对角线的两个接点。
电路板左上角的接点接入直流电源，右下角的接点接入飞行车的发动装置。
达达发现因为某些元件的方向不小心发生了改变，电路板可能处于断路的状态。
她准备通过计算，旋转最少数量的元件，使电源与发动装置通过若干条短缆相连。
不过，电路的规模实在是太大了，达达并不擅长编程，希望你能够帮她解决这个问题。
注意：只能走斜向的线段，水平和竖直线段不能走。
Input
对于每组测试数据，第一行包含正整数R和C，表示电路板的行数和列数。
之后R行，每行C个字符，字符是"/"和"\"中的一个，表示标准件的方向。
Output
对于每组测试数据，在单独的一行输出一个正整数，表示所需的缩小旋转次数。
如果无论怎样都不能使得电源和发动机之间连通，输出NO SOLUTION。
Example
样例输入
3 5
\\/\\
\\///
/\\\\样例输出
1Hint
1≤R,C≤500,
1≤T≤5
#include <bits/stdc++.h>
#define ll long long
#define inf 0x3f3f3f3f
#define il inline
#define in(a) a=read()
#define out(a) printf( "%d" , a )
#define outn(a) out(a),putchar('\n')
#define I_int int
inline I_int read() {
I_int x = 0 , f = 1 ; char c = getchar() ;
while( c < '0' || c > '9' ) {
if( c == '-' ) f = -1 ;
c = getchar() ;
}
while( c >= '0' && c <= '9' ) {
x = (x << 1) + (x << 3) + c - 48 ;
c = getchar() ;
}
return x * f ;
}
#undef I_int
using namespace std ;
const int N = 510 ;
const int M = (500*500+10)*4 ;
const int dx[] = {0,0,1,-1};
const int dy[] = {-1,1,0,0};
char a[ N ][ N ] ;
int n , m ;
int head[ M ] , d[ M ] , cnt , vis[ M ] ;
struct node {
int to , nxt , v ;
} e[ M << 1 ] ;
void ins( int u , int v , int w ) {
e[ ++ cnt ].to = v ;
e[ cnt ].nxt = head[ u ] ;
e[ cnt ].v = w ;
head[ u ] = cnt ;
}
bool check( int x , int y ) {
if( x < 0 || x > n || y < 0 || y > m ) return 0 ;
return 1 ;
}
int zb( int x , int y ) {
return (x-1)*(m+1)+y ;
}
deque<int>q;
void spfa() {
vis[ 1 ] = 1 ;
for( int i = 1 ; i <= (n+1)*(m+1) ; i ++ ) d[ i ] = inf ;
d[ 1 ] = 0 ;
q.push_front(1);
while( !q.empty() ) {
int u = q.front() ; q.pop_front() ;
vis[ u ] = 0 ;
for( int i = head[ u ] ; i ; i = e[ i ].nxt ) {
int v = e[ i ].to ;
if( d[ v ] > d[ u ] + e[ i ].v ) {
d[ v ] = d[ u ] + e[ i ].v ;
if( !vis[ v ] ) {
vis[ v ] = 1 ;
if(!e[i].v) q.push_front(v);
else q.push_back(v) ;
}
}
}
}
if( d[zb(n,m)] == inf ) puts("NO SOLUTION") ;
else outn( d[ zb(n+1,m+1) ] ) ;
}
int main() {
in( n ) ; in( m ) ;
for( int i = 1 ; i <= n ; i ++ ) {
scanf( "%s" , a[ i ] + 1 ) ;
for( int j = 1 ; j <= m ; j ++ ) {
if( a[ i ][ j ] == '\\' ) {
ins( zb(i,j+1) , zb(i+1,j) , 1 ) , ins( zb(i+1,j) , zb(i,j+1) , 1 ) ;
ins( zb(i,j) , zb(i+1,j+1) , 0 ) , ins( zb(i+1,j+1) , zb(i,j) , 0 ) ;
}
if( a[ i ][ j ] == '/' ) {
ins( zb(i,j+1) , zb(i+1,j) , 0 ) , ins( zb(i+1,j) , zb(i,j+1) , 0 ) ;
ins( zb(i,j) , zb(i+1,j+1) , 1 ) , ins( zb(i+1,j+1) , zb(i,j) , 1 ) ;
}
}
}
spfa() ;
}
1238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
