public void Solve()
{
var n = sc.Integer();
var G = Enumerate(n, x => new List <int>());
for (int i = 0; i < n - 1; i++)
{
var f = sc.Integer() - 1;
var t = sc.Integer() - 1;
G[f].Add(t);
G[t].Add(f);
}
Func <int, int, ModInteger[]> dfs = null;
dfs = (prev, cur) =>
{
var ret = new ModInteger[2] {
1, 1
};
foreach (var to in G[cur])
{
if (prev == to)
{
continue;
}
var res = dfs(cur, to);
ret[0] *= res[0] + res[1];
ret[1] *= res[0];
}
return(ret);
};
var ans = dfs(-1, 0);
IO.Printer.Out.WriteLine(ans[0] + ans[1]);
}
public void Solve()
{
var n = sc.Integer();
var s = sc.Scan();
//const int MOD = (int)ModInteger.Mod;
var dp = new ModInteger[n + 1];
dp[0] = 1;
for (int _ = 0; _ < n; _++)
{
var next = new ModInteger[n + 1];
for (int i = 0; i < n; i++)
{
next[i + 1] += dp[i];
//if (next[i + 1] >= MOD) next[i + 1] -= MOD;
next[i + 1] += dp[i];
//if (next[i + 1] >= MOD) next[i + 1] -= MOD;
var p = Math.Max(0, i - 1);
next[p] += dp[i];
//if (next[p] >= MOD) next[p] -= MOD;
}
dp = next;
}
ModInteger res = dp[s.Length];
var k = ModInteger.Pow(2, s.Length);
res *= ModInteger.Pow(k, ModInteger.Mod - 2);
IO.Printer.Out.WriteLine(res);
}
public void Solve()
{
var a = sc.Long();
var b = sc.Long();
ModInteger.Mod = sc.Integer();
var mat = new ModMatrix(2, 2);
mat[0, 0] = 10;
mat[0, 1] = 1;
mat[1, 1] = 1;
var vec = new ModMatrix(2, 1);
vec[0, 0] = 1;
vec[0, 1] = 1;
var gcd = MathEx.GCD(a, b);
var A = (ModMatrix.Pow(mat, a - 1) * vec)[0, 0];
mat[0, 0] = ModInteger.Pow(10, gcd);
var B = (ModMatrix.Pow(mat, b / gcd - 1) * vec)[0, 0];
IO.Printer.Out.WriteLine(A * B);
//IO.Printer.Out.WriteLine(A * B * ModInteger.Inverse(GCD));
}
public void Solve()
{
var n = sc.Integer();
var s = sc.Scan();
var dp = new ModInteger[n + 1];
var next = new ModInteger[n + 1];
dp[0] = 1;
for (int _ = 0; _ < n; _++)
{
for (int i = 0; i < n; i++)
{
next[i + 1] += dp[i];
next[i + 1] += dp[i];
next[Math.Max(0, i - 1)] += dp[i];
}
for (int i = 0; i <= n; i++)
{
dp[i] = next[i];
next[i] = 0;
}
}
var res = dp[s.Length];
var k = ModInteger.Pow(2, s.Length);
res *= ModInteger.Pow(k, ModInteger.Mod - 2);
IO.Printer.Out.WriteLine(res);
}
public static ModInteger operator -(ModInteger l, ModInteger r)
{
var n = new ModInteger(); n.num = l.num + Mod - r.num; if (n.num >= Mod)
{
n.num -= Mod;
}
return(n);
}
public void Solve()
{
var n = sc.Integer();
var m = sc.Integer();
var max = Enumerate(n, x => x);
var s = sc.Scan();
for (int i = 0; i < m; i++)
{
var l = sc.Integer() - 1;
var r = sc.Integer() - 1;
max[l] = Math.Max(max[l], r);
}
for (int i = 1; i < n; i++)
{
max[i] = Math.Max(max[i], max[i - 1]);
}
var dp = new ModInteger[n + 1];
dp[0] = 1;
var a = 0; var b = 0;
for (int i = 0, r = 0; i < n; i++)
{
while (r <= max[i])
{
if (s[r] == '0')
{
a++;
}
else
{
b++;
} r++;
}
var next = new ModInteger[n + 1];
for (int j = 0; j <= n; j++)
{
if (dp[j].num == 0)
{
continue;
}
if (j + 1 <= a)
{
next[j + 1] += dp[j];
}
var k = i - j;
if (k + 1 <= b)
{
next[j] += dp[j];
}
}
dp = next;
}
IO.Printer.Out.WriteLine(dp[a]);
}
public static ModInteger operator +(ModInteger l, ModInteger r)
{
var n = new ModInteger()
{
num = l.num + r.num
}; if (n.num >= Mod)
{
n.num -= Mod;
}
return(n);
}
public static ModInteger Pow(ModInteger v, long k)
{
ModInteger ret = 1;
var n = k;
for (; n > 0; n >>= 1, v *= v)
{
if ((n & 1) == 1)
{
ret = ret * v;
}
}
return(ret);
}
public void Solve()
{
var n = sc.Integer();
var A = sc.Long();
var B = sc.Long();
var a = new BigInteger[n];
for (int i = 0; i < n; i++)
{
a[i] = sc.Long();
}
Array.Sort(a);
if (A == 1)
{
for (int i = 0; i < n; i++)
{
IO.Printer.Out.WriteLine(a[i]);
}
return;
}
while (B > 0)
{
if (a[n - 1] < a[0] * A)
{
break;
}
a[0] *= A;
Array.Sort(a);
Debug.WriteLine(a.AsJoinedString());
B--;
}
Debug.WriteLine(B);
var k = B / n;
var rem = B % n;
while (rem > 0)
{
a[0] *= A;
Array.Sort(a);
rem--;
}
for (int i = 0; i < n; i++)
{
var v = a[i] % 1000000007;
v = (v * ModInteger.Pow(A, k).num) % 1000000007;
IO.Printer.Out.WriteLine(v);
}
}
public ModTable(int n)
{
perm = new ModInteger[n + 1];
inv = new ModInteger[n + 1];
perm[0] = 1;
for (int i = 1; i <= n; i++)
{
perm[i] = perm[i - 1] * i;
}
inv[n] = ModInteger.Inverse(perm[n]);
for (int i = n - 1; i >= 0; i--)
{
inv[i] = inv[i + 1] * (i + 1);
}
inv[0] = inv[1];
}
public void Solve()
{
var n = sc.Integer();
var A = new int[n];
var B = new int[n];
const int ADD = 2100;
var dp = Enumerate(4200, x => new ModInteger[4200]);
for (int i = 0; i < n; i++)
{
A[i] = sc.Integer();
B[i] = sc.Integer();
dp[ADD - A[i]][ADD - B[i]] += 1;
}
for (int i = 1; i < 4200; i++)
{
for (int j = 1; j < 4200; j++)
{
dp[i][j] += dp[i - 1][j] + dp[i][j - 1];
}
}
ModInteger sum = 0;
for (int i = 0; i < n; i++)
{
sum += dp[ADD + A[i]][ADD + B[i]];
}
var fact = new ModInteger[8200];
var inv = new ModInteger[8200];
fact[0] = inv[0] = 1;
for (int i = 1; i < 8200; i++)
{
fact[i] = fact[i - 1] * i;
inv[i] = ModInteger.Inverse(fact[i]);
}
for (int i = 0; i < n; i++)
{
sum -= fact[2 * A[i] + 2 * B[i]] * inv[2 * A[i]] * inv[2 * B[i]];
}
sum *= ModInteger.Inverse(2);
IO.Printer.Out.WriteLine(sum);
}
public void Solve()
{
var n = sc.Integer();
var a = sc.Integer();
var b = sc.Integer();
var c = sc.Integer();
var d = sc.Integer();
var table = new ModTable(2 * n);
var dp = new ModInteger[n + 1];
dp[0] = 1;
for (int sz = a; sz <= b; sz++)
{
var next = new ModInteger[n + 1];
for (int i = 0; i <= n; i++)
{
if (dp[i].num == 0)
{
continue;
}
ModInteger all = 1;
var size = i;
for (int k = 1; k <= d; k++)
{
size += sz;
if (size > n)
{
break;
}
all *= table.Combination(n - size + sz, sz);
if (c <= k && k <= d)
{
next[size] += dp[i] * all * table.invp[k];
}
}
}
for (int j = 0; j <= n; j++)
{
dp[j] += next[j];
}
//Debug.WriteLine(dp.AsJoinedString());
}
IO.Printer.Out.WriteLine(dp[n]);
}
ModInteger f(int[] a)
{
var n = a.Length;
ModInteger ret = 0;
var d = new ModInteger[n - 1];
for (int i = 0; i < n - 1; i++)
{
d[i] = a[i + 1] - a[i];
}
for (int i = 0; i < n - 1; i++)
{
var l = i + 1;
var r = n - l;
ret += d[i] * l * r;
}
return(ret);
}
ModInteger f(int n, int m)
{
this.n = n; this.m = m;
dp = new ModInteger[m, n + 1];
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n + 1; j++)
{
dp[i, j].num = -1;
}
}
ModInteger ans = 0;
for (int i = 0; i <= n; i++)
{
ans += dfs(0, i);
}
return(ans);
}
public void Solve()
{
var n = sc.Integer();
var s = sc.Scan();
const long MOD = ModInteger.Mod;
var dp = new long[n + 1];
var next = new long[n + 1];
dp[0] = 1;
for (int _ = 0; _ < n; _++)
{
for (int i = 0; i < n; i++)
{
next[i + 1] += dp[i];
if (next[i + 1] >= MOD)
{
next[i + 1] -= MOD;
}
next[i + 1] += dp[i];
if (next[i + 1] >= MOD)
{
next[i + 1] -= MOD;
}
var p = Math.Max(0, i - 1);
next[p] += dp[i];
if (next[p] >= MOD)
{
next[p] -= MOD;
}
}
for (int i = 0; i <= n; i++)
{
dp[i] = next[i];
next[i] = 0;
}
}
ModInteger res = dp[s.Length];
var k = ModInteger.Pow(2, s.Length);
res *= ModInteger.Pow(k, ModInteger.Mod - 2);
IO.Printer.Out.WriteLine(res);
}
public void Solve()
{
var n = sc.Integer();
var c = sc.Integer();
var a = sc.Integer(n);
var b = sc.Integer(n);
var dp = new ModInteger[c + 1];
dp[0] = 1;
var range = new ModInteger[420, 420];
for (int i = 1; i < 420; i++)
{
range[i, 0] = 1;
for (int k = 1; k < 420; k++)
{
range[i, k] = range[i, k - 1] * i;
}
}
for (int k = 0; k < 420; k++)
{
for (int i = 1; i < 420; i++)
{
range[i, k] += range[i - 1, k];
}
}
for (int i = 0; i < n; i++)
{
var next = new ModInteger[c + 1];
for (int j = 0; j <= c; j++)
{
for (int l = 0; j + l <= c; l++)
{
next[j + l] += dp[j] * (range[b[i], l] - range[a[i] - 1, l]);
}
}
dp = next;
}
IO.Printer.Out.WriteLine(dp[c]);
}
public void Solve()
{
var n = sc.Integer();
var m = sc.Integer();
var k = sc.Integer();
var table = new ModTable(n + m + k + 1);
ModInteger ans = 0;
ModInteger C = 1;
var l = 0;
var r = 0;
for (int i = n; i <= n + m + k; i++)
{
var a = table.Combination(i - 1, n - 1);
a *= ModInteger.Pow(3, n + m + k - i);
a *= C;
ans += a;
C *= 2;
var rem = i - n + 1;
Debug.WriteLine("{0} {1}", l, r);
var nl = Math.Max(0, rem - k);
var nr = Math.Min(m, rem);
if (l != nl)
{
C -= table.Combination(i - n, l);
}
if (r == nr)
{
C -= table.Combination(i - n, r);
}
else if (r > nr)
{
C -= table.Combination(i - n, r) * 2;
}
l = nl;
r = nr;
}
IO.Printer.Out.WriteLine(ans);
}
public void Solve()
{
var n = sc.Integer();
var k = sc.Integer();
ModInteger ans = 0;
var div = MathEx.GetDivisors(n);
var dp = new ModInteger[div.Count];
for (int i = 0; i < div.Count; i++)
{
if (n % 2 == 0)
{
dp[i] += ModInteger.Pow(k, div[i]);
}
else
{
dp[i] += ModInteger.Pow(k, div[i] / 2 + 1);
}
for (int j = 0; j < i; j++)
{
if (div[i] % div[j] == 0)
{
dp[i] -= dp[j];
}
}
if (n % 2 == 0 && (n / div[i]) % 2 == 0)
{
ans += dp[i] * div[i];
}
if (n % 2 == 1)
{
ans += dp[i] * div[i];
}
}
Debug.WriteLine(dp.AsJoinedString());
//naive(n, k);
IO.Printer.Out.WriteLine(ans);
}
public void Solve()
{
var n = sc.Integer();
var l = sc.Long(n).Distinct().ToArray();
Array.Sort(l);
var ans = ModInteger.Pow(2, l[0]);
var gcd = 0L;
foreach (var x in l.Skip(1).Select(x => x - l[0]))
{
if (gcd == 0)
{
gcd = x;
}
else
{
gcd = MathEx.GCD(gcd, x);
}
}
ans *= ModInteger.Pow(2, (gcd + 1) / 2);
IO.Printer.Out.WriteLine(ans);
}
ModInteger dfs(int i, int j)
{
if (i == m)
{
return(1);
}
if (dp[i, j].num != -1)
{
return(dp[i, j]);
}
ModInteger ret = 0;
var k = n - j;
if (j > 0)
{
ret += dfs(i + 1, j - 1) + dfs(i + 1, j);
}
if (k > 0)
{
ret += dfs(i + 1, j + 1) + dfs(i + 1, j);
}
return(dp[i, j] = ret);
}
public void Solve()
{
var n = sc.Integer();
var ep = new ModInteger[n + 50];
var cum = new ModInteger[n + 50];
for (int i = 0; i <= n; i++)
{
ep[i].num = -1;
}
ep[0] = 1;
ep[1] = n;
Func <int, ModInteger> dfs = null;
dfs = m =>
{
//Debug.WriteLine(m);
if (m < 0)
{
return(1);
}
if (ep[m].num != -1)
{
return(ep[m]);
}
ModInteger ret = 0;
for (int i = 1; i <= n; i++)
{
//1
if (i == 1)
{
ret += dfs(m - i);
}
else
{
ret += dfs(m - i - 1);
}
if (i != 1)
{
ret += n - 1;
}
}
return(ep[m] = ret);
};
dfs(2);
//Debug.WriteLine(dfs(n));
ep[0] = 1;
ep[1] = n;
cum[0] = ep[0];
cum[1] = ep[0] + ep[1];
cum[2] = cum[1] + ep[2];
for (int m = 3; m <= n; m++)
{
ModInteger ret = 0;
ret += ep[m - 1];
ret += cum[m - 3];
ret += n - m + 1;
ModInteger val = n - 1; val *= n - 1;
ret += val;
ep[m] = ret;
cum[m] = cum[m - 1] + ep[m];
}
//Debug.WriteLine(ep.AsJoinedString());
IO.Printer.Out.WriteLine(ep[n]);
}
public void Solve()
{
var n = sc.Integer();
var a = sc.Integer(n);
var RG = Enumerate(n, x => new List <int>());
var RA = Enumerate(n, x => - 1);
var size = new int[n];
var iscycle = Enumerate(n, x => true);
var s = new DisjointSet(n);
var t = new DisjointSet(n);
{
var d = new int[n];
var g = Enumerate(n, x => new List <int>());
for (int i = 0; i < n; i++)
{
a[i]--;
g[i].Add(a[i]);
RG[a[i]].Add(i);
s.Unite(i, a[i]);
d[a[i]]++;
}
if (d.Any(x => x >= 3))
{
Debug.WriteLine("hoge");
IO.Printer.Out.WriteLine(0); return;
}
foreach (var x in Graph.TopologicalSort(g))
{
iscycle[x] = false;
}
for (int i = 0; i < n; i++)
{
if (iscycle[i] && iscycle[a[i]])
{
t.Unite(i, a[i]);
RA[a[i]] = i;
}
if (!iscycle[i] && !iscycle[a[i]])
{
t.Unite(i, a[i]);
}
}
for (int i = 0; i < n; i++)
{
if (!iscycle[i] && RG[i].Count > 1)
{
Debug.WriteLine("turai");
IO.Printer.Out.WriteLine(0);
return;
}
}
for (int i = 0; i < n; i++)
{
if (!iscycle[i] && iscycle[a[i]])
{
size[a[i]] = t.Size(i);
}
}
}
ModInteger ans = 1;
//??: cycle, namori
var cycle = new int[n + 1];
{
var used = new bool[n];
Func <int, int, int, ModInteger> dfs = null;
dfs = (cur, sz, d) =>
{
Debug.WriteLine($"{cur} {sz} {d}");
if (sz == -1 && size[cur] == 0)
{
return(dfs(RA[cur], -1, -1));
}
else if (size[cur] == 0)
{
used[cur] = true;
return(dfs(RA[cur], sz, d + 1));
}
else
{
ModInteger ret = 0;
if (sz == -1)
{
ret = 1;
}
if (sz > d)
{
ret = 0;
}
else if (sz == d)
{
ret = 1;
}
else
{
ret = 2;
}
if (used[cur])
{
return(ret);
}
used[cur] = true;
ret *= dfs(RA[cur], size[cur], 1);
return(ret);
}
};
for (int i = 0; i < n; i++)
{
if (s[i] == i)
{
if (s.Size(i) == t.Size(i))
{
cycle[s.Size(i)]++;
}
}
}
for (int i = 0; i < n; i++)
{
if (s.Size(i) != t.Size(i) && RA[i] != -1 && !used[i])
{
ans *= dfs(i, -1, -1);
}
}
}
//IO.Printer.Out.WriteLine(ans);
//return;
//cycle
for (int i = 0; i <= n; i++)
{
if (cycle[i] == 0)
{
continue;
}
var k = cycle[i];
var dp = new ModInteger[k + 1];
for (int j = 0; j <= k; j++)
{
dp[j].num = -1;
}
Func <int, ModInteger> dfs = null;
dfs = m =>
{
if (m == 0)
{
return(1);
}
else if (m < 0)
{
return(0);
}
if (dp[m].num != -1)
{
return(dp[m]);
}
var ret = dfs(m - 1);
if (i % 2 != 0 && i != 1)
{
ret *= 2;
}
ret += dfs(m - 2) * i * (m - 1);
return(dp[m] = ret);
};
ans *= dfs(k);
}
IO.Printer.Out.WriteLine(ans);
}
public static ModInteger operator ^(ModInteger l, long r)
{
return(ModInteger.Pow(l, r));
}
public void Solve()
{
var n = ri;
var m = ri;
var Q = Enumerate(n + 1, x => new List <KeyValuePair <int, int> >());
for (int i = 0; i < m; i++)
{
var l = ri;
var r = ri;
var x = ri;
Q[r].Add(new KeyValuePair <int, int>(l, x));
}
ModInteger ans = 0;
var dp = new int[28372625];
dp[0] = 1;
for (int i = 0; i <= n; i++)
{
for (int j = i; j <= n; j++)
{
for (int k = j; k <= n; k++)
{
var s = enc(i, j, k);
if (dp[s] == 0)
{
continue;
}
//Debug.WriteLine("{0} {1} {2} {3}", i, j, k, dp[i, j, k]);
var max = Max(i, Max(j, k));
var ok = true;
foreach (var q in Q[max])
{
var cnt = 0;
if (q.Key <= i)
{
cnt++;
}
if (q.Key <= j)
{
cnt++;
}
if (q.Key <= k)
{
cnt++;
}
if (cnt != q.Value)
{
ok = false;
break;
}
}
if (!ok)
{
continue;
}
dp[s] %= 1000000007;
if (max == n)
{
ans += dp[s];
}
dp[enc(j, k, max + 1)] += dp[s];
dp[enc(j, k, max + 1)] %= 1000000007;
dp[enc(i, k, max + 1)] += dp[s];
dp[enc(i, k, max + 1)] %= 1000000007;
dp[enc(i, j, max + 1)] += dp[s];
dp[enc(i, j, max + 1)] %= 1000000007;
}
}
}
IO.Printer.Out.WriteLine(ans);
}
public void Solve()
{
var n = sc.Integer();
var k = sc.Integer();
var a = n / k;
var b = n % k;
var fact = new ModInteger[2050];
for (int i = (int)(fact[0] = 1).num; i < 2050; i++)
{
fact[i] = i * fact[i - 1];
}
var C = new ModInteger[4050, 4050];
C[0, 0] = 1;
for (int i = 0; i < 4010; i++)
{
for (int j = 0; j < 4010; j++)
{
C[i + 1, j] += C[i, j];
C[i + 1, j + 1] += C[i, j];
}
}
//dp(i,j) = i ????????? j ????????????
var dp2 = Enumerate(2050, x => new ModInteger[2050]);
dp2[0][0] = 1;
for (int i = 0; i < 2010; i++)
{
for (int j = 0; j < 2010; j++)
{
dp2[i + 1][j] += dp2[i][j];
dp2[i + 2][j + 1] += dp2[i][j];
}
}
var dp = new ModInteger[1];
dp[0] = 1;
for (int _ = 0; _ < 2; _++)
{
for (int mod = 0; mod < k; mod++)
{
var sz = a;
if (mod < b)
{
sz++;
}
var next = new ModInteger[sz + dp.Length];
for (int i = 0; i < dp.Length; i++)
{
for (int j = 0; j < sz; j++)
{
next[i + j] += dp[i] * dp2[sz][j];
}
}
dp = next;
}
}
for (int i = n; i >= 0; i--)
{
dp[i] *= fact[n - i];
for (int j = i + 1; j < dp.Length; j++)
{
dp[i] -= C[j, i] * dp[j];
}
}
IO.Printer.Out.WriteLine(dp[0]);
}
