1001 大搬家
Time Limit: 2000/1000 MS (Java/Others)
Memory Limit: 65536/65536 K (Java/Others)
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)
利用二维矩阵来模拟是不行（这道题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--;
}
else
j+=n; //明文中相邻字符在密文中相隔矩阵行数
}
else
j++;
}
}
printf("\n");
}
return 0;
}
1003 IP聚合
Time Limit: 2000/1000 MS (Java/Others)
Memory Limit: 65536/65536 K (Java/Others)
#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)
这道题答案已经在提示中了，如果能放中间,对方不能放边上了，那么自己赢了，如果对方还能放，那么根据对称，自己也能放，也就是说，只要对方能放，自己也一定能放，所以只要第一个能放中间，那么就一定能赢，否则就输了。
#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)
搜索：分别从国王和骑士开始搜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;
}
Time Limit: 2000/1000 MS (Java/Others)
Memory Limit: 65536/65536 K (Java/Others)
参考：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 。
375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
