USACO 2.1 Healthy Holsteins

        这道题对我来说的难点，一开始绊在搜索方式的选择上。从题意粗看，如果用BFS的方法，搜索的次数会比较少，然而用BFS的话，就不能继承之前的计算结果了，而且迭代起来也比较麻烦。所以退而求其次，使用DFS的搜索方式，这样程序的逻辑比较顺，因为迭代的次数并没有想象当中的那么多，所以暴力搜索还是可行的。

        大概思路是这样的：通过DFS迭代，寻找满足条件的组合。在满足条件的组合中，选出长度最短的解。

        其中，辅助用到的是一个跟V一样长的bool数组，用于标明上次计算中，这一种维他命是否已经超过需求的维他命，否则的话，这次就跳过不去计算。另外还有记录上次排列的int数组和数组的长度。

        如果某次检测中，所有维他命都符合了要求，那么就不迭代它之后的排列组合，这里做了一个这样的剪枝。比如说，125这个排列可以完全满足条件的话，那么就不再迭代1256或1257之类这样的组合。

        如果找到了满足条件的解，那么就记录它的组合。

        在满足条件的这些解中，由上向下寻找长度最短的解，由于题目中还有编号尽量靠前的这个要求，所以这样查找一定能找到题目需要的那组。

        话说在这个地方，我还给测试数据坑了一下233，我没有对存储最优解位置的变量做初始化，如果G只有1个而且G等于V的话，由于我的判断条件是小于，而不是小于等于，这样程序就找不到任何满足条件的解了。

        附上代码：

#include <iostream>
#include <fstream>
using namespace std;

const int MAXV = 25;
const int MAXG = 15;
int V, G;
int vs[MAXV];
int gs[MAXG][MAXV];
int feeds[40000][MAXG];
int feedLens[40000];
int n = 0;

void findFeeds(bool* flags, int* tmpFeeds, int tmpFeedLen)
{
    if (tmpFeeds[tmpFeedLen-1] == G-1)
        return;

    int i, j, k;
    bool flag;
    bool tmpFlags[MAXV];
    int tmp;
    for (i = tmpFeedLen == 0 ? 0 : tmpFeeds[tmpFeedLen-1]+1; i < G; i ++) {
        flag = true;
        for (j = 0; j < V; j ++) {
            if (!flags[j]) {
                tmp = 0;
                for (k = 0; k < tmpFeedLen; k ++)
                    tmp += gs[tmpFeeds[k]][j];
                tmp += gs[i][j];
                tmpFlags[j] = tmp >= vs[j];
                flag = tmpFlags[j] ? flag : false;
            }
            else
                tmpFlags[j] = true;
        }
        if (flag) {
            for (j = 0; j < tmpFeedLen; j ++)
                feeds[n][j] = tmpFeeds[j];
            feeds[n][tmpFeedLen] = i;
            feedLens[n] = tmpFeedLen + 1;
            n ++;
            continue;
        }
        tmpFeeds[tmpFeedLen] = i;
        findFeeds(tmpFlags, tmpFeeds, tmpFeedLen+1);
    }
}

int main()
{
    ifstream fin ("holstein.in");
    ofstream fout ("holstein.out");
    int i, j;

    fin >> V;
    for (i = 0; i < V; i ++)
        fin >> vs[i];
    fin >> G;
    for (i = 0; i < G; i ++)
        for (j = 0; j < V; j ++)
            fin >> gs[i][j];

    bool* flags = new bool[MAXV];
    int* tmpFeeds = new int[MAXG];
    findFeeds(flags, tmpFeeds, 0);

    int minFeedLen = G;
    int minFeedPos = 0;
    for (i = 0; i < n; i ++) {
        if (feedLens[i] < minFeedLen) {
            minFeedLen = feedLens[i];
            minFeedPos = i;
        }
    }
    fout << minFeedLen;
    for (i = 0; i < minFeedLen; i ++)
        fout << " " << feeds[minFeedPos][i] + 1;
    fout << endl;

    return 0;
}

        看了一下官方解，没想到官方比我想的办法还要暴力，由于G最多是15，所以每种feed选或不选的话，最多也就2^15种组合，把每种组合的可行性计算出来，再找出其中的最优解。

        每次最后都要说两句闲话，从这道题里得到的经验是，剪枝有时候适度就好，不一定要追求最优解，暴力穷举可以作为一种可行的方案。

        我在大多数时候都奉行着空间换时间的原则，然而看官方解，与我的程序内存的消耗相差悬殊，而迭代次数其实并没有严重影响到时间的消耗，其中的权衡果然是门学问……