PHP တွင် Disjoint Set (Union-Find Algorithm)

ထုတ်ဝေသည်- ၂၀၂၅၊ ဖေဖော်ဝါရီ ၁၆ UTC ၁၂:၃၄:၄၉
နောက်ဆုံး မွမ်းမံပြင်ဆင်သည်- ၂၀၂၆၊ ဇန်နဝါရီ ၂၆ UTC ၁၀:၃၇:၁၇

ဤ ဆောင်းပါး သည် အနည်းဆုံး ကျယ်ပြန့် သော သစ်ပင် အယ်ဂိုရီသမ် များ တွင် ယူနီယွန်-ရှာဖွေ အတွက် အများအားဖြင့် အသုံးပြု သော ၊ အဆက်အသွယ် မ ရှိ သော ဒေတာ ဖွဲ့စည်းပုံ ၏ ပီပီပီ အကောင်အထည်ဖော် မှု တစ် ခု ကို ဖော်ပြ ထား သည် ။

ဤစာမျက်နှာကို လူများတတ်နိုင်သမျှ ဝင်ရောက်ကြည့်ရှုနိုင်စေရန်အတွက် ဤစာမျက်နှာကို အင်္ဂလိပ်မှ စက်ဖြင့် ဘာသာပြန်ထားခြင်းဖြစ်ပါသည်။ ကံမကောင်းစွာဖြင့်၊ စက်ဘာသာပြန်ခြင်းသည် ပြီးပြည့်စုံသောနည်းပညာမဟုတ်သေးသောကြောင့် အမှားအယွင်းများဖြစ်ပေါ်လာနိုင်သည်။ သင်နှစ်သက်ပါက မူရင်းအင်္ဂလိပ်ဗားရှင်းကို ဤနေရာတွင် ကြည့်ရှုနိုင်ပါသည်။

Disjoint Set (Union-Find Algorithm) in PHP

အဆက်အသွယ် မ ရှိ သော အစုအဝေး ( အများအားဖြင့် ယူနီယံ - ရှာဖွေ ခြင်း အတွက် အများအားဖြင့် အသုံးပြု သော ) သည် ဒြပ်စင် များ ၏ ခွဲခြား မှု တစ် ခု ကို မ ဆက်စပ် သော ( အထပ်ထပ် မ ရှိ သော ) အစုအဝေး များ အဖြစ် စီမံ ခန့်ခွဲ ရန် အသုံးပြု သော အချက်အလက် ဖွဲ့စည်း မှု တစ် ခု ဖြစ် သည် ။ ၎င်း သည် အဓိက လုပ်ဆောင် ချက် နှစ် ခု ကို ထိရောက် စွာ ထောက်ပံ့ ပေး သည် ။

Find: မည်သည့်အစိတ်အပိုင်းတစ်ခု ပိုင်ဆိုင်သည်ကို ဆုံးဖြတ်သည်။
Union: အစုံနှစ်စုံကို ပေါင်းစပ်ပါ။

ဤ ဖွဲ့စည်းပုံ သည် အထူးသဖြင့် ခရုစကာ ၏ အယ်ဂိုရီသမ် ကဲ့သို့ ၊ အနည်းဆုံး ကျယ်ပြန့် သော သစ်ပင် အယ်ဂိုရီသမ် များ တွင် အသုံးဝင် သည် ။

အစုများကို ထိရောက်စွာ ပေါင်းစပ်ရန် Disjoint Set ၏ အောက်ပါ PHP အကောင်အထည်ဖော်မှုအပေါ် မှီခိုအားထားသော ကျပန်း မျောက်မျောများ ဖန်တီးရန် အသုံးပြုသော Kruskal ၏ အယ်ဂိုရီသမ်ကို အကောင်အထည်ဖော်မှုတစ်ခု ကျွန်ုပ်တွင် ရှိသည်။ စိတ်ဝင်စားတယ်ဆိုရင် ဒီမှာ လုပ်ဆောင်နေတာကို တွေ့နိုင်ပါတယ်– Kruskal ၏ Algorithm Maze မီးစက်

