မှန်ကန်သော တြိဂံနံပါတ် LeetCode ဖြေရှင်းချက်

ပြဿနာထုတ်ပြန်ချက်- မှန်ကန်သောတြိဂံနံပါတ် LeetCode Solution ကပြောသည် - ကိန်းပြည့် array နံပါတ်များကိုပေး၍ တြိဂံတစ်ခု၏ဘေးဘက်အလျားအဖြစ် ၎င်းတို့ကိုတြိဂံတစ်ခု၏ဘေးဘက်အလျားအဖြစ်ယူမည်ဆိုပါက ၎င်းတို့ကို တြိဂံဖြစ်အောင်ပြုလုပ်နိုင်သည့် array မှရွေးချယ်ထားသော triplet အရေအတွက်ကို ပြန်ပေးသည်။ ဥပမာ 1- Input- nums = [2,2,3,4] Output- 3 ရှင်းလင်းချက်- အကျုံးဝင်သော ပေါင်းစပ်မှုများမှာ- 2,3,4 (အသုံးပြုသည်...

ဆက်ဖတ်ရန်

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

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

ဆက်ဖတ်ရန်

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

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

ဆက်ဖတ်ရန်

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 ကြားတွင် လမ်းညွှန်မထားသော အစွန်းတစ်ခုရှိသည်။ ဂရပ်တွင်...

ဆက်ဖတ်ရန်

ဒီဇိုင်းထည့်သွင်းပြီး Words Data Structure LeetCode ဖြေရှင်းချက်ကို ရှာဖွေပါ။

ပြဿနာထုတ်ပြန်ချက်- ဒီဇိုင်းထည့်သွင်းခြင်းနှင့် ရှာဖွေခြင်း Words Data Structure LeetCode Solution ကပြောသည် - စကားလုံးအသစ်များထည့်ခြင်းနှင့် string သည် ယခင်ထည့်ထားသည့်စာကြောင်းများနှင့်ကိုက်ညီမှုရှိမရှိရှာဖွေခြင်းတို့ကိုပံ့ပိုးပေးသည့်ဒေတာဖွဲ့စည်းပုံတစ်ခုကိုဒီဇိုင်းဆွဲပါ။ WordDictionary အတန်းကို အကောင်အထည်ဖော်ပါ- WordDictionary() အရာဝတ္တုကို အစပြုသည်။ ပျက်ပြယ်သော addWord(စကားလုံး) သည် ဒေတာတည်ဆောက်ပုံသို့ စကားလုံးကို ပေါင်းထည့်သည်၊ ၎င်းကို နောက်ပိုင်းတွင် ကိုက်ညီနိုင်ပါသည်။ bool search(word) ရှိပါက အမှန်အတိုင်းပြန်ဖြစ်မည်...

ဆက်ဖတ်ရန်

အနည်းဆုံး Path Sum Leetcode ဖြေရှင်းချက်

Problem Statement The Minimum Path Sum LeetCode Solution – "Minimum Path Sum" သည် ပေးထားသော anxm grid တွင် အနုတ်လက္ခဏာမဟုတ်သော ကိန်းပြည့်များပါ၀င်ကြောင်းပြောပြီး လမ်းကြောင်းတစ်လျှောက်ရှိ ဂဏန်းများအားလုံး၏ပေါင်းလဒ်ကို နည်းပါးသွားစေမည့် လမ်းကြောင်းကို အပေါ်မှလက်ဝဲမှ ညာဘက်အောက်သို့ ရှာရန် လိုအပ်ပါသည်။ . ငါတို့သာ လှုပ်ရှားနိုင်တယ်...

ဆက်ဖတ်ရန်

Min Cost Climbing Stairs LeetCode Solution

ပြဿနာ ထုတ်ပြန်ချက် အနည်းဆုံး လှေကားတက်ခြင်း ကုန်ကျစရိတ် LeetCode ဖြေရှင်းချက် - ကုန်ကျစရိတ် [i] သည် လှေကားပေါ်တက်ခြင်း၏ ကုန်ကျစရိတ်ဖြစ်ပြီး ကိန်းပြည့်အခင်းကုန်ကျစရိတ်ကို ပေးပါသည်။ ကုန်ကျစရိတ် ပေးချေပြီးသည်နှင့် တစ်လှမ်း သို့မဟုတ် နှစ်လှမ်းတက်နိုင်သည်။ အညွှန်း 0 ဖြင့် အဆင့်မှ စတင်နိုင်သည် သို့မဟုတ် အဆင့်ဖြင့် ...

ဆက်ဖတ်ရန်

Decode String Leetcode ဖြေရှင်းချက်

ပြဿနာဖော်ပြချက် Decode String LeetCode ဖြေရှင်းချက် – “Decode String” သည် သင့်အား ကုဒ်လုပ်ထားသော စာကြောင်းကို ကုဒ်လုပ်ထားသော စာကြောင်းအဖြစ်သို့ ပြောင်းလဲရန် တောင်းဆိုသည်။ ကုဒ်ဝှက်ခြင်းစည်းမျဉ်းသည် k[encoded_string] ဖြစ်ပြီး၊ လေးထောင့်ကွင်းစကွက်များအတွင်း ကုဒ်လုပ်ထားသော_စာကြောင်းကို k သည် အပြုသဘောဆောင်သော ကိန်းပြည့်ဖြစ်သည့် k အကြိမ်ကြိမ်တိတိ ထပ်ခါတလဲလဲလုပ်နေပါသည်။ ဥပမာ- ထည့်သွင်းခြင်း- s = ”3[a]2[bc]” အထွက်- “aabcbc”…

ဆက်ဖတ်ရန်

ပေးထားသော Sum Condition LeetCode ဖြေရှင်းချက်ကို ကျေနပ်စေသော နောက်ဆက်တွဲအရေအတွက်

ပေးထားသော Sum Condition ကို ကျေနပ်စေသော LeetCode ဖြေရှင်းချက်- ကိန်းပြည့်ဂဏန်းများနှင့် ကိန်းပြည့်ပစ်မှတ်ကို ခင်းကျင်းပေးထားသည့် ပြဿနာဖော်ပြချက် အရေအတွက်က ဆိုသည်။ ၎င်းတွင် အနိမ့်ဆုံးနှင့် အမြင့်ဆုံးဒြပ်စင်၏ ပေါင်းလဒ်သည် ပစ်မှတ်နှင့် လျော့နည်းသည် သို့မဟုတ် ညီမျှသည်ဟု အချည်းနှီးမဟုတ်သော နောက်ဆက်တွဲ နံပါတ်များကို ပြန်ပေးပါ။ အဖြေက များလွန်းတာကြောင့်...

ဆက်ဖတ်ရန်

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Tree

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Tree ပေးသည် ဟုဆိုသည်။ root ဒွိစုံသစ်ပင်၏ “ချိတ်ဆက်ထားသောစာရင်း” အဖြစ် သစ်ပင်ကို ပြားချပ်စေသည်-

  • "လင့်ခ်ချိတ်ထားသောစာရင်း" သည် အလားတူအသုံးပြုသင့်သည်။ TreeNode အတန်းဘယ်မှာလဲ။ right ကလေးညွှန်ပြချက်သည် စာရင်းရှိ နောက် node ကို ညွှန်ပြသည်။ left ကလေးညွှန်းကိန်းသည် အမြဲတမ်းဖြစ်သည်။ null.
  • "လင့်ခ်ချိတ်ထားသောစာရင်း" သည် a ကဲ့သို့ အစဉ်လိုက်ရှိသင့်သည်။ ကြိုတင်မှာယူမှု ဖြတ်သန်း ဒွိသစ်ပင်၏။

 

ဥပမာအား 1:

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Treeinput:

 root = [1,2,5,3,4,null,6]

output:

 [1,null,2,null,3,null,4,null,5,null,6]

ဥပမာအား 2:

input:

 root = []

output:

 []

ဥပမာအား 3:

input:

 root = [0]

output:

 [0]

 

အယ်လ်ဂိုရစ်သမ် –

IDEA –

  • ဒွိသစ်ပင်တစ်ပင်ကို ပြားချပ်စေရန်အတွက်၊ ဘယ်ဘက်သစ်ပင်၏ ညာဘက်ဆုံးဒြပ်စင်ကို ဦးစွာရှာတွေ့မည်ဖြစ်ပြီး ညာဘက်ဆုံးဒြပ်စင်ကိုရပြီးနောက် ပေးထားသောသစ်ပင်၏ ညာဘက်အခွဲနှင့် ထိုနိတ်၏ညာဘက်ညွှန်သူကို ချိတ်ဆက်မည်ဖြစ်သည်။
  • အဆင့် 2 တွင်ကျွန်ုပ်တို့သည် root node ၏ညာဘက်ညွှန်ပြချက်ကိုဘယ်-subtree နှင့်ချိတ်ဆက်ပြီး left-subtree ကို null အဖြစ်သတ်မှတ်မည်ဖြစ်သည်။
  • ယခု အဆင့် 3 တွင် ကျွန်ုပ်တို့၏ root node သည် right-subtree node တစ်ခုဖြစ်ပြီး တူညီသောလုပ်ငန်းစဉ်သည် ဤ node နှင့်ဖြစ်သွားမည်ဖြစ်ပြီး၊ ဘယ်ဘက်အပိုင်းများအားလုံး null ဖြစ်သွားသည်အထိ လုပ်ငန်းစဉ်သည် ဆက်လက်ရှိနေမည်ဖြစ်သည်။

ချိတ်ဆက်ထားသောစာရင်း Leetcode ဖြေရှင်းချက်သို့ Flatten Binary Tree အတွက်ချဉ်းကပ်နည်း

– ပထမတော့၊ ငါ while(root != null) ဖြစ်တဲ့ loop တစ်ခုကို run မယ် ပြီးရင် variable နှစ်ခုကိုယူပြီး ဘယ်ဘက် subtree ကို သိမ်းမယ်။

- ထို့နောက် while(k.left != null) ကို အသုံးပြု၍ ဘယ်ဘက်အခွဲ၏ ညာဖက်အစွန်းကို စစ်ဆေးမည်ဖြစ်ပြီး (k.right = root.right) ကို အသုံးပြု၍ အဆိုပါ node နှင့် ညာဖက်အခွဲနှင့် ချိတ်ဆက်ပေးမည်ဖြစ်သည်။

- ထို့နောက် root node ၏ ညာဘက်ညွှန်ပြချက်ကို ဘယ်ဘက်အခွဲ(root.right=left) ဖြင့် လင့်ခ်ချိတ်ပြီး root node ၏ ဘယ်ဘက်ညွှန်ပြချက်ကို null(root.left=null) အဖြစ် သတ်မှတ်ပြီး ( root = root.right ) ဖြင့် အပ်ဒိတ်လုပ်မည်ဖြစ်သောကြောင့် ယခု root သည် မှန်ကန်ပါသည်။ subtree node များ။

- ဘယ်ဘက်-သစ်ပင် အစိတ်အပိုင်းများအားလုံး ညာဘက်သစ်ပင်ဖြစ်လာသည်အထိ ဤလုပ်ငန်းစဉ်ကို ဆက်လက်လုပ်ဆောင်ပါမည်။ ထို့ကြောင့် ဒွိစုံပင်သည် ပြားသွားလိမ့်မည်။

 

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Tree

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Tree

Python ဖြေရှင်းချက်-

class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        while(root):
            
            if root.left:
                
                k = root.left
                temp = root.left
            
            
                while(k.right):
                    k = k.right
            
                k.right = root.right
            
                root.right = temp
            
                root.left = None
            
            root = root.right

Java ဖြေရှင်းချက်-

class Solution {
    public void flatten(TreeNode root) {       
        while (root != null) {
            if (root.left != null) {
                TreeNode k = root.left;
                TreeNode temp = root.left;
                while (k.right != null) k = k.right;
                k.right = root.right;
                root.right = temp;
                root.left = null;
            }
            root = root.right;
        }
    }
}

အချိန်ရှုပ်ထွေးမှု- O(N)

အာကာသရှုပ်ထွေး: အို (1)

တစ်ကြိမ်သာ ဖြတ်ကျော်ပြီးသည်နှင့်အမျှ အချိန်၏ရှုပ်ထွေးမှုသည် o(n) ဖြစ်လိမ့်မည်။

အပိုနေရာမယူထားသောကြောင့်၊ space complexity သည် o(1) constant extra space ဖြစ်လိမ့်မည်။

အလားတူမေးခွန်း- https://www.tutorialcup.com/interview/linked-list/flattening-linked-list.htm

Translate »