Submission #23704

---

Source Code Expand

#include <map>
#include <set>
#include <cmath>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <bitset>
#include <fstream>
#include <sstream>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
#define li        long long int
#define rep(i,to) for(li i=0;i<((li)(to));++i)
#define pb        push_back
#define sz(v)     ((li)(v).size())
#define bit(n)    (1ll<<(li)(n))
#define all(vec)  (vec).begin(),(vec).end()
#define each(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define MP        make_pair
#define F         first
#define S         second
/*

#define MAX 100500

map<pair<li,li>, li> dp[MAX][2][2];
map<li, li> next_dp[MAX];
li mod = 1000000007;

li next(li n, li d)
{
	if(next_dp[d].find(n) != next_dp[d].end()) return next_dp[d][n];
	for(li i = d + 1; i * i <= n; i++)if(n % i == 0) return next_dp[d][n] = i;
	return next_dp[d][n] = n;
}

li recur(li n, li d, li rem, li minus, li can_plus)
{
cout << n << " " << d << " " << rem << " " << minus << " " << can_plus << endl;
	if(rem < 0) return 0;
	if(n < d) return 0;

	if(n == 1){
		li res =  0;
		if(minus) rem--;
		if(rem < 0) return 0;
		return rem / 2 + 1;
	}
	
	map<pair<li,li>, li> &DP = dp[rem][minus][can_plus];
	if(DP.find(MP(n, d)) != DP.end()) return DP[MP(n, d)];
		
	li res = 0;
		
	
	if(n == d){
		if(can_plus) res = (res + recur(1, 1, rem - 1,  minus, true)) % mod;
		res = (res + recur(1, 1, rem - 1, 1 - minus, true)) % mod;
	}else{
		li next_d = next(n, d);
		res = (res + recur(n, next_d, rem, minus, true)) % mod;
		if(can_plus) res = (res + recur(n / d, d, rem - 1, minus, true)) % mod;
		res = (res + recur(n / d, d, rem - 1, 1 - minus, false)) % mod;
	}
	
	return DP[MP(n, d)] = res;
}
	

int main()
{
	li n, m;
	cin >> n >> m;
	cout << recur(n, 2, m, false, true) << endl;
}

*/


#define CC 35ll
#define MAX 100500

map<li, li> dp[MAX][2];
li C[MAX][CC];
li ONE[MAX][2];
li N, M;
li mod = 1000000007;
vector<li> D;


li one(li rem, li minus)
{
	if(rem == 0) return 1 - minus;
	li &res = ONE[rem][minus];
	if(res != -1) return res;
	return res = (one(rem - 1, minus) + one(rem - 1, 1 - minus)) % mod;
}

li recur(li n, li rem, li minus)
{
	if(rem < 0) return 0;
	if(n == 1){
		li used = M - rem;
		return C[M][used] * one(rem, minus) % mod;
	}
	
	if(dp[rem][minus].find(n) != dp[rem][minus].end()) return dp[rem][minus][n];
	
	li res = 0;
	
	for(li i = 0; i < sz(D) && D[i] <= n; i++){
		if(n % D[i] != 0) continue;
		res = (res + recur(n / D[i], rem - 1, minus)) % mod;
		res = (res + recur(n / D[i], rem - 1, 1 - minus)) % mod;
	}
	return dp[rem][minus][n] = res;
}

int main()
{
	rep(i, MAX) C[i][0] = 1;
	rep(i, CC) C[i][i] = 1;
	rep(i, MAX)rep(j, min(CC, i))if(j) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
	
	cin >> N >> M;
	li minus = N < 0;
	N = abs(N);
	
	for(li i = 2; i * i <= N; i++)if(N % i == 0){
		D.pb(i);
		if(i * i < N) D.pb(N / i);
	}
	D.pb(N);
	sort(all(D));
	
	memset(ONE, -1, sizeof(ONE));
	cout << recur(abs(N), M, minus) << endl;
}

Submission Info

Judge Result