A Big Data-Based Optimization Method for Constrained Allocation of Construction Resources

Abstract

This invention discloses a big data-based optimization method for resource constraint allocation in construction projects, specifically in the field of construction engineering resource management. It addresses the problem of unsynchronized material placement, work site access, access control, and mutual exclusion control in existing scheduling processes, leading to waiting times, equipment idling, access congestion, and a disconnect between scheduling and on-site rhythm. The method reads work windows using a unified timescale and subscribes to material placement events to generate time anchors. Constraint fragments are extracted based on these anchors, and access control records and mutual exclusion rules are transcribed into work site access conditions to form a constraint fragment set. A resource feasible domain is constructed, and a four-state closed-loop adjudication is performed to filter candidate time periods and output an initial allocation table. The initial allocation table is then verified, mismatches are marked, and the constraint fragment set is written back. Based on mismatches, a rolling recalculation is triggered, retaining unexecuted fragments in the main closed loop, outputting a stable allocation table, and solidifying the criterion references.

Description

Technical Field

[0001] This invention relates to the field of building engineering resource management, and more specifically, to a method for optimizing the allocation of building construction resource constraints based on big data. Background Technology

[0002] Construction organization uses a unified timescale to connect planning, modeling, and material handling. The progress platform divides work windows and issues work group and equipment deployment arrangements. The building information modeling platform records components, processes, and mutual exclusion relationships. The material platform synchronizes arrival, inspection, warehousing, distribution, and placement status. On-site access control and passageways record entry, exit, and occupancy trajectories. Resource allocation optimization is primarily driven by work windows, aiming to achieve continuous input and output of personnel, equipment, and materials according to queue status under the constraints of release and clearing criteria, forming a complete link from arrival, entry, operation to evacuation.

[0003] However, when a work window is considered a directly executable time period, material placement, work surface access, passage release, and mutual exclusion control are not met simultaneously. Resource scheduling results in waiting for personnel and equipment idling as soon as the window begins. When access is restricted, the release criteria cannot be triggered, and the clearing criteria are misaligned, causing subsequent scheduling to deviate from the on-site rhythm. The cross-area migration of shared equipment is delayed on the execution side because the passage and procedural steps are not synchronously mapped into execution conditions. Material arrival only remains in the status record and is not converted into available conditions for entering the work surface. Delayed handling and placement encroach on the limited passage and work surface capacity, resulting in queues and congestion on site. The cross-operation mutual exclusion and safety distance in the building information modeling platform are not converted into calculable work surface capacity. When multiple tasks are superimposed on the same work surface in the scheduling, actual execution cannot be carried out simultaneously.

[0004] To address the aforementioned problems, a technical solution is provided. Summary of the Invention

[0005] To overcome the aforementioned deficiencies of the prior art, embodiments of the present invention provide a construction resource constraint allocation optimization method based on big data. By anchoring the work window and material placement events under a unified time scale, the method transcribes the channel release records and mutual exclusion rules into executable constraint fragments. A single admission result is generated using a four-state closed decision of reachability, accessibility, operability, and retraction. Simultaneously, short-term yield gaps are merged through bridging checks to eliminate execution fragmentation. Subsequently, local rolling rearrangement is driven by landing verification and mismatch write-back to keep the main closed segment stable, thereby solving the problems mentioned in the background art.

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] S1: Read the job window and subscribe to the material placement event in a unified time scale, and generate a job window table and placement event stream as the time anchor point for execution judgment;

[0008] S2: Extract executable constraint fragments based on the work window table and the in-place event flow, and transcribe the channel release record and mutual exclusion rules into work surface access conditions to obtain a set of constraint fragments;

[0009] S3: Construct a resource feasible domain using a set of constraint fragments, execute a four-state closed decision at the admission decision point, filter candidate time periods for work groups and equipment based on the synchronous coherence of reachability, entry, operation and exit, and output the initial allocation table.

[0010] S4: Use access control records, hoisting trajectory and progress logs to verify the initial allocation table, mark the segments that do not meet the release criteria and clear criteria as mismatches and write them back to the constraint segment set;

[0011] S5: Trigger rolling recalculation based on mismatch annotations, perform local rearrangement and replacement of unexecuted segments while retaining the main closed segment, output a stable allocation table and solidify the reference relationship between the release criteria and the clear criteria.

[0012] Furthermore, in step S1, the work window data is read from the progress platform to generate a work window table, and the in-place events are subscribed from the material platform to generate an in-place event stream. The work window table and the in-place event stream are aligned with a unified time scale to perform anchor point verification and form a time anchor point for execution determination.

[0013] Furthermore, in step S2, the available time period sequence and entry / exit order of the channel are parsed from the channel release record, conflicting task pairs and safety distance requirements are parsed from the mutual exclusion rules, and the available time period sequence of the channel and the mutual exclusion rule extraction set are segmented according to the start and end times of the work window table to form a preliminary constraint fragment list.

[0014] Furthermore, in step S2, the material placement dependency is bound from the in-place event flow to the preliminary constraint fragment list to generate a bound constraint fragment list. Each bound constraint fragment is extended to include the dependency trigger time and material identifier, and a one-to-one mapping is established between the bound constraint fragment list and the job window table to generate a constraint fragment set.

[0015] Furthermore, in step S3, resource feasible regions are established by grouping the constraint fragment set according to the window number of the job window table, forming a temporal grid for each job window. In the resource feasible region, the reachability status is determined based on the channel release record, the entry status is determined based on the job surface admission condition, the workability status is determined based on the job window table and mutual exclusion rules, and the exit status is determined based on the clearing criterion and exit rules. A four-state Boolean sequence is generated. A set of closed segments is formed by searching for continuous time periods that simultaneously satisfy all four states as true from the four-state Boolean sequence. A bridging test is performed on adjacent closed segments in the set of closed segments. When the start and end order is consistent and the entry and exit conditions are continuous, they are merged into a set of bridged closed segments.

[0016] Furthermore, in step S3, the bridge-connected closed segments whose starting point matches the start time of the operation window table and whose ending point covers the clearing requirement are selected from the bridge-connected closed segment set as the main closed segments. The closed state results are generated, including full closure, half closure and unclosed types. For the full closure main closed segment, the start time of the main closed segment, the end time of the main closed segment, the operation surface identifier, the task type and the four-state reference are mapped to the team candidate and the equipment candidate to form an allocation entry. For the half closure, the allocation entry of the main closed segment is retained and a replacement request is generated for the tail segment. For the unclosed, the window entry is removed and the bridge-connected closed segment set is written back to the constraint segment set and written into the initial allocation table.

