結果
| 問題 | No.1195 数え上げを愛したい（文字列編） |
| ユーザー |
 eSeF
|
| 提出日時 | 2020-08-22 19:42:43 |
| 言語 | C#(csc) (csc 3.9.0) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 20,699 bytes |
| コンパイル時間 | 2,798 ms |
| コンパイル使用メモリ | 115,840 KB |
| 実行使用メモリ | 52,256 KB |
| 最終ジャッジ日時 | 2024-10-15 12:15:49 |
| 合計ジャッジ時間 | 11,504 ms |
|
ジャッジサーバーID （参考情報） |
judge5 / judge2 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | TLE | - |
| testcase_01 | -- | - |
| testcase_02 | -- | - |
| testcase_03 | -- | - |
| testcase_04 | -- | - |
| testcase_05 | -- | - |
| testcase_06 | -- | - |
| testcase_07 | -- | - |
| testcase_08 | -- | - |
| testcase_09 | -- | - |
| testcase_10 | -- | - |
| testcase_11 | -- | - |
| testcase_12 | -- | - |
| testcase_13 | -- | - |
| testcase_14 | -- | - |
| testcase_15 | -- | - |
| testcase_16 | -- | - |
| testcase_17 | -- | - |
| testcase_18 | -- | - |
| testcase_19 | -- | - |
| testcase_20 | -- | - |
| testcase_21 | -- | - |
| testcase_22 | -- | - |
| testcase_23 | -- | - |
| testcase_24 | -- | - |
| testcase_25 | -- | - |
コンパイルメッセージ
Microsoft (R) Visual C# Compiler version 3.9.0-6.21124.20 (db94f4cc) Copyright (C) Microsoft Corporation. All rights reserved.
ソースコード
using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using System.Numerics;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Diagnostics;
using static System.Math;
using static System.Array;
using static AtCoder.Cout;
using static AtCoder.Tool;
using static AtCoder.ModInt;
namespace AtCoder
{
class AC
{
//const int MOD = 1000000007;
const int MOD = 998244353;
const int INF = int.MaxValue / 2;
const long SINF = long.MaxValue / 3;
const double EPS = 1e-8;
static readonly int[] dI = { 0, 1, 0, -1, 1, -1, -1, 1 };
static readonly int[] dJ = { 1, 0, -1, 0, 1, 1, -1, -1 };
static void Main(string[] args)
{
//var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false }; Console.SetOut(sw);
var th = new Thread(Run, 1 << 26);
th.Start();
th.Join();
//Run();
Console.Out.Flush();
}
static void Run()
{
int Testcase = 1;
//Testcase = Cin.Int;
for (var _ = 0; _ < Testcase; _++) Solve();
}
static void Solve()
{
var S = Cin.Str;
var c = new int[26];
for (var i = 0; i < S.Length; i++) c[S[i] - 'a']++;
var P = new long[26][];
for(var i = 0; i < 26; i++)
{
P[i] = new long[c[i] + 1];
for (var j = 0; j <= c[i]; j++) P[i][j] = (1 / Fac(j)).value;
}
var ntt = new Math_NTT(998244353, 3);
for (var i = 1; i < 26; i++) P[0] = ntt.Convolution_NTT(P[0], P[i]);
ModInt ans = 0;
//Out_Sep(P[0]);
for (var L = 1; L <= S.Length; L++) ans += P[0][L] * Fac(L);
OutL(ans.value);
}
public struct Edge
{
public int from;
public int to;
public long dist;
public Edge(int t, long c)
{
from = -1;
to = t;
dist = c;
}
public Edge(int f, int t, long c)
{
from = f;
to = t;
dist = c;
}
}
}
public class Math_NTT
{
private long mod;
private long root;
public Math_NTT(long prime_mod, long premitive_root) { mod = prime_mod; root = premitive_root; }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
long modpow(long x, long nn) => nn == 0 ? 1 : (nn % 2 == 0 ? modpow((x * x) % mod, nn / 2) : (x * modpow(x, nn - 1)) % mod);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
long inverse(long x) => modpow(x, mod - 2);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void NTT(ref long[] a, bool inv = false)
{
int n = a.Length;
int h = 0;
for (var i = 0; (1 << i) < n; i++) h++;
//バタフライ演算準備
for (var i = 0; i < n; i++)
{
int j = 0;
for (var k = 0; k < h; k++) j |= ((i >> k) & 1) << (h - 1 - k);
//２進法表記が逆の数字とスワップする
if (i < j)
{
var kep = a[i];
a[i] = a[j];
a[j] = kep;
}
}
//バタフライ演算パート
for (var b = 1; b < n; b <<= 1)
{
long W = modpow(root, (inv ? (mod - 1) - (mod - 1) / (b << 1) : (mod - 1) / (b << 1)));
long z = 1;
for (var j = 0; j < b; j++)
{
for (var k = 0; k < n; k += (b << 1))
{
var s = a[k + j];
var t = (a[k + j + b] * z) % mod;
a[k + j] = (s + t) % mod;
a[k + j + b] = (s - t + mod) % mod;
}
z = (z * W) % mod;
}
}
if (inv)
{
for (var i = 0; i < n; i++) a[i] = (a[i] * modpow(n, mod - 2)) % mod;
}
}
/*void NTT(ref long[] a, bool rev = false)
{
var n = (long)a.Length;
if (n == 1) return;
var b = new long[n];
var s = modpow(root, rev ? (mod - 1 - (mod - 1) / n) : (mod - 1) / n);
var kp = Enumerable.Repeat((long)1, (int)(n / 2 + 1)).ToArray();
long i, j, k, l, r;
for (i = 0; i < n / 2; ++i) kp[i + 1] = (kp[i] * s) % mod;
for (i = 1, l = n / 2; i < n; i <<= 1, l >>= 1)
{
for (j = 0, r = 0; j < l; ++j, r += i)
{
for (k = 0, s = kp[i * j]; k < i; ++k)
{
var p = a[k + r]; var q = a[k + r + n / 2];
b[k + 2 * r] = (p + q) % mod;
b[k + 2 * r + i] = ((p - q + mod) % mod * s) % mod;
}
}
var t = a; a = b; b = t;
}
if (rev)
{
s = inverse(n);
for (i = 0; i < n; ++i) a[i] = (a[i] * s) % mod;
}
}*/
/*[MethodImpl(MethodImplOptions.AggressiveInlining)]
public long[] Convolution_NTT(long[] a, long[] b)
{
int N = a.Length + b.Length - 1;
int t = 1;
while (t < N) t <<= 1;
var nxa = new long[t];
var nxb = new long[t];
for (var i = 0; i < t; i++)
{
nxa[i] = i < a.Length ? a[i] : 0;
nxb[i] = i < b.Length ? b[i] : 0;
}
NTT(ref nxa);
NTT(ref nxb);
for (var i = 0; i < t; i++) nxa[i] = (nxa[i] * nxb[i]) % mod;
NTT(ref nxa, true);
var ret = new long[N];
for (var i = 0; i < N; i++) ret[i] = nxa[i];
return ret;
}*/
public long[] Convolution_NTT(long[] a, long[] b)
{
//memo: mod 998244353 => primitive_root = 3
// mod 924844033 => root = 5
int N = a.Length + b.Length - 1;
int t = 1;
while (t < N) t <<= 1;
var nxa = new long[t];
var nxb = new long[t];
for (var i = 0; i < t; i++)
{
nxa[i] = i < a.Length ? a[i] : 0;
nxb[i] = i < b.Length ? b[i] : 0;
}
NTT(ref nxa);
NTT(ref nxb);
for (var i = 0; i < t; i++) nxa[i] = (nxa[i] * nxb[i]) % mod;
NTT(ref nxa, true);
var ret = new long[N];
for (var i = 0; i < N; i++) ret[i] = nxa[i];
return ret;
}
}
struct ModInt
{
public long value;
//private const int MOD = 1000000007;
private const int MOD = 998244353;
public ModInt(long value) { this.value = value; }
public static implicit operator ModInt(long a)
{
var ret = a % MOD;
return new ModInt(ret < 0 ? (ret + MOD) : ret);
}
public static ModInt operator +(ModInt a, ModInt b) => (a.value + b.value);
public static ModInt operator -(ModInt a, ModInt b) => (a.value - b.value);
public static ModInt operator *(ModInt a, ModInt b) => (a.value * b.value);
public static ModInt operator /(ModInt a, ModInt b) => a * Modpow(b, MOD - 2);
public static ModInt operator <<(ModInt a, int n) => (a.value << n);
public static ModInt operator >>(ModInt a, int n) => (a.value >> n);
public static ModInt operator ++(ModInt a) => a.value + 1;
public static ModInt operator --(ModInt a) => a.value - 1;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ModInt Modpow(ModInt a, long n)
{
var k = a;
ModInt ret = 1;
while (n > 0)
{
if ((n & 1) != 0) ret *= k;
k *= k;
n >>= 1;
}
return ret;
}
private static readonly List<long> Factorials = new List<long>() { 1 };
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ModInt Fac(long n)
{
for (var i = Factorials.Count(); i <= n; i++)
{
Factorials.Add((Factorials[i - 1] * i) % MOD);
}
return Factorials[(int)n];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ModInt nCr(long n, long r)
{
if (n < 0 || r < 0) return 0;
return n < r ? 0 : Fac(n) / (Fac(r) * Fac(n - r));
}
public static explicit operator int(ModInt a) => (int)a.value;
}
public class Rolling_Hash
{
const ulong m30 = (1UL << 30) - 1;
const ulong m31 = (1UL << 31) - 1;
const ulong MOD = (1UL << 61) - 1;
const ulong Pl = (MOD << 1) << 1;
private uint B;
private string S;
ulong[] hash;
ulong[] pw;
public Rolling_Hash(string str)
{
S = str;
B = (uint)new Random().Next(1 << 12 + 1, int.MaxValue);
int L = S.Length;
hash = new ulong[L + 1];
pw = new ulong[L + 1];
hash[0] = 0;
pw[0] = 1;
for (var i = 0; i < L; i++)
{
hash[i + 1] = CalcMod(Mul(hash[i], B) + S[i]);
pw[i + 1] = CalcMod(Mul(pw[i], B));
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ulong GetHashValue(int idx) => hash[idx];
[MethodImpl(MethodImplOptions.AggressiveInlining)]//segment [l,r]
public ulong Hash_fold(int l, int r) => CalcMod(Pl + hash[r + 1] - Mul(hash[l], pw[r - l + 1]));
[MethodImpl(MethodImplOptions.AggressiveInlining)]//segment[start,start+len-1]
public ulong Hash_sub(int start, int len) => CalcMod(Pl + hash[start + len] - Mul(hash[start], pw[len]));
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ulong[] GetHashArray() => hash;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
ulong Mul(ulong a, ulong b)
{
ulong au = a >> 31;
ulong ad = a & m31;
ulong bu = b >> 31;
ulong bd = b & m31;
ulong mid = ad * bu + au * bd;
ulong midu = mid >> 30;
ulong midd = mid & m30;
return au * bu * 2 + midu + (midd << 31) + ad * bd;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
ulong CalcMod(ulong x)
{
ulong xu = x >> 61;
ulong xd = x & MOD;
ulong res = xu + xd;
if (res >= MOD) res -= MOD;
return res;
}
}
public class Priority_Queue<T>
{
private List<T> Q;
private readonly Comparison<T> Func_Compare;
public Priority_Queue(Comparison<T> comp)
{
Func_Compare = comp;
Q = new List<T>();
}
private void PushHeap(List<T> list, T item)
{
int n = list.Count();
list.Add(item);
while (n != 0)
{
int pIndex = (n - 1) / 2;
if (Func_Compare(list[n], list[pIndex]) < 0)
{
Swap(Q, n, pIndex);
}
else { break; }
n = pIndex;
}
}
private void PopHeap(List<T> list)
{
int n = list.Count() - 1;
list[0] = list[n];
list.RemoveAt(n);
int cur = 0;
int comp;
while (2 * cur + 1 <= n - 1)
{
int c1 = 2 * cur + 1;
int c2 = 2 * (cur + 1);
if (c1 == n - 1)
{
comp = c1;
}
else
{
comp = Func_Compare(list[c1], list[c2]) < 0 ? c1 : c2;
}
if (Func_Compare(list[cur], list[comp]) > 0)
{
Swap(Q, cur, comp);
}
else { break; }
cur = comp;
}
}
private void Swap(List<T> list, int a, int b)
{
T keep = list[a];
list[a] = list[b];
list[b] = keep;
}
public void Enqueue(T value)
{
PushHeap(Q, value);
}
public T Dequeue()
{
T ret = Q[0];
PopHeap(Q);
return ret;
}
public T Peek()
{
return Q[0];
}
public int Count()
{
return Q.Count();
}
public bool Any()
{
return Q.Any();
}
}
public class SegmentTree<T>
{
//1-indexed type
int n;
T[] Tree;
Func<T, T, T> f;
T ex;
int L;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public SegmentTree(int size, Func<T, T, T> fun, T exvalue)
{
ex = exvalue;
f = fun;
n = 1;
while (n < size) n <<= 1;
Tree = new T[n << 1];
L = (n << 1) - 1;
for (var i = 0; i <= L; i++) Tree[i] = ex;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public SegmentTree(int size, Func<T, T, T> fun, T exvalue, T[] initial)
{
ex = exvalue;
n = 1; while (n < size) n <<= 1;
f = fun;
Tree = new T[n << 1];
L = (n << 1) - 1;
for (var i = 0; i <= L; i++) Tree[i] = (n <= i && i <= n + initial.Length - 1) ? initial[i - n] : ex;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Set_All()
{
for (var i = n - 1; i >= 1; i--) Tree[i] = f(Tree[i << 1], Tree[(i << 1) | 1]);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Assign(int idx, T nxt) => Tree[idx + n] = nxt;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Update(int idx)
{
int now = idx + n;
while (now > 1)
{
now >>= 1;
Tree[now] = f(Tree[now << 1], Tree[now << 1 | 1]);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Query_Update(int idx, T nxt)
{
Assign(idx, nxt); Update(idx);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Query_Update_func(int idx, T y)
{
Assign(idx, f(Peek(idx), y)); Update(idx);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public T Query_Fold(int l, int r)
{
int L = n + l;
int R = n + r;
T vL = ex, vR = ex;
while (L < R)
{
if (L % 2 == 1)
{
vL = f(vL, Tree[L]);
L++;
}
if (R % 2 == 1)
{
vR = f(Tree[R - 1], vR);
R--;
}
L >>= 1;
R >>= 1;
}
return f(vL, vR);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public T Peek(int idx) => Tree[idx + n];
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Display(int len)
{
for (var i = 0; i < len; i++) Console.Write($"{Tree[i + n]} ");
Console.WriteLine();
}
}
public class UnionFind
{
private int[] parent;
private int[] rank;
private int[] size;
public UnionFind(int n)
{
parent = new int[n];
rank = new int[n];
size = new int[n];
for (var i = 0; i < n; i++)
{
parent[i] = i;
rank[i] = 0;
size[i] = 1;
}
}
public int Root(int x)
{
return parent[x] == x ? x : parent[x] = Root(parent[x]);
}
public bool SameRoot(int x, int y)
{
return Root(x) == Root(y);
}
public void Unite(int x, int y)
{
x = Root(x);
y = Root(y);
if (x == y) { return; }
if (rank[x] < rank[y])
{
parent[x] = y;
size[y] += size[x];
size[x] = 0;
}
else
{
parent[y] = x;
if (rank[x] == rank[y]) { rank[x]++; }
size[x] += size[y];
size[y] = 0;
}
}
public int SizeOf(int x)
{
return size[Root(x)];
}
}
static class Cin
{
public static string[] ReadSplit => Console.ReadLine().Split();
public static int[] ReadSplitInt => ConvertAll(Console.ReadLine().Split(), int.Parse);
public static long[] ReadSplitLong => ConvertAll(Console.ReadLine().Split(), long.Parse);
public static double[] ReadSplit_Double => ConvertAll(Console.ReadLine().Split(), double.Parse);
public static string Str => Console.ReadLine();
public static int Int => int.Parse(Console.ReadLine());
public static long Long => long.Parse(Console.ReadLine());
public static double Double => double.Parse(Console.ReadLine());
public static T Conv<T>(string input)
{
if (typeof(T).Equals(typeof(ModInt)))
{
return (T)(dynamic)(long.Parse(input));
}
return (T)Convert.ChangeType(input, typeof(T));
}
public static void Input<T>(out T a) => a = Conv<T>(Console.ReadLine());
public static void Input<T, U>(out T a, out U b)
{ var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); }
public static void Input<T, U, V>(out T a, out U b, out V c)
{ var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); }
public static void Input<T, U, V, W>(out T a, out U b, out V c, out W d)
{ var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); d = Conv<W>(q[3]); }
public static void Input<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e)
{ var q = ReadSplit; a = Conv<T>(q[0]); b = Conv<U>(q[1]); c = Conv<V>(q[2]); d = Conv<W>(q[3]); e = Conv<X>(q[4]); }
}
static class Cout
{
public static void OutL(object s) => Console.WriteLine(s);
public static void Out_Sep<T>(IEnumerable<T> s) => Console.WriteLine(string.Join(" ", s));
public static void Out_Sep<T>(IEnumerable<T> s, string sep) => Console.WriteLine(string.Join($"{sep}", s));
public static void Out_Sep(params object[] s) => Console.WriteLine(string.Join(" ", s));
public static void Out_One(object s) => Console.Write($"{s} ");
public static void Out_One(object s, string sep) => Console.Write($"{s}{sep}");
public static void Endl() => Console.WriteLine();
}
public static class Tool
{
static public void Initialize<T>(ref T[] array, T initialvalue)
{
array = ConvertAll(array, x => initialvalue);
}
static public void Swap<T>(ref T a, ref T b)
{
T keep = a;
a = b;
b = keep;
}
static public void Display<T>(T[,] array2d, int n, int m)
{
for (var i = 0; i < n; i++)
{
for (var j = 0; j < m; j++)
{
Console.Write($"{array2d[i, j]} ");
}
Console.WriteLine();
}
}
static public long Gcd(long a, long b)
{
if (a == 0 || b == 0) return Max(a, b);
return a % b == 0 ? b : Gcd(b, a % b);
}
static public long LPow(int a, int b) => (long)Pow(a, b);
static public bool Bit(long x, int dig) => ((1L << dig) & x) != 0;
static public int Sig(long a) => a == 0 ? 0 : (int)(a / Abs(a));
}
}