码迷,mamicode.com
首页 > 其他好文 > 详细

20150714学校测试

时间:2015-07-14 18:18:11      阅读:109      评论:0      收藏:0      [点我收藏+]

标签:

  • 前言
    4个题里有两个SCOI的题,还都是2005年的。

  • 题目

  • 一、整数的表示
    任何一个正整数都可以用2的幂次方表示.例如:137=27+23+20同时约定次方用括号来表示,即ab可表示为a(b)由此可知,137可表示为:2(7)+2(3)+2(0)进一步:7=22+2+20(212)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(n20000)
    输出文件:
    只有一行,就是符合约定的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(T10),表示一共有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个数,依次为第二列的格子中的数。(1N10000
    输出文件:
    一个数,即第一列中雷的摆放方案数。
    输入输出举例:
    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;
}
  • 总结
    暂时没思路时要毫不犹豫地先把搜索写上,再没思路就专心优化自己的搜索。遇到简单的题目更要细心,一旦想错了就什么都完了。

版权声明:本文为博主原创文章,未经博主允许不得转载。

20150714学校测试

标签:

原文地址:http://blog.csdn.net/t14t41t/article/details/46879043

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!