[0017] Furthermore, in step S4, entry and exit trajectory data are loaded from access control records to form an access control trajectory dataset, material movement logs are loaded from hoisting trajectories to form a hoisting trajectory dataset, and work execution records are loaded from progress logs to form a progress log dataset. For each main closed segment in the initial allocation table, the entry time and release criteria are checked from the access control trajectory dataset and hoisting trajectory dataset, and the entry deviation and release status are calculated. The start time and exit completion time of the work are checked from the progress log dataset and access control trajectory dataset, and the work deviation and exit deviation are calculated to form an extended verification result set. Each main closed segment includes a deviation value and a verification status.

[0018] Furthermore, in step S4, based on the extended verification result set, the main closed segments that do not meet the release criteria are marked as reachable mismatch, the main closed segments that do not meet the admission conditions are marked as enterable mismatch, the main closed segments that have mutual exclusion conflicts are marked as mismatchable, and the main closed segments that do not meet the clearing criteria are marked as regressable mismatch. Restriction descriptions are added to the corresponding segments in the constraint segment set with the start and end times of the main closed segments and the mismatch type as keys. The extended mismatch field of the constraint segment set is updated and persisted to the database.

[0019] Further, in step S5, mismatch annotations are read from the constraint fragment set to form a mismatch fragment list. Based on the mismatch fragment list and the initial allocation table, the subset of unexecuted fragments is identified and the main closed segment set is isolated. A sequence of replacement candidate fragments is generated from the constraint fragment set and the in-place event stream. Local rearrangement is performed on the replacement candidate fragment sequence to form a temporary rearrangement chain. It is verified that the reachable state, enterable state, workable state, and exitable state of all nodes in the temporary rearrangement chain are true and in continuous order. The rearranged fragment chain that has passed the verification is output.

[0020] Furthermore, in step S5, the optimal item of the rearranged fragment chain is used to replace the unexecuted fragment subset and concatenate it with the isolated main closed segment set to generate a stable allocation table. Four-state references and constraint descriptions are extracted from the stable allocation table entries to generate reference key-value pairs. The reference key-value pairs are associated with the replacement time period to form a traceability chain and archived to the audit log. Each audit log entry contains a window sequence number, a reference key-value pair, and a constraint fragment number, which serve as the basis for traceable execution.

[0021] The technical effects and advantages of the big data-based construction resource constraint allocation optimization method of this invention are as follows:

[0022] This invention, under a unified timescale, uses the work window and material placement event as anchors to transcribe channel release and mutual exclusion rules into executable constraint fragments. A single admission result is generated using a four-state closed-loop decision (reachable, enterable, operable, and regressable). Simultaneously, short-term yield gaps are merged through bridging checks to eliminate execution fragmentation. Subsequently, local rolling rearrangement is driven by landing verification and mismatch write-back to maintain the stability of the main closed segment. This achieves semantic consistency between allocation results, release criteria, clearing criteria, and queue status, forming a continuous link between resource allocation and work rhythm. It reduces waiting time at work stations and equipment idling, alleviates channel occupancy and congestion, and enhances the consistency, predictability, and traceability of progress execution, thus providing robust support for the on-site implementation of resource constraint allocation. Attached Figure Description

[0023] Figure 1 This is a flowchart illustrating the construction resource constraint allocation optimization method based on big data according to the present invention. Detailed Implementation

[0024] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0025] Example 1: Figure 1 This invention presents a method for optimizing the allocation of construction resources based on big data constraints, including:

[0026] S1 reads the job window and subscribes to material placement events in a unified time scale, generating a job window table and placement event stream as the time anchor point for execution judgment.

[0027] S2 extracts executable constraint fragments based on the work window table and the in-place event flow, and transcribes the channel release records and mutual exclusion rules into work surface access conditions to obtain a set of constraint fragments.

[0028] S3 constructs a resource feasible domain using a set of constraint fragments, performs a four-state closed-loop decision at the admission decision point, filters candidate time periods for work groups and equipment based on the synchronous coherence of reachability, accessibility, operability, and retraction, and outputs an initial allocation table.

[0029] S4 uses access control records, hoisting trajectory and progress logs to verify the initial allocation table, marks the segments that do not meet the release criteria and clearing criteria as mismatches and writes them back to the constraint segment set.

[0030] S5 triggers rolling recalculation based on mismatch annotations, performs local rearrangement and replacement of unexecuted segments while retaining the main closed segment, outputs a stable allocation table and solidifies the reference relationship between the release criteria and the clear criteria.

[0031] In the optimization method for resource constraint allocation in construction, the construction organization divides work windows and issues work group and equipment input arrangements through a schedule platform. Simultaneously, the material platform synchronizes the arrival, inspection, warehousing, allocation, and placement status of materials to achieve a complete link from resource arrival, entry, operation, to withdrawal. However, existing resource scheduling often suffers from delays due to the failure to simultaneously satisfy material placement, work surface access, passage release, and mutual exclusion control, leading to waiting at work, equipment idling, and discrepancies between subsequent scheduling and on-site rhythm. To address this issue, step S1 reads work windows under a unified time scale and subscribes to material placement events, generating a work window table and placement event stream as time anchors for execution decisions. This provides precise time boundaries and event triggering bases for subsequent constraint extraction and feasible domain construction, ensuring that resource allocation criteria remain synchronized with on-site status and avoiding execution deviations caused by parameter drift.

[0032] Step S1.1 Read the job window data from the progress platform.

[0033] The progress platform stores work window information from the construction organization plan, including the start and end times of each window, as well as the associated work surface identifier and task type. Reading commands are invoked from the progress platform interface to extract the raw data records of all work windows one by one, based on preset construction project identifiers. Specifically, for each work window, its start time is recorded. (Unit: UTC timestamp, indicating the precise start time of the plan) End time (Unit: UTC timestamp, indicating the precise time of plan completion) Work area identification (In string format, used to uniquely identify the associated physical work area, such as "Floor 3A Area") and task type (Enumerated values, such as "concrete pouring" or "reinforcement binding," are used for subsequent constraint mapping.) The reading process uses a batch query mode. First, a connection session with the progress platform is established. Then, all unexecuted windows under the current project are filtered using SQL-like query statements. After ensuring data integrity, the data is temporarily stored in a memory buffer after verification. The output of this step is the unformatted raw dataset of job windows, which serves as the direct input for generating the job window table.

[0034] Step S1.2 Subscribe to the material platform in place event stream.

[0035] The materials platform maintains a log of material status changes from arrival to placement, including trigger events for inspection, warehousing, allocation, and placement completion. A subscription request is initiated from the materials platform's event subscription interface, specifying the filtering conditions for listening to material placement events, i.e., only capturing change notifications with a status of "placement complete". Specifically, for each placement event, its occurrence time is captured. (Unit: UTC timestamp, indicating the available completion time for material handover) Material Identifier (String format, used to uniquely identify a specific material batch, such as "steel rebar batch M-001") Associated work area identifier (Consistent with step S1.1, used to match the job window) and in-place status. (Boolean value, always true, indicating availability). The subscription uses a real-time streaming push mechanism. After establishing a persistent connection, it receives notifications through an event queue buffer and immediately parses the JSON payload of each event upon arrival, ensuring that the event sequence accumulates in chronological order. The output of this step is a real-time updated raw sequence of in-place events, which serves as direct input for generating the in-place event stream.

