分治的基本思路:
(1)划分问题:把问题的实际化为子问题;
(2)递归求解:递归解决子问题;
(2)合并问题:合并子问题得解.
举例:
1.给定一个数列，其中可能有正数也可能有负数，找出其中连续的一个子数列（不允许空序列），使它们的和尽可能大。
解法:
我们可以把整个序列平均分成左右两部分，答案则会在以下三种情况中：
1、所求序列完全包含在左半部分的序列中。
2、所求序列完全包含在右半部分的序列中。
3、所求序列刚好横跨分割点，即左右序列各占一部分。
前两种情况和大问题一样，只是规模小了些，如果三个子问题都能解决，那么答案就是三个结果的最大值。我们主要研究一下第三种情况如何解决：我们只要计算出：以分割点为起点向左的最大连续序列和、以分割点为起点向右的最大连续序列和，这两个结果的和就是第三种情况的答案。因为已知起点，所以这两个结果都能在O(N)的时间复杂度能算出来。
递归不断减小问题的规模，直到序列长度为1的时候，那答案就是序列中那个数字。
#include <bits/stdc++.h>
using namespace std;
// 区间左闭右开
int maxSum(int *A, int x, int y) {
int m = x+(y-x)/2; // 分成两部分
if(y-x == 1) return A[x]; // 如果只有一个数直接返回
int ans = max(maxSum(A, x, m), maxSum(A, m, y)); // 全部存在于左边和全部存在于右边的情况取最大
//cout << "debug: " << x << "&" << y << " # "<< ans << endl;
int v, l, r;
// 从分界点往左的最大和
v = 0, l = A[m-1];
for (int i = m-1; i >= 0; i--) {
l = max(l, v += A[i]);
}
// 从分界点往右的最大和
v = 0, r = A[m];
for (int i = m; i < y; i++) {
r = max(r, v += A[i]);
}
ans = max(ans, l+r);
return ans;
}
int main() {
int n;
int A[105];
cin >> n;
for(int i = 0; i < n; i++) cin >> A[i];
cout << maxSum(A, 0, n);
return 0;
}
其他解法
(1) O（n^3)（暴力）
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, ans;
int a[1000];
cin >> n;
for(int i = 0; i < n; i++) {
cin >> a[i];
}
ans = a[0];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
sum = 0;
for (int k = i; k <= j; ++k) {
sum += a[k];
}
ans = max(ans, sum);
}
}
cout << ans << endl;
return 0;
}
(2) O(n^2) （前缀和）
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans;
cin >> n;
int a[n+5], b[n+5];
for(int i = 0; i < n; i++) {
cin >> a[i];
}
b[0] = a[0];
for (int i = 1; i < n; ++i) {
b[i] = b[i-1] + a[i];
}
ans = a[0];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
ans = max(ans, b[j] - b[i] + a[i]);
}
}
cout << ans << endl;
return 0;
}
// 1 2 3 4 5
//
// 2 4
(3) O(n)(dp)
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans;
cin >> n;
int a[n+5], dp[n+5];
for(int i = 0; i < n; i++) {
cin >> a[i];
}
dp[0] = a[0];
ans = a[0];
for (int i = 1; i < n; ++i) {
if(dp[i-1] > 0) dp[i] = dp[i-1] + a[i];
else dp[i] = a[i];
ans = max(dp[i], ans);
}
cout << ans << endl;
return 0;
}
/*
8
4 -3 5 -2 -1 2 6 -2
* */
2.全排列
参考博文:https://blog.csdn.net/whealther/article/details/48878829
当n=1时,集合中只有一个元素;当n>1时,将整个数列中每一个数分别与第一个数交换后加其他数的全排列，因此每次都是处理后n-1个数的全排列(递归)
ps.必须交换两次, 交换完了后要交换回来，因为后面交换都是在原来的数列1，2，3...的基础上交换的，所以在排列前要交换一次，排列后还要交换一次（还原）
代码
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int a[105];
void perm(int k, int m) {
if(k == m) { // 只剩一个元素
for(int i = 1; i <= m; i++) {
printf("%d", a[i]);
if(i != m)
printf(" ");
}
printf("
");
return;
}
for(int i = k; i <= m; i++) {
swap(a[i], a[k]);
perm(k+1, m); // 相当于以当前元素为首的全排列
swap(a[i], a[k]);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {a[i] = i;}
perm(1, n);
return 0;
}
3.整数划分
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[100][100];
// 函数表示正整数n可以划分为不大于m的数的方法数
ll solve(int n, int m) {
if(n < 1 || m < 1) return 0;
if(dp[n][m]>0) return dp[n][m];
// m或者n为一,只有一种情况
if(n == 1 || m == 1) dp[n][m] = 1;
// m > n与m=n相同
if(m > n) dp[n][m] = solve(n, n);
// m=n时,用n组成m只有一种情况,在加上小于m的所有情况
if((n != 1 && m != 1) && m == n) dp[n][m] = solve(n, m-1)+1;
// m < n,emmmmmm看几个样例体会一下...
/*
6；
5+1；
4+2，4+1+1；
3+3，3+2+1，3+1+1+1；
2+2+2，2+2+1+1，2+1+1+1+1；
1+1+1+1+1+1。
*/
if(m < n) dp[n][m] = solve(n, m-1) + solve(n-m, m);
return dp[n][m];
}
int main() {
int n;
while(~scanf("%d", &n)) {
memset(dp, 0, sizeof dp);
solve(n, n);
printf("%lld
", dp[n][n]);
}
return 0;
}