Description du titre
Donnez-vous un tableau nums contenant n entiers, et jugez s'il y a trois éléments a, b, c en nombres tels que a + b + c = 0? Veuillez trouver tous les triplets qui remplissent les conditions et qui ne sont pas répétés.
Remarque: la réponse ne peut pas contenir des triplets répétés.
Exemple: étant
donné le tableau nums = [-1, 0, 1, 2, -1, -4], l'
ensemble de triplets qui répond aux exigences est:
[
[-1, 0, 1],
[-1, -1 , 2]
]
Idée:
Commencez par trier le tableau,
créez une liste pour stocker
un nombre num [i] dans le tableau fixe de résultat , puis utilisez un double pointeur pour pointer vers les extrémités gauche et droite du nombre (nums [gauche], nums [droite ]), et calculez le nombre Et la somme des nombres pointés par les deux pointeurs. S'il est égal à 0, il est ajouté au jeu de résultats.
Si num [i] est supérieur à 0, les nombres suivants sont supérieurs à 0, et la somme des trois nombres ne doit pas être 0, et la boucle se termine;
si num [i] == num [i-1], le nombre est répété et ignoré;
Si somme est 0, ajouter au jeu de résultats, si nums [gauche] = nums [gauche + 1], le résultat sera répété, gauche ++; si nums [droite] = nums [droite-1] , le résultat sera répété, à droite–;
code:
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
Arrays.sort(nums);
List<List<Integer>> res = new ArrayList<>();
for(int i = 0;i<nums.length-2;i++){
int left = i+1;
int right = nums.length - 1;
if(nums[i] >0){
return res;
}
if(i > 0 && nums[i] == nums[i-1]){
continue;
}
while(left < right){
int sum = nums[i]+nums[left]+nums[right];
if(sum == 0){
res.add(Arrays.asList(new Integer[]{
nums[i],nums[left],nums[right]}));
while(left <right && nums[left] == nums[left+1]){
left++;
}
while(left <right && nums[right] == nums[right-1]){
right--;
}
left++;
right--;
}else if (sum < 0){
left++;
}else{
right--;
}
}
}
return res;
}
}
La somme la plus proche de trois nombres
description du problème
Étant donné un tableau nums comprenant n entiers et une cible de valeur cible. Trouvez les trois entiers en nombres afin que leur somme soit la plus proche de la cible. Renvoie la somme de ces trois nombres. Supposons qu'il n'y ait qu'une seule réponse pour chaque ensemble d'entrées.
Entrée: nums = [-1,2,1, -4], target = 1
Sortie: 2
Explication: La somme la plus proche de la cible est 2 (-1 + 2 + 1 = 2).
L'idée est fondamentalement la même que celle de la question précédente. Vous
devez ajouter une variable diff pour enregistrer la différence entre la somme de trois nombres et la cible, et la variable closeSum enregistre la somme la plus proche de trois nombres.
Il n'est pas nécessaire de juger de la relation de taille entre nums [gauche] et nums [gauche + 1], nums [droite] et nums [droite-1] (la question précédente n'est pas répétable)
si la somme actuelle de trois nombres est plus que la différence de la cible Si la différence est petite, mettez à jour la valeur de la différence et mettez également à jour la valeur closeSum.
Si la somme actuelle de trois nombres est inférieure à la cible, alors left ++, augmentant la somme.
Si la somme actuelle de trois nombres est plus grand que la cible, puis à droite -, ce qui rend la somme plus petite
Code:
class Solution {
public int threeSumClosest(int[] nums, int target) {
Arrays.sort(nums);
int diff = Integer.MAX_VALUE;
int closeSum = 0;
for(int i = 0;i<nums.length-2;i++){
int left = i+1;
int right = nums.length-1;
int sum = 0;
int tempdiff = 0;
while(left < right){
sum = nums[i] + nums[left] + nums[right];
tempdiff = Math.abs(sum-target);
if(tempdiff < diff){
closeSum = sum;
diff = tempdiff;
}
if(sum < target){
left++;
}else if (sum > target){
right--;
}else{
return closeSum;
}
}
}
return closeSum;
}
}