2015年百度之星程序设计大赛 - 资格赛【题解】

1001 大搬家

Accepts: 866

Submissions: 3804

Time Limit: 2000/1000 MS (Java/Others)

Memory Limit: 65536/65536 K (Java/Others)

Problem Description

近期B厂组织了一次大搬家，所有人都要按照指示换到指定的座位上。指示的内容是坐在位置i上的人要搬到位置j上。现在B厂有N个人，一对一到N个位置上。搬家之后也是一一对应的，改变的只有位次。

在第一次搬家后，度度熊由于疏忽，又要求大家按照原指示进行了一次搬家。于是，机智的它想到：再按这个指示搬一次家不就可以恢复第一次搬家的样子了。于是，B厂史无前例的进行了连续三次搬家。

虽然我们都知道度度熊的“机智”常常令人堪忧，但是不可思议的是，这回真的应验了。第三次搬家后的结果和第一次的结果完全相同。

那么，有多少种指示会让这种事情发生呢？如果两种指示中至少有一个人的目标位置不同，就认为这两种指示是不相同的。

Input

第一行一个整数T，表示T组数据。

每组数据包含一个整数N(1≤N≤1000000)。

Output

对于每组数据，先输出一行 Case #i: 然后输出结果，对1000000007取模。

Sample Input

2

1

3

Sample Output

Case #1:

1

Case #2:

4
解题思路：这道题应该这样去思考：因为数据范围在1000000以内，所以需要打表存储一下。打表的过程递推过来。
f[i]表示n==i时候的结果（取模之后的），在不考虑是否数据是否溢出的前提下，思考f[i]应该等于多少，或者该
如何计算出来。
思路：加法原理，当前有i-1，我们已经知道了f[i-1],我们现在要把i加进来，此时如果第i单独映
射的话,其余的就是f[i-1]的所有情况，就f[i]=f[i-1]. 如果i和其他的进行两两映射，则有（i-1）种选法，当
选定某一个后，其余的i-2个数就会有f[i-2]中组合方式。所以最后的推导公式是：
f[i] = f[i-1]+(i-1)*f[i-2].(还要防止类型溢出)

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <ctype.h>

#include <math.h>

#include <algorithm>

#define mod 1000000007



using namespace std;

__int64 f[1000000+10];

void work()

{

    f[0]=0;

    f[1]=1;

    f[2]=2;

    f[3]=4;

    //f[i] = f[i-1] + (i-1)*f[i-2]



    for(int i=4; i<=1000000; i++){

        f[i] = (f[i-1]%mod +(i-1)*f[i-2]%mod)%mod ;

    }

}



int main()

{

    int t; scanf("%d", &t);

    int i, j, k;

    int n;



    work();

    int cnt=1;

    while(t--)

    {

        scanf("%d", &n);

        printf("Case #%d:\n", cnt++ );

        printf("%I64d\n", f[n]);

    }

    return 0;

}

 

1002 列变位法解密

Accepts: 778

Submissions: 2693

Time Limit: 2000/1000 MS (Java/Others)

Memory Limit: 65536/65536 K (Java/Others)

Problem Description

列变位法是古典密码算法中变位加密的一种方法，具体过程如下 将明文字符分割成个数固定的分组（如5个一组，5即为密钥），按一组一行的次序整齐排列，最后不足一组不放置任何字符，完成后按列读取即成密文。

比如：

原文：123456789

密钥：4

变换后的矩阵：

1234

5678

9xxx

（最后的几个x表示无任何字符，不是空格，不是制表符，就没有任何字符，下同）

密文：159263748

再比如：

原文：Hello, welcome to my dream world!

密钥：7

变换后的矩阵：

Hello,

welcome

 to my 

dream w

orld!xx

密文：

Hw doeetrrlloellc adoomm!,my e w

实现一个利用列变位法的加密器对Bob来说轻而易举，可是，对Bob来说，想清楚如何写一个相应的解密器似乎有点困难，你能帮帮他吗？

Input

第一行一个整数T，表示T组数据。

每组数据包含2行

第一行，一个字符串s（1≤|s|≤1e5），表示经过列变位法加密后的密文

