Leetcode_first-missing-positive (updated c++ and python version)

地址：http://oj.leetcode.com/problems/first-missing-positive/

思路：模拟题。用一个足够长的布尔数组来存储。时间复杂度O(N), 空间复杂度都O(k).

在做题之前应该明白第一个缺失的正数应该是1~n+1之间的，如果1~n都被填满，那么应该返回n+1

如果k存在，则放在k-1的下标处，即A[k-1]，具体如下操作：

1. 如果A[k] <=0 || A[k] > n, 无效, k递增，下一次循环

2. 如果A[k] <= k+1, 直接将A[k]赋值为k+1，k递增，下一次循环

3. 否则，若A[ A[K]-1 ] 值 <=0 || >n, 说明A[ A[K]-1 ] 值无效，直接将A[ A[K]-1 ] 赋值为A[k]

4. 否则，[ A[K]-1 ]  值有效，如果A[k] 与 A[ A[k]-1 ] 不相等， 置换，(相等的话k递增继续处理，因为A[k]的值被其后的A[A[k]-1]保留了)

5. 否则，k递增下一次循环

参考代码：c++

 
 

  
  //SECOND TRIAL, O(N) running time with constant space
 
 
  
  

   
   class 
   
   Solution 
   
   {
  
  
  
  

   
   public
   
   :
  
  
  
  

   
       
   
   int 
   
   firstMissingPositive
   
   (
   
   int 
   
   A
   
   [], 
   
   int 
   
   n
   
   ) 
   
   {
  
  
  
  

   
           
   
   int 
   
   k 
   
   = 
   
   0
   
   ;
  
  
  
  

   
           
   
   while
   
   (
   
   k
   
   <
   
   n
   
   )
  
  
  
  

   
           
   
   {
  
  
  
  

   
               
   
   if
   
   (
   
   A
   
   [
   
   k
   
   ]
   
   >
   
   0 
   
   && 
   
   A
   
   [
   
   k
   
   ]
   
   <=
   
   n
   
   )
  
  
  
  

   
               
   
   {
  
  
  
  

   
                   
   
   if
   
   (
   
   A
   
   [
   
   k
   
   ]
   
   <=
   
   k
   
   +
   
   1
   
   )
  
  
  
  

   
                       
   
   A
   
   [
   
   A
   
   [
   
   k
   
   ]
   
   -
   
   1
   
   ] 
   
   = 
   
   A
   
   [
   
   k
   
   ++
   
   ];
  
  
  
  

   
                   
   
   else 
   
   if
   
   (
   
   A
   
   [
   
   A
   
   [
   
   k
   
   ]
   
   -
   
   1
   
   ]
   
   <=
   
   0 
   
   || 
   
   A
   
   [
   
   A
   
   [
   
   k
   
   ]
   
   -
   
   1
   
   ]
   
   >
   
   n
   
   )
  
  
  
  

   
                       
   
   A
   
   [
   
   A
   
   [
   
   k
   
   ]
   
   -
   
   1
   
   ] 
   
   = 
   
   A
   
   [
   
   k
   
   ++
   
   ];
  
  
  
  

   
                   
   
   else 
   
   if
   
   (
   
   A
   
   [
   
   A
   
   [
   
   k
   
   ]
   
   -
   
   1
   
   ]
   
   !=
   
   A
   
   [
   
   k
   
   ])
  
  
  
  

   
                       
   
   swap
   
   (
   
   A
   
   [
   
   k
   
   ], 
   
   A
   
   [
   
   A
   
   [
   
   k
   
   ]
   
   -
   
   1
   
   ]);
  
  
  
  

   
                   
   
   else
  
  
  
  

   
                       
   
   ++
   
   k
   
   ;
  
  
  
  

   
               
   
   }
  
  
  
  

   
               
   
   else
  
  
  
  

   
                   
   
   ++
   
   k
   
   ;
  
  
  
  

   
           
   
   }
  
  
  
  

   
           
   
   for
   
   (
   
   int 
   
   i 
   
   = 
   
   0
   
   ; 
   
   i
   
   <
   
   n
   
   ; 
   
   ++
   
   i
   
   )
  
  
  
  

   
               
   
   if
   
   (
   
   A
   
   [
   
   i
   
   ]
   
   !=
   
   i
   
   +
   
   1
   
   )
  
  
  
  

   
                   
   
   return 
   
   i
   
   +
   
   1
   
   ;
  
  
  
  

   
           
   
   return 
   
   n
   
   +
   
   1
   
   ;
  
  
  
  

   
       
   
   }
  
  
  
  

   
   };
  
  
 
 

  
  
 
 

