Problem:
現代的な屋敷(Modern Mansion)

あなたは，ある大きな屋敷に迷い込んでしまった．この屋敷は正方形の部屋が東西南北に格子状に，東西方向に M 列，南北方向に N 行の合計 M × N 個並んだ構造をしている．西から x 列目(1 ≤ x ≤ M)，南から y 行目(1 ≤ y ≤ N) にある部屋を(x, y) で表す．

東西南北に隣り合う 2 部屋の間は，壁の中央にある扉により結ばれている．それぞれの扉は，閉じていて通行不可能な状態か，開いていて通行可能な状態のいずれかにある．扉が開いているとき，それらの部屋の中央間を移動するのに 1 分間かかる．また，いくつかの部屋の中央にはスイッチがあり，スイッチを 1 分間押し続けると，屋敷内のすべての扉の開閉の状態が切り替わる．

今，東西に隣り合う 2 部屋を結ぶすべての扉は閉じていて，南北に隣り合う 2 部屋を結ぶすべての扉は開いている．あなたは今部屋 (1, 1) の中央にいて，部屋 (M, N) の中央まで最短時間で移動したい．

課題

屋敷の大きさ M, N および，スイッチのある K 個の部屋の位置 (X1, Y1), (X2, Y2),..., (XK, YK) が与えられる．東西に隣り合う 2 部屋を結ぶすべての扉は閉じていて，南北に隣り合う 2 部屋を結ぶすべての扉は開いている状態から始めて，部屋 (1, 1) の中央から部屋 (M, N) の中央まで移動するのに最短で何分かかるかを求めるプログラムを作成せよ．ただし，部屋 (M, N) に辿り着くことができないときはそれを指摘せよ．

制限

2 ≤ M ≤ 100 000      屋敷の東西方向の部屋の個数

2 ≤ N ≤ 100 000     屋敷の南北方向の部屋の個数

1 ≤ K ≤ 200 000     スイッチのある部屋の個数

1 ≤ Xi ≤ M     スイッチのある部屋の東西方向の位置

1 ≤ Yi ≤ N     スイッチのある部屋の南北方向の位置

入力

標準入力から以下のデータを読み込め．

1 行目には，整数 M, N, K が空白を区切りとして書かれている．M は屋敷の東西方向の部屋の個数，N は屋敷の南北方向の部屋の個数，K はスイッチのある部屋の個数を表す．

続く K 行のうちの i 行目(1 ≤ i ≤ K) には，整数 Xi, Yi が空白を区切りとして書かれている．これは，部屋(Xi, Yi) の中央にスイッチがあることを表す．K 個の組(X1, Y1), (X2, Y2),..., (XK, YK) は互いに異なる．

出力

標準出力に，移動に最短で何分かかるかを表す整数を 1 行で出力せよ．ただし，部屋(M, N) に辿り着くことができないときは代わりに整数 -1 を出力せよ．

採点基準

採点用データのうち，配点の20%分については，M ≤ 1 000, N ≤ 1 000 を満たす．

採点用データのうち，配点の30%分については，K ≤ 2 000 を満たす．

採点用データのうち，配点の50%分については，これら 2 つの条件の少なくとも一方を満たす．また，これら 2 つの条件の両方を満たすような採点用データはない．

入出力例

入力例 1

3 2 1
1 2

出力例 1

4

この例では，以下の行動によって 4 分間で部屋(1, 1) の中央から部屋(3, 2) の中央へ移動することができ，これが最短である．

部屋(1, 2) の中央へ移動する．

部屋(1, 2) の中央のスイッチを押す．

部屋(2, 2) の中央へ移動する．

部屋(3, 2) の中央へ移動する．

このときの屋敷の様子が以下の図に表されている．図では右方向が東，上方向が北であり，×印はあなたの位置，○印はスイッチを表す．

入力例 2

3 2 1
2 1

出力例 2

-1

