蔚来杯2022牛客暑期多校训练营5 ABCDFGHK

比赛链接

A

题解

知识点：图论，dp。

暴力建图，连接所有点的双向通路，除了原点是单向的，并且把路径长度作为权值。

随后，从原点出发（ $f[0] = 0$ ，其他点负无穷，保证从原点出发），按照权值从大到小（大的先走小的后走，相等属于同一阶段，满足拓扑序）进行dp。

对于路径 $(u,v)$ 的状态转移方程是 $g[v] = max(g[v],f[u]+1)$ ，其中 $f,g$ 分别存储上一次结果和这一次结果，做到滚动数组节省空间，随后把 $g$ 还给 $f$ ，下次dp前把 $g$ 初始化负无穷。

最后，找到所有点的最大值。

时间复杂度 $O(n^2)$

空间复杂度 $O(n^2)$

代码

 #include <bits/stdc++.h>
 
using namespace std;
 
struct node {
    int u, v, w;
};
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    pair<int, int> p[2007];
    for (int i = 1;i <= n;i++) {
        int u, v;
        cin >> u >> v;
        p[i] = { u,v };
    }
    vector<node> e;
    for (int i = 0;i <= n;i++)///暴力连边,只从原点出发
        for (int j = 1;j <= n;j++)
            if (i != j)e.push_back({ i,j,(p[i].first - p[j].first) * (p[i].first - p[j].first) + (p[i].second - p[j].second) * (p[i].second - p[j].second) });
    sort(e.begin(), e.end(), [&](node a, node b) {
        return a.w > b.w;
    });///从大到小距离走
    vector<int> f(n + 1, -2e9), g(n + 1, -2e9);
    int i = 0, j = 0;
    f[0] = 0;///解锁原点
    while (i < e.size()) {
        vector<node> t;
        while (j < e.size() && e[i].w == e[j].w) t.push_back(e[j++]);///把下一个大小的边都加入
        for (auto ed : t) g[ed.v] = -2e9;///初始化
        for (auto ed : t) g[ed.v] = max(g[ed.v], f[ed.u] + 1);///更新到下一个点吃到最多的数量
        for (auto ed : t) f[ed.v] = max(g[ed.v], f[ed.v]);///滚动
        i = j;
    }
    cout << *max_element(f.begin(), f.end()) << '\n';
    return 0;
}

B

题解

知识点：二分，贪心，排序。

答案单调是可以二分的，所以优先考虑二分。发现对于一个答案要选择最便宜的去验证答案，因此每次需要对序列排序（因为排序规则和答案有关），满足关系式：

a_{v a l} + k a_{i d} < b_{v a l} + k b_{i d}

$a_{val} + ka_{id} < b_{val} + kb_{id}$

取 $k$ 个如果价值总和小于等于钱数，证明答案可行。

时间复杂度 $O(n\log^2n)$

空间复杂度 $O(n)$

代码

 #include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
int n, m;
struct node {
    ll val;
    ll id;
}a[100007];
 
bool check(int mid) {
    sort(a + 1, a + n + 1, [&](node a, node b) {
        return a.val + mid * a.id < b.val + mid * b.id;
    });
    ll sum = 0;
    for (int i = 1;i <= mid;i++) sum += a[i].val + mid * a[i].id;
    return sum <= m;
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> m;
    for (int i = 1;i <= n;i++) cin >> a[i].val, a[i].id = i;
    int l = 0, r = n;
    while (l <= r) {
        int mid = l + r >> 1;
        if (check(mid)) l = mid + 1;
        else r = mid - 1;
    }
    cout << r << '\n';
    return 0;
}

C

题解

知识点：思维。

对某位Y/N数进行分类讨论，如下列表格：

YES数/NO数	0	1	>1
0	-1	-1/0	0
1	-1/1	-1	0
>1	1	1	-1

存在四种情况能确定，两种可能确定，剩下三种不确定直接 $-1$ 。

确定的四种：

