Il y a de nombreux problèmes dans la vie réelle, comme comment maximiser les bénéfices des marchands en achetant et en vendant des marchandises? Comment obtenir les meilleurs résultats globaux dans l'inscription des étudiants? Comment un médecin peut-il atteindre le niveau de service global le plus élevé, etc. Nous pouvons tous les transformer en problèmes de prise de décision bilatéraux de manière unifiée. Parlons d'abord de votre compréhension de la prise de décision bilatérale.
Prise de décision bilatérale - compréhension personnelle
Pour aider tout le monde à comprendre, j'utiliserai un exemple simple pour introduire les décisions bilatérales. Il y a 10 clients sur le marché, à savoir A0, A1, A2, A3, A4, A5, A6, A7, A8, A9. Il y a des produits sur le marché, à savoir B0, B1, B2, B3, B4, B5, B6, B7, B8 et B9. Maintenant, ces 10 produits doivent être distribués à ces 10 clients, et la satisfaction globale est requise. Bien sûr, chaque client marque chaque produit différemment. Les clients avec N produits sont satisfaits de l'AMBN. Alors, comment allouer ces produits pour rendre la satisfaction globale la plus élevée? Ce sujet est un problème de prise de décision bilatéral.
Introduction de l'algorithme
Il existe de nombreux algorithmes pour la mise en œuvre de la prise de décision bilatérale. Voici une façon de penser à soi-même (s'il y a une similitude, c'est une pure coïncidence). Cet algorithme a été pensé sur la base d'un article sur les algorithmes génétiques que j'ai écrits auparavant. Cet algorithme nécessite que le nombre de clients et de produits soit cohérent et qu'il s'agit d'une relation individuelle. Si le nombre est incohérent ou une paire de n (n est une valeur spécifique), nous pouvons utiliser cet algorithme en créant un produit virtuel (client). Permettez-moi de présenter brièvement l'idée de l'algorithme:
1) Nous choisissons d'abord un plan d'allocation. Ici, nous ne supposons pas que le plan d'allocation initial est d'allouer des produits M à M clients;
2) Nous définissons l'étape de comparaison étape sur 1;
3) Déterminez si l'étape dépasse la longueur du tableau. S'il dépasse l'algorithme de fin, s'il ne dépasse pas l'étape suivante, continuez à exécuter l'étape suivante;
4) Comparez les deux clients sous la taille de l'étape, en supposant que leur plan d'allocation est commuté. Si la satisfaction après l'ajustement est supérieure à la satisfaction avant le réglage, changez-la, sinon le gardez tel quel, déplacez la position de comparaison un en arrière pour continuer à étape 4);
5) Il n'y a aucun plan d'allocation qui peut être ajusté en vertu de cette étape, ajoutez 1 à l'étape;
6) Passez à l'étape 3) et continuez à s'exécuter.
Dans la description de l'algorithme ci-dessus, nous nous concentrons sur l'étape 4). Ici, nous supposons que le produit alloué par le premier client est le produit n ° 1, et que le produit alloué par le deuxième client est le produit n ° 2, et leur satisfaction à l'égard du produit est A1b1 et A2B2, respectivement. À l'heure actuelle, la satisfaction globale des deux clients est SCORE1 = A1B1 + A2B2. Ici, nous comparons leur plan d'allocation, c'est-à-dire que le produit alloué par le premier client est le produit n ° 2, et le produit alloué par le deuxième client est le produit n ° 1, et à ce moment, leur satisfaction à l'égard du produit est respectivement A1B2 et A2B1. La satisfaction globale de ces deux clients est SCORE2 = A1B2 + A2B1. Si Score1 est inférieur à Score2, alors nous modifions la stratégie d'allocation, sinon nous maintenons la stratégie d'allocation d'origine.
Analyse du code Java
L'introduction ci-dessus peut ne pas être trop spécifique, ou nous ne savons pas comment l'implémenter avec Java. Décomposons la mise en œuvre:
1) Lors de la rédaction d'un algorithme, nous devons d'abord définir certaines constantes, sauver les schémas d'allocation, etc .:
classe publique TwoSideDecision {private int num = 10; // nombre de personnes privées booléen maxflag = true; // s'il faut trouver la valeur maximale private int [] [] scorarray; // score d'évaluation mutuelle entre ab privé int [] DecisionArray; // comment choisir B}Il y a un attribut maxflag ici. Sa fonction est de déterminer si nos décisions bilatérales doivent être prises comme maximum ou minimum. True représente la valeur maximale, FALSE représente la valeur minimale; NUM est utilisé pour identifier le nombre d'individus, Scorray Tray est utilisé pour représenter la satisfaction des utilisateurs à l'égard du produit, DecisionArray est utilisé pour enregistrer le plan d'allocation du produit, DecisionArray [0] signifie que le produit alloué par le client avec le nombre 0 est DecisionArray [0];
2) Avant d'exécuter l'algorithme, nous devons définir le nombre d'individus
public void setNum (int num) {if (num <1) {System.out.println ("num doit être supérieur à 0"); retour; } this.num = num; } 3) Les clients marquent la satisfaction du produit et déterminent le plan d'allocation initial
public void setScoreArray (int [] [] scorarray) {if (scorarray == null) {System.out.println ("Scorarray est null"); } if (! (Scorarray.length == num && ScorArray [0] .length == num)) {System.out.println ("Scorarray doit être" + num); } this.scoreArray = ScorArray; DecisionArray = new int [num]; // Décision initiale, diagonale pour (int i = 0; i <num; i ++) {DecisionArray [i] = i; } décision(); } 4) Ensuite, effectuez l'étape 4) dans la description de l'algorithme pour confirmer si le plan d'allocation est ajusté
Boolean Private Compare (int spepsize) {for (int i = 0; i <num - sceapse; i ++) {int a1 = i; int a2 = i + étapes; int b1 = DecisionArray [A1]; int b2 = DecisionArray [A2]; // la somme des deux scores d'origine int score1 = SCORAY [A1] [B1] + SCORAY [A2] [B2]; int entre1 = math.abs (scorarray [a1] [b1] - scorarray [a2] [b2]); // la somme des deux scores après échange int score2 = scorarray [a1] [b2] + scorarray [a2] [b1]; int entre2 = math.abs (Scorarray [A1] [B2] - Scorarray [A2] [B1]); if (maxflag) {// Le score final maximum est if (score1 <= score2) {// Le score après l'échange n'est pas inférieur à l'échange précédent // Le score après l'échange est supérieur à l'échange précédent ou la différence après échange est supérieure à l'échange précédent if (score1 <score2 || entre2> entre 1) {DeciscandArray [A1] = b2; DecisionArray [A2] = B1; Retour Vrai; }}} else {// Le score final est le plus petit if (score1> = score2) {// Le score après l'échange n'est pas inférieur à celui avant d'échange // Le score après l'échange est supérieur à celui de l'échange avant ou la différence après échange est supérieure à celle avant l'échange if (score1> score2 || entre2> entre1) {DeciscandArray [A1] = B2; DecisionArray [A2] = B1; Retour Vrai; }}} return false; } La valeur de retour de cette méthode consiste à confirmer si la commutation se produit à cette taille de pas. Si la commutation se produit à cette taille de pas, nous pouvons comparer la taille de l'étape suivante. Cela complète l'algorithme de prise de décision bilatéral. Jetons un coup d'œil aux résultats des tests ci-dessous.
Résultats en cours d'exécution
Test maximum
Test de valeur minimale
Code complet
/ ** * @ Description: Algorithme de décision de correspondance bilatérale * / package com.lulei.twosided.matching.decisionmaking; import com.lulei.util.jsonutil; classe publique TwoSideDecision {private int num = 10; // nombre de personnes privées booléen maxflag = true; // s'il faut trouver la valeur maximale privée int [] [] scorarray; // score d'évaluation mutuelle entre AB private int [] DecisionArray; // comment choisir B booléen public ismaxflag () {return maxflag; } public void setmaxflag (booléen maxflag) {this.maxflag = maxflag; } / ** * @return * @Author: Lulei * @Description: Obtenez la décision finale * / public int [] getDecisionArray () {return DecisionArray; } / ** * @return * @author: Lulei * @Description: obtenez la note de la décision * / public int getSCoreUm () {int sum = 0; pour (int i = 0; i <num; i ++) {sum + = scorarray [i] [DecisionArray [i]]; } RETOUR SUM; } / ** * @param num * @author: Lulei * @description: définissez le nombre d'individus de prise de décision bilatéraux * / public void setNum (int num) {if (num <1) {System.out.println ("num doit être supérieur à 0"); retour; } this.num = num; } / ** * @param ScorArray * @Author: Lulei * @Description: Définissez l'évaluation entre les individus de la classe A et les individus de la classe B * / public void setScoreArray (int [] [] scorarray) {if (Scorarray == Null) {System.out.println ("Scorarray est nul"); } if (! (Scorarray.length == num && ScorArray [0] .length == num)) {System.out.println ("Scorarray doit être" + num); } this.scoreArray = ScorArray; DecisionArray = new int [num]; // Décision initiale, diagonale pour (int i = 0; i <num; i ++) {DecisionArray [i] = i; } décision(); } / ** * @Author: Lulei * @Description: Calculez la décision optimale * / private void Decision () {if (ScorArray == Null || DecisionArray == NULL) {System.out.println ("s'il vous plaît init ScorArray"); } pour (int spship = 1; Stepsize <num; Stepsize ++) {// échange while (compare (étapes)); }} / ** * @param étapes SITSIZE * @return * @Author: Lulei * @Description: Comparaison de la taille de pas spécifique, valeur de retour pour confirmer si l'échange se produit * / private booléan compare (int stepingSise) {for (int i = 0; i <num - sceapsize; i ++) {int a1 = i; int a2 = i + étapes; int b1 = DecisionArray [A1]; int b2 = DecisionArray [A2]; // la somme des deux scores d'origine int score1 = SCORAY [A1] [B1] + SCORAY [A2] [B2]; int entre1 = math.abs (scorarray [a1] [b1] - scorarray [a2] [b2]); // la somme des deux scores après échange int score2 = scorarray [a1] [b2] + scorarray [a2] [b1]; int entre2 = math.abs (Scorarray [A1] [B2] - Scorarray [A2] [B1]); if (maxflag) {// Le score final maximum est if (score1 <= score2) {// Le score après l'échange n'est pas inférieur à l'échange précédent // Le score après l'échange est supérieur à l'échange précédent ou la différence après échange est supérieure à l'échange précédent if (score1 <score2 || entre2> entre 1) {DeciscandArray [A1] = b2; DecisionArray [A2] = B1; Retour Vrai; }}} else {// Le score final minimum if (score1> = score2) {// Le score après l'échange n'est pas inférieur à celui avant d'échange // Le score après l'échange est supérieur à celui avant l'échange ou la différence après l'échange est supérieure à celle avant l'échange if (score1> score2 || entre2> entre1) {Deciscanday [A1] = B2; DecisionArray [A2] = B1; Retour Vrai; }}}} return false; } public static void main (String [] args) {int [] [] scorarray = {{0,1,2,3,4,5,6,7,8,9}, {1,2,3,4,5,6,7,8,9,0}, {2,3,4,5,6,7,8,9,0,1 {3,4,5,6,7,8,9,0,1,2}, {4,5,6,7,8,9,0,1,2,3,}, {5,6,7,8,9,0,1,2,3,4,5}, {6,7,8,9,0,1,2,3,4,5},, 6,7,8,9,0,1,2,3,4,5}, {7,8,9,0,1,2,3,4,5,6}, {8,9,0,1,2,3,4,5,6,7}, {9,0,1,2,3,4,5,6,7}, {9,0,1,2,3,4,5,6,7}; TwoSideDecision Test = new TwoSideDision (); test.setnum (10); test.setMaxFlag (false); Test.SetSCoreArray (Scorarray); System.out.println ("décision optimale"); System.out.println (jsonutil.parsejson (test.getDecisionArray ())); System.out.println ("Score de décision"); System.out.println (test.getScoreSUM ()); }}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.