1.一步之遥
从昏迷中醒来，小明发现自己被关在X星球的废矿车里。 矿车停在平直的废弃的轨道上。 他的面前是两个按钮，分别写着“F”和“B”。
小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。 按F，会前进97米。按B会后退127米。
透过昏暗的灯光，小明看到自己前方1米远正好有个监控探头。 他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。
或许，通过多次操作F和B可以办到。矿车上的动力已经不太足，黄色的警示灯在默默闪烁… 每次进行 F 或 B 操作都会消耗一定的能量。
小明飞快地计算，至少要多少次操作，才能把矿车准确地停在前方1米远的地方。请填写为了达成目标，最少需要操作的次数。
注意，需要提交的是一个整数，不要填写任何无关内容（比如：解释说明等）
直接套用两层循环，将满足条件的值存储到数组中。遍历数组得到其中的最小值即可。
int main(void)
{
int i,j,count[100]={0},m=0;
int min;
for(i=0;i<101;i++)
{
for(j=0;j<101;j++)
{
if((97*i-j*127)==1)
{
count[m++]=i+j;
}
}
}
min=count[0];
for(i=0;i<100;i++)
{
if(count[i]&&count[i]<min)
{
min=count[i];
}
}
printf("%d\n",min);
return 0;
} 2.凑平方数
把0~9这10个数字，分成多个组，每个组恰好是一个平方数，这是能够办到的。 比如：0, 36, 5948721
再比如： 1098524736 1, 25, 6390784 0, 4, 289, 15376 等等…
注意，0可以作为独立的数字，但不能作为多位数字的开始。 分组时，必须用完所有的数字，不能重复，不能遗漏。
如果不计较小组内数据的先后顺序，请问有多少种不同的分组方案？
注意：需要提交的是一个整数，不要填写多余内容。
#define LL long long
bool mark[100]; ///标记哪些数字出现过
LL res[100],sum=0; ///res保存结果
bool tmpmark[10]; ///临时标记
bool judge(LL x)
{ ///判断这个数是否是出现过
memset(tmpmark,0,sizeof(tmpmark));
if(x==0){
if(mark[0] == 1)
return false;
return true;
}
while(x!=0){
if(mark[x%10] || tmpmark[x%10])
return false;
tmpmark[x%10] = 1;
x/=10;
}
return true;
}
int update(LL x,int coun)///用于修改哪些数字已经出现过
{
if(x==0)
{
mark[x] = 1;
coun++;
return coun;
}
while(x!=0)
{
mark[x%10] = 1;
x/=10;
coun++;
}
return coun;
}
void reupdate(LL x)///用于还原上一个标记状态
{
if(x==0)
{
mark[x] = 0;
return ;
}
while(x!=0)
{
mark[x%10] = 0;
x/=10;
}
}
void dfs(int coun,int rescoun,LL last)
{
if(coun == 10)
{
for(int i=0;i<rescoun;i++)
cout<<res[i]<<' ';
cout<<">>>"<<sum<<endl;
sum++;
return ;
}
for(LL i=last;i<=100000;i++)
{
if(judge(i*i))
{ ///判断是否出现了该数里面含有的数字
int tmpcoun = update(i*i,coun); ///更新新状态（包含i*i）
res[rescoun] = i*i;
dfs(tmpcoun,rescoun+1,i+1);
reupdate(i*i); ///还原上一状态
}
}
}
int main ()
{
memset(mark,0,sizeof(0));
dfs(0,0,0);
cout<<sum;
return 0;
} 方案二
#include"iostream"
#include"algorithm"
#include"string.h"
#include"math.h"
#include<map>
#include<set>
using namespace std;
long long shu[20];
int ai[10]={0,1,2,3,4,5,6,7,8,9};
set<string> jj;
void dfs(int cur,int num)
{
if(cur==10)
{
long long shu2[20];
for(int i=0;i<num;i++)
shu2[i]=shu[i];
sort(shu2,shu2+num);
string xu;
for(int i=0;i<num;i++)
{
while(shu2[i])
{
int a=shu2[i]%10;
shu2[i]=shu2[i]/10;
char b=a+'0';
xu=xu+b;
}
xu+='-';
}
jj.insert(xu);
return ;
}
if(ai[cur]==0)
{
shu[num]=0;
dfs(cur+1,num+1);
}
else
{
long long sum=0;
for(int i=cur;i<10;i++)
{
sum=sum*10+ai[i];
double son=sqrt(sum);
if(son==(int)son)
{
shu[num]=sum;
dfs(i+1,num+1);
}
}
}
}
int main()
{
do
{
memset(shu,0,sizeof(shu));
dfs(0,0);
}while(next_permutation(ai,ai+10));
cout<<jj.size()<<endl;
return 0;
}3.棋子换位
有n个棋子A，n个棋子B，在棋盘上排成一行。 它们中间隔着一个空位，用“.”表示，比如：
AAA.BBB
现在需要所有的A棋子和B棋子交换位置。 移动棋子的规则是：
1. A棋子只能往右边移动，B棋子只能往左边移动。
2. 每个棋子可以移动到相邻的空位。
3. 每个棋子可以跳过相异的一个棋子落入空位（A跳过B或者B跳过A）。AAA.BBB 可以走法： 移动A ==> AA.ABBB 移动B ==> AAAB.BB
跳走的例子： AA.ABBB ==> AABA.BB
以下的程序完成了AB换位的功能，请仔细阅读分析源码，填写划线部分缺失的内容。
#include <stdio.h>
#include <string.h>
void move(char* data, int from, int to)
{
data[to] = data[from];
data[from] = '.';
}
int valid(char* data, int k)
{
if(k<0 || k>=strlen(data)) return 0;
return 1;
}
void f(char* data)
{
int i;
int tag;
int dd = 0; // 移动方向
while(1){
tag = 0;
for(i=0; i<strlen(data); i++){
if(data[i]=='.') continue;
if(data[i]=='A') dd = 1;
if(data[i]=='B') dd = -1;
if(valid(data, i+dd) && valid(data,i+dd+dd)
&& data[i+dd]!=data[i] && data[i+dd+dd]=='.'){
//如果能跳...
move(data, i, i+dd+dd);
printf("%s\n", data);
tag = 1;
break;
}
}
if(tag) continue;
for(i=0; i<strlen(data); i++){
if(data[i]=='.') continue;
if(data[i]=='A') dd = 1;
if(data[i]=='B') dd = -1;
if(valid(data, i+dd) && data[i+dd]=='.'){
// 如果能移动...
if( ______________________ ) continue; //填空位置
move(data, i, i+dd);
printf("%s\n", data);
tag = 1;
break;
}
}
if(tag==0) break;
}
}
int main()
{
char data[] = "AAA.BBB";
f(data);
return 0;
}注意：只提交划线部分缺少的代码，不要复制已有代码或填写任何多余内容。
思路：手动模拟这个跳的过程会发现一个规律，当能直接平移的时候，必须是“.”的两边有A,B两个不相同的字母
所以我们就把相同的情况过滤掉
answer: valid(data, i+dd+dd) && valid(data,i-dd)&&data[i+dd+dd]==data[i-dd]
4.机器人塔
X星球的机器人表演拉拉队有两种服装，A和B。 他们这次表演的是搭机器人塔。
类似： 
队内的组塔规则是：
A 只能站在 AA 或 BB 的肩上。
B 只能站在 AB 或 BA 的肩上。
你的任务是帮助拉拉队计算一下，在给定A与B的人数时，可以组成多少种花样的塔。
输入一行两个整数 M 和 N，空格分开（0 < M,N < 500）,分别表示A、B的人数，保证人数合理性。
要求输出一个整数，表示可以产生的花样种数。
例如： 用户输入： 1 2
程序应该输出： 3
再例如： 用户输入： 3 3
程序应该输出： 4
资源约定： 峰值内存消耗 < 256M CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0 注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。 注意: 所有依赖的函数必须明确地在源文件中 #include ， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
int c=0;
int s[1000][1000];
int sum=0;
void f(int i,int j,int a,int b,int l)
{
if(i==c&&j==0) //export
{
sum++;
return ;
}
else
{
if(i==0)
{
if(a>0&&j<l)
{
if(j+1==c)
{
s[i][j]=1;
f(i+1,0,a-1,b,l-1);
}
else
{
s[i][j]=1;
f(i,j+1,a-1,b,l);
}
}
if(b>0&&j<l)
{
if(j+1==l)
{
s[i][j]=2;
f(i+1,0,a,b-1,l-1);
}
else
{
s[i][j]=2;
f(i,j+1,a,b-1,l);
}
}
}
else
{
if(a>0&&j<l)
{
if((s[i-1][j]==1&&s[i-1][j+1]==1)||(s[i-1][j]==2&&s[i-1][j+1]==2))
{
s[i][j]=1;
if(j+1==l)
f(i+1,0,a-1,b,l-1);
else
f(i,j+1,a-1,b,l);
}
}
if(b>0&&j<l)
{
if(!((s[i-1][j]==1&&s[i-1][j+1]==1)||(s[i-1][j]==2&&s[i-1][j+1]==2)))
{
s[i][j]=2;
if(j+1==l)
f(i+1,0,a,b-1,l-1);
else
f(i,j+1,a,b-1,l);
}
}
}
}
}
int main()
{
int m,n;
scanf("%d%d",&m,&n);
for(int i=0;i<m+n;i++)
{
if(i*(i+1)/2==m+n)
c=i; //层数
}
f(0,0,m,n,c);
printf("%d",sum);
return 0;
}
5.广场舞
LQ市的市民广场是一个多边形，广场上铺满了大理石的地板砖。
地板砖铺得方方正正，就像坐标轴纸一样。
以某四块砖相接的点为原点，地板砖的两条边为两个正方向，一块砖的边长为横纵坐标的单位长度，则所有横纵坐标都为整数的点都是四块砖的交点（如果在广场内）。广场的砖单调无趣，却给跳广场舞的市民们提供了绝佳的参照物。每天傍晚，都会有大批市民前来跳舞。
舞者每次都会选一块完整的砖来跳舞，两个人不会选择同一块砖，如果一块砖在广场边上导致缺角或者边不完整，则没人会选这块砖。
（广场形状的例子参考【图1.png】）现在，告诉你广场的形状，请帮LQ市的市长计算一下，同一时刻最多有多少市民可以在广场跳舞。
【输入格式】 输入的第一行包含一个整数n，表示广场是n边形的（因此有n个顶点）。
接下来n行，每行两个整数，依次表示n边形每个顶点的坐标（也就是说广场边缘拐弯的地方都在砖的顶角上。数据保证广场是一个简单多边形。【输出格式】 输出一个整数，表示最多有多少市民可以在广场跳舞。
【样例输入】 5 3 3 6 4 4 1 1 -1 0 4
【样例输出】 7
【样例说明】 广场如图1.png所示，一共有7块完整的地板砖，因此最多能有7位市民一起跳舞。
【数据规模与约定】 对于30%的数据，n不超过100，横纵坐标的绝对值均不超过100。
对于50%的数据，n不超过1000，横纵坐标的绝对值均不超过1000。
对于100%的数据，n不超过1000，横纵坐标的绝对值均不超过100000000（一亿）。资源约定： 峰值内存消耗 < 256M CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0 注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。 注意:
所有依赖的函数必须明确地在源文件中 #include ， 不能通过工程设置而省略常用头文件。提交时，注意选择所期望的编译器类型。
#include<iostream>
using namespace std;
int all_sum=0,n;
int max(int a,int b){
if(a>b)
return a;
else
return b;
}
int min(int a,int b){
if(a>b)
return b;
else
return a;
}
bool judge_point_is_in(int points[][2],int x,int y){
bool result=false;
int i=0,j=n-1;
for(;i<n;i++){
if(min(points[i][1], points[j][1])<y&&max(points[i][1], points[j][1])>=y){
double temp=(double)points[i][0]+(double)(((double)(y-points[i][1])/(double)(points[i][1]-points[j][1]))*((double)(points[i][0]-points[j][0])));
if(temp<x){
result=!result;
}
}
j=i;
}
return result;
}
int main() {
int i;
cin>>n;
int points[1000][2];
int max_x=-100000000,max_y=-100000000;
int min_x=100000000,min_y=100000000;
for(i=0;i<n;i++){
cin>>points[i][0]>>points[i][1];
if(points[i][0]>max_x)max_x=points[i][0];
if(points[i][0]<min_x)min_x=points[i][0];
if(points[i][1]>max_y)max_y=points[i][1];
if(points[i][1]<min_y)min_y=points[i][1];
}
for(i=min_x;i<max_x;i++){
for(int j=min_y;j<max_y;j++){
if(judge_point_is_in(points, i, j)&&judge_point_is_in(points, i+1, j)&&judge_point_is_in(points, i, j+1)&&judge_point_is_in(points, i+1, j+1)){
all_sum++;
}
}
}
cout<<all_sum<<endl;
return 0;
}6.生成树计数
给定一个 n*m 的格点图，包含 n 行 m 列共 n*m 个顶点，相邻的顶点之间有一条边。
【图1.png】给出了一个3*4的格点图的例子。如果在图中删除部分顶点和其相邻的边，如上图删除第2行第3列和第3行第1列的顶点后，如【图2.png】所示。
图的生成树指包含图中的所有顶点和其中的一部分边，使得任意两个顶点之间都有由边构成的唯一路径。如果两个生成树包含有不同的边即被认为不同，则上图*有31种不同的生成树，其中a边不选有10种，a边选有21种。
给出格点图中保留的顶点的信息，请计算该图一共有多少种不同的生成树。【输入格式】 输入的第一行包含两个整数n, m，用空格分隔，表示格点图的行数和列数。
接下来n行，每行m个字母（中间没有分隔字符），每个字母必然是大写E或大写N，E表示对应的顶点存在，N表示对应的顶点不存在。保证存在至少一个顶点。【输出格式】 输出一行，包含一个整数，表示生成树的个数。答案可能很大，你只需要计算答案除以1000000007的余数即可。
【样例输入】 3 4 EEEE EENE NEEE
【样例输出】 31
【数据规模与约定】 对于10%的数据，1<=n<=2。 对于30%的数据，1<=n<=3。 对于40%的数据，1<=n<=4。
对于50%的数据，1<=n<=5。 另有20%的数据，1<=n*m<=12。 另有10%的数据，1<=m<=15。
对于100%的数据，1<=n<=6，1<=m<=100000。资源约定： 峰值内存消耗 < 256M CPU消耗 < 4500ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0 注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。 注意:
所有依赖的函数必须明确地在源文件中 #include ， 不能通过工程设置而省略常用头文件。提交时，注意选择所期望的编译器类型。