Free Candies

Little Bob is playing a game. He wants to win some candies in it - as many as possible.

There are 4 piles, each pile contains N candies. Bob is given a basket which can hold at most 5 candies. Each time, he puts a candy at the top of one pile into the basket, and if there're two candies of the same color in it ,he can take both of them outside the basket and put them into his own pocket. When the basket is full and there are no two candies of the same color, the game ends. If the game is played perfectly, the game will end with no candies left in the piles.

For example, Bob may play this game like this (N=5):

Step1	Initial Piles		Step2	Take one from pile #2
Piles	Basket	Pocket	Piles	Basket	Pocket
1 2 3 4 1 5 6 7 2 3 3 3 4 9 8 6 8 7 2 1	nothing	nothing	1 3 4 1 5 6 7 2 3 3 3 4 9 8 6 8 7 2 1	2	nothing
Step3	Take one from pile #2		Step4	Take one from pile #3
Piles	Basket	Pocket	Piles	Basket	Pocket
1 3 4 1 6 7 2 3 3 3 4 9 8 6 8 7 2 1	2 5	nothing	1 4 1 6 7 2 3 3 3 4 9 8 6 8 7 2 1	2 3 5	nothing
Step5	Take one from pile #2		Step6	put two candies into his pocket
Piles	Basket	Pocket	Piles	Basket	Pocket
1 4 1 6 7 2 3 3 4 9 8 6 8 7 2 1	2 3 3 5	nothing	1 4 1 6 7 2 3 3 4 9 8 6 8 7 2 1	2 5	a pair of 3

Note that different numbers indicate different colors, there are 20 kinds of colors numbered 1..20.

'Seems so hard...'Bob got very much puzzled. How many pairs of candies could he take home at most?

 

Input

The input will contain no more than 10 test cases. Each test case begins with a line containing a single integer n(1<=n<=40) representing the height of the piles. In the following n lines, each line contains four integers xi1,xi2,xi3,xi4 (in the range 1..20). Each integer indicates the color of the corresponding candy. The test case containing n=0 will terminate the input, you should not give an answer to this case.

Output

Output the number of pairs of candies that the cleverest little child can take home. Print your answer in a single line for each test case.

Sample Input

5
1 2 3 4
1 5 6 7
2 3 3 3
4 9 8 6
8 7 2 1
1
1 2 3 4
3
1 2 3 4
5 6 7 8
1 2 3 4
0

Sample Output

8
0

3

题意：题目中给了四堆多种颜色的糖果，每一堆有n个糖果，还给了一个篮子，这个篮子一次最多只能装5个糖果，如果在装的过程中有两个糖果的颜色一样，那么就可以把这一对糖果带回家了。每次只能从某堆的堆顶取糖果，问最多能带回家多少对糖果。

思路：这个题用栈做，我们可以把这每堆糖果看成一个栈，每次从栈顶取糖果，这道题有一个剪枝，就当每取出一个糖果时，此时四个栈的状态是唯一的，因为只要达到以前有过的状态，那么肯定是有相同的结果的，就是记忆化搜索，能大大缩短运行时间。代码如下：

#include<stdio.h>
#include<string.h>
#include<stack>
using namespace std;
int n,maxx,num[50][5],book[50][50][50][50];
stack<int>Q[4];
void dfs(int x,int f,int ans,int p[])
{
    if(f>4)
    {
        return;
    }
    if(ans>maxx)
        maxx=ans;
    for(int i=0; i<4; i++)
    {
        p[i]++;
        if(!Q[i].empty()&&!book[p[0]][p[1]][p[2]][p[3]])
        {
            int t=Q[i].top();
            Q[i].pop();
            if(x&(1<<t))
            {
                int now=x-(x&(1<<t));
                dfs(now,f-1,ans+1,p);
            }
            else
            {
                int now=x|(1<<t);
                dfs(now,f+1,ans,p);
            }
            book[p[0]][p[1]][p[2]][p[3]]=1;
            Q[i].push(t);
        }
        p[i]--;
    }
}
int main()
{
    while(~scanf("%d",&n)&&n)
    {
        maxx=0;
        for(int i=0; i<4; i++)
        {
            while(!Q[i].empty())
                Q[i].pop();
        }
        for(int i=0; i<n; i++)
            for(int j=0; j<4; j++)
                scanf("%d",&num[i][j]);
        for(int i=n-1; i>=0; i--)
        {
            for(int j=0; j<4; j++)
                Q[j].push(num[i][j]);
        }
        memset(book,0,sizeof(book));
        book[0][0][0][0]=1;
        int ll[4]= {0};
        dfs(0,0,0,ll);
        printf("%d\n",maxx);
    }
}