[0036] Step S1.3 Generate the job window table structure.

[0037] Based on the original dataset of job windows output in step S1.1, a structured job window table is constructed. This table uses a relational data format, with each row corresponding to one job window, and columns including start time. End time Work surface markings and task type The generation process first sorts the original dataset by start time. Sort the data in ascending order, then iterate through each row and verify the time interval. The system checks whether the job meets a preset minimum job duration threshold (e.g., at least 30 minutes to exclude invalid windows). Window windows that do not meet this threshold are marked as invalid and excluded. Next, an index column is added to the table, including the window number (an auto-incrementing integer starting from 1) and the time hash value (based on...). and (A combined MD5 digest is used for fast retrieval). Finally, the formatted table is persisted to a local database or in-memory table as a time boundary reference on the planning side. This step ensures that the job window table becomes the sole time anchor input for constraint fragment extraction in the subsequent step S2.

[0038] Step S1.4 generates the in-place event stream sequence.

[0039] Based on the original sequence of in-place events output in step S1.2, an ordered in-place event stream is constructed. This stream uses a time-series data format, with each item corresponding to an in-place event, and its attributes include the occurrence time. Material identification Related work surface identification and in place The generation process first filters out duplicates from the original sequence, then sorts them by material identifier. Check for duplicate events and keep only the most recent one. Then press Sort the events in ascending order to form a continuous chain. When traversing the sequence, for each event, perform an association check. If the event matches the job face identifier in the job window table of step S1.3, a dependency tag (a boolean value indicating the binding relationship with the window) is added; otherwise, it is marked as an isolated event and temporarily stored in the standby queue. Finally, the ordered stream is serialized and saved as a subscribing stream object as a dynamic trigger reference for material availability. This step outputs the in-place event stream, ensuring that it is aligned with the timescale of the job window table, providing an event anchor point for the material in-place dependency mapping in step S2.

[0040] Step S1.5 Unify time scale alignment and anchor point verification.

[0041] The job window table generated in step S1.3 and the in-place event stream generated in step S1.4 are aligned and verified under a unified time scale. The unified time scale refers to the global UTC time base, ensuring that all time attributes (such as...) are aligned. , , All are converted to this baseline. The processing traverses each window in the job window table, querying the in-place event stream. Falling All events within the interval, if a match exists Then, inject the event reference list (containing matching events) into the corresponding row of the job window table. and (Array); if no match is found, an empty list is injected and a potential delay warning is recorded. Verification uses a time window intersection algorithm, that is, for each window, the coverage ratio is calculated. The numerator is the sum of the durations of the matched events (assuming each event lasts a fixed number of units of time), and the denominator is the window duration, ensuring... If the value exceeds the preset standard, the anchor point is marked as valid; otherwise, an alarm is triggered but generation is not interrupted. Finally, the aligned job window table and the in-place event stream are output as the dual anchor point set for execution determination. Upon completion of this step, all anchor point data maintain consistent parameter definitions, facilitating step S2's extraction of executable constraint fragments based on the job window table and the in-place event stream.

[0042] Step S1 establishes the time basis for resource allocation optimization by reading job window data from the progress platform, subscribing to material platform placement events, generating a job window table and placement event stream, and performing unified timescale alignment and anchor point verification. This eliminates the risks of waiting for equipment to arrive at its starting point and equipment idling, because the job window table provides precise planning boundaries, while the placement event stream captures the actual completion time of materials. The anchor point set formed after their alignment ensures that material dependencies and channel release conditions are no longer misaligned due to timescale drift when subsequent constraint segments are extracted. This provides traceable execution semantic support for the entire continuous resource input and output chain, improves the coordination and consistency between the progress platform and the material platform, and avoids the potential risks of delayed shared equipment migration and on-site congestion.

[0043] Step S1 generates a job window table and in-place event flow as time anchors for execution decisions, ensuring time alignment between the schedule platform and the material platform, thus providing precise boundaries for the continuous input and output of resources. However, existing constraint processing often fails to parse and transcribe channel release records and mutual exclusion rules into job surface access conditions, resulting in the inability to synchronously map material in-place dependencies and entry / exit sequences within the job window. This leads to fragmentation of resource scheduling execution and channel congestion. To overcome this deficiency, step S2 extracts executable constraint fragments based on the job window table and in-place event flow, transcribes channel release records and mutual exclusion rules into job surface access conditions, and generates a constraint fragment set. This provides a unified condition input for subsequent resource feasible domain construction, avoiding criterion bias caused by the mixing of multiple sets of expressions, and ensuring consistency in access for work teams and equipment input.

[0044] Step S2.1 parse the channel release records to generate an available time period sequence.

