精华内容
下载资源
问答
  • 离散数学 等价关系解释

    千次阅读 2011-11-09 08:02:10
    集合的每一种划分又对应于该集合的一个等价关系,不同的等价关系对应于集合的划分也不同,因此集合有多少不同划分,就有多少不同等价关系,三个元素的集合共有5种不同划分,(含有1块和3块各有1种,含有2块有3种),故含有三...
    集合上每个等价关系对应集合的一种划分,集合的每一种划分又对应于该集合的一个等价关系,不同的等价关系对应于集合的划分也不同,因此集合有多少不同划分,就有多少不同等价关系,三个元素的集合共有5种不同划分,(含有1块和3块各有1种,含有2块有3种),故含有三个元素的集合,可以确定5种等价关系.
       如A={1,2,3},则5种不同划分为 
    {{1}, {2}, {3}};{{1}, {2,3}};{{1,3}, {2}};{{1,2}, {3}};{{1, 2, 3}};
    对应的等价关系为
    R1={(1,1),(2,2),(3,3)};R2={(1,1),(2,2),(2,3),(3,2),(3,3)};
    R3={(1,1),(1,3),(3,1),(2,2),(3,3)};
    R4={(1,1),(1,2),(2,1),(2,2),(3,3)};
    R5={(1,1),(2,2),(3,3),(1,2),(2,1),(2,3),(3,2),(1,3),(3,1)};
    一般地,对有n个元素的集合有Bn种不同的划分(等价关系),Bn称为Catalan数
    Bn=2n!/((n+1)n!n!),如4个元素的集合,可以确定14种等价关系

    展开全文
  • 等价类划分 原则 完备测试 ...边界值测试不能实现完备测试和...等价类测试的关键就是确定类的等价关系 等价类划分 例子 一个两变量x1和x2的函数F联系起来,如果F实现为一个程序,则输入变量x1和x2将拥有...

    等价类划分


    原则

    1. 完备测试
    2. 避免冗余
    3. 边界值测试不能实现完备测试和避免冗余
    4. 等价类测试重复边界值测试的两个决定因素:健壮性和单/多缺陷假设
    5. 等价类种类:强/弱等价类,健壮/一般等价类

    思想

    1. 等价类的测试思想是通过每个等价类中的一个元素标识测试用例
    2. 等价类测试的关键就是确定类的等价关系

    等价类划分

    例子
    一个两变量x1和x2的函数F联系起来,如果F实现为一个程序,则输入变量x1和x2将拥有以下边界以及边界内的区间:

    • a<=x1<=d,区间为[a,b),[b,c),[c,d]
    • e<=x2<=g,区间为[e,f),[f,g]
      x1和x2的无效值是:x1<a, x1>d,x2<e,x2>g

    弱一般等价类测试
    弱一般等价类测试通过使用一个测试用例中的每个等价类(区间)的一个变量实现。(单缺陷);
    测试用例的个数实际上取决于变量区间最多的变量的区间个数。
    弱一般等价类

    强一般等价类测试
    强一般等价类测试基于多缺陷假设,因此需要等价类笛卡儿积的每个元素对应的测试用例。
    所有变量所有取值的所有组合,取值为有效值
    覆盖所有的等价类。
    有可能的输入组合中的一个。
    强一般等价类

    弱健壮等价类测试
    健壮:考虑无效值;弱:单缺陷假设
    对于有效输入,使用每个有效类的一个值
    对于无效输入,测试用例将拥有一个无效值,并保持其余的值都是有效的
    弱健壮性等价类

    强健壮等价类测试
    健壮:考虑无效值
    强:多缺陷假设
    强健壮性等价类

    展开全文
  • 并查集实现等价

    2014-03-25 10:51:53
    等价关系:集合或类(以集合为例)上的等价关系R指一个具有自反, 对称, 传递性的二元关系。等价类: 在一个定义了... 假设集合S有n个元素,m个形如(x,y) (x,y 属于 S)的等价偶对确定等价关系R,如何求S的划分,即该如何求S
    等价关系:集合或类(以集合为例)上的等价关系R指一个具有自反, 对称, 传递性的二元关系。
    等价类: 在一个定义了等价关系的集合中可以按该等价关系分成等价类(即两个元素只要有xRy, 则它们属于同一等价类), 即集合的一些子集组成的集,。容易证明这些等价类两两不交且其并等于原集合.
     假设集合S有n个元素,m个形如(x,y) (x,y 属于 S)的等价偶对确定了等价关系R,如何求S的划分,即该如何求S的等价类?? 
     1)利用链表结构实现
      2)利用并查集实现(我么这里将讨论的)

    并查集:并查集是一种树型的数据结构,用于处理一些不相交集合(Disjoint Sets)的合并及查询问题。常常在使用中以森林来表示。

    并查集方式求等价类的方法如下:

        (1)令集合S中每个元素个子形成一个只包含单个成员的子集,记为S0,S1,...Sn-1.

          (2)  重复读入m个偶对,对每个读入的偶对(x,y),判定x和y所属子集。假设x属于Si,y属于Sj,如果Si != Sj,侧将Si 并于 Sj并将Si置空(或将Sj并于Si,                      并将Sj置空)。则当m个偶对都被处理过后,S0,S1,...,Sn-1中所有非空子集即为S的R等价类.


    由此可见并查集方式求子集关键是1)查找一个元素所属的集合.2)求二个子集的合集3)求非空集合

    并查集的定义

    1. const int Max_TreeNode=100;//树的节点的最大值  
    2. //利用双亲表示法表示树  
    3.   
    4. template <typename T>   
    5. class UFSET  
    6. {  
    7. public:  
    8.     //树的节点定义  
    9.    typedef struct TreeNode  
    10.    {  
    11.      T data;//树的节点的值  
    12.      int parent;//节点的双亲所在的位置(如果该节点为根节点侧该值为以该节点为根的树的节点个数的负值)  
    13.    } TreeNode, *PTreeNode ;  
    14.       
    15.     TreeNode nodes[Max_TreeNode];  
    16.     int n;//节点个数(集合元素的个数)  
    17.       
    18.     UFSET(T * datas,int size):n(size)//datas为集合中所有元素值的集合,size为集合元素的个数  
    19.     {  
    20.         for(int i=0;i<size;i++)  
    21.         {  
    22.             nodes[i].data=datas[i];  
    23.             //最开始令每个元素各自形成只包含该元素的子集  
    24.             nodes[i].parent=-1;  
    25.         }  
    26.     }  
    27. };  

          查找元素所属的集合
    1. //查找元素e所属的集合(用根节点所在位置表示集合)  
    2. template <typename T>  
    3. int find(UFSET<T> & t,T e)  
    4. {  
    5.    //先找到值为e的节点  
    6.    for(int i=0;i<t.n;++i)  
    7.    {  
    8.     if(t.nodes[i].data==e)  
    9.     {    
    10.        int j;  
    11.        for(j=i;t.nodes[j].parent>=0;j=t.nodes[j].parent);  
    12.        return j;  
    13.     }  
    14.    }  
    15.    return -1;//表示值为e的节点不存在  
    16. }  

       当所查元素i不在树的第二层时,在算法中增加一个“压缩路劲的功能”,将所有从根到元素路径上的元素都变成树根的孩子。

      查找元素所属的集合的改进型

    1. //find函数的一种改进型  
    2. template <typename T>  
    3. int mix_find(UFSET<T> & t,T e)  
    4. {  
    5.    //先找到值为e的节点  
    6.    for(int i=0;i<t.n;++i)  
    7.    {  
    8.     if(t.nodes[i].data==e)  
    9.     {    
    10.        int j;  
    11.        for(j=i;t.nodes[j].parent>=0;j=t.nodes[j].parent);  
    12.        //将所有从节点t.nodes[i]到根t.nodes[j]的路径上的节点都变成根t.nodes[j]的孩子  
    13.        while(i!=j)  
    14.        {  
    15.           int temp=t.nodes[i].parent;  
    16.           t.nodes[i].parent=j;  
    17.           i=temp;  
    18.        }  
    19.        return j;  
    20.     }  
    21.    }  
    22.    return -1;//表示值为e的节点不存在  
    23. }  

    合并子集

    1. //合并子集  
    2. //将节点少的子集合并到节点多的子集上  
    3. template <typename T>  
    4. void merger(UFSET<T> & t,int i,int j)  
    5. {  
    6.    // t.nodes[i]和 t.nodes[j] 分别表示集合的两个互不相交的子集Si和Sj的根节点  
    7.    if(i<0 || i>t.n || j<0 || j>t.n)  
    8.        return ;  
    9.    if(t.nodes[i].parent>t.nodes[j].parent)//t.nodes[i]的节点个数少于t.nodes[j]的节点个数  
    10.    {  
    11.       t.nodes[j].parent+=t.nodes[i].parent;  
    12.       t.nodes[i].parent=j;  
    13.    }  
    14.    else  
    15.    {  
    16.       t.nodes[i].parent+=t.nodes[j].parent;  
    17.       t.nodes[j].parent=i;  
    18.    }  
    19. }  
        计算等价类
    1. //计算等价类(即最后非空子集的个数)  
    2. template <typename T>  
    3. int EquClassCount(UFSET<T> & t)  
    4. {  
    5.     int count=0;  
    6.     for(int i=0;i<t.n;i++)  
    7.         if(t.nodes[i].parent<0)  
    8.             count++;  
    9.     return count;  
    10. }  

    下面求解小米公司2013笔试题:

    朋友圈:假如已知有n个人和m对好友关系,如果两个人是直接或者间接有好友关系,则认为他们属于同一个朋友圈。写程序判断里面有多少朋友圈。
    例如 
    n = 5, m = 3  r = {(1,2), (2, 3), (4, 5)}  1 2 3 是一个朋友圈, 4 5 是一个朋友圈。
    所以输出是2. 

    完整代码余下所示:

    1. #include "stdafx.h"  
    2. #include <iostream>  
    3.    
    4. const int Max_TreeNode=100;//树的节点的最大值  
    5. //利用双亲表示法表示树  
    6.   
    7. template <typename T>   
    8. class UFSET  
    9. {  
    10. public:  
    11.     //树的节点定义  
    12.    typedef struct TreeNode  
    13.    {  
    14.      T data;//树的节点的值  
    15.      int parent;//节点的双亲所在的位置(如果该节点为根节点侧该值为以该节点为根的树的节点个数的负值)  
    16.    } TreeNode, *PTreeNode ;  
    17.       
    18.     TreeNode nodes[Max_TreeNode];  
    19.     int n;//节点个数(集合元素的个数)  
    20.       
    21.     UFSET(T * datas,int size):n(size)//datas为集合中所有元素值的集合,size为集合元素的个数  
    22.     {  
    23.         for(int i=0;i<size;i++)  
    24.         {  
    25.             nodes[i].data=datas[i];  
    26.             //最开始令每个元素各自形成只包含该元素的子集  
    27.             nodes[i].parent=-1;  
    28.         }  
    29.     }  
    30. };  
    31.   
    32. //查找元素e所属的集合(用根节点所在位置表示集合)  
    33. template <typename T>  
    34. int find(UFSET<T> & t,T e)  
    35. {  
    36.    //先找到值为e的节点  
    37.    for(int i=0;i<t.n;++i)  
    38.    {  
    39.     if(t.nodes[i].data==e)  
    40.     {    
    41.        int j;  
    42.        for(j=i;t.nodes[j].parent>=0;j=t.nodes[j].parent);  
    43.        return j;  
    44.     }  
    45.    }  
    46.    return -1;//表示值为e的节点不存在  
    47. }  
    48.   
    49. //find函数的一种改进型  
    50. template <typename T>  
    51. int mix_find(UFSET<T> & t,T e)  
    52. {  
    53.    //先找到值为e的节点  
    54.    for(int i=0;i<t.n;++i)  
    55.    {  
    56.     if(t.nodes[i].data==e)  
    57.     {    
    58.        int j;  
    59.        for(j=i;t.nodes[j].parent>=0;j=t.nodes[j].parent);  
    60.        //将所有从节点t.nodes[i]到根t.nodes[j]的路径上的节点都变成根t.nodes[j]的孩子  
    61.        while(i!=j)  
    62.        {  
    63.           int temp=t.nodes[i].parent;  
    64.           t.nodes[i].parent=j;  
    65.           i=temp;  
    66.        }  
    67.        return j;  
    68.     }  
    69.    }  
    70.    return -1;//表示值为e的节点不存在  
    71. }  
    72.   
    73. //合并子集  
    74. //将节点少的子集合并到节点多的子集上  
    75. template <typename T>  
    76. void merger(UFSET<T> & t,int i,int j)  
    77. {  
    78.    // t.nodes[i]和 t.nodes[j] 分别表示集合的两个互不相交的子集Si和Sj的根节点  
    79.    if(i<0 || i>t.n || j<0 || j>t.n)  
    80.        return ;  
    81.    if(t.nodes[i].parent>t.nodes[j].parent)//t.nodes[i]的节点个数少于t.nodes[j]的节点个数  
    82.    {  
    83.       t.nodes[j].parent+=t.nodes[i].parent;  
    84.       t.nodes[i].parent=j;  
    85.    }  
    86.    else  
    87.    {  
    88.       t.nodes[i].parent+=t.nodes[j].parent;  
    89.       t.nodes[j].parent=i;  
    90.    }  
    91. }  
    92.   
    93. //计算等价类(即最后非空子集的个数)  
    94. template <typename T>  
    95. int EquClassCount(UFSET<T> & t)  
    96. {  
    97.     int count=0;  
    98.     for(int i=0;i<t.n;i++)  
    99.         if(t.nodes[i].parent<0)  
    100.             count++;  
    101.     return count;  
    102. }  
    103.   
    104. //将元素值为e1和e2所在集合合并  
    105. template <typename T>  
    106. void mix_merger(UFSET<T> & t,T e1,T e2)  
    107. {  
    108.     int i=mix_find(t,e1);  
    109.     int j=mix_find(t,e2);  
    110.     if(i>=0 && j>=0 && i!=j)  
    111.         merger(t,i,j);  
    112. }  
    113.   
    114. int _tmain(int argc, _TCHAR* argv[])  
    115. {  
    116.     int friends[]={1,2,3,4,5};  
    117.     UFSET<int> friend_set(friends,sizeof(friends)/sizeof(int));  
    118.     mix_merger(friend_set,1,2);  
    119.     mix_merger(friend_set,2,3);  
    120.     mix_merger(friend_set,4,5);  
    121.     std::cout<<"朋友串个数为:"<<EquClassCount(friend_set)<<std::endl;  
    122.     system("PAUSE");  
    123.     return 0;  
    124. }  

    本文主要参考资料:数据结构(C语言本 严蔚敏版) P139——P143
    展开全文
  • 6.5 树与等价问题

    2021-01-10 16:25:54
    假设集合S有n个元素,m个形如(x, y)(x, y ∈ S)的等价偶对确定等价关系R,求R a. 令S中的每个元素各自形成一个只含单个成员的子集,记作S1 , S2 , … , Sn。 b. 重复读入m个偶对,对每个读入的偶对(x, y),...
    • 如何划分等价类
      假设集合 S 有 n 个元素,m个形如(x, y)(x, y ∈ S) 的等价偶对确定了等价关系R,求R
      a. 令S中的每个元素各自形成一个只含单个成员的子集,记作 S1 , S2 , … , Sn
      b. 重复读入 m 个偶对,对每个读入的偶对(x, y),判定 x 和 y 所属的子集。假设x ∈ Si , y ∈ Sj , 若 Si != Sj ,则将Si并入Sj,并置Si为空(或将Sj并入Si,并置Sj为空)。在m个偶对都被处理过后,S1 , S2 , … , Sn所有非空子集即为S 的R的等价类
      【其实就是构造只含单个成员的集合判定某个单元素所在的子集归并两个互不相交的集合成为一个集合

    利用树型结构表示集合,并划分等价类

    • 以森林 F = ( T1, T2, … ,Tn ) 来表示上述集合 S,森林中的每一棵树 Ti ( i = 1, 2, … , n ) 表示 S 中的一个元素 一一 子集 Si (Si ⊂ S, i = 1, 2, … , n),树中的每个结点表示子集中的一个成员 x ( 结点结构采用双亲表示法,即设置一个指针域指向其双亲结点 ),约定根节点的成员 / 数据域兼作子集的名称
    • 如下图,(a) 表示子集 S1 = { 1, 3, 6, 9 },(b) 表示 S2 = {2, 8, 10 },© 表示 S3 = S1 U S2
      实现两棵树的并操作:只要将一棵子集树的根结点指向另一棵子集树的根结点即可。

    在这里插入图片描述

    • 代码实现
    #define MAX_TREE_SIZE 100
    // 以下结构描述单个结点结构
    typedef struct PTNode
    {
    	TElemType data; // 结点数据域
    	int parent; // 双亲位置域,指示双亲的在表中的下标
    } PTNode;
    // 以下结构描述树结构
    typedef struct
    {
    	PTNode nodes[MAX_TREE_SIZE];// 顺序表存放所有结点,0号单元弃用
    	int r, n; // r 为根的下标,n 为结点总数
    } PTree;
    
    typedef PTree MFSet;
    
    // 查找森林 / 集合S中结点i所在子集的根
    // 时间复杂度为 O(d), d是子集 / 树 的深度
    int find_mfset(MFSet S, int i)
    {
    	// 找集合 S 中 i 所在子集的根
    	if(i < 1 || i > S.n)
    	{
    		return -1;
    	}
    	for(j = i; S.nodes[j].parent > 0; j=S.nodes[j].parent);
    	return j;
    }
    
    // 合并森林 S 的两个互不相交的子集 的并集
    // S.nodes[i], S.nodes[j] 分别是这两个子集的根结点 
    // 时间复杂度为 O(1)
    Status merge_mfset(MFSet &S, int i, int j)
    {
    	if(i < 1 || i > S.n || j < 1 || j > S.n)
    	{
    		return ERROR;
    	}
    	// 将其中一个子集的根结点指向另一个根结点即可
    	S.nodes[i].parent = j;
    }
    
    展开全文
  • 聚类操作校准是在样本点之间定义等价关系,属于同一类的任意两样本点被认为是等价的,而基于传统的等价关系聚类存在缺陷,不能解决异类有交集聚类问题。分析了基于等价关系聚类粒度分析不足的原因,利用模糊...
  • DFA化简定义:找一个状态数比原来得确定有限自动机状态数少得确定有限自动机,但是表示得语言和原来的确定有限自动机相同 状态等价: 状态s和t等价,意味着从s和t出发,读出识别同一个字符α,都到达了终态,那么这...
  • 基于卡诺图确定依赖基,张亦舜,,依赖基是关系模式中属性集的一个划分,多值依赖的逻辑蕴含可由依赖基直接判定。根据数据依赖与逻辑函数之间存在的对应等价联系,
  • 一、并查集的概念: 首先,为了引出并查集,先介绍几个概念: 1、等价关系(Equivalent Relation) 自反性、对称性、传递...注意,等价类形成对S的一个划分:S的每一个成员恰好互斥地出现在一个等价类中。为了确定是...
  • 软件测试规范

    2018-04-23 09:16:12
    1.等价划分 .......................................................................................................................................... 7 2.因果图 ........................................
  • 然后根据等价表的特点,以属性粒为基本单位,用属性粒的可分辨量、属性粒相对于决策属性的类别数量、决策表中相同行的数量这3基本参数确定属性的优劣,并以最优属性为划分属性自上向下直接构建决策树。实例分析...
  • 给定对象间的一个等价关系,即导致由等价类构成的近似空间的不分明关系,Rough集就用不分明对象类形成的上近似和下近似来描述。这些近似分别对应了确定属于给定类的最大的对象集合和可能属于给定类的最小的对象集合...
  • java包的设计原则整理总结

    千次阅读 2013-12-20 16:46:59
    前3个原则关注包的内聚...一个包的重用粒度(granule of reuse)可以和发布粒度(granule of release)一样大。我们说重用的任何东西都必须同时被发布和跟踪 a,由于重用性必须是基于包的,所以可重用的包必须包含可重
  • Java编程思想(完整版)

    2012-02-13 00:13:57
    确定了对象和它们的接口后,便可着手编写一个程序。出于对多方面原因的考虑,可能还需要比这更多的说明及文档,但要求掌握的资料绝对不能比这还少。 整个过程可划分为四个阶段,阶段0刚刚开始采用某些形式的结构。...
  • 2、将业务高度相关的表放到一个库中,将业务关系不是很紧密的表严格按照微服务模式来拆分,这样既可以使用微服务,也避免了数据库分散导致后台系统统计功能难以实现,是一个折中的方案。 3、数据库严格按照微服务的...
  • 50 给定的一个型变为另一个型的所有可能的同型变换之间的关系 第162目 51 歧型 第163目 52 与同时既是正常地又是反常地包含在另一个型中的型有关的定理 第164目 53 由型表示数的一般性研究以及这些表示与变换的联系 ...
  • 9. 软件详细设计的主要任务是确定模块的( C )。 A. 功能 B. 外部接口 C. 算法和使用的数据结构 D. 编程 10.为了提高软件的可维护性,在编码阶段应注意( B ) A.保存测试用例和数据 B.提高模块的独立性 C...
  • (3)三角形单元任一一条边上的形函数,仅与该端点节点坐标有关,而与另外一个节点坐标无关;(4)型函数的值在0~1之间变换。 21. 结构的网格划分应注意哪些问题.如何对其进行节点编号。才能使半带宽最小。P50,P8...
  • 3.1.2词法分析器作为一个独立子程序 3.2词法分析器的设计 3.2.1输入、预处理 3.2.2 单词符号的识别:超前搜索 3.2.3状态转换图 3.2.4状态转换图的实现 3.3正规表达式与有限自动机 3.3.1正规式与正规集 ...
  • 软件工程知识点

    2012-12-02 21:34:25
    如同任何事物都有一个发生、发展、成熟直至衰亡的全过程一样,软件系统或软件产品也有一个定义、开发、运行维护直至被淘汰这样的全过程,我们把软件将要经历的这个全过程称为软件的生命周期。它包含:软件定义、软件...
  • 12.4.1 一个传统的层次结构 280 12.4.2 抽象类 283 12.4.3 其他实现方式 285 12.4.4 对象创建的局部化 287 12.5 类层次结构和抽象类 289 12.6 忠告 289 12.7 练习 289 第13章 模板 292 13.1 引言 292 13.2 ...
  • 13.2 一个简单的string模板 293 13.2.1 定义一个模板 294 13.2.2 模板实例化 295 13.2.3 模板参数 296 13.2.4 类型等价 296 13.2.5 类型检查 297 13.3 函数模板 298 13.3.1 函数模板的参数 299 13.3.2 函数...
  • C++程序设计语言(特别版)--源代码

    热门讨论 2012-04-23 07:33:51
    12.4.1 一个传统的层次结构 280 12.4.2 抽象类 283 12.4.3 其他实现方式 285 12.4.4 对象创建的局部化 287 12.5 类层次结构和抽象类 289 12.6 忠告 289 12.7 练习 289 第13章 模板 292 13.1 引言 292 13.2 ...
  • Code Compl 代码大全

    2011-05-26 12:09:22
     包含(“有一个……”的关系)  继承(“是一个……”关系)  成员函数和数据成员  构造函数  6.4 创建类的原因  应该避免的类  总结:创建类的理由  与具体编程语言相关的问题  6.6 超越类:包  更多...
  • 12.2 一个简单的代码生成程序 12.2.1 计算机模型 12.2.2 待用信息链表法 12.2.3 代码生成算法 12.3 几种常用的代码生成程序的开发方法 12.3.1 解释性代码生成法 12.3.2 模式匹配代码生成法 12.3.3 表驱动代码...
  • 数据库设计有几个范式,一般我们要做到的是第三范式,即数据表中没有冗余字段以及同一个表中的字段没有函数依赖关系,冗余字段即在一个表中已经保存过的信息,在另一个表中就不应该存在,如果需要的话,可以通过表间...

空空如也

空空如也

1 2
收藏数 39
精华内容 15
关键字:

一个等价关系确定一个划分