text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
typedef pair<int,int> P;
int n;
int x[100005],y[100005];
int ct(int a){
int cnt = 0;
while(a > 1){
a /= 2;
cnt++;
}
return cnt;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
vector<P> a;
for (int i = 0;i < n;i++){
cin >> x[i] >> y[i];
a.push_back(P(x[i]+y[i],1));
}
sort(a.begin(),a.end());
while(true){
vector<P> nex;
nex.push_back(a[0]);
for (int i = 1;i < a.size();i++){
if(a[i] == a[i-1]){
nex[nex.size()-1].second++;
}else{
nex.push_back(a[i]);
}
}
bool flag = true;
for (int i = 0;i < nex.size();i++){
if(nex[i].second >= 2){
int tmp = nex[i].second-(1<<ct(nex[i].second));
if(tmp!=0)nex.push_back(P(nex[i].first,tmp));
nex[i].first += ct(nex[i].second);
nex[i].second = 1;
flag = false;
}
}
sort(nex.begin(),nex.end());
a = nex;
//for (int i = 0;i < a.size();i++){
// cout << a[i].first << " " << 0 << endl;
//}
//cout << endl;
if(flag) break;
}
for (int i = 0;i < a.size();i++){
cout << a[i].first << " " << 0 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e9+100;
const ll MOD = 1e9+7;
const bool debug = 0;
int main() {
int N;
priority_queue<int, vector<int>, greater<int> > pq;
cin >> N;
REP(i, N) {
int a, b;
scanf("%d %d", &a, &b);
pq.push(a + b);
}
vector<int> ans;
while (pq.size() > 1) {
int a = pq.top(); pq.pop();
int b = pq.top(); pq.pop();
if (a == b) pq.push(a + 1);
else {
pq.push(b);
ans.push_back(a);
}
}
if (pq.size() > 0) ans.push_back(pq.top());
REP(i, ans.size()) printf("%d 0\n", ans[i], i == ans.size() - 1 ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, S[1000001];
int main()
{
cin >> N;
for(int i = 0; i < N; i++) {
int X, Y;
cin >> X >> Y;
S[X + Y]++;
}
for(int i = 0; i < 1000000; i++) {
S[i + 1] += S[i] >> 1;
if(S[i] & 1) cout << i << " " << 0 << endl;
}
}
|
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<unordered_map>
#include<array>
#include<map>
#include<iomanip>
//<< setprecision(5)
using namespace std;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
#define dme cout<<-1<<endl;return 0
const int mod=1000000007;
const llint big=1e9+10;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-7;
template <class T,class U>void mineq(T& a,U b){if(a>b){a=b;}}
template <class T,class U>void maxeq(T& a,U b){if(a<b){a=b;}}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){return a/gcd(a,b)*b;}
int main(void){
int n,i;cin>>n;
static int aizu[200300]={0};
for(i=0;i<n;i++){
int a,b;cin>>a>>b;
aizu[a+b]++;
}
for(i=0;i<200279;i++){
aizu[i+1]+=aizu[i]/2;
aizu[i]%=2;
if(aizu[i]==1){cout<<i<<" 0"<<endl;}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
const int N=400000;
int ct[N]={};
int main()
{
int n;
scanf(" %d", &n);
rep(i,n)
{
int a,b;
scanf(" %d %d", &a, &b);
a+=b;
++ct[a];
}
rep(i,N-100)
{
for(int j=20; j>0; --j)
{
if(ct[i]>>j&1)
{
ct[i] -= 1<<j;
++ct[i+j];
}
}
}
rep(i,N)
{
if(ct[i]>0) printf("%d 0\n", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int Count[2000017];
void solve() {
for (int i = 0; i < 2000017; ++i) {
if (Count[i] == 0) {
continue;
}
cout << i << " 0" << endl;
}
}
int main() {
int a, b, c;
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> a >> b;
c = a + b;
while (Count[c] != 0) {
Count[c] = 0;
++c;
}
Count[c] = 1;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200200];
int main() {
int n;
cin >> n;
for(int i=0; i<n; i++) {
int x,y;
cin >> x >> y;
a[x+y]++;
}
for(int i=0; i<200100; i++) {
a[i+1]+=a[i]/2;
a[i]%=2;
if(a[i]) cout << i << " " << 0 << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main() {
int n; cin >> n;
priority_queue<int, vector<int>, greater<int>>pq;
for (int i = 0; i<n; i++) { int a, b; cin >> a >> b; pq.push(a + b); }
while (pq.size() > 0) {
int p = pq.top(); pq.pop();
if (pq.size() == 0)cout << p << " 0\n";
else if (p == pq.top()) {
pq.pop(); pq.push(++p);
}
else cout << p << " 0\n";
}
return 0;
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
typedef long long int ll;
using namespace std;
int main(){
int N,table[200030],a,b,S,tmp;
for(int i = 0; i < 200030; i++)table[i] = 0;
scanf("%d",&N);
for(int loop = 0; loop < N; loop++){
scanf("%d %d",&a,&b);
table[a+b]++;
}
for(int i = 0; i < 200030; i++){
if(table[i] > 1){
tmp = table[i];
table[i] = 0;
S = 2;
for(int k = 0; tmp != 0;k++,tmp /= S){
if(tmp%S == 1){
table[i+k]++;
}
}
}
}
for(int i = 0; i < 200030; i++){
if(table[i] != 0){
printf("%d 0\n",i);
}
}
return 0;
}
|
#include<iostream>
using namespace std;
static const int PMAX = 100000;
int N, T[2 * PMAX + 20 + 1];
int main() {
int a, b;
for (int i = 0; i <= 2 * PMAX + 20; i++)T[i] = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a >> b;
T[a + b]++;
}
for (int i = 0; i < 2 * PMAX + 20; i++) {
T[i + 1] += T[i]/2;
T[i] = T[i] % 2;
if (T[i])cout << i << " " << 0 << endl;
}
return 0;
}
|
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <bitset>
using namespace std;
typedef pair<int, int> P;
#define rep(i, n) for (int i=0; i<(n); i++)
#define all(c) (c).begin(), (c).end()
#define uniq(c) c.erase(unique(all(c)), (c).end())
#define index(xs, x) (int)(lower_bound(all(xs), x) - xs.begin())
#define _1 first
#define _2 second
#define pb push_back
#define INF 1145141919
#define MOD 1000000007
int N;
int C[300000];
signed main() {
ios::sync_with_stdio(false); cin.tie(0);
cin >> N;
rep(i, N) {
int a, b;
cin >> a >> b;
C[a+b]++;
}
vector<int> ans;
rep(i, 300000-1) {
C[i+1] += C[i]/2;
if (C[i]%2) ans.pb(i);
}
for (int x : ans) cout << x << " " << 0 << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int n;
set<int> s;
int main(){
scanf("%d",&n);
for(int i=0;i<n;i++){
int x,y;
scanf("%d %d",&x,&y);
int z=x+y;
while(s.count(z)>0){
s.erase(z);
z++;
}
s.insert(z);
}
set<int> :: iterator it;
for(it=s.begin();it!=s.end();it++)
cout<< *it <<' '<<0<<endl;
return 0;
}
|
// なにこれ
// なにこれと言いながらシミュレーションすると解けます
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int>v(300000);
for (int i = 0; i < n; i++)
{
int a, b;
cin >> a >> b;
v[a + b] ++;
}
for (int i = 0; i < 250000; i++) {
v[i + 1] += v[i] / 2;
v[i] %= 2;
if (v[i] > 0) cout << i << " " << 0 << endl;
}
}
|
#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
#include <iterator>
using namespace std;
int main()
{
int n;
cin >> n;
set<int> s;
for(int i=0; i<n; ++i){
int a, b;
cin >> a >> b;
a += b;
while(s.find(a) != s.end()){
s.erase(a);
++ a;
}
s.insert(a);
}
for(int x : s)
cout << x << " 0" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
constexpr int max_m = 1 << 21;
int n; cin >> n;
vector<int> cnt(max_m);
for(int i = 0; i < n; ++i) {
int a, b; cin >> a >> b;
cnt[a + b] += 1;
}
for(int i = 0; i + 1 < max_m; ++i) {
cnt[i + 1] += cnt[i] / 2;
cnt[i] &= 1;
if(cnt[i] & 1) cout << i << " " << 0 << endl;
}
}
|
#include <iostream>
using namespace std;
int n, a[100009], b[100009], c[300009];
int main(){
cin>>n;
for(int i=0;i<n;i++) {
cin>>a[i]>>b[i];
c[a[i]+b[i]]++;
}
for(int i=0;i<=250000;i++){
c[i+1]+=(c[i]/2);
c[i]%=2;
}
for(int i=0;i<=250000;i++){
if(c[i]>=1) cout<<i<<" "<<0<<endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
//// < "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\b.txt"
int main() {
int N; cin >> N;
vector<int>v(3e5);
for (int i = 0; i < N; ++i) {
int a, b; cin >> a >> b;
v[a + b]++;
}
for (int i = 0; i < 2e5 + 10000; ++i) {
v[i + 1] += v[i] / 2;
v[i] %= 2;
}
for (int i = 0; i < 2e5 + 10000; ++i) {
if (v[i]) {
cout << i << " " << 0 << endl;
}
}
return 0;
}
|
#include<iostream>
using namespace std;
int a[100000], b[100000], n, c[1000000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i]; c[a[i] + b[i]]++;
}
for (int i = 0; i < 999999; i++) {
c[i + 1] += c[i] / 2; c[i] %= 2;
if (c[i] == 1)cout << i << ' ' << 0 << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define all(v) (v).begin(),(v).end()
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define pb push_back
#define fi first
#define se second
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
int N;
int cnt[333333];
signed main(){
cin>>N;
rep(i,N){
int a,b;
cin>>a>>b;
cnt[a+b]++;
}
for(int i=0;i<333333-1;i++){
cnt[i+1]+=cnt[i]/2;
cnt[i]%=2;
if(cnt[i]){
cout<<i<<" "<<0<<endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define pb push_back
#define rep(i, a, n) for(int i = (a); i < (n); i++)
#define dep(i, a, n) for(int i = (a); i >= (n); i--)
#define mod 1e9+7
__attribute__((constructor))
void initial() {
cin.tie(0);
ios::sync_with_stdio(false);
}
int main() {
int n;
cin >> n;
int a[300001] = {};
rep(i, 0, n) {
int b, c;
cin >> b >> c;
a[b + c]++;
}
rep(i, 0, 300001) {
if(a[i] >= 2) {
a[i + 1] += a[i] / 2;
a[i] = a[i] % 2;
}
}
rep(i, 0, 300001) {
if(a[i]) cout << i << " " << 0 << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a, b;
int d[300005] = {};
int ma = 0;
for(int i = 0;i < n;++i){
cin >> a >> b;
++d[a + b];
ma = max(ma, a + b);
}
for(int i = 0;i <= 300000;++i){
d[i + 1] += (d[i] / 2);
d[i] %= 2;
}
for(int i = 0;i <= 300000;++i){
if(d[i] == 1){
cout << i << " 0" << endl;
}
}
return 0;
}
|
#include <iostream>
using namespace std;
int n,a[3400010] = {};
int main(){
cin >> n;
for(int i = 0;i < n;i++){
int A,b;
cin >> A >> b;
a[A + b]++;
}
for(int i = 0;i <= 3400000;i++){
if(a[i] % 2) cout << i << " " << 0 << endl;
a[i + 1] += a[i] / 2;
}
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main() {
vector<int> line(200020, 0);
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
int a, b;
cin >> a >> b;
++line[a + b];
}
for (int i = 0; i < line.size()-1; ++i) {
line[i + 1] += line[i] / 2;
line[i] %= 2;
if (line[i]) {
cout << i << " " << 0 << endl;
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int a[500000];
int main(){
int n,x,y;
cin>>n;
for(int i=0;i<n;i++){
cin>>x>>y;
a[x+y]++;
}
for(int i=0;i<500000;i++){
if(a[i]>1){
a[i+1]+=a[i]/2;
if(a[i]%2)a[i]=1;
else a[i]=0;
}
}
for(int i=0;i<500000;i++){
if(a[i])cout<<i<<' '<<0<<endl;
}
}
|
#include <iostream>
using namespace std;
int cnt[252521];
int main() {
int n, a, b, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a >> b;
cnt[a + b]++;
}
for (i = 0; i < 252500; i++) {
cnt[i + 1] += cnt[i] / 2;
cnt[i] %= 2;
}
for (i = 0; i < 252500; i++) {
if (cnt[i]) {
cout << i << " " << 0 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using LL = long long;
using namespace std;
#define DBG(x) ; // cerr<<#x<<" = "<<x<<endl
#define rep(i,n) for(int i=0;i<(n);++i)
LL N;
int main()
{
cin >> N;
std::vector<LL>a(N), b(N);
rep(i, N) cin >> a[i] >> b[i];
std::priority_queue<LL, std::vector<LL>, std::greater<LL>>c;
rep(i, N) c.push(a[i] + b[i]);
while(!c.empty())
{
LL num1 = c.top(); c.pop();
if (c.empty())
{
cout << num1 << " 0" << endl;
break;
}
LL num2 = c.top();
if (num1 == num2)
{
c.pop();
c.push(num1 + 1);
}
else cout << num1 << " 0" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) REP(i,0,n)
#define REP(i,s,e) for(int i=(s); i<(int)(e); i++)
#define pb push_back
#define all(r) (r).begin(),(r).end()
#define rall(r) (r).rbegin(),(r).rend()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
const ll MOD = 1e9 + 7;
double EPS = 1e-8;
int main(){
int n;
cin>>n;
map<int, int> m;
rep(i, n) {
int a, b;
cin>>a>>b;
m[a+b]++;
}
bool update = true;
while(update) {
update = false;
map<int, int> _m;
for(auto& p : m) {
if(p.se > 1) _m[p.fi +1] += p.se/2, _m[p.fi] += p.se % 2, update = true;
else _m[p.fi] += p.se;
}
m = _m;
}
for(auto& p : m) {
if(p.se > 0) cout<<p.fi<<" "<<0<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m[200000+20+1];
int main() {
int n;
scanf("%d", &n);
while (n--) {
int a, b;
scanf(" %d %d",&a,&b);
m[a+b]++;
}
for(int i=0;i<200000+20;i++){
m[i+1] += m[i]/2;
m[i] = m[i]%2;
if(m[i]>0){
cout << i << " " << 0 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;++i)
#define rrep(i,n) for(int i=n-1;i>=0;--i)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define yesno(flg) if(flg){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;}
#define Vi vector<int>
#define pb push_back
#define i197 1000000007
#define MAX_N 200002
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef pair<Pii,int> Piii;
typedef pair<string,string> Pss;
const int inf=1000000000;
struct edge{
int myc,to,c,cost;
};
struct pos{
int to,cost,color;
};
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
int dp[300001]={};
void add(int k){
if(dp[k]==0){
dp[k]=1;
}else{
dp[k]=0;
add(k+1);
}
}
int main() {
int n,a,b;
Vi v;
cin>>n;
rep(i,n){
cin>>a>>b;
add(a+b);
}
rep(i,300001){
if(dp[i]==1)cout<<i<<" 0"<<endl;
}
return 0;
}
|
#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<math.h>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
#define fore(i,a) for(auto &i:a)
#define REP(i,n) for(int i=0;i<n;i++)
#define eREP(i,n) for(int i=0;i<=n;i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define eFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define SORT(c) sort((c).begin(),(c).end())
#define rSORT(c) sort((c).rbegin(),(c).rend())
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
//vector<vector<int> > dp;
//vector<vector<vector<int> > > vvvi;
//dp=vector<vector<int> >(N, vector<int>(M,0));
//vector<pair<int,int> > v;
//v.push_back(make_pair(x,y));
//priority_queue<int,vector<int>, greater<int> > q2;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N;
int bit[400010] = { 0 };
cin >> N;
REP(i, N) {
int a, b;
cin >> a >> b;
bit[a + b]++;
}
REP(i, 400009) {
bit[i + 1] += bit[i] / 2;
bit[i] %= 2;
}
int ans = 0;
REP(i, 400010) {
if (bit[i])
cout << i << " " << 0 << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n, a, b;
cin >> n;
vector<int> cnt(200030, 0);
for(int i = 0; i < n; i++){
cin >> a >> b;
cnt[a+b]++;
}
for(int i = 0; i < 200020; i++){
cnt[i+1] += cnt[i]/2;
if(cnt[i]%2) cout << i << " " << 0 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
int b[300000] = {};
for(int i = 0;i < n;i++){
int x, y;
cin >> x >> y;
b[x+y] += 1;
}
for(int i = 0;i < 300000-1;i++){
b[i+1] += b[i] / 2;
b[i] %= 2;
}
for(int i = 0;i < 300000;i++){
if(b[i] != 0){
cout << i << " " << 0 << endl;
}
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
//#define int long long
#define DBG 1
#define dump(o) if(DBG){cerr<<#o<<" "<<(o)<<" ";}
#define dumpl(o) if(DBG){cerr<<#o<<" "<<(o)<<endl;}
#define dumpc(o) if(DBG){cerr<<#o; for(auto &e:(o))cerr<<" "<<e;cerr<<endl;}
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a > b) { a = b; return true; } return false; }
#define MAX 210000
signed main() {
int N; cin >> N;
int c[MAX] = {};
rep(i, 0, N) {
int a, b; cin >> a >> b;
c[a + b]++;
}
rep(i, 0, MAX - 1) {
c[i + 1] += c[i]/2;
c[i] %= 2;
}
rep(i, 0, MAX) {
if (c[i] == 0)continue;
cout << i << " " << 0 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF 10000000
#define LLINF 100000000000000
typedef long long ll;
typedef pair<int, int> P;
#define pb push_back
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define VSORT(v) sort(v.begin(), v.end());
#define fi first
#define se second
#define out(x) cout << x << endl;
int dx[] = {1, 0, -1, 0}, dy[] = { 0,1,0,-1 };
ll MOD = 1000000007;
struct edge {
ll from, to, cost;
};
int v[10000005]={0};
int main() {
int n;
cin >> n;
for(int i = 0; i < n; i++){
int a,b;
cin >> a >> b;
v[a+b]++;
}
for(int i = 0; i < 10000000; i++){
int num = v[i]/2;
v[i] -= num * 2;
v[i+1] += num;
}
for(int i = 0; i < 10000000; i++){
if(v[i] > 0){
cout << i <<" " <<v[i]-1 << endl;
}
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> d(201000, 0);
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
d[a + b]++;
}
for (int i = 0; i < 201000; i++) {
if (d[i] > 0) {
int k = d[i] / 2;
int kk = d[i] % 2;
if (kk > 0) {
cout << i << ' ' << 0 << endl;
}
d[i + 1] += k;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define pb push_back
#define rep(i, a, n) for(int i = (a); i < (n); i++)
#define dep(i, a, n) for(int i = (a); i >= (n); i--)
#define mod 1e9+7
__attribute__((constructor))
void initial() {
cin.tie(0);
ios::sync_with_stdio(false);
}
int main() {
int n;
cin >> n;
int aa[500001] = {};
rep(i, 0, n) {
int a, b;
cin >> a >> b;
aa[a + b]++;
}
rep(i, 0, 500000) {
if(aa[i]) {
aa[i + 1] += aa[i] / 2;
if(aa[i] % 2 == 1) cout << i << " " << 0 << endl;
}
}
}
|
#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>
static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;
template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;
int main() {
int n;
cin >> n;
vector<int> A(200100);
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
A[a+b]++;
}
for (int i = 0; i < 200099; ++i) {
A[i+1] += A[i]/2;
A[i] &= 1;
}
for (int i = 0; i < 200100; ++i) {
if(A[i]) printf("%d %d\n", i, 0);
}
return 0;
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
typedef long long int ll;
using namespace std;
int main(){
int N,table[200030],a,b,S,tmp;
for(int i = 0; i < 200030; i++)table[i] = 0;
scanf("%d",&N);
for(int loop = 0; loop < N; loop++){
scanf("%d %d",&a,&b);
table[a+b]++;
}
for(int i = 0; i < 200030; i++){
if(table[i] != 0){
tmp = table[i];
table[i] = 0;
S = 2;
for(int k = 0; tmp != 0;k++,tmp /= S){
if(tmp%S == 1){
table[i+k]++;
}
}
}
}
for(int i = 0; i < 200030; i++){
if(table[i] != 0){
printf("%d 0\n",i);
}
}
return 0;
}
|
#include<iostream>
#include<algorithm>
#define INF 210000
using namespace std;
int c[INF];
int main(){
int n,a,b;
for(int i=0;i<INF;i++)c[i]=0;
cin>>n;
for(int i=0;i<n;i++){
cin>>a>>b;
c[a+b]++;
}
for(int i=0;i<INF-1;i++){
c[i+1]+=c[i]/2;
if(c[i]%2)cout<<i<<" 0"<<endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
int mod=10000;
struct Mod {
public:
int num;
Mod() : Mod(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) {
//static_assert(mod<INT_MAX / 2, "mod is too big, please make num 'long long int' from 'int'");
}
Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator+(const Mod a, const long long int b) { return b + a; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator*(const long long int a, const Mod b) { return Mod(a)*b; }
Mod operator*(const Mod a, const long long int b) { return Mod(b)*a; }
Mod operator*(const Mod a, const int b) { return Mod(b)*a; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator*=(Mod& a, const long long int &b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
Mod mod_pow(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = mod_pow((a * a), (n / 2));
if (n % 2) res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) {
return Mod(a) / b;
}
Mod operator/=(Mod &a, const Mod b) {
return a = a / b;
}
#define MAX_MOD_N 1024000
Mod fact[MAX_MOD_N], factinv[MAX_MOD_N];
void init() {
fact[0] = Mod(1); factinv[0] = 1;
for (int i = 0; i < MAX_MOD_N - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
//keta prenum,upping,aless,bmore,bai
Mod dp[502][10][2][2][2][500][2];
long long int powmod(long long int a, long long int b, const int mod) {
assert(b >= 0);
if (b == 0)return 1;
if (b == 1)return a;
long long int ans = 1;
long long int aa = powmod(a, b / 2, mod);
ans *= aa*aa;
ans %= mod;
if (b % 2)ans *= a;
ans %= mod;
return ans;
}
int main() {
string A, B; int M; cin >> A >> B >> M;
int asize = A.size(); int bsize = B.size();
for (int i = asize; i <= 501; ++i) {
A = '0' + A;
}
for (int i = bsize; i <= 501; ++i) {
B= '0' + B;
}
Mod ans = 0;
for (int i = 0; i < 10; ++i) {
bool amore = i >= (A[501] - '0');
bool bless = i <= (B[501] - '0');
dp[0][i][0][amore][bless][i%M][0]+=1;
dp[0][i][1][amore][bless][i%M][0]+=1;
dp[0][i][0][amore][bless][i%M][1] += 1;
}
for (int keta = 1; keta <= 501; ++keta) {
for (int prenum = 0; prenum < 10; ++prenum) {
for (int upping = 0; upping < 2; ++upping) {
for (int amore = 0; amore < 2; ++amore) {
for (int bless = 0; bless< 2; ++bless) {
for (int bai = 0; bai < M; ++bai) {
for (int death = 0; death < 2; ++death) {
if (dp[keta - 1][prenum][upping][amore][bless][bai][death]) {
for (int nextnum = 0; nextnum < 10; ++nextnum) {
if (death){
if (nextnum) {
continue;
}
}
else {
if (upping) {
if (nextnum <= prenum)continue;
}
else {
if (nextnum >= prenum)continue;
}
}
bool nextamore, nextbless;
if (nextnum >(A[501 - keta] - '0')) {
nextamore = true;
}
else if (nextnum == (A[501 - keta] - '0')) {
nextamore = amore;
}
else {
nextamore = false;
}
if (nextnum > (B[501 - keta] - '0')) {
nextbless = false;
}
else if (nextnum == (B[501 - keta] - '0')) {
nextbless = bless;
}
else {
nextbless = true;
}
int nextbai = bai +powmod(10, keta,M)*nextnum;
nextbai %= M;
assert(nextbai < mod);
if (keta == 1 && nextnum == 1 && (!upping) == 1 && nextamore == 1 && nextbless == 1 && nextbai == 0) {
int c = 0; c++;
}
dp[keta][nextnum][!upping][nextamore][nextbless][nextbai][death] += dp[keta - 1][prenum][upping][amore][bless][bai][death];
/*if (nextnum == 0 && keta == 3 && !nextbai&&death) {
cout << nextnum << " " << prenum << endl;
cout << dp[keta - 1][prenum][upping][amore][bless][bai][death] << endl;;
}*/
if (!death&&nextnum) {
dp[keta][nextnum][!upping][nextamore][nextbless][nextbai][1] += dp[keta - 1][prenum][upping][amore][bless][bai][death];
}
}
}
}
}
}
}
}
}
}
for (int prenum = 0; prenum < 10; ++prenum) {
for (int upping = 0; upping < 2; ++upping) {
for (int death = 1; death < 2; ++death) {
if (dp[501][prenum][upping][1][1][0][death]) {
ans += dp[501][prenum][upping][1][1][0][death];
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int memo[501][501][10][3][2];
// [n桁目][剰余][どの数字を使った]
// [どっちでも、上昇、下降][上限を超えそう/超えない]
char A[1024], B[1024];
int M;
char *str;
int dp(int n, int mod, int use, int updn, int limit)
{
if (str[n] == '\0') return mod == 0 && (use || updn);
if (memo[n][mod][use][updn][limit]){
return memo[n][mod][use][updn][limit];
}
int res = 0;
for (int i = 0; i <= 9; i++){
if ( (limit == 1 || (limit == 0 && i <= str[n] - '0')) && ((updn == 0 && (!use || (use != i))) || ((updn == 1 && i < use) || (updn == 2 && i > use))) ){
int UPDN = 0;
if (updn == 0){
if (use != 0){
if (i < use) UPDN = 2;
else UPDN = 1;
}
}
else UPDN = !(updn - 1) + 1;
res += dp(n + 1, (mod * 10 + i) % M, i, UPDN, limit || i < str[n] - '0');
res %= 10000;
}
}
memo[n][mod][use][updn][limit] = res;
return res;
}
int main()
{
scanf("%s %s %d", A, B, &M);
int p = strlen(A) - 1;
while (true){
if (A[p] > '0'){
A[p]--;
break;
}
else {
A[p] = '9';
p--;
}
}
str = A;
int tmp = dp(0, 0, 0, 0, 0);
str = B;
memset(memo, 0, sizeof(memo));
printf("%d\n", (dp(0, 0, 0, 0, 0) - tmp + 10000) % 10000);
return 0;
}
|
#include <cstdio>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
const int MOD = 10000;
int solve(string s, int m)
{
int n = s.size();
vector<vector<vector<vector<int> > > > dp1(n+1, vector<vector<vector<int> > >(10, vector<vector<int> >(2, vector<int>(m, 0))));
vector<vector<vector<vector<int> > > > dp2(n+1, vector<vector<vector<int> > >(10, vector<vector<int> >(2, vector<int>(m, 0))));
for(int i=0; i<n; ++i){
for(int x=1; x<=9; ++x){
if(i == 0 && x > s[0] - '0')
continue;
if(i == 0 && x == s[0] - '0'){
dp1[i+1][x][0][x%m] = 1;
if(i < n-1)
dp2[i+1][x][0][x%m] = 1;
}else{
dp1[i+1][x][1][x%m] = 1;
if(i < n-1)
dp2[i+1][x][1][x%m] = 1;
}
}
for(int x=0; x<=9; ++x){
for(int j=0; j<2; ++j){
for(int rest=0; rest<m; ++rest){
for(int y=0; y<=9; ++y){
if(j == 0 && y > s[i] - '0')
continue;
if(y == x)
continue;
int k = (j == 1 || y < s[i] - '0')? 1:0;
int rest1 = (rest * 10 + y) % m;
if((i % 2 == 0) ^ (y > x)){
dp1[i+1][y][k][rest1] += dp1[i][x][j][rest];
dp1[i+1][y][k][rest1] %= MOD;
}else{
dp2[i+1][y][k][rest1] += dp2[i][x][j][rest];
dp2[i+1][y][k][rest1] %= MOD;
}
}
}
}
}
}
int ret = 0;
for(int i=0; i<=9; ++i){
for(int j=0; j<2; ++j){
ret += dp1[n][i][j][0] + dp2[n][i][j][0];
}
}
ret %= MOD;
return ret;
}
int main()
{
string a, b;
int m;
cin >> a >> b >> m;
for(int i=a.size()-1; ; --i){
if(a[i] > '0'){
-- a[i];
break;
}
a[i] = '9';
}
int ret = solve(b, m) - solve(a, m);
ret = (ret % MOD + MOD) % MOD;
cout << ret << endl;
return 0;
}
|
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<climits>
#include<iostream>
#include<sstream>
#include<utility>
#include<map>
#include<vector>
#include<queue>
#include<algorithm>
#include<set>
#include<stack>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int MOD=10000;
int dp[503][10][2][2][503];
char A[2][505];
int M;
char tmp[506];
int dfs(int x,int d,int n,bool f,int up,int mod)
{
if(d==0)memset(dp,-1,sizeof(dp));
//printf("%d %d %d %d %d %d\n",x,d,n,f,up,mod);
if(~dp[d][n][f][up][mod])return dp[d][n][f][up][mod];
if(d==strlen(A[x]))
{
// if(mod==0)puts(tmp);
return mod==0;
}
int res=0;
int ub=(f?9:A[x][d]-'0');
for(int i=0;i<=ub;i++)
{
if(up==0&&n<=i)continue;
if(up==1&&n>=i)continue;
if(up==2&&n&&n==i)continue;
int nf;
if(up==2)
{
if(n==0)nf=2;
else if(n>i)nf=1;
else nf=0;
}else nf=!up;
tmp[d]=i+'0';
res=(res+dfs(x,d+1,i,f|(i!=A[x][d]-'0'),nf,(mod*10+i)%M))%MOD;
}
return dp[d][n][f][up][mod]=res%MOD;
}
int main()
{
memset(dp,-1,sizeof(dp));
scanf("%s%s%d",A[0],A[1],&M);
for(int i=strlen(A[0])-1;A[0][i]>=0;i--)
{
if(A[0][i]=='0')
A[0][i]='9';
else
{
A[0][i]=A[0][i]-1;break;
}
}
printf("%d\n",(dfs(1,0,0,0,2,0)-dfs(0,0,0,0,2,0)+MOD)%MOD);
return 0;
}
|
#include<bits/stdc++.h>
#define int long long
#define rep for(int i=0;i<n;++i)
#define per for(int i=n;i>0;--i)
#define FOR(i,a,b) for(int i=a;i<=b;++i)
#define ROF(i,a,b) for(int i=a;i>=b;--i)
using namespace std;
static const int INF =1<<61;
static const int MOD = 10000;
string num1,num2;
string s;
int m;
int mem[501][500][10][3][3];
int cal(int n,int mod,int p,int pp,int f){
int res=0;
if(mem[n][mod][p][pp][f]!=-1)return mem[n][mod][p][pp][f];
if(n==s.size())return 0;
FOR(i,0,9){
int b=pp;
int t=f;
int temp=(mod*10);
temp+=i;
if(n==0){
if(i==0)continue;
if(i>s[n]-'0')t=1;
else if(i<s[n]-'0')t=2;
else t=0;
if(s.size()==1){
if(s[0]-'0'>i&&i%m==0)res+=cal(n+1,i%m,i,b,t)+1;
}
else{
if(i%m==0){
res+=(cal(n+1,i%m,i,b,t)+1)%MOD;
}
else res+=cal(n+1,i%m,i,b,t);
}
}
else if(n==1){
if(t==0){
if(i>s[n]-'0')t=1;
else if(i<s[n]-'0')t=2;
}
if(p==i)continue;
else if(p<i)b=1;
else if(p>i)b=0;
if(temp%m==0){
res+=(cal(n+1,temp%m,i,b,t)+1)%MOD;
}
else res+=cal(n+1,temp%m,i,b,t);
}
else if(n==s.size()-1){
if(t==0){
if(i>s[n]-'0')t=1;
else if(i<s[n]-'0')t=2;
}
if(t==2){
if(b==1){
if(p>i){
if(temp%m==0){
res+=(cal(n+1,temp%m,i,b,t)+1)%MOD;
}
}
}
else if(b==0){
if(p<i){
if(temp%m==0){
res+=(cal(n+1,temp%m,i,b,t)+1)%MOD;
}
}
}
}
if(t==0){
if(b==1){
if(p>i&&s[n]-'0'>=i){
if(temp%m==0){
res+=(cal(n+1,temp%m,i,b,t)+1)%MOD;
}
}
}
else if(b==0){
if(p<i&&s[n]-'0'>=i){
if(temp%m==0){
res+=(cal(n+1,temp%m,i,b,t)+1)%MOD;
}
}
}
}
}
else{
if(t==0){
if(i>s[n]-'0')t=1;
else if(i<s[n]-'0')t=2;
}
if(b==1){
if(p>i){
b=0;
if(temp%m==0){
res+=(cal(n+1,temp%m,i,b,t)+1)%MOD;
}
else res+=cal(n+1,temp%m,i,b,t);
}
}
else if(b==0){
if(p<i){
b=1;
if(temp%m==0){
res+=(cal(n+1,temp%m,i,b,t)+1)%MOD;
}
else res+=cal(n+1,temp%m,i,b,t)%MOD;
}
}
}
}
return mem[n][mod][p][pp][f]=res%MOD;
}
int vr,vl;
signed main(){
cin>>num1>>num2;
cin>>m;
s=num1;
memset(mem,-1,sizeof(mem));
vl=cal(0,0,0,0,0)%MOD;
memset(mem,-1,sizeof(mem));
s=num2;
vr=cal(0,0,0,0,0)%MOD;
cout<<(vr-vl+MOD)%MOD<<endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<functional>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<tuple>
#include<stack>
#include<queue>
#include<deque>
#include<sstream>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<bitset>
#include<time.h>
#include<cstdlib>
#include<cassert>
#define ll long long
#define fi first
#define se second
using namespace std;
const ll MOD=10000;
string a,b;
int m;
ll dp[502][2][500][11][3][2];
/*inline ll solve(string s){
int n=(int)s.length();
for(int i=0;i<510;i++)for(int j=0;j<2;j++)for(int k=0;k<500;k++)for(int l=0;l<11;l++)for(int o=0;o<3;o++)for(int h=0;h<2;h++)dp[i][j][k][l][o][h]=0;
dp[0][0][0][0][0][0]=1;
for(int i=0;i<n;i++)for(int j=0;j<2;j++)for(int k=0;k<m;k++)for(int l=0;l<11;l++)for(int o=0;o<3;o++)for(int h=0;h<2;h++){
int lim=j?9:s[i]-'0';
for(int d=0;d<lim+1;d++){
if(l==0 && i==0){
dp[i+1][j || d<lim][(10*k+d)%m][d+1][0][h || (l!=1 && l!=0)]+=dp[i][j][k][l][o][h];
//cout<<i+1<<" "<<(int)(j || d<lim)<<" "<<(10*k+d)%m<<" "<<d+1<<" "<<o<<endl;
continue;
}
if(o!=1){
if(d>l-1){
dp[i+1][j || d<lim][(10*k+d)%m][d+1][(o==2?1:(h || l!=1)?1:0)][h || l!=1]+=dp[i][j][k][l][o][h];
//cout<<i+1<<" "<<(int)(j || d<lim)<<" "<<(10*k+d)%m<<" "<<d+1<<" "<<1<<endl;
}
}
if(o!=2){
if(d<l-1){
dp[i+1][j || d<lim][(10*k+d)%m][d+1][(o==1?2:(h || l!=1)?2:0)][h || l!=1]+=dp[i][j][k][l][o][h];
//cout<<i+1<<" "<<(int)(j || d<lim)<<" "<<(10*k+d)%m<<" "<<d+1<<" "<<2<<endl;
}
}
}
}
ll res=0;
for(int i=0;i<2;i++)for(int j=0;j<500;j++)for(int k=1;k<11;k++)for(int l=1;l<3;l++){
if(j==0)
res+=dp[n][i][j][k][l][1];
if(dp[n][i][j][k][l][1]>0 && j==0)cout<<i<<" "<<j<<" "<<k<<" "<<l<<"="<<dp[n][i][j][k][l][1]<<endl;
}
return res;
}*/
inline ll solve(string s){
int n=(int)s.length();
for(int i=0;i<n+1;i++)for(int j=0;j<2;j++)for(int k=0;k<m;k++)for(int l=0;l<11;l++)for(int mm=0;mm<3;mm++)for(int o=0;o<2;o++)dp[i][j][k][l][mm][o]=0;
dp[0][0][0][0][0][0]=1;
for(int i=0;i<n;i++){
for(int j=0;j<2;j++){
for(int k=0;k<m;k++){
for(int l=0;l<11;l++){
for(int mm=0;mm<3;mm++){
for(int o=0;o<2;o++){
int lim=j?9:s[i]-'0';
int pre=l-1;
for(int d=0;d<lim+1;d++){
if(d==0 && o==0){
(dp[i+1][j || d<lim][(10*k+d)%m][0][0][0]+=dp[i][j][k][l][mm][o])%=MOD;
continue;
}
if(pre==-1){
(dp[i+1][j || d<lim][(10*k+d)%m][d+1][0][1]+=dp[i][j][k][l][mm][o])%=MOD;
continue;
}
if(pre<d && mm!=1){
(dp[i+1][j || d<lim][(10*k+d)%m][d+1][1][1]+=dp[i][j][k][l][mm][o])%=MOD;
}
if(pre>d && mm!=2){
(dp[i+1][j || d<lim][(10*k+d)%m][d+1][2][1]+=dp[i][j][k][l][mm][o])%=MOD;
}
}
}
}
}
}
}
}
ll ans=0;
for(int i=0;i<2;i++)for(int j=1;j<11;j++)for(int k=0;k<3;k++){
(ans+=dp[n][i][0][j][k][1])%=MOD;
}
return ans;
}
inline string min1(string s){
int n=(int)s.length();
for(int i=n-1;i>=0;i--){
int now=s[i]-'0';
if(now-1<0){
s[i]='9';
}else{
s[i]='0'+now-1;
break;
}
}
for(int i=0;i<n;i++){
if(s=="0")break;
if(s[i]=='0')s=s.substr(1,s.length()-1);
else break;
}
return s;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout<<fixed;
#ifdef LOCAL_DEFINE
freopen("in", "r", stdin);
freopen("out","w",stdout);
#endif
ll ansa,ansb;
cin>>a>>b>>m;
//while(cin>>a>>b>>m){
a=min1(a);
ansb=solve(b);
//cout<<b<<" ansb="<<ansb<<endl;
ansa=solve(a);
//cout<<a<<" ansa="<<ansa<<endl;
cout<<(ansb+MOD-ansa)%MOD<<"\n";
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
int c[501],d[500][500][10][3][2],m;
bool e;
int fi(int p,int q,int r,int s,bool t){
int i;
if(p<0){
if(t&&!q)
e=true;
return !q;
}
if(d[p][q][r][s][t?1:0]>=0)
return d[p][q][r][s][t?1:0];
int ct=0;
if(s==0||s==2){
for(i=r+1;i<=(t?c[p]:9);++i)
ct=(ct+fi(p-1,(q*10+i)%m,i,1,t&&i==c[p]))%10000;
}
if(s==1||s==2){
for(i=0;i<=min(t?c[p]:9,r-1);++i)
ct=(ct+fi(p-1,(q*10+i)%m,i,0,t&&i==c[p]))%10000;
}
return d[p][q][r][s][t?1:0]=ct;
}
int main(){
int i,j;
char a[502],b[502];
scanf("%s%s%d",a,b,&m);
int aln=strlen(a),bln=strlen(b);
int ct=0;
memset(d,-1,sizeof(d));
for(i=0;b[i];++i)
c[bln-i-1]=b[i]-'0';
for(i=aln;i<=bln;++i)
for(j=1;j<=(i==bln?c[bln-1]:9);++j)
ct=(ct+fi(i-2,j%m,j,2,i==bln&&j==c[bln-1]))%10000;
memset(d,-1,sizeof(d));
for(i=0;a[i];++i)
c[aln-i-1]=a[i]-'0';
e=false;
for(j=1;j<=c[aln-1];++j)
ct=(ct-fi(aln-2,j%m,j,2,j==c[aln-1])+10000)%10000;
if(e)
ct=(ct+1)%10000;
printf("%d\n",ct);
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define CLEAR(arr, val) memset(arr, val, sizeof(arr))
#define rep(i, n) for (int i = 0; i < n; ++i)
template <class T> void max_swap(T& a, const T& b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T& b) { a = min(a, b); }
typedef long long ll;
typedef pair<int, int> pint;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };
const int mod = 10000;
int m;
int rem[512][10];
int incr[512][512][10], decr[512][512][10];
void dpru(int digits)
{
for (int i = 0; i < 10; ++i)
rem[0][i] = i;
for (int i = 0; i < digits; ++i)
for (int j = 0; j < 10; ++j)
rem[i + 1][j] = (rem[i][j] * 10) % m;
for (int i = 0; i < 10; ++i)
incr[0][i % m][i] = decr[0][i % m][i] = 1;
for (int i = 0; i < digits; ++i)
{
for (int j = 0; j < m; ++j)
{
for (int k = 0; k < 10; ++k)
{
for (int l = 0; l < 10; ++l)
{
int r = (j + rem[i + 1][l]) % m;
if (l > k)
(incr[i + 1][r][l] += decr[i][j][k]) %= mod;
else if (l < k)
(decr[i + 1][r][l] += incr[i][j][k]) %= mod;
}
}
}
}
}
bool zig_zag(int n)
{
vector<int> v;
for (int i = n; i; i /= 10)
v.push_back(i % 10);
for (int i = 1; i < v.size(); ++i)
if (v[i - 1] == v[i])
return false;
for (int i = 2; i < v.size(); ++i)
if (v[i - 2] < v[i - 1] && v[i - 1] < v[i]
|| v[i - 2] > v[i - 1] && v[i - 1] > v[i])
return false;
return true;
}
vector<int> zig_zag_simple(int n)
{
vector<int> res;
for (int i = 1; i <= n; ++i)
if (i % m == 0 && zig_zag(i))
res.push_back(i);
return res;
}
int zig_zag_eq_less(const string& s)
{
const int n = s.size();
if (n <= 3)
return zig_zag_simple(atoi(s.c_str())).size();
vector<int> d(n);
for (int i = 0; i < n; ++i)
d[i] = s[n-1 - i] - '0';
int res = zig_zag_simple(99).size();
for (int digits = 2; digits < n - 1; ++digits)
for (int i = 1; i < 10; ++i)
(res += incr[digits][0][i] + decr[digits][0][i]) %= mod;
for (int i = 1; i < d[n - 1]; ++i)
{
int r = (m - rem[n - 1][i]) % m;
for (int j = 0; j < 10; ++j)
{
if (i < j)
(res += incr[n - 2][r][j]) %= mod;
else if (i > j)
(res += decr[n - 2][r][j]) %= mod;
}
}
int rr = rem[n - 1][d[n - 1]];
for (int i = 0; i < d[n - 2]; ++i)
{
int r = (m - rr) % m;
if (d[n - 1] < i)
(res += incr[n - 2][r][i]) %= mod;
else if (d[n - 1] > i)
(res += decr[n - 2][r][i]) %= mod;
}
if (d[n - 2] == d[n - 1])
return res;
(rr += rem[n - 2][d[n - 2]]) %= m;
bool inc = d[n - 1] > d[n - 2];
for (int i = n - 3; i >= 0; --i)
{
if (inc)
{
for (int j = d[i + 1] + 1; j < d[i]; ++j)
(res += incr[i][(m - rr) % m][j]) %= mod;
}
else
{
for (int j = 0; j < min(d[i], d[i + 1]); ++j)
(res += decr[i][(m - rr) % m][j]) %= mod;
}
if (inc ^ (d[i + 1] < d[i]))
break;
(rr += rem[i][d[i]]) %= m;
inc ^= true;
if (i == 0 && rr == 0)
++res;
}
return res;
}
string decrement(const string& n)
{
string res = n;
for (int i = res.size() - 1; i >= 0; --i)
{
if (res[i] == '0')
res[i] = '9';
else
{
--res[i];
break;
}
}
if (res[0] == '0')
res.erase(0, 1);
return res;
}
int main()
{
string a, b;
cin >> a >> b >> m;
int digits = b.size();
dpru(digits);
int y = zig_zag_eq_less(b);
int x = zig_zag_eq_less(decrement(a));
cout << (y - x + mod) % mod << endl;
//m = 3;
//dpru(100);
//int S = 11000000;
//int R = 1;
//for(;;)
//{
//cin >> S;
//for (int i = S; i < S + R; ++i)
//{
// vector<int> z = zig_zag_simple(i);
// stringstream ss;
// ss << i;
// int cor = z.size();
// int my = zig_zag_eq_less(ss.str());
// //if (cor != my)
// printf("%4d: %3d, %3d\n", i, cor, my);
//}
//}
}
|
#include <bits/stdc++.h>
using namespace std;
#define all(v) begin(v), end(v)
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for(int i = (int)(s); i < (int)(n); i++)
const int mod = 10000;
string A, B;
int M;
// dp[index][islower][mod][zig-zag][prev]
int dp[501][2][500][3][10];
int solve(const string& s, int idx, int lt, int m, int zg, int prev)
{
if(idx == s.size()) return m == 0;
int& ret = dp[idx][lt][m][zg][prev];
if(~ret) return ret;
ret = 0;
int lim = lt ? 9 : s[idx]-'0';
rep(d, lim + 1) {
int zgzg = -1;
if(zg == 0) { // start
if(prev == 0) zgzg = 0;
else if(d == prev) continue;
else if(d < prev) zgzg = 1;
else if(d > prev) zgzg = 2;
} else if(zg == 1) { // up
if(d <= prev) continue;
else zgzg = 2;
} else if(zg == 2) { // down
if(d >= prev) continue;
else zgzg = 1;
}
assert(zgzg != -1);
(ret += solve(s, idx+1, lt||d<lim, (m*10+d)%M, zgzg, d)) %= mod;
}
return ret % mod;
}
signed main()
{
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
cin >> A >> B >> M;
for(int i = (int)A.size()-1; i >= 0; i--) {
if(A[i] == '0') {
A[i] = '9';
} else {
A[i]--;
break;
}
}
memset(dp, -1, sizeof(dp));
int a = solve(A, 0, 0, 0, 0, 0);
memset(dp, -1, sizeof(dp));
int b = solve(B, 0, 0, 0, 0, 0);
cout << (b - a + mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for(int i=a; i<n; i++)
#define repq(i,a,n) for(int i=a; i<=n; i++)
#define repr(i,a,n) for(int i=a; i>=n; i--)
typedef long long int ll;
typedef pair<int, int> pii;
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
constexpr ll MOD = 10000LL;
// digit, mod, prev, neu-up-down, flag
// neu-up-down ... 0 -> neutral, 1 -> up, 2 -> down
ll dp[510][510][10][3][2];
ll solve(string s, int M, int less) {
memset(dp, 0, sizeof(dp));
dp[0][0][0][0][0] = 1;
int N = s.length();
rep(i,0,N) rep(j,0,M) rep(k,0,10) rep(l,0,3) rep(f,0,2) {
int lim = f ? 9 : s[i] - '0';
// neutral (l == 0 and k == 0)
if(l == 0 && k == 0) {
rep(x,0,lim+1) {
int mo = (j*10+x) % M;
(dp[i+1][mo][x][0][f || x < lim] += dp[i][j][k][l][f]) %= MOD;
}
}
else {
// (up, neutral) -> down
if(l == 0 || l == 1) {
rep(x,0,lim+1) {
if(x >= k) continue;
int mo = (j*10+x) % M;
(dp[i+1][mo][x][2][f || x < lim] += dp[i][j][k][l][f]) %= MOD;
}
}
// (down, neutral) -> up
if(l == 0 || l == 2) {
rep(x,0,lim+1) {
if(x <= k) continue;
int mo = (j*10+x) % M;
(dp[i+1][mo][x][1][f || x < lim] += dp[i][j][k][l][f]) %= MOD;
}
}
}
}
ll ret = 0;
rep(k,0,10) rep(l,0,3) rep(f,0,2) {
if(less == 1 && f == 0) continue;
(ret += dp[N][0][k][l][f]) %= MOD;
}
return ret;
}
int main() {
string A, B; cin >> A >> B;
int M; cin >> M;
ll ra = solve(A, M, 1);
ll rb = solve(B, M, 0);
cout << (rb - ra + MOD) % MOD << endl;
return 0;
}
|
#include<iostream>
#include<string>
#define M 10000
using namespace std;
short dp[2][2][3][10][550]; //dp[digit][bound][dec or else or inc][prv num][mod]
int zig(string s,int m){
int n = s.size(),up,mod,ub,odd,nxt;
for(int j=0;j<3;j++)
for(int k=0;k<10;k++)
for(int l=0;l<m;l++)
dp[0][0][j][k][l] = dp[0][1][j][k][l] = 0;
dp[0][1][1][0][0] = 1;
for(int i=0;i<n;i++){
odd = i&1, nxt = 1-odd;
for(int j=0;j<3;j++)
for(int k=0;k<10;k++)
for(int l=0;l<m;l++)
dp[nxt][0][j][k][l] = dp[nxt][1][j][k][l] = 0;
for(int j=0;j<2;j++){
if(j==1)up = s[i]-'0';
else up = 9;
for(int k=0;k<3;k++){
for(int l=0;l<10;l++){
for(int x=0;x<=up;x++){
if(k==0 && x<=l)continue;
if(k==2 && l<=x)continue;
for(int y=0;y<m;y++){
mod = (y*10 + x) % m;
if(j==1 && x==up)ub = 1;
else ub = 0;
if(k==1 && l==0){
dp[nxt][ub][1][x][mod] += dp[odd][j][k][l][y];
dp[nxt][ub][1][x][mod] %= M;
}else if(x<l){
dp[nxt][ub][0][x][mod] += dp[odd][j][k][l][y];
dp[nxt][ub][0][x][mod] %= M;
}else if(x>l){
dp[nxt][ub][2][x][mod] += dp[odd][j][k][l][y];
dp[nxt][ub][2][x][mod] %= M;
}
}
}
}
}
}
}
int ans = 0; odd = n&1;
for(int i=0;i<2;i++)
for(int j=0;j<3;j++)
for(int k=0;k<10;k++){
ans += dp[odd][i][j][k][0];
ans %= M;
}
return ans;
}
string dec(string a){
int n = a.size() - 1;
while(a[n]=='0'){
a[n--] = '9';
}
a[n]--;
if(a[n] == '0')a = a.substr(1,n-1);
return a;
}
int main(){
string a,b;
int m;
cin >> a >> b >> m;
cout << (zig(b,m) - zig(dec(a),m) + M) % M << endl;
}
|
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
#define mod 10000
#define INF 2000000000
#define LLINF 4000000000000000000
#define SIZE 50010
char A[510],B[510];
int M;
int memo[501][2][10][500][3];
// h=?????° Z = true->up false->down b=1???????????°??? m=(modM)
// a=0..???MAX&?????± 1..???MAX&??¶????????? 2..???MAX-1&?????± c=0..A 1..B
// O(500*2*10*500*3*2 = 15000000)
int MAX_a,C[510];
int dfs(int h,bool Z,int b,int m,int a){
int ret = 0;
if(h == MAX_a && a==2) return 0;
if(m==0 && h > 0 && !(h==1 && Z==false))
ret = 1;
if((h == MAX_a) || (h == MAX_a-1 && a==2)){
return ret;
}
if(memo[h][Z][b][m][a]>0){
return memo[h][Z][b][m][a];
}
//[s,e)
int s=0,e=10;
if(h==0) s =1;
if(Z==true){
s = b+1;
}else{
e = b;
}
if(a == 1){
for(int i=s;i<e;i++){
if(C[h] < i)
ret+=dfs(h+1,!Z,i,(m*10+i)%M,2);
else if(C[h]==i)
ret+=dfs(h+1,!Z,i,(m*10+i)%M,1);
else
ret+=dfs(h+1,!Z,i,(m*10+i)%M,0);
}
}else{
for(int i=s;i<e;i++){
ret+=dfs(h+1,!Z,i,(m*10+i)%M,a);
}
}
memo[h][Z][b][m][a] = ret%mod;
return ret%mod;
}
int is_ZigZag(){
bool Z;
if(MAX_a==1)
return 1;
if(C[0]==C[1])
return 0;
if(MAX_a==2){
return 1;
}
Z = (C[0] > C[1]);
for(int i=2;i<MAX_a;i++){
if(!(Z==true && C[i-1] < C[i]) && !(Z==false && C[i-1] > C[i])){
return 0;
}
}
return 1;
}
int main(){
int ans_A,ans_B,length_A=0,length_B=0;
scanf("%s %s %d",A,B,&M);
while(A[length_A]!='\0') length_A++;
while(B[length_B]!='\0') length_B++;
for(int i=0;i<length_A;i++){
C[i] = A[i]-'0';
}
MAX_a = length_A;
ans_A = dfs(0,1,-1,0,1) + dfs(0,0,10,0,1);
ans_A -= is_ZigZag();
for(int i=0;i<501;i++){
for(int j=0;j<2;j++){
for(int k=0;k<10;k++){
for(int l=0;l<500;l++){
for(int m=0;m<3;m++){
memo[i][j][k][l][m] = 0;
}
}
}
}
}
for(int i=0;i<length_B;i++){
C[i] = B[i]-'0';
}
MAX_a = length_B;
ans_B = dfs(0,1,-1,0,1) + dfs(0,0,10,0,1);
printf("%d\n",(ans_B+mod-(ans_A%mod))%mod);
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <utility>
#include <cmath>
#include <map>
#include <set>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define INF_LL 1e18
#define INF 1e9
#define REP(i, n) for(int i = 0;i < (n);i++)
#define FOR(i, a, b) for(int i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fst first
#define snd second
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;
ll MOD = 1e9+7;
int M;
string s, s1;
int dp[510][501][2][3][10];
void dec1(){
for(int i = s1.size()-1;i >= 0;i--){
if(s1[i] == 0) s1[i] = 9;
else{
s1[i]--;
break;
}
}
}
const int up = 1, down = 2, stay = 0;
int dfs(int dig, int md, bool tight, int ud, int be){
if(dig == s.size()) return ud ? md ? 0 : 1 : 0;
if(~dp[dig][md][tight][ud][be]) return dp[dig][md][tight][ud][be];
int lim = tight ? s[dig] : 9;
ll res =0;
REP(i, lim+1){
if(ud == stay){
if(dig < s.size()-1 && be == i){
res += dfs(dig+1, (md*10)%M, tight & (i==lim), stay, i);
}else if(be != i){
res += dfs(dig+1, (md*10+i)%M, tight & (i==lim), up, i);
if(dig < s.size()-1)
res += dfs(dig+1, (md*10+i)%M, tight & (i==lim), down, i);
}
}else if(ud == up){
if(be > i)
res += dfs(dig+1, (md*10+i)%M, tight & (lim==i), down, i);
}else{
if(be < i)
res += dfs(dig+1, (md*10+i)%M, tight & (lim==i), up, i);
}
}
res %= 10000;
return dp[dig][md][tight][ud][be] = res;
}
int main(void){
cin >> s1 >> s >> M;
REP(i, s.size()) s[i] -='0';
REP(i, s1.size()) s1[i] -= '0';
dec1();
memset(dp, -1, sizeof dp);
ll res1 = dfs(0,0,1,0,0);
memset(dp, -1, sizeof dp);
s = s1;
ll res2 = dfs(0,0,1,0,0);
cout << (res1-res2+10000)%10000 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define each(itr,c) for(__typeof(c.begin()) itr=c.begin(); itr!=c.end(); ++itr)
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
const int mod=10000;
int M;
// a???????????§?±????, ????????????????????°b, ????????????M??§?????°???c, S??????????¢????d, leading zero????????????e, ?¬???????????????????????????????f
int dp[506][10][500][2][2][2];
string s;
int dfs(int a, int b, int c, int d, int e, int f)
{
if(dp[a][b][c][d][e][f]>=0) return dp[a][b][c][d][e][f];
if(a==505) return c==0;
// 1????????????
if(a==504 && e==1)
{
int ub=9;
if(d==0) ub=s[a]-'0';
int ret=0;
for(int i=1; i<=ub; ++i) ret+=(i%M==0);
return ret;
}
int ret=0;
if(e==1)
{
// ?¬??????????leading zero????¶???????
if(d==0)
{
ret+=dfs(a+1,0,c,(s[a]!='0'),1,f);
ret%=mod;
}
else
{
ret+=dfs(a+1,0,c,d,1,f);
ret%=mod;
}
// leading zero????????????
if(d==0)
{
int ub = s[a]-'0';
if(ub>0)
{
// printf("a= %d, ub= %d\n", a,ub);
for(int i=1; i<ub; ++i)
{
ret+=dfs(a+1,i,(c*10+i)%M,1,0,0);
ret%=mod;
ret+=dfs(a+1,i,(c*10+i)%M,1,0,1);
ret%=mod;
}
ret+=dfs(a+1,ub,(c*10+ub)%M,0,0,0);
ret%=mod;
ret+=dfs(a+1,ub,(c*10+ub)%M,0,0,1);
ret%=mod;
}
}
else
{
for(int i=1; i<10; ++i)
{
ret+=dfs(a+1,i,(c*10+i)%M,1,0,0);
ret%=mod;
ret+=dfs(a+1,i,(c*10+i)%M,1,0,1);
ret%=mod;
}
}
}
else
{
// ??????
if(f==0)
{
if(d==0)
{
int ub=s[a]-'0';
rep(i,b)
{
if(i<ub)
{
ret+=dfs(a+1,i,(c*10+i)%M,1,e,!f);
ret%=mod;
}
else if(i==ub)
{
ret+=dfs(a+1,i,(c*10+i)%M,0,e,!f);
ret%=mod;
}
}
}
else
{
rep(i,b)
{
ret+=dfs(a+1,i,(c*10+i)%M,1,e,!f);
ret%=mod;
}
}
}
else
{
if(d==0)
{
int ub=s[a]-'0';
for(int i=b+1; i<10; ++i)
{
if(i<ub)
{
ret+=dfs(a+1,i,(c*10+i)%M,1,e,!f);
ret%=mod;
}
else if(i==ub)
{
ret+=dfs(a+1,i,(c*10+i)%M,0,e,!f);
ret%=mod;
}
}
}
else
{
for(int i=b+1; i<10; ++i)
{
ret+=dfs(a+1,i,(c*10+i)%M,1,e,!f);
ret%=mod;
}
}
}
}
return dp[a][b][c][d][e][f]=ret;
}
inline string fill_leadingzero(string c)
{
string ret=c;
while(ret.size()<505) ret = "0"+ret;
return ret;
}
int isValid(string c)
{
int C=c.size();
rep(i,C-1)
{
if(c[i]==c[i+1]) return 0;
}
int ud=1;
if(c[0]<c[1]) ud=0;
for(int i=1; i<C-1; ++i)
{
if(ud==1)
{
if(c[i]>c[i+1]) return 0;
}
else
{
if(c[i]<c[i+1]) return 0;
}
ud = !ud;
}
int sum=0;
rep(i,C)
{
sum = sum*10 + (c[i]-'0');
sum%=M;
}
return sum==0;
}
int main()
{
string A,B;
cin >>A >>B >>M;
int ans=0;
memset(dp,-1,sizeof(dp));
s=fill_leadingzero(B);
ans+=dfs(0,0,0,0,1,0);
memset(dp,-1,sizeof(dp));
s=fill_leadingzero(A);
ans-=dfs(0,0,0,0,1,0);
ans+=isValid(A);
ans = (ans+mod)%mod;
printf("%d\n", ans);
return 0;
}
|
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
#define MOD 10000
string s;
short dp[2][3][10][500][501]; //[free][増減][prev][余り][index]
int m;
int solve( bool fr, int updw, int pre, int mod, int index){
if( index == s.size() ) return !mod;
if( dp[fr][updw][pre][mod][index] != -1 ) return dp[fr][updw][pre][mod][index];
int ret = 0, end = fr ? 9 : s[index];
for(int i = 0, u ; i <= end ; i++ ){
switch(updw){
case 0: //さいしょ
if( pre && pre == i ) continue;
else if( pre == 0 ) u = 0;
else if( pre > i ) u = 1;
else u = 2;
break;
case 1: //次あっぷ
if( pre >= i ) continue;
else u = 2;
break;
case 2: //次だうん
if( pre <= i ) continue;
else u = 1;
break;
}
ret += solve( fr|(i!=s[index]), u, i, (mod*10+i)%m, index+1);
}
return dp[fr][updw][pre][mod][index] = ret % MOD;
}
void java(){
for(int i = s.size() - 1 ; i >= 0 ; i-- ){
if(s[i] == 0) s[i] = 9;
else{
s[i]--;
break;
}
}
}
void init(){
for(int j = 0 ; j < 3 ; j++ )
for(int k = 0 ; k < 10 ; k++ )
for(int l = 0 ; l < m ; l++ )
for(int q = 0 ; q <= s.size() ; q++ )
dp[0][j][k][l][q] = dp[1][j][k][l][q] = -1;
}
int main(){
string s1;
cin >> s >> s1 >> m;
for(int i = 0 ; i < s.size() ; i++ ) s[i] -= '0';
java();
init();
int an = solve( 0, 0, 0, 0, 0);
s = s1;
for(int i = 0 ; i < s.size() ; i++ ) s[i] -= '0';
init();
int bn = solve( 0, 0, 0, 0, 0);
cout << ( bn - an + MOD ) % MOD << endl;
}
|
#include<bits/stdc++.h>
#define MOD 10000
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
typedef pair<int, int>P;
int dp1[502][2][10][500][3], dp2[502][2][10][500][3], m;
void solve(int dp[][2][10][500][3], string&a) {
dp[0][0][0][0][0] = 1;
rep(i, a.size())rep(j, 2)rep(k, 10)rep(l, m)rep(d, 3) {
int s, g, p = a[i] - '0';
if (d == 1) { s = k + 1; g = (j ? 9 : p); }
else if (d == 2) { s = 0; g = (j ? k - 1 : min(k - 1, p)); }
else { s = 0; g = (j ? 9 : p); }
for (int x = s; x <= g; x++) {
if (x&&k == x)continue;
int y;
if (d == 1)y = 2;
else if (d == 2)y = 1;
else {
if (k == 0)y = 0;
else if (x < k)y = 1;
else y = 2;
}
(dp[i + 1][j || x < p][x][(l * 10 + x) % m][y] += dp[i][j][k][l][d]) %= MOD;
}
}
}
int main() {
string a, b; cin >> a >> b >> m;
int d = a.size() - 1;
while (a[d] == '0') {
a[d] = '9'; d--;
}
a[d]--;
solve(dp1, a); solve(dp2, b);
int sum1 = 0, sum2 = 0;
rep(i, 2)rep(j, 10)rep(t, 3) {
(sum1 += dp1[a.size()][i][j][0][t]) %= MOD;
(sum2 += dp2[b.size()][i][j][0][t]) %= MOD;
}
printf("%d\n", (sum2 + MOD - sum1) % MOD);
}
|
// g++ -std=c++17 -O3 -fmax-errors=1 -fsanitize=undefined
#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
#define all(c) ((c).begin()), ((c).end())
#define TEST(s) if (!(s)) { cout << __LINE__ << " " << #s << endl; exit(-1); }
// state = x : x == n % mod
struct ModuloAutomaton {
int mod;
ModuloAutomaton(int mod) : mod(mod) { }
int init() { return 0; }
int size() { return mod; }
int next(int state, int a) { return (10 * state + a) % mod; }
bool accept(int state) { return state == 0; }
};
// state = 0 : empty
// 1 : fail
// 2 ... 10 : singleton and last number is state-1
// 11 ... 19 : increased and last number is state-10
// 20 ... 28 : decreased and last number is state-20
struct ZigZagAutomaton {
int init() { return 0; }
int size() { return 29; }
int next(int state, int a) {
if (state == 0) return a == 0 ? 0 : a + 1;
if (state == 1) return 1;
if (state <= 10) {
int last = state - 1;
if (a > last) return a + 10;
else if (a < last) return a + 20;
} else if (state <= 19) {
int last = state - 10;
if (a < last) return a + 20;
} else if (state <= 28) {
int last = state - 20;
if (a > last) return a + 10;
}
return 1;
}
bool accept(int state) { return state != 1; }
};
template <class Automaton1, class Automaton2>
struct CompositionAutomaton {
Automaton1 A;
Automaton2 B;
int created = 0;
vector<vector<int>> table;
vector<int> fst, snd;
int compose(int state1, int state2) {
if (table[state1][state2] < 0) {
table[state1][state2] = fst.size();
fst.push_back(state1);
snd.push_back(state2);
}
return table[state1][state2];
}
CompositionAutomaton(Automaton1 A, Automaton2 B) : A(A), B(B) {
table.assign(A.size(), vector<int>(B.size(), -1));
}
int init() { return compose(A.init(), B.init()); }
int size() { return A.size() * B.size(); }
int next(int state, int a) {
return compose(A.next(fst[state], a), B.next(snd[state], a));
}
bool accept(int state) {
return A.accept(fst[state]) && B.accept(snd[state]);
}
};
template <class Automaton>
int digitDP(string num, Automaton A, int eq = 1) {
int n = num.size();
vector<vector<vector<int>>> dp(n+1);
dp[0] = vector<vector<int>>(2, vector<int>(A.size()));
dp[0][1][A.init()] = 1;
auto addTo = [&](int &x, int y) {
if ((x += y) >= 10000) x -= 10000;
};
for (int i = 0; i < n; ++i) {
//cout << i << endl;
dp[i+1] = vector<vector<int>>(2, vector<int>(A.size()));
for (int tight = 0; tight <= 1; ++tight) {
for (int state = 0; state < A.size(); ++state) {
if (dp[i][tight][state] == 0) continue;
int lim = (tight ? num[i] - '0' : 9);
for (int d = 0; d <= lim; ++d) {
int tight_ = tight && d == lim;
int state_ = A.next(state, d);
addTo(dp[i+1][tight_][state_], dp[i][tight][state]);
}
}
}
dp[i].clear();
}
int ans = 0;
for (int tight = 0; tight <= eq; ++tight)
for (int state = 0; state < A.size(); ++state)
if (A.accept(state)) addTo(ans, dp[n][tight][state]);
return ans;
}
template <class Automaton>
int debug(string num, Automaton A) {
function<void(int,int,int,string)> rec
= [&](int i, int tight, int state, string s) {
if (i == num.size()) {
if (A.accept(state)) cout << s << endl;
return;
}
int lim = (tight ? num[i] - '0' : 9);
for (int d = 0; d <= lim; ++d) {
int tight_ = tight && d == lim;
int state_ = A.next(state, d);
s.push_back('0' + d);
rec(i+1, tight_, state_, s);
s.pop_back();
}
};
rec(0, 1, A.init(), "");
}
int main() {
char A[1000], B[1000];
int M;
scanf("%s %s %d", A, B, &M);
ZigZagAutomaton zigzag;
ModuloAutomaton modulo(M);
CompositionAutomaton<ZigZagAutomaton,ModuloAutomaton> CM(zigzag, modulo);
int a = digitDP(A, CM, 0);
int b = digitDP(B, CM, 1);
cout << (b + (10000 - a)) % 10000 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) FOR(i, 0, n)
#define FOR(i,a,b) for(int i=a;i<b;i++)
#ifdef LOCAL
#define DEBUG(...) printf(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
#define MOD 10000
#define N 512
int m;
int memo[N][2][3][10][3][N];
char a[3][N];
int k;
// bool debug=false;
int DP(int, int, int, int, int, int);
int dp(int p, int q, int r, int s, int t, int u){
if(~memo[p][q][r][s][t][u]) return memo[p][q][r][s][t][u];
else return memo[p][q][r][s][t][u]=DP(p, q, r, s, t, u);
// return DP(p, q, r, s, t, u);
}
// digit count, leading zero, constrain, before, next none/up/down, mod
int DP(int p, int q, int r, int s, int t, int u){
int ret=0;
if(p==0){
if(u==0){
ret=1;
}else ret=0;
}else{
if(q){
REP(i, 10){
if(i>a[r][k-p]) continue;
// printf(" (%d, %d)->(%d, %d)\n", p, u, p-1, u*10+i);
ret+=dp(p-1, i==0, i<a[r][k-p]?2:r, i, 0, i%m);
}
}else{
if(t==0){
REP(i, 10){
if(i==s) continue;
if(i>a[r][k-p]) continue;
ret+=dp(p-1, q, i<a[r][k-p]?2:r, i, s>i?1:2, (u*10+i)%m);
}
}else if(t==1){
FOR(i, s+1, 10){
if(i>a[r][k-p]) continue;
ret+=dp(p-1, q, i<a[r][k-p]?2:r, i, 2, (u*10+i)%m);
}
}else{
REP(i, s){
if(i>a[r][k-p]) continue;
ret+=dp(p-1, q, i<a[r][k-p]?2:r, i, 1, (u*10+i)%m);
}
}
}
}
ret%=MOD;
return ret;
}
int main(){
scanf("%s%s%d", a[0], a[1], &m);
int x[2];
REP(i, 2){
x[i]=strlen(a[i]);
REP(j, x[i]) a[i][j]-='0';
}
REP(i, N) a[2][i]=9;
REP(h, N) REP(i, 2) REP(j, 3) REP(f, 10) REP(l, 3) REP(g, N)
memo[h][i][j][f][l][g]=-1;
k=x[0];
int p=dp(k, 1, 0, 0, 0, 0);
// debug=true;
REP(h, N) REP(i, 2) REP(j, 3) REP(f, 10) REP(l, 3) REP(g, N)
memo[h][i][j][f][l][g]=-1;
k=x[1];
int q=dp(k, 1, 1, 0, 0, 0);
int r=0;
REP(j, 2){
bool ok=true;
REP(i, x[0]-1){
if((i+j)%2==0 && a[0][i]>=a[0][i+1]) ok=false;
if((i+j)%2==1 && a[0][i]<=a[0][i+1]) ok=false;
}
if(ok) r=1;
}
int buf=0;
REP(i, x[0]){
buf*=10;
buf+=a[0][i];
buf%=m;
}
if(buf) r=0;
int ans=(q-p+r+MOD*100)%MOD;
printf("%d\n", ans);
}
|
#include<bits/stdc++.h>
#define MOD 10000
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int dp1[502][2][10][500][3], dp2[502][2][10][500][3], m, len[2];
char S[2][550];
void solve(int dp[][2][10][500][3], int o) {
dp[0][0][0][0][0] = 1;
rep(i, len[o])rep(j, 2)rep(k, 10)rep(l, m)rep(d, 3) {
if (dp[i][j][k][l][d] == 0)continue;
int s, g, p = S[o][i] - '0';
if (d == 1) { s = k + 1; g = (j ? 9 : p); }
else if (d == 2) { s = 0; g = (j ? k - 1 : min(k - 1, p)); }
else { s = 0; g = (j ? 9 : p); }
for (int x = s; x <= g; x++) {
if (x&&k == x)continue;
int y;
if (d == 1)y = 2;
else if (d == 2)y = 1;
else {
if (k == 0)y = 0;
else if (x < k)y = 1;
else y = 2;
}
(dp[i + 1][j || x < p][x][(l * 10 + x) % m][y] += dp[i][j][k][l][d]) %= MOD;
}
}
}
int main() {
scanf("%s%s%d", S[0], S[1], &m);
rep(i, 2)len[i] = strlen(S[i]);
int d = len[0] - 1;
while (S[0][d] == '0') {
S[0][d] = '9'; d--;
}
S[0][d]--;
solve(dp1, 0); solve(dp2, 1);
int sum1 = 0, sum2 = 0;
rep(i, 2)rep(j, 10)rep(t, 3) {
(sum1 += dp1[len[0]][i][j][0][t]) %= MOD;
(sum2 += dp2[len[1]][i][j][0][t]) %= MOD;
}
printf("%d\n", (sum2 + MOD - sum1) % MOD);
}
|
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
#define MOD 10000
string s;
short dp[2][3][10][500][501]; //[free][増減][prev][余り][index]
int m;
int solve( bool fr, int updw, int pre, int mod, int index){
if( index == s.size() ) return !mod;
if( dp[fr][updw][pre][mod][index] != -1 ) return dp[fr][updw][pre][mod][index];
int ret = 0, end = fr ? 9 : s[index];
for(int i = 0, u ; i <= end ; i++ ){
switch(updw){
case 0: //さいしょ
if( pre && pre == i ) continue;
else if( pre == 0 ) u = 0;
else if( pre > i ) u = 1;
else u = 2;
break;
case 1: //次あっぷ
if( pre >= i ) continue;
else u = 2;
break;
case 2: //次だうん
if( pre <= i ) continue;
else u = 1;
break;
}
ret += solve( fr|(i!=s[index]), u, i, (mod*10+i)%m, index+1);
}
return dp[fr][updw][pre][mod][index] = ret % MOD;
}
void java(){
for(int i = s.size() - 1 ; i >= 0 ; i-- ){
if(s[i] == 0) s[i] = 9;
else{
s[i]--;
break;
}
}
}
int main(){
string s1;
cin >> s >> s1 >> m;
for(int i = 0 ; i < s.size() ; i++ ) s[i] -= '0';
java();
fill_n( ****dp, 2 * 3 * 10 * 500 * 501, -1);
int an = solve( 0, 0, 0, 0, 0);
s = s1;
for(int i = 0 ; i < s.size() ; i++ ) s[i] -= '0';
fill_n( ****dp, 2 * 3 * 10 * 500 * 501, -1);
int bn = solve( 0, 0, 0, 0, 0);
cout << ( bn - an + MOD ) % MOD << endl;
}
|
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <climits>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 1<<29;
const double PI = acos(-1);
const double EPS = 1e-8;
int MOD = 10000;
int dp[501][10][500][2][2];
string str;
int n;
int M;
int rec(int pos, int pre, int q, bool up, bool smaller) {
if (pos == n) return q==0;
if (dp[pos][pre][q][up][smaller] >= 0) return dp[pos][pre][q][up][smaller];
int res = 0;
int s = str[pos]-'0';
int lb, ub;
if (up) lb = 0, ub = pre-1;
else lb = pre+1, ub = 9;
if (!smaller) ub = min(ub, s);
//cout << pos << " " << pre << " " <<lb << " " << ub << endl;
for (int i=lb; i<=ub; ++i) {
res = (res + rec(pos+1, i, (q*10+i)%M, !up, i<s?1:smaller)) % MOD;
}
return dp[pos][pre][q][up][smaller] = res;
}
int solve(string s) {
n = s.size();
str = s;
memset(dp, -1, sizeof(dp));
int res = 0;
for (int i=1; i<=s[0]-'0'; ++i) {
if (n>=2) res = (res + rec(1,i,i%M,0,s[0]-'0'!=i)) % MOD;
res = (res + rec(1,i,i%M,1,s[0]-'0'!=i)) % MOD;
}
for (int i=1; i<n; ++i) {
for (int j=1; j<=9; ++j) {
if (i!=n-1) res = (res + rec(i+1,j,j%M,0,1)) % MOD;
// // cout << i << " "<< j << endl;
// // cout << res << endl;
res = (res + rec(i+1,j,j%M,1,1)) % MOD;
}
}
return res;
}
string minus1(string s) {
int c = 1;
for (int i=s.size()-1; i>=0; --i) {
if (s[i] == '0') s[i] = '9';
else {
s[i]--;
break;
}
}
return s;
}
int main() {
string A, B;
cin >> A >> B;
cin >> M;
//M = 5;
//cout << solve("0") << endl;
cout << (solve(B)-solve(minus1(A)) + MOD) % MOD << endl;
}
|
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string>
#include <tuple>
#include <vector>
#include <map>
#include <unordered_map>
#include <list>
#include <set>
#include <stack>
#include <queue>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <cassert>
using namespace std;
#define LL long long
#define MP(a, b) make_pair(a, b)
#undef INT_MIN
#undef INT_MAX
#define INT_MIN -2147483647
#define INT_MAX 2147483647
#define LL_MIN (LL)-3223372036854775807
#define LL_MAX (LL)9223372036854775807
#define PI 3.14159265359
#define MOD 10000
string A,B;
int M;
int dp[501][10][3][500][4];
//order501*10*2*500*4*10=10^8
int solve(int now, int mae, int updown, int amari, int giri){
if(now == B.size() && amari == 0) return 1;
if(dp[now][mae][updown][amari][giri] != -1) return dp[now][mae][updown][amari][giri];
int re = 0;
if(giri == 0){
if(updown == 0){
for(int i=mae+1; i<=9; i++) re += solve(now+1,i,1,(amari*10+i)%M, 0);
}
if(updown == 1){
for(int i=mae-1; i>=0; i--) re += solve(now+1,i,0,(amari*10+i)%M, 0);
}
if(updown == 2){
for(int i=1; i<=9; i++) re += solve(now+1,i,0,(amari*10+i)%M, 0) + solve(now+1,i,1,(amari*10+i)%M, 0);
}
}
if(giri == 1){
if(updown == 0){
for(int i=mae+1; i<=9; i++){
if(A[A.size()-B.size()+now]-'0' == i) re += solve(now+1,i,1,(amari*10+i)%M, 1);
if(A[A.size()-B.size()+now]-'0' < i) re += solve(now+1,i,1,(amari*10+i)%M, 0);
}
}
if(updown == 1){
for(int i=mae-1; i>=0; i--){
if(A[A.size()-B.size()+now]-'0' == i) re += solve(now+1,i,0,(amari*10+i)%M, 1);
if(A[A.size()-B.size()+now]-'0' < i) re += solve(now+1,i,0,(amari*10+i)%M, 0);
}
}
if(updown == 2){
for(int i=1; i<=9; i++){
if(A[A.size()-B.size()+now]-'0' == i) re += solve(now+1,i,0,(amari*10+i)%M, 1) + solve(now+1,i,1,(amari*10+i)%M, 1);
if(A[A.size()-B.size()+now]-'0' < i) re += solve(now+1,i,0,(amari*10+i)%M, 0) + solve(now+1,i,1,(amari*10+i)%M, 0);
}
}
}
if(giri == 2){
if(updown == 0){
for(int i=mae+1; i<=9; i++){
if(B[now]-'0' == i) re += solve(now+1,i,1,(amari*10+i)%M, 2);
if(B[now]-'0' > i) re += solve(now+1,i,1,(amari*10+i)%M, 0);
}
}
if(updown == 1){
for(int i=mae-1; i>=0; i--){
if(B[now]-'0' == i) re += solve(now+1,i,0,(amari*10+i)%M, 2);
if(B[now]-'0' > i) re += solve(now+1,i,0,(amari*10+i)%M, 0);
}
}
if(updown == 2){
for(int i=1; i<=9; i++){
if(B[now]-'0' == i) re += solve(now+1,i,0,(amari*10+i)%M, 2) + solve(now+1,i,1,(amari*10+i)%M, 2);
if(B[now]-'0' > i) re += solve(now+1,i,0,(amari*10+i)%M, 0) + solve(now+1,i,1,(amari*10+i)%M, 0);
}
}
}
if(giri == 3){
if(updown == 0){
for(int i=mae+1; i<=9; i++){
if(A[now]-'0' == i && B[now]-'0' == i) re += solve(now+1,i,1,(amari*10+i)%M, 3);
else if(A[now]-'0' == i && B[now]-'0' > i) re += solve(now+1,i,1,(amari*10+i)%M, 1);
else if(B[now]-'0' == i && A[now]-'0' < i) re += solve(now+1,i,1,(amari*10+i)%M, 2);
else if(A[now]-'0' < i & i < B[now]-'0') re += solve(now+1,i,1,(amari*10+i)%M, 0);
}
}
if(updown == 1){
for(int i=mae-1; i>=0; i--){
if(A[now]-'0' == i && B[now]-'0' == i) re += solve(now+1,i,0,(amari*10+i)%M, 3);
else if(A[now]-'0' == i && B[now]-'0' > i) re += solve(now+1,i,0,(amari*10+i)%M, 1);
else if(B[now]-'0' == i && A[now]-'0' < i) re += solve(now+1,i,0,(amari*10+i)%M, 2);
else if(A[now]-'0' < i & i < B[now]-'0') re += solve(now+1,i,0,(amari*10+i)%M, 0);
}
}
if(updown == 2){
for(int i=1; i<=9; i++){
if(A[now]-'0' == i && B[now]-'0' == i) re += solve(now+1,i,0,(amari*10+i)%M, 3) + solve(now+1,i,1,(amari*10+i)%M, 3);
else if(A[now]-'0' == i && B[now]-'0' > i) re += solve(now+1,i,0,(amari*10+i)%M, 1) + solve(now+1,i,1,(amari*10+i)%M, 1);
else if(B[now]-'0' == i && A[now]-'0' < i) re += solve(now+1,i,0,(amari*10+i)%M, 2) + solve(now+1,i,1,(amari*10+i)%M, 2);
else if(A[now]-'0' < i & i < B[now]-'0') re += solve(now+1,i,0,(amari*10+i)%M, 0) + solve(now+1,i,1,(amari*10+i)%M, 0);
}
}
}
//cout << now << " " << mae << " " << updown << " " << amari << " " << giri << " " << re << endl;
return dp[now][mae][updown][amari][giri] = re % MOD;
}
int main() {
iostream::sync_with_stdio(false);
cin >> A >> B >> M;
for(int i=0; i<B.size(); i++){
for(int j=0; j<10; j++){
for(int k=0; k<3; k++){
for(int l=0; l<M; l++){
for(int m=0; m<4; m++){
dp[i][j][k][l][m] = -1;
}
}
}
}
}
int ans = 0;
if(A.size() == B.size()){
/*if(A[0]==B[0]) ans = solve(1, A[0]-'0', 0, 0, 3);
else{
ans += solve(1, A[0]-'0', 0, 0, 1);
for(int i=A[0]-'0'+1; i<B[0]-'0'; i++){
ans += solve(1, i, 0, 0, 0);
}
ans += solve(0, B[0]-'0', 0, 0, 2);
}*/
ans = solve(0, 0, 2, 0, 3);
if(A.size() == 1) ans /= 2;
}
else{
/*ans += solve(0, B[0]-'0', 0, 0, 2);
for(int i=B[0]-'0'-1; i>=1; i--){
ans += solve(0, i, 0, 0, 0);
}
for(int i=1; i<B.size()-A.size(); i++){
}*/
ans += solve(0, 0, 2, 0, 2);
for(int i=1; i<B.size()-A.size(); i++){
ans += solve(i, 0, 2, 0, 0);
}
int tmp = solve(B.size()-A.size(), 0, 2, 0, 1);
if(A.size() == 1) tmp /= 2; //up,downでダブっているため
ans += tmp;
}
cout << ans % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
string A,B;
int M;
const LL MOD = 10000;
LL dp[555][10][555][2][2];
//S以下の0modMなジグザグ数の個数を求める
LL solve(string&S){
int N=S.size();
int firstdig=S[0]-'0';
if(N==1){
return firstdig/M;
}
memset(dp,0,sizeof(dp));
for(int i=1;i<firstdig;++i){
dp[0][i][i%M][0][0]=1;
dp[0][i][i%M][1][0]=1;
}
dp[0][firstdig][firstdig%M][0][1]=1;
dp[0][firstdig][firstdig%M][1][1]=1;
auto addrem=[](LL& ins,LL plr){
ins+=plr;
ins%=MOD;
};
for(int d=0;d<N-1;++d){
for(int v=0;v<10;++v){
for(int r=0;r<M;++r){
for(int f=0;f<2;++f){
for(int n=0;n<2;++n){
LL now=dp[d][v][r][f][n];
if(n==0){
if(f){
for(int nv=v+1;nv<10;++nv){
addrem(
dp[d+1][nv][(r*10+nv)%M][!f][n],now
);
}
}else{
for(int nv=0;nv<v;++nv){
addrem(
dp[d+1][nv][(r*10+nv)%M][!f][n],now
);
}
}
}else{
int lim=S[d+1]-'0';
if(f){
for(int nv=v+1;nv<=lim;++nv){
addrem(
dp[d+1][nv][(r*10+nv)%M][!f][(nv==lim)],now
);
}
}else{
for(int nv=0;nv<min(lim+1,v);++nv){
addrem(
dp[d+1][nv][(r*10+nv)%M][!f][(nv==lim)],now
);
}
}
}
}
}
}
}
for(int i=1;i<10;++i){
addrem(dp[d+1][i][i%M][0][0],1);
addrem(dp[d+1][i][i%M][1][0],1);
}
}
LL res=0;
for(int v=0;v<10;++v){
for(int f=0;f<2;++f){
for(int n=0;n<2;++n){
addrem(
res,dp[N-1][v][0][f][n]
);
}
}
}
res -= 9 / M;
return res;
}
int main(){
cin>>A;
cin>>B;
cin>>M;
LL L=solve(A);
LL R=solve(B);
bool Azig=true;
if(A.size()>1){
vector<int>vec;
for(int i=1;i<A.size();++i){
if(A[i-1]<A[i]){
vec.push_back(1);
}else if(A[i-1]>A[i]){
vec.push_back(0);
}else{
Azig=false;
break;
}
}
if(Azig){
for(int j=1;j<vec.size();++j){
if(vec[j]==vec[j-1]){
Azig=false;
break;
}
}
}
}
LL ans=R-L;
if(Azig)ans++;
ans+=MOD;
ans%=MOD;
//cerr<<L<<" "<<R<<endl;
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
#define MOD 10000
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int dp[502][2][10][500][3], m, len[2];
char S[2][550];
inline int solve(int o) {
memset(dp,0,sizeof(dp));
dp[0][0][0][0][0] = 1;
rep(i, len[o])rep(j, 2)rep(k, 10)rep(l, m)rep(d, 3) {
if (dp[i][j][k][l][d] == 0)continue;
int s, g, p = S[o][i] - '0';
if (d == 1) { s = k + 1; g = (j ? 9 : p); }
else if (d == 2) { s = 0; g = (j ? k - 1 : min(k - 1, p)); }
else { s = 0; g = (j ? 9 : p); }
for (int x = s; x <= g; x++) {
if (x&&k == x)continue;
int y;
if (d == 1)y = 2;
else if (d == 2)y = 1;
else {
if (k == 0)y = 0;
else if (x < k)y = 1;
else y = 2;
}
(dp[i + 1][j || x < p][x][(l * 10 + x) % m][y] += dp[i][j][k][l][d]) %= MOD;
}
}
int sum=0;
rep(j,10)rep(t,3){
(sum+=dp[len[o]][1][j][0][t])%=MOD;
if(o)(sum+=dp[len[o]][0][j][0][t])%=MOD;
}
return sum;
}
int main() {
scanf("%s%s%d", S[0], S[1], &m);
rep(i, 2)len[i] = strlen(S[i]);
printf("%d\n", (solve(1) + MOD - solve(0)) % MOD);
}
|
#include<stdio.h>
#include<string.h>
#define M 10000
int dp[2][2][10][500];
char a[501];
char b[501];
int m;
int solve(char s[],bool cont){
memset(dp,0,sizeof(dp));
int n=strlen(s);
int i,j,k,l;
int pre=2,cur=2;
int mm=0;
bool use=true;
int d=s[0]-'0';
for(i=1;i<d;i++){
dp[0][0][i][i%m]=1;
dp[0][1][i][i%m]=1;
}
mm=d%m;
if(n==1){
int ans=0;
for(i=1;i<d;i++)if(i%m==0)ans++;
if(cont&&mm==0)ans++;
return ans;
}
for(i=1;i<n;i++){
for(j=0;j<2;j++)for(k=0;k<10;k++)for(l=0;l<m;l++)dp[i%2][j][k][l]=0;
for(j=1;j<10;j++){
dp[i%2][0][j][j%m]=1;
dp[i%2][1][j][j%m]=1;
}
for(j=0;j<10;j++){
for(k=0;k<m;k++){
for(l=0;l<j;l++)dp[i%2][0][l][(k*10+l)%m]=(dp[i%2][0][l][(k*10+l)%m]+dp[(i+1)%2][1][j][k])%M;
for(l=j+1;l<10;l++)dp[i%2][1][l][(k*10+l)%m]=(dp[i%2][1][l][(k*10+l)%m]+dp[(i+1)%2][0][j][k])%M;
}
}
if(use){
d=s[i]-'0';
for(j=0;j<d;j++){
if(cur==1||cur==2)if(j<s[i-1]-'0')dp[i%2][0][j][(mm*10+j)%m]++;
if(cur==-1||cur==2)if(j>s[i-1]-'0')dp[i%2][1][j][(mm*10+j)%m]++;
}
pre=cur;
if(s[i]>s[i-1])cur=1;
else if(s[i]<s[i-1])cur=-1;
else cur=0;
if(pre==cur||cur==0)use=false;
}
mm=(mm*10+d)%m;
}
int ans=0;
for(i=0;i<10;i++){
ans+=dp[(n+1)%2][0][i][0];
ans+=dp[(n+1)%2][1][i][0];
if(i>=1&&i%m==0)ans--;
}
if(use&&cont&&mm==0)ans++;
return ans%M;
}
int main(){
scanf(" %s",a);
scanf(" %s",b);
scanf("%d",&m);
int p=solve(a,false);
int q=solve(b,true);
printf("%d\n",(q-p+M)%M);
return 0;
}
|
#include <iostream>
#include <string>
#define int long long
#define MOD 10000
using namespace std;
int m;
int dp[510][500][10][4][2] = {};//keta,mod,prevnum,UorDorNoorZero,limit
int calc(string s){
for(int i = 0;i <= s.length();i++){
for(int j = 0;j < m;j++){
for(int k = 0;k < 10;k++){
for(int l = 0;l < 4;l++){
for(int o = 0;o < 2;o++) dp[i][j][k][l][o] = 0;
}
}
}
}
dp[0][0][0][3][1] = 1;
for(int i = 0;i < s.length();i++){
for(int j = 0;j < m;j++){
for(int k = 0;k < 10;k++){
for(int l = 0;l < 10;l++){
if(k < l){
(dp[i + 1][(j * 10 + l) % m][l][0][0] += dp[i][j][k][1][0] + dp[i][j][k][2][0]) %= MOD;
if(l < s[i] - '0') (dp[i + 1][(j * 10 + l) % m][l][0][0] += dp[i][j][k][1][1] + dp[i][j][k][2][1]) %= MOD;
else if(l == s[i] - '0') (dp[i + 1][(j * 10 + l) % m][l][0][1] += dp[i][j][k][1][1] + dp[i][j][k][2][1]) %= MOD;
}
else if(k > l){
(dp[i + 1][(j * 10 + l) % m][l][1][0] += dp[i][j][k][0][0] + dp[i][j][k][2][0]) %= MOD;
if(l < s[i] - '0') (dp[i + 1][(j * 10 + l) % m][l][1][0] += dp[i][j][k][0][1] + dp[i][j][k][2][1]) %= MOD;
else if(l == s[i] - '0') (dp[i + 1][(j * 10 + l) % m][l][1][1] += dp[i][j][k][0][1] + dp[i][j][k][2][1]) %= MOD;
}
if(!k){
if(!l) (dp[i + 1][j][0][3][0] += dp[i][j][k][3][0] + dp[i][j][k][3][1]) %= MOD;
else{
(dp[i + 1][(j * 10 + l) % m][l][2][0] += dp[i][j][k][3][0]) %= MOD;
if(l < s[i] - '0') (dp[i + 1][(j * 10 + l) % m][l][2][0] += dp[i][j][k][3][1]) %= MOD;
else if(l == s[i] - '0') (dp[i + 1][(j * 10 + l) % m][l][2][1] += dp[i][j][k][3][1]) %= MOD;
}
}
}
}
}
}
int ans = 0;
for(int i = 0;i < 10;i++){
for(int j = 0;j < 3;j++){
for(int k = 0;k < 2;k++){
ans = (ans + dp[s.length()][0][i][j][k]) % MOD;
}
}
}
return ans;
}
signed main(){
string a,b;
cin >> a >> b >> m;
for(int i = a.length() - 1;i >= 0;i--){
if(a[i] != '0'){
a[i]--;
if(!i && a[i] == '0') a = a.substr(1,a.length() - 1);
break;
}
a[i] = '9';
}
//cout << calc(b) << endl;
cout << (calc(b) - calc(a) + MOD) % MOD << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int dp[2][3][10][500][500];
string s;
int M;
int rec(int idx, int mod, bool free, int pre, int pre_up){
if(idx == s.size()) return mod == 0;
if(~dp[free][pre_up][pre][idx][mod]) return dp[free][pre_up][pre][idx][mod];
int ret = 0, end = free ? 9 : s[idx] - '0';
for(int i = 0; i <= end; i++){
#define next(l) rec( idx + 1, (mod * 10 + i) % M, free|(i != end), i, l)
if(pre_up == 1 && pre <= i) continue;
if(pre_up == 2 && pre >= i) continue;
if(pre_up == 0){
if(pre && pre == i) continue;
if(pre == 0) ret += next(0);
else if(pre < i) ret += next(1);
else if(pre > i) ret += next(2);
} else if(pre_up == 1){
ret += next(2);
} else {
ret += next(1);
}
}
return dp[free][pre_up][pre][idx][mod] = ret % 10000;
}
int get_value(string str){
s = str;
fill_n( ****dp, 500 * 500 * 10 * 2 * 3, -1);
return rec( 0, 0, false, 0, 0);
}
string sub(string s){
for(int i = s.size() - 1; i >= 0; i--){
if(s[i] == '0') s[i] = '9';
else{ s[i]--; break; }
}
return s;
}
int main(){
string a, b;
cin >> a >> b;
cin >> M;
cout << (get_value(b) - get_value(sub(a)) + 10000) % 10000 << endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cstring>
using namespace std;
int M;
int dp[2][501][11][2];
int dp2[2][501][11][2][2];
const int mod=10000;
bool isCheckCond(int firstUp,int pos,int prvDig,int curDig){
bool ok=false;
if(firstUp){
if((pos%2)==1)ok=prvDig<curDig;
else ok=prvDig>curDig;
}
else{
if((pos%2)==0)ok=prvDig<curDig;
else ok=prvDig>curDig;
}
return ok;
}
bool checkM(string &s){
int sum=0;
for(int i=0;i<(int)s.size();i++){
sum+=s[i]-'0';
sum%=M;
}
return (sum==0);
}
bool isZig(string &s){
if(s.size()==1)return true;
bool firstUp=(s[1]-s[0]>0);
for(int i=1;i<(int)s.size();i++){
bool ok=isCheckCond(firstUp,i,s[i-1]-'0',s[i]-'0');
if(!ok)return false;
}
return true;
}
int solve1(int lastRank){
for(int pos=lastRank-1;pos>=0;pos--){
int nxt=pos%2;
int prv=(pos+1)%2;
for(int num=0;num<=500;num++){
for(int prvDig=0;prvDig<10;prvDig++){
for(int firstUp=0;firstUp<2;firstUp++){
int res=0;
if(pos==lastRank-1)res=((num%M)==0);
else{
// »ÝÌÓÉJÚÂ\Èç1ðÁZ
res=((num%M)==0)&&(pos!=0);
for(int i=0;i<=9;i++){
// ÅÌ
ª0Å;ß
if(pos==0&&i==0)continue;
// OÌ
æèå«ÈéÌÝJÚ
bool ok=isCheckCond(firstUp,pos,prvDig,i);
if(pos==0){
res+=dp[prv][(i)%M][i][0];
res%=mod;
res+=dp[prv][(i)%M][i][1];
if(i%M==0)res--;
}
else if(ok)res+=dp[prv][(num*10+i)%M][i][firstUp];
}
}
dp[nxt][num][prvDig][firstUp]=res%mod;
}
}
}
}
return dp[0][0][0][0]%mod;
}
int solve2(string &s,int lastRank){
for(int pos=lastRank;pos>=0;pos--){
int nxt=pos%2;
int prv=(pos+1)%2;
for(int num=0;num<=500;num++){
for(int prvDig=0;prvDig<10;prvDig++){
for(int firstUp=0;firstUp<2;firstUp++){
for(int isSmaller=0;isSmaller<2;isSmaller++){
int res=0;
if(pos==lastRank)res=((num%M)==0);
else{
// »ÝÌÓÉJÚÂ\Èç1ðÁZ
for(int i=0;i<=9;i++){
// ÅÌ
ª0Å;ß
if(pos==0&&i==0)continue;
bool ok=isCheckCond(firstUp,pos,prvDig,i);
// OÌ
æèå«Èé,©Âsðz¦Ä¢È¢ÌÝJÚ
if(pos==0){
// ¡ñIðµ½
ªÇÌöxÌ嫳©
if(s[pos]-'0'==i){
res+=dp2[prv][(num*10+i)%M][i][0][0];
res%=mod;
res+=dp2[prv][(num*10+i)%M][i][1][0];
res%=mod;
}
if(s[pos]-'0'>i){
res+=dp2[prv][(num*10+i)%M][i][0][1];
res%=mod;
res+=dp2[prv][(num*10+i)%M][i][1][1];
res%=mod;
}
else if(s[pos]-'0'<i)break;
}
else if(ok){
if(isSmaller)res+=dp2[prv][(num*10+i)%M][i][firstUp][isSmaller];
else{
// ¯¶ÈçA»ÌÜÜ
if(s[pos]-'0'==i)res+=dp2[prv][(num*10+i)%M][i][firstUp][isSmaller];
// ¡ñIñ¾ªsÌæ謳¢ÈçÎ
else if(s[pos]-'0'>i)res+=dp2[prv][(num*10+i)%M][i][firstUp][1];
else if(s[pos]-'0'<i)break;
}
}
}
}
dp2[nxt][num][prvDig][firstUp][isSmaller]=res%mod;
}
}
}
}
}
return dp2[0][0][0][0][0]%mod;
}
int calc(string &A){
int a=0;
if(A.size()!=1){
a=solve1(A.size());
}
int b=0;
if(A.size()==1){
for(int i=1;i<=A[0]-'0';i++)if((i%M)==0)b++;
}
else{
b=solve2(A,A.size());
}
int res=(a+b)%mod;
return res;
}
int main(){
string A,B;
cin>>A>>B>>M;
// BȺÌàÌ©çAȺÌàÌðø
// AªàµWOUO©ÂMÌ{ÈçA»Ìªø
int a=calc(A);
int b=calc(B);
int res=(b-a+mod)%mod;
if(isZig(A)&&checkM(A))res++;
// res%=mod;
cout<<res<<endl;
return 0;
}
|
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
const int mod = 10000;
string a, b; int m, power[509], modm[6009], dp[509][11][2][509];
int solve(string s, int z) {
// [1, s]
int n = s.size();
int ret1 = 0;
for (int i = z; i < n - 1; i++) {
for (int j = 1; j <= 9; j++) ret1 += dp[i][j][z][0];
while (ret1 >= mod) ret1 -= mod;
}
int mod1 = 0;
for (int i = n - 1; i >= 0; i--) {
int r = s[i] - 48, tl = (i == n - 1 ? 1 : 0), tr = (i == 0 ? r : r - 1);
if (i != n - 1) {
if ((i + z) & 1) tl = max(tl, s[i + 1] - 48 + 1);
else tr = min(tr, s[i + 1] - 48 - 1);
}
for (int j = tl; j <= tr; j++) ret1 += dp[i][j][z][mod1];
while (ret1 >= mod) ret1 -= mod;
mod1 = (mod1 - r * power[i] + r * m) % m;
if (i != n - 1) {
if (((i + z) & 1) && s[i + 1] >= s[i]) break;
if (!((i + z) & 1) && s[i + 1] <= s[i]) break;
}
}
return ret1;
}
int main() {
cin >> a >> b >> m;
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
a[0]--;
for (int i = 0; i < a.size(); i++) {
if (a[i] < 48) {
a[i] += 10;
a[i + 1]--;
}
}
if (a.back() == 48) a.pop_back();
if (a == "") a = "0";
for (int i = 0; i <= 6000; i++) modm[i] = i % m;
power[0] = modm[1];
for (int i = 1; i <= 500; i++) power[i] = power[i - 1] * 10 % m;
for (int i = 0; i <= 9; i++) dp[0][i][0][i % m] = dp[0][i][1][i % m] = 1;
for (int i = 1; i <= 500; i++) {
for (int j = 0; j <= 9; j++) {
for (int k = 0; k < m; k++) {
int z = modm[k - j * power[i] + j * m];
if (i & 1) {
for (int l = 0; l < j; l++) dp[i][j][0][k] += dp[i - 1][l][0][z];
for (int l = 9; l > j; l--) dp[i][j][1][k] += dp[i - 1][l][1][z];
}
else {
for (int l = 9; l > j; l--) dp[i][j][0][k] += dp[i - 1][l][0][z];
for (int l = 0; l < j; l++) dp[i][j][1][k] += dp[i - 1][l][1][z];
}
while (dp[i][j][0][k] >= mod) dp[i][j][0][k] -= mod;
while (dp[i][j][1][k] >= mod) dp[i][j][1][k] -= mod;
}
}
}
int ret1 = (solve(a, 0) + solve(a, 1)) % mod;
int ret2 = (solve(b, 0) + solve(b, 1)) % mod;
cout << (ret2 - ret1 + mod) % mod << endl;
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
const int mod = 10000;
char const *limit;
int maxk, cut;
int memo[10][512][512][4];
inline int idx(bool up, bool down, bool high)
{
return ((up << 1) | (down << 0));
}
int search(int n, int k, int p, bool up, bool down, bool high)
{
int sum = 0;
if(k >= (maxk - 1))
return p == 0;
if(!high && memo[n][k][p][idx(up, down, high)] != -1)
return memo[n][k][p][idx(up, down, high)];
for(int i = 0; i < 10; ++i) {
if((n < i && !up) || (n == i) || (n > i && !down))
continue;
char c = limit[k + 1] - '0';
if(high && c < i)
continue;
bool nexthigh = high && (c == i);
sum += search(i, k + 1, (p * 10 + i) % cut, n > i, n < i, nexthigh);
}
sum = sum % mod;
if(!high)
memo[n][k][p][idx(up, down, high)] = sum;
return sum;
}
int search(char *str, int law)
{
int sum = 0;
int len = strlen(str);
bool start = false;
memset(memo[0][0][0], -1, 10 * 512 * 512 * 4 * sizeof(int));
maxk = len;
cut = law;
limit = str;
for(int i = 0; i < maxk; ++i) {
char c = limit[i] - '0';
if(!start && c == 0)
continue;
for(int j = 1; j < 10; ++j) {
if(!start && c < j)
continue;
bool nexthigh = !start && (c == j);
sum += search(j, i, j % cut, true, true, nexthigh);
}
start = true;
sum = sum % mod;
}
return sum;
}
int judge(char *str, int law)
{
int len = strlen(str);
bool start = false;
int p = 0;
bool up;
for(int i = 0; (i < (len - 1)) && (p != -1); ++i) {
char c1 = str[i] - '0', c2 = str[i + 1] - '0';
if(!start && c1 == 0)
continue;
p = (p * 10 + c1) % law;
if(start) {
if(up && c1 >= c2)
p = -1;
if(!up && c1 <= c2)
p = -1;
up = !up;
} else {
if(c1 == c2)
p = -1;
else
up = c1 > c2;
}
start = true;
}
if(p != -1)
p = (p * 10 + (str[len - 1] - '0')) % law;
return p == 0;
}
int main()
{
char a[512] = "00", b[512] = "00";
int m;
scanf("%s%s%d", a + 2, b + 2, &m);
int na, nb, ea;
na = search(a, m);
nb = search(b, m);
ea = judge(a, m);
int ans = (nb - na + ea + 5 * mod) % mod;
//printf("%d - %d + %d = %d\n", nb, na, ea, ans);
printf("%d\n", ans);
return 0;
}
|
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
#define MOD 10000
int M;
char A[503], B[503];
short dp[503][10][2][2][503];
void dec(char *t){
int n = strlen(t);
t[n - 1]--;
for(int i = n - 1; i > 0; i--){
if(t[i] < '0'){
t[i] += 10;
t[i - 1]--;
}
}
if(t[0] == '0'){
for(int i = 0; i < n; i++){
t[i] = t[i + 1];
}
}
}
int solve(char *t){
int n = strlen(t);
for(int i = 0; i < n; i++){
t[i] -= '0';
}
memset(dp, 0, sizeof(dp));
for(int i = 1; i <= t[0]; i++){
dp[1][i][0][i == t[0]][i % M] = 1;
if(n != 1){
dp[1][i][1][i == t[0]][i % M] = 1;
}
}
for(int i = 1; i < n; i++){
for(int next = 1; next <= 9; next++){
dp[i + 1][next][0][0][next % M]++;
dp[i + 1][next][0][0][next % M] %= MOD;
if(i != n - 1){
dp[i + 1][next][1][0][next % M]++;
dp[i + 1][next][1][0][next % M] %= MOD;
}
}
for(int before = 0; before <= 9; before++){
for(int up = 0; up < 2; up++){
for(int eq = 0; eq < 2; eq++){
int from = up ? 0 : before + 1;
int to = up ? before - 1 : 9;
if(eq) to = min(to, (int)t[i]);
for(int rem = 0; rem < M; rem++){
if(dp[i][before][up][eq][rem] == 0) continue;
for(int next = from; next <= to; next++){
int nextEq = eq && next == t[i];
int nextRem = (rem * 10 + next) % M;
dp[i + 1][next][!up][nextEq][nextRem] += dp[i][before][up][eq][rem];
dp[i + 1][next][!up][nextEq][nextRem] %= MOD;
}
}
}
}
}
}
int res = 0;
for(int before = 0; before <= 9; before++){
for(int up = 0; up < 2; up++){
for(int eq = 0; eq < 2; eq++){
if(dp[n][before][up][eq][0] == 0) continue;
//printf("before:%d up:%d eq:%d = %d\n",before,up,eq,dp[n][before][up][eq][0]);
res += dp[n][before][up][eq][0];
res %= MOD;
}
}
}
return res;
}
int main(){
while(scanf("%s%s%d", A, B, &M) != EOF){
dec(A);
printf("%d\n", (solve(B) - solve(A) + MOD) % MOD);
}
}
|
#include<algorithm>
#include<iostream>
#include<vector>
#include<map>
#include<cstring>
using namespace std;
const int MOD=10000;
vector < int > A,B;
int M;
int dp[505][10][3][505][2];
void sub1(vector<int> &q){
for(int i=q.size()-1; i>=0; --i){
if(q[i]==0){
q[i]=9;
} else {
--q[i];
return;
}
}
return;
}
int ZigZag(const vector<int> v,int idx,int prv,int updown,int mod,bool free){
if(idx==v.size()) return !mod;
if(~dp[idx][prv][updown][mod][free]) return dp[idx][prv][updown][mod][free];
int r=(free?9:v[idx]);
int ret=0;
for(int i=0; i<=r; ++i,ret%=MOD){
if(updown==0&&prv<=i) continue;
if(updown==1&&prv>=i) continue;
if(updown==2&&prv&&prv==i) continue;
int u;
if(updown==2){
if(prv==0){
u=2;
} else if(prv>i){
u=1;
} else {
u=0;
}
} else u=!updown;
ret+=ZigZag(v,idx+1,i,u,(mod*10+i)%M,free|(i!=v[idx]));
}
return dp[idx][prv][updown][mod][free]=ret%MOD;
}
int main(){
string a,b;
cin >> a >> b >> M;
for(int i=0; i<a.size(); ++i) A.push_back(a[i]-'0');
for(int j=0; j<b.size(); ++j) B.push_back(b[j]-'0');
sub1(A);
memset(dp,-1,sizeof(dp));
int ra=ZigZag(A,0,0,2,0,false);
memset(dp,-1,sizeof(dp));
int rb=ZigZag(B,0,0,2,0,false);
int ret=(rb-ra+MOD)%MOD;
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define all(v) begin(v), end(v)
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for(int i = (int)(s); i < (int)(n); i++)
//const int inf = 1LL << 55;
const int mod = 10000;//1e9 + 7;
string A, B;
int M;
// dp[index][islower][mod][zig-zag][prev]
int dp[501][2][500][3][10];
int solve(const string& s, int idx, int lt, int m, int zg, int prev)
{
if(idx == s.size()) return m == 0;
int& ret = dp[idx][lt][m][zg][prev];
if(~ret) return ret;
ret = 0;
int lim = lt ? 9 : s[idx]-'0';
rep(d, lim + 1) {
int zgzg = -1;//0;
if(zg == 0) { // start
if(prev == 0) zgzg = 0;
else if(d == prev) continue;
else if(d < prev) zgzg = 1;
else if(d > prev) zgzg = 2;
} else if(zg == 1) { // up
if(d <= prev) continue;
else zgzg = 2;
} else if(zg == 2) { // down
if(d >= prev) continue;
else zgzg = 1;
}
assert(zgzg != -1);
(ret += solve(s, idx+1, lt||d<lim, (m*10+d)%M, zgzg, d)) %= mod;
}
return ret % mod;
}
signed main()
{
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
cin >> A >> B >> M;
for(int i = (int)A.size()-1; i >= 0; i--) {
if(A[i] == '0') {
A[i] = '9';
} else {
A[i]--;
break;
}
}
memset(dp, -1, sizeof(dp));
int a = solve(A, 0, 0, 0, 0, 0);
memset(dp, -1, sizeof(dp));
int b = solve(B, 0, 0, 0, 0, 0);
cout << (b - a + mod) % mod << endl;
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
string A,B;
int M;
int dp[2][3][10][501][501];
int mod=10000;
int solve(string S,int f,int x,int pre,int rem,int index){
if(index==S.length()){
return !rem;
}
if(dp[f][x][pre][rem][index]!=-1)return dp[f][x][pre][rem][index];
int end;
if(f)end=9;
else end=S[index]-'0';
int res=0;
for(int u=0;u<=end;u++){
int nextx;
if(x==0){
if(pre!=0&&pre==u)continue;
if(pre==0)nextx=0;
else if(pre>u)nextx=1;
else nextx=2;
}
else if(x==1){
if(pre>=u)continue;
nextx=2;
}
else{
if(pre<=u)continue;
nextx=1;
}
res+=solve(S,f|(u!=(S[index]-'0')),nextx,u,(rem*10+u)%M,index+1);
}
res%=mod;
return dp[f][x][pre][rem][index]=res;
}
string ff(string S){
int pos=S.length()-1;
while(S[pos]=='0'){
S[pos]='9';
pos--;
}
S[pos]=(S[pos]-'0')-1+'0';
if(pos==0&&S[pos]=='0')S.erase(S.begin());
return S;
}
int main()
{
for(int i=0;i<3;i++)for(int j=0;j<10;j++)for(int k=0;k<501;k++)for(int l=0;l<501;l++)for(int m=0;m<2;m++)dp[m][i][j][k][l]=-1;
cin >> A >> B;scanf("%d",&M);
A=ff(A);
int ans1=solve(A,0,0,0,0,0);
for(int i=0;i<3;i++)for(int j=0;j<10;j++)for(int k=0;k<501;k++)for(int l=0;l<501;l++)for(int m=0;m<2;m++)dp[m][i][j][k][l]=-1;
int ans2=solve(B,0,0,0,0,0);
printf("%d\n",(ans2-ans1+mod)%mod);
return 0;
}
|
#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define pb push_back
int dy[]={0, 0, 1, -1, 1, 1, -1, -1};
int dx[]={1, -1, 0, 0, 1, -1, -1, 1};
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
#define mp make_pair
#define fi first
#define sc second
string A,B;
ll M;
ll dp[2][2][4][10][1000];
ll mod = 10000;
int main(){
cin >> A >> B;
cin >> M;
ll n = B.length();
dp[0][0][0][0][0] = 1;
REP(i,n) {
REP(j,2) {
REP(k,4) {
REP(l,10) {
REP(m,M) {
ll lim = (j ? 9 : B[i] - '0');
REP(d,lim + 1) {
if(k == 0) {
if(d == 0) {
(dp[1][j || d < lim][0][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
continue;
}
(dp[1][j || d < lim][1][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
}else if(k == 1) {
if(d == l) {
continue;
}
ll e = 2 + (d > l);
(dp[1][j || d < lim][e][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
}else if(k == 2) {
if(d <= l) {
continue;
}
(dp[1][j || d < lim][3][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
}else if(k == 3) {
if(d >= l) {
continue;
}
(dp[1][j || d < lim][2][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
}
}
}
}
}
}
REP(j,2) {
REP(k,4) {
REP(l,10) {
REP(m,M) {
dp[0][j][k][l][m] = dp[1][j][k][l][m];
dp[1][j][k][l][m] = 0;
}
}
}
}
}
ll ans = 0;
REP(j,2) {
REP(k,4) {
REP(l,10) {
(ans += dp[0][j][k][l][0]) %= mod;
}
}
}
n = A.length();
REP(j,2) {
REP(k,4) {
REP(l,10) {
REP(m,M) {
dp[0][j][k][l][m] = 0;
dp[1][j][k][l][m] = 0;
}
}
}
}
dp[0][0][0][0][0] = 1;
REP(i,n) {
REP(j,2) {
REP(k,4) {
REP(l,10) {
REP(m,M) {
ll lim = (j ? 9 : A[i] - '0');
REP(d,lim + 1) {
if(k == 0) {
if(d == 0) {
(dp[1][j || d < lim][0][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
continue;
}
(dp[1][j || d < lim][1][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
}else if(k == 1) {
if(d == l) {
continue;
}
ll e = 2 + (d > l);
(dp[1][j || d < lim][e][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
}else if(k == 2) {
if(d <= l) {
continue;
}
(dp[1][j || d < lim][3][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
}else if(k == 3) {
if(d >= l) {
continue;
}
(dp[1][j || d < lim][2][d][(m * 10 + d) % M] += dp[0][j][k][l][m]) %= mod;
}
}
}
}
}
}
REP(j,2) {
REP(k,4) {
REP(l,10) {
REP(m,M) {
dp[0][j][k][l][m] = dp[1][j][k][l][m];
dp[1][j][k][l][m] = 0;
}
}
}
}
}
REP(k,4) {
REP(l,10) {
(ans += mod - dp[0][1][k][l][0]) %= mod;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
int dp[501][10][500][2][3];
string str;
string a, b;
int m;
int dfs(int keta, int num, int mod, bool free, int state) {
if (keta == str.size()) return mod == 0;
if (dp[keta][num][mod][free][state] != -1) return dp[keta][num][mod][free][state];
int res = 0;
switch (state) {
case 0: // next up
FOR(i, num + 1, free ? 10 : str[keta] + 1)
res += dfs(keta + 1, i, (mod * 10 + i) % m, free | (!free && str[keta] != i), 1);
break;
case 1: // next down
REP(i, free ? num : min(num, str[keta] + 1))
res += dfs(keta + 1, i, (mod * 10 + i) % m, free | (!free && str[keta] != i), 0);
break;
case 2: // now zero
if (keta == str.size() - 1) return (free ? 9 : str[keta]) / m;
else res += dfs(keta + 1, 0, 0, true, 2);
FOR(i, 1, free ? 10 : str[keta] + 1) {
res += dfs(keta + 1, i, i % m, free | (!free && str[keta] != i), 0);
res += dfs(keta + 1, i, i % m, free | (!free && str[keta] != i), 1);
}
break;
}
return dp[keta][num][mod][free][state] = res % 10000;
}
int solve() {
fill(dp[0][0][0][0], dp[501][0][0][0], -1);
REP(i, str.size()) str[i] -= '0';
int res = dfs(0, 0, 0, false, 2);
return res;
}
int main() {
cin >> a >> b >> m;
for (int i = a.size() - 1; i >= 0; i--) {
if (a[i] == '0') a[i] = '9';
else {
a[i]--;
break;
}
}
if (a != "0" && a[0] == '0') a.erase(a.begin());
str = a;
int na = solve();
str = b;
int nb = solve();
cout << (nb - na + 10000) % 10000 << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <climits>
#include <string>
#include <vector>
#include <cmath>
using namespace std;
#define MOD 10000
//#define MOD 1145141919
string A, B;
int M;
int dp[510][10][2][3][2][510];
int f(string &X, int i, int L, int lc, bool d, int e, bool zero, int m) {
if (dp[i][lc][d][e][zero][m] != -1) return dp[i][lc][d][e][zero][m];
if (i == L-1) {
return dp[i][lc][d][e][zero][m] = (e == 2 ? 0 : zero ? 0 : m == 0);
}
int ret = 0;
for (int c=0; c<10; c++) {
int nz = false;
if (zero) {
if (c == 0) nz = true;
}
else {
if (d == 0 && lc <= c) continue;
if (d == 1 && lc >= c) continue;
}
int ne = e;
int h = (int)X[i+1] - (int)'0';
if (e == 1 && c < h) ne = 0;
if (e == 1 && c > h) ne = 2;
ret = (ret + f(X, i+1, L, c, !d, ne, nz, (m*10 + c) % M)) % MOD;
}
return dp[i][lc][d][e][zero][m] = ret;
}
void reset() {
for (int i=0; i<510; i++) {
for (int j=0; j<10; j++) {
for (int k=0; k<2; k++) {
for (int e=0; e<2; e++) {
for (int zero=0; zero<2; zero++) {
for (int l=0; l<510; l++) {
dp[i][j][k][e][zero][l] = -1;
}
}
}
}
}
}
}
int solve(string X) {
if (X.length() == 1) {
int t = (int)X[0] - (int)'0';
int x = 0;
for (int i=1; i<=t; i++) if (i % M == 0) x++;
return x;
}
int x = 0;
for (int i=1; i<10; i++) if (i % M == 0) x++;
int i = X[0] == '0';
int ans = -x;
reset();
int L = X.length();
for (int c=0; c<10; c++) {
int h = (int)X[i] - (int)'0';
int e = c < h ? 0 : (c == h ? 1 : 2);
ans = (ans + f(X, i, L, c, true , e, c == 0, c % M)) % MOD;
ans = (ans + f(X, i, L, c, false, e, c == 0, c % M)) % MOD;
}
return ans;
}
int main() {
cin >> A >> B >> M;
// A -= 1
int h = A.length() - 1;
while (true) {
if (A[h] > '0') {
A[h] = (char)((int)A[h]-1);
break;
}
A[h] = '9';
h -= 1;
}
cout << (solve(B) - solve(A) + MOD) % MOD << "\n";
return 0;
}
|
#include <cstdio>
#include <cstring>
using namespace std;
int dp[501][10][3][2][500];
char a[502],b[502],*s;
int alen,blen,slen,m;
int solve(int n,int pv,int ud,int ok,int md) {
if(n==slen)return !md;
if(dp[n][pv][ud][ok][md]>=0)return dp[n][pv][ud][ok][md];
int ret=0;
for(int i=0;i<=(ok?9:s[n]-'0');i++) {
if(ud==0 && pv<=i)continue;
if(ud==1 && pv>=i)continue;
if(ud==2 && pv!=0 && pv==i)continue;
int u;
if(ud==2) {
if(pv==0)u=2;
else if(pv>i)u=1;
else u=0;
}else{
u=ud^1;
}
ret+=solve(n+1,i,u,ok||(i!=(s[n]-'0')),(md*10+i)%m);
}
return dp[n][pv][ud][ok][md]=ret%10000;
}
int main() {
scanf("%s",a);
alen=strlen(a);
for(int i=alen-1;i>=0;i--) {
if(a[i]>='1') {
a[i]--;
for(int j=i+1;j<alen;j++)a[j]='9';
break;
}
}
if(alen>=2&&a[0]=='0') {
for(int i=1;i<=alen;i++)a[i-1]=a[i];
alen--;
}
scanf("%s",b);
blen=strlen(b);
scanf("%d",&m);
int aa,bb;
s=b,slen=blen;
memset(dp,-1,sizeof(dp));
bb=solve(0,0,2,0,0);
s=a,slen=alen;
memset(dp,-1,sizeof(dp));
aa=solve(0,0,2,0,0);
printf("%d\n",(bb+10000-aa)%10000);
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <complex>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
template<class T> inline T sqr(T x) {return x*x;}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define each(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define exist(s,e) ((s).find(e)!=(s).end())
#define range(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) range(i,0,n)
#define clr(a,b) memset((a), (b) ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF =1LL << 62;
const int inf =1 << 29;
const int mod=10000;
string decrease(string x){
for(int i=x.size()-1;i>=0;i--){
if(x[i]!='0'){
x[i]--;
if(x[i]=='0'&& i==0 &x.size()>1)
x=x.substr(1);
return x;
}else
x[i]='9';
}
return x;
}
int dp[501][500][10][2][3];
int solve(string s,int m){
int n=s.size();
clr(dp,0);
dp[0][0][0][0][0]=1;
rep(i,n)rep(j,m)rep(a,10)rep(b,2)rep(c,3){
int cur=s[i]-'0';
rep(l,10){
int nb=1;
if(!b){
if(cur<l) continue;
if(cur==l) nb=0;
}
int nc=0;
if(c==0){
if(a>0){
if(a==l) continue;
if(a<l)
nc=1;
else
nc=2;
}
}
if(c==1){
if(a<=l) continue;
nc=2;
}
if(c==2){
if(a>=l) continue;
nc=1;
}
int nj=(j*10+l)%m;
dp[i+1][nj][l][nb][nc]=(dp[i+1][nj][l][nb][nc]+dp[i][j][a][b][c]+mod)%mod;
}
}
int res=0;
rep(a,10)rep(b,2)rep(c,3) res=(res+dp[n][0][a][b][c]+mod)%mod;
return res;
}
int main(void){
string a,b;
cin >> a >> b;
int m;
cin >> m;
a=decrease(a);
int ans=(solve(b,m)-solve(a,m)+mod)%mod;
cout << ans << endl;
return 0;
}
|
#include <cstdio>
#include <cstring>
using namespace std;
int dp[501][10][3][2][500];
char a[502],b[502],*s;
int alen,blen,slen,m;
int solve(int n,int pv,int ud,int ok,int md) {
if(n==slen)return !md;
if(dp[n][pv][ud][ok][md]>=0)return dp[n][pv][ud][ok][md];
int ret=0;
for(int i=0;i<=(ok?9:s[n]-'0');i++) {
if(ud==0 && pv<=i)continue;
if(ud==1 && pv>=i)continue;
if(ud==2 && pv!=0 && pv==i)continue;
int u;
if(ud==2) {
if(pv==0)u=2;
else if(pv>i)u=1;
else u=0;
}else{
u=ud^1;
}
ret+=solve(n+1,i,u,ok||(i!=(s[n]-'0')),(md*10+i)%m);
}
return dp[n][pv][ud][ok][md]=ret%10000;
}
int main() {
scanf("%s",a);
alen=strlen(a);
for(int i=alen-1;i>=0;i--) {
if(a[i]>='1') {
a[i]--;
for(int j=i+1;j<alen;j++)a[j]='9';
break;
}
}
scanf("%s",b);
blen=strlen(b);
scanf("%d",&m);
int aa,bb;
s=b,slen=blen;
memset(dp,-1,sizeof(dp));
bb=solve(0,0,2,0,0);
s=a,slen=alen;
memset(dp,-1,sizeof(dp));
aa=solve(0,0,2,0,0);
printf("%d\n",(bb+10000-aa)%10000);
}
|
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
const int mod = 10000;
string a, b; int m, power[509], dp[509][11][2][509];
int solve(string s, int z) {
// [1, s]
int n = s.size();
int ret1 = 0;
for (int i = z; i < n - 1; i++) {
for (int j = 1; j <= 9; j++) ret1 += dp[i][j][z][0];
while (ret1 >= mod) ret1 -= mod;
}
int mod1 = 0;
for (int i = n - 1; i >= 0; i--) {
int r = s[i] - 48, tl = (i == n - 1 ? 1 : 0), tr = (i == 0 ? r : r - 1);
if (i != n - 1) {
if ((i + z) & 1) tl = max(tl, s[i + 1] - 48 + 1);
else tr = min(tr, s[i + 1] - 48 - 1);
}
for (int j = tl; j <= tr; j++) ret1 += dp[i][j][z][mod1];
while (ret1 >= mod) ret1 -= mod;
mod1 = (mod1 - r * power[i] + r * m) % m;
if (i != n - 1) {
if (((i + z) & 1) && s[i + 1] >= s[i]) break;
if (!((i + z) & 1) && s[i + 1] <= s[i]) break;
}
}
return ret1;
}
int main() {
cin >> a >> b >> m;
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
a[0]--;
for (int i = 0; i < a.size(); i++) {
if (a[i] < 48) {
a[i] += 10;
a[i + 1]--;
}
}
if (a.back() == 48) a.pop_back();
if (a == "") a = "0";
power[0] = 1 % m;
for (int i = 1; i <= 500; i++) power[i] = power[i - 1] * 10 % m;
for (int i = 0; i <= 9; i++) dp[0][i][0][i % m] = dp[0][i][1][i % m] = 1;
for (int i = 1; i <= 500; i++) {
for (int j = 0; j <= 9; j++) {
for (int k = 0; k < m; k++) {
int z = (k - j * power[i] + j * m) % m;
if (i & 1) {
for (int l = 0; l < j; l++) dp[i][j][0][k] += dp[i - 1][l][0][z];
for (int l = 9; l > j; l--) dp[i][j][1][k] += dp[i - 1][l][1][z];
}
else {
for (int l = 9; l > j; l--) dp[i][j][0][k] += dp[i - 1][l][0][z];
for (int l = 0; l < j; l++) dp[i][j][1][k] += dp[i - 1][l][1][z];
}
while (dp[i][j][0][k] >= mod) dp[i][j][0][k] -= mod;
while (dp[i][j][1][k] >= mod) dp[i][j][1][k] -= mod;
}
}
}
int ret1 = (solve(a, 0) + solve(a, 1)) % mod;
int ret2 = (solve(b, 0) + solve(b, 1)) % mod;
cout << (ret2 - ret1 + mod) % mod << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cstring>
using namespace std;
int M;
int dp[502][501][11][2];
int dp2[502][501][11][2][2];
const int mod=10000;
bool isCheckCond(int firstUp,int pos,int prvDig,int curDig){
bool ok=false;
if(firstUp){
if((pos%2)==1)ok=prvDig<curDig;
else ok=prvDig>curDig;
}
else{
if((pos%2)==0)ok=prvDig<curDig;
else ok=prvDig>curDig;
}
return ok;
}
bool checkM(string &s){
int sum=0;
for(int i=0;i<(int)s.size();i++){
sum+=s[i]-'0';
sum%=M;
}
return (sum==0);
}
bool isZig(string &s){
if(s.size()==1)return true;
bool firstUp=(s[1]-s[0]>0);
for(int i=1;i<(int)s.size();i++){
bool ok=isCheckCond(firstUp,i,s[i-1]-'0',s[i]-'0');
if(!ok)return false;
}
return true;
}
int solve1(int lastRank){
for(int pos=lastRank-1;pos>=0;pos--){
for(int num=0;num<=500;num++){
for(int prvDig=0;prvDig<10;prvDig++){
for(int firstUp=0;firstUp<2;firstUp++){
int res=0;
if(pos==lastRank-1)res=((num%M)==0);
else{
// »ÝÌÓÉJÚÂ\Èç1ðÁZ
res=((num%M)==0)&&(pos!=0);
for(int i=0;i<=9;i++){
// ÅÌ
ª0Å;ß
if(pos==0&&i==0)continue;
// OÌ
æèå«ÈéÌÝJÚ
bool ok=isCheckCond(firstUp,pos,prvDig,i);
if(pos==0){
res+=dp[pos+1][(i)%M][i][0];
res%=mod;
res+=dp[pos+1][(i)%M][i][1];
if(i%M==0)res--;
}
else if(ok)res+=dp[pos+1][(num*10+i)%M][i][firstUp];
}
}
dp[pos][num][prvDig][firstUp]=res%mod;
}
}
}
}
return dp[0][0][0][0]%mod;
}
int solve2(string &s,int lastRank){
for(int pos=lastRank;pos>=0;pos--){
for(int num=0;num<=500;num++){
for(int prvDig=0;prvDig<10;prvDig++){
for(int firstUp=0;firstUp<2;firstUp++){
for(int isSmaller=0;isSmaller<2;isSmaller++){
int res=0;
if(pos==lastRank)res=((num%M)==0);
else{
// »ÝÌÓÉJÚÂ\Èç1ðÁZ
for(int i=0;i<=9;i++){
// ÅÌ
ª0Å;ß
if(pos==0&&i==0)continue;
bool ok=isCheckCond(firstUp,pos,prvDig,i);
// OÌ
æèå«Èé,©Âsðz¦Ä¢È¢ÌÝJÚ
if(pos==0){
// ¡ñIðµ½
ªÇÌöxÌ嫳©
if(s[pos]-'0'==i){
res+=dp2[pos+1][(num*10+i)%M][i][0][0];
res%=mod;
res+=dp2[pos+1][(num*10+i)%M][i][1][0];
res%=mod;
}
if(s[pos]-'0'>i){
res+=dp2[pos+1][(num*10+i)%M][i][0][1];
res%=mod;
res+=dp2[pos+1][(num*10+i)%M][i][1][1];
res%=mod;
}
else if(s[pos]-'0'<i)break;
}
else if(ok){
if(isSmaller)res+=dp2[pos+1][(num*10+i)%M][i][firstUp][isSmaller];
else{
// ¯¶ÈçA»ÌÜÜ
if(s[pos]-'0'==i)res+=dp2[pos+1][(num*10+i)%M][i][firstUp][isSmaller];
// ¡ñIñ¾ªsÌæ謳¢ÈçÎ
else if(s[pos]-'0'>i)res+=dp2[pos+1][(num*10+i)%M][i][firstUp][1];
else if(s[pos]-'0'<i)break;
}
}
}
}
dp2[pos][num][prvDig][firstUp][isSmaller]=res%mod;
}
}
}
}
}
return dp2[0][0][0][0][0]%mod;
}
int calc(string &A){
int a=0;
if(A.size()!=1){
a=solve1(A.size());
}
int b=0;
if(A.size()==1){
for(int i=1;i<=A[0]-'0';i++)if((i%M)==0)b++;
}
else{
b=solve2(A,A.size());
}
int res=(a+b)%mod;
return res;
}
int main(){
string A,B;
cin>>A>>B>>M;
// BȺÌàÌ©çAȺÌàÌðø
// AªàµWOUO©ÂMÌ{ÈçA»Ìªø
int a=calc(A);
int b=calc(B);
int res=(b-a+mod)%mod;
if(isZig(A)&&checkM(A))res++;
// res%=mod;
cout<<res<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int M;
int memo[512][16][512][4][2];
string limit;
int f(int pos , int digit , int mod , int up , int free){
if(pos == -1) return (mod == 0);
if(memo[pos][digit][mod][up][free] != -1) return memo[pos][digit][mod][up][free];
int ans = 0;
if(up != 2){
if(up){
for(int i = digit+1 ; i <= (free?9:limit[pos]) ; i++){
ans += f(pos-1,i,(mod*10+i)%M,up^1,free||(i < limit[pos]));
}
}else{
for(int i = (free?digit-1:min((int)limit[pos],digit-1)) ; i >= 0 ; i--){
ans += f(pos-1,i,(mod*10+i)%M,up^1,free||(i < limit[pos]));
}
}
}else{
ans += f(pos-1,0,(mod*10+0)%M,2,free||(0 < limit[pos]));
for(int i = 1 ; i <= (free?9:limit[pos]) ; i++){
ans += f(pos-1,i,(mod*10+i)%M,0,free||(i < limit[pos]));
if(pos != 0) ans += f(pos-1,i,(mod*10+i)%M,1,free||(i < limit[pos]));
}
}
ans %= 10000;
return memo[pos][digit][mod][up][free] = ans;
}
int solve(string n){
memset(memo,-1,sizeof(memo));
limit = "0" + n;
reverse(limit.begin(),limit.end());
for(int i = 0 ; i < limit.size() ; i++) limit[i] -= '0';
return f(limit.size()-1,0,0,2,0) - 1;
}
int zig(string s){
if(s.size() == 1) return true;
if(s[0] == s[1]) return false;
if(s.size() == 2) return s[0] != s[1];
int up = s[0] > s[1];
for(int i = 2 ; i < s.size() ; i ++){
if( s[i-1] == s[i] || (up && s[i-1] >= s[i]) || (!up && s[i-1] <= s[i]) ) return false;
up^=1;
}
return true;
}
int main(){
string A,B;
cin >> A >> B >> M;
cout << ( solve(B) - solve(A) + zig(A) + 100000) % 10000 << endl;
}
|
// g++ -std=c++17 -O3 -fmax-errors=1 -fsanitize=undefined
#include <bits/stdc++.h>
using namespace std;
#define fst first
#define snd second
#define all(c) ((c).begin()), ((c).end())
#define TEST(s) if (!(s)) { cout << __LINE__ << " " << #s << endl; exit(-1); }
// state = x : x == n % mod
struct ModuloAutomaton {
int mod;
ModuloAutomaton(int mod) : mod(mod) { }
int init() { return 0; }
int size() { return mod; }
int next(int state, int a) { return (10 * state + a) % mod; }
bool accept(int state) { return state == 0; }
};
// state = 0 : empty
// 1 : fail
// 2 ... 10 : singleton and last number is state-1
// 11 ... 19 : increased and last number is state-10
// 20 ... 28 : decreased and last number is state-20
struct ZigZagAutomaton {
int init() { return 0; }
int size() { return 29; }
int next(int state, int a) {
if (state == 0) return a == 0 ? 0 : a + 1;
if (state == 1) return 1;
if (state <= 10) {
int last = state - 1;
if (a > last) return a + 10;
else if (a < last) return a + 20;
} else if (state <= 19) {
int last = state - 10;
if (a < last) return a + 20;
} else if (state <= 28) {
int last = state - 20;
if (a > last) return a + 10;
}
return 1;
}
bool accept(int state) { return state != 1; }
};
struct Automaton {
vector<vector<int>> trans;
vector<bool> is_accept;
int init() { return 0; }
int next(int state, int a) { return trans[state][a]; }
bool accept(int state) { return is_accept[state]; }
int size() { return trans.size(); }
};
template <class Automaton1, class Automaton2>
Automaton intersectionAutomaton(Automaton1 A, Automaton2 B) {
Automaton M;
vector<vector<int>> table(A.size(), vector<int>(B.size(), -1));
vector<int> x = {A.init()}, y = {B.init()};
table[x[0]][y[0]] = 0;
for (int i = 0; i < x.size(); ++i) {
M.trans.push_back(vector<int>(10, -1));
M.is_accept.push_back(A.accept(x[i]) && B.accept(y[i]));
for (int a = 0; a <= 9; ++a) {
int u = A.next(x[i], a), v = B.next(y[i], a);
if (table[u][v] == -1) {
table[u][v] = x.size();
x.push_back(u);
y.push_back(v);
}
M.trans[i][a] = table[u][v];
}
}
return M;
}
template <class Automaton>
int digitDP(string num, Automaton A, int eq = 1) {
int n = num.size();
vector<vector<vector<int>>> dp(n+1);
dp[0] = vector<vector<int>>(2, vector<int>(A.size()));
dp[0][1][A.init()] = 1;
auto addTo = [&](int &x, int y) {
if ((x += y) >= 10000) x -= 10000;
};
for (int i = 0; i < n; ++i) {
dp[i+1] = vector<vector<int>>(2, vector<int>(A.size()));
for (int tight = 0; tight <= 1; ++tight) {
for (int state = 0; state < A.size(); ++state) {
if (dp[i][tight][state] == 0) continue;
int lim = (tight ? num[i] - '0' : 9);
for (int d = 0; d <= lim; ++d) {
int tight_ = tight && d == lim;
int state_ = A.next(state, d);
addTo(dp[i+1][tight_][state_], dp[i][tight][state]);
}
}
}
dp[i].clear();
}
int ans = 0;
for (int tight = 0; tight <= eq; ++tight)
for (int state = 0; state < A.size(); ++state)
if (A.accept(state)) addTo(ans, dp[n][tight][state]);
return ans;
}
template <class Automaton>
int debug(string num, Automaton A) {
function<void(int,int,int,string)> rec
= [&](int i, int tight, int state, string s) {
if (i == num.size()) {
if (A.accept(state)) cout << s << endl;
return;
}
int lim = (tight ? num[i] - '0' : 9);
for (int d = 0; d <= lim; ++d) {
int tight_ = tight && d == lim;
int state_ = A.next(state, d);
s.push_back('0' + d);
rec(i+1, tight_, state_, s);
s.pop_back();
}
};
rec(0, 1, A.init(), "");
}
void AOJ_ZIGZAG() {
char A[1000], B[1000];
int M;
scanf("%s %s %d", A, B, &M);
ZigZagAutomaton zigzag;
ModuloAutomaton modulo(M);
auto IM = intersectionAutomaton(zigzag, modulo);
int a = digitDP(A, IM, 0);
int b = digitDP(B, IM, 1);
cout << (b + (10000 - a)) % 10000 << endl;
}
int main() { AOJ_ZIGZAG(); }
|
#include <iostream>
#include <string>
#include <cstring>
#define MOD 10000
using namespace std;
string a,b;
int M, dp[502][2][10][3][500], mod=10000, ans=0;
//dp[何桁目を見ているか][自由に選べるか][今の桁の数字][今で下がるか上がるか][今の桁までの余り]
//1で前より上がる、2で前より下がる、0で未変化
//0で自由に選べない、1で自由に選べる
//dp[0][][][][] is unused
int solve ()
{
if (a=="0") return 0; //0なので最後で-1してはならない
ans=0;
memset(dp, 0, sizeof(dp));
for (int i=0; i<=a[0]-'0'; i++)
{
if (i!=a[0]-'0') dp[1][1][i][0][i%M]=1;
else dp[1][0][i][0][i%M]=1;
}
for (int i=1; i<a.size(); i++) //今何桁目を見ているか
{
//b=0 まだ自由には使えないので今の桁の数字はaの同じ桁の所の数字より小さいまたは同じでなければいけない
for (int j=0; j<=a[i]-'0'; j++) //次の桁になれる数字（aを越えない）
{
for (int k=0; k<=a[i-1]-'0'; k++) //今の桁の数字としてありえる数（このセクションでは数字は自由に使えないので前の数字として全てが考えられるわけではない）
{
for (int l=0; l<3; l++) //今回上昇するか下降するかそのままか
{
for (int m=0; m<M; m++) //今の桁までの余りとして考えられる数字
{
if (l==0) //前と比べて上下していない
{
if (k==0) //今の数字が0で今回も増減しないのでまだ桁がジグザグまで達していない
{
if (j==a[i]-'0') //次の桁で限界まで取るので自由に選べない
{
//初めの桁なので増減していないとみなせる
dp[i+1][0][j][0][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
}
else //今の桁で自由になる（限界まで取らない）
{
dp[i+1][1][j][0][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
}
}
else //今の数字は0じゃない＝＝ジグザグはもう始まっている
{
if (j<k) //次の数字は今のよりも小さい
{
if (j==a[i]-'0') dp[i+1][0][j][2][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
else dp[i+1][1][j][2][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
}
//次と今が同じだったらアウトなのでパス
if (j>k) //次の数字は今のより大きい
{
if (j==a[i]-'0') dp[i+1][0][j][1][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
else dp[i+1][1][j][1][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
}
}
}
if (l==1) //今に至るときに増加したので次は減少
{
if (j<k)
{
if (j==a[i]-'0') dp[i+1][0][j][2][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
else dp[i+1][1][j][2][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
}
}
if (l==2) //今減少、次増加
{
if (j>k)
{
if (j==a[i]-'0') dp[i+1][0][j][1][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
else dp[i+1][1][j][1][(m*10+j)%M]+=dp[i][0][k][l][m]%mod;
}
}
}
}
}
}
//今回で自由に使えるようにする (b=1)
for (int j=0; j<=9; j++) //自由なので次に使う数字は何でもいい
{
for (int k=0; k<=9; k++) //もし一つ前が自由じゃなかったとしてもそこには何も入っていないのでセーフ
{
for (int l=0; l<3; l++)
{
for (int m=0; m<M; m++)
{
if (l==0)
{
if (k==0) dp[i+1][1][j][0][(m*10+j)%M]+=dp[i][1][k][l][m]%mod;
else
{
if (j<k) dp[i+1][1][j][2][(m*10+j)%M]+=dp[i][1][k][l][m]%mod;
if (j>k) dp[i+1][1][j][1][(m*10+j)%M]+=dp[i][1][k][l][m]%mod;
}
}
if (l==1)
{
if (j<k) dp[i+1][1][j][2][(m*10+j)%M]+=dp[i][1][k][l][m]%mod;
}
if (l==2)
{
if (j>k) dp[i+1][1][j][1][(m*10+j)%M]+=dp[i][1][k][l][m]%mod;
}
}
}
}
}
}
for (int i=0; i<2; i++) for (int j=0; j<=9; j++) for (int k=0; k<3; k++) ans+=dp[a.size()][i][j][k][0];
return (ans-1)%mod; //全て0の場合を引く
}
int main()
{
cin>>a>>b>>M;
int zig_a=0, zig_b=0;
for (int i=a.size()-1; i>=0; i--)
{
if (a[i]>'0')
{
a[i]--;
break;
}
else a[i]='9';
}
if (a[0]=='0' && a.size()!=1) a=a.substr(1,a.size()-1);
zig_a=solve();
a=b;
zig_b=solve();
cout<<(zig_b-zig_a+mod)%mod<<'\n';
return 0;
}
|
#include<iostream>
#include<string>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;
int x[555][555][11][2];
int y[555][555][11][2];
int main() {
//init.
string n, m;
int N[555];
int M[555];
int giri[555][3][4];
int girix[2];
bool giriy[2];
int a = 0, b = 0, c = 0, d = 0, e, sum, sum2;
memset(giri, 0, sizeof(giri));
memset(x, 0, sizeof(x));
char T[10] = { '0','1','2','3','4','5','6','7','8','9' };
cin >> n >> m;
cin >> c;
for (int i = 1; i <= n.size(); i++) {
for (int j = 0; j < 10; j++) {
if (n[i - 1] == T[j]) {
N[i] = j;
}
}
giri[i][0][0] = (giri[i - 1][0][0] * 10 + N[i]) % c;
giri[i][0][1] = N[i];
if (i >= 2) {
if (N[i] > N[i - 1]) {
giri[i][0][2] = 1;
}
else if (N[i - 1] > N[i]) {
giri[i][0][2] = 2;
}
else {
giri[i][0][2] = 0;
}
}
}
for (int i = 1; i <= m.size(); i++) {
for (int j = 0; j < 10; j++) {
if (m[i - 1] == T[j]) {
M[i] = j;
}
}
giri[i][1][0] = (giri[i - 1][1][0] * 10 + M[i]) % c;
giri[i][1][1] = M[i];
if (i >= 2) {
if (M[i] > M[i - 1]) {
giri[i][1][2] = 1;
}
else if (M[i - 1] > M[i]) {
giri[i][1][2] = 2;
}
else {
giri[i][1][2] = 0;
}
}
}
if (giri[1][0][1] > giri[2][0][1]) {
giriy[0] = true;
}
else if (giri[2][0][1] > giri[1][0][1]) {
giriy[0] = false;
}
else {
girix[0] = 1;
}
if (giri[1][1][1] > giri[2][1][1]) {
giriy[1] = true;
}
else if (giri[2][1][1] > giri[1][1][1]) {
giriy[1] = false;
}
else {
girix[1] = 1;
}
girix[0] = n.size() + 1;
for (int i = 3; i <= n.size(); i++) {
if (girix[0] <= i) {
break;
}
if (i % 2 == 1) {
if (giriy[0] == false) {
if (giri[i][0][1] >= giri[i - 1][0][1]) {
girix[0] = i;
}
}
else {
if (giri[i][0][1] <= giri[i - 1][0][1]) {
girix[0] = i;
}
}
}
else {
if (giriy[0] == false) {
if (giri[i][0][1] <= giri[i - 1][0][1]) {
girix[0] = i;
}
}
else {
if (giri[i][0][1] >= giri[i - 1][0][1]) {
girix[0] = i;
}
}
}
}
girix[1] = m.size() + 1;
for (int i = 3; i <= m.size(); i++) {
if (girix[1] <= i) {
break;
}
if (i % 2 == 1) {
if (giriy[1] == false) {
if (giri[i][1][1] >= giri[i - 1][1][1]) {
girix[1] = i;
}
}
else {
if (giri[i][1][1] <= giri[i - 1][1][1]) {
girix[1] = i;
}
}
}
else {
if (giriy[1] == false) {
if (giri[i][1][1] <= giri[i - 1][1][1]) {
girix[1] = i;
}
}
else {
if (giri[i][1][1] >= giri[i - 1][1][1]) {
girix[1] = i;
}
}
}
}
//1st.
for (int i = 1; i < 10; i++) {
if (giri[1][0][1] >= i || n.size() >= 2) {
x[1][i%c][i][0] += 1;
}
}
for (int i = 1; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (i > j) {
x[2][(i * 10 + j) % c][j][0] += 1;
}
else if (i < j) {
x[2][(i * 10 + j) % c][j][1] += 1;
}
}
}
for (int i = 3; i < n.size(); i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < 10; k++) {
if (i % 2 == 0) {
for (int l = 0; l < k; l++) {
x[i][(j * 10 + l) % c][l][0] += x[i - 1][j][k][0];
x[i][(j * 10 + l) % c][l][0] %= 10000;
}
}
else {
for (int l = k + 1; l < 10; l++) {
x[i][(j * 10 + l) % c][l][0] += x[i - 1][j][k][0];
x[i][(j * 10 + l) % c][l][0] %= 10000;
}
}
}
}
}
for (int i = 3; i < n.size(); i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < 10; k++) {
if (i % 2 == 1) {
for (int l = 0; l < k; l++) {
x[i][(j * 10 + l) % c][l][1] += x[i - 1][j][k][1];
x[i][(j * 10 + l) % c][l][1] %= 10000;
}
}
else {
for (int l = k + 1; l < 10; l++) {
x[i][(j * 10 + l) % c][l][1] += x[i - 1][j][k][1];
x[i][(j * 10 + l) % c][l][1] %= 10000;
}
}
}
}
}
sum = 0;
if (n.size() >= 3) {
for (int i = 1; i < n.size(); i++) {
for (int j = 0; j < 10; j++) {
sum += x[i][0][j][1];
sum += x[i][0][j][0];
}
}
}
else {
for (int i = 1; i <= n.size(); i++) {
for (int j = 0; j < 10; j++) {
sum += x[i][0][j][1];
sum += x[i][0][j][0];
}
}
}
memset(x, 0, sizeof(x));
for (int i = 1; i < 10; i++) {
x[1][i%c][i][0] += 1;
}
for (int i = 1; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (i > j) {
x[2][(i * 10 + j) % c][j][0] += 1;
}
else if (i < j) {
x[2][(i * 10 + j) % c][j][1] += 1;
}
}
}
for (int i = 3; i < m.size(); i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < 10; k++) {
if (i % 2 == 0) {
for (int l = 0; l < k; l++) {
x[i][(j * 10 + l) % c][l][0] += x[i - 1][j][k][0];
x[i][(j * 10 + l) % c][l][0] %= 10000;
}
}
else {
for (int l = k + 1; l < 10; l++) {
x[i][(j * 10 + l) % c][l][0] += x[i - 1][j][k][0];
x[i][(j * 10 + l) % c][l][0] %= 10000;
}
}
}
}
}
for (int i = 3; i < m.size(); i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < 10; k++) {
if (i % 2 == 1) {
for (int l = 0; l < k; l++) {
x[i][(j * 10 + l) % c][l][1] += x[i - 1][j][k][1];
x[i][(j * 10 + l) % c][l][1] %= 10000;
}
}
else {
for (int l = k + 1; l < 10; l++) {
x[i][(j * 10 + l) % c][l][1] += x[i - 1][j][k][1];
x[i][(j * 10 + l) % c][l][1] %= 10000;
}
}
}
}
}
sum2 = 0;
if (m.size() >= 3) {
for (int i = 1; i < m.size(); i++) {
for (int j = 0; j < 10; j++) {
sum2 += x[i][0][j][1];
sum2 += x[i][0][j][0];
}
}
}
else {
for (int i = 1; i <= m.size(); i++) {
for (int j = 0; j < 10; j++) {
sum2 += x[i][0][j][1];
sum2 += x[i][0][j][0];
}
}
}
//2nd.
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
for (int i = 1; i < 10; i++) {
if (giri[1][0][1]>i) {
x[1][i%c][i][0] += 1;
}
if (giri[1][0][1] == i) {
y[1][i%c][i][0] += 1;
}
}
for (int i = 1; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (i > j) {
x[2][(i*10+j)%c][j][0] += x[1][i%c][i][0];
if (j < giri[2][0][1]) {
x[2][(i * 10 + j) % c][j][0] += y[1][i%c][i][0];
}
else if (j == giri[2][0][1]) {
y[2][(i * 10 + j) % c][j][0] += y[1][i%c][i][0];
}
}
else if (i < j) {
x[2][(i * 10 + j) % c][j][1] += x[1][i%c][i][0];
if (j < giri[2][0][1]) {
x[2][(i * 10 + j) % c][j][1] += y[1][i%c][i][0];
}
else if (j == giri[2][0][1]) {
y[2][(i * 10 + j) % c][j][1] += y[1][i%c][i][0];
}
}
}
}
for (int i = 3; i <= n.size(); i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < 10; k++) {
if (i % 2 == 0) {
for (int l = 0; l < k; l++) {
x[i][(j * 10 + l) % c][l][0] += x[i - 1][j][k][0];
if (l < giri[i][0][1]) {
x[i][(j * 10 + l) % c][l][0] += y[i - 1][j][k][0];
}
else if (l == giri[i][0][1]) {
y[i][(j * 10 + l) % c][l][0] += y[i - 1][j][k][0];
}
x[i][(j * 10 + l) % c][l][0] %= 10000;
y[i][(j * 10 + l) % c][l][0] %= 10000;
}
}
else {
for (int l = k+1; l < 10; l++) {
x[i][(j * 10 + l) % c][l][0] += x[i - 1][j][k][0];
if (l < giri[i][0][1]) {
x[i][(j * 10 + l) % c][l][0] += y[i - 1][j][k][0];
}
else if (l == giri[i][0][1]) {
y[i][(j * 10 + l) % c][l][0] += y[i - 1][j][k][0];
}
x[i][(j * 10 + l) % c][l][0] %= 10000;
y[i][(j * 10 + l) % c][l][0] %= 10000;
}
}
}
}
}
for (int i = 3; i <= n.size(); i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < 10; k++) {
if (i % 2 == 1) {
for (int l = 0; l < k; l++) {
x[i][(j * 10 + l) % c][l][1] += x[i - 1][j][k][1];
if (l < giri[i][0][1]) {
x[i][(j * 10 + l) % c][l][1] += y[i - 1][j][k][1];
}
else if (l == giri[i][0][1]) {
y[i][(j * 10 + l) % c][l][1] += y[i - 1][j][k][1];
}
x[i][(j * 10 + l) % c][l][1] %= 10000;
y[i][(j * 10 + l) % c][l][1] %= 10000;
}
}
else {
for (int l = k + 1; l < 10; l++) {
x[i][(j * 10 + l) % c][l][1] += x[i - 1][j][k][1];
if (l < giri[i][0][1]) {
x[i][(j * 10 + l) % c][l][1] += y[i - 1][j][k][1];
}
else if (l == giri[i][0][1]) {
y[i][(j * 10 + l) % c][l][1] += y[i - 1][j][k][1];
}
x[i][(j * 10 + l) % c][l][1] %= 10000;
y[i][(j * 10 + l) % c][l][1] %= 10000;
}
}
}
}
}
if (n.size() >= 3) {
for (int i = 0; i < 10; i++) {
sum += x[n.size()][0][i][0];
sum += x[n.size()][0][i][1];
sum += y[n.size()][0][i][0];
sum += y[n.size()][0][i][1];
}
}
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
for (int i = 1; i < 10; i++) {
if (giri[1][1][1]>i) {
x[1][i%c][i][0] += 1;
}
if (giri[1][1][1] == i) {
y[1][i%c][i][0] += 1;
}
}
for (int i = 1; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (i > j) {
x[2][(i * 10 + j) % c][j][0] += x[1][i%c][i][0];
if (j < giri[2][1][1]) {
x[2][(i * 10 + j) % c][j][0] += y[1][i%c][i][0];
}
else if (j == giri[2][1][1]) {
y[2][(i * 10 + j) % c][j][0] += y[1][i%c][i][0];
}
}
else if (i < j) {
x[2][(i * 10 + j) % c][j][1] += x[1][i%c][i][0];
if (j < giri[2][1][1]) {
x[2][(i * 10 + j) % c][j][1] += y[1][i%c][i][0];
}
else if (j == giri[2][1][1]) {
y[2][(i * 10 + j) % c][j][1] += y[1][i%c][i][0];
}
}
}
}
for (int i = 3; i <= m.size(); i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < 10; k++) {
if (i % 2 == 0) {
for (int l = 0; l < k; l++) {
x[i][(j * 10 + l) % c][l][0] += x[i - 1][j][k][0];
if (l < giri[i][1][1]) {
x[i][(j * 10 + l) % c][l][0] += y[i - 1][j][k][0];
}
else if (l == giri[i][1][1]) {
y[i][(j * 10 + l) % c][l][0] += y[i - 1][j][k][0];
}
x[i][(j * 10 + l) % c][l][0] %= 10000;
y[i][(j * 10 + l) % c][l][0] %= 10000;
}
}
else {
for (int l = k + 1; l < 10; l++) {
x[i][(j * 10 + l) % c][l][0] += x[i - 1][j][k][0];
if (l < giri[i][1][1]) {
x[i][(j * 10 + l) % c][l][0] += y[i - 1][j][k][0];
}
else if (l == giri[i][1][1]) {
y[i][(j * 10 + l) % c][l][0] += y[i - 1][j][k][0];
}
x[i][(j * 10 + l) % c][l][0] %= 10000;
y[i][(j * 10 + l) % c][l][0] %= 10000;
}
}
}
}
}
for (int i = 3; i <= m.size(); i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < 10; k++) {
if (i % 2 == 1) {
for (int l = 0; l < k; l++) {
x[i][(j * 10 + l) % c][l][1] += x[i - 1][j][k][1];
if (l < giri[i][1][1]) {
x[i][(j * 10 + l) % c][l][1] += y[i - 1][j][k][1];
}
else if (l == giri[i][1][1]) {
y[i][(j * 10 + l) % c][l][1] += y[i - 1][j][k][1];
}
x[i][(j * 10 + l) % c][l][1] %= 10000;
y[i][(j * 10 + l) % c][l][1] %= 10000;
}
}
else {
for (int l = k + 1; l < 10; l++) {
x[i][(j * 10 + l) % c][l][1] += x[i - 1][j][k][1];
if (l < giri[i][1][1]) {
x[i][(j * 10 + l) % c][l][1] += y[i - 1][j][k][1];
}
else if (l == giri[i][1][1]) {
y[i][(j * 10 + l) % c][l][1] += y[i - 1][j][k][1];
}
x[i][(j * 10 + l) % c][l][1] %= 10000;
y[i][(j * 10 + l) % c][l][1] %= 10000;
}
}
}
}
}
if (m.size() >= 3) {
for (int i = 0; i < 10; i++) {
sum2 += x[m.size()][0][i][0];
sum2 += x[m.size()][0][i][1];
sum2 += y[m.size()][0][i][0];
sum2 += y[m.size()][0][i][1];
}
}
if (m.size() >= 490 && m.size()%2==1) {
sum2 += 1;
}
cout << (sum2 - sum+10000000) % 10000 << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define MOD 10000
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
typedef pair<int, int>P;
int dp1[502][2][10][500][3], dp2[502][2][10][500][3], m;
void solve(int dp[][2][10][500][3], string&a) {
dp[0][0][0][0][0] = 1;
rep(i, a.size())rep(j, 2)rep(k, 10)rep(l, m)rep(d, 3) {
int s, g, p = a[i] - '0';
if (d == 1) { s = k + 1; g = (j ? 9 : p); }
else if (d == 2) { s = 0; g = (j ? k - 1 : min(k - 1, p)); }
else { s = 0; g = (j ? 9 : p); }
for (int x = s; x <= g; x++) {
if (x&&k == x)continue;
int y;
if (d == 1)y = 2;
else if (d == 2)y = 1;
else {
if (k == 0)y = 0;
else if (x < k)y = 1;
else y = 2;
}
(dp[i + 1][j || x < p][x][(l * 10 + x) % m][y] += dp[i][j][k][l][d]) %= MOD;
}
}
}
int main() {
string a, b; cin >> a >> b >> m;
int d = a.size() - 1;
while (a[d] == '0') {
a[d] = '9'; d--;
}
a[d]--;
if (*a.begin() == '0'&&a.size() > 1)a = a.substr(1);
solve(dp1, a); solve(dp2, b);
int sum1 = 0, sum2 = 0;
rep(i, 2)rep(j, 10)rep(t, 3) {
(sum1 += dp1[a.size()][i][j][0][t]) %= MOD;
(sum2 += dp2[b.size()][i][j][0][t]) %= MOD;
}
printf("%d\n", (sum2 + MOD - sum1) % MOD);
}
|
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
typedef long long int ll;
static const int MAX_LEN = 501;
static const int MAX_M = 500;
string A, B;
int M;
int memo[MAX_LEN][10][MAX_M][3][2];
int solve(string S){
if(S == "0") return 0;
int sum[MAX_LEN];
fill(sum, sum + S.length(), 0);
for(int i = 0; i < S.length(); i++){
if(i == 0){
sum[i] = S[i] - '0';
}else{
sum[i] = (sum[i - 1] * 10 + (S[i] - '0'));
}
sum[i] %= M;
}
for(int i = 0; i < S.length(); i++){
for(int j = 0; j < 10; j++){
for(int k = 0; k < M; k++){
for(int l = 0; l < 3; l++){
for(int m = 0; m < 2; m++){
memo[i][j][k][l][m] = 0;
}
}
}
}
}
for(int i = 1; i <= S[0] - '0'; i++){
if(i == S[0] - '0'){
memo[0][i][i % M][2][1]++;
}else{
memo[0][i][i % M][2][0]++;
}
}
for(int i = 1; i < S.length(); i++){
for(int j = 1; j < 10; j++){
memo[i][j][j % M][2][0]++;
}
for(int j = 0; j < M; j++){
for(int k = 0; k < 10; k++){
for(int l = 0; l < 10; l++){
if(l > k){
memo[i][l][(j * 10 + l) % M][1][0] += memo[i - 1][k][j][0][0];
memo[i][l][(j * 10 + l) % M][1][0] += memo[i - 1][k][j][2][0];
memo[i][l][(j * 10 + l) % M][1][0] %= 10000;
}else if(l < k){
memo[i][l][(j * 10 + l) % M][0][0] += memo[i - 1][k][j][1][0];
memo[i][l][(j * 10 + l) % M][0][0] += memo[i - 1][k][j][2][0];
memo[i][l][(j * 10 + l) % M][0][0] %= 10000;
}
}
}
}
for(int j = 0; j < S[i] - '0'; j++){
if(j > (S[i - 1] - '0')){
memo[i][j][(sum[i - 1] * 10 + j) % M][1][0] += (memo[i - 1][S[i - 1] - '0'][sum[i - 1]][0][1] + memo[i - 1][S[i - 1] - '0'][sum[i - 1]][2][1]);
}else if(j < (S[i - 1] - '0')){
memo[i][j][(sum[i - 1] * 10 + j) % M][0][0] += (memo[i - 1][S[i - 1] - '0'][sum[i - 1]][1][1] + memo[i - 1][S[i - 1] - '0'][sum[i - 1]][2][1]);
}
}
if(S[i] > S[i - 1]){
memo[i][S[i] - '0'][sum[i]][1][1] = (memo[i - 1][S[i - 1] - '0'][sum[i - 1]][0][1] + memo[i - 1][S[i - 1] - '0'][sum[i - 1]][2][1]);
}else if(S[i] < S[i - 1]){
memo[i][S[i] - '0'][sum[i]][0][1] = (memo[i - 1][S[i - 1] - '0'][sum[i - 1]][1][1] + memo[i - 1][S[i - 1] - '0'][sum[i - 1]][2][1]);
}
}
int res = 0;
for(int i = 0; i < 3; i++){
for(int j = 0; j < 10; j++){
res += memo[S.length() - 1][j][0][i][0];
}
res += memo[S.length() - 1][S[S.length() - 1] - '0'][0][i][1];
}
return res % 10000;
}
int main(){
cin >> A >> B >> M;
reverse(A.begin(), A.end());
for(int i = 0; i < A.length(); i++){
if(A[i] != '0'){
A[i]--;
break;
}else A[i] = '9';
}
if(A[A.length() - 1] == '0' && A != "0") A.erase(A.begin() + A.length() - 1);
reverse(A.begin(), A.end());
cout << (solve(B) - solve(A) + 10000) % 10000 << endl;
return 0;
}
|
#include<string>
#include<cstdio>
#include<cstring>
#define rep(i,a) for(int i=0;i<(a);++i)
#define repd(i,a) for(int i=(a);i>=0;--i)
#define clr(a,v) memset((a),(v),sizeof(a))
char A[502], B[502];
int M;
int dp[501][2][10][3][501];
int rec( const std::string &br, int i, bool smaller, int prv, short up, int mod )
{
if( i == br.size() )
return !mod;
int &ret = dp[i][smaller][prv][up][mod];
if( ~ret )
return ret;
ret = 0;
rep( d, smaller?10:br[i]-'0'+1 ) if( !d||d!=prv )
if( up==2 || up==1&&d<prv || !up&&d>prv )
ret = (ret + rec( br, i+1, smaller|d!=br[i]-'0', d, up==2&&!prv?2:d>prv, (mod*10+d)%M )) % 10000;
return ret;
}
int main()
{
scanf( "%s%s%d", A, B, &M );
int c = 1, e = strlen(A)-1;
repd( i, e )
{
A[i]-=c;
c=0;
if( A[i]-'0' < 0 )
A[i]+=10, c=1;
}
clr( dp, -1 ); int upr = rec( B, 0, false, 0, 2, 0 );
clr( dp, -1 ); int lwr = rec( A, 0, false, 0, 2, 0 );
printf( "%d\n", (upr-lwr+10000)%10000 );
return 0;
}
|
#include <bits/stdc++.h> // {{{
#define ARG4(_1, _2, _3, _4, ...) _4
#define rep(...) ARG4(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define REP(i, a) FOR(i, 0, a)
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rrep(...) ARG4(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
#define RREP(i, a) RFOR(i, 0, a)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (int)(a); --i)
#define ALL(c) (c).begin(), (c).end()
#define TEN(n) ((ll)(1e##n))
#define pb emplace_back
#define mp make_pair
#define fst first
#define snd second
#define let const auto
#define USE1(T) template <typename T>
#define USE2(T, U) template <typename T, typename U>
#define I_ inline
#define mygc(c) (c) = getchar_unlocked()
#define mypc(c) putchar_unlocked(c)
USE1(T) using duo = std::pair<T, T>;
USE1(T) using vec = std::vector<T>;
using ll = long long;
// clang-format off
USE2(T,U) I_ bool chmax(T&x,U a){return x<a&&(x=a,1);}
USE2(T,U) I_ bool chmin(T&x,U a){return a<x&&(x=a,1);}
USE1(T=int) I_ T in(){T x;std::cin>>x;return x;}
USE1(T=int) I_ vec<T> in(int n){vec<T> v;v.reserve(n);rep(i,n)v.pb(in<T>());return v;}
USE1(T) vec<T> ndvec(T v,int n){return vec<T>(n, v);}
USE2(T,...Ts) auto ndvec(T v,int n,Ts...ns)->vec<decltype(ndvec(v,ns...))>{return ndvec(ndvec(v,ns...),n);}
USE1(T) I_ void pr(T x){std::cout<<x<<'\n';}
USE2(T,...Ts) I_ void pr(T x,Ts...xs){std::cout<<x<<' ';pr(xs...);}
I_ int re(){int x=0,m=0,k;for(;;){mygc(k);if(k=='-'){m=1;break;}if('0'<=k&&k<='9'){x=k-'0';break;}}for(;;){mygc(k);if(k<'0'||'9'<k)break;x=x*10+k-'0';}return x;}
I_ void wr(int x,char c='\n'){int s=0,m=0;char b[32];if(x<0)m=1,x=-x;for(;x;x/=10)b[s++]=x%10;if(!s)b[s++]=0;if(m)mypc('-');for(;s--;)mypc(b[s]+'0');mypc(c);}
struct IoSetup {
IoSetup(){
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.precision(10);
std::cerr.precision(10);
}
} iosetup;
// clang-format on
// }}}
using namespace std;
const int inf = 1001001001;
const ll infll = 1001001001001001001ll;
const int dd[] = {0, 1, 0, -1, 0};
const int MOD = TEN(4);
int memo[501][10][2][2][500];
struct ZigZagNumber {
const string S;
const int N;
const int M;
ZigZagNumber(const string& S, int M) : S(S), N(S.size()), M(M) {}
int dfs(int i, int pre, bool high, bool tight, int tot) {
if (i == N) { return tot == 0; }
int& ret = memo[i][pre][high][tight][tot];
if (ret != -1) return ret;
int x = S[i] - '0';
int l = 0, r = 10;
if (high) {
l = pre + 1;
} else {
r = pre;
}
if (tight) chmin(r, x + 1);
ret = 0;
rep(j, l, r) { ret += dfs(i + 1, j, !high, tight && j == x, (10 * tot + j) % M); }
return ret %= MOD;
}
int solve() {
memset(memo, -1, sizeof(memo));
int ret = 0;
rep(k, N) {
int x = S[k] - '0';
int l = 1, r = 10;
if (k == 0) chmin(r, x + 1);
rep(i, l, r) {
bool tight = k == 0 && i == x;
ret += dfs(k + 1, i, true, tight, i % M);
if (k < N - 1) { ret += dfs(k + 1, i, false, tight, i % M); }
}
ret %= MOD;
}
return ret;
}
};
string decr(string s) {
rrep(i, s.size()) {
if (s[i]-- != '0') break;
s[i] = '9';
}
return s.substr(s.size() > 1 && s[0] == '0');
}
signed main() {
auto A = decr(in<string>());
auto B = in<string>();
int M = in();
pr((ZigZagNumber(B, M).solve() + MOD - ZigZagNumber(A, M).solve()) % MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int mod;
int m;
int cal(string x){
if(x.size() == 1) return (x[0]-'0')/m + 1;
int dp[2][600][10][2][2]; //桁数, 余り, 数字, 最大, 増減
memset(dp,0,sizeof(dp));
dp[0][0][0][0][0] = 1;
int top = x[0]-'0';
for (int i = 1;i < top;i++){
dp[0][i%m][i][0][0] = 1;
dp[0][i%m][i][0][1] = 1;
}
dp[0][top%m][top][1][0] = 1;
dp[0][top%m][top][1][1] = 1;
int cur = 0, next = 1;
for (int d = 0;d < x.size()-1;d++){
memset(dp[next],0,sizeof(dp[next]));
for (int rem = 0;rem < m;rem++){
for (int num = 0;num < 10;num++){
for (int isMax = 0;isMax<2;isMax++){
for (int isL = 0;isL<2;isL++){
if(dp[cur][rem][num][isMax][isL] == 0) continue;
int crt = dp[cur][rem][num][isMax][isL];
crt %= mod;
if(num == 0 && isL == 0){
dp[next][0][0][0][0] += crt;
for (int i = 1;i < 10;i++){
dp[next][i%m][i][0][0] += crt;
if(d != x.size()-2)dp[next][i%m][i][0][1] += crt;
}
}else if(isMax == 1){
int xn = x[d+1]-'0';
if(isL == 0){
for (int i = num-1;i >= 0;i--){
if(i > xn) continue;
else if(i == xn) dp[next][(rem*10+i)%m][i][1][1] += crt;
else dp[next][(rem*10+i)%m][i][0][1] += crt;
}
}else{
for (int i = num+1;i <= xn;i++){
if(i == xn) dp[next][(rem*10+i)%m][i][1][0] += crt;
else dp[next][(rem*10+i)%m][i][0][0] += crt;
}
}
}else if(isL == 0){
for (int i = num-1;i >= 0;i--){
dp[next][(rem*10+i)%m][i][0][1] += crt;
}
}else if(isL == 1){
for (int i = num+1;i <= 9;i++){
dp[next][(rem*10+i)%m][i][0][0] += crt;
}
}
}
}
}
}
swap(cur,next);
}
int ret = 0;
for (int i = 0;i < 10;i++){
for (int j = 0;j < 2;j++){
for (int k = 0;k < 2;k++){
ret += dp[cur][0][i][j][k];
//if(dp[cur][0][i][j][k] != 0) cout << i << " " << ret << endl;
ret %= mod;
}
}
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string a,b; cin >> a >> b >> m;
mod = 10000;
bool f = false;
for (int i = a.size()-1;i >= 0;i--){
if(f && a[i] == '0'){
a[i] = '9';
}else if(f){
a[i]--; break;
}else if(a[i] == '0'){
a[i] = '9'; f = true;
}else{
a[i]--; break;
}
}
if(a[0] == '0' && a.size() >= 2){
string c = "";
for (int i = 0;i < a.size()-1;i++){
c += a[i+1];
}
a = c;
}
//cout << a << endl;
//cout << cal(a) << " " << cal(b) << endl;
cout << (mod+cal(b) - cal(a))%mod << endl;
return 0;
}
|
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
// less - decsend - pos - residual - val
int dp[2][2][501][500][10];
const int mod = 10000;
int calc(string s, int m){
if(s == "0") return 0;
memset(dp, 0, sizeof(dp));
int n = s.length();
for(int i = 0; i < n; i++){
for(int less = 0; less < 2; less++){
for(int dec = 0; dec < 2; dec++){
for(int res = 0; res < m; res++){
for(int val = 0; val < 10; val++){
if(dp[less][dec][i][res][val] == 0) continue;
for(int nval = 0; nval < 10; nval++){
if(less == 0 && nval > s[i]-'0') break;
if(val == nval || dec == (val > nval)) continue;
int nless = less || (s[i]-'0' > nval);
int ndec = 1-dec;
int nres = (res*10+nval)%m;
(dp[nless][ndec][i+1][nres][nval] += dp[less][dec][i][res][val]) %= mod;
}
}
}
}
}
// begin number here
for(int nval = 1; nval <= 9; nval++){
if(i == 0 && nval > s[i]-'0') break;
int less = (i==0&&nval==s[i]-'0' ? 0 : 1);
for(int dec = 0; dec < 2; dec++){
dp[less][dec][i+1][nval%m][nval]++;
}
}
}
int ret = 0;
for(int i = 0; i < 2; i++){
for(int j = 0; j < 2; j++){
for(int k = 0; k < 10; k++){
(ret += dp[i][j][n][0][k]) %= mod;
}
}
}
int ma = 9;
if(s.length() == 1) ma = stoi(s);
for(int i = 1; i <= ma; i++){
if(i%m == 0) ret--;
}
ret = (ret + mod) % mod;
return ret;
}
int main(){
string a, b;
cin >> a >> b;
int m;
cin >> m;
for(int i = a.length()-1; i >= 0; i--){
if(a[i] != '0'){
a[i]--;
break;
}else{
a[i] = '9';
}
}
reverse(a.begin(), a.end());
while(a.size() > 1 && a.back() == '0') a.pop_back();
reverse(a.begin(), a.end());
cout << (calc(b,m)-calc(a,m)+mod)%mod << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <set>
#include <cstring>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,j) FOR(i,0,j)
#define mp std::make_pair
const int INF = 1 << 24;
const int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1}, dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
typedef unsigned long long ull;
typedef std::pair<int,int> P;
std::string A, B;
int M;
int dp[501][501][10][3][2];
bool zigzag(const std::string &s){
for(int i=0;i+2<s.size();i++){
if(s[i+1]-s[i] > 0 && s[i+2]-s[i+1] < 0);
else if(s[i+1]-s[i] < 0 && s[i+2]-s[i+1] > 0);
else{return false;}
}
return true;
}
int rec(std::string &s, int d, int r, int prev_n, int updown, int nine){
if(d == s.size()){return r == 0;}
if(dp[d][r][prev_n][updown][nine] != -1){
return dp[d][r][prev_n][updown][nine];
}
int n = s[d]-'0', res = 0;
for(int i=0;i<=(nine?9:n);i++){
// 増加しない
if(updown == 0 && prev_n <= i)continue;
// 減少しない
if(updown == 1 && prev_n >= i)continue;
// 一つ前が0でない または 0以外の先頭桁が決まっていて，次がその桁の数と同じ(増加も減少もしない)
if(updown == 2 && prev_n && prev_n == i)continue;
int dd;
if(updown == 2){
if(prev_n == 0){ // 0でいく
dd = 2;
}else if(prev_n > i){ // 減少する
dd = 1;
}else { // 増加する
dd = 0;
}
} else dd = !updown; // 反転
res = (res + rec(s, d+1, (r*10+i)%M, i, dd, nine|(i!=n))) % 10000;
}
return dp[d][r][prev_n][updown][nine] = res;
}
int main(){
std::cin >> A >> B;
std::cin >> M;
int an, bn;
memset(dp, -1, sizeof(dp));
bn = rec(B, 0, 0, 0, 2, 0);
memset(dp, -1, sizeof(dp));
an = rec(A, 0, 0, 0, 2, 0);
std::cout << (bn - an + 10000 + zigzag(A)) % 10000 << std::endl;
}
|
#include<bits/stdc++.h>
#define MOD 10000
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int dp[502][2][10][500][3], m;
char S[2][550];
int solve(int o) {
memset(dp, 0, sizeof(dp));
dp[0][0][0][0][0] = 1;
int i;
for (i = 0; S[o][i]; i++)rep(j, 2)rep(k, 10)rep(l, m)rep(d, 3) {
if (dp[i][j][k][l][d] == 0)continue;
int s, g, p = S[o][i] - '0';
if (d == 1)s = k + 1, g = (j ? 9 : p);
else if (d == 2)s = 0, g = (j ? k - 1 : min(k - 1, p));
else s = 0, g = (j ? 9 : p);
for (int x = s; x <= g; x++) {
if (x&&k == x)continue;
int y;
if (d == 1)y = 2;
else if (d == 2)y = 1;
else {
if (k == 0)y = 0;
else if (x < k)y = 1;
else y = 2;
}
(dp[i + 1][j || x < p][x][(l * 10 + x) % m][y] += dp[i][j][k][l][d]) %= MOD;
}
}
int sum = 0;
rep(k, 2) {
if (!k && !o)continue;
rep(j, 10)rep(t, 3)(sum += dp[i][k][j][0][t]) %= MOD;
}
return sum;
}
int main() {
scanf("%s%s%d", S[0], S[1], &m);
printf("%d\n", (solve(1) + MOD - solve(0)) % MOD);
}
|
#include<bits/stdc++.h>
#define MOD 10000
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int dp[502][2][10][500][3], m;
char S[2][550];
int solve(int o) {
memset(dp, 0, sizeof(dp));
dp[0][0][0][0][0] = 1;
int i;
for (i = 0; S[o][i]; i++)rep(j, 2)rep(k, 10)rep(l, m)rep(d, 3) {
if (dp[i][j][k][l][d] == 0)continue;
int s, g, p = S[o][i] - '0';
if (d == 1)s = k + 1, g = (j ? 9 : p);
else if (d == 2)s = 0, g = (j ? k - 1 : min(k - 1, p));
else s = 0, g = (j ? 9 : p);
for (int x = s; x <= g; x++) {
if (x&&k == x)continue;
int y;
if (d == 1)y = 2;
else if (d == 2)y = 1;
else {
if (k == 0)y = 0;
else if (x < k)y = 1;
else y = 2;
}
(dp[i + 1][j || x < p][x][(l * 10 + x) % m][y] += dp[i][j][k][l][d]) %= MOD;
}
}
int sum = 0;
rep(k, 2)rep(j, 10)rep(t, 3) {
if (!k && !o)continue;
(sum += dp[i][k][j][0][t]) %= MOD;
}
return sum;
}
int main() {
scanf("%s%s%d", S[0], S[1], &m);
printf("%d\n", (solve(1) + MOD - solve(0)) % MOD);
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
const int MOD = 10000;
std::string a, b; // <=1e500
int m; // <=500
int dp[2][2][510][510][15][3];
char Ch(int i) {
return '0' + i;
}
int func(bool lower, bool upper, int mod, int idx, int prev, int stat) {// stat: 0: zero, 1: ?¢???????, 2: ??????
if(idx >= a.size()) {
if(lower && upper && mod % m == 0) {
return true;
}else {
return false;
}
}
if(dp[lower][upper][mod][idx][prev][stat] != -1) {
return dp[lower][upper][mod][idx][prev][stat];
}
mod *= 10;
int ans = 0;
for(int i = 0; i <= 9; ++i) {
int nm = (mod + i) % m;
char c = '0' + i;
bool newLower;
bool newUpper;
int newStat;
if(lower) {
newLower = lower;
}else {
if(b[idx] < c) {
continue;
}
if(b[idx] == c && idx != a.size() - 1) {
newLower = false;
}else {
newLower = true;
}
}
if(upper) {
newUpper = true;
}else {
if(a[idx] > c) {
continue;
}
if(a[idx] == c && idx != a.size() - 1) {
newUpper = false;
}else {
newUpper = true;
}
}
if(stat == 0) {
if(prev == 0) {
newStat = 0;
}else if(prev > i){
newStat = 1;
}else if(prev < i) {
newStat = 2;
}else {
continue;
}
}else if(stat == 1) {
if(i <= prev) {
continue;
}
newStat = 2;
}else {
if(i >= prev) {
continue;
}
newStat = 1;
}
ans += func(newLower, newUpper, nm, idx + 1, i, newStat);
ans %= MOD;
}
return dp[lower][upper][mod / 10][idx][prev][stat] = ans;
}
int main() {
std::cin >> a >> b >> m;
while(a.size() < b.size()) {
a = std::string("0") + a;
}
memset(dp, -1, sizeof(dp));
std::cout << func(false, false, 0, 0, 0, 0) << std::endl;
}
|
#include <iostream>
#include <string>
#include <algorithm>
#define llint long long
#define mod 10000
using namespace std;
string a, b;
llint m;
llint beki[505];
llint dp[505][505][10][2][2];
llint calc(string &s)
{
int n = s.size();
llint ret = 0;
for(int i = n-1; i >= 0; i--){
for(int j = 0; j < m; j++){
for(int k = 0; k < 10; k++){
for(int l = 0; l < 2; l++){
for(int b = 0; b < 2; b++){
dp[i][j][k][l][b] = 0;
}
}
}
}
}
for(int i = n-1; i >= 0; i--){
for(int j = 1; j <= 9; j++){
if(i == n-1 && j > s[i]-'0') continue;
for(int k = 0; k < 2; k++){
if(i == 0 && k == 1) continue;
int l = 1;
if(i == n-1 && j == s[i]-'0') l = 0;
dp[i][(j*beki[i])%m][j][l][k] = 1;
}
}
}
for(int i = n-1; i > 0; i--){
for(int j = 0; j < m; j++){
for(int k = 0; k < 10; k++){
for(int l = 0; l < 2; l++){
for(int b = 0; b < 2; b++){
for(int nk = 0; nk < 10; nk++){
if(b == 0 && k >= nk) continue;
if(b == 1 && k <= nk) continue;
if(l == 0 && nk > s[i-1]-'0') continue;
int nl = l;
if(nk < s[i-1]-'0') nl = 1;
(dp[i-1][(j+nk*beki[i-1])%m][nk][nl][1-b] += dp[i][j][k][l][b]) %= mod;
}
}
}
}
}
}
for(int k = 0; k < 10; k++){
for(int l = 0; l < 2; l++){
for(int b = 0; b < 2; b++){
ret += dp[0][0][k][l][b], ret %= mod;
}
}
}
return ret;
}
int main(void)
{
cin >> a >> b >> m;
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
beki[0] = 1;
for(int i = 1; i < 505; i++) beki[i] = beki[i-1] * 10 % m;
llint ans = (calc(b) - calc(a) + mod) % mod;
llint sum = 0;
for(int i = 0; i < a.size(); i++) sum += beki[i]*(a[i]-'0'), sum %= m;
bool flag = true;
for(int i = 1; i < a.size()-1; i++){
int x = a[i-1]-'0', y = a[i]-'0', z = a[i+1]-'0';
if((y-x)*(z-y) >= 0) flag = false;
}
if(flag && sum == 0) ans++, ans %= mod;
cout << ans << endl;
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
//dp[何文字目か][直前の数字][上下][自由に選べるか][余り]
//上:0 下:1
int m;
string s;
char z[555];
int dp[501][10][3][2][500];
int solve(int n,int be,int ud,int ok,int md){
if(n == (int)s.size()){
//if(!md)cout << z << endl;
return md?0:1;
}
if(dp[n][be][ud][ok][md] >= 0) return dp[n][be][ud][ok][md];
int ret = 0;
for(int i = 0; i <= ((ok)?9:(int)(s[n]-'0')); i++){
if(ud == 0 && be <= i) continue;
if(ud == 1 && be >= i) continue;
if(ud == 2 && be != 0 && be == i) continue;
int u;
if(ud == 2){
if(be == 0) u = 2;
else if(be > i) u = 1;
else u = 0;
}else{
u = (ud+1)%2;
}
//z[n] = i + '0';
ret += solve(n+1,i,u,(ok || i != (int)(s[n]-'0'))?1:0,(md*10+i)%m);
//z[m] = '\0';
}
return dp[n][be][ud][ok][md] = ret%10000;
}
int main(void){
string c,d;
cin >> c >> d >> m;
for(int i = (int)c.size()-1; i >= 0; i--){
if(c[i] == '0'){
c[i] = '9';
}else{
c[i]--;
break;
}
}
s = c;
memset(dp,-1,sizeof(dp));
int a = solve(0,0,2,0,0);
//cout << "A" << endl;
s = d;
memset(dp,-1,sizeof(dp));
int b = solve(0,0,2,0,0);
//cout << "B" << endl;
//cout << a << endl;
//cout << b << endl;
cout << (b + 10000 - a)%10000 << endl;
}
|
/*
脳みそがないのでJOI予選落ち不可避
*/
#include <stdio.h>
#include <string.h>
#define MOD 10000
enum Dir {UP=0, DOWN, NODIR};
enum Type {LAX=0, SEVERE};
int dp[2][500][10][2][2]; // dp[ind][mod][digit][dir][type]
char a[502];
char b[502];
char nines[502];
int m;
int ans;
int calc(char *digits) {
int ind, i, i2, j, j2, k;
int len = strlen(digits);
int src = 0;
int dst = 1;
int ret = 0;
if (len == 1) return (digits[0]-'0')/m;
memset(dp, 0, sizeof(dp));
for (i=1; i<10; i++) {
int d = digits[0] - '0';
if (i < d) {
dp[src][i%m][i][UP][LAX] += 1;
dp[src][i%m][i][DOWN][LAX] += 1;
} else if (i == d) {
dp[src][i%m][i][UP][SEVERE] += 1;
dp[src][i%m][i][DOWN][SEVERE] += 1;
}
}
for (ind=1; ind<len; ind++) {
int d = digits[ind] - '0';
if (ind != 1) {
for (i=1; i<10; i++) {
dp[src][i%m][i][UP][LAX] += 1;
dp[src][i%m][i][DOWN][LAX] += 1;
}
}
for (i=0; i<m; i++) {
for (j=0; j<10; j++) {
for (j2=j-1; j2>=0; j2--) {
int i2 = (i*10 + j2) % m;
dp[dst][i2][j2][DOWN][LAX] += dp[src][i][j][UP][LAX];
if (j2 < d) {
dp[dst][i2][j2][DOWN][LAX] += dp[src][i][j][UP][SEVERE];
} else if (j2 == d) {
dp[dst][i2][j2][DOWN][SEVERE] += dp[src][i][j][UP][SEVERE];
}
dp[dst][i2][j2][DOWN][LAX] %= MOD;
dp[dst][i2][j2][DOWN][SEVERE] %= MOD;
}
for (j2=j+1; j2<10; j2++) {
int i2 = (i*10 + j2) % m;
dp[dst][i2][j2][UP][LAX] += dp[src][i][j][DOWN][LAX];
if (j2 < d) {
dp[dst][i2][j2][UP][LAX] += dp[src][i][j][DOWN][SEVERE];
} else if (j2 == d) {
dp[dst][i2][j2][UP][SEVERE] += dp[src][i][j][DOWN][SEVERE];
}
dp[dst][i2][j2][UP][LAX] %= MOD;
dp[dst][i2][j2][UP][SEVERE] %= MOD;
}
}
}
dst ^= 1;
src ^= 1;
memset(dp[dst], 0, sizeof(dp[dst]));
}
for (i=0; i<2; i++) {
for (j=0; j<2; j++) {
for (k=0; k<10; k++) {
ret += dp[src][0][k][i][j];
ret %= MOD;
}
}
}
ret += 9/m;
return ret;
}
int is_zigzag(char *digits) {
int i;
int len = strlen(digits);
int now = NODIR;
int pre_d = -1;
int mod = 0;
for (i=0; i<len; i++) {
int d = digits[i] - '0';
if ((now == UP && d <= pre_d) || (now == DOWN && d >= pre_d)) {
return 0;
}
if (i != 0 && d > pre_d) now = DOWN;
else if (i != 0 && d < pre_d) now = UP;
mod = (mod * 10 + d) % m;
pre_d = d;
}
return mod == 0;
}
int main() {
scanf("%s", a);
scanf("%s", b);
scanf("%d", &m);
ans = calc(b) - calc(a) + is_zigzag(a) + MOD;
printf("%d\n", ans % MOD);
}
|
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
const int mod = 10000;
string x;
int m,memo[510][510][10][2][3];
int dp(int keta,int d,int bef,bool sml,int zig){
if(keta == x.size()) return d==0;
if(memo[keta][d][bef][sml][zig] != -1) return memo[keta][d][bef][sml][zig];
int n = sml?9:(x[keta]-'0');
int res = 0;
for(int i=0;i<=n;i++){
if(zig == 2){
if(i == 0) res = ( res+dp(keta+1,(d*10+i)%m,i,sml|(i<n),2) )%mod;
else{
res = ( res+dp(keta+1,(d*10+i)%m,i,sml|(i<n),bef<i) )%mod;
if(keta < x.size()-1) res = ( res+dp(keta+1,(d*10+i)%m,i,sml|(i<n),bef>i) )%mod;
}
continue;
}
if(zig == 0 && i <= bef) continue;
if(zig == 1 && bef <= i) continue;
res = ( res+dp(keta+1,(d*10+i)%m,i,sml|(i<n),!zig) )%mod;
}
return memo[keta][d][bef][sml][zig] = res;
}
int main()
{
string a,b;
int ans;
cin >> a >> b;
cin >> m;
x = b;
fill_n(****memo,510*510*10*2*3,-1);
ans = dp(0,0,0,0,2)+mod;
for(int i=a.size()-1;i>=0;i--){
if(a[i] == '0') a[i] = '9';
else {
a[i]--;
break;
}
}
x = a;
fill_n(****memo,510*510*10*2*3,-1);
ans -= dp(0,0,0,0,2);
cout << ans%mod << endl;
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <complex>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define SORT(x) sort((x).begin(),(x).end())
#define all(x) (x).begin(),(x).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define MOD 10000
int dp[505][10][505][3][2];
int M;
vector<int> a,b;
int rec(vector<int> &vec,int index,int prev,int mod,int upper,bool free)
{
if(index==vec.size())return (mod?0:1);
if(dp[index][prev][mod][upper][free]>0)return dp[index][prev][mod][upper][free];
int can;
if(free){can=9;}
else {can=vec[index];}
int res=0;
for(int i=0;i<=can;i++)
{
res%=MOD;
if(upper==0&&prev>=i)continue;
if(upper==1&&prev<=i)continue;
if(upper==2&&prev&&prev==i)continue;
int new_upper;
if(upper==2)
{
if(prev==0)new_upper=2;
else if(prev<i)new_upper=1;
else new_upper=0;
}
else new_upper=!upper;
res += rec(vec,index+1,i,(mod*10+i)%M,new_upper,free|(i!=vec[index]));
}
return dp[index][prev][mod][upper][free]=res%MOD;
}
int main()
{
string s1,s2;
cin >> s1;
cin >> s2;
cin >> M;
for(int i=0;i<s1.size();i++)a.pb(s1[i]-'0');
for(int i=0;i<s2.size();i++)b.pb(s2[i]-'0');
for(int i=a.size()-1;i>=0;i--)
{
if(a[i]==0)a[i]=9;
else
{
a[i]--;
break;
}
}
memset(dp,-1,sizeof(dp));
int A=rec(a,0,0,0,2,false);
memset(dp,-1,sizeof(dp));
int B=rec(b,0,0,0,2,false);
int ans=(B-A+MOD)%MOD;
//cout << A << ' ' << B <<endl;
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.