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 C (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
int main(void){
    long long h,w,tmp;
    scanf("%lld%lld",&h,&w);
    if (h>w){
        tmp=h;
        h=w;
        w=tmp;
    }
    long long ans;
    
    
    if (h%3==0 || w%3==0){
        printf("0\n");
        exit(0);
    } else {
        long long s1=h*w,sx1[3];
        sx1[0]=h*((w+3-1)/3);
        sx1[1]=(h/2)*(w-((w+3-1)/3));
        sx1[2]=s1-sx1[0]-sx1[1];
        long long sx1min=sx1[0],sx1max=sx1[0];
        if (sx1min>sx1[1]){
            sx1min=sx1[1];
        }
        if (sx1min>sx1[2]){
            sx1min=sx1[2];
        }
        if (sx1max<sx1[1]){
            sx1max=sx1[1];
        }
        if (sx1max<sx1[2]){
            sx1max=sx1[2];
        }
        ans=sx1max-sx1min;
        
        long long s2=h*w,sx2[3];
        sx2[0]=h*(w/3);
        sx2[1]=(h/2)*(w-(w/3));
        sx2[2]=s2-sx2[0]-sx2[1];
        long long sx2min=sx2[0],sx2max=sx2[0];
        if (sx2min>sx2[1]){
            sx2min=sx2[1];
        }
        if (sx2min>sx2[2]){
            sx2min=sx2[2];
        }
        if (sx2max<sx2[1]){
            sx2max=sx2[1];
        }
        if (sx2max<sx2[2]){
            sx2max=sx2[2];
        }
        if (ans>sx2max-sx2min){
            ans=sx2max-sx2min;
        }
        
        long long s3=h*w,sx3[3];
        sx3[0]=h*(w/3);
        sx3[1]=h*((w-(w/3))/2);
        sx3[2]=s3-sx3[0]-sx3[1];
        long long sx3min=sx3[0],sx3max=sx3[0];
        if (sx3min>sx3[1]){
            sx3min=sx3[1];
        }
        if (sx3min>sx3[2]){
            sx3min=sx3[2];
        }
        if (sx3max<sx3[1]){
            sx3max=sx3[1];
        }
        if (sx3max<sx3[2]){
            sx3max=sx3[2];
        }
        if (ans>sx3max-sx3min){
            ans=sx3max-sx3min;
        }
        
        long long s4=h*w,sx4[3];
        sx4[0]=h*((w+3-1)/3);
        sx4[1]=h*((w+3-1)/3)/2;
        sx4[2]=s4-sx4[0]-sx4[1];
        long long sx4min=sx4[0],sx4max=sx4[0];
        if (sx4min>sx4[1]){
            sx4min=sx4[1];
        }
        if (sx4min>sx4[2]){
            sx4min=sx4[2];
        }
        if (sx4max<sx4[1]){
            sx4max=sx4[1];
        }
        if (sx4max<sx4[2]){
            sx4max=sx4[2];
        }
        if (ans>sx4max-sx4min){
            ans=sx4max-sx4min;
        }    
  
    }
    printf("%lld\n",ans);
	return 0 ;
}