大整数乘法 分治法
分治法思想:将一个规模为n的问题,分解成k个规模较小的子问题,子问题和原问题相同,且相互独立。然后递归的解决这些子问题,最终合并成原问题的解。所以说其是一种自底向上的算法。
代码
//头文件
#pragma once
class Big_number_multiply
{
public:
long long BigNumberMultiply(long long X, long long Y, int N);
};
//.cpp 文件
#include "Big_number_multiply.h"
#include <algorithm>
long long Big_number_multiply::BigNumberMultiply(long long X, long long Y, int N)
{
if (N<=2) // 已经包含了 X,Y =0 的情况,
{
return X * Y;
}
else
{
long long A = (X / pow(10, N / 2)) * pow(10, N / 2);// 注意A需要恢复到10 ^(N/2)
long long B = X - A;
long long C = Y / pow(10, N / 2) * pow(10, N / 2);
long long D = Y - C;
long long AC = BigNumberMultiply(A, C, N / 2);
long long BD = BigNumberMultiply(B, D, N / 2);
long long ABCD = BigNumberMultiply((A-B), (D-C), N / 2)+ AC + BD;
return AC + BD + ABCD;
}
}
//main
//大整数乘法 --分治法
Big_number_multiply bnm;
cout << bnm.BigNumberMultiply(1234, 1234, 4)<<endl;
最接近点对 分治法
一维的和二维的,下面是二维的伪码
伪代码
bool bestFasten(int S , int d)
{
m = S 按照X排序的中点
将区域S 以m为分界线分成S1 ,S2
bestFasten(s1,d1);
bestFasten(s2,d2);
d = min(d1,d2)
对区域S 中的Y 坐标进行排序,然后以m为轴,以d为边界,将S划分为一个两个子区域S3,S4
按照y从小到大的顺序从S3中选一个点A,然后以A点为轴心,
在S4区域中选取(A-d,A+d)的区域在S4 中最多有6个与之结合的点(鸽舍原理)设其距离为dm
dmin = min(dm,d)
return true;
}
矩阵连乘问题-- 动态规划
动态规划的思路:
将一个规模为n的问题,分解成k个规模较小的子问题,这些子问题和原问题相同,但是互相有联系,然后递归的求解最优值,最后求出原问题的最优解。
设计步骤:
1,寻找最优解的性质
2,递归的定义最优解
3,使用自底向上的思路求解最优解
4,得到最终的最优解
代码:
最优解的性质:
m[i][j]=0 (i=j)
m[i][j] = m[i][k]+m[k+1][j] + p[i-1]p[k]p[j] (i<j)
//.h文件
#pragma once
#include<vector>
using namespace std;
class Matrix_continue_multiply
{
public:
void MatrixContinueMultiply(vector<int> demension,int n);
public:
int m[10][10];
int s[10][10];
};
//cpp文件
#include "Matrix_continue_multiply.h"
#include<iostream>
using namespace std;
// m[i][j] 代表的是从 i 到 j 的矩阵相乘的最优值
// s[i][j] 代表的是断开的位置k
void Matrix_continue_multiply::MatrixContinueMultiply(vector<int> p,int n)
{
for (int i = 1; i <= n; i++)
{
m[i][i] = 0; //自己乘自己为0
}
// r 记录长度
for (int r = 2; r<=n; r++)
{
for (int i = 1;i<=n-r+1;i++)
{
int j = r + i - 1;
m[i][j] = m[i + 1][j] + p[i - 1]*p[i]*p[j];
s[i][j] = i;
for (int k =i+1;k<j;k++)
{
int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
if (t< m[i][j])
{
m[i]