信息技术领域关键分析与应用-优快云博客

本文链接：https://blog.youkuaiyun.com/u010660276/article/details/46003145

大搬家

Accepts: 1516

Submissions: 6288

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

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

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

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

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

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

思路：dp[i]表示i个人，两次搬家回到原位置的方法，那么可得状态转移方程

dp[i]=dp[i-1]+dp[i-2]*(n-1)

表示新加进来的人要么自己转移到自己，要么从前面选一个人组成二元组

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define LL long long
const int  N = 1000005;
const LL mod = 1000000007;

LL dp[N];
void init ()
{
    dp[1]=1;
    dp[2]=2;
    for(int i=3; i<N; i++)
    {
        dp[i]=dp[i-1]+(i-1)*dp[i-2];
        dp[i]%=mod;
    }

}
int main()
{
    int T,n;
    scanf("%d",&T);
    int test=1;
    init();
    while (T--)
    {
        printf("Case #%d:\n",test++);
        scanf("%d",&n);
        printf("%d\n",dp[n]);
    }
    return 0;
}

下棋

Accepts: 345

Submissions: 2382

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

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

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

第一行包含一个整数 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 ,保证骑士与国王一开始不在同一个方格内且他们都可以移动。：

思路：首先bfs处理处king和knight到每个节点的最短时间，如果king先到达，那么答案时间就是knight到达的时间（因为如果king在k时间到达这个节点吗，那么肯定可以在>=k的时间到达这个节点），如果knight先到达，那么时间就是king到达的时间+如果奇偶性不同的话要加上额外的1，因为要同时移动，必须相同的奇偶时间到达这个点

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int maxn=1010;
const int INF=0x3f3f3f3f;
int dis[2][maxn][maxn];
int N,M,K;
int X[2],Y[2];
int dx[2][8]={{-1,-1,-1,0,1,1,1,0},{-1,-2,-2,-1,1,2,2,1}};
int dy[2][8]={{-1,0,1,1,1,0,-1,-1},{-2,-1,1,2,2,1,-1,-2}};
struct node
{
    int x,y,t;
};
int main()
{
    int T,cas=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&N,&M,&K);
        scanf("%d%d%d%d",&X[0],&Y[0],&X[1],&Y[1]);
        queue<node> q;
        memset(dis,INF,sizeof(dis));
        for(int S=0;S<2;S++)
        {
            while(!q.empty())q.pop();
            dis[S][X[S]][Y[S]]=0;
            node a;
            a.x=X[S],a.y=Y[S],a.t=0;
            q.push(a);
            while(!q.empty())
            {
                node b=q.front();q.pop();
                if(b.t>K)break;
                for(int i=0;i<8;i++)
                {
                    a.x=b.x+dx[S][i],a.y=b.y+dy[S][i];
                    if(a.x<=0||a.x>N||a.y<=0||a.y>M||dis[S][a.x][a.y]<INF)continue;
                    a.t=b.t+1;
                    dis[S][a.x][a.y]=a.t;
                    q.push(a);
                }
            }
        }
        int ans=INF+10;
        for(int i=1;i<=N;i++)
            for(int j=1;j<=M;j++)
            {
                if(dis[1][i][j]<=dis[0][i][j])ans=min(ans,dis[0][i][j]+(dis[0][i][j]&1^dis[1][i][j]&1));
                else if(dis[1][i][j]>1)ans=min(ans,dis[1][i][j]);
            }
        printf("Case #%d:\n",cas++);
        if(ans<=K)printf("%d\n",ans);
        else printf("OH,NO!\n");

    }
    return 0;
}

单调区间

Accepts: 358

Submissions: 938

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

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

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

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

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

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

这个题是Matrix67顾森大神的博客上的，下面转自：http://www.matrix67.com/blog/archives/5296

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

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

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

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

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

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

参考资料：Ross Honsberger, From Erdos to Kiev: Problems of Olympiad Caliber, pp. 29-33

非常神奇！

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int maxn=100010;
int N;
int main()
{
    int T,cas=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&N);
        printf("Case #%d:\n",cas++);
        printf("%.6lf %.6lf\n",1.0+(N-2)*19.0/27.0,(46.0-38.0/N)/(19.0-11.0/N) );
    }
    return 0;
}