冲刺Noip2017模拟赛4 解题报告—

题1 韬韬抢苹果（apple）

【问题描述】

又到了收获的季节，树上结了许多韬韬，错了，是许多苹果，有很多个小韬韬都来摘苹

果。每个韬韬都想要最大的苹果，所以发生了争执，为了解决他们的矛盾，出题人定了一项

特殊的规则，按体重的大小来定顺序，每一轮都是先由胖的先摘（照顾胖子），每个韬韬都

是很聪明的，不会错过眼前最大的苹果。现在问题来了，一共有 n 个苹果，m 个韬韬，要你

按原顺序输出每个韬韬可以抢到的苹果的总大小。

【输入格式】apple.in

第一行两个数 n,m。

接下来一行 n 个数，分别为每个苹果的大小。

接下来一行 m 个数，分别为每个韬韬的体重。

【输出格式】apple.out

一行 m 个数，每个韬韬抢到的苹果的大小。

【输入样例】

【输出样例】

【 数据规模 】

n,m<=

题目

　tag：模拟

　思路：模拟即可，为了防止被极端数据卡开了long long。

 #include<cstdio>

 #include<algorithm>

 #include<iostream>

 #include<cstring>

 #include<cmath>

 #define ll long long

 #define maxn 100010

 using namespace std;

 ll ans[maxn];

 int ap[maxn],po,n,m;

 struct TT{

     int w,id;

 }tt[maxn];

 bool cmp1(int x,int y)

 {

     return x>y;

 }

 bool cmp2(TT x,TT y)

 {

     return x.w>y.w;

 }

 int main()

 {

     //freopen("apple.in","r",stdin);

     //freopen("apple.out","w",stdout);

     scanf("%d%d",&n,&m);

     for(int i=;i<=n;++i) scanf("%d",&ap[i]);

     for(int i=;i<=m;++i){

         scanf("%d",&tt[i].w);

         tt[i].id=i;

     }

     sort(ap+,ap+n+,cmp1);

     sort(tt+,tt+m+,cmp2);

     int f=po=;

     while(){

         for(int i=;i<=m;++i){

             ans[tt[i].id]+=ap[po++];

             if(po>n){

                 f=;

                 break;

             }

         }

         if(!f) break;

     }

     for(int i=;i<=m;++i) cout<<ans[i]<<" ";

     return ;

 }

题2 开场舞蹈(dance)

【问题描述】

在全世界人民的期盼下， 年北京奥林匹克运动会终于隆重召开了！

为了展示中华民族博大精深的优秀传统文化，负责开幕式开场舞蹈的编排人员一丝不

苟，每一个细节都力争完美。关于队伍是采用“天圆”阵还是“地方”阵的问题，大家讨论

了七天七夜，仍没有结果。于是，他们希望借助计算机，计算两种阵型的成本。

队伍将排列在一个二维平面内，且必须以（，）点为中心使得队伍保持对称美。“天

圆”阵是一个圆形，而“地方”阵则是一个边平行于坐标轴的正方形。由于某种因素，阵型

要求覆盖某些点（可以在边上）。

你的任务是，计算出能够覆盖这些点的两种阵型的最小面积。

【输入文件】

输入文件  dance.in。第一行是一个整数 n（<=n<=），表示需要覆盖的点的个数。

接下来 n 行，第 i 行是两个整数 xi，yi（-<=xi，yi<=），表示第 i 个点的坐标位

置（xi，yi）。

【输出文件】

输出文件  dance.out。第一行是一个整数 s1，表示能够覆盖这些点的“天圆”阵的最小

面积（pi=3.14，四舍五入）。第二行是一个整数 s2，表示能够覆盖这些点的“地方”阵的

最小面积。

【样例输入】

【样例输出】

题目

tag：模拟

思路：取最大值，注意四舍五入的处理，乘10取整，再将mod10的结果与5比较。还有更简单的方法，加上0.5再取整。

 #include<cstdio>

 #include<algorithm>

 #include<iostream>

 #include<cstring>

 #include<cmath>

 #define ll long long

 #define maxn 100010

 using namespace std;

 const double pi=3.14;

 int n,A,ans;

 double R;

 double cal(int x,int y){return sqrt((double)(x*x+y*y));}

 int main()

 {

     //freopen("dance.in","r",stdin);

     //freopen("dance.out","w",stdout);

     int x,y;

     scanf("%d",&n);

     for(int i=;i<=n;++i){

         scanf("%d%d",&x,&y);

         R=max(R,cal(x,y));

         A=max(A,max(abs(x),abs(y)));

     }

     y=(int)(R*R*pi*);

     ans=y/;

     if(y%>=) ans++;

     printf("%d\n",ans);

     printf("%d\n",A*A*);

     return ;

 }

题3 架设电话线(phoneline)

【 问题描述 】

