NOIP模拟赛 城市

题目描述

$ZZQ$ 是一国之主。 这个国家有$N$个城市， 第$i$个城市与第$(i + 1) (mod N)$和$(i - 1) (mod N)$在一个正$N$边形相连。

$ZZQ$ 又新建了$N - 3$条道路。这些道路都是连接两个城市的直线 段，且任意两条线段都只可能在城市处相交，不会在旧的道路上新建 道路。同时$ZZQ$钦定任何一条新旧道路通行都只需要花费$1$天时间。

建设完成后，$ZZQ$开始了$M$次旅行，她想知道每次旅行最少需要 花费多少天。

输入输出格式

输入格式：

第一行输入 一个 个正整数$N$，表示城市个数。

接下来$N - 3$行，每行两个整数$u, v$，表示这条道路连接的两个城市。

接下来一个整数$M$，表示旅行次数。

接下来$M$行，每行两个整数$u, v$表示这次旅行的起点和终点。

保证起点和终点不同。

输出格式：

对于每个询问，输出一行一个整数$ans$表示答案。

---

其实这题在$BZOJ$上有原题：$BZOJ - 4449$

首先这显然是一个平面图，然后正解是平面图转对偶图 + 点分治，对偶图是什么？我不知道啊。

然后对偶图就是将平面图的面看作点，然后相邻的面之间连边，其中有$N - 3$条边，$N - 2$个点，故对偶图显然是一棵树。

其中，要建对偶图的话，每次选择$Deg$为$2$的点，再处理一下三角剖分，就能知道有哪些面相连了。

然后就在树上点分治。

至于过程，考虑一条原图的新加的边，如果某个询问的两个点恰好跨过它，那么就一遍$BFS$就好了，否则找到它们所在的被此时直线切割形成的两个块的左块或右块进行分治，于是可以使用点分治。

那么如何处理多个询问有哪几个横跨了当前点分治中心呢？只需将询问编号与当前分治中心用链式前向星连起来，访问到当前中心时扫一遍即可，当然这是需要下传的。

复杂度$O(NlogN)$。

代码：

#pragma GCC optimize ("O3")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

const int MAXN = 1e05 + 10;
const int MAXM = 1e05 + 10;
const int MAXQ = 1e05 + 10;

const int INF = 0x7fffffff;

struct LinkedForwardStar {
    int to;
    bool ban;

    int next;
} ;

LinkedForwardStar Link[MAXM << 1];
int Head[MAXN]= {0};
int size = 1;

void Insert (int u, int v) {
    Link[++ size].to = v;
    Link[size].ban = false;
    Link[size].next = Head[u];

    Head[u] = size;
}

vector<int> Graph[MAXN];

struct Edge {
    int u, v;
    int index;

    Edge () {}

    Edge (int fu, int fv, int find) :
        u (fu), v (fv), index (find) {}

    bool operator < (const Edge& p) const {
        if (u == p.u)
            return v < p.v;
        return u < p.u;
    }
} ;

Edge Edges[MAXN * 3];
int edges = 0;
int ind = 0;

int Triangle[MAXN][3];

void AddEdge (int x, int y, int z) { // 处理三角剖分
    ind ++;
    Triangle[ind][0] = x;
    Triangle[ind][1] = y;
    Triangle[ind][2] = z;
    Edges[++ edges] = Edge (min (x, y), max (x, y), ind);
    Edges[++ edges] = Edge (min (x, z), max (x, z), ind);
    Edges[++ edges] = Edge (min (y, z), max (y, z), ind);
    // cout << "Test: " << x << ' ' << y << ' ' << z << endl;
}

int N, M;

int Deg[MAXN]= {0};
bool Vis[MAXN]= {false};

queue<int> Que;

void Toposort () {
    for (int i = 1; i <= N; i ++)
        if (Deg[i] == 2)
            Que.push(i);

    while (! Que.empty()) {
        int u = Que.front();
        Que.pop();

        if (Deg[u] != 2)
            continue;
        Vis[u] = true;

        int x = 0, y;
        for (int i = 0; i < (int) Graph[u].size(); i ++) {
            int v = Graph[u][i];
            if (Vis[v])
                continue;

            ! x ? x = v : y = v;
            Deg[v] --;
            if (Deg[v] == 2)
                Que.push(v);
        }
        AddEdge (u, x, y);
    }
}

void Construct () {
    sort (Edges + 1, Edges + edges + 1);
    for (int i = 1; i < edges; i ++)
        if (Edges[i].u == Edges[i + 1].u && Edges[i].v == Edges[i + 1].v) {
            Insert (Edges[i].index, Edges[i + 1].index);
            Insert (Edges[i + 1].index, Edges[i].index);
        }
}

int Size[MAXN]= {0};

int tot;

int minval = INF, gravity;
void Get_Gravity (int root, int father) {
    Size[root] = 1;
    int maxpart = 0;
    for (int i = Head[root]; i; i = Link[i].next) {
        int v = Link[i].to;
        if (v == father || Link[i].ban)
            continue;

        Get_Gravity (v, root);
        Size[root] += Size[v];
        maxpart = max (maxpart, Size[v]);
    }
    maxpart = max (maxpart, tot - Size[root]);

    if (maxpart < minval) {
        minval = maxpart;
        gravity = root;
    }
}

