結果

問題 No.315 世界のなんとか3.5
ユーザー 🍮かんプリン
提出日時 2022-11-01 09:37:04
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 994 ms / 2,000 ms
コード長 15,598 bytes
コンパイル時間 2,415 ms
コンパイル使用メモリ 196,612 KB
実行使用メモリ 6,944 KB
最終ジャッジ日時 2024-07-16 04:42:22
合計ジャッジ時間 16,056 ms
ジャッジサーバーID
(参考情報)
judge3 / judge1
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 36
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

/**
* @FileName a.cpp
* @Author kanpurin
* @Created 2022.11.01 09:37:00
**/
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
template< int MOD >
struct mint {
public:
unsigned int x;
mint() : x(0) {}
mint(long long v) {
long long w = (long long)(v % (long long)(MOD));
if (w < 0) w += MOD;
x = (unsigned int)(w);
}
mint(std::string &s) {
unsigned int z = 0;
for (int i = 0; i < s.size(); i++) {
z *= 10;
z += s[i] - '0';
z %= MOD;
}
x = z;
}
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint& operator+=(const mint &a) {
if ((x += a.x) >= MOD) x -= MOD;
return *this;
}
mint& operator-=(const mint &a) {
if ((x -= a.x) >= MOD) x += MOD;
return *this;
}
mint& operator*=(const mint &a) {
unsigned long long z = x;
z *= a.x;
x = (unsigned int)(z % MOD);
return *this;
}
mint& operator/=(const mint &a) {return *this = *this * a.inv(); }
friend mint operator+(const mint& lhs, const mint& rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint& lhs, const mint& rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint& lhs, const mint& rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint& lhs, const mint& rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint& lhs, const mint& rhs) {
return lhs.x == rhs.x;
}
friend bool operator!=(const mint& lhs, const mint& rhs) {
return lhs.x != rhs.x;
}
friend std::ostream& operator<<(std::ostream &os, const mint &n) {
return os << n.x;
}
friend std::istream &operator>>(std::istream &is, mint &n) {
unsigned int x;
is >> x;
n = mint(x);
return is;
}
mint inv() const {
assert(x);
return pow(MOD-2);
}
mint pow(long long n) const {
assert(0 <= n);
mint p = *this, r = 1;
while (n) {
if (n & 1) r *= p;
p *= p;
n >>= 1;
}
return r;
}
mint sqrt() const {
if (this->x < 2) return *this;
if (this->pow((MOD-1)>>1).x != 1) return mint(0);
mint b = 1, one = 1;
while (b.pow((MOD-1) >> 1) == 1) b += one;
long long m = MOD-1, e = 0;
while (m % 2 == 0) m >>= 1, e += 1;
mint x = this->pow((m - 1) >> 1);
mint y = (*this) * x * x;
x *= (*this);
mint z = b.pow(m);
while (y.x != 1) {
int j = 0;
mint t = y;
while (t != one) j += 1, t *= t;
z = z.pow(1LL << (e-j-1));
x *= z; z *= z; y *= z; e = j;
}
return x;
}
};
constexpr int MOD = 1e9 + 7;
struct Monoid {
using T = mint<MOD>;
T val;
bool undef = true;
Monoid() { *this = zero(); }
Monoid(T val, bool undef = true) : val(val),
undef(undef) {}
static Monoid zero() { return Monoid(0); }
static Monoid e() { return Monoid(1,false); }
Monoid& operator+=(const Monoid &a) {
if (this->undef) *this = a;
else if (!a.undef) this->val += a.val;
return *this;
}
Monoid& operator*=(int c) {
return *this;
}
friend Monoid operator+(const Monoid& a, const Monoid& b) {
return Monoid(a) += b;
}
friend Monoid operator*(const Monoid& a, int c) {
return Monoid(a) *= c;
}
friend std::ostream& operator<<(std::ostream &os, const Monoid &x) {
return os << x.val;
}
};
struct Automaton {
vector<vector<int>> delta;
vector<bool> is_accept, is_reject;
int qsize;
int init;
int alphabet_size = 10;
inline int next(int state, int c) const { return delta[state][c]; }
inline bool accept(int state) const { return is_accept[state]; }
inline bool reject(int state) const { return is_reject[state]; }
inline int size() const {return qsize; }
};
struct IndexAutomaton {
vector<bool> is_accept, is_reject;
int qsize;
int init;
int alphabet_size = 10;
function<int(int,int,int)> next;
inline bool accept(int state) const { return is_accept[state]; }
inline bool reject(int state) const { return is_reject[state]; }
inline int size() const {return qsize; }
};
struct LeqIndexAutomaton : public IndexAutomaton {
private:
const int tight = 0;
const int loose = 1;
const int dead = 2;
string str;
bool eq;
void initializer() {
qsize = 3;
init = tight;
next = [&](int state, int c, int n) -> int {
if (n >= str.size() || state == dead) return dead;
if (state == tight) {
if (c == str[n]-'0') return tight;
if (c < str[n]-'0') return loose;
return dead;
}
return loose;
};
set_is_accept();
set_is_reject();
}
void set_is_accept() {
is_accept.resize(qsize,false);
is_accept[tight] = eq;
is_accept[loose] = true;
}
void set_is_reject() {
is_reject.resize(qsize,false);
is_reject[dead] = true;
}
public:
function<int(int,int,int)> next;
LeqIndexAutomaton(string s, bool eq = true, int alpha_size = 10) : str(s),
eq(eq) {
alphabet_size = alpha_size;
initializer();
}
};
struct ModuloAutomaton : public Automaton {
private:
int mod;
void initializer() {
qsize = mod;
init = 0;
set_delta();
set_is_accept();
set_is_reject();
}
void set_delta() {
delta.resize(qsize,vector<int>(alphabet_size));
for (int state = 0; state < qsize; state++) {
for (int c = 0; c < alphabet_size; c++) {
delta[state][c] = (state*10+c)%mod;
}
}
}
void set_is_accept() {
is_accept.resize(qsize,false);
is_accept[0] = true;
}
void set_is_reject() {
is_reject.resize(qsize,false);
}
public:
ModuloAutomaton(int mod, int alpha_size = 10) : mod(mod) {
alphabet_size = alpha_size;
initializer();
}
};
struct ZigZagAutomaton : public Automaton {
private:
void initializer() {
qsize = 2+alphabet_size*3;
init = alphabet_size*3;
set_delta();
set_is_accept();
set_is_reject();
}
void set_delta() {
delta.resize(qsize,vector<int>(alphabet_size));
for (int state = 0; state < qsize; state++) {
for (int c = 0; c < alphabet_size; c++) {
if (state == alphabet_size*3) {
if (c == 0)
delta[state][c] = alphabet_size*3;
else
delta[state][c] = c;
}
else if (state < alphabet_size) {
if (c < state)
delta[state][c] = alphabet_size+c;
else if (c > state)
delta[state][c] = alphabet_size*2+c;
else
delta[state][c] = alphabet_size*3+1;
}
else if (state < alphabet_size*2) {
if (c > state-alphabet_size)
delta[state][c] = alphabet_size*2+c;
else
delta[state][c] = alphabet_size*3+1;
}
else if (state < alphabet_size*3) {
if (c < state-alphabet_size*2)
delta[state][c] = alphabet_size+c;
else
delta[state][c] = alphabet_size*3+1;
}
else {
delta[state][c] = alphabet_size*3+1;
}
}
}
}
void set_is_accept() {
is_accept.resize(qsize,false);
for (int state = 0; state < alphabet_size*3; state++) {
is_accept[state] = true;
}
}
void set_is_reject() {
is_reject.resize(qsize,false);
is_reject[alphabet_size*3+1] = true;
}
public:
ZigZagAutomaton(int alpha_size = 10) {
alphabet_size = alpha_size;
initializer();
}
};
template<class Automaton1, class Automaton2>
Automaton IntersectionAutomaton(const Automaton1 &A, const Automaton2 &B) {
assert(A.alphabet_size == B.alphabet_size);
Automaton M;
M.alphabet_size = A.alphabet_size;
vector<vector<int>> table(A.size(), vector<int>(B.size(),-1));
vector<int> x = {A.init}, y = {B.init};
table[x[0]][y[0]] = 0;
M.init = 0;
for (int i = 0; i < x.size(); ++i) {
M.delta.push_back(vector<int>(M.alphabet_size, -1));
M.is_accept.push_back(A.accept(x[i]) && B.accept(y[i]));
M.is_reject.push_back(A.reject(x[i]) || B.reject(y[i]));
for (int c = 0; c < A.alphabet_size; c++) {
int u = A.next(x[i],c), v = B.next(y[i],c);
if (table[u][v] == -1) {
table[u][v] = x.size();
x.push_back(u);
y.push_back(v);
}
M.delta[i][c] = table[u][v];
}
}
M.qsize = M.delta.size();
return M;
}
template<typename Automaton>
Monoid digitDP(const string &s, const Automaton &dfa, bool eq = 1) {
vector<vector<Monoid>> dp(2,vector<Monoid>(dfa.size(),Monoid::zero()));
dp[1][dfa.init] = Monoid::e();
for (int i = 0; i < s.size(); i++) {
vector<vector<Monoid>> dp2(2,vector<Monoid>(dfa.size(),Monoid::zero()));
for (int tight = 0; tight <= 1; tight++) {
for (int state = 0; state < dfa.size(); state++) {
if (dfa.reject(state) || dp[tight][state].undef) continue;
int lim = (tight ? s[i] - '0' : dfa.alphabet_size - 1);
for (int c = 0; c <= lim; c++) {
int tight_ = tight && c == lim;
int state_ = dfa.next(state,c);
if (dfa.reject(state_)) continue;
dp2[tight_][state_] += dp[tight][state]*c;
}
}
}
dp = move(dp2);
}
Monoid ans = Monoid::zero();
for (int tight = 0; tight <= eq; tight++)
for (int state = 0; state < dfa.size(); state++)
if (dfa.accept(state)) ans += dp[tight][state];
return ans;
}
Automaton Minimize(const Automaton& dfa) {
std::vector<int> partition_0(dfa.qsize, -1);
int accept_idx = -1, reject_idx = -1;
for (int state = 0; state < dfa.qsize; state++) {
if (!dfa.accept(state)) continue;
if (accept_idx == -1) accept_idx = state;
partition_0[state] = accept_idx;
}
for (int state = 0; state < dfa.qsize; state++) {
if (partition_0[state] != -1) continue;
if (reject_idx < 0) reject_idx = state;
partition_0[state] = reject_idx;
}
auto _equivalent = [&](int i, int j) {
for (int c = 0; c < dfa.alphabet_size; c++) {
int dest_i = dfa.delta[i][c];
int dest_j = dfa.delta[j][c];
if (partition_0[dest_i] != partition_0[dest_j]) return false;
}
return true;
};
while (true) {
vector<int> partition(dfa.qsize, -1);
for (int i = 0; i < dfa.qsize;) {
partition[i] = i;
int i_next = dfa.qsize;
for (int j = i+1; j < dfa.qsize; j++) {
if (partition[j] >= 0) continue;
if (partition_0[i] == partition_0[j] && _equivalent(i, j)) {
partition[j] = i;
}
else if (i_next == dfa.qsize) { i_next = j; }
}
i = i_next;
}
if (partition_0 == partition) break;
partition_0 = move(partition);
}
Automaton M;
M.alphabet_size = dfa.alphabet_size;
vector<int> idx(dfa.qsize);
for (int state = 0; state < dfa.qsize; state++) {
if (partition_0[state] == state) {
idx[state] = M.delta.size();
M.delta.push_back(vector<int>(M.alphabet_size, -1));
M.is_accept.push_back(dfa.accept(state));
M.is_reject.push_back(dfa.reject(state));
}
else {
idx[state] = idx[partition_0[state]];
M.is_reject[idx[state]] = M.is_reject[idx[state]] | dfa.reject(state);
}
}
M.qsize = M.delta.size();
M.init = idx[dfa.init];
for (int state = 0; state < dfa.qsize; state++) {
if (partition_0[state] != state) continue;
for (int c = 0; c < M.alphabet_size; c++) {
M.delta[idx[state]][c] = idx[dfa.delta[state][c]];
}
}
return M;
}
struct IncludeAllAutomaton : public Automaton {
private:
vector<int> elems;
void initializer() {
qsize = 1+(1<<(int)elems.size());
init = (1<<(int)elems.size());
set_delta();
set_is_accept();
set_is_reject();
}
void set_delta() {
delta.resize(qsize,vector<int>(alphabet_size));
for (int state = 0; state < qsize; state++) {
for (int c = 0; c < alphabet_size; c++) {
if (state == init && c == 0) delta[state][c] = init;
else {
delta[state][c] = state==init?0:state;
for (int i = 0; i < elems.size(); i++) {
if (c == elems[i]) {
delta[state][c] = delta[state][c]|1<<i;
break;
}
}
}
}
}
}
void set_is_accept() {
is_accept.resize(qsize,false);
is_accept[(1<<(int)elems.size())-1] = true;
}
void set_is_reject() {
is_reject.resize(qsize,false);
}
public:
IncludeAllAutomaton(vector<int> elems, int alpha_size = 10) : elems(elems) {
alphabet_size = alpha_size;
initializer();
}
};
template<class Automaton1, class Automaton2>
Automaton UnionAutomaton(const Automaton1 &A, const Automaton2 &B) {
assert(A.alphabet_size == B.alphabet_size);
Automaton M;
M.alphabet_size = A.alphabet_size;
vector<vector<int>> table(A.size(), vector<int>(B.size(),-1));
vector<int> x = {A.init}, y = {B.init};
table[x[0]][y[0]] = 0;
M.init = 0;
for (int i = 0; i < x.size(); ++i) {
M.delta.push_back(vector<int>(M.alphabet_size, -1));
M.is_accept.push_back(A.accept(x[i]) || B.accept(y[i]));
M.is_reject.push_back(A.reject(x[i]) && B.reject(y[i]));
for (int c = 0; c < A.alphabet_size; c++) {
int u = A.next(x[i],c), v = B.next(y[i],c);
if (table[u][v] == -1) {
table[u][v] = x.size();
x.push_back(u);
y.push_back(v);
}
M.delta[i][c] = table[u][v];
}
}
M.qsize = M.delta.size();
return M;
}
int main() {
string a,b;cin >> a >> b;
int p;cin >> p;
auto M1 = Minimize(ModuloAutomaton(p));
auto M2 = ModuloAutomaton(3);
auto M3 = IncludeAllAutomaton({3});
auto M4 = UnionAutomaton(M2,M3);
auto M5 = IntersectionAutomaton(M1,M4);
cout << digitDP(b,M4).val-digitDP(a,M4,false).val-digitDP(b,M5).val+digitDP(a,M5,false).val << endl;
return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0