கே நெகேஷன்ஸ் லீட்கோட் தீர்வுக்குப் பிறகு வரிசையின் தொகையை அதிகரிக்கவும்


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது அமேசான்
அணி லீட்கோட்

இந்த இடுகை கே நெகேஷன்ஸ் லீட்கோட் தீர்வுக்குப் பிறகு வரிசை வரிசையை அதிகப்படுத்துகிறது

சிக்கல் அறிக்கை

சிக்கலில் ”K க்குப் பிறகு வரிசையின் அளவை அதிகரிக்கவும் நிராகரிப்புகள்”எங்களுக்கு ஒரு வரிசை அர் மற்றும் ஒரு மதிப்பு வழங்கப்படுகிறது. வரிசை முழு எண் மதிப்புகளைக் கொண்டுள்ளது. Ar [i] இன் மதிப்பை -arr [i] K முறைக்கு மாற்றலாம். I இன் மதிப்பை நாம் மீண்டும் செய்யலாம். இந்த முறை K முறைகளைப் பயன்படுத்துவதன் மூலம் வரிசை தொகையை அதிகப்படுத்துவதும், மாற்றியமைத்தபின் மொத்த வரிசைத் தொகையைத் திருப்புவதும் எங்கள் பணி.

உதாரணமாக

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

விளக்கம்:

கே எதிர்மறைகள் லீட்கோட் தீர்வுக்குப் பிறகு வரிசையின் தொகையை அதிகரிக்கவும்

கொடுக்கப்பட்ட வரிசையில் -3 முதல் 3 மற்றும் -4 முதல் 4 வரை மாற்றும்போது, ​​வரிசையின் மொத்த தொகை 13 ஆகிறது.

அணுகுமுறை

எங்கள் பணி வரிசை தொகையை அதிகரிக்கவும் மற்றும் வரிசை நேர்மறை மற்றும் எதிர்மறை கூறுகளைக் கொண்டிருக்கும், எனவே இந்த படிகளைப் பின்பற்றுவோம்:

  1. முதலில் நாம் வரிசையை வரிசைப்படுத்துவோம், ஏனென்றால் சிறிய மதிப்பின் அடையாளத்தை மாற்ற விரும்புகிறோம். அதிகரிக்க இது பயனுள்ளதாக இருக்கும் வரிசை தொகை.
  2.  இப்போது நாம் அதிகபட்சமாக K இன் அடையாளத்தை மாற்றுவோம் எதிர்மறை எண்கள்.
  3. இதற்கிடையில், வரிசையில் பூஜ்ஜியம் இருக்கிறதா இல்லையா என்பதையும் கண்காணிப்போம்.
  4. கண்டுபிடிக்க வரிசை தொகை.
  5. எங்கள் இறுதி பதில் இருக்கும் வரிசை தொகை என்றால்:
    1. K இன் மதிப்பு பூஜ்ஜியமாகிறது.
    2. வரிசையில் பூஜ்ஜியம் உள்ளது. இந்த வழியில் பூஜ்ஜியத்தின் அடையாளத்தை மாற்றுவோம்.
    3. எதிர்மறை மதிப்புகளின் அடையாளத்தை மாற்றிய பின் K இன் மதிப்பை மீட்டெடுப்பது சமமாகும். இந்த வழியில் நாம் எதிர்மறை எண்ணுக்கு நேர்மறை எண்ணை உருவாக்குவோம், பின்னர் அதை மீண்டும் நேர்மறையாக்குவோம்.
  6. இங்கே K இன் மதிப்பு எதிர்மறையானது, எனவே நாம் அதன் அடையாளத்தை மாற்றுவோம் மிகச்சிறிய நேர்மறை எண் கே முறை. இது எதிர்மறையாக மாறும். இப்போது புதிய வரிசை தொகையை திருப்பித் தருகிறோம்.

கே எதிர்மறைகள் லீட்கோட் தீர்வுக்குப் பிறகு வரிசையின் அளவை அதிகரிப்பதற்கான குறியீடு

சி ++ குறியீடு

#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

கே எதிர்மறைகள் லீட்கோட் தீர்வுக்குப் பிறகு வரிசையின் அதிகபட்ச தொகையின் சிக்கலான பகுப்பாய்வு

நேர சிக்கலானது

மேலே உள்ள குறியீட்டின் நேர சிக்கலானது ஓ (n) ஏனென்றால், கொடுக்கப்பட்ட வரிசையை ஒரு முறை மட்டுமே பயணிக்கிறோம்.

விண்வெளி சிக்கலானது

மேலே உள்ள குறியீட்டின் இட சிக்கலானது ஓ (1) ஏனென்றால் பதில்களைச் சேமிக்க ஒரு மாறி மட்டுமே பயன்படுத்துகிறோம்.

குறிப்புகள்