1005. Maximize Sum Of Array After K Negations

LeetCode easy original: C# #array #csharp #easy #leetcode #sort

선택한 UI 언어에 맞게 문제 텍스트를 러시아어에서 번역합니다. 코드는 변경하지 않습니다.

LeetCode Static

given 정수 배열 nums и 정수 k, измените 배열 следующим образом: выберите индекс i и замените nums[i] на -nums[i]. Вы должны применить этот процесс ровно k раз. Вы можете выбрать один и тот же индекс i несколько раз. return наибольшую возможную сумму 배열а после его модификации таким образом.

예제:

Input: nums = [4,2,3], k = 1

Output: 5

C# 해법

매칭됨/원본

public class Solution {
    public int LargestSumAfterKNegations(int[] nums, int k) {
        Array.Sort(nums);
        
        for (int i = 0; i < nums.Length; i++) {
            if (k > 0 && nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            }
        }
        
        if (k % 2 == 1) {
            Array.Sort(nums);
            nums[0] = -nums[0];
        }
        
        return nums.Sum();
    }
}

C++ 해법

자동 초안, 제출 전 검토

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public int LargestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        
        for (int i = 0; i < nums.size(); i++) {
            if (k > 0 && nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            }
        }
        
        if (k % 2 == 1) {
            sort(nums.begin(), nums.end());
            nums[0] = -nums[0];
        }
        
        return nums.Sum();
    }
}

Java 해법

매칭됨/원본

import java.util.Arrays;

public class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        Arrays.sort(nums);
        
        for (int i = 0; i < nums.length; i++) {
            if (k > 0 && nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            }
        }
        
        if (k % 2 == 1) {
            Arrays.sort(nums);
            nums[0] = -nums[0];
        }
        
        return Arrays.stream(nums).sum();
    }
}

JavaScript 해법

매칭됨/원본

class Solution {
    largestSumAfterKNegations(nums, k) {
        nums.sort((a, b) => a - b);
        
        for (let i = 0; i < nums.length; i++) {
            if (k > 0 && nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            }
        }
        
        if (k % 2 === 1) {
            nums.sort((a, b) => a - b);
            nums[0] = -nums[0];
        }
        
        return nums.reduce((a, b) => a + b, 0);
    }
}

Python 해법

매칭됨/원본

class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        nums.sort()
        
        for i in range(len(nums)):
            if k > 0 and nums[i] < 0:
                nums[i] = -nums[i]
                k -= 1
        
        if k % 2 == 1:
            nums.sort()
            nums[0] = -nums[0]
        
        return sum(nums)

Go 해법

매칭됨/원본

import (
    "sort"
)

func largestSumAfterKNegations(nums []int, k int) int {
    sort.Ints(nums)
    
    for i := 0; i < len(nums); i++ {
        if k > 0 && nums[i] < 0 {
            nums[i] = -nums[i]
            k--
        }
    }
    
    if k % 2 == 1 {
        sort.Ints(nums)
        nums[0] = -nums[0]
    }
    
    sum := 0
    for _, num := range nums {
        sum += num
    }
    return sum
}

Algorithm

Сортировка 배열а:

Отсортируйте 배열 nums по возрастанию, чтобы наибольшее количество раз менять самые маленькие (отрицательные) значения на их противоположные.

Модификация 배열а:

Пройдитесь по отсортированному 배열у и замените k наименьших значений на их противоположные (умножьте на -1). Если встретите 0, прекратите дальнейшие изменения, так как изменение 0 на -0 не имеет смысла.

Проверка остатка изменений:

Если после первого прохода остались изменения (k нечетное), то find минимальное значение в измененном 배열е и еще раз поменяйте его знак. Это обеспечит максимальную сумму.

😎

Vacancies for this task

활성 채용 with overlapping task tags are 표시됨.

전체 채용

아직 활성 채용이 없습니다.