QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#428060#8769. Champernowne Substringucup-team987#WA 215ms3820kbC++2018.5kb2024-06-01 17:13:492024-06-01 17:13:50

Judging History

你现在查看的是最新测评结果

  • [2024-06-01 17:13:50]
  • 评测
  • 测评结果：WA
  • 用时：215ms
  • 内存：3820kb
查看
  • [2024-06-01 17:13:49]
  • 提交

answer

#include<iostream>
#include<vector>
#include<cassert>

#include <cassert>
#include <numeric>
#include <type_traits>

#ifdef _MSC_VER
#include <intrin.h>
#endif


#include <utility>

#ifdef _MSC_VER
#include <intrin.h>
#endif

namespace atcoder {

namespace internal {

constexpr long long safe_mod(long long x, long long m) {
    x %= m;
    if (x < 0) x += m;
    return x;
}

struct barrett {
    unsigned int _m;
    unsigned long long im;

    explicit barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}

    unsigned int umod() const { return _m; }

    unsigned int mul(unsigned int a, unsigned int b) const {

        unsigned long long z = a;
        z *= b;
#ifdef _MSC_VER
        unsigned long long x;
        _umul128(z, im, &x);
#else
        unsigned long long x =
            (unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
        unsigned int v = (unsigned int)(z - x * _m);
        if (_m <= v) v += _m;
        return v;
    }
};

constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
    if (m == 1) return 0;
    unsigned int _m = (unsigned int)(m);
    unsigned long long r = 1;
    unsigned long long y = safe_mod(x, m);
    while (n) {
        if (n & 1) r = (r * y) % _m;
        y = (y * y) % _m;
        n >>= 1;
    }
    return r;
}

constexpr bool is_prime_constexpr(int n) {
    if (n <= 1) return false;
    if (n == 2 || n == 7 || n == 61) return true;
    if (n % 2 == 0) return false;
    long long d = n - 1;
    while (d % 2 == 0) d /= 2;
    constexpr long long bases[3] = {2, 7, 61};
    for (long long a : bases) {
        long long t = d;
        long long y = pow_mod_constexpr(a, t, n);
        while (t != n - 1 && y != 1 && y != n - 1) {
            y = y * y % n;
            t <<= 1;
        }
        if (y != n - 1 && t % 2 == 0) {
            return false;
        }
    }
    return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);

constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
    a = safe_mod(a, b);
    if (a == 0) return {b, 0};

    long long s = b, t = a;
    long long m0 = 0, m1 = 1;

    while (t) {
        long long u = s / t;
        s -= t * u;
        m0 -= m1 * u;  // |m1 * u| <= |m1| * s <= b


        auto tmp = s;
        s = t;
        t = tmp;
        tmp = m0;
        m0 = m1;
        m1 = tmp;
    }
    if (m0 < 0) m0 += b / s;
    return {s, m0};
}

constexpr int primitive_root_constexpr(int m) {
    if (m == 2) return 1;
    if (m == 167772161) return 3;
    if (m == 469762049) return 3;
    if (m == 754974721) return 11;
    if (m == 998244353) return 3;
    int divs[20] = {};
    divs[0] = 2;
    int cnt = 1;
    int x = (m - 1) / 2;
    while (x % 2 == 0) x /= 2;
    for (int i = 3; (long long)(i)*i <= x; i += 2) {
        if (x % i == 0) {
            divs[cnt++] = i;
            while (x % i == 0) {
                x /= i;
            }
        }
    }
    if (x > 1) {
        divs[cnt++] = x;
    }
    for (int g = 2;; g++) {
        bool ok = true;
        for (int i = 0; i < cnt; i++) {
            if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
                ok = false;
                break;
            }
        }
        if (ok) return g;
    }
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);

unsigned long long floor_sum_unsigned(unsigned long long n,
                                      unsigned long long m,
                                      unsigned long long a,
                                      unsigned long long b) {
    unsigned long long ans = 0;
    while (true) {
        if (a >= m) {
            ans += n * (n - 1) / 2 * (a / m);
            a %= m;
        }
        if (b >= m) {
            ans += n * (b / m);
            b %= m;
        }

        unsigned long long y_max = a * n + b;
        if (y_max < m) break;
        n = (unsigned long long)(y_max / m);
        b = (unsigned long long)(y_max % m);
        std::swap(m, a);
    }
    return ans;
}

}  // namespace internal

}  // namespace atcoder


#include <cassert>
#include <numeric>
#include <type_traits>

