题号 标题 已通过代码 题解/讨论 通过率 团队的状态
A All-one Matrices 点击查看 单调栈+前缀和 326/2017  通过
B Beauty Values 点击查看 进入讨论 827/1995  通过
C CDMA 点击查看 进入讨论 669/1115  通过
D Distance 点击查看 理性暴力 37/554 OK
E Explorer 点击查看 可修改并查集，LCT 83/920 OK
F Flower Dance 点击查看 进入讨论 13/121 未通过
G Gemstones 点击查看 进入讨论 883/2062  通过
H How Many Schemes 点击查看 进入讨论 3/61 未通过
I Inner World 点击查看 dfs序，矩形面积 17/94 OK
J Just Jump 点击查看 DP，容斥 85/532 OK
 

A - All-one Matrices

题意：

给定一个n × m的 01矩阵，输出极大全1子矩阵的个数。

思路：

先搞出每个点向下能走的距离。

利用单调栈维护每个点最左能到达的值，由于有相同的情况，所以要跑两次单调栈，

第一次求出每个点最左能到的地方。

第二次要弹栈的，判断是否能作为子矩阵的最上层，计入答案。

  1. // #pragma GCC optimize(2)
  2. // #pragma GCC optimize(3)
  3. // #pragma GCC optimize(4)
  4. #include <algorithm>
  5. #include  <iterator>
  6. #include  <iostream>
  7. #include   <cstring>
  8. #include   <cstdlib>
  9. #include   <iomanip>
  10. #include    <bitset>
  11. #include    <cctype>
  12. #include    <cstdio>
  13. #include    <string>
  14. #include    <vector>
  15. #include     <stack>
  16. #include     <cmath>
  17. #include     <queue>
  18. #include      <list>
  19. #include       <map>
  20. #include       <set>
  21. #include   <cassert>
  22. // #include<bits/extc++.h>
  23. // using namespace __gnu_pbds;
  24. using namespace std;
  25. #define pb push_back
  26. #define fi first
  27. #define se second
  28. #define debug(x) cerr<<#x << " := " << x << endl;
  29. #define bug cerr<<"-----------------------"<<endl;
  30. #define FOR(a, b, c) for(int a = b; a <= c; ++ a)
  31.  
  32. typedef long long ll;
  33. typedef long double ld;
  34. typedef pair<int, int> pii;
  35. typedef pair<ll, ll> pll;
  36.  
  37. const int inf = 0x3f3f3f3f;
  38. const ll inff = 0x3f3f3f3f3f3f3f3f;
  39. const int mod = 1e9+;
  40.  
  41. template<typename T>
  42. inline T read(T&x){
  43.     x=;int f=;char ch=getchar();
  44.     while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();
  45.     while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();
  46.     return x=f?-x:x;
  47. }
  48.  
  49. /**********showtime************/
  50.  
  51.             const int maxn = ;
  52.             char str[maxn][maxn];
  53.             int sum[maxn][maxn];
  54.             int dp[maxn][maxn];
  55.             int ls[maxn];
  56.             stack<pii>st;
  57. int main(){
  58.             int n,m;
  59.             scanf("%d%d", &n, &m);
  60.             for(int i=; i<=n; i++) scanf("%s", str[i] + );
  61.             for(int i=; i<=n; i++) {
  62.                 for(int j=; j<=m; j++) {
  63.                     sum[i][j] = sum[i][j-];
  64.                     if(str[i][j] == '') sum[i][j] ++;
  65.                 }
  66.             }
  67.  
  68.             for(int i=n; i>=; i--) {
  69.                 for(int j=; j<=m; j++) {
  70.                     if(str[i][j] == '') dp[i][j] = dp[i+][j] + ;
  71.                     else dp[i][j] = ;
  72.                 }
  73.             }
  74.  
  75.             int ans = ;
  76.             for(int i=; i<=n; i++) {
  77. //                debug(i);
  78.                 while(!st.empty()) st.pop();
  79.                 st.push(pii(-, ));
  80.                 for(int j=; j<=m; j++) {
  81.                         while(!st.empty() && st.top().fi >= dp[i][j]) {
  82.                             st.pop();
  83.                         }
  84.                         ls[j] = st.top().se + ;
  85.                         st.push(pii(dp[i][j], j));
  86.                 }
  87.                 while(!st.empty()) st.pop();
  88.                  for(int j=; j<=m + ; j++) {
  89.                     while(!st.empty() && st.top().fi > dp[i][j]) {
  90.                         int le = ls[st.top().se], ri = j - ;
  91.                         st.pop();
  92.                         if(sum[i-][ri] - sum[i-][le-] == ri - le + ) continue;
  93.                         ans++;
  94.                     }
  95.                     if(j < m +  && (st.empty() || dp[i][j] > st.top().fi) )st.push(pii(dp[i][j], j));
  96.                 }
  97.  
  98.             }
  99.             printf("%d\n", ans);
  100.             return ;
  101. }
  102. /*
  103. 5 5
  104. 11111
  105. 11110
  106. 11100
  107. 11100
  108. 10000
  109. 3 6
  110. 001000
  111. 011011
  112. 010011
  113.  
  114. */

