Problem:
Score : 400 points

Problem Statement

There is a bar of chocolate with a height of H blocks and a width of W blocks.
Snuke is dividing this bar into exactly three pieces.
He can only cut the bar along borders of blocks, and the shape of each piece must be a rectangle.

Snuke is trying to divide the bar as evenly as possible.
More specifically, he is trying to minimize S_{max} - S_{min}, where S_{max} is the area (the number of blocks contained) of the largest piece, and S_{min} is the area of the smallest piece.
Find the minimum possible value of S_{max} - S_{min}.

Constraints

2 ≤ H, W ≤ 10^5

Input

Input is given from Standard Input in the following format:

H W

Output

Print the minimum possible value of S_{max} - S_{min}.

Sample Input 1

3 5

Sample Output 1

0

In the division below, S_{max} - S_{min} = 5 - 5 = 0.

Sample Input 2

4 5

Sample Output 2

2

In the division below, S_{max} - S_{min} = 8 - 6 = 2.

Sample Input 3

5 5

Sample Output 3

4

In the division below, S_{max} - S_{min} = 10 - 6 = 4.

Sample Input 4

100000 2

Sample Output 4

1

Sample Input 5

100000 100000

Sample Output 5

50000

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


use std::io;
use std::cmp;

fn min(w: i64, h: i64) -> i64 {
    let x = (w as f64 / 2f64).floor() as i64;
    let y = (h as f64 / 2f64).floor() as i64;
    cmp::max(x*h, w*y)
}

fn solve(w: i64, h: i64) -> i64 {
    let mut min = w * h + 1;
    for y in 0..h {
        let vmin = {
            let x = (w as f64 / 2f64).floor() as i64;
            let a = y*w;
            let b = (h-y)*x;
            let c = (h-y)*(w-x);
            let smax = cmp::max(cmp::max(a, b), c);
            let smin = cmp::min(cmp::min(a, b), c);
            smax - smin
        };
        let hmin = {
            let z = ((h-y) as f64 / 2f64).floor() as i64;
            let a = y*w;
            let b = z*w;
            let c = (h-y-z)*w;
            let smax = cmp::max(cmp::max(a, b), c);
            let smin = cmp::min(cmp::min(a, b), c);
            smax - smin
        };
        min = cmp::min(cmp::min(vmin, hmin), min);
    }
    min
}

fn main() {

    let mut input = String::new();

    io::stdin().read_line(&mut input);
    let mut iter = input.split_whitespace();

    let h = iter.next().unwrap().parse::<i64>().unwrap();
    let w = iter.next().unwrap().parse::<i64>().unwrap();

    println!("{}", cmp::min(solve(h,w), solve(w,h)));
}