---
# System prepended metadata

title: Untitled

---

```cpp=
int main{

    Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、所有非加班車與加班車之集合K、非加班車的車輛數k_bar、車輛司機優先順序的集合P、加班車輛順位之集合P+、位在第r區的客戶點集合G_r、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k
    //從第一分區開始分配
    r=1
    Repeat
        k=d_1^r;
        將離場站(分區0)在分區 r 內最近的第一個顧客點x分配給第一優先順序的車輛路徑集合γ^r;
        x=min{distance(x_0,N_0)}, x_0 in γ^r;
        將離分區 r 質點最近的顧客 x 從集合γ ^r中取出並加入到車輛k路徑η_k的尾端;
        將顧客點 x 的需求量q_x加到l_k;
        將場站到顧客點 x 的旅行 𝜏_0x 和服務時間𝜃_x加到 s_k(s_k = 𝜏_0x+ 𝜃_x);
        t=1;    
        Repeat
            將分區 r 內離第一個顧客點 x 最近的顧客點 y 從車輛路徑集合γ^r加入到η _k的尾端;
            將顧客點 y 的需求量q_y加到l_k;
            將顧客點 x 到顧客點 y 的旅行𝜏_xy和服務時間 𝜃_y 加到 s_k 裡(s_k = 𝜏_xy+ 𝜃_y);
            t=t+1;x=y;
        Until t>G_r;
        r=r+1;
    Until r>R;
    //從第一分區開始檢查
    r=1;
    Repeat
        //若車輛超過限制
        if(l_k>c*μ or s_k>t)
            p=2;
            Repeat
                選取分區 r 中離第 p 優先順序司機車輛 k’ 。 k’=d^p_r;
                if(l_k’>c*μ or s_k’>t)
                    p=p+1;
                    goto step 75;//跳到第75行繼續選取其他順位的車輛的迴圈
                Else(
                    ε=1;
                    Repeat
                        車輛 k 路徑η _k中選取離分區k’質心第 ε 近的顧客點 x;
                        H_k’(測試用路徑) = η_k’;
                        將顧客點需求量 q_x 加入測試用路徑 H_k’ 內並計算 H_k’路徑內的l_k’ ; l_k’= Σ q_i ;i ϵ H_k’;
                        if(l_k’>c*μ)
                            goto step 67;//跳到第67行繼續選取其他顧客點的迴圈
                        End if
                        //開始尋找最適合插入的位置
                        t=1; y_best=M;
                        Repeat
                            選取嘗試路徑 H_k’ 中顧客點;
                            y=v^k’_t 以及顧客點;
                            y’=v^k’_t+1 並計算;
                            y*=|yx|+|xy’-|yy’|;
                            if(y* < y_best)
                                y_best=y*;
                            Else y_best=y_best
                            t=t+1;
                        Until t > Σv^k’_i i ϵ H_k’;
                        將顧客點 x 加入到H_k’的y_best的位置，並計算 H_k’路徑的總耗時(s_k’=Σ𝜏_ij +Σ𝜃_i i ϵ H_k’ , j ϵ H_k’);
                        if(s_k’>t)
                            goto step 67;//跳到第67行繼續選取其他顧客點的迴圈
                        Else{
                            將顧客點 x 在η_k路徑中所在的第 m 個位置從η _k移除後連結第 m-1 個和第 m+1 個的顧客點將 x 加入到η_k’裡的y_best;
                            將l_k減去q_x;
                            重新計算η_k路徑裡的s_k;
                            if(l_k>c*μ or s_k>t)
                                ε=1;
                                goto step 68;//跳到第68行繼續選取其他顧客點的迴圈
                            Else goto step 106;//跳到第106行繼續下一個分區
                        }
                        ε=ε+1;
                    Until ε <= Σ v^k_i , i ϵ N ;
                )
                將所有超過限制的車輛d_p^r透過支援車的方式來協助分配顧客點;
                if(協助車為非加班車)
                    將顧客點x加到支援車的最佳位置上;
                Else(協助車為加班車)
                    將顧客點x加到支援車尾端;
            p=p+1;//尋找後續順位
            Until p > P/P^+;
            //--------------------------------加班車------------------------------------------------//
            ν=1; o=1;
            Repeat
                Repeat
                    車輛 k 路徑 η _k 中選取需求量第 ν 大的顧客點 x ;
                    H_o(測試用路徑) = η_o;
                    將顧客點 x 加到測試用路徑 H_o 內並計算 H_o路徑內的 l_o，l_o= Σ q_i ;i ϵH_o ;
                    If(l_o>c*μ)
                        goto step 101; //跳到第101行繼續尋找其他顧客點的迴圈
                    Else{
                        計算 H_o 路徑的總耗時s_o= Σ𝜏_ij+Σ 𝜃_i, i ϵ H_o , j ϵH_o;
                        If(s_o>t)
                            goto step 101; //跳到第101行繼續尋找其他顧客點的迴圈
                        Else{
                            將顧客點 x 在 η _k 路徑中所在的第 m 個位置從 η _k 移除後連結第m-1個和第m+1個的顧客點;
                            將 x 加入到 η _o 的尾端;
                            將l_k減去q_x;
                            重新計算η_k路徑裡的s_k;
                            If(l_k>c*μ or s_k>t)
                                ν=1;
                                goto step 102; //跳到第102行繼續尋找其他顧客點的迴圈
                            Else goto step 106;//跳到第106行繼續下一個分區
                        }
                    } 
                    ν=ν+1;
                Until ν <= Σ v^k_i,i ϵ N
                o=o+1;
            Until o > P^+;
        End if
        r=r+1;
    Until r>R;
}
//------------------------------------------------------------這裡 演算法一-----------------------------------------------
Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、所有非加班車與加班車之集合K、非加班車的車輛數k_bar、車輛司機優先順序的集合P、加班車輛順位之集合P+、位在第r區的客戶點集合G_r、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k
    //從第一分區開始分配
    
    r=1
    Repeat
        k=d_1^r;
        將離場站(分區0)在分區 r 內最近的第一個顧客點x分配給第一優先順序的車輛路徑集合γ^r;
        x=min{distance(x_0,N_0)}, x_0 in γ^r;
        將離分區 r 質點最近的顧客 x 從集合γ ^r中取出並加入到車輛k路徑η_k的尾端;
        將顧客點 x 的需求量q_x加到l_k;
        將場站到顧客點 x 的旅行 𝜏_0x 和服務時間𝜃_x加到 s_k(s_k = 𝜏_0x+ 𝜃_x);
        t=1;    
        Repeat
            將分區 r 內離第一個顧客點 x 最近的顧客點 y 從車輛路徑集合γ^r加入到η _k的尾端;
            將顧客點 y 的需求量q_y加到l_k;
            將顧客點 x 到顧客點 y 的旅行𝜏_xy和服務時間 𝜃_y 加到 s_k 裡(s_k = 𝜏_xy+ 𝜃_y);
            t=t+1;x=y;
        Until t>G_r;
        r=r+1;
    Until r>R;
//-------------------------------------------------------演算法二--------------------------------------------------------
Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、所有非加班車與加班車之集合K、車輛司機優先順序的集合P、加班車輛順位之集合P+、位在第r區的客戶點集合G_r、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k
    //從第一分區開始檢查
    r=1;
    Repeat
        //若車輛超過限制
        if(l_k>c*μ or s_k>t)
            p=2;
            Repeat
                選取分區 r 中離第 p 優先順序司機車輛 k’ 。 k’=d^p_r;
                if(l_k’>c*μ or s_k’>t)
                    p=p+1;
                    goto step 49;//跳到第49行繼續選取其他順位的車輛的迴圈
                Else(
                    ε=1;
                    Repeat
                        車輛 k 路徑η _k中選取離分區k’質心第 ε 近的顧客點 x;
                        H_k’(測試用路徑) = η_k’;
                        將顧客點需求量 q_x 加入測試用路徑 H_k’ 內並計算 H_k’路徑內的l_k’ ; l_k’= Σ q_i ;i ϵ H_k’;
                        if(l_k’>c*μ)
                            goto step 46;//跳到第46行繼續選取其他顧客點的迴圈
                        End if
                        //開始尋找最適合插入的位置
                        t=1; y_best=M;
                        Repeat
                            選取嘗試路徑 H_k’ 中顧客點;
                            y=v^k’_t 以及顧客點;
                            y’=v^k’_t+1 並計算;
                            y*=|yx|+|xy’-|yy’|;
                            if(y* < y_best)
                                y_best=y*;
                            Else y_best=y_best
                            t=t+1;
                        Until t > Σv^k’_i i ϵ H_k’;
                        將顧客點 x 加入到H_k’的y_best的位置，並計算 H_k’路徑的總耗時(s_k’=Σ𝜏_ij +Σ𝜃_i i ϵ H_k’ , j ϵ H_k’);
                        if(s_k’>t)
                            goto step 46;//跳到第46行繼續選取其他顧客點的迴圈
                        Else{
                            將顧客點 x 在η_k路徑中所在的第 m 個位置從η _k移除後連結第 m-1 個和第 m+1 個的顧客點將 x 加入到η_k’裡的y_best;
                            將l_k減去q_x;
                            重新計算η_k路徑裡的s_k;
                            if(l_k>c*μ or s_k>t)
                                ε=1;
                                goto step 68;//跳到第47行繼續選取其他顧客點的迴圈
                            Else goto step 55;//跳到第55行繼續下一個分區
                        }
                        ε=ε+1;//尋找其他顧客點
                    Until ε <= Σ v^k_i , i ϵ N ;//直到確認完所有顧客點
                )
            p=p+1;//尋找後續順位的非加班車
            Until p > P/P^+;//直到後續順位的非加班車用完
            if(l_k>c*μ or s_k>t)
                加班車程序//第三PART;
            End if
        End if
        r=r+1;//選取下個分區
    Until r>R;//直到確認完所有分區
Output : 車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k
//-------------------------------------------------------演算法三--------------------------------------------------------
Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、車輛司機優先順序的集合P、加班車輛順位之集合P+、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_o
    //加班車程序
    ν=1; o=1;
    Repeat
        Repeat
            車輛 k 路徑 η _k 中選取需求量第 ν 大的顧客點 x ;
            H_o(測試用路徑) = η_o;
            將顧客點 x 加到測試用路徑 H_o 內並計算 H_o路徑內的 l_o，l_o= Σ q_i ;i ϵH_o ;
            If(l_o>c*μ)
                goto step 26; //跳到第26行繼續尋找其他顧客點的迴圈
            Else{
                計算 H_o 路徑的總耗時s_o= Σ𝜏_ij+Σ 𝜃_i, i ϵ H_o , j ϵH_o;
                If(s_o>t)
                    goto step 26; //跳到第26行繼續尋找其他顧客點的迴圈
                Else{
                    將顧客點 x 在 η _k 路徑中所在的第 m 個位置從 η _k 移除後連結第m-1個和第m+1個的顧客點;
                    將 x 加入到 η _o 的尾端;
                    將l_k減去q_x;
                    重新計算η_k路徑裡的s_k;
                    If(l_k>c*μ or s_k>t)
                        ν=1;
                        goto step 27; //跳到第27行繼續尋找其他顧客點的迴圈
                    End if
                }
            } 
            ν=ν+1;//尋找其他顧客點
        Until ν <= Σ v^k_i,i ϵ N //直到確認完所有顧客點
        o=o+1;//尋找其他加班車
    Until o > P^+;直到所有加班車用完
Output : 車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k
//---------------------------------------------------------------非常感謝----------------------------------------------
```
* $\text{Input main\{}$
    * $\textbf{Input:}$
    * 在不考慮限制的狀況下，將分區 $r$ 的所有顧客分配給第一優先順序的司機車輛集合 $\gamma^{r}$
    * 
    * 從第一分區開始
    * 將所有超過限制的車輛 $d_p^r$ 透過尋找非加班車的支援車的方式來協助分配顧客點;
    * 若沒有可使用的非加班車
    * 使用加班車協助分配顧客點
    * 
    * $r=1;$
    * $\textbf{Repeat}$
        * $k = d_{r}^{1};$
        * 將離場站(分區0)在分區 $r$ 內最近的第一個顧客點 $x$ 分配給第一優先順序的車輛路徑集合 $\gamma^r;$
        * $x=\min \{distance(x_0,N_0) \},~x_0 \in \gamma^r;$
        將離分區 $r$ 質點最近的顧客 $x$ 從集合 $\gamma^r$ 中取出並加入到車輛 $k$ 路徑 $\eta_k$ 的尾端$;$
        * 將顧客點 $x$ 的需求量 $q_x$ 加到 $l_k;$
        * 將場站到顧客點 $x$ 的旅行 $\tau_{0x}$ 和服務時間 $\theta_x$ 加到 $s_k~(s_k = \tau_{0x}+ \theta_x);$
        * $t=1;$
        * $\textbf{Repeat}$
            * 將分區 $r$ 內離第一個顧客點 $x$ 最近的顧客點 $y$ 從車輛路徑集合 $\gamma^r$ 加入到 $\eta_k$ 的尾端$;$
            * 將顧客點 $y$ 的需求量 $q_y$ 加到 $l_k;$
            * 將顧客點 $x$ 到顧客點 $y$ 的旅行 $\tau_{xy}$ 和服務時間 $\theta_y$ 加到 $s_k$ 裡 $(s_k = \tau_{xy} + \theta_y);$
            * $t=t+1;~~x=y;$
        * $\textbf{Until}~~t > G_{r};$
        * $r=r+1;$
    * $\textbf{Until}~~r>R;$
    * 
    * $r=1;$
    * $\textbf{Repeat}$
        * $\textbf{If}~~(l_k > c*u ~\textbf{or}~ s_k > t)$
            * $p=2;$
            * $\textbf{Repeat}$
                * 選取分區 $r$ 中離第 $p$ 優先順序司機車輛 $$
            * $\textbf{Until}~~p > P/P^{+}$
    * $\textbf{Until}~~r>R$
* $\}$

