ແຈກຢາຍເຂົ້າ ໜົມ ໃຫ້ຄົນ Leetcode Solution  


ລະດັບຄວາມຫຍຸ້ງຍາກ Easy
ຂັ້ນຕອນວິທີ ການຄົ້ນຫາຖານສອງ ລະຫັດ ການສໍາພາດ ການສໍາພາດກ່ອນ LeetCode LeetCodeSolutions ຄະນິດສາດ

ຖະແຫຼງການບັນຫາ  

ໃນບັນຫານີ້, ພວກເຮົາໄດ້ຮັບສອງຕົວເລກ ເຂົ້າ ໜົມ ແລະ ຈຳ ນວນຄົນ. ເຂົ້າ ໜົມ ເລກ ທຳ ອິດແມ່ນ ຈຳ ນວນເຂົ້າ ໜົມ ທີ່ພວກເຮົາມີ. num_people ສະແດງ ຈຳ ນວນຄົນທີ່ພວກເຮົາຕ້ອງແຈກເຂົ້າ ໜົມ.

ກົດລະບຽບຂອງການແຈກຢາຍເຂົ້າ ໜົມ ແມ່ນ:
ພວກເຮົາເລີ່ມຈາກຜູ້ທີ່ຢູ່ເບື້ອງຊ້າຍໃຫ້ເຂົ້າ ໜົມ 1 ກ້ອນແລ້ວພວກເຮົາໃຫ້ເຂົ້າ ໜົມ 2 ກ້ອນແກ່ຄົນທີ 2, ເຂົ້າ ໜົມ 3 ກ້ອນໃຫ້ຄົນທີ 3 ຈົນ n ເດັກນ້ອຍຖອກເຂົ້າ ໜົມ ໃຫ້ຄົນ. ຫລັງຈາກນັ້ນພວກເຮົາເລີ່ມຕົ້ນອີກເທື່ອ ໜຶ່ງ ຈາກຜູ້ທີ່ຢູ່ເບື້ອງຊ້າຍໃຫ້ເດັກ n + 1 ເຂົ້າ ໜົມ ຫຼັງຈາກນັ້ນ n + 2, n + 3. ການແຈກຢາຍວົງຈອນນີ້ຍັງສືບຕໍ່ຈົນກວ່າພວກເຮົາຈະກິນເຂົ້າ ໜົມ ຊະນິດຕ່າງໆເຊັ່ນ: ເມື່ອເຂົ້າ ໜົມ ທີ່ຍັງເຫຼືອຂອງພວກເຮົາ ໜ້ອຍ ກວ່າຄວາມຕ້ອງການໃນປະຈຸບັນ, ພວກເຮົາຈະໃຫ້ເຂົ້າ ໜົມ ທີ່ຍັງເຫຼືອໃຫ້ແກ່ບຸກຄົນປັດຈຸບັນແລະຫຼັງຈາກນັ້ນພວກເຮົາຢຸດ.

ຍົກຕົວຢ່າງ

candies = 7, num_people = 4
[1,2,3,1]

ຄໍາອະທິບາຍ:

ໃນຄັ້ງ ທຳ ອິດ, ans [0] + = 1, ແລະແຖວແມ່ນ [1,0,0,0].
ໃນຄັ້ງທີສອງ, ans [1] + = 2, ແລະແຖວແມ່ນ [1,2,0,0].
ຄັ້ງທີສາມ, ans [2] + = 3, ແລະແຖວແມ່ນ [1,2,3,0].
ສີ່ລ້ຽວ, ans [3] + = 1 (ເພາະວ່າມີເຂົ້າ ໜົມ ດຽວເທົ່ານັ້ນ), ແລະແຖວສຸດທ້າຍແມ່ນ [1,2,3,1].

candies = 10, num_people = 3
[5,2,3]

ຄໍາອະທິບາຍ:

ເບິ່ງ
ຄຳ ແຕກ

ໃນຄັ້ງ ທຳ ອິດ, ans [0] + = 1, ແລະແຖວແມ່ນ [1,0,0].
ໃນຄັ້ງທີສອງ, ans [1] + = 2, ແລະແຖວແມ່ນ [1,2,0].
ຄັ້ງທີສາມ, ans [2] + = 3, ແລະແຖວແມ່ນ [1,2,3].
ສີ່ລ້ຽວ, ans [0] + = 4, ແລະແຖວສຸດທ້າຍແມ່ນ [5,2,3].

