hihoCoder 1033

题目链接：

http://hihocoder.com/problemset/problem/1033

听说这个题是xiaodao出的~~

我们要知道dp其实就是一个记忆化搜索的过程，如果某个子结构之前搜索过了，那么这次我们就不搜索了。

所以数位dp记录的其实就是dp[pos][state]pos位以内满足条件state的情况数。

当然，作为第二次做数位dp的渣渣，我觉得还是得强调几点：

1、一定要记录一个limit，代表这一位的取数是否受限制。

2、记录一个flag，代表之前的数是否都是前导0。

3、注意(!flag&&!limit)的情况下再给dp[pos][state]赋值。

剩下的好像就没啥了。。。dfs就行，注意递归结束条件。。。

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
const int maxn = 20;
const int maxs = 300;
const long long mod = 1000000000 + 7;

typedef long long int64;

typedef struct Node{
  int64 cnt, sum;

  Node(){
    cnt = sum = 0;
  }

  Node( int64 cnt, int64 sum ){
     this->cnt = cnt;
     this->sum = sum;
  }

  Node(const struct Node& node){
    cnt = node.cnt;
    sum = node.sum;
  }
}Node;

Node dp[maxn][maxs][2];
int64 l, r;
int k;

int64 c[maxn];
int digit[maxn];

void Init(void){
  c[0] = 1;
  for( int i = 1; i <= 18; ++i ){
    c[i] = (c[i-1] * 10)%mod;
  }
}

Node dfs( int pos, int sum, int p, int flag, int limit ){
  Node ans;
  if( sum < 0 || sum > 200 )
     return Node(0, 0);

  if( pos < 0 ){
    if(flag)
      ans.cnt = 0;
    else
      ans.cnt = (sum == 100) ? 1 : 0;
    ans.sum = 0;
    return ans;
  }

  if(!flag && !limit && dp[pos][sum][p].cnt != -1)
    return dp[pos][sum][p];
  int last = limit ? digit[pos] : 9;

  Node a;
  ans.cnt = 0, ans.sum = 0;
  for( int i = 0; i <= last; ++i ){
    if( i == 0 && flag ){
      a = dfs( pos-1, sum, p, flag, limit&&(i == last) );
    }else{
      if(p){
        a = dfs( pos-1, sum-i, p^1, 0, limit&&(i == last) );
      }else{
        a = dfs( pos-1, sum+i, p^1, 0, limit&&(i == last) );
      }
    }
    ans.cnt = (ans.cnt + a.cnt + mod)%mod;
    ans.sum = (ans.sum + (c[pos]*i%mod*a.cnt)%mod + a.sum + mod)%mod;
  }

  if(!limit && !flag){
    dp[pos][sum][p].cnt = ans.cnt;
    dp[pos][sum][p].sum = ans.sum;
  }

  return ans;
}

int bitSet( int64 num ){
  int len = 0;
  memset( digit, 0, sizeof(digit) );

  while(num){
    digit[len++] = num%10;
    num /= 10;
  }

  return len-1;
}

void InitDP(void){
  memset( dp, -1, sizeof(dp) );
}

void solve(void){
  InitDP();

  int len;
  len = bitSet(l-1);
  //cout << "len1: " << len << endl;
  Node ans1 = dfs(len, k+100, 1, 1, 1);
  //cout << ans1.sum << endl;
  len = bitSet(r);
  //cout << "len2: " << len << endl;
  Node ans2 = dfs(len, k+100, 1, 1, 1);

  printf("%lld
", ((ans2.sum - ans1.sum + mod)%mod));
}

int main(void){
  Init();
  while(scanf("%lld%lld%d", &l, &r, &k) != EOF){
    solve();
  }

  return 0;
}

注意下dfs过程中sum不能小于0或超过200。