bzoj 2304
不多说。。。放组数据：
path.in
10
2 4 6 10
1
2 4 6 10
2 7 6 8
1
2 4 6 10
1 7 7 8
2
2 5 3 8
4 10 6 7
2 1 5 4
1
3 1 4 3
2 7 6 8
1
2 4 6 10
1 7 7 8
2
2 5 3 8
4 10 6 7
2 1 5 4
1
3 1 4 3
2 7 6 8
1
2 4 6 10
1 7 7 8
2
2 5 3 8
4 10 6 7
2 1 5 4
1
3 1 4 3
------------------------------------
path.out
10
9
9
No Path
9
9
No Path
9
9
No Path
总之。。。比以前写的代码清晰多了。。。
#include int > ind;
int tot;
bool fo[maxn][4];
Node P[maxn];
Square S[maxn];
int Tx[maxn];
struct Edge
{
int v, w, next;
} edge[maxn];
int head[maxn], el;
Node trans(Node p,int t)
{
if(t < 0)
{
if((-t) & 1) p.x *= -1;
if((-t) & 2) std::swap(p.x, p.y);
}
if(t > 0)
{
if(t & 2) std::swap(p.x, p.y);
if(t & 1) p.x *= -1;
}
return p;
}
int newnode(Node p)
{
P[++tot] = p;
head[tot] = 0;
memset(fo[tot], false, sizeof(bool) * 4);
return tot;
}
void newedge(int u,int v,int w)
{
edge[++el] = (Edge){v, w, head[u]}, head[u] = el;
}
int getind(Node p)
{
if(!ind.count(p))
{
ind[p] = newnode(p);
}
return ind[p];
}
void init()
{
Node s, t;
ind.clear();
tot = el = 0;
scanf("%d%d%d%d", &s.x, &s.y, &t.x, &t.y);
scanf("%d", &n);
ind[s] = newnode(s), ind[t] = newnode(t);
for(int i = 1; i <= n; i++)
{
int xl, xr, yl, yr;
scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
if(xl > xr) std::swap(xl, xr);
if(yl > yr) std::swap(yl, yr);
S[i] = (Square){(Node){xl, yl}, (Node){xr, yr}};
getind((Node){xl, yl}), getind((Node){xr, yl});
getind((Node){xl, yr}), getind((Node){xr, yr});
}
}
void build(int l,int r,int s)
{
Tx[s] = -inf;
if(l != r)
{
int mid = (l + r) >> 1;
build(l, mid, s << 1);
build(mid + 1, r, s << 1 | 1);
}
}
void change(int x,int l,int r,int ll,int rr,int s)
{
if(l <= ll && rr <= r)
{
Tx[s] = x;
return;
}
int mid = (ll + rr) >> 1;
if(l <= mid) change(x, l, r, ll, mid, s << 1);
if(r > mid) change(x, l, r, mid + 1, rr, s << 1 | 1);
}
int query(int k,int l,int r,int s)
{
if(l == r) return Tx[s];
int res = 0;
int mid = (l + r) >> 1;
if(k <= mid) res = query(k, l, mid, s << 1);
else res = query(k, mid + 1, r, s << 1 | 1);
res = std::max(res, Tx[s]);
return res;
}
void prework(int type)
{
static Event E[maxn];
static int ty[maxn];
int tl = 2 * n;
for(int i = 1; i <= n; i++)
{
S[i].ll = trans(S[i].ll, type);
S[i].rr = trans(S[i].rr, type);
int xl = S[i].ll.x, xr = S[i].rr.x;
int yl = S[i].ll.y, yr = S[i].rr.y;
if(xl > xr) std::swap(xl, xr);
if(yl > yr) std::swap(yl, yr);
ty[i] = yl, ty[i + n] = yr;
S[i] = (Square){(Node){xl, yl}, (Node){xr, yr}};
}
ty[++tl] = trans(P[1], type).y;
ty[++tl] = trans(P[2], type).y;
std::sort(ty + 1, ty + tl + 1);
tl = std::unique(ty + 1, ty + tl + 1) - (ty + 1);
int Ecnt = 0;
for(int i = 1; i <= n; i++)
{
int xl = S[i].ll.x, xr = S[i].rr.x;
int yl = S[i].ll.y, yr = S[i].rr.y;
yl = std::lower_bound(ty + 1, ty + tl + 1, yl) - ty;
yr = std::lower_bound(ty + 1, ty + tl + 1, yr) - ty;
E[++Ecnt] = (Event){0, xl, yl, yr};
E[++Ecnt] = (Event){1, xr, yl, yr};
}
int sPy = std::lower_bound(ty + 1, ty + tl + 1, trans(P[1], type).y) - ty;
int tPy = std::lower_bound(ty + 1, ty + tl + 1, trans(P[2], type).y) - ty;
E[++Ecnt] = (Event){0, trans(P[1], type).x, sPy, sPy};
E[++Ecnt] = (Event){0, trans(P[2], type).x, tPy, tPy};
std::sort(E + 1, E + Ecnt + 1);
build(1, tl, 1);
for(int i = 1; i <= Ecnt; i++)
{
if(E[i].tp == 1)
{
change(E[i].x, E[i].l, E[i].r, 1, tl, 1);
}
else
{
int lx = query(E[i].l, 1, tl, 1);
int rx = query(E[i].r, 1, tl, 1);
if(lx > -inf) fo[getind(trans((Node){lx, ty[E[i].l]}, -type))][type] = true;
if(rx > -inf) fo[getind(trans((Node){rx, ty[E[i].r]}, -type))][type] = true;
}
}
for(int i = 1; i <= n; i++)
{
S[i].ll = trans(S[i].ll, -type);
S[i].rr = trans(S[i].rr, -type);
int xl = S[i].ll.x, xr = S[i].rr.x;
int yl = S[i].ll.y, yr = S[i].rr.y;
if(xl > xr) std::swap(xl, xr);
if(yl > yr) std::swap(yl, yr);
S[i] = (Square){(Node){xl, yl}, (Node){xr, yr}};
}
}
int getdist(int a,int b)
{
return abs(P[a].x - P[b].x) + abs(P[a].y - P[b].y);
}
void changefo()
{
for(int i = 1; i <= n; i++)
{
int xl = S[i].ll.x, xr = S[i].rr.x;
int yl = S[i].ll.y, yr = S[i].rr.y;
memset(fo[getind((Node){xl, yl})], false, sizeof(bool) * 4);
memset(fo[getind((Node){xr, yl})], false, sizeof(bool) * 4);
memset(fo[getind((Node){xl, yr})], false, sizeof(bool) * 4);
memset(fo[getind((Node){xr, yr})], false, sizeof(bool) * 4);
}
}
void build(bool revs,int b)
{
static std::pairint> pa[maxn];
for(int i = 1; i <= tot; i++)
{
pa[i] = std::make_pair(P[i], i);
if(revs) std::swap(pa[i].first.x, pa[i].first.y);
}
std::sort(pa + 1, pa + tot + 1);
for(int i = 1, j = 1; i <= tot; i = j)
{
while(j <= tot && pa[i].first.x == pa[j].first.x) j++;
for(int k = i + 1; k < j; k++)
{
int pre = pa[k - 1].second;
int now = pa[k].second;
int w = getdist(now, pre);
if(!fo[now][b]) newedge(now, pre, w);
if(!fo[pre][b ^ 1]) newedge(pre, now, w);
}
}
}
void solve()
{
static long long dist[maxn];
static std::priority_queue heap;
static bool vis[maxn];
for(int i = 1; i <= tot; i++)
{
dist[i] = linf;
vis[i] = false;
}
dist[1] = 0;
heap.push((Data){0, 1});
while(!heap.empty())
{
int t = heap.top().ind;
heap.pop();
if(vis[t]) continue;
vis[t] = true;
for(int i = head[t]; i ; i = edge[i].next)
{
int v = edge[i].v;
if(dist[t] + edge[i].w < dist[v])
{
dist[v] = dist[t] + edge[i].w;
heap.push((Data){dist[v], v});
}
}
}
if(dist[2] < linf)
{
printf("%lld\n", dist[2]);
}
else
{
puts("No Path");
}
}
int main()
{
int T;
#ifndef ONLINE_JUDGE
freopen("path.in","r",stdin);
freopen("path.out","w",stdout);
#endif
scanf("%d", &T);
while(T--)
{
init();
prework(0);
prework(1);
prework(2);
prework(3);
changefo();
build(true, 0);
build(false, 2);
solve();
}
#ifndef ONLINE_JUDGE
fclose(stdin);
fclose(stdout);
#endif
return 0;
}