DAY 4 基础算法

基础算法

本来今天是要讲枚举暴力还有什么的，没想到老师就说句那种题目就猪国杀，还说只是难打，不是难。。。。

STL（一）set

感觉今天讲了好多，set，单调栈，单调队列，单调栈和单调队列保证了序列的单调性，一般的，凡是找左右第一个比他大或小的大概率是这个东西，原来作业1的奶牛歌声就是这个东西，但不是道为什么我爆力优化过了。。。。

然后就是这题

 这题要用set，不用还过不了。。。。

set常用函数

• begin()     　　 ,返回set容器的第一个元素
• end() 　　　　 ,返回set容器的最后一个元素
• clear()   　　     ,删除set容器中的所有的元素
• empty() 　　　,判断set容器是否为空
• max_size() 　 ,返回set容器可能包含的元素最大个数
• size() 　　　　 ,返回当前set容器中的元素个数
• rbegin　　　　 ,返回的值和end()相同
• rend()　　　　 ,返回的值和rbegin()相同

可以这样练下手

#include<iostream>
#include<set>
using namespace std;
int main()
{
    set<int >s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(4);
    cout<<"长度是"<<s.size()<<endl;
    cout<<"可能包含元素的最大个数为"<<s.max_size() <<endl;
    cout<<"第一个元素是"<< *s.begin()<<endl;
    cout<<"最后一个元素是"<<*s.end()<<endl;
    s.clear();
    if(s.empty())
    {
        cout<<"空啦！！！！"<<endl; 
    }
        cout<<"长度是"<<s.size()<<endl;
    cout<<"可能包含元素的最大个数为"<<s.max_size() <<endl;
}        

 输出是这样的：

 

注意如果这样打

#include<iostream>
#include<set>
using namespace std;
int main()
{
    set<int >s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    cout<<"第一个元素是"<< *s.begin()<<endl;
    cout<<"最后一个元素是"<<*s.end()<<endl;
    return 0;
}

 我们可以发现最后一个元素显示还是3.。。

 

• count() 用来查找set中某个某个键值出现的次数

这个函数在set并不是很实用，因为一个键值在set只可能出现0或1次，这样就变成了判断某一键值是否在set出现过了。

#include<iostream>
#include<set>
using namespace std;
int main()
{
    set<int >s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    cout<<"set 中 1 出现的次数是 ："<<s.count(1)<<endl;
    cout<<"set 中 4 出现的次数是 ："<<s.count(4)<<endl;
    return 0;
}

 输出应该是这样的

• equal_range() ，返回一对定位器，分别表示第一个大于或等于给定关键值的元素和 第一个大于给定关键值的元素，这个返回值是一个pair类型，如果这一对定位器中哪个返回失败，就会等于end()的值。

 

#include <iostream>
#include <set>

using namespace std;

int main()
{
    set<int> s;
    set<int>::iterator iter;
    for(int i = 1 ; i <= 5; ++i)
    {
        s.insert(i);
    }
    for(iter = s.begin() ; iter != s.end() ; ++iter)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    pair<set<int>::const_iterator,set<int>::const_iterator> pr;
    pr = s.equal_range(3);
    cout<<"第一个大于等于 3 的数是 ："<<*pr.first<<endl;
    cout<<"第一个大于 3的数是 ： "<<*pr.second<<endl;
    return 0;
}

 输出因该是这样的

•  erase(iterator)  ,删除定位器iterator指向的值

• erase(first,second),删除定位器first和second之间的值
• erase(key_value),删除键值key_value的值

 

#include<iostream>
#include<set>
using namespace std;
int main()
{
    set<int> s;
    set<int>::const_iterator iter;
    set<int>::iterator first;
    set<int>::iterator second;
    for(int i = 1 ; i <= 10 ; ++i)
    {
        s.insert(i);
    }
    //第一种删除
    s.erase(s.begin());
    //第二种删除
    first = s.begin();
    second = s.begin();
    second++;
    second++;
    s.erase(first,second);
    //第三种删除
    s.erase(8);
    cout<<"删除后 set 中元素是 ：";
    for(iter = s.begin() ; iter != s.end() ; ++iter)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    return 0;
    return 0;
}

 

输出

 

 

• insert(key_value); 将key_value插入到set中 ，返回值是pair<set<int>::iterator,bool>，bool标志着插入是否成功，而iterator代表插入的位置，若key_value已经在set中，则iterator表示的key_value在set中的位置。

