bool get_min(T& a, const T &b) {return b < a? a = b, 1: 0;}
#define SQR(v) ((v) * (v))
const int maxint = -1u>>1;
const double eps = 1e-6;
int sgn(const double &a) {
return (a > eps) - (a < -eps);
}
struct P {
double x, y;
P(double _x, double _y)
:x(_x), y(_y) {}
P() {}
bool operator == (const P &a) const {
return sgn(x - a.x) == 0 && sgn(y - a.y) == 0;
}
bool operator != (const P &a) const {
return sgn(x - a.x) != 0 || sgn(y - a.y) != 0;
}
bool operator < (const P &a) const {
return sgn(x - a.x) < 0 || sgn(x - a.x) == 0 && sgn(y - a.y) < 0;
}
P operator + (const P &a) const {
return P(x + a.x, y + a.y);
}
P operator - (const P &a) const {
return P(x - a.x, y - a.y);
}
P operator * (const double &a) const {
return P(x * a, y * a);
}
P operator / (const double &a) const {
return P(x / a, y / a);
}
P turn_left() const {
return P(-y, x);
}
P trunc(double a) const {
a /= sqrt(SQR(x) + SQR(y));
return P(x * a, y * a);
}
void input() {
scanf("%lf %lf", &x, &y);
}
void output() const {
printf("%lf %lf\n", x, y);
}
};
double dist(const P &a, const P &b) {
return sqrt(SQR(a.x - b.x) + SQR(a.y - b.y));
}
struct Simplex {
static const int maxn = 2500 + 100;
double A[maxn][maxn], b[maxn], c[maxn], v;
int Nsets[maxn], Bsets[maxn], Nsize, Bsize;
void clear(int n, int m, int *T) {
Nsize = n, Bsize = m;
memset(c, 0, sizeof(c));
for (int i = 0; i < Nsize; ++i) {
c[i] = -1;
}
for (int i = 0; i < Bsize; ++i) {
b[Nsize + i] = -T[i];
}
for (int i = 0; i < Bsize; ++i) {
Bsets[i] = Nsize + i;
}
for (int i = 0; i < Nsize; ++i) {
Nsets[i] = i;
}
v = 0;
memset(A, 0, sizeof(A));
}
void insert(int u, int v, double c) {
A[u + Nsize][v] = c;
}
void del() {
for (int i = 0; i < Bsize; ++i) {
if (Bsets[i] == Nsize + Bsize - 1) {
pivot(Nsize + Bsize - 1, Nsets[0]);
}
}
for (int i = 0; i < Nsize; ++i) {
if (Nsets[i] == Nsize + Bsize - 1) {
Nsets[i] = Nsets[--Nsize];
return ;
}
}
while (1);
}
void init() {
int l = Bsets[0];
for (int i = 0; i < Bsize; ++i) {
if (b[Bsets[i]] < b[l]) {
l = Bsets[i];
}
}
if (sgn(b[l]) >= 0) {
return ;
}
double remc[maxn];
copy(c, c + Nsize + Bsize + 1, remc);
Nsets[Nsize] = Nsize + Bsize;
++Nsize;
for (int i = 0; i < Bsize; ++i) {
A[Bsets[i]][Nsize + Bsize - 1] = -1;
}
memset(c, 0, sizeof(c));
c[Nsize + Bsize - 1] = -1;
pivot(l, Nsize + Bsize - 1);
if (sgn(optimize()) < 0) {
printf("error: nosolution\n");
return ;
}
del();
copy(remc, remc + Nsize + Bsize + 1, c);
for (int a = 0; a < Bsize; ++a) {
int i = Bsets[a];
if (sgn(c[i]) != 0) {
v += c[i] * b[i];
for (int j = 0; j < Nsize; ++j) {
c[Nsets[j]] -= A[i][Nsets[j]] * c[i];
}
c[i] = 0;
}
}
}
double find() {
init();
optimize();
return v;
}
double optimize() {
while (1) {
int l, e;
double mmax = -1;
for (int i = 0; i < Nsize; ++i) {
int tmpe = Nsets[i];
if (sgn(c[tmpe]) <= 0) {
continue;
}
int tmpl = maxint;
double mmin = 1e100;
for (int i = 0; i < Bsize; ++i) {
int u = Bsets[i];
if (sgn(A[u][tmpe]) > 0 && (b[u] / A[u][tmpe] < mmin || sgn(b[u] / A[u][tmpe] - mmin) == 0 && u < tmpl)) {
mmin = b[u] / A[u][tmpe];
tmpl = u;
}
}
if (tmpl == maxint) {
return mmin;
}
if (mmin * c[tmpe] > mmax) {
mmax = mmin * c[tmpe];
l = tmpl;
e = tmpe;
}
}
if (mmax == -1) {
return v;
}
pivot(l, e);
}
}
void pivot(int l, int e) {
b[e] = b[l] / A[l][e];
A[e][l] = 1 / A[l][e];
for (int i = 0; i < Nsize; ++i) {
int u = Nsets[i];
if (u != e) {
A[e][u] = A[l][u] / A[l][e];
}
}
for (int i = 0; i < Bsize; ++i) {
int u = Bsets[i];
if (u != l) {
b[u] -= A[u][e] * b[e];
A[u][l] = -A[u][e] * A[e][l];
for (int j = 0; j < Nsize; ++j) {
int v = Nsets[j];
if (v != e) {
A[u][v] -= A[u][e] * A[e][v];
}
}
}
}
v += b[e] * c[e];
c[l] = -A[e][l] * c[e];
for (int i = 0; i < Nsize; ++i) {
int u = Nsets[i];
if (u != e) {
c[u] -= c[e] * A[e][u];
}
}
for (int i = 0; i < Nsize; ++i) {
if (Nsets[i] == e) {
Nsets[i] = l;
break;
}
}
for (int i = 0; i < Bsize; ++i) {
if (Bsets[i] == l) {
Bsets[i] = e;
break;
}
}
}
} simplex;
struct Graph {
static const int maxn = 100 * 100;
static const int maxm = 100;
int n, m;
int adj[maxn][maxm];
void init() {
n = m = 0;
memset(adj, 0, sizeof(adj));
}
void insert(int u, int v) {
get_max(n, u + 1);
get_max(m, v + 1);
adj[u][v] = 1;
}
double find_ans(int *T) {
simplex.clear(n, m, T);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (adj[i][j]) {
simplex.insert(j, i, -1);
}
}
}
double ans = simplex.find() * -1;
return ans;
}
};
Graph g;
int main() {
int ca;
scanf("%d", &ca);
while (ca--) {
int n, r;
scanf("%d %d", &n, &r);
P dt[n];
int T[n];
for (int i = 0; i < n; ++i) {
dt[i].input();
scanf("%d", T + i);
}
vector cir;
bool visited[n];
for (int i = 0; i < n; ++i) {
visited[i] = false;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (dt[i] != dt[j]) {
double d = dist(dt[i], dt[j]);
if (sgn(d - r * 2) == 0) {
cir.push_back((dt[i] + dt[j]) / 2);
visited[i] = visited[j] = true;
} else if (sgn(d - r * 2) < 0) {
cir.push_back((dt[i] + dt[j]) / 2 + (dt[j] - dt[i]).turn_left().trunc(sqrt(SQR(r) - SQR(d / 2))));
visited[i] = visited[j] = true;
}
}
}
}
sort(cir.begin(), cir.end());
cir.erase(unique(cir.begin(), cir.end()), cir.end());
g.init();
double ans = 0;
for (int i = 0; i < n; ++i) {
if (visited[i] == false) {
ans += T[i];
T[i] = -116;
}
}
for (int i = 0; i < SZ(cir); ++i) {
for (int j = 0; j < n; ++j) {
if (sgn(dist(cir[i], dt[j]) - r) <= 0) {
g.insert(i, j);
}
}
}
printf("%.2lf\n", ans + g.find_ans(T));
}
return 0;
}
]]>
