1001 大搬家

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

1.可以所有的人都不移动

2.只选其中两个人来移动

3.选4个人来移动，其中两两分组，组内移动，依次选6，8，10, n/2*2个人两两分组来移动。

排列组合问题，算出前几组解，找出规律即可。

#include<stdio.h>
#define LL long long
#define MOD 1000000007
LL a[1000001];
int main()
{int T,N;a[1]=1;a[2]=2;a[3]=4;for(int i= 4; i<=1000000; ++i){ a[i]=a[i-1]+(i-1)*a[i-2];a[i]%=MOD;}scanf("%d",&T);for (int i=1; i<=T; i++){scanf("%d",&N);printf("Case #%d:\n%lld\n",i, a[N]);}return 0;
}

1002 列变位法解密

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,
welcometo 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

利用二维矩阵来模拟是不行（这道题50000*50000的矩阵开不了），直接计算每个字符的位置，然后输出。

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
char s[100001];
bool vis[100001];
int main()
{int t,k,n,m;scanf("%d",&t);getchar();for (int i=1; i<=t; i++){gets(s);scanf("%d",&k);getchar();int len=strlen(s);n=len/k;  //计算密文字符的行数m=len%k;  //最后一行字符的个数if (len==k || k==1){printf("Case #%d:\n",i);puts(s);continue;}int N=len;memset(vis, false, sizeof(vis));printf("Case #%d:\n",i);while(len)  //循环查找密文中各字符的位置，知道所有的字符都找完{for (int j=0; j<N;)  //遍历字符串{if (!vis[j])  //没有使用过{printf("%c",s[j]);vis[j]=true;len--;if (m)    //处理字符是最后一行的情况{j+=n+1;m--;}elsej+=n; //明文中相邻字符在密文中相隔矩阵行数}elsej++;}}printf("\n");}return 0;
}

1003 IP聚合

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

#include <iostream>
#include <set>
using namespace std;
int t,n,m;
struct node
{int a;int b;int c;int d;}IP[1001];node mask[55];int main()
{scanf("%d",&t);long long hash=0;for (int i=1; i<=t; i++){scanf("%d%d",&n,&m);for (int j=0; j<n; j++){scanf("%d.%d.%d.%d",&IP[j].a,&IP[j].b,&IP[j].c,&IP[j].d);}for (int j=0; j<m; j++){scanf("%d.%d.%d.%d",&mask[j].a,&mask[j].b,&mask[j].c,&mask[j].d);}set<long long>s;printf("Case #%d:\n",i);for (int j=0; j<m; j++){s.clear();for (int k=0; k<n; k++){hash=0;hash+=((IP[k].a&mask[j].a)*(long long)1000000000);hash+=((IP[k].b&mask[j].b)*1000000);hash+=((IP[k].c&mask[j].c)*1000);hash+=((IP[k].d&mask[j].d));s.insert(hash);}printf("%ld\n",s.size());}}return 0;
}

1004 放盘子

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

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

这道题答案已经在提示中了，如果能放中间,对方不能放边上了，那么自己赢了，如果对方还能放，那么根据对称，自己也能放，也就是说，只要对方能放，自己也一定能放，所以只要第一个能放中间，那么就一定能赢，否则就输了。

#include <iostream>
#include <cmath>
using namespace std;
int main()
{int t,n;double a,r;scanf("%d",&t);for (int i=1; i<=t; i++){scanf("%d%lf%lf",&n,&a,&r);printf("Case #%d:\n",i);double R=a/2/tan(3.1415926/n);  //内切圆半径if (r<=R){printf("Give me a kiss!\n");}else{printf("I want to kiss you!\n");}}return 0;
}

1005 下棋

Time Limit: 6000/3000 MS (Java/Others)

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

Problem Description

N∗M的棋盘上有一个受伤的国王与一个要去救援国王的骑士，他们每个单位时间必须同时移动一次寻找对方。如下图所示，黑色的图例表示国王（右）或骑士（左）当前所在的位置，那么灰色的位置表示在一次移动中他们可能到达的位置。国王伤势严重，因此他必须在K个单位时间内得到骑士的救援，否则会挂掉。问国王是否可以在K个单位时间内获得救援，如果可以，最短需要花多少个单位时间。

Input

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

每组测试数据第一行包含三个整数N,M,K, 且2≤N,M≤1000, 1≤K≤200。第二行两个整数Xking,Yking，对应国王所在方格的坐标。第三行两个整数Xknight,Yknight，对应骑士所在方格的坐标。其中1≤Xking,Xknight≤N,1≤Yking,Yknight≤M,保证骑士与国王一开始不在同一个方格内且他们都可以移动。：

Output

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

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

第二行输出测试数据的结果，如果国王可以得到救援，则输出最快需要花多少个单位时间。否则，输出“OH,NO!”。

Sample Input

Sample Output

Case #1:
1
Case #2:
OH,NO!

搜索：分别从国王和骑士开始搜k层，对比它们各自搜索后的矩阵信息。找出步数相同的最小的步数，或者步数不一致，但是满足一定条件的步数。

#include <iostream>
#include <queue>
#include <vector>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
int dir1[8][2]={1,0,1,1,0,1,-1,1,-1,0,-1,-1,0,-1,1,-1};  //国王
int dir2[8][2]={2,1,1,2,-1,2,-2,1,-2,-1,-1,-2,1,-2,2,-1}; //骑士
struct node
{int x;int y;int step;
}king,b;
int t,n,m,k;
queue<node>q;
int vis1[1001][1001];
int vis2[1001][1001];
bool check(node &a)
{if (a.x<0 || a.x>=n ||a.y<0 || a.y>=m){return false;}return true;
}
int bfs(int dir[][2],int vis[][1001])
{node temp1,t1;while (!q.empty()){temp1=q.front();q.pop();for (int i=0; i<8; i++){t1=temp1;t1.x+=dir[i][0];t1.y+=dir[i][1];t1.step++;if (t1.step>k){continue;}if (check(t1)){if (vis[t1.x][t1.y]==0){q.push(t1);vis[t1.x][t1.y]=t1.step;}else if(vis[t1.x][t1.y]>t1.step){q.push(t1);vis[t1.x][t1.y]=t1.step;}}}}return -1;
}
int main()
{scanf("%d",&t);for(int i=1;i<=t;i++){memset(vis1, 0, sizeof(vis1));memset(vis2, 0, sizeof(vis2));scanf("%d%d%d",&n,&m,&k);scanf("%d%d",&king.x,&king.y);king.x--;king.y--;king.step=0;vis1[king.x][king.y]=0;scanf("%d%d",&b.x,&b.y);b.x--;b.y--;b.step=0;vis2[b.x][b.y]=0;q.push(king);bfs(dir1,vis1); //从国王开始搜k层while (!q.empty()){q.pop();}q.push(b);     //从骑士开始搜k层bfs(dir2,vis2);int min=100000;for (int i=0; i<n; i++)  //对比两个搜索的矩阵{for (int j=0; j<m; j++){if (vis1[i][j]==vis2[i][j] && vis1[i][j]!=0) //两个步数相等{if (min>vis1[i][j]){min=vis1[i][j];}}else if(vis1[i][j]!=0 && vis2[i][j]!=0){if(vis2[i][j]%vis1[i][j]==2 || vis1[i][j]%vis2[i][j]==2) //因为可以重复走 走过的地方，则他们之间只要满足一定的关系也是可以的{if (min>max(vis2[i][j], vis1[i][j])){min=max(vis2[i][j], vis1[i][j]);}}}}}printf("Case #%d:\n",i);if (min==100000){printf("OH,NO!\n");}else{printf("%d\n",min);}}return 0;
}

1006 单调区间

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

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

Problem Description

百小度最近在逛博客，然后发现了一个有趣的问题。

如下图所示，是一个12位数014326951987, 它的数字先逐渐变大, 然后变小，再变大，接着变小，又变大，最后变小。我们就称，其共包含6个单调区间。

现在问题来了：一个n位数平均包含多少个单调区间？单调区间的平均长度又是多少？

因为我们考虑到这样的数样本太大，有10n这么多，所以百小度决定缩小样本，假定任意两位相邻数字不能相同，而且这个n位数允许以0开头。现在我已经将样本大小已经被缩小到10∗9n−1，接下来把这个问题交给你，请你开启大脑挖掘机，挖挖答案在哪里。

Input

第一行为T，表示输入数据组数。

下面T行，每行包含一个正整数n，n为不大于100000的正整数。

Output

对第i组数据，输出

Case #i:

然后输出两个实数，用空格隔开，分别为平均单调区间数和单调区间平均长度，结果保留六位小数。

Sample Input

2
2
12

Sample Output

Case #1:
1.000000 2.000000
Case #2:
8.037037 2.368664

参考：matrix67

#include<iostream>
#include<cstdio>
using namespace std;
int main()
{int t,n;scanf("%d", &t);for (int i = 1; i <= t; i++){scanf("%d", &n);printf("Case #%d:\n%.6lf %.6lf\n", i, 1 + (n - 2)*19.0 / 27.0, (46 - 38.0 / n) / (19 - 11.0 / n));}return 0;
}

下面转自matrix67

趣题：一个n位数平均有多少个单调区间？

考虑这么一个 14 位数 02565413989732 ，如图所示，它的数字先逐渐变大，然后开始变小，再变大，再变小，再变大，再变小。我们就说，它一共包含了 6 个单调区间。我们的问题就是：一个 n 位数平均有多少个单调区间？为了避免歧义，我们假设任意两位相邻的数字都不相同，因而像 77765589911 这样的数我们就不考虑了。另外，大家可能已经注意到了，我们允许这个 n 位数以数字 0 开头。因而，更精确地说，我们的问题是：相邻数字都不相同的、允许以 0 开头的所有 n 位数当中，平均有多少个单调区间？

这个题目来自 1987 年 IMO 候选题。

让我们把所有这种 n 位数的个数记作 N 。那么 N 等于多少？这个 n 位数的第一位有 10 种选择，今后的每一位都只有 9 种选择（因为要跟前一位不一样），因而 n 位数一共有 N = 10 · 9n-1 个。接下来，我们要求的就是，所有 n 位数当中的所有单调区间一共有多少个。我们换一种方法来累计这些单调区间：先算所有从第一位开始的单调区间，再算所有从第二位开始的单调区间，等等，最后算所有从第 n 位开始的单调区间。如果用 ri 来表示所有从第 i 位开始的单调区间的数目，那么我们要求的平均单调区间数就是 (r1 + r2 + … + rn) / N ，也就是 r1 / N + r2/ N + … + rn / N 。注意到其中的每一项 ri / N 其实就是从 N 个合法的 n 位数中任取一个后，存在以第 i 位数打头的单调区间的概率。因此，我们只需要求出这 n 个概率值，加起来便是我们想要的答案了。

显然， r1 / N = 1 ，因为第一位数字必然会引领一个单调区间。显然， rn / N = 0 ，因为最后一位数字不可能引领一个新的单调区间。那么，对于其他的 ri / N 呢？注意到，第 i – 1 位、第 i 位和第 i + 1 位的大小关系一共可能有以下四种情况：

其中，只有第三种情况和第四种情况下，第 i 位才会成为一个新的单调区间的开始。为了计算这两种情况发生的概率，我们只需要算出情况 1 和情况 2 发生的概率，再用 1 来减即可。情况 1 发生的概率有多大呢？三位数字串一共有 10 · 92 个（第一位有 10 种选择，后面的每一位都只有 9 种选择，因为要跟前一位不一样）。为了得到递增的数字串，我们只需要选出三个不同的数字，然后把它们从小到大排列即可，这一共有 C(10, 3) 种方法。因此，情况 1 的发生概率就是 C(10, 3) / (10 · 92) = 4/27 。同理，情况 2 的发生概率也是 4/27 ，两者加起来就是 8/27 ；反过来，情况 3 和情况 4 出现的概率就是 1 – 8/27 = 19/27 了。

因此，我们最终要求的答案就是 1 + 19/27 + 19/27 + … + 19/27 + 0 = 1 + (n – 2) · 19/27 。

这个结论还会引出很多有意思的问题。在一个 29 位数当中，平均会产生 20 个单调区间。我们似乎发现了一个很不合理的地方：这岂不意味着，平均每个单调区间的长度只有 29/20 = 1.45 个数字吗？考虑到单调区间的长度不可能恰好是 1.45 个数字，为了得到 1.45 这个平均长度，一定有些区间的长度比 1.45 小，有些区间的长度比 1.45 大。有些区间的长度比 1.45 小，这不就意味着这些区间的长度为 1 吗？而一个区间的长度显然是不可能为 1 的。怎么回事？

其实， 29/20 = 1.45 这个算式是错的。在这 20 个单调区间中，除了最后一个区间以外，每一个区间的最后一个数与下一个区间的第一个数都是公共的。因此，这个 29 位数当中，有 19 个数被重复使用了。所以，在一个 29 位数当中，单调区间的平均长度应该是 (29 + 19) / 20 = 2.4 。

类似的， n 位数的单调区间的平均长度为 (n + (19/27)(n – 2)) / (1 + (19/27)(n – 2)) = (46n – 38) / (19n – 11) = (46 – 38/n) / (19 – 11/n) 。当 n 无穷大时，其极限为 46/19 。

2015年百度之星程序设计大赛 - 资格赛相关推荐

2015年百度之星程序设计大赛 - 资格赛【题解】
1001 大搬家 Accepts: 866 Submissions: 3804 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/6 ...
2015年百度之星程序设计大赛 - 资格赛：1002列变位法解密
列变位法解密 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem De ...
2015年百度之星程序设计大赛 - 资格赛（1004放盘子）
[题目链接]:click here~~ 小度熊喜欢恶作剧.今天他向来访者们提出一个恶俗的游戏.他和来访者们轮流往一个正多边形内放盘子.最后放盘子的是获胜者,会赢得失败者的一个吻.玩了两次以后,小度熊发 ...
2018百度之星程序设计大赛 - 资格赛 hdu6345（找区间最小值）
子串查询 Time Limit: 3500/3000 MS (Java/Others) Memory Limit: 262144/262144 K (Java/Others) Total Sub ...
2018百度之星程序设计大赛资格赛（4道题的答案）
目前是百度之星的资格赛比赛时间,写对一道题就可以进入后面的比赛了,我们初赛再见咯.明明昨天就上传该文章,可惜图片太多一直列为待审核,现在图片都删了,日后再来详细补充题目吧. ###调查问卷 #incl ...
bestCoder 2015 百度之星程序设计大赛资格赛-1003-IP聚合
IP聚合 Accepts: 1907 Submissions: 5012 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/6553 ...
2017百度之星程序设计大赛 - 资格赛【1001 Floyd求最小环 1002 歪解(并查集)，1003 完全背包 1004 01背包 1005 打表找规律+卡特兰数】...
度度熊保护村庄 Accepts: 13 Submissions: 488 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/3276 ...
2017百度之星程序设计大赛-资格赛
ACM模版忙里偷闲的写了几道题,这两天好忙啊--只过一道题就能通过资格赛,所以并没有什么签到题--但是的确有的题被我想难了~~~ 1002-度度熊的王国战略 >>>并查集<& ...
2014年百度之星程序设计大赛 - 资格赛（未完成）
链接第一次看到题目的时候,我还以为,这套题目好简单,可是当我做下去的时候,发现是我想的太简单了.. 没做完,这几天补上.. Energy Conversion Problem Descriptio ...

2015年百度之星程序设计大赛 - 资格赛

1001 大搬家

1002 列变位法解密

1003 IP聚合

1004 放盘子

1005 下棋

1006 单调区间

趣题：一个n位数平均有多少个单调区间？

2015年百度之星程序设计大赛 - 资格赛相关推荐

最新文章

热门文章