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

最新推荐文章于 2011-06-21 23:01:00 发布

阿波321

最新推荐文章于 2011-06-21 23:01:00 发布

阅读量6k

点赞数 2

分类专栏：思维题目分析砝码分盐问题文章标签： struct div each pointers null search

本文链接：https://blog.csdn.net/livelylittlefish/article/details/6557192

版权

思维题目分析同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

砝码分盐问题

11 篇文章 0 订阅

订阅专栏

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

Content

5.1基本思想

5.2 第2次称量过程

5.3 第3次称量过程

5.4如何创建节点？

5.5输出结果

5.6讨论

附录 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

5. 再改进的方法

从上图中，删除那些有分解结果但结果并非所求的节点，包括中间节点和叶子节点，如下图所示。

那么，能否通过编程直接计算求得上图所有正确的解呢？

——一定可以。关键就看怎么编程实现目标了。

5.1 基本思想

在第4节程序的基础上，继续修改代码，删除weight3()函数，直接在weight2()中对第2次称量并对第2次称量的结果进行再分解(即第3次称量)，并对第3次分解结果进行判断，只有当该称量过程满足目标时，才建立节点，包括第2层和第3层的节点。这样，没有分解结果的节点(包括第2层和第3层的节点)就不会被建立，如上图，叶子节点全部是正确的分解结果。不仅让问题更直观，且节省了空间，虽然空间并不那么重要。

5.2 第2次称量过程

如上所述，第2次称量过程中要对第2次称量分解的结果进行再分解(第3次称量)，并对第3次分解结果进行判断，这就是该方法的重点实现过程，如下。第1次称量过程的代码及具体的代码请参考附录4。

00095: / ** the second division, according to x=x1+x2, y=y1+y2, x1<=x2, y1<=y2
00096:    but, x and y are saved in node1- >to_be_divided_[0] and node1- >to_be_divided_[1].
00097:    so, unify them to be as x.
00098: */
00099: void weight2()
00100: {
00101:    int div = 0, i = 0, k1 = 0, w = 0;
00102:    struct Division_Node *cur = &root;
00103:
00104:    int step = 2;
00105:    for (i = 0; i < cur->child_; i++) //for each node1 in step1
00106:    {
00107:       struct Division_Node *node1 = cur->next_[i]; //step 2 will use all nodes created in step 1
00108:
00109:       //to avoid repeatance
00110:       int to_be_divided = To_Be_Devided;
00111:       if (node1->heap_[node1->to_be_divided_[0]] == node1- >heap_[node1->to_be_divided_[1]])
00112:          to_be_divided-- ;
00113:
00114:       int child1 = 0;
00115:       for (div = 0; div < to_be_divided; div++)//step2, will divide x=heap_[0],y=heap_[1] of node1
00116:       {
00117:          int curpos1 = node1->to_be_divided_[div];
00118:          int x = node1->heap_[curpos1]; //the current heap to be divided
00119:
00120:          for (k1 = 0; k1 < Max_Num; k1++) //divide x=x1+x2, use x in order to be in a uniform
00121:          {
00122:             w = ws[k1];
00123:             int x1 = (x - w)/ 2;
00124:             int x2 = (x + w)/ 2;
00125:             if (x1 % 2 != 0) //no need to judge x2
00126:                continue;
00127:
00128:             struct Division_Node *node2 = NULL;
00129:             int child2 = 0;
00130:
00131:             /** a correct solution, and only in this case, create node2 and node3 */
00132:             child2 = weightx1(curpos1, step, x1, x2, child1, child2, node1, &node2);//divide x1
00133:             if (x2 != x1) //to avoid repeatance
00134:                child2 = weightx2(curpos1, step, x1, x2, child1, child2, node1, &node2);//divide x2
00135:
00136:             if (node2)
00137:             {
00138:                node2->child_ = child2;
00139:                child1++;
00140:             }
00141:          }
00142:       }
00143:       node1->child_ = child1;
00144:    }
00145: }

5.3 第3次称量过程

该方法中，第3次称量过程在weightx1()和weightx2()中完成，且是第2次过程中嵌套进行，即通过weight2()调用完成。由于weightx1()和weightx2()思想相同，此处以weightx2()为例叙述，其他的代码可参考附录4。

00173: int weightx2(int curpos1, int step, int x1, int x2, int child1, int child2, 
00174:    struct Division_Node* node1, struct Division_Node **node2)
00175: {
00176:    int k2 = 0, w = 0;
00177:    int curpos2 = step;
00178:
00179:    for (k2 = 0; k2 < Max_Num; k2++)
00180:    {
00181:       w = ws[k2];
00182:       int x21 = (x2 - w)/ 2; //divide x or y, use x in order to be in a uniform
00183:       int x22 = (x2 + w)/ 2;
00184:       if (x21 % 2 != 0)      //no need to judge x12
00185:          continue;
00186:
00187:       if (x21 + x1 == heap1 || x22 + x1 == heap1)
00188:       {
00189:          *node2 = create_node(node1, *node2, curpos1, curpos2, step, x1, x2, x21, x22,
00190:             child1, child2);
00191:          child2++;
00192:          break;
00193:       }
00194:    }
00195:
00196:    return child2;
00197: }

