https 計算 color 方向 不變 這樣的 ive turn sizeof

坐標離散化 (來自《挑戰程序設計競賽》P164)
給出題目和主體代碼：

題目:
區域的個數
w*h的格子上畫了n條或垂直或水平的寬度為1的直線。求出這些線將格子劃分了多少個區域
(w和h的範圍都為[1, 1e6],n的範圍為[1,500])

思路：
一般先想到的是類似水塘問題的處理，建立數組並深度優先搜索
但是這個問題中w和h最大為1000000，所以沒辦法創建w*h的數組。因此我們要使用坐標離散化這一技巧

將前後沒有變化的行列(意思是消除後不會影響區域個數的)相除後並不會影響區域的個數
數組裏只需要存儲有直線的行列以及其前後的行列就足夠了，這樣的話大小最多3n*3n就足夠了，因此就可以創建出數組並利用搜索求出區域的個數

(爭議：《挑戰》原文是說 6n * 6n,可是我覺得似乎有些不對勁，我特意請教了師兄和隊友以後，他們也覺得是3n*3n)

收獲：
1. 坐標壓縮

2. find函數可以在vector中找到某個元素的位置
註意，find函數要求支持 == ，所以如果是自定義類型，需要先重載 ==
blog： http://www.cnblogs.com/fnlingnzb-learner/p/5889026.html


3. 區域很大時，用遞歸函數可能棧溢出，故而此題改用隊列

4. unique函數和erase函數
有關blog：
http://www.cnblogs.com/zhangshu/archive/2011/07/23/2115090.html

http://www.cnblogs.com/liyazhou/archive/2010/02/07/1665421.html

註意：
unique的去重並非真正的去重，只是將重復的元素都排到後面去。此外，unique只能在相鄰元素中去重，所以使用之前應該先排序

*****技巧：真正的去重並刪除重復部分****
vector<int> v;
sort(v.begin(), v.end());
v.erase(unique( v.begin(), v.end() ), v.end());

#include <iostream>
#include 
 
<cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int maxn = 500;
int W,H,N;
int X1[maxn],X2[maxn],Y1[maxn],Y2[maxn];
bool fld[maxn*6][maxn*6];
int dx[4]={0,0,-1,1};
int dy[4]={1,-1,0,0};


//對x1和x2進行坐標離散化，並返回離散後的寬度。（對於y1,y2同理）
//將x1,x2更新為離散後的x1,x2.y不變在x方向上縮小。（處理y1,y2時同理）
int compress(int *x1,int *x2,int w)
{
    vector<int> xs;
    for(int i = 0;i < N;i++)//確定離散後x軸上哪些值還存在
    {
        for(int d = -1;d <= 1; d++)
        {
            int tx1 = x1[i] + d, tx2 = x2[i] + d;
            if(1 <= tx1 && tx1 <= w) xs.push_back(tx1);
            if(1 <= tx2 && tx2 <= W) xs.push_back(tx2);
        }
    }
    sort(xs.begin(),xs.end());
    xs.erase(unique(xs.begin(),xs.end()),xs.end());//去重
    for(int i = 0; i < N; i++)//轉化為新的x1,x2;
    {
        x1[i] = find(xs.begin(),xs.end(),x1[i])-xs.begin();
        x2[i] = find(xs.begin(),xs.end(),x2[i])-xs.begin();
    }
    return xs.size();
}

void solve()
{
    //離散化
    W = compress(X1,X2,W);
    H = compress(Y1,Y2,H);
    //填充新的網格
    memset(fld,0,sizeof(fld));
    for(int i=0;i<N;i++)
    {
        for(int y=Y1[i];y<=Y2[i];y++)
        {
            for(int x=X1[i];x<=X2[i];x++)
            {
                fld[y][x]=true;
            }
        }
    }
    //利用BFS計算區域數
    int ans=0;
    for(int y=0;y<H;y++)
    {
        for(int x=0;x<W;x++)
        {
            if(fld[y][x]) continue;
            ans++;
            queue<pair<int, int> > que;
            que.push(make_pair(x,y));
            while(!que.empty())
            {
                int sx=que.front().first, sy=que.front().second;
                que.pop();
                for(int i=0;i<4;i++)
                {
                    int tx=sx + dx[i],ty=sy + dy[i];
                    if(tx<0 || tx>=W || ty<0 || ty>=H || fld[ty][tx]) continue;
                    que.push(make_pair(tx,ty));
                    fld[ty][tx]=true;
                }
            }
        }
    }
    printf("%d\n",ans);
}

int main()
{
    while(scanf("%d%d%d",&W,&H,&N)==3)
    {
        for(int i=0;i<N;i++)
            scanf("%d",&X1[i]);
        for(int i=0;i<N;i++)
            scanf("%d",&X2[i]);
        for(int i=0;i<N;i++)
            scanf("%d",&Y1[i]);
        for(int i=0;i<N;i++)
            scanf("%d",&Y2[i]);
            solve();
    }
    return 0;
}

/*
輸入：
10 10 5
1 1 4 9 10
6 10 4 9 10
4 8 1 1 6
4 8 10 5 10
輸出：
6
*/

參考：
技巧 坐標離散化 (來自《挑戰程序設計競賽》P164)

【坐標離散化】