ວິທີການທີ 1 (ກຳ ລັງແຮງງານ)  

ວິທີທີ່ງ່າຍທີ່ສຸດແມ່ນໃຫ້ເຂົ້າ ໜົມ l ໃຫ້ຄົນທີ 2 ແລະໃຫ້ຄົນທີ 2 ໃຫ້ຄົນທີ XNUMX ແລະອື່ນໆເພື່ອຍ້າຍໄປເປັນຄົນສຸດທ້າຍ. ຫຼັງຈາກນັ້ນ, ເລີ່ມຕົ້ນອີກຄັ້ງ ໜຶ່ງ ຈາກຄົນ ທຳ ອິດໃຫ້ເດັກກິນເຂົ້າຫນົມຕາມຄວາມ ເໝາະ ສົມ.
ສິ່ງນີ້ສາມາດເຮັດໄດ້ໂດຍໃຊ້ a loop ຮັງ, ໃນທີ່ວົງແຫວນຂ້າງນອກຈະແລ່ນ ສຳ ລັບເງື່ອນໄຂທີ່ມີເຂົ້າ ໜົມ ທີ່ຍັງເຫຼືອຢູ່ຫລືບໍ່. ວົງແຫວນພາຍໃນຈະແລ່ນຈາກຊ້າຍຫາຂວາເຊິ່ງຈະສະຫຼຸບຄຸນຄ່າຂອງແຕ່ລະ ຕຳ ແໜ່ງ ພ້ອມດ້ວຍເຂົ້າ ໜົມ ໃນປະຈຸບັນ. ແຕ່ມັນອາດຈະມີສະຖານະການທີ່ເຂົ້າ ໜົມ ທີ່ຍັງເຫຼືອຢູ່ໃນປະຈຸບັນຈະນ້ອຍກວ່າຄວາມຕ້ອງການໃນປະຈຸບັນ. ດັ່ງນັ້ນ, ມັນຈະມີສະພາບການຖ້າຫາກວ່າຢູ່ໃນວົງຈອນພາຍໃນ.

ໃນເວລາທີ່ເຂົ້າ ໜົມ ທີ່ຕ້ອງການໃນປະຈຸບັນສູງກວ່າເຂົ້າ ໜົມ ທີ່ຍັງເຫຼືອ, ເຂົ້າ ໜົມ ທີ່ຍັງເຫຼືອຈະຖືກມອບໃຫ້ແກ່ບຸກຄົນໃນປະຈຸບັນ. ຖ້າບໍ່ດັ່ງນັ້ນ, ເຂົ້າ ໜົມ ທີ່ ຈຳ ເປັນໃນປະຈຸບັນຈະຖືກມອບໃຫ້ແກ່ຄົນປະຈຸບັນ.

ການຈັດຕັ້ງປະຕິບັດ ສຳ ລັບການແຈກຢາຍເຂົ້າ ໜົມ ໃຫ້ແກ່ປະຊາຊົນ Leetcode Solution

ໂຄງການ C ++

#include <iostream>
#include <vector>
using namespace std;
vector<int> distributeCandies(int candies, int num_people) {
        vector<int>ans;
        /*
        initially everyone has no candy. Thus, answer array is filled up with zeros.
        */
        for(int i=0;i<num_people;i++){
            ans.push_back(0);
        }
        int cur=0;//current requirement is initialized to zero
        while(candies>0){
            for(int i=0;i<num_people;i++){
                cur++; //current requirement increments by one each time.
                if(candies>=cur){ //checks if the remaining candies are greater than current requirement 
                ans[i]+=cur;
                candies-=cur;
                }else{
                    ans[i]+=candies;
                    candies=0;
                }
            }
        }
        return ans;
    }
int main()
{
    int candies=10,num_people=3;
    vector<int>ans=distributeCandies(candies, num_people);
    for(int i:ans)cout<<(i)<<" ";
}
5 2 3

ໂຄງການ Java

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

class Rextester
{  
    public static void main(String args[])
    {
        int candies=10, num_people=3;
        int[]ans=distributeCandies(candies, num_people);
        for(int i:ans)System.out.print(i+" ");
    }
    public static  int[] distributeCandies(int candies, int num_people) {
        int[]ans=new int[num_people];
        Arrays.fill(ans,0);
        int cur=0;
        while(candies>0){
            for(int i=0;i<num_people;i++){
                cur++;
                if(candies>=cur){
                ans[i]+=cur;
                candies-=cur;
                }else{
                    ans[i]+=candies;
                    candies=0;
                }
            }
        }
        return ans;
    }
}
5 2 3