Y > 1且N = 0，不可能是错误询问，直接确定为 $1$ 。
N > 1且Y = 0，同上确定为 $0$ 。
Y > 1且N = 1，确定唯一错误询问，并确定为 $1$ 。
N > 1且Y = 1，同上确定为 $0$ 。

可能确定的两种：

Y = 1且N = 0，最终错误询问被发现时可确定为 $1$ ，否则不确定，因此将此类计数，最终判断这种情况。
N = 1且Y = 0，同上可能确定为 $0$ 。

不确定的三种：

Y = 0且N = 0，显然不确定。
Y = 1且N = 1，发现错误询问，但依然不确定。
Y > 1且N > 1，错误询问超额。

时间复杂度 $O(n)$

空间复杂度 $O(n)$

代码

 #include <bits/stdc++.h>
 
using namespace std;
 
struct bit {
    int y, n;
}a[100007];
 
bool ans[100007];
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    int x;
    string s;
    for (int i = 1;i <= 3 * n;i++) {
        cin >> x >> s;
        if (s == "YES") a[x].y++;
        else a[x].n++;
    }
    bool fault = false;
    bool ok = true;
    int cnt = 0;
    for (int i = 0;i < n;i++) {
        if (a[i].y > 1 && a[i].n == 0) ans[i] = 1;
        else if (a[i].y == 0 && a[i].n > 1) ans[i] = 0;
        else if (!fault && a[i].y > 1 && a[i].n == 1) ans[i] = 1, fault = 1;
        else if (!fault && a[i].y == 1 && a[i].n > 1) ans[i] = 0, fault = 1;
        else if (a[i].y == 1 && a[i].n == 0) ans[i] = 1, cnt++;
        else if (a[i].y == 0 && a[i].n == 1) ans[i] = 0, cnt++;
        else ok = false;
    }
    if (!ok || !fault && cnt) cout << -1;
    else for (int i = 0;i < n;i++) cout << ans[i];
    cout << '\n';
    return 0;
}

D

题解

知识点：树形dp。

题目要求，树中满足度为 $1$ 的节点的权值都相同（0/1）的连通子图个数。

因为全为 $0$ 和全为 $1$ 两种情况其实解决方法一样，所以可以同一个方法跑两次即可。

考虑度为 $1$ 的节点颜色为 $flag$ 。设 $dp[i]$ 表示为以编号 $i$ 的节点为根的子树的方案数。对于根 $u$ 及其子节点 $v_i$ ，每个子节点 $v_i$ 都有 $dp[v_i]$ 种选择方案使得以 $v_i$ 为根的子树符合条件，加上不选 $v_i$ 分支的一种，共有 $dp[v_i] + 1$ 种方案。对所有子节点 $v_i$ ，都可以独立的选和不选，所以进行乘法原理的运算，得到选择子节点 $v_i$ 的所有方案数为 $\prod (dp[v_i]+1)$ 。

但有一种情况是所有子节点都不选，只留个根。这种方案会使这个节点成为一个度为 $1$ 的点（因为是子树），颜色必须要符合 $flag$ 才可以作为一种方案。因此这种情况要特判，故 $dp[u] = \prod (dp[v_i]+1) - 1 + [a[u] == flag]$ 。

接下来是记录答案，如果 $a[u] = flag$ ，则作为一个独立的以 $u$ 为根的树（不是别的节点的子树）的所有方案和是子树的所有方案 $dp[u]$ 是等价的，因为 $u$ 无论如何都符合条件；如果 $a[u] \neq flag$ ，则作为一个独立树，当只选了一个子节点的情况是不可行的，此时根节点 $u$ 是度为 $1$ 的，与 $dp[u]$ 的情况不同（因为是子树， $u$ 只有在什么都不选的情况才会度为 $1$ ），因此要从 $dp[u]$ 中减去 $\sum dp[v_i]$ 。

值得注意的是，无论 $a[u]$ 是否同色，当其本身成为一个只有一个节点的图时，都是满足条件的。这种情况其实已经算在了 $a[u] = flag$ 中 $dp[u]$ 的一种里，不需要额外计算，否则会重复。

