ఉప-శ్రేణుల లీట్‌కోడ్ పరిష్కారాన్ని తిప్పికొట్టడం ద్వారా రెండు శ్రేణులను సమానంగా చేయండి


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది <span style="font-family: Mandali; ">ఫేస్‌బుక్ </span>
అర్రే

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

ఉప-శ్రేణుల లీట్‌కోడ్ పరిష్కారాన్ని తిప్పికొట్టడం ద్వారా రెండు శ్రేణులను సమానంగా చేయండి

target = [1,2,3,4], arr = [2,4,1,3]
true

వివరణ: మేము మొదటి ఉప-శ్రేణిని ఇండెక్స్ 0 నుండి 2 కి రివర్స్ చేయవచ్చు, తరువాత మేము ఉప శ్రేణిని 1 నుండి 2 కి రివర్స్ చేయవచ్చు. చివరికి, మేము ఇండెక్స్ 2 నుండి 3 వరకు రివర్స్ చేస్తాము. మరియు ఈ విధంగా, మేము లక్ష్య శ్రేణిని చేయవచ్చు . పై చిత్రాన్ని పరిశీలించడం ద్వారా దీన్ని బాగా అర్థం చేసుకోవచ్చు.

ఉప-శ్రేణుల లీట్‌కోడ్ పరిష్కారాన్ని తిప్పికొట్టడం ద్వారా రెండు శ్రేణులను సమానంగా చేయడానికి విధానం

లెక్కింపు పద్ధతిని ఉపయోగించి సమస్యను సులభంగా పరిష్కరించవచ్చు. లెక్కింపు పద్ధతి కొన్ని ప్రామాణిక అల్గోరిథంలు. ఇది కౌంట్ సార్టింగ్‌తో పాటు అనేక ఇతర ప్రశ్నలలో ఉపయోగించబడుతుంది. కాబట్టి ఇక్కడ మేము లక్ష్య శ్రేణి నుండి మూలకాల సంఖ్యను ఉంచుతాము. అప్పుడు మేము ఇన్పుట్ శ్రేణి యొక్క మూలకాలను దాటుతాము. మేము ఏదైనా మూలకాన్ని ఎదుర్కొన్నప్పుడు, దాని సంఖ్యను ఫ్రీక్వెన్సీ లేదా కౌంట్ అర్రే నుండి తగ్గిస్తాము. ఈ ఆపరేషన్ సమయంలో ఏదో ఒకవిధంగా ఉంటే, ఏదైనా సూచిక ప్రతికూల విలువను కలిగి ఉంటుంది.

ఫ్రీక్వెన్సీ శ్రేణిలోని ప్రతికూల గణన ఇన్పుట్ శ్రేణి మూలకానికి పెద్ద గణనను చూపుతుంది. అయితే ఇలా చేయడం సమస్యను ఎలా పరిష్కరిస్తుంది? మీరు పరిశీలన తెలుసుకున్న తర్వాత సమాధానం చాలా సులభం. ఒకసారి మీరు ఉప శ్రేణుల యొక్క కొన్ని రివర్సల్స్ చేయడానికి ప్రయత్నిస్తారు. ఇన్పుట్ శ్రేణి యొక్క ఏదైనా మూలకాన్ని మీకు కావలసిన చోట ఉంచవచ్చని మీరు సులభంగా గుర్తించవచ్చు. కాబట్టి, ఈ నియమాన్ని ఉపయోగించి లక్ష్య శ్రేణిలోని అంశాలు ఇన్‌పుట్ శ్రేణికి సమానంగా ఉన్నాయో లేదో తనిఖీ చేయాలి.

ఉప-శ్రేణుల లీట్‌కోడ్ సొల్యూషన్‌ను రివర్స్ చేయడం ద్వారా రెండు శ్రేణులను సమానంగా చేయడానికి కోడ్

సి ++ కోడ్

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

bool canBeEqual(vector<int>& target, vector<int>& arr) {
    vector<int> cnt(1001, 0);
    for(int i=0;i<target.size();i++)
        ++cnt[target[i]];
    for (int i=0;i<arr.size();i++) {
        if (--cnt[arr[i]] < 0) {
            return false;
        }
    }
    return true;
}

int main(){
    vector<int> target = {1, 2, 3, 4};
    vector<int> arr = {2, 3, 1, 4};
    cout<<(canBeEqual(target, arr) ? "true" : "false");
}
true

జావా కోడ్

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

class Main
{
  public static boolean canBeEqual(int[] target, int[] arr) {
        int[] cnt = new int[1001];
        for(int i=0;i<target.length;i++)
            ++cnt[target[i]];
        for (int i=0;i<arr.length;i++) {
            if (--cnt[arr[i]] < 0) {
                return false;
            }
        }
        return true;
    }
    
  public static void main (String[] args) throws java.lang.Exception
  {
    int[] target = {1, 2, 3, 4};
      int[] arr = {2, 3, 1, 4};
      System.out.print(canBeEqual(target, arr) ? "true" : "false");
  }
}
true

సంక్లిష్టత విశ్లేషణ

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

పై), ఎందుకంటే మేము శ్రేణుల యొక్క అన్ని అంశాలపై ప్రయాణిస్తాము.

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

ఓ (1), ఎందుకంటే మేము స్థిరమైన పరిమాణ పౌన frequency పున్యం లేదా కౌంట్ శ్రేణిని ఉపయోగించాము.