A management method and system for automatic storage and scheduling of bee products

Abstract

The present application relates to warehouse management technical field, specifically to a kind of for bee product automatic warehouse scheduling management method and system.The method includes: the node of warehouse scheduling task is structured into Fibonacci heap, node key value is associated with scheduling priority, and product batch and cut-off tendency value attribute are additionally added;When the key value of target node is reduced and less than the key value of parent node, the batch condensation factor of the two is calculated;If condensation factor is greater than the condensation threshold set according to the number of root linked list nodes, the target node is not cut off, the key value of parent node is reduced and recursive determination is made;Otherwise, cut off and move into root linked list, accumulate cut-off tendency value for parent node, and when accumulated tendency value exceeds trigger threshold and is not root node, disconnect and move into root linked list reset and recursive processing;Based on the smallest node sequence, scheduling instruction is executed.The scheme of the present application can guarantee the continuity of batch task scheduling, greatly reduce the empty load moving distance of equipment, and reduce the risk of cold chain violation.

Description

Technical Field

[0001] This invention relates to the field of warehouse management technology. More specifically, this invention relates to a management method and system for automated warehouse scheduling of bee products. Background Technology

[0002] In modern intelligent warehousing systems, scheduling and management determine the overall operational efficiency of goods entering and leaving the warehouse. Systems typically utilize priority queue data structures to achieve optimal resource allocation. Fibonacci heaps, as a common priority queue data structure, offer advantages in reducing the amortized constant time complexity of node key-value operations, theoretically making them suitable for handling frequent high-concurrency priority adjustment tasks in warehousing systems. Bee product warehousing is characterized by batch aggregation operations; continuously processing the same batch of products offers high synergistic benefits in terms of handling paths and environmental control. However, when conventional priority queues adjust node priorities, the cascading disconnection mechanism of the underlying data structure relies solely on simple topological rules, severing the implicit business attribute relationships between task nodes. This leads to the easy separation and fragmentation of related task nodes that originally belonged to the same batch and had high processing cohesion, disrupting batch task continuity and causing frequent cross-batch operations.

[0003] Currently, Chinese patent application CN114896889A discloses an improved multi-objective local search algorithm for optimizing the picking strategy of warehouse stacker cranes. This application addresses the picking scheduling problem in smart warehouses when multiple orders are placed. It optimizes and sorts the sequence of goods to be picked by the stacker crane using a multi-objective local optimization algorithm and sets execution priorities based on the urgency of the order tasks. This improved scheme, based on priority and macro-sequence search, optimizes the stacker crane operation path to a certain extent when multiple batches of orders are concurrent, improving picking continuity.

[0004] However, the technical solution in this application fails to integrate product batch attributes and task cohesion into the maintenance logic of the underlying queue structure. Due to the lack of an evaluation and buffering mechanism based on business closeness, when facing highly related cold chain tasks in the same batch, the application's sorting adjustments based solely on urgency are prone to causing unnecessary cascading cutoff operations in the underlying data structure. This lack of consideration for physical load and batch time affinity means that highly related tasks still face the risk of being decoupled and separated, leading to a disconnect between structural adjustments under the current scheduling and sorting algorithm and the actual batch warehousing business continuity requirements. The fragmentation of underlying business relationships not only increases the ineffective computational overhead of maintaining the system's data structure but also increases the unloaded travel distance of stacker cranes when actually dispatching instructions, thus restricting the throughput efficiency of the overall warehousing equipment. Summary of the Invention

[0005] The purpose of this invention is to propose a management method and system for automatic warehousing and scheduling of bee products, in order to solve the problems of large inefficient computational overhead in maintaining data structures and low throughput efficiency of warehousing equipment in the prior art; to this end, this invention provides solutions in the following two aspects.

[0006] In a first aspect, the present invention provides a management method for automated storage and scheduling of bee products, comprising:

[0007] The data structure for bee product warehousing and scheduling tasks is represented as nodes in a Fibonacci heap. The key value of each node is associated with the scheduling priority of the task, and each node is assigned a product batch attribute and a cutoff tendency attribute. When a key value reduction operation is performed on a target node and the target node's key value is less than that of its parent node, a cascading cutoff decision is executed. The batch cohesion factor between the target node and its parent node based on the product batch attribute is calculated. If the batch cohesion factor is greater than a cohesion threshold set according to the number of nodes in the root linked list of the current heap, the target node is not cut off. Instead, the key value of the parent node is reduced to the target node's key value to maintain the min-heap property, and the process is recursively performed on the parent node. Execute the key value reduction operation and cascade cut-off determination; otherwise, execute the cut-off operation, disconnect the target node from its parent node and move it into the root linked list, and perform cascade cut-off processing on the parent node. Based on the batch cohesion factor, accumulate the cut-off tendency value of the parent node, and determine whether the accumulated cut-off tendency value of the parent node exceeds the cascade trigger threshold. If it exceeds the threshold and the parent node is not the root node, cut it from its own parent node and move it into the root linked list, reset the cut-off tendency value, and recursively perform the accumulated cut-off tendency value and cascade cut-off processing on the parent node's parent node. Based on the minimum node pop sequence of the Fibonacci heap, obtain and execute the scheduling instructions for bee product storage.

[0008] By introducing a batch cohesion factor calculation and threshold judgment mechanism when performing key value reduction operations on target nodes, the node connection is maintained and the parent node key value is reduced synchronously when the correlation is high. This breaks the traditional cascading cut-off mechanism and avoids the warehousing tasks related to the same batch being scattered and separated when priority is adjusted. This ensures the continuity of warehousing processing of products in the same batch and generates scheduling instructions that are more in line with the batch management needs of bee products.