Farmer John 打算将电话线引到自己的农场，但电信公司并不打算为他提供免费服务。

于是，FJ 必须为此向电信公司支付一定的费用。

FJ 的农场周围分布着 N( <= N <= ,)根按 ..N 顺次编号的废弃的电话线杆，任意两

根电话线杆间都没有电话线相连。一共 P( <= P <= ,)对电话线杆间可以拉电话线，其

余的那些由于隔得太远而无法被连接。

第 i 对电话线杆的两个端点分别为 A_i、B_i，它们间的距离为 L_i ( <= L_i <=

,,)。数据中保证每对{A_i，B_i}最多只出现  次。编号为  的电话线杆已经接入了

全国的电话网络，整个农场的电话线全都连到了编号为 N 的电话线杆上。也就是说，FJ 的

任务仅仅是找一条将  号和 N 号电话线杆连起来的路径，其余的电话线杆并不一定要连入

电话网络。

经过谈判，电信公司最终同意免费为 FJ 连结 K( <= K < N)对由 FJ 指定的电话线杆。

对于此外的那些电话线，FJ 需要为它们付的费用，等于其中最长的电话线的长度（每根电

话线仅连结一对电话线杆）。如果需要连结的电话线杆不超过 K 对，那么 FJ 的总支出为 。

请你计算一下，FJ 最少需要在电话线上花多少钱。

【输入格式】

* 第  行:  个用空格隔开的整数：N，P，以及 K

* 第 ..P+ 行: 第 i+ 行为  个用空格隔开的整数：A_i，B_i，L_i

【输入样例】phoneline.in

【输入说明】

一共有  根废弃的电话线杆。电话线杆  不能直接与电话线杆 、 相连。电话线杆

不能直接与电话线杆 、 相连。其余所有电话线杆间均可拉电话线。电信公司可以免费为

FJ 连结一对电话线杆。

【输出格式】

* 第  行: 输出  个整数，为 FJ 在这项工程上的最小支出。如果任务不可能完成，输

出-

【输出样例】phoneline.out

【输出说明】

FJ 选择如下的连结方案：->；->；->，这  对电话线杆间需要的电话线的长度分

别为 、、。FJ 让电信公司提供那条长度为  的电话线，于是，他所需要购买的电话线的

最大长度为 。

题目

tag:二分、最短路

思路：由于对于路径的选择、寻找答案都有很大的不确定性，可以考虑二分答案x作划分免费和付费的分界线，它也是付费边的上限。如果选择的边比x大视作距离为1，否则距离为0，那么dis[n]就被赋予了新的意义——从点1到点n最少选择的大于x的边数，跑一遍SPFA再看dis[n]有没有超过k，大于k说明答案不成立，因为电话公司无论如何都要支付超过x的这么多边，要把上限提高使得dis[n]变小减轻电话公司的压力。

 #include<cstdio>

 #include<algorithm>

 #include<iostream>

 #include<cstring>

 #include<cmath>

 #include<queue>

 #define ll long long

 #define maxn 100010

 #define inf 1<<30

 using namespace std;

 int n,m,k,hl[],vis[],dis[],cnt,cs[];

 queue<int>Q;

 struct X{

     int u,v,w,ne;

 }e[];

 void add(int u,int v,int w)

 {

     e[++cnt].u=u;

     e[cnt].v=v;

     e[cnt].w=w;

     e[cnt].ne=hl[u];

     hl[u]=cnt;

 }

 void spfa()

 {

     memset(dis,/,sizeof(dis));

     dis[]=;

     vis[]=;

     Q.push();

     while(!Q.empty()){

         int u=Q.front();

         Q.pop();

         for(int i=hl[u];i;i=e[i].ne){

             int v=e[i].v;

             if(dis[v]>dis[u]+cs[i]){

                 dis[v]=dis[u]+cs[i];

                 if(!vis[v]){

                     vis[v]=;

                     Q.push(v);

                 }

             }

         }

         vis[u]=;

     }

 }

 bool div2(int x)

 {

     memset(cs,,sizeof(cs));

     for(int i=;i<=n;++i)

         for(int j=hl[i];j;j=e[j].ne)

             if(e[j].w>x) cs[j]=;

     spfa();

     return dis[n]<=k;

 }

 bool cmp(int x,int y){

     return x>y;

 }

 int main()

 {

     //freopen("phoneline.in","r",stdin);

     //freopen("phoneline.out","w",stdout);

     int x,y,w;

     scanf("%d%d%d",&n,&m,&k);

     for(int i=;i<=m;++i){

         scanf("%d%d%d",&x,&y,&w);

         add(x,y,w);

         add(y,x,w);

     }

     int l=,r=;

     while(l<r){

         int mid=(l+r)>>;

         if(div2(mid)) r=mid;

         else l=mid+;

     }

     r==?printf("-1"):printf("%d\n",r);

     return ;

 }