> 123
>>456
>>>77788899
>>>>4566





1  int main{
2  
3      Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、所有非加班車與加班車之集合K、非加班車的車輛數k_bar、車輛司機優先順序的集合P、加班車輛順位之集合P+、位在第r區的客戶點集合G_r、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k
4      //從第一分區開始分配
5      r=1
6      Repeat
7          k=d_1^r;
8          將離場站(分區0)在分區 r 內最近的第一個顧客點x分配給第一優先順序的車輛路徑集合γ^r;
9          x=min{distance(x_0,N_0)}, x_0 in γ^r;
10         將離分區 r 質點最近的顧客 x 從集合γ ^r中取出並加入到車輛k路徑η_k的尾端;
11         將顧客點 x 的需求量q_x加到l_k;
12         將場站到顧客點 x 的旅行 𝜏_0x 和服務時間𝜃_x加到 s_k(s_k = 𝜏_0x+ 𝜃_x);
13         t=1;    
14         Repeat
15             將分區 r 內離第一個顧客點 x 最近的顧客點 y 從車輛路徑集合γ^r加入到η _k的尾端;
16             將顧客點 y 的需求量q_y加到l_k;
17             將顧客點 x 到顧客點 y 的旅行𝜏_xy和服務時間 𝜃_y 加到 s_k 裡(s_k = 𝜏_xy+ 𝜃_y);
18             t=t+1;x=y;
19         Until t>G_r;
20         r=r+1;
21     Until r>R;
22     //從第一分區開始檢查
23     r=1;
24     Repeat
25         //若車輛超過限制
26         if(l_k>c*μ or s_k>t)
27             p=2;
28             Repeat
29                 選取分區 r 中離第 p 優先順序司機車輛 k’ 。 k’=d^p_r;
30                 if(l_k’>c*μ or s_k’>t)
31                     p=p+1;
32                     goto step 75;//跳到第75行繼續選取其他順位的車輛的迴圈
33                 Else(
34                     ε=1;
35                     Repeat
36                         車輛 k 路徑η _k中選取離分區k’質心第 ε 近的顧客點 x;
37                         H_k’(測試用路徑) = η_k’;
38                         將顧客點需求量 q_x 加入測試用路徑 H_k’ 內並計算 H_k’路徑內的l_k’ ; l_k’= Σ q_i ;i ϵ H_k’;
39                         if(l_k’>c*μ)
40                             goto step 67;//跳到第67行繼續選取其他顧客點的迴圈
41                         End if
42                         //開始尋找最適合插入的位置
43                         t=1; y_best=M;
44                         Repeat
45                             選取嘗試路徑 H_k’ 中顧客點;
46                             y=v^k’_t 以及顧客點;
47                             y’=v^k’_t+1 並計算;
48                             y*=|yx|+|xy’-|yy’|;
49                             if(y* < y_best)
50                                 y_best=y*;
51                             Else y_best=y_best
52                             t=t+1;
53                         Until t > Σv^k’_i i ϵ H_k’;
54                         將顧客點 x 加入到H_k’的y_best的位置，並計算 H_k’路徑的總耗時(s_k’=Σ𝜏_ij +Σ𝜃_i i ϵ H_k’ , j ϵ H_k’);
55                         if(s_k’>t)
56                             goto step 67;//跳到第67行繼續選取其他顧客點的迴圈
57                         Else{
58                             將顧客點 x 在η_k路徑中所在的第 m 個位置從η _k移除後連結第 m-1 個和第 m+1 個的顧客點將 x 加入到η_k’裡的y_best;
59                             將l_k減去q_x;
60                             重新計算η_k路徑裡的s_k;
61                             if(l_k>c*μ or s_k>t)
62                                 ε=1;
63                                 goto step 68;//跳到第68行繼續選取其他顧客點的迴圈
64                             Else goto step 106;//跳到第106行繼續下一個分區
65                         }
66                         ε=ε+1;
67                     Until ε <= Σ v^k_i , i ϵ N ;
68                 )
69                 將所有超過限制的車輛d_p^r透過支援車的方式來協助分配顧客點;
70                 if(協助車為非加班車)
71                     將顧客點x加到支援車的最佳位置上;
72                 Else(協助車為加班車)
73                     將顧客點x加到支援車尾端;
74             p=p+1;//尋找後續順位
75             Until p > P/P^+;
76             //--------------------------------加班車------------------------------------------------//
77             ν=1; o=1;
78             Repeat
79                 Repeat
80                     車輛 k 路徑 η _k 中選取需求量第 ν 大的顧客點 x ;
81                     H_o(測試用路徑) = η_o;
82                     將顧客點 x 加到測試用路徑 H_o 內並計算 H_o路徑內的 l_o，l_o= Σ q_i ;i ϵH_o ;
83                     If(l_o>c*μ)
84                         goto step 101; //跳到第101行繼續尋找其他顧客點的迴圈
85                     Else{
86                         計算 H_o 路徑的總耗時s_o= Σ𝜏_ij+Σ 𝜃_i, i ϵ H_o , j ϵH_o;
87                         If(s_o>t)
88                             goto step 101; //跳到第101行繼續尋找其他顧客點的迴圈
89                         Else{
90                             將顧客點 x 在 η _k 路徑中所在的第 m 個位置從 η _k 移除後連結第m-1個和第m+1個的顧客點;
91                             將 x 加入到 η _o 的尾端;
92                             將l_k減去q_x;
93                             重新計算η_k路徑裡的s_k;
94                             If(l_k>c*μ or s_k>t)
95                                 ν=1;
96                                 goto step 102; //跳到第102行繼續尋找其他顧客點的迴圈
97                             Else goto step 106;//跳到第106行繼續下一個分區
98                         }
99                     } 
100                    ν=ν+1;
101                Until ν <= Σ v^k_i,i ϵ N
102                o=o+1;
103            Until o > P^+;
104        End if
105        r=r+1;
106    Until r>R;
107}






