POJ 1169

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#define MAXN 1930
#define M_4 4
using namespace std;

struct _node
{
    int len;
    int wide;
};
struct _node_ans
{
    int len;
    int wide;
    int area;
};

int _max(int a,int b);
int _max(int a,int b,int c);
int _max(int a,int b,int c,int d);
int compare(const void * i,const void * j);
void fun_1(int index);
void fun_2(int index);
void fun_3(int index);
void fun_4(int index);
void fun_5(int index);
void fun_6(int index);
_node _m[M_4];
int _sub[M_4];
int compare1(const void * i,const void * j);
_node_ans _ans[MAXN];
void init();
int stack_p = 0;

int main()
{
    //freopen("acm.acm","r",stdin);
    int i;
    int sum = 0;
    int temp;
    for(i = 0; i < M_4; ++ i)
    {
        cin>>_m[i].wide;
        cin>>_m[i].len;
    }
    init();
    do
    {
        fun_1(-1);
        fun_2(-1);
        fun_3(-1);
        fun_4(-1);
        fun_6(-1);
    }while(next_permutation(_sub,_sub+M_4));
    qsort(_ans,stack_p,sizeof(_node_ans),compare);
    temp = _ans[0].area;
    for(i = 0; i < stack_p; ++ i)
    {
        if(_ans[i].area == temp)
        {
            if(_ans[i].len > _ans[i].wide)
            {
                iter_swap(&_ans[i].len,&_ans[i].wide);
            }
            ++ sum;
        }
        else
            break;
    }
    qsort(_ans,sum,sizeof(_node_ans),compare1);
    cout<<temp<<endl;
    for(i = 0; i < sum; ++ i)
    {
        if(i == 0 || (_ans[i].len != _ans[i-1].len || _ans[i].wide != _ans[i-1].wide))
            cout<<_ans[i].len<<" "<<_ans[i].wide<<endl;
    }
}

int compare1(const void * i,const void * j)
{
    return ((_node_ans *)i)->len - ((_node_ans *)j)->len;
}

int compare(const void * i,const void * j)
{
    return ((_node_ans *)i)->area - ((_node_ans *)j)->area;
}

void init()
{
    int i;
    for(i = 0; i < M_4; ++ i)
    {
        _sub[i] = i;
    }
}

void fun_1(int index)
{
    ++ index;
    if(index == M_4)
    {
        _ans[stack_p].len = _m[_sub[0]].len + _m[_sub[1]].len + _m[_sub[2]].len + _m[_sub[3]].len;
        _ans[stack_p].wide = _max(_m[_sub[0]].wide,_m[_sub[1]].wide,_m[_sub[2]].wide,_m[_sub[3]].wide);
        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;
        stack_p ++;
        return;
    }
    fun_1(index);
    iter_swap(&_m[_sub[index]].wide,&_m[_sub[index]].len);
    fun_1(index);
    iter_swap(&_m[_sub[index]].wide,&_m[_sub[index]].len);
}

void fun_2(int index)
{
    ++ index;
    if(index == M_4)
    {
        _ans[stack_p].len =_max(_m[_sub[0]].len +_m[_sub[1]].len + _m[_sub[2]].len,_m[_sub[3]].len);
        _ans[stack_p].wide = _max(_m[_sub[0]].wide,_m[_sub[1]].wide,_m[_sub[2]].wide) + _m[_sub[3]].wide;
        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;
        stack_p ++;
        return;
    }
    fun_2(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
    fun_2(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
}

void fun_3(int index)
{
    ++ index;
    if(index == M_4)
    {
        _ans[stack_p].len = _m[_sub[0]].len + _max(_m[_sub[1]].len+_m[_sub[2]].len ,_m[_sub[3]].len );
        _ans[stack_p].wide = _max(_m[_sub[0]].wide,_max(_m[_sub[1]].wide,_m[_sub[2]].wide)+_m[_sub[3]].wide);
        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;
        stack_p ++;
        return;
    }
    fun_3(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
    fun_3(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
}

void fun_4(int index)
{
    ++ index;
    if(index == M_4)
    {
        _ans[stack_p].len = _m[_sub[0]].len + _m[_sub[1]].len + _max(_m[_sub[2]].len,_m[_sub[3]].len);
        _ans[stack_p].wide = _max(_m[_sub[0]].wide,_m[_sub[1]].wide,_m[_sub[2]].wide + _m[_sub[3]].wide);
        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;
        stack_p ++;
        return;
    }
    fun_4(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
    fun_4(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
}

void fun_6(int index)
{
    ++ index;
    if(index == M_4)
    {
        _ans[stack_p].len =    _max(_m[_sub[0]].len+_m[_sub[3]].len,_m[_sub[1]].len + _m[_sub[2]].len,_m[_sub[0]].len + _m[_sub[2]].len);
        _ans[stack_p].wide = _max(_m[_sub[0]].wide+_m[_sub[1]].wide,_m[_sub[2]].wide+_m[_sub[3]].wide,_m[_sub[1]].wide+_m[_sub[3]].wide);
        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;
        stack_p ++;
        return;
    }
    fun_6(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
    fun_6(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
}

int _max(int a,int b)
{
    if(a > b)
    {
        return a;
    }
    return b;
}

int _max(int a,int b,int c)
{
    a = _max(a,b);
    a = _max(a,c);
    return a;
}

int _max(int a,int b,int c,int d)
{
    return _max(a,_max(b,c,d));
}

void fun_5(int index)
{
    ++ index;
    if(index == M_4)
    {
        _ans[stack_p].len = _m[_sub[0]].len + _m[_sub[1]].len + _max(_m[_sub[2]].len,_m[_sub[3]].len);
        _ans[stack_p].wide = _max(_m[_sub[0]].wide,_m[_sub[1]].wide,_m[_sub[2]].wide + _m[_sub[3]].wide);
        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;
        stack_p ++;
        return;
    }
    fun_5(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
    fun_5(index);
    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);
}