回溯——oj1172 健康的荷斯坦奶牛

　　花了一个多小时的时间搞定了这道题= =

　　给出题面:

　　很明显这道题是一道搜索的题，我用的是dfs+回溯。暴力的方法是设置一个计数器，如果满足条件时就进入下一重dfs，每次都判断是否达到要求，如果所用的肥料数最小的话就更新数组，这样的话可以拿下80%的数据，但仔细算算，如果是极限数据的话，需要进行15重dfs，每重都有一个二重循环，这样的话时间复杂度大概是（15*15）^15，很明显这样会超时，这时候需要做优化。

　　仔细想想，每重dfs都是从数组的起点开始搜索，但实际上搜索的时候做了许多次重复，所以用了大部分的时间做了重复的操作，那具体应该怎么办呢？很显然，因为每次都是从数组起点开始搜索，所以上一重dfs中所搜索到的数的之前的数都是做的重复操作，那么可以建立一个指针，指针指向上一重dfs中搜索到的位置，在本次搜索中从指针的下一位开始搜索即可。

　　此外还有一点可优化：因为要求输出使用饲料的最小数量，所以可以进行特判，当搜索的次数大于已经搜索到的最小次数时return即可。

　　代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int V,v[31],G,g[31][31],ans=9999,n[31];
bool flag,f[31],vitamin[31];
void dfs(int num,int place)
{
    if (num>=ans)    return;
    flag=true;
    for (int i=1;i<=V;i++)
        if (v[i]>n[i])    {flag=false;    break;}
    if (flag)
    {
        if (num<ans)
        {
            ans=num;
            for (int i=1;i<=G;i++)
                f[i]=vitamin[i];
        }
    }
    else
        for (int i=place+1;i<=G;i++)
        {
            if (!vitamin[i])
            {
                for (int j=1;j<=V;j++)
                    n[j]+=g[i][j];
                vitamin[i]=true;
                dfs(num+1,i);
                vitamin[i]=false;
                for (int j=1;j<=V;j++)
                    n[j]-=g[i][j];
            }
        }
}
int main()
{
    //freopen("add.in","r",stdin);
    //freopen("add.out","w",stdout);
    memset(n,0,sizeof(n));
    memset(vitamin,false,sizeof(vitamin));
    memset(f,false,sizeof(f));
    scanf("%d",&V);
    for (int i=1;i<=V;i++)
        scanf("%d",&v[i]);
    scanf("%d",&G);
    for (int i=1;i<=G;i++)
        for (int j=1;j<=V;j++)
            scanf("%d",&g[i][j]);
    dfs(0,0);
    printf("%d ",ans);
    for (int i=1;i<=G;i++)
        if (f[i])
            printf("%d ",i);
    return 0;
}