• inset(first,second);将定位器first到second之间的元素插入到set中，返回值是void.

 

• lower_bound(key_value) ，返回第一个大于等于key_value的定位器

 

• upper_bound(key_value)，返回最后一个大于key_value的定位器

非常尴尬的发现就算学了这个东西，那题还是不会。。。。。。。

STL（二）bitset

    感觉这个东西还挺好用的，也是STL里的一个神器，感觉好多题目都能用，那个三维偏序好像除了CDQ分治，KD——tree，和bitset都能打。。。还是只占一个字符，比单纯的bool,好用不知道多少。

初始化：

 

#include<iostream>
#include<bitset>
using namespace std;
int main()
{
    bitset<4> bitset1;//初始化，长度为4，全都是0 
    bitset<8> bitset2(12);//长度是8，用二进制存12，不足位补0 
    string s="10101";
    bitset<10> bitset3(s);//同上 
    cout<<bitset1<<endl;
    cout<<bitset2<<endl;
    cout<<bitset3<<endl;
    return 0;
}

 

 

 

    输出应该是这样的：

另外，bitset只能存0或1，如果有其他的东西会报错，原来char也可以，但不知道为什么会警告，能不用最好还是不用。。。。

一些常见的位运算：

#include<iostream>
#include<bitset>
using namespace std;
int main()
{
    bitset<4> bitset1(string("1100"));
    bitset<4> bitset2(string("0011"));
    cout<<(bitset1^=bitset2)<<endl;//按位异或后将值付给bitset1 
    cout<<(bitset1&=bitset2)<<endl;//按位与后将值付给bitset1 
    cout<<(bitset1|=bitset2)<<endl;//按位或后将值付给bitset1 
    cout<<(bitset1<<=2)<<endl;//右移后将值付给bitset1 
    cout<<(bitset1>>=1)<<endl;//左移后将值付给bitset1 
    cout<<(bitset1==bitset2)<<endl; //假的，返回false（0） 
    cout<<(bitset1!=bitset2)<<endl;//真的，返回true（1或-1）
    cout<<(bitset2&bitset1)<<endl;//左移后将值付给bitset1 ，其他同理 
    return 0;
}

 

输出应该是这样的：

 

还可以像数组那样去访问每一位

一些常用的函数：

这正是STL吸引人的主要原因，可以不用手打，但会慢，对于我这样的蒟蒻就完全不会有影响，但也许对于机房旁边的大佬（传送门）就会有很大影响，这会让他AK不了IOI！！！！

 

#include<iostream>
#include<bitset>
#include<cstdlib>
#include<cstdio>
#include<bits/stdc++.h>
using namespace std;
int main()
{
    bitset<8> bitset1(string("10111010"));
    cout<<bitset1.count()<<endl;//（count函数用来求bitset中1的位数，foo中共有５个１
    cout<<bitset1.size()<<endl;//（size函数用来求bitset的大小，一共有８位
    cout<<bitset1.test(0)<<endl;//（test函数用来查下标处的元素是０还是１，并返回false或true，此处foo[0]为１，返回true
    cout<<bitset1.test(2)<<endl;//（同理，foo[2]为０，返回false
    cout<<bitset1.any()<<endl;//（any函数检查bitset中是否有１
    cout<<bitset1.none()<<endl;//（none函数检查bitset中是否没有１
    cout<<bitset1.all()<<endl;//f（all函数检查bitset中是全部为１　
    //说明一下：test函数会对下标越界做出检查，而用过数组方式访问的元素则不会，所以用test更安全一些 


    string s=bitset1.to_string();//将bitset转换成string类型
    unsigned long a=bitset1.to_ulong();//将bitset转换成unsigned long类型
    cout<<s<<endl;
    cout<<a<<endl;
    

    cout<<bitset1.flip(2)<<endl;//（flip函数传参数时，用于将参数位取反，本行代码将foo下标２处"反转"，即０变１，１变０
    cout<<bitset1.flip()<<endl;//（flip函数不指定参数时，将bitset每一位全部取反
    cout<<bitset1.set()<<endl;//（set函数不指定参数时，将bitset的每一位全部置为１
    cout<<bitset1.set(3,0)<<endl;//（set函数指定两位参数时，将第一参数位的元素置为第二参数的值，本行对foo的操作相当于foo[3]=0
    cout<<bitset1.set(3)<<endl; //（set函数只有一个参数时，将参数下标处置为１
    cout<<bitset1.reset(4)<<endl;//（reset函数传一个参数时将参数下标处置为０
    cout<<bitset1.reset()<<endl;//(reset函数不传参数时将bitset的每一位全部置为０
    //这些函数同样会检查数组下标，有异常会提示。 
    
    return 0;
}

 

 

 

 贪心：

