51Nod 1278 相离的圆 c/c++题解

最新推荐文章于 2022-08-16 18:35:33 发布

东瓜Lee

最新推荐文章于 2022-08-16 18:35:33 发布

阅读量325

点赞数

分类专栏： # 51Nod 文章标签： 51Nod算法题解二分法技巧题

本文链接：https://blog.csdn.net/qq_41708792/article/details/100063206

版权

51Nod 专栏收录该内容

57 篇文章 4 订阅

订阅专栏

题目描述

平面上有N个圆，他们的圆心都在X轴上，给出所有圆的圆心和半径，求有多少对圆是相离的。
例如：4个圆分别位于1, 2, 3, 4的位置，半径分别为1, 1, 2, 1，那么{1, 2}, {1, 3} {2, 3} {2, 4} {3, 4}这5对都有交点，只有{1, 4}是相离的。
输入
第1行：一个数N，表示圆的数量(1 <= N <= 50000)
第2 - N + 1行：每行2个数P, R中间用空格分隔，P表示圆心的位置，R表示圆的半径(1 <= P, R <= 10^9)
输出
输出共有多少对相离的圆。
输入样例
4
1 1
2 1
3 2
4 1
输出样例
1

题解1：

按照圆的起点从小到大排序，然后枚举每个圆i的终点，找出第一个大于圆i的终点的起点，那么后面的圆一定不和圆i相交，统计出每一个圆和后面的圆不相交的个数即可。
注意：
根据终点找起点的时候，不能用O(n)的枚举方式，总的时间复杂度O(n²)(还有一层枚举终点的O(n)循环)不满足题目要求，但又因为起点是从小到大排序的，所以可以用二分法找起点。

代码1:

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <utility>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <bitset>
#include <iterator>
using namespace std;

typedef long long ll;
const int inf = 0x3f3f3f3f;
const ll  INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double E = exp(1.0);
const int MOD = 1e9+7;
const int MAX = 5e4+5;
int n;

struct circle
{
    int p,r;// p-圆心 r-半径
    int s,e;// 圆的左端点和右端点
}circle[MAX];

int cmp(struct circle C1,struct circle C2)
{
    return C1.s < C2.s;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    while(cin >> n)
    {
        for(int i = 0; i < n; i++)
        {
            cin >> circle[i].p >> circle[i].r;
            // 每个圆可以看作是一条线段，求相离的圆的数量 == 求不相交的线段的数量
            circle[i].s = circle[i].p - circle[i].r;
            circle[i].e = circle[i].p + circle[i].r;
        }
        sort(circle,circle+n,cmp);// 按照线段的起点排序
        int sum = 0;
        for(int i = 0; i < n; i++)
        {
            /* O(n2)的做法，直接从前往后找起点 - 超时
            for(int j = 0; j < n; j++)
            {
                if(circle[j].s > circle[i].e)
                {
                    sum += (n-j);
                    break;
                }
            }*/
            
            /* O(nlogn)的做法，用二分的方法找尽可能小而且又要大于终点的起点 --- 这个二分没写出来*/
            int l = 0; int r = n-1;
            int index = 0;
            while(l <= r)
            {
                int mid = (l+r)/2;
                if(circle[mid].s <= circle[i].e)
                {
                    l = mid + 1;
                }
                else
                {
                    r = mid - 1;
                    index = mid;
                }
            }
            sum += (n-index);
        }
        cout << sum << endl;
    }
    return 0;
}

题解2：

按照圆的终点从小到大排序，然后枚举每个圆i的起点，找出最后一个大于圆i的起点的终点，那么前面的圆一定不和圆i相交，统计出每一个圆和前的圆不相交的个数即可。
注意：
根据起点找终点的时候，不能用O(n)的枚举方式，总的时间复杂度O(n²)(还有一层枚举起点的O(n)循环)不满足题目要求，但又因为终点是从小到大排序的，所以可以用二分法找终点。

代码2：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <utility>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <bitset>
#include <iterator>
using namespace std;

typedef long long ll;
const int inf = 0x3f3f3f3f;
const ll  INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double E = exp(1.0);
const int MOD = 1e9+7;
const int MAX = 5e4+5;
int n;

struct circle
{
    int p,r;// p-圆心 r-半径
    int s,e;// 圆的左端点和右端点
}circle[MAX];

int cmp(struct circle C1,struct circle C2)
{
    return C1.e < C2.e;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    while(cin >> n)
    {
        for(int i = 0; i < n; i++)
        {
            cin >> circle[i].p >> circle[i].r;
            // 每个圆可以看作是一条线段，求相离的圆的数量 == 求不相交的线段的数量
            circle[i].s = circle[i].p - circle[i].r;
            circle[i].e = circle[i].p + circle[i].r;
        }
        sort(circle,circle+n,cmp);// 按照线段的终点排序
        int sum = 0;
        for(int i = 0; i < n; i++)
        {
            /* O(n2)的做法，直接从后往前找终点 - 超时
            for(int j = n-1; j >= 0; j--)
            {
                if(circle[j].e < circle[i].s)
                {
                    sum += j+1;
                    break;
                }
            }*/
            
            /* O(nlogn)的做法，用二分的方法找尽可能小而且大于等于起点的的终点 */
            int l = 0; int r = n-1;
            int index = 0;
            while(l <= r)
            {
                int mid = (l+r)/2;
                if(circle[mid].e >= circle[i].s)
                {
                    r = mid - 1;
                    index = mid;
                }
                else
                {
                    l = mid + 1;
                }
            }
            sum += index;
        }

        cout << sum << endl;
    }
    return 0;
}

题解3：

将所有的点(包括起点和终点)从小到大的排序(如果位置相同，按照第一个点的类型来排 - 这里我也不太理解，如果不写就会有的点过不了)，然后O(n)枚举2n个点，记录下起点的剩余数量res，如果遇到了起点，res–，如果遇到了终点，sum+=res，因为后面还有res个起点，一定不会和这个终点对应的圆相交。

代码3：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <utility>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <bitset>
#include <iterator>
using namespace std;

typedef long long ll;
const int inf = 0x3f3f3f3f;
const ll  INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double E = exp(1.0);
const int MOD = 1e9+7;
const int MAX = 5e4+5;
int n;
struct Node
{
    int x,type;
}node[2*MAX];

int cmp(Node a,Node b)
{
    if(a.x != b.x)// 坐标不同，按从小到大的顺序排
    {
        return a.x < b.x;
    }
    else// 坐标相同，按照起点在前的顺序排
    {
        return !a.type;
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    while(cin >> n)
    {
        int cnt = 0;
        int p,r;
        for(int i = 0; i < n; i++)
        {
            cin >> p >> r;
            node[cnt].x = p-r; node[cnt++].type = 0;// 起点
            node[cnt].x = p+r; node[cnt++].type = 1;// 终点
        }
        sort(node,node+cnt,cmp);// 将所有的点按照作为从小到大排序
        // 枚举每个点(包括起点和终点)
        // if i = 起点,则剩余起点个数-1
        // if i = 终点,则和这个终点对应的圆 不相交的圆的个数 为 剩余起点个数
        int sum = 0;
        int res = n;// 剩余起点的个数
        for(int i = 0; i < cnt; i++)
        {
            if(node[i].type == 0)
                res--;
            else
                sum += res;
        }
        cout << sum << endl;
    }

    return 0;
}