【2015新手赛网络赛】 1004 Good Subsets

题意

给定一个数N，问所有满足下述性质的集合的个数：
集合中所有数的数码都只出现一次。
例如：{135,27,49}符合，{134,27,49}不符合（因为出现了两个4），{177,23}不符合（因为177出现了两次7）

题解

第一想法是：$f[S]$表示数码集为S的情况下，组出一个$\leq N$的数，有多少种方案？
这一步是一个数位DP，枚举每一位统计即可，唯一需要注意的是，同一个数中数码也只能出现一次，统计的时候改一下即可。

---

第二步比赛时想偏了，先说说偏了的想法：
注意到现在我们只要依次枚举集合中每个数所取到的数码集，统计就能得到答案。

int oriS;
void dfs(int d, int lS, modn ans) {
    for (int S = lS+1; S < (1<<10); ++ S) if (!(oriS&S) && f[S].n) {
        oriS ^= S;
        dfs(d+1, S, ans * f[S]);
        oriS ^= S;
    }
    res = res + ans;
}

复杂度计算即为：10个不同的元素，放入m个相同的盒子中，m不定。。（可能是$\sum Stirling2(n,k)$），然而这是过不了的。。。

QwQ

---

有了上面“错误”的想法，接下来的想法也挺直观，即一个类似n!转为2^n的问题。
令$g[S][x]$表示目前数码集为$S$，所取数集合有$x$个元素的排列总数（注意算的是排列）。
第二维主要目的是为了判重，比赛时因为没搞清怎么判重而没去想这个角度Orz，提供一个判重方法是：
思考一个3个数的全排列：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
重新排序后：
1 2 3
2 1 3
1 3 2
3 1 2
2 3 1
3 2 1
可以发现，如果把最后一列遮住，那么前面组成了少一个元素的全排列。

由此得到启发，我们每次只加入一个元素的话，就可以保证其求排列的情况下不重复了

for (int SS = (S-1)&S; SS; SS = (SS-1)&S)
    g[S][i] += g[S^SS][1] * g[SS][i-1];

那么，在统计答案的时候只需要除以的阶乘即可

res = res + g[S][i] / fact[i];

---

看了标程以后，发现又更“正常”的写法。。。
我们可以发现，如果每次只加入包含最大的数 or 包含最小的数的集合，这样，就可以轻易地保证不会算重复。。。

包含最大的数：

for(int i = 1; i < 1<<10; ++i) {
    int k = 0;
    for(int j = 0; i >> j; j++) k = 1 << j;
    f[i] = c[i];
    for(int j = i ^ k; j; j = (j - 1) & i) {
        f[i] = (f[i] + 1ll * f[j] * c[i^j] % Mod) % Mod;
    }
    ans = (ans + f[i]) % Mod;
}

包含最小的数：

for(int i = 1; i < 1<<10; ++i) {
    int k = 0;
    f[i] = 0;
    for(int j = i; j; j = (j - 1) & i) if (j&(i&-i)) {
        f[i] = (f[i] + 1ll * f[i^j] * c[j] % Mod) % Mod;
    }
    ans = (ans + f[i]) % Mod;
}        

另外有个小写法： 清洗掉最后的“1”：S = S & (S-1) or S = S ^ (S & (-S))

code

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;

typedef int modn;
typedef long long LL;

modn f[1<<10], g[1<<10][10];

char num[20];

modn res;
int n, m;

modn fact[10], fact_[10];

int solve() {
    scanf("%d", &n); ++ n;
    sprintf(num, "%d", n); m = strlen(num);
    if (n == 1) return 0;

    for (int S = 0; S < (1<<10); ++ S) {
        int s = 0;
        for (int i = 0; i < 10; ++ i) if (S&(1<<i)) ++ s;
        if (s > m) f[S] = 0;
        else if (s < m) {
            if (S&(1<<0))
                f[S] = (LL)fact[s-1] * (s-1);
            else
                f[S] = fact[s];
        } else {
            f[S] = 0;
            int _S = S;
            for (int i = 0; i < m; ++ i) {
                int j = m-1-i, p = num[i] - '0';
                int x;
                for (x = 0; x < p; ++ x) {
                    if (!(i == 0 && x == 0) && (_S&(1<<x))) {
                        f[S] = f[S] + fact[j];
                    }
                }
                if (!(_S&(1<<x))) break;
                _S ^= (1<<x);
            }
        }
    }
    res = 0;

    memset(g, 0, sizeof g);
    for (int S = 1; S < (1<<10); ++ S) {
        g[S][1] = f[S]; res += f[S];
        for (int i = 2; i < 10; ++ i) {
            for (int SS = (S-1)&S; SS; SS = (SS-1)&S)
                g[S][i] += g[S^SS][1] * g[SS][i-1];
            res = res + g[S][i] / fact[i];
        }
    }

    printf("%d\n", res);
    return 1;
}

int main() {
//  freopen("E.in", "r", stdin);

    fact[0] = 1;
    for (int i = 1; i < 10; ++ i) fact[i] = fact[i-1] * i;

    while (solve());

//  for(;;);
    return 0;
}