Hər bir işçinin altında işçilərin sayını tapın

Çətinlik səviyyəsi Asan
Tez-tez soruşulur Akkolit GE Healthcare microsoft Mintra Qualcomm Sinopsis Teradata
HashingBaxılıb 59

HashMaps ən faydalı məlumat strukturlarından biridir. Hər işçinin altındakı işçi sayını tapmaq, məşhur filmin yaranma tarixini xatırladan bir problemdir. Bir xəyalda xəyal qurmaq kimidir. Burada bir işçinin altında işləyən bir işçimiz var və s.

Problem bəyanat

Bəs bu məsələdən nə çıxarmalıyıq?

Yaxşı. Kimsə ABŞ-ın altından çalışdığı işçilərin sayını hesablamaq üçün bu yorucu işi tapşırıb.

Əvvəlcə problemin bizə necə təqdim olunduğunu bir sınaq işi ilə əhatə edək:

Birincisi işçi, ikincisi menecer olmaqla bizə cütlüklər verilir. Başqalarına təyin olunmuş işçilərin sayını tapmaq lazımdır.

Hər bir işçinin altında işçilərin sayını tapınPin
Test işi göstərilir

Yanaşma və İdeologiya

Problemin həll olunmasının bir çox yolu var. Bununla birlikdə, yolların əksəriyyəti ya vaxtında, ya da məkanda ağırdır. Burada qeyd etdiyim bir şey bu yolda ən yaxşı yol kimi görünürdü.

  • Birincisi, məlumat strukturlarını yekunlaşdırarkən Hashmaps-ın problemi həll etməyin ən yaxşı yolu olduğunu başa düşdüm
  • İkincisi, səmərəli istifadə olunduğunu başa düşdüm. Yalnız bir döngə kifayət idi.
  • Bir hashmap saxlayırıq.
  • Haşmapın açarları işçilərdir
  • Haşmapın dəyəri, onların altındakı işçilərin sayındadır
  • Bir döngə edirik.
  • Hər dəfə baxırıq ki, menecer üçün bir açar var
  • Bunu etsək, əvvəlki dəyərə 1 əlavə edirik
  • İşçi üçün bir açarımız varsa hər dəfə baxırıq
  • Bunu etsək, biz onun altında çalışan insanlar şəbəkəmizə

Hər bir işçinin altındakı işçi sayını tapmaq üçün Java kodu

void group(lisa[][],int x,int y)
{
    unordered_map<char,int>store;
    for(int i=0;i<x;i++)
    {
    if(store.find(lisa[i][1])!=lisa.end())
    {
        if(store.find(lisa[i][0])!=lisa.end())
            store[lisa[i][1]]=lisa[[i][0]]+store[lisa[i][1]]+1;
        else
            store[lisa[i][1]]=store[lisa[i][1]]+1;
        else
            store.put[lisa[i][1]]=1;
    }
    for (int data : store)  
    {
        cout<<"Key = " + datagetKey() + ", Value = "+entry.getValue());
    }
}
int main() 
{
     Character[6][2]lisa;
        lisa[0][0]='A';
        lisa[0][1]='C';            
        lisa[1][0]='B';
        lisa[1][1]='C';
        lisa[2][0]='C';
        lisa[2][1]='F';
        lisa[3][0]='D';
        lisa[3][1]='E';
        lisa[4][0]='E';
        lisa[4][1]='F';
        lisa[5][0]='F';
        lisa[5][1]='F';
        group(lisa,6,2);
}

Java-dan C ++ dilinə keçərkən HashMap-dən unordered_map-ə necə keçdiyimizi görmək olar.

Hər bir işçinin altındakı işçi sayını tapmaq üçün C ++ kodu