この例では，あなたは部屋(3, 2) に辿り着くことができない．

入力例 3

8 9 15
3 1
3 2
3 7
3 8
1 1
4 5
4 3
5 6
5 8
6 3
6 2
7 5
8 9
8 6
8 5

出力例 3

25

この例では，最初の屋敷の様子は以下の図のようになっている．部屋(1, 1) や部屋(M, N) の中央にスイッチがある可能性もあることに注意せよ．

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in C++11 (judge verdict: Memory Limit Exceeded)

#include<iostream>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<cstring>
#include<cmath>
using namespace std;

#define WHITE 0
#define GRAY 1
#define BLACK 2
#define BFSMAX 1100
#define MAX_W 210000
#define MAX_N 210000
#define INF 1LL<<60

long long h, w, K;

pair<long long, long long> tap[MAX_N];
vector<pair<long long, long long>>tate[MAX_W], yoko[MAX_W];//yoko->|   o  o |

long long path[BFSMAX][BFSMAX][2], x[BFSMAX][BFSMAX];
long long color[MAX_N][2], dist[MAX_N][2];
vector<pair<long long, long long>>graph1[MAX_N], graph2[MAX_N];

priority_queue<pair<long long, long long>, vector<pair<long long, long long>>, greater<pair<long long, long long>>>Q1, Q2;
queue<pair<int, int>>Q_1, Q_2;

void dijkstra() {
	for (int i = 0; i < MAX_N; i++) {
		dist[i][0] = INF;
		dist[i][1] = INF;
		color[i][0] = WHITE;
		color[i][1] = WHITE;
	}
	dist[K][0] = 0;
	color[K][0] = GRAY;
	Q1.push(make_pair(0LL, K));
	while (!Q1.empty() || !Q2.empty()) {
		//Q1.
		if (!Q1.empty()) 
		{
			pair<long long, long long>C = Q1.top();
			Q1.pop();
			long long D = C.second;
			color[D][0] = BLACK;
			if (dist[D][0] < C.first) { 
				continue; 
			}

			for (int j = 0; j < graph1[D].size(); j++) {
				int E = graph1[D][j].first;
				int F = graph1[D][j].second;
				if (color[E][1] == BLACK) {
					continue;
				}
				if (E == K) {
					continue;
				}

				if (dist[E][1] > dist[D][0] + F) {
					dist[E][1] = dist[D][0] + F;
					color[E][1] = GRAY;
					Q2.push(make_pair(dist[E][1], E));
				}
			}
		}

		if (!Q2.empty())
		{
			pair<long long, long long>C = Q2.top();
			Q2.pop();
			long long D = C.second;
			color[D][1] = BLACK;
			if (dist[D][1] < C.first) {
				continue;
			}

			for (int j = 0; j < graph2[D].size(); j++) {
				int E = graph2[D][j].first;
				int F = graph2[D][j].second;
				if (color[E][0] == BLACK) {
					continue;
				}
				if (E == K) {
					continue;
				}

				if (dist[E][0] > dist[D][1] + F) {
					dist[E][0] = dist[D][1] + F;
					color[E][0] = GRAY;
					Q1.push(make_pair(dist[E][0], E));
				}
			}
		}
	}
}

long long solve() {
	for (int i = 0; i < MAX_W; i++) {
		for (int j = 0; j < tate[i].size(); j++) {
			for (int k = j; k < tate[i].size(); k++) {
				int A1 = tate[i][j].second;
				int B1 = tate[i][k].second;
				int A2 = tate[i][j].first;
				int B2 = tate[i][k].first;
				int C = 0;
				if (B1 != K + 1) { C = 1; }
				graph1[A1].push_back(make_pair(B1, abs(A2 - B2) + C));
				graph1[B1].push_back(make_pair(A1, abs(A2 - B2) + C));
			}
		}
	}
	for (int i = 0; i < MAX_W; i++) {
		for (int j = 0; j < yoko[i].size(); j++) {
			for (int k = j + 1; k < yoko[i].size(); k++) {
				int A1 = yoko[i][j].second;
				int B1 = yoko[i][k].second;
				int A2 = yoko[i][j].first;
				int B2 = yoko[i][k].first;
				int C = 0;
				if (B1 != K + 1) { C = 1; }
				graph2[A1].push_back(make_pair(B1, abs(A2 - B2) + C));
				graph2[B1].push_back(make_pair(A1, abs(A2 - B2) + C));
			}
		}
	}
	dijkstra();
	return min(dist[K + 1][0], dist[K + 1][1]);
}

