from collections import defaultdict, deque
from typing import List, Set, Dict, Tuple

def get_piece_coords(grid: List[List[int]], piece_num: int) -> Set[Tuple[int, int]]:
    """Get all coordinates for a given piece number."""
    coords = set()
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == piece_num:
                coords.add((i, j))
    return coords

def get_all_pieces(grid: List[List[int]]) -> Set[int]:
    """Get set of all piece numbers in the grid."""
    pieces = set()
    for row in grid:
        pieces.update(row)
    return pieces

def get_top_pieces(grid: List[List[int]]) -> Set[int]:
    """Get pieces that form the top surface."""
    return set(grid[0])

def is_on_floor(coords: Set[Tuple[int, int]], height: int) -> bool:
    """Check if piece touches the floor."""
    return any(i == height-1 for i, j in coords)

def has_stable_support(piece_coords: Set[Tuple[int, int]], 
                      supporting_pieces: Dict[int, Set[Tuple[int, int]]], 
                      height: int) -> bool:
    """
    Check if a piece has stable support either from floor or other pieces.
    A piece needs horizontal edge contact (positive area) for stability.
    """
    # Check floor contact
    if is_on_floor(piece_coords, height):
        return True
        
    # Check support from other pieces
    piece_bottom_edges = {(i,j) for i,j in piece_coords if (i+1,j) not in piece_coords}
    
    for support_coords in supporting_pieces.values():
        support_top_edges = {(i,j) for i,j in support_coords if (i-1,j) not in support_coords}
        
        # Check for horizontal edge overlap (positive area contact)
        for i, j in piece_bottom_edges:
            if (i+1, j) in support_top_edges:
                return True
                
    return False

def is_configuration_stable(pieces: Set[int], grid: List[List[int]], 
                          piece_coords: Dict[int, Set[Tuple[int, int]]], 
                          height: int) -> bool:
    """Check if a given configuration of pieces forms a stable table."""
    # Must include all top pieces
    top_pieces = get_top_pieces(grid)
    if not top_pieces.issubset(pieces):
        return False
    
    # Top pieces must form at most two pieces
    if len(top_pieces - (top_pieces - pieces)) > 2:
        return False
        
    # Check stability of each piece
    stable_pieces = set()
    
    while True:
        found_stable = False
        for piece in pieces - stable_pieces:
            if has_stable_support(piece_coords[piece], 
                                {p: piece_coords[p] for p in stable_pieces}, 
                                height):
                stable_pieces.add(piece)
                found_stable = True
                
        if not found_stable:
            break
            
    return stable_pieces == pieces

def solve(height: int, width: int, grid: List[List[int]]) -> int:
    """Find minimum number of pieces needed for a stable table."""
    all_pieces = get_all_pieces(grid)
    piece_coords = {p: get_piece_coords(grid, p) for p in all_pieces}
    
    # Start with minimum required pieces (top pieces)
    min_pieces = float('inf')
    top_pieces = get_top_pieces(grid)
    
    # Try all possible combinations of pieces
    queue = deque([(top_pieces, set())])
    seen = set()
    
    while queue:
        required, optional = queue.popleft()
        current = required | optional
        
        # Skip if we've seen this combination or it's larger than current minimum
        if tuple(sorted(current)) in seen or len(current) >= min_pieces:
            continue
        seen.add(tuple(sorted(current)))
        
        # Check if current configuration is stable
        if is_configuration_stable(current, grid, piece_coords, height):
            min_pieces = min(min_pieces, len(current))
            continue
            
        # Try adding each remaining piece
        remaining = all_pieces - current
        for piece in remaining:
            queue.append((required, optional | {piece}))
            
    return min_pieces

# Process input
h, w = map(int, input().split())
grid = []
for _ in range(h):
    grid.append(list(map(int, input().split())))
    
print(solve(h, w, grid))