Bellman-Ford负权值最短路模版

1.n个点，m条边，含有负边。
2.外层循环n-1次，内层循环m次，进行松弛
3.添加check变量判断本轮是否进行松弛了，如果未进行松弛则可以提前退出循环
4.处理有向边时，注意u[i]和v[i]的顺序不要颠倒

#include <iostream>
using namespace std;
int main() {
    int dis[20001] = {0}, u[200001], v[200001],w[200001]
    int n, m, inf = 99999999;
    fill(dis+2,dis+20001,inf);
    scanf("%d %d", &n, &m);
    for(int i = 1;  i <= m; i++){
        scanf("%d %d %d",&u[i], &v[i], &w[i]);
    }
    for(int k = 1; k <= n - 1; k++){
        int  check = 0;
        for(int i = 1; i <= m; i++){
            if(dis[v[i]] > dis[u[i]] + w[i]){
                dis[v[i]] = dis[u[i]] + w[i];
                check = 1;
            }
        }
        if(check == 0) break;
    }
    for(int i = 2; i <= n; i++){
        printf("%d\n",dis[i]);
    }
}

#include <iostream>

using namespace std;

int main() {

int dis[20001] = {0}, u[200001], v[200001],w[200001]

int n, m, inf = 99999999;

fill(dis+2,dis+20001,inf);

scanf("%d %d", &n, &m);

for(int i = 1; i <= m; i++){

scanf("%d %d %d",&u[i], &v[i], &w[i]);

}

for(int k = 1; k <= n - 1; k++){

int check = 0;

for(int i = 1; i <= m; i++){

if(dis[v[i]] > dis[u[i]] + w[i]){

dis[v[i]] = dis[u[i]] + w[i];

check = 1;

}

if(check == 0) break;

}

for(int i = 2; i <= n; i++){

printf("%d\n",dis[i]);

}

优先队列使用

优先队列详解和使用

1.优先队列和普通队列相似，但是出队按照优先级高的先出队，进队和出队时间复杂度都为O(log2n)。

2.因为内部原理是用堆实现，插入时候把堆调整（花费o(log2n)）,删除时直接删除堆顶（O(1)），然后把剩下元素调整（O(long2 n)）。把一个原始无序集合，通过完全二叉树够造成堆花费O(nlog2n)。

3.（1）.适用于动态添加和删除时，实时维护最值。(2).也可用于n个元素取前k个（比如10G的数据，取前100个最值，在内存不够情况下，只需要开辟100个数据的堆空间，把这10G数据依次读取进/出优先队列（堆）,即可解决内存的问题，而且时间复杂度在nlong2k）。

//比较优先级的方法
//1. 在队列元素的内部定义比较方法 例如：
//默认 优先级/排序
struct node{
    int value1, value2;
    friend bool operator > (const node a, const node b){ 
        if(a.value1 == b.value1) return a.value1 < b.value1;
        else a.value2 == b.value2;
    }
};
//    注意这里是升序排序,  node1 < node2 < node3
//    所以优先级和顺序一样 node1 < node2 < node3
//    sort()         排列后顺序为 node1 , node2 , node3
//    priority_queue 按照优先级大出队, 依次出队 node3, node2, node1
------------------------------------------------------------------------
//2. 指定 优先级/排序
//例子1 priority_queue<T, vector<T>, less<T> > q; 大顶堆, vector为指定内部实现结构。
//     注意哦：< < 之间要留空格，不然会被编译器认为 << 是一对哦
     
//例子2 
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct node {
    int value1, value2;
    friend bool operator < (const node &a, const node &b) {
        if (a.value1 != b.value1) return a.value1 < b.value1;
        else a.value2 < b.value2;
    }
};
struct cmp {
    bool operator()(const node &a, const node &b) {
        if (a.value1 != b.value1) return a.value1 > b.value1;
        else a.value2 > b.value2;
    }
};
int main() {
    priority_queue<int, vector<int>, cmp> q;
}
//（1）在外面指定比较用结构体,建堆方式用指定规则
//（2）外部指定比内部定义优先级高,同时出现以指定的为准
// 注意：排序是需要指定的是比较函数,优先队列指定的是比较用的结构体
//      比如 排序传 less<T>(),  优先队列传less<T>

//比较优先级的方法

//1. 在队列元素的内部定义比较方法例如：

//默认优先级/排序

struct node{

int value1, value2;

friend bool operator > (const node a, const node b){

if(a.value1 == b.value1) return a.value1 < b.value1;

else a.value2 == b.value2;

}

};

// 注意这里是升序排序, node1 < node2 < node3

// 所以优先级和顺序一样 node1 < node2 < node3

// sort() 排列后顺序为 node1 , node2 , node3

// priority_queue 按照优先级大出队, 依次出队 node3, node2, node1

------------------------------------------------------------------------

//2. 指定优先级/排序

//例子1 priority_queue<T, vector<T>, less<T> > q; 大顶堆, vector为指定内部实现结构。

// 注意哦：< < 之间要留空格，不然会被编译器认为 << 是一对哦

//例子2

#include <iostream>

#include <queue>

#include <vector>

using namespace std;

struct node {

int value1, value2;

friend bool operator < (const node &a, const node &b) {

if (a.value1 != b.value1) return a.value1 < b.value1;

else a.value2 < b.value2;

}

};

struct cmp {

bool operator()(const node &a, const node &b) {

if (a.value1 != b.value1) return a.value1 > b.value1;

else a.value2 > b.value2;

}

};

int main() {

priority_queue<int, vector<int>, cmp> q;

}

//（1）在外面指定比较用结构体,建堆方式用指定规则

//（2）外部指定比内部定义优先级高,同时出现以指定的为准

// 注意：排序是需要指定的是比较函数,优先队列指定的是比较用的结构体

// 比如排序传 less<T>(), 优先队列传less<T>

c++为例
初始化	priority_queue<T> q;
入队	q.push();
出队	q.pop();
队头( 优先队列队头是top，普通的是front )	q.top()
元素个数	q.size();
判断队是否空	q.empty();

c语言文件读入与写入

实现控制台与文件写入的自由切换

C语言中文件流读入写入
#include <stdio.h>
#include <stdlib.h>
int main () {
    FILE *fin  = fopen ("test.in", "r");
    FILE *fout = fopen ("test.out", "w");//覆盖文件
    // FILE *fout = fopen ("test.out", "w+");//追加文件
    int a, b;
    fscanf (fin, "%d %d", &a, &b);     
    fprintf (fout, "%d\n", a+b);
    exit (0);
}

c++读取写入文件 
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main() {
    ofstream fout ("test.out");
    ifstream fin ("test.in");//追加文件
    // ifstream fin ("test.in", ios::app);//覆盖文件
    int a, b;
    fin >> a >> b;
    fout << a+b << endl;
    return 0;
}

C语言中文件流读入写入

#include <stdio.h>

#include <stdlib.h>

int main () {

FILE *fin = fopen ("test.in", "r");

FILE *fout = fopen ("test.out", "w");//覆盖文件

// FILE *fout = fopen ("test.out", "w+");//追加文件

int a, b;

fscanf (fin, "%d %d", &a, &b);

fprintf (fout, "%d\n", a+b);

exit (0);

}

c++读取写入文件

#include <iostream>

#include <fstream>

#include <string>

using namespace std;

int main() {

ofstream fout ("test.out");

ifstream fin ("test.in");//追加文件

// ifstream fin ("test.in", ios::app);//覆盖文件

int a, b;

fin >> a >> b;

fout << a+b << endl;

return 0;

}

完全由文件输入或输出

继续阅读“c语言文件读入与写入”

c语言整数浮点数读入格式

float duoble
    scanf 时用%f、%lf ;
    printf时都用%f;
long double 
    都用%Lf

long long 
    输入输出都用 %lld;

字符串转换成数字
        stoi stol stoll stof stod stold  ->
        int, long, long long, float, double ,long double

float duoble

scanf 时用%f、%lf ;

printf时都用%f;

long double

都用%Lf

long long

输入输出都用 %lld;

字符串转换成数字

stoi stol stoll stof stod stold ->

int, long, long long, float, double ,long double

set使用技巧

#include <set>
{
set中会自动排序，由小到大，插入时，红黑树
set<int> s;// char string

int arr[5] = {0,1,2,3,4};
set<int> iset(arr,arr+5);
vector<int>::iteartor it;

s.begin() //s首地址
*s.begin()//首元素；
s.begin()++//允许
s.begin+1//不允许

s.size()//元素个数；
s.insert(n);//插入n;
s.clear()//清空s;
bool is = s.empty();
循环
for(int i : s)
cout << i;
for(auto i = s.begin(); i <= s.end(); i++)
cout << *i;
查找
s.find(n) == s.end()//没找到，一直查到尾
s.find(n) != s.end()//找到了，停在找到的位置了
s.count(n) == 1//有次元素，找到了
s.count(n) == 0//无此元素，没找到
it = s.find(n)//
擦除
s.erase(n)//删除n;
s.erase(s.begin(),s.begin() + 4)//

}

#include <set>

{

set中会自动排序，由小到大，插入时，红黑树

set<int> s;// char string

int arr[5] = {0,1,2,3,4};

set<int> iset(arr,arr+5);

vector<int>::iteartor it;

s.begin() //s首地址

*s.begin()//首元素；

s.begin()++//允许

s.begin+1//不允许

s.size()//元素个数；

s.insert(n);//插入n;

s.clear()//清空s;

bool is = s.empty();

循环

for(int i : s)

cout << i;

for(auto i = s.begin(); i <= s.end(); i++)

cout << *i;

查找

s.find(n) == s.end()//没找到，一直查到尾

s.find(n) != s.end()//找到了，停在找到的位置了

s.count(n) == 1//有次元素，找到了

s.count(n) == 0//无此元素，没找到

it = s.find(n)//

擦除

s.erase(n)//删除n;

s.erase(s.begin(),s.begin() + 4)//

}

容器的使用

#include <vecoter>
{ 
  初始化
  //vector从0下标开始；
  vector<int> v， v1;//空容器
  vector<int> v(3)//包含3个元素；
  vector<int> v(3,9)//包含3个元素,每个元素都是9；
  vector<int> v(v1)//copy v1;
  int a[3] = {0,1,2};
  vector<int> v(a,a+3)//copy a数组；
  
  状态
  v.size()//返回v个数，空是时候是0，空时不可atuo i = v.begin();
  v.begin()//首地址
  v.end()//末元素地址+1；for里终止条件 auto i != v.end(); i < end(); i <= v.end()-1;
         //有点像数组最后一位的空位置
  v.at(i) == v[i]//推荐使用后者；
  bool is = v.empty();/空返回true，不空返回false;
  v.push_back(n)//在尾部添加n进容器；
  v.pop_back()//删除尾元素；
  二维容器
  vector<vector<int>> v1;
  vector<int> v[5];
  vector<>
    
  vector<vector<int>> ans(r,vector<int>(c));//初始化r行c列的容器
  v1.size()//v1有几行
  v1[i].size()//v1[i]几行有几个元素，即有几列

    
  遍历
  for(int i : v)
        cout << i;
  for(auto i = v.begin() ; i < v.end() ; i++ ) 
        cout << *i;////auto 推荐使用；
   for(auto i = v.begin() ; i ！= v.end() ; i++ ) 
        cout << *i;
  for(vector<int>::iterator it = vecIntB.begin() ;it!=vecIntB.end();it++)   
        cout<<*it;
 
    
  删除
    v.erase(v.begin()+2)//删除第3个元素（v.begin()+2地址所在）；
    v.erase(v.begin()+2，v.begin()+5)//删除第3-5个元素
    v.erase(v.begin(),v.end());//清空
    v.clear() ;//清空；
    v.begin()+1//允许这样操作  
  v.pop_back() & v.erase() & v.push_back 后 v.size() 会变；
    
       
    如有错误，欢迎指正，如有不足，欢迎补充。
}

#include <vecoter>

{

初始化

//vector从0下标开始；

vector<int> v， v1;//空容器

vector<int> v(3)//包含3个元素；

vector<int> v(3,9)//包含3个元素,每个元素都是9；

vector<int> v(v1)//copy v1;

int a[3] = {0,1,2};

vector<int> v(a,a+3)//copy a数组；

状态

v.size()//返回v个数，空是时候是0，空时不可atuo i = v.begin();

v.begin()//首地址

v.end()//末元素地址+1；for里终止条件 auto i != v.end(); i < end(); i <= v.end()-1;

//有点像数组最后一位的空位置

v.at(i) == v[i]//推荐使用后者；

bool is = v.empty();/空返回true，不空返回false;

v.push_back(n)//在尾部添加n进容器；

v.pop_back()//删除尾元素；

二维容器

vector<vector<int>> v1;

vector<int> v[5];

vector<>

vector<vector<int>> ans(r,vector<int>(c));//初始化r行c列的容器

v1.size()//v1有几行

v1[i].size()//v1[i]几行有几个元素，即有几列

遍历

for(int i : v)

cout << i;

for(auto i = v.begin() ; i < v.end() ; i++ )

cout << *i;////auto 推荐使用；

for(auto i = v.begin() ; i ！= v.end() ; i++ )

cout << *i;

for(vector<int>::iterator it = vecIntB.begin() ;it!=vecIntB.end();it++)

cout<<*it;

删除

v.erase(v.begin()+2)//删除第3个元素（v.begin()+2地址所在）；

v.erase(v.begin()+2，v.begin()+5)//删除第3-5个元素

v.erase(v.begin(),v.end());//清空

v.clear() ;//清空；

v.begin()+1//允许这样操作

v.pop_back() & v.erase() & v.push_back 后 v.size() 会变；

如有错误，欢迎指正，如有不足，欢迎补充。

}

欢迎造访我的www.github.com/xminjie

sort的使用

sort(a,a+5)//排序a首元素到a+4地址所在元素；
  sort  快排和插排

stable_sort  归并

partail_sort     堆排

sort默认从小到大，也可自行定义com



stable_sort 与sort用法相同

sort(a,a+5,)

sort(a,a+5,less<int>())

sort(a,a+5,greater<int>())

com函数

bool com(){

}
sort(a,a+5,cmp);

部分排序
partial_sort(a,a+2,a+5)
partial_sort(v.begin(),v.begin+5,v.end(),com)//部分排序前5个
nth_element(v.begin(),v.begin()+6,v.end())//第七名，v.begin()+6的地址所在元素；
  
结构体排序  
  struct stu{
    int a;
    int b;
  }a[5];
bool comp(stu x,stu y){
  if(a == b)  { return x.b < y.b;}
  else  return x.a < y.a ;
}
sort(a,a+5,comp);

sort(a,a+5)//排序a首元素到a+4地址所在元素；

sort 快排和插排

stable_sort 归并

partail_sort 堆排

sort默认从小到大，也可自行定义com

stable_sort 与sort用法相同

sort(a,a+5,)

sort(a,a+5,less<int>())

sort(a,a+5,greater<int>())

com函数

bool com(){

}

sort(a,a+5,cmp);

部分排序

partial_sort(a,a+2,a+5)

partial_sort(v.begin(),v.begin+5,v.end(),com)//部分排序前5个

nth_element(v.begin(),v.begin()+6,v.end())//第七名，v.begin()+6的地址所在元素；

结构体排序

struct stu{

int a;

int b;

}a[5];

bool comp(stu x,stu y){

if(a == b) { return x.b < y.b;}

else return x.a < y.a ;

}

sort(a,a+5,comp);

bitset操作c++

#include <bitset>

0101101010//一个bitset类型的变量
9876543210//对应元素的下标

初始化
using std :: bitset

bitset<5> bit1("11101")//最简单的初始化
！！！ bit1 = bit2//没有这个操作，编译不通过

bitset<n> b; //b有n位，每位都为0
bitset<n> b(u); //b是unsigned long型u的一个副本
bitset<n> b(s); //b是string对象s中含有的位串的副本
bitset<n> b(s, pos, n); //b是string对象s中pos位置开始个n素的拷贝
bitset在定义时，要明确bitset含有多少位，须在尖括号内给出长度值;
如bitset<32> bitvec; //32位，全为0

不满左边补0
string s = "101";//若(string s = "102")会运行奇怪的错误，bitset报错；
bitset<10> bit1(s)//即先把101摆在那，剩余的7位（下标从3-9）在左面用0补；
//bit1:0000000,101 (请忽略','那是我为了方便理解加的，实际并不存在)

溢出从左截取；
string s = "001111111"
bitset<5> bit1(s)//最终截取字符串前几位：00111；
////bit1:00111

取部分
string s = "001111"
bitset<10> bit1(s，1)
//最终截下标为1到最后的元素，即先把01111摆在那，剩余的5位（下标从5-9）在左面用0补
//bit1：00000,01111 (请忽略','那是我为了方便理解加的，实际并不存在)

bitset<10> bit1(s，1，2）//从下标为1，截取2个元素，即先把01摆在那，剩余的8位（下标从2-9）在左面用0补
//bit1：00000000，01 (请忽略','那是我为了方便理解加的，实际并不存在)

查找
bitset<10> bit1;
bit1.size()//返回二进制总位数；
bit1.count()//返回bit1里1的个数；
bool is = bit1.any()// is = if(bit1.count() >= 1)
bool is = bit1.none()// is = if(bit1.count() == 0)
bool is = bit[5].test// is = bit1.[5]; 即测试 bit1[5]==1？

操作
bit1.set()//所有位设为1
bit1.set(pos)//下标为pos的位设为1
bit1.reset//所有位设为0
bit1.reset(pos)//下标为pos的位设为0
bit1.flip()//所有位取反
bit1.flip(pos)//pos位取反
bit1.to_ulong()//返回一个usign long long 整数

#include <bitset>

0101101010//一个bitset类型的变量

9876543210//对应元素的下标

初始化

using std :: bitset

bitset<5> bit1("11101")//最简单的初始化

！！！ bit1 = bit2//没有这个操作，编译不通过

bitset<n> b; //b有n位，每位都为0

bitset<n> b(u); //b是unsigned long型u的一个副本

bitset<n> b(s); //b是string对象s中含有的位串的副本

bitset<n> b(s, pos, n); //b是string对象s中pos位置开始个n素的拷贝

bitset在定义时，要明确bitset含有多少位，须在尖括号内给出长度值;

如bitset<32> bitvec; //32位，全为0

不满左边补0

string s = "101";//若(string s = "102")会运行奇怪的错误，bitset报错；

bitset<10> bit1(s)//即先把101摆在那，剩余的7位（下标从3-9）在左面用0补；

//bit1:0000000,101 (请忽略','那是我为了方便理解加的，实际并不存在)

溢出从左截取；

string s = "001111111"

bitset<5> bit1(s)//最终截取字符串前几位：00111；

////bit1:00111

取部分

string s = "001111"

bitset<10> bit1(s，1)

//最终截下标为1到最后的元素，即先把01111摆在那，剩余的5位（下标从5-9）在左面用0补

//bit1：00000,01111 (请忽略','那是我为了方便理解加的，实际并不存在)

bitset<10> bit1(s，1，2）//从下标为1，截取2个元素，即先把01摆在那，剩余的8位（下标从2-9）在左面用0补

//bit1：00000000，01 (请忽略','那是我为了方便理解加的，实际并不存在)

查找

bitset<10> bit1;

bit1.size()//返回二进制总位数；

bit1.count()//返回bit1里1的个数；

bool is = bit1.any()// is = if(bit1.count() >= 1)

bool is = bit1.none()// is = if(bit1.count() == 0)

bool is = bit[5].test// is = bit1.[5]; 即测试 bit1[5]==1？

操作

bit1.set()//所有位设为1

bit1.set(pos)//下标为pos的位设为1

bit1.reset//所有位设为0

bit1.reset(pos)//下标为pos的位设为0

bit1.flip()//所有位取反

bit1.flip(pos)//pos位取反

bit1.to_ulong()//返回一个usign long long 整数

二分查找binary_search() & upper_bound() & lower_bound()

vector<int> a = {0,1,2,2,3,4};
使用前提是a已经升序排好了
cout << binary_search(a.begin(),a.end(),2);//a,a+3迭代位置（a->a+2地址所在），查找2
//return ture or false
upper_bound(a.begin(),a.end(),2)//返回指针
//从左往右，返回第一个比 大于 的该数的地址，
//找不到就返回最后一个元素的下一位 a.end()
lower_bound(a.begin(),a.end(),2)//返回指针
//从左往右，找到第一个 大于等于 该数的地址，
//找不到就返回最后一个元素的下一位 a.end()
当cout << binary_search(a.begin(),a.end(),2) == false;
则lower_bound(a.begin(),a.end(),2) == upper_bound(a.begin(),a.end(),2)

vector<int> a = {0,1,2,2,3,4};

使用前提是a已经升序排好了

cout << binary_search(a.begin(),a.end(),2);//a,a+3迭代位置（a->a+2地址所在），查找2

//return ture or false

upper_bound(a.begin(),a.end(),2)//返回指针

//从左往右，返回第一个比大于的该数的地址，

//找不到就返回最后一个元素的下一位 a.end()

lower_bound(a.begin(),a.end(),2)//返回指针

//从左往右，找到第一个大于等于该数的地址，

//找不到就返回最后一个元素的下一位 a.end()

当cout << binary_search(a.begin(),a.end(),2) == false;

则lower_bound(a.begin(),a.end(),2) == upper_bound(a.begin(),a.end(),2)

容器的使用

<span role="presentation"><span class="cm-meta">#include &lt;vecoter&gt;</span></span>
<span role="presentation">{ </span>
<span role="presentation">  <span class="cm-variable">初始化</span></span>
<span role="presentation">  <span class="cm-comment">//vector从0下标开始；</span></span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;</span> <span class="cm-variable">v，</span> <span class="cm-variable">v1</span>;<span class="cm-comment">//空容器</span></span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;</span> <span class="cm-variable">v</span>(<span class="cm-number">3</span>)<span class="cm-comment">//包含3个元素；</span></span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;</span> <span class="cm-variable">v</span>(<span class="cm-number">3</span>,<span class="cm-number">9</span>)<span class="cm-comment">//包含3个元素,每个元素都是9；</span></span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;</span> <span class="cm-variable">v</span>(<span class="cm-variable">v1</span>)<span class="cm-comment">//copy v1;</span></span>
<span role="presentation">  <span class="cm-variable-3">int</span> <span class="cm-variable">a</span>[<span class="cm-number">3</span>] <span class="cm-operator">=</span> {<span class="cm-number">0</span>,<span class="cm-number">1</span>,<span class="cm-number">2</span>};</span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;</span> <span class="cm-variable">v</span>(<span class="cm-variable">a</span>,<span class="cm-variable">a</span><span class="cm-operator">+</span><span class="cm-number">3</span>)<span class="cm-comment">//copy a数组；</span></span>
<span role="presentation">  </span>
<span role="presentation">  <span class="cm-variable">状态</span></span>
<span role="presentation">  <span class="cm-variable">v</span>.<span class="cm-variable">size</span>()<span class="cm-comment">//返回v个数，空是时候是0，空时不可atuo i = v.begin();</span></span>
<span role="presentation">  <span class="cm-variable">v</span>.<span class="cm-variable">begin</span>()<span class="cm-comment">//首地址</span></span>
<span role="presentation">  <span class="cm-variable">v</span>.<span class="cm-variable">end</span>()<span class="cm-comment">//末元素地址+1；for里终止条件 auto i != v.end(); i &lt; end(); i &lt;= v.end()-1;</span></span>
<span role="presentation">         <span class="cm-comment">//有点像数组最后一位的空位置</span></span>
<span role="presentation">  <span class="cm-variable">v</span>.<span class="cm-variable">at</span>(<span class="cm-variable">i</span>) <span class="cm-operator">==</span> <span class="cm-variable">v</span>[<span class="cm-variable">i</span>]<span class="cm-comment">//推荐使用后者；</span></span>
<span role="presentation">  <span class="cm-variable-3">bool</span> <span class="cm-variable">is</span> <span class="cm-operator">=</span> <span class="cm-variable">v</span>.<span class="cm-variable">empty</span>();<span class="cm-operator">/</span><span class="cm-variable">空返回true，不空返回false</span>;</span>
<span role="presentation">  <span class="cm-variable">v</span>.<span class="cm-variable">push_back</span>(<span class="cm-variable">n</span>)<span class="cm-comment">//在尾部添加n进容器；</span></span>
<span role="presentation">  <span class="cm-variable">v</span>.<span class="cm-variable">pop_back</span>()<span class="cm-comment">//删除尾元素；</span></span>
<span role="presentation">  <span class="cm-variable">二维容器</span></span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;&gt;</span> <span class="cm-variable">v1</span>;</span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;</span> <span class="cm-variable">v</span>[<span class="cm-number">5</span>];</span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;&gt;</span></span>
<span role="presentation">    </span>
<span role="presentation">  <span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;&gt;</span> <span class="cm-variable">ans</span>(<span class="cm-variable">r</span>,<span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;</span>(<span class="cm-variable">c</span>));<span class="cm-comment">//初始化r行c列的容器</span></span>
<span role="presentation">  <span class="cm-variable">v1</span>.<span class="cm-variable">size</span>()<span class="cm-comment">//v1有几行</span></span>
<span role="presentation">  <span class="cm-variable">v1</span>[<span class="cm-variable">i</span>].<span class="cm-variable">size</span>()<span class="cm-comment">//v1[i]几行有几个元素，即有几列</span></span>
<span role="presentation"></span>
<span role="presentation">    </span>
<span role="presentation">  <span class="cm-variable">遍历</span></span>
<span role="presentation">  <span class="cm-keyword">for</span>(<span class="cm-variable-3">int</span> <span class="cm-variable">i</span> : <span class="cm-variable">v</span>)</span>
<span role="presentation">        <span class="cm-variable">cout</span> <span class="cm-operator">&lt;&lt;</span> <span class="cm-variable">i</span>;</span>
<span role="presentation">  <span class="cm-keyword">for</span>(<span class="cm-keyword">auto</span> <span class="cm-variable">i</span> <span class="cm-operator">=</span> <span class="cm-variable">v</span>.<span class="cm-variable">begin</span>() ; <span class="cm-variable">i</span> <span class="cm-operator">&lt;</span> <span class="cm-variable">v</span>.<span class="cm-variable">end</span>() ; <span class="cm-variable">i</span><span class="cm-operator">++</span> ) </span>
<span role="presentation">        <span class="cm-variable">cout</span> <span class="cm-operator">&lt;&lt;</span> <span class="cm-operator">*</span><span class="cm-variable">i</span>;<span class="cm-comment">////auto 推荐使用；</span></span>
<span role="presentation">   <span class="cm-keyword">for</span>(<span class="cm-keyword">auto</span> <span class="cm-variable">i</span> <span class="cm-operator">=</span> <span class="cm-variable">v</span>.<span class="cm-variable">begin</span>() ; <span class="cm-variable">i</span> <span class="cm-variable">！</span><span class="cm-operator">=</span> <span class="cm-variable">v</span>.<span class="cm-variable">end</span>() ; <span class="cm-variable">i</span><span class="cm-operator">++</span> ) </span>
<span role="presentation">        <span class="cm-variable">cout</span> <span class="cm-operator">&lt;&lt;</span> <span class="cm-operator">*</span><span class="cm-variable">i</span>;</span>
<span role="presentation">  <span class="cm-keyword">for</span>(<span class="cm-variable">vector</span><span class="cm-operator">&lt;</span><span class="cm-variable-3">int</span><span class="cm-operator">&gt;</span>::<span class="cm-variable">iterator</span> <span class="cm-variable">it</span> <span class="cm-operator">=</span> <span class="cm-variable">vecIntB</span>.<span class="cm-variable">begin</span>() ;<span class="cm-variable">it</span><span class="cm-operator">!=</span><span class="cm-variable">vecIntB</span>.<span class="cm-variable">end</span>();<span class="cm-variable">it</span><span class="cm-operator">++</span>)   </span>
<span role="presentation">        <span class="cm-variable">cout</span><span class="cm-operator">&lt;&lt;*</span><span class="cm-variable">it</span>;</span>
 
<span role="presentation">    </span>
<span role="presentation">  <span class="cm-variable">删除</span></span>
<span role="presentation">    <span class="cm-variable">v</span>.<span class="cm-variable">erase</span>(<span class="cm-variable">v</span>.<span class="cm-variable">begin</span>()<span class="cm-operator">+</span><span class="cm-number">2</span>)<span class="cm-comment">//删除第3个元素（v.begin()+2地址所在）；</span></span>
<span role="presentation">    <span class="cm-variable">v</span>.<span class="cm-variable">erase</span>(<span class="cm-variable">v</span>.<span class="cm-variable">begin</span>()<span class="cm-operator">+</span><span class="cm-number">2</span><span class="cm-variable">，v</span>.<span class="cm-variable">begin</span>()<span class="cm-operator">+</span><span class="cm-number">5</span>)<span class="cm-comment">//删除第3-5个元素（v.begin()+4地址所在）及以后所有元素；</span></span>
<span role="presentation">    <span class="cm-variable">v</span>.<span class="cm-variable">erase</span>(<span class="cm-variable">v</span>.<span class="cm-variable">begin</span>(),<span class="cm-variable">v</span>.<span class="cm-variable">end</span>());<span class="cm-comment">//清空</span></span>
<span role="presentation">    <span class="cm-variable">v</span>.<span class="cm-variable">clear</span>() ;<span class="cm-comment">//清空；</span></span>
<span role="presentation">    <span class="cm-variable">v</span>.<span class="cm-variable">begin</span>()<span class="cm-operator">+</span><span class="cm-number">1</span><span class="cm-comment">//允许这样操作  </span></span>
<span role="presentation">  <span class="cm-variable">v</span>.<span class="cm-variable">pop_back</span>() <span class="cm-operator">&amp;</span> <span class="cm-variable">v</span>.<span class="cm-variable">erase</span>() <span class="cm-operator">&amp;</span> <span class="cm-variable">v</span>.<span class="cm-variable">push_back</span> <span class="cm-variable">后</span> <span class="cm-variable">v</span>.<span class="cm-variable">size</span>() <span class="cm-variable">会变；</span></span>
<span role="presentation">    </span>
<span role="presentation">    <span class="cm-variable">注：姑且认为中v</span>(<span class="cm-variable">v</span>.<span class="cm-variable">begin</span>(),<span class="cm-variable">v</span>.<span class="cm-variable">end</span>()) <span class="cm-operator">=&gt;</span> <span class="cm-variable">v</span>(<span class="cm-variable">p1</span>,<span class="cm-variable">p2</span>),</span>
<span role="presentation">       <span class="cm-variable">p1为操作起始地址，p2为操作元素末地址</span><span class="cm-operator">+</span><span class="cm-number">1</span><span class="cm-variable">，</span> <span class="cm-variable">类似sort（）；</span></span>
<span role="presentation">       <span class="cm-variable">大概就是像操作p1</span><span class="cm-operator">-&gt;</span><span class="cm-variable">p2，需要中（p1，p2</span><span class="cm-operator">+</span><span class="cm-number">1</span><span class="cm-variable">）</span></span>
<span role="presentation">      <span class="cm-variable">（！！！此条仅为方便记忆，不保证说法的严谨，也欢迎大家指正</span>)</span>
<span role="presentation">         </span>
<span role="presentation">       </span>
<span role="presentation">    <span class="cm-variable">如有错误，欢迎指正，如有不足，欢迎补充。</span></span>
<span role="presentation">} </span>

#include <vecoter>

{

初始化

//vector从0下标开始；

vector<int> v， v1;//空容器

vector<int> v(3)//包含3个元素；

vector<int> v(3,9)//包含3个元素,每个元素都是9；

vector<int> v(v1)//copy v1;

int a[3] = {0,1,2};

vector<int> v(a,a+3)//copy a数组；

状态

v.size()//返回v个数，空是时候是0，空时不可atuo i = v.begin();

v.begin()//首地址

v.end()//末元素地址+1；for里终止条件 auto i != v.end(); i < end(); i <= v.end()-1;

//有点像数组最后一位的空位置

v.at(i) == v[i]//推荐使用后者；

bool is = v.empty();/空返回true，不空返回false;

v.push_back(n)//在尾部添加n进容器；

v.pop_back()//删除尾元素；

二维容器

vector<>

vector<vector<int>> ans(r,vector<int>(c));//初始化r行c列的容器

v1.size()//v1有几行

v1[i].size()//v1[i]几行有几个元素，即有几列

遍历

for(int i : v)

cout << i;

for(auto i = v.begin() ; i < v.end() ; i++ )

cout << *i;////auto 推荐使用；

for(auto i = v.begin() ; i ！= v.end() ; i++ )

cout << *i;

for(vector<int>::iterator it = vecIntB.begin() ;it!=vecIntB.end();it++)

cout<<*it;

删除

v.erase(v.begin()+2，v.begin()+5)//删除第3-5个元素（v.begin()+4地址所在）及以后所有元素；

v.clear() ;//清空；

v.begin()+1//允许这样操作

v.pop_back() & v.erase() & v.push_back 后 v.size() 会变；

注：姑且认为中v(v.begin(),v.end()) => v(p1,p2),

p1为操作起始地址，p2为操作元素末地址+1， 类似sort（）；

大概就是像操作p1->p2，需要中（p1，p2+1）

（！！！此条仅为方便记忆，不保证说法的严谨，也欢迎大家指正)

如有错误，欢迎指正，如有不足，欢迎补充。

}

欢迎造访我的www.github.com/xminjie

分类：语法笔记c++

Bellman-Ford负权值最短路模版

优先队列使用

优先队列详解和使用

c语言文件读入与写入

实现控制台与文件写入的自由切换

c语言整数浮点数读入格式

set使用技巧

vector容器的使用

容器的使用

sort的使用

sort的使用

bitset操作c++

二分查找binary_search() & upper_bound() & lower_bound()

vector容器的使用

容器的使用