设计一个4*4 魔方的c++程序，，让魔方的各行值的和等于各列值的和，并且等于两 对角线值的和64.例如以下魔方： 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31

好的，这是一个比较有挑战的问题，需要用到回溯算法来解决。具体步骤如下：

1. 定义一个4*4的二维数组作为魔方矩阵，初始化为全0。

2. 编写一个递归函数，它的参数包括当前要填的行数和列数，以及已经填好的矩阵。

3. 在递归函数中，首先判断当前行和当前列是否已经填满了，如果是，就检查当前矩阵是否符合条件，如果符合，输出结果并结束递归；否则直接返回。

4. 如果当前行和列还没有填满，那么就从1到16的数字中依次尝试填入当前位置，并继续递归下一行或下一列。

5. 在填入数字之前，需要判断当前数字是否已经被用过了，如果被用过了就跳过。

6. 在填入数字之后，需要检查当前矩阵是否符合条件，如果不符合就回溯到上一步，并且将当前位置清零。

7. 如果所有的数字都尝试完了，还没有找到符合条件的矩阵，就返回上一步。

下面是具体的C++代码实现：

#include <iostream>
#include <cstring>
using namespace std;

const int N = 4;
int a[N][N], b[N], c[N], d[2];

bool check()  // 检查当前矩阵是否符合条件
{
    for (int i = 0; i < N; i++) {
        if (b[i] != c[i] || b[i] != 34) return false;
    }
    if (d[0] != d[1] || d[0] != 34) return false;
    return true;
}

void dfs(int x, int y)  // 回溯算法
{
    if (x == N && y == 0) {  // 矩阵填满了
        if (check()) {  // 检查符合条件
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    cout << a[i][j] << " ";
                }
                cout << endl;
            }
            cout << endl;
        }
        return;
    }
    if (y == N) {  // 列填满了，换行
        dfs(x+1, 0);
        return;
    }
    for (int i = 1; i <= N*N; i++) {  // 枚举数字
        if (!a[x][y] && !b[y] && !c[x] && (!x || y == x || y == N-1-x) && (!x || y == N-1-x || y == x)) {  // 判断是否可用
            a[x][y] = i;
            b[y] += i;
            c[x] += i;
            if (x == y) d[0] += i;
            if (x == N-1-y) d[1] += i;
            dfs(x, y+1);
            if (x == y) d[0] -= i;
            if (x == N-1-y) d[1] -= i;
            a[x][y] = 0;
            b[y] -= i;
            c[x] -= i;
        }
    }
}

int main()
{
    memset(a, 0, sizeof(a));
    memset(b, 0, sizeof(b));
    memset(c, 0, sizeof(c));
    d[0] = d[1] = 0;
    dfs(0, 0);
    return 0;
}

这个程序的时间复杂度很高，需要枚举的情况很多，因此需要耐心等待程序运行结果。