Wannafly挑战赛21

链接：https://www.nowcoder.com/acm/contest/159/A
来源：牛客网

灯塔

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述:

Z市是一座港口城市，来来往往的船只依靠灯塔指引

在海平面上，存在n个灯塔。每个灯塔可以照亮以它的中心点为中心的90°范围。特別地， 由于特殊限制，每个灯塔照亮范围的角的两条边必须要么与坐标轴平行要么与坐标轴成45°。 由于经费限制，Z市的灯塔只能被点亮一座。你需要求出在这种情况下，是否存在一座灯塔能够照亮Z市

 

 

 

 

 

输入描述:

第一行一个整数T,表示数据组数。
对于每组数据，第一行一个整数n，表示灯塔的数量。
接下来n行，每行两个整数xi,yi

，表示第i座灯塔的坐标点。

输出描述:

如果存在一座灯塔能够照亮Z市的所有灯塔则输出Yes，否则输出No（区分大小写）。

示例1

输入

复制

2
4
1 1
1 2
2 1
2 2
5
4 7
0 4
7 3
3 0
3 4

输出

复制

Yes
No

备注:

n≤1000000,T≤10,0≤|xi|,|yi|≤10^9

找到最优策略,就是四个角,x最小,x最大,y最小,y最大.

#include <bits/stdc++.h>
#define N 1000005
#define inf 1000000000
using namespace std;
struct Node{
    int x,y;
}node[N];
bool cmpx1(Node a,Node b){
    if(a.x == b.x){
        return a.y<b.y;
    }
    return a.x<b.x;
}
bool cmpy1(Node a,Node b){
    if(a.y == b.y){
        return a.x > b.x;
    }
    return a.y<b.y;
}
int t;
int main(){
    scanf("%d",&t);
    while(t--){
        int x1 = inf,x2 = -inf,y1 = inf,y2 = -inf;
        int n;
        scanf("%d",&n);
        bool prime = false;
        for(int i=0;i<n;i++){
            scanf("%d%d",&node[i].x,&node[i].y);
            x1 = min(x1,node[i].x);//x最小值
            x2 = max(x2,node[i].x);//x最大值
            y1 = min(y1,node[i].y);//y最小值
            y2 = max(y2,node[i].y);//y最大值
        }
        sort(node,node+n,cmpx1);//x最小y最小
        int xx = node[0].x,yy = node[0].y;
        int xn = node[n-1].x,yn = node[n-1].y;
        if((xx == x1&&yy == y1)||(xn == x2&&yn == y2)){
            prime = true;
        }else{
            bool flag = true;
            for(int i=0;i<n;i++){
                if(abs(node[i].y-yy)>abs(node[i].x-xx)){
                    flag = false;
                    break;
                }
            }
            if(flag) prime = true;
            flag = true;
            for(int i=0;i<n;i++){
                if(abs(node[i].y-yn)>abs(node[i].x-xn)){
                    flag = false;
                    break;
                }
            }
            if(flag) prime = true;
        }
        if(prime){
            cout<<"Yes"<<endl;
            continue;
        }
        sort(node,node+n,cmpy1);//x最小y最大
        xx = node[0].x,yy = node[0].y;
        xn = node[n-1].x,yn = node[n-1].y;
        if((xx == x2&&yy == y1)||(xn == x1&&yn == y2)){
            prime = true;
        }else{
            bool flag = true;
            for(int i=0;i<n;i++){
                if(abs(node[i].y-yy)<abs(node[i].x-xx)){
                    flag = false;
                    break;
                }
            }
            if(flag) prime = true;
            flag = true;
            for(int i=0;i<n;i++){
                if(abs(node[i].y-yn)<abs(node[i].x-xn)){
                    flag = false;
                    break;
                }
            }
            if(flag) prime = true;
        }
        if(prime){
            cout<<"Yes"<<endl;
        }else{
            cout<<"No"<<endl;
        }
    }
    return 0;
}

链接：https://www.nowcoder.com/acm/contest/159/B
来源：牛客网

机器人

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

