1. priority_queue
无理由在广搜和解决贪心问题用处很大，首先作为广搜的挑选最优状态如Astar，然后是当做堆给最短路和最小生成树做优化，用的是贪心思想。
定义优先级，和正常的反过来。
bool operator < (const number1 &a)const {
return x > a.x; // 从小到大 ，x 小的 优先级别高
}
优先队列的实现就是一个堆，队尾进入一个新元素就和父节点比较上升，出对就调整堆。
上一道纯贪心和优先队列完美结合的例题 HDU 4544
#include <iostream> #include <cstdio> #include <queue> #include <algorithm> using namespace std; #define MAXN 100006 #define LL long long int Blood[MAXN]; bool cmp(int a, int b) { return a > b; } struct Node { int D, cost; bool operator <(const Node &tmp) const { return cost > tmp.cost; } } arrow[MAXN]; int N, M; priority_queue<Node> Q; bool cmp_Node(Node a, Node b) { return a.D > b.D; } LL solve() { LL Min_cost = 0; int pos = 0; for (int i = 0; i < N; i++) { while (pos < M && Blood[i] <= arrow[pos].D) Q.push(arrow[pos++]); if (Q.empty()) { return -1; } Min_cost += Q.top().cost; Q.pop(); } return Min_cost; } int main() { // freopen("data_tmp.txt", "r", stdin); int i; while (~scanf("%d%d", &N, &M)) { while (!Q.empty()) Q.pop(); for (i = 0; i < N; i++) scanf("%d", &Blood[i]); for (i = 0; i < M; i++) scanf("%d", &arrow[i].D); for (i = 0; i < M; i++) scanf("%d", &arrow[i].cost); sort(Blood, Blood + N, cmp); sort(arrow, arrow + M, cmp_Node); if (arrow[0].D < Blood[0]) { puts("No"); continue; } LL ans = solve(); if (ans == -1) puts("No"); else printf("%I64d ", ans); } return 0; }
2. set 与 hash_set
应用，首先是集合操作，交并补对称差，和查找.count() ，指向键值>=k的第一个元素.lower_bound() ，指向键值>k的第一个元素.upper_bound()，it-- 就得到<=val 的最大值。
其次是对于动态插入删除有序的题，或者维护状态（最远曼哈顿距离），可以用set快速找到应该插入的位置，如insert和lower_bound 都会返回位置的迭代器。
上一道很有代表性的set应用 (hash_set用法和set一致，很多情况下hash_set效率更高，且hash表空间分配上使用了一个近似于倍增的素数表，最开始取第一个素数，当空间不足时就使用下一个素数)
内部实现为一颗红黑树。
//给出一些能引起周围一定区域内炸弹爆炸的炸弹，按给出顺序引爆 //输出每次爆炸会引起几个炸弹的爆炸 //unique(）去重操作，返回去重后尾地址 //lower_bound(first,last,val)求first到last区间内大于等于val第一个值 #include<queue> #include<set> #include<algorithm> #include<iostream> #include<cmath> using namespace std; const int maxn = 100015; int myhash[maxn]; struct node { int x, y, d; } mine[maxn]; struct node2 { int y, id; node2(int a, int b) { y = a; id = b; } bool operator<(const node2 &tmp) const { return y < tmp.y; } }; multiset<node2> p[maxn]; multiset<node2>::iterator LL, RR, it; queue<int> q; bool vis[maxn]; int main() { int n; while (scanf("%d", &n) != EOF, n) { for (int i = 0; i < n; i++) { scanf("%d%d%d", &mine[i].x, &mine[i].y, &mine[i].d); myhash[i] = mine[i].x; //在 x 方向离散化 } sort(myhash, myhash + n); int cnt = unique(myhash, myhash + n) - myhash; for (int i = 0; i < cnt; i++) p[i].clear(); memset(vis, 0, sizeof(vis)); for (int i = 0; i < n; i++) { int pos = lower_bound(myhash, myhash + cnt, mine[i].x) - myhash; p[pos].insert(node2(mine[i].y, i)); // i 是原序号 } int id; scanf("%d", &id); while (!q.empty()) q.pop(); int ans = 0; q.push(id); vis[id] = 1; while (!q.empty()) { int now_id = q.front(); //点燃第一个 q.pop(); ans++; int first_pos = lower_bound(myhash, myhash + cnt, mine[now_id].x - mine[now_id].d) - myhash; int last_pos = upper_bound(myhash, myhash + cnt, mine[now_id].x + mine[now_id].d) - myhash; //首先由横坐标确定大致的 x 寻找范围 for (int pos = first_pos; pos < last_pos; pos++) { int dy = mine[now_id].d - abs(mine[now_id].x - myhash[pos]); //lower_bound 与upper_bound配合确定上下界 LL = p[pos].lower_bound(node2(mine[now_id].y - dy, 0)); RR = p[pos].upper_bound(node2(mine[now_id].y + dy, 0)); for (it = LL; it != RR; it++) { if (vis[it->id] == 0) { vis[it->id] = 1; q.push(it->id); } } p[pos].erase(LL, RR); //删除已经爆炸的点 区间删除 } } printf("%d ", ans); } return 0; }
3. map
首先是映射，如规定10000000000对应1，而不能开那么大的bool数组吧，那就用map就可以。
其次它有自排序功能，所以对于处理字典序很有用。
map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的。
//给出一系列要忽略的单词，这些单词以外的单词都看作关键字。给出一些标题，按这些关键字的字典序给标题排序 #include <iostream> #include <cstdio> #include <map> #include <set> #include <cctype> #include <algorithm> using namespace std; const int maxn = 220; int main() { string k, st; int a = 0; set<string> o; multimap<string, string> r; while (cin >> k && k != "::") o.insert(k); getchar(); while (getline (cin, st)) { for (int i = 0; i < st.size(); i++) st[i] = tolower(st[i]); for (int i = 0; i < st.size(); i++) { if (!isalpha(st[i])) continue; string t; int rec = i; while (i < st.size() && isalpha(st[i])) t += st[i++]; if (!o.count(t)) { for (int j = 0; j < t.size(); j++) t[j] = toupper(t[j]); string temp = st; temp.replace(rec, t.size(), t); r.insert(make_pair(t, temp)); } } } for (multimap<string, string>::iterator i = r.begin(); i != r.end(); i++) cout << i -> second << endl; return 0; }
4.heap
头文件 #include <algorithm>
建立堆 make_heap(_First, _Last, _Comp)
默认是建立最大堆的。对int类型，可以在第三个参数传入greater<int>()得到最小堆。
在堆中添加数据 push_heap (_First, _Last) 要先在最后加入数据，再调用push_heap()在原堆上调整
在堆中删除数据
pop_heap(_First, _Last) 要先调用pop_heap()清除第一个并调整成堆，再删除数据
堆排序 sort_heap(_First, _Last) 稳定排序
#include <algorithm> using namespace std; int num[20]; void debug() { for (int i = 0; i < 11; i++) printf("%d ", num[i]); puts(""); } int main() { memset(num, -1, sizeof(num)); for (int i = 0; i < 10; i++) num[i] = rand() % 100; debug(); make_heap(num, num + 10); debug(); num[10] = 100; push_heap(num, num + 11); debug(); pop_heap(num, num + 11); num[10] = -1; debug(); return 0; }
执行结果
原数组 41 67 34 0 69 24 78 58 62 64 -1
建堆后 78 69 41 62 67 24 34 58 0 64 -1
添加100调整后 100 78 41 62 69 24 34 58 0 64 67
清除堆顶调整后 78 69 41 62 67 24 34 58 0 64 -1
POJ 2051
//============================================================================ // Name : Test.cpp // Author : // Version : // Copyright : Your copyright notice // Description : Hello World in C++, Ansi-style //============================================================================ #include <iostream> #include <algorithm> using namespace std; struct Node { int id, p, time; bool operator <(const Node &tmp) const { return (time == tmp.time) ? id > tmp.id : time > tmp.time; } } node[4000]; int main() { char opr[10]; int cnt = 0; while (scanf("%s", opr) && opr[0] != '#') { scanf("%d%d", &node[cnt].id, &node[cnt].p); node[cnt].time = node[cnt].p; cnt++; } make_heap(node, node + cnt); int k; scanf("%d", &k); while (k--) { printf("%d ", node[0].id); pop_heap(node, node + cnt); node[cnt - 1].time += node[cnt - 1].p; push_heap(node, node + cnt); } return 0; }
5.string
有关函数
string类的构造函数： string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常 string类的字符操作： const char &operator[](int n)const; const char &at(int n)const; char &operator[](int n); char &at(int n); operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。 const char *data()const;//返回一个非null终止的c字符数组 const char *c_str()const;//返回一个以null终止的c字符串 int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目 string的特性描述: int capacity()const; //返回当前容量（即string中不必增加内存即可存放的元素个数） int max_size()const; //返回string对象中可存放的最大字符串的长度 int size()const; //返回当前字符串的大小 int length()const; //返回当前字符串的长度 bool empty()const; //当前字符串是否为空 void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分 string类的输入输出操作: string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。 函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符' '分开。 string的赋值： string &operator=(const string &s);//把字符串s赋给当前字符串 string &assign(const char *s);//用c类型字符串s赋值 string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值 string &assign(const string &s);//把字符串s赋给当前字符串 string &assign(int n,char c);//用n个字符c赋值给当前字符串 string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串 string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串 string的连接： string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾 string &append(const char *s); //把c类型字符串s连接到当前字符串结尾 string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾 string &append(const string &s); //同operator+=() string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾 string &append(int n,char c); //在当前字符串结尾添加n个字符c string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾 string的比较： bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等 运算符">","<",">=","<=","!="均被重载用于字符串的比较； int compare(const string &s) const;//比较当前字符串和s的大小 int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小 int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小 int compare(const char *s) const; int compare(int pos, int n,const char *s) const; int compare(int pos, int n,const char *s, int pos2) const; compare函数在>时返回1，<时返回-1，==时返回0 string的子串： string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串 string的交换： void swap(string &s2); //交换当前字符串与s2的值 string类的查找函数： int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置 int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置 int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置 int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置 //查找成功时返回所在位置，失败返回string::npos的值 int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置 int rfind(const char *s, int pos = npos) const; int rfind(const char *s, int pos, int n = npos) const; int rfind(const string &s,int pos = npos) const; //从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值 int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置 int find_first_of(const char *s, int pos = 0) const; int find_first_of(const char *s, int pos, int n) const; int find_first_of(const string &s,int pos = 0) const; //从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos int find_first_not_of(char c, int pos = 0) const; int find_first_not_of(const char *s, int pos = 0) const; int find_first_not_of(const char *s, int pos,int n) const; int find_first_not_of(const string &s,int pos = 0) const; //从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos int find_last_of(char c, int pos = npos) const; int find_last_of(const char *s, int pos = npos) const; int find_last_of(const char *s, int pos, int n = npos) const; int find_last_of(const string &s,int pos = npos) const; int find_last_not_of(char c, int pos = npos) const; int find_last_not_of(const char *s, int pos = npos) const; int find_last_not_of(const char *s, int pos, int n) const; int find_last_not_of(const string &s,int pos = npos) const; //find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找 string类的替换函数： string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串s string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符 string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在p0处插入串s string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符 string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处插入n个字符c string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串s string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符 string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串s string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符c string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串 string类的插入函数： string &insert(int p0, const char *s); string &insert(int p0, const char *s, int n); string &insert(int p0,const string &s); string &insert(int p0,const string &s, int pos, int n); //前4个函数在p0位置插入字符串s中pos开始的前n个字符 string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c iterator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置 void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符 void insert(iterator it, int n, char c);//在it处插入n个字符c string类的删除函数 iterator erase(iterator first, iterator last);//删除[first，last）之间的所有字符，返回删除后迭代器的位置 iterator erase(iterator it);//删除it指向的字符，返回删除后迭代器的位置 string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串 string类的迭代器处理： string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。 用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有： const_iterator begin()const; iterator begin(); //返回string的起始位置 const_iterator end()const; iterator end(); //返回string的最后一个字符后面的位置 const_iterator rbegin()const; iterator rbegin(); //返回string的最后一个字符的位置 const_iterator rend()const; iterator rend(); //返回string第一个字符位置的前面 rbegin和rend用于从后向前的迭代访问，通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现 字符串流处理： 通过定义ostringstream和istringstream变量实现，<sstream>头文件中 例如： string input("hello,this is a test"); istringstream is(input); string s1,s2,s3,s4; is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test" ostringstream os; os<<s1<<s2<<s3<<s4; cout<<os.str();
6.stable_sort
sort优点一大堆，一个缺点就是它不是一种稳定的排序。要追求稳定性，只好用stable_sort了。
在各种排序算法中，合并排序是稳定的，但一般的合并排序需要额外的O(N)的存储空间，而这个条件不是一定能够满足的。所以在stable_sort内部，首先判断是否有足够的额外空间，有的话就使用普通合并函数，总的时间复杂性和快速排序一个数量级，都是O(N*logN)。
如果没有额外空间，使用了一个merge_without_buffer的关键函数进行就地合并，这个合并过程不需要额外的存储空间（递归的堆栈除外），但时间复杂度变成O(N*logN)，这种情况下，总的stable_sort时间复杂度是O(N*logN*logN)。