【省内训练2018-10-26】网友数

【思路要点】

• 首先，当 $k\ge 9$ ，任何 $\ge 28$ 的数 $x$ 均为网友数。 $(1)$
• $(1)$ 的证明：
  当 $x\le 1000$ ，我们可以暴力验证命题的正确性。
  否则，考虑 $x$ 的末位，我们可以用 $9$ 个 $4$ 或是 $7$ 造出 $0$ 至 $9$ 以内的任何末位，这样，我们可以在 $x$ 中将造出的数减去， $x$ 将减少一位。
• 假设 $k\le 8$ ，考虑如何判断一个数 $x$ 是否为网友数。
• 考虑枚举每一位的网友数分布，记 $d{p}_{i,j,k}$ 表示考虑了 $x$ 最高的 $i$ 位，余数为 $j$ ，已用了 $k$ 个网友数的状态是否能够达到。转移时首先枚举下一位使用的网友数的数量 $k^{\prime }$ ，应当保证 $k^{\prime }\ge k$ ，再枚举 $4$ 的数量 $four$ ，从而算出 $7$ 的数量 $seven=k^{\prime }-four$ ，新的余数 $j^{\prime }$ 即为 $j\ast 10+a_{i+1}-4\ast four-7\ast seven$ 。最后判断是否能够达到 $i$ 为位数， $j=0$ 的状态即可。注意到 $j$ 每过一位就会 $\ast 10$ ，因此 $j>6$ 的状态均为无效状态，可以剪枝。
• 考虑原题，我们显然需要数位 $dp$ ，但是直接数位 $dp$ 会重复计算一个数。因此，我们不妨把前面的 $dp$ 作为状态压入最终的数位 $dp$ 中。即将上述的 $d{p}_{i,\ast ,\ast }$ 作为一个整体计入状态，这大约是 $7\ast 9=63$ 个 $0/1$ 位，看似状态量十分庞大。
• 但实际上，从初始状态出发，经过有限步合法转移，能够到达的状态是十分有限的，取 $k=8$ 时，能够到达的状态仅有 $1654$ 种，因此，直接按照前述 $dp$ 即可。
• 时间复杂度 $O(10\ast Cnt\ast |V|+10\ast CntLogCnt)$ ，其中 $Cnt=1654$ ， $|V|$ 表示 $L,R$ 的位数。
• 我们甚至可以将本题改为多组询问，可以得到 $O(Q\ast |V|+10\ast Cnt\ast |V|+10\ast CntLogCnt)$ 的时间复杂度。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
namespace force {
	const int MAXN = 38;
	bool valid[MAXN];
	vector <int> good;
	ll calc(ll r) {
		ll ans = 0;
		for (int i = 1; i <= 37 && i <= r; i++)
			ans += valid[i];
		if (r >= 37) ans += r - 37;
		return ans;
	}
	void work(ll l, ll r) {
		valid[0] = true;
		for (int i = 1; i <= 9; i++) {
			for (int j = 37; j >= 0; j--)
				if (valid[j]) {
					if (j + 4 <= 37) valid[j + 4] = true;
					if (j + 7 <= 37) valid[j + 7] = true;
				}
		}
		writeln(calc(r) - calc(l - 1));
	}
}
ll ql, qr, k;
namespace DynamicProgramming {
	const int states = 1654;
	const int MAXS = 1800;
	const int MAXN = 25;
	unordered_map <bitset <128>, int> mp;
	bitset <128> trans(bitset <128> now, int nxt) {
		bitset <128> res; res.reset();
		for (int i = 0; i < 128; i++) {
			if (!now[i]) continue;
			int Residue = i / 10, Used = i % 10;
			for (int used = Used; used <= k; used++)
			for (int four = used; four >= 0; four--) {
				int residue = Residue * 10 + nxt - four * 4 - (used - four) * 7;
				if (residue < 0) break;
				if (residue <= 6) res.set(residue * 10 + used);
			}
		}
		return res;
	}
	int l, r, tot, bits, a[MAXN], edge[MAXS][10];
	ll dp[MAXN][2][MAXS]; bitset <128> q[MAXS];
	ll getans(int pos, bool type, int state) {
		if (pos == 0) {
			bool ans = false;
			for (int i = 0; i <= k; i++)
				ans |= q[state][i];
			return ans;
		}
		if (dp[pos][type][state] != -1)
			return dp[pos][type][state];
		ll ans = 0;
		for (int i = 0; i <= (type ? a[pos] : 9); i++)
			ans += getans(pos - 1, type && (i == a[pos]), edge[state][i]);
		return dp[pos][type][state] = ans;
	}
	ll work(ll r) {
		bits = 0;
		while (r != 0) {
			a[++bits] = r % 10;
			r /= 10;
		}
		memset(dp, -1, sizeof(dp));
		return getans(bits, 1, 1);
	}
	void main() {
		l = r = tot = 1, q[1] = 1;
		mp[1] = tot++;
		while (l <= r) {
			bitset <128> now = q[l++];
			for (int i = 0; i <= 9; i++) {
				bitset <128> dest = trans(now, i);
				if (!mp.count(dest)) {
					mp[dest] = tot++;
					q[++r] = dest;
				}
			}
		}
		//cerr << r << endl;
		for (int i = 1; i <= r; i++)
		for (int j = 0; j <= 9; j++)
			edge[i][j] = mp[trans(q[i], j)];
		writeln(work(qr) - work(ql - 1));
	}
}
int main() {
	read(ql), read(qr), read(k);
	if (k >= 9) force :: work(ql, qr);
	else DynamicProgramming :: main();
	return 0;
}