ການວິເຄາະຄວາມສັບສົນ ສຳ ລັບການແຈກຢາຍເຂົ້າ ໜົມ ໃຫ້ກັບຜູ້ຄົນ Leetcode Solution

ຄວາມສັບສົນເວລາ

O (ສູງສຸດ (sqrt (ເຂົ້າ ໜົມ ຖົ່ວ))): ຄວາມຕ້ອງການໃນປະຈຸບັນເພີ່ມຂື້ນ 1 ໃນທຸກໆວົງຈອນ. ສະນັ້ນ, ຈຳ ນວນເຂົ້າ ໜົມ ທີ່ຫຼຸດລົງຄັ້ງ ທຳ ອິດໂດຍ 2 ຫຼັງຈາກນັ້ນກໍ່ຈະຫຼຸດລົງ XNUMX ແລະອື່ນໆ.
ສະນັ້ນ, ຫຼັງຈາກເວລາ t, ຈຳ ນວນເຂົ້າ ໜົມ ທີ່ຫຼຸດລົງແມ່ນ t * (t + 1) / 2 ຫຼືປະມານ t ^ 2 ເຂົ້າ ໜົມ ກໍ່ຖືກຫຼຸດລົງຫຼັງຈາກເວລາ t.
ສະນັ້ນ, ເພື່ອຫຼຸດເຂົ້າ ໜົມ ເຄັກທີ່ພວກເຮົາຕ້ອງການເວລາ sqrt (c).
ດັ່ງນັ້ນ, ຄວາມສັບສົນຂອງເວລາແມ່ນ sqrt (ເຂົ້າ ໜົມ).

ເບິ່ງ
ການຊອກຫາ ຄຳ ສັບ Leetcode Solution

ຄວາມສັບສົນໃນອະວະກາດ 

O (num_people): ຂບວນການຂອງຂະ ໜາດ num_people ແມ່ນຖືກ ນຳ ໃຊ້. ດັ່ງນັ້ນ, ຄວາມສັບສົນໃນພື້ນທີ່ແມ່ນ O (num_people).

