POJ2932 平面扫描

Description

A student named Round Square loved to play with cones. He would arrange cones with different base radii arbitrarily on the floor and would admire the intrinsic beauty of the arrangement. The student even began theorizing about how some cones dominate other cones: a cone A dominates another cone B when cone B is completely within the cone A. Furthermore, he noted that there are some cones that not only dominate others, but are themselves dominated, thus creating complex domination relations. After studying the intricate relations of the cones in more depth, the student reached an important conclusion: there exist some cones, all-powerful cones, that have unique properties: an all-powerful cone is not dominated by any other cone. The student became so impressed by the mightiness of the all-powerful cones that he decided to worship these all-powerful cones.

Unfortunately, after having arranged a huge number of cones and having worked hard on developing this grandiose cone theory, the student become quite confused with all these cones, and he now fears that he might worship the wrong cones (what if there is an evil cone that tries to trick the student into worshiping it?). You need to help this student by finding the cones he should worship.

Input

The input le specifies an arrangement of the cones. There are in total N cones (1 ≤ N ≤ 40000). Cone i has radius and height equal to R_i, i = 1 … N. Each cone is hollow on the inside and has no base, so it can be placed over another cone with smaller radius. No two cones touch.

The first line of the input contains the integer N. The next N lines each contain three real numbers R_i, x_i, y_i separated by spaces, where (x_i, y_i) are the coordinates of the center of the base of cone i.

Output

The first line of the output le should contain the number of cones that the student should worship. The second line contains the indices of the cones that the student should worship in increasing order. Two consecutive numbers should be separated by a single space.

Sample Input

5
1 0 -2
3 0 3
10 0 0
1 0 1.5
10 50 50

Sample Output

2
3 5
平面有N个两两没有公共点的园，i号园的园心在(xi, yi)，半径ri。求所有最外层，即不包含其他园内部的园。
我们可以在从左向右平移与y轴平行的直线的同时，维护与扫描线相交的最外层的园的集合。从左向右移动的过程中，只有扫描线移动到园的左右两端时，园与扫描线的相交关系才会发生变化，
因此我们先将所有这样的x坐标枚举出来并排号序。扫描到左端时，只要判断是否被包含在相邻的园中就行，因为假设该园被包含在更远的园中却不包含在最近的园中就会出现两园相交的情况，与题目两两没有公共点的园相矛盾。

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <vector>
#include <set>
using namespace std;
const int N = 40010;
double x[N], y[N], r[N];
int n;
bool inside(int i, int j) {
    double dx = x[i] - x[j], dy = y[i] - y[j];
    return dx * dx + dy * dy <= r[j] * r[j];
}
void solve() {
    vector<pair<double, int> > events;
    for(int i = 0; i < n; i ++) {
        events.push_back(make_pair(x[i] - r[i], i));
        events.push_back(make_pair(x[i] + r[i], i+n));
    }
    sort(events.begin(), events.end());
    set<pair<double, int> > st;
    vector<int> res;
    for(int i = 0; i < events.size(); i ++) {
        int id = events[i].second % n;
        if(events[i].second < n) {
            set<pair<double, int> > ::iterator it = st.lower_bound(make_pair(y[id], id));
            if(it != st.end() && inside(id, it->second)) continue;
            if(it != st.begin() && inside(id, (--it)->second)) continue;
            res.push_back(id);
            st.insert(make_pair(y[id], id));
        } else {
            st.erase(make_pair(y[id], id));
        }
    }
    sort(res.begin(), res.end());
    printf("%d\n",(int)res.size());
    for(int i = 0; i < res.size(); i ++) {
        printf("%d%c",res[i]+1, i +1 == res.size() ? '\n':' ');
    }
}
int main() {
    scanf("%d", &n);
    for(int i = 0; i < n; i ++) {
        scanf("%lf %lf %lf", &r[i], &x[i], &y[i]);
    }
    solve();
    return 0;
}