این برنامه جاوا کلیه زیر مجموعه های ممکن (مجموعه برق) یک آرایه معین را با استفاده از backtracking تولید می کند

مرجع YouTube Video: Link
این برنامه جاوا کلیه زیر مجموعه های ممکن (مجموعه برق) یک آرایه معین را با استفاده از آن تولید می کند پس اندازبشر بیایید قدم به قدم آن را بشکنیم.

اجازه دهید آرایه ای باشد [1, 2, 3]بشر

درک کد

این برنامه از دو کارکرد اصلی تشکیل شده است:

1. subsets(int[] nums):

   • لیست نتیجه را آغاز می کند (list) برای ذخیره تمام زیر مجموعه ها.
   • آرایه ورودی را مرتب می کند (اگرچه مرتب سازی در این مورد غیر ضروری است).
   • عملکرد یاور را فراخوانی می کند backtrack() برای تولید زیر مجموعه ها.

2. backtrack(List> list, List tempList, int [] nums, int start):

   • زیر مجموعه فعلی را اضافه می کند (tempList) به لیست نتیجه (list).
   • از طریق اعداد در nums، اضافه کردن یک عنصر در هر زمان tempList، و به صورت بازگشتی زیر مجموعه های بعدی را بررسی می کند.
   • پس از بازگشت ، آخرین عنصر را به پشت پرده برداشته و سایر امکانات را کشف می کند.

اجرای گام به گام

بیایید فرض کنیم ورودی:

nums = [1, 2, 3]

مرحله 1: اعدام را شروع کنید

• subsets(nums) با nums = [1, 2, 3]
• list به عنوان یک لیست خالی آغاز می شود: list = []
• backtrack() با:

  backtrack(list, tempList = [], nums = [1, 2, 3], start = 0)

مرحله 2: اولین تماس به backtrack

• tempList = [] به list
• list = [[]]
• برای تکرار حلقه 1 (i = 0):
  • اضافه کردن 1 به tempList → tempList = [1]
  • فراخوانی backtrack(list, tempList = [1], nums, start = 1)

مرحله 3: تماس دوم به backtrack

• tempList = [1] به list
• list = [[], [1]]
• برای تکرار حلقه 1 (i = 1):
  • اضافه کردن 2 به tempList → tempList = [1, 2]
  • فراخوانی backtrack(list, tempList = [1, 2], nums, start = 2)

مرحله 4: تماس سوم به backtrack

• tempList = [1, 2] به list
• list = [[], [1], [1, 2]]
• برای تکرار حلقه 1 (i = 2):
  • اضافه کردن 3 به tempList → tempList = [1, 2, 3]
  • فراخوانی backtrack(list, tempList = [1, 2, 3], nums, start = 3)

مرحله 5: تماس چهارم به backtrack

• tempList = [1, 2, 3] به list
• list = [[], [1], [1, 2], [1, 2, 3]]
• start = 3 (خارج از مرزها) ، بنابراین عملکرد برمی گردد
• Backtrack: حذف 3 → tempList = [1, 2]

مرحله ششم: بازگشت به تماس سوم

• حلقه را در تماس سوم ادامه دهید (i = 2 تمام شد)
• Backtrack: حذف 2 → tempList = [1]
• برای تکرار حلقه 2 (i = 2):
  • اضافه کردن 3 به tempList → tempList = [1, 3]
  • فراخوانی backtrack(list, tempList = [1, 3], nums, start = 3)

مرحله 7: تماس پنجم به backtrack

• tempList = [1, 3] به list
• list = [[], [1], [1, 2], [1, 2, 3], [1, 3]]
• Backtrack: حذف 3 → tempList = [1]
• Backtrack: حذف 1 → tempList = []

مرحله 8: بازگشت به تماس دوم

• برای تکرار حلقه 2 (i = 1):
  • اضافه کردن 2 به tempList → tempList = [2]
  • فراخوانی backtrack(list, tempList = [2], nums, start = 2)

مرحله 9: تماس ششم به backtrack

• tempList = [2] به list
• list = [[], [1], [1, 2], [1, 2, 3], [1, 3], [2]]
• برای تکرار حلقه 1 (i = 2):
  • اضافه کردن 3 به tempList → tempList = [2, 3]
  • فراخوانی backtrack(list, tempList = [2, 3], nums, start = 3)

مرحله 10: تماس هفتم به backtrack

• tempList = [2, 3] به list
• list = [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3]]
• Backtrack: حذف 3 → tempList = [2]
• Backtrack: حذف 2 → tempList = []

مرحله 11: بازگشت به اولین تماس

• برای تکرار حلقه 3 (i = 2):
  • اضافه کردن 3 به tempList → tempList = [3]
  • فراخوانی backtrack(list, tempList = [3], nums, start = 3)

مرحله 12: تماس هشتم به backtrack

• tempList = [3] به list
• list = [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]
• Backtrack: حذف 3 → tempList = []
• همه تکرارها کامل می شوند. بازگشت listبشر

نتیجه نهایی

[[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]

غذای اصلی

1. رویکرد پس زمینه:

   • ما زیر مجموعه ها را به صورت بازگشتی کشف می کنیم ، عناصر را اضافه می کنیم و از بین می بریم.
   • در tempList برای ساخت زیر مجموعه ها استفاده می شود و هر ایالت در آن ذخیره می شود listبشر

2. پیچیدگی زمانی:

   • o (2^n) → از آنجا که هر عنصر می تواند شامل شود یا نه ، ما تولید می کنیم 2^n زیر مجموعه ها

3. پیچیدگی فضا:

   • o (2^n * n) → هر زیر مجموعه به فضا احتیاج دارد ، و وجود دارد 2^n زیر مجموعه ها ، هر یک از آنها به O(n) فضا

4. تجسم درخت بازگشتی:

   • عملکرد بازگشتی درختی را ایجاد می کند که در آن هر سطح با انتخاب یا پرش یک عنصر مطابقت دارد.

این تجزیه گام به گام توضیح می دهد که چگونه زیر مجموعه ها به صورت بازگشتی با استفاده از آنها تولید می شوند پس اندازبشر 🚀