[0009] Furthermore, the process of structuring the bee product warehousing and scheduling task data into nodes of a Fibonacci heap, where the key value of each node is associated with the scheduling priority of the task, and product batch attributes and cutoff tendency attributes are added to each node, includes: extracting the remaining shelf life days and expected processing time from the bee product warehousing and scheduling task; multiplying the sum of the remaining shelf life days and a preset safe number of days greater than zero by the expected processing time to obtain a priority coefficient; setting the priority coefficient as the key value of the node corresponding to the task in the Fibonacci heap; reading the system timestamp of the bee products arriving at the warehouse as the product batch attribute of the node; and initializing the cutoff tendency attribute corresponding to the node to 0.

[0010] By multiplying the sum of the remaining shelf life days and the safe days by the expected processing time to calculate the priority coefficient and setting it as the key value, the absolute urgency of a single task and the overall throughput of warehouse machinery are balanced. This avoids queue congestion caused by individual tasks taking too long and near-expiry tasks monopolizing equipment for a long time, which is caused by using the remaining shelf life as the only criterion. This ensures the total amount of products that can safely enter and leave the warehouse per unit time.

[0011] Further, the calculation of the batch cohesion factor between the target node and the parent node based on the product batch attribute includes: extracting the first arrival system timestamp corresponding to the target node and the second arrival system timestamp corresponding to the parent node; obtaining a preset time constant; the batch cohesion factor value is equal to the ratio of constant 1 to the target denominator; wherein, the target denominator is calculated by: calculating the absolute value of the difference between the first arrival system timestamp and the second arrival system timestamp, dividing the absolute value by the preset time constant, and then adding the quotient to constant 1.

[0012] Further, if the batch cohesion factor is greater than the cohesion threshold set according to the number of nodes in the root linked list of the current heap, it includes: counting the total number of nodes in the root linked list of the current Fibonacci heap; the cohesion threshold is equal to the ratio of the set basic threshold constant to the square root of the total number of nodes; determining whether the batch cohesion factor value is greater than the set cohesion threshold, and outputting the corresponding Boolean determination result.

[0013] Further, the step of accumulating the cutoff tendency value for the parent node based on the batch cohesion factor includes: reading the set cutoff compensation constant from the memory; dividing the cutoff compensation constant by the batch cohesion factor value to calculate the corresponding cutoff tendency value increment; adding the current cumulative cutoff tendency value of the parent node to the cutoff tendency value increment, and using the sum to overwrite the current cumulative cutoff tendency value of the parent node.

[0014] By dividing the cutoff compensation constant by the batch cohesion factor to obtain the cutoff tendency value increment and accumulating it, an inverse relationship between the tendency increment and the batch cohesion factor is achieved. This results in cutoff operations with lower relevance generating larger cutoff tendency value increments, thus improving the node tree response performance in highly discrete warehouse scheduling scenarios.

[0015] Further, determining whether the cumulative cutoff tendency value of the parent node exceeds the cascading trigger threshold includes: extracting the total task load of the scheduled task corresponding to the parent node; dividing the total task load by a preset baseline load to perform dimensionless processing, obtaining a dimensionless load ratio; subtracting the product of the dimensionless load ratio and the adjustment weight constant from a preset global fixed trigger constant, and comparing the calculation result with a preset minimum trigger threshold to take the maximum value, calculating the cascading trigger threshold; comparing the updated cumulative cutoff tendency value of the parent node with the calculated cascading trigger threshold; when the cumulative cutoff tendency value is greater than the cascading trigger threshold, confirming that the cumulative cutoff tendency value of the parent node exceeds the cascading trigger threshold.

[0016] Furthermore, the step of obtaining and executing scheduling instructions for bee product warehousing based on the minimum node pop-out sequence of the Fibonacci stack includes: responding to a scheduling trigger signal, sequentially popping nodes and mapping them as scheduling tasks into a to-do array by repeatedly calling the minimum node extraction interface of the Fibonacci stack, generating a minimum node pop-out sequence until the Fibonacci stack is empty or the maximum number of single scheduling tasks is reached; sequentially extracting the location number and inbound / outbound action type parameter combination of each scheduling task according to the index order in the to-do array and splicing them into a standard control data frame; and sequentially sending all the spliced ​​standard control data frames to the programmable logic controller of the warehouse stacker crane along the Ethernet bus to start the actual inbound / outbound mechanical operation of bee products.

[0017] Furthermore, the step of performing the severing operation, disconnecting the target node from its parent node and moving it into the root linked list, includes: modifying the left and right sibling pointers of the target node to connect them to each other, thereby removing the target node from the parent node's child linked list, and decrementing the degree field of the parent node by 1; modifying the root linked list pointer of the Fibonacci heap and the left and right pointers of the target node, inserting the target node to the left of the pointer of the global minimum node, and setting the flag field of the target node to false.

[0018] By precisely modifying the left and right sibling pointers of the target node to remove it from the parent node's child linked list and inserting it to the left of the global minimum node pointer, the reconstruction of the node disconnection and transfer operation inside the Fibonacci heap is achieved. This ensures the correctness of the internal linking relationship of the data structure is maintained quickly when the detachment operation is performed, and reduces maintenance overhead.