1  int main{
2  
3    Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、所有非加班車與加班車之集合K、非加班車的車輛數k_bar、車輛司機優先順序的集合P、加班車輛順位之集合P+、位在第r區的客戶點集合G_r、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k
4    //從第一分區開始分配
5    r=1
6    Repeat
7      k=d_1^r;
8      將離場站(分區0)在分區 r 內最近的第一個顧客點x分配給第一優先順序的車輛路徑集合γ^r;
9      x=min{distance(x_0,N_0)}, x_0 in γ^r;
10     將離分區 r 質點最近的顧客 x 從集合γ ^r中取出並加入到車輛k路徑η_k的尾端;
11     將顧客點 x 的需求量q_x加到l_k;
12     將場站到顧客點 x 的旅行 𝜏_0x 和服務時間𝜃_x加到 s_k(s_k = 𝜏_0x+ 𝜃_x);
13     t=1;  
14     Repeat
15       將分區 r 內離第一個顧客點 x 最近的顧客點 y 從車輛路徑集合γ^r加入到η _k的尾端;
16       將顧客點 y 的需求量q_y加到l_k;
17       將顧客點 x 到顧客點 y 的旅行𝜏_xy和服務時間 𝜃_y 加到 s_k 裡(s_k = 𝜏_xy+ 𝜃_y);
18       t=t+1;x=y;
19     Until t>G_r;
20     r=r+1;
21   Until r>R;
22   //從第一分區開始檢查
23   r=1;
24   Repeat
25     //若車輛超過限制
26     if(l_k>c*μ or s_k>t)
27       p=2;
28       Repeat
29         選取分區 r 中離第 p 優先順序司機車輛 k’ 。 k’=d^p_r;
30         if(l_k’>c*μ or s_k’>t)
31           p=p+1;
32           goto step 75;//跳到第75行繼續選取其他順位的車輛的迴圈
33         Else(
34           ε=1;
35           Repeat
36             車輛 k 路徑η _k中選取離分區k’質心第 ε 近的顧客點 x;
37             H_k’(測試用路徑) = η_k’;
38             將顧客點需求量 q_x 加入測試用路徑 H_k’ 內並計算 H_k’路徑內的l_k’ ; l_k’= Σ q_i ;i ϵ H_k’;
39             if(l_k’>c*μ)
40               goto step 67;//跳到第67行繼續選取其他顧客點的迴圈
41             End if
42             //開始尋找最適合插入的位置
43             t=1; y_best=M;
44             Repeat
45               選取嘗試路徑 H_k’ 中顧客點;
46               y=v^k’_t 以及顧客點;
47               y’=v^k’_t+1 並計算;
48               y*=|yx|+|xy’-|yy’|;
49               if(y* < y_best)
50                 y_best=y*;
51               Else y_best=y_best
52               t=t+1;
53             Until t > Σv^k’_i i ϵ H_k’;
54             將顧客點 x 加入到H_k’的y_best的位置，並計算 H_k’路徑的總耗時(s_k’=Σ𝜏_ij +Σ𝜃_i i ϵ H_k’ , j ϵ H_k’);
55             if(s_k’>t)
56               goto step 67;//跳到第67行繼續選取其他顧客點的迴圈
57             Else{
58               將顧客點 x 在η_k路徑中所在的第 m 個位置從η _k移除後連結第 m-1 個和第 m+1 個的顧客點將 x 加入到η_k’裡的y_best;
59               將l_k減去q_x;
60               重新計算η_k路徑裡的s_k;
61               if(l_k>c*μ or s_k>t)
62                 ε=1;
63                 goto step 68;//跳到第68行繼續選取其他顧客點的迴圈
64               Else goto step 106;//跳到第106行繼續下一個分區
65             }
66             ε=ε+1;
67           Until ε <= Σ v^k_i , i ϵ N ;
68         )
69         將所有超過限制的車輛d_p^r透過支援車的方式來協助分配顧客點;
70         if(協助車為非加班車)
71           將顧客點x加到支援車的最佳位置上;
72         Else(協助車為加班車)
73           將顧客點x加到支援車尾端;
74       p=p+1;//尋找後續順位
75       Until p > P/P^+;
76       //--------------------------------加班車------------------------------------------------//
77       ν=1; o=1;
78       Repeat
79         Repeat
80           車輛 k 路徑 η _k 中選取需求量第 ν 大的顧客點 x ;
81           H_o(測試用路徑) = η_o;
82           將顧客點 x 加到測試用路徑 H_o 內並計算 H_o路徑內的 l_o，l_o= Σ q_i ;i ϵH_o ;
83           If(l_o>c*μ)
84             goto step 101; //跳到第101行繼續尋找其他顧客點的迴圈
85           Else{
86             計算 H_o 路徑的總耗時s_o= Σ𝜏_ij+Σ 𝜃_i, i ϵ H_o , j ϵH_o;
87             If(s_o>t)
88               goto step 101; //跳到第101行繼續尋找其他顧客點的迴圈
89             Else{
90               將顧客點 x 在 η _k 路徑中所在的第 m 個位置從 η _k 移除後連結第m-1個和第m+1個的顧客點;
91               將 x 加入到 η _o 的尾端;
92               將l_k減去q_x;
93               重新計算η_k路徑裡的s_k;
94               If(l_k>c*μ or s_k>t)
95                 ν=1;
96                 goto step 102; //跳到第102行繼續尋找其他顧客點的迴圈
97               Else goto step 106;//跳到第106行繼續下一個分區
98             }
99           } 
100          ν=ν+1;
101        Until ν <= Σ v^k_i,i ϵ N
102        o=o+1;
103      Until o > P^+;
104    End if
105    r=r+1;
106  Until r>R;
107}


