From Gossip@caterpillar

Algorithm Gossip: 三色旗

 說明

三色旗的問題最早由E.W.Dijkstra所提出，他所使用的用語為Dutch Nation Flag(Dijkstra為荷蘭人)，而多數的作者則使用Three-Color Flag來稱之。

假設有一條繩子，上面有紅、白、藍三種顏色的旗子，起初繩子上的旗子顏色並沒有順序，您希望將之分類，並排列為藍、白、紅的順序，要如何移動次數才會最少，注意您只能在繩子上進行這個動作，而且一次只能調換兩個旗子。

解法

在一條繩子上移動，在程式中也就意味只能使用一個陣列，而不使用其它的陣列來作輔助，問題的解法很簡單，您可以自己想像一下在移動旗子，從繩子開頭進行，遇到藍色往前移，遇到白色留在中間，遇到紅色往後移，如下所示：
三色旗
只是要讓移動次數最少的話，就要有些技巧：
  1. 如果圖中W所在的位置為白色，則W+1，表示未處理的部份移至至白色群組。
  2. 如果W部份為藍色，則B與W的元素對調，而B與W必須各+1，表示兩個群組都多了一個元素。
  3. 如果W所在的位置是紅色，則將W與R交換，但R要減1，表示未處理的部份減1。

注意B、W、R並不是三色旗的個數，它們只是一個移動的指標；什麼時候移動結束呢？一開始時未處理的R指標會是等於旗子的總數，當R的索引數減至少於W的索引數時，表示接下來的旗子就都是紅色了，此時就可以結束移動，如下所示：
三色旗

演算法


Procedure MOVE(Flags[]) [
    wFlag = 0;
    Flag = 0;
    rFlag = LENGTH(Flags[]) - 1;

    WHILE(wFlag <= rFlag) [
        IF(Flags[wFlag] == 'W') [
            wFlag = wFlag + 1;
        ]
        ELSE IF(Flags[wFlag] == 'B') [
            SWAP(Flags[], bFlag, wFlag);
            bFlag = bFlag + 1;
            wFlag = wFlag + 1;
        ]
        ELSE [
            WHILE(wFlag < rFlag && Flags[rFlag] == 'R')
                rFlag = rFlag - 1;
            SWAP(Flags[], rFlag, wFlag);
            rFlag = rFlag - 1;                
        ]
    ]
]

實作：C    Java    Python    Scala    Ruby

  • C 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

#define BLUE 'b' 
#define WHITE 'w' 
#define RED 'r' 

#define SWAP(x, y) { char temp; \
                     temp = color[x]; \
                     color[x] = color[y]; \
                     color[y] = temp; }

void printFlags(char* color) {
    int i; 
    for(i = 0; i < strlen(color); i++) 
        printf("%c ", color[i]); 
    printf("\n");     
}

void move(char* color) {
    int wFlag = 0;
    int bFlag = 0;
    int rFlag = strlen(color) - 1;
    while(wFlag <= rFlag) {
        switch(color[wFlag]) {
            case WHITE:
                   wFlag++;
                   break;
            case BLUE:
                   SWAP(bFlag, wFlag);
                   bFlag++; wFlag++;
                   break;
            default:
                   while(wFlag < rFlag && color[rFlag] == RED)
                       rFlag--;
                   SWAP(rFlag, wFlag);
                   rFlag--;
        }
    }
}

int main() {
    char color[] = {'r', 'w', 'b', 'w', 'w', 
                    'b', 'r', 'b', 'w', 'r', '\0'}; 
    printFlags(color);
    move(color);
    printFlags(color);

    return 0; 
}

  • Java 
import java.util.*;

public class ThreeColorFlag {
    private void swap(char[] flags, int x, int y) {
        char temp = flags[x];
        flags[x] = flags[y];
        flags[y] = temp;
    }
    
    public String move(char[] flags) {
        int wFlag = 0;
        int bFlag = 0;
        int rFlag = flags.length - 1;
    
        while(wFlag <= rFlag) {
            switch(flags[wFlag]) {
                case 'W': 
                    wFlag++; 
                    break;
                case 'B': 
                    swap(flags, bFlag, wFlag); 
                    bFlag++; wFlag++; 
                    break;
                default: 
                    while(wFlag < rFlag && flags[rFlag] == 'R')
                        rFlag--;
                    swap(flags, rFlag, wFlag);
                    rFlag--;        
            }
        }
        
        return new String(flags);
    }
    
    public static void main(String[] args) {        
        System.out.print("輸入三色旗順序（ex. RWBBWRWR）：");
        
        ThreeColorFlag threeColorFlag = new ThreeColorFlag();
        String flags = threeColorFlag.move(
               (new Scanner(System.in)).next().toUpperCase().toCharArray());
        
        System.out.println("移動順序後：" + flags);        
    }
}

  • Python
class ThreeColorFlag:    
    def move(self, flags):
        wFlag = 0
        bFlag = 0
        rFlag = len(flags) - 1
        while wFlag <= rFlag:
            if flags[wFlag] == "W":
                wFlag += 1
            elif flags[wFlag] == "B":
                flags[bFlag], flags[wFlag] = flags[wFlag], flags[bFlag]
                bFlag += 1
                wFlag += 1
            else:
                while ((wFlag < rFlag) and (flags[rFlag] == "R")):
                    rFlag -= 1
                flags[rFlag], flags[wFlag] = flags[wFlag], flags[rFlag]
                rFlag -= 1
        return flags

flags = list(input("輸入三色旗順序（ex. RWBBWRWR）："))
threeColorFlag = ThreeColorFlag()
flags = threeColorFlag.move(flags)
print("移動順序後：", flags)

  • Scala
def move(flags: Array[Char]) = {
    def swap(i: Int, j: Int) {
        val t = flags(i); flags(i) = flags(j); flags(j) = t
    }
    
    def nr(r: Int, w: Int): Int = 
          if((w < r) && (flags(r) == 'R')) nr(r - 1, w) else r
    
    def move(w: Int, b: Int, r: Int): Unit = {
        if(w <= r) {
            flags(w) match {
                case 'W' => move(w + 1, b, r)
                case 'B' => swap(b, w)
                            move(w + 1, b + 1, r)
                case  _  => val tr = nr(r, w)
                            swap(tr, w)
                            move(w, b, tr - 1)
            }
        }
    }
   
    move(0, 0, flags.length - 1)
    flags
}

print("輸入三色旗順序（ex. RWBBWRWR）：")
move(readLine.toCharArray).foreach(print)

  • Ruby
# encoding: Big5
class ThreeColorFlag
    def move(flags)
        wFlag = 0
        bFlag = 0
        rFlag = flags.length - 1
        while wFlag <= rFlag
            case flags[wFlag]
            when "W"
                wFlag += 1
            when "B"
                flags[bFlag], flags[wFlag] = flags[wFlag], flags[bFlag]
                bFlag += 1
                wFlag += 1
            else
                while wFlag < rFlag && flags[rFlag] == "R"
                    rFlag -= 1
                end
                flags[rFlag], flags[wFlag] = flags[wFlag], flags[rFlag]
                rFlag -= 1
            end
        end
        flags
    end
end

print "輸入三色旗順序（ex. RWBBWRWR）："
flags = gets.chomp!
threeColorFlag = ThreeColorFlag.new()
flags = threeColorFlag.move(flags)
print "移動順序後：#{flags} \n"