from collections import deque

# 섬에 번호 부여하기
def make_island(x, y, grid, number, visited):
    global N
    global M
    # 탐색 방향
    dx = [1,-1,0,0]
    dy = [0,0,1,-1]

    q = deque()
    q.append([x, y])
    grid[x][y] = number
    visited[x][y] = True

    while q:
        cx, cy = q.popleft()
        
        for dir in range(4):
            nx = cx + dx[dir]
            ny = cy + dy[dir]

            # 맵밖을 벗어나지 않고
            if 0 <= nx < N and 0 <= ny < M:
                # 방문한적이 없는 곳이면
                if not visited[nx][ny] and grid[nx][ny] != 0:
                    visited[nx][ny] = True
                    grid[nx][ny] = number
                    q.append([nx, ny])

# 섬을 노드로, 다른 섬으로 갈 수 있는 다리 후보를 edge로 만들기
    # 같은 섬을 연결하는 다리의 경우에는 최소 값으로 설정
def make_graph(grid, num_of_island):
    global N
    global M
    
    # 탐색 방향 하, 상, 우, 좌
    dx = [1,-1,0,0] 
    dy = [0,0,1,-1]
    
    graph = [[100 for _ in range(num_of_island)] for __ in range(num_of_island)]

    # 탐색
    for x in range(N):
        for y in range(M):
            # 바다가 아니면
            if grid[x][y] != 0:
                # 4방위 탐색
                for dir in range(4):
                    # 연결가능 여부, 노드번호, 다리길이 반환
                    check, node, value = check_dir(dir, grid, x, y)
                    # 연결 가능하고
                    if check:
                        # 다리기리가 더 작으면 최소값으로 바꿔주기
                        if graph[grid[x][y]][node] > value:
                            graph[grid[x][y]][node] = value
                            graph[node][grid[x][y]] = value

    return graph

# 연결 가능한 섬이 있는지 검사
def check_dir(dir, grid, x, y):
    global N
    global M

    curr_island = grid[x][y] # 현재 섬 번호
    start_x = x # 탐색 시작 좌표
    start_y = y # 탐색 시작 좌표

    # 탐색 방향
    dx = [1,-1,0,0] 
    dy = [0,0,1,-1]

    check, node, value = False, -1, -1

    while True:
        # 정해진 방향으로 쭉 진행
        x = x + dx[dir]
        y = y + dy[dir]

        # 맵을 안벗어 나면 검사
        if 0 <= x < N and 0 <= y < M:  
            # 바다가 아닌 다른 섬이 나올 경우 값들을 계산 및 저장 하고 탈출!
            if grid[x][y] != 0 and grid[x][y] != curr_island:
                if abs(x - start_x) - 1 >= 2 or abs(y - start_y) - 1 >= 2:
                    check = True # 연결 가능!
                    node = grid[x][y] # 연결 될 섬 번호
                    # 다리 길이!
                        # 수평 또는 수직 으로만 움직이기 때문에 x쪽, y쪽 둘중 하나는 0이다. 그래서 큰 값으로 선택하면 다리길이
                    value = abs(x - start_x) if abs(x - start_x) > abs(y - start_y) else abs(y - start_y) 
                    return check, node, value - 1   
                else: # 길이가 2가 안되면 다리 건설 불가
                    return check, node, value
            # 섬 내부, 겹치는 방향 좌표일 경우
            elif grid[x][y] == curr_island:
                return check, node, value
        else: # 맵을 벗어나는 경우
            return check, node, value

# 부모 찾기
def find(x, parents):
    if x == parents[x]:
        return x
    else:
        parents[x] = find(parents[x], parents)
        return parents[x]

# 부모 합치기
def union(x, y, parents):
    x = find(x, parents)
    y = find(y, parents)

    # 같으면 변경 필요 없음
    if x==y: return

    # 낮은 값을 부모 노드로
    if x<y: parents[y] = x
    else: parents[x] = y

def kruskal(parents, edges):
    length = 0

    # 간선 연결
    for edge in edges:
        w, s, e = edge
        # 연결이 안되어 있는 섬이면
        if find(s, parents) != find(e, parents):
            # 연결
            union(s, e, parents)
            # 다리 길이 더해주기
            length += w
    # 다리길이 반환
    return length

def Print_grid(grid):
    print('')
    for _ in range(len(grid)):
        print(grid[_])
    print('')

# main
N, M = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(N)]

# 1. island 정보구성
visited = [[False for _ in range(M)] for __ in range(N)] # 섬 방문 여부
number = 1 # 섬 고유 번호 1~
for x in range(N):
    for y in range(M):
        # 방문하지 않았고 바다가 아니면 탐색
        if not visited[x][y] and grid[x][y] != 0:
            make_island(x, y, grid, number, visited)
            number += 1

# 2. 각 섬을 그래프 형태로 만들기(노드, 엣지 만들기)
num_of_island = number
    # 1 ~ N을 번호로 사용
graph = make_graph(grid, num_of_island)

# 3. 그래프를 이용해 최소 신장 트리 만들기
    # 크루스칼 알고리즘
parents = [_ for _ in range(num_of_island)] # 부모(그룹) 표시
edges = []
for s in range(num_of_island):
    for e in range(s+1, num_of_island):
        if graph[s][e] != 100:
            edges.append([graph[s][e], s, e])
    # edge 가중치 순으로 정렬
edges = sorted(edges, key=lambda x: x[0])
length = kruskal(parents, edges)
answer = length if length != 0 else -1

# 4. 모든 섬을 연결하지 못했으면 -1
root = find(parents[1], parents)
for idx in range(2, len(parents)):
    temp = find(parents[idx], parents)
    if root != temp:
        answer = -1
        break

print(answer)