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

本文探讨了一道关于集合中数字唯一性的计数问题,采用数位DP和组合数学的方法进行解答。通过构建动态规划状态转移方程,解决了如何避免重复计数的难点。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题意

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

题解

第一想法是:f[S]表示数码集为S的情况下,组出一个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不定。。(可能是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];

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

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;
}
资源下载链接为: https://pan.quark.cn/s/22ca96b7bd39 在当今的软件开发领域,自动化构建与发布是提升开发效率和项目质量的关键环节。Jenkins Pipeline作为一种强大的自动化工具,能够有效助力Java项目的快速构建、测试及部署。本文将详细介绍如何利用Jenkins Pipeline实现Java项目的自动化构建与发布。 Jenkins Pipeline简介 Jenkins Pipeline是运行在Jenkins上的一套工作流框架,它将原本分散在单个或多个节点上独立运行的任务串联起来,实现复杂流程的编排与可视化。它是Jenkins 2.X的核心特性之一,推动了Jenkins从持续集成(CI)向持续交付(CD)及DevOps的转变。 创建Pipeline项目 要使用Jenkins Pipeline自动化构建发布Java项目,首先需要创建Pipeline项目。具体步骤如下: 登录Jenkins,点击“新建项”,选择“Pipeline”。 输入项目名称和描述,点击“确定”。 在Pipeline脚本中定义项目字典、发版脚本和预发布脚本。 编写Pipeline脚本 Pipeline脚本是Jenkins Pipeline的核心,用于定义自动化构建和发布的流程。以下是一个简单的Pipeline脚本示例: 在上述脚本中,定义了四个阶段:Checkout、Build、Push package和Deploy/Rollback。每个阶段都可以根据实际需求进行配置和调整。 通过Jenkins Pipeline自动化构建发布Java项目,可以显著提升开发效率和项目质量。借助Pipeline,我们能够轻松实现自动化构建、测试和部署,从而提高项目的整体质量和可靠性。
<think>嗯,用户现在问的是“new_subsets怎么弄”,看起来他们在之前的递归求子集的代码中对`new_subsets`的生成过程不太明白。首先,我需要回顾之前的对话,确保自己正确理解上下文。 用户之前询问如何用递归方法求集合的子集,我给出了一个Python代码示例,其中`new_subsets`是通过遍历已有的`rest_subsets`并将当前元素添加到每个子集中生成的。现在用户可能对这部分的具体实现有疑问,或者不理解`new_subsets`是如何形成的。 接下来,我需要分析用户的问题。他们可能不太理解列表推导式的作用,或者想知道为什么这样处理就能生成包含当前元素的子集。也有可能对递归过程中`rest_subsets`和`new_subsets`的关系感到困惑。 考虑到用户可能是编程新手,需要将问题拆解得更详细。我应该从递归的基本思路开始,逐步解释每一步发生了什么,特别是`new_subsets`的生成过程。可能需要用更简单的例子来演示,比如用一个小集合如[1,2]来逐步展示递归调用栈和变量的变化。 此外,用户可能对代码中的列表操作不太熟悉,比如`[current] + subset`是如何工作的。需要解释Python中列表拼接的机制,以及这里的`subset`指的是`rest_subsets`中的每一个元素,即已有的子集。 还要注意用户可能的误区,比如认为`new_subsets`是直接添加当前元素到原集合,而实际上它是将当前元素添加到每一个已有的子集中,从而生成新的子集。需要强调这一步是递归生成子集的关键,即每次递归都处理剩余元素,然后将当前元素与之前的子集组合。 最后,要确保回答结构清晰,分步骤说明,并结合示例代码和具体的例子来验证每个步骤的正确性,帮助用户建立直观的理解。</think>好的!我来详细解释 `new_subsets` 的生成过程,以及它在递归生成子集中的核心作用。 --- ### **关键概念** - **目标**:递归生成子集时,每一步需要将当前元素与已生成的子集组合,形成包含当前元素的新子集。 - **核心操作**:将当前元素添加到所有已存在的子集中,生成一批新的子集。 --- ### **具体步骤解释** 假设当前处理的元素是 `current`,已递归生成的子集列表是 `rest_subsets`(即不包含 `current` 的所有子集)。那么: 1. **遍历已有子集**:对 `rest_subsets` 中的每一个子集(例如 `subset = []` 或 `subset = [2]`)。 2. **添加当前元素**:将 `current` 插入到每个子集的头部(或尾部),生成新的子集。 3. **收集所有新子集**:将这些新生成的子集组合成 `new_subsets`。 **代码实现**: ```python current = nums[0] new_subsets = [ [current] + subset for subset in rest_subsets ] ``` --- ### **示例演示** 以集合 `[1, 2, 3]` 为例,递归到最深层时(处理最后一个元素 `3`): - `rest_subsets` 是空集的子集:`[[]]` - `current = 3` - `new_subsets = [[3] + subset for subset in [[]]] → [[3]]` **合并结果**:`rest_subsets (不包含3) + new_subsets (包含3)` → `[[], [3]]` --- #### **递归向上返回的过程** 假设递归返回到处理 `current = 2`: - `rest_subsets` 是 `[[], [3]]`(不包含2的子集) - `new_subsets` 是 `[[2] + [], [2] + [3]] → [[2], [2, 3]]` - 合并结果:`[[], [3], [2], [2, 3]]` 继续返回到处理 `current = 1`: - `rest_subsets` 是 `[[], [3], [2], [2, 3]]`(不包含1的子集) - `new_subsets` 是 `[[1] + s for s in rest_subsets] → [[1], [1,3], [1,2], [1,2,3]]` - 合并结果:`[[], [3], [2], [2,3], [1], [1,3], [1,2], [1,2,3]]` --- ### **为什么这样设计?** - **递归逻辑**:每一步只处理当前元素,其余交给递归解决。 - **数学本质**:若已知集合 $S' = S \setminus \{a\}$ 的所有子集,则 $S$ 的子集 = $S'$ 的子集(不包含 $a$) + 每个 $S'$ 的子集添加 $a$ 后的结果(包含 $a$)。 --- ### **常见误区** 1. **直接操作原集合**:错误地修改原集合会导致重复或遗漏。递归应始终处理剩余元素。 2. **浅拷贝问题**:如果直接引用列表(如 `subset.append(current)`),会导致所有子集共享同一内存。必须创建新列表(例如 `[current] + subset`)。 --- ### **总结** `new_subsets` 的作用是:**将当前元素添加到所有已有子集中,生成包含当前元素的新子集**。它是递归过程中“扩展子集”的核心步骤,最终与不包含当前元素的子集合并,形成完整的子集集合。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值