[0019] Further, the step of cutting off from its own parent node and moving into the root linked list, resetting the cutting tendency value, and recursively performing the cumulative cutting tendency value and cascading cutting processing on the parent node's parent node includes: declaring a temporary pointer variable to read and cache the parent node's parent node address; disconnecting the doubly linked list to remove the parent node from its own parent node's child linked list and appending it to the root linked list, while simultaneously setting the parent node pointer to null; resetting the parent node's cumulative cutting tendency value to zero; using the ancestor node cached by the temporary pointer variable as the new parent node for the next round of recursion, using the cut-off parent node as the new target node, re-extracting the arrival system timestamp of the new level node pair, recalculating the batch cohesion factor and the corresponding cutting tendency value increment, and repeatedly performing the process of accumulating the cutting tendency value increment and comparing the threshold until the threshold is triggered as false or the root node is traced back.

[0020] In the second aspect, a management system for automated storage and scheduling of bee products includes: The system includes a processor and a memory storing computer instructions for automated storage and scheduling management of bee products. When the computer instructions are executed by the processor, the system performs the aforementioned management method for automated storage and scheduling of bee products.

[0021] The beneficial effects of this invention are as follows: This invention deeply integrates the underlying queue data structure maintenance logic with the batch management requirements of bee product warehousing scheduling. When adjusting the priority of execution nodes, it can accurately identify and maintain the associated connection status of tasks in the same batch and with high density of scheduling, effectively preventing the frequent fragmentation of highly collaborative continuous tasks. When facing task splitting requirements, it can control the timing of node decoupling through a dynamic buffer evaluation system, significantly reducing ineffective data structure maintenance overhead and suppressing excessively frequent cascading operations. Simultaneously, the system can dynamically weigh the scheduling priority based on the urgency of the task and the physical load status, outputting a sequence of instructions that balances execution priority and continuous operation characteristics. The final generated scheduling instruction sequence guides the orderly operation of the underlying warehousing hardware, minimizing the idle movement distance of equipment such as stacker cranes and robotic arms, effectively reducing the risk of timeout violations in cold chain product outbound operations, and comprehensively improving the throughput efficiency of global warehousing machinery and the overall smoothness of automated warehousing logistics. Attached Figure Description

[0022] Figure 1 The flowchart illustrating the steps of the management method for automated storage and scheduling of bee products in this embodiment is shown in the schematic diagram. Figure 2 This is a schematic diagram illustrating the relationship between the number of nodes and the agglomeration threshold. Figure 3 This is a test chart comparing the comprehensive performance of the multi-dimensional evaluation effect. Detailed Implementation

[0023] The technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention.

[0024] like Figure 1 As shown in this embodiment, a management method for automated storage and scheduling of bee products includes the following steps: Step S1: Structure the bee product warehousing and scheduling task data into nodes of a Fibonacci heap. The key value of the node is associated with the scheduling priority of the task, and product batch attribute and cut-off tendency value attribute are added to the node.

[0025] The system's underlying layer relies on the class keyword in object-oriented programming languages ​​to construct a Fibonacci heap node data structure with multi-dimensional attribute fields. In the class initialization function, multiple member variables are declared, including pointers to parent nodes, pointers to child nodes, left sibling pointers, right sibling pointers, degree number fields, and boolean type flag fields.

[0026] The database connection object is used to access the data table of bee product warehousing orders stored in the structured query language relational database. The urgency timestamp and the countdown value of the product's shelf life are extracted for each task. These two values ​​are weighted and summed to calculate a comprehensive score. This comprehensive score is then written to the key-value member variable of the node using an assignment statement; a smaller key value indicates higher priority.

[0027] At the same time, a string-type batch number variable is added to the class to store the extracted product batch number string as a product batch attribute, and an additional floating-point accumulator variable is set with an initial value of 0 as a cutoff tendency value attribute.

[0028] In an optional embodiment, the step of structuring the bee product warehousing and scheduling task data into nodes of a Fibonacci heap, wherein the key value of the node is associated with the scheduling priority of the task, and product batch attribute and cutoff tendency value attribute are added to the node, includes: extracting the remaining shelf life days and expected processing time from the bee product warehousing and scheduling task; multiplying the sum of the remaining shelf life days and a preset safety day greater than zero by the expected processing time to obtain a priority coefficient; setting the priority coefficient as the key value of the node corresponding to the task in the Fibonacci heap; reading the system timestamp of the bee products arriving at the warehouse as the product batch attribute of the node; and initializing the cutoff tendency value attribute corresponding to the node to 0.

[0029] The warehouse scheduling and management system obtains the physical and business attribute parameters of the currently assigned tasks from the database interface. For example, for a batch of royal jelly requiring cold chain temporary storage, the program extracts the remaining shelf life as 15 days and sets the expected processing time, estimated based on the conveyor belt distance, to 10 minutes. A preset safety day parameter greater than zero is set, with a value ranging from 3 to 7 days. This preventative value effectively avoids products nearing their expiration date having a shelf life close to 0, thus preventing distortion of the overall priority coefficient or the occurrence of anomalies such as multiplication to zero.

[0030] In this embodiment, the safety days are set to 5 days, resulting in a priority coefficient of 200. The system writes the calculated value of 200 as the key value into the key value field of the corresponding task node. The clock is called to obtain the absolute time information when the batch of bee products arrives at the warehouse after unloading, and the timestamp of the current system time, such as 1682837291, is recorded as the product batch attribute of the node. In actual warehouse scheduling scenarios, if only the remaining shelf life is used as the sole absolute criterion, it is easy for some time-consuming and near-expiration tasks to monopolize the stacker crane or robotic arm for a long time, causing a large number of subsequent tasks to experience queue congestion, resulting in a large number of overdue goods. This invention uses the expected processing time as a time cost penalty factor, and when the remaining shelf life is similar, it prioritizes tasks with shorter processing times by assigning smaller key values ​​and higher priorities, thereby balancing the absolute urgency of a single task with the overall warehouse machinery throughput, and fully ensuring the total amount of products safely entering and leaving the warehouse per unit time.

