P1443 马的遍历
题目描述
有一个 n×m 的棋盘，在某个点 (x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。
输入格式
输入只有一行四个整数，分别为 n,m,x,y。
输出格式
一个 n×m 的矩阵，代表马到达某个点最少要走几步（左对齐，宽 5 格，不能到达则输出 −1）。
输入输出样例
输入 #1
3 3 1 1输出 #1
0 3 2
3 -1 1
2 1 4 说明/提示
数据规模与约定
对于全部的测试点，保证 1≤x≤n≤400，1≤y≤m≤400。
代码实现：
# include<iostream>
# include<queue>
# include<cstring>
using namespace std;
const int N=520;
queue<pair<int,int> >q;//队列
bool vis[N][N];
int n,m,sx,sy,len[N][N];
int dis[8][2]={1,2,2,1,1,-2,2,-1,-1,2,-2,1,-1,-2,-2,-1};//马可以移动的8个方向
void bfs()//深搜
{
q.push(make_pair(sx,sy));
vis[sx][sy]=1;
while(!q.empty())
{
int x=q.front().first;
int y=q.front().second;
q.pop();
for(int i=0;i<8;i++)
{
int dx=x+dis[i][0];
int dy=y+dis[i][1];
if(dx>=1&&dx<=n&&dy>=1&&dy<=m&&!vis[dx][dy])
{
vis[dx][dy]=1;
len[dx][dy]=len[x][y]+1;
q.push(make_pair(dx,dy));
}
}
}
}
int main()
{
cin>>n>>m>>sx>>sy;
memset(len,-1,sizeof len);
len[sx][sy]=0;
bfs();
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
printf("%-5d",len[i][j]);
cout<<endl;
}
return 0;
}P1747 好奇怪的游戏
题目背景
《爱与愁的故事第三弹·shopping》娱乐章。
调调口味来道水题。（个人感觉一点也不水，真的超级难，像我这种菜鸡真的要发很长时间来研究的，哎，谁叫我实力不够呢）
题目描述
爱与愁大神坐在公交车上无聊，于是玩起了手机。一款奇怪的游戏进入了爱与愁大神的眼帘：***（游戏名被打上了马赛克）。这个游戏类似象棋，但是只有黑白马各一匹，在点x1,y1和x2,y2上。它们得从点x1,y1和x2,y2走到1,1。这个游戏与普通象棋不同的地方是：马可以走“日”，也可以像象走“田”。现在爱与愁大神想知道两匹马到1,1的最少步数，你能帮他解决这个问题么？
输入格式
第1行：两个整数x1，y1
第2行：两个整数x2，y2
输出格式
第1行：黑马到1,1的步数
第2行：白马到1,1的步数
输入输出样例
输入 #1
12 16
18 10输出 #1
8
9
说明/提示
100%数据：x1,y1,x2,y2<=20;
代码实现：
# include<iostream>
# include<cstdio>
# include<cstring>
using namespace std;
const int N=101;
bool bk[N][N];
int m,n,p,q,head,tail;
//一共有12个方向可以移动；
int dx[13]={-1,-2,-2,-2,-2,-1,1,2,2,2,2,1};
int dy[13]={2,2,1,-1,-2,-2,-2,-2,-1,1,2,2};
//定义结构体来模拟队列；
struct node{
int x,y,step;
}que[N*N];
bool judge(int x,int y)//判断是否越界；
{
if(x>=1&&x<=N&&y>=1&&y<=N&&!bk[x][y])
{
return true;
}
return false;
}
void bfs(int a,int b)
{
head=tail=1;
que[head].x=a;
que[head].y=b;
que[head].step=0;
bk[a][b]=true;
tail++;
while(head<tail)
{
for(int i=0;i<12;i++)
{
int tx=que[head].x+dx[i];
int ty=que[head].y+dy[i];
if(judge(tx,ty))
{
bk[tx][ty]=true;
que[tail].x=tx;
que[tail].y=ty;
que[tail].step=que[head].step+1;
tail++;
if(tx==1&&ty==1)
{
cout<<que[tail-1].step<<endl;
return ;
}
}
}
head++;
}
}
int main()
{
memset(bk,false,sizeof bk);
cin>>m>>n;
bfs(m,n);
memset(bk,false,sizeof bk);
cin>>p>>q;
bfs(p,q);
return 0;
}P1746 离开中山路
题目背景
《爱与愁的故事第三弹·shopping》最终章。
题目描述
爱与愁大神买完东西后，打算坐车离开中山路。现在爱与愁大神在x1,y1处，车站在x2,y2处。现在给出一个n×n（n<=1000）的地图，0表示马路，1表示店铺（不能从店铺穿过），爱与愁大神只能垂直或水平着在马路上行进。爱与愁大神为了节省时间，他要求最短到达目的地距离（a[i][j]距离为1）。你能帮他解决吗？
输入格式
第1行：一个数 n
第2行~第n+1行：整个地图描述（0表示马路，1表示店铺，注意两个数之间没有空格）
第n+2行：四个数 x1,y1,x2,y2
输出格式
只有1行：最短到达目的地距离
输入输出样例
输入 #1
3
001
101
100
1 1 3 3输出 #1
4
说明/提示
20%数据：n<=100
100%数据：n<=1000
代码实现：
# include<iostream>
# include<cstring>
using namespace std;
int const N=1010;
int n,x1,x2,y1,y2;
char a[N][N];
bool bk[N][N];
int dx[4]={0,-1,0,1};
int dy[4]={-1,0,1,0};
struct node{
int x;
int y;
int step;
}q[N*N];
bool dj(int x,int y)
{
if(x>=1&&x<=n&&y>=1&&y<=n&&a[x][y]!='1'&&!bk[x][y])
{
return true;
}
return false;
}
int main()
{
cin>>n;
memset(bk,false,sizeof bk);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
cin>>a[i][j];
cin>>x1>>y1>>x2>>y2;
bk[x1][y1]=true;
int head,tail;
head=tail=1;
q[head].x=x1;
q[head].y=y1;
q[head].step=0;
tail++;
while(head<tail)
{
for(int i=0;i<4;i++)
{
int tx=q[head].x+dx[i];
int ty=q[head].y+dy[i];
if(dj(tx,ty))
{
bk[tx][ty]=true;
q[tail].x=tx;
q[tail].y=ty;
q[tail].step=q[head].step+1;
tail++;
}
if(tx==x2&&ty==y2)
{
cout<<q[head].step+1<<endl;
return 0;
}
}
head++;
}
return 0;
}P2298 Mzc和男家丁的游戏
题目背景
ｍｚｃ与ｄｊｎ的第二弹。
题目描述
ｍｚｃ家很有钱（开玩笑），他家有ｎ个男家丁（做过上一弹的都知道）。他把她们召集在了一起，他们决定玩捉迷藏。现在mzc要来寻找他的男家丁，大家一起来帮忙啊！
由于男家丁数目不多，再加上mzc大大的找人【laopo】水平很好，所以一次只需要找一个男家丁。
输入格式
第一行有两个数ｎ，m，表示有n行m列供男家丁躲藏，
之后n行m列的矩阵，‘m‘表示mzc，‘d’表示男家丁，‘#’表示不能走，‘.‘表示空地。
输出格式
一行，若有解：一个数sum，表示找到男家丁的最短移动次数。
若无解：输出“No Way!”。
输入输出样例
输入 #1
5 6
.#..#.
....#.
d.....
#####.
m.....输出 #1
12
说明/提示
3=<M,n<=2000
由于mzc大大十分着急，所以他只能等待1S。
代码实现：
# include<iostream>
# include<cstring>
# include<queue>
using namespace std;
const int N=2010;
int x1,x2,y1,y2,n,m;
int dx[4]={0,-1,0,1};
int dy[4]={-1,0,1,0};
struct OP{
int x;
int y;
};
char a[N][N];
int f[N][N];
bool flag[N][N];
int bfs(int x,int y)
{
queue<OP>op;//队列和结构体的结合；
op.push((OP){x,y});
flag[x][y]=true;
while(!op.empty())
{
OP k=op.front();
if(k.x==x2&&k.y==y2)
return f[x2][y2];
for(int i=0;i<4;i++)
{
int tx=k.x+dx[i];
int ty=k.y+dy[i];
if(!flag[tx][ty]&&tx>=1&&tx<=n&&ty>=1&&ty<=m&&a[tx][ty]=='.')
{
op.push((OP){tx,ty});
flag[tx][ty]=true;
f[tx][ty]=f[k.x][k.y]+1;
}
}
op.pop();
}
return 0;
}
int main()
{
memset(flag,false,sizeof flag);
cin>>n>>m;
for(int i=1;i<=n;i++)
{
getchar();//消除字符；
for(int j=1;j<=m;j++)
{
cin>>a[i][j];
if(a[i][j]=='m')
{
x1=i;
y1=j;
}
if(a[i][j]=='d')
{
x2=i;
y2=j;
a[i][j]='.';
}
}
}
if(bfs(x1,y1))
cout<<f[x2][y2];
else
cout<<"No Way!";
return 0;
} P1332 血色先锋队
题目背景
巫妖王的天灾军团终于卷土重来，血色十字军组织了一支先锋军前往诺森德大陆对抗天灾军团，以及一切沾有亡灵气息的生物。孤立于联盟和部落的血色先锋军很快就遭到了天灾军团的重重包围，现在他们将主力只好聚集了起来，以抵抗天灾军团的围剿。可怕的是，他们之中有人感染上了亡灵瘟疫，如果不设法阻止瘟疫的扩散，很快就会遭到灭顶之灾。大领主阿比迪斯已经开始调查瘟疫的源头。原来是血色先锋军的内部出现了叛徒，这个叛徒已经投靠了天灾军团，想要将整个血色先锋军全部转化为天灾军团！无需惊讶，你就是那个叛徒。在你的行踪败露之前，要尽快完成巫妖王交给你的任务。
题目描述
军团是一个 nnn 行 mmm 列的矩阵，每个单元是一个血色先锋军的成员。感染瘟疫的人，每过一个小时，就会向四周扩散瘟疫，直到所有人全部感染上瘟疫。你已经掌握了感染源的位置，任务是算出血色先锋军的领主们感染瘟疫的时间，并且将它报告给巫妖王，以便对血色先锋军进行一轮有针对性的围剿。
输入格式
第 111 行：四个整数 nnn，mmm，aaa，bbb，表示军团矩阵有 nnn 行 mmm 列。有 aaa 个感染源，bbb 为血色敢死队中领主的数量。
接下来 aaa 行：每行有两个整数 xxx，yyy，表示感染源在第 xxx 行第 yyy 列。
接下来 bbb 行：每行有两个整数 xxx，yyy，表示领主的位置在第 xxx 行第 yyy 列。
输出格式
第 111 至 bbb 行：每行一个整数，表示这个领主感染瘟疫的时间，输出顺序与输入顺序一致。如果某个人的位置在感染源，那么他感染瘟疫的时间为 000。
输入输出样例
输入 #1
5 4 2 3
1 1
5 4
3 3
5 3
2 4输出 #1
3
1
3说明/提示
输入输出样例 1 解释
如下图，标记出了所有人感染瘟疫的时间以及感染源和领主的位置。
数据规模与约定
对于 100%的数据，保证 1≤n,m≤500，1≤a,b≤10^5。
代码实现：
# include<iostream>
# include<cstring>
# include<queue>
using namespace std;
int s[520][520];//520dj
int bk[520][520];//520dj
int n,m,a,b;
int dx[4]={0,0,-1,1},dy[4]={-1,1,0,0};
struct node{
int u,v;
int hour;
};
queue<node>q;
int main()
{
cin>>n>>m>>a>>b;
int x,y;
while(a--)
{
cin>>x>>y;
q.push({x,y,0});
bk[x][y]=1;
}
while(!q.empty())
{
node x=q.front();
int hour=x.hour;
int u=x.u;
int v=x.v;
q.pop();
for(int i=0;i<4;i++)
{
int tx=u+dx[i];
int ty=v+dy[i];
if(tx>=1&&tx<=n&&ty>=1&&ty<=m&&!bk[tx][ty])
{
bk[tx][ty]=1;
s[tx][ty]=hour+1;
q.push({tx,ty,hour+1});
}
}
}
while(b--)
{
cin>>x>>y;
cout<<s[x][y]<<endl;
}
return 0;
}
P1451 求细胞数量
题目描述
一矩形阵列由数字 0 到 9 组成，数字 1 到 9代表细胞，细胞的定义为沿细胞数字上下左右若还是细胞数字则为同一细胞，求给定矩形阵列的细胞个数。
输入格式
第一行两个整数代表矩阵大小 n 和 m。
接下来 n行，每行一个长度为 m 的只含字符 0到 9 的字符串，代表这个 n×m 的矩阵。
输出格式
一行一个整数代表细胞个数。
输入输出样例
输入 #1
4 10
0234500067
1034560500
2045600671
0000000089输出 #1
4
说明/提示
数据规模与约定
对于 100% 的数据，保证 1≤n,m≤100 。
代码实现：
# include<iostream>
# include<cstring>
using namespace std;
int n,m,ans;
char a[110][110];
void dfs(int x,int y)
{
if(x>n||x<1||y>m||y<1||a[x][y]=='0') return ;
a[x][y]='0';
dfs(x+1,y);
dfs(x,y+1);
dfs(x-1,y);
dfs(x,y-1);
}
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>a[i][j];
}
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
if(a[i][j]!='0')
{
ans++;
dfs(i,j);
}
}
}
cout<<ans<<endl;
}P1162 填涂颜色
题目描述
由数字0组成的方阵中，有一任意形状闭合圈，闭合圈由数字1构成，围圈时只走上下左右4个方向。现要求把闭合圈内的所有空间都填写成2.例如：6×6 的方阵（n=6），涂色前和涂色后的方阵如下：
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 0 0 0 1
1 1 1 1 1 1
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 2 2 1
1 1 2 2 2 1
1 2 2 2 2 1
1 1 1 1 1 1
输入格式
每组测试数据第一行一个整数n(1≤n≤30)
接下来n行，由0和1组成的n×n的方阵。
方阵内只有一个闭合圈，圈内至少有一个0。
输出格式
已经填好数字222的完整方阵。
输入输出样例
输入 #1
6
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 0 0 0 1
1 1 1 1 1 1输出 #1
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 2 2 1
1 1 2 2 2 1
1 2 2 2 2 1
1 1 1 1 1 1说明/提示
1≤n≤30
代码实现：
# include<iostream>
# include<cstring>
using namespace std;
int n,a[40][40],b[40][40];
void dfs(int x,int y)
{
if(x<0||y<0||x>n+1||y>n+1||a[x][y]!=0) return ;
a[x][y]=1;
dfs(x+1,y);
dfs(x,y+1);
dfs(x-1,y);
dfs(x,y-1);
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
cin>>b[i][j];
if(b[i][j]==0) a[i][j]=0;
else a[i][j]=2;
}
dfs(0,0);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(a[i][j]==0) cout<<2<<' ';
else cout<<b[i][j]<<' ';
}
cout<<endl;
}
return 0;
}P1683 入门
题目描述
不是任何人都可以进入桃花岛的，黄药师最讨厌象郭靖一样呆头呆脑的人。所以，他在桃花岛的唯一入口处修了一条小路，这条小路全部用正方形瓷砖铺设而成。有的瓷砖可以踩，我们认为是安全的，而有的瓷砖一踩上去就会有喷出要命的毒气，那你就死翘翘了，我们认为是不安全的。你只能从一块安全的瓷砖上走到与他相邻的四块瓷砖中的任何一个上，但它也必须是安全的才行。
由于你是黄蓉的朋友，她事先告诉你哪些砖是安全的、哪些砖是不安全的，并且她会指引你飞到第一块砖上（第一块砖可能在任意安全位置），现在她告诉你进入桃花岛的秘密就是：如果你能走过最多的瓷砖并且没有死，那么桃花岛的大门就会自动打开了，你就可以从当前位置直接飞进大门了。
注意：瓷砖可以重复走过，但不能重复计数。
输入格式
第一行两个正整数 W和 H，分别表示小路的宽度和长度。
以下 H 行为一个 H×W 的字符矩阵。每一个字符代表一块瓷砖。其中，. 代表安全的砖，# 代表不安全的砖，@ 代表第一块砖。
输出格式
输出一行，只包括一个数，即你从第一块砖开始所能安全走过的最多的砖块个数（包括第一块砖）。
输入输出样例
输入 #1
11 9
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#..@#.#.
.#.#####.#.
.#.......#.
.#########.
...........输出 #1
59说明/提示
数据规模与约定
对于全部的测试点，保证 1≤W,H≤20。
代码实现：
# include<iostream>
# include<cstring>
using namespace std;
char a[30][30];
int sum=0,n,m;
void dfs(int x,int y)
{
a[x][y]='1';
sum++;
if(a[x-1][y]=='.'&&x-1>0) dfs(x-1,y);
if(a[x][y-1]=='.'&&y-1>0) dfs(x,y-1);
if(a[x+1][y]=='.'&&x+1<=n) dfs(x+1,y);
if(a[x][y+1]=='.'&&y+1<=m) dfs(x,y+1);
}
int main()
{
int x,y;
cin>>m>>n;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>a[i][j];
if(a[i][j]=='@')
{
x=i;
y=j;
}
}
}
dfs(x,y);
cout<<sum<<endl;
return 0;
}P1019 单词接龙
题目背景
注意：本题为上古 NOIP 原题，不保证存在靠谱的做法能通过该数据范围下的所有数据。
题目描述
单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如 beast 和 astonish，如果接成一条龙则变为 beastonish，另外相邻的两部分不能存在包含关系，例如 at 和 atide 间不能相连。
输入格式
输入的第一行为一个单独的整数 nnn 表示单词数，以下 n 行每行有一个单词，输入的最后一行为一个单个字符，表示“龙”开头的字母。你可以假定以此字母开头的“龙”一定存在。
输出格式
只需输出以此字母开头的最长的“龙”的长度。
输入输出样例
输入 #1
5
at
touch
cheat
choose
tact
a输出 #1
23说明/提示
样例解释：连成的“龙”为 atoucheatactactouchoose。
n≤20
代码实现：
# include<bits/stdc++.h>
# include<iostream>
# include<algorithm>
# include<cstring>
# include<cmath>
using namespace std;
int n,len=0,vis[1010]={0};
string str[1010];
int dj(string a,string b)
{
int p=min(a.length(),b.length());
for(int i=1;a.length()==1?i<=p:i<p;i++)
{
bool flag=true;
for(int j=0;j<i;j++)
{
if(a[a.length()-i+j]!=b[j])
{
flag=false;
break;
}
}
if(flag) return i;
}
return 0;
}
void dfs(string s,int length_now)
{
len=max(len,length_now);
for(int i=1;i<=n;i++)
{
if(vis[i]>1) continue;
else
{
int add=dj(s,str[i]);
if(add!=0)
{
vis[i]++;
dfs(str[i],length_now+str[i].length()-add);
vis[i]--;
}
}
}
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
cin>>str[i];
cin>>str[n+1];
dfs(str[n+1],1);
cout<<len<<endl;
return 0;
}P1025 数的划分
题目描述
将整数 n 分成 k 份，且每份不能为空，任意两个方案不相同（不考虑顺序）。
例如：n=7，k=3，下面三种分法被认为是相同的。
1,1,5；
1,5,1；
5,1,1；
问有多少种不同的分法。
输入格式
n,k（6<n≤200，2≤k≤6）
输出格式
1 个整数，即不同的分法。
输入输出样例
输入 #1
7 3输出 #1
4说明/提示
四种分法为：
1,1,5;
1,2,4;
1,3,3;
2,2,3.
【题目来源】
NOIP 2001 提高组第二题
代码实现：
# include<bits/stdc++.h>
using namespace std;
int cnt=0,n,k;
void dfs(int last,int sum,int nowk)
{
if(nowk==k)
{
if(sum==n) cnt++;
return ;
}
for(int i=last;sum+i*(k-nowk)<=n;i++)
{
dfs(i,sum+i,nowk+1);
}
}
int main()
{
cin>>n>>k;
dfs(1,0,0);
cout<<cnt<<endl;
return 0;
}P11 57 组合的输出
题目描述
排列与组合是常用的数学方法，其中组合就是从n个元素中抽出r个元素(不分顺序且r≤n)r ，我们可以简单地将n个元素理解为自然数1,2,…,n，从中任取r个数。
现要求你输出所有组合。
例如n=5,r=3，所有组合为：
123,124,125,134,135,145,234,235,245,345；
输入格式
一行两个自然数n,r(1<n<21,0≤r≤n)
输出格式
所有的组合，每一个组合占一行且其中的元素按由小到大的顺序排列，每个元素占三个字符的位置，所有的组合也按字典顺序。
**注意哦!输出时，每个数字需要333个场宽，pascal可以这样：
write(ans:3);
输入输出样例
输入 #1
5 3 输出 #1
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5代码实现：
# include<bits/stdc++.h>
using namespace std;
int a[30],n,r;
void dfs(int k)
{
if(k>r)
{
for(int i=1;i<=r;i++)
printf("%3d",a[i]);
cout<<endl;
return ;
}
for(int i=a[k-1]+1;i<=n;i++)
{
a[k]=i;
dfs(k+1);
}
}
int main()
{
cin>>n>>r;
dfs(1);
return 0;
}P1036 选数
题目描述
已知 n 个整数 x1,x2,⋯ ,xn，以及 1个整数 k（k<n）。从 n 个整数中任选 k 个整数相加，可分别得到一系列的和。例如当 n=4，k=3，4 个整数分别为 3,7,12,19时，可得全部的组合与它们的和为：
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）。
第二行 n 个整数，分别为 x1,x2,⋯ ,xn（1≤xi≤5×10^6）。
输出格式
输出一个整数，表示种类数。
输入输出样例
输入 #1
4 3
3 7 12 19输出 #1
1说明/提示
【题目来源】
NOIP 2002 普及组第二题
代码实现：
# include<bits/stdc++.h>
# include<algorithm>
# include<cmath>
using namespace std;
typedef long long ll;
ll n,k,a[30],sum=0;
int dj(ll x)//素数判断函数；
{
int k=0;
for(int i=2;i<x;i++)
{
if(x%i==0) k++;
}
return k;
}
void dfs(ll x,ll y,ll z)
{
if(x==n+1) return ;
if(z==k) {
if(dj(y)==0) sum++;
return ;
}
for(int i=x+1;i<=n;i++)
{
dfs(i,y+a[i],z+1);
}
}
int main()
{
cin>>n>>k;
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
sort(a+1,a+n+1);
dfs(0,0,0);
cout<<sum<<endl;
return 0;
} P1441 砝码称重
题目描述
现有 n 个砝码，重量分别为 ai，在去掉 m 个砝码后，问最多能称量出多少不同的重量（不包括 0）。
请注意，砝码只能放在其中一边。
输入格式
第 1 行为有两个整数 n 和 m，用空格分隔。
第 2 行有 n 个正整数 a1,a2,a3,…,an，表示每个砝码的重量。
输出格式
仅包括 1 个整数，为最多能称量出的重量数量。
输入输出样例
输入 #1
3 1
1 2 2输出 #1
3说明/提示
【样例说明】
在去掉一个重量为 2 的砝码后，能称量出 1,2,3共 3 种重量。
【数据规模】
对于 20% 的数据，m=0。
对于 50% 的数据，m≤1。
对于 50% 的数据，n≤10。
对于 100% 的数据，n≤20， m≤4，m<n，ai≤100。
代码实现：
# include<bits/stdc++.h>
# include<iostream>
# include<algorithm>
using namespace std;
const int maxn=104;
const int inf=999999;
int n,m;
int num[maxn];
bool vis[maxn];
bool dp[2005];
int ans;
void dj()
{
fill(dp,dp+2005,false);
dp[0]=true;
int maxnum=0;
int cnt=0;
for(int i=1;i<=n;i++)
{
if(vis[i]) continue;
for(int j=maxnum;j>=0;j--)
{
if(dp[j]&&!dp[j+num[i]])
{
dp[j+num[i]]=true;
cnt++;
}
}
maxnum+=num[i];
}
ans=max(ans,cnt);
}
void dfs(int u,int step)
{
if(step==m)
{
dj();
return ;
}
if(u>=n+1) return ;
dfs(u+1,step);
vis[u]=true;
dfs(u+1,step+1);
vis[u]=false;
}
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
cin>>num[i];
dfs(1,0);
cout<<ans<<endl;
return 0;
}P1665 正方形计数
题目描述
给定平面上N个点，你需要计算以其中4个点为顶点的正方形的个数。注意这里的正方形边不一定需要和坐标轴平行。
输入格式
第一行一个数X，以下N个点的坐标。
【数据规模】
对于20%的数据，满足1≤N≤20;
对于100%的数据，满足1≤N≤500; -50≤X[i],Y[i]≤50，点不会重叠。
输出格式
一个数表示正方形的个数。
输入输出样例
输入 #1
7
0 0
0 1
1 0
1 1
1 2
2 1
2 2输出 #1
3代码实现：
# include<bits/stdc++.h>
using namespace std;
const int maxn=520;//520dj;
int n,ans,vis[2001][2001];
struct nond{
int x,y;
}v[maxn];
bool dj(int i,int j)
{
int dx=(v[i].x+v[j].x)/2;
int dy=(v[i].y+v[j].y)/2;
int x1=dx-(dy-v[i].y);
int y1=dy+(dx-v[i].x);
int x2=dx+(dy-v[i].y);
int y2=dy-(dx-v[i].x);
if(x1<0||y1<0||x2<0||y2<0)
return false;
if(vis[x1][y1]&&vis[x2][y2])
return true;
return false;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d%d",&v[i].x,&v[i].y);
v[i].x+=50;v[i].y+=50;
v[i].x*=2;v[i].y*=2;
vis[v[i].x][v[i].y]=1;
}
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++)
if(dj(i,j)) ans++;
cout<<ans/2;
}以我的水平，还剩下10道题没有做出来，日后有时间再把这24道搜索题看看，加深模板印象！！！
题目如下：
5019
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