D-Distance

思路

考虑非情况，如果点数不多，就枚举点数，如果点数很多，就把这么多点的影响通过bfs记录下来。

  1. /*
  2. * @Author: chenkexing
  3. * @Date:   2019-08-11 21:48:52
  4. * @Last Modified by:   chenkexing
  5. * @Last Modified time: 2019-08-11 23:23:57
  6. */
  7.  
  8. // #pragma GCC optimize(2)
  9. // #pragma GCC optimize(3)
  10. // #pragma GCC optimize(4)
  11. #include <algorithm>
  12. #include  <iterator>
  13. #include  <iostream>
  14. #include   <cstring>
  15. #include   <cstdlib>
  16. #include   <iomanip>
  17. #include    <bitset>
  18. #include    <cctype>
  19. #include    <cstdio>
  20. #include    <string>
  21. #include    <vector>
  22. #include     <stack>
  23. #include     <cmath>
  24. #include     <queue>
  25. #include      <list>
  26. #include       <map>
  27. #include       <set>
  28. #include   <cassert>
  29. // #include<bits/extc++.h>
  30. // using namespace __gnu_pbds;
  31. using namespace std;
  32. #define pb push_back
  33. #define fi first
  34. #define se second
  35. #define debug(x) cerr<<#x << " := " << x << endl;
  36. #define bug cerr<<"-----------------------"<<endl;
  37. #define FOR(a, b, c) for(int a = b; a <= c; ++ a)
  38.  
  39. typedef long long ll;
  40. typedef long double ld;
  41. typedef pair<int, int> pii;
  42. typedef pair<int, pii> p3;
  43. typedef pair<ll, ll> pll;
  44.  
  45. const int inf = 0x3f3f3f3f;
  46. const ll inff = 0x3f3f3f3f3f3f3f3f;
  47. const int mod = 1e9+;
  48.  
  49. template<typename T>
  50. inline T read(T&x){
  51.     x=;int f=;char ch=getchar();
  52.     while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();
  53.     while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();
  54.     return x=f?-x:x;
  55. }
  56.  
  57. /**********showtime************/
  58.  
  59.             const int maxn = 1e5+;
  60.             int n,m,h,q;
  61.             int getid(int x, int y, int z) {
  62.                 return (z - )* (n * m) + (x-)*m + y;
  63.             }
  64.             vector<int>vx,vy,vz;
  65.             int dis[maxn];
  66.             int xia[][] = {{,,},{,,},{,,}, {-,  , }, {, - , }, {,  ,- }};
  67.             void rebuild(){
  68.                 queue< p3>que;
  69.                 for(int i=; i<vx.size(); i++) {
  70.                         int nx = vx[i];
  71.                         int ny = vy[i];
  72.                         int nz = vz[i];
  73.                         dis[getid(nx, ny, nz)] = ;
  74.                         que.push(p3(nx, pii(ny, nz)));
  75.                 }
  76.                 vx.clear();
  77.                 vy.clear();
  78.                 vz.clear();
  79.                 while(!que.empty()) {
  80.                     p3 tmp = que.front(); que.pop();
  81.                     int x = tmp.fi;
  82.                     int y = tmp.se.fi;
  83.                     int z = tmp.se.se;
  84.                     for(int i=; i<; i++) {
  85.                         int nx = x + xia[i][];
  86.                         int ny = y + xia[i][];
  87.                         int nz = z + xia[i][];
  88.                         if(nx <=  || nx > n || ny <= || ny > m || nz <=  || nz > h) continue;
  89.                         if(dis[getid(nx, ny, nz)] > dis[getid(x, y, z)] + ) {
  90.                             dis[getid(nx, ny, nz)] = dis[getid(x, y, z)] + ;
  91.                             que.push(p3(nx, pii(ny, nz)));
  92.                         }
  93.                     }
  94.                 }
  95.  
  96.             }
  97. int main(){
  98.             scanf("%d%d%d%d", &n, &m, &h, &q);
  99.             int E = sqrt(n * m * h) + ;
  100.             memset(dis, inf, sizeof(dis));
  101.  
  102.             while(q--) {
  103.                 int op, x, y, z;
  104.                 scanf("%d%d%d%d", &op, &x, &y, &z);
  105.                 if(op == ) {
  106.                     vx.pb(x);
  107.                     vy.pb(y);
  108.                     vz.pb(z);
  109.                 }
  110.                 else {
  111.                     int ans = dis[getid(x, y, z)];
  112.                     for(int i=; i<vx.size(); i++) {
  113.                         int nx = vx[i];
  114.                         int ny = vy[i];
  115.                         int nz = vz[i];
  116.                         ans = min(ans, abs(nx - x) + abs(ny - y) + abs(nz - z));
  117.                     }
  118.                     printf("%d\n", ans);
  119.                 }
  120.                 if(vx.size() >= E) rebuild();
  121.             }
  122.             return ;
  123. }

