我自己琢磨的，恳请大家帮忙论证·

hujunhua

正在计算到3¹⁷。
---------------------------------------------------------------------------------
悲剧呀，下班了回去让程序继续跑，晚上9点钟来看，已经跑完了，应该是生成了一个巨量的一维表mw，内存占用为40%（运行前为17%）。
然后写一个语句，将表输出到一个txt文件，监视显示内存占用很快上升到98%，一会就跳出一个提示：

然后就看到内存占用直线下垮到11%（开启M10之前的水平），一会就回到了17%，所有的变量都恢复成了蓝色（未定义、未赋值的状态）。
可怜我还没有让那个mw 显屏看一眼呢

裴进兵

hujunhua 发表于 2015-6-19 09:47
这个不正确。a(n+d)=a(n)±a(d)的情况，有d>1的情况。
在10000以内，至少d=2的情况我们知道比比皆是，虽 ...

我可以理解为，后面减1或者减3，是可以相互转化的，对吧

hujunhua

比如，79可以四种分解式
1）79=78+1=2·3·13+1=2·3·(3·4+1)+1，a(79)=2+3+3+4+1+1=14
2）79=81-2=3⁴-2, a(79)=3·4+2=14
3）由2）转化：79=3⁴-2=3⁴-3+1=3(3³-1)+1, a(79)=3+3·3+1+1=14.
4）79=80-1=5·2⁴-1, a(79)=5+2·4+1=14.

hujunhua

@ 裴进兵
在3¹⁶以内搜索{2,3,5,7}的组合压缩点，结果全都是5和7的组合压缩点，不干2，3的事。共以下6个：

1）   5⁴·7=4375
2 )    5⁶=15625
3）   5²·7⁴=60025=60024+1=3·82·244+1=3·(3⁴+1)·(3⁵+1)+1, a(60025)=33, 而2a(5)+4a(7)=34.
4）   5·7⁷=4117715
5）   5³·7⁶=14706125
6）   7⁹=40353607

其中5的压缩点5⁶和7的压缩点7⁹在关于b(n)的文献上看到过。

裴进兵

裴进兵 发表于 2015-6-19 23:26
我可以理解为，后面减1或者减3，是可以相互转化的，对吧

我明白了，谢谢，诚挚的感谢！

裴进兵

hujunhua 发表于 2015-6-20 00:51
比如，79可以四种分解式
1）79=78+1=2*3*13+1=2*3*(3*4+1)+1，a(79)=2+3+3+4+1+1=14
2）79=81-2=3^4-2, a ...

明白，一目了然，谢谢，非常感谢！

mathe

计算到2²⁶左右最大k值57(64071257)

mathe

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <assert.h>
   
4. #include <math.h>  
   
5. #define MAXM (1<<26) //max to 2^26
   
6. #define PREDEF_VALUE 32
   
7. #define MUL       1
   
8. #define ADD       2
   
9. #define SUB1      4
   
10. #define SUBM      8
    
11. unsigned short value[MAXM]={0,1, 2, 3, 4, 5, 5, 6, 6, 6, 7, 8, 7, 8, 8, 8, 8, 9, 8, 9, 9, 9, 10, 10, 9, 10, 10, 9, 10, 11, 10, 11, 10};//provide the  unsigned char dtype[MAXM];
    
12. int max_available_m;
    
13. void setall() {
    
14.      int i,j;
    
15.      dtype[1]=MUL;
    
16.      for(i=1;i<=PREDEF_VALUE;i++){
    
17.           if(i>1&&value[i]==value[i-1]+1){
    
18.                dtype[i]|=SUB1;
    
19.           }
    
20.           for(j=1;j<=i;j++){//MUL
    
21.              int k=i*j;int nv=value[i]+value[j];
    
22.              if(value[k]==0||nv<value[k]){
    
23.                   value[k]=nv;dtype[k]=MUL;
    
24.              }else if(nv==value[k]){
    
25.                   dtype[k]|=MUL;
    
26.              }             k=i+j;
    
27.              if(value[k]==0||nv<value[k]){
    
28.                   value[k]=nv;dtype[k]=ADD;
    
29.              }else if(nv==value[k]){
    
30.                   dtype[k]|=ADD;
    
31.              }
    
32.           }
    
33.      }
    
34.      for(i=PREDEF_VALUE+1;i<MAXM;i++){
    
35.           int ub=(int)floor(pow(16.0*i,1.0/3.0));
    
36.           assert(value[i]>0);
    
37.           if(i+ub<=MAXM){
    
38.           max_available_m=i;
    
39.           for(j=1;j<=ub;j++){
    
40.                int nv=value[i+j]+value[j];
    
41.                if(nv<value[i]){
    
42.                    value[i]=nv;dtype[i]=j<6?SUB1:SUBM;
    
43.                }else if(nv==value[i]){
    
44.                    dtype[i]|=j<6?SUB1:SUBM;
    
45.                }
    
46.           }
    
47.      }
    
48.           for(j=1;j<=i&&j<=(MAXM-1)/i;j++){
    
49.                int k=i*j;int nv=value[i]+value[j];
    
50.                if(value[k]==0||nv<value[k]){
    
51.                    value[k]=nv;dtype[k]=MUL;
    
52.                }else if(nv==value[k]){
    
53.                    dtype[k]|=MUL;
    
54.                }
    
55.           }
    
56.           ub=2*ub;
    
57.           for(j=1;j<=i&&j<=MAXM-1-i&&j<=ub;j++){
    
58.                int k=i+j;int nv=value[i]+value[j];
    
59.                if(value[k]==0||nv<value[k]){
    
60.                     value[k]=nv;dtype[k]=ADD;
    
61.                }else if(nv==value[k]){
    
62.                     dtype[k]|=ADD;
    
63.                }
    
64.           }
    
65.      }
    
66. }
    
67.   int main() {
    
68.      int i;
    
69.      setall();
    
70.      for(i=1;i<max_available_m;i++){
    
71.          printf("value[%d]=%d\n", i,value[i]);
    
72.      }
    
73. }
    

复制代码

裴进兵

n-1, n, n+1三个数中必然有一个3倍数，一到两个偶数，这样用加减1来调整成2、3倍数，分解完之后，数字和是不是最小呢？

hujunhua

文献中提到了分解树——用图来表达四则分解的方法。树的中间结点都是乘号或者加号，树的叶结点就是数字1（可带负号）。
实际绘制树图时有所简化：
1、最底层的加号结点用它所含1的数量来代替，其下的多个叶结点1则省略了。这步简并后，新的叶结点就是数字1，2，3等。
2、乘号结点下的多个相同叶结点缩并为一个叶结点，在连结线上标示幂次。
如下 两例：

9573958

9573956

分解树显示了分解式的层次结构。