ວິທີການ 2 (ການຄົ້ນຫາຖານສອງ 

ໃນວິທີການທີ່ຜ່ານມາ, ພວກເຮົາໄດ້ໃຫ້ເຂົ້າ ໜົມ ໃຫ້ແກ່ແຕ່ລະຄົນໂດຍແຕ່ລະຄົນ. ຫຼັງຈາກນັ້ນ, ອີກເທື່ອ ໜຶ່ງ ພວກເຮົາເລີ່ມຕົ້ນໃຫ້ເຂົ້າ ໜົມ ຕັ້ງແຕ່ເລີ່ມຕົ້ນ. ນີ້ແມ່ນຂະບວນການທີ່ໃຊ້ເວລາຢ່າງແນ່ນອນ.
ດັ່ງນັ້ນ, ໃນວິທີການນີ້, ພວກເຮົາໂດຍພື້ນຖານແລ້ວຈະປະຕິບັດຕາມຂັ້ນຕອນດັ່ງຕໍ່ໄປນີ້.

ຫນ້າທໍາອິດ, ພວກເຮົາຄິດໄລ່ຈໍານວນທັງຫມົດຂອງການປະຕິບັດເຂົ້າຫນົມຕ່າງໆທີ່ສົມບູນ. ຕົວຢ່າງ: ພວກເຮົາຈະຊອກຫາປະຊາຊົນທັງ ໝົດ ທີ່ໄດ້ຮັບເຂົ້າຫນົມແນ່ນອນຕາມກົດລະບຽບ.
ການແຈກຢາຍເລີ່ມຈາກ 1 ແລະເພີ່ມຂື້ນໂດຍ 1. ດັ່ງນັ້ນການແຈກຢາຍຕ້ອງມີບາງຢ່າງເຊັ່ນ: 1 2 3 4 5 6. ຕອນນີ້ສົມມຸດວ່າພວກເຮົາໄດ້ໃຫ້ເຂົ້າ ໜົມ ຫວານ 6 ຄັ້ງຢ່າງປະສົບຜົນ ສຳ ເລັດ. ຈາກນັ້ນ ຈຳ ນວນເຂົ້າ ໜົມ ທີ່ບໍລິໂພກທັງ ໝົດ ແມ່ນລວມຕົວເລກ ທຳ ມະຊາດ 6 ຕົວ ທຳ ອິດ.
ດັ່ງນັ້ນພວກເຮົາສາມາດເວົ້າໄດ້ວ່າໃນເວລາໃດກໍ່ຕາມ, ຈຳ ນວນເຂົ້າ ໜົມ ທີ່ບໍລິໂພກແມ່ນ ຈຳ ນວນຕົວເລກ ທຳ ມະຊາດທີ່ n ແມ່ນການແຈກຢາຍເຮັດຈົນຮອດຈຸດເວລານັ້ນ.
ຕອນນີ້ພວກເຮົາຕ້ອງການການແຈກຢາຍທີ່ປະສົບຜົນ ສຳ ເລັດສູງສຸດຕາມກົດລະບຽບ. ie ພວກເຮົາຕ້ອງການມູນຄ່າສູງສຸດຂອງ n ເຊັ່ນວ່າ n (n + 1) / 2 <= ຈຳ ນວນເຂົ້າ ໜົມ ທັງ ໝົດ.

ເພື່ອຊອກຫາມູນຄ່າຂອງ n, ພວກເຮົາມີຫຼາຍວິທີການ. ພວກເຮົາສາມາດແກ້ໄຂການເຮັດວຽກຂອງ quadratic ສຳ ລັບ n ຫຼືພວກເຮົາສາມາດເລີ່ມຕົ້ນໄດ້ n = 1 ແລະຮັກສາການປ່ຽນແທນຄ່າຂອງ n ດ້ວຍຄ່າເພີ່ມຂອງ n ໂດຍ 1 ເສັ້ນ. ແຕ່ວິທີແກ້ໄຂທີ່ ເໝາະ ສົມທີ່ສຸດແມ່ນໃຊ້ການຄົ້ນຫາຖານສອງຢູ່ບ່ອນນີ້.

ການຄົ້ນຫາຖານສອງເພື່ອຊອກຫາຄ່າຂອງ n.

ເພື່ອໃຊ້ການຄົ້ນຫາຖານສອງຢູ່ທີ່ນີ້, ພວກເຮົາຕ້ອງຮູ້ຂອບເຂດທີ່ n ສາມາດມາ. ພວກເຮົາສາມາດເວົ້າໄດ້ວ່າຢ່າງ ໜ້ອຍ ມູນຄ່າຂອງ n ສາມາດເປັນ 1 ໄດ້ເພາະວ່າຂໍ້ ຈຳ ກັດຂອງເຂົ້າ ໜົມ ແມ່ນຢ່າງ ໜ້ອຍ 1. ດັ່ງນັ້ນ, ຢ່າງ ໜ້ອຍ ພວກເຮົາສາມາດໃຫ້ເຂົ້າ ໜົມ 1 ໜ່ວຍ ໃຫ້ຄົນ ທຳ ອິດ, ສະນັ້ນເຮັດໃຫ້ການແຈກຢາຍ ໜຶ່ງ ຢ່າງປະສົບຜົນ ສຳ ເລັດ (ດັ່ງນັ້ນ, ຈຳ ກັດ l = 1) . ຂອບເທິງສຸດຂອງ n ສາມາດສັບຊ້ອນໃນການຄິດໄລ່, ສະນັ້ນພວກເຮົາພຽງແຕ່ໃຫ້ມັນມີຄ່າເທົ່າກັບຕົວເລກໃຫຍ່ໂດຍຕົວເຮົາເອງ (ໃຫ້ຂໍ້ຜູກມັດເທິງ = = 1000000).

ເບິ່ງ
ບັນທຶກການເຂົ້າຮ່ວມຂອງນັກຮຽນ I Leetcode Solution

ຕອນນີ້ພວກເຮົາຕ້ອງການຈຸດ n ລະຫວ່າງ l ແລະ r ເຊິ່ງເປັນຄ່າສູງສຸດທີ່ ເໝາະ ສົມກັບສົມຜົນ.
n (n + 1) / 2 <= ຈຳ ນວນເຂົ້າ ໜົມ ທັງ ໝົດ.
ຖ້າຈຸດໃດ (ປ່ອຍໃຫ້ຈຸດກາງ) ລະຫວ່າງ l ແລະ r ພໍໃຈກັບສົມຜົນຂ້າງເທິງ. ແລະຈຸດຕໍ່ໄປ (ໝາຍ ເຖິງກາງ +1) ບໍ່ສາມາດຕອບສະ ໜອງ ສົມຜົນໄດ້. ຫຼັງຈາກນັ້ນກາງຈະເປັນ ຈຳ ນວນສູງສຸດຂອງການແຈກຢາຍທີ່ປະສົບຜົນ ສຳ ເລັດ.

ຫຼັງຈາກທີ່ພວກເຮົາໄດ້ພົບເຫັນ ຈຳ ນວນການປະຕິບັດທີ່ ສຳ ເລັດ (ກາງ), ພວກເຮົາສາມາດຄິດໄລ່ ຈຳ ນວນຮອບວຽນຂອງການແຈກຢາຍທີ່ສົມບູນ, ເຊິ່ງແມ່ນ k = ກາງ /ຈຳ ນວນຄົນ.

ດຽວນີ້ພວກເຮົາ ກຳ ລັງຄິດໄລ່ເຂົ້າ ໜົມ ໃຫ້ກັບແຕ່ລະຄົນຫຼັງຈາກຮອບວຽນ k ສຳ ເລັດແລ້ວ.

ແຈກຢາຍເຂົ້າ ໜົມ ໃຫ້ຄົນ Leetcode SolutionPin

 

ດັ່ງນັ້ນ, ພວກເຮົາໄດ້ຄົ້ນພົບ ຄຳ ສັບທາງຄະນິດສາດເພື່ອ ຄຳ ນວນ ຈຳ ນວນເຂົ້າ ໜົມ ຫລັງຈາກ k ຮອບວຽນສົມບູນ. ຈະເປັນແນວໃດກ່ຽວກັບ k + 1 ຂອງຮອບວຽນທີ່ບໍ່ຄົບຖ້ວນ.
ໃນຮອບວຽນ k + 1 ທີ່ບໍ່ຄົບຖ້ວນ, ພວກເຮົາສາມາດເວົ້າໄດ້ຢ່າງງ່າຍດາຍວ່າການປະຕິບັດເຂົ້າ ໜົມ ທີ່ປະສົບຜົນ ສຳ ເລັດຈະບໍ່ໄປຫາຄົນອື່ນ, ເຂົ້າ ໜົມ ຂອງພວກເຮົາຈະ ສຳ ເລັດຢູ່ບ່ອນໃດບ່ອນ ໜຶ່ງ ລະຫວ່າງ.

ພວກເຮົາໄດ້ຄິດໄລ່ແລ້ວວ່າຄວາມ ສຳ ເລັດທີ່ ສຳ ເລັດຜົນສຸດທ້າຍຂອງພວກເຮົາແມ່ນກາງແລ້ວ. ແລະກາງ%ຈຳ ນວນຄົນ ບຸກຄົນທີ່ຈະໄດ້ຮັບການກິນເຂົ້າຫນົມຫວານກາງເດືອນທີ່. ແລະຄົນຕໍ່ໄປຈະໄດ້ຮັບເຂົ້າ ໜົມ ທີ່ເຫລືອຢູ່.

ແຈກຢາຍເຂົ້າ ໜົມ ໃຫ້ຄົນ Leetcode Solution
ດັ່ງນັ້ນພວກເຮົາຈະເພີ່ມການແຈກຢາຍວົງຈອນທີ່ບໍ່ຄົບຖ້ວນຄັ້ງສຸດທ້າຍນີ້ໃຫ້ເປັນ% ເຄິ່ງ ທຳ ອິດຂອງພວກເຮົາຈຳ ນວນຄົນ ແລະ 1 + ກາງ%ຈຳ ນວນຄົນ ຈະໄດ້ຮັບເຂົ້າ ໜົມ ທີ່ຍັງເຫຼືອທັງ ໝົດ.

ການຈັດຕັ້ງປະຕິບັດ ສຳ ລັບການແຈກຢາຍເຂົ້າ ໜົມ ໃຫ້ແກ່ປະຊາຊົນ Leetcode Solution

ໂຄງການ C ++

#include <iostream>
#include <vector>
using namespace std;
vector<int> distributeCandies(int candies, int num_people) {
        long l=0,r=1000000;
        long mid=0;
        /*
        searching the last successful fulfilment point mid
        */
        while(l<=r){
            mid=l+(r-l)/2;
            long a=((mid+1)*(mid))/2;
            long c=((mid+2)*(mid+1))/2;
            if(a<=candies && c>candies)break;
            else if(a>candies)r=mid;
            else l=mid;
        }
        long k=mid/num_people;
        /*
        here k is the number of complete cycles
        */
        long ans[num_people];
        int i=0;
        for(i=0;i<num_people;i++){
            ans[i]=((k*(k-1)*num_people)/2)+(i+1)*k;//calculating the number of candies to each person after k complete cycles.
        }
        for(i=0;i<mid%num_people;i++){
            ans[i]+=((k*num_people)+i+1);//giving candies to first mid%num_people in k+1 th incomplete cycle.
        }
        ans[i%num_people]+=candies-(mid*(mid+1)/2);// giving all the remaining candies to next person 
        vector<int> ans1;
        for(i=0;i<num_people;i++){
            ans1.push_back((int)(ans[i]));
        }
        return ans1;
        
    }
int main()
{
    int candies=10,num_people=3;
    vector<int>ans=distributeCandies(candies, num_people);
    for(int i:ans)cout<<(i)<<" ";
}
5 2 3

ໂຄງການ Java

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

class Rextester
{  
    public static void main(String args[])
    {
        int candies=10, num_people=3;
        int[]ans=distributeCandies(candies, num_people);
        for(int i:ans)System.out.print(i+" ");
    }
    public static  int[] distributeCandies(int candies, int num_people) {
       
        long l=0,r=1000000;
        long mid=0;
        /*
        searching the last successful fulfilment point mid
        */
        while(l<=r){
            mid=l+(r-l)/2;
            long a=((mid+1)*(mid))/2;
            long c=((mid+2)*(mid+1))/2;
            if(a<=candies && c>candies)break;
            else if(a>candies)r=mid;
            else l=mid;
        }
        long k=mid/num_people;
        /*
        here k is the number of complete cycles
        */
        long[]ans=new long[num_people];
        int i=0;
        for(i=0;i<num_people;i++){
            ans[i]=((k*(k-1)*num_people)/2)+(i+1)*k;//calculating the number of candies to each person after k complete cycles.
        }
        for(i=0;i<mid%num_people;i++){
            ans[i]+=((k*num_people)+i+1);//giving candies to first mid%num_people in k+1 th incomplete cycle.
        }
        ans[i%num_people]+=candies-(mid*(mid+1)/2);// giving all the remaining candies to next person
        int[]ans1=new int[num_people];
        for(i=0;i<ans1.length;i++){
            ans1[i]=(int)(ans[i]);
        }
        return ans1;
    }
}
5 2 3

ການວິເຄາະຄວາມສັບສົນ ສຳ ລັບການແຈກຢາຍເຂົ້າ ໜົມ ໃຫ້ກັບຜູ້ຄົນ Leetcode Solution

ຄວາມສັບສົນເວລາ

O (num_people):  ເພື່ອຊອກຫາຈໍານວນຂອງຄວາມສໍາເລັດທີ່ປະສົບຜົນສໍາເລັດ, ພວກເຮົາກໍາລັງໃຊ້ a ໃນຂະນະທີ່ loop ເຊິ່ງຈະດໍາເນີນການບັນທຶກ (10^6) ເທື່ອໃນກໍລະນີຮ້າຍແຮງທີ່ສຸດປະມານ 32. ຈາກນັ້ນພວກເຮົາໄດ້ດໍາເນີນການວົນຮອບເປັນຈໍານວນເທື່ອລະຄົນ. ດັ່ງນັ້ນ, ເວລາສົມບູນແມ່ນ O (num_people+32) ຫຼື O (num_people).

ເບິ່ງ
ການ ດຳ ເນີນງານ XOR ໃນ Array Leetcode Solution

ໝາຍ ເຫດ: ສູດການຄິດໄລ່ນີ້ຈະດີທີ່ສຸດເມື່ອ ຈຳ ນວນເຂົ້າ ໜົມ ມີຫຼາຍກ່ວາ ຈຳ ນວນຄົນ. ເນື່ອງຈາກວ່າ, ສູດການຄິດໄລ່ນີ້ບໍ່ໄດ້ຂື້ນກັບ ຈຳ ນວນເຂົ້າ ໜົມ.

ຄວາມສັບສົນໃນອະວະກາດ 

O (num_people): ຂບວນການຂອງຂະ ໜາດ num_people ແມ່ນຖືກ ນຳ ໃຊ້. ດັ່ງນັ້ນ, ຄວາມສັບສົນໃນພື້ນທີ່ແມ່ນ O (num_people).

1