├── P100_Loading.cpp
├── P13_Perm.cpp
├── P13_perm.py
├── P14_q.cpp
├── P14_q.py
├── P15_Hanoi.cpp
├── P15_hanoi.py
├── P17_binary_search.py
├── P24_QuickSort.cpp
├── P24_QuickSort_Split.cpp
├── P25_RandomizedQuickSort.cpp
├── P27_RandomizedSelect.cpp
├── P47_MatriMultiply.cpp
├── P49_MatrixChain.cpp
├── P54_LCS.cpp
├── P54_LCS.py
├── P57_MaxSum.cpp
├── P57_maxsum.py
├── P68_Compress.cpp
├── P71_MNS.cpp
├── P75_Knapsack.cpp
├── P96_GreedySelector.cpp
├── README.assets
    ├── 0-1背包问题1.png
    ├── 0-1背包问题2.png
    ├── 0-1背包问题3.png
    ├── 图像压缩1.png
    ├── 图像压缩2.png
    ├── 图像压缩3.png
    ├── 快速排序1.png
    ├── 快速排序2.png
    ├── 快速排序3.png
    ├── 快速排序4.png
    ├── 最优装载1.png
    ├── 最优装载2.png
    ├── 最优装载3.png
    ├── 最大子段和1.png
    ├── 最大子段和2.png
    ├── 最大子段和3.png
    ├── 最大子段和4.png
    ├── 最长公共子序列1.png
    ├── 最长公共子序列2.png
    ├── 最长公共子序列3.png
    ├── 活动安排问题1.png
    ├── 活动安排问题2.png
    ├── 活动安排问题3.png
    ├── 电路布线1.png
    ├── 电路布线2.png
    ├── 电路布线3.png
    ├── 电路布线4.png
    ├── 矩阵连乘问题1.png
    ├── 矩阵连乘问题2.png
    ├── 矩阵连乘问题3.png
    └── 矩阵连乘问题4.png
└── README.md


/P100_Loading.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | 
 5 | class SortIndices{
 6 | private:
 7 |     int* mparr;
 8 | public:
 9 |     SortIndices(int* parr)
10 |     :mparr(parr)
11 |     {}
12 |     bool operator()(int i,int j)const{
13 |         return mparr[i]<mparr[j];
14 |     }
15 | };
16 | 
17 | template<typename Type>// 使用模板以支持整型及浮点型
18 | int* Loading(int x[],Type w[],Type c,int n){
19 |     int *t=new int [n+1];
20 |     for(int i=1;i<=n;i++)
21 |         t[i]=i;
22 |     sort(t+1,t+n+1,SortIndices(w));// 左闭右开,排序范围等价于[t+1,t+n]
23 |     for(int i=1;i<=n;i++)
24 |         x[i]=0;
25 |     for(int i=1;i<=n && w[t[i]]<=c;i++){
26 |         x[t[i]]=1;
27 |         c-=w[t[i]];
28 |     }
29 |     return t;
30 | }
31 | 
32 | int main(){
33 |     const int n=8;
34 |     int x[n+1];
35 |     int w[n+1]={0,100,200,50,90,150,50,20,80};
36 |     int c=400;
37 | 
38 |     int* t=Loading(x,w,c,n);
39 | 
40 | 
41 |     printf("%-8c|",'i');
42 |     for(int i=1;i<=n;i++)
43 |         printf("%6d",i);
44 |     printf("\n");
45 | 
46 |     printf("w[t[i]] |");
47 |     for(int i=1;i<=n;i++)
48 |         printf("%6d",t[i]);
49 |     printf("\n");
50 | 
51 |     printf("loaded  |");
52 |     int loaded=0;
53 |     for(int i=1;i<=n && x[t[i]]==1;i++){
54 |         loaded+=w[t[i]];
55 |         printf("%6d",loaded);
56 |     }
57 |     printf("\n");
58 | 
59 |     printf("\nx=(%d",x[1]);
60 |     for(int i=2;i<=n;i++)
61 |         printf(",%d",x[i]);
62 |     printf(")");
63 |     return 0;
64 | }