[0031] During node initialization, the native structure pointer is set to null, and the cutoff tendency attribute variable is initialized to 0. This underlying data configuration allows nodes with extended business parameters to be successfully added to the scheduling algorithm's memory pool to await further logical evaluation.

[0032] Step S2: When a key value reduction operation is performed on the target node and the key value of the target node is less than the key value of the parent node, a cascade cut-off determination is performed. The batch cohesion factor of the target node and the parent node based on the product batch attribute is calculated. If the batch cohesion factor is greater than the cohesion threshold set according to the number of root linked list nodes of the current heap, the target node is not cut off. The key value of the parent node is reduced to maintain the min-heap property of the key value of the target node. At the same time, the key value reduction operation and the cascade cut-off determination are recursively performed on the parent node.

[0033] Specifically, in response to a priority update event triggered by a change in the bee product scheduling environment, the system modifies the target node's key-value variable to a new, smaller value. The system obtains the target node's key-value using a member access operator and compares it with the parent node's key-value. If the target node's key-value is less than the parent node's key-value, it extracts the batch number variable string features from both the target node and parent node.

[0034] The edit distance algorithm is used to calculate the Levenstein distance between two strings. This Levenstein distance is added to a constant 1 to obtain the denominator value. Then, the constant 1 is divided by the denominator value to calculate a normalized floating-point number between 0 and 1. The system sets this normalized floating-point number as the batch cohesion factor.

[0035] The algorithm execution logic includes traversing the root linked list of the current Fibonacci heap to calculate the total number of nodes, using the system's built-in mathematical function library to calculate the inverse proportional function value or the reciprocal of the square root of the total number of nodes, and combining it with preset weight coefficients to calculate the set agglomeration threshold, so that the agglomeration threshold is negatively correlated with the total number of nodes in the root linked list, thereby dynamically reducing the requirement of not cutting off when the root node is crowded.

[0036] The batch cohesion factor is compared with the cohesion threshold using branching statements. If the batch cohesion factor is greater than the cohesion threshold, the existing parent-child bidirectional pointer link remains unchanged. An assignment operation is used to overwrite the target node's current key value into the parent node's key value member variable, ensuring the min-heap property requirement of the parent node's key value being less than or equal to the child node's key value is met. The function to decrease the key value is then called again, with the parent node as the new parameter, until the current processing node's key value is greater than or equal to the parent node's key value or the current processing node reaches the root position of the Fibonacci heap. Because the Fibonacci heap follows a top-down topological constraint when extracting the minimum node, the target node must be executed after its parent node. When the batch cohesion factor is greater than the cohesion threshold, it indicates that the parent and child nodes belong to a strongly correlated or similar batch. In this case, the parent node's key value is forcibly reduced to the target node's key value, binding the parent and target nodes into a high-priority execution cluster in the data structure. When the scheduler pops the parent node, the scheduling parsing algorithm will recognize the special parent-child structure formed by the binding and force the priority extraction of the target child node's task data into the execution queue before executing the parent node's task. This not only allows the originally urgent target node to be exposed and enter the ready state as early as possible, but also guides the mechanical equipment to continuously execute the same batch or adjacent storage locations, reducing the idle movement distance of the warehouse stacker crane.

[0037] In an optional embodiment, calculating the batch cohesion factor of the target node and the parent node based on product batch attributes includes: extracting the first arrival system timestamp corresponding to the target node and the second arrival system timestamp corresponding to the parent node; obtaining a preset time constant; the batch cohesion factor value is equal to the ratio of constant 1 to the target denominator; wherein, the target denominator is calculated by: calculating the absolute value of the difference between the first arrival system timestamp and the second arrival system timestamp, dividing the absolute value by the preset time constant, and then adding the quotient to constant 1.

[0038] The specific expression for the batch cohesion factor is: ; In the formula, Batch cohesion factor, The first arrival timestamp of the system. This is the second arrival system timestamp. is the time constant.

[0039] When the algorithm triggers a key-value decrement action on nodes within the heap and initiates a pre-reconstruction check, the system extracts the timestamp parameters of the relevant nodes. For example, it obtains the first system arrival timestamp of the target node representing the latest batch of tasks. Its value is 1682838000, which corresponds to 10:00:00 AM on a certain business day. At the same time, the second arrival system timestamp of the preceding batch tasks that serve as the parent node is extracted. The value is 1682839800, which corresponds to 10:30:00 on the same day.

[0040] Then load the preset time constant. Its value can be set between 3600 seconds and 14400 seconds. Under the current operating environment, The time is configured to represent 3600 seconds per hour. The absolute time difference is calculated to be 1800 seconds. This absolute time difference is divided by the time constant using a normalized division operation, yielding a value of 0.5. The target denominator is 0.5 plus the constant 1, resulting in 1.5.

[0041] Substituting the aforementioned specific values ​​into the batch cohesion factor formula, the batch cohesion factor is obtained. =0.67. This calculation result accurately maps the degree of temporal proximity to a weight value between 0 and 1 using a dimensionless fractional algorithm, indicating that there is a temporal affinity between batches of bee products. This makes it less likely that tasks that are closer in time will be split up or cut off, thereby maintaining the continuous outbound delivery of goods with similar environmental timeliness requirements.

[0042] In an optional embodiment, if the batch cohesion factor is greater than the cohesion threshold set according to the number of nodes in the root linked list of the current heap, the steps include: counting the total number of nodes in the root linked list of the current Fibonacci heap; the cohesion threshold is equal to the ratio of the set basic threshold constant to the square root of the total number of nodes; determining whether the batch cohesion factor value is greater than the set cohesion threshold, and outputting the corresponding Boolean determination result.

