Algorithm 毛里塔尼亚国旗问题

我已经为这个问题制定了解决方案

但这一次，我想尝试更困难的事情：毛里塔尼亚国旗问题——4种颜色，而不是3种。对有效的算法有什么建议吗

基本上，毛里求斯国旗问题的重点是如何根据毛里求斯国旗的颜色顺序（红、蓝、黄、绿）对给定的配对列表进行排序。数字也必须按升序排序

方案编程示例输入：

（（第3条规则）（第6条规则）（第1条规则）（第2条规则）（第7条规则）（第3条规则）（第1条规则）（第8条规则））

输出：

---

（（R.1）（R.3）（B.2）（B.8）（Y.1）（Y.7）（G.3）（G.6））这就像荷兰国旗问题一样，但我们有四种颜色。基本上同样的策略也适用。假设我们有（其中^表示正在扫描的点）

我们扫描了一个

红色，然后将第一个蓝色与当前节点交换

蓝色我们什么也不做

我们和最后一个交换黄色

我们把最后一个黄色和最后一个换成绿色？那么，当前节点是否已交换

因此，我们需要保持跟踪或比平常多出一个指针

我们需要跟踪第一个蓝色，第一个？，最后一个？，最后一个Y

---

一般来说，相同的策略适用于任何数量的颜色，但需要越来越多的交换。我用数字代替颜色

// l  - index at which 0 should be inserted.
// m1 - index at which 1 should be inserted.
// m2 - index at which 2 should be inserted.
// h  - index at which 3 should be inserted.
l=m1=m2=0;
h=arr.length-1
while(m2 <= h) {
    if (arr[m2] == 0) {
        swap(arr, m2, l);
        l++;

        // m1 should be incremented if it is less than l as 1 can come after all
        // 0's
        //only.
        if (m1 < l) {
            m1++;
        }
        // Now why not always incrementing m2 as we used to do in 3 flag partition
        // while comparing with 0? Let's take an example here. Suppose arr[l]=1
        // and arr[m2]=0. So we swap arr[l] with arr[m2] with and increment l.
        // Now arr[m2] is equal to 1. But if arr[m1] is equal to 2 then we should
        // swap arr[m1] with arr[m2]. That's  why arr[m2] needs to be processed
        // again for the sake of arr[m1]. In any case, it should not be less than
        // l, so incrmenting.
        if(m2<l) {
            m2++;
        }       
    }
    // From here it is exactly same as 3 flag.
    else if(arr[m2]==1) {
        swap(arr, m1, m2)
        m1++;
        m2++;           
    }
    else if(arr[m2] ==2){
        m2++;
    }
    else {
        swap(arr, m2, h);
        h--;
    }           
}


}

//l-应插入0的索引。
//m1-应插入1的索引。
//m2-应插入2的索引。
//h-应插入3的索引。
l=m1=m2=0；
h=arr.length-1
而（m2基本上保持以下几点：

a[0-p] => '0'
a[p-q] => '1'
a[q-r] => '2'
a[r-s] => traversing! 
a[s-length] => '3'          

代码：

intp=-1，q=-1，r=0，s=a.length-1；
虽然（r我有类似的代码，但不是

function sort(a:string[]){    
         let low = 0;
         let mid1 = 0;
         let mid2 = a.length-1;
         let high = a.length-1;

        while(mid1 <= mid2){
             switch(a[mid1]){

                 case '0':

                        [a[mid1],a[low]] = [a[low],a[mid1]];
                        mid1++;
                        low++;
                        break;

                 case '1':mid1++;break;

                 case '2':
                 case '3':[a[mid1],a[mid2]] = [a[mid2],a[mid1]];
                            mid2--;
                            break;

                 }
         }
    //sort 2 and 3
         while(mid1 <= high){
          switch(a[mid1]){
                 case '2': mid1++; break;
                 case '3': [a[mid1],a[high]] = [a[high],a[mid1]]
                            high--;
                            break;

           }
        }

}