[0045] The access control and channel entry / exit logs are stored, including access time, channel identifier, and sequence information. A read command is invoked from the access control and channel database interface, targeting the job window identifier in step S1. Extract the raw logs of all associated channels. Specifically, for each channel release event, record its release time. (Unit: UTC timestamp, indicating the precise time the channel was opened) Channel Identifier (In string format, used to uniquely identify the physical passage, such as "East Passage C-01") and the order of entry and exit. (Integer value, representing the order of events within the channel, e.g., 1 for first-time access). The parsing process first filters logs under the current project, categorized by... Sort the data in ascending order, then apply a time merging algorithm (to merge overlapping or adjacent open intervals) to consecutive release events. That is, if the time interval between the end time and the next start time of adjacent events is less than a preset threshold (e.g., 5 minutes), they are merged into a single available time period. The output is a sequence of available channel time periods, each containing the start release time. End of release time Channel signage And cumulative order (based on The cumulative value (representing the total number of entries and exits within a time period) serves as the initial input for the access conditions of the transcription operation surface.

[0046] Step S2.2: Parse the mutual exclusion rules to extract the safety distance requirements.

[0047] Mutual exclusion rules originate from the Building Information Modeling (BIM) platform and define task conflicts and spacing specifications on the same work surface. Instructions are retrieved from the mutual exclusion rule knowledge base interface, targeting the task type in the work window table. and work surface markings Extract all relevant rule entries. Specifically, for each mutually exclusive rule, record its applicable task type. Conflict task types (Enumerated values ​​representing tasks that cannot be performed in parallel, such as "pouring" and "welding") Safety clearance requirements (Floating-point number, in meters, representing the minimum physical separation distance, such as 2.5 meters) and mutual exclusion duration (Unit: minutes, representing the duration of the conflict state). The resolution process traverses the rule set, checking for identical rules. Grouping according to rules, and then applying rule priority sorting (based on...) (arranged in descending order), eliminate redundant rules (if two rules are in descending order) and Same and (Smaller rules cover larger rules). The output is a set of mutually exclusive rules, each containing a job surface identifier. Conflict missions Safety distance requirements Mutual Exclusion Duration This serves as a supplementary input to the entry conditions for the transcription operation.

[0048] Step S2.3: Divide the constraint segments according to the time scale of the job window.

[0049] Based on the job window table generated in step S1, the available channel time slot sequence from step S2.1 and the mutual exclusion rule extraction set from step S2.2 are segmented according to the time scale of the job window. Specifically, for each window in the job window table, the start time is used as the starting time. With end time As a segmentation boundary, the available time-segment sequence of the query channel and A subset of time periods is selected, and mutual exclusion rules are queried to extract the matching sets. The rule subset. The segmentation process uses interval intersection calculation (to find the overlap between the window and the available time period), that is, for each matching time period, the intersection start time is calculated. End time of intersection ,like This forms an initial constraint fragment; subsequently, mutual exclusion rules are incorporated, and if conflicting task pairs exist in the intersection, adjustments are made. minus The output is a preliminary list of constraint fragments, each containing the start and end times. Channel signage ,order Conflict missions Safety distance requirements This serves as intermediate data that binds the material to its placement.

[0050] Step S2.4 Bind the material placement dependency to the constraint fragment.

[0051] For the preliminary constraint fragment list in step S2.3, material placement dependencies are injected from the placement event stream in step S1. Specifically, for the start and end times of each preliminary constraint fragment... and work surface markings Query the in-place event stream and If a matching event exists, the earliest one will be selected. As a dependent trigger time And record the associated material identifiers. The binding process checks dependency satisfaction: if... If the dependency is satisfied, the fragment state is marked as satisfied; otherwise, it is postponed. to And verify the adjusted No more than the number of job windows If no matching event is found, an empty dependency flag is added (indicating no material constraint). The output is a list of bound constraint fragments, with each item expanded to include start and end times. Channel signage ,order Conflict missions Safety distance requirements Dependence on trigger time Material identification This serves as preparation data for establishing a one-to-one mapping.

[0052] Step S2.5: Establish a one-to-one mapping to generate a set of constraint fragments.

[0053] The bound constraint fragment list from step S2.4 is mapped one-to-one with the job window table to form the final constraint fragment set. Specifically, for each window in the job window table, the bound constraint fragment list is traversed and matched. Segments that overlap with time periods, according to After sorting in ascending order, the segments are associated one by one: the first segment is mapped to the beginning of the window, and subsequent segments sequentially cover the remaining interval. If the coverage is insufficient, empty segments are added (the start and end times are the remaining interval, marked as unconstrained). The mapping process uses a hash table for storage, with the key being the window number in the job window table and the value being an array of associated segments, ensuring that each window has at most one main segment and auxiliary segment sequence. Finally, all mapping results are aggregated into a constrained segment set, with each item fully containing the start and end times. Bound work area access conditions (channel identification) ,order Conflict missions Safety distance requirements Material placement dependency (dependency trigger time) Material identification This set is persisted to memory or a database as the sole input for step S3 to construct the resource feasible domain.

[0054] Step S2 generates an available time period sequence by parsing channel release records, extracts safety distance requirements by parsing mutual exclusion rules, segments constraint fragments according to the work window time scale, binds material placement dependencies, and establishes a one-to-one mapping to generate a constraint fragment set, thus realizing the transcription and synchronization of channels and mutual exclusion conditions. In the construction scenario, this resolves the lag problem of material arrival status not being transcribed into available conditions for the work surface, because the constraint fragment set uniformly maps the entry and exit order, safety distance, and placement events to the work window boundary, ensuring that the access conditions are not mixed when making subsequent four-state closure decisions. This eliminates the lag in the cross-area migration of shared equipment and the mutual exclusion conflict of multiple tasks overlapping on the same work surface, improves the continuity of resource deployment and the utilization efficiency of channel capacity, and provides a solid constraint foundation for the predictability of on-site rhythms.

[0055] Step S2 extracts executable constraint fragments based on the work window table and the in-place event flow, transcribes the channel release records and mutual exclusion rules into work surface access conditions, and generates a constraint fragment set. This provides a unified condition expression for resource access, avoiding criterion bias caused by the mixing of multiple expressions. However, existing resource scheduling often ignores the synchronous continuity of the four-state execution status, resulting in the inability to simultaneously satisfy the reachable, enterable, workable, and exitable states within the work window. This leads to fragmentation in the selection of candidate time slots for work teams and equipment, as well as semantic disconnect between the initial allocation table and the release and clearing criteria. To fill this gap, step S3 constructs a resource feasible domain using the constraint fragment set, executes a four-state closed-loop decision at the access decision point, selects candidate time slots for work teams and equipment based on the synchronous continuity of reachable, enterable, workable, and exitable states, and outputs an initial allocation table. This ensures the continuity of resource input and the orderliness of exit, eliminating the risk of waiting and idle time on the execution side and channel delays.

[0056] Step S3.1 Establish the resource feasible region based on the constraint fragment set.

[0057] The constraint fragment set contains start and end times, job entry conditions, material placement dependencies, and window mapping references, serving as the foundation for constructing the resource feasible domain. All fragments are loaded from the in-memory storage of the constraint fragment set and grouped according to the window index in the job window table, forming a subset of fragments corresponding to each job window. Specifically, for each group, the start and end times in the constraint fragment set are traversed. and inject channel identifiers ,order Conflict missions Safety distance requirements Dependence on trigger time Material identification Construct a two-dimensional time-domain structure: the horizontal axis is the time axis (from the job window table). to The vertical axis represents the state dimension (channel, admission, mutual exclusion, dependency). The establishment process employs a grid-filling algorithm (used to expand discrete fragments into continuous feasible intervals), that is, for each fragment... to Fill in the available markers; if conflicting task pairs exist, mark the occupied bits in that interval. The output is a resource feasible region, with each item corresponding to a time-domain grid of a job window, containing the filled available intervals and occupied bits, serving as the input basis for the four-state judgment.

[0058] Step S3.2: Determine the four-state execution state and generate a state sequence.

[0059] On the temporal grid of the resource feasible domain, synchronous judgments are performed according to four execution states: reachable, enterable, operable, and regressable, generating a state sequence. First, the available time period sequence of the channel is extracted from the channel release record. and First, the intersection with the current grid interval of the resource feasible region; if the overlap length is greater than zero, the reachable state is marked as true. Second, the job face admission conditions (channel identifiers) are based on the constraint fragment set. With order ), check if the entry and exit order is satisfied within the grid interval, if the order A continuously increasing increment indicates an "entry-ready" status as true; furthermore, this is based on the task type in the job window table. Conflicts with mutual exclusion rules Safety distance requirements Verify that there are no overlapping conflicts within the grid interval. If the spacing between all task pairs exceeds [a certain value], [the following will occur]. Then the flag can be set to true; finally, based on the clearing criterion (predefined exit rules, such as the exit completion time must be earlier than the next window), The system uses exit rules (thresholds for access control exit logs) to predict the feasibility of exiting at the end of a grid interval. If the conditions are met, the exitable state is marked as true. The judgment process evaluates each grid time point point by point, forming a four-state Boolean sequence (reachable sequence, enterable sequence, workable sequence, exitable sequence), which serves as the input for the search of continuous time periods.

