砝码分盐问题——从数学和计算机的角度分析(6)

本文链接：https://blog.youkuaiyun.com/livelylittlefish/article/details/6557225

本文从数学和计算机的角度深入探讨了砝码分盐问题，提出了一种直接计算所有正确解的方法。通过第3次称量过程的直接计算，避免了繁琐的分解过程，简化了算法。附带的代码实现展示了这一方法的有效性，能够输出所有正确的盐分解过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本博客（http://blog.youkuaiyun.com/livelylittlefish ）贴出作者（阿波）相关研究、学习内容所做的笔记，欢迎广大朋友指正！

Content

6.1基本思想

6.2 第3次称量过程

6.3如何创建节点？

6.4结果

6.5讨论

附录 1 ：数学分解的代码weight1.c

附录 2 ：数学分解程序weight1 的运行结果

附录 3 ：树结构分解的代码weight2.c

附录 4 ：再改进的方法的代码weight3.1.c/3.2.c/3.3.c

附录 5 ：再改进的方法的代码weight3.1.c/3.2.c/3.3.c 的输出结果

附录 6 ：直接计算正确分解的代码weight4.c

附录 7 ：一个更简单的方法的代码weight5.1.c/5.2.c/5.3.c

6. 能否直接计算求出所有正确解？

第3、4节的讨论，均是从这个角度出发：即找到所有有结果的分解并在所有结果中判断哪些分解过程是满足目标的分解。

而第5节的讨论，从对第3次称量结果直接进行判断其是否满足目标这个角度出发。

能否再转换一下思路？——能否直接计算求出所有正确的解？

The answer is yes!

6.1 基本思想

第2次分解(称量)后，直接将满足目标的第3次称量解求出，判断这个计算出来的第3次称量所用的砝码是否在砝码组合内。如果在，表明该次称量过程为所求的正确解；否则，放弃，继续判断。如下图。

——听起来，这个方法要简单地多。

6.2 第3次称量过程

根据该基本思想，改写第5节的程序，第1、2次称量过程与第5节基本相同，不再列出，此处描述第3次称量过程。

设3次称量过程统一为以下过程。

(1) 第1次称量：z=x+y, x<=y

(2) 第2次称量：x=x1+x2, x1<=x2

(3) 第3次称量：对x1(x2)直接计算满足目标的x11和x12(x21和x22)，下面重点描述。

若对x1称量，假设被分解为x1=x11+x12(这里x11和x12的大小不定)，则最后的分解结果为(x11,x12,x2,y)，则直接计算出满足目标的x11=heap1-x2，根据x11计算x12=x1-x11，由此得出w=x11-x12或x12-x11，然后在ws数组中查找w是否是已知的砝码，若是，则该分解即为所求的正确分解；否则，继续。代码如下。

00136: /** the 3rd weight, in this function, divide x1 and x2
00137:    unify them into the following equations
00138:    z = x + y, x <= y
00139:    x = x1 + x2, x1 <= x2
00140:    x1 = x11 + x12, x11 <= x12
00141:    that is, the salts divided: x11, x12, x2, y, then x11+x2=heap1 or x12+x2=heap
00142:    the basic thoughts: get x11(or x12)=heap1- x2, then, get x12(or x11)=x1- x11(or x12)
00143:    then, get w=x12- x11, find w in ws, if found, it is a correct division; otherwise, not a
00144:    correct division, do next.
00145: */
00146: int weight3(int x1, int x2, int curpos1, int child1, int step, struct Division_Node* node1)
00147: {
00148:    int k = 0, w = 0;
00149:    int curpos2 = curpos1;
00150:    int child2 = 0;
00151:    struct Division_Node *node2 = NULL;
00152:
00153:    //divide x1
00154:    {
00155:       int x11 = heap1 - x2;
00156:       int x12 = x1 - x11;
00157:       if (x11 <= x12)
00158:          w = x12 - x11;
00159:       else
00160:          w = x11 - x12;
00161:
00162:       for (k = 0; k < Max_Num; k++)
00163:       {
00164:          if (ws[k] == w)
00165:          {
00166:             node2 = create_node(node1, node2, curpos1, curpos2, step,
00167:                x1, x2, x11, x12, child1, child2);
00168:             child2++;
00169:             break;
00170:          }
00171:       }
00172:    }
00173:
00174:    //divide x2
00175:    if (x2 != x1) //to avoid repeatance
00176:    {
00177:       int x21 = heap1 - x1;
00178:       int x22 = x2 - x21;
00179:       if (x21 <= x22)
00180:          w = x22 - x21;
00181:       else
00182:          w = x21 - x22;
00183:
00184:       curpos2 = step;
00185:       for (k = 0; k < Max_Num; k++)
00186:       {
00187:          if (ws[k] == w)
00188:          {
00189:             node2 = create_node(node1, node2, curpos1, curpos2, step,
00190:                x1, x2, x21, x22, child1, child2);
00191:             child2++;
00192:             break;
00193:          }
00194:       }
00195:    }
00196:
00197:    if (node2)
00198:    node2->child_ = child2;
00199:
00200:    return child2;
00201: }

