2017计蒜之道程序设计大赛初赛第六场题解

比赛链接

题目可以在比赛的题目列表中查看

微软手机的信号显示

命题人：镇高红

微软近日推出了一款功能极简的手机，在手机上用一个包含了 7×77 \times 77×7 个像素的区域来显示手机信号。满信号的时候显示如下：

+-----+

|-  4G|

|--   |

|---  |

|---- |

|-----|

+-----+

每一格信号（第 i(1≤i≤5)i(1 \le i \le 5)i(1≤i≤5) 格信号有 iii 个

-

）代表 20%20\%20% 的信号强度，不足一格信号的部分不显示。同时会在右上角显示当前的网络传输模式。在信号强度不低于 90%90\%90% 的时候显示

4G

；当信号低于90%90\%90%、不低于 60%60\%60% 的时候显示

3G

；否则显示

E

。

对于给定的当前信号强度 d%d\%d%，输出信号的 7×77
\times 77×7 像素的图案。

输入格式

输入一个整数 d(0≤d≤100)d(0 \le d \le 100)d(0≤d≤100)，表示信号强度。

输出格式

按照题目要求输出，每行末尾不要输出多余的空白字符。

样例输入1

0

样例输出1

+-----+
|    E|
|     |
|     |
|     |
|     |
+-----+

样例输入2

65

样例输出2

+-----+
|-  3G|
|--   |
|---  |
|     |
|     |
+-----+

解题思路：简单的模拟题，分支判断结构。

比较简单，按题目要求输出就可以了。

AC：

#include<iostream>
#include<stdio.h>
#include<map>
#include<vector>
#include<queue>
#include<set>
#include<cstdlib>
#include<string.h>
#include<algorithm>
#include<cmath>
#define MAXN 1000010
#define EPS 1e-9
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;

int main()
{
int d,n,m,k,i,j;
scanf("%d",&d);
printf("+-----+\n");
n=d/20;
for(i=1;i<=5;i++)
{
if(i==1)
{
if(d>=90)
{
if(n<i)
printf("| 4G|\n");
else
printf("|- 4G|\n");
}
else if(d>=60&&d<90)
{
if(n<i)
printf("| 3G|\n");
else
printf("|- 3G|\n");
}
else
{
if(n<i)
printf("| E|\n");
else
printf("|- E|\n");
}
}
else
{
if(n<i)
printf("| |\n");
else
{
printf("|");
for(j=1;j<=i;j++)
{
printf("-");
}
for(k=j;k<=5;k++)
printf(" ");
printf("|\n");
}
}

}
printf("+-----+\n");
return 0;
}

Java版：

package jisuanzhidao.chusai6;

import java.util.Scanner;

public class One {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();

String [] strs=new String[5];
strs[0]=null;
strs[1]="|--   |";
strs[2]="|---  |";
strs[3]="|---- |";
strs[4]="|-----|";

String blank="|     |";
String s4G="|-  4G|";
String s3G="|-  3G|";
String E0="|    E|";
String E1="|-   E|";

System.out.println("+-----+");
if(n>=90){
strs[0]=s4G;
}
else if(n>=60){
strs[0]=s3G;
}
else if(n>=20){
strs[0]=E1;
}
else{
strs[0]=E0;
}
System.out.println(strs[0]);
n-=20;
int i=1;
while(n>=20){
n-=20;
System.out.println(strs[i++]);
}
for(;i<5;++i){
System.out.println(blank);
}
System.out.println("+-----+");
}

}

微软大楼设计方案

命题人：陈松扬

近日，微软新大楼的设计方案正在广泛征集中，其中一种方案格外引人注目。在这个方案中，大楼由 nnn 栋楼组成，这些楼从左至右连成一排，编号依次为 111 到 nnn，其中第 iii 栋楼有 hih_ih​i​​ 层。每栋楼的每一层为一个独立的 办公区域，可以步行 直达同层相邻楼栋的办公区域，以及 直达同楼栋相邻楼层的办公区域。





由于方案设计巧妙，上一层楼、下一层楼、向左右移动到相邻楼栋同层的办公区域均刚好需要 111 分钟。在这些办公区域中，有一些被 核心部门 占用了（一个办公区域内最多只有一个核心部门），出于工作效率的考虑，微软希望核心部门之间的移动时间越短越好。对于一个给定的 最大移动时间 kkk，大楼的 协同值 定义为：有多少个 核心部门对 之间的移动时间不超过 kkk。由于大楼门禁的限制，不可以走出整个大楼，也不可以登上天台思考人生。你可以认为在办公区域内的移动时间忽略不计，并且在大楼内总是按照最优方案进行移动。

对于一个给定的新大楼设计方案，你能算出方案的协同值么？

输入格式