1 Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、所有非加班車與加班車之集合K、非加班車的車輛數k_bar、車輛司機優先順序的集合P、加班車輛順位之集合P+、位在第r區的客戶點集合G_r、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k
2   //從第一分區開始分配
3   
4   r=1
5   Repeat
6     k=d_1^r;
7     將離場站(分區0)在分區 r 內最近的第一個顧客點x分配給第一優先順序的車輛路徑集合γ^r;
8     x=min{distance(x_0,N_0)}, x_0 in γ^r;
9     將離分區 r 質點最近的顧客 x 從集合γ ^r中取出並加入到車輛k路徑η_k的尾端;
10    將顧客點 x 的需求量q_x加到l_k;
11    將場站到顧客點 x 的旅行 𝜏_0x 和服務時間𝜃_x加到 s_k(s_k = 𝜏_0x+ 𝜃_x);
12    t=1;  
13    Repeat
14      將分區 r 內離第一個顧客點 x 最近的顧客點 y 從車輛路徑集合γ^r加入到η _k的尾端;
15      將顧客點 y 的需求量q_y加到l_k;
16      將顧客點 x 到顧客點 y 的旅行𝜏_xy和服務時間 𝜃_y 加到 s_k 裡(s_k = 𝜏_xy+ 𝜃_y);
17      t=t+1;x=y;
18    Until t>G_r;
19    r=r+1;
20  Until r>R;