贪心是个非常有用的东西，有时候没有思路，也不会证明，但乱搞就过了。。。。

bzoj 3668 起床困难综合征（门）

• 从高位到低位枚举每一位，判断是1还是0，位运算各位之间不会影响。
• 保证当前的数不会大于m;

• 对于0能变为1的两种情况直接变。

• 0变为的两种情况不予考虑。

代码就非常简单：

 

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=1e5+10;
char op[10];
long long  n,m;
long long  t;
long long  ans=0,ans0=0,ans1=0x7fffffff;
int main()
{
    //freopen("testdata.in","r",stdin);
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%s %lld",op,&t);
        if(op[0]=='A')
        {
            ans1&=t;
            ans0&=t;
        }
        else
        if(op[0]=='O')
        {
            ans1|=t;
            ans0|=t;
        }
        else
        if(op[0]=='X')
        {
            ans1^=t;
            ans0^=t;
        }
    }
    for(int i=30;i>=0;i--)
    {
        if(ans0&(1<<i))
        {
            ans+=(1<<i);
        }
        else
        if((m>=(1<<i))&&(ans1&(1<<i)))
        {
            m-=(1<<i);
            ans+=(1<<i);
        }
    }
    cout<<ans<<endl;
    return 0;
}

 BZOJ 2563 阿狸和桃子的游戏（门）

这题可以吧边权平分到两边的点，这样相对大小没变，一减也没变。

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1e6+10;
int sum[maxn];
int x,y,z;
int k;
int ans=0;
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>k;
        sum[i]=k<<1;
    }
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        sum[x]+=z;
        sum[y]+=z;
    }
    sort(sum+1,sum+1+n);
    for(int i=n;i>=1;i-=2)
    {
        ans+=sum[i]-sum[i-1];
    }
    ans/=2;
    cout<<ans<<endl;
    return 0;
}

 NOIP  2015 跳石头（还是回淮南的测试里的题目）

•  显然这题这题就是二分还是比较经典的哪一类。
• 二分一个答案，看他是否符合条件。
• 贪心
• 从第二块开始循环（第一块不能搬走，要不然你站哪？）假设现在到了第i块，上一个没搬走的是第J块，如果当前的距离小于ans，就可以直接搬走，要不然就留下来。
• 最后一块不能搬走，要不你最后站哪？

快乐的代码时光（机房考试还有人打了线段树，几千字。。。）

 

 

 

 

 

      NOIP 2012 DAY2 T2 借教室

• 这题好快乐，暴力拿了50分。。。
• 正解还是二分，二分一个答案，看他能满足到哪一个订单。
• 然后把1到ans的所有订单都扫描一下。
• 可以用差分数组优化一下复杂度。

代码

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdlib>

using namespace std;

const int maxn=1e6+10;

int need[maxn];
int sheng[maxn];
int r[maxn];
int l[maxn];
int d1[maxn];
int d2[maxn];
int n,m;

int panduan(int x)
{
    memset(d2,0,sizeof(d2));
    for(int i=1;i<=x;i++)
    {
         d2[l[i]]+=d1[i];
        d2[r[i]+1]-=d1[i]; 
    }
    for(int i=1;i<=n;i++)
    {
        need[i]=need[i-1]+d2[i];
        if(need[i]>sheng[i])
        return 0;
    }
    return 1;
}

int main()
{
    memset(d1,0,sizeof(d1));
    memset(need,0,sizeof(need));
    memset(sheng,0,sizeof(sheng));
    memset(l,0,sizeof(l));
    memset(r,0,sizeof(r));
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>sheng[i];
    }
    for(int i=1;i<=m;i++)
    {
        cin>>d1[i]>>l[i]>>r[i];
    }
    if(panduan(m))
    {
        cout<<"0"<<endl;
        return 0;
    }
    else
    {
        int L=1,R=m;
        while(L<R)
        {
            int middle=(L+R)/2;
            if(panduan(middle))
            {
                L=middle+1;
            }
            else
            {
                R=middle;
            }
        }
        cout<<"-1"<<endl<<L<<endl;
    }
    return 0;
}