0

我有一个包含这种结构的双端队列。

struct New_Array {                    
    array<array<int,4>,4> mytable;       
    int h;
};

在这个结构中，2 个不同的数组可能具有相同的 h 值。

deque<New_Array> Mydeque;

我也知道双端队列中有多少不同的 h（的值steps）。以及 deque( Mydeque.size()) 中有多少结构。

我需要为每个 h 打印一个数组。从h=0直到开始h=steps（步数是一个已知int值）。每个要打印的数组必须更接近双端队列的末尾。

我试过这样的事情：

void foo(deque<New_Array> Mydeque, int steps)
 for(int i=0; i<steps; i++)
     {
        deque<New_Array>::iterator it;
        it = find(Mydeque.begin(),Mydeque.end(),i);
        PrintBoard(*it); // This if a function where you enter the New_Array struct 
                         // and it prints the array         
     }
}

以上给了我：error C2679: binary '==' : no operator found which takes a right-hand operand of type 'const bool' (or there is no acceptable conversion)

或者是这样的：

void foo(deque<New_Array> Mydeque, int steps)
for(int i=0; i<steps; i++)
     {
        deque<New_Array>::iterator it;
        for(unsigned int j=0;j<Mydeque.size();j++)
            {
            it = find_if(Mydeque.begin(),Mydeque.end(),Mydeque[j].h==i);
            PrintBoard(*it);
            break;
            }           

     }

以上给了我：error C2064: term does not evaluate to a function taking 1 arguments

编辑：deque未排序。对于每个应打印h的。array这array应该是此时更接近双端队列末尾的那个。

4

4 回答 4

1

记住最后一个值并跳过：

assert(!Mydeque.empty());
int old_h = Mydeque[0].h + 1; // make sure it's different!

for (std::size_t i = 0, end != Mydeque.size(); i != end; ++i)
{
    if (Mydeque[i].h == old_h) continue;

    print(Mydeque[i]);
    old_h = Mydeque[i].h;
}
于 2012-06-18T12:58:57.823 回答
1

首先，请注意您std::array在堆栈上声明了您的，因此存储也将在堆栈上。这意味着迭代结构涉及为每次比较加载 (4*4+1)*int。如果这对性能敏感，我建议使用，std::vector因为负载将仅是外部向量指针，而hwhen 仅比较h.

struct New_Array {                    
    vector<vector<int,4>,4> mytable;
    int h;
};

其次，如果您需要通过它们的h值访问这些表，或者h一次访问具有给定值的所有表，请让每个人都更容易并将它们存储为映射中的向量，或向量的排序向量：

std::map<int,std::vector<New_Array> > rolodex;
rolodex[someNewArray.h].push_back(someNewArray);

如果你按顺序构造这个，那么每个向量中的第一项将是要打印的：

for(auto it : rolodex) {
    vector<New_Array> tablesForThisH = it->second;
    if(tablesForThisH.begin() != tablesForThisH.end())
       PrintBoard(it->second[0]);
}

由于std:map按升序（我认为）存储（和迭代）它的键，这将按升序遍历不同的h值。同样，它只需要加载堆栈存储的结构，它只是hint 和向量头（可能是 12 个字节，如本问题所述）。

如果代码有误，请见谅，我的 stl 有点生疏了。

于 2012-06-18T13:21:02.397 回答
0

遍历deque, 并将所有元素插入到 amap中，使用h作为键。由于您的h值集似乎是连续的，您可以使用 avector代替，但测试是否已找到元素会更加困难。

于 2012-06-18T12:58:49.527 回答
0

解决方案是：

void Find_Solution_Path(deque<New_Array> Mydeque, int steps)
{
for(int i=0; i<steps+1; i++)
    {
        for(int j=Mydeque.size()-1;j>-1;j--)
        {
            if (Mydeque[j].h==i)
            {
                PrintBoard(Mydeque[j]);
                cout<<endl;
                break;
            }    
        }    
    }
}
于 2012-06-18T14:27:32.710 回答