该分解过程如下。

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

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

(3) 第3次称量：x2=x21+x22, x21<=x22

最后的分解结果为(x1, x21, x22, y)，故需要判断x1+x21或x1+x22是否为heap1=100，如代码所示。实际上，对第1次称量出的y的分解在weight2()第115行的for循环中完成，即统一为以上过程。

5.4 如何创建节点？

如上所述，只有在满足目标时，才建立节点，包括第2层和第3层的节点，即代码中的node2和node3。如下。

00199: struct Division_Node *create_node(struct Division_Node *node1, struct Division_Node *node2,
00200:    int curpos1, int curpos2, int step, int x1, int x2, int x11, int x12, int child1, int child2)
00201: {
00202:    if (node2 == NULL)  //此处放置重复创建node2(当node2有多个儿子节点时)
00203:    {
00204:       //new a node in step 2
00205:       node2 = (struct Division_Node*)malloc(sizeof(struct Division_Node));
00206:       memset(node2, 0, sizeof(struct Division_Node));
00207:       memcpy(node2->heap_, node1->heap_, (Max_Num - 1) * sizeof(int)); //copy from its parent
00208:       node2->parent_be_divided_ = curpos1;
00209:       node2->step_ = step;
00210:       node2->heap_[curpos1] = x1;
00211:       node2->heap_[step] = x2;
00212:       node2->to_be_divided_[0] = curpos1;
00213:       node2->to_be_divided_[1] = step;
00214:       node1->next_[child1] = node2; //link current node1 and node2
00215:    }
00216:
00217:    //new a node in step 3
00218:    struct Division_Node *node3 = (struct Division_Node*)malloc(sizeof(struct Division_Node));
00219:    memset(node3, 0, sizeof(struct Division_Node));
00220:    memcpy(node3->heap_, node2- >heap_, (Max_Num - 1) * sizeof(int)); //copy from its parent
00221:    node3->parent_be_divided_ = curpos2;
00222:    node3->step_ = step + 1;
00223:    node3->heap_[curpos2] = x11;
00224:    node3->heap_[step + 1] = x12;
00225:    node3->to_be_divided_[0] = curpos2; //in fact, this array in step3 needed for dump
00226:    node3->to_be_divided_[1] = step + 1;
00227:    node2->next_[child2] = node3; //link current node2 and node3
00228:
00229:    return node2;
00230: } ? end create_node

5.5 输出结果

-------------------------------------
the results of all correct divisions:
-------------------------------------
280 = 140 + 140
140 = 70 + 70
70 = 30 + 40

280 = 138 + 142
138 = 62 + 76
62 = 24 + 38

280 = 138 + 142
138 = 62 + 76
76 = 38 + 38

280 = 138 + 142
142 = 66 + 76
66 = 24 + 42

280 = 138 + 142
142 = 62 + 80
80 = 38 + 42

这就是所有满足目标的正确称量过程，即上图中的所有叶子节点的值。该方法的3中写法可参考附录4，其输出结果可参考附录5。

5.6 讨论

该方法如其基本思想，对第3次分解结果进行判断，只有当该称量过程满足目标时，才建立节点，包括第2层和第3层的节点，从而叶子节点全部是正确的分解结果，让问题更直观，且节省了大量空间，虽然空间并不那么重要。

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

//weight3.1.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. */ #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(); 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, k2 = 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 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; //divide x1 and x2 int tmpx1 = x1; int tmpx2 = x2; int curpos2 = curpos1; int child2 = 0; struct Division_Node *node2 = NULL; int to_be_divided2 = To_Be_Devided; if (x2 == x1) to_be_divided2--; int count = 0; while (count < to_be_divided2) //for step3, divide x1 or x2 { for (k2 = 0; k2 < Max_Num; k2++) { w = ws[k2]; int x11 = (x1 - w)/2; //divide x or y, use x in order to be in a uniform int x12 = (x1 + w)/2; if (x11 % 2 != 0) //no need to judge x12 continue; /** unify them into the following equations z = x + y, x <= y x = x1 + x2, x1 <= x2 x1 = x11 + x12, x11 <= x12 */ /** a correct solution, and only in this case, create node2 and node3 */ if (x11 + x2 == heap1 || x12 + x2 == heap1) { if (x1 <= x2) node2 = create_node(node1, node2, curpos1, curpos2, step, x1, x2, x11, x12, child1, child2); else node2 = create_node(node1, node2, curpos1, curpos2, step, x2, x1, x11, x12, child1, child2); child2++; break; } } count++; x1 = x2; //divide x2 x2 = tmpx1; //for the judge condition curpos2 = step; } x1 = tmpx1; //restore x1, x2 x2 = tmpx2; if (node2) { node2->child_ = child2; child1++; } } } node1->child_ = child1; } } 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); } }

