A security conflict detection and elimination method for weighted bipartite graph matching

Abstract

The application provides a security conflict detection and elimination method for weighted bipartite graph matching. Firstly, the method uses the order-revealing encryption to encrypt the weight data of the bipartite graph, so that the edge server can compare the data size without obtaining the data plaintext. Secondly, the method uses the secret sharing technology to split the weight value into two share weight values, so that any edge server cannot obtain the complete weight value in the conflict elimination process. Finally, the method designs a secure conflict detection and elimination algorithm based on the idea of the greedy algorithm, and iteratively compares the conflicts through the multi-edge server cooperation mode until the optimal allocation result is found. Through the scheme, the complexity of the bipartite graph optimal matching is reduced under the condition of ensuring the data security, and the matching efficiency is greatly improved.

Description

A Secure Collision Detection and Removal Method for Weighted Bipartite Graph Matching Technical Field

[0001] This invention relates to the field of optimal matching technology for weighted bipartite graphs, and in particular to a method for safe conflict detection and elimination in weighted bipartite graph matching. Background Technology

[0002] Optimal matching of weighted bipartite graphs is a prominent problem in graph theory. Its core objective is to find a matching in a given bipartite graph such that the sum of the weights of the matching edges is maximized or minimized. This problem not only has theoretical value but also plays a crucial role in various practical applications such as resource allocation, project scheduling, and task matching. Taking project scheduling as an example, when assigning a series of project subtasks to different workers, since the cost for each worker to complete different subtasks varies, the weighted bipartite graph matching algorithm can find an optimal allocation scheme to minimize the total cost of completing the project.

[0003] With the ever-expanding scale of bipartite graph data, traditional methods of performing bipartite graph matching locally on the user's end are no longer sufficient to meet users' needs for rapid matching results. Therefore, there is an urgent need for high-performance computing platforms to quickly achieve optimal bipartite graph matching. Edge computing, as an emerging computing paradigm, moves computing tasks from the cloud to the network edge, bringing data processing and computation closer to users or devices, effectively improving service response speed and providing powerful computational support for optimal matching of weighted bipartite graphs.

[0004] However, as the amount of stored data continues to increase, edge servers become more vulnerable to attacks, leading to the risk of privacy breaches. This is because the weight data in bipartite graphs often contains special meanings, such as the degree of intimacy between nodes and sensitive information like transaction amounts. To ensure the security of bipartite graph data, current research suggests that data owners should encrypt the data before outsourcing it and design an optimal matching scheme for the bipartite graph based on the encrypted data. This approach can both ensure the security of the weight data and successfully complete the optimal matching of the bipartite graph, achieving the dual goals of data protection and efficient computation.

[0005] The paper "User experience-driven secure task assignment in spatialcrowdsourcing" models the waiting time between drivers and passengers as a bipartite graph. It designs a homomorphic encryption-based Hungarian algorithm to achieve optimal matching of the bipartite graph based on ciphertext, thereby minimizing the waiting time for all passengers. However, this scheme requires complex homomorphic encryption computation and demands that the number of drivers and passengers be equal. Therefore, designing a lightweight weighted bipartite graph optimal matching method while ensuring the security of weighted data remains a challenging problem. Summary of the Invention

[0006] To address the aforementioned shortcomings in existing technologies, this invention provides a secure conflict detection and elimination method for weighted bipartite graph matching. This method transforms the optimal matching problem of a weighted bipartite graph into a winning node selection problem, and eliminates conflicts by designing a winning node conflict detection and elimination algorithm to obtain the optimal matching result. To ensure security, the secure conflict detection and elimination algorithm is run on three non-colluding edge servers. First, the method uses unordered encryption to encrypt the bipartite graph weight data, ensuring that the edge servers can compare data sizes without obtaining the plaintext data. Second, the method employs secret sharing technology to split the weight value into two shares, ensuring that no edge server can obtain the complete weight value during conflict elimination. Finally, the method designs a secure conflict detection and elimination algorithm based on the idea of ​​a greedy algorithm, iteratively comparing conflicts through multi-edge server collaboration until the optimal allocation result is found. The entire method is designed based on lightweight cryptographic principles, requiring no complex homomorphic encryption operations, and has high overall operating efficiency.

