Este será el primer problema que se resolverá en Java aquí.
Hace unos dos meses, ya había hecho este problema en C ++ durante el entrenamiento de verano. Recuerdo que cuando las vulnerabilidades fueron modificadas y parcheadas poco a poco, todo el código era completamente ilegible; luego, ajusté mi pensamiento y diseñé una solución en su conjunto.
Recuerdo la pregunta más impresionante en ese momento: (se puede simplificar a) ¿cómo asegurar que una cadena de números compuesta por 01 sea todo 0 o todo 1?
Hay dos esquemas: el primero es comparar continuamente si los bits i e i-1 son los mismos durante el proceso transversal, y el otro es comparar solo si los bits i-ésimo y 0-ésimo son iguales. Para este problema, la segunda solución es mucho más conveniente.
Esta pregunta probablemente signifique obtener una cuerda, abrirla en un lugar, qué tan lejos puede llegar al más profundo a la izquierda y qué tan lejos puede ir al más profundo a la derecha, devolver la suma de ellos; para diferentes lugares, compare el valor más grande. Cruzo todos los puntos en la parte de la función principal y comparo el máximo; uso una función para encontrar la profundidad total de cada lugar; y esta función llama a la función de profundidad izquierda y la función de profundidad derecha respectivamente (son solo ligeramente diferentes, aproximadamente en Dirección de movimiento y límite).
Hice una copia de neckLace y los conecté de la cabeza a la cola para solucionar el problema del bucle.
package brokenNecklace;
//双倍的项链接起来
//从第二位开始经过到一条完整项链加一位
//left和right
//延续性的判断
//开头w： 从第一个有效的开始
//开头rb： 记录下开头的情况
//经过w： 移动到下一个 计数+1
//经过rb 对比后再决定是否+1；
import java.util.Scanner;
public class Main {
static int n;
static String necklace;
static String doubleNecklace;
static int maxLen= 0;
public static void main(String[] args) {
Scanner console= new Scanner(System.in);
n = console.nextInt();
necklace = console.next();
doubleNecklace = necklace + necklace;
//System.out.println(doubleNecklace);
if(n==1) {
System.out.println(1);
}
for(int i=1; i< n; i++) {
//条件表达式
maxLen= length(i)>maxLen?length(i):maxLen;
}
if(maxLen>n)System.out.println((int)(maxLen*0.5));
else System.out.println(maxLen);
}
public static int length(int loca) {
int thisMax= 0;
int leftLen= 0;
int rightLen= 0;
leftLen= findDeptL(loca-1);
rightLen= findDeptR(loca);
thisMax= leftLen+rightLen;
return thisMax;
}
public static int findDeptL(int loca) {
int dept= 0;
char saveHead= 'A';
boolean hasHead= false;
//标记是否走到尽头
boolean lenSign= true;
//第一个白色；非白色 中间白色； 非白色； 记录下第一个非白色的；
while(lenSign == true) {
//System.out.println(loca + "LOCA");
if(loca==-1) break;
else if(doubleNecklace.charAt(loca) == 'w') {
loca = loca -1;
dept ++;
}
else if(hasHead== false) {
saveHead= doubleNecklace.charAt(loca);
loca= loca-1;
dept++;
hasHead= true;
}
else if(hasHead== true && doubleNecklace.charAt(loca)== saveHead ) {
loca= loca-1;
dept ++;
}
else if(doubleNecklace.charAt(loca)!= saveHead) {
break;
}
else {
System.out.println("ERROR");
}
}
return dept;
}
public static int findDeptR(int loca) {
int dept= 0;
char saveHead= 'A';
boolean hasHead= false;
//标记是否走到尽头
boolean lenSign= true;
//第一个白色；非白色 中间白色； 非白色； 记录下第一个非白色的；
while(lenSign == true) {
//System.out.println(loca);
if(loca==2*n) break;
if(doubleNecklace.charAt(loca) == 'w') {
if(loca==0) break;
loca = loca +1;
dept ++;
}
else if(hasHead== false) {
saveHead= doubleNecklace.charAt(loca);
loca= loca+1;
dept++;
hasHead= true;
}
else if(hasHead== true && doubleNecklace.charAt(loca)== saveHead ) {
loca= loca+1;
dept ++;
}
else if(doubleNecklace.charAt(loca)!= saveHead) {
break;
}
else {
System.out.println("ERROR");
}
}
return dept;
}
}
Para buscar profundidad, creo que lo más importante es distinguir entre diferentes situaciones; planeo dividir de esta manera, según el principio o el medio, y según el blanco o br;
así que al final me sale esta situación: el comienzo es blanco; el comienzo es br; el medio Es blanco, con br en el medio. Primero escribí un bucle while, pero luego descubrí que no funcionaba. (Lo siguiente está en el orden de if elseif)
Si el comienzo es blanco, entonces la profundidad es +1, y pasa al siguiente (de hecho, el blanco en el medio se maneja de la misma manera); tenga en cuenta que necesitamos registrar el color de la primera posición que no es blanco, porque así es como juzgamos si es continuo. Básicamente, necesitamos una variable para registrar si se ha obtenido la primera posición no blanca (¿hasHead?); Si no, registre el color; si lo hay, es la posición normal en el medio, y el color es consistente y continúa avanzando; Tenga en cuenta que la inconsistencia de color debe tener el color inicial, por lo que una vez que el color no sea el mismo, salga entre ellos; no estoy seguro al escribir, y use elseif para separar completamente todas las situaciones, y luego escriba else para ver si hay algo. Considerado.
public static int findDeptL(int loca) {
int dept= 0;
char saveHead= 'A';
boolean hasHead= false;
//标记是否走到尽头
boolean lenSign= true;
//第一个白色；非白色 中间白色； 非白色； 记录下第一个非白色的；
while(lenSign == true) {
//System.out.println(loca + "LOCA");
if(loca==-1) break;
else if(doubleNecklace.charAt(loca) == 'w') {
loca = loca -1;
dept ++;
}
else if(hasHead== false) {
saveHead= doubleNecklace.charAt(loca);
loca= loca-1;
dept++;
hasHead= true;
}
else if(hasHead== true && doubleNecklace.charAt(loca)== saveHead ) {
loca= loca-1;
dept ++;
}
else if(doubleNecklace.charAt(loca)!= saveHead) {
break;
}
else {
System.out.println("ERROR");
}
}
return dept;
}
Se completa así la función para encontrar la profundidad. Otro punto es muy interesante, porque el collar es un círculo, por lo que también debes considerar el lazo. Quiero agregar directamente un collar copiado a doublenNecklace después de la cadena del collar importado para resolver este problema: por ejemplo, si el collar es bbwwr, obtendré un bbwwrbbwwr y realizaré operaciones de análisis sobre esto. Tenga en cuenta que en este caso, la longitud del collar de color puro, como wwwww, bbbbb o wwwbb, será el doble de largo que n; pensé que sería algo muy problemático, pero lo encontré simple
if(maxLen>n)System.out.println((int)(maxLen*0.5));
else System.out.println(maxLen);
Simplemente evite valores de salida irrazonables.