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 i in 1..=sqrtn {
	// 	let cnt = n / i - n / (i + 1);
	// 	large[i] = cnt as i64;
	// }

	for _ in 0..k {
		let mut nexts = vec![0; sqrtn + 1];
		let mut nextl = vec![0; sqrtn + 1];
		for i in 1..=sqrtn {
			nextl[i] = small[i];
			nexts[i] = large[i];
		}

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

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

		small = nexts;
		large = nextl;
	}

	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);
}