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

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

ဆက်ဖတ်ရန်

အတိုဆုံး Unsorted Continuous Subarray LeetCode ဖြေရှင်းချက်

Problem Statement တွင် အတိုဆုံး Unsorted Continuous Subarray LeetCode Solution မှ ပြောကြားသည်မှာ - ကိန်းပြည့် array နံပါတ်များကို ပေး၍ ဤ subarray ကို ငယ်စဉ်ကြီးလိုက် စီမည်ဆိုပါက၊ array တစ်ခုလုံးကို ငယ်စဉ်ကြီးလိုက် စီမည်ဟူသော စဉ်ဆက်မပြတ် subarray တစ်ခုကို ရှာရပါမည်။ အတိုဆုံး subarray ၏ အရှည်ကို ပြန်ပေးပါ။ ဥပမာ 1-…

ဆက်ဖတ်ရန်

Sum Root to Leaf Numbers LeetCode ဖြေရှင်းချက်

Problem Statement Sum Root to Leaf Numbers LeetCode Solution ကပြောသည် - သင့်အား 0 မှ 9 ဂဏန်းများသာပါဝင်သော ဒွိသစ်ပင်၏အမြစ်ကို ပေးထားသည်။ သစ်ပင်ရှိ အမြစ်မှ အရွက်လမ်းကြောင်းတစ်ခုစီသည် နံပါတ်တစ်ခုကို ကိုယ်စားပြုသည်။ ဥပမာအားဖြင့်၊ အမြစ်မှအရွက်လမ်းကြောင်း 1 -> 2 -> 3 သည် နံပါတ် 123 ကိုကိုယ်စားပြုသည်။ အမြစ်မှအရွက်နံပါတ်အားလုံး၏ စုစုပေါင်းပေါင်းလဒ်ကို ပြန်ပေးပါ။ စမ်းသပ်မှု…

ဆက်ဖတ်ရန်

စကားချပ် LeetCode ဖြေရှင်းချက်၏ ရမှတ်

Problem Statement ကွင်းပိတ် LeetCode ဖြေရှင်းချက်၏ ရမှတ်က - မျှတသော ကွင်းပိတ် string ကို ပေး၍ အများဆုံးရမှတ်ကို ပြန်ပေးသည်။ ဟန်ချက်ညီသော စကားချပ်ကြိုးတစ်ချောင်း၏ ရမှတ်သည် အောက်ပါစည်းမျဉ်းများပေါ်တွင် အခြေခံသည်- “()” တွင် ရမှတ် 1 ရှိသည်။ AB တွင် ရမှတ် A+B ရှိပြီး A နှင့် B သည် ဟန်ချက်ညီသော စကားချပ်ကြိုးများဖြစ်သည်။ (A) ရမှတ် 2*A ရှိပြီး A သည်...

ဆက်ဖတ်ရန်

Rectangle Overlap LeetCode ဖြေရှင်းချက်

ပြဿနာထုတ်ပြန်ချက်- Rectangle Overlap LeetCode ဖြေရှင်းချက် – ဝင်ရိုးတန်းညှိထားသော စတုဂံကို စာရင်းတစ်ခုအနေဖြင့် ကိုယ်စားပြုသည်ဟုဆိုသည်၊ (x1၊ y1၊ x2၊ y2]၊ (x1၊ y1) သည် ၎င်း၏ဘယ်ဘက်အောက်ခြေထောင့်နှင့် (x2) ဖြစ်သည်၊ , y2) သည် ၎င်း၏ ညာဘက်အပေါ်ထောင့်၏ သြဒိနိတ်ဖြစ်သည်။ ၎င်း၏အပေါ်နှင့်အောက်ခြေအစွန်းများသည် X-axis နှင့်အပြိုင်ဖြစ်ပြီး ၎င်း၏ဘယ်ဘက်...

ဆက်ဖတ်ရန်

အများဆုံးလူဦးရေနှစ် 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 ကို ခင်းကျင်းထားပြီး ဖြစ်သောကြောင့် ကိန်းသေဟု ယူဆနိုင်ပါသည်။

 

 

 

 

 

 

