C++ solve函数代码示例

int main()
{
	// search_space();
	solve(112, true);
	return 0;
}

int main()  
{  
    while(EOF!=scanf("%d",&N) && 0!=N)  
        solve();  
    return 0;  
}  

int main()
{
    printf("%d\n", solve());
    return 0;
}

	int maxDamage(vector <int> level, vector <int> damage) 
	{

		memset(dp,-1,sizeof dp);
		return solve(level,damage,0,0);
	}

int main( int argc, char *argv[] )
{
    if ( (argc == 2) &&
         (   (GF2::console::find_switch(argc,argv,"--help"))
          || (GF2::console::find_switch(argc,argv,"-h"    ))
         )
       )
    {
        std::cout << "[Usage]:\n"
                  << "\t--generate\n"
                  << "\t--generate3D\n"
                  << "\t--formulate\n"
                  << "\t--formulate3D\n"
                  << "\t--solver mosek|bonmin|gurobi\n"
                  << "\t--solver3D mosek|bonmin|gurobi\n"
                  << "\t--merge\n"
                  << "\t--merge3D\n"
                  << "\t--datafit\n"
                  << "\t--corresp\n"
                  //<< "\t--show\n"
                  << std::endl;

        return EXIT_SUCCESS;
    }
    else if ( GF2::console::find_switch(argc,argv,"--segment") || GF2::console::find_switch(argc,argv,"--segment3D") )
    {
       return segment( argc, argv );
    }
    else if ( GF2::console::find_switch(argc,argv,"--generate") || GF2::console::find_switch(argc,argv,"--generate3D") )
    {
        return generate(argc,argv);
    }
    else if ( GF2::console::find_switch(argc,argv,"--formulate") || GF2::console::find_switch(argc,argv,"--formulate3D"))
    {
        return formulate( argc, argv );
        //return GF2::ProblemSetup::formulateCli<GF2::Solver::PrimitiveContainerT, GF2::Solver::PointContainerT>( argc, argv );
    }
    else if ( GF2::console::find_switch(argc,argv,"--solver") || GF2::console::find_switch(argc,argv,"--solver3D") ) // Note: "solver", not "solve" :-S
    {
        return solve( argc, argv );
        //return GF2::Solver::solve( argc, argv );
    }
    else if ( GF2::console::find_switch(argc,argv,"--datafit") || GF2::console::find_switch(argc,argv,"--datafit3D") )
    {
        return datafit( argc, argv );
        //return GF2::Solver::datafit( argc, argv );
    }
    else if ( GF2::console::find_switch(argc,argv,"--merge") || GF2::console::find_switch(argc,argv,"--merge3D") )
    {
        return merge(argc, argv);
    }
    else if ( GF2::console::find_switch(argc,argv,"--show") )
    {
        std::cerr << "[" << __func__ << "]: " << "the show option has been moved to a separate executable, please use thatt one" << std::endl;
        return 1;
        //return GF2::Solver::show( argc, argv );
    }
    else if ( GF2::console::find_switch(argc,argv,"--subsample") )
    {
        return subsample( argc, argv );
    }
//    else if ( GF2::console::find_switch(argc,argv,"--corresp") || GF2::console::find_switch(argc,argv,"--corresp3D") )
//    {
//        return corresp( argc, argv );
//    }

    std::cerr << "[" << __func__ << "]: " << "unrecognized option" << std::endl;
    return 1;

    // --show --dir . --cloud cloud.ply --scale 0.05f --assoc points_primitives.txt --use-tags --no-clusters --prims primitives.bonmin.txt

//    std::string img_path( "input2.png" );
//    pcl::console::parse_argument( argc, argv, "--img", img_path );
//    float scale = 0.1f;
//    pcl::console::parse_argument( argc, argv, "--scale", scale );

//    return GF2::Solver::run( img_path, scale, {0, M_PI_2, M_PI}, argc, argv );
}

cv::RotatedRect cv::fitEllipse( InputArray _points )
{
    Mat points = _points.getMat();
    int i, n = points.checkVector(2);
    int depth = points.depth();
    CV_Assert( n >= 0 && (depth == CV_32F || depth == CV_32S));

    RotatedRect box;

    if( n < 5 )
        CV_Error( CV_StsBadSize, "There should be at least 5 points to fit the ellipse" );

    // New fitellipse algorithm, contributed by Dr. Daniel Weiss
    Point2f c(0,0);
    double gfp[5], rp[5], t;
    const double min_eps = 1e-8;
    bool is_float = depth == CV_32F;
    const Point* ptsi = points.ptr<Point>();
    const Point2f* ptsf = points.ptr<Point2f>();

    AutoBuffer<double> _Ad(n*5), _bd(n);
    double *Ad = _Ad, *bd = _bd;

    // first fit for parameters A - E
    Mat A( n, 5, CV_64F, Ad );
    Mat b( n, 1, CV_64F, bd );
    Mat x( 5, 1, CV_64F, gfp );

    for( i = 0; i < n; i++ )
    {
        Point2f p = is_float ? ptsf[i] : Point2f((float)ptsi[i].x, (float)ptsi[i].y);
        c += p;
    }
    c.x /= n;
    c.y /= n;

    for( i = 0; i < n; i++ )
    {
        Point2f p = is_float ? ptsf[i] : Point2f((float)ptsi[i].x, (float)ptsi[i].y);
        p -= c;

        bd[i] = 10000.0; // 1.0?
        Ad[i*5] = -(double)p.x * p.x; // A - C signs inverted as proposed by APP
        Ad[i*5 + 1] = -(double)p.y * p.y;
        Ad[i*5 + 2] = -(double)p.x * p.y;
        Ad[i*5 + 3] = p.x;
        Ad[i*5 + 4] = p.y;
    }

    solve(A, b, x, DECOMP_SVD);

    // now use general-form parameters A - E to find the ellipse center:
    // differentiate general form wrt x/y to get two equations for cx and cy
    A = Mat( 2, 2, CV_64F, Ad );
    b = Mat( 2, 1, CV_64F, bd );
    x = Mat( 2, 1, CV_64F, rp );
    Ad[0] = 2 * gfp[0];
    Ad[1] = Ad[2] = gfp[2];
    Ad[3] = 2 * gfp[1];
    bd[0] = gfp[3];
    bd[1] = gfp[4];
    solve( A, b, x, DECOMP_SVD );

    // re-fit for parameters A - C with those center coordinates
    A = Mat( n, 3, CV_64F, Ad );
    b = Mat( n, 1, CV_64F, bd );
    x = Mat( 3, 1, CV_64F, gfp );
    for( i = 0; i < n; i++ )
    {
        Point2f p = is_float ? ptsf[i] : Point2f((float)ptsi[i].x, (float)ptsi[i].y);
        p -= c;
        bd[i] = 1.0;
        Ad[i * 3] = (p.x - rp[0]) * (p.x - rp[0]);
        Ad[i * 3 + 1] = (p.y - rp[1]) * (p.y - rp[1]);
        Ad[i * 3 + 2] = (p.x - rp[0]) * (p.y - rp[1]);
    }
    solve(A, b, x, DECOMP_SVD);

    // store angle and radii
    rp[4] = -0.5 * atan2(gfp[2], gfp[1] - gfp[0]); // convert from APP angle usage
    if( fabs(gfp[2]) > min_eps )
        t = gfp[2]/sin(-2.0 * rp[4]);
    else // ellipse is rotated by an integer multiple of pi/2
        t = gfp[1] - gfp[0];
    rp[2] = fabs(gfp[0] + gfp[1] - t);
    if( rp[2] > min_eps )
        rp[2] = std::sqrt(2.0 / rp[2]);
    rp[3] = fabs(gfp[0] + gfp[1] + t);
    if( rp[3] > min_eps )
        rp[3] = std::sqrt(2.0 / rp[3]);

    box.center.x = (float)rp[0] + c.x;
    box.center.y = (float)rp[1] + c.y;
    box.size.width = (float)(rp[2]*2);
    box.size.height = (float)(rp[3]*2);
    if( box.size.width > box.size.height )
    {
        float tmp;
        CV_SWAP( box.size.width, box.size.height, tmp );
        box.angle = (float)(90 + rp[4]*180/CV_PI);
//.........这里部分代码省略.........

 vector<vector<int>> permute(vector<int>& nums) {
     if (nums.size() <= 1)
         return {nums};
     solve(0, nums);
     return permutations;
 }

void SampleSAT::islearn(int datasize, char* outfilename)
{
  int iteration = 0;  // iteration counter
  double drand;       // double  type random variable
  int irand;          // integer type random variable
  double lik;         // likelihood
  double stSec1;
  double stSec2;
  double stSec3;
  int step = 1;       // length of Markov chain
  cdsdSec = 0;
  cdddSec = 0;
  cntSec  = 0;
  double pF = 0;
  double adlogmax;
  double logsum;
  int admaxidx;
  double hl_ss;
  double temp;
  bool flag;
  FILE* helFile = fopen(outfilename, "w");

  while(iteration < lparams_->maxiter){
    iteration++;

    if(iteration == 1){
      for(int j = 0; j < numAtom; j++){
        sd[j] = 0;
      }
    }
    stSec1 = timer.time();

    /////  sampling routine ////
    for(int i = 0; i < lparams_->numsample; i++){
      drand = sat_->getGrand()*datasize;
      irand = drand; // get random integers in (0~datasize)
      for(int j = 0; j < numAtom; j++){
        xx[j] = tdata[irand][j];
      } // get random one training data (one model)
      for(int j = 0; j < step; j++){
        solve(sat_, xx);
      }
      for(int j = 0; j < numAtom; j++){
        sbuf[i][j] = xx[j];
      }
      for(int j = 0; j < numAtom; j++){
        if(xx[j] == 1){
          weight[i] += log(sat_->getTheta(j));
        }else{
          weight[i] += log(1-sat_->getTheta(j));
        }
      }
    }
    normalize(weight, lparams_->numsample);

    for(int j = 0; j < numAtom; j++){
      sd[j] += weight[j]*(xx[j])/(sat_->getTheta(j)) - weight[j]*(1 - xx[j])/(1 - sat_->getTheta(j));
    } //sum sample counts
    cdsdSec += timer.time() - stSec1;

    ///  calc. q(\x|F) from local samples ///
    for(int j = 0; j < datasize_t; j++){
      counts[j] = 0;
    }

    stSec3 = timer.time();

    for(int i = 0; i < datasize_t; i++){
      for(int j = 0; j < numAtom; j++){
        if(sdata[i][j] == 1){
          q_xF[i] += log(sat_->getRealProb(j));
        }else{
          q_xF[i] += log(1-sat_->getRealProb(j));
        }
      }
    }
    normalize(q_xF, datasize_t);
    cntSec += timer.time() - stSec3;

    stSec2 = timer.time();
    for(int i = 0; i < datasize; i++){
      for(int j = 0; j < numAtom; j++){
        dd[j] += (tdata[i][j])/(sat_->getTheta(j)) - (1 - tdata[i][j])/(1 - sat_->getTheta(j));
      }
    } //calc dd
    for(int j = 0; j < numAtom; j++){
      dd[j] /= datasize;
    }
    cdddSec += timer.time() - stSec2;

    for(int j = 0; j < numAtom; j++){
      ex[j] = lparams_->ita*(dd[j] - sd[j]);
    } // calc ex

    sat_->updateTheta(ex); //update theta
    pF=0;
    logsum = 0;
    adlogmax = -100000;
    admaxidx = 0;
    lik=0;
//.........这里部分代码省略.........

//.........这里部分代码省略.........
    prim->vars[var] = primOld->vars[var];
    numReads  += 1;
    numWrites += 1;
  }

  af::timer inductionEqnTimer = af::timer::start();
  cons->vars[vars::B1] = 
    consOld->vars[vars::B1] - 0.5*dt*divFluxes->vars[vars::B1];
  cons->vars[vars::B2] = 
    consOld->vars[vars::B2] - 0.5*dt*divFluxes->vars[vars::B2];
  cons->vars[vars::B3] = 
    consOld->vars[vars::B3] - 0.5*dt*divFluxes->vars[vars::B3];

  prim->vars[vars::B1] = cons->vars[vars::B1]/geomCenter->g;
  prim->vars[vars::B1].eval();
  prim->vars[vars::B2] = cons->vars[vars::B2]/geomCenter->g;
  prim->vars[vars::B2].eval();
  prim->vars[vars::B3] = cons->vars[vars::B3]/geomCenter->g;
  prim->vars[vars::B3].eval();
  double inductionEqnTime = af::timer::stop(inductionEqnTimer);

  primGuessPlusEps->vars[vars::B1] = prim->vars[vars::B1];
  primGuessPlusEps->vars[vars::B2] = prim->vars[vars::B2];
  primGuessPlusEps->vars[vars::B3] = prim->vars[vars::B3];

  primGuessLineSearchTrial->vars[vars::B1] = prim->vars[vars::B1];
  primGuessLineSearchTrial->vars[vars::B2] = prim->vars[vars::B2];
  primGuessLineSearchTrial->vars[vars::B3] = prim->vars[vars::B3];

  /* Solve dU/dt + div.F - S = 0 to get prim at n+1/2 */
  jacobianAssemblyTime = 0.;
  lineSearchTime       = 0.;
  linearSolverTime     = 0.;
  af::timer solverTimer = af::timer::start();
  solve(*prim);
  double solverTime = af::timer::stop(solverTimer);

  /* Copy solution to primHalfStepGhosted. WARNING: Right now
   * primHalfStep->vars[var] points to prim->vars[var]. Might need to do a deep
   * copy. */
  for (int var=0; var < prim->numVars; var++)
  {
    primHalfStep->vars[var] = prim->vars[var];
    numReads  += 1;
    numWrites += 1;
  }
  af::timer halfStepCommTimer = af::timer::start();
  primHalfStep->communicate();
  double halfStepCommTime = af::timer::stop(halfStepCommTimer);

  af::timer halfStepDiagTimer = af::timer::start();
  halfStepDiagnostics(numReads,numWrites);
  double halfStepDiagTime = af::timer::stop(halfStepDiagTimer);
  /* Half step complete */

  double halfStepTime = af::timer::stop(halfStepTimer);

  PetscPrintf(PETSC_COMM_WORLD, "\n");
  PetscPrintf(PETSC_COMM_WORLD, "    ---Performance report--- \n");
  PetscPrintf(PETSC_COMM_WORLD, "     Boundary Conditions : %g secs, %g %\n",
                                 boundaryTime, boundaryTime/halfStepTime * 100
             );
  PetscPrintf(PETSC_COMM_WORLD, "     Setting elemOld     : %g secs, %g %\n",
                                 elemOldTime, 
                                 elemOldTime/halfStepTime * 100
             );

int main(){
  scanf("%d %d", &N, &M);
  solve();
  return 0;
}

int main()
{
    
   
    solve();
}

/* entry point */
int main(int argc, char** argv){
    solve();
    return 0;
}

ompl::base::PlannerStatus ompl::tools::Lightning::solve(double time)
{
    ob::PlannerTerminationCondition ptc = ob::timedPlannerTerminationCondition(time);
    return solve(ptc);
}

 int depthSum(std::vector<NestedInteger>& V) {
   return solve(V, 1);
 }

int main () {
  int p;
  scanf("%d", &p);
  printf("%d\n", solve(p));
  return 0;
}