1 Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、所有非加班車與加班車之集合K、車輛司機優先順序的集合P、加班車輛順位之集合P+、位在第r區的客戶點集合G_r、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k
2   //從第一分區開始檢查
3   r=1;
4   Repeat
5     //若車輛超過限制
6     if(l_k>c*μ or s_k>t)
7       p=2;
8       Repeat
9         選取分區 r 中離第 p 優先順序司機車輛 k’ 。 k’=d^p_r;
10        if(l_k’>c*μ or s_k’>t)
11          p=p+1;
12          goto step 49;//跳到第49行繼續選取其他順位的車輛的迴圈
13        Else(
14          ε=1;
15          Repeat
16            車輛 k 路徑η _k中選取離分區k’質心第 ε 近的顧客點 x;
17            H_k’(測試用路徑) = η_k’;
18            將顧客點需求量 q_x 加入測試用路徑 H_k’ 內並計算 H_k’路徑內的l_k’ ; l_k’= Σ q_i ;i ϵ H_k’;
19            if(l_k’>c*μ)
20              goto step 46;//跳到第46行繼續選取其他顧客點的迴圈
21            End if
22            //開始尋找最適合插入的位置
23            t=1; y_best=M;
24            Repeat
25              選取嘗試路徑 H_k’ 中顧客點;
26              y=v^k’_t 以及顧客點;
27              y’=v^k’_t+1 並計算;
28              y*=|yx|+|xy’-|yy’|;
29              if(y* < y_best)
30                y_best=y*;
31              Else y_best=y_best
32              t=t+1;
33            Until t > Σv^k’_i i ϵ H_k’;
34            將顧客點 x 加入到H_k’的y_best的位置，並計算 H_k’路徑的總耗時(s_k’=Σ𝜏_ij +Σ𝜃_i i ϵ H_k’ , j ϵ H_k’);
35            if(s_k’>t)
36              goto step 46;//跳到第46行繼續選取其他顧客點的迴圈
37            Else{
38              將顧客點 x 在η_k路徑中所在的第 m 個位置從η _k移除後連結第 m-1 個和第 m+1 個的顧客點將 x 加入到η_k’裡的y_best;
39              將l_k減去q_x;
40              重新計算η_k路徑裡的s_k;
41              if(l_k>c*μ or s_k>t)
42                ε=1;
43                goto step 68;//跳到第47行繼續選取其他顧客點的迴圈
44              Else goto step 55;//跳到第55行繼續下一個分區
45            }
46            ε=ε+1;//尋找其他顧客點
47          Until ε <= Σ v^k_i , i ϵ N ;//直到確認完所有顧客點
48        )
49      p=p+1;//尋找後續順位的非加班車
50      Until p > P/P^+;//直到後續順位的非加班車用完
51      if(l_k>c*μ or s_k>t)
52        加班車程序//第三PART;
53      End if
54    End if
55    r=r+1;//選取下個分區
56  Until r>R;//直到確認完所有分區
57Output : 車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k