[0043] Before evaluating whether to truncate the target node, the system obtains the current lateral node status of the heap structure to control structural balance. The algorithm calculates the total number N of nodes currently attached to the Fibonacci heap root list. For example, when the system has accumulated a large number of jobs, the extracted total number N is 144.

[0044] Meanwhile, the configuration table stores the set basic threshold constant k, whose value can be set between 0.5 and 2.0. Here, the preset value of 1.2 is used. The system performs a square root operation on the number of nodes 144, which yields 12. Dividing the constant 1.2 by 12, the currently set agglomeration threshold T is 0.1.

[0045] The program then calls a comparison logic instruction to compare the batch cohesion factor value of 0.67 obtained in the previous step with the threshold of 0.1. Since 0.67 is greater than 0.1, the system outputs the corresponding Boolean judgment result as true. This calculation mode not only combines the temporal closeness of the two nodes themselves, but also utilizes the macroscopic topological parameters of the entire heap, which can mitigate the structural flattening phenomenon caused by excessively moving nodes to the root layer when there are many root nodes.

[0046] The relationship between the total number of nodes and the agglomeration threshold is as follows: Figure 2 As shown in the figure, the curve illustrates the variation of the agglomeration threshold calculation model used in this application. The horizontal axis represents the total number of nodes, and the vertical axis represents the set dimensionless agglomeration threshold.

[0047] Within the x-coordinate range of 0 to 25, when the total number of nodes attached to the root linked list is small, i.e., the heap structure is relatively loose, the agglomeration threshold is in the high range of 0.4 to 1.2, indicating that the agglomeration threshold calculated by the system remains at a relatively high level. Based on this, the system can allow more nodes to maintain parent-child connections within the Fibonacci heap, prioritizing the continuous execution of tasks with high batch correlation. As the total number of nodes on the x-coordinate continues to increase towards 50 and even 200, the heap structure becomes more crowded, and the agglomeration threshold rapidly decreases according to the set inverse square root function mechanism, eventually stabilizing around 0.1.

[0048] The aforementioned trend in the cohesion threshold indicates that by dynamically lowering the threshold requirement for triggering non-cut-off conditions under node congestion, it is possible to effectively prevent the system from becoming extremely flat due to excessively promoting internal nodes to the root layer when facing massive discrete tasks.

[0049] Step S3: Otherwise, perform a cut-off operation, disconnect the target node from its parent node and move it into the root linked list, and perform cascade cut-off processing on the parent node. Based on the batch cohesion factor, accumulate the cut-off tendency value of the parent node, and determine whether the accumulated cut-off tendency value of the parent node exceeds the cascade trigger threshold. If it exceeds the threshold and the parent node is not the root node, cut it from its own parent node and move it into the root linked list, reset the cut-off tendency value, and recursively perform the accumulated cut-off tendency value and cascade cut-off processing on the parent node's parent node.

[0050] The system determines that the current operating condition is under the logic branch where the batch cohesion factor is less than or equal to the cohesion threshold, and performs a doubly linked list disconnection operation to complete the structural decoupling. Specifically, it modifies the left and right sibling pointers of the target node to connect them, thereby removing the target node from the parent node's child linked list and decrementing the parent node's degree field by 1; it also modifies the root linked list pointer of the Fibonacci heap and the left and right pointers of the target node, inserting the target node to the left of the global minimum node pointer, and setting the target node's flag field to false.

[0051] The program instruction performs a division operation by dividing the constant 1 by the batch cohesion factor to obtain the tendency increment value, thereby establishing an inverse proportional relationship between the data. The control system then uses a compound assignment operator to accumulate this tendency increment value into the parent node accumulator variable, calls the system configuration read interface to obtain the floating-point cascading trigger threshold constant preset in the initialization configuration file, and uses the greater than sign comparison operator to compare the current value of the parent node accumulator variable with the cascading trigger threshold constant.

[0052] When the judgment result is true and the parent node is confirmed to be non-root node by checking that the parent node contains an upper-level associated pointer that is not null, the algorithm continues to execute the cascade judgment and reorganization step. Specifically, a temporary pointer variable is declared to read and cache the address of the parent node; the doubly linked list is disconnected, the parent node is removed from its own parent node's child linked list and appended to the root linked list, and the parent node pointer is set to null to disconnect; the cumulative severance tendency value of the parent node is reset to 0; the ancestor node cached in the temporary pointer variable is used as the new parent node for the next round of recursion, and the severed parent node is used as the new target node. The arrival system timestamp of the new level node pair is re-extracted, the batch cohesion factor and the corresponding severance tendency value increment are recalculated, and the process of accumulating the severance tendency value increment and comparing the threshold is repeated until the threshold judgment is false or the root node is traced back.

[0053] In an optional embodiment, the step of accumulating the cutoff tendency value for the parent node based on the batch cohesion factor includes: reading a set cutoff compensation constant from the memory; dividing the cutoff compensation constant by the batch cohesion factor value to calculate the corresponding cutoff tendency value increment; adding the current cumulative cutoff tendency value of the parent node to the cutoff tendency value increment, and using the sum to overwrite the current cumulative cutoff tendency value of the parent node.

[0054] When the Boolean result is false, indicating insufficient time affinity and allowing cutoff, the control algorithm will calculate the cumulative cutoff tendency value. The system first reads the set cutoff compensation constant, which can be adjusted between 0.2 and 0.8. In this embodiment, the value is set to 0.4 under the control conditions.

