- 前言
4个题里有两个SCOI的题，还都是2005年的。
- 题目
- 一、整数的表示
任何一个正整数都可以用2的幂次方表示.例如:137=27+23+20同时约定次方用括号来表示,即ab可表示为a(b)由此可知,137可表示为:2(7)+2(3)+2(0)进一步:7=22+2+20(21用2表示)3=2+20所以最后137可表示为:2(2(2)+2+2(0))+2(2+2(0))+2(0)又如:1315=210+28+25+2+1所以1315最后可表示为:2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)
输入文件:
只有一行，就是正整数n(n≤20000)
输出文件:
只有一行，就是符合约定的n的0,2表示(在表示中不能有空格)
- 二、排数问题：
设有n个正整数，将他们连接成一排，组成一个最大的多位整数。例如：n=3时，3个整数13,312,343,连成的最大整数为:34331213。又如：n=4时，4个整数7,13,4,246连接成的最大整数为7424613。
输入文件：
输入文件有N+1行，第一行为整数N（≤100）。此后N行，每行输入一个正整数（≤32767）。
输出文件：
输出:连接成的多位数。
输入输出举例：
输入arra.in：
3
13
312
343
输出arra.out：
34331213
- 三、 骑士精神（Knight）
在一个5×5的棋盘上有12个白色的骑士和12个黑色的骑士， 且有一个空位。在任何时候一个骑士都能按照骑士的走法（它可以走到和它横坐标相差为1，纵坐标相差为2或者横坐标相差为2，纵坐标相差为1的格子）移动到空位上。
给定一个初始的棋盘，怎样才能经过移动变成如下目标棋盘：
为了体现出骑士精神，他们必须以最少的步数完成任务。
输入文件：
第一行有一个正整数T(T≤10)，表示一共有N组数据。接下来有T个5×5的矩阵，0表示白色骑士，1表示黑色骑士，*表示空位。两组数据之间没有空行。
输出文件：
对于每组数据都输出一行。如果能在15步以内（包括15步）到达目标状态，则输出步数，否则输出－1。
输入输出举例：
Knight.in：
2
10110
01*11
10111
01001
00000
01011
110*1
01110
01010
00100
Knight.out
7
-1
- 四 扫雷 (Mine)
相信大家都玩过扫雷的游戏。那是在一个n*m的矩阵里面有一些雷，要你根据一些信息找出雷来。万圣节到了，“余”人国流行起了一种简单的扫雷游戏，这个游戏规则和扫雷一样，如果某个格子没有雷，那么它里面的数字表示和它8连通的格子里面雷的数目。现在棋盘是n×2的，第一列里面某些格子是雷，而第二列没有雷，如下图：
由于第一列的雷可能有多种方案满足第二列的数的限制，你的任务即根据第二列的信息确定第一列雷有多少种摆放方案。
输入文件：
第一行为N，第二行有N个数，依次为第二列的格子中的数。(1≤N≤10000）
输出文件：
一个数，即第一列中雷的摆放方案数。
输入输出举例：
Mine.in:
2
1
Mine.out
2
- 题解和代码
- 第一题一看就是递归处理。递归中最重要的一环就是设计好边界，本题中当n=20时输出2(0)，n=21时输出2，其余的就可以把n进行二进制分解再分别递归了。要注意何时输出+号。这里可以用树状数组里的低位技术(lowbit)在O(log2n)的时间里完成分解。实测Codevs中(n约为1012)用了7ms，很快。分解过后的数可以储存在一个栈里，把栈弹到只剩一个元素时就不要输出+号了。
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n;
void init()
{
freopen("number.in", "r", stdin);
freopen("number.out", "w", stdout);
scanf("%d", &n);
}
inline int f(int x)
//求指数
{
int y = -1;
while(x != 0)
{
++y;
x >>= 1;
}
return y;
}
void work(int k)
{
int *s = new int[20], top = 0;
memset(s, 0, sizeof(s));
while(k != 0)
{
s[++top] = (k & (-k));
k -= (k & (-k));
}
for(int i = top; i > 1; --i)
{
if(f(s[i]) == 0)
{
printf("2(0)");
}
else
{
if(f(s[i]) == 1)
{
printf("2");
}
else
{
printf("2(");
work(f(s[i]));
printf(")");
}
}
printf("+");
}
if(f(s[1]) == 0)
{
printf("2(0)");
}
else
{
if(f(s[1]) == 1)
{
printf("2");
}
else
{
printf("2(");
work(f(s[1]));
printf(")");
}
}
delete [] s;
s = NULL;
}
int main()
{
init();
work(n);
return 0;
}
- 第二题是很明显的贪心，但有两种常见的错误思路：
把大的数放前面。反例，9、13，913>139;
把短的数放前面。反例，12、123，12312>12123。我一开始就犯了这个错误。
其实只要把a和b这两个数按ab和ba的方式分别放一下，然后若ab>ba，则把a放b前面（可以不相邻）；若ab<ba，则把b放a前面（也可以不相邻）。这样自定义一个比较函数，快排即可。
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct number
{
int num;
bool operator < (number b) const
{
int *p = new int[20], *bp = new int[20];
int top = 0, btop = 0, k = num;
bool flag = false;
memset(p, 0, sizeof(p));
memset(bp, 0, sizeof(bp));
//分解每一位
while(k > 0)
{
p[++top] = k % 10;
k /= 10;
}
while(b.num > 0)
{
bp[++btop] = b.num % 10;
b.num /= 10;
}
long long s = 0, bs = 0;
//按ab方式连
for(int i = top; i > 0; --i)
{
s = s * 10 + p[i];
}
for(int i = btop; i > 0; --i)
{
s = s * 10 + bp[i];
}
//按ba方式连
for(int i = btop; i > 0; --i)
{
bs = bs * 10 + bp[i];
}
for(int i = top; i > 0; --i)
{
bs = bs * 10 + p[i];
}
if(s > bs)
{
flag = true;
}
delete [] p;
delete [] bp;
p = bp = NULL;
return flag;
}
};
number a[105];
int n;
int main()
{
freopen("arra.in", "r", stdin);
freopen("arra.out", "w", stdout);
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
{
scanf("%d", &a[i].num);
}
sort(a + 1, a + n + 1);
for(int i = 1; i <= n; ++i)
{
printf("%d", a[i].num);
}
return 0;
}
- 第三题一眼看上去是一道广搜，但算了一下状态数，发现最多到了815……于是乎想到启发式迭代加深，即IDA*。然而不幸的是没*对，全都-1。后来把启发函数改成了普通的可行性剪枝（就是代码中残留的h函数，它的返回值一开始是int的），然后竟然没T。IDA*->dfsID……实际上这个可行性剪枝是非常强的，当前步数加上和标准答案不一致的位置数如果超过了总步数，那么一定无解。因为走一步顶多把一个骑士的位置修正到正确位置。
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
const int t[5][5] = {{1, 1, 1, 1, 1}, {0, 1, 1, 1, 1}, {0, 0, -1, 1, 1}, {0, 0, 0, 0, 1}, {0, 0, 0, 0, 0}};
const int dx[8] = {-2, -1, 1, 2, 2, 1, -1, -2}, dy[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int T, K, sx, sy;
int s[5][5];
bool flag;
void init()
{
char a[10];
flag = false;
for(int i = 0; i < 5; ++i)
{
scanf("%s", &a);
for(int j = 0; j < 5; ++j)
{
if(a[j] == ‘*‘)
{
sx = i; sy = j;
s[i][j] = -1;
}
else
{
s[i][j] = a[j] - ‘0‘;
}
}
}
}
bool check(int p[5][5])
{
for(int i = 0; i < 5; ++i)
{
for(int j = 0; j < 5; ++j)
{
if(p[i][j] != t[i][j])
{
return false;
}
}
}
return true;
}
bool h(int now[5][5], int nowk)
{
int k = 0;
for(int i = 0; i < 5; ++i)
{
for(int j = 0; j < 5; ++j)
{
if(now[i][j] != t[i][j])
{
++k;
if(k + nowk > K)
{
return false;
}
}
}
}
return true;
}
void dfs(int now[5][5], int x, int y, int nowk)
{
if(nowk == K)
{
if(check(now))
{
flag = true;
return;
}
}
if(flag)
{
return;
}
for(int i = 0; i < 8; ++i)
{
int nx = x + dx[i], ny = y + dy[i];
if(nx >= 0 && ny >= 0 && nx < 5 && ny < 5)
{
swap(now[x][y], now[nx][ny]);
if(h(now, nowk))
{
dfs(now, nx, ny, nowk + 1);
}
swap(now[x][y], now[nx][ny]);
}
}
}
int main()
{
freopen("knight.in", "r", stdin);
freopen("knight.out", "w", stdout);
scanf("%d", &T);
while(T--)
{
init();
for(K = 1; K <= 15; ++K)
{
dfs(s, sx, sy, 0);
if(flag)
{
printf("%d\n", K);
break;
}
}
if(!flag)
{
puts("-1");
}
}
return 0;
}
- 第四题看上去像dp计数问题，但一开始并没有想到如何转移，于是先写了个暴搜。起初为了便于以后对拍大数据，就先预处理了一下必须放雷的格子，然后加了若干可行性剪枝。后来跑大数据时发现挺快的，于是交到了bzoj上，结果20msAC。省选题啊！暴搜都能过？
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n, a[10005], ans, c[10005];
bool f[10005];
void init()
{
freopen("mine.in", "r", stdin);
freopen("mine.out", "w", stdout);
memset(f, 0, sizeof(f));
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
{
scanf("%d", &a[i]);
if(a[i] == 3)
{
f[i - 1] = f[i] = f[i + 1] = true;
}
}
if(a[1] == 2)
{
f[1] = f[2] = true;
}
if(a[n] == 2)
{
f[n] = f[n - 1] = true;
}
}
void dfs(int k, bool b)
//该放第k个位置，同时第k-1个位置有没有放雷
{
if(k > n && c[k - 1] == a[k - 1])
{
++ans;
return;
}
if(c[k - 2] != a[k - 2])
{
return;
}
if(c[k - 1] < a[k - 1] && c[k] < a[k])
{
++c[k - 1]; ++c[k]; ++c[k + 1];
dfs(k + 1, true);
--c[k - 1]; --c[k]; --c[k + 1];
}
if((!f[k]) && (c[k - 1] == a[k - 1]))
{
dfs(k + 1, false);
}
}
void work()
{
++c[1]; ++c[2];
dfs(2, true);
--c[1]; --c[2];
dfs(2, false);
printf("%d\n", ans);
}
int main()
{
init();
work();
return 0;
}
后来想到了一种方式：f[i][0||1][0||1][0||1]第一维表示递推到第i个位置，第二维表示i-1位置的放雷情况，第三维是i位置放雷情况，第四维i+1位置。这样方程就非常清晰（详见代码)。
只是要注意1的左边和n的右边是不能放雷的。
#include <cstdio>
#include <algorithm>
using namespace std;
int n, a[10005], f[10005][2][2][2];
void init()
{
freopen("mine.in", "r", stdin);
freopen("mine.out", "w", stdout);
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
{
scanf("%d", &a[i]);
}
switch(a[1])
{
case 0: f[1][0][0][0] = 1;
break;
case 1: f[1][0][1][0] = f[1][0][0][1] = 1;
break;
case 2: f[1][0][1][1] = 1;
break;
default:break;
}
}
void work()
{
for(int i = 2; i < n; ++i)
{
switch(a[i])
{
case 0: f[i][0][0][0] = f[i - 1][1][0][0] + f[i - 1][0][0][0];
break;
case 1: f[i][1][0][0] = f[i - 1][1][1][0] + f[i - 1][0][1][0];
f[i][0][1][0] = f[i - 1][1][0][1] + f[i - 1][0][0][1];
f[i][0][0][1] = f[i - 1][1][0][0] + f[i - 1][0][0][0];
break;
case 2: f[i][1][1][0] = f[i - 1][1][1][1] + f[i - 1][0][1][1];
f[i][1][0][1] = f[i - 1][1][1][0] + f[i - 1][0][1][0];
f[i][0][1][1] = f[i - 1][1][0][1] + f[i - 1][0][0][1];
break;
case 3: f[i][1][1][1] = f[i - 1][1][1][1] + f[i - 1][0][1][1];
break;
default:break;
}
}
int ans = 0;
switch(a[n])
{
case 0: ans += f[n - 1][1][0][0] + f[n - 1][0][0][0];
break;
case 1: ans += f[n - 1][1][1][0] + f[n - 1][0][1][0];
ans += f[n - 1][1][0][1] + f[n - 1][0][0][1];
break;
case 2: ans += f[n - 1][1][1][1] + f[n - 1][0][1][1];
break;
default:break;
}
printf("%d\n", ans);
}
int main()
{
init();
work();
return 0;
}
- 总结
暂时没思路时要毫不犹豫地先把搜索写上，再没思路就专心优化自己的搜索。遇到简单的题目更要细心，一旦想错了就什么都完了。
版权声明：本文为博主原创文章，未经博主允许不得转载。