├── .github
    └── workflows
    │   └── main.yml
├── README.md
├── docs
    ├── 1000 A+B=C.md
    ├── 1001 统计数字个数.md
    ├── 1002 找第2小数.md
    ├── 1003 冒泡排序.md
    ├── 1004 归并排序.md
    ├── 1005 快速排序.md
    ├── 1006 堆排序.md
    ├── 1007 最大乘积.md
    ├── 1008 拦截导弹2.md
    ├── 1009 拦截导弹1.md
    ├── 1010 二分搜素.md
    ├── 1011 最近点对.md
    ├── 1012 寻找凸包.md
    ├── 1013 逆序对.md
    ├── 1014 最大子数组和.md
    ├── 1015 天机轮廓.md
    ├── 1016 两元素和.md
    ├── 1017 电路布线.md
    ├── 1018 01背包问题2.md
    ├── 1019 01背包问题1.md
    ├── 1020 矩阵连乘.md
    ├── 1021 钢条切割.md
    ├── 1022 最长公共子序列.md
    ├── 1025 最长非降子序列.md
    ├── 1026 插入乘号.md
    ├── 1027 带权活动选择.md
    ├── 1039 拓扑排序.md
    ├── 1040 搜索二位矩阵.md
    ├── 1041 寻找两个正序数组的中位数.md
    ├── 1042 最低票价.md
    ├── 1043 鸡蛋掉落.md
    └── index.md
└── mkdocs.yml


/.github/workflows/main.yml:
--------------------------------------------------------------------------------
 1 | # This is a basic workflow to help you get started with Actions
 2 | 
 3 | name: CI
 4 | 
 5 | # Controls when the workflow will run
 6 | on:
 7 |   # Triggers the workflow on push or pull request events but only for the main branch
 8 |   push:
 9 |     branches: [ main ]
10 |   pull_request:
11 |     branches: [ main ]
12 | 
13 |   # Allows you to run this workflow manually from the Actions tab
14 |   workflow_dispatch:
15 | 
16 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel
17 | jobs:
18 |   # This workflow contains a single job called "build"
19 |   build:
20 |     # The type of runner that the job will run on
21 |     runs-on: ubuntu-latest
22 | 
23 |     # Steps represent a sequence of tasks that will be executed as part of the job
24 |     steps:
25 |       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
26 |       - uses: actions/checkout@v2
27 |       
28 |       - uses: actions/setup-python@v2
29 |         with:
30 |           python-version: 3.x
31 |       - run: pip install mkdocs
32 |       - run: pip install mkdocs-material
33 |       - run: mkdocs gh-deploy --force
34 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## 东南大学算法设计与分析课程OJ答案 
 2 | ---
 3 | 在线入口：https://zpengc.github.io/seu_monash_algorithm-design-and-analysis/
 4 | 
 5 | ---
 6 | 
 7 | ## 参考资料
 8 | - **Weight Interval Scheduling** https://courses.cs.washington.edu/courses/cse521/13wi/slides/06dp-sched.pdf
 9 | 
10 | - **算法导论** https://edutechlearners.com/download/Introduction_to_algorithms-3rd%20Edition.pdf
11 | 
12 | - **CMSC451课程** http://www.cs.umd.edu/~jkatz/451/f21/lectures.html
13 | 
14 | - **Cloest Point Pair** 
15 |     - https://ocw.tudelft.nl/wp-content/uploads/Algoritmiek_Closest_Pair_of_Points.pdf
16 |     - http://people.csail.mit.edu/indyk/6.838-old/handouts/lec17.pdf
17 |     
18 | - **摊还分析**https://sites.cs.ucsb.edu/~suri/cs130a/Amortized.pdf
19 | 
20 | - **black and white color problem of tree nodes** 
21 | 
22 |     - https://web.stanford.edu/class/cs97si/04-dynamic-programming.pdf
23 |     - https://blog.csdn.net/weixin_30672295/article/details/94898224
24 | 
25 | - 
26 | 
27 |     
28 | 
29 |     
30 | 
31 | 


--------------------------------------------------------------------------------
/docs/1000 A+B=C.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include <iostream>
 3 | using namespace std;
 4 | int main() {
 5 |     int n, a, b;
 6 |     cin >> n;
 7 |     for(int i=0; i<n; i++) {
 8 |         cin >> a >> b;
 9 |         cout << a + b << endl;
10 |     }
11 |     return 0;
12 | }
13 | ```


--------------------------------------------------------------------------------
/docs/1001 统计数字个数.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include <iostream>
 3 | #include <string>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n;
10 |     cin>>n;
11 |     string str;
12 |     getline(cin, str);
13 |     for(int i=0;i<n;i++)
14 |     {
15 |         getline(cin, str);
16 |         int num=0;
17 |         for(int j=0;j<str.size();j++)
18 |         {
19 |             if(str[j]>='0' && str[j]<='9')
20 |             {
21 |                 num++;
22 |             }
23 |         }
24 |         cout<<num<<endl;
25 |     }
26 |     return 0;
27 | }
28 | ```


--------------------------------------------------------------------------------
/docs/1002 找第2小数.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include <iostream>
 3 | #include<limits.h>
 4 | using namespace std;
 5 | 
 6 | int f(int a[], int size)
 7 | {
 8 |     int first, second;
 9 |     if (size < 2)
10 |     {
11 |         return 0;
12 |     }
13 |     first = second = INT_MAX;
14 |     for(int i=0;i<size;i++)
15 |     {
16 |         if(a[i]<first)
17 |         {
18 |             second = first;
19 |             first = a[i];
20 |         }
21 |         else if(a[i]<second && a[i]!=first)
22 |         {
23 |             second = a[i];
24 |         }
25 |     }
26 |     return second;
27 | }
28 | 
29 | 
30 | int main()
31 | {
32 |     int n;
33 |     cin>>n;
34 |     for(int i=0;i<n;i++)
35 |     {
36 |         int size;
37 |         cin>>size;
38 |         int a[size];
39 |         for(int j=0; j<size; j++)
40 |             cin >> a[j];
41 |         cout<<f(a, size)<<endl;
42 |     }
43 |     return 0;
44 | }
45 | ```


--------------------------------------------------------------------------------
/docs/1003 冒泡排序.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | void bubble_sort_one_iter(int a[], int size)
 6 | {
 7 |     for(int i=0;i<size-1;i++)
 8 |     {
 9 |         if(a[i]>a[i+1])
10 |         {
11 |             swap(a[i], a[i+1]);
12 |         }
13 |     }
14 |     for(int i=0;i<size;i++)
15 |     {
16 |         cout<<a[i]<<" ";
17 |     }
18 |     cout<<endl;
19 | }
20 | 
21 | int main()
22 | {
23 |     int n;
24 |     cin>>n;
25 |     for(int i=0;i<n;i++)
26 |     {
27 |         int size;
28 |         cin>>size;
29 |         int a[size];
30 |         for(int i=0;i<size;i++)
31 |         {
32 |             cin>>a[i];
33 |         }
34 |         bubble_sort_one_iter(a, size);
35 |     }
36 |     return 0;
37 | }
38 | ```


