STL

参考：http://www.cplusplus.com/reference/set/set/

一、set 是按特定顺序存储唯一元素的容器

实现是一种非常高效的平衡检索二叉树：红黑树(Red-Black Tree)。

二、set 的特性

1、set中的元素都是排好序的（与lower_bound()等结合使用能起到找前驱、后继的作用）

2、set集合中没有重复的元素（常常用于去重）

三、set 的成员函数

begin（）	返回指向第一个元素的迭代器
end（）	返回指向最后一个元素的迭代器

// set::begin/end
#include <iostream>
#include <set>

int main ()
{
  int myints[] = {75,23,65,42,13};
  std::set<int> myset (myints,myints+5);

  std::cout << "myset contains:";
  for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
    std::cout << ' ' << *it;

  std::cout << '
';

  return 0;
}

empty ()	如果集合为空，返回true
size ()	集合中元素的数目
max_size()	返回集合能容纳的元素的最大限值

// set::empty
#include <iostream>
#include <set>

int main ()
{
  std::set<int> myset;

  myset.insert(20);
  myset.insert(30);
  myset.insert(10);

  std::cout << "myset contains:";
  while (!myset.empty())
  {
     std::cout << ' ' << *myset.begin();
     myset.erase(myset.begin());
  }
  std::cout << '
';

  return 0;
}


// set::size
#include <iostream>
#include <set>

int main ()
{
  std::set<int> myints;
  std::cout << "0. size: " << myints.size() << '
';

  for (int i=0; i<10; ++i) myints.insert(i);
  std::cout << "1. size: " << myints.size() << '
';

  myints.insert (100);
  std::cout << "2. size: " << myints.size() << '
';

  myints.erase(5);
  std::cout << "3. size: " << myints.size() << '
';

  return 0;
}

// set::max_size
#include <iostream>
#include <set>

int main ()
{
  int i;
  std::set<int> myset;

  if (myset.max_size()>1000)
  {
    for (i=0; i<1000; i++) myset.insert(i);
    std::cout << "The set contains 1000 elements.
";
  }
  else std::cout << "The set could not hold 1000 elements.
";

  return 0;
}

insert()	在集合中插入元素
erase()	删除集合中的元素
swap()	交换两个集合变量
clear()	清除所有元素

 

 

 

 

// set::insert (C++98)
#include <iostream>
#include <set>

