ကွင်းပိတ် Leetcode ဖြေရှင်းချက်အမြင့်ဆုံး Nesting Depth


ခက်ခဲအဆင့် လွယ်ကူသော
မကြာခဏမေးတယ် ဘလွန်းဘာ့ဂ်
ကြိုး

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

ဤပြproblemနာတွင်မှန်ကန်သောကွင်းကွင်းကိုပေးထားသည် ကြိုး (vps) နံပါတ်အချို့၊ အော်ပရေတာအချို့ (ဥပမာ +, -, *) နှင့်ကွင်းကွင်းအချို့ (ဥပမာ '(', ')') ရှိသည်။
ခိုင်လုံသောကွင်းကွင်းကြိုး (vps) များမှာ

  1.  ""
  2. “”” ဆိုတာဘယ်ကိန်းလဲ
  3. "(က)" A သည်ခိုင်လုံသောကွင်းကွင်းဖြစ်လျှင်
  4. “ A * B” သည်အော်ပရေတာတစ်မျိုးဖြစ်ပြီး A နှင့် B သည်ခိုင်လုံသောကွင်းကွင်းဖြစ်သည်။

ကျွန်ုပ်တို့၏ရည်ရွယ်ချက်မှာပေးထားသော string တွင်ကွင်း၏အတိမ်အနက်ကိုရှာဖွေရန်ဖြစ်သည်။
e.g. “(1+(2*3)+((8)/4))+1”
နံပါတ် ၈ မှာအများဆုံးကွင်းထဲမှာဖြစ်ပြီးကွင်းတိမ်အနက်မှာ ၃ ဖြစ်ကြောင်းတွေ့နိုင်တယ်။ ၃ ကိုထုတ်မယ်။

ကွင်းပိတ် Leetcode ဖြေရှင်းချက်အမြင့်ဆုံး Nesting Depth
နောက်ဥပမာတစ်ခုကြည့်ရအောင်။
e.g. “1+(2*3)/(2-1)”
vps 2 * 3 သို့မဟုတ်အခြား vps 2-1 နှစ်ခုစလုံးသည်ကွင်း၏အတိမ်အနက်အတွင်းဖြစ်သည်။ ဆိုလိုသည်မှာ ၁ ။

နမူနာ

s = "(1+(2*3)+((8)/4))+1"
3

ရှင်းလင်းချက်:

Digit 8 သည် string အတွင်းရှိ nested ကွင်းဆက် (၃) ခုအတွင်းမှဖြစ်သည်။

s = "(1)+((2))+(((3)))"
3

ချဉ်းကပ်နည်း

string ကို vps လို့ပေးထားတယ်။ ကွင်းထဲမှာအမြင့်ဆုံးအကျဆုံးကိုရှာရမယ်။ ဒါကြောင့်ကျနော်တို့ကွင်းထဲအာရုံစူးစိုက်ခြင်းနှင့်အခြားဇာတ်ကောင်များ (နံပါတ်များနှင့်အော်ပရေတာ) လျစ်လျူရှုနိုင်ပါတယ်။

အသိုက်အဝန်းအသစ်စတင်သောအခါမှသာကွင်းအတွင်းအတိမ်အနက်သည်မြင့်တက်သွားသည်။ ဆိုလိုသည်မှာစတင်ကွင်းစများ '(' ဆိုလိုသည်မှာကွင်းအတွင်းအတိမ်အနက်သည် ၁ တိုးလာသည်။ ဆိုလိုသည်မှာကွင်းပိတ်လိုက်လျှင်အတိမ်အနက်သည် ၁ သို့လျော့နည်းသွားသည် ') ဆိုလိုသည်မှာအတိမ်အနက်ကို ၁ ခုလျှော့ချသည်ကိုဆိုလိုသည်။

ကျွန်ုပ်တို့၏ချဉ်းကပ်မှုတွင်ကျွန်ုပ်တို့သည်လက်ရှိနက်ရှိုင်းသော variable (let k) နှင့်အမြင့်ဆုံးအနက် (variable ans) ကိုသာအသုံးပြုလိမ့်မည်။ နှစ်ခုစလုံးကိုသုညသို့စတင်သည် (အနက် ၀၀ သည်ကျွန်ုပ်တို့သည်မူလကကွင်းပြင်အားလုံးတွင်မရှိတော့ဟုဆိုလိုသည်) ။ ပြီးတော့ဘယ်ဘက်မှညာသို့ input string ကိုဖြတ်သန်းပါ။ ကျွန်ုပ်တို့ဆွေးနွေးခဲ့သည့်လှည့်ကွက်အရ၊ '(' သင်္ကေတသည်လက်ရှိအတိမ်အနက် k ကို ၁ နှင့်တိုးပါက 'a' ကိုတွေ့ပါက) ကိုတွေ့သည့်အခါ၊ အတိမ်အနက်ကို ၁ ကိုလျှော့ချလိမ့်မည်။
တစ်ခုချင်းစီကိုတိုင်းငါတို့လက်ရှိအတိမ်အနက်အများဆုံးအတိမ်အနက်ထက်ကြီးမြတ်လျှင်စစ်ဆေးပါလိမ့်မယ်။ ဟုတ်ကဲ့လျှင်လက်ရှိအတိမ်အနက်ကိုအမြင့်ဆုံး variable ကိုသတ်မှတ်ပါလိမ့်မည်။
နောက်ဆုံး traversal ပြီးနောက်ကျွန်ုပ်တို့၏ ans variable သည်အတိမ်အနက်ကိုသိုလှောင်ထားပြီး၎င်းကို output ထုတ်ပါလိမ့်မည်။

အကောင်အထည်ဖော်ရေး

Parentheses Leetcode Solution ၏အမြင့်ဆုံးအသိုက်အတွက် C ++ Program

#include <iostream>
using namespace std;

int maxDepth(string s) 
{
    int ans=0,k=0;
    for(int i=0;i<s.length();i++)
    {
        if(s[i]=='(')k++;
        else if(s[i]==')')k--;
        ans=ans>k?ans:k;
    }
    return ans;
}
int main()
{
    cout<<maxDepth("(1)+((2))+(((3)))");
}
3

Parentheses Leetcode Solution ၏အမြင့်ဆုံး Nesting Depth အတွက် Java Program

import java.util.*;
import java.lang.*;

class Solution
{  
    public static int maxDepth(String s) 
    {
        int ans=0,k=0;
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)=='(')k++;
            else if(s.charAt(i)==')')k--;
            ans=Math.max(ans,k);
        }
        return ans;
    }
    
    public static void main(String args[])
    {
        System.out.println(maxDepth("(1)+((2))+(((3)))"));
    }
}
3

အဆိုပါကွင်း Leetcode ဖြေရှင်းချက်၏အများဆုံးအသိုက်အနက်ရှုပ်ထွေးခွဲခြမ်းစိတ်ဖြာခြင်း

အချိန်ရှုပ်ထွေး

အို ()) ကျနော်တို့ပေးထားသောစကားရပ်ဘယ်ဘက်မှညာဘက်ဖြတ်သန်းနေကြသည်။ ထို့ကြောင့် n သည်ပေးထားသော string ၏အရှည်ဖြစ်သောအို (n) ဖြစ်သည်။

အာကာသရှုပ်ထွေးမှု 

အို (၁) အမြဲတမ်းအပိုနေရာများကိုမသုံးပါ ထို့ကြောင့်အာကာသရှုပ်ထွေးအို (1) ဖြစ်ပါတယ်။