--------------------------------------------------------------------------------
/docs/1004 归并排序.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | int temp[1000];
 6 | int res[1000];
 7 | 
 8 | void merge(int a[], int low, int middle, int high){
 9 |     
10 |     int i=low,k=low,j=middle+1;
11 |     while(i <= middle && j <= high){
12 |          if(a[i]<=a[j])
13 |              temp[k++]=a[i++];
14 |         else temp[k++]=a[j++];
15 |     }
16 |     while(i<=middle)
17 |         temp[k++]=a[i++];
18 |     while(j<=high)
19 |         temp[k++]=a[j++];
20 |     for(k=low;k<=high;k++)
21 |        a[k] = temp[k];
22 |     return;
23 |         
24 | }
25 | 
26 | void merge_sort(int a[], int low, int high, int level)
27 | {
28 |     if (low >= high)
29 |     {
30 |         return;
31 |     }
32 |     int middle = (low+high)/2;
33 |     merge_sort(a, low, middle, level+1);
34 |     merge_sort(a, middle+1, high, level+1);
35 |     merge(a, low, middle, high);
36 |     if(level==3)
37 |     {
38 |         for(int i=low;i<=high;i++)
39 |         {
40 |             res[i] = a[i];
41 |         }
42 |     }
43 | }
44 | 
45 | void print(int a[], int size)
46 | {
47 |     for(int i=0;i<size;i++)
48 |     {
49 |         cout<<a[i]<<" ";
50 |     }
51 |     cout<<endl;
52 | }
53 | 
54 | int main()
55 | {
56 |     int n;
57 |     cin>>n;
58 |     for(int i=0;i<n;i++)
59 |     {
60 |         int size;
61 |         cin>>size;
62 |         int a[size];
63 |         for(int i=0;i<size;i++)
64 |         {
65 |             cin>>a[i];
66 |         }
67 |         merge_sort(a, 0, size-1, 1);
68 |         print(res, size);
69 |     }
70 |     return 0;
71 | }
72 | 
73 | ```


--------------------------------------------------------------------------------
/docs/1005 快速排序.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include <iostream>
 3 | #include<limits.h>
 4 | using namespace std;
 5 | 
 6 | int f(int a[], int size)
 7 | {
 8 |     int first, second;
 9 |     if (size < 2)
10 |     {
11 |         return 0;
12 |     }
13 |     first = second = INT_MAX;
14 |     for(int i=0;i<size;i++)
15 |     {
16 |         if(a[i]<first)
17 |         {
18 |             second = first;
19 |             first = a[i];
20 |         }
21 |         else if(a[i]<second && a[i]!=first)
22 |         {
23 |             second = a[i];
24 |         }
25 |     }
26 |     return second;
27 | }
28 | 
29 | 
30 | int main()
31 | {
32 |     int n;
33 |     cin>>n;
34 |     for(int i=0;i<n;i++)
35 |     {
36 |         int size;
37 |         cin>>size;
38 |         int a[size];
39 |         for(int j=0; j<size; j++)
40 |             cin >> a[j];
41 |         cout<<f(a, size)<<endl;
42 |     }
43 |     return 0;
44 | }
45 | ```


--------------------------------------------------------------------------------
/docs/1006 堆排序.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | void heapify(int a[], int size, int idx)
 6 | {
 7 |     int smallest = idx;
 8 |     int left = idx*2+1;
 9 |     int right = idx*2+2;
10 |     // 优先向左子树调整
11 |     if(left<size && a[left]<a[smallest])
12 |     {
13 |         smallest = left;
14 |     }
15 |     if(right<size && a[right]<a[smallest])
16 |     {
17 |         smallest = right;
18 |     }
19 |     if(smallest!=idx)
20 |     {
21 |         swap(a[idx], a[smallest]);
22 |         // 继续调整以孩子为根节点的子树
23 |         heapify(a, size, smallest);
24 |     }
25 |     
26 | }
27 | 
28 | void heap_sort(int a[], int size)
29 | {
30 |     // 建堆
31 |     for(int i=size/2-1;i>=0;i--)
32 |     {
33 |         heapify(a, size, i);     
34 |     }
35 | }
36 | 
37 | void print(int a[], int size)
38 | {
39 |     for(int i=0;i<size;i++)
40 |     {
41 |         cout<<a[i]<<" ";
42 |     }
43 |     cout<<endl;
44 | }
45 | 
46 | int main()
47 | {
48 |     int n;
49 |     cin>>n;
50 |     for(int i=0;i<n;i++)
51 |     {
52 |         int size;
53 |         cin>>size;
54 |         int a[size];
55 |         for(int i=0;i<size;i++)
56 |         {
57 |             cin>>a[i];
58 |         }
59 |         heap_sort(a, size);
60 |         print(a, size);
61 |     }
62 |     return 0;
63 | }
64 | 
65 | ```


--------------------------------------------------------------------------------
/docs/1007 最大乘积.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<cstring>
 4 | #include<string>
 5 | 
 6 | using namespace std;
 7 | 
 8 | //返回v[start]~v[end]这些数字所表示的数值
 9 | long nums(int v[],int start,int end){
10 |     long num=v[start];
11 |     for(int k=start+1;k<=end;k++){
12 |         num = num*10+v[k];
13 |     }
14 |     return num;
15 | }
16 | 
17 | long MaxMult(int v[], int bits,int k){
18 |     // 原数字0~bits-1位中加入k个乘号所得表达式的最大值
19 |     long dp[bits][k+1];
20 | 	memset(dp,0,sizeof(dp));
21 |     for(int i=0; i<bits; i++)
22 |         dp[i][0] = nums(v,0,i); //不划分就是前i个一起构成一个数
23 | 
24 |     //在v[0]~v[i]之间插入j个乘号
25 |     for(int i=0; i<bits; i++)
26 |     {
27 |         //显然j的个数不能超过i
28 |         for(int j=1; j<=k&&j<i+1; j++)
29 |         //插入乘号的位置为k
30 |             for(int k=0;k<i;k++)
31 |                 dp[i][j] = max(dp[i][j],dp[k][j-1]*nums(v,k+1,i));
32 |     }
33 |     return dp[bits-1][k];
34 | 
35 | }
36 | 
37 | 
38 | int main() {
39 |     int n;
40 |     cin >> n;
41 |     for(int i=0; i<n; i++){
42 |         int bits;
43 |         int k;
44 |         cin>>bits>>k;
45 |         string s;
46 |         cin >> s;
47 |         int v[bits];
48 |         for(int j=0;j<bits;j++)
49 |             v[j] = s[j]-'0';
50 |         cout << MaxMult(v,bits,k) << endl;
51 |     }   
52 |     return 0;
53 | }
54 | ```


--------------------------------------------------------------------------------
/docs/1008 拦截导弹2.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | using namespace std;
 4 | 
 5 | // Longest Decreasing Subsequence problem
 6 | int LDS(int a[], int num)
 7 | {
 8 |     int lds[num];
 9 |     int max = 0;
10 |     for (int i = 0; i < num; i++)
11 |     {
12 |         lds[i] = 1;
13 |     }
14 |     for (int i = 1; i < num; i++)
15 |     {
16 |         for (int j = 0; j < i; j++)
17 |         {
18 |             if (a[i] < a[j] && lds[i] < lds[j] + 1)
19 |             {
20 |                 lds[i] = lds[j] + 1;
21 |             }
22 |         }
23 |     }
24 |     for (int i = 0; i < num; i++)
25 |     {
26 |         if (max < lds[i])
27 |         {
28 |             max = lds[i];
29 |         }
30 |     }
31 |     return max;
32 | }
33 | 
34 | int greedy(int a[], int num)
35 | {
36 |     // height[i]表示第i个系统能够发射的最大高度
37 |     int height[num];
38 |     // count用来计数
39 |     int count=0,min_idx=0;
40 | 
41 |     height[0] = a[0];
42 |     for(int i=1;i<num;i++)
43 |     {
44 |         if(a[i]>height[count]){
45 |             height[++count]=a[i];
46 |         }
47 |         else{
48 |             min_idx=count;
49 |             for(int j=count;j>=0;j--)
50 |             {
51 |                 //所有系统中发射高度最矮的那套来拦截
52 |                 if(height[j]<height[min_idx] && height[j]>=a[i])
53 |                 {
54 |                     min_idx=j;
55 |                 }
56 |             }
57 |             height[min_idx]=a[i];
58 |         }
59 |     }
60 |     return count+1;
61 | }
62 | 
63 | int main() {
64 |     int n;
65 |     cin >> n;
66 |     for(int i=0; i<n; i++){
67 |         int num;
68 |         cin>>num;
69 |         int a[num];
70 |         for(int j=0;j<num;j++)
71 |         {
72 |             cin>>a[j];
73 |         }
74 |         cout<<LDS(a, num)<<" "<<greedy(a, num)<<endl;
75 |     }   
76 |     return 0;
77 | }
78 | ```


--------------------------------------------------------------------------------
/docs/1009 拦截导弹1.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | using namespace std;
 4 | 
 5 | // Longest Decreasing Subsequence problem
 6 | int LDS(int a[], int num)
 7 | {
 8 |     int lds[num];
 9 |     int max = 0;
10 |     for (int i = 0; i < num; i++)
11 |     {
12 |         lds[i] = 1;
13 |     }
14 |     for (int i = 1; i < num; i++)
15 |     {
16 |         for (int j = 0; j < i; j++)
17 |         {
18 |             if (a[i] < a[j] && lds[i] < lds[j] + 1)
19 |             {
20 |                 lds[i] = lds[j] + 1;
21 |             }
22 |         }
23 |     }
24 |     for (int i = 0; i < num; i++)
25 |     {
26 |         if (max < lds[i])
27 |         {
28 |             max = lds[i];
29 |         }
30 |     }
31 |     return max;
32 | }
33 | 
34 | 
35 | int main() {
36 |     int n;
37 |     cin >> n;
38 |     for(int i=0; i<n; i++){
39 |         int num;
40 |         cin>>num;
41 |         int a[num];
42 |         for(int j=0;j<num;j++)
43 |         {
44 |             cin>>a[j];
45 |         }
46 |         cout<<LDS(a, num)<<endl;
47 |     }   
48 |     return 0;
49 | }
50 | ```


