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

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

အဆိုပါ တစ်နှစ်တာ၏လူဦးရေ x သည် ထိုနှစ်အတွင်း အသက်ရှင်နေသေးသော အရေအတွက်ဖြစ်သည်။ ဟိ ith လူတစ်ဦးကို တစ်နှစ်အတွင်း ရေတွက်သည်။ x၎။လူဦးရေ x ယင်း၌တည်ရှိ၏ ပါဝင်သော အကွာအဝေး [birth_i, death_i - 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 <= birth_i < death_i <= 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) ကို ပြန်ပေးပါမည်။ ထို့ကြောင့် လူဦးရေအများဆုံးနှစ်ကို ရှာပါ။

ကုဒ်:

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