E - Explorer

可撤回的并查集

利用线段树优化

注意每次从左子树或者右子树回来的时候，都要进行清空。

  1. // #pragma GCC optimize(2)
  2. // #pragma GCC optimize(3)
  3. // #pragma GCC optimize(4)
  4. #include <algorithm>
  5. #include  <iterator>
  6. #include  <iostream>
  7. #include   <cstring>
  8. #include   <cstdlib>
  9. #include   <iomanip>
  10. #include    <bitset>
  11. #include    <cctype>
  12. #include    <cstdio>
  13. #include    <string>
  14. #include    <vector>
  15. #include     <stack>
  16. #include     <cmath>
  17. #include     <queue>
  18. #include      <list>
  19. #include       <map>
  20. #include       <set>
  21. #include   <cassert>
  22. // #include<bits/extc++.h>
  23. // using namespace __gnu_pbds;
  24. using namespace std;
  25. #define pb push_back
  26. #define fi first
  27. #define se second
  28. #define debug(x) cerr<<#x << " := " << x << endl;
  29. #define bug cerr<<"-----------------------"<<endl;
  30. #define FOR(a, b, c) for(int a = b; a <= c; ++ a)
  31.  
  32. typedef long long ll;
  33. typedef long double ld;
  34. typedef pair<int, int> pii;
  35. typedef pair<ll, ll> pll;
  36.  
  37. const int inf = 0x3f3f3f3f;
  38. const ll inff = 0x3f3f3f3f3f3f3f3f;
  39. const int mod = 1e9+;
  40.  
  41. template<typename T>
  42. inline T read(T&x){
  43.     x=;int f=;char ch=getchar();
  44.     while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();
  45.     while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();
  46.     return x=f?-x:x;
  47. }
  48. const int N = 1e5+;
  49.  
  50. /// 可撤回并查集模板
  51. struct UFS {
  52.     stack<pair<int*, int>> stk;
  53.     int fa[N], rnk[N];
  54.     inline void init(int n) {
  55.         for (int i = ; i <= n; ++i) fa[i] = i, rnk[i] = ;
  56.     }
  57.     inline int Find(int x) {
  58.         while(x^fa[x]) x = fa[x];
  59.         return x;
  60.     }
  61.     inline void Merge(int x, int y) {
  62.         x = Find(x), y = Find(y);
  63.         if(x == y) return ;
  64.         if(rnk[x] <= rnk[y]) {
  65.             stk.push({fa+x, fa[x]});
  66.             fa[x] = y;
  67.             if(rnk[x] == rnk[y]) {
  68.                 stk.push({rnk+y, rnk[y]});
  69.                 rnk[y]++;
  70.             }
  71.         }
  72.         else {
  73.             stk.push({fa+y, fa[y]});
  74.             fa[y] = x;
  75.         }
  76.     }
  77.     inline void Undo() {
  78.         *stk.top().fi = stk.top().se;
  79.         stk.pop();
  80.     }
  81. }T;
  82. /**********showtime************/
  83.             const int maxn = 1e5+;
  84.             int n,m;
  85.             struct E{
  86.                 int u, v, le, ri;
  87.                 void init(int U, int V, int Le, int Ri) {
  88.                     u = U; v = V;
  89.                     le = Le; ri = Ri;
  90.                 }
  91.             } edge[maxn];
  92.  
  93.             vector<int>vec;
  94.             int getid(int x) {
  95.                 return lower_bound(vec.begin(), vec.end(), x) - vec.begin() + ;
  96.             }
  97.  
  98.             vector <int> node[maxn * ];
  99.             int sz[maxn * ];
  100.             void update(int L, int R, int id, int le, int ri, int rt) {
  101.                 if(le >= L && ri <= R) {
  102.                     node[rt].pb(id);
  103.                     return;
  104.                 }
  105.                 int mid = (le + ri) >> ;
  106.                 if(mid >= L) update(L, R, id, le, mid, rt<<);
  107.                 if(mid < R) update(L, R, id, mid+, ri, rt<<|);
  108.             }
  109.             ll ans = ;
  110.  
  111.             void dfs(int le, int ri, int rt) {
  112.                 for(int id : node[rt]) {
  113.                     T.Merge(edge[id].u, edge[id].v);
  114.                 }
  115.                 int sz = T.stk.size();
  116.                 if(le == ri) {
  117.                     if(T.Find() == T.Find(n)) {
  118. //                        cout<<ri<<endl;
  119.                         ans += vec[ri] - vec[le-];
  120.                     }
  121.  
  122.                     return;
  123.                 }
  124.                 int mid = (le + ri) >> ;
  125.                 dfs(le, mid, rt<<);
  126.                 while(T.stk.size() > sz) {
  127.                     T.Undo();
  128.                 }
  129.                 dfs(mid+, ri, rt<<|);
  130.                 while(T.stk.size() > sz) {
  131.                     T.Undo();
  132.                 }
  133.             }
  134. int main(){
  135.             scanf("%d%d", &n, &m);
  136.             T.init(n);
  137.             for(int i=; i<=m; i++) {
  138.                 int u,v,le,ri;
  139.                 scanf("%d%d%d%d", &u, &v, &le, &ri);
  140.                 edge[i].init(u, v, le, ri+);
  141.                 vec.pb(le);
  142.                 vec.pb(ri + );
  143.             }
  144.             sort(vec.begin(), vec.end());
  145.             vec.erase(unique(vec.begin(), vec.end()), vec.end());
  146.             int tot = vec.size();
  147.             for(int i=; i<=m; i++) {
  148.                 int l = getid(edge[i].le);
  149.                 int r = getid(edge[i].ri) - ;
  150. //                cout<<l<<" " << r << endl;
  151.                 update(l, r, i, , tot-, );
  152.             }
  153.             ans = ;
  154.             dfs(, tot-, );
  155.             printf("%lld\n", ans);
  156.             return ;
  157. }