--------------------------------------------------------------------------------
/docs/1010 二分搜素.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | using namespace std;
 4 | 
 5 | void binary_search(int a[], int low, int high, int target)
 6 | {
 7 |     int temp = a[(low+high)/2];
 8 |     while(low<=high)
 9 |     {
10 |         int mid = (low+high)/2;
11 |         if(a[mid]==target)
12 |         {
13 |             cout<<"success, father is "<<temp<<endl;
14 |             return;
15 |         }
16 |         else if(a[mid]>target)
17 |         {
18 |             high = mid-1;
19 |             temp = a[mid];
20 |         }
21 |         else
22 |         {
23 |             low = mid+1;
24 |             temp = a[mid];
25 |         }
26 |     }
27 |     cout<<"not found, father is "<<temp<<endl;
28 | }
29 | 
30 | int main() {
31 |     int n;
32 |     cin >> n;
33 |     for(int i=0; i<n; i++){
34 |         int size;
35 |         cin>>size;
36 |         int target;
37 |         cin>>target;
38 |         int a[size];
39 |         for(int j=0;j<size;j++)
40 |         {
41 |             cin>>a[j];
42 |         }
43 |         binary_search(a, 0, size-1, target);
44 |     }   
45 |     return 0;
46 | }
47 | ```


--------------------------------------------------------------------------------
/docs/1011 最近点对.md:
--------------------------------------------------------------------------------
  1 | ```
  2 | #include<iostream>
  3 | #include<cfloat>
  4 | #include<math.h>
  5 | #include<iomanip>
  6 | using namespace std;
  7 | 
  8 | struct Point
  9 | {
 10 | 	int x;
 11 |     int y;
 12 | };
 13 | 
 14 | 
 15 | // http://www.cplusplus.com/reference/cstdlib/qsort/  qsort函数需要compar函数原型
 16 | int compareX(const void* a, const void* b)
 17 | {
 18 | 	Point *p1 = (Point *)a, *p2 = (Point *)b;
 19 | 	return (p1->x != p2->x) ? (p1->x - p2->x) : (p1->y - p2->y);
 20 | }
 21 | 
 22 | int compareY(const void* a, const void* b)
 23 | {
 24 | 	Point *p1 = (Point *)a, *p2 = (Point *)b;
 25 | 	return (p1->y != p2->y) ? (p1->y - p2->y) : (p1->x - p2->x);
 26 | }
 27 | 
 28 | 
 29 | float dist(Point p1, Point p2)
 30 | {
 31 |     // 乘以1.0防止int类型溢出
 32 | 	float x = sqrt( 1.0*(p1.x - p2.x)*1.0*(p1.x - p2.x) + 1.0*(p1.y - p2.y)*1.0*(p1.y - p2.y));
 33 |     return x;
 34 | }
 35 | 
 36 | float bruteForce(Point P[], int n)
 37 | {
 38 | 	float min = FLT_MAX;
 39 | 	for (int i = 0; i < n; ++i)
 40 | 		for (int j = i+1; j < n; ++j)
 41 | 			if (dist(P[i], P[j]) < min)
 42 | 				min = dist(P[i], P[j]);
 43 | 	return min;
 44 | }
 45 | 
 46 | float min(float x, float y)
 47 | {
 48 | 	return (x < y)? x : y;
 49 | }
 50 | 
 51 | 
 52 | float stripClosest(Point strip[], int size, float d)
 53 | {
 54 | 	float min = d; 
 55 | 
 56 | 	for (int i = 0; i < size; ++i)
 57 | 		for (int j = i+1; j < size && (strip[j].y - strip[i].y) < min; ++j)
 58 | 			if (dist(strip[i],strip[j]) < min)
 59 | 				min = dist(strip[i], strip[j]);
 60 | 
 61 | 	return min;
 62 | }
 63 | 
 64 | float closestUtil(Point Px[], Point Py[], int n)
 65 | {
 66 | 	if (n <= 3)
 67 | 		return bruteForce(Px, n);
 68 | 
 69 | 	int mid = n/2;
 70 | 	Point midPoint = Px[mid];
 71 | 
 72 | 
 73 | 	Point Pyl[mid];
 74 | 	Point Pyr[n-mid]; 
 75 | 	int li = 0, ri = 0; 
 76 | 	for (int i = 0; i < n; i++)
 77 | 	{
 78 | 	if ((Py[i].x < midPoint.x || (Py[i].x == midPoint.x && Py[i].y < midPoint.y)) && li<mid)
 79 | 		Pyl[li++] = Py[i];
 80 | 	else
 81 | 		Pyr[ri++] = Py[i];
 82 | 	}
 83 | 
 84 | 	float dl = closestUtil(Px, Pyl, mid);
 85 | 	float dr = closestUtil(Px + mid, Pyr, n-mid);
 86 | 
 87 | 	float d = min(dl, dr);
 88 | 
 89 | 	Point strip[n];
 90 | 	int j = 0;
 91 | 	for (int i = 0; i < n; i++)
 92 | 		if (abs(Py[i].x - midPoint.x) < d)
 93 | 			strip[j] = Py[i], j++;
 94 | 
 95 | 	return stripClosest(strip, j, d);
 96 | }
 97 | 
 98 | float closest(Point P[], int n)
 99 | {
100 | 	Point Px[n];
101 | 	Point Py[n];
102 | 	for (int i = 0; i < n; i++)
103 | 	{
104 | 		Px[i] = P[i];
105 | 		Py[i] = P[i];
106 | 	}
107 | 
108 | 	qsort(Px, n, sizeof(Point), compareX);
109 | 	qsort(Py, n, sizeof(Point), compareY);
110 | 
111 | 	return closestUtil(Px, Py, n);
112 | }
113 | 
114 | 
115 | 
116 | 
117 | int main() {
118 |     int n;
119 |     cin>>n;
120 |     for(int i=0;i<n;i++)
121 |     {
122 |         int size;
123 |         cin>>size;
124 |         Point P[size];
125 |         for(int i=0;i<size;i++)
126 |         {
127 |             Point p;
128 |             cin>>p.x;
129 |             cin>>p.y;
130 |             P[i] = p;
131 |         }
132 | 
133 |         cout<<fixed<<setprecision(2)<<closest(P, size) << endl;
134 |     }
135 |    return 0;
136 | }
137 | ```


--------------------------------------------------------------------------------
/docs/1012 寻找凸包.md:
--------------------------------------------------------------------------------
  1 | ```
  2 | #include<iostream>
  3 | #include<vector>
  4 | #include <stack>
  5 | using namespace std;
  6 | 
  7 | struct Point
  8 | {
  9 |     int x, y;
 10 | };
 11 | 
 12 | Point p0;
 13 |  
 14 | // A utility function to find next to top in a stack
 15 | Point nextToTop(stack<Point> &S)
 16 | {
 17 |     Point p = S.top();
 18 |     S.pop();
 19 |     Point res = S.top();
 20 |     S.push(p);
 21 |     return res;
 22 | }
 23 |  
 24 | // A utility function to swap two points
 25 | void swap(Point &p1, Point &p2)
 26 | {
 27 |     Point temp = p1;
 28 |     p1 = p2;
 29 |     p2 = temp;
 30 | }
 31 |  
 32 | // A utility function to return square of distance
 33 | // between p1 and p2
 34 | int distSq(Point p1, Point p2)
 35 | {
 36 |     return (p1.x - p2.x)*(p1.x - p2.x) +
 37 |           (p1.y - p2.y)*(p1.y - p2.y);
 38 | }
 39 |  
 40 | // To find orientation of ordered triplet (p, q, r).
 41 | // The function returns following values
 42 | // 0 --> p, q and r are collinear
 43 | // 1 --> Clockwise
 44 | // 2 --> Counterclockwise
 45 | int orientation(Point p, Point q, Point r)
 46 | {
 47 |     int val = (q.y - p.y) * (r.x - q.x) -
 48 |               (q.x - p.x) * (r.y - q.y);
 49 |  
 50 |     if (val == 0) return 0;  // collinear
 51 |     return (val > 0)? 1: 2; // clock or counterclock wise
 52 | }
 53 |  
 54 | // A function used by library function qsort() to sort an array of
 55 | // points with respect to the first point
 56 | int compare(const void *vp1, const void *vp2)
 57 | {
 58 |    Point *p1 = (Point *)vp1;
 59 |    Point *p2 = (Point *)vp2;
 60 |  
 61 |    // Find orientation
 62 |    int o = orientation(p0, *p1, *p2);
 63 |    if (o == 0)
 64 |      return (distSq(p0, *p2) >= distSq(p0, *p1))? -1 : 1;
 65 |  
 66 |    return (o == 2)? -1: 1;
 67 | }
 68 |  
 69 | // Prints convex hull of a set of n points.
 70 | void convexHull(Point points[], int n ,int id)
 71 | {
 72 |    // Find the bottommost point
 73 |    int ymin = points[0].y, min = 0;
 74 |    for (int i = 1; i < n; i++)
 75 |    {
 76 |      int y = points[i].y;
 77 |  
 78 |      // Pick the bottom-most or chose the left
 79 |      // most point in case of tie
 80 |      if ((y < ymin) || (ymin == y &&
 81 |          points[i].x < points[min].x))
 82 |         ymin = points[i].y, min = i;
 83 |    }
 84 |  
 85 |    // Place the bottom-most point at first position
 86 |    swap(points[0], points[min]);
 87 |  
 88 |    // Sort n-1 points with respect to the first point.
 89 |    // A point p1 comes before p2 in sorted output if p2
 90 |    // has larger polar angle (in counterclockwise
 91 |    // direction) than p1
 92 |    p0 = points[0];
 93 |    qsort(&points[1], n-1, sizeof(Point), compare);
 94 |  
 95 |    // If two or more points make same angle with p0,
 96 |    // Remove all but the one that is farthest from p0
 97 |    // Remember that, in above sorting, our criteria was
 98 |    // to keep the farthest point at the end when more than
 99 |    // one points have same angle.
100 |    int m = 1; // Initialize size of modified array
101 |    for (int i=1; i<n; i++)
102 |    {
103 |        // Keep removing i while angle of i and i+1 is same
104 |        // with respect to p0
105 |        while (i < n-1 && orientation(p0, points[i],
106 |                                     points[i+1]) == 0)
107 |           i++;
108 |  
109 |  
110 |        points[m] = points[i];
111 |        m++;  // Update size of modified array
112 |    }
113 |  
114 |    // If modified array of points has less than 3 points,
115 |    // convex hull is not possible
116 |    if (m < 3) return;
117 |  
118 |    // Create an empty stack and push first three points
119 |    // to it.
120 |    stack<Point> S;
121 |    S.push(points[0]);
122 |    S.push(points[1]);
123 |    S.push(points[2]);
124 |  
125 |    // Process remaining n-3 points
126 |    for (int i = 3; i < m; i++)
127 |    {
128 |       // Keep removing top while the angle formed by
129 |       // points next-to-top, top, and points[i] makes
130 |       // a non-left turn
131 |       while (S.size()>1 && orientation(nextToTop(S), S.top(), points[i]) != 2)
132 |          S.pop();
133 |       S.push(points[i]);
134 |    }
135 |  
136 |    // Now stack has the output points, print contents of stack
137 |    cout<<"case "<<id+1<<":"<<endl;
138 |    stack<Point> ss;
139 |    while (!S.empty())
140 |    {
141 |        Point p = S.top();
142 |        ss.push(p);
143 |        S.pop();
144 |    }
145 |    while (!ss.empty())
146 |    {
147 |        Point p = ss.top();
148 |        cout << p.x << " " << p.y << endl;
149 |        ss.pop();
150 |    }
151 | }
152 | 
153 | int main()
154 | {
155 |     int n;
156 |     cin>>n;
157 |     for(int i=0;i<n;i++)
158 |     {
159 |         int size;
160 |         cin>>size;
161 |         Point p[size];
162 |         for(int j=0;j<size;j++)
163 |         {
164 |             cin>>p[j].x;
165 |             cin>>p[j].y;
166 |         }
167 |         convexHull(p, size, i);
168 |     }
169 |     return 0;
170 | }
171 | ```


--------------------------------------------------------------------------------
/docs/1013 逆序对.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | using namespace std;
 4 | 
 5 | int merge(int arr[], int temp[], int left, int mid,
 6 |           int right)
 7 | {
 8 |     int i, j, k;
 9 |     int inv_count = 0;
10 |  
11 |     i = left; /* i is index for left subarray*/
12 |     j = mid; /* j is index for right subarray*/
13 |     k = left; /* k is index for resultant merged subarray*/
14 |     while ((i <= mid - 1) && (j <= right)) {
15 |         if (arr[i] <= arr[j]) {
16 |             temp[k++] = arr[i++];
17 |         }
18 |         else {
19 |             temp[k++] = arr[j++];
20 |  
21 |             inv_count = inv_count + (mid - i);
22 |         }
23 |     }
24 |  
25 |     while (i <= mid - 1)
26 |         temp[k++] = arr[i++];
27 |  
28 |     while (j <= right)
29 |         temp[k++] = arr[j++];
30 |  
31 |     for (i = left; i <= right; i++)
32 |         arr[i] = temp[i];
33 |  
34 |     return inv_count;
35 | }
36 | 
37 | int _mergeSort(int arr[], int temp[], int left, int right)
38 | {
39 |     int inv_count = 0;
40 |     if (right > left) {
41 |         int mid = (right + left) / 2;
42 |  
43 |         inv_count += _mergeSort(arr, temp, left, mid);
44 |         inv_count += _mergeSort(arr, temp, mid + 1, right);
45 |  
46 |         inv_count += merge(arr, temp, left, mid + 1, right);
47 |     }
48 |     return inv_count;
49 | }
50 | 
51 | int mergeSort(int arr[], int array_size)
52 | {
53 |     int temp[array_size];
54 |     return _mergeSort(arr, temp, 0, array_size - 1);
55 | }
56 | 
57 | int main()
58 | {
59 |     int n;
60 |     cin>>n;
61 |     for(int i=0;i<n;i++)
62 |     {
63 |         int size;
64 |         cin>>size;
65 |         int arr[size];
66 |         for(int j=0;j<size;j++)
67 |         {
68 |             cin>>arr[j];
69 |         }
70 |         cout<<mergeSort(arr, size)<<endl;
71 |     }
72 |     return 0;
73 | }
74 | ```


