zoukankan      html  css  js  c++  java

  • C++排序算法总结

    【1】插入排序：

    是一个对少量元素进行排序的有效算法。实现比较简单。时间复杂度：O(n^2)，空间复杂度：O(1)。是稳定的排序方法。

    代码：

    [cpp] view plaincopyprint?
    1. //insertion sort 
    2. #include <iostream> 
    3. using namespace std; 
    4.  
    5. //insertion sort 
    6. void InsertionSort(int *a,int n) 
    7. { 
    8.     int temp; 
    9.     for(int i = 1;i < n;++i) 
    10.     { 
    11.         temp = *(a + i); 
    12.         int j = i - 1; 
    13.         while(j >= 0 && *(a + j) > temp) 
    14.         { 
    15.             *(a + j + 1) = *(a + j); 
    16.             --j; 
    17.         } 
    18.         *(a + j + 1) = temp; 
    19.     } 
    20. } 
    21.  
    22. int main() 
    23. { 
    24.     int n,temp; 
    25.     cout<<"please input the number of the values that need to sort:"<<endl; 
    26.     cin>>n; 
    27.     int *a = (int*)malloc(n *sizeof(int)); 
    28.     cout<<"please input each value:"<<endl; 
    29.     for(int i = 0;i < n;++i) 
    30.     { 
    31.         cin>>temp; 
    32.         *(a + i) = temp; 
    33.     } 
    34.     /*
    35.     //insertion sort
    36.     for(int i = 1;i < n;++i)
    37.     {
    38.         temp = *(a + i);
    39.         int j = i - 1;
    40.         while(j >= 0 && *(a + j) > temp)
    41.         {
    42.             *(a + j + 1) = *(a + j);
    43.             --j;
    44.         }
    45.         *(a + j + 1) = temp;
    46.     }*/ 
    47.     InsertionSort(a,n); 
    48.  
    49.     cout<<"the values after sort:"<<endl; 
    50.     for(int i = 0;i < n;++i) 
    51.         cout<<*(a + i)<<" "; 
     
    1. free(a); 
     
    1. } 

    数据测试：


    上述代码可以改进的一个地方是：在查找插入位置的时候可以采用二分查找，但是这样依然不可以把时间复杂度降低为O(nlogn)，因为移动元素的复杂度没有降低。所以时间复杂度仍然是O(n^2)。

    做此改进需要添加函数InsertLoc用于二分查找需要插入的位置，以及修改函数InsertionSort的实现。具体如下：

    [cpp] view plaincopyprint?
    1. //改进：用二分查找来找到插入的位置 
    2. //在数组a[low]---a[high]查找val插入的位置 
    3. int InsertLoc(int *a,int low,int high,int val) 
    4. { 
    5.     if(low == high) 
    6.     { 
    7.         if(val > *(a + low))return (low + 1); 
    8.         else 
    9.             return low; 
    10.     } 
    11.     int mid = (low + high) / 2; 
    12.     if(val > *(a + mid) && val > *(a + mid + 1)) 
    13.         return InsertLoc(a,mid + 1,high,val); 
    14.     else if(val < *(a + mid) && val < *(a + mid + 1)) 
    15.         return InsertLoc(a,low,mid,val); 
    16.     else 
    17.         return mid; 
    18. } 
    19.  
    20. void InsertionSort(int *a,int n) 
    21. { 
    22.     int temp,insert_location; 
    23.     for(int i = 1;i < n;++i) 
    24.     { 
    25.         temp = *(a + i); 
    26.         int j = i - 1; 
    27.         insert_location = InsertLoc(a,0,j,temp); 
    28.         cout<<"insert_location:"<<insert_location<<endl; 
    29.         while(j >= insert_location) 
    30.         { 
    31.             *(a + j + 1) = *(a + j); 
    32.             --j; 
    33.         } 
    34.         *(a + insert_location) = temp; 
    35.         for(int m = 0;m <= i;++m) 
    36.             cout<<*(a + m)<<" "; 
    37.         cout<<endl; 
    38.     } 
    39. } 

    【2】选择排序

    第一次找出A[0,...,n-1]的最小的元素，与A[0]交换，接着，找出A[1,...,n-1]的次小得元素，与A[1]互换。对A中头n-1个元素执行这一过程。时间复杂度：O(n^2)，空间复杂度O(1)。是不稳定的排序方法。比如序列5 8 5 2 9，第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序是不稳定的排序算法。

    但是严蔚敏的《数据结构》书上面Page289页说，所有时间复杂度为O(n^2)的简单排序都是稳定的。不知道为什么？求指导~~

    其给出的简单排序的伪代码：

    [cpp] view plaincopyprint?
    1. void SelectSort(SqList &L) 
    2. { 
    3.     //对顺序表L做简单排序 
    4.     for(i = 1;i < L.length;++i)//选择第i小得记录，并交换到位 
    5.     { 
    6.         j = SelectMinKey(L,i);//在L.r[i..L.length]中选择key最小的记录 
    7.         if(i != j)//与第i个记录交换 
    8.         { 
    9.             temp = L.r[i]; 
    10.             L.r[i] = L.r[j]; 
    11.             L.r[j] = temp; 
    12.         } 
    13.     } 
    14. } 

    代码：

    [cpp] view plaincopyprint?
    1. //选择排序 
    2. #include <iostream> 
    3. using namespace std; 
    4.  
    5. void ChoseSort(int* a,int n) 
    6. { 
    7.     int temp,minVal,minIndex; 
    8.     for(int i = 0;i < n - 1;++i) 
    9.     { 
    10.         minVal = *(a + i);//记录a[i,...,n-1]之间的最小值 
    11.         minIndex = i;//记录a[i,...,n-1]之间的最小值的下标 
    12.         for(int j = i + 1;j < n;++j) 
    13.         { 
    14.             if(minVal > *(a + j)) 
    15.             { 
    16.                 minVal = *(a + j); 
    17.                 minIndex = j; 
    18.             } 
    19.         } 
    20.         //交换a[i]和a[i,...,n-1]之间的最小值最小值 
    21.         if(minIndex != i) 
    22.         { 
    23.             temp = *(a + i); 
    24.             *(a + i) = *(a + minIndex); 
    25.             *(a + minIndex) = temp; 
    26.         } 
    27.     } 
    28. } 
    29.  
    30. int main() 
    31. { 
    32.     int n,temp; 
    33.     cout<<"please input the number of the values that need to sort:"<<endl; 
    34.     cin>>n; 
    35.     int *a = (int*)malloc(n *sizeof(int)); 
    36.     cout<<"please input each value:"<<endl; 
    37.     for(int i = 0;i < n;++i) 
    38.     { 
    39.         cin>>temp; 
    40.         *(a + i) = temp; 
    41.     } 
    42.     ChoseSort(a,n); 
    43.     cout<<"the values after sort:"<<endl; 
    44.     for(int i = 0;i < n;++i) 
    45.         cout<<*(a + i)<<" "; 
    46.     free(a); 
    47. } 

    【3】合并排序

    采用分治法。将n个元素分成各含n/2个元素的子序列，用合并排序法对两个子序列递归的排序(子序列长度为1时递归结束)，最后合并两个已排序的子序列得到结果。时间复杂度：O(nlogn)，空间复杂度：O(n)。是稳定的排序方法。

    代码：

    [cpp] view plaincopyprint?
    1. //合并排序 
    2. #include <iostream> 
    3. using namespace std; 
    4.  
    5. #define MAX_VALUE 100000//用于设置哨兵，避免检查是否每一个堆都是空的 
    6.  
    7. //合并两个子数组的函数 
    8. void Merge(int *a,int p,int q,int r) 
    9. { 
    10.     int num1,num2; 
    11.     num1 = q - p + 1; 
    12.     num2 = r - q; 
    13.     int *a1 = (int*)malloc((num1 + 1) *sizeof(int)); 
    14.     int *a2 = (int*)malloc((num2 + 1) *sizeof(int)); 
    15.     for(int i = 0;i < num1;++i) 
    16.         *(a1 + i) = *(a + p + i); 
    17.     *(a1 + num1) = MAX_VALUE;//设置哨兵元素 
    18.     for(int i = 0;i < num2;++i) 
    19.         *(a2 + i) = *(a + q + 1 + i); 
    20.     *(a2 + num2) = MAX_VALUE;//设置哨兵元素 
    21.      
    22.     //进行排序 
    23.     int index1 = 0; 
    24.     int index2 = 0; 
    25.     for(int i = p;i <= r;++i) 
    26.     { 
    27.         if(*(a1 + index1) < *(a2 + index2)) 
    28.         { 
    29.             *(a + i) = *(a1 + index1); 
    30.             ++index1; 
    31.         } 
    32.         else 
    33.         { 
    34.             *(a + i) = *(a2 + index2); 
    35.             ++index2; 
    36.         } 
    37.     } 
    38.     free(a1); 
     
    1. free(a2); 
     
    1. } 
    [cpp] view plaincopyprint?
    1. //递归合并排序算法 
    2. void MergeSort(int *a,int p,int r) 
    3. { 
    4.     if(p < r) 
    5.     { 
    6.         int q = (p + r) / 2; 
    7.         MergeSort(a,p,q); 
    8.         MergeSort(a,q + 1,r); 
    9.         Merge(a,p,q,r); 
    10.     } 
    11. } 
    12.  
    13. int main() 
    14. { 
    15.     int n,temp; 
    16.     cout<<"please input the number of the values that need to sort:"<<endl; 
    17.     cin>>n; 
    18.     int *a = (int*)malloc(n *sizeof(int)); 
    19.     cout<<"please input each value:"<<endl; 
    20.     for(int i = 0;i < n;++i) 
    21.     { 
    22.         cin>>temp; 
    23.         *(a + i) = temp; 
    24.     } 
    25.     MergeSort(a,0,n - 1); 
    26.     cout<<"the values after sort:"<<endl; 
    27.     for(int i = 0;i < n;++i) 
    28.         cout<<*(a + i)<<" "; 
    29.     free(a); 
     
    1. } 

    如果不使用哨兵元素，需要修改Merge函数，如下：

    [cpp] view plaincopyprint?
    1. //合并两个子数组的函数(不使用哨兵元素) 
    2. void Merge(int *a,int p,int q,int r) 
    3. { 
    4.     int num1,num2; 
    5.     num1 = q - p + 1; 
    6.     num2 = r - q; 
    7.     int *a1 = (int*)malloc(num1 *sizeof(int)); 
    8.     int *a2 = (int*)malloc(num2 *sizeof(int)); 
    9.     for(int i = 0;i < num1;++i) 
    10.         *(a1 + i) = *(a + p + i); 
    11.     for(int i = 0;i < num2;++i) 
    12.         *(a2 + i) = *(a + q + 1 + i); 
    13.      
    14.     //进行排序 
    15.     int index1 = 0; 
    16.     int index2 = 0; 
    17.     int index = p; 
    18.     while(index1 < num1 && index2 <num2) 
    19.     { 
    20.         if(*(a1 + index1) < *(a2 + index2)) 
    21.         { 
    22.             *(a + index) = *(a1 + index1); 
    23.             ++index; 
    24.             ++index1; 
    25.         } 
    26.         else{ 
    27.             *(a + index) = *(a2 + index2); 
    28.             ++index; 
    29.             ++index2; 
    30.         } 
    31.     } 
    32.     while(index1 < num1) 
    33.     { 
    34.         *(a + index) = *(a1 + index1); 
    35.         ++index; 
    36.         ++index1; 
    37.     } 
    38.     while(index2 < num2) 
    39.     { 
    40.         *(a + index) = *(a2 + index2); 
    41.         ++index; 
    42.         ++index2; 
    43.     } 
    44.     free(a1);<pre class="cpp" name="code">  free(a2);</pre> 
    45. <pre></pre> 
    46. <pre class="cpp" name="code">}</pre> 
    47. <p><span style="color: rgb(255, 0, 0); font-family: KaiTi_GB2312; font-size: 24px;"><strong>【4】冒泡排序</strong></span></p> 
    48. <p>每一趟都比较相邻两个元素，若是逆序的，则交换。结束的条件应该是“在一趟排序过程中没有进行过交换元素的操作”。时间复杂度：O(n^2)，空间复杂度O(1)。是稳定的排序。</p> 
    49. <pre class="cpp" name="code">#include <iostream> 
    50. using namespace std; 
    51.  
    52. void BubbleSort(int *a,int n) 
    53. { 
    54.     int flag,temp;//标记是否进行过交换操作 
    55.     for(int i = 0;i < n - 1;++i) 
    56.     { 
    57.         flag = 0; 
    58.         for(int j = 0;j < n - 1 - i;++j) 
    59.         { 
    60.             if(*(a + j) > *(a + j + 1)) 
    61.             { 
    62.                 temp = *(a + j); 
    63.                  *(a + j) =  *(a + j + 1); 
    64.                  *(a + j + 1) = temp; 
    65.                  flag = 1; 
    66.             } 
    67.         } 
    68.         if(flag == 0)break; 
    69.     } 
    70. } 
    71.  
    72. int main() 
    73. { 
    74.     int n,temp; 
    75.     cout<<"please input the number of the values that need to sort:"<<endl; 
    76.     cin>>n; 
    77.     int *a = (int*)malloc(n *sizeof(int)); 
    78.     cout<<"please input each value:"<<endl; 
    79.     for(int i = 0;i < n;++i) 
    80.     { 
    81.         cin>>temp; 
    82.         *(a + i) = temp; 
    83.     } 
    84.     BubbleSort(a,n); 
    85.     cout<<"the values after sort:"<<endl; 
    86.     for(int i = 0;i < n;++i) 
    87.         cout<<*(a + i)<<" "; 
    88. <pre class="cpp" name="code">   free(a);</pre> 
    89. <pre></pre> 
    90. <pre class="cpp" name="code">}</pre> 
    91. <p><span style="color: rgb(255, 0, 0); font-family: KaiTi_GB2312; font-size: 24px;"><strong>【5】快速排序</strong></span></p> 
    92. <p>它是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将待排序元素分成两个部分，其中一部分元素比另一部分元素小。再分别对这两部分元素进行排序。以达到整个元素序列有序。时间复杂度：O(nlogn)，空间复杂度O(logn)，是不稳定的算法。</p> 
    93. <p>代码：</p> 
    94. <pre class="cpp" name="code">#include <iostream> 
    95. using namespace std; 
    96.  
    97. int Partition(int *a,int low,int high) 
    98. { 
    99.     int PivotKey = *(a + low);//用第一个元素做枢轴 
    100.     while(low < high) 
    101.     { 
    102.         while(low < high && *(a + high) > PivotKey)--high; 
    103.         *(a + low) = *(a + high); 
    104.         while(low < high && *(a + low) < PivotKey)++low; 
    105.         *(a + high) = *(a + low); 
    106.     } 
    107.     *(a + low) = PivotKey; 
    108.     return low; 
    109. } 
    110.  
    111. void QuickSort(int *a,int low,int high) 
    112. { 
    113.     if(low < high) 
    114.     { 
    115.         int PivotLoc = Partition(a,low,high); 
    116.         QuickSort(a,low,PivotLoc - 1); 
    117.         QuickSort(a,PivotLoc + 1,high); 
    118.     } 
    119. } 
    120.  
    121. int main() 
    122. { 
    123.     int n,temp; 
    124.     cout<<"please input the number of the values that need to sort:"<<endl; 
    125.     cin>>n; 
    126.     int *a = (int*)malloc(n *sizeof(int)); 
    127.     cout<<"please input each value:"<<endl; 
    128.     for(int i = 0;i < n;++i) 
    129.     { 
    130.         cin>>temp; 
    131.         *(a + i) = temp; 
    132.     } 
    133.     QuickSort(a,0,n - 1); 
    134.     cout<<"the values after sort:"<<endl; 
    135.     for(int i = 0;i < n;++i) 
    136.         cout<<*(a + i)<<" "; 
    137.     free(a);}</pre> 
    138. <p><br> 
    139. </p> 
    140. <p><span style="color: rgb(255, 0, 0); font-family: KaiTi_GB2312; font-size: 24px;"><strong>【6】计数排序</strong></span></p> 
    141. <p>计数排序的思想是对每一个输入元素x，确定出小于x的元素的个数。然后我们就可以直接把它放在嘴中输出数组中相应的位置上。</p> 
    142. <p>但是计数排序基于这样一个假设：n个输入元素的每一个大小范围都是[0,k]。</p> 
    143. <p>代码：</p> 
    144. <p><pre class="cpp" name="code">#include <iostream> 
    145. using namespace std; 
    146.  
    147. //Counting Sort Algorithm 
    148. //A:array before sorting 
    149. //B:array after sorting 
    150. //n:the number of A 
    151. //k:all the elements is in [0,k] 
    152. void CountintSort(int A[],int *B,int n,int k,int *C) 
    153. { 
    154.     //初始化C数组 
    155.     for (int i = 0;i <= k;++i) 
    156.     { 
    157.         C[i] = 0; 
    158.     } 
    159.  
    160.     for (int i = 0;i < n;++i) 
    161.     { 
    162.         ++C[A[i]];//C[i]：值等于i的元素的个数 
    163.     } 
    164.  
    165.     for (int i = 1;i <= k;++i) 
    166.     { 
    167.         C[i] += C[i - 1];//C[i]：值小于等于i的元素的个数 
    168.     } 
    169.      
    170.     for (int i = n - 1;i >= 0;--i) 
    171.     { 
    172.         B[C[A[i]] - 1] = A[i];//注意：下标索引从0开始！ 
    173.         --C[A[i]]; 
    174.     } 
    175. } 
    176.  
    177. int main() 
    178. { 
    179.     int A[6] = {2,7,1,4,0,3}; 
    180.     int n = 6; 
    181.     int k = 7; 
    182.     int *B = (int *)malloc(n *sizeof(int)); 
    183.     int *C = (int *)malloc((k + 1) *sizeof(int)); 
    184.     cout << "排序之前的元素：" << endl; 
    185.     for (int i = 0;i < n;++i) 
    186.     { 
    187.         cout << A[i] << " "; 
    188.     } 
    189.     cout << endl; 
    190.     CountintSort(A,B,n,k,C); 
    191.     cout << "排序之后的元素：" << endl; 
    192.     for (int i = 0;i < n;++i) 
    193.     { 
    194.         cout << B[i] << " "; 
    195.     } 
    196.     cout << endl; 
    197.     free(B); 
    198.     free(C); 
    199. }</pre><br> 
    200. 运行结果：<p></p> 
    201. <p><img alt="" src="http://my.csdn.net/uploads/201206/10/1339316958_2887.jpg"><br> 
    202. </p> 
    203. <p><strong>时间复杂度分析：</strong></p> 
    204. <p>时间复杂度是O(k + n)。一般，当k = O(n)时，常常采用计数排序。这时候的运行时间为O(n)。</p> 
    205. <p>计数排序是稳定的排序。</p> 
    206. <p><br> 
    207. </p> 
    208. <p>一些好的参考资料：不同排序算法间的比较：<a href="http://commons.wikimedia.org/wiki/File:SortingAlgoComp.png">http://commons.wikimedia.org/wiki/File:SortingAlgoComp.png</a><br> 
    209. 一些排序算法的 C 及 Pascal 实现 ：<br> 
    210. <a href="http://www.nocow.cn/index.php/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95">http://www.nocow.cn/index.php/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95</a></p> 
    211. <p>最后，简要比较一下各排序算法，转自维基百科：</p> 
    212. <p><span id=".E7.AE.80.E8.A6.81.E6.AF.94.E8.BE.83"class="mw-headline">简要比较</span> 
    213. <table class="wikitable     "> 
    214. <tbody> 
    215. <tr> 
    216. <th rowSpan="2">名称</th> 
    217. <th rowSpan="2">数据对象</th> 
    218. <th rowSpan="2">稳定性</th> 
    219. <th colSpan="2">时间复杂度</th> 
    220. <th rowSpan="2">空间复杂度</th> 
    221. <th rowSpan="2">描述</th> 
    222. </tr> 
    223. <tr> 
    224. <th>平均</th> 
    225. <th>最坏</th> 
    226. </tr> 
    227. <tr> 
    228. <td>插入排序</td> 
    229. <td>数组、链表</td> 
    230. <td>√</td> 
    231. <td colSpan="2"><span dir="ltr"class="texhtml"><em>O</em>(<em>n</em><sup>2</sup>)</span></td> 
    232. <td>O(1)</td> 
    233. <td>(有序区,无序区)。把无序区的第一个元素插入到有序区的合适的位置。对数组：比较得少，换得多。</td> 
    234. </tr> 
    235. <tr> 
    236. <td rowSpan="2">直接选择排序</td> 
    237. <td>数组</td> 
    238. <td>×</td> 
    239. <td rowSpan="2" colSpan="2"><span dir="ltr"class="texhtml"><em>O</em>(<em>n</em><sup>2</sup>)</span></td> 
    240. <td rowSpan="2">O(1)</td> 
    241. <td rowSpan="2">(有序区,无序区)。在无序区里找一个最小的元素跟在有序区的后面。 对数组：比较得多，换得少。</td> 
    242. </tr> 
    243. <tr> 
    244. <td>链表</td> 
    245. <td>√</td> 
    246. </tr> 
    247. <tr> 
    248. <td>堆排序</td> 
    249. <td>数组</td> 
    250. <td>×</td> 
    251. <td colSpan="2">O(nlogn)</td> 
    252. <td>O(1)</td> 
    253. <td>(最大堆,有序区)。从堆顶把根卸出来放在有序区之前，再恢复堆。</td> 
    254. </tr> 
    255. <tr> 
    256. <td>归并排序</td> 
    257. <td>数组、链表</td> 
    258. <td>√</td> 
    259. <td colSpan="2">O(nlogn)</td> 
    260. <td>O(n) +O(logn) ， 如果不是从下到上</td> 
    261. <td>把数据分为两段，从两段中逐个选最小的元素移入新数据段的末尾。可从上到下或从下到上进行。</td> 
    262. </tr> 
    263. <tr> 
    264. <td>快速排序</td> 
    265. <td>数组</td> 
    266. <td>×</td> 
    267. <td>O(nlogn)</td> 
    268. <td><span dir="ltr" class="texhtml"><em>O</em>(<em>n</em><sup>2</sup>)</span></td> 
    269. <td>O(logn) ,O(n)</td> 
    270. <td>(小数,枢纽元,大数)。</td> 
    271. </tr> 
    272. <tr> 
    273. <td>Accum qsort</td> 
    274. <td>链表</td> 
    275. <td>√</td> 
    276. <td>O(nlogn)</td> 
    277. <td><span dir="ltr" class="texhtml"><em>O</em>(<em>n</em><sup>2</sup>)</span></td> 
    278. <td>O(logn) ,O(n)</td> 
    279. <td>(无序区,有序区)。把无序区分为(小数,枢纽元,大数)，从后到前压入有序区。</td> 
    280. </tr> 
    281. <tr> 
    282. <td colSpan="7"> </td> 
    283. <td> </td> 
    284. </tr> 
    285. <tr> 
    286. <td>决策树排序</td> 
    287. <td> </td> 
    288. <td>√</td> 
    289. <td colSpan="2">O(logn!)</td> 
    290. <td>O(n!)</td> 
    291. <td>O(n) <O(logn!) <O(nlogn)</td> 
    292. </tr> 
    293. <tr> 
    294. <td colSpan="7"> </td> 
    295. <td> </td> 
    296. </tr> 
    297. <tr> 
    298. <td>计数排序</td> 
    299. <td>数组、链表</td> 
    300. <td>√</td> 
    301. <td colSpan="2">O(n)</td> 
    302. <td>O(n+m)</td> 
    303. <td>统计小于等于该元素值的元素的个数 i，于是该元素就放在目标数组的索引 i位。(i≥0)</td> 
    304. </tr> 
    305. <tr> 
    306. <td>桶排序</td> 
    307. <td>数组、链表</td> 
    308. <td>√</td> 
    309. <td colSpan="2">O(n)</td> 
    310. <td>O(m)</td> 
    311. <td>将值为 i 的元素放入i 号桶，最后依次把桶里的元素倒出来。</td> 
    312. </tr> 
    313. <tr> 
    314. <td>基数排序</td> 
    315. <td>数组、链表</td> 
    316. <td>√</td> 
    317. <td colSpan="2"> </td> 
    318. <td> </td> 
    319. <td>一种多关键字的排序算法，可用桶排序实现。</td> 
    320. </tr> 
    321. </tbody> 
    322. </table> 
    323. <p></p> 
    324. <ul> 
    325. <li>均按从小到大排列 </li><li>n 代表数据规模 </li><li>m 代表数据的最大值减最小值 </li></ul> 
    326. <div><pre class="cpp" name="code"></pre></div><div></div><pre></pre> 
    327. <pre></pre> 
    328. <pre></pre> 
    329. <pre></pre> 
    330. <pre></pre> 
    331. <pre></pre> 
    332. <pre></pre> 
    333. <pre></pre> 
    334. </pre> 
  • 相关阅读:
    bzoj3771 Triple
    【BZOJ-1597】土地购买 DP + 斜率优化
    【BZOJ-1911】特别行动队 DP + 斜率优化
    【BZOJ-3144】切糕 最小割-最大流
    【BZOJ-2095】Bridge 最大流 + 混合图欧拉回路 + 二分
    【BZOJ-3996】线性代数 最小割-最大流
    【BZOJ-1497】最大获利 最大流
    【BZOJ-1500】维修数列 Splay
    【BZOJ-1458】士兵占领 最大流
    【BZOJ-3626】LCA 树链剖分
  • 原文地址：https://www.cnblogs.com/wuyida/p/6301190.html
Copyright © 2011-2022 走看看