//weight3.2.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 in a while-loop unify them into the following equations z = x + y, x <= y x = x1 + x2, x1 <= x2 x1 = x11 + x12, x11 <= x12 */ int weight3(int x1, int x2, int curpos1, int child1, int step, struct Division_Node* node1) { int k2 = 0, w = 0; int tmpx1 = x1; int curpos2 = curpos1; int child2 = 0; struct Division_Node *node2 = NULL; int to_be_divided2 = To_Be_Devided; if (x2 == x1) to_be_divided2--; int count = 0; while (count < to_be_divided2) //for step3, divide x1 or x2 { for (k2 = 0; k2 < Max_Num; k2++) { w = ws[k2]; int x11 = (x1 - w)/2; //divide x or y, use x in order to be in a uniform int x12 = (x1 + w)/2; if (x11 % 2 != 0) //no need to judge x12 continue; /** a correct solution, and only in this case, create node2 and node3 */ if (x11 + x2 == heap1 || x12 + x2 == heap1) { if (x1 <= x2) node2 = create_node(node1, node2, curpos1, curpos2, step, x1, x2, x11, x12, child1, child2); else node2 = create_node(node1, node2, curpos1, curpos2, step, x2, x1, x11, x12, child1, child2); child2++; break; } } count++; x1 = x2; //divide x2 x2 = tmpx1; //for the judge condition curpos2 = step; } 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); } }

//weight3.3.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 weightx1 * and weightx2, not like the improved search method. */ #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 weightx1(int curpos1, int step, int x1, int x2, int child1, int child2, struct Division_Node* node1, struct Division_Node **node2); int weightx2(int curpos1, int step, int x1, int x2, int child1, int child2, struct Division_Node* node1, struct Division_Node **node2); 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 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; struct Division_Node *node2 = NULL; int child2 = 0; /** a correct solution, and only in this case, create node2 and node3 */ child2 = weightx1(curpos1, step, x1, x2, child1, child2, node1, &node2); //divide x1 if (x2 != x1) //to avoid repeatance child2 = weightx2(curpos1, step, x1, x2, child1, child2, node1, &node2); //divide x2 if (node2) { node2->child_ = child2; child1++; } } } node1->child_ = child1; } } int weightx1(int curpos1, int step, int x1, int x2, int child1, int child2, struct Division_Node* node1, struct Division_Node **node2) { int k2 = 0, w = 0; int curpos2 = curpos1; for (k2 = 0; k2 < Max_Num; k2++) { w = ws[k2]; int x11 = (x1 - w)/2; //divide x or y, use x in order to be in a uniform int x12 = (x1 + w)/2; if (x11 % 2 != 0) //no need to judge x12 continue; if (x11 + x2 == heap1 || x12 + x2 == heap1) { *node2 = create_node(node1, *node2, curpos1, curpos2, step, x1, x2, x11, x12, child1, child2); child2++; break; } } return child2; } int weightx2(int curpos1, int step, int x1, int x2, int child1, int child2, struct Division_Node* node1, struct Division_Node **node2) { int k2 = 0, w = 0; int curpos2 = step; for (k2 = 0; k2 < Max_Num; k2++) { w = ws[k2]; int x21 = (x2 - w)/2; //divide x or y, use x in order to be in a uniform int x22 = (x2 + w)/2; if (x21 % 2 != 0) //no need to judge x12 continue; if (x21 + x1 == heap1 || x22 + x1 == heap1) { *node2 = create_node(node1, *node2, curpos1, curpos2, step, x1, x2, x21, x22, child1, child2); child2++; break; } } 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); } }

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

-------------------------------------
the results of all correct divisions:
-------------------------------------
280 = 140 + 140
140 = 70 + 70
70 = 30 + 40

280 = 138 + 142
138 = 62 + 76
62 = 24 + 38

280 = 138 + 142
138 = 62 + 76
76 = 38 + 38

280 = 138 + 142
142 = 66 + 76
66 = 24 + 42

280 = 138 + 142
142 = 62 + 80
80 = 38 + 42

思维题目, 树型结构, 砝码分盐

阿波321

关注

2
点赞
踩
15

收藏

觉得还不错? 一键收藏
13
评论
砝码分盐问题——从数学和计算机的角度分析(5)

本博客（http://blog.csdn.net/livelylittlefish ）贴出作者（阿波）相关研究、学习内容所做的笔记，欢迎广大朋友指正！Content0. 问题 1. 一些方法 2. 从数学的角度分析 3. 能否编程计算？ 4. 一个改进的方法 5. 再改进的方法 5.1基本思想5.2 第2次称量过程5.3 第3次称量过程5.4如何创建节点？5.5输出结果5.6讨论6. 能否直接计算
复制链接

扫一扫

专栏目录