I - Inner World

先把n个子树看成一颗树，相同的点合并到一起，附加一个区间信息就行了。

然后利用dfs序+前缀和的思想处理询问即可

  1. // #pragma GCC optimize(2)
  2. // #pragma GCC optimize(3)
  3. // #pragma GCC optimize(4)
  4. #include <algorithm>
  5. #include  <iterator>
  6. #include  <iostream>
  7. #include   <cstring>
  8. #include   <cstdlib>
  9. #include   <iomanip>
  10. #include    <bitset>
  11. #include    <cctype>
  12. #include    <cstdio>
  13. #include    <string>
  14. #include    <vector>
  15. #include     <stack>
  16. #include     <cmath>
  17. #include     <queue>
  18. #include      <list>
  19. #include       <map>
  20. #include       <set>
  21. #include   <cassert>
  22. // #include<bits/extc++.h>
  23. // using namespace __gnu_pbds;
  24. using namespace std;
  25. #define pb push_back
  26. #define fi first
  27. #define se second
  28. #define debug(x) cerr<<#x << " := " << x << endl;
  29. #define bug cerr<<"-----------------------"<<endl;
  30. #define FOR(a, b, c) for(int a = b; a <= c; ++ a)
  31.  
  32. typedef long long ll;
  33. typedef long double ld;
  34. typedef pair<int, int> pii;
  35. typedef pair<ll, ll> pll;
  36.  
  37. const int inf = 0x3f3f3f3f;
  38. const ll inff = 0x3f3f3f3f3f3f3f3f;
  39. const int mod = ;
  40.  
  41. template<typename T>
  42. inline T read(T&x){
  43.     x=;int f=;char ch=getchar();
  44.     while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();
  45.     while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();
  46.     return x=f?-x:x;
  47. }
  48. /**********showtime************/
  49.  
  50.             const int maxn = 3e5+;
  51.  
  52.             int le[maxn],ri[maxn];
  53.             vector<int>mp[maxn];
  54.             int id[maxn], dfn[maxn], tim = , sz[maxn];
  55.             void dfs(int u) {
  56.                 dfn[u] = ++tim;
  57.                 id[tim] = u;
  58.                 sz[u] = ;
  59.                 for(int v : mp[u]) {
  60.                     dfs(v);
  61.                     sz[u] += sz[v];
  62.                 }
  63.             }
  64.             struct node{
  65.                 int le, ri, id, op;
  66.                 node(int Le, int Ri, int Id, int Op){
  67.                     le = Le; ri = Ri; id = Id; op = Op;
  68.                 }
  69.             };
  70.             vector<node> g[maxn];
  71.             ll ans[maxn];
  72.             struct TT{
  73.                 ll sum[maxn<<], lazy[maxn<<];
  74.                 void pushdown(int le, int ri, int rt) {
  75.                     lazy[rt<<] += lazy[rt];
  76.                     lazy[rt<<|] += lazy[rt];
  77.                     int mid = (le + ri) >> ;
  78.                     sum[rt<<] += 1ll*lazy[rt] * (mid - le + );
  79.                     sum[rt<<|] += 1ll*lazy[rt] * (ri - mid);
  80.                     lazy[rt] = ;
  81.                 }
  82.                 void update(int L, int R, int c, int le, int ri, int rt) {
  83.                     if(le >= L && ri <= R) {
  84.                         sum[rt] += 1ll * c * (ri - le + );
  85.                         lazy[rt] += 1ll * c;
  86.                         return ;
  87.                     }
  88.                     int mid = (le + ri) >> ;
  89.                     if(lazy[rt]) pushdown(le , ri, rt);
  90.                     if(L <= mid) update(L, R, c, le, mid, rt<<);
  91.                     if(mid < R) update(L, R, c, mid+, ri, rt<<|);
  92.                     sum[rt] = sum[rt<<] + sum[rt<<|];
  93.                 }
  94.                 ll query(int L, int R, int le, int ri, int rt) {
  95.                     if(le >= L && ri <= R) {
  96.                         return sum[rt];
  97.                     }
  98.                     int mid = (le + ri) >> ;
  99.                     if(lazy[rt]) pushdown(le, ri, rt);
  100.                     ll res = ;
  101.                     if(L <= mid) res += query(L, R, le, mid, rt<<);
  102.                     if(mid < R) res += query(L, R, mid+, ri,rt<<|);
  103.                     return res;
  104.                 }
  105.             } tree;
  106. int main(){
  107.             int n,m;
  108.             scanf("%d%d", &n, &m);
  109.             le[] = , ri[] = n;
  110.             for(int i=; i<=m; i++) {
  111.                 int u,v,l,r;
  112.                 scanf("%d%d%d%d", &u, &v, &l, &r);
  113.                 mp[u].pb(v);
  114.                 le[v] = l, ri[v] = r;
  115.             }
  116.             int N = m + ;
  117.             ///dfs序，将一个点的子树表示成一个区间
  118.             dfs();
  119.  
  120.             int q;  scanf("%d", &q);
  121.             for(int i=; i<=q; i++) {
  122.                 int u, le, ri;
  123.                 scanf("%d%d%d", &u, &le, &ri);
  124.                 int t1 = dfn[u] - ;
  125.                 ///将一次询问拆成两次操作，类似于把区间和改为前缀和相减
  126.                 g[t1].pb(node(le, ri, i, -));
  127.                 g[t1 + sz[u]].pb(node{le, ri, i, });
  128.             }
  129.  
  130.             for(int i=; i<=tim; i++) {
  131.                 int u = id[i];
  132.                 tree.update(le[u], ri[u], , , n, );
  133.                 ///因为是二维面积，所以要用线段树等数据结构维护前缀和
  134.                 for(node a : g[i]) {
  135.                     ans[a.id] += 1ll * a.op * tree.query(a.le, a.ri, , n, );
  136.                 }
  137.             }
  138.  
  139.             for(int i=; i<=q; i++) printf("%lld\n", ans[i]);
  140.             return ;
  141. }
  142. /*
  143. 4 3
  144. 1 2 1 2
  145. 1 3 2 4
  146. 3 4 2 3
  147. 2
  148. 1 1 4
  149. 3 1 4
  150. */

