函数作用（持续积累）

next_permutation直接排出所有可能的情况，适用于全排列。max作用  比较所有ans然后赋值给ma,均需要#include<algorithm>头文件。

#include<stdio.h>

#include<string.h>
#include<algorithm>
#include<vector>
#include<iostream>
#include<math.h>
#include<queue>
#include<stack>
using namespace std;
int a[6][6];
int main()
{
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
        scanf("%d",&a[i][j]);
    int b[5];
    for(int i=0;i<5;i++)
        b[i]=i;
    int ma=0;
    do
    {
        int ans=0;
        ans+=a[b[0]][b[1]];
        ans+=a[b[1]][b[0]];
        ans+=a[b[1]][b[2]];
        ans+=a[b[2]][b[1]];
        ans+=2*a[b[2]][b[3]];
        ans+=2*a[b[3]][b[2]];
        ans+=2*a[b[3]][b[4]];
        ans+=2*a[b[4]][b[3]];
        ma=max(ans,ma);
    }while(next_permutation(b,b+5));
    printf("%d\n",ma);

}代码由小鑫友情提供作参考。

C++优先队列的基本使用方法

 #include<iostream>
#include<functional>
#include<queue>
using namespace std;

struct node
{
    friend bool operator< (node n1, node n2)
    {
        return n1.priority < n2.priority;//"<"为从大到小排列，">"为从小打到排列
    }
    int priority;
    int value;
};

int main()
{
    const int len = 5;
    int i;
    int a[len] = {3,5,9,6,2};
    //示例1
    priority_queue<int> qi;//普通的优先级队列，按从大到小排序
    for(i = 0; i < len; i++)
        qi.push(a[i]);
    for(i = 0; i < len; i++)
    {
        cout<<qi.top()<<" ";
        qi.pop();
    }
    cout<<endl;

    //示例2
    priority_queue<int, vector<int>, greater<int> > qi2;//从小到大的优先级队列，可将greater改为less，即为从大到小
    for(i = 0; i < len; i++)
        qi2.push(a[i]);
    for(i = 0; i < len; i++)
    {
        cout<<qi2.top()<<" ";
        qi2.pop();
    }
    cout<<endl;

    //示例3
    priority_queue<node> qn;//必须要重载运算符
    node b[len];
    b[0].priority = 6; b[0].value = 1;
    b[1].priority = 9; b[1].value = 5;
    b[2].priority = 2; b[2].value = 3;
    b[3].priority = 8; b[3].value = 2;
    b[4].priority = 1; b[4].value = 4;
 
    for(i = 0; i < len; i++)
        qn.push(b[i]);
    cout<<"优先级"<<'\t'<<"值"<<endl;
    for(i = 0; i < len; i++)
    {
        cout<<qn.top().priority<<'\t'<<qn.top().value<<endl;
        qn.pop();
    }
    return 0;
}

对于队列里元素为一个结构体类型，按照某一个属性排序，就需要对比较函数进行重载

小结一下：

1、若是定义值类型对象，如： 

int 
 main() 
{      
    priority_queue<node> qn;

    node n1; 
    n1.a = 9; 
    node n2; 
    n2.a = 2; 
    node n3; 
    n3.a = 50;  

    qn.push(n1);

    qn.push(n2);

    qn.push(n3);

     int  size = qn.size();

     for ( int  i = 0; i < size; i++) 
    { 
        cout << qn.top().a << endl;

        qn.pop(); 
    } 
         return  0;

} 
则定义优先级的时候，直接在类中写个friend 的操作符重载函数即可： 

class  node 
{ 
public : 
     int  a;

    node(){} 
    node( int  x):a(x){} 
friend   bool  operator<( const  node ne1, const  node ne2)//参数也可以为引用，值传递 
    { 
         if (ne1.a > ne2.a) 
        { 
             return   true ; 
        } 
         else 
        { 
             return   false ; 
        } 
    } 
}; 
其中在c＋＋primer第三版 中文版中关于操作符重载有如下描述：

"程序员只能为类类型或枚举类型的操作数定义重载操作符我们可以这样来实现把重 
载操作符声明为类的成员或者声明为名字空间成员同时至少有一个类或枚举类型的参数 
按值传递或按引用传递"

因此不可用指针类型的参数；

