Чи можна з'ясувати, чи існує послідовність у поліномі в часі в наступній задачі?

Я певний час думав над наступною проблемою, і не знайшов рішення для поліномів. Лише груба-чотирикласна. Я також намагався зменшити проблему NP-Complete, не маючи успіху.

Ось проблема :

У вас відсортований набір пар натуральних чисел. $\{(A_1, B_1), (A_2, B_2), \ldots, (A_n, B_n)\}$

$(A_i, B_i) < (A_j, B_j) \Leftrightarrow A_i < A_j \lor (A_i = A_j \land B_i < B_j)$ $(A_i, B_i) = (A_j, B_j) \Leftrightarrow A_i = A_j \land B_i = B_j$

Наступна операція може бути застосована до пари: Swap(pair). Він поміняє елементи пари, тому стане( 50 , 10 $(10, 50)$$(50, 10)$

Коли пара в наборі поміняється, набір автоматично знову сортується (поміняється пара не виходить на місце, і він переміститься на своє місце в наборі).

Проблема полягає в тому, щоб побачити, чи є послідовність, яка, починаючи з якоїсь пари, підміняє весь набір із наступною умовою:

Після того, як пара поміняється, наступна пара, яку потрібно поміняти, повинна бути або спадкоємцем, або парою попередника в наборі.

Було б чудово знайти поліноміальне вирішення цієї проблеми або зменшення проблеми NP-Complete в ній.

Примітка.
Це вже проблема вирішення. Я не хочу знати, яка це послідовність: тільки якщо послідовність існує.

Приклад того, як сортується набір після заміни пари

$\textbf{(6, 5)}$
$(1,2)$
$(3,4)$
$(7,8)$

Якщо я поміняю першу пару, вона стає на: , і після сортування набору (розміщення відсортованої пари у новій позиції) ми маємо:$(5,6)$

$(1,2)$
$(3,4)$
$\textbf{(5,6)}$
$(7,8)$

Тоді мені доведеться поміняти або пара (попередник), або (наступник), і повторювати процес, поки всі пари не будуть замінені (якщо можливо).( 7 , 8 $(3,4)$$(7,8)$

Важливо:
Ви не можете замінити вже помінену пару.
Якщо є послідовність операцій "swap", то всі пари повинні бути перейменовані на один раз і лише один раз.

Приклад, коли неможливо замінити всі пари

( 1 , 4 ) ( 3 , 2 ) ( 5 , 5 $(0, 0)$
$(1, 4)$
$(3, 2)$
$(5, 5)$

... Я шукав деякі шаблони, щоб створити скорочення проблеми NPC, але не знайшов способу представити "потік" за допомогою "вилки" ...

Отже (після деякої роботи) це поліноміальний алгоритм ...

АЛГОРИТМ

Початковий список можна розглядати як масив послідовних " дірок ". Для кожної початкової пари поставте " елемент " на номер отвору . Кожну пару можна розглядати як спрямований край від положення до положення . Крок полягає у виборі елемент в положенні і переміщення його в становище призначення (отвір призначення стає нерухомим шпенька ). Видаляємо край і переходимо до вибору наступного кроку, який розпочнеться з одного з двох найближчих доступних елементів( a j , b j ) b j a j a j b j b j a j b j b k b j b j b k$N*2$$(a_j,b_j)$$b_j$$a_j$$a_j$$b_j$$b_j$$a_j$$b_j$$b_k$ з положення (тільки отвори між і дозволено). Треба знайти послідовність послідовних рухів.$b_j$$b_j$$b_k$$N$

• Для кожного розгляньте (у положенні масиву ) як початковий елемент .b j a j s t a r $(a_j,b_j)$$b_j$$a_j$$start$

  • Для кожного розглянемо як кінцевий елемента (край від положення до положення буде остаточним краєм).a k e n d a k b $(a_k,b_k), a_k \neq a_j$$a_k$$end$$a_k$$b_k$

    • генерувати послідовність рухів із використовуючи наступні критерії, поки не досягнете елемента (і рішення не знайдено) або умови зупинкиe n $start$$end$

Коли ви робите рух, ви фіксуєте кілочок у позиції і масив розбивається на два розділи (зліва) та (праворуч), і єдиний спосіб перейти з в (або з в ) - це використання краю що стрибають через кілочок. Встановити L R L R R $b_j$$L$$R$$L$$R$$R$$L$

• $edgesLR$ = кількість ребер зліва направо (не рахувати остаточний край)
• $edgesRL$ = кількість ребер справа наліво (не рахувати остаточний край)
• e d g e s L R - e d g e s R $flow$ =$edgesLR - edgesRL$

Випадки:

А) якщо тоді одна з двох секцій стане недосяжною, зупиніться$| flow | > 1$

Тепер припустимо, що , тобто e n d ∈ $end > b_j$$end \in R$

B) якщо то є додатковий край зліва направо, ви повинні піти вліво (виберіть найближчий елемент ), інакше ви ніколи не досягнетеL e n $flow = 1$$L$$end$

C) , якщо , тобто додаткове ребро справа наліво і будь-який вузол ви вибираєте ви ніколи не досягнете , зупинкаe n $flow = -1$$end$

Г) якщо ви повинні піти праворуч (виберіть найближчий елемент ), інакше ви будете не доходити доR e n $flow = 0$$R$$end$

Якщо ( ), B, C, D перевернуті. e n d ∈ $end < b_j$$end \in L$