无根树可以以任何节点为根，因此从 $1$ 开始没什么问题。

时间复杂度 $O(n)$

空间复杂度 $O(n)$

代码

 #include <bits/stdc++.h>
 
using namespace std;
 
const int mod = 1e9 + 7;
bool a[300007];
vector<int> g[300007];
bool flag;
int dp[300007];
int ans;
 
void dfs(int u, int fa) {
    int sum = 0, mul = 1;
    for (int v : g[u]) {
        if (v == fa) continue;
        dfs(v, u);
        mul = 1LL * mul * (dp[v] + 1) % mod;///（子节点方案+不选子节点的一个方案）进行乘法原理
        sum = (0LL + sum + dp[v]) % mod;///只选了一个子节点的方案数
    }
    dp[u] = (mul - 1 + (a[u] == flag)) % mod;///mul减去一个子节点都不选的可能加上自己可能符合要求的可能
    if (a[u] == flag) ans = (0LL + ans + dp[u]) % mod;///当前节点符合要求，答案加上dp[u]即可
    else ans = (0LL + ans + dp[u] - sum + mod) % mod;///当前节点不符合要求，则不能成为度为1的节点，减去选一个子节点的所有方案
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) {
        char ch;
        cin >> ch;
        a[i] = ch - '0';
    }
    for (int i = 1;i <= n - 1;i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    flag = 1;
    dfs(1, 0);
    flag = 0;
    dfs(1, 0);
    cout << ans << '\n';
    return 0;
}

F

题解

知识点：计算几何。

纯纯的计算几何（没学过，函数都是现场造的，好难qwq。

注意到是从上往下看，因此考虑从下往上遍历，考虑每一个被上面盖住的弧长即可。

实现过程上，先考虑两个圆 $a[i]$ 被 $a[j]$ 覆盖，且是相交的情况。发现只需要用一个余弦定理计算以 $a[j]$ 半径为对边， $a[i]$ 与 $Dist_{C_i,C_j}$ 为邻边的三角形的夹角弧度 $\theta$ ，然后乘以二就是被覆盖的弧长弧度；如果两个圆相离或者后者包含于前者则弧度为 $0$ ；如果前者包含于后者，是全覆盖，弧度为 $2\pi$ 。

但事实上不止一个圆覆盖，因此要考虑重复覆盖的问题，这涉及到了区间合并，因此考虑以 $x$ 轴正半轴为基准，逆时针为正方向，形成区间 $[-\pi,\pi]$ ，同时刚好满足 atan2 函数的特性。

先计算 $\overrightarrow {C_iC_j}$ 的区间弧度 $base$ ，然后加减 $\theta$ ，得到始边弧度和终边弧度。同时要考虑始边弧度 $<-\pi$ 和终边弧度 $>\pi$ 的特判，要把一个角拆成两个角，比如 $[-1.1\pi,0.5\pi]$ 拆成 $[0.9\pi,\pi]$ 与 $[-\pi,0.5\pi]$ 。

随后按起边从小到大排序合并区间，要注意有可能该圆不被任何圆覆盖， $cnt$ 为 $0$ ，因此不能以第一个弧段为初始条件，应该以 $[-\pi-1,-\pi-1]$ 类似的为初始条件，或者以 $[\pi+1,\pi+1]$ 额外加入数组作为终止条件，顺便还可以把最后一段有效区间加上，我个人喜欢后面这种。

时间复杂度 $O(n^2)$

空间复杂度 $O(n)$

代码

 #include <bits/stdc++.h>
 
using namespace std;
 
const double pi = acos(-1.0);
 
struct Point {
    double x;
    double y;
};
 
struct Circle {
    Point A;
    double r;
}a[1007];
 
double sqr(double x) {
    return x * x;
}
 
double dist2(Point A, Point B) {
    return sqr(A.x - B.x) + sqr(A.y - B.y);
}
 
