Es gibt viele Probleme im wirklichen Leben, beispielsweise wie man den Händlergewinnen durch Kauf und Verkauf von Waren maximieren? Wie kann man die besten Gesamtergebnisse bei der Einschreibung von Studenten erzielen? Wie kann ein Patientendoktor das höchste Gesamt-Service-Level usw. erreichen. Wir können diese alle auf einheitliche Weise in bilaterale Entscheidungsprobleme umwandeln. Lassen Sie uns zunächst über Ihr Verständnis der bilateralen Entscheidungsfindung sprechen.
Bilaterale Entscheidungsfindung-persönliches Verständnis
Um jedem zu helfen, zu verstehen, werde ich ein einfaches Beispiel verwenden, um die bilateralen Entscheidungen vorzustellen. Es sind 10 Kunden auf dem Markt, nämlich A0, A1, A2, A3, A4, A5, A6, A7, A8, A9. Es gibt Produkte auf dem Markt, nämlich B0, B1, B2, B3, B4, B5, B6, B7, B8 und B9. Jetzt müssen diese 10 Produkte an diese 10 Kunden verteilt werden, und die allgemeine Zufriedenheit ist erforderlich. Natürlich bewertet jeder Kunde jedes Produkt anders. Kunden mit N -Produkten sind mit Ambn zufrieden. Wie kann man diese Produkte also zuweisen, um die allgemeine Zufriedenheit am höchsten zu machen? Dieses Thema ist ein bilaterales Problem mit der Entscheidungsfindung.
Algorithmus Einführung
Es gibt viele Algorithmen für die Implementierung bilateraler Entscheidungen. Hier ist eine Möglichkeit, über sich selbst zu denken (wenn es Ähnlichkeit gibt, ist es rein Zufall). Dieser Algorithmus wurde anhand eines Artikels über genetische Algorithmen angesehen, die ich zuvor geschrieben habe. Dieser Algorithmus verlangt, dass die Anzahl der Kunden und Produkte konsistent sein muss, und es handelt sich um eine Einzelbeziehung. Wenn die Zahl inkonsistent oder ein Paar N (n ist ein bestimmter Wert), können wir diesen Algorithmus durch Erstellen eines virtuellen Produkts (Kunden) verwenden. Lassen Sie mich kurz die Idee der Algorithmus vorstellen:
1) Wir wählen zunächst einen Zuweisungsplan. Hier gehen wir nicht davon aus, dass der anfängliche Allokationsplan darin besteht, M -Produkte M -Kunden zuzuweisen.
2) Wir setzen den Vergleichschritt auf 1;
3) Bestimmen Sie, ob der Schritt die Länge des Arrays überschreitet. Wenn es den Endalgorithmus überschreitet, führen Sie den nächsten Schritt weiter aus.
4) Vergleichen Sie die beiden Kunden unter der Stufenschrittgröße unter der Annahme, dass ihr Allokationsplan umgeschaltet ist. Wenn die Zufriedenheit nach der Einstellung größer als die Zufriedenheit vor der Einstellung ist, wechseln Sie sie ansonsten so, wie sie ist, die Vergleichsposition um einen nach hinten, um weiter bis zu Schritt 4).
5) Es gibt keinen Allokationsplan, der unter diesem Schritt angepasst werden kann. Fügen Sie 1 zum Schritt hinzu;
6) Springen Sie zu Schritt 3) und führen Sie weiter aus.
In der obigen Algorithmusbeschreibung konzentrieren wir uns auf Schritt 4). Hier gehen wir davon aus, dass das vom erste Kunden zugewiesene Produkt Produkt Nr. 1 ist und das vom zweite Kunden zugewiesene Produkt Produkt Nr. 2 ist und ihre Zufriedenheit mit dem Produkt A1B1 bzw. A2B2 ist. Zu diesem Zeitpunkt ist die allgemeine Zufriedenheit der beiden Kunden Score1 = A1B1+A2B2. Hier vergleichen wir ihren Allokationsplan, dh das vom erste Kunden zugewiesene Produkt ist Produkt Nr. 2, und das vom zweite Kunden zugewiesene Produkt ist Produkt Nr. 1. Zu diesem Zeitpunkt ist ihre Zufriedenheit mit dem Produkt A1B2 bzw. A2B1. Die allgemeine Zufriedenheit dieser beiden Kunden ist Score2 = A1B2+A2B1. Wenn Score1 weniger als Score2 ist, ändern wir die Allokationsstrategie, andernfalls beibehalten wir die ursprüngliche Allokationsstrategie.
Java -Code -Analyse
Die obige Einführung ist möglicherweise nicht zu spezifisch, oder wir wissen nicht, wie sie es mit Java implementieren sollen. Lassen Sie uns die Implementierung aufschlüsseln:
1) Beim Schreiben eines Algorithmus müssen wir zunächst einige Konstanten definieren, Zuordnungsschemata usw.:
public class zwölfteDecision {private int num = 10; // Anzahl der Personen private boolean maxflag = true; // ob er den Maximalwert privat int [] [] scorearray; // gegenseitige Bewertungsbewertung zwischen privat int [] Dectrayarray; // Wie aus b} auswählen sollHier gibt es ein Maxflag -Attribut. Seine Funktion besteht darin, festzustellen, ob unsere bilateralen Entscheidungen als maximal oder minimal angesehen werden sollten. True repräsentiert den Maximalwert, False repräsentiert den Mindestwert; Num wird verwendet, um die Anzahl der Personen zu identifizieren. Das ScoreArray -Array wird verwendet, um die Benutzerzufriedenheit mit dem Produkt darzustellen. Entscheidungsarray wird verwendet, um den Allokationsplan des Produkts zu speichern. Entscheidungstray [0] bedeutet, dass das vom Kunden mit der Nummer 0 zugewiesene Produkt [0].
2) Vor dem Ausführen des Algorithmus müssen wir die Anzahl der Personen festlegen
public void setNum (int num) {if (num <1) {System.out.println ("num muss größer als 0"); zurückkehren; } this.num = num; } 3) Kunden bewerten die Produktzufriedenheit und bestimmen den anfänglichen Allokationsplan
public void setScoreArray (int [] [] scoreArray) {if (scoreArray == null) {System.out.println ("scorearray ist null"); } if (! (scoreArray.length == num && scoreArray [0] .Length == num)) {System.out.println ("scorearray 'muss" + num); } this.scorearray = scoreArray; Entscheidungstraße = new int [num]; // Erstentscheidung, diagonal für (int i = 0; i <num; i ++) {Dectrayarray [i] = i; } Entscheidung(); } 4) Dann Schritt 4) in der Algorithmusbeschreibung durchführen, um zu bestätigen, ob der Allokationsplan eingestellt ist
private boolean compare (int stepsize) {für (int i = 0; i <num - stepsize; i ++) {int a1 = i; int a2 = i + stropssize; int B1 = Dectrayarray [A1]; int b2 = Dectrayarray [A2]; // Die Summe der ursprünglichen zwei Punkte int Score1 = scorearray [a1] [b1] + scorearray [a2] [b2]; int zwischen 1 = math.abs (scorearray [a1] [b1] - scorearray [a2] [b2]); // Die Summe der beiden Bewertungen nach Exchange Int Score2 = ScoreArray [A1] [B2] + ScoreArray [A2] [B1]; int zwischen2 = math.abs (scorearray [a1] [b2] - scorearray [a2] [b1]); if (maxflag) {// Die maximale Endbewertung ist if if (Score1 <= Score2) {// Die Punktzahl nach dem Austausch ist nicht geringer als der vorherige Exchange // Die Punktzahl nach dem Austausch ist größer als der vorherige Austausch oder der Differenz nach dem Austausch ist größer als der vorherige Austausch if (Score1 <Score2 || zwischen 2> zwischen 1) {Dectray] = B2; Entscheidungstraps [A2] = B1; zurückkehren; }}} else {// Die Endbewertung ist die kleinste wenn (Score1> = Score2) {// Die Punktzahl nach dem Austausch ist nicht geringer als der vorab der Exchange // Die Punktzahl nach dem Austausch ist größer als der vorab oder der Differenz nach dem Austausch ist größer als der vorab der Exchange if (Score1> Score2 || zwischen 2> zwischen 1) {Deciodearray [a1] = b2; Entscheidungstraps [A2] = B1; zurückkehren; }}} return false; } Der Rückgabewert dieser Methode besteht darin, zu bestätigen, ob die Schaltung bei dieser Schrittgröße auftritt. Wenn das Schalten bei dieser Schrittgröße auftritt, können wir die nächste Schrittgröße vergleichen. Dadurch wird der bilaterale Entscheidungsalgorithmus abgeschlossen. Schauen wir uns die folgenden Testergebnisse an.
Auslaufergebnisse
Maximale Test
Mindestwerttest
Vollständiger Code
/ ***@Beschreibung: Bilateral Matching Decision Algorithmus*/ Package com.lulei.twosidge.Matching.DecisionMaking; import com.lulei.util.jsonutil; public class zweigesidteDecision {private int num = 10; // Anzahl der Personen private boolean maxflag = true; // ob der maximale Wert privat int [] [] scorearray; // gegenseitige Bewertungsbewertung zwischen privat int [] DectrayArray; // So wählen Sie BOOLEAN ISMAXFLAG () Return MaxFlag; } public void setMaxflag (boolean maxflag) {this.maxflag = maxflag; } / ** * @return * @Author: lulei * @Description: Holen Sie sich die endgültige Entscheidung * / public int [] getDeCisionArray () {return DecelyArray; } / ** * @return * @Author: lulei * @Description: Holen Sie sich die Bewertung für die Entscheidung * / public int getScoresum () {int sum = 0; für (int i = 0; i <num; i ++) {sum+= scorearray [i] [Decelyarray [i]]; } Return Sum; } / ** * @param num * @Author: lulei * @Description: Stellen Sie die Anzahl der bilateralen Entscheidungen ein * / public void setNum (int num) {if (num <1) {System.out.println ("Num Muss größer als 0"); zurückkehren; } this.num = num; } / ** * @param scoreArray * @Author: lulei * @Description: Setzen Sie die Bewertung zwischen Individuen in der Klasse A und Individuen in Klasse B * / public void setScoreArray (int [] [] scoreArray) {if (scoreArray == null) {System.out.println ("Scorearray is null"); } if (! (scoreArray.length == num && scoreArray [0] .Length == num)) {System.out.println ("scorearray 'muss" + num); } this.scorearray = scoreArray; Entscheidungstraße = new int [num]; // Erstentscheidung, diagonal für (int i = 0; i <num; i ++) {Dectrayarray [i] = i; } Entscheidung(); } / *** @Author: lulei* @Description: Berechnen Sie die optimale Entscheidung* / private void Decision () {if (scoreArray == null || DectrayArray == null) {System.out.println ("bitte init scoreArray"); } für (int stepsize = 1; stepsize <num; stepsize ++) {// austauschen while (compare (stepsize)); }} / ** * @param stepsize * @return * @Author: lulei * @Description: Vergleich der spezifischen Schrittgröße, Rückwert, um zu bestätigen, ob der Austausch auftritt int a2 = i + stropssize; int B1 = Dectrayarray [A1]; int b2 = Dectrayarray [A2]; // Die Summe der ursprünglichen zwei Punkte int Score1 = scorearray [a1] [b1] + scorearray [a2] [b2]; int zwischen 1 = math.abs (scorearray [a1] [b1] - scorearray [a2] [b2]); // Die Summe der beiden Bewertungen nach Exchange Int Score2 = ScoreArray [A1] [B2] + ScoreArray [A2] [B1]; int zwischen2 = math.abs (scorearray [a1] [b2] - scorearray [a2] [b1]); if (maxflag) {// Die maximale Endbewertung ist if if (Score1 <= Score2) {// Die Punktzahl nach dem Austausch ist nicht geringer als der vorherige Exchange // Die Punktzahl nach dem Austausch ist größer als der vorherige Austausch oder der Differenz nach dem Austausch ist größer als der vorherige Austausch if (Score1 <Score2 || zwischen 2> zwischen 1) {Dectray] = B2; Entscheidungstraps [A2] = B1; zurückkehren; }}} else {// Die minimale Endbewertung if (Score1> = Score2) {// Die Punktzahl nach dem Austausch ist nicht geringer als der vorab der Exchange // Die Punktzahl nach dem Austausch ist größer als der Vorabbaus oder der Differenz nach dem Austausch ist größer als der vorab der Exchange if (Score1> Score2 || zwischen 2> zwischen 1) {Dectray] = B2; Entscheidungstraps [A2] = B1; zurückkehren; }}}} return false; } public static void main (String [] args) {int [] [] scoreArray = {{0,1,2,3,4,5,6,7,8,9}, {1,2,3,4,5,6,7,8,9,0}, {2,3,4,6,7,8,9,9,9,0},, {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,2,3,4,5}, {6,7,8,9,0,2,2,3,5,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}, {9,0,1,2,3,4,5,6,7}}; Zweigesiedelter Dezisionstest = neuer zweigesidterDecision (); test.setnum (10); test.setMaxflag (false); test.setsCorearray (scoreArray); System.out.println ("optimale Entscheidung"); System.out.println (jsonutil.parsejson (test.getDecisionArray ())); System.out.println ("Entscheidungsbewertung"); System.out.println (test.getScoresum ()); }}Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.