CTSC2000 冰原探险

最新推荐文章于 2019-01-02 12:17:00 发布
最新推荐文章于 2019-01-02 12:17:00 发布
阅读量882 收藏
点赞数 1
分类专栏： dfs-bfs CTSC 文章标签： vijos CTSC 2000
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SLYZ_wumingshi/article/details/52974081
版权

这是我第一次写博客，写的不好，请多见谅~

今天上午日常考试，第二题就是这个题目。
传送门
(其实我是在vijos上测评的)

题目描述 ：

传说中，南极有一片广阔的冰原，在冰原下藏有史前文明的遗址。整个冰原被横竖划分成了很多个大小相等的方格。在这个冰原上有N个大小不等的矩形冰山，这些巨大的冰山有着和南极一样古老的历史，每个矩形冰山至少占据一个方格，且其必定完整地占据方格。冰山和冰山之间不会重叠，也不会有边或点相连。以下两种情况均是不可能出现的：
这里写图片描述
ACM探险队在经过多年准备之后决定在这个冰原上寻找遗址。根据他们掌握的资料，在这个冰原上一个大小为一格的深洞中，藏有一个由史前人类制作的开关。而唯一可以打开这个开关的是一个占据接近一格的可移动的小冰块。显然，在南极是不可能有这样小的独立冰块的，所以这块冰块也一定是史前文明的产物。他们在想办法把这个冰块推到洞里去，这样就可以打开一条通往冰原底部的通道，发掘史前文明的秘密。冰块的起始位置与深洞的位置均不和任何冰山相邻。这个冰原上的冰面和冰山都是完全光滑的，轻轻的推动冰块就可以使这个冰块向前滑行，直到撞到一座冰山就在它的边上停下来。冰块可以穿过冰面上所有没有冰山的区域，也可以从两座冰山之间穿过（见下图）。冰块只能沿网格方向推动。
这里写图片描述
请你帮助他们以最少的推动次数将冰块推入深洞中。
格式
输入格式
输入文件第一行为冰山的个数N (1<=N<=4000)，第二行为冰块开始所在的方格坐标X1,Y1，第三行为深洞所在的方格坐标X2,Y2，以下N行每行有四个数，分别是每个冰山所占的格子左上角和右下角坐标Xi1,Yi1,Xi2,Yi2
输出格式
输出文件仅包含一个整数，为最少推动冰块的次数。如果无法将冰块推入深洞中，则输出0。
样例1
样例输入1[复制]
2
1 1
5 5
1 3 3 3
6 2 8 4
样例输出1[复制]
3
限制
各个测试点1s

解题过程：

当时自己也没多想，于是就敲了个bfs暴力，结果不幸的是while循环崩了，而且写的还不是正解。。于是。。结果你懂得
以下是我考试时的代码：

#include<cstdio>
#include<cstdlib>
int n,i,j,k,x1,y1,x2,y2,d,t1,t2,t3,t4,g=1;
int f[3][1000001];
bool b[2001][2001];
int way[5][2]={0,0,-1,0,0,-1,0,1,1,0};
void pd(int n)
{
    if(f[0][n]==x2&&f[1][n]==y2)
    {
        printf("%d",d);
        exit(0);
    }
}
void bfs(int begin,int end)
{
    int i,j;
    for(i=begin;i<=end;i++) pd(i);
    int x,y;
    for(i=begin;i<=end;i++)
      for(j=1;j<=4;j++)
      {
        if(f[2][i]+j==5) continue;
        x=f[0][i];y=f[1][i];
        while(1) {x+=way[j][0];y+=way[j][1];if(b[x][y]) break;}//这个while循环崩掉了
//      while(!b[x+way[j][0]][y+way[j][1]]) {x+=way[j][0];y+=way[j][1];if(x==1999||y==1999) break;}
        if(x==0||x==2000||y==0||y==2000) continue;
        x-=way[j][0];y-=way[j][1];
        f[0][++g]=x;
        f[1][g]=y;
        f[2][g]=j;
      }
    d++;
    if(g>end)
      bfs(end+1,g);
}
main()
{
    freopen("ice.in","r",stdin);
    freopen("ice.out","w",stdout);
    scanf("%d%d%d%d%d",&n,&x1,&y1,&x2,&y2);
    for(k=1;k<=n;k++)
    {
        scanf("%d%d%d%d",&t1,&t2,&t3,&t4);
        for(i=t1;i<=t3;i++)
          b[i][t2]=b[i][t4]=1;
        for(i=t2;i<=t4;i++)
          b[t1][i]=b[t3][i]=1;
    }
    for(i=0;i<=2000;i++) b[i][0]=b[0][i]=b[i][2000]=b[2000][i]=1;
    f[0][1]=x1;f[1][1]=y1;f[2][1]=233;
    bfs(1,1);
    printf("0");
}