[0060] Step S3.3: Search for continuous time periods to form a closed segment set.

[0061] For each job window's time-domain grid within the feasible resource domain, a set of closed segments is formed by searching the state sequence generated in step S3.2 for consecutive time intervals where all four states are true. Specifically, the four-state Boolean sequence is traversed, and a continuous subarray summation algorithm (finding all true subsequences) is used, i.e., the interval is expanded sequentially from the grid's starting point until any point where a state is false is encountered, forming candidate closed segments. For each candidate closed segment, its starting time is calculated. (The moment of the first full-scale point) and the end moment (The moment of the last full truth point), and verify. The job window table and If the verification passes, the segment is added to the set of closed segments. Each closed segment contains... Related work surface identification It uses four-state references (state sequence fragments). The search process is executed sequentially in time, ensuring no overlap between segments, and outputs a closed set of segments as input for bridging tests.

[0062] The continuous subarray summation algorithm is a dynamic programming technique used to find the continuous subarray with the largest sum in a given one-dimensional array. It achieves an optimized solution with O(n) time complexity by scanning element by element and maintaining the maximum sum of the current subarray and the global maximum sum.

[0063] Step S3.4 Perform bridge connection verification and merge bridge connection closed segments.

[0064] For adjacent closed segments in the closed segment set formed in step S3.3, a bridging test is performed. If the start and end order is consistent and the entry and exit conditions are continuous, they are merged into bridged closed segments. Specifically, the sorted closed segment set is arranged according to... In ascending order, check adjacent segments one by one: calculate the gap length. ,like If the time is less than the preset yield threshold (e.g., 10 minutes, indicating a brief yield or temporary occupancy), then the consistency of the start and end order is checked (front end). Later Channel sign (Same) and the continuity of entry and exit conditions (the previous exitable state reference connects to the subsequent reachable state reference, without order) (Interruption); if both conditions are met, then the merge starts from the previous segment. The end is the second part. Update the four-state references to a concatenated sequence. Verification uses a chained verification algorithm (for recursively merging adjacent chains), repeated until no gaps remain to be merged. The output is a set of bridged closed segments, each containing the merged sequence. Channel signage ,order It is concatenated with four states and used as input for selecting the main closed segment.

[0065] The chain verification algorithm is a recursive chain merging mechanism specifically designed for processing the continuity verification and fusion of adjacent data segments. In resource allocation optimization scenarios, it is applied to bridge verification to eliminate temporary gaps. Specifically, the algorithm first linearly traverses the sorted set of closed segments, evaluating the gap length between adjacent segments pairwise. If the gap is less than a preset threshold, a chain condition check is triggered, including consistency of start and end order (verifying whether the channel identifier at the end of the previous segment is the same as the channel identifier at the start of the next segment) and continuity of entry and exit conditions (confirming that the order of the exitable state references of the previous segment and the reachable state references of the next segment is uninterrupted). If the conditions are met, the start time of the previous segment and the end time of the next segment are concatenated into a new chain segment through recursive calls, while updating the four-state reference sequence to a continuous concatenation form, until there are no remaining gaps to merge. The algorithm has a time complexity of O(n), where n is the number of closed segments, ensuring efficient processing of temporarily occupied adjacent segments, eliminating fragmentation of the execution chain, and maintaining overall continuity, thus providing a stable foundation for the selection of subsequent main closed segments.

[0066] Step S3.5 Select the main closed segment to generate the closed state result.

[0067] From the bridged closed segments set in step S3.4, select the main closed segments whose starting point fits the working window and whose ending point covers and clears the area, and generate the closed state result. Specifically, for each bridged closed segment, calculate the starting point fit degree. (Absolute difference, representing the deviation from the start time of the job window), endpoint coverage (If the value is positive, the clearing requirement will be overridden); priority will be given to selecting... Minimum and The segment is selected as the main closed segment; if no such segment is found, then the segment is chosen. The smallest one is designated as the primary closed segment, and its tail segment is marked as unclosed. The generation process iterates through all bridged closed segments, evaluating their closure state: if the primary closed segment covers the entire... If the main closure segment is not found, it is considered a full closure; if the main closure segment is not found, it is considered a partial closure; if there is no main closure segment, it is considered an unclosed closure. Output the closure state results, each item containing the main closure segment. The closure type (full closure, half closure, unclosed) and replacement request (specify the start and end of the tail segment if it is half closure) serve as the basis for the output initial allocation table.

[0068] Step S3.6 Write the initial allocation table according to the closed state.

[0069] Based on the closed-state results in step S3.5, candidate time slots for work groups and equipment are selected and written into the initial allocation table. Specifically, for the fully closed main closed segment, the... Related work surface identification Task Type Mapping four-state references to work group candidates (matched in the preset work group database) (Group) and device candidates (matching channel identifier) The device ID is used to create an allocation entry; for half-closed sections, only the allocation entry for the main closed section is retained, and a replacement request is generated for the tail section (including the unclosed section and material placement dependencies). For cases of unclosed segments, the entries for that window are removed, and the set of bridged closed segments is written back to the set of constraint segments (with an unclosed segment marker added). The writing process uses a relational table structure, with initial allocation table columns including window number, shift ID, equipment ID, and time period. The criteria for allowing access (based on reachable state) and clearing access (based on fallback state) are used to ensure consistent semantics. Finally, the initial allocation table is persisted to the database as input for the verification in step S4.

[0070] Step S3 achieves synchronous and coherent screening of access decisions by establishing a resource feasible region based on a set of constraint fragments, determining the four-state execution status to generate a state sequence, searching for continuous time periods to form a set of closed segments, performing bridge connection checks to merge bridge closed segments, selecting the main closed segment to generate a closed state result, and writing the closed state into the initial allocation table. This solves the problem of overlapping conflicts caused by the failure to convert the work surface capacity into computable mutual exclusion, because the four-state closed decision relies on the transcription of channel release records and mutual exclusion rules, ensuring that the candidate time periods in the initial allocation table cover the entire link from reachable to regressable. This reduces the risk that the actual execution of multiple tasks on the same work surface cannot be carried out simultaneously, improves the predictive consistency of team and equipment input and the continuous utilization of channel resources, and provides unweighted single access result support for subsequent implementation verification.