void _memset() {
	memset(tap, 0, sizeof(tap));
	memset(color, 0, sizeof(color));
	memset(dist, 0, sizeof(dist));
	for (int i = 0; i < MAX_W; i++) {
		tate[i].clear();
		yoko[i].clear();
	}
	for (int i = 0; i < MAX_N; i++) {
		graph1[i].clear();
		graph2[i].clear();
	}
}

long long bfs() {
	for (int i = 1; i <= w; i++) {
		for (int j = 1; j <= h; j++) {
			path[i][j][0] = INF;
			path[i][j][1] = INF;
		}
	}
	for (int i = 0; i < K; i++) {
		x[tap[i].first][tap[i].second] = 1;
	}
	Q_1.push(make_pair(1, 1));
	path[1][1][0] = 0;

	while (!Q_1.empty() || !Q_2.empty())
	{
		if (!Q_1.empty()) {
			pair<long long, long long> H = Q_1.front(); Q_1.pop();
			long long I = H.first;
			long long J = H.second;
			if (x[I][J] <= 1) {
				if (path[I][J + 1][0] > path[I][J][0] + 1) {
					path[I][J + 1][0] = path[I][J][0] + 1;
					Q_1.push(make_pair(I, J + 1));
				}
				if (path[I][J - 1][0] > path[I][J][0] + 1) {
					path[I][J - 1][0] = path[I][J][0] + 1;
					Q_1.push(make_pair(I, J - 1));
				}
			}
			if (x[I][J] == 1) {
				if (path[I][J][1] > path[I][J][0] + 1) {
					path[I][J][1] = path[I][J][0] + 1;
					Q_2.push(make_pair(I, J));
				}
			}
		}
		if (!Q_2.empty()) {
			pair<long long, long long> H = Q_2.front(); Q_2.pop();
			long long I = H.first;
			long long J = H.second;
			if (x[I][J] <= 1) {
				if (path[I + 1][J][1] > path[I][J][1] + 1) {
					path[I + 1][J][1] = path[I][J][1] + 1;
					Q_2.push(make_pair(I + 1, J));
				}
				if (path[I - 1][J][1] > path[I][J][1] + 1) {
					path[I - 1][J][1] = path[I][J][1] + 1;
					Q_2.push(make_pair(I - 1, J));
				}
			}
			if (x[I][J] == 1) {
				if (path[I][J][0] > path[I][J][1] + 1) {
					path[I][J][0] = path[I][J][1] + 1;
					Q_1.push(make_pair(I, J));
				}
			}
		}
	}

	return min(path[w][h][0], path[w][h][1]);
}

int main() {
	_memset();
	cin >> w >> h >> K;
	for (int i = 0; i < K; i++) {
		cin >> tap[i].first >> tap[i].second;//cin.x,y
	}
	tap[K] = make_pair(1, 1);
	tap[K + 1] = make_pair(w, h);
	for (int i = 0; i < K + 2; i++) {
		tate[tap[i].first].push_back(make_pair(tap[i].second, i));
		yoko[tap[i].second].push_back(make_pair(tap[i].first, i));
	}
	long long G;
	if (w <= 1000 && h <= 1000) { G = bfs(); }
	else { G = solve(); }
	if (G >= INF) { G = -1; }
	cout << G << endl;
	return 0;
}