首先要发现一个性质：如果一些线段有交集，那么交集一定是条线段，并且一定有其中一条线段的左端点是交集的左端点。
所以方案可以转化为求其中一条线段的左端点是交集的左端点的方案数。
这启发我们枚举每个点作为交集的左端点，计算至少有一条线段的左端点是这个点的方案数。如果此时经过这个点的线段数是 \(p\)，以这个点作为左端点的线段数是 \(s\)，方案数即为 \(\binom{p}{k}-\binom{p-s}{k}\)。
不会重复的原因：因为每个交集都只有一个左端点，所以我们枚举左端点，每个方案只会被计算一次贡献。
离散化一下，枚举每个点计算贡献即可。
#include <bits/stdc++.h>
typedef long long ll;
ll read() {
ll x = 0, f = 1;
char c = getchar();
while(!isdigit(c)) {
if(c == '-') f = -1;
c = getchar();
}
while(isdigit(c)) {
x = (x << 3) + (x << 1) + (c - '0');
c = getchar();
}
return x * f;
}
ll n, k, tot, mod = 998244353, ans, now;
ll a[600010], l[300010], r[300010], cntl[600010], cntr[600010], inv[300010], fac[300010];
ll qpow(ll a, ll b) {
ll ret = 1;
while(b) {
if(b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
void init(int t) {
fac[0] = 1;
for(int i = 1; i <= t; i++) {
fac[i] = fac[i - 1] * i % mod;
}
inv[t] = qpow(fac[t], mod - 2);
for(int i = t - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
ll C(ll m, ll n) {
if(m < n || m < 0 || n < 0) return 0;
return fac[m] * inv[n] % mod * inv[m - n] % mod;
}
void Solve() {
n = read(), k = read();
init(300000);
for(int i = 1; i <= n; i++) {
l[i] = read(), r[i] = read();
a[++tot] = l[i], a[++tot] = r[i];
}
std::sort(a + 1, a + tot + 1);
int len = std::unique(a + 1, a + tot + 1) - a - 1;
for(int i = 1; i <= n; i++) {
l[i] = std::lower_bound(a + 1, a + len + 1, l[i]) - a;
r[i] = std::lower_bound(a + 1, a + len + 1, r[i]) - a;
cntl[l[i]]++, cntr[r[i] + 1]++;
}
for(int i = 1; i <= tot; i++) {
now += cntl[i] - cntr[i];
ans = (ans + C(now, k) - C(now - cntl[i], k) + mod) % mod;
}
std::cout << ans << "\n";
}
int main() {
Solve();
return 0;
}
102012G Rikka with Intersections of Paths
求树上选 \(k\) 条路径至少有一个共同交点的方案数。
考虑转化，我们需要一个性质：如果树上两条路径有公共点，那么其中一定有一个公共点是某一条路径的两个端点的 \(lca\)。
所以我们转化为枚举公共点计算贡献。求经过公共点的路径中至少有 \(1\) 条路径的 \(lca\) 是公共点的方案数。发现这题求的形式和几乎一样，如果此时经过这个点的路径数是 \(p\)，以这个点作为 \(lca\) 的路径数是 \(s\)，方案数即为 \(\binom{p}{k}-\binom{p-s}{k}\)。
为什么这样不会重复？因为我们枚举的公共点是其中一条路径的 \(lca\)，而其他路径的 \(lca\) 的深度一定都小于等于公共点（不然不可能经过公共点），也就是此时这个点是方案中深度最深的公共点，每个方案都有且只有一个最深公共点，所以每个方案只会被计算一次。
\(p\) 直接树上差分，\(s\) 不用说了。最后计算枚举点贡献即可。
#include <bits/stdc++.h>
typedef long long ll;
int read() {
int x = 0, f = 1;
char c = getchar();
while(!isdigit(c)) {
if(c == '-') f = -1;
c = getchar();
}
while(isdigit(c)) {
x = (x << 3) + (x << 1) + (c - '0');
c = getchar();
}
return x * f;
}
int t, n, m, k, cnt, mod = 1000000007;
ll ans, fac[300010], inv[300010];
int h[300010], dep[300010], anc[300010][22];
int w[300010], w2[300010];
struct node{
int to, nxt;
} e[600010];
void add(int u, int v) {
e[++cnt].to = v;
e[cnt].nxt = h[u];
h[u] = cnt;
}
void dfs(int u, int fa) {
for(int i = h[u]; i; i = e[i].nxt) {
int v = e[i].to;
if(v == fa) continue;
dep[v] = dep[u] + 1;
anc[v][0] = u;
dfs(v, u);
}
}
void dfs2(int u, int fa) {
for(int i = h[u]; i; i = e[i].nxt) {
int v = e[i].to;
if(v == fa) continue;
dfs2(v, u);
w[u] += w[v];
}
}
ll qpow(ll a, ll b) {
ll ret = 1;
while(b) {
if(b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
void init() {
for(int j = 1; j <= 19; j++) {
for(int i = 1; i <= n; i++) {
anc[i][j] = anc[anc[i][j - 1]][j - 1];
}
}
}
void setup(int cnt) {
fac[0] = 1;
for(int i = 1; i <= cnt; i++) {
fac[i] = fac[i - 1] * i % mod;
}
inv[cnt] = qpow(fac[cnt], mod - 2);
for(int i = cnt - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
int lca(int u, int v) {
if(dep[u] < dep[v]) std::swap(u, v);
for(int i = 19; i >= 0; i--) if(dep[anc[u][i]] >= dep[v]) u = anc[u][i];
if(u == v) return u;
for(int i = 19; i >= 0; i--) if(anc[u][i] != anc[v][i]) u = anc[u][i], v = anc[v][i];
return anc[u][0];
}
ll C(ll m, ll n) {
if(m < n || m < 0 || n < 0) return 0;
return fac[m] * inv[n] % mod * inv[m - n] % mod;
}
void Solve() {
cnt = 0;
memset(h, 0, sizeof(h));
memset(w, 0, sizeof(w));
memset(w2, 0, sizeof(w2));
n = read(), m = read(), k = read();
for(int i = 1; i < n; i++) {
int u = read(), v = read();
add(u, v), add(v, u);
}
dep[1] = 1;
dfs(1, 0);
init();
for(int i = 1; i <= m; i++) {
int u = read(), v = read();
int rt = lca(u, v);
w[u]++, w[v]++, w[rt]--, w[anc[rt][0]]--;
w2[rt]++;
}
dfs2(1, 0);
ans = 0;
for(int i = 1; i <= n; i++) {
// std::cout << w[i] << " " << w2[i] << "\n";
ans = (ans + C(w[i], k) - C(w[i] - w2[i], k) + mod) % mod;
}
std::cout << ans << "\n";
}
int main() {
setup(300000);
t = read();
while(t--) {
Solve();
}
return 0;
}