Cómo alterar filas específicas de la lista 2d según el valor de booleano dependiente de la lista

¿Cómo puedo incorporar esta verificación booleana T / F en este código sin que pase por toda la lista de matrices>?

la situación es la siguiente;

arraylist<arraylist<Integer>> bigArray....elig arraylist<Boolean>
elig.size() == bigArray.get(0).size();
bigArray is rectangular (i.e. no differing sizes of interior Lists

mi código es el siguiente:

for(int j=0; j<(bigArr.size()); j++) {  //lets assume this is ==10           
  for(int e=0; e<(ballotArr.get(0).size()); e++) {   //assume == 5
    if(elig.get(e) == false) {          
        for(int k=0; k<(ballotArr.get(0).size()); k++) {  //==5
            bigArr.get(j).set(k, big.get(j).get(k)-1);
        }
    }
  } 
}

Como puede verse claramente, esto recorrerá el bucle for más interior 10 veces en cualquier momento elig.get (e) == false, y se restará de todos los índices.

lo que es necesario es que elig.get (e) mantenga un valor estable mientras que for (int k) procesa, y luego obtenga el siguiente valor (al menos creo que esta es la solución)

el objetivo es restar 1 de todas las filas que tienen un valor de 1 en una columna específica.

Gracias por cualquier ayuda / sugerencia.

preguntado el 01 de febrero de 12 a las 22:02

1 Respuestas

Usando las implementaciones de la biblioteca, esto se puede acelerar ligeramente. El uso de colecciones personalizadas pueden hacer esto más rápido aún, pero eso está fuera de alcance aquí. usted son en contra de ciertas restricciones de iteración, por lo que hay mucho que puede hacer en cualquier caso.

Será útil dividir el procedimiento en métodos más pequeños:

public static void decrementColumns(List<List<Integer>> rows, List<Boolean> mask) {
    final List<Integer> maskIndicies = getMaskIndicies(mask);
    // We're locked into this iteration because we have to modify every row.
    for (List<Integer> row : rows) {
        apply(maskIndicies, row);
    }
}

// Your big savings will come from figuring out the indicies.
// This allows us to make the iterations-per-row smaller - 
//   assuming not every row (or even most) is set to 'true'!
public static List<Integer> getMaskIndicies(List<Boolean> mask) {
    final List<Integer> maskIndicies = new ArrayList<Integer>(mask.size());
    for (int i = 0; i < mask.size(); i++) {
        if (mask.get(i)) {
            maskIndicies.add(i);
        }
    } 
}

public static void apply(List<Integer> maskIndicies, List<Integer> row) {
    // We're locked into this iteration, needing to apply the transformation
    // to every column included.
    for (Integer index : maskIndicies) {
        final Integer modified = row.get(index) - 1;
        row.set(index, modified);
    }
}

Tenga en cuenta que esto es NO seguro para subprocesos, así que ten cuidado. Tampoco escribí ningún control de seguridad, así que ...


EDIT:

Al releer la pregunta, me di cuenta de que inicialmente leí mal lo que estaba haciendo el código (y me estoy pateando, de alguna manera se me cayó un bucle).

La versión revisada:

public static void decrementColumns(List<List<Integer>> rows, List<Boolean> mask) {
    final int count = getMaskCount(mask);
    // We're locked into this iteration because we have to modify every row.
    for (List<Integer> row : rows) {
        apply(row, count);
    }
}

public static void int getMaskCount(List<Boolean> mask) {
    int count = 0;
    for(Boolean flag : mask) {
        if (!flag) {
            count++;
        }
    }
    return count;
}

public static void apply(List<Integer> row, int count) {
    for (int index = 0; index < row.size(); index++) {
        final Integer modified = row.get(index) - count;
        row.set(index, modified);
    }
}

Tenga en cuenta que este posible no está haciendo ~ exactamente ~ lo que hace su código original, solo lo que supongo que está intentando hacer, dado su texto de 'requisitos'. Por un lado, define al menos 2 lista adicional, para la que no da las relaciones, una de las cuales estoy bastante seguro es un error tipográfico. Si edita su pregunta para mayor claridad, es posible que pueda proporcionar una mejor respuesta; hay algunas cosas ambiguas o contradictorias entre su código y el texto de su pregunta. Tenga en cuenta que mientras su código original se ejecuta en O(m * (n ^ 2)), el mínimo (y mi versión) se ejecuta en O(n + (m * n)).

Respondido 02 Feb 12, 21:02

¿Alguna sugerencia sobre cómo hacer esto a mi manera (es decir, sin acelerar un poco)? Realmente quiero entender la lógica de esto. - Dax Duisado

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.