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>
#include <queue>
using namespace std;

int w, h, c, n;
int a[50][50];
queue<int> q;

void bfs() {
	int x, y;
	while (1) {
		x = q.front() % w;
		y = q.front() / w;
		if ( x > 0 && a[y][x - 1] == 1 ) {
			a[y][x - 1] = 0;
			q.push( y * w + x - 1 );
		}
		if ( y > 0 && a[y - 1][x] == 1 ) {
			a[y - 1][x] = 0;
			q.push( ( y - 1 ) * w + x );
		}
		if ( x < w - 1 && a[y][x + 1] == 1 ) {
			a[y][x + 1] = 0;
				q.push( y * w + x + 1 );
		}
		if ( y < h - 1 && a[y + 1][x] == 1 ) {
			a[y + 1][x] = 0;
			q.push( ( y + 1 ) * w + x );
		}
		q.pop();
		if ( q.empty() ) break;	
	}
	n++;
}

int main() {

	while (1) {
		n = 0;
		for ( int j = 0; j < 50; j++ )
			for ( int i = 0; i < 50; i++ )
				a[j][i] = 0;
		cin >> w >> h;
		if ( w == 0 ) break;
		for ( int j = 0; j < h; j++ ) {
			for ( int i = 0; i < w; i++ ) {
				cin >> c;
				a[j][i] = c;
			}
		}
		for ( int j = 0; j < h; j++ ) {
			for ( int i = 0; i < w; i++ ) {
				if ( a[j][i] == 1 ) {
					a[j][i] = 0;
					q.push( j * w + i );
					bfs();
				}
			}
		}
		cout << n << endl;
	}
}

C++: #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
#define coutd(n) cout << fixed << setprecision(n)
#define ll long long int
#define vl vector<ll>
#define vi vector<int>
const int INF = 2147483647;
const ll MOD = 1000000007;

using namespace std;

void dfs(const int i, const int j, const int h, const int w, const vector<vi> &grid, vector<vector<bool>> &visited) {
  if (not(0 <= i and i < h and 0 <= j and j < w))
    return;
  if (visited[i][j] or grid[i][j] == 0)
    return;
  visited[i][j] = true;
  int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
  int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
  REP(k, 8) { dfs(i + dx[k], j + dy[k], h, w, grid, visited); }
}

