【Codeforces811E】Vladik and Entertaining Flags [线段树][并查集]

Vladik and Entertaining Flags

Time Limit: 20 Sec  Memory Limit: 512 MB

Description

　　n * m的矩形，每个格子上有一个数字代表颜色。

　　q次询问，询问[l, r]有几个连通块，若颜色相同并且连通则属于同一个连通块。

Input

　　输入第一行n,m,q。
　　然后一个n*m的矩形。
　　之后q行，每行两个整数l，r。

Output

　　输出q行，对于每个询问输出答案。

Sample Input

　　4 5 4
　　1 1 1 1 1
　　1 2 2 3 3
　　1 1 1 2 5
　　4 4 5 5 5
　　1 5
　　2 5
　　1 2
　　4 5

Sample Output

　　6
　　7
　　3
　　4

HINT

　　1 ≤ n ≤ 10, 1 ≤ m, q ≤ 1e5， 1 ≤ l ≤ r ≤ m

Solution

　　我们运用线段树，线段树一个节点i维护这个点表示的[L, R]。

　　具体维护Li列~Ri列的连通块个数，Li列连通信息，Ri列连通信息，Li列编号，Ri列编号。

　　连通信息指的是n个点的连通关系，用一个[10]存下来即可。

　　我们现在考虑如何合并两个区间。

　　合并的时候，我们先cnt = 两个区间cnt之和，然后考虑左区间的右端信息 以及 右区间的左端信息。

　　如果有两个相同的值属于不同连通块，就把它们连通起来，修改一下信息，然后cnt--。显然用并查集处理连通即可。

Code

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 using namespace std;
 typedef long long s64;

 const int ONE = ;
 const int MOD = 1e9 + ;

 int get()
 {
         int res = , Q = ; char c;
         while( (c = getchar()) <  || c > )
             if(c == '-') Q = -;
         if(Q) res = c - ;
         while( (c = getchar()) >=  && c <= )
             res = res *  + c - ;
         return res * Q;
 }

 int n, m, Q;
 int col[][ONE];
 int l, r;

 int fat[ONE], total = ;
 int Find(int x)
 {
         if(fat[x] == x) return x;
         return fat[x] = Find(fat[x]);
 }

 int Un(int x, int y)
 {
         int f1 = Find(x), f2 = Find(y);
         if(f1 != f2) return fat[f1] = f2, ;
         return ;
 }

 struct power
 {
         int val;
         int l[], lid;
         int r[], rid;
         friend power operator +(power a, power b)
         {
             power c;
             c.val = a.val + b.val;
             c.lid = a.lid, c.rid = b.rid;

             for(int i = ; i <= n; i++)
                 fat[a.l[i]] = a.l[i], fat[a.r[i]] = a.r[i],
                 fat[b.l[i]] = b.l[i], fat[b.r[i]] = b.r[i];

             for(int i = ; i <= n; i++)
                 if(col[i][a.rid] == col[i][b.lid])
                     c.val -= Un(a.r[i], b.l[i]);

             for(int i = ; i <= n; i++)
                 c.l[i] = Find(a.l[i]), c.r[i] = Find(b.r[i]);

             return c;
         }
 }Node[ONE];

 void Build(int i, int l, int r)
 {
         if(l == r)
         {
             Node[i].lid = Node[i].rid = l;
             for(int j = ; j <= n; j++)
                 if(col[j - ][l] != col[j][l])
                     Node[i].l[j] = Node[i].r[j] = ++total, Node[i].val++;
                 else
                     Node[i].l[j] = Node[i].r[j] = Node[i].l[j - ];
             return;
         }
         int mid = l + r >> ;
         Build(i << , l, mid), Build(i <<  | , mid + , r);
         Node[i] = Node[i << ] + Node[i <<  | ];
 }

 power Query(int i, int l, int r, int L, int R)
 {
         if(L <= l && r <= R) return Node[i];

         int mid = l + r >> ;
         if(!(mid +  <= R)) return Query(i << , l, mid, L, R);
         else if(!(L <= mid)) return Query(i <<  | , mid + , r, L, R);
         else return Query(i << , l, mid, L, R) + Query(i <<  | , mid + , r, L ,R);
 }

 int main()
 {
         n = get();    m = get();    Q = get();
         for(int i = ; i <= n; i++)
             for(int j = ; j <= m; j++)
                 col[i][j] = get();
         Build(, , m);

         while(Q--)
         {
             l = get(), r = get();
             power res = Query(, , m, l, r);
             printf("%d\n", res.val);
         }

 }