ဘာပဲဖြစ်ဖြစ်၊ ဒါက Disjoint Set ရဲ့ ကျွန်မရဲ့ PHP အကောင်အထည်ဖော်မှုပါ။

class DisjointSet 
{
    private $parent = [];
    private $rank   = [];

    public function __construct($size) 
    {
        for ($i = 0; $i < $size; $i++) 
        {
            $this->parent[$i]   = $i;
            $this->rank[$i]     = 0;
        }
    }

    public function find($x) 
    {
        if ($this->parent[$x] != $x) 
        {
            $this->parent[$x] = $this->find($this->parent[$x]);
        }

        return $this->parent[$x];
    }

    public function union($x, $y) 
    {
        $rootX = $this->find($x);
        $rootY = $this->find($y);

        if ($rootX != $rootY) 
        {
            if ($this->rank[$rootX] > $this->rank[$rootY]) 
            {
                $this->parent[$rootY] = $rootX;
            }
            elseif ($this->rank[$rootX] < $this->rank[$rootY]) 
            {
                $this->parent[$rootX] = $rootY;
    
            }
            else
            {
                $this->parent[$rootY] = $rootX;
                $this->rank[$rootX]++;
            }
        }
    }
}

ပျော်စရာအတွက် မျောက်မျောများ ဖန်တီးခြင်းအပြင် Disjoint Set ဒေတာဖွဲ့စည်းပုံကို တကယ့်ဘဝဇာတ်လမ်းများအတွက်လည်း အမှန်တကယ် အသုံးပြုနိုင်ပါသည်။

ဥပမာ၊ သုံးစွဲသူများအား သူငယ်ချင်းအသစ်များကို အကြံပေးလိုသည့် လူမှုကွန်ရက်တစ်ခုကို မြင်ယောင်ကြည့်ပါ၊ ထို့နောက် ဤသူငယ်ချင်း ဆက်ဆံရေးရှိပြီးသားလူခြောက်ဦးရှိသည်ဆိုပါစို့။

၁ နဲ့ ၂ က သူငယ်ချင်းတွေပါ။
၂ နဲ့ ၃ က သူငယ်ချင်းတွေပါ။
၄ နဲ့ ၅ က သူငယ်ချင်းတွေပါ။
၆ တွင် သူငယ်ချင်း များ မ ရှိ ပါ ။

Union-Find အယ်ဂိုရီသမ်ကို ဤသီးခြားအုပ်စုများတွင် အသုံးပြုခြင်းဖြင့် အောက်ပါအချက်များကို တွေ့ရှိသင့်သည်။

အုပ်စုတစ်စုတွင် ၁၊ ၂ နှင့် ၃ တို့ဖြစ်သည်။
ဒုတိယအုပ်စုတွင် ၄ နှင့် ၅ တို့ဖြစ်သည်။
တတိယအုပ်စုတွင် ၆ ဦး။

ယင်းကိုအခြေခံ၍ ၁ နှင့် ၃ သည် သူငယ်ချင်းများဖြစ်သင့်သည်ဟု အကြံပြုခြင်းသည် ယုတ္တိရှိပေမည်၊ အကြောင်းမှာ သူတို့တွင် တူညီသော ပုဂ္ဂိုလ် ၂ ရှိကြသောကြောင့်ဖြစ်သည်။

တကယ်တော့ ဒီလို ဥပမာလေးတစ်ခုမှာ ဒီအချက်ကို သင်ကိုယ်တိုင် အလွယ်တကူ တွေ့မြင်နိုင်ပေမဲ့ ဒီအယ်ဂိုရီသမ်ရဲ့ ထိရောက်မှုက လူသန်းပေါင်းများစွာနဲ့ သူငယ်ချင်းအုပ်စုတွေဆီ ဖြစ်နိုင်ခြေရှိရှိ အတိုင်းအတာကို အတိုင်းအတာတစ်ခု တိုးချဲ့နိုင်စေတယ်။