Это походит на это Оптимизация Probelm, не проблема сортировки.

Я держал пари с с немного (или возможно много) работы, кто-то мог показать, что это функционально эквивалентно одному из известного NP полные проблемы. Однако для некоторых определенных функций (таких как a^b в Вашем примере), проблема могла бы быть легче.

С тех пор на используемой функции нет никакого переприлипания

также a^b мог быть любой функцией, работающей по любому числу последовательных элементов.

если постоянная функция используется (скажите, что тот, что alwasys возвращается 1), сумма будет тем же для всех упорядочиваний, но Вы не обязательно знаете это, пока Вы не посмотрели на все упорядочивания.

Таким образом, я не вижу ничего более быстрого, чем оценка функции-и-суммы на всех перестановках.

(Вы можете memoize результаты для каждого кортежа для ускорения оценки, но я думаю, что все еще необходимо посмотреть на них всех),

Править: Кроме того, так как это могла быть функция, действующая на все элементы, у Вас могла быть функция, которая возвратилась 0 для всех перестановок кроме одной, для которой это возвращается 1.

Таким образом для общего случая, Вы определенно испытываете необходимость для оценки функции на всех перестановках.

Это - домашняя работа assignement?

В противном случае это - проблема динамического программирования. Для наблюдения его необходимо преобразовать проблему в следующую с помощью примера в качестве основы. Вы в запуске. Можно выбрать любой {1,2,3,4}. Оттуда можно принять решение перейти в {1,2,3,4}. Сделайте в эти 4 раза, когда и у Вас есть все расположение длины 4 из списка {1,2,3,4}.

Теперь Вам нужна функция стоимости, которая определяется как:

f(prev, next) = prev ^ next
              = 0 if the solution is not valid for your original problem 
              = 0 if prev is the start

Общая стоимость выражается как

cost(i|a|X) = min(i in {1,2,3,4}, f(i, a) + cost(X))

отметьте это i|a|X представьте список, запускающийся с элемента a, и затем я и остальная часть списка X.

Взгляд на cost функция необходимо распознать динамическое программирование.

Оттуда можно получить алгоритм. Взгляд на Википедию для введения в динамическое программирование.

Моя реализация Схемы, которую можно протестировать со Схемой PLT:

(define (cost lst f)
  (if (null? lst)
      0
      (let ((h (car lst))
            (t (cdr lst)))
        (if (null? t)
            0
            (+ (f h (car t))
               (cost t f))))))

