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> 
  • 相关阅读:
    POJ 1015 Jury Compromise【DP】
    POJ 1661 Help Jimmy【DP】
    HDU 1074 Doing Homework【状态压缩DP】
    HDU 1024 Max Sum Plus Plus【DP，最大m子段和】
    占坑补题。。最近占的坑有点多。。。
    Codeforces 659F Polycarp and Hay【BFS】
    Codeforces 659E New Reform【DFS】
    Codeforces 659D Bicycle Race【计算几何】
    廖大python实战项目第四天
    廖大python实战项目第三天
  • 原文地址：https://www.cnblogs.com/wuyida/p/6301190.html
Copyright © 2011-2022 走看看