Atcoder Beginner Contest 259 (D, E, F)

D - Circumference

在直角坐标系下有 $N$ 个圆， 给定每个圆的圆心坐标 $(x_i, y_i)$ 和 半径 $r$， 判断是否能从起点 $(s_x, s_y)$ 到 终点 $(t_x, t_y)$ 你只能沿着圆弧走

$1\le N \le 3000$ $-10^9 \le x_i,y_i \le 10 ^9$ $1 \le r_i \le 10^9$

保证起点和终点在给定的圆内。

记两圆圆心距离为 $dis$

判断每两个圆是否相交，即 $r_i+r_j \le dis \quad abs(r_i-r_j) \ge dis$

防止精度误差，两边都平方即可 如果相交就连边。跑一遍 bfs 即可。

#include <bits/stdc++.h>
#define int long long
using namespace std;
typedef long long ll;
const int N = 3010;

struct node {
    int x, y, r;
}q[N];

vector<int> g[N];

int dis(int x1, int y1, int x2, int y2) {
    return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
int vis[N];

void solve() {
    int n;
    cin >> n;
    int xs, ys, tx, ty;
    cin >> xs >> ys >> tx >> ty;
    int st, ed;
    for (int i = 1; i <= n; i++) {
        cin >> q[i].x >> q[i].y >> q[i].r;
        if (dis(xs, ys, q[i].x, q[i].y) == q[i].r * q[i].r) st = i;
        if (dis(tx, ty, q[i].x, q[i].y) == q[i].r * q[i].r) ed = i;
    }
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (dis(q[i].x, q[i].y, q[j].x, q[j].y) >= (q[i].r - q[j].r) * (q[i].r - q[j].r) && 
            dis(q[i].x, q[i].y, q[j].x, q[j].y) <= (q[i].r + q[j].r) * (q[i].r + q[j].r)) {
                g[i].push_back(j);
                g[j].push_back(i);
            }
        }
    }
    memset(vis, -1, sizeof(vis));
    queue<int> q;
    q.push(st);
    vis[st] = 0;
    while (q.size()) {
        int u = q.front();
        q.pop();
        for (auto v : g[u]) {
            if (vis[v] == -1) {
                vis[v] = vis[u] + 1;
                q.push(v);
            }
        }
    }
    if (vis[ed] == -1) {
        cout << "No\n";
    } else {
        cout << "Yes\n";
    }

}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t = 1;
    while (t--) {
        solve();
    }

    return 0;
}

E - LCM on Whiteboard

给定 $N$ 个正整数 $a_1, a_2,...a_N$， 给定 $a_i$ 的形式为， $a_i = p_{i,1}^{e{i,1}} \times ... \times p_{i,m_i} ^ {e_i,m_i}$ ， 即给定 $m$ 组 $p, e$ 保证 $p$ 为素数。

现在要把 $N$ 个数中选择一个数替换为1， 定义 $val$ 为 $N$ 个数的最小公倍数。问 $val$ 有多少可能的值。

考虑一个数变成1会不会对最终的最小公倍数有影响，如果这个数某个质因子出现的次数等于出现次数的最大值，并且最大值只有他自己，那么这个数变成1则会影响最小公倍数，否则最小公倍数不变。用 map 记录一下即可。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 2e5 + 10;
vector<PII> g[N];

void solve() {
	int n;
	cin >> n;
	map<int, int> mp, mp2;
	for (int i = 1; i <= n; i++) {
		int k;
		cin >> k;
		for (int j = 1; j <= k; j++) {
			int a, b;
			cin >> a >> b;
			g[i].push_back({a, b});
			mp[a] = max(mp[a], b);
		}
	}
	for (int i = 1; i <= n; i++) {
		for (auto x : g[i]) {
			int p = x.first, cnt = x.second;
			if (cnt == mp[p]) mp2[p]++;
		}
 	}
	int ans = 0, tag = 0;
	for (int i = 1; i <= n; i++) {
		bool flg = 0;
		for (auto x : g[i]) {
			int p = x.first, cnt = x.second;
			if (mp[p] == cnt && mp2[p] == 1) {
				flg = 1;
				break;
			}
		}
		if (flg) ans++;
		else tag = 1;
	}
	cout << ans + tag << "\n";
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int t = 1;
	while (t--) {
		solve();
	}
	return 0;
}

F - Select Edges

给定一个 $N$ 个点的树，每条边有边权（$10^9\le w \le 10^9$） 对于每个点来说，最多选择 $d_i$ 条顶点有 $i$ 的边。

选择一些边，使得边权和最大。

$2\le N \le 3 \times 10^5$ $d_i \ge 0$

考虑树形DP， $dp[i][0]$ 代表以 $i$ 为根的子树不向父亲连边的最大边权和，$dp[i][1]$ 代表以 $i$ 为根的子树向父亲连边的最大边权和。计算 $dp[i][1]$ 时，考虑向儿子最多连 $d[i] - 1$ 条边。

求最大的 $d_i$ 或者 $d_i-1$ 条边，每次排序一下就行。

转移：$dp[i][0]$ = $\sum dp[son][0] + \sum _ 1 ^ {d_i}(dp[son][1] - dp[son][0] + w)$

​ $dp[i][1] = \sum dp[son][0] + \sum _ 1 ^ {d_i-1}(dp[son][1] - dp[son][0] + w)$

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 3e5 + 10;
vector<PII> g[N];
int d[N];
ll dp[N][2];

void dfs(int u, int f) {
    ll sum = 0;
    vector<ll> v;
    for (auto x : g[u]) {
        if (x.first == f) continue;
        dfs(x.first, u);
        sum += dp[x.first][0];
        v.push_back(dp[x.first][1] + x.second - dp[x.first][0]);
    }
    sort(v.begin(), v.end());
    reverse(v.begin(), v.end());
    if (d[u] == 0) {
        dp[u][0] = sum;
        dp[u][1] = -1e18;
    } else {
        dp[u][0] = dp[u][1] = sum;
        for (int i = 0; i < v.size(); i++) {
            if (v[i] <= 0) break;
            if (i < d[u]) dp[u][0] += v[i];
            if (i < d[u] - 1) dp[u][1] += v[i];
        }
    }

}

void solve() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> d[i];
    for (int i = 1; i < n; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a].push_back({b, c});
        g[b].push_back({a, c});
    }
    dfs(1, -1);
    cout << dp[1][0] << "\n";
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t = 1;
    while (t--) {
        solve();
    }
    return 0;
}