贪心算法之区间选点

最新推荐文章于 2024-09-04 19:09:05 发布

GraveDiggerKIng

最新推荐文章于 2024-09-04 19:09:05 发布

阅读量682

点赞数

分类专栏：贪心算法

本文链接：https://blog.youkuaiyun.com/GraveDiggerKIng/article/details/8528888

版权

贪心算法专栏收录该内容

2 篇文章

订阅专栏

区间选点的主要内容只有一句话：对区间的末端点进行排序！

然后便可以简单操作了！

题目：

Radar

时间限制： 1000 ms | 内存限制： 65535 KB

难度： 3

描述

Assume the coasting is an infinite straight line. Land is in one side of coasting, sea in the other. Each small island is a point locating in the sea side. And any radar installation, locating on the coasting, can only cover d distance, so an island in the sea can be covered by a radius installation, if the distance between them is at most d.

We use Cartesian coordinate system, defining the coasting is the x-axis. The sea side is above x-axis, and the land side below. Given the position of each island in the sea, and given the distance of the coverage of the radar installation, your task is to write a program to find the minimal number of radar installations to cover all the islands. Note that the position of an island is represented by its x-y coordinates.

输入

The input consists of several test cases. The first line of each case contains two integers n (1<=n<=1000) and d, where n is the number of islands in the sea and d is the distance of coverage of the radar installation. This is followed by n lines each containing two integers representing the coordinate of the position of each island. Then a blank line follows to separate the cases.

The input is terminated by a line containing pair of zeros

输出

For each test case output one line consisting of the test case number followed by the minimal number of radar installations needed. "-1" installation means no solution for that case.

样例输入

样例输出

Case 1: 2
Case 2: 1

题目的意思就是给你一个坐标轴，雷达在x轴上，岛屿分布在x轴上方，给你岛屿的坐标以及雷达的最大扫描面积，求最少用几个雷达可以将所有的岛屿覆盖！

代码如下：

#include <stdio.h>
#include <math.h>
#include <algorithm>
using namespace std;
struct BB
{
    double B,E;
    int flag;
}a[1010];
int cmp(struct BB a1,struct BB a2)
{
    if(a1.E!=a2.E)
    return a1.E<a2.E;
}
int main()
{
    int n,N=1,d,i,sum=1,t=2;
    while(scanf("%d%d",&n,&d)!=EOF)
    {
        if(n==d&&d==0)  break;
        double x,y;
        for(i=1;i<=n;i++)
        {
            scanf("%lf%lf",&x,&y);
            if(d<y){t=1;}
            a[i].B=(x-sqrt(d*d-y*y));
            a[i].E=(x+sqrt(d*d-y*y));
            a[i].flag=1;
        }
        if(t==1)
        {
            printf("Case %d: -1\n",N);
        }
        else
        {
            sort(a+1,a+1+n,cmp);
            for(i=1;i<=n;i++)
            {
                for(int j=1;j<=n;j++)
                {
                    if(a[i].E<=a[j].E&&a[i].E>=a[j].B&&a[j].flag!=0)
                    {
                        a[j].flag=0;
                    }
                }
                for(int k=1;k<=n;k++)
                {
                    if(a[i].E<a[k].B)
                       {
                           sum++;
                           i=k-1;
                           a[k].flag=0;
                           break;
                       }
                }
            }
            printf("Case %d: %d\n",N,sum);
        }
        N++;
    }
    return 0;
}

我在做贪心时，发现最容易WA的原因就是粗心！！！（主要表现在核心代码的小细节上和定义某一些变量类型时）