1 Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、車輛司機優先順序的集合P、加班車輛順位之集合P+、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_o
2   //加班車程序
3   ν=1; o=1;
4   Repeat
5     Repeat
6       車輛 k 路徑 η _k 中選取需求量第 ν 大的顧客點 x ;
7       H_o(測試用路徑) = η_o;
8       將顧客點 x 加到測試用路徑 H_o 內並計算 H_o路徑內的 l_o，l_o= Σ q_i ;i ϵH_o ;
9       If(l_o>c*μ)
10        goto step 26; //跳到第26行繼續尋找其他顧客點的迴圈
11      Else{
12        計算 H_o 路徑的總耗時s_o= Σ𝜏_ij+Σ 𝜃_i, i ϵ H_o , j ϵH_o;
13        If(s_o>t)
14          goto step 26; //跳到第26行繼續尋找其他顧客點的迴圈
15        Else{
16          將顧客點 x 在 η _k 路徑中所在的第 m 個位置從 η _k 移除後連結第m-1個和第m+1個的顧客點;
17          將 x 加入到 η _o 的尾端;
18          將l_k減去q_x;
19          重新計算η_k路徑裡的s_k;
20          If(l_k>c*μ or s_k>t)
21            ν=1;
22            goto step 27; //跳到第27行繼續尋找其他顧客點的迴圈
23          End if
24        }
25      } 
26      ν=ν+1;//尋找其他顧客點
27    Until ν <= Σ v^k_i,i ϵ N //直到確認完所有顧客點
28    o=o+1;//尋找其他加班車
29  Until o > P^+;直到所有加班車用完
30Output : 車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k