[0007] This method involves four types of entities: Trusted Third Party (TTP), Data Owner (DO), Data User (DU), and Edge Server (ES). It is assumed that the Trusted Third Party, Data Owner, and Data User are trusted entities, while the Edge Server is a semi-honest entity; that is, the ES will honestly execute the protocol, but may intentionally or unintentionally speculate on weight values ​​during the execution process. The functions of each entity involved in the method are as follows:

[0008] Trusted Third Party (TTP): The trusted third party is responsible for generating the keys required for secure bipartite graph matching and distributing the keys to the corresponding entities.

[0009] Data Owner (DO): The data owner owns the bipartite graph data, is responsible for encrypting the weight data in the graph, and outsources it to edge servers to provide services.

[0010] Data user (DU): The data user sends a matching request containing the nodes to the edge server, hoping that the edge server will return the best match among these nodes.

[0011] Edge Server (ES): The edge server is responsible for storing encrypted data uploaded by data owners and processing matching requests from data users. After completing the optimal match, it returns the corresponding matching result to the data user.

[0012] Given a security parameter λ, a large prime number p much larger than the weight value, an unordered encryption scheme ORE = (Init, Enc, Cmp), an asymmetric encryption scheme PKE = (Gen, Enc, Dec), and a bipartite graph G = (U, V, E, W), where U = {u1, u2, ..., u...} m} and V={v1,v2,…,v n} contains all vertices of a bipartite graph G, and the vertex sets U and V are disjoint, E = {e i,j} i∈[1,m],j∈[1,n] Let W be the set of all edges in a bipartite graph G, where W = {w i,j} i∈[1,m],j∈[1,n] Let G be the set of weights of all edges in a bipartite graph G.

[0013] This invention provides a secure conflict detection and elimination method for weighted bipartite graph matching, comprising the following steps:

[0014] Step S1: Execute the key generation algorithm (sk ORE ,{(pk l ,sk l )} l＝{1,2} ←KeyGen(λ), the key generation algorithm is executed by a trusted third party, TTP. First, TTP inputs the security parameter λ, and then executes the algorithm ORE.Init(λ) to generate the decryption encryption key sk. ORE Next, TTP executes the PKE.G(λ) algorithm to generate two public-private key pairs (pk1, sk1) and (pk2, sk2); finally, TTP sets (sk1, sk2) as a public-private key pair. ORE Send sk1 and sk2 to the data owner DO, and send sk1 and sk2 to edge server ES1 and edge server ES2 respectively.

[0015] Step S2: Execute the bipartite graph encryption algorithm (EG) ← GraphEnc(G, sk OREThe bipartite graph encryption algorithm (pk1, pk2) is executed by the data owner DO. Given a bipartite graph G = (U, V, E, W), DO executes the GraphEnc algorithm to generate an encrypted bipartite graph EG. The row indices of EG store the nodes in the vertex set U, and the column indices of EG store the nodes in the vertex set V. Specifically, for each weight value w in G... i,j First, run ORE.Enc(sk) ORE ,w i,j The algorithm generates ciphertext values ​​[[w] i,j Then, using the idea of ​​additive secret sharing, w i,j Divided into two share values and in Next, asymmetric encryption PKE will be used to... Encryption in Finally Stored in EG[i][j], the detailed process of the bipartite graph encryption algorithm is shown in the table below. After the entire algorithm is completed, DO sends EG to the edge server ES3 for storage.

[0016]

[0017] Step S3: Execute the matching request generation algorithm (Q U Q V ←ReqGen(G), the matching request generation algorithm is run by the data user DU. The matching request generated by this algorithm indicates that DU expects the edge server to find an optimal match from some nodes in U to some nodes in V. Without loss of generality, the method of this invention assumes that the data user DU expects to find node Q. U =(u1,u2,…,u t ) to Q V =(v1,v2,…,v s The optimal match of ) is obtained. After the algorithm is completed, DU will (Q) U Q V Send it to the edge server ES3.

[0018] Step S4: Execute the bipartite graph secure matching algorithm (M) U,V )←SecGraMatch(EG,Q U Q V The algorithm is executed jointly by three edge servers when a matching request (Q) is received. U Q V After that, the edge server executes the bipartite graph secure matching algorithm based on EG to obtain the optimal matching result M. U,V .

[0019] Furthermore, the definition of optimal matching for a bipartite graph is as follows:

[0020] Let π(u i ,v j ) represents the matching state, if π(u i ,v j ) = 1, indicating that node u i With node v j Matching; if π(u) i ,v j If ) = 0, it means that node u will not be included. i Same node v j Matching, given Q U and Q V The objective of optimal matching of a bipartite graph is expressed as:

[0021]

[0022] To improve efficiency, this invention will solve M U,V Transformed into a winning node selection problem, specifically: the edge server ES3 first finds Q from the cryptographic bipartite graph EG. U and Q V The weight, share, and ciphertext values ​​of the corresponding nodes are used to form a matrix. and Then, ES3 will and The data is sent to edge servers ES1 and ES2 respectively. Then, edge servers ES1 and ES2... Generate a weighted ranking matrix Perform conflict detection on the winning node, for each conflict v c ∈Q V That is, v c It is Q U Maximum matching of multiple nodes in a set; edge servers ES1 and ES2 construct conflict resolution sets. And work with ES3 to eliminate conflicts, thereby from Q U Find the most suitable v c The node.

[0023] Furthermore, the detailed steps of the bipartite graph secure matching algorithm are as follows:

[0024] Step S41: For Q U =(u1,u2,…,u t ) and Q V =(v1,v2,…,v sThe edge server ES3 finds Q from the cryptographic bipartite graph EG. U and Q V The corresponding encrypted weight value and share value of the node, specifically for Q U u in i and Q V v in j The edge server ES3 obtains from EG[i][j]. and set When request (Q) U Q V After all nodes in the edge server ES3 have been processed, the edge server ES3 will... and Send them to edge servers ES1 and ES2 respectively;

[0025] Step S42: Collision detection, when ES1 receives ES2 received Then, ES1 and ES2 first use the asymmetric encryption private keys sk1 and sk2 respectively to... and Decrypt to obtain the plaintext share value, which is the new share. equal New equal Then, edge servers ES1 and ES2 execute the RankMatrixCons algorithm to generate a ranking matrix. And according to The ranking order in the share matrix respectively and Perform the corresponding sorting; then, the edge servers ES1 and ES2 detect... For each row in the table, the first-ranked node is used to construct a relationship with v. j Conflict set Right now

[0026]

[0027] Step S43: Conflict elimination. This step eliminates conflicts for each set of conflicts until all sets of conflicts contain only one element. Without loss of generality, assume v... j It is Q U Let the winner node of the ρ nodes be... Edge servers construct conflict resolution sets for ES1 and ES2. Each of the conflict resolution scenarios will u k Same as v j Match, will Except for u k Other nodes match with their second-ranked nodes;

[0028] for Any two cases S x and S y ES1 and ES2 are respectively based on and Calculate the difference between these two cases. and The calculation process is as follows:

[0029]

[0030] in, Indicate u x The node ranked first The share weight value inside, Indicate u z The node ranked second in The share weight value inside, Indicate u y The node ranked first The share weight value inside, Indicate u y The node ranked second in The share weight value inside, Indicate u x The node ranked first The share weight value inside, Indicate u z The node ranked second in The share weight value inside, Indicate u y The node ranked first The share weight value inside, Indicate u y The node ranked second in The share weight value inside;

[0031] When two cases S are obtained x and S y After the differences, the edge servers ES1 and ES2 will respectively and Send to the edge server ES3, ES3 computes If d x,y If ∈[0, p / 2], then it indicates that S x The sum of the weights inside is greater than S.y The weights inside, ES3 send d x,y =1 for ES1 and ES2; if d x,y If ∈[p / 2,p], then it indicates that S x The sum of the weights inside is less than S. y The weights inside, ES3 send d x,y =0 for ES1 and ES2, when the conflict elimination set After comparing all the cases, ES1 and ES2 will be able to know... The case with the largest weight is S. o That is, satisfying the following formula, and setting M. U,V ←M U,V ∪{(u o ,v j )};

[0032]

[0033] Meanwhile, edge servers ES1 and ES2 update the matrix according to the above formula. That is, for All nodes inside, ES1 and ES2 will exclude u o All except lines and v j The relevant weight value is set to -1, that is, for z∈[1,m] and z≠o, the weight is set to -1. After updating the matrix Then, the edge server continues to perform conflict detection and elimination according to steps S42 and S43 until the number of elements in all conflict sets is 1.

[0034] The security of the proposed method will be explained below. First, the decryption encryption ensures the security of the weight data; second, the secret sharing technology and the multi-edge server non-collusion assumption ensure that no single server can obtain the complete weight value; finally, due to asymmetric encryption, the edge server ES3 cannot locate the specific node based on the obtained weight difference.

[0035] Compared with the prior art, the present invention has the following beneficial technical effects:

[0036] (1) The present invention proposes a method for safe conflict detection and elimination for weighted bipartite graph matching, which transforms the optimal matching of bipartite graphs into the problem of winning node conflict detection and elimination, and can quickly complete the optimal matching of bipartite graphs without revealing the weight values;

[0037] (2) This invention proposes a secure method for detecting conflict in winning nodes. This method uses decryption encryption to ensure the security of weight data, while ensuring that the edge server can construct a ranking matrix to complete the conflict detection.

[0038] (3) This invention proposes a secure method for eliminating winning node conflicts. This method is based on a ranking matrix and secret sharing, and uses multi-edge server collaboration to find the optimal situation in the conflict set.

[0039] (4) This invention proposes a secure weighted bipartite graph matching method. This method does not require complex homomorphic encryption operations and can greatly improve matching efficiency while ensuring the security of weight data. Attached Figure Description

[0040] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0041] Figure 1 is a system model diagram of a security conflict detection and elimination method for weighted bipartite graph matching provided in an embodiment of the present invention;

[0042] Figure 2 is a flowchart illustrating the secure bipartite graph matching steps in a secure conflict detection and elimination method for weighted bipartite graph matching provided by an embodiment of the present invention.

[0043] Figure 3 is an example diagram of an encrypted bipartite graph in a security conflict detection and elimination method for weighted bipartite graph matching provided by an embodiment of the present invention.

[0044] Figure 4 is an example diagram of secure bipartite graph matching in a secure conflict detection and elimination method for weighted bipartite graph matching provided by an embodiment of the present invention. Detailed Implementation

[0045] 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.

[0046] As shown in Figure 1, this invention provides a secure conflict detection and elimination method for weighted bipartite graph matching. The system model of this method includes four types of entities: Trusted Third Party (TTP), Data Owner (DO), Data User (DU), and Edge Server (ES). It is assumed that the Trusted Third Party, Data Owner, and Data User are trusted entities, while the Edge Server is a semi-honest entity; that is, the ES will honestly execute the protocol, but will intentionally or unintentionally speculate on weight values ​​during the protocol execution process.

[0047] Trusted third party: The trusted third party is responsible for generating the keys and parameters required for secure matching of bipartite graphs and distributing the keys to the corresponding entities.

[0048] Data owner: The data owner owns the complete bipartite graph data, is responsible for encrypting the weight data in the graph, and outsources it to edge servers to provide services.

[0049] Data users: Data users send matching requests containing the nodes to the edge server, hoping that the edge server will return the best match among these nodes.

[0050] Edge servers: Edge servers are responsible for storing encrypted bipartite graph data uploaded by data owners and processing matching requests from data users. Once a match is completed, the corresponding matching result is returned to the data user. Multiple edge servers come from different service providers, and to avoid damage to reputation or other harms, a non-collusion security assumption exists between the multiple edge servers.

[0051] The workflow for each entity in the bipartite graph safe optimal matching method is as follows:

[0052] Trusted Third-Party TTP: Given a security parameter λ, this entity runs the KeyGen(λ) algorithm to generate the decryption encryption key sk. ORE And the asymmetric encryption public / private key pairs (pk1, sk1) and (pk2, sk2), after executing the algorithm, the trusted third party will... ORE ,pk1,pk2) are sent to the data owner DO, and sk1 and sk2 are sent to edge server ES1 and edge server ES2 respectively.

[0053] Data owner DO: Given a bipartite graph G = (U, V, E, W), this entity runs the GraphEnc algorithm to generate an encrypted bipartite graph EG. After executing the algorithm, the data owner DO sends EG to the edge server ES3 for storage.

[0054] Data user DU: When DU expects to find an optimal match from some nodes in U to some nodes in V, data user DU executes the ReqGen algorithm to generate a matching request (Q). U Q V ), and (Q U Q V Send it to the edge server ES3.

[0055] Edge Server: Given a cryptographic bipartite graph EG and a matching request (Q) U Q V Edge servers ES1, ES2, and ES3 jointly execute the bipartite graph secure matching algorithm SecGraMatch(EG,Q). U Q V To obtain the optimal matching result M U,V SecGraMatch(EG,Q) U Q V The steps of the algorithm are shown in Figure 2.

[0056] This embodiment uses a bipartite graph G = (U, V, E, W) with vertex sets |U| = 5 and |V| = 5 as an example to illustrate the steps of the method in detail. In the example, the weight values ​​in W range from [1, 10], and the large prime number p = 193.

[0057] Step 1: A trusted third party runs the KeyGen algorithm to generate a key and sends the corresponding key to the corresponding entity in the system. This includes:

[0058] Step 11: Given a security parameter λ, a trusted third party runs the algorithm ORE.Init(λ) to generate the decryption encryption key sk. ORE ;

[0059] Step 12: Given the security parameter λ, a trusted third party runs the algorithm PKE.G(λ) to generate two pairs of public / private keys (pk1, sk1) and (pk2, sk2) for the asymmetric encryption algorithm;

[0060] Step 13: A trusted third party will (sk ORE ,pk1,pk2) are sent to the data owner DO, and sk1 and sk2 are sent to edge server ES1 and edge server ES2 respectively.

[0061] Step 2: The data owner runs the GraphEnc algorithm to encrypt the bipartite graph G into EG. After executing the algorithm, the data owner sends EG to the edge server ES3 for storage. The encrypted bipartite graph EG is shown in Figure 3.

[0062] Step 21: For the weight value w in G i,jThe data owner runs ORE.Enc(sk) ORE ,w i,j Algorithm generates ciphertext value

[0063] Step 22: For the weight value w in G i,j The data owner will w i,j Divided into two share values and in

[0064] Step 23: For share values and The data owner uses asymmetric encryption to encrypt the data, that is...

[0065] Step 24: The data owner will Store in EG[i][j];

[0066] Step 25: Once all weight values ​​in G are encrypted, the data owner sends EG to the edge server ES3 for storage.

[0067] Step 3: The data user executes the ReqGen algorithm to generate a matching request (Q). U Q V ), where Q U ={u1,u2}、Q V ={v1,v2,v3}. After executing the algorithm, the data user will (Q U Q V Send it to the edge server ES3.

[0068] Step 4: Given the cryptographic bipartite graph EG and the matching request (Q) U Q V Edge servers ES1, ES2, and ES3 jointly execute SecGraMatch(EG, Q). U Q V The algorithm obtains the optimal matching result M. U,V Figure 4 shows an example of the algorithm execution. After executing the algorithm, the edge server sends the result M. U,V Send to data users. Specifically:

[0069] Step 41: For u i ∈Q U and v j ∈Q V (i∈[1,2],j∈[1,3]), the edge server ES3 obtains from EG[i][j]. and set When Q U and Q V After processing the weights between all nodes, ES3 will... and Send them to edge servers ES1 and ES2 respectively;

[0070] Step 42: When ES1 receives ES2 received Then, ES1 and ES2 use the asymmetric encryption private keys sk1 and sk2 respectively to... and Decrypt to obtain the plaintext share value, which is the new share. equal New equal

[0071] Step 43: Edge servers ES1 and ES2 execute the RankMatrixCons algorithm to generate a ranking matrix. And according to The ranking order in the share matrix respectively and Perform the corresponding sorting;

[0072] Step 44: Edge Server ES1 and ES2 Detection For each row in the table, construct a set of conflicts related to v1, starting with the first-ranked node. Right now

[0073] Step 45: For ES1 and ES2 conflict resolution set on the server for S1 and S2, ES1 and ES2 are respectively based on and Calculate the difference between these two cases. and and respectively and Send to ES3;

[0074] Step 46: Edge Server ES3 Computation Because of d 1,2 ∈[1,p / 2], ES3 sets d 1,2 =1 and return it to the edge servers ES1 and ES2;

[0075] Step 47: When d is received 1,2 =1, edge servers ES1 and ES2 are configured according to formula d. o,y =1, Update matrix That is, setting And obtain M U,V ←M U,V ∪{(u1,v1)};

[0076] Edge servers ES1 and ES2 are based on the new matrix Conflict detection and elimination are performed. This is due to the conflict set constructed in the new ranking matrix. and Since all elements in the array contain only one element, all conflicts have been resolved, and the edge server obtains M. U,V ←M U,V ∪{(u2,v3)}.

[0077] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for secure conflict detection and elimination in weighted bipartite graph matching, characterized in that, The method includes: Step S1: A trusted third-party TTP executes a key generation algorithm. Generate a key and send it to the data owner DO, edge server ES1, and edge server ES2. For safety parameters, To reveal the encryption key, For public-private key pairs; Step S2: Given a bipartite graph The data owner, DO, executes a bipartite graph encryption algorithm. The two-part diagram Encryption and will Send to the edge server ES3 for storage; Step S3: Data user DU executes the matching request generation algorithm. The matching request generated by this algorithm indicates that DU expects the edge server to find a match from... Middle node to An optimal match for a node, i.e., the node that the data user DU expects to find. arrive The optimal match, where, and Represents the vertex set, indicating that after the algorithm is executed, DU will... Send to edge server ES3; Step S4: Execute the bipartite graph secure matching algorithm The algorithm is executed jointly by three edge servers when a matching request is received. Then, the edge server according to The optimal matching result is obtained by executing the bipartite graph safe matching algorithm. Step S4 further includes: Step S41: For and Edge server ES3 from cryptographic bipartite graph Found and The encryption weight value and share value of the corresponding node, that is, for In and In ES3 edge servers from get and set ， ， When request After all nodes have been processed, the edge server ES3 will... and Send to edge servers ES1 and ES2 respectively; Step S42: Conflict detection, when ES1 receives ES2 received Then, ES1 and ES2 each use the private key for asymmetric encryption. and right and Decrypt to obtain the plaintext share value, which is the new share. equal new equal Then, the edge servers ES1 and ES2 execute... Algorithm generates ranking matrix and according to The ranking order in the share matrix respectively and Perform the corresponding sorting; then, the edge servers ES1 and ES2 detect... For each row, the first-ranked node is used to construct information about... Conflict set ,Right now Step S43: Conflict elimination. This step eliminates conflicts for each set of conflicts until the number of elements in all sets of conflicts is 1.

2. The method according to claim 1, characterized in that, Step S1 further includes: Step S11: TTP input security parameters Then execute the algorithm. Generate decryption encryption key Step S12: TTP Execution Algorithm Generate two public-private key pairs and Step S13: TTP will Send to the data owner DO, and Send them to edge server ES1 and edge server ES2 respectively.

3. The method according to claim 1, characterized in that, Step S2 further includes: Step S21: For Each weight value in Data owner runs Algorithm generates ciphertext value Step S22: Using the idea of ​​additive secret sharing, Divided into two share values and ,in ， Representing large prime numbers; Step S23: Using asymmetric encryption Will Encryption ,in ， Step S24: ... Store to ,when After all weight values ​​in the DO are encrypted, DO will Send it to the edge server for storage using ES3.

4. The method according to claim 1, characterized in that, Step S43 further includes: setting yes middle The winning node among the nodes, Edge servers construct conflict resolution sets for ES1 and ES2. Each of the conflict resolution scenarios Will same Match, will Except Other nodes are matched with their second-ranked nodes; for Any two cases and ES1 and ES2 are respectively based on and Calculate the difference between these two cases. and The calculation process is as follows: in, express The node ranked first in The share weight value inside, express The node ranked second in The share weight value inside, express The node ranked first in The share weight value inside, express The node ranked second in The share weight value inside, express The node ranked first in The share weight value inside, express The node ranked second in The share weight value inside, express The node ranked first in The share weight value inside, express The node ranked second in The share weight value inside; when obtained in two cases and After the differences, the edge servers ES1 and ES2 will respectively and Send to the edge server ES3, ES3 computes ,like This indicates The weights inside are greater than The weights inside, ES3 sending Give ES1 and ES2; if This indicates The weights inside are less than The weights inside, ES3 sending Given ES1 and ES2, when the conflict resolution set After comparing all the cases, ES1 and ES2 will be able to know... The case with the highest weight is That is, satisfying the following formula and setting... ： Meanwhile, edge servers ES1 and ES2 update the matrix according to the above formula. That is, for All nodes inside, ES1 and ES2 will be excluded All outside of lines and The relevant weight values ​​are That is, for and ， After updating the matrix Then, the edge server continues to perform conflict detection and elimination according to steps S42 and S43 until the number of elements in all conflict sets is 1.

Images