ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਲੀਟਕੋਡ ਹੱਲ ਕਹਿੰਦਾ ਹੈ ਕਿ - ਤੁਹਾਨੂੰ ਇੱਕ 2D ਪੂਰਨ ਅੰਕ ਐਰੇ ਦਿੱਤਾ ਗਿਆ ਹੈ logs ਜਿੱਥੇ ਹਰ ਇਕ logs[i] = [birth_i, death_i] ਦੇ ਜਨਮ ਅਤੇ ਮੌਤ ਦੇ ਸਾਲਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ith ਵਿਅਕਤੀ

The ਕੁਝ ਸਾਲ ਦੀ ਆਬਾਦੀ x ਉਸ ਸਾਲ ਦੌਰਾਨ ਜਿਊਂਦੇ ਲੋਕਾਂ ਦੀ ਸੰਖਿਆ ਹੈ। ਦ ith ਇੱਕ ਵਿਅਕਤੀ ਨੂੰ ਸਾਲ ਵਿੱਚ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ xਦੀ ਆਬਾਦੀ ਜੇਕਰ x ਵਿੱਚ ਹੈ ਸੰਮਲਿਤ ਸੀਮਾ [birth_i, death_i - 1]. ਨੋਟ ਕਰੋ ਕਿ ਵਿਅਕਤੀ ਹੈ ਨਾ ਉਸ ਸਾਲ ਵਿੱਚ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਉਹ ਮਰਦੇ ਹਨ।

ਵਾਪਸੀ ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਦਾ ਸਾਲ.

 

ਉਦਾਹਰਨ 1:

ਇੰਪੁੱਟ:

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

ਆਉਟਪੁੱਟ:

 1993

ਸਪਸ਼ਟੀਕਰਨ:

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

ਉਦਾਹਰਨ 2:

ਇੰਪੁੱਟ:

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

ਆਉਟਪੁੱਟ:

 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

 

ਐਲਗੋਰਿਥਮ -

• ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਦਾ ਸਾਲ ਲੱਭਣ ਲਈ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦਿੱਤੇ ਮੈਟ੍ਰਿਕਸ ਦੇ ਹਰੇਕ ਅੰਤਰਾਲ ਦੀ ਜਾਂਚ ਕਰਕੇ ਹਰ ਸਾਲ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਆਬਾਦੀ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਾਂਗੇ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਲੱਭਾਂਗੇ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਦਾ ਸਾਲ ਵਾਪਸ ਕਰਾਂਗੇ। ਜੇਕਰ ਗਿਣਤੀ ਇੱਕੋ ਜਿਹੀ ਹੈ ਤਾਂ ਅਸੀਂ ਸਿਰਫ਼ ਪਿਛਲੇ ਸਾਲ (ਸ਼ੁਰੂਆਤੀ ਸਾਲ) ਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹਾਂ।

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਲੀਟਕੋਡ ਹੱਲ ਲਈ ਪਹੁੰਚ

- ਪਹਿਲਾਂ, ਅਸੀਂ ਆਕਾਰ 101 ਦੀ ਇੱਕ ਐਰੇ ਬਣਾਵਾਂਗੇ ਕਿਉਂਕਿ ਸਾਲਾਂ ਦੀਆਂ ਪਾਬੰਦੀਆਂ 1950 ਤੋਂ 2050 ਦੀ ਰੇਂਜ ਵਿੱਚ ਹਨ।

- ਉਸ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ 0 ਤੋਂ ਲੌਗਸ ਦੀ ਲੰਬਾਈ ਤੱਕ ਇੱਕ ਲੂਪ ਚਲਾਵਾਂਗੇ ਅਤੇ ਸੂਚਕਾਂਕ (ਲੌਗਸ[i][o]) 'ਤੇ ਐਰੇ ਦੀ ਗਿਣਤੀ ਨੂੰ 1 ਤੱਕ ਵਧਾਵਾਂਗੇ ਅਤੇ ਸੂਚਕਾਂਕ (ਲੌਗਸ[i]) 'ਤੇ ਐਰੇ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਵਾਂਗੇ। [1]) 1 ਦੁਆਰਾ

- ਦੁਬਾਰਾ ਅਸੀਂ ਐਰੇ ਦੀ ਲੰਬਾਈ ਤੱਕ 0 ਤੋਂ ਇੱਕ ਲੂਪ ਚਲਾਵਾਂਗੇ ਅਤੇ ਇੱਕ ਵੇਰੀਏਬਲ ਪ੍ਰੀਵ ਕਾਉਂਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਐਰੇ ਦੇ ਹਰੇਕ ਐਲੀਮੈਂਟ ਨੂੰ ਐਰੇ+ਪ੍ਰੀਵ ਦੁਆਰਾ ਅਪਡੇਟ ਕਰਾਂਗੇ ਅਤੇ ਪ੍ਰੀਵ = ਐਰੇ[i] ਦੁਆਰਾ ਅੱਪਡੇਟ ਕਰਾਂਗੇ।

- ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਲੂਪ ਚਲਾਵਾਂਗੇ ਅਤੇ ਐਰੇ ਵਿੱਚ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਲੱਭਾਂਗੇ ਅਤੇ ਉਸ ਖਾਸ ਸੂਚਕਾਂਕ (ਇੰਡੈਕਸ+1950) ਨੂੰ ਵਾਪਸ ਕਰਾਂਗੇ। ਇਸ ਲਈ ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਦਾ ਸਾਲ ਲੱਭੋ।

ਕੋਡ:

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਪਾਈਥਨ ਲੀਟਕੋਡ ਹੱਲ:

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

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਜਾਵਾ ਲੀਟਕੋਡ ਹੱਲ:

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;
        
        
    }
}

ਵੱਧ ਤੋਂ ਵੱਧ ਆਬਾਦੀ ਸਾਲ ਲੀਟਕੋਡ ਹੱਲ ਦਾ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ:

ਟਾਈਮ ਜਟਿਲਤਾ

ਉਪਰੋਕਤ ਹੱਲ ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ O(n) ਹੈ।

ਟਾਈਮ ਜਟਿਲਤਾ

ਉਪਰੋਕਤ ਘੋਲ ਦੀ ਸਪੇਸ ਜਟਿਲਤਾ O(1) ਹੈ।

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਲੰਬਾਈ = 101 ਦੀ ਇੱਕ ਐਰੇ ਬਣਾਈ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਇਸਨੂੰ ਸਥਿਰ ਮੰਨ ਸਕਦੇ ਹਾਂ