第二行，一个整数K（1≤K≤|s|），表示原文在使用列变位法加密时的密钥

输入保证密文字符串中只含有ASCII码在[0x20,0x7F)范围内的字符

Output

对于每组数据，先输出一行

Case #i:

然后输出一行，包含一个字符串s_decrypt，表示解密后得到的明文

Sample Input

4

159263748

4

Hw doeetrrlloellc adoomm!,my  e w

7

Toodming is best

16

sokaisan

1

Sample Output

Case #1:

123456789

Case #2:

Hello, welcome to my dream world!

Case #3:

Toodming is best

Case #4:

sokaisan
算法分析：此题目不能开二维矩阵直接存储，用vector很好实现模拟。一次将串的每个字符放入它在矩阵中的正确位置后，再将每一行一次输
出出来就行了。
代码：

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <math.h>

#include <vector>

#include <set>

#include <algorithm>

#define N 100000+10



using namespace std;





int main()

{

    int t;

    int i, j, k;



    scanf("%d", &t);

    char s[N];

    int n;

    vector<char>q[N];

    int cnt=1;



    while(t--)

    {

        scanf("%*c");

        gets(s);

        //puts(s);

        int len=strlen(s);

        //printf("len=%d\n", len);

        scanf("%d", &n); //代表列数

        int hang=len/n;

        if(len%n > 0)

            hang++; //行数+1

        //计算最后一行有几个空位

        int kong=n-(len%n);

        int dd=n-kong; //计算有几个完整列



        for(i=0; i<=hang; i++)

            q[i].clear();



        int e=0;

        if(dd==0){

            for(i=0; i<len; i++)

            {

                q[e].push_back(s[i]);

                e++;

                if(e==hang) e=0;

            }

        }

        else {

            for(i=0; i<len; i++){

                q[e].push_back(s[i]);

                e++;

                if(e == hang )  //填充了一个列

                {

                    e=0;

                    dd--;

                    if(dd==0)

                        hang--;

                }

            }

        }



        printf("Case #%d:\n", cnt++);

        for(i=0; i<hang; i++)

        {

            for(j=0; j<q[i].size(); j++)

                printf("%c", q[i][j]);

        }

        if(len%n > 0)

            for(i=0; i<q[hang].size(); i++)

                printf("%c", q[hang][i]);

        printf("\n");

    }

    return 0;

}

 

1003 IP聚合

Accepts: 811

Submissions: 1850

Time Limit: 2000/1000 MS (Java/Others)

Memory Limit: 65536/65536 K (Java/Others)

Problem Description

当今世界，网络已经无处不在了，小度熊由于犯了错误，当上了度度公司的网络管理员，他手上有大量的 IP列表，小度熊想知道在某个固定的子网掩码下，有多少个网络地址。网络地址等于子网掩码与 IP 地址按位进行与运算后的结果，例如：

子网掩码：A.B.C.D

IP 地址：a.b.c.d

网络地址：(A&a).(B&b).(C&c).(D&d)

Input

第一行包含一个整数T，（1≤T≤50）代表测试数据的组数，

接下来T组测试数据。每组测试数据包含若干行，

第一行两个正整数N（1≤N≤1000,1≤M≤50）,M。接下来N行，每行一个字符串，代表一个 IP 地址，

再接下来M行，每行一个字符串代表子网掩码。IP 地址和子网掩码均采用 A.B.C.D的形式，其中A、B、C、D均为非负整数，且小于等于255。

Output

对于每组测试数据，输出两行：

第一行输出: "Case #i:" 。i代表第i组测试数据。

第二行输出测试数据的结果，对于每组数据中的每一个子网掩码，输出在此子网掩码下的网络地址的数量。

Sample Input

2

5 2

192.168.1.0

192.168.1.101

192.168.2.5

192.168.2.7

202.14.27.235

255.255.255.0

255.255.0.0

4 2

127.127.0.1

10.134.52.0

127.0.10.1

10.134.0.2

235.235.0.0

1.57.16.0

Sample Output

Case #1:

3

2

Case #2:

3