ПРИМІТКА. Під час руху вліво або вправо ви повинні вважати кілочком. Наприклад, якщо ви повинні йти праворуч, але найближчий елемент на - переміщення неможливо (і ви повинні продовжити з іншою парою )R e n d ( s t a r t , e n d $end$$R$$end$$(start,end)$

Застосовуйте ту саму резонацію при кожному русі.

СКЛАДНІСТЬ

Потоки через кожен отвір можуть бути попередньо обчислені в O (N) і повторно використані при кожному скануванні.

Петлі:

for start = 1 to N
  for end = 1 to N
    for move = 1 to N
      make a move (fix a peg and update flows)
      check if another move can be done using flow     

Під час обчислення вибір не робиться, тому складність алгоритму становить$O(N^3)$

КОД

Це робоча реалізація алгоритму Java:

public class StrangeSort {
    static int PEG = 0xffffff, HOLE = 0x0;
    static int M = 0, N = 0, choices = 0, aux = 0, end;
    static int problem[][], moves[], edgeflow[], field[];    
    boolean is_hole(int x) { return x == HOLE; }
    boolean is_peg(int x) { return x == PEG; }
    boolean is_ele(int x) { return ! is_peg(x) && ! is_hole(x); };
    int []cp(int src[]) { // copy an array
        int res[] = new int[src.length];
        System.arraycopy(src, 0, res, 0, res.length);
        return res;
    }    
    /* find the first element on the left (dir=-1) right (dir=1) */
    int find(int pos, int dir, int nm) {
        pos += dir;
        while (pos >= 1 && pos <= M ) {
            int x = field[pos];
            if ( is_peg(x) || (pos == end && nm < N-1) ) return 0;
            if ( is_ele(x) ) return pos;
            pos += dir;
        }
        return 0;
    }
    void build_edges() {
        edgeflow = new int[M+1];
        for (int i = 1; i<=M; i++) {
            int start = i;
            int b = field[start];
            if (! is_ele(b)) continue;
            if (i == end) continue;
            int dir = (b > start)? 1 : -1;
            start += dir;
            while (start != b) { edgeflow[start] += dir; start += dir; }
        }
    }
    boolean rec_solve(int start, int nm) {
        boolean f;
        int j;
        int b = field[start];
        moves[nm++] = b;
        if (nm == N) return true;
        //System.out.println("Processing: " + start + "->" + field[start]);        
        field[start] = HOLE;
        field[b] = PEG;
        int dir = (b > start)? 1 : -1;
        int i = start + dir;
        while (i != b) { edgeflow[i] -= dir; i += dir; } // clear edge                
        int flow = edgeflow[b];
        if (Math.abs(flow) > 2) return false;
        if (end > b) {
            switch (flow) {
            case 1 :                    
                j = find(b,-1,nm);
                if (j <= 0) return false;
                return rec_solve(j,nm);
            case -1 :
                return false;
            case 0 :          
                j = find(b,1,nm);
                if (j <= 0) return false;
                return rec_solve(j,nm);
            }        
        } else {
            switch (flow) {
            case -1 :                    
                j = find(b,1,nm);
                if (j <= 0) return false;
                return rec_solve(j,nm);
            case 1 :
                return false;
            case 0 :          
                j = find(b,-1,nm);
                if (j <= 0) return false;
                return rec_solve(j,nm);
            }            
        }
        return false;
    }
    boolean solve(int demo[][]) {
        N = demo.length;
        for (int i = 0; i < N; i++)
            M = Math.max(M, Math.max(demo[i][0], demo[i][1]));
        moves = new int[N];
        edgeflow = new int[M+1];
        field = new int[M+1];
        problem = demo;        
        for (int i = 0; i < problem.length; i++) {
            int a = problem[i][0];
            int b = problem[i][1];
            if ( a < 1 || b < 1 || a > M || b > M || ! is_hole(field[a]) || ! is_hole(field[b])) {
                System.out.println("Bad input pair (" + a + "," + b + ")");
                return false;
            }
            field[a] = b;
        }
        for (int i = 1; i <= M; i++) {
            end = i;
            build_edges();
            if (!is_ele(field[i])) continue;
            for (int j = 1; j <= M; j++) {
                if (!is_ele(field[j])) continue;
                if (i==j) continue;
                int tmp_edgeflow[] = cp(edgeflow);
                int tmp_field[] = cp(field);
                choices = 0;
                //System.out.println("START: " + j + " " + " END: " + i);
                if (rec_solve(j, 0)) {
                    return true;
                }
                edgeflow = tmp_edgeflow;
                field = tmp_field;
            }
        }
        return false;
    }
    void init(int demo[][]) {

    }
    public static void main(String args[]) {
        /**** THE INPUT ********/        

        int demo[][] =  {{4,2},{5,7},{6,3},{10,12},{11,1},{13,8},{14,9}};

        /***********************/        
        String r = "";
        StrangeSort sorter = new StrangeSort();       
        if (sorter.solve(demo)) {
            for (int i = 0; i < N; i++) { // print it in clear text
                int b =  moves[i];
                for (int j = 0; j < demo.length; j++)
                    if (demo[j][1] == b)
                        r += ((i>0)? " -> " : "") + "(" + demo[j][0] + "," + demo[j][1] + ")";
            }             
            r = "SOLUTION: "+r;
        }
        else
            r = "NO SOLUTIONS";
        System.out.println(r);
    }    
}

Це не рішення, а переформулювання, яке дозволяє уникнути явної згадки про операції заміни та сортування. Почніть з сортування всього комбінованого списку імен файлів та їх замінених версій та визначте кожне ім'я файлу з його індексом у цьому списку. Потім два файли є сусідами, якщо всі старі назви файлів між ними вже знищені, і якщо жодна з нових імен файлів між ними ще не створена. Переформульована проблема полягає в наступному:

$n$$(a, b)$$a, b \in \{1,2,…,2n\}$$(a_1, b_1), (a_2, b_2),...,(a_n, b_n)$

• $a_j$$b_i$$a_{i+1}$$j \le i$
• $b_j$$b_i$$a_{i+1}$$j \ge i+1$