大一ACM第一周总结(边练边改)

                            一、STL
                            二、贪心算法
            小技巧：
            万能头文件
           1. #include<bits/stdc++.h>
            using namespace std;
           2.sync_with_stdio(false)//可以使cin加快；
            应用函数：
            
           1. 简便的排列方式sort
             头文件：#include<algorithm>
             用法：
              sort(begin,end)
              sort(begin,end,cmp)
              eg:
                int num[]={1,5,6,2,9};
                sort(num,num+5);//不加函数则默认从小到大排列；
                bool cmp(int a int b)
                { return a>b;  
                }
                sort(num,num+5，cmp);//从大到小排列;
           2.去重unique
              描述：该函数作用是“去除”容器或者数组中相邻元素的重复出现的元素。（注意是相邻）    
                   去除实质是将重复的元素放到容器的末尾，返回值是去重之后的尾地址；
              定义：1.iterator unique(iterator begin,iterator);
                    2.iterator uinque(iterator begin,iterator end,bool MyFunc);
                    iterator是迭代器，这个函数意义表示对区间[it_1,it_2）去重//左闭右开区间
                    最后一个参数是元素是否相等的判定函数。
                    返回值是指向最后一个元素的下一个元素的迭代器。
              用法（***做题后写***）
                    
           3.生成排列
              头文件：#include<algorithm>
              定义：1.bool next_permutation(begin,end);
              //改变区间内元素的顺序，产生下一个排列。
                    2.bool prev_permuation(begin,end);
             //产生前一个排列；end为最后一个元素的下一个位置；
           4.upper_bound和lower_bound
               定义：1.upper_bound(begin,end,value);
               //返回>value的元素的第一个位置；
                     2.lower_bound(begin,end,value);
                //返回>=value的元素的第一个位置；
              eg:
                num[]={1,3,5,2,4,6,7,5,2,5};
                lower_bound(num,num+6,2)//为num+1;
                upper_bound(num,num+6,2)//为num+3;
           
                  
           
             一：
    string:
              描述：可变长度的字符序列
              头文件：<string>
              定义：string s1;
              用法：
          1.赋值
              eg:
                s2="today";
              eg:
                s2=s1;//把s1的内容赋给s2；
          2.字符串连接、追加
              eg:
                s1="4";
                s2="3";
                s3=s1+s4;//s3="43";
              eg:
                s1+=s2;//把s2的内容加到s1后面去；
          3.将string写到输出流中;将输入流写到string中
              eg:
                os<<s;//将s写到输出流os中,返回os;
              eg:
                is>>s;
                //将输入流is读取字符串写到s中，字符串用空白分隔，返回is;
              eg:
                getline(is,s)//从输入流is中读取一行赋给s,返回is；从输入流is读取内容，遇到换行符为止；
          4.empty
              eg:
                s.empty();//s为空返回true,否则返回false;
          5.size
              eg:
                s.size();//返回s中字符的个数；
          6.对字符串中单个字符的引用
              eg:
                s[n];
          7.转换（***不会用***）
              eg:
                s.c_str()；//返回s中内容对应的c风格字符串首地址；
          8.判断两个字符串大小关系
              eg:
                s1==s2;//s1和s2中字符完全一样时为相等；
              eg:
                s1!=s2;//与上原理一致，但注意比较时区分字母大小写
              eg:
                <.<=,>,>=;//利用字符在字典中的位置顺序进行比较；（比较原则过后补充）
    栈（stack）:
    
              描述：一种先进后出的数据结构，只有一个出口，只能操作最顶端元素。
              定义：stack<data_type>stack_name;
                   eg:
                     stack<int>s;
              用法：
           1.empty
              eg: 
                s.empty();
           2.size
               eg:
                 s.size();
           3.返回栈顶元素值
               eg:
                 s.top();//栈顶的元素是后进的元素
           4.移除栈顶元素
               eg:
                 s.pop();
           5.向栈中压入一个元素
               eg:
                 s.push(a);
    队列（queue）：
    
              描述：一种先进先出的数据结构，从低端加入元素，从顶端取出元素。
              用法：
           1.empty
               eg:
                 q.empty();
           2.size
               eg:
                 q.size();
           3.返回队列内下个元素
               eg:
                 q.front();
           4.返回队列内最后一个元素
                eg:
                  q.back();
           5.移除队列内一个元素
                eg:
                  q.pop();
           6.向队列内放入一个元素
                eg:
                  q.push(a);
    vector:
              描述：动态数组
              定义：vector<data_type>vector_name;
                   eg:
                     vector<int>v;
              用法：
           1.empty
                 eg:
                   v.empty();
           2.size
                 eg:
                   v.size();
           3.将元素插入最尾端
               push_back(data_type a);
                  eg:
                    v.push_back(int a);//将整形元素a插入最尾端  
           4. 将最尾端元素删除
               pop_back();
                  eg:
                    v.pop_back();//将v最尾端元素删除；
           5. 取某一位置的元素
               v[i];
                  eg:
                  v[0];
   优先队列（priority_queue）:
               描述：拥有权值观念的queue,自动依照元素权值排列，高在前，低在后；
                       缺省情况下，priority_queue是利用max_heap完成的（***不懂***）
               头文件：#include<queue>
               定义：
                 priority_queue<data_type>priority_queue_name;
                   eg:
                     priority_queue<int>q;//默认是大顶堆（***不懂***）
               1.empty;
                   eg:
                     q.empty;
               2.size;
                   eg:
                     q.size; 
               3.将元素置入优先队列；
                   eg:
                     q,push(elem);
               4.返回优先队列的下一个元素
                   eg:
                     q.top();
               5.移除一个元素
                   eg:
                     q.pop();
  set和multiset的简单应用；
                头文件：#include<set>
                定义：1.set<data_type>set_name;
                    eg:
                      set<int >s;//默认由小到大排序；
                      若想按照自己的方式排序，可以重载小于号。(***不懂***)
                 struct new type
                 {
                 int x,y;
                 bool operator<(const new_type &a)const
                 {
                  if(x!=a.x)
                  return x<a.x;
                  return y<a.y;
                  }

                        } 
                 set<new_type>s;
                 用法：
                    1.安插新副本，返回新元素位置
                     s.insert(elem);
                    2.移除与elem元素相等的所有元素
                    s.erase(elem);//返回值为被移除的元素的个数；
                    3.移除迭代器pos所指位置上的元素
                     s.erase(pos);//无返回值；
                    4.移除全部元素，将容器清空；
                         s.clear();
                     5.size;
                       eg:   
                         s.size();
                     6.empty;
                       eg:
                         s.empty();
                     7.计数;
                       eg:
                         s.count（elem);
                         .//返回元素值为elem的元素的个数；
                     8.lower_bound(elem)和upper_bound(elem)
                      返回元素值>=elem的第一个元素的位置；
                      返回元素值>elem的第一个元素的位置//这俩位置都是迭代器。
                     9.返回迭代器的一个位置
                       eg:
                         s.begin();//返回一个双向迭代器，指向第一个元素；
                         s.end();//返回一个双向迭代器，只想最后一个元素的下一个；
                     
             注：迭代器：
              eg:
             multiset<int>::iterator pos;
             for(pos=s.begin();pos!=s.end();pos++)
  map和multimap简单应用：
               头文件：#include<map>
               定义：map<data_type1,data_type2>map_name;
                       eg:
                         map<string,int>m//默认按string由小到大排序；
               用法：
                      1.size;
                       eg:
                         m.size();
                      2.empty();
                        eg:
                          m.empty();
                      3.某元素的个数；
                        eg:
                          m.count(key);//返回键值等于key的元素的个数；
                      4.lower_bound和upper_bound；
                        eg:
                          m.lower_bound(key);
                          //返回键值等于key的元素的第一个可安插的位置；
                          m.upper_bound(key);
                          //返回键值等于key的元素的最后一个可安插的位置；
                       5. 返回迭代器的某一位置；
                         m.begin();//指向第一个元素；
                         m.end();//指向最后一个元素的下一个位置；
                       6.将容器清空；
                         m.clear();
                       7.移除键值为elem的所有元素；
                         m.erase(pos)//移除迭代器pos所指位置上的元素。
                       8.直接元素存取；
                         m[key]=value;//查找的时候若键值没有为key的元素，则安插一个键值；
                       9.插入一个元素；
                           m.insert(elem)//插入一个元素elem；
                         a)运用value_type插入(***不懂***)
                         map<string,float>m;
                         m.insert(map<string,float)::value_type("Robin",22.3));
                         b)运用pair<>(***不懂***)
                           m.insert(pair<string,float>("Robin",22.3));
                         c)运用make_pair()(***不懂***)
                           m.insert(make_pair("Robin",22,3))；
二、贪心算法
    描述：一种求最优解的办法，按照某种最优策略，将复杂问题层层分解成子问题（一般每次只有一个），再通过解决子问题得到整个问题的最优解；
    原理：从局部上考虑问题，而不是从整体上考虑‘
    流程：
           1.判断能否使用贪心算法；
           2.如何选择贪心标准，得到最优解；