C++STL常用介绍

vector

vector,向量，也叫做边长数组。相比较平时我们定义的数组如：

int A[maxsize]；

而言，vector的长度可变，而平时的数组的长度固定，maxsize的取值不好确定。

1.定义

需要添加头文件

#include<vector>
using namespace std;

定义也很简单

vector<类型> 名称;
vector<int> ve;//举例
vector<char> ve;
vector<double> res;

2.迭代器

定义：概念略似指针，一些函数的使用和一些容器必须用迭代器访问，因此很重要，如set。这里的vector支持迭代器访问和直接访问（ve[0]这种写法）

vector<类型>::iterator it;
//其中 如果要访问int类型的vector就必须要把对应的迭代器的类型为int，如:
vector<int> ve;//int 类型的变长数组
vector<int>::iterator it;//对应为int的迭代器
it=ve.begin();//it指向ve的第一个元素
it=ve.end();//it指向ve最后一个元素的下一个元素，即不存在的那个位置通常用来判断循环结束
//如：
for(it=ve.begin();it!=ve.end();it++)
//it从第一个开始，遍历到最后一个元素结束，结束时，it指向最后一个元素的下一个元素，此时it==ve.,end()因此退出循环。
//如果我想要打印对应的值
printf("%d",(*it));
//*it 就对对应的值
x=*it;//把it位置的值给x

3.vector的常用函数：

1.push_back(x);//x为变量
2.pop_back();
3.size();
4.clear();
5.insert(it,x);//it为迭代器，x是变量
6.erase（it）;//it为迭代器
7.erase(first,last);//删除从first到last的所有元素

用法举例：

vector<int> ve;
ve.push_back(1);//将1压入数组,此时数组里有：1
ve.pop_back();//弹出数组最后的一个数，此时数组里有： 
a=ve.size();//a的值应该为0
//以下注释部分为ve数组里面数
ve.push_back(2);//2
ve.push_back(3);//2 3
ve.push_back(4);//2 3 4
ve.push_back(5);//2 3 4 5
vector<int>::iterator it=ve.begin();//it指向2
insert(it,6);//6 2 3 4 5
it++;//it指向从6进到2
erase(it);//6 3 4 5
erase(it,it+1);//6 5
ve.clear();//

4.二维边长数组

定义两种方法：

vector<类型> A[maxsize];//定义一个x固定maxsize长，而y方向变长的数组
vector<vector<类型> >// >>中间有空格,这是两个维度都是变长的数组

5.题目举例

由于一时没找到比较好的题目，拿这题举例。
题目链接: 跳转地址

这一题的思想主要是用动态规划：
1.先从左上向右下遍历一次，每个点到0的距离等于左边的距离和上边的距离的最小值+1。
2.从右下向左上遍历一次，每个点到0的距离等于右边的距离和下边的距离的最小值+1。
这样就实现了当前点到0的距离为上下左右的最小值+1。
但这不是重点，题目给出条件：
给定矩阵的元素个数不超过 10000。
但xy<=10000;可能是100100也可能10000*1。
如果使用 int A[maxsize][maxsize];定义数组，maxsize必须设置为10001以上，内存浪费大，且可能超过内存限制，采用二维边长数组定义，就会小得多。

代码：

class Solution {
public:

    const int INF=10000000;
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        vector<vector<int> > ve;
        vector<int> vt;
        for(int i=0;i<matrix.size();i++){
            vt.clear();
            for(int j=0;j<matrix[0].size();j++){
                if(matrix[i][j]!=0)
                vt.push_back(INF);
                else{
                    vt.push_back(0);
                }
            }
            ve.push_back(vt);
        }
        for(int i=0;i<matrix.size();i++){
            for(int j=0;j<matrix[0].size();j++){
                if(ve[i][j]!=0){
                    if(i-1>=0)
                    ve[i][j]=min(ve[i][j],ve[i-1][j]+1);
                    if(j-1>=0)
                    ve[i][j]=min(ve[i][j],ve[i][j-1]+1);
                }
            }
        }
        for(int i=matrix.size()-1;i>=0;i--){
            for(int j=matrix[0].size()-1;j>=0;j--){
                if(ve[i][j]!=0){
                    if(i+1<=matrix.size()-1)
                    ve[i][j]=min(ve[i][j],ve[i+1][j]+1);
                    if(j+1<=matrix[0].size()-1)
                    ve[i][j]=min(ve[i][j],ve[i][j+1]+1);
                }
            }
        }
        
        return ve;
        
    }
};