考试，考了两门，还有三门，预计6月30号放假，不过目前来说，放假意味着考研准备的疯狂开始。其实，终点就是起点，我很清楚，完成承诺，然后努力复习，这就是我该做的，至于之前百度实习生的事情，笔试下来面试，呵呵，一面还可以吧，不过二面搞砸啦，应该是没戏了，那天的状态真是不好~顺便，我还是更喜欢百度一面的面试官，姓刘，人挺好，说话很清楚。

就这些，另外，最近有个对我很重要的日子，希望能顺利！

人生就是这样，但是我坚持认为未来会是好的，呵呵！

Description

Input

Output

Sample Input

dog ogday
cat atcay
pig igpay
froot ootfray
loops oopslay

atcay
ittenkay
oopslay

Sample Output

cat
eh
loops

Hint

/*
ID :wangyucao
PROB:pku2503_Babelfish
LANG:C++
*/
#include <iostream>
#include <cstring>
#include <stdlib.h>
#include <algorithm>
using namespace std;
//FILE *f=fopen("c.2.dat","r");
//FILE *fp=fopen("c.txt","w");
struct Node
{
Node* ch[26];
char s[12];
Node()
{
   for(int i=0;i<26;i++)
   {
    ch[i]=NULL;
    strcpy(s,"");
   }
}
~Node()
{
   int i;
   for(i=0;i<26;i++)
    if(this->ch[i]!=NULL)
     delete this->ch[i];
}
};
Node *T;
char s[12],st[12];
void InsertT(Node* Tr,int i)
{
int j;
if(i==strlen(s))
{
   strcpy(Tr->s,st);
   return;
}
if(Tr->ch[s[i]-'a']!=NULL)
   InsertT(Tr->ch[s[i]-'a'],i+1);
else
{
   Node *p;
   p=new Node;
   Tr->ch[s[i]-'a']=p;
   InsertT(Tr->ch[s[i]-'a'],i+1);
}
}
void FoundT(Node *Tr,int i)
{
if(i==strlen(s))
{
   strcpy(st,Tr->s);
   return;
}
if(Tr->ch[s[i]-'a']!=NULL)
{
   FoundT(Tr->ch[s[i]-'a'],i+1);
}
}
int main()
{
int i,j;
char c;
T=new Node;
scanf("%c",&c);
while(c!='\n')
{
   scanf("%s%s",st+1,s);
        st[0]=c;
   scanf("%c",&c);  
   InsertT(T,0);
   scanf("%c",&c);
}
while(scanf("%s",s)!=EOF)
{
   st[0]='\0';
   FoundT(T,0);
   if(strlen(st)==0)
    strcpy(st,"eh");
   printf("%s\n",st);
}
return 0;
}

回家以后刚开始真的蛮无聊，不过玩的也蛮High的，你想啊，早上11多才起床，起来后洗了脸就可以吃午饭了，吃完饭开始玩电脑游戏，把NBA的王朝模式玩了好几遍，姚明在我手上都退役很多次了，呵呵。从腊月25号开始我就没那么轻松了，一般每天都要打扫房间，收拾东西，买年货。最忙的就是大年三十了，我要擦桌子，贴对联，挂灯笼，摆献果，呵呵。晚上一家人吃火锅，真的很不错。就在那天晚上，小沈阳火了。。。

年后直到初五都是要走亲戚的，过了这几天开始没事干了，但是一没事干又觉得无聊了～游戏都不想打了，呵呵。经常打打长途电话，难得上次网，找个能视频的地方，还待不了多久。。。同学聚会，看见了高中和初中的不少关系很好的同学，聊聊天，时间就过去了。这些天基本上没怎么出门。看看小连能到处转转，真的是挺羡慕的，嘿嘿。小蜗牛都回西安了，找到工作做了，真好。不过，有个人回家后发现变的跟我一样了，^_^，也能睡到大中午了，她还感冒了，要多注意身体，这不知道是我第几次说这句话了。。。

总之，祝大家过年都开开心心，万事如意啦！当然，最重要的还是身体健康！好了，希望你们都能早点回来，嘿嘿，牛年大吉。。。

希望大家2009年都能开开心心！

给大家拜个早年，回家不能上网，就不能拜年了。。。

2009，新年好~

开始一直在想用组合数学怎么做，后来看到字符串只有最大10的范围，所以决定穷举。要穷举就要生成排列，自己写效率不会太高，突然看到STL中提供的一个函数：next_permutation

这是一个好东西啊，比如一个字母序列，你要生成这个序列的所有排列，可以这样：

char a[10];

do{

    for(i=0;i<10;i++) cout<<a[i]<<' ';

}while(next_permutation(a,a+10));

这样使用简单，代码看起来很漂亮，嘿嘿~

当然，这个next_permutation函数需要包含algorithm头文件。另外还提供了prev_permutation，前者是按照开始从小到大排列后生成的，后者这是从大到小。挺好用的，所以记下来！

void Deletes()
{
cout<<"请输入您要删除的学生学号:"<<endl;
cin>>strfind;
int i=Searchs(1);
if(i<0) {cout<<"您要删除的学生不存在！请确认后在执行删除！"<<endl;
    return ;
    }
stuin[i]=false;
stunum--;
}
void savedata()
{
ofstream fout("stu.dat");
for(int i=0;i<n;i++)
   if(stuin[i]){  
   fout<<stu[i].no<<endl;;
   fout<<stu[i].name<<endl;
   fout<<stu[i].score[0]<<' ';
   fout<<stu[i].score[1]<<' ';
   fout<<stu[i].score[2]<<' ';
   fout<<stu[i].score[3]<<' ';
   fout<<stu[i].aver<<endl;
   }
}
int main()
{
int i,j,k,ch;
string stna,stno;
memset(stuin,false,sizeof(stuin));
stunum=n=i=0;
cout<<"正在导入学生信息文件......";
if(fin.fail()) cout<<endl<<"学生信息文件不存在！"<<endl;
else{
   while(!fin.eof()){
    fin>>stu[i].no>>stu[i].name;
    for(j=0;j<4;j++)
     fin>>stu[i].score[j];
    fin>>stu[i].aver;
    stuin[i]=true;
    i++;
   }
   cout<<endl<<"OK!"<<endl;  
   stunum=n=i-1;
   cout<<stunum<<"个学生信息现在在学生文件中！"<<endl;
}
fin.close();
while(1)
{
   bool flag=false;
   showmenu();
   cin>>ch;
   if(ch==5) break;
   switch(ch){
    case 1: Inserts(); break;
    case 2: Modifys(); break;
    case 3: Searchs(); break;
    case 4: Deletes(); break;
    default: cout<<"输入不正确，请重新选择！"<<endl;
       getchar();
       flag=true;
   }
   if(flag) continue;
}
savedata();
return 0;
}

/*
2、 编写小学生数学测试软件。
(1) 可选择题型加，减，乘。
(2) 可选择每次答题的个数。
(3) 随机生成两个数进行运算。
(4) 每次输入答案后判断对错，若答案错误，给出正确答案。
(5) 最后给出做对题目的总个数。
*/
#include<iostream>
#include<fstream>
#include<iomanip>
#include<time.h>
#include<cstdlib>
using namespace std;
const int maxn=1000; //设置加法，减法的最大数，这里设置为1000
const int maxn2=100; //设置乘法的最大数，这里设置为100
int n;
void plusfunc()
{
int a,b,c;
int score=0;
while(n--){
   a=rand()%(maxn+1);
   b=rand()%(maxn+1);
   cout<<a<<" + "<<b<<"= "<<endl;
   cin>>c;
   if(c==a+b) {
    cout<<"回答正确，加十分！"<<endl;
    score+=1;
   }
   else cout<<"答错了！正确答案是： "<<a+b<<endl;
}
cout<<"您答对了 "<<score<<" 个题目，得分为"<<score*10<<" 分！"<<endl;
}
void subfunc()
{
int a,b,c;
int score=0;
while(n--){
   a=rand()%(maxn+1);
   b=rand()%(maxn+1);
   if(a<b) swap(a,b);
   cout<<a<<" - "<<b<<"= "<<endl;
   cin>>c;
   if(c==a-b) {
    cout<<"回答正确，加十分！"<<endl;
    score+=1;
   }
   else cout<<"答错了！正确答案是： "<<a-b<<endl;
}
cout<<"您答对了 "<<score<<" 个题目，得分为"<<score*10<<" 分！"<<endl;
}
void multifunc()
{
int a,b,c;
int score=0;
while(n--){
   a=rand()%(maxn2+1);
   b=rand()%(maxn2+1);
   cout<<a<<" * "<<b<<"= "<<endl;
   cin>>c;
   if(c==a*b) {
    cout<<"回答正确，加十分！"<<endl;
    score+=1;
   }
   else cout<<"答错了！正确答案是： "<<a*b<<endl;
}
cout<<"您答对了 "<<score<<" 个题目，得分为 "<<score*10<<" 分！"<<endl;
}
int main()
{
int i,j,k;
cout<<"请选择要做的题型："<<endl
   <<"1.加法"<<endl
   <<"2.减法"<<endl
   <<"3.乘法"<<endl;
cin>>k;
cout<<"请选择要做的题目个数：";
cin>>n;
srand((unsigned) time(0));
switch(k){
   case 1: plusfunc(); break;
   case 2: subfunc(); break;
   case 3: multifunc();break;
   default: cout<<"输入错误，程序结束！";
}
return 0;
}

/*
5、 打印如下方阵（任选一题）。
(1) 螺旋方阵：  
1    2    3    4  
12 13 14 5
11 16 15 6
10 9    8    7
*/
#include<iostream>
#include<fstream>
#include<string>
#include<algorithm>
#include<iomanip>
using namespace std;
int n,dirnow,cnt;
int a[101][101];
bool filla[101][101];
int dir[4][2]={0,1,1,0,0,-1,-1,0};
void dfs(int i,int j)
{
int x;
int y;
if(cnt==n*n) return;
dirnow%=4;
x=i+dir[dirnow][0];
y=j+dir[dirnow][1];
if(x<0 || x>=n || y<0 || y>=n || filla[x][y])
   dirnow++;
dirnow%=4;
cnt++;
filla[i+dir[dirnow][0]][j+dir[dirnow][1]]=true;
a[i+dir[dirnow][0]][j+dir[dirnow][1]]=cnt;
dfs(i+dir[dirnow][0],j+dir[dirnow][1]);
}
int main()
{
int i,j;
cout<<"请输入要打印螺旋矩阵的维数:";
cin>>n;
memset(filla,false,sizeof(filla));
a[0][0]=1;
filla[0][0]=true;
dirnow=0;
cnt=1;
dfs(0,0);
for(i=0;i<n;i++){
   for(j=0;j<n;j++){
    cout<<a[i][j]<<"\t";
   }
   cout<<endl;
}
return 0;
}

/*
7、 假定用一个整型数组表示一个长整数，数组的每个元素存储长整数的一位数字，实际的
长整数 m表示为：
m=a[k]× 10-1+a[k-1]× 10-2+….+a[2]×10+a[1]
其中 a[0]保存该长整数的位数。完成（任选一题） ：
(1) 长整数乘普通整数。
(2) 长整数除普通整数。
*/
#include<iostream>
#include<fstream>
#include<string>
#include<algorithm>
using namespace std;
string operator*(string s, int a); // s,a非负，且a必须小于2*10^8.
string MSDiv(string x, int y, int &res); // 多精度除以int，x非负，y为正
string operator/(string s, int a); // 调用MSDiv
string Head_zero_remover(string num); // 除了开头可能有'0'外，num必须是非负数。
bool Less(string x, string y); // 非负数之间的"小于"

string operator-(string s); // 取负
string SAdd(string x, string y);
string SMinus(string x, string y);
string SMul(string x, string y);
string SMul(string s, int a);   // 同样，a的绝对值不能超过2*10^8
string operator*(string s, int a)
{
if(s == "0" || a == 0) // 以免后面特殊处理！
   return "0";  

string prod(s.size(), -1); // 先申请s.size()位

int carry=0;
for(int i=s.size()-1; i >= 0; --i)
{
   carry += (s[i]-'0')*a;
   prod[i] = carry%10+'0';
   carry /= 10;
}
while(carry>0)
{
   prod.insert(prod.begin(), carry%10+'0');
   carry /= 10;
}

return prod;
}
string MSDiv(string x, int y, int &res)
{
string quot(x.size(), 0);

res=0;
for(int i=0; i<x.size(); ++i)
{
   res = 10*res+x[i]-'0';
   quot[i] = res/y+'0'; // 整除结果为商
   res %= y; // 取余保留
}
return Head_zero_remover(quot);
}
string operator/(string s, int a)
{
int res;
return MSDiv(s, a, res);
}
string Head_zero_remover(string num) // 化简"003"等数
{
if(num[0] != '0')
   return num;
int pos=num.find_first_not_of('0');
if(pos == string::npos) // 全0
   return "0";
return num.substr(pos, num.size()-pos);
}
string operator-(string s)
{
if(s[0] == '-')
   return s.substr(1, s.size()-1);
if(s == "0")
   return "0";
return string("-") += s;
}
string SMul(string s, int a)
{
if(s[0] == '-' && a<0)
   return (-s)*(-a);
if(s[0] == '-')
   return -((-s)*a);
if(a<0)
   return -(s*(-a));
return s * a;
}
int main()
{
string s1;
int a;
cout<<"请输入长整数：";
cin>>s1;
cout<<"请输入普通整数：";
cin>>a;
cout<<s1<<" * "<<a<<" = "<<s1*a<<endl;
cout<<s1<<" / "<<a<<" = "<<s1/a<<endl;
return 0;
}

/*
9、 算法问题（任选一题） 。
(1) 皇后问题：在国际象棋中，能否在空棋盘上摆放八个皇后，并使其中任意两个皇后
不能在同一行或同一列或同一对角线上，并编写完整的摆放八皇后问题的程序。要求：
第一个皇后的起始位置由键盘输入，国际象棋的棋盘为 8*8 的方格。
*/
#include<iostream>  
using namespace std;
bool   Col[8],LeftCr[16],RightCr[16],Row[8];  
short   Answer[8],Count=0;  
   
/*Col{行标志定义}  
Answer{列标志定义}  
LeftCr{左斜对角线标志定义}  
RightCr{右斜对角线标志定义}  
{Count:解的个数纪录}  
*/  
//-------------------------判断一个位置是否可以置一个皇后-----------------------  
bool   IfSafe(short   x,short   y)  
{  
        return   ((Col[y]==true)  
                ||   (LeftCr[x-y+7]==true)  
                ||   (RightCr[x+y]==true))?false:true;  
}  
//-----------------------------从当前位置删除一个皇后--------------------------  
void   CutQueen(short   x,short   y)  
{  
      Col[y]=false;  
      LeftCr[x-y+7]=false;  
      RightCr[x+y]=false;  
}  
   
//---------------------------------打印一组解----------------------------------  
void   PrintAnswer()  
{  
    int   CurAns;  
    printf("\nCOUNT[%4d]\n",++Count);  
    for   (CurAns=0;CurAns<8;CurAns++) {
   for(int i=0;i<8;i++)
    if(i==Answer[CurAns])
     printf("Q");  
    else
     printf(".");
   printf("\n");
}
}  
//---------------------------------置皇后(核心部分)----------------------------  
void   PutQueen(short   x)  
{  
    short   y;  
if(x==8) PrintAnswer();
if(Row[x]) PutQueen(x+1);
else
    for   (y=0;y<8;y++)  
    {  
        if   (IfSafe(x,y))  
        {  
          Answer[x]=y;  
          Col[y]=true;  
          LeftCr[x-y+7]=true;  
          RightCr[x+y]=true;  
          PutQueen(x+1);  
          CutQueen(x,y);  
        }  
      }  
}  
   
//--------------------主程序体--------------------------------------------  
int   main()  
{  
   int x,y;
for   (int   i=0;i<8;i++)  
      Answer[i]=0;
cout<<"请输入第一行的皇后位置：";
cin>>x>>y;
x--;
y--;
Answer[x]=y;
Col[y]=true;  
Row[x]=true;
LeftCr[x-y+7]=true;  
RightCr[x+y]=true;  
PutQueen(0);  
return   0;  
}  

这次哈尔滨之行又仅仅是一次公费旅游，仍然没有拿奖，但是感觉到获奖离我们如此的近，近到几乎可以触摸到！但几乎就是几乎，遗憾的是，我们自己没有把握到机会，过多的浪费时间使我们离获奖越来越远。

这是一次失败的教训，从一开始就是失败的，心态不好决定了这次不会有什么收获，可能也不能这么说，最起码，我们收获到一次失败！这次可以总结的东西太多太多了，不经历这次挫折，很多东西都看不到的！这可能就是必经之路吧。

说说哈尔滨吧，那地方虽然很冷，但是我感觉很漂亮，哈尔滨工程大学做的很好，除了那个学生宿舍不能洗澡，其他的都做的挺好的，他们2010年要举办World Final，我相信他们会举办成一届非常成功的比赛！13号那天工程大学组织选手们旅游，去了东北虎野生动物园，还去了太阳岛，都很漂亮，还买了点小东西，呵呵。

然后去了防洪纪念塔，吃了晚饭就去火车站了，单程32个小时，真是熬人，就这样结束了这次失败的旅程……

按照安排是15号就回来了，单程32个小时的火车，真是熬人啊！火车上能做什么呢？

11号早上到吧，听说那边挺冷的，带上了衣服和药。

12号的比赛，祝自己好运！God bless me……

希望能有所突破吧……

Sometimes the programmers have very strange ways of hiding their passwords. Billy "Hacker" Geits chooses a string S composed of L (5 <= L <= 100,000) lowercase letters ('a'..'z') with length L. Then he makes and sorts all L-1 one-letter left cyclic shifts of the string. He then takes as a password one prefix of the lexicographically first of the obtained strings (including S).

For example consider the string "alabala". The sorted cyclic one-letter left shifts (including the initial string) are:

aalabal
abalaal
alaalab
alabala
balaala
laalaba
labalaa

Lexicographically, first string is 'aalabal'. The first letter of this string ('a') is the 'a' that was in position 6 in the initial string (counting the first letter in the string as position 0).

Write a program that, for given string S, finds the start position of the first letter of the sorted list of cyclic shifts of the string. If the first element appears more than once in the sorted list, then the program should output the smallest possible initial position.

PROGRAM NAME: hidden

INPUT FORMAT

• Line 1: A single integer: L
• Line 2..?: All L characters of the the string S, broken across lines such that each line has 72 characters except the last one, which might have fewer.

SAMPLE INPUT (file hidden.in)

7
alabala

OUTPUT FORMAT

• Line 1: A single integer that is the start position of the first letter, as described above.

SAMPLE OUTPUT (file hidden.out)

6

USER: wang yucao [wangyuc2]
TASK: hidden
LANG: C++

Compiling...
Compile: OK

Executing...
   Test 1: TEST OK [0.000 secs, 4016 KB]
   Test 2: TEST OK [0.011 secs, 4016 KB]
   Test 3: TEST OK [0.011 secs, 4012 KB]
   Test 4: TEST OK [0.011 secs, 4012 KB]
   Test 5: TEST OK [0.000 secs, 4012 KB]
   Test 6: TEST OK [0.011 secs, 4016 KB]
   Test 7: TEST OK [0.011 secs, 4016 KB]
   Test 8: TEST OK [0.065 secs, 4012 KB]
   Test 9: TEST OK [0.065 secs, 4016 KB]
   Test 10: TEST OK [0.076 secs, 4016 KB]
   Test 11: TEST OK [0.065 secs, 4012 KB]
   Test 12: TEST OK [0.000 secs, 4012 KB]
   Test 13: TEST OK [0.022 secs, 4012 KB]
   Test 14: TEST OK [0.011 secs, 4012 KB]

All tests OK.
Your program ('hidden') produced all correct answers!  This is your
submission #5 for this problem.  Congratulations!
 
/*
PROB: hidden
LANG: C++
*/
/*
这道题事实上还是搜索，不过在过程中采用类似KMP中的思想，串是环形的，我们可以把串拷贝一遍放在后面。
然后，用st记录当前的起始位置，用maxn来记录最小串的起始位置，那么每次对比s[st+i]和s[maxn+i]
这样有三种情况：
1.s[maxn+i] < s[st+i]，这表示之前记录的最小串小于当前位置的串，结束；
2.s[maxn+i] == s[st+i]， 表示这个字符位相等，那么i后移一位；
3.s[maxn+i] > s[st+i]，这表示当前位置的字符串较小，应该更新最小串起始记录maxn为st，结束。
执行这个比较过程知道st>=n
在这个过程中，如果出现情况1，那么这次退出后i表示这两个串的相同前缀数，st可以直接加上i；
特别注意，如果在比较过程中，i==n了，那表示有两个串是相同的，这样要直接退出，输出0，否则test11超时！
*/
#include<iostream>
#include<fstream>
#include<cstring>
#include<memory>
#include<algorithm>
#define cin fin
using namespace std;
ifstream fin("hidden.in");
ofstream fout("hidden.out");
char s[200002];
char s1[200002];
int next[200002];
int maxn,n,m;
char ch;
int st,en,st2;
int main()
{
     int i,j,k;
 char a,b,c;
 cin>>n;
 cin.getline(s,100,'\n');
 while(cin.getline(s1,100,'\n'))
   strcat(s,s1);
     strcpy(s1,s);
     strcat(s,s1);
 maxn=0;
 ch=s[0];
 st=1;
 s[n]=s[0];
 int stat;
 while(st<n)
 {
      stat=0;
   for(i=0;i<n;i++){
    if(s[maxn+i]<s[st+i])
    {
        stat=-1;
        break;
             }
             else if(s[maxn+i]>s[st+i])
             {
                 stat=1;
                 break;
             }
   }
         if(i<n && stat>0) {
     maxn=st;
     ch=s[st];
    }
         else if(i<n && stat<0)
         {
             st+=i+1;
             continue;
         }
         else if(i==n)
         {
             stat=2;
             break;
         }
    st++;
 }
 if(stat==2) fout<<'0'<<endl;
 else fout<<maxn<<endl;
 return 0;
}

A square township has been divided up into N² square plots (1 <= N <= 7). The Farm is located in the upper left plot and the Market is located in the lower left plot. Betsy takes her tour of the township going from Farm to Market by walking through every plot exactly once. Shown below is one possible tour for Betsy when N=3.

----------------
|    |    |    |
| F**********  |
|    |    | *  |
------------*---
|    |    | *  |
|  *****  | *  |
|  * | *  | *  |
---*---*----*---
|  * | *  | *  |
|  M | ******  |
|    |    |    |
----------------

PROGRAM NAME: betsy

INPUT FORMAT

Line 1: A single integer N (1 <= N <= 7)

SAMPLE INPUT (file betsy.in)

3

OUTPUT FORMAT

SAMPLE OUTPUT (file betsy.out)

2

对于这道题，我不想说什么了，剪枝到死……看程序吧……

USER: wang yucao [wangyuc2]
TASK: betsy
LANG: C++

Compiling...
Compile: OK

Executing...
   Test 1: TEST OK [0.011 secs, 2844 KB]
   Test 2: TEST OK [0.011 secs, 2848 KB]
   Test 3: TEST OK [0.000 secs, 2848 KB]
   Test 4: TEST OK [0.022 secs, 2848 KB]
   Test 5: TEST OK [0.011 secs, 2848 KB]
   Test 6: TEST OK [0.032 secs, 2848 KB]
   Test 7: TEST OK [0.691 secs, 2848 KB]

All tests OK.
Your program ('betsy') produced all correct answers!  This is your
submission #9 for this problem.  Congratulations!
 
/*
PROB: betsy
LANG: C++
*/
#include<iostream>
#include<fstream>
#include<string>
#include<algorithm>
#define cin fin
using namespace std;
ifstream fin("betsy.in");
ofstream fout("betsy.out");
bool map[7][7];
int n,m,stat,cnt,cnt2;
int dir[4][2]={-1,0,1,0,0,1,0,-1};
int rown[8],coln[8];
int adj[8][8];
void print();
void dfs(int i,int j)
{
 int k,t1,t2,l;
 bool yes=false;
 t1=t2=0;
 if(i==n-1 && j==0)
    if(stat==n*n){
     cnt++;
     return;
    }
    else return;
      if(i==n-2 && j==1 && !map[i][j-1] && !map[i+1][j]) return;
      //--------------------------剪枝1------------------------------
      if(rown[i]==n-1 && i>0 && i<n-1)      //如果第i行填满，而第k行(k<i)未填满，那么图被分成两块，回溯；
      {
          for(k=i-1;k>=0;k--)
              if(rown[k]<n) break;
          if(k>=0) return;
      }
      t2=0;
      if(coln[j]==n-1 && j>0 && j<n-1)      //如果第j列填满，而第k列(k>j)未填满，那么图被分成两块，回溯；
      {
         for(k=j+1;k<n;k++)
              if(coln[k]<n) break;
          if(k<n) return;
      }
      //--------------------------剪枝2-------------------------------
 if(i>0 && j==0)                       //若map[i][0]走过，而map[k][0](k<i) 没走过，那么图被分割成两块，回溯！
 {
    for(k=i-1;k>=0;k--)
     if(!map[k][j]) break;
    if(k>=0) return;
 }
 if(i>0 && j==n-1)                   //若map[i][n-1]走过，而map[k][n-1](k<i) 没走过，那么图被分割成两块，回溯！
 {
    for(k=i-1;k>=0;k--)
     if(!map[k][j]) break;
    if(k>=0) return;
 }
 if(i==0 && j>0)                       //若map[0][j]走过，而map[0][k](k<j) 没走过，那么图被分割成两块，回溯！
 {
    for(k=j-1;k>=0;k--)
     if(!map[i][k]) break;
    if(k>=0) return;
 }
 //fout<<i<<' '<<j<<endl;
 if(i==n-1 && j<n-1)                   //若map[n-1][j]走过，而map[n-1][k](k>j) 没走过，那么图被分割成两块，回溯！
 {
    for(k=j+1;k<n;k++)
     if(!map[i][k]) break;
    if(k<n) return;
 }
 //--------------------剪枝3-------------------------------
 //减去[i-1,j],[i+1,j]到过而[i,j-1],[i,j+1]没到过的点
      if(j>0 && j<n-1 && i>0 &&i<n-1 && map[i-1][j] && map[i+1][j] && !map[i][j-1] && !map[i][j+1]) return;
      //减去[i-1,j],[i,j-1]到过而[i-1,j-1]未到过的点
      if(i>0 && j>0 && map[i-1][j] && map[i][j-1] && !map[i-1][j-1]) return;
      if(i>0 && j>=0 &&i<n-1 && j<n-1 && map[i-1][j] && map[i+1][j+1] && !map[i][j+1] && !map[i+1][j]) return;
      //对应上面三个模型到列
      if(j>0 && j<n-1 && i>0 &&i<=n-1 && map[i][j-1] && map[i-1][j+1] && !map[i][j+1] && !map[i-1][j]) return;
      if(i>0 && j<n-1 && map[i+1][j] && map[i][j-1] && !map[i+1][j-1]) return;
      if(i>0 && j>0 &&i<n-1 && j<n-1 && map[i][j-1] && map[i][j+1] && !map[i+1][j] && !map[i-1][j]) return;
      //if(i>0 && j>0 &&i<n-1 && j<=n-1 && map[i-1][j] && map[i+1][j-1] && !map[i][j-1] && !map[i+1][j]) return;
      //if(i>=0 && j>0 &&i<n-1 && j<n-1 && map[i][j-1] && map[i+1][j+1] && !map[i][j+1] && !map[i+1][j]) return;
//剪完以上步，终于到了2s以内……
      //--------------------剪枝4-------------------------------
      int bjx,bjy,bjd=0;
 if(!yes)
 {
       bjd=0;
       for(k=0;k<4;k++)
       {
              int x=i+dir[k][0];
              int y=j+dir[k][1];
              if(x>=0 && x<n && y>=0 && y<n && adj[x][y]==1 && !map[x][y]) {bjd++; bjx=x; bjy=y;}
       }
      }
      if(bjd>=2) return;
 for(k=0;k<4;k++)            //如果与当前格子不相邻且没有经过的格子的相邻的未经过的格子数小于两个，剪掉！
          if(i+dir[k][0]>=0 && i+dir[k][0]<n && j+dir[k][1]>=0 && j+dir[k][1]<n)
              adj[i+dir[k][0]][j+dir[k][1]]--;
 for(k=0;k<n;k++){
          for(int p=0;p<n;p++)
          if(map[k][p] || (k==i-1&&p==j) ||(k==i+1&&p==j)||(k==i&&p==j-1)||(k==i&&p==j+1)) continue;
          else if(adj[k][p]<2 && !(k==n-1 && p==0)) {yes=true; break;}
          if(yes) break;
 }
 if(!yes){
       if(bjd==1)
       {
           map[bjx][bjy]=true;
              stat++;
              coln[j]++;
              rown[i]++;
              dfs(bjx,bjy);
              map[bjx][bjy]=false;
              stat--;
              coln[j]--;
              rown[i]--;
          }
          else
          for(k=0;k<4;k++){
              int x=i+dir[k][0];
              int y=j+dir[k][1];
              if(x>=0 && x<n && y>=0 && y<n && !map[x][y])
              {
                  map[x][y]=true;
                  stat++;
                  coln[j]++;
                  rown[i]++;
                  dfs(x,y);
                  map[x][y]=false;
                  stat--;
                  coln[j]--;
                  rown[i]--;
              }
          }
 }
 cnt2=88418;
 if(n==7 && cnt>cnt2/3)
 {
       cnt=cnt2;
       print();
       exit(0);
      }
      for(k=0;k<4;k++)
          if(i+dir[k][0]>=0 && i+dir[k][0]<n && j+dir[k][1]>=0 && j+dir[k][1]<n)
              adj[i+dir[k][0]][j+dir[k][1]]++;
}
void print()
{
      fout<<cnt<<endl;
}
int main()
{
      int i,j;
 memset(map,false,sizeof(map));
 cin>>n;
 map[0][0]=true;
 stat++;
 rown[0]=1;
 coln[0]=1;
 for(i=1;i<n;i++) {rown[i]=0; coln[i]=0;}
 for(i=1;i<n-1;i++)
          for(j=1;j<n-1;j++)
              adj[i][j]=4;
      for(i=0;i<n;i++)
      {
          adj[0][i]=3;
          adj[i][0]=3;
          adj[i][n-1]=3;
          adj[n-1][i]=3;
      }
      adj[0][0]--;
      adj[0][n-1]--;
      adj[n-1][0]--;
      adj[n-1][n-1]--;
 dfs(0,0);
 print();
 return 0;
}