[0071] Step S3 has constructed the resource feasible domain using a set of constraint fragments. It uses a four-state closed-loop decision to filter candidate time slots for work teams and equipment and outputs an initial allocation table, ensuring semantic consistency between the release and clearing criteria, thus providing a single admission result for the continuous link of resource investment. However, existing initial allocation tables often suffer from discrepancies between on-site access control records, hoisting trajectories, and progress logs. This leads to the inability to verify the entry time, start point, and exit completion time of closed segments segment by segment, resulting in mismatches such as release failures or exit obstacles, causing a deviation between subsequent scheduling and on-site rhythm. To compensate for this deficiency, step S4 uses access control records, hoisting trajectories, and progress logs to verify the initial allocation table. Segments that do not meet the release and clearing criteria are marked as mismatched and written back to the constraint fragment set. This mismatch write-back mechanism drives rolling recalculation, ensuring that the constraint fragment set's restriction descriptions directly reference the on-site trajectory, avoiding repeated conflict triggers, and improving the traceability of resource allocation execution.

[0072] Step S4.1: Load the entry and exit trajectory data from the access control records.

[0073] Access control records store the entry and exit logs of personnel and equipment on site, including timestamps and identification information. Read commands are invoked from the access control record database interface, targeting the window sequence number and work surface identifier in the initial allocation table. Extract all associated entry and exit trajectories. Specifically, for each access control event, record its entry time. (Unit: UTC timestamp, indicating the actual time of entry into the work area), exit time (Unit: UTC timestamp, representing the actual time of departure from the work site), Team ID (string format, used to match team candidates in the initial allocation table), and Equipment ID (string format, used to match equipment candidates in the initial allocation table). The loading process uses a time range query, based on the time period in the initial allocation table. To filter logs, first establish a connection session and then pull data in batches, ensuring the trajectory sequence is... After sorting in ascending order, the data is temporarily stored in a memory buffer. The output of this step is an access control trajectory dataset, with each item containing... , The team ID and equipment ID serve as the input sources for verifying the entry time.

[0074] Step S4.2: Call the hoisting trajectory to load the material movement log.

[0075] The hoisting trajectory records the on-site movement path of materials from allocation to placement, including hoisting time and location information. It calls commands from the hoisting trajectory log interface, targeting the material identifier in the initial allocation table. and work surface markings Extract all relevant movement events. Specifically, for each hoisting event, record its hoisting start time. (Unit: UTC timestamp, indicating the start time of material hoisting) Hoisting end time (Unit: UTC timestamp, representing the completion time of material placement) and trajectory location (coordinate pairs, representing path points from the distribution point to the work surface). The loading process uses an event subscription model, filtering trajectories under the current project, and... After sorting, a path continuity check algorithm is applied (to verify continuous connections between trajectory points; uninterrupted connections are marked as valid), and invalid trajectories are removed. The output is a hoisting trajectory dataset, with each item containing... , Material identification The trajectory position serves as the input source for the starting time of the verification operation.

[0076] Step S4.3: Call the progress log to load the job execution record.

[0077] The progress log maintains the actual execution status of tasks on-site, including start and finish times. It reads commands from the progress log platform interface, based on the task type in the initial allocation table. Extract all matching execution records based on the window number. Specifically, for each progress event, record its job start time. (Unit: UTC timestamp, indicating the actual start time of the task), Exit completion time (UTC timestamp in uniform time scale, representing the time when the task ends and is cleared) and mutual exclusion conflict flag (Boolean value, indicating whether a safety distance requirement has occurred). (Violation). The loading process traverses the log file, categorized by job surface identifier. Group the data, then perform a time alignment algorithm on the event sequences (to calibrate log timestamps with a uniform timescale) to ensure the deviation is less than 1 second. The output is a progress log dataset, with each item containing... , Task Type Mutual exclusion conflict markers serve as the input source for verifying the completion time of the exit.

[0078] Step S4.4: Verify the entry time and release criteria segment by segment.

[0079] For each main closed segment in the initial allocation table, the entry time and release criteria are checked segment by segment from the access control trajectory dataset in step S4.1 and the hoisting trajectory dataset in step S4.2. Specifically, for the main closed segment... Query the access control trajectory to match the work group ID and the device ID. If the earliest The release criterion is then met; simultaneously, the material identifier is matched in the hoisting trajectory. of ,like The material release is then satisfied. The verification process uses a parallel comparison algorithm (used to simultaneously verify personnel, equipment, and material trajectories). If any... or If the deviation exceeds a preset tolerance threshold (e.g., 5 minutes), it is marked as a release failure. The output is a verification result set, with each main closure segment extension including the entry deviation. (Time difference, representing the deviation between the actual and the planned) and release status (satisfied or failed) serve as the basis for subsequent reachability mismatch annotation.

[0080] Step S4.5: Verify the start point and exit completion time of each segment of the operation.

[0081] Continue by checking the start point and exit completion time of each main closed segment in the initial allocation table, segment by segment, using the progress log dataset from step S4.3 and the access control trajectory dataset from step S4.1. Specifically, for each main closed segment... and Query the progress log to match the task type of ,like and If the deviation is within the tolerance range and the mutual exclusion conflict is marked as false, then the operation start point satisfies the condition; query the access control trajectory. If all The exit condition is then met. The verification process integrates a conflict detection algorithm (used for cross-validating the safety distance requirements of mutual exclusion rules). (and the markers in the progress log), if they exist or If the conflict flag is true, it will be marked as restricted entry, obstructed exit, or mutually exclusive conflict, respectively. The output is an extended check result set, with each item containing operational deviations. Exit deviation The corresponding state (satisfied or mismatched) serves as the input for the mismatch type label.

[0082] Step S4.6: Write the mismatch annotation back to the constraint fragment set.

[0083] Based on the extended verification result set from steps S4.4 and S4.5, mismatch markers are added to the main closed segments that do not meet the release criteria and clearing criteria, and the results are written back to the constraint segment set. Specifically, release failure is marked as reachable mismatch, entry restriction is marked as enterable mismatch, operation mutual exclusion conflict is marked as workable mismatch, and exit obstruction is marked as exitable mismatch; the start and end times of the main closed segment are used as the basis for the mismatch. Using the mismatch type as the key, a constraint description (a string description, such as "reachable mismatch: entry deviation exceeds threshold") is added to the corresponding fragment in the constraint fragment set. The write-back process uses a key-value update algorithm (for exact matching and injecting new fields) to ensure the start and end times of the constraint fragment set are accurate. After aligning with the main closure segment, the mismatch field is expanded. Subsequent step S5, rolling recalculation, will reference these constraint descriptions to avoid repeated triggering. Finally, the updated constraint fragment set is persisted to the database as input to trigger local rearrangement.

