warmhole

心得：
　　这道题为第一章，扎心了。
　　首先，这道题是可以暴力的，一开始想太多，不甘心暴力；

　　其次，这道题递归写的不熟悉，不简洁，证明对递归理解还不到位。

　　我的递归的思路是：如果已经选了两个点作为一对，那么剩余的点的做法应该是一样的，前提是将他们放入一个新的数组，避免读取到已经匹配的点。这种写法比较麻烦。

　　其他人的递归思路：扫描一个数组，如果已经匹配则从下一个点开始，否则开始匹配，每次匹配完之后，将匹配结果还原。写法很简洁。

其实思路差不多，不过我每次都需要重新生成临时数组。

我的代码：

/*{
PROG:wormhole
LANG:C++
ID:jzyjzy2
}*/

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string.h>

void createAndSearchMatrix(int matrix[][2],int *result,int N);
void recursion(int matrix[][2],int N,int num,int *chosenState,int *result);
int main()
{

    freopen ("wormhole.in","r",stdin);
    freopen ("wormhole.out","w",stdout);
    int matrix[12][2]={0};//[0]is the point reach after enter the point,[1]is the point reach after exit from the point
    int N;
    int cordinate[12][2]={0};

    int result=0;
    scanf("%d",&N);
    int i,j=0;
    int nearest[2]={0};//[0]is the nearest distance,[1][2] are the point numbeer
    for(i=0;i<N;i++)
    {
        scanf("%d%d",&cordinate[i][0],&cordinate[i][1]);
        matrix[i][1]=-1;
    }
    for(i=0;i<N;i++)
    {
        nearest[0]=1000000001;
        for(j=0;j<N;j++)
        {
            if(cordinate[i][1]==cordinate[j][1]&&cordinate[j][0]>cordinate[i][0])
            {
                if(cordinate[j][0]-cordinate[i][0]<nearest[0])
                {
                    nearest[0]=cordinate[j][0]-cordinate[i][0];
                    nearest[1]=i;
                    nearest[2]=j;
                }
            }
        }
        matrix[nearest[1]][1]=nearest[2];
    }
    createAndSearchMatrix(matrix,&result,N);
    printf("%d\n",result);
    return 0;
}
void createAndSearchMatrix(int matrix[][2],int *result,int N)
{
    int chosenState[12]={0};
    int i=0;
    for(i=0;i<N;i++)
        chosenState[i]=i;
    recursion(matrix,N,N,chosenState,result);
}
void recursion(int matrix[][2],int N,int num,int *chosenState,int* result)
{
    int state[12]={0};
    int i,j,k,nowPoint,isCircle=0;
    int tmpChosen[12]={0};
    if(N<=0)
    {
        isCircle=0;
        for(i=0;i<num;i++)
        {
            memset(state,0,12*sizeof(int));
            nowPoint=i;
            while(state[nowPoint]!=1)
            {
                state[nowPoint]=1;
                nowPoint=matrix[nowPoint][1];
                if(nowPoint<0)
                {
                    break;
                }
                nowPoint=matrix[nowPoint][0];

                if(state[nowPoint]==1)
                {
                    isCircle=1;
                    (*result)++;
                    break;
                }
            }
            if(isCircle==1)
                break;
        }
        return;
    }
    for(i=1;i<N;i++)
    {
        memcpy(tmpChosen,chosenState,12*sizeof(int));
        matrix[tmpChosen[0]][0]=tmpChosen[i];
        matrix[tmpChosen[i]][0]=tmpChosen[0];
        k=1;
        for(j=0;j<N-2;j++)
        {
            if(k==i)
                k++;
            tmpChosen[j]=tmpChosen[k];
            k++;
        }
        recursion(matrix,N-2,num,tmpChosen,result);
    }
}