Jump Game IV LeetCode ဖြေရှင်းချက်

ပြဿနာထုတ်ပြန်ချက်- Jump Game IV LeetCode Solution ကပြောသည် - ကိန်းပြည့် arr တစ်ခုအား ပေးခြင်းဖြင့် သင်သည် array ၏ ပထမအညွှန်းတွင် ကနဦး နေရာယူထားသည်။ အဆင့်တစ်ဆင့်တွင် သင်သည် အညွှန်း i မှ အညွှန်းကိန်း- i + 1 ရှိရာ- i + 1 < arr.length သို့ ခုန်နိုင်သည်။ i – 1 where: i – 1 >=…

ဆက်ဖတ်ရန်

အများဆုံးလူဦးရေနှစ် LeetCode ဖြေရှင်းချက်

ပြProbleနာဖော်ပြချက်

အများဆုံးလူဦးရေနှစ် LeetCode ဖြေရှင်းချက် ဒီလိုပြောတယ် – မင်းကို 2D integer array ပေးတယ်။ logs ဘယ်မှာလဲ logs[i] = [birthi, deathi] မွေးဖွားခြင်းနှင့် သေဆုံးခြင်းနှစ်များကို ဖော်ပြသည်။ ith လူတစ်ဦး။

အဆိုပါ တစ်နှစ်တာ၏လူဦးရေ x သည် ထိုနှစ်အတွင်း အသက်ရှင်နေသေးသော အရေအတွက်ဖြစ်သည်။ ဟိ ith လူတစ်ဦးကို တစ်နှစ်အတွင်း ရေတွက်သည်။ x၎။လူဦးရေ x ယင်း၌တည်ရှိ၏ ပါဝင်သော အကွာအဝေး [birthi, deathi - 1]. ထိုပုဂ္ဂိုလ်ကို သတိပြုပါ။ မဟုတ် သူတို့သေတဲ့နှစ်ကို ရေတွက်တယ်။

ပြန်လာ အများဆုံးလူဦးရေနှစ်.

 

ဥပမာအား 1:

input:

 logs = [[1993,1999],[2000,2010]]

output:

 1993

ရှင်းလင်းချက်:

 The maximum population is 1, and 1993 is the earliest year with this population.

ဥပမာအား 2:

input:

 logs = [[1950,1961],[1960,1971],[1970,1981]]

output:

 1960

ရှင်းလင်းချက်:

 
The maximum population is 2, and it had happened in years 1960 and 1970.
So the maximum population year is 1960.

 

ကန့်သတ်ချက်များ:

  • 1 <= logs.length <= 100
  • 1950 <= birthi < deathi <= 2050

 

အယ်လ်ဂိုရစ်သမ် –

  • အများဆုံးလူဦးရေနှစ်ကိုရှာရန်။ ပထမဦးစွာ၊ ကျွန်ုပ်တို့သည် ပေးထားသော matrix ၏ ကြားကာလတစ်ခုစီကို စစ်ဆေးခြင်းဖြင့် နှစ်စဉ်ရှိ စုစုပေါင်း အရေအတွက် လူဦးရေအပေါ် အာရုံစိုက်ပြီး အများဆုံး count ကို ရှာပြီး အမြင့်ဆုံးတန်ဖိုး၏ နှစ်ကို ပြန်ပေးပါမည်။ အကယ်၍ အရေအတွက် တူညီပါက ယခင်နှစ် (အစောဆုံးနှစ်) ကို ပြန်ပေးပါသည်။

အများဆုံးလူဦးရေ တစ်နှစ်အတွက် LeetCode ဖြေရှင်းချက်

- ပထမ၊ ကျွန်ုပ်တို့သည် အရွယ်အစား 101 ၏ အကန့်အသတ်များ အပိုင်းအခြား 1950 မှ 2050 အတွင်း ရှိနေသောကြောင့် ကျွန်ုပ်တို့ ဖန်တီးပါမည်။

- ထို့နောက်၊ ကျွန်ုပ်တို့သည် 0 မှ logs အရှည်အထိ loop တစ်ခုကို run ပြီး index(logs[i][o]) တွင် array ၏ count ကို 1 ဖြင့် တိုးပြီး index (logs[i] [1]) ၁

- နောက်တဖန် ကျွန်ုပ်တို့သည် 0 မှ array ၏အရှည်အထိ loop တစ်ခုကို run ပြီး variable prev count တစ်ခုပြုလုပ်ပြီး array ၏ element တစ်ခုစီကို array+prev ဖြင့် update လုပ်ပြီး prev prev = array[i] ဖြင့် update လုပ်ပါမည်။

- နောက်ဆုံးတွင်၊ ကျွန်ုပ်တို့သည် loop တစ်ခုကို run ပြီး array တွင် အများဆုံးတန်ဖိုးကို ရှာပြီး ထိုအထူးညွှန်းကိန်း(index+1950) ကို ပြန်ပေးပါမည်။ ထို့ကြောင့် လူဦးရေအများဆုံးနှစ်ကို ရှာပါ။

