本文解析了算法挑战赛中的几个典型题目，包括矿车定位、数字分组、棋子换位等，介绍了各题目的背景、解决思路及核心代码实现。
一步之遥
从昏迷中醒来，小明发现自己被关在X星球的废矿车里。
矿车停在平直的废弃的轨道上。
他的面前是两个按钮，分别写着“F”和“B”。
小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。
按F，会前进97米。按B会后退127米。
透过昏暗的灯光，小明看到自己前方1米远正好有个监控探头。
他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。
或许，通过多次操作F和B可以办到。
矿车上的动力已经不太足，黄色的警示灯在默默闪烁...
每次进行 F 或 B 操作都会消耗一定的能量。
小明飞快地计算，至少要多少次操作，才能把矿车准确地停在前方1米远的地方。
请填写为了达成目标，最少需要操作的次数。
注意，需要提交的是一个整数，不要填写任何无关内容（比如：解释说明等）
97
这道题一眼就可以看出需要求97x+127y=1的最小解，用拓展欧几里得，当然这是一个天空，暴力一个一个枚举也可以
code：
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int e_gcd(int a,int b,int &x,int &y){
if(b == 0){
x = 1;
y = 0;
return a;
}
int q = e_gcd(b,a%b,y,x);
y -= a / b * x;
return q;
}
int main(){
int x,y;
int g = e_gcd(97,127,x,y);
cout << x-y << endl;
return 0;
}
凑平方数
把0~9这10个数字，分成多个组，每个组恰好是一个平方数，这是能够办到的。
比如：0, 36, 5948721
再比如：
1098524736
1, 25, 6390784
0, 4, 289, 15376
等等...
注意，0可以作为独立的数字，但不能作为多位数字的开始。
分组时，必须用完所有的数字，不能重复，不能遗漏。
如果不计较小组内数据的先后顺序，请问有多少种不同的分组方案？
注意：需要提交的是一个整数，不要填写多余内容。
300
一开始自己写了一个搜索，结果跑出来900多种，一定是有重复的，当时不知道怎么存去重了，看了别人的去重，转换成stirng然后不同数字间用一个字符‘-’分隔，然后放入set中去重
然后看了网上的搜索，一种思路是先打表出所有符合条件的平方数，然后在这些数中用深搜进行分组并判断条件。
code：
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;
const ll INF = 9876543210;
ll pow2[1000];
int top = 0,ans = 0;
bool check(string num){
int vis[10] = {0};
int len = num.length();
for(int i = 0; i < len; i++){
int tmp = num[i] - '0';
vis[tmp]++;
if(vis[tmp] > 1) return false;
}
return true;
}
string change(ll num){
string s = "";
if(num == 0) s += "0";
while(num){
char ch[] = {num % 10 + '0','\0'};
s.insert(0,ch);
num /= 10;
}
return s;
}
void init(){
for(ll i = 0; i * i <= INF; i++){
ll tmp = i * i;
if(check(change(tmp)))
pow2[top++] = tmp;
}
}
void dfs(int start,string num){
int len = num.length();
if(len > 10 || !check(num)) return;
if(len == 10 && check(num)){
ans++;
return;
}
for(int i = start; i < top; i++){//下次递归是找这个i之后的数保证了不会重复，就像两重循环枚举内层循环从外层循环枚举的数开始而不是重新开始
dfs(i+1,num+change(pow2[i]));
}
}
int main(){
init();
dfs(0,"");
cout << ans << endl;
return 0;
}
棋子换位
有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;
}
注意：只提交划线部分缺少的代码，不要复制已有代码或填写任何多余内容。
data[i] == 'A' && i != 0 && i <= strlen(data)-3 && data[i-1] == 'B' && data[i+2] == 'B'
这道题我的答案代码和网上不一样，但是跑出来结果是一样的，因为这个代码是固定的，只要结果是对的就可以，我一开始没有思路，因为眼看一直没看出来到底是怎么交换的，然后就写了广搜的程序，并还原了路径，然后根据打印出的那个路径，确定的这个代码，其实我这样写不具有普适性，对于这个样例是可以的。
#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(data[i] == 'A' && i != 0 && i <= strlen(data)-3 && data[i-1] == 'B' && data[i+2] == 'B') 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;
}
//测试程序，根据以下程序得到的答案
//#include <iostream>
//#include <cstring>
//#include <cstdio>
//#include <string>
//#include <vector>
//#include <queue>
//#include <map>
//using namespace std;
//
//string result = "BBB.AAA";
//struct node{
// string s;
// vector<string> path;
//}a,nexta;
//map<string,int>vis;
//void exchange(string data, int from, int to)
//{
// data[to] = data[from];
// data[from] = '.';
//}
//
//int valid(string data, int k)
//{
// if(k < 0 || k >= data.length()) return 0;
// return 1;
//}
//
//void f()
//{
// a.s = "AAA.BBB";
// a.path.push_back(a.s);
// vis[a.s] = 1;
// queue<node>q;
// q.push(a);
// while(!q.empty()){
// a = q.front();
// //cout << a.s << endl;
// q.pop();
// if(a.s == result){
// for(int i = 0; i < a.path.size(); i++){
// cout << a.path[i] << endl;
// }
// return;
// }
// int dd;
// for(int i = 0; i < a.s.length(); i++){
// if(a.s[i]=='.') continue;
// if(a.s[i]=='A') dd = 1;
// if(a.s[i]=='B') dd = -1;
//
// if(valid(a.s, i+dd) && valid(a.s,i+dd+dd)
// && a.s[i+dd] != a.s[i] && a.s[i+dd+dd] == '.'){
// //如果能跳...
// //cout << "??" << endl;
// nexta = a;
// nexta.s[i+dd+dd] = nexta.s[i];
// nexta.s[i] = '.';
// if(!vis.count(nexta.s)){
// vis[nexta.s] = 1;
// nexta.path.push_back(nexta.s);
// q.push(nexta);
// }
// }
// }
// for(int i = 0; i < a.s.length(); i++){
// if(a.s[i]=='.') continue;
// if(a.s[i]=='A') dd = 1;
// if(a.s[i]=='B') dd = -1;
//
// if(valid(a.s, i+dd) && a.s[i+dd]=='.'){
// //如果能移动...
// // cout << "???" << endl;
// nexta = a;
// nexta.s[i+dd] = nexta.s[i];
// nexta.s[i] = '.';
// if(!vis.count(nexta.s)){
// vis[nexta.s] = 1;
// nexta.path.push_back(nexta.s);
// q.push(nexta);
// }
// }
// }
// }
//
//}
//
//int main()
//{
// f();
// return 0;
//}
机器人塔
X星球的机器人表演拉拉队有两种服装，A和B。
他们这次表演的是搭机器人塔。
类似：
A
B B
A B A
A A B B
B B B A B
A B A B B A
队内的组塔规则是：
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 <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
这道题得全分是不可能的，一开始看到网上有用深搜暴力枚举底层的所有情况，然后底层确定了实际上整个塔就确定了，然后还原出整个塔统计AB个数，和所给AB个数比较看是否符合。这样时间复杂度是比较大的，这样写大约是得20%的分数吧
然后观察这个递推过程发现：
每层第i个和上层第i个有异或运算A^B=B ,A^A=A,B^B=A,B^A=B。 好了，本题基本结束。
map[line][i]=map[line][i-1]^map[line-1][i-1];
也就是要确定一个位置的时候是根据它的左边和左上是什么异或得到的，让A=0，B=1就行了。这样就能优化很多，大约可以过一半多的数据吧code：
//优化
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int ans;
int a[1100];
int mp[50][50];
void init(){
int sum = 0;
for(int i = 1; i <= 50; i++){
sum += i;
a[i] = sum;
}
}
void DFS(int line,int reA,int reB,int n){
//line表示当前行，reA表示可用A个数，reB可用B个数，n是总的层数
int A = reA;
int B = reB;
if(reA < 0 || reB < 0)
return;
if(line == n && A == 0 && B == 0){
ans++;
return;
}
reA = A;
reB = B;
mp[line][0] = 0;//第一个只能枚举，因为左边没有
reA--;
for(int i = 1; i <= line; i++){//因为递归函数中line是从0开始的所有实际line行应有line+1个，
//第一个枚举了，剩下个line个根据递推式确定
mp[line][i] = mp[line][i-1] ^ mp[line-1][i-1];
if(mp[line][i] == 0)
reA--;
else
reB--;
}
DFS(line+1,reA,reB,n);
reA = A;
reB = B;
mp[line][0] = 1;
reB--;
for(int i = 1; i <= line; i++){
mp[line][i] = mp[line][i-1] ^ mp[line-1][i-1];
if(mp[line][i] == 0)
reA--;
else
reB--;
}
DFS(line+1,reA,reB,n);
}
int main(){
init();
int x,y,n;
while(scanf("%d%d",&x,&y) != EOF){
ans = 0;
for(int i = 0; i <= 50; i++){
if(a[i] == x+y){
n = i;
break;
}
}
DFS(0,x,y,n);
printf("%d\n",ans);
}
return 0;
}
//一般搜索法，先深搜枚举确定最底层，只要最底层确定整个塔就确定了，然后统计ab个数比较即可但是速度慢
//#include <iostream>
//#include <cstring>
//#include <cstdio>
//using namespace std;
//int a[1100];
//char s1[1000],s2[1000];
//int vis[1000];
//int n,m,k,ans;
//void init(){
// int sum = 0;
// for(int i = 1; i <= 50; i++){
// sum += i;
// a[i] = sum;
// }
//}
//int judge(int t){//由最底层向上推出整个塔，统计出ab个数，看是否相同
// strcpy(s2+1,s1+1);
// int suma = 0,sumb = 0;
// while(t){
// for(int i = 1; i <= t; i++){
// if(s2[i] == 'A') suma++;
// if(s2[i] == 'B') sumb++;
// }
// for(int i = 1; i <= t-1; i++){
// if(s2[i] == s2[i+1])
// s2[i] = 'A';
// else
// s2[i] = 'B';
// }
// t--;
// }
// if(suma == m && sumb == n)
// return 1;
// return 0;
//}
//void dfs(int cnt){//dfs枚举最底层
// if(cnt == k+1){
// if(judge(k))
// ans++;
// return;
// }
// if(!vis[cnt]){
// vis[cnt] = 1;
// s1[cnt] = 'A';
// dfs(cnt+1);
// s1[cnt] = 'B';
// dfs(cnt+1);
// vis[cnt] = 0;
// }
//}
//int main(){
// init();
// scanf("%d%d",&m,&n);
// ans = 0;
// for(int i = 0; i <= 50; i++){
// if(a[i] == n+m){
// k = i;
// break;
// }
// }
// dfs(1);
// printf("%d\n",ans);
// return 0;
//}
广场舞
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 <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
code：
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
//待输入点的坐标
double vx[100],vy[100];
int num;//顶点个数
//关键函数，判断点是否在凸多边形内
int isIn(double testx,double testy){
for(int k = 0; k < num; k++){
if(testx == vx[k] && testy == vy[k])//这个点恰好是顶点，当然算在里面
return 1;
}
for(int i = 0; i < num; i++){
double dy = vy[(i+1)%num] - vy[i];
double dx = vx[(i+1)%num] - vx[i];
if(dx == 0.0) continue;
double k = dy / dx;//算出多边形某条面的斜率
if((vy[i] - testy) / (vx[i]-testx) == k && (testx > vx[i]) != (testx > vx[(i+1)%num]))
return 1;
//上面的判断什么意思呢？我们来分析一下，首先发现这个测试点和边上一点的斜率和这条边斜率相同说明什么
//这保证了这个点必定在这条线段上或者线段的延长线上，那么只有当在线段上才是在图形内部
//所以只需要让测试点的x横坐标在线段连端点的x横坐标之间即可，上面写法的意思就是不能在同侧
//测试点x值不能同时在两端点左侧，也不能同时在两端右侧，而在某一个点上的情况之前就已经判断了
}
//上面for循环判断了在边上的情况，我们用到了斜率，但是有一种斜率是求不出来的,就是和y轴平行的时候下面就是对这种情况的判断
for(int i = 0; i < num; i++){
if(testx == vx[i] && vx[i] == vx[(i+1)%num] && (testy > vy[i]) != (testy > vy[(i+1)%num]))
return 1;
//三点x横坐标相等，测试点的y值在两端点之间
}
//以上点在边上的情况就判断完了，下面不在边上的情况我们就利用水平射线相交点判别法判断
int flag = 0;//记录交点个数的奇偶性
for(int i = 0,j = num-1; i < num; j = i++){
if((vy[i] > testy) != (vy[j] > testy) && (testx < (vx[j] - vx[i]) * (testy - vy[i]) / (vy[j] - vy[i]) + vx[i]))
flag = !flag;
}
return flag;
//具体解释见上面博客的解释
}
bool IsSquare(double x,double y){
//判断是否可以构成小正方形及判断它本身和它的左，下，左下点是否在凸多边形内
if(isIn(x,y)){
if(!isIn(x+1.0,y)) return false;
if(!isIn(x,y-1.0)) return false;
if(!isIn(x+1.0,y-1.0)) return false;
return true;
}
else
return false;
}
int main(){
int ans = 0;
scanf("%d",&num);
for(int i = 0; i < num; i++){
scanf("%lf%lf",&vx[i],&vy[i]);
}
//获得图形的边界
double xmax = vx[0],xmin = vx[0];
double ymax = vy[0],ymin = vy[0];
for(int i = 0; i < num; i++){
xmax = max(xmax,vx[i]);
xmin = min(xmin,vx[i]);
ymax = max(ymax,vy[i]);
ymin = min(ymin,vy[i]);
}
//扫描范围内的每个点
for(double x = xmin; x <= xmax; x++){
for(double y = ymax; y >= ymin; y--){
//判断是否可以构成一个完整的小正方
if(IsSquare(x,y)) ans++;
}
}
printf("%d\n",ans);
return 0;
}
/*
7
1 2
1 4
3 7
4 4
6 6
6 2
2 1
ans:12
6
1 3
2 4
3 3
4 4
5 3
3 -1
ans:4
*/
生成树计数
给定一个 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 <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
不会。。不打算研究了，比赛肯定也不会
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
