NOIP2018提高组模拟题（二）

最新推荐文章于 2020-10-04 19:37:56 发布

weixin_30500663

最新推荐文章于 2020-10-04 19:37:56 发布

阅读量140

点赞数

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

版权

咒语(curse)

Description

亮亮梦到自己来到了魔法城堡，但一扇巨大的石门阻拦了他通向城堡内的路。正当他沮丧之际，突然发现门上有一处机关，机关上有一张很长的纸条。

亮亮拿起纸条的一端，只见上面写着打开机关的方法：“打开机关需要念动符咒，咒语是一串长为 L 的由 0 和 1 组成的字符串。在这张长纸条上列了 n 个长为 L 的字符串，正确的咒语即是在纷繁的 2^L 种字符串中，与这些纸条上的字符串相异度之和最小，并且在满足这一条件下，0 的个数最多的字符串。两个字符串的相异度定义为对应位置不相等的字符对的个数。如‘011’和‘001’的相异度为 1，因为它们有且只有第二个位置上的字符不相等。”

亮亮拉起纸条，只觉得纸条似乎永远也拉不完。这上面有着数以万计的字符串，而每一个字符串的长度也或百或千，以人力看来是无法得到正确的咒语。你能帮帮他，让他得以进入魔法城堡，一窥其中的奥秘吗？

Input

第一行为一个数字 N 。

接下来的 N 行，每行为一个长为 L 的 01 字符串。数据保证 N 个字符串等长。

Output

只有一行，是一个长为 L 的字符串 S，即为正确的咒语。

别看题面这么长,这不是一个渣题 emmm

记录每一位上\(1\)的个数,判断当前位上是\(1\)的个数多还是\(0\)的个数多,决定输出\(1\)或\(0\)

\(pos[i]\)代表\(i\)位置上\(1\)的个数,则\(n-pos[i]\)就代表\(i\)位置上\(0\)的个数.

代码