4
算法分析：打表去重统计计数输出。 STL vector+set

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <math.h>

#include <vector>

#include <set>

#include <algorithm>





using namespace std;



struct node

{

    int a,b,c,d;

    bool operator <(const node &x)const{

        if(a==x.a){

            if(b==x.b){

                if(c==x.c){

                    return d<x.d;

                }else

                return c<x.c;

            }else

            return b<x.b;

        }else

        return a<x.a;

    }

}cur;



int main()

{

    int t;

    int i, j, k;

    scanf("%d", &t);



    int n, m;

    int cnt=1;

    char s[200];

    int a,b,c,d;

    while(t--)

    {

        scanf("%d %d", &n, &m);

        set<node>q; q.clear();

        vector<node>p; p.clear();

        vector<node>w; w.clear();

        //printf("%d %d %d %d\n", a,b, c, d);



        for(i=0; i<n; i++){

            scanf("%d.%d.%d.%d", &cur.a, &cur.b, &cur.c, &cur.d);

            p.push_back(cur);

        } //IP地址



        for(i=0; i<m; i++){

            scanf("%d.%d.%d.%d", &cur.a, &cur.b, &cur.c, &cur.d);

            w.push_back(cur);

        } //网络地址

        node cc;

        printf("Case #%d:\n", cnt++);

        for(i=0; i<m; i++)

        {

            for(j=0; j<n; j++)

            {

                cc.a=p[j].a & w[i].a;

                cc.b=p[j].b & w[i].b;

                cc.c=p[j].c & w[i].c;

                cc.d=p[j].d & w[i].d;

                q.insert(cc);

            }

            printf("%d\n", q.size());

            q.clear();

        }



    }

	return 0;

}

 

1004 放盘子

Accepts: 846

Submissions: 2224

Time Limit: 2000/1000 MS (Java/Others)

Memory Limit: 65536/65536 K (Java/Others)

Problem Description

小度熊喜欢恶作剧。今天他向来访者们提出一个恶俗的游戏。他和来访者们轮流往一个正多边形内放盘子。最后放盘子的是获胜者，会赢得失败者的一个吻。玩了两次以后，小度熊发现来访者们都知道游戏的必胜策略。现在小度熊永远是先手，他想知道他是否能获胜。

注意盘子不能相交也不能和多边形相交也不能放在多边形外。就是说，盘子内的点不能在多边形外或者别的盘子内。

Input

第一行一个整数T，表示T组数据。每组数据包含3个数n,a,r(4≤n≤100,0<a<1000,0<r<1000)

n是偶数，代表多边形的边数，a代表正多边形的边长，r代表盘子的半径。

Output

对于每组数据，先输出一行

Case #i:

然后输出结果.如果小度熊获胜，输出”Give me a kiss!” 否则输出”I want to kiss you!”

Sample Input

2

4 50 2.5

4 5.5 3

Sample Output

Case #1:

Give me a kiss!

Case #2:

I want to kiss you!

Hint

在第一组样例中，小度熊先在多边形中间放一个盘子，接下来无论来访者怎么放，小度熊都根据多边形中心与来访者的盘子对称着放就能获胜。

解题分析：可以参看这个博客http://www.cnblogs.com/crazyacking/p/4524687.html，只要多边形对边的距离大于 圆盘的直径就会是小度熊赢的！
代码：

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <ctype.h>

#include <math.h>

#include <algorithm>

#define mod 1000000007

#define PI acos(-1.0)



using namespace std;



int main()

{

    int t;

    scanf("%d", &t);

    int i, j;

    int n; double d, r;

    int cnt=1;

    while(t--)

    {

        scanf("%d %lf %lf", &n, &d, &r);

        double o=360.0/n/2.0; //开始这是int的定义 WA一次

        double cc=(2.0*PI*o)/360.0;

        double h=(d/2.0)/(tan(cc));

        h=h*2.0;

        r=r*2.0;

        printf("Case #%d:\n", cnt++ );

        if(h>=r){

            printf("Give me a kiss!\n");

        }

        else

            printf("I want to kiss you!\n");

    }

    return 0;

}