text stringlengths 49 983k |
|---|
//解説見ました.
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1000000007;
ll dp[105][4][2];
int main(){
string s;
cin >>s;
ll n = s.size();
ll hi;
cin >> hi;
dp[0][0][0]=1;
for(int i=0; i<n; i++){
for(int j=0; j<4; j++){
for(int k=0; k<2; k++){
ll nd = s[i]-'0';
for(int d=0; d<10; d++){
int ni=i+1,nj=j,nk=k;
if(d!=0)nj++;
if(nj>hi)continue;
if(k==0){
if(d>nd)continue;
if(d<nd)nk=1;
}
dp[ni][nj][nk] += dp[i][j][k];
}
}
}
}
ll ans = dp[n][hi][0] + dp[n][hi][1];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N=110;
char s[N];
int dp[5][N][2],k,n;
int dfs(int now,int num,int flag){
int ans=0;
if(num>k)return 0;
if(now==n+1)return(num==k);
if(dp[num][now][flag]!=-1)return dp[num][now][flag];
int lim=9;if(flag)lim=s[now]-'0';
for(int i=0;i<=lim;i++){
ans+=dfs(now+1,num+(i!=0),flag&&(i==lim));
}
return dp[num][now][flag]=ans;
}
int main(){
scanf("%s",s+1);
scanf("%d",&k);
memset(dp,-1,sizeof(dp));
n=strlen(s+1);
cout<<dfs(1,0,1);
} |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int dp[105][5][2];
int main() {
string s;
int K;
cin >> s >> K;
dp[0][0][0] = 1;
int n=s.length();
rep(i, n) rep(k, K+1) rep(t, 2) {
int d=s[i]-'0';
rep(j, 10) {
if(t == 0 && j>d) continue;
if(t == 0 && j==d) {
dp[i+1][k+(j>0)][0] += dp[i][k][t];
} else {
dp[i+1][k+(j>0)][1] += dp[i][k][t];
}
}
}
cout << dp[n][K][0]+dp[n][K][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN=110;
int n,k,cnt,ans,p[4]={1,9,81,729};
char c[MAXN];
int cx (int x,int k) {
if (k==0) {return 1;}
if (k==1) {return x;}
if (k==2) {return (x*(x-1))/2;}
if (k==3) {return (x*(x-1)*(x-2))/6;}
return 0;
}
int main () {
scanf("%s%d",c+1,&k);
int n=strlen(c+1);
for (int i=1;i<=n;i++) {
if (c[i]!='0') {
cnt++;
ans+=cx(n-i,k-cnt+1)*p[k-cnt+1];
ans+=(c[i]-'0'-1)*cx(n-i,k-cnt)*p[k-cnt];
}
}
printf("%d\n",ans+(cnt==k));
return 0;
} |
#include<bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
typedef long long ll;
int main(){
string s;cin >> s;
ll K,n = s.size(),i,j,k,l;cin >> K;
ll dp[n+1][2][K+2];
memset(dp,0,sizeof(dp));dp[0][0][0] = 1;
ll z;
for(i=0;i<n;i++){
z = s[i]-'0';
for(j=0;j<2;j++){
for(k=0;k<=K;k++){
dp[i+1][j|(z!=0)][k] += dp[i][j][k];
for(l=1;l<=(j ? 9:z);l++){
dp[i+1][j|(l<z)][k+1] += dp[i][j][k];
}
}
}
}
printf("%lld\n",dp[n][0][K]+dp[n][1][K]);
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
string N;
int K;
ll dp[150][2][5];
void solve()
{
dp[0][0][0]=1;
const int n = N.length();
for(int i=0;i<n;++i)for(int smaller=0;smaller<2;++smaller)for(int num=0;num<=K;++num){
for(int k=0;k<=(smaller?9:N[i]-'0');++k){
if(k == 0) dp[i+1][smaller|(k<N[i]-'0')][num] += dp[i][smaller][num];
else{
if(num < K) dp[i+1][smaller|(k<N[i]-'0')][num+1] += dp[i][smaller][num];
}
}
}
ll ans = dp[n][0][K]+dp[n][1][K];
cout << ans << '\n';
}
int main()
{
cin >> N;
cin >> K;
solve();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define lowbit(x) ((x)&(-x))
int n,K,dp[5][105][3];
char str[105];
int dfs(int m,int use,int limit) {
if(use>K){
return 0;
}
if(m>n){
return use==K;
}
if(dp[use][m][limit] != -1){
return dp[use][m][limit];
}
int up=limit==1?str[m]-'0':9,ans=0;
for(int i = 0; i <= up; ++i){
ans += dfs(m+1, use+(i!=0), limit&&i==up);
}
return dp[use][m][limit]=ans;
}
void run_case() {
cin>>(str+1)>>K;
n=strlen(str+1);
memset(dp,-1,sizeof(dp));
cout<<dfs(1, 0, 1)<<endl;
}
int main(){
run_case();
cout.flush();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
string S;
int K;
int N;
int dp[110][5][2];
int main()
{
cin>>S>>K;
N = S.length();
dp[0][0][1] = 1;
for(int i = 0; i < N; i ++)
{
for(int j = 0; j <= K; j ++)
{
int Num = S[i] - '0';
if(Num == 0)
{
dp[i + 1][j][0] += dp[i][j][0];
dp[i + 1][j][1] += dp[i][j][1];
dp[i + 1][j + 1][0] += (dp[i][j][0] * 9);
}
else
{
dp[i + 1][j][0] += (dp[i][j][0] + dp[i][j][1]);
dp[i + 1][j + 1][0] += (dp[i][j][0] * 9);
dp[i + 1][j + 1][0] += (dp[i][j][1] * (Num - 1));
dp[i + 1][j + 1][1] += dp[i][j][1];
}
}
}
cout<<dp[N][K][0] + dp[N][K][1]<<endl;
return 0;
} |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int dp[105][4][2];
int main(){
string s;
int K;
cin >> s >> K;
int n = s.size();
dp[0][0][0] = 1;
rep(i, n)rep(j, 4)rep(k, 2){
int nd = s[i]-'0';
rep(d, 10){
int ni = i+1, nj = j, nk = k;
if(d != 0) nj++;
if(nj > K) continue;
if(k == 0){
if(d > nd) continue;
if(d < nd) nk = 1;
}
dp[ni][nj][nk] += dp[i][j][k];
}
}
int ans = dp[n][K][0] + dp[n][K][1];
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
long long under[110][5];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string s; int k; cin >> s >> k;
int n = s.size(); int cnt = 0;
for (int i = 0; i < n; i++) {
int sn = s[i] - '0';
for (int u = 0; u <= 3; u++) {
for (int d = 0; d < 10; d++) {
under[i+1][u+(d!=0)] += under[i][u];
}
}
for (int d = 0; d < sn; d++) {
if ((cnt + (d!=0)) < 5) under[i+1][(d!=0)+cnt] += 1;
}
cnt += (sn != 0);
}
cout << under[n][k] + (cnt == k) << "\n";
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
template <typename A,size_t N,typename T>
void Fill(A(&array)[N],const T &val){
fill((T*)array,(T*)(array+N),val);
}
int main() {
string N;
int k;
cin >> N >> k;
int l=N.size();
vector<int> v(l);
rep(i,l)
v[i]=(N[i]-'0');
int dp[101][2][5]={};
// Fill(dp,0);
dp[0][0][0]=1;
rep(i,l)
rep(s,2){
int y=(s?9:v[i])+1;
rep(j,k+1)
rep(x,y){
dp[i+1][s||x<v[i]][j+(x>0)]+=dp[i][s][j];
}
}
cout<<dp[l][0][k]+dp[l][1][k];
} |
#include <iostream>
#include <string>
using namespace std;
long long dp[105][2][105];
int main() {
string N; cin >> N;
int n = N.size();
int k; cin >> k;
dp[0][0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int smaller = 0; smaller < 2; ++smaller) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k <= (smaller ? 9 : N[i] - '0'); ++k) {
dp[i + 1][smaller || k < N[i] - '0'][j + (k ? 1 : 0)] += dp[i][smaller][j];
}
}
}
}
cout << dp[n][0][k] + dp[n][1][k] << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
int k, d[5] = {}, e[5] = {0, 1};
cin >> n >> k;
for(auto c : n) {
for(int i = k; i >= 0; i--) {
d[i + 1] += d[i] * 9;
if(c != '0')
d[i + 1] += e[i + 1] + e[i] * (c - '1'), e[i + 1] = e[i];
}
}
cout << d[k + 1] + e[k + 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for(int __x = __start; __x < __end; __x++)
string s;
int n, k;
ll dp[1010][5][2];
ll dfs(int i = 0, int x = 0, bool l = true) {
if (i == n) return x == k;
if (x > k) return 0;
ll &cc = dp[i][x][l];
if (~cc) return cc;
ll ans = 0;
int u = l ? s[i]-'0' : 9;
loop(d,0,u+1) {
ans += dfs(i + 1, x + (d != 0), l && d == u);
}
return cc = ans;
}
int main() {
cin >> s;
cin >> k;
n = s.size();
memset(dp, -1, sizeof(dp));
cout << dfs() << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll cache[105][2][5];
string s;
ll k;
ll dp(ll n,ll f,ll cnt)
{
if(cnt>k)
return 0;
if(n==s.size())
{
if(cnt==k)
{
return 1;
}
return 0;
}
if(cache[n][f][cnt]!=-1)
return cache[n][f][cnt];
ll m;
if(f==1)
m=9;
else
m=s[n]-'0';
ll ans=0;
for(ll i=0;i<=m;i++)
{
if(i!=0)
{
if(i!=m)
ans+=dp(n+1,1,cnt+1);
else
ans+=dp(n+1,f,cnt+1);
}
else
{
if(i!=m)
ans+=dp(n+1,1,cnt);
else
ans+=dp(n+1,f,cnt);
}
}
return cache[n][f][cnt]=ans;
}
int main()
{
cin>>s;
cin>>k;
memset(cache,-1,sizeof(cache));
cout<<dp(0,0,0);
} |
#include <bits/stdc++.h>
using namespace std;
string n;int ans,k;
int g(int a,int b){
int res=1;
for(int i=0;i<b;i++)res*=a-i;
for(int i=1;i<=b;i++)res/=i;
while(b--)res*=9;
return res;
}
int f(int i,int a){
int res=0,rem=n.size()-i;
if(rem<a)return 0;
if(!a)return 1;
if(n[i]=='0')return f(i+1,a);
return f(i+1,a-1)+(n[i]-'1')*g(rem-1,a-1)+g(rem-1,a);
}
signed main(){
cin>>n>>k;
cout<<f(0,k)<<endl;
}
|
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
typedef long long ll;
string N;
int K;
ll dp[100 + 10][2][4];
int main() {
cin >> N >> K;
dp[0][1][0] = 1;
for (int i = 0; i < N.size(); i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k <= K; k++) {
for (int d = 0; d <= (j ? N[i] - '0' : 9); d++) {
if(d == 0)
dp[i + 1][(!j) ? 0 : ((d == (N[i] - '0')) ? 1 : 0)][k] += dp[i][j][k];
else if(k != K)
dp[i + 1][(!j) ? 0 : ((d == (N[i] - '0')) ? 1 : 0)][k + 1] += dp[i][j][k];
}
}
}
}
cout << dp[N.size()][0][K] + dp[N.size()][1][K] << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
// dp[i][j][k]
// kは0以外の桁数0,1,2,3,4以上の5種類
int dp[120][2][5] = {};
string N;
int K;
cin >> N >> K;
vector<int> n(N.size());
for(int i = 0; i < N.size(); ++i){
n.at(i) = N.at(i) - '0';
}
dp[0][0][0] = 1;
for(int i = 0; i < n.size(); ++i){
for(int j = 0; j < 2; ++j){
for(int k = 0; k < 5; ++k){
for(int x = 0; x <= (j ? 9 : n.at(i)); ++x){
dp[i+1][j || x < n.at(i)][min(k + (x!=0), 4)] += dp[i][j][k];
}
}
}
}
cout << dp[n.size()][0][K] + dp[n.size()][1][K] << endl;
return 0;
} |
#include <algorithm>
#include <iostream>
using namespace std;
const int N = 100, K = 3;
int dp[N + 1][K + 1], dq[N + 1][K + 1];
int main() {
string s; cin >> s;
int n = s.length();
int k; cin >> k;
dp[0][0] = 0;
dq[0][0] = 1;
for (int i = 0; i < n; i++) {
int d = s[i] - '0';
for (int j = 0; j <= k; j++) {
dp[i + 1][j] += dp[i][j];
if (j < k)
dp[i + 1][j + 1] += dp[i][j] * 9;
if (d == 0)
dq[i + 1][j] += dq[i][j];
else {
dp[i + 1][j] += dq[i][j];
if (j < k) {
dp[i + 1][j + 1] += dq[i][j] * (d - 1);
dq[i + 1][j + 1] += dq[i][j];
}
}
}
}
cout << dp[n][k] + dq[n][k] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string N;
cin >> N;
int K;
cin >> K;
int L = N.size();
vector<int> n(L);
for (int i = 0; i < L; i++){
n[i] = N[i] - '0';
}
vector<vector<vector<long long>>> dp(L + 1, vector<vector<long long>>(2, vector<long long>(K + 2, 0)));
dp[0][0][0] = 1;
for (int i = 0; i < L; i++){
for (int j = 0; j < 2; j++){
for (int k = 0; k <= K; k++){
for (int d = 0; d <= (j ? 9 : n[i]); d++){
dp[i + 1][j | d < n[i]][d == 0 ? k : k + 1] += dp[i][j][k];
}
}
}
}
cout << dp[L][0][K] + dp[L][1][K] << endl;
} |
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using ll = long long;
using namespace std;
int dp[102][4][2];
int main(){
string N;
int K;
cin >> N >> K;
int ketasu = N.size();
dp[0][0][0] = 1;//0桁の/非０数が０個の/不確定に１
rep(i, ketasu)rep(j, K+1)rep(k, 2){
int a = N[i] - '0';
int ni = i+1;
rep(d, 10){
int nj = j, nk = k;
if(d != 0) nj++;
if(nj > K) continue;
if(nk == 0){
if(d > a) continue;
if(d < a) nk = 1;
}
dp[ni][nj][nk] += dp[i][j][k];
}
}
cout << dp[ketasu][K][0] + dp[ketasu][K][1] << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)
const int mod = 1000000007;
int dp[105][4][2];
int main(){
string s;
int K;
cin >> s >> K;
int n = s.size();
dp[0][0][0] = 1;
rep(i, n)rep(j, 4)rep(k, 2) {
int nd = s[i] - '0';
rep(d, 10) {
int ni = i + 1, nj = j, nk = k;
if(d != 0) ++nj;
if(nj > K) continue;
if (k == 0) {
if(d > nd) continue;
if(d < nd) nk = 1;
}
dp[ni][nj][nk] += dp[i][j][k];
}
}
int ans = dp[n][K][0] + dp[n][K][1];
cout << ans << endl;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
string s;cin >> s;
int K;cin >> K;
int n=s.size();
ll dp[n+1][2][K+2];
memset(dp,0,sizeof(dp));
dp[0][0][0]=1;
for(int i=0;i<n;i++){
int p=s[i]-'0';
for(int j=0;j<2;j++){
for(int k=0;k<=K;k++){
for(int l=0;l<=(j?9:p);l++){
dp[i+1][j||(l<p)][k+(l!=0)]+=dp[i][j][k];
}
}
}
}
cout << dp[n][0][K]+dp[n][1][K] << endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long llint;
// dp[決めた桁数][N未満][0でない数字が何個あるか]
llint dp[111][2][5];
int main() {
string s;
int k, n;
cin >> s >> k;
n = s.size();
dp[0][0][0] = 1;
for (int i = 0; i < n; i++) {
int num = s[i] - '0';
for (int j = 0; j < 2; j++) { // N未満かどうか
for (int z = 0; z <= k; z++) { // 0でない数字が何個あるか
for (int d = 0; d <= (j ? 9 : num); d++) {
dp[i + 1][j || (d < num)][z + (d > 0)] += dp[i][j][z];
}
}
}
}
cout << dp[n][0][k] + dp[n][1][k] << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int dp[101][4][2];
int main()
{string s; cin >> s;
int n = s.size();
int K; cin >> K;
dp[0][0][0] = 1;
for (int i = 0; i < n; ++i)
{auto D = s[i] - '0';
for (int j = 0; j <= K; ++j)
{for (int k = 0; k < 2; ++k)
{for (int d = 0; d <= 9; ++d)
{auto j1 = j, k1 = k;
if (d > 0) ++j1;
if (j1 > K) continue;
if (k == 0)
{if (d > D) continue;
if (d < D) k1 = 1;}
dp[i + 1][j1][k1] += dp[i][j][k];}}}}
cout << dp[n][K][0] + dp[n][K][1] << endl;} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define MAX_N 10000
#define MAX_L 100
const int MOD=1e9+7;
int dp[MAX_N+1][2][MAX_L+2];
int main() {
int K,l;
string N;
cin >> N >> K;
l = N.size();
rep(i,l+1)
rep(j,2)
rep(k,l+1)
dp[i][j][k] = 0;
dp[0][0][1] = 1;
rep(i,l) {
int x = N.at(i)-'0';
rep(j,2)
rep(k,l+2)
rep(p,(j?9:x)+1)
dp[i+1][j || p<x][k + (p!=0)] += dp[i][j][k];
}
cout << dp[l][0][K+1]+dp[l][1][K+1] << endl;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
string s1;
int n,k;
int a[10001];
int dp[101][2][101][2];
int dfs(int x,int up,int num,int pre)
{
if(x==0)
return num==k;
if(dp[x][up][num][pre]!=-1) return dp[x][up][num][pre];
dp[x][up][num][pre]=0;
// if(pre!=0)
dp[x][up][num][pre]+=dfs(x-1,up&&('0'==s1[x-1]),num,pre);
for(int i=1;i<=9;i++)
{
if(up&&i+'0'>s1[x-1])
break;
dp[x][up][num][pre]+=dfs(x-1,up&&(i+'0'==s1[x-1]),num+1,1);
}
return dp[x][up][num][pre];
}
signed main()
{
cin>>s1>>k;
reverse(s1.begin(),s1.end());
n=s1.length();
memset(dp,-1,sizeof(dp));
printf("%lld",dfs(s1.length(),1,0,0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[110][5][2];
int main(){
ios::sync_with_stdio(0);
cout << setprecision(10) << fixed;
string s;
int k;
cin >> s >> k;
int n = s.size();
dp[0][0][0] = 1;
for (int i = 0; i < n; ++i){
int sd = s[i] - '0';
for (int j = 0; j <= k; ++j){
for (int less = 0; less < 2; ++less){
for (int d = 0; d <= (less ? 9 : sd); ++d){
dp[i + 1][j + (d != 0)][less || (d < sd)] += dp[i][j][less];
}
}
}
}
cout << dp[n][k][0] + dp[n][k][1];
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int dp[105][4][2];
int main() {
string s; cin >> s;
int K; cin >> K;
int n = s.size();
dp[0][0][0] = 1;
rep(i, n)rep(j, 4)rep(k, 2) {
int nd = s[i] - '0';
rep(d, 10) {
int ni = i + 1, nj = j, nk = k;
if (d != 0) nj++;
if (nj > K) continue;
if (k == 0) {
if (nd < d) continue;
if (nd > d) nk = 1;
}
dp[ni][nj][nk] += dp[i][j][k];
}
}
int ans = dp[n][K][1] + dp[n][K][0];
cout << ans << endl;
return 0;
} |
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
string N;
long long dptable[100][4][2];
long long dp(int i, int j, bool adh) {
if (j == 0) return 1;
if (i == N.size()) return 0;
if (dptable[i][j][adh] != -1) return dptable[i][j][adh];
if (adh) return dptable[i][j][adh] = dp(i + 1, j, N[i] == '0') + (N[i] == '0' ? 0 : ((N[i] - '0' - 1) * dp(i + 1, j - 1, false) + dp(i + 1, j - 1, adh)));
else return dptable[i][j][adh] = dp(i + 1, j, adh) + 9 * dp(i + 1, j - 1, adh);
}
int main() {
memset(dptable, -1, sizeof dptable);
int K;
cin >> N >> K;
cout << dp(0, K, true);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<=n;i++)
typedef long long ll;
ll dp[103][2][4];
int main(){
string n;
cin >> n;
int k;
cin >> k;
int l = n.size();
dp[0][0][0] = 1;
for (int i = 0; i < l; ++i) {
int D = n[i] - '0';
for (int smaller = 0; smaller < 2 ; ++smaller) {
for (int j = 0; j <= k ; ++j) {
for (int x = 0; x <= (smaller ? 9 : D) ; ++x) {
int nj = j;
if(x != 0) nj++;
if(nj > k) continue;
dp[i+1][smaller || (x < D)][nj] += dp[i][smaller][j];
}
}
}
}
cout << dp[l][1][k] + dp[l][0][k] << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
string str;
int dp[666][666];
int a[666];int k;
int dfs(int pos,int state,bool lead/*前导零*/,bool limit/*数位上界变量*/){
if(pos==-1) return k==state;
if(!limit && !lead && dp[pos][state]!=-1) return dp[pos][state];
int up=limit?a[pos]:9;
int ans=0;
for(int i=0;i<=up;i++){
ans+=dfs(pos-1,state+((i == 0?0:1)),i==0&&lead,limit&& i==a[pos]);
}
if(!limit && !lead) dp[pos][state]=ans;
return ans;
}
signed main(){
memset(dp,-1,sizeof(dp));
cin>>str>>k;int cnt=0;
for(int i=str.size()-1;i>=0;i--) a[cnt++]=(str[i]-'0');
cout<<dfs(cnt-1,0,true,true);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); ++i)
int dp[110][2][5];
int main() {
string S;
int K;
cin >> S >> K;
int N = S.size();
dp[0][0][0] = 1;
rep(i, N) rep(less, 2) rep(k, 4) {
int x = less ? 9 : S[i] - '0';
rep(d, x + 1) {
dp[i + 1][less || d < x][k + (d > 0)] += dp[i][less][k];
}
}
cout << dp[N][0][K] + dp[N][1][K] << '\n';
return 0;
}
|
#include <iostream>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
ll dp[105][2][5];
int main() {
string s;
cin >> s;
int M;
cin >> M;
int n = s.size();
dp[0][0][0] = 1;
rep(i, n) {
int t = s[i] - '0';
rep(j, 2) for (int k = 0; k <= M; ++k) {
for (int d = 0; d <= (j ? 9 : t); ++d) {
dp[i + 1][j || (d < t)][min(k + (d != 0), M + 1)] += dp[i][j][k];
}
}
}
cout << dp[n][1][M] + dp[n][0][M] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string num, t = "";
int k, n;
long long rec (int j, int cnt) {
if (cnt == k)
return t <= num;
long long res = 0LL;
for (int i = j; i < n; ++i) {
if (t[i] == '0') {
for (char c = '1'; c <= '9'; ++c) {
t[i] = c;
res += rec(i + 1, cnt + 1);
t[i] = '0';
}
}
}
return res;
}
signed main () {
cin >> num >> k;
n = num.size();
t = string(n, '0');
cout << rec(0, 0) << '\n';
}
|
#include<iostream>
using namespace std;
string N;long K,dp[111][2][4],i,j,k,l,r,c,M;
int main(){
cin>>N>>K;
M=N.size();
dp[0][0][0]=1;
for(i=0;i<M;i++){
for(j=0;j<2;j++){
r=j?9:N[i]-'0';
for(k=0;k<=K;k++){
for(l=0;l<=r;l++){
c=k+!!l;
if(c<=K)dp[i+1][j||l<r][c]+=dp[i][j][k];
}
}
}
}
cout<<dp[M][0][K]+dp[M][1][K]<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int k;
string s;
string t;
int Rec(int i = 0, int Last = -1)
{
if(i == k) return t <= s;
int Res = 0;
for(int j = Last + 1; j < s.size(); j++)
{
if(t[j] == '0')
{
for(int r = 1; r < 10; r++)
{
t[j] = r + '0';
Res += Rec(i + 1, j);
t[j] = '0';
}
}
}
return Res;
}
int main()
{
cin >> s >> k;
t = string(s.size(), '0');
cout << Rec() << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
string s;
int ln,k;
ll fun(int id,int ch,int k)
{
ll ans=0;
int vl=s[id]-'0';
if(k==0) return 1;
if(k<0 || id>=ln) return 0;
if(ch && !vl) ans=fun(id+1,1,k);
else ans=fun(id+1,0,k);
for(int i=1;i<=9;i++)
{
if(ch)
{
if(i<vl) ans+=fun(id+1,0,k-1);
else if(i==vl) ans+=fun(id+1,1,k-1);
}
else ans+=fun(id+1,0,k-1);
}
return ans;
}
int main()
{
cin>>s>>k;
ln=s.length();
cout<<fun(0,1,k);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int dp[110][5];
string s;
int k, n;
ll dfs(int pos, int num, bool lim){
if(num>k)return 0;
if(pos>=n) return num==k;
if(!lim&&dp[pos][num]!=-1)return dp[pos][num];
ll ret = 0;
int up = lim?s[pos]-'0':9;
for(int i=0; i<=up; ++i){
ret += dfs(pos+1, num+(i!=0), lim&&(i==up));
}
if(!lim)dp[pos][num]=ret;
return ret;
}
int main()
{
cin >> s >> k;
memset(dp, -1, sizeof(dp));
n=s.size();
cout << dfs(0, 0, 1)<<"\n";
} |
#include <bits/stdc++.h>
#define int long long
using namespace std;
string N; int K;
int dp[1000][2][10];
signed main(){
cin>>N>>K;
dp[0][0][0]=1;
int l=N.size();
for(int i=0;i<l;i++){
for(int smaller=0;smaller<2;smaller++){
//smallerが1ならi桁目まではNと一緒
//0ならNよりも小さいことが確定している
for(int j=0;j<=K;j++){
for(int k=0; k<=(smaller ? 9 : N[i]-'0'); k++){
dp[i+1][smaller or (k<(N[i]-'0'))][k==0 ? j : j+1]+=dp[i][smaller][j];
}
}
}
}
cout<<dp[l][0][K]+dp[l][1][K]<<endl;
} |
#include<bits/stdc++.h>
using namespace std;
char n[109];
int k,dp[109][5],limit[109][5];
int main() {
scanf("%s%d",n,&k);
int len=strlen(n);
dp[0][0]=1;
dp[0][1]=n[0]-'0';
limit[0][1]=n[0]=='0'?0:1;
limit[0][0]=n[0]=='0'?1:0;
for(int i=0;i+1<len;i++)
for(int j=0;j<=min(k,i+1);j++) {
dp[i+1][j]+=dp[i][j];
dp[i+1][j+1]+=dp[i][j]*9-limit[i][j]*(9-n[i+1]+'0');
limit[i+1][j]+=(n[i+1]=='0'?limit[i][j]:0);
limit[i+1][j+1]+=(n[i+1]=='0'?0:limit[i][j]);
}
printf("%d\n",dp[len-1][k]);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
string s;
int K;
cin >> s >> K;
int n = s.size();
int dp[n+1][2][K+5];
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for (int i = 0; i < n; ++i) for (int j = 0; j < 2; ++j) for (int k = 0; k < K+1; ++k) {
int lim = j ? 9 : s[i]-'0';
for (int d = 0; d < lim+1; ++d) {
dp[i+1][j || d < lim][k + (d != 0)] += dp[i][j][k];
}
}
cout << dp[n][0][K] + dp[n][1][K] << '\n';
return 0;
}
|
#include<iostream>
using namespace std;
string n;int A,k;
int g(int a,int b){A=6;while(b--)A*=(a-b)*9,A/=b+1;return A/6;}
int f(int i,int a){int A=n.size()-i;return A<a?0:a?n[i]=='0'?f(i+1,a):f(i+1,a-1)+(n[i]-'1')*g(A-1,a-1)+g(A-1,a):1;}
int main(){cin>>n>>k;cout<<f(0,k);}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
string N;int K;ll dp0[1010][5],dp1[1010][5];
cin >> N >> K;
dp0[1][0] = 1; dp0[1][1] = (N[0]-'0') - 1; dp0[1][2] = 0; dp0[1][3] = 0;
dp1[1][0] = 0; dp1[1][1] = 1; dp1[1][2] = 0; dp1[1][3] = 0;
for(int i = 2; i <= N.size();i++){
dp0[i][0] = dp0[i-1][0];
for(int j = 1; j <= K; j++){
dp0[i][j] = dp0[i-1][j-1] * 9 + dp0[i-1][j] + dp1[i-1][j-1]*max(N[i-1]-'0'-1,0)+dp1[i-1][j]*((N[i-1]-'0'>0));
dp1[i][j] = dp1[i-1][j-1]*min(N[i-1]-'0',1)+dp1[i-1][j]*(((N[i-1]-'0')==0)?(1):(0));
}
}
cout << (dp0[N.size()][K]+dp1[N.size()][K]);
return 0;
} |
#include<bits/stdc++.h>
#define int long long
using namespace std;
int dp[110][5],dp2[110][5];
signed main(){
string N;
int K;
cin>>N>>K;
dp2[0][0]=1;
for(int i=0;i<N.size();i++){
for(int j=0;j<=K;j++){
dp[i+1][j]=dp[i][j]+(N[i]!='0'?dp2[i][j]:0);
dp2[i+1][j]=(N[i]=='0'?dp2[i][j]:0);
}
for(int j=0;j<K;j++){
dp[i+1][j+1]+=dp[i][j]*9+dp2[i][j]*max(N[i]-'1',0);
dp2[i+1][j+1]+=(N[i]!='0'?dp2[i][j]:0);
}
}
cout<<dp[N.size()][K]+dp2[N.size()][K]<<endl;
} |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <map>
using namespace std;
string n;
int k;
long dp[110][2][9];
int main()
{
cin >> n >> k;
dp[0][1][0] = 1;
for (int i = 0; i < (int)n.size(); ++i) {
for (int j = 0; j < 2; ++j) {
int x = (j ? n[i] - '0' : 9);
for (int a = 0; a <= x; ++a) {
for (int b = 0; b <= k; ++b) {
if (a != 0) dp[i + 1][j && (a == x)][b + 1] += dp[i][j][b];
else dp[i + 1][j && (a == x)][b] += dp[i][j][b];
}
}
}
}
cout << dp[(int)n.size()][0][k] + dp[(int)n.size()][1][k];
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
string N;int K,n;
int nCr(int n,int r){
if(r==1)return n;
if(r==2)return n*(n-1)/2;
if(r==3)return n*(n-1)*(n-2)/6;
return 0;
}
int dp(int i,int k,bool s){
if(k==0)return 1;
else if(i==n)return 0;
if(s)return nCr(n-i,k)*pow(9,k);
else {
if(N[i]=='0')return dp(i+1,k,0);
else return dp(i+1,k,1)+dp(i+1,k-1,1)*(N[i]-'1')+dp(i+1,k-1,0);
}
}
int main(){
cin>>N>>K;
n=N.size();
cout<<dp(0,K,0)<<endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int inf = 1001001001;
int dp[105][4][2];
int main(){
string s;
cin >> s;
int n = s.size();
int K;
cin >> K;
dp[0][0][0] = 1;
rep(i,n)rep(j,4)rep(k,2){
int nd = s[i] - '0';
rep(d,10){
int ni = i+1, nj = j, nk = k;
if (d != 0) nj++;
if (nj > K) continue;
if (k == 0){
if(d > nd) continue;
if(d < nd) nk = 1;
}
dp[ni][nj][nk] += dp[i][j][k];
}
}
int ans = dp[n][K][0]+dp[n][K][1];
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
long long A[200][2][4] = {};
int main() {
string N; cin >> N;
int K; cin >> K;
A[0][0][0] = 1;
for(int i=0; i<N.size(); ++i) {
for(int j=0; j<2; ++j) {
for(int k=0; k<4; ++k) {
int n = (int)(N[i] - '0');
A[i + 1][j | (n > 0)][k] += A[i][j][k];
if(k == 3) continue;
for(int c=1; c<=(j?9:n); ++c) {
A[i + 1][j | (n > c)][k + 1] += A[i][j][k];
}
}
}
}
cout << A[N.size()][0][K] + A[N.size()][1][K] << endl;
} |
#include <bits/stdc++.h>
#define ll long long
#define MAX 205
using namespace std;
string s;
int n, k, a[MAX];
ll f[MAX][MAX];
ll dp(int x, int lim, int cnt){
if(x > n) return cnt == k;
if(f[x][cnt] != -1 && !lim) return f[x][cnt];
ll res = 0;
int h = lim?a[x]:9;
for(int i = 0; i <= h; i++){
res += dp(x+1, lim&&(i==h), cnt+(i>0));
}
if(!lim) f[x][cnt] = res;
return res;
}
int main()
{
memset(f, -1, sizeof(f));
string s;
cin >> s >> k;
n = s.length();
for(int i = 0; i < s.length(); i++){
a[i+1] = s[i]-'0';
}
ll ans = dp(1, 1, 0);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 200005;
string n;
int k;
ll dp[111][4][2];
ll f(int i, int j, int less) {
if(j > k) return 0;
if(i == (int)n.size()) return j == k;
ll &ans = dp[i][j][less];
if(~ans) return ans;
ans = 0;
if(less) {
return ans = f(i + 1, j, less) + f(i + 1, j + 1, less) * 9;
}
else {
int dig = int(n[i] - '0');
for(int d = 0; d <= dig; d++) {
ans += f(i + 1, j + !!d, d < dig);
}
}
return ans;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> k;
cout << f(0, 0, 0) << endl;
}
|
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
using ll = long long;
ll dp[110][2][110];
int main() {
string N;
int K;
cin >> N >> K;
memset(dp, 0, sizeof(dp));
dp[0][1][0] = 1;
for(int n = 0; n < N.size(); ++n) {
for(int limited : {0, 1}) {
int limit = (limited ? N[n] - '0' : 9);
for(int i = 0; i <= limit; ++i) {
for(int k = 0; k <= N.size(); ++k) {
int add = i != 0 ? 1 : 0;
dp[n + 1][limited && (i == limit)][k + add] += dp[n][limited][k];
}
}
}
}
ll result = dp[N.size()][0][K] + dp[N.size()][1][K];
cout << result << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
string n;int A,k;
int g(int a,int b){A=6;while(b--)A*=(a-b)*9,A/=b+1;return A/6;}
int f(int i,int a){int A=n.size()-i;return (A<a?0:!a?1:n[i]=='0'?f(i+1,a):f(i+1,a-1)+(n[i]-'1')*g(A-1,a-1)+g(A-1,a));}
int main(){cin>>n>>k;cout<<f(0,k);}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double dd;
const int N = 2e5+5;
const double eps = 1e-8;
string s;
int k;
int dp[105][5][2];
int main(){
// freopen("input.txt","r",stdin);
cin>>s>>k;
dp[0][0][0] = 1;
for(int i = 0;i < s.size();i++){
for(int j = 0;j <= k;j++){
int nd = s[i] - '0';
for(int m = 0;m < 2;m++){
for(int n = 0;n < 10;n++){
int nj = j,nk = m;
if(n != 0) nj++;
if(nj > k) continue;
if(m == 0){
if(n > nd) continue;
if(n < nd) nk = 1;
}
dp[i+1][nj][nk] += dp[i][j][m];
}
}
}
}
cout<<dp[s.size()][k][0]+dp[s.size()][k][1]<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
string a;
int k,n;
long long dp[102][2][100000];
long long solve(int pos,int tight,int cnt){
if(cnt>k) return 0;
if(n==pos) return (cnt==k)?1:0;
if(dp[pos][tight][cnt]!=-1) return dp[pos][tight][cnt];
long long ret=0;
for(int i=0;i<10;i++){
if(tight&&i>a[pos]-'0') break;
int nxt_cnt=cnt+(i>0);
int nxt_tight=tight&&i==(a[pos]-'0');
ret+=solve(pos+1,nxt_tight,nxt_cnt);
}
return dp[pos][tight][cnt]=ret;
}
int main()
{
cin>>a>>k;
n=a.size();
memset(dp,-1,sizeof(dp));
cout<<solve(0,1,0);
}
|
#include<bits/stdc++.h>
using namespace std;
char s[200];
int f[200][4],b[4]={1,9,81,729};
int c(int n,int m){
if(m>n)return 0;
int ans=1;
for(int i=1;i<=m;i++)ans*=n-i+1;
for(int i=1;i<=m;i++)ans/=i;
return ans;
}
int main(){
int k;scanf("%s%d",s,&k);
int l=strlen(s);
f[l][0]=1;
for(int i=l-1;~i;i--){
int x=s[i]-'0';
f[i][0]=1;
for(int j=1;j<=k;j++){
if(x==0)f[i][j]=f[i+1][j];
else f[i][j]=f[i+1][j-1]+(x-1)*c(l-i-1,j-1)*b[j-1]+c(l-i-1,j)*b[j];
}
}
printf("%d",f[0][k]);
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
#define fst first
#define scd second
long long dp[101][5][2];
int main()
{
string n;
int k;
cin >> n >> k;
dp[0][0][1] = 1;
for(int i = 0; i < n.size(); ++i)
{
for(int j = 0; j <= k; ++j)
{
for(int l = 0; l < 2; ++l)
{
for(int m = (l ? n[i] - '0' : 9); m > 0; --m)
{
dp[i + 1][j + 1][l & (m == n[i] - '0')] += dp[i][j][l];
}
dp[i + 1][j][l & (0 == n[i] - '0')] += dp[i][j][l];
}
}
}
cout << dp[n.size()][k][0] + dp[n.size()][k][1] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
int dp[110][2][4];
int seen[110][2][4];
string digit;
int k;
int solve(int id, int can, int cnt)
{
if(cnt > k) return 0;
if(id == digit.size())
return cnt == k;
if(seen[id][can][cnt]) return dp[id][can][cnt];
int num = digit[id] - '0';
int ans = 0;
for(int i = 0; i < 10; i++)
if(can or i <= num)
ans += solve(id + 1, can or i < num, cnt + (i > 0));
seen[id][can][cnt] = true;
return dp[id][can][cnt] = ans;
}
int32_t main()
{
cin >> digit >> k;
cout << solve(0, 0, 0) << '\n';
return 0;
} |
// E - Almost Everywhere Zero
#include <bits/stdc++.h>
using namespace std;
#define rp(i,s,e) for(int i=(s);i<(e);++i)
string N;
int K;
int lt = 0, eq = 1;//lt: <, eq: =
int dp[100+1][2][4+1];// digit DP, [|N|+1: 1 origin][lt|eq][k:0~3]
int main(){
cin>>N>>K;
int dn = N.size();
dp[0][eq][0] = 1;
rp(i,0,dn){
int di = N[i] - '0';
rp(k,0,K+1){
dp[i+1][lt][k] = dp[i][lt][k] * 1 + dp[i][eq][k] * (di?1:0);
if(k) dp[i+1][lt][k] += dp[i][lt][k-1] * 9 + dp[i][eq][k-1] * max(0,di-1);
if(dp[i][eq][k]) dp[i+1][eq][k+(di>0)] = 1;
}
}
cout<< dp[dn][lt][K] + dp[dn][eq][K] <<endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define rep(i,n) for(ll i=0;i<(ll)n;i++)
ll dp[110][2][5];
int main(){
string s; cin >> s;
int n = s.size();
ll K; cin >> K;
dp[0][0][0]=1;
rep(i,n){
int D = s[i]-'0';
rep(j,2){
rep(k,K+1){
for(int d=0;d<=(j ? 9:D);d++){
dp[i+1][j | (d<D)][k + (d>0)] += dp[i][j][k];
}
}
}
}
cout << dp[n][0][K]+dp[n][1][K] << endl;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i=0; i<n; i++)
#define pb push_back
#define int long long
string N;
int K;
int dp[110][3][5];
signed main() {
cin.tie(0); ios::sync_with_stdio(false);
cin >> N >> K;
int L = N.size();
dp[0][0][0] = 1;
rep(i, L) {
int D = N[i]-'0';
rep(j, 2) rep(k, K+1) {
int max_d = j==0 ? D+1:10;
rep(d, max_d) {
int nk = k+(d!=0 ? 1:0);
if (nk>K) continue;
dp[i+1][j|(d<D)][nk] += dp[i][j][k];
}
}
}
cout << dp[L][0][K]+dp[L][1][K] << endl;
} |
#include <iostream>
#include <vector>
#include <string>
#include <memory.h>
using namespace std;
typedef long long ll;
int main(){
string s;
int K;
cin >> s >> K;
int N = s.size();
int dp[N + 1][2][K + 5];
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for (int i = 0; i < N;i++){
for (int j = 0; j < 2;j++){
for (int k = 0; k < K + 1;k++){
int t = j ? 9 : s[i] - '0';
for (int l = 0; l < t + 1;l++){
dp[i + 1][j || l < t][k + (l != 0)] += dp[i][j][k];
}
}
}
}
cout << dp[N][0][K] + dp[N][1][K] << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
string S;
int K;
int dp[2][100+1][5];
signed main() {
//https://atcoder.jp/contests/abc154/tasks/abc154_e
cin >> S >> K;
int n = S.size();
dp[0][0][0] = 1;
for(int i=0; i<n; i++) {
int s = (int)(S[i] - '0');
for(int k=0; k<=K; k++) {
for(int d=0; d<=9; d++) dp[1][i+1][k + (int)(d!=0)] += dp[1][i][k];
for(int d=0; d<s; d++) dp[1][i+1][k + (int)(d!=0)] += dp[0][i][k];
dp[0][i+1][k + (int)(s!=0)] += dp[0][i][k];
}
}
cout << dp[1][n][K] + dp[0][n][K] << endl;
} |
#include<bits/stdc++.h>
using namespace std;
typedef int64_t LL;
LL com(LL m,LL j)
{
switch(j)
{
case 1:return m;
case 2:return m*(m-1)/2;
case 3:return m*(m-1)*(m-2)/6;
default:return 0;
}
}
string S;
int N,K;
LL f(int i,int k,int under)
{
if(k==0)return 1;
if(i==N)return 0;
if(under)return com(N-i,k)*pow(9,k);
else
{
if(S.at(i)=='0')return f(i+1,k,false);
else return f(i+1,k,true)+f(i+1,k-1,true)*(S.at(i)-'1')+f(i+1,k-1,false);
}
}
int main()
{
cin>>S>>K;
N=S.size();
cout<<f(0,K,false)<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
string S;
int K;
int num[1001] = {0};
int keta;
int f(int p,int k){
if(k < 0) return 0;
if(k == 0) return 1;
if(p <= 0) return 0;
return f(p-1,k) + 9*f(p-1,k-1);
}
int solve(){
int sm = 0;
int k = K;
for(int i = keta-1; i > 0; i--){
if(num[i] != 0){
sm += f(i,k) + (num[i]-1)*f(i,k-1);
k--;
}
// if(k < 0) k = 0;
}
if(k == 0){
sm += 1;
}
if(k == 1){
sm += num[0];
}
return sm;
}
int main(){
cin >> S >> K;
keta = S.size();
for(int i = 0; i < S.size(); i++){
num[S.size()-1-i] = S[i] - '0';
}
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int k, l;
int count(int i, bool equal, int nzero) {
if (nzero > k)
return 0;
if (nzero == k)
return 1;
if (i == l)
return 0;
int ans = 0;
for (int d = 0; d < 10; ++d) {
if (equal) {
if (d > s[i] - '0')
continue;
if (d < s[i] - '0')
ans += count(i + 1, false, nzero + (d > 0));
else
ans += count(i + 1, true, nzero + (d > 0));
} else
ans += count(i + 1, false, nzero + (d > 0));
}
return ans;
}
int main() {
cin >> s >> k;
l = s.length();
cout << count(0, 1, 0) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
string S;
int K;
cin >> S >> K;
int N = S.size();
vector<vector<vector<int>>> dp( N + 1, vector<vector<int>>( 2, vector<int>( K + 2 ) ) );
dp[0][0][0] = 1;
for( int i = 0; i < N; i++ ) {
for( int j = 0; j < 2; j++ ) {
int lim = S[i] - '0';
if( j ) lim = 9;
for( int k = 0; k <= K; k++ ) {
for( int x = 0; x <= lim; x++ ) {
int kk = 0;
if( x ) kk = 1;
dp[i + 1][j || x < lim][k + kk] += dp[i][j][k];
}
}
}
}
int ans = dp[N][0][K] + dp[N][1][K];
cout << ans << endl;
}
|
// E - Almost Everywhere Zero
#include <bits/stdc++.h>
using namespace std;
#define rp(i,s,e) for(int i=(s);i<(e);++i)
string N;
int K;
int lt = 0, eq = 1;//lt: <, eq: =
int dp[101][2][4];// digit DP, [|N|+1: 1 origin][lt|eq][k:0~3]
int main(){
cin>>N>>K;
int dn = N.size();
dp[0][eq][0] = 1;
rp(i,0,dn){
int di = N[i] - '0';
rp(k,0,K+1){
rp(dk,0,2){
int ltk = 0, eqk = 0;
if(dk==0) ltk = 1, eqk = di?1:0;
else if(k) ltk = 9, eqk = max(0,di-1);
dp[i+1][lt][k] += dp[i][lt][k-dk] * ltk + dp[i][eq][k-dk] * eqk;
}
if(dp[i][eq][k] & k+(di>0)<4) dp[i+1][eq][k+(di>0)] = 1;
}
}
cout<< dp[dn][lt][K] + dp[dn][eq][K] <<endl;
} |
// E - Almost Everywhere Zero
#include <bits/stdc++.h>
using namespace std;
#define rp(i,s,e) for(int i=(s);i<(e);++i)
string N;
int K;
int lt = 0, eq = 1;//lt: <, eq: =
int dp[100+1][2][4+1];// digit DP, [|N|+1: 1 origin][lt|eq][k:0~3]
int main(){
cin>>N>>K;
int dn = N.size();
dp[0][eq][0] = 1;
rp(i,0,dn){
int di = N[i] - '0';
rp(k,0,4){
dp[i+1][lt][k] = dp[i][lt][k] * 1 + dp[i][eq][k] * (di?1:0);
if(k) dp[i+1][lt][k] += dp[i][lt][k-1] * 9 + dp[i][eq][k-1] * max(0,di-1);
if(dp[i][eq][k]) dp[i+1][eq][k+(di>0)] = 1;
}
}
cout<< dp[dn][lt][K] + dp[dn][eq][K] <<endl;
} |
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
using ll = long long;
#define FOR(i,a,n) for(int i=a;i<n;++i)
#define eFOR(i,a,n) for(int i=a;i<=n;++i)
#define rFOR(i,a,n) for(int i=n-1;a<=i;--i)
#define erFOR(i,a,n) for(int i=n;a<=i;--i)
ll dp[102][2][5];
int main() {
string t; cin >> t;
int n = t.length();
vector<int> s(n);
FOR(i, 0, n)s[i] = t[i] - '0';
int k; cin >> k;
dp[0][0][0] = 1;
FOR(i, 0, n)FOR(small, 0, 2)eFOR(j, 0, k)eFOR(x, 0, (small ? 9 : min(9, s[i]))) {
dp[i + 1][small | (x < s[i])][j + (x != 0)] += dp[i][small][j];
}
cout << dp[n][0][k] + dp[n][1][k] << endl;
} |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
string s;
int k;
int dp[105][2][5];
int rec(int id, int tight, int left) {
if (left < 0) return 0;
if (id == (int)s.size()) return left == 0;
int &ans = dp[id][tight][left];
if (ans != -1) return ans;
ans = 0;
int lim = tight ? s[id] - '0' : 9;
for (int i = 0; i <= lim; i++)
ans += rec(id + 1, (i < s[id] - '0') ? 0 : tight, left - (i > 0));
return ans;
}
signed main() {
ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
cin >> s >> k;
memset(dp, -1, sizeof dp);
cout << rec(0, 1, k);
} |
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
typedef long long ll;
int main(void){
int k,i,j,dp[105][2][4]={};
string n;
cin >> n >> k;
dp[0][1][0]=1;
for (i=0;i<n.size();i++){
dp[i+1][0][0]=1;
for (j=1;j<=3;j++){
if (n[i]!='0') dp[i+1][0][j]+=dp[i][1][j];
dp[i+1][0][j]+=dp[i][0][j-1]*9+dp[i][0][j];
dp[i+1][0][j]+=dp[i][1][j-1]*max(0,n[i]-'0'-1);
if (n[i]=='0') dp[i+1][1][j]=dp[i][1][j];
else dp[i+1][1][j]=dp[i][1][j-1];
}
}
cout << dp[n.size()][0][k]+dp[n.size()][1][k] << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
string s;
int k, ans, sz, t;
int main(){
cin >> s >> k;
sz = s.size();
for(; k; k--){
for(; s[t] == '0'; t++, sz--);
if(sz < k) break;
if(k == 3) ans += (sz - 1) * (sz - 2) * (sz - 3) / 6 * 9 * 9 * 9 + (s[t] - '1') * (sz - 1) * (sz - 2) / 2 * 9 * 9;
else if(k == 2) ans += (sz - 1) * (sz - 2) / 2 * 9 * 9 + (s[t] - '1') * (sz - 1) * 9;
else ans += (sz - 1) * 9 + (s[t] - '0');
t++; sz--;
}
printf("%d\n",ans);
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int k, l;
cin >> k;
l = n.size();
int dp[105][5][2] = {};
dp[0][0][0] = 1;
int d;
for(int i=0; i<l; i++){
d = n.at(i) - '0';
for(int j = 0; j <= k; j++){
for(int smaller = 0; smaller < 2; smaller++){
for(int x = 0; x <= (smaller ? 9 : d); x++){
dp[i+1][x ? j+1 : j][smaller || x < d] += dp[i][j][smaller];
}
}
}
}
cout << dp[l][k][0] + dp[l][k][1] << endl;
} |
#include <iostream>
#include <cstdio>
using namespace std;
int k, n, s;
string a;
int C(int p, int q) {
int i, re = 1;
if (p < q || q < 0) return 0;
for (i = p; i > p - q; i--) re *= i;
for (i = q; i > 1; i--) re /= i;
return re;
}
int pow(int p) {
int re = 1;
while (p > 0) re *= 9, p--;
return re;
}
int main()
{
int i;
cin >> a >> k;
n = a.size();
for (i = 0; i < n && k >= 0; i++) {
if (a[i] > '0') {
s += C(n - i - 1, k) * pow(k) + (a[i] - '1') * C(n - i - 1, k - 1) * pow(k - 1);
k--;
}
}
if (k == 0) s++;
cout << s << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int C(int n, int k) {
double res = 1;
for (int i = 1; i <= k; ++i)
res = res * (n - k + i) / i;
return (int)(res + 0.01);
}
int main() {
string s;
cin >> s;
int n = s.length(), k;
cin >> k;
int ans = C(n, k) * pow(9, k), digits = 0;
for(int i = 0; i < n && k - digits; i++) {
int d = s[i] - '0';
ans -= (9 - d) * C(n - (i + 1), k - digits - 1) * pow(9, k - digits - 1);
if(d != 0) digits++;
}
printf("%d", ans);
} |
#include<bits/stdc++.h>
using namespace std;
int dp[2][100][4], k;
char s[101];
int main()
{
scanf(" %s", s + 1); int len = strlen(s + 1);
scanf("%d", &k);
dp[1][0][0] = 1;
for (int i = 1, c; i <= len; i++)
{
c = s[i] - '0';
for (int j = 0; j <= k; j++)
{
dp[0][i][j] = dp[0][i - 1][j];
if (c) dp[0][i][j] += dp[1][i - 1][j];
if (j) dp[0][i][j] += dp[0][i - 1][j - 1] * 9 + dp[1][i - 1][j - 1] * max(0, c - 1);
if (j || !c) dp[1][i][j] = dp[1][i - 1][j - (c > 0)];
}
}
printf("%d\n", dp[0][len][k] + dp[1][len][k]);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
string N;int K;cin>>N>>K;
vector<vector<long>> DP(N.length(),vector<long>(4,0));
DP[0][0]=1;
DP[0][1]=(int)N[0]-48;
int c=1;
for(int i=1;i<N.length();i++){
DP[i][0]=1;
for(int j=1;j<=3;j++){
DP[i][j]=DP[i-1][j]+DP[i-1][j-1]*9-(c+1==j?9-((int)N[i]-48):0);
}
if((int)N[i]-48!=0)c++;
}
cout<<DP[N.length()-1][K];
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string s;
int n,dp[105][2][5],K;
int main(){
cin>>s>>K;n=s.size();s="$"+s;
for (int i=1;i<=n;i++) s[i]-='0';
dp[0][1][0]=1;
for (int i=1;i<=n;i++){
for(int k=0;k<=K;k++){
if (s[i]==0) dp[i][1][k]+=dp[i-1][1][k],dp[i][0][k]+=dp[i-1][0][k];
else dp[i][0][k]+=dp[i-1][0][k]+dp[i-1][1][k];
for (int j=1;j<10;j++){
if (s[i]<j){
dp[i][0][k+1]+=dp[i-1][0][k];
}
if (s[i]>j){
dp[i][0][k+1]+=dp[i-1][0][k]+dp[i-1][1][k];
}
if (s[i]==j){
dp[i][1][k+1]+=dp[i-1][1][k];
dp[i][0][k+1]+=dp[i-1][0][k];
}
}
}
}
cout<<dp[n][1][K]+dp[n][0][K];
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string s;
int k;
ll dp[101][2][5];
int main() {
cin >> s;
int n = (int)s.size();
cin >> k;
for (int i = 0; i < 101; i++) for (int j = 0; j < 2; j++) for (int l = 0; l < 5; l++) dp[i][j][l] = 0;
dp[0][0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
for (int l = 0; l <= k; l++) {
int lim = j == 1 ? 9 : (s[i] - '0');
for (int m = 0; m <= lim; m++) {
dp[i + 1][j || (m < lim)][l + (m != 0)] += dp[i][j][l];
}
}
}
}
cout << dp[n][0][k] + dp[n][1][k] << endl;
} |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 10;
char s[N];
int a[N];
int f[N][2][4];
int dfs(int pos,int up,int k){
if(k<0) return 0;
if(pos==-1) return k==0;
int &ans = f[pos][up][k];
if(ans!=-1) return ans;
ans = 0;
for(int i=0;i<=(up?a[pos]:9);i++){
ans += dfs(pos-1,up&&i==a[pos],k-(!!i));
}
return ans;
}
int main(){
int k; cin>>s>>k;
int len = strlen(s);
for(int i=0;i<len;i++) a[i] = s[len-i-1]-'0';
// for(int i=0;i<len;i++) cout<<a[i]<<' '; cout<<endl;
memset(f,-1,sizeof(f));
cout<<dfs(len-1,1,k)<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
string N;
int n, k;
ll f[105][2][10];
ll dq(int id, int tight, int cnt) {
if (id == 0)
return (cnt == k);
if (cnt > k)
return 0;
if (f[id][tight][cnt] != -1)
return f[id][tight][cnt];
ll res = 0;
int k = tight ? (N[n - id] - '0') : 9;
for (int i = 0; i <= k; ++i) {
res += dq(id - 1, tight && (i == k), cnt + (i != 0));
}
return (f[id][tight][cnt] = res);
}
int main() {
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> N >> k;
n = N.length();
memset(f, -1, sizeof(f));
cout << dq(n, 1, 0);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
long long dp[120][2][4];
// [iまでの桁][未満フラグ][0ではない値何個あるか]
int main(){
for(int i=0;i<120;i++){
for(int j=0;j<2;j++){
for(int k=0;k<4;k++){
dp[i][j][k]=0;
}
}
}
string n; cin>>n;
int k; cin>>k;
dp[0][0][0]=1;
for(int i=0;i<n.length();i++){
int D=n[i]-'0';
for(int j=0;j<2;j++){
for(int k=0;k<4;k++){
for(int d=0; d<=((j==true)? 9:D); d++){
// d: 最下位の数字として可能なもの
if(k+(d!=0)>3)continue;
dp[i+1][j||(d<D)][k+(d!=0)]+=dp[i][j][k];
}
}
}
}
cout<<dp[n.length()][0][k]+dp[n.length()][1][k]<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s; cin>>s;
int K; cin>>K;int k=K;
int N=s.size();
int64_t ans=0;
for(int i=0;i<N;i++){
int64_t a=s.at(i)-'0';
if(a!=0){
int64_t b=1;
for(int64_t j=1;j<=K;j++)
b=(b*(N-i-j)*9)/j;
if(K!=1){
int64_t c=1;
for(int64_t j=1;j<=K-1;j++)
c=(c*(N-i-j)*9)/j;b+=(a-1)*c;
}
if(K==1){b+=a-1;}ans+=b; K--; if(K==0)break;
}
}for(int i=0;i<N;i++)
if(s.at(i)!='0')k--;
if(k<=0)ans++;
cout<<ans<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define MOD 1000000007
int main() {
string N;
int K;
cin >> N >> K;
long long dp[110][2][5] = {0};
dp[0][0][0] = 1;
for(int i = 0;i < N.size();i++) {
for(int j = 0;j < 2;j++) {
for(int k = 0;k <= K;k++) {
int n = N[i]-'0';
for(int d = 0;d < 10;d++) {
if(d > n && j == 0) continue;
int nk = k;
if(d != 0) nk++;
dp[i+1][j||d < n][nk] += dp[i][j][k];
}
}
}
}
cout << dp[N.size()][0][K]+dp[N.size()][1][K] << endl;
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
constexpr int mod=1e9+7;
signed main(){
int dp[102][2][4]={};
dp[0][0][0]=1;
string n;
int K;
cin>>n>>K;
for(int i=0;i<n.size();i++)
for(int j=0;j<2;j++)
for(int k=0;k<4;k++)
for(int x=0;x<=(j?9:n[i]-'0');x++)
if(k!=3||x==0)
dp[i+1][j||x<n[i]-'0'][k+(x!=0)]+=dp[i][j][k];
cout<<dp[n.size()][0][K]+dp[n.size()][1][K]<<endl;
}
|
#include<bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(n); i++)
#define ll long long
using namespace std;
int main() {
string S; cin>>S;
int N=S.size();
int K; cin>>K;
ll dp[101][2][5];
rep(i, 101) rep(j, 2) rep(k, 5) dp[i][j][k]=0;
dp[0][0][0]=1;
rep(i, N) {
int D=S[i]-'0';
rep(smaller, 2) {
rep(k, K+1) {
for (int d=0; d<=(smaller ? 9 : D); d++) {
if (d!=0) dp[i+1][smaller||(d<D)][k+1]+=dp[i][smaller][k];
else dp[i+1][smaller||(d<D)][k]+=dp[i][smaller][k];
}
}
}
}
cout<<dp[N][0][K]+dp[N][1][K]<<endl;
} |
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int dp[105][2][4];
int main(){
string s;
int x;
cin>>s>>x;
int n=s.size();
dp[0][0][0]=1;
for(int i=0; i<n; ++i){
int D=s[i]-'0';
for(int j=0; j<2; ++j){
for(int k=0; k<=x; ++k){
for(int d=0; d<=(j?9:D); ++d){
if(k+(d!=0)>x)continue;
dp[i+1][j||(d<D)][k+(d!=0)]+=dp[i][j][k];
}
}
}
}
cout<<dp[n][0][x]+dp[n][1][x]<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
long long k;
cin >> s >> k;
long long ans=0, tmp=k;
for(int i=0;i<s.length() && k>0;i++){
if(s[i]!='0'){
long long plus=1;
for(int j=0;j<k;j++){
plus *= 9*(s.length()-i-1-j);
}
for(int j=0;j<k;j++){
plus /= j+1;
}
ans += plus;
plus=1;
for(int j=0;j<k-1;j++){
plus *= 9*(s.length()-i-1-j);
}
for(int j=0;j<k-1;j++){
plus /= j+1;
}
ans += (s[i]-'0'-1)*plus;
k--;
}
}
cout << ans+(k==0?1:0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[105], k, n;
string s;
int f(int p, int k)
{
if (k < 0) return 0;
if (k == 0) return 1;
if (p <= 0) return 0;
return f(p-1, k) + 9*f(p-1,k-1);
}
int solve()
{
int sum = 0;
int kk = k;
for (int i = n - 1; i; i--)
{
if (num[i] != 0)
{
sum += f(i, kk) + (num[i] - 1) * f(i, kk-1);
kk--;
}
}
if (kk == 0) sum++;
if (kk == 1) sum += num[0];
return sum;
}
int main()
{
cin >> s >> k;
n = s.size();
for (int i = 0; i < n; i++)
num[n - 1 - i] = s[i] - '0';
cout << solve();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int64_t a(string &n,int k,int p,bool f){
if(k==0)
return 1;
if(p+k>n.size())
return 0;
if(f){
int64_t x=1;
for(int i=0;i<k;i++)
x*=(n.size()-p-i)*9;
for(int i=k;i>0;i--)
x/=i;
return x;
}
int d=(int)(n.at(p)-'0');
return (d>0?a(n,k-1,p+1,0)+a(n,k-1,p+1,1)*(d-1)+a(n,k,p+1,1):a(n,k,p+1,0));
}
int main(){
string n;
int k;
cin>>n>>k;
cout<<a(n,k,0,0)<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
int dp[105][4][2];
int main() {
string n;
cin >> n;
int l=n.size();
int K;
cin >> K;
dp[0][0][0]=1;
for (int i=0;i<l;i++){
for (int j=0;j<4;j++){
for (int k=0;k<2;k++){
int nd=n[i]-'0';
for (int d=0;d<10;d++){
int ni=i+1,nj=j,nk=k;
if (d!=0)nj++;
if (nj>K)continue;
if (k==0){
if (d<nd)nk=1;
if (d>nd)continue;
}
dp[ni][nj][nk]+=dp[i][j][k];
}
}}}
int ans = dp[l][K][0]+dp[l][K][1];
cout << ans <<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M=110;
char s[M];
int dp[M][5][3];
int main(int argc, char const *argv[])
{
scanf("%s",s+1);
int k;cin>>k;
int len=strlen(s+1);
dp[1][0][0]=1;
dp[0][0][0]=1;
for(int i=1;i<=len;i++){
for(int j=0;j<=3;j++){//j个非零数字
for(int p=0;p<2;p++){//p=0表示一定小于
int num=s[i]-'0';
for(int d=0;d<=9;d++){
int ni=i+1,nj=j,np=p;
if(d!=0)nj++;
if(nj>k)continue;
if(np==0){
if(d>num)continue;
if(d<num)np=1;
}
dp[ni][nj][np]+=dp[i][j][p];
}
}
}
}
cout<<dp[len+1][k][0]+dp[len+1][k][1]<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int dp[102][4][2];
int main(){
string s;
int kp;
cin >> s >> kp;
int n = s.size();
dp[0][0][0] = 1;
for(int i=0; i<n; ++i) for(int j=0; j<4; ++j) for(int k=0; k<2; ++k){
int si = s[i] - '0';
for(int l=0; l<10; ++l){
int nk = k;
if(k == 0){
if(l > si) continue;
if(l < si) nk = 1;
}
if(l==0) dp[i+1][j][nk] += dp[i][j][k];
else if(j<kp) dp[i+1][j+1][nk] += dp[i][j][k];
}
}
int ans = dp[n][kp][0] + dp[n][kp][1];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
string s;
int k;
int dp[501][5][2];
int main(void){
cin >> s;
scanf("%d",&k);
dp[0][0][0]=1;
int n=s.size();
for(int i=0;i<n;i++){
for(int j=0;j<=k;j++){
for(int l=0;l<2;l++){
for(int a=0;a<=9;a++){
if(l==1){
dp[i+1][j+(a!=0?1:0)][l]+=dp[i][j][l];
}else if((s[i]-'0')>a){
dp[i+1][j+(a!=0?1:0)][1]+=dp[i][j][l];
}else if((s[i]-'0')==a){
dp[i+1][j+(a!=0?1:0)][0]+=dp[i][j][l];
}
}
}
}
}
printf("%d\n",dp[n][k][0]+dp[n][k][1]);
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s; cin>>s;
int k; cin>>k;
long long dp[111][2][5]={};
int len=s.size();
dp[0][0][0]=1;
for(int i=0; i<len; ++i)
{
for(int x=0; x<=k; ++x)
{
dp[i+1][1][x+1]+=9*dp[i][1][x];
dp[i+1][1][x]+=dp[i][1][x];
dp[i+1][s[i]>'0'][x]+=dp[i][0][x];
if(s[i]>'0')
{
dp[i+1][1][x+1]+=(s[i]-'1')*dp[i][0][x];
dp[i+1][0][x+1]+=dp[i][0][x];
}
}
}
cout << dp[len][0][k]+dp[len][1][k] << "\n";
} |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
string N;
int K;
int main()
{
cin >> N;
cin >> K;
int ans = 0;
auto A = vector<int>(K+1,0);
int B;
A[0] = 1;
A[1] = N[0] - '0' - 1;
B = 1;
for (unsigned i = 1; i < N.size(); i++) {
auto Ad = vector<int>(K + 1, 0);
int n = N[i] - '0';
Ad[0] = 1;
for (int j = 1; j <= K; j++) {
Ad[j] += A[j - 1] * 9;
Ad[j] += A[j];
}
if (n > 0) {
if (B < K + 1) {
Ad[B] += 1;
}
if (B < K) {
Ad[B + 1] += n - 1;
}
B++;
}
A = Ad;
}
ans = A[K];
if (B == K) { ans++; }
cout << ans << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
string n;
int k;
int dp[105][105][2];
int count(int x,int nz,int t){
if(x==n.size()){
if(nz==k)
return 1;
return 0;
}
if(dp[x][nz][t]!=-1)
return dp[x][nz][t];
int c=0,m=9;
if(t){
m=n[x]-'0';
}
for(int i=0;i<=m;i++){
if(i!=0){
c+=count(x+1,nz+1,(t&&(i==m)?1:0));
}
else
c+=count(x+1,nz,(t&&(i==m)?1:0));
}
return dp[x][nz][t]=c;
}
signed main(){
cin>>n>>k;
memset(dp,-1,sizeof(dp));
cout<<count(0,0,1);
}
|
#include <bits/stdc++.h>
using namespace std;
long cas(string S, long k){
long i, s=S[0]-'0', l=S.size(), m=0; string T="";
if(l<k){ return 0; }
for(i=1; i<l; i++){ if(S[i]!='0'){ T=S.substr(i); break; } }
if(k==1){ return 9*(l-1)+s; }
else{
if(k==3){ m=(s-1)*(l-1)*(l-2)*9*9/2+9*9*3*(l-1)*(l-2)*(l-3)/2; }
else{ m=(s-1)*(l-1)*9+9*9*(l-1)*(l-2)/2; }
return m+cas(T, k-1); }
}
int main(){
string N; long K; cin >> N >> K;
cout << cas(N, K) << "\n";
} |
#include<bits/stdc++.h>
using namespace std;
int main() {
string n;
int k,l,i;
long a;
cin>>n>>k;
a=0;
l=n.length();
if (k==1) a+=9*(l-1)+(n.at(0)-'0');
else if (k==2 && l>=2) {
a+=81*(l-1)*(l-2)/2+(n.at(0)-'1')*9*(l-1);
i=1;
while (i<l && n.at(i)=='0') i++;
if (i<l) a+=9*(l-i-1)+(n.at(i)-'0');
}
else if (k==3 && l>=3) {
a+=729*(l-1)*(l-2)*(l-3)/6+(n.at(0)-'1')*81*(l-1)*(l-2)/2;
i=1;
while (i<l-1 && n.at(i)=='0') i++;
if (i<l-1) {
a+=81*(l-i-1)*(l-i-2)/2+(n.at(i)-'1')*9*(l-i-1);
i++;
while (i<l && n.at(i)=='0') i++;
if (i<l) a+=9*(l-i-1)+(n.at(i)-'0');
}
}
cout<<a<<endl;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.