mooc上的OJ系统是mooc开发的？还是武汉理工开发的？这一点跟武汉理工机试的形式密切相关。
mooc上面的OJ系统最好练习下 dev
武汉理工mooc算法题目：
【贪心算法】
求解畜栏问题（20分）
题目内容：
有n头牛（1<=n<=50,000)要挤奶。给定每头牛挤奶的时间区间[A,B](1<=A<=B<=1,000,000，A,B为整数)。牛需要呆在畜栏里才能挤奶。一个畜栏同一时间只能容纳一头牛。问至少需要多少个畜栏，才能完成全部挤奶工作，以及每头牛都放哪个畜栏里？注意：在同一个畜栏的两头牛，它们挤奶时间区间不能在端点重合。
输入格式:
第1行：一个正整数N；
第2..N+1行：第i+1行的两个整数给出第i头奶牛的挤奶时间。
输出格式：
需要畜栏的最小数
输入样例：
5
1 10
2 4
3 6
5 8
4 7
输出样例：
4
#include <stdio.h>
#define MaxSize 10
typedef struct{
int start;
int end;
int flags;
}IntervalType;
int Partition(IntervalType a[],int s,int t){ //快排划分算法
int i = s,j = t;
IntervalType tmp = a[s];
while(i != j){
while(j > i && a[j].end >= tmp.end)
j--;
a[i] = a[j];
while(i < j && a[i].end <= tmp.end)
i++;
a[j] = a[i];
}
a[i] = tmp;
return i; //划分点
}
void QuickSort(IntervalType a[],int s,int t){ //快排
int i;
if(s < t){
i = Partition(a,s,t);
QuickSort(a,s,i - 1);
QuickSort(a,i + 1,t);
}
}
int maxCover(IntervalType x[],int n){
int i,j;
int sum = 0;
int flag = 1;
while(sum < n){
i = 0;
while(x[i].flags != 0)
i++;
x[i].flags = flag; //第一个区间
sum++;
for(j = i + 1;j < n;j++){
if(x[j].start > x[i].end){ //不相交
x[j].flags = flag; //标志位赋值
i = j;
sum++;
}
}
flag++; //标志位增加
}
return flag - 1; //畜栏总数
}
int main()
{
int num,i,n;
IntervalType x[MaxSize];
scanf("%d",&num);
for(i = 0;i < num;i++){
scanf("%d%d",&x[i].start,&x[i].end);
x[i].flags = 0;
}
Partition(x,,num); //按照开始时间排序排序 --->应该是按照结束时间排序
n = maxCover(x,num);
printf("%d\n",n);
for(i = 0;i < num;i++)
printf("%d\n",x[i].flags);
return 0;
}
// https://blog.csdn.net/weixin_43903478/article/details/88912092
// todo 以下解法没有看明白
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
struct Cow {
int b, e; // 挤奶区间起点和终点
int No; // 编号
bool operator < (const Cow & c) const {
return b < c.b;
}
} cows[50100];
int pos[50100]; // pos[i]表示编号为i的奶牛去的畜栏编号
struct Stall {
int end; // 结束时间
int No; // 编号
bool operator < (const Stall & s) const {
return end > s.end;
}
Stall (int e, int n) : end(e), No(n) {}
};
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &cows[i].b, &cows[i].e);
cows[i].No = i;
}
sort(cows, cows+n);
int total = 0;
priority_queue<Stall> pq;
for (int i = 0; i < n; i++) {
if (pq.empty()) {
++total;
pq.push(Stall(cows[i].e, total));
pos[cows[i].No] = total;
} else {
Stall st = pq.top();
if (st.end < cows[i].b) { // 端点也不能重合
pq.pop();
pos[cows[i].No] = st.No;
pq.push(Stall(cows[i].e, st.No));
} else {
++total;
pq.push(Stall(cows[i].e, total));
pos[cows[i].No] = total;
}
}
}
printf("%d\n", total);
for (int i = 0; i < n; i++) {
printf("%d\n", pos[i]);
}
return 0;
}
2求解区间覆盖问题（20分）
题目内容：
设x1,x2,... ,xn是实直线上的n个点。用固定长度的闭区间覆盖这n个点，至少需要多少个这样的固定长度闭区间?设计求解此问题的有效算法。对于给定的实直线上的n个点和闭区间的长度k，编程计算覆盖点集的最少区间数。
输入格式:
输入数据的第一行有2个正整数n和k，表示有n个点，且固定长度闭区间的长度为k。接下来的1行中，有n个整数，表示n个点在实直线上的坐标（可能相同）。
输出格式：
将编程计算出的最少区间数输出。
输入样例：
7 3
1 2 3 4 5 -2 6
输出样例：
3
https://wenku.baidu.com/view/69bcaf768e9951e79b8927ca.html
（这个是之前复习江南大学的算法题目整理的，还不错）
int greedy(vector<int> x,int k){
int i,sum=1,n=x.size();
sort(x.begin,x.end());
int temp = x[0]; // 区间的起始位置
for(i=1;i<n;++i)
if(x[i] - temp > k){
sum++;
temp = x[i];
}
return sum;
}
-----------------------
【算法基础】
（这道题目按照考试场景应该属于简单的题目，但是自己却想不出来）
1Smith数问题（20分）
题目内容：
若一个正整数的质因数分解式逐位相加之和等于其本身逐位相加之和，则称这个数为 Smith 数。如 4937775=3*5*5*65837，而 3+5+5+6+5+8+3+7=42，4+9+3+7+7+7+5=42，所以 4937775 是 Smith 数。给定一个正整数 N，求大于 N 的最小Smith 数。
输入格式:
若干个正整数，一行代表一个正整数 N，以输入 0 表示结束
输出格式：
按行输出大于正整数N 的最小 Smith 数
输入样例：
4937774
200
0
输出样例：
4937775
202
时间限制：500ms内存限制：32000kb
#include <stdio.h>
#include <math.h>
int isSmith(int);
int isPrime(int);
int everySum(int);
int main()
{
int num;
int flag = 0;
while((scanf("%d",&num) != EOF) && (num != 0)) {
flag = 0;
for(int i = num + 1; ; i++) {
if( isSmith(i) ) {
printf("%d\n",i);
flag ++;
}
if(flag == 1){
break;
}
}
}
return 0;
}
int isSmith(int n) {
int i,b = n;
int num[1000],x = 0;
int sum = 0;
while( !isPrime(n)) {
for(i = 2; i < n; i++) {
if( isPrime(i) && n % i == 0)
{
num[x] = i;
x++;
break;
}
}
n /= i;
}
num[x] = n;
for( i = 0; i <= x; i++) {
sum += everySum(num[i]);
}
if(sum == everySum(b))
return 1;
else
return 0;
}
int isPrime(int x) {
int i,num = 1;
for(i = 2; i < x; i++) {
if( x % i == 0) {
num = -1;
break;
}
}
if(num == 1)
return 1;
else
return 0;
}
//自己：判断是否是素数改为下面的情况更好
bool isPrime(int x) //判断整数x是否是素数
{
int n = (int)sqrt(x);
for(int i=2; i<=n; i++)
if(x%i == 0) return false;
return true;
}
int everySum(int x) {
int sum = 0;
while(x > 0) {
sum += x % 10;
x /= 10;
}
return sum;
}
这道题目比较容易，可以省略。
2最接近数问题（20分）
题目内容：
设计算法找出整数数组a[n]（n<=50）中相差最小的两个元素（称为最接近数）的差。
输入格式:
第一行为数组大小n，第二行为n个数组元素，元素之间用空格分开
输出格式：
最接近数的差
输入样例：
5
65 38 26 75 40
输出样例：
2
武汉理工课后习题 先用快速排序的模板进行排序
if(a[i+1]-a[i] <= a[i+2] - a[i+1]) value = a[i+1]-a[i];
else value = a[i+2] - a[i+1];
【分治法】
1循环左移问题（20分）
题目内容：
设计分治算法实现将字符数组A[n]中所有元素循环左移k个位置,例如，对abcdefgh循环左移3位得到defghabc。
输入格式:
第一行为数组长度n
第二行为循环左移数k
第三行为数组中元素
输出格式：
循环左移k个位置后的结果
输入样例：
8
3
abcdefgh
输出样例：
defghabc
自己：忽略了一点，分治法并不一定等分为两份
// 采用分治法
// 将数组分为 0-k-1 和 k-n-1 两块
// 将这两块分别左移
// 然后再合并左移
#include<stdio.h>
void reverse(int begin,int end,char a[]){
int k = end-begin+1;
for(int i=0;i<k/2;i++){
int temp=a[begin+i];
a[begin+i]=a[end-i];
a[end-i]=temp;
}
}
int main(){
int n,k;
char a[1000];
scanf("%d%d%s",&n,&k,a);
reverse(0,k-1,a);
reverse(k,n-1,a);
reverse(0,n-1,a);
printf("%s",a);
return 0;
}
2逆序数问题（20分）
题目内容：
设a1, a2,…, an是集合{1, 2, …, n}的一个排列，如果i<j且ai>aj，则序偶(ai, aj)称为该排列的一个逆序。例如，2, 3, 1有两个逆序：(3, 1)和(2, 1)。设计算法统计给定排列中含有逆序的个数。
输入格式:
第一行输入集合中元素个数n，第二行输入n个集合元素
输出格式：
含有逆序的个数
输入样例：
3
2 3 1
输出样例：
2
todo 记得华科之前考过 没有看明白 暂时先背下来
由于是对元素进行比对，考虑在排序中进行计数的可能，将数组视作n个小集合，每个集合中初始含有一个元素，将集合两两合并并且进行排序，在排序中计数逆序的个数（如果调整前满足逆序条件那么计数，如果为顺序则不做处理），依次向上排序直到最终合成一个有序数组。
由于在排序时可以是做是两个有序集合之间在对比，每次取集合的第一个元素与另一个集合的第一个元素进行对比，满足条件后其后的元素都不再需要对比，直接计数即可（即计数的核心代码 mid-i+1），满足需要的排序方法为归并排序，实际上只需要在归并排序的程序中插入一条代码就可以满足条件。
#include
#include<stdlib.h>
using namespace std;
int number=0;
void Merge(int left,int right,int mid,int *a,int *b){
int i=left;
int j=mid+1;
int k=left;
if(i!=mid+1&&j!=right+1){
if(a[i]>a[j]){
b[k++]=a[j++];
number=number+mid-i+1;
}
else
b[k++]=a[i++];
}
while(i!=mid+1)
b[k++]=a[i++];
while(j!=right+1)
b[k++]=a[j++];
for(i=left;i<=right;i++)
a[i]=b[i];
}
void Mergesort(int left,int right,int *a,int b){
int mid;
if(left<right){
mid=(left+right)/2;
Mergesort(left,mid,a,b);
Mergesort(mid+1,right,a,b);
Merge(left,right,mid,a,b);
}
}
int main(void){
int n,i;
int a[100],b[100];
cin>>n;
for(i=0;i<n;i++)
cin>>a[i];
Mergesort(0,n-1,a,b);
cout<<number<<endl;
system(“pause”);
return 0;
}
————————————————
#include<cstdio>
using namespace std;
int count=0;
int b[1000];
void merge(int a[],int begin,int mid,int end){
int l=begin,m=mid+1,r=end,n=0;
while(l<=mid&&m<=r){
if(a[l]<=a[m]){
b[n++]=a[l];
l++;
}
else{
b[n++]=a[m];
m++;
count+=mid-l+1;
}
}
while(l<=mid) {
b[n++]=a[l++];
}
while(m<=r){
b[n++]=a[m++];
}
for(int i=0;i<n;i++){
a[begin++]=b[i];
}
}
void mergeSort(int a[],int b,int e){
if(b<e){
int mid=(b+e)/2;
mergeSort(a,b,mid);
mergeSort(a,mid+1,e);
merge(a,b,mid,e);
}
}
int main(){
int n,a[1000];
scanf("%d",&n);
for(int i=0;i<n;i++) scanf("%d",&a[i]);
mergeSort(a,0,n-1);
printf("%d",count);
return 0;
}
-----------------------------
----------------------------------------
【动态规划】
拦截导弹问题（20分）
题目内容：
某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。
输入格式：
第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。
输出格式：
输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。
输入样例：
8
300 207 155 300 299 170 158 65
输出样例：
6
最长不增子序列 P231
见王道P231
------------------------------
2新水果取名（20分）
题目内容：
两种水果杂交出一种新水果，现在给新水果取名，要求这个名字中包含以前两种水果的字母，且名字尽量短，即：以前的水果名字arr1、arr2是新水果名arr的子序列，使用动态规划的思想设计算法得到新水果名arr。
输入格式:
以空格分开两个水果的名字
输出格式：
新水果的名字
输入样例：
pear peach
输出样例：
pearch
输入样例：
peach pear
输出样例：
peachr
todo 网上：《算法设计与分析学习指导》李春葆 考试前参照这个看看
https://blog.csdn.net/m0_45338067/article/details/109628853
https://www.pianshen.com/article/7735291382/
3机器人路径规划（20分）
题目内容：
一个机器人只能向下和向右移动，每次只能移动一步，设计一个算法求机器人从（1,1）到（m，n）有多少条路径。
输入格式:
以空格分开m，n
输出格式：
路径条数
输入样例：
4 5
输出样例：
35
（解法一）
// 递归，但不是动态规划，感觉这个题目2019年江南大学考过
using namespace std;
int robot(int x, int y);
int main() {
int n, m;
cin >> n >> m;
cout << robot(n, m);
return 0;
}
int robot(int x, int y) {
if (x == 1 && y == 1) {
return 1;
}
else if (x == 1) {
return robot(x, y - 1);
}
else if (y == 1) {
return robot(x - 1, y);
}
else {
return robot(x - 1, y) + robot(x, y - 1);
}
}
（解法二 属于动态规划算法中比较容易的题目了）
import java.util.Scanner;
public class Main {
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
int x=input.nextInt()+1;
int y=input.nextInt()+1;
print(x,y);
}
public static void print(int x,int y)
{
int L[][]=new int [x][y];
//进行初始化//可以不用这样设定，但是我个人习惯上将边界定为0
for(int i=0;i<x;i++)
{
L[i][0]=0;
}
for(int i=0;i<y;i++)
{
L[0][i]=0;
}
for(int i=1;i<x;i++)
{
for(int j=1;j<y;j++)
{
L[i][j]=1;
}
}
//
for(int i=2;i<x;i++)
{
for(int j=2;j<y;j++)
{
L[i][j]=L[i-1][j]+L[i][j-1];//中间部分到每个点都有两条路可走
}
}
System.out.print(L[x-1][y-1]);
}
}
类似于王道机试指南P224 先设置边界，初始值，在进行动态规划。
----------------------
【回溯法】
1求解最小机器重量设计问题（20分）
题目内容：
设某一机器由n个部件组成,部件编号为1~n，每一种部件都可以从m个不同的供应商处购得，供应商编号为1~m。设wij是从供应商j处购得的部件i的重量,cij是相应的价格。对于给定的机器部件重量和机器部件价格，计算总价格不超过d的最小重量机器设计。（注意：输出结果中第一行最后没有空格。比如下面的输出样例中1 3 1后面没有空格。）
输入格式:
第1行输入3个正整数n,m和d。接下来n行输入wij（每行m个整数），最后n行输入cij（每行m个整数）,这里1≤n、m≤100。
输出格式：
输出的第1行包括n个整数，表示每个对应的供应商编号，第2行为对应的最小重量。
输入样例：
3 3 7
1 2 3
3 2 1
2 3 2
1 2 3
5 4 2
2 1 2
输出样例：
1 3 1
4
todo
https://blog.csdn.net/weixin_42997798/article/details/89332717
https://blog.csdn.net/initiallht/article/details/85227395
http://www.rkpass.cn/tk_timu/6_77_4_anli.html
2求解部分和问题（20分）
题目内容：
给出N个正整数组成的数组A，求能否从中选出若干个，使他们的和为K。如果可以，输出："YES"，否则输出"NO"。
输入格式:
第1行：2个数N、K, N为数组的长度, K为需要判断的和(2 ≤N ≤ 20，1 ≤ K ≤ 10^9)
第2 到第 N + 1行：每行1个数，对应数组的元素A[i] (1 ≤ A[i]≤ 10^6)
输出格式：
如果可以，输出："YES"，否则输出"NO"。
样例输入
4 13
1
2
4
7
样例输出
YES
输入样例：
5 9
1
2
3
4
5
输出样例：
YES
todo
https://blog.csdn.net/Komatsu_1137/article/details/103985432
https://blog.csdn.net/qq_40909347/article/details/89289925
--------------------------------
【分支限界法】（自己感觉分支限界法不是重点，武汉理工可能不考，或者只考1道题，掌握经典案例即可）
1迷宫问题（20分） （江南大学2019年考过，word也有整理，务必背下来，算法笔记，武汉理工课后习题都有，此处略）
题目内容：
定义一个二维数组，例如：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
输入格式:
一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一最短路径。
输出格式：
左上角到右下角的最短路径，格式如样例所示。
输入样例：
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出样例：
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)
-------------
From LeetCode:
方法一：自顶向下的递归
class Solution {
public:
int height(TreeNode* root) {
if (root == NULL) {
return 0;
} else {
return max(height(root->left), height(root->right)) + 1;
}
}
bool isBalanced(TreeNode* root) {
if (root == NULL) {
return true;
} else {
return abs(height(root->left) - height(root->right)) <= 1 && isBalanced(root->left) && isBalanced(root->right);
}
}
};
方法二：自底向上的递归
方法一由于是自顶向下递归，因此对于同一个节点，函数 height 会被重复调用，导致时间复杂度较高。如果使用自底向上的做法，则对于每个节点，函数 height 只会被调用一次。
自底向上递归的做法类似于后序遍历，对于当前遍历到的节点，先递归地判断其左右子树是否平衡，再判断以当前节点为根的子树是否平衡。如果一棵子树是平衡的，则返回其高度（高度一定是非负整数），否则返回 -1−1。如果存在一棵子树不平衡，则整个二叉树一定不平衡。
class Solution {
public:
int height(TreeNode* root) {
if (root == NULL) {
return 0;
}
int leftHeight = height(root->left);
int rightHeight = height(root->right);
if (leftHeight == -1 || rightHeight == -1 || abs(leftHeight - rightHeight) > 1) {
return -1;
} else {
return max(leftHeight, rightHeight) + 1;
}
}
bool isBalanced(TreeNode* root) {
return height(root) >= 0;
}
};
#include<iostream>
#include<string.h>
#include<algorithm>
#include <fstream>
#include <sstream>
#define max(a,b) (a>b?a:b)
using namespace std;
int dp[1100][1100];
int MAX;
int main()
{
int i,j,n,m,T,x,y;
ifstream cinfile;
cinfile.open("input.txt",ios::in);
cinfile>>T;
// scanf("%d",&T);
while(T--)
{
// scanf("%d %d %d %d",&n,&m,&x,&y);
cinfile>>n>>m>>x>>y;
MAX=0;
memset(dp,0,sizeof(dp));
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
{
// scanf("%d",&dp[i][j]);
cinfile>>dp[i][j];
dp[i][j]+=dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1];
if(i>=x&&j>=y)
{
MAX=max(MAX,dp[i][j]-dp[i][j-y]-dp[i-x][j]+dp[i-x][j-y]);
}
}
// printf("%d\n",MAX);
cinfile.close();
ofstream outfile;
outfile.open("output.txt",ios::out);
outfile<<MAX<<endl;
}
return 0;
}
-------------------
《算法笔记》
无穷大：
const int INF = (1<<30) - 1;
const int INF = 0x3fffffff;
数据类型：
longlong scanf("%lld",&n);
double scanf("%lf",&db);
fabs 而不是 abs()
P46
int a[5] = {1,2,3,4,5};
memset(a,0,sizeof(a)); ------ string.h
字符数组：char str[15] = {'G','o','o','d'};
P195
for(vector<int>::iterator it = vi.begin();it != vi.end;i++){
printf("%d ",*it);
}
push_back()
pop_back()
size()
clear()
insert()
vi.insert(vi.begin() + 2 ,-1); // 将-1插入vi[2]的位置
erase()
vi.erase(vi.begin() + 1,vi.begin() + 4); // 删除vi[1],vi[2],vi[3]
-------------
set -- 集合，是一个内部自动有序且不含重复元素的容器。
#include <set>
set只能通过迭代器iterator访问：
set<typename>::iterator it;
insert()
find()
erase()
删除单个元素：
方法1：st.erase(st.find(100)); // 利用find()函数找到100，然后利用erase删除他
方法2：st.erase(100);//删除set中值为100的元素
删除一个区间内的所有元素：
set<int>::iterator it = st.find(30);
st.erase(it,st.end()); // 删除元素30至set末尾之间的元素
size()
clear()
string：(自己：把他看为php语法即可)
#include <string>
str[i]; // 通过下标访问
通过迭代器访问：
string::iterator it;
for(string::iterator it = str.begin();it != str.end();it++){
printf("%c",*it);
}
(1)+= + ---------拼接
（2） == != > 等等 比较大小 字典序
（3）length() 或 size()
insert(pos,string);
eg：
string str = "abcxyz",str2 = "opq";
1）insert(3,str2); // 往str[3]处插入opq,这里str2的位置直接写”opq“也是可以的
2）str.insert(str.begin()+3,str2.begin(),str2.end());
earse
(1) str.erase(str.begin()+4);
(2) str.erase(str.begin()+2,str.end()-1)
(3)str.erase(pos,length) str.erase(3,2) 删除从3号位开始的2个字符
clear()
substr(pos,len)
string::npos
-------------------
P213
#include <map>
map<string,int> mp;
map<char,int> mp;
mp['c'] = 20;
mp['c'] = 30; // 20被覆盖
for(map<char,int>::iterator it = mp.begin();it != mp.end();it++){
printf("%c %d\n", it->first,it->second());
}
map会以键从大到小的顺序自动排序，set也是（红黑树）
常用函数：
find(key)
map<char,int>::iterator it = mp.find(b);
printf("%c %d\n", it->first,it->second());
erase()
1)删除单个元素：
mp.erase(it) it为需要删除的元素的迭代器
或者：mp.erase(key)
eg: mp.erase('b');
2）删除一个区间内的所有元素
map<char,int>::iterator it = mp.find('b');
mp.erase(it,mp.end());
size()
claer()
#include <queue>
push()
front() back() 可以分别获得队首元素和队尾元素
size()
empty()
使用front()和pop()函数前，必须使用empty()判断队列是否为空
双端队列(deque)---略
优先队列 priority_queue
头文件也是 #include <queue>
和队列不一样的是，优先队列没有front()和back()函数，而只能通过top()函数来访问队首元素（也可以成为堆顶元素），也就是优先级别最高的元素
push()
top()
pop()
empty()
size()
priority_queue<int> q;
priority_queue<int,vector<int>,less<int> > q;
priority_queue<int,vector<int>,greater<int> > q;
less<int>表示数字大的优先级别越大，而greater<int> 表示数字小的优先级越大。
stack
push()
top()
pop()
empty()
size()
pair ---- 略
#include <algorithm>
max() min() abs() swap(x,y)
int a[10] = {10,11,12,13,14,15};
reverse(a,a+4);
next_permutation() 略
fill() 针对数组或者容器 和memset不同，这里的赋值可以是数组类型对应范围中的任意值
int a[5] = {1,2,3,4,5};
fill(a,a+5,233); //将a[0]-a[4]均赋值为233
sort(首元素地址(必填),尾元素地址的下一个地址（必填）,比较函数（非必填));
在STL标准容器中，只有vector、string、deque是可以使用sort()的。
lower_bound() 和 upper_bound() ---- 略
投递喜马拉雅等公司10个岗位
