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); } }