曼哈顿距离应用

#!/usr/bin/env python3                                                          
                                                                                
                                                                                
class Manhattan:                                                                
                                                                                
    def scan_distance(self, node_val, row_cur, col_cur):                        
        """                                                                     
        @params:                                                                
            @node_val: 元素值                                                   
            @row_cur: 当前行索引                                                
            @row_cur: 当前列索引                                                
        @return:                                                                
            当前行列索引确定的值是否为0                                         
        判断依据                                                                
        """                                                                     
        #  索引越界                                                             
        if row_cur >= self.rows or col_cur >= self.cols:                        
            return False                                                        
                                                                                
        return self.array[row_cur][col_cur] is 0                                
                                                                                
    def get_max(self, row, col):                                                
        """                                                                     
        @params:                                                                
            @row: 元素所在行                                                    
            @col: 元素所在列                                                    
        @return:
            @result: 指定元素到最近的0可能的最大距离                            
        """                                                                     
        result = max(row, self.rows - row - 1, col, self.cols - col - 1)        
                                                                                
        return result                                                           
                                                                                
    def check_distance(self, node_val, row, col, d):                            
        """                                                                     
        @params:                                                                
            @node_val: 元素值                                                   
            @row: 元素所在行                                                    
            @col: 元素所在列                                                    
            @d: 验证距离值                                                      
        @return:                                                                
            待验证距离是否为最近距离                                            
        """                                                                     
        for x in range(-d, d + 1):                                              
            #  当前行索引                                                       
            row_cur = row + x                                                   
            #  纵向行距                                                         
            y = d - int(x if x >= 0 else -x)                                    
            #  当前列索引                                                       
            col_cur = col + y                                                   
            if self.scan_distance(node_val, row_cur, col_cur):                  
                return True                                                     
                                                                                
            #  当前对称列索引
            col_cur = col - y                                                   
            if self.scan_distance(node_val, row_cur, col_cur):                  
                return True                                                     
                                                                                
        return False                                                            
                                                                                
    def get_distance(self, row, col):                                           
        """                                                                     
        @params:                                                                
            @array: 给定二维矩阵                                                
            @row: 元素所在行                                                    
            @col: 元素所在列                                                    
        @return:                                                                
            指定元素到最近的0的距离                                             
        """                                                                     
        #  节点值                                                               
        node_val = self.array[row][col]                                         
        if node_val is 0:                                                       
            return 0                                                            
                                                                                
        #  获取可能的最大距离                                                   
        d_max = self.get_max(row, col)                                          
                                                                                
        for d in range(d_max + 1):                                              
            if self.check_distance(node_val, row, col, d):                      
                return d

        return d_max + 1                                                        
                                                                                
    def get_distance_array(self, array):                                        
        """                                                                     
        @params:                                                                
            @array: 给定由0和1组成的二维矩阵                                    
        @return:                                                                
            @result: 每个元素到最近的0的距离组成的新二维矩阵                    
        """                                                                     
        self.array = array                                                      
                                                                                
        #  矩阵总行数                                                           
        self.rows = len(array)                                                  
        #  矩阵总列数                                                           
        self.cols = len(array[0])                                               
        #  结果存储列表                                                         
        result = list()                                                         
                                                                                
        for row in range(self.rows):                                            
            #  创建二维空列表                                                   
            result.append(list())                                               
                                                                                
            for col in range(self.cols):                                        
                #  获取最近距离                                                 
                result[row].append(self.get_distance(row, col))                 
                                                                                
        return result