Problem:
Score : 300 points

Problem Statement

You are given integers N and K. Find the number of triples (a,b,c) of positive integers not greater than N such that a+b,b+c and c+a are all multiples of K.
The order of a,b,c does matter, and some of them can be the same.

Constraints

1 \leq N,K \leq 2\times 10^5

N and K are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the number of triples (a,b,c) of positive integers not greater than N such that a+b,b+c and c+a are all multiples of K.

Sample Input 1

3 2

Sample Output 1

9

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

Sample Input 2

5 3

Sample Output 2

1

Sample Input 3

31415 9265

Sample Output 3

27

Sample Input 4

35897 932

Sample Output 4

114191

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

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    )
}

// a+b = xk
// b+c = yk
// c+a = zk
// 2a = (x+z-y)k
// 2b = (y+x-z)k
// 2c = (z+y-x)k

// b = xk - a
// c = zk - a
// b+c = (x+z)k - 2a = yk

// 3 2

fn solve(n: usize, k: usize) -> usize {
    if (k % 2) == 1 {
        let odd = n / k;
        odd * odd * odd
    } else {
        let odd = n / (k/2);
        let odd = if odd % 2 == 1 { odd/2 + 1 } else { odd/2 };
        let ev = n / k;
        odd * odd * odd + ev * ev * ev
    }
}

fn main() {
    let (n, k) = parse_line!(usize, usize);

    println!("{}", solve(n, k));
}

#[test]
fn solve_test() {
    assert_eq!(solve(3,2), 9);
    assert_eq!(solve(5,3), 1);
    assert_eq!(solve(35897, 932), 114191);
}