¿Hay muchos problemas en la vida real, como cómo maximizar las ganancias comerciales comprando y vendiendo productos? ¿Cómo lograr los mejores resultados generales en la inscripción de estudiantes universitarios? ¿Cómo puede un médico paciente lograr el nivel de servicio general más alto, etc. Todos podemos transformarlos en problemas de toma de decisiones bilaterales de manera unificada? Primero hablemos sobre su comprensión de la toma de decisiones bilaterales.
Toma de decisiones bilaterales-comprensión personal
Para ayudar a todos a comprender, utilizaré un ejemplo simple para introducir qué son las decisiones bilaterales. Hay 10 clientes en el mercado, a saber, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9. Hay productos en el mercado, a saber, B0, B1, B2, B3, B4, B5, B6, B7, B8 y B9. Ahora, estos 10 productos deben distribuirse a estos 10 clientes, y se requiere la satisfacción general. Por supuesto, cada cliente obtiene cada producto de manera diferente. Los clientes con productos están satisfechos con Ambn. Entonces, ¿cómo asignar estos productos para que la satisfacción general sea la más alta? Este tema es un problema bilateral de toma de decisiones.
Algoritmo Introducción
Hay muchos algoritmos para implementar la toma de decisiones bilaterales. Aquí hay una forma de pensar en uno mismo (si hay similitud, es puramente coincidencia). Este algoritmo se pensó en base a un artículo sobre algoritmos genéticos que escribí antes. Este algoritmo requiere que el número de clientes y productos sea consistente, y es una relación uno a uno. Si el número es inconsistente o un par de N (n es un valor específico), podemos usar este algoritmo construyendo un producto virtual (cliente). Permítanme presentar brevemente la idea del algoritmo:
1) Primero elegimos un plan de asignación. Aquí no asumimos que el plan de asignación inicial es asignar m productos a los clientes de M;
2) establecemos el paso de comparación en 1 en 1;
3) Determine si el paso excede la longitud de la matriz. Si excede el algoritmo final, si no excede el siguiente paso, continúe ejecutando el siguiente paso;
4) Compare los dos clientes bajo el tamaño del paso de paso, suponiendo que se cambie su plan de asignación. Si la satisfacción después del ajuste es mayor que la satisfacción antes del ajuste, cambiela, de lo contrario, manténgala como está, mueva la posición de comparación una hacia atrás para continuar el paso 4);
5) No hay un plan de asignación que se pueda ajustar bajo este paso, agregue 1 al paso;
6) Salta al paso 3) y continúe ejecutándole.
En la descripción del algoritmo anterior, nos centramos en el paso 4). Aquí suponemos que el producto asignado por el primer cliente es el producto No. 1, y el producto asignado por el segundo cliente es el Producto No. 2, y su satisfacción con el producto es A1B1 y A2B2, respectivamente. En este momento, la satisfacción general de los dos clientes es Score1 = A1B1+A2B2. Aquí comparamos su plan de asignación, es decir, el producto asignado por el primer cliente es el Producto No. 2, y el producto asignado por el segundo cliente es el Producto No. 1, y en este momento su satisfacción con el producto es A1B2 y A2B1, respectivamente. La satisfacción general de estos dos clientes es Score2 = A1B2+A2B1. Si Score1 es menor que Score2, entonces cambiamos la estrategia de asignación, de lo contrario mantenemos la estrategia de asignación original.
Análisis de código Java
La introducción anterior puede no ser demasiado específica, o no sabemos cómo implementarla con Java. Desglosemos la implementación:
1) Al escribir un algoritmo, primero debemos definir algunas constantes, guardar esquemas de asignación, etc.:
clase pública TwosidedDecision {private int num = 10; // Número de individuos booleanos privados maxflag = true; // si debe encontrar el valor máximo private int [] [] scorearray; // puntaje de evaluación mutua entre ab private int [] decisionArray; //Hay un atributo MaxFlag aquí. Su función es identificar si nuestras decisiones bilaterales deben tomarse como el máximo o mínimo. Verdadero representa el valor máximo, False representa el valor mínimo; NUM se utiliza para identificar el número de individuos, ScorearRay Array se usa para representar la satisfacción del usuario con el producto, DecisionArray se usa para guardar el plan de asignación del producto, DecisionArray [0] significa que el producto asignado por el cliente con el número 0 es DecisionArray [0];
2) Antes de ejecutar el algoritmo, necesitamos establecer el número de personas
public void setnum (int num) {if (num <1) {System.out.println ("num debe ser mayor que 0"); devolver; } this.num = num; } 3) Los clientes obtienen la satisfacción del producto y determinan el plan de asignación inicial
public void setScoreArray (int [] [] scoreArray) {if (scoreArray == null) {System.out.println ("ScoreArArray es nulo"); } if (! (scorearray.length == num && scorearray [0] .length == num)) {system.out.println ("scorearray`s debe ser" + num); } this.scorearray = scorearray; decisionArray = new int [num]; // decisión inicial, diagonal para (int i = 0; i <num; i ++) {decisionArray [i] = i; } decisión(); } 4) Luego realice el paso 4) en la descripción del algoritmo para confirmar si el plan de asignación está ajustado
Private Boolean Compare (int Stepesize) {for (int i = 0; i <num - Stepsize; i ++) {int a1 = i; int a2 = i + Stepsize; int b1 = decisionArray [a1]; int b2 = decisionArray [a2]; // La suma de los dos puntajes originales int score1 = scorearray [a1] [b1] + scorearray [a2] [b2]; int entre1 = math.abs (scorearray [a1] [b1] - scorearray [a2] [b2]); // La suma de las dos puntuaciones después de Exchange int store22 = scorearray [a1] [b2] + scorearray [a2] [b1]; int entre2 = math.abs (scorearray [a1] [b2] - scorearray [a2] [b1]); if (maxflag) {// La puntuación final máxima es if (score1 <= stork2) {// El puntaje después del intercambio no es menor que el intercambio anterior // El puntaje después del intercambio es mayor que el intercambio anterior o la diferencia después del intercambio es mayor que el intercambio anterior si (score1 <scatting2 || entre2> entre1) {decisión array [a1] = b2; DecisionArray [A2] = B1; devolver verdadero; }}} else {// El puntaje final es el más pequeño if (scatting1> = score2) {// El puntaje después del intercambio no es menor que el intercambio anterior // El puntaje después del intercambio es mayor que el intercambio anterior o la diferencia después del intercambio es mayor que el intercambio anterior if (score1> store2 || entre2> entre 1) {decisión de decisión [a1] = b2; DecisionArray [A2] = B1; devolver verdadero; }}} return false; } El valor de retorno de este método es confirmar si la conmutación ocurre en este tamaño de paso. Si la conmutación ocurre en este tamaño de paso, podemos comparar el siguiente tamaño de paso. Esto completa el algoritmo bilateral de toma de decisiones. Echemos un vistazo a los resultados de la prueba a continuación.
Resultados de ejecución
Prueba máxima
Prueba de valor mínimo
Código completo
/ ***@Descripción: Algoritmo de decisión de correspondencia bilateral*/ paquete com.lulei.twosided.matching.decisionMaking; import com.lulei.util.jsonutil; clase pública TwosidedDecision {private int num = 10; // Número de individuos booleanos privados maxflag = true; // si para encontrar el valor máximo private int [] [] scorearray; // puntuación de evaluación mutua entre ab private int [] decisionArray; // cómo elegir b público booleano booleano booleano booleano () {return maxflag; } public void setmaxflag (boolean maxflag) {this.maxflag = maxflag; } / ** * @return * @author: lulei * @Description: Obtenga la decisión final * / public int [] getDecisionArray () {return DecisionArray; } / ** * @return * @author: lulei * @Description: Obtenga la calificación de la decisión * / public int getScoresum () {int sum = 0; para (int i = 0; i <num; i ++) {sum+= scoreArray [i] [decisionArray [i]]; } suma de retorno; } / ** * @param num * @author: lulei * @Description: establezca el número de individuos bilaterales de toma de decisiones * / public void setNum (int num) {if (num <1) {System.Println ("NUM debe ser mayor que 0"); devolver; } this.num = num; } / ** * @param scorearray * @author: lulei * @Description: Establezca la evaluación entre individuos en la clase A y los individuos en la clase B * / public void setScorEarray (int [] [] scorearray) {if (scoreArArray == null) {system.out.println (ScorearRay (nulle "); } if (! (scorearray.length == num && scorearray [0] .length == num)) {system.out.println ("scorearray`s debe ser" + num); } this.scorearray = scorearray; decisionArray = new int [num]; // decisión inicial, diagonal para (int i = 0; i <num; i ++) {decisionArray [i] = i; } decisión(); } / *** @author: lulei* @Description: calcule la decisión óptima* / decisión privada void () {if (scoreArray == null || decisionArray == null) {system.out.println ("por favor inicial screarearray"); } para (int stepesize = 1; Stepsize <num; Stepsize ++) {// intercambio while (compare (StepSize)); }} / ** * @param Stepsize * @return * @author: lulei * @description: comparación del tamaño de paso específico, valor de retorno para confirmar si el intercambio ocurre * / private boolean compare (int stepesize) {for (int i = 0; i <num - stepesize; i ++) {int a1 = i; int a2 = i + Stepsize; int b1 = decisionArray [a1]; int b2 = decisionArray [a2]; // La suma de los dos puntajes originales int score1 = scorearray [a1] [b1] + scorearray [a2] [b2]; int entre1 = math.abs (scorearray [a1] [b1] - scorearray [a2] [b2]); // La suma de las dos puntuaciones después de Exchange int store22 = scorearray [a1] [b2] + scorearray [a2] [b1]; int entre2 = math.abs (scorearray [a1] [b2] - scorearray [a2] [b1]); if (maxflag) {// La puntuación final máxima es if (score1 <= stork2) {// El puntaje después del intercambio no es menor que el intercambio anterior // El puntaje después del intercambio es mayor que el intercambio anterior o la diferencia después del intercambio es mayor que el intercambio anterior si (score1 <scatting2 || entre2> entre1) {decisión array [a1] = b2; DecisionArray [A2] = B1; devolver verdadero; }}} else {// El puntaje final mínimo if (score1> = scatter2) {// El puntaje después del intercambio no es menor que el intercambio anterior // El puntaje después del intercambio es mayor que el intercambio anterior o la diferencia después del intercambio es mayor que el intercambio anterior if (scatter1> score2 || entre2> entre1) {decisionArray [A1] = b2; DecisionArray [A2] = B1; devolver verdadero; }}}} 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,9,0}, {2,3,4,5,6,7,9,9,11}, {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},, {7,8,9,0,1,2,3,4,5,6}, {8,9,0,1,2,3,4,4,5,6,7}, {9,0,1,2,3,4,5,6,7}, {9,0,1,2,3,4,6,7,7}, {9,0,1,2,3,4,4,4,5,5,5}; TwosidedDecision test = new twosidedDecision (); test.setNum (10); test.setMaxFlag (falso); test.setscorearray (scorearray); System.out.println ("decisión óptima"); System.out.println (jsonutil.parsejson (test.getDecisionArray ())); System.out.println ("Puntuación de decisión"); System.out.println (test.getScoresum ()); }}Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.