分支定界演算法代碼c語言

❶ 用分支限界法，寫01背包問題！C語言版！急~~~~~~能不用結構體，盡量別用！

class Object{
friend int Knapsack(int *,int *,int,int,int *);
public :
int operator<=(Object a)const {return(d>=a.d);}
private:
int ID;
floa d;//單位重量價值
};

template <class Typew,class Typep> class Knap;
class bbnode{
friend Knap<int,int>;
friend int Knapsack （int *,int *,int,int,int *）;
private:
bbnode * parent;
bool LChild;
};
template<class Typew,class Typep>
class Heap Node{
friend Knap<Typep>;
public:
operator Typep ()const{return uprofit;}
private:
Typep uprofit,profit;//結點價值上界
Typew weight;//結點所相應的價值
int level;//結點所相應的重量
bbnode *ptr;//指向活結點在子集樹中相應結點的指針
}；
template<class Typew,class Typep>
class Knap{
friend Typep Knapsack(Typep *,Typew *,Typew,int,int *);
public:
Typep MaxKnapsack();
private:
MaxHeap<HeapNode<Typep,Typew>>* H;
Typep Bound(int i);
void AddLiveNode(Typep up,Typep cp,Typew cw ,bool ch,int level);
bbnode * E;//指向擴展結點的指針
Typew c;//背包容量
int n;//物品總數
Typew * w;//物品重量數組
Typep * p;//物品價值數組
Typew cw;//當前裝包重量
Typep cp;//當前裝包價值
int * bestx;//最優解
}；
上界函數：
template<class Typew,class Typep>
Typep Knap<Typew,Typep>::Bound(int i)
{//計算結點所相應價值的上界
Typew clef=c-cw;//剩餘容量
Typep b=cp;//價值上界
//以物品單位重量價值遞減次序裝剩餘容量
while(i<n&&w[i]<=cleft){
cleft-=w[i];
b+=p[i];
i++;
}
//裝填剩餘容量裝滿背包
if（i<=n）b+=p[i]/w[i] * clef;
return b;
}
函數AddLiveNode將一個新的活結點插入到子集樹和優先隊列中
template<class Typep,class Typew>
void Knap<Typep,Typew>::AddLiveNode(Typep up,Typep cp,Typew cw,bool ch,int lev)
{//將一個新的活結點插入到子集樹和最大堆H中
bbnode * b=new bbnode;
b->parent=E;
b->LChild=ch;
HeapNode<Typep,Typew>N;
N.uprofit=up;
N.profit=cp;
N.weight=cw;
N.level=lev;
N.ptr=b;
H->Insert(N);
}
template<class Typew,class Typep>
Typep Knap<Typew,Typep>::MaxKnapsack()
{//優先隊列式分支限界法，返回最大價值，bestx返回最優解
//定義最大堆的容量為1000
H=new MaxHeap<HeapNode<Typep,Typew>>(1000);
//為bestx分配存儲空間
bestx=new int[n+1];
//初始化
int i=1;
E=0;
cw=cp=0;
Typep bestp=0;//當前最優值
Typep up=Bound(1);//價值上界
//搜索子集空間樹
while(i!=n+1){
//非葉結點，檢查當前擴展結點的左兒子節點
Typew wt=cw+w[i];
if(wt<=c){//左兒子節點為可行結點
if(cp+p[i]>bestp)bestp=cp+p[i];
AddLiveNode(up,cp+p[i],cw+w[i],true,i+1);}
up=Bound(i+1);
//檢查當前擴展結點的右兒子節點
if(up>=bestp)//右子樹可能含最優解
AddLiveNode(up,cp,cw,false,i+1)
//曲下一個結點
HeapNode<Typep,Typew> N;
H->DeleteMax(N);
E=N.ptr;
cw=N.weight;
cp=N.profit;
up=N.uprofit;
i=N.level;
}
for ( int j=n;j>0;j-- )
{
bextx[j]=E->LChile;
E=E->parent;
}
return cp;
}

❷ 分別用隊列和優先順序隊列分支限界法解0—1背包問題

利用優先順序分支限界法設計0/1背包問題的演算法，掌握分支限界法的基本思想和演算法設計的基本步驟，注意其中結點優先順序的確定方法，要有利於找到最優解的啟發信息。

