NOIP2018提高组模拟题（五）

最新推荐文章于 2021-02-14 19:50:11 发布

weixin_30659829

最新推荐文章于 2021-02-14 19:50:11 发布

阅读量185

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/-guz/p/9865636.html

版权

字符串(string)

Description

小林与亮亮正在做一个游戏。小林随意地写出一个字符串，字符串只由大写字母组成，然后指定一个非负整数 m，亮亮可以进行至多 m 次操作，每次操作为交换相邻两个字符。亮亮的目标是使得操作后的字符串出现最长相同的字符的长度最大。你能帮亮亮计算一下这个最大长度是多少吗？

Input

第一行一个字符串 S。第二行一个整数 m。

Output

只有一个整数，表示所求的最大长度。

表示刚开始想了一个小时的\(DP\)

然后还出样例了,

~~要不是手出了一组样例就凉了~~

然后还有20分钟的时候,发现是个贪心+递归

将两侧的向中间移动显然更优.

容易发现,同种字母移动才会产生影响.

因此直接枚举每种字母,记录其位置.

由于从某一位置到目标位置的交换次数可求.所以这样是可做的.

\(\color{red}{官方题解}\)~~表示没看太懂~~

考察内容：字符串、枚举与贪心

字符串长度不超过 50，我们就可以枚举哪一个字符不动，其他相同字符向它靠近，左右两边相同字符计算出它们与选定字符相邻需要移动几次，以此为关键值从小到大排序，贪心地处理即可。

