玄关求条QWQ

#include<bits/stdc++.h>
using namespace std;

const double EPS = 1e-9;

struct Pt {
    double x, y;
    Pt() : x(0), y(0) {}
    Pt(double x, double y) : x(x), y(y) {}
};

double sq(double x) { return x * x; }

double dst(const Pt& a, const Pt& b) {
    return sqrt(sq(a.x - b.x) + sq(a.y - b.y));
}

void cir_int(Pt A, double rA, Pt B, double rB, vector<Pt>& res) {
    double dx = B.x - A.x, dy = B.y - A.y;
    double d2 = sq(dx) + sq(dy);
    if (d2 < EPS) return;
    double d = sqrt(d2);
    if (d > rA + rB + EPS || d < fabs(rA - rB) - EPS) 
        return;
    
    double a = (sq(rA) - sq(rB) + d2) / (2 * d);
    double h = sqrt(sq(rA) - sq(a));
    double px = A.x + a * dx / d;
    double py = A.y + a * dy / d;
    
    res.push_back(Pt(px - h * dy / d, py + h * dx / d));
    res.push_back(Pt(px + h * dy / d, py - h * dx / d));
}

int main() {
    int N, M;
    double Rmx;
    cin >> N >> M >> Rmx;
    vector<double> bx(N), by(N), br(N);
    for (int i = 0; i < N; i++) {
        cin >> bx[i] >> by[i] >> br[i];
    }
    vector<Pt> enm;
    for (int i = 0; i < M; i++) {
        double x, y;
        cin >> x >> y;
        enm.push_back(Pt(x, y));
    }

    vector<Pt> cand = enm;
    
    if (N > 0) {
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                vector<Pt> tmp;
                cir_int(Pt(bx[i], by[i]), br[i] + Rmx, 
                       Pt(bx[j], by[j]), br[j] + Rmx, tmp);
                
                for (const Pt& p : tmp) {
                    bool ok = true;
                    for (int k = 0; k < N; k++) {
                        double d = dst(p, Pt(bx[k], by[k]));
                        if (d < br[k] + Rmx - EPS) {
                            ok = false;
                            break;
                        }
                    }
                    if (ok) cand.push_back(p);
                }
            }
        }

        for (int j = 0; j < M; j++) {
            for (int i = 0; i < N; i++) {
                double dx = enm[j].x - bx[i];
                double dy = enm[j].y - by[i];
                double d2 = sq(dx) + sq(dy);
                double Re = br[i] + Rmx;
                double Re2 = sq(Re);
                
                if (d2 < Re2 + EPS) continue;
                if (d2 < EPS) continue;
                
                double base_x = bx[i] + (sq(Re) * dx) / d2;
                double base_y = by[i] + (sq(Re) * dy) / d2;
                
                double sqrt_val = Re * sqrt(d2 - Re2) / d2;
                
                cand.push_back(Pt(
                    base_x - sqrt_val * dy,
                    base_y + sqrt_val * dx
                ));
                
                cand.push_back(Pt(
                    base_x + sqrt_val * dy,
                    base_y - sqrt_val * dx
                ));
            }
        }
    }

    int ans = 0;
    for (const Pt& c : cand) {
        double rad = Rmx;
        bool skip = false;
        
        for (int i = 0; i < N; i++) {
            double d = dst(c, Pt(bx[i], by[i]));
            double r_needed = d - br[i];
            
            if (r_needed < -EPS) {
                skip = true;
                break;
            }
            if (r_needed < rad) 
                rad = r_needed;
        }
        
        if (skip || rad < EPS) continue;
        
        int cnt = 0;
        for (const Pt& e : enm) {
            if (dst(c, e) < rad + EPS) 
                cnt++;
        }
        
        if (cnt > ans) ans = cnt;
    }
    
    cout << ans << endl;
    return 0;
}