[0055] At this point, assuming the batch cohesion factor value calculated by the cut-off sub-task node and the parent node is 0.2, the program performs division with 0.4 as the dividend and 0.2 as the divisor to obtain the value 2, which is the increment of the cut-off tendency value.

[0056] After the calculation is complete, the system reads the cumulative cutoff tendency value of the parent node representing the current cutoff task. For example, if the cutoff tendency value variable of the parent node has reached 1.5, the system adds the old value of 1.5 to the increment of 2 to obtain the latest value of 3.5.

[0057] Subsequently, the system overwrites the parent node's current cumulative pruning tendency value with the summed value of 3.5. This numerical update process, through cumulative calculation, enables pruning operations with low correlation to generate a pruning tendency value increment that is inversely proportional to the batch cohesion factor, thereby improving the node tree response performance under highly discrete warehouse scheduling.

[0058] In an optional embodiment, determining whether the cumulative cutoff tendency value of the parent node exceeds the cascading trigger threshold includes: extracting the total task load of the scheduled task corresponding to the parent node; dividing the total task load by a preset baseline load to perform dimensionless processing, obtaining a dimensionless load ratio; subtracting the product of the dimensionless load ratio and the adjustment weight constant from a preset global fixed trigger constant, and comparing the calculation result with a preset minimum trigger threshold to take the maximum value, calculating the cascading trigger threshold; comparing the updated cumulative cutoff tendency value of the parent node with the calculated cascading trigger threshold; when the cumulative cutoff tendency value is greater than the cascading trigger threshold, confirming that the cumulative cutoff tendency value of the parent node exceeds the cascading trigger threshold.

[0059] The system's internal scheduler calculates the cascading trigger threshold based on the loading status. The program reads the total load weight information of the task from the inbound / outbound order details bound to the parent node. For example, the weight data of a whole pallet of packaged propolis is 750kg. The system retains a preset baseline load weight, for example, a configuration parameter of 1000kg. Dividing 750kg by 1000kg yields a dimensionless load weight ratio of 0.75.

[0060] The system then acquires a series of set benchmark control parameters, where the global fixed trigger constant can range from 3.0 to 5.0, and the adjustment weight constant can range from 1.0 to 2.0. In this embodiment, the two constants are set to 4.0 and 2.0, respectively. Multiplying 0.75 by the adjustment weight constant 2.0 yields a product of 1.5. Then, subtracting 1.5 from the global fixed trigger constant gives the calculated difference of 2.5.

[0061] The system calculates a difference of 2.5 and compares it with the preset minimum trigger threshold, then extracts the maximum value. Here, the minimum trigger threshold is set to 1.5, and the system determines that the actual cascading trigger threshold for this parent node is 2.5 after comparison.

[0062] Based on this, the system extracts the updated cumulative cutoff tendency value of 3.5 for comparison. Since 3.5 is greater than the cascading trigger threshold of 2.5, the system confirms that the cumulative cutoff tendency value of the parent node exceeds the cascading trigger threshold. The program sends a notification to the heap manager, instructing the system to perform a decoupling action on the node to remove it from the upper-layer structure.

[0063] Step S4: Based on the minimum node pop sequence of the Fibonacci heap, obtain and execute the scheduling instructions for bee product storage.

[0064] Specifically, the core algorithm for extracting the minimum node of a Fibonacci heap is invoked. The scheduling task node with the smallest key value and the highest priority is obtained by accessing the global minimum node pointer. All child nodes of this minimum node are then sequentially removed from their child linked lists and added to the root linked list of the Fibonacci heap. Subsequently, the system releases or logically deletes the minimum node entity from memory.

[0065] Create an array of node pointers indexed by the degree of each node. Traverse all nodes in the merged root list, connect nodes with the same degree through a tree merging operation so that no two nodes with the same degree exist in the root list. Then rescan the merged root list and update the global minimum node pointer.

[0066] The core algorithm for extracting the minimum node described above is repeatedly called within a loop control structure until the entire Fibonacci heap is empty, thus generating a sequence of minimum nodes popped from high to low priority. The product batch number and task data contained in each popped node are packaged and encapsulated into a message payload in Extensible Markup Language (XML) format. This message payload is sent to the underlying programmable logic controller (PLC) via a socket communication mechanism based on the Transmission Control Protocol (TCP). The PLC converts the received sequence instructions into level signals that drive the trolley and robotic arm storage hardware. Various devices complete the corresponding bee product batch's inbound or outbound handling and stacking actions according to the popped order.

[0067] In an optional embodiment, obtaining and executing scheduling instructions for bee product storage based on the minimum node pop-out sequence of the Fibonacci stack includes: responding to a scheduling trigger signal, sequentially popping nodes and mapping them as scheduling tasks into a to-do array by repeatedly calling the minimum node extraction interface of the Fibonacci stack, generating a minimum node pop-out sequence until the Fibonacci stack is empty or the maximum number of single scheduling tasks is reached; sequentially extracting the location number and inbound / outbound action type parameter combination of each scheduling task according to the index order in the to-do array and splicing them into a standard control data frame; and sequentially sending all the spliced ​​standard control data frames to the programmable logic controller of the warehouse stacker crane along the Ethernet bus to start the actual inbound / outbound mechanical operation of bee products.

[0068] Specifically, when a scheduling trigger signal is detected, the system iteratively calls the Fibonacci heap's minimum node extraction interface, sequentially popping nodes with the lowest priority key values ​​and mapping them as scheduled tasks, storing them in a to-do array. This iterative process continues until the heap is determined to be empty, or the number of popped nodes reaches the set limit for a single scheduling operation. For example, if this limit is set to 10, the system stops the extraction process and generates a minimum node popping sequence.