(define (solve lst f)
  (let loop ((s '()))
    (if (= (length s) (length lst))
        s
        (loop
         (let choose ((candidate lst)
                      (optimal #f)
                      (optimal-cost #f))
           (if (null? candidate)
               optimal
               (let ((c (car candidate)))
                 (if (memq c s)
                     (choose (cdr candidate) optimal optimal-cost)
                     (if (not optimal) 
                         (choose (cdr candidate) (cons c s) (cost (cons c s) f))
                         (if (<= (cost (cons c s) f)
                                 (cost optimal f))
                             (choose (cdr candidate) (cons c s) (cost (cons c s) f))
                             (choose (cdr candidate) optimal optimal-cost)))))))))))

Затем вызов (solve '(1 2 3 4) expt) урожаи другое минимальное решение' (3 2 1 4).

Это - то, что я имею до сих пор. Я создал класс Calc, в который я могу передать каждую из своих комбинаций, она затем вычисляет общее количество и имеет ToString () метод, таким образом, Вы не должны волноваться об итерации для вывода строки суммы и значения. Можно достигнуть общее количество, и список передал в в конструкторе. Можно затем просто добавить, что каждая комбинация устанавливает на список, который можно отсортировать по LINQ в inst. Общее количество..., как я продемонстрировал. Все еще работая над средством генерировать каждую комбинацию...

class Calc
{
    private int[] items;
    private double total;
    public double Total 
    { 
        get
        { 
            return total; 
        } 
    }
    public int[] Items
    {
        get { return items;  }
        set { total = Calculate(value); }
    }
    public static double Calculate(int[] n)
    {
        double t = 0;
        for (int i = 0; i < n.Length - 1; i++)
        {
            int a = n[i]; int b = n[i + 1];
            t += a^b;
        }
        return t;
    }
    public Calc(int[] n)
    {
        this.items = n;
        this.total = Calculate(n);
    }
    public override string ToString()
    {
        var s = String.Empty;
        for (int i = 0; i < items.Length - 1; i++)
        {
            int a = items[i]; int b = items[i + 1];
            s += String.Format("{0}^{1}", a, b);
            s += i < items.Length - 2 ? "+" : "=";
        }
        s += total;
        return s;
    }
}

И затем мы используем класс в нашем вычислении и очень быстро виде общими количествами каждой перестановки:

class Program
{
    static void Main(string[] args)
    {
        var Calculations = new List<Calc>();

        ////Add a new item to totals for every combination of...working on this
        Calculations.Add(new Calc(new int[] { 1, 2, 3, 4 }));
        //...

        //Grab the item with the lowest total... if we wanted the highest, we'd
        //just change .First() to .Last()
        var item = Calculations.OrderBy(i=>i.Total).First();
        Console.WriteLine(item);
        //Or if we wanted all of them:
        //Calculations.OrderBy(i=>i.Total).ForEach(Console.WriteLine);
    }
}

Это - определенно не отсортированный список. Если у Вас есть отсортированный список [x~0 ~... x~n ~], список [x~0 ~.. x~i-1 ~, x~i+1 ~.. x~n ~] (т.е. x~i ~ удаленный) будет по определению также отсортирован. В Вашем примере, удаляя 0 из подпоследовательности 100 0 100, довольно вероятно, не отсортировал бы список.

Я только вижу одно решение:

"в лоб"

    public static int Calculate(Func<int, int, int> f, IList<int> l)
    {
        int sum = 0;
        for (int i = 0; i < l.Count-1; i++)
        {
            sum += f(l[i], l[i + 1]);
        }
        return sum;
    }

    public static IEnumerable<IEnumerable<T>> Permute<T>(IEnumerable<T> list, int count)
    {
        if (count == 0)
        {
            yield return new T[0];
        }
        else
        {
            int startingElementIndex = 0;
            foreach (T startingElement in list)
            {
                IEnumerable<T> remainingItems = AllExcept(list, startingElementIndex);

                foreach (IEnumerable<T> permutationOfRemainder in Permute(remainingItems, count - 1))
                {
                    yield return Concat<T>(
                        new T[] { startingElement },
                        permutationOfRemainder);
                }
                startingElementIndex += 1;
            }
        }
    }

    // Enumerates over contents of both lists.
    public static IEnumerable<T> Concat<T>(IEnumerable<T> a, IEnumerable<T> b)
    {
        foreach (T item in a) { yield return item; }
        foreach (T item in b) { yield return item; }
    }

    // Enumerates over all items in the input, skipping over the item
    // with the specified offset.
    public static IEnumerable<T> AllExcept<T>(IEnumerable<T> input, int indexToSkip)
    {
        int index = 0;
        foreach (T item in input)
        {
            if (index != indexToSkip) yield return item;
            index += 1;
        }
    }

    public static void Main(string[] args)
    {
        List<int> result = null;
        int min = Int32.MaxValue;
        foreach (var p in Permute<int>(new List<int>() { 1, 2, 3, 4 }, 4))
        {
            int sum = Calculate((a, b) => (int)Math.Pow(a, b), new List<int>(p));
            if (sum < min)
            {
                min = sum;
                result = new List<int>(p);
            }
        }
        // print list
        foreach (var item in result)
        {
            Console.Write(item);
        }
    }

Я украл код перестановки из блога Ian Griffiths.

Этот - NP полная проблема, потому что алгоритм неизвестен (NB для заданной функции a^b, это не Завершенный NP, это может быть сделано единственной передачей после сортировки, видеть пример ниже для решения),

Нет никакого пути впереди, что можно в общем записать "алгоритм сортировки", не вычисляя результаты заданной функции для всех возможных перестановок списка.

Однако когда-то, учитывая функцию, можно (возможно) создать метод сортировки для этого, например, для a^b выше, заказать список таким образом (не применяя функцию ни к каким объектам) “Max, минута, затем макс., следующая минута. “. и реверс тот порядок.

В зависимости от сложности заданной функции будет все больше трудно предоставить оптимизированные программы сортировки.

Спасибо,

Хм, это - интересная проблема. Используя существующие конструкции сортировки (IComparable) не будет работать хорошо, потому что Вам нужно больше информации, чем доступно compareTo методу.

Решение этого будет чрезвычайно зависящим от того, каков метод, который Вы хотите использовать для сортировки. Однако на первый взгляд казалось бы, что необходимо будет, вероятно, выполнить итерации по всем возможным заказам найти минимальный заказ. Вы могли потенциально сорвать его если текущая сумма в большем, чем предыдущая полная сумма.

Я должен буду дать этому выстрел и видеть то, что я могу придумать.

непротестированный и бездоказательный:

1. Отсортируйте список
2. Создайте пар из отсортированного списка, захватив первое число и последнее, затем 2-е и 2-е для длительности, и т.д. (т.е. 1,2,3,4 становится 1,4 и 2,3),
3. Для каждой пары сохраните, это - значение a^b. Обратный вид этот список
4. Замените значения a^b в своем новом списке с Вашим a и значения b

Я предполагаю, что это не может быть настолько просто..., но это работает на Ваш пример и не является этим, что действительно имеет значение?