我一开始的思路很简单，就是用一个布尔矩阵模拟。然而人家毕竟是CTSC出的题，再怎么着也不至于这么水呀，于是人家就故意不谢坐标范围。

下午老师讲题以后我又重做了一遍。一开始我自己脑补了一个坐标系，然而写完以后测试样例的时候发现程序死了。这让我一脸懵逼，画出图来一看，这个题目的描述简直有毒！我就不描述了，见图：

可以看到，这个坐标系里面x轴是竖着的，y轴是横着的。这和我想象的一点也不符合。

我相信，只要是一个正常人，看完样例以后一定会先想到的是这个样子。然而就像图里标出来的，左上和右下是矛盾的，这就很蛋疼了。我的代码本来是这个样子：

#include<cstdio>
#include<cstdlib>
#include<cstring>
long long n,i,j,x1,y1,x2,y2,d,g=1,t,p;
struct aa
{
    int x1,y1,x2,y2;
}a[4002];
bool b[4002][5];
int f[16002][3];
void pd(int n)
{
    if(f[n][0]==x2&&f[n][1]==y2)
    {
        printf("%d",d);
        exit(0);
    }
}
int findl(int x,int y)
{
    int i,s=1e9,p=1e9+7;//s:距离 
    for(i=1;i<=n;i++)
      if(a[i].x2<x&&x-a[i].x2<s&&a[i].y1<=y&&y<=a[i].y2)
      {
        s=x-a[i].x2;
        p=i;
      }
    return p;
}
int findr(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(a[i].x1>x&&a[i].x1-x<s&&a[i].y1<=y&&y<=a[i].y2)//不是a[i].y1<=y&&y<=a[i].y2,注意 
      {
        s=a[i].x1-x;
        p=i;
      }
    return p;
}
int findu(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(a[i].y2>y&&a[i].y2-y<s&&a[i].x1<=x&&x<=a[i].x2)
      {
        s=a[i].y2-y;
        p=i;
      }
    return p;
}
int findd(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(a[i].y1<y&&y-a[i].y1<s&&a[i].x1<=x&&x<=a[i].x2)
      {
        s=y-a[i].y1;
        p=i;
      }
    return p;
}
void bfs(int begin,int end)
{
    int i,p;
    for(i=begin;i<=end;i++) pd(i);
    for(i=begin;i<=end;i++)
      if(i==1)
      {
        p=findu(f[1][0],f[1][1]);
        if(p!=1e9+7)
        {
            f[++g][0]=f[1][1];
            f[g][1]=a[p].y2-1;
            f[g][2]=2;//在下面 
        }
        p=findd(f[1][0],f[1][1]);
        if(p!=1e9+7)
        {
            f[++g][0]=f[1][1];
            f[g][1]=a[p].y1+1;
            f[g][2]=1;//在上面 
        }
        p=findl(f[1][0],f[1][1]);
        if(p!=1e9+7)
        {
            f[++g][0]=f[1][0];
            f[g][1]=a[p].x2+1;
            f[g][2]=4;//在右面 
        }
        p=findr(f[1][0],f[1][1]);
        if(p!=1e9+7)
        {
            f[++g][0]=f[1][0];
            f[g][1]=a[p].x1-1;
            f[g][2]=3;//在左面 
        }
      }
      else//现在贴在某一冰山上 
        if(f[i][2]==1||f[i][2]==2)//现在只能左右滑动 
        {
            p=findl(f[i][0],f[i][1]);
            if(p!=1e9+7)
            {
                f[++g][0]=f[i][0];
                f[g][1]=a[p].x2+1;
                f[g][2]=4;
            }
            p=findr(f[i][0],f[i][1]);
            if(p!=1e9+7)
            {
                f[++g][0]=a[p].x1-1;
                f[g][1]=f[i][1];
                f[g][2]=3;
            }
        }
        else//现在只能上下滑动 
        {
            p=findu(f[i][0],f[i][1]);
            if(p!=1e9+7)
            {
                f[++g][0]=a[p].y2-1;
                f[g][1]=f[i][1];
                f[g][2]=2;
            }
            p=findd(f[i][0],f[i][1]);
            if(p!=1e9+7)
            {
                f[++g][0]=a[p].y1+1;
                f[g][1]=f[i][1];
                f[g][2]=1;
            }
        }
    d++;
    bfs(end+1,g);
}
main()
{
    scanf("%d%d%d%d%d",&n,&x1,&y1,&x2,&y2);
    for(i=1;i<=n;i++)
      scanf("%d%d%d%d",&a[i].x1,&a[i].y1,&a[i].x2,&a[i].y2);
    a[++n].x1=x2;a[n].x2=x2;a[n].y1=a[n].y2=y2;
    memset(b,1,sizeof(b));
    f[1][0]=x1;f[1][1]=y1;f[1][2]=-1;
    bfs(1,1);
    printf("0");
}