--------------------------------------------------------------------------------
/docs/1014 最大子数组和.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<climits>
 4 | using namespace std;
 5 | 
 6 | int func(int a[], int size)
 7 | {
 8 |     int res = INT_MIN;
 9 |     int max_end_here = 0;
10 |     for(int i=0;i<size;i++)
11 |     {
12 |         max_end_here += a[i];
13 |         if(max_end_here > res)
14 |         {
15 |             res = max_end_here;
16 |         }
17 |         if(max_end_here < 0)
18 |         {
19 |             max_end_here = 0;
20 |         }
21 |     }
22 |     return res;
23 | }
24 | 
25 | int main()
26 | {
27 |     int n;
28 |     cin>>n;
29 |     for(int i=0;i<n;i++)
30 |     {
31 |         int size;
32 |         cin>>size;
33 |         int arr[size];
34 |         for(int j=0;j<size;j++)
35 |         {
36 |             cin>>arr[j];
37 |         }
38 |         cout<<func(arr, size)<<endl;
39 |     }
40 |     return 0;
41 | }
42 | ```


--------------------------------------------------------------------------------
/docs/1015 天机轮廓.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<climits>
 4 | #include<vector>
 5 | #include<set>
 6 | #include<algorithm>
 7 | using namespace std;
 8 | 
 9 | vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {
10 |         // use walls to record buildings; left wall is an insertion event, and right wall is a deletion event
11 |         vector<pair<int, int>> walls, ans;                  // first: x, second: height
12 |         for (auto b : buildings) {
13 |             // push in left / right walls
14 |             // let left wall has negative height to ensure left wall goes to multiset first if with same 'x' as right wall
15 |             walls.push_back(make_pair(b[0], -b[2]));
16 |             walls.push_back(make_pair(b[1], b[2]));
17 |         }
18 |         sort(walls.begin(), walls.end());                   // sort walls
19 |         
20 |         multiset<int> leftWallHeights = {0};                // keep left wall heights sorted; dummy '0' for convenience
21 |         int top = 0;                                        // current max height among leftWallHeights
22 |         for (auto w : walls) {
23 |             if (w.second < 0) {                             // it's a left wall, insert the height
24 |                 leftWallHeights.insert(-w.second);
25 |             } else {                                        // it's a right wall, delete the height
26 |                 leftWallHeights.erase(leftWallHeights.find(w.second));
27 |             }
28 |             
29 |             if (*leftWallHeights.rbegin() != top) {         // mark a skyline point if top changes
30 |                 ans.push_back(make_pair(w.first, top = *leftWallHeights.rbegin()));
31 |             }
32 |         }
33 |         
34 |         return ans;
35 | }
36 | 
37 | void func(vector<vector<int>> buildings)
38 | {
39 |     vector<pair<int, int>> ans = getSkyline(buildings);
40 |     for (auto it : ans) {
41 |         cout<<it.first<<" "<<it.second<<endl;
42 |     }
43 | }
44 | 
45 | int main()
46 | {
47 |     const int tuple_size = 3;
48 |     int n;
49 |     cin>>n;
50 |     vector<vector<int>> buildings;
51 |     for(int i=0;i<n;i++)
52 |     {
53 |         vector<int> building(3);
54 |         for(int j=0;j<tuple_size;j++)
55 |         {
56 |             cin>>building[j];
57 |         }
58 |         buildings.push_back(building);
59 |     }
60 |     func(buildings);
61 |     return 0;
62 | }
63 | ```


