低级数据结构
单调队列
1293 : 生 日 礼 物 1293:生日礼物 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;
}
最大子序和
可 以 y y 一 下 , 最 优 选 择 的 策 略 集 合 一 定 是 一 个 可以yy一下,最优选择的策略集合一定是一个 可以yy一下,最优选择的策略集合一定是一个下标位置递增、对应的前缀和S的值也递增 的 序 列 , 枚 举 右 端 点 i , 对 i 执 行 以 下 操 作 : 的序列,枚举右端点i,对i执行以下操作: 的序列,枚举右端点i,对i执行以下操作:
- 判 断 队 头 决 策 与 i 的 距 离 是 否 超 出 M 的 范 围 , 超 出 则 出 队 。 判断队头决策与i的距离是否超出M的范围,超出则出队。 判断队头决策与i的距离是否超出M的范围,超出则出队。
- 此 时 队 头 就 是 右 端 点 为 i 时 , 左 端 点 j 的 最 优 选 择 。 此时队头就是右端点为i时,左端点j的最优选择。 此时队头就是右端点为i时,左端点j的最优选择。
- 不 断 删 除 队 尾 决 策 , 直 到 队 尾 对 应 的 S 值 小 于 S [ i ] 。 然 后 把 i 作 为 一 个 新 的 决 策 入 队 。 不断删除队尾决策,直到队尾对应的S值小于S[i]。然后把i作为一个新的决策入队。 不断删除队尾决策,直到队尾对应的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 最 小 函 数 值 2085 最小函数值 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;
}
结 构 体 类 型 ( s t r u c t ) 的 s e t , 使 用 时 必 须 要 重 载 < 运 算 符 结构体类型(struct )的set ,使用时必须要重载<运算符 结构体类型(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
《C
《C++
P
r
i
m
e
r
》
Primer》
Primer》