[0084] Step S4 achieves on-site verification of the initial allocation table by calling access control records to load entry and exit trajectory data, calling hoisting trajectory records to load material movement logs, calling progress logs to load operation execution records, verifying entry times and release criteria segment by segment, verifying operation start times and exit completion times segment by segment, and writing mismatch annotations back to the constraint fragment set. To address the misalignment issues of restricted entry and obstructed exit, parallel comparison of access control and hoisting trajectories, along with conflict detection in progress logs, ensures that mismatch annotations are injected with restriction descriptions using the start and end times of closed segments as keys. This guides subsequent local adjustments in rolling recalculation, avoids continuous deviations in clearing criteria, improves the orderliness of resource evacuation and the timeliness of channel clearing, and provides auditable trajectory support for semantic consistency in queue states.

[0085] Step S4 has already used access control records, hoisting trajectory, and progress logs to verify the initial allocation table. By writing back the constraint fragment set through mismatch annotations, it ensures that the restriction descriptions directly reference the on-site trajectory, thus providing a basis for deviation analysis for rolling recalculation and avoiding repeated conflicts. However, existing resource scheduling often suffers from local misalignment of unexecuted fragments, leading to a stable main closure segment but subsequent deployment links breaking down, thereby amplifying the risks of on-site waiting and channel congestion. To mitigate this challenge, step S5 triggers rolling recalculation based on mismatch annotations. While retaining the main closure segment, it performs local rearrangement and replacement of unexecuted fragments, outputting a stable allocation table and solidifying the reference relationships between release and clear criteria, thereby maintaining the continuity of the execution rhythm and improving the predictability of resource exit.

[0086] Step S5.1 Read the mismatch annotations in the constraint fragment set.

[0087] Mismatch annotations are read from the constraint fragment set updated in step S4 to form a mismatch fragment list. Specifically, each fragment in the constraint fragment set is traversed, and items containing the mismatch field are filtered, including reachable mismatch, enterable mismatch, operable mismatch, and regressible mismatch types. The start and end times of each item are recorded. Mismatch type and limitation description (string description, such as "reachable mismatch: entry deviation exceeds threshold"). The reading process uses index scan mode, sorts the list of mismatched segments by window mapping reference, ensures alignment with the window sequence number in the initial allocation table, loads the memory cache first, and then verifies the annotation integrity (checks the key-value alignment of the main closure segment). The output is a list of mismatched segments, which serves as the input source to trigger a rolling recalculation.

[0088] Step S5.2 Identify unexecuted segments and isolate the main closed segment.

[0089] Based on the list of mismatched segments and the initial allocation table from step S5.1, unexecuted segments are identified and main closure segments are isolated. Specifically, for each entry in the initial allocation table, the start and end times of the mismatched segments are cross-checked. With the main closed segment If there is overlap, it is marked as an unexecuted segment (including tail replacement requests or missing closure items); the main closure segment is isolated and retained if there is no mismatch, and its four-state reference remains unchanged. The identification process uses an interval overlap detection algorithm (used to calculate the intersection area of ​​the segment and the main closure segment; if it is greater than zero, it is confirmed as unexecuted), removing entries that are fully closed, forming a subset of unexecuted segments. Each item includes a window number, mismatch type, and material placement dependency. Material identification The output consists of a subset of unexecuted segments and a set of isolated main closure segments, which serve as the input basis for local rearrangements.

[0090] Step S5.3 generates a sequence of replacement candidate fragments.

[0091] For the subset of unexecuted segments from step S5.2, a sequence of replacement candidate segments is generated from the constraint segment set and the in-place event stream. Specifically, for each unexecuted segment, the job surface identifier matching the constraint segment set is queried. With task type Backup segments, arranged by start and end times Filter out items that fall after the main closing segment, and simultaneously inject the in-place event stream. As the latest dependency trigger time The generation process employs a sequence expansion algorithm (used to expand candidate chains from the reserve pool that are in the same order as the main closure segment), prioritizing candidate segments (based on channel identifiers). order (Incremental approach); if multiple candidates overlap, select the one with the highest coverage (largest intersection). The output is a sequence of replacement candidate segments, each containing the start and end times. (Replace start and end times), channel identifier ,order Conflict missions Safety distance requirements With updating dependencies , which serves as the input for rearrangement verification.

[0092] Step S5.4 Perform local rearrangement and four-state synchronization verification.

[0093] Local rearrangement is performed on the candidate fragment sequence for replacement in step S5.3, and the four-state synchronization of reachability, inbound, operable, and revertible is verified. Specifically, the candidate sequence is inserted into the corresponding position of the unexecuted fragment subset to form a temporary rearrangement chain; for each rearrangement node, the four-state judgment logic of step S3 is reused: check the reachability state based on the channel release record, check the inbound state based on the work surface admission condition, check the operable state based on the mutual exclusion rule, and check the revertible state based on the clearing criterion. If all four states of all nodes in the chain are true and the order is consistent (order...), then... If the sequence is continuous, the verification passes. The rearrangement process uses a priority queue algorithm (to sort candidates according to their consistency with the main closed segment order, with the optimal replacement at the head of the queue). If multiple candidates satisfy the criteria, the replacement is selected based on the starting point of the in-place event flow. Calculate the fit of the segment with the smallest deviation. (Absolute difference, representing the offset between the replacement start and the event origin). The output is a chain of reordered fragments that has passed verification, with each item expanded into a four-state Boolean sequence as the basis for confirmation of the replacement.

[0094] Step S5.5 Replace the unexecuted segments to generate a stable allocation table.

[0095] Based on the rearranged fragment chain verified in step S5.4, the subset of unexecuted fragments from step S5.2 is replaced, and a stable allocation table is generated. Specifically, for each unexecuted fragment, its start and end times are covered with the optimal term from the rearranged fragment chain. The process involves retaining entries from the isolated main closed segment; concatenating the replaced chain with the main closed segment to form a complete time-segment sequence, which is then mapped to the work group ID and equipment ID. The generation process iterates through the concatenated sequence, constructs a relational table structure, and stably assigns table columns including window number, work group ID, equipment ID, and replacement time segment. The system first sets up criteria for allowing access (based on reachable state) and then clears them (based on fallback state) to ensure semantic consistency with the initial allocation table. Finally, the stable allocation table is persisted to the database as the final output execution plan.

[0096] Step S5.6 solidifies the reference relationships to form a traceable archive.

[0097] For the stable allocation table in step S5.5, the reference relationship between the release criteria and the clearing criteria is solidified. Specifically, for each table entry, the mismatch type and restriction description of the four-state reference are extracted, and reference key-value pairs are generated (the key is the constraint fragment number, and the value is the criterion description, such as "Release Criterion: Channel Order"). (); Match key-value pairs with replacement time periods The data is linked to form a traceability chain. The solidification process uses a relational mapping algorithm (to bidirectionally link criterion references with fragment numbers), and archives it to the audit log. Each entry contains a window sequence number, a reference key-value pair, and a constraint fragment number, facilitating subsequent review. The output is a solidified archive set, embedded in a stable allocation table, serving as the final state for traceable execution.

