public static DPState operator-(DPState state1, DPState state2)
{
var size = state1.Size - state2.Size;
var count = state1.Count / (Modular.Combination(state1.Size, state2.Size) * state2.Count);
return(new DPState(count, size));
}
public static DPState operator+(DPState state1, DPState state2)
{
var size = state1.Size + state2.Size;
var count = Modular.Combination(size, state1.Size) * state1.Count * state2.Count;
return(new DPState(count, size));
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var n = inputStream.ReadInt();
var c = inputStream.ReadLongArray();
var costs = new long[n + 1]; // 0≦i≦N個違ったときに支払うトータルコスト
long subSum = 0;
for (int i = 0; i < c.Length; i++)
{
subSum += c[i];
costs[i + 1] = costs[i] + subSum;
}
var totalCost = new Modular(0);
for (int i = 1; i <= n; i++)
{
totalCost += Modular.Combination(n, i) * new Modular(costs[i]);
}
totalCost *= Modular.Pow(new Modular(2), n);
yield return(totalCost.Value);
}
public DPState Multiply(DPState other)
{
var size = Size + other.Size;
var count = Modular.Combination(size, Size) * Count * other.Count;
return(new DPState(count, size));
}
public CountAndWay Multiply(CountAndWay other)
{
var sum = Count + other.Count;
var way = Modular.Combination(sum, Count) * Way * other.Way;
return(new CountAndWay(sum, way));
}
Modular Count(int height, int width, int k)
{
var patterns = Modular.Combination(height * width - 2, k - 2);
var sum = new Modular(0);
for (int d = 1; d < width; d++)
{
sum += new Modular(d) * new Modular(height) * new Modular(height) * new Modular(width - d);
}
return(patterns * sum);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.InitializeCombinationTable(1_000_000);
var(n, m) = inputStream.ReadValue <int, int>();
var count = Modular.Zero;
for (int duplicated = 0; duplicated <= n; duplicated++)
{
var sign = (duplicated & 1) == 0 ? 1 : -1;
count += sign * Modular.Combination(n, duplicated) * Modular.Permutation(m, duplicated) * Modular.Pow(Modular.Permutation(m - duplicated, n - duplicated), 2);
}
yield return(count.Value);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
const int mod = 998244353;
var(blockCount, colorCount, maxPair) = inputStream.ReadValue <int, int, int>();
var total = new Modular(0, mod);
for (int i = 0; i <= maxPair; i++)
{
total += Modular.Combination(blockCount - 1, i, mod) * Modular.Pow(new Modular(colorCount - 1, mod), blockCount - i - 1) * new Modular(colorCount, mod);
}
yield return(total.Value);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(n, k) = inputStream.ReadValue <int, int>();
Modular.InitializeCombinationTable();
var count = Modular.Zero;
for (int empty = 0; empty < k; empty++)
{
var sign = (empty & 1) == 0 ? 1 : -1;
count += sign * Modular.Combination(k, empty) * Modular.Pow(k - empty, n);
}
yield return(count.Value);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var nk = inputStream.ReadIntArray();
var n = nk[0];
var k = nk[1];
Modular total = new Modular(0);
var maxMoveCount = Math.Min(n - 1, k);
for (int i = 0; i <= maxMoveCount; i++)
{
total += Modular.Combination(n, i) * Modular.CombinationWithRepetition(n - i, i);
}
yield return(total.Value);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(children, candies) = inputStream.ReadValue <int, int>();
Modular.InitializeCombinationTable();
if (children > candies)
{
yield return(Modular.CombinationWithRepetition(children, candies));
}
else
{
var less = candies / children;
var moreChildren = candies - less * children;
yield return(Modular.Combination(children, moreChildren));
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var k = inputStream.ReadInt();
var s = inputStream.ReadLine();
var lastLength = s.Length + k;
Modular.InitializeCombinationTable(2500000);
var count = Modular.Zero;
for (int lastS = s.Length; lastS <= lastLength; lastS++)
{
count += Modular.Combination(lastS - 1, s.Length - 1) * Modular.Pow(25, lastS - s.Length) * Modular.Pow(26, lastLength - lastS);
}
yield return(count.Value);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var n = inputStream.ReadInt();
var a = inputStream.ReadIntArray();
var duplicated = a.GroupBy(i => i).Single(g => g.Count() > 1).Key;
var leftIndex = -1;
var rightIndex = -1;
for (int i = 0; i < a.Length; i++)
{
if (a[i] == duplicated)
{
if (leftIndex == -1)
{
leftIndex = i;
}
else
{
rightIndex = i;
}
}
}
var left = leftIndex;
var right = a.Length - rightIndex - 1;
var center = rightIndex - leftIndex - 1;
for (int length = 1; length <= a.Length; length++)
{
var total = Modular.Combination(a.Length, length);
if (left + right >= length - 1)
{
total -= Modular.Combination(left + right, length - 1);
}
yield return(total.Value);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.InitializeCombinationTable();
var(n, k) = inputStream.ReadValue <int, int>();
var a = inputStream.ReadIntArray();
Array.Sort(a);
var result = Modular.Zero;
for (int i = 0; i <= n - k; i++)
{
result -= a[i] * Modular.Combination(n - i - 1, k - 1);
}
for (int i = k - 1; i < a.Length; i++)
{
result += a[i] * Modular.Combination(i, k - 1);
}
yield return(result);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.InitializeCombinationTable();
var n = inputStream.ReadInt();
var a = inputStream.ReadIntArray();
var diffs = new Modular[a.Length - 1];
for (int i = 0; i < diffs.Length; i++)
{
diffs[i] = new Modular(Math.Abs(a[i] - a[i + 1]));
}
var result = Modular.GetZero();
for (int i = 0; i < diffs.Length; i++)
{
result += diffs[i] * Modular.Combination(diffs.Length - 1, i);
}
yield return(result);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.Mod = 1_000_000_007;
Modular.InitializeCombinationTable();
var n = inputStream.ReadInt();
var a = inputStream.ReadIntArray();
var(dupLeft, dupRight) = GetDuplicatedIndices(a);
var left = dupLeft;
var right = a.Length - dupRight - 1;
for (int k = 1; k <= a.Length; k++)
{
var count = Modular.Combination(a.Length, k);
if (left + right >= k - 1)
{
count -= Modular.Combination(left + right, k - 1);
}
yield return(count);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.Mod = 998244353;
Modular.InitializeCombinationTable();
var(n, a, b, k) = inputStream.ReadValue <int, int, int, long>();
var count = Modular.Zero;
for (int x = 0; x <= n; x++)
{
var remain = k - (long)a * x;
if (remain >= 0 && remain % b == 0)
{
var y = remain / b;
if (y <= n)
{
count += Modular.Combination(n, x) * Modular.Combination(n, (int)y);
}
}
}
yield return(count);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(_, k) = inputStream.ReadValue <int, int>();
var a = inputStream.ReadIntArray();
Array.Sort(a);
var sum = Modular.Zero;
Modular.InitializeCombinationTable();
for (int i = 0; i <= a.Length - k; i++)
{
sum += -a[i] * Modular.Combination(a.Length - i - 1, k - 1);
}
for (int i = k - 1; i < a.Length; i++)
{
sum += a[i] * Modular.Combination(i, k - 1);
}
yield return(sum);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.InitializeCombinationTable();
var(n, m) = inputStream.ReadValue <int, int>();
var primes = PrimeFactorize(Math.Abs(n)).GroupBy(i => i).Select(g => (g.Key, g.Count()));
var count = Modular.One;
foreach (var(_, c) in primes)
{
count *= Modular.CombinationWithRepetition(m, c);
}
var minusCombination = Modular.Zero;
for (int i = (-Math.Sign(n) + 1) / 2; i <= m; i += 2)
{
minusCombination += Modular.Combination(m, i);
}
count *= minusCombination;
yield return(count.Value);
}
Modular Sum(int width, int height, int k)
{
var result = Modular.Zero;
var squares = width * height;
for (int distance = 1; distance < width; distance++)
{
result += new Modular(distance) * new Modular(height) * new Modular(height) * Modular.Combination(squares - 2, k - 2) * new Modular(width - distance);
}
return(result);
}
