【挑战】计算48种依次泛化的假设情况下，总共有多少种不可再简化的析合范式？

一种可行的算法： 
由于属性泛化后，一个泛化的假设可以对应多个具体假设。 
把所有假设按三属性泛化，二属性泛化，一属性泛化，具体属性排序(这样可以保证排在后面的假设不会包含前面的任何一个假设，所以省略了一些包含判断)，进行循环枚举，按顺序遍历所有假设组合2⁴⁸种可能(当然绝大部分都提前结束了，不会是那么夸张的量级，虽然也不低)：

• 使用栈来实现非递归，如果当前假设还有没被析合式所包含的具体假设，则认为可以入栈，并当前栈大小的长度计数加1，并继续扫描。
• 如果当前扫描已经到了最后一个假设，或者所有具体假设已经被全部包含，则退栈。
• 循环结束条件：当最后一个假设作为第一个压入栈的元素时，认为已经遍历结束。

由于一共有18种具体假设，可以用一个32位整型(变量为hypos_cur)的后18位来表示每一个具体假设。用1表示具体假设没被包含，用0表示具体假设已经被析合式包含。初始的析合式为空，可以设初试值为0X3FFFF。每个假设也对应一个32位整型(假设变量为hypo_const),代表着它所对应了哪些具体假设，如果它包含了某种具体假设，则该位为1。

• 判断析合式是否包含了全部的具体假设：hypos_cur=0。
• 判断该假设是否已经被析合范式包含:用hypo_const与hypos_cur做与运算(结果用hypo_tmp表示)，如果为0表示已经被包含(判断该假设是否包含了当前的析合式:用hypo_const与hypos_cur做或运算，如果为0X3FFFFF，则认为该假设包含了当前析合式，但由于前面对所有假设做了排序，不可能出现这种情况，所以可以省略该判断)。
• 当某个假设加入析合范式后(入栈)用hypos_cur与hypo_tmp做异或运算，来更改析合式所包含的具体假设。
• 出栈时再次用hypos_cur与hypo_tmp做异或，回到加入该假设前的情况。
• 因为是指数级遍历的算法，所以很慢

下面将直接贴上代码，供参阅讨论：

#include <vector>

#include <stack>

using namespace std;

 

//按泛化程度排序，保证排在后面的假设不会不会包含前面的任何一个假设

static const char list[] = {

    0,0,0,

    0,0,1,0,0,2,0,0,3,0,1,0,0,2,0,0,3,0,1,0,0,2,0,0,

    0,1,1,0,1,2,0,1,3,0,2,1,0,2,2,0,2,3,0,3,1,0,3,2,0,3,3,

    1,0,1,1,0,2,1,0,3,2,0,1,2,0,2,2,0,3,

    1,1,0,1,2,0,1,3,0,2,1,0,2,2,0,2,3,0,

    1,1,1,1,1,2,1,1,3,1,2,1,1,2,2,1,2,3,1,3,1,1,3,2,1,3,3,

    2,1,1,2,1,2,2,1,3,2,2,1,2,2,2,2,2,3,2,3,1,2,3,2,2,3,3

};

 

//用来派生的抽象类

class hypos {

public:

    virtual int insert(int cur) = 0;

};

 

//单个的假设类

/*

hypo_const  假设对应的具体假设集合

*/

class hypo :public hypos {

public:

    hypo(int a, int b, int c) {

        hypo_const = 0;

        vector<char>  p[3];

        if (a == 0) {

            p[0].push_back(1);

            p[0].push_back(2);

        }

        else

            p[0].push_back(a);

        if (b == 0) {

            p[1].push_back(1);

            p[1].push_back(2);

            p[1].push_back(3);

        }

        else

            p[1].push_back(b);

        if (c == 0) {

            p[2].push_back(1);

            p[2].push_back(2);

            p[2].push_back(3);

        }

        else

            p[2].push_back(c);

        for (unsigned int i = 0;i < p[0].size();i++)

            for (unsigned int j = 0;j < p[1].size();j++)

                for (unsigned int k = 0;k < p[2].size();k++)

                    hypo_const |= (1 << (p[0][i] * 9 + p[1][j] * 3 + p[2][k] - 13));

    }

 

    //判断是否要加入到析合式 如果还有具体假设没被包含，则加入

    int insert(int cur) {

        return (hypo_const & cur);

    };

 

private:

    int hypo_const;

};

 

//用于压入栈的派生类 用来实现非递归

/*

hypo_tmp    记录这个假设入栈时，带入了哪些具体假设，出栈时要还原

ptr         记录入栈时的位置

*/

class hypo_ss :public hypos {

public:

    hypo_ss(int _ptr,int tmp){

        hypo_tmp = tmp;

        ptr = _ptr;

    }

    int insert(int cur) {

        return 0;

    };

    int hypo_tmp;

    int ptr;

};

 

//用来循环遍历的类

/*

sum     各个长度的析合式各有多少种可能

ss      用来实现非递归的栈

hypos_cur   当前没被包含的具体假设 初始值为0X3FFFF

hyposs  48个假设集合

*/

class Traversal :public hypos {

public:

    Traversal() {

        hypos_cur = 0x3ffff;

        for(int i=0;i<48;i++)

            hyposs.push_back(hypo(list[3*i], list[3*i+1], list[3*i+2]));

    }

 

    //循环顺序遍历的主体

    //cur  初试的位置 设为0

    int insert(int cur) {

        //当前指向的位置

        int ptr = cur;

        while (1) {

            //退出条件 当最后一个假设作为第一个入栈的元素 表示遍历完成

            if (ptr > 47 && !ss.size()) break;

            //回退条件  扫描到最后或者所有具体假设都被包含

            if (hypos_cur == 0 || ptr>47) {

                hypo_ss hypo_tmp = ss.top();

                hypos_cur ^= hypo_tmp.hypo_tmp;

                ptr = hypo_tmp.ptr + 1;

                ss.pop();

                continue;

            }

 

            //入栈条件  如果该假设还有未被包含的具体假设 则入栈，并当前栈大小的计数加1

            if (int tmp =hyposs[ptr].insert(hypos_cur)) {

                hypos_cur ^= tmp;

                ss.push(hypo_ss(ptr, tmp));

                if (sum.size() < ss.size())

                    sum.push_back(0);

                sum[ss.size() - 1]++;

            }

            ptr++;

        }

        return 1;

    };

    //输出各个长度的可能数

    void print() {

        for (unsigned int i = 0;i < sum.size();i++)

            printf("length %d : %d
", i + 1, sum[i]);

    }

private:

    vector<int> sum;

    stack<hypo_ss> ss;

    int hypos_cur;

    vector<hypo> hyposs;

};

 

int main()

{

    Traversal traversal;

    traversal.insert(0);

    traversal.print();

    system("pause");

    return 0;

}