代码意识流——花朵数问题(七)
本文前一部分的链接
http://www.cnblogs.com/KBTiller/archive/2011/06/05/2073421.html
20.验算
验算过程的基本思路是求出“和”中各个数字有多少个，然后与得到这个"和"的数字组合比较，如果两者一致则“和”是一个花朵数。
例如，由一个5、一个3和一个1可以得到这三个数字的3次方的和为5^3+3^3+1^3==153,而153恰好是由一个5、一个3和一个1这三个数字构成这时就可以断定153是花朵数。
反之，由一个5、一个3和一个2可以得到这三个数字的3次方的和为，5^3+3^3+2^3==160,160中有一个6、一个1和一个0，与求得160的三个数字的组合(5,3,2)不符，这就表明160不是花朵数。
这种算法首先要记录求出数字N次方之和的各个数字的个数。
记录各数字的个数
在"2_穷举.c"定义这种数据类型
typedef unsigned int SHUZI_GESHU[JINZHI];
//SHUZI_GESHU[d]存储数字d的个数
在xunhuan()中定义这种类型的局部变量，显然这应该是static类别的
static SHUZI_GESHU sz_gs ;
记录递归过程中各个数字的个数，并测试
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
//验算<=>记录结果
}
}
测试通过。
接着在xunhuan()中写出验算的代码，判断“和”中数字出现的次数与sz_gs 中的记录是否一致
xunhuan()
{
……
if( 吻合 ( & sz_gs , &he ) == 是 ){ //验算
//<=>记录结果
}
}
吻合 ( & sz_gs , &和 )
{
int 和中各数字的个数[JINZHI];
if( 超过W位(和) == 是 || 不足W位(和) == 是 ){ //#include "3_大数.h"
return 否;
}
求和中各数字的个数（ &和中各数字的个数 , &和 ）；//#include "3_大数.h"
if ( memcmp (和中各数字的个数 ,sz_gs ,sizeof 和中各数字的个数 )==0 ){ //#include <string.h>
return 是;
}
return 否;
}
这段代码涉及到很多回答是或否的问题，由于讨厌在写代码时费神用0或1思考这样的问题，在工程中加入了这样一个文件
/*常用.h*/
#ifndef CHANGYONG_H
#define CHANGYONG_H
typedef enum { SHI , FOU } SF ;
#endif // CHANGYONG_H
并分别在"2_穷举.h"、"3_大数.h"中添加了
#include "常用.h"
现在，“2_穷举.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演变成
/*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"演变为
/*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”演变为
/*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 ;
}
}
}
编译运行，结果为
153
吻合
370
吻合
371
吻合
407
吻合
总算看到点亮了。
