Go: ///
// File:  1160.go
// Author: ymiyamoto
//
// Created on Sun Mar  4 20:45:57 2018
//
package main

import (
	"fmt"
)

var w, h int
var graph [][]string

func dfs(visited [][]bool, x, y int) {
	visited[x][y] = true

	for i := -1; i <= 1; i++ {
		for j := -1; j <= 1; j++ {
			dx := x + i
			dy := y + j
			if 0 <= dx && dx < h && 0 <= dy && dy < w && graph[dx][dy] == "1" && !visited[dx][dy] {
				dfs(visited, dx, dy)
			}
		}
	}
}

func main() {
	for {
		fmt.Scan(&w, &h)
		if w == 0 && h == 0 {
			break
		}

		graph = make([][]string, h)
		for i := range graph {
			graph[i] = make([]string, w)
		}

		for i := 0; i < h; i++ {
			for j := 0; j < w; j++ {
				var s string
				fmt.Scan(&s)
				graph[i][j] = s
			}
		}

		visited := make([][]bool, h)
		for i := range visited {
			visited[i] = make([]bool, w)
		}

		count := 0
		for i := range graph {
			for j := range graph[i] {
				if graph[i][j] == "1" && !visited[i][j] {
					dfs(visited, i, j)
					count++
				}
			}
		}

		fmt.Println(count)
	}
}

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

struct Fast {Fast(){std::cin.tie(0);ios::sync_with_stdio(false);}} fast;

/* cpp template {{{ */

/* short */
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) begin(v), end(v)
#define RALL(v) (v).rbegin(), (v).rend()
#define X real()
#define Y imag()

/* REPmacro */
#define REPS(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define rep(i, n) REPS(i, 0, n)
#define REP1(i,n) for (ll i = 1; i <= (ll)(n); ++i)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (ll i = (a); i >= (ll)(n); --i)
#define DEP(i, n) DEPS(i, n, 0)
#define EACH(i, n) for (auto&& i : n)

/* debug */
#define debug(x) cerr << x << " " << "(L:" << __LINE__ << ")" << '\n';

/* alias */
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
using D = double;
using P = complex<D>;
using vs = vector<string>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;

/* const */
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
const D EPS = 1e-9;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1}, dy[] = {1, 0, -1, 0, 1, -1, -1, 1};

/* func */
inline bool inside(int y, int x, int H, int W) {return y >= 0 && x >= 0 && y < H && x < W;}
inline int in() {int x; cin >> x; return x;}
inline ll IN() {ll x; cin >> x; return x;}
inline vs split(const string& t, char c) {vs v; stringstream s(t); string b; while(getline(s, b, c)) v.eb(b); return v;}
template <typename T> inline bool chmin(T& a, const T& b) {if (a > b) a = b; return a > b;}
template <typename T> inline bool chmax(T& a, const T& b) {if (a < b) a = b; return a < b;}
template <typename T, typename S> inline void print(const pair<T, S>& p) {cout << p.first << " " << p.second << endl;}
template <typename T> inline void print(const T& x) {cout << x << '\n';}
template <typename T, typename S> inline void print(const vector<pair<T, S>>& v) {for (auto&& p : v) print(p);}
template <typename T> inline void print(const vector<T>& v, string s = " ") {rep(i, v.size()) cout << v[i] << (i != (ll)v.size() - 1 ? s : "\n");}

vs field;
int w,h;
void dfs(int y, int x)
{
  field[y][x]='0';
  rep(i,4)
  {
    int nx=x+dx[i], ny=y+dy[i];
    if(nx<w&&0<=nx&&ny<h&&0<=ny&&field[ny][nx]=='1')
    {
      dfs(ny,nx);
    }
  }
}