第一行包含两个正整数 n,k(1≤k≤200020)n,k(1\leq k\leq 200020)n,k(1≤k≤200020)，分别表示大楼的栋数以及最大移动时间。

第二行包含 nnn 个正整数 h1,h2,...,hn(1≤hi≤20)h_1,h_2,...,h_n(1\leq
h_i\leq 20)h​1​​,h​2​​,...,h​n​​(1≤h​i​​≤20)，分别表示每栋楼的层数。

接下来一行包含一个正整数 mmm，表示 核心部门 个数。

接下来 mmm 行，每行两个正整数 xi,yi(1≤xi≤n,1≤yi≤hxi)x_i,y_i(1\leq
x_i\leq n,1\leq y_i\leq h_{x_i})x​i​​,y​i​​(1≤x​i​​≤n,1≤y​i​​≤h​x​i​​​​)，表示该核心部门位于第 xix_ix​i​​ 栋楼的第 yiy_iy​i​​ 层。

输入数据保证 mmm 个核心部门的位置不会重复。

对于简单版本：1≤n,m≤501\leq n,m\leq 501≤n,m≤50；

对于中等版本：1≤n≤200000,1≤m≤20001\leq n\leq 200000,1\leq m\leq 20001≤n≤200000,1≤m≤2000；

对于困难版本：1≤n,m≤2000001\leq n,m\leq 2000001≤n,m≤200000。

输出格式

输出一个整数，即整个大楼的 协同值。

样例解释

样例对应题目描述中的图，核心部门 111 和核心部门 333 之间的距离为 8>78>78>7，因此不能计入答案。

样例输入

5 7
4 1 1 3 1
3
1 4
3 1
4 3

样例输出

2

简单

枚举每个 核心部门 作为起点，然后 BFS 求出到其它所有核心部门的最短路即可。

时间复杂度 O(mnh+m^2)O(mnh+m​2​​)。

#include<iostream>
#include<stdio.h>
#include<map>
#include<vector>
#include<queue>
#include<set>
#include<cstdlib>
#include<string.h>
#include<algorithm>
#include<cmath>
#define MAXN 1000010
#define EPS 1e-9
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;

struct node{
int x;
int y;
}p[55];

bool cmp(node a,node b)
{
if(a.x!=b.x)
return a.x<b.x;
else
return a.y<b.y;
}

int h[55];

int main()
{
int n,m,k,i,j,xi,yi,xj,yj,cnt,ii,jj,tx,ty,ans;
scanf("%d%d",&n,&k);
for(i=1;i<=n;i++)
{
scanf("%d",&h[i]);
}
scanf("%d",&m);
for(i=1;i<=m;i++)
{
scanf("%d%d",&p[i].x,&p[i].y);
}
ans=0;
sort(p+1,p+m+1,cmp);
for(i=1;i<m;i++)
{
xi=p[i].x;
yi=p[i].y;
for(j=i+1;j<=m;j++)
{
xj=p[j].x;
yj=p[j].y;
cnt=0;
if(xi==xj)
{
cnt+=yj-yi;
if(cnt<=k)
{
ans++;
}
}
else
{
tx=xi;
ty=yi;
for(ii=xi;ii<xj;ii++)
{
if(h[ii+1]<ty)
{
cnt+=ty-h[ii+1];
cnt++;
ty=h[ii+1];
tx=ii+1;
}
else
{
cnt++;
tx=ii+1;
}
}
cnt+=abs(ty-yj);
if(cnt<=k)
{
ans++;
}
}
}
}
printf("%d\n",ans);
return 0;
}

中等

对于两个核心部门 A,BA,B，不妨设 x_A\leq
x_Bx​A​​≤x​B​​，那么有 dis(A,B)=x_B-x_A+y_A+y_Bdis(A,B)=x​B​​−x​A​​+y​A​​+y​B​​ -2\min(h_{x_A},h_{x_A+1},...,h_{x_B},
y_A, y_B)−2min(h​x​A​​​​,h​x​A​​+1​​,...,h​x​B​​​​,y​A​​,y​B​​)。

枚举两个核心部门，那么瓶颈在于快速计算某个区间内 hh 的最小值。注意到 h\leq
20h≤20，设 s[i][j]s[i][j]表示前 ii 个位置中有多少 hh 为 jj，那么从小到大枚举 jj 即可得到最小值，每次查询复杂度为 O(h)O(h)。

时间复杂度 O(nh+m^2h)O(nh+m​2​​h)。

