1.递归剪枝法
输入一串数组，找到数组中子序列的的最大顺序
fun_back(int a[], int i, int n) {
int max_len = 1;
for (int j = i + 1; j < n; j++)
if (a[j] > a[i])
if (max_len < fun_back(a, j, n) + 1)
max_len = fun_back(a, j, n) + 1;
return max_len;
if (i == n - 1)
return max_len;
}
int main() {
int n, max = 0; //输入个数
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
//max > fun_back(a, i, n) ? max : fun_back(a, i, n);
if (max < fun_back(a, i, n))
max = fun_back(a, i, n);
}
cout << max;
}例如输入了5个数
1.主函数对每个变量都都进行遍历一遍，是根节点的所有子节点是标识一处。
2，递归函数只需要判断当前节点是否大于父节点，如果满足，就调用下一个递归，如果不满足就返回值。
最后，递归要判断是否到了底层，就是到第四层的时候。要么就往下走，要么就退出。不然最后一层已经在无法向下递归了。
2，二维数组遍历法
2.1对角线遍历
int main() {
int n, m; //输入个数
cin >> n;
cin >> m;
int temp = 0;
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
cin >> a[i][j];
}
//输入n行m列的二位数组
for (int p = 0; p < n + m - 1; p++) {
for (int i = 0; i <= p; i++)
if (i < n && (p - i) < m) {
cout << a[i][p - i] << " ";
}
cout << endl;
}
}
我以其中的的交点作为二维坐标的焦点。
1：我们可以发现所有线上的坐标，在同一条坐标之上的值总是相等的。
2：我们要遍历这个值，是M+N-1。对角线分别对应着一个值
3：注意绿线坐标的部分，如果是4*4的二维坐标，则这个坐标最开始是a[4][0],这个坐标是并不存在的。所以需要判断所遍历的值是否在二维坐标的范围之内。
2.2类似地，还可以把代码改为蛇形遍历
int main() {
int n, m; //输入个数
cin >> n;
cin >> m;
int temp = 0;
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
cin >> a[i][j];
}
//输入n行m列的二位数组
for (int p = 0; p < n + m - 1; p++) {
if (p % 2 == 0) {
for (int i = 0; i <= p; i++)
if (i < n && (p - i) < m) {
cout << a[i][p - i] << " ";
}
cout << "#" << p << endl;
} else {
for (int i = p; i >= 0; i--)
if (i < n && (p - i) < m) {
cout << a[i][p - i] << " ";
}
cout << "#" << p << endl;
}
cout << endl;
}
}如下图：
2.3螺旋法（任何矩阵，非方阵容）
这是用来实验的数据
一；方阵容
偶数：
4 4
1 2 3 4
5 6 7 8
2 3 4 5
6 7 8 9
奇数
3 3
1 2 3
5 6 7
2 3 4
二：非方阵容
3 5
1 2 3 4 5
2 3 4 5 6
4 5 6 7 8
5 3
1 2 3
5 6 7
2 3 4
6 7 8
7 8 9#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m; //输入个数
cin >> n;
cin >> m;
int temp = 0;
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
cin >> a[i][j];
}
int top, bottom, left, right;
top = 0, bottom = n - 1, left = 0, right = m - 1;
while (top <= (bottom ) && left <= (right)) {
// 左 -> 右（上边）
for (int l = left; l <= right ; l++) {
cout << a[top][l] << " >";
}
cout << endl;
// 上 -> 下（右边）
for (int i = top + 1 ; i <= bottom ; i++) {
cout << a[i][right] << " ↓ ";
}
cout << endl;
// 右 -> 左（下边）
if (bottom % 2 == 0
|| bottom != top) //如果在bottom与top变化到同样的值的时候，如果是偶数就会出现只有一行的情况，一行的情况会被遍历两次
for (int i = right - 1; i >= left && left <= right ; i--) {
cout << a[bottom][i] << " < ";
}
cout << endl;
// 下 -> 上（左边）
if (left % 2 == 0 || left != right)
for (int i = bottom - 1; i > top && top <= bottom; i--) {
cout << a[i][left] << " ↑ ";
}
cout << endl;
// 往里进一层
top ++;
left ++;
bottom --;
right --;
cout << "---------" << endl;
}
}
可以省去内部的条件限制思想：螺旋法的思想就是需要一层一层地遍历，把每一层单独拿出来观察，就像剥洋葱一样，但是洋葱的内部却不是一样的。
希望他这样子：
不过他会这样子：
下面来谈一谈剥洋葱的过程：
一般步骤：先→再↓再←再↑。
???? 这里就需要四个遍历函数。
需要注意的是
普通外层遍历
1.我们的每一步都会与下一步产生一个交集的元素。这个元素应当放在本步处理，而不是放在下一步处理。
2最后一次剥皮在向上剥皮，这时要注意最后一个元素不能重叠
?
上面所说的用四个遍历就可以完成
内层遍历
最后有可能剩下如图的两种情况，如果我们直接用上述的代码会出现内层被反复打印的情况。这种情况只是：在边界变量相等并且边界变量为奇数的情况之下。如图第二层的时候 bottom=top=1.(因为偶数剥皮不会剩下只有一列)
所以上述情况发生的时候我们就不再打印。因为已经打印过了。
?
上述情况（重复打印）是条件交接处： ?? M1且M2
?那么这种情况就打印，相反不是这种情况就打印。这是逻辑关系 !（M1且M2）=！M1或！M2
?
?
