Solution Leetcode and Explaination Every single line

Author: Github-Saurabh0

Bonus15 - Count the Number of Arrays with K Matching Adjacent Elements/Program Explaination.txt

@@ -0,0 +1,116 @@
+✅ Java Code: countGoodArrays
+
+class Solution {
+ public int countGoodArrays(int n, int m, int k) {
+ final long[][] factAndInvFact = getFactAndInvFact(n);
+ final long[] fact = factAndInvFact[0];
+ final long[] invFact = factAndInvFact[1];
+ return (int) (m * modPow(m - 1, n - k - 1) % MOD * nCk(n - 1, k, fact, invFact) % MOD);
+ }
+
+ private static final int MOD = 1_000_000_007;
+
+ private long modPow(long x, long n) {
+ if (n == 0)
+ return 1;
+ if (n % 2 == 1)
+ return x * modPow(x, n - 1) % MOD;
+ return modPow(x * x % MOD, n / 2);
+ }
+
+ private long[][] getFactAndInvFact(int n) {
+ long[] fact = new long[n + 1];
+ long[] invFact = new long[n + 1];
+ long[] inv = new long[n + 1];
+ fact[0] = invFact[0] = 1;
+ inv[0] = inv[1] = 1;
+ for (int i = 1; i <= n; ++i) {
+ if (i >= 2)
+ inv[i] = MOD - MOD / i * inv[MOD % i] % MOD;
+ fact[i] = fact[i - 1] * i % MOD;
+ invFact[i] = invFact[i - 1] * inv[i] % MOD;
+ }
+ return new long[][] {fact, invFact};
+ }
+
+ private int nCk(int n, int k, long[] fact, long[] invFact) {
+ return (int) (fact[n] * invFact[k] % MOD * invFact[n - k] % MOD);
+ }
+}
+
+
+
+📘Explanation
+
+public int countGoodArrays(int n, int m, int k)
+🔹 n = array ka size
+🔹 m = allowed values 1 se m tak
+🔹 k = number of equal adjacent pairs required
+
+final long[][] factAndInvFact = getFactAndInvFact(n);
+🔹 Factorials aur unka modular inverse calculate kar liya for combination calculation.
+
+final long[] fact = factAndInvFact[0];
+final long[] invFact = factAndInvFact[1];
+🔹 Arrays ko alag variables me assign kar liya.
+
+return (int) (m * modPow(m - 1, n - k - 1) % MOD * nCk(n - 1, k, fact, invFact) % MOD);
+🔹 Final answer:
+
+Pehle element ke liye m choices
+
+Baaki n-k-1 elements ke liye (m-1) choices (different from previous)
+
+n-1 gaps me se k equal hone chahiye → nCk(n-1, k)
+
+Supporting Methods:
+modPow(x, n) → Fast Power (Binary Exponentiation)
+
+private long modPow(long x, long n)
+🔹 x^n % MOD calculate karta hai efficiently
+🔹 Recursive approach use kiya with modulo at each step
+
+getFactAndInvFact(n)
+
+private long[][] getFactAndInvFact(int n)
+🔹 Factorials aur unka inverse precompute karta hai:
+
+fact[i] = i!
+
+inv[i] = i⁻¹ mod MOD
+
+invFact[i] = (i!)⁻¹ mod MOD
+
+inv[i] = MOD - MOD / i * inv[MOD % i] % MOD;
+🔹 Fermat's Little Theorem use kiya inverse nikalne ke liye
+
+nCk(n, k, fact, invFact)
+
+private int nCk(int n, int k, long[] fact, long[] invFact)
+🔹 nCk (combination) = fact[n] * invFact[k] * invFact[n-k] % MOD
+
+🧠 Example Input:
+n = 4, m = 3, k = 1
+Step by Step:
+
+Pehle element ke liye 3 choices
+
+4-1-1 = 2 elements = (m-1)^2 = 2^2 = 4
+
+3 gaps, 1 equal = C(3,1) = 3
+→ Total = 3 * 4 * 3 = 36
+
+🚀 Time Complexity:
+
+O(n) for precomputing factorials
+
+O(log n) for power calculation
+
+O(1) for final answer after precomputation
+
+🚀 Space Complexity:
+
+O(n) for storing factorial and inverse arrays
+
+🔗 Need more help or Java tricks?
+https://www.linkedin.com/in/saurabh884095/

Bonus15 - Count the Number of Arrays with K Matching Adjacent Elements/Soluition.java

@@ -0,0 +1,37 @@
+class Solution {
+ public int countGoodArrays(int n, int m, int k) {
+ final long[][] factAndInvFact = getFactAndInvFact(n);
+ final long[] fact = factAndInvFact[0];
+ final long[] invFact = factAndInvFact[1];
+ return (int) (m * modPow(m - 1, n - k - 1) % MOD * nCk(n - 1, k, fact, invFact) % MOD);
+ }
+
+ private static final int MOD = 1_000_000_007;
+
+ private long modPow(long x, long n) {
+ if (n == 0)
+ return 1;
+ if (n % 2 == 1)
+ return x * modPow(x, n - 1) % MOD;
+ return modPow(x * x % MOD, n / 2);
+ }
+
+ private long[][] getFactAndInvFact(int n) {
+ long[] fact = new long[n + 1];
+ long[] invFact = new long[n + 1];
+ long[] inv = new long[n + 1];
+ fact[0] = invFact[0] = 1;
+ inv[0] = inv[1] = 1;
+ for (int i = 1; i <= n; ++i) {
+ if (i >= 2)
+ inv[i] = MOD - MOD / i * inv[MOD % i] % MOD;
+ fact[i] = fact[i - 1] * i % MOD;
+ invFact[i] = invFact[i - 1] * inv[i] % MOD;
+ }
+ return new long[][] {fact, invFact};
+ }
+
+ private int nCk(int n, int k, long[] fact, long[] invFact) {
+ return (int) (fact[n] * invFact[k] % MOD * invFact[n - k] % MOD);
+ }
+}