线段树：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;
/******************************************************/
#define LL long long int
#define mem(a,b) memset(a,b,sizeof(a))
#define mid ((l+r)/2)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define L rt<<1
#define R rt<<1|1
#define N 200000+50
#define pow(a) a*a
#define INF 0x3f3f3f3f
#define max(a,b) (a>b?a:b)
#define min(a,b) (a<b?a:b)
/*********************************************************/
int n, MAX;
int m;
int dat
;
struct node{
int l, r, minn;
};
struct tree{
int x, high;
}house
;
node s[N<<2];
void build(int l, int r, int rt){
if (l == r){
s[rt].minn = dat[l];
return;
}
build(lson);
build(rson);
s[rt].minn = (s[L].minn < s[R].minn ? s[L].minn : s[R].minn);
}
int query(int a, int b, int l, int r, int rt){
if (a <= l&&r <= b){
return s[rt].minn;
}
int m = (l + r) / 2;
int res = 0, res2 = 0;
if (a <= m)res = query(a, b, lson);
if (b > m)res2 = query(a, b, rson);
return min(res, res2);
}
int dis(tree a, tree b){
return abs(a.x - b.x) + abs(a.high - b.high);
}
int main(){
scanf("%d%d", &n, &MAX);
for (int i = 1; i <= n; i++){
scanf("%d", &dat[i]);
}
build(1, n, 1);
scanf("%d", &m);
for (int i = 1; i <= m; i++){
int a, b;scanf("%d%d", &a, &b);
house[i].x = a;
house[i].high = b;
}
int cnt = 0;
for (int i = 1; i <= m; i++){
for (int j = 1+i; j <= m; j++){
int did = dis(house[i], house[j]);
if (did > MAX)continue;
int minn = query(house[i].x, house[j].x, 1, n, 1);
if (minn == min(house[i].high, house[j].high)){
cnt++;
}
else{
int d = house[i].high + house[j].high + abs(house[i].x - house[j].x)-2;
if (d <= MAX)cnt++;
}
}
}
cout << cnt  << endl;

}

Java：（似乎有点问题？？）

解题思路：简单版本，暴力枚举即可。

                  中等版本，考虑特殊情况，如两点直连的距离小于k，则必然不能到达；两点由最低层走最长路径小于等于k，则必然能到达。

package jisuanzhidao.chusai6;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Two {

public static void main(String[] args)throws IOException {
// TODO Auto-generated method stub
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
line=br.readLine();
String [] strss=line.split(" ");
int n=Integer.parseInt(strss[0]);
int k=Integer.parseInt(strss[1]);
line=br.readLine();
String [] strsH=line.split(" ");
int [] h=new int
;
for(int i=0;i<n;++i){
h[i]=Integer.parseInt(strsH[i]);
}
line=br.readLine();
int m=Integer.parseInt(line);
int [] x=new int[m];
int [] y=new int[m];
int i=0;
int M=m;
while((M--)>0){
line=br.readLine();
String [] strs=line.split(" ");
x[i]=Integer.parseInt(strs[0]);
y[i++]=Integer.parseInt(strs[1]);
}
int ans=0;
for(int j=0;j<m;++j){
for(int w=j+1;w<m;++w){
if(lessThanK(x,y,h,k,j,w)){
++ans;
}
}
}
System.out.println(ans);
}

public static boolean lessThanK(int [] x,int [] y,int []h,int k,int start,int end){
if((Math.abs(x[start]-x[end])+Math.abs(y[start]-y[end]))>k){
return false;
}
if((Math.abs(x[start]-x[end])+y[start]+y[end]-2)<=k){
return true;
}
else{
int s=x[start];
int e=x[end];
if(s>e){
int t=s;
s=e;
e=t;
}
int maxH=y[start]<y[end]?y[start]:y[end];
for(int Y=maxH;Y>=1;--Y){
boolean flag=true;
for(int i=s-1;i<e;i++){
if(h[i]<Y){
flag=false;
break;
}
}
if(flag){
maxH=Y;
break;
}
}
int xlen=Math.abs(x[start]-x[end])+1;
int ylen=y[start]-maxH+y[end]-maxH;
if((xlen+ylen-1)<=k){
return true;
}
else{
return false;
}

}
}

}

困难

还是假设 x_A\leq
x_Bx​A​​≤x​B​​，考虑从左往右枚举 BB，用一个单调上升的栈维护 hh，那么对于当前的 BB 来说，单调栈按 hh 的区间最小值将序列划分成了 O(h)O(h) 个子区间。

枚举每个子区间，再枚举 y_Ay​A​​ 的值，那么此时 x_Ax​A​​ 的取值范围可以直接通过解不等式得到，用前缀和询问出该范围内有多少核心部门即可。

时间复杂度 O(nh^2)O(nh​2​​)。

由于测试数据的覆盖能力有限，出现了一些能通过大规模数据但不能通过小规模数据的情况，这说明写出的代码仍然是有问题的，再仔细检查一下代码。