Language: C++

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pld pair<long double, int>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define ff first
#define ss second
#define SZ(x) ((int)(x).size())
#define ld long double
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

const int MAXN = 1e3+100;
int H, W, sx, sy, x2, y2 D[MAXN][MAXN];
bool a[MAXN][MAXN], vis[MAXN][MAXN];

struct node{
    int x, y, d;
    bool operator<(const node &other) const{
        return d < other.d;
    }
};

bool valid(int x, int y){
    return (x >= 0 && x < H && y >= 0 && y < W && a[x][y]);
}

int dijkstra(){
    sx--, sy--, x2--, y2--;
    priority_queue<node> pq;
    pq.push({sx, sy, 0});
    D[x1][y1] = 0;
    while(!pq.empty()){
        int x = pq.top().x;
        int y = pq.top().y;
        int d = pq.top().d;
        pq.pop();
        if(vis[x][y])
            continue;
        vis[x][y] = true;
        for(int i = x-2; i <= x+2; i++){
            for(int j = y-2; j <= y+2; j++){
                if(!valid(i, j))
                    continue;
                if(i == x && j == y)
                    continue;
                if((i == x && abs(j - y) <= 1) || (j == y && abs(i - x) <= 1)){
                    if(D[i][j] > D[x][y]){
                        D[i][j] = D[x][y];
                        pq.push({i, j, D[i][j]});
                    }
                } else{
                    if(D[i][j] > D[x][y] + 1){
                        D[i][j] = D[x][y] + 1;
                        pq.push({i, j, D[i][j]});
                    }
                }
            }
        }
    }
    if(D[x2][y2] == INT_MAX)
        D[x2][y2] = -1;
    return D[x2][y2];
}

main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> H >> W;
    cin >> sx >> sy >> x2 >> y2;
    for(int i = 0; i < H; i++){
        string s; cin >> s;
        for(int j = 0; j < W; j++){
            a[i][j] = (s[j] == '.');
            D[i][j] = INT_MAX;
        }
    }
    cout << dijkstra();
}


Compiler output:
a.cc:15:26: error: expected initializer before 'D'
   15 | int H, W, sx, sy, x2, y2 D[MAXN][MAXN];
      |                          ^
a.cc: In function 'int dijkstra()':
a.cc:30:23: error: 'y2' was not declared in this scope; did you mean 'yn'?
   30 |     sx--, sy--, x2--, y2--;
      |                       ^~
      |                       yn
a.cc:33:5: error: 'D' was not declared in this scope
   33 |     D[x1][y1] = 0;
      |     ^
a.cc:33:7: error: 'x1' was not declared in this scope; did you mean 'y1'?
   33 |     D[x1][y1] = 0;
      |       ^~
      |       y1
a.cc:51:32: error: no matching function for call to 'std::priority_queue<node>::push(<brace-enclosed initializer list>)'
   51 |                         pq.push({i, j, D[i][j]});
      |                         ~~~~~~~^~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/queue:66,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:157,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_queue.h:736:7: note: candidate: 'void std::priority_queue<_Tp, _Sequence, _Compare>::push(const value_type&) [with _Tp = node; _Sequence = std::vector<node, std::allocator<node> >; _Compare = std::less<node>; value_type = node]'
  736 |       push(const value_type& __x)
      |       ^~~~
/usr/include/c++/14/bits/stl_queue.h:736:30: note:   no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'const std::priority_queue<node>::value_type&' {aka 'const node&'}
  736 |       push(const value_type& __x)
      |            ~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_queue.h:744:7: note: candidate: 'void std::priority_queue<_Tp, _Sequence, _Compare>::push(value_type&&) [with _Tp = node; _Sequence = std::vector<node, std::allocator<node> >; _Compare = std::less<node>; value_type = node]'
  744 |       push(value_type&& __x)
      |       ^~~~
/usr/include/c++/14/bits/stl_queue.h:744:25: note:   no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'std::priority_queue<node>::value_type&&' {aka 'node&&'}
  744 |       push(value_type&& __x)
      |            ~~~~~~~~~~~~~^~~
a.cc:56:32: error: no matching function for call to 'std::priority_queue<node>::push(<brace-enclosed initializer list>)'
   56 |                         pq.push({i, j, D[i][j]});
      |                         ~~~~~~~^~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_queue.h:736:7: note: candidate: 'void std::priority_queue<_Tp, _Sequence, _Compare>::push(const value_type&) [with _Tp = node; _Sequence = std::vector<node, std::allocator<node> >; _Compare = std::less<node>; value_type = node]'
  736 |       push(const value_type& __x)
      |       ^~~~
/usr/include/c++/14/bits/stl_queue.h:736:30: note:   no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'const std::priority_queue<node>::value_type&' {aka 'const node&'}
  736 |       push(const value_type& __x)
      |            ~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_queue.h:744:7: note: candidate: 'void std::priority_queue<_Tp, _Sequence, _Compare>::push(value_type&&) [with _Tp = node; _Sequence = std::vector<node, std::allocator<node> >; _Compare = std::less<node>; value_type = node]'
  744 |       push(value_type&& __x)
      |       ^~~~
/usr/include/c++/14/bits/stl_queue.h:744:25: note:   no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'std::priority_queue<node>::value_type&&' {aka 'node&&'}
  744 |       push(value_type&& __x)
      |            ~~~~~~~~~~~~~^~~
a.cc: At global scope:
a.cc:67:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
   67 | main(){
      | ^~~~
a.cc: In function 'int main()':
a.cc:71:30: error: 'y2' was not declared in this scope; did you mean 'yn'?
   71 |     cin >> sx >> sy >> x2 >> y2;
      |                              ^~
      |                              yn
a.cc:76:13: error: 'D' was not declared in this scope
   76 |             D[i][j] = INT_MAX;
      |             ^