要求：設計0/1背包問題的分支限界演算法，利用c語言（c++語言）實現演算法，給出程序的正確運行結果。

注意：
1. 把物品按照單位體積的價值降序排列；
2. 構造優先順序分支限界法的狀態空間樹，共n層，第i層每個節點的兩個分支分別代表第i個物品的取和不取；
3. 節點上需要保存的值有：S代表已裝入背包的物品的總體積，V代表已裝入背包的物品的總價值，u代表當前節點的上界，計算公式如下：
u=V+（C-S）（vi+1/si+1）
其中C是背包的總容積，vi+1代表第i+1個物品的價值，si+1代表第i+1個物品的體積。
4. 選擇適當的數據結構（如最大堆，或者基本的線性數組）實現演算法，輸出最後結果。

❸ 特徵選擇 分支定界法

分支定界 (branch and bound) 演算法是一種在問題的解空間樹上搜索問題的解的方法.但與回溯演算法不同,分支定界演算法採用廣度優先或最小耗費優先的方法搜索解空間樹。

分枝界限法也能夠使用在混合整數規劃問題上，其為一種系統化的解法，以一般線性規劃之單形法解得最佳解後。

將非整數值之決策變數分割成為最接近的兩個整數，分列條件，加入原問題中，形成兩個子問題(或分枝)分別求解，如此便可求得目標函數值的上限（上界）或下限（下界），從其中尋得最佳解。

分支定界法演算法分析：

1、演算法優點：可以求得最優解、平均速度快。

因為從最小下界分支，每次算完限界後，把搜索樹上當前所有的葉子結點的限界進行比較，找出限界最小的結點，此結點即為下次分支的結點。這種決策的優點是檢查子問題較少，能較快的求得最佳解。

2、缺點：要存儲很多葉子結點的限界和對應的耗費矩陣。花費很多內存空間。

存在的問題：分支定界法可應用於大量組合優化問題。其關鍵技術在於各結點權值如何估計，可以說一個分支定界求解方法的效率基本上由值界方法決定，若界估計不好，在極端情況下將與窮舉搜索沒多大區別。

❹ 分支定界法 0-1多背包問題

的動態規劃0-1背包問題
/ ************************************* *********************************** /
/ * 0-1背包問題： /> / * n種物品和一個背包
/ *項目無線網路，我的體重VI的價值
/ *背包的容量為c
/ *應該如何選擇項目載入背包使物品裝入背包
/ *總最看重的嗎？
/ *註：選擇項目裝入背包的物品我只有兩個選擇
/ *載入或不裝入背包。我不能載入多個
/ *不能只是載入的項目。
/ *

/ * 1。 0-1背包問題的形式化描述：
/ * C> 0，無線網路> 0，六0，0 <= I <= N要求找到一個n
/ * 0-1向量（ X1，X2，...，XN），使得：
/ *最大sum_ {= 1到n}（ⅵ*ⅹⅰ），並滿足下面的約束：
/ *（1）sum_ {I = 1到n}（WI *十一）<= C

/ *（2）十一∈{0，1} 1 <= I <= N
/ * ...... / a>
/ * 2。
/ * 0-1背包問題0-1背包問題的解決有重疊的性質的最優子結構性質和子適合
/ *使用動態規劃方法解決
/

/ * 2.1最優子結構性質
/ *設置（Y1，Y2，...，yn）的0-1背包問題，最佳的解決方案，它肯定
> / *結論（Y2，Y3，...，yn）的是下面的子問題的最優解：
/ *最大sum_ {i = 2到n}（VI *十一）
/ *（1）sum_ {i = 2到N}（WI *十一）<= C - W1 * Y1
/ *（2）十一∈{0，1}，2 <= I <= N /> / *否則，子問題有一個最優的解決方案（Z2，Z3，...，zn的），
/ *（Y2，Y3，...，yn）的比的最優解。然後：
/ * sum_ {i = 2到n}（VI *子）sum_ {i = 2到n}（VI *易）
/ *，W1 * Y1 + sum_ {i = 2到n}（WI *子）<= C
/ *進一步指出：
/ * V1 * Y1 + sum_ {i = 2到n}（VI *子）> sum_ {i = 1 N}（VI *易）
/ * W1 * Y1 + sum_ {i = 2到n}（無線ZI）<= C
/ *這說明：（Y1，Z2，Z3， ，...，ZN）0-1背包問題是一個更好的解決方案，然後
/ *說明（Y1，Y2，...，yn）的是不矛盾的前提下，最佳的解決方案，因此，最好
/ *建立的子結構的性質。
/ *
/ * 2.2子重疊性質
/ *設置給定的0-1背包問題的子P（I，J）：
/ *最大sum_ {K = I N}（VK * XK）
/ *（1）sum_ {K = I為n}（周* XK）<= J
/ *（2）XK∈{0，1}， I <= K <= N

