Depth-First Search
深度搜索和宽度搜索对立，宽度搜索是横向搜索（队列实现），而深度搜索是纵向搜索（递归实现）；
看下面这个例子：
现在需要驾车穿越一片沙漠，总的行驶路程为L。小胖的吉普装满油能行驶X距离，同时其后备箱最多能放下四桶油。在起点有N种汽油，每种汽油都有无限桶，一桶能行驶距离Ai。现在小胖想知道：能不能恰好带四桶油，再加上出发前装满的油，使得恰好能行驶L距离。
两个 恰好 使得这道题的难度增加；
如何才能做到恰好？ 动态规划 还是 搜索？
先看看搜索行不行
限制条件是：“恰好四桶油”，“恰好行驶距离为L”
那就一个一个的试试，深搜一把试试看
bool flag = false ;
void dfs( int tong , int s ) {
if(tong > 4 || s > L)
return ;
if(tong == 4 && s == L) {
flag = true ;
return ;
}
for(int i = 1 ; i <= n ; i++ ) // n 为汽油种类
for(int j = 1 ; j <= 4 ; j++)
dfs(tong + j , s + a[i] * j ) ;
}
如果能够找到 flag 就为 true ；
判断 flag 即可得出结果；
具体实现代码如下：
#include<iostream>
#include<string.h>
#include<string>
#include<algorithm>
using namespace std ;
int a[1005] ;
int L , X , N ;
int ans ;
void dfs(int a1 , int sum) {
if(a1 > 4 || sum > L - X)
return ;
if(a1 == 4 && sum == L - X) {
ans = 1 ;
return ;
}
for(int i = 1 ; i <= N ; i++)
for(int j = 1 ; j <= 4 ; j++)
dfs(a1+j , sum + a[i] * j ) ;
}
int main() {
int n ;
cin >> n ;
while(n--) {
cin >> L >> X >> N ;
memset(a,0,sizeof(a[0])) ;
for(int i = 1 ; i <= N ; i++)
cin >> a[i] ;
sort(a+1,a+1+n) ;
ans = 0 ;
dfs(0,0) ;
if(ans)
cout << "Yes" << endl ;
else
cout << "No" << endl ;
}
return 0 ;
}
很高兴总算找到答案了，但是不要忘了这个数据可能会很大，如果还用这个方法肯定会超时，如果一个算法速度达不到，这个算法是没有多大意义的。
那我们下面应该想想能不能用对程序进行优化，看到上面是不是有很多地方都是重复计算了，一般可以用多消耗一些内存换取程序运行的时间；
观察发现，当带四桶相同的油，多算了好多，既然是深度搜索，应该一直往深度探索，所以以上程序可修改为：
#include<iostream>
#include<string.h>
#include<string>
#include<algorithm>
using namespace std ;
int a[1005] ;
int L , X , N ;
int ans ;
void dfs(int i ,int a1 , int sum) {
if(a1 > 4 || sum > L - X)
return ;
if(a1 == 4 && sum == L - X) {
ans = 1 ;
return ;
}
for( ; i <= N ; i++)
for(int j = 1 ; j <= 4 ; j++)
dfs(i+1,a1+j , sum + a[i] * j ) ;
}
int main() {
int n ;
cin >> n ;
while(n--) {
cin >> L >> X >> N ;
memset(a,0,sizeof(a[0])) ;
for(int i = 1 ; i <= N ; i++)
cin >> a[i] ;
sort(a+1,a+1+n) ;
ans = 0 ;
dfs(1,0,0) ;
if(ans)
cout << "Yes" << endl ;
else
cout << "No" << endl ;
}
return 0 ;
}
就算如此优化，还是避免不了超时的结果，那还应该如何优化才能达到想要的结果呢，结果发现，还存在可以优化的地方，如果一桶汽油就可以跑完全程，那样的汽油就应该抛弃，通过先前对汽油种类排序，最后留下来的都是一桶跑不完全程的，当全程不能够分成四份时，那么同一种汽油最多取三桶；
通过分析再次对上面程序就行优化得到下面程序：
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int a[1002];
int l,x,n,m;
int flag;
void dfs(int i,int count,int sum)
{
int j;
if(count>4||sum>l||flag)
return;
if(count==4&&sum==l)
{
flag=1;
return ;
}
for(;i<n;i++)
for(j=1;j<=m;j++)
dfs(i+1,count+j,sum+j*a[i]);
}
int main()
{
int t;
int i,j;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&l,&x,&n);
l=l-x;
for(i=0;i<n;i++)
scanf("%d",&a[i]);
sort(a,a+n);
for(i=0;i<n;i++)
if(a[i]>=l) //若第a[i]种汽油，一桶的行驶路程不小于l-x，后面的搜索情况不能满足题意，直接舍弃后面的数据
{
n=i;
break;
}
m=4;
if(l%4!=0) //若l-x不能被4整除，每种汽油最多带3桶，可能满足题意
m=3;
flag=0;
dfs(0,0,0);
if(flag)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
下面介绍一种用动态规划解答方案：
用 dp[ i ][ j ] 代表 带 i 桶汽油，恰好能行驶 j 公里，如果 dp[ 4 ][ L ] = true 则代表存在 ；
#include<iostream>
#include<string>
#include<string.h>
using namespace std ;
int main() {
int n ;
cin >> n ;
while(n--) {
bool dp[6][1005] ; // dp[i][j] 带 i 桶汽油，恰好能行驶 j 公里
memset(dp,false,sizeof(dp)) ;
int L , X , N ;
cin >> L >> X >> N ;
int a[1005];
for(int ii = 1 ; ii <= N ; ii++)
cin >> a[ii] ;
L = L - X ;
dp[0][0] = true ; // 带 0 桶汽油 ， 恰好行驶 0 公里
for(int i = 0 ; i <= L ; i++) // 控制条件有两个时，主要判断哪个在前，哪个在后
for(int j = 0 ; j <= 4 ; j++) {
if(dp[j][i])
for(int k = 1 ; k <= N ; k++) {
if(i + a[k] <= L )
dp[j+1][i+a[k]] = true ; // 为动态变量赋值
}
}
if(dp[4][L])
cout << "Yes" << endl ;
else
cout << "No" << endl ;
}
return 0 ;
}
