မက်စ်ဆက်တိုက် Ones Leetcode ဖြေရှင်းချက်


ခက်ခဲအဆင့် လွယ်ကူသော
မကြာခဏမေးတယ် အမေဇုံ
အခင်းအကျင်း

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

Max Consecutive Ones ပြproblemနာမှာ binary array တစ်ခုပေးထားတယ်။ ပေးထားသောခင်းကျင်းပြသထားသည့်အများဆုံးဆက်တိုက်အရေအတွက်ကိုကျွန်ုပ်တို့ရှာရမည်။
input array ထဲမှာ ၀ နဲ့ ၁ ကသာပါမယ်။

နမူနာ

[1,1,0,1,1,1]
3

ရှင်းလင်းချက်:
ပထမဂဏန်းနှစ်လုံးသို့မဟုတ်နောက်ဆုံးသုံးဂဏန်းသည်ဆက်တိုက် ၁ လုံးဖြစ်သည်။
အများဆုံးဆက်တိုက် 1s သည် 3 ဖြစ်သည်။

[0,1,0]
1

ရှင်းလင်းချက်:
အများဆုံးဆက်တိုက် 1s သည် 1 ဖြစ်သည်။

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

ဒီပြproblemနာကိုဖြေရှင်းဖို့အတွက်ကျွန်တော်တို့က array ထဲမှာရှိတဲ့အညွှန်းကိန်းနှစ်ခုကိုဖြတ်ပြီးသွားနိုင်ပါတယ် ကွင်းဆက်စဉ် nested အောက်ပါ algorithm ဖြင့်:

၁။ ဖြတ်သန်းသွားသောကာလအတွင်းနောက်ဆုံးအမြင့်ဆုံးဆက်တိုက် ၁ စက္ကန့်ကိုသိမ်းဆည်းမည့် variable တစ်ခုကိုဖန်တီးပါ။
၂။ i ကိုပထမဆုံး index နဲ့ variable တစ်ခုကိုဖန်တီးပြီးအစပြုပါ။
၃။ i <array အရွယ်မရောက်မှီတိုင်အောင်ယခု loop ကို run ပါ။
၄။ ကွင်းဆက်အတွင်းရှိလက်ရှိအညွှန်းကိန်းရှိ i သည် 4 လားမဟုတ်စစ်ဆေးသည်။ အကယ်၍ 1 နှင့်မညီလျှင် i ကိုအတိုးမြှောက်ပါ။ ကျန် 1 သည်ညီမျှလျှင် count variable တစ်ခုကို ဖန်တီး၍ ၀ နှင့်စတင်ပါ။ nested while loop ကို run ပါ။ ထို့နောက် nested စဉ် loop အတွင်းရှိ 1s ဆက်တိုက်အတွက် array ကိုဖြတ်သန်းပါ။ ဆိုလိုသည်မှာ num [i] သည် 0 နှင့်ညီမျှလျှင် travers ခင်းသည်လက်ရှိဆက်တိုက် 1s ၏အရေအတွက်ကိုဆက်လက်အောက်ပါအတိုင်းဖြစ်သည်။

မက်စ်ဆက်တိုက်
5. ခင်းကျင်းမှု၏ 0 သို့မဟုတ်အဆုံးကိုတွေ့ပြီးသည့်နောက်၊ ၎င်းသည်တန်ဖိုးအဟောင်းကိုလက်ရှိ variable ဆက်တိုက် 1s count နှင့်နှိုင်းယှဉ်ခြင်းအားဖြင့်အများဆုံး variable ကို update လုပ်ပါ။
နေစဉ် loop ကိုပြီးဆုံးပြီးနောက် 6. အများဆုံးတန်ဖိုးကိုပြန်သွားပါ။

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

မက်စ်ဆက်တိုက်သူများ Leetcode ဖြေရှင်းချက်များအတွက် C ++ အစီအစဉ်

#include <bits/stdc++.h>
using namespace std;

int findMaxConsecutiveOnes(vector<int>& nums) {

    int maximum=0;
    int i=0;

    while(i<nums.size())
    {
        int conOnes=0;
        while(i< nums.size() && nums[i]==1)
        {
            conOnes++;
            i++;
        }

        maximum=max(maximum,conOnes);
        i++;
    }

    return maximum; 
}

int main() 
{
    vector<int> nums={1,1,0,1,1,1};
    cout<<findMaxConsecutiveOnes(nums)<<endl;

  return 0; 
}
3

မက်စ်ဆက်တိုက်သူများ Leetcode ဖြေရှင်းနည်းအတွက် Java အစီအစဉ်

import java.lang.*;

class MaxOnes
{  
    public static int findMaxConsecutiveOnes(int[] nums) 
    {
        int maximum=0;
        int i=0;

        while(i<nums.length)
        {
        int conOnes=0;
        while(i< nums.length && nums[i]==1)
        {
        conOnes++;
        i++;
        }

        maximum=Math.max(maximum,conOnes);

        i++;
        }

        return maximum; 

    }
    
    public static void main(String args[])
    {
        int nums[]={1,1,0,1,1,1};

        System.out.println(findMaxConsecutiveOnes(nums));
        
    }
}
3

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

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

အို (N): ကျွန်ုပ်တို့သည် index ကိုစတင်ခြင်းမှနောက်ဆုံးအညွှန်းသို့အစဉ်လိုက်ခင်းကျင်းပြသမှုကိုဖြတ်ပြီးတစ်ကြိမ်သာအညွှန်းကိုသွားသည်။ ထို့ကြောင့်အချိန်ရှုပ်ထွေး linear O (N) ဖြစ်လိမ့်မည်။

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

အို (၁) ကျွန်ုပ်တို့သည်မည်သည့်အပိုအာကာသကိုမျှအသုံးမပြုပါ။