#include<cstdio>
#include<cstring>
#define R register
using namespace std;
int n,pos[20008],len;
char s[20008];
inline void calc(char *ch)
{
    if(!len)len=strlen(ch);
    for(R int i=0;i<len;i++)
        if(ch[i]=='1')pos[i]++;
}
int main()
{
    //freopen("curse.in","r",stdin);
    //freopen("curse.out","w",stdout);
    scanf("%d",&n);
    for(R int i=1;i<=n;i++)
    {
        scanf("%s",s);
        calc(s);
    }
    for(R int i=0;i<len;i++)
    {
        if(pos[i]>(n-pos[i]))putchar('1');
        else putchar('0');
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}

神光(light)

Description

亮亮成功地念出了咒语，石门缓缓地自动移开，一道道绚丽的神光从城堡内激射而出。亮亮好奇而又兴奋地走入了城堡中，迎面有一座极长的魔法阵。

魔法阵可以看作一条直线，它被均匀地分成了 1 000 000 000 个位置，一个位置可以看成是一个格子。有些位置上筑有法坛，一共 N 座。亮亮只有破了眼前的魔法阵，才能继续前进，而欲破法阵，必须毁掉所有的法坛。

亮亮身前有两根法杖：一根颜色血红，能发红色神光，光芒可以笼罩连续 L 个位置，并摧毁这 L 个位置上所有的法坛，最多使用 R 次；另一根颜色碧绿，能发绿色神光，光芒可以笼罩连续 2L 个位置，并摧毁这 2L 个位置上所有的法坛，最多使用 G 次。

法杖的神奇之处在于，L 的值必须由亮亮事先设定好，并且一经设定，便无法更改。亮亮需要在规定的次数下摧毁所有法坛，并且使得 L 最小。

Input

第一行三个整数 N, R, G。

第 i (2<=i<=n+1) 行一个整数Ai，表示第 i 座法坛的位置。

Output

只有一个整数，表示 L 的最小值。

数据范围

对于 50%的数据，N <= 100；

对于 100%的数据，1 <= N <= 2000，1 <= R, G, Ai <= 1,000,000,000。

T2竟然是最难的题 emmm,

首先二分不是很难想到吧.(二分我们的\(L\)

看到\(R,G \leq 1e9\),完了,岂不是要打暴力.

后来发现当\(R+G>N\)的时候,直接输出\(1\)即可 emm.(老子有的是,随便放 ╭(╯^╰)╮

然后问题就转变为了\(R,G \leq 2000\),考虑\(DP\)

设\(f[i][j]\)代表使用了\(i\)次红灯,\(j\)次红灯干掉了多少法坛.

显然我们考虑如何传递上面的状态,

则我们

设\(p[i]\)代表从\(i\)位置用红光能干到最靠右的位置

\(q[i]\)代表从\(i\)位置用绿光能干到最靠右的位置

先给出状态转移方程:
\[ f[i][j]=max(p[f[i-1][j]+1],f[i][j])\\ f[i][j]=max(q[f[i][j-1]+1],f[i][j]) \]
考虑到\(f[i][j]\)代表着什么。

我们对\(A\)数组进行排序之后,得到的\(f[i][j]\)必定递增(从\(1\)到\(i\)

则我们可以根据这个性质写出状态转移方程.

解释了里面为什么是\(f[i-1][j]\),应该不是很难理解.

代码

#include<cstdio>
#include<cstring>
#include<cctype>
#include<algorithm>
#define int long long
#define N 2008
#define clear(a) memset(a,0,sizeof a)
#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 g,G,n,a[N],ans;
int p[N],q[N],f[2][N*1000];//f[i][j]i次红光,j次绿光,能毁多少法坛 
inline bool ok(int x)
{
    clear(p);clear(q);clear(f);
    for(R int i=1;i<=n;i++)
    {
        for(R int j=i;j<=n;j++)
        {
            if(a[j]-a[i]+1<=x)p[i]=j;
            if(a[j]-a[i]+1<=x*2)q[i]=j; 
        }
    }
    p[n+1]=q[n+1]=n;
    for(R int i=0;i<=g;i++)
    {
        int op=i&1;
        for(R int j=0;j<=G;j++)
        {
            if(i!=0)f[op][j]=max(p[f[op^1][j]+1],f[op][j]);
            if(j!=0)f[op][j]=max(q[f[op][j-1]+1],f[op][j]); 
        }
    }   
    return f[g&1][G]==n;
}
signed main()
{
    //freopen("light.in","r",stdin);
    //freopen("light.out","w",stdout);
    in(n),in(g),in(G);
    if(g+G>n)
    {
        puts("1");
        return 0;
    }
    for(R int i=1;i<=n;i++)in(a[i]);
    sort(a+1,a+n+1);
    int l=0,r=1e9;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(ok(mid))r=mid-1,ans=mid;
        else l=mid+1;
    }
    printf("%lld",ans);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

迷宫(maze)

Description

　破了魔法阵后，亮亮进入了一座迷宫。这座迷宫叫做“梦境迷宫”，亮亮只有走出这座迷宫，才能从睡梦中醒来。

　梦境迷宫可以用无向图来表示。它共有 n 个点和 m 条双向道路，每条道路都有边权，表示通过这条道路所需的时间，且每条道路可以多次经过。亮亮位于一号点，而出口则是 n 号点。原本，亮亮该找到一条最短路，快速冲出迷宫，然而，梦境迷宫的特殊之处在于，如果沿着最短路到达出口，亮亮就会永远陷入梦境。因此，亮亮必须寻找一条次短路。次短路的长度须严格大于最短路（可以有多条）的长度，同时又不大于所有除最短路外的道路的长度。

　你的任务，就是编写一个程序，帮助亮亮找到通向出口的次短路。

Input

第一行有两个整数 n、m，表示迷宫内共有 n 个点，m 条边。

接下来 m 行，每行三个整数 x、y、z，表示结点 x 和 y 之间连有一条边权为 z 的无向边。

Output

一个整数，表示次短路的长度。

难得T3这么简单,傻逼题啊,直接跑一遍\(Spfa\)求次短路.

考虑我们的次短路和最短路有关系,所以可以在跑最短路的时候跑出次短路.

存在三种情况

能更新最短路
能更新次短路,但是不能更新最短路
只能更新次短路

分类讨论

一.能更新最短路

　这时候我们的次短路直接继承最短路即可.

二.能更新次短路,但是不能更新最短路

　如果我们到达当前点\(u\)所连的\(v\)的最短路无法被更新,显然当前边为一条不优边,我们可以用到达\(u\)的最短路通过当前边来更新到达\(v\)的次短路.(这一情况有些难理解.但是又不太难理解)

三.只能更新次短路

直接通过到达\(u\)的次短路更新到达\(v\)的次短路

代码

#include<cstdio>
#include<queue>
#include<cctype>
#define R register
#define int long long
#define N 5555
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,head[N],tot,dis[N],diss[N];
bool vis[N];
struct cod{int u,v,w;}edge[800008];
inline void add(int x,int y,int z)
{
    edge[++tot].u=head[x];
    edge[tot].v=y;
    edge[tot].w=z;
    head[x]=tot;
}
inline void spfa()
{
    for(R int i=1;i<=n;i++)dis[i]=diss[i]=2147483647666LL;
    dis[1]=0;vis[1]=true;
    queue<int>q;q.push(1);
    while(!q.empty())
    {
        int u=q.front();q.pop();vis[u]=false;
        for(R int i=head[u];i;i=edge[i].u)
        {
            if(dis[edge[i].v]>dis[u]+edge[i].w)
            {
                diss[edge[i].v]=dis[edge[i].v];
                dis[edge[i].v]=dis[u]+edge[i].w;
                if(!vis[edge[i].v])
                {
                    vis[edge[i].v]=true;
                    q.push(edge[i].v);
                }
            }
            if(dis[u]+edge[i].w>dis[edge[i].v] and diss[edge[i].v]>dis[u]+edge[i].w)
            {
                diss[edge[i].v]=dis[u]+edge[i].w;
                if(!vis[edge[i].v])
                {
                    vis[edge[i].v]=true;
                    q.push(edge[i].v);
                }   
            }
            if(diss[edge[i].v]>diss[u]+edge[i].w)
            {
                diss[edge[i].v]=diss[u]+edge[i].w;
                if(!vis[edge[i].v])
                {
                    vis[edge[i].v]=true;
                    q.push(edge[i].v);
                }
            }
        }
    }
    printf("%lld",diss[n]);
}
signed main()
{
    freopen("maze.in","r",stdin);
    freopen("maze.out","w",stdout);
    in(n),in(m);
    for(R int i=1,x,y,z;i<=m;i++)
    {
        in(x),in(y),in(z);
        add(x,y,z);add(y,x,z);
    }
    spfa();
    fclose(stdin);
    fclose(stdout);
    return 0;
}

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

weixin_30500663

关注

0
点赞
踩
0

收藏

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

咒语(curse)Description亮亮梦到自己来到了魔法城堡，但一扇巨大的石门阻拦了他通向城堡内的路。正当他沮丧之际，突然发现门上有一处机关，机关上有一张很长的纸条。亮亮拿起纸条的一端，只见上面写着打开机关的方法：“打开机关需要念动符咒，咒语是一串长为 L 的由 0 和 1 组成的字符串。在这张长纸条上列了 n 个长为 L 的字符串，正确的咒语即是在纷繁的 2^L 种字符串中，...
复制链接

扫一扫