函数排序（a:string[]）{
设low=0；
设mid1=0；
设mid2=a.length-1；
设高=a.length-1；
while（mid1
函数sort3（a:string[]）：void{
设low=0；
设mid1=0；
设mid2=0；
设高=a.长度-1；
while（mid2
a:string[]=['1'，'2'，'1'，'0'，'2'，'4'，'3'，'0'，'1'，'3']；
函数sort3（a:string[]）：void{
设low=0；
设mid1=0；
设mid2=0；
设mid3=0；
设高=a.长度-1；
虽然（mid3No，事实上，我们并不都知道荷兰国旗的问题是什么。我也编辑了你的问题，删除了所有大写文本。现在我们知道这实际上是一个CS问题，也许关闭者会重新考虑他们的决定？没有必要关闭这个问题，因为这是一个有趣的问题。但它可以被重新措辞来描述让问题变得更好。而且我也不确定这个算法问题是否有任何解决方案。在编辑之后，这个问题在我看来很清楚。投票重新打开，因为我是毛里求斯人。（除其他原因外）虽然此代码片段可以解决问题，但确实有助于提高您的文章质量。请记住，您是在为将来的读者回答问题，而这些人可能不知道您提出代码建议的原因。虽然此代码片段可以解决问题，但确实有助于提高您文章的质量。请记住如果您将来为读者回答这个问题，那么这些人可能不知道您的代码建议的原因。
a[0-p] => '0'
a[p-q] => '1'
a[q-r] => '2'
a[r-s] => traversing! 
a[s-length] => '3'          

        int p=-1,q=-1,r=0,s=a.length-1;
        while(r<=s){
            if(a[r]==0){
                exchange(a,p+1,r);
                p++;r++;
                if(q!=-1)
                    q++;
            } else if (a[r]==1){
                if(q==-1)
                    q=p;
                exchange(a,q+1,r);
                q++;r++;
            } else if(a[r]==2) {
                r++;
            } else {
                exchange(a,r,s);
                s--;
            }

        }

function sort(a:string[]){    
         let low = 0;
         let mid1 = 0;
         let mid2 = a.length-1;
         let high = a.length-1;

        while(mid1 <= mid2){
             switch(a[mid1]){

                 case '0':

                        [a[mid1],a[low]] = [a[low],a[mid1]];
                        mid1++;
                        low++;
                        break;

                 case '1':mid1++;break;

                 case '2':
                 case '3':[a[mid1],a[mid2]] = [a[mid2],a[mid1]];
                            mid2--;
                            break;

                 }
         }
    //sort 2 and 3
         while(mid1 <= high){
          switch(a[mid1]){
                 case '2': mid1++; break;
                 case '3': [a[mid1],a[high]] = [a[high],a[mid1]]
                            high--;
                            break;

           }
        }

}

function sort3(a:string[]):void{
    let low = 0;
    let mid1 = 0;
    let mid2 = 0;
    let high = a.length - 1;
    while(mid2<=high){
        switch(a[mid2]){
            case '0': [a[mid2],a[low]] = [a[low],a[mid2]];
                    low++;
                    if(mid1<low)
                    mid1++;
                    if(mid2<mid1)
                    mid2++;
                    break;

            case '1': [a[mid2],a[mid1]] = [a[mid1],a[mid2]];
                    mid1++;
                    mid2++;
                    break;

            case '2':mid2++
                   break;

            case '3':[a[mid2],a[high]] = [a[high],a[mid2]];
                    high--;
        }
    }
}

let a:string[] = ['1','2','1','0','2','4','3','0','1','3'];

function sort3(a:string[]):void{
    let low = 0;
    let mid1 = 0;
    let mid2 = 0;
    let mid3 = 0;
    let high = a.length - 1;
    while(mid3<=high){
        switch(a[mid3]){
            case '0': [a[mid3],a[low]] = [a[low],a[mid3]];
                    low++;
                    if(mid1 < low)
                    mid1++;
                    if(mid2 < mid1)
                    mid2++;
                    if(mid3 < mid2)
                    mid3++;
                    break;

            case '1': [a[mid3],a[mid1]] = [a[mid1],a[mid3]];
                    mid1++;
                    if(mid2 < mid1)
                    mid2++;
                    if(mid3 < mid2)
                    mid3++
                    break;

            case '2': [a[mid2],a[mid3]] = [a[mid3],a[mid2]];
                        mid2++;
                        mid3++;
                   break;

            case '3':
                    mid3++;break;

            case '4': [a[mid3],a[high]] = [a[high],a[mid3]];
                        high--;
        }
    }
}