Existem muitos problemas na vida real, como maximizar os lucros do comerciante comprando e vendendo mercadorias? Como alcançar os melhores resultados gerais na matrícula de estudantes universitários? Como um médico paciente pode alcançar o nível geral de serviço geral, etc. Todos nós podemos transformá-los em problemas bilaterais de tomada de decisão de maneira unificada. Vamos falar sobre sua compreensão da tomada de decisão bilateral.
Tomada de decisão bilateral-compreensão pessoal
Para ajudar todos a entender, usarei um exemplo simples para introduzir o que são decisões bilaterais. Existem 10 clientes no mercado, como A0, A1, A2, A3, A4, A5, A6, A7, A8, A9. Existem produtos no mercado, ou seja, B0, B1, B2, B3, B4, B5, B6, B7, B8 e B9. Agora, esses 10 produtos devem ser distribuídos a esses 10 clientes, e a satisfação geral é necessária. Obviamente, cada cliente obtém cada produto de maneira diferente. Os clientes com N produtos estão satisfeitos com a AMBN. Então, como alocar esses produtos para tornar a satisfação geral a mais alta? Este tópico é um problema bilateral de tomada de decisão.
Introdução ao algoritmo
Existem muitos algoritmos para implementar a tomada de decisão bilateral. Aqui está uma maneira de pensar em si mesmo (se houver semelhança, é puramente coincidência). Esse algoritmo foi pensado com base em um artigo sobre algoritmos genéticos que escrevi antes. Esse algoritmo exige que o número de clientes e produtos seja consistente e é um relacionamento individual. Se o número for inconsistente ou um par de n (n for um valor específico), podemos usar esse algoritmo construindo um produto virtual (cliente). Deixe -me apresentar brevemente a ideia do algoritmo:
1) Primeiro escolhemos um plano de alocação. Aqui não assumimos que o plano de alocação inicial é alocar produtos M aos clientes M;
2) definimos a etapa de comparação para 1;
3) Determine se a etapa excede o comprimento da matriz. Se exceder o algoritmo final, se não exceder a próxima etapa, continue executando a próxima etapa;
4) Compare os dois clientes no tamanho da etapa, assumindo que seu plano de alocação seja alterado. Se a satisfação após o ajuste for maior que a satisfação antes do ajuste, alterne -o; caso contrário, mantenha -o como estiver, mova a posição de comparação um para trás para continuar a etapa 4);
5) Não há plano de alocação que possa ser ajustado nesta etapa, adicione 1 à etapa;
6) Salte para a etapa 3) e continue a executar.
Na descrição do algoritmo acima, focamos na etapa 4). Aqui, assumimos que o produto alocado pelo primeiro cliente é o produto nº 1, e o produto alocado pelo segundo cliente é o produto nº 2, e sua satisfação com o produto é A1B1 e A2B2, respectivamente. Neste momento, a satisfação geral dos dois clientes é SCORE1 = A1B1+A2B2. Aqui, comparamos o plano de alocação, ou seja, o produto alocado pelo primeiro cliente é o produto nº 2, e o produto alocado pelo segundo cliente é o produto nº 1 e, neste momento, sua satisfação com o produto é A1B2 e A2B1, respectivamente. A satisfação geral desses dois clientes é o Score2 = A1B2+A2B1. Se o Score1 for menor que o SCORE2, alteramos a estratégia de alocação; caso contrário, mantemos a estratégia de alocação original.
Análise de código Java
A introdução acima pode não ser muito específica, ou não sabemos como implementá -lo com o Java. Vamos dividir a implementação:
1) Ao escrever um algoritmo, primeiro precisamos definir algumas constantes, salvar esquemas de alocação, etc.:
Classe pública Decisão dupla {private int num = 10; // Número de indivíduos Private boolean maxflag = true; // Se deve encontrar o valor máximo privado int [] [] scoreArray; // pontuação de avaliação mútua entre a abate de DecisionArray; // Como escolher B}Há um atributo maxflag aqui. Sua função é identificar se nossas decisões bilaterais devem ser tomadas como o máximo ou o mínimo. O verdadeiro representa o valor máximo, o falso representa o valor mínimo; O NUM é usado para identificar o número de indivíduos, a matriz ScoreArray é usada para representar a satisfação do usuário com o produto, o DecisionArray é usado para salvar o plano de alocação do produto, o DecisionArray [0] significa que o produto alocado pelo cliente com o número 0 é o DecisionArray [0];
2) Antes de executar o algoritmo, precisamos definir o número de indivíduos
public void setNum (int num) {if (num <1) {System.out.println ("num deve ser maior que 0"); retornar; } this.num = num; } 3) Os clientes pontuam a satisfação do produto e determinam o plano de alocação inicial
public void setScoreArray (int [] [] scoreArray) {if (scoreArray == null) {System.out.println ("scoreArray é nulo"); } if (! (scoreArray.length == num && scoreArray [0] .Length == num)) {System.out.println ("scoreArray's deve ser" + num); } this.scoreArray = scoreArray; DecisionArray = new int [num]; // Decisão inicial, diagonal para (int i = 0; i <num; i ++) {DecisionArray [i] = i; } decisão (); } 4) Em seguida, execute a etapa 4) na descrição do algoritmo para confirmar se o plano de alocação é ajustado
Comparo booleano privado (int stepsize) {for (int i = 0; i <num - steisize; i ++) {int a1 = i; int a2 = i + stepsize; int b1 = DecisionArray [A1]; int b2 = DecisionArray [A2]; // a soma das duas pontuações originais int score1 = scoreArray [a1] [b1] + scoreArray [a2] [b2]; int entre1 = math.abs (scoreArray [a1] [b1] - scoreArray [a2] [b2]); // a soma das duas pontuações após o troca int escore2 = scoreArray [a1] [b2] + scoreArray [a2] [b1]; int entre2 = math.abs (scoreArray [a1] [b2] - scoreArray [a2] [b1]); if (maxflag) {// A pontuação final máxima é se (score1 <= score2) {// a pontuação após a troca não for menor que a troca anterior // a pontuação após a troca é maior que a troca anterior ou a diferença após a troca é maior que a troca anterior se (score1 <score2 || entre 2> entre1) {DecisionArray [a1] = B2; DecisionArray [A2] = B1; retornar true; }}} else {// A pontuação final é a menor if (score1> = score2) {// A pontuação após a troca não é menor que a troca antes da troca // A pontuação após a troca é maior que a troca antes ou a diferença após a troca é maior que a troca antes (Score1> Score2 || entre2> entre1) {DecisionArray [A1] = B2; DecisionArray [A2] = B1; retornar true; }}} retorna false; } O valor de retorno deste método é confirmar se a comutação ocorre neste tamanho de etapa. Se a comutação ocorrer neste tamanho de etapa, podemos comparar o tamanho da próxima etapa. Isso completa o algoritmo bilateral de tomada de decisão. Vamos dar uma olhada nos resultados do teste abaixo.
Resultados de execução
Teste máximo
Teste de valor mínimo
Código completo
/ ***@Descrição: Algoritmo de decisão de correspondência bilateral*/ package com.lulei.twosided.matching.decisionmaking; importação com.lulei.util.jsonutil; classe pública Decisão dupla {private int num = 10; // Número de indivíduos Privados booleanos maxflag = true; // Se deve encontrar o valor máximo privado int [] [] scoreArray; // pontuação de avaliação mútua entre abate ab privado int [] decishArray; } public void setMaxFlag (boolean maxflag) {this.maxflag = maxflag; } / ** * @return * @author: lulei * @description: obtenha a decisão final * / public int [] getDecisionArray () {return DecisionArray; } / ** * @return * @author: lulei * @description: obtenha a classificação para a decisão * / public int getScoresum () {int sum = 0; for (int i = 0; i <num; i ++) {sum+= scoreArray [i] [DecisionArray [i]]; } retornar soma; } / ** * @param num * @author: lulei * @description: defina o número de indivíduos de tomada de decisão bilateral * / public void Setnum (int num) {if (num <1) {System.out.println ("num deve ser maior que 0"); retornar; } this.num = num; } / ** * @param scoreArray * @Author: lulei * @Description: Defina a avaliação entre indivíduos na classe A e indivíduos na classe b * / public void setScoreArray (int [] [] scoreArray) {if (scoreArray == null) {System.out.println ("scorearra é n"; } if (! (scoreArray.length == num && scoreArray [0] .Length == num)) {System.out.println ("scoreArray's deve ser" + num); } this.scoreArray = scoreArray; DecisionArray = new int [num]; // Decisão inicial, diagonal para (int i = 0; i <num; i ++) {DecisionArray [i] = i; } decisão (); } / *** @Author: lulei* @Description: Calcule a decisão ideal* / private void Decision () {if (scoreArray == NULL || DecisionArray == null) {System.out.println ("por favor init scorearray"); } para (int spetedize = 1; stepsize <num; stedsize ++) {// troca while (compare (stepsize)); }} / ** * @param steisize * @return * @author: lulei * @description: comparação do tamanho do passo específico, valor de retorno para confirmar se a troca ocorre * / private boolean Compare (int sisseize) {for (int i = i <num - stepseize; i ++) {int a1 = i; int a2 = i + stepsize; int b1 = DecisionArray [A1]; int b2 = DecisionArray [A2]; // a soma das duas pontuações originais int score1 = scoreArray [a1] [b1] + scoreArray [a2] [b2]; int entre1 = math.abs (scoreArray [a1] [b1] - scoreArray [a2] [b2]); // a soma das duas pontuações após o troca int escore2 = scoreArray [a1] [b2] + scoreArray [a2] [b1]; int entre2 = math.abs (scoreArray [a1] [b2] - scoreArray [a2] [b1]); if (maxflag) {// A pontuação final máxima é se (score1 <= score2) {// a pontuação após a troca não for menor que a troca anterior // a pontuação após a troca é maior que a troca anterior ou a diferença após a troca é maior que a troca anterior se (score1 <score2 || entre 2> entre1) {DecisionArray [a1] = B2; DecisionArray [A2] = B1; retornar true; }}} else {// a pontuação final mínima se (score1> = score2) {// A pontuação após a troca não é menor que a troca antes da troca // A pontuação após a troca é maior que a troca antes da troca ou a diferença após a troca é maior que a troca antes da troca (Score1> Score2 || entre2> entre1) {DecisionArray [a1] = B2; DecisionArray [A2] = B1; retornar true; }}}} retornar 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,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}, {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,7,7}, {9,0,1,2,4,,4,7,7,7}}, {9,0,2,2,4,,6,7,7}}} {9,0,2,2,4,s Teste de decisione twoSided = new TwoSidedDecision (); test.setNum (10); test.setMaxFlag (false); test.SetsCoreArray (ScoreArray); System.out.println ("Decisão ideal"); System.out.println (jsonutil.parsejson (test.getDecisionArray ())); System.out.println ("pontuação de decisão"); System.out.println (test.getscoresum ()); }}O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.