ARC020 C A mod B Problem

##問題
https://atcoder.jp/contests/arc020/tasks/arc020_3
##見た感じ
求めるべきものは

```math
S=\sum_{i=1}^n a_i \left(\sum_{j=0}^{l_i} 10^{\lceil \log_{10}a_i \rceil*j} \right)10^{\sum_{l=i+1}^{n}\lceil \log_{10}a_i \rceil}~~~~mod~~b
```
であり、

```math
\sum_{j=0}^{l_i} 10^{\lceil \log_{10}a_i \rceil*j} = \frac{10^{\lceil \log_{10}a_i \rceil*l_i}-1}{10^{\lceil \log_{10}a_i \rceil}-1}
```
なので、$b$と$10^{\lceil \log_{10}a_i \rceil}-1$が常に互いに素の時は、剰余の逆数をフェルマーの小定理とか、拡張ユークリッドの互除法を使って求めれば、計算できるから、99点はとれそう。
今回の計算のネックは$\sum_{j=0}^{l_i} 10^{\lceil \log_{10}a_i \rceil*j}$やから、ここを逆数を使わずに高速に求められたらいける。
ここで、$s_n = \sum_{j=0}^{n} 10^{\lceil \log_{10}a_i \rceil*j}$とすると、$s_n = 10^{\lceil \log_{10}a_i \rceil}s_{n-1}+1$なので、

```math
\left( \begin{array}{cc} s_n\\ 1\\ \end{array} \right) = \left(\begin{array}{cc} 10^{\lceil \log_{10}a_i \rceil} & 1 \\ 0 & 1 \\ \end{array} \right) \left( \begin{array}{cc} s_{n-1}\\ 1\\ \end{array} \right)\\
s_0 = 1\\
\left( \begin{array}{cc} s_n\\ 1\\ \end{array} \right) = \left(\begin{array}{cc} 10^{\lceil \log_{10}a_i \rceil} & 1 \\ 0 & 1 \\ \end{array} \right)^{n-1} \left( \begin{array}{cc} s_0 =1 \\ 1\\ \end{array} \right)
```
となり、これは繰り返し二乗法を使えば、O(\log n)で求まる。
##解法
上のようにすれば計算できる。
でも今回は99点のやつしかかいてない。。。
##ソースコード
```c++
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
struct mint{
    ll x; // typedef long long ll;
    mint(ll x = 0) : x((x % mod + mod) % mod) {}
    mint &operator= (const mint &a) { x=a.x; return *this; }
    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;
    }

    // for prime mod
    mint inv() const { return pow(mod - 2); }
    mint &operator/=(const mint a) { return *this *= a.inv(); }
    mint operator/(const mint a) const { return mint(*this) /= a; }
    mint& operator++(int) { return *this += mint(1); }
    mint& operator--(int) { return *this -= mint(1); }
    bool operator!=(const int a) { return this->x!=a; }
    bool operator==(const int a) { return this->x==a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
// combination mod prime
// https://www.youtube.com/watch?v=8uowVvQ_-Mo&feature=youtu.be&t=1619
struct combination{
    vector<mint> fact, ifact;
    combination(int n) : fact(n + 1), ifact(n + 1)
    {
        assert(n < mod);
        fact[0] = 1;
        for (int i = 1; i <= n; ++i)
            fact[i] = fact[i - 1] * i;
        ifact[n] = fact[n].inv();
        for (int i = n; i >= 1; --i)
            ifact[i - 1] = ifact[i] * i;
    }
    mint operator()(int n, int k)
    {
        if (k < 0 || k > n)
            return 0;
        return fact[n] * ifact[k] * ifact[n - k];
    }
    mint parm(int n,int k){
        if (k < 0 || k > n)
            return 0;
        return fact[n] * ifact[n-k];
    }
};
template<class T>
bool maxin (T &a,T b){if(a<b){a=b;return 1;}return 0;}
template<class T>
bool minin (T &a,T b){if(a>b){a=b;return 1;}return 0;}
template<class M,class N> 
common_type_t<M,N> mygcd(M a,N b){
    a=abs(a);b=abs(b);
    if(a < b) return mygcd(b, a);
    M r;
    while ((r=a%b)) {
        a = b;
        b = r;
    }
    return b;
}
template<class M,class N>
common_type_t<M,N> mylcm(M a,N b){
    return (a/mygcd(a,b))*b;
}
template<class M,class N>
pair<common_type_t<M,N>,common_type_t<M,N>> euclid(M a,N b){
    using P=pair<common_type_t<M,N>,common_type_t<M,N>>;
    if(a==0)return {0,1};
    else if(b==0)return {1,0};
    else{
        if(a>=b){
            A x=a/b;
            a=a%b;
            P res=euclid(a,b);
            return {res.first,res.second-x*res.first};
        }else{
            A x=b/a;
            b=b%a;
            P res=euclid(a,b);
            return {res.first-x*res.second,res.second};
        }
    }
}
template<class M,class N>
common_type_t<M,N> myInv(M a,N m=mod){
    pair<common_type_t<M,N>,common_type_t<M,N>> res=euclid(a,m);
    return res.first%m;
}
const int N_MAX=100005;
int n,b;
vll a,l,mem;
vector<mint> sum;

void Main(){
    int x=0,y=INF10,z=1;
    //入力
    cin>>n;
    rep(i,n)cin>>x>>y,a.pb(x),l.pb(y);
    cin>>b;
    mod=b;
    //処理
    mint ans=0;
    rep(i,n){
        int cou=1;
        ll m=10;
        for(cou;m<=a[i];cou++,m*=10);
        mem.pb(cou);
    }
    sum.resize(n,mint(1));
    vrep(i,n-1){
        sum[i]=sum[i+1]*mint(10).pow(mem[i+1]*l[i+1]);
    }
    mint in=mint(10);
    rep(i,n){
        in=10;
        in=in.pow(mem[i]);in-=1;
        mint rec=a[i];
        rec*=mint(10).pow(mem[i]*l[i])-1;
        rec*=myInv(in.x,mod);
        rec*=sum[i];
        ans+=rec;
    }
    //出力
    cout << ans <<endl;
}

int main(){
    cin.tie(nullptr);
    cout<<fixed<<setprecision(12);
    Main();
}
```