--------------------------------------------------------------------------------
/docs/1016 两元素和.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<unordered_set>
 4 | using namespace std;
 5 | 
 6 | 
 7 | 
 8 | bool func(int arr[], int size, int target)
 9 | {
10 |     unordered_set<int> s;
11 |     for(int i=0;i<size;i++)
12 |     {
13 |         int remain = target - arr[i];
14 |         if(s.find(remain)!=s.end())
15 |         {
16 |             return true;
17 |         }
18 |         else
19 |         {
20 |             s.insert(arr[i]);
21 |         }
22 |     }
23 |     return false;
24 | }
25 | 
26 | int main()
27 | {
28 |     int n;
29 |     cin>>n;
30 |     for(int i=0;i<n;i++)
31 |     {
32 |         int size, target;
33 |         cin>>size;
34 |         cin>>target;
35 |         int arr[size];
36 |         for(int j=0;j<size;j++)
37 |         {
38 |             cin>>arr[j];
39 |         }
40 |         if(func(arr, size, target))
41 |         {
42 |             cout<<"yes"<<endl;
43 |         }
44 |         else
45 |         {
46 |             cout<<"no"<<endl;
47 |         }
48 |     }
49 |     return 0;
50 | }
51 | ```


--------------------------------------------------------------------------------
/docs/1017 电路布线.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | using namespace std;
 4 | 
 5 | 
 6 | int merge(int array[], int const left, int const mid, int const right)
 7 | {
 8 | 	int s1 = mid - left + 1;
 9 | 	int s2 = right - mid;
10 | 
11 | 	int *leftArray = new int[s1],
12 | 		*rightArray = new int[s2];
13 | 
14 | 	for (int i = 0; i < s1; i++)
15 | 		leftArray[i] = array[left + i];
16 | 	for (int j = 0; j < s2; j++)
17 | 		rightArray[j] = array[mid + 1 + j];
18 | 
19 | 	int indexOfSubArrayOne = 0, indexOfSubArrayTwo = 0; 
20 | 	int indexOfMergedArray = left; 
21 |     int sum=0;
22 | 	while (indexOfSubArrayOne < s1 && indexOfSubArrayTwo < s2) {
23 | 		if (leftArray[indexOfSubArrayOne] <= rightArray[indexOfSubArrayTwo]) {
24 | 			array[indexOfMergedArray] = leftArray[indexOfSubArrayOne];
25 | 			indexOfSubArrayOne++;
26 |             sum+=indexOfSubArrayTwo;
27 | 		}
28 | 		else {
29 | 			array[indexOfMergedArray] = rightArray[indexOfSubArrayTwo];
30 | 			indexOfSubArrayTwo++;
31 | 		}
32 | 		indexOfMergedArray++;
33 | 	}
34 | 	while (indexOfSubArrayOne < s1) {
35 | 		array[indexOfMergedArray] = leftArray[indexOfSubArrayOne];
36 | 		indexOfSubArrayOne++;
37 | 		indexOfMergedArray++;
38 |         sum+=indexOfSubArrayTwo;
39 | 	}
40 | 	while (indexOfSubArrayTwo < s2) {
41 | 		array[indexOfMergedArray] = rightArray[indexOfSubArrayTwo];
42 | 		indexOfSubArrayTwo++;
43 | 		indexOfMergedArray++;
44 | 	}
45 |     return sum;
46 | }
47 | 
48 | int mergeSort(int array[], int begin, int end)
49 | {
50 |     if (begin >= end)
51 |         return 0; 
52 |     int sum=0;
53 |     auto mid = (begin + end) / 2;
54 |     sum+=mergeSort(array, begin, mid);
55 |     sum+=mergeSort(array, mid + 1, end);
56 |     sum+=merge(array, begin, mid, end);
57 |     return sum;
58 | }
59 | 
60 | 
61 | int main()
62 | {
63 |     int n;
64 |     cin>>n;
65 |     for(int i=0;i<n;i++)
66 |     {
67 |         int size;
68 |         cin>>size;
69 |         int arr[size];
70 |         for(int j=0;j<size;j++)
71 |         {
72 |             cin>>arr[j];
73 |         }
74 |         cout<<mergeSort(arr, 0, size-1)<<endl;
75 |     }
76 |     return 0;
77 | }
78 | ```


--------------------------------------------------------------------------------
/docs/1018 01背包问题2.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<vector>
 4 | using namespace std;
 5 | 
 6 | int func(int weight[], int profit[], int capacity, int n_gem)
 7 | {
 8 |     vector<vector<int>> dp(n_gem+1, vector<int>(capacity+1, -1));
 9 |     for(int i=0;i<=n_gem;i++)
10 |     {
11 |         dp[i][0] = 0;
12 |     }
13 |     
14 |     for (int i=1;i<=n_gem;i++)
15 |     {
16 |         for (int j=capacity;j>=1;j--)
17 |         {
18 |             // weight, profit数组下标从0开始，所以i-1
19 |             int curr_weight = weight[i - 1];
20 |             int curr_profit = profit[i - 1];
21 |             if (j >= curr_weight && dp[i - 1][j - curr_weight] != -1)
22 |             {
23 |                 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - curr_weight] + curr_profit);
24 |             }
25 |             else 
26 |             {
27 |                 dp[i][j] = dp[i - 1][j];
28 |             }
29 |         }
30 |     }
31 |     if(dp[n_gem][capacity] == -1)
32 |     {
33 |         return 0;
34 |     }
35 |     return dp[n_gem][capacity];    
36 | }
37 | 
38 | int main() {
39 |     // 测试次数
40 |     int n_test;
41 |     cin>>n_test;
42 |     for(int i=0;i<n_test;i++)
43 |     {
44 |         // 宝石个数
45 |         int n_gem;
46 |         cin>>n_gem;
47 |         // 背包容量
48 |         int bag_capacity;
49 |         cin>>bag_capacity;
50 |         int weight[n_gem];
51 |         int profit[n_gem];
52 |         for(int i=0;i<n_gem;i++)
53 |         {
54 |             // 宝石大小
55 |             int weight_gem;
56 |             cin>>weight_gem;
57 |             // 宝石价值
58 |             int profit_gem;
59 |             cin>>profit_gem;
60 |             weight[i] = weight_gem;
61 |             profit[i] = profit_gem;
62 |         }
63 |         cout<<func(weight, profit, bag_capacity, n_gem)<<endl;
64 |     }
65 |    return 0;
66 | }
67 | ```


--------------------------------------------------------------------------------
/docs/1019 01背包问题1.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<vector>
 4 | using namespace std;
 5 | 
 6 | int func(int weight[], int profit[], int capacity, int n_gem)
 7 | {
 8 |     vector<vector<int>> dp(n_gem + 1, vector<int>(capacity + 1));
 9 |     for(int i=0;i<=n_gem;i++)
10 |     {
11 |         dp[i][0] = 0;
12 |     }
13 |     for(int i=0;i<=capacity;i++)
14 |     {
15 |         dp[0][i] = 0;
16 |     }
17 |     for(int i = 1; i <= n_gem; i++)
18 |     {
19 |         for(int j = 1; j <= capacity; j++)
20 |         {
21 |             // 容量允许，可以装入物品
22 |             if(j >= weight[i-1])
23 |             {
24 |                 // 分为两种情况，装入物品和不装入物品
25 |                 dp[i][j] = max(profit[i - 1] + dp[i - 1][j - weight[i - 1]], dp[i - 1][j]);
26 |             }
27 |             // 容量不足，不装入该物品
28 |             else
29 |             {
30 |                 dp[i][j] = dp[i-1][j];
31 |             }
32 |         }
33 |     }
34 |     return dp[n_gem][capacity];
35 | }
36 | 
37 | int main() {
38 |     // 测试次数
39 |     int n_test;
40 |     cin>>n_test;
41 |     for(int i=0;i<n_test;i++)
42 |     {
43 |         // 宝石个数
44 |         int n_gem;
45 |         cin>>n_gem;
46 |         // 背包容量
47 |         int bag_capacity;
48 |         cin>>bag_capacity;
49 |         int weight[n_gem];
50 |         int profit[n_gem];
51 |         for(int i=0;i<n_gem;i++)
52 |         {
53 |             // 宝石大小
54 |             int weight_gem;
55 |             cin>>weight_gem;
56 |             // 宝石价值
57 |             int profit_gem;
58 |             cin>>profit_gem;
59 |             weight[i] = weight_gem;
60 |             profit[i] = profit_gem;
61 |         }
62 |         cout<<func(weight, profit, bag_capacity, n_gem)<<endl;
63 |     }
64 |    return 0;
65 | }
66 | ```


