低级数据结构与stl简单使用

低级数据结构

单调队列

$1293:生日礼物$

#include <iostream>
#include <cstdio>
#include <algorithm>
const int N = 1e6 + 5, INF = 0x3f3f3f3f;
using namespace std;
int vis[65];
int ans = INF;

struct node
{
    int x, id;
    node(int a = 0, int b = 0):x(a),id(b) {}
    friend bool operator < (const node& a, const node& b) {
        return a.x < b.x;
    }
}q[N];

int main()
{
    int n, k, m, t, cnt = 0, c = 1;
    scanf("%d%d", &n, &k);
    for (int i = 0; i < k; ++i) {
        scanf("%d", &m);
        while(m--) {
            scanf("%d", &t);
            q[cnt++] = node(t, i);
        }
    }
    sort(q, q + cnt);
    int l = 0, r = 0;
    vis[q[0].id] = 1;
    while (l <= r) {
        while (c < k && r < n - 1) {
            if(++vis[q[++r].id] == 1) c++;
        }
        if (c == k) ans = min(ans, q[r].x - q[l].x);
        if(--vis[q[l++].id] == 0)  c--;
    }
    printf("%d\n", ans);
    return 0;
}

---

最大子序和

$可以yy一下，最优选择的策略集合一定是一个$下标位置递增、对应的前缀和S的值也递增$的序列，枚举右端点i，对i执行以下操作:$

1. $判断队头决策与i的距离是否超出M的范围，超出则出队。$
2. $此时队头就是右端点为i时，左端点j的最优选择。$
3. $不断删除队尾决策，直到队尾对应的S值小于S[i]。然后把i作为一个新的决策入队。$

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 3e5 + 5, INF = 0x3f3f3f3f;
int n, m, s[N], q[N];

int main()
{
    cin >> n >> m;
    s[0] = 0;
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &s[i]);
        s[i] += s[i - 1];
    }
    int l = 1, r = 1, ans = -INF;//l队头r队尾
    for (int i = 1; i <= n; ++i) {
        while (l <= r && q[l] < i - m) l++;
        ans = max(ans, s[i] - s[q[l]]);
        while (l <= r && s[q[r]] >= s[i]) r--;
        q[++r] = i;
    }
    cout << ans << endl;
    return 0;
}

---

stl的简单使用

string

#include <iostream>
#include <string>
using namespace std;

int main()
{
	cout << "***Test 1 begin***" << endl;
	const char *cp = "Hello World!!!";
	char noNull[] = {'H', 'i'};
	string s1(cp); //拷贝cp中字符直到遇到空字符；s1 = "Hello World!!!"
	string s2(noNull, 2); //从noNull中拷贝两个字符：s2 = "Hi"
	string s3(cp + 6, 5); //从cp[6]开始拷贝5个字符；s3 = "World"
	string s4(s1, 6, 5); // 从s1[6]开始拷贝5个字符；s4 = "World"
	cout << s1 << endl << s2 << endl << s3 << endl << s4 << endl << endl;

	string s("Hello World");
	cout << s.max_size() << endl;
	string s5 = s.substr(0, 5); //s5 = "hello"
	string s6 = s.substr(6); //s6 = world;
	cout << s5 << endl << s6 << endl;

    int pos = s.find("World", 0);
    cout << pos << endl;

    s.append(5, '!');
    cout << s << endl;
	s.insert(s.size(), 5, '!'); //末尾插入5个感叹号
	cout << s << endl;
	s.erase(s.size() - 10, 10); //s删除最后10个字符串
	cout << s << endl;
	cout << "***Test 1 end***" << endl;
	return 0;
}

---

stack，queue 和 priority_queue

stack

• size()
• top()
• push()
• pop()
• empty()

queue && priority_queue

• empty()
• front()
• push()
• front()
• back()
• pop()
• size()

//下面两种优先队列的定义是等价的
priority_queue<int> q;
priority_queue<int, vector<int>, less<int> >;//后面有一个空格

$如果想让优先队列总是把最小的元素放在队首，只需进行如下的定义：$

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

P$2085最小函数值$

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
const int N = 1e4 + 5;
int n, m;

