Comment implémenter un tableau non décroissant en Java

# 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 # Titre Description # 🎜🎜 ## 🎜🎜 ## 🎜🎜 ## 🎜🎜 # Étant donné un tableau contenant n entiers, votre tâche est de vérifier s'il peut devenir non descendant en modifiant au plus un élément. Un tableau non descendant satisfait array[i-1]<=array[i] pour tout i (1<=i

Échantillon 1 :

ⅰ Entrée : [4,2,3]

ⅱ Sortie : Vrai # 🎜🎜#

ⅲ Remarque : Vous pouvez changer le premier chiffre 4 en 1 pour obtenir [1,2,3] sous forme de tableau non décroissant

Exemple 2 : # 🎜🎜#

ⅰ Entrée : [4,2,1]ⅱ Sortie : False

ⅲ Description : Impossible de modifier au plus un L'élément rend le tableau non descendant.

Analyse des idées de résolution de problèmes

a

Pensée simple. peut Obtenu, il n'y a que trois situations : celles qui remplissent les conditions sans modification, celles qui peuvent satisfaire les conditions en modifiant un élément, et celles qui ne peuvent pas satisfaire les conditions même si un élément est modifié. Dans le premier cas, parcourez simplement le tableau pour voir si chaque élément du tableau est supérieur ou égal à l'élément précédent. Si tel est le cas, renvoyez vrai. Pour le deuxième cas, vous pouvez énumérer le nombre tableau[i] à modifier, puis vérifier si le nombre avant le tableau[i] n'est pas décroissant, et si le nombre après le tableau[i] n'est pas décroissant, #🎜 🎜# Enfin, vous devez également vérifier si

array[i-1]<=array[i+1]

est vrai

(si array[ i] est situé à la limite, alors pas besoin de vérifier), si c'est vrai, vous pouvez remplacer array[i] par n'importe quel nombre entre array[i-1] et array[i+1] pour faire du tableau un non- tableau descendant. C'est le cas 2. Renvoie vrai si ce n'est pas vrai pour tous les i, alors c'est le cas trois et faux est renvoyé. La complexité temporelle de cette opération est O(n^2) et la complexité spatiale supplémentaire est O(1).

b.

Quelles conditions peut-on remplir pour transformer un nombre en tableau non décroissant après l'avoir modifié ? Évidemment, un tel tableau doit satisfaire à la condition selon laquelle il n'existe qu'une seule paire de nombres adjacents qui ne satisfait pas à la condition de non-déclin, c'est-à-dire qu'il n'y a qu'un seul i unique (1<=iarray[i], on peut affirmer que s'il existe plusieurs de ces i, le tableau d'origine ne peut pas devenir un tableau non descendant en modifiant au plus un nombre. Alors, tout tableau qui remplit cette condition peut-il satisfaire au non-déclin en modifiant un nombre ? Non, par exemple [2,4,1,3], seul le 4,1 adjacent ne satisfait pas au non décroissant, mais il ne peut pas devenir non décroissant en changeant un seul nombre. En fait, s'il n'y a qu'un seul i qui satisfait array[i-1]>array[i], alors le nombre à modifier doit être parmi les deux nombres array[i-1] et array[i], alors vous peut appliquer l’approche précédente et porter des jugements séparés sur les deux situations. De plus, puisque array[i-1]>array[i] n'est vrai que pour i, tous les autres nombres adjacents satisfont à la condition non décroissante, donc pour array[i-1] on dit que les tableaux avant et après remplissent respectivement les conditions non descendantes, et il en va de même pour array[i]. Par conséquent, il vous suffit de juger si les deux tableaux avant et après peuvent être connectés en un tableau non descendant. Plus précisément, si le nombre à modifier est array[i-1], il vous suffit alors de juger si array[i-2]<=array[i] est vrai. De même, si vous souhaitez modifier array[i]. , alors vous devez juger si array[i-1]<=array[i+1] est vrai. Bien sûr, c'est vrai si array[i-1] ou array[i] est situé sur la limite. Pour résumer cet algorithme : comptez le nombre de positions adjacentes qui ne satisfont pas au non-déclin. Si le nombre est 0, renvoie vrai (pas besoin de modifier). Si le nombre est supérieur à 1, renvoie faux. Sinon, un jugement supplémentaire doit être effectué. : Supposons que non La position qui satisfait le non-déclin est i, array[i-1]>array[i], et les conditions pour finalement renvoyer vrai sont array[i-1], array[i] est la limite, ou tableau[i-2]< =tableau[i] ou tableau[i-1]<=tableau[i+1]. La complexité temporelle est O(n) et la complexité spatiale supplémentaire est O(1).

Programme de référenceVersion Java : # 🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!