【训练题32：多重集康托展开 | 数位DP】[HAOI2010]计数 | 洛谷 P2518

洛谷 P2518：计数

难度

$省选/NOI-$

$-\frac{971}{2.28k}$

题意 + 数据范围 + 样例解释

• 给你一个$0\sim 9$数字的多重集排列，比如 $1020$
  问你该排列是该多重集全排列的字典序第几排列$(base0)$。
  多重集合大小 $\le 50$
  答案保证不会超过 $2^{63}-1$，所以答案不取模。
• 对于多重集合 { 0 , 0 , 1 , 2 } \{0,0,1,2\} {0,0,1,2}，按字典序的全排列为：
  $0012,0021,0102,0120,0201,0210,1002,1020,1200,2001,2010,2100$
  所以 $1020$ 是第 $7$ 个排列。（ $0012$ 是第 $0$ 个排列）

康托展开

• 例题：【模板】康托展开：洛谷 P5367
• 康托展开就是求 $1\sim N$的全排列的字典序是第几小，其实与原题的区别就是不是多重集。

公式：

• 字典序号 $=\underset{i=1}{\sum ^n}{S}_i\times (n-i)!$
  其中 $S_i$ 表示目前还没有用过的所有数里面，小于给定排列第 $i$ 个数的个数。
• 公式什么鬼？初学肯定一脸蒙蔽，但是推导过程其实很简单：
  考虑全排列 $3,4,1,2$。这里 $3$ 是排列第一位，$1$ 是第四位。

1. 你现在要构造一个新的全排列，你希望算出所有比原排列小的全排列个数。
2. 如果你第一位选择了 $1$ 或者 $2$ ，那么你后面三个数无论怎么排列，构造出的全排列一定比给的排列要字典序更小。个数 $=2\times (4-1)!$
3. 然后你第一位只能选择 $3$ 了，如果选择 $4$ 是不可能构造出比原排列小的全排列的。
4. 接下来第二位，要想后面随便排列，你这一位能选 $1$ 或 $2$，因为数字3已经被你选过了。个数 $=2\times (4-2)!$
5. 接下来第三位，没有比 $1$ 还小的数，那就个数 $=0\times (4-3)!$，这一位只能选 $1$。
6. 最后一位，没有比 $2$ 还小的没有选过的数。个数 $=0\times (4-4)!$
7. 最后总的答案等于上面所有个数相加 $=16$，即该全排列是第 $16$ 个全排列。

优化：

• 如果你直接找有多少个数是目前没有用过的，那时间复杂度 $O(N^2)$
  我们可以用树状数组或者线段树记录 $[0,x]$ 中还有多少个数没有用。
  记 $query(0,x)$ 表示 $[0,x]$ 范围内没有用过的数的个数，则
  字典序号 $=\underset{i=1}{\sum ^n}query(0,a[i]-1)\times (n-i)!$
  时间复杂度 $O(N\log N)$

核心代码：

/*
 _            __   __          _          _
| |           \ \ / /         | |        (_)
| |__  _   _   \ V /__ _ _ __ | |     ___ _
| '_ \| | | |   \ // _` | '_ \| |    / _ \ |
| |_) | |_| |   | | (_| | | | | |___|  __/ |
|_.__/ \__, |   \_/\__,_|_| |_\_____/\___|_|
        __/ |
       |___/
*/
const int MAX = 1e6+50;
const ll  MOD = 998244353;

ll fac[MAX];
ll aa[MAX];
ll cc[MAX];
int n;

ll lowbit(ll x){
    return x & (-x);
}
ll upd(ll x,ll c){
    while(x <= n){
        cc[x] += c;
        x += lowbit(x);
    }
}
ll query(ll x){
    ll res = 0;
    while(x){
        res += cc[x];
        x -= lowbit(x);
    }
    return res;
}
void init(int x){
    fac[0] = 1;
    for(int i = 1;i <= x;++i){
        fac[i] = fac[i-1] * i % MOD;
    }
}
int main()
{
    scanf("%d",&n);
    for(int i = 1;i <= n;++i){
        scanf("%d",&aa[i]);
        upd(i,1);
    }
    init(n);
    ll ans = 1;
    for(int i = 1;i <= n;++i){
        ans = (ans + query(aa[i] - 1) * fac[n - i] % MOD) % MOD;
        upd(aa[i],-1);
    }
    cout << ans;
    return 0;
}