struct fun
{
    int a, b, c;
}f[N];

struct val
{
    int num, x, v;
    val(int a = 0, int b = 0, int c = 0):num(a),x(b),v(c) {}
    bool operator < (const val& a) const{
        return v > a.v;
    }
}res[N];

priority_queue<val, vector<val>, less<val> > q;

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; ++i) {
        scanf("%d%d%d", &f[i].a, &f[i].b, &f[i].c);
        q.push(val(i, 1, f[i].a + f[i].b + f[i].c));
    }
    for (int i = 0; i < m; ++i) {
        val t = q.top();
        q.pop();
        printf("%d ", t.v);
        q.push(val(t.num, t.x + 1, f[t.num].a*(t.x+1)*(t.x+1) + f[t.num].b*(t.x+1) + f[t.num].c));
    }
    return 0;
}

---

vector

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    int a[10] = {2, 4, 6, 8, 10, 9, 7, 5, 3, 1};
    vector<int> v(a, a + 7);
    //v.assign(b.begin(), b.begin() + 3); //将b的0~2个元素构成的向量赋给v
    //v.assign(4, 2); v只含四个2
    v.push_back(11);
    for(vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    v.pop_back();

    cout << endl << v.front() << " " << v.back() << " " << v.size() << " " << v.capacity() << endl;
    v.clear();
    if(v.empty()) cout << "empty\n";
    return 0;
}

• begin()
• end()
• empty()
• front()
• back()
• push_back()
• pop_back()

map

#include <iostream>
#include <map>
using namespace std;

int main()
{
       map<int, string> Student;
       Student[1] =  “student_one”;
       Student[2] =  “student_two”;
       Student[3] =  “student_three”;
       //Student.insert(pair<int, string>(1, “student_one”));
       //Student.insert(pair<int, string>(2, “student_two”));
       //Student.insert(pair<int, string>(3, “student_three”))
       map<int, string>::iterator  it;
       for (it = Student.begin(); it != mapStudent.end(); it++)
      　　 cout << iter->first << ”   ” << it->second << end;
}

---

deque

• push_front()
• push_back()
• pop_front()
• pop_back()
• erase()
• front()
• back()
• empty()
• size()

#include <deque>  
#include <cstdio>  
#include <algorithm>  
using namespace std;  
int main()  
{  
    deque<int> ideq(20); //Create a deque ideq with 20 elements of default value 0  
    deque<int>::iterator pos;  
    int i;  
    for (i = 0; i < 20; ++i)  
        ideq[i] = i;  
  
    printf("输出deque中数据:\n");  
    for (i = 0; i < 20; ++i)  
        printf("%d ", ideq[i]);  
    putchar('\n');  
  
    //在头尾加入新数据  
    printf("\n在头尾加入新数据...\n");  
    ideq.push_back(100);  
    ideq.push_front(i);  
  
    //输出deque  
    printf("\n输出deque中数据:\n");  
    for (pos = ideq.begin(); pos != ideq.end(); pos++)  
        printf("%d ", *pos);  
    putchar('\n');  
  
    //查找  
    const int FINDNUMBER = 19;  
    printf("\n查找%d\n", FINDNUMBER);  
    pos = find(ideq.begin(), ideq.end(), FINDNUMBER);//注意迭代器类型在此查找  
    if (pos != ideq.end())  
        printf("find %d success\n", *pos);  
    else  
        printf("find failed\n");  
  
    //在头尾删除数据  
    printf("\n在头尾删除数据...\n");  
    ideq.pop_back();  
    ideq.pop_front();  
  
    //输出deque  
    printf("\n输出deque中数据:\n");  
    for (pos = ideq.begin(); pos != ideq.end(); pos++)  
        printf("%d ", *pos);  
    putchar('\n');  
    return 0;  
}  

---

lower_bound( )和upper_bound( )

#include <iostream>
#include <algorithm>
using namespace std;