J - Just Jump

由于有m个限制，我们就计算出m个对应点不合法方案的个数。

这里要利用容斥，第i个点不合法的方案要减去之前就不合法的点转移过来的方案。

然后dp转移。

O($m ^ 2 + n$)的复杂度

从一个点x转移到y，走p步，每步长度要大于t,的方案数。可以转化为小球放入盒子中的问题。

设x到y之间有n个点，

就可以转化为有n个小球，分到p个盒子中，每个盒子至少要有t个小球。

那么我们先安排每个盒子t个小球。

那么剩下的$ n - t \times p$个小球放入盒子中，盒子可以为空。

这个怎么做呢，我们利用隔板法，多放入$ n - t \times p$个盒子，选出 p - 1个盒子作为隔板即可。

即

$\dbinom{n - p \times t + p - 1}{p-1}$

  1. // #pragma GCC optimize(2)
  2. // #pragma GCC optimize(3)
  3. // #pragma GCC optimize(4)
  4. #include <algorithm>
  5. #include  <iterator>
  6. #include  <iostream>
  7. #include   <cstring>
  8. #include   <cstdlib>
  9. #include   <iomanip>
  10. #include    <bitset>
  11. #include    <cctype>
  12. #include    <cstdio>
  13. #include    <string>
  14. #include    <vector>
  15. #include     <stack>
  16. #include     <cmath>
  17. #include     <queue>
  18. #include      <list>
  19. #include       <map>
  20. #include       <set>
  21. #include   <cassert>
  22. // #include<bits/extc++.h>
  23. // using namespace __gnu_pbds;
  24. using namespace std;
  25. #define pb push_back
  26. #define fi first
  27. #define se second
  28. #define debug(x) cerr<<#x << " := " << x << endl;
  29. #define bug cerr<<"-----------------------"<<endl;
  30. #define FOR(a, b, c) for(int a = b; a <= c; ++ a)
  31.  
  32. typedef long long ll;
  33. typedef long double ld;
  34. typedef pair<int, int> pii;
  35. typedef pair<ll, ll> pll;
  36.  
  37. const int inf = 0x3f3f3f3f;
  38. const ll inff = 0x3f3f3f3f3f3f3f3f;
  39. const int mod = ;
  40.  
  41. template<typename T>
  42. inline T read(T&x){
  43.     x=;int f=;char ch=getchar();
  44.     while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();
  45.     while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();
  46.     return x=f?-x:x;
  47. }
  48. /**********showtime************/
  49.             const int maxn=1e7+;
  50.             ll A[maxn];
  51.             ll B[maxn];
  52.             ll quick(int x,int n){
  53.                 ll ans=;
  54.                 while(n){
  55.                     if(n&) ans=1ll*ans*x%mod;
  56.                     x=1ll*x*x%mod;
  57.                     n=n/;
  58.                 }
  59.                 return ans;
  60.             }
  61.             void init(){
  62.                 int n=maxn-;
  63.                 A[]=; B[]=;
  64.                 for(int i=;i<=n;i++) A[i]=1ll*A[i-]*i%mod;
  65.                 B[n]=quick(A[n],mod-);
  66.                 for(int i=n-;i>=;i--) B[i]=1ll*B[i+]*(i+)%mod;
  67.             }
  68.             ll CC(ll n,ll x){
  69.                 if(x>n) return ;
  70.                 return 1ll*A[n]*B[n-x]%mod*B[x]%mod;
  71.             }
  72.             ll dp[maxn];
  73.             ll s[], sum[maxn];
  74.             pii a[];
  75. int main(){
  76.             init();
  77. //            debug(CC(500, 1));
  78.             int L,d,m;
  79.             scanf("%d%d%d", &L, &d, &m);
  80.             for(int i=; i<=m; i++) {
  81.                 scanf("%d%d", &a[i].se, &a[i].fi);
  82.             }
  83.             sort(a + , a +  + m);
  84.             for(int i=; i<=m; i++) {
  85.                 ll pos = a[i].fi, t = a[i].se;
  86.                 s[i] = CC(pos - t * d + t - , t - );
  87. //                cout<<s[i]<<" ";
  88.                 for(int j=; j<i; j++){
  89.                     if(a[j].fi < a[i].fi && a[j].se < a[i].se) {
  90.                         ll prepos = a[j].fi, pret = a[j].se;
  91.                         ll n = pos - prepos, tt = t - pret;
  92.                         s[i] = (s[i] - 1ll*s[j] * CC(n - tt * d + tt - , tt - )%mod + mod) % mod;
  93.                     }
  94.                 }
  95.  
  96.                 dp[pos] =((dp[pos] - s[i])% mod + mod) % mod;
  97.             }
  98. //            cout<<endl;
  99.             dp[] = ;
  100.             sum[] = ;
  101.             for(int i=; i<=L; i++) {
  102.                 if(i-d >= ) dp[i] += sum[i-d];
  103.                 dp[i] = dp[i] % mod;
  104.                 sum[i] = (sum[i-] + dp[i]) % mod;
  105. //                cout<<dp[i]<<" ";
  106.             }
  107. //            cout<<endl;
  108.             printf("%lld\n", dp[L]);
  109.             return ;
  110. }
  111. /*
  112. 5 2 4
  113. 1 2
  114. 2 5
  115. 2 8
  116. 2 9
  117. */

