Created
June 22, 2020 18:27
-
-
Save SamZhangQingChuan/23533064b1705149bb141c6ae1fd1023 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#pragma comment(linker, "/stack:200000000") | |
#pragma GCC optimize("Ofast") | |
//#pragma GCC optimize(3) | |
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native") | |
//#pragma GCC target("sse3","sse2","sse") | |
//#pragma GCC target("avx","sse4","sse4.1","sse4.2","ssse3") | |
//#pragma GCC target("f16c") | |
//#pragma GCC optimize("inline","fast-math","unroll-loops","no-stack-protector") | |
//#pragma GCC diagnostic error "-fwhole-program" | |
//#pragma GCC diagnostic error "-fcse-skip-blocks" | |
//#pragma GCC diagnostic error "-funsafe-loop-optimizations" | |
//#pragma GCC diagnostic error "-std=c++14" | |
#include "bits/stdc++.h" | |
#include "ext/pb_ds/tree_policy.hpp" | |
#include "ext/pb_ds/assoc_container.hpp" | |
#define PB push_back | |
#define PF push_front | |
#define LB lower_bound | |
#define UB upper_bound | |
#define fr(x) freopen(x,"r",stdin) | |
#define fw(x) freopen(x,"w",stdout) | |
#define REP(x, l, u) for(ll x = l;x<u;x++) | |
#define RREP(x, l, u) for(ll x = l;x>=u;x--) | |
#define complete_unique(a) a.erase(unique(begin(a),end(a)),end(a)) | |
#define mst(x, a) memset(x,a,sizeof(x)) | |
#define all(a) begin(a),end(a) | |
#define rall(a) rbegin(a),rend(a) | |
#define PII pair<int,int> | |
#define PLL pair<ll,ll> | |
#define MP make_pair | |
#define lowbit(x) ((x)&(-(x))) | |
#define bitcnt(x) (__builtin_popcountll(x)) | |
#define lson (ind<<1) | |
#define rson (ind<<1|1) | |
#define se second | |
#define fi first | |
#define sz(x) ((int)x.size()) | |
#define EX0 exit(0); | |
typedef long long ll; | |
typedef unsigned long long ull; | |
typedef double db; | |
typedef long double ld; | |
using namespace __gnu_pbds; //required | |
using namespace std; | |
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; | |
typedef vector<ll> VLL; | |
typedef vector<int> VI; | |
const ll mod = 998244353; | |
string to_string (string s) { return '"' + s + '"'; } | |
string to_string (const char *s) { return to_string ((string) s); } | |
string to_string (bool b) { return (b ? "true" : "false"); } | |
template<typename A, typename B> | |
string to_string (pair<A, B> p) { return "(" + to_string (p.first) + ", " + to_string (p.second) + ")"; } | |
template<typename A> | |
string to_string (A v) { | |
bool first = true; | |
string res = "{"; | |
for (const auto &x : v) { | |
if (!first) { res += ", "; } | |
first = false; | |
res += to_string (x); | |
} | |
res += "}"; | |
return res; | |
} | |
void debug_out () { cerr<<endl; } | |
template<typename Head, typename... Tail> | |
void debug_out (Head H, Tail... T) { | |
cerr<<" "<<to_string (H); | |
debug_out (T...); | |
} | |
#ifdef LOCAL | |
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__) | |
#else | |
#define dbg(...) {} | |
#endif | |
template<typename T, typename S> | |
inline bool upmin (T &a, const S &b) { return a > b ? a = b, 1 : 0; } | |
template<typename T, typename S> | |
inline bool upmax (T &a, const S &b) { return a < b ? a = b, 1 : 0; } | |
ull twop (ll x) { return 1ULL<<x; } | |
ll MOD (ll a, ll m) { | |
a %= m; | |
if (a < 0)a += m; | |
return a; | |
} | |
ll inverse (ll a, ll m) { | |
a = MOD (a, m); | |
if (a <= 1)return a; | |
return MOD ((1 - inverse (m, a) * m) / a, m); | |
} | |
template<typename T> | |
T sqr (T x) { return x * x; } | |
ll gcd (ll a, ll b) { | |
a = abs (a), b = abs (b); | |
while (b != 0) { | |
a %= b; | |
swap (a, b); | |
} | |
return a; | |
} | |
ll fast (ll a, ll b, ll mod) { | |
a %= mod; | |
if (b < 0)a = inverse (a, mod), b = -b; | |
ll ans = 1; | |
while (b) { | |
if (b & 1)ans = ans * a % mod; | |
a = a * a % mod; | |
b /= 2; | |
} | |
return ans % mod; | |
} | |
struct SAM { | |
static const int maxn = 300010 * 2; | |
struct Node { | |
Node *nxt[26], *fail; | |
int cnt; | |
int len; | |
}; | |
Node *root; | |
int cnt; | |
Node no[maxn]; | |
Node *newNode () { | |
memset (&no[cnt], 0, sizeof (Node)); | |
return &no[cnt++]; | |
} | |
void init () { | |
cnt = 0; | |
root = newNode (); | |
} | |
SAM () { | |
init (); | |
} | |
void add (const string &s) { | |
Node *cur = root; | |
REP(i, 0, sz (s)) { | |
cur = add (cur, s[i] - 'a'); | |
} | |
} | |
Node *add (Node *p, int c) { | |
Node *cur = newNode (); | |
cur->len = p->len + 1; | |
while (p && !p->nxt[c])p->nxt[c] = cur, p = p->fail; | |
if (!p) { | |
cur->fail = root; | |
return cur; | |
} | |
Node *q = p->nxt[c]; | |
if (q->len == p->len + 1) { | |
cur->fail = q; | |
} else { | |
Node *nq = newNode (); | |
*nq = *q; | |
nq->len = p->len + 1; | |
q->fail = cur->fail = nq; | |
while (p && p->nxt[c] == q)p->nxt[c] = nq, p = p->fail; | |
} | |
return cur; | |
} | |
void pre (const string &s) { | |
Node *cur = root; | |
REP(i, 0, sz (s)) { | |
cur = cur->nxt[s[i] - 'a']; | |
cur->cnt++; | |
} | |
} | |
//call pre first | |
//return sum of cnt | |
void getCnt () { | |
vector<Node *> v; | |
REP(i, 1, cnt) { | |
v.PB (&no[i]); | |
} | |
sort (all(v), [] (const Node *a, const Node *b) { | |
return a->len > b->len; | |
}); | |
REP(i, 0, sz (v)) { | |
v[i]->fail->cnt += v[i]->cnt; | |
} | |
} | |
vector<pair<PLL, ll> > getNumOfDistinctSubstrings () { | |
vector<pair<PLL, ll> > ans; | |
REP(i, 1, cnt)ans.emplace_back (MP (no[i].len, no[i].fail->len), no[i].cnt); | |
return (ans); | |
} | |
}; | |
namespace SOLVE { | |
SAM sam; | |
VLL v[200010]; | |
ll ans[200010]; | |
void main () { | |
sam.init (); | |
string s; | |
int k; | |
cin>>s>>k; | |
fill (ans, ans + sz(s) + 1, 0); | |
REP(i, 0, sz (s) + 5)v[i].clear (); | |
sam.add (s); | |
sam.pre (s); | |
sam.getCnt (); | |
auto res = sam.getNumOfDistinctSubstrings (); | |
for (auto i:res) { | |
v[i.fi.se + 1].PB (i.se); | |
v[i.fi.fi + 1].PB (-i.se); | |
} | |
REP(i, 0, sz (s) + 1) { | |
dbg(i, v[i]); | |
} | |
VLL sum (k + 1, 0); | |
sum[0] = 1; | |
ll fac = 1; | |
REP(i, 1, k + 1) { | |
fac = fac * i % mod; | |
} | |
REP(i, 0, sz (s) + 1) { | |
for (auto cnt:v[i]) { | |
if (cnt > 0) { | |
RREP(j, k, 1)sum[j] = (sum[j] + sum[j - 1] * cnt) % mod; | |
} else { | |
REP(j, 1, k + 1) { | |
sum[j] = MOD (sum[j] + sum[j - 1] * cnt, mod); | |
} | |
} | |
} | |
ans[i] = sum[k] * fac % mod; | |
dbg(ans[i]); | |
} | |
REP(i, 1, sz (s) + 1) { | |
ans[i] = ans[i] * fast (sz(s) - i + 1, -k, mod) % mod; | |
cout<<ans[i]<<" "; | |
} | |
cout<<"\n"; | |
} | |
} | |
signed main () { | |
#ifdef LOCAL | |
fr("/Users/zhangqingchuan/Desktop/cp/cp/input.txt"); | |
fw("/Users/zhangqingchuan/Desktop/cp/cp/output.txt"); | |
#endif | |
ios::sync_with_stdio (false); | |
cin.tie (nullptr); | |
cout.tie (nullptr); | |
int t = 1; | |
cin>>t; | |
for (int i = 1; i <= t; i++) { | |
// cout<<"Case #"<<i<<": "; | |
SOLVE::main (); | |
} | |
// clock_t st = clock(); | |
// while(clock() - st < 3.0 * CLOCKS_PER_SEC){ | |
// | |
// } | |
return 0; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment