2，如果剪枝，
根据回溯的过程，会先求到dfs(n)最后那个结点，再是dfs(n-1)..dfs(1)。
剪枝应当是在结构体中N[i]增加一个变量vnow,
vnow初值为0，记录从该结点开始搜索所有int dfs(i)的返回值，并不断更新使其最大，
当搜索到i的时候，如果N[i].vnow不为0，则需要满足N[i].vnow+当前temp（前面的可行系列的总值）>vmax(所要求的最大值的当前值)，若vnow为0，则可以不满足这个条件，因为这是第一次。

Note: the number of first circle should always be 1.

Input

Output

You are to write a program that completes above process.

Sample Input

6
8

Sample Output

Case 1:
1 4 3 2 5 6
1 6 5 2 3 4
Case 2:
1 2 3 8 5 6 7 4
1 2 5 8 3 4 7 6
1 4 7 6 5 8 3 2
1 6 7 4 3 8 5 2

3
joj
jlu
acm
6
cctv
redcode
lindong
we
love
programming
3
daoyuanlee
come
on

6
11
10

Problem Source: provided by loon

#include<iostream>
#include<cstdlib>
using namespace std;
struct S
{
 string a;
 char begin;
 char end;
 int length;
 }s[13];
 int visited[13];
int temp; 
void search(int a,int num,int pre)
 {
  
  for(int i=0;i<num;i++ )
  {
   if(s[i].begin==s[pre].end&&visited[i]==0)
   {
    visited[i]=1;
    search(a+s[i].length,num,i);
    if(a+s[i].length>temp)temp=a+s[i].length;
    visited[i]=0;
   }
  }
 }
  int main()
  {
  freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
   int num;
   while(cin>>num)
   {
    int i;
  temp=0;
  for( i=0;i<num;i++)
  {
   cin>>s[i].a;
   s[i].length=(s[i].a).size();
   s[i].begin=(s[i].a)[0];
   s[i].end=(s[i].a)[s[i].length-1];
   if(s[i].length>temp)
   temp=s[i].length;
     }
  for(i=0;i<num;i++) 
     {
   memset(visited,0,sizeof(visited));
   visited[i]=1;
   search(s[i].length,num,i);
  }
  cout<<temp<<endl;
 }

  //system("PAUSE");
  return   0;
  }

以上代码超时。完全可以剪枝。
举个例子
abc
cbd
dbm
dbacmdp
我的程序一直搜啊搜，每次搜完都重新开始。比如在以a开头后，搜到c，下次再搜索时直接利用c的结果，这是深搜的特点决定的！！！
*************************
这种类似的有序搜索都可以用     *  备忘录方法*
**************************
#include<iostream>
#include<cstdlib>
using namespace std;
int num;
struct S
{
 string a;
 char begin;
 char end;
 int length;
 }s[13];
 int visited[13];
int temp;
int sum[13]; 
int search(int pre)//·µ»Ø´ÓpreµãÒÔºóµÄ×ܵÄÖµ
 {
  int j=s[pre].length,k=0;
  for(int i=0;i<num;i++ )
  {
   if(s[i].begin==s[pre].end&&visited[i]==0&&i!=pre)//必须要有I！=pre
   {
    visited[i]=1;
    k=search(i)+s[pre].length;
    if(k>j)j=k;
   }
   else
   {
    if(s[i].begin==s[pre].end&&i!=pre)//必须要有i!=pre
    return sum[i]+s[pre].length;//相当于备忘录，而且无需visited[i]=0;
   }
  }
  sum[pre]=j;
  return j;
 }
  int main()
  {
 freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
   while(cin>>num)
   {
    int i,j;
  temp=0;
  j=0;
  for( i=0;i<num;i++)
  {
   cin>>s[i].a;
   s[i].length=(s[i].a).size();
   s[i].begin=(s[i].a)[0];
   s[i].end=(s[i].a)[s[i].length-1];
   if(s[i].length>temp)
   temp=s[i].length;
     }
  for(i=0;i<num;i++) 
     {
   memset(visited,0,sizeof(visited));
            memset(sum,0,sizeof(sum));
   visited[i]=1;
   j=search(i);
   if(j>temp)
   temp=j;
  }
  cout<<temp<<endl;
 }

  //system("PAUSE");
  return   0;
  }

因为I！=pre又错了几下。
以后debug尽量自己用眼睛看，更省时间！！！！！！！！！

  int  dfs(int sum,int flag,int n,int time)//´Ótime¿ªÊ¼ËÑË÷
  {
  if(sum==0)return 1;
    if(time<n)
  {
   for(int k=time;k<n;k++)
   {
    if(mark[k]<0&&sum-length[k]>=0)
    {
     mark[k]=flag;
     if(dfs(sum-length[k],flag,n,k+1))
     return 1;
     else
     mark[k]=-1;
       } 
   }
  }
    
 return 0;
  }
  int main()
  {
  freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
  int num,n;
 
  cin>>num;
  while(num--)
  {
  int sum=0;
  cin>>n;
  for(int k=0;k<n;k++)
  {
   cin>>length[k];
   mark[k]=-1;
   sum+=length[k];
  }
  sort(length,length+n,cmp);
  if(sum%4!=0||length[0]>sum/4)
  cout<<"no"<<endl;
  else
  {
   sum/=4;
   if(dfs(sum,1,n,0))
    {
   if(dfs(sum,2,n,0))
          {
     if(dfs(sum,3,n,0))
     cout<<"yes"<<endl;
     else
     cout<<"no"<<endl;
        } 
        else
        cout<<"no"<<endl;
          }
         else
         cout<<"no"<<endl;
  }
    }
  //system("PAUSE");
  return   0;
  }
正确的解法应当是，在一起搜索。
下面是一段超时的代码
#include<iostream>
#include<cstdlib>
#include<algorithm>
using namespace std;
 int length[21];
 int mark[21];
 int flag=0;
 int target;
 bool cmp(int x,int y)
{
    return x>y;
}

  int func(int i)
  {
  while(mark[i]>0)
  i++;
  return i;
 }
  void  dfs(int sum,int n,int time,int level)//从序号为time的开始搜索
  {
  if(flag)return ;
  if(sum==0&&level==3)
  {
  flag=1;
  return;
     }
     if(sum==0)
     {
   level++;
   dfs(target,n,func(0),level);
  }
    else if(time<n)
  {
   for(int k=time;k<n;k++)
   {
    if(k>1)
               {
               
                if(length[k]==length[k-1]&&!mark[k-1])
                    continue;//显然
               }
                if(sum<length[n-1])  continue;//显然
    if(mark[k]<0&&sum-length[k]>=0)
    {
     mark[k]=1;
     dfs(sum-length[k],n,func(k+1),level);
     mark[k]=-1;
       } 
   }
  }
  }
  int main()
  {
  freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
  int num,n;
 
  cin>>num;
  while(num--)
  {
  int sum=0;
  cin>>n;
  for(int k=0;k<n;k++)
  {
   cin>>length[k];
   mark[k]=-1;
   sum+=length[k];
  }
  sort(length,length+n,cmp);
  if(sum%4!=0||length[0]>sum/4)
  cout<<"no"<<endl;
  else
  {
   sum/=4;
   target=sum;
   dfs(sum,n,0,0);
       if(flag==0)
       cout<<"no"<<endl;
       else
       cout<<"yes"<<endl;
  }   
    }
  //system("PAUSE");
  return   0;
  }

上面超时就超时原因是减枝不彻底。level标记也不太好
决定另外炉灶,先看看别人的代码
#include<iostream>
#include<algorithm>
using namespace std;
int s[21];
int v[21];
int len;
int m;
int dfs(int cur,int num,int beg,int fin)
{    
 int solve(int );
 if(num==1)
  return 1;
 if(cur==len)
 {
  return solve(num-1);
 }
   for(int i=beg;i>=fin;i--)
   {
    if(!v[i]&&cur+s[i]<=len)
    {  
     v[i]=1;
     if(dfs(cur+s[i],num,i-1,fin))
      return 1;
     v[i]=0;
    }
   }
   return 0;
}

int solve(int edge_num)
{   
     int i;
  for(i=m;i>=1;i--)
   if(!v[i])
   { 
    v[i]=1;
    if(dfs( s[i],edge_num,i-1,1))
     return 1;
    v[i]=0;
   }
 return 0;
}

int main()
{
 int n;
 cin>>n;
 while(n--)
 {
  
  cin>>m;
  int i;
  int sum=0;
  for(i=1;i<=m;i++)
  {
   cin>>s[i];
   sum+=s[i];
   v[i]=0;
  }
  
  len=sum/4;
  if(4*len!=sum)
  {
   cout<<"no"<<endl;
   continue;
  }
  sort(s+1,s+m+1);
  if(s[m]>len)
  {
   cout<<"no"<<endl;
   continue;
  }
  if(solve(4))
   cout<<"yes"<<endl;
  else
   cout<<"no"<<endl;
 }
 return 0;
}//剪枝还可以做得更好！！！
人家的solve写得好！！，结合dfs.

Output

Print a new line after each test case.

Sample Input

2
1
1 2
0 0
5
3
1 2
3 5
3 1
2 4
4 5
0 0
5
5
5 1
5 2
5 3
5 4
4 1
4 2
0 0
0

Sample Output

Case 1: The longest path from 1 has length 1, finishing at 2.
Case 2: The longest path from 3 has length 4, finishing at 5.
Case 3: The longest path from 5 has length 2, finishing at 1.

提交了10次，AC 3次，超时4次，wa 3次。

很无语。

应该是动态规划最好，但是我不是很熟，用了搜索。以下是超时的代码

