蚁巢相遇问题

一 问题描述

有 N 个蚁巢,编号为 1~N 。第 i 个蚁巢的位置是(xi , yi),没有两个蚁巢在同一位置。所有蚂蚁都遵守一些规律:

① 当一只蚂蚁在蚁巣 p 时,它总是移动到离 p 最近的另一个蚁巣,若有多个蚁巣与 p 的距离最小,则它会移动到 x 坐标值较小的蚁巣。若仍有平局,则选择 y 坐标值较小的蚁巣。当蚂蚁从一个蚁巣移动到另一个蚁巣时,它总是沿着连接它们的线段移动。

② 蚂蚁从不停下来,当蚂蚁到达一个蚁巣时,它会立即移动到下一个蚁巣。所以,蚂蚁可以无限次地造访蚁巣。

③ 所有蚂蚁都以同样的速度移动,所有蚂蚁和蚁巢都可被看作点。给定两个不同的蚁巣,求两只蚂蚁同时从这两个蚁巣移动,会不会在某个时间相遇?

二 输入和输出

1 输入

输入以整数 T(T≤10)为开头,表示测试用例的数量。每个测试用例都以整数 N 和 Q (2≤N≤10^5 ,1≤Q≤10^5 )为开头,分别表示蚁巢数和查询数。下面的 n 行,每行都包含两个整数 Xi 和 Yi (-10^9≤Xi , Yi≤10^9 ),表示第 i 个蚁巢的位置。下面的 Q 行,每行都包含两个整数 i 和 j(1≤i , j≤N ,i≠j ),表示两个给定蚁巢的编号。

2 输出

对每个测试用例,都输出“Case#X :”,其中 X 是用例编号,从 1 开始。然后对每个查询,若两个蚂蚁会相遇,则在一行中输出“YES”,否则输出“NO”。

三 输入和输出样例

1 输入样例

2

2 1

0 0

-1 1

1 2

5 2

1 1

3 3

4 4

0 -3

0 -4

1 3

2 4

2 输出样例

Case #1:

YES

Case #2:

YES

NO

四 分析和设计

1 分析

本问题为二维数据,可采用 KD 树解决。因为蚂蚁总是向最近的蚁巢移动,因此可以将蚁巢与最近的蚁巢合并为一个连通分量,采用并查集实现。查询从两个蚁巢出发的两只蚂蚁是否会相遇时,只需查询两个蚁巢是否在同一个连通分量中。

(1)根据输入数据的二维坐标创建 KD 树。

(2)在 KD 树中查询每个点 p[i] 的最近点,合并两个点为一个连通分量。

(3)对每个查询 x、y,若 x 、y 在同一个连通分量中,则输出“YES”,否则输出“NO”。

2 设计

查询给定点 p 的最近点,直接套用查询距离 p 最近的 m 个点的模板,算法步骤如下。

(1)创建一个序对,第 1 个元素记录当前节点到 p 的距离,第 2 个元素记录当前节点;然后创建一个优先队列,存储离 p 最近的序对,优先队列按距离最大优先。

(2)从树根开始查询,先计算树根与 p 的距离 dis(kd[rt], p),用 tmp 记录该距离和树根节点。

(3)若 p.x[dim]<kd[rt].x [dim],则先在 lc 中查询,否则在 rc 中查询。在程序中若判断 p.x [dim]≥kd[rt].x [dim],则交换 lc 和 rc,这样就可以统一为首先在 lc 中查询。

(4)若 lc 不空,则在 lc 中递归查询 query(lc,m,dep+1, p)。

(5)若队列中的元素个数小于 m ,则直接将 tmp 入队,flag=1,还需要在右子树中查询;否则若判断 tmp 到 p 的距离小于堆顶到 p 的距离,则堆顶出队,tmp 入队。若以 p 为球心且 p 到队列中最远点的距离为半径的超球体与划分点的另一区域有交集(d≤r),则 flag=1,还需要在右子树中查询。

(6)若 rc 不空且 flag=1,则在 rc 中递归查询 query(rc,m,dep+1,p)。

本问题可能有多个点到 p 的距离相同,因此需要对与另一区域有交集的判断条件加等号。若到 p 最近的两个点距离相同,则比较第 1 维的大小,若第 1 维相同,则比较第 2 维的大小,选择坐标小的点作为最近点。如下图所示,G、C 到 p 的距离相同,比较第一维,G 的 x 坐标比 C 的 x 坐标小,选择 G。

