选最合适的公寓——距离学校，超市，健身房的最大距离最小

refer to: https://www.algoexpert.io/questions/Apartment%20Hunting

Arrays.Apartment Hunting.Hard

• 题目描述：

给定一组连续的block的信息链表，每个元素代表每一个街区的设备情况（是否有学校，健身房，超市），再给定一个requirements数组，包含需要考虑的元素（学校，健身房，超市）

求住在哪一个街区会使得去学校，健身房，超市的最大距离最小。

• 分析

1. 使用三个for循环

顺序遍历每一个街区，对于每一个街区，遍历每一个reqs，计算当前的街区满足所有reqs的至少要走多少步（所有reqs满足的最大值），最大值存到一个res数组中，代表住在每一个街区的前往三个位置至少要走多少步

计算res数组的最小值，最小的（至少走多少步到达学校，超市，健身房）

• 代码

• import java.util.*;
  
  //O(b^2*r) time | O(b) space
  //b is the number of blocks, r is the number of requirements
  class Program {
    public static int apartmentHunting(List<Map<String, Boolean>> blocks, String[] reqs) {
          int[] res = new int[blocks.size()];//the maxDistance needed to go to 3 places at each block
          Arrays.fill(res, Integer.MIN_VALUE);//need to calculate max value, initialize as min value
          
          for(int i = 0; i < blocks.size(); i++){//iterate all blocks
              for(String req: reqs){//iterate all requiements
                  int minReq = Integer.MAX_VALUE;//min distance to satisfy each requirement at current block
                  for(int j = 0; j < blocks.size(); j++){
                      if(blocks.get(j).get(req)){//check the list, if the boolean value is true, we find the req
                          minReq = Math.min(minReq, Math.abs(i-j));//update the min distance 
                      }                
                  }
                  res[i] = Math.max(res[i], minReq);    //update the  maxDistance needed to go to 3 places at each block        
              }            
          }
          return getMinIdx(res);//get the min index according to the res array.
          
    }
      public static int getMinIdx(int[] Array){ //function to get min_value index from an array
          int idx_min = 0;
          int min_value = Integer.MAX_VALUE;
          for(int i=0; i < Array.length; i++){
              if(min_value > Array[i]){
                  min_value = Array[i];
                  idx_min = i;
              }        
          }
          return idx_min;        
      }
  }

  2. 简化时间复杂度：对于每一个地点，提前计算每一个街区到达每一个地点的最短距离，存储起来，得到一个二元数组，然后对于每一个街区，求每一个街区到达三个地点至少走多少步（maxDisAtBlocks）,这里得到一个一元数组存储maxDisAtBlocks，最后求maxDisAtBlocks的最小值的索引号。

• 

代码

import java.util.*;
//O(br) time | O(br) space
//b: # of blocks, r: # of requirements
class Program {
  public static int apartmentHunting(List<Map<String, Boolean>> blocks, String[] reqs) {
    int[][] minDisFromBlocks = new int[reqs.length][];
        for(int i = 0; i < reqs.length; i++){
            minDisFromBlocks[i] = getMinDistance(blocks, reqs[i]);
            //get the min distance from each block to each req.
        }
        int[] maxDisAtBlocks = getMaxDistanceAtBlocks(blocks, minDisFromBlocks);
        //get the max distance for each block to go to the three required places13         return getMinIdx(maxDisAtBlocks);
    }
    
    public static int[] getMinDistance(List<Map<String, Boolean>> blocks, String req){
        //the min distance from each block to each req.
        int[] minDistance = new int[blocks.size()];
        int closeReqIdx = Integer.MAX_VALUE;
        for(int i = 0; i < blocks.size(); i++){
            if(blocks.get(i).get(req)) closeReqIdx = i;
            minDistance[i] = Math.abs(i-closeReqIdx);
        }
        for(int i = blocks.size() - 1; i >= 0; i--){
            if(blocks.get(i).get(req)) closeReqIdx = i;
            minDistance[i] = Math.min(minDistance[i], Math.abs(i-closeReqIdx));
        }
        return minDistance;    
    }
    
    public static int[] getMaxDistanceAtBlocks(
        //get the max distance to all reqs from each block
    List<Map<String, Boolean>> blocks, int[][] minDisFromBlocks){
        int[] maxDisAtBlocks = new int[blocks.size()];
        for(int i = 0; i < blocks.size(); i++){
            int[] minDisAtBlock = new int[minDisFromBlocks.length];
            for(int j = 0; j < minDisFromBlocks.length; j++){
                minDisAtBlock[j] = minDisFromBlocks[j][i];
            }
            maxDisAtBlocks[i] = arrayMax(minDisAtBlock);        
        }
        return maxDisAtBlocks;    
    }
    
    public static int getMinIdx(int[] Array){ 
        //function to get min_value index from an array
        int idx_min = 0;
        int min_value = Integer.MAX_VALUE;
        for(int i=0; i < Array.length; i++){
            if(min_value > Array[i]){
                min_value = Array[i];
                idx_min = i;
            }        
        }
        return idx_min;        
    }
    
    public static int arrayMax(int[] array){
        //get the max value from an array
        int max = array[0];
        for(int a: array){
            if(a>max){
                max = a;
            }
        }
        return max;    
    }
    
}