text stringlengths 49 983k |
|---|
#include<bits/stdc++.h>
using namespace std;
int main(){
long long n; cin>>n;
for(long long a=sqrt(n);a>0;a--){
if(n%a==0){
cout<<a-2+n/a<<endl;
return 0;
}
}
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int N;
cin >>N;
long int we,they;
for(long int i=sqrt(N);i>=1;i--){
if(N%i==0){we=i;they=N/i;break;}
}
cout <<we +they -2 <<endl;
} |
#include<iostream>
#include<math.h>
using namespace std;
int main()
{
long long int n;
cin>>n;
int a;
for(int i=sqrt(n);i>0;i--)
{
if(n%i==0)
{
a=i;
break;
}
}
cout<<a+n/a-2;
}
|
#include<iostream>
using namespace std;
int main(void){
long long n;
long long t;
cin>>n;
t=0;
for(long long i=1;i*i<=n;i++){
if(n%i==0){
t=i;
}
}
cout<<t+n/t-2;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long long a;
cin >> a;
for(long long i=sqrt(a);i>0;i--){
if(a%i==0){
cout << i+a/i-2 << endl;
break;
}
}
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long i64;
int main()
{
i64 n,i,ans;
scanf("%lld",&n);
for(i=1;i*i<=n;i++)
if(n%i==0)ans=i;
printf("%lld",ans+n/ans-2);
return 0;
} |
#include <iostream>
#include <math.h>
#include <limits>
using namespace std;
int main()
{
long long int n;
cin>>n;
long long int i=sqrt(n+10);
while (i>=1)
{if (n%i==0)
{cout <<i+(n/i)-2;
break;}
else i--;
}
} |
#include<iostream>
#include<math.h>
using namespace std;
int main(){
double x;
long long N,i,y;
cin >> N;
x=sqrt(N);
for(i=x;x>=1;i--){if(N%i==0)break;
}
y=N/i;
cout << i-1+y-1 << endl;
return 0;
} |
#include<iostream>
using namespace std;
int main (void)
{
long long int i,j,n,ans;
cin>>n;
i=1;
while(1)
{
j=n/i;
if(i*j==n){ans=i+j-2;}
if(i>j)break;
i++;
}
cout<<ans;
} |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < n; ++i)
using namespace std;
typedef long long ll;
int mod;
struct mint {
ll x;
mint(ll x=0):x(x%mod){}
mint& operator+=(const mint a) {
(x += a.x) %= mod;
return *this;
}
mint& operator-=(const mint a) {
(x += mod-a.x) %= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res+=a;
}
mint operator-(const mint a) const {
mint res(*this);
return res-=a;
}
mint operator*(const mint a) const {
mint res(*this);
return res*=a;
}
};
ll b, ten;
mint pow_(mint x, ll t) {
if (t == 0) return 1;
if (t%2 == 1) {
return pow_(x,t-1)*x;
} else {
mint y = pow_(x,t/2);
return y*y;
}
}
mint f(ll l) {
if (l == 0) return 0;
if (l%2 == 1) {
ll pl = l-1;
mint x = f(pl);
return x*ten + 1;
} else {
ll pl = l/2;
mint x = f(pl);
return x*pow_(ten, pl) + x;
}
}
mint g(ll l) {
if (l == 0) return 0;
if (l%2 == 1) {
ll pl = l-1;
mint x = g(pl);
return x*ten + mint(b)*pl;
} else {
ll pl = l/2;
mint x = g(pl);
return x*pow_(ten, pl) + x + mint(b)*pl*f(pl);
}
}
int main() {
ll L, a;
cin >> L >> a >> b >> mod;
ll last = a+b*(L-1);
mint ans = 0;
ten = 10;
for (int i = 1; i <= 18; ++i, ten *= 10) {
ll l = ten/10, r = ten-1;
if (last < l) continue;
if (a > r) continue;
ll na = 0; // 初項
ll nl = 0; // 長さ
{
if (a >= l) na = a;
else {
na = ((l-a)+(b-1))/b*b+a;
na = min(na, last);
}
}
{
ll nlast = 0;
if (last <= r) nlast = last;
else {
nlast = (r-a)/b*b+a;
}
nl = (nlast-na)/b+1;
}
ans *= pow_(ten, nl);
ans += f(nl)*na;
ans += g(nl);
}
cout << ans.x << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define all(ppp) ppp.begin(),ppp.end()
#define out(ppp) cout<<(ppp)<<endl
#define out1(ppp) cout<<(ppp)
#define MAX_CHAR 256
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define REP(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define pb push_back
#define lint ll
typedef long double ld;
typedef complex<ld> cd;
ll MOD;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
typedef vector<vpi> vvpi;
typedef set<pi> spi;
const int INF=INT_MAX;
vector<vector<lint>> matmul(const vector<vector<lint>> &A, const vector<vector<lint>> &B, lint mod=MOD){
int H = A.size(), W = B[0].size(), K = B.size();
vector<vector<lint>> C(H, vector<lint>(W));
REP(i, H) REP(j, W) REP(k, K) (C[i][j] += A[i][k] * B[k][j]) %= mod;
return C;
}
vector<vector<lint>> matpower(vector<vector<lint>> X, lint n, lint mod=MOD){
vector<vector<lint>> res(X.size(), vector<lint>(X.size()));
REP(i, res.size()) res[i][i] = 1;
while (n)
{
if (n & 1) res = matmul(res, X, mod);
X = matmul(X, X, mod); n >>= 1;
}
return res;
}
lint power(lint x, lint n){
lint ans = 1;
while (n>0)
{
if (n & 1) (ans *= x) %= MOD;
(x *= x) %= MOD;
n >>= 1;
}
return ans;
}
ll sol(ll len,ll A,ll B,ll amari){
if(!len){
return amari;
}
ll d=to_string(A).length();
ll m=1;
F0R(i,d){
m*=10;
}
ll n_term=min((m-1-A)/B+1,len);
vector<vector<ll>> trans{{power(10,d),0,0},{1,1,0},{0,B,1}};
trans=matpower(trans,n_term);
amari=(trans[0][0]*(amari%MOD)%MOD+trans[1][0]*(A%MOD)%MOD+1*trans[2][0]%MOD)%MOD;
return sol(len-n_term,A+B*n_term,B,amari);
}
void solve(){
ll l,A,B;
cin>>l>>A>>B>>MOD;
ll ret=sol(l,A,B,0);
out(ret);
}
int main(){
solve();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define fi first
#define se second
typedef pair<ll,ll> P;
using VP = vector<P>; using VVP = vector<VP>;
using VI = vector<ll>; using VVI = vector<VI>; using VVVI = vector<VVI>;
#define INF 1ll<<59
ll Mod;
VVI matproduct(VVI a,VVI b){
if(a[0].size()!=b.size()) cout<<a[0].size()<<" "<<b.size()<<endl;
VVI w(a.size(),VI(b[0].size(),0));
for(ll i=0;i<a.size();i++){
for(ll j=0;j<b[0].size();j++){
for(ll k=0;k<a[0].size();k++){
w[i][j]+=(a[i][k]%Mod)*(b[k][j]%Mod);
w[i][j]%=Mod;
}
}
}
return w;
}
VVI square(VVI a){
return matproduct(a,a);
}
int main(){
ll i,j;
ll l,a,b,m;
cin>>l>>a>>b>>m;
Mod=m;
ll k=1;
ll d[19];
ll ke[19];
ke[0]=1;
for(i=1;i<19;i++){
d[i]=max((k*10-1-a+b)/b,0ll)-max((k-1-a+b)/b,0ll);
k*=10;
ke[i]=(ke[i-1]*10)%Mod;
}
for(i=1;i<19;i++){
if(d[i]<l) l-=d[i];
else {
d[i]=l;
l=0;
}
}
VVI ans(1,VI(3));
ans[0][0]=0;
ans[0][1]=a%Mod;
ans[0][2]=1;
for(i=1;i<19;i++){
VVI w(3,VI(3,0));
w[0][0]=ke[i];
w[1][0]=1;
w[1][1]=1;
w[2][1]=b%Mod;
w[2][2]=1;
for(j=0;j<62;j++){
if((d[i]>>j)&1) ans=matproduct(ans,w);
w=square(w);
}
}
cout<<ans[0][0]<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using Matrix = vector<vector<ll>>;
inline ll ceil_ll(ll x, ll y) { return (x + y - 1) / y; }
Matrix mulMatrix(const Matrix &A, const Matrix &B, const ll MOD) {
Matrix C(3, vector<ll>(3));
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
(C[i][j] += (A[i][k] * B[k][j]) % MOD) %= MOD;
}
}
}
return C;
}
Matrix powMatrix(Matrix A, ll e, const ll MOD) {
vector<vector<ll>> X(3, vector<ll>(3));
X[0][0] = X[1][1] = X[2][2] = 1;
for ( ; 0 < e; e >>= 1) {
if (e & 1) X = mulMatrix(X, A, MOD);
A = mulMatrix(A, A, MOD);
}
return X;
}
ll fast_pow10(ull e, const ull MOD) {
ull a = 10, x = 1;
for ( ; 0 < e; e >>= 1) {
if (e & 1) (x *= a) %= MOD;
(a *= a) %= MOD;
}
return x;
}
int main() {
cin.tie(0); ios::sync_with_stdio(false);
// cout << setprecision(8) << setiosflags(ios::fixed);
constexpr int DIGITS = 19;
vector<ll> pow10(DIGITS);
pow10[0] = 1;
for (int i = 1; i < DIGITS; ++i)
pow10[i] = 10 * pow10[i - 1];
ll L, A, B, M;
cin >> L >> A >> B >> M;
vector<ll> begin(DIGITS), num(DIGITS);
for (ll d = 1; d < DIGITS; ++d) {
begin[d] = max(0ll, ceil_ll(pow10[d - 1] - A, B));
const ll end = min((pow10[d] - A - 1) / B, L - 1);
const ll s_l = A + B * begin[d], s_r = A + B * end;
if (pow10[d - 1] <= s_l && s_r < pow10[d] && begin[d] <= end)
num[d] = end - begin[d] + 1;
}
ll ans = 0;
for (ll d = 1; d < DIGITS; ++d) {
if (num[d] == 0) continue;
Matrix X(3, vector<ll>(3));
X[0][0] = pow10[d] % M; X[0][1] = 1;
X[1][1] = 1; X[1][2] = B % M;
X[2][2] = 1;
X = powMatrix(X, num[d], M);
const ll s0 = (A + B * begin[d]) % M;
const ll s = ((X[0][1] * s0) % M + X[0][2]) % M;
(ans *= fast_pow10((ull)d * num[d], M)) %= M;
(ans += s) %= M;
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
using namespace std;
long L,A,B,M;
long power(long a,long b){return b?power(a*a%M,b/2)*(b%2?a:1)%M:1;}
long ten[99],sten[99],iten[99];
long n;
long sum(long k)
{
long ret=0,p=1;
for(int i=61;i--;)
{
if(k>>i&1)
{
(ret+=sten[i]*p)%=M;
p=p*ten[i]%M;
}
}
return ret;
}
long isum(long k)
{
long ret=0,p=1,g=0;
for(int i=61;i--;)
{
if(k>>i&1)
{
(ret+=(iten[i]+sten[i]*g)%M*p)%=M;
p=p*ten[i]%M;
g=(g+(1LL<<i))%M;
}
}
return ret;
}
long cnt[18],SUM[18];
int main()
{
cin>>L>>A>>B>>M;
long pre=0,tmpten=1;
long ans=0;
for(n=1;n<=18;n++)
{
cnt[n-1]=1;
long l=pre,r=L;
tmpten*=10;
while(r-l>1)
{
long m=(l+r)/2;
if(A+B*m<tmpten)l=m;
else r=m;
}
long k=l-pre;
if(k<0||l>=L||A+B*l>=tmpten)
{
continue;
}
pre=l+1;
ten[0]=tmpten%M;
sten[0]=1;
iten[0]=0;
if(k+1&1)cnt[n-1]=tmpten%M;
for(int i=1;i<61;i++)
{
ten[i]=ten[i-1]*ten[i-1]%M;
sten[i]=(ten[i-1]+1)%M*sten[i-1]%M;
iten[i]=((ten[i-1]+1)%M*iten[i-1]+(1LL<<i-1)%M*sten[i-1]%M*ten[i-1])%M;
if(k+1>>i&1)cnt[n-1]=cnt[n-1]*ten[i]%M;
}
SUM[n-1]=(((A+B*l)%M*sum(k+1)%M-B%M*isum(k+1))%M+M)%M;
}
long p=1;
for(int i=18;i--;)
{
ans=(ans+SUM[i]*p)%M;
p=p*cnt[i]%M;
}
cout<<ans<<endl;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<unordered_map>
using namespace std;
typedef long long ll;
#define chmax(a,b) a=max(a,b)
#define chmin(a,b) a=min(a,b)
#define mod 1000000007
#define mad(a,b) a=(a+b)%mod
#define Nmax 55
ll mo;
ll po(ll x,ll y){ if(y<0)cout<<1/0<<endl;
ll res=1;
for(;y;y>>=1){
if(y&1)res=res*x;
x=x*x;
}
return res;
}
ll pomo(ll x,ll y){ if(y<0)cout<<1/0<<endl;
ll res=1;
for(;y;y>>=1){
if(y&1)res=res*x%mo;
x=x*x%mo;
}
return res;
}
struct matrix{
ll t[3][3];
};
matrix mul(matrix a,matrix b){
matrix c;
for(int i=0;i<3;i++)for(int j=0;j<3;j++){
ll res=0;
for(int k=0;k<3;k++){
res+=a.t[i][k]*b.t[k][j];
}
c.t[i][j]=res%mo;
}
return c;
}
ll solve(ll d,ll a,ll b,ll l){
matrix r[66];
ll kei[]={1,b%mo,0,0,po(10,d)%mo,0,1,a%mo,1};
for(int i=0;i<3;i++)for(int j=0;j<3;j++){
r[0].t[i][j]=kei[i*3+j];
}
for(int i=1;i<62;i++)r[i]=mul(r[i-1],r[i-1]);
matrix res; bool fi=1;
for(int i=0;i<62;i++){
if((1LL<<i)&l){
if(fi)res=r[i],fi=0;
else res=mul(res,r[i]);
}
}
return res.t[2][1];
}
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
ll l,a,b;
cin>>l>>a>>b>>mo;
ll ans=0;
ll ruiketa=1;
for(int d=18;d>=1;d--){
if(po(10,d)<=a)continue;
if(a+b*(l-1)<po(10,d-1))continue;
ll s=a; if(s<po(10,d-1))s=a+(po(10,d-1)-1-a+b)/b*b;
ll t=a+b*(l-1); if(po(10,d)<=t)t=a+(po(10,d)-1-a)/b*b;
ll len=(t-s)/b+1;
if(len>0){
ll res=solve(d,s,b,len); //cout<<d<<" "<<s<<" "<<b<<" "<<len<<" "<<res<<endl;
ans=ans+ruiketa*res; ans%=mo;
ruiketa=ruiketa*pomo(pomo(10,len),d)%mo;
}
}
cout<<ans<<endl;
}
|
#include <cstdio>
#include <tuple>
#include <utility>
using namespace std;
typedef long long ll;
ll L, A, B, M;
int len(ll x)
{
int res = 0;
while (x) ++res, x /= 10;
return res;
}
tuple<ll, ll, ll> calc(ll C, ll N)
{
if (N == 1)
return make_tuple(C, 1, 0);
auto z = calc(C, N / 2);
z = make_tuple(get<0>(z) * get<0>(z) % M, get<1>(z) * (1 + get<0>(z)) % M, (get<2>(z) * (1 + get<0>(z)) + (N / 2) % M * get<1>(z)) % M);
if (N & 1)
z = make_tuple(get<0>(z) * C % M, (get<1>(z) + get<0>(z)) % M, (get<2>(z) * C + N - 1) % M);
return z;
}
pair<ll, ll> solve(ll l, ll r)
{
int xl = len(A + B * l), xr = len(A + B * r);
if (xl == xr)
{
ll pw = 1;
for (int i = 1; i <= xl; ++i) pw = pw * 10 % M;
ll X = (A + B * l) % M, Y = B % M;
auto tmp = calc(pw, r - l + 1);
return make_pair(get<0>(tmp), (get<1>(tmp) * X + get<2>(tmp) * Y) % M);
}
ll mid = l + r >> 1;
pair<ll, ll> ansl = solve(l, mid), ansr = solve(mid + 1, r);
return make_pair(ansl.first * ansr.first % M, (ansl.second * ansr.first + ansr.second) % M);
}
int main()
{
scanf("%lld%lld%lld%lld", &L, &A, &B, &M);
printf("%lld\n", solve(0, L - 1).second);
return 0;
}
|
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <stdio.h>
using namespace std;
#define int long long
int keta(int a) {
int res = 0;
while (a > 0) {
a /= 10;
res++;
}
return res;
}
int L, A, B, M;
int po(int a, int p) {
if (p == 0)return 1;
int res = po(a, p / 2);
res = (res * res) % M;
if (p & 1) {
res = (res * a) % M;
}
return res;
}
int calc(int z, int c) {
if (c == 0)return 0;
if (c == 1)return 1;
int res = calc(z, c / 2);
res = (res + (res * po(z, c / 2))) % M;
if (c & 1) {
res = (res + po(z, c - 1)) % M;
}
return res;
}
int calc2(int z, int c) {
if (c == 0)return 0;
if (c == 1)return 0;
int res = calc2(z, c / 2);
res = (res + (res * po(z, c / 2))) % M;
res = (res + (( ((c / 2) % M) * po(z, c / 2)) % M) * calc(z, c / 2)) % M;
if (c & 1) {
res = (res + ((c - 1) % M) * po(z, c - 1)) % M;
}
return res;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> L >> A >> B >> M;
vector<int> X(20, 0);
for (int i = 1; i <= 19; i++) {
int ok = L;
int ng = -1;
while (ok - ng > 1) {
int m = (ok + ng) / 2;
int a = A + B * m;
if (keta(a) >= i) {
ok = m;
}
else {
ng = m;
}
}
X[i] = ok;
}
int b = 1;
int la = L;
int res = 0;
int AA = A % M;
int BB = B % M;
for (int i = 19; i >= 0; i--) {
int cnt = la - X[i];
if (cnt > 0) {
int z = po(10, i);
int t = (AA + BB * ((la - 1) % M)) % M;
int diff = 0;
diff = (diff + t * calc(z, cnt)) % M;
diff = (diff - BB * calc2(z, cnt)) % M;
if (diff < 0)diff += M;
diff = (diff*b) % M;
res = (res + diff) % M;
b = (b * po(po(10, cnt), i)) % M;
}
la = X[i];
}
/*cerr << calc2(2, 2) << endl;
cerr << calc2(2, 3) << endl;
cerr << calc2(2, 4) << endl;
cerr << calc2(2, 5) << endl;*/
cout << res << endl;
} |
#include"bits/stdc++.h"
using namespace std;
using ll = int64_t;
ll L, A, B, M;
vector<vector<ll>>& operator*=(vector<vector<ll>>& lhs, vector<vector<ll>> rhs) {
auto result = lhs;
for (ll i = 0; i < result.size(); i++) {
for (ll j = 0; j < result[i].size(); j++) {
result[i][j] = 0;
for (ll k = 0; k < lhs.size(); k++) {
(result[i][j] += lhs[i][k] * rhs[k][j] % M) %= M;
}
}
}
return lhs = result;
}
int main() {
cin >> L >> A >> B >> M;
ll ans = 0;
ll pre = 0;
ll s = A;
for (ll d = 1; d <= 18; d++) {
ll target = 1;
for (ll j = 0; j < d; j++) {
target *= 10;
}
ll low = pre - 1, eq_high = L;
while (low != eq_high - 1) {
ll mid = (low + eq_high) / 2;
ll s_mid = A + B * mid;
(s_mid < target ? low = mid : eq_high = mid);
}
ll C_d = eq_high - pre;
pre = eq_high;
vector<vector<ll>> mat = {
{ target % M, 0, 0 },
{ 1, 1, 0 },
{ 0, B % M, 1 }
};
vector<vector<ll>> result = {
{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 }
};
while (C_d) {
if (C_d % 2 == 1) {
result *= mat;
}
C_d /= 2;
mat *= mat;
}
vector<ll> v = { ans, s, 1 };
ans = 0;
s = 0;
for (ll i = 0; i < 3; i++) {
(ans += v[i] * result[i][0] % M) %= M;
(s += v[i] * result[i][1] % M) %= M;
}
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i=0; i<(int)(n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using Graph = vector<vi>; // vi <=> vl
using vb = vector<bool>;
using boolGraph = vector<vb>;
using P = pair<int, int>; // int <=> ll
const int MOD = 1e9+7;
const int MOD2 = 998244353;
const double EPS = 1e-9;
int main() {
ll L, A, B, M;
cin >> L >> A >> B >> M;
P digit = P(1, 1);
ll tmp = 10;
while (A >= tmp) {
tmp *= 10;
++digit.first;
}
ll last = A + B * (L-1);
tmp = 10;
while (last >= tmp) {
tmp *= 10;
++digit.second;
}
ll init = A;
ll ans = 0;
for (int k=digit.first; k<=digit.second; ++k) {
ll pow10 = pow(10, k);
if (pow10 <= init) continue;
ll num = (min(pow10 - 1, last) - init) / B + 1;
vl rem(64);
rem[0] = pow10 % M;
rep(i,63) {
rem[i+1] = rem[i] * rem[i] % M;
}
vl dp(64);
dp[0] = 1;
rep(i,63) {
dp[i+1] = dp[i] * (1 + rem[i]) % M;
}
ll expo = 1, sigma_a = 0;
for (int i=63; i>=0; --i) {
if ((num >> i) & 1) {
(sigma_a += expo * dp[i]) %= M;
(expo *= rem[i]) %= M;
}
}
vl dp2(64), power(64);
dp2[0] = 1;
power[0] = 1;
rep(i,63) {
dp2[i+1] = (dp2[i] * (1 + rem[i]) + dp[i] * power[i]) % M;
power[i+1] = power[i] * 2 % M;
}
ll expo2 = 1, sum = 0, sigma_b = 0;
for (int i=63; i>=0; --i) {
if (((num - 1) >> i) & 1) {
(sigma_b += sum * power[i] + expo2 * dp2[i]) %= M;
(sum += expo2 * dp[i]) %= M;
(expo2 *= rem[i]) %= M;
}
}
(ans *= expo) %= M;
(ans += (init % M) * sigma_a + (B % M) * sigma_b) %= M;
init += B * num;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long l,a,b,m,L,R,mid,fuck,fk,dur,cur;
struct mat
{
long long a[11][11];
mat()
{
for (int i=1;i<=3;i++)
{
for (int j=1;j<=3;j++)
a[i][j]=(i==j);
}
}
mat operator * (const mat &u) const
{
mat res;
for (int i=1;i<=3;i++)
{
for (int j=1;j<=3;j++)
{
res.a[i][j]=0;
for (int k=1;k<=3;k++)
{
res.a[i][j]=(res.a[i][j]+a[i][k]*u.a[k][j])%m;
}
}
}
return res;
}
}ma,ans,fp;
mat binpow(mat a,long long t)
{
mat res,p=a;
for (long long i=t;i;i>>=1)
{
if (i&1) res=res*p;
p=p*p;
}
return res;
}
int main()
{
scanf("%lld%lld%lld%lld",&l,&a,&b,&m);
cur=a;
while(l)
{
fuck=1;fk=cur;
while(fk)
{
fk/=10;
fuck*=10;
}
ma.a[1][1]=fuck%m;ma.a[1][2]=ma.a[1][3]=ma.a[2][3]=ma.a[3][1]=0;
ma.a[2][1]=ma.a[2][2]=ma.a[3][2]=ma.a[3][3]=1;
dur=(fuck-cur+b-1)/b;
dur=min(dur,l);
fp=fp*binpow(ma,dur);
l-=dur;cur+=b*dur;
}
printf("%lld\n",(fp.a[2][1]*(a%m)+fp.a[3][1]*(b%m))%m);
return 0;
} |
#include<iostream>
#include<iomanip>
#include<vector>
#include<string>
#include<cstring>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<climits>
#include<fstream>
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
constexpr Int TEN(int n) { return n == 0 ? 1 : 10 * TEN(n-1); }
Int L, A, B, M;
typedef struct m {
Int m[3][3];
}Matrix;
Matrix operator * (Matrix a, Matrix b) {
Matrix c;
for(int i = 0;i < 3;i++) {
for(int j = 0;j < 3;j++) {
c.m[i][j] = 0;
for(int k = 0;k < 3;k++) {
c.m[i][j] = (c.m[i][j]+ (a.m[i][k]*b.m[k][j]%M))%M;
}
}
}
return c;
}
Matrix create(Int op, Int b) {
Matrix A;
A.m[0][0] = op % M;
A.m[0][1] = 0;
A.m[0][2] = 0;
A.m[1][0] = 1;
A.m[1][1] = 1;
A.m[1][2] = 0;
A.m[2][0] = 0;
A.m[2][1] = B%M;
A.m[2][2] = 1;
return A;
}
Matrix pow(Matrix x, Int y) {
Matrix ans;
if(y == 1)
return x;
ans = pow(x*x,y/2);
if(y&1) {
ans = ans*x;
}
return ans;
}
int main(void) {
cin>>L>>A>>B>>M;
Int op = 10;
Int ans = 0;
Int o = 0;
L--;
for(int i = 1;i <= 19;i++) {
Int l = o,r = L,p = -1;
while(l <= r) {
Int mid = (l+r)/2;
if(mid*B+A < op) {
p = mid;
l = mid+1;
} else {
r = mid-1;
}
}
if(p != -1) {
Matrix a = create(op,B);
a = pow(a,p-o+1);
Int t = (B*o%M+A) % M;
ans = (ans * a.m[0][0]%M + t*a.m[1][0]%M+a.m[2][0])%M;
o = p+1;
}
if(o > L)
break;
op *= 10;
}
cout<<ans<<endl;
return 0;
}
|
#include<iostream>
using namespace std;
typedef long long ll;
void mult(ll m, const ll x[3][3], const ll y[3][3], ll z[3][3]) {
for(int i=0;i<3;i++) for(int j=0;j<3;j++) {
z[i][j] = 0;
for(int k=0;k<3;k++) {
z[i][j] += x[i][k] * y[k][j];
}
z[i][j] %= m;
}
}
int main() {
ll l, a, b, m;
cin >> l >> a >> b >> m;
ll ans = 0;
for(ll r=10;l>0;r*=10) {
if(r <= a) continue;
ll n = (r-a-1) / b + 1;
if(n > l) n = l;
ll mat[3][3] = {
{r % m, 0, 0},
{1, 1, 0},
{0, b % m, 1}
};
ll p[3][3] = {
{1, 0, 0},
{0, 1, 0},
{0, 0, 1}
};
for(int s=63;s>=0;s--) {
ll tmp[3][3];
mult(m, p, p, tmp);
if((n >> s) & 1) {
mult(m, tmp, mat, p);
} else {
for(int i=0;i<3;i++) for(int j=0;j<3;j++) p[i][j] = tmp[i][j];
}
}
ll v[3] = {ans, a % m, 1};
ans = 0;
for(int i=0;i<3;i++) {
ans += v[i] * p[i][0];
}
ans %= m;
l -= n;
a += b * n;
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <string>
#include <random>
#include <stack>
#include <set>
#include <unordered_set>
#define bug(x) cout<<"zdongdebug: "<<x<<endl;
#define bug2(x, y) cout<<"zdongdebug: "<<x<<" "<<y<<endl;
using namespace std;
typedef unsigned long long ll;
const int maxn = 100005;
class Mat{
public:
vector<vector<ll>> each;
vector<vector<ll>> ret;
ll mod;
Mat(ll sum, ll cur, ll b, ll p10, ll mod){
each = {{p10, 1, 0},{0,1,1},{0,0,1}};
ret = {{sum},{cur},{b}};
this->mod = mod;
}
vector<vector<ll>> mul(vector<vector<ll>>a, vector<vector<ll>>b){
vector<vector<ll>> ret = vector<vector<ll>>(a.size(),vector<ll>(b[0].size(),0));
for(int i=0;i<a.size();i++)
for(int j=0;j<b[0].size();j++){
ll tt = 0;
for(int k=0;k<b.size();k++){
tt=(tt+a[i][k]*b[k][j]%mod)%mod;
}
ret[i][j]=tt;
}
return ret;
}
ll calSum(ll n){
vector<vector<ll>>tt={{1,0,0},{0,1,0},{0,0,1}};
while(n){
if(n&1){
tt = mul(tt, each);
}
each = mul(each, each);
n>>=1;
}
ret = mul(tt, ret);
return ret[0][0];
}
};
ll helper(ll x){
ll ret = 0;
while(x){
ret=ret*10 + 9;
x/=10;
}
return ret;
}
int main() {
#ifdef suiyuan2009
freopen("/Users/suiyuan2009/CLionProjects/icpc/input.txt", "r", stdin);
#endif
ll n,a,b,mod;
cin>>n>>a>>b>>mod;
ll sum = a % mod;
ll cur = a+b;
n--;
while(n){
ll mx = helper(cur);
ll cnt = (mx-cur)/b;
Mat solve = Mat(sum, cur%mod, b%mod, (mx+1)%mod, mod);
ll tcnt = min(n,cnt+1);
ll nsum = solve.calSum(tcnt);
//cout<<sum<<" "<<cur<<" "<<mx+1<<" "<<tcnt<<" "<<nsum<<endl;
sum = nsum;
cur = tcnt * b + cur;
n-=tcnt;
}
cout<<sum<<endl;
//bug(cur)
return 0;
} |
#include <iostream>
#include <vector>
#include <algorithm>
#include <initializer_list>
using lli=long long int;
int mod;
template<size_t N>
class matN{
public:
lli m[N][N] = {};
matN(){}
matN(std::initializer_list<lli> init){
auto it = init.begin();
for(int i = 0; i < N; i++){
for(int j = 0; j < N; j++){
m[i][j] = (((*it)%mod)+mod)%mod;
++it;
}
}
}
};
template<size_t N>
const matN<N> operator*(const matN<N>& lhs, const matN<N>& rhs){
matN<N> ans;
for(int i = 0; i < N; i++){
for(int j = 0; j < N; j++){
for(int k = 0; k < N; k++){
ans.m[i][j] += lhs.m[i][k]*rhs.m[k][j];
ans.m[i][j] %= mod;
}
}
}
return ans;
}
int main(){
lli L,A,B;
std::cin >> L >> A >> B >> mod;
std::vector<lli> ns_d(1);
lli tmp = 9;
while(A+B*(L-1)>tmp){
if(A>tmp){
ns_d.push_back(0);
}else{
ns_d.push_back((tmp-A)/B+1);
}
tmp = tmp*10+9;
}
ns_d.push_back(L);
matN<3> mat_total = {1,0,0,0,1,0,0,0,1};
for(int i = 1; i < ns_d.size(); i++){
lli ipow = 1;
for(int j = 0; j < i; j++){
ipow = (ipow*10)%mod;
}
lli isize = ns_d[i]-ns_d[i-1];
matN<3> mat_last = {ipow,1,0,0,1,B,0,0,1};
int nb = 0;
while((isize>>nb)!=0){
if((isize>>nb)&1){
mat_total = mat_last*mat_total;
}
mat_last = mat_last*mat_last;
nb++;
}
}
lli ans = ((mat_total.m[0][1]*(A%mod))%mod+mat_total.m[0][2])%mod;
std::cout << ans << std::endl;
return 0;
}
|
#include<iostream>
#include<string>
#include<iomanip>
#include<cmath>
#include<vector>
#include<algorithm>
using namespace std;
// #define int long long
#define int __int128
#define rep(i,n) for(int i = 0; i < (n); i++)
#define INF ((long long)1e18)
#define endl "\n"
#define yn(f) ((f)?"Yes":"No")
#define YN(f) ((f)?"YES":"NO")
#define MAX
long long MOD;
template<typename type>
vector<vector<type>> product(vector<vector<type>> &a, vector<vector<type>> &b){
vector<vector<type>> res(a.size(),vector<type>(b[0].size(),0));
for(int i = 0; i < a.size(); i++){
for(int j = 0; j < b[0].size(); j++){
for(int k = 0; k < b.size(); k++){
res[i][j] += a[i][k]*b[k][j];
res[i][j] %= MOD;
}
}
}
return res;
}
template<typename type>
vector<vector<type>> matrix_power(vector<vector<type>> matrix, long long n){
vector<vector<type>> res(matrix.size(), vector<type>(matrix.size(),0));
for(int i = 0; i < matrix.size(); i++) res[i][i] = 1;
for( ; n > 0; n >>= 1){
if(n&1) res = product(res,matrix);
matrix = product(matrix,matrix);
}
return res;
}
int check(int num){
int con = 0;
while(num) con++, num /= 10;
return con;
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
vector<vector<int>> ans(3,vector<int>(1,0));
long long L, A, B;
int b = -1;
cin>>L>>A>>B>>MOD;
ans[0][0] = 0;
ans[1][0] = A;
ans[2][0] = 1;
for(int i = 1, power = 10; i <= 18; i++, power *= 10){
vector<vector<int>> matrix(3,vector<int>(3,0));
int d = 0;
int m = 0, l = 0, h = L;
while(l + 1 < h){
int m = (l + h)/2;
if(check(A + m*B) > i){
h = m;
} else {
l = m;
}
}
if(check(A + l*B) < i) continue;
d = l - b;
b = l;
matrix[0][0] = power;
matrix[0][1] = matrix[1][1] = matrix[2][2] = 1;
matrix[1][2] = B;
matrix = matrix_power(matrix, d);
ans = product(matrix, ans);
}
cout<<(long long)ans[0][0]<<endl;
return 0;
} |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <map>
#include <queue>
#include <iomanip>
#include <set>
#define mkp make_pair
typedef long long ll;
using namespace std;
ll L,A,B,M;
ll MOD=1000000007;
typedef vector<ll> vec;//ll?
typedef vector<vec> mat;
mat mul(mat &A,mat &B){
mat C(A.size(),vec(B[0].size()));
for(int i=0;i<A.size();i++){
for(int k=0;k<B.size();k++){
for(int j=0;j<B[0].size();j++){
C[i][j]=(C[i][j]+A[i][k]*B[k][j]%MOD)%MOD;
}
}
}
return C;
}
mat pow(mat A,ll n){
mat B(A.size(),vec(A.size()));
for(int i=0;i<A.size();i++){
B[i][i]=1;
}
while(n>0){
if(n&1) B=mul(B,A);
A=mul(A,A);
n=(n>>1);
}
return B;
}
int digit(ll val){
if(val==0) return 0;
else return (1+digit(val/10));
}
int main(){
cin>>L>>A>>B>>M;
MOD=M;
ll ans=0;
ll ten[20]={};
ten[0]=1;
for(int i=1;i<=18;i++) ten[i]=ten[i-1]*10%MOD;
ll start=0;
while(start<L){
ll ng=L;
ll ok=start;
ll nowdigit=digit(A+B*start);
while(ng-ok>1){
ll mid=(ng+ok)/2;
if(digit(A+B*mid)==nowdigit) ok=mid;
else ng=mid;
}
mat C(3,vec(3));
C[0][0]=ten[nowdigit];
C[0][1]=1;
C[0][2]=A%MOD;
C[1][0]=0;
C[1][1]=1;
C[1][2]=B%MOD;
C[2][0]=0;
C[2][1]=0;
C[2][2]=1;
C=pow(C,(ok-start+1));
mat D(3,vec(1));
D[0][0]=ans;
D[1][0]=(B*start)%MOD;
D[2][0]=1;
D=mul(C,D);
ans=D[0][0];
ans=(ans+MOD)%MOD;
start=ok+1;
}
cout<<ans<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (int)(n); ++i)
#define reps(i,n) for (int i = 1; i <= (int)(n); ++i)
#define repd(i,n) for (int i = (int)(n - 1); i >= 0; --i)
#define repds(i,n) for(int i = (int)(n); i > 0; --i)
#define all(f,x,...) ([&](decltype((x)) whole) { return (f)(begin(whole), end(whole), ## __VA_ARGS__); })(x)
#define rall(f,x,...) ([&](decltype((x)) whole) { return (f)(rbegin(whole), rend(whole), ## __VA_ARGS__); })(x)
#define sz(a) (int)(a).size()
using ll = long long;
using ld = long double;
constexpr ll inf = static_cast<ll>(1e17);
constexpr int iinf = static_cast<int>(1e9);
constexpr ll MOD = static_cast<ll>(1e9 + 7);
ll mod = MOD;
using MatrixChild = std::vector<long long>;
using Matrix = std::vector<MatrixChild>;
Matrix matrixmul(Matrix& a, Matrix& b) {
Matrix c(a.size(), MatrixChild(b[0].size()));
for (int i = 0; i < (int)a.size(); ++i)
for (int k = 0; k < (int)b.size(); ++k)
for (int j = 0; j < (int)b[0].size(); ++j)
c[i][j] = (c[i][j] + a[i][k] * b[k][j]) % mod;
return c;
}
Matrix matrixpow(Matrix a, long long n) {
Matrix b(a.size(), MatrixChild(a.size()));
for (int i = 0; i < (int)a.size(); ++i)
b[i][i] = 1;
while (n > 0) {
if (n & 1)
b = matrixmul(b, a);
a = matrixmul(a, a);
n >>= 1;
}
return b;
}
ll l, a, b;
void solve() {
cin >> l >> a >> b >> mod;
ll ten = 1;
ll ans = 0;
rep(i, 19) {
ten *= 10;
if (a >= ten)
continue;
auto num = min((ten - 1 - a) / b, l - 1) + 1;
l -= num;
if (num == 0) {
if (l == 0)
break;
continue;
}
Matrix ansMat{
{ ans, a % mod, 1 }
};
Matrix mat{
{ ten % mod, 0, 0 },
{ 1, 1, 0 },
{ 0, b, 1 }
};
mat = matrixpow(mat, num);
ansMat = matrixmul(ansMat, mat);
ans = ansMat[0][0] % mod;
a += b * num;
}
cout << ans % mod << endl;
return;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
solve();
return 0;
}
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
ll L,A,B,M;
ll S;
struct MOD_INT{
ll x;
MOD_INT(ll arg_x){
x = arg_x;
x %= M;
}
MOD_INT& operator+=(const MOD_INT a) {
(x += a.x) %= M;
return *this;
}
MOD_INT& operator-=(const MOD_INT a) {
(x += M-a.x) %= M;
return *this;
}
MOD_INT& operator*=(const MOD_INT a) {
(x *= a.x) %= M;
return *this;
}
MOD_INT operator+(const MOD_INT a) const {
MOD_INT res(*this);
return res+=a;
}
MOD_INT operator-(const MOD_INT a) const {
MOD_INT res(*this);
return res-=a;
}
MOD_INT operator*(const MOD_INT a) const {
MOD_INT res(*this);
return res*=a;
}
};
MOD_INT mod_pow(MOD_INT x,ll count, ll mod){
if(count == 0){
return 1;
}
if(count%2 == 1){
return mod_pow(x,count-1,mod)*x;
}
else{
MOD_INT y = mod_pow(x,count/2,mod);
return y*y;
}
}
MOD_INT f(ll loc){
if(loc == 0){
return 0;
}
MOD_INT ret(0);
if(loc%2 == 1){
ll tmp = loc-1;
ret = f(tmp);
return ret*S+1;
}else{
ll tmp = loc/2;
ret = f(tmp);
return ret*mod_pow(S,loc/2,M)+ret;
}
}
MOD_INT g(ll loc){
if(loc == 0){
return 0;
}
MOD_INT ret(0);
if(loc%2 == 1){
ll tmp = loc-1;
ret = g(tmp);
return ret*S+MOD_INT(B)*tmp;
}else{
ll tmp = loc/2;
ret = g(tmp);
return ret = ret*mod_pow(S,tmp,M)+ret+MOD_INT(B)*tmp*f(tmp);
}
}
int main(){
scanf("%lld %lld %lld %lld",&L,&A,&B,&M);
MOD_INT ans = 0;
S = 10;
ll last = A+B*(L-1);
ll head,tail,num;
for(ll i = 1; i <= 18; i++,S *= 10){
ll mini = S/10,maxi = S-1;
if(A > maxi || last < mini)continue;
if(A >= mini){
head = A;
}else{
head = ((mini-A)+(B-1))/B*B+A;
head = min(head,last);
}
if(last <= maxi){
tail = last;
}else{
tail = (maxi-A)/B*B+A;
}
num = (tail-head)/B+1;
//printf("i:%lld head:%lld tail:%lld num:%lld\n",i,head,tail,num);
ans *= mod_pow(S,num,M);
ans += f(num)*head;
ans += g(num);
}
printf("%lld\n",ans.x);
return 0;
}
|
#include <vector>
#include <iostream>
using namespace std;
int binpow(unsigned long long a, unsigned long long b, int m) {
// returns a^b mod m
a %= m;
int ans = 1;
while (b > 0) {
if (b & 1) ans = 1LL * ans * a % m;
a = 1LL * a * a % m;
b >>= 1;
}
return ans;
}
int binpow2(unsigned long long a, unsigned long long b, int m) {
// returns a^0 + a^1 + a^2 + ... + a^(b-1) mod m
a %= m;
if (b == 0) return 0;
if (b & 1) return (1LL * binpow2(a, b - 1, m) * a + 1) % m;
return 1LL * binpow2(a, b / 2, m) * (binpow(a, b / 2, m) + 1) % m;
}
int binpow3(unsigned long long a, unsigned long long b, int m) {
// return a^0 * 0 + a^1 * 1 + a^2 * 2 + ... + a^(b-1) * (b-1)
a %= m;
if (b == 0) return 0;
if (b & 1) return (binpow3(a, b - 1, m) + 1LL * binpow(a, b - 1, m) * ((b - 1) % m)) % m;
int r1 = binpow(a, b / 2, m);
int r2 = binpow2(a, b / 2, m);
int r3 = binpow3(a, b / 2, m);
return (1LL * r3 * (r1 + 1) + 1LL * r2 * ((b / 2) % m) % m * r1) % m;
}
int main() {
long long L, A, B; int M;
cin >> L >> A >> B >> M;
const int max_digits = 18;
unsigned long long mult = 1;
for (int i = 0; i < max_digits; ++i) {
mult *= 10;
}
int ans = 0; unsigned long long curlen = 0;
for (int i = max_digits; i >= 1; --i) {
mult /= 10;
long long pl = (mult < A ? 0 : (mult - A + B - 1) / B);
long long pr = (mult * 10 < A ? 0 : (mult * 10 - A + B - 1) / B);
if (pl > L) pl = L;
if (pr > L) pr = L;
if (pl == pr) continue;
unsigned long long nlen = pr - pl;
int bs = (mult * 10) % M;
int c2 = binpow2(bs, nlen, M);
int c3 = binpow3(bs, nlen, M);
int sub = int(1LL * c2 * ((A + ((pr - 1) % M) * (B % M)) % M) % M) - int(1LL * c3 * (B % M) % M);
if (sub < 0) sub += M;
ans = (ans + 1LL * sub * binpow(10, curlen, M)) % M;
if (ans >= M) ans -= M;
curlen += nlen * (unsigned long long)(i);
}
cout << ans << endl;
return 0;
} |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int main(){
ll l,a,b,m,e,ans=0; cin>>l>>a>>b>>m;
vector<ll> p(19,1);
rep(i,18) p[i+1]=p[i]*10;
e=a+b*(l-1);
ll an=0,en=0,A=a,E=e;
while(A>0){
A/=10; an++;
}
while(E>0){
E/=10; en++;
}
ll cur=l-1,c=1;
for(int i=en;i>=an;i--){
ll num=1,d=(a%m+b%m*(cur%m))%m,ad=b%m,mul=p[i]%m;
if(i==an) num-=(a+b-(a%b)+b-1)/b;
else num-=(p[i-1]+b-(a%b)+b-1)/b;
if(i==en) num+=(e+b-(a%b))/b;
else num+=(p[i]-1+b-(a%b))/b;
rep(j,64){
if(num&(1LL<<j)){
ans=(ans+(c*d)%m)%m;
c=c*mul%m;
d=(m+d-ad)%m;
}
d=(m+d-ad)*mul%m+d;
d%=m;
ad=(mul+1)*ad%m*2%m;
mul=mul*mul%m;
}
cur-=num;
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
#define ALL(v) (v).begin(), (v).end()
#define rep(i, n) for (ll i = 0, __##i##_length = (n); i < __##i##_length; i++)
#define rep_reverse(i, n) for (ll i = (n)-1; 0 < i; i--)
#define FOR(i, from, to) for (ll i = (from), __##i##_end = (to); i < __##i##_end; i++)
#define FOR_REVERSE(i, from, to) for (ll i = (to)-1, __##i##_end = (from); __##i##_end <= i; i--)
#define foreach(e, v) for (const auto e : (v))
#define vfree(v) std::vector<int>().swap(v)
#define DEBUG(x) cout << #x << " = " << (x) << endl
using namespace std;
typedef int64_t ll;
typedef vector<ll> llv;
typedef vector<ll> llvv;
llv mul(llv lhs, llv rhs, ll mod)
{
llv dst(9, 0);
rep(i, 9)
rep(j, 3)
{
dst[i] += (lhs[3 * (i / 3) + j] * rhs[j * 3 + (i % 3)]) % mod;
dst[i] %= mod;
}
return dst;
}
llv mul_vec_mat(llv vec, llv mat, ll mod)
{
llv dst(3);
rep(i, 3)
dst[i] = ((vec[0] * mat[i] % mod) + (vec[1] * mat[i + 3] % mod) + (vec[2] * mat[i + 6] % mod)) % mod;
return dst;
}
llv powmod(llv m, ll n, ll mod)
{
if (n == 0)
return llv{1, 0, 0, 0, 1, 0, 0, 0, 1};
if (n & 1)
{
llv tmp = powmod(m, n - 1, mod);
return mul(tmp, m, mod);
}
else
{
llv tmp = powmod(m, n / 2, mod);
return mul(tmp, tmp, mod);
}
}
int main()
{
ll L, A, B, M;
cin >> L >> A >> B >> M;
llv mat{1, 1, 0, 0, 0, 0, B % M, 0, 1};
ll i = 0, d = 10;
llv state{A % M, 0, 1};
mat[4] = d;
while (i <= L)
{
ll nexti = (d - A + B - 1) / B;
if (nexti != 0 && i <= nexti && i <= L)
{
mat[4] = d % M;
llv dst = powmod(mat, min(nexti, L) - i, M);
i = nexti;
state = mul_vec_mat(state, dst, M);
}
d *= 10;
}
cout << state[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using i64 = long long;
using Mat = std::vector<std::vector<i64>>;
i64 mod;
Mat make_mat(int n, int m) {
return Mat(n, std::vector<i64>(m));
}
Mat unit_mat(int n) {
auto ret = make_mat(n, n);
for (int i = 0; i < n; i++) ret[i][i] = 1;
return ret;
}
Mat operator*(const Mat &lhs, const Mat &rhs) {
int n = lhs.size();
auto ret = make_mat(n, n);
for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) for (int k = 0; k < n; k++) {
ret[i][j] = (ret[i][j] + lhs[i][k] * rhs[k][j] % mod) % mod;
}
return ret;
}
Mat pow(Mat m, i64 k) {
const int size = m.size();
auto ret = unit_mat(size);
while (k) {
if ((k & 1) == 1) ret = m * ret;
m = m * m;
k >>= 1ll;
}
return ret;
}
int main() {
i64 n, a, b;
std::cin >> n >> a >> b >> mod;
std::vector<i64> dcnt(20);
i64 sum = 0;
int initial = std::to_string(a).length();
for (i64 i = initial; i < 20; i++) {
i64 l = 0, r = n, th = 1;
for (i64 j = 0; j < i; j++) th *= 10;
while (r - l > 1) {
i64 k = (l + r) / 2;
i64 s = a + b * k;
if (s < th) l = k;
else r = k;
}
dcnt[i] = l + 1 - sum;
sum = l + 1;
}
i64 dd = 10;
i64 ret = 0, s = a;
for (i64 i = 1; i <= 18; i++) {
Mat m { { dd, 0, 0 }, { 1, 1, 0 }, { 0, b, 1 } };
m = pow(m, dcnt[i]);
ret = (ret * m[0][0] % mod + s * m[1][0] % mod + m[2][0]) % mod;
s = (s * m[1][1] % mod + m[2][1]) % mod;
dd = dd * 10 % mod;
}
std::cout << ret << std::endl;
return 0;
}
|
#include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/2
#define all(x) (x).begin(),(x).end()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define debug_vec(v) cerr<<#v<<":";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
using namespace std;
int MOD = 998244353;
// int MOD = 1000000007;
ll M;
//matrix
typedef vector<ll> vec;
typedef vector<vector<ll>> mat;
vec matmul(vec &dp,mat &mt){ // ret = Mv;
ll m = dp.size();
vec ret(m,0);
rep(i,m){
rep(j,m){
ret[i] += (mt[i][j]*dp[j])%M;
ret[i] %= M;
}
}
return ret;
}
mat update(mat &mt){ //ret = M^2
int m = mt.size();
mat ret(m,vec(m,0));
rep(i,m) rep(j,m) rep(k,m) ret[i][j] = (ret[i][j] + mt[i][k]*mt[k][j]%M)%M;
return ret;
}
void matpow(vec &dp,mat &mt,int k){// dp = (M^k)dp
int m = dp.size();
while(k){
if(k&1) dp = matmul(dp,mt);
mt = update(mt);
k /= 2;
}
}
signed main(){
ll l,a,b;
cin >> l >> a >> b >> M;
ll p[19];
p[0] = 1;
for(int i = 1;i <= 18;i++) p[i] = 10*p[i-1];
ll d[20]; // 10^d 以上になる最初のs
rep(i,19){
// 条件を満たす最小を求める
ll ok = l; //解が存在する値
ll ng = -1; //解が存在しない値
while(abs(ok-ng)>1){
ll mid = (ok+ng)/2;
if(a+b*mid >= p[i]){
ok = mid;
}else{
ng = mid;
}
}
d[i] = ok;
}
d[19] = l;
vec dp(3,0);
dp[1] = a%M;
dp[2] = 1;
rep(i,19){
mat mt(3,vec(3,0));
mt[0][0] = ((p[i]%M)*10)%M;
mt[0][1] = mt[1][1] = mt[2][2] = 1;
mt[1][2] = b%M;
matpow(dp,mt,d[i+1]-d[i]);
}
cout << dp[0]%M << endl;
//rep(i,19)cerr << i << " " << d[i] << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl https://cf17-final-open.contest.atcoder.jp/tasks/cf17_final_a
// rm -r -f test;oj dl http://abc129.contest.atcoder.jp/tasks/abc129_f
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i=0; i<(int)(n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using Graph = vector<vi>; // vi <=> vl
using vb = vector<bool>;
using boolGraph = vector<vb>;
using P = pair<int, int>; // int <=> ll
const int MOD = 1e9+7;
const int MOD2 = 998244353;
const double EPS = 1e-9;
int main() {
ll L, A, B, M;
cin >> L >> A >> B >> M;
P digit = P(1, 1);
ll tmp = 10;
while (A >= tmp) {
tmp *= 10;
++digit.first;
}
ll last = A + B * (L-1);
tmp = 10;
while (last >= tmp) {
tmp *= 10;
++digit.second;
}
ll init = A;
ll ans = 0;
ll pow10 = pow(10, digit.first);
for (int k=digit.first; k<=digit.second; ++k) {
if (pow10 <= init) {
pow10 *= 10;
continue;
}
ll num = (min(pow10 - 1, last) - init) / B + 1;
vl rem(64), dp(64), dp2(64), power(64);
rem[0] = pow10 % M;
dp[0] = 1;
dp2[0] = 1;
power[0] = 1;
rep(i,63) {
rem[i+1] = rem[i] * rem[i] % M;
dp[i+1] = dp[i] * (1 + rem[i]) % M;
dp2[i+1] = (dp2[i] * (1 + rem[i]) + dp[i] * power[i]) % M;
power[i+1] = power[i] * 2 % M;
}
ll expo = 1, sigma_a = 0;
ll expo2 = 1, sum = 0, sigma_b = 0;
for (int i=63; i>=0; --i) {
if ((num >> i) & 1) {
(sigma_a += expo * dp[i]) %= M;
(expo *= rem[i]) %= M;
}
if (((num - 1) >> i) & 1) {
(sigma_b += sum * power[i] + expo2 * dp2[i]) %= M;
(sum += expo2 * dp[i]) %= M;
(expo2 *= rem[i]) %= M;
}
}
(ans *= expo) %= M;
(ans += (init % M) * sigma_a + (B % M) * sigma_b) %= M;
init += B * num;
pow10 *= 10;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
long long n, a, b, mod;
bool read() {
if (!(cin >> n >> a >> b >> mod))
return false;
return true;
}
int getlen(long long num) {
auto res = 0;
for (; num > 0; num /= 10, ++res) { }
return res;
}
long long bpow(long long a, long long n, long long mod) {
auto res = 1ll;
a %= mod;
for (; n > 0; n /= 2, a = a * a % mod)
if (n & 1)
res = res * a % mod;
return res;
}
long long series1(long long x, long long n) {
if (n == 0)
return 1ll;
auto nn = (n - 1) / 2;
auto res = series1(x, nn) * (1 + bpow(x, nn + 1, mod)) % mod;
if (n % 2 == 0)
res += bpow(x, n, mod);
return res % mod;
}
long long series2(long long x, long long n) {
if (n == 0)
return 0ll;
auto nn = (n - 1) / 2;
auto piv = bpow(x, nn + 1, mod);
auto res = (series2(x, nn) * (1 + piv) + (nn + 1) % mod * series1(x, nn) % mod * piv) % mod;
if (n % 2 == 0)
res += n % mod * bpow(x, n, mod) % mod;
return res % mod;
}
long long calc(long long a, long long b, long long n) {
long long x = bpow(10ll, getlen(a), mod);
return (mod + (a % mod * series1(x, n) - b % mod * series2(x, n)) % mod) % mod;
}
void solve() {
auto ans = 0ll;
for (long long len = getlen(a), i = 0; i < n; ++len) {
if (len < getlen(a + i * b))
continue;
auto l = i;
auto r = n - 1;
for (; l < r; ) {
auto m = (l + r + 1) / 2;
if (getlen(a + b * m) > len)
r = m - 1;
else
l = m;
}
ans = bpow(bpow(10ll, len, mod), r + 1 - i, mod) * ans % mod;
ans = (ans + calc(a + r * b, b, r - i)) % mod;
i = r + 1;
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
|
#include <iostream>
#define ll long long
using namespace std;
ll cal10[64];
ll big10(ll key, ll mod){
ll res=1;
for(int i=0; i<64; ++i){
if(key&((ll) 1<<i)){
res=(res*cal10[i])%mod;
}
}
return res;
}
int main() {
ll L, A, B, M;
cin >> L >> A >> B >> M;
ll b10[19];
b10[0]=1;
for(int i=1; i<19; ++i) b10[i]=b10[i-1]*10;
ll rnow=L, dig=0, ans=0;
cal10[0]=10%M;
for(int i=1; i<64; ++i) cal10[i]=(cal10[i-1]*cal10[i-1])%M;
for(int p=18; p>0; --p){
ll left=-1, right=rnow;
while(left+1<right){
ll mid=(left+right)/2;
if(A+B*mid<b10[p-1]) left=mid;
else right=mid;
}
ll cnt=rnow-right;
if(cnt==0) continue;
ll dp[3][3], ep[3][3];
dp[0][0]=(b10[p]+1)%M;
dp[0][1]=dp[0][2]=M-b10[p]%M;
dp[1][0]=1;
dp[1][1]=dp[1][2]=dp[2][0]=dp[2][1]=0;
dp[2][2]=b10[p]%M;
for(int i=0; i<3; ++i){
for(int j=0; j<3; ++j){
if(i==j) ep[i][j]=1;
else ep[i][j]=0;
}
}
for(int s=0; s<64; ++s){
ll fp[3][3];
if((cnt-1)&((ll) 1<<s)){
for(int j=0; j<3; ++j){
for(int k=0; k<3; ++k){
fp[j][k]=0;
for(int q=0; q<3; ++q){
fp[j][k]=(fp[j][k]+(dp[j][q]*ep[q][k])%M)%M;
}
}
}
for(int i=0; i<9; ++i) ep[i/3][i%3]=fp[i/3][i%3];
}
for(int j=0; j<3; ++j){
for(int k=0; k<3; ++k){
fp[j][k]=0;
for(int q=0; q<3; ++q){
fp[j][k]=(fp[j][k]+(dp[j][q]*dp[q][k])%M)%M;
}
}
}
for(int i=0; i<9; ++i) dp[i/3][i%3]=fp[i/3][i%3];
}
ll ad=(ep[0][0]*(((A%M)+((B%M)*((rnow-1)%M))%M)))%M;
ad=(ad+(ep[0][2]*(B%M))%M)%M;
ad=(ad*big10(dig, M))%M;
ans=(ans+ad)%M;
dig += cnt*p;
rnow=right;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int INF=1e9;
const int MOD=1e9+7;
//const int MOD=998244353;
const long long LINF=1e18;
using namespace std;
#define int long long
//template
int L,a,b,m;
int x=0;
int gy[3][3],tmp[3][3],ans[3][3];
int pw(int n,int k){
if(k<0)return pw(n,k+MOD-1);
int res=1;
while(k){
if(k&1)res*=n;//res%=MOD;
n*=n;//n%=MOD;
k>>=1;
}
return res;
}
void toans(){
memset(tmp,0,sizeof(tmp));
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
tmp[i][j]+=gy[i][k]*ans[k][j];
for(int i=0;i<3;i++)for(int j=0;j<3;j++)ans[i][j]=tmp[i][j]%m;
}
void gygy(){
memset(tmp,0,sizeof(tmp));
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
tmp[i][j]+=gy[i][k]*gy[k][j];
for(int i=0;i<3;i++)for(int j=0;j<3;j++)gy[i][j]=tmp[i][j]%m;
}
void g(int n){
int t=n;
memset(ans,0,sizeof(ans));
ans[0][0]=ans[1][1]=ans[2][2]=1;
while(n){
if(n&1)toans();
gygy();
n>>=1;
}
}
void f(int n){
int l=(pw(10,n-1)-a)/b;if((pw(10,n-1)-a)%b)l++;if((pw(10,n-1)-a)<0)l=0;
int r=(pw(10,n)-a)/b;r--;if((pw(10,n)-a)%b)r++;if((pw(10,n)-a)<0)r=-1;
r=min(r,L-1);l=min(l,L);
memset(gy,0,sizeof(gy));
gy[0][1]=gy[1][1]=gy[2][2]=1;
gy[1][2]=b;
gy[0][0]=pw(10,n)%m;
g(r-l+1);
x=(ans[0][0]*x+ans[0][1]*((a%m+b%m*l)%m)+ans[0][2])%m;
}
//main
signed main(){
cin>>L>>a>>b>>m;
for(int i=1;i<=18;i++)f(i);
cout<<x<<endl;
}
/*
解説AC
多分キムチ鍋食べてた日の回
行列累乗使うってネタバレは見てたけど桁が動くから出来なくね？って思ってたけど良く考えたら桁18種類だし場合分けするだけだった
実装はそこまで詰まらずに出来たのでわりかし満足
*/
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll L, A, B;
int mod;
void specPower(int d, int q, ll p, int &dsum, int &sum, int &qpw)
{
if (p == 0) { dsum = sum = 0; qpw = 1; }
else {
specPower(d, q, p / 2, dsum, sum, qpw);
dsum = (ll(dsum) * qpw + ll(p / 2) * ll(d) % mod * sum + ll(dsum)) % mod;
sum = (ll(sum) * qpw + ll(sum)) % mod;
qpw = ll(qpw) * qpw % mod;
if (p % 2) {
dsum = (ll(dsum) * q + ll(p / 2 * 2) * d + ll(d)) % mod;
sum = (ll(sum) * q + 1ll) % mod;
qpw = ll(qpw) * q % mod;
}
}
}
int main()
{
cin >> L >> A >> B >> mod;
ll fir = A, lst = A + (L - 1) * B;
ll lef = 1, rig = 10;
int res = 0;
while (lef <= lst) {
if (fir < rig) {
ll hm = (min(rig - 1, lst) - fir) / B + 1;
int dsum, sum, qpw;
specPower(B % mod, rig % mod, hm - 1, dsum, sum, qpw);
int my = dsum;
sum = (sum + qpw) % mod;
my = (my + ll(fir % mod) * sum) % mod;
qpw = ll(rig % mod) * qpw % mod;
res = (ll(res) * qpw + ll(my)) % mod;
fir += hm * B;
}
lef *= 10; rig *= 10;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define debug(x) cerr << #x << " " << x << '\n'
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using pli = pair<ll,int>;
const int INF = 0x3f3f3f3f, N = 2e5 + 5;
const ll LINF = 1e18 + 5;
ll len, A, B, L, R;
int mod, n;
struct matrix
{
ll mat[3][3];
}a;
matrix operator * (matrix a, matrix b)
{
matrix res;
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
{
res.mat[i][j] = 0;
for(int k=0; k<n; k++)
res.mat[i][j] = (res.mat[i][j]+a.mat[i][k]*b.mat[k][j]%mod)%mod;
}
return res;
}
void one(matrix& E)
{
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
E.mat[i][j] = (i==j);
}
matrix operator ^ (matrix a, ll x)
{
matrix res;
one(res);
while(x)
{
if(x&1) res = res * a;
a = a * a;
x >>= 1;
}
return res;
}
bool find(ll x, ll y)
{
ll l = 0, r = len-1;
L = -1;
while(l<=r)
{
ll mid = (l+r)>>1;
ll cur = A + mid*B;
if(cur<x) l = mid + 1;
else L = mid, r = mid - 1;
}
l = 0, r = len-1;
R = -1;
while(l<=r)
{
ll mid = (l+r)>>1;
ll cur = A + mid*B;
if(cur>=y) r = mid - 1;
else R = mid, l = mid + 1;
}
if(R==len-1) return 0;
return 1;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cin >> len >> A >> B >> mod;
const ll up = 1e18;
ll ans = 0, s = 0;
bool ok = 1;
n = 3;
for(ll d=10; d<=up&&ok; d*=10)
{
ok = find(d/10, d);
if(R-L+1<=0) continue;
a.mat[0][0] = d%mod;
a.mat[0][1] = a.mat[0][2] = a.mat[1][2] = a.mat[2][0] = 0;
a.mat[1][0] = a.mat[1][1] = a.mat[2][2] = 1;
a.mat[2][1] = B%mod;
a = a ^ (R-L+1);
(s = A + L*B) %= mod;
(ans = ans*a.mat[0][0]%mod + s*a.mat[1][0]%mod + a.mat[2][0]) %= mod;
}
ans = (ans + mod)%mod;
cout << ans;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <initializer_list>
using lli=long long int;
int M;
class mat3{
public:
lli m[3][3] = {};
mat3(){}
mat3(std::initializer_list<lli> init){
auto it = init.begin();
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3; j++){
m[i][j] = (((*it)%M)+M)%M;
++it;
}
}
}
};
const mat3 operator*(const mat3& lhs, const mat3& rhs){
mat3 ans;
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3; j++){
for(int k = 0; k < 3; k++){
ans.m[i][j] += lhs.m[i][k]*rhs.m[k][j];
}
ans.m[i][j] %= M;
}
}
return ans;
}
int main(){
lli L,A,B;
std::cin >> L >> A >> B >> M;
std::vector<lli> ns_d(1);
lli tmp = 9;
while(A+B*(L-1)>tmp){
if(A>tmp){
ns_d.push_back(0);
}else{
ns_d.push_back((tmp-A)/B+1);
}
tmp = tmp*10+9;
}
ns_d.push_back(L);
mat3 mat_total = {1,0,0,0,1,0,0,0,1};
for(int i = 1; i < ns_d.size(); i++){
lli ipow = 1;
for(int j = 0; j < i; j++){
ipow = (ipow*10)%M;
}
lli isize = ns_d[i]-ns_d[i-1];
mat3 mat_last = {ipow,1,0,0,1,B,0,0,1};
int nb = 0;
while((isize>>nb)!=0){
if((isize>>nb)&1){
mat_total = mat_last*mat_total;
}
mat_last = mat_last*mat_last;
nb++;
}
}
lli ans = ((mat_total.m[0][1]*(A%M))%M+mat_total.m[0][2])%M;
std::cout << ans << std::endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<vector<ll>> Mat;
#define ALL(v) (v).begin(),(v).end()
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
ll pow_10[20];
ll M;
ll mod_pow(ll a, ll n) {
if (n == 0) return 1;
if (n % 2 == 0) {
ll tmp = mod_pow(a, n / 2);
return (tmp * tmp) % M;
}
return (a * mod_pow(a, n - 1)) % M;
}
Mat operator*(const Mat& a, const Mat& b) {
Mat ret(a.size(), vector<ll>(b[0].size()));
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < b[0].size(); j++) {
for (int k = 0; k < a[0].size(); k++) {
(ret[i][j] += a[i][k] * b[k][j] % M) %= M;
}
}
}
return ret;
}
Mat mat_pow(const Mat& a, ll n) {
Mat ret;
if (n == 0) {
ret = Mat(a.size(), vector<ll>(a[0].size()));
for (int i = 0; i < a.size(); i++) ret[i][i] = 1;
return ret;
}
if (n % 2 == 0) {
Mat t = mat_pow(a, n / 2);
ret = t * t;
}
else {
Mat t = mat_pow(a, n / 2);
ret = t * t;
ret = ret * a;
}
return ret;
}
int main() {
ll L, A, B;
cin >> L >> A >> B >> M;
pow_10[0] = 1;
for (int i = 1; i <= 18; i++) {
pow_10[i] = pow_10[i - 1] * 10;
}
ll X = 0, s = A % M;
for (int i = 0; i < 18; i++) {
ll l, r;
if (pow_10[i] <= A) l = 0;
else l = (pow_10[i] - A + B - 1) / B;
if (pow_10[i + 1] <= A) r = 0;
else r = (pow_10[i + 1] - A + B - 1) / B;
if (l == r) continue;
if (l >= L) break;
r = min(r, L);
Mat P(3, vector<ll>(3));
P[0][0] = pow_10[i + 1] % M;
P[0][1] = 1;
P[1][1] = 1;
P[1][2] = B % M;
P[2][2] = 1;
Mat Q = mat_pow(P, r - l);
Mat v(3, vector<ll>(1));
v[0][0] = X;
v[1][0] = s;
v[2][0] = 1;
Mat R = Q * v;
X = R[0][0];
s = R[1][0];
}
cout << X << endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef vector<long long> vec;
typedef vector<vec> mat;
long long L, A, B, M;
mat mal( mat a, mat b )
{
mat c( 3, vec( 3 ) );
for( int i = 0; i < 3; i++ ) {
for( int j = 0; j < 3; j++ ) {
for( int k = 0; k < 3; k++ ) {
c[i][j] += a[i][k] * b[k][j] % M;
c[i][j] %= M;
}
}
}
return c;
}
mat powmat( mat m, long long n )
{
mat res( 3, vec( 3 ) );
for( int i = 0; i < 3; i++ ) res[i][i] = 1;
while( n ) {
if( n & 1 ) res = mal( res, m );
m = mal( m, m );
n >>= 1;
}
return res;
}
int main() {
cin >> L >> A >> B >> M;
long long ans = 0;
for( long long pow10 = 10; pow10 <= 1e18; pow10 *= 10 ) {
if( pow10 <= A ) continue;
long long Cd = (pow10 - A + B - 1) / B;
Cd = min( Cd, L );
mat m( 3, vec( 3 ) );
m[0][0] = pow10 % M;
m[1][0] = 1;
m[1][1] = 1;
m[2][1] = B % M;
m[2][2] = 1;
m = powmat( m, Cd );
mat r( 3, vec( 3 ) );
r[0][0] = ans;
r[0][1] = A % M;
r[0][2] = 1;
r = mal( r, m );
ans = r[0][0];
A += Cd * B;
L -= Cd;
if( L == 0 ) {
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define all(V) V.begin(),V.end()
using vv = vector<vector<ll>>;
ll M;
void say(vv v) {
for (int i = 0;i < 3;i++) {
for (int j = 0;j < 3;j++)
cout << v[i][j] << " ";
cout << endl;
}
}
vv matpow(vv X, ll K) {
vv A(3, vector<ll>(3, 0)), N = A, S = A;
A[0][0] = A[1][1] = A[2][2] = 1;
while (K) {
if (K & 1) {
for (int i = 0;i < 3;i++) {
for (int j = 0;j < 3;j++) {
for (int k = 0;k < 3;k++) {
N[j][k] += A[j][i] * X[i][k];
N[j][k] %= M;
}
}
}
}
else
N = A;
A = N;
K /= 2;
if (K < 1)break;
N = S;
for (int i = 0;i < 3;i++)
for (int j = 0;j < 3;j++)
for (int k = 0;k < 3;k++)
N[j][k] += X[j][i] * X[i][k], N[j][k] %= M;
X = N;
N = S;
}
return A;
}
ll modpow(ll x, ll y) {
ll ans = 1;
while (y) {
if (y & 1)ans *= x;
x *= x;
x %= M;
ans %= M;
y /= 2;
}
return ans;
}
int main() {
ll A, B, L;
cin >> L >> A >> B >> M;
vector<vector<ll>> mt(3, vector<ll>(3, 0));
vector<ll> mans(19, 0), kr(20, 1);
ll d10 = 10, ft = A, lt = A + (L - 1) * B, nl;
for (ll i = 1;i < 19;i++) {
if (d10 > ft) {
nl = (min(d10 - 1, lt) - ft) / B;
vv H = {
{d10 % M, B % M, ft % M},
{0,1,1},
{0,0,1}
};
vv G = matpow(H, nl);
mans[i] = (G[0][0] * (ft % M) + G[0][1] + G[0][2]) % M;
kr[i] = modpow(d10 % M, nl + 1);
ft += (nl + 1) * B;
}
if (d10 > lt)break;
d10 *= 10;
}
for (int i = 19;i > 0;i--) {
kr[i - 1] *= kr[i];
kr[i - 1] %= M;
}
ll fans = 0;
for (ll i = 1;i < 19;i++) {
fans += kr[i + 1] * mans[i];
fans %= M;
}
cout << fans << endl;
} |
#include <iostream>
#include <stdlib.h>
#include <string>
#define llint long long
using namespace std;
llint n, a, b, mod;
llint beki[35];
llint modpow(llint a, llint n)
{
if(n == 0) return 1;
if(n % 2){
return ((a%mod) * (modpow(a, n-1)%mod)) % mod;
}
else{
return modpow((a*a)%mod, n/2) % mod;
}
}
llint calc2(llint n, llint x)
{
if(n == 0) return 0;
if(n % 2){
return (calc2(n-1, x) + modpow(modpow(10, n-1), x) % mod) % mod;
}
else{
llint res = calc2(n/2, x);
llint ret = res * modpow(modpow(10, n/2), x) % mod + res; ret %= mod;
return ret;
}
}
llint calc(llint l, llint r, llint d)
{
//cout << l << " " << r << " " << d << endl;
if(l > r) return 0;
if(l == r) return (a%mod+b%mod*l%mod) % mod;
if((r-l+1)%2){
return (calc(l+1, r, d) + modpow(modpow(10, r-l), d) % mod * ((a%mod+b%mod*l%mod)%mod) % mod) % mod;
}
else{
llint m = (l+r)/2;
llint res = calc(l, m, d);
llint ret = res * modpow(modpow(10, r-m), d) % mod + res; ret %= mod;
ret += b*(r-m)%mod * calc2(r-m, d) % mod, ret %= mod;
return ret;
}
}
int main(void)
{
cin >> n >> a >> b >> mod;
//mod = 1000000007;
beki[0] = 1;
for(int i = 1; i < 19; i++) beki[i] = beki[i-1] * 10;
llint len = 1, ans = 0;
for(int i = 18; i >= 1; i--){
//cout << i << endl;
llint l = (beki[i-1]-a+b-1)/b;
llint r = (beki[i]-a+b-1)/b - 1;
if((beki[i-1]-a+b-1) < 0) l = -1;
if((beki[i]-a+b-1)/b < 0) r = -1;
if(l >= n || r < 0) continue;
r = min(r, n-1), l = max(l, 0LL);
//cout << ans << endl;
//cout << l << " " << r << " " << i << " " << len << endl;
llint res = calc(l, r, i);
ans += res * len % mod, ans %= mod;
llint tmp = modpow(modpow(10, r-l+1), i);
len *= tmp, len %= mod;
//len += (r-l+1)%mod * i%mod, len %= mod;
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
const int INF=1e9;
const int MOD=1e9+7;
//const int MOD=998244353;
const long long LINF=1e18;
using namespace std;
#define int long long
//template
int L,a,b,m;
int x=0;
int gy[3][3],tmp[3][3],ans[3][3];
int pw(int n,int k){
if(k<0)return pw(n,k+MOD-1);
int res=1;
while(k){
if(k&1)res*=n;//res%=MOD;
n*=n;//n%=MOD;
k>>=1;
}
return res;
}
void toans(){
memset(tmp,0,sizeof(tmp));
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
tmp[i][j]+=gy[i][k]*ans[k][j];
for(int i=0;i<3;i++)for(int j=0;j<3;j++)ans[i][j]=tmp[i][j]%m;
}
void gygy(){
memset(tmp,0,sizeof(tmp));
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
tmp[i][j]+=gy[i][k]*gy[k][j];
for(int i=0;i<3;i++)for(int j=0;j<3;j++)gy[i][j]=tmp[i][j]%m;
}
void g(int n){
int t=n;
memset(ans,0,sizeof(ans));
ans[0][0]=ans[1][1]=ans[2][2]=1;
while(n){
if(n&1)toans();
gygy();
n>>=1;
}
}
void f(int n){
int l=(pw(10,n-1)-a)/b;if((pw(10,n-1)-a)%b)l++;if((pw(10,n-1)-a)<0)l=0;
int r=(pw(10,n)-a)/b;r--;if((pw(10,n)-a)%b)r++;if((pw(10,n)-a)<0)r=-1;
r=min(r,L-1);l=min(l,L);
//cout<<l<<" "<<r<<endl;
memset(gy,0,sizeof(gy));
gy[0][1]=gy[1][1]=gy[2][2]=1;
gy[1][2]=b;
gy[0][0]=pw(10,n)%m;
g(r-l+1);
x=(ans[0][0]*x+ans[0][1]*((a%m+b%m*l)%m)+ans[0][2])%m;
//cout<<x<<endl;
}
//main
signed main(){
cin>>L>>a>>b>>m;
for(int i=1;i<=18;i++)f(i);
cout<<x<<endl;
}
/*
if(t==2&&n==1){
cout<<gy[0][0]<<" "<<gy[0][1]<<" "<<gy[0][2]<<endl;
cout<<gy[1][0]<<" "<<gy[1][1]<<" "<<gy[1][2]<<endl;
cout<<gy[2][0]<<" "<<gy[2][1]<<" "<<gy[2][2]<<endl;
}
*/
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define forn(i, n) for (ll i = 0; i < (n); i++)
#define fori(i, b, e) for (ll i = (b); i < (e); i++)
#define forr(i, b, e) for (ll i = (b); i >= (e); i--)
#define allele(v) v.begin(), v.end()
#define fi first
#define se second
ll mod;
class Matrix
{
public:
vector<vector<ll>> M;
Matrix(int h, int w)
{
M = vector<vector<ll>>(h, vector<ll>(w));
}
vector<ll> &operator[](int i)
{
return M[i];
}
};
Matrix operator*(Matrix x, Matrix y)
{
int xh = x.M.size(), xw = x[0].size();
int yh = y.M.size(), yw = y[0].size();
if (xw != yh)
throw invalid_argument("Sizes do not match.");
Matrix res(xh, yw);
forn(i, xh) forn(j, yw)
{
res[i][j] = 0;
forn(k, xw) res[i][j] += ((x[i][k] % mod) * (y[k][j] % mod)) % mod, res[i][j] %= mod;
}
return res;
}
template <typename T>
T quickpow(T b, ll e)
{
T cur = b;
T ans = b;
e--;
while (e)
{
if (e & 1)
ans = ans * cur;
cur = cur * cur;
e >>= 1;
}
return ans;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll l, a, b;
cin >> l >> a >> b >> mod;
ll pow10[20];
ll cur = 1;
forn(i, 19) pow10[i] = cur, cur *= 10;
Matrix ans(3, 1);
ans.M = {{0}, {a}, {b}};
forn(x, 19)
{
if (pow10[x + 1] <= a)
continue;
ll L = (pow10[x + 1] - a + b - 1) / b - (max(pow10[x], a) - a + b - 1) / b;
L = min(L, l), l -= L;
Matrix M(3, 3);
M.M = {{pow10[x + 1] % mod, 1, 0}, {0, 1, 1}, {0, 0, 1}};
if (L > 0)
ans = quickpow(M, L) * ans;
}
cout << ans[0][0] << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template<class T>
void debug(T itr1, T itr2) { auto now = itr1; while(now<itr2) { cout << *now << " "; now++; } cout << endl; }
#define repr(i,from,to) for (int i=(int)from; i<(int)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i,N) repr(i,0,N)
#define per(i,N) for (int i=(int)N-1; i>=0; i--)
const ll MOD = pow(10,9)+7;
const ll LLINF = pow(2,61)-1;
const int INF = pow(2,30)-1;
vector<ll> fac;
void c_fac(int x=pow(10,6)+10) { fac.resize(x,true); rep(i,x) fac[i] = i ? (fac[i-1]*i)%MOD : 1; }
ll inv(ll a, ll m=MOD) { ll b = m, x = 1, y = 0; while (b!=0) { int d = a/b; a -= b*d; swap(a,b); x -= y*d; swap(x,y); } return (x+m)%m; }
ll nck(ll n, ll k) { return fac[n]*inv(fac[k]*fac[n-k]%MOD)%MOD; }
ll gcd(ll a, ll b) { if (a<b) swap(a,b); return b==0 ? a : gcd(b, a%b); }
ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
int main() {
ll L, A, B, M; cin >> L >> A >> B >> M;
ll dl[18] = {}; rep(i,18) dl[i] = min((ll)L, max((ll)0, ((ll)pow(10,i+1)-A+(B-1))/B));
ll fn[18] = {}; rep(i,18) fn[i] = (max(A,pow(10,i+1)<=A ? -1 : ((ll)pow(10,i)-A+(B-1))/B*B+A))%M;
per(i,17) dl[i+1] -= dl[i];
// debug(dl,dl+18); debug(fn,fn+18);
ll p10[18] = {}; rep(i,18) p10[i] = i==0 ? 10%M : (p10[i-1]*10)%M;
ll arr[3] = {0,1,B};
rep(i,18) {
arr[1] = fn[i];
ll mat[3][3] = {{p10[i],1,0},{0,1,1},{0,0,1}};
ll now = 1;
while (dl[i]>=now) {
if (dl[i]&now) {
ll ta[3] = {}; rep(j,3) rep(k,3) ta[j] =(ta[j]+mat[j][k]*arr[k])%M ;
rep(j,3) arr[j] = ta[j];
}
ll tm[3][3] = {}; rep(j,3) rep(k,3) rep(l,3) tm[j][k] = (tm[j][k]+mat[j][l]*mat[l][k])%M;
rep(j,3) rep(k,3) mat[j][k] = tm[j][k];
now *= 2;
}
// cout << i+1 << ": "; debug(arr,arr+3);
}
ll result = arr[0];
cout << result << endl;
return 0;
} |
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <typeinfo>
#include <numeric>
#include <functional>
#include <unordered_map>
#include <bitset>
#include <stack>
#include <assert.h>
#include <unordered_set>
#include <random>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for(ll i = 0; i < n; i++)
using vec = vector<ll>;
using mat = vector<vec>;
mat mul(mat a, mat b, ll m){
mat c(a.size(), vec(b[0].size()));
for(ll i = 0; i < a.size(); i++){
for(ll k = 0; k < b.size(); k++){
for(ll j = 0; j < b[0].size(); j++){
c[i][j] = (c[i][j] + a[i][k] * b[k][j]) % m;
}
}
}
return c;
}
mat POW(mat a, ll n, ll m){
mat b(a.size(), vec(a.size()));
for(ll i = 0; i < a.size(); i++){
b[i][i] = 1;
}
while(n > 0){
if(n & 1){
b = mul(b, a, m);
}
a = mul(a, a, m);
n >>= 1;
}
return b;
}
ll len(ll x){
ll res = 0;
while(x > 0){
x /= 10;
res++;
}
return res;
}
ll f(ll l, ll a, ll b){
ll z = len(a);
ll le = 0, ri = l;
while(le < ri){
ll m = (le + ri) / 2;
if(z == len(a + b * m)){
le = m + 1;
}
else{
ri = m;
}
}
return le;
}
int main(){
ll l, a, b, m;
cin >> l >> a >> b >> m;
ll sum = 0;
while(l > 0){
ll k = f(l, a, b);
ll p = 1;
REP(i, len(a)){
p *= 10;
p %= m;
}
vec r = {sum, a % m, 1};
mat x = {{p, 0, 0},
{1, 1, 0},
{0, b % m, 1}};
x = POW(x, k, m);
vec t(3);
t[0] = (r[0] * x[0][0] + r[1] * x[1][0] + r[2] * x[2][0]) % m;
t[1] = (r[0] * x[0][1] + r[1] * x[1][1] + r[2] * x[2][1]) % m;
t[2] = (r[0] * x[0][2] + r[1] * x[1][2] + r[2] * x[2][2]) % m;
sum = t[0];
l -= k;
a += b * k;
}
cout << sum << endl;
} |
#include<iostream>
using namespace std;
long L,A,B,M;
long ten[99],sten[99],iten[99];
long n;
long cnt[18],SUM[18];
long pre,tmpten,ans,ll,rr,mm,k,X,Y,p,g;
int main()
{
cin>>L>>A>>B>>M;
pre=-1,tmpten=1;
for(n=1;n<=18;n++)
{
cnt[n-1]=1;
ll=pre,rr=L;
tmpten*=10;
while(rr-ll>1)
{
mm=(ll+rr)/2;
if(A+B*mm<tmpten)ll=mm;
else rr=mm;
}
k=ll-pre;
if(k<0)
{
continue;
}
pre=ll;
ten[0]=tmpten%M;
sten[0]=1;
iten[0]=0;
if(k&1)cnt[n-1]=tmpten%M;
for(int i=1;i<61;i++)
{
ten[i]=ten[i-1]*ten[i-1]%M;
sten[i]=(ten[i-1]+1)%M*sten[i-1]%M;
iten[i]=((ten[i-1]+1)%M*iten[i-1]+(1LL<<i-1)%M*sten[i-1]%M*ten[i-1])%M;
if(k>>i&1)cnt[n-1]=cnt[n-1]*ten[i]%M;
}
X=0,p=1,Y=0,g=0;
for(int i=61;i--;)
{
if(k>>i&1)
{
(X+=sten[i]*p)%=M;
(Y+=(iten[i]+sten[i]*g)%M*p)%=M;
p=p*ten[i]%M;
g=(g+(1LL<<i))%M;
}
}
SUM[n-1]=(((A+B*ll)%M*X-B%M*Y)%M+M)%M;
}
p=1;
for(int i=18;i--;)
{
ans=(ans+SUM[i]*p)%M;
p=p*cnt[i]%M;
}
cout<<ans<<endl;
}
|
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define FOR(i,j,k) for(int (i)=(j);(i)<(int)(k);++(i))
#define rep(i,j) FOR(i,0,j)
#define each(x,y) for(auto &(x):(y))
#define mp make_pair
#define MT make_tuple
#define all(x) (x).begin(),(x).end()
#define debug(x) cout<<#x<<": "<<(x)<<endl
#define smax(x,y) (x)=max((x),(y))
#define smin(x,y) (x)=min((x),(y))
#define MEM(x,y) memset((x),(y),sizeof (x))
#define sz(x) (int)(x).size()
#define RT return
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
int MOD = 0;
vector<vector<int> > mulMatMod(const vector<vector<int> > &A, const vector<vector<int> > &B) {
auto n = (int)A.size(), m = (int)A[0].size(), p = (int)B[0].size();
vector<vector<int> > res(n, vector<int>(p));
for (int i = 0; i < n; ++i)for (int j = 0; j < p; ++j) for (int k = 0; k < m; ++k)
res[i][j] = (int)((res[i][j] + (long long)A[i][k] * B[k][j]) % MOD);
return res;
}
vector<vector<int> > powMatMod(vector<vector<int> > A, long long k) {
auto n = (int)A.size();
vector<vector<int> > res(n, vector<int>(n));
for (int i = 0; i < n; ++i)res[i][i] = 1;
while (k) {
if (k % 2)res = mulMatMod(res, A);
k /= 2;
A = mulMatMod(A, A);
}
return res;
}
int digit(ll x) {
int res = 0;
while (x > 0) {
res++;
x /= 10;
}
return res;
}
void solve() {
ll L, A, B;
int M;
cin >> L >> A >> B >> M;
MOD = M;
ll ans = 0;
for (ll i = 0; i < L;) {
int d = digit(A + B * i);
ll pw = 1;
rep(j, d)pw *= 10;
ll j = (pw - A + B - 1) / B;
smin(j, L);
assert(j > i);
vector<vi> C(3, vi(3));
C[0][0] = C[0][2] = C[1][0] = C[2][2] = 1;
C[1][1] = (int)(pw%M);
auto D = powMatMod(C, j - i);
ll x = (A + B * i) % MOD;
ans = D[1][0] * x+ D[1][1] * ans + D[1][2] * (B%M);
ans %= MOD;
i = j;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll L,a,b,mod;
struct Matric
{
ll a[3][3];
Matric(){memset(a,0,sizeof(a));}
Matric operator*(const Matric&o)const
{
Matric ans;
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
ans.a[i][j]=(ans.a[i][j]+a[i][k]*o.a[k][j]%mod)%mod;
return ans;
}
};
Matric Mqpow(Matric a,ll n)
{
Matric ans;
ans.a[0][0]=ans.a[1][1]=ans.a[2][2]=1;
while(n)
{
if(n&1) ans=ans*a;
a=a*a;
n>>=1;
}
return ans;
}
ll qpow(ll a,ll n)
{
ll ans=1;
while(n)
{
if(n&1) ans=ans*a%mod;
a=a*a%mod;
n>>=1;
}
return ans;
}
int getlen(ll x)
{
int ans=0;
while(x)
{
x/=10;
ans++;
}
return ans;
}
ll getpos(int x)
{
ll l=1,r=L,ans=1;
while(l<=r)
{
ll m=l+r>>1;
if(getlen(a+(m-1)*b)<=x) ans=m,l=m+1;
else r=m-1;
}
return ans;
}
/*
si=s(i-1)*qpow(10,i)+qi+B;
gi=g(i-1)+B;
|10i 1 1| |si-1|
|0 1 1| |gi-1|
|0 0 1| |B|
*/
int main()
{
scanf("%lld%lld%lld%lld",&L,&a,&b,&mod);
ll ans=a%mod,res=a%mod,now=1;
for(int i=1;i<=18;i++)
{
ll p=getpos(i);
if(p==now) continue;
{
Matric A;
A.a[0][0]=qpow(10,i);A.a[0][1]=1;A.a[0][2]=1;
A.a[1][1]=1;A.a[1][2]=1;
A.a[2][2]=1;
A=Mqpow(A,p-now);
ans=(A.a[0][0]*ans%mod+A.a[0][1]*res%mod+b%mod*A.a[0][2]%mod)%mod;
res=(res+b*(p-now))%mod;
now=p;
}
}
printf("%lld\n",ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long L,A,B,M;
template<class K>
vector<vector<K>> matmul(const vector<vector<K>> &A,const vector<vector<K>> &B){
vector<vector<K>> C(A.size(),vector<K>(B[0].size(),K()));
for (int i=0;i<A.size();++i)
for (int j=0;j<B[0].size();++j)
for (int k=0;k<B.size();++k)
C[i][j]=(C[i][j]+A[i][k]*B[k][j]%M)%M;
return C;
}
template<class K>
vector<vector<K>> matpow(vector<vector<K>> A,long long n){
vector<vector<K>> res(A.size(),vector<K>(A.size(),K()));
for (int i=0;i<A.size();++i) res[i][i]=K(1);
while(n){
if (n&1) res=matmul(res,A);
A=matmul(A,A); n>>=1;
}
return res;
}
int digit(long long n){
int res=0;
while(n>0){n/=10; ++res;}
return res;
}
long long modpow(long long a,long long n){
long long res=1;
while(n>0){
if (n&1) res=res*a%M;
a=a*a%M; n>>=1;
}
return res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> L >> A >> B >> M;
vector<pair<long long,int>> ds;
ds.emplace_back(1,digit(A));
for(int i=digit(A)+1;;++i){
long long n=((long long)pow(10,i-1)-A+B-1)/B+1;
if (L<n) break;
if (digit(A+(n-1)*B)!=i) continue;
ds.emplace_back(n,i);
if (i==18) break;
}
ds.emplace_back(L+1,19);
int s=ds.size();
long long ans=0;
vector<vector<long long>> po(3,vector<long long>(3))
,cal={{1,1,0},{0,1,1},{0,0,1}}
,init={{0},{1},{B%M}}
,result(3,vector<long long>(1));
for (int i=0;i<s-1;++i){
long long n=ds[i+1].first-ds[i].first,d=ds[i].second;
cal[0][0]=modpow(10,d);
po=matpow(cal,n);
init[0][0]=ans,init[1][0]=(A%M+(ds[i].first-1)*B%M)%M;
ans=matmul(po,init)[0][0];
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define FORR(i, m, n) for (int i = (m); i >= (n); --i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
//const ll mod = 1000000007;
const ll mod2 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 1e18;
const ld EPS = 1e-10;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
ll mod;
ll keta[19], cnt[19];
typedef vector<ll> vec;
typedef vector<vec> mat;
mat mul(mat& a, mat& b) {
mat c(a.size(), vec(b[0].size(), 0));
rep(i, a.size()) {
rep(k, b.size()) {
rep(j, b[0].size()) {
c[i][j] += a[i][k] * b[k][j];
c[i][j] %= mod;
}
}
}
return c;
}
mat pow(mat a, ll n) {
mat b(a.size(), vec(a.size(), 0));
rep(i, a.size()) b[i][i] = 1;
while (n > 0) {
if (n & 1) b = mul(b, a);
a = mul(a, a);
n >>= 1;
}
return b;
}
int main() {
ll l, a, b;
cin >> l >> a >> b >> mod;
keta[0] = 1;
rep(i, 18) keta[i + 1] = keta[i] * 10;
rep(i, 19) keta[i]--;
rep(i, 19) {
if (keta[i] - a < 0) continue;
cnt[i] = min(l, (keta[i] - a) / b + 1);
}
repr(i, 18) cnt[i + 1] -= cnt[i];
mat A = {{1, b % mod, a % mod}, {0, 1, 1}, {0, 0, 1}};
mat ans = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
rep(i, 18) {
A[0][0] = A[0][0] * 10 % mod;
mat res = pow(A, cnt[i + 1]);
ans = mul(res, ans);
}
cout << ans[0][2] << endl;
return 0;
} |
#include <iostream>
#include <cstring>
using namespace std;
typedef long long ll;
class Matrix{
private:
ll m[3][3];
public:
Matrix(){memset(m, 0, sizeof(m));}
Matrix(ll m11, ll m12, ll m13, ll m21, ll m22, ll m23, ll m31, ll m32, ll m33){
m[0][0] = m11; m[0][1] = m12; m[0][2] = m13;
m[1][0] = m21; m[1][1] = m22; m[1][2] = m23;
m[2][0] = m31; m[2][1] = m32; m[2][2] = m33;
}
ll &at(int i, int j){return m[i][j];}
Matrix mul(Matrix o, ll mod){
Matrix out;
for (int i = 0; i < 3; ++i){
for (int j = 0; j < 3; ++j){
for (int k = 0; k < 3; ++k){
out.at(i, j) += (m[i][k]*o.at(k, j)) % mod;
}
}
}
return out % mod;
}
Matrix operator%(ll mod){
Matrix out;
for (int i = 0; i < 3; ++i){
for (int j = 0; j < 3; ++j){
out.at(i, j) = m[i][j] % mod;
}
}
return out;
}
};
Matrix eye(){
return Matrix(1, 0, 0, 0, 1, 0, 0, 0, 1);
}
Matrix powMat(Matrix a, ll n, ll mod){
if (n == 0) return eye();
else if (n == 1) return a;
else if (n % 2 == 0){
Matrix tmp = powMat(a, n/2, mod);
return tmp.mul(tmp, mod);
}
else return a.mul(powMat(a, n-1, mod), mod);
}
void printMat(Matrix a){
for (int i = 0; i < 3; ++i){
for (int j = 0; j < 3; ++j){
printf("%ld ", a.at(i, j));
}
printf("\n");
}
}
ll l, a, b, m, c[19], t, ans;
Matrix p, q;
int main(){
cin >> l >> a >> b >> m;
c[0] = 0;
t = 1;
for (int d = 1; d <= 18; ++d){
t *= 10;
if (t > a) c[d] = min(l, (t - 1 - a) / b + 1);
else c[d] = 0;
}
for (int d = 0; d < 18; ++d){
c[d] = c[d+1] - c[d];
}
p = {1, 0, 0, 1, 1, 0, 0, b, 1};
q = eye();
for (int d = 0; d < 18; ++d){
p.at(0, 0) *= 10;
q = q.mul(powMat(p % m, c[d], m), m);
}
ans = (q.at(1, 0)*(a%m)) % m;
ans = (ans + q.at(2, 0)) % m;
printf("%ld", ans);
} |
#include <bits/stdc++.h>
#define int long long
#define inf (int)(3e18)
#define mod (int)(1e9+7)
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int mod_pow(int x,int y,int z){
int res=1;
while(y>0){
if(y&1)res*=x;
x*=x;x%=z;
y>>=1;
res%=z;
}
return res;
}
struct mat{
int m;
vector<vector<int>>ma;
mat(int x,int y,int z){
m=z;
ma.resize(x);
rep(i,x)ma[i].resize(y);
rep(i,x)rep(j,y)ma[i][j]=0;
}
mat operator*(mat a){
assert(ma[0].size()==a.ma.size());
mat res(ma.size(),a.ma[0].size(),m);
rep(i,ma.size()){
rep(j,a.ma[0].size()){
rep(k,a.ma.size()){
res.ma[i][j]+=ma[i][k]*a.ma[k][j]%m;
res.ma[i][j]%=m;
}
}
}
return res;
}
mat pow(int x){
assert(ma.size()==ma[0].size());
mat res(ma.size(),ma.size(),m),me(ma.size(),ma.size(),m);
rep(i,ma.size())res.ma[i][i]=1;
me.ma=ma;
while(x>0){
if(x&1)res=res*me;
me=me*me;
x>>=1;
}
return res;
}
};
int l,a,b,m;
signed main(){
cin>>l>>a>>b>>m;
mat ans(1,3,m),rui(3,3,m);
ans.ma={{0,a%m,1}};
rui=rui.pow(0);
for(int i=1;i<=18;i++){
int ma=mod_pow(10,i,inf)-1,mi=mod_pow(10,i-1,inf)-1;
if(ma<a)continue;
if(mi>=a+b*(l-1))continue;
ma=min(ma,a+b*(l-1));
int ko=(ma-a)/b+1;
if(mi>=a)ko-=(mi-a)/b+1;
mat x(3,3,m);
x.ma[0]={mod_pow(10,i,m),0,0};
x.ma[1]={1,1,0};
x.ma[2]={0,b%m,1};
rui=rui*x.pow(ko);
}
ans=ans*rui;
cout<<ans.ma[0][0]<<endl;
}
|
#include <bits/stdc++.h>
#define fio ios_base::sync_with_stdio(false)
#define pdl cout << "*" << endl
#define MOD 1000000007
#define INF 1000000000
#define INFLL 1000000000000000000ll
#define ff first
#define ss second
#define long int64_t
using namespace std;
typedef pair<int, int> pii;
typedef pair<long, long> pll;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<> dis(0, INF<<1);
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char* name, Arg1&& arg1){ cerr << name << " : " << arg1 << endl; }
template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args)
{ const char* comma = strchr(names + 1, ','); cerr.write(names, comma - names) << " : " << arg1 << " | "; __f(comma+1, args...); }
const int M = 18;
int mod;
struct Mat
{
int m[3][3];
Mat(int v)
{
memset(m, 0, sizeof m);
for(int i=0; i<3; i++)
m[i][i] = v;
}
Mat operator* (const Mat &a) const
{
Mat r(0);
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
for(int k=0; k<3; k++)
r.m[i][j] = (r.m[i][j] + m[i][k] * 1ll * a.m[k][j]) % mod;
return r;
}
};
int modexp(Mat a, long b, int s)
{
Mat r(1);
while(b)
{
if(b & 1)
r = r * a;
a = a * a;
b >>= 1;
}
return (s * 1ll * r.m[0][1] + r.m[0][2]) % mod;
}
int modexp(int a, long b)
{
int r = 1;
while(b)
{
if(b & 1)
r = (r * 1ll * a) % mod;
a = (a * 1ll * a) % mod;
b >>= 1;
}
return r;
}
long t[M+1];
long bs(long n, long a, long b, long lim)
{
long l = -1, r = n;
while(l != r)
{
long mid = l+r+1 >> 1;
if(a + mid * b < lim)
l = mid;
else
r = mid-1;
}
return l;
}
int main()
{
fio;
long l, a, b, t1 = 1;
int ans = 0;
cin >> l >> a >> b >> mod;
t[0] = -1;
for(int i=1; i<=M; i++)
{
t1 *= 10;
t[i] = bs(l-1, a, b, t1);
long A = a + (t[i-1] + 1) * b;
long n = t[i] - t[i-1];
if(n)
{
Mat a(1);
a.m[0][0] = t1 % mod;
a.m[0][1] = 1;
a.m[1][2] = b % mod;
int r = modexp(a, n, A % mod);
int x = modexp(t1 % mod, n);
ans = (ans * 1ll * x + r) % mod;
}
}
cout << ans << endl;
return 0;
} |
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
typedef long long LL;
LL MOD;
struct qq{LL s[3][3];};
qq operator * (qq a,qq b)
{
qq c;
for (LL u=0;u<=2;u++)
for (LL i=0;i<=2;i++)
{
c.s[u][i]=0;
for (LL j=0;j<=2;j++)
c.s[u][i]=(c.s[u][i]+a.s[u][j]*b.s[j][i]%MOD)%MOD;
}
return c;
};
LL L,A,B;
qq Pow (qq x,LL y)
{
if (y==1) return x;
qq lalal=Pow(x,y>>1);
lalal=lalal*lalal;
if (y&1) lalal=lalal*x;
return lalal;
}
int main()
{
scanf("%lld%lld%lld%lld",&L,&A,&B,&MOD);L--;
LL op=10,ans=0;
LL o=0;
for (LL u=1;u<=19;u++)
{
LL l=o,r=L,p=-1;
while (l<=r)
{
LL mid=(l+r)>>1;
if (mid*B+A<op) {p=mid;l=mid+1;}
else r=mid-1;
}
if (p!=-1)
{
qq a;
a.s[0][0]=op%MOD;a.s[0][1]=1;a.s[0][2]=0;
a.s[1][0]=0;a.s[1][1]=1;a.s[1][2]=B%MOD;
a.s[2][0]=0;a.s[2][1]=0;a.s[2][2]=1;
a=Pow(a,p-o+1);
LL t=(o%MOD*B%MOD+A)%MOD;
//printf("%lld %lld %lld\n",op,t,p-o+1);
ans=(ans*a.s[0][0]%MOD+t*a.s[0][1]%MOD+a.s[0][2])%MOD;
o=p+1;
}
if (o>L) break;
op*=10;
}
printf("%lld\n",ans);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int MAX=100003,INF=1<<30;
ll mod;
typedef vector<vector<ll>> mat;
mat mul(mat &A, mat&B){
mat C(A.size(),vector<ll>(B[0].size()));
for(int i=0;i<A.size();i++){
for(int k=0;k<B.size();k++){
for(int j=0;j<B[0].size();j++){
C[i][j]=(C[i][j]+A[i][k]*B[k][j])%mod;
}
}
}
return C;
}
mat pow(mat A,ll n){
mat B(A.size(),vector<ll>(A.size()));
for(int i=0;i<A.size();i++){
B[i][i]=1;
}
while(n>0){
if(n&1) B=mul(B,A);
A=mul(A,A);
n/=2;
}
return B;
}
ll rui(ll a,ll b){
ll ans=1;
while(b>0){
if(b&1) ans=ans*a%mod;
a=a*a%mod;
b/=2;
}
return ans;
}
int main(){
ll L,X,Y;cin>>L>>X>>Y>>mod;
ll sum=0;
mat ans(3,vector<ll>(1,0));
ans[0][0]=0;ans[1][0]=(X-(Y%mod)+mod)%mod;ans[2][0]=1;
for(int d=1;d<=18;d++){
ll a=1,cnt;
for(int j=1;j<=d;j++) a*=10;
if(a-1<X) continue;
if(a/10-1<X&&X<=a-1){
cnt=(a-1-X)/Y+1;
}else{
cnt=(a-1-X)/Y-(a/10-1-X)/Y;
}
if(sum+cnt>L) cnt=L-sum;
mat A(3,vector<ll>(3,0)),B(2,vector<ll>(1,0));
A[0][0]=a%mod;
A[0][1]=A[1][1]=A[2][2]=1;
A[0][2]=A[1][2]=Y%mod;
A=pow(A,cnt);
A=mul(A,ans);
for(int i=0;i<3;i++) ans[i][0]=A[i][0];
sum+=cnt;
if(sum==L) break;
//cout<<ans[0][0]<<endl;
}
cout<<ans[0][0]<<endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)n; i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<pi, pi> pp;
typedef pair<ll, ll> pl;
const double EPS = 1e-9;
const ll MOD = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
ll L, A, B, M;
ll cnt[19];
ll sum[19];
ll p10[19];
#define MAT_S 3
vector<vector<ll>> mul (vector<vector<ll>> x, vector<vector<ll>> y) {
vector<vector<ll>> ret(MAT_S, vector<ll>(MAT_S, 0));
rep(i,MAT_S) rep(j,MAT_S) rep(k,MAT_S) {
ret[i][j] = (ret[i][j] + x[i][k]*y[k][j]) % M;
}
return ret;
}
ll mat_pow (ll x, ll y, ll st) {
vector<vector<ll>> b(MAT_S, vector<ll>(MAT_S, 0));
b[0][0] = p10[x]; b[0][1] = 1; b[0][2] = 0;
b[1][0] = 0; b[1][1] = 1; b[1][2] = B%M;
b[2][0] = 0; b[2][1] = 0; b[2][2] = 1;
vector<vector<ll>> r(MAT_S, vector<ll>(MAT_S, 0));
r[0][0] = 1; r[0][1] = 0; r[0][2] = 0;
r[1][0] = 0; r[1][1] = 1; r[1][2] = 0;
r[2][0] = 0; r[2][1] = 0; r[2][2] = 1;
while (y) {
if (y&1) r = mul(r, b);
b = mul(b,b);
y /= 2;
}
return (r[0][1] * st + r[0][2]) % M;
}
ll mod_pow (ll x, ll y) {
ll ret = 1;
while (y) {
if (y&1) ret = ret * x % M;
x = x * x % M;
y /= 2;
}
return ret;
}
int main() {
cin >> L >> A >> B >> M;
ll t = 1;
p10[0] = 1;
for (int i = 1; i < 19; i++) p10[i] = p10[i-1] * 10 % M;
rep(i,18) {
t *= 10;
cnt[i+1] = (t-1>=A) + max(0LL,(t-1-A))/B - sum[i];
sum[i+1] = sum[i] + cnt[i+1];
if (sum[i+1] > L) {
cnt[i+1] -= sum[i+1]-L;
sum[i+1] = L;
}
}
rep(i,19) { sum[i] %= M; }
ll ans = 0;
for (int i = 1; i <= 18; i++) {
if (cnt[i] == 0) continue;
ll tmp = 1;
for (int j = i+1; j < 19; j++) rep(_,j) tmp = tmp * mod_pow(10,cnt[j]) % M;
tmp = tmp * mat_pow(i, cnt[i], (A+(B%M)*sum[i-1])%M) % M;
ans = (ans + tmp) % M;
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
#define mp make_pair
#define fst first
#define snd second
#define forn(i,n) for (int i = 0; i < int(n); i++)
#define forn1(i,n) for (int i = 1; i <= int(n); i++)
#define popcnt __builtin_popcount
using namespace std;
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,int> pli;
typedef pair<int,ll> pil;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
template <typename T> T id(T b) {return b;};
template <class It> bool all(It f,It l){return std::all_of(f,l,id<bool>);}
template <class It> bool any(It f,It l){return std::any_of(f,l,id<bool>);}
template <typename T> void chmax(T &x, T y) {if (x < y) x = y;}
template <typename T> void chmin(T &x, T y) {if (x > y) x = y;}
ll l,a,b,MOD;
typedef vector<long long> vec;
typedef vector<vec> mat;
mat make_mat(int n, int m) {
return mat(n, vec(m));
}
mat mat_mul(const mat &a, const mat &b) {
mat r = mat(a.size(), vec(b[0].size()));
for (int i = 0; i < (int)a.size(); i++) {
for (int k = 0; k < (int)a[i].size(); k++) {
for (int j = 0; j < (int)b[k].size(); j++)
r[i][j] = (r[i][j] + a[i][k] * b[k][j] % MOD) % MOD;
}
}
return r;
}
mat mat_pow(mat a, long long b) {
mat r = mat(a.size(), vec(a[0].size()));
for (int i = 0; i < (int)a.size(); i++)
r[i][i] = 1;
while (b > 0) {
if (b&1) r = mat_mul(r,a);
a = mat_mul(a,a);
b >>= 1;
}
return r;
}
ll d9(int d) {
ll res = 0;
forn(i,d) res = 10LL*res + 9;
return res;
}
ll c(int d) {
ll mx = d9(d);
ll l = 0, r = (mx-a)/b+2;
while (r - l > 1) {
ll mid = l + (r - l) / 2;
if (a+b*mid <= mx)
l = mid;
else
r = mid;
}
return l+1;
}
int main()
{
#ifdef FASTIO
ios_base::sync_with_stdio(false); cin.tie(nullptr);
#endif
cin >> l >> a >> b >> MOD;
ll prev = 0;
int d = 1;
ll ten = 10;
mat res = mat{{0,a%MOD,1}};
while (l > 0) {
ll cur = c(d);
mat A = mat{{ten,0,0},{1,1,0},{0,b%MOD,1}};
ll k = min(l,cur - prev);
mat B = mat_pow(A, k);
res = mat_mul(res, B);
l -= k;
prev = cur;
d++;
ten = (ten * 10) % MOD;
}
cout << res[0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define sz(c) int(c.size())
#define rep(i,a,b) for (int i=a; i<(b); ++i)
#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)
using namespace std;
using ll = long long;
int M;
inline int madd(int x,int y) {
if (x+y<M) return x+y; else return x+y-M;
}
inline int msub(int x,int y) {
if (x-y>=0) return x-y; else return x-y+M;
}
inline int mmul(int x,int y) {
return int(ll(x)*y % M);
}
template<class T,int N,int P,int M>
void matmul(T res[N][M], const T A[N][P], const T B[P][M]) { // res=A*B
static T tmp[N][M];
rep(i,0,N) rep(j,0,M) tmp[i][j]=0;
rep(i,0,N) rep(j,0,M) rep(k,0,P) {
tmp[i][j]=madd(tmp[i][j], mmul(A[i][k],B[k][j]));
}
rep(i,0,N) rep(j,0,M) res[i][j]=tmp[i][j];
}
template<class T,int N,int M>
void matpow(T res[N][M], const T A[M][M], ll p) { // res=res*A^p
static T tmp[M][M];
rep(i,0,M) rep(j,0,M) tmp[i][j]=A[i][j];
while (p>0) {
if (p%2) matmul<T,N>(res,res,tmp);
matmul<T,M>(tmp,tmp,tmp);
p/=2;
}
}
int len(ll x) {
assert(x>0);
int res=0;
while (x>0) {
x/=10;
res++;
}
return res;
}
ll find_len(ll L,ll A,ll B) {
int z=len(A);
ll l=0,r=L;
while (l<r) {
ll m=l+(r-l)/2;
if (z==len(A+B*m)) l=m+1; else r=m;
}
return l;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout<<fixed<<setprecision(10);
ll L,A,B;
cin>>L>>A>>B>>M;
int sum=0;
while (L>0) {
ll k=find_len(L,A,B);
int p=1;
rep(i,0,len(A)) p=mmul(p,10);
int r[1][3]={{sum,int(A%M),1}};
int X[3][3]={{p,0,0},
{1,1,0},
{0,int(B%M),1}};
matpow<int,1>(r,X,k);
sum=r[0][0];
L-=k;
A+=B*k;
}
cout<<sum<<"\n";
}
|
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(a); (i)<(b); ++(i))
#define rFor(i, a, b) for(int (i)=(a)-1; (i)>=(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef pair<int, int> pii;
typedef vector<vector<lint>> mat;
mat mul(mat &a, mat &b, lint &mod){
int n = a.size();
int m = b[0].size();
mat c = vector<vector<lint>>(n, vector<lint>(m, 0));
rep(i, n)rep(j, m){
lint t = 0;
rep(k, a[0].size()) t = (t + a[i][k] * b[k][j] % mod) % mod;
c[i][j] = t;
}
return c;
}
mat pow(mat a, lint k, lint &mod){
int n = a.size();
mat ret = vector<vector<lint>>(n, vector<lint>(n, 0));
rep(i, n) ret[i][i] = 1;
while(k){
if(k & 1){
ret = mul(ret, a, mod);
k -= 1;
}
else{
a = mul(a, a, mod);
k >>= 1;
}
}
return ret;
}
lint binsearch(lint i, lint a, lint b, lint l){
if(to_string(a).size() > i) return 0;
if(to_string(a+b*(l-1)).size() <= i) return l-1;
lint low = 0;
lint high = l-1;
while(high - low > 1){
lint mid = (high + low) / 2;
if(to_string(a+b*mid).size() > i) high = mid;
else low = mid;
}
return low;
}
int main(){
lint l, a, b, m;
scanf("%lld%lld%lld%lld", &l, &a, &b, &m);
mat v = vector<vector<lint>>(3, vector<lint>(1, 0));
v[0][0] = 0; v[1][0] = a; v[2][0] = b;
mat p = vector<vector<lint>>(3, vector<lint>(3, 0));
p[0][0] = p[0][1] = p[1][1] = p[1][2] = p[2][2] = 1;
lint num[20];
rep(i, 20) num[i] = binsearch(i, a, b, l);
num[0] = -1;
For(i, 1, 20){
p[0][0] = (p[0][0] * 10) % m;
mat q = pow(p, num[i] - num[i-1], m);
v = mul(q, v, m);
}
printf("%lld\n", v[0][0]);
} |
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll L,A,B,M;
mat mult(mat &A,mat &B){
mat C(A.size(),vec(B[0].size()));
for(int i=0;i<A.size();i++){
for(int k=0;k<B.size();k++){
for(int j=0;j<B[0].size();j++){
(C[i][j] += A[i][k]*B[k][j]%M)%=M;
}
}
}
return C;
}
mat pow(mat A, ll n){
if(n==1) return A;
else if(n%2==0){
mat B = pow(A,n/2);
return mult(B,B);
}else{
mat B = pow(A,n-1);
return mult(A,B);
}
}
ll cnt[20] = {};
ll cnt2[20] = {};
ll p[19] = {1};
int main(){
cin >> L >> A >> B >> M;
for(int i=1;i<=18;i++) p[i] = 10*p[i-1];
/*ll now = A;
for(int i=0;i<L;i++){
for(int j=1;j<=18;j++){
if(now<p[j]){
cnt2[j]++;
break;
}
}
now += B;
}
for(int i=1;i<=18;i++) cerr << cnt2[i] << " ";
cerr << endl;
*/for(int i=1;i<=18;i++){
if(p[i]-1<A) continue;
if(A+(L-1)*B<p[i-1]) continue;
cnt[i] = (min(p[i]-1,A+(L-1)*B)-A)/B+1;
if(i>1 && p[i-1]-1>A) cnt[i] -= max((p[i-1]-1-A)/B+1,0LL);
}
ll ans = 0;
mat res(3,vec(3,0));
res[0][0] = res[1][1] = res[2][2] = 1;
/* for(int i=1;i<=18;i++) cerr << cnt[i] << " ";
cerr << endl;
*/ for(int i=1;i<=18;i++){
if(cnt[i]==0) continue;
mat A(3,vec(3,0));
A[0][0] = p[i]%M; A[0][1] = A[1][1] = A[2][2] = 1;
A[1][2] = B;
mat a = pow(A,cnt[i]);
res = mult(a,res);
}
cout << (res[0][2]+A%M*res[0][1]%M)%M << endl;
} |
//ΔABC129F
#include<iostream>
#include<cstdio>
#include<fstream>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<bitset>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long LL;
typedef double DB;
int m;
LL d;
int mul(int x,int y){
return (LL)x*y%m;
}
int fpow(LL x,LL y){
int z=1;
x%=m;
while(y){
if(y&1)
z=mul(z,x);
y>>=1;
x=mul(x,x);
}
return z;
}
pair<int,int> solve(LL w,int o){
if(w==1)
return make_pair(1,0);
int a,b,e=fpow(o,w/2);
pair<int,int> p=solve(w/2,o);
a=p.first,b=p.second;
p.first=mul(a,e+1);
p.second=(mul(b,e+1)+mul(a,(w/2)%m))%m;
if(w&1){
a=p.first,b=p.second;
p.first=(mul(a,o)+1)%m;
p.second=(b+a)%m;
}
return p;
}
int main()
{
LL w,l,r,o,a,b,c,s;
int i;
pair<int,int> p;
cin>>w>>l>>r>>m;
d=r;
r=l+d*(w-1);
s=0;
o=1;
for(i=0;i<18;i=i+1){
a=max(l,o);
a+=(l%d-a%d+d)%d;
b=min(r,o*10-1);
b-=(b%d-r%d+d)%d;
o*=10;
if(a>b)
continue;
c=(b-a)/d+1;
s=mul(s,fpow(o,c));
p=solve(c,o%m);
s+=mul(a%m,p.first);
s+=mul(d%m,p.second);
s%=m;
}
cout<<s;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
typedef uint64_t ull;
typedef int64_t ll;
typedef std::pair<ll, ll> PLL;
ll L, A, B, MOD, ten;
struct mll {
ll x;
mll(ll x=0): x(x%MOD){
}
mll& operator+=(const mll a) {
(x += a.x) %= MOD;
return *this;
}
mll& operator-=(const mll a) {
(x += MOD-a.x) %= MOD;
return *this;
}
mll& operator*=(const mll a) {
(x *= a.x) %= MOD;
return *this;
}
mll operator+(const mll a) const {
mll res(*this);
return res+=a;
}
mll operator-(const mll a) const {
mll res(*this);
return res-=a;
}
mll operator*(const mll a) const {
mll res(*this);
return res*=a;
}
};
// x^y
mll pow_(mll x, ll y) {
if (y==0)
return mll(1);
else if(y%2==1) {
return pow_(x, y-1) * x;
} else {
mll z = pow_(x, y/2);
return z*z;
}
}
mll f(ll l) {
if (l==0)
return 0;
if (l%2==1){
ll pl = l-1;
mll x = f(pl);
return x*mll(ten)*mll(10)+mll(1);
} else {
ll pl = l/2;
mll x = f(pl);
return x*pow_(mll(ten)*mll(10), pl) + x;
}
return 0;
}
mll g(ll l) {
if (l==0)
return 0;
if (l%2==1) {
ll pl = l-1;
mll x = g(pl);
return x*mll(ten)*mll(10) + B*pl;
} else {
ll pl = l/2;
mll x = g(pl);
return x*pow_(mll(ten)*mll(10), pl) + x + mll(B)*mll(pl)*f(pl);
}
}
signed main() {
cin>>L>>A>>B>>MOD;
mll ans(0);
ten = 1;
for (ll k=0; k<18; k++, ten*=10) { // [ 10^k 10^(k+1) ) の区間について
if (A+B*(L-1) < ten) continue;
if (10*ten <= A) continue;
ll a; // 区間内での初項
if (ten <= A) {
a = A;
} else{
a = (ten-A + B-1)/B * B + A;
}
ll last; // 区間内での最後の項
if (A+B*(L-1) < 10*ten) {
last = A+B*(L-1);
} else {
last = (10*ten-1 - A)/B * B + A;
}
ll l = (last-a)/B + 1; // 区間内での項の数
if (last < a) continue;
mll ans_k = mll(a)*f(l) + g(l);
ans *= pow_(mll(10*ten), l);
ans += ans_k;
//printf("k=%d [%2lld %2lld) %2lld -> %2lld (%lld) ans_k=%d\n",
// k, ten, ten*10, a, last, l, ans_k.x);
}
cout<<ans.x<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
long long MOD = 1000000007;
struct matrix
{
vector<vector<ll>> mat;
ll row;
ll col;
void resize( ll row, ll col, ll initial )
{
this->row = row;
this->col = col;
mat.resize( row, vector<ll>( col, initial ) );
}
void identity() // first resize with initial = 0
{
for ( ll i = 0; i < (ll)mat.size(); i++ ) mat[i][i] = 1;
}
matrix operator+( matrix &b ) const
{
matrix temp;
temp.resize( row, col, 0 );
for ( ll i = 0; i < row; i++ )
{
for ( ll j = 0; j < col; j++ )
{
temp.mat[i][j] = ( mat[i][j] % MOD ) + ( b.mat[i][j] % MOD );
temp.mat[i][j] %= MOD;
}
}
return temp;
}
matrix operator*( matrix &b ) const
{
matrix temp;
ll ro, co;
temp.resize( row, b.col, 0 );
for ( ll i = 0; i < row; i++ )
{
for ( ll j = 0; j < b.col; j++ )
{
for ( ll k = 0; k < col; k++ )
{
temp.mat[i][j] +=
( ( mat[i][k] % MOD ) * ( b.mat[k][j] % MOD ) );
temp.mat[i][j] %= MOD;
}
}
}
return temp;
}
matrix power( ll b )
{
matrix a = matrix( *this );
matrix ans;
ans.resize( row, col, 0 );
ans.identity();
while ( b )
{
if ( b & (ll)1 ) { ans = ans * a; }
a = a * a;
b >>= 1;
}
return ans;
}
};
int main()
{
ll l, a, b, m;
cin >> l >> a >> b >> m;
MOD = m;
matrix ans;
ans.resize( 1, 3, 0 );
ans.mat[0][0] = a % MOD;
ans.mat[0][1] = ( a + b ) % MOD;
ans.mat[0][2] = 1;
ll term = 1, d = 10;
while ( term < l )
{
ll lo = max( (ll)0, ( ( d / 10 - 1 ) - a ) / b );
ll hi = min( l - 1, max( ( d - 1 - a ) / b, (ll)0 ) );
ll now = hi - lo;
term += hi - lo;
matrix temp;
temp.resize( 3, 3, 0 );
temp.mat[0][0] = d % MOD;
temp.mat[1][0] = 1;
temp.mat[1][1] = 1;
temp.mat[2][1] = b % MOD;
temp.mat[2][2] = 1;
temp = temp.power( now );
ans = ans * temp;
d *= 10;
}
cout << ans.mat[0][0] << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<vector<ll>> matrix;
matrix mult(matrix a, matrix b, int m) {
matrix c;
for(int i = 0; i < a.size(); i++) {
c.push_back({});
for(int j = 0; j < b[0].size(); j++) {
c[i].push_back(0);
for(int k = 0; k < b.size(); k++) {
c[i][j] += a[i][k] * b[k][j];
c[i][j] %= m;
}
}
}
return c;
}
matrix pow(matrix b, ll e, int m) {
matrix r;
for(int i = 0; i < b.size(); i++) {
r.push_back({});
for(int j = 0; j < b.size(); j++) {
r[i].push_back(i == j);
}
}
while(e) {
if(e%2) {
r = mult(r, b, m);
}
e /= 2;
if(e) {
b = mult(b, b, m);
}
}
return r;
}
void solve(ll start, ll diff, ll numTerms, ll m) {
ll len = 1;
ll currCap = 9;
matrix curr;
curr.push_back({0});
curr.push_back({start%m});
curr.push_back({1});
while(numTerms > 0) {
/*
(x, start, 1) -> (10**len*x + start, start + diff, 1)
*/
len *= 10;
len %= m;
for(int d = 60; d >= 0; d--) {
if((1LL << d) > numTerms) continue;
ll lastTerm = start + (-1 + (1LL << d)) * diff;
if(lastTerm <= currCap) {
numTerms -= 1LL << d;
matrix b = {
{len, 1, 0},
{0, 1, diff%m},
{0, 0, 1}
};
curr = mult(pow(b, 1LL << d, m), curr, m);
start += (1LL << d) * diff;
}
}
currCap = 10 * currCap + 9;
}
cout << curr[0][0] << "\n";
}
void solve() {
ll a, b, n, m;
cin >> n >> a >> b >> m;
solve(a, b, n, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
solve();
/*
int t;
cin >> t;
for(int i = 1; i <= t; i++) {
cout << "Case #" << i << ": ";
solve();
}
*/
}
|
#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define ll __int128
ll P,L,A,B;
struct Mat{
ll a[3][3];
Mat(){memset(a,0,sizeof a);}
ll* operator [] (int x){return a[x];}
const ll* operator [] (int x)const{return a[x];}
Mat operator * (const Mat &rhs) const
{
Mat ret;
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
(ret[i][j]+=a[i][k]*rhs[k][j]%P)%=P;
return ret;
}
};
ll ksm(ll a,ll b)
{
ll ret=1;
for(;b;b>>=1,(a*=a)%=P)
if(b&1)
(ret*=a)%=P;
return ret%P;
}
Mat ksm(Mat a,ll b)
{
Mat ret;
ret[0][0]=ret[1][1]=ret[2][2]=1;
for(;b;b>>=1,a=a*a)
if(b&1)
ret=ret*a;
return ret;
}
ll Calc(__int128 fir,__int128 num,ll len)
{
if(num<=0)
return 0;
Mat trans;
trans[0][0]=ksm(10,len+1);
trans[1][0]=trans[1][1]=1;
trans[2][0]=trans[2][1]=B%P;trans[2][2]=1;
Mat B;
B[0][0]=B[0][1]=fir%P;B[0][2]=1;
return (B*ksm(trans,num-1))[0][0];
}
__int128 get(int b) //10^b
{
__int128 ret=1;
while(b--)
ret*=10;
return ret;
}
__int128 Ceil(__int128 a,__int128 b)
{
return (a+b-1)/b;
}
__int128 Floor(__int128 a,__int128 b)
{
return a/b;
}
int main()
{
long long _L,_A,_B,_P;
cin>>_L>>_A>>_B>>_P;
L=_L;A=_A;B=_B;P=_P;
ll Ans=0;
__int128 lst=A+((__int128)B)*(L-1);
for(int i=0;i<=36;i++)
{
if(get(i)>lst)
continue;
__int128 downlim=get(i),uplim=min(get(i+1)-1,lst);
if(uplim<A)
continue;
if(downlim>lst)
continue;
__int128 First=A+Ceil(downlim-A,B)*B;
if(A>downlim&&A<=uplim)
First=A;
if(First>lst)
continue;
if(downlim>uplim)
continue;
if(uplim<First)
continue;
Ans=(Ans*ksm(10,(__int128)(i+1)*(Floor(uplim-First,B)+1))%P+Calc(First%P,Floor(uplim-First,B)+1,i))%P;
}
printf("%lld\n",(long long)(Ans%P));
}
|
#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define boost ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define check(x) cout << #x << " : " << (x) << endl
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
//#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
typedef vector< ll > edge;
typedef pair< ll , ll > mypair;
typedef priority_queue <ll> max_heap;
typedef priority_queue <ll, vector<ll>, greater<ll> > min_heap;
ll mod=1e9+7;
const ll inf=1e15+10;
const ll N=3e6;
struct matrix
{
vector<vector<ll> > mat;
void resize(ll a,ll b, ll initial)
{
mat.resize(a,vector<ll> (b,initial));
}
void identity()// first resize with initial = 0
{
for(ll i=0;i<(ll)mat.size();i++) mat[i][i]=1;
}
ll get_rows()
{
return mat.size();
}
ll get_cols()
{
return mat[0].size();
}
matrix operator + ( matrix & b) const
{
matrix temp;
ll ro,co;
ro=b.get_rows();
co=b.get_cols();
temp.resize(ro,co,0);
for(ll i=0;i<ro;i++)
{
for(ll j=0;j<co;j++)
{
temp.mat[i][j]=mat[i][j]+b.mat[i][j];
temp.mat[i][j]%=mod;
}
}
return temp;
}
matrix operator * ( matrix & b) const
{
matrix temp;
ll ro,co;
ro=mat.size();
co=b.get_cols();
ll mi=b.get_rows();
temp.resize(ro,co,0);
for(ll i=0;i<ro;i++)
{
for(ll j=0;j<co;j++)
{
for(ll k=0;k<mi;k++)
{
//temp.mat[i][j]+=mat[i][k]*b.mat[k][j];
temp.mat[i][j]+=((mat[i][k]%mod) * (b.mat[k][j]%mod));
temp.mat[i][j]%=mod;
}
}
}
return temp;
}
void print()
{
for(auto &i:mat)
{
for(auto &j:i) cout<<j<<" ";
cout<<endl;
}
}
};
matrix power(matrix a,ll b)
{
matrix ans;
ans.resize(a.get_rows(),a.get_cols(),0);
ans.identity();
while(b)
{
if(b & (ll)1)
{
ans=ans*a;
}
a=a*a;
b>>=1;
}
return ans;
}
int main()
{
boost;
ll l,a,b,m;
cin>>l>>a>>b>>m;
mod=m;
ll lo,hi;
matrix ans;
ans.resize(1,3,0);
ans.mat[0][0]=a%mod;
ans.mat[0][1]=(a+b)%mod;
ans.mat[0][2]=1;
ll term =1,d=10;
while(term<l)
{
lo=max((ll)0,((d/10-1)-a)/b);
hi=min(l-1,max((d-1-a)/b,(ll)0));
term+=hi-lo;
ll now=hi-lo;
matrix temp;
temp.resize(3,3,0);
temp.mat[0][0]=d%mod;
temp.mat[1][0]=1;
temp.mat[1][1]=1;
temp.mat[2][1]=b%mod;
temp.mat[2][2]=1;
temp=power(temp,now);
ans=ans*temp;
d*=10;
//check(term);check(hi);check(lo);
}
cout<<ans.mat[0][0];
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define all(a) (a).begin(),(a).end()
#define ll long long
ll modp(ll a,ll b,ll m){
if(b==0) return 1;
if(b%2) return modp(a,b-1,m)*a%m;
return modp(a,b/2,m)*modp(a,b/2,m)%m;
}
ll npow(ll a,ll b){
if(b==0) return 1;
if(b%2) return npow(a,b-1)*a;
return npow(a,b/2)*npow(a,b/2);
}
int main(){
ll L,A,B,M;
cin>>L>>A>>B>>M;
ll X[18]={};
ll nine=0,sum=0;
ll D[3];
D[0]=0;
D[1]=A%M;
D[2]=1;
ll AA=A;
int size=0;
while(AA){
AA/=10;
size++;
}
rep(i,18){
nine=nine*10+9;
if(i+1>=size){
ll Y=(nine-A)/B+(i+1>=size);
ll tmp=min(L,Y);
X[i]=max(0LL,tmp-sum);
sum=tmp;
}
}
rep(i,18){
ll P[3][3][70]={};
ll Q[3][3]={};
rep(j,3) rep(k,3) P[j][k][0]=(j==k);
rep(j,3) rep(k,3) Q[j][k]=(j==k);
P[0][0][1]=modp(10,i+1,M);
P[1][0][1]=1;
P[1][1][1]=1;
P[2][1][1]=B%M;
P[2][2][1]=1;
rep(j,65){
if(j>1) rep(k,3) rep(l,3){
P[k][l][j]=(P[k][l][j]+P[k][0][j-1]*P[0][l][j-1])%M;
P[k][l][j]=(P[k][l][j]+P[k][1][j-1]*P[1][l][j-1])%M;
P[k][l][j]=(P[k][l][j]+P[k][2][j-1]*P[2][l][j-1])%M;
}
}
rep(j,64){
ll QQ[3][3];
if(X[i]&npow(2,j)){
rep(k,3) rep(l,3) QQ[k][l]=Q[k][l];
rep(k,3) rep(l,3){
Q[k][l]=(QQ[k][0]*P[0][l][j+1])%M;
Q[k][l]=(Q[k][l]+QQ[k][1]*P[1][l][j+1])%M;
Q[k][l]=(Q[k][l]+QQ[k][2]*P[2][l][j+1])%M;
}
}
}
ll DD[3];
rep(j,3) DD[j]=D[j];
rep(j,3){
D[j]=(DD[0]*Q[0][j])%M;
D[j]=(D[j]+DD[1]*Q[1][j])%M;
D[j]=(D[j]+DD[2]*Q[2][j])%M;
}
}
cout<<D[0]<<endl;
} |
#include <iostream>
using namespace std;
typedef long long ll;
int fp(int a, ll x, int m) {
if (x == 0) {
return 1;
}
if (x % 2 == 1) {
return 1ll * a * fp(a, x - 1, m) % m;
}
int t = fp(a, x / 2, m);
return 1ll * t * t % m;
}
int dc1(int a, ll x, int m) {
if (x == 0) {
return 0;
}
if (x % 2 == 1) {
return (dc1(a, x - 1, m) + fp(a, x - 1, m)) % m;
}
int t = dc1(a, x / 2, m);
return (t + 1ll * fp(a, x / 2, m) * t) % m;
}
int dc2(int a, ll x, int m) {
if (x == 0) {
return 0;
}
if (x % 2 == 1) {
return (dc2(a, x - 1, m) + (x - 1) % m * fp(a, x - 1, m)) % m;
}
int t = dc2(a, x / 2, m);
int t2 = (t + x / 2 % m * dc1(a, x / 2, m)) % m;
t2 = 1ll * t2 * fp(a, x / 2, m) % m;
return (t + t2) % m;
}
int main() {
ll l, a, b;
int m;
cin >> l >> a >> b >> m;
ll last = a + (l - 1) * b;
int pow10 = 1;
ll p = (ll)1e9 * (ll)1e9;
int ans = 0;
for (int i = 18; i >= 0; i--) {
if (last >= p) {
ll first = p / b * b + a % b;
if (first < p) {
first += b;
}
if (first < a) {
first = a;
}
int tens = fp(10, i + 1, m);
ll cnt = (last - first) / b + 1;
int cur = last % m * dc1(tens, cnt, m) % m;
cur = ((cur - b % m * dc2(tens, cnt, m)) % m + m) % m;
cur = 1ll * cur * pow10 % m;
ans = (ans + cur) % m;
pow10 = 1ll * pow10 * fp(tens, cnt, m) % m;
last = first - b;
if (last < a) {
break;
}
}
p /= 10;
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
using namespace std;
typedef unsigned long long ll;
ll L,A,B,M;
ll ten;
struct mll {
long long x;
mll(long long x):x(x%M){}
mll& operator+=(const mll a) {
(x+=a.x) %= M;
return *this;
}
mll& operator-=(const mll a) {
(x+=M-a.x) %= M;
return *this;
}
mll& operator*=(const mll a) {
(x*=a.x) %= M;
return *this;
}
mll& operator/=(const mll a) {
(x/=a.x) %= M;
return *this;
}
mll& operator%=(const mll a) {
(x%=a.x) %= M;
return *this;
}
mll operator+(const mll a) {
mll res(*this);
return res+=a;
}
mll operator-(const mll a) {
mll res(*this);
return res-=a;
}
mll operator*(const mll a) {
mll res(*this);
return res*=a;
}
mll operator/(const mll a) {
mll res(*this);
return res/=a;
}
mll operator%(const mll a) {
mll res(*this);
return res%=a;
}
};
mll pow_(ll a, ll b) {
if(b == 0) return mll(1);
if(b%2 == 1) {
return pow_(a,b-1)*mll(a);
} else {
mll c = pow_(a,b/2);
return c*c;
}
}
mll f(ll n) {
if(n==0) return mll(0);
if(n%2) {
return f(n-1) + pow_(ten, n-1);
} else {
return f(n/2)*(pow_(ten, n/2) + mll(1));
}
}
mll g(ll n) {
if(n==0) return mll(0);
if(n%2) {
return g(n-1)*mll(ten) + mll(n-1);
} else {
return g(n/2)*(pow_(ten, n/2)+mll(1)) + f(n/2)*mll(n/2);
}
}
int main() {
cin>>L>>A>>B>>M;
ll last = A+B*(L-1);
mll ans = 0;
ten = 1;
for(int k=1;k<=18;k++) {
ll l = ten, r = ten*10-1;
if(last < l || A > r) {
ten*=10;
continue;
}
ll a,curlast,n;
if(A>=l) a = A;
else {
a = (l-A+B-1)/B*B+A;
}
if(a>r) {
ten*=10;
continue;
}
if(last <= r) curlast = last;
else {
curlast = (r-a)/B*B+a;
}
n = (curlast-a)/B+1;
ten*=10;
ans*=pow_(ten, n);
ans+=mll(a)*f(n) + mll(B)*g(n);
}
cout<<ans.x;
}
|
#include <bits/stdc++.h>
#define dbug(x) cout<<#x<<"="<<x<<endl
using namespace std;
template <typename T> void read(T &t) {
t=0; char ch=getchar(); int f=1;
while ('0'>ch||ch>'9') { if (ch=='-') f=-1; ch=getchar(); }
do {(t*=10)+=ch-'0';ch=getchar();} while ('0'<=ch&&ch<='9'); t*=f;
}
typedef long long ll;
ll a,b,L,mod,mi[100],tmp,lst,k;
ll cnt[20],sum[20];
ll s1[100],s2[100];
ll ans;
int main() {
//freopen("1.txt","r",stdin);
read(L); read(a); read(b); read(mod);
ll l,r,res,mid,x,y,t1,t2; tmp=1; lst=-1;
for (int i=1;i<=18;i++) {
l=lst,r=L-1; tmp*=10; res=lst-1;
while (l<=r) {
mid=(l+r)/2;
if (a+mid*b<tmp) res=mid,l=mid+1;
else r=mid-1;
}
k=res-lst;
if (k<0) continue;
lst=res;
mi[0]=tmp%mod;
s1[0]=1; s2[0]=0;
for (int j=1;j<=62;j++) {
mi[j]=mi[j-1]*mi[j-1]%mod;
s1[j]=(mi[j-1]+1)*s1[j-1]%mod;
s2[j]=(mi[j-1]+1)*s2[j-1]%mod+(1LL<<(j-1))%mod*s1[j-1]%mod*mi[j-1]%mod;
s2[j]%=mod;
}
cnt[i]=1;
x=0,y=0; t1=1,t2=0;
for (int j=62;j>=0;j--)
if (k&(1LL<<j)) {
x+=s1[j]*t1%mod; x%=mod;
y+=(s2[j]+s1[j]*t2%mod)*t1%mod; y%=mod;
t1=t1*mi[j]%mod;
t2=(t2+(1LL<<j))%mod;
cnt[i]=cnt[i]*mi[j]%mod;
}
sum[i]=(a+b*res)%mod*x%mod-b%mod*y%mod;
sum[i]=(sum[i]%mod+mod)%mod;
}
tmp=1;
for (int i=18;i>=1;i--) {
ans+=sum[i]*tmp%mod; ans%=mod;
tmp=tmp*cnt[i]%mod;
}
printf("%lld\n",ans);
return 0;
} |
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
#define vvi std::vector<std::vector<int> >
#define vvl std::vector<std::vector<ll> >
#define MODs 1000000007;
typedef long long int ll;
using namespace std;
vvl dot(vvl a, vvl b, ll M){
vvl c = vv(a.size(), b[0].size(), 0, ll);
for(int i=0;i<a.size();i++){
for(int j=0;j<b[0].size();j++){
for(int k=0;k<b.size();k++){
c[i][j] = (c[i][j] + (a[i][k]*b[k][j])%M)%M;
}
}
}
return c;
}
int main(int argc, char const *argv[]) {
ll L, A, B, M;
cin >> L >> A >> B >> M;
vector<ll> keta(19, 0);
ll now = 1, wa=0;
for(int i=0;i<18;i++){
now *= 10;
if(A >= now) keta[i+1]=0;
else{
keta[i+1] = (now-1 - A)/B + 1;
keta[i+1]-=wa;
}
if(i==17) keta[i+1] = L - wa;
if(wa + keta[i+1] <= L) wa += keta[i+1];
else keta[i+1] = L - wa, wa = L;
}
now = 1;
vvl ans = vv(1, 3, 0, ll);
ans[0][0] = 0, ans[0][1] = A%M, ans[0][2] = 1;
for(ll i=1;i<19;i++) {
now *= 10;
vvl c = vv(3, 3, 0, ll);
c[0][0] = now%M, c[1][0] = 1, c[1][1] = 1, c[2][1] = B%M, c[2][2]=1;
while(keta[i]>0){
if(keta[i]%2==1) ans = dot(ans, c, M);
c = dot(c, c, M);
keta[i]/=2;
}
}
std::cout << ans[0][0] << '\n';
return 0;
}
|
// luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int n=3;
struct mat{
ll a[n][n];
};
ll mod;
mat operator*(mat a,mat b)
{
mat c;
for(int i=0;i<n;i++) for(int j=0;j<n;j++)
{
c.a[i][j]=0;
for(int k=0;k<n;k++) c.a[i][j]=(c.a[i][j]+a.a[i][k]%mod*(b.a[k][j])%mod)%mod;
}
return c;
}
mat qpow(mat x,ll y)
{
mat res;for(int i=0;i<n;i++) for(int j=0;j<n;j++) res.a[i][j]=(i==j);
while(y)
{
if(y&1) res=res*x;
x=x*x;y=y/2;
}
return res;
}
ll A,B,L;ll C;
ll above(ll lim)
{
ll l=0,r=L;ll res=0;
while(l<=r)
{
ll mid=(l+r)/2;
if(mid*B+A>=lim)
r=mid-1,res=mid*B+A;
else l=mid+1;
}
return res;
}
ll qpow(ll x,ll y)
{
x%=mod;
ll res=1;
while(y)
{
if(y&1) res=res*x%mod;
x=x*x%mod;y=y/2;
}
return res;
}
ll length(ll x)
{
ll t=0;
while(x) x/=10,t++;
return t;
}
ll solution()
{
ll l=1,r=10;ll k=10;mat res;
for(int i=0;i<n;i++) for(int j=0;j<n;j++) res.a[i][j]=0;
res.a[0][0]=A%mod,res.a[0][1]=0,res.a[0][2]=1;int flg=10000000;
ll ek=0;
while(1)
{
ll s=above(l),e=above(r)-B;if(!s) break;
while(e+B<=C and length(e+B)==length(l)) e+=B;//cout<<l<<" "<<e<<"\n";
if(e>C) e=C; ll tot=(e-s)/B+1;
if(s<=e)
{
mat o;for(int i=0;i<n;i++) for(int j=0;j<n;j++) o.a[i][j]=0;
o.a[0][0]=o.a[0][1]=o.a[2][2]=1;
o.a[1][1]=k%mod;o.a[2][0]=B%mod;
res=res*qpow(o,tot);ek+=tot;
}
flg--;if(!flg) break;
if(l>4e17) break;
l=l*10;
if(r>2e17 or r*10>C) r=C,flg=1;
else r=r*10;
k=k*10%mod;
}
assert(ek==L+1);
return res.a[0][1];
}
int main()
{
cin>>L>>A>>B>>mod;L--;
C=A+B*L;
cout<<solution();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll L,a,b,mod;
struct Matric
{
ll a[3][3];
Matric(){memset(a,0,sizeof(a));}
Matric operator*(const Matric&o)const
{
Matric ans;
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
ans.a[i][j]=(ans.a[i][j]+a[i][k]*o.a[k][j]%mod)%mod;
return ans;
}
};
Matric Mqpow(Matric a,ll n)
{
Matric ans;
ans.a[0][0]=ans.a[1][1]=ans.a[2][2]=1;
while(n)
{
if(n&1) ans=ans*a;
a=a*a;
n>>=1;
}
return ans;
}
ll qpow(ll a,ll n)
{
ll ans=1;
while(n)
{
if(n&1) ans=ans*a%mod;
a=a*a%mod;
n>>=1;
}
return ans;
}
int getlen(ll x)
{
int ans=0;
while(x)
{
x/=10;
ans++;
}
return ans;
}
ll getpos(int x)
{
ll l=1,r=L,ans=1;
while(l<=r)
{
ll m=l+r>>1;
if(getlen(a+(m-1)*b)<=x) ans=m,l=m+1;
else r=m-1;
}
return ans;
}
/*
si=s(i-1)*qpow(10,i)+qi+B;
gi=g(i-1)+B;
|10i 1 1| |si-1|
|0 1 1| |gi-1|
|0 0 1| |B|
*/
int main()
{
scanf("%lld%lld%lld%lld",&L,&a,&b,&mod);
ll ans=a%mod,res=a%mod,now=1;
for(int i=1;i<=18;i++)
{
ll p=getpos(i);
if(p==now) continue;
Matric A;
A.a[0][0]=qpow(10,i);A.a[0][1]=1;A.a[0][2]=1;
A.a[1][0]=0;A.a[1][1]=1;A.a[1][2]=1;
A.a[2][0]=0;A.a[2][1]=0;A.a[2][2]=1;
A=Mqpow(A,p-now);
ans=(A.a[0][0]*ans%mod+res*A.a[0][1]%mod+b%mod*A.a[0][2]%mod)%mod;
res=(res+b*(p-now))%mod;
now=p;
}
printf("%lld\n",ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
ll l, a, b, mod;
template <class T> struct Matrix {
vector<vector<T>> A;
Matrix(int n, int m) : A(n, vector<T>(m)) {}
Matrix(int n) : A(n, vector<T>(n)) {}
int size() {
return A.size();
}
inline vector<T> &operator[](int i) {
return A[i];
}
};
template <class T> Matrix<T> operator*(Matrix<T> A, Matrix<T> B) {
Matrix<T> R(A.size(), B[0].size());
for (int i = 0; i < A.size(); ++i)
for (int j = 0; j < B[0].size(); ++j)
for (int k = 0; k < B.size(); ++k)
R[i][j] = (R[i][j] + (A[i][k] * B[k][j]) % mod) % mod;
return R;
}
template <class T> Matrix<T> power(Matrix<T> X, ll n) {
Matrix<T> R(X.size());
for (int i = 0; i < X.size(); i++)
R[i][i] = 1;
while (n > 0) {
if (n & 1)
R = R * X;
X = X * X;
n >>= 1;
}
return R;
}
template <class T> void print(Matrix<T> A) {
for (int i = 0; i < A.size(); ++i)
for (int j = 0; j < A[0].size(); ++j)
cout << A[i][j] << ((j != A[0].size() - 1) ? ' ' : '\n');
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> l >> a >> b >> mod;
Matrix<ll> z(1, 3);
z[0][1] = a % mod;
z[0][2] = 1;
vector<ll> c(19);
ll mn = 1, mx = 10;
rep(i, 1, 19) {
c[i] = min(l, (mx - a + b - 1) / b) - max(0ll, (mn - a + b - 1) / b);
mn *= 10ll;
mx *= 10ll;
}
mx = 1;
rep(i, 1, 19) {
mx *= 10ll;
if (c[i] > 0) {
Matrix<ll> p(3);
p[1][0] = p[1][1] = p[2][2] = 1;
p[0][0] = mx % mod;
p[2][1] = b % mod;
z = z * power(p, c[i]);
}
}
cout << z[0][0] << endl;
return 0;
} |
#include<bits/stdc++.h>
#define ll long long
#define pii_ pair<int,int>
#define mp_ make_pair
#define pb push_back
#define fi first
#define se second
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define show1(a) cout<<#a<<" = "<<a<<endl
#define show2(a,b) cout<<#a<<" = "<<a<<"; "<<#b<<" = "<<b<<endl
using namespace std;
const ll INF = 1LL<<60;
const int inf = 1<<30;
const int maxn = 2e5+5;
inline void fastio() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);}
ll qpow(ll a,ll b,ll M) {a%=M;ll s=1;while(b){if(b&1)s=(s*a)%M;a=(a*a)%M;b>>=1;}return s; }
ll qmul(ll a,ll b,ll M) {a%=M;ll s=0;while(b){if(b&1)s=(s+a)%M;a=(a+a)%M;b>>=1;}return s; }
ll M,pt[20];
struct Matrix
{
ll mat[3][3];
Matrix() {memset(mat,0,sizeof(mat));}
Matrix operator * (Matrix b)
{
Matrix res;
rep(i,0,2) rep(j,0,2) rep(k,0,2) res.mat[i][j] = (res.mat[i][j] + mat[i][k]*b.mat[k][j]%M)%M;
return res;
}
Matrix operator ^ (ll b)
{
Matrix res,A=*this;
rep(i,0,2) res.mat[i][i] = 1;
while(b){
if(b&1) res = res * A;
A = A*A;
b>>=1;
}
return res;
}
};
int main()
{
fastio(); ll n,a,b;
cin>>n>>a>>b>>M;
ll ans = 0;
pt[0] = 1;
rep(i,1,18) pt[i] = pt[i-1]*10;
ll L = a,R = a+(n-1)*b;
rep(i,1,18){
if(L < pt[i]){
ll e = (pt[i]-L-1)/b*b+L;
if(e>R) e = R;
ll t = (e-L)/b + 1;
Matrix A;
A.mat[0][0] = pt[i]%M;
A.mat[0][1] = A.mat[1][1] = A.mat[2][2] = 1;
A.mat[1][2] = b%M;
A = A^t;
ans = (ans*A.mat[0][0]%M + L%M*A.mat[0][1]%M + A.mat[0][2]) %M;
if(e==R)break;
L = e + b;
}
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int M;
using mat = vector<vector<ll>>;
// multiplication, A[0].size = B.size が必要
mat mul(mat &A, mat &B) {
mat C(A.size(), vector<ll>(B[0].size(), 0));
for (int i = 0; i < A.size(); ++i) {
for (int k = 0; k < B.size(); ++k) {
for (int j = 0; j < B[0].size(); ++j) {
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % M;
}
}
}
return C;
}
// 正方行列の累乗
mat pow(mat A, ll n){
mat B(A.size(), vector<ll>(A.size(), 0));
for (int i = 0; i < A.size(); ++i) {
B[i][i] = 1;
}
while(n > 0){
if(n & 1) B = mul(B, A);
A = mul(A, A);
n >>= 1;
}
return B;
}
ll modPow(ll x, ll n) {
ll res = 1;
while(n > 0){
if(n & 1) res = res * x % M;
x = x * x % M;
n >>= 1;
}
return res;
}
int main() {
ll L, A, B;
cin >> L >> A >> B >> M;
ll C = A + B * (L-1);
// 桁数ごとに初項と項数を保存
vector<ll>first(19);
vector<ll>num(19, 0);
vector<ll>last(19);
last[0] = A % B - B;
ll pow_ten = 1;
for (int i = 1; i < 19; ++i) {
first[i] = last[i-1] + B;
pow_ten *= 10;
last[i] = ((pow_ten-1-A) / B) * B + A;
first[i] = max(first[i], A);
ll end = min(last[i], C);
if(first[i] <= end) {
num[i] = (end - first[i]) / B + 1;
}
}
ll ans = 0;
for (int i = 1; i < 19; ++i) {
mat X = {{ans, first[i]%M, 1}};
mat P(3, vector<ll>(3));
P[0] = {modPow(10, i), 0, 0};
P[1] = {1, 1, 0};
P[2] = {0, B%M, 1};
auto Pn = pow(P, num[i]);
X = mul(X, Pn);
ans = X[0][0];
}
cout << ans;
return 0;
} |
#include <bits/stdc++.h>
#define sz(c) int(c.size())
#define rep(i,a,b) for (int i=a; i<(b); ++i)
#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)
using namespace std;
using ll = long long;
using matrix = int[3][3];
int M;
inline int madd(int x,int y) {
if (x+y<M) return x+y; else return x+y-M;
}
inline int msub(int x,int y) {
if (x-y>=0) return x-y; else return x-y+M;
}
inline int mmul(int x,int y) {
return int(ll(x)*y % M);
}
void matmul(matrix &res, const matrix &A, const matrix &B,
int n, int p, int m) { // res[n x m] = A[n x p] * B[p x m]
static matrix tmp;
rep(i,0,n) rep(j,0,m) tmp[i][j]=0;
rep(i,0,n) rep(j,0,m) rep(k,0,p) {
tmp[i][j]=madd(tmp[i][j], mmul(A[i][k],B[k][j]));
}
rep(i,0,n) rep(j,0,m) res[i][j]=tmp[i][j];
}
void matpow(ll pow, matrix &res, const matrix &A,
int n, int m) { // res[n x m] = res[n x m] * (A[m x m]^pow)
static matrix tmp;
rep(i,0,m) rep(j,0,m) tmp[i][j]=A[i][j];
while (pow>0) {
if (pow%2) matmul(res,res,tmp,n,m,m);
matmul(tmp,tmp,tmp,m,m,m);
pow/=2;
}
}
int len(ll x) {
assert(x>0);
int res=0;
while (x>0) {
x/=10;
res++;
}
return res;
}
ll find_len(ll L,ll A,ll B) {
int z=len(A);
ll l=0,r=L;
while (l<r) {
ll m=l+(r-l)/2;
if (z==len(A+B*m)) l=m+1; else r=m;
}
return l;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout<<fixed<<setprecision(10);
ll L,A,B;
cin>>L>>A>>B>>M;
int sum=0;
while (L>0) {
ll k=find_len(L,A,B);
int p=1;
rep(i,0,len(A)) p=mmul(p,10);
matrix r={{sum,int(A%M),1}};
matrix X={{p,0,0},
{1,1,0},
{0,int(B%M),1}};
matpow(k,r,X,1,3);
sum=r[0][0];
L-=k;
A+=B*k;
}
cout<<sum<<"\n";
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int mod;
struct mint {
ll x;
mint(ll x=0):x( (x%mod + mod) % mod ) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ( (x += a.x) >= mod ) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ( ( x += mod - a.x) >= mod ) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
( x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t&1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) { return mint(*this) /= a; }
};
istream& operator>>(istream& is, mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
ll b, ten;
mint f(ll l) {
if (l == 0) return 0;
if (l%2 == 1) {
ll pl = l-1;
mint x = f(pl);
return x*ten + 1;
} else {
ll pl = l/2;
mint x = f(pl);
return x*mint(ten).pow(pl) + x;
}
}
mint g(ll l) {
if (l == 0) return 0;
if (l%2 == 1) {
ll pl = l-1;
mint x = g(pl);
return x*ten + mint(b)*pl;
} else {
ll pl = l/2;
mint x = g(pl);
return x*mint(ten).pow(pl) + x + mint(b)*pl*f(pl);
}
}
int main() {
ll L, a;
cin >> L >> a >> b >> mod;
ten = 10;
ll last = a + b * (L - 1);
mint ans = 0;
for (int i = 1; i <= 18; ++i, ten *= 10) {
ll l = ten/10, r = ten - 1;
if (a > r) continue;
if (last < l) continue;
ll na = 0, nl = 0, nlast = 0;
{
if (a >= l) na = a;
else {
na = ( l-a + b-1 )/b * b + a;
}
}
{
if (last <= r) nlast = last;
else {
nlast = (r - a)/b * b + a;
}
nl = (nlast - na)/b + 1;
}
ans *= mint(ten).pow(nl);
ans += f(nl)*na;
ans += g(nl);
}
cout << ans << endl;
return 0;
} |
#include<bits/stdc++.h>
#define ll long long
#define fornum(A,B,C) for(A=B;A<C;A++)
#define mp make_pair
#define pii pair<int,int>
#define pll pair<ll,ll>
using namespace std;
/////////////////////////////////////////////////////
ll L,A,B,M;
ll i,j,k;
ll dmul[3][3];
ll mul[3][3];
ll ans[3][3];
void calc(ll a){
if(a==0)
return;
ll i, j,k,l;
if(a&1){
fornum(i,0,3){
fornum(j,0,3){
dmul[i][j] = ans[i][j];
}
}
fornum(i,0,3){
fornum(j,0,3){
ans[i][j]=0;
fornum(k,0,3){
ans[i][j] = (ans[i][j] + dmul[i][k] * mul[k][j])%M;
}
}
}
}
fornum(i,0,3){
fornum(j,0,3){
dmul[i][j] = mul[i][j];
}
}
fornum(i,0,3){
fornum(j,0,3){
mul[i][j]=0;
fornum(k,0,3){
mul[i][j] = (mul[i][j] + dmul[i][k] * dmul[k][j])%M;
}
}
}
calc(a / 2);
}
int main(){
scanf("%lld%lld%lld%lld", &L, &A, &B, &M);
//A %= M;
//B %= M;
ans[0][0] = 1;
ans[1][1] = 1;
ans[2][2] = 1;
ll a = 0;
ll b = 10;
fornum(i,0,18){
ll l = 0;
ll r = L;
while(l<r){
ll c = (r + l) / 2;
ll C = A + B * c;
if(C<b){
l = c + 1;
}else{
r = c;
}
}
//printf("%lld,%lld\n", a, r);
fornum(j,0,3){
fornum(k,0,3){
mul[j][k] = 0;
}
}
mul[0][0] = b%M;
mul[1][0] = 1;
mul[1][1] = 1;
mul[2][1] = B%M;
mul[2][2] = 1;
calc(r - a);
a = r;
b *= 10;
}
/*
fornum(i,0,3){
fornum(j,0,3){
printf("%lld ", ans[i][j]);
}
printf("\n");
}*/
printf("%lld", (A%M * ans[1][0] + ans[2][0]) % M);
return 0;
} |
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll L,A,B,M;
mat mult(mat &A,mat &B){
mat C(A.size(),vec(B[0].size()));
for(int i=0;i<A.size();i++){
for(int k=0;k<B.size();k++){
for(int j=0;j<B[0].size();j++){
(C[i][j] += A[i][k]*B[k][j]%M)%=M;
}
}
}
return C;
}
mat pow(mat A, ll n){
if(n==1) return A;
else if(n%2==0){
mat B = pow(A,n/2);
return mult(B,B);
}else{
mat B = pow(A,n-1);
return mult(A,B);
}
}
ll cnt[20] = {};
ll cnt2[20] = {};
ll p[19] = {1};
int main(){
cin >> L >> A >> B >> M;
for(int i=1;i<=18;i++) p[i] = 10*p[i-1];
for(int i=1;i<=18;i++){
if(p[i]-1<A) continue;
if(A+(L-1)*B<p[i-1]) continue;
cnt[i] = (min(p[i]-1,A+(L-1)*B)-A)/B+1;
if(i>1 && p[i-1]-1>A) cnt[i] -= max((p[i-1]-1-A)/B+1,0LL);
}
ll ans = 0;
mat res(3,vec(3,0));
res[0][0] = res[1][1] = res[2][2] = 1;
for(int i=1;i<=18;i++){
if(cnt[i]==0) continue;
mat A(3,vec(3,0));
A[0][0] = p[i]%M; A[0][1] = A[1][1] = A[2][2] = 1;
A[1][2] = B;
mat a = pow(A,cnt[i]);
res = mult(a,res);
}
cout << (res[0][2]+A%M*res[0][1]%M)%M << endl;
} |
#include<bits/stdc++.h>
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugArray(x,n) for(long long hoge = 0; (hoge) < (n); ++ (hoge)) cerr << #x << "[" << hoge << "]: " << x[hoge] << '\n'
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vll;
const ll INF = INT_MAX;
const ll MOD = 1e9+7;
ll mod=1e9+7;
struct Matrix {
vector<vector<long long> > val;
Matrix(int n, int m, long long x = 0) : val(n, vector<long long>(m, x)) {}
void init(int n, int m, long long x = 0) {val.assign(n, vector<long long>(m, x));}
size_t size() const {return val.size();}
inline vector<long long>& operator [] (int i) {return val[i];}
};
// O( n )
Matrix identity(int n) {
Matrix A(n, n);
for (int i = 0; i < n; ++i) A[i][i] = 1;
return A;
}
// O( n^3 )
Matrix mul(Matrix A, Matrix B) {
Matrix C(A.size(), B[0].size());
for (int i = 0; i < (ll)C.size(); ++i)
for (int j = 0; j < (ll)C[i].size(); ++j)
for (int k = 0; k < (ll)A[i].size(); ++k)
C[i][j] = (C[i][j] + A[i][k] * B[k][j]%mod)%mod;
return C;
}
// O( n^3 log e )
Matrix pow(Matrix A, ll e) {
return e == 0 ? identity(A.size()) :
e % 2 == 0 ? pow(mul(A, A), e/2) : mul(A, pow(A, e-1));
}
ostream &operator<<(ostream &os, Matrix &v) {
os << "[";
for (int i = 0; i < (ll)v.size(); i++){
if (i > 0) os << endl << " ";
os << "[";
for (int j = 0; j < (ll)v[i].size(); os << v[i][j++])
if (j > 0) os << " ";
os << "]";
}
os << "]";
return os;
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll L,A,B,M;cin>>L>>A>>B>>M;
mod=M;
ll X=0,s=A%mod;
ll p10=1;
for(ll d=1;d<=18&&L>0;d++){
//debug(d);
ll C=0;
if(p10*10>A)C += (p10*10-1-A)/B+1;
if(p10>A)C -= (p10-1-A)/B+1;
//debug(C);
Matrix Mat(3,3);
Mat[0][0]=p10*10%mod;
Mat[0][1]=1;
Mat[1][1]=1;
Mat[1][2]=B%mod;
Mat[2][2]=1;
Matrix D=pow(Mat,min(L,C));
//cerr<<D<<endl;
ll tmp=X*D[0][0]%mod+s*D[0][1]%mod+D[0][2];
s=(X*D[1][0]%mod+s*D[1][1]%mod+D[1][2])%mod;
X=tmp%mod;
L-=C;
//debug(X);
//debug(s);
p10*=10;
}
cout<<X<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m;
int mul(long long a, long long b){
return a * b % m;
}
int pw(long long a, long long b){
a %= m;
long long r = 1;
for(; b; b >>= 1, a = mul(a, a)) if(b&1) r = mul(r, a);
return r;
}
using mat = vector<vector<long long> >;
mat create(int n){
return vector<vector<long long> > (n, vector<long long>(n, 0));
}
mat iden(int n){
mat r = create(n);
for(int i = 0; i < n; i++) r[i][i] = 1;
return r;
}
mat mul(mat a, mat b){
int n = a.size();
mat r = create(n);
for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) for(int k = 0; k < n; k++){
r[i][j] += mul(a[i][k], b[k][j]);
if(r[i][j] >= m) r[i][j] -= m;
}
return r;
}
int len(long long x){
int sz = 0;
while(x) sz++, x /= 10;
return sz;
}
int main(){
long long l, a, b; cin >> l >> a >> b >> m;
long long mv = 0, sum = 0;
while(l > 0){
long long lo = 1, hi = l - 1, ans = 0;
int need = len(a);
while(lo <= hi){
long long mid = (lo + hi)>>1;
if(len(a + b * mid) == need) ans = mid, lo = mid + 1;
else hi = mid - 1;
}
mat now = create(3), res = iden(3);
now[0][0] = pw(10, need);
now[1][0] = 1;
now[1][1] = 1;
now[2][1] = b % m;
now[2][2] = 1;
long long sz = ans + 1, ind = ans + 1;
for(; sz; sz >>= 1, now = mul(now, now)) if(sz&1) res = mul(res, now);
sum = mul(sum, res[0][0]) + mul(a % m, res[1][0]) + res[2][0];
sum %= m;
a += ind * b;
l -= ind;
}
cout << sum << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <map>
#include <queue>
#include <iomanip>
#include <set>
#define mkp make_pair
typedef long long ll;
using namespace std;
ll L,A,B,M;
ll MOD=1000000007;
typedef vector<ll> vec;//ll?
typedef vector<vec> mat;
mat mul(mat &A,mat &B){
mat C(A.size(),vec(B[0].size()));
for(int i=0;i<A.size();i++){
for(int k=0;k<B.size();k++){
for(int j=0;j<B[0].size();j++){
C[i][j]=(C[i][j]+A[i][k]*B[k][j]%MOD)%MOD;
}
}
}
return C;
}
mat pow(mat A,ll n){
mat B(A.size(),vec(A.size()));
for(int i=0;i<A.size();i++){
B[i][i]=1;
}
while(n>0){
if(n&1) B=mul(B,A);
A=mul(A,A);
n=(n>>1);
}
return B;
}
int digit(ll val){
if(val==0) return 0;
else return (1+digit(val/10));
}
int main(){
cin>>L>>A>>B>>M;
MOD=M;
ll ans=0;
ll ten[20]={};
ten[0]=1;
for(int i=1;i<=18;i++) ten[i]=ten[i-1]*10%MOD;
ll start=0;
while(start<L){
ll ng=L;
ll ok=start;
ll nowdigit=digit(A+B*start);
while(ng-ok>1){
ll mid=(ng+ok)/2;
if(digit(A+B*mid)==nowdigit) ok=mid;
else ng=mid;
}
mat C(3,vec(3));
C[0][0]=ten[nowdigit];
C[0][1]=1;
C[0][2]=0;
C[1][0]=0;
C[1][1]=1;
C[1][2]=B%MOD;
C[2][0]=0;
C[2][1]=0;
C[2][2]=1;
C=pow(C,(ok-start+1));
mat D(3,vec(1));
D[0][0]=ans;
D[1][0]=(A+B*start)%MOD;
D[2][0]=1;
D=mul(C,D);
ans=D[0][0];
ans=(ans+MOD)%MOD;
start=ok+1;
}
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
using namespace std;
typedef long long ll;
int main()
{
ll l, a, b, m;
cin >> l >> a >> b >> m;
a -= b;
ll d[19];
d[0] = 0;
ll f[19];
ll t = 0;
for(int i = 1; i <= 18; i++){
t = (t + 1) * 10 - 1;
d[i] = max(0ll, min(l, (t - a) / b));
f[i] = (a + b * d[i]) % m;
}
for(int i = 18; i > 0; i--) d[i] = d[i] - d[i - 1];
ll p[19];
p[0] = 1;
for(int i = 1; i <= 18; i++) p[i] = p[i - 1] * 10 % m;
ll ans = 0;
t = 1;
for(int i = 18; i > 0; i--){
ll s = f[i];
ll u = p[i];
ll v = b % m;
while(d[i]){
if(d[i] % 2){
ans = (ans + s * t % m) % m;
t = t * u % m;
s = (s + m - v % m) % m;
}
s = (s + (s + m - v % m) % m * u % m) % m;
v = v * (u + 1) % m * 2 % m;
u = u * u % m;
d[i] /= 2;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define loop(n, i) for(int i=0;i<n;i++)
#define loop1(n, i) for(int i=1;i<=n;i++)
#define rloop(n, i) for(int i=n;i;i++)
#define HERE cout << "HERE: " << __LINE__ << endl;
#define INSP(v) cout << v << " at " << __LINE__ << endl;
using namespace std;
using ll = long long;
template <class T>
using V = vector<T>;
using M = V<V<ll>>;
const int MSIZE = 3;
ll m;
void printmat(M a) {
loop (MSIZE, i) {
loop (MSIZE, j) {
cout << a[i][j] << " ";
}
cout << endl;
}
}
M matmul(M a, M b) {
M ret = V<V<ll>>(MSIZE, V<ll>(MSIZE));
loop (MSIZE, i) loop (MSIZE, j) {
loop (MSIZE, s) {
ret[i][j] += a[i][s] * b[s][j] % m;
ret[i][j] %= m;
}
}
return ret;
}
int main() {
ll l, a, b; cin >> l >> a >> b >> m;
ll crr = a;
ll x = 0, s = a % m;
loop1 (18, d) {
ll last = 1;
loop (d, i) last *= 10;
last--;
last = min(last, a + b * (l - 1));
if (last < crr) continue;
ll c = (last - crr) / b + 1;
crr += b * c;
ll shift = 1;
loop (d, i) shift = (shift * 10) % m;
M base = {
{ shift, 0, 0 },
{ 1, 1, 0 },
{ 0, b % m, 1 }
};
M mat = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
while (c) {
if (c % 2) mat = matmul(mat, base);
base = matmul(base, base);
c /= 2;
}
ll nx = (x * mat[0][0] + s * mat[1][0] + mat[2][0]) % m;
ll ns = (x * mat[0][1] + s * mat[1][1] + mat[2][1]) % m;
x = nx, s = ns;
}
cout << x << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF 1<<30
#define endl '\n'
#define maxn 100005
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
typedef long long ll;
const double PI = acos(-1.0);
#define dbg(x) cerr << #x << " = " << x << endl;
#define dbg2(x, y) cerr << #x << " = " << x << ", " << #y << " = " << y << endl;
#define dbg3(x, y, z) cerr << #x << " = " << x << ", " << #y << " = " << y << ", " << #z << " = " << z << endl;
//const ll mod = 1e9 + 7;
const ll M = 18;
ll mod;
struct Mat
{
ll m[3][3];
Mat(ll v)
{
memset(m, 0, sizeof m);
for(ll i = 0; i < 3; i++)
m[i][i] = v;
}
Mat operator* (const Mat &a) const
{
Mat r(0);
for(ll i = 0; i < 3; i++)
{
for(ll j = 0; j < 3; j++)
{
for(ll k = 0; k < 3; k++)
{
r.m[i][j] = (r.m[i][j] + m[i][k] * 1ll * a.m[k][j]) % mod;
}
}
}
return r;
}
};
ll modexp(Mat a, ll b, ll s)
{
Mat r(1);
while(b)
{
if(b & 1) r = r * a;
a = a * a;
b >>= 1;
}
return (s * 1ll * r.m[0][1] + r.m[0][2]) % mod;
}
ll modexp(ll a, ll b)
{
ll r = 1;
while(b)
{
if(b & 1) r = (r * 1ll * a) % mod;
a = (a * 1ll * a) % mod;
b >>= 1;
}
return r;
}
ll t[M+1];
ll BS(ll n, ll a, ll b, ll lmt)
{
ll l = -1, r = n;
while(l != r)
{
ll mid = (l + r + 1) >> 1;
if(a + mid * b < lmt) l = mid;
else r = mid - 1;
}
return l;
}
int main()
{
FASTIO
/*
//double start_time = clock();
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
//*/
ll l, a, b, t1 = 1;
ll ans = 0;
cin >> l >> a >> b >> mod;
t[0] = -1;
for(ll i = 1; i <= M; i++)
{
t1 *= 10;
t[i] = BS(l - 1, a, b, t1);
ll A = a + (t[i - 1] + 1) * b;
ll n = t[i] - t[i - 1];
if(n)
{
Mat a(1);
a.m[0][0] = t1 % mod;
a.m[0][1] = 1;
a.m[1][2] = b % mod;
ll r = modexp(a, n, A % mod);
ll x = modexp(t1 % mod, n);
ans = (ans * 1ll * x + r) % mod;
}
}
cout << ans << endl;
//double end_time = clock();
//prllf( "Time = %lf ms\n", ( (end_time - start_time) / CLOCKS_PER_SEC)*1000);
return 0;
}
|
#include<bits/stdc++.h>
#define lowbit(a) ((a)&(-(a)))
using namespace std;
void file(bool opt)
{
if (opt&&fopen("in.txt", "r"))
{
freopen("in.txt", "r", stdin);
//freopen("out.txt", "w", stdout);
}
}
long long L, A, B;
long long mod;
long long ans = 0;
long long powt[19];
struct mat {
int val[3][3];
mat() { memset(val, 0, sizeof val); }
void init(int i)
{
memset(val, 0, sizeof val);
val[0][0] = powt[i] % mod, val[1][0] = val[1][1] = val[2][1] = val[2][2] = 1;
}
}a,res;
mat operator*(mat a, mat b)
{
mat c;
for (int i = 0; i<3; i++)
for (int j = 0; j<3; j++)
for (int k = 0; k<3; k++)
c.val[i][j] = (c.val[i][j] + 1ll * a.val[i][k] * b.val[k][j]) % mod;
return c;
}
void poww(long long L,long long R,int d)
{
long long n = (R - L) / B + 1;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
res.val[i][j] = (i == j);
a.init(d);
while (n)
{
if (n & 1)res = res * a;
n >>= 1;
a = a*a;
}
ans = (1ll * ans*res.val[0][0]%mod + L % mod*res.val[1][0] % mod + B % mod*res.val[2][0]) % mod;
}
int main()
{
cin >> L >> A >> B >> mod;
powt[0] = 1;
for (int i = 1; i <= 18; i++)
powt[i] = powt[i - 1] * 10ll;
long long ed = A + B * (L - 1);
for (int d = 1; d <= 18; d++)
{
if (A < powt[d])
{
long long R = (powt[d] - 1 - A) / B * B + A;
R = min(R, ed);
poww(A, R, d);
if (R == ed)break;
A = R + B;
}
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
long c[22];
int main() {
long L, a, b, M;
cin >> L >> a >> b >> M;
for (long i = 0, j = 1; i < 18; i++, j *= 10) {
long l = -1, r = L;
while (l + 1 < r) {
long m = (l + r) / 2;
if (a + b * m < j) l = m;
else r = m;
}
if (a + b * r < j * 10)
c[i] = r;
else if (i) c[i] = c[i - 1];
}
c[18] = L;
long t = 1, S = 0, T = a;
for (int e = 0; e < 18; e++) {
(t *= 10) %= M;
long A[4][3][3] = {};
for (int i = 0; i < 3; i++)
A[2][i][i] = 1;
A[0][0][1] = A[0][1][1] = A[0][2][2] = 1;
A[0][1][2] = b;
A[0][0][0] = t;
int x = 0, y = 2;
auto f = [&](int &z) {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
A[z ^ 1][i][j] = 0;
for (int k = 0; k < 3; k++)
(A[z ^ 1][i][j] += A[x][i][k] * A[z][k][j]) %= M;
}
}
z ^= 1;
};
for (long k = c[e + 1] - c[e];;) {
if (k & 1) f(y);
k >>= 1;
if (!k) break;
f(x);
}
S = (S*A[y][0][0] + T * A[y][0][1] + A[y][0][2]) % M;
(T += A[y][1][2]) %= M;
}
cout << S << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long l, a, b, m;
long long mat[66][3][3] = {0},now[3][3] = {0};
long long solve();
void setmat();
void calc(long long x);
int main(){
cin >> l >> a >> b >> m;
cout << solve() << endl;
return 0;
}
long long solve(){
long long ten = 1,bf = 0,nowc = 0;
// {{10^d, 0, 0}
// {1, 1, 0}
// {0, B, 1}}
mat[0][1][0] = mat[0][1][1] = mat[0][2][2] = 1;
mat[0][2][1] = b % m;
for(int i = 0;i < 3;++i)now[i][i] = 1;
for(long long i = 0;i < 18;++i){
ten *= 10;
mat[0][0][0] = ten % m;
setmat();
nowc = max((ten - a - 1) / b + 1, 0LL);
nowc = min(l,nowc);
swap(bf,nowc);
nowc = bf - nowc;
for(long long i = 60;i >= 0;--i)
if(nowc >= (1LL << i)){
nowc -= 1LL << i;
calc(i);
}
if(bf == l)break;
}
long long ans = 0;
ans = (a % m * now[1][0] % m + now[2][0]) % m;
return ans;
}
void setmat(){
for(int i = 1;i < 62;++i)
for(int j = 0;j < 3;++j)
for(int k = 0;k < 3;++k) {
mat[i][j][k] = 0;
for (int n = 0; n < 3; ++n)
(mat[i][j][k] += mat[i-1][j][n] * mat[i-1][n][k] % m) %= m;
}
}
void calc(long long x){
long long tmp[3][3] = {0};
for(int i = 0;i < 3;++i)
for(int k = 0;k < 3;++k)
for(int j = 0;j < 3;++j)
(tmp[i][j] += now[i][k] * mat[x][k][j] % m) %= m;
for(int i = 0;i < 3;++i)
for(int j = 0;j < 3;++j)
now[i][j] = tmp[i][j];
} |
//
// Created by yamunaku on 2019/11/05.
//
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define repl(i, l, r) for(int i = (l); i < (r); i++)
#define per(i, n) for(int i = ((n)-1); i >= 0; i--)
#define perl(i, l, r) for(int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(),(x).end()
#define MOD9 998244353
#define MOD1 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP <<" "<<
#define CYES cout<<"Yes"<<endl
#define CNO cout<<"No"<<endl
#define CFS cin.tie(0);ios::sync_with_stdio(false)
#define CST(x) cout<<fixed<<setprecision(x)
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vector<int>> mti;
typedef vector<ll> vl;
typedef vector<vector<ll>> mtl;
ll b, m;
ll modpow(ll x, ll a){
ll ans = 1;
while(a > 0){
if(a % 2) ans = ans * x % m;
a /= 2;
x = x * x % m;
}
return ans;
}
void matprod(mtl &ret, mtl &x, mtl &y){
int n = x.size();
mtl ans = mtl(n, vl(n, 0));
rep(i, n){
rep(j, n){
rep(k, n){
ans[i][j] = (ans[i][j] + x[i][k] * y[k][j] % m) % m;
}
}
}
ret = ans;
}
void matpow(mtl &ret, mtl &x, ll a){
int n = x.size();
mtl ans = mtl(n, vl(n, 0));
rep(i, n) ans[i][i] = 1;
while(a > 0){
if(a % 2) matprod(ans, ans, x);
a /= 2;
matprod(x, x, x);
}
ret = ans;
}
ll solve(ll n, ll c, ll t){
mtl x = {
{1, 0, 0},
{b, 1, 0},
{0, 1, t}
};
matpow(x, x, n);
return (x[2][0] + x[2][1] * c % m) % m;
}
int main(){
ll s, a;
cin >> s >> a >> b >> m;
ll ans = 0;
ll now = 0;
for(ll t = 10, k = 1; now < s && k <= 18; t *= 10, k++){
if(b * now + a < t){
ll w = max(0ll, min((t - 1 - (b * now + a)) / b + 1, s - now));
rep(i,k){
ans = ans * modpow(10, w) % m;
}
ans = (ans + solve(w, (b * now + a) % m, t % m)) % m;
now += w;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define sqr(a) ((a) * (a))
#define sz(a) int(a.size())
#define all(a) a.begin(), a.end()
#define forn(i, n) for(int i = 0; i < int(n); i++)
#define fore(i, l, r) for(int i = int(l); i < int(r); i++)
typedef long long li;
typedef long double ld;
typedef pair<int, int> pt;
template <class A, class B> ostream& operator << (ostream& out, const pair<A, B> &a) {
return out << "(" << a.x << ", " << a.y << ")";
}
template <class A> ostream& operator << (ostream& out, const vector<A> &v) {
out << "[";
forn(i, sz(v)) {
if(i) out << ", ";
out << v[i];
}
return out << "]";
}
mt19937 rnd(time(NULL));
const int INF = int(1e9);
const li INF64 = li(1e18);
const ld EPS = 1e-9;
const ld PI = acos(-1.0);
int MOD;
li l, a, b;
bool read () {
if (scanf("%lld%lld%lld%d", &l, &a, &b, &MOD) != 4)
return false;
return true;
}
int add(int a, int b){
a += b;
if (a >= MOD) a -= MOD;
return a;
}
int sub(int a, int b){
a -= b;
if (a < 0) a += MOD;
return a;
}
int mul(int a, int b){
return a * li(b) % MOD;
}
struct mat{
int a[3][3];
mat(){
memset(a, 0, sizeof(a));
};
int* operator [](int x){
return a[x];
}
};
int cnt0;
mat mul(mat a, mat b){
mat c;
forn(i, 3) forn(j, 3) forn(k, 3)
c[i][j] = add(c[i][j], mul(a[i][k], b[k][j]));
return c;
}
mat binpow(mat a, li b){
mat res;
forn(i, 3) res[i][i] = 1;
while (b){
if (b & 1)
res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
void solve(){
int res = 0;
for (li cur = 10; cur <= INF64; cur *= 10){
if (cur <= a) continue;
li len = (cur - a + b - 1) / b;
len = min(len, l);
mat tmp;
tmp[0][0] = cur % MOD;
tmp[1][0] = 1;
tmp[1][1] = 1;
tmp[2][1] = b % MOD;
tmp[2][2] = 1;
tmp = binpow(tmp, len);
mat orig;
orig[0][0] = res;
orig[0][1] = a % MOD;
orig[0][2] = 1;
orig = mul(orig, tmp);
res = orig[0][0];
a += len * b;
l -= len;
if (l == 0)
break;
}
printf("%d\n", res);
}
int main() {
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int tt = clock();
#endif
cerr.precision(15);
cout.precision(15);
cerr << fixed;
cout << fixed;
#ifdef _DEBUG
while(read()) {
#else
if(read()) {
#endif
solve();
#ifdef _DEBUG
cerr << "TIME = " << clock() - tt << endl;
tt = clock();
#endif
}
} |
#include <bits/stdc++.h>
#include <cmath>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define sz(x) ll(x.size())
typedef long long ll;
typedef pair<int, int> P;
//typedef pair<ll, ll> P;
//const double INF = 1e10;
const ll INF = 1001001001;
#define mins(x, y) x = min(x, y)
#define maxs(x, y) x = max(x, y)
int mod;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
(x += a.x) %= mod;
return *this;
}
mint &operator-=(const mint a) {
(x += mod - a.x) %= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
};
ll b, ten;
mint pow_(mint x, ll t) {
if (t == 0) return 1;
if (t % 2 == 1) {
return pow_(x, t - 1) * x;
} else {
mint y = pow_(x, t / 2);
return y * y;
}
}
mint f(ll l) {
if (l == 0) return 0;
if (l % 2 == 1) {
ll pl = l - 1;
mint x = f(pl);
return x * ten + 1;
} else {
ll pl = l / 2;
mint x = f(pl);
return x * pow_(ten, pl) + x;
}
}
mint g(ll l) {
if (l == 0) return 0;
if (l % 2 == 1) {
ll pl = l - 1;
mint x = g(pl);
return x * ten + mint(b) * pl;
} else {
ll pl = l / 2;
mint x = g(pl);
return x * pow_(ten, pl) + x + mint(b) * pl * f(pl);
}
}
int main() {
ll L, a;
cin >> L >> a >> b >> mod;
ll last = a + b * (L - 1);
mint ans = 0;
ten = 10;
for (int i = 1; i <= 18; i++, ten *= 10) {
ll l = ten / 10, r = ten - 1;
if (last < l) continue;
if (a > r) continue;
ll na = 0;
ll nl = 0;
{
if (a >= l) na = a;
else {
na = ((l - a) + (b - 1)) / b * b + a;
na = min(na, last);
}
}
{
ll nlast = 0;
if (last <= r) nlast = last;
else {
nlast = (r - a) / b * b + a;
}
nl = (nlast - na) / b + 1;
}
ans *= pow_(ten, nl);
ans += f(nl) * na;
ans += g(nl);
}
cout << ans.x << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
Int powmod(Int x, unsigned long long y, Int M)
{
if (y == 0) return 1;
if (y % 2 == 0) return powmod(x*x%M, y/2, M);
return x*powmod(x*x%M, y/2, M)%M;
}
using Matrix = array<Int, 9>;
Matrix mul(Matrix A, Matrix B, Int M) {
Matrix ans = {};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
(ans[i*3+j] += A[i*3+k] * B[k*3+j]) %= M;
}
}
}
return ans;
}
Matrix powmat(Matrix A, Int x, Int M) {
if (x == 0) return { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
if (x % 2 == 0) return powmat(mul(A, A, M), x/2, M);
return mul(A, powmat(mul(A, A, M), x/2, M), M);
}
Int f(Int A, Int B, Int R, Int N, Int M)
{
Matrix mat = { R, 1, 0, 0, 1, B, 0, 0, 1 };
Matrix X = { 0, 0, 0, A, 0, 0, 1, 0, 0 };
Int t = mul(powmat(mat, N, M), X, M)[0];
return t;
}
int main()
{
Int L, A, B, M; cin >> L >> A >> B >> M;
array<Int, 19> counts = {};
Int idx = 0;
for (int i = 1; i < counts.size(); i++) {
Int k = (Int)pow(10, i) - 1 - A;
if (k < idx*B) continue;
k /= B;
k = min(L-1, k);
counts[i] = k - idx + 1;
idx += counts[i];
}
Int ans = 0;
for (int i = 1; i < counts.size(); i++) {
unsigned long long s = 0, t = 0;
for (int j = 1; j < i; j++) s += counts[j];
for (int j = i+1; j < counts.size(); j++) t += j * counts[j];
ans = (ans + f((A%M+B%M*(s%M))%M, B%M, powmod(10, i, M), counts[i], M) * powmod(10, t, M)) % M;
}
cout << ans << '\n';
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int mod;
long long int l[20];
long long int cnt[20];
long long int shift[20];
long long int mp(long long int a,long long int b){
a%=mod;
long long int res=1;
while(b){
if(b&1)
res=res*a%mod;
a=a*a%mod;
b>>=1;
}
return res;
}
long long int f(long long int n,long long int k){
if(n==0) return 1;
long long int res=f((n-1)/2,k);
res=(res+res*mp(mp(10,(n+1)/2),k))%mod;
if(n%2==0)
res=(res+mp(mp(10,n),k))%mod;
return res;
}
long long int g(long long int n,long long int k){
if(n==0) return 0;
long long int res=g((n-1)/2,k);
res=(res+res*mp(mp(10,(n+1)/2),k))%mod;
res=(res+(n+1)/2%mod*mp(mp(10,(n+1)/2),k)%mod*f((n-1)/2,k))%mod;
if(n%2==0)
res=(res+n%mod*mp(mp(10,n),k)%mod)%mod;
return res;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int L,A,B;
cin>>L>>A>>B>>mod;
for(int i=0;i<=18;i++){
long long int x=1;
for(int j=0;j<i;j++)
x*=10;
long long int lo=0,hi=L;
while(lo<hi){
long long int mid = (lo+hi)/2;
if(A+B*mid>=x)
hi=mid;
else
lo=mid+1;
}
l[i]=lo;
}
for(int i=1;i<=18;i++)
cnt[i]=l[i]-l[i-1];
shift[18]=1;
for(int i=17;i>=1;i--)
shift[i]=mp(mp(10,cnt[i+1]),i+1)%mod;
long long int ans=0;
long long int d = -1;
for(int i=1;i<=18;i++){
d+=cnt[i];
long long int n = cnt[i];
if(cnt[i]==0){
ans=ans*shift[i]%mod;
continue;
}
ans=(ans+(A%mod+B%mod*d%mod)%mod*f(n-1,i))%mod;
long long int tmp=B%mod;
tmp=tmp*g(n-1,i)%mod;
ans=(ans-tmp+mod)%mod;
ans=ans*shift[i]%mod;
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using PP = pair<long, long>;
const int INF = 1e9;
long n, a, b, m;
long pre[20];
vector<PP> decomp() {
long l = a;
long rem = n;
vector<PP> ret;
for (long base = 1; ; base *= 10) {
long num = (base - l + b - 1) / b;
if (num < 0) num = 0;
if (rem <= num) {
ret.push_back(PP(l, rem));
return ret;
}
ret.push_back(PP(l, num));
l += num * b;
rem -= num;
}
}
long modpow(long b, long e) {
if (e == 0) return 1;
if (e % 2 == 1) return b * modpow(b, e - 1) % m;
long t = modpow(b, e / 2);
return t * t % m;
}
long cat(long d, long n) {
if (n == 0) return 0;
if (n % 2 == 1) {
long res = modpow(pre[d], (n - 1)) % m;
return (res + cat(d, n - 1)) % m;
}
long res = cat(d, n / 2);
long t = (res + res * modpow(pre[d], (n / 2)) % m) % m;
return t;
}
long sub(long a, long b, long d, long n) {
if (n == 0) return 0;
if (n % 2 == 1) {
long res = a % m * cat(d, n) % m;
return (res + sub(b, b, d, n - 1)) % m;
}
long res = sub(a, b, d, n / 2);
long t = (res + res * modpow(pre[d], n / 2) % m) % m;
long c = b % m * (n / 2) % m * cat(d, n / 2) % m;
return (t + c) % m;
}
int main() {
cin >> n >> a >> b >> m;
vector<PP> res = decomp();
long base = 1;
for (int i = 0; i < 20; ++i) {
pre[i] = base;
base = base * 10 % m;
}
long sum = 0;
long mul = 1;
for (int i = (int)res.size() - 1; i >= 0; --i) {
if (res[i].second == 0) continue;
long ans = sub(res[i].first, b, i, res[i].second);
sum = (sum + ans * mul % m) % m;
mul = mul * modpow(pre[i], res[i].second) % m;
}
cout << sum << endl;
} |
#include "bits/stdc++.h"
using namespace std;
//int N,M,K,L,R,H,W;
long long int N,M,K,L,R,H,W;
//const long long int MOD=1000000007;
const long long int MOD=998244353;
vector<vector<long long int>>matrix_product(vector<vector<long long int>>v, vector<vector<long long int>>w) {
vector<vector<long long int>>ret(v.size(), vector<long long int>(w.front().size()));
for (int i = 0; i < ret.size(); i++) {
for (int j = 0; j < ret[i].size(); j++) {
for (int k = 0; k < w.size(); k++) {
ret[i][j] += v[i][k] * w[k][j];
ret[i][j]%=M;
}
}
}
return ret;
}
int main(){
cin>>N>>L>>R>>M;
vector<long long int>ten(19,1);
for(int i=1;i<19;i++)ten[i]=ten[i-1]*10;
vector<vector<long long int>>ans(1,vector<long long int>({0,L%M,R%M}));
while(N){
//cout<<N<<" "<<L<<endl;
long long int box=L;
int cnt=0;
while(box){
cnt++;
box/=10;
}
long long int nx=L+(N-1)*R;
box=nx;
int ccnt=0;
while(box){
ccnt++;
box/=10;
}
long long int num=N;
if(ccnt!=cnt){
long long int dif=ten[cnt]-1;
dif-=L;
dif/=R;
nx=L+dif*R;
dif++;
num=dif;
}
//cout<<nx<<" "<<num<<endl;
vector<vector<long long int>>by(3,vector<long long int>(3));
by[0][0]=ten[cnt]%M;
by[1][0]=1;
by[1][1]=1;
by[2][1]=1;
by[2][2]=1;
vector<vector<long long int>>ret(3,vector<long long int>(3));
ret[0][0]=1;
ret[1][1]=1;
ret[2][2]=1;
for(int i=0;i<60;i++){
if((num>>i)&1){
ret=matrix_product(ret,by);
}
by=matrix_product(by,by);
}
for(int i=0;i<3;i++){
//for(int j=0;j<3;j++){
// cout<<ret[i][j]<<" ";
//}
//cout<<endl;
}
ans=matrix_product(ans,ret);
N-=num;
L=nx+R;
}
cout<<ans[0][0]<<endl;
return 0;
} |
#include<iostream>
using namespace std;
long L,A,B,M;
long power(long a,long b){return b?power(a*a%M,b/2)*(b%2?a:1)%M:1;}
long ten[99];
long n;
long sum(long k)
{
long ret=0,p=1;
for(int i=61;i--;)
{
if(k>>i&1)
{
(ret+=ten[i]*p)%=M;
p=p*power(power(10,n),1LL<<i)%M;
}
}
return ret;
}
long iten[99];
long isum(long k)
{
long ret=0,p=1,g=0;
for(int i=61;i--;)
{
if(k>>i&1)
{
(ret+=(iten[i]+ten[i]*g)%M*p)%=M;
p=p*power(power(10,n),1LL<<i)%M;
g=(g+(1LL<<i))%M;
}
}
return ret;
}
long cnt[18],SUM[18];
int main()
{
cin>>L>>A>>B>>M;
long pre=0,tmpten=1;
long ans=0;
for(n=0;n<18;n++)
{
long l=pre,r=L;
tmpten*=10;
while(r-l>1)
{
long m=(l+r)/2;
if(A+B*m<tmpten)l=m;
else r=m;
}
long k=l-pre;
if(k<0||l>=L||A+B*l>=tmpten)
{
cnt[n]=1;
continue;
}
pre=l+1;
n++;
ten[0]=1;
for(int i=1;i<61;i++)ten[i]=(power(power(10,n),(1LL<<i-1))+1)%M*ten[i-1]%M;
iten[0]=0;
for(int i=1;i<61;i++)
{
iten[i]=((power(power(10,n),(1LL<<i-1))+1)%M*iten[i-1]+(1LL<<i-1)%M*ten[i-1]%M*power(power(10,n),(1LL<<i-1)))%M;
}
cnt[n-1]=power(power(10,n),k+1);
SUM[n-1]=(((A+B*l)%M*sum(k+1)%M-B%M*isum(k+1))%M+M)%M;
n--;
}
long p=1;
for(int i=18;i--;)
{
ans=(ans+SUM[i]*p)%M;
p=p*cnt[i]%M;
}
cout<<ans<<endl;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.