FloodFill 算法

输入数据会构成一个无向图，包含图的顶点个数和边数。你需要输出经过 FloodFill 算法染色后的节点，要求将每个节点按染色结果分类。其中，和之前学习的一样，输入的节点从编号为 $0$ 开始，染色的结果由 $1$ 开始递增。

输入格式

输入的第一行为两个整数 $n$ 和 $m$（$1\le n,m\le 100$），分别表示图中顶点个数和边数。接下来共有 $m$ 行，格式为a b（$0\le a,b<n$），表示一条 $a$ 点到 $b$ 点的无向边。

输出格式

输出的行数取决于染色结果的种类，每一行的格式为x:a b c代表节点 $a$，$b$，$c$ 颜色为 $x$，x按从小到大的顺序输出，$a$、$b$、$c$ 按由小到大顺序排列，输出每个节点后再输出一个空格。

样例输入

11 10
0 1
0 2
1 2
1 3
2 3
4 5
4 6
7 8
8 9
8 10

样例输出

1:0 1 2 3 
2:4 5 6 
3:7 8 9 10 
#include <iostream>
#include <vector>
#include <cstring>
#include <queue>
using std::cin;
using std::cout;
using std::endl;
using std::queue;
using std::vector;

class Graph {
private:
    int n;
    int * color;
    vector<int> * edges;
public:
    Graph(int input_n) {
        n = input_n;
        edges = new vector<int>[n];
        color = new int[n];
        memset(color, 0, n * sizeof(int));
    }

    ~Graph() {
        delete[] edges;
        delete[] color;
    }

    void insert(int x, int y) {
        edges[x].push_back(y);
        edges[y].push_back(x);
    }

    void floodfill() {
        int color_cnt=0;
        for(int i=0;i<n;i++)
        {
            if(color[i]==0)
            {
                color_cnt++;
                queue<int>q;
                color[i]=color_cnt;
                q.push(i);
                while(!q.empty())
                {
                    int vertex=q.front();
                    for(int j:edges[vertex])
                    {
                        if(color[j]==0)
                        {
                            color[j]=color_cnt;
                            q.push(j);
                        }
                    }
                    q.pop();
                }
            }
        }
 //       vector<int> c(color_cnt+1);
        vector<vector<int> >c(color_cnt+1);
        for(int i=0;i<n;i++)
        {
            c[color[i]].push_back(i);
        }
        for(int i=1;i<=color_cnt;i++)
        {
            if(c[i].size()>0)
                cout<<i<<":";
            for(int j=0;j<c[i].size();j++)
            {
                if(j==c[i].size()-1)
                {
                    cout<<c[i][j]<<" "<<endl;
                }
                else
                {
                    cout<<c[i][j]<<" ";
                }
            }
        }
    }
};

int main() {
    int n,m,a,b;
    cin>>n>>m;
    Graph g(n);
    while(m--)
    {
        cin>>a>>b;
        g.insert(a,b);
    }
    g.floodfill();
    return 0;
}
开始用的是vector<int> c(color_cnt+1),不行，变成vector<vector<int> >c,还是不行，改成vector<vector<int> >c(color_cnt+1),OK了。

补充vector有关知识：

如果一个向量的每一个元素是一个向量，则称为二维向量，例如

   
   

    
    

     
     

      
      [cpp] 
      
      view plain
      
       copy
      
      

      
      
     
     
    
    
    
    
vector<vector<int> >vv(3, vector<int>(4));//这里，两个“>”间的空格是不可少的  
   
   
将构造一个二维向量vv，它含有三个元素，每个元素含有4个int型元素的向量。编译器两次调用vector的构造函数构造对象vv，第一次调用构造函数构造了一个无名的含有4个0的vector<int>对象：

   
   
[0]
[1]
[2]
[3]
0
0
0
0
第二次调用构造函数，以这个无名向量为初值初始化它的三个元素，结果是：

   
   
vv
[0]
[1]
[2]
[3]
[0]
0
0
0
0
[1]
0
0
0
0
[2]
0
0
0
0
vv[i]表示第i(i=0,1,2)行的元素组成的向量。vv.size()的值是3，vv[1].size()的值是4.

一个二维向量每个元素的长度可以不同，例如

   
   

    
    

     
     

      
      [cpp] 
      
      view plain
      
       copy
      
      

      
      
     
     
    
    
    
    
vector<vector<int> >vv;  
for(int c = 1; c <= 3; c++)  
    vv.push_back(vector<int>(c,0));  
   
   
上面代码产生一个长度不同的二维向量，第一行只有1个元素，第二行有两个，第三行三个。

应用例子：输入一个n个整数，将他们分别除以选定的一个整数(称为模)，按余数将这些整数分组。

   
   

    
    

     
     

      
      [cpp] 
      
      view plain
      
       copy
      
      

      
      
     
     
    
    
    
    
#include <iostream>  
#include <vector>  
using namespace std;  
  
void classify(vector<int>& v,int mode, vector<vector<int> >& vv)  
{  
    for (vector<int>::const_iterator iter = v.begin(); iter != v.end(); iter++)  
    {  
        int index = (*iter) % mode;//取余数  
        vv[index].push_back(*iter);//插入元素  
    }  
}  
  
int main()  
{  
    int mode;//模  
    cin>>mode;  
    vector<vector<int> >vv(mode);//定义了一个有mode行的二维向量  
    int n;//n个整数  
    cin>>n;  
    vector<int>v(n);//一维向量,保存n个整数  
    for (int i = 0;i < n; i++)  
        cin>>v[i];  
  
    //开始分类  
    classify(v,mode,vv);  
  
    for (i = 0; i < mode; i++)  
    {  
        cout<<"余数是 "<<i<<":";  
        if(vv[i].empty())  
            cout<<endl;  
        else  
        {  
            for (vector<int>::const_iterator p = vv[i].begin(); p != vv[i].end(); p++)  
                cout<<*p<<" ";  
            cout<<endl;  
        }  
    }  
    return 0;  
}  
   
   
运行结果：
http://blog.csdn.net/yuanjilai/article/details/7321484