namespace atcoder {

namespace internal {

#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value ||
                                  std::is_same<T, __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int128 =
    typename std::conditional<std::is_same<T, __uint128_t>::value ||
                                  std::is_same<T, unsigned __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using make_unsigned_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value,
                              __uint128_t,
                              unsigned __int128>;

template <class T>
using is_integral = typename std::conditional<std::is_integral<T>::value ||
                                                  is_signed_int128<T>::value ||
                                                  is_unsigned_int128<T>::value,
                                              std::true_type,
                                              std::false_type>::type;

template <class T>
using is_signed_int = typename std::conditional<(is_integral<T>::value &&
                                                 std::is_signed<T>::value) ||
                                                    is_signed_int128<T>::value,
                                                std::true_type,
                                                std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<(is_integral<T>::value &&
                               std::is_unsigned<T>::value) ||
                                  is_unsigned_int128<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<
    is_signed_int128<T>::value,
    make_unsigned_int128<T>,
    typename std::conditional<std::is_signed<T>::value,
                              std::make_unsigned<T>,
                              std::common_type<T>>::type>::type;

#else

template <class T> using is_integral = typename std::is_integral<T>;

template <class T>
using is_signed_int =
    typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<is_integral<T>::value &&
                                  std::is_unsigned<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<is_signed_int<T>::value,
                                              std::make_unsigned<T>,
                                              std::common_type<T>>::type;

#endif

template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;

template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;

template <class T> using to_unsigned_t = typename to_unsigned<T>::type;

}  // namespace internal

}  // namespace atcoder


namespace atcoder {

namespace internal {

struct modint_base {};
struct static_modint_base : modint_base {};

template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;

}  // namespace internal

template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
struct static_modint : internal::static_modint_base {
    using mint = static_modint;

  public:
    static constexpr int mod() { return m; }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    static_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    static_modint(T v) {
        long long x = (long long)(v % (long long)(umod()));
        if (x < 0) x += umod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    static_modint(T v) {
        _v = (unsigned int)(v % umod());
    }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v -= rhs._v;
        if (_v >= umod()) _v += umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        unsigned long long z = _v;
        z *= rhs._v;
        _v = (unsigned int)(z % umod());
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        if (prime) {
            assert(_v);
            return pow(umod() - 2);
        } else {
            auto eg = internal::inv_gcd(_v, m);
            assert(eg.first == 1);
            return eg.second;
        }
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }

  private:
    unsigned int _v;
    static constexpr unsigned int umod() { return m; }
    static constexpr bool prime = internal::is_prime<m>;
};

template <int id> struct dynamic_modint : internal::modint_base {
    using mint = dynamic_modint;

  public:
    static int mod() { return (int)(bt.umod()); }
    static void set_mod(int m) {
        assert(1 <= m);
        bt = internal::barrett(m);
    }
    static mint raw(int v) {
        mint x;
        x._v = v;
        return x;
    }

    dynamic_modint() : _v(0) {}
    template <class T, internal::is_signed_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        long long x = (long long)(v % (long long)(mod()));
        if (x < 0) x += mod();
        _v = (unsigned int)(x);
    }
    template <class T, internal::is_unsigned_int_t<T>* = nullptr>
    dynamic_modint(T v) {
        _v = (unsigned int)(v % mod());
    }

    unsigned int val() const { return _v; }

    mint& operator++() {
        _v++;
        if (_v == umod()) _v = 0;
        return *this;
    }
    mint& operator--() {
        if (_v == 0) _v = umod();
        _v--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        _v += rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        _v += mod() - rhs._v;
        if (_v >= umod()) _v -= umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        _v = bt.mul(_v, rhs._v);
        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        auto eg = internal::inv_gcd(_v, mod());
        assert(eg.first == 1);
        return eg.second;
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs._v == rhs._v;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs._v != rhs._v;
    }

  private:
    unsigned int _v;
    static internal::barrett bt;
    static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt(998244353);

using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;

namespace internal {

template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;

template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;

template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};

template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;

}  // namespace internal

}  // namespace atcoder