python:

 
 

  
  class 
  
  Solution
  
  :
 
 
 
 

  
      
  
  # @param A, a list of integers
 
 
 
 

  
      
  
  # @return an integer
 
 
 
 

  
      
  
  def 
  
  firstMissingPositive
  
  (
  
  self
  
  , 
  
  A
  
  ):
 
 
 
 

  
          
  
  cnt 
  
  = 
  
  0
 
 
 
 

  
          
  
  while 
  
  cnt 
  
  < 
  
  len
  
  (
  
  A
  
  ):
 
 
 
 

  
              
  
  if 
  
  A
  
  [
  
  cnt
  
  ] 
  
  > 
  
  0 
  
  and 
  
  A
  
  [
  
  cnt
  
  ] 
  
  <= 
  
  len
  
  (
  
  A
  
  ):
 
 
 
 

  
                  
  
  if 
  
  A
  
  [
  
  cnt
  
  ] 
  
  <= 
  
  cnt 
  
  + 
  
  1
  
  :
 
 
 
 

  
                      
  
  A
  
  [ 
  
  A
  
  [
  
  cnt
  
  ]
  
  -
  
  1 
  
  ] 
  
  = 
  
  A
  
  [
  
  cnt
  
  ]
 
 
 
 

  
                      
  
  cnt 
  
  += 
  
  1
 
 
 
 

  
                  
  
  elif 
  
  A
  
  [ 
  
  A
  
  [
  
  cnt
  
  ]
  
  -
  
  1 
  
  ] 
  
  <=
  
  0 
  
  or 
  
  A
  
  [ 
  
  A
  
  [
  
  cnt
  
  ]
  
  -
  
  1 
  
  ]
  
  >
  
  len
  
  (
  
  A
  
  ):
 
 
 
 

  
                      
  
  A
  
  [ 
  
  A
  
  [
  
  cnt
  
  ]
  
  -
  
  1 
  
  ] 
  
  = 
  
  A
  
  [
  
  cnt
  
  ]
 
 
 
 

  
                      
  
  cnt 
  
  += 
  
  1
 
 
 
 

  
                  
  
  elif 
  
  A
  
  [
  
  cnt
  
  ] 
  
  != 
  
  A
  
  [ 
  
  A
  
  [
  
  cnt
  
  ]
  
  -
  
  1 
  
  ]:
 
 
 
 
		    
  
  #better to use tmp to swap
 
 
 
 

  
                      
  
  #tmp = A[cnt]
 
 
 
 

  
                      
  
  #A[cnt] = A[A[cnt]-1]
 
 
 
 

  
                      
  
  #A[tmp-1] = tmp
 
 
 
 
		    
  
  #Attention!! this one is OK, but A[cnt], A[A[cnt]-1] = A[A[cnt]-1], A[cnt] is wrong
 
 
 
 

  
                      
  
  A
  
  [
  
  A
  
  [
  
  cnt
  
  ]
  
  -
  
  1
  
  ], 
  
  A
  
  [
  
  cnt
  
  ] 
  
  = 
  
  A
  
  [
  
  cnt
  
  ], 
  
  A
  
  [
  
  A
  
  [
  
  cnt
  
  ]
  
  -
  
  1
  
  ]
 
 
 
 

  
                  
  
  else
  
  :
 
 
 
 

  
                      
  
  cnt 
  
  += 
  
  1
 
 
 
 

  
              
  
  else
  
  :
 
 
 
 

  
                  
  
  cnt 
  
  += 
  
  1
 
 
 
 

  
          
 
 
 
 

  
          
  
  for 
  
  i 
  
  in 
  
  range
  
  (
  
  0
  
  , 
  
  len
  
  (
  
  A
  
  )):
 
 
 
 

  
              
  
  if 
  
  A
  
  [
  
  i
  
  ] 
  
  != 
  
  i
  
  +
  
  1
  
  :
 
 
 
 

  
                  
  
  return 
  
  i
  
  +
  
  1
 
 
 
 

  
          
  
  return 
  
  len
  
  (
  
  A
  
  )
  
  +
  
  1