--------------------------------------------------------------------------------
/docs/1020 矩阵连乘.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<climits>
 4 | using namespace std;
 5 | 
 6 | // 数组长度为n，矩阵个数为n-1
 7 | int min_cost(int p[], int n)
 8 | {
 9 |     // m[i,j]表示矩阵matrix[i] matrix[i+1] ... matrix[j-1] matrix[j]的最小乘法代价
10 |     int m[n][n];
11 |     int i, j, k, L, q;
12 |  
13 |     // 一个矩阵，不存在最小乘法代价，为0
14 |     // 索引从1到n-1，表示矩阵1-矩阵n-1
15 |     for (i=1; i<n; i++)
16 |         m[i][i] = 0;    
17 |  
18 |     //L表示连乘的矩阵个数，从2到n-1
19 |     for (L=2; L<n; L++)
20 |     {
21 |         // n-gram的思想，以L为单位进行分割，最少分成1个，最多分成n-L+1个
22 |         for (i=1; i<n-L+1; i++)
23 |         {
24 |             // j表示同一个连乘长度内的最后一个元素的下标
25 |             j = i+L-1;
26 |             m[i][j] = INT_MAX; 
27 |  
28 |             for (k=i; k<=j-1; k++)
29 |             {
30 |                 // m[i][k]连乘后的结果矩阵：p[i-1]行，p[k]列
31 |                 // m[k+1][j]连乘后的结果矩阵：p[k]行，p[j]列
32 |                 // 两个结果矩阵连乘代价：p[i-1]*p[k]*p[j]
33 |                 q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
34 |                 if (q < m[i][j])
35 |                 {
36 |                     m[i][j] = q;    
37 |                 }
38 |             }
39 |         }
40 |     }
41 |  
42 |     return m[1][n-1];  
43 | }
44 | 
45 | int main() {
46 |     // 测试次数
47 |     int n_test;
48 |     cin>>n_test;
49 |     for(int i=0;i<n_test;i++)
50 |     {
51 |         // 矩阵个数
52 |         int n_matrix;
53 |         cin>>n_matrix;
54 |         // 存储每个矩阵的行数和列数，前一个矩阵的列数和后一个矩阵的行数重复，只存储1个，因此大小为2*n_matrix-(n_matrix-1)
55 |         int chain[n_matrix+1];
56 |         for(int i=0;i<n_matrix;i++)
57 |         {
58 |             // 行和列
59 |             int row;
60 |             cin>>row;
61 |             int col;
62 |             cin>>col;
63 |             if(i==0)
64 |             {
65 |                 chain[i] = row;
66 |                 chain[i+1] = col;
67 |             }
68 |             else
69 |             {
70 |                 chain[i+1] = col;
71 |             }
72 |         }
73 |         cout<<min_cost(chain, n_matrix+1)<<endl;
74 |     }
75 |    return 0;
76 | }
77 | ```


--------------------------------------------------------------------------------
/docs/1021 钢条切割.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<climits>
 4 | using namespace std;
 5 | 
 6 | // 无限背包问题，钢材相当于背包，每个售卖的小段钢材相当于物品，假设每种售卖的小段钢材是没有数量限制的
 7 | // dp数组申请为1维数组，2维数组显示内存不足错误
 8 | int cut_rod(int prices[], int sizes[], int capacity, int n)
 9 | {
10 |     // 局部变量赋值为0，否则系统赋随机值
11 |     int dp[capacity+1] = {0,};
12 |     // 背包容量为0
13 |     dp[0] = 0;
14 |     // 从小到大遍历所有背包容量
15 |     for(int i=1;i<=capacity;i++)
16 |     {
17 |         // 遍历所有物品
18 |         for(int j=0;j<n;j++)
19 |         {
20 |             // 容量允许的情况下
21 |             if(sizes[j]<=i)
22 |             {
23 |                 dp[i] = max(dp[i], dp[i-sizes[j]] + prices[j]);
24 |             }
25 |         }
26 |     }
27 |     return dp[capacity];
28 | }
29 | 
30 | int main() {
31 |     // 测试次数
32 |     int n_test;
33 |     cin>>n_test;
34 |     for(int i=0;i<n_test;i++)
35 |     {
36 |         // 钢条长度
37 |         int capacity;
38 |         cin>>capacity;
39 |         // 价目表价格种类数
40 |         int n_types;
41 |         cin>>n_types;
42 |         int prices[n_types];
43 |         int sizes[n_types];
44 |         for(int j=0;j<n_types;j++)
45 |         {
46 |             cin>>sizes[j];
47 |             cin>>prices[j];
48 |         }
49 |         cout<<cut_rod(prices, sizes, capacity, n_types)<<endl;
50 |     }
51 |    return 0;
52 | }
53 | ```


--------------------------------------------------------------------------------
/docs/1022 最长公共子序列.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<string>
 4 | using namespace std;
 5 | 
 6 | //最长公共序列和最长公共子串不是一个问题
 7 | 
 8 | // longest common sequence
 9 | int lcs(string s, string t, int m, int n)
