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

struct mapst {
	int x, y;
};

#define func(x,y) (c[y][x]&&!f[y][x])

int main() {
	int w, h, ans=0;
	int c[50][50], f[50][50];
	queue<mapst> q;
	while(1) {
		cin >> w >> h;
		if(!w&&!h) break;
		ans = 0;
		for(int i=0; i<h; ++i) for(int j=0; j<w; ++j) {
			cin >> c[i][j];
			f[i][j] = 0;
		}
		for(int i=0; i<h; ++i) for(int j=0; j<w; ++j) {
			mapst m = {j, i}, ms;
			if(func(j,i)) {
				q.push(m);
				ans++;
				do {
					m = q.front();
					q.pop();
					
					f[m.y][m.x] = 1;
					if(m.x>0&&m.y>0) if(func(m.x-1,m.y-1)) {
						ms.x = m.x-1; ms.y = m.y-1;
						q.push(ms);
					}
					if(m.y>0) if(func(m.x,m.y-1)) {
						ms.x = m.x; ms.y = m.y-1;
						q.push(ms);
					}
					if(m.x<w-1&&m.y>0) if(func(m.x+1,m.y-1)) {
						ms.x = m.x+1; ms.y = m.y-1;
						q.push(ms);
					}
					if(m.x<w-1) if(func(m.x+1,m.y)) {
						ms.x = m.x+1; ms.y = m.y;
						q.push(ms);
					}
					if(m.x<w-1&&m.y<h-1) if(func(m.x+1,m.y+1)) {
						ms.x = m.x+1; ms.y = m.y+1;
						q.push(ms);
					}
					if(m.y<h-1) if(func(m.x,m.y+1)) {
						ms.x = m.x; ms.y = m.y+1;
						q.push(ms);
					}
					if(m.x>0&&m.y<h-1) if(func(m.x-1,m.y+1)) {
						ms.x = m.x-1; ms.y = m.y+1;
						q.push(ms);
					}
					if(m.x>0) if(func(m.x-1,m.y)) {
						ms.x = m.x-1; ms.y = m.y;
						q.push(ms);
					}
				}while(!q.empty());
			}
		}
		cout << ans << endl;
	}
}

C++: #include <iostream>
#include <map>
// #include <cstdio>
#include <stacK>

using namespace std;

int main() {
	while(1) {
	int w, h, data[52][52]={{0}};
	cin >> w >> h;
	if (w == 0 && h ==0) break;
	// memset(data, 0, sizeof(data));
	for (int i=1; i<=h; i++) {
		for (int j=1; j<=w; j++) {
			cin >> data[i][j];
		}
	}
	// for (int i=0; i<h; i++) {
	// 	for (int j=0; j<w; j++) {
	// 		cout << data[i][j] << "," ;
	// 	}cout <<endl;
	// }
	stack<pair<int, int> > s;
	int count=0;
	int H[8] = {-1, -1, -1, 0, 0, 1, 1, 1}, W[8] ={-1, 0, 1, -1, 1, -1, 0, 1};
	for(int i=1; i<=h; i++) {
		for (int j=1; j<=w; j++) {
			if (data[i][j]) {
				count++;
				s.push(make_pair(i, j));
				while (!(s.empty())) {
					pair<int, int> now;
					now = s.top();
					s.pop();
					data[now.first][now.second]=0;
					for (int k=0; k<8; k++) {
						if (data[H[k]+now.first][W[k]+now.second])
							s.push(make_pair(H[k]+now.first, W[k]+now.second));
					}
				}
			}
		}
	}
	cout << count <<endl;
}
}

C++: #include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <algorithm>
#include <functional>
#include <stack>
#include <queue>
#include <string>
#include <map>
#include <unordered_map>
#include <bitset>
#include <numeric>
#include <vector>
#include <unordered_set>
#include <bitset>
#include <limits>
#include <random>
#include <complex>
#include <numeric>
#include <cstdlib>
#include <bits/stdc++.h>


using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;

const ll mod=1000000007ll;
const ll inf=1000000000000000ll;

const ll nmax=50;

bool visited[nmax+1][nmax+1];
ll field[nmax+1][nmax+1];

ll h,w;

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

