void Backtracking(int i) 
{
  
	if(i>n) 
	{ 
		Print();
		if(bestPrice>bp)
		{
			bp=bestPrice;
			for(int j=1;j<=n;j++)
               bA[j]=bestAnswer[j];
		}
		return; 
         } 
if(currentWeight+weight[i]<=c) 
	{ //将物品i放入背包,搜索左子树 
		bestAnswer[i] = 1; 
		currentWeight += weight[i]; 
		bestPrice += price[i]; 
		Backtracking(i+1); //完成上面的递归,返回到上一结点,物品i不放入背包,准备递归右子树 
		currentWeight -= weight[i]; 
		bestPrice -= price[i]; 
	} bestAnswer[i] = 0; 
	Backtracking(i+1); 
} 
void Backtracking(int now) {
	if(now >= 12)
		return;
	if(now > 0) {
		int i, f = 1, c = now;
		int tmp = 2, count = 2;
		for(i = 2; i <= c+1; i++)
			f *= i;
		for(i = 0; i < c-1; i++) {
			if(step[i] == step[i+1] && step[i] == 2)
				count++, tmp *= count;
			else {
				if(step[i] == 2)
					f /= tmp, tmp = 2, count = 2;
			}
		}		
		if(step[i] == 2)
			f /= tmp, tmp = 2, count = 2;
		ans[c+1] += f;
	}
	step[now] = 0;
	Backtracking(now+1);
	step[now] = 2;
	Backtracking(now+1);
}
void Backtracking(int l, int r) {
	if(l+1 < r) {
		int m = Wy[l][r];
		printf("(");
		Backtracking(l, m);
		printf(" x ");
		Backtracking(m+1, r);
		printf(")");
	}
	if(l == r)
		printf("A%d", l+1);
	if(l+1 == r)
		printf("(A%d x A%d)", l+1, r+1);
}
 vector<string> readBinaryWatch(int num) {
     if (num == 0) {
         result.push_back("0:00");
         return result;
     }
     vector<bool> leds(10, false);
     Backtracking(leds, 0, num);
     return result;
 }
int main() {
	int t, n;
	Backtracking(0);
	scanf("%d", &t);
	while(t--) {
		scanf("%d", &n);
		printf("%d\n", ans[n]);
	}
    return 0;
}
 void Backtracking(vector<bool>& leds, int index, int num) {
     if (index >= 10 || num <= 0) {
         if (num == 0) {
             int hour = 0, minute = 0;
             for (int i = 0; i < 4; ++i) {
                 if (leds.at(i)) {
                     int shift = 4 - i - 1;
                     hour += (1 << shift);
                 } 
             }
             for (int i = 4; i < 10; ++i) {
                 if (leds.at(i)) {
                     int shift = 6 - (i - 4) - 1;
                     minute += (1 << shift);
                 }
             }
             if (hour >= 12 || minute >= 60) {   // 0:00 to 11:59
                 return;
             }
             string tmp;
             tmp.append(to_string(hour));
             tmp.append(":");
             if (minute < 10) {
                 tmp.append("0");
             }
             tmp.append(to_string(minute));
             result.push_back(tmp);
         }
         return;
     }
     //off
     Backtracking(leds, index + 1, num);
     
     //on
     leds.at(index) = true;
     Backtracking(leds, index + 1, num - 1);
     leds.at(index) = false;
 }
void main() 
{ 	int i; 
    printf("请输入物品的数量:\n");
    scanf("%d",&n);
    printf("请输入背包的容量(能承受的重量):\n");
    scanf("%d",&c);
    printf("请依次输入%d个物品的重量:\n",n);

for(i=1;i<=n;i++)
        scanf("%d",&weight[i]);
    printf("请依次输入%d个物品的价值:\n",n);
 for(i=1;i<=n;i++)
        scanf("%d",&price[i]);
	printf("各符合条件的路径为:\n"); 
	Backtracking(1);
	printf("*******************************************************\n");
	printf("\nthe best answer is {"); 
	for(i=1;i<n;++i) 
		printf("%d,",bA[i]); 
	printf("%d}\tthe price is %d\n",bA[i],bp); 
 }
main() {
	int n, A[11], C = 0;
	while(scanf("%d", &n) == 1 && n) {

		for(a = 0; a < n; a++)
			scanf("%d %d", &A[a], &A[a+1]);
		for(a = 1; a < n; a++) {
			for(b= 0, c= a + b; c < n; b++, c++) {
				int min = 2147483647, t, set;
				for(d = b; d < c; d++) {
					t = DP[b][d] + DP[d+1][c] + A[b]*A[d+1]*A[c+1];
					if(min > t) {
						min = t, set = d;
					}
				}
				DP[b][c] = min, Wy[b][c] = set;
			}
		}
		printf("Case %d: ", ++C);
		Backtracking(0, n-1);
		puts("");
	}
	return 0;
}
Exemple #9
0
/*! \fn solve system with Newton-Raphson
 *
 *  \param [in]  [n] size of equation
 *                [eps] tolerance for x
 *                [h] tolerance for f'
 *                [k] maximum number of iterations
 *                [work] work array size of (n*X)
 *                [f] user provided function
 *                [data] userdata
 *                [info]
 *				  [calculate_jacobian] flag which decides whether Jacobian is calculated
 *					(0)  once for the first calculation
 * 					(i)  every i steps (=1 means original newton method)
 * 					(-1) never, factorization has to be given in A
 *
 */