代码

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#define R register
using namespace std;
inline void in(int &x)
{
    int f=1;x=0;char s=getchar();
    while(!isdigit(s)){if(s=='-')f=-1;s=getchar();}
    while(isdigit(s)){x=x*10+s-'0';s=getchar();}
    x*=f;
}
int ans,m,n;
int pos[833];
char s[833];
inline int cs(char s)
{
    return s-'A'+1;
}
inline int calc(int l,int r)
{
    if(l==r)return 0;
    if(l==r-1)return pos[r]-pos[l]-1;
    return calc(l+1,r-1)+pos[r]-pos[l]-(r-l);
}
int main()
{
    freopen("string.in","r",stdin);
    freopen("string.out","w",stdout);
    scanf("%s",s+1);in(m);n=strlen(s+1);
    for(R int i=1;i<=26;i++)
    {
        int tmp=0;
        for(R int j=1;j<=n;j++)
            if(cs(s[j])==i)pos[++tmp]=j;
        if(tmp==1){ans=max(ans,1);continue;}
        int now=-2147483644;
        for(R int j=1;j<=tmp;j++)
            for(R int l=j+1;l<=tmp;l++)
                if(calc(j,l)<=m)
                    now=max(now,l-j+1);
        ans=max(ans,now);
    }
    printf("%d",ans);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

桃园之礼(peach)

Description

小林和亮亮在桃园里一起玩游戏。桃园里的桃树成行成列，刚好构成一个 N ×M 的矩阵，亮亮在某些桃树下放置了一些小礼物，要求小林把所有树下的礼物全部收集起来。小林从左上角的桃树(1,1)出发，走到右下角的桃树(N,M)。他只能沿着路径向下或者向右走，某些桃树下有礼物，他必须到达所有有礼物的树下并把礼物收集起来。小林在出发前，想请你帮他计算一下，他有多少种不同的走法。由于答案可能很大，你只需要输出答案模 100000000（10^8）后的值即可。

Input

第一行三个整数 N,M 和 K。 N,M 表示矩阵的大小， K 表示有礼物的桃树的棵数。

接下来 k 行，每行两个整数 X,Y，表示一棵有礼物的桃树的坐标(X,Y)

Output

只有一个整数，表示不同的走法数模 100000000 后的值。

刚开始没看懂题.

首先不考虑中间的有礼物的树.

我们就是求解从\((1,1)\)到\((n,m)\)的走法.

有这么多种
\[ C_{n+m-2}^{m-1} \]

因为我们只可能会走\(n+m-2\)步,而我们必须要选择\(m-1\)步走横向.

这\(m-1\)步随便选.即\(C_{n+m-2}^{m-1}\)，

当然也可以是
\[ C_{n+m-2}^{n-1} \]
然后就是将大的矩形拆成小的矩形了.,

比如,如果一些地方有礼物的树.,我们就可以拆成这些子矩形。

然后我们求解子矩形从左上角到右下角的方案数.

根据乘法原理累乘即可.

注意判无解的情况!!!(被卡了\(10pts\))

这题恶心就恶心在模数不是一个质数.

我们可以考虑质因数分解来求解.

这里就不过多解释如何质因数分解了,相信大家能看懂代码的.

\(\color{red}{官方题解}\)

考察算法：质因数分解（或逆元+中国剩余定理）、排列组合

根据乘法原理，问题可以分解为求在一个 n*m 的矩形中，从左上角走到右下角共有几种走法。显然答案为 \(C_{n+m-2}^{m-1}\) 。我们既可以用分解质因数的方法来计算，也可以采用求逆元与中国剩余定理的方法来处理除法

代码

#include<cstdio>
#include<iostream>
#include<algorithm>
#define N 10008
#define mod 100000000
#define R register
#define int long long 
using namespace std;
inline void in(int &x)
{
    int f=1;x=0;char s=getchar();
    while(!isdigit(s)){if(s=='-')f=-1;s=getchar();}
    while(isdigit(s)){x=x*10+s-'0';s=getchar();}
    x*=f;
}
int n,m,k,ans=1,cur;
struct cod{int x,y;}t[10008];
bool vis[60008];
int prime[60008],cnt,f[60008];
inline void pri()
{
    for (R int i=2;i<=n+m;i++)
    {
        if (!vis[i]) prime[++cnt] = i;
        for (R int j=1;j<=cnt and i*prime[j]<=n+m;j++)
        {
            vis[i*prime[j]]=true;
            if (i%prime[j]==0) break;
        }
    }
}
inline int ksm(int x,int &y)//这里加&,可以达到memset的效果. 
{
    R int res=1;
    for(;y;y>>=1,x=x*x%mod)
        if(y&1)res=res*x%mod;
    return res;
}
inline void calc(int x,int v)
{
    for (R int i=1;i<=cnt and prime[i]<=x;i++) 
    while(x%prime[i]==0)f[i]+=v,x/=prime[i];
    cur=cur*x%mod; 
}
inline int C(int x,int y)
{
    if (y>x) return 0;
    cur=1;
    for(R int i=x-y+1;i<=x;i++) calc(i,1);
    for(R int i=1;i<=y;i++) calc(i,-1);
    for(R int i=1;i<=cnt and prime[i]<=x;i++)
        (cur*=ksm(prime[i],f[i]))%=mod;
    return cur;
}
inline bool ccp(const cod&a,const cod&b)
{
    if(a.x==b.x)return a.y<b.y;
    return a.x<b.x;
}
signed main()
{
    freopen("peach.in","r",stdin);
    freopen("peach.out","w",stdout);
    in(n),in(m),in(k);pri();
    t[1].x=t[1].y=1;
    for(R int i=2;i<=k+1;i++)
        in(t[i].x),in(t[i].y);
    t[2+k].x=n,t[2+k].y=m;
    sort(t+1,t+k+3,ccp);
    for(R int i=2;i<=k+2;i++)
    {
        int nn=t[i].x-t[i-1].x+1,mm=t[i].y-t[i-1].y+1;
        if(nn<=0 or mm<=0)//判无解 
        {
            puts("0");
            return 0;
        }
        (ans*=C(nn+mm-2,mm-1))%=mod;
    }
    printf("%lld",ans);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

魔法森林(forest)

Description

亮亮在梦中游历了魔法城堡后，对此心驰神往，于是用自己制造的法杖，创造了一片魔法森林。

这片森林中一开始有 n 个节点，没有边相连，若想要在第 i 个点和第 j 个点之间建立一条双向通路，则需花费 Cij 的魔法值。

每个结点上住着一个魔法居民，若两个节点间有边直接相连，则他们就成为了邻居。居民一共有三种类型：

①村民：他们只能通过道路拜访自己的邻居。

②巫师：他们可以拜访自己的邻居以及邻居的邻居。

③大魔法师：由于他们拥有法力，因此可以拜访所有与自己连通的人。

亮亮不希望有人孤单，因此他保证了每种类型的居民要么不出现，否则至少出现两个。同时，他又希望大家能建立良好的关系，所以他决定花费魔法值为魔法森林修路，使得任意居民都可以拜访其他所有的居民。

他想知道，最少需要建立多少条道路才能达成自己的心愿。在道路数目最少的前提下，花费的魔法值最小又是多少。

Input

第一行有一个整数 n。

第二行有 n 个整数，第 i 个整数表示 i 号节点所居住的居民的类型（1 表示村民， 2 表示巫师， 3 表示大魔法师）。

接下来 n 行，每行 n 个数，是一个 n*n 的矩阵 Cij。数据保证 Cij = Cji, Cii=0。

Output

一行两个整数，分别表示最小道路数和最小魔法值。

这里就不多BB了,官方题解写的挺好.

\(\color{red}{官方题解}\)

考察算法：分类讨论、图论

①存在第一类点的情况

此时，显然要从每个第一类点向其它点连边。我们发现这样是满足要求的，因为这样一来，每个第二类点都可以通过第一步到达一个第一类点来访问所有点，并且整个图显然也是连通的。直接模拟即可。

②只存在第三类点的情况

此时，目的是使所有点连通。也就是一个最小生成树问题。使用 \(Prim\) 或 \(Kruskal\) 在 \(O(N^2)\)或 \(O(N^2logN)\)中解决。

③其他情况

这就是说，存在第二类点，另外只可能存在第三类点。我们取一个点，从这个点向其它点各连一条边，构成一个 star。我们发现 star 是一棵树，且直径≤2，所以是满足要求的。从而，第一问“最小边数”的答案为 N-1。下面将对第二类点的数目进行讨论：

③a 恰两个

此时，若选择让两个第二类点成为邻居，那么其他的点可以在两个第二类点中选择一个费用小的连过去。否则，这两个点的距离=2，那么就是说这两个点有一个公共邻居 u。显然其他的点都只能连到 u 上，这样一来就构成了一个以 u 为中心的 star。枚举所有 star 即可。

③b 超过两个

由于边数是 N-1，因此至少有一对第二类点不是邻居。

这样一来就成了③a的第二种情况，枚举所有 star 即可。

最后的结论是：首先枚举所有 star 取最小费用，然后如果第二类点的数目为 2，再考虑这两个点直接相连时的特殊情况即可。

代码

#include<cstdio>
#include<iostream>
#include<algorithm>
#define R register
using namespace std;
inline void in(int &x)
{
    int f=1;x=0;char s=getchar();
    while(!isdigit(s)){if(s=='-')f=-1;s=getchar();}
    while(isdigit(s)){x=x*10+s-'0';s=getchar();}
    x*=f;
}
int n,v[2580],tot,f[2580],mnn=4;
bool flg;
int res[258][258];
struct cod{int u,v,w;}edge[80008];
inline bool ccp(const cod&a,const cod&b)
{
    return a.w<b.w;
}
int find(int x){return f[x]==x?x:f[x]=find(f[x]);}
inline void mofashi()
{
    int cnt=0,ans=0;
    for(R int i=1;i<=n;i++)f[i]=i;
    for(R int i=1;i<=n;i++)
        for(R int j=1,x;j<=n;j++)
        {
            in(x);
            if(i>=j and x)
            {
                edge[++tot].u=i;
                edge[tot].v=j;
                edge[tot].w=x;
            }
        }
    sort(edge+1,edge+tot+1,ccp);
    for(R int i=1;i<=tot;i++)
    {
        R int u=edge[i].u,v=edge[i].v,w=edge[i].w;
        R int fu=find(u),fv=find(v);
        if(fu==fv)continue;
        cnt++;ans+=w;f[fu]=fv;
        if(cnt==n-1)break;
    }
    printf("%d\n%d\n",cnt,ans);
}
int main()
{
    freopen("forest.in","r",stdin);
    freopen("forest.out","w",stdout);
    in(n);
    for(R int i=1;i<=n;i++)in(v[i]),mnn=min(v[i],mnn);
    if(mnn==1)
    {
        for(R int i=1;i<=n;i++)
            for(R int j=1;j<=n;j++)
                in(res[i][j]);
        long long ans=0;
        int cnt=0;
        for(R int i=1;i<=n;i++)
            for(R int j=i+1;j<=n;j++)
                if(v[i]==1 or v[j]==1)
                    cnt++,ans+=res[i][j];
        printf("%d %lld\n",cnt,ans);
        return 0;
    }
    if(mnn==2)
    {
        for(R int i=1;i<=n;i++)
            for(R int j=1;j<=n;j++)
                in(res[i][j]);
        int tot2=0,pa=-1,pb=-1;
        for(R int i=1;i<=n;i++)
            if(v[i]==2)tot2++;
        long long ans=21474836476666LL;
        if(tot2==2)
        {
            for(R int i=1;i<=n;i++)
            {   
                if(v[i]==2)
                {
                    if(pa==-1)
                        pa=i;
                    else 
                        pb=i;
                }
            }
            ans=res[pa][pb];
            for(R int i=1;i<=n;i++)
                ans+=min(res[i][pa],res[i][pb]);
        }
        for(R int i=1;i<=n;i++)
        {
            long long rs=0;
            for(R int j=1;j<=n;j++)
                rs+=res[i][j];
            ans=min(ans,rs);
        }
        printf("%d %lld",n-1,ans);
    }
    if(mnn==3)mofashi();
    fclose(stdin);
    fclose(stdout);
    return 0;
}

转载于:https://www.cnblogs.com/-guz/p/9865636.html

weixin_30659829

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
NOIP2018提高组模拟题（五）

字符串(string)Description小林与亮亮正在做一个游戏。小林随意地写出一个字符串，字符串只由大写字母组成，然后指定一个非负整数 m，亮亮可以进行至多 m 次操作，每次操作为交换相邻两个字符。亮亮的目标是使得操作后的字符串出现最长相同的字符的长度最大。你能帮亮亮计算一下这个最大长度是多少吗？Input第一行一个字符串 S。第二行一个整数 m。Output只有一个整...
复制链接

扫一扫