double rad(double a, double b, double c) {///余弦定理，a对边，b，c邻边
    return acos((b * b + c * c - a * a) / (2 * b * c));
}
 
double xrad(Point A, Point B) {///与x轴正方向夹角[-pi，pi]
    return atan2(A.y - B.y, A.x - B.x);///斜率y/x，且由象限决定 
}
 
struct node {
    double x;
    double y;
}xy[1007 << 1];
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++)
        cin >> a[i].A.x >> a[i].A.y >> a[i].r;
    double ans = 0;
    for (int i = 1;i <= n;i++) {
        int cnt = 0;
        for (int j = i + 1;j <= n;j++) {
            ++cnt;
            double len2 = dist2(a[i].A, a[j].A);
            if (len2 >= sqr(a[i].r + a[j].r) || sqrt(len2) <= a[i].r - a[j].r) {///相离 或 j内含于i
                xy[cnt] = { 0,0 };
                continue;
            }
            else if (sqrt(len2) <= a[j].r - a[i].r) {///i内含于j,全盖住了
                xy[cnt] = { -pi,pi };
                break;
            }
            double xita = rad(a[j].r, a[i].r, sqrt(len2));
            double base = xrad(a[j].A, a[i].A);
            xy[cnt].x = base - xita;
            xy[cnt].y = base + xita;
            if (xy[cnt].x < -pi) {///起边小于-pi那就分成[起边+2pi,pi],[-pi,终边]
                cnt++;
                xy[cnt] = { xy[cnt - 1].x + 2 * pi, pi };
                xy[cnt - 1].x = -pi;
            }
            else if (xy[cnt].y > pi) {///同上
                cnt++;
                xy[cnt] = { -pi, xy[cnt - 1].y - 2 * pi };
                xy[cnt - 1].y = pi;
            }
        }
        sort(xy + 1, xy + cnt + 1, [&](node a, node b) {
            return a.x < b.x;
        });///按起边从小到大排序，开始合并区间
        xy[++cnt] = { pi + 1,pi + 1 };///终止特殊判断，方便把最后一段有效段加上
        ans += 2 * pi * a[i].r;///先加上周长
        double lpre = -pi - 1, rmax = -pi - 1;///初始化负无穷，不能初始化第一个，因为有可能一个都没有（如果上面加了终止判断，可以不考虑这个）
        for (int j = 1;j <= cnt;j++) {///合并区间
            if (xy[j].x >= rmax) {
                ans -= (rmax - lpre) * a[i].r;///减去一个区间的周长
                lpre = xy[j].x;
            }
            rmax = max(rmax, xy[j].y);
        }
    }
    cout << fixed << setprecision(15) << ans << '\n';
    return 0;
}

G

题解

方法一

知识点：manachar。

不会qwq。

方法二

知识点：回文自动机。

模板题。不多说（因为也不会说qwq。

时间复杂度 $O(n)$

空间复杂度 $O(n)$

代码

方法一

无

方法二

 #include<bits/stdc++.h>
#define ll long long
using namespace std;
 
const int N = 5e5 + 10;
char s[N];
int n, lst, len[N];
int now, tot = 1, fail[N], cnt[N], t[N][26];
 
int getfail(int u, int p) {
    while (p - len[u] - 1 <= 0 || s[p - len[u] - 1] != s[p])	u = fail[u];
    return u;
}
 
int insert(char c, int id) {
    int p = getfail(now, id);
    if (!t[p][c - 'a']) {
        fail[++tot] = t[getfail(fail[p], id)][c - 'a'];
        t[p][c - 'a'] = tot;
        len[tot] = len[p] + 2;
        cnt[tot] = cnt[fail[tot]] + 1;
    }
    return cnt[now = t[p][c - 'a']];
}
 
