One-Dimensional Battle Ships CodeForces - 567D

One-Dimensional Battle Ships

题目描述
Alice and Bob love playing one-dimensional battle ships. They play on the field in the form of a line consisting of n square cells (that is, on a 1 × n table).

At the beginning of the game Alice puts k ships on the field without telling their positions to Bob. Each ship looks as a 1 × a rectangle (that is, it occupies a sequence of a consecutive squares of the field). The ships cannot intersect and even touch each other.

After that Bob makes a sequence of “shots”. He names cells of the field and Alice either says that the cell is empty (“miss”), or that the cell belongs to some ship (“hit”).

But here’s the problem! Alice like to cheat. May be that is why she responds to each Bob’s move with a “miss”.

Help Bob catch Alice cheating — find Bob’s first move, such that after it you can be sure that Alice cheated.

Input
The first line of the input contains three integers: n, k and a (1 ≤ n, k, a ≤ 2·105) — the size of the field, the number of the ships and the size of each ship. It is guaranteed that the n, k and a are such that you can put k ships of size a on the field, so that no two ships intersect or touch each other.

The second line contains integer m (1 ≤ m ≤ n) — the number of Bob’s moves.

The third line contains m distinct integers x1, x2, …, xm, where xi is the number of the cell where Bob made the i-th shot. The cells are numbered from left to right from 1 to n.

Output
Print a single integer — the number of such Bob’s first move, after which you can be sure that Alice lied. Bob’s moves are numbered from 1 to m in the order the were made. If the sought move doesn’t exist, then print “-1”.

Example

Input
11 3 3
5
4 8 6 1 11
Output
3

Input
5 1 3
2
1 5
Output
-1

Input
5 1 3
1
3
Output
1

大致题意
在一条长度为n的板子上，放着k艘长度为a的船，船和船之间不能接触（即最少得相隔一个单位放置）Bob 攻击m个位置，每次Alice得告诉Bob是否击中，但就算击中了Alice也会撒谎说没有击中，问最少需要几次就能判断Alice说谎，如果能则输出最少次数，否则输出-1.

思路
可以先求出最多可以放置的船的数量sum，然后用set来维护攻击点的位置，先将0，和n+1两个点初始化放入set，然后每次更新攻击点u，找set中和他最近的左右两个点l和r，更新sum，然后更新u点的num和l点的num，如果sum < k，则输出此时的次数，将flag标记为1，结束，否则将u点放入set，更新l，放入set。如果最后flag不为1则输出-1.

下面是代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#include<cmath>
#include<string>
#include<set> 
#define eps 1e-7
#define LD long double
#define LL long long
#define maxn 200050
using namespace std;
struct node{    
    int num,idx;  //idx表示坐标值，num表示这个点到下个标记点之间间最多可以放置的船的数量
};
bool operator <(node x,node y)
{
    return x.idx<y.idx;
}
int b[maxn]; 

set<node>myset;
set<node>::iterator it;

int shu(int l,int a) //求在区间长为l中最多可以放置的长度为a的小船的数量
{
    int num,yu;
    num=l/(a+1);
    yu=l%(a+1);
    if(yu==a) num++;
    return num;

}

int main()
{
    int n,k,a;
    cin>>n>>k>>a;
    myset.clear();
    int sum=shu(n,a);//开始最多可以放置的小船的数量
    node v;
    v.idx=0;
    v.num=sum;
    myset.insert(v);//初始化0点，放入set
    v.idx=n+1;
    v.num=0;
    myset.insert(v);//初始化n+1点，放入set

    int m;
    cin>>m;
    for(int i=1;i<=m;i++) 
    cin>>b[i];
    int flag=1,cnt=0;
    for(int i=1;i<=m;i++)//遍历m次攻击的点
    {
        node u;
        u.idx=b[i];
        u.num=0;
        it=myset.lower_bound(u);//找到攻击点最近的右边那个点

        node temp1,temp2;
        temp2=*it;//最近的右边点r
        it--;
        temp1=*it;//最近的左边点l
        sum-=temp1.num;//l到r这个区间最多可以放置的船的数量会改变，所以sum减去原来这个区间内最多可以放置的数量

        node t1,t2;
        t1.idx=temp1.idx;
        t1.num=shu(b[i]-temp1.idx-1,a);//求出l到u这个区间内最多可以放置的船的数量，更新num

        t2.idx=b[i];
        t2.num=shu(temp2.idx-b[i]-1,a);//求出u到r这个区间内最多可以放置的船的数量，更新num
        sum+=t1.num+t2.num;//更新此时板子上最多可以放置的船的数量sum
        if(sum<k)//如果sum<k，说明Alice说谎
        {
            flag=0;
            cnt=i;
            break;
        }
        myset.erase(temp1);//否则，将旧点l移除set，将新的点l和u放入set
        myset.insert(t1);
        myset.insert(t2);
    }
    if(flag==0) //输出结果
     cout<<cnt;
     else 
     cout<<-1;
     return 0;
}