五 代码

package com.platform.modules.alg.alglib.hdu5809;

import javafx.util.Pair;

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;

public class Hdu5809 {
    private int N = 50010;
    public String output = "";

    private final int inf = 0x3f3f3f3f;

    int idx, n, q, k = 2;
    int fa[] = new int[N];

    Node a[] = new Node[N];

    int sz[] = new int[N << 2];
    Node kd[] = new Node[N << 2];

    public Hdu5809() {
        for (int i = 0; i < a.length; i++) {
            a[i] = new Node();
        }
    }

    PriorityQueue<Pair<Integer, Node>> que = new PriorityQueue<>(new MyComparator());

    public String cal(String input) {
        int T, cas = 0;
        String[] line = input.split("\n");
        T = Integer.parseInt(line[0]);
        int count = 1;
        while (T-- > 0) {
            String[] num = line[count++].split(" ");
            n = Integer.parseInt(num[0]);
            q = Integer.parseInt(num[1]);

            for (int i = 0; i < n; i++) {
                String[] node = line[count++].split(" ");
                a[i].x[0] = Integer.parseInt(node[0]);
                a[i].x[1] = Integer.parseInt(node[1]);
                a[i].id = fa[i] = i;
            }
            build(1, 0, n - 1, 0);
            for (int i = 0; i < n; i++) {
                query(1, 1, 0, a[i]);
                Node tmp = que.peek().getValue();
                int u = find(a[i].id);
                int v = find(tmp.id);
                fa[u] = v;
                while (!que.isEmpty()) que.poll();
            }
            output += String.format("Case #%d:\n", ++cas);

            while (q-- > 0) {
                int x, y;
                String[] query = line[count++].split(" ");
                x = Integer.parseInt(query[0]);
                y = Integer.parseInt(query[1]);
                x--;
                y--; // 编号从0开始
                if (find(x) == find(y)) {
                    output += "YES\n";
                } else {
                    output += "NO\n";
                }
            }
        }

        return output;
    }

    int dis(Node p, Node q) {
        int ret = 0;
        for (int i = 0; i < k; i++)
            ret += (p.x[i] - q.x[i]) * (p.x[i] - q.x[i]);
        return ret > 0 ? ret : inf;
    }

    void build(int i, int l, int r, int dep) {
        if (l > r) return;
        int mid = (l + r) >> 1;
        idx = dep % k;
        sz[i] = 1;
        sz[i << 1] = sz[i << 1 | 1] = 0;
        Arrays.sort(a, l, r + 1);
        kd[i] = a[mid];
        build(i << 1, l, mid - 1, dep + 1);
        build(i << 1 | 1, mid + 1, r, dep + 1);
    }

    void query(int rt, int m, int dep, Node p) {
        if (sz[rt] == 0) return;
        Pair<Integer, Node> tmp = new Pair(dis(kd[rt], p), kd[rt]);

        int lc = rt << 1, rc = rt << 1 | 1, dim = dep % k, flag = 0;
        if (p.x[dim] >= kd[rt].x[dim]) {
            int temp = lc;
            lc = rc;
            rc = temp;
        }
        if (sz[lc] > 0)
            query(lc, m, dep + 1, p);
        if (que.size() < m) {
            que.add(tmp);
            flag = 1;
        } else {
            if (tmp.getKey() < que.peek().getKey()) {
                que.poll();
                que.add(tmp);
            }
            if ((p.x[dim] - kd[rt].x[dim]) * (p.x[dim] - kd[rt].x[dim]) <= que.peek().getKey())//注意有=号,可能有多个点有相同距离
                flag = 1;
        }
        if (sz[rc] > 0 && flag == 1)
            query(rc, m, dep + 1, p);
    }

    int find(int x) {
        if (fa[x] == x) {
            return x;
        } else {
            fa[x] = find(fa[x]);
            return fa[x];
        }
    }

    class Node implements Comparable<Node> {
        int x[] = new int[2];
        int id;

        public int compareTo(Node o) {
            for (int i = 0; i < k; i++)
                if (x[i] != o.x[i]) return x[i] > o.x[i] ? 1 : -1; // 升序
            return 0;
        }
    }

    class MyComparator implements Comparator<Pair<Integer, Node>> {
        @Override
        public int compare(Pair<Integer, Node> num1, Pair<Integer, Node> num2) {
            return num2.getKey().compareTo(num1.getKey());
        }
    }
}

 六 测试

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值