[Pergunta do pincel de algoritmo] O recipiente que contém mais água

Problema: 11. O recipiente que contém mais água

linha de raciocínio

No começo, eu só pensava em violência, e a ideia era parecida com a ideia do palíndromo mais longo da string existente, localizando as marcas de início e fim de uma string.
Mas depois de enviá-lo, descobri que o tempo expirou. O principal motivo é que as condições de restrição são difíceis de escrever, portanto, ponteiros duplos devem ser considerados para otimização.

método de resolução de problemas

Em cada estado, não importa se a prancha longa ou a prancha curta é estreitada para o meio, a largura da borda inferior do tanque será reduzida em −1-1−1​:
Se a pranchinha for movida para dentro, o prancha curta do tanque será min(h[ i],h[j])min(h[i], h[j])min(h[i],h[j]) pode se tornar maior, então a área da próxima pia pode aumentar.
Se a prancha longa for movida para dentro, a prancha curta do tanque min(h[i],h[j])min(h[i], h[j])min(h[i],h[j]) Permanece inalterado Ou fica menor, então a área da próxima pia deve ficar menor.
Portanto, inicialize os dois ponteiros para organizar as extremidades esquerda e direita do tanque de água, mova a pranchinha para dentro em um quadro a cada ciclo e atualize a área máxima até que os dois ponteiros se encontrem e saltem; a área máxima pode ser obtida.

a complexidade

• Complexidade de tempo:

Adicionar complexidade de tempo, exemplo: $O\left(N\right)$

• Complexidade do espaço:

Adicione a complexidade do espaço, exemplo: $O\left(1\right)$

Código

class Solution:
    def maxArea(self, height: List[int]) -> int:
        start = 0 
        end = len(height) - 1
        res = 0

        while start < end:
            if height[start] < height[end]:
                res = max(res,height[start] * (end-start))
                start = start + 1
            else:
                res = max(res,height[end] * (end-start))
                end = end - 1
        return res 

Mas no início, o envio era feito com a ideia do palíndromo mais longo da string, e o timeout sempre era informado, mas não é difícil de implementar.

Código (sem otimização)

	class Solution:
    def maxArea(self, height: List[int]) -> int:
        max_vol = 0
        flag_start = 0

        start_index = 0
        while start_index < len(height):
            if height[start_index] < height[flag_start]:
                pass
            else:
                for i in range(start_index+1,len(height))[::-1]:
                    wid_ = i - start_index
                    hei_ = min(height[i],height[start_index])
                    vol = wid_ * hei_
                    if vol > max_vol:
                        max_vol = vol
                        flag_start = start_index

            start_index = start_index + 1
        return max_vol