static void xunhuan( const int gssx /*个数上限*/,
const int sz /*关于哪个数字*/,
DASHU (*p_hang)[WEISHU + 1] /*指向一行数据*/)
{
static DASHU he = { { 0 } } ;//static DASHU he ; // =0 待完成
DASHU he_ = he ; //记录累加前的值 //记录累加前的值
static SHUZI_GESHU sz_gs ;

if( sz > 0 ){
int i;
for( i = 0 ; i <= gssx ; i++ ){
sz_gs[sz] = i ; //记录数字的个数
ds_jiaru ( &he , *p_hang + i ) ;
xunhuan( gssx - i , sz - 1 , p_hang + 1 );
he = he_ ; //恢复原来的值
}
}
else{
sz_gs[sz] = gssx ; //记录数字的个数
#ifdef CESHI
{
int i;
for ( i = 0 ; i < JINZHI ; i++ ){
printf("%d*%d " , sz_gs[i] , i );
}
putchar('\n');
}
#endif
//验算<=>记录结果
}
}

/*常用.h*/

#ifndef CHANGYONG_H
#define CHANGYONG_H

typedef enum { SHI , FOU } SF ;

#endif // CHANGYONG_H

/*2_穷举.h*/

#ifndef QIONGJU_H
#define QIONGJU_H

/**************************类型定义**************************/
#include "3_大数.h"
#include "常用.h"

/**************************函数原型**************************/

extern void qiongju( void );
#include <stdlib.h> //malloc()

#endif // QIONGJU_H

/*2_穷举.c*/

#include "2_穷举.h"
#include "0_问题.h"

typedef unsigned int SHUZI_GESHU[JINZHI];
//SHUZI_GESHU[d]存储数字d的个数

typedef DASHU SHUJUBIAO[JINZHI-1][WEISHU + 1];
//0*(JINZHI-1)^N 1*(JINZHI-1)^N ……WEISHU*(JINZHI-1)^N
//0*(JINZHI-2)^N 1*(JINZHI-2)^N ……WEISHU*(JINZHI-1)^N
//……
//0*(1)^N 1*(1)^N ……WEISHU*(1)^N

static void xunhuan(const int , const int , DASHU (*)[WEISHU + 1] ) ;

static void jianli_sjb ( SHUJUBIAO * * ); //建立数据表

static SF wenhe( SHUZI_GESHU * const , const DASHU * const);

static SF wenhe( SHUZI_GESHU * const p_sz_gs ,
const DASHU * const p_he )
{
int sz_gs_he[JINZHI] = { 0 }; //和中各数字的个数

if( chaoguo_W(p_he) == SHI // 超过W位 || 不足W位
|| buzu_W (p_he) == SHI ){
return FOU ;
}

qiu_sz_gs( &sz_gs_he , p_he ); // 求和中各数字的个数

if ( memcmp ( sz_gs_he , *p_sz_gs , sizeof sz_gs_he )==0 ){
return SHI ;
}
return FOU ;

}

//建立数据表
static void jianli_sjb ( SHUJUBIAO * * p_p_sjb )
{
if( (* p_p_sjb = malloc(sizeof(SHUJUBIAO)) ) == NULL ){ //#include <stdlib.h>
exit(!EXIT_SUCCESS);
}

{
int i , j ;
for( i = 0 ; i < JINZHI - 1 ; i ++){
ds_fuzhi( *( * * p_p_sjb + i ) + 0 , 0 );//第一列为0
ds_fuzhi( *( * * p_p_sjb + i ) + 1 , 1 );//第二列先赋值为1
for( j = 0 ; j < N ; j ++ ){ //求N次幂
ds_chengyi( *( * * p_p_sjb + i ) + 1 , JINZHI - 1 - i );
}
for( j = 2 ; j <= WEISHU ; j ++ ){
(*( * * p_p_sjb + i ))[j] = (*( * * p_p_sjb + i ))[j-1] ;
ds_jiaru ( *( * * p_p_sjb + i ) + j , *( * * p_p_sjb + i ) + 1 ) ;
}
}
}
}

extern void qiongju( void )
{
SHUJUBIAO *p_sjb = NULL ;

jianli_sjb ( & p_sjb ); //建立数据表
xunhuan( WEISHU , JINZHI-1 , *p_sjb ) ;
free ( p_sjb );

}

