@atcoder - AGC036F@ Square Constraints

目錄

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

給定一個整數 N，統計有多少個 0~2N-1 的排列 \(P_0, P_1, ..., P_{2N-1}\) 知足：
\[N^2 \le i^2 + P_i^2 \le (2N)^2 (0 \le i < 2N)\]

求合法排列數量 mod m。

Constraints
1≤N≤250, 2≤M≤10^9

Input
輸入格式以下：
N M
Output
輸出合法排列數量 mod m。

Sample Input 1
2 998244353
Sample Output 1
4

@solution@

根據條件 \(N^2 \le i^2 + P_i^2 \le (2N)^2\)，咱們能夠求得 \(P_i\) 的上下界 \(lb_i \le P_i \le rb_i\)。
當 \(0 \le i < N\) 時，\(lb_i = \sqrt{N^2 - i^2}, rb_i = \sqrt{(2N)^2 - i^2}\)。
當 \(N \le i < 2N\) 時，\(lb_i = 0, rb_i = \sqrt{(2N)^2 - i^2}\)。

注意到當 \(i \ge N\) 時 \(lb_i\) 就始終等於 0 了。這意味着有一半元素有着相同下界。
假如 \(lb_i\) 全都爲 0，是否有快捷的計算方法呢？

假如 \(lb_i\) 全都爲 0，將 \(rb_i\) 從小到大排好序獲得 \(rb'_i\)，而後從小到大依次考慮每個 \(rb'_i\) 的貢獻。
由於較大的 \(rb'_i\) 必定包含較小的 \(rb'_j\)，這意味着不管 j 選擇什麼，i 老是會少一個可選擇的數。
\(rb'_i\) 對應能夠選擇 \(rb'_i + 1\) 種數（注意能夠選 0），刪去前面的已經被佔用的就只剩\(rb'_i + 1 - i\) 種數（注意下標從 0 開始）。
那麼總貢獻爲 \(\prod_{i=0}^{2N-1}(rb'_i + 1 - i)\)。

對於有下界的狀況，考慮經典容斥一波。
枚舉哪些數強制 < lb，那麼那些數的限制對應變成 \(P_i < lb_i\)，即 \(P_i \le lb_i - 1\)。而後就又可使用咱們上面的方法進行計數。
可是這個是指數級的算法。考慮根據題目性質進行優化。

首先只有 0 ~ N-1 這些數可能會 < lb，那麼咱們只容斥 0 ~ N-1 的部分。
而後，若是你打個表（或者直接觀察），你會發現隨着 i 增大，\(lb_i\) 與 \(rb_i\) 是遞減的。
而咱們計數的時候須要排序後的結果，因此這個性質的價值很大。
最後一點，對於 0 ~ N-1 這些數，有 \(\max\{lb\} <= \min\{rb\}\)。

有了這些結論，咱們就能夠設計咱們的算法了。假設我想要求 k 個 < lb 的方案數 f(k)：

N ~ 2N-1 這些數只能取 rb 爲上界。排完序後那些比它們上界小的，要麼是 N ~ 2N-1 中因爲單調性而較小的，要麼是 0 ~ N-1 中取 lb-1 爲上界時比較小的。

0 ~ N-1 這些數，當取 lb-1 爲上界時大體同上，要麼是 0 ~ N-1 中因爲單調性而較小的，要麼是 N ~ 2N-1 較小的。
而取 rb 爲上界時，首先有 N ~ 2N-1 因爲單調性因此全部都比它小，其次那 k 個取 lb-1 爲上界的必定比它小（由上面的性質），最後有 0 ~ N 中那些因爲單調性而比它小的。

由此，咱們將 0 ~ N-1 以 lb-1 爲第一關鍵字，rb 爲第二關鍵字； N ~ 2N-1 以 rb 爲第一關鍵字，0 爲第二關鍵字，所有進行排序。
從小到大做 dp，令 dp(i, j) 表示前 i 個選出 j 個 < lb 的方案數。最後 f(k) = dp(2N, k)。

總方案爲 f(0) - f(1) + f(2) - f(3) + ...
時間複雜度 O(n^3)。

@accepted code@

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
#define mp make_pair
#define fi first
#define se second
typedef pair<int, int> pii;
const int MAXN = 500;
int N, M;
int add(int x, int y) {return (x + y) % M;}
int mul(int x, int y) {return 1LL*x*y % M;}
int sub(int x, int y) {return add(x, M-y);}
int f[MAXN + 5][MAXN + 5]; pii a[MAXN + 5];
int solve(int t) {
    int cnt1 = 0, cnt2 = 0;
    f[0][0] = 1;
    for(int i=0;i<2*N;i++) {
        if( a[i].se == 0 ) {
            for(int j=0;j<=cnt2;j++)
                f[i+1][j] = mul(f[i][j], a[i].fi - (cnt1 + j) + 1);
            cnt1++;
        }
        else {
            f[i+1][0] = 0;
            for(int j=0;j<=cnt2;j++)
                f[i+1][j+1] = mul(f[i][j], a[i].fi - (cnt1 + j) + 1);
            for(int j=0;j<=cnt2;j++)
                f[i+1][j] = add(f[i+1][j], mul(f[i][j], a[i].se - (N + cnt2 - j + t) + 1));
            cnt2++;
        }
    }
    return f[2*N][t];
}
int main() {
    scanf("%d%d", &N, &M);
    for(int i=0;i<N;i++) {
        a[i].fi = 0, a[i].se = 2*N - 1;
        while( a[i].fi*a[i].fi + i*i < N*N ) a[i].fi++; a[i].fi--; 
        while( a[i].se*a[i].se + i*i > 4*N*N ) a[i].se--;
    }
    for(int i=N;i<2*N;i++) {
        a[i].fi = 2*N - 1, a[i].se = 0;
        while( a[i].fi*a[i].fi + i*i > 4*N*N ) a[i].fi--;
    }
    sort(a, a + 2*N);
    int ans = 0;
    for(int i=N;i>=0;i--)
        ans = sub(solve(i), ans);
    printf("%d\n", ans);
}

@details@

抱歉，我不會組合計數.jpg。