using namespace std;
using mint=atcoder::modint998244353;
string ansN;int anspos;
void upd(string ans,int pos)
{
	if(ansN.size()!=ans.size())
	{
		if(ansN.size()>ans.size())ansN=ans,anspos=pos;
		return;
	}
	if(ansN>ans)ansN=ans,anspos=pos;
	else if(ansN==ans&&anspos>pos)anspos=pos;
}
string S;
mint solve()
{
	{//init
		ansN="1"+S;anspos=1;
		for(char&c:ansN)if(c=='?')c='0';
	}
	{//d<=2
		vector<string>C;
		for(int e=1;e<=9;e++)
		{
			C.push_back(string(1,'0'+e));
		}
		for(int e=1;e<=9;e++)for(int f=0;f<=9;f++)
		{
			string t;
			t+=e+'0';
			t+=f+'0';
			C.push_back(t);
		}
		for(int i=0;i<C.size();i++)
		{
			for(int j=0;j<C[i].size();j++)
			{
				bool ok=true;
				int pi=i,pj=j;
				for(int k=0;k<S.size();k++)
				{
					if(pi==C.size())
					{
						ok=false;
						break;
					}
					else if(S[k]!='?'&&C[pi][pj]!=S[k])
					{
						ok=false;
						break;
					}
					pj++;
					if(C[pi].size()==pj)pi++,pj=0;
				}
				if(ok)upd(C[i],j);
			}
		}
	}
	for(int d=3;d<=S.size()+1;d++)
	{
		{//d-1 -> d
			vector<string>C;
			for(int e=0;e<=9;e++)
			{
				C.push_back(string(d-2,'9'));
				C.back()+=e+'0';
			}
			for(int e=0;e<=9;e++)
			{
				C.push_back("1"+string(d-2,'0'));
				C.back()+=e+'0';
			}
			for(int i=0;i<C.size();i++)
			{
				for(int j=0;j<C[i].size();j++)
				{
					bool ok=true;
					int pi=i,pj=j;
					for(int k=0;k<S.size();k++)
					{
						if(pi==C.size())
						{
							ok=false;
							break;
						}
						else if(S[k]!='?'&&C[pi][pj]!=S[k])
						{
							ok=false;
							break;
						}
						pj++;
						if(C[pi].size()==pj)pi++,pj=0;
					}
					if(ok)upd(C[i],j);
				}
			}
		}
		{//keta agari nasi
			for(int i=0;i<10;i++)
			{
				for(int j=0;j<d;j++)
				{
					string tmp(d-1,'?');
					bool ok=true;
					int pi=i,pj=j;
					for(int k=0;k<S.size();k++)
					{
						if(pi==10)
						{
							ok=false;
							break;
						}
						else if(pj==d-1)
						{
							if(S[k]!='?'&&S[k]!=pi+'0')
							{
								ok=false;
								break;
							}
						}
						else if(S[k]!='?')
						{
							if(tmp[pj]!='?'&&tmp[pj]!=S[k])
							{
								ok=false;
								break;
							}
							tmp[pj]=S[k];
						}
						pj++;
						if(d==pj)pi++,pj=0;
					}
					if(ok&&tmp[0]!='0')
					{
						for(int k=0;k<tmp.size();k++)if(tmp[k]=='?')tmp[k]=k==0?'1':'0';
						tmp+='0'+i;
						upd(tmp,j);
					}
				}
			}
		}
		for(int kk=1;kk<=d-1;kk++)
		{//keta agari at kk
			for(int e=kk==d-1?1:0;e<=8;e++)
			{
				for(int i=0;i<10;i++)
				{
					for(int j=0;j<d;j++)
					{
						string tmp(d-kk-1,'?');
						bool ok=true;
						int pi=i,pj=j;
						for(int k=0;k<S.size();k++)
						{
							if(pj==d-1)
							{
								if(S[k]!='?'&&S[k]!=pi%10+'0')
								{
									ok=false;
									break;
								}
							}
							else if(pj>=d-kk)
							{
								if(S[k]!='?'&&S[k]!=(pi<10?'9':'0'))
								{
									ok=false;
									break;
								}
							}
							else if(pj==d-kk-1)
							{
								if(S[k]!='?'&&S[k]!=(pi<10?e:e+1)+'0')
								{
									ok=false;
									break;
								}
							}
							else if(S[k]!='?')
							{
								if(tmp[pj]!='?'&&tmp[pj]!=S[k])
								{
									ok=false;
									break;
								}
								tmp[pj]=S[k];
							}
							pj++;
							if(d==pj)pi++,pj=0;
						}
						if(ok&&(tmp.empty()||tmp[0]!='0'))
						{
							for(int k=0;k<tmp.size();k++)if(tmp[k]=='?')tmp[k]=k==0?'1':'0';
							tmp+=e+'0';
							tmp+=string(kk-1,'9');
							tmp+=i+'0';
							upd(tmp,j);
						}
					}
				}
			}
		}
	}
	mint ans=0;
	for(int d=1;d<ansN.size();d++)ans+=(mint(10).pow(d)-mint(10).pow(d-1))*d;
	for(int i=0;i<ansN.size();i++)
	{
		int c=ansN[i]-'0';
		if(i==0)c--;
		assert(c>=0);
		ans+=c*mint(10).pow(ansN.size()-i-1)*ansN.size();
	}
	ans+=anspos;
	return ans;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	int T;cin>>T;
	for(;T--;)
	{
		cin>>S;
		mint ans=solve();
		ans++;
		cout<<ans.val()<<endl;
	}
}
Source code, Language: C++20

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 27ms
memory: 3592kb

