leetcode 12 30

12 30

381. El número de diccionarios ordenados medio

tema

La esencia del tema

Primero recorre el árbol decimal de la siguiente manera

El primer código menos perfecto

class Solution {
    
    
    public List<Integer> lexicalOrder(int n) {
    
    
         List<Integer> nums=new ArrayList<Integer>();
		 dfs(nums, 0, n);
		 for(int i=0;i<nums.size();i++)
		 {
    
    
			 System.out.println(nums.get(i));
		 }
		 return nums;
    }

    public static void dfs(List<Integer> nums,int num,int n)
	{
    
    
		if(num>n)
		{
    
    
			return;
		}
		for(int j=0;j<=9;j++)
		{
    
    
			num=num*10+j;
			if(num==0)
				continue;
			if(num>n)
				break;
			nums.add(num);
			dfs(nums, num, n);
			num=(num-j)/10; 
			
		}
		return;
	}

Análisis imperfecto:
1. Se encuentra principalmente en la operación de escritura variable, lo que provoca un gran consumo de tiempo
2. El parámetro del método transfiere la lista en el medio, lo que provoca un gran consumo de tiempo
3. Después de la prueba, los dos aspectos son las principales razones, lo que resulta en un tiempo superior a 200 ms, normal 5- 7 ms

El segundo código más completo

class Solution {
    
    
     List<Integer> nums=new ArrayList<Integer>();
	 public  List<Integer> lexicalOrder(int n) {
    
    
		 
		 dfs( 0, n,0);
		 return nums;
	 }
	public void dfs(int num,int n,int step)
	{
    
    
		if(num>n)
		{
    
    
			return;
		}
		if(num>0)
		{
    
    
			nums.add(num);
		}
		for(int i=step>0?0:1;i<=9;i++)
		{
    
    
			dfs( num*10+i, n, step+1);
		}
	}
}

Plan de mejora
1. Para la escritura diferida de variables, use el parámetro de método para operar la variable, de modo que cuando regrese al nodo anterior, recupere automáticamente
2. Para el parámetro de lista pasado, cambie el método dfs por el método de instancia y cree la lista de variables globales de instancia.

Preguntas de la entrevista 05.01. Fácil de insertar

tema

La esencia del tema

Para enteros sin signo, existen como códigos originales en máquinas de 32 bits. Los bits superpuestos de N y M se reemplazan por M.

Código

class Solution {
    
    
     public  int insertBits(int N, int M, int i, int j) {
    
    
		 	char[] s1=to2array(N);
		 	char[] s2=to2array(M);
		 	int u=0;
		 	for(int q=i;q<=j;q++)
		 	{
    
    
		 		s1[q]=s2[u];
		 		u++;
		 	}
		 	int n=toten(s1);
		 	return n;
		 	
	    }
	public static int toten(char[] q)
	{
    
    
		int n=0;
		int l=1;
		for(int i=0;i<32;i++)
		{
    
    
			if(i!=0)
				l=l*2;
			if(q[i]=='0')
			{
    
    
				
				continue;
			}
			int j=q[i]-'0';
		
			n=n+l*j;
			
		}
		return n;
	}
	public static char[] to2array(int m)
	{
    
    
		char[] t= new char[32];
	 	int n=m;
	 	int i=0;
	 	for(int j=0;j<32;j++)
	 	{
    
    
	 		t[j]='0';
	 	}
	 	while(n!=0)
	 	{
    
    	
	 		char l=(char) (n%2+'0');
	 		n=n/2;
	 		t[i]=l;
	 		i++;
	 	}
	 	return t;
	}
	
}

Análisis:
1. to2array () convierte un número decimal en una matriz binaria de caracteres con una longitud de 32, usando la extensión cero
2 toten () es una matriz de caracteres con una longitud de 32 para convertir a un número decimal
consejos:
'0' significa El carácter 0, cuando participa en la operación, se convierte automáticamente al tipo int, que es el código asscci, si el número involucrado en la operación sigue siendo 0, se requiere -'0 '. De la misma manera, si desea convertir 0 en un carácter, debe agregar + '0', e int se convertirá automáticamente a char

1220 Dificultad para contar el número de secuencias de vocales

tema:

El primer código menos perfecto:

Análisis:
Usando programación dinámica, map [n] [i] representa el número de cadenas de caracteres que terminan con la letra correspondiente a la enésima posición (n ... 1) e i.
Ecuación de transición de estado:
map [i] [1] + = map [i +1] [0]; // a solo puede ser seguido por e
map [i] [0] + = map [i + 1] [1]; // e solo puede ser seguido por a o i
map [i] [2 ] + = mapa [i + 1] [1];
mapa [i] [0] + = mapa [i + 1] [2]; // i no puede ser seguido por otro i
mapa [i] [1] + = mapa [i + 1] [2];
mapa [i] [3] + = mapa [i + 1] [2];
mapa [i] [4] + = mapa [i + 1] [2];
mapa [ i] [2] + = mapa [i + 1] [3]; // o solo puede ir seguido de "i" o "u"
mapa [i] [4] + = mapa [i + 1] [3];
map [i] [0] + = map [i + 1] [4]; // u solo puede ir seguido de un

class Solution {
    
    
   public  int countVowelPermutation(int n) {
    
    
       long[][] map=new long[n][5];
        //'a', 'e', 'i', 'o', 'u'对应的字母
       //  0    1    2    3    4
       int mod = 1000000007;
       for(int j=0;j<5;j++)
   		{
    
    
  
   			map[n-1][j]=1;
   		
   		}
        for(int i=n-2;i>=0;i--)
        {
    
    
    		map[i][1]+=map[i+1][0];//a后面只能跟e
    		map[i][0]+=map[i+1][1];//e后面只能跟a或者i
    		map[i][2]+=map[i+1][1];
    		map[i][0]+=map[i+1][2];//i后面不能跟着另一个i
    		map[i][1]+=map[i+1][2];
    		map[i][3]+=map[i+1][2];
    		map[i][4]+=map[i+1][2];
    		map[i][2]+=map[i+1][3];//o后面只能跟着“i”或者“u”
    		map[i][4]+=map[i+1][3];
    		map[i][0]+=map[i+1][4];//u后面只能跟着a
    		for(int j=0;j<5;j++)
            {
    
    
            	map[i][j]=map[i][j]%mod;
            }
        }
        long y=0;
        for(int i=0;i<5;i++)
        {
    
    
        	y+=map[0][i];
        }
        int result=(int)(y%mod);
        return result;
   }
	
}

Imperfecciones:
1. El mapa [] [] accede a demasiados estados, de hecho, solo se necesita el estado de nivel superior, no todo el almacenamiento.
2. El resultado intermedio módulo 10 elevado a la novena potencia +7 utiliza long para guardar la precisión, pero todos los resultados intermedios deben ser división módulo

El segundo código más completo:

Análisis:
1. Utilice una capa de variables y una capa de variables locales para actualizar

class Solution {
    
    
   public  int countVowelPermutation(int n) {
    
    
       long a=1,e=1,i=1,o=1,u=1;
        //特定字母之后能排的字母
		//a  e
		//e  ai
		//i  aeou
		//o  iu
		//u  a
		
		//反推出特定字母之前能排的字母
		//eiu     a
		//ai      e
		//eo      i
		//i       o
		//io      u
		int mod=1000000007;
		for(int q=0;q<n-1;q++)
		{
    
    
			long a_tmp=(e+i+u)%mod;
			long e_tmp=(a+i)%mod;
			long i_tmp=(e+o)%mod;
			long o_tmp=i;
			long u_tmp=(i+o)%mod;
			
			a=a_tmp;
			e=e_tmp;
			i=i_tmp;
			o=o_tmp;
			u=u_tmp;
		}
		return  (int)((a+e+i+o+u)%mod);
   }
	
}