int _omc_newton(int(*f)(int*, double*, double*, void*, int), DATA_NEWTON* solverData, void* userdata)
{

  int i, j, k = 0, l = 0, nrsh = 1;
  int *n = &(solverData->n);
  double *x = solverData->x;
  double *fvec = solverData->fvec;
  double *eps = &(solverData->ftol);
  double *fdeps = &(solverData->epsfcn);
  int * maxfev = &(solverData->maxfev);
  double *fjac = solverData->fjac;
  double *work = solverData->rwork;
  int *iwork = solverData->iwork;
  int *info = &(solverData->info);
  int calc_jac = 1;

  double error_f  = 1.0 + *eps, scaledError_f = 1.0 + *eps, delta_x = 1.0 + *eps, delta_f = 1.0 + *eps, delta_x_scaled = 1.0 + *eps, lambda = 1.0;
  double current_fvec_enorm, enorm_new;


  if(ACTIVE_STREAM(LOG_NLS_V))
  {
    infoStreamPrint(LOG_NLS_V, 1, "######### Start Newton maxfev: %d #########", (int)*maxfev);

    infoStreamPrint(LOG_NLS_V, 1, "x vector");
    for(i=0; i<*n; i++)
      infoStreamPrint(LOG_NLS_V, 0, "x[%d]: %e ", i, x[i]);
    messageClose(LOG_NLS_V);

    messageClose(LOG_NLS_V);
  }

  *info = 1;

  /* calculate the function values */
  (*f)(n, x, fvec, userdata, 1);

  solverData->nfev++;

  /* save current fvec in f_old*/
  memcpy(solverData->f_old, fvec, *n*sizeof(double));

  error_f = current_fvec_enorm = enorm_(n, fvec);

  while(error_f > *eps && scaledError_f > *eps  &&  delta_x > *eps  &&  delta_f > *eps  && delta_x_scaled > *eps)
  {
    if(ACTIVE_STREAM(LOG_NLS_V))
    {
      infoStreamPrint(LOG_NLS_V, 0, "\n**** start Iteration: %d  *****", (int) l);

      /*  Debug output */
      infoStreamPrint(LOG_NLS_V, 1, "function values");
      for(i=0; i<*n; i++)
        infoStreamPrint(LOG_NLS_V, 0, "fvec[%d]: %e ", i, fvec[i]);
      messageClose(LOG_NLS_V);
    }

    /* calculate jacobian if no matrix is given */
    if (calc_jac == 1 && solverData->calculate_jacobian >= 0)
    {
      (*f)(n, x, fvec, userdata, 0);
      solverData->factorization = 0;
      calc_jac = solverData->calculate_jacobian;
    }
    else
    {
      solverData->factorization = 1;
      calc_jac--;
    }


    /* debug output */
    if(ACTIVE_STREAM(LOG_NLS_JAC))
    {
      char buffer[4096];

      infoStreamPrint(LOG_NLS_JAC, 1, "jacobian matrix [%dx%d]", (int)*n, (int)*n);
      for(i=0; i<solverData->n;i++)
      {
        buffer[0] = 0;
        for(j=0; j<solverData->n; j++)
          sprintf(buffer, "%s%10g ", buffer, fjac[i*(*n)+j]);
        infoStreamPrint(LOG_NLS_JAC, 0, "%s", buffer);
      }
      messageClose(LOG_NLS_JAC);
    }

    if (solveLinearSystem(n, iwork, fvec, fjac, solverData) != 0)
    {
      *info=-1;
      break;
    }
    else
    {
      for (i =0; i<*n; i++)
        solverData->x_new[i]=x[i]-solverData->x_increment[i];

      infoStreamPrint(LOG_NLS_V,1,"x_increment");
      for(i=0; i<*n; i++)
        infoStreamPrint(LOG_NLS_V, 0, "x_increment[%d] = %e ", i, solverData->x_increment[i]);
      messageClose(LOG_NLS_V);

      if (solverData->newtonStrategy == NEWTON_DAMPED)
      {
        damping_heuristic(x, f, current_fvec_enorm, n, fvec, &lambda, &k, solverData, userdata);
      }
      else if (solverData->newtonStrategy == NEWTON_DAMPED2)
      {
        damping_heuristic2(0.75, x, f, current_fvec_enorm, n, fvec, &k, solverData, userdata);
      }
      else if (solverData->newtonStrategy == NEWTON_DAMPED_LS)
      {
        LineSearch(x, f, current_fvec_enorm, n, fvec, &k, solverData, userdata);
      }
      else if (solverData->newtonStrategy == NEWTON_DAMPED_BT)
      {
        Backtracking(x, f, current_fvec_enorm, n, fvec, solverData, userdata);
      }
      else
      {
        /* calculate the function values */
        (*f)(n, solverData->x_new, fvec, userdata, 1);
        solverData->nfev++;
      }

      calculatingErrors(solverData, &delta_x, &delta_x_scaled, &delta_f, &error_f, &scaledError_f, n, x, fvec);

      /* updating x */
      memcpy(x, solverData->x_new, *n*sizeof(double));

      /* updating f_old */
      memcpy(solverData->f_old, fvec, *n*sizeof(double));

      current_fvec_enorm = error_f;

      /* check if maximum iteration is reached */
      if (++l > *maxfev)
      {
        *info = -1;
        warningStreamPrint(LOG_NLS_V, 0, "Warning: maximal number of iteration reached but no root found");
        break;
      }
    }

    if(ACTIVE_STREAM(LOG_NLS_V))
    {
      infoStreamPrint(LOG_NLS_V,1,"x vector");
      for(i=0; i<*n; i++)
        infoStreamPrint(LOG_NLS_V, 0, "x[%d] = %e ", i, x[i]);
      messageClose(LOG_NLS_V);
      printErrors(delta_x, delta_x_scaled, delta_f, error_f, scaledError_f, eps);
    }
  }

  solverData->numberOfIterations  += l;
  solverData->numberOfFunctionEvaluations += solverData->nfev;

  return 0;
}