本蒟蒻修改了n遍程序仍然死循环，这时候有好心人提醒我说，不要管原图的错误，按照上面的编就行了。修改后的find是这个样子：

int findl(int x,int y)
{
    int i,s=1e9,p=1e9+7;//s:距离 
    for(i=1;i<=n;i++)
      if(a[i].y2<y&&y-a[i].y2<s&&a[i].x1<=x&&x<=a[i].x2)
      {
        s=y-a[i].y2;
        p=i;
      }
    return p;
}
int findr(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(a[i].y1>y&&a[i].y1-y<s&&a[i].x1<=x&&x<=a[i].x2)
      {
        s=a[i].y1-y;
        p=i;
      }
    return p;
}
int findu(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(x>a[i].x2&&x-a[i].x2<s&&a[i].y1<=y&&y<=a[i].y2)
      {
        s=x-a[i].x2;
        p=i;
      }
    return p;
}
int findd(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(x<a[i].x1&&a[i].x1-x<s&&a[i].y1<=y&&y<=a[i].y2)
      {
        s=a[i].x1-x;
        p=i;
      }
    return p;
}

然而这样仍然是错误的。为什么呢？因为我是把结束点也就是深洞当做一个冰山来看待的，这也就导致程序能成功地找到通向洞口最近的路，但并不能停止递归，于是成功地导致了死循环。继续修改，代码成了这个样子：