int main() {
  while (true) {
    int w, h;
    cin >> w >> h;
    if (w == 0 and h == 0)
      return 0;
    vector<vi> grid(h, vi(w, 0));
    vector<vector<bool>> visited(h, vector<bool>(w, false));
    REP(i, h) {
      REP(j, w) { cin >> grid[i][j]; }
    }

    int ans = 0;
    REP(i, h) {
      REP(j, w) {
        if (not visited[i][j] and grid[i][j] == 1) {
          ans++;
          dfs(i, j, h, w, grid, visited);
        }
      }
    }
    cout << ans << endl;
  }
  return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
using ll=long long;
using vec=vector<ll>;
using mat=vector<vec>;
#define For(i,a,b) for(i=a;i<b;i++)
#define rep(i,N) For(i,0,N)
#define rep1(i,N) For(i,1,N)
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define mod 1000000007
using datas=pair<ll,ll>;
using tdata=pair<datas,ll>;

long mmid(long a,long b,long c){return a<b?(b<c?b:max(a,c)):(b>c?b:min(a,c));}

ll modinv(ll a) {
  ll b=mod,u=1,v=0,t;
  while(b){
    t=a/b;
    a-=t*b; swap(a,b);
    u-=t*v; swap(u,v);
  }
  return (u+mod)%mod;
}

ll moddevide(ll a,ll b){return (a*modinv(b))%mod;}

ll modncr(ll n,ll r){
  ll i,plus=1;
  rep(i,r){
    plus=(plus*(n-i))%mod;
    plus=moddevide(plus,i+1);
  }
  return plus;
}

ll modncrlistp[200000],modncrlistm[200000];

ll modncrs(ll n,ll r){
  ll i,j;
  if(modncrlistp[n]==0){
    for(i=n;i>=0;i--){
      if(modncrlistp[i])break;
    }
    if(i<0){
      modncrlistp[0]=1;
      rep1(i,n+1){
        modncrlistp[i]=(modncrlistp[i-1]*i)%mod;
      }
    }else{
      For(j,i+1,n+1){
        modncrlistp[j]=(modncrlistp[j-1]*j)%mod;
      }
    }
  }
  if(modncrlistm[n]==0){
    for(i=n;i>=0;i--){
      if(modncrlistm[i])break;
    }
    if(i<0){
      modncrlistm[0]=1;
      rep1(i,n+1){
        modncrlistm[i]=(modncrlistm[i-1]*modinv(i))%mod;
      }
    }else{
      For(j,i+1,n+1)modncrlistm[j]=(modncrlistm[j-1]*modinv(j))%mod;
    }
  }
  return (((modncrlistp[n]*modncrlistm[r])%mod)*modncrlistm[n-r])%mod;
}

ll euclidean_gcd(ll a, ll b) {
  if(a<b) return euclidean_gcd(b, a);
  ll r;
  while ((r=a%b)){a=b;b=r;}
  return b;
}

ll countdigits(ll n){
  ll ans=0;
  while(n){n/=10;ans++;}
  return ans;
}

ll sumdigits(ll n){
  ll ans=0;
  while(n){ans+=n%10;n/=10;}
  return ans;
}

void printmap(vector<ll>& a,ll H,ll W){
  ll i,j;
  For(i,0,H+2){
    For(j,0,W+2){cout<<a[i*(W+2)+j];}
    cout<<endl;
  }
}
void inputmap(vector<ll>& a,ll H,ll W){
  ll i,j;
  string ss;
  For(i,1,H+1){
    cin>>ss;
    For(j,1,W+1){
      if(ss[j-1]=='#'){
        a[i*(W+2)+j]=1;
      }else{
        a[i*(W+2)+j]=0;
      }
    }
  }
}
ll lpow(ll a,ll b){
  ll i,res=1;
  rep(i,b){
    res*=a;
  }
  return res;
}

struct unionfind{
  vector<ll> par,treesize;
  unionfind(ll N){
    par.resize(N);
    for(ll i=0;i<N;i++)par[i]=i;
    treesize.resize(N);
    for(ll i=0;i<N;i++)treesize[i]=1;
  }
  ll root(ll x){
    ll r;
    if(par[x]==x)return x;
    r=root(par[x]);
    if(par[x]!=r){
      treesize[r]+=treesize[x];
      treesize[x]=0;
      par[x]=r;
    }
    return r;
  }
  void unite(ll x,ll y){
    ll px=root(x);
    ll py=root(y);
    if(px!=py){
      par[px]=py;
      treesize[py]+=treesize[px];
      treesize[px]=0;
    }
  }
  bool parcheck(ll x,ll y){
    ll px=root(x);
    ll py=root(y);
    return px==py;
  }
  ll size(ll x){
    ll px=root(x);
    return treesize[px];
  }
};

int main(){
  while(1){
  ll i,j=0,N,M,cnt=0;
  cin>>M>>N;
  if(N+M==0)return 0;
  unionfind tree(N*M);
  vec v(N*M);
  set<ll> se;
  rep(i,N){
    rep(j,M){
      cin>>v[i*M+j];
      if(v[i*M+j]==1){
        if(i>0&&v[(i-1)*M+j]==1){
          tree.unite(i*M+j,(i-1)*M+j);
        }
        if(j>0&&v[i*M+j-1]==1){
          tree.unite(i*M+j,i*M+j-1);
        }
        if(i>0&&j>0&&v[(i-1)*M+j-1]==1){
          tree.unite(i*M+j,(i-1)*M+j-1);
        }
        if(i>0&&j<M-1&&v[(i-1)*M+j+1]==1){
          tree.unite(i*M+j,(i-1)*M+j+1);
        }
      }else{
        cnt++;
      }
    }
  }

  rep(i,N*M){
    ll K=tree.root(i);
    se.insert(K);
  }
  cout<<(ll)se.size()-cnt<<endl;
  se.clear();
}}

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

int num, land[1080][1080];
int xs[] = { 1, 1, 0, -1, -1, -1, 0, 1 };
int ys[] = { 0, 1, 1, 1, 0, -1, -1, -1 };
void dfs(int x, int y) {
    land[x][y] = 0;
    for (int i = 0; i < 8; i++) {
        int tx = x + xs[i];
        int ty = y + ys[i];
        if (land[tx][ty])dfs(tx, ty);
    }
}

int main() {
    int w, h;
    while (1) {
        cin >> h >> w;
        if (w == 0 || h == 0)
            break;
        num = 0;
        for (int i = 1; i <= w; i++) {
            for (int j = 1; j <= h; j++) {
                cin >> land[i][j];
            }
        }
        for (int i = 1; i <= w; i++) {
            for (int j = 1; j <= h; j++) {
                if (land[i][j]) {
                    num++;
                    dfs(i, j);
                }
            }
        }
        cout << num << endl;
    }
    return 0;
}