2、如果想定义一个指针类型的优先队列，那就不可这么简单的定义了，你需要自定义一个自己的比较函数，在priority_queue的模板函数中，我们可以利用这样一个template<class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type> >模板，在我们的程序代码中，则需要自己定义一个类来定义第三个模板参数，如：

class  nodePointerComparer  
{  
public :  
    nodePointerComparer(){}  
     bool  operator ()( const  node* ne1,  const  node* ne2)  const   
    {  
         return  ne1->lessthan(ne2);  
    }  
};  

当然在这之前我们的类Node要重新书写 

class  node  
{  
public :  
     int  a;  
    node(){}  
    node( int  x):a(x){} 

     bool  lessthan( const  node* pnode)  const   
    {  
         return  a < pnode->a;  
    }  
};  
这样在main函数中就可以定义指针类型的优先队列了：

int  main()  
{  
    priority_queue <node*, vector <node*>, nodePointerComparer> qn;  
    node *n1 =  new  node(90);  
    node *n2 =  new  node(2);  
    node *n3 =  new  node(50); 

    qn.push(n1);  
    qn.push(n2); /span>

> 
    qn.push(n3); 

     int  size = qn.size();  
     for ( int  i = 0; i < size; i++)  
    {  
        cout << qn.top()->a << endl;  
        qn.pop();  
    }  
     return  0; 

}  
疑问之处：如果你使用第一种值传递的操作符重载，来实现第二种的指针类型优先队列，是不会达到想要的结果的，个人理解是因为在指针类型的优先队列中找“<”运算符的时候，重载的不是我们写的值传递friend bool operator<(const node ne1,const node ne2)//

也就是没有找到指针类型的"<"重载，所有不会达到优先队列的效果。http://www.csie.ntnu.edu.tw/~u91029/index.html

#include<iostream>
#include<vector>
using namespace std;
const int maxn = 10000 + 5;

int main(){
    vector<int> v;
    v.clear();//对vector的初始化,清空v内的所有元素
    v.push_back(0);//把一个元素存在v的末尾，相当于v[0] = 0
    v.push_back(3);//v[1] = 3;
    v.size();//v现在存储了多少个元素

    cout << v[0] << endl;
    cout << v.size() << endl;
    for(int i = 0;i < v.size();i++)
        cout << v[i] << ' ';

    return 0;
}
/*

struct Edge{
    int to, dis;
    Edge(int to, int dis){
        this -> to = to;
        this -> dis = dis;
    }
};

vector<Edge> G[maxn];

int main(){
    for(int i = 0;i < maxn;i++)
        G[i].clear();

    G[0].push_back(Edge(1, 1));
    G[0].push_back(Edge(2, 2));
    G[1].push_back(Edge(0, 2));
    for(int i = 0;i < G[0].size();i++){
        Edge& e = G[0][i];
        int to = e.to;
        int dis = e.dis;
        cout << to << ' ' << dis << endl;
    }
}
*/

map

•问题1：输入一些字符串，统计每个字符串出现的次数。

•egg abc egga abc qwer asdf egg abc

•abc : 3

•egg : 2

•qwer: 1

•

•问题2：输入一些数字。统计每个数字出现的次数。

•1000000000， 123， 2， 4125246, 2

•map //做hash，第一个键值必须是定义了 < 的数据类型(例如 string ,pair，int，char)

•头文件<map>

•定义 map<string, int> m;

•初始化 m.clear();

•逗号分开的是两个数据，第一个是键值，第二个是键值对应的值。

•赋值 m["abc"] = 1;

•访问m["abc"];

•查找某一个键值x是否在m中 m.count(x)

string

•头文件<string>

•定义 string s；//不用说明字符串的最大长度，自动管理

•输入 cin >> s; //读入有空格或换行隔开的字符串

•输出 cout << s;

•默认比较函数 是按字符串的字典序大小比较

•字符数组 string s[maxn];

•字符串长度 s.length()

•访问一个字符串的某一个字符s[i]

•字符串可以直接相加

•s1 = a; s2 = b; s3 = s1 + s2;

•s3 = ab;

pair

•pair<int, int > // 定义数据类型

•

•typedef pair<int,int> P;// 这样写起来比较方便

•

•P p = make_pair(a, b); // 初始化赋值

•或者 p = P(a, b);//类似结构体赋值，不用写构造函数

•p.first = a ;p.second =b;//访问元素