【 bzoj4537】HNOI2016 最小公倍数

　　首先将边按a的值分组，每$\sqrt{m}$一组。

　　对于每一组，将符合一组a的询问选出来，将这些询问和这一块之前的边(a一定小于这些询问)按b排序，然后交替插入，询问，对于一个询问，在当前块也有可能有满足的边，我们将其加入，考虑后并撤销，由于块大小是$\sqrt{m}$所以复杂度正确。

　　注意 : 1.并查集不能路径压缩，否则无法撤销；

2.在筛选一组的询问时，不要让一个询问被考虑多次，也就是说用询问的a小于终点后的那条边的a作为筛选条件，否则假如所有的a一样，那么每个询问每次都会被考虑一遍。

　　复杂度为$\sqrt{m}mlog(m) + Q \sqrt{m}$

 #include <bits/stdc++.h>
 #define rep(i, a, b) for (int i = a; i <= b; i++)
 #define drep(i, a, b) for (int i = a; i >= b; i--)
 #define REP(i, a, b) for (int i = a; i < b; i++)
 #define pb push_back
 #define mp make_pair
 #define xx first
 #define yy second
 using namespace std;
 typedef long long ll;
 typedef pair<int, int> pii;
 const int inf = 0x3f3f3f3f;
 const ll INF = 0x3f3f3f3f3f3f3f3fll;
 template <typename T> void Max(T& a, T b) { if (b > a) a = b; }
 //*********************************

 const int maxn = , maxm = ;
 struct DATA {
     int u, v, a, b, id;
 } e[maxm], q[maxn], tmp[maxn];
 bool cmpa(DATA a, DATA b) { return a.a < b.a; }
 bool cmpb(DATA a, DATA b) { return a.b < b.b; }

 struct Option {
     int x, y, xmaxa, xmaxb, sz, ymaxa, ymaxb, f; Option() {}
     Option(int _x, int _y, int _xmaxa, int _xmaxb, int _sz, int _ymaxa, int _ymaxb, int _f) :
         x(_x), y(_y), xmaxa(_xmaxa), xmaxb(_xmaxb), sz(_sz), ymaxa(_ymaxa), ymaxb(_ymaxb), f(_f) {}
 } op[maxn];

 int top;
 int fa[maxn], sz[maxn], maxa[maxn], maxb[maxn];
 int ans[maxn];
 int getfather(int x) { return fa[x] == x ? x : getfather(fa[x]); }
 void merge(int x, int y, int a, int b) {
     int fx = getfather(x), fy = getfather(y);
     if (sz[fx] < sz[fy]) swap(fx, fy);
     op[++top] = (Option){fx, fy, maxa[fx], maxb[fx], sz[fx], maxa[fy], maxb[fy], fa[fy]};
     if (fx == fy) {
         maxa[fx] = max(maxa[fx], a);
         maxb[fx] = max(maxb[fx], b);
         return;
     }
     sz[fx] += sz[fy];
     maxa[fx] = max(maxa[fx], max(maxa[fy], a));
     maxb[fx] = max(maxb[fx], max(maxb[fy], b));
     fa[fy] = fx;
 }

 void retrace() {
     drep(i, top, ) {
         maxa[op[i].x] = op[i].xmaxa;
         maxb[op[i].x] = op[i].xmaxb;
         maxa[op[i].y] = op[i].ymaxa;
         maxb[op[i].y] = op[i].ymaxb;
         fa[op[i].y] = op[i].f;
         sz[op[i].x] = op[i].sz;
     }
 }

 int main() {
     /*
     freopen("multiple.in", "r", stdin);
     freopen("multiple.out", "w", stdout);
     */
     int n, m; scanf("%d%d", &n, &m);
     rep(i, , m) scanf("%d%d%d%d", &e[i].u, &e[i].v, &e[i].a, &e[i].b);
     int Q; scanf("%d", &Q);
     rep(i, , Q) scanf("%d%d%d%d", &q[i].u, &q[i].v, &q[i].a, &q[i].b), q[i].id = i;
     int Sz = sqrt(m);

     sort(e + , e +  + m, cmpa);
     sort(q + , q +  + Q, cmpb);

     for (int st = ; st <= m; st += Sz) {
         int end = min(st + Sz - , m);

         int cnt();
         for (int i = ; i <= Q; i++) if (q[i].a >= e[st].a && (st + Sz > m || q[i].a < e[end + ].a)) tmp[++cnt] = q[i];
         if (!cnt) continue;

         sort(e + , e + st, cmpb);

         rep(i, , n) fa[i] = i, sz[i] = , maxa[i] = maxb[i] = -;
         for (int k = , j = ; k <= cnt; k++) {
             while (e[j].b <= tmp[k].b && j < st) merge(e[j].u, e[j].v, e[j].a, e[j].b), j++;

             top = ;
             rep(i, st, end) if (e[i].a <= tmp[k].a && e[i].b <= tmp[k].b) merge(e[i].u, e[i].v, e[i].a, e[i].b);
             int fx = getfather(tmp[k].u), fy = getfather(tmp[k].v);
             if (fa[fx] == fa[fy] && maxa[fx] == tmp[k].a && maxb[fx] == tmp[k].b) ans[tmp[k].id] = ;
             retrace();
         }

     }
     rep(i, , Q) if (ans[i]) puts("Yes"); else puts("No");

     return ;
 }

multiple