//---------------------------------------------------------------------------------------------------------------------
Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、車輛司機優先順序的集合P、加班車輛順位之集合P+、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k1^t;
    //最後修正
    r=1 
    尋找每輛車k中不屬於該車輛所屬分區r之顧客並將其放在集合B中;
    b=|B|;
    Repeat 
        H_k1^t=η_k1;
        從集合B中需求量第a小的顧客點x開始放入第一優先順位車輛的測試車輛路徑H_k1^t;
        l_k1= Σ q_i ;i ϵH_k1^t;
        if(l_k1 > c*μ)
            goto step 35;
        Else(
            將顧客點x加入到H_k1^t;
            //開始尋找最適合插入的位置
            t=0; y_best=M;
            Repeat
                選取嘗試路徑H_k1^t中顧客點;
                y=H_k1^t 以及顧客點;
                y’=H_k1^t+1 並計算;
                y*=|yx|+|xy’-|yy’|;
                if(y* <y_best)
                    y_best=y*;
                Else y_best=y_best;
                t=t+1;
            Until t > H_k1^t;
            將顧客點 x 加入到H_k1^t的y_best的位置，並計算H_k1^t路徑的總耗時(s_k1=Στ_ij+Σθ_i i ϵH_k1^t , j ϵH_k1^t);
            if(s_k > t)
                goto step 35;
            Else(
                將顧客點x從η_k中的位置m中移除並連結m-1和m+1，加到η_k1的y_best位置;
                s_k = s_k1;
                l_k = l_k1;
            )
        )
        a=a+1;
    Until a>b;
