題目傳送門

　　傳送門I

　　傳送門II

題目大意

　　平面上有$n$個點，第$i$個點可以畫一條平行於$y$軸且經過這個點的直線或者平行於$x$軸且經過這個點的直線或者什麼都不做，問能夠產生多少種本質不同的圖案。

　　考慮每個點與它$x$座標相同且$y$座標比它大的第一個點連一條無向邊，以及與它$y$座標相同且$x$座標第一個比它大的點連一條無向邊。

　　顯然，每個連通塊和連通塊之間互不影響，所以分別考慮每個連通塊。

　　設當前連通塊所有點的橫座標構成的集合為$X$，縱座標構成的集合為$Y$。

• 如果點數等於邊數減一，只有對於包含所有滿足$x = x_i\vee y = y_i , x_i \in X, y_i \in Y$的直線的圖案無法畫出，其他圖案都能畫出。（這裡的所有圖案指，圖案中包含的任意一條直線一定經過這中間某個點的所有圖案）
  我們考慮用歸納法來證明它。假設新增的點的座標是$(x_0, y_0)$
• 當$|V| = 1$的時候顯然成立。
• 假設當$|V| = k - 1$的時成立，考慮加入一個葉節點。
  顯然我們只需要證明直線數為$|X| + |Y| - 1$的所有圖案都能畫出。（其它的只需要選一個這樣的圖案，然後點一些點不操作就行了）
  
  • 假設新增加了一個橫座標$x_0$，那麼考慮我們點當前這個點，畫一條直線$x = x_0$，這樣所有不存在的直線不是$x = x_0$的圖案都可以畫出了。
    

    （其中藍色虛線表示不存在的直線，紫色表示前$k - 1$個點選擇的直線，綠色表示第$k$個點選擇的直線，紅點是第$k$個點）

  • 考慮如果不存在直線$x = x_0$的圖案，那麼對於前$k - 1$個點，我們找一個不存在直線$y = y_0$的方案，然後過這個點畫一條直線$y = y_0$。
    
• 對於點數大於等於邊數，我們考慮它的任意一個生成基環樹。
  任意刪去環上的一個點，剩下一堆樹，根據以上結論，我們可以構造出一個包含所有滿足$x = x_i\vee y = y_i , x_i \in X, y_i \in Y$的圖案（先讓樹上某個直線畫不了，然後這個新點去補鍋，剩下的樹可以用歸納法，不斷新增葉節點來證明）。

 　　所以當一個連通塊是樹的時候方案數為$2^{|X| + |Y|} - 1$，否則是$2^{|X| + |Y|}$。

Code

  1 /**
  2  * Codeforces
 
  3  * Problem#870E
  4  * Accepted
  5  * Time: 93ms
  6  * Memory: 9800k
  7  */
  8 #include <algorithm>
  9 #include <iostream>
 10 #include <cstdlib>
 11 #include <cstdio>
 12 #include <set>
 13 using namespace std;
 14 typedef bool boolean;
 15 
 16 template <typename T>
 17 void pcopy(T* pst, const T* ped, T* pval) {
 18     for ( ; pst != ped; *(pst++) = *(pval++));
 19 }
 20 
 21 typedef class Point {
 22     public:
 23         int x, y, id;
 24 
 25         Point(int x = 0, int y = 0, int id = 0):x(x), y(y), id(id) {}
 26 }Point;
 27 
 28 typedef class union_found {
 29     public:
 30         int n;
 31         int *f;
 32         int *dif;    // |E| - |V|
 33 
 34         union_found() {    }
 35         union_found(int n):n(n) {
 36             f = new int[(n + 1)];
 37             dif = new int[(n + 1)];
 38             for (int i = 1; i <= n; i++)
 39                 f[i] = i, dif[i] = -1;    
 40         }
 41 
 42         int find(int x) {
 43             return (f[x] == x) ? (x) : (f[x] = find(f[x]));
 44         }
 45 
 46         void unit(int u, int v) {
 47             int fu = find(u), fv = find(v);
 48             if (fu == fv) {
 49                 dif[fu]++;
 50                 return;
 51             }
 52             dif[fu] += dif[fv] + 1;
 53             f[fv] = fu;
 54         }
 55 
 56         int operator [] (int u) {
 57             return find(u);
 58         }
 59 
 60         int operator () (int u) {
 61             return dif[u];
 62         }
 63 }union_found;
 64 
 65 const int M = 1e9 + 7;
 66 
 67 int add(int a, int b) {
 68     return ((a += b) >= M) ? (a - M) : (a);
 69 }
 70 
 71 int mul(int a, int b) {
 72     return a * 1ll * b % M;
 73 }
 74 
 75 int sub(int a, int b) {
 76     return ((a -= b) < 0) ? (a + M) : (a);
 77 }
 78 
 79 int qpow(int a, int p) {
 80     int pa = a, rt = 1;
 81     for ( ; p; p >>= 1, pa = mul(pa, pa))
 82         if (p & 1)
 83             rt = mul(rt, pa);
 84     return rt;
 85 }
 86 
 87 int n;
 88 Point* ps;
 89 set<int> *sx, *sy;
 90 union_found dsu;
 91 
 92 inline void init() {
 93     scanf("%d", &n);
 94     ps = new Point[(n + 1)];
 95     for (int i = 1, x, y; i <= n; i++) {
 96         scanf("%d%d", &x, &y);
 97         ps[i] = Point(x, y, i);
 98     }
 99 }
100 
101 inline void solve() {
102     dsu = union_found(n);
103     sort(ps + 1, ps + n + 1, [&] (const Point& a, const Point& b) {    return (a.x ^ b.x) ? (a.x < b.x) : (a.y < b.y);    });
104     for (int i = 1, j, x; i <= n; i = j) {
105         for (x = ps[i].x, j = i + 1; j <= n && ps[j].x == x; j++);
106         for (int k = i; k < j; k++)
107             if (k + 1 < j)
108                 dsu.unit(ps[k].id, ps[k + 1].id);
109     }
110 
111     for (int i = 1; i <= n; i++)
112         swap(ps[i].x, ps[i].y);
113     sort(ps + 1, ps + n + 1, [&] (const Point& a, const Point& b) {    return (a.x ^ b.x) ? (a.x < b.x) : (a.y < b.y);    });
114     for (int i = 1, j, x; i <= n; i = j) {
115         for (x = ps[i].x, j = i + 1; j <= n && ps[j].x == x; j++);
116         for (int k = i; k < j; k++)
117             if (k + 1 < j)
118                 dsu.unit(ps[k].id, ps[k + 1].id);
119     }
120 
121     sx = new set<int>[(n + 1)];
122     sy = new set<int>[(n + 1)];
123     for (int i = 1, p; i <= n; i++) {
124          p = ps[i].id;
125          sx[dsu[p]].insert(ps[i].x);
126          sy[dsu[p]].insert(ps[i].y);
127     }
128     int res = 1;
129     for (int i = 1; i <= n; i++) {
130         if (dsu[i] == i)
131             res = mul(res, sub(qpow(2, sx[i].size() + sy[i].size()), (dsu(i) < 0)));
132     }
133     printf("%d\n", res);
134 }
135 
136 int main() {
137     init();
138     solve();
139     return 0;
140 }