10 | {
11 |     // dp[i][j]表示长度为i的字符串和长度为j的字符串的lcs
12 |     int dp[m+1][n+1] = {0,};
13 |     for(int i=0;i<=m;i++)
14 |     {
15 |         for(int j=0;j<=n;j++)
16 |         {
17 |             // 任何一个字符串长度为0，lcs结果为0
18 |             if(i==0 || j==0)
19 |             {
20 |                 dp[i][j] = 0;
21 |             }
22 |             // 两个字符串最后一个字符相同
23 |             else if(s[i-1] == t[j-1])
24 |             {
25 |                 // 状态转移方程1
26 |                 dp[i][j] = dp[i-1][j-1] + 1;
27 |             }
28 |             else
29 |             {
30 |                 // 状态转移方程2
31 |                 dp[i][j] = max(dp[i-1][j], dp[i][j-1]); 
32 |             }
33 |         }
34 |     }
35 |     return dp[m][n];
36 | }
37 | 
38 | 
39 | int main() {
40 |     // 测试次数
41 |     int n_test;
42 |     cin>>n_test;
43 |     for(int i=0;i<n_test;i++)
44 |     {
45 |         string s1;
46 |         string s2;
47 |         cin>>s1;
48 |         cin>>s2;
49 |         cout<<lcs(s1, s2, s1.size(), s2.size())<<endl;
50 |     }
51 |    return 0;
52 | }
53 | ```


--------------------------------------------------------------------------------
/docs/1025 最长非降子序列.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<climits>
 4 | using namespace std;
 5 | 
 6 | int func(int arr[], int n)
 7 | {
 8 |     int dp[n] = {1,};
 9 |     for(int i=0;i<n;i++)
10 |     {
11 |         dp[i] = 1;
12 |     }
13 |  
14 |  
15 |     for (int i = 1; i < n; i++) {
16 |         for (int j = 0; j < i; j++)
17 |             if (arr[i] >= arr[j])
18 |                 dp[i] = max(dp[i], dp[j] + 1);
19 |     }
20 |  
21 |     int ans = INT_MIN;
22 |     for(int i=0;i<n;i++)
23 |     {
24 |         if(dp[i] > ans)
25 |         {
26 |             ans = dp[i];
27 |         }
28 |     }
29 |     return ans;
30 | }
31 | 
32 | int main() {
33 |     // 测试次数
34 |     int n_test;
35 |     cin>>n_test;
36 |     for(int i=0;i<n_test;i++)
37 |     {
38 |         int num;
39 |         cin>>num;
40 |         int arr[num];
41 |         for(int j=0;j<num;j++)
42 |         {
43 |             cin>>arr[j];
44 |         }
45 |         cout<<func(arr, num)<<endl;
46 |     }
47 |    return 0;
48 | }
49 | ```


--------------------------------------------------------------------------------
/docs/1026 插入乘号.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | using namespace std;
 4 | 
 5 | 
 6 | long long func(int arr[],int n, int k) {
 7 |     // dp[i][j]表示在第1到第i个数里面插入j个乘号得到的最大值
 8 |     long long dp[n+1][n+1];
 9 |     long long sum[n+1];
10 |     sum[0]=0;
11 |     // 存储累加和
12 |     for(int i=1; i<=n;i++) 
13 |     {
14 |         sum[i] = sum[i-1] + arr[i];
15 |     }
16 |     for(int i=1; i<=n;i++) {
17 |         dp[i][0] = sum[i];
18 |     }
19 |     for(int i=2;i<=n;++i)
20 |         for(int j=1;j<i;++j)
21 |             dp[i][j]=-1;
22 |     
23 |     // j表示乘法符号个数
24 |     for(int j=1;j<=k;++j)
25 |     {
26 |         // 乘号可以放入的范围，[1,i]
27 |         for(int i=j+1;i<=n;++i)
28 |         {
29 |             // 乘号放入k位置，k之前的位置已经被测试过了
30 |             for(int k=j+1;k<=i;++k)
31 |             {
32 |                 // dp[k-1][j-1]表示乘法插入后的左部分，sum[i] = sum[k-1]表示右部分
33 |                 dp[i][j]=max(dp[i][j],dp[k-1][j-1]*(sum[i]-sum[k-1]));
34 |             }
35 |         }
36 |     }
37 |     return dp[n][k];
38 | }
39 |     
40 | 
41 | 
42 | int main() {
43 |     int n_test;
44 |     cin >> n_test;
45 |     for(int i=0; i<n_test; i++){
46 |         int n;
47 |         int k;
48 |         cin>>n;
49 |         cin>>k;
50 |         int arr[n+1];
51 |         for(int j=1;j<=n;j++){
52 |             cin >> arr[j];
53 |         }
54 |         cout<<func(arr,n,k)<<endl;
55 |     }   
56 |     return 0;
57 | }
58 | ```


--------------------------------------------------------------------------------
/docs/1027 带权活动选择.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<algorithm>
 4 | using namespace std;
 5 | 
 6 | struct activity
 7 | {
 8 |   int start_time;
 9 |   int finish_time;
10 |   int weight;  
11 | };
12 | 
13 | bool compare(activity a1, activity a2)
14 | {
15 |     return (a1.finish_time != a2.finish_time) ? (a1.finish_time < a2.finish_time) : (a1.start_time < a2.start_time);
16 | }
17 | 
18 | 
19 | int get_last_activity(activity arr[], int idx)
20 | {
21 |     // arr为根据结束时间排序后的数组
22 |     // 从后往前找
23 |     for(int i=idx-1;i>=0;i--)
24 |     {
25 |         if(arr[i].finish_time <= arr[idx].start_time)
26 |         {
27 |             return i;
28 |         }
29 |     }
30 |     return -1;
31 | }
32 | 
33 | int choose(activity arr[], int n)
34 | {
35 |     int dp[n+1];
36 |     dp[1] = arr[0].weight;
37 |     for(int i=2;i<=n;i++)
38 |     {
39 |         int sum = arr[i-1].weight;
40 |         int idx = get_last_activity(arr, i-1);
41 |         if(idx!=-1)
42 |         {
43 |             sum += dp[idx+1];
44 |         }
45 |         dp[i] = max(sum, dp[i-1]);
46 |     }
47 |     return dp[n];
48 | }
49 | 
50 | int main() {
51 |     // 测试次数
52 |     int n_test;
53 |     cin>>n_test;
54 |     for(int i=0;i<n_test;i++)
55 |     {
56 |         // 活动个数
57 |         int n_activity;
58 |         cin>>n_activity;
59 |         activity arr[n_activity];
60 |         for(int j=0;j<n_activity;j++)
61 |         {
62 |             activity temp;
63 |             cin>>temp.start_time;
64 |             cin>>temp.finish_time;
65 |             cin>>temp.weight;
66 |             arr[j] = temp;
67 |         }
68 |         sort(arr, arr+n_activity, compare);
69 |         cout<<choose(arr, n_activity)<<endl;
70 |     }
71 |    return 0;
72 | }
73 | ```


--------------------------------------------------------------------------------
/docs/1039 拓扑排序.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<vector>
 4 | #include<queue>
 5 | using namespace std;
 6 | 
 7 | 
 8 | int main()
 9 | {
10 |     int n_test;
11 |     cin>>n_test;
12 |     for(int i=0;i<n_test;i++)
13 |     {
14 |         int n_vertex;
15 |         int n_edge;
16 |         cin>>n_vertex;
17 |         cin>>n_edge;
18 |         int in_degree[n_vertex+1] = {0,};
19 |         vector<vector<int>> adj(n_vertex+1, vector<int>(n_vertex+1, 0));
20 |         vector<int> ans;
21 |         queue<int> zero_degree;
22 |         for(int j=0;j<n_edge;j++)
23 |         {
24 |             //u->v
25 |             int u;
26 |             int v;
27 |             cin>>u;
28 |             cin>>v;
29 |             adj[u].push_back(v);
30 |             in_degree[v]++;
31 |         }
32 |         for(int k=1;k<=n_vertex;k++)
33 |         {
34 |             if(in_degree[k]==0)
35 |             {
36 |                 zero_degree.push(k);
37 |             }
38 |         }
39 |         int num = 0;
40 |         while(!zero_degree.empty())
41 |         {
42 |             int vertice = zero_degree.front();
43 |             zero_degree.pop();
44 |             ans.push_back(vertice);
45 |             for(int i=0;i<adj[vertice].size();i++)
46 |             {
47 |                 if(adj[vertice][i]!=0 &&--in_degree[adj[vertice][i]]==0)
48 |                 {
49 |                     zero_degree.push(adj[vertice][i]);
50 |                 }
51 |             }
52 |             num++;
53 |         }
54 |         if(num!=n_vertex)
55 |         {
56 |             cout<<"0";
57 |         }
58 |         else
59 |         {
60 |             for(int i=0;i<ans.size();i++)
61 |             {
62 |                 cout<<ans[i]<<" ";
63 |             }
64 |         }
65 |         cout<<endl;
66 |     }
67 | }
68 | ```


--------------------------------------------------------------------------------
/docs/1040 搜索二位矩阵.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<vector>
 4 | #include<iomanip>
 5 | using namespace std;
 6 | 
 7 | // 思想就是和矩阵右上角元素比较，不断缩小范围
 8 | bool search(vector<vector<int>> matrix, int row, int col, int target)
 9 | {
10 |     if(row==0 || col==0)
11 |     {
12 |         return false;
13 |     }
14 |     int i = 0;
15 |     int j = col-1;
16 |     while(i<row && j>=0)
17 |     {
18 |         if(target == matrix[i][j])
19 |         {
20 |             return true;
21 |         }
22 |         else if(target < matrix[i][j])
23 |         {
24 |             j--;
25 |         }
26 |         else
27 |         {
28 |             i++;
29 |         }
30 |     }
31 |     return false;
32 | }
33 | 
34 | int main()
35 | {
36 |     int n_test;
37 |     cin>>n_test;
38 |     for(int i=0;i<n_test;i++)
39 |     {
40 |         int row;
41 |         int col;
42 |         int target;
43 |         cin>>row;
44 |         cin>>col;
45 |         cin>>target;
46 |         vector<vector<int>> matrix(row, vector<int>(col));
47 |         for(int i=0;i<row;i++)
48 |         {
49 |             for(int j=0;j<col;j++)
50 |             {
51 |                 cin>>matrix[i][j];
52 |             }
53 |         }
54 |         cout<<boolalpha<<search(matrix, row, col, target)<<endl;
55 |     }
56 | }
57 | ```


