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: Wrong Answer)


use std::io;
use std::io::prelude::*;





fn main() {

    // basic boilerplate
    let input = io::stdin();
    let mut string = String::new();

    // read in the input
    input.read_line(&mut string).unwrap();

    let elems = string.split(" ").map(|seq| seq.trim().parse::<u32>().unwrap()).collect::<Vec<_>>();

    // sweet and sexy
    let (N,K) = (elems[0], elems[1]);



    // now we want to find the number of triples (a,b,c) of positive integers lte N,
    // such that a + b, b + c, c + a are multiples of K

    // thus

    //  q_ab * k = a + b
    //  q_bc * k = b + c
    //  q_ca * k = c + a


    // this means that no pair of triples will be greater than k, and thus cannot
    // be multiples
    if 2 * N < K {
        println!("0");
    }


    // now we will use dynamic programming to solve the problem
    let whole_number_count = (N / K) as u32;
    let mut values = whole_number_count * whole_number_count * whole_number_count; // choosing 3 from #whole_number count

    // now if we need to consider halves
    if K % 2 == 0 {
        let half_and_whole_number_count = N * 2 / K;
        let half_number_count = half_and_whole_number_count - whole_number_count;
        values += half_number_count * half_number_count * half_number_count;
    }


    println!("{}", values)

}