2021 Vivo School recluta la aprobación anticipada del análisis del examen escrito
El título no se puede escribir por completo. Vivo pondrá el título en Niuke después de una inspección visual. Aquí hay un análisis.
1. El problema de plantar flores
Acabo de descubrir que eran 605 preguntas en Leetcode
假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花？能则返回True，不能则返回False。
示例 1:
输入: flowerbed = [1,0,0,0,1], n = 1
输出: True
示例 2:
输入: flowerbed = [1,0,0,0,1], n = 2
输出: False
注意:
数组内已种好的花不会违反种植规则。
输入的数组长度范围为 [1, 20000]。
n 是非负整数，且不会超过输入数组的大小。
Al principio pensé que era un problema de programación dinámica, que perdía mucho tiempo, pero luego descubrí que era un problema para encontrar un patrón.
Ideas de resolución de problemas:
Caso 1: excluir el punto final
Excluyendo los puntos finales, asumimos que el área donde se pueden plantar flores está rodeada de flores, es decir, el 0 continuo en el medio está rodeado por 1.
En la siguiente situación, obviamente es imposible cultivar flores.
1 0 0 1 ；
Y esta situación:
1 0 0 0 1 Lata plantar 1 flor
1 0 0 0 0 1 Lata plantar 1 flor
1 0 0 0 0 0 1 Lata plantar 2 flores
1 0 0 0 0 0 0 1 Lata plantar 2 flores
1 0 0 0 0 0 0 0 1 puedo plantar 3 flores
1 0 0 0 0 0 0 0 0 1 puedo plantar 3 flores
No es difícil encontrar que cada dos ceros, habrá muchas oportunidades para una flor.
La fórmula es muy fácil de calcular, cuando hay n ceros en el medio, puedes plantar (n-1) / 2 flores
Caso 2: considere el punto final
Cuando un cierto punto final es 0, podemos
plantar una variedad de flores 1 0 0 puede plantar 1 flor
1 0 0 0 puede plantar 1 flor
1 0 0 0 0 puede plantar 2 flores
1 0 0 0 0 0 puede plantar 2 flores
1 0 0 0 0 0 0 Se pueden plantar 3 flores
1 0 0 0 0 0 0 0 Se pueden plantar 3 flores
Situación 3: el tamaño del jardín es solo 1
Cuando el tamaño del jardín es 1, no podemos obtener un intervalo, solo tenemos un punto y tenemos que lidiar con esta situación especialmente
En resumen, podemos obtener el siguiente código
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int len=in.nextInt();
int plant[]=new int[len];
int curr=0;
while (curr<len){
plant[curr++]=in.nextInt();
}
slove(plant);
}
private static void slove(int nums[]){
if(nums.length==1){
int x=nums[0]==0?1:0;
System.out.println(x);
return;
}
int slow=0;//0
int quick=0;//1
int count=0;
while (slow<nums.length&&quick<nums.length){
while (slow<nums.length&&nums[slow]==1){
slow++;
}
quick=slow;
while (quick<nums.length&&nums[quick]==0){
quick++;
}
if(quick-slow>=3){
count+=counter(quick-slow);
}
//考虑端节点
if((slow==0||quick==nums.length)&&(quick-slow>=2)){
count++;
}
slow=quick;
}
System.out.println(count);
}
//计算两个空白字符之间的
private static int counter(int sub){
return (sub-1)/2;
}
2. Prueba de calidad
El punto principal de la pregunta es dejar caer el teléfono y dejar caer la prueba para probar la calidad del teléfono.
No diré mucho sobre esta pregunta, una pregunta clásica de Leetcode: Leetcode-887
3. Fusionar la canalización
La idea principal del tema:
Entrada: n significa que hay varias canalizaciones.
Salida: Organizada en orden ascendente, la canalización combinada
Muy simple, es un problema de clasificación. Sin embargo, se requiere una lista vinculada en este tema. Y queda una función estática en el código fuente para fusionar la lista vinculada recién ingresada.
Idea de resolución de problemas: use un pequeño montón superior para fusionar varias canalizaciones de entrada, luego sáquelas y combínelas en una sola canalización. Luego, en la función de combinación, vuelva a combinar las dos listas vinculadas e insértelas a medida que lleguen
public class Main {
private static ListNode dummyNode=new ListNode(-1);
private static ListNode currNode=dummyNode;
public static void main(String[] args) {
currNode=dummyNode;
List<String> lines = new ArrayList<>();
Scanner scanner = null;
try {
scanner = new Scanner(System.in);
int totalLine=Integer.valueOf(scanner.nextLine());
while (totalLine>0) {
lines.add(scanner.nextLine());
totalLine--;
// write your code here
}
PriorityQueue<Integer> queue=new PriorityQueue<>();
for (int i=0;i<lines.size();i++){
String[] nums=lines.get(i).split(" ");
for(String num:nums){
queue.offer(Integer.valueOf(num));
}
}
while (queue.isEmpty()==false){
currNode.next=new ListNode(queue.poll());
currNode=currNode.next;
}
} finally {
if (scanner != null) {
scanner.close();
}
}
// TODO output
ListNode curr=dummyNode.next;
while (curr!=null){
if(curr.next==null){
System.out.print(curr.val);
}else {
System.out.print(curr.val+" ");
}
curr=curr.next;
}
}
static class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
}
}
private static ListNode mergeNodes(ListNode head ) {
dummyNode=merge(dummyNode.next,head);
return dummyNode.next;
}
private static ListNode merge(ListNode n1,ListNode n2){
if(n1==null||n2==null){
return n1==null?n2:n1;
}
ListNode newDummy=new ListNode(-1);
ListNode curr=newDummy;
while(n1!=null&&n2!=null){
int val=n1.val;
if(n1.val>n2.val){
val=n2.val;
n2=n2.next;
}else {
n1=n1.next;
}
curr.next=new ListNode(val);
curr=curr.next;
}
curr.next=n1==null?n2:n1;
return newDummy.next;
}
}
Hay muchos códigos en los temas dados por vivo, así que escribo más aquí.