text stringlengths 49 983k |
|---|
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
const int MAXN = 1000010;
string s;
int prefix[MAXN];
int capacity[MAXN];
int cal(int maxPrefix) {
int maxNumber = maxPrefix - prefix[s.size()];
for (int i = s.size(); i > 0; i--) {
maxNumber = min(maxNumber, maxPrefix - prefix[i]);
capacity[i] = maxNumber / 2;
}
int curPrefix = 0;
int tempMaxPrefix = 0;
int tempMinPrefix = 0;
int counts = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
curPrefix++;
}
else if (s[i] == '0') {
curPrefix--;
}
else {
// ?
if (capacity[i + 1] > counts) {
curPrefix++;
counts++;
}
else {
curPrefix--;
}
}
tempMaxPrefix = max(tempMaxPrefix, curPrefix);
tempMinPrefix = min(tempMinPrefix, curPrefix);
}
return tempMaxPrefix - tempMinPrefix;
}
int main() {
cin >> s;
prefix[0] = 0;
int maxPrefix = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
prefix[i + 1] = prefix[i] + 1;
}
else {
prefix[i + 1] = prefix[i] - 1;
}
maxPrefix = max(maxPrefix, prefix[i + 1]);
}
cout << min(cal(maxPrefix), cal(maxPrefix + 1)) << endl;
} |
#include <iostream>
#include <limits>
using namespace std;
int main() {
string s;
cin >> s;
int maxPrefix = 0, prefix[s.size() + 1];
prefix[0] = 0;
for (int i = 1; i <= s.size(); ++i) {
if (s[i - 1] == '1') {
prefix[i] = prefix[i - 1] + 1;
} else {
prefix[i] = prefix[i - 1] - 1;
}
maxPrefix = max(maxPrefix, prefix[i]);
}
auto solve = [&](int maxPrefix) {
int capacity[s.size() + 1];
for (int i = s.size(), j = numeric_limits<int>::max(); i > 0; --i) {
j = min(j, maxPrefix - prefix[i]);
capacity[i] = j / 2;
}
int sum = 0, tempMaxPrefix = 0, tempMinPrefix = 0, count = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1') {
++sum;
} else if (s[i] == '0') {
--sum;
} else if (capacity[i + 1] > count) {
++sum;
++count;
} else {
--sum;
}
tempMaxPrefix = max(tempMaxPrefix, sum);
tempMinPrefix = min(tempMinPrefix, sum);
}
return tempMaxPrefix - tempMinPrefix;
};
cout << min(solve(maxPrefix), solve(maxPrefix + 1));
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint inf = 1LL << 60;
const lint mod = 1000000007;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
lint ok = n;
lint ng = 0;
auto check = [&](lint mid) {
for (int i = 0; i < 2; ++i) {
int a = i;
int b = mid;
if (a % 2 != b % 2)
b--;
bool ok = true;
for (int j = 0; j < n; ++j) {
if (s[j] == '1') {
a++, b++;
} else if (s[j] == '0') {
a--, b--;
} else {
a--, b++;
}
if (a < 0)
a += 2;
if (b > mid)
b -= 2;
if (a > b) {
ok = false;
break;
}
}
if (ok)
return true;
}
return false;
};
while (abs(ok - ng) != 1) {
lint mid = (ok + ng) / 2;
(check(mid) ? ok : ng) = mid;
}
cout << ok << "\n";
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+50;
char s[N];int n,now,mn[N],mx[N],m,smx[N],smn[N],ans=1e9,mm;
void solve(int x){
int dat=mn[1],sum=0;
for(int i=2;i<=m;i++){
if(smx[i]+sum+2<=x)sum+=2;
dat=min(dat,mn[i]+sum);
}
ans=min(ans,x-dat);
}
int main(){
scanf("%s",s+1);n=strlen(s+1);
for(int i=1,j;i<=n;i++){
if(s[i]=='?'){m++;mn[m]=mx[m]=now;continue;}
j=i;
while(j<n&&s[j+1]!='?')j++;
m++;mn[m]=now;mx[m]=now;
for(int k=i;k<=j;k++){
if(s[k]=='0')now--;
else now++;
mn[m]=min(mn[m],now);
mx[m]=max(mx[m],now);
}
i=j+1;
}
if(s[n]=='?')m++,mn[m]=mx[m]=now;mm=mx[1];
for(int i=2;i<=m;i++)mn[i]-=(i-1),mx[i]-=(i-1),mm=max(mm,mx[i]);
for(int i=1;i<=m;i++)ans=max(ans,mx[i]-mn[i]);
smx[m]=mx[m];
for(int i=m-1;i;i--)smx[i]=max(smx[i+1],mx[i]);
solve(mm);solve(mm+1);cout<<ans;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
string s;
int n,g[1010101],ans;
int sl(int nww)
{
int a=0,b=0,nw=0;
for(int i=1;i<=n;i++)
{
if(s[i]=='?')
{
if(nw+1+g[i+1]<=nww)
{
nw+=1;
}
else
{
nw--;
}
}
else if(s[i]=='1')
{
nw++;
}
else
{
nw--;
}
a=max(a,nw);
b=min(b,nw);
}
return a-b;
}
int main()
{
cin>>s;
n=s.size();
s=' '+s;
for(int i=n;i>=1;i--)
{
if(s[i]=='1')
{
g[i]=max(0,g[i+1]+1);
}
else
{
g[i]=max(0,g[i+1]-1);
}
}
ans=min(sl(g[1]),sl(g[1]+1));
cout<<ans<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define INF int(1e9)
const int maxn=1000005;
int n;
char s[maxn];
bool check(int d){
pair<int,int>val[2]={make_pair(0,d),make_pair(0,d)};
for(int i=0;i<n;i++){
for(int j=0;j<2;j++){
if(val[j].first%2!=j)val[j].first++;
if(val[j].second%2!=j)val[j].second--;
}
pair<int,int>nval[2]={make_pair(INF,-INF),make_pair(INF,-INF)};
for(int c=0;c<2;c++)if(s[i]=='?'||s[i]=='0'+c){
for(int j=0;j<2;j++){
int vl=val[j].first+2*c-1;
int vr=val[j].second+2*c-1;
vl=max(vl,0);
vr=min(vr,d);
if(vl>vr)continue;
nval[j^1].first=min(nval[j^1].first,vl);
nval[j^1].second=max(nval[j^1].second,vr);
}
}
val[0]=nval[0];
val[1]=nval[1];
}
for(int j=0;j<2;j++){
if(val[j].first%2!=j)val[j].first++;
if(val[j].second%2!=j)val[j].second--;
}
return val[0].first<=val[0].second||val[1].first<=val[1].second;
}
int main(){
scanf("%s",s);n=strlen(s);
int l=0,r=n;
while(l<r){
int mid=l+r>>1;
if(check(mid))r=mid;
else l=mid+1;
}
printf("%d\n",r);
return 0;
} |
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#define vll vector<ll>
#define vvvl vector<vvl>
#define vvl vector<vector<ll>>
#define VV(a, b, c, d) vector<vector<d>>(a, vector<d>(b, c))
#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));
#define re(c, b) for(ll c=0;c<b;c++)
#define all(obj) (obj).begin(), (obj).end()
typedef long long int ll;
typedef long double ld;
using namespace std;
int main(int argc, char const *argv[]) {
string s;std::cin >> s;
ll n = s.size();
ll l = 0, r = n;
while(r-l>1){
bool f = false;
ll mid = (l+r)/2;
for(int i=0;i<2;i++){
ll a = i, b = mid;
if(a%2!=b%2) b--;
for(int j=0;j<n;j++){
if(s[j]=='1') a++, b++;
else if(s[j]=='0') a--, b--;
else a--, b++;
if(a<0) a+=2;
if(b>mid) b-=2;
if(b<a) goto nxt;
}
f = true;
nxt:;
}
if(f) r = mid;
else l = mid;
}
std::cout << r << '\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
char s[1000005];
int n,a[1000005],sum,mx[1000005],b[1000005];
int f(int x)
{
int ans=0;
for(int i=1;i<=n;i++)
{
if(s[i]=='?')
{
if(mx[i]+(ans+1)*2<=x)ans++,b[i]=1;
else b[i]=-1;
}
else if(s[i]=='1')b[i]=1;
else b[i]=-1;
}
int anss=b[1];
for(int i=2;i<=n;i++)b[i]+=b[i-1],anss=min(anss,b[i]);
return min(anss,0);
}
int main()
{
scanf("%s",s+1);
n=strlen(s+1);
for(int i=1;i<=n;i++)
if(s[i]=='1')sum++,a[i]=a[i-1]+1;
else sum--,a[i]=a[i-1]-1;
mx[n]=a[n];
for(int i=n-1;i>=1;i--)mx[i]=max(mx[i+1],a[i]);
int z=max(mx[1],0);
printf("%d",min(z-f(z),z+1-f(z+1)));
return 0;
} |
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#define debug(...) fprintf(stderr,__VA_ARGS__)
using namespace std;
template<class T> inline bool Cmax(T &x,T y) {return x<y?x=y,1:0;}
const int maxn=1e6+50;
int n;
int sum[maxn],mx[maxn];
bool mark[maxn];
char S[maxn];
int f(int M) {
static int s[maxn]; s[0]=0;
for(int i=1,cnt=0;i<=n;++i) {
if(mark[i]) {
if(mx[i]+2*(cnt+1)<=M) s[i]=1,++cnt;
else s[i]=-1;
}
else s[i]=S[i]=='0'?-1:1;
}
for(int i=1;i<=n;++i) s[i]+=s[i-1];
return *min_element(s,s+n+1);
}
int main() {
scanf("%s",S+1),n=strlen(S+1);
for(int i=1;i<=n;++i) {
if(S[i]=='?') mark[i]=1;
if(S[i]=='1') sum[i]=sum[i-1]+1;
else sum[i]=sum[i-1]-1;
}
for(int i=n;i>=0;--i) {
mx[i]=sum[i];
if(i!=n) Cmax(mx[i],mx[i+1]);
}
int Z=mx[0];
printf("%d\n",min(Z-f(Z),(Z+1)-f(Z+1)));
return 0;
} |
#define ENABLE_DEBUG 1
// Kana's kitchen {{{
#include<bits/stdc++.h>
#define ALL(v) std::begin(v),std::end(v)
#define LOOP(k) for(i64 ngtkana_is_a_genius=0; ngtkana_is_a_genius<(i64)k; ngtkana_is_a_genius++)
using i32 = std::int_least32_t;
using i64 = std::int_least64_t;
using u32 = std::uint_least32_t;
using u64 = std::uint_least64_t;
using usize = std::size_t;
template <class T, class U> using pair = std::pair<U, T>;
template <class T> using diag_pair = std::pair<T, T>;
template <class... Args> using tuple = std::tuple<Args...>;
template <class T> using vec = std::vector<T>;
template <class T> using numr = std::numeric_limits<T>;
#ifdef NGTKANA
#include<debug.hpp>
#else
#define DEBUG(...)(void)0
#endif
/*}}}*/
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cout << std::setprecision(15) << std::fixed;
std::string s;
std::cin >> s;
i32 l=0, r=s.length();
while (1<r-l) {
i32 mid = (l + r) / 2;
bool ok = false;
for (i32 p=0; p<2; p++) {
i32 a = p, b = mid;
if (p%2!=mid%2) b--;
bool ng = false;
for (char c: s) {
if (c=='0') a++, b++;
if (c=='1') a--, b--;
if (c=='?') a--, b++;
if (a<0) a += 2;
if (mid<b) b -= 2;
if (b<a) {
ng = true;
break;
}
}
if (!ng) {
ok = true;
break;
}
}
(ok ? r : l) = mid;
}
std::cout << r << '\n';
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long li;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
li min_maximum = 0, cur = 0;
vector<li> min_offset(1, 0);
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1') {
cur += 1;
} else {
cur -= 1;
}
min_offset.emplace_back(cur);
min_maximum = max(cur, min_maximum);
}
vector<li> back_max(s.size() + 1, min_offset.back());
for (int i = s.size() - 1; i >= 0; --i) {
back_max[i] = max(back_max[i + 1], min_offset[i]);
}
li ans = s.size();
for (int ub = min_maximum; ub < min_maximum + 2; ++ub) {
li cur = 0, maximum = 0, minimum = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '0') {
cur -= 1;
} else if (s[i] == '1') {
cur += 1;
} else {
if (cur + 1 + max(0LL, back_max[i + 1] - min_offset[i + 1]) > ub) {
cur -= 1;
} else {
cur += 1;
}
}
maximum = max(maximum, cur);
minimum = min(minimum, cur);
}
ans = min(ans, maximum - minimum);
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int dp[20005][100][5];
string s;
int n,k;
int Rec(int index,int zeros,bool flag){
if(zeros > k) return 0;
if(index == n)
return zeros == k;
if(dp[index][zeros][flag] + 1) return dp[index][zeros][flag];
int Res =0;
int Limit = flag?9:s[index];
for(int i =0; i<=Limit; i++){
Res+=Rec(index+1,zeros + (i!=0),!flag && i == s[index]?0:1);
}
return dp[index][zeros][flag] = Res;
}
int main()
{
cin>>s>>k;
n = s.length();
for(int i = 0 ; i<n; i++)
s[i] = s[i]-'0';
memset(dp,-1,sizeof(dp));
cout<<Rec(0,0,0);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
int solve(const string &n, int k) {
int m = n.length();
vector<vector<vector<int>>> dp(m + 1, vector<vector<int>>(2, vector<int>(k + 1, 0)));
dp[0][0][0] = 1;
rep(i, 0, m) {
int d = n[i] - '0';
rep(flag, 0, 2) rep(j, 0, k + 1) rep(l, 0, (flag ? 10 : d + 1)) {
dp[i + 1][flag || (l < d)][(l != 0 ? j + 1 : j)] += dp[i][flag][j];
}
}
return dp[m][0][k] + dp[m][1][k];
}
int main() {
string n;
cin >> n;
int k;
cin >> k;
cout << solve(n, k) << endl;
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) rep(j, 2) for (int k = 0; k <= M; ++k) {
int D = s[i] - '0';
for (int d = 0; d <= (j ? 9 : D); ++d) {
dp[i + 1][j || d < D][min(M + 1, (k + (d != 0)))] += dp[i][j][k];
}
}
cout << dp[n][0][M] + dp[n][1][M] << endl;
return 0;
}
|
#include <algorithm>
#include <string.h>
#include <iostream>
#include <stdio.h>
using namespace std;
const int N = 110;
const int K = 3;
int dp[5][N][K];
int n, k;
char str[N];
int ans;
int dfs(int m, int u, int limit) {
if (u > k)
return 0;
if (m > n)
return (u == k);
if (dp[u][m][limit] != -1)
return dp[u][m][limit];
int t = limit == 1 ? str[m] - '0' : 9, ans = 0;
for (int i = 0; i <= t; i++)
ans += dfs(m + 1, u + (i != 0), limit && i == t);
return dp[u][m][limit] = ans;
}
int main() {
cin >> (str + 1) >> k;
n = strlen(str + 1);
memset(dp, -1, sizeof dp);
cout << dfs(1, 0, 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;
cin >> s;
int n = s.size();
int K;
cin >> K;
dp[0][0][0] = 1;
rep(i,n)rep(j,4)rep(k,2) { //i桁目まで決めて、0以外をj個使って
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;
int main() {
string N; int k;
cin >> N >> k;
int dig = N.size();
int dp0[dig+1][max(dig+1,4)], dp1[dig+1][max(dig+1,4)];
for(int i=0;i<=dig;i++){for(int j=0;j<=max(dig,3);j++){dp0[i][j]=0;dp1[i][j]=0;}}
int n = N[0]-'0';
for(int d=0;d<=9;d++){
dp0[1][d>0] += d<n;
dp1[1][d>0] += d==n;
}
for(int i=1;i<dig;i++){
int n = N[i]-'0';
for(int j=0;j<=i;j++){
for(int d=0;d<=9;d++){
dp0[i+1][j+(d>0)] += dp0[i][j] + (d<n)*dp1[i][j];
dp1[i+1][j+(d>0)] += (d==n)*dp1[i][j];
}
}
}
cout << dp0[dig][k]+dp1[dig][k] << endl;
}
|
#include <bits/stdc++.h>
#define f(i,n) for(int i=0;i<n;i++)
#define P pair<int,int>
#define S second
using namespace std;
int x[1000000];
string s;
int n;
int nCr(int a, int b) {
if (a < b)return 0;
int z = 1;
for (int i = a; i > a - b; i--) {
z *= i;
}
for (int i = 1; i <= b; i++) {
z /= i;
}
return z;
}
int mutu(int x,int y) {
if (y == n)return 1;
if (x >= s.size())return 0;
if (s[x] == '0') {
return mutu(x + 1, y);
}
else {
return nCr((int)s.size() - x - 1, n - y)*pow(9, n - y) + nCr((int)s.size() - x - 1, n - y - 1)*(s[x] - '1')*pow(9, n - y - 1) + mutu(x + 1, y + 1);
}
}
signed main() {
cin >> s >> n;
cout<<mutu(0, 0)<<endl;
} |
#include<cstdio>
#include<cstring>
using namespace std;
char ch[110];
long long n[110],len;
long long k;
long long ans;
long long f[110][4][2];
long long dfs(long long now,long long last,bool check)
{
if(last==k+1)
return 0;
if(now==len+1)
return last==k;
if(f[now][last][check]!=-1)
return f[now][last][check];
long long ret=0,p=check? n[now]:9;
for(long long i=0;i<=p;i++)
ret+=dfs(now+1,last+(i!=0),check&&(i==p));
return f[now][last][check]=ret;
}
int main()
{
scanf("%s",ch+1);
scanf("%lld",&k);
memset(f,-1,sizeof(f));
len=strlen(ch+1);
for(long long i=1;i<=len;i++)
n[i]=ch[i]-'0';
ans=dfs(1,0,1);
printf("%lld\n",ans);
} |
#include <bits/stdc++.h>
#define all(x) begin(x), end(x)
#define _ << ' ' <<
using namespace std;
using ll = long long;
string n;
int k;
int dp[100][4][2];
int f(int i, int r, int s)
{
if (r > k)
return 0;
if (i == n.size())
return r == k;
int& sol = dp[i][r][s];
if (sol != -1)
return sol;
sol = 0;
int d = n[i] - '0';
for (int j = 0; j <= 9; ++j)
{
if (s == 0 && j > d)
continue;
sol += f(i + 1, r + (j != 0 ? 1 : 0), (j < d ? 1 : s));
}
return sol;
}
int main()
{
cin >> n >> k;
memset(dp, -1, sizeof dp);
cout << f(0, 0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
ll dp[110][2][10];
int main() {
string n;
int k;
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++) {
for (int j = 0; j <= 3; j++) {
for (int x = 0; x <= (smaller ? 9 : (int)(n[i] - '0')); x++) {
dp[i + 1][smaller || x < (int)(n[i] - '0')][j + (x != 0)] += dp[i][smaller][j];
}
}
}
}
cout << dp[l][0][k] + dp[l][1][k] << endl;
} |
#include<cstdio>
#include<cstring>
int l,k;
char s[110];
long long dp0[110][4],dp1[110][4];//可能等于、已经小于,第i位，用了j个非零数字
int main()
{
//freopen("test.in","r",stdin);
scanf("%s%d",s,&k);
l=strlen(s);
dp1[0][0]=1;//这一位小于，这一位是0
dp0[0][0]=0;//这一位等于，这一位是0
dp0[0][1]=1;
dp1[0][1]=s[0]-'0'-1;
for(int i=1;i<l;i++)
{
dp1[i][0]=1;//0
for(int j=1;j<=k;j++)
{
if(s[i]=='0')
{
dp0[i][j]=dp0[i-1][j];//只能填一个0
dp1[i][j]=dp1[i-1][j]+dp1[i-1][j-1]*9;
}
else
{
dp0[i][j]=dp0[i-1][j-1];
dp1[i][j]=dp0[i-1][j-1]*(s[i]-'0'-1)+dp0[i-1][j]+dp1[i-1][j]+dp1[i-1][j-1]*9;
}
}
}
printf("%lld\n",dp0[l-1][k]+dp1[l-1][k]);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using PL = pair<ll,ll>;
int main()
{
string s; ll t; cin >> s >> t;
for(auto &i : s) i -= '0';
ll n = s.size();
vector<vector<vector<ll>>> dp(n + 1, vector<vector<ll>>(120, vector<ll>(2)));
dp[0][0][0] = 1;
for(ll i = 0; i < n; i++) {
for(ll j = 0; j < 110; j++) {
for(ll k = 0; k < 2; k++) {
for(ll d = 0; d <= (k ? 9 : s[i]); d++) {
dp[i + 1][j + (d != 0)][k || d < s[i]] += dp[i][j][k];
}
}
}
}
cout << dp[n][t][0] + dp[n][t][1] << endl;
} |
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int a[100],len,K;
long ans=0;
int solve(int k,int s){
if(s==len)return 0;
if(a[s]==0)return solve(k,s+1);
if(k==1)return a[s]+9*(len-1-s);
else if(k==2){
return (len-1-s)*(len-2-s)/2*81
+(len-1-s)*(a[s]-1)*9
+solve(k-1,s+1);
}else if(k==3){
return (len-1-s)*(len-2-s)*(len-3-s)/6*729
+(len-1-s)*(len-2-s)/2*81*(a[s]-1)
+solve(k-1,s+1);
}else return 0;
}
int main(){
string S;
cin>>S>>K;
len=S.length();
for(int i=0;i<len;i++)a[i]=S[i]-'0';
cout<<solve(K,0);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=205;
int p,n;
char s[N];
ll dp[N][4][2];
int main()
{
scanf("%s",s+1);
scanf("%d",&p);
int n=strlen(s+1);
dp[0][0][1]=1;
for(int i=1;i<=n;i++)
for(int j=0;j<=3;j++)
for(int k=0;k<=1;k++)
{
int up=k?s[i]-'0':9;
if(j==p) up=0;
for(int h=0;h<=up;h++)
dp[i][j+(h!=0)][k&&(h==up)]+=dp[i-1][j][k];
}
printf("%lld\n",dp[n][p][0]+dp[n][p][1]);
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); i++)
int dp[110][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 dp[110][2][110];
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 j=0;j<2;++j){
for(int k=0;k<l;++k){
for(int d=0;d<=(j ? 9:D);++d){
dp[i+1][j||(d<D)][d==0 ? k:(k+1)] += dp[i][j][k];
}
}
}
}
cout << dp[l][0][K] + dp[l][1][K] << endl;
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[101][2][4];// digit DP, [|N|+1: 1 origin][lt|eq][k:0~3]
int main(){
cin>>N>>K;
N = "0" + N;
int dn = N.size();
int di = N[0] - '0';
dp[0][eq][0] = 1;
rp(i,1,dn){
di = N[i] - '0';
rp(k,0,4){
// lt
dp[i][lt][k] = dp[i-1][lt][k] * 1 + dp[i-1][eq][k] * (di?1:0);
if(k) dp[i][lt][k] += dp[i-1][lt][k-1] * 9 + dp[i-1][eq][k-1] * max(0,di-1);
// eq
if(dp[i-1][eq][k]) dp[i][eq][k+(di>0)] = 1;
}
}
cout<< dp[dn-1][lt][K] + dp[dn-1][eq][K] <<endl;
} |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
string s; int p;
cin >> s >> p;
for(auto &i : s)i -= '0';
int n = s.size();
vector<vector<vector<ll>>> dp(n + 1, vector<vector<ll>>(110, vector<ll>(2))); //i桁目まで見て0がjこでフラグがk;
dp[0][0][0] = 1;
for(int i = 0; i < n; i++) {
for(int j = 0; j < 105; j++) {
for(int k = 0; k < 2; k++) {
for(int d = 0; d <= (k ? 9 : s[i]); d++) {
dp[i + 1][j + (d != 0)][k || d < s[i]] += dp[i][j][k];
}
}
}
}
cout << dp[n][p][0] + dp[n][p][1] << endl;
} |
#include <bits/stdc++.h>
int ri() {
int n;
scanf("%d", &n);
return n;
}
int main() {
std::string s;
std::cin >> s;
for (auto &i : s) i -= '0';
int n = s.size();
int num = ri();
int dp[n + 1][num + 1][2];
memset(dp, 0, sizeof(dp));
dp[0][0][1] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= num; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l <= (k ? s[i] : 9); l++) {
if (l && j == num) continue;
int &target = dp[i + 1][j + !!l][k && l == s[i]];
target += dp[i][j][k];
}
}
}
}
printf("%d\n", dp[n][num][0] + dp[n][num][1]);
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
long long f(string s, int k) {
int n = s.length();
if (n < k) return 0;
if (s[0] == '0') return f(s.substr(1), k);
if (k == 1)
return s[0] - '0' + 9 * (n - 1);
long long res = f(s.substr(1), k - 1);
if (k == 2)
res += (s[0] - '1') * 9 * (n - 1) + 81 * (n - 1) * (n - 2) / 2;
else
res += (s[0] - '1') * 81 * (n - 1) * (n - 2) / 2 + 243 * (n - 1) * (n - 2) * (n - 3) / 2;
return res;
}
int main() {
string s;
cin >> s;
int k;
scanf("%d", &k);
long long ans = f(s, k);
printf("%lld\n", ans);
return 0;
} |
#include <iostream>
#include <string>
using namespace std;
using ll = long long;
ll dp[110][2][110];
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
string s;
int K;
cin >> s >> K;
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 < K+5; ++k){
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;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;
int K;
cin>>S>>K;
int L=S.size();
vector<vector<int>> dp(L+2,vector<int>(K+1));
int X=0;
for(int i=0;i<L;i++){
int A=S[i]-'0';
for(int j=0;j<K;j++){
dp[i+1][j+1]=dp[i][j+1]+9*dp[i][j];
}
dp[i+2][0]=1;
if(A){
X++;
if(X<=K){
dp[i+1][X]+=A-1;
dp[i+1][X-1]++;
}
}
}
if(X>=K){
dp[L][K]++;
}
cout<<dp[L][K]<<endl;
} |
#include<bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, a) for (int i = 0; i < (int)(a); ++i)
i64 solve(string s, int K) {
i64 dp[102][2][5][2] = {1};
rep(i, s.size()) rep(j, 2) rep(k, 4) rep(l, 2) {
int lim = j ? 9 : s[i] - '0';
rep(d, lim + 1) {
dp[i+1][j || d < lim][k + (d != 0)][l || d != 0] += dp[i][j][k][l];
}
}
i64 ans = 0;
rep(j, 2){
//cerr << dp[s.size()][j][K][1] << endl;
ans += dp[s.size()][j][K][1];
}
return ans;
}
int main(){
string s;
cin >> s;
int k;
cin >> k;
cout << solve(s, k) << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int n, k, dp[5][105][3];
char s[105];
int dfs(int use, int m, int lim) {
if (use > k) return 0;
if (m > n) return use == k;
if (dp[use][m][lim] != -1) return dp[use][m][lim];
int ans = 0;
int up = lim == 1 ? s[m] - '0' : 9;
for (int i = 0; i <= up; i++)
ans += dfs(use + (i != 0), m + 1, lim and i == up);
return dp[use][m][lim] = ans;
}
int main() {
cin >> (s + 1) >> k;
n = strlen(s + 1);
memset(dp, -1, sizeof dp);
cout << dfs(0, 1, 1);
} |
#include <bits/stdc++.h>
using namespace std;
int k=0,res=0;
string n="";
int dp[101][4][2];
int main()
{
cin >> n >> k;
dp[0][0][0] = 1;
for (int i=0; i<n.size(); i++)
{
int x = (n[i]-'0');
for (int j=0; j<4; j++)
{
for (int s=0; s<2; s++)
for (int l=0; l<10; l++)
{
int ni=i+1,nj=j, ns=s;
if (l!=0)
nj++;
if (nj>k)
continue;
if (ns==0)
{
if (l>x)
continue;
if (l<x)
ns = 1;
}
dp[ni][nj][ns]+=dp[i][j][s];
}
}
}
cout << dp[n.size()][k][0]+dp[n.size()][k][1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k;
cin >> k;
int l = s.size();
vector<int> n(l);
for(int i = 0; i < l; i++) n.at(i) = s.at(i) - '0';
int dp[110][2][110];
dp[0][0][0] = 1;
for(int i = 0; i < l; i++){
for(int sma = 0; sma < 2; sma++){
for(int j = 0; j <= k; j++){
for(int x = 0; x <=(sma ? 9: n.at(i)); x++){
if(x == 0) dp[i+1][sma || x < n.at(i)][j] += dp[i][sma][j];
else dp[i+1][sma || x < n.at(i)][j+1] += dp[i][sma][j];
}
}
}
}
cout << dp[l][0][k] + dp[l][1][k] << endl;
} |
#include <cstdio>
#include <algorithm>
#include <cstring>
long long dp[110][2][4];
int main()
{
char s[110];
int k;
scanf("%s%d", &s, &k);
int n = strlen(s);
dp[0][0][0] = 1;
for (int i = 0; i < n; ++i)
{
for (int less = 0; less < 2; ++less)
{
const int D = s[i] - '0';
for (int j = 0; j < k; ++j)
{
for (int d = 0; d <= (less ? 9 : D); ++d)
{
dp[i + 1][(less || d < D)][j + (d == 0 ? 0 : 1)] += dp[i][less][j];
}
}
dp[i + 1][less || 0 < D][k] += dp[i][less][k];
}
}
printf("%lld\n", dp[n][0][k] + dp[n][1][k]);
}
|
#include <iostream>
int solve(int a, std::string str, int k){
int m = str[str.length()-a] - '0';
if(a < k) return 0;
if(!m) return solve(a-1, str, k);
switch (k) {
case 1:
return m + 9*(a-1); break;
case 2:
return (m-1)*(a-1)*9 + (a-1)*(a-2)/2*81 + solve(a-1, str, 1); break;
case 3:
return (m-1)*(a-1)*(a-2)/2*81 + (a-1)*(a-2)*(a-3)/6*729 + solve(a-1, str, 2); break;
}
}
int main(int argc, char *argv[])
{
std::string s;
int k;
std::cin >> s >> k;
std::cout << solve(s.length(), s, k) << std::endl;
return 0;
}
|
#include <iostream>
#include <bits/stdc++.h>
#define ll long long
using namespace std;
string s;
ll k,dp[110][4][2];
ll Rec(int i , int k , bool isSmaller){
if(k < 0) return 0;
if(i == s.size()) return (k == 0);
if(dp[i][k][isSmaller] != -1) return dp[i][k][isSmaller];
ll Res = 0;
for(char j = '0';j<='9';j++){
if(j <= s[i] || isSmaller) Res+=Rec(i + 1 , j == '0' ? k : k - 1 , j < s[i] ? true : isSmaller);
}
return dp[i][k][isSmaller] = Res;
}
int main()
{
memset(dp , -1 , sizeof(dp));
cin >> s >> k;
cout << Rec(0 , k , 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
char n[N];
int k;
int dp[N][5];
int main() {
scanf("%s", n);
scanf("%d", &k);
int sz = strlen(n);
reverse(n, n + sz);
dp[0][0] = 1;
for(int i = 1; i < sz; ++i) {
dp[i][0] = 1;
for(int j = 1; j <= k; ++j) {
dp[i][j] = dp[i - 1][j] + (9 * dp[i - 1][j - 1]);
}
}
int ans = 0;
for(int i = sz - 1, j = k; i >= 0 and j >= 0; --i, --j) {
if(j == 0) {
ans++;
break;
}
int num = n[i] - '0';
if(num == 0) {
j++;
continue;
}
int l = 1;
if(i == 0) l = 0;
ans += (num - l) * dp[i][j - 1] + dp[i][j];
}
printf("%d\n", ans);
return 0;
}
|
#include <cstdio>
#include <cstring>
char s[100001];int n,k;int f[111][11][2];
int dfs(int cur,int cnt,bool lim)
{
if(cnt>k)return f[cur][cnt][lim]=0;
if(~f[cur][cnt][lim])return f[cur][cnt][lim];
if(cur==n+1)return f[cur][cnt][lim]=(cnt==k);int ans=0;
for(int i=0;i<=(lim?s[cur]-'0':9);++i)ans+=dfs(cur+1,cnt+!!i,lim&&i==s[cur]-'0');return f[cur][cnt][lim]=ans;
}
int main()
{
scanf("%s%d",s+1,&k);n=strlen(s+1);memset(f,-1,sizeof(f));
printf("%d\n",dfs(1,0,true));return 0;
} |
#include<iostream>
using namespace std;
string N;
int K;
long dp[111][2][4];
int main()
{
cin>>N>>K;
dp[0][0][0]=1;
for(int i=0;i<N.size();i++)
{
for(int j=0;j<2;j++)
{
int lim=j?9:N[i]-'0';
for(int k=0;k<=K;k++)
{
for(int l=0;l<=lim;l++)
{
int nk=k+!!l;
if(nk<=K)
{
dp[i+1][j||l<lim][nk]+=dp[i][j][k];
}
}
}
}
}
cout<<dp[N.size()][0][K]+dp[N.size()][1][K]<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[10000][2][5];
string s;
int n,k;
ll f(int len,bool tight,int cnt)
{
if(cnt>k) return 0;
if(len==n) return (cnt==k);
if(dp[len][tight][cnt]!=-1) return dp[len][tight][cnt];
ll ans=0;
for(int i=0;i<10;i++)
{
if(tight && i>(s[len]-'0')) break;
ans+=f(len+1,tight&(s[len]-'0'==i),cnt+(i!=0));
}
return dp[len][tight][cnt]=ans;
}
int main()
{
cin>>s>>k;
n=s.length();
memset(dp,-1,sizeof(dp));
ll ans=f(0,1,0);
cout<<ans<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
string N;
int K;
cin >> N >> K;
vector<vector<long long>> dp(N.size()+1,vector<long long>(5,0));
//dp.at(0).at(0)=1;
int count=0;
for(int i=0;i<N.size();i++){
for(int j=0;j<=K;j++){
if(j>0) dp.at(i+1).at(j)=dp.at(i).at(j) + dp.at(i).at(j-1)*9;
else dp.at(i+1).at(j)=dp.at(i).at(j);
}
if(N.at(i)=='0') continue;
if(count<5) dp.at(i+1).at(count)++;
if(count+1<5) dp.at(i+1).at(count+1)+=(N.at(i)-'0')-1;
count++;
}
if(count==K) dp.at(N.size()).at(K)++;
cout << dp.at(N.size()).at(K) << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <queue>
#include <functional>
#include <iomanip>
using namespace std;
int dp[105][2][5];
int main() {
string s;
int k;
cin >> s >> k;
int n = s.size();
dp[0][0][0] = 1;
for(int i = 0; i < n; ++i){
for(int sm = 0; sm < 2; ++sm){
for(int j = 0; j < k + 1; ++j){
for(int x = 0; x <= (sm ? 9 : s[i]-'0'); ++x){
dp[i + 1][sm || x < (s[i]-'0')][j+(x>0)] += dp[i][sm][j];
}
}
}
}
cout << dp[n][0][k] + dp[n][1][k];
} |
#include<bits/stdc++.h>
using namespace std;
int f(int n,int k){
if(k>n) return 0;
if(k==0) return 1;
if(k==1) return n;
if(k==2) return n*(n-1)/2;
if(k==3) return n*(n-1)*(n-2)/6;
}
int tenth(int k){
int ret = 1;
for(int i=0; i<k; i++) ret*=9;
return ret;
}
int main(){
string s;
int k;
cin>>s>>k;
vector<int>arr(s.length()+1,0);
int n = s.length();
for(int i=0; s[i]; i++){
arr[i+1] = (int)(s[i]-'0');
}
int ret = 0;
for(int i=1; i<=n; i++){
for(int j=0; j<arr[i]; j++){
if(j==0) ret+=tenth(k)*f(n-i,k);
else ret+=tenth(k-1)*f(n-i,k-1);
}
if(arr[i]) k--;
if(k==0){
ret++;
break;
}
}
cout<<ret;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
string s;
cin>>s;
int k;
cin>>k;
string t="$"+s;
int n=s.size();
ll dp1[101][4]={0},dp2[101][4]={0};
dp2[0][0]=1;
for(int i=1; i<=n; i++)
{
int num=t[i]-'0';
if(num==0)
{
dp1[i][0]=1;
dp2[i][0]=0;
for(int j=1; j<=k; j++)
{
dp1[i][j]=dp1[i-1][j]+dp1[i-1][j-1]*9;
dp2[i][j]=dp2[i-1][j];
}
}
else
{
dp1[i][0]=1;
dp2[i][0]=0;
for(int j=1; j<=k; j++)
{
dp1[i][j]=dp1[i-1][j]+dp1[i-1][j-1]*9+dp2[i-1][j]+dp2[i-1][j-1]*(num-1);
dp2[i][j]=dp2[i-1][j-1];
}
}
}
ll ans=dp1[n][k]+dp2[n][k];
cout<<ans;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int dp[100][2][5];
int main(){
string N;
int K;
vector<int> n;
cin >> N >> K;
int l = N.size();
for(auto a : N) n.push_back(a-'0');
dp[0][0][0]=1;
dp[0][1][0]=0;
dp[0][0][1]=0;
dp[0][1][1]=0;
for(int i=0; i<l; i++){
for(int smaller=0; smaller<2; smaller++){
for(int j=0; j<5; j++){
for(int x=0; x <= (smaller ? 9 : n[i]); x++){
dp[i+1][smaller || x<n[i]][x!=0 ? min(4, j+1) : j]+=dp[i][smaller][j];
}
}
}
}
cout << dp[l][0][K]+dp[l][1][K] << endl;
} |
#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):g(A,a--)+g(A,a)*(n[i]-'1')+f(i+1,a):1;}
int main(){cin>>n>>k;cout<<f(0,k);}
|
#include <bits/stdc++.h>
using namespace std;
string n;
int k;
int comb(int n, int k) {
int rv = 1;
for (int i = 0; i < k; i++)
rv *= n--;
while (k)
rv /= k--;
return rv;
}
int g(int free, int k) {
return comb(free, k) * pow(9, k);
}
int f(string n, int k) {
if (k == 0)
return 1;
if (n.size() < k)
return 0;
int init = n[0] - '0';
if (init) {
return f(n.substr(1), k - 1) + (init - 1) * g(n.size() - 1, k - 1)
+ g(n.size() - 1, k);
}
return f(n.substr(1), k);
}
int main() {
cin >> n >> k;
cout << f(n, k) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
int dp[101][2][6];
int main() {
string N;
int K,l;
cin >> N >> K;
l = N.size();
dp[0][0][1] = 1;
rep(i,l) {
int d=N.at(i)-'0';
rep(j,2)
rep(k,K+2)
rep(m,(j?9:d)+1)
dp[i+1][j||m<d][k+(m!=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 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<bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[102][2][5];
int k, sz;
vector<int> v;
ll fun(int pos, int small, int cnt)
{
if(pos==sz) return cnt==k;
if(cnt>k) return 0;
ll& ret = dp[pos][small][cnt];
if(ret!=-1) return ret;
ret = 0;
int lim;
if(small) lim = 9;
else lim = v[pos];
for(int i=0; i<=lim; i++){
ret+=fun(pos+1, small||(i<lim), cnt+(i>0));
}
return ret;
}
int main()
{
memset(dp, -1, sizeof dp);
string str;
cin>>str;
cin>>k;
sz = str.size();
v.resize(sz);
for(int i=sz-1; i>=0; i--)
v[i] = str[i]-'0';
cout<<fun(0,0,0)<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
string S;
int const M = 101;
int dp[M][5][2], K, D, N;
signed main(){
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
cin >> S; cin >> K;
N = S.size();
dp[N][K][0] = dp[N][K][1] = 1;
for(int i = N - 1; i >= 0; i--){
for(int k = K; k >= 0; k--, D = S[i] - '0'){
for(int d = 1; d >= 0; d--){
for(int j = (d) ? D : 9; j >= 0; j--){
dp[i][k][d] += dp[i + 1][min(4ll,k + (j > 0))][d & (j == D)];
}
}
}
}
cout << dp[0][0][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint MOD = 1e9+7;
lint dp[110][110][2];
signed main(){
string s; cin >> s;
lint K; cin >> K;
lint N = s.size();
dp[0][0][0] = 1;
for(lint i = 0; i < N; i++){
for(lint j = 0; j < 100; j++){
for(lint k = 0; k < 2; k++){
if(k == 1){
for(lint l = 0; l < 10; l++){
dp[i + 1][j + (l != 0)][1] += dp[i][j][1];
}
}
if(k == 0){
lint lim = s[i] - '0';
for(lint l = 0; l <= lim; l++){
dp[i + 1][j + (l != 0)][l != lim] += dp[i][j][0];
}
}
}
}
}
cout << dp[N][K][0] + dp[N][K][1] << endl;
} |
#include<bits/stdc++.h>
#define int long long
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
int dp[101][4][2];
string s;
int N,K;
int solve(int I,int k,int f)
{
if( k > K )return 0;
if( I == N)return k==K;
int &ans = dp[I][k][f];
if( ans!=-1 )return ans;
ans=0;
if(f)
{
for(int i=0;i<s[I]-'0';i++)
{
ans+=solve(I+1,k+(i!=0),0);
}
ans+=solve(I+1,k+(s[I]!='0'),1);
}
else
{
for(int i=0;i<10;i++)
ans+=solve(I+1,k+(i!=0),0);
}
return ans;
}
int32_t main()
{
memset(dp,-1,sizeof(dp));
cin >> s >> K; N=s.length();
cout << solve(0,0,1) << 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;
const int INF=0x3f3f3f3f;
const ll INFL=0x3f3f3f3f3f3f3f3f;
const int MOD=1000000007;
ll dp[200][2][5];
int main(){
string s;int K;cin>>s>>K;
dp[0][0][0]=1;
rep(i,s.size())rep(j,2)rep(k,K+1){
int lim=(j?9:s[i]-'0');
for(int t=0;t<=lim;t++){
dp[i+1][j||t<lim][k+(t>0)]+=dp[i][j][k];
}
}
ll ans=0;
rep(i,2){
ans+=dp[s.size()][i][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,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<bits/stdc++.h>
using namespace std;
using ll=long long;
const ll MOD=1e9+7;
const int INF=1e9;
const ll LINF=(ll)1e18;
int main(){
string s;
int k;
cin>>s>>k;
int num=s.size();
ll dp[num+1][2][k+2];
memset(dp,0,sizeof(dp));
dp[0][0][0]=1;
for(int i=0;i<num;i++){
int D=s[i]-'0';
for(int j=0;j<2;j++){
for(int l=0;l<=k;l++){
for(int d=0;d<=(j?9:D);++d){
if(d!=0)dp[i+1][j||(d<D)][l+1]+=dp[i][j][l];
else dp[i+1][j||(d<D)][l]+=dp[i][j][l];
}
}
}
}
cout<<dp[num][0][k]+dp[num][1][k]<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
string S;
int K;
int dp[2][100+1][5];
signed main() {
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;
using i32 = int_fast32_t;
using i64 = int_fast64_t;
string n;
i32 k, l;
i64 com(i64 m, i64 r) {
if (r < 0 || r > m) return 0;
if (r == 0) return 1;
return m * com(m-1, r-1) / r;
}
i64 solve(i32 i, i32 j, bool less) {
if (j == 0) return 1;
if (i == l) return 0;
if (less) return com(l-i, j) * pow(9, j);
if (n[i] == '0') return solve(i+1, j, false);
return solve(i+1, j, true) + solve(i+1, j-1, true) * (n[i] - '1') + solve(i+1, j-1, false);
}
int main() {
cin >> n;
cin >> k;
l = n.size();
cout << solve(0, k, false) << endl;
}
|
#include<iostream>
using namespace std;
int main(){
string N;int K;
cin>>N>>K;
int dp[N.size()+1][2][K+1];
for(int i=0;i<=N.size();i++)for(int j=0;j<=1;j++)for(int k=0;k<=K;k++)dp[i][j][k]=0;
dp[0][0][0]=1;
for(int i=1;i<=N.size();i++){
for(int j=0;j<=1;j++){
for(int k=0;k<=K;k++){
for(int d=0;d<=(j?9:N[i-1]-'0');d++){
if(k==K&&d!=0)continue;
dp[i][j||d<N[i-1]-'0'][k+(!!d)]+=dp[i-1][j][k];
}
}
}
}
cout<<dp[N.size()][0][K]+dp[N.size()][1][K]<<endl;
return 0;
} |
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
typedef long long ll;
int main(void){
int k,i,j,dp[2][105][4]={};
string n;
cin >> n >> k;
dp[1][0][0]=1;
for (i=1;i<=n.size();i++){
dp[0][i][0]=1;
for (j=1;j<=3;j++){
if (n[i-1]!='0') dp[1][i][j]=dp[1][i-1][j-1];
else dp[1][i][j]=dp[1][i-1][j];
dp[0][i][j]+=dp[0][i-1][j]+dp[0][i-1][j-1]*9;
if (n[i-1]!='0') dp[0][i][j]+=dp[1][i-1][j]+dp[1][i-1][j-1]*max(0,n[i-1]-'1');
}
}
cout << dp[0][n.size()][k]+dp[1][n.size()][k] << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, m;
cin >> s >> m;
n = s.length();
long long dp[110][2][5] = {0};
dp[0][0][0] = 1;
for (int i = 0; i < n; i++) {
const int c = s[i] - '0';
for (int j = 0; j < 2; j++) {
for (int k = 0; k <= m; k++) {
for (int d = 0; d <= (j ? 9 : c); d++) {
dp[i+1][j || (d < c)][(d == 0) ? k : k+1] += dp[i][j][k];
}
}
}
}
long long ans = dp[n][0][m] + dp[n][1][m];
cout << ans << endl;
return 0;
} |
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>
#include <unordered_set>
#include <map>
#include <numeric>
#include <algorithm>
using namespace std;
int dp[101][2][5] = {};
int main() {
std::string N;
int K;
std::cin >> N >> K;
int L = N.size();
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) {
const int D = j ? 9 : N[i] - '0';
for (int d = 0; d <= D; ++d) {
dp[i+1][j || (d < D)][k + (d != 0)] += dp[i][j][k];
}
}
}
}
std::cout << dp[L][0][K] + dp[L][1][K] << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string n;int ans,k;
int g(int a,int b){
int res=6;
while(b--)res*=(a-b)*9,res/=b+1;
return res/6;
}
int f(int i,int a){
int rem=n.size()-i;
return (rem<a?0:!a?1:n[i]=='0'?f(i+1,a):f(i+1,a-1)+(n[i]-'1')*g(rem-1,a-1)+g(rem-1,a));
}
int main(){
cin>>n>>k;
cout<<f(0,k)<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> vec;
typedef vector<vec> mat;
int main(){
string n;
int k,x;
cin>>n>>k;
ll dp[1000][2][4];
dp[0][0][0]=1;
rep(i,n.size())rep(j,2)rep(k,4){
if(j==1) x=9;
else x=n[i]-'0';
rep(l,x+1) if(k+(l!=0)<4) dp[i+1][j||l<x][k+(l!=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++)
using namespace std;
int k;
string s;
int memo[100][2][4];
int dfs(int i,bool smaller,int c){
if(i==s.length()) return c==k?1:0;
if(c>k) return 0;
if(memo[i][smaller][c]!=-1) return memo[i][smaller][c];
int res=0;
if(smaller){
rep(d,10){
res+=dfs(i+1,true,c+(d==0?0:1));
}
}
else{
rep(d,s[i]-'0'+1){
res+=dfs(i+1,d<s[i]-'0',c+(d==0?0:1));
}
}
memo[i][smaller][c]=res;
return res;
}
int main(){
memset(memo,-1,sizeof memo);
cin>>s>>k;
cout<<dfs(0,false,0)<<'\n';
return 0;
}
|
#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<N.size();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;
typedef long long ll;
ll dp[105][4][2];
int main(){
string n;
int K;
cin >> n >> K;
int digit = n.size();
dp[0][0][0] = 1;
for(int i=0;i<digit;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) continue;
if(d<nd) nk=1;
}
dp[ni][nj][nk] += dp[i][j][k];
}
}
}
}
cout << dp[digit][K][1]+dp[digit][K][0] << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
string N;
int K;
cin >> N >> K;
int sz = N.size();
static int64_t dp[102][5][2];
dp[0][0][0] = 1;
for(int i=0; i<sz; i++) for(int j=0; j<=K; j++) for(int k=0; k<2; k++){
for(int l=0; l<10; l++){
int c = N[i]-'0';
if(k == 0 && l > c) continue;
dp[i+1][j+(l>0)][k|(l<c)] += dp[i][j][k];
}
}
int64_t ans = 0;
for(int k=0; k<2; k++) ans += dp[sz][K][k];
cout << ans << endl;
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[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){
dp[i+1][lt][k] += dp[i][lt][k-dk] * (dk? (k?9:0): 1);
dp[i+1][lt][k] += dp[i][eq][k-dk] * (dk? (k?max(0,di-1):0): (di?1:0));
}
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;
} |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(int)(n); i++)
using namespace std;
typedef long long LL;
typedef pair<int,int> P;
int main(){
string N;
cin >> N;
int s=N.size();
int K;
cin >> K;
int dp0[110][5]={0}, dp1[110][5]={0};
dp0[0][0]=1;
rep(i,s){
int n=N[i]-'0';
rep(j,4){
if(n!=0){
dp0[i+1][j+1]+=dp0[i][j];
dp1[i+1][j]+=dp0[i][j]+dp1[i][j];
dp1[i+1][j+1]+=dp0[i][j]*(n-1)+dp1[i][j]*9;
}
else{
dp0[i+1][j]+=dp0[i][j];
dp1[i+1][j]+=dp1[i][j];
dp1[i+1][j+1]+=dp1[i][j]*9;
}
}
}
cout << dp0[s][K]+dp1[s][K] << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
#define mp make_pair
const int maxn=100;
int n,m;
char a[maxn+5];
int dfs(int k,int num,bool flag=true)
{
if(k>n)
{
if(num==0) return 1;
return 0;
}
int ans=dfs(k+1,num,flag&&a[k]==0);
if(num>0)
{
int limit=flag?a[k]:9;
if(limit>=1)
{
ans+=(limit-1)*dfs(k+1,num-1,0);
ans+=dfs(k+1,num-1,flag);
}
}
return ans;
}
int main()
{
scanf("%s",a+1);
n=strlen(a+1);
scanf("%d",&m);
for(int i=1;i<=n;++i) a[i]-='0';
cout<<dfs(1,m)<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int DP[110][5][5];
int main()
{
int N,K;
string S;
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++)
{
if(S[i]=='0'){
DP[i+1][j][1]+=DP[i][j][1];
DP[i+1][j][0]+=DP[i][j][0];
DP[i+1][j+1][0]+=DP[i][j][0]*9;
}
else
{
DP[i+1][j][0]+=DP[i][j][1]+DP[i][j][0];
for(int _=1;_<10;_++)
DP[i+1][j+1][0]+=DP[i][j][0];
for(int _=1;_<S[i]-'0';_++)
DP[i+1][j+1][0]+=DP[i][j][1];
DP[i+1][j+1][1]+=DP[i][j][1];
}
}
cout<<DP[N][K][1]+DP[N][K][0]<<endl;
return 0;
} |
#include <iostream>
#include <vector>
#include <string>
int main()
{
std::string n;
int k;
std::cin >> n >> k;
long long dp[102][2][5] = {};
dp[0][0][0] = 1;
const int L = n.length();
for (int i = 0; i < L; ++i)
{
const int D = n[i] - '0';
for (int j = 0; j < 2; ++j)
{
for (int nonzero = 0; nonzero < (k + 1); ++nonzero)
{
for (int d = 0; d <= (j ? 9 : D); ++d)
{
dp[i + 1][j || d != D][(d == 0 ? nonzero : nonzero + 1)] += dp[i][j][nonzero];
}
}
}
}
std::cout << (dp[L][0][k] + dp[L][1][k]) << std::endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string N;
int K;
ll dp[101][2][5];
ll solve(int pos = 0, bool tight = true, int ck = 0)
{
if (ck > K) {
return 0;
}
if (pos == N.size()) {
return ck == K ? 1 : 0;
}
int digit = N[pos] - '0';
ll& rdp = dp[pos][tight][ck];
if (~rdp) return rdp;
ll res = 0;
for (int i = 0; i <= (tight ? digit : 9); i++) {
res += solve(pos+1, tight && digit == i, i==0 ? ck : ck + 1);
}
return rdp = res;
}
int main()
{
cin >> N>>K;
memset(dp, -1, sizeof(dp));
cout << solve() <<endl;
}
|
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
string s;
ll x, n, lim, d[105][2][5]={1};
int main() {
ll i, j, k, l;
cin >> s >> x;
n = s.size();
for(i=0; i<n; i++) {
for(j=0; j<2; j++) {
lim = (j ? 9 : s[i]-'0');
for(k=0; k<=x; k++) {
for(l=0; l<=lim; l++) {
d[i+1][j||l<lim][k+(l>0)] += d[i][j][k];
}
}
}
}
cout << d[n][0][x] + d[n][1][x];
return 0;
} |
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
typedef long long int llint;
string S;
int K;
llint dp[105][4][2];
int main() {
cin >> S >> K;
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 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 > K)continue;
if (k == 0) {
if (d > nd)continue;
if (d < nd)nk = 1;
}
dp[ni][nj][nk] += dp[i][j][k];
}
}
}
}
cout << dp[N][K][0] + dp[N][K][1] << endl;
} |
// Copyright 2020 yaito3014
#include <bits/stdc++.h>
using namespace std;
int main(){
string N;
int K;
cin >> N >> K;
int len = N.length();
// dp[i][j][smaller]
vector<vector<array<int,2>>> dp(len+1,vector<array<int,2>>(K+1));
for(auto&v:dp)for(auto&w:v)w.fill(0);
dp[0][0][0] = 1;
for(int i = 0; i < len; ++i){
for(int j = 0; j <= K; ++j){
for(auto smaller : { true, false }){
int k_n = smaller?9:N[i]-'0';
for(int k = 0; k <= k_n; ++k){
if(k!=0&&j==K)continue;
dp[i+1][j+(k==0?0:1)][smaller||k<N[i]-'0']
+= dp[i][j][smaller];
}
}
}
}
cout << dp[len][K][0] + dp[len][K][1] << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
vector<int>n;
int dp[109][9][9];
int main(){
string s;
int m;
cin>>s>>m;
int len=s.size();
for(int i=0;i<len;i++){
n.push_back(s[i]-'0');
}
dp[0][0][0]=1;
for(int i=0;i<len;i++){
for(int smaller=0;smaller<2;smaller++){
for(int j=0;j<=m;j++){
for(int x=0;x<=(smaller?9:n[i]);x++){
dp[i+1][smaller||x<n[i]][j+(x!=0)] += dp[i][smaller][j];
}
}
}
}
cout<<dp[len][0][m]+dp[len][1][m]<<endl;
return(0);
}
|
#include <iostream>
using namespace std;
#include <string>
#include <vector>
#include <algorithm>
#include <map>
typedef long long ll;
#include <cmath>
ll sub(string s, int k)
{
//cerr<<"["<<s<<"]"<<k<<endl;
if (k==0) return 1;
if (s=="") return 0;
string _9=string(s.length()-1,'9');
string s1=s.substr(1);
if (s[0]=='0') return sub(s1,k);
ll ret=0;
if (s[0]>'1') ret+=(s[0]-'0'-1)*sub(_9,k-1);
ret+=sub(_9,k);
ret+=sub(s1,k-1);
return ret;
}
int main(int argc, char *argv[])
{
string n;
int k;
ll ret=0;
cin >> n>>k;
ret=sub(n,k);
cout<<ret<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (n); ++i)
#define repr(i, a, b) for (auto i = (a); i < (b); ++i)
#define itr(x) for (auto&& v : (x))
#define updatemax(t, v) ((t) = std::max((t), (v)))
#define updatemin(t, v) ((t) = std::min((t), (v)))
ll dp[101][2][5];
int main() {
string n;
ll k;
cin >> n >> k;
ll nlen = n.size();
dp[0][1][0] = 1;
rep(i, nlen) {
ll x = n[i] - '0';
rep(j, 2) rep(k, 4) rep(l, 10) {
if (j == 1 && l > x) continue;
dp[i + 1][j == 1 && l == x][k + (l > 0)] += dp[i][j][k];
}
}
cout << dp[nlen][0][k] + dp[nlen][1][k] << endl;
}
|
#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
string N; int K, dp[105][2][105];
int main() {
cin >> N >> K;
int lng = N.size(); dp[0][0][0] = 1;
for(int i = 1; i <= lng; ++i) {
int n = N.at(i-1)-'0';
for(int j = 0; j < 2; ++j) {
for(int k = 0; k <= i; ++k) {
for(int d = 0; d <= (j?9:n); ++d) {
dp[i][j||d<n][k+(d>0)] += dp[i-1][j][k];
}
}
}
}
cout << dp[lng][0][K]+dp[lng][1][K] << endl;
} |
#include <iostream>
#include <algorithm>
using namespace std;
string s;
int k,ans;
inline void dfs(int pos,int x,int flag)
{
if(pos==s.size())
{
if(!x) ++ans;
return ;
}
if(!x)
{
++ans;
return ;
}
for(int i='1';i<='9';i++)
{
if(i>s[pos]&&flag) break;
if(i>=s[pos]) dfs(pos+1,x-1,flag);
if(i<s[pos]) dfs(pos+1,x-1,0);
}
dfs(pos+1,x,flag&(s[pos]=='0'));
}
int main(int argc, char** argv) {
cin >> s >> k;
dfs(0,k,1);
cout << ans;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long int64;
int n, k;
int64 dp[105][5][2];
char a[105];
int64 F(int i, int c, int eq) {
if(c > k)
return 0;
if(i == n + 1)
return c == k;
int64 &ans = dp[i][c][eq];
if(ans != -1)
return ans;
ans = 0;
int lim = eq ? (a[i] - '0') : 9;
for(int d = 0; d <= lim; d++) {
int neq = eq && d == (a[i] - '0');
ans += F(i + 1, c + (d > 0), neq);
}
return ans;
}
int main() {
scanf("%s%d", a + 1, &k);
n = strlen(a + 1);
memset(dp, -1, sizeof(dp));
printf("%lld\n", F(1, 0, 1));
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
using ll = long long;
using P = pair<int,int>;
int dp[110][110][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,K+1)rep(k,2){
int x = s[i]- '0';//いまのけた
rep(d,10){
int ni = i+1,nj = j,nk = k;
if(!k && d > x )continue;
if(d < x)nk = 1;
if(d != 0)nj++;
dp[ni][nj][nk] +=dp[i][j][k];
}
}
cout << dp[n][K][0]+dp[n][K][1] << endl;
return 0;
} |
#include <bits/stdc++.h>
#define ll long long int
#define MOD 1000000007
using namespace std;
ll ret(string s, int k){
if (s.size() == 0)
return 0;
if (s[0] == '0')
return ret(s.substr(1), k);
if (k == 1){
return (s[0] - '0') + 9 * (ll)(s.size() - 1);
}
string t = "";
for (unsigned int i = 0; i < s.size() - 1; i++){
t += string("9");
}
return ret(s.substr(1), k - 1) + (s[0] - '0' - 1) * ret(t, k - 1) + ret(t, k);
}
int main(void){
string n;
int k;
cin >> n;
cin >> k;
cout << ret(n, k) << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
string s;
ll k;
ll ans;
ll f(ll p, ll q)
{
if(q == 0) return 1;
if(p >= s.size()) return 0;
if(s[p] == '0') return f(p + 1, q);
ll re = 0;
re += f(p + 1, q - 1);
ll x = 1;
for(ll i = 0; i < q; i++) x *= 9;
ll lt = s.size() - p - 1;
if(q == 1) re += lt * x + (s[p] - '1') * x / 9;
else if(q == 2) re += lt * (lt - 1) / 2 * x + (s[p] - '1') * lt * x / 9;
else re += lt * (lt - 1) * (lt - 2) / 6 * x + (s[p] - '1') * lt * (lt - 1) / 2 * x / 9;
return re;
}
int main()
{
cin>>s>>k;
cout<<f(0, k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[110][2][10];
int main()
{
string s;
cin >> s;
int n = (int)s.size();
int k;
cin >> k;
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 granica = j ? 9 : (s[i]-'0');
for(int d = 0; d <= granica; ++d)
{
dp[i+1][j || d < granica][l + (d!=0)] += dp[i][j][l];
}
}
}
}
cout << dp[n][0][k] + dp[n][1][k] << '\n';
return 0;
}
|
#include<iostream>
using namespace::std;
string s;
int n,t;
void brute(int i,string g,int k){
if(k==0){
if(g>s)
return;
//cout<<g<<' '<<(g>s)<<'\n';
int o=1;
//for(int j=0;j<n;j++)
// o*=max(1,g[j]-'0');
t+=o;
return;
}
//cout<<g<<'\n';
for(;i<n-k+1;i++){
if(k!=1)
for(int j='1';j<='9' && g<=s;j++){
g[i]=j;
if(g<=s) brute(i+1,g,k-1);
}
else{
g[i]='9';
if(g>s)
t+=s[i]-'0';
else t+=9;
}
g[i]='0';
}
}
int main(){
cin>>s;
int k;
n=s.length();
cin>>k;
string g="";
for(int i=0;i<n;i++)
g+="0";
brute(0,g,k);
cout<<t<<'\n';
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
int k, dp[105][2][105];
string digit;
int digitdp(int id, bool can, int sum)
{
if(id == digit.size())
{
if(sum == k)
return 1;
return 0;
}
if(dp[id][can][sum] != -1)
return dp[id][can][sum];
int d = digit[id] - '0';
int ans=0;
for(int i=0; i<10; i++)
if(i<=d or can)
ans += digitdp(id+1, i<d or can, sum+(i!=0));
return dp[id][can][sum] = ans;
}
int32_t main()
{
cin >> digit >> k;
memset(dp, -1, sizeof(dp));
digitdp(0,0,0);
cout << dp[0][0][0] << '\n';
} |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
vector<int> v;
while(cin.peek() != '\n')v.push_back(getchar()-'0');
int n = (int)v.size();
int k; cin >> k;
ll dp1[101][5] = {};
ll dp2[101][5] = {};
dp1[0][1] = v[0]-1;
dp1[0][0] = 1;
dp2[0][1] = 1;
for(int i = 0; i < n-1; ++i){
for(int j = 0; j <= k; ++j){
dp1[i+1][j] += dp1[i][j]+dp2[i][j]*(v[i+1]!=0);
dp1[i+1][j+1] += dp1[i][j]*9+dp2[i][j]*max<ll>(v[i+1]-1,0);
dp2[i+1][j] += dp2[i][j]*(v[i+1]==0);
dp2[i+1][j+1] += dp2[i][j]*(v[i+1]!=0);
}
}
cout << dp1[n-1][k] + dp2[n-1][k] << endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD=1e9+7;
// http://luzhiled.hatenablog.com/entry/2017/12/03/124453
string N;
int K;
int dp[10002][2][5];
// k桁目
int rec(int k = 0, bool tight = true, int num = 0){
if(num>K)return 0LL;
if(k==N.size())return num==K;
int x = N[k] - '0';
int r = (tight ? x:9);
int &res = dp[k][tight][num];
if(~res) return res;
res = 0;
for(int i=0;i<=r;++i){
(res += rec(k+1,tight&&i==r,(num+(i!=0))) ) %= MOD;
}
return res;
}
int main(){
cin >> N >> K;
memset(dp, -1, sizeof(dp));
cout << rec() << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef vector<int> vec;
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];
}
}
cout<< dp[n][K][0]+dp[n][K][1]<<endl;
}
|
#include <iostream>
#include <algorithm>
std::string N;
int Kt[4][101];
int K(int k, int n) {
// n-k zeros
if (k > n) return 0;
if (k==0) return 1;
return 9*Kt[k-1][n-1] + Kt[k][n-1];//9*K(k-1, n-1) + K(k, n-1);
}
int f(int k, int n) {
if (k==0) return 1;
if (n >= N.length()) return 0;
if (N[n] == '0') return f(k, n+1);
return (N[n]-'1')*K(k-1, N.length()-n-1) + K(k, N.length()-n-1) + f(k-1, n+1);
}
int main() {
std::ios_base::sync_with_stdio(0);
int k;
std::cin >> N >> k;
for (int kk=0;kk<=3;++kk)
for (int n=0;n<=100;++n)
Kt[kk][n] = K(kk,n);
std::cout << f(k, 0);
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[101][2][4];// digit DP, [|N|+1: 1 origin][lt|eq][k:0~3]
void update(int i, int k, int di){
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;
}
int main(){
cin>>N>>K;
int dn = N.size();
dp[0][eq][0] = 1;
rp(i,0,dn) rp(k,0,K+1) update(i, k, N[i]-'0');
cout<< dp[dn][lt][K] + dp[dn][eq][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][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) nk = 1;
if (nd < d) continue;
}
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;
#define rep(i, n) for (int i=0; i<(n); ++i)
using ll = long long;
using P = pair<int, int>;
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;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.