အများဆုံးလူဦးရေနှစ် Leetcode ဖြေရှင်းချက်

ကုဒ်:

လူဦးရေအများဆုံးနှစ် Python Leetcode ဖြေရှင်းချက်-

class Solution:
    def maximumPopulation(self, logs: List[List[int]]) -> int:
        arr = [0]*101
        for i in range(len(logs)):
            
            arr[logs[i][0]-1950] += 1
            
            arr[logs[i][1]-1950] -= 1
            
        
        previous = arr[0]
        for i in range(1,101):
            arr[i] += previous
            previous = arr[i]
            
        print(arr)
        maxi = 0
        ind = 0
        
        for i in range(len(arr)):
            if arr[i] > maxi:
                maxi = arr[i]
                ind = i + 1950
        print(maxi)        
        return ind

အများဆုံးလူဦးရေနှစ် Java လီတင်ကုဒ်ဖြေရှင်းချက်-

class Solution {
    public int maximumPopulation(int[][] logs) {
        
        int[] arr = new int[101];
        for(int i = 0;i < logs.length;i++){
            
            arr[logs[i][0]-1950] +=1;
            arr[logs[i][1]-1950] -=1;
            
            
        }
        
        int prev = arr[0];
        for(int i=1;i<arr.length;i++){
            
            arr[i] += prev;
            prev = arr[i];
            
        }
        
        int ind = 0;
        int maxi = 0;
        
        for(int i=0;i<arr.length;i++){
            
            if(maxi < arr[i]){
                
                maxi = arr[i];
                ind = i+1950;
            }
        }
        
        
        return ind;
        
        
    }
}

အများဆုံးလူဦးရေနှစ်၏ Leetcode ဖြေရှင်းချက်ကို ရှုပ်ထွေးမှု ခွဲခြမ်းစိတ်ဖြာခြင်း-

အချိန်ရှုပ်ထွေး

အထက်ပါအဖြေ၏ အချိန်ရှုပ်ထွေးမှုသည် O(n) ဖြစ်သည်။

အချိန်ရှုပ်ထွေး

အထက်ပါအဖြေ၏ အာကာသရှုပ်ထွေးမှုသည် O(1) ဖြစ်သည်။

အရှည် = 101 ကို ခင်းကျင်းထားပြီး ဖြစ်သောကြောင့် ကိန်းသေဟု ယူဆနိုင်ပါသည်။

 

 

 

 

 

 

Group 1 ၏ Together Leetcode ဖြေရှင်းချက်သို့ အနည်းဆုံး လဲလှယ်မှု

ပြဿနာထုတ်ပြန်ချက်တွင် အုပ်စု 1 အားလုံး၏ အတူတကွ Leetcode ဖြေရှင်းချက်သို့ အနိမ့်ဆုံးဖလှယ်မှု – binary array ဒေတာကို ပေးထားပြီး၊ array အတွင်းရှိ မည်သည့်နေရာ၌မဆို 1 ၏ပါဝင်နေသည့် array အားလုံးကို စုဖွဲ့ရန် လိုအပ်သော အနည်းဆုံး လဲလှယ်မှုအရေအတွက်ကို ပြန်ပေးသည်ဟု ဆိုသည်။ Input- data = [1,0,1,0,1] Output- 1 ရှင်းလင်းချက်- အားလုံးကို အုပ်စုဖွဲ့ရန် နည်းလမ်း 3 ခု ရှိပါသည်။

ဆက်ဖတ်ရန်

အများဆုံးလူဦးရေနှစ် LeetCode ဖြေရှင်းချက်

ပြဿနာထုတ်ပြန်ချက်- အများဆုံးလူဦးရေနှစ် Leetcode ဖြေရှင်းချက်က - သင့်အား မှတ်တမ်းတစ်ခုစီသည် [i] = [birthi, deathi] ၏ မွေးဖွားခြင်းနှင့် သေဆုံးခြင်းနှစ်များကို ညွှန်ပြသည့် 2D integer array မှတ်တမ်းများကို သင့်အား ပေးထားပါသည်။ နှစ်တစ်နှစ်ရဲ့ လူဦးရေ x က အဲဒီနှစ်မှာ အသက်ရှင်နေတဲ့ လူအရေအတွက်ကလား။ x ဖြစ်ပါက x ၏လူဦးရေတွင် ၎င်းကိုရေတွက်သည်...

ဆက်ဖတ်ရန်

အကောင်းဆုံး Meeting Point LeetCode ဖြေရှင်းချက်

ပြဿနာထုတ်ပြန်ချက်- အကောင်းဆုံး Meeting Point Leetcode Solution ကပြောထားသည် – 1 တစ်ခုစီသည် သူငယ်ချင်းတစ်ဦး၏အိမ်ကို အမှတ်အသားပြုသည့် amxn ဒွိဂရစ်ဂရစ်ဖြင့် ပေးအပ်ထားသော အနည်းဆုံး စုစုပေါင်းခရီးအကွာအဝေးကို ပြန်ပေးသည်။ စုစုပေါင်း ခရီးအကွာအဝေးသည် သူငယ်ချင်းအိမ်များနှင့် တွေ့ဆုံသည့်နေရာကြား အကွာအဝေး၏ ပေါင်းစုဖြစ်သည်။ အကွာအဝေးကို Manhattan Distance ကို အသုံးပြု၍ တွက်ချက်သည်...