题4 洪水（slikar）

【问题描述】

一天，一个画家在森林里写生，突然爆发了山洪，他需要尽快返回住所中，那里是安全

的。

森林的地图由 R 行 C 列组成，空白区域用点“.”表示，洪水的区域用“*”表示，而

岩石用“X”表示，另画家的住所用“D”表示，画家用“S”表示。

有以下几点需要说明：

.每一分钟画家能向四个方向移动一格（上、下、左、右）

.每一分钟洪水能蔓延到四个方向的相邻格子（空白区域）

.洪水和画家都不能通过岩石区域

.画家不能通过洪水区域（同时也不行，即画家不能移到某个格子，该格子在画家达到

的同时被洪水蔓延到了，这也是不允许的）

. 洪水蔓不到画家的住所。

给你森林的地图，编写程序输出最少需要花费多长时间才能从开始的位置赶回家中。

【输入】

输入第一行包含两个整数 R 和 C(R,C<=)。

接下来 R 行每行包含 C 个字符(“.”、“*”、“X”、“D”或“S”)。地图保证只有一个“D”

和一个“S”。

【输出】

输出画家最快安全到达住所所需的时间，如果画家不可能安全回家则输出“KAKTUS”。

【输入输出样例  】

slikar.in slikar.out

D.*

...

.S.

【输入输出样例  】

slikar.in slikar.out

D.*

...

..S

KAKTUS

【输入输出样例  】

slikar.in slikar.out

D...*.

.X.X..

....S.

题目

tag：模拟/dfs、bfs/最短路

思路：初始化所有点洪水出现的时间为无穷大，以每个“*”作基点向外dfs预处理更新时间（能取到最小值再扩展，此处算是剪枝），之后bfs走迷宫，到达的时间一定要先于洪水出现的时间，也可以二维转一维跑SPFA。

 #include<cstdio>

 #include<algorithm>

 #include<iostream>

 #include<cstring>

 #include<cmath>

 #include<queue>

 #define ll long long

 #define maxn 2510

 #define inf 707406378

 using namespace std;

 int dx[]={,,,-},dy[]={,,-,},n,m,cnt,dis[maxn],hl[maxn],MP[maxn],S,T,vis[maxn];

 char mp[][];

 queue<int>Q;

 struct X{

     int u,v,w,ne;

 }e[maxn*];

 void add(int u,int v)

 {

     e[++cnt].u=u;

     e[cnt].v=v;

     e[cnt].ne=hl[u];

     hl[u]=cnt;

 }

 int cal(int x,int y){return (x-)*m+y;}

 bool ok(int x,int y)

 {

     if(x>=&&x<=n&&y>=&&y<=m) return true;

     return false;

 }

 void dfs(int x,int y,int t)

 {

     if(!t||(ok(x,y)&&mp[x][y]=='.'&&t<MP[cal(x,y)])){

         MP[cal(x,y)]=t;

         for(int i=;i<;++i) dfs(x+dx[i],y+dy[i],t+);

     }

 }

 bool spfa()

 {

     dis[S]=;

     vis[S]=;

     Q.push(S);

     while(!Q.empty()){

         int u=Q.front();

         Q.pop();

         for(int i=hl[u];i;i=e[i].ne){

             int v=e[i].v,aft=dis[u]+;

             if(dis[v]>aft&&MP[v]>aft){

                 dis[v]=aft;

                 if(!vis[v]){

                     vis[v]=;

                     Q.push(v);

                 }

             }

         }

         vis[u]=;

     }

     if(dis[T]==inf) return false;

     return true;

 }

 int main()

 {

     //freopen("slikar.in","r",stdin);

     //freopen("slikar.out","w",stdout);

     memset(dis,/,sizeof(dis));

     memset(MP,/,sizeof(MP));

     scanf("%d%d",&n,&m);

     for(int i=;i<=n;++i)

         for(int j=;j<=m;++j)

             scanf(" %c",&mp[i][j]);

     for(int i=;i<=n;++i)

         for(int j=;j<=m;++j){

             if(mp[i][j]=='*') dfs(i,j,);

             else{

                 switch(mp[i][j]){

                     case 'S':S=cal(i,j);break;

                     case 'D':T=cal(i,j);break;

                     case 'X':continue;break;

                 }

                 for(int k=;k<;++k){

                     int X=i+dx[k],Y=j+dy[k],t=;

                     if(ok(X,Y)&&mp[X][Y]!='*'&&mp[X][Y]!='X') add(cal(i,j),cal(X,Y));

                 }

             }

         }

     if(!spfa()) puts("KAKTUS");

     else printf("%d\n",dis[T]);

     return ;

 }

————————今天好晚了懒得粘分割线呢————————

　　芒果君：表示这次终于没有翻车，没有预计结果因为害怕这么多模拟写炸，最后还挺高的，开森，不过以后还是要多刷图论啊。