题目

小明被绑架到X星球的巫师W那里。

其时，W正在玩弄两组数据(2 3 5 8)和 (1 4 6 7)
他命令小明从一组数据中分别取数与另一组中的数配对，共配成4对（组中的每个数必被用到）。
小明的配法是：{(8,7),(5,6),(3,4),(2,1)}

巫师凝视片刻，突然说这个配法太棒了！

因为：
每个配对中的数字组成两位数，求平方和，无论正倒，居然相等：

87^2 + 56^2 + 34^2 + 21^2  =  12302
78^2 + 65^2 + 43^2 + 12^2  =  12302

小明想了想说：“这有什么奇怪呢，我们地球人都知道，随便配配也可以啊！”
{(8,6),(5,4),(3,1),(2,7)}

86^2 + 54^2 + 31^2 + 27^2 = 12002
68^2 + 45^2 + 13^2 + 72^2 = 12002

巫师顿时凌乱了。。。。。

请你计算一下，包括上边给出的两种配法，巫师的两组数据一共有多少种配对方案具有该特征。
配对方案计数时，不考虑配对的出现次序。
就是说：
{(8,7),(5,6),(3,4),(2,1)}
与
{(5,6),(8,7),(3,4),(2,1)}
是同一种方案。

注意：需要提交的是一个整数，不要填写任何多余内容（比如，解释说明文字等）

思路分析

先取得全部不重复组合，再计算正和倒的平方和，如果相等，计数变量自增。

取得全部不重复组合

自己想了好久，发现各种代码实现不如枚举来得简单……反正只有24个……

图一
由图一易知当第一组为(2,1)时，共有6种情况，而第一组共有4种可能，所以总共有6x4=24种可能。
所以可以定义一个三维维数组：

int all[24][4][2]={{{2,1},{3,4},{5,6},{8,7}},
                       {{2,1},{3,4},{5,7},{8,6}},
                       {{2,1},{3,6},{5,4},{8,7}},
                       {{2,1},{3,6},{5,7},{8,4}},
                       {{2,1},{3,7},{5,4},{8,6}},
                       {{2,1},{3,7},{5,6},{8,4}},
                       {{2,4},{3,1},{5,6},{8,7}},
                       {{2,4},{3,1},{5,7},{8,6}},
                       {{2,4},{3,6},{5,1},{8,7}},
                       {{2,4},{3,6},{5,7},{8,1}},
                       {{2,4},{3,7},{5,1},{8,6}},
                       {{2,4},{3,7},{5,6},{8,1}},
                       {{2,6},{3,1},{5,4},{8,7}},
                       {{2,6},{3,1},{5,7},{8,4}},
                       {{2,6},{3,4},{5,1},{8,7}},
                       {{2,6},{3,4},{5,7},{8,1}},
                       {{2,6},{3,7},{5,1},{8,4}},
                       {{2,6},{3,7},{5,4},{8,1}},
                       {{2,7},{3,1},{5,4},{8,6}},
                       {{2,7},{3,1},{5,6},{8,4}},
                       {{2,7},{3,4},{5,1},{8,6}},
                       {{2,7},{3,4},{5,6},{8,1}},
                       {{2,7},{3,6},{5,1},{8,4}},
                       {{2,7},{3,6},{5,4},{8,1}}};

另外，我只是一个C语言初学者，如果您有一个合适的取全部不重复组合的算法，请务必联系我，谢谢！

（下面是我想算法时的一些内容，因为不知道自己之后是否能想到更好的算法，所以没有删掉，而是选择用删除线勾掉，请您跳过阅读）
自上而下思考：
2与其他一组的四个数字有四种组合方式，分别为(2,1) (2,4) (2,6) (2,7)
当第一组确定下来是(2,1)后，3与另一组的三个数字有三种组合方式，分别为(3,4) (3,6) (3,7)
当第二组确定下来是(3,4)后，5与另一组的两个数字有两种组合方式，分别为(5,6) (5,7)
当第三组确定下来是(5,6)后，8与另一组的剩下的一个数字就只有一种组合方式，是(8,7)
而当第三组确定下来是(5,7)后，8与另一组的剩下的一个数字就只有一种组合方式，是(8,6)

定义结构体储存数据如下：
struct data{
int first[2];
int second[2];
int third[2];
int fourth[2];
};
~~一个结构体存储一组数据，如组合方式：(2,1) (3,4) (5,6) (8,7)用结构体数组即为：
~~
xxx.first[0]=2;
xxx.first[1]=1;
xxx.second[0]=3;
xxx.second[1]=4;
xxx.third[0]=5;
xxx.third[1]=6;
xxx.fourth[0]=8;
xxx.fourth[1]=7;

取得全部不重复组合算法：
由图一易知当第一组为(2,1)时，共有6种情况，而第一组共有4种可能，所以总共有6x4=24种可能。所以定义全部可能为一个结构体数组，数组长度为24：
struct data all[24];

计算正和倒的平方和

int cnt=0;
    for(int i=0;i<24;i++){
        int sum1=0,sum2=0;
        for(int j=0;j<4;j++){
            sum1+=pow(all[i][j][0]*10+all[i][j][1],2);
        }
        for(int j=0;j<4;j++){
            sum2+=pow(all[i][j][1]*10+all[i][j][0],2);
        }
        if(sum1==sum2){
            cnt++;
        }
    }

完整代码

#include <stdio.h>
#include <math.h>

int main(){
    int all[24][4][2]={{{2,1},{3,4},{5,6},{8,7}},
                       {{2,1},{3,4},{5,7},{8,6}},
                       {{2,1},{3,6},{5,4},{8,7}},
                       {{2,1},{3,6},{5,7},{8,4}},
                       {{2,1},{3,7},{5,4},{8,6}},
                       {{2,1},{3,7},{5,6},{8,4}},
                       {{2,4},{3,1},{5,6},{8,7}},
                       {{2,4},{3,1},{5,7},{8,6}},
                       {{2,4},{3,6},{5,1},{8,7}},
                       {{2,4},{3,6},{5,7},{8,1}},
                       {{2,4},{3,7},{5,1},{8,6}},
                       {{2,4},{3,7},{5,6},{8,1}},
                       {{2,6},{3,1},{5,4},{8,7}},
                       {{2,6},{3,1},{5,7},{8,4}},
                       {{2,6},{3,4},{5,1},{8,7}},
                       {{2,6},{3,4},{5,7},{8,1}},
                       {{2,6},{3,7},{5,1},{8,4}},
                       {{2,6},{3,7},{5,4},{8,1}},
                       {{2,7},{3,1},{5,4},{8,6}},
                       {{2,7},{3,1},{5,6},{8,4}},
                       {{2,7},{3,4},{5,1},{8,6}},
                       {{2,7},{3,4},{5,6},{8,1}},
                       {{2,7},{3,6},{5,1},{8,4}},
                       {{2,7},{3,6},{5,4},{8,1}}};

    int cnt=0;
    for(int i=0;i<24;i++){
        int sum1=0,sum2=0;
        for(int j=0;j<4;j++){
            sum1+=pow(all[i][j][0]*10+all[i][j][1],2);
        }
        for(int j=0;j<4;j++){
            sum2+=pow(all[i][j][1]*10+all[i][j][0],2);
        }
        if(sum1==sum2){
            cnt++;
        }
    }

    printf("%d",cnt);

    return 0;
}

结果

24