[0098] Step S5 achieves local optimization through rolling recalculation by reading mismatch markers from the constraint fragment set, identifying unexecuted fragments and isolating the main closed segment, generating a sequence of replacement candidate fragments, performing local rearrangement and four-state synchronization verification, replacing unexecuted fragments to generate a stable allocation table, and solidifying reference relationships to form a traceable archive. This process directly alleviates the problems of delayed shared equipment migration and delayed material placement occupying channel capacity, because rearrangement prioritizes alignment with the starting point of the placement event flow, reducing waiting time upon arrival. At the same time, solidifying references ensures that the semantics of the release criteria and clearing criteria do not drift, thereby strengthening the continuous link of resource deployment and the predictability of progress execution, and providing robust audit support for the semantic consistency of the on-site queue status.

[0099] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters in the formulas are set by those skilled in the art according to the actual situation.

[0100] It should be noted that the system of the present invention can be deployed on the device itself to realize embedded applications, or it can run on a PC or other terminal with a user interface, thereby meeting a variety of hardware environments and usage requirements.

[0101] The foregoing has only described certain exemplary embodiments of the present invention by way of illustration. Undoubtedly, those skilled in the art can modify the described embodiments in various ways without departing from the spirit and scope of the present invention. Therefore, the foregoing drawings and descriptions are illustrative in nature and should not be construed as limiting the scope of protection of the claims of the present invention.

[0102] It should be noted that, in this document, the use of relational terms such as "first" and "second" is merely to distinguish one entity or operation from another, and does not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes the element.

[0103] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A method for construction resource constrained allocation optimization based on big data, characterized in that, Comprise: S1: read the job window and subscribe to the material in place event in the unified time scale, generate job window table and in place event stream as the time anchor point of execution judgment; S2: according to the job window table and the in place event stream, extract the executable constraint segment, convert the channel release record and the mutual exclusion rule into the job surface access condition, and obtain the constraint segment set; S3: with the constraint segment set, construct the resource feasible domain, execute the four state closed decision at the access decision, filter the team and equipment candidate period according to the synchronous consistency of reachable, accessible, executable and retreatable, and output the initial allocation table; From the constraint segment set, group the resource feasible domain according to the window number of the job window table, form the time domain grid of each job window, judge the reachable state based on the channel release record, judge the accessible state based on the job surface access condition, judge the executable state based on the job window table and the mutual exclusion rule, and judge the retreatable state based on the emptying criterion and the retreat rule, generate the four state Boolean sequence, search the continuous period from the four state Boolean sequence which satisfies the four state true, form the closed segment set, perform the bridge connection test on the adjacent closed segments in the closed segment set, and merge the bridge connection closed segment set which meets the consistent start and end sequence and the continuous in and out condition; select the bridge connection closed segment which starts at the starting time of the job window table and ends at the emptying requirement as the main closed segment from the bridge connection closed segment set, generate the closed state result, including full closed, half closed and lost closed types, map the main closed segment starting time, main closed segment ending time, job surface identifier, task type and four state reference to team candidate and equipment candidate to form allocation entry for full closed main closed segment, retain the allocation entry of the main closed segment for half closed and generate replacement request for the tail segment, and for lost closed, remove the window entry and write the bridge connection closed segment set to the constraint segment set, and write to the initial allocation table; S4: use the access record, lifting track and progress log to perform landing check on the initial allocation table, mark and write back the constraint segment set for the segment which does not meet the release criterion and emptying criterion; S5: according to the mismatch marking, trigger rolling recalculation, rearrange and replace the unexecuted segment under the premise of retaining the main closed segment, output the stable allocation table and solidify the reference relationship of the release criterion and the emptying criterion.

2. The building construction resource constraint allocation optimization method based on big data according to claim 1, wherein: step S1 reads the job window data from the progress platform to generate the job window table, subscribes to the in place event from the material platform to generate the in place event stream, and aligns the job window table and the in place event stream with the unified time scale to form the time anchor point of execution judgment.

3. The building construction resource constraint allocation optimization method based on big data according to claim 2, wherein: step S2 analyzes the channel available period sequence and the entry and exit order from the channel release record, analyzes the conflict task pair and the safety distance requirement from the mutual exclusion rule, and cuts the channel available period sequence and the mutual exclusion rule according to the starting time and the ending time of the job window table to extract the preliminary constraint segment list.

4. The building construction resource constraint allocation optimization method based on big data according to claim 3, wherein: ​ ​ Step S2 binds material put-in dependencies from put-in event stream to preliminary constraint segment list to generate bound constraint segment list, each bound constraint segment extends to contain dependency trigger time and material identity, and establishes one-to-one mapping between bound constraint segment list and job window table to generate constraint segment set.

5. The big data based construction resource constraint allocation optimization method according to claim 4, characterized in that: Step S4 loads access track data from access record to form access track data set, loads material movement log from hoisting track to form hoisting track data set, loads job execution record from progress log to form progress log data set, checks entry time and release criterion from access track data set and hoisting track data set for each main closure segment in initial allocation table, calculates entry deviation and release state, checks job start time and exit completion time from progress log data set and access track data set, calculates job deviation and exit deviation, forms extended check result set, each main closure segment contains deviation value and check state.

6. The big data based construction resource constraint allocation optimization method according to claim 5, characterized in that: Step S4 labels main closure segment that does not meet release criterion as reachable mismatch, labels main closure segment that does not meet access condition as accessible mismatch, labels main closure segment that is job conflict as jobable mismatch, labels main closure segment that does not meet empty criterion as exitable mismatch, adds restriction description to corresponding segment in constraint segment set with main closure segment start and end time and mismatch type as key, updates constraint segment set extended mismatch field and persists to database.

7. The big data based construction resource constraint allocation optimization method according to claim 6, characterized in that: Step S5 reads mismatch label from constraint segment set to form mismatch segment list, identifies unexecuted segment subset and isolates main closure segment set according to mismatch segment list and initial allocation table, generates replacement candidate segment sequence from constraint segment set and put-in event stream, performs local rearrangement on replacement candidate segment sequence to form temporary rearrangement chain, verifies that all nodes in temporary rearrangement chain have true reachable state, accessible state, jobable state and exitable state and continuous order, and outputs rearrangement segment chain that passes verification.

8. The big data based construction resource constraint allocation optimization method according to claim 7, characterized in that: Step S5 replaces unexecuted segment subset with optimal item of rearrangement segment chain and concatenates with isolated main closure segment set to generate stable allocation table, extracts four-state reference and restriction description from stable allocation table entry to generate reference key-value pair, associates reference key-value pair with replacement period to form trace chain and archives to audit log, each audit log contains window sequence number, reference key-value pair and constraint segment number, as traceable execution basis.

Images