Странное поведение массива

        private int[] best;
 
        public int[] BestVectorOptimalFlow
        {
            set {
                best = value;
            }
            get {
                return best; 
            }
        }
 
        public int[] OptmalBust()
        {
            int[] arr = new int[N];
            int index;
            
 
            decimal intensityTemp, serviceFTemp, serviceSTemp, costTemp, additionalTemp;
 
            for (int i = 0; i < N; i++)
            {
                arr[i] = i + 1;
            }
 
            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < N - 1; j++)
                {
                    index = arr[j];
                    intensityTemp = IntensityIncomingFlow[j];
                    serviceFTemp = ServiceFirstTime[j];
                    serviceSTemp = ServiceSecondTime[j];
                    costTemp = CostStayRequirements[j];
                    additionalTemp = AdditionalPenaltyRequirements[j];
 
                    arr[j] = arr[j + 1];
                    IntensityIncomingFlow[j] = IntensityIncomingFlow[j + 1];
                    ServiceFirstTime[j] = ServiceFirstTime[j + 1];
                    ServiceSecondTime[j] = ServiceSecondTime[j + 1];
                    CostStayRequirements[j] = CostStayRequirements[j + 1];
                    AdditionalPenaltyRequirements[j] = AdditionalPenaltyRequirements[j + 1];
 
 
                    arr[j + 1] = index;
                    IntensityIncomingFlow[j + 1] = intensityTemp;
                    ServiceFirstTime[j + 1] = serviceFTemp;
                    ServiceSecondTime[j + 1] = serviceSTemp;
                    CostStayRequirements[j + 1] = costTemp;
                    AdditionalPenaltyRequirements[j + 1] = additionalTemp;
 
                    decimal sum1 = 0;
                    decimal sum2 = 0;
 
                    foreach (int h in arr)
                    {
                        sum1 += IntensityIncomingFlow[h-1] * CostStayRequirements[h-1] * SpentInSystemAverageTime[h-1];
                    }
 
                    foreach (int h in arr)
                    {
                        sum2 += IntensityIncomingFlow[h-1] * AdditionalPenaltyRequirements[h-1] * ServiceInterruptionsAverageTime[h-1];
                    }
 
                    decimal sum = sum1 + sum2;
 
                    if (sum < bestquality)
                    {
                        bestquality = sum;
                        best = arr;
                    }
                }
            }
 
 
            if (best == null)
            {
                return null;
            }
            else
            {
                return best;
            }
 
        }
    }

        public int[] BestVectorOptimalFlow
        {
            set {
                best = value;
            }
            get {
                return best; 
            }
        }

            if (best == null)
            {
                return null;
            }
            else
            {
                return best;
            }

  if (sum < bestquality)
                    {
                        bestquality = sum;
                        best = arr;
                    }