算法整理合集
目录
1、冒泡排序
2、堆排序
3、快速排序
4、哈希查找
5、折半查找
6、棋盘覆盖
7、递归：二分查找
8、递归：阶乘
9、大整数乘法
10、递归-Strassen矩阵乘法
11、斐波那契数列 递归
12、n后问题
13、Hanoi塔问题
14、半数单集
15、整数因子分解问题
16、C语言-生成随机数
17、无和集问题
18、多处最优服务次序问题
19、最优装载
20、装载问题
21、最大子段和
22、最优二叉搜索树
23、最长公共子序列
24、作业调度
25、循环赛日程表
26、旅行售货员
27、流水作业调度-动态规划
28、快速排序2
29、递归：有重复元素的排列问题
30、递归：整数划分
31、动态规划01背包
32、动态规划-矩阵连乘
33、动态规划：最长公共子序列
34、多级调度（贪心）
35、分支限界-装载问题
36、活动安排
37、矩阵乘积标准式
1、冒泡排序
将待排序的n个记录看作按纵向排列，每趟排序时自下至上对排序范围中每对相邻元素进行比较，若次序不符合要求就交换。每趟排序都能使待排序 范围内关键字最小的元素像气泡一样“冒”到待排序范围最上端
#include
void Bubble(int *a,int n);
void Bubble2(int *p,int n);
int main()
{
int a[]={38,20,46,38,74,12};
Bubble(a,6);
printf("\n");
Bubble2(a,6);
return 0;
}
void Bubble(int *a,int n)//这个n就是数组元素个数
{
int i,j;
int t;
for(i=0;ip[i])
{
t=p[i];
p[i]=p[j];
p[j]=t;
}
}
}
for(i=0;i 2、堆排序
#include
#define MAXSIZE 100
typedef struct
{
int key;
}DataType;
typedef struct
{
DataType list[MAXSIZE];
int length;
}SeqList;
void HeapAdjust(SeqList *L,int low,int high)
{
int i, j;
i=low;
j=2*i;
L->list[0]=L->list[i];
for(;j<=high;j*=2)
{
if(jlist[j].keylist[j+1].key)
j++;
if(L->list[0].key>=L->list[j].key)
break;
else
{
L->list[i]=L->list[j];
i=j;
}
}
L->list[i]=L->list[0];
}
void HeapCreate(SeqList *L)
{
int i, n;
n=L->length;
for(i=n/2;i>0;i--)
HeapAdjust(L,i,n);
}
void HeapSort(SeqList *L)
{
int i, n=L->length;
HeapCreate(L);
for(i=n;i>1;i--)
{
L->list[0]=L->list[1];
L->list[1]=L->list[i];
L->list[i]= L->list[0];
HeapAdjust(L,1,i-1);
}
}
int main()
{
SeqList L={{0,18,27,10,8,18,38,4,17,21},10};
HeapCreate(&L);
HeapSort(&L);
int i;
for(i=1;i<=10;i++)
{
printf("%d ",L.list[i].key);
}
return 0;
} 3、快速排序
#include
#define MAXSIZE 100
typedef struct
{
int key;
}DataType;
typedef struct
{
DataType list[MAXSIZE];
int length;
}SeqList;
int QuickPass(SeqList *L,int low,int high)
{
int i,j;
i=low;
j=high;
L->list[0]=L->list[i];
while(i!=j)
{
while((L->list[j].key>=L->list[0].key)&&(ilist[i]=L->list[j];
i++;
}
while((L->list[i].key<=L->list[0].key)&&(ilist[j]=L->list[i];
j--;
}
}
L->list[i]=L->list[0];
return i;
}
void QuickSort(SeqList *L,int s,int t)
{
int i;
if(s 4、哈希查找
#include
#include
#define NULLKEY 0
#define DELKEY -1
typedef struct
{
int key;
}Haxi;
int Hash(int k)
{
int i;
i=k%97;
return i;
}
int InsertHash(Haxi ht[],int m,int k)
{
int h0,hi,di;
h0=Hash(k);
hi=h0;
di=1;
while(ht[hi].key!=NULLKEY&&ht[hi].key!=DELKEY&&ht[hi].key!=k&&di 5、折半查找
#include
#define MAXSIZE 100
#define KeyType int
typedef struct STUDENTS
{
char name[10];
int grade;
}stu;
typedef struct
{
stu data[MAXSIZE+1];
int length;
}SeqList;
int Binsearch(SeqList *L,KeyType x)
{
int low,mid,high;
low=1;
high=L->length;
while(low<=high)
{
mid=(low+high)/2;
if(L->data[mid].grade==x)
return mid;
else
if(L->data[mid].grade 6、棋盘覆盖
#include
using namespace std;
int tile;
int Board[100][100];
void ChessBoard(int tr,int tc,int dr,int dc,int size);
int main()
{
int dr,dc,size;
cout<<"请输入棋盘的行列大小:";
cin>>size;
cout<<"请输入特殊方格的行列号:";
cin>>dr>>dc;
Board[dr][dc]=-1;
ChessBoard(0,0,dr,dc,size);
for(int i=0;i=tc+s)//特殊方格在此棋盘中
ChessBoard(tr,tc+s,dr,dc,s);
else
{
Board[tr+s-1][tc+s]=t;//t覆盖左下角
ChessBoard(tr,tc+s,tr+s-1,tc+s,s);//覆盖其余方格
}
//覆盖左下角子棋盘
if(dr>=tr+s&&dc=tr+s&&dc>=tc+s)//特殊方格在此棋盘中
ChessBoard(tr+s,tc+s,dr,dc,s);
else
{
Board[tr+s][tc+s]=t;//t覆盖左上角
ChessBoard(tr+s,tc+s,tr+s,tc+s,s);//覆盖其余方格
}
} 7、递归：二分查找
#include
using namespace std;
int BinSearch(int *data,int key,int low,int high)
{
int mid=(low+high)/2;
if(low>high) return -1;
if(key==data[mid]) return mid;
if(key>number;
int location=BinSearch(data,number,0,9);
cout<<"location="< 8、递归：阶乘
#include
int factorial(int n)
{
if(n==0)
return 1;
return n*factorial(n-1);
}
int main()
{
printf("%d",factorial(3));
}
9、大整数乘法
#include
#include
#include
using namespace std;
int Sign(int x)
{
if(x>0)
return 1;
else if (x<0)
return -1;
return 0;
}
int divideConquer(int X, int Y, int n)
{
int sign=Sign(X)*Sign(Y);
int x=abs(X);
int y=abs(Y);
if (x==0||y==0)
return 0;
else if(n==1)
return sign*x*y;
else
{
int A=x/pow(10,n/2);
int B=x-A*pow(10,n/2);
int C=y/pow(10,n/2);
int D=y-C*pow(10,n/2);
int AC=divideConquer(A,C,n/2);
int BD=divideConquer(B,D,n/2);
int ABDC=divideConquer((A-B),(D-C),n/2)+AC+BD;
return sign*(AC*pow(10,n)+ABDC*pow(10,(int)(n/2))+BD);
}
}
int main()
{
int x,y;
int n;
cout<<"请分别输入两个十进制的数字以及位数（注：位数须是偶数）"<>x>>y>>n;
cout< 10、递归-Strassen矩阵乘法
#include
#include
#include
#define N 2 //矩阵阶数
void add(int n,int A[N][N],int B[N][N],int C[N][N])
{
int i,j;
for(i=0;i 11、斐波那契数列 递归
#include
using namespace std;
int fibonacci(int n)
{
if(n<=1)
return 1;
return fibonacci(n-1)+fibonacci(n-2);
}
int main()
{
int n;
cin>>n;
for(int i=0;i<5;i++)
cout< 12、n后问题
#include
#include
using namespace std;
class Queen{
friend int nQueen(int);
private:
bool Place(int k);
void Backtrack();
int n;//皇后个数
int *x;//当前解
long sum;//当前已找到的可行方案数
};
bool Queen::Place(int k)
{
for(int j=1;j0)
{
x[k]+=1;
while(x[k]<=n&&!(Place(k)))//第k个分量选取合适的值
x[k]++;
if(x[k]<=n)//选取到了合适的值
{
if(k==n)//到达叶子结点数，方案数++
{
sum++;
cout<<"可行解有：";
for(int i=1;i<=n;i++)
{
cout< 13、Hanoi塔问题
#include
using namespace std;
int sum;//总共需要走的步数sum
void move(char X,int N,char Y)
{
cout<"<>n;
hanoi(n,'A','B','C');//实参盘子数n 柱子A,B,C
cout<<"总共需要走的步数为："< 14、半数单集
#include
#include
using namespace std;
int a[600];
long comp(int n)
{
long ans=1;
if(a[n]>0)
return a[n];
for(int i=1;i<=n/2;i++)
{
ans+=comp(i);
if((i>10)&&(2*(i/10)<=i%10))
ans-=a[i/10];
}
a[n]=ans;
return ans;
}
int main()
{
int n;
a[1]=1;
ifstream in("input2-4.txt");
if(in)
{
in>>n;
in.close();
}
int sum;
ofstream out("output2-4.txt");
if(out)
{
out< 15、整数因子分解问题
#include
#include
using namespace std;
int total;
void solve(int n)
{
if(n==1)
total++;
else
{
for(int i=2;i<=n;i++)
{
if(n%i==0)
solve(n/i);
}
}
}
int main()
{
int n;
ifstream in("input2-11.txt");
if(in)
{
in>>n;
in.close();
}
solve(n);
ofstream out("output2-11.txt");
if(out)
{
out< 16、C语言-生成随机数
#include
#include
#include
int *getRandom()
{
static int r[10] ; // static类型
int i ;
srand((unsigned)time(NULL));
for(i=0;i<10;++i)
r[i]=rand()%100;
return r ; // 返回数组首地址
}
int main()
{
int *p,i;
p=getRandom();
for(i=0;i<10;i++)
printf("*(p+[%d]):%d\n",i,*(p+i));
return 0;
} 17、无和集问题
#include
#include
using namespace std;
const int N = 100;
int a[N][N]; //存储当前解的数组，其中a[n][0]表示第n个子集的元素个数，a[n][1]到a[n][a[n][0]]为这个子集的所有元素
int num=1; //设置初始结果为1（最后要减1，所以初始值为0）
int best; //最优值
int e[N][N]; //最优解,其中的结构和a[n][n]一样
bool h[N][N];//判定数组,h[i][j]表示第i个子集中是否有j这个元素
int n; //表示最多只可以有n个子集
void dfs(int m)
{ //判断当前num是否能插入第m个子集
if(m==n)
{ //n个子集的下标是0到n-1,所以当m等于n时表示当前num不能插入所有子集
if(num<=best)
return; //如果当前num不如当前最优值best，就返回
best=num; //如果比最优值好，更新最优值和最优解
for(int i=0;i>n;
in.close();
}
dfs(0);
ofstream out("output5-6.txt");
if(out)
{
out<<--best< 18、多处最优服务次序问题
#include
#include
#include
#define Maxsize 100
using namespace std;
void Greedy(int a[],int n,int s)
{
int sumservice[Maxsize]={0};//一共s个服务点，每个服务点的总服务时间
int sumwait[Maxsize]={0};//每个服务点顾客的总等待时间
double sumtime=0;//所有人的等待服务时间
int j=1;
for(int i=0;i 19、最优装载
#include
#include
using namespace std;
void Sort(int *w,int n)
{
for(int i=0;i 20、装载问题
#include
using namespace std;
class Loading{
friend int MaxLoading(int [],int,int[]);
public:
void Backtrack(int i);
int n,
*x,
*bestx,
*w,
c,
cw,
bestw,
r;
};
void Loading::Backtrack(int i)
{
if(i>n){
if(cw>bestw){
for(int j=1;j<=n;j++)
bestx[j]=x[j];
bestw=cw;
}
return ;
}
r-=w[i];
if(cw+w[i]<=c)
{
x[i]=1;
cw+=w[i];
Backtrack(i+1);
cw-=w[i];
}
if(cw+r>bestw)
{
x[i]=0;
Backtrack(i+1);
}
r+=w[i];
}
int MaxLoading(int w[],int c,int n,int bestx[])
{
Loading X;
X.x=new int[n+1];
X.w=w;
X.c=c;
X.n=n;
X.bestx=bestx;
X.bestw=0;
X.cw=0;
X.r=0;
for(int i=1;i<=n;i++)
X.r+=w[i];
X.Backtrack(1);
delete[] X.x;
return X.bestw;
}
int main()
{
int w[]={8,6,2,3};
int n=4;
int c=12;
int bestx[4];
int bestw=MaxLoading(w,c,n,bestx);
cout< 21、最大子段和
#include
using namespace std;
int MaxSum(int n,int *a)
{
int sum=0;
int b=0;
for(int i=0;i0)
b+=a[i];
else
b=a[i];
if(b>sum)
sum=b;
}
return sum;
}
int main()
{
int a[]={-2,11,-4,13,-5,-2};
cout<<"max="< 22、最优二叉搜索树
#include
#include
using namespace std;
void OptimalBinarySearchTree(int n, double* p, double* q, double** root, double** w, double** e);
void printBintree(double** root, int i, int j);
int main()
{
cout << "最优二叉搜索树 自底向上非递归的动态规划算法\n\n";
int n; // 根节点数
double* p; // 查找 关键字 的概率
double* q; // 查找 虚拟键 的概率
double** root; // 根节点
double** w; // 子树概率总和
double** e; // 子树期望
cout << "请输入节点数目 n：";
cin >> n;
p = new double[n + 1];
q = new double[n + 1];
root = new double* [n + 2];
w = new double* [n + 2];
e = new double* [n + 2];
for (int i = 0; i < n + 2; i++)
{
root[i] = new double[n + 1];
w[i] = new double[n + 1];
e[i] = new double[n + 1];
//memset(w[i], 0, sizeof(double) * (n + 1));
//memset(e[i], 0, sizeof(double) * (n + 1));
}
cout << "请输入节点查找成功的概率(n个)：";
for (int i = 1; i <= n; i++)
cin >> p[i];
cout << "请输入节点查找失败的概率(n+1个)：";
for (int i = 0; i <= n; i++)
cin >> q[i];
// 构造最优二叉搜索树
OptimalBinarySearchTree(n, p, q, root, w, e);
// 输出二叉树
printBintree(root, 1, n);
for (int i = 0; i < n + 2; i++)
{
for (int j = 0; j < n + 1; j++)
{
cout << e[i][j] << "\t";
}
cout << endl;
}
// 删除指针
delete[] p;
delete[] q;
for (int i = 0; i < n + 2; i++)
{
delete[] root[i];
delete[] w[i];
delete[] e[i];
}
delete[] root;
delete[] w;
delete[] e;
}
void OptimalBinarySearchTree(int n, double* p, double* q, double** root, double** w, double** e)
{
// 处理w[i,j]和e[i,j]中i=j+1的情况，这种情况都是q[i-1]
for (int i = 1; i <= n + 1; i++) {
w[i][i - 1] = q[i - 1];
e[i][i - 1] = 0;
}
int i = 0; // 子问题起始节点的下标
int j = 0; // 子问题最后节点的下标
int r = 0; // 子问题根节点的下标
double temp = 0; // 存放计算得到的临时期望
// 子问题中节点数量(ki~kj的长度)，从0到n-1
for (int len = 1; len <= n; len++)
{
// 循环所有节点数为len的子问题
for (i = 1; i <= n - len+1; i++)
{
j = len + i-1;
e[i][j] = INT_MAX;
w[i][j] = w[i][j - 1] + p[j] + q[j];
for (r = i ; r <= j; r++)
{
temp = e[i][r - 1] + e[r + 1][j] + w[i][j];
// 保存最优解
if (temp < e[i][j])
{
e[i][j] = temp;
root[i][j] = r;
}
}
}
}
}
void printBintree(double** root, int i, int j)
{
if (i < j)
{
int r = root[i][j];
cout << "S" << r << "是根\n";
if (root[i][r - 1] > 0)
cout << "S" << r << "的左孩子是S" << root[i][r - 1] << endl;
if (root[r + 1][j] > 0)
cout << "S" << r << "的右孩子是S" << root[r + 1][j] << endl;
printBintree(root, i, r - 1);
printBintree(root, r + 1, j);
}
}
23、最长公共子序列
#include
#include
using namespace std;
#define Length 7
#define MAXSIZE 100
char x[MAXSIZE];
char y[MAXSIZE];
int c[MAXSIZE][MAXSIZE];
int b[MAXSIZE][MAXSIZE];
void LCS(int i,int j)
{
if(i==0||j==0)
return;
if(b[i][j]==1)
{
LCS(i-1,j-1);
cout<>x+1>>y+1;
int i,j;
for(i=0;i<=Length;i++)
c[i][0]=0;
for(i=0;i<=Length;i++)
c[0][i]=0;
for(i=1;i<=Length;i++)
{
for(j=1;j<=Length;j++)
{
if(x[i]==y[j])
{
c[i][j]==c[i-1][j-1]+1;
b[i][j]=1;
}else if(c[i-1][j]>=c[i][j-1])
{
c[i][j]=c[i-1][j];
b[i][j]=2;
}else{
c[i][j]=c[i][j-1];
b[i][j]=3;
}
}
}
LCS(Length,Length);
return 0;
} 24、作业调度
#include
#include
using namespace std;
class Flowshop{
friend Flow(int**,int,int[]);
private:
void Backtrack(int i);
int **M, //各作业所需的处理时间
*x, //当前作业调度
*bestx,//当前最优作业调度
*f2, //机器2完成处理时间
f1, //机器1完成处理时间
f, //完成时间和
bestf, //当前最优值
n; //作业数
};
void Swap(int &a,int& b)
{
int temp=a;
a=b;
b=temp;
}
void Flowshop::Backtrack(int i)
{
if(i>n)
{
if(ff1)?f2[i-1]:f1)+M[x[j]][2];
f+=f2[i];
if(f 25、循环赛日程表
#include
using namespace std;
void Table(int k,int** a)
{
int n=1;
int m=1;
for(int i=1;i<=k;i++)
n*=2;
for(int i=1;i<=n;i++)
a[1][i]=i;
for(int s=1;s<=k;s++)
{
n/=2;
for(int t=1;t<=n;t++)
for(int i=m+1;i<=2*m;i++)
for(int j=m+1;j<=2*m;j++){
a[i][j+(t-1)*m*2]=a[i-m][j+(t-1)*m*2-m];
a[i][j+(t-1)*m*2-m]=a[i-m][j+(t-1)*m*2];
}
m*=2;
}
}
int main()
{
int k=9;
int** a;
a=new int*[9];
for(int i=0;i<9;i++)
a[i]=new int[9];
Table(k,a);
for(int i=0;i<9;i++){
for(int j=0;j<9;j++){
cout< 26、旅行售货员
#include
using namespace std;
class Traveling{
friend int TSP(int**,int[],int,int);
public:
void Backtrack(int i);
int n,
*x,
*bestx;
**a,
cc,
bestc,
NoEdge;
};
void Traveling::Backtrack(int i)
{
if (i == n) {
if(a[x[n-1]][x[n]] 27、流水作业调度-动态规划
#include
#include
using namespace std;
class Jobtype{
public:
int operator < (Jobtype &a) const
{
return (keyb[i]?b[i]:a[i];
d[i].job=a[i]<=b[i];
d[i].index=i;
}
sort(d,d+n);
int j=0;
int k=n-1;
for(int i=0;i 28、快速排序2
#include
#include
using namespace std;
int Partition(int a[],int p,int r)
{
int i=p;
int j=r+1;
int x=a[p];
while(true){
while(a[++i]x) ;
if(i>=j)
break;
swap(a[i],a[j]);
}
a[p]=a[j];
a[j]=x;
return j;
}
void QuickSort(int a[],int p,int r)
{
if(p 29、递归：有重复元素的排列问题
#include
#include
using namespace std;
char ch[10];
int cnt=0;
int findsame(int k,int m)
{
for(int i=k;i>n;
cout<<"请输入"<>ch[i];
perm(0,n-1);
cout<<"count="< 30、递归：整数划分
#include
int q(int n,int m);
void result(int n,int k);
int a[100];
int main()
{
int i;
scanf("%d",&i);
printf("%d",q(i,i));
printf("\n");
result(i ,0);
return 0;
}
int q(int n,int m)
{
if((n<1)||(m<1))
return 0;
if((n==1)||(m==1))
return 1;
if(n0;i--)//从第一层开始
{
if(k==0||i<=a[k-1])//划分条件：a[k]>a[k+1]
{
a[k]=i;
result(n-i,k+1);//递归
}
}
}
} 31、动态规划01背包
#include
using namespace std;
int m[5][10];
int min(int i,int j)
{
return i>j?j:i;
}
int max(int i,int j)
{
return i>j?i:j;
}
void Knapsack(int* v,int* w,int c,int n)
{
int jMax=min(w[n]-1,c);
for(int j=0;j<=jMax;j++)
m[n][j]=0;
for(int j=w[n];j<=c;j++)
m[n][j]=v[n];
for(int i=n-1;i>1;i--)
{
jMax=min(w[i]-1,c);
for(int j=0;j<=jMax;j++)
m[i][j]=m[i+1][j];
for(int j=w[i];j<=c;j++)
m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]);
}
m[1][c]=m[2][c];
if(c>=w[1])
m[1][c]=max(m[1][c],m[2][c-w[1]]+v[1]);
}
void Traceback(int* w,int c,int n,int* x)
{
for(int i=1;i 32、动态规划-矩阵连乘
#include
using namespace std;
#define Row 2
#define Col 2
void MatrixChain(int *p,int n,int **m,int **s)
{
for(int i=0;i<=n;i++)
{
m[i][i]=0;
}
for(int r=2;r<=n;r++)
{
for(int i=1;i<=n-r+1;i++)
{
int j=i+r-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 33、动态规划：最长公共子序列
#include
using namespace std;
#define Max 100
#define size 7
int b[Max][Max];
int c[Max][Max];
char x[Max];
char y[Max];
void LCSLength(int m,int n)
{
int i,j;
for(i=1;i<=m;i++)
c[i][0]=0;
for(i=1;i<=n;i++)
c[0][i]=0;
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{
if(x[i]==y[j])
{
c[i][j]=c[i-1][j-1]+1;
b[i][j]=1;
}else if(c[i-1][j]>=c[i][j-1])
{
c[i][j]=c[i-1][j];
b[i][j]=2;
}else{
c[i][j]=c[i][j-1];
b[i][j]=3;
}
}
}
}
void LCS(int i,int j)
{
if(i==0||j==0)
return;
if(b[i][j]==1)
{
LCS(i-1,j-1);
cout<>x+1>>y+1;
LCSLength(size,size);
cout<<"The longest common subsequence="< 34、多级调度（贪心）
#include
#define MAXLENGTH 10
int d[MAXLENGTH];
int S[MAXLENGTH][MAXLENGTH];
struct work{
int hour;
int number;
};
work t[MAXLENGTH];
void bubble_sort(work a[], int n){
int i, j;
work temp;
for (j = 0; j < n - 1; j++){
for ( i = 0; i < n-1-j; i++)
{
if (a[i].hour0; j++)
{
printf("作业%d\t", S[i][j]);
}
printf("处理时间:%d\n",d[i]);
printf("\n");
}
} 35、分支限界-装载问题
void EnQueue(Queue&Q,int wt,int& bestw,inti,int n)
{
if(i==n)
{
if(wt>bestw)
bestw=wt;
}
else
Q.Add(wt);
}
template
Type MaxLoading(Type w[],Type c,int n)
{
Queue Q;
Q.Add(-1);
int i =1;
Type Ew=0;
Type bestw=0;
while(true)
{
if(Ew+w[i]<=c)
//x[i]=1
EnQueue(Q,Ew+w[i],bestw,i,n);
EnQueue(Q,Ew,bestw,i,n);
//x[i]=0
Q.Delete(Ew);
if(Ew==-1)
{
if(Q.IsEmpty())
return bestw;
Q.Add(-1);
Q.Delete(Ew);
i++;
}
}
} 36、活动安排
#include
using namespace std;
void GreedySelector(int n,int s[],int f[],bool A[])
{
A[1]=true;//该算法一开始选择活动1
int j=1;//变量j用以记录最近一次加入到A中的活动
for(int i=2;i<=n;i++)
{
if(s[i]>=f[j])//开始时间不早于最近加入集合A中的活动j的结束时间
{
A[i]=true;
j=i;
}else
A[i]=false;
}
}
int main()
{
int start[]={0,1,3,0,5,3,5,6,8,8,2,12};//活动开始时间
int end []={0,4,5,6,7,8,9,10,11,12,13,14};//活动结束时间（非减序排列）
bool A []={0,0,0,0,0,0,0,0,0,0,0,0};//存储所选择的活动
GreedySelector(11,start,end,A);
cout<<"结果:";
for(int i=1;i<=11;i++)
{
if(A[i]==1)
{
cout< 37、矩阵乘积标准式
#include
using namespace std;
#define Row 2
#define Col 2
void matrixMultiply(int a[Row][Col],int b[Row][Col],int c[Row][Col],int ra,int ca,int rb,int cb)
{
if(ca!=rb)
{
printf("矩阵不可乘");
exit(1);
}else{
for(int i=0;i 38、暴力解法
暴力就是枚举，一般就是,这个东西数据规模有限，直接枚举所有可能求解就好,不需要用到好的算
法。说暴力，意思就是,这里很简单,直接枚举就好,我就不用动态规划、bfs剪枝、平衡树什么的算法来解决了。换句话说，暴力就行了=数学题里面的"显然"。
就比如说指定1-1000中的任意一个数字让你猜,假如要猜的数字是500。你可以从1开始一个一个试，但也可以用二分法解决。循环套循环,遍历尝试所有可能的组合。大部分情况下会导致算法时间很长，但确实有用且简单。
例如要解密一个密文，只需要将所有可能的明文组合全部进行就可以了。暴力方法就是没有方法,一个个穷举所有可能性,是最容易想到的也是最慢的做法。
以01背包问题为例,这个问题的正确解法是DP,那.暴力做法是什么呢?就是穷举所有组合,把每样物品放入/不放入都试一遍,对于n件物品一共就有2^n中不同的选择,在不剪枝的情况下很快就会超时。