ll ans[3];
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n;
    cin >> s + 1;
    fail[0] = 1, len[1] = -1;
    for (int i = 1;i <= n;i++) {
        lst = insert(s[i], i);
        if (s[i] == 'k') ans[0] += lst;
        else if (s[i] == 'f') ans[1] += lst;
        else if (s[i] == 'c') ans[2] += lst;
    }
    cout << ans[0] << ' ' << ans[1] << ' ' << ans[2] << '\n';
    return 0;
}

H

题解

知识点：数学，计算几何。

画图，求并集面积。

显然， $S_U = 2(\dfrac{n}{2})^2 + \dfrac{1}{2}\pi(\dfrac{n}{2})^2 = \dfrac{n^2}{2} + \dfrac{\pi n^2}{8}$ 。

（把union area看成交集QAQ，要被英语退役了）

时间复杂度 $O(1)$

空间复杂度 $O(1)$

代码

 #include <bits/stdc++.h>
 
using namespace std;
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    double n;
    cin >> n;
    cout << fixed << setprecision(15) << n * n / 2.0 + n * n * acos(-1.0) / 8.0 << '\n';///圆和多边形面积并集
    return 0;
}

K

题解

知识点：数学。

首先如果 $n-k<=k$ 则一定拿不到。

然后根据鸽巢原理。因为一对耳机有两个头，最坏情况是每对都只拿了一个头即 $n-k$ 个耳机，还要补上 $k+1$ 个耳机凑成 $k+1$ 对，因此一共要拿 $n+1$ 个耳机。

时间复杂度 $O(1)$

空间复杂度 $O(1)$

代码

 #include <bits/stdc++.h>
 
using namespace std;
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, k;
    cin >> n >> k;
    if (n - k <= k) {
        cout << -1 << '\n';
        return 0;
    }
    cout << n + 1 << '\n';
    return 0;
}

posted @ 2022-08-02 16:07 空白菌阅读(110) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2023牛客寒假算法基础集训营1 ACDEFGHKLM

· 2023牛客暑期多校训练营6 ABCEG

· 231028校内赛

· 图论训练记录 2025.1

· 2024牛客暑期多校训练营2

公告

昵称：空白菌
园龄： 3年2个月
粉丝： 66
关注： 15

+加关注

2025年3月

日

一

二

三

四

五

六

空白菌

蔚来杯2022牛客暑期多校训练营5 ABCDFGHK

A

题解

代码

B

题解

代码

C

题解

代码

D

题解

代码

F

题解

代码

G

题解

方法一

方法二

代码

方法一

方法二

H

题解

代码

K

题解