signed main() 
{
  while(cin>>w>>h, w||h)
  {
    field.clear(); //初期化！！
    string s;
    rep(i,h) 
    {
      cin>>s;
      field.pb(s);
    }
    int x,y;
    int cnt=0;
    rep(y,h) rep(x,w)
    {
      if(field[y][x]=='1') 
      {
        dfs(y,x);
        cnt++;
      }
    }
    print(cnt);
  }

  return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll,ll>
#define FOR(I,A,B) for(ll I = (A); I < (B); ++I)
#define FORR(I,A,B) for(ll I = (B-1); I >= (A); --I)
#define SORT(x) (sort(x.begin(),x.end())) // 0 2 2 3 4 5 8 9
#define REV(x) (reverse(x.begin(),x.end())) //reverse
ll gcd(ll a,ll b){if(a<b)swap(a,b);if(a%b==0)return b;else return gcd(b,a%b);}
ll lcm(ll a,ll b){ll c=gcd(a,b);return ((a/c)*(b/c)*c);}//saisyo kobaisu
#define NEXTP(x) next_permutation(x.begin(),x.end())
const ll INF=1e18+7;
const ll MOD=1e9+7;

class UnionFind{
public:
	vector<int> par;
	//0-indexed
	void init(int n = 1) {
		par.resize(n);
		for (int i = 0; i < n; ++i) par[i] = i;
	}
	int root(int x = 1){
		if(par[x]==x)return x;
		else{
			return par[x] = root(par[x]);
		}
	}
	void unite(int x = 1,int y = 1){
		x = root(x);
		y = root(y);
		if(x==y)return;
		par[x] = y;
	}
};

bool solve(){
	ll H,W;
	cin >> W >> H;
	UnionFind island;
	island.init(W*H);
	ll dx[] = {0,1,0,-1,1,1,-1,-1};
	ll dy[] = {1,0,-1,0,1,-1,1,-1};
 	if(H==0&&W==0)return false;
	ll tile[H][W];
	ll zero = 0;
	FOR(i,0,H)FOR(j,0,W)cin>>tile[i][j];
	FOR(i,0,H)FOR(j,0,W){
		if(tile[i][j]==1){
			ll x = i;
			ll y = j;
			FOR(k,0,8)if(x+dx[k]<H&&x+dx[k]>=0&&y+dy[k]<W&&y+dy[k]>=0){
				ll nx = x+dx[k];
				ll ny = y+dy[k];
				if(tile[nx][ny]==1)
					island.unite(x*W+y,nx*W+ny);
			}
		}else{
			zero++;
		}
	}
	set<ll> s;
	FOR(i,0,H*W)s.insert(island.root(i));
	cout << s.size() - zero << endl;
	return true;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	while(solve());
}

C++: #include <iostream>
#include <queue>
#include <algorithm>
#include <cstring>

using namespace std;

namespace {
    const int MAX_W = 50;
    const int MAX_H = 50;
    int W, H;
    int F[MAX_H][MAX_W];
    bool input() {
        cin >> W >> H;
        if (W == 0 && H == 0) return false;
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < W; j++) {
                cin >> F[i][j];
            }
        }
        return true;
    }

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

    void solve() {
        bool used[H][W];
        memset(used, 0, sizeof(used));
        int ans = 0;
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < W; j++) {
                if (F[i][j] == 0) continue;
                if (used[i][j]) continue;
                typedef pair<int, int> P;
                queue<P> Q;
                Q.push(P(i, j));
                ans++;
                used[i][j] = true;
                while (!Q.empty()) {
                    P c = Q.front(); Q.pop();
                    int y = c.first, x = c.second;
                    for (int k = 0; k < 8; k++) {
                        int ny = y + dy[k];
                        int nx = x + dx[k];
                        if (ny < 0 || ny >= H) continue;
                        if (nx < 0 || nx >= W) continue;
                        if (F[ny][nx] == 0) continue;
                        if (used[ny][nx]) continue;
                        used[ny][nx] = true;
                        Q.push(P(ny, nx));
                    }
                }
            }
        }
        cout << ans << endl;
    }
}

int main() {
    while (input()) solve();
    return 0;
}