/ * P（I，J）的問題是背包容量為j，可選的項目我，我+1，...，n的子的問題
/ *設M（I，J）是子P（I，J），最大總價值的最優值。在最佳
/ *子結構的性質可以創建遞歸米的（I，J）：
/ *。遞歸的初始M（N，J）
/ * / /背包容量為j，可選的項目只有n，，如果背包容量j是大於項目?
/ / /重量直接載入;無法載入。
/ * M（N，J）= VN，J> = WN
/ * M（N，J）= 0，0 <= J <WN
/ * B。遞推公式M（I，J）
/ * / /背包容量?，可選的項目我，我+1，...，N
/ * / /背包容量J <無線網路，後來乾脆不安裝成的文章：
/ * M（I，J）= M（I +1，J），0 <= j的無線
/ * / / J> =無線網路，文章中，我載入的項目之間我選擇
/ *沒有我的最佳值：M（i +1，j）的安裝項目
/ *載入項，我的最優值：M（i +1， J-WI）+ VI

/ *：
/ * M（I，J）= {M（I +1，J），M（I +1，J-無線）+ VI}，J> =無線
/ *
/ ***************************** ******************************************* /
/>

定義MAX（A，B）（（（一）（二））（A）（B））
定義分（A，B）（ （（A）（B））（A）（B））
模板
無效背包（類型* V，INT * W，C，N，類型* * M）
{
/ /遞歸的初始條件
詮釋JMAX = MIN（W [N] - 1，C）;
（J = 0;? <= JMAX J + +）{
米[N] [J] = 0;
}

（J = W [N]; <= C; J + +）{
M [N] [J] = V [N];
}

/ /我從2到n-1，分別為j> = wi和0 <= j的無線M（I，J）
（INT I = N-1; i> 1的，我 - ）{
JMAX = MIN（W [我] - 1，C）;
（J = 0; <= JMAX; J + +）{
M [] [J] = M [+1] [J]; ...... />}
為（J = W [I]; <= C; + +）{
M [] [J] = MAX（M [+1] [J]， M [+1] [JW [我] + V [I]）;
}
}

M [1] [C] = M [2] [ C];
（C> = W [1]）{
M [1] [C] = MAX（M [1] [C]，M [2] [CW [1]] + V [1]）;
}

}

模板
無效回溯（類型**米，INT * W， INT整數N，C，* X）
{
為（int i = 1; <N，我+ +）{
（M [] [C] == M [+1] [C]）×[I] = 0;
其他{
×[我] = 1;
C - = W [I];
}
}
×[N] =（M [N] [C]）？ 1:0;
}

：（INT ARGC，字元*的argv []）
{
廉政n = 5;
>詮釋W [6] = {-1，2，2，6，5，4};
INT V [6] = {-1，6，3，5，4，6};
>詮釋C = 10;

** ppm =百新詮釋[N +1];
（INT I = 0; I <N +1，我+ +）{
PPM [] =新的int [C +1];
}

詮釋x [6];

背包的（V ，W，C，N，PPM）;
：回溯的（ppm時，W，C，N，X）;

返回0;}

貪心演算法求解0-1背包問題
的基本思路？貪婪的方法：
逐漸接近目標，給予盡可能快地獲得一個更好的解決方案在地上 - 從最初的解決方案的問題。當達到一個演算法的步驟不能繼續向前走，演算法停止。
的演算法問題：
1）不能保證獲得最終的解決方案;
2）不能被用來謀求最大或最小解決方案;
3）尋求滿足一定的約束條件，可行的解決方案。

演算法：
開始從最初的解決方案的問題;

獲得可行的解決方案提出了總體目標，而移動元素的解決方案;
所有解決方案組件組合成一個可行的解決方案的問題;
2實例分析

1）。背包問題，背包，背包容量是M = 150。 7物品時，物品可分為任意的尺寸。的
要求盡可能多，以使總價值的物品裝入背包，但不能超過總容量。

的項ABCDEFG
權重值35 30 60 50 40 10 25
10 40 30 50 35 40 30

：
目標函數： σpi，
約束裝入的物品的總重量計不超過背包容量：Σwi<= M（M = 150）
（1）根據貪心策略，每個選定的值最大的裝載物品的背包，得到的結果是最優的？
（2）每次選擇負載最小的項目可以得到最佳的解決方案嗎？
（3）每次你選擇一個單位容量的最有價值的項目，解決這個問題的戰略。

（環境：C + +）
包括與ltiostream.h的>
＃定義最大100 / /最大數量的項目
無效排序（N，飄起了[MAX]，持股量B [MAX]）/ /密度值的排序
{
整數J，H，和K;
持股量T1，T2， T3，C [MAX];
（k = 1時，K <= N，K + +）
?[K] = [K] / B [K]
（H = 1，H <N，H + +）
（J = 1，J <= NH J + +）
（C [J] C [j +1]中）
{T1 = A [J]，A [J] = A [j +1]中的[J +1] = T1;
T2 = B [J]; B [J] = B [j +1]中，B [J +1] = T2;
T3 = C [J] C [J] = C [j +1]中，C [J +1] = T3;
>}
}
無效背包（INT N，持股量limitw，浮動V [MAX]，浮瓦特[MAX]，詮釋x [MAX]）
{浮動C1 / / C1背包剩餘的負載重量
我
排序（N，V，W）/ /排序價值密度的
C1 = limitw
為（i = 1我=我+ +）
{
（W [I]> C1）打破;
×[我] = 1; / / x [我]的文章我了解
C1 = C1-W [I];
}
}
無效的主要（）
{N，I，X [MAX];
>浮法V [MAX]，W [MAX]，totalv = 0，totalw = 0，limitw;
法院<<「請輸入n和limitw：」
CIN >> N >> limitw
為（i = 1; <=我+ +）
×[我] = 0; / /初始化為0的產品選擇表
法院<<「請進入價值的項目依次：「<< endl;
（i = 1; <=我+ +）
CIN >> V [I];
法院<; <endl;
法院<<「請輸入的重量反過來的項目：」<< endl;
（i = 1; <= N; + +）
CIN >> W [I];
法院<< endl;
背包（N，limitw，V，W，X）;
法院<<「選擇的是：」
>（i = 1; <= N; + +）
{
法院<< X [I];
（X [I] == 1） totalw = totalw + W [I];
}
法院<< endl;
法院<<「總重量的背包：<<totalw << endl; / /背包裝載總重量
法院<<「總價值的背包為：的」「totalv << endl; / /背包的總價值
}
三回溯演算法0 -1背包問題
1.0-l背包問題是選定的子集的問題。
一般,0-1背包問題是NP-難的。
0-1背包解決方案的可用空間的一個子集樹。
喜歡回溯0-1背包問題裝載問題的回溯是非常一流。搜索解空間樹的搜索，只要其左子節點是一個可行的節點，進入其左子樹。
右子樹可能只包含右子樹搜索的最佳解決方案，否則，切右子樹。設r其餘
商品的價值的總和;陰極保護電流值;當前最優值bestp。
子樹可以削權當CP + R≤bestp。在右子樹的上限解的計算是更好的方法，其餘項目根據其單位重量排序的值
然後在打開載入項直到合適的，然後到的文章充滿背包。得到的值是上限
右子樹的解決方案。
2。解決方案的想法：
為了便於計算中上的第一個項目，每單位重量的約束根據降序自己的價值，並此後，只要測試的順序
可以觀察到的各種物品。在實現綁定在當前節點的上限計算。搜索解決方案空間樹，只要其左子節點是一個可行的節點，搜索到的左子樹，右子樹可能含有進入右子樹搜索的最佳解決方案之前，否則，切右子樹。

回溯跳躍系統的搜索演算法。它包含了所有問題的解空間樹的解決方案，根據深度優先的策略，開始從根本上搜索解空間樹。總是首先確定節點的解決方案不包含樹演算法搜索的解空間中的任何節點。當然不包含跳層和它的祖先節點的節點是根的子樹的搜索回溯系統，否則，進入子樹，繼續深入搜索優先策略。回溯所有使用的解決方案，提出了一個問題，我們必須回頭去根，根的子樹搜索，直到結束。回溯，用乞求的問題，任何一個解決方案，只要搜索一個解決問題的辦法可以結束了。被稱為回溯的深度優先搜索演算法的問題的解決方案，它適用於了解一些大量的組合。
2。演算法框架： BR />問題的解空間：應用回溯法解決問題，首先應該明確的定義問題的解決空間問題的解空間中至少包含一個（最佳）的解決方案。
B。回溯基本思想是：以確定的組織結構對空間的理解，回溯從開始節點（根），深度優先搜索整個解空間的起始節點成為一個活結點，也是當前擴展節點。在當前的擴展結中，搜索到的深度方向移動到一個新的節點。新的節點是一個新的活結點，和目前的擴張節點，如果當前的交界處延長不能進一步移動，在深度方向上，那麼當前的擴展結點死鎖。換言之，此節點不再是一個活結點，在這一點上，應該向後移動（回溯）指向一個活結活結擴展節點停止回溯這樣的遞歸地搜索解空間中工作，直到你找到解決方案或解決方案所需的空間活結點。
3。用回溯法解決問題通常是由以下三個步驟：
解決方案的空間一個給定的問題，定義問題;
B。確定易於搜索的解空間結構;
C。深度優先的方式搜索解空間，並在搜索過程中通過修剪功能，以避免無效搜索;
＃包括

使用命名空間std;

類雷德克納普
{
朋友整數背包（P []，詮釋W []，詮釋三，廉政n）;

：
無效的print（）
{

（M = 1，M <= N，M + +）
{
法院<< bestx [M] <<「」;
}
法院<< endl;
};

私人如下：
整數約束（int i）的;
無效回溯（int i）的;

詮釋三;/ /背包容量
廉政n，/ /項目數
詮釋* W / /菜單項權重數組
詮釋* p ;/ /項目值的數組
詮釋CW ;/ /重量
INT CP ;/ /電流值

詮釋bestp ;/ /當前的最優值
詮釋* bestx ;/ /當前最優解
詮釋*

}

詮釋雷德克納普::綁定（一）
{
/ /計算x ;/ /當前的解決方案上限
詮釋裂= C-CW ;/ /剩餘容量
INT B = CP;
/ /項目單位重量價值遞減的序列載入項
（I <= N &&瓦特[I] <=裂）
{
裂= W [I]
B + = [];
+ +;
>}
/ /填充背包
如果（i <= N）
B + = [I] / W [I] *裂;
回報B; ...... />}

無效雷德克納普::回溯（一）
{
如果（I>）
{
（ bestp <CP）
{
（J = 1; <= N; + +）
bestx [J] = [J]。
bestp = CP
}
回報;
}
（CW + W [I] <= C）/ /搜索左子樹
{
×[我] = 1;
CW + = W [I];
CP + = [];
回溯 - 觸控板（i +1）;
CW - = W [I];
CP-= P [I];
}
如果「（綁定（i +1）> bestp）/ /搜索右子樹
{ BR /> x [I] = 0;
回溯 - 觸控板（i +1）;
}

}

>類對象
{
朋友整數背包（P []，詮釋W []，詮釋三，廉政n）;

內部操作符<=（對象A ）常量
{
回報率（D> =廣告）;
}

私人如下：
整數ID;
浮動D; />};

整數背包（P []，詮釋W []，詮釋三，廉政n）
{
/ /為雷德克納普： ：Backtrack面板 - 觸控板初始化
詮釋W = 0;
詮釋P = 0;
INT I = 1;
對象* Q =新的對象[N]; / a>（I = 1; <=我+ +）
{
Q [I-1]。ID =我;
Q [I-1]，D = 1.0 * P [I] / W [I];
P + = [];
W + = W [I];
}
（W <= C）
回報P ;/ /載入的所有項目
/ /按產品單位重量排序
浮F;
為（i = 0; I <N;我+ +）
（整數J = I，J <N; J + +）
{
（Q [I]，D <Q [J]。四）
{ BR /> F = Q [I]，D;
Q [我]，D = Q [J]。天;
Q [J]。D = F;
}
a>

}

雷德克納普K;
KP =新的int [N +1];
KW =新的int [N +1];
KX = INT [N +1];
K.bestx =新的int [N +1];
KX [0] = 0;
K.bestx [0 ] = 0;
為（i = 1; <= N; + +）
{
KP [I] = P [Q [I-1]。ID]; BR /> KW [我] = W [Q [I-1]。ID];
}
K.cp = 0;
K.cw = 0;
KC = C;
KN = N;
K.bestp = 0;
/ /回溯搜索
K.Backtrack（）;
K.print的（）
刪除[] Q;
刪除[]千瓦;
刪除[] KP;
回報K.bestp;

}

無效的主要（）
{
* P;
* W;
整數C = 0;
廉政n = 0;
> INT I = 0;
字元K表;
法院<<「0-1背包問題 - 回溯」<< endl;
法院<<「通過zbqplayer <而（K）
{
法院<<「請輸入一個背包容量（C）：」<< endl;
CIN >> C;
法院<<「請輸入的項目數（n）：「<< endl;
CIN >> N
P =新的int [N +1];
W =新的int [ +1];
P [0] = 0;
W [0] = 0;

法院<<「請輸入一個值（P）的項目： << endl;
（i = 1; <= N; + +）
CIN >> P [I];

法院<<「請輸入項目的重量（W）：「<< endl;
為（i = 1; <=我+ +）
CIN >> W [I]
BR />法院<<「最佳的解決方案（bestx）：」<< endl;
法院<<「最佳的值（bestp）：」<< endl;
的cout <<背負的（P， W，C，N）<< endl;
法院<<「[S]重新啟動」<< endl;
法院<<「[q]退出」<< endl; BR /> CIN >> K
}
四個分支定界法求解0-1背包問題
問題描述：已知的N項和一個背包可以容納M個權重，權重我的體重，只認沽或不投入，解決如何把在背包中的物品的總收益的項目，可以使每一個項目。
2。設計的思考和分析：選擇的項目，或不構成解決方案樹，左子樹不載入，正確的說，節點負載，以獲得最佳的樹檢索問題的解決辦法謝界殺不符合要求的節點。

包括

結構良好
{
詮釋權重;
詮釋的利益;
INT標志;/ /是否載入標簽
};

整型數= 0 ;/ /項目數
詮釋upbound = 0;
詮釋curp = 0，curw = 0 ;/ /當前實際價值和重量
詮釋maxweight = 0;
好包= NULL;

的虛空Init_good（）{
>袋=新好[數字];

（INT I = 0;我數，我+ +）
{
法院<<「請輸入第一塊「。 ;「<< i +1 <<」重的項目：「
CIN >>袋[i]的重量;
法院<<」請輸入片「<< i +1 << 「項目的好處：」
CIN >>袋[I]。利益;
袋[I]。標志= 0 ;/ /初始標志沒有被裝入背包
法院<< endl;
}

}

詮釋getbound（整數民， * bound_u）/ /返回節點c計和壓力表ü
{
（瓦特= curw，P = curp，民數&&（W +包[NUM]重量）<= maxweight NUM + +）
{
W = W +包[NUM]。重量;
P = W +包[NUM]。效益;
}

* bound_u = P +包[NUM]。 ，效益;
回報（P +包[NUM]。利益（（maxweight-W）/袋[NUM]。重量））;
}

無效LCbag（）
{
bound_u = 0，bound_c = 0 ;/ /當前節點c方向和u和約束

（i = 0;號碼;我+ +層）/ /層穿越解決方案，樹，以決定是否載入不同的項目
{（I +1，及bound_u））>
（（bound_c =的getbound upbound）/ /遍歷左子樹
upbound = bound_u ;/ /改變有U計不會改變的標志
如果「（getbound（I＆bound_u）> bound_c）/ /遍歷右子樹
/ /如果載入，以確定是否大於左子樹的根的右子樹C標尺C標尺負載
{的
upbound = bound_u ;/ /變化有u和約束
curp = curp +包[I]。利益的
curw = curw +包[i]的重量;/ /重量和效益從現有再加上新的項目
袋[I]。標志= 1; / /標記載入
}

}

}

顯示（）
{
/> COUT <<「項目可放置在背包里數：」;
（INT I = 0;我數，我+ +）
（袋[I]。標志> 0 ）
法院<< i +1 <<「」;
法院<< endl;
刪除[]袋;
}