के नेगेशन्स लीटकोड सोल्यूशन नंतर अ‍ॅरेची बेरीज वाढवा


अडचण पातळी सोपे
वारंवार विचारले ऍमेझॉन
अरे लेटकोड

के नेगेशन्स लीटकोड सोल्यूशन नंतर हे पोस्ट मॅक्सिमाइझ सम ऑफ अ‍ॅरे वर आहे

समस्या विधान

समस्येमध्ये ”के नंतर अ‍ॅरेचा अधिकतम योग नकारार्थी”आपल्याला अ‍ॅरे अ‍ॅर व व्हॅल्यू के दिले जाते. अ‍ॅरे मध्ये पूर्णांक व्हॅल्यू असतात. आपण एर [i] ते -अर [i] के वेळा बदलू शकतो. I ची व्हॅल्यू पुनरावृत्ती करू शकतो. आमची कार्ये ही पद्धत के वेळा वापरुन अ‍ॅरेची बेरीज करणे आणि सुधारणानंतर एकूण अ‍ॅरेची रक्कम परत करणे हे आहे.

उदाहरण

arr = [2,-3,-1,5,-4], k=2
13

स्पष्टीकरण:

के नेगेशन्स लीटकोड सोल्यूशन नंतर अ‍ॅरेची बेरीज वाढवा

दिलेल्या अ‍ॅरेमध्ये जेव्हा आपण -3 ते 3 आणि -4 ते 4 बदलू तेव्हा अ‍ॅरेची एकूण बेरीज 13 होईल.

दृष्टीकोन

आमचे कार्य आहे अ‍ॅरेची बेरीज वाढवा आणि अ‍ॅरेमध्ये दोन्ही सकारात्मक आणि नकारात्मक घटक असतात, म्हणून आम्ही या चरणांचे अनुसरण करू:

  1. सर्वप्रथम आपण अ‍ॅरेची वर्गीकरण करू कारण आपल्याला सर्वात लहान मूल्याचे चिन्ह बदलू इच्छित आहे. हे जास्तीत जास्त करण्यात उपयुक्त ठरेल अ‍ॅरे बेरीज.
  2.  आता आम्ही जास्तीत जास्त के चे चिन्ह बदलू नकारात्मक संख्या.
  3. दरम्यान, शून्य अ‍ॅरेमध्ये उपस्थित आहे की नाही याचीही आम्ही नोंद ठेवू.
  4. शोध अ‍ॅरे बेरीज.
  5. आमचे अंतिम उत्तर असेल अ‍ॅरे बेरीज तर:
    1. K ची व्हॅल्यू शून्य होते.
    2. शून्य अ‍ॅरे मध्ये उपस्थित आहे. अशाप्रकारे आपण शून्याचे चिन्ह बदलत राहू.
    3. नकारात्मक मूल्यांचे चिन्ह बदलल्यानंतर के चे उर्वरित मूल्य समान आहे. अशाप्रकारे आपण negativeणात्मक संख्येला सकारात्मक संख्या बनवू आणि नंतर त्यास पुन्हा सकारात्मक बनवू.
  6. येथे के चे मूल्य नकारात्मक आहे म्हणून आम्ही साइन इन करू सर्वात लहान सकारात्मक संख्या के वेळा. हे नकारात्मक बनवेल. आता आपण नवीन अ‍ॅरेची रक्कम परत करू.

के नेगेशन्स लीटकोड सोल्यूशन नंतर अ‍ॅरे मॅक्सिमाइझ सम ऑफ अ‍ॅरेचा कोड

सी ++ कोड

#include <bits/stdc++.h> 
using namespace std; 
    int largestSumAfterKNegations(vector<int>& A, int K) {
        sort(A.begin(),A.end());
        int sum=0,neg=0,zero=0;
        for(int i=0;i<A.size();i++)
        {
            if(A[i]==0)
                zero=1;
            if(A[i]<0&&K>0)
            {  A[i]=-A[i];K--;}
            sum+=A[i];
        }
        if(zero||K==0||K%2==0)
         return sum;
        else
            return sum-2*(*min_element(A.begin(),A.end()));       
    }
int main() 
{ 
 vector<int> arr = {2,-3,-1,5,-4}; 
 int k=2;
 cout<<largestSumAfterKNegations(arr,k)<<endl; 
 return 0;
}
13

जावा कोड

import java.util.Arrays; 
public class Tutorialcup {
    public static int largestSumAfterKNegations(int[] A, int K) {
        Arrays.sort(A);
        int sum=0,neg=0,zero=0;
        for(int i=0;i<A.length;i++)
        {
            if(A[i]==0)
                zero=1;
            if(A[i]<0&&K>0)
            {  A[i]=-A[i];K--;}
            sum+=A[i];
        }
        if(zero==1||K==0||K%2==0)
         return sum;
        else
            return sum-2*(Arrays.stream(A).min().getAsInt());      
    }
  public static void main(String[] args) {
    int [] arr = {2,-3,-1,5,-4}; 
    int k=2;
    int ans=  largestSumAfterKNegations(arr,k);
    System.out.println(ans);
  }
}
13

के नेगेशन्स लीटकोड सोल्यूशन नंतर अ‍ॅरेच्या मॅक्सिमाइझ समचे गुंतागुंत विश्लेषण

वेळ गुंतागुंत

वरील कोडची वेळ जटिलता आहे O (n) कारण आम्ही दिलेल्या अ‍ॅरेला फक्त एकदाच ट्रॅव्हर्स करत आहोत.

जागेची जटिलता

वरील कोडची स्पेस कॉम्प्लेक्सिटी आहे ओ (1) कारण आम्ही उत्तरे साठवण्यासाठी फक्त एक व्हेरिएबल वापरत आहोत.

संदर्भ