Problem:
Score : 600 points

Problem Statement

Find the number of sequences of length K consisting of positive integers such that the product of any two adjacent elements is at most N, modulo 10^9+7.

Constraints

1\leq N\leq 10^9

1 2\leq K\leq 100 (fixed at 21:33 JST)

N and K are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the number of sequences, modulo 10^9+7.

Sample Input 1

3 2

Sample Output 1

5

(1,1), (1,2), (1,3), (2,1), and (3,1) satisfy the condition.

Sample Input 2

10 3

Sample Output 2

147

Sample Input 3

314159265 35

Sample Output 3

457397712

Solution in Rust (1.15.1) (judge verdict: Accepted)

const MOD: i64 = 1000000007;

fn main() {
	let mut s = String::new();
	std::io::stdin().read_line(&mut s).unwrap();
	let mut s = s.split_whitespace();
	let n: usize = s.next().unwrap().parse().unwrap();
	let k: usize = s.next().unwrap().parse().unwrap();

	let mut pattern = vec![];
	for i in (1..).take_while(|&i| i * i <= n) {
		pattern.push((i, 0));
		pattern.push((n / i, 0));
	}
	pattern.sort();
	pattern.dedup();
	for i in 0..pattern.len() - 1 {
		let l = n / pattern[i + 1].0;
		let r = n / pattern[i].0;
		pattern[i].1 = r - l;
	}
	pattern.last_mut().unwrap().1 = 1;

	let get_index = |n| pattern.binary_search_by_key(&n, |p| p.0).unwrap();

	let mut dp = vec![vec![0; pattern.len()]; k + 1];
	dp[0][get_index(n)] = 1;
	for i in 0..k {
		for j in (0..pattern.len() - 1).rev() {
			dp[i][j] = (dp[i][j] + dp[i][j + 1]) % MOD;
		}
		for j in 0..pattern.len() {
			dp[i + 1][j] = (dp[i + 1][j] + dp[i][get_index(n / pattern[j].0)] * pattern[j].1 as i64) % MOD;
		}
	}
	let mut ans = (0..pattern.len()).fold(0, |r, i| (r + dp[k][i]) % MOD);
	println!("{}", ans);
}