Output : 車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k
//------------------------------------------------------------------------------------------------------------------------------


1 Input : 路網節點之集合N、路網邊之集合A、各分區區域代號之集合R、車輛司機優先順序的集合P、加班車輛順位之集合P+、服務第r區的第p順位司機參數d_p^r、每部貨車可容納最大材積c、車輛可允許容積的最大使用率μ、從點i到點j的旅行時間τ_ij ，∀(i,j)∈A、客戶i訂購貨品的總材積q_i，∀ i∈N、任一司機在客戶i所需停留的服務時間θ_i，∀i∈N_0、非加班車最大工時t、車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k、車輛k之測試用路徑H_k1^t;
2   //最後修正
3   r=1 
4   尋找每輛車k中不屬於該車輛所屬分區r之顧客並將其放在集合B中;
5   b=|B|;
6   Repeat 
7     H_k1^t=η_k1;
8     從集合B中需求量第a小的顧客點x開始放入第一優先順位車輛的測試車輛路徑H_k1^t;
9     l_k1= Σ q_i ;i ϵH_k1^t;
10    if(l_k1 > c*μ)
11      goto step 35;
12    Else(
13      將顧客點x加入到H_k1^t;
14      //開始尋找最適合插入的位置
15      t=0; y_best=M;
16      Repeat
17        選取嘗試路徑H_k1^t中顧客點;
18        y=H_k1^t 以及顧客點;
19        y’=H_k1^t+1 並計算;
20        y*=|yx|+|xy’-|yy’|;
21        if(y* <y_best)
22          y_best=y*;
23        Else y_best=y_best;
24        t=t+1;
25      Until t > H_k1^t;
26      將顧客點 x 加入到H_k1^t的y_best的位置，並計算H_k1^t路徑的總耗時(s_k1=Στ_ij+Σθ_i i ϵH_k1^t , j ϵH_k1^t);
27      if(s_k > t)
28        goto step 35;
29      Else(
30        將顧客點x從η_k中的位置m中移除並連結m-1和m+1，加到η_k1的y_best位置;
31        s_k = s_k1;
32        l_k = l_k1;
33      )
34    )
35    a=a+1;
36  Until a>b;
37Output : 車輛k的總載貨量l_k、車輛k的總時間s_k、車輛k之實際路徑η_k