void dfs(ll x,ll y,ll h,ll w){
    field[x][y]=0;
    stack<P> stk;
    stk.push(P(x,y));
    visited[x][y]=true;

    while(!(stk.empty())){
        P p=stk.top();stk.pop();
        for(ll i=0;i<8;i++){
            ll nx=p.first+dx[i];
            ll ny=p.second+dy[i];
            if(0<=nx&&nx<h&&0<=ny&&ny<w&&field[nx][ny]==1&&(!visited[nx][ny])){
                field[nx][ny]=0;
                stk.push(P(nx,ny));
                visited[nx][ny]=true;
            }
        }
    }
}

int main() {
    while(true){
    ll w,h,ans;
    cin>>w>>h;
    if(w==0&&h==0)break;

    for(ll i=0;i<h;i++){
        for(ll j=0;j<w;j++){
            cin>>field[i][j];
            visited[i][j]=false;
        }
    }
    ans=0;
    for(ll i=0;i<h;i++){
        for(ll j=0;j<w;j++){
            if(field[i][j]==1){
                dfs(i,j,h,w);
/*
                for(ll k=0;k<h;k++){
                    for(ll l=0;l<w;l++){
                        cout<<field[k][l]<<" ";
                    }
                    cout<<endl;
                }
*/
                ans++;
            }
        }
    }

    cout<<ans<<endl;
}
    return 0;
}

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

void proc(int *maps,int p,int w,int h){
	if(maps[p]==1) maps[p]=2;
	else return;
	int x=p%w;
	int y=p/w;
	for(int i=-1;i<=1;++i){
		for(int j=-1;j<=1;++j){
			int nx=x+j;
			int ny=y+i;
			if(nx>=0&&ny>=0&&nx<w&&ny<h){
				proc(maps,nx+ny*w,w,h);
			}
		}
	}
}

int main(void){
	int w,h;
	while(cin>>w>>h,w&&h){
		int chizu[2500];
		for(int i=0;i<h;++i){
			for(int j=0,a;j<w;++j){
				cin>>a;
				chizu[i*h+j]=a;
			}
		}
		int count = 0;
		for(int i=0;i<w*h;++i){
			if(chizu[i]==1){
				proc(chizu,i,w,h);
				++count;
			}
		}
		cout<<count<<endl;
	}
	return 0;
}

C++: #include<iostream>

using namespace std;

int map[50][50];
int h,w;
int dx[]={-1,0,1},dy[]={-1,0,1};
void loop(int ,int );
int main(){
	
	while(cin>>h>>w,h){
		int cnt=0;
		for(int i=0;i<w;i++){
			for(int j=0;j<h;j++){
				cin>>map[i][j];
			}
		}
		for(int i=0;i<w;i++){
			for(int j=0;j<h;j++){
				if(map[i][j]==1){
					loop(i,j);	
					cnt++;	
				}
			}
		}
		cout<<cnt<<endl;
		for(int i=0;i<w;i++){
			for(int j=0;j<h;j++){
				map[i][j]=0;
			}
		}
	}
	return 0;
}
void loop(int x,int y){
	map[x][y]=0;
	for(int i=0;i<3;i++){
		for(int j=0;j<3;j++){
			if(map[x+dx[i]][y+dy[j]]==1){
				loop(x+dx[i],y+dy[j]);
			}
		}
	}
	return ;
}

C++: #include<iostream>
#include<queue>
#define N 51
using namespace std;

int w, h, ans = 0, map[N][N];

void search_zahyou(int w, int h);

int main(){
	while(cin >>w >>h){
		ans = 0;
		if(w == 0 && h == 0) break;
		for(int i = 0; i < h; i++){
			for(int k = 0; k < w; k++){
				cin >>map[i][k];
			}
		}
		for(int i = 0; i < h; i++){
			for(int k = 0; k < w; k++){
				if(map[i][k] == 0){
					continue;
				}
				else{
					ans++;
					search_zahyou(i, k);
				}
			}
		}
		cout <<ans <<endl;
	}
	return 0;
}

void search_zahyou(int inh, int inw){
	char searchh[8] = {-1, -1, -1, 0, 1, 1, 1, 0}, searchw[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
	if(h <= inh || w <= inw){
	} else{
		map[inh][inw] = 0;
		for(int i = 0; i < 8; i++){
			if(map[inh + searchh[i]][inw + searchw[i]] == 1){
				search_zahyou(inh + searchh[i], inw + searchw[i]);
			}
		}
	}
}