--------------------------------------------------------------------------------
/docs/1041 寻找两个正序数组的中位数.md:
--------------------------------------------------------------------------------
 1 | ```cpp
 2 | #include<iostream>
 3 | #include<algorithm>
 4 | #include<iomanip>
 5 | using namespace std;
 6 | 
 7 | // leetcode 4.
 8 | // https://leetcode.com/problems/median-of-two-sorted-arrays/
 9 | 
10 | float func(int arr1[], int arr2[], int len_1, int len_2)
11 | {
12 |     int arr[len_1+len_2];
13 |     int p = 0;
14 |     int q = 0;
15 |     int idx = 0;
16 |     while(p<len_1 && q<len_2)
17 |     {
18 |         if(arr1[p] <= arr2[q])
19 |         {
20 |             arr[idx++] = arr1[p++]; 
21 |         }
22 |         else
23 |         {
24 |             arr[idx++] = arr2[q++];
25 |         }
26 |     }
27 |     while(p<len_1)
28 |     {
29 |         arr[idx++] = arr1[p++];
30 |     }
31 |     while(q<len_2)
32 |     {
33 |         arr[idx++] = arr2[q++];
34 |     }
35 |     if( (len_1+len_2)%2!=0 )
36 |     {
37 |         return arr[(len_1+len_2)/2];
38 |     }
39 |     else
40 |     {
41 |         return ( arr[(len_1+len_2)/2] + arr[(len_1+len_2)/2-1] ) / 2.0;
42 |     }
43 | }
44 | 
45 | int main()
46 | {
47 |     int n_test;
48 |     cin>>n_test;
49 |     for(int i=0;i<n_test;i++)
50 |     {
51 |         int len_1;
52 |         int len_2;
53 |         cin>>len_1;
54 |         cin>>len_2;
55 |         int arr_1[len_1];
56 |         int arr_2[len_2];
57 |         for(int j=0;j<len_1;j++)
58 |         {
59 |             cin>>arr_1[j];
60 |         }
61 |         for(int j=0;j<len_2;j++)
62 |         {
63 |             cin>>arr_2[j];
64 |         }
65 |         // 输入的数据已经是有序了，不需要再排序
66 |         // sort(arr_1, arr_1+len_1);
67 |         // sort(arr_2, arr_2+len_2);
68 |         // 题目bug，不需要保留小数
69 |         cout<<func(arr_1, arr_2, len_1, len_2)<<endl;
70 |     }
71 | }
72 | ```
73 | 


--------------------------------------------------------------------------------
/docs/1042 最低票价.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<algorithm>
 4 | #include<iomanip>
 5 | #include<climits>
 6 | using namespace std;
 7 | 
 8 | // leetcode 983 Minimum Cost For Tickets.
 9 | // https://leetcode.com/problems/minimum-cost-for-tickets/
10 | 
11 | int func(int days[], int costs[], int len, int n_costs)
12 | {
13 |     // dp[i]表示前i天旅行的费用
14 |     int dp[366];
15 |     for(int i=0;i<366;i++)
16 |     {
17 |         dp[i] = INT_MAX;
18 |     }
19 |     // 前0天，没有旅行，没有费用
20 |     dp[0] = 0;
21 |     // 扫描days数组的下标
22 |     int idx = 0;
23 |     for(int i=1;i<366;i++)
24 |     {
25 |         // 第i天不旅行，防止idx下标出界
26 |         // idx>=len必须放在前面，先进行判断，否则会造成缓冲区溢出
27 |         if(days[idx] != i || idx>=len)
28 |         {
29 |             // 费用和之前保持不变
30 |             dp[i] = dp[i-1];
31 |         }
32 |         // 第i天旅行
33 |         else
34 |         {
35 |             // 三种费用依次比较，注意防止i-1，i-7，i-30出了边界
36 |             dp[i] = min(dp[i], ( i>=1 ? dp[i-1] : 0 ) + costs[0]);  // 一天的费用
37 |             dp[i] = min(dp[i], ( i>=7 ? dp[i-7] : 0) + costs[1]);  // 七天的费用
38 |             dp[i] = min(dp[i], ( i>=30 ? dp[i-30] : 0) + costs[2]);  // 一个月的费用
39 |             // 下一次旅行的日期
40 |             idx++;
41 |         }
42 |     }
43 |     return dp[365];
44 | }
45 | 
46 | int main()
47 | {
48 |     const int n_costs = 3;
49 |     int n_test;
50 |     cin>>n_test;
51 |     for(int i=0;i<n_test;i++)
52 |     {
53 |         int len;
54 |         cin>>len;
55 |         int days[len];
56 |         int costs[n_costs];
57 |         for(int j=0;j<len;j++)
58 |         {
59 |             cin>>days[j];
60 |         }
61 |         for(int j=0;j<n_costs;j++)
62 |         {
63 |             cin>>costs[j];
64 |         }
65 |         cout<<func(days, costs, len, n_costs)<<endl;
66 |     }
67 | }
68 | ```


--------------------------------------------------------------------------------
/docs/1043 鸡蛋掉落.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | #include<iostream>
 3 | #include<vector>
 4 | #include<iomanip>
 5 | using namespace std;
 6 | 
 7 | int func(int n_egg, int n_floor)
 8 | {
 9 |     vector<vector<int>> dp(n_floor+1, vector<int>(n_egg+1, 0));
10 |         int m = 0;
11 |         while (dp[m][n_egg] < n_floor) {
12 |             m++;
13 |             for (int k = 1; k <= n_egg; ++k)
14 |                 dp[m][k] = dp[m - 1][k - 1] + dp[m - 1][k] + 1;
15 |         }
16 |         return m;
17 | }
18 | 
19 | int main()
20 | {
21 |     int n_test;
22 |     cin>>n_test;
23 |     for(int i=0;i<n_test;i++)
24 |     {
25 |         int n_egg;
26 |         int n_floor;
27 |         cin>>n_egg;
28 |         cin>>n_floor;
29 |         cout<<func(n_egg, n_floor)<<endl;
30 |     }
31 | }
32 | ```


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
 1 | 
 2 | ## 东南大学算法设计与分析课程OJ [http://47.99.179.148/](http://47.99.179.148/)
 3 | 
 4 | 
 5 | 
 6 | - C++中各种输入函数的缓冲区问题
 7 | 
 8 |   [string - Using getline() in C++ - Stack Overflow](https://stackoverflow.com/questions/18786575/using-getline-in-c)
 9 | 
10 | - convert int to double to avoid potential integer overflow
11 | 
12 |   [Trying to return as double, getting integer in C++ - Stack Overflow](https://stackoverflow.com/questions/35478555/trying-to-return-as-double-getting-integer-in-c)
13 | 
14 | - c-prefixed头文件和.h extension文件区别
15 | 
16 |   [c++ - cmath vs math.h (And similar c-prefixed vs .h extension headers) - Stack Overflow](https://stackoverflow.com/questions/10694255/cmath-vs-math-h-and-similar-c-prefixed-vs-h-extension-headers)
17 | 
18 | 


--------------------------------------------------------------------------------
/mkdocs.yml:
--------------------------------------------------------------------------------
1 | site_name: 东南大学算法设计与分析课程OJ 
2 | theme:
3 |  name: material
4 | repo_url: https://github.com/zpengc/seu_monash_algorithm-design-and-analysis


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