public override IEnumerable <object> Solve(TextReader inputStream)
{
const int MaxDigit = 60;
var n = inputStream.ReadInt();
var a = inputStream.ReadLongArray();
var bits = new int[MaxDigit];
foreach (var ai in a)
{
for (int digit = 0; digit < MaxDigit; digit++)
{
if ((ai & (1L << digit)) > 0)
{
bits[digit]++;
}
}
}
var sum = Modular.Zero;
for (int digit = 0; digit < MaxDigit; digit++)
{
sum += new Modular(bits[digit]) * new Modular(n - bits[digit]) * new Modular(1L << digit);
}
yield return(sum);
}
public override void Solve(IOManager io)
{
var tests = io.ReadInt();
var invTwo = Modular.One / new Modular(2);
for (int t = 0; t < tests; t++)
{
var n = io.ReadInt();
var a = io.ReadInt();
var b = io.ReadInt();
// a > bにする
a.SwapIfSmallerThan(ref b);
if (a + b > n)
{
io.WriteLine(0);
continue;
}
var result = Square(new Modular(n - a + 1)) * Square(new Modular(n - b + 1));
result -= Square(new Modular(a - b + 1)) * Square(new Modular(n - a + 1));
var line = new Modular(n - a - b + 1) * new Modular(b - 1) + new Modular(b - 1) * new Modular(b) * invTwo;
result -= line * (a - b + 1) * (n - a + 1) * 4;
result -= Square(line) * 4;
io.WriteLine(result);
}
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.Mod = Mod;
var queries = inputStream.ReadInt();
for (int q = 0; q < queries; q++)
{
var(x, d, n) = inputStream.ReadValue <int, int, int>();
if (d == 0)
{
yield return(Modular.Pow(x, n).Value);
}
else if (x == 0)
{
yield return(0);
}
else
{
var p = new Modular(x) / new Modular(d);
if (p.Value + n - 1 > Mod)
{
yield return(0);
}
else
{
var normalized = Modular.Permutation(n + p.Value - 1, n);
var pow = Modular.Pow(d, n);
yield return((normalized * pow).Value);
}
}
}
}
public CountAndWay Multiply(CountAndWay other)
{
var sum = Count + other.Count;
var way = Modular.Combination(sum, Count) * Way * other.Way;
return(new CountAndWay(sum, way));
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var ns = inputStream.ReadIntArray();
var s = ns[1];
var a = inputStream.ReadIntArray();
const int mod = 998244353;
var counts = new Modular[a.Length + 1, s + 1, 3]; // 3引数目は状態（0:L未決定, 1:R未決定, 2:両方決定）
Clear(counts, mod);
counts[0, 0, 0] = new Modular(1);
for (int item = 0; item < a.Length; item++)
{
var ai = a[item];
for (int sum = 0; sum <= s; sum++)
{
// 0
counts[item + 1, sum, 0] += counts[item, sum, 0]; // 0 -> 0
counts[item + 1, sum, 1] += counts[item, sum, 1]; // 1 -> 1
counts[item + 1, sum, 2] += counts[item, sum, 2]; // 2 -> 2
if (sum + ai <= s)
{
counts[item + 1, sum + ai, 1] += counts[item, sum, 0] * new Modular(item + 1); // 0 -> 1
counts[item + 1, sum + ai, 2] += counts[item, sum, 0] * new Modular((item + 1) * (a.Length - item)); // 0 -> 1 -> 2
counts[item + 1, sum + ai, 1] += counts[item, sum, 1]; // 1 -> 1
counts[item + 1, sum + ai, 2] += counts[item, sum, 1] * new Modular(a.Length - item); // 1 -> 2
}
}
}
yield return(counts[a.Length, s, 2].Value);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var ns = inputStream.ReadIntArray();
var s = ns[1];
var a = inputStream.ReadIntArray();
const int mod = 998244353;
var counts = new Modular[a.Length + 1, s + 1];
Clear(counts, mod);
var total = new Modular(0, mod);
for (int i = 0; i < a.Length; i++)
{
counts[i, 0] += new Modular(1, mod); // in
for (int sum = 0; sum <= s; sum++)
{
counts[i + 1, sum] += counts[i, sum];
if (sum + a[i] <= s)
{
counts[i + 1, sum + a[i]] += counts[i, sum];
}
}
total += counts[i + 1, s]; // out
}
yield return(total.Value);
}
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 l = inputStream.ReadLine().Select(c => c == '1').ToArray();
var counts = new Modular[l.Length + 1, 2];
const int Equal = 0;
const int Less = 1;
counts[0, Equal] = 1;
for (int i = 0; i < l.Length; i++)
{
if (l[i])
{
counts[i + 1, Equal] += counts[i, Equal] * 2;
counts[i + 1, Less] += counts[i, Equal];
counts[i + 1, Less] += counts[i, Less] * 3;
}
else
{
counts[i + 1, Equal] += counts[i, Equal];
counts[i + 1, Less] += counts[i, Less] * 3;
}
}
yield return(counts[l.Length, Equal] + counts[l.Length, Less]);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var n = inputStream.ReadInt();
var a = inputStream.ReadIntArray();
var divisors = new Counter <int>();
foreach (var ai in a)
{
var currentDivisors = GetDivisors(ai);
foreach (var divisor in currentDivisors)
{
divisors[divisor.Item1] = Math.Max(divisors[divisor.Item1], divisor.Item2);
}
}
var lcm = new Modular(1);
foreach (var divisor in divisors)
{
for (int i = 0; i < divisor.Item2; i++)
{
lcm *= new Modular(divisor.Item1);
}
}
var total = new Modular(0);
foreach (var ai in a)
{
total += lcm / new Modular(ai);
}
yield return(total.Value);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(children, candies) = inputStream.ReadValue <int, int>();
var limits = inputStream.ReadIntArray();
var counts = new Modular[children + 1, candies + 1];
counts[0, 0] = 1;
for (int child = 1; child <= children; child++)
{
var prefixSum = Modular.Zero;
for (int distributed = 0; distributed <= candies; distributed++)
{
prefixSum += counts[child - 1, distributed];
if (distributed - limits[child - 1] - 1 >= 0)
{
prefixSum -= counts[child - 1, distributed - limits[child - 1] - 1];
}
counts[child, distributed] = prefixSum;
}
}
yield return(counts[children, candies]);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var s = inputStream.ReadLine();
const int Mod = 13;
var counts = new Modular[s.Length + 1, Mod];
counts[0, 0] = 1;
for (int i = 0; i < s.Length; i++)
{
var c = s[i];
if (c != '?')
{
c -= '0';
Proceed(Mod, counts, i, c);
}
else
{
for (int value = 0; value < 10; value++)
{
Proceed(Mod, counts, i, value);
}
}
}
yield return(counts[s.Length, 5]);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.Mod = 998244353;
var(itemCount, sum) = inputStream.ReadValue <int, int>();
var values = inputStream.ReadIntArray();
var results = new Modular[itemCount + 1, sum + 1];
var result = Modular.Zero;
for (int item = 0; item < itemCount; item++)
{
results[item, 0] += 1; // in
for (int s = 0; s <= sum; s++)
{
// 選ばない
results[item + 1, s] += results[item, s];
// 選ぶ
var next = s + values[item];
if (next <= sum)
{
results[item + 1, next] += results[item, s];
}
}
result += results[item + 1, sum]; // out
}
yield return(result);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.Mod = 998244353;
var(initialHeight, initialWidth, lastHeight, lastWidth) = inputStream.ReadValue <int, int, int, int>();
var counts = new Modular[lastHeight + 1, lastWidth + 1];
var minuses = new Modular[lastHeight + 1, lastWidth + 1];
counts[initialHeight, initialWidth] = Modular.One;
for (int row = initialHeight; row <= lastHeight; row++)
{
for (int column = initialWidth; column <= lastWidth; column++)
{
if (row == initialHeight && column == initialWidth)
{
continue;
}
counts[row, column] = row * counts[row, column - 1] + column * counts[row - 1, column]
- (row - 1) * (column - 1) * counts[row - 1, column - 1];
}
}
yield return(counts[lastHeight, lastWidth].Value);
}
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 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)
{
var hw = inputStream.ReadIntArray();
var h = hw[0];
var w = hw[1];
var maze = new char[h][];
for (int i = 0; i < h; i++)
{
maze[i] = inputStream.ReadLine().ToCharArray();
}
var pathCount = CreateInitializedArray(h, w, maze);
pathCount[0, 0] = new Modular(1);
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
if (maze[i][j] != '#')
{
var up = i != 0 ? pathCount[i - 1, j] : new Modular(0);
var left = j != 0 ? pathCount[i, j - 1] : new Modular(0);
UpdateWhenLarge(ref pathCount[i, j], up + left);
}
}
}
yield return(pathCount[h - 1, w - 1].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 override IEnumerable <object> Solve(TextReader inputStream)
{
var k = inputStream.ReadLine().Select(c => c - '0').ToArray();
var d = inputStream.ReadInt();
var counts = new Modular[k.Length + 1, 2, d];
const int Equal = 0;
const int Less = 1;
counts[0, Equal, 0] = 1;
for (int digit = 0; digit < k.Length; digit++)
{
for (int mod = 0; mod < d; mod++)
{
// Equal
counts[digit + 1, Equal, (mod + k[digit]) % d] += counts[digit, Equal, mod];
for (int added = 0; added < k[digit]; added++)
{
counts[digit + 1, Less, (mod + added) % d] += counts[digit, Equal, mod];
}
// Less
for (int added = 0; added <= 9; added++)
{
counts[digit + 1, Less, (mod + added) % d] += counts[digit, Less, mod];
}
}
}
yield return(counts[k.Length, Equal, 0] + counts[k.Length, Less, 0] - 1);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var(boxCount, children) = inputStream.ReadValue <int, int>();
var candies = inputStream.ReadIntArray();
Modular.Mod = children;
var prefixSum = new Modular[boxCount + 1];
for (int i = 0; i < candies.Length; i++)
{
prefixSum[i + 1] = prefixSum[i] + candies[i];
}
var counts = new Counter <int>();
long total = 0;
foreach (var mod in prefixSum)
{
counts[mod.Value]++;
}
foreach (var(value, c) in counts)
{
total += c * (c - 1) / 2;
}
yield return(total);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var n = inputStream.ReadInt();
var colors = new List <int>();
var last = -1;
for (int i = 0; i < n; i++)
{
var color = inputStream.ReadInt() - 1;
if (color != last)
{
colors.Add(color);
}
last = color;
}
var lastSeen = Enumerable.Repeat(-1, colors.Max() + 1).ToArray();
var dp = new Modular[colors.Count + 1];
dp[0] = 1;
for (int i = 0; i < colors.Count; i++)
{
dp[i + 1] += dp[i];
if (lastSeen[colors[i]] != -1)
{
dp[i + 1] += dp[lastSeen[colors[i]] + 1];
}
lastSeen[colors[i]] = i;
}
yield return(dp[colors.Count]);
}
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));
}
private static void UpdateNextMod(Modular[,] mods, Modular tenFactor, int digit, int currentNumber)
{
for (int lastMod = 0; lastMod < 13; lastMod++)
{
var nextMod = new Modular(lastMod, 13) + new Modular(currentNumber, 13) * tenFactor;
mods[digit + 1, nextMod.Value] += mods[digit, lastMod];
}
}
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, length) = inputStream.ReadValue <int, long>();
var counts = new Modular[60, n];
var nexts = new List <int> [60, n];
for (int i = 0; i < n; i++)
{
var a = inputStream.ReadIntArray();
var currentNexts = new List <int>();
for (int j = 0; j < n; j++)
{
if (a[j] == 1)
{
currentNexts.Add(j);
}
}
nexts[0, i] = currentNexts;
counts[0, i] = currentNexts.Count;
}
for (int pow = 1; pow < 60; pow++)
{
for (int start = 0; start < n; start++)
{
var currentNexts = nexts[pow - 1, start];
var doubleNexts = Enumerable.Empty <int>();
var c = Modular.Zero;
foreach (var next in currentNexts)
{
c += counts[pow - 1, next];
doubleNexts = doubleNexts.Concat(nexts[pow - 1, next]);
}
counts[pow, start] = counts[pow - 1, start] * c;
nexts[pow, start] = doubleNexts.Distinct().ToList();
}
}
var result = Modular.Zero;
for (int start = 0; start < n; start++)
{
var c = Modular.One;
for (int pow = 0; pow < 60; pow++)
{
if (((1L << pow) & length) > 0)
{
c *= counts[pow, start];
}
}
result += c;
}
yield return(result);
}
Modular GetEdgeSum(int[] coordinates)
{
var sum = new Modular(0);
for (int i = 0; i + 1 < coordinates.Length; i++)
{
sum += new Modular(i + 1) * new Modular(coordinates.Length - i - 1) * new Modular(coordinates[i + 1] - coordinates[i]);
}
return(sum);
}
private static void Clear(Modular[,] counts, int mod)
{
for (int i = 0; i < counts.GetLength(0); i++)
{
for (int j = 0; j < counts.GetLength(1); j++)
{
counts[i, j] = new Modular(0, mod);
}
}
}
private void ClearArray(Modular[,] array)
{
for (int i = 0; i < array.GetLength(0); i++)
{
for (int j = 0; j < array.GetLength(1); j++)
{
array[i, j] = new Modular(0);
}
}
}
public async Task <bool> AddModular(Modular modular)
{
if (!Existed(modular.ModularId))
{
await _dbContext.Modulars.AddAsync(modular);
return(await _dbContext.SaveChangesAsync() > 0);
}
return(true);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
var n = inputStream.ReadInt();
var s = inputStream.ReadLine();
if (s[0] == 'W' || s[^ 1] == 'W')
{
yield return(0);
yield break;
}
var edges = new Edge[s.Length];
var last = s[0];
for (int i = 1; i < s.Length; i++)
{
if (s[i] != last)
{
edges[i] = edges[i - 1];
}
else
{
edges[i] = edges[i - 1] == Edge.Left ? Edge.Right : Edge.Left;
}
last = s[i];
}
if (edges.Count(e => e == Edge.Left) != n)
{
yield return(0);
yield break;
}
var count = Modular.One;
var leftCount = 0;
foreach (var edge in edges)
{
if (edge == Edge.Left)
{
leftCount++;
}
else
{
count *= leftCount--;
}
}
count *= Modular.Factorial(n);
yield return(count);
}
public override IEnumerable <object> Solve(TextReader inputStream)
{
Modular.Mod = 998244353;
var n = inputStream.ReadInt();
var d = inputStream.ReadIntArray();
if (d[0] != 0)
{
yield return(0);
yield break;
}
else
{
var counts = new int[n];
counts[0] = 1;
for (int i = 1; i < d.Length; i++)
{
if (d[i] == 0)
{
yield return(0);
yield break;
}
else
{
counts[d[i]]++;
}
}
var total = Modular.One;
var selected = 1;
for (int distance = 1; distance < counts.Length; distance++)
{
if (counts[distance] == 0)
{
yield return(0);
yield break;
}
else
{
total *= Modular.Pow(counts[distance - 1], counts[distance]);
selected += counts[distance];
if (selected == n)
{
break;
}
}
}
yield return(total);
}
}