#include<cstdio>
#include<cstdlib>
#include<cstring>
long long n,i,j,x1,y1,x2,y2,d,g=1,t,p;
struct aa
{
    int x1,y1,x2,y2;
}a[4002];
bool b[4002][5];
int f[16002][3];
void print()
{
    printf("%d",d);
    exit(0);
}
int findl(int x,int y)
{
    int i,s=1e9,p=1e9+7;//s:距离 
    for(i=1;i<=n;i++)
      if(a[i].y2<y&&y-a[i].y2<s&&a[i].x1<=x&&x<=a[i].x2)
      {
        if(i==n) print();
        s=y-a[i].y2;
        p=i;
      }
    return p;
}
int findr(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(a[i].y1>y&&a[i].y1-y<s&&a[i].x1<=x&&x<=a[i].x2)
      {
        if(i==n) print();
        s=a[i].y1-y;
        p=i;
      }
    return p;
}
int findu(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(x>a[i].x2&&x-a[i].x2<s&&a[i].y1<=y&&y<=a[i].y2)
      {
        if(i==n) print();
        s=x-a[i].x2;
        p=i;
      }
    return p;
}
int findd(int x,int y)
{
    int i,s=1e9,p=1e9+7;
    for(i=1;i<=n;i++)
      if(x<a[i].x1&&a[i].x1-x<s&&a[i].y1<=y&&y<=a[i].y2)
      {
        if(i==n) print();
        s=a[i].x1-x;
        p=i;
      }
    return p;
}
void bfs(int begin,int end)
{
    int i,p;
    d++;
    for(i=begin;i<=end;i++)
      if(i==1)
      {
        p=findu(f[1][0],f[1][1]);
        if(p!=1e9+7&&b[p][2])
        {
            f[++g][0]=a[p].x2+1;
            f[g][1]=f[1][1];
            f[g][2]=2;//在下面 
            b[p][2]=0;
        }
        p=findd(f[1][0],f[1][1]);
        if(p!=1e9+7&&b[p][1])
        {
            f[++g][0]=a[p].x1-1;
            f[g][1]=f[1][1];
            f[g][2]=1;//在上面 
            b[p][1]=0;
        }
        p=findl(f[1][0],f[1][1]);
        if(p!=1e9+7&&b[p][4])
        {
            f[++g][0]=f[1][0];
            f[g][1]=a[p].y2+1;
            f[g][2]=4;//在右面 
            b[p][4]=0;
        }
        p=findr(f[1][0],f[1][1]);
        if(p!=1e9+7&&b[p][3])
        {
            f[++g][0]=f[1][0];
            f[g][1]=a[p].y1-1;
            f[g][2]=3;//在左面 
            b[p][3]=0;
        }
      }
      else//现在贴在某一冰山上 
        if(f[i][2]==1||f[i][2]==2)//现在只能左右滑动 
        {
            p=findl(f[i][0],f[i][1]);
            if(p!=1e9+7&&b[p][4])
            {
                f[++g][0]=f[i][0];
                f[g][1]=a[p].y2+1;
                f[g][2]=4;
                b[p][4]=0;
            }
            p=findr(f[i][0],f[i][1]);
            if(p!=1e9+7&&b[p][3])
            {
                f[++g][0]=f[i][0];
                f[g][1]=a[p].y1-1;
                f[g][2]=3;
                b[p][3]=0;
            }
        }
        else//现在只能上下滑动 
        {
            p=findu(f[i][0],f[i][1]);
            if(p!=1e9+7&&b[p][2])
            {
                f[++g][0]=a[p].x2+1;
                f[g][1]=f[i][1];
                f[g][2]=2;
                b[p][2]=0;
            }
            p=findd(f[i][0],f[i][1]);
            if(p!=1e9+7&&b[p][1])
            {
                f[++g][0]=a[p].x1-1;
                f[g][1]=f[i][1];
                f[g][2]=1;
                b[p][1]=0;
            }
        }
    bfs(end+1,g);
}
main()
{
    scanf("%d%d%d%d%d",&n,&x1,&y1,&x2,&y2);
    for(i=1;i<=n;i++)
      scanf("%d%d%d%d",&a[i].x1,&a[i].y1,&a[i].x2,&a[i].y2);
    a[++n].x1=x2;a[n].x2=x2;a[n].y1=a[n].y2=y2;
    memset(b,1,sizeof(b));
    f[1][0]=x1;f[1][1]=y1;f[1][2]=-1;
    bfs(1,1);
    printf("0");
}

然而还是WA。经过反复查看，我发现我的程序在无解时是会无限递归下去的，于是主程序里的那个printf(“0”)并无卵用。所以我在每一个find里都加入了一个判断(举个例子)：


void print()
{
    printf("%d",d);
    exit(0);
}
int findl(int x,int y)
{
    int i,s=1e9,p=1e9+7;//s:距离 
    for(i=1;i<=n;i++)
      if(a[i].y2<y&&y-a[i].y2<s&&a[i].x1<=x&&x<=a[i].x2)
      {
        if(i==n) print();
        s=y-a[i].y2;
        p=i;
      }
    return p;
}

其实我也应该反思一下，考试的时候自己为什么没有想到可以不用布尔数组？那样的话适应范围是很小的。后来重做的时候一开始我忘记了使用判重数组，这又意味着什么？没有及时推出递归导致死循环，说明我在做题的时候还是没有很好地理解题意。

