Problem:
Score : 400 points

Problem Statement

There is a knight - the chess piece - at the origin (0, 0) of a two-dimensional grid.

When the knight is at the square (i, j), it can be moved to either (i+1,j+2) or (i+2, j+1).

In how many ways can the knight reach the square (X, Y)?

Find the number of ways modulo 10^9 + 7.

Constraints

1 \leq X \leq 10^6

1 \leq Y \leq 10^6

All values in input are integers.

Input

Input is given from Standard Input in the following format:

X Y

Output

Print the number of ways for the knight to reach (X, Y) from (0, 0), modulo 10^9 + 7.

Sample Input 1

3 3

Sample Output 1

2

There are two ways: (0,0) \to (1,2) \to (3,3) and (0,0) \to (2,1) \to (3,3).

Sample Input 2

2 2

Sample Output 2

0

The knight cannot reach (2,2).

Sample Input 3

999999 999999

Sample Output 3

151840682

Print the number of ways modulo 10^9 + 7.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)


// D - Knight

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;

// mod p （pは素数）の下でのべき乗を求める
ll mod_pow(ll a, ll n, ll p) {
	ll result = 1;
	while (n > 0) {
		if (n & 1) result = result * a % p;
		a = a * a % p;
		n >>= 1;
	}
	return result;
};

// mod p（pは素数）の下での逆元を求める（フェルマーの小定理を利用）
ll mod_inverse(ll a, ll p) {
	return mod_pow(a, p-2, p);
}

// mod p （pは素数）の下での除算 (a / b)
ll mod_devide(ll a, ll b, ll p) {
	return a * mod_inverse(b, p) % p;
}

// mod p （pは素数）の下での組み合わせ（nCk）を計算
ll mod_comb(ll n, ll k, ll p) {
	ll numerator = 1;
	for (int i=n; i>n-k; i--) {
		numerator *= i;
		numerator %= p;
	}

	ll denominator = 1;
	for (int i=k; i>0; i--) {
		denominator *= i;
		denominator %= p;
	}

	return mod_devide(numerator, denominator, p);
}

int main()
{
	ll X, Y;
	cin >> X >> Y;

	// move_1: X方向に1, Y方向に2
	// move_2: X方向に2, Y方向に1
	// 1 * move_1 + 2 * move_2 = X
	// 2 * move_1 + 1 * move_2 = Y
	ll move_1 = (2 * Y - X) / 3;
	ll move_2 = (2 * X - Y) / 3;
	ll move_total = move_1 + move_2;

	if (1 * move_1 + 2 * move_2 != X) {
		cout << 0 << endl;
		return 0;
	}

	if (2 * move_1 + 1 * move_2 != Y) {
		cout << 0 << endl;
		return 0;
	}

	if (move_1 < 0 || move_2 < 0 || move_total != (X + Y) / 3) {
		cout << 0 << endl;
		return 0;
	}

	ll ans = mod_comb(move_total, move_1, MOD);

	cout << ans << endl;

	return 0;
}