求满足条件的序列

根据上排给出十个数，在其下排填出对应的十个数， 要求下排每个数都是先前上排那十个数在下排出现的次数。 
上排的十个数如下： 

如0，1，2，3，4，5，6，7，8，9

则6，2，1，0，0，0，1，0，0，0

分析：

没有找到明显的规律或计算公式，考虑使用搜索，从左往右完成序列。

将上下两个序列命名为A和B。对于下一个将要填充的位置p，

（1）如果A[p]在前面没出现过，则

枚举0~9的数字，如果该数字满足前面已经填上的数字构成的限制条件，则继续填下一位

（2）如果A[p]在前面出现过并填入了map[A[p]]

则检查此处填上map[A[p]]是否满足限制条件，如满足则继续填下一位，否则返回。

限制条件通过维护一个数组实现，第i位表示i在B中还能出现几次。如果是-1表示该数字在下面还没有出现过。将map数组也集成到这个数组。

减枝：根据限制条件，如果当前某个数字还要出现k次，但剩下的不到k个数字，这当前路径不合法。更强的条件是统计所有数字目前还能够出现的次数。

代码：

#include <iostream>
using namespace std;

int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int b[10];
// 第一列：A序列中i在B序列中对应的数字，-1表示还没有对应
// 第二列：B序列中i还能用几次，-1表示暂时还没有限制
// 第三列：B序列中i已经出现了几次
int map[10][3];

void init() {
    for(int i = 0; i < 10; i++){
        map[i][0] = map[i][1] = -1;
        map[i][2] = 0;
    }
}

void printB() {
    for(int i = 0; i < 10; i++) {
        cout << b[i] << " ";
    }
    cout << endl;
}

bool isValid() {
    for(int i = 0; i < 10; i++) {
        if(!(map[i][1] == 0 || (map[i][1] == -1 && map[i][2] == 0))) {
            return false;
        }
    }
    return true;

}
// 填充B序列中的第p位
void searchB(int p) {
    if(p == 10) {
        if(isValid()) {
            printB();
        }
        return;
    }
    if(map[a[p]][0] == -1) {
        // a[p]在b中还没有对应数字，可以填入0~9的满足要求的数字
        for(int i = 9; i >= 0; i--) {
            b[p] = i;
            // 保存变量
            int temp1 = map[a[p]][0];
            int temp2 = map[i][2];
            int temp3 = map[a[p]][1];
            int temp4 = map[i][1];

            map[a[p]][0] = i;
            // i 还没有被限制
            if(map[i][1] == -1) {
                map[i][2] ++;
            } else {
                map[i][1] --;
                if(map[i][1] < 0) goto mark;
            }
            map[a[p]][1] = i-map[a[p]][2];
            if(map[a[p]][1] < 0) goto mark;
            // 不可能出现这么多次了
            if(map[a[p]][1] > 9-p) goto mark;
            searchB(p+1);
mark:
            // 还原变量
            map[a[p]][0] = temp1;
            map[i][2] = temp2;
            map[a[p]][1] = temp3;
            map[i][1] = temp4;;
        }
    } else {
        // a[p]在b中已经有对应数字filledNum
        int filledNum = map[a[p]][0];
        b[p] = filledNum;
        // 保存变量
        int temp1 = map[filledNum][2];
        int temp2 = map[filledNum][1];

        if(map[filledNum][1] == -1) {
            map[filledNum][2] ++;
        } else {
            map[filledNum][1] --;
            if(map[filledNum][1] < 0) goto mark1;
        }
        searchB(p+1);
        // 还原变量
mark1:
        map[filledNum][2] = temp1;
        map[filledNum][1] = temp2;
    }
}

int main() {
    init();
    searchB(0);
    return 0;
}