有限多重集的全排列

• 想要知道这题的解法，这个知识需要掌握。
• 假设有 $n$ 种不同元素，第 $i$ 种元素的个数为 $cn{t}_i$
  则该有限多重集的全排列方案数为：
  $ans=\frac{(\underset{i=1}{\sum ^n}cn{t}_i)!}{\underset{i=1}{\prod ^n}(cn{t}_i!)}$
• 但是这题不能取模，这么算明显会爆 $LL$，我们可以使用朴素做法：
  一共 $shu=\sum cn{t}_i$ 种元素，一开始选择 $cn{t}_1$ 个位置填充一号元素，方案数$C_{shu}^{cn{t}_1}$
  然后在余下的 $shu-cn{t}_1$个位置选择 $cn{t}_2$ 个位置填充二号元素，方案数 $C_{shu-cn{t}_1}^{cn{t}_2}$
  $⋮$
  最后在 $shu-cn{t}_1-\cdots -cn{t}_{n-1}$ 个位置选择 $cn{t}_n$ 个位置填充 $n$ 号元素
  则该有限多重集的全排列方案数为：
  $ans=C_{shu}^{cn{t}_1}\times C_{shu-cn{t}_1}^{cn{t}_2}\times \cdots \times C_{shu-cn{t}_1-\cdots -cn{t}_{n-1}}^{cn{t}_n}$

多重集康托展开

• 其实思路和原来一样，写成公式比较麻烦，但是写成算法会比较简单。
• 对于第 $i$ 位，如果我们放置字典序小于原排列的元素，那么后面的所有元素的排列数就是多重集的全排列。
  接下来，我们第 $i$ 位放置和原排列相同的元素，再递推到 $i+1$位，重复这个步骤。
• 然后就……没了？确实没了。

核心代码

时间复杂度： $O(10^2\times n)$，$10$是因为这里数字只有 $0\sim 9$

/*
 _            __   __          _          _
| |           \ \ / /         | |        (_)
| |__  _   _   \ V /__ _ _ __ | |     ___ _
| '_ \| | | |   \ // _` | '_ \| |    / _ \ |
| |_) | |_| |   | | (_| | | | | |___|  __/ |
|_.__/ \__, |   \_/\__,_|_| |_\_____/\___|_|
        __/ |
       |___/
*/
#define ll long long
const int MAX = 50+50;

ll CC[MAX][MAX];
string ss;
int n;

ll C(int n,int m){		/// 记忆化组合数
    /// Cnm=Cn-1m+Cn-1m-1
    if(CC[n][m])return CC[n][m];
    if(n < m)return 0;
    if(m == 1)return n;
    if(m == 0 || n == m)return 1;
    CC[n][m] = C(n-1,m) + C(n-1,m-1);
    return CC[n][m];
}

int cnt[15];			/// 记录每个数字的出现次数
ll solve(){				/// 求有限多重集全排列个数。
    int shu = 0;
    for(int i = 0;i < 10;++i)shu += cnt[i];

    ll res = 1LL;
    for(int i = 0;i < 10;++i){
        if(cnt[i]){
            res = res * C(shu,cnt[i]);
            shu -= cnt[i];
        }
    }
    return res;
}

int main()
{
    cin >> ss;
    n = ss.size();

    for(int i = 0;i < n;++i){
        cnt[ss[i]-'0']++;
    }
    ll ans = 0;
    for(int i = 0;i < n;++i){
        for(char j = '0';j < ss[i];++j){
            if(cnt[j-'0']){				/// 放一个比原排列该位置字典序小的元素
                cnt[j-'0']--;
                ans = ans + solve();
                cnt[j-'0']++;
            }
        }
        cnt[ss[i]-'0']--;				/// 放一个原排列该位置的元素
    }
    cout << ans;
    return 0;
}