usaco——holstein

不知怎么的，递归函数让我头大，总是不习惯这种思维。最后千辛万苦把错误找到了。看了看效率，比官方的逊色一点儿。读了一下，都是递归。但是搜索方案不一样。我的先是按总饲料数递增来搜。官方的没有这个顺序。他就是原始搜索，从第一饲料，然后加第二饲料。。。。。。，每加入新饲料都检验，存下当前最好的。中间有剪枝。我想这两种方法的好坏很大程度上决定于具体的数据。效率分析上，就是有的我快，有的他快，当然他快的多一点儿。。。

Healthy Holsteins
Burch & Kolstad

Farmer John prides himself on having the healthiest dairy cows in the world. He knows the vitamin content for one scoop of each feed type and the minimum daily vitamin requirement for the cows. Help Farmer John feed his cows so they stay healthy while minimizing the number of scoops that a cow is fed.

Given the daily requirements of each kind of vitamin that a cow needs, identify the smallest combination of scoops of feed a cow can be fed in order to meet at least the minimum vitamin requirements.

Vitamins are measured in integer units. Cows can be fed at most one scoop of any feed type. It is guaranteed that a solution exists for all contest input data.

PROGRAM NAME: holstein

INPUT FORMAT

Line 1:	integer V (1 <= V <= 25), the number of types of vitamins
Line 2:	V integers (1 <= each one <= 1000), the minimum requirement for each of the V vitamins that a cow requires each day
Line 3:	integer G (1 <= G <= 15), the number of types of feeds available
Lines 4..G+3:	V integers (0 <= each one <= 1000), the amount of each vitamin that one scoop of this feed contains. The first line of these G lines describes feed #1; the second line describes feed #2; and so on.

SAMPLE INPUT (file holstein.in)

4
100 200 300 400
3
50   50  50  50
200 300 200 300
900 150 389 399

OUTPUT FORMAT

The output is a single line of output that contains:

• the minimum number of scoops a cow must eat, followed by:
• a SORTED list (from smallest to largest) of the feed types the cow is given

If more than one set of feedtypes yield a minimum of scoops, choose the set with the smallest feedtype numbers.

SAMPLE OUTPUT (file holstein.out)

2 1 3

自己的代码：
/*  
ID: guangxue1  
PROG: holstein 
LANG: C++  
*/

#include <fstream>
using namespace std;

int c, have;
int st[25];
int choose;
int food[15][25];
int memory[15];
int vit[25];

inline bool IsEnough()
{
  for(int i=0; i<c; ++i)
    if(vit[i]<st[i])
      return false;
  return true;
}
void core(int cnt,int n,int N)
{ 
  if(cnt>0&&n<N)
  for(int i=n; i<N&&have==0; ++i) 
    { for(int j=0; j<c&&have==0; ++j)
         vit[j]+=food[i][j];
      memory[cnt]=i;
      core(cnt-1,i+1,N); 
       if(IsEnough())
       { have=1;return; }
       else 
        for(int j=0; j<25; ++j) vit[j]-=food[i][j];
    }
  if(have==1) return;    
}


int main()
{
  ifstream fin("holstein.in");
  ofstream fout("holstein.out");
  fin>>c;
  for(int i=0; i<c; ++i)
     fin>>st[i];
  fin>>choose;
  for(int i=0; i<choose; ++i)
     for(int j=0; j<c; ++j)
        fin>>food[i][j];
  for(int i=1; i<choose+1; ++i)
    { core(i,0,choose); if(have==1){ fout<<i<<' ';for(int j=i; j>1; --j)
   fout<<memory[j]+1<<' '; fout<<memory[1]+1<<endl; break;}}
  return 0;
}
 

官方代码：

#include <stdio.h>
#include <assert.h>

#define MAXV 25
#define MAXF 15

int req[MAXV]; /* the vitamin requirements */
int numv; /* number of vitamins */

int feeds[MAXF][MAXV]; /* the vitamin within each feed */
int numf; /* number of feeds */

int best; /* the minimum number of feeds to use found thus far */
int bestf[MAXF]; /* the set */

int curf[MAXF]; /* the current set of feeds being considered */

void find_feed(int fcnt, int fid)
 { /* fcnt is the number of feeds in the current mixture,
      fid is the identifier of the first feed to try adding (last feed + 1) */
  int lv;

  /* check if the requirement has been met */
  for (lv = 0; lv < numv; lv++)
    if (req[lv] > 0) break; 
  if (lv >= numv)
   { /* all the requirements are met */
    /* we know this is better, since we wouldn't have checked it otherwise
       (see below) */
    best = fcnt;
    for (lv = 0; lv < best; lv++)
      bestf[lv] = curf[lv];
    return;
   }

  while (fid < numf && fcnt+1 < best)
   { /* try adding each feed to the mixture */
     /* the fcnt+1 < best ensures that we stop if there's no hope
	in finding a better solution than one found already */

    /* add the vitamins from this feed */
    for (lv = 0; lv < numv; lv++)
      req[lv] -= feeds[fid][lv]; 
    curf[fcnt] = fid; /* put it in the list */

    find_feed(fcnt+1, fid+1); 

    /* undo adding the vitamins */
    for (lv = 0; lv < numv; lv++)
      req[lv] += feeds[fid][lv];

    /* next feed */
    fid++;
   }
 }

int main(void) 
 {
  FILE *fin, *fout;
  int lv, lv2;

  fin = fopen("holstein.in", "r");
  fout = fopen("holstein.out", "w");
  assert(fin);
  assert(fout);

  fscanf (fin, "%d", &numv);
  for (lv = 0; lv < numv; lv++)
    fscanf (fin, "%d", &req[lv]);
  fscanf (fin, "%d", &numf);
  for (lv = 0; lv < numf; lv++)
    for (lv2 = 0; lv2 < numv; lv2++)
      fscanf (fin, "%d", &feeds[lv][lv2]);

  best = numf+1;
  find_feed(0, 0);

  fprintf (fout, "%i", best);
  for (lv = 0; lv < best; lv++) 
    fprintf (fout, " %i", bestf[lv]+1);
  fprintf (fout, "/n");
  return 0;
 }