LinkedForwardStar Qlink[MAXQ << 5];
int Qhead[MAXN];
int qsize = 0;

void Qinsert (int u, int v) {
    Qlink[++ qsize].to = v;
    Qlink[qsize].next = Qhead[u];

    Qhead[u] = qsize;
}

int Answer[MAXQ]= {0};

int Dist[3][MAXN]= {0};

int cur = 0;

int Rec[MAXN * 3];
int Belong[MAXN], Last[MAXN];
// Belong[]记录所属子树，Last[]记录分治中心编号（为了防止BFS越过当前分支中心管理子树）

int cnt = 0;

void BFS (int S, int type) {
    while (! Que.empty())
        Que.pop();
    for (int i = 1; i <= cnt; i ++)
        Dist[type][Rec[i]] = INF;

    Que.push(S);
    Dist[type][S] = 0;

    while (! Que.empty()) {
        int u = Que.front();
        Que.pop();

        for (int i = 0; i < (int) Graph[u].size(); i ++) {
            int v = Graph[u][i];
            if (Dist[type][v] < INF || Last[v] < cur)
                continue;

            Dist[type][v] = Dist[type][u] + 1;
            Que.push(v);
        }
    }
}

void DFS (int root, int father, int top) {
    for (int j = 0; j < 3; j ++) {
        Rec[++ cnt] = Triangle[root][j];
        Belong[Triangle[root][j]] = top;
        Last[Triangle[root][j]] = cur;
    }

    for (int i = Head[root]; i; i = Link[i].next) {
        int v = Link[i].to;
        if (v == father || Link[i].ban)
            continue;
        DFS (v, root, top);
    }
}

pair<int, int> Queries[MAXQ];

int Query[MAXQ];

void Solve (int root) {
    if (! Qhead[root])
        return ;

    tot = Size[root];
    minval = INF;
    Get_Gravity (root, 0);
    cur ++, cnt = 0;
    for (int i = Head[gravity]; i; i = Link[i].next) {
        int v = Link[i].to;
        if (Link[i].ban)
            continue;
        DFS (v, gravity, v);
    }
    for (int j = 0; j < 3; j ++) {
        Rec[++ cnt] = Triangle[gravity][j];
        Belong[Triangle[gravity][j]] = gravity;
        Last[Triangle[gravity][j]] = cur;
    }

    for (int j = 0; j < 3; j ++)
        BFS (Triangle[gravity][j], j);
    cnt = 0;
    for (int i = Qhead[root]; i; i = Qlink[i].next) {
        int v = Qlink[i].to;
        Query[++ cnt] = v;
    }
    Qhead[root] = 0;

    for (int i = 1; i <= cnt; i ++) {
        int u = Queries[Query[i]].first, v = Queries[Query[i]].second;
        if (Belong[u] == Belong[v]) {
            if (Belong[u] == gravity)
                Answer[Query[i]] = 1; // 在同一个三角剖分中
            else
                Qinsert (Belong[u], Query[i]);
        }
        else {
            for (int j = 0; j < 3; j ++)
                Answer[Query[i]] = min (Answer[Query[i]], Dist[j][u] + Dist[j][v]);
        }
    }

    for (int i = Head[gravity]; i; i = Link[i].next) {
        int v = Link[i].to;
        if (! Link[i].ban) {
            Link[i ^ 1].ban = true;
            Solve (v);
        }
    }
}

int getnum () {
    int num = 0;
    char ch = getchar ();

    while (! isdigit (ch))
        ch = getchar ();
    while (isdigit (ch))
        num = (num << 3) + (num << 1) + ch - '0', ch = getchar ();

    return num;
}

int main () {
    // freopen ("city.in", "r", stdin);

    N = getnum ();

    for (int i = 1; i <= N; i ++)
        Dist[0][i] = Dist[1][i] = Dist[2][i] = INF;

    for (int i = 1; i < N; i ++) {
        Graph[i].push_back(i + 1);
        Graph[i + 1].push_back(i);
        Deg[i] ++, Deg[i + 1] ++;
    }
    Graph[1].push_back(N), Graph[N].push_back(1);
    Deg[1] ++, Deg[N] ++;
    for (int i = 1; i <= N - 3; i ++) {
        int u, v;
        u = getnum (), v = getnum ();
        u ++, v ++;
        Graph[u].push_back(v);
        Graph[v].push_back(u);
        Deg[u] ++, Deg[v] ++;
    }

    Toposort ();
    Construct ();

    M = getnum ();

    for (int i = 1; i <= M; i ++) {
        int u, v;
        u = getnum (), v = getnum ();
        u ++, v ++;
        if (u != v) {
            Queries[i] = make_pair (u, v);
            Qinsert (1, i); // 一开始所有询问都位于根节点的子树中
            Answer[i] = INF;
        }
    }

    Size[1] = N;
    Solve (1);

    for (int i = 1; i <= M; i ++)
        printf ("%d
", Answer[i]);

    return 0;
}

/*
6
0 2
0 3
0 4
4
1 5
3 0
4 5
2 4
*/