Binary Tree Inorder Traversal LeetCode ဖြေရှင်းချက်

ပြဿနာဖော်ပြချက်- Binary Tree Inorder Traversal LeetCode ဖြေရှင်းချက် binary tree ၏ အမြစ်ကို ပေးထားသည့်အတွက်၊ ၎င်း၏ nodes များ၏ တန်ဖိုးများ အစီအစဥ်ဖြတ်ကျော်မှုကို ပြန်ပေးသည်။ ဥပမာ 1- ထည့်သွင်းမှု- root = [1,null,2,3] အထွက်- [1,3,2] နမူနာ 2- ထည့်သွင်းမှု- root = [] အထွက်- [] ဥပမာ 3- ထည့်သွင်းမှု- root = [1] အထွက်- [1] ကန့်သတ်ချက်များ- အတွင်းရှိ node အရေအတွက်...

ဆက်ဖတ်ရန်

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

Problem Statement Stone ဂိမ်း IV LeetCode ဖြေရှင်းချက် – Alice နှင့် Bob တို့သည် Alice ကို ပထမဆုံး စတင်ခြင်းဖြင့် ဂိမ်းတစ်ခုကို အလှည့်ကျ ကစားကြသည်။ အစကတော့ မီးပုံထဲမှာ ကျောက်တုံးတွေရှိတယ်။ ကစားသမားတစ်ဦးစီ၏အလှည့်တွင်၊ ထိုကစားသမားသည် Pile ရှိ သုညမဟုတ်သော စတုရန်းနံပါတ်မရှိသော ကျောက်တုံးများကို ဖယ်ရှားခြင်း ပါဝင်သော လှုပ်ရှားမှုတစ်ခုကို ပြုလုပ်သည်။ ထို့အပြင် ကစားသမားတစ်ဦးသည် ပြောင်းရွှေ့ရန် မဖြစ်နိုင်ပါက သူ/သူမ ...

ဆက်ဖတ်ရန်

Graph Bipartite ဖြစ်ပါသလား။ LeetCode ဖြေရှင်းချက်

Problem Statement Is Graph Bipartite LeetCode Solution- n node များပါရှိသော လမ်းညွှန်မထားသော ဂရပ်တစ်ခု ပါရှိပါသည်။ node တစ်ခုစီကို 0 နှင့် n – 1 ကြားတွင် ရေတွက်ထားသည်။ သင့်အား 2D array ဂရပ်တစ်ခု ပေးထားပြီး၊ graph[u] သည် သင့်အတွက် node များဖြစ်သော node များဖြစ်သည်။ ကပ်လျက်။ ပို၍တရားဝင်သည်၊ ဂရပ်[u]ရှိ v တစ်ခုစီအတွက်၊ node u နှင့် node v ကြားတွင် လမ်းညွှန်မထားသော အစွန်းတစ်ခုရှိသည်။ ဂရပ်တွင်...

ဆက်ဖတ်ရန်

စီတန်းထားသော မြို့ပတ်လင့်ခ်စာရင်း LeetCode ဖြေရှင်းချက်သို့ ထည့်ပါ။

ပြဿနာထုတ်ပြန်ချက်- စီတန်းထားသောမြို့ပတ်ရထားချိတ်ဆက်ထားသောစာရင်းတွင်ထည့်ပါ LeetCode ဖြေရှင်းချက် – ကြီးလိုက်ကြီးလိုက် စီထားသည့် Circular Linked List node ကို ပေးဆောင်ပါက ၎င်းသည် စီထားသော စက်ဝိုင်းစာရင်းတစ်ခုအဖြစ် ကျန်ရှိနေသည့် စာရင်းထဲသို့ တန်ဖိုးထည့်သွင်းရန် လုပ်ဆောင်ချက်တစ်ခုရေးပါ။ ပေးထားသော node သည်...

ဆက်ဖတ်ရန်

Translate »