#include<iostream>
#include<cstdlib>
using namespace std;
int path[101][101];
int mark[101];
int len[101];//
int end[101];
int dfs(int start,int num)//返回从当前点出发的最大长度
{
if(mark[start]==1)return len[start];
mark[start]=1;
end[start]=start;
for(int i=1;i<=num;i++)
{
if(path[start][i])
{
if(len[start]<dfs(i,num)+1)
{
len[start]=len[i]+1;
end[start]=end[i];
}
else
if(len[start]==len[i]+1&&end[start]>end[i])
end[start]=end[i];
}
}
mark[start]=0;//这句坚决不需要 
return len[start];
}
int main()
{
// freopen("s.txt","r",stdin);
//freopen("key.txt","w",stdout);
int j,k,turn=0;
int start,num;
while(cin>>num)
{
turn++;
if(num==0)break;
memset(path,0,sizeof(path));
memset(mark,0,sizeof(mark));
memset(len,0,sizeof(len));
memset(end,0,sizeof(end));
cin>>start;
while(cin>>j>>k)
{
if(j==0)break;
path[j][k]=1;
}
cout<<"Case "<<turn<<": The longest path from "<<start<<" has length "<<dfs(start,num)<<", finishing at "<<end[start]<<"."<<endl<<endl;
}
//system("PAUSE");
return   0;
}
以下是ac的代码
#include<iostream>
#include<cstdlib>
using namespace std;
int path[102][102];
int mark[102], len[102],end[102];
int dfs(int start,int num)//返回从当前点出发的最大长度
{
if(mark[start]==1)return len[start];
mark[start]=1;
end[start]=start;
len[start]=0;
int i,t;
for( i=1;i<=num;i++)
{
if(path[start][i])
{
t=dfs(i,num)+1;
if(t>len[start])
{
len[start]=t;
end[start]=end[i];
}
else
if(len[start]==t)
{
if(end[start]>end[i])
end[start]=end[i];
}
}
}
return len[start];
}
int main()
{
//freopen("s.txt","r",stdin);
//freopen("key.txt","w",stdout);
int j,k,turn=0;
int start,num;
while(cin>>num,num)
{
turn++;
memset(path,0,sizeof(path));
memset(mark,0,sizeof(mark));
memset(len,0,sizeof(len));
memset(end,0,sizeof(end));
cin>>start;
while(cin>>j>>k,j||k)
{
path[j][k]=1;
}
dfs(start,num);
cout<<"Case "<<turn<<": The longest path from "<<start<<" has length "<<len[start]<<", finishing at "<<end[start]<<"."<<endl<<endl;
}
//system("PAUSE");
return   0;
}
不妨执行一下
5
3
1 2
3 5
3 1
2 4
4 5
0 0
先是len[3]=0;end[3]=3;flag[3]=1;
再执行t=dfs(1)+1,
转入dfs（1）；len[1]=0;end[1]=1;flag[1]=1;
再执行t=dfs(2)+1;
转入dfs(2),len[2]=0;end[2]=2;flag[2]=1;
再执行t=dfs(4)+1
转入dfs(4),len[4]=0;end[4]=4;flag[4]=1;
再转入t=dfs（5)+1;
转入dfs(5),len[5]=0;end[5]=5;flag[5]=1;return(len[5]=0);
则t=1;t>len[4];len[4]=1;end[4]=end[5]=5;再看4没了其他相邻元素。dfs(4)=return(len[4])=1;
t=dfs(4)+1=2;len[2]=t=2;end[2]=end[4]=5;再看2没了其他相邻元素，dfs(2)=return(len(2)=2;
再看t=dfs(2)+1=3;len[1]=t=3;end[1]=en[2]=5;再看1有没有其他相邻元素，dfs(1)=return(len(1)=3
再执行t=dfs(1)+1,len[3]=4;end[3]=end[1]=5;再看3有没有其他相邻元素，有dfs(5),已经遍历到了，所以dfs（5）return len【5】。
没有影响。
假设改为
5
3
5 2
3 5
3 1
2 4
4 1
0 0
执行时会走3->1>这时的1结点len[1]已经求的   3>5>2>4>1len[1]已知了

On a chess board sizes of m*n(1<=m<=5,1<=n<=5),given a start position,work out the amount of all the different paths through which the horse could return to the start position.(The position that the horse passed in one path must be different.The horse jumps in a way like "日")

Input

The input consists of several test cases.The size of the chess board m,n(row,column),and the start position v,h(vertical , horizontal) ,separated by a space.The left-up point is (0,0)

Output

the amount of the paths in a single line

Sample Input

5 4 3 1

Sample output

4596

解析：
马走日，八个方向，
不允许某条路径上重复。
if(path[i][j]==1)
{
   if(i==v && j==h)
    counts++;
//重复的如果是出发点，返回值
   return ;//无论怎样，只要重复就返回
}

Description

The ministers of the cabinet were quite upset by the message from the Chief of Security stating that they would all have to change the four-digit room numbers on their offices.
— It is a matter of security to change such things every now and then, to keep the enemy in the dark.
— But look, I have chosen my number 1033 for good reasons. I am the Prime minister, you know!
— I know, so therefore your new number 8179 is also a prime. You will just have to paste four new digits over the four old ones on your office door.
— No, it’s not that simple. Suppose that I change the first digit to an 8, then the number will read 8033 which is not a prime!
— I see, being the prime minister you cannot stand having a non-prime number on your door even for a few seconds.
— Correct! So I must invent a scheme for going from 1033 to 8179 by a path of prime numbers where only one digit is changed from one prime to the next prime.

Now, the minister of finance, who had been eavesdropping, intervened.
— No unnecessary expenditure, please! I happen to know that the price of a digit is one pound.
— Hmm, in that case I need a computer program to minimize the cost. You don't know some very cheap software gurus, do you?
— In fact, I do. You see, there is this programming contest going on... Help the prime minister to find the cheapest prime path between any two given four-digit primes! The first digit must be nonzero, of course. Here is a solution in the case above.

1033
1733
3733
3739
3779
8779
8179

The cost of this solution is 6 pounds. Note that the digit 1 which got pasted over in step 2 can not be reused in the last step – a new 1 must be purchased.

Input

Output

Sample Input

3
1033 8179
1373 8017
1033 1033

Sample Output

6
7
0