Buenas, continuando con el algoritmo uno de los apartados con respecto al código anterior me pide que lo modifique para devolver por consola la matriz con la primera baldosa que se coloque en ella definido con las siguientes variables :
Citar
int n =4; int [] tilesSize ={1, 2, 5}
donde int n=4 es el tamaño de del suelo en metros cuadrados y tilesSize los tamaños de las baldosas. El codigo que he modificado comparado con el anterios es el siguiente:
Código:
public class ResultadoBaldosasModificado {
public static void main(String[] args) { Scanner scan = new Scanner(System.in); int baldosas[] = {1, 2 ,5}; int solar = 4; int nBaldosas = 3; }
algoritmoVoraz(baldosas, solar);
}
/** * Algoritmo voraz. * * @param tamBaldosas the tam baldosas * @param metros the metros */ private static void algoritmoVoraz (int[] tamBaldosas, int metros){
int actual, size; int side = metros; actual = baldosas.length-1; size = baldosas[actual]; int []puestas= new int[baldosas.length]; for(int i = 0; i < side; i++) { for(int j = 0; j < side; j++) { while(solucion[i][j]==0 && actual >=0) { size=baldosas[actual]; if(cabe(size, i, j, solucion, side)) { for(int fila = i; fila < i + size; fila++) { for(int col = j; col <j + size; col++) { solucion[fila][col] = size;
} } puestas[actual]++; }else { actual--; } } } }
System.out.println(); for(int k=0; k<solucion.length; k++) { for(int r=0; r<solucion.length; r++) { System.out.print(solucion[k][r]); } System.out.println(); } System.out.println("\nLas baldosas puestas son las siguientes: "); for(int s=0; s<baldosas.length; s++) { System.out.println("De tamaño "+baldosas[s]+" se han puesto "+puestas[s]+" baldosas.");
}
}
/** * Método para saber si cabe una baldosa en el espacio restante. * * @param size the size * @param r the r * @param c the c * @param solucion1 the solucion 1 * @param lado the lado * @return true, si cabe la baldosa */ private static boolean cabe (int size, int r, int c, int [][] solucion1, int lado){ boolean fits = r + size <= lado && c + size <= lado; if(fits){ for(int row = r; fits && row < r + size; row++){ for(int col = c; fits && col < c + size; col++){ if(solucion1[row][col] != 0) { fits = false; } } } } return fits; }
/** * Mergesort. * * @param array the array * @param left posicion del numero de la izquierda * @param right the right * @return el array de enteros ordenado */ private static int[] mergesort(int[] array, int left, int right){ if (left < right) { int mid = (left+right)/2; mergesort (array, left, mid); mergesort (array, mid + 1, right); merge (array, left, mid, right); } return array; }
/** * Merge. */ private static void merge (int [ ] a, int p, int q, int r) { int i = p, j = q+1, k = p; int [ ] temp = new int [r-p+1]; for (int l = p; l <= r; l++) { temp[l-p] = a[l]; } while (i <= q && j <= r) { if (temp[i-p] <= temp[j-p]) { a[k] = temp[i-p]; i++; } else { a[k] = temp[j-p]; j++; } k++; } if (j-1 == r){ while (i <= q) { a[k] = temp[i-p]; k++; i++; } } }
Buenas, tengo un problema con un código que estoy realizando en el que se me pide que haga las inversiones de un numero presente en una lista en una lista (El numero 1). De forma mas explicativa es que si se pide buscar las inversiones de 1 o de X, son del número "1" o del número "X" y el algoritmo tendrá que funcionar siempre igual, pero contando sólo el número de inversiones que se le realizan a dicho número. El algoritmo debe utilizar el método divide y vencerás. Contar inversiones me refiero donde ai y aj estén en diferentes mitades y devolver la suma de las cantidades. El código que he realizado me devuelve un resultado pero se que no es el correcto.
Código:
public class inversiones { /** * The main method. * * @param args the arguments * @throws IOException Signals that an I/O exception has occurred. */
public static void main(String[] args) throws IOException { Scanner leer = new Scanner(new File("C:\\\\Users\\\\Downloads\\\\InversionOf1.dat")); int nCases = leer.nextInt();
System.out.println("El número de inversiones que tiene el array dado es: " +ordenar(a, 0, a.length-1)); } /** * Merge. Método valido para ordenar el array. * * @param a2 array que queremos ordenar * @param a numero de la izquierda * @param middle la mitad entre el límite inferior y superior * @param b numero de la derecha * @return el número de inversiones acontecidas durante el recorrido del método */ private static int merge (double[] a2, int a, int middle, int b) { int cont=0; int i=0, j=0, k=a;
double[] left = Arrays.copyOfRange(a2, a, middle+1); double [] right = Arrays.copyOfRange(a2, middle+1, b+1);
/*Comparar antes del contador si el elemento que tenemos que sumar es uno o no, Si es uno que sume y si no que no sume*/ while(i<left.length && j<right.length) { if(left[i] <= right[j]) { a2[k++]=left[i++]; i++; }else { a2[k++]=right[j++]; if(a2[k++] == 1){ cont += (middle+1)-(a+j); //cont++; } //cont += (middle+1)-(a+i); j++; } a++; }
/** * Método para ordenar el array, recursivo. Parecido a MergeSort. * * @param a2 array a ordenar * @param min, limite inferior del array que queremos ordenar * @param max, limite superior del array que queremos ordenar * @return numero de inversiones necesarias para ordenar el array */ private static int ordenar(double[] a2, int min, int max) { int cont=0; int middle = (min+max)/2; if(min<max) { cont = ordenar (a2, min, middle); //ordenar la izquierda cont = cont + ordenar (a2, middle + 1, max); //ordenar la derecha cont = cont + merge (a2, min, middle, max); } return cont; }
}
No entiendo que es lo que podría estar mal. También adjunto una pequeña lista de numero como ejemplo de los datos donde hay que buscar las inversiones de 1:
Hola, tengo unas dudas sobre unas consultas que he realizado y la verdad no se si están bien como las he hecho, si alguien con conocimiento del tema me puede hechar una mano se lo agradecería y corregir como se hacen. He hecho un video para que podáis ver las relaciones y las tablas con sus datos. Las consultas son:
1. Cuadro de partidos completo de una edición SELECT idPartido FROM Partidos WHERE idPartido IN (SELECT numEdicion FROM Ediciones)
2. Resultado de su participación en las distintas ediciones de un torneo SELECT DIST numEdicion FROM Ediciones WHERE numEdicion IN (SELECT idTorneo FROM Torneos)
Y hay una tercera que no se como hacerla para nada. 3. Clasificación actual de todas las jugadoras contenidas en la BD, indicando sus puntos, el número de victorias en torneos y el número de finales disputadas.
Hola, les escribo para saber si alguien me puede ayudar con un código que tengo que hacer en java. El enunciado del problema consiste en: Necesitamos un solar/terreno con una superficie cuadrada de n metros cuadrados de lado. Para el solado podemos elegir diferentes baldosas cuadradas s0,s1,s2... metros de lado. Para reducir costes en la construcción pretendemos utilizar tan pocas baldosas como sea posible y por razones estéticas queremos usas baldosas enteras (aunque se mezclen los tamaños). El objetivo es implementar en java un código que resuelva el problema y que sea óptimo.
Adjunto el codigo que llevo realizado por ahora pero del cual no se cual es el problema por el que no puedo resolver el trabajo:
Código:
import java.util.Scanner;
/** * The Class BaldosasAV. * Clase que calcula mediante un algoritmo voraz la solución óptima para rellenar el suelo de un solar de dimensiones cuadradas * con baldosas también cuadradas de diferentes dimensiones. */
public class ProblemaBaldosas { /** * The main method. * * @param args the arguments */ public static void main(String[] args) { Scanner scan = new Scanner(System.in); int baldosas[]; System.out.println("Introduzca las dimensiones del solar (metros cuadrados): "); int solar = scan.nextInt(); System.out.println("Indique el número de baldosas diferentes: "); int nBaldosas = scan.nextInt(); baldosas = new int[nBaldosas];
System.out.println("Inserte los tamaños de las baldosas: "); for(int i = 0; i < nBaldosas; i++) { System.out.println((i+1) + ".-Inserte un tamaño: "); baldosas[i] = scan.nextInt(); } algoritmoVoraz(baldosas, solar); }
/** * Algoritmo voraz. * * @param tamBaldosas the tam baldosas * @param metros the metros */ private static void algoritmoVoraz (int[] tamBaldosas, int metros){
int actual, size; int side = metros; actual = baldosas.length-1; size = baldosas[actual]; int []puestas= new int[baldosas.length]; for(int i = 0; i < side; i++) { for(int j = 0; j < side; j++) { while(solucion[i][j]==0 && actual >=0) { size=baldosas[actual]; if(cabe(size, i, j, solucion, side)) { for(int fila = i; fila < i + size; fila++) { for(int col = j; col <j + size; col++) { solucion[fila][col] = size;
} } puestas[actual]++; }else { actual--; } } } }
System.out.println(); for(int k=0; k<solucion.length; k++) { for(int r=0; r<solucion.length; r++) { System.out.print(solucion[k][r]); } System.out.println(); } System.out.println("\nLas baldosas puestas son las siguientes: "); for(int s=0; s<baldosas.length; s++) { System.out.println("De tamaño "+baldosas[s]+" se han puesto "+puestas[s]+" baldosas."); }
}
/** * Método para saber si cabe una baldosa en el espacio restante. * * @param size the size * @param r the r * @param c the c * @param solucion1 the solucion 1 * @param lado the lado * @return true, si cabe la baldosa */ private static boolean cabe (int size, int r, int c, int [][] solucion1, int lado){ boolean fits = r + size <= lado && c + size <= lado; if(fits){ for(int row = r; fits && row < r + size; row++){ for(int col = c; fits && col < c + size; col++){ if(solucion1[row][col] != 0) { fits = false; } } } } return fits; }
/** * Mergesort. * * @param array the array * @param left posicion del numero de la izquierda * @param right the right * @return el array de enteros ordenado */ private static int[] mergesort(int[] array, int left, int right){ if (left < right) { int mid = (left+right)/2; mergesort (array, left, mid); mergesort (array, mid + 1, right); merge (array, left, mid, right); } return array; }
/** * Merge. * * @param a the a * @param p the p * @param q the q * @param r the r */ private static void merge (int [ ] a, int p, int q, int r) { int i = p, j = q+1, k = p; int [ ] temp = new int [r-p+1]; for (int l = p; l <= r; l++) { temp[l-p] = a[l]; } while (i <= q && j <= r) { if (temp[i-p] <= temp[j-p]) { a[k] = temp[i-p]; i++; } else { a[k] = temp[j-p]; j++; } k++; } if (j-1 == r){ while (i <= q) { a[k] = temp[i-p]; k++; i++; } } }
Mostrar Mensajes