როგორ შევცვალოთ გადაწყვეტილება ზარების ჯამებისა და კომბინაციების გამოთვლისთვის, თუ ზარების რაოდენობა პარამეტრია?

თუ სათამაშო კუბიკების რაოდენობა პარამეტრად იქცევა, ჯამებისა და კომბინაციების გამოთვლის გადაწყვეტილება უნდა იყოს დინამიური და მასშტაბური.

მოძრაობები:

1. რეკურსიული გადაცემა:

   • თითოეულ კუბიკზე განიხილეთ ყველა შესაძლო მნიშვნელობა (1–6).
   • რეკურსიულად დააჯამეთ მნიშვნელობები და ითვალეთ კომბინაციების რაოდენობა თითო ჯამისთვის.

2. დინამიური პროგრამირება:

   • გამოიყენეთ მასივი ან სიტყვაკი, სადაც ინდექსი არის ჯამი, ხოლო მნიშვნელობა — ამ ჯამის მიღების გზების რაოდენობა.
   • თავდაპირველად, 0 კუბიკისთვის, 0 ჯამის მიღების გზების რაოდენობა 1-ია.
   • თითოეულ კუბიკზე განაახლეთ მასივი, დამატებით გზების რაოდენობით ახალი ჯამებისთვის.

მაგალითი Go-ში დინამიური პროგრამირებით:

func diceSums(numDice int) map[int]int {
    dp := make(map[int]int)
    dp[0] = 1

    for i := 0; i < numDice; i++ {
        next := make(map[int]int)
        for sum, count := range dp {
            for face := 1; face <= 6; face++ {
                next[sum+face] += count
            }
        }
        dp = next
    }
    return dp
}

// გამოყენება:
// sums := diceSums(3)
// fmt.Println(sums) // აჩვენებს კომბინაციების რაოდენობას თითო ჯამისთვის 3 კუბიკით

ეს მიდგომა საშუალებას აძლევს ეფექტურად გამოთვალოთ კომბინაციების რაოდენობა ნებისმიერი რაოდენობის კუბიკებისთვის, ხელით ყველა ვარიანტის გადავლით გარეშე.