从前在月球上有一个机器人。
月球可以看作一个 n*m 的网格图，每个格子有三种可能：空地，障碍，机器人（有且仅有一个），现在地面指挥中心想让机器人在月球上行走，每次可以发送一个指令，为 U-往上走、D-往下走、L-往左走、R-往右走的其中之一。
当机器人接收到一个行走指令时，如果即将到达的位置为障碍物，那么机器人将留在原地，否则机器人向对应方向走一步，如果其走出边界那么立即死亡。
地面指挥中心当然不想让机器人就这么挂掉，因此其定义一个操作序列是安全的，当且仅当机器人按此操作序列走不会死亡。
但是从地球向月球发信息不是个容易的事，而且有时候某些指令还会在茫茫宇宙中被吞没，比如指挥中心传出去 RUR 指令，到机器人那里就可能变成 RR 或者变成 U，因此定义一个操作序列是绝对安全的当且仅当其任意子序列都是安全的。
现在地面指挥中心想知道，对于某一个地图，绝对安全的操作序列最长可以到多少，如果存在一个长度为正无穷的这样的序列，那么输出-1。

输入描述:

第一行一个正整数T，表示数据组数。
接下来一共 T 组数据，每组数据第一行有两个正整数 n,m，表示网格图的大小, 接下来 n 行，每行 m 个字符，表示这张网格图。
其中字符“.”表示空地，“#”表示障碍物，“S”表示机器人所在位置。

输出描述:

一共 T 行，每行一个整数，表示答案。

示例1

输入

复制

3
5 5
#####
#...#
.#S#.
#...#
#####
1 7
S......
5 8
#.######
#.#..S.#
#.#.##.#
#......#
########

输出

复制

-1
6
-1

备注:

数据范围 0≤T,n,m≤50

这算是一个理解题,只要分析出来了,就能直接A.

#include <bits/stdc++.h>
using namespace std;
int dis[4][2]={0,1,0,-1,-1,0,1,0};
int t;
char s[55][55];
int main(){
    cin>>t;
    while(t--){
        memset(s,0,sizeof(s));
        int x,y;
        int xx,yy;
        cin>>x>>y;
        for(int i=0;i<x;i++){
            for(int j = 0;j<y;j++){
                cin>>s[i][j];
                if(s[i][j]=='S'){
                    xx = i,yy = j;
                }
            }
        }
        bool prime = true;
        for(int i=0;i<4;i++){
            int x1 = xx,y1 = yy;
            for(int j= 0;x1>=0&&x1<x&&y1>=0&&y1<y;j++){
                x1 += dis[i][0];
                y1 += dis[i][1];
                if(s[x1][y1]=='#'){
                    prime = false;
                    break;
                }
            }
            if(!prime) break;
        }
        if(prime){
            cout<<x+y-2<<endl;
        }else{
            cout<<"-1"<<endl;
        }
    }
    return 0;
}

链接：https://www.nowcoder.com/acm/contest/159/C
来源：牛客网

大水题

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 131072K，其他语言262144K
64bit IO Format: %lld

题目描述

现在给你N个正整数a_i，每个数给出一“好数程度” g_i（数值相同但位置不同的数之间可能有不同的好数程度）。对于在 i 位置的数，如果有一在j位置的数满足 j < i 且 a_i=a_j，则你可以将位于[i,j]闭区间内的序列评为“好序列”，然后获得∑g_k(j≤k≤i)（此闭区间内“好数程度”之和）分数。

注意: 在所有情况下，每个数都只能被一个”好序列”包含（只能与其他相应数被评为”好序列”一次）；在符合要求的情况下，”好序列”的评定次数不受限制，且通过不同”好序列”获得的分数可以累加。

输入描述:

第一行有一个正整数N。
接下来的一行有N个正整数a

_i

，表示意义如上。
（保证a

_i

在32位整型范围内）
接下来的一行有N个正整数g

_i

，表示a

_i

的”好数程度”。
（保证g

_i

在64位整型范围内）

输出描述:

一个整数，你可以获得的最大分数（通过不同”好序列”获得的分数可以累加），保证答案在64位整型范围内。

示例1

输入

复制

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

输出

复制

23

备注:

数据范围 2≤N≤300000

题目叫大水题,但是我没写出来.(哭死)
赛后补题看了一下别人的思路,dp,加上前缀和就行.

#include <bits/stdc++.h>
#define N 300005
#define ll long long int
using namespace std;

ll a[N],b[N],dp[N][2];
map<ll,ll> mp;

int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    for(int i=1;i<=n;i++){
        cin>>b[i];
        b[i] += b[i-1];
    }
    for(int i=1;i<=n;i++){
        ll ans;
        if(mp.count(a[i]))
            ans = mp[a[i]];
        else ans = 0;
        if(ans){
            dp[i][1] = max(dp[ans][1]+b[i]-b[ans],dp[ans][0]+b[i]-b[ans-1]);
        }
        dp[i][0] = max(dp[i-1][0],dp[i-1][1]);
        mp[a[i]] = i;
    }
    cout<<max(dp[n][0],dp[n][1])<<endl;
    return 0;
}