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::cmp::min;

fn main() {
    let stdin = std::io::stdin();
    let mut locked = stdin.lock();
    let mut sc = scanner::Scanner::new(&mut locked);

    let h = sc.next_signed();
    let w = sc.next_signed();

    let mut r = i64::max_value();
    for x in 1..w {
        let w = w - x;
        let mut a = [h * x, h / 2 * w, (h + 1) / 2 * w];
        a.sort();
        r = min(r, a[2] - a[0]);
        let mut a = [h * x, w / 2 * h, (w + 1) / 2 * h];
        a.sort();
        r = min(r, a[2] - a[0]);
    }
    let (h, w) = (w, h);
    for x in 1..w {
        let w = w - x;
        let mut a = [h * x, h / 2 * w, (h + 1) / 2 * w];
        a.sort();
        r = min(r, a[2] - a[0]);
        let mut a = [h * x, w / 2 * h, (w + 1) / 2 * h];
        a.sort();
        r = min(r, a[2] - a[0]);
    }

    println!("{}", r);
}

mod scanner {
    use std::io::{BufRead, Error, ErrorKind, Read};
    use std::str::FromStr;

    pub struct Scanner<'a, R>
    where
        R: 'a + BufRead + ?Sized,
    {
        reader: &'a mut R,
    }

    impl<'a, R> Scanner<'a, R>
    where
        R: 'a + BufRead + ?Sized,
    {
        pub fn new(reader: &'a mut R) -> Self {
            Scanner { reader: reader }
        }

        #[allow(dead_code)]
        pub fn next_byte(&mut self) -> u8 {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .next()
                .unwrap()
                .unwrap()
        }

        #[allow(dead_code)]
        pub fn next_bytes(&mut self) -> Vec<u8> {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .take_while(|ref c| Self::is_printable(*c.as_ref().ok().unwrap()))
                .collect::<Result<Vec<u8>, _>>()
                .unwrap()
        }

        #[allow(dead_code)]
        pub fn next_unsigned(&mut self) -> u64 {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .take_while(|ref c| Self::is_printable(*c.as_ref().ok().unwrap()))
                .fold(Ok(0), |s, x| {
                    s.and_then(|t| {
                        x.and_then(|y| {
                            if b'0' <= y && y <= b'9' {
                                Ok(t * 10 + (y - b'0') as u64)
                            } else {
                                Err(Error::new(ErrorKind::InvalidData, "found not a digit"))
                            }
                        })
                    })
                })
                .unwrap()
        }

        #[allow(dead_code)]
        pub fn next_signed(&mut self) -> i64 {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .take_while(|ref c| Self::is_printable(*c.as_ref().ok().unwrap()))
                .fold(Ok([0i64, 0]), |s, x| {
                    x.and_then(|y| {
                        s.and_then(|t| {
                            if t[0] == 0 && y == b'-' {
                                Ok([-1, 0])
                            } else if b'0' <= y && y <= b'9' {
                                Ok([
                                    if t[0] == 0 { 1 } else { t[0] },
                                    t[1] * 10 + (y - b'0') as i64,
                                ])
                            } else {
                                Err(Error::new(ErrorKind::InvalidData, "found not a digit"))
                            }
                        })
                    })
                })
                .and_then(|s| Ok(s[0] * s[1]))
                .unwrap()
        }

        #[allow(dead_code)]
        pub fn next_float(&mut self) -> f64 {
            self.reader
                .bytes()
                .skip_while(|ref c| !Self::is_printable(*c.as_ref().ok().unwrap()))
                .take_while(|ref c| Self::is_printable(*c.as_ref().ok().unwrap()))
                .collect::<Result<Vec<u8>, Error>>()
                .and_then(|t| {
                    String::from_utf8(t).or(Err(Error::new(ErrorKind::InvalidData, "invalid data")))
                })
                .and_then(|s| {
                    f64::from_str(&s).or(Err(Error::new(ErrorKind::InvalidData, "invalid data")))
                })
                .unwrap()
        }

        fn is_printable(c: u8) -> bool {
            0x21 <= c && c <= 0x7e
        }
    }
}