[0069] After obtaining the execution sequence, the location number and inbound / outbound action type parameters for each scheduling task are extracted sequentially according to the index order in the to-do array. These parameters are then combined and concatenated into a standard control data frame. This control data frame is sequentially sent along the Ethernet bus to the programmable logic controller (PLC) of the warehouse stacker crane, which then initiates the actual inbound / outbound mechanical operations of the bee products.

[0070] A high-concurrency cold chain warehousing simulation environment for honeycomb products was constructed, continuously injecting 3000 inbound and outbound scheduling tasks. The task arrival times followed a Poisson distribution, and the task loads were randomly generated between 200kg and 1000kg. The hardware environment was uniformly configured with an eight-core processor and a server with large-capacity memory. A traditional standard scheduling algorithm was run as the control group, and a scheduling algorithm applying all the improved attributes of this application was run as the experimental group. The performance indicators were extracted and compared under the condition of continuous high-load operation for 8 hours.

[0071] In the control group, the total computation and execution time of the scheduling algorithm for all tasks was 14,500 seconds. During this period, the underlying nodes triggered frequent cascading cut-off and reassembly operations 860 times, resulting in an average idle travel distance of 450 meters per task for the warehouse stacker crane and a cold chain outbound timeout violation rate of 4.2%. In the experimental group, after applying the technical solution of this application, the total processing time for the exact same task set was reduced to 12,100 seconds, the number of cascading cut-off operations was reduced to 215, the average idle travel distance of the warehouse stacker crane decreased to 320 meters per task, and the cold chain outbound timeout violation rate decreased to 0.5%.

[0072] The comprehensive performance comparison test results between the traditional scheduling algorithm control group and the improved experimental group of this application are as follows: Figure 3 As shown, all indicators were normalized to a baseline of 100, using the control group values ​​as a benchmark. The horizontal axis of the figure lists four evaluation dimensions in sequence: total system scheduling computation time, stack structure cascade disconnection operation, average idle travel distance of the stacker crane, and cold chain outbound timeout violation rate; the vertical axis represents the relative values ​​of each indicator. In each evaluation dimension, the bars on the left with a uniform height aligned to the value of 100 represent the normalized baseline data of the traditional scheduling algorithm, while the bars on the right with varying degrees of height reduction represent the test data of the improved experimental group of this invention.

[0073] from Figure 3 As can be seen, in terms of the total system scheduling computation time, the value of the right-hand bar has decreased to around 83, reflecting that the algorithm of this invention significantly improves the overall computational efficiency of the system when processing the same massive set of scheduling tasks. In terms of stack structure cascading cut-off operations, the right-hand bar shows a significant decrease, with its value plummeting and stabilizing at around 25, only about 1 / 4 of the traditional standard algorithm, indicating that the maintenance frequency of the underlying data structure has significantly decreased after adopting the technical solution of this invention. In terms of the average idle travel distance of the stacker crane, the bar of the improved experimental group has fallen back to around 71. This significant decrease reflects a significant reduction in meaningless back-and-forth movement of the physical hardware equipment in the automated warehouse, effectively avoiding idle cross-area runs caused by scattered and fragmented tasks. In terms of the cold chain outbound timeout violation rate, the right-hand bar representing the experimental group of this invention has shrunk dramatically to around 12. The significant reduction in the violation rate reflects that most cold chain bee products facing the risk of expiration and spoilage have received timely and proper priority outbound circulation.

[0074] The present invention also provides a management system for automated storage and scheduling of bee products. The system includes a processor and a memory, the memory storing computer program instructions. When the processor executes the computer program instructions, it implements the above-described management method for automated storage and scheduling of bee products according to the present invention.

[0075] The system also includes other components well known to those skilled in the art, such as communication buses and communication interfaces, the settings and functions of which are known in the art and therefore will not be described in detail here.

[0076] While various embodiments of the invention have been shown and described in this specification, it will be apparent to those skilled in the art that such embodiments are provided by way of example only. Many modifications, alterations, and alternatives will occur to those skilled in the art without departing from the spirit and essence of the invention.

Claims

1. A management method for automated storage and scheduling of bee products, characterized in that, include: The data of bee product warehousing and scheduling tasks is structured into nodes of a Fibonacci heap. The key value of the node is associated with the scheduling priority of the task, and product batch attribute and cut-off tendency value attribute are added to the node. When a key value reduction operation is performed on a target node and the key value of the target node is less than the key value of the parent node, a cascade cutoff determination is performed. The batch cohesion factor of the target node and the parent node based on the product batch attribute is calculated. If the batch cohesion factor is greater than the cohesion threshold set according to the number of root linked list nodes of the current heap, the target node is not cut off. The key value of the parent node is reduced to maintain the min-heap property of the key value of the target node. At the same time, the key value reduction operation and the cascade cutoff determination are recursively performed on the parent node. Otherwise, a cut-off operation is performed, disconnecting the target node from its parent node and moving it into the root linked list. Then, a cascade cut-off process is performed on the parent node. The cut-off tendency value is accumulated for the parent node based on the batch cohesion factor. It is determined whether the accumulated cut-off tendency value of the parent node exceeds the cascade trigger threshold. If it exceeds the threshold and the parent node is not the root node, it is cut off from its own parent node and moved into the root linked list. The cut-off tendency value is reset, and the accumulated cut-off tendency value and cascade cut-off process are recursively performed on the parent node's parent node. Based on the minimum node pop sequence of the Fibonacci heap, the scheduling instructions for bee product storage are obtained and executed.

