text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
const int MOD = 10000;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
int dp[505][2][505][10][3][3];
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
string a, b;
int m;
cin >> a >> b >> m;
int n = b.size();
if(n != 1) {
VI mo(n); mo[0] = 1%m;
FOR(i, 1, n) mo[i] = mo[i-1]*10%m;
// B以下の数を求める桁DP
dp[0][0][0][0][0][0] = 1;
REP(i, n) REP(j, 2) REP(k, m) REP(l, 10) REP(x, 3) REP(y, 3) {
if(!dp[i][j][k][l][x][y]) continue;
// cout << i << "," << j << "," << k << "," << l << "," << x << "," << y << " ";
// cout << dp[i][j][k][l][x][y] << endl;
int lim = j?9:b[i]-'0';
REP(d, lim+1) {
// 上昇か下降か
int cond = 0;
if(y==1) {
if(l < d) cond = 1;
else if(l > d) cond = 2;
} else if(x == 1) {
if(l > d) cond = 2;
} else if(x == 2) {
if(l < d) cond = 1;
}
// leading-zero
int cond2 = 0;
if(y==0) {
if(d) cond2 = 1;
} else if(y==1) {
cond2 = 2;
} else {
cond2 = 2;
}
(dp[i+1][j||d<lim][(k+mo[n-1-i]*d)%m][d][cond][cond2] += dp[i][j][k][l][x][y]) %= MOD;
}
}
}
int ans = 0;
if(n != 1) {
REP(i, 2) REP(j, 10) FOR(k, 1, 3) REP(l, 3) {
if(!dp[n][i][0][j][k][l]) continue;
// cout << n << "," << i << "," << 0 << "," << j << "," << k << "," << l << " ";
// cout << dp[n][i][0][j][k][l] << endl;
(ans += dp[n][i][0][j][k][l]) %= MOD;
}
REP(i, 9) {
ans += (i+1)%m==0;
}
} else {
REP(i, b[0]-'0') {
ans += (i+1)%m==0;
}
}
// cout << ans << endl;
n = a.size();
if(n != 1) {
VI mo(n); mo[0] = 1%m;
FOR(i, 1, n) mo[i] = mo[i-1]*10%m;
// A以下の数を求める桁DP
memset(dp, 0, sizeof(dp));
dp[0][0][0][0][0][0] = 1;
REP(i, n) REP(j, 2) REP(k, m) REP(l, 10) REP(x, 3) REP(y, 3) {
if(!dp[i][j][k][l][x][y]) continue;
// cout << i << "," << j << "," << k << "," << l << "," << x << "," << y << " ";
// cout << dp[i][j][k][l][x][y] << endl;
int lim = j?9:a[i]-'0';
REP(d, lim+1) {
int cond = 0;
if(y==1) {
if(l < d) cond = 1;
else if(l > d) cond = 2;
} else if(x == 1) {
if(l > d) cond = 2;
} else if(x == 2) {
if(l < d) cond = 1;
}
int cond2 = 0;
if(y==0) {
if(d) cond2 = 1;
} else if(y==1) {
cond2 = 2;
} else {
cond2 = 2;
}
(dp[i+1][j||d<lim][(k+mo[n-1-i]*d)%m][d][cond][cond2] += dp[i][j][k][l][x][y]) %= MOD;
}
}
}
if(n != 1) {
REP(i, 2) REP(j, 10) FOR(k, 1, 3) REP(l, 3) {
if(!dp[n][i][0][j][k][l]) continue;
// cout << n << "," << i << "," << 0 << "," << j << "," << k << "," << l << " ";
// cout << dp[n][i][0][j][k][l] << endl;
(ans -= dp[n][i][0][j][k][l] + MOD) %= MOD;
}
REP(i, 9) ans -= (i+1)%m==0;
ans = (ans%MOD+MOD)%MOD;
} else {
REP(i, a[0]-'0') {
ans -= (i+1)%m==0;
}
}
// aがmの倍数かつジグザグ数ならansに+1する
bool can = a[0]!=a[1];
bool flag = a[0]<a[1];
FOR(i, 2, n) {
if(flag) {
if(a[i-1]>a[i]) {
flag = false;
} else {
can = false;
break;
}
} else {
if(a[i-1]<a[i]) {
flag = true;
} else {
can = false;
break;
}
}
}
int now = 0;
for(int i=n-1; i>=0; --i) now = (now*10 + (a[i]-'0')) % m;
if(now) can = false;
if(can) ans++;
cout << ans%MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<map>
#include<cstring>
#include<string>
#include <math.h>
#include<algorithm>
// #include <boost/multiprecision/cpp_int.hpp>
#include<functional>
#define int long long
#define inf 1000000007
#define pa pair<int,int>
#define ll long long
#define pal pair<double,pa>
#define ppa pair<int,int>
#define ppap pair<int,pa>
#define ssa pair<string,int>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define VI vector<int>
using namespace std;
class pas{
public:
int x,y;
pas(int x=0,int y=0):x(x),y(y) {}
pas operator + (pas p) {return pas(x+p.x,y+p.y);}
pas operator - (pas p) {return pas(x-p.x,y-p.y);}
pas operator * (int a) {return pas(x*a,y*a);}
pas operator / (int a) {return pas(x/a,y/a);}
// double absv() {return sqrt(norm());}
int norm() {return x*x+y*y;}
bool operator < (const pas &p) const{
return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pas &p) const{
return x==p.x && y==p.y;
}
};
int mod=10000;
int dp[600][600][2][11];
int dp2[600][600][2][11];
int m;
int ch(string e ){
if(e=="0") return 1;
if(e.length()==1){
return (1+(e[0]-'0')/m);
}
while(e[0]=='0') e=e.substr(1);
for(int i=0;i<600;i++)for(int j=0;j<600;j++)for(int k=0;k<2;k++)for(int f=0;f<11;f++)dp[i][j][k][f]=0,dp2[i][j][k][f]=0;
dp[0][0][0][10]=1;
dp2[0][0][0][10]=1;
for(int i=0;i<e.length();i++){
int gk=1;
if(i%2) gk*=-1;
for(int num=0;num<10;num++){
for(int j=0;j<m;j++){
for(int f=0;f<11;f++){
if(f==10 && num==0) continue;
if(num<e[i]-'0' && (gk*(num-f)>0 || f==10)){
dp[i+1][(j*10+num)%m][1][num]+=dp[i][j][1][f];
dp[i+1][(j*10+num)%m][1][num]+=dp[i][j][0][f];
}
else if(num==e[i]-'0' && (gk*(num-f)>0 || f==10)){
dp[i+1][(j*10+num)%m][1][num]+=dp[i][j][1][f];
dp[i+1][(j*10+num)%m][0][num]+=dp[i][j][0][f];
}
else if(num>e[i]-'0' && (gk*(num-f)>0 || f==10)){
dp[i+1][(j*10+num)%m][1][num]+=dp[i][j][1][f];
}
dp[i+1][(j*10+num)%m][0][num]%=mod;
dp[i+1][(j*10+num)%m][1][num]%=mod;
}
}
}
if(i>0){
for(int num=1;num<10;num++) dp[i+1][num%m][1][num]++;
}
// for(int j=0;j<m;j++)for(int k=0;k<2;k++)for(int l=0;l<11;l++)if(dp[i+1][j][k][l])cout<<"1 "<<i+1<<" "<<j<<" "<<k<<" "<<l<<" "<<dp[i+1][j][k][l]<<endl;
// cout<<dp[i+1][0][1][5]<<endl;
}
for(int i=0;i<e.length();i++){
int gk=-1;
if(i%2) gk*=-1;
for(int num=0;num<10;num++){
for(int j=0;j<m;j++){
for(int f=0;f<11;f++){
if(f==10 && num==0) continue;
if(num<e[i]-'0' && (gk*(num-f)>0 || f==10)){
dp2[i+1][(j*10+num)%m][1][num]+=dp2[i][j][1][f];
dp2[i+1][(j*10+num)%m][1][num]+=dp2[i][j][0][f];
}
else if(num==e[i]-'0' && (gk*(num-f)>0 || f==10)){
dp2[i+1][(j*10+num)%m][1][num]+=dp2[i][j][1][f];
dp2[i+1][(j*10+num)%m][0][num]+=dp2[i][j][0][f];
}
else if(num>e[i]-'0' && (gk*(num-f)>0 || f==10)){
dp2[i+1][(j*10+num)%m][1][num]+=dp2[i][j][1][f];
}
dp2[i+1][(j*10+num)%m][0][num]%=mod;
dp2[i+1][(j*10+num)%m][1][num]%=mod;
}
}
}
if(i>0 && i!=e.length()-1){
for(int num=1;num<10;num++) dp2[i+1][num%m][1][num]++;
}
// for(int j=0;j<m;j++)for(int k=0;k<2;k++)for(int l=0;l<11;l++)if(dp2[i+1][j][k][l])cout<<"2 "<<i+1<<" "<<j<<" "<<k<<" "<<l<<" "<<dp2[i+1][j][k][l]<<endl;
}
int ans=1;
for(int f=0;f<=10;f++){
// cout<<"1 "<<f<<" "<<dp[e.length()][0][1][f]<<endl;
// cout<<"2 "<<f<<" "<<dp2[e.length()][0][1][f];
// cout<<endl;
ans+=dp[e.length()][0][1][f]+dp2[e.length()][0][1][f]+dp[e.length()][0][0][f]+dp2[e.length()][0][0][f];
ans%=mod;
}
return ans;
}
signed main(){
// int pr[3];
string s1,s2;
cin>>s1>>s2;
int l=s1.length();
for(int i=l-1;i>=0;i--){
if(s1[i]!='0'){
s1[i]--;
break;
}
s1[i]='9';
}
cin>>m;
// cout<<ch(s2)<<endl;
cout<<(ch(s2)-ch(s1)+mod)%mod<<endl;
//cout<<ans<<endl;
}
|
#include<iostream>
#include<string>
using namespace std;
const int mod = 10000;
int dp[600][600][11][2][2];
string S, T; int power[600], n;
int zen_shori(int Keta) {
for (int i = 0; i <= Keta; i++) {
for (int k = 0; k < n; k++) {
for (int j = 0; j < 10; j++) {
dp[i][k][j][0][0] = 0;
dp[i][k][j][0][1] = 0;
dp[i][k][j][1][0] = 0;
dp[i][k][j][1][1] = 0;
}
}
}
int F = 0;
for (int i = 1; i <= 9; i++) { if (i%n == 0)F++; }
if (Keta == 1)return F;
if (Keta == 0)return 0;
dp[0][0][0][0][1] = 1; dp[0][0][10][1][1] = 1;
for (int i = 0; i < Keta; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < 11; k++) {
for (int l = 0; l < 2; l++) {
int L = 0, R = 9;
if (l == 0)L = k + 1;
if (l == 1)R = k - 1;
for (int m = 0; m <= 9; m++) {
int Plus = (power[i] * m) % n;
int to = (j + Plus) % n;
if (L <= m && m <= R) {
dp[i + 1][to][m][1 - l][0] += dp[i][j][k][l][0]; dp[i + 1][to][m][1 - l][0] %= mod;
}
if (m >= 1) { dp[i + 1][to][m][1 - l][0] += dp[i][j][k][l][1]; dp[i + 1][to][m][1 - l][0] %= mod; }
if (m == 0) { dp[i + 1][to][m][1 - l][1] += dp[i][j][k][l][1]; dp[i + 1][to][m][1 - l][1] %= mod; }
}
}
}
}
}
int sum = 0;
for (int i = 0; i < 10; i++) { for (int j = 0; j < 2; j++) { sum += dp[Keta][0][i][j][0]; } }
sum -= F;
//cout << sum << endl;
return sum;
}
int solve(string V) {
for (int i = 0; i <= V.size(); i++) {
for (int k = 0; k < n; k++) {
for (int j = 0; j < 10; j++) {
dp[i][k][j][0][0] = 0;
dp[i][k][j][0][1] = 0;
dp[i][k][j][1][0] = 0;
dp[i][k][j][1][1] = 0;
}
}
}
int F = 0;
for (int i = 1; i <= (int)(V[0] - '0'); i++) { if (i%n == 0)F++; }
if (V.size() == 1)return F;
dp[0][0][0][0][1] = 1; dp[0][0][10][1][1] = 1;
for (int i = 0; i < (int)V.size(); i++) {
int P = V[i] - '0';
for (int j = 0; j < n; j++) {
for (int k = 0; k < 11; k++) {
for (int l = 0; l < 2; l++) {
if (dp[i][j][k][l][0] == 0 && dp[i][j][k][l][1] == 0)continue;
int L = 0, R = 9;
if (l == 0)L = k + 1;
if (l == 1)R = k - 1;
for (int m = L; m <= R; m++) {
if (i == 0 && m == 0)continue;
int Plus = (power[i] * m) % n;
int to = (j + Plus) % n;
dp[i + 1][to][m][1 - l][0] += dp[i][j][k][l][0]; dp[i + 1][to][m][1 - l][0] %= mod;
if (P > m) { dp[i + 1][to][m][1 - l][0] += dp[i][j][k][l][1]; dp[i + 1][to][m][1 - l][0] %= mod; }
if (P == m) { dp[i + 1][to][m][1 - l][1] += dp[i][j][k][l][1]; dp[i + 1][to][m][1 - l][1] %= mod; }
}
}
}
}
}
int sum = 0;
for (int i = 0; i < 10; i++) { for (int j = 0; j < 2; j++) { sum += dp[V.size()][0][i][j][0] + dp[V.size()][0][i][j][1]; } }
//cout << sum << endl;
return sum;
}
int solve2(string V) {
int v = 1; for (int i = V.size() - 1; i >= 0; i--) { power[i] = v; v *= 10; v %= n; }
int r1 = solve(V);
int r2 = zen_shori(V.size() - 1);
return (r2 + r1) % mod;
}
int main() {
cin >> S >> T >> n;
int ii = S.size() - 1; while (S[ii] == '0') { S[ii] = '9'; ii--; } S[ii]--;
while (S[0] == '0' && S.size() >= 2)S = S.substr(1, S.size() - 1);
cout << (solve2(T) - solve2(S) + mod) % mod << endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#define int long long
#define vel vector<long long>
#define vvel vector<vel>
#define vvvel vector<vvel>
void mmin(int &a, int b) { a = min(a, b); }
void mmax(int &a, int b) { a = max(a, b); }
void sor(vel &v) { sort(v.begin(), v.end()); }
void m1(int &a) { a = a % 10000; }
int sign(int n) {
if (n == 0)return n;
return n / abs(n);
}
int zero() { return 0; }
int zi(vel a, int mo, vel rui) {
int ke = a.size();
int ans = 9 / mo;
if (ke == 0)return 0;
if (ke == 1)return a[0]/mo;
vvvel ze(2,vvel(10, vel(mo, 0)));
vvvel dp0 = ze;
vvvel dp1 = ze;
for (int i = 0; i < 10; i++) {
dp0[0][i][i%mo]++;
if (i <= a[0])dp1[0][i][i%mo]++;
}
dp0[1] = dp0[0];
dp1[1] = dp1[0];
int di;
di = 1;
for (int k1 = 1; k1 < ke; k1++) {
int r1 = rui[k1];
vvvel odp0 = dp0;
vvvel odp1 = dp1;
dp0 = ze; dp1 = ze;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < mo; j++) {
for (int k = 0; k < 10; k++) {
int xx = (r1*k) % mo;
xx = (xx + j) % mo;
int ty = sign(i-k)*di;
if (ty != 0) {
ty = (ty + 1) / 2;
dp0[ty][k][xx] += odp0[ty][i][j];
m1(dp0[ty][k][xx]);
if (k < a[k1]) {
dp1[ty][k][xx] += odp0[ty][i][j];
m1(dp0[ty][k][xx]);
}
else if (k == a[k1]) {
dp1[ty][k][xx] += odp1[ty][i][j];
m1(dp1[ty][k][xx]);
}
}
}
}
}
if (k1 + 1 < ke) {
for (int i = 1; i < 10; i++) {
ans += dp0[0][i][0] + dp0[1][i][0];
m1(ans);
}
}
else {
for (int i = 1; i < 10; i++) {
ans += dp1[0][i][0] + dp1[1][i][0];
m1(ans);
}
}
di *= -1;
}
return ans;
}
signed main() {
string ka;
string kb;
cin >> ka >> kb;
int m; cin >> m;
int n = ka.size();
vel a; int fl = 1;
for (int i = 0; i < n; i++) {
if ((i != 0 or ka[i] != '1') and (i == 0 or ka[i] == '0')) fl = 0;
}
if (fl == 1) { n--; a = vel(n, 9); }
else {
a = vel(n);
for (int i = 0; i < n; i++) a[i] = ka[i] - 48;
reverse(a.begin(), a.end());
for (int i = 0; i < n; i++) {
if (a[i] == 0) { a[i] = 9; }
else { a[i]--; break; }
}
}
int si = kb.size();
vel rui(si, 1); int sum = a[0];
for (int i = 1; i < si; i++) {
rui[i] = (rui[i - 1] * 10) % m;
}
vel b(si);
for (int i = 0; i < si; i++) { b[i] = kb[si - i - 1] - 48; }
cout << (zi(b, m, rui) - zi(a, m, rui)+10000)%10000 << endl;
return 0;
}
|
#include <cstring>
#include <cstdio>
#include <algorithm>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
using namespace std;
int dp[2][2][2][2][2][10][512];
char a[512];
char b[512];
int m;
int aa[512];
int bb[512];
int main(){
scanf("%s", a);
scanf("%s", b);
scanf("%d", &m);
int nb = strlen(b);
int na = strlen(a);
REP(i,na) aa[i] = a[na - i - 1] - '0';
REP(i,nb) bb[i] = b[nb - i - 1] - '0';
reverse(aa, aa + nb);
reverse(bb, bb + nb);
for(int i = aa[0]; i <= bb[0]; i++){
int fa = 0;
int fb = 0;
int nz = 0;
if(i > aa[0]) fa = 1;
if(i < bb[0]) fb = 1;
if(i != 0) nz = 1;
dp[0][fa][fb][nz][0][i][i % m] = 1;
if(nz == 1 && nb != 1)
dp[0][fa][fb][nz][1][i][i % m] = 1;
}
REP(i,nb - 1){
REP(fa,2) REP(fb,2) REP(nz,2) REP(ud,2) REP(p, 10) REP(am, m)
dp[(i + 1) % 2][fa][fb][nz][ud][p][am] = 0;
REP(fa,2) REP(fb,2) REP(nz,2) REP(ud,2)
REP(p,10) REP(am, m) if(dp[i % 2][fa][fb][nz][ud][p][am]){
int low = 0;
int high = 9;
// printf("%d: %d %d %d %d %d %d: %d\n", i, fa, fb, nz, ud, p, am, dp[i % 2][fa][fb][nz][ud][p][am]);
if(fa == 0) low = aa[i + 1];
if(fb == 0) high = bb[i + 1];
if(nz == 1){
if(ud == 0) low = max(low, p + 1);
else high = min(high, p - 1);
}
for(int next = low; next <= high; next++){
int ffa = fa;
int ffb = fb;
int nnz = nz;
if(next > aa[i + 1]) ffa = 1;
if(next < bb[i + 1]) ffb = 1;
if(next > 0) nnz = 1;
if(nz == 0 && nnz == 1 && i != nb - 2){
dp[(i + 1) % 2][ffa][ffb][nnz][0][next][(am * 10 + next) % m]
= (dp[i % 2][fa][fb][nz][ud][p][am] + dp[(i + 1) % 2][ffa][ffb][nnz][0][next][(am * 10 + next) % m]) % 10000;
dp[(i + 1) % 2][ffa][ffb][nnz][1][next][(am * 10 + next) % m]
= (dp[i % 2][fa][fb][nz][ud][p][am] + dp[(i + 1) % 2][ffa][ffb][nnz][1][next][(am * 10 + next) % m]) % 10000;
}else{
dp[(i + 1) % 2][ffa][ffb][nnz][!ud][next][(am * 10 + next) % m]
= (dp[i % 2][fa][fb][nz][ud][p][am] + dp[(i + 1) % 2][ffa][ffb][nnz][!ud][next][(am * 10 + next) % m]) % 10000;
}
}
}
}
int ans = 0;
REP(fa,2) REP(fb,2) REP(ud,2) REP(p,10)
ans = (ans + dp[(nb - 1) % 2][fa][fb][1][ud][p][0]) % 10000;
printf("%d\n", ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> P;
typedef pair<int,int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template<typename T> inline bool chmax(T &a, T b){if(a<b){a=b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if(a>b){a=b;return true;}return false;}
template<typename T> ostream& operator<<(ostream& s,const complex<T>& d) {return s<<"("<<d.real()<<", "<<d.imag()<< ")";}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const pair<T1,T2>& d) {return s<<"("<<d.first<<", "<<d.second<<")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& d){
int len=d.size();
rep(i,len){
s<<d[i];if(i<len-1) s<<" ";
}
return s;
}
template<typename T> ostream& operator<<(ostream& s,const vector<vector<T>>& d){
int len=d.size();
rep(i,len){
s<<d[i]<<endl;
}
return s;
}
template<typename T> ostream& operator<<(ostream& s,const set<T>& v){
s<<"{ ";
for(auto itr=v.begin();itr!=v.end();++itr) {
if (itr!=v.begin()) {s<< ", ";}
s<<(*itr);
}
s<<" }";
return s;
}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const map<T1,T2>& m){
s<<"{"<<endl;
for(auto itr=m.begin();itr!=m.end();++itr){
s<<" "<<(*itr).first<<" : "<<(*itr).second<<endl;
}
s<<"}"<<endl;
return s;
}
const ll mod=10000;
const ll inf=1e17;
const int INF=1e9;
const double PI=acos(-1);
const double EPS=1e-10;
struct mint {
ll x;
mint(ll x=0):x((x%mod+mod)%mod){}
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod-a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res+=a;
}
mint operator-(const mint a) const {
mint res(*this);
return res-=a;
}
mint operator*(const mint a) const {
mint res(*this);
return res*=a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t>>1);
a *= a;
if (t&1) a *= *this;
return a;
}
// for prime mod
mint inv() const {
return pow(mod-2);
}
mint& operator/=(const mint a) {
return (*this) *= a.inv();
}
mint operator/(const mint a) const {
mint res(*this);
return res/=a;
}
};
int m;
mint dp[510][2][10][510][4];
/*
決定している桁数
x以下が確定しているか 0:まだ 1:確定
前の桁に置かれた数字
mで割った余り
単調増加かどうか 0:1桁だけ確定 1:増加 2:減少 3:まだ確定していない
*/
mint solve(string x){
rep(i,510)rep(j,2)rep(k,10)rep(l,510)rep(n,4) dp[i][j][k][l][n]=0;
dp[0][0][0][0][3]=1;
rep(i,x.size())rep(a,2)rep(b,10)rep(c,m)rep(d,4){
int now=x[i]-'0';
rep(nb,10){
int na=a,nc=c,nd=d;
if(a==0 && now<nb) continue;//xより大きな値はダメ
if(nb<now) na=1;//xより小さいことが確定したら
if(d==3){//何も決まっていない状態からは1桁確定した状態に遷移する
if(nb==0) nd=3;
else nd=0;
nc=nb%m;
}
if(d==0){//1桁確定した状態からは2桁確定した状態へ
if(b==nb) continue;
if(b<nb) nd=1;
if(b>nb) nd=2;
}
if(d==2){//減少してたところからは増加に
nd=1;
if(b>=nb) continue;
}
if(d==1){
nd=2;
if(b<=nb) continue;
}
nc=(10*c+nb)%m;
dp[i+1][na][nb][nc][nd]+=dp[i][a][b][c][d];
}
}
mint ret=0;
rep(a,2)rep(b,10)rep(d,3) ret+=dp[x.size()][a][b][0][d];
//cout<<ret.x<<endl;
return ret;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string a,b;
cin>>a>>b>>m;
int ind=a.size()-1;
while(true){
int now=a[ind]-'0';
if(now>=1){
now--;
a[ind]=now+'0';
break;
}else{
a[ind]='9';
ind--;
}
}
mint ans=solve(b)-solve(a);
cout<<ans.x<<endl;
}
|
#include<iostream>
using namespace std;
#define rep(i, a) for(int i=0; i<(a); i++)
string A, B;
int M;
int memo[502][2][4][10][500];
//pos, less, hoge, pre, modM
string S;
const int up=2, down=3;
const int mod=1e4;
int rec(int i, int j, int k, int l, int m){
if(memo[i][j][k][l][m]!=-1) return memo[i][j][k][l][m];
if(i==S.size()){
return memo[i][j][k][l][m]=((k!=0)&&(m==0));
}
int ret=0;
int ue=(j? 9: S[i]-'0');
rep(d, ue+1){
int diff=d-l;
int nj=(j||d<ue);
int nk;
int nm=(10*m+d)%M;
if(k==0){
nk=(d!=0);
}else if(k==1){
if(diff==0) continue;
nk=(diff>0? up: down);
}else if(k==up&&diff<0){
nk=down;
}else if(k==down&&diff>0){
nk=up;
}else{
continue;
}
(ret+=rec(i+1, nj, nk, d, nm))%=mod;
}
return memo[i][j][k][l][m]=(ret%mod);
}
int calc(string N){
fill((int*)memo, (int*)memo+502*2*4*10*500, -1);
S=N;
return rec(0, 0, 0, 0, 0);
}
void minus1(){
int len=A.size();
for(int i=0; i<len; i++){
char ch=A[len-1-i];
if(ch=='0'){
A[len-1-i]='9';
}else{
A[len-1-i]=ch-1;
break;
}
}
if(A[0]=='0'&&A.size()>1) A=A.substr(1);
}
int main(){
cin>> A>> B>> M;
minus1();
cout<< (calc(B)-calc(A)+mod)%mod<< endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int mod=10000;
string A,B,S;
int M;
int memo[501][10][3][2][500];
int calc(int keta=0,int mae=0,int hoko=0,int jiyuu=0,int amari=0){
if(keta==S.size()){
return amari==0;
}
if(~memo[keta][mae][hoko][jiyuu][amari])
return memo[keta][mae][hoko][jiyuu][amari];
int ret=0;
for(int i=0;i<10;i++){
if(jiyuu==0&&S[keta]<i+'0')break;
if((hoko||mae)&&mae==i)continue;
int njiyuu=jiyuu|(i+'0'!=S[keta]);
int namari=(amari*10+i)%M;
if(hoko==0){
if(mae)ret=(ret+calc(keta+1,i,mae<i?2:1,njiyuu,namari))%mod;
else ret=(ret+calc(keta+1,i,0,njiyuu,namari))%mod;
}
else if(hoko==1&&mae<i){
ret=(ret+calc(keta+1,i,2,njiyuu,namari))%mod;
}
else if(hoko==2&&mae>i){
ret=(ret+calc(keta+1,i,1,njiyuu,namari))%mod;
}
}
return memo[keta][mae][hoko][jiyuu][amari]=ret;
}
int main(){
cin>>A>>B>>M;
A[A.size()-1]--;
for(int i=A.size()-1;i>0;i--){
if(A[i]>='0')break;
A[i]='9';
A[i-1]--;
}
S=B;memset(memo,-1,sizeof(memo));
int vb=calc();
S=A;memset(memo,-1,sizeof(memo));
int va=calc();
cout<<(vb-va+mod)%mod<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
string minusone(string s) {
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] != '0') {
s[i] = s[i] - 1;
break;
} else {
s[i] = '9';
}
}
return s.substr(s[0] == '0' ? 1 : 0);
}
int solve(string limit, int mod) {
//mod 今の数-1 厳しくない？厳しい？ 減少？増加？未確定？
vector<vector<vector<vector<int>>>> dp
(mod, vector<vector<vector<int>>>(
11, vector<vector<int>>(
2, vector<int>(
3))));
dp[0][0][true][2] = 1;
for (int index = 0; index < limit.size(); index++) {
vector<vector<vector<vector<int>>>> after
(mod, vector<vector<vector<int>>>(
11, vector<vector<int>>(
2, vector<int>(
3))));
for (int backnum = 0; backnum <= 10; backnum++) {
for (int nownum = backnum == 0 ? 0 : 1; nownum <= 10; nownum++) {
bool up = backnum < nownum;
for (int backmod = 0; backmod < mod; backmod++) {
int nowmod = (backmod * 10 + max(0, nownum - 1)) % mod;
if (backnum == 0) { // no num ->
if (nownum == 1) continue; // zero start
/* unknown -> unknown */
if (index == 0) { // tight ->
if (nownum - 1 == limit[index] - '0') { // -> tight
after[nowmod][nownum][true][2] += dp[backmod][backnum][true][2];
} else if (nownum - 1 < limit[index] - '0') { // -> not tight
after[nowmod][nownum][false][2] += dp[backmod][backnum][true][2];
}
}
/* not tight -> not tight */
after[nowmod][nownum][false][2] += dp[backmod][backnum][false][2];
} else { // num -> num
if (nownum == backnum) continue;
if (nownum - 1 == limit[index] - '0') { // tight -> tight
after[nowmod][nownum][true][up] += dp[backmod][backnum][true][!up];
after[nowmod][nownum][true][up] += dp[backmod][backnum][true][2];
} else if (nownum - 1 < limit[index] - '0') { // tight -> not tight
after[nowmod][nownum][false][up] += dp[backmod][backnum][true][!up];
after[nowmod][nownum][false][up] += dp[backmod][backnum][true][2];
}
/* not tight -> not tight */
after[nowmod][nownum][false][up] += dp[backmod][backnum][false][!up];
after[nowmod][nownum][false][up] += dp[backmod][backnum][false][2];
}
for (int tmp = 0; tmp < 2; tmp++) {
after[nowmod][nownum][true][tmp] %= 10000;
after[nowmod][nownum][false][tmp] %= 10000;
}
}
}
}
dp = after;
}
int ret = 0;
for (int lastnum = 0; lastnum <= 9; lastnum++) {
for (int tight = 0; tight < 2; tight++) {
for (int updown = 0; updown < 3; updown++) {
int x = dp[0][lastnum + 1][tight][updown];
if (x > 0) {
ret += x;
}
ret %= 10000;
}
}
}
return ret;
}
int main() {
string a, b;
int mod;
cin >> a >> b >> mod;
int ret = solve(b, mod) - solve(minusone(a), mod);
cout << (ret + 10000) % 10000 << endl;
}
|
#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][2][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 <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned __int128 HASH;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll,int> plli;
typedef pair<double, int> pdbi;
typedef pair<int,pii> pipii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n);i>0;i--)
#define rrep2(i,a,b) for (int i=(a);i>b;i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const ll INF = 1<<30;
const ll mod = 10000;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
//#define int long long
#define addm(X, Y) ((X) = ((X) + (Y) % mod) % mod)
string a, b;
ll dp1[2][2][10][2][2][500 + 5], dp2[2][2][10][2][2][500 + 5];
int mo;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> a >> b >> mo;
dp1[0][0][0][0][0][0] = 1;
dp1[0][0][0][1][0][0] = 1;
int cur = 1, pre = 0;
rep(i, b.size()){
rep(j, 2)rep(d, 10)rep(l, 2)rep(z, 2)rep(m, mo) dp1[cur][j][d][l][z][m] = 0;
rep(j, 2) {
int lim = j ? 9 : b[i] - '0';
rep(d, lim + 1)rep(k, 10)rep(z, 2) {
if (z != 0 && d == k) continue;
rep(l, 2) {
if (z != 0 && ((l == 0 && d < k) || (l == 1 && k < d))) continue;
rep(m, mo) {
if (z == 0 && d == 0) dp1[cur][1][0][l^1][0][0] = 1;
else addm(dp1[cur][j || d < lim][d][l^1][1][(10 * m + d) % mo], dp1[pre][j][k][l][z][m]);
}
}
}
}
swap(cur, pre);
}
int b_end = pre;
dp2[0][0][0][0][0][0] = 1;
dp2[0][0][0][1][0][0] = 1;
cur = 1;
pre = 0;
rep(i, a.size()) {
rep(j, 2)rep(d, 10)rep(l, 2)rep(z, 2)rep(m, mo) dp2[cur][j][d][l][z][m] = 0;
rep(j, 2) {
int lim = j ? 9 : a[i] - '0';
rep(d, lim + 1)rep(k, 10)rep(z, 2) {
if (z != 0 && d == k) continue;
rep(l, 2) {
if (z != 0 && ((l == 0 && d < k) || (l == 1 && k < d))) continue;
rep(m, mo) {
if (z == 0 && d == 0) dp2[cur][1][0][l^1][0][0] = 1;
else addm(dp2[cur][j || d < lim][d][l^1][1][(10 * m + d) % mo], dp2[pre][j][k][l][z][m]);
}
}
}
}
swap(cur, pre);
}
int a_end = pre;
ll ans = 0;
rep(j, 2)rep(d, 10)rep(z, 2)rep(l, 2) addm(ans, dp1[b_end][j][d][l][z][0]);
rep(j, 2)rep(d, 10)rep(z, 2)rep(l, 2) ans = (ans - dp2[a_end][j][d][l][z][0] + 2 * mod) % mod;
if (a.size() == 1) {
if (stoi(a) % mo == 0) addm(ans, 1);
if (b.size() == 1) {
rep2(i, stoi(a) + 1, stoi(b) + 1) {
if (i % mo != 0) continue;
ans = (ans - 1 + mod) % mod;
}
}
else {
rep2(i, stoi(a) + 1, 10) {
if (i % mo != 0) continue;
ans = (ans - 1 + mod) % mod;
}
}
}
else {
rep(l, 2) addm(ans, dp2[a_end][0][a[a.size() - 1] - '0'][l][1][0]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int dp[501][2][4][10][501],n,m,sum;
string s,t;
int dfs(int idx,bool tight=true,int zig=3,int pre=0,int mod=0){
if(idx==s.size())return (!mod)&&(zig<3);
int &res=dp[idx][tight][zig][pre][mod];
if(~res)return res;
res=0;
int x=s[idx]-'0';
int r=(tight?x:9);
for(int i=0;i<=r;i++){
if(zig<3&&pre==i)continue;
if(zig==0&&pre>=i)continue;
if(zig==1&&pre<=i)continue;
res+=dfs(idx+1,tight&&i==r,zig<2?zig^1:zig==2?pre<i:i?2:3,i,(mod*10+i)%m);
res%=10000;
}
return res;
}
int main(){
memset(dp,-1,sizeof(dp));
cin>>s>>t>>m;
int A=dfs(0);
memset(dp,-1,sizeof(dp));
swap(s,t);
int B=dfs(0);
r(i,t.size())sum+=(sum*10+(t[i]-'0'))%m;
cout<<(B-A+10000+!sum)%10000<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int M;
const int MOD = 10000;
string A, B;
int memo[512][2][2][10][512];
int dfs2(int i, bool low, bool tight, int pre, int rem);
int dfs1(int i=0, bool tight=true)
{
int x = B[i] - '0';
int r = (tight) ? (x) : 9;
int ret = 0;
if (B.size() - 1 == i){
for (int j = 1; j <= r; j++){
if (j % M) continue;
ret++;
}
return ret;
}
ret += dfs1(i + 1, false);
for (int j = 1; j <= r; ++j){
ret += dfs2(i + 1, true, tight && x == j, j, j % M);
ret += dfs2(i + 1, false, tight && x == j, j, j % M);
}
return ret % MOD;
}
int dfs2(int i, bool low, bool tight, int pre, int rem)
{
if (i == B.size()){
return rem == 0;
}
int &ret = memo[i][low][tight][pre][rem];
if (ret != -1){
return ret;
}
ret = 0;
int x = B[i] - '0';
int r = low ? pre - 1 : 9;
int l = low ? 0 : (pre + 1);
if (tight){
r = min(r, x);
}
for (int j = l; j <= r; j++){
ret += dfs2(i + 1, !low, tight && j == x, j, (rem * 10 + j) % M);
}
return ret %= MOD;
}
int main()
{
cin >> A >> B >> M;
for (int i = A.size() - 1; i >= 0; --i){
if (A[i] - '0'){
A[i]--;
break;
}
A[i] = '9';
}
if (A[0] == '0' && A.size() != 1) A = A.substr(1);
memset(memo, -1, sizeof(memo));
int b = dfs1();
swap(A, B);
memset(memo, -1, sizeof(memo));
int a = dfs1();
cout << (b - a + MOD) % MOD << endl;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstdio>
#include<list>
#include<queue>
#include<string.h>
#include<functional>
#include<stack>
#include<deque>
#include<string>
#include<limits.h>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#define mod 10000
using namespace std;
int dp[10][505][2][2][501][2];
/*
i?????????A
???i?????????????????????
A????????§???????????????
B???????°?????????????
M??§?????£????????????
????????£????????????????????£?????????
*/
int A[505], B[505];
signed main() {
int ans = 10000;
string a, b; int m; cin >> a >> b >> m;
if (a.length() == 1) {
for (int j = 1; j <= 9; j++) {
if (j >= a[0] - '0'&&j%m == 0)ans--;
}
}
while (a.length() < b.length()) {
a = '0' + a;
}
for (int i = 0; i < a.length(); i++) {
A[i] = a[i] - '0';
B[i] = b[i] - '0';
}
int S = 0, G = 0;
for (int i = 0; i < a.length(); i++) {
if (S <= 10)S = S * 10 + A[i];
if (G <= 10)G = G * 10 + B[i];
//i?????????????§???????
for (int j = 1; j <= 9; j++) {
if (j == S) {
if (j == G) {
dp[j][i][0][0][j%m][0]++;
dp[j][i][0][0][j%m][1]++;
}
else if (j < G) {
dp[j][i][0][1][j%m][0]++;
dp[j][i][0][1][j%m][1]++;
}
}
else if (j > S) {
if (j == G) {
dp[j][i][1][0][j%m][0]++;
dp[j][i][1][0][j%m][1]++;
}
else if (j < G) {
dp[j][i][1][1][j%m][0]++;
dp[j][i][1][1][j%m][1]++;
}
}
}
for (int j = 0; j < m; j++) {
for (int k = 0; k <= 9; k++) {//????????°
for (int l = 0; l <= 9; l++) {//???????????°
dp[k][i][0][0][j][0] %= mod;
dp[k][i][0][0][j][1] %= mod;
dp[k][i][0][1][j][0] %= mod;
dp[k][i][0][1][j][1] %= mod;
dp[k][i][1][0][j][0] %= mod;
dp[k][i][1][0][j][1] %= mod;
dp[k][i][1][1][j][0] %= mod;
dp[k][i][1][1][j][1] %= mod;
if (k == l)continue;
if (l > A[i+1]) {
if (l > B[i+1]) {
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][0][1][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
}
else if (l == B[i + 1]) {
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][0][1][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
dp[l][i + 1][1][0][(j * 10 + l) % m][k < l] += dp[k][i][0][0][j][k > l];
dp[l][i + 1][1][0][(j * 10 + l) % m][k < l] += dp[k][i][1][0][j][k > l];
}
else
{
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][0][1][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][0][0][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][0][j][k > l];
}
}
else if (l == A[i + 1]) {
if (l > B[i + 1]) {
dp[l][i + 1][0][1][(j * 10 + l) % m][k < l] += dp[k][i][0][1][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
}
else if (l == B[i + 1]) {
dp[l][i + 1][0][1][(j * 10 + l) % m][k < l] += dp[k][i][0][1][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
dp[l][i + 1][0][0][(j * 10 + l) % m][k < l] += dp[k][i][0][0][j][k > l];
dp[l][i + 1][1][0][(j * 10 + l) % m][k < l] += dp[k][i][1][0][j][k > l];
}
else
{
dp[l][i + 1][0][1][(j * 10 + l) % m][k < l] += dp[k][i][0][1][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
dp[l][i + 1][0][1][(j * 10 + l) % m][k < l] += dp[k][i][0][0][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][0][j][k > l];
}
}
else
{
if (l > B[i + 1]) {
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
}
else if (l == B[i + 1]) {
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
dp[l][i + 1][1][0][(j * 10 + l) % m][k < l] += dp[k][i][1][0][j][k > l];
}
else
{
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][1][j][k > l];
dp[l][i + 1][1][1][(j * 10 + l) % m][k < l] += dp[k][i][1][0][j][k > l];
}
}
}
}
}
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int l = 0; l < 2; l++) {
for (int n = 0; n <= 9; n++) {
ans += dp[n][a.length() - 1][i][j][0][l];
ans %= mod;
}
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
#define EACH(i,a) for (auto& i : a)
#define FOR(i,a,b) for (ll i=(a);i<(b);i++)
#define RFOR(i,a,b) for (ll i=(b)-1;i>=(a);i--)
#define REP(i,n) for (ll i=0;i<(n);i++)
#define RREP(i,n) for (ll i=(n)-1;i>=0;i--)
#define debug(x) cout<<#x<<": "<<x<<endl
#define pb push_back
#define ALL(a) (a).begin(),(a).end()
const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);
template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
EACH(x,vec) is >> x;
return is;
}
/*
template<class... T>
ostream& operator<<(ostream& os, tuple<T...>& t) {
for (size_t i = 0; i < tuple_size< tuple<T...> >::value; ++i) {
if (i) os << " ";
os << get<0>(t);
}
return os;
}
*/
template<typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
REP(i,vec.size()) {
if (i) os << " ";
os << vec[i];
}
return os;
}
template<typename T>
ostream& operator<<(ostream& os, vector< vector<T> >& vec) {
REP(i,vec.size()) {
if (i) os << endl;
os << vec[i];
}
return os;
}
const ll mod = 1e4;
ll dp[501][500][2][11][3] = {0};
bool check(const string& s) {
int n = s.size();
vector<int> v;
REP(i, n) {
v.pb(s[i]-'0');
}
vector<int> d(n-1);
REP(i, n-1) {
d[i] = v[i+1]-v[i];
}
REP(i, n-1) {
if (d[i] == 0) return false;
}
REP(i, n-2) {
if ( d[i] * d[i+1] > 0 ) {
return false;
}
}
return true;
}
ll add(ll a, ll b) {
if (a < 0) a += mod;
if (b < 0) b += mod;
if (a + b >= mod) return a + b - mod;
return a + b;
}
int M;
ll f(const string& s) {
int n = s.size();
vector<int> v(n);
REP(i, n) v[i] = s[i]-'0';
fill(dp[0][0][0][0], dp[500][499][1][11], 0);
dp[0][0][1][0][2] = 1;
REP(i, n) REP(j, M) REP(k, 2) REP(pd, 11) REP(ud, 3) {
if (dp[i][j][k][pd][ud] == 0) continue;
int l = 0, r = 10;
// if (i == 0) {
// l = 1;
// }
if (k == 1) {
r = v[i]+1;
}
for (int d = l; d < r; ++d) {
int ni = i + 1;
int nj = (j * 10 + d) % M;
int nk = k == 1 && d == r-1 ? 1 : 0;
int nud = d > pd ? 1 : 0;
if (ud == 2 && pd == 0) {
if (d == 0) nud = 2, nk = 0;
else nud = 2;
}
else if (ud == 2) {
if (d == pd) continue;
}
else {
if (d == pd) continue;
if (ud == nud) continue;
}
// cout << dp[i][j][k][pd][ud] << endl;
// cout << i << " " << j << " " << k << " " << pd << " " << ud << endl;
// cout << "->" << ni << " " << nj << " " << nk << " " << d << " " << nud << endl;
dp[ni][nj][nk][d][nud] = add(dp[ni][nj][nk][d][nud], dp[i][j][k][pd][ud]);
}
}
ll res = 0;
REP(j, 2) REP(k, 11) REP(l, 3) {
if (dp[n][0][j][k][l] == 0) continue;
// cout << n << " " << 0 << " " << j << " " << k << " " << l << endl;
res = add(res, dp[n][0][j][k][l]);
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
string A, B; cin >> A >> B;
cin >> M;
ll ans = 0;
if ( check(A) ) ++ans;
ans = add(ans, -f(A));
ans = add(ans, f(B));
// cout << f("5") << endl;
// cout << f("10") << endl;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 10000;
#define rep(i,n) for(int i = 0;i < n;i++)
#define rrep(i,n) for(int i = 1;i <= n;i++)
string s;
int dp[502][2][3][10][500], m;
//dp[桁][使えるか][上下][前の数字][mod]
int rec(int p, int ok, int pre_up, int pre, int num){
if(p == s.size())return (num == 0);
if(dp[p][ok][pre_up][pre][num] != -1)return dp[p][ok][pre_up][pre][num];
int n = ok ? 9 : s[p]-'0';
int res = 0;
for(int i = 0;i <= n;i++){
if(pre_up == 1 && pre <= i)continue;
if(pre_up == 2 && pre >= i)continue;
if(pre_up == 0){
if(pre == 0)res += rec(p+1, ok|(i < n), 0, i, (num*10+i)%m);
else if(pre < i)res += rec(p+1, ok|(i < n), 1, i, (num*10+i)%m);
else if(pre > i)res += rec(p+1, ok|(i < n), 2, i, (num*10+i)%m);
}else if(pre_up == 1){
res += rec(p+1, ok|(i < n), 2, i, (num*10+i)%m);
}else{
res += rec(p+1, ok|(i < n), 1, i, (num*10+i)%m);
}
}
return dp[p][ok][pre_up][pre][num] = res % mod;
}
int get(string str){
s = str;
fill((int*)dp, (int*)(dp+502), -1);
int ans = rec(0, 0, 0, 0, 0);
return ans;
}
string calc(string str){
for(int i = str.size()-1;i >= 0;i--){
if(str[i] == '0')str[i] = '9';
else {str[i]--;break;}
}
return str;
}
int main(){
string a, b;
cin >> a >> b >> m;
int ans = (get(b)-get(calc(a)) + mod)%mod;
printf("%d\n", ans);
return 0;
}
|
#include "stdio.h"
#include "string.h"
#include <iostream>
using namespace std;
pair<int,int> maxw[555];
pair<int,int> minw[555];
long long int dp[500][10][2];
long long int dp2[500][10][2];
char a[555];
char b[555];
int aw[555];
int bw[555];
int main()
{
int m;
scanf("%s",a);
scanf("%s",b);
scanf("%d",&m);
int l;
l = strlen(b);
int lw;
lw = strlen(a);
for(int i = 0; i < l; i++)
{
bw[i] = b[i] - '0';
if(0 <= (i - l + lw))
{
aw[i] = a[i - l + lw] - '0';
}
else
{
aw[i] = 0;
}
}
int flg = 0;
maxw[0] = make_pair(3,bw[0] % m);
if(aw[0] == 0)
{
minw[0] = make_pair(0,0);
}
else
{
minw[0] = make_pair(3,aw[0] % m);
flg = 1;
}
for(int i = 1; i < l; i++)
{
if(maxw[i - 1].first == 3)
{
if(bw[i] > bw[i - 1])
{
maxw[i] = make_pair(2,(maxw[i - 1].second * 10 + bw[i]) % m);
}
else if(bw[i] < bw[i - 1])
{
maxw[i] = make_pair(1,(maxw[i - 1].second * 10 + bw[i]) % m);
}
else
{
maxw[i] = make_pair(-1,0);
}
}
else if(maxw[i - 1].first == 2)
{
if(bw[i] < bw[i - 1])
{
maxw[i] = make_pair(1,(maxw[i - 1].second * 10 + bw[i]) % m);
}
else
{
maxw[i] = make_pair(-1,0);
}
}
else if(maxw[i - 1].first == 1)
{
if(bw[i] > bw[i - 1])
{
maxw[i] = make_pair(2,(maxw[i - 1].second * 10 + bw[i]) % m);
}
else
{
maxw[i] = make_pair(-1,0);
}
}
else
{
maxw[i] = make_pair(-1,0);
}
if(flg == 0)
{
if(aw[i] != 0)
{
minw[i] = make_pair(3,aw[i] % m);
flg = 1;
}
else
{
minw[i] = make_pair(0,0);
}
}
else
{
if(minw[i - 1].first == 3)
{
if(aw[i] > aw[i - 1])
{
minw[i] = make_pair(2,(minw[i - 1].second * 10 + aw[i]) % m);
}
else if(aw[i] < aw[i - 1])
{
minw[i] = make_pair(1,(minw[i - 1].second * 10 + aw[i]) % m);
}
else
{
minw[i] = make_pair(-1,0);
}
}
else if(minw[i - 1].first == 2)
{
if(aw[i] < aw[i - 1])
{
minw[i] = make_pair(1,(minw[i - 1].second * 10 + aw[i]) % m);
}
else
{
minw[i] = make_pair(-1,0);
}
}
else if(minw[i - 1].first == 1)
{
if(aw[i] > aw[i - 1])
{
minw[i] = make_pair(2,(minw[i - 1].second * 10 + aw[i]) % m);
}
else
{
minw[i] = make_pair(-1,0);
}
}
else
{
minw[i] = make_pair(-1,0);
}
}
}
for(int i = 0; i < 500; i++)
{
for(int ii = 0; ii < 10; ii++)
{
dp[i][ii][0] = 0;
dp[i][ii][1] = 0;
}
}
int flh = 0;
for(int i = 0; i < l; i++)
{
for(int j = 0; j < 500; j++)
{
for(int jj = 0; jj < 10; jj++)
{
dp2[j][jj][0] = 0;
dp2[j][jj][1] = 0;
}
}
for(int ii = 0; ii < 10; ii++)
{
for(int j = 0; j < 10; j++)
{
if(ii > j)
{
for(int jj = 0; jj < m; jj++)
{
dp2[(jj * 10 + ii) % m][ii][1] += dp[jj][j][0];
}
}
else if(ii < j)
{
for(int jj = 0; jj < m; jj++)
{
dp2[(jj * 10 + ii) % m][ii][0] += dp[jj][j][1];
}
}
}
}
if(aw[i] != bw[i] && flh == 0)
{
flh = 1;
}
if(flh != 0)
{
if(flh != 1)
{
if(i == 0)
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
dp2[j % m][j][0]++;
dp2[j % m][j][1]++;
}
}
else if(maxw[i - 1].first == 3)
{
for(int j = 0; j < bw[i]; j++)
{
if(j > bw[i - 1])
{
dp2[(maxw[i - 1].second * 10 + j) % m][j][1]++;
}
else if(j < bw[i - 1])
{
dp2[(maxw[i - 1].second * 10 + j) % m][j][0]++;
}
}
}
else if(maxw[i - 1].first == 2)
{
for(int j = 0; j < bw[i]; j++)
{
if(j < bw[i - 1])
{
dp2[(maxw[i - 1].second * 10 + j) % m][j][0]++;
}
}
}
else if(maxw[i - 1].first == 1)
{
for(int j = 0; j < bw[i]; j++)
{
if(j > bw[i - 1])
{
dp2[(maxw[i - 1].second * 10 + j) % m][j][1]++;
}
}
}
if(i != 0)
{
if(minw[i - 1].first == 0)
{
if(i == l - 1)
{
for(int j = aw[i]; j < 10; j++)
{
dp2[j % m][j][0]++;
}
}
else
{
for(int j = aw[i] + 1; j < 10; j++)
{
dp2[j % m][j][0]++;
dp2[j % m][j][1]++;
}
}
}
else if(minw[i - 1].first == 3)
{
for(int j = aw[i] + 1; j < 10; j++)
{
if(j > aw[i - 1])
{
dp2[(minw[i - 1].second * 10 + j) % m][j][1]++;
}
else if(j < aw[i - 1])
{
dp2[(minw[i - 1].second * 10 + j) % m][j][0]++;
}
}
}
else if(minw[i - 1].first == 2)
{
for(int j = aw[i] + 1; j < 10; j++)
{
if(j < aw[i - 1])
{
dp2[(minw[i - 1].second * 10 + j) % m][j][0]++;
}
}
}
else if(minw[i - 1].first == 1)
{
for(int j = aw[i] + 1; j < 10; j++)
{
if(j > aw[i - 1])
{
dp2[(minw[i - 1].second * 10 + j) % m][j][1]++;
}
}
}
}
}
else
{
if(i == 0)
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
dp2[j % m][j][0]++;
dp2[j % m][j][1]++;
}
}
else if(maxw[i - 1].first == 3)
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
if(j > bw[i - 1])
{
dp2[(maxw[i - 1].second * 10 + j) % m][j][1]++;
}
else if(j < bw[i - 1])
{
dp2[(maxw[i - 1].second * 10 + j) % m][j][0]++;
}
}
}
else if(maxw[i - 1].first == 2)
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
if(j < bw[i - 1])
{
dp2[(maxw[i - 1].second * 10 + j) % m][j][0]++;
}
}
}
else if(maxw[i - 1].first == 1)
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
if(j > bw[i - 1])
{
dp2[(maxw[i - 1].second * 10 + j) % m][j][1]++;
}
}
}
/*
if(i != 0)
{
if(minw[i - 1].first == 0)
{
if(i == l - 1)
{
for(int j = aw[i]; j < bw[i]; j++)
{
dp2[j % m][j][0]++;
}
}
else
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
dp2[j % m][j][0]++;
dp2[j % m][j][1]++;
}
}
}
else if(minw[i - 1].first == 3)
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
if(j > aw[i - 1])
{
dp2[(minw[i - 1].second * 10 + j) % m][j][1]++;
}
else if(j < aw[i - 1])
{
dp2[(minw[i - 1].second * 10 + j) % m][j][0]++;
}
}
}
else if(minw[i - 1].first == 2)
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
if(j < aw[i - 1])
{
dp2[(minw[i - 1].second * 10 + j) % m][j][0]++;
}
}
}
else if(minw[i - 1].first == 1)
{
for(int j = aw[i] + 1; j < bw[i]; j++)
{
if(j > aw[i - 1])
{
dp2[(minw[i - 1].second * 10 + j) % m][j][1]++;
}
}
}
}
*/
}
flh++;
}
for(int j = 0; j < m; j++)
{
for(int jj = 0; jj < 10; jj++)
{
for(int jjj = 0; jjj < 2; jjj++)
{
dp[j][jj][jjj] = dp2[j][jj][jjj] % 10000;
}
}
}
}
int all = 0;
for(int i = 0; i < 10; i++)
{
all = (all + dp[0][i][0]) % 10000;
all = (all + dp[0][i][1]) % 10000;
}
printf("%d\n",all);
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
template <class T>
std::vector<T> vec(int len, T elem) { return std::vector<T>(len, elem); }
constexpr int MOD = 10000;
void decr(std::string& s) {
std::reverse(s.begin(), s.end());
for (auto& c : s) {
if (c != '0') {
--c;
break;
} else {
c = '9';
}
}
std::reverse(s.begin(), s.end());
}
int calc(std::string s, int m) {
std::reverse(s.begin(), s.end());
auto dp = vec(2, vec(2, vec(10, vec(m, 0))));
{
char c = s.front();
int dmax = c - '0';
for (int ch = 0; ch <= 1; ++ch) {
for (int d = 0; d <= 9; ++d) {
dp[0][ch][d][d % m] = 1;
if (d <= dmax) {
dp[1][ch][d][d % m] = 1;
}
}
}
s.erase(s.begin());
}
int ret = 0, ten = 10 % m;
bool first = true;
for (char c : s) {
for (int ch = 0; ch <= 1; ++ch) {
if (first && ch == 1) continue;
for (int d = 1; d <= 9; ++d) {
(ret += dp[0][ch][d][0]) %= MOD;
}
}
first = false;
int dmax = c - '0';
auto ndp = vec(2, vec(2, vec(10, vec(m, 0))));
for (int ch = 0; ch <= 1; ++ch) {
for (int pd = 0; pd <= 9; ++pd) {
for (int r = 0; r < m; ++r) {
int lpval = dp[0][ch][pd][r],
tpval = dp[1][ch][pd][r];
for (int d = 0; d <= 9; ++d) {
if ((ch == 0 && pd >= d) || (ch == 1 && pd <= d)) continue;
int nr = (r + ten * d) % m;
// loose -> loose
(ndp[0][1 - ch][d][nr] += lpval) %= MOD;
// loose -> tight
if (d < dmax) {
(ndp[1][1 - ch][d][nr] += lpval) %= MOD;
}
// tight -> tight
if (d == dmax) {
(ndp[1][1 - ch][d][nr] += tpval) %= MOD;
}
}
}
}
}
dp = ndp;
(ten *= 10) %= m;
}
for (int ch = 0; ch <= 1; ++ch) {
if (first && ch == 1) continue;
for (int d = 1; d <= 9; ++d) {
(ret += dp[1][ch][d][0]) %= MOD;
}
}
return ret;
}
void solve() {
std::string a, b;
int m;
std::cin >> a >> b >> m;
decr(a);
std::cout << (calc(b, m) - calc(a, m) + MOD) % MOD << "\n";
}
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include<iostream>
#include<string>
#define M 10000
using namespace std;
int 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;
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++){
int odd = i&1;
for(int j=0;j<3;j++)
for(int k=0;k<10;k++)
for(int l=0;l<m;l++)
dp[1-odd][0][j][k][l] = dp[1-odd][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[1-odd][ub][1][x][mod] += dp[odd][j][k][l][y];
dp[1-odd][ub][1][x][mod] %= M;
}else if(x<l){
dp[1-odd][ub][0][x][mod] += dp[odd][j][k][l][y];
dp[1-odd][ub][0][x][mod] %= M;
}else if(x>l){
dp[1-odd][ub][2][x][mod] += dp[odd][j][k][l][y];
dp[1-odd][ub][2][x][mod] %= M;
}
}
}
}
}
}
}
int ans = 0;
for(int i=0;i<2;i++)
for(int j=0;j<3;j++)
for(int k=0;k<10;k++){
ans += dp[n&1][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 <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
const int MOD = 10000;
string A;
string B;
int M;
short dp[2][502][502][11][2];
void Minus() {
int index = B.size() - 1;
while (true) {
if (B[index] != 0) {
B[index]--;
break;
}
B[index] = 9;
index--;
}
if (index == 0 && B[0] == 0) {
B = B.substr(1);
}
}
int calc(bool ban, int upper, int depth, int rest, int prev, int up) {
if (!ban && dp[upper][depth][rest][prev][up] != -1) { return dp[upper][depth][rest][prev][up]; }
if (depth == (int)B.size()) {
return rest == 0;
}
int l = 0;
int r = 9;
if (ban) { l = 1; }
if (upper) { r = B[depth] - '0'; }
if (up) {
l = prev + 1;
} else {
r = min(r, prev - 1);
}
int ret = 0;
if (l <= r) {
int v = up ? l : r;
int nupper = upper && v == B[depth] - '0';
int nrest = (rest * 10 + v) % M;
ret += calc(false, nupper, depth + 1, nrest, v, up ^ 1);
ret += calc(ban, upper, depth, rest, v, up);
}
if (ban) { return ret % MOD; }
return dp[upper][depth][rest][prev][up] = ret % MOD;
}
int ZigZag(int depth) {
if (depth == (int)B.size() - 1) {
if (B.size() == 1) { return calc(true, 1, depth, 0, 10, 0); }
return calc(true, 0, depth, 0, 10, 0);
}
int ans = 0;
if (depth == 0) {
ans = calc(true, 1, 0, 0, 10, 0) + calc(true, 1, 0, 0, 0, 1);
} else {
ans = calc(true, 0, depth, 0, 10, 0) + calc(true, 0, depth, 0, 0, 1);
}
return ans % MOD;
}
int main() {
while (cin >> A >> B >> M) {
int ans = 0;
MEMSET(dp, -1);
FOR(i, 0, B.size()) {
ans = (ans + ZigZag(i)) % MOD;
}
swap(A, B);
Minus();
MEMSET(dp, -1);
FOR(i, 0, B.size()) {
ans = (ans - ZigZag(i) + MOD) % MOD;
}
cout << ans << endl;
}
}
|
#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
int dp[2][12][502][502]={0};
int m;
char min(char x,char y){if(x>y)return y; return x;}
char max(char x,char y){if(x<y)return y; return x;}
int count(string s){
int ret=0;
int ss=s.size();
if(ss==1)return s[0]/3;
for(int i=1;i<ss;i++){
for(int j=1;j<10;j++){
ret+=dp[0][j][i][0];
if(i!=1)ret+=dp[1][j][i][0];
ret%=10000;
}
}
for(int i=1;i<s[0];i++){
ret+=dp[0][i][ss][0];
ret+=dp[1][i][ss][0];
ret%=10000;
}
int p[502]={0};
int tt[502]={0};
tt[0]=1;
for(int i=1;i<502;i++){tt[i]=tt[i-1]*10; tt[i]%=m;}
p[0]=s[0]*tt[ss-1];
p[0]%=m;
for(int i=1;i<502;i++){
p[i]=p[i-1]+s[i]*tt[ss-1-i];
p[i]%=m;
}
for(int i=1;i<ss;i++){
int t=(i+0)%2;
if(t==1){
if(s[i-1]>=s[i])break;
for(int j=s[i-1]+1;j<s[i];j++){
ret+=dp[t][j][ss-i][(m-p[i-1])%m];
ret%=10000;
}
if(i==ss-1)ret+=dp[t][s[i]][ss-i][(m-p[i-1])%m];
}
if(t==0){
for(int j=0;j<min(s[i-1],s[i]);j++){
ret+=dp[t][j][ss-i][(m-p[i-1])%m];
ret%=10000;
}
if(s[i-1]<=s[i])break;
if(i==ss-1)ret+=dp[t][s[i]][ss-i][(m-p[i-1])%m];
}
}
for(int i=1;i<ss;i++){
int t=(i+1)%2;
if(t==1){
if(s[i-1]>=s[i])break;
for(int j=s[i-1]+1;j<s[i];j++){
ret+=dp[t][j][ss-i][(m-p[i-1])%m];
ret%=10000;
}
if(i==ss-1)ret+=dp[t][s[i]][ss-i][(m-p[i-1])%m];
}
if(t==0){
for(int j=0;j<min(s[i-1],s[i]);j++){
ret+=dp[t][j][ss-i][(m-p[i-1])%m];
ret%=10000;
}
if(s[i-1]<=s[i])break;
if(i==ss-1)ret+=dp[t][s[i]][ss-i][(m-p[i-1])%m];
}
}
return ret;
}
string f(string s){
int ss=s.size();
int k=ss-1;
while(s[k]==0){
s[k]=9;
k--;
}
s[k]--;
if(k==0&&s[k]==0){
string ret="";
char c='9'-48;
for(int i=0;i<ss-1;i++)ret+=c;
return ret;
}
return s;
}
int main(){
string a,b;
cin>>a;
cin>>b;
int sa=a.size(),sb=b.size();
for(int i=0;i<sa;i++)a[i]-=48;
for(int i=0;i<sb;i++)b[i]-=48;
scanf("%d",&m);
dp[0][0][0][0]=1; dp[1][10][0][0]=1; //dp[0][0][1][0]=1;
int s=max(sa,sb);
int t=1;
for(int j=1;j<=s;j++){
for(int i=0;i<=9;i++){
for(int k=0;k<m;k++){
for(int l=i+1;l<=10;l++){
dp[0][i][j][k]+=dp[1][l][j-1][(k-i*t+i*m)%m];
dp[0][i][j][k]%=10000;
}
}
}
for(int i=0;i<=9;i++){
for(int k=0;k<m;k++){
for(int l=0;l<i;l++){
dp[1][i][j][k]+=dp[0][l][j-1][(k-i*t+i*m)%m];
dp[1][i][j][k]%=10000;
}
}
}
t*=10;
t%=m;
}
a=f(a);
printf("%d\n",(count(b)-count(a)+10000)%10000);
}
|
#include <iostream>
#include <string>
#define UNDEF -1
#define UP 0
#define DN 1
#define NB 0
#define BD 1
using namespace std;
string buf;
int A[501],dp[501][10][2][2][500],len;
int M;
int dfs(int cnt,int dig,int udn,int bdr,int amr)
{
if(dp[cnt][dig][udn][bdr][amr] == UNDEF)
{
dp[cnt][dig][udn][bdr][amr] = 0;
if(cnt == 0)
{
if(amr == 0)
dp[cnt][dig][udn][bdr][amr]++;
}
else
{
if(udn == UP)
{
if(bdr == BD)
{
for(int nd = dig+1;nd < A[cnt-1];nd++)
{
dp[cnt][dig][udn][bdr][amr] += dfs(cnt-1,nd,DN,NB,((amr*10)+nd)%M);
}
if(A[cnt-1] > dig)
{
dp[cnt][dig][udn][bdr][amr] += dfs(cnt-1,A[cnt-1],DN,BD,((amr*10)+A[cnt-1])%M);
}
}
else
{
for(int nd = dig+1;nd < 10;nd++)
{
dp[cnt][dig][udn][bdr][amr] += dfs(cnt-1,nd,DN,NB,((amr*10)+nd)%M);
}
}
}
else
{
if(bdr == BD)
{
for(int nd = min(A[cnt-1]-1,dig-1);nd >= 0;nd--)
{
dp[cnt][dig][udn][bdr][amr] += dfs(cnt-1,nd,UP,NB,((amr*10)+nd)%M);
}
if(A[cnt-1] < dig)
{
dp[cnt][dig][udn][bdr][amr] += dfs(cnt-1,A[cnt-1],UP,BD,((amr*10)+A[cnt-1])%M);
}
}
else
{
for(int nd = dig-1;nd >= 0;nd--)
{
dp[cnt][dig][udn][bdr][amr] += dfs(cnt-1,nd,UP,NB,((amr*10)+nd)%M);
}
}
}
}
}
dp[cnt][dig][udn][bdr][amr] = dp[cnt][dig][udn][bdr][amr] % 10000;
return dp[cnt][dig][udn][bdr][amr];
}
int zigzag()
{
for(int cnt = 0;cnt < 501;cnt++)
{
for(int dig = 0;dig < 10;dig++)
{
for(int udn = 0;udn < 2;udn++)
{
for(int bdr = 0;bdr < 2;bdr++)
{
for(int amr = 0;amr < 500;amr++)
{
dp[cnt][dig][udn][bdr][amr] = UNDEF;
}
}
}
}
}
int result;
if(len == 1)
result = A[0]/M;
else
{
result = 9 / M;
for(int cnt = 1;cnt < len-1;cnt++)
{
for(int dig = 1;dig < 10;dig++)
{
result += dfs(cnt,dig,UP,NB,dig);
result += dfs(cnt,dig,DN,NB,dig);
}
result = result % 10000;
}
for(int dig = 1;dig < A[len-1];dig++)
{
result += dfs(len-1,dig,UP,NB,dig);
result += dfs(len-1,dig,DN,NB,dig);
}
result += dfs(len-1,A[len-1],UP,BD,A[len-1]);
result += dfs(len-1,A[len-1],DN,BD,A[len-1]);
result = result % 10000;
}
return result;
}
int main(void)
{
cin >> buf;
len = buf.length();
char t;
for(int i = 0;i < len;i++)
{
t = buf[(len-1)-i];
A[i] = atoi(&t);
}
for(int i = 0;i < len;i++)
{
if(A[i] != 0)
{
A[i]--;
break;
}
}
cin >> buf;
cin >> M;
int zig1 = zigzag();
len = buf.length();
for(int i = 0;i < len;i++)
{
t = buf[(len-1)-i];
A[i] = atoi(&t);
}
int zig2 = zigzag();
cout << ((zig2 - zig1)+10000)%10000 << endl;
}
|
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
#include<cmath>
#include<climits>
#include<string>
#include<set>
#include<map>
#include<iostream>
using namespace std;
#define rep(i,n) for(int i=0;i<((int)(n));i++)
#define reg(i,a,b) for(int i=((int)(a));i<=((int)(b));i++)
#define irep(i,n) for(int i=((int)(n))-1;i>=0;i--)
#define ireg(i,a,b) for(int i=((int)(b));i>=((int)(a));i--)
typedef long long int lli;
typedef pair<int,int> mp;
#define fir first
#define sec second
#define IINF INT_MAX
#define LINF LLONG_MAX
#define eprintf(...) fprintf(stderr,__VA_ARGS__)
int m;
#define MOD 10000
int dp[505][505][15][2][2]; //keta,amari,sento,zanonaoke,sameok,muki
//p0 .. sameok,p1 .. sameng
bool isgz(string s){
int r = 0;
rep(i,s.size()){
r = (r*10+s[i]-'0')%m;
}
if(r%m!=0)return false;
if(s.size()<=1)return true;
if(s[0]==s[1])return false;
int d = (s[0]>s[1]?1:0);
rep(i,s.size()){
if(!i)continue;
if(d^(s[i]>s[i-1]?1:0)^(i%2))return false;
}
return true;
}
int gzn(string s){
{
string ts = "";
irep(i,s.size()){
ts += s[i];
}
swap(s,ts);
}
memset(dp,0,sizeof(dp));
int res=0;
int ls=s.size();
rep(j,10){
int i = j%m;
if(i==0)res++;
rep(k,2){
if((s[0]-'0')>=j)dp[1][i][j][0][k]=1;
else dp[1][i][j][1][k]=1;
}
}
//printf("i.1 . %d\n",res);
int bm=10%m;
reg(i,2,ls){
rep(j,m){
rep(k,10){
rep(p,2){
rep(q,2){
int& d = dp[i][j][k][p][q]; //sameok
int c = s[i-1]-'0';
int am = (bm*k)%m;
//?????????j-am????????????
int bj = (j-am+m)%m;
rep(bk,10){
rep(bp,2){
if(p==0){
if(c<k)continue;
if(c==k && bp==1)continue;
}
else{
if(c>k)continue;
if(c==k && bp==0)continue;
}
if(bk==k)continue;
if(q^(i%2)^(bk<k?1:0))continue;
d = (d+dp[i-1][bj][bk][bp][q])%MOD;
}
}
if(i<ls && j==0 && k!=0)res = (res+d)%MOD; //0pad
}
}
}
}
bm = (bm*10)%m;
//printf("i.%d .. %d\n",i,res);
}
/*
reg(i,1,ls){
rep(k,10){
printf("%d %d : ",i,k);
rep(j,m){
printf("(%d %d,%d %d) ",dp[i][j][k][0][0],dp[i][j][k][0][1],dp[i][j][k][1][0],dp[i][j][k][1][1]);
}
printf("\n");
}
}
*/
if(ls>1){
reg(i,1,9){
rep(k,2){
res = (res+dp[ls][0][i][0][k])%MOD;
}
}
}
else{
res=(s[0]-'0')/m+1;
}
//printf("%s .. %d\n",s.c_str(),res);
return res;
}
int main(void){
string a,b;
cin >> a >> b >> m;
int ma = gzn(a);
int mb = gzn(b);
if(isgz(a))mb++;
printf("%d\n",(MOD+mb-ma)%MOD);
return 0;
}
|
#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <algorithm>
#include <queue>
#include <stack>
#include <functional>
#include <bitset>
#include <assert.h>
#include <unordered_map>
#include <fstream>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef pair<int,int> pii;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(int i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 510000;
ll dy[8] = {1,-1,0,0,1,-1,1,-1};
ll dx[8] = {0,0,1,-1,1,-1,-1,1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
if(a>b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
if(a<b){
a = b; return true;
}
else return false;
}
template<typename T> inline void print(T &a){
rep(i,a.size()) cout << a[i] << " ";
cout << "\n";
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){cout << a << " " << b << "\n";}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << "\n";
}
const int mod = 1e9 + 7;
//const int mod = 998244353;
int dp[505][505][10][3][2];
int m;
int M = 10000;
int solve(string s){
int n = s.size();
rep(i,n+1) rep(j,m) rep(k,10) rep(l,3) rep(o,2) dp[i][j][k][l][o] = 0;
dp[0][0][0][1][0] = 1;
rep(i,n){
int c = s[i] - '0';
rep(j,m){
rep(k,10){
rep(l,10){
if(k+l == 0) dp[i+1][j][0][1][0] += dp[i][j][0][1][0];
else if(l == 0){
if(i == 0){
if(k <= c) dp[i+1][(j*10+k)%m][k][1][(k<c)] += dp[i][j][0][1][0];
}else{
dp[i+1][(j*10+k)%m][k][1][1] += dp[i][j][0][1][0];
}
}else{
if(k==l) continue;
if(k<c) rep(o,2) dp[i+1][(j*10+k)%m][k][(k<l)*2][1] += dp[i][j][l][1][o];
else if(k==c) rep(o,2) dp[i+1][(j*10+k)%m][k][(k<l)*2][o] += dp[i][j][l][1][o];
else dp[i+1][(j*10+k)%m][k][(k<l)*2][1] += dp[i][j][l][1][1];
}
if(k == l) continue;
if(k<c) rep(o,2) dp[i+1][(j*10+k)%m][k][(k<l)*2][1] += dp[i][j][l][(k>l)*2][o];
else if(k==c) rep(o,2) dp[i+1][(j*10+k)%m][k][(k<l)*2][o] += dp[i][j][l][(k>l)*2][o];
else dp[i+1][(j*10+k)%m][k][(k<l)*2][1] += dp[i][j][l][(k>l)*2][1];
rep(o,3) rep(p,2) dp[i+1][(j*10+k)%m][k][o][p] %= M;
}
}
}
}
ll ans = 0;
rep(i,10) rep(j,3) rep(k,2){
ans += dp[n][0][i][j][k];
ans %= M;
}
ans = (ans - 1 + M) % M;
return ans;
}
int main(){
string a,b; cin >> a >> b;
cin >> m;
if(a.back() != '0') a.back()--;
else{
for(ll i=a.size()-1; i>=0; i--){
if(a[i] != '0'){
a[i]--;
break;
}
a[i] = '9';
}
if(a[0] == '0') a.erase(a.begin());
}
cout << (solve(b) - solve(a) + M) % M << "\n";
}
|
#include<bits/stdc++.h>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
const int mod=10000;
char a[505],b[505];
int m;
int dp[501][500][10][2][2];//????????????m??§?????£??????????????°??????????????????????¢?????????????????°?????????????n??¨?????´?????????????????´?????????
int check(char *n){//n??\???????????°??¶??°??°
int i;
for(i=0;i<501;i++) for(int j=0;j<500;j++) for(int k=0;k<10;k++) for(int r=0;r<2;r++) for(int l=0;l<2;l++) dp[i][j][k][r][l]=0;
for(i=1;n[i+1]!=0;i++) for(int k=1;k<10;k++) for(int r=0;r<2;r++) dp[i][k%m][k][r][0]=1;
for(int k=1;k<10;k++) dp[i][k%m][k][0][0]=1;
for(i=1;i<n[0]-48;i++) dp[0][i%m][i][1][0]=dp[0][i%m][i][0][0]=1;
dp[0][(n[0]-48)%m][n[0]-48][0][1]=dp[0][(n[0]-48)%m][n[0]-48][1][1]=1;
for(i=0;n[i+1]!=0;i++) for(int j=0;j<m;j++) for(int k=0;k<10;k++){
for(int z=0;z<10;z++){
if(k==z) continue;
dp[i+1][(j*10+z)%m][z][z>k][0]+=dp[i][j][k][z<k][0];
if(n[i+1]-48==z) dp[i+1][(j*10+z)%m][z][z>k][1]+=dp[i][j][k][z<k][1];
if(n[i+1]-48>z) dp[i+1][(j*10+z)%m][z][z>k][0]+=dp[i][j][k][z<k][1];
dp[i+1][(j*10+z)%m][z][z>k][0]%=10000;
}
}
int res=0;
if(i==0){
for(int j=1;j<=n[0]-48;j++) if(j%m==0) res++;
return res;
}
for(int k=0;k<10;k++) for(int r=0;r<2;r++) for(int l=0;l<2;l++){ res+=dp[i][0][k][r][l]; res%=10000;}
return res%10000;
}
int zig(char *n){//n????????°??¶??°?????????
if(n[1]==0) return 1;
if(n[0]==n[1]) return 1;
bool c=n[0]<n[1];
for(int i=1;n[i+1]!=0;i++) if((n[i]<n[i+1])==c||n[i]==n[i+1]) return 0; else c=n[i]<n[i+1];
return 1;
}
int main(){
scanf("%s%s%d",a,b,&m);
printf("%d\n",(check(b)-check(a)+zig(a)+10000)%10000);
}
|
#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];
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 <iostream>
#include <vector>
#include <numeric>
using namespace std;
class range {
private:
struct Iterator {
int val;
int operator*() {return val;}
bool operator!=(Iterator &itr) {return val < itr.val;}
void operator++() {++val;}
};
Iterator i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iterator &begin() {return i;}
Iterator &end() {return n;}
};
template<class T> T at(vector<T> v, int i) {return v[(i % (int)v.size() + v.size()) % v.size()];}
const long long MOD = 10000;
class Inverse {
private:
vector<long long> inv;
public:
Inverse(int n) {
inv = vector<long long>(n, 1);
for (int i : range(2, n)) inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
}
long long operator()(long long a) const {
if (a < (int)inv.size()) return inv[a];
long long b = MOD, x = 1, y = 0;
while (b) {
long long t = a / b;
swap(a -= t * b, b);
swap(x -= t * y, y);
}
return (MOD + x % MOD) % MOD;
}
};
Inverse inv(1000000);
class Mint {
private:
long long val;
public:
Mint() {}
Mint(long long val) : val(val % MOD) {}
Mint operator+=(const Mint &m) {
val += m.val;
if (val >= MOD) val -= MOD;
return *this;
}
Mint operator-=(const Mint &m) {
val -= m.val;
if (val < 0) val += MOD;
return *this;
}
Mint operator*=(const Mint &m) {
val *= m.val;
val %= MOD;
return *this;
}
Mint operator/=(const Mint &m) {
val *= inv(m.val);
val %= MOD;
return *this;
}
Mint operator+(const Mint &m) const {
Mint res = *this;
res += m;
return res;
}
Mint operator-(const Mint &m) const {
Mint res = *this;
res -= m;
return res;
}
Mint operator*(const Mint &m) const {
Mint res = *this;
res *= m;
return res;
}
Mint operator/(const Mint &m) const {
Mint res = *this;
res /= m;
return res;
}
Mint operator++() {return val += 1;}
Mint operator--() {return val -= 1;}
Mint operator=(int n) {return *this = Mint(n);}
operator long long() {
return val;
}
};
ostream &operator<<(ostream &os, Mint a) {
os << (long long)a;
return os;
}
istream &operator>>(istream &is, Mint &a) {
long long n;
is >> n;
a = Mint(n);
return is;
}
#include <sstream>
template<class A, class B> B convert(A a) {
stringstream ss;
ss << a;
B b;
ss >> b;
return b;
}
bool iszigzag(int a, int m) {
if (a % m) return false;
string s = convert<int, string>(a);
for (int i : range(s.size() - 1)) {
if (i % 2 == 0 && s[i] <= s[i + 1]) return false;
if (i % 2 == 1 && s[i] >= s[i + 1]) return false;
}
return true;
}
bool iszagzig(int a, int m) {
if (a % m) return false;
string s = convert<int, string>(a);
for (int i : range(s.size() - 1)) {
if (i % 2 == 1 && s[i] <= s[i + 1]) return false;
if (i % 2 == 0 && s[i] >= s[i + 1]) return false;
}
return true;
}
Mint solve(string s, Mint m) {
if (s == "0") return 0;
Mint res = 0;
for (int t : range(2)) {
vector<vector<vector<Mint>>> dp(2, vector<vector<Mint>>(11, vector<Mint>(m, 0)));
for (int i : range(1, s[0] - '0')) dp[0][i][i % m] = 1;
dp[0][10][int(s[0] - '0') % m] = 1;
for (int i : range(1, s.size())) {
if (i % 2 == t) {
for (int mm : range(m)) for (int j : range(10)) for (int k : range(j)) dp[1][j][(mm * 10 + j) % m] += dp[0][k][mm];
for (int mm : range(m)) for (int j : range(s[i] - '0')) if (j > s[i - 1] - '0') dp[1][j][(mm * 10 + j) % m] += dp[0][10][mm];
if (s[i - 1] < s[i]) for (int mm : range(m)) dp[1][10][(mm * 10 + s[i] - '0') % m] += dp[0][10][mm];
for (int j : range(1, 10)) ++dp[1][j][j % m];
} else {
for (int mm : range(m)) for (int j : range(10)) for (int k : range(j + 1, 10)) dp[1][j][(mm * 10 + j) % m] += dp[0][k][mm];
for (int mm : range(m)) for (int j : range(s[i] - '0')) if (j < s[i - 1] - '0') dp[1][j][(mm * 10 + j) % m] += dp[0][10][mm];
if (s[i - 1] > s[i]) for (int mm : range(m)) dp[1][10][(mm * 10 + s[i] - '0') % m] += dp[0][10][mm];
for (int j : range(1, 10)) ++dp[1][j][j % m];
}
dp[0] = dp[1];
for (auto &i : dp[1]) fill(i.begin(), i.end(), 0);
}
for (const auto &i : dp[0]) res += i[0];
}
if (s.size() == 1u) {
for (int i : range(1, convert<string, int>(s))) if (i % m == 0) --res;
} else {
for (int i : range(1, 10)) if (i % m == 0) --res;
}
return res;
}
int main() {
string a, b;
Mint m;
cin >> a >> b >> m;
for (int i = a.size() - 1; i >= 0; --i) {
if (a[i] != '0') {
--a[i];
break;
} else {
a[i] = '9';
}
}
while (a.size() > 1u && a[0] == '0') a = a.substr(1);
cout << solve(b, m) - solve(a, m) << endl;
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef short T;
const int MOD = 10000;
bool even_is_up;
inline bool up_turn(int col) {
bool even = (col & 1) == 0;
return even_is_up ? even : !even;
}
// テ・ツ青?、ツスツ催」ツ?ョ M テ」ツ?ォテ」ツつ暗」ツつ?MODテッツシツ?
// mod_of[0]テ」ツ??テ」ツ?ョテ、ツスツ催ッツシツ稽od_of[1]テ」ツ??0テ」ツ?ョテ、ツスツ催「ツ?ヲテ「ツ?ヲ
int mod_of[501];
int M;
// memo[high_limited][low_limited][prev_digit][column][acc]
T memo[2][2][16][512][500];
vector<int> low_digits, high_digits;
int dfs(int col, int high_limited, int low_limited, int prev, int acc) {
if(col == -1) return acc == 0;
bool first_digit = (prev < 0 || prev >= 10);
T dmy = -1;
T &res = first_digit ? dmy : memo[high_limited][low_limited][prev][col][acc];
//cout << "come " << col << ' ' << prev << ' ' << acc << ": res = " << res << endl;
if(res < 0) {
res = 0;
int low = low_limited ? low_digits[col] : 0;
int high = high_limited ? high_digits[col] : 9;
if(first_digit) low = max(low, 1);
if(up_turn(col)) {
low = max(low, prev+1);
} else {
high = min(high, prev-1);
}
for(int digit = low; digit <= high; ++digit) {
int next_hl = high_limited && (digit == high_digits[col]);
int next_ll = low_limited && (digit == low_digits[col]);
//cout << col << ' ' << high_limited << ' ' << low_limited << ' ' << acc << ": choose " << digit << endl;
res += dfs(col-1, next_hl, next_ll, digit, (acc+mod_of[col]*digit) % M);
res %= MOD;
}
}
return res;
}
void clear_memo() {
const int nelems = sizeof(memo) / sizeof(T);
fill_n((T*)memo, nelems, -1);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
string A, B;
cin >> A >> B >> M;
mod_of[0] = 1 % M;
for(int i = 1; i <= 500; ++i) {
mod_of[i] = (mod_of[i-1]*10) % M;
}
for(string::reverse_iterator it = A.rbegin(); it != A.rend(); ++it) {
low_digits.push_back(*it - '0');
}
for(string::reverse_iterator it = B.rbegin(); it != B.rend(); ++it) {
high_digits.push_back(*it - '0');
}
for(int i = 0; i < (int)B.size()-(int)A.size(); ++i) {
low_digits.push_back(0); // sentinel
}
const int low_ord = (int)A.size()-1;
const int high_ord = (int)B.size()-1;
int res = 0;
for(int step = 0; step < 2; ++step) {
//cout << "step " << step << endl;
even_is_up = (step == 0);
clear_memo();
for(int col = high_ord; col >= low_ord; --col) {
if(col == 0 && step == 1) break; // 1テヲツ。ツ?」ツ?ョテヲツ閉ーテ」ツ?ョテ、ツコツ古ゥツ?催」ツつォテ」ツつヲテ」ツδウテ」ツδ暗ゥツ伉イテヲツュツ「
bool low_limited = (col == low_ord);
bool high_limited = (col == high_ord);
int prev = up_turn(col) ? -1 : 10;
res += dfs(col, high_limited, low_limited, prev, 0);
res %= MOD;
}
}
cout << res << endl;
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
using namespace std;
#define MOD (10000)
string A,B;
int a[511],b[511];
int M,N;
int dp[501][501][10][2][3];//桁、割ったあまり、前回の値、減少or増加、aを使ったかbを使ったか
int lth(int num,int n){
return (num*10+n)%M;
}
//桁,割ったあまり,前回の値,1:増加or2:減少,1bit:aを使ったか2bit:bを使ったか,0以外が出たかどうか
int solve(int no,int m,int zg,int zgf,int fl,bool uz){
// printf("%d %d %d %d %d\n",no,m,zg,zgf,fl);
if(no==N){
if(m==0 && uz)
//printf("%d %d %d %d %d\n",no,m,zg,zgf,fl);
return 1;
//return 1;
else
return 0;
//return 0;
}
if(zgf>=0) if(dp[no][m][zg][zgf][fl]!=-1) return dp[no][m][zg][zgf][fl];
int ret = 0;
for(int i=0;i<=9;i++){
/* if(!uz){
if( i < a[no] ) continue;
ret += solve(no+1,lth(m,i),i,0,fl,(uz || i!=0));
ret %= MOD;
} else{*/
if(zgf==0 && zg<i) continue;
if(zgf==1 && zg>i) continue;
if(zg==i && uz) continue;
if( i < a[no] && (fl&1) ) continue;
if( i > b[no] && (fl&2) ) continue;
int fl2 = fl;
if( i != a[no] ) fl2=fl2&~1;
if( i != b[no] ) fl2=fl2&~2;
int zgf2;
if(zg<i) zgf2=0;
else zgf2=1;
if(!uz) zgf2=-1;
ret += solve(no+1,lth(m,i),i,zgf2,fl2,uz || i!=0);
ret%=MOD;
}
if(zgf>=0)
return dp[no][m][zg][zgf][fl]=ret;
return ret;
//return ret;
}
int solve(){
int ret=0;
for(int i=0; i<=9; i++){
int fl=3;
if( i < a[0] ) continue;
if( i > b[0] ) continue;
if( i != a[0]) fl=fl&~1;
if( i != b[0] ) fl=fl&~2;
ret += solve(1,i%M,i,-1,fl,i!=0);
ret%=MOD;
}
return ret;
}
int main(){
memset(dp,-1,sizeof(dp));
cin >> A >> B >> M;
N = B.size();
for(int i=0;i<N;i++){
b[i]=B[i]-'0';
if(N-(int)A.size()<=i) a[i]=A[i-(N-(int)A.size())]-'0';
}
/* for(int i=0;i<N;i++) cout << a[i];
puts("");
for(int i=0;i<N;i++) cout << b[i];
puts("");*/
cout << solve() << "\n";
}
|
#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];
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(i, 2)rep(j, 10)rep(t, 3) {
if (!i && !o)continue;
(sum += dp[len[o]][i][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<iostream>
#include<string>
using namespace std;
int dp[501 + 10][2][10][3][500];
//dp[a][b][c][d][e]:a桁目 b1で自由に使える0で自由に使えない 今の桁はc
//d1で前より上がってる2で前より下がってる0で前と変わらない eは余り
int MOD = 10000;
int M;
string A, B;
//1~nまでのジグザグ数%10000
int calc(string n) {
for (int i = 0; i <= 500; i++)for (int j = 0; j < 2; j++)for (int k = 0; k < 10; k++)
for (int l = 0; l < 3; l++)for (int m = 0; m < 500; m++)dp[i][j][k][l][m] = 0;
for (int i = 0; i < n[0] - '0'; i++)
dp[1][1][i][0][i % M] = 1;
dp[1][0][(n[0] - '0')][0][(n[0] - '0') % M] = 1;
for (int a = 1; a < n.size(); a++) {
for (int b = 0; b < 2; b++) {
int limit = b ? 9 : n[a] - '0';
for (int c = 0; c <= limit; c++) {
for (int d = 0; d <= (b ? 9 : n[a - 1] - '0'); d++) {
for (int e = 0; e < 3; e++) {
for (int f = 0; f < M; f++) {
if (e == 0) {
//前と比べて増加も減少もしてない
if (d == 0) {
(dp[a + 1][b || c < limit][c][0][(f * 10 + c) % M] += dp[a][b][d][e][f]) %= MOD;
}
else {
if (c < d) {
(dp[a + 1][b || c < limit][c][2][(f * 10 + c) % M] += dp[a][b][d][e][f]) %= MOD;
}
if (c > d) {
(dp[a + 1][b || c < limit][c][1][(f * 10 + c) % M] += dp[a][b][d][e][f]) %= MOD;
}
}
}
else if (e == 1) {
//今増加→次減少
if (c >= d)continue;
(dp[a + 1][b || c < limit][c][2][(f * 10 + c) % M] += dp[a][b][d][e][f]) %= MOD;
}
else if (e == 2) {
//今減少→次増加
if (c <= d)continue;
(dp[a + 1][b || c < limit][c][1][(f * 10 + c) % M] += dp[a][b][d][e][f]) %= MOD;
}
}
}
}
}
}
}
int ans = 0;
for (int b = 0; b < 2; b++)for (int c = 0; c <= 9; c++)for (int e = 0; e <= 2; e++)
ans += dp[n.size()][b][c][e][0];
ans--;
ans %= MOD;
return ans;
}
bool isZigZag(string n) {
bool f;
if (n.size() == 1)return true;
if (n[0] == n[1])return false;
if (n[0] > n[1])f = true;
if (n[0] < n[1])f = false;
for (int i = 1; i < n.size() - 1; i++) {
if (f) {
if (n[i + 1] <= n[i])return false;
f = !f;
}
else {
if (n[i + 1] >= n[i])return false;
f = !f;
}
}
return true;
}
int main() {
cin >> A >> B >> M;
cout << (calc(B) - calc(A) + isZigZag(A) + MOD) % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e4;
int memo[501][10][2][2][500];
string S;
int N, M;
int dfs(int i, int p, bool up, bool tight, int tot) {
if (i == N) return tot == 0;
int& r = memo[i][p][up][tight][tot];
if (r != -1) return r;
int x = S[i] - '0';
int L = 0, R = 10;
if (up) {
L = p + 1;
} else {
R = p;
}
if (tight) R = min(R, x + 1);
r = 0;
for (int j = L; j < R; j++) {
r += dfs(i + 1, j, !up, tight && j == x, (10 * tot + j) % M);
}
return r %= MOD;
}
int solve(string s) {
S = s;
N = s.size();
memset(memo, -1, sizeof(memo));
int r = 0;
for (int k = 0; k < N; k++) {
int x = S[k] - '0';
int L = 1, R = 10;
if (k == 0) R = min(R, x + 1);
for (int i = L; i < R; i++) {
bool tight = k == 0 && i == x;
r += dfs(k + 1, i, 1, tight, i % M);
if (k < N - 1) { r += dfs(k + 1, i, 0, tight, i % M); }
}
r %= MOD;
}
return r;
}
string decr(string s) {
for (int i = s.size() - 1; i >= 0 && s[i]-- == '0'; s[i++] = '9');
return s.substr(s.size() > 1 && s[0] == '0');
}
int main() {
string A, B;
cin >> A >> B >> M;
cout << (solve(B) + MOD - solve(decr(A))) % MOD << endl;
}
|
#include<cstdio>
#include<cstring>
char a[505], b[505];
int dp[505][10][500][2][3];
int m, lena, lenb, ans = 10000;
int solvea(int keta, int last, int mod, int zigzag, int less){
int res = 0;
if(dp[keta][last][mod][zigzag][less] != -1)return dp[keta][last][mod][zigzag][less];
if(keta == lena){
if(mod == 0 && less == 1 && !(keta == 1 && zigzag == 1))res = 1;
else res = 0;
}
else if(keta == 0){
for(int i = 1;i <= 9;i++){
if(i < a[0] - '0')
res += solvea(1, i, i % m, 0, 1) + solvea(1, i, i % m, 1, 1);
if(i == a[0] - '0')
res += solvea(1, i, i % m, 0, 0) + solvea(1, i, i % m, 1, 0);
if(i > a[0] - '0')
res += solvea(1, i, i % m, 0, 2) + solvea(1, i, i % m, 1, 2);
}
}
else{
if(mod == 0 && !(keta == 1 && zigzag == 1))res++;
if(zigzag == 0){
for(int i = 0;i < last;i++){
if(less == 0){
if(i < a[keta] - '0')
res += solvea(keta + 1, i, (mod * 10 + i) % m, 1, 1);
if(i == a[keta] - '0')
res += solvea(keta + 1, i, (mod * 10 + i) % m, 1, 0);
if(i > a[keta] - '0')
res += solvea(keta + 1, i, (mod * 10 + i) % m, 1, 2);
}
else{
res += solvea(keta + 1, i, (mod * 10 + i) % m, 1, less);
}
}
}
if(zigzag == 1){
for(int i = last + 1;i <= 9;i++){
if(less == 0){
if(i < a[keta] - '0')
res += solvea(keta + 1, i, (mod * 10 + i) % m, 0, 1);
if(i == a[keta] - '0')
res += solvea(keta + 1, i, (mod * 10 + i) % m, 0, 0);
if(i > a[keta] - '0')
res += solvea(keta + 1, i, (mod * 10 + i) % m, 0, 2);
}
else{
res += solvea(keta + 1, i, (mod * 10 + i) % m, 0, less);
}
}
}
}
return dp[keta][last][mod][zigzag][less] = res % 10000;
}
int solveb(int keta, int last, int mod, int zigzag, int less){
int res = 0;
if(dp[keta][last][mod][zigzag][less] != -1)return dp[keta][last][mod][zigzag][less];
if(keta == lenb){
if(mod != 0 || less == 2)res = 0;
else res = 1;
}
else if(keta == 0){
for(int i = 1;i <= 9;i++){
if(i < b[0] - '0')
res += solveb(1, i, i % m, 0, 1) + solveb(1, i, i % m, 1, 1);
if(i == b[0] - '0')
res += solveb(1, i, i % m, 0, 0) + solveb(1, i, i % m, 1, 0);
if(i > b[0] - '0')
res += solveb(1, i, i % m, 0, 2) + solveb(1, i, i % m, 1, 2);
}
}
else{
if(mod == 0 && !(keta == 1 && zigzag == 1))res++;
if(zigzag == 0){
for(int i = 0;i < last;i++){
if(less == 0){
if(i < b[keta] - '0')
res += solveb(keta + 1, i, (mod * 10 + i) % m, 1, 1);
if(i == b[keta] - '0')
res += solveb(keta + 1, i, (mod * 10 + i) % m, 1, 0);
if(i > b[keta] - '0')
res += solveb(keta + 1, i, (mod * 10 + i) % m, 1, 2);
}
else{
res += solveb(keta + 1, i, (mod * 10 + i) % m, 1, less);
}
}
}
else{
for(int i = last + 1;i <= 9;i++){
if(less == 0){
if(i < b[keta] - '0')
res += solveb(keta + 1, i, (mod * 10 + i) % m, 0, 1);
if(i == b[keta] - '0')
res += solveb(keta + 1, i, (mod * 10 + i) % m, 0, 0);
if(i > b[keta] - '0')
res += solveb(keta + 1, i, (mod * 10 + i) % m, 0, 2);
}
else{
res += solveb(keta + 1, i, (mod * 10 + i) % m, 0, less);
}
}
}
}
return dp[keta][last][mod][zigzag][less] = res % 10000;
}
int main(){
scanf("%s\n%s\n%d", a, b, &m);
lena = strlen(a);
lenb = strlen(b);
memset(dp, -1, sizeof(dp));
ans += solveb(0, 0, 0, 0, 0);
memset(dp, -1, sizeof(dp));
ans -= solvea(0, 0, 0, 0, 0);
printf("%d\n", ans % 10000);
}
|
// 0570.cpp
// 12/03/19.
#if 1
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <cctype>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <iterator>
#include <bitset>
#include <complex>
#include <fstream>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T> T RoundOff(T a){ return int(a+.5-(a<0)); }
template<class T, class C> void chmax(T& a, C b){ if(a < b) a = b; }
template<class T, class C> void chmin(T& a, C b){ if(b < a) a = b; }
template<class T, class C> pair<T, C> mp(T a, C b){ return make_pair(a, b); }
const int MOD = 10000;
int memo[501][10][2][2][501];
string A, B;
int M;
// x*10^nをvで割った時の余り
int calc_rest(int x, int n, int v)
{
for(int i = 0; i < n; i++)
{
x -= (x / v) * v;
x *= 10;
}
return x / 10;
}
// 数値列をディクリメントする
string dec(string S)
{
for(int i = S.size() - 1; 0 <= i; i--)
{
if(S[i] != '0')
{
S[i]--;
if(S[i] == '0' && i == 0 && 1 < S.size()) S = S.substr(1);
return S;
}
else S[i] = '9';
}
return S;
}
// S=対象の文字列, pnt=着目している文字の場所, prv=直前の文字, ul=数字は増えるか, sp=既に最大の数より小さいことが決まっているか, rest=累積の余り, zero=最初であり0が禁止されているか
int rec(string &S, int pnt, int prv, bool inc, bool sp, int rest, bool zero)
{
if(pnt == S.size()) return rest == 0;
if(!zero && memo[pnt][prv][inc][sp][rest] != -1) return memo[pnt][prv][inc][sp][rest];
int dig = S.size() - pnt;
ll res = 0;
if(inc)
{
int lim = (sp ? 10 : S[pnt] - '0' + 1);
for(int i = prv + 1; i < lim; i++)
{
res += rec(S, pnt + 1, i, false, sp || i < S[pnt] - '0', (rest * 10 + i) % M, false);
res %= MOD;
}
}
else
{
for(int i = min(prv - 1, (sp ? prv - 1 : S[pnt] - '0')); i >= zero; i--)
{
res += rec(S, pnt + 1, i, true, sp || i < S[pnt] - '0', (rest * 10 + i) % M, false);
res %= MOD;
}
}
return memo[pnt][prv][inc][sp][rest] = res;
}
// S以下のZigZagNumberを数える
int count(string &S)
{
if(S.size() == 1) return (S[0] - '0') / M;
memset(memo, -1, sizeof memo);
ll res = 9 / M;
for(int i = 1; i < S.size(); i++)
{
int inc = rec(S, S.size() - i - 1, 0, true, i != S.size() - 1, 0, false);
int fal = rec(S, S.size() - i - 1, (i == S.size() - 1 ? S[0] - '0' + 1 : 10), false, i != S.size() - 1, 0, true);
res += inc + fal;
res %= MOD;
}
return res;
}
int solve()
{
A = dec(A);
return (count(B) - count(A) + MOD) % MOD;
}
int main()
{
cin >> A >> B >> M;
cout << solve() << endl;
}
#endif
|
#include <bits/stdc++.h>
using namespace std;
#define DUMP(x) cerr << #x << "=" << x << endl
#define DUMP2(x, y) cerr<<"("<<#x<<", "<<#y<<") = ("<<x<<", "<<y<<")"<< endl
#define BINARY(x) static_cast<bitset<16> >(x)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define in_range(x, y, w, h) (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
#define ALL(a) (a).begin(),(a).end()
typedef long long ll;
const int INF = 1e9;
typedef pair<int, int> PII;
int dx[4]={0, -1, 1, 0}, dy[4]={-1, 0, 0, 1};
const int MOD = 10000;
int dp[501][500][10][3][2];
int M, L;
string N;
int solve(int n, int m, int last, int up, int same)
{
if (n == L) return !m;
if (dp[n][m][last][up][same] != -1) return dp[n][m][last][up][same];
int res = 0;
rep(d, 10) {
int nsame = 0;
if (same && d > N[n] - '0') break;
if (same && d == N[n] - '0') nsame = 1;
int nup = (up + 1) % 2;
if (up == 0 && last >= d) continue;
if (up == 1 && last <= d) continue;
if (up == 2 && last && last == d) continue;
if (up == 2) {
if (last == 0) nup = 2;
else if (last < d) nup = 1;
else if (last > d) nup = 0;
else assert(false);
}
res += solve(n+1, (m * 10 + d) % M, d, nup, nsame);
res %= MOD;
}
return dp[n][m][last][up][same] = res;
}
/**
int calc(string N, int M)
{
int L = N.size();
memset(dp, 0, sizeof(dp));
dp[0][0][0][2][1] = 1;
rep(i, L) rep(m, M) rep(last, 10) rep(up, 3) rep(same, 2) {
if (dp[i][m][last][up][same] == 0) continue;
rep(d, 10) {
int nup = (up + 1) % 2;
if (up == 0 && last >= d) continue;
if (up == 1 && last <= d) continue;
if (up == 2) {
if (last == 0) nup = 2;
else if (last < d) nup = 1;
else if (last > d) nup = 0;
else continue;
}
int nsame = 0;
if (same && d > N[i] - '0') break;
if (same && d == N[i] - '0') nsame = 1;
dp[i+1][(m*10 + d) % M][d][nup][nsame] += dp[i][m][d][up][same];
// dp[i+1][(m*10 + d) % M][d][nup][nsame] %= MOD;
cerr << "A" << endl;
}
}
#if 1
rep(i, L) rep(m, M) rep(last, 10) rep(up, 3) rep(same, 2) {
cerr << i+1 << " " << m << " " << last << " " << up << " " << same << " : ";
cerr << dp[i+1][m][last][up][same] << endl;
}
#endif
int res = 0;
rep(last, 10) rep(up, 2) rep(same, 2) {
res += dp[L][0][last][up][same];
}
return res - 1;
}
*/
int main()
{
/*
int M;
string A, B;
cin >> A >> B >> M;
cout << calc(B, M) - calc(A, M) + sim(A, true) + sim(A, false) << endl;
*/
string A, B;
cin >> A >> B >> M;
// A -= 1
for (int i=A.size()-1; i>=0; i--) {
if (A[i] == '0') A[i] = '9';
else {
A[i]--;
break;
}
}
N = A;
L = N.size();
memset(dp, -1, sizeof(dp));
int tmpa = solve(0, 0, 0, 2, 1);
N = B;
L = N.size();
memset(dp, -1, sizeof(dp));
int tmpb = solve(0, 0, 0, 2, 1);
cout << (tmpb - tmpa + MOD) % MOD << endl;
}
|
#include <cstdio>
#include <vector>
#include <bits/stdc++.h>
template<typename T>
void fill_all(T& i, const T& v){
i = v;
}
template<typename U, typename T, size_t N>
void fill_all(T (&arr)[N], const U& v){
for(auto& i : arr){
fill_all(i, v);
}
}
#if 1
int N=0;
char TOP[5010];
std::string BTM;
int BACE;
int16_t dp[2][2][2][12][2][500][1000];//is_zero, is_bef_less, is_bef_biger, ??´???, is_upper, ??´????????§???mod, i ??¶?´?????????????i??\??????????????°
int16_t func(bool is_zero, bool is_bef_less, bool is_bef_biger, int8_t bef, bool is_upper, int16_t mod, int16_t i);
int16_t func_run(bool is_zero, bool is_bef_less, bool is_bef_biger, int8_t bef, bool is_upper, int16_t mod, int16_t i)
{
#ifdef DEBUG
std::cout << "in[" <<(is_zero?1:0)<<' '<<(is_bef_less?1:0)<<' '<<(is_bef_biger?1:0)<<' '<<(int)(bef)<<' '<<(is_upper?1:0)<<' '<<(mod)<<' '<<(i)<<"]\n";
#endif
auto call = [&](bool l,bool b, int8_t v){return func(false,l,b,v,!is_upper, (mod*10+v)%BACE, i+1);};
int res = 0;
int fend = 9;//[]????????¨???
int fbegin = 0;
if(is_zero)
{
//????°??????????????????????0????¶????
if('0'==BTM[i]){res += func(true, true, false, 0, false, 0, i+1);}
//0????????°??????????????????
if(i<N-1){res += func(false, is_bef_less, is_bef_biger, -1, true, 0, i);}
mod = 0;
fend = 9; fbegin = 1;
}
else
{
if(is_upper){
fbegin = bef + 1;
}
else{
fend = bef - 1;
}
}
if(!is_bef_less){
//?????§???
auto top = TOP[i]-'0';
if(fbegin <= top && top <= fend){
res += call(false, is_bef_biger||BTM[i]<TOP[i], top);
}
fend = std::min(fend, top-1);
}
if(!is_bef_biger){
//????°????
auto btm = BTM[i]-'0';
if(fbegin <= btm && btm <= fend){
res += call(is_bef_less||BTM[i]<TOP[i], false, btm);
}
fbegin = std::max(fbegin, btm+1);
}
for(int i = fbegin;i <= fend;++i){
res += call(true, true, i);
}
#ifdef DEBUG
std::cout << "out[" <<(is_zero?1:0)<<' '<<(is_bef_less?1:0)<<' '<<(is_bef_biger?1:0)<<' '<<(int)(bef)<<' '<<(is_upper?1:0)<<' '<<(mod)<<' '<<(i)<<"]\n";
std::cout << "...res="<<res%10000<<"\n";
#endif
return (res%10000);
}
inline int16_t func(bool is_zero, bool is_bef_less, bool is_bef_biger, int8_t bef, bool is_upper, int16_t mod, int16_t i)
{
if(i >= N){
return (is_zero || mod%BACE)?0:1;
}
if(is_zero)
{
bef=0;is_upper=false;mod=0;
}
auto& memo = dp[is_zero?1:0][is_bef_less?1:0][is_bef_biger?1:0][bef+1][is_upper?1:0][mod][i];
if(memo>=0){return memo;}
return memo = func_run(is_zero, is_bef_less, is_bef_biger, bef, is_upper, mod, i);
}
int main()
{
fill_all<int16_t>(dp,-1);
std::cin >> BTM>>TOP>>BACE;
while(TOP[N] != '\0'){++N;}
BTM.insert(BTM.begin(), N-BTM.size(), '0');
#ifdef DEBUG
std::cout <<"BTM="<<BTM<<"\n";
std::cout <<"TOP="<<TOP<<"\n";
std::cout <<"N="<<N<<"\n";
std::cout <<"BACE="<<BACE<<"\n";
#endif
int res = 0;
res += func_run(true, false,false,0,false, 0, 0);
std::cout << res%10000 << std::endl;
}
#endif
|
#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back
const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const int MOD = 10000;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }
template<typename T> T ceil(T a, T b) { return a/b + !!(a%b); }
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.first<<','<<a.second<<')';
return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
out<<'[';
REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}
out<<']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int dp[505][2][505][10][3][3];
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
string a, b;
int m;
cin >> a >> b >> m;
int n = b.size();
if(n != 1) {
VI mo(n); mo[0] = 1%m;
FOR(i, 1, n) mo[i] = mo[i-1]*10%m;
// N以下の数を求める桁DP
dp[0][0][0][0][0][0] = 1;
REP(i, n) REP(j, 2) REP(k, m) REP(l, 10) REP(x, 3) REP(y, 3) {
if(!dp[i][j][k][l][x][y]) continue;
// cout << i << "," << j << "," << k << "," << l << "," << x << "," << y << " ";
// cout << dp[i][j][k][l][x][y] << endl;
int lim = j?9:b[i]-'0';
REP(d, lim+1) {
int cond = 0;
if(y==1) {
if(l < d) cond = 1;
else if(l > d) cond = 2;
} else if(x == 1) {
if(l > d) cond = 2;
} else if(x == 2) {
if(l < d) cond = 1;
}
int cond2 = 0;
if(y==0) {
if(d) cond2 = 1;
} else if(y==1) {
cond2 = 2;
} else {
cond2 = 2;
}
(dp[i+1][j||d<lim][(k+mo[n-1-i]*d)%m][d][cond][cond2] += dp[i][j][k][l][x][y]) %= MOD;
}
}
}
int ans = 0;
if(n != 1) {
REP(i, 2) REP(j, 10) FOR(k, 1, 3) REP(l, 3) {
if(!dp[n][i][0][j][k][l]) continue;
// cout << n << "," << i << "," << 0 << "," << j << "," << k << "," << l << " ";
// cout << dp[n][i][0][j][k][l] << endl;
(ans += dp[n][i][0][j][k][l]) %= MOD;
}
REP(i, 9) {
ans += (i+1)%m==0;
}
} else {
REP(i, b[0]-'0') {
ans += (i+1)%m==0;
}
}
// cout << ans << endl;
n = a.size();
if(n != 1) {
VI mo(n); mo[0] = 1%m;
FOR(i, 1, n) mo[i] = mo[i-1]*10%m;
// N以下の数を求める桁DP
memset(dp, 0, sizeof(dp));
dp[0][0][0][0][0][0] = 1;
REP(i, n) REP(j, 2) REP(k, m) REP(l, 10) REP(x, 3) REP(y, 3) {
if(!dp[i][j][k][l][x][y]) continue;
// cout << i << "," << j << "," << k << "," << l << "," << x << "," << y << " ";
// cout << dp[i][j][k][l][x][y] << endl;
int lim = j?9:a[i]-'0';
REP(d, lim+1) {
int cond = 0;
if(y==1) {
if(l < d) cond = 1;
else if(l > d) cond = 2;
} else if(x == 1) {
if(l > d) cond = 2;
} else if(x == 2) {
if(l < d) cond = 1;
}
int cond2 = 0;
if(y==0) {
if(d) cond2 = 1;
} else if(y==1) {
cond2 = 2;
} else {
cond2 = 2;
}
(dp[i+1][j||d<lim][(k+mo[n-1-i]*d)%m][d][cond][cond2] += dp[i][j][k][l][x][y]) %= MOD;
}
}
}
if(n != 1) {
REP(i, 2) REP(j, 10) FOR(k, 1, 3) REP(l, 3) {
if(!dp[n][i][0][j][k][l]) continue;
// cout << n << "," << i << "," << 0 << "," << j << "," << k << "," << l << " ";
// cout << dp[n][i][0][j][k][l] << endl;
(ans -= dp[n][i][0][j][k][l] + MOD) %= MOD;
}
REP(i, 9) ans -= (i+1)%m==0;
ans = (ans%MOD+MOD)%MOD;
} else {
REP(i, a[0]-'0') {
ans -= (i+1)%m==0;
}
}
// aがmの倍数かつジグザグ数ならansに+1する
bool can = a[0]!=a[1];
bool flag = a[0]<a[1];
FOR(i, 2, n) {
if(flag) {
if(a[i-1]>a[i]) {
flag = false;
} else {
can = false;
break;
}
} else {
if(a[i-1]<a[i]) {
flag = true;
} else {
can = false;
break;
}
}
}
int now = 0;
for(int i=n-1; i>=0; --i) now = (now*10 + (a[i]-'0')) % m;
if(now) can = false;
if(can) ans++;
cout << ans%MOD << endl;
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <cctype>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <iterator>
#include <bitset>
#include <complex>
#include <fstream>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T> T RoundOff(T a){ return int(a+.5-(a<0)); }
template<class T, class C> void chmax(T& a, C b){ if(a < b) a = b; }
template<class T, class C> void chmin(T& a, C b){ if(b < a) a = b; }
template<class T, class C> pair<T, C> mp(T a, C b){ return make_pair(a, b); }
const int MOD = 10000;
int memo[501][10][2][2][501];
string A, B;
int M;
// x*10^nをvで割った時の余り
int calc_rest(int x, int n, int v)
{
for(int i = 0; i < n; i++)
{
x -= (x / v) * v;
x *= 10;
}
return x / 10;
}
// 数値列をディクリメントする
string dec(string S)
{
for(int i = S.size() - 1; 0 <= i; i--)
{
if(S[i] != '0')
{
S[i]--;
if(S[i] == '0' && i == 0 && 1 < S.size()) S = S.substr(1);
return S;
}
else S[i] = '9';
}
return S;
}
// S=対象の文字列, pnt=着目している文字の場所, prv=直前の文字, ul=数字は増えるか, sp=既に最大の数より小さいことが決まっているか, rest=累積の余り, zero=最初であり0が禁止されているか
int rec(string &S, int pnt, int prv, bool inc, bool sp, int rest, bool zero)
{
if(pnt == S.size()) return rest == 0;
if(!zero && memo[pnt][prv][inc][sp][rest] != -1) return memo[pnt][prv][inc][sp][rest];
int dig = S.size() - pnt;
ll res = 0;
if(inc)
{
int lim = (sp ? 10 : S[pnt] - '0' + 1);
for(int i = prv + 1; i < lim; i++)
{
res += rec(S, pnt + 1, i, false, sp || i < S[pnt] - '0', (rest * 10 + i) % M, false);
res %= MOD;
}
}
else
{
for(int i = (sp ? prv - 1 : min(prv - 1, S[pnt] - '0')); zero <= i; i--)
{
res += rec(S, pnt + 1, i, true, sp || i < S[pnt] - '0', (rest * 10 + i) % M, false);
res %= MOD;
}
}
return zero ? res : memo[pnt][prv][inc][sp][rest] = res;
}
// S以下のZigZagNumberを数える
int count(string &S)
{
if(S.size() == 1) return (S[0] - '0') / M;
memset(memo, -1, sizeof memo);
ll res = 9 / M;
for(int i = 1; i < S.size(); i++)
{
int inc = rec(S, S.size() - i - 1, 0, true, i != S.size() - 1, 0, true);
int fal = rec(S, S.size() - i - 1, (i == S.size() - 1 ? S[0] - '0' + 1 : 10), false, i != S.size() - 1, 0, true);
res += inc + fal;
res %= MOD;
}
return res;
}
int solve()
{
A = dec(A);
return (count(B) - count(A) + MOD) % MOD;
}
int main()
{
cin >> A >> B >> M;
cout << solve() << endl;
}
|
#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) {
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);
}
|
//03
#include<iostream>
#include<string>
using namespace std;
int mem[500][500][10][3];
int m;
int rec(int rd,int r,int l,int d){
if(rd==0){
return r==0;
}else if(mem[rd][r][l][d]!=-1){
return mem[rd][r][l][d];
}else{
int re=0;
for(int i=0;i<10;i++){
if(i!=l&&(l<i)!=d){
re=(re+rec(rd-1,(r*10+i)%m,i,l<i))%10000;
}
}
return mem[rd][r][l][d]=re;
}
}
int rrec(string s,int l,int r,int d){
if(s==""){
return r==0;
}else{
int re=0;
int i;
for(i=0;i<s[0]-'0';i++){
if(l!=i&&(l<i)!=d){
re=(re+rec(s.size()-1,(r*10+i)%m,i,l<i))%10000;
}
}
if(l!=i&&(l<i)!=d){
re=(re+rrec(s.substr(1),s[0]-'0',(r*10+s[0]-'0')%m,l<i))%10000;
}
return re;
}
}
int zzn(string s){
int r=0;
if(s.size()>=2){
int h=(s[0]-'0')*10+s[1]-'0';
for(int i=10;i<h;i++){
if(i%10!=i/10){
r=(r+rec(s.size()-2,i%m,i%10,i%10>i/10))%10000;
}
}
if(s[0]!=s[1]){
r=(r+rrec(s.substr(2),h%10,h%m,s[1]>s[0]))%10000;
}
for(int i=3;i<=s.size();i++){
for(int j=10;j<99;j++){
if(j%10!=j/10){
r=(r+rec(s.size()-i,j%m,j%10,j%10>j/10))%10000;
}
}
}
r=(r+(9/m)+1)%10000;
return r;
}else{
return (s[0]-'0')/m+1;
}
}
// #include<sstream>
// int main(){
// fill(mem[0][0][0],mem[500][0][0],-1);
// m=1;
// int l=0;
// for(int i=0;i<100000;i++){
// stringstream ss;
// ss<<i;
// int c=zzn(ss.str());
// if(c!=l){
// cout<<i<<endl;
// l=c;
// }
// }
// }
int main(){
fill(mem[0][0][0],mem[500][0][0],-1);
string a,b;
cin>>a>>b>>m;
bool zzm=false;
int r=0;
for(int i=0;i<a.size();i++){
r=(r*10+a[i]-'0')%m;
}
if(r==0){
int i;
int d=2;
for(i=0;i<a.size()-1;i++){
if(a[i]==a[i+1]||d==(a[i+1]>a[i]))break;
d=(a[i+1]>a[i]);
}
if(i==a.size()-1){
zzm=true;
}
}
cout<<(zzn(b)-zzn(a)+10000+zzm)%10000<<endl;
return 0;
}
|
#include <iostream>
#include <cstring>
#include <string>
using namespace std;
string sa,sb;
int a[501],b[501];
int m,mod=10000;
int dp[502][501][10][4][2];
int solve(int d[],int sz,bool low){
memset(dp,0,sizeof(dp));
dp[0][0][0][0][0]=1;
for(int i=0;i<sz;++i){
for(int j=0;j<m;++j){
for (int k=0;k<10;++k){
for(int l=0;l<4;++l){
for(int p=0;p<2;++p){
int lim=p?9:d[i];
for(int q=0;q<=lim;++q){
if(l==0)(dp[i+1][q%m][q][q!=0][p||q<lim] +=dp[i][j][k][l][p])%=mod;
else if(l==1&&q!=k)(dp[i+1][(j*10+q)%m][q][q<k?2:3][p||q<lim] +=dp[i][j][k][l][p])%=mod;
else if(l==2&&q>k)(dp[i+1][(j*10+q)%m][q][3][p||q<lim] +=dp[i][j][k][l][p])%=mod;
else if(l==3&&q<k)(dp[i+1][(j*10+q)%m][q][2][p||q<lim] +=dp[i][j][k][l][p])%=mod;
}
}
}
}
}
}
int res=0;
for(int i=0;i<10;++i){
for(int j=0;j<4;++j){
for(int k=0;k<2;++k){
if(low&&k==0) continue;
(res += dp[sz][0][i][j][k])%=mod;
}
}
}
return res;
}
int main(){
cin>>sa>>sb>>m;
for(int i=0;i<sb.size();++i) b[i]=sb[i]-'0';
for(int i=0;i<sa.size();++i) a[i]=sa[i]-'0';
cout<<(solve(b,sb.size(),false)-solve(a,sa.size(),true)+mod)%mod<<endl;
return 0;
}
|
#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
char A[1100];
char B[1100];
int mod=10000;
short int dp[2][520][3][11][11];
char tc[1100];
int c;
int calc(){
int n=strlen(tc);
for(int i=0;i<2;i++)for(int j=0;j<520;j++)for(int k=0;k<3;k++)
for(int l=0;l<11;l++)for(int m=0;m<11;m++)
dp[i][j][k][l][m]=0;
dp[0][0][1][10][10]=1;
int ret=0;
for(int i=0;i<n;i++){
int t=i%2;
for(int j=0;j<520;j++)for(int k=0;k<3;k++)
for(int l=0;l<11;l++)for(int m=0;m<11;m++)
dp[!t][j][k][l][m]=0;
for(int j=0;j<c;j++){
for(int k=0;k<3;k++)for(int l=0;l<11;l++)for(int m=0;m<11;m++){
if(!dp[t][j][k][l][m])continue;
for(int n=0;n<10;n++){
if(i==0&&n==0)continue;
if(m==n)continue;
int tm=(j*10+n)%c;
int tk=k;
if(tk==1&&n<tc[i]-'0')tk=0;
if(tk==1&&n>tc[i]-'0')tk=2;
if(l<10&&m<10&&(l-m)*(n-m)<=0)continue;
dp[!t][tm][tk][m][n]=(dp[!t][tm][tk][m][n]+dp[t][j][k][l][m])%mod;
}
}
}
for(int j=0;j<3;j++){
for(int k=0;k<11;k++)for(int l=0;l<11;l++){
if(i+1==n&&j==2)continue;
ret=(ret+dp[!t][0][j][k][l])%mod;
}
}
}
return ret;
}
int main(){
scanf("%s%s",A,B);
scanf("%d",&c);
for(int i=0;i<1100;i++)tc[i]=B[i];
int ret=calc();
for(int i=0;i<1100;i++)tc[i]=A[i];
ret=(ret+mod-calc())%mod;
int now=0;
bool ok=true;
for(int i=0;A[i];i++){
now*=10;
now+=A[i]-'0';
now%=c;
if(i>=1&&A[i]==A[i-1])ok=false;
if(i>=2&&(A[i]-A[i-1])*(A[i-2]-A[i-1])<=0){
ok=false;
}
}
if(ok&&now==0)ret=(ret+1)%mod;
printf("%d\n",ret);
}
|
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef double db;
ll m;
string a,b;
ll dp[501][10][2][2][500];//dp[??????????????????][??°???][0:up(next) 1:down(next)][0:suf 1:below][mod]
ll d[501];
ll solve(string s){
ll T=1;
ll L=s.size();
if(L==1) return (s[0]-'0')/m;
for(ll i=1;i<=L;i++){
d[L-i]=T;
T=(T*10)%m;
}
memset(dp,0,sizeof(dp));
for(ll i=0;i<2;i++){
for(ll j=1;j<s[0]-'0';j++){
dp[0][j][i][1][j*d[0]%m]=1;
}
dp[0][s[0]-'0'][i][0][d[0]*(s[0]-'0')%m]=1;
}
for(ll i=1;i<L;i++){
for(ll j=1;j<10;j++){
dp[i][j][0][1][j*d[i]%m]=dp[i][j][1][1][j*d[i]%m]=1;
}
}
for(ll i=0;i<L-1;i++){
for(ll j=0;j<2;j++){//down up
for(ll w=0;w<2;w++){//sufbelow
for(ll k=0;k<10;k++){
for(ll p=0;p<m;p++){
if(j){//down
if(w){//below
for(ll next=0;next<k;next++){
dp[i+1][next][0][1][(p+d[i+1]*next)%m]= (dp[i+1][next][0][1][(p+d[i+1]*next)%m]+dp[i][k][1][1][p])%10000;
}
}
else{//suf
for(ll next=0;next<s[i+1]-'0'&&next<k;next++){
dp[i+1][next][0][1][(p+d[i+1]*next)%m]=(dp[i+1][next][0][1][(p+d[i+1]*next)%m]+dp[i][k][1][0][p])%10000;
}
if(s[i+1]<s[i]&&s[i+1]-'0'<k) dp[i+1][s[i+1]-'0'][0][0][(p+d[i+1]*(s[i+1]-'0'))%m]=(dp[i+1][s[i+1]-'0'][0][0][(p+d[i+1]*(s[i+1]-'0'))%m]+dp[i][k][1][0][p])%10000;
}
}//dp[??????????????????][??°???][0:up(next) 1:down(next)][0:suf 1:below][mod]
else{//up
if(w){//below
for(ll next=k+1;next<10;next++){
dp[i+1][next][1][1][(p+d[i+1]*next)%m]= (dp[i+1][next][1][1][(p+d[i+1]*next)%m]+dp[i][k][0][1][p])%10000;
}
}
else{//suf
for(ll next=k+1;next<s[i+1]-'0';next++){
dp[i+1][next][1][1][(p+d[i+1]*next)%m]=(dp[i+1][next][1][1][(p+d[i+1]*next)%m]+dp[i][k][0][0][p])%10000;
}
if(s[i+1]>s[i]) dp[i+1][s[i+1]-'0'][1][0][(p+d[i+1]*(s[i+1]-'0'))%m]=(dp[i+1][s[i+1]-'0'][1][0][(p+d[i+1]*(s[i+1]-'0'))%m]+dp[i][k][0][0][p])%10000;
}
}
}
}
}
}
}
ll sum=0;
for(ll i=0;i<10;i++) for(ll j=0;j<2;j++) for(ll k=0;k<2;k++) sum=(sum+dp[L-1][i][j][k][0])%10000;
/*for(ll i=0;i<L;i++){
for(ll num=0;num<10;num++){
for(ll mod=0;mod<m;mod++){
cout<<"dp["<<i<<"]["<<num<<"][up][bel]["<<mod<<"]="<<dp[i][num][0][1][mod]<<endl;
cout<<"dp["<<i<<"]["<<num<<"][down][bel]["<<mod<<"]="<<dp[i][num][1][1][mod]<<endl<<endl;
}
}
}
cout<<endl;
for(ll i=0;i<L;i++){
for(ll num=0;num<10;num++){
for(ll mod=0;mod<m;mod++){
cout<<"dp["<<i<<"]["<<num<<"][up][suf]["<<mod<<"]="<<dp[i][num][0][0][mod]<<endl;
cout<<"dp["<<i<<"]["<<num<<"][down][suf]["<<mod<<"]="<<dp[i][num][1][0][mod]<<endl;
}
}
}*/
return sum-9/m;
}
int main()
{
cin>>a>>b>>m;
if(a=="1") printf("%lld\n",solve(b));
else{
ll k=a.size()-1;
while(a[k]=='0'){
a[k]='9';
k--;
}
if(k==0&&a[k]=='1'){
string t;
for(ll i=1;i<a.size();i++) t+="9";
a=t;
}
else{
a[k]=a[k]-1;
}
printf("%lld\n",(10000+solve(b)-solve(a))%10000);
}
//dp[??????????????????][??°???][0:up(next) 1:down(next)][0:suf 1:below][mod]
}
|
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
#define MOD 10000
string s;
int 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<bits/stdc++.h>
using namespace std;
vector<int> stov(string s){
vector<int> res(s.size());
for(int i=0;i<s.size();i++){
res[i]=s[i]-'0';
}
return res;
}
void inc(vector<int>& n){
for(int i=n.size()-1;i>=0;i--){
if(n[i]<9){
n[i]++;
return;
}
n[i]=0;
}
n.insert(n.begin(),1);
}
using vi=vector<int>;
using vvi=vector<vi>;
using vvvi=vector<vvi>;
using vvvvi=vector<vvvi>;
const int SIZE=502;
const int MOD=10000;
const int BOTH=0;
const int LOWER=1;
const int UPPER=2;
int main(){
string abuf,bbuf;
cin>>abuf>>bbuf;
int m;
cin>>m;
auto a=stov(abuf),b=stov(bbuf);
inc(b);
vvvvi dp(SIZE+1,vvvi(10,vvi(m,vi(3,0))));
for(int i=0;i<10;i++){
dp[1][i][i%m][BOTH]=1;
}
vector<int> tenv(SIZE,1);
int ten=10%m;
for(int i=1;i<SIZE;i++){
tenv[i]=ten;
for(int j=0;j<10;j++){
for(int k=0;k<m;k++){
for(int r=0;r<10;r++){
int tok=(k+r*ten)%m;
if(j<r){
(dp[i+1][r][tok][LOWER]+=dp[i][j][k][UPPER])%=MOD;
(dp[i+1][r][tok][LOWER]+=dp[i][j][k][BOTH])%=MOD;
}
if(r<j){
(dp[i+1][r][tok][UPPER]+=dp[i][j][k][LOWER])%=MOD;
(dp[i+1][r][tok][UPPER]+=dp[i][j][k][BOTH])%=MOD;
}
}
}
}
ten=(ten*10)%m;
}
auto solve=[&](vector<int> &v){
int res=0;
for(int i=1;i<v.size();i++){
for(int j=1;j<10;j++){
res+=dp[i][j][0][LOWER];
res+=dp[i][j][0][UPPER];
res+=dp[i][j][0][BOTH];
res%=MOD;
}
}
for(int i=1;i<v[0];i++){
res+=dp[v.size()][i][0][LOWER];
res+=dp[v.size()][i][0][UPPER];
res+=dp[v.size()][i][0][BOTH];
res%=MOD;
}
int flag=BOTH;
int cnt=(tenv[v.size()-1]*v[0])%m;
for(int i=1;i<v.size();i++){
for(int j=0;j<v[i];j++){
int tok=(m-cnt)%m;
if(v[i-1]<j){
if(flag==BOTH || flag==UPPER){
res+=dp[v.size()-i][j][tok][LOWER];
res+=dp[v.size()-i][j][tok][BOTH];
}
}
if(v[i-1]>j){
if(flag==BOTH || flag==LOWER){
res+=dp[v.size()-i][j][tok][UPPER];
res+=dp[v.size()-i][j][tok][BOTH];
}
}
res%=MOD;
}
if(v[i-1]<v[i]){
if(flag==BOTH || flag==UPPER){
flag=LOWER;
}
else break;
}
else if(v[i-1]>v[i]){
if(flag==BOTH || flag==LOWER){
flag=UPPER;
}
else break;
}
else break;
cnt=(cnt+tenv[v.size()-1-i]*v[i])%m;
}
return res;
};
cout<<((solve(b)-solve(a))%MOD+MOD)%MOD<<endl;
return 0;
}
|
// JOI 2011-2012 予選6
#include<iostream>
#include<string>
#include<vector>
#include<cstring>
// 多倍長整数
std::vector<int> A, B;
int M;
// memo[現在i桁目][Mで割った余り][直前の数字][直前が増加・減少(0: 増, 1: 減, 2: 上から0が連続][自由に選べるか]
int memo[501][500][10][3][2];
// メモ化再帰
// (vで表される数)以下のZig-Zag数の個数を10000で割った余りを返す
int rec( const std::vector<int>& v, int n, int mod, int prv, int ud, bool ok )
{
if( n == v.size() )
return !mod;
if( memo[n][mod][prv][ud][ok] >= 0 )
return memo[n][mod][prv][ud][ok];
int ret = 0;
for( int i = 0; i <= ( ok ? 9 : v[n] ); ++i )
{
if( !ud && prv <= i )
continue;
if( ud == 1 && prv >= i )
continue;
if( ud == 2 && prv && prv == i )
continue;
int nud;
if( ud == 2 )
{
if( !prv )
nud = 2;
else if( prv > i )
nud = 1;
else
nud = 0;
}
else
nud = !ud;
ret += rec( v, n + 1, ( mod * 10 + i ) % M, i, nud, ok | i != v[n] );
}
return memo[n][mod][prv][ud][ok] = ret % 10000;
}
int main()
{
std::string s, t;
std::cin >> s >> t >> M;
for( int i = 0; i != s.size(); ++i )
A.push_back( s[i] - '0' );
for( int i = 0; i != t.size(); ++i )
B.push_back( t[i] - '0' );
// A - 1をする
// c: carry
int c = 1;
for( int i = A.size() - 1; i >= 0; --i )
{
A[i] -= c;
c = 0;
if( A[i] < 0 )
{
c = 1;
A[i] += 10;
}
}
memset( memo, -1, sizeof( memo ) );
int a = rec( A, 0, 0, 0, 2, 0 );
memset( memo, -1, sizeof( memo ) );
int b = rec( B, 0, 0, 0, 2, 0 );
// 10000で割った余りなので、f( B ) < f( A - 1 )の可能性あり
std::cout << ( 10000 + b - a ) % 10000 << std::endl;
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;
}
|
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <cassert>
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <bitset>
#include <functional>
#include <numeric>
using namespace std;
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define mp(a,b) make_pair((a),(b))
#define pb(a) push_back((a))
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<((x))<<endl
#define fi first
#define se second
#define INF 2147483600
#define MOD 10000
#define long long long
long dp[2][2][3][10][500];
// [-][?????????????][????????????????????leading zero?][?????????digit][mod m]
long solve(string &str, int m, bool eq){
int n=str.size();
auto prev = dp[0];
auto crnt = dp[1];
fill(prev[0][0][0], prev[2][0][0], 0);
int ini = str[0]-'0';
repl(i,1, ini+1){
prev[i==ini][2][i][i%m]=1;
}
repl(i,1,n){
fill(crnt[0][0][0], crnt[2][0][0], 0);
int lim=str[i]-'0';
rep(k,10) rep(l,m){
rep(d,10) if(k!=d) (crnt[0][k<d][d][(l*10+d)%m] += prev[0][k>d][k][l] + prev[0][2][k][l])%=MOD;
rep(d,lim+1) if(k!=d) (crnt[d==lim][k<d][d][(l*10+d)%m] += prev[1][k>d][k][l] + prev[1][2][k][l])%=MOD;
}
repl(d,1,10) crnt[0][2][d][d%m]=1;
swap(prev, crnt);
}
long ret=0;
rep(i,2) if(i==0 || eq){
rep(j,3) rep(k,10) (ret += prev[i][j][k][0])%=MOD;
}
return ret;
}
int main(){
string a,b;
int m;
cin>>a>>b>>m;
cout << (solve(b, m, true) - solve(a,m,false) + MOD)%MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MAX_N 501
#define MAX_M 501
typedef long long ll;
const ll MOD = 10000LL;
int M;
ll dp[MAX_N][MAX_M][10][2][3];
ll dfs(int idx, int m, int d, bool lt, int up, string &s)
{
if (idx == (int)s.size()) {
return (m == 0);
}
ll &res = dp[idx][m][d][lt][up];
if (res != -1) return res;
res = 0;
int num = s[idx] - '0';
for (int i = 0; i < 10; i++) {
int nup = -1;
if (lt || i <= num) {
if (up == 0 && d < i) {
nup = 1;
} else if (up == 1 && d > i) {
nup = 0;
} else if (up == 2) {
if (d == 0) {
nup = 2;
} else if (d > i) {
nup = 0;
} else if (d < i) {
nup = 1;
}
}
if (nup != -1) {
res += dfs(idx + 1, (10*m + i) % M, i, lt || (i < num), nup, s);
}
res %= MOD;
}
}
return res;
}
void sub(string &A)
{
for (int i = (int)A.size()-1; i >= 0; i--) {
int num = (A[i] - '0'); num--;
if (num == -1) {
A[i] = '9';
} else {
A[i] = num + '0';
return;
}
}
}
int main()
{
string A, B;
cin >> A >> B >> M;
sub(A);
memset(dp, -1, sizeof(dp));
ll va = dfs(0, 0, 0, 0, 2, A);
memset(dp, -1, sizeof(dp));
ll vb = dfs(0, 0, 0, 0, 2, B);
cout << (vb - va + MOD) % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
return os << p.FF << " " << p.SS;
}
template<class T>
void maxi(T& x, T y){
if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
if(x > y) x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 10000;
int N;
int M;
int dp[505][505][3][2][10];
int solve(string& s, int i, int m, int udh, int full, int x){
int& res = dp[i][m][udh][full][x];
if(res != -1) return res;
if(i == N){
return res = (m == 0? 1: 0);
}
res = 0;
int ub = (full? s[i] - '0' + 1: 10);
int c = s[i] - '0';
REP(nx, ub){
int nfull = full && nx == c;
int nm = (m * 10 + nx) % M;
if(udh == 0 && x < nx)
(res += solve(s, i+1, nm, 1, nfull, nx)) %= MOD;
else if(udh == 1 && x > nx)
(res += solve(s, i+1, nm, 0, nfull, nx)) %= MOD;
else if(udh == 2){
if(x == 0)
(res += solve(s, i+1, nm, 2, nfull, nx)) %= MOD;
if(x > 0 && nx != x)
(res += solve(s, i+1, nm, (x<nx?1:0), nfull, nx)) %= MOD;
}
}
return res;
}
void pre(string& s){
for(int i=SZ(s)-1;i>=0;--i){
if(s[i] != '0'){
s[i]--;
break;
}
else s[i] = '9';
}
if(s[0] == '0' && SZ(s) > 1){
s.erase(begin(s));
}
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
string A, B;
cin >> A >> B;
cin >> M;
pre(A);
fill((int*)dp, (int*)dp+505*505*3*2*10, -1);
N = SZ(A);
int fa = solve(A, 0, 0, 2, 1, 0);
fill((int*)dp, (int*)dp+505*505*3*2*10, -1);
N = SZ(B);
int fb = solve(B, 0, 0, 2, 1, 0);
cout << (fb + MOD - fa) % MOD << 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];
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<iostream>
using namespace std;
#define rep(i, a) for(int i=0; i<(a); i++)
string A, B;
int M;
int memo[502][2][4][10][500];
//pos, less, hoge, pre, modM
string S;
const int up=2, down=3;
const int mod=1e4;
int rec(int i, int j, int k, int l, int m){
if(memo[i][j][k][l][m]!=-1) return memo[i][j][k][l][m];
if(i==S.size()){
return memo[i][j][k][l][m]=((k!=0)&&(m==0));
}
int ret=0;
int ue=(j? 9: S[i]-'0');
rep(d, ue+1){
int diff=d-l;
int nj=(j||d<ue);
int nk;
int nm=(10*m+d)%M;
if(k==0){
nk=(d!=0);
}else if(k==1){
if(diff==0) continue;
nk=(diff>0? up: down);
}else if(k==up&&diff<0){
nk=down;
}else if(k==down&&diff>0){
nk=up;
}else{
continue;
}
(ret+=rec(i+1, nj, nk, d, nm))%=mod;
}
return memo[i][j][k][l][m]=ret;
}
int calc(string N){
fill((int*)memo, (int*)memo+502*2*4*10*500, -1);
S=N;
return rec(0, 0, 0, 0, 0);
}
void minus1(){
int len=A.size();
for(int i=0; i<len; i++){
char ch=A[len-1-i];
if(ch=='0'){
A[len-1-i]='9';
}else{
A[len-1-i]=ch-1;
break;
}
}
if(A[0]=='0'&&A.size()>1) A=A.substr(1);
}
int main(){
cin>> A>> B>> M;
minus1();
cout<< (calc(B)-calc(A)+mod)%mod<< endl;
return 0;
}
|
#include<bits/stdc++.h>
#define LL lon long
using namespace std;
string s;
string str1,str2;
static const int MOD=10000;
int M;
int mem[501][10][3][3][500];
int cal(int n,int p,int pp,int f,int mod){
int res=0;
if(n==s.size()){
if(mod==0)return 1;
else return 0;
}
if(mem[n][p][pp][f][mod]!=-1)return mem[n][p][pp][f][mod];
int t=9;
if(f!=1)t=s[n]-'0';
for(int i=0;i<=t;++i){
if(pp==1&&p>=i)continue;
else if(pp==0&&p<=i)continue;
else if(pp==2&&p!=0&&p==i)continue;
int b;
if(pp==2){
if(p==0)b=2;
else if(p<i)b=0;
else b=1;
}
else if(pp==1)b=0;
else b=1;
int k;
if(f==1)k=1;
else if(i!=s[n]-'0')k=1;
else k=0;
int temp=mod*10+i;
if(temp==0)res+=cal(n+1,i,b,k,0);
else res+=cal(n+1,i,b,k,temp%M);
}
return mem[n][p][pp][f][mod]=res%MOD;
}
int main(){
int vr=0;
int vl=0;
cin>>str1>>str2>>M;
s=str1;
memset(mem,-1,sizeof(mem));
vl=cal(0,0,2,0,0);
s=str2;
memset(mem,-1,sizeof(mem));
vr=cal(0,0,2,0,0);
if((str1[0]-'0')%M==0&&str1.size()==1)vl--;
cout<<(vr-vl+MOD)%MOD<<endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<string>
#include<stack>
#include<cstdio>
#include<cmath>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef pair<int,P> P1;
#define fr first
#define sc second
#define mp make_pair
#define pb push_back
#define rep(i,x) for(int i=0;i<x;i++)
#define rep1(i,x) for(int i=1;i<=x;i++)
#define rrep(i,x) for(int i=x-1;i>=0;i--)
#define rrep1(i,x) for(int i=x;i>0;i--)
#define sor(v) sort(v.begin(),v.end())
#define rev(s) reverse(s.begin(),s.end())
#define lb(vec,a) lower_bound(vec.begin(),vec.end(),a)
#define ub(vec,a) upper_bound(vec.begin(),vec.end(),a)
#define uniq(vec) vec.erase(unique(vec.begin(),vec.end()),vec.end())
#define min_3(a,b,c) min(a,min(b,c))
#define max_3(a,b,c) max(a,max(b,c))
#define mp1(a,b,c) P1(a,P(b,c))
#define pque(a) priority_queue<a>
#define rpque(a) priority_queue<a,vector<a>,greater<a>>
const int INF=1000000000;
const int dir_4[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
const int dir_8[8][2]={{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1}};
const int kaijou[10]={1,1,2,6,24,120,720,5040,40320,362880};
const int M = 10000;
int dp[502][2][10][502]; //桁数,上がりスタート/下りスタート,先頭文字,mod M
int modpow(int x,int k,int m){
if(k == 0)return 1;
int tmp = modpow(x,k/2,m);
tmp *= tmp; tmp %= m;
if(k&1){tmp *= x; tmp%=m; }
return tmp;
}
int solver(string s,int m){
int n = s.size();
if(n == 0)return 0;
if(n == 1){
return (s[0]-'0')/m;
}
int ret = 0;
rep1(i,s[0]-'0'-1){
ret += dp[n][0][i][0];
ret += dp[n][1][i][0];
ret %= M;
}
for(int i = 2;i <= n-1; i ++){
rep1(j,9){
ret += dp[i][0][j][0];
ret += dp[i][1][j][0];
ret %= M;
}
}
ret += 9/m; ret %= M;
//cout << ret << endl;
int a = -1 , b = s[0]-'0';
int sum = 10*m-b*modpow(10,n-1,m); sum %= m;
//cout << sum << endl;
rep1(i,n-1){
int c = s[i]-'0';
if(a == -1){
if(c <= b){
rep(j,c){
ret += dp[n-i][0][j][sum];
ret %= M;
}
if(c == b)break;
a = b;
b = c;
sum += 10*m-b*modpow(10,n-i-1,m);
sum %= m;
}
else {
rep(j,b){
ret += dp[n-i][0][j][sum];
ret %= M;
}
for(int j = b+1; j < c; j ++){
ret += dp[n-i][1][j][sum];
ret %= M;
}
a = b;
b = c;
sum += 10*m-b*modpow(10,n-i-1,m);
sum %= m;
}
}
else {
if(a < b){
if(c < b){
rep(j,c){
ret += dp[n-i][0][j][sum];
ret %= M;
}
a = b;
b = c;
sum += 10*m-b*modpow(10,n-i-1,m);
sum %= m;
}
else {
rep(j,b){
ret += dp[n-i][0][j][sum];
ret %= M;
}
break;
}
}
else {
if(c <= b)break;
else {
for(int j = b+1;j < c;j ++){
ret += dp[n-i][1][j][sum];
ret %= M;
}
a = b;
b = c;
sum += 10*m-b*modpow(10,n-i-1,m);
sum %= m;
}
}
}
if(i == n-1 && sum == 0)ret ++;
}
return ret;
}
int main(){
string a,b;
int m;
cin >> a >> b >> m;
rrep(i,a.size()){
if(a[i] != '0'){
a[i] --;
break;
}
a[i] = '9';
}
if(a[0] == '0'){
string a_ = "";
rep1(i,a.size()-1)a_ += a[i];
a = a_;
}
rep(i,10){
dp[1][0][i][i%m] = 1;
dp[1][1][i][i%m] = 1;
}
for(int i = 2 ; i < 502; i ++ ){
rep(j,10){
rep(k,m){
int c = (k+10*m-j*modpow(10,i-1,m))%m;
dp[i][0][j][k] = 0;
for(int l = j+1 ; l < 10 ; l ++){
dp[i][0][j][k] += dp[i-1][1][l][c];
}
dp[i][1][j][k] = 0;
rep(l,j){
dp[i][1][j][k] += dp[i-1][0][l][c];
}
dp[i][0][j][k] %= M;
dp[i][1][j][k] %= M;
}
}
}
/*while(1){
string s;
cin >> s;
if(s == "END")break;
printf("%d\n",solver(s,m));
}*/
printf("%d\n",(solver(b,m)-solver(a,m)+M)%M);
}
|
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <map>
#include <list>
#include <set>
#include <numeric>
#include <queue>
#include <stack>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <climits>
#include <cfloat>
#include <ctime>
#include <complex>
#include <cassert>
#include <iomanip>
using namespace std;
typedef long long LL;
typedef pair<int,int> P;
int M;
int dp[2][2][2][10][500]={};
int num(string s, int rem){
memset(dp,0,sizeof(dp));
auto cur=dp[0];
auto nex=dp[1];
int order=10%M;
for(int k=0;k<10;k++){
cur[0][0][k][k%M]=cur[1][0][k][k%M]=1;
if(k<=s[0]-'0'){
cur[0][1][k][k%M]=cur[1][1][k][k%M]=1;
}
}
int ret=0;
ret/=2;
ret%=10000;
for(int i=1;i<s.size();i++){
for(int k=1;k<10;k++){
//cout << k << ": " << cur[0][0][k][0] << ", " << cur[1][0][k][0] << endl;
ret+=cur[0][0][k][rem]+cur[1][0][k][rem];
}
if(i==1){
ret/=2;
}
//cout << i << ", " << ret << endl;
ret%=10000;
for(int r=0;r<M;r++){
for(int k=1;k<10;k++){
cur[0][0][k][r]+=cur[0][0][k-1][r];
cur[0][0][k][r]%=10000;
cur[0][1][k][r]+=cur[0][1][k-1][r];
cur[0][1][k][r]%=10000;
}
for(int k=8;k>=0;k--){
cur[1][0][k][r]+=cur[1][0][k+1][r];
cur[1][0][k][r]%=10000;
cur[1][1][k][r]+=cur[1][1][k+1][r];
cur[1][1][k][r]%=10000;
}
}
for(int k=0;k<10;k++){
int v=(order*k)%M;
for(int r=0;r<M;r++){
if(k>0){
nex[1][0][k][r]=cur[0][0][k-1][(r-v+M)%M];
if(k<s[i]-'0'){
nex[1][1][k][r]=nex[1][0][k][r];
}
else if (s[i]-'0'==k)
{
nex[1][1][k][r]=cur[0][1][k-1][(r-v+M)%M];
}
else
{
nex[1][1][k][r]=0;
}
}
else
{
nex[1][0][k][r]=0;
nex[1][1][k][r]=0;
}
if(k<9){
nex[0][0][k][r]=cur[1][0][k+1][(r-v+M)%M];
if(k<s[i]-'0'){
nex[0][1][k][r]=nex[0][0][k][r];
}
else if(s[i]-'0'==k){
//cout << "aaa " << k << ": " << v << ", " << cur[1][1][k+1][(r-v+M)%M] << endl;
nex[0][1][k][r]=cur[1][1][k+1][(r-v+M)%M];
}
else
{
nex[0][1][k][r]=0;
}
}
else
{
nex[0][0][k][r]=0;
nex[0][1][k][r]=0;
}
}
}
order*=10;
order%=M;
swap(cur,nex);
}
for(int k=1;k<=s[s.size()-1]-'0';k++){
//cout << k << ", " << cur[0][1][k][0] << ", " << cur[1][1][k][0] << endl;
ret+=cur[0][1][k][rem]+cur[1][1][k][rem];
}
if(s.size()==1){
ret/=2;
}
ret%=10000;
return ret;
}
int num2(string a, int rem){
reverse(a.begin(),a.end());
istringstream istr(a);
int v;
istr >> v;
int ret=0;
for(int i=rem;i<=v;i+=M){
if(i==0)continue;
ostringstream ostr;
ostr << i;
string str=ostr.str();
if(str.size()==1){
ret++;
continue;
}
if(str.size()==2){
if(str[0]!=str[1]){
ret++;
}
continue;
}
ret++;
for(int i=1;i<str.size()-1;i++){
if((str[i]-str[i-1])*(str[i+1]-str[i])>=0)
{
ret--;
break;
}
}
}
return ret;
}
bool isZigZag(string s){
int v=0;
int b=1;
for(int i=0;i<s.size();i++){
v+=b*s[i];
v%=M;
b*=10;
b%=M;
}
if(v!=0)return false;
if(s.size()==1){
return true;
}
if(s.size()==2){
return s[0]!=s[1];
}
for(int i=1;i+1<s.size();i++)
{
if((s[i]-s[i-1])*(s[i+1]-s[i])>=0){
return false;
}
}
return true;
}
int main() {
string a,b;
#if 0
int m;
cin >> a >> M >> m;
reverse(a.begin(),a.end());
cout << num(a,m) << ", " << num2(a,m) << endl;
return 0;
#else
cin >> a >> b >> M;
reverse(a.begin(),a.end());
reverse(b.begin(),b.end());
int v=num(b,0)-num(a,0);
if(isZigZag(a)){
v++;
}
cout << (10000+v)%10000 << endl;
#endif
}
|
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
const int MOD = 10000;
int dp[2][510][2][3][10]; // dp[桁][%M][値未満か][形状][１つ前] := 総数%MOD
// 形状 0 -> V, 1 -> A, 2 -> malicious end point
int compute(string N,int M){
rep(j,M)rep(k,2)rep(m,3)rep(l,10) dp[1][j][k][m][l] = 0;
rep(i,N[0]-'0') dp[1][i%M][1][2][i] = 1;
dp[1][(N[0]-'0')%M][0][2][N[0]-'0'] = 1;
int len = N.size();
REP(i,1,len){ // 桁
int phase = i & 1;
rep(j,M)rep(k,2)rep(l,3)rep(m,10) dp[!phase][j][k][l][m] = 0;
rep(j,10){ // 今みてる値
rep(k,10){// 次の値
if( j == 0 ) ( dp[!phase][k%M][1][2][k] += 1 ) %= MOD;
if( j == k ) continue;
int state = -1;
if( j > k ) state = 0;
else state = 1;
rep(l,2){
bool lt = l | ( N[i]-'0' > k );
if( !lt && N[i]-'0' < k ) continue;
rep(m,M) ( dp[!phase][(m*10+k)%M][lt][state&1][k] += ( dp[phase][m][l][(state+1)&1][j] + (j?dp[phase][m][l][2][j]:0) ) ) %= MOD;
}
}
}
}
int ret = 0;
rep(i,2)rep(j,3)rep(k,10) ( ret += dp[len&1][0][i][j][k] ) %= MOD;
return ret;
}
string minus_one(string s){
reverse(s.begin(),s.end());
rep(i,s.size()){
if( s[i] != '0' ){
s[i] = (char)((s[i]-'0'-1)+'0');
reverse(s.begin(),s.end());
if( s.size() >= 2 && i == (int)s.size()-1 ) s = s.substr(1);
return s;
}
s[i] = '9';
}
return "@";
}
int main(){
string A,B;
int M;
while(cin>>A >> B>>M) cout << ( compute(B,M) - compute(minus_one(A),M) + MOD ) % MOD << endl;
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;
char c[]={'0','1','2','3','4','5','6','7','8','9'};
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){
//cout<<k+c[i]<<endl;
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){
//cout<<k+c[i]<<endl;
//cout<<"hoge"<<endl;
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){
//cout<<k+c[i]<<endl;
//cout<<"hoge"<<endl;
res+=(cal(n+1,temp%m,i,b,t)+1)%MOD;
}
}
}
else if(b==0){
if(p<i){
if(temp%m==0){
//cout<<k+c[i]<<endl;
//cout<<"hoge"<<endl;
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){
//cout<<k+c[i]<<endl;
//cout<<"hoge"<<endl;
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){
//cout<<k+c[i]<<endl;
//cout<<"hoge"<<endl;
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){
//cout<<k+c[i]<<endl;
//cout<<"hoge"<<endl;
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){
//cout<<k+c[i]<<endl;
//cout<<"hoge"<<endl;
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<string>
using namespace std;
string s;
int M,len;
int dp[2][3][10][500][500];
int getans(string str);
string change(string str);
int bfs(bool flg,int pm,int num,int mod,int idx);
int main(){
string a,b;
cin >> a; cin >> b; cin >> M;
//cout << getans(b) << endl;
//cout << getans(change(a)) << endl;
cout << (getans(b) - getans(change(a))+10000) % 10000 << endl;
}
string change(string str){
int len = str.size();
for(int i=len-1;i>=0;i--){
if(str[i] == '0') str[i] = '9';
else {
str[i]--;
break;
}
}
return (str);
}
int getans(string str){
s = str;
len = s.size();
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
for(int k=0;k<10;k++){
for(int l=0;l<500;l++){
for(int p=0;p<500;p++){
dp[i][j][k][l][p] = -1;
}
}
}
}
}
return bfs(false,0,0,0,0);
}
int bfs(bool flg,int pm,int num,int mod,int idx){
if(idx == len) return mod == 0;
if(dp[flg][pm][num][mod][idx] != -1) return dp[flg][pm][num][mod][idx];
int ret = 0,end;
if(flg) end = 9;
else end = s[idx] - '0';
for(int i=0;i<=end;i++){
if(pm == 1 && num <= i) continue;
if(pm == 2 && num >= i) continue;
if(pm == 0){
if(num && num == i) continue;
if(num == 0) ret += bfs(flg|(i!=end),0,i,(mod*10+i)%M,idx+1);
else if(num < i) ret += bfs(flg|(i!=end),1,i,(mod*10+i)%M,idx+1);
else if(num > i) ret += bfs(flg|(i!=end),2,i,(mod*10+i)%M,idx+1);
}
else if(pm == 1){
ret += bfs(flg|(i!=end),2,i,(mod*10+i)%M,idx+1);
}
else if(pm == 2){
ret += bfs(flg|(i!=end),1,i,(mod*10+i)%M,idx+1);
}
}
return dp[flg][pm][num][mod][idx] = ret % 10000;
}
|
#include <iostream>
#include <algorithm>
#include <climits>
#include <cstring>
#include <string>
#include <vector>
#include <cmath>
using namespace std;
#define MOD 10000
char A[510], B[510];
int M;
int memo[510][10][3][3][500];
int f(char *x, int i, int d, int c, int u, int r) {
if (memo[i][c][d][u][r] >= 0) return memo[i][c][d][u][r];
if (i == strlen(x)) {
int ret = 0;
if (u != 2) ret = r == 0;
return memo[i][c][d][u][r] = ret;
}
int ret = r == 0;
for (int k=0; k<10; k++) {
int nu = u;
if (c == k) continue;
if (d == 0 && c < k) continue;
if (d == 1 && c > k) continue;
int nd;
if (d == 2) nd = c > k;
else nd = 1-d;
if (u == 1 && k > (int)(x[i] - '0')) nu = 2;
if (u == 1 && k < (int)(x[i] - '0')) nu = 0;
ret += f(x, i+1, nd, k, nu, (k + r*10) % M);
ret %= MOD;
}
return memo[i][c][d][u][r] = ret;
}
int f(char *x) {
int ret = 0;
for (int i=0; i<510; i++) {
for (int j=0; j<10; j++) {
for (int d=0; d<3; d++) {
for (int k=0; k<3; k++) {
for (int l=0; l<500; l++) {
memo[i][j][d][k][l] = -1;
}
}
}
}
}
for (int i=1; i<10; i++) {
char c = (int)(x[0] - '0');
ret += f(x, 1, 2, i, i > c ? 2 : (i == c ? 1 : 0), i % M);
ret %= MOD;
}
return ret;
}
void decrement(char *x) {
int L = strlen(x);
int h = L - 1;
while (x[h] == '0') {
x[h] = '9';
h -= 1;
}
x[h] = (char)(x[h] - 1);
if (L > 1 && h == 0) {
for (int i=0; i<L-1; i++) x[i] = x[i+1];
x[L-1] = '\0';
}
}
int main() {
cin >> A >> B >> M;
decrement(A);
cout << (f(B) - f(A) + MOD) % MOD << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
enum Order {DEC, EQL, INC};
int memo[501][10][500][3][2];
const vector<int> vec(const string& s) {
vector<int> res;
for(const auto& c: s) res.insert(begin(res), c - '0');
return res;
}
bool zigzag(const string& s, int M) {
auto n = vec(s);
for(int i = 1; i < n.size(); ++i) if(n[i - 1] == n[i]) return false;
for(int i = 2; i < n.size(); ++i) {
if(n[i - 2] < n[i - 1] && n[i - 1] < n[i]) return false;
if(n[i - 2] > n[i - 1] && n[i - 1] > n[i]) return false;
}
int r = 0;
int m = 1 % M;
for(const auto& i: n) {
r = (r + i * m) % M;
m = (10 * m) % M;
}
return !r;
}
// Return n * 10^d mod M.
int remain(int n, int d, int M) {
static vector<int> base = {1};
while(base.size() <= d) base.push_back((base.back() * 10) % M);
return (n * base[d]) % M;
}
int rec(const vector<int>& n, int M, int d, int i, int r, int ord, int eql) {
if(memo[d][i][r][ord][eql]) return memo[d][i][r][ord][eql];
if(!d) return !r;
int res = 0;
if(eql) {
if(ord == INC && i > n[d-1]) res += rec(n, M, d-1, n[d-1], (r + remain(n[d-1], d-1, M)) % M, DEC, 1);
if(ord == DEC && i < n[d-1]) res += rec(n, M, d-1, n[d-1], (r + remain(n[d-1], d-1, M)) % M, INC, 1);
for(int j = 0; j < n[d-1]; ++j) {
if(ord == INC && i > j) res += rec(n, M, d-1, j, (r + remain(j, d-1, M)) % M, DEC, 0);
if(ord == DEC && i < j) res += rec(n, M, d-1, j, (r + remain(j, d-1, M)) % M, INC, 0);
}
} else {
if(ord == EQL) {
if(d == 1) {
for(int j = 0; j < 10; ++j) if(!(j % M)) ++res;
} else {
res += rec(n, M, d-1, 0, 0, EQL, 0);
for(int j = 1; j < 10; ++j) {
res += rec(n, M, d-1, j, remain(j, d-1, M), DEC, 0);
res += rec(n, M, d-1, j, remain(j, d-1, M), INC, 0);
}
}
} else {
for(int j = 0; j < 10; ++j) {
if(ord == INC && i > j) res += rec(n, M, d-1, j, (r + remain(j, d-1, M)) % M, DEC, 0);
if(ord == DEC && i < j) res += rec(n, M, d-1, j, (r + remain(j, d-1, M)) % M, INC, 0);
}
}
}
return memo[d][i][r][ord][eql] = (res % 10000);
}
int count(const string& s, int M) {
auto n = vec(s);
int res = 0;
for(int d = 0; d < n.size(); ++d) for(int i = 0; i < 10; ++i) for(int r = 0; r < M; ++r) for(int ord: {DEC, INC, EQL}) for(int eql: {0, 1}) memo[d][i][r][ord][eql] = 0;
if(n.size() == 1) {
for(int i = 0; i <= n.front(); ++i) res += !(i % M);
} else {
int d = n.size() - 1;
res += rec(n, M, d, n[d], remain(n[d], d, M), INC, 1);
res += rec(n, M, d, n[d], remain(n[d], d, M), DEC, 1);
res += rec(n, M, d, 0, 0, EQL, 0);
for(int i = 1; i < n[d]; ++i) {
res += rec(n, M, d, i, remain(i, d, M), INC, 0);
res += rec(n, M, d, i, remain(i, d, M), DEC, 0);
}
}
return res % 10000;
}
int main() {
string A, B;
int M;
cin >> A >> B >> M;
cout << (count(B, M) - count(A, M) + (zigzag(A, M) ? 1 : 0) + 10000) % 10000 << endl;
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 10000
enum Type{
LIMITED,
NO_LIMIT,
};
enum DIR{
UP,
DOWN,
NONE,
};
enum WHICH{
A,
B,
};
char buf[502];
int ARRAY[2][502],len[2],M;
int dp[2][502][2][2][10][500];
int calc(WHICH which,int digit,Type type,DIR dir,int pre_num,int pre_mod,bool zero_FLG){
if(digit == len[which]){
if(zero_FLG){
return 0;
}else{
if(pre_mod == 0){
return 1;
}else{
return 0;
}
}
}
if(zero_FLG){
int ret = 0;
ret += calc(which,digit+1,NO_LIMIT,NONE,0,0,true);
for(int num = 1; num <= 9; num++){
ret += calc(which,digit+1,NO_LIMIT,UP,num,num%M,false);
if(digit+1 < len[which]){
ret += calc(which,digit+1,NO_LIMIT,DOWN,num,num%M,false);
}
}
return ret%NUM;
}
if(dp[which][digit][type][dir][pre_num][pre_mod] != -1)return dp[which][digit][type][dir][pre_num][pre_mod];
int ret = 0;
if(type == LIMITED){
if(dir == UP){
for(int num = pre_num+1; num <= ARRAY[which][digit]; num++){
if(num < ARRAY[which][digit]){
ret += calc(which,digit+1,NO_LIMIT,DOWN,num,(10*pre_mod+num)%M,false);
}else{
ret += calc(which,digit+1,LIMITED,DOWN,num,(10*pre_mod+num)%M,false);
}
}
}else{
for(int num = 0; num <= min(pre_num-1,ARRAY[which][digit]); num++){
if(num < ARRAY[which][digit]){
ret += calc(which,digit+1,NO_LIMIT,UP,num,(10*pre_mod+num)%M,false);
}else{
ret += calc(which,digit+1,LIMITED,UP,num,(10*pre_mod+num)%M,false);
}
}
}
}else{
if(dir == UP){
for(int num = pre_num+1; num <= 9; num++){
ret += calc(which,digit+1,NO_LIMIT,DOWN,num,(10*pre_mod+num)%M,false);
}
}else{
for(int num = 0; num <= pre_num-1; num++){
ret += calc(which,digit+1,NO_LIMIT,UP,num,(10*pre_mod+num)%M,false);
}
}
}
return dp[which][digit][type][dir][pre_num][pre_mod] = ret%NUM;
}
int func(WHICH which){
for(int length = 0; length <= len[which]; length++){
for(int a = 0; a <= 1; a++){
for(int b = 0; b <= 1; b++){
for(int num = 0; num <= 9; num++){
for(int mod = 0; mod <= M-1; mod++){
dp[which][length][a][b][num][mod] = -1;
}
}
}
}
}
int ret = 0;
ret += calc(which,1,NO_LIMIT,NONE,0,0,true);
for(int head_num = 1; head_num <= ARRAY[which][0]; head_num++){
if(head_num == ARRAY[which][0]){
ret += calc(which,1,LIMITED,UP,head_num,head_num%M,false);
if(len[which] > 1){
ret += calc(which,1,LIMITED,DOWN,head_num,head_num%M,false);
}
}else{
ret += calc(which,1,NO_LIMIT,UP,head_num,head_num%M,false);
if(len[which] > 1){
ret += calc(which,1,NO_LIMIT,DOWN,head_num,head_num%M,false);
}
}
}
return ret%NUM;
}
bool is_A_zigzag(){
if(len[A] == 1){
if(ARRAY[A][0] > 0){
return true;
}else{
return false;
}
}
for(int digit = 0; digit < len[A]-1; digit++){
if(ARRAY[A][digit] == ARRAY[A][digit+1])return false;
}
DIR dir;
if(ARRAY[A][0] > ARRAY[A][1]){
dir = DOWN;
}else{
dir = UP;
}
for(int digit = 1; digit < len[A]-1; digit++){
if(ARRAY[A][digit] > ARRAY[A][digit+1]){
if(dir == DOWN)return false;
dir = DOWN;
}else if(ARRAY[A][digit] < ARRAY[A][digit+1]){
if(dir == UP)return false;
dir = UP;
}
}
return true;
}
int main(){
scanf("%s",buf);
for(len[A] = 0; buf[len[A]] != '\0'; len[A]++){
ARRAY[A][len[A]] = buf[len[A]]-'0';
}
scanf("%s",buf);
for(len[B] = 0; buf[len[B]] != '\0'; len[B]++){
ARRAY[B][len[B]] = buf[len[B]]-'0';
}
scanf("%d",&M);
int minus_A = 0;
if(is_A_zigzag()){
minus_A = 1;
}
printf("%d\n",(func(B)-(func(A)-minus_A)+NUM)%NUM);
return 0;
}
|
#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;
// dp[i][j][pre][eq or low][up or down or first]
int dp[2][500][10][2][3];
const int mod = 10000;
inline void add(int &a, int b) {
a = (a+b) % mod;
}
int solve(const string &s, int m) {
memset(dp,0,sizeof(dp));
REP(i,s.size()) {
int now = i&1;
int nxt = (i+1)&1;
REP(j,m)REP(pre,10)REP(low,2)REP(up,3) dp[nxt][j][pre][low][up]=0;
REP(j,m) {
REP(pre,10) {
REP(k,10) {
// first digit
if (k>0 && (i!=0 || k<=s[i]-'0')) {
bool eqlow = 1;
if (i==0 && k==s[i]-'0') eqlow = 0;
dp[nxt][k%m][k][eqlow][2] = 1;
}
// other
if (k<pre) {
add(dp[nxt][(j*10+k)%m][k][1][1], dp[now][j][pre][1][0]);
add(dp[nxt][(j*10+k)%m][k][1][1], dp[now][j][pre][1][2]);
if (k<=s[i]-'0') {
add(dp[nxt][(j*10+k)%m][k][k!=s[i]-'0'][1], dp[now][j][pre][0][0]);
add(dp[nxt][(j*10+k)%m][k][k!=s[i]-'0'][1], dp[now][j][pre][0][2]);
}
}
if (k>pre) {
add(dp[nxt][(j*10+k)%m][k][1][0], dp[now][j][pre][1][1]);
add(dp[nxt][(j*10+k)%m][k][1][0], dp[now][j][pre][1][2]);
if (k<=s[i]-'0') {
add(dp[nxt][(j*10+k)%m][k][k!=s[i]-'0'][0], dp[now][j][pre][0][1]);
add(dp[nxt][(j*10+k)%m][k][k!=s[i]-'0'][0], dp[now][j][pre][0][2]);
}
}
}
}
}
}
int ans = 0;
REP(pre,10) {
REP(low,2) {
REP(up,3) {
// if (dp[s.size()&1][0][pre][low][up]) {
// cout << pre << " " << low << " "<< up << endl;
// }
add(ans, dp[s.size()&1][0][pre][low][up]);
}
}
}
return ans;
}
string sub1(string s) {
for (int i=s.size()-1; i>=0; --i) {
if (s[i]-'0'-1 < 0) {
s[i] = '9';
} else {
s[i] -= 1;
return s;
}
}
return s;
}
int main() {
string a, b;
cin >> a >> b;
int m;cin >> m;
// cout << solve(sub1("1"), 1) << endl;
// cout << solve(string("10"),2) << endl;
cout << (solve(b,m)-solve(sub1(a),m)+mod)%mod << 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];
inline 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<climits>
#include<cassert>
#include<algorithm>
#include<cassert>
#include<map>
#include<vector>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
enum{UP=0,DOWN=1,NON=2};
const int N = 512;
const int M = 512;
const int mod = 10000;
//const int mod = 1000000;
//æ¡æ°,sum%M,æå¾ã®æ°å,次ã®æ°åãupãªã®ãdownãªã®ã,ä¸éã¨ä¸è´ãã¦ãããã©ããã
//ä½æ¡ç®ã¾ã§èªãã ããç¾å¨ã®%mã®å¤,åã®æå¾ã®æ¡ãup or down,ä¸éã¨ä¸è´
//500 * 500 * 10 ** 2 * 2
int dp[N][M][11][3][2];
int solve(const int n,int now,const int m,int val,int last,int st,bool match,const string &in){
//cout <<"state " << now <<" "<< val <<" "<< last <<" " <<st <<" " << match << endl;
if (now == n){
return val == 0 && last != 10?1:0;
}
int &ret = dp[now][val][last][st][match];
if (ret != -1)return ret;
ret = 0;
/*ãã®æ¡ããå§ã¾ãæ°ã*/
if (last == 10){
REP(i,1,10){
bool nextMatch=false;
if (now == 0 && i > in[0]-'0')break;
if (now == 0 && i == in[0]-'0')nextMatch = true;
ret += solve(n,now+1,m,i%m,i,NON,nextMatch,in);
ret %= mod;
}
ret += solve(n,now+1,m,0,10,NON,false,in);
return ret;
}
REP(i,0,10){
bool nextMatch=false;
if (match && i > in[now]-'0')break;
if (match && i == in[now] - '0')nextMatch = true;
if (i == last)continue;
if (st == UP && i >= last)continue; //i-1çªç®ã¨i-2çªç®ã«ã¤ãã¦i-2 < i-1 ãªã®ã§ãi-1 <= i ã¯è¨±ãããªã
if (st == DOWN && i <= last)continue;//i-1çªç®ã¨i-2çªç®ã«ã¤ãã¦i-2 < i-1 ãªã®ã§ãi-1 <= i ã¯è¨±ãããªã
int nextst;
if (last < i)nextst = UP;
if (last > i)nextst = DOWN;
ret += solve(n,now+1,m,(i+val*10)%m,i,nextst,nextMatch,in);
ret %= mod;
}
return ret;
}
int getVal(string in,int m){
rep(i,N)rep(j,N)rep(k,11)rep(l,3)rep(n,2)dp[i][j][k][l][n] = -1;
int ans = solve(in.size(),0,m,0,10,NON,true,in);
return ans;
}
bool isZigzag(string &in){
if (in.size() == 1)return true;
if (in.size() == 2)return in[0] != in[1];
REP(i,2,in.size()){
if ((in[i-2] < in[i-1] && in[i-1] > in[i]) ||
(in[i-2] > in[i-1] && in[i-1] < in[i]));
else return false;
}
return true;
}
bool isModm(string &in,int m){
int now = 0;
rep(i,in.size()){
now = now*10 + (in[i]-'0');
now %= m;
}
return now == 0;
}
/*
*/
int main(){
/*b-a + isZigzagAndModm(am)*/
string a,b;
int m;
while(cin>>a>>b>>m){
int tmp = isZigzag(a) && isModm(a,m)?1:0;
int tb = getVal(b,m),ta = getVal(a,m);
//cout << tb <<" " << ta <<" " << tmp << endl;
int ans = ((tb-ta+mod)%mod+tmp)%mod;
cout << ans << endl;
}
}
/*
10
11
12
13
14
15
16
17
18
19
20
3
6
9
12
15
18
9 3
99 27
999 177
9999 1038
99999 6315
999999 8133
ans 1234567 247
*/
|
#include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long int ll;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define endl "\n"
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
const int MOD = 10000;
int dp[510][510][10][3][2];
int M;
int calc(string s) {
memset(dp, 0, sizeof(dp));
int n = s.size();
int firstNum = s[0] - '0';
for(int i = 0; i <= firstNum; i++) {
if(i == firstNum) {
dp[1][i % M][i][0][0] = 1;
} else {
dp[1][i % M][i][0][1] = 1;
}
}
// i := 上からi桁目
for(int i = 1; i < n; i++) {
// j := Mで割ったあまり
for(int j = 0; j < M; j++) {
// k := 今の数字
for(int k = 0; k < 10; k++) {
// l := 増加中(2)or減少中(1)or変化なし(0)のフラグ
for(int l = 0; l < 3; l++) {
// a := 次の数字
// flg == 1
for(int a = 0; a < 10; a++) {
int nr = (10 * j + a) % M;
if(l == 0) {
if(k == 0) {
(dp[i + 1][nr][a][0][1] += dp[i][j][k][l][1]) %=
MOD;
} else {
if(a < k) {
(dp[i + 1][nr][a][1][1] +=
dp[i][j][k][l][1]) %= MOD;
}
if(a > k) {
(dp[i + 1][nr][a][2][1] +=
dp[i][j][k][l][1]) %= MOD;
}
}
} else if(l == 1 && a > k) {
(dp[i + 1][nr][a][2][1] += dp[i][j][k][l][1]) %=
MOD;
} else if(l == 2 && a < k) {
(dp[i + 1][nr][a][1][1] += dp[i][j][k][l][1]) %=
MOD;
}
}
// flg == 0
if(k > (int)(s[i - 1] - '0')) {
continue;
}
int limit = s[i] - '0';
for(int a = 0; a <= limit; a++) {
int nr = (10 * j + a) % M;
if(a == limit) {
if(l == 0) {
if(k == 0) {
(dp[i + 1][nr][a][0][0] +=
dp[i][j][k][l][0]) %= MOD;
} else {
if(a < k) {
(dp[i + 1][nr][a][1][0] +=
dp[i][j][k][l][0]) %= MOD;
}
if(a > k) {
(dp[i + 1][nr][a][2][0] +=
dp[i][j][k][l][0]) %= MOD;
}
}
} else if(l == 1 && a > k) {
(dp[i + 1][nr][a][2][0] += dp[i][j][k][l][0]) %=
MOD;
} else if(l == 2 && a < k) {
(dp[i + 1][nr][a][1][0] += dp[i][j][k][l][0]) %=
MOD;
}
} else {
if(l == 0) {
if(k == 0) {
(dp[i + 1][nr][a][0][1] +=
dp[i][j][k][l][0]) %= MOD;
} else {
if(a < k) {
(dp[i + 1][nr][a][1][1] +=
dp[i][j][k][l][0]) %= MOD;
}
if(a > k) {
(dp[i + 1][nr][a][2][1] +=
dp[i][j][k][l][0]) %= MOD;
}
}
} else if(l == 1 && a > k) {
(dp[i + 1][nr][a][2][1] += dp[i][j][k][l][0]) %=
MOD;
} else if(l == 2 && a < k) {
(dp[i + 1][nr][a][1][1] += dp[i][j][k][l][0]) %=
MOD;
}
}
}
}
}
}
}
int res = 0;
for(int i = 0; i < 10; i++) {
for(int j = 0; j < 3; j++) {
for(int k = 0; k < 2; k++) {
(res += dp[n][0][i][j][k]) %= MOD;
}
}
}
res = (MOD + res - 1) % MOD;
return res;
}
int check(string s) {
int n = s.size();
int now = 0;
for(int i = 0; i < n; i++) {
now = (10 * now + (int)(s[i] - '0')) % M;
}
if(now != 0) {
return 0;
}
if(n == 1 && s != "0") {
return 1;
}
if(n == 1 && s == "0") {
return 0;
}
bool isZouka;
int fi = s[0] - '0';
int se = s[1] - '0';
if(fi > se) {
isZouka = false;
} else if(fi < se) {
isZouka = true;
} else {
return 0;
}
for(int i = 1; i < n - 1; i++) {
fi = s[i] - '0';
se = s[i + 1] - '0';
if(fi > se && !isZouka) {
return 0;
}
if(fi < se && isZouka) {
return 0;
}
if(fi == se) {
return 0;
}
isZouka = !isZouka;
}
return 1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string a, b;
cin >> a >> b >> M;
int ans = (MOD + calc(b) - calc(a) + check(a)) % MOD;
cout << ans << endl;
}
|
#include<bits/stdc++.h>
#define LL lon long
using namespace std;
string s;
string str1,str2;
static const int MOD=10000;
int M;
int mem[501][10][3][3][500];
int cal(int n,int p,int pp,int f,int mod){
int res=0;
if(n==s.size()){
if(mod==0)return 1;
else return 0;
}
if(mem[n][p][pp][f][mod]!=-1)return mem[n][p][pp][f][mod];
int t=9;
if(f!=1)t=s[n]-'0';
for(int i=0;i<=t;++i){
if(pp==1&&p>=i)continue;
else if(pp==0&&p<=i)continue;
else if(pp==2&&p!=0&&p==i)continue;
int b;
if(pp==2){
if(p==0)b=2;
else if(p<i)b=0;
else b=1;
}
else if(pp==1)b=0;
else b=1;
int k;
if(f==1)k=1;
else if(i!=s[n]-'0')k=1;
else k=0;
int temp=mod*10+i;
res+=cal(n+1,i,b,k,temp%M);
}
return mem[n][p][pp][f][mod]=res%MOD;
}
int main(){
int vr=0;
int vl=0;
cin>>str1>>str2>>M;
for(int i=str1.size()-1;i>=0;i--){
if(str1[i]=='0'){
str1[i]='9';
}
else{
str1[i]--;
break;
}
}
s=str1;
memset(mem,-1,sizeof(mem));
vl=cal(0,0,2,0,0);
s=str2;
memset(mem,-1,sizeof(mem));
vr=cal(0,0,2,0,0);
cout<<(vr-vl+MOD)%MOD<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T,T MOD = 1000000007>
struct Mint{
T v;
Mint():v(0){}
Mint(signed v):v(v){}
Mint(long long t){v=t%MOD;if(v<0) v+=MOD;}
Mint& operator+=(Mint a){v+=a.v;if(v>=MOD)v-=MOD;return *this;}
Mint& operator-=(Mint a){v+=MOD-a.v;if(v>=MOD)v-=MOD;return *this;}
Mint& operator*=(Mint a){v=1LL*v*a.v%MOD;return *this;}
Mint operator+(Mint a){return Mint(v)+=a;};
Mint operator-(Mint a){return Mint(v)-=a;};
Mint operator*(Mint a){return Mint(v)*=a;};
Mint operator-(){return v?MOD-v:v;}
bool operator==(const Mint a)const{return v==a.v;}
bool operator!=(const Mint a)const{return v!=a.v;}
};
//INSERT ABOVE HERE
using M = Mint<int, 10000>;
M dp[505][505][2][2][3][10];
bool used[505][505][2][2][3][10];
int m;
M dfs(string &a,int pos,int v,int tight,int lz,int inc,int curr){
M &res=dp[pos][v][tight][lz][inc][curr];
if(used[pos][v][tight][lz][inc][curr]) return res;
used[pos][v][tight][lz][inc][curr]=1;
int n=a.size();
if(pos==n) return res=M(v==0);
res=M(0);
for(int k=0;k<10;k++){
if(tight&&a[pos]-'0'<k) continue;
int npos=pos+1;
int nv=(v*10+k)%m;
int ntight=tight&&(a[pos]-'0'==k);
int nlz=lz&&(k==0);
int ninc=0;
int ncurr=k;
if(!lz) ninc=curr<k?1:2;
if(!lz&&(curr==k||inc==ninc)) continue;
res+=dfs(a,npos,nv,ntight,nlz,ninc,ncurr);
}
return res;
}
int zigzag(string s){
int n=s.size();
for(int i=1;i<n;i++) if(s[i-1]==s[i]) return 0;
for(int i=1;i+1<n;i++) if(s[i-1]<s[i]&&s[i]<s[i+1]) return 0;
return 1;
}
signed main(){
string a,b;
cin>>a>>b>>m;
M ans;
memset(used,0,sizeof(used));
ans+=dfs(b,0,0,1,1,0,0);
memset(used,0,sizeof(used));
ans-=dfs(a,0,0,1,1,0,0);
if(zigzag(a)) ans+=M(1);
cout<<ans.v<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 10000;
int dp[505][2][3][10][500]; // dp[桁][未満フラグ][谷:0/山:1/未定:2][直前の数字][余り]
int solve(string x, int m, int f=0){
int n = x.size();
memset(dp, 0, sizeof(dp));
dp[0][0][2][0][0] = 1;
for(int i=0;i<n;i++){
int D = x[i]-'0';
for(int j=0;j<2;j++){
for(int k=0;k<3;k++){
for(int l=0;l<10;l++){
for(int d=0;d<=(j?9:D);d++){
if((k==0 && l>=d) || (k==1 && l<=d) || (k==2 && l>0 && l==d)) continue;
for(int r=0;r<m;r++){
dp[i+1][j||(d<D)][((k==2&&l==0)?2:l<d)][d][(r*10+d)%m] += dp[i][j][k][l][r];
dp[i+1][j||(d<D)][((k==2&&l==0)?2:l<d)][d][(r*10+d)%m] %= MOD;
}
}
}
}
}
}
int res = 0;
for(int i=(f?1:0);i<2;i++)for(int j=0;j<3;j++)for(int k=0;k<=9;k++){
res += dp[n][i][j][k][0];
res %= MOD;
}
return res;
}
int main(){
string a, b;
int m;
cin >> a >> b >> m;
cout << (solve(b,m) - solve(a,m,1) + MOD)%MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
using namespace std;
const int MOD = 10000;
inline void add(unsigned short& x, unsigned short y){ x = (x + y) % MOD; }
int calc(string s, int M){
int N = s.size();
vector<int> a(N);
REP(i, N) a[i] = s[i] - '0';
// [i-th][mod][last][zeros, first, down, up][low or not]
static unsigned short dp[502][502][10][4][2] = {};
memset(dp, 0, sizeof(dp));
dp[0][0][0][0][0] = 1;
unsigned short pow_10[502] = {};
pow_10[0] = 1;
for(int i = 1; i < N; i++){
pow_10[i] = pow_10[i - 1] * 10 % M;
}
for(int i = 0; i < N; i++)
for(int mod = 0; mod < M; mod++)
for(int last = 0; last < 10; last++)
for(int type = 0; type < 4; type++)
for(int islow = 0; islow < 2; islow++)
for(int next = 0; next < 10; next++){
const int& cur = dp[i][mod][last][type][islow];
if(cur == 0) continue;
if(!islow && a[i] < next) continue;
int nlow = islow || (next < a[i]);
int nmod = (mod + next * pow_10[N - 1 - i]) % M;
if(type == 0){
int ntype = (next == 0 ? 0 : 1);
add(dp[i + 1][nmod][next][ntype][nlow], cur);
}else if(type == 1 && last != next){
int ntype = (last < next ? 3 : 2);
add(dp[i + 1][nmod][next][ntype][nlow], cur);
}else if(type == 2 && last < next){
int ntype = 3;
add(dp[i + 1][nmod][next][ntype][nlow], cur);
}else if(type == 3 && last > next){
int ntype = 2;
add(dp[i + 1][nmod][next][ntype][nlow], cur);
}
}
unsigned short ans = 0;
for(int last = 0; last < 10; last++)
for(int type = 0; type < 4; type++)
for(int islow = 0; islow < 2; islow++){
add(ans, dp[N][0][last][type][islow]);
}
return ans;
}
string dec(string s){
for(int i = s.size() - 1; i >= 0; i--){
if(s[i] != '0'){
s[i] --;
break;
}else{
s[i] = '9';
}
}
return s;
}
int main(){
string A, B;
while(cin >> A >> B){
int M;
cin >> M;
cout << (calc(B, M) - calc(dec(A), M) + MOD) % MOD << endl;
}
return 0;
}
|
#include <iostream>
#include <fstream>
#include <typeinfo>
#include <vector>
#include <cmath>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <iomanip>
#include <cctype>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<25;
const ll INF=1ll<<50;
const double pi=acos(-1);
const double eps=1e-8;
const vi emp;
const int mod=10000;
int dp[502][11][500][2][2];
int solve(string s,int D){
int n=s.size();
for(int i=0;i<=n;i++) for(int j=0;j<=10;j++) for(int k=0;k<D;k++) for(int l=0;l<2;l++) for(int m=0;m<2;m++) dp[i][j][k][l][m]=0;
dp[0][10][0][0][0]++;
for(int i=0;i<n;i++) for(int j=0;j<=10;j++) for(int k=0;k<D;k++) for(int l=0;l<2;l++) for(int m=0;m<2;m++){
if(j!=10){
int S=m?0:j+1,T=m?j-1:9;
if(!l) T=min(T,s[i]-'0');
for(int d=S;d<T+1;d++) (dp[i+1][d][(10*k+d)%D][l||s[i]-'0'!=d/*d<T*/][!m]+=dp[i][j][k][l][m])%=mod;
}
else if(!k&&!l&&!m){
int lim=(i==0)?s[i]-'0':9;
for(int d=1;d<lim+1;d++) for(int I=0;I<2;I++) dp[i+1][d][d%D][i||d<lim][I]++;
dp[i+1][10][0][0][0]++;
}
}
int ans=0;
for(int i=0;i<10;i++) for(int j=0;j<2;j++) for(int k=0;k<2;k++){
(ans+=dp[n][i][0][j][k])%=mod;
}
int num=9/D;
if(s.size()==1&&s[0]-'0'<num*D) num=(s[0]-'0')/D;
return (ans+mod-num)%mod;
}
string Minus(string s){
if(s.back()>'0') s[s.size()-1]-=1;
else{
for(int i=s.size()-1;i>=0;i--) if(s[i]>'0'){
s[i]-=1;
for(int j=i+1;j<s.size();j++) s[j]='9';
break;
}
}
if(s=="0") return s;
for(int i=0;i<s.size();i++) if(s[i]!='0'){
s.erase(s.begin(),s.begin()+i);
break;
}
return s;
}
string A,B;
int D;
int main(){
cin>>A>>B>>D;
cout<<(solve(B,D)-solve(Minus(A),D)+2*mod)%mod<<endl;
}
|
#include<iostream>
#include<string>
using namespace std;
int dp[2][12][502][502]={0};
int m;
char min(char x,char y){if(x>y)return y; return x;}
char max(char x,char y){if(x<y)return y; return x;}
int count(string s){
int ret=0;
int ss=s.size();
if(ss==1)return s[0]/3;
for(int i=1;i<ss;i++){
for(int j=1;j<10;j++){
ret+=dp[0][j][i][0];
if(i!=1)ret+=dp[1][j][i][0];
ret%=10000;
}
}
for(int i=1;i<s[0];i++){
ret+=dp[0][i][ss][0];
ret+=dp[1][i][ss][0];
ret%=10000;
}
int p[502]={0};
int tt[502]={0};
tt[0]=1;
for(int i=1;i<502;i++){tt[i]=tt[i-1]*10; tt[i]%=m;}
p[0]=s[0]*tt[ss-1];
p[0]%=m;
for(int i=1;i<502;i++){
p[i]=p[i-1]+s[i]*tt[ss-1-i];
p[i]%=m;
}
for(int i=1;i<ss;i++){
int t=(i+0)%2;
if(t==1){
if(s[i-1]>=s[i])break;
for(int j=s[i-1]+1;j<s[i];j++){
ret+=dp[t][j][ss-i][(m-p[i-1])%m];
ret%=10000;
}
if(i==ss-1)ret+=dp[t][s[i]][ss-i][(m-p[i-1])%m];
}
if(t==0){
for(int j=0;j<min(s[i-1],s[i]);j++){
ret+=dp[t][j][ss-i][(m-p[i-1])%m];
ret%=10000;
}
if(s[i-1]<=s[i])break;
if(i==ss-1)ret+=dp[t][s[i]][ss-i][(m-p[i-1])%m];
}
}
for(int i=1;i<ss;i++){
int t=(i+1)%2;
if(t==1){
if(s[i-1]>=s[i])break;
for(int j=s[i-1]+1;j<s[i];j++){
ret+=dp[t][j][ss-i][(m-p[i-1])%m];
ret%=10000;
}
if(i==ss-1)ret+=dp[t][s[i]][ss-i][(m-p[i-1])%m];
}
if(t==0){
for(int j=0;j<min(s[i-1],s[i]);j++){
ret+=dp[t][j][ss-i][(m-p[i-1])%m];
ret%=10000;
}
if(s[i-1]<=s[i])break;
if(i==ss-1)ret+=dp[t][s[i]][ss-i][(m-p[i-1])%m];
}
//if(i==ss-1)ret++;
}
return ret;
}
//int count(string s){
// int ret=0;
// int ss=s.size();
// if(ss==1)return s[0]/3;
// for(int i=1;i<ss;i++){
// for(int j=1;j<10;j++){
// ret+=dp[0][j][i][0];
// if(i!=1)ret+=dp[1][j][i][0];
// ret%=10000;
// }
// }
// cout<<"count("<<s<<")="<<ret<<endl;
// for(int k=0;k<2;k++){
// int t=k;
// int tt[502]={0};
// tt[1]=1;
// for(int i=2;i<=ss;i++){
// tt[i]=(tt[i-1]*10)%m;
// }
// int q=0;
// for(int i=0;i<ss;i++){
// int p=0;
// if(i==0)p=1;
// if(i!=0&&t==1)p=max(p,s[i-1]);
// int pp=s[i];
// if(i!=0&&t==0)pp=min(s[i-1],pp);
// for(int j=p;j<pp;j++){
/// ret+=dp[t][j][ss-i][(m-q)%m];
// ret%=10000;
// }
// if(i<ss-1){
// if(t==0&&s[i]>=s[i+1])break;
// //if(t==1)s[i+1]=min(s[i+1],s[i]-1);
// t=1-t;
// q+=s[i]*tt[ss-i];
// q%=m;
// }
// if(i==ss-1){
// ret+=dp[t][s[i]][1][(m-q)%m];
// }
// }
// }
// for(int i=0;i<ss;i++)s[i]+=48;
// cout<<"count("<<s<<")="<<ret<<endl;
// return ret;
//}*/
string f(string s){
int ss=s.size();
int k=ss-1;
while(s[k]==0){
s[k]=9;
k--;
}
s[k]--;
if(k==0&&s[k]==0){
string ret="";
char c='9'-48;
for(int i=0;i<ss-1;i++)ret+=c;
return ret;
}
return s;
}
int main(){
string a,b;
cin>>a;
cin>>b;
int sa=a.size(),sb=b.size();
for(int i=0;i<sa;i++)a[i]-=48;
for(int i=0;i<sb;i++)b[i]-=48;
scanf("%d",&m);
dp[0][0][0][0]=1; dp[1][10][0][0]=1; //dp[0][0][1][0]=1;
int s=max(sa,sb);
int t=1;
for(int j=1;j<=s;j++){
for(int i=0;i<=9;i++){
for(int k=0;k<m;k++){
for(int l=i+1;l<=10;l++){
dp[0][i][j][k]+=dp[1][l][j-1][(k-i*t+i*m)%m];
dp[0][i][j][k]%=10000;
}
}
}
for(int i=0;i<=9;i++){
for(int k=0;k<m;k++){
for(int l=0;l<i;l++){
dp[1][i][j][k]+=dp[0][l][j-1][(k-i*t+i*m)%m];
dp[1][i][j][k]%=10000;
}
}
}
t*=10;
t%=m;
}
a=f(a); //f(string s)は(string)s-1を返す。
printf("%d\n",(count(b)-count(a)+10000)%10000);
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <cstring>
#include <numeric>
#include <algorithm>
#include <functional>
#include <array>
#include <map>
#include <queue>
#include <limits.h>
#include <set>
#include <stack>
#include <random>
#define rep(i,s,n) for(int i = (s); (n) > i; i++)
#define REP(i,n) rep(i,0,n)
#define RANGE(x,a,b) ((a) <= (x) && (x) <= (b))
#define POWT(x) ((x)*(x))
#define ALL(x) (x).begin(), (x).end()
#define MODI 10000
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
template<int MOD>
struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { int sigt = sig % MOD; if (sigt < 0) sigt += MOD; x = sigt; }
ModInt(signed long long sig) { int sigt = sig % MOD; if (sigt < 0) sigt += MOD; x = sigt; }
int get() const { return (int) x; }
ModInt &operator+=(ModInt that) { if ((x += that.x) >= MOD) x -= MOD; return *this; }
ModInt &operator-=(ModInt that) { if ((x += MOD - that.x) >= MOD) x -= MOD; return *this; }
ModInt &operator*=(ModInt that) { x = (unsigned long long)x * that.x % MOD; return *this; }
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
//ModInt operator++(int) const { return ModInt(*this) += 1; }
//ModInt operator--(int) const { return ModInt(*this) -= 1; }
ModInt inverse() const {
signed a = x, b = MOD, u = 1, v = 0;
while (b) {
signed t = a / b;
a -= t * b; std::swap(a, b);
u -= t * v; std::swap(u, v);
}
if (u < 0) u += Mod;
ModInt res; res.x = (unsigned) u;
return res;
}
};
signed main() {
char stra[502], strb[502];
int a[502] = {}, b[502] = {}, m;
ModInt<MODI> ans = 0;
scanf("%s %s %d", stra, strb, &m);
int alen = strlen(stra), blen = strlen(strb);
int mmm = 0;
REP(i, alen) {
a[i] = stra[i]-'0';
mmm = (mmm * 10 + a[i]) % m;
}
bool zii = 1;
for(int i = 1; alen > i; i++){
if ((i % 2) && a[i] > a[i - 1]) {
zii = 0;
break;
}
if (!(i % 2) && a[i] < a[i - 1]) {
zii = 0;
break;
}
}
if (zii) {
for (int i = 1; alen > i; i++) {
if (!(i % 2) && a[i] > a[i - 1]) {
zii = 0;
break;
}
if ((i % 2) && a[i] < a[i - 1]) {
zii = 0;
break;
}
}
}
if (zii && (!mmm))
ans+=1;
REP(i, blen) {
b[i] = strb[i] - '0';
}
map<pii, ModInt<MODI>> pnum;//NUM,MOD
//B
for (int i = 1; b[0] > i; i++) {
pnum[{i, i%m}] += 1;
}
pnum[{b[0], -(b[0] % m) - 1}] += 1;
for (int i = 1; blen > i; i++) {//?????????
map<pii, ModInt<MODI>> next;
for (auto cur : pnum) {
if (cur.first.second < 0) {
if (i % 2) {
for (int j = cur.first.first + 1; b[i] > j; j++) {
next[{j, (-(cur.first.second + 1) * 10 + j) % m}] += cur.second;
}
if (b[i] > cur.first.first) {
next[{b[i], -(((-(cur.first.second + 1)) * 10 + b[i]) % m) - 1}] += cur.second;
}
}
else {
for (int j = min(cur.first.first, b[i]) - 1; 0 <= j; j--) {
next[{j, (-(cur.first.second + 1) * 10 + j) % m}] += cur.second;
}
if (b[i] < cur.first.first) {
next[{b[i], -(((-(cur.first.second + 1)) * 10 + b[i]) % m) - 1}] += cur.second;
}
}
}
else {
if (i % 2) {
for (int j = cur.first.first + 1; 9 >= j; j++) {
next[{j, (cur.first.second * 10 + j) % m}] += cur.second;
}
}
else {
for (int j = cur.first.first - 1; 0 <= j; j--) {
next[{j, (cur.first.second * 10 + j) % m}] += cur.second;
}
}
}
}
for (int i = 1; 9 >= i; i++) {
next[{i, i%m}] += 1;
}
pnum.swap(next);
}
for (auto cur : pnum) {
if (cur.first.second == 0 || cur.first.second == -1) {
ans += cur.second;
}
}
pnum.clear();
if (blen > 1) {
for (int i = 1; b[0] > i; i++) {
pnum[{i, i%m}] += 1;
}
pnum[{b[0], -(b[0] % m) - 1}] += 1;
for (int i = 1; blen > i; i++) {//?????????
map<pii, ModInt<MODI>> next;
for (auto cur : pnum) {
if (cur.first.second < 0) {
if (!(i % 2)) {
for (int j = cur.first.first + 1; b[i] > j; j++) {
next[{j, (-(cur.first.second + 1) * 10 + j) % m}] += cur.second;
}
if (b[i] > cur.first.first) {
next[{b[i], -(((-(cur.first.second + 1)) * 10 + b[i]) % m) - 1}] += cur.second;
}
}
else {
for (int j = min(cur.first.first, (int) b[i]) - 1; 0 <= j; j--) {
next[{j, (-(cur.first.second + 1) * 10 + j) % m}] += cur.second;
}
if (b[i] < cur.first.first) {
next[{b[i], -(((-(cur.first.second + 1)) * 10 + b[i]) % m) - 1}] += cur.second;
}
}
}
else {
if (!(i % 2)) {
for (int j = cur.first.first + 1; 9 >= j; j++) {
next[{j, (cur.first.second * 10 + j) % m}] += cur.second;
}
}
else {
for (int j = cur.first.first - 1; 0 <= j; j--) {
next[{j, (cur.first.second * 10 + j) % m}] += cur.second;
}
}
}
}
if (i < (blen - 1)) {
for (int i = 1; 9 >= i; i++) {
next[{i, i%m}] += 1;
}
}
else {
printf("");
}
pnum.swap(next);
}
for (auto cur : pnum) {
if (cur.first.second == 0 || cur.first.second == -1) {
ans += cur.second;
}
}
pnum.clear();
}
//A
for (int i = 1; a[0] > i; i++) {
pnum[{i, i%m}] += 1 ;
}
pnum[{a[0], -(a[0] % m) - 1}] += 1;
for (int i = 1; alen > i; i++) {//?????????
map<pii, ModInt<MODI>> next;
for (auto cur : pnum) {
if (cur.first.second < 0) {
if (i % 2) {
for (int j = cur.first.first + 1; a[i] > j; j++) {
next[{j, (-(cur.first.second + 1) * 10 + j) % m}] += cur.second;
}
if (a[i] > cur.first.first) {
next[{a[i], -(((-(cur.first.second + 1)) * 10 + a[i]) % m) - 1}] += cur.second;
}
}
else {
for (int j = min(cur.first.first, (int) a[i]) - 1; 0 <= j; j--) {
next[{j, (-(cur.first.second + 1) * 10 + j) % m}] += cur.second;
}
if (a[i] < cur.first.first) {
next[{a[i], -(((-(cur.first.second + 1)) * 10 + a[i]) % m) - 1}] += cur.second;
}
}
}
else {
if (i % 2) {
for (int j = cur.first.first + 1; 9 >= j; j++) {
next[{j, (cur.first.second * 10 + j) % m}] += cur.second;
}
}
else {
for (int j = cur.first.first - 1; 0 <= j; j--) {
next[{j, (cur.first.second * 10 + j) % m}] += cur.second;
}
}
}
}
for (int i = 1; 9 >= i; i++) {
next[{i, i%m}] += 1;
}
pnum.swap(next);
}
for (auto cur : pnum) {
if (cur.first.second == 0 || cur.first.second == -1) {
ans -= cur.second;
}
}
pnum.clear();
if (alen > 1) {
for (int i = 1; a[0] > i; i++) {
pnum[{i, i%m}] += 1;
}
pnum[{a[0], -(a[0] % m) - 1}] += 1;
for (int i = 1; alen > i; i++) {//?????????
map<pii, ModInt<MODI>> next;
for (auto cur : pnum) {
if (cur.first.second < 0) {
if (!(i % 2)) {
for (int j = cur.first.first + 1; a[i] > j; j++) {
next[{j, (-(cur.first.second + 1) * 10 + j) % m}] += cur.second;
}
if (a[i] > cur.first.first) {
next[{a[i], -(((-(cur.first.second + 1)) * 10 + a[i]) % m) - 1}] += cur.second;
}
}
else {
for (int j = min(cur.first.first, (int) a[i]) - 1; 0 <= j; j--) {
next[{j, (-(cur.first.second + 1) * 10 + j) % m}] += cur.second;
}
if (a[i] < cur.first.first) {
next[{a[i], -(((-(cur.first.second + 1)) * 10 + a[i]) % m) - 1}] += cur.second;
}
}
}
else {
if (!(i % 2)) {
for (int j = cur.first.first + 1; 9 >= j; j++) {
next[{j, (cur.first.second * 10 + j) % m}] += cur.second;
}
}
else {
for (int j = cur.first.first - 1; 0 <= j; j--) {
next[{j, (cur.first.second * 10 + j) % m}] += cur.second;
}
}
}
}
if (i < (alen - 1)) {
for (int i = 1; 9 >= i; i++) {
next[{i, i%m}] += 1;
}
}
pnum.swap(next);
}
for (auto cur : pnum) {
if (cur.first.second == 0 || cur.first.second == -1) {
ans -= cur.second;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
string str[2];
const short mod=10000;
int dmod;
//何桁目か・mod・a桁目の数字・↑(0)、↓(1)、一桁目(2)・Bと一致しているか(1)否か(0)
unsigned short dp[501][501][11][3][3];
//何桁目か・mod・a桁目の数字・↑(0)、↓(1)、一桁目(2)・Aと一致しているか(1)否か(0)
void dfs(int a,int div,int c,int d,int e){
}
int main(void){
memset(dp,0,sizeof(dp));
cin >> str[0];
cin >> str[1];
cin >> dmod;
//1~Bまでのジグザグ数の計算
//一桁目だけ計算
for(int i=0;i<=(str[1][0]-'0');i++){
int b=i%dmod;
if(i==0)continue;
else if(i!=(str[1][0]-'0'))dp[0][b][i][2][0]=1;
else dp[0][b][i][2][1]=1;
}
for(int a=1;a<str[1].size();a++){
//0が続く場合
// dp[a][0][0][2][2]=1;
//ここから登場する数
for(int c=1;c<=9;c++){
dp[a][c%dmod][c][2][0]=1;
}
for(int b=0;b<dmod;b++){
for(int c=0;c<=9;c++){
for(int pc=0;pc<=9;pc++){
int div=(b*10+c)%dmod;
if(c>pc){
dp[a][div][c][0][0]=(dp[a][div][c][0][0]+dp[a-1][b][pc][1][0]+dp[a-1][b][pc][2][0])%mod;
if(pc==0)dp[a][div][c][0][0]=(dp[a][div][c][0][0]+dp[a][b][pc][2][2])%mod;
if(c<(str[1][a]-'0')){
dp[a][div][c][0][0]=(dp[a][div][c][0][0]+dp[a-1][b][pc][1][1]+dp[a-1][b][pc][2][1])%mod;
}
if(c==(str[1][a]-'0')){
dp[a][div][c][0][1]=(dp[a][div][c][0][1]+dp[a-1][b][pc][1][1]+dp[a-1][b][pc][2][1])%mod;
}
}
if(c<pc){
dp[a][div][c][1][0]=(dp[a][div][c][1][0]+dp[a-1][b][pc][0][0]+dp[a-1][b][pc][2][0])%mod;
if(c<(str[1][a]-'0')){
dp[a][div][c][1][0]=(dp[a][div][c][1][0]+dp[a-1][b][pc][0][1]+dp[a-1][b][pc][2][1])%mod;
}
if(c==(str[1][a]-'0')){
dp[a][div][c][1][1]=(dp[a][div][c][1][1]+dp[a-1][b][pc][0][1]+dp[a-1][b][pc][2][1])%mod;
}
}
}
}
}
}
//
int ans=0;
//1~Bまでの分を足す
for(int i=0;i<10;i++){
ans=(ans+dp[str[1].size()-1][0][i][0][0]+dp[str[1].size()-1][0][i][0][1]+dp[str[1].size()-1][0][i][1][0]+dp[str[1].size()-1][0][i][1][1]+dp[str[1].size()-1][0][i][2][0]+dp[str[1].size()-1][0][i][2][1])%mod;
}
memset(dp,0,sizeof(dp));
//1~Aまでのジグザグ数の計算
for(int i=0;i<=(str[0][0]-'0');i++){
int b=i%dmod;
if(i==0)continue;
else if(i!=(str[0][0]-'0'))dp[0][b][i][2][0]=1;
else dp[0][b][i][2][1]=1;
}
for(int a=1;a<str[0].size();a++){
//0が続く場合
// dp[a][0][0][2][2]=1;
//ここから登場する数
for(int c=1;c<=9;c++){
dp[a][c%dmod][c][2][0]=1;
}
for(int b=0;b<dmod;b++){
for(int c=0;c<=9;c++){
for(int pc=0;pc<=9;pc++){
int div=(b*10+c)%dmod;
if(c>pc){
dp[a][div][c][0][0]=(dp[a][div][c][0][0]+dp[a-1][b][pc][1][0]+dp[a-1][b][pc][2][0])%mod;
if(pc==0)dp[a][div][c][0][0]=(dp[a][div][c][0][0]+dp[a][b][pc][2][2])%mod;
if(c<(str[0][a]-'0')){
dp[a][div][c][0][0]=(dp[a][div][c][0][0]+dp[a-1][b][pc][1][1]+dp[a-1][b][pc][2][1])%mod;
}
if(c==(str[0][a]-'0')){
dp[a][div][c][0][1]=(dp[a][div][c][0][1]+dp[a-1][b][pc][1][1]+dp[a-1][b][pc][2][1])%mod;
}
}
if(c<pc){
dp[a][div][c][1][0]=(dp[a][div][c][1][0]+dp[a-1][b][pc][0][0]+dp[a-1][b][pc][2][0])%mod;
if(c<(str[0][a]-'0')){
dp[a][div][c][1][0]=(dp[a][div][c][1][0]+dp[a-1][b][pc][0][1]+dp[a-1][b][pc][2][1])%mod;
}
if(c==(str[0][a]-'0')){
dp[a][div][c][1][1]=(dp[a][div][c][1][1]+dp[a-1][b][pc][0][1]+dp[a-1][b][pc][2][1])%mod;
}
}
}
}
}
}
//
//1~A-1までの分を引く
for(int i=0;i<10;i++){
ans=(ans+mod*2-dp[str[0].size()-1][0][i][0][0]-dp[str[0].size()-1][0][i][1][0]-dp[str[0].size()-1][0][i][2][0])%mod;
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<string>
using namespace std;
const int mod = 10000;
int dp[600][600][11][2][2];
string S, T; int power[600], n;
int zen_shori(int Keta) {
for (int i = 0; i < 360000; i++) {
for (int j = 0; j < 10; j++) {
dp[i / 600][i % 600][j][0][0] = 0;
dp[i / 600][i % 600][j][0][1] = 0;
dp[i / 600][i % 600][j][1][0] = 0;
dp[i / 600][i % 600][j][1][1] = 0;
}
}
int F = 0;
for (int i = 1; i <= 9; i++) { if (i%n == 0)F++; }
if (Keta == 1)return F;
if (Keta == 0)return 0;
dp[0][0][0][0][1] = 1; dp[0][0][10][1][1] = 1;
for (int i = 0; i < Keta; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < 11; k++) {
for (int l = 0; l < 2; l++) {
int L = 0, R = 9;
if (l == 0)L = k + 1;
if (l == 1)R = k - 1;
for (int m = 0; m <= 9; m++) {
int Plus = (power[i] * m) % n;
int to = (j + Plus) % n;
if (L <= m && m <= R) {
dp[i + 1][to][m][1 - l][0] += dp[i][j][k][l][0]; dp[i + 1][to][m][1 - l][0] %= mod;
}
if (m >= 1) { dp[i + 1][to][m][1 - l][0] += dp[i][j][k][l][1]; dp[i + 1][to][m][1 - l][0] %= mod; }
if (m == 0) { dp[i + 1][to][m][1 - l][1] += dp[i][j][k][l][1]; dp[i + 1][to][m][1 - l][1] %= mod; }
}
}
}
}
}
int sum = 0;
for (int i = 0; i < 10; i++) { for (int j = 0; j < 2; j++) { sum += dp[Keta][0][i][j][0]; } }
sum -= F;
//cout << sum << endl;
return sum;
}
int solve(string V) {
for (int i = 0; i < 360000; i++) {
for (int j = 0; j < 10; j++) {
dp[i / 600][i % 600][j][0][0] = 0;
dp[i / 600][i % 600][j][0][1] = 0;
dp[i / 600][i % 600][j][1][0] = 0;
dp[i / 600][i % 600][j][1][1] = 0;
}
}
int F = 0;
for (int i = 1; i <= (int)(V[0] - '0'); i++) { if (i%n == 0)F++; }
if (V.size() == 1)return F;
dp[0][0][0][0][1] = 1; dp[0][0][10][1][1] = 1;
for (int i = 0; i < (int)V.size(); i++) {
int P = V[i] - '0';
for (int j = 0; j < n; j++) {
for (int k = 0; k < 11; k++) {
for (int l = 0; l < 2; l++) {
if (dp[i][j][k][l][0] == 0 && dp[i][j][k][l][1] == 0)continue;
int L = 0, R = 9;
if (l == 0)L = k + 1;
if (l == 1)R = k - 1;
for (int m = L; m <= R; m++) {
if (i == 0 && m == 0)continue;
int Plus = (power[i] * m) % n;
int to = (j + Plus) % n;
dp[i + 1][to][m][1 - l][0] += dp[i][j][k][l][0]; dp[i + 1][to][m][1 - l][0] %= mod;
if (P > m) { dp[i + 1][to][m][1 - l][0] += dp[i][j][k][l][1]; dp[i + 1][to][m][1 - l][0] %= mod; }
if (P == m) { dp[i + 1][to][m][1 - l][1] += dp[i][j][k][l][1]; dp[i + 1][to][m][1 - l][1] %= mod; }
}
}
}
}
}
int sum = 0;
for (int i = 0; i < 10; i++) { for (int j = 0; j < 2; j++) { sum += dp[V.size()][0][i][j][0] + dp[V.size()][0][i][j][1]; } }
//cout << sum << endl;
return sum;
}
int solve2(string V) {
int v = 1; for (int i = V.size() - 1; i >= 0; i--) { power[i] = v; v *= 10; v %= n; }
int r1 = solve(V);
int r2 = zen_shori(V.size() - 1);
return (r2 + r1) % mod;
}
int main() {
cin >> S >> T >> n;
int ii = S.size() - 1; while (S[ii] == '0') { S[ii] = '9'; ii--; } S[ii]--;
while (S[0] == '0' && S.size() >= 2)S = S.substr(1, S.size() - 1);
cout << (solve2(T) - solve2(S) + mod) % mod << endl;
return 0;
}
|
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
constexpr int mod = 10000;
constexpr int MAX_DIGIT = 500;
constexpr int MAX_M = 500;
int dp[MAX_DIGIT + 1][MAX_M][10][2][2]; // digit, modulo m, prev, less flag, zig-zag flag
int calc(const string &limit, int m) {
const int n = limit.size();
memset(dp, 0, sizeof(dp));
for(int i = 0; i < n; ++i) {
for(int j = 0; j < 10; ++j) {
const bool lt = (j < limit[i] - '0');
const bool le = (j <= limit[i] - '0');
if(j && (i || le)) {
(dp[i + 1][j % m][j][i || lt][true] += 1) %= mod;
(dp[i + 1][j % m][j][i || lt][false] += 1) %= mod;
}
for(int k = 0; k < m; ++k) {
const int next_rest = (k * 10 + j) % m;
for(int l = 0; l < j; ++l) {
(dp[i + 1][next_rest][j][true][true] += dp[i][k][l][true][false]) %= mod;
if(le) {
(dp[i + 1][next_rest][j][lt][true] += dp[i][k][l][false][false]) %= mod;
}
}
for(int l = j + 1; l < 10; ++l) {
(dp[i + 1][next_rest][j][true][false] += dp[i][k][l][true][true]) %= mod;
if(le) {
(dp[i + 1][next_rest][j][lt][false] += dp[i][k][l][false][true]) %= mod;
}
}
}
}
}
int res = 0;
for(int i = 0; i < 10; ++i) {
res += dp[n][0][i][true][true];
res += dp[n][0][i][true][false];
if(i && (n > 1 || i < limit.back() - '0') && i % m == 0) {
--res;
}
}
return res % mod;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string a, b;
int m;
cin >> a >> b >> m;
int carry = 1;
for(int i = b.size() - 1; i >= 0; --i) {
b[i] += carry;
if(b[i] <= '9') {
carry = 0;
break;
}
else {
b[i] = '0';
}
}
if(carry) b = '1' + b;
cout << (calc(b, m) - calc(a, m) + mod) % mod << endl;
return EXIT_SUCCESS;
}
|
#include<bits/stdc++.h>
#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<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;
a=min1(a);
ansb=solve(b);
ansa=solve(a);
cout<<(ansb+MOD-ansa)%MOD<<"\n";
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
#include <bits/stdc++.h>
#define N 10000
using namespace std;
string a,b;
long long m;
long long dp[512][4][4][16][512] = {0};
long long solve(string &s);
int main(){
cin >> a >> b >> m;
reverse(a.begin(),a.end());
int id = 0;
while(a[id]=='0')a[id++] = '9';
--a[id];
if(a[a.size()-1] == '0')a.pop_back();
reverse(a.begin(),a.end());
cout << (solve(b)- solve(a) + N) % N << endl;
return 0;
}
long long solve(string &s){
long long ans = 0,ssize = s.size();
if(ssize == 0)return 0;
if(ssize == 1)return ((s[0] - '0')/m + N) % N;
//last digit
ans = (-9/m + N) % N;
for(int i = 0;i <= ssize;++i)
for(int j= 0;j <2;++j)
for(int k= 0;k < 2;++k)
for(int l = 0;l < 10;++l)
for(int o = 0;o < m;++o)
dp[i][j][k][l][o] = 0;
//index
for(int i = 0;i < ssize;++i)
//next num
for(int j = 0;j < 10;++j){
if(j != 0 && (i != 0 || s[i] - '0' >= j))
for(int k = 0;k < 2;++k)
++dp[i+1][!(i==0&&s[i] - '0' ==j)][k][j][j%m] %= N;
//before num (down)
for(int k = 0;k < j;++k)
if(j != k)
//mod m
for(int l = 0;l < m;++l){
// less than:1
if(j < s[i] - '0'){
dp[i+1][1][1][j][(l * 10+j)%m] += (dp[i][1][0][k][l] + dp[i][0][0][k][l]) % N;
dp[i+1][1][1][j][(l * 10+j)%m] %= N;
}
// equal
else if(j == s[i] - '0'){
dp[i+1][1][1][j][(l * 10+j)%m] += dp[i][1][0][k][l];
dp[i+1][1][1][j][(l * 10+j)%m] %= N;
dp[i+1][0][1][j][(l * 10+j)%m] += dp[i][0][0][k][l];
dp[i+1][0][1][j][(l * 10+j)%m] %= N;
}
else {
dp[i+1][1][1][j][(l * 10+j)%m] += dp[i][1][0][k][l];
dp[i+1][1][1][j][(l * 10+j)%m] %= N;
}
}
//before num (up)
for(int k = j + 1;k < 10;++k)
if(j != k)
//mod m
for(int l = 0;l < m;++l){
// less than:1
if(j < s[i] - '0'){
dp[i+1][1][0][j][(l * 10 +j)%m] += (dp[i][1][1][k][l] + dp[i][0][1][k][l]) % N;
dp[i+1][1][0][j][(l * 10 +j)%m] %= N;
}
// equal
else if(j == s[i] - '0'){
dp[i+1][1][0][j][(l * 10 +j)%m] += dp[i][1][1][k][l];
dp[i+1][1][0][j][(l * 10 +j)%m] %= N;
dp[i+1][0][0][j][(l * 10 +j)%m] += dp[i][0][1][k][l];
dp[i+1][0][0][j][(l * 10 +j)%m] %= N;
}
else {
dp[i+1][1][0][j][(l * 10 +j)%m] += dp[i][1][1][k][l];
dp[i+1][1][0][j][(l * 10 +j)%m] %= N;
}
}
}
for(int i = 0;i < 2;++i)
for(int j = 0;j < 2;++j)
for(int k = 0;k < 10;++k){
ans += dp[ssize][i][j][k][0];
ans %= N;
}
return ans % N;
}
|
#include<cstdio>
#include<cstring>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int n,m;
char s[512];
int dp[512][500][10][2];
// 今何桁目か, i 桁目を自由に決められるか, i 桁目までの mod m での値, i-1 桁目の数字, 一つ前で上がったか下がったか, 直前まですべて 0 だったか
int dfs(int i,bool b,int mod,int pre,bool up,bool z){
if(i==n) return mod==0?1:0;
if(b && !z && dp[i][mod][pre][up?1:0]!=-1) return dp[i][mod][pre][up?1:0];
int res=0;
int d0=s[i]-'0';
if(z){
res+=dfs(i+1,true,(10*mod+0)%m,0,true,true);
if(!b){
for(int d=1;d<=d0;d++){
res+=dfs(i+1,d<d0,(10*mod+d)%m,d, true,false);
res+=dfs(i+1,d<d0,(10*mod+d)%m,d,false,false);
}
}
else{
for(int d=1;d<10;d++){
res+=dfs(i+1,true,(10*mod+d)%m,d, true,false);
res+=dfs(i+1,true,(10*mod+d)%m,d,false,false);
}
}
}
else{
if(!b){
if(up){ // 前回上がったなら今回下がる
for(int d=0;d<=d0&&d<pre;d++){
res+=dfs(i+1,d<d0,(10*mod+d)%m,d,!up,false);
}
}
else{ // 前回下がったなら今回上がる
for(int d=pre+1;d<=d0;d++){
res+=dfs(i+1,d<d0,(10*mod+d)%m,d,!up,false);
}
}
}
else{
if(up){
rep(d,pre){
res+=dfs(i+1,true,(10*mod+d)%m,d,!up,false);
}
}
else{
for(int d=pre+1;d<10;d++){
res+=dfs(i+1,true,(10*mod+d)%m,d,!up,false);
}
}
}
}
res%=10000;
if(b && !z) dp[i][mod][pre][up?1:0]=res;
return res;
}
int solve(const char *a){
strcpy(s,a);
n=strlen(s);
memset(dp,-1,sizeof dp);
int res=dfs(0,false,0,0,true,true);
// dfs で 1, 2, ..., 9 を二回カウントしてしまうので、その分を答えから引く
for(int i=1;i<10;i++){
if((n>=2 || i<=a[0]-'0') && i%m==0) res--;
}
return (res+10000)%10000;
}
// decrement
char *dec(char *a){
int n=strlen(a),i;
for(i=n-1;a[i]=='0';i--) a[i]='9';
a[i]--;
if(n>=2 && a[0]=='0') memmove(a,a+1,n); // leading 0 を削除
return a;
}
int main(){
char a[512],b[512];
scanf("%s%s%d",a,b,&m);
printf("%d\n",(solve(b)-solve(dec(a))+10000)%10000);
return 0;
}
|
#include<vector>
#include<map>
#include<set>
#include<algorithm>
#include<functional>
#include<numeric>
#include<utility>
#include<sstream>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cctype>
#include<string>
#include<cstring>
using namespace std;
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 EACH(i,c) for(typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
const int MOD=10000;
int M;
int memo[501][10][3][2][500];
//up->1,down->0;
string s;
int solve(int n,int prev,int ud,int fr,int md){
if(n==s.size())return md?0:1;
if(memo[n][prev][ud][fr][md]!=-1)
return memo[n][prev][ud][fr][md];
int ret=0;
for(int i=0;i<=(fr?9:s[n]-'0');i++){
if(ud==1&&prev>=i)continue;
if(ud==0&&prev<=i)continue;
if(ud==2&&prev!=0&&prev==i)continue;
int u;
if(ud==2){
if(prev==0)u=2;
else if(prev<i)u=0;
else u=1;
}
else u=1-ud;
int f;
if(fr)f=1;
else{
if(i!=s[n]-'0')f=1;
else f=0;
}
ret+=solve(n+1,i,u,f,(md*10+i)%M);
ret%=MOD;
}
return memo[n][prev][ud][fr][md]=ret;
}
int main(){
string A,B;
cin>>A>>B>>M;
for(int i=A.size()-1;i>=0;i--){
if(A[i]=='0'){
A[i]='9';
}
else{
A[i]--;
break;
}
}
s=A;
memset(memo,-1,sizeof(memo));
int a=solve(0,0,2,0,0);
s=B;
memset(memo,-1,sizeof(memo));
int b=solve(0,0,2,0,0);
cout<<(b-a+MOD)%MOD<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;
bool GaussJordan(const vvd& _a,const vd& b,vd& x)
{
int n=_a.size();
vvd a(n,vd(n+1));
rep(i,n){
copy(all(_a[i]),begin(a[i]));
a[i][n]=b[i];
}
rep(i,n){
int p=i;
repi(j,i+1,n) if(abs(a[p][i])<abs(a[j][i])) p=j;
if(abs(a[p][i])<EPS) return false;
swap(a[i],a[p]);
peri(j,i,n+1) a[i][j]/=a[i][i];
rep(j,n) if(j!=i) peri(k,i,n+1) a[j][k]-=a[j][i]*a[i][k];
}
rep(i,n) x[i]=a[i][n];
return true;
}
struct Edge{
int src,dst;
double cost;
int cap,flow;
Edge(){}
Edge(int s,int d,double co,int ca=0,int f=0):src(s),dst(d),cost(co),cap(ca),flow(f){}
};
bool operator<(const Edge& a,const Edge& b){return a.cost<b.cost;}
bool operator>(const Edge& a,const Edge& b){return a.cost>b.cost;}
struct Graph{
vector<Edge> es;
vi head,next;
Graph(){}
Graph(int n):head(n,-1){}
// コスト:-co,容量:0の逆辺も追加する
void AddEdge(int u,int v,double co,int ca){
es.emplace_back(u,v,co,ca); next.push_back(head[u]); head[u]=es.size()-1;
es.emplace_back(v,u,-co,0); next.push_back(head[v]); head[v]=es.size()-1;
}
};
double MinCostFlow(Graph& g,int tap,int sink,int flow)
{
int n=g.head.size();
double res=0;
vd pots(n);
while(flow>EPS){
vd cost(n,INF);
vi prev(n,-1);
priority_queue<Edge,vector<Edge>,greater<Edge>> pq;
pq.emplace(-1,tap,0);
while(pq.size()){
Edge cur=pq.top(); pq.pop();
if(cur.cost>cost[cur.dst]-EPS) continue;
cost[cur.dst]=cur.cost;
prev[cur.dst]=cur.src;
for(int i=g.head[cur.dst];i!=-1;i=g.next[i]){
Edge e=g.es[i];
if(e.cap-e.flow==0) continue;
pq.emplace(i,e.dst,cost[e.src]+e.cost+pots[e.src]-pots[e.dst]);
}
}
if(cost[sink]==INF) return -1;
rep(i,n) pots[i]+=cost[i];
int augment=flow;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
Edge e=g.es[prev[v]];
augment=min(augment,e.cap-e.flow);
}
if(augment<EPS) return -1;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
int i=prev[v];
g.es[i].flow+=augment;
g.es[i^1].flow-=augment;
}
flow-=augment;
res+=augment*pots[sink];
}
return res;
}
void solve()
{
int n,s,t,f; cin>>n>>s>>t>>f;
vd cs(n);
{
vvd a(n,vd(n));
vd b(n);
rep(i,n){
rep(j,n) cin>>a[i][j];
cin>>b[i];
}
GaussJordan(a,b,cs);
}
Graph g(n);
rep(i,n){
int m; cin>>m;
vi ds(m),fs(m);
rep(j,m) cin>>ds[j];
rep(j,m) cin>>fs[j];
rep(j,m) g.AddEdge(i,ds[j],abs(cs[ds[j]]-cs[i]),fs[j]);
}
double res=MinCostFlow(g,s,t,f);
if(res==-1)
puts("impossible");
else
printf("%.10f\n",res);
}
int main()
{
int tc; cin>>tc;
rep(_,tc) solve();
}
|
#include<bits/stdc++.h>
using namespace std;
#define MAX_V 105
#define INF 1000000001
typedef pair< double ,int> P;
struct edge {
int to;
int cap;
int rev;
double cost;
};
int V;
vector<edge> G[MAX_V];
double h[MAX_V];
double dist[MAX_V];
int prevv[MAX_V],preve[MAX_V];
void init_edge(){
for(int i=0;i<MAX_V;i++)G[i].clear();
}
void add_edge(int from,int to,int cap,double cost){
G[from].push_back((edge){to,cap,(int)G[to].size(),cost});
G[to].push_back((edge){from,0,(int)G[from].size()-1,-cost});
}
double min_cost_flow(int s,int t,int f){
double eps = 1e-5;
double res = 0;
fill(h,h+V,0.0);
while(f>0){
priority_queue< P, vector<P>, greater<P> > que;
fill( dist, dist+V , (double)INF );
dist[s]=0;
que.push(P(0,s));
fill ( prevv , prevv + V , s );
while(!que.empty()){
P p = que.top(); que.pop();
int v = p.second;
if(dist[v]+eps < p.first)continue;
for(int i=0;i<(int)G[v].size();i++){
edge &e = G[v][i];
if(e.cap>0&&dist[e.to] > eps+dist[v]+e.cost+h[v]-h[e.to]){
dist[e.to]=dist[v]+e.cost+h[v]-h[e.to];
prevv[e.to]=v;
preve[e.to]=i;
que.push(P(dist[e.to],e.to));
}
}
}
if(dist[t] == INF){
return -1;
}
for(int v=0;v<V;v++)h[v]+=dist[v];
int d=f;
for(int v=t;v!=s;v=prevv[v]){
d=min(d,G[prevv[v]][preve[v]].cap);
}
assert( d > 0 );
f-=d;
res+=d*h[t];
for(int v=t;v!=s;v=prevv[v]){
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
typedef vector< double > vec;
typedef vector<vec> mat;
vec gauss_jordan(const mat&A,const vec&b){
int n=A.size();
mat B(n,vec(n+1));
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)B[i][j]=A[i][j];
for(int i=0;i<n;i++)B[i][n]=b[i];
for(int i=0;i<n;i++){
int pivot=i;
for(int j=i;j<n;j++)
if(abs(B[j][i])>abs(B[pivot][i]))pivot=j;
swap(B[i],B[pivot]);
if(abs(B[i][i])< 0.0000001 )return vec();
for(int j=i+1;j<=n;j++)B[i][j]/=B[i][i];
for(int j=0;j<n;j++){
if(i!=j)
for(int k=i+1;k<=n;k++)B[j][k]-=B[j][i]*B[i][k];
}
}
vec x(n);
for(int i=0;i<n;i++)x[i]=B[i][n];
return x;
}
int N,si,ti,F;
int M;
int main(){
int T;
cin>>T;
while(T--){
init_edge();
cin>>N>>si>>ti>>F;
mat A( N , vec(N) );
vec B( N );
for(int i=0;i<N;i++){
for(int j=0;j<N;j++)scanf("%lf",&A[i][j]);
scanf("%lf",&B[i]);
}
vec C=gauss_jordan(A,B);
for(int i=0;i<N;i++){
cin>>M;
vector<int> d(M);
vector<int> f(M);
for(int j=0;j<M;j++)scanf("%d",&d[j]);
for(int j=0;j<M;j++)scanf("%d",&f[j]);
for(int j=0;j<M;j++){
add_edge(i,d[j],f[j], abs(C[i]-C[d[j]]) );
}
}
V=N;
double ans=min_cost_flow(si,ti,F);
if(ans<=-1.0){
cout<<"impossible"<<endl;
}else{
printf("%.10f\n",ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
typedef long double D;
struct edge { int to; D cap, cost; int rev; };
//int const INF = 1<<29;
double const Inf = 1e40;
int const Max = 300;
D h[Max], dist[Max];
int prevv[Max], preve[Max];
int V;
vector<edge> G[Max];
inline void add_edge(int f, int t, D cap, D cost) {
G[f].push_back((edge){t, cap, cost, (int)G[t].size()});
G[t].push_back((edge){f, 0, -cost, (int)G[f].size()-1});
}
double const INF = 1e40;
long double const EPS = 1e-5;
typedef pair<D, int> P;
D min_cost_flow(int S, int T, D f) {
D ret = 0;
fill(h, h+V, 0);
while(f > 0) {
priority_queue<P, vector<P>, greater<P> > pq;
fill(dist, dist+V, INF);
dist[S] = 0;
pq.push(P(0, S));
while(!pq.empty()) {
D cost = pq.top().first;
int curr = pq.top().second; pq.pop();
if(dist[curr] < cost) { continue; }
rep(i, G[curr].size()) {
edge& e = G[curr][i];
if(e.cap > EPS && dist[e.to] > dist[curr] + e.cost + h[curr] - h[e.to] + EPS) {
dist[e.to] = dist[curr] + e.cost + h[curr] - h[e.to];
prevv[e.to] = curr;
preve[e.to] = i;
pq.push(P(dist[e.to], e.to));
}
}
}
if(dist[T] == INF) { return -1; }
rep(i, V) h[i] += dist[i];
D d = f;
for(int v = T; v!=S; v=prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
ret += d*h[T];
for(int v=T; v!=S; v=prevv[v]) {
edge& e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return ret;
}
template<class T>
vector<T> gauss_jordan(vector<vector<T> > const& A, vector<T> const& b) {
int N = A.size();
vector<vector<T> > B(A);
rep(i, B.size()) B[i].resize(N+1);
rep(i, N) B[i][N] = b[i];
rep(i, N) {
int pivot = i;
REP(j, i, N) {
if(abs(B[pivot][i]) < abs(B[j][i])) {
pivot = j;
}
}
swap(B[i], B[pivot]);
if(abs(B[i][i]) < EPS) { return vector<T>(); }
REP(j, i+1, N+1) { B[i][j] /= B[i][i]; }
rep(j, N) if(i != j) {
REP(k, i+1, N+2) B[j][k] -= B[j][i] * B[i][k];
}
}
vector<T> x(N);
rep(i, N) x[i] = B[i][N];
return x;
}
typedef vector<D> Vec;
typedef vector<Vec> Mat;
int main() {
int Tc; cin >> Tc;
while(Tc--) {
int N, s, t; D F; cin >> N >> s >> t >> F;
V = N;
rep(i, N) G[i].clear();
Mat A(N, Vec(N)); Vec b(N);
rep(i, N) {
rep(j, N) {
cin >> A[i][j];
}
cin >> b[i];
}
Vec X(gauss_jordan(A, b));
rep(i, N) {
int M; cin >> M;
vector<int> ds(M);
rep(j, M) { cin >> ds[j]; }
rep(j, M) {
D f; cin >> f;
// cerr << i << " -> " << ds[j] << endl;
add_edge(i, ds[j], f, abs(X[i]-X[ds[j]]));
}
}
D r = min_cost_flow(s, t, F);
if(r < EPS) {
cout << "impossible\n";
}
else {
printf("%.10Lf\n", r);
}
}
return 0;
}
|
#include<algorithm>
#include<cassert>
#include<cctype>
#include<climits>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<iomanip>
#include<map>
#include<numeric>
#include<queue>
#include<vector>
#include<set>
#include<string>
#include<stack>
#include<sstream>
#include<complex>
#define pb push_back
#define clr clear()
#define sz size()
#define fs first
#define sc second
#define rep(i,a) for(int i=0;i<(int)(a);i++)
#define rrep(i,a) for(int i=(int)(a)−1;i>=0;i−−)
#define all(a) (a).begin(),(a).end()
#define EQ(a,b) (abs((a)−(b)) < EPS)
#define INIT(a) memset(a,0,sizeof(a))
using namespace std;
typedef double D;
typedef pair<D,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
const D EPS = 1e-7;
const D INF = 1e9;
const D PI = acos(-1);
typedef vector<D> vec;
typedef vector<vec> mat;
struct matrix{
mat m;
int r,c;
matrix(void){r=c=0;m.clr;}
matrix(mat a){
r = a.sz; c = a[0].sz;
m.resize(r);
rep(i,r)m[i].resize(c);
rep(i,r)rep(j,c)m[i][j] = a[i][j];
}
matrix operator+(matrix a){
if(r==a.r && c==a.c){
rep(i,r)rep(j,c)a.m[i][j] += m[i][j];
}
return a;
}
matrix operator-(matrix a){
rep(i,a.r)rep(j,a.c)a.m[i][j] *= -1;
return *this+a;
}
matrix operator*(matrix a){
matrix x;
if(c==a.r){
x.r = r; x.c = a.c;
x.m.resize(r);
rep(i,r)x.m[i].resize(a.c);
rep(i,r)rep(j,a.c){
x.m[i][j] = 0;
rep(k,c)x.m[i][j] += m[i][k] * a.m[k][j];
}
}
return x;
}
};
vec gauss_jordan(const mat& A, const vec& b){
int n = A.size();
mat B(n,vec(n+1));
rep(i,n)rep(j,n)B[i][j] = A[i][j];
rep(i,n)B[i][n] = b[i];
rep(i,n){
int p=i;
for(int j=i;j<n;j++)
if(abs(B[j][i]) > abs(B[p][i]))p = j;
swap(B[i],B[p]);
//解がないか、一意でない
if(abs(B[i][i]) < EPS)return vec();
for(int j=i+1;j<=n;j++)B[i][j] /= B[i][i];
rep(j,n)
if(i != j)
for(int k=i+1;k<=n;k++)B[j][k] -= B[j][i] * B[i][k];
}
vec x(n);
rep(i,n)x[i] = B[i][n];
return x;
}
int T;
int N,s,t,F;
mat a;
vec b;
//辺の定義。必要に応じて削る。
struct edge{
int from,to,cap,rev;
D cost;
edge(int a=0,int b=0,D c=0,int d=0,int e=0):from(a),to(b),cost(c),cap(d),rev(e){}
};
int v; //グラフの頂点数
vector<edge> G[110]; //グラフの隣接リスト表現
//辺の追加。2つ目の辺の追加はフローアルゴリズムの残余グラフ用。
void AddEdge(int s,int g, D c,int p){
G[s].pb(edge(s,g,c,p,G[g].sz));
G[g].pb(edge(g,s,-c,0,G[s].sz-1));
}
D d[110];
D h[110];
int pv[110],pe[110];
D MinCostFlow(int s,int t,int f){
D res = 0;
fill(h,h+v,0);
while(f>0){
priority_queue<P ,vector<P> ,greater<P> > q;
fill(d,d+v,INF);
d[s] = 0; q.push(P(0,s));
while(q.sz){
P p = q.top();q.pop();
int u = p.second;
if(d[u] > p.first+EPS)continue;
rep(i,G[u].sz){
edge &e = G[u][i];
if(e.cap>0 && d[e.to] > d[u] + e.cost + h[u] - h[e.to] + EPS){
d[e.to] = d[u] + e.cost + h[u] - h[e.to];
pv[e.to] = u; pe[e.to] = i;
q.push(P(d[e.to],e.to));
}
}
}
if(d[t]==INF)return -1;
rep(u,v)h[u] += d[u];
int x = f;
for(int u=t;u!=s;u=pv[u])x = min(x,G[pv[u]][pe[u]].cap);
f-=x;
res += x*h[t];
for(int u=t;u!=s;u=pv[u]){
edge &e = G[pv[u]][pe[u]];
e.cap -= x;
G[u][e.rev].cap += x;
}
}
return res;
}
int M[110];
int to[110][110], f[110][110];
int main(){
cin >> T;
while(T--){
cin >> N >> s >> t >> F;
a.resize(N); b.resize(N);
rep(i,N){
a[i].resize(N);
rep(j,N)cin >> a[i][j];
cin >> b[i];
G[i].clr;
}
vec temp = gauss_jordan(a,b);
rep(i,N){
cin >> M[i];
rep(j,M[i])cin >> to[i][j];
rep(j,M[i])cin >> f[i][j];
rep(j,M[i]){
AddEdge(i,to[i][j],abs(temp[i]-temp[to[i][j]]),f[i][j]);
}
}
v = N;
D ans = MinCostFlow(s,t,F);
if(ans < EPS)cout << "impossible" << endl;
else cout << fixed << setprecision(10) << ans << endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
#include <map>
#include <queue>
#include <functional>
#include <cstdio>
using namespace std;
const double eps = 1e-8;
bool equals(double a, double b) {
return abs(a-b) < eps;
}
typedef vector<double> vec;
typedef vector<vec> mat;
vec gauss_jordan(const mat &A, const vec &b) {
int n = A.size();
mat B(n, vec(n+1));
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
B[i][j] = A[i][j];
}
}
for(int i = 0; i < n; ++i) B[i][n] = b[i];
for(int i = 0; i < n; ++i) {
int pivot = i;
for(int j = i; j < n; ++j) {
if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
}
swap(B[i], B[pivot]);
if(abs(B[i][i]) < eps) return vec();
for(int j = i+1; j <= n; ++j) B[i][j] /= B[i][i];
for(int j = 0; j < n; ++j) {
if(i != j) {
for(int k = i + 1; k <= n; ++k) {
B[j][k] -= B[j][i] * B[i][k];
}
}
}
}
vec x(n);
for(int i = 0; i < n; ++i) {
x[i] = B[i][n];
}
return x;
}
struct Edge {
int to, cap, rev;
double cost;
Edge(int to, int cap, double cost, int rev)
: to(to), cap(cap), cost(cost), rev(rev) {}
};
typedef pair<double, int> P;
const int MAX_N = 101;
const double inf = 1e80;
void addEdge(vector<Edge> G[], int from, int to, int cap, double cost) {
G[from].push_back(Edge(to, cap, cost, G[to].size()));
G[to].push_back(Edge(from, 0, -cost, (int)G[from].size()-1));
}
double min_cost_flow(int N, vector<Edge> G[], int s, int t, int f) {
double res = 0;
vector<double> h(N, 0.0);
vector<int> prevv(N), preve(N);
while(f > 0) {
priority_queue<P, vector<P>, greater<P> > que;
vector<double> dist(N, inf);
dist[s] = 0.0;
que.push(P(0.0, s));
while(!que.empty()) {
P p = que.top(); que.pop();
int v = p.second;
if(dist[v] < p.first) continue;
for(int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
double ndist = dist[v] + max(0.0, e.cost + h[v] - h[e.to]);
if(e.cap > 0 && dist[e.to] > ndist) {
dist[e.to] = ndist;
prevv[e.to] = v;
preve[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if(dist[t] == inf) {
return -1;
}
for(int v = 0; v < N; ++v) h[v] += dist[v];
int d = f;
for(int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for(int v = t; v != s; v = prevv[v]) {
Edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int main() {
int T;
cin >> T;
while(T--) {
int n, s, t, F;
cin >> n >> s >> t >> F;
vector<vector<double> > A(n, vector<double>(n));
vector<double> b(n);
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
cin >> A[i][j];
}
cin >> b[i];
}
vector<double> values = gauss_jordan(A, b);
vector<Edge> G[MAX_N];
for(int i = 0; i < n; ++i) {
int m;
cin >> m;
vector<int> to(m), cap(m);
for(int j = 0; j < m; ++j) cin >> to[j];
for(int j = 0; j < m; ++j) cin >> cap[j];
for(int j = 0; j < m; ++j) {
addEdge(G, i, to[j], cap[j], abs(values[i] - values[to[j]]));
}
}
double ans = min_cost_flow(n, G, s,t,F);
if(ans == -1) printf("impossible\n");
else printf("%.8f\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using Array = vector<double>;
using vec = vector<double>;
using Matrix = vector<Array>;
using mat = vector<Array>;
const double eps = 1e-8;
vec gauss_jordan(const mat&A, const vec&b) {
int n = A.size();
mat B(n, vec(n + 1));
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)B[i][j] = A[i][j];
for(int i = 0; i < n; i++)B[i][n] = b[i];
for(int i = 0; i < n; i++) {
int pivot = i;
for(int j = i; j<n; j++)
if(abs(B[j][i])>abs(B[pivot][i]))pivot = j;
swap(B[i], B[pivot]);
if(abs(B[i][i]) < 0.0000001)return vec();
for(int j = i + 1; j <= n; j++)B[i][j] /= B[i][i];
for(int j = 0; j < n; j++) {
if(i != j)
for(int k = i + 1; k <= n; k++)B[j][k] -= B[j][i] * B[i][k];
}
}
vec x(n);
for(int i = 0; i < n; i++)x[i] = B[i][n];
return x;
}
const int MAX_V = 100010;
typedef int Capacity;
typedef double Cost;
const Cost inf = 1e9;
struct Edge {
int dst;
Capacity cap, cap_orig;
Cost cost;
int revEdge; bool isRev;
Edge(int dst, Capacity cap, Cost cost, int revEdge, bool isRev)
:dst(dst), cap(cap), cap_orig(cap), cost(cost), revEdge(revEdge), isRev(isRev) {
}
};
struct PrimalDual {
int n;
vector<vector<Edge> > g;
vector<int> top;
PrimalDual(int n_) : n(n_), g(vector<vector<Edge> >(n_)) {}
void add_edge(int src, int dst, Capacity cap, Cost cost) { // ?????????
g[src].push_back(Edge{ dst, cap, cost, (int)g[dst].size(), false });
g[dst].push_back(Edge{ src, 0, -cost, (int)g[src].size() - 1, true });
}
Cost solve(int s, int t, int f) {
Cost res = 0;
static Cost h[MAX_V], dist[MAX_V];
static int prevv[MAX_V], preve[MAX_V];
fill(h, h + n, 0);
if(top.size()) {
assert(top.size() == n);
for(int i = 0; i < n; i++) {
int v = top[i];
for(int i = 0; i < g[v].size(); i++) {
Edge& e = g[v][i];
if(e.cap == 0) continue;
int u = e.dst;
h[u] = min(h[u], h[v] + e.cost);
}
}
}
while(f > 0) {
typedef pair<Cost, int> pcv;
priority_queue<pcv, vector<pcv>, greater<pcv> > q;
for(int i = 0; i < n; i++) {
dist[i] = inf;
}
dist[s] = 0;
q.push(pcv(0, s));
while(q.size()) {
pcv p = q.top(); q.pop();
int v = p.second;
if(dist[v] < p.first) continue;
for(int i = 0; i < g[v].size(); i++) {
Edge &e = g[v][i];
if(e.cap > 0 && dist[e.dst] > dist[v] + e.cost + h[v] - h[e.dst] + eps) {
dist[e.dst] = dist[v] + e.cost + h[v] - h[e.dst];
prevv[e.dst] = v;
preve[e.dst] = i;
q.push(pcv(dist[e.dst], e.dst));
}
}
}
if(abs(dist[t] - inf) < eps) {
return -1;
}
for(int v = 0; v < n; v++) {
h[v] += dist[v];
}
// s-t ????????????????????£??????????????????
int d = f;
for(int v = t; v != s; v = prevv[v]) {
d = min(d, g[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for(int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.revEdge].cap += d;
}
}
return res;
}
// ??????????????????=???????????????-?????¨??????????????¨???
void view() {
for(int i = 0; i < g.size(); i++) {
for(int j = 0; j < g[i].size(); j++) {
if(!g[i][j].isRev) {
Edge& e = g[i][j];
printf("%3d->%3d (flow:%d)\n", i, e.dst, e.cap_orig - e.cap);
}
}
}
}
};
int d[1000];
int f[1000];
void solve() {
int N, S, T, F;
cin >> N >> S >> T >> F;
Matrix A(N, Array(N));
Array b(N);
for(int i = 0; i < N; i++) {
for(int j = 0; j < N; j++) {
cin >> A[i][j];
}
cin >> b[i];
}
Array tm = gauss_jordan(A, b);
PrimalDual pd(N);
for(int i = 0; i < N; i++) {
int M;
cin >> M;
for(int j = 0; j < M; j++) {
cin >> d[j];
}
for(int j = 0; j < M; j++) {
cin >> f[j];
}
for(int j = 0; j < M; j++) {
pd.add_edge(i, d[j], f[j], abs(tm[i] - tm[d[j]]));
}
}
Cost res = pd.solve(S, T, F);
if(res == -1) {
cout << "impossible" << endl;
}
else {
cout << fixed << setprecision(15) << res << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
while(T--) solve();
}
|
#include "bits/stdc++.h"
using namespace std;
/* verified AOJ1327 One-Dimensional Cellular Automaton
~Matrix~
??????????°????????¨?????????§??????
vector iostream cmath cassert ??????
Matrix a(VV), b(VV);
?????????:a*b
????????????:l*a
???:a+b
???:a-b
??¢???:a.transport()
?????????:a.cofactor()
?????????:a.det()
a???i???j??????:a.get(i,j)???
a???i??????j?????????k?????£??\:set(i,j,k)
????????????a[i][j] (a[i][j]=k)
a???x???:a.pow(x)
n*n?????¬??????E:Matrix(n)
m*n 0??????:Matrix(m,n)
m*n ??¨????´????p?????????:Matrix(m,n,p)
Row???row??§????????????(m*1??????):Matrix(row)
**(??´??°??????)**
????§????:a.triangulate()
?????????:a.rank()
?????????:a.inverse()
//(????????????a.det()?????????a.pre_inverse()??§?±??????? ??´??°???)
??¬??????????¶???????:a.rowReduction()
//??£???????¬?????¨????????§£??????
***
*/
#include <vector>
#include <iostream>
#include <cmath>
#include <cassert>
using namespace std;
typedef double Elem;
typedef vector<Elem> Row;
typedef vector<Row> VV;
typedef long double ld;
const ld EPS = 1e-11;
const bool isZero(const Elem e) {
return abs(e) < EPS;
}
struct Matrix {
VV matrix;
int n, m;
Matrix(const VV &matrix_);
explicit Matrix(int n_);
explicit Matrix(const Row &row);
Matrix(int m_, int n_);
Matrix(int m_, int n_, Elem e);
const Elem get(const int i, const int j) const;
void set(const int x, const int y, const Elem k);
const Matrix operator + (const Matrix &rhs) const;
const Matrix operator * (const Matrix &rhs) const;
const Matrix operator - (const Matrix &rhs) const;
Matrix &operator += (const Matrix &rhs);
Matrix &operator *= (const Matrix &rhs);
Matrix &operator -= (const Matrix &rhs);
Row &operator[](const int x);
const Matrix transport() const;
const Matrix pow(int x) const;
const Matrix cofactor(int x, int y) const;
const Elem det() const;
const Matrix triangulate() const;
const int rank() const;
//?????????????????¨????????°???(?????????)*(?????????)?????????
//A:matrix,return det A * A^-1
const Matrix pre_inverse() const;
const Matrix inverse() const;
const Matrix rowReduction() const;
};
const Matrix operator * (const Elem lambda, const Matrix &rhs) {
Matrix tmp(rhs);
for (int i = 0; i < rhs.m; i++)
for (int j = 0; j < rhs.n; j++)
tmp.set(i, j, tmp.get(i, j) * lambda);
return tmp;
}
Matrix::Matrix(const VV &matrix_) : matrix(matrix_) {
m = matrix_.size();
if (m == 0) n = 0;
else n = matrix_[0].size();
}
Matrix::Matrix(int n_) : m(n_), n(n_) {
matrix = VV(n, Row(n, 0));
for (int i = 0; i < n; ++i)
set(i, i, 1);
}
Matrix::Matrix(const Row &row) : m(1), n(row.size()), matrix(VV(1, row)) {
//size???m???vector<Elem>??????mx1???????????????
(*this) = transport();
}
Matrix::Matrix(int m_, int n_) : m(m_), n(n_) {
matrix = VV(m, Row(n, 0));
}
Matrix::Matrix(int m_, int n_, Elem e) : m(m_), n(n_) {
matrix = VV(m, Row(n, e));
}
const Elem Matrix::get(const int i, const int j) const {
if (0 <= i && i < m && 0 <= j && j < n)
return matrix[i][j];
cerr << "get(" << i << "," << j << ")is not exist." << endl;
throw;
}
void Matrix::set(const int i, const int j, const Elem k) {
if (0 <= i && i < m && 0 <= j && j < n) {
*(matrix[i].begin() + j) = k;
return;
}
cerr << "set(" << i << "," << j << ")is not exist." << endl;
throw;
}
const Matrix Matrix::operator + (const Matrix &rhs) const {
assert(m == rhs.m && n == rhs.n);
Matrix tmp(m, n, 0);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
tmp.set(i, j, get(i, j) + rhs.get(i, j));
}
}
return tmp;
}
const Matrix Matrix::operator * (const Matrix &rhs) const {
assert(n == rhs.m);
Matrix tmp(m, rhs.n, 0);
Elem sum;
for (int i = 0; i < m; i++)
for (int j = 0; j < rhs.n; j++) {
sum = 0;
for (int k = 0; k < n; k++) {
sum += get(i, k) * rhs.get(k, j);
}
tmp.set(i, j, sum);
}
return tmp;
}
const Matrix Matrix::operator - (const Matrix &rhs) const {
return *this + ((Elem)-1 * rhs);
}
Matrix &Matrix::operator += (const Matrix &rhs) {
return *this = *this + rhs;
}
Matrix &Matrix::operator *= (const Matrix &rhs) {
return *this = *this * rhs;;
}
Matrix &Matrix::operator -= (const Matrix &rhs) {
return *this = *this - rhs;
}
Row &Matrix::operator[](const int x) {
return matrix[x];
}
const Matrix Matrix::transport() const {
VV tmp;
for (int i = 0; i < n; i++) {
Row row;
for (int j = 0; j < m; j++)
row.push_back(get(j, i));
tmp.push_back(row);
}
return tmp;
}
const Matrix Matrix::pow(int x) const {
Matrix tmp(*this), e(m);
for (int i = 1; i <= x; i <<= 1) {
if ((x & i) > 0)
e = e * tmp;
tmp = tmp * tmp;
}
return e;
}
const Matrix Matrix::cofactor(int x, int y) const {
VV tmp;
for (int i = 0; i < m; i++) {
if (x == i) continue;
Row row;
for (int j = 0; j < n; j++) {
if (y == j) continue;
row.push_back(get(i, j));
}
tmp.push_back(row);
}
return Matrix(tmp);
}
const Elem Matrix::det() const {
assert(n == m);
Matrix tri = triangulate();
Elem ans = 1;
for (int i = 0; i < n; ++i) {
ans *= tri[i][i];
}
return ans;
if (m == 1)
return get(0, 0);
Elem sum = 0;
for (int i = 0; i < m; i++) {
sum += ((i % 2 == 0 ? 1 : -1) * get(i, 0)) * Matrix(cofactor(i, 0)).det();
}
return sum;
}
const Matrix Matrix::triangulate() const {
Matrix tmp(*this);
Elem e;
int p = 0;
for (int i = 0; i < m && p < n; i++, p++) {
if (isZero(tmp.get(i, p))) {
tmp.set(i, p, 0);
bool flag = true;
for (int j = i + 1; j < m; j++)
if (!isZero(tmp.get(j, p))) {
for (int k = 0; k < n; k++)
tmp.set(i, k, tmp.get(i, k) + tmp.get(j, k));
//tmp[i].swap(tmp[j]);
flag = false;
break;
}
if (flag) {
i--;
continue;
}
}
for (int j = i + 1; j < m; j++) {
e = tmp.get(j, p) / tmp.get(i, p);
for (int k = 0; k < n; k++)
tmp.set(j, k, tmp.get(j, k) - tmp.get(i, k) * e);
}
}
return tmp;
}
const int Matrix::rank() const {
Matrix tmp(triangulate());
for (int i = min(tmp.m - 1, tmp.n - 1); i >= 0; i--) {
for (int j = tmp.n - 1; j >= i; j--)
if (isZero(tmp.get(i, j)))
continue;
else
return i + 1;
}
return 0;
}
const Matrix Matrix::pre_inverse() const {
assert(m == n);
Matrix tmp(m, n, 0);
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
tmp.set(i, j, ((i + j) % 2 == 0 ? 1 : -1)*cofactor(i, j).det());
return tmp.transport();
}
/*O(n!)????£?
const Matrix Matrix::inverse() const {
Matrix tmp(pre_inverse());
Elem e = det();
assert(!isZero(e));
tmp = 1 / e * tmp;
return tmp.transport();
}*/
const Matrix Matrix::inverse() const {
assert(m == n);
Matrix tmp(m, n * 2), tmp2(m, n);
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
tmp.set(i, j, get(i, j));
for (int i = 0; i < m; i++)
tmp.set(i, i + n, 1);
tmp = tmp.rowReduction();
//?????????????????¨??????????????????????????§??????
for (int i = 0; i < m; i++)
assert(isZero(tmp.get(i, i) - 1));
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
tmp2.set(i, j, tmp.get(i, j + n));
return tmp2;
}
/*
a b c j
d e f k
g h i l
ax+by+cz=j;
dx+ey+fz=k;
gx+hy+iz=l;
|
V
1 0 0 x
0 1 0 y
0 0 1 z
???????????????
*/
const Matrix Matrix::rowReduction() const {
Matrix tmp(*this);
Elem e;
int p = 0;
for (int i = 0; i < m && p < n; i++, p++) {
if (isZero(tmp.get(i, p))) {
tmp.set(i, p, 0);
bool flag = true;
for (int j = i + 1; j < m; j++)
if (!isZero(tmp.get(j, p))) {
for (int k = 0; k < n; k++)
tmp.set(i, k, tmp.get(i, k) + tmp.get(j, k));
//tmp[i].swap(tmp[j]);
flag = false;
break;
}
if (flag) {
i--;
continue;
}
}
e = 1 / tmp.get(i, p);
tmp.set(i, p, 1);
for (int k = i + 1; k < n; k++)
tmp.set(i, k, tmp.get(i, k)*e);
for (int j = 0; j < m; j++) {
if (i == j) continue;
e = tmp.get(j, p);
for (int k = 0; k < n; k++)
tmp.set(j, k, tmp.get(j, k) - tmp.get(i, k) * e);
}
}
return tmp;
}
typedef ld Weight;
struct Edge {
int src, dest;
int cap, rev;
Weight weight;
bool operator < (const Edge &rhs) const { return weight > rhs.weight; }
};
const int V = 4000;
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
Weight h[V]; //??????????????£???
Weight dist[V]; //???????????¢
int prevv[V], preve[V]; //??´???????????¨??????
void add_edge(Graph &g, int src, int dest, int cap, Weight weight) {
g[src].push_back(Edge{ src, dest, cap, (int)g[dest].size(), weight });
g[dest].push_back(Edge{ dest, src, 0, (int)g[src].size() - 1, -weight });
}
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(auto i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const Weight INF = 2147483647;
const Weight eps = 1e-9;
//????????????double?????????eps?????????
Weight min_cost_flow(Graph &g, int s, int t, int f) {
Weight res = 0;
memset(h, 0, sizeof(h));
typedef pair<Weight, int> P;
while (f > 0) {
priority_queue<P, vector<P>, greater<P> > que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top(); que.pop();
const int v = p.second;
if (dist[v] < p.first) continue;
REP(i, g[v].size()) {
Edge &e = g[v][i];
if (e.cap > 0 && dist[e.dest] > dist[v] + e.weight + h[v] - h[e.dest] + eps) {
dist[e.dest] = dist[v] + e.weight + h[v] - h[e.dest];
prevv[e.dest] = v;
preve[e.dest] = i;
que.push(P(dist[e.dest], e.dest));
}
}
}
if (dist[t] == INF) return -1;
REP(v, V) h[v] = h[v] + dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v]) d = min(d, g[prevv[v]][preve[v]].cap);
f -= d;
res = res + d * h[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
int main() {
int T; cin >> T;
while (T--) {
int N, S, T, F; cin >> N >> S >> T >> F;
vector<ld>ts;
{
Matrix mat(N, N + 1);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N + 1; ++j) {
int a; cin >> a;
mat[i][j] = a;
}
}
mat = mat.rowReduction();
for (int i = 0; i < N; ++i) {
ts.push_back(mat[i][N]);
}
}
Graph g(N);
for (int i = 0; i < N; ++i) {
int M; cin >> M;
vector<int>ds, fs;
for (int j = 0; j < M; ++j) {
int d; cin >> d; ds.push_back(d);
}
for (int j = 0; j < M; ++j) {
int f; cin >> f; fs.push_back(f);
}
for (int j = 0; j < M; ++j) {
add_edge(g, i, ds[j], fs[j], abs(ts[i] - ts[ds[j]]));
}
}
ld ans = min_cost_flow(g, S, T, F);
if (ans < 0)cout << "impossible" << endl;
else
{
cout << setprecision(10) << fixed << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MAX_V 300
#define INF 1e9
const double EPS = 1e-8;
typedef vector<double> vec;
typedef vector<vec> mat;
typedef pair<double, int> P;
struct edge {
int to, cap, rev;
double cost;
edge(int to, int cap, int rev, double cost) :
to(to), cap(cap), rev(rev), cost(cost) {}
};
int V;
vector<edge> G[MAX_V];
double dist[MAX_V], h[MAX_V];;
int prevv[MAX_V], preve[MAX_V];
void add_edge(int from, int to, int cap, double cost){
G[from].push_back(edge(to, cap, G[to].size(), cost));
G[to].push_back(edge(from, 0, G[from].size()-1, -cost));
}
double min_cost_flow(int s, int t, int f)
{
double res = 0;
fill(h, h+V, 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> Q;
fill(dist, dist+V, INF);
dist[s] = 0;
Q.push(P(0, s));
while (!Q.empty()) {
P p = Q.top(); Q.pop();
int v = p.second;
if (dist[v] < p.first) continue;
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to] + EPS) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
Q.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == INF) {
return -1;
}
for (int v = 0; v < V; v++) {
h[v] += dist[v];
}
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d*h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
vec gauss_jordan(const mat &A, const vec &b)
{
int n = A.size();
mat B(n, vec(n+1));
for (int i = 0; i < n; i++){
for(int j = 0 ; j < n ; j++) {
B[i][j] = A[i][j];
}
}
for (int i = 0; i < n; i++) {
B[i][n] = b[i];
}
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i ; j < n ; j++) {
if (abs(B[j][i]) > abs(B[pivot][i])) {
pivot = j;
}
}
swap(B[i],B[pivot]);
if (abs(B[i][i]) < EPS) return vec();
for (int j = i+1; j <= n; j++) {
B[i][j] /= B[i][i];
}
for (int j = 0; j < n; j++) {
if (i != j) {
for (int k = i+1; k <= n; k++) {
B[j][k] -= B[j][i]*B[i][k];
}
}
}
}
vec x(n);
for (int i = 0; i < n; i++) {
x[i] = B[i][n];
}
return x;
}
void init()
{
for (int i = 0; i < MAX_V; i++) {
G[i].clear();
}
}
int main()
{
int Tc;
scanf("%d", &Tc);
while (Tc--) {
int N, s, t, F;
init();
scanf("%d %d %d %d", &N, &s, &t, &F);
mat a(N, vec(N)); vec c(N);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
scanf("%lf", &a[i][j]);
}
scanf("%lf", &c[i]);
}
vec res = gauss_jordan(a, c);
for (int i = 0; i < N; i++) {
int M, d[N], f;
scanf("%d", &M);
for (int j = 0; j < M; j++) {
scanf("%d", &d[j]);
}
for (int j = 0; j < M; j++) {
scanf("%d", &f);
add_edge(i, d[j], f, abs(res[i]-res[d[j]]));
}
}
V = N;
double ans = min_cost_flow(s, t, F);
if (ans == -1) {
printf("impossible\n");
} else {
printf("%.6f\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;
bool GaussJordan(const vvd& _a,const vd& b,vd& x)
{
int n=_a.size();
vvd a(n,vd(n+1));
rep(i,n){
copy(all(_a[i]),begin(a[i]));
a[i][n]=b[i];
}
rep(i,n){
int p=i;
repi(j,i+1,n) if(abs(a[p][i])<abs(a[j][i])) p=j;
if(abs(a[p][i])<EPS) return false;
swap(a[i],a[p]);
peri(j,i,n+1) a[i][j]/=a[i][i];
rep(j,n) if(j!=i) peri(k,i,n+1) a[j][k]-=a[j][i]*a[i][k];
}
rep(i,n) x[i]=a[i][n];
return true;
}
struct Edge{
int src,dst;
double cost;
int cap,flow;
Edge(){}
Edge(int s,int d,double co,int ca=0,int f=0):src(s),dst(d),cost(co),cap(ca),flow(f){}
};
bool operator<(const Edge& a,const Edge& b){return a.cost<b.cost;}
bool operator>(const Edge& a,const Edge& b){return a.cost>b.cost;}
struct Graph{
vector<Edge> es;
vi head,next;
Graph(){}
Graph(int n):head(n,-1){}
// コスト:-co,容量:0の逆辺も追加する
void AddEdge(int u,int v,double co,int ca){
es.emplace_back(u,v,co,ca); next.push_back(head[u]); head[u]=es.size()-1;
es.emplace_back(v,u,-co,0); next.push_back(head[v]); head[v]=es.size()-1;
}
};
double MinCostFlow(Graph& g,int tap,int sink,int flow)
{
int n=g.head.size();
double res=0;
vd pots(n);
while(flow>EPS){
vd cost(n,INF);
vi prev(n,-1);
priority_queue<Edge,vector<Edge>,greater<Edge>> pq;
pq.emplace(-1,tap,0);
while(pq.size()){
Edge cur=pq.top(); pq.pop();
if(cur.cost>cost[cur.dst]-EPS) continue;
cost[cur.dst]=cur.cost;
prev[cur.dst]=cur.src;
for(int i=g.head[cur.dst];i!=-1;i=g.next[i]){
Edge e=g.es[i];
if(e.cap-e.flow==0) continue;
pq.emplace(i,e.dst,cost[e.src]+e.cost+pots[e.src]-pots[e.dst]);
}
}
if(cost[sink]==INF) return -1;
rep(i,n) pots[i]+=cost[i];
int augment=flow;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
Edge e=g.es[prev[v]];
augment=min(augment,e.cap-e.flow);
}
if(augment<EPS) return -1;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
int i=prev[v];
g.es[i].flow+=augment;
g.es[i^1].flow-=augment;
}
flow-=augment;
res+=augment*pots[sink];
}
return res;
}
void solve()
{
int n,s,t,f; scanf("%d%d%d%d",&n,&s,&t,&f);
vd cs(n);
{
vvd a(n,vd(n));
vd b(n);
rep(i,n){
rep(j,n) scanf("%lf",&a[i][j]);
scanf("%lf",&b[i]);
}
GaussJordan(a,b,cs);
}
Graph g(n);
rep(i,n){
int m; scanf("%d",&m);
vi ds(m),fs(m);
rep(j,m) scanf("%d",&ds[j]);
rep(j,m) scanf("%d",&fs[j]);
rep(j,m) g.AddEdge(i,ds[j],abs(cs[ds[j]]-cs[i]),fs[j]);
}
double res=MinCostFlow(g,s,t,f);
if(res==-1)
puts("impossible");
else
printf("%.10f\n",res);
}
int main()
{
int tc; scanf("%d",&tc);
rep(_,tc) solve();
}
|
#include<algorithm>
#include<cassert>
#include<cctype>
#include<climits>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<iomanip>
#include<map>
#include<numeric>
#include<queue>
#include<vector>
#include<set>
#include<string>
#include<stack>
#include<sstream>
#include<complex>
#define pb push_back
#define clr clear()
#define sz size()
#define fs first
#define sc second
#define rep(i,a) for(int i=0;i<(int)(a);i++)
#define rrep(i,a) for(int i=(int)(a)−1;i>=0;i−−)
#define all(a) (a).begin(),(a).end()
#define EQ(a,b) (abs((a)−(b)) < EPS)
#define INIT(a) memset(a,0,sizeof(a))
using namespace std;
typedef long double D;
typedef pair<D,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
const D EPS = 1e-7;
const D INF = 1e10;
const D PI = acos(-1);
typedef vector<D> vec;
typedef vector<vec> mat;
struct matrix{
mat m;
int r,c;
matrix(void){r=c=0;m.clr;}
matrix(mat a){
r = a.sz; c = a[0].sz;
m.resize(r);
rep(i,r)m[i].resize(c);
rep(i,r)rep(j,c)m[i][j] = a[i][j];
}
matrix operator+(matrix a){
if(r==a.r && c==a.c){
rep(i,r)rep(j,c)a.m[i][j] += m[i][j];
}
return a;
}
matrix operator-(matrix a){
rep(i,a.r)rep(j,a.c)a.m[i][j] *= -1;
return *this+a;
}
matrix operator*(matrix a){
matrix x;
if(c==a.r){
x.r = r; x.c = a.c;
x.m.resize(r);
rep(i,r)x.m[i].resize(a.c);
rep(i,r)rep(j,a.c){
x.m[i][j] = 0;
rep(k,c)x.m[i][j] += m[i][k] * a.m[k][j];
}
}
return x;
}
};
vec gauss_jordan(const mat& A, const vec& b){
int n = A.size();
mat B(n,vec(n+1));
rep(i,n)rep(j,n)B[i][j] = A[i][j];
rep(i,n)B[i][n] = b[i];
rep(i,n){
int p=i;
for(int j=i;j<n;j++)
if(abs(B[j][i]) > abs(B[p][i]))p = j;
swap(B[i],B[p]);
//解がないか、一意でない
if(abs(B[i][i]) < EPS)return vec();
for(int j=i+1;j<=n;j++)B[i][j] /= B[i][i];
rep(j,n)
if(i != j)
for(int k=i+1;k<=n;k++)B[j][k] -= B[j][i] * B[i][k];
}
vec x(n);
rep(i,n)x[i] = B[i][n];
return x;
}
int T;
int N,s,t,F;
mat a;
vec b;
//辺の定義。必要に応じて削る。
struct edge{
int from,to,cap,rev;
D cost;
edge(int a=0,int b=0,D c=0,int d=0,int e=0):from(a),to(b),cost(c),cap(d),rev(e){}
};
int v; //グラフの頂点数
vector<edge> G[110]; //グラフの隣接リスト表現
//辺の追加。2つ目の辺の追加はフローアルゴリズムの残余グラフ用。
void AddEdge(int s,int g, D c,int p){
G[s].pb(edge(s,g,c,p,G[g].sz));
G[g].pb(edge(g,s,-c,0,G[s].sz-1));
}
D d[110];
D h[110];
int pv[110],pe[110];
D MinCostFlow(int s,int t,int f){
D res = 0;
fill(h,h+v,0);
while(f>0){
priority_queue<P ,vector<P> ,greater<P> > q;
fill(d,d+v,INF);
d[s] = 0; q.push(P(0,s));
while(q.sz){
P p = q.top();q.pop();
int u = p.second;
if(d[u] > p.first+EPS)continue;
rep(i,G[u].sz){
edge &e = G[u][i];
if(e.cap>0 && d[e.to] > d[u] + e.cost + h[u] - h[e.to] + EPS){
d[e.to] = d[u] + e.cost + h[u] - h[e.to];
pv[e.to] = u; pe[e.to] = i;
q.push(P(d[e.to],e.to));
}
}
}
if(d[t]==INF)return -1;
rep(u,v)h[u] += d[u];
int x = f;
for(int u=t;u!=s;u=pv[u])x = min(x,G[pv[u]][pe[u]].cap);
f-=x;
res += x*h[t];
for(int u=t;u!=s;u=pv[u]){
edge &e = G[pv[u]][pe[u]];
e.cap -= x;
G[u][e.rev].cap += x;
}
}
return res;
}
int M[110];
int to[110][110], f[110][110];
int main(){
cin >> T;
while(T--){
cin >> N >> s >> t >> F;
a.resize(N); b.resize(N);
rep(i,N){
a[i].resize(N);
rep(j,N)cin >> a[i][j];
cin >> b[i];
G[i].clr;
}
vec temp = gauss_jordan(a,b);
rep(i,N){
cin >> M[i];
rep(j,M[i])cin >> to[i][j];
rep(j,M[i])cin >> f[i][j];
rep(j,M[i]){
AddEdge(i,to[i][j],abs(temp[i]-temp[to[i][j]]),f[i][j]);
}
}
v = N;
D ans = MinCostFlow(s,t,F);
if(ans < EPS)cout << "impossible" << endl;
else cout << fixed << setprecision(10) << ans << endl;
}
}
|
#include<algorithm>
#include<cassert>
#include<cctype>
#include<climits>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<iomanip>
#include<map>
#include<numeric>
#include<queue>
#include<vector>
#include<set>
#include<string>
#include<stack>
#include<sstream>
#include<complex>
#define pb push_back
#define clr clear()
#define sz size()
#define fs first
#define sc second
#define rep(i,a) for(int i=0;i<(int)(a);i++)
#define rrep(i,a) for(int i=(int)(a)−1;i>=0;i−−)
#define all(a) (a).begin(),(a).end()
#define EQ(a,b) (abs((a)−(b)) < EPS)
#define INIT(a) memset(a,0,sizeof(a))
using namespace std;
typedef long double D;
typedef pair<int,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
const D EPS = 1e-7;
const D INF = 1e10;
const D PI = acos(-1);
typedef vector<D> vec;
typedef vector<vec> mat;
struct matrix{
mat m;
int r,c;
matrix(void){r=c=0;m.clr;}
matrix(mat a){
r = a.sz; c = a[0].sz;
m.resize(r);
rep(i,r)m[i].resize(c);
rep(i,r)rep(j,c)m[i][j] = a[i][j];
}
matrix operator+(matrix a){
if(r==a.r && c==a.c){
rep(i,r)rep(j,c)a.m[i][j] += m[i][j];
}
return a;
}
matrix operator-(matrix a){
rep(i,a.r)rep(j,a.c)a.m[i][j] *= -1;
return *this+a;
}
matrix operator*(matrix a){
matrix x;
if(c==a.r){
x.r = r; x.c = a.c;
x.m.resize(r);
rep(i,r)x.m[i].resize(a.c);
rep(i,r)rep(j,a.c){
x.m[i][j] = 0;
rep(k,c)x.m[i][j] += m[i][k] * a.m[k][j];
}
}
return x;
}
};
vec gauss_jordan(const mat& A, const vec& b){
int n = A.size();
mat B(n,vec(n+1));
rep(i,n)rep(j,n)B[i][j] = A[i][j];
rep(i,n)B[i][n] = b[i];
rep(i,n){
int p=i;
for(int j=i;j<n;j++)
if(abs(B[j][i]) > abs(B[p][i]))p = j;
swap(B[i],B[p]);
//解がないか、一意でない
if(abs(B[i][i]) < EPS)return vec();
for(int j=i+1;j<=n;j++)B[i][j] /= B[i][i];
rep(j,n)
if(i != j)
for(int k=i+1;k<=n;k++)B[j][k] -= B[j][i] * B[i][k];
}
vec x(n);
rep(i,n)x[i] = B[i][n];
return x;
}
int T;
int N,s,t,F;
mat a;
vec b;
//辺の定義。必要に応じて削る。
struct edge{
int from,to,cap,rev;
D cost;
edge(int a=0,int b=0,D c=0,int d=0,int e=0):from(a),to(b),cost(c),cap(d),rev(e){}
};
int v; //グラフの頂点数
vector<edge> G[110]; //グラフの隣接リスト表現
//辺の追加。2つ目の辺の追加はフローアルゴリズムの残余グラフ用。
void AddEdge(int s,int g, D c,int p){
G[s].pb(edge(s,g,c,p,G[g].sz));
G[g].pb(edge(g,s,-c,0,G[s].sz-1));
}
D d[110];
int pv[110],pe[110]; //直前の頂点と辺
D primal_dual(int s,int t, int f){
D res = 0;
while(f>0){
/*
rep(i,v){
cout << "-----" << i << "-----" << endl;
rep(j,G[i].sz){
cout << G[i][j].to << " " << G[i][j].cost << " " << G[i][j].cap << endl;
}
}
*/
fill(d,d+v,INF);
d[s] = 0;
bool update = true;
while(update){
update = false;
rep(u,v){
if(d[u]==INF)continue;
rep(i,G[u].sz){
edge &e = G[u][i];
if(e.cap > 0 && d[e.to] > d[u] + e.cost + EPS){
d[e.to] = d[u] + e.cost;
pv[e.to] = u; pe[e.to] = i;
update = true;
}
}
}
}
if(d[t] == INF)return -1;
int x=f;
for(int u=t;u!=s;u=pv[u]){
x = min(x,G[pv[u]][pe[u]].cap);
}
f-=x;
res += x*d[t];
for(int u=t;u!=s;u=pv[u]){
edge &e = G[pv[u]][pe[u]];
e.cap -= x;
G[u][e.rev].cap += x;
}
}
return res;
}
int M[110];
int to[110][110], f[110][110];
int main(){
cin >> T;
while(T--){
cin >> N >> s >> t >> F;
a.resize(N); b.resize(N);
rep(i,N){
a[i].resize(N);
rep(j,N)cin >> a[i][j];
cin >> b[i];
G[i].clr;
}
vec temp = gauss_jordan(a,b);
//rep(i,N)cout << temp[i] << " "; cout << endl;
rep(i,N){
cin >> M[i];
rep(j,M[i])cin >> to[i][j];
rep(j,M[i])cin >> f[i][j];
rep(j,M[i]){
AddEdge(i,to[i][j],abs(temp[i]-temp[to[i][j]]),f[i][j]);
}
}
v = N;
D ans = primal_dual(s,t,F);
if(ans < EPS)cout << "impossible" << endl;
else cout << fixed << setprecision(10) << ans << endl;
}
}
|
#include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
#define int long long
#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 (b < a) { a = b; return true; } return false; }
#define EPS 1e-8
struct MinimumCostFlow {
using Flow = int;
using Cost = double;
const Cost kInfCost = INF;
struct Edge {
int to, rev;
Flow cap;
Cost cost;
Edge() {}
Edge(int to, int rev, Flow cap, Cost cost) :to(to), rev(rev), cap(cap), cost(cost) {}
};
int n;
vector<vector<Edge>> g;
vector<Cost> dist;
vector<int> prevv, preve;
MinimumCostFlow(int n) :n(n), g(n), dist(n), prevv(n), preve(n) {}
void addArc(int from, int to, Flow cap, Cost cost) {
g[from].emplace_back(to, (int)g[to].size(), cap, cost);
g[to].emplace_back(from, (int)g[from].size() - 1, Flow(), -cost);
}
// s??????t????????????f???????°??????¨???
// ??????????????´?????? kInfCost
Cost minimumCostFlow(int s, int t, Flow f) {
Cost total = Cost();
while (f > 0) {
// Bellman-Ford
fill(dist.begin(), dist.end(), kInfCost);
dist[s] = 0;
bool update = true;
while (update) {
update = false;
for (int v = 0; v < n; v++) {
if (dist[v] == kInfCost)continue;
for (int i = 0; i < g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap > Flow() && dist[e.to] > EPS + dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
prevv[e.to] = v;
preve[e.to] = i;
update = true;
}
}
}
}
// ????????\???????????????
if (dist[t] == kInfCost)
return kInfCost;
// ?????????????????£??????????????????
Flow d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, g[prevv[v]][preve[v]].cap);
f -= d;
total += dist[t] * d;
for (int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return total;
}
};
// ??¬??????????¶???????, Gauss elimination
// O(n^3)
// ???????¶????, forward elimination
// ????????£??\, back substitution
using Num = double;
using Vec = vector<Num>;
using Mat = vector<Vec>;
Vec gaussianElimination(Mat A, Vec b) {
const int n = A.size(), m = A[0].size();
int pi = 0, pj = 0;
while (pi < n && pj < m) {
for (int i = pi + 1; i < n; i++)
if (abs(A[i][pj]) > abs(A[pi][pj]))
A[i].swap(A[pi]), swap(b[i], b[pi]);
if (abs(A[pi][pj]) > 0) {
Num d = A[pi][pj];
for (int j = 0; j < m; j++)
A[pi][j] /= d;
b[pi] /= d;
for (int i = pi + 1; i < n; i++) {
Num k = A[i][pj];
for (int j = 0; j < m; j++)
A[i][j] -= k * A[pi][j];
b[i] -= k * b[pi];
}
pi++;
}
pj++;
}
for (int i = pi; i < n; i++)
if (abs(b[i]) > 0)
return Vec();
if (pi < m || pj < m)
return Vec();
for (int j = m - 1; j >= 0; j--)
for (int i = 0; i < j; i++)
b[i] -= b[j] * A[i][j];
return b;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T; cin >> T;
cout << fixed << setprecision(10);
while (T--) {
int N, s, t, F; cin >> N >> s >> t >> F;
MinimumCostFlow mcf(N);
Mat a(N, Vec(N));
Vec c(N);
rep(i, 0, N) rep(j, 0, N + 1) {
if (j == N)cin >> c[i];
else cin >> a[i][j];
}
Vec x = gaussianElimination(a, c);
dump(x);
rep(i, 0, N) {
int M; cin >> M;
vector<int> d(M); rep(j, 0, M) {
cin >> d[j];
}
vector<int> f(M); rep(j, 0, M) {
cin >> f[j];
}
rep(j, 0, M) {
mcf.addArc(i, d[j], f[j], abs(x[i] - x[d[j]]));
}
}
auto res = mcf.minimumCostFlow(s, t, F);
if (res == INF)
cout << "impossible" << endl;
else
cout << res << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
//#define EPS 0.000000001
using namespace std;
#define EPS 0.0000001
typedef vector<double> VEC;
typedef vector<VEC> MATRIX;
typedef pair<double,int> P; //firstは最短距離、secondは頂点の番号
#define NUM 105
//辺を表す構造体{行先、容量、コスト、逆辺のインデックス}
struct Edge{
Edge(int arg_to,int arg_capacity,double arg_cost,int arg_rev_index){
to = arg_to;
capacity = arg_capacity;
cost = arg_cost;
rev_index = arg_rev_index;
}
int to,capacity,rev_index;
double cost;
};
int V; //頂点数
int H,W;
vector<Edge> G[NUM]; //グラフの隣接リスト表現
double h[NUM]; //ポテンシャル
double dist[NUM]; //最短距離
int pre_node[NUM],pre_edge[NUM]; //直前の頂点と辺
int adj[NUM];
void add_edge(int from,int to,int capacity,double cost){
G[from].push_back(Edge(to,capacity,cost,G[to].size()));
G[to].push_back(Edge(from,0,-cost,G[from].size()-1));
}
//流せない場合は-1を返す
double min_cost_flow(int source,int sink,int flow){
double ret = 0;
for(int i = 0; i < V; i++)h[i] = 0;
while(flow > 0){
//ダイクストラ法を用いてhを更新する
priority_queue<P,vector<P>,greater<P>> Q;
for(int i = 0; i < V; i++)dist[i] = BIG_NUM;
dist[source] = 0;
Q.push(P(0,source));
while(!Q.empty()){
P p = Q.top();
Q.pop();
int node_id = p.second;
if(dist[node_id]+0.00001 < p.first)continue; //最短でなければSKIP
for(int i = 0; i < G[node_id].size(); i++){
Edge &e = G[node_id][i];
if(e.capacity > 0 && dist[e.to] > 0.00001+dist[node_id]+e.cost+h[node_id]-h[e.to]){
dist[e.to] = dist[node_id]+e.cost+h[node_id]-h[e.to];
pre_node[e.to] = node_id;
pre_edge[e.to] = i;
Q.push(P(dist[e.to],e.to));
}
}
}
if(fabs(dist[sink]-BIG_NUM) < 0.00001){
//これ以上流せない
return -1;
}
for(int node_id = 0; node_id < V; node_id++)h[node_id] += dist[node_id];
//source-sink間最短路に沿って目いっぱい流す
int tmp_flow = flow;
for(int node_id = sink; node_id != source; node_id = pre_node[node_id]){
tmp_flow = min(tmp_flow,G[pre_node[node_id]][pre_edge[node_id]].capacity);
}
flow -= tmp_flow;
ret += tmp_flow*h[sink];
for(int node_id = sink; node_id != source; node_id = pre_node[node_id]){
Edge &e = G[pre_node[node_id]][pre_edge[node_id]];
e.capacity -= tmp_flow;
G[node_id][e.rev_index].capacity += tmp_flow;
}
}
return ret;
}
MATRIX gauss_jordan(MATRIX A){
MATRIX C(H,VEC(W+1));
for(int row = 0; row < H; row++){
for(int col = 0; col <= W; col++){
C[row][col] = A[row][col];
}
}
int base_row;
double tmp;
for(int i = 0; i < H; i++){
base_row = i;
for(int row = i+1; row < W; row++){
if(fabs(C[row][i]) > fabs(C[base_row][i])){
base_row = row;
}
}
if(fabs(C[base_row][i]) < EPS)continue; //操作不要
if(base_row != i)swap(C[base_row],C[i]);
tmp = C[i][i]; //係数
for(int col = 0; col <= W; col++){ //基準行の係数を1にする
C[i][col] /= tmp;
}
for(int row = 0; row < H; row++){
if(row == i || fabs(C[row][i]) < EPS)continue; //基準行、または該当列が0ならSKIP
tmp = C[row][i];
for(int col = i; col <= W; col++){
C[row][col] -= C[i][col]*tmp;
}
}
}
return C;
}
void func(){
for(int i = 0; i < NUM; i++){
G[i].clear();
}
int source,sink,FLOW;
scanf("%d %d %d %d",&V,&source,&sink,&FLOW);
H = V;
W = V;
MATRIX A(H,VEC(W+1));
for(int row = 0; row < H; row++){
for(int col = 0; col <= W; col++){
scanf("%lf",&A[row][col]);
}
}
//気温を計算
A = gauss_jordan(A);
int num_edge,tmp_capacity;
for(int loop = 0; loop < V; loop++){
scanf("%d",&num_edge);
for(int i = 0; i < num_edge; i++){
scanf("%d",&adj[i]);
}
for(int i = 0; i < num_edge; i++){
scanf("%d",&tmp_capacity);
add_edge(loop,adj[i],tmp_capacity,fabs(A[loop][W]-A[adj[i]][W]));
}
}
double ans = min_cost_flow(source,sink,FLOW);
if(fabs(ans+1.0) < EPS){
printf("impossible\n");
}else{
printf("%.10lf\n",ans);
}
}
int main(){
int num_case;
scanf("%d",&num_case);
for(int loop = 0; loop < num_case; loop++){
func();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MAX_V 300
#define INF 1e9
const double EPS = 1e-8;
typedef vector<double> vec;
typedef vector<vec> mat;
typedef pair<double,int> P;
struct edge{
int to,cap,rev;
double cost;
edge(int to,int cap,int rev,double cost) :
to(to),cap(cap),rev(rev),cost(cost) {}
};
int V;
vector<edge> G[MAX_V];
double dist[MAX_V],h[MAX_V];;
int prevv[MAX_V],preve[MAX_V];
void add_edge(int from,int to,int cap,double cost){
G[from].push_back(edge(to,cap,G[to].size(),cost));
G[to].push_back(edge(from,0,G[from].size()-1,-cost));
}
double min_cost_flow(int s,int t,int f){
double res = 0;
fill(h,h+V,0);
while(f > 0){
priority_queue<P,vector<P>,greater<P> > Q;
fill(dist,dist+V,INF);
dist[s] = 0;
Q.push(P(0,s));
while(!Q.empty()){
P p = Q.top(); Q.pop();
int v = p.second;
if(dist[v] < p.first) continue;
for(int i = 0 ; i < (int)G[v].size() ; i++){
edge &e = G[v][i];
if(e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to] + EPS){
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
Q.push(P(dist[e.to],e.to));
}
}
}
if(dist[t] == INF){
return -1;
}
for(int v = 0 ; v < V ; v++){
h[v] += dist[v];
}
int d = f;
for(int v = t ; v != s ; v = prevv[v]){
d = min(d,G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d*h[t];
for(int v = t ; v != s ; v = prevv[v]){
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
vec gauss_jordan(const mat &A,const vec &b){
int n = A.size();
mat B(n,vec(n+1));
for(int i = 0 ; i < n ; i++){
for(int j = 0 ; j < n ; j++){
B[i][j] = A[i][j];
}
}
for(int i = 0 ; i < n ; i++){
B[i][n] = b[i];
}
for(int i = 0 ; i < n ; i++){
int pivot = i;
for(int j = i ; j < n ; j++){
if(abs(B[j][i]) > abs(B[pivot][i])){
pivot = j;
}
}
swap(B[i],B[pivot]);
if(abs(B[i][i]) < EPS) return vec();
for(int j = i+1 ; j <= n ; j++){
B[i][j] /= B[i][i];
}
for(int j = 0 ; j < n ; j++){
if(i != j){
for(int k = i+1 ; k <= n ; k++){
B[j][k] -= B[j][i]*B[i][k];
}
}
}
}
vec x(n);
for(int i = 0 ; i < n ; i++){
x[i] = B[i][n];
}
return x;
}
void init(){
for(int i = 0 ; i < MAX_V ; i++){
G[i].clear();
}
}
int main(){
int Tc;
cin >> Tc;
while(Tc--){
int N,s,t,F;
init();
cin >> N >> s >> t >> F;
mat a(N,vec(N)); vec c(N);
for(int i = 0 ; i < N ; i++){
for(int j = 0 ; j < N ; j++){
cin >> a[i][j];
}
cin >> c[i];
}
vec res = gauss_jordan(a,c);
for(int i = 0 ; i < N ; i++){
int M,d[N],f;
cin >> M;
for(int j = 0 ; j < M ; j++){
cin >> d[j];
}
for(int j = 0 ; j < M ; j++){
cin >> f;
add_edge(i,d[j],f,abs(res[i]-res[d[j]]));
}
}
V = N;
double ans = min_cost_flow(s,t,F);
if(ans == -1){
printf("impossible\n");
}else{
printf("%.6f\n",ans);
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define MAX_V 105
#define INF 1000000001
typedef pair< double ,int> P;
struct edge {
int to;
int cap;
int rev;
double cost;
};
int V;
vector<edge> G[MAX_V];
double h[MAX_V];
double dist[MAX_V];
int prevv[MAX_V],preve[MAX_V];
void init_edge(){
for(int i=0;i<MAX_V;i++)G[i].clear();
}
void add_edge(int from,int to,int cap,double cost){
G[from].push_back((edge){to,cap,(int)G[to].size(),cost});
G[to].push_back((edge){from,0,(int)G[from].size()-1,-cost});
}
double min_cost_flow(int s,int t,int f){
double eps = 1e-5;
double res = 0;
fill(h,h+V,0.0);
while(f>0){
priority_queue< P, vector<P>, greater<P> > que;
fill( dist, dist+V , (double)INF );
dist[s]=0;
que.push(P(0,s));
// fill ( prevv , prevv + V , s );
while(!que.empty()){
P p = que.top(); que.pop();
int v = p.second;
if(dist[v]+eps < p.first)continue;
for(int i=0;i<(int)G[v].size();i++){
edge &e = G[v][i];
if(e.cap>0&&dist[e.to] > eps+dist[v]+e.cost+h[v]-h[e.to]){
dist[e.to]=dist[v]+e.cost+h[v]-h[e.to];
prevv[e.to]=v;
preve[e.to]=i;
que.push(P(dist[e.to],e.to));
}
}
}
if(dist[t] == INF){
return -1;
}
for(int v=0;v<V;v++)h[v]+=dist[v];
int d=f;
for(int v=t;v!=s;v=prevv[v]){
d=min(d,G[prevv[v]][preve[v]].cap);
}
assert( d > 0 );
f-=d;
res+=d*h[t];
for(int v=t;v!=s;v=prevv[v]){
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
typedef vector< double > vec;
typedef vector<vec> mat;
vec gauss_jordan(const mat&A,const vec&b){
int n=A.size();
mat B(n,vec(n+1));
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)B[i][j]=A[i][j];
for(int i=0;i<n;i++)B[i][n]=b[i];
for(int i=0;i<n;i++){
int pivot=i;
for(int j=i;j<n;j++)
if(abs(B[j][i])>abs(B[pivot][i]))pivot=j;
swap(B[i],B[pivot]);
if(abs(B[i][i])< 0.0000001 )return vec();
for(int j=i+1;j<=n;j++)B[i][j]/=B[i][i];
for(int j=0;j<n;j++){
if(i!=j)
for(int k=i+1;k<=n;k++)B[j][k]-=B[j][i]*B[i][k];
}
}
vec x(n);
for(int i=0;i<n;i++)x[i]=B[i][n];
return x;
}
int N,si,ti,F;
int M;
int main(){
int T;
cin>>T;
while(T--){
init_edge();
cin>>N>>si>>ti>>F;
mat A( N , vec(N) );
vec B( N );
for(int i=0;i<N;i++){
for(int j=0;j<N;j++)scanf("%lf",&A[i][j]);
scanf("%lf",&B[i]);
}
vec C=gauss_jordan(A,B);
for(int i=0;i<N;i++){
cin>>M;
vector<int> d(M);
vector<int> f(M);
for(int j=0;j<M;j++)scanf("%d",&d[j]);
for(int j=0;j<M;j++)scanf("%d",&f[j]);
for(int j=0;j<M;j++){
add_edge(i,d[j],f[j], abs(C[i]-C[d[j]]) );
}
}
V=N;
double ans=min_cost_flow(si,ti,F);
if(ans<=-1.0){
cout<<"impossible"<<endl;
}else{
printf("%.10f\n",ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using Array = vector<double>;
using vec = vector<double>;
using Matrix = vector<Array>;
using mat = vector<Array>;
const double eps = 1e-8;
Array GaussJordan(const Matrix& A, const Array& b) {
int n = A.size();
Matrix B(n, Array(n + 1));
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++) B[i][j] = A[i][j];
for(int i = 0; i < n; i++) B[i][n] = b[i];
for(int i = 0; i < n; i++) {
int pivot = i;
for(int j = i; j < n; j++) {
if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
}
swap(B[i], B[pivot]);
if(abs(B[i][i]) < eps) return Array();
for(int j = i + 1; j <= n; j++) B[i][j] /= B[i][i];
for(int j = 0; j < n; j++) {
if(i != j) {
for(int k = i + 1; k <= n; k++) B[j][k] -= B[j][i] * B[i][k];
}
}
}
Array x(n);
for(int i = 0; i < n; i++) x[i] = B[i][n];
return x;
}
const int MAX_V = 100010;
typedef int Capacity;
typedef double Cost;
const Cost inf = 1e9;
struct Edge {
int dst;
Capacity cap, cap_orig;
Cost cost;
int revEdge; bool isRev;
Edge(int dst, Capacity cap, Cost cost, int revEdge, bool isRev)
:dst(dst), cap(cap), cap_orig(cap), cost(cost), revEdge(revEdge), isRev(isRev) {
}
};
struct PrimalDual {
int n;
vector<vector<Edge> > g;
vector<int> top;
PrimalDual(int n_) : n(n_), g(vector<vector<Edge> >(n_)) {}
void add_edge(int src, int dst, Capacity cap, Cost cost) { // ?????????
g[src].push_back(Edge{ dst, cap, cost, (int)g[dst].size(), false });
g[dst].push_back(Edge{ src, 0, -cost, (int)g[src].size() - 1, true });
}
Cost solve(int s, int t, int f) {
Cost res = 0;
static Cost h[MAX_V], dist[MAX_V];
static int prevv[MAX_V], preve[MAX_V];
fill(h, h + n, 0);
if(top.size()) {
assert(top.size() == n);
for(int i = 0; i < n; i++) {
int v = top[i];
for(int i = 0; i < g[v].size(); i++) {
Edge& e = g[v][i];
if(e.cap == 0) continue;
int u = e.dst;
h[u] = min(h[u], h[v] + e.cost);
}
}
}
while(f > 0) {
typedef pair<Cost, int> pcv;
priority_queue<pcv, vector<pcv>, greater<pcv> > q;
for(int i = 0; i < n; i++) {
dist[i] = inf;
}
dist[s] = 0;
q.push(pcv(0, s));
while(q.size()) {
pcv p = q.top(); q.pop();
int v = p.second;
if(dist[v] < p.first) continue;
for(int i = 0; i < g[v].size(); i++) {
Edge &e = g[v][i];
if(e.cap > 0 && dist[e.dst] > dist[v] + e.cost + h[v] - h[e.dst] + eps) {
dist[e.dst] = dist[v] + e.cost + h[v] - h[e.dst];
prevv[e.dst] = v;
preve[e.dst] = i;
q.push(pcv(dist[e.dst], e.dst));
}
}
}
if(abs(dist[t] - inf) < eps) {
return -1;
}
for(int v = 0; v < n; v++) {
h[v] += dist[v];
}
// s-t ????????????????????£??????????????????
int d = f;
for(int v = t; v != s; v = prevv[v]) {
d = min(d, g[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for(int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.revEdge].cap += d;
}
}
return res;
}
// ??????????????????=???????????????-?????¨??????????????¨???
void view() {
for(int i = 0; i < g.size(); i++) {
for(int j = 0; j < g[i].size(); j++) {
if(!g[i][j].isRev) {
Edge& e = g[i][j];
printf("%3d->%3d (flow:%d)\n", i, e.dst, e.cap_orig - e.cap);
}
}
}
}
};
int d[1000];
int f[1000];
void solve() {
int N, S, T, F;
cin >> N >> S >> T >> F;
Matrix A(N, Array(N));
Array b(N);
for(int i = 0; i < N; i++) {
for(int j = 0; j < N; j++) {
cin >> A[i][j];
}
cin >> b[i];
}
Array tm = GaussJordan(A, b);
PrimalDual pd(N);
for(int i = 0; i < N; i++) {
int M;
cin >> M;
for(int j = 0; j < M; j++) {
cin >> d[j];
}
for(int j = 0; j < M; j++) {
cin >> f[j];
}
for(int j = 0; j < M; j++) {
pd.add_edge(i, d[j], f[j], abs(tm[i] - tm[d[j]]));
}
}
Cost res = pd.solve(S, T, F);
if(res == -1) {
cout << "impossible" << endl;
}
else {
cout << fixed << setprecision(15) << res << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
while(T--) solve();
}
|
#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;
typedef vector<double> vec;
typedef vector<vec> mat;
ostream &operator<<(ostream &os, const vec &a) {
FOR(it, a) os << setw(6) << *it << " ";
return os;
}
ostream &operator<<(ostream &os, const mat &a) {
FOR(it, a) os << *it << endl;
return os;
}
bool GaussElimination(const mat &A, const vec &b, vec &res) {
int n = A.size();
mat B(n, vec(n+1));
REP(i,n) REP(j,n)
B[i][j] = A[i][j];
REP(i, n) B[i][n] = b[i];
int nowy = 0;
REP(x, n) {
int pivot = -1;
for (int j=nowy; j<n; ++j)
if (B[j][x]) {
pivot = j;break;
}
if (pivot == -1) continue;
swap(B[nowy], B[pivot]);
for (int j=nowy+1; j<n; ++j) {
double t = B[j][x] / B[nowy][x];
for (int k=x; k<=n; ++k)
B[j][k] = B[j][k] - B[nowy][k] * t;
}
nowy++;
}
res.clear();
for (int y=nowy; y<n; ++y)
if (B[y][n]) // rank(A) != rank(A|b)
return 0;
if (nowy != n) { // rank(A) == rank(A|b) != n
return 0;
}
res.resize(n);
for (int x=n-1; x>=0; --x) {
double sum = B[x][n];
for (int i=n-1; i>x; --i) {
sum -= res[i] * B[x][i];
}
res[x] = sum / B[x][x];
}
return 1;
}
typedef double Weight;
struct Edge {
int src, dst;
Weight capacity, cost;
int rev;
Edge(int src, int dst, Weight capacity, Weight cost) :
src(src), dst(dst), capacity(capacity), cost(cost) { }
Edge(int src, int dst, Weight capacity, Weight cost, int rev) :
src(src), dst(dst), capacity(capacity), cost(cost), rev(rev) { }
};
bool operator < (const Edge &e, const Edge &f) {
return e.cost != f.cost ? e.cost > f.cost : // !!INVERSE!!
e.src != f.src ? e.src < f.src : e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
void add_edge2(Graph &g, int s, int d, Weight cap, Weight cost) {
g[s].push_back(Edge(s,d,cap,cost,g[d].size()));
g[d].push_back(Edge(d,s,0,-cost,g[s].size()-1));
}
pair<Weight, Weight> minimumCostFlow4(Graph g, int s, int t) {
const int n = g.size();
pair<Weight, Weight> total; // (cost, flow)
vector<Weight> h(n,INF);
h[s] = 0;
REP(k, n) {
bool update = 0;
REP(i, n) {
FOR(e,g[i]) if (e->capacity)
if (h[e->dst] > h[e->src] + e->cost) {
h[e->dst] = h[e->src] + e->cost;
update = 1;
}
}
if (!update) break;
}
for (int F = INF; F > 0;) { // residual flow
vector<Weight> d(n, INF); d[s] = 0;
vector<int> pv(n,-1), pe(n);
priority_queue<Edge> Q;
for (Q.push(Edge(-2,s,0,0)); !Q.empty(); ) {
Edge e = Q.top(); Q.pop();
if (pv[e.dst] != -1) continue;
pv[e.dst] = e.src;
pe[e.dst] = e.rev;
REP(i, g[e.dst].size()) {
Edge &f = g[e.dst][i];
if (f.capacity > 0 && d[f.dst] > d[f.src] + f.cost + h[f.src] - h[f.dst]) {
d[f.dst] = d[f.src] + f.cost + h[f.src] - h[f.dst];
Q.push(Edge(f.src, f.dst, 0, d[f.dst], i));
}
}
}
if (pv[t] == -1) break;
Weight f = F;
for (int u = t; u != s; u = pv[u])
f = min(f, g[pv[u]][pe[u]].capacity);
if (!f) break;
for (int u = t; u != s; u = pv[u]) {
total.first += f * g[pv[u]][pe[u]].cost;
g[pv[u]][pe[u]].capacity -= f;
g[u][g[pv[u]][pe[u]].rev].capacity += f;
}
F -= f;
total.second += f;
REP(u,n) if (h[u] != INF) h[u] += d[u];
}
return total;
}
int d[100];
double f[100];
int main() {
int T;
cin >> T;
while(T--) {
int N,s,t,F;
cin>>N>>s>>t>>F;
mat A(N,vec(N));
vec b(N);
REP(i,N) {
REP(j,N) cin>>A[i][j];
cin>>b[i];
}
vec temp;
assert(GaussElimination(A,b,temp));
Graph g(N+1);
REP(i,N) {
int M;
cin >> M;
REP(j,M) cin >> d[j];
REP(j,M) cin >> f[j];
REP(j,M) {
add_edge2(g,i,d[j],f[j],abs(temp[i]-temp[d[j]]));
//printf("%.10f %.10f\n", f[j], abs(temp[i]-temp[d[j]]));
}
}
add_edge2(g,N,s,F,0);
pair<Weight,Weight> p = minimumCostFlow4(g,N,t);
//cout << p.first << " " << p.second << endl;
if (p.second >F-EPS) {
printf("%.10f\n", p.first);
} else {
puts("impossible");
}
}
}
|
#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 double EPS = 1.0e-10;
const double INF = DBL_MAX / 1000;
void linearSystem(vector<vector<double> >& mat, vector<double>& x)
{
int n = mat.size();
x.resize(n);
for(int i=0; i<n; ++i){
int tmp = i;
for(int j=i; j<n; ++j){
if(mat[j][i] > mat[tmp][i])
tmp = j;
}
swap(mat[i], mat[tmp]);
for(int j=n; j>=i; --j)
mat[i][j] /= mat[i][i];
for(int j=0; j<n; ++j){
if(j == i)
continue;
for(int k=n; k>=i; --k){
mat[j][k] -= mat[i][k] * mat[j][i];
}
}
}
for(int i=0; i<n; ++i)
x[i] = mat[i][n];
}
class Edge{
public:
int to, cap, rev;
double cost;
Edge(){};
Edge(int to0, int cap0, double cost0){to = to0; cap = cap0, cost = cost0;}
Edge(int to0, int cap0, double cost0, int rev0){to = to0; cap = cap0; cost = cost0; rev = rev0;}
};
double minCostFlow(const vector<vector<Edge> >& edges0, int source, int sink, int flow)
{
int n = edges0.size();
vector<vector<Edge> > edges(n);
for(int i=0; i<n; ++i){
for(unsigned j=0; j<edges0[i].size(); ++j){
const Edge& e = edges0[i][j];
edges[i].push_back(Edge(e.to, e.cap, e.cost, edges[e.to].size()));
edges[e.to].push_back(Edge(i, 0, -e.cost, edges[i].size()-1));
}
}
vector<double> h(n, 0.0);
vector<int> prevV(n);
vector<int> prevE(n);
double ret = 0.0;
while(flow > 0){
vector<double> dist(n, INF);
dist[source] = 0.0;
priority_queue<pair<double,int> ,vector<pair<double,int> >, greater<pair<double,int> > > q;
q.push(make_pair(0.0, source));
while(!q.empty()){
pair<double, int> p = q.top();
q.pop();
int v = p.second;
if(dist[v] < p.first - EPS)
continue;
for(unsigned i=0; i<edges[v].size(); ++i){
Edge e = edges[v][i];
if(e.cap > 0 && dist[v] + e.cost + h[v] - h[e.to] < dist[e.to] - EPS){
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevV[e.to] = v;
prevE[e.to] = i;
q.push(make_pair(dist[e.to], e.to));
}
}
}
if(dist[sink] > INF / 10)
return -1.0;
for(int i=0; i<n; ++i)
h[i] += dist[i];
int g = flow;
for(int i=sink; i!=source; i=prevV[i])
g = min(g, edges[prevV[i]][prevE[i]].cap);
for(int i=sink; i!=source; i=prevV[i]){
Edge& e = edges[prevV[i]][prevE[i]];
e.cap -= g;
edges[i][e.rev].cap += g;
}
flow -= g;
ret += g * h[sink];
}
return ret;
}
int main()
{
int T;
cin >> T;
while(--T >= 0){
int n, s, t, f;
cin >> n >> s >> t >> f;
vector<vector<double> > a(n, vector<double>(n+1));
for(int i=0; i<n; ++i){
for(int j=0; j<n+1; ++j){
cin >> a[i][j];
}
}
vector<double> x; // 気温
linearSystem(a, x);
vector<vector<Edge> > edges(n);
for(int i=0; i<n; ++i){
int m;
cin >> m;
vector<int> to(m), cap(m);
for(int j=0; j<m; ++j)
cin >> to[j];
for(int j=0; j<m; ++j)
cin >> cap[j];
for(int j=0; j<m; ++j)
edges[i].push_back(Edge(to[j], cap[j], abs(x[i] - x[to[j]])));
}
double ret = minCostFlow(edges, s, t, f);
if(ret < -0.5)
cout << "impossible" << endl;
else
printf("%.10f\n", ret);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-3;
bool GaussJordan(const vvd& _a,const vd& b,vd& x)
{
int n=_a.size();
vvd a(n,vd(n+1));
rep(i,n){
copy(all(_a[i]),begin(a[i]));
a[i][n]=b[i];
}
rep(i,n){
int p=i;
repi(j,i+1,n) if(abs(a[p][i])<abs(a[j][i])) p=j;
if(abs(a[p][i])<EPS) return false;
swap(a[i],a[p]);
peri(j,i,n+1) a[i][j]/=a[i][i];
rep(j,n) if(j!=i) peri(k,i,n+1) a[j][k]-=a[j][i]*a[i][k];
}
rep(i,n) x[i]=a[i][n];
return true;
}
struct Edge{
int src,dst;
double cost;
int cap,flow;
Edge(){}
Edge(int s,int d,double co,int ca=0,int f=0):src(s),dst(d),cost(co),cap(ca),flow(f){}
};
bool operator<(const Edge& a,const Edge& b){return a.cost<b.cost;}
bool operator>(const Edge& a,const Edge& b){return a.cost>b.cost;}
struct Graph{
vector<Edge> es;
vi head,next;
Graph(){}
Graph(int n):head(n,-1){}
// コスト:-co,容量:0の逆辺も追加する
void AddEdge(int u,int v,double co,int ca){
es.emplace_back(u,v,co,ca); next.push_back(head[u]); head[u]=es.size()-1;
es.emplace_back(v,u,-co,0); next.push_back(head[v]); head[v]=es.size()-1;
}
};
double MinCostFlow(Graph& g,int tap,int sink,int flow)
{
int n=g.head.size();
double res=0;
vd pots(n);
while(flow>EPS){
vd cost(n,INF);
vi prev(n,-1);
priority_queue<Edge,vector<Edge>,greater<Edge>> pq;
pq.emplace(-1,tap,0);
while(pq.size()){
Edge cur=pq.top(); pq.pop();
if(cur.cost>cost[cur.dst]-EPS) continue;
cost[cur.dst]=cur.cost;
prev[cur.dst]=cur.src;
for(int i=g.head[cur.dst];i!=-1;i=g.next[i]){
Edge e=g.es[i];
if(e.cap-e.flow==0) continue;
pq.emplace(i,e.dst,cost[e.src]+e.cost+pots[e.src]-pots[e.dst]);
}
}
if(cost[sink]==INF) return -1;
rep(i,n) pots[i]+=cost[i];
int augment=flow;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
Edge e=g.es[prev[v]];
augment=min(augment,e.cap-e.flow);
}
if(augment<EPS) return -1;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
int i=prev[v];
g.es[i].flow+=augment;
g.es[i^1].flow-=augment;
}
flow-=augment;
res+=augment*pots[sink];
}
return res;
}
void solve()
{
int n,s,t,f; scanf("%d%d%d%d",&n,&s,&t,&f);
vd cs(n);
{
vvd a(n,vd(n));
vd b(n);
rep(i,n){
rep(j,n) scanf("%lf",&a[i][j]);
scanf("%lf",&b[i]);
}
GaussJordan(a,b,cs);
}
Graph g(n);
rep(i,n){
int m; scanf("%d",&m);
vi ds(m),fs(m);
rep(j,m) scanf("%d",&ds[j]);
rep(j,m) scanf("%d",&fs[j]);
rep(j,m) g.AddEdge(i,ds[j],abs(cs[ds[j]]-cs[i]),fs[j]);
}
double res=MinCostFlow(g,s,t,f);
if(res==-1)
puts("impossible");
else
printf("%.10f\n",res);
}
int main()
{
int tc; scanf("%d",&tc);
rep(_,tc) solve();
}
|
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<vector>
using namespace std;
namespace MCF {
// required <string.h> <vector> <queue> <algorithm>
#define MAXN 110
#define MAXM 30000
#define wint int
#define cint long double
const wint wEPS = 0;
const wint wINF = 1001001001;
const cint cEPS = 1e-7L;
const cint cINF = 1e10L;
int n, m, ptr[MAXN], next[MAXM], zu[MAXM];
wint capa[MAXM], tof;
cint cost[MAXM], toc, d[MAXN], pot[MAXN];
int vis[MAXN], pree[MAXN];
void init(int _n) {
n = _n; m = 0; memset(ptr, ~0, n * 4);
}
void ae(int u, int v, wint w, cint c) {
next[m] = ptr[u]; ptr[u] = m; zu[m] = v; capa[m] = w; cost[m] = +c; ++m;
next[m] = ptr[v]; ptr[v] = m; zu[m] = u; capa[m] = 0; cost[m] = -c; ++m;
}
bool solve(int src, int ink, wint flo = wINF) {
int i, u, v;
wint f;
cint c, cc;
memset(pot, 0, n * sizeof(cint));
//*
for (bool cont = 1; cont; ) {
cont = 0;
for (u = 0; u < n; ++u) for (i = ptr[u]; ~i; i = next[i]) if (capa[i] > wEPS) {
if (pot[zu[i]] > pot[u] + cost[i] + cEPS) {
pot[zu[i]] = pot[u] + cost[i]; cont = 1;
}
}
}
//*/
for (toc = 0, tof = 0; tof + wEPS < flo; ) {
typedef pair<cint,int> node;
priority_queue< node,vector<node>,greater<node> > q;
for (u = 0; u < n; ++u) { d[u] = cINF; vis[u] = 0; }
for (q.push(make_pair(d[src] = 0, src)); !q.empty(); ) {
c = q.top().first; u = q.top().second; q.pop();
if (vis[u]++) continue;
for (i = ptr[u]; ~i; i = next[i]) if (capa[i] > wEPS) {
cc = c + cost[i] + pot[u] - pot[v = zu[i]];
if (d[v] > cc + cEPS) { q.push(make_pair(d[v] = cc, v)); pree[v] = i; }
}
}
if (!vis[ink]) return 0;
f = flo - tof;
for (v = ink; v != src; v = zu[i ^ 1]) { i = pree[v]; f=min(f,capa[i]); }
for (v = ink; v != src; v = zu[i ^ 1]) { i = pree[v]; capa[i] -= f; capa[i ^ 1] += f; }
tof += f;
toc += f * (d[ink] - pot[src] + pot[ink]);
for (u = 0; u < n; ++u) pot[u] += d[u];
}
return 1;
}
}
const long double EPS=1e-10L;
typedef vector<long double>vec;
typedef vector<vec>mat;
long double ABS(long double a){return max(a,-a);}
vec gauss_jordan(const mat &A,const vec &b){
int n=A.size();
mat B(n,vec(n+1));
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)B[i][j]=A[i][j];
for(int i=0;i<n;i++)B[i][n]=b[i];
for(int i=0;i<n;i++){
int pivot=i;
for(int j=i;j<n;j++){
if(ABS(B[j][i])>ABS(B[pivot][i]))pivot=j;
}
swap(B[i],B[pivot]);
if(ABS(B[i][i])<EPS)return vec();
for(int j=i+1;j<=n;j++)B[i][j]/=B[i][i];
for(int j=0;j<n;j++){
if(i!=j){
for(int k=i+1;k<=n;k++)B[j][k]-=B[j][i]*B[i][k];
}
}
}
vec x(n);
for(int i=0;i<n;i++)x[i]=B[i][n];
return x;
}
int t1[110];
int t2[110];
int main(){
int T;scanf("%d",&T);
while(T--){
int a,b,c,d;
scanf("%d%d%d%d",&a,&b,&c,&d);
mat A(a,vec(a));
vec B(a);
for(int i=0;i<a;i++){
for(int j=0;j<a;j++){
scanf("%Lf",&A[i][j]);
}
scanf("%Lf",&B[i]);
}
vec C=gauss_jordan(A,B);
//s for(int i=0;i<a;i++)printf("%Lf ",C[i]);
MCF::init(a);
for(int i=0;i<a;i++){
int p;scanf("%d",&p);
for(int j=0;j<p;j++){
scanf("%d",t1+j);
}
for(int j=0;j<p;j++)scanf("%d",t2+j);
for(int j=0;j<p;j++)MCF::ae(i,t1[j],t2[j],ABS(C[i]-C[t1[j]]));
}
int res=MCF::solve(b,c,d);
if(!res)printf("impossible\n");
else printf("%.12Lf\n",MCF::toc);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-6;
bool GaussJordan(const vvd& _a,const vd& b,vd& x)
{
int n=_a.size();
vvd a(n,vd(n+1));
rep(i,n){
copy(all(_a[i]),begin(a[i]));
a[i][n]=b[i];
}
rep(i,n){
int p=i;
repi(j,i+1,n) if(abs(a[p][i])<abs(a[j][i])) p=j;
if(abs(a[p][i])<EPS) return false;
swap(a[i],a[p]);
peri(j,i,n+1) a[i][j]/=a[i][i];
rep(j,n) if(j!=i) peri(k,i,n+1) a[j][k]-=a[j][i]*a[i][k];
}
rep(i,n) x[i]=a[i][n];
return true;
}
struct Edge{
int src,dst;
double cost;
int cap,flow;
Edge(){}
Edge(int s,int d,double co,int ca=0,int f=0):src(s),dst(d),cost(co),cap(ca),flow(f){}
};
bool operator<(const Edge& a,const Edge& b){return a.cost<b.cost;}
bool operator>(const Edge& a,const Edge& b){return a.cost>b.cost;}
struct Graph{
vector<Edge> es;
vi head,next;
Graph(){}
Graph(int n):head(n,-1){}
// コスト:-co,容量:0の逆辺も追加する
void AddEdge(int u,int v,double co,int ca){
es.emplace_back(u,v,co,ca); next.push_back(head[u]); head[u]=es.size()-1;
es.emplace_back(v,u,-co,0); next.push_back(head[v]); head[v]=es.size()-1;
}
};
double MinCostFlow(Graph& g,int tap,int sink,int flow)
{
int n=g.head.size();
double res=0;
vd pots(n);
while(flow){
vd cost(n,INF);
vi prev(n,-1);
priority_queue<Edge,vector<Edge>,greater<Edge>> pq;
pq.emplace(-1,tap,0);
while(pq.size()){
Edge cur=pq.top(); pq.pop();
if(cur.cost>cost[cur.dst]-EPS) continue;
cost[cur.dst]=cur.cost;
prev[cur.dst]=cur.src;
for(int i=g.head[cur.dst];i!=-1;i=g.next[i]){
Edge e=g.es[i];
if(e.cap-e.flow==0) continue;
pq.emplace(i,e.dst,cost[e.src]+e.cost+pots[e.src]-pots[e.dst]);
}
}
if(cost[sink]==INF) return -1;
rep(i,n) pots[i]+=cost[i];
int augment=flow;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
Edge e=g.es[prev[v]];
augment=min(augment,e.cap-e.flow);
}
if(augment<EPS) return -1;
for(int v=sink;v!=tap;v=g.es[prev[v]].src){
int i=prev[v];
g.es[i].flow+=augment;
g.es[i^1].flow-=augment;
}
flow-=augment;
res+=augment*pots[sink];
}
return res;
}
void solve()
{
int n,s,t,f; cin>>n>>s>>t>>f;
vd cs(n);
{
vvd a(n,vd(n));
vd b(n);
rep(i,n){
rep(j,n) cin>>a[i][j];
cin>>b[i];
}
GaussJordan(a,b,cs);
}
Graph g(n);
rep(i,n){
int m; cin>>m;
vi ds(m),fs(m);
rep(j,m) cin>>ds[j];
rep(j,m) cin>>fs[j];
rep(j,m) g.AddEdge(i,ds[j],abs(cs[ds[j]]-cs[i]),fs[j]);
}
double res=MinCostFlow(g,s,t,f);
if(res==-1)
puts("impossible");
else
printf("%.10f\n",res);
}
int main()
{
int tc; cin>>tc;
rep(_,tc) solve();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.