2019NC#8的更多相关文章

  1. 2019nc#2

    A Eddy Walker 题意 你有n个点(0-n-1),按顺序形成一个环,初始时你在0的位子,你随机顺时针走一步或者逆时针走一步, 一旦你走到一个点后,环上所有点都被经过至少一次后,你就必须停下来 ...

  2. 2019nc#10

    题号 标题 已通过代码 题解/讨论 通过率 团队的状态 A Blackjack 点击查看 背包DP 32/109 补好了 B Coffee Chicken 点击查看 进入讨论 738/2992  通过 ...

  3. 2019nc#9

    题号 标题 已通过代码 题解/讨论 通过率 团队的状态 A The power of Fibonacci 点击查看 进入讨论 69/227 未通过 B Quadratic equation 点击查看 ...

  4. 2019nc#7

    题号 标题 已通过代码 题解/讨论 通过率 团队的状态 A String 点击查看 进入讨论 566/3539  通过 B Irreducible Polynomial 点击查看 规律 730/229 ...

  5. 2019nc#6

    https://ac.nowcoder.com/acm/contest/886#question 题号 标题 已通过代码 题解/讨论 通过率 团队的状态 A Garbage Classificatio ...

  6. 2019nc#5

    题号 标题 已通过代码 题解/讨论 通过率 团队的状态 A digits 2 点击查看 1017/2384  通过 B generator 1 点击查看 567/3692  通过 C generato ...

  7. 2019nc#4

    题号 标题 已通过代码 题解 通过率 团队的状态 A meeting 点击查看 树直径 604/2055   B xor 点击查看 线段树维护线性基交 81/861 未通过 C sequence 点击 ...

  8. 2019nc#3

    题号 标题 已通过代码 题解/讨论 通过率 团队的状态 A Graph Games 点击查看 进入讨论 18/292 未通过 B Crazy Binary String 点击查看 1107/3615 ...

  9. 2019NC#1

    LINK B Integration 题意: 给定$a_1,a_2,...,a_n$, 计算 $$\frac{1}{π}\int_{0}^{\infty}\frac{1}{\prod\limits_{ ...

随机推荐

  1. VIM常用命令速查（转）

  2. MyBatis 简介与入门

    简介 什么是 MyBatis ? MyBatis 是一款优秀的持久层框架,它支持定制化 SQL.存储过程以及高级映射.MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集.My ...

  3. Spring浅入浅出——不吹牛逼不装逼

    Spring浅入浅出——不吹牛逼不装逼 前言: 今天决定要开始总结框架了,虽然以前总结过两篇,但是思维是变化的,而且也没有什么规定说总结过的东西就不能再总结了,是吧.这次总结我命名为浅入浅出,主要在于 ...

  4. Selenium+java - 借助autolt完成上传文件操作

    写在前面: 上传文件是每个自动化测试同学会遇到,而且可以说是面试必考的问题,标准控件我们一般用sendkeys()就能完成上传,但是我们的测试网站的上传控件一般为自己封装的,用传统的上传已经不好用了, ...

  5. java学习中碰到的疑惑和解答（一）

    今天写一个接口的时候发现,接口的方法不需要写修饰符,直接写数据类型加上方法名(参数)即可通过编译. import java.util.List; import com.bjm.pojo.Flower; ...

  6. String与new String()的区别

    JVM为了提升性能和减少内存开销,避免字符串的重复创建,维护了一块特殊的内存空间——字符串实例池. String赋值的两种方式. 1.String str = "test"; 以这 ...

  7. 浅谈 JavaScript 垃圾回收机制

    github 获取更多资源 https://github.com/ChenMingK/WebKnowledges-Notes 在线阅读:https://www.kancloud.cn/chenmk/w ...

  8. JavaScript 数组、字符串、Map、Set 方法整理

    在线阅读 https://www.kancloud.cn/chenmk/web-knowledges/1080519 数组 isArray():Array.isArray(value) 用于检测变量是 ...

  9. 树莓派dht11，土壤湿度传感器，继电器的使用。树莓派云灌溉（二）

    关于传感器的一些说明 我的想法是这样的 我尽量用易于理解的语言去说我的想法 首先,土壤湿度传感器和dh11会获取数据,然后树莓派会处理这些数据,读出土壤温湿度和空气温湿度,并将这些数据上传到云服务器, ...

  10. Unity进阶之ET网络游戏开发框架 04-资源打包

    版权申明: 本文原创首发于以下网站: 博客园『优梦创客』的空间:https://www.cnblogs.com/raymondking123 优梦创客的官方博客:https://91make.top ...