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.42.0) (judge verdict: Accepted)

const MOD: i64 = 1000000007;

fn main() {
	let mut s = String::new();
	use std::io::Read;
	std::io::stdin().read_to_string(&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();
	use num::integer::Roots;
	let sqrtn = n.sqrt();
	let mut small = vec![0; sqrtn + 1];
	let mut large = vec![0; sqrtn + 1];
	small[1] = 1;

	for _ in 0..k {
		std::mem::swap(&mut small, &mut large);

		for i in 1..sqrtn {
			large[i + 1] = (large[i + 1] + large[i]) % MOD;
			large[i] = (large[i] * (n / i - n / (i + 1)) as i64) % MOD;
		}
		if sqrtn == n / sqrtn {
			small[sqrtn] = large[sqrtn];
		} else {
			small[sqrtn] = (small[sqrtn] + large[sqrtn]) % MOD;
		}
		large[sqrtn] = (large[sqrtn] * (n / sqrtn - n / (sqrtn + 1)) as i64) % MOD;

		for i in (1..sqrtn).rev() {
			small[i] = (small[i] + small[i + 1]) % MOD;
		}
	}

	let ans = small[sqrtn]
		+ if sqrtn == n / sqrtn { 0 } else { large[sqrtn] }
		+ (1..sqrtn).fold(0, |r, i| (r + small[i] + large[i])) % MOD;
	println!("{}", ans % MOD);
}