--------------------------------------------------------------------------------
/P13_Perm.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | void Perm(int list[],int k,int m){
 5 |     if(k==m){
 6 |         for(int i=0;i<=m;i++)
 7 |             cout<<list[i];
 8 |     cout<<endl;
 9 |     }
10 |     else{
11 |         for(int i=k;i<=m;i++){
12 |             swap(list[k],list[i]);
13 |             Perm(list,k+1,m);
14 |             swap(list[k],list[i]);
15 |         }
16 |     }
17 | }
18 | 
19 | int main(){
20 |     int s[]={1,2,3};
21 |     int length=sizeof(s)/sizeof(s[0]);
22 |     Perm(s,0,length-1);
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/P13_perm.py:
--------------------------------------------------------------------------------
 1 | from typing import List
 2 | 
 3 | def perm(ls:List,k:int,m:int)->None:
 4 |     if k==m:
 5 |         for i in range(m+1):
 6 |             print(ls[i],end='')
 7 |         print()
 8 |     else:
 9 |         for i in range(k,m+1):
10 |             ls[k],ls[i]=ls[i],ls[k]
11 |             perm(ls,k+1,m)
12 |             ls[k],ls[i]=ls[i],ls[k]
13 | 
14 | def main():
15 |     ls=[1,2,3]
16 |     perm(ls,0,2)
17 | 
18 | if __name__=="__main__":
19 |     main()
20 | 


--------------------------------------------------------------------------------
/P14_q.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int q(int n,int m){
 5 |     if(n<1||m<1)
 6 |         return 0;
 7 |     if(n==1||m==1)
 8 |         return 1;
 9 |     if(n<m)
10 |         return q(n,n);
11 |     if(n==m)
12 |         return q(n,m-1)+1;
13 |     return q(n,m-1)+q(n-m,m);
14 | }
15 | 
16 | int main(){
17 |     cout<<q(6,4);
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/P14_q.py:
--------------------------------------------------------------------------------
 1 | def q(n:int,m:int)->int:
 2 |     if n<1 or m<1:
 3 |         return 0
 4 |     if n==1 or m==1:
 5 |         return 1
 6 |     if n<m:
 7 |         return q(n,n)
 8 |     if n==m:
 9 |         return q(n,m-1)+1
10 |     return q(n,m-1)+q(n-m,m)
11 | 
12 | def p(n:int)->int:
13 |     return q(n,n)
14 | 
15 | def main():
16 |     x=6
17 |     print(p(x))
18 | 
19 | if __name__=="__main__":
20 |     main()


--------------------------------------------------------------------------------
/P15_Hanoi.cpp:
--------------------------------------------------------------------------------
 1 | #include <stack>
 2 | #include <iostream>
 3 | //#define VNAME(value) (#value)
 4 | using namespace std;
 5 | 
 6 | 
 7 | void Move(stack<int> &a,stack<int> &b){
 8 |     b.push(a.top());
 9 |     a.pop();
10 |     return ;
11 | }
12 | 
13 | void Hanoi(int n,stack<int> &a,stack<int> &b,stack<int> &c){
14 |     if(n>0){
15 |         Hanoi(n-1,a,c,b);
16 |         Move(a,b);
17 |         Hanoi(n-1,c,b,a);
18 |     }
19 |     return ;
20 | }
21 | 
22 | void StackPrint(stack<int> s){
23 |     //cout<<VNAME(s)<<':';
24 |     for (stack<int> dump=s;!dump.empty();dump.pop())
25 |         cout<<dump.top()<<' ';
26 |     cout<<'\n';
27 | }
28 | 
29 | int main(){
30 |     stack<int> a,b,c;
31 |     int n=3;
32 |     for(int i=n;i>0;i--)
33 |         a.push(i);
34 | 
35 |     cout<<"a:";
36 |     StackPrint(a);
37 |     cout<<"b:";
38 |     StackPrint(b);
39 |     cout<<"c";
40 |     StackPrint(c);
41 |     
42 |     Hanoi(n,a,b,c);
43 |     cout<<"a:";
44 |     StackPrint(a);
45 |     cout<<"b:";
46 |     StackPrint(b);
47 |     cout<<"c";
48 |     StackPrint(c);
49 |     return 0;
50 | }


--------------------------------------------------------------------------------
/P15_hanoi.py:
--------------------------------------------------------------------------------
 1 | from typing import List
 2 | 
 3 | def move(a:List,b:List)->None:
 4 |     temp=a.pop()
 5 |     b.append(temp)
 6 | 
 7 | def hanoi(n:int,a:List,b:List,c:List)->None:#para3：借用柱
 8 |     if n>0:
 9 |         hanoi(n-1,a,c,b)
10 |         move(a,b)
11 |         globalPrint()
12 |         hanoi(n-1,c,b,a)
13 | 
14 | a,b,c=[],[],[]
15 | 
16 | def globalPrint():
17 |     print(a,b,c)
18 | 
19 | def main():
20 |     n=3
21 |     for i in range(n,0,-1):
22 |         a.append(i)
23 |     hanoi(n,a,b,c)
24 | 
25 | if __name__=="__main__":
26 |     main()


--------------------------------------------------------------------------------
/P17_binary_search.py:
--------------------------------------------------------------------------------
 1 | from typing import List
 2 | 
 3 | def binary_search(a:List,x,n:int)->int:
 4 |     left,right=0,n-1
 5 |     while left<=right:
 6 |         middle=(left+right)>>1
 7 |         if x==a[middle]:
 8 |             return middle
 9 |         if x>a[middle]:
10 |             left=middle+1
11 |         else:
12 |             right=middle-1
13 |     return -1
14 | 
15 | def main():
16 |     ls=sorted([1,4,6,2,36,71,6,3,6,8,4,456])
17 |     print(ls)
18 |     print(binary_search(ls,36,len(ls)))
19 | 
20 | if __name__=="__main__":
21 |     main()


--------------------------------------------------------------------------------
/P24_QuickSort.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | 
 5 | template <typename Type>
 6 | int Partition(Type a[],int p,int r){
 7 |     int i=p,j=r+1;  // 待排区间[p+1,r]
 8 |     Type x=a[p];  // 基准元素
 9 |     while(true){
10 |         while(a[++i]<x && i<r)  // 存在a[t]>=x,t=i+1,i+2,...,r-1（后面所有的元素都比基准元素大）的情况，可能越界，即脱离待排数组，需要约束该向右指针以防该情况发生，出于效率我认为可以改做i<j(上一个j)
11 |             ;
12 |         while(a[--j]>x)  // 左侧必定存在元素<=x，不会越界
13 |             ;
14 |         if(i>=j)
15 |             break;
16 |         swap(a[i],a[j]);
17 |     }
18 |     // swap(a[p],a[j]);
19 |     a[p]=a[j];
20 |     a[j]=x;
21 |     return j;
22 | }
23 | 
24 | template <typename Type>
25 | void QuickSort(Type a[],int p,int r){
26 |     if(p<r){
27 |         printf("Sorting: {%d",a[p]);
28 |         for(int i=p+1;i<=r;i++)
29 |             printf(",%d",a[i]);
30 |         printf("}\n");
31 | 
32 |         int q=Partition(a,p,r);
33 | 
34 |         printf("Sorted:  {%d",a[p]);
35 |         for(int i=p+1;i<=r;i++)
36 |             printf(",%d",a[i]);
37 |         printf("}\n");
38 | 
39 |         QuickSort(a,p,q-1);
40 |         QuickSort(a,q+1,r);
41 |     }
42 | }
43 | 
44 | int main(){
45 |     const int n=8;
46 |     int *a=new int[n+1]{0,8,4,1,7,11,5,6,9};  // C++11
47 |     // int a[n+1]={0,8,4,1,7,11,5,6,9};  // C99
48 |     
49 |     printf("Original a={%d",a[1]);
50 |     for(int i=2;i<=n;i++)
51 |         printf(",%d",a[i]);
52 |     printf("}\n\n");
53 | 
54 |     QuickSort(a,1,n);
55 | 
56 |     printf("\nResult a={%d",a[1]);
57 |     for(int i=2;i<=n;i++)
58 |         printf(",%d",a[i]);
59 |     printf("}");
60 | 
61 |     return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/P24_QuickSort_Split.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | 
 5 | template <typename Type>
 6 | int Split(Type a[],int p,int r){
 7 |     int i=p;
 8 |     Type x=a[p];
 9 |     for(int j=p+1;j<=r;j++)
10 |         if(x>a[j] && ++i!=j)
11 |                 swap(a[i],a[j]);
12 |     // swap(a[i],a[p]);  // 标准的Split算法
13 |     // 模拟手算的Split算法
14 |     for(int j=p;j<i;j++)
15 |         swap(a[j],a[j+1]);
16 |     return i;
17 | }
18 | 
19 | template <typename Type>
20 | void QuickSort(Type a[],int p,int r){
21 |     if(p<r){
22 |         printf("Spliting: {%d",a[p]);
23 |         for(int i=p+1;i<=r;i++)
24 |             printf(",%d",a[i]);
25 |         printf("}\n");
26 | 
27 |         int q=Split(a,p,r);
28 | 
29 |         printf("Splited:  {%d",a[p]);
30 |         for(int i=p+1;i<=r;i++)
31 |             printf(",%d",a[i]);
32 |         printf("}\n");
33 | 
34 |         QuickSort(a,p,q-1);
35 |         QuickSort(a,q+1,r);
36 |     }
37 | }
38 | 
39 | int main(){
40 |     const int n=8;
41 |     int *a=new int[n+1]{0,8,4,1,7,11,5,6,9};  // C++11
42 |     // int a[n+1]={0,8,4,1,7,11,5,6,9};  // C99
43 |     
44 |     printf("Original a={%d",a[1]);
45 |     for(int i=2;i<=n;i++)
46 |         printf(",%d",a[i]);
47 |     printf("}\n\n");
48 | 
49 |     QuickSort(a,1,n);
50 | 
51 |     printf("\nResult a={%d",a[1]);
52 |     for(int i=2;i<=n;i++)
53 |         printf(",%d",a[i]);
54 |     printf("}");
55 | 
56 |     return 0;
57 | }


--------------------------------------------------------------------------------
/P25_RandomizedQuickSort.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | #include <vector>
 4 | #include <random>
 5 | using namespace std;
 6 | 
 7 | template <typename Type>
 8 | Type Random(Type p,Type r){
 9 |     random_device rd;
10 |     default_random_engine e(rd());
11 |     uniform_int_distribution<Type> u(p, r);
12 |     Type x=u(e);
13 |     return x;
14 | }
15 | 
16 | template <typename Type>
17 | int Partition(Type a[],int p,int r){
18 |     int i=p,j=r+1;
19 |     while(true){
20 |         while(a[++i]<a[p] && i<r)
21 |             ;
22 |         while(a[--j]>a[p])
23 |             ;
24 |         if(i>=j)
25 |             break;
26 |         swap(a[i],a[j]);
27 |     }
28 |     swap(a[p],a[j]);
29 |     return j;
30 | }
31 | 
32 | template <typename Type>
33 | int RandomizedPartition(Type a[],int p,int r){
34 |     int i=Random(p,r);
35 |     swap(a[i],a[p]);
36 |     return Partition(a,p,r);
37 | }
38 | 
39 | template <typename Type>
40 | void RandomizedQuickSort(Type a[],int p,int r){
41 |     if(p<r){
42 |         printf("Sorting: {%d",a[p]);
43 |         for(int i=p+1;i<=r;i++)
44 |             printf(",%d",a[i]);
45 |         printf("}\n");
46 |         
47 |         int q=RandomizedPartition(a,p,r);
48 | 
49 |         printf("Sorted:  {%d",a[p]);
50 |         for(int i=p+1;i<=r;i++)
51 |             printf(",%d",a[i]);
52 |         printf("}\n");
53 | 
54 |         RandomizedQuickSort(a,p,q-1);
55 |         RandomizedQuickSort(a,q+1,r);
56 |     }
57 | }
58 | 
59 | template <typename Type>
60 | void RandomizedQuickSort(vector<Type>& a,int p,int r){
61 |     // 将向量转为数组
62 |     int arr[a.size()];
63 |     copy(a.begin(),a.end(),arr);
64 |     // 调用数组的随机化的快速排序算法
65 |     RandomizedQuickSort(arr,p,r);
66 |     // 将排序后的数组转为向量
67 |     vector<int> varr(arr, arr+a.size());  // 拷贝指针的范围左闭右开，arr+a.size()是已知数组长度（原向量长度）的做法，数组长度大多数时候需要计算，即结束指针使用arr+sizeof(arr)/sizeof(arr[0])
68 |     // 赋值回向量
69 |     a=varr;
70 | }
71 | 
72 | int main(){
73 |     const int n=8;
74 |     vector<int> a={0,8,4,1,7,11,5,6,9};  // C++98 STL
75 |     // int *a=new int[n+1]{0,8,4,1,7,11,5,6,9};  // C++11
76 |     // int a[n+1]={0,8,4,1,7,11,5,6,9};  // C99
77 | 
78 |     printf("Original a={%d",a[1]);
79 |     for(int i=2;i<=n;i++)
80 |         printf(",%d",a[i]);
81 |     printf("}\n\n");
82 | 
83 |     RandomizedQuickSort(a,1,n);
84 | 
85 |     printf("\nResult a={%d",a[1]);
86 |     for(int i=2;i<=n;i++)
87 |         printf(",%d",a[i]);
88 |     printf("}");
89 | 
90 |     return 0;
91 | }
92 | 


--------------------------------------------------------------------------------
/P27_RandomizedSelect.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <random>
 3 | #include <algorithm>
 4 | using namespace std;
 5 | 
 6 | template <typename Type>
 7 | Type Random(Type p,Type r){
 8 |     random_device rd;
 9 |     default_random_engine e(rd());
10 |     uniform_int_distribution<Type> u(p, r);
11 |     Type x=u(e);
12 |     return x;
13 | }
14 | 
15 | template <typename Type>
16 | int Partition(Type a[],int p,int r){
17 |     int i=p,j=r+1;
18 |     while(true){
19 |         while(a[++i]<a[p] && i<r)
20 |             ;
21 |         while(a[--j]>a[p])
22 |             ;
23 |         if(i>=j)
24 |             break;
25 |         swap(a[i],a[j]);
26 |     }
27 |     swap(a[p],a[j]);
28 |     return j;
29 | }
30 | 
31 | template <typename Type>
32 | int RandomizedPartition(Type a[],int p,int r){
33 |     int i=Random(p,r);
34 |     swap(a[i],a[p]);
35 |     return Partition(a,p,r);
36 | }
37 | 
38 | template <typename Type>
39 | void RandomizedQuickSort(Type a[],int p,int r){
40 |     if(p<r){
41 |         int q=RandomizedPartition(a,p,r);
42 |         RandomizedQuickSort(a,p,q-1);
43 |         RandomizedQuickSort(a,q+1,r);
44 |     }
45 | }
46 | 
47 | template <typename Type>
48 | Type RandomizedSelect(Type a[],int p,int r,int k){
49 |     if(p==r)
50 |         return a[p];
51 |     int i=RandomizedPartition(a,p,r);
52 |     int j=i-p+1;
53 |     if(k<=j)
54 |         return RandomizedSelect(a,p,i,k);
55 |     else
56 |         return RandomizedSelect(a,i+1,r,k-j);
57 | }
58 | 
59 | int main(){
60 |     const int n=22;
61 |     int k=5;  // k在一些情况下会导致随机数引擎段错误，很迷啊席八，换C里面的rand()也一样，考完试再想（估计不会了）
62 |     int* a=new int [n+1]{0,2,6,9,1,4,10,20,6,22,11,10,9,4,3,7,16,11,8,2,5,4,1};
63 |     int ak=RandomizedSelect(a,1,n,k);
64 |     RandomizedQuickSort(a,1,n);
65 | 
66 |     printf("a[i]|");
67 |     for(int i=1;i<=n;i++)
68 |         printf("%3d",a[i]);
69 |     printf("\n");
70 | 
71 |     printf("  i |");
72 |     for(int i=1;i<=n;i++)
73 |         printf("%3d",i);
74 |     printf("\n");
75 | 
76 |     printf("The %d-th smallest element is %d",k,ak);
77 |     return 0;
78 | }


--------------------------------------------------------------------------------
/P47_MatriMultiply.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstdlib>
 3 | bool MatriMultiply(int **a,int **b,int **c,int ra,int ca,int rb,int cb){
 4 |     if(ca!=rb){
 5 |         perror("矩阵不可乘");
 6 |         exit(EXIT_FAILURE);// #define EXIT_FAILURE 1
 7 |     }
 8 |     for(int i=0;i<ra;i++){
 9 |         for(int j=0;j<cb;j++){
10 |             int sum=a[i][0]*b[0][j];
11 |             for(int k=1;k<ca;k++)
12 |                 sum+=a[i][k]*b[k][j];
13 |             c[i][j]=sum;
14 |         }
15 |     }
16 |     return true;
17 | }
18 | int main(){
19 |     int a[3][3]={
20 |     {1,2,1},
21 |     {1,2,1},
22 |     {1,2,1}};
23 |     int ra=3;
24 |     int ca=3;
25 |     int *pa[3];
26 |     for(int i=0;i<ra;i++)
27 |         pa[i]=a[i];
28 | 
29 |     int b[3][3]={
30 |     {2,1,1},
31 |     {2,1,1},
32 |     {2,1,1}};
33 |     int rb=4;
34 |     int cb=3;
35 |     int *pb[3];
36 |     for(int i=0;i<rb;i++)
37 |         pb[i]=b[i];
38 | 
39 |     int c[3][3]={{},{},{}};
40 |     int rc=3;
41 |     int cc=3;
42 |     int *pc[3];
43 |     for(int i=0;i<rc;i++)
44 |         pc[i]=c[i];
45 | 
46 |     MatriMultiply(pa,pb,pc,ra,ca,rb,cb);
47 |     for(int i=0;i<rc;i++){
48 |         for(int j=0;j<cc;j++)
49 |             printf("%d ",c[i][j]);
50 |         printf("\n");
51 |     }
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/P49_MatrixChain.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | void MatrixChain(int *p,int n,int **m,int **s){
 3 |     for (int i=1;i<=n;i++)
 4 |         m[i][i]=0;
 5 |     for (int r=2;r<=n;r++){
 6 |         for (int i=1;i<=n-r+1;i++){
 7 |             int j=i+r-1;
 8 |             // 打擂法初始化
 9 |             int k=i;
10 |             m[i][j]=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];//m[i][i]=0，所以可以不写
11 |             s[i][j]=i;
12 |             for (int k=i+1;k<j;k++){
13 |                 int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
14 |                 if (t<m[i][j]){
15 |                     m[i][j]=t;
16 |                     s[i][j]=k;
17 |                 }
18 |             }
19 |         }
20 |     }
21 | }
22 | bool Traceback(int i,int j,int **s){
23 |     if (i==j)
24 |         return false;
25 |     Traceback(i,s[i][j],s);
26 |     Traceback(s[i][j]+1,j,s);
27 |     printf("Multiply A %d, %d and A %d, %d\n",i,s[i][j],s[i][j]+1,j);
28 |     return true;
29 | }
30 | bool PrintMatrixFromOne(int **m,int r,int c){
31 |     // int r=sizeof(m)/sizeof(m[0]);
32 |     // int c=sizeof(m[0])/sizeof(m[0][0]);
33 |     for (int i=1;i<r+1;i++){
34 |         for (int j=1;j<c+1;j++)
35 |             printf("%8d ",m[i][j]);
36 |         printf("\n");
37 |     }
38 |     printf("\n");
39 |     return true;
40 | }
41 | int main(){
42 |     // const int n=6;
43 |     // int p[n+1]={30,35,15,5,10,20,25};
44 |     const int n=5;
45 |     int p[n+1]={20,30,50,10,35,25};
46 |     // int p[n+1]={4,6,10,2,7,5};
47 |     // m和n忽略0行0列
48 |     int m[n+1][n+1]={};
49 |     int *pm[n+1];
50 |     for (int i=1;i<=n+1;i++)
51 |         pm[i]=m[i];
52 |     int s[n+1][n+1]={};
53 |     int *ps[n+1];
54 |     for (int i=1;i<=n+1;i++)
55 |         ps[i]=s[i];
56 |     MatrixChain(p,n,pm,ps);
57 |     PrintMatrixFromOne(pm,n,n);
58 |     PrintMatrixFromOne(ps,n,n);
59 |     Traceback(1,n,ps);
60 |     return 0;
61 | }


--------------------------------------------------------------------------------
/P54_LCS.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cstring>
  3 | #include <cstdio>
  4 | using namespace std;
  5 | void LCSLength(int m,int n,char *x,char *y,int **c,int **b){
  6 |     int i,j;
  7 |     // 这里要改，不然c[0][0]初始化不到，其实为了完整性（好看）b也该初始化的
  8 |     // 初始化第0列
  9 |     for(int i=0;i<=m;i++){
 10 |         c[i][0]=0;
 11 |         b[i][0]=0;
 12 |     }
 13 |     // 初始化第0行
 14 |     for(int i=0;i<=n;i++){
 15 |         c[0][i]=0;
 16 |         b[0][i]=0;
 17 |     }
 18 |     for(i=1;i<=m;i++){
 19 |         for(j=1;j<=n;j++){
 20 |         // 从左到右 从上到下遍历
 21 |             // 对一个4格的右下格子
 22 |             // 如果匹配上了，从左上格子转移
 23 |             // 这里要改，序列的索引应从0起
 24 |             if(x[i-1]==y[j-1]){
 25 |                 c[i][j]=c[i-1][j-1]+1;
 26 |                 b[i][j]=1;
 27 |             }
 28 |             // 如果没匹配上
 29 |             // 且上方格子大于（等于）左方格子，从上方格子转移
 30 |             else if(c[i-1][j]>=c[i][j-1]){
 31 |                 c[i][j]=c[i-1][j];
 32 |                 b[i][j]=2;
 33 |             }
 34 |             // 且左方格子大于上方格子，从左方格子转移
 35 |             else{
 36 |                 c[i][j]=c[i][j-1];
 37 |                 b[i][j]=3;
 38 |             }
 39 |         }
 40 |     }
 41 | }
 42 | 
 43 | void LCS(int i,int j,char *x,int **b){
 44 |     // 如果递归至边界，结束
 45 |     if(i==0||j==0)
 46 |         return ;
 47 |     // 如果标记为1（左上箭头），递归进左上格子，递归结束后打印本格字符
 48 |     if(b[i][j]==1){
 49 |         LCS(i-1,j-1,x,b);
 50 |         // 这里要改，序列的索引应从0起
 51 |         cout<<x[i-1];
 52 |     }
 53 |     // 如果标记为2（向上箭头），递归进上方格子，不打印
 54 |     else if(b[i][j]==2)
 55 |         LCS(i-1,j,x,b);
 56 |     // 如果标记为3（向左箭头），递归进左方格子，不打印
 57 |     else if(b[i][j]==3)
 58 |         LCS(i,j-1,x,b);
 59 | }
 60 | 
 61 | bool PrintMatrix(int **m,int r,int c,char *x,char *y){
 62 |     printf("    \'\'");
 63 |     for (int i=0;i<=c;i++)
 64 |         printf("%4c",y[i]);
 65 |     printf("\n");
 66 |     for (int i=0;i<=r;i++){
 67 |         if(i==0)
 68 |             printf("\'\'");
 69 |         else
 70 |             printf("%2c",x[i-1]);
 71 |         for (int j=0;j<=c;j++)
 72 |             printf("%4d",m[i][j]);
 73 |         printf("\n");
 74 |     }
 75 |     printf("\n");
 76 |     return true;
 77 | }
 78 | 
 79 | int main(){
 80 |     // char X[]="abcbdb";
 81 |     // char Y[]="acbbabdbb";
 82 |     char X[]={'A','B','C','B','D','A','B','\0'};
 83 |     char Y[]={'B','D','C','A','B','A','\0'};// 这里不加结束符会栈溢出，X在Y的高地址方向（栈底方向），会被拼接到Y后
 84 |     const int lenX=strlen(X);
 85 |     const int lenY=strlen(Y);
 86 |     // printf("%p\n%p\n...\n%p\n%p\n",Y,Y+1,X,X+1);// 栈示意图
 87 |     // 法一：直接创建指针的指针（创建int*的指针int**）
 88 |     int** c=new int*[lenX+1];//先创建指针的指针，指向一个指针数组
 89 |     for (int i=0;i<lenX+1;i++)
 90 |         c[i]=new int[lenY+1];//让指针数组中的每一个指针，都指向一个动态一维数组
 91 |     int** b=new int*[lenX+1];
 92 | 	for (int i=0;i<lenX+1;i++)
 93 | 		b[i]=new int[lenY+1];
 94 |     // b[0][2]=3;int**可以用[]运算符赋值
 95 |     LCSLength(lenX,lenY,X,Y,c,b);
 96 | 
 97 | 
 98 |     printf("X=\"");
 99 |     for(int i=0;i<lenX;i++)
100 |         printf("%c",X[i]);
101 |     printf("\"\n");
102 | 
103 |     printf("Y=\"");
104 |     for(int i=0;i<lenY;i++)
105 |         printf("%c",Y[i]);
106 |     printf("\"\n");
107 | 
108 |     PrintMatrix(c,lenX,lenY,X,Y);
109 |     PrintMatrix(b,lenX,lenY,X,Y);
110 | 
111 |     printf("Z=\"");
112 |     LCS(lenX,lenY,X,b);
113 |     printf("\"\n");
114 | 
115 |     printf("|Z|=%d",c[lenX][lenY]);
116 |     // printf("\n");
117 | 
118 |     // 行指针int(*)[col]演示
119 |     // int X[3][3]={
120 |     // {1,2,3},
121 |     // {4,5,6},
122 |     // {7,8,9}};
123 |     // cout<<endl<<**X<<endl<<**(X+1)<<endl<<**(X+2);
124 | 
125 |     // 法二：将“行指针”的指针转化为指针的指针
126 |     // int c[lenX+1][lenY+1]={0},b[lenX+1][lenY+1]={0};
127 |     // int *pc[lenX+1],*pb[lenX+1];
128 |     // for(int i=0;i<lenX+1;i++){
129 |     // 把每个行指针转化为指针（将int(*)[col]转为int*）
130 |     //     pc[i]=c[i];
131 |     //     pb[i]=b[i];
132 |     // }
133 |     // LCSLength(lenX,lenY,X,Y,pc,pb);
134 |     // LCS(lenX,lenY,X,pb);
135 |     return 0;
136 | }


--------------------------------------------------------------------------------
/P54_LCS.py:
--------------------------------------------------------------------------------
 1 | def lcs_length(text1:str,text2:str)->int:
 2 |     m,n=len(text1),len(text2)
 3 |     dp=[[0]*(n+1) for _ in range(m+1)]
 4 |     for i in range(1,m+1):
 5 |         for j in range(1,n+1):
 6 |             if text1[i-1]==text2[j-1]:
 7 |                 dp[i][j]=dp[i-1][j-1]+1
 8 |             else:
 9 |                 dp[i][j]=max(dp[i-1][j],dp[i][j-1])
10 |                 # 输出跟CUMT式先上后左的答案不同的原因在于这个max
11 |     return dp[-1][-1]#逆序下标，代表最后一行最后一列，即dp[m][n]
12 | 
13 | def main():
14 |     A='abcbdb'
15 |     B='acbbabdbb'
16 |     print(lcs_length(A,B))
17 | 
18 | if __name__=="__main__":
19 |     main()


--------------------------------------------------------------------------------
/P57_MaxSum.cpp:
--------------------------------------------------------------------------------
  1 | #include <cstdio>
  2 | 
  3 | int MaxSum1(int n,int* a,int &besti,int &bestj){//简单算法 O(n^3)
  4 |     int sum=0;
  5 |     for(int i=1;i<=n;i++){
  6 |         for(int j=i;j<=n;j++){
  7 |             int thisSum=0;// 每次重新计算从i到j的子段和
  8 |             for(int k=i;k<=j;k++)
  9 |                 thisSum+=a[k];
 10 |             if(thisSum>sum){
 11 |                 sum=thisSum;
 12 |                 besti=i;
 13 |                 bestj=j;
 14 |             }
 15 |         }
 16 |     }
 17 |     return sum;
 18 | }
 19 | 
 20 | int MaxSum2(int n,int* a,int &besti,int &bestj){//改进的简单算法 O(n^2)
 21 |     int sum=0;
 22 |     for(int i=1;i<=n;i++){
 23 |         int thisSum=0;// 从i到j的子段和=第j个整数+从i到j-1的子段和（上次对j循环得到的子段和）
 24 |         for(int j=i;j<=n;j++){
 25 |             thisSum+=a[j];
 26 |             if(thisSum>sum){
 27 |                 sum=thisSum;
 28 |                 besti=i;
 29 |                 bestj=j;
 30 |             }
 31 |         }
 32 |     }
 33 |     return sum;
 34 | }
 35 | 
 36 | int MaxSubSum(int *a,int left,int right){
 37 |     int sum=0;
 38 |     if(left==right)
 39 |         return a[left]>0?a[left]:0;
 40 |     else{
 41 |         int middle=(left+right)/2;
 42 |         int leftSubSum=MaxSubSum(a,left,middle);
 43 |         int rightSubSum=MaxSubSum(a,middle+1,right);
 44 | 
 45 |         int s1=0;
 46 |         int thisS1=0;
 47 |         for(int i=middle;i>=left;i--){
 48 |             thisS1+=a[i];
 49 |             if(thisS1>s1)
 50 |                 s1=thisS1;
 51 |         }
 52 | 
 53 |         int s2=0;
 54 |         int thisS2=0;
 55 |         for(int i=middle+1;i<=right;i++){
 56 |             thisS2+=a[i];
 57 |             if(thisS2>s2)
 58 |                 s2=thisS2;
 59 |         }
 60 |         int crossSubSum=s1+s2;
 61 |         sum=crossSubSum;
 62 |         if(leftSubSum>sum)
 63 |             sum=leftSubSum;
 64 |         if(rightSubSum>sum)
 65 |             sum=rightSubSum;
 66 |     }
 67 |     return sum;
 68 | }
 69 | 
 70 | int MaxSum3(int n,int* a){//分治算法 O(nlogn)
 71 |     return MaxSubSum(a,1,n);
 72 | }
 73 | 
 74 | int MaxSum4(int n,int* a){//动态规划算法 O(n)
 75 |     int sum=0;
 76 |     int b=0;
 77 |     // 在变量只从子结构的一种情况转移时可以用一维dp，而且这个状态转移方程只在两个相邻格子之间(b[j-1] b[j])甚至不需要定义数组
 78 |     // 二维dp也是一样的，状态转移方程只在两个相邻行之间(dp[i][] dp[i-1][])甚至不需要定义m*n的二维数组，这就是许多题解将空间复杂度O(m*n)优化为O(min(m,n))的依据
 79 |     for(int i=1;i<=n;i++){
 80 |         if(i==1) printf("b=[");
 81 |         printf("%d",b>0 ? b+=a[i] : b=a[i]);// 试了一下赋值语句的返回值，顺便打印过程
 82 |         if(i!=n) printf(",");
 83 |         // b>0 ? b+=a[i] : b=a[i];
 84 |         // 注意该算法的结果取最大值而不是b[n]，要记得打擂保存
 85 |         if(b>sum)
 86 |             sum=b;
 87 |     }
 88 |     printf("]");
 89 |     return sum;
 90 | }
 91 | 
 92 | 
 93 | int main(){
 94 |     const int n=6;
 95 |     int a[n+1]={0,-2,11,-4,13,-5,-2};
 96 |     // int besti,bestj;
 97 |     // int maxSubSum=MaxSum1(n,a,besti,bestj);
 98 |     // int maxSubSum=MaxSum2(n,a,besti,bestj);
 99 |     // int maxSubSum=MaxSum3(n,a);
100 |     int maxSubSum=MaxSum4(n,a);
101 |     // printf("(%d,%d)",besti,bestj);
102 |     printf("\n%d",maxSubSum);
103 |     return 0;
104 | }


--------------------------------------------------------------------------------
/P57_maxsum.py:
--------------------------------------------------------------------------------
1 | n=int(input())
2 | A=[int(_) for _ in input().split()]
3 | sum=float('-inf')
4 | dp=float('-inf')
5 | for a in A:
6 |     dp=max(dp+a,a)
7 |     sum=max(sum,dp)
8 | print(sum)


--------------------------------------------------------------------------------
/P68_Compress.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <iostream>
 3 | #include <algorithm>
 4 | using namespace std;
 5 | 
 6 | int BitLength(int i){
 7 |     int k=1;
 8 |     i/=2;
 9 |     while(i>0){
10 |         k++;
11 |         i/=2;
12 |     }
13 |     return k;
14 | }
15 | 
16 | void Compress(int n,int p[],int s[],int l[],int b[]){
17 |     int Lmax=256,header=11;
18 |     s[0]=0;
19 |     for(int i=1;i<=n;i++){
20 |         b[i]=BitLength(p[i]);
21 |         int bmax=b[i];
22 |         s[i]=s[i-1]+bmax;
23 |         l[i]=1;
24 |         for(int k=2;k<=i&&k<=Lmax;k++){
25 |             if(bmax<b[i-k+1])
26 |                 bmax=b[i-k+1];
27 |             if(s[i]>s[i-k]+k*bmax){
28 |                 s[i]=s[i-k]+k*bmax;
29 |                 l[i]=k;
30 |             }
31 |         }
32 |         s[i]+=header;
33 |     }
34 | }
35 | 
36 | void Traceback(int n,int& i,int s[],int l[]){
37 |     if(n==0)
38 |         return ;
39 |     Traceback(n-l[n],i,s,l);
40 |     s[i++]=n-l[n];
41 | }
42 | 
43 | void Output(int s[],int l[],int b[],int n){
44 |     cout<<"The optimal value is "<<s[n]<<endl;
45 |     int m=0;
46 |     Traceback(n,m,s,l);
47 |     s[m]=n;
48 | 
49 |     cout<<"Decompose into "<<m<<" segments "<<endl;
50 |     for(int j=1;j<=m;j++){
51 |         l[j]=l[s[j]];
52 |         for(int k=s[j-1];k<=s[j];k++)  // 这里应该取整段的最大bit值而不是取最后一个
53 |             b[j]=max(b[j],b[k]);
54 |     }
55 |     for(int j=1;j<=m;j++)
56 |         cout<<"Segment"<<j<<": "<<"length is "<<l[j]<<", "<<"bits is "<<b[j]<<endl;
57 | }
58 | 
59 | void printVector(int* x,int n){
60 |     for(int i=1;i<=n;i++)
61 |         printf("%5d",x[i]);
62 |     printf("\n");
63 | }
64 | 
65 | int main(){
66 |     const int n=9;
67 |     int* p=new int[n+1]{0,9,11,10,12,15,127,178,220,0};
68 |     // const int n=7;
69 |     // int* p=new int[n+1]{0,4,5,6,7,129,138,1};
70 |     int* b=new int[n+1]();  // 使用()将每个元素初始化为0
71 |     int* l=new int[n+1]();
72 |     int* s=new int[n+1]();
73 |     Compress(n,p,s,l,b);
74 | 
75 |     printf("   i   ");
76 |     for(int i=1;i<=n;i++)
77 |         printf("%5d",i);
78 |     printf("\n       ");
79 |     for(int i=1;i<=n;i++)
80 |         printf("_____");
81 |     printf("\n");
82 |     printf(" p[i] |");
83 |     printVector(p,n);
84 |     printf(" b[i] |");
85 |     printVector(b,n);
86 |     printf(" l[i] |");
87 |     printVector(l,n);
88 |     printf(" s[i] |");
89 |     printVector(s,n);
90 |     printf("\n");
91 | 
92 |     Output(s,l,b,n);
93 | 
94 |     return 0;
95 | }


--------------------------------------------------------------------------------
/P71_MNS.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | void MNS(int pi[],int n,int **size){
 5 |     // 初始化第一行
 6 |     for(int j=0;j<pi[1];j++)
 7 |         size[1][j]=0;
 8 |     for(int j=pi[1];j<=n;j++)
 9 |         size[1][j]=1;
10 |     // 2->n-1行按状态转移方程计算
11 |     for(int i=2;i<n;i++){
12 |         for(int j=0;j<pi[i];j++)
13 |             size[i][j]=size[i-1][j];
14 |         for(int j=pi[i];j<=n;j++)
15 |             size[i][j]=max(size[i-1][j],size[i-1][pi[i]-1]+1);
16 |     }
17 |     // 最后一行只算最后一列，单拎出来
18 |     size[n][n]=max(size[n-1][n],size[n-1][pi[n]-1]+1);
19 | }
20 | 
21 | void Traceback(int pi[],int **size,int n,int Net[],int &m){
22 |     int j=n;// 列坐标（下端接线柱）
23 |     m=0;
24 |     for(int i=n;i>1;i--){// 行坐标（上端接线柱）
25 |         if(size[i][j]!=size[i-1][j]){
26 |             Net[m++]=i;
27 |             j=pi[i]-1;
28 |         }
29 |     }
30 |     // 这里要改，这两句明显只针对第一行，应和前面的n->2行分开
31 |     // 第一行的上方格子不能用，只能特判
32 |     if(j>=pi[1])
33 |     // 如果下段接线柱pi[2]在pi[1]后面，那么上端接线柱1一定可以加入集合
34 |         Net[m++]=1;
35 | }
36 | 
37 | bool PrintMatrix(int **m,int r,int c,int pi[]){
38 |     printf("            ");
39 |     for (int i=1;i<=c;i++)
40 |         printf("%4d",i);
41 |     printf("\n");
42 |     printf("            ");
43 |     for (int i=1;i<=c;i++)
44 |         printf("____");
45 |     printf("\n");
46 |     for (int i=1;i<=r;i++){
47 |         printf("(%2d,%2d)  %2d|",i,pi[i],i);
48 |         for (int j=1;j<=c;j++)
49 |             printf("%4d",m[i][j]);
50 |         printf("\n");
51 |     }
52 |     printf("\n");
53 |     return true;
54 | }
55 | 
56 | 
57 | 
58 | int main(){
59 |     const int n=10;
60 |     int pi[n+1]={0,2,4,7,8,5,6,9,3,10,1};
61 |     // int pi[n+1]={0,8,7,4,2,5,1,9,3,10,6};
62 |     int Net[n]={0};
63 |     int m=0;
64 |     int size[n+1][n+1]={0};
65 |     int* psize[n+1];
66 |     for(int i=0;i<(n+1);i++)
67 |         psize[i]=size[i];
68 |     MNS(pi,n,psize);
69 |     PrintMatrix(psize,n,n,pi);
70 |     Traceback(pi,psize,n,Net,m);
71 |     printf("{(%d,%d)",Net[m-1],pi[Net[m-1]]);
72 |     for(int i=m-2;i>=0;i--)
73 |         printf(",(%d,%d)",Net[i],pi[Net[i]]);
74 |     printf("}");
75 |     return 0;
76 | }


--------------------------------------------------------------------------------
/P75_Knapsack.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | template<typename Type>
 5 | void Knapsack(Type* v,int* w,int c,int n,Type** m){
 6 |     // 初始化第n行
 7 |     int jMax=min(w[n]-1,c);
 8 |     for(int j=0;j<=jMax;j++)
 9 |         m[n][j]=0;
10 |     for(int j=w[n];j<=c;j++)
11 |         m[n][j]=v[n];
12 |     // 第n-1->2行按状态转移方程计算
13 |     for(int i=n-1;i>1;i--){
14 |         jMax=min(w[i]-1,c);
15 |         for(int j=0;j<=jMax;j++)
16 |         // 装不了的时候，把下一行抄上来，使用其所对应情况的最优解
17 |             m[i][j]=m[i+1][j];
18 |         for(int j=w[i];j<=c;j++)
19 |         // 能装的时候，考虑一下是不是装了（下一行背包剩余空间最优解+v[i]）还没有不装（下方格子最优解）大
20 |             m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]);
21 |     }
22 |     // 第1行只算最后一列，单拎出来
23 |     m[1][c]=m[2][c];
24 |     if(c>w[1])
25 |         m[1][c]=max(m[1][c],m[2][c-w[1]]+v[1]);
26 | }
27 | 
28 | template<typename Type>
29 | void Traceback(Type** m,int* w,int c,int n,int* x){
30 |     for(int i=1;i<n;i++){
31 |         // 如果是从下一行转移上来的，也就是没装，记作0
32 |         if(m[i][c]==m[i+1][c])
33 |             x[i]=0;
34 |         // 如果不是，记作1
35 |         else{
36 |             x[i]=1;
37 |             c-=w[i];
38 |         }
39 |     }
40 |     x[n]=(m[n][c])?1:0;
41 | }
42 | 
43 | bool PrintMatrix(int **m,int r,int c,int* v,int* w){
44 |     printf("  v  w    ");
45 |     for(int i=0;i<=c;i++)
46 |         printf("%4d",i);
47 |     printf("\n");
48 |     printf("           ");
49 |     for (int i=0;i<=c;i++)
50 |         printf("____");
51 |     printf("\n");
52 |     for (int i=1;i<=r;i++){
53 |         printf("%3d%3d%4d|",v[i],w[i],i);
54 |         for (int j=0;j<=c;j++)
55 |             if(j==w[i])
56 |                 printf(" [%2d",m[i][j]);
57 |             else
58 |                 printf("%4d",m[i][j]);
59 |         printf("\n");
60 |     }
61 |     return true;
62 | }
63 | 
64 | int main(){
65 |     const int n=5;
66 |     const int c=10;
67 |     // 写到这里才发现书上对所有一维数组从1开始数的好处，如果频繁在数组“从0起”和矩阵“从1起”间切换确实是一件让人很不舒服的事情
68 |     // 所以以后干脆都从1开始好了，在oj上输入的时候直接i=1配&w[i]或者i=0配&w[i+1]
69 |     // int w[n+1]={0,2,2,6,5,4};
70 |     // int v[n+1]={0,6,3,5,4,6};
71 |     int w[n+1]={0,1,5,4,2,2};
72 |     int v[n+1]={0,4,6,4,3,2};
73 |     int m[n+1][c+1]={0};
74 |     int* pm[n+1];
75 |     for(int i=0;i<(n+1);i++)
76 |         pm[i]=m[i];
77 |     int x[n+1]={0};
78 |     Knapsack(v,w,c,n,pm);
79 |     PrintMatrix(pm,n,c,v,w);
80 |     Traceback(pm,w,c,n,x);
81 |     printf("x=(%d",x[1]);
82 |     for(int i=2;i<=n;i++)
83 |         printf(",%d",x[i]);
84 |     printf(")");
85 |     return 0;
86 | }


--------------------------------------------------------------------------------
/P96_GreedySelector.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | // #include <cstring>
 3 | #include <algorithm>
 4 | using namespace std;
 5 | // 不直接对数组排序，而是按排序标准对下标排序，这样可以达到同时排序多个数组的效果（保留数组间原本的同下标映射关系）
 6 | // int arr[5]=    {   4,   1,   3,   6,   2};
 7 | // string arr1[5]={"a1","b1","c1","d1","e1"};
 8 | 
 9 | // int indices[5]={0,1,2,3,4};
10 | // sort(indices, indices+5, SortIndices(arr));
11 | // int indices[5]={1,4,2,0,3}; //排序完应该是这样的
12 | 
13 | // arr[indices[i]]与arr1[indices[i]]仍有映射关系
14 | 
15 | class SortIndices{
16 | private:
17 |     int* mparr;
18 | public:
19 |     SortIndices(int* parr)
20 |     :mparr(parr)
21 |     {}
22 |     bool operator()(int i,int j)const{
23 |         return mparr[i]<mparr[j];
24 |     }
25 | };
26 | 
27 | void GreedySelector(int n,int s[],int f[],bool A[],int indices[]){
28 |     // @param s start 
29 |     // @param t final
30 |     A[1]=true;
31 |     int j=1;// 正进行的活动
32 |     for(int i=2;i<=n;i++){
33 |         if(f[indices[j]]<=s[indices[i]]){//if(f[j]<=s[i]){
34 |             A[i]=true;
35 |             j=i;
36 |         }
37 |         else
38 |             A[i]=false;
39 |     }
40 | }
41 | int main(){
42 |     const int N=11;
43 |     // int s[N+1]={0,1,3,0,5,3,5,6,8,8,2,12};
44 |     // int f[N+1]={0,4,5,6,7,8,9,10,11,12,13,14};
45 |     int s[N+1]={0,5,0,3,5,3,1,8,6,8,12,2};
46 |     int f[N+1]={0,9,6,5,7,8,4,11,10,12,14,13};
47 |     bool A[N+1]={false};
48 |     // memset(A,false,sizeof(A[0]));
49 | 
50 |     int indices[N+1]={0,1,2,3,4,5,6,7,8,9,10,11};
51 |     sort(indices+1, indices+N+1, SortIndices(f));
52 | 
53 |     printf("i    |");
54 |     for(int i=1;i<=N;i++)
55 |         printf("%4d",indices[i]);
56 |     printf("\n");
57 | 
58 |     printf("s[i] |");
59 |     for(int i=1;i<=N;i++)
60 |         printf("%4d",s[indices[i]]);
61 |     printf("\n");
62 | 
63 |     printf("f[i] |");
64 |     for(int i=1;i<=N;i++)
65 |         printf("%4d",f[indices[i]]);
66 |     printf("\n");
67 | 
68 |     GreedySelector(N,s,f,A,indices);
69 | 
70 |     printf("A[i] |");
71 |     for(int i=1;i<=N;i++)
72 |         printf("%4d",A[i]);
73 |     printf("\n");
74 | 
75 |     printf("E={%d",indices[1]);  // 第一个活动必被选中
76 |     for(int i=2;i<=N;i++)
77 |         if(A[i]==true)
78 |             printf(",%d",indices[i]);
79 |     printf("}");
80 |     return 0;
81 | }


--------------------------------------------------------------------------------
/README.assets/0-1背包问题1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/0-1背包问题1.png


--------------------------------------------------------------------------------
/README.assets/0-1背包问题2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/0-1背包问题2.png


--------------------------------------------------------------------------------
/README.assets/0-1背包问题3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/0-1背包问题3.png


--------------------------------------------------------------------------------
/README.assets/图像压缩1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/图像压缩1.png


--------------------------------------------------------------------------------
/README.assets/图像压缩2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/图像压缩2.png


--------------------------------------------------------------------------------
/README.assets/图像压缩3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/图像压缩3.png


--------------------------------------------------------------------------------
/README.assets/快速排序1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/快速排序1.png


--------------------------------------------------------------------------------
/README.assets/快速排序2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/快速排序2.png


--------------------------------------------------------------------------------
/README.assets/快速排序3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/快速排序3.png


--------------------------------------------------------------------------------
/README.assets/快速排序4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/快速排序4.png


--------------------------------------------------------------------------------
/README.assets/最优装载1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最优装载1.png


--------------------------------------------------------------------------------
/README.assets/最优装载2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最优装载2.png


--------------------------------------------------------------------------------
/README.assets/最优装载3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最优装载3.png


--------------------------------------------------------------------------------
/README.assets/最大子段和1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最大子段和1.png


--------------------------------------------------------------------------------
/README.assets/最大子段和2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最大子段和2.png


--------------------------------------------------------------------------------
/README.assets/最大子段和3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最大子段和3.png


--------------------------------------------------------------------------------
/README.assets/最大子段和4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最大子段和4.png


--------------------------------------------------------------------------------
/README.assets/最长公共子序列1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最长公共子序列1.png


--------------------------------------------------------------------------------
/README.assets/最长公共子序列2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最长公共子序列2.png


--------------------------------------------------------------------------------
/README.assets/最长公共子序列3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/最长公共子序列3.png


--------------------------------------------------------------------------------
/README.assets/活动安排问题1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/活动安排问题1.png


--------------------------------------------------------------------------------
/README.assets/活动安排问题2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/活动安排问题2.png


--------------------------------------------------------------------------------
/README.assets/活动安排问题3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/活动安排问题3.png


--------------------------------------------------------------------------------
/README.assets/电路布线1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/电路布线1.png


--------------------------------------------------------------------------------
/README.assets/电路布线2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/电路布线2.png


--------------------------------------------------------------------------------
/README.assets/电路布线3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/电路布线3.png


--------------------------------------------------------------------------------
/README.assets/电路布线4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/电路布线4.png


--------------------------------------------------------------------------------
/README.assets/矩阵连乘问题1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/矩阵连乘问题1.png


--------------------------------------------------------------------------------
/README.assets/矩阵连乘问题2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/矩阵连乘问题2.png


--------------------------------------------------------------------------------
/README.assets/矩阵连乘问题3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/矩阵连乘问题3.png


--------------------------------------------------------------------------------
/README.assets/矩阵连乘问题4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WanpengXu/Computer-Algorithms/e86f25bb938be43400add34e7707974f268e6909/README.assets/矩阵连乘问题4.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Computer-Algorithms
 2 | 王晓东版《计算机算法设计与分析（第五版）》代码实现（C++, python 第五学期结束后有极小可能补充java实现）  
 3 | 提供了书中算法的实现并对一些错误进行了修正，提供了适用于书中算法函数调用格式的样例并**增加了过程（演算步骤）的打印**，样例来自书中或中国矿业大学（CUMT）计算机学院PPT，
 4 | 适用于中国矿业大学计算机学院开设的以下课程：
 5 | 1. 算法设计与分析A
 6 | 2. 算法设计与分析B
 7 | 3. 算法导论
 8 | 4. 算法概论
 9 | 
10 | ## Chap2 递归与分治策略
11 | ## 快速排序
12 | ### 例题
13 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F1.png)
14 | ### 答案
15 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F2.png)
16 | ### 运行结果
17 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F3.png)
18 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F4.png)
19 | 
20 | ## Chap3 动态规划
21 | ## 矩阵连乘问题
22 | ### 例题
23 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E7%9F%A9%E9%98%B5%E8%BF%9E%E4%B9%98%E9%97%AE%E9%A2%981.png)
24 | ### 答案
25 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E7%9F%A9%E9%98%B5%E8%BF%9E%E4%B9%98%E9%97%AE%E9%A2%982.png)
26 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E7%9F%A9%E9%98%B5%E8%BF%9E%E4%B9%98%E9%97%AE%E9%A2%983.png)
27 | ### 运行结果
28 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E7%9F%A9%E9%98%B5%E8%BF%9E%E4%B9%98%E9%97%AE%E9%A2%984.png)
29 | 
30 | ## 最长公共子序列
31 | ### 例题
32 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E9%95%BF%E5%85%AC%E5%85%B1%E5%AD%90%E5%BA%8F%E5%88%971.png)
33 | ### 答案
34 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E9%95%BF%E5%85%AC%E5%85%B1%E5%AD%90%E5%BA%8F%E5%88%972.png)
35 | ### 运行结果
36 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E9%95%BF%E5%85%AC%E5%85%B1%E5%AD%90%E5%BA%8F%E5%88%973.png)
37 | 
38 | ## 最大子段和
39 | ### 例题
40 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E5%A4%A7%E5%AD%90%E6%AE%B5%E5%92%8C1.png)
41 | ### 答案
42 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E5%A4%A7%E5%AD%90%E6%AE%B5%E5%92%8C2.png)
43 | ### 运行结果
44 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E5%A4%A7%E5%AD%90%E6%AE%B5%E5%92%8C3.png)
45 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E5%A4%A7%E5%AD%90%E6%AE%B5%E5%92%8C4.png)
46 | 
47 | ## 图像压缩
48 | ### 例题
49 | ![Image text](https://github.com/WanpengXu/Computer-Algorithms/blob/main/README.assets/%E5%9B%BE%E5%83%8F%E5%8E%8B%E7%BC%A91.png)
50 | ### 答案
51 | ![Image text](https://github.com/WanpengXu/Computer-Algorithms/blob/main/README.assets/%E5%9B%BE%E5%83%8F%E5%8E%8B%E7%BC%A92.png)
52 | ### 运行结果
53 | ![Image text](https://github.com/WanpengXu/Computer-Algorithms/blob/main/README.assets/%E5%9B%BE%E5%83%8F%E5%8E%8B%E7%BC%A93.png)
54 | 
55 | ## 电路布线
56 | ### 例题
57 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E7%94%B5%E8%B7%AF%E5%B8%83%E7%BA%BF1.png)
58 | ### 答案
59 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E7%94%B5%E8%B7%AF%E5%B8%83%E7%BA%BF2.png)
60 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E7%94%B5%E8%B7%AF%E5%B8%83%E7%BA%BF3.png)
61 | ### 运行结果
62 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E7%94%B5%E8%B7%AF%E5%B8%83%E7%BA%BF4.png)
63 | 
64 | ## 0-1背包问题
65 | ### 例题
66 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/0-1%E8%83%8C%E5%8C%85%E9%97%AE%E9%A2%981.png)
67 | ### 答案
68 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/0-1%E8%83%8C%E5%8C%85%E9%97%AE%E9%A2%982.png)
69 | ### 运行结果
70 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/0-1%E8%83%8C%E5%8C%85%E9%97%AE%E9%A2%983.png)
71 | 
72 | ## Chap4 贪心算法
73 | ## 活动安排问题
74 | ### 例题
75 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%B4%BB%E5%8A%A8%E5%AE%89%E6%8E%92%E9%97%AE%E9%A2%981.png)
76 | ### 答案
77 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%B4%BB%E5%8A%A8%E5%AE%89%E6%8E%92%E9%97%AE%E9%A2%982.png)
78 | ### 运行结果
79 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%B4%BB%E5%8A%A8%E5%AE%89%E6%8E%92%E9%97%AE%E9%A2%983.png)
80 | 
81 | ## 最优装载
82 | ### 例题
83 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E4%BC%98%E8%A3%85%E8%BD%BD1.png)
84 | ### 答案
85 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E4%BC%98%E8%A3%85%E8%BD%BD2.png)
86 | ### 运行结果
87 | ![Image text](https://github.com/AoiDarcy/Computer-Algorithms/blob/main/README.assets/%E6%9C%80%E4%BC%98%E8%A3%85%E8%BD%BD3.png)
88 | 


--------------------------------------------------------------------------------