ဆက်ဖတ်ရန်

အနည်းဆုံး Path Sum Leetcode ဖြေရှင်းချက်

Problem Statement The Minimum Path Sum LeetCode Solution – "Minimum Path Sum" သည် ပေးထားသော anxm grid တွင် အနုတ်လက္ခဏာမဟုတ်သော ကိန်းပြည့်များပါ၀င်ကြောင်းပြောပြီး လမ်းကြောင်းတစ်လျှောက်ရှိ ဂဏန်းများအားလုံး၏ပေါင်းလဒ်ကို နည်းပါးသွားစေမည့် လမ်းကြောင်းကို အပေါ်မှလက်ဝဲမှ ညာဘက်အောက်သို့ ရှာရန် လိုအပ်ပါသည်။ . ငါတို့သာ လှုပ်ရှားနိုင်တယ်...

ဆက်ဖတ်ရန်

Min Cost Climbing Stairs LeetCode Solution

ပြဿနာ ထုတ်ပြန်ချက် အနည်းဆုံး လှေကားတက်ခြင်း ကုန်ကျစရိတ် LeetCode ဖြေရှင်းချက် - ကုန်ကျစရိတ် [i] သည် လှေကားပေါ်တက်ခြင်း၏ ကုန်ကျစရိတ်ဖြစ်ပြီး ကိန်းပြည့်အခင်းကုန်ကျစရိတ်ကို ပေးပါသည်။ ကုန်ကျစရိတ် ပေးချေပြီးသည်နှင့် တစ်လှမ်း သို့မဟုတ် နှစ်လှမ်းတက်နိုင်သည်။ အညွှန်း 0 ဖြင့် အဆင့်မှ စတင်နိုင်သည် သို့မဟုတ် အဆင့်ဖြင့် ...

ဆက်ဖတ်ရန်

ပေးထားသော Sum Condition LeetCode ဖြေရှင်းချက်ကို ကျေနပ်စေသော နောက်ဆက်တွဲအရေအတွက်

ပေးထားသော Sum Condition ကို ကျေနပ်စေသော LeetCode ဖြေရှင်းချက်- ကိန်းပြည့်ဂဏန်းများနှင့် ကိန်းပြည့်ပစ်မှတ်ကို ခင်းကျင်းပေးထားသည့် ပြဿနာဖော်ပြချက် အရေအတွက်က ဆိုသည်။ ၎င်းတွင် အနိမ့်ဆုံးနှင့် အမြင့်ဆုံးဒြပ်စင်၏ ပေါင်းလဒ်သည် ပစ်မှတ်နှင့် လျော့နည်းသည် သို့မဟုတ် ညီမျှသည်ဟု အချည်းနှီးမဟုတ်သော နောက်ဆက်တွဲ နံပါတ်များကို ပြန်ပေးပါ။ အဖြေက များလွန်းတာကြောင့်...

ဆက်ဖတ်ရန်

မြို့တရားသူကြီး LeetCode ဖြေရှင်းချက်ကို ရှာပါ။

ပြဿနာထုတ်ပြန်ချက်- Town Judge LeetCode ဖြေရှင်းချက်ကို ရှာပါ - မြို့တစ်မြို့တွင် 1 မှ n တံဆိပ်တပ်ထားသောလူများရှိပါသည်။ အဲဒီလူတွေထဲက တစ်ယောက်က မြို့တရားသူကြီးဖြစ်ပြီး မြို့တရားသူကြီးကို ရှာဖို့ လိုတယ် ဆိုတဲ့ ကောလဟာလတစ်ခုရှိတယ်။ မြို့တရားသူကြီးရှိလျှင် မြို့တရားသူကြီးက ဘယ်သူ့ကိုမှ မယုံဘူး။ …

ဆက်ဖတ်ရန်

GetRandom O(1) Leetcode ဖြေရှင်းချက်ကို ဖျက်ရန် ထည့်သွင်းပါ။

ပြဿနာဖော်ပြချက် GetRandom O(1) LeetCode ဖြေရှင်းချက် - "Insert Delete GetRandom O(1)" သည် သင့်အား O(1) အချိန်ရှုပ်ထွေးမှုတွင် ဤလုပ်ဆောင်ချက်လေးခုကို အကောင်အထည်ဖေါ်ရန် တောင်းဆိုပါသည်။ insert(val)- val ကို ကျပန်းသတ်မှတ်ထားသော set ထဲသို့ထည့်ကာ set တွင် element သည် အစပိုင်းတွင် ပျက်ကွက်ပါက true ပြန်ပေးပါ။ ၎င်းသည် မှားယွင်းသောအခါတွင် ပြန်လာသည်...

ဆက်ဖတ်ရန်

Translate »