6.3 如何创建节点？

同5.4节。此处省略，具体代码请参考附录6。

6.4 结果

同5.5节，输出结果为所有正确的分解过程。

6.5 讨论

该方法直接计算满足目标的第3次分解，好理解，也进一步简化了分解过程。

附录6：直接计算正确分解的代码weight4.c

/** * the proble of dividing salt using weight. * a heap of salt with 280g, divide it into two small heaps of salt with 100g and 180g * respectively, in 3 steps. the weights are 4g and 14g. there is a balance of course. * * this is an direct-solving approach based on the improved search method. * that is, in the second weighth, direct-solving the problem, weight2 call weight3, * not like the improved search method (weight3 is called by the upper control program * after weight2). */ #include <stdio.h> #include <stdlib.h> #include <string.h> #define Max_Num 5 #define To_Be_Devided 2 #define total 280 //the total weight of the heap of salt int ws[]={0, 4, 10, 14, 18}; //all cases of the weights combination int heap1 = 100, heap2 = 180; //the target weight of the two samll heaps of salt struct Division_Node { int parent_be_divided_; //array to_be_divided_[] divided from its parent with this index int step_; //the node step in the division process int heap_[Max_Num - 1]; //all divisions of its parent position for all weights int to_be_divided_[2]; //salt heap index to be divided in next step struct Division_Node *next_[2 * Max_Num]; //all pointers to all child divisions int child_; //the numbe of children (not NULL in array next_) }; //the root, for step 1, heap_[0] will be divided static struct Division_Node root = {0, 0, {total}, {0}, {NULL}, 0}; void weight1(); void weight2(); int weight3(int x1, int x2, int curpos1, int child1, int step, struct Division_Node* node1); struct Division_Node *create_node(struct Division_Node *node1, struct Division_Node *node2, int curpos1, int curpos2, int step, int x1, int x2, int x11, int x12, int child1, int child2); void dump_all_results(struct Division_Node* node); void free_all_nodes(struct Division_Node* node); int main(/* int argc, char** argv */) { weight1(); weight2(); printf("-------------------------------------/n"); printf("the results of all correct divisions:/n"); printf("-------------------------------------/n"); dump_all_results(&root); free_all_nodes(&root); return 0; } /** the first division, according to z=x+y, x <= y */ void weight1() { int div = 0, k = 0, w = 0; struct Division_Node *cur = &root; int child = 0; int step = 1; for (div = 0; div < To_Be_Devided - 1; div++) //for step 1, only divide heap_[0] { int curpos = cur->to_be_divided_[div]; int z = cur->heap_[curpos]; //the current heap to be divided for (k = 0; k < Max_Num; k++) { w = ws[k]; int x = (z - w)/2; //divide z int y = (z + w)/2; if (x % 2 != 0) //no need to judge y[k] continue; //new a node in step 1 struct Division_Node *node1 = (struct Division_Node*)malloc(sizeof(struct Division_Node)); memset(node1, 0, sizeof(struct Division_Node)); node1->parent_be_divided_ = curpos; node1->step_ = step; node1->heap_[curpos] = x; node1->heap_[step] = y; node1->to_be_divided_[0] = curpos; node1->to_be_divided_[1] = step; cur->next_[child++] = node1; //link root and node1 } } cur->child_ = child; } /** the second division, according to x=x1+x2, y=y1+y2, x1<=x2, y1<=y2 but, x and y are saved in node1->to_be_divided_[0] and node1->to_be_divided_[1]. so, unify them to be as x. */ void weight2() { int div = 0, i = 0, k1 = 0, w = 0; struct Division_Node *cur = &root; int step = 2; for (i = 0; i < cur->child_; i++) //for each node1 in step1 { struct Division_Node *node1 = cur->next_[i]; //step 2 will use all nodes created in step 1 //to avoid repeatance int to_be_divided = To_Be_Devided; if (node1->heap_[node1->to_be_divided_[0]] == node1->heap_[node1->to_be_divided_[1]]) to_be_divided--; int child1 = 0; for (div = 0; div < to_be_divided; div++) //for step 2, will divide x=heap_[0], y=heap_[1] of node1 { int curpos1 = node1->to_be_divided_[div]; int x = node1->heap_[curpos1]; //the current heap to be divided int child2 = 0; for (k1 = 0; k1 < Max_Num; k1++) //divide x=x1+x2, use x in order to be in a uniform { w = ws[k1]; int x1 = (x - w)/2; int x2 = (x + w)/2; if (x1 % 2 != 0) //no need to judge x2 continue; child2 = weight3(x1, x2, curpos1, child1, step, node1); //call weight3 to divide x1 and x2 if (child2 > 0) child1++; } } node1->child_ = child1; } } /** the 3rd weight, in this function, divide x1 and x2 unify them into the following equations z = x + y, x <= y x = x1 + x2, x1 <= x2 x1 = x11 + x12, x11 <= x12 that is, the salts divided: x11, x12, x2, y, then x11+x2=heap1 or x12+x2=heap the basic thoughts: get x11(or x12)=heap1-x2, then, get x12(or x11)=x1-x11(or x12) then, get w=x12-x11, find w in ws, if found, it is a correct division; otherwise, not a correct division, do next. */ int weight3(int x1, int x2, int curpos1, int child1, int step, struct Division_Node* node1) { int k = 0, w = 0; int curpos2 = curpos1; int child2 = 0; struct Division_Node *node2 = NULL; //divide x1 { int x11 = heap1 - x2; int x12 = x1 - x11; if (x11 <= x12) w = x12 - x11; else w = x11 - x12; for (k = 0; k < Max_Num; k++) { if (ws[k] == w) { node2 = create_node(node1, node2, curpos1, curpos2, step, x1, x2, x11, x12, child1, child2); child2++; break; } } } //divide x2 if (x2 != x1) //to avoid repeatance { int x21 = heap1 - x1; int x22 = x2 - x21; if (x21 <= x22) w = x22 - x21; else w = x21 - x22; curpos2 = step; for (k = 0; k < Max_Num; k++) { if (ws[k] == w) { node2 = create_node(node1, node2, curpos1, curpos2, step, x1, x2, x21, x22, child1, child2); child2++; break; } } } if (node2) node2->child_ = child2; return child2; } struct Division_Node *create_node(struct Division_Node *node1, struct Division_Node *node2, int curpos1, int curpos2, int step, int x1, int x2, int x11, int x12, int child1, int child2) { if (node2 == NULL) { //new a node in step 2 node2 = (struct Division_Node*)malloc(sizeof(struct Division_Node)); memset(node2, 0, sizeof(struct Division_Node)); memcpy(node2->heap_, node1->heap_, (Max_Num - 1) * sizeof(int)); //copy from its parent node2->parent_be_divided_ = curpos1; node2->step_ = step; node2->heap_[curpos1] = x1; node2->heap_[step] = x2; node2->to_be_divided_[0] = curpos1; node2->to_be_divided_[1] = step; node1->next_[child1] = node2; //link current node1 and node2 } //new a node in step 3 struct Division_Node *node3 = (struct Division_Node*)malloc(sizeof(struct Division_Node)); memset(node3, 0, sizeof(struct Division_Node)); memcpy(node3->heap_, node2->heap_, (Max_Num - 1) * sizeof(int)); //copy from its parent node3->parent_be_divided_ = curpos2; node3->step_ = step + 1; node3->heap_[curpos2] = x11; node3->heap_[step + 1] = x12; node3->to_be_divided_[0] = curpos2; //in fact, this array in step3 needed for dump node3->to_be_divided_[1] = step + 1; node2->next_[child2] = node3; //link current node2 and node3 return node2; } //visit each leaf node (all leaf nodes are the division result) void dump_all_results(struct Division_Node* node) { int i = 0, j = 0, k = 0; struct Division_Node *cur = node; for (i = 0; i < cur->child_; i++) //for each node1 in step1 { struct Division_Node *node1 = cur->next_[i]; for (j = 0; j < node1->child_; j++) //for each node2 of node1 in step2 { struct Division_Node *node2 = node1->next_[j]; for (k = 0; k < node2->child_; k++) //for each node3 of node2 in step 3 { struct Division_Node *node3 = node2->next_[k]; printf("%d = %d + %d/n", total, node1->heap_[node1->to_be_divided_[0]], node1->heap_[node1->to_be_divided_[1]]); printf("%d = %d + %d/n", node1->heap_[node2->parent_be_divided_], node2->heap_[node2->to_be_divided_[0]], node2->heap_[node2->to_be_divided_[1]]); printf("%d = %d + %d/n/n", node2->heap_[node3->parent_be_divided_], node3->heap_[node3->to_be_divided_[0]], node3->heap_[node3->to_be_divided_[1]]); } } } } void free_all_nodes(struct Division_Node* node) { int i = 0, j = 0, k = 0; struct Division_Node *cur = node; for (i = 0; i < cur->child_; i++) //for each node1 in step1 { struct Division_Node *node1 = cur->next_[i]; for (j = 0; j < node1->child_; j++) //for each node2 of node1 in step2 { struct Division_Node *node2 = node1->next_[j]; for (k = 0; k < node2->child_; k++) //for each node3 of node2 in step 3 { struct Division_Node *node3 = node2->next_[k]; free(node3); } free(node2); } free(node1); } }