సమాన శ్రేణి మూలకాలకు కనీస కదలికలు లీట్‌కోడ్ పరిష్కారం


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది అమెజాన్ ఆపిల్ Coursera ఫాక్ట్‌సెట్ నిజానికి JP మోర్గాన్ గణితాలు మైక్రోసాఫ్ట్ Swiggy
డ్రాబ్రిడ్జ్ మఠం

సమస్యల నివేదిక

ఈ సమస్యలో, మాకు ఒక ఇవ్వబడుతుంది అమరిక పూర్ణాంకాల. అలాగే, ఈ శ్రేణిలో నిర్దిష్ట కార్యకలాపాలను నిర్వహించడానికి మాకు అనుమతి ఉంది. ఒక ఆపరేషన్‌లో, మేము శ్రేణిలోని ”n - 1 ″ (ఏదైనా మినహా అన్ని అంశాలు) 1 ని పెంచవచ్చు.

అన్ని శ్రేణి మూలకాలను సమానంగా చేయడానికి అవసరమైన కనీస సంఖ్యలో ఆపరేషన్లను మేము కనుగొనాలి.

ఉదాహరణ

Array = {1 , 2 , 3}
3
Array = {1 , 1 , 1}
0

 

సమాన శ్రేణి మూలకాలకు కనీస కదలికలు లీట్‌కోడ్ పరిష్కారంఅప్రోచ్ (మఠం)

ఈ సమస్యలో, అన్ని శ్రేణి మూలకాలతో సమానంగా మీరు 1 పెంచాలనుకుంటున్న సంఖ్యల సమితిని ఎన్నుకోవడం కష్టం. అయితే, శ్రేణిలో 'N - 1' మూలకాలను పెంచడం అనేది ఒక శ్రేణి మూలకాన్ని 1 తగ్గించడం. అన్ని మూలకాలు సమానమైన తర్వాత వాటి విలువ ఏమిటో తెలుసుకోవడానికి మేము ఇష్టపడటం లేదు, బదులుగా కదలికల సంఖ్యను కనుగొనడంలో మాకు ఆసక్తి ఉంది. ఇప్పుడు, ఇది మన ఆపరేషన్ శ్రేణిలోని ఒక మూలకాన్ని 1 ద్వారా తగ్గించడం కాబట్టి, శ్రేణిలోని అన్ని మూలకాలను శ్రేణిలో ఉన్న కనీస మూలకానికి మార్చాలి (ఇది ఏమాత్రం తగ్గించాల్సిన అవసరం లేదు మరింత).

సమాన శ్రేణి మూలకాలకు కనీస కదలికల అమలు లీట్‌కోడ్ పరిష్కారం

సి ++ ప్రోగ్రామ్

#include <bits/stdc++.h>

using namespace std;

int minMoves(vector <int> nums) {
    int mn = *min_element(nums.begin() , nums.end()) , moves = 0;
    for(int &i : nums)
        moves += i - mn;
    return moves;
}

int main() {
    vector <int> nums = {1 , 2 , 3};
    cout << minMoves(nums) << endl;
    return 0;
}

జావా ప్రోగ్రామ్

import java.lang.*;
import java.util.*;

class min_moves {
    public static void main(String args[]) {
        int[] nums = {1 , 2 , 3};
        System.out.println(minMoves(nums));
    }

    public static int minMoves(int[] nums) {
        if(nums.length == 0)
            return 0;
        int mn = nums[0];
        for(int i = 0 ; i < nums.length ; i++) {
            mn = Math.min(mn , nums[i]);
        }

        int moves = 0;
        for(int i = 0 ; i < nums.length ; i++) {
            moves += nums[i] - mn;
        }

        return moves;
    }
}
3

సమాన శ్రేణి మూలకాలకు కనీస కదలికల సంక్లిష్టత విశ్లేషణ లీట్‌కోడ్ పరిష్కారం

సమయం సంక్లిష్టత

పై), శ్రేణి యొక్క N = పరిమాణం. మేము మొత్తం శ్రేణిని ఒకసారి ప్రయాణించాము.

అంతరిక్ష సంక్లిష్టత 

O (1), మేము శ్రేణిలో స్థిరమైన మెమరీ స్థలాన్ని ఉపయోగిస్తున్నందున.