2. The management method for automated storage and scheduling of bee products according to claim 1, characterized in that, The data structure for bee product warehousing and scheduling tasks is formatted as nodes in a Fibonacci heap. The key-value pairs of these nodes are associated with the scheduling priority of the tasks. Furthermore, product batch attributes and cutoff tendency attributes are added to each node, including: Extract the remaining shelf life days and expected processing time from the bee product storage and scheduling task; The priority coefficient is obtained by multiplying the sum of the remaining shelf life days and the preset safe days (greater than zero) by the expected processing time. The priority coefficient is set to the key value of the corresponding node of the task in the Fibonacci heap; Read the system timestamp of the bee products arriving at the warehouse as the product batch attribute of the node; The cutoff tendency attribute corresponding to the node is initialized to 0.

3. The management method for automated storage and scheduling of bee products according to claim 1, characterized in that, The calculation of the batch cohesion factor between the target node and the parent node based on product batch attributes includes: Extract the first arrival system timestamp of the target node and the second arrival system timestamp of the parent node; Obtain the preset time constant; The batch cohesion factor value is equal to the ratio of constant 1 to the target denominator; wherein, the target denominator is calculated by: calculating the absolute value of the difference between the first arrival system timestamp and the second arrival system timestamp, dividing the absolute value by the preset time constant, and then adding the quotient to constant 1.

4. The management method for automated storage and scheduling of bee products according to claim 1, characterized in that, The statement that if the batch cohesion factor is greater than the cohesion threshold set according to the number of root linked list nodes of the current heap includes: Count the total number of nodes in the root linked list of the current Fibonacci heap; The aggregation threshold is equal to the ratio of the set basic threshold constant to the square root of the total number of nodes; Determine whether the batch coagulation factor value is greater than the set coagulation threshold, and output the corresponding Boolean determination result.

5. The management method for automated storage and scheduling of bee products according to claim 1, characterized in that, The step of accumulating the cutoff tendency value for the parent node based on the batch cohesion factor includes: Read the set cutoff compensation constant from the memory; Divide the cutting compensation constant by the batch cohesion factor value to calculate the corresponding cutting tendency value increment; Add the current cumulative cutoff tendency value of the parent node to the increment of the cutoff tendency value, and use the sum to overwrite the current cumulative cutoff tendency value of the parent node.

6. The management method for automated storage and scheduling of bee products according to claim 1, characterized in that, The step of determining whether the cumulative cutoff tendency value of the parent node exceeds the cascading trigger threshold includes: Extract the total workload of the scheduled task corresponding to the parent node; Divide the total load of the task by the preset benchmark load and perform dimensionless processing to obtain the dimensionless load ratio. The cascade trigger threshold is calculated by subtracting the product of the dimensionless load ratio and the adjustment weight constant from the preset global fixed trigger constant, comparing the calculation result with the preset minimum trigger threshold and taking the maximum value. Compare the updated cumulative cutoff tendency value of the parent node with the calculated cascading trigger threshold; When the cumulative cutoff tendency value is greater than the cascading trigger threshold, it is confirmed that the cumulative cutoff tendency value of the parent node exceeds the cascading trigger threshold.

7. The management method for automated storage and scheduling of bee products according to claim 1, characterized in that, The process of obtaining and executing scheduling instructions for bee product storage based on the minimum node pop sequence of the Fibonacci heap includes: In response to the scheduling trigger signal, the minimum node extraction interface of the Fibonacci heap is called in a loop to pop nodes one by one and map them as scheduling tasks and store them in the to-do array, generating a minimum node pop sequence until the Fibonacci heap is empty or the maximum number of single scheduling is reached. According to the index order in the to-do array, extract the location number and inbound / outbound action type parameter combination of each scheduling task and splice them into a standard control data frame. All the standard control data frames that have been spliced ​​together are sent sequentially to the programmable logic controller of the warehouse stacker crane along the Ethernet bus to start the actual mechanical operation of bee products entering and leaving the warehouse.

8. The management method for automated storage and scheduling of bee products according to claim 1, characterized in that, The step of performing the severing operation, which disconnects the target node from its parent node and moves it into the root linked list, includes: Modify the left and right sibling pointers of the target node to connect them, thereby removing the target node from the parent node's child list and decrementing the parent node's degree field by 1; Modify the root linked list pointer of the Fibonacci heap and the left and right pointers of the target node, insert the target node to the left of the pointer of the global minimum node, and set the flag field of the target node to false.

9. The management method for automated storage and scheduling of bee products according to claim 1, characterized in that, The step of cutting off the node from its parent node and moving it into the root linked list, resetting the cutting tendency value, and recursively performing accumulating cutting tendency values ​​and cascading cutting processing on the parent nodes of the parent node includes: Declare a temporary pointer variable to read and cache the address of the parent node; Disconnecting a doubly linked list removes the parent node from its own parent's child list and appends it to the root list, while simultaneously setting the parent node's pointer to null to disconnect it. The cumulative cut-off tendency value of the parent node is reset to zero to complete the reset; The ancestor node cached by the temporary pointer variable is used as the new parent node for the next round of recursion. The cut-off parent node is used as the new target node. The arrival system timestamp of the new level node pair is extracted again. The batch cohesion factor and the corresponding cut-off tendency value increment are recalculated. The process of accumulating the cut-off tendency value increment and comparing the threshold is repeated until the threshold is triggered as false or the root node is traced back.

10. A management system for automated storage and scheduling of bee products, characterized in that, include: processor; A memory storing computer instructions for automated storage and scheduling management of bee products, which, when executed by the processor, cause the system to perform the management method for automated storage and scheduling of bee products according to any one of claims 1-9.

Images