public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.InitializeCombinationTable();
var nodesCount = inputStream.ReadInt();
graph = new BasicGraph(nodesCount);
for (int i = 0; i < nodesCount - 1; i++)
{
var(a, b) = inputStream.ReadValue <int, int>();
a--;
b--;
graph.AddEdge(new BasicEdge(a, b));
graph.AddEdge(new BasicEdge(b, a));
}
dpStates = new DPState[nodesCount];
for (int i = 0; i < dpStates.Length; i++)
{
dpStates[i] = new DPState(new Modular(1), 0);
}
var rerooting = new Rerooting <BasicNode, BasicEdge, DPState>(graph);
var results = rerooting.Solve().Select(r => r.Count.Value);
foreach (var result in results)
{
yield return(result);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.InitializeCombinationTable();
var n = inputStream.ReadInt();
var k = inputStream.ReadInt();
yield return(Modular.CombinationWithRepetition(n, k).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 k = inputStream.ReadInt();
var s = inputStream.ReadLine();
var sum = Modular.Zero;
Modular.InitializeCombinationTable(2500000);
for (int taken = 0; taken <= k; taken++)
{
sum += Modular.CombinationWithRepetition(taken + 1, s.Length - 1) * Modular.Pow(25, taken) * Modular.Pow(26, k - taken);
}
yield return(sum.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)
{
Modular.InitializeCombinationTable();
var s = inputStream.ReadInt();
var result = Modular.Zero;
for (int l = 1; l <= s / 3; l++)
{
var remain = s - l * 3;
if (remain >= 0)
{
result += Modular.CombinationWithRepetition(l, remain);
}
}
yield return(result);
}
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)
{
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 void Solve(IOManager io)
{
Modular.InitializeCombinationTable();
var n = io.ReadInt();
var tree = new BasicGraph(n);
for (int i = 0; i < n - 1; i++)
{
var a = io.ReadInt() - 1;
var b = io.ReadInt() - 1;
tree.AddEdge(a, b);
tree.AddEdge(b, a);
}
var rerooting = new Rerooting <BasicEdge, CountAndWay>(tree);
var results = rerooting.Solve();
foreach (var r in results)
{
io.WriteLine(r.Way);
}
}
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 nodeCount = inputStream.ReadInt();
var graph = new BasicGraph(nodeCount);
for (int i = 0; i < nodeCount - 1; i++)
{
var(u, v) = inputStream.ReadValue <int, int>();
u--;
v--;
graph.AddEdge(new BasicEdge(u, v));
graph.AddEdge(new BasicEdge(v, u));
}
var rerooting = new Rerooting <BasicNode, BasicEdge, CountAndWay>(graph);
var results = rerooting.Solve();
foreach (var result in results)
{
yield return(result.Way);
}
}
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);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.InitializeCombinationTable();
var(height, width, k) = inputStream.ReadValue <int, int, int>();
yield return(Sum(width, height, k) + Sum(height, width, k));
}
