Home » 国际竞赛 » Details

USACO 2020 February Contest, Platinum Problem 3. Help Yourself

Category: 国际竞赛, 计算机国际竞赛 Date: 2022年7月4日下午2:45

USACO 2020 February Contest, Platinum Problem 3. Help Yourself

Bessie has been given $N$ ( $1 \leq N \leq 10^{5}$ ) segments on a 1D number line. The $i$ th segment contains all reals $x$ such that $l_{i} \leq x \leq r_{i}$ .

Define the union of a set of segments to be the set of all $x$ that are contained within at least one segment. Define the complexity of a set of segments to be the number of connected regions represented in its union, raised to the power of $K$ ( $2 \leq K \leq 10$ ).

Bessie wants to compute the sum of the complexities over all $2^{N}$ subsets of the given set of $N$ segments, modulo $10^{9} + 7$ .

Normally, your job is to help Bessie. But this time, you are Bessie, and there is no one to help you. Help yourself!

SCORING

Test case 2 satisfies $N \leq 16$ .
Test cases 3-5 satisfy $N \leq 1000$ , $K = 2$ .
Test cases 6-8 satisfy $N \leq 1000$ .
For each $T \in [9, 16],$ test case $T$ satisfies $K = 3 + (T - 9)$ .

INPUT FORMAT (file help.in):

The first line contains $N$ and $K$ .Each of the next $N$ lines contains two integers $l_{i}$ and $r_{i}$ . It is guaranteed that $l_{i} < r_{i}$ and all $l_{i}, r_{i}$ are distinct integers in the range $1 \dots 2 N .$

OUTPUT FORMAT (file help.out):

Output the answer, modulo $10^{9} + 7$ .

SAMPLE INPUT:

SAMPLE OUTPUT:

The complexity of each nonempty subset is written below.

{[1, 6]} ⟹ 1, {[2, 3]} ⟹ 1, {[4, 5]} ⟹ 1

{[1, 6], [2, 3]} ⟹ 1, {[1, 6], [4, 5]} ⟹ 1, {[2, 3], [4, 5]} ⟹ 4

{[1, 6], [2, 3], [4, 5]} ⟹ 1

The answer is $1 + 1 + 1 + 1 + 1 + 4 + 1 = 10$ .

Problem credits: Benjamin Qi

USACO 2020 February Contest, Platinum Problem 3. Help Yourself 题解(翰林国际教育提供，仅供参考)

题解请注册或登录查看

[/hide]

(Analysis by Benjamin Qi)

Sort the segments by left coordinate, and try placing the segments into a subset in this order. The only information we need to store about the collection of segments that are members of the subset is the rightmost coordinate in this collection.

For each $0 \leq i \leq 2 N$ , $d p [i]$ will store information about collections with rightmost coordinate $i$ . Suppose that collection $c$ contains exactly $a_{c}$ segments in this union. Then for each $0 \leq j \leq K$ we'll store

d p [i] [j] = \sum c a j c .

So $d p [i] [0]$ stores the number of collections with rightmost coordinate $i$ , $d p [i] [1]$ stores the sum of the number of segments in the union of each collection with rightmost coordinate $i$ , and so on.

If we add a segment $[l, r]$ to a collection $c$ with rightmost coordinate $i$ ,

If $i < l$ then $a_{c}$ increases by one and the rightmost coordinate becomes $r$ .
Otherwise if $i < r$ then $a_{c}$ remains unchanged and the rightmost coordinate becomes $r$ .
Otherwise $a_{c}$ and the rightmost coordinate remain unchanged.

To account for case 1, we need to find the updated value of $d p [i]$ after adding one to each $a_{c}$ . Call the result $a d v (d p [i]) .$ By the binomial theorem,

a d v (d p [i]) [j] = \sum c (a c + 1) j = \sum k = 0 j (j k) a k c = \sum k = 0 j (j k) d p [i] [k] .

This update can be performed in $O (K^{2})$ time, giving a DP solution that runs in $O (N^{2} K^{2})$ or $O (N^{2} + N K^{2})$ time.

To receive full credit, use a lazy segment tree that supports point updates, range sum queries, and range multiplication updates.

For case 1, add $a d v (\sum_{i = 0}^{l - 1} d p [i])$ to $d p [r]$ .
For case 2, add $\sum_{i = l}^{r - 1} d p [i]$ to $d p [r]$ .
For case 3, multiply $d p [i]$ by two for each $i > r$ .

