LeetCode. 가장 가까운 사람을 최대화 거리

기술:

행에서 seats, 1그 자리에 앉아 사람을 대표하고, 0좌석이 비어 있음을 나타냅니다. 

적어도 하나의 빈 자리, 적어도 한 사람이 앉아있다.

알렉스는 그와 그에게 가장 가까운 사람 사이의 거리가 최대화되도록 자리에 앉아 싶어한다. 

가장 가까운 사람에게 그 최대 거리를 돌려줍니다.

예 1 :

입력 : [1,0,0,0,1,0,1]
 출력 : 2
 명 : 
알렉스 번째 오픈 좌석에 앉아있는 경우 (있음 [2])을 다음에 가장 가까운 사람의 거리 2. 갖는 
알렉스는 어떤 경우에 앉는 열려있는 다른 유저가 가장 가까운 사람의 거리 (1)를 갖고 
따라서, 가장 가까운 사람의 최대 거리가 2이다.

예 2 :

입력 : [1,0,0,0]
 출력 : 3
 설명 : 
알렉스는 마지막 좌석에 앉아있는 경우, 가장 가까운 사람이 3 석 떨어져 있습니다. 
대답은 3 이렇게하면, 최대 거리 가능하다.

노트 :

1. 1 <= seats.length <= 20000
2. seats , 적어도 하나의 만 0 또는 1 초를 포함 0하고, 적어도 하나를 1.

허용

45488

제출

108771

 

자세한 코드

클래스 해결 {
     공공  INT maxDistToClosest ( INT []를 좌석) { 
        
        
        경우 (seats.length == 2 ) { 
            
            반환 1 ; 
        } 
        
       INT의 결과 = 0 ; 
       INT 최대 = 는 Integer.MIN_VALUE; 
        
       INT의 카운트 = 0 ; 
        
        문자열의 = "" ; 
        
        위한 ( INT ; I <seats.length; 나는 0 = I ++ ) { 
            
            S = S + 좌석 [I];
            경우 (시트 [I] == 0 ) { 
                
                카운트 ++  ;        
            }
            
             다른 { 
 
                경우 (카운트> 최대) { 

                    최대 =이 카운트; 
                   
                } 
                카운트 = 0 ; 
            } 
        } 
        경우 (카운트> 최대) { 
            
            최대 =이 카운트; 
        } 
        문자열 서브 = "" ; 
        
        위한 ( INT ; I <최대 I ++ I 0 = {) 
            서브 = 서브 + "0" ; 
        } 
        
        
        경우 (sub.equals가 (0, (s.substring sub.length ())) || sub.equals (s.substring (s.length () -sub.length ()는 s.length ()))) { 
            
            결과 = 최대; 
        } 
        
        다른 { 
            
            경우 (최대 2 % == 0 ) { 
                결과 = 최대 / 2 ; 
            } 
            다른 { 
                결과 = 최대 / 2 + 1 ; 
            } 
            
        } 
        INT sub_max_1 = 0 ;  
        INT sub_max_2 = 0 ; 
        
        위한 ( INT ; I <seats.length; 나는 0 = I ++ ) {
             경우 (시트 [I] == 0 ) { 
                
                sub_max_1 ++ ; 
                
            }
            
            또 {
                 휴식 ; 
            } 
        } 

        대 ( INT I = seats.length-1, I> 0; 난 ... ) { 
            
            경우 (시트 [I] == 0 ) { 
                sub_max_2 ++ ;  
            } 
            
            다른 {
                 휴식 ; 
            } 
        } 
        INT TMP = sub_max_1> sub_max_2? sub_max_1 : sub_max_2;
        반환 결과> TMP를? 결과 : tmp를; 
    } 
    
}