#include<bits/stdc++.h>
using namespace std;
void group(char lisa[][2],int x)
{
    unordered_map<char,int>store;
    for(int i=0;i<x;i++)
    {
        int a=lisa[i][1];
        int b=lisa[i][0];
    if(store.find(lisa[i][1])!=store.end())
    {
        if(store.find(lisa[i][0])!=store.end())
            store[a]=store[b]+store[a]+1;
        else
            store[a]=store[a]+1;
    }
        else
            store[a]=1;
    }
    for (auto data : store)  
    {
        cout<<"Key = "<<data.first<< ", Value = "<<data.second<<endl;        
    }
}
int main() 
{
    char lisa[6][2];
        lisa[0][0]='A';
        lisa[0][1]='C';            
        lisa[1][0]='B';
        lisa[1][1]='C';
        lisa[2][0]='C';
        lisa[2][1]='F';
        lisa[3][0]='D';
        lisa[3][1]='E';
        lisa[4][0]='E';
        lisa[4][1]='F';
        lisa[5][0]='F';
        lisa[5][1]='F';
        group(lisa,6);
}
[[A,C],[B,C],[C,F],[D,E],[E,F],[F,F]]
{{A:0},{B,0},{C,2},{D,0},{E,1},{F,5}}

Mürəkkəblik təhlili

Zaman Mürəkkəbliyi = O (N)

Bütün elementlərdən keçən tək bir döngə işlədərkən

Kosmik Mürəkkəblik = O (N)

Bütün açar dəyər cütlərini saxlamaq üçün HashMap istifadə etdikdə

Kiçik bir çimdik

İndi yalnız işçinin məlumatları altında olan işçini deyil, hər bir işçinin əhəmiyyətini təmin edirik. Hər bir menecerin əhəmiyyəti barədə məlumat vermək mamont vəzifəsi daşıyırıq.

Müvafiq məlumatlara baxmaq üçün BFS həyata keçirərkən bir-bir prosesi keçək

  • Birincisi, a elementlərini yerləşdiririk növbə.
  • Bu növbə boşalana qədər növbəti imkanları araşdırmağa davam edəcəyik
  • İkincisi, növbədən ən üst elementi alırıq
  • İşçinin götürdüyü işçilərin siyahısını alırıq
  • Bütün bu işçi kodlarını yığınımıza qoyuruq
  • Eyni zamanda qarşılaşdığımız idxalatları da əlavə edirik
  • Beləliklə, növbə boşalana qədər bütün idxalatlar hazır olacaq

Hər bir işçinin altındakı işçi sayını tapmaq üçün Java kodu

class Solution 
{
    public int getImportance(List<Employee> employees, int id) 
    {
        int sum=0;
        Queue<Integer>trav=new LinkedList<>();
        trav.add(id);
        while(!trav.isEmpty())
        {
            int cur=trav.remove();
            for(int i=0;i<employees.size();i++)
            {
                if(employees.get(i).id==cur)
                {
                    sum=sum+employees.get(i).importance;
                    List<Integer>nxt=employees.get(i).subordinates;
                    for(int j=0;j<nxt.size();j++)
                        trav.add(nxt.get(j));
                    break;
                }
            }
        }
        return sum;
    }
}

Hər bir işçinin altındakı işçi sayını tapmaq üçün C ++ kodu

class Solution 
{
public:
    int getImportance(vector<Employee*> employees, int id) 
    {
        int sum=0;
        queue<int>trav;
        trav.push(id);
        while(!trav.empty())
        {
            int cur=trav.front();
            trav.pop();
            for(int i=0;i<employees.size();i++)
            {
                if(employees[i]->id==cur)
                {
                    sum=sum+employees[i]->importance;
                    vector<int>nxt=employees[i]->subordinates;
                    for(int j=0;j<nxt.size();j++)
                        trav.push(nxt[j]);
                    break;
                }
            }
        }
        return sum;    
    }
};
[[1,5,[2,3]],[2,3,[]],[3,3,[]]] 1
11

Mürəkkəblik təhlili

Zamanın mürəkkəbliyi = O (V + E)

Kosmik mürəkkəblik = O (n)

V = Diklərin sayı

E = Kənarların sayı

  • Birincisi, V dəfə bitən növbəni boşaltırıq. Döngədə
    • Veriləri növbədən çıxarırıq = O (1) əməliyyatı
    • Klonları əldə etmək üçün bütün qonşu kənarlarından keçərək = O (Adj)
    • Qonşuların əlavə edilməsi = O (1) əməliyyatı
  • Nəhayət, mürəkkəbliyi xülasə edərək = V * (O (1) + O (Adj) + O (1))
  • Hansı O (V) + O (V * Adj) qədər qaynar
  • Zamanın mürəkkəbliyini etmək = O (V + E)
  • Məkan mürəkkəbliyi O (n) dir, çünki bizə lazım olan hər şey növbə idi

References

Translate »