C++ 如何为元素为二维数组的map和priority_队列编写比较器

我正在尝试对一个大小为15的N字谜进行*搜索。我的开始状态是随机的。目标状态是代码中的des数组。我只能在拼图中的4个方向上用0（空白状态）交换分片以创建新状态。为了实现这一点，我使用了一个优先级队列和4个映射。对于所有这些，我使用了二维数组。Compare是优先级队列的比较器，map\u cmp是4个映射的比较器。Vis用于跟踪访问的状态，Dis用于记录路径数，parent用于保留状态的父级，ab用于保留每个状态的0（空白）位置。代码如下：

enter code here
#include<bits/stdc++.h>
using namespace std;
#define pii pair<int,int>
int fx[]={0,0,1,-1};
int fy[]={1,-1,0,0};
int des[4][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11},{12,13,14,15}};
int func1(int node[][4])
{
    int cnt=0;
    for(int i=0;i<4;i++)
    {
        for(int j=0;j<4;j++)
        {
            if(i==0 && j==0)
                continue;
            if(des[i][j]!=node[i][j])
                cnt++;
        }
    }
    return cnt;
}
double func2(int node[][4])
{
    int a,b,x,y;
    double sum=0.0;
    for(int i=0;i<4;i++)
    {
        for(int j=0;j<4;j++)
        {
            if(node[i][j]==0)
                continue;
            a=node[i][j];
            x=a/4;
            y=a%4;
            sum+=sqrt((i-x)*(i-x)+ (j-y)*(j-y));
        }
    }
}
struct map_cmp {
    bool operator()(const int (&a)[4][4], const int (&b)[4][4]) const {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                if(a[i][j]!=b[i][j])
                    return true;
                else
                    continue;
            }
        }
        return false;
    }
};
map<int[4][4],int,map_cmp>vis;
map<int[4][4],int,map_cmp>dist;
map<int[4][4],int[][4],map_cmp>parent;
map< int[4][4],pair<int,int>,map_cmp >ab;
struct compare
{
    bool operator()(const int (&a)[4][4],const int (&b)[4][4] )const{
        return ((dist[a]+func1(a)) < (dist[b]+func1(b)));
    }
};
bool isValid(int row, int col)
{
    return (row >= 0) && (row < 4) && (col >= 0) && (col < 4);
}
int bfs( int src[][4],int a,int b)
 {
    int u[4][4];
    int v[4][4];
    int x,y;
    vis[src]=1;
    dist[src]=0;
    parent[src]={0};
    ab[src]=pii(a,b);
    pii pos;
    priority_queue < int[4][4], vector < int[4][4] > , compare > q;
    q.push(src);
    while(!q.empty())
    {
        u = q.top();
        q.pop();
        pos=ab[u];
        for(int i=0;i<4;i++)
        {
            copy(u,u+16,v);
            x=pos.first+fx[i];
            y=pos.second+fy[i];
            if(isValid(x,y))
            {
                swap(v[pos.first][pos.second],v[x][y]);
                vis[v]=1;
                dist[v]=dist[u]+1;
                ab[v]=pii(x,y);
                parent[v]=u;
                if(memcmp(des,v,sizeof(des))==0)
                    return dist[v];
                q.push(v);
            }
        }
    }
}
int main()
{
    int a,b,i,j,k,m,n,x,y;
    int result[5];
    int src[4][4]={{7,2,12,11},{10,14,0,6},{8,13,3,1},{9,5,15,4}};
    for(i=0;i<4;i++)
    {
        for(j=0;j<4;j++)
        {
            if(src[i][j]==0)
            {
                x=i;
                y=j;
                break;
            }
        }
        if(j!=4)
            break;
    }
    a=bfs(src,x,y);
    ab.clear();
}

在此处输入代码
#包括
使用名称空间std；
#定义pii对
int fx[]={0,0,1，-1}；
int fy[]={1，-1,0,0}；
int des[4][4]={0,1,2,3}，{4,5,6,7}，{8,9,10,11}，{12,13,14,15}；
int func1（int节点[][4]）
{
int-cnt=0；
对于（int i=0；i不必考虑未调整大小的数组问题

让我们考虑标题中的问题，从<代码> STD的定义开始：：PrimRythyQueals，
std:：优先级队列

三个参数是元素类型，元素容器（默认std:：vector），比较器（它是一个带有（）比较器的类，默认std:：less）

类TpType{}；
类类型比较器{
布尔运算符（）（TpType&a、TpType&b）常量{
返回true；
}
};
std:：priority_队列，tptypecomparator>q；
C++没有大小数组。类型<代码> int [] [4 ]< /代码>本身是无效的，它仅在定义和初始化数组时是有效的。作为一种可能的解决方案，考虑使用和。然后可以使用<代码> STD:：向量< /代码>。我知道数组大小将是4×4。我正在修改我的代码。它不会解决刚才所说的问题吗？<代码> STD:：MAP< /COD>编译，就像<代码> STD:：PrimRythyQueue>代码>因为
std:：array
有一个
运算符，所以如果我在map中使用array，我就不需要编写比较器。对吧？？？。我从来没有使用过它。所以我想了解更多信息。至于优先级，我只需要将数据类型更改为array。这样行吗？我不明白。我的优先级声明如下右？？优先级队列，比较>q；结构比较{bool操作符（）（常量int（&a）[4][4]，常量int（&b）[4][4]）常量{return（（dist[a]+func1（a））<（dist[b]+func1（b））；}；将二维数组包装到一个类中，或者只是将其用作int指针，这会使您更容易理解。好的，我明白了。但我正试图这样做。这不可能吗？我将尝试使用该类。请详细说明为什么这会给我错误
tptypecomparator
不是有效的
比较器e
，它应该返回false
class TpType {};

    class TpTypeComparatator {
        bool operator () (TpType &a, TpType &b) const {
            return true;
        }
    };

    std::priority_queue, TpTypeComparatator> q;