Question

我编写了一个贪婪的搜索算法，但由于无法回溯并达到最终状态，因此会进入无限循环。如何以最佳方式在C ++中完成反向跟踪！

    while(!f1.eof() )
        {
            f1>>temp1>>time;

            A[i].loc_name=temp1;
            A[i].time_taken=time;

                initial_start=1; // make initial to 1 and final to i

                final_finish=i;

        i=i+1;
        }

    while(!f2.eof())
        {
            f2>>temp1>>temp2>>time;
            int ci=0;
            while( ci != i )
                {

                    if (temp1 == A[ci].loc_name)
                        {
                            flag1=ci;
                            tf1=time;

                        }
                    if (temp2 == A[ci].loc_name)
                        {
                            flag2=ci;
                            tf2=time;
                        }
                    ci=ci+1;
                }



            A[flag1].loc.push_back(flag2);
            A[flag1].time_live.push_back(time);

            A[flag2].loc.push_back(flag1);
            A[flag2].time_live.push_back(time);         

        }


//Greedy Search algorithm   
                int min,min_time,finish,start,l;
                vector<int>path;
                min_time=99999;
                l=0;
                finish=1;
                start=0;
//Choosing the node with the minimum value 
            while(finish != final_finish)
                {

                for(int u=0;u<A[start].loc.size();u++)
                    {
                        l=A[start].loc[u];
                        if(A[l].time_taken < min_time)
                            {   
                                min_time=A[l].time_taken;
                                finish = l;

                            }

                    }
                min=min+min_time;
                path.push_back(start);
                    start=finish;   
//Printing the path found by Greedy search into an output file
            f3<<A[l].loc_name<<min<<endl;
                }

Answer 1

int algo(int value, int stopValue, list<int> & answer)
{
    if(value == stopValue)
    {
        return 0;
    }
    if(value > stopValue)
    {
        return 1;
    }

    if(algo(value+2, stopValue) == 0)
    {
        answer.push_back(2);
        return 0;
    }
    if(algo(value+1, stopValue) == 0)
    {
        answer.push_back(1);
        return 0;
    }
    return 1;
}

这是一个简单的贪婪递归算法，它可以找到一个数字由2组成的1和1。贪婪算法仅适用于某些问题，并且在大多数情况下都会产生次优结果。

Answer 2

请勿使用!stream.eof()。

while (!f1.eof()) {
  f1 >> temp1 >> time;

// instead becomes:
while (f1 >> temp1 >> time) {

eof方法检查最后一次提取是否试图读取过去的eof。如果设置，则不表示最后一次提取失败（这是失败方法）。它无法预测未来，并告诉您接下来流将发生什么。几乎唯一合理的使用eof是在后你知道流已经失败并且你想看看它是否因为eof而失败。

if (stream >> var) {
  // use var
}
else { // extraction failed
  if (stream.eof()) {
    // we know why it failed
  }
  else {
    // some other reason, probably formatting
  }
}

我没有检查你的其余代码。

在贪婪的最佳搜索算法中，有效的反向跟踪方法是什么？

2 个答案: