Go: package main

import (
	"fmt"
)

func main() {
	var h, w int
	for {
		fmt.Scan(&w, &h)
		if w == 0 && h == 0 {
			return
		}
		matrix := make([][]int, h)
		Sean := make([][]bool, h)
		for i := 0; i < h; i++ {
			matrix[i] = make([]int, w)
			Sean[i] = make([]bool, w)
			for j := 0; j < w; j++ {
				fmt.Scan(&matrix[i][j])
			}
		}
		var count int
		for i := 0; i < h; i++ {
			for j := 0; j < w; j++ {
				if matrix[i][j] == 1 && Sean[i][j] == false {
					search(i, j, h, w, matrix, Sean)
					count++
				}
			}
		}
		fmt.Println(count)
	}
}
func search(x int, y int, h int, w int, matrix [][]int, Sean [][]bool) {
	if x < 0 || y < 0 || x >= h || y >= w || matrix[x][y] == 0 {
		return
	}
	if Sean[x][y] == true {
		return
	}

	Sean[x][y] = true

	search(x+1, y, h, w, matrix, Sean)
	search(x-1, y, h, w, matrix, Sean)
	search(x, y+1, h, w, matrix, Sean)
	search(x, y-1, h, w, matrix, Sean)
	search(x+1, y-1, h, w, matrix, Sean)
	search(x-1, y+1, h, w, matrix, Sean)
	search(x+1, y+1, h, w, matrix, Sean)
	search(x-1, y-1, h, w, matrix, Sean)
}

C++: #include <iostream>
using namespace std;

void input(int **, int, int);
int howManyIslands(int **, int, int);
void howBigIslands(int **, bool **, int, int, int, int);

int main()
{
	int **island, w, h;
	while(true){
		cin >> w >> h;
		if(w==h && h==0) break;
		island = new int*[w];
		for(int i=0; i<w; i++)
			island[i] = new int[h];
		input(island, w, h);
		cout << howManyIslands(island, w, h) << endl;
		for(int i=0; i<w; i++)
			delete[] island[i];
		delete[] island;
	}
	return 0;
}

void input(int **island, int w, int h)
{
	char buf[60];
	cin.clear();cin.ignore();
	for(int i=0; i<h; i++){
		cin.getline(buf, sizeof(buf));
		int j=0, k=0;
		while(buf[j] != '\0'){
			if(buf[j] != ' '){
				switch(buf[j]){
				case '0':
					island[k][i] = 0;
					k++;
					break;
				case '1':
					island[k][i] = 1;
					k++;
					break;
				}
				if(w==k) break;
			}
			j++;
		}
	}
}

int howManyIslands(int **island, int w, int h)
{
	bool **check;
	int ans = 0;
	check = new bool*[w];
	for(int i=0; i<w; i++){
		check[i] = new bool[h];
		for(int j=0; j<h; j++)
			check[i][j] = false;
	}
	for(int i=0; i<w; i++){
		for(int j=0; j<h; j++){
			if(check[i][j])continue;
			if(island[i][j]){
				ans++;
				howBigIslands(island, check, i, j, w, h);
			} else {
				check[i][j] = true;
			}
		}
	}
	for(int i=0; i<w; i++)
		delete[] check[i];
	delete[] check;

	return ans;
}

void howBigIslands(int **island, bool **check, int x, int y, int w, int h)
{
	if(check[x][y]) return;
	enum __DIR{ UPPER_LEFT, UP, UPPER_RIGHT, LEFT, RIGHT, LOWER_LEFT,
		UNDER, LOWER_RIGHT, DIR_END};
	int periphe[DIR_END][2]={
			{-1, -1}, {0, -1}, {1, -1},
			{-1, 0}, {1, 0},
			{-1, 1}, {0, 1}, {1, 1}
	};
	check[x][y] = true;
	for(int i=0; i<DIR_END; i++){
		if(x+periphe[i][0] < 0 || w-1 < x+periphe[i][0] ||
			y+periphe[i][1] < 0 || h-1 < y+periphe[i][1]) continue;
		if(island[x+periphe[i][0]][y+periphe[i][1]]){
			if(!check[x+periphe[i][0]][y+periphe[i][1]])
				howBigIslands(island, check,
				x+periphe[i][0], y+periphe[i][1], w, h);
		}
	}
}

C++: #include <bits/stdc++.h>
using namespace std;

int main(void){
	int w, h;
	int dx[] = {1,1,0,-1,-1,-1,0,1};
	int dy[] = {0,1,1,1,0,-1,-1,-1};
	while(true){
		cin >> w >> h;
		if(!w&&!h)break;
		vector<int> c[h+2];
		c[0].resize(w+2);
		c[h+1].resize(w+2);
		for(int i = 1; i <= h; ++i){
			c[i].resize(w+2);
			for(int j = 1; j <= w; ++j){
				cin >> c[i][j];
			}
		}
		int ans = 0;
		queue<pair<int, int>> q;
		for(int i = 1; i <= h; ++i){
			for(int j = 1; j <= w; ++j){
				if(c[i][j] == 1){
					q.emplace(i,j);
					ans++;
					c[i][j] = 0;
					while(!q.empty()){
						int x = q.front().first;
						int y = q.front().second;
						q.pop();
						for(int dir = 0; dir < 8; ++dir){
							int nx = x + dx[dir];
							int ny = y + dy[dir];
							if(c[nx][ny]==1){
								q.emplace(nx,ny);
								c[nx][ny]=0;
							}
						}
					}
				}
			}
		}
		cout << ans << endl;
	}
	return 0;
}

C++: #include<bits/stdc++.h>
#include<algorithm>
#include<string>
#include<iostream>
using namespace std;
#define int long long
#define double long double
#define fo(a,b) for(int a=0;a<b;a++)
#define Sort(a) sort(a.begin(),a.end())
#define rev(a) reverse(a.begin(),a.end())
#define fi first
#define se second
#define th third
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(),a.end()),a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int,vector<int>,greater<int>>
#define PriP priority_queue<P<int,int>,vector<P<int,int>>,greater<P<int,int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a)  (a).begin(),(a).end()
#define elif else if

const int dx[8]={1,1,1,0,0,-1,-1,-1};
const int dy[8]={-1,0,1,-1,1,-1,0,1};
int H,W;
V<V<int>> field;

void dfs(int h,int w){
  field[h][w]=0;
  fo(dir,8){
    int nh=h+dx[dir];
    int nw=w+dy[dir];
    if(nh<0||nw<0||nh>=H||nw>=W)
      continue;
    if(field[nh][nw]==0)
      continue;
    dfs(nh,nw);
  }
}
signed main(){
  while(cin>>W>>H){
    if(H==0||W==0)
      break;
    field.assign(H,V<int> (W,0));
    fo(h,H){
      fo(w,W){
        cin>>field[h][w];
      }
    }
    int ans=0;
    fo(h,H){
      fo(w,W){
        if(field[h][w]==0)
          continue;
        dfs(h,w);
        ++ans;
      }
    }
    cout<<ans<<endl;
  }
}

C++: # include <iostream>

const int MAX_W = 50;
const int MAX_H = 50;

int w, h;

int c[MAX_H][MAX_W];

int dx[8] = { 0,-1,-1,-1,0,1,1,1 }, dy[8] = { -1,-1,0,1,1,1,0,-1 };

void dfs(int x, int y) {
	c[y][x] = 0;
	for (int i = 0; i < 8; ++i) {
		int nx = x + dx[i];
		int ny = y + dy[i];
		if (nx >= 0 && ny >= 0 && nx < w&&ny < h&&c[ny][nx] == 1)
			dfs(nx, ny);
	}
}

int solve() {
	int sum = 0;
	for (int i = 0; i < h; ++i) {
		for (int j = 0; j < w; ++j) {
			if (c[i][j] == 1) {
				++sum;
				dfs(j, i);
			}
		}
	}
	return sum;
}

int main() {
	while (1) {
		std::cin >> w >> h;
		if ((w + h) == 0)
			break;
		for (int i = 0; i < h; ++i) {
			for (int j = 0; j < w; ++j)
				std::cin >> c[i][j];
		}
		int res = solve();
		std::cout << res << std::endl;
	}
	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }

int dx[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
int dy[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int w, h;

void dfs(vector< vector<int> > &isisland, vector< vector<bool> > &vvisited, int x, int y) {
    // ここで島の色塗りを行う
    vvisited[y][x] = true;
    for(int i = 0; i < 8; ++i) {
        int nx = x+dx[i]; int ny = y+dy[i];
        if(nx >= 0 && nx < w && ny >= 0 && ny < h) {
            if(isisland[ny][nx] == 1 && !vvisited[ny][nx]) {
                dfs(isisland, vvisited, nx, ny);
            }
        }
    }
}

int main() {
    while(1) {
        cin >> w >> h;
        if(w == 0 && h == 0) break;
        else {
            vector< vector<int> > island(h, vector<int>(w, 0));
            for(int i = 0; i < h; ++i) {
                for(int j = 0; j < w; ++j) {
                    cin >> island[i][j];
                }
            }

            vector< vector<bool> > visited(h, vector<bool>(w, false));
            int total = 0;
            for(int i = 0; i < h; ++i) {
                for(int j = 0; j < w; ++j) {
                    if(island[i][j] == 1 && !visited[i][j]) {
                        total++;
                        dfs(island, visited, j, i);
                    }
                }
            }
            cout << total << endl;
        }
    }    
}