iamwms
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
[BZOJ2541][Ctsc2000]冰原探险（bfs）
zyf2000
10-30 895
题目描述传送门题解乍一看这道题好像无从下手，实际上就是预处理之后bfs。 因为要冰块要撞上冰山了之后才能停下来，所以从一个地方向某一个方向推它停在哪里是一定的，并且从某一个冰山左右只能忘上下推，从一个冰山的上下只能往左右推。那这样的话，就可以把每一个冰山的四边编上号，然后每一次暴力查找往某个方向推会撞到哪里。将这两个部分连边。那这样的话就会出来一个有向图，用一遍bfs就可以求出最短路。代码#inc
CTSC 2000 冰原探险
dianyi2475的博客
06-03 227
题目 题目背景 传说中，南极有一片广阔的冰原，在冰原下藏有史前文明的遗址。整个冰原被横竖划分成了很多个大小相等的方格。在这个冰原上有N个大小不等的矩形冰山，这些巨大的冰山有着和南极一样古老的历史，每个矩形冰山至少占据一个方格，且其必定完整地占据方格。冰山和冰山之间不会重叠，也不会有边或点相连。以下两种情况均是不可能出现的： 题目描述 ACM探险队在经过多年准备之后决定在这...
bzoj 2541: [Ctsc2000]冰原探险 （bfs+建图）
clover_hxy的博客
10-30 558
2541: [Ctsc2000]冰原探险 Time Limit: 3 Sec  Memory Limit: 128 MB Submit: 29  Solved: 18 [Submit][Status][Discuss] Description 传说中，南极有一片广阔的冰原，在冰原下藏有史前文明的遗址。整个冰原被横竖划分成了很多个大小相等的方格。在这个冰原上有N个大小不等的矩形冰山，这
【[CTSC2000]冰原探险】
weixin_30443731的博客
01-02 207
noip前练一下码力还是非常有前途的 这道题本来就是想写个大暴力弃疗的，所以直接强上暴力浑身舒爽 结果发现要不是判重的时候脑残了，就能\(A\)了 没什么好说的呀，就是每一次都暴力\(O(n)\)往上下左右扩展状态，之后放到队列里，\(map\)判重就好了 代码 #include<iostream> #include<cstdio> #include<cst...
[Ctsc2000]冰原探险
weixin_30294709的博客
05-10 127
Description 传说中，南极有一片广阔的冰原，在冰原下藏有史前文明的遗址。整个冰原被横竖划分成了很多个大小相等的方格。在这个冰原上有N个大小不等的矩形冰山，这些巨大的冰山有着和南极一样古老的历史，每个矩形冰山至少占据一个方格，且其必定完整地占据方格。冰山和冰山之间不会重叠，也不会有边或点相连。以下两种情况均是不可能出现的： ACM探险队在经过多年准备之后决定在这个冰原上寻找遗址。根据他们...
CTSC2018试题day2
04-15
【CTSC NOI 知识点详解】 CTSC（China Team Selection Contest）是中国信息学奥林匹克（NOI）国家队选拔赛的重要组成部分，旨在挑选出最优秀的选手代表中国参加国际信息学奥林匹克竞赛（IOI）。2018年的CTSC，即...
CTSC 1997 题面 + 数据
09-25
CTSC 1997的题目，包含了笔试 + 上机的原题以及上机部分的数据。 各大OJ都没有这套题目，虽然年代久远，但质量极高，值得训练！ 难度大约在NOIP 提高组 / ACM 分区赛 / CodeForces Div.2水平。
CTSC2018试题day1
04-15
IOI 2018 中国国家队选拔赛暨精英赛（CTSC 2018）竞赛真题（PDF版，无数据）
ctsc2014 day2 数据
02-20
【标题】"ctsc2014 day2 数据"指的是中国信息学奥林匹克竞赛（China Team Selection Contest, CTSC）2014年第二天的比赛数据。CTSC是针对中学生的高水平编程竞赛，通常涵盖算法设计、数据结构和问题解决等多个方面。...
CTSC 1998 题面 + 数据 + 标程
09-25
《CTSC 1998：经典编程竞赛的回顾与解析》 CTSC（China Team Selection Contest）是中国信息学奥林匹克的一项重要赛事，1998年的比赛距今已有二十多年，尽管时间流转，但其题目的价值却并未因岁月而褪色。这次分享...
BZOJ 2541: [Ctsc2000]冰原探险
aisen1985的博客
11-14 112
Descrption 有一些矩形障碍,碰到障碍会停下,求从一个点到另一个点的最少移动步数. Sol BFS. 因为题目的特殊性质,两个矩形没有任何相邻,起始点和终点和矩形没有相邻. 所以从一个点的移动只有 左/右 或 上/下两种可能,与它到该点的方向不同,不然就又移动回去了. 然后可以在边BFS的时候边建图,往上/下 或 左/右 找能限制住他的矩阵. 复杂度 \(O(n^2...
构图（+BFS）——BZOJ2541/Luogu3716 [CTSC2000]冰原探险
2333：jzqjzq的博客专栏
06-06 350
题面：Luogu3716 BZOJ2541 无限烧脑预处理建图系列，同时也是我攻下的CTSC第一题！ 只要把图能建得出来就Accepted了 所以只说建图（最后的bfs有什么好说的。。。） 我们把冰山拆成四个点，冰山的每一边是一个点 然后我们暴力对每一个点（也就是冰山的边）往上下左右找最近的能撞的冰山（或者直接掉进洞里），然后连上有向边（注意有向边！！！） 当然啦，每一条边要么上下方向要
bzoj2538: [Ctsc2000]公路巡逻
weixin_30512089的博客
10-30 111
超车这个东西这么恶心肯定是要暴力求的(自圆其说) 那么分成一个个时间段来搞，然后DP一下 化一下那个速度，耗费时间是在300s~600s之间的 那我们就可以设f[i][j]为走到第i个位置用了j的时间相遇的最小值 这里有个坑点，就是出发时间和到达时间均相等的两辆车也算相遇。。。 #include<cstdio> #include<iostream> ...
bzoj2538 [Ctsc2000]公路巡逻
Elijahqi
01-07 558
(http://www.elijahqi.win/2018/01/07/bzoj2538-ctsc2000%E5%85%AC%E8%B7%AF%E5%B7%A1%E9%80%BB/) Description 在一条没有分岔的高速公路上有n个关口，相邻两个关口之间的距离都是10km。所有车辆在这条高速公路上的最低速度为60km/h，最高速度为120km/h，并且只能在关口处改变速度。 巡逻的方
[KM算法] BZOJ 2539 [Ctsc2000]丘比特的烦恼
雯舞
07-04 822
这就很裸了 只是坑点实在多 坐标有实数 字串大小写 不可连的边设为-inf 貌似题目保证有完备匹配？ #include #include #include #include #include #include #include #include #define cl(x) memset(x,0,sizeof(x)) using namespace std; const int
[BZOJ2540]ctsc2000快乐的蜜月（dp+归并排序）
DOFYPXY的博客
02-26 528
列表内容[BZOJ2540]ctsc2000快乐的蜜月（dp+归并排序）先考虑k=1的情况。 f[i]表示前i天可以获得的最大收入。显然f[i]=max(f[i-1],f[ps]+(i-ps)*cost),p为以i结尾的预定。 那么k>1的： f[i,k]表示前i天可以获得的第k大收入。 f[i]=f[i-1]; 然后对于每一个预定p q1:=f[i]; q2:=f[ps]中每个元素+
rq-104
Sky_Gr_OI
04-23 474
题目描述 传说中，南极有一片广阔的冰原，在冰原下藏有史前文明的遗址。整个冰原被横竖划分成了很多个大小相等的方格。在这个冰原上有N个大小不等的矩形冰山，这些巨大的冰山有着和南极一样古老的历史，每个矩形冰山至少占据一个方格，且其必定完整地占据方格。冰山和冰山之间不会重叠，也不会有边或点相连。以下两种情况均是不可能出现的： ACM探险队在经过多年准备之后决定在这个冰原上寻找遗址。根据他们掌握的资
poj1101
Phoebe201421085的专栏
04-18 1314
#include #include using namespace std; int w,h,x1,x2,y1,y2,a[80][80],f[80][80],best,now, dx[4]={0,0,-1,1}, dy[4]={-1,1,0,0}; void dfs(int xx,int yy,int dd) { int i,x,y; if (nowbes
CTSC 选课
weixin_34357436的博客
07-17 157
题面（有删减） 题目描述 学校实行学分制。每门的必修课都有固定的学分，同时还必须获得相应的选修课程学分。学校开设了N（N<300）门的选修课程，每个学生可选课程的数量M是给定的。学生选修了这M门课并考核通过就能获得相应的学分。你的任务是为自己确定一个选课方案，使得你能得到的学分最多，并且必须满足先修课优先的原则。假定课程之间不存在时间上的冲突。 输入输出格式 输入格式： ...
[CTSC 1997]选课\\
最新发布
08-05
引用中提到，学校实行学分制，每门课程都有固定的学分，同时还需要获得相应的选修课程学分。引用中提到，有些选修课程需要先修其他课程才能选修。每门课程都有一个课号，依次为1，2，3，...。引用中提到了一个选课...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值