精华内容
下载资源
问答
  • 一个集合有多少个非空子集
    2021-03-16 16:28:23

    题解:观察测试样例,会发现每个子集的选择规律与二进制((2^n) - 1)到 1 的顺序生成的规律是一致的,样例中n=3,2^n-1=7,用二进制表示为111,其中每一位的1表示数组中的三个数都选择。

    class Subset {

    public:

    vector > getSubsets(vector A, int n) {

    sort(A.begin(),A.end());

    vector> res;

    int size=1<

    for(int i=size-1;i>0;i--){

    vector temp;

    for(int j=n-1;j>=0;j--){

    if((i>>j)&1)

    temp.push_back(A[j]);

    }

    res.push_back(temp);

    }

    return res;

    }

    };

    课堂练习:给定一个十进制的正整数,写下从1开始,到N的所有整数,然后数一下其中出现&OpenCurlyDoubleQuote;1”的个数。

    题目 1 给定一个十进制的正整数,写下从1开始,到N的所有整数,然后数一下其中出现“1”的个数. 2 要求: (1) 写一个函数 f(N) ,返回1 到 N 之间出现的“1”的个数.例如 f(12)  ...

    怎么实现元素ol的降序排序显示

    首先介绍一下什么是ol元素.这里直接引用MDN里面的定义:The HTML

    1. Element (or HTML Ordered List Element) represents a ...

    数组转集合、集合转数组、字符串数组与int型、long型数组等的转换

    在项目中经常会遇到数组转集合.集合转数组.数组之间类型转换等操作 1.数组转集合 为了实现把一个数组转换成一个ArrayList,很多Java程序员会使用如下的代码: String str[] = { ...

    给定一个字符串,根据字符出现频率排序--Java实现

    题目描述: 给定一个字符串,请将字符串里的字符按照出现的频率降序排列. 示例 1: 输入:"tree" 输出:"eert" 解释:'e'出现两次,'r'和't' ...

    java 给定一个日期期间 返回形如Mar 2015 3&sol;20-3&sol;31的数据

    最近一个项目中有个前台对于表头要求: 给定一个日期期间返回形如 Mar 2015 3/20-3/31Apr 2015 4/1-4/30 这样的月年数据,简单的写了下代码,暂时没想到更好的办法 例如传进 ...

    随机推荐

    springMVC接收参数的几种方式

    Spring3 MVC请求参数获取的几种方法 一.      通过@PathVariabl获取路径中的参数 @RequestMapping(value="user/{id}/{name}&q ...

    OGG-03517 Conversion from character set failed解决方法

    用goldengate同步oracle数据到mysql,由于一个字段某行数据的字段集的原因导致 replicat进程报 OGG-03517错 OGG-03517  Conversion from ch ...

    Apache MINA&lpar;一&rpar;

    Apache MINA is a network application framework which helps users develop high performance and high s ...

    Compass是什么

    Compass是一个强大的Sass框架,他的设计目标是顺畅.搞笑地装扮互联网,使用它的人可以写出可维护性更高的样式表. Compass由三个主要部分组成:混混合器和实用工具类库,能够集成到应用开发环境 ...

    jQuery插件使用大全

    1.jQuery datepicker日历插件使用说明 http://wenku.baidu.com/view/12804e1e59eef8c75fbfb3e3 2.jqueryFileUpload插 ...

    &lbrack;转&rsqb;oracle性能调优之--Oracle 10g AWR 配置

    一.ASH和AWR的故事 1.1 关于ASH 我们都知道,用户在ORACLE数据库中执行操作时,必然要创建相应的连接和会话,其中,所有当前的会话信息都保存在动态性能视图V$SESSION中,通过该视图 ...

    使用 IIS Manager 对 Windows Azure 网站进行远程管理

     最近,我们为客户新增了使用 Windows自带的 IIS管理控制台管理 Azure网站的功能.IIS Manager支持 HTTP over SSL,提供到您的 Windows Azure 网站 ...

    STL之涉及到的算法

    一.非变异算法 是一组不破坏操作数据的模板函数,用来对序列数据进行逐个处理.元素查找.子序列搜索.统计和匹配.非变异算法具有极为广泛的适用性,基本上可应用与各种容器. 1查找容器元素find 它用于查 ...

    16&lowbar;Linux网络配置

    A类:255.0.0.0        8 0 000 0001 - 0 111 1111 127用户回环,1-126 2^7-1个A类地址 容纳多少个主机:2^24-2 主机位全0:网络地址 主机位 ...

    svg常见形状

    SVG是使用XML来描述二维图形和绘图程序的语言.是指可伸缩矢量图形(Scalable Vector Graphics),svg.图像在放大或改变尺寸的情况下图形质量不会有所损失. svg的主要竞争者 ...

    更多相关内容
  • 某个集合有n元素,它的所有子数(包括空集和自己)为2^n,两种办法,种是位图法(任一元素选取或不选取),另种办法是递归法: // File name: main.m #include <iostream> #include <vector...

     某个集合有n个元素,它的所有子集数(包括空集和自己)为2^n,有两种办法,一种是位图法(任一个元素选取或不选取),另一种办法是递归法:

    // File name: main.m
    
    #include <iostream>
    #include <vector>
    
    #include "Subset.hpp"
    
    using namespace std;
    
    int main(int argc, const char * argv[]) {
    
        char s[] = "abcd";
        int len = (int)std::char_traits<char>::length(s);
        //allSubsets(s, len);
        r_allSubsets(s, len);
    
        return 0;
    }

    //
    //  Subset.cpp
    //  SubsetCPP
    //
    //  Created by SongLiming on 2022-3-1.
    //
    
    #include "Subset.hpp"
    
    #include <iostream>
    #include <vector>
    
    
    using namespace std;
    
    
    /*使用非递归的思想 如果有一个数组  大小为n
      那么就使用n 位的二进制 如果对应的位为1 那么就输出这个位
      如果对应的位为0 那么就不输出这个位*/
    
    /*
       使用位图的思想 构造一个位集合 大小和数组大小一样,如果位图中相应的
       位为1,表示可以输出这个数组中的元素 如果位图中相应位为0 表示数组中相应位不输出
       这里模拟位图使用的数组 ,这里的重点是模拟数组加1的操作
     */
    
    /*使用数组模拟位图加1的操作  数组可以一直加1  直到数组内所有元素都是1
      函数返回值为bool 数组初始化最高位为1*/
    void allSubsets(char str[], const int n)
    {
        // 只算非空子集
        if (n <= 0) {
            exit(-1);
        }
    
        unsigned long value = 1; // will be set to 2^n - 1
        for (int i = 0, bit = 1; i < n; ++i) {
            value |= bit; // 逐位设置为1
            bit <<= 1;
        }
    
        unsigned long count = value;
        while (value) {
            int bit = 1;
            for (int i = 0; i < n; ++i) {
                int r = (bit & value);
                bit <<= 1;
                if (r != 0) {
                    std::cout << str[i];
                }
            }
            std::cout << std::endl;
            --value;
        }
        std::cout << "Count of non-empty subsets: " << count << std::endl;
    }
    
    
    /**
     二:递归迭代法:
    
     1)采用递归迭代,具体过程如下,
    
     设,原始集合s=<a,b,c,d>,子集结果为r:
    
     第一次迭代:
     r=<a>
    
     第二次迭代:
     r=<a ab b>
    
     第三次迭代:
     r=<a ab b ac abc bc c>
    
     第四次迭代:
     r=<a ab b ac abc bc c ad abd bd acd abcd bcd cd d>
    
    
    
     每次迭代,都是上一次迭代的结果+上次迭代结果中每个元素都加上当前迭代的元素+当前迭代的元素。
    
     具体代码如下:
     ————————————————
     版权声明:本文为CSDN博主「鱼思故渊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
     原文链接:https://blog.csdn.net/yusiguyuan/article/details/39367147
    
     */
    
    
    
    /*上述方法不可用 明白递归的思想 下面每次都是输出back中的字符即可
      这次输出的子集就是上次输出的子集 +这次迭代的元素 + 这次迭代的元素的本身*/
    #if 1
    void r_allSubsets(char *str, int len)
    {
        /*使用两个数组,一个记录上次迭代的结果
          一个记录这次需要输出的结果
          vec记录的是下次迭代需要参考的子集
          back记录的是参考vec迭代以后生成新的子集
         */
        int count = 0;
        vector<char> vec;
        vector<char> back;
    
        for (int i = 0; i < len; ++i) {
            if (i == 0) {
                // 第一次迭代
                vec.push_back(str[i]);
                vec.push_back(',');
                back = vec;
            } else {
                for (int j = 0; j < back.size(); ++j) {
                    if (back[j] == ',') {
                        back.insert(back.begin() + j, str[i]);
                        ++j;
                    }
                }
                back.push_back(str[i]);
                back.push_back(',');
            }
            for (int j = 0; j < back.size(); ++j) {
                if (back[j] == ',') {
                    printf("\n");
                    ++count;
                } else {
                    printf("%c", back[j]);
                }
                if (i) {
                    vec.push_back(back[j]);
                }
            }
            back = vec;
        }
        printf("Non-empty subsets count is %d \n", count);
    }
    #endif

    展开全文
  • 1.对于一个大小为n的数集,求出该数集的每个"非空子集"的方差之和对10°+7取模的结果。 附件1说明:第一行一个正整数口表示集合大小,第二行几个整数表示集合中的元素。/ /求集合的所有子集的算法(1): 对于任意集合...

    /题目:
    注:要求提交程序源代码和执行结果,编程语言不限。
    1.对于一个大小为n的数集,求出该数集的每个"非空子集"的方差之和对10°+7取模的结果。
    附件1说明:第一行一个正整数口表示集合大小,第二行几个整数表示集合中的元素。
    /

    /求集合的所有子集的算法(1):
    对于任意集合A,元素个数为n(空集n=0),其所有子集的个数为2^n个
    如集合A={a,b,c},其子集个数为8;对于任意一个元素,在每个子集中,
    要么存在,要么不存在,对应关系是:
    a->1或a->0
    b->1或b->0
    c->1或c->0
    映射为子集:
    (a,b,c)
    (1,1,1)->(a,b,c)
    (1,1,0)->(a,b )
    (1,0,1)->(a, c)
    (1,0,0)->(a )
    (0,1,1)->( b,c)
    (0,1,0)->( b )
    (0,0,1)->( c)
    (0,0,0)->@ (@表示空集)
    算法(1):
    观察以上规律,与计算机中数据存储方式相似,故可以通过一个整型数(int)与
    集合映射000…000 ~ 111…111(0表示有,1表示无,反之亦可),通过该整型数
    逐次增1可遍历获取所有的数,即获取集合的相应子集。
    在这里提一下,使用这种方式映射集合,在进行集合运算时,相当简便,如
    交运算对应按位与&,{a,b,c}交{a,b}得{a,b}<—>111&110==110
    并运算对应按位或|,
    差运算对应&~。
    /

    /求集合的所有子集的算法(1):
    设函数f(n)=2^n (n>=0),有如下递推关系f(n)=2
    f(n-1)=2*(2f(n-2))
    由此可知,求集合子集的算法可以用递归的方式实现,对于每个元素用一个映射列表marks,标记其在子集中的有无
    很显然,在集合元素个数少的情况下,算法(1)优于算法(2),因为只需通过加法运算,便能映射出子集,
    而算法(2)要递归调用函数,速度稍慢。但算法(1)有一个严重缺陷,集合的个数不能大于在计算机中一个整型数的位数,
    一般计算机中整型数的为32位。对于算法(2)就没这样限制。
    /

    /求 方差和 的算法:
    求每个子集的均值和方差
    然后求所有子集方差和
    /

    #include<iostream>
    #include<vector>
    #include<numeric>
    #include<cmath>
    #include<algorithm>
    using namespace std;
    
    double s = 0.0;
    
    double average(vector<int>& subset)//计算均值
    {
    	double sum = accumulate(subset.begin(), subset.end(), 0.0);
    	double mean = sum / subset.size();
    
    	return mean;
    }
    
    double variance(vector<int>& subset, double mean)
    {
    	double accum = 0.0;
    	std::for_each(subset.begin(), subset.end(), [&](const double d) {
    		accum += pow(d - mean, 2);
    		});
    	if (accum == 0) return 0;
    	else return accum/subset.size();
    }
    
    void print1(const vector<int>& a, int mark, int length)
    {
    	bool allZero = true;
    	int limit = 1 << length;
    	double mean = 0.0, accum = 0.0;
    	vector<int>temp;
    	cout << "子集:";
    	for (int i = 0; i < length; ++i)
    	{
    		if (((1 << i) & mark) != 0) //mark第i+1位为1,表示取该元素
    		{
    			allZero = false;
    			cout << a[i] << " ";
    			temp.push_back(a[i]);
    		}
    	}
    
    	if (allZero == true) 
    	{ 
    		cout << "空集"; 
    		cout << "     均值:无";
    		cout << "     方差:无";
    	}
    	else 
    	{
    		cout << "     均值:";
    		mean = average(temp);
    		cout << mean;
    
    		cout << "     方差:";
    		accum = variance(temp, mean);
    		cout << accum;
    	}
    	
    	s += accum;
    
    	cout << endl;
    }
    void subset1(const vector<int>& a, int length)
    {
    	if (length > 31) return;
    
    	int lowFlag = 0; //对应000...000
    	int highFlag = (1 << length) - 1; //对应111...111
    
    	for (int i = lowFlag; i <= highFlag; ++i)
    	{
    		print1(a, i, length);
    	}
    }
    
    void print2(vector<int>& a, vector<bool>& marks, int length)
    {
    	double mean = 0.0, accum = 0.0;
    	vector<int>temp;
    	bool allFalse = true;
    
    	cout << "子集:";
    	for (int i = 0; i < length; ++i)
    	{
    		if (marks[i] == true)
    		{
    			allFalse = false;
    			cout << a[i] << "  ";
    			temp.push_back(a[i]);
    		}
    	}
    
    	if (allFalse == true)
    	{
    		cout << "空集";
    		cout << "     均值:无";
    		cout << "     方差:无";
    	}
    	else
    	{
    		cout << "     均值:";
    		mean = average(temp);
    		cout << mean;
    
    		cout << "     方差:";
    		accum = variance(temp, mean);
    		cout << accum;
    	}
    
    	s += accum;
    
    	cout << endl;
    }
    
    
    void subset2(vector<int>& a, vector<bool>& marks, int m, int n, int length)
    {
    	if (m > n) 	print2(a, marks, length);
    	else
    	{
    		marks[m] = true;
    		subset2(a, marks, m + 1, n, length);
    		marks[m] = false;
    		subset2(a, marks, m + 1, n, length);
    	}
    }
    
    int main()
    {
    	int n;
    	vector<int>set;//set表示集合
    	cin >> n;
    	
    	for (int i = 0, x; i < n; i++)
    	{
    		cin >> x;
    		set.push_back(x);
    	}
    	if (n < 32) subset1(set, n);
    	else
    	{
    		vector<bool> marks(n, 0);
    		subset2(set, marks, 0, n - 1, n);
    	}
    
    	cout << "方差和 对10的9次方+7 取模 结果:";
    	cout << (int)s % int(pow(10, 9) + 7) << endl;
    
    	return 0;
    }
    

    集合的非空子集方差和

    展开全文
  • Python---按字典序输出集合的所有非空子集 通过使用模拟二进制减法以判断每次选取的具体元素。其中flag[ ]为模拟二进制数,初始化全为1,当flag[0]为0时结束循环。下标为0位不作为选取(用来判断是否结束),从下标...

    Python---按字典序输出集合的所有非空子集


    通过使用模拟二进制减法以判断每次选取的具体元素。其中flag[ ]为模拟二进制数,初始化全为1,当flag[0]为0时结束循环。下标为0位不作为选取(用来判断是否结束),从下标为1开始到size + 1,数值为0则代表不选取原数组中所对应的元素,反之为1则选取。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    实现代码:

    class Solution:
        def subsets(self, set):
            size = len(set)
            flags = [1]*(size + 1)          #flag标志有无
            result = []                     #存储结果
            while flags[0] == 1:            #实现2进制减1操作
                i = size
                while flags[i] != 1:
                    flags[i] = 1
                    i = i - 1
                flags[i] = 0
                subset = []                 # 存储单个结果
                for j in range(1,size + 1):
                    if flags[j]==1:
                        subset.append(set[j-1])
                result.append(subset)
            return result
    
        def __init__(self, set):
            list = self.subsets(set)
            answer = [[] for i in set]  # 初始化结果数组
            for i in list:
                if len(i) != 0:         #过滤掉空集
                    answer[len(i) - 1].append(i)  # 将相应长度的子集放到answer的项中
            for item in answer:
                print(item)  # 打印结果
    
    def main():
        list = [1,2,3,4,5,6,7,8,9,10]
        Solution(list)
    
    if __name__ == '__main__':
        main()
    
    展开全文
  • 组 n 元素可以划分为非空子集。 这包提供了列出所有可能的分区的功能。 分区数为贝尔数。 可以选择指定组成分区的子集的数量。 分区数是第二类斯特林数。
  • * 求一个集合(元素唯一)的子串的个数 * * @author 楠 * */ public class Test02 { public static void main(String[] args) { // TODO Auto-generated method stub char[] arr = { 'a', 'b', 'c' }; ...
  • 给定一个int数组A和数组的大小int n,请返回A的所有非空子集。保证A的元素个数小于等于20,且元素互异。各子集内部从大到小排序,子集之间字典逆序排序,见样例。  测试样例:[123,456,789]  * 返回{[789,456,...
  • 【算法】求非空子集的三种思路

    千次阅读 2020-04-16 19:15:51
    简化:编写一个方法,返回int数组的所有非空子集。 (n个元素的集合的子集个数:2^n - 1) 二、思路及代码 思路一:递归 对每个元素,都可以选择进入或者不进入子集。 因此,求n个元素的子集,可以分解成:求出n-1...
  • 非空子集个数计算

    千次阅读 2015-03-24 13:51:26
    题目:n元素的集合{1,2,.....,n},可以划分为若干个非空子集,如,当n=4时,集合{1,2,3,4}可以划分为15不同的非空子集如下: 由4个子集组成: {{1},{2},{3},{4}} 由3个子集组成: {{1,2},{3},{4}} {{1,3},{2},{4}} {{1,4...
  • 递归之非空子集

    2022-03-20 09:41:41
    请编写一个方法,返回某集合的所有非空子集。 给定一个int数组A和数组的大小int n,请返回A的所有非空子集。 保证A的元素个数小于等于20,且元素互异。 各子集内部从大到小排序,子集之间字典逆序排序 */ public ...
  • Apriori算法求集合非空子集java代码public class Test {public static void main(String[] args) {String str="abcd" ;//用Set集合保存结保证内容重复Set set = new HashSet();//外层循环控制指针移动位置 从 a ...
  • 集合元素的所有非空子集

    千次阅读 2015-08-27 22:10:57
    现有一个包含N个元素的集合S,求集合S的所有非空子集? 例如:集合S包含三个元素{a, b, c},则它的所有非空子集为: {a}, {b}, {c}, {a, b}, {a, c}, {b, c} 和{a, b, c}。 这里先用位操作的思路来求解,具体方法...
  • 列出一个集合的所有非空子集

    千次阅读 2012-10-16 19:19:18
    整体思路 description: 我们先看一个例子 ...非空子集有 {a}  |-->{a, b ,c }-->{a, b ,c ,d} {a, b}-->|  |-->{a, b ,d} {a, c}-->{a, c ,d} {a, d} {b}   {b, c}-->{b ,c ,d} {b, d}
  • 非空子集个

    千次阅读 2016-07-23 15:50:22
    求元素数为偶数的非空子集有多少个 ,知道公式 2^(n-1)(mod)-1 ;就很简单了 记得是要 对1000000007取模!! 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 #include __ int64 f ( _...
  • 字符串的非空子集 import java.util.*; public class _非空子集 { public static List<String> sList = new ArrayList<String>(); public static void main(String[] args) { Scanner sc = new ...
  • 众所周知,一个序列拥有许多非空子序列。 所谓子序列就是在原序列中任意删除 0 个或多个元素,然后保持剩下元素的顺序不变所形成的序列。...再比如序列 [1, 1],它的非空子序列:[1, 1],[1] (删除了第一个 1),.
  • 、全排列 全排列如果使用递归来实现的话是元素与元素交换的问题,而如果使用迭代实现的话是把当前字符加在已形成字符的前面或后面的问题。这里分别使用迭代,普通递归和多路递归+回溯实现。 迭代实现 //迭代...
  • 请编写一个方法,返回某集合的所有非空子集。 给定一个int数组A和数组的大小int n,请返回A的所有非空子集。保证A的元素个数小于等于20,且元素互异。各子集内部从大到小排序,子集之间字典逆序排序,见样例。 ...
  • 集合划分:包含n元素的集合划分为正好k个非空子集的方法的数目
  • C语言求非空子集

    千次阅读 2018-05-09 22:45:03
    例如,当n=4 时,集合{1,2,3,4}可以划分为15 不同的非空子集如下:{{1},{2},{3},{4}},{{1,2},{3},{4}},{{1,3},{2},{4}},{{1,4},{2},{3}},{{2,3},{1},{4}},{{2,4},{1},{3}},{{3,4},{1...
  • 注意因为是集合里面套集合,况且各个每个集合元素不重复,可以用Set 里面套Set 当加入元素成为集合中时,不能直接改变他,要克隆到t2中,再添加。否则就会出现,元素重复的现象,因为前面先添加进去的集合会跟着...
  • 今天同学问了下我怎么编程实现求集合{0,1….n-1}的非空子集合,我发现这恰好是棵满二叉树的题,可以用二叉树求解。 代码如下: #include using namespace std; #include int n ; int flag[20]; typedef ...
  • 给定一个序列的元素,里面由数字或字符组成,可能重复的值,如何求它的非空子集数目?比如说序列{1, 2, 3, 4},它的非空子集包括:{{1}, {2}, {3}, {4}, {1,2}, {1,3}, {1,4}, {2,3}, {2,4},{3,4}, {1,2,3}, {1,...
  • 前言最近在实现论文《Learning Actionlet Ensemble for 3D Human Action Recognition》的过程中,遇到需要找出一个集合的所有子集的问题,于是在网上查找了一些资料,发现利用格雷码可以轻松地解决这类问题。...
  • 概要今天偶然看到个关于数学中集合的问题,就突发奇想的想用python实现下求一个集合的子集。准备我当然先要复习下,什么是集合,什么是子集?比较粗犷的讲法,集合就是一堆确定的东西,细致一点的讲法呢,就是由...
  • 假如有一个n个元素的集合,那么它的非空子集有2的次方-1个,而一个n位的二进制数除去0刚好可以表示2的n次方-1种状态。刚好可以建立对应的联系,因此只需要检测二进制数所表示的每一种状态1的位置,把对应位置的角标...
  • n 元素的集合{1,2,, n }可以划分为若干个非空子集。例如,当 n=4 时,集合{1,2, 3,4}可以划分为 15 不同的非空子集如下: {{1},{2},{3},{4}}, {{1,2},{3},{4}}, {{1,3},{2},{4}}, {{1,4},{2}...
  • 和传统的程序设计语言不同,SPL中集合的应用非常普遍,实际上最常见的序列和序表等本质上都是集合,可以对它们进行真正的集合运算,...从集合角度出发,SPL提供了两个集合A、B的交、并、联、差等基本运算符:A^B,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,560
精华内容 1,824
热门标签
关键字:

一个集合有多少个非空子集