input:

9
0
???1
121
1?1?1
??5?54?50?5?505?65?5
000000000000
?2222222
?3????????9??8???????1??0
9?9??0????????????2

output:

11
7
14
10
314159
796889014
7777
8058869
38886

result:

ok 9 lines

Test #2:

score: 0
Accepted
time: 120ms
memory: 3616kb

input:

10
0000000000000000000000000
0000000?002100000000000?0
6999?999?999999989?999999
0???0?1000?0??000?????0?1
9??9?999998?9?999999100?0
96?9997999?8999991????010
99?99??999999999??????99?
?0?0000?00000000?0210?0?0
99?999?999?99?9??999?9?9?
9?????9?99?99??9??99??9??

output:

545305036
574985081
788888865
5889591
902934046
488873
902034054
830780534
68888820
5882870

result:

ok 10 lines

Test #3:

score: 0
Accepted
time: 84ms
memory: 3536kb

input:

10
23573?0208935200503593500
08?9?1188980?661?18161467
22000103111010?24490??02?
4?129184?3644311331226625
9014217281609919609168?18
27809?1808?34646796569990
5116137658333853138917519
8778798398090800698?93888
742?9472125?9529272277272
5260238541343?22235629222

output:

108802929
797951281
758593545
919282423
660254768
34219412
452740345
687192108
692870314
277899385

result:

ok 10 lines

Test #4:

score: 0
Accepted
time: 129ms
memory: 3532kb

input:

10
98898918898?0109088100808
???08?9???1??????88??????
8?1???????0118????00???8?
??1880????1?8???111101108
???????11??1????0???000??
?9?01???0????9????8???9??
???1?1?????1????90?0????0
??8?????????18?9?????????
8????91?8???????????????9
??0????1?????9??8?909???0

output:

397005130
796170672
681417627
201652995
493829373
76730467
798698896
6434
43334
443792

result:

ok 10 lines

Test #5:

score: 0
Accepted
time: 86ms
memory: 3592kb

input:

10
012003??1?0?591??0?30?30?
1000?0?1100000?731?101211
?0?11?80101111?1??1328???
411410110174?154311111111
20005??141101015?0?1?0??1
5??81010????10???237300?0
?3605?3611014?09?446?6313
1110015171261071000007001
991?11162011?0191117?0410
?200500??003??60??01900?2

output:

900307781
839110958
981675858
995851013
389598828
122551361
79267861
295093505
388362258
286706944

result:

ok 10 lines

Test #6:

score: 0
Accepted
time: 98ms
memory: 3548kb

input:

10
?150?7??2???902??0?80?70?
1??????11??????001?1?1017
???12???1?5111?1??3?0????
61165?11?196?376621133111
0???0??1041?5?20???1????1
0???3?2?????1????70?0????
?7????7?11?48????98???747
1420?2717247207100?0?8??1
001?13185031??301119??71?
?5??0??????7??0????10???5

output:

864484608
74700832
681727245
536368659
226329329
975189011
448648057
967696005
376743109
173528449

result:

ok 10 lines

Test #7:

score: 0
Accepted
time: 27ms
memory: 3820kb

input:

10
2??0?0??4??3
??0?64?5???1????
??????????01???0017???0
1147???1?1?
07?060????0??
0706457?760130
??4????3???4?
199?0?19?0?2262880
3675036117
032?????8?0??00??

output:

6099056
69020130
488979
68978070
41928
657141248
909
87550531
643195723
982967061

result:

ok 10 lines

Test #8:

score: 0
Accepted
time: 77ms
memory: 3536kb

input:

10
1004024914000141171664179
4112700045099296212010057
2000700072177165003008355
5147124088080418420102215
0111131163261117111189161
0000000507001000083001045
4616130013212189231581163
6370033693059001070063068
2600011505817800101005111
8171898166180081571808187

output:

492541635
485994730
881341707
302237585
319228799
682761479
494203217
307458184
948671187
770194561

result:

ok 10 lines

Test #9:

score: 0
Accepted
time: 34ms
memory: 3596kb

input:

10
9999??1?24109
9961?9?99?9?17??9?9981?9
?55139?310?
01060999911010?100001
????1???0???0
1999?9?9??1?1?99
?6?098?????0?91?06?
??9?9?9920
1009??99?9?83011009
?08815?9?290?6??8159992?

output:

701914982
502544507
838514018
198720051
210
1088344
69369676
88485
208314295
325404847

result:

ok 10 lines

Test #10:

score: 0
Accepted
time: 109ms
memory: 3740kb

input:

10
???9?9????9??1????0?00?0?
?19??5?6705?2006?7?705420
?8?99??9?10????00?000????
26??9???8??1862?9?99???1?
?1?811????119911?1801?0?1
99?0?7?400?????0?7???0??0
9981?80?15??9?99??9??8?2?
87??9787249?8724?98725008
?1???1??7??9?????7??9????
529999810002?2999991000??

output:

488877
578261397
68888881
922387376
922701699
750962293
869492708
5123872
795205985
107899748

result:

ok 10 lines

Test #11:

score: 0
Accepted
time: 125ms
memory: 3596kb

input:

10
?????????????0??0?0?0??0?
?7??1???99???991?070??000
30???7??????8???1??????1?
??45??9?99?9??50????0?09?
?6???0?????9????6?6???0?0
1?????71??811??12?0?2????
?0???0???0???0??0?0?????0
1????999?8???1?8??0?0?088
0??3?000?81?0?030??0181?0
????9?9??99??0??0?81???00

output:

38878
974988866
7995940
207215288
789434908
3675
2915
656463525
46595272
162777032

result:

ok 10 lines

Test #12:

score: 0
Accepted
time: 139ms
memory: 3820kb

input:

10
???????2?6?9?99????9??6??
?9?9??6???9?9??2????0?6??
?13?11?1????7?1??????1?99
??9???9011??00?999?9??1??
0?0?1??0?2?00????1??110?2
?6?301?1818??9??????11???
?1????8?????99??2???????2
?9?????4????9?9??73?49???
???9?7????98??9??????????
?96??9?7?????????99????9?

output:

785875062
118488877
347574749
926770730
39160338
299823179
6742876
217198712
548872
438872

result:

ok 10 lines

Test #13:

score: 0
Accepted
time: 117ms
memory: 3616kb

input:

10
???97??0?99???07?99?00800
?99??3?04??9??310??000?3?
2????1?1?????001???1??632
??1???????????39?????9???
0???5?60?9???????9?2????0
9??99?9?93?191???9??99993
9733?98???993?1?03?101331
9??07?30000207?3?0?1?0703
?9?86?00?00086??0?00????0
????1?99??181?9????8??00?

output:

5944871
70013524
400601421
40868
35709572
642051114
154378
753914535
641178416
83376873

result:

ok 10 lines

Test #14:

score: 0
Accepted
time: 149ms
memory: 3544kb

input:

10
9?20?0???0???00???01?0??0
9?9?1?9???19??97?????????
??9????1?1??00?0??1?9????
9??6168??9?9?9??6?9??998?
9??963702???9?9?9?9???0??
9?????????9?9??8?9???9?9?
?07????0??0?????0????0???
9???9????1???9?99?9???1?9
5?8??99???????89??999?9?7
????9?74???9?9???????????

output:

690644535
1083462
798698973
995370331
446157661
5882928
530890
148240876
882732928
69688682

result:

ok 10 lines

Test #15:

score: 0
Accepted
time: 166ms
memory: 3536kb

input:

10
9??9?53??000?3?0?????0?0?
?8???9??72???9????28??9??
999?9180?0??????????0????
9?99???00??0?0?????0?????
9?????9??000?????0????00?
?999???99?0?????0????????
?????0?0??5?80???00??????
9??????????????5?9??9??9?
?????9?????8?9?999??????0
???????61??9?9????9??????

output:

35988885
854409694
510644532
488886
488882
38881
789346093
1059429
438873
5952561

result:

ok 10 lines

Test #16:

score: -100
Wrong Answer
time: 215ms
memory: 3800kb

input:

10
?199???9??5?999??9965?9?9
????0??????9??5??????????
??????????0?0?00??1????0?
7????9?1?????0???????????
???????0???????????60????
????9??????0??9????4?????
?????????????????????????
????0??20?0??????????0???
????0????????????????????
????999??999??????????0?2

output:

885690430
5249
488883
2883
39174
782884
1
88923
7
148888874

result:

wrong answer 2nd lines differ - expected: '167', found: '5249'
English 繁體中文 简体中文

Server Time: 2024-12-12 15:32:57 | OpenSource Project