精华内容
下载资源
问答
  • 问题求解的一般过程: 数据表示的任务(数据的逻辑结构->数据的存储结构)  数值问题:用数学方程表示数据模型  非数值问题:线性表、树、图等结构 数据处理的任务  建立在数据模型的基础上进行设计,数据模型不同...

    数据表示的任务:数据的逻辑结构->数据的存储结构(顺序、链式、索引、散列)

    逻辑结构的二元组表示

    同一逻辑结构可以对应多种存储结构;设计存储结构,既存储元素又存储关系

    算法的设计—>实现,用程序表达还是用中间数据表达?



    一个好的算法,要考虑它的时间复杂度和空间复杂度


    程序就是在数据的某些特定表示方法和结构的基础上,对一个算法使用某种程序设计语言的具体实现

    展开全文
  • 基于贪心算法求解TSP问题 一TSP问题 TSP问题Travelling Salesman Problem即旅行商问题又译为旅行推销员问题货郎担问题是数学领域中著名问题之一假设有一个旅行商人要拜访n个城市他必须选择所要走路径路径限制是...
  • 第10章 问题求解与算法设计第10章 问题求解与...问题求解与算法设计问题求解过程问题求解的一般过程 明确问题理解问题方案设计方案选择解决步骤方案评价问题求解的计算机处理过程开始第10章 问题求解与算法设计x0Nx问题
  • 思维的过程才是最重要,我们要不止是金蛋,更是那只下金蛋鸡。 ———此类想法总结句 传说爱因斯坦出过这样一道逻辑题,此题有18个条件,要求大家最后推理出问题的答案。是否真为爱因斯坦所出我也无法考证,...

    思维的过程才是最重要的,我们要的不止是金蛋,更是那只下金蛋的鸡。

    ———此类想法总结句

    传说爱因斯坦出过这样一道逻辑题,此题有18个条件,要求大家最后推理出问题的答案。是否真为爱因斯坦所出我也无法考证,当然我想这只是出题人为了引起大家的注意罢了,但是题目本身还是挺有意思的,也属于实际生活中的问题了(别较真...)。我们先说说这道题本身:

    1、在一条街上,有5座房子,喷了5种颜色。 2、每个房子里住着不同国籍的人。 3、每个人喝着不同的饮料,抽不同品牌的香烟,养不同的宠物。 4、英国人住红色房子。5、瑞典人养狗。 6、丹麦人喝茶。 7、绿色房子在白色房子左面。 8、绿色房子主人喝咖啡。9、抽Pall Mall香烟的人养鸟。 10、黄色房子主人抽Dunhill香烟。 11、住在中间房子的人喝牛奶。 12、挪威人住第一间房。 13、抽Blends香烟的人住在养猫的人隔壁。 14、养马的人住抽Dunhill香烟的人隔壁。 15、抽Blue Master的人喝啤酒。 16、德国人抽Prince香烟。 17、挪威人住蓝色房子隔壁。 18、抽Blends香烟的人有一个喝水的邻居。 问:哪个国家的人养鱼?

    初见此题,若纯粹使用逻辑推理的方法是肯定做得出来的,但是若用计算机来求解此类实际问题,又应当如何去做呢?

    首先,面对这18个条件,我们既然要让计算机去做,就首先得把看似复杂的问题简单化(因为:一切复杂的东西都是由很多简单的事务所组成的——某名人名言),在计算机的领域里,就是我们所说的复杂度的控制问题。这里的复杂度有两个方面:第一、题目本身的复杂度;第二、针对题目编程的实现复杂度(程序是否容易实现、是否易懂、程序本身是否易读等等都需要我们考虑)。那么针对这个题目来说,条件这么多,我们如何下手呢?先别急,让我们现将题目大致浏览一下,找到里面所涉及的元素有哪些?通过阅读我们可以发现,这里涉及的元素有如下几个:房子(House)、房子颜色(HouseColor)、国籍(Nationality)、饮料(Beverage)、香烟(Cigarette)、宠物(Pets),找到元素以后,我们接下来去看一下元素之间的关系,找到其中自己感觉比较棘手的要点。通过对题目的大致浏览,我们不难发现,这些条件中最麻烦的部分,就是关于:隔壁、邻居、左面这些位置信息的表达。至于说类似:英国人住红色房子等等这一类条件,倒是很好转化为条件表达式。对于位置信息的表达,我们可以挖掘出一个隐含元素,那个就是门牌号(House number),通过对这一隐含元素的挖掘,我们就能够很好地处理好关于房子位置的信息了。这个时候我们可以初步做一些编程的“规划"了,这里为了提高程序的可读性(也是控制程序复杂度的一个方面!),我们使用枚举来进行对于不同种类的事务进行标识,具体如下:

    enum PET            //宠物
    {
        Dog = 0,
        Fish,
        Horse,
        Cat,
        Bird
    };
    
    enum HOUSECOLOR     //房子颜色
    {
        Red = 5,
        Green,
        Yellow,
        Blue,
        White
    };
    
    enum BEVERAGE       //饮料
    {
        Milk = 10,
        Coffee,
        Tea,
        Beer,
        Water
    };
    
    enum NATIONALITY    //国籍
    {
        Germany = 15,
        Norway,
        British,
        Sweden,
        Denmark
    };
    
    enum CIGARETTE      //香烟(品牌)
    {
        PallMall = 20,
        Dunhill,
        Blends,
        BlueMaster,
        Prince
    };

    为了容易编程,我们引入面向对象的设计思想,现在房子这么重要,我们就不以人为本了,哈哈,就以房子为本来进行设计(PS:当然,这个是开玩笑的啦,以房子为本的原因是由于房子位置关系的相对复杂性决定的,我们将房子定下来,并且对每个房子都强制一个唯一的门牌号,这样房子之间的相互关系就很好解决了)。另外,对于此题的问题是问:哪个国家的人养鱼,就是指明了涉及到的两个元素:国籍、宠物。我们写程序的时候就可以根据这两个要点要进行全方位的验证即可。验证的方法相当简单,就是在对关系条件的逐一验证而已,这里仅仅需要我们穷举出不同国籍与宠物之间的排列即可。(为什么是排列而不是组合呢?这里主要考虑到验证房子之间的关系上,因此属于排列问题,而不是组合问题)。即类似于以下:英国人养鸟住二号房子、德国人养马住三号房子这样。。。把所有的情况穷举出来,然后放到条件关系中去验证,满足所有条件的即为解。这样的求解在思路上属于最容易想到且在编程实现上也可行的一个方法,以下,我们先用这个方法来对此题求解【注意:现有后优!!! 一开始就绞尽脑汁去想各种优化和捷径往往使得程序在短时间内无法完成,所谓:过早的优化是万恶之源!!!,因此在短时间内快速找到可行的解决方案并编程处理是首要任务】,若十来分钟过去了,得出了如下的烂尾代码:

    typedef unsigned int UINT;
    enum HOUSECOLOR     //房子颜色
    {
        XColor  = -1,    //未知
        Red     =  0,
        Green,
        Yellow,
        Blue,
        White
    };
    
    enum BEVERAGE       //饮料
    {
        XDrink  = -1,   //未知
        Milk    =  0,
        Coffee,
        Tea,
        Beer,
        Water
    };
    
    enum NATIONALITY    //国籍
    {
        XNation  = -1,  //未知
        Norway  =   0,
        Germany,
        British,
        Sweden,
        Denmark
    };
    
    enum CIGARETTE      //香烟(品牌)
    {
        XCigar   = -1,  //未知
        PallMall =  0,
        Dunhill,
        Blends,
        BlueMaster,
        Prince
    };
    
    enum PET            //宠物
    {
        XPet    = -1,   //未知
        Dog     =  0,
        Fish,
        Horse,
        Cat,
        Bird
    };
    
    class House
    {
    public:
        House( const int iHouseNum,
               HOUSECOLOR eColor    = XColor,
               CIGARETTE eCigar     = XCigar, 
               BEVERAGE eDrink      = XDrink,
               NATIONALITY eNation  = XNation, 
               PET ePet             = XPet )
               : m_iHouseNum( iHouseNum ),
                 m_eColor( eColor ),
                 m_eCigar( eCigar ),
                 m_eDrink( eDrink ),
                 m_eNation( eNation ),
                 m_ePet( ePet )
        {
    
        }
        ~House(){}
    public:
        //Relationship
        bool IsOnLeftSide( const House &objHouse )
        {
            return 1 == (m_iHouseNum - objHouse.m_iHouseNum);
        }
    
        bool IsOnRightSide( const House &objHouse )
        {
            return -1 == (m_iHouseNum - objHouse.m_iHouseNum);
        }
    
        bool IsNeighbour( const House &objHouse )
        {
            return 1 == abs(m_iHouseNum - objHouse.m_iHouseNum );
        }
    
    public:
        //Setter and Getter
        void SetCigar( const CIGARETTE eCigar ) { m_eCigar = eCigar; }
        void SetHouseColor( const HOUSECOLOR eColor ) { m_eColor = eColor; }
        void SetBeverage( const BEVERAGE eDrink ) { m_eDrink = eDrink; }
        void SetNationality(const NATIONALITY eNation ) { m_eNation = eNation; }
        void SetPet( const PET ePet ) { m_ePet = ePet; }
    
        const CIGARETTE GetCigar( void ) const { return m_eCigar; }
        const HOUSECOLOR GetHouseColor( void ) const { return m_eColor; }
        const BEVERAGE GetBeverage( void ) const { return m_eDrink; }
        const NATIONALITY GetNationality( void ) const { return m_eNation; }
        const PET GetPet( void ) const { return m_ePet; }
        const int GetHouseNum( void ) const { return m_iHouseNum; }
    
    private:
        CIGARETTE       m_eCigar;
        HOUSECOLOR      m_eColor;
        BEVERAGE        m_eDrink;
        NATIONALITY     m_eNation;
        PET             m_ePet;
        int             m_iHouseNum;
    };
    
    int main()
    {
        House rgpHouses[5] = { obj_1, obj_2, obj_3, obj_4, obj_5 };
        for (UINT i=1; i<5; ++i)                                //British
        {
            for (UINT j=1; j<5; ++j)                            //Germany
            {
                for (UINT k=1; k<5; ++k)                        //Sweden
                {
                    for (UINT l=1; l<5; ++l)                    //Denmark
                    {
                        for (UINT m=1; m<5; ++m)                //Fish
                        {
                            for (UINT n=1; n<5; ++n)            //Horse
                            {
                                for (UINT o=1; o<5; ++n)        //Cat
                                {
                                    for (UINT p=1; p<5; ++p)    //Bird
                                    {
                                        rgpHouses[i].SetNationality( British );
                                        rgpHouses[i].SetHouseColor( Red );
    
                                        rgpHouses[j].SetNationality( Germany );
                                        rgpHouses[j].SetCigar(Prince);
    
                                        rgpHouses[k].SetNationality( Sweden );
                                        rgpHouses[k].SetPet( Dog );
    
                                        rgpHouses[l].SetNationality( Denmark );
                                        rgpHouses[l].SetBeverage( Tea );
                                    }
                                }
                            }
    
                        }
                       
                    }
                }
            }
        }
    }   //此代码为烂尾代码,循环体内的赋值有明显的问题!!!导致思路无法继续下去!!!

    结果发现纯粹使用面向过程的方法,自己竟然无法顺利地解出这道题,在表述复杂性降低的情况下,部分穷举以及方便验证上的复杂度并没有得到实质性地降低。因此得重新寻找比较好的解法。于是我重新阅读题目,这次我进行了另外的尝试,首先将题目条件进行分类,分为:断言条件与关系条件,顾名思义,对于断言条件就是指的类似:什么是什么,什么就什么的这样的条件,例如:英国人住红房子,挪威人养狗等等;而关系条件指的是:谁跟谁有什么关系之类的这样的表示,例如:养马的人住抽Dunhill香烟的人隔壁。根据题目我们可以得到下面的这个分类表格:

    条件分析表
    断言条件 关系条件
    英国人住红色房子
    绿色房子在白色房子左面
    瑞典人养狗 
    抽Blends香烟的人住在养猫的人隔壁
    丹麦人喝茶  
    养马的人住抽Dunhill香烟的人隔壁
    绿色房子主人喝咖啡
    挪威人住蓝色房子隔壁
    抽Pall Mall香烟的人养鸟
    抽Blends香烟的人有一个喝水的邻居
    黄色房子主人抽Dunhill香烟

    住在中间房子的人喝牛奶

    挪威人住第一间房

    抽Blue Master的人喝啤酒

    德国人抽Prince香烟
     

    得到如下分析:

    门牌号:     01                    02                     04                    08                     10

                         0000-0001     0000-0010      0000-0100      0000-1000      0001-0000  (默认未知为:0x00h)
    国籍:         挪威                 德国                 英国                  瑞典                丹麦
    颜色:         黄                     蓝                     红                      绿                    白
    饮料:         啤酒                 水                     牛奶                  咖啡                茶
    香烟牌子: Dunhill             Prince              Blends             BlueMaster     PallMall
    宠物             Fish                 Horse               Cat                   Dog                 Bird         


    按照:门牌号、国籍、颜色、饮料、香烟牌子、宠物,这样的顺序排列,          
    例如:英国人住红色房子在2号房间喝水养鸟抽PallMall烟就可以表示为:0x020404021010 (6个字节)
    设置条件的方法例如: 0xF2FFFF 表示英国。

                                          门牌号   国籍   颜色   饮料   香烟牌子   宠物 

    断言条件:                   0   1  2  3  4  5
    英国人住红色房子0x000404000000   (判断方法and 0x000404000000,若为0或还是为其本身都满足条件,否则不满足)
    瑞典人养狗0x000800000008   (判断方法and 0x000800000008,若为0或还是为其本身都满足条件,否则不满足)
    丹麦人喝茶0x001000100000   同上思路,略之。
    绿色房子主人喝咖啡0x000008080000
    抽Pall Mall香烟的人养鸟0x000000001010 
    黄色房子主人抽Dunhill香烟0x000001000100
    住在中间房子的人喝牛奶0x040000040000
    挪威人住第一间房0x010100000000
    抽Blue Master的人喝啤酒0x000000010800     
    德国人抽Prince香烟0x000200000200

    关系条件:
    绿色房子在白色房子左面。               
    抽Blends香烟的人住在养猫的人隔壁
    养马的人住抽Dunhill香烟的人隔壁
    挪威人住蓝色房子隔壁===>蓝色房子是第二间房(由关系条件转化为了断言条件

    抽Blends香烟的人有一个喝水的邻居

    然而,思考到这里有一个新的问题产生了,首先判断用的数据占有6个字节,因此不好使用恰当的内置数据类型进行直接的数据判断(不是大了就是小了),只能使用诸如数组这样的类型来进行相应的判断,而这个时候,就无法使用直接“与”操作来进行判断了。这个时候,反过来考虑一下是否真需要采用“与”操作的这种类型判断呢?!问题的核心究竟是什么呢?!——想要过滤出符合断言条件的不同组合,进而求解出答案!若单纯使用数组判断的话该如何判断比较好呢?再次观察条件我们不难发现,起先我们为了采用“与”判断而对判断数据进行了“特殊”的位设计,现在由于设计的数据大小不太适合内置数据类型的直接操作,而导致“与”操作的优越性无法体现出来,反而成了累赘。当前就需要我们做一个取舍了?!是否要废弃这种按照与操作设计的数据格式!同时对于条件,正向判断的确不是很容易,那么我们是否能够换一个角度去看问题,比如说去逆向判断,例如:英国人住红色的房子,其反面就是英国人不住红色的房子或者红色房子里住的不是英国人!这样一想,我们重新试着去设计新的判断方法及判断数据。还是沿用如下的组合,只不过数据的表现形式变一下,不用采用位来设计了,而是简单的计数标记。

    门牌号:     01                    02                        03                     04                     5

    国籍:         挪威                 德国                 英国                  瑞典                丹麦
    颜色:         黄                     蓝                     红                      绿                    白
    饮料:         啤酒                 水                     牛奶                  咖啡                茶
    香烟牌子: Dunhill             Prince              Blends             BlueMaster     PallMall
    宠物             Fish                 Horse               Cat                   Dog                 Bird         

    同时,为了兼顾显示的需要,对应组合表可以设计出如下的对应,显示字符:

    //门牌号:   1           2           3           4           5
    //国籍:     挪威        德国        英国        瑞典        丹麦
    //颜色:     黄          蓝          红          绿          白
    //饮料:     啤酒        水          牛奶        咖啡        茶
    //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
    //宠物:     Fish        Horse       Cat         Dog         Bird
    char *pstrsNationality[5] = { "挪威", "德国", "英国", "瑞典", "丹麦" };
    char *pstrsHouseColor[5]  = { "黄", "蓝", "红", "绿", "白" };
    char *pstrsBeverage[5]    = { "啤酒", "水", "牛奶", "咖啡", "茶" };
    char *pstrsCigarette[5]   = { "Dunhill", "Prince", "Blends", "BlueMaster", "PallMall" };
    char *pstrsPet[5]         = { "Fish", "Horse", "Cat", "Dog", "Bird" };
    有了这个一一对应,我们设计程序的第一道过滤就水到渠成了!

    首先根据断言条件进行的第一层过滤设计如下:

    设i、j、k、m、n、o分别代表:门牌号、国籍、颜色、饮料、香烟牌子、宠物。

        for (UCHAR i=1; i<6; ++i)                      //门牌号
        {
            for (UCHAR j=1; j<6; ++j)                  //国籍
            {
                for (UCHAR k=1; k<6; ++k)              //颜色
                {
                    for (UCHAR m=1; m<6; ++m)          //饮料
                    {
                       for (UCHAR n=1; n<6; ++n)       //香烟牌子
                        {
                           for (UCHAR o=1; o<6; ++o)   //宠物
                           {   //门牌号:   1           2           3           4           5
                               //国籍:     挪威        德国        英国        瑞典        丹麦
                               //颜色:     黄          蓝          红          绿          白
                               //饮料:     啤酒        水          牛奶        咖啡        茶
                               //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
                               //宠物:     Fish        Horse       Cat         Dog         Bird 
                                //(否)1.英国人住红色房子
                                if ( 3==j&&3!=k || 3==k&&3!=j )
                                    continue;
                                //(否)2.瑞典人养狗
                                if ( 4==j&&4!=o || 4==o&&4!=j )
                                    continue;
                                //(否)3.丹麦人喝茶
                                if ( 5==j&&5!=m || 5==m&&5!=j )
                                    continue;
                                //(否)4.绿色房子主人喝咖啡
                                if ( 4==k&&4!=m || 4==m&&4!=k )
                                    continue;
                                //(否)5.抽Pall Mall香烟的人养鸟
                                if ( 5==n&&5!=o || 5==o&&5!=n )
                                    continue;
                                //(否)6.黄色房子主人抽Dunhill香烟
                                if ( 1==k&&1!=n || 1==n&&1!=k )
                                    continue;
                                //(否)7.住在中间房子的人喝牛奶
                                if ( 3==i&&3!=m || 3==m&&3!=i )
                                    continue;
                                //(否)8.挪威人住第一间房 
                                if ( 1==j&&1!=i || 1==i&&1!=j )
                                    continue;
                                //(否)9.抽Blue Master的人喝啤酒
                                if ( 1==m&&4!=n || 4==n&&1!=m )
                                    continue;
                                //(否)10.德国人抽Prince香烟
                                if ( 2==j&&2!=n || 2==n&&2!=j )
                                    continue;
                                //(否)11.蓝色房子是第二间房
                                if ( 2==i&&2!=k || 2==k&&2!=i )
                                    continue;
    
                                printf("%d %d %d %d %d %d \n", i,j,k,m,n,o);
                            }
                        }
                    }
                }
            }
        }
    这样很容易就达到了第一层过滤的目的。于此同时,我们还需要对第二层过滤做一个准备!第二层的过滤,即:对应关系条件的过滤,通过上面已有的分析。关系条件为:

    1、绿色房子在白色房子左面。                           
    2、抽Blends香烟的人住在养猫的人隔壁。
    3、养马的人住抽Dunhill香烟的人隔壁。
    4、抽Blends香烟的人有一个喝水的邻居。

    对应关系条件判断的方法,我也可以分别从正反两个方面来进行分析:

    首先正面分析:以关系条件1为例,绿色房子在白色房子的左面。那么若碰到绿色房子,则必须遍历出另外房子为白色且房号减去绿色房子房号为-1则满足条件。同理对应白色房子,也要遍历出绿色房子且房号减去白房子为1。

    然后反面分析:绿色房子不在白色房子左面,还是需要去遍历并判断。

    因此得出一个简单的结论,正面或者反面分析对此条件判断难度基本等价。那么我们就采取大家容易思考的正向判断方法,同时在判断前先做好准备工作。首先将不同房间的情况做一个分组。经过第一次的过滤可以完成这个操作:将属于不同的房间号的情况各自放到对应的地方。由于各个房号对应的情况数量无法立即确定,所以用到的容器要求是可变容的。这里我们“偷偷懒”直接用标准C++里面提供的vector容器算了。这样我们需要五个容器对应不同的房间,将属于不同房间的情况一一放入,容器里面的元素我们采用std::string来存储。然后针对不同的情况进行判断。五个容器的处理与一个容器的处理在本质上其实是一样的,因此根据以上的思路,很容易获得如下程序:

    //门牌号:   1           2           3           4           5
    //国籍:     挪威        德国        英国        瑞典        丹麦
    //颜色:     黄          蓝          红          绿          白
    //饮料:     啤酒        水          牛奶        咖啡        茶
    //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
    //宠物:     Fish        Horse       Cat         Dog         Bird
    char *pstrsNationality[5] = { "挪威", "德国", "英国", "瑞典", "丹麦" };
    char *pstrsHouseColor[5]  = { "黄", "蓝", "红", "绿", "白" };
    char *pstrsBeverage[5]    = { "啤酒", "水", "牛奶", "咖啡", "茶" };
    char *pstrsCigarette[5]   = { "Dunhill", "Prince", "Blends", "BlueMaster", "PallMall" };
    char *pstrsPet[5]         = { "Fish", "Horse", "Cat", "Dog", "Bird" };
    
    int main()
    {
        size_t tNum_1 = 0;
        size_t tNum_2 = 0;
        size_t tNum_3 = 0;
        size_t tNum_4 = 0;
        size_t tNum_5 = 0;
        std::vector<std::string>  rgpConditions;
    
        //第一阶段循环
        for (UCHAR i=1; i<6; ++i)                      //门牌号
        {
            for (UCHAR j=1; j<6; ++j)                  //国籍
            {
                for (UCHAR k=1; k<6; ++k)              //颜色
                {
                    for (UCHAR m=1; m<6; ++m)          //饮料
                    {
                       for (UCHAR n=1; n<6; ++n)       //香烟牌子
                        {
                           for (UCHAR o=1; o<6; ++o)   //宠物
                           {   //门牌号:   1           2           3           4           5
                               //国籍:     挪威        德国        英国        瑞典        丹麦
                               //颜色:     黄          蓝          红          绿          白
                               //饮料:     啤酒        水          牛奶        咖啡        茶
                               //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
                               //宠物:     Fish        Horse       Cat         Dog         Bird 
                                //(否)1.英国人住红色房子
                                if ( 3==j&&3!=k || 3==k&&3!=j )
                                    continue;
                                //(否)2.瑞典人养狗
                                if ( 4==j&&4!=o || 4==o&&4!=j )
                                    continue;
                                //(否)3.丹麦人喝茶
                                if ( 5==j&&5!=m || 5==m&&5!=j )
                                    continue;
                                //(否)4.绿色房子主人喝咖啡
                                if ( 4==k&&4!=m || 4==m&&4!=k )
                                    continue;
                                //(否)5.抽Pall Mall香烟的人养鸟
                                if ( 5==n&&5!=o || 5==o&&5!=n )
                                    continue;
                                //(否)6.黄色房子主人抽Dunhill香烟
                                if ( 1==k&&1!=n || 1==n&&1!=k )
                                    continue;
                                //(否)7.住在中间房子的人喝牛奶
                                if ( 3==i&&3!=m || 3==m&&3!=i )
                                    continue;
                                //(否)8.挪威人住第一间房 
                                if ( 1==j&&1!=i || 1==i&&1!=j )
                                    continue;
                                //(否)9.抽Blue Master的人喝啤酒
                                if ( 1==m&&4!=n || 4==n&&1!=m )
                                    continue;
                                //(否)10.德国人抽Prince香烟
                                if ( 2==j&&2!=n || 2==n&&2!=j )
                                    continue;
                                //(否)11.蓝色房子是第二间房
                                if ( 2==i&&2!=k || 2==k&&2!=i )
                                    continue;
                                
                                std::string objStrCondition;
                                objStrCondition.push_back( i );
                                objStrCondition.push_back( j );
                                objStrCondition.push_back( k );
                                objStrCondition.push_back( m );
                                objStrCondition.push_back( n );
                                objStrCondition.push_back( o );
                                rgpConditions.push_back( objStrCondition );
                                if ( 1 == i ) ++tNum_1;
                                if ( 2 == i ) ++tNum_2;
                                if ( 3 == i ) ++tNum_3; 
                                if ( 4 == i ) ++tNum_4; 
                                if ( 5 == i ) ++tNum_5;
                            }
                        }
                    }
                }
            }
        }
        
        tNum_2 += tNum_1;
        tNum_3 += tNum_2;
        tNum_4 += tNum_3;
        tNum_5 += tNum_4;
    
        //第二层过滤求得结果:
        for ( size_t t_1=0; t_1<tNum_1; ++t_1)
        {
            for (size_t t_2=tNum_1; t_2<tNum_2; ++t_2)
            {
                for (size_t t_3=tNum_2; t_3<tNum_3; ++t_3)
                {
                    for (size_t t_4=tNum_3; t_4<tNum_4; ++t_4)
                    {
                        for (size_t t_5=tNum_4; t_5<tNum_5; ++t_5)
                        {
                             UINT uNationality = rgpConditions[t_1][1]+
                                                rgpConditions[t_2][1]+
                                                rgpConditions[t_3][1]+
                                                rgpConditions[t_4][1]+
                                                rgpConditions[t_5][1];
    
                            UINT uColor   = rgpConditions[t_1][2]+
                                            rgpConditions[t_2][2]+
                                            rgpConditions[t_3][2]+
                                            rgpConditions[t_4][2]+
                                            rgpConditions[t_5][2];
    
                            UINT uBeverage  = rgpConditions[t_1][3]+
                                              rgpConditions[t_2][3]+
                                              rgpConditions[t_3][3]+
                                              rgpConditions[t_4][3]+
                                              rgpConditions[t_5][3];
    
                            UINT uCigar  = rgpConditions[t_1][4]+
                                           rgpConditions[t_2][4]+
                                           rgpConditions[t_3][4]+
                                           rgpConditions[t_4][4]+
                                           rgpConditions[t_5][4];
    
                            UINT uPet    = rgpConditions[t_1][5]+
                                           rgpConditions[t_2][5]+
                                           rgpConditions[t_3][5]+
                                           rgpConditions[t_4][5]+
                                           rgpConditions[t_5][5];
                            if ( 15 != uNationality ||
                                 15 != uColor || 15 != uBeverage ||
                                 15 != uCigar || 15 != uPet )
                                    continue;
    
                            //1、绿色房子在白色房子左面。
                            bool bV1(false),bV2(false),bV3(false),bV4(false);
                            if ( 4 == rgpConditions[t_1][2] && 5 == rgpConditions[t_2][2] ||
                                 4 == rgpConditions[t_2][2] && 5 == rgpConditions[t_3][2]  ||
                                 4 == rgpConditions[t_3][2] && 5 == rgpConditions[t_4][2] ||
                                 4 == rgpConditions[t_4][2] && 5 == rgpConditions[t_5][2] )
                                bV1 = true;
    
                            //2、抽Blends香烟的人住在养猫的人隔壁。
                            if ( 3 == rgpConditions[t_1][4] && 3 == rgpConditions[t_2][5] ||
                                 3 == rgpConditions[t_2][4] && 3 == rgpConditions[t_3][5] ||
                                 3 == rgpConditions[t_3][4] && 3 == rgpConditions[t_4][5] ||
                                 3 == rgpConditions[t_4][4] && 3 == rgpConditions[t_5][5] ||
                                 3 == rgpConditions[t_1][5] && 3 == rgpConditions[t_2][4] ||
                                 3 == rgpConditions[t_2][5] && 3 == rgpConditions[t_3][4] ||
                                 3 == rgpConditions[t_3][5] && 3 == rgpConditions[t_4][4] ||
                                 3 == rgpConditions[t_4][5] && 3 == rgpConditions[t_5][4])
                                bV2 = true;
    
                            //3、养马的人住抽Dunhill香烟的人隔壁。
                            if ( 1 == rgpConditions[t_1][4] && 2 == rgpConditions[t_2][5] ||
                                 1 == rgpConditions[t_2][4] && 2 == rgpConditions[t_3][5] ||
                                 1 == rgpConditions[t_3][4] && 2 == rgpConditions[t_4][5] ||
                                 1 == rgpConditions[t_4][4] && 2 == rgpConditions[t_5][5] ||
                                 2 == rgpConditions[t_1][5] && 1 == rgpConditions[t_2][4] ||
                                 2 == rgpConditions[t_2][5] && 1 == rgpConditions[t_3][4] ||
                                 2 == rgpConditions[t_3][5] && 1 == rgpConditions[t_4][4] ||
                                 2 == rgpConditions[t_4][5] && 1 == rgpConditions[t_5][4])
                                bV3 = true;
                            //4、抽Blends香烟的人有一个喝水的邻居。
                            if ( 2 == rgpConditions[t_1][3] && 3 == rgpConditions[t_2][4] ||
                                 2 == rgpConditions[t_2][3] && 3 == rgpConditions[t_3][4] ||
                                 2 == rgpConditions[t_3][3] && 3 == rgpConditions[t_4][4] ||
                                 2 == rgpConditions[t_4][3] && 3 == rgpConditions[t_5][4] ||
                                 3 == rgpConditions[t_1][4] && 2 == rgpConditions[t_2][3] ||
                                 3 == rgpConditions[t_2][4] && 2 == rgpConditions[t_3][3] ||
                                 3 == rgpConditions[t_3][4] && 2 == rgpConditions[t_4][3] ||
                                 3 == rgpConditions[t_4][4] && 2 == rgpConditions[t_5][3])
                                bV4 = true;
                            if ( bV1 && bV2 && bV3 && bV4 )
                            {
                                printf("OK! The Result is:\n");
                                printf("%d %s %s %s %s %s\n", 
                                    rgpConditions[t_1][0],
                                    pstrsNationality[rgpConditions[t_1][1]-1],
                                    pstrsHouseColor[rgpConditions[t_1][2]-1],
                                    pstrsBeverage[rgpConditions[t_1][3]-1],
                                    pstrsCigarette[rgpConditions[t_1][4]-1],
                                    pstrsPet[rgpConditions[t_1][5]-1]);
    
                                printf("%d %s %s %s %s %s\n", 
                                    rgpConditions[t_2][0],
                                    pstrsNationality[rgpConditions[t_2][1]-1],
                                    pstrsHouseColor[rgpConditions[t_2][2]-1],
                                    pstrsBeverage[rgpConditions[t_2][3]-1],
                                    pstrsCigarette[rgpConditions[t_2][4]-1],
                                    pstrsPet[rgpConditions[t_2][5]-1]);
    
                                printf("%d %s %s %s %s %s\n", 
                                    rgpConditions[t_3][0],
                                    pstrsNationality[rgpConditions[t_3][1]-1],
                                    pstrsHouseColor[rgpConditions[t_3][2]-1],
                                    pstrsBeverage[rgpConditions[t_3][3]-1],
                                    pstrsCigarette[rgpConditions[t_3][4]-1],
                                    pstrsPet[rgpConditions[t_3][5]-1]);
    
                                printf("%d %s %s %s %s %s\n", 
                                    rgpConditions[t_4][0],
                                    pstrsNationality[rgpConditions[t_4][1]-1],
                                    pstrsHouseColor[rgpConditions[t_4][2]-1],
                                    pstrsBeverage[rgpConditions[t_4][3]-1],
                                    pstrsCigarette[rgpConditions[t_4][4]-1],
                                    pstrsPet[rgpConditions[t_4][5]-1]);
    
                                printf("%d %s %s %s %s %s\n", 
                                    rgpConditions[t_5][0],
                                    pstrsNationality[rgpConditions[t_5][1]-1],
                                    pstrsHouseColor[rgpConditions[t_5][2]-1],
                                    pstrsBeverage[rgpConditions[t_5][3]-1],
                                    pstrsCigarette[rgpConditions[t_5][4]-1],
                                    pstrsPet[rgpConditions[t_5][5]-1]);
                            }
                            
                        }
                    }
                }
            }
        }
    }
    虽然获得了正确的结果(如图):

    但是整个程序看起来是相当繁琐,而且特别容易弄错(编程的时候由于数字与意义的对应问题),对调试也不利,我们当如何改进呢?首先,一开始我们想到的枚举变量可以保留,用来作为数字与意义的对应,这样编程的时候不容易出错!!!(这点相当重要)。另外对应关系条件的判断上,是否能够采取更加便捷的方式?!这也是接下来优化的目标所在。另外整个程序的算法复杂度为O(n^6),是否能够优化?!在做优化之前,我们回到文章的题目,来稍微总结一下这个思维过程:

    1、分清楚数据与条件,将数据用容易且合适的方式表示出来;

    2、接下来对条件进行详细地分析,将条件进行细分,同时将复杂条件转换为简单条件;

    3、对于不同的条件思考如何使用计算机语言做判断,分别从正向与反向充分思考;

    4、综合数据与条件关系,思考解题策略:即算法的初步构思【要求可行即可,不用过于强调优化!】

    5、根据算法写出相应的程序;

    6、对程序进行算法与编写本身的优化。

    7、获取更好更优的程序。

    对于此题的优化,放到由一道逻辑推理题衍生的对于实际问题求解的一般思路(续)里面再记录一下。

    展开全文
  • CFD的求解过程

    千次阅读 2018-07-07 15:49:39
    总体计算流程 无论是流动问题、传热问题,还是污染物运移问题,无论是稳态问题还是瞬态问题,其求解过程都可以用下图表示。1.建立控制方程建立控制方程是求解任何问题前都必须首先进行一般的流体流动可根据...

    总体计算流程

      无论是流动问题、传热问题,还是污染物的运移问题,无论是稳态问题还是瞬态问题,其求解过程都可以用下图表示。

    1.建立控制方程

    建立控制方程是求解任何问题前都必须首先进行的。一般的流体流动可根据之前的流体控制方程直接给出。当处于湍流时要添加湍流方程。

    2.确定边界条件与初始条件

    初始条件与边界条件是控制方程有确定解的前提,控制方程与相应的初始条件、边界条件的组合构成对一个物理过程完整的数学描述。

    初始条件是所研究对象在过程开始时刻各个求解变量的空间分布情况。对于瞬态问题必须给定初始条件。对于稳态问题,不需要初始条件。

    边界条件是在求解区域的边界上所求解的变量或其导数随地点和时间的变化规律。对于任何问题都需要给定边界条件。

    3.划分计算网格

    采用数值方法求解控制方程时,都是想办法将控制方程在空间区域上进行离散,然后求解得到的离散方程组。要想在空间域上离散控制方程,必须使用网格。现已发展出多种对各种区域进行离散以生成网格的办法,统称为网格生成技术。网格的生产过程就是计算平面到物理平面的坐标映射过程。

    不同的问题采用不同的数值解法时,所需要的网格形式是有一定的区别的,但生成网格的办法基本一致,目前网格分为结构网格和非结构网格两大类。简单来讲,结构网格在空间上比较规范,而非结构网格在空间分布上没有明显的行线和列线。结构化网格生成方法有:代数方法生成网格、椭圆形微分方程方法生成网格和Thomas&Middlecoff方法生成网格。非结构化网格生成技术有:四叉树(二维)/八叉树(三维)方法、Delaunay方法、阵面推进法。

    4.建立离散方程

    对于在求解域内所建立的偏微分方程,理论上是有真解的(精确解或解析解)。但是由于所处理的问题自身的复杂性,一般很难获得方程的真解。因此,就需要通过数值方法把计算域内有限数量位置(网格节点或网格中心点)上的因变量当作基本未知量来处理,从而建立起一组关于这些未知量的代数方程组,通过求解代数方程组来得到这些节点值,从而计算域内其他位置上的值则根据节点位置上的值来确定。

    由于所引入的应变量在节点之间的分布假设及推导离散化方程的方法不同,就形成了有限差分法(FDM)、有限体积法(DVM)、有限元法(FEM)等不同的离散化方法。对于瞬态问题,除了在空间域上的离散外,还要涉及在时间域上的离散。离散后,将要涉及使用何种时间积分方案的问题。

    5.离散初始条件和边界条件

    前面所给的初始条件和初始边界是连续的,现在需要针对所生产的网格,将连续性的初始条件和边界条件转化为特定节点上的值。这样连同在上一阶段生产的离散控制方程才能对方程组进行求解。在商业CFD软件中,往往在前处理阶段完成网格划分后,直接在边界上指定初始条件和边界条件,然后由前处理软件自动将这些初始条件和边界条件按离散的方式分配到相应的节点上去。

    6.给定求解控制参数

    在离散空间上建立了离散化的代数方程组,并施加离散化的初始条件和边界条件后,还需要给定流体的物理参数个湍流模型的经验系数。此外,还要给定迭代计算的控制精度、瞬态问题的时间步长和输出频率等。

    7.求解离散方程

    在进行上述设置后,生产了具有定解条件的代数方程组。对于这些方程组数学上已有相应的解法,如线性方程组可采用Gauss消去法或Gauss-Seidel迭代法求解。商用CFD软件往往提供不同的解法,以适应不同类型的问题。这属于求解器设置的范畴。

    8.判断解的收散性

    对于稳态问题的解,或是瞬态问题在某个特定时间步上的解,往往要通过多次迭代才能得到。有时因为网格形式或网格大小、对流项的离散插值格式等原因,可能导致解的发散。对于瞬态问题,若采用显式格式进行时间域上的积分,当时间步长过大时,也可能造成解的振荡或发散。因此,在迭代过程中,要对解的收敛性随时监视,并在系统达到指定精度后结束迭代过程。

    9.显示和输出计算结果

    通过上述求解过程得到个计算节点上的解后,需要通过适当的手段将整个计算域上的结果表示出来。这是,我们可以采用线值图、矢量图、等值线图、流线图、云图等方式。


    展开全文
  • 接上次关于逻辑推理题分析,这次我们需要对上次思路做一个反思,同时整理出更优方法出来,一方面,帮助我们能够快速地找到解决问题的思路,同时能够提供一个良好解决方案。还记得上次分析当中,我们采用...

    接上次的关于逻辑推理题的分析,这次我们需要对上次的思路做一个反思,同时整理出更优的方法出来,一方面,帮助我们能够快速地找到解决问题的思路,同时能够提供一个良好解决方案。还记得上次的分析当中,我们采用面向对象的方法做了一次简单的尝试,但是由于思路的不完整性或者说部分的方向偏差导致不得不中断而采用其他的面向过程的解决方案。现在我们已经有了一个可行的方案了,在这个前提下,我们再次尝试一下更加令人容易想到且容易理解的,采用面向对象的方法进行全方位的思考解题。将逻辑问题转变成计算机能够处理的数据,并得出我们所需要的结论。OK,先回顾一下上次关于面向对象的方法进行思考的过程。我们为什么会采取以房子为中心而不是以人为中心进行设计呢?!当时的原因是:由于条件中最难使用计算机语言表达的是关于关系的条件,而这些关系是与房子本身紧密相关的例如:左面、邻居、隔壁等等,这些关系都是与房子直接相关的,我们需要使用房间号来进行判定的。因此我们为了让这个难以表述的条件得到良好的表述,我们采用了以房子为中心的设计方案。但是在这个思考的过程中,却犯了一个错误:那就是没有完全搞清楚定了什么条件要推导或者说要验证什么的问题。结果在写验证过的时候出现了逻辑混乱的现象。现在让我们还原当时的过程,重新整理一下思路:我们一开始想到要用枚举来使得程序的可读性增强且容易我们编程的时候思路的清晰,这点是没有问题的,另外我们采用了面向对象的思考方法,将所有相关的属性作为一个类,并且对于比较“棘手”的判断设计了相应的方法,这点也是没有问题的,那么问题出在哪儿呢?换句话说,这个程序最后烂尾到哪个地方了呢?我们再看看烂尾的代码,明显地,我们可以发现我们的出发点有个地方出了问题,我们需要的是对不同情况的一个穷举,而不是对某个特定的情况进行挨个“组合”。也就是在循环的地方出了问题,导致了代码烂尾了,换句话说就是在对条件的使用上出现了思维混乱的问题,现在我们重新调整一下思路,现在已经知道,假设我们把房子定下来,弄了五个房子对象,这个时候我可以根据要求进行设置,但是不可避免地要碰到一个排列的问题。一方面我们想快速解决问题,另外一方面我们又想规避一下排列的问题,毕竟排列需要涉及到的操作也是相对毕竟繁琐的。这个时候我们单纯地去定房子意义已经不大了,那么我们能否这样来考虑呢,将房子这个类的使用进行一下改变,不一开始进行房子的制定,而是继续沿用之前我们的方法,不过这次不论是从程序的可读性上来说还是判断条件的转换来说相比上次都要方便了许多!部分代码如下所示:

    //门牌号:   1           2           3           4           5
    //国籍:     挪威        德国        英国        瑞典        丹麦
    //颜色:     黄          蓝          红          绿          白
    //饮料:     啤酒        水          牛奶        咖啡        茶
    //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
    //宠物:     Fish        Horse       Cat         Dog         Bird
    
    enum HOUSECOLOR     //房子颜色
    {
        Yellow  =  1,
        Blue,
        Red,
        Green,
        White
    };
    
    enum BEVERAGE       //饮料
    {
        Beer    =  1,
        Water,
        Milk,
        Coffee,
        Tea
    };
    
    enum NATIONALITY    //国籍
    {
        Norway  =   1,
        Germany,
        British,
        Sweden,
        Denmark
    };
    
    enum CIGARETTE      //香烟(品牌)
    {
        Dunhill =  1,
        Prince,
        Blends,
        BlueMaster,
        PallMall
    };
    
    enum PET            //宠物
    {
        Fish    =  1,
        Horse,
        Cat,
        Dog,
        Bird
    };
    
    class House
    {
    public:
        House( const int iHouseNum,
               NATIONALITY eNation, 
               HOUSECOLOR eColor,
               BEVERAGE eDrink,
               CIGARETTE eCigar, 
               PET ePet )
                : m_iHouseNum( iHouseNum ),
                  m_eColor( eColor ),
                  m_eCigar( eCigar ),
                  m_eDrink( eDrink ),
                  m_eNation( eNation ),
                  m_ePet( ePet )
        {
    
        }
        ~House(){}
    public:
        //Relationship
        bool IsOnLeftSide( const House &objHouse )
        {
            return 1 == (m_iHouseNum - objHouse.m_iHouseNum);
        }
    
        bool IsOnRightSide( const House &objHouse )
        {
            return -1 == (m_iHouseNum - objHouse.m_iHouseNum);
        }
    
        bool IsNeighbour( const House &objHouse )
        {
            return 1 == abs(m_iHouseNum - objHouse.m_iHouseNum );
        }
    
    public:
        //Setter and Getter
        //void SetCigar( const CIGARETTE eCigar ) { m_eCigar = eCigar; }
        //void SetHouseColor( const HOUSECOLOR eColor ) { m_eColor = eColor; }
        //void SetBeverage( const BEVERAGE eDrink ) { m_eDrink = eDrink; }
        //void SetNationality(const NATIONALITY eNation ) { m_eNation = eNation; }
        //void SetPet( const PET ePet ) { m_ePet = ePet; }
    
        const CIGARETTE GetCigar( void ) const { return m_eCigar; }
        const HOUSECOLOR GetHouseColor( void ) const { return m_eColor; }
        const BEVERAGE GetBeverage( void ) const { return m_eDrink; }
        const NATIONALITY GetNationality( void ) const { return m_eNation; }
        const PET GetPet( void ) const { return m_ePet; }
        const int GetHouseNum( void ) const { return m_iHouseNum; }
    
    private:
        CIGARETTE       m_eCigar;
        HOUSECOLOR      m_eColor;
        BEVERAGE        m_eDrink;
        NATIONALITY     m_eNation;
        PET             m_ePet;
        int             m_iHouseNum;
    };
    
    //门牌号:   1           2           3           4           5
    //映射号:  1           2           3           4           5
    //国籍:     挪威        德国        英国        瑞典        丹麦
    //颜色:     黄          蓝          红          绿          白
    //饮料:     啤酒        水          牛奶        咖啡        茶
    //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
    //宠物:     Fish        Horse       Cat         Dog         Bird
    char *pstrsNationality[5] = { "挪威", "德国", "英国", "瑞典", "丹麦" };
    char *pstrsHouseColor[5]  = { "黄", "蓝", "红", "绿", "白" };
    char *pstrsBeverage[5]    = { "啤酒", "水", "牛奶", "咖啡", "茶" };
    char *pstrsCigarette[5]   = { "Dunhill", "Prince", "Blends", "BlueMaster", "PallMall" };
    char *pstrsPet[5]         = { "Fish", "Horse", "Cat", "Dog", "Bird" };
    
    int main( int argc, char *argv[] )
    {
        size_t tNum_1 = 0;
        size_t tNum_2 = 0;
        size_t tNum_3 = 0;
        size_t tNum_4 = 0;
        size_t tNum_5 = 0;
        std::vector<House*> rgpHouses;
        clock_t tStart = clock();
        for (int iNum=1; iNum<6; ++iNum )                               //门牌号
        {
            for (UCHAR eNation=1; eNation<6; ++eNation)                 //国籍
            {
                for (UCHAR eColor=1; eColor<6; ++eColor)                //颜色
                {
                    for (UCHAR eDrink=1; eDrink<6; ++eDrink)            //饮料
                    {
                        for (UCHAR eCigar=1; eCigar<6; ++eCigar)        //香烟
                        {
                            for (UCHAR ePet=1; ePet<6; ++ePet)          //宠物
                            {
                                //根据断言条件进行过滤
                                //断言条件:
                                //8、挪威人住第一间房(否)
                                if ( 1==iNum && Norway != eNation )
                                    continue;
    
                                //11、第二间房间是蓝色的(否)
                                if ( 2==iNum && Blue != eColor )
                                    continue;
    
                                //7、住在中间房子的人喝牛奶(否)
                                if ( 3==iNum && Milk != eDrink )
                                    continue;
    
                                //1、英国人住红色房子(否)
                                if ( British == eNation && Red != eColor )
                                    continue;
    
                                //2、瑞典人养狗(否)
                                if ( Sweden == eNation && Dog != ePet )
                                    continue;
    
                                //3、丹麦人喝茶(否)
                                if ( Denmark == eNation && Tea != eDrink )
                                    continue;
    
                                //4、绿色房子主人喝咖啡(否)
                                if ( Red == eColor && Coffee != eDrink )
                                    continue;
    
                                //5、抽Pall Mall香烟的人养鸟(否)
                                if ( PallMall == eCigar && Bird != ePet )
                                    continue;
    
                                //6、黄色房子主人抽Dunhill香烟(否)
                                if ( Yellow == eColor && Dunhill != eCigar )
                                    continue;
    
                                //9、抽Blue Master的人喝啤酒(否)
                                if ( Beer == eDrink && BlueMaster != eCigar )
                                    continue;
    
                                //10、德国人抽Prince香烟(否)
                                if ( Germany == eNation && Prince != eCigar )
                                    continue;
    
                                House *pObjHouse = new House(iNum,(NATIONALITY)eNation,
                                    (HOUSECOLOR)eColor,(BEVERAGE)eDrink,
                                    (CIGARETTE)eCigar,(PET)ePet);
    
                                rgpHouses.push_back( pObjHouse );
                                if ( 1 == iNum ) ++tNum_1;
                                if ( 2 == iNum ) ++tNum_2;
                                if ( 3 == iNum ) ++tNum_3;
                                if ( 4 == iNum ) ++tNum_4;
                                if ( 5 == iNum ) ++tNum_5;
    
    这样的可读性明显要看了很多,同时在对关系条件的判断上虽然思路与之前也是一样的,但是由于采用对象的表述方法,因此将判断的方法写入类中,使得程序的逻辑结构更加清晰,程序不容易出错。虽然算法复杂度没有改变,且由于使用new的原因甚至速度有所下降但是,换来的却是思路与结构更为清晰的代码,从这点来说还是值得的。当然若想不受new操作的拖累,完全可以按照此思路去改写前一次的程序,用枚举变量去表述,同样可以获得良好的可读性。可读性的问题解决了,接下来,我们从全排的角度去解决此类问题,来设计一下看看是否再算法复杂度上能够比之前的方法要小些,得到代码如下:
    //门牌号:   1           2           3           4           5
    //国籍:     挪威        德国        英国        瑞典        丹麦
    //颜色:     黄          蓝          红          绿          白
    //饮料:     啤酒        水          牛奶        咖啡        茶
    //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
    //宠物:     Fish        Horse       Cat         Dog         Bird
    
    enum HOUSECOLOR     //房子颜色
    {
        XColor  =  0,
        Yellow  =  1,
        Blue,
        Red,
        Green,
        White
    };
    
    enum BEVERAGE       //饮料
    {
        XDrink  =  0,
        Beer    =  1,
        Water,
        Milk,
        Coffee,
        Tea
    };
    
    enum NATIONALITY    //国籍
    {
        XNation  =  0,
        Norway  =   1,
        Germany,
        British,
        Sweden,
        Denmark
    };
    
    enum CIGARETTE      //香烟(品牌)
    {
        XCigar  =  0,
        Dunhill =  1,
        Prince,
        Blends,
        BlueMaster,
        PallMall
    };
    
    enum PET            //宠物
    {
        XPet    =  0,
        Fish    =  1,
        Horse,
        Cat,
        Dog,
        Bird
    };
    
    class House
    {
    public:
        House( const int iHouseNum,
               NATIONALITY eNation = XNation, 
               HOUSECOLOR eColor = XColor,
               BEVERAGE eDrink = XDrink,
               CIGARETTE eCigar = XCigar, 
               PET ePet = XPet )
                : m_iHouseNum( iHouseNum ),
                  m_eColor( eColor ),
                  m_eCigar( eCigar ),
                  m_eDrink( eDrink ),
                  m_eNation( eNation ),
                  m_ePet( ePet )
        {
    
        }
        ~House(){}
    public:
        //Relationship
        //bool IsOnLeftSide( const House &objHouse )
        //{
        //    return 1 == (m_iHouseNum - objHouse.m_iHouseNum);
        //}
    
        //bool IsOnRightSide( const House &objHouse )
        //{
        //    return -1 == (m_iHouseNum - objHouse.m_iHouseNum);
        //}
    
        //bool IsNeighbour( const House &objHouse )
        //{
        //    return 1 == abs(m_iHouseNum - objHouse.m_iHouseNum );
        //}
    
    public:
        //Setter and Getter
        void SetCigar( const CIGARETTE eCigar ) { m_eCigar = eCigar; }
        void SetHouseColor( const HOUSECOLOR eColor ) { m_eColor = eColor; }
        void SetBeverage( const BEVERAGE eDrink ) { m_eDrink = eDrink; }
        void SetNationality(const NATIONALITY eNation ) { m_eNation = eNation; }
        void SetPet( const PET ePet ) { m_ePet = ePet; }
    
        const CIGARETTE GetCigar( void ) const { return m_eCigar; }
        const HOUSECOLOR GetHouseColor( void ) const { return m_eColor; }
        const BEVERAGE GetBeverage( void ) const { return m_eDrink; }
        const NATIONALITY GetNationality( void ) const { return m_eNation; }
        const PET GetPet( void ) const { return m_ePet; }
        const int GetHouseNum( void ) const { return m_iHouseNum; }
    
    private:
        CIGARETTE       m_eCigar;
        HOUSECOLOR      m_eColor;
        BEVERAGE        m_eDrink;
        NATIONALITY     m_eNation;
        PET             m_ePet;
        int             m_iHouseNum;
    };
    
    //门牌号:   1           2           3           4           5
    //映射号:  1           2           3           4           5
    //国籍:     挪威        德国        英国        瑞典        丹麦
    //颜色:     黄          蓝          红          绿          白
    //饮料:     啤酒        水          牛奶        咖啡        茶
    //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
    //宠物:     Fish        Horse       Cat         Dog         Bird
    char *pstrsNationality[5] = { "挪威", "德国", "英国", "瑞典", "丹麦" };
    char *pstrsHouseColor[5]  = { "黄", "蓝", "红", "绿", "白" };
    char *pstrsBeverage[5]    = { "啤酒", "水", "牛奶", "咖啡", "茶" };
    char *pstrsCigarette[5]   = { "Dunhill", "Prince", "Blends", "BlueMaster", "PallMall" };
    char *pstrsPet[5]         = { "Fish", "Horse", "Cat", "Dog", "Bird" };
    
    int main( int argc, char *argv[] )
    {
        //国籍:     挪威        德国        英国        瑞典        丹麦
        std::vector<NATIONALITY> rgpNations;
        rgpNations.push_back( Norway );
        rgpNations.push_back( Germany );
        rgpNations.push_back( British );
        rgpNations.push_back( Sweden );
        rgpNations.push_back( Denmark );
        std::sort( rgpNations.begin(), rgpNations.end() );
    
        std::vector<HOUSECOLOR>  rgpColors;
        //颜色:     黄          蓝          红          绿          白
        rgpColors.push_back( Yellow );
        rgpColors.push_back( Blue );
        rgpColors.push_back( Red );
        rgpColors.push_back( Green );
        rgpColors.push_back( White );
        std::sort( rgpColors.begin(), rgpColors.end() );
    
        //饮料:     啤酒        水          牛奶        咖啡        茶
        std::vector<BEVERAGE>    rgpDrinks;
        rgpDrinks.push_back( Beer );
        rgpDrinks.push_back( Water );
        rgpDrinks.push_back( Milk );
        rgpDrinks.push_back( Coffee );
        rgpDrinks.push_back( Tea );
        std::sort( rgpDrinks.begin(), rgpDrinks.end() );
    
        //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
        std::vector<CIGARETTE>   rgpCigars;
        rgpCigars.push_back( Dunhill );
        rgpCigars.push_back( Prince );
        rgpCigars.push_back( Blends );
        rgpCigars.push_back( BlueMaster );
        rgpCigars.push_back( PallMall );
        std::sort( rgpCigars.begin(), rgpCigars.end() );
    
        //宠物:     Fish        Horse       Cat         Dog         Bird
        std::vector<PET>         rgpPets;
        rgpPets.push_back( Fish );
        rgpPets.push_back( Horse );
        rgpPets.push_back( Cat );
        rgpPets.push_back( Dog );
        rgpPets.push_back( Bird );
        std::sort( rgpPets.begin(), rgpPets.end() );
    
        clock_t tStart = clock();
        House obj_1(1), obj_2(2), obj_3(3), obj_4(4), obj_5(5);
        UINT uCounter = 0;
        do                              //国籍
        {
            do                          //颜色
            {
                do                      //饮料
                {
                    do                  //香烟
                    {
                        do              //宠物
                        {
                            //国籍
                            obj_1.SetNationality( rgpNations[0] );
                            obj_2.SetNationality( rgpNations[1] );
                            obj_3.SetNationality( rgpNations[2] );
                            obj_4.SetNationality( rgpNations[3] );
                            obj_5.SetNationality( rgpNations[4] );
    
                            //颜色
                            obj_1.SetHouseColor( rgpColors[0] );
                            obj_2.SetHouseColor( rgpColors[1] );
                            obj_3.SetHouseColor( rgpColors[2] );
                            obj_4.SetHouseColor( rgpColors[3] );
                            obj_5.SetHouseColor( rgpColors[4] );
    
                            //饮料
                            obj_1.SetBeverage( rgpDrinks[0] );
                            obj_2.SetBeverage( rgpDrinks[1] );
                            obj_3.SetBeverage( rgpDrinks[2] );
                            obj_4.SetBeverage( rgpDrinks[3] );
                            obj_5.SetBeverage( rgpDrinks[4] );
    
                            //香烟
                            obj_1.SetCigar( rgpCigars[0] );
                            obj_2.SetCigar( rgpCigars[1] );
                            obj_3.SetCigar( rgpCigars[2] );
                            obj_4.SetCigar( rgpCigars[3] );
                            obj_5.SetCigar( rgpCigars[4] );
    
                            //宠物
                            obj_1.SetPet( rgpPets[0] );
                            obj_2.SetPet( rgpPets[1] );
                            obj_3.SetPet( rgpPets[2] );
                            obj_4.SetPet( rgpPets[3] );
                            obj_5.SetPet( rgpPets[4] );
                            std::cout << "uCounter:" << ++uCounter <<" Fin:24883200000" << std::endl;
                            //根据断言条件进行过滤
                            //断言条件:
                            //8、挪威人住第一间房(否)
                            if ( Norway != obj_1.GetNationality() )
                                continue;
    
                            //11、第二间房间是蓝色的(否)
                            if ( Blue != obj_2.GetHouseColor() )
                                continue;
    
                            //7、住在中间房子的人喝牛奶(否)
                            if ( Milk != obj_3.GetBeverage() )
                                continue;
    
                            //1、英国人住红色房子(否)
                            if ((British == obj_2.GetNationality() && Red != obj_2.GetHouseColor()) ||
                                (British == obj_3.GetNationality() && Red != obj_3.GetHouseColor()) ||
                                (British == obj_4.GetNationality() && Red != obj_4.GetHouseColor()) ||
                                (British == obj_5.GetNationality() && Red != obj_5.GetHouseColor()) )
                                continue;
    
                            //2、瑞典人养狗(否)
                                
                            if ((Sweden == obj_2.GetNationality() && Dog != obj_2.GetPet()) ||
                                (Sweden == obj_3.GetNationality() && Dog != obj_3.GetPet()) ||
                                (Sweden == obj_4.GetNationality() && Dog != obj_4.GetPet()) ||
                                (Sweden == obj_5.GetNationality() && Dog != obj_5.GetPet()) )
                                continue;
    
                            //3、丹麦人喝茶(否)
                            if ((Denmark == obj_2.GetNationality() && Tea != obj_2.GetBeverage()) ||
                                (Denmark == obj_3.GetNationality() && Tea != obj_3.GetBeverage()) ||
                                (Denmark == obj_4.GetNationality() && Tea != obj_4.GetBeverage()) ||
                                (Denmark == obj_5.GetNationality() && Tea != obj_5.GetBeverage()) )
                                continue;
    
    
                            //10、德国人抽Prince香烟(否)
                            if ((Germany == obj_2.GetNationality() && Prince != obj_2.GetCigar()) ||
                                (Germany == obj_3.GetNationality() && Prince != obj_3.GetCigar()) ||
                                (Germany == obj_4.GetNationality() && Prince != obj_4.GetCigar()) ||
                                (Germany == obj_5.GetNationality() && Prince != obj_5.GetCigar()) )
                                continue;
    
                            //4、绿色房子主人喝咖啡(否)
                            if ((Green == obj_1.GetHouseColor() && Coffee != obj_1.GetBeverage()) ||
                                (Green == obj_2.GetHouseColor() && Coffee != obj_2.GetBeverage()) ||
                                (Green == obj_3.GetHouseColor() && Coffee != obj_3.GetBeverage()) ||
                                (Green == obj_4.GetHouseColor() && Coffee != obj_4.GetBeverage()) ||
                                (Green == obj_5.GetHouseColor() && Coffee != obj_5.GetBeverage()) )
                                continue;
    
                            //5、抽Pall Mall香烟的人养鸟(否)
                            if ((PallMall == obj_1.GetCigar() && Bird != obj_1.GetPet()) ||
                                (PallMall == obj_2.GetCigar() && Bird != obj_2.GetPet()) ||
                                (PallMall == obj_3.GetCigar() && Bird != obj_3.GetPet()) ||
                                (PallMall == obj_4.GetCigar() && Bird != obj_4.GetPet()) ||
                                (PallMall == obj_5.GetCigar() && Bird != obj_5.GetPet()) )
                                continue;
    
                            //6、黄色房子主人抽Dunhill香烟(否)
                            if ((Dunhill == obj_1.GetCigar() && Yellow != obj_1.GetHouseColor()) ||
                                (Dunhill == obj_2.GetCigar() && Yellow != obj_2.GetHouseColor()) ||
                                (Dunhill == obj_3.GetCigar() && Yellow != obj_3.GetHouseColor()) ||
                                (Dunhill == obj_4.GetCigar() && Yellow != obj_4.GetHouseColor()) ||
                                (Dunhill == obj_5.GetCigar() && Yellow != obj_5.GetHouseColor()) )
                                continue;
    
                            //9、抽Blue Master的人喝啤酒(否)
                            if ((BlueMaster == obj_1.GetCigar() && Beer != obj_1.GetBeverage()) ||
                                (BlueMaster == obj_2.GetCigar() && Beer != obj_2.GetBeverage()) ||
                                (BlueMaster == obj_3.GetCigar() && Beer != obj_3.GetBeverage()) ||
                                (BlueMaster == obj_4.GetCigar() && Beer != obj_4.GetBeverage()) ||
                                (BlueMaster == obj_5.GetCigar() && Beer != obj_5.GetBeverage()) )
                                continue;
    
                            //关系条件判断过滤
                            //1、绿色房子在白色房子左面。(否)
                            if ( (Green == obj_1.GetHouseColor() && White != obj_2.GetHouseColor()) ||
                                 (Green == obj_2.GetHouseColor() && White != obj_3.GetHouseColor()) ||
                                 (Green == obj_3.GetHouseColor() && White != obj_4.GetHouseColor()) ||
                                 (Green == obj_4.GetHouseColor() && White != obj_5.GetHouseColor()) )
                                 continue;
    
                            //2、抽Blends香烟的人住在养猫的人隔壁。(否)
                            if ( (Blends == obj_1.GetCigar() && Cat != obj_2.GetPet()) ||
                                 (Blends == obj_2.GetCigar() && Cat != obj_1.GetPet() && Cat != obj_3.GetPet())||
                                 (Blends == obj_3.GetCigar() && Cat != obj_2.GetPet() && Cat != obj_4.GetPet())||
                                 (Blends == obj_4.GetCigar() && Cat != obj_3.GetPet() && Cat != obj_5.GetPet())||
                                 (Blends == obj_5.GetCigar() && Cat != obj_4.GetPet()))
                                 continue;
    
                            //4、抽Blends香烟的人有一个喝水的邻居。(否)
                            if ( (Blends == obj_1.GetCigar() && Water != obj_2.GetBeverage()) ||
                                 (Blends == obj_2.GetCigar() && Water != obj_1.GetBeverage() && Water != obj_3.GetBeverage())||
                                 (Blends == obj_3.GetCigar() && Water != obj_2.GetBeverage() && Water != obj_4.GetBeverage())||
                                 (Blends == obj_4.GetCigar() && Water != obj_3.GetBeverage() && Water != obj_5.GetBeverage())||
                                ( Blends == obj_5.GetCigar() && Water != obj_4.GetBeverage()))
                                continue;
    
                            //3、养马的人住抽Dunhill香烟的人隔壁。(否)
                            if ( (Horse == obj_1.GetPet() && Dunhill != obj_2.GetCigar()) ||
                                 (Horse == obj_2.GetPet() && Dunhill != obj_1.GetCigar() && Dunhill != obj_3.GetCigar())||
                                 (Horse == obj_3.GetPet() && Dunhill != obj_2.GetCigar() && Dunhill != obj_4.GetCigar())||
                                 (Horse == obj_4.GetPet() && Dunhill != obj_3.GetCigar() && Dunhill != obj_5.GetCigar())||
                                 (Horse == obj_5.GetPet() && Dunhill != obj_4.GetCigar()))
                                continue;
    
                            clock_t tFinish = clock();
                            std::cout <<"Time Cost is"<<tFinish-tStart<<"ms"<<std::endl;
                            std::cout <<"1 " 
                            <<" "<< pstrsNationality[obj_1.GetNationality()]
                            <<" "<< pstrsHouseColor[obj_1.GetHouseColor()]
                            <<" "<< pstrsBeverage[obj_1.GetBeverage()]
                            <<" "<< pstrsCigarette[obj_1.GetCigar()]
                            <<" "<< pstrsPet[obj_1.GetPet()]
                            <<std::endl;
    
                            std::cout <<"2 " 
                            <<" "<< pstrsNationality[obj_2.GetNationality()]
                            <<" "<< pstrsHouseColor[obj_2.GetHouseColor()]
                            <<" "<< pstrsBeverage[obj_2.GetBeverage()]
                            <<" "<< pstrsCigarette[obj_2.GetCigar()]
                            <<" "<< pstrsPet[obj_2.GetPet()]
                            <<std::endl;
    
                            std::cout <<"3 " 
                                <<" "<< pstrsNationality[obj_3.GetNationality()]
                            <<" "<< pstrsHouseColor[obj_3.GetHouseColor()]
                            <<" "<< pstrsBeverage[obj_3.GetBeverage()]
                            <<" "<< pstrsCigarette[obj_3.GetCigar()]
                            <<" "<< pstrsPet[obj_3.GetPet()]
                            <<std::endl;
    
                            std::cout <<"4 " 
                            <<" "<< pstrsNationality[obj_4.GetNationality()]
                            <<" "<< pstrsHouseColor[obj_4.GetHouseColor()]
                            <<" "<< pstrsBeverage[obj_4.GetBeverage()]
                            <<" "<< pstrsCigarette[obj_4.GetCigar()]
                            <<" "<< pstrsPet[obj_4.GetPet()]
                            <<std::endl;
    
                            std::cout <<"5 " 
                            <<" "<< pstrsNationality[obj_5.GetNationality()]
                            <<" "<< pstrsHouseColor[obj_5.GetHouseColor()]
                            <<" "<< pstrsBeverage[obj_5.GetBeverage()]
                            <<" "<< pstrsCigarette[obj_5.GetCigar()]
                            <<" "<< pstrsPet[obj_5.GetPet()]
                            <<std::endl;
    
                        } while( next_permutation(rgpPets.begin(), rgpPets.end()) );
                    } while( next_permutation(rgpCigars.begin(), rgpCigars.end()) );
                } while( next_permutation(rgpDrinks.begin(), rgpDrinks.end()) );
            } while( next_permutation(rgpColors.begin(), rgpColors.end()) );
        } while( next_permutation(rgpNations.begin(), rgpNations.end()) ); 
    
        return 0;
    }
    代码的可读性可谓是非常高了,但是其算法复杂度却是相当之高,粗略估计一下大概至少需要执行个把小时才能有结果,因此不具备“切实”的可行性(PS:为一个简单的题目等个把小时不实际!),看看如何优化一下子?!通过对实现进行观察我们可以发现,有些判断还有条件可以提前,这样可以大大降低不必要的循环次数,另外对于例如:挪威人住第一间房这样的条件可以将挪威人在房间上的排列剔除掉。经过优化的代码大大提高了效率,代码如下:
    //门牌号:   1           2           3           4           5
    //映射号:  1           2           3           4           5
    //国籍:     挪威        德国        英国        瑞典        丹麦
    //颜色:     黄          蓝          红          绿          白
    //饮料:     啤酒        水          牛奶        咖啡        茶
    //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
    //宠物:     Fish        Horse       Cat         Dog         Bird
    char *pstrsNationality[5] = { "挪威", "德国", "英国", "瑞典", "丹麦" };
    char *pstrsHouseColor[5]  = { "黄", "蓝", "红", "绿", "白" };
    char *pstrsBeverage[5]    = { "啤酒", "水", "牛奶", "咖啡", "茶" };
    char *pstrsCigarette[5]   = { "Dunhill", "Prince", "Blends", "BlueMaster", "PallMall" };
    char *pstrsPet[5]         = { "Fish", "Horse", "Cat", "Dog", "Bird" };
    
    int main( int argc, char *argv[] )
    {
        //国籍:     挪威        德国        英国        瑞典        丹麦
        std::vector<NATIONALITY> rgpNations;
        //rgpNations.push_back( Norway );
        rgpNations.push_back( Germany );
        rgpNations.push_back( British );
        rgpNations.push_back( Sweden );
        rgpNations.push_back( Denmark );
        std::sort( rgpNations.begin(), rgpNations.end() );
    
        std::vector<HOUSECOLOR>  rgpColors;
        //颜色:     黄          蓝          红          绿          白
        rgpColors.push_back( Yellow );
        //rgpColors.push_back( Blue );
        rgpColors.push_back( Red );
        rgpColors.push_back( Green );
        rgpColors.push_back( White );
        std::sort( rgpColors.begin(), rgpColors.end() );
    
        //饮料:     啤酒        水          牛奶        咖啡        茶
        std::vector<BEVERAGE>    rgpDrinks;
        rgpDrinks.push_back( Beer );
        rgpDrinks.push_back( Water );
        //rgpDrinks.push_back( Milk );
        rgpDrinks.push_back( Coffee );
        rgpDrinks.push_back( Tea );
        std::sort( rgpDrinks.begin(), rgpDrinks.end() );
    
        //香烟牌子: Dunhill     Prince      Blends      BlueMaster  PallMall
        std::vector<CIGARETTE>   rgpCigars;
        rgpCigars.push_back( Dunhill );
        rgpCigars.push_back( Prince );
        rgpCigars.push_back( Blends );
        rgpCigars.push_back( BlueMaster );
        rgpCigars.push_back( PallMall );
        std::sort( rgpCigars.begin(), rgpCigars.end() );
    
        //宠物:     Fish        Horse       Cat         Dog         Bird
        std::vector<PET>         rgpPets;
        rgpPets.push_back( Fish );
        rgpPets.push_back( Horse );
        rgpPets.push_back( Cat );
        rgpPets.push_back( Dog );
        rgpPets.push_back( Bird );
        std::sort( rgpPets.begin(), rgpPets.end() );
    
        clock_t tStart = clock();
        House obj_1(1), obj_2(2), obj_3(3), obj_4(4), obj_5(5);
        UINT uCounter = 0;
        obj_1.SetNationality( Norway );
        obj_2.SetHouseColor( Blue );
        obj_3.SetBeverage( Milk );
        do                              //国籍
        {
            //国籍
            obj_2.SetNationality( rgpNations[0] );
            obj_3.SetNationality( rgpNations[1] );
            obj_4.SetNationality( rgpNations[2] );
            obj_5.SetNationality( rgpNations[3] );
            do                          //颜色
            {
                //颜色
                obj_1.SetHouseColor( rgpColors[0] );
                obj_3.SetHouseColor( rgpColors[1] );
                obj_4.SetHouseColor( rgpColors[2] );
                obj_5.SetHouseColor( rgpColors[3] );
                //1、英国人住红色房子(否)
                if ((British == obj_2.GetNationality() && Red != obj_2.GetHouseColor()) ||
                    (British == obj_3.GetNationality() && Red != obj_3.GetHouseColor()) ||
                    (British == obj_4.GetNationality() && Red != obj_4.GetHouseColor()) ||
                    (British == obj_5.GetNationality() && Red != obj_5.GetHouseColor()) )
                    continue;
    
                //1、绿色房子在白色房子左面。(否)
                if ( (Green == obj_1.GetHouseColor() && White != obj_2.GetHouseColor()) ||
                    (Green == obj_2.GetHouseColor() && White != obj_3.GetHouseColor()) ||
                    (Green == obj_3.GetHouseColor() && White != obj_4.GetHouseColor()) ||
                    (Green == obj_4.GetHouseColor() && White != obj_5.GetHouseColor()) ||
                    Green == obj_5.GetHouseColor() )
                    continue;
                do                      //饮料
                {
                    //饮料
                    obj_1.SetBeverage( rgpDrinks[0] );
                    obj_2.SetBeverage( rgpDrinks[1] );
                    obj_4.SetBeverage( rgpDrinks[2] );
                    obj_5.SetBeverage( rgpDrinks[3] );
    
                    //3、丹麦人喝茶(否)
                    if ((Denmark == obj_2.GetNationality() && Tea != obj_2.GetBeverage()) ||
                        (Denmark == obj_3.GetNationality() && Tea != obj_3.GetBeverage()) ||
                        (Denmark == obj_4.GetNationality() && Tea != obj_4.GetBeverage()) ||
                        (Denmark == obj_5.GetNationality() && Tea != obj_5.GetBeverage()) )
                        continue;
    
                    //4、绿色房子主人喝咖啡(否)
                    if ((Green == obj_1.GetHouseColor() && Coffee != obj_1.GetBeverage()) ||
                        (Green == obj_2.GetHouseColor() && Coffee != obj_2.GetBeverage()) ||
                        (Green == obj_3.GetHouseColor() && Coffee != obj_3.GetBeverage()) ||
                        (Green == obj_4.GetHouseColor() && Coffee != obj_4.GetBeverage()) ||
                        (Green == obj_5.GetHouseColor() && Coffee != obj_5.GetBeverage()) )
                        continue;
    
                    do                  //香烟
                    {
                        //香烟
                        obj_1.SetCigar( rgpCigars[0] );
                        obj_2.SetCigar( rgpCigars[1] );
                        obj_3.SetCigar( rgpCigars[2] );
                        obj_4.SetCigar( rgpCigars[3] );
                        obj_5.SetCigar( rgpCigars[4] );
    
                        //10、德国人抽Prince香烟(否)
                        if ((Germany == obj_2.GetNationality() && Prince != obj_2.GetCigar()) ||
                            (Germany == obj_3.GetNationality() && Prince != obj_3.GetCigar()) ||
                            (Germany == obj_4.GetNationality() && Prince != obj_4.GetCigar()) ||
                            (Germany == obj_5.GetNationality() && Prince != obj_5.GetCigar()) )
                            continue;
    
                        //6、黄色房子主人抽Dunhill香烟(否)
                        if ((Dunhill == obj_1.GetCigar() && Yellow != obj_1.GetHouseColor()) ||
                            (Dunhill == obj_2.GetCigar() && Yellow != obj_2.GetHouseColor()) ||
                            (Dunhill == obj_3.GetCigar() && Yellow != obj_3.GetHouseColor()) ||
                            (Dunhill == obj_4.GetCigar() && Yellow != obj_4.GetHouseColor()) ||
                            (Dunhill == obj_5.GetCigar() && Yellow != obj_5.GetHouseColor()) )
                            continue;
    
                        //9、抽Blue Master的人喝啤酒(否)
                        if ((BlueMaster == obj_1.GetCigar() && Beer != obj_1.GetBeverage()) ||
                            (BlueMaster == obj_2.GetCigar() && Beer != obj_2.GetBeverage()) ||
                            (BlueMaster == obj_3.GetCigar() && Beer != obj_3.GetBeverage()) ||
                            (BlueMaster == obj_4.GetCigar() && Beer != obj_4.GetBeverage()) ||
                            (BlueMaster == obj_5.GetCigar() && Beer != obj_5.GetBeverage()) )
                            continue;
    
                        //4、抽Blends香烟的人有一个喝水的邻居。(否)
                        if ( (Blends == obj_1.GetCigar() && Water != obj_2.GetBeverage()) ||
                            (Blends == obj_2.GetCigar() && Water != obj_1.GetBeverage() && Water != obj_3.GetBeverage())||
                            (Blends == obj_3.GetCigar() && Water != obj_2.GetBeverage() && Water != obj_4.GetBeverage())||
                            (Blends == obj_4.GetCigar() && Water != obj_3.GetBeverage() && Water != obj_5.GetBeverage())||
                            ( Blends == obj_5.GetCigar() && Water != obj_4.GetBeverage()))
                            continue;
                        do              //宠物
                        {
                            //宠物
                            obj_1.SetPet( rgpPets[0] );
                            obj_2.SetPet( rgpPets[1] );
                            obj_3.SetPet( rgpPets[2] );
                            obj_4.SetPet( rgpPets[3] );
                            obj_5.SetPet( rgpPets[4] );
    
                            //2、瑞典人养狗(否)
                            if ((Sweden == obj_2.GetNationality() && Dog != obj_2.GetPet()) ||
                                (Sweden == obj_3.GetNationality() && Dog != obj_3.GetPet()) ||
                                (Sweden == obj_4.GetNationality() && Dog != obj_4.GetPet()) ||
                                (Sweden == obj_5.GetNationality() && Dog != obj_5.GetPet()) )
                                continue;
    
    
                            //5、抽Pall Mall香烟的人养鸟(否)
                            if ((PallMall == obj_1.GetCigar() && Bird != obj_1.GetPet()) ||
                                (PallMall == obj_2.GetCigar() && Bird != obj_2.GetPet()) ||
                                (PallMall == obj_3.GetCigar() && Bird != obj_3.GetPet()) ||
                                (PallMall == obj_4.GetCigar() && Bird != obj_4.GetPet()) ||
                                (PallMall == obj_5.GetCigar() && Bird != obj_5.GetPet()) )
                                continue;
    
                            //关系条件判断过滤
                            //2、抽Blends香烟的人住在养猫的人隔壁。(否)
                            if ( (Blends == obj_1.GetCigar() && Cat != obj_2.GetPet()) ||
                                 (Blends == obj_2.GetCigar() && Cat != obj_1.GetPet() && Cat != obj_3.GetPet())||
                                 (Blends == obj_3.GetCigar() && Cat != obj_2.GetPet() && Cat != obj_4.GetPet())||
                                 (Blends == obj_4.GetCigar() && Cat != obj_3.GetPet() && Cat != obj_5.GetPet())||
                                 (Blends == obj_5.GetCigar() && Cat != obj_4.GetPet()))
                                 continue;
    
                            //3、养马的人住抽Dunhill香烟的人隔壁。(否)
                            if ( (Horse == obj_1.GetPet() && Dunhill != obj_2.GetCigar()) ||
                                 (Horse == obj_2.GetPet() && Dunhill != obj_1.GetCigar() && Dunhill != obj_3.GetCigar())||
                                 (Horse == obj_3.GetPet() && Dunhill != obj_2.GetCigar() && Dunhill != obj_4.GetCigar())||
                                 (Horse == obj_4.GetPet() && Dunhill != obj_3.GetCigar() && Dunhill != obj_5.GetCigar())||
                                 (Horse == obj_5.GetPet() && Dunhill != obj_4.GetCigar()))
                                continue;
    
                            clock_t tFinish = clock();
                            std::cout <<"Time Cost is"<<tFinish-tStart<<"ms"<<std::endl;
                            std::cout <<"1 " 
                            <<" "<< pstrsNationality[obj_1.GetNationality()-1]
                            <<" "<< pstrsHouseColor[obj_1.GetHouseColor()-1]
                            <<" "<< pstrsBeverage[obj_1.GetBeverage()-1]
                            <<" "<< pstrsCigarette[obj_1.GetCigar()-1]
                            <<" "<< pstrsPet[obj_1.GetPet()-1]
                            <<std::endl;
    
                            std::cout <<"2 " 
                            <<" "<< pstrsNationality[obj_2.GetNationality()-1]
                            <<" "<< pstrsHouseColor[obj_2.GetHouseColor()-1]
                            <<" "<< pstrsBeverage[obj_2.GetBeverage()-1]
                            <<" "<< pstrsCigarette[obj_2.GetCigar()-1]
                            <<" "<< pstrsPet[obj_2.GetPet()-1]
                            <<std::endl;
    
                            std::cout <<"3 " 
                                <<" "<< pstrsNationality[obj_3.GetNationality()-1]
                            <<" "<< pstrsHouseColor[obj_3.GetHouseColor()-1]
                            <<" "<< pstrsBeverage[obj_3.GetBeverage()-1]
                            <<" "<< pstrsCigarette[obj_3.GetCigar()-1]
                            <<" "<< pstrsPet[obj_3.GetPet()-1]
                            <<std::endl;
    
                            std::cout <<"4 " 
                            <<" "<< pstrsNationality[obj_4.GetNationality()-1]
                            <<" "<< pstrsHouseColor[obj_4.GetHouseColor()-1]
                            <<" "<< pstrsBeverage[obj_4.GetBeverage()-1]
                            <<" "<< pstrsCigarette[obj_4.GetCigar()-1]
                            <<" "<< pstrsPet[obj_4.GetPet()-1]
                            <<std::endl;
    
                            std::cout <<"5 " 
                            <<" "<< pstrsNationality[obj_5.GetNationality()-1]
                            <<" "<< pstrsHouseColor[obj_5.GetHouseColor()-1]
                            <<" "<< pstrsBeverage[obj_5.GetBeverage()-1]
                            <<" "<< pstrsCigarette[obj_5.GetCigar()-1]
                            <<" "<< pstrsPet[obj_5.GetPet()-1]
                            <<std::endl;
                        } while( next_permutation(rgpPets.begin(), rgpPets.end()) );
                    } while( next_permutation(rgpCigars.begin(), rgpCigars.end()) );
                } while( next_permutation(rgpDrinks.begin(), rgpDrinks.end()) );
            } while( next_permutation(rgpColors.begin(), rgpColors.end()) );
        } while( next_permutation(rgpNations.begin(), rgpNations.end()) ); 
        return 0;
    }

    经过优化后的代码,能够很好地得出运行结果。同样的道理,对于我们之前采用的不用全排列的方法也可以综合使用判断提前的优化手段,使得计算效率大大提升,省去不必要的循环。如此一来,不仅有了解决方案、而且代码的可读性大大增强,同时对于结构的细微调整达到了良好的优化目的。







    展开全文
  • 遗传算法求解一般函数极值问题

    千次阅读 2019-09-11 18:24:55
    遗传算法实现 ...大部分函数求解过程直接采用实数编码方式即可 function ret=Code(lenchrom,bound) %本函数将变量编码成染色体,用于随机初始化一个种群 % lenchrom input : 染色体长度 % bound input...
  • 在分酒问题上面,用DFS解决我个人认为是不太好。主要是因为无法很好地控制一个往回代的过程,也就是如果不仔细加以控制,甚至于即便加以控制,总是有那么一点不确定性将会让程序崩溃。而且在求出解方面可能会...
  • 问题求解与程序设计

    2019-10-03 04:12:17
    问题提出时,想要利用计算机进行求解,而一般计算机不会分析问题并直接给出解决问题的方案,故我们个人需要分析问题并给...程序设计的一般过程如图所示 由问题到想法的过程,需要分析待处理的数据以及数据之间的...
  • 论文研究- 大规模复杂决策问题求解的2 3模型及其分形性质.pdf, 决策过程的任务是,选择一组互相联系的决策变量(决策行动、决策函数),在给定的环境条件或初始条件下,使一...
  • 在绝大多数需要人工智能方法求解的问题缺乏直接求解的方法,因此搜索成为求解的一般方法 病态繁衍 状态图与状态图搜索 搜索是人工智能技术中问题求解的基本技术,也就是说人工智能的求解问题最终都归结为某种搜索,...
  • 给出一种求解一般D.C.规划非孤立全局最优解算法。该算法克服了目前一些逼近算法在计算过程中有时得到解为不可行解、甚至远离真正全局最优解的问题。数值结果表明了算法有效性。
  • 化工领域的过程设计、生产控制、配方和计划等众多问题的数学模型,...理想有效解的求法一般分为两步,先求各目标的最优值、再求理想有效解,这将影响求解的速度;为此提出在PSO(粒子群优化)算法中加入惩罚项,同时对PSO
  • 编写递归程序的难度较大,在掌握递归的基本...我们可以将计算机所求解的问题分为两大类:数值问题和非数值问题。两类问题具有不同的性质,所以解决问题的方法也是不同的。对于数值问题编写递归程序的一般方法是:...
  • 递归:是指函数、过程、子程序在运行过程中直接或间接...问题求解方法是递归:有些问题求解方法是递归,典型有Hanoi塔问题求解。 但递归也有缺点,该算法解题运算效率低,在递归调用过程中系统为...
  • 利用联合进化遗传算法 ( CEGA)建立了求解多目标排序问题的一般框架 ,采用目标权衡分析诱导出决策人的偏好关系 ,并将其引入求解过程 ,以确定满意排序 ,在搜索寻优过程中 ,...
  • 本文在分析标准技术冲突求解本质的基础上,针对设计中经常出现的单目标优化问题,借助统计分析和聚类分析技术,提出了基于TRIZ冲突矩阵进行单目标问题创新设计的快速求解方法,给出了该方法进行创新设计的一般流程,最后...
  • 课程简介 课程定位 核心通识课 计算机基础...掌握问题求解的一般思想和方法理解常用的问题求解算法 理解数据的概念理解数据结构的含义和作用 理解计算机程序计算机程序设计语言的概念理解程序编写和程序运行的基本内
  • 01背包问题属于组合优化问题的一个例子,求解01背包问题过程可以被视作在很多可行解当中求解一个最优解。01背包问题的一般描述如下: 给定n个物品和一个背包,物品i的重量为Wi,其价值为Vi,背包的容量为C。选择...
  • DFS求解迷宫问题

    千次阅读 2017-09-25 21:41:17
    这种搜索问题一般使用深度搜索DFS,从出口处开始,根据选择不同方向(上下左右)来到达另一个位置,这时可以把新到达位置看做是新起点,这样就可以递归的求解同样问题,递归结束条件是最后到达了终点。...
  • 一、递归概念 递归(recursion)是一个过程或函数在其定义或说明...在逐步求解问题后,再返回(回溯)得到大问题的解。递归算法只需少量步骤就可描述出解题过程所需要多次重复计算,大大地减少了算法代码量。 ...
  • 优化过程中新w,b计算: lr为学习率 为防止梯度过大,一般求和后会除以样本数量,即取平均值 代码: import numpy as np # 计算均方误差(定义loss=(w * x_i + b - y_i)**2 | 遍历每一个[i]求和) def points_avg2_...
  • 本文针对一般作业排序问题 ,将遗传算法与启发式方法相结合 ,建立了一种混合算法框架 ,利用遗传算法改进启发式方法的求解性能 ,同时利用启发式方法引导遗传搜索过程 ,以提高其搜索效率。通过对完工时间与平均延误时间...
  • 一、算法与问题求解的基本概念 1. 什么是算法? 算法是解决问题的方法和过程,严格讲是满足下述性质的指令序列: 输入: 有零个或多个外部量作为算法的输入; 输出: 算法至少一个量作为输出; 确定性:组成...
  • 层次型问题一般具备结构特征: 有且仅有一个初始状态,所有相关因素按照不同属性自上而下分解成若干层次。 树遍历: 按照一定规律不重复访问访问树中每一个节点。 遍历过程实质上是将树这种非线性结构...
  • vandermonda方程的求解

    2021-02-28 12:26:01
    另外,vandermonda矩阵条件数一般都很大,从而相应的求解问题是病态。 2.采用解决方法: 研究在某些条件下稳定性好算法,以求得高精度解。采用Bjorck - Pereyra 算法求解通常vandermo
  • 确定决策过程编写代码进行求解0-1 背包问题的延伸最后一块石头重量问题描述示例问题分析转换成动态规划问题写出状态转移方程通用动态规划公式理解总结与升华 前言 提起动态规划,大部分人最先想到就是背包...
  • 在使用面向过程的编程语言进行程序编写的过程中,一般是按照结构化编程思想、模块化程序设计方法来进行程序编写和代码组织。我们熟悉C语言就是这样一类程序设计语言,它通常以函数为单位进行程序模块...
  • 程序设计与算法(问题求解) 第2章;程序基本组成输入处理与输出;计算机解题示例 ;当a+b>c 且 a+c>b 且 b+c>a 时三角形存在其面积 式中 p=(a+b+c)/2;计算机处理步骤 可设a=3cm,b=4cm,c=5cm 输入abc值计算p=(3+4+5...
  • 转换(启动)时间是工业中带有清洗、更换物料工序生产过程所需要, 该时间一般很大程度上依赖于紧接工序. 这种环境下调度问题都是工件顺序依赖. 本文研究顺序依赖...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 890
精华内容 356
关键字:

问题求解的一般过程