代码

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	#include <bits/stdc++.h>

	using namespace std;

	struct node {
	int u, v, w;
	};

	int main() {
	std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n;
	cin >> n;
	pair<int, int> p[2007];
	for (int i = 1;i <= n;i++) {
	int u, v;
	cin >> u >> v;
	p[i] = { u,v };
	}
	vector<node> e;
	for (int i = 0;i <= n;i++)///暴力连边,只从原点出发
	for (int j = 1;j <= n;j++)
	if (i != j)e.push_back({ i,j,(p[i].first - p[j].first) * (p[i].first - p[j].first) + (p[i].second - p[j].second) * (p[i].second - p[j].second) });
	sort(e.begin(), e.end(), [&](node a, node b) {
	return a.w > b.w;
	});///从大到小距离走
	vector<int> f(n + 1, -2e9), g(n + 1, -2e9);
	int i = 0, j = 0;
	f[0] = 0;///解锁原点
	while (i < e.size()) {
	vector<node> t;
	while (j < e.size() && e[i].w == e[j].w) t.push_back(e[j++]);///把下一个大小的边都加入
	for (auto ed : t) g[ed.v] = -2e9;///初始化
	for (auto ed : t) g[ed.v] = max(g[ed.v], f[ed.u] + 1);///更新到下一个点吃到最多的数量
	for (auto ed : t) f[ed.v] = max(g[ed.v], f[ed.v]);///滚动
	i = j;
	}
	cout << *max_element(f.begin(), f.end()) << '\n';
	return 0;
	}

	#include <bits/stdc++.h>
	#define ll long long

	using namespace std;

	int n, m;
	struct node {
	ll val;
	ll id;
	}a[100007];

	bool check(int mid) {
	sort(a + 1, a + n + 1, [&](node a, node b) {
	return a.val + mid * a.id < b.val + mid * b.id;
	});
	ll sum = 0;
	for (int i = 1;i <= mid;i++) sum += a[i].val + mid * a[i].id;
	return sum <= m;
	}

	int main() {
	std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	cin >> n >> m;
	for (int i = 1;i <= n;i++) cin >> a[i].val, a[i].id = i;
	int l = 0, r = n;
	while (l <= r) {
	int mid = l + r >> 1;
	if (check(mid)) l = mid + 1;
	else r = mid - 1;
	}
	cout << r << '\n';
	return 0;
	}

	#include <bits/stdc++.h>

	using namespace std;

	struct bit {
	int y, n;
	}a[100007];

	bool ans[100007];

	int main() {
	std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n;
	cin >> n;
	int x;
	string s;
	for (int i = 1;i <= 3 * n;i++) {
	cin >> x >> s;
	if (s == "YES") a[x].y++;
	else a[x].n++;
	}
	bool fault = false;
	bool ok = true;
	int cnt = 0;
	for (int i = 0;i < n;i++) {
	if (a[i].y > 1 && a[i].n == 0) ans[i] = 1;
	else if (a[i].y == 0 && a[i].n > 1) ans[i] = 0;
	else if (!fault && a[i].y > 1 && a[i].n == 1) ans[i] = 1, fault = 1;
	else if (!fault && a[i].y == 1 && a[i].n > 1) ans[i] = 0, fault = 1;
	else if (a[i].y == 1 && a[i].n == 0) ans[i] = 1, cnt++;
	else if (a[i].y == 0 && a[i].n == 1) ans[i] = 0, cnt++;
	else ok = false;
	}
	if (!ok \|\| !fault && cnt) cout << -1;
	else for (int i = 0;i < n;i++) cout << ans[i];
	cout << '\n';
	return 0;
	}

	#include <bits/stdc++.h>

	using namespace std;

	const int mod = 1e9 + 7;
	bool a[300007];
	vector<int> g[300007];
	bool flag;
	int dp[300007];
	int ans;

	void dfs(int u, int fa) {
	int sum = 0, mul = 1;
	for (int v : g[u]) {
	if (v == fa) continue;
	dfs(v, u);
	mul = 1LL * mul * (dp[v] + 1) % mod;///（子节点方案+不选子节点的一个方案）进行乘法原理
	sum = (0LL + sum + dp[v]) % mod;///只选了一个子节点的方案数
	}
	dp[u] = (mul - 1 + (a[u] == flag)) % mod;///mul减去一个子节点都不选的可能加上自己可能符合要求的可能
	if (a[u] == flag) ans = (0LL + ans + dp[u]) % mod;///当前节点符合要求，答案加上dp[u]即可
	else ans = (0LL + ans + dp[u] - sum + mod) % mod;///当前节点不符合要求，则不能成为度为1的节点，减去选一个子节点的所有方案
	}

	int main() {
	std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n;
	cin >> n;
	for (int i = 1;i <= n;i++) {
	char ch;
	cin >> ch;
	a[i] = ch - '0';
	}
	for (int i = 1;i <= n - 1;i++) {
	int u, v;
	cin >> u >> v;
	g[u].push_back(v);
	g[v].push_back(u);
	}
	flag = 1;
	dfs(1, 0);
	flag = 0;
	dfs(1, 0);
	cout << ans << '\n';
	return 0;
	}

	#include <bits/stdc++.h>

	using namespace std;

	const double pi = acos(-1.0);

	struct Point {
	double x;
	double y;
	};

	struct Circle {
	Point A;
	double r;
	}a[1007];

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

	double dist2(Point A, Point B) {
	return sqr(A.x - B.x) + sqr(A.y - B.y);
	}

	double rad(double a, double b, double c) {///余弦定理，a对边，b，c邻边
	return acos((b * b + c * c - a * a) / (2 * b * c));
	}

	double xrad(Point A, Point B) {///与x轴正方向夹角[-pi，pi]
	return atan2(A.y - B.y, A.x - B.x);///斜率y/x，且由象限决定
	}

	struct node {
	double x;
	double y;
	}xy[1007 << 1];

	int main() {
	std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n;
	cin >> n;
	for (int i = 1;i <= n;i++)
	cin >> a[i].A.x >> a[i].A.y >> a[i].r;
	double ans = 0;
	for (int i = 1;i <= n;i++) {
	int cnt = 0;
	for (int j = i + 1;j <= n;j++) {
	++cnt;
	double len2 = dist2(a[i].A, a[j].A);
	if (len2 >= sqr(a[i].r + a[j].r) \|\| sqrt(len2) <= a[i].r - a[j].r) {///相离或 j内含于i
	xy[cnt] = { 0,0 };
	continue;
	}
	else if (sqrt(len2) <= a[j].r - a[i].r) {///i内含于j,全盖住了
	xy[cnt] = { -pi,pi };
	break;
	}
	double xita = rad(a[j].r, a[i].r, sqrt(len2));
	double base = xrad(a[j].A, a[i].A);
	xy[cnt].x = base - xita;
	xy[cnt].y = base + xita;
	if (xy[cnt].x < -pi) {///起边小于-pi那就分成[起边+2pi,pi],[-pi,终边]
	cnt++;
	xy[cnt] = { xy[cnt - 1].x + 2 * pi, pi };
	xy[cnt - 1].x = -pi;
	}
	else if (xy[cnt].y > pi) {///同上
	cnt++;
	xy[cnt] = { -pi, xy[cnt - 1].y - 2 * pi };
	xy[cnt - 1].y = pi;
	}
	}
	sort(xy + 1, xy + cnt + 1, [&](node a, node b) {
	return a.x < b.x;
	});///按起边从小到大排序，开始合并区间
	xy[++cnt] = { pi + 1,pi + 1 };///终止特殊判断，方便把最后一段有效段加上
	ans += 2 * pi * a[i].r;///先加上周长
	double lpre = -pi - 1, rmax = -pi - 1;///初始化负无穷，不能初始化第一个，因为有可能一个都没有（如果上面加了终止判断，可以不考虑这个）
	for (int j = 1;j <= cnt;j++) {///合并区间
	if (xy[j].x >= rmax) {
	ans -= (rmax - lpre) * a[i].r;///减去一个区间的周长
	lpre = xy[j].x;
	}
	rmax = max(rmax, xy[j].y);
	}
	}
	cout << fixed << setprecision(15) << ans << '\n';
	return 0;
	}

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

	const int N = 5e5 + 10;
	char s[N];
	int n, lst, len[N];
	int now, tot = 1, fail[N], cnt[N], t[N][26];

	int getfail(int u, int p) {
	while (p - len[u] - 1 <= 0 \|\| s[p - len[u] - 1] != s[p]) u = fail[u];
	return u;
	}

	int insert(char c, int id) {
	int p = getfail(now, id);
	if (!t[p][c - 'a']) {
	fail[++tot] = t[getfail(fail[p], id)][c - 'a'];
	t[p][c - 'a'] = tot;
	len[tot] = len[p] + 2;
	cnt[tot] = cnt[fail[tot]] + 1;
	}
	return cnt[now = t[p][c - 'a']];
	}

	ll ans[3];

	int main() {
	std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	cin >> n;
	cin >> s + 1;
	fail[0] = 1, len[1] = -1;
	for (int i = 1;i <= n;i++) {
	lst = insert(s[i], i);
	if (s[i] == 'k') ans[0] += lst;
	else if (s[i] == 'f') ans[1] += lst;
	else if (s[i] == 'c') ans[2] += lst;
	}
	cout << ans[0] << ' ' << ans[1] << ' ' << ans[2] << '\n';
	return 0;
	}