int main ()
{
  std::set<int> myset;
  std::set<int>::iterator it;
  std::pair<std::set<int>::iterator,bool> ret;

  // set some initial values:
  for (int i=1; i<=5; ++i) myset.insert(i*10);    // set: 10 20 30 40 50

  ret = myset.insert(20);               // no new element inserted

  if (ret.second==false) it=ret.first;  // "it" now points to element 20

  myset.insert (it,25);                 // max efficiency inserting
  myset.insert (it,24);                 // max efficiency inserting
  myset.insert (it,26);                 // no max efficiency inserting

  int myints[]= {5,10,15};              // 10 already in set, not inserted
  myset.insert (myints,myints+3);

  std::cout << "myset contains:";
  for (it=myset.begin(); it!=myset.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  return 0;
}


// erasing from set
#include <iostream>
#include <set>

int main ()
{
  std::set<int> myset;
  std::set<int>::iterator it;

  // insert some values:
  for (int i=1; i<10; i++) myset.insert(i*10);  // 10 20 30 40 50 60 70 80 90

  it = myset.begin();
  ++it;                                         // "it" points now to 20

  myset.erase (it);

  myset.erase (40);

  it = myset.find (60);
  myset.erase (it, myset.end());

  std::cout << "myset contains:";
  for (it=myset.begin(); it!=myset.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  return 0;
}


// swap sets
#include <iostream>
#include <set>

main ()
{
  int myints[]={12,75,10,32,20,25};
  std::set<int> first (myints,myints+3);     // 10,12,75
  std::set<int> second (myints+3,myints+6);  // 20,25,32

  first.swap(second);

  std::cout << "first contains:";
  for (std::set<int>::iterator it=first.begin(); it!=first.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  std::cout << "second contains:";
  for (std::set<int>::iterator it=second.begin(); it!=second.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  return 0;
}


// set::clear
#include <iostream>
#include <set>

int main ()
{
  std::set<int> myset;

  myset.insert (100);
  myset.insert (200);
  myset.insert (300);

  std::cout << "myset contains:";
  for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  myset.clear();
  myset.insert (1101);
  myset.insert (2202);

  std::cout << "myset contains:";
  for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  return 0;
}

find()	返回一个指向被查找到元素的迭代器
count()	返回某个值元素的个数
lower_bound()	返回指向大于（或等于）某值的第一个元素的迭代器
upper_bound()	返回大于某个值元素的迭代器

// set::find
#include <iostream>
#include <set>

int main ()
{
  std::set<int> myset;
  std::set<int>::iterator it;

  // set some initial values:
  for (int i=1; i<=5; i++) myset.insert(i*10);    // set: 10 20 30 40 50

  it=myset.find(20);
  myset.erase (it);
  myset.erase (myset.find(40));

  std::cout << "myset contains:";
  for (it=myset.begin(); it!=myset.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  return 0;
}


// set::count
#include <iostream>
#include <set>

int main ()
{
  std::set<int> myset;

  // set some initial values:
  for (int i=1; i<5; ++i) myset.insert(i*3);    // set: 3 6 9 12

  for (int i=0; i<10; ++i)
  {
    std::cout << i;
    if (myset.count(i)!=0)
      std::cout << " is an element of myset.
";
    else
      std::cout << " is not an element of myset.
";
  }

  return 0;
}


// set::lower_bound/upper_bound
#include <iostream>
#include <set>

int main ()
{
  std::set<int> myset;
  std::set<int>::iterator itlow,itup;

  for (int i=1; i<10; i++) myset.insert(i*10); // 10 20 30 40 50 60 70 80 90

  itlow=myset.lower_bound (30);                //       ^
  itup=myset.upper_bound (60);                 //                   ^

  myset.erase(itlow,itup);                     // 10 20 70 80 90

  std::cout << "myset contains:";
  for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  return 0;
}

例题：http://poj.org/problem?id=3050

Hopscotch

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 5441		Accepted: 3582

Description

The cows play the child's game of hopscotch in a non-traditional way. Instead of a linear set of numbered boxes into which to hop, the cows create a 5x5 rectilinear grid of digits parallel to the x and y axes. 

They then adroitly hop onto any digit in the grid and hop forward, backward, right, or left (never diagonally) to another digit in the grid. They hop again (same rules) to a digit (potentially a digit already visited). 

With a total of five intra-grid hops, their hops create a six-digit integer (which might have leading zeroes like 000201). 

Determine the count of the number of distinct integers that can be created in this manner.

Input

* Lines 1..5: The grid, five integers per line

Output

* Line 1: The number of distinct integers that can be constructed

Sample Input

1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 2 1
1 1 1 1 1

Sample Output

15

Hint

OUTPUT DETAILS: 
111111, 111112, 111121, 111211, 111212, 112111, 112121, 121111, 121112, 121211, 121212, 211111, 211121, 212111, and 212121 can be constructed. No other values are possible.

Source

USACO 2005 November Bronze

 

题目大意：

有一个 5*5 矩阵，你可以在矩阵里朝上下左右行走五步，起点任意。问能走出多少种不同的序列。

大概思路：

DFS + set去重

 

AC code（492K 32MS）：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <set>
#define INF 0x3f3f3f3f
using namespace std;

int mp[6][6];
set<int> S;
int ans;

void dfs(int x, int y, int step, int sum)
{
    if(step == 6)
    {
        sum = sum*10 + mp[x][y];
        S.insert(sum);
        //ans = S.size();
        //printf("%d
", ans);
        return;
    }
    else
    {
        sum = sum*10 + mp[x][y];
        if(x-1 >= 1) dfs(x-1, y, step+1, sum);
        if(x+1 <= 5) dfs(x+1, y, step+1, sum);
        if(y-1 >= 1) dfs(x, y-1, step+1, sum);
        if(y+1 <= 5) dfs(x, y+1, step+1, sum);
    }
    return;
}

int main()
{
    for(int i = 1; i <= 5; i++)
    for(int j = 1; j <= 5; j++)
    {
        scanf("%d", &mp[i][j]);
    }

    for(int i = 1; i <= 5; i++)
    for(int j = 1; j <= 5; j++)
    {
        dfs(i, j, 1, 0);
    }
    ans = S.size();
    printf("%d
", ans);
    return 0;
}

例题：https://www.lydsy.com/JudgeOnline/problem.php?id=1588

1588: [HNOI2002]营业额统计

Time Limit: 5 Sec  Memory Limit: 162 MB
Submit: 19175  Solved: 8093

Description

营业额统计 Tiger最近被公司升任为营业部经理，他上任后接受公司交给的第一项任务便是统计并分析公司成立以来的营业情况。 Tiger拿出了公司的账本，账本上记录了公司成立以来每天的营业额。分析营业情况是一项相当复杂的工作。由于节假日，大减价或者是其他情况的时候，营业额会出现一定的波动，当然一定的波动是能够接受的，但是在某些时候营业额突变得很高或是很低，这就证明公司此时的经营状况出现了问题。经济管理学上定义了一种最小波动值来衡量这种情况： 该天的最小波动值 当最小波动值越大时，就说明营业情况越不稳定。 而分析整个公司的从成立到现在营业情况是否稳定，只需要把每一天的最小波动值加起来就可以了。你的任务就是编写一个程序帮助Tiger来计算这一个值。 第一天的最小波动值为第一天的营业额。  输入输出要求

Input

第一行为正整数 ，表示该公司从成立一直到现在的天数，接下来的n行每行有一个整数(有可能有负数) ，表示第i

天公司的营业额。

天数n<=32767,

每天的营业额ai <= 1,000,000。

最后结果T<=2^31

Output

输出文件仅有一个正整数，即Sigma(每天最小的波动值) 。结果小于2^31 。

Sample Input

6
5
1
2
5
4
6

Sample Output

12

HINT

结果说明：5+|1-5|+|2-1|+|5-5|+|4-5|+|6-5|=5+4+1+0+1+1=12

题目大意：显而易见

大概思路：set + lower_bound() 求前驱或者后继

 

AC code：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define ll long long int
using namespace std;

set<ll> T;
int N;

int main()
{
    scanf("%d", &N);
    set<ll>::iterator it;
    if(N == 0)
    {
        printf("0
");
        return 0;
    }
    ll res = 0;
    ll p = 0;
    N--;
    scanf("%lld", &p);
    res+=p;
    T.insert(p);

    while(N--)
    {   ll t = INF;
        scanf("%lld", &p);
        it = T.lower_bound(p);
        if(it != T.end())
        {
            t = min(t, abs((*it)-p));
        }
        if(it != T.begin())
        {
            t = min(t, abs((*--it)-p));
        }
        res+=t;
        T.insert(p);
    }
    printf("%lld
", res);

    return 0;
}