static void xunhuan( const int gssx /*个数上限*/,
const int sz /*关于哪个数字*/,
DASHU (*p_hang)[WEISHU + 1] /*指向一行数据*/)
{
static DASHU he = { { 0 } } ;//static DASHU he ; // =0 待完成
DASHU he_ = he ; //记录累加前的值 //记录累加前的值
static SHUZI_GESHU sz_gs ;

if( sz > 0 ){
int i;
for( i = 0 ; i <= gssx ; i++ ){
sz_gs[sz] = i ; //记录数字的个数
ds_jiaru ( &he , *p_hang + i ) ;
xunhuan( gssx - i , sz - 1 , p_hang + 1 );
he = he_ ; //恢复原来的值
}
}
else{
sz_gs[sz] = gssx ; //记录数字的个数

if( wenhe ( & sz_gs , &he ) == SHI ){ //验算两者是否"吻合"
#ifdef CESHI
ds_shuchu ( & he );
puts("吻合");
#endif
//<=>记录结果
}
}
}

/*3_大数.h*/

#ifndef DASHU_H
#define DASHU_H

#include "0_问题.h" //DASHU用到了WEISHU

/**************************类型定义**************************/
//gw_sz[0]为个位，gw_sz[WEISHU-1]为最高位
//gw_sz[WEISHU-1]的值大于等于JINZHI表示溢出
typedef struct {
int gw_sz[WEISHU] ;
}
DASHU ;
#include "常用.h"

/**************************函数原型**************************/

extern void ds_fuzhi ( DASHU * const , const int ) ;
extern void ds_shuchu( const DASHU * const ) ;
extern void ds_jiaru ( DASHU * const , const DASHU * const ) ;
extern void ds_chengyi( DASHU * const , const int );
extern SF chaoguo_W(const DASHU * const);
extern SF buzu_W(const DASHU * const);
extern void qiu_sz_gs( int (*)[JINZHI] , const DASHU * const ) ;

#endif // DASHU_H

/*3_大数.c*/
#include "3_大数.h"

static void ds_jinwei ( DASHU * const );

//统计*p_he中的各数字个数=> *p_sz_gs
extern void qiu_sz_gs( int (*p_sz_gs)[JINZHI] , const DASHU * const p_he )
{
int * t = p_he->gw_sz ;
while( t < p_he->gw_sz + WEISHU ){
(*p_sz_gs)[*t++] ++ ;
}

}

extern SF buzu_W(const DASHU * const p_ds)
{
if(p_ds->gw_sz[WEISHU-1] == 0 ){
return SHI ;
}
return FOU ;
}
//判断是否超过WEISHU
extern SF chaoguo_W(const DASHU * const p_ds)
{
if(p_ds->gw_sz[WEISHU-1] >=JINZHI ){
return SHI ;
}
return FOU ;
}

//* p_ds *= cs
extern void ds_chengyi( DASHU * const p_ds , const int cs )
{
int * t = p_ds->gw_sz ;
while( t < p_ds->gw_sz + WEISHU ){
*t++ *=cs ;
}
ds_jinwei ( p_ds );
}

//进位
static void ds_jinwei ( DASHU * const p_ds )
{
int * t = p_ds->gw_sz , * const w = t + WEISHU - 1 ;
while( t < w ){
*( t + 1 ) += * t / JINZHI ;
* t ++ %= JINZHI ;
}
}

// *p_he += *p_js
extern void ds_jiaru ( DASHU * const p_he , const DASHU * const p_js )
{
int *he_t = p_he->gw_sz , * const he_w = he_t + WEISHU ; //- 1 ;
const int *js_t = p_js->gw_sz ;
while( he_t < he_w ){
*he_t++ += *js_t++ ;
}
ds_jinwei ( p_he ); // static void ds_jinwei ( DASHU * const );
}

extern void ds_shuchu( const DASHU * const p_ds )
{
int * const t = p_ds->gw_sz , *w = t + WEISHU - 1 ;
while( w > t && *w == 0 ){ //高位0不输出
w--;
}
while( w > t ){
printf( "%d" , * w -- );
}
printf( "%d\n" , * t ) ;
}

//在*p_ds中写入n
extern void ds_fuzhi ( DASHU * const p_ds , const int n )
{
p_ds->gw_sz[0] = n ;
//可能有进位，同时把高位写为0
{
int *t = p_ds->gw_sz , //指向 p_ds->gw_sz[0]
*w = t + WEISHU - 1 ; //指向 p_ds->gw_sz[WEISHU-1]
while( t < w ){
*( t + 1 ) = * t / JINZHI ;
* t ++ %= JINZHI ;
}
}
}