After the above operations are performed for each segment, the final answer will be $\sum_{i = 0}^{2 N} d p [i] [K]$ . This can be done in $O (N K^{2} + N K \log N)$ time; the first term is for calculating $a d v ()$ and the second is for the range updates and queries. (In fact, it's possible to remove the $N K^{2}$ term, but I won't describe the method here.)

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

typedef long long ll;
#define f first
#define s second

const int MOD = 1e9+7; 

void setIO(string s) {
  ios_base::sync_with_stdio(0); cin.tie(0); 
  freopen((s+".in").c_str(),"r",stdin);
  freopen((s+".out").c_str(),"w",stdout);
}
 
struct mi {
  int v; explicit operator int() const { return v; }
  mi(ll _v) : v(_v%MOD) { v += (v<0)*MOD; }
  mi() : mi(0) {}
};
mi operator+(mi a, mi b) { return mi(a.v+b.v); }
mi operator-(mi a, mi b) { return mi(a.v-b.v); }
mi operator*(mi a, mi b) { return mi((ll)a.v*b.v); }
 
vector<pair<int,int>> v;
mi res;
int N,K;

typedef array<mi,11> T;
mi cum[11][11];
 
T adv(T p) {
  for (int i = K; i >= 0; --i) for (int j = i; j <= K; ++j)
    cum[i][j] = (i == j ? p[i] : cum[i][j-1]+cum[i+1][j]);
  T res; for (int i = 0; i <= K; ++i) res[i] = cum[0][i];
  return res;
}
 
T seg[1<<18];
mi lazy[1<<18];
 
vector<int> y = {0};
 
void push(int ind, int L, int R) {
  if (lazy[ind].v == 1) return;
  for (int i = 0; i <= K; ++i) seg[ind][i] = seg[ind][i]*lazy[ind];
  if (L != R) {
    lazy[2*ind] = lazy[2*ind]*lazy[ind];
    lazy[2*ind+1] = lazy[2*ind+1]*lazy[ind];
  }
  lazy[ind] = 1;
}
 
void mul(int pos, int ind, int L, int R) {
  push(ind,L,R);
  if (pos > R) return;
  if (pos <= L) {
    lazy[ind] = 2;
    push(ind,L,R);
    return;
  }
  int M = (L+R)/2;
  mul(pos,2*ind,L,M); mul(pos,2*ind+1,M+1,R);
  for (int i = 0; i <= K; ++i) seg[ind][i] = seg[2*ind][i]+seg[2*ind+1][i];
}
 
void upd(int pos, const T& val, int ind, int L, int R) {
  push(ind,L,R);
  if (pos < L || pos > R) return;
  for (int i = 0; i <= K; ++i) seg[ind][i] = seg[ind][i]+val[i];
  if (L == R) return;
  int M = (L+R)/2;
  if (pos <= M) upd(pos,val,2*ind,L,M);
  else upd(pos,val,2*ind+1,M+1,R);
}
 
void query(int lo, int hi, T& t, int ind, int L, int R) {
  push(ind,L,R);
  if (hi < L || lo > R) return;
  if (lo <= L && R <= hi) { 
    for (int i = 0; i <= K; ++i) t[i] = t[i]+seg[ind][i]; 
    return; 
  }
  int M = (L+R)/2;
  query(lo,hi,t,2*ind,L,M); query(lo,hi,t,2*ind+1,M+1,R);
}
 
void ad(int a, int b) {
  auto i1 = lower_bound(begin(y),end(y),a)-begin(y)-1;
  auto i2 = lower_bound(begin(y),end(y),b)-begin(y);
  T A = T(); query(0,i1,A,1,0,N); A = adv(A);
  T B = T(); query(i1+1,i2,B,1,0,N); 
  for (int i = 0; i <= K; ++i) A[i] = A[i]+B[i];
  upd(i2,A,1,0,N);
  mul(i2+1,1,0,N);
}
 
int main() {
  setIO("help");
  for (int i = 1; i < (1<<18); ++i) lazy[i] = 1;
  cin >> N >> K; v.resize(N); 
  for (auto& t: v) {
    cin >> t.f >> t.s;
    y.push_back(t.s);
  }
  sort(begin(v),end(v)); sort(begin(y),end(y));
  T ori = T(); ori[0] = 1;
  upd(0,ori,1,0,N);
  for (auto t: v) ad(t.f,t.s);
  T res = T(); query(0,N,res,1,0,N);
  cout << res[K].v << "\n";
}

[/hide]