Cuenta pública original:
bigsaisi es buena, ¡recuerda darle me gusta y cobrar!
Siga y responda a bigsai para recibir recursos avanzados en PDF de Java, y responda al grupo para unirse al grupo de punch de Likou .
Contenido de registro la semana pasada : multiplicación de 43 cuerdas y 44 combinación de comodines 45 juego de saltos y 46 arreglo completo
Contenido de registro de ayer : LeetCode 47 arreglo completo Ⅱ y 48 imágenes giratorias
Agrupación disfórica de letras
Dada una serie de cadenas, combine la letra dislexia. Las palabras alifáticas se refieren a cadenas con las mismas letras pero con diferentes disposiciones.
示例:
输入: ["eat", "tea", "tan", "ate", "nat", "bat"]
输出:
[
["ate","eat","tea"],
["nat","tan"],
["bat"]
]
Descripción:
Todas las entradas están en minúsculas.
No se considera el orden en el que se emiten las respuestas.
análisis
El significado del título es dar varias palabras de cadena y luego poner todas las mismas letras en una List<String>. Nuestra pregunta central es ¿dónde poner esto?
Puede usar la enumeración de fuerza bruta para juzgar cada vez, pero eso es demasiado ineficiente, por lo que podemos usar el almacenamiento de hash . Crea un Map<String,List<String>>tipo de HashMap para almacenamiento.
El código de implementación es:
public List<List<String>> groupAnagrams(String[] strs) {
List<List<String>>lists=new ArrayList<>();
Map<String,List<String>>map=new HashMap<>();
for(String str: strs)
{
char vachar[]=str.toCharArray();
Arrays.sort(vachar);
String team=String.copyValueOf(vachar);
List<String>list=map.getOrDefault(team,new ArrayList<>());
list.add(str);
map.put(team,list);
}
// for(List<String> list:map.values())
// {
// lists.add(list);
// }
lists.addAll(map.values());
return lists;
}
Resultados del:
Pow (x, n)
Obviamente, un algoritmo de exponenciación rápido, recomiendo encarecidamente mi propia introducción de exponenciación rápida: estructura de datos y algoritmo; esta puede ser la explicación de exponenciación rápida más fácil,
pero debe prestar atención a algunos puntos:
- El procesamiento de números negativos y el número negativo pueden ser el valor mínimo de int más un valor de conversión de signo fuera de límites . Por lo tanto, cuando un número negativo se convierte en un número positivo, la potencia negativa se puede convertir en una potencia positiva para el cálculo. Por ejemplo, 5 -2147483648 = 5 -1 x 5 -2147483647 = (1/5) x (1/5) 2147483647 . El intervalo int es [-2147483648,2147483647].
- Preste atención a la condición de parada. En teoría, puede reescribir una función para optimizarla ligeramente, pero debido a que la complejidad del nivel de registro de potencia rápido es relativamente baja, no la optimizaré y escribiré directamente:
public double myPow(double x, int n) {
if(n<0)
return (1.0/x)*myPow(1.0/x,-(n+1));
if(n==0)
return 1;
else if(n%2==0)
return myPow(x*x,n/2);
else
return x*myPow(x*x,n/2);
}
Reina N
El problema de las n reinas estudia cómo colocar n reinas en un tablero de ajedrez de n × n y hacer que las reinas no puedan atacarse entre sí.
La imagen de arriba muestra una solución al problema de las 8 reinas.
Dado un número entero n, devuelve soluciones a todos los diferentes problemas de n reinas.
Cada solución contiene un plan claro de colocación de peones para el problema de n-damas, en el que 'Q' y '.' Representan la dama y la posición vacía respectivamente.
Ejemplo:
输入：4
输出：[
[".Q..", // 解法 1
"...Q",
"Q...",
"..Q."],
["..Q.", // 解法 2
"Q...",
"...Q",
".Q.."]
]
解释: 4 皇后问题存在两个不同的解法。
Consejo: las
reinas no pueden atacarse entre sí, es decir: no puede haber dos reinas en la misma línea horizontal, vertical o diagonal.
Leeré este artículo sobre el problema de las ocho reinas: algoritmo de retroceso | Recordando el problema de las ocho reinas que nos ha desconcertado en esos años . Ya está muy claro. Si no lo entiendes, puedes mirarlo en detalle.
En la implementación específica, se necesita un map[][]mapa para registrar los símbolos de cada ubicación, y luego se almacena de acuerdo con las reglas, pero aquí uso una StringBuilder[]matriz para completar.
Además, al juzgar la dirección línea por línea, no es necesario juzgar la dirección horizontal.
Adjunta el código:
// boolean heng[];
boolean shu[];
boolean zuoxie[];
boolean youxie[];
public List<List<String>> solveNQueens(int n) {
List<List<String>> list=new ArrayList<List<String>>();
StringBuilder stringBuilder[]=new StringBuilder[n];
for(int i=0;i<n;i++)
{
stringBuilder[i]=new StringBuilder();
for(int j=0;j<n;j++)
{
stringBuilder[i].append('.');
}
}
shu=new boolean[n];
zuoxie=new boolean[n*2];
youxie=new boolean[n*2];
dfs(0,stringBuilder,list,n);
return list;
}
private void dfs(int index, StringBuilder sBuilder[], List<List<String>> list,int n) {
// TODO Auto-generated method stub
if(index==n)//存入
{
List<String>val=new ArrayList<String>();
//StringBuilder sBuilder=new StringBuilder();
for(int i=0;i<n;i++)
{
val.add(sBuilder[i].toString());
}
list.add(val);
}
else {
for(int j=0;j<n;j++)
{
if(!shu[j]&&!zuoxie[index+j]&&!youxie[index+(n-1-j)])
{
shu[j]=true;
zuoxie[index+j]=true;
youxie[index+(n-1-j)]=true;
//map[index][j]='Q';
sBuilder[index].setCharAt(j, 'Q');
dfs(index+1,sBuilder, list, n);
shu[j]=false;
zuoxie[index+j]=false;
youxie[index+(n-1-j)]=false;
sBuilder[index].setCharAt(j, '.');
//map[index][j]='.';
}
}
}
}
Siempre familiar 100%:
Conclusión: Muy bien, estamos aquí hoy, bienvenidos a prestar atención a la cuenta pública de tecnología original: [ bigsai ], responda al grupo y agregue el WeChat del autor para unirse al registro. Responda a " bigsai " para recibir recursos avanzados.