int main(){
	cout << "lower_bound and upper_bound test" << endl;
	int b[7] = {1, 3, 5, 7, 9, 11, 13};
	int c[7] = {30, 28, 26, 24, 22, 20, 18};
	int t1 = lower_bound(b, b + 7, 5) - b;//返回数组中第一个大于或等于被查数的值
	int t2 = upper_bound(b, b + 7, 5) - b;//返回数组中第一个大于被查数的值
	int t3 = lower_bound(c, c + 7, 1, greater<int>()) - c;//返回数组中第一个小于或等于被查数的值
	int t4 = upper_bound(c, c + 7, 1, greater<int>()) - c;//返回数组中第一个小于被查数的值
	cout << b[t1] << " " << b[t2] << " " <<  t1 << " " << t2 << endl;
	cout << c[t3] << " " << c[t4] << " " <<  t3 << " " << t4 << endl;
	cout << "test ending" << endl;
	return 0;
} 

unique

#include<iostream>
#include<algorithm>
#include <vector>
using namespace std;

int main()
{
    int a[12] = {3, 2, 3, 4, 5, 2, 6, 9 ,10, 5, 9, 10};
    sort(a, a + 12);    //无序数组先排序
    int t = unique(a, a + 12) - a;
    for(int i = 0; i < t; ++i)
        cout << a[i] << " ";
    cout << endl;
    vector<int> v = {1, 4, 3, 3, 4, 5, 6, 6, 7};
    vector<int>::iterator it;
    sort(v.begin(), v.end());
    it = unique(v.begin(), v.end());
    v.resize(distance(v.begin(), it));
    //sort(v.begin(), v.end());
    //v.erase(unique(v.begin(), v.end()), v.end());
    for(it = v.begin(); it != v.end(); ++it)
        cout << *it << " ";
    cout << endl;
}

---

nth_element

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool cmp(int a, int b)
{
    return a > b;
}

int main () {
    vector<int> v;
    for (int i=1; i<10; i++) v.push_back(i);   // 1 2 3 4 5 6 7 8 9
    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
        cout << ' ' << *it;
    cout << '\n';

    random_shuffle (v.begin(), v.end());
    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
        cout << ' ' << *it;
    cout << '\n';

    nth_element (v.begin(), v.begin()+5, v.end());
    //使第n大元素处于第n位置,比这个元素小的元素都排在这个元素之前，比这个元素大的元素都排在这个元素之后
    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
        cout << ' ' << *it;
    cout << '\n';

    nth_element (v.begin(), v.begin()+5, v.end(), cmp);
    //使第n小元素处于第n位置,比这个元素大的元素都排在这个元素之前，比这个元素小的元素都排在这个元素之后
    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
        cout << ' ' << *it;
    cout << '\n';

    return 0;
}

---

set

• begin()
• end()
• insert()
• clear()
• empty()
• max_size()
• size()
• erase(it)
• count()
• find()

#include <iostream>
#include<set>
using namespace std;

int main()
{
    set<int> s;                //创建一个int类型的set
    s.insert(1);                //插入数据
    s.insert(3);
    s.insert(2);
    s.insert(1);
    cout << "set 中 1 出现的次数是: "<< s.count(1) << endl;
    for (set<int>::iterator it = s.begin(); it != s.end(); ++it)    
        cout << *it << endl;	//这里用到了set中的元素已经从小到大排好序的性质
    return 0;
}

$结构体类型（struct）的set，使用时必须要重载<运算符$

1.强调快速随机访问。则vector要比list好得多 。
2.已知要存储元素的个数。vector 好于list。
3.强调增删且不要在两端插入修改元素。则list显然要比vector好。
4.除非我们需要在容器首部插入和删除元素，deque好于vector。因为vector仅仅在尾部增删快速。
5.如果只在容易的首部和尾部插入数据元素，则选择deque.
6.如果只需要在读取输入时在容器的中间位置插入元素，然后需要随机访问元素，则可考虑输入时将元素读入到一个List容器，然后排序，然后将排序后的list容器复制到一个vector容器中。

• 能进行算术运算的迭代器只有随机访问迭代器，要求容器元素存储在连续内存空间内，
• 即vector、string、deque的迭代器是有加减法的；
• 而map、set、multimap、multiset、list的迭代器是没有加减法的。他们仅支持++itr、–itr这些操作。

参考文献:
[1] $《C$++$Primer》$