在以下问题中是否可以找到多项式时间内是否存在序列？

我一直在思考以下问题，但尚未找到多项式解决方案。只有蛮力。我一直在尝试将NP完全问题简化为没有成功的问题。

这是问题所在：

您有一个正整数对的排序集。 $\{(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)。它交换该对中的元素，因此将变为$(10, 50)$$(50, 10)$

交换集合中的一对时，该集合将自动再次排序（交换后的对不适当，它将移入集合中的位置）。

问题在于查看是否有从某些对开始的序列交换整个集合，并具有以下条件：

一对交换后，下一个要交换的对必须是集合中的后继对或前导对。

找到这个问题的多项式时间解，或者将NP-完全问题简化为一个很好的解决方案。

注意：
这已经是一个决策问题。我不想知道序列是什么：仅当序列存在时。

交换对后如何对集合进行排序的示例

$\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)$

重要：
您不能交换已交换的对。
如果有一系列“交换”操作，则所有对必须重命名一次，并且只能重命名一次。

无法交换所有货币对的示例

（1 ，4 ）（3 ，2 ）（5 ，5 $(0, 0)$
$(1, 4)$
$(3, 2)$
$(5, 5)$

...我搜索了一些模式来减少NPC问题，但没有找到用“叉子”来表示“流”的方法。

所以（经过一些工作）这是一个多项式算法...

算法

起始列表可以视为个连续“ holes ” 的数组。对于每个初始对，将“ 元素 ”放在孔编号。可以将每对视为从位置到位置有向边。甲举动在于拾取元件在位置并将其移动到它的目的地位置（目的地孔变为不可移动的PEG）。我们删除边缘，然后继续选择下一个动作，该动作将从两个最接近的元素之一开始（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 $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$

情况：

A）如果那么两个分区之一将变得无法访问，请停止$| flow | > 1$

现在假设，即 Ë Ñ d ∈ $end > b_j$$end \in R$

B）如果那么从左到右还有一个额外的边，您必须向左走（选择的最近元素），否则您将永远无法到达L e n $flow = 1$$L$$end$

C）如果那么从右到左会有一条额外的边，无论您选择哪个节点，都将永远不会到达，停止e n $flow = -1$$end$

D）如果，则必须向右走（选择的最近元素），否则就必须到达R e n $flow = 0$$R$$end$

如果（），则B，C，D反转。 Ë Ñ 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 我一个我+ 1 Ĵ ≥ 我+ $b_j$$b_i$$a_{i+1}$$j \ge i+1$