NOIP模拟题 2016.11.8 [数学归纳法] [贪心] [二分答案] [Bash模拟]

最新推荐文章于 2022-10-09 21:16:26 发布
最新推荐文章于 2022-10-09 21:16:26 发布
阅读量595 收藏 1
点赞数 1
分类专栏： 数学 贪心 二分答案 Bash模拟 文章标签： 数学 贪心 二分答案 Bash模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ourfutr2330/article/details/53082043
版权
贪心 同时被 3 个专栏收录
22 篇文章 0 订阅
订阅专栏
二分答案
7 篇文章 0 订阅
订阅专栏
数学
3 篇文章 0 订阅
订阅专栏

T1：
题意：有n个字符串，每个字符串可以通过无限次翻转区间[1,m]中的字符，但是要保证m为偶数。

通过简单的变换可以把整个字符串左移2位，那么由数学归纳法可以得到左移K位都是可以做到的，只要保证K是偶数。
把相邻的两个奇数位和偶数位看成一个单位，再次变换可以发现交换任意两个相邻单位都是合法的，那么可以推出任意两个单位之间的交换都是合法的。
由于一个单位里的两个字符是可以互换位置的，这样每一个字符串都有一个可以确定的最小字典序表示方法，规定每个单位组成的二元组的大小为以第一个字符为第一关键字，第二个字符为第二关键字来比较大小。
这样随便用个什么东西统计一下就好了，这里数据范围给得很宽裕，就map来处理即可。
最后答案是Sigma(cnt[i]%2).

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
const int INF=0x3f3f3f3f;
const int maxn = 55;
string s;
int n;
map <string,int> mp;
inline void init()
{
    mp.clear();
    read(n);
    for(int k=1;k<=n;k++)
    {
        cin>>s;
        int lens = s.size();
        for(int i=0;(i|1)<lens;i+=2) if(s[i]>s[i|1]) swap(s[i],s[i|1]);
        for(int i=0;(i|1)<lens;i+=2)
            for(int j=0;(j|1)<lens-(i+2);j+=2)
                if(s.substr(j,2)>s.substr(j+2,2))
                    swap(s[j],s[j+2]),swap(s[j|1],s[(j|1)+2]);
        if(mp.count(s)) mp[s]++;
        else mp[s]=1;
    }
}
int work()
{
    int ans = 0;
    for(map <string,int> ::iterator it = mp.begin(); it!=mp.end(); it++)
        ans += it->second % 2;
    return ans;
}
int main()
{
    freopen("kahuucino.in","r",stdin);
    freopen("kahuucino.out","w",stdout);
    int T;
    read(T);
    while(T--)
    {
        init();
        int ans = work();
        printf("%d",ans);
        putchar('\n');
    }
    return 0;
}

T2:
题意：每个油库里都有两个值，战斗力和能量值，规定战斗力大的可以吃掉战斗力小的，吃掉之后新的战斗力为 原战斗力+吃掉的能量值-吃掉的战斗力，求最大能得到的 战斗力+能量值。

规定战斗力小于能量值的为good，其他的为bad，那么对于确定的一个油库里，只有good类别的油库里是有用的，bad一定不吃，吃了浪费战斗力。。
显然应当首先吃战斗力小的，因为吃了小的之后战斗力会增加，更有利于吃战斗力大的good。
那么可以枚举油库里，但是这样是O(n^2)的算法，要GG。
由于是按照战斗力从小到大的顺序去吃good，在某一时刻可能不足以吃掉后面的油库里，所以应当维护一个当前需要的最大战斗力值。
sum[i] = Sigma(Y[i] - X[i])
MAX[i] = max(MAX[i-1] , X[i] - sum[i-1])
前i-1个实际上是给吃第i个提供能量的，所以在这里减去sum[i-1]，为了保证二分的确定性。
所以枚举每一个bad中的油库里和good中战斗力最高的油库里，二分确定最大的能够吃掉的油库里即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
const LL INF = (1LL<<60);
const int maxn = 100005;
struct Node
{
    LL x,y;
    Node() {}
    Node (const LL &_x,const LL &_y) { x=_x; y=_y; }
    bool operator < (const Node &t) const
    {
        if(x ^ t.x) return x < t.x;
        return y < t.y;
    }
}good[maxn],bad[maxn];
int goodn,badn;
int n;
LL sum[maxn],MAX[maxn]; // formed as prefix
inline void init()
{
    read(n);
    for(int i=1;i<=n;i++)
    {
        LL x,y;
        read(x); read(y);
        if(x < y) good[++goodn] = Node(x,y);
        else bad[++badn] = Node(x,y);
    }
    sort(good+1,good+goodn+1);
    MAX[0]=0; sum[0]=0;
    for(int i=1;i<=goodn;i++)
    {
        sum[i] = sum[i-1] + good[i].y - good[i].x;
        MAX[i] = max(MAX[i-1],good[i].x - sum[i-1]);
    }
}
inline int search(int L,int R,LL x)
{
    while(L < R)
    {
        int mid = (L+R+1)>>1;
        if(MAX[mid] < x) L = mid;
        else R = mid - 1;
    }
    return L;
}
LL work()
{
    LL ans = 0;
    smax(ans,sum[search(0,goodn-1,good[goodn].x)]+good[goodn].x+good[goodn].y);
    for(int i=1;i<=badn;i++)
    {
        int pos = search(0,goodn,bad[i].x);
        smax(ans,sum[pos]+bad[i].x+bad[i].y);
    }
    return ans;
}
int main()
{
    freopen("zyougamaya.in","r",stdin);
    freopen("zyougamaya.out","w",stdout);
    init();
    LL ans = work();
    printf(AUTO,ans);
    return 0;
}

T3:
题意：实现一个Bash模拟器，支持文件和文件夹创建删除操作，并且可以查看当前目录内容。

这个直接搞。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
const int INF=0x3f3f3f3f;
const int maxn = 120;
struct Node
{
    int fa;
    string s;
    int val; // 1 for D , 2 for F
    bool disabled;
}node[maxn];
#define fa(x) node[x].fa
#define s(x) node[x].s
#define val(x) node[x].val
#define disabled(x) node[x].disabled
struct Edge
{
    int to,next;
}edge[maxn];
int head[maxn];
int maxnode,maxedge;
inline void addedge(int u,int v)
{
    edge[++maxedge] = (Edge) { v,head[u] };
    head[u] = maxedge;
}
int root;
void initialize()
{
    root = maxnode = 1;
    memset(head,-1,sizeof(head)); maxedge=-1;
}
void go_back()
{
    if(!fa(root)) puts("No parent directory!");
    else root = fa(root);
}
void go_forward(const string &to)
{
    for(int i=head[root];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(disabled(v) || val(v)!=1) continue;
        if(s(v) == to)
        {
            root = v;
            return;
        }
    }
    puts("No such directory!");
}
void touch(const string &to)
{
    for(int i=head[root];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(disabled(v) || val(v)!=2) continue;
        if(s(v) == to)
        {
            puts("File already exists!");
            return;
        }
    }
    ++maxnode;
    fa(maxnode) = root;
    val(maxnode) = 2; // File
    s(maxnode) = to;
    addedge(root,maxnode);
}
void rm(const string &to)
{
    for(int i=head[root];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(disabled(v) || val(v)!=2) continue;
        if(s(v) == to)
        {
            disabled(v) = true;
            return;
        }
    }
    puts("No such file!");
}
void mkdir(const string &to)
{
    for(int i=head[root];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(disabled(v) || val(v)!=1) continue;
        if(s(v) == to)
        {
            puts("Directory already exists!");
            return;
        }
    }
    ++maxnode;
    fa(maxnode) = root;
    val(maxnode) = 1; // Directory
    s(maxnode) = to;
    addedge(root,maxnode);
}
void rmdir(const string &to)
{
    for(int i=head[root];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(disabled(v) || val(v)!=1) continue;
        if(s(v) == to)
        {
            disabled(v) = true;
            return;
        }
    }
    puts("No such directory!");
}
stack <int> sta;
void ls()
{
    for(int i=head[root];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(disabled(v)) continue;
        sta.push(v);
    }
    while(!sta.empty())
    {
        int u = sta.top(); sta.pop();
        cout<<s(u);
        printf(" <%c>\n",val(u)==1?'D':'F');
    }
}
int main()
{
    freopen("nacumegu.in","r",stdin);
    freopen("nacumegu.out","w",stdout);
    initialize();
    int Q;
    read(Q);
    while(Q--)
    {
        string cmd,s;
        cin>>cmd;
        if(cmd!="ls") cin>>s;
        if(cmd=="cd")
            if(s=="..") go_back();
            else go_forward(s);
        else if(cmd[0]=='t') touch(s);
        else if(cmd[0]=='m') mkdir(s);
        else if(cmd=="ls") ls();
        else if(cmd=="rm") rm(s);
        else rmdir(s);
    }
}
JacquesdeH
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NOIP初赛模拟题.pdf
08-07
NOIP初赛模拟题.pdf
【用法详解】C++--STL之map的用法详解与学习心得
荷叶田田
01-27 1636
STL之map的用法详解与学习心得map是一种二叉树的数据存储结构。map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的（map中的元素是自动按Key升序排序的）map的特点:  1、存储Key-value对                          2、支持快速查找，查找的复杂度基本是Log(N)         ...
C++ map的常用用法（超详细）(*^ｰ^)人(^ｰ^*)
Curz酥的博客
03-02 3万+
map常用操作详细讲解
C++中的map用法详解
gaoqiandr的博客
10-09 3万+
对于C++中的map容器的用法详解，简单易懂，非常适合小白同学
贪心算法的数学证明 (更新中)
kyle的博客
06-10 3596
贪心算法的数学证明
贪心算法
Modestr的博客
09-29 589
Foreward： Greed is human nature, curiosity is human motivation. 贪婪是人类的本性，求知是人类的动力。 今天要介绍的算法是贪心算法（Greedy），又名贪婪算法 前面部分会比较基础易懂，后面有些部分会稍稍硬核 所以 What’s the greedy algorithm? Definition: A greedy algorithm is a simple, intuitive algorithm that is used in optimi
冲刺NOIP模拟试题三.pdf
10-01
冲刺NOIP模拟试题三.pdf
【精选资料】NOIP初赛模拟试题.pdf
03-18
全国信息学奥林匹克联赛,计算机编程，论文，历届，信息技术比赛，参考资料，极具学习价值
冲刺NOIP2011模拟试题（二）.pdf
08-11
冲刺NOIP2011模拟试题（二）.pdf
NOIP初赛模拟题2.pdf
最新发布
03-18
全国信息学奥林匹克联赛,计算机编程，论文，历届，信息技术比赛，参考资料，极具学习价值
算法设计与分析（4）——贪心法
xiaobai_qian的博客
06-03 3929
北京大学 屈婉玲老师的MOOC视频：算法设计与分析。 这个课程不仅适用于 算法设计与分析 的学习，也非常适用于 数学建模 的学习，如果是学习 数学建模的基础部分，前两周的内容是非常适合的，如果要进一步学习 建模思想，建议把这十周视频好好看一遍。( •̀ ω •́ )y
贪心算法总结——读书笔记
TommyZht的专栏
06-16 3333
1、基本概念 贪心算法是一种求解组合优化问题的算法设计技术，其求解过程由一系列决策构成，每一步决策仅依赖于某种局部优化的性质。 与动态规划算法不同，贪心算法在做决策时候不必考虑所有子问题的选择结果。
java并查集/最小生成树-kruskal算法_搞定面试算法系列 | 贪心算法与正确性归纳证明
weixin_39819661的博客
11-23 241
主要思想贪心算法就是让计算机模拟一个「贪心的人」来做出决策。这个贪心的人是目光短浅的，他每次总是：只做出当前看来最好的选择只看眼前的利益，而不考虑做出选择后对未来造成的影响并且他一旦做出了选择，就没有办法反悔（不可回溯），所以为了利益最大化，他需要保证绝不能做出错误的选择。贪心算法不是从整体最优的角度上考虑问题，而是只在意某种意义上的局部最优解。因此，贪心算法并不能保证在所有情况下都能获得最优解。...
贪心算法的证明（贪心策略是安全的）
fan2273的博客
06-21 1万+
由于最近考算法，经常会遇到要求证明贪心算法中，贪心策略及贪心选择是正确的。 由于这块涉及到胚和拟阵的问题，书上仅在贪心算法章节的描述过于抽象，以至于我真的是头大了很久才算弄懂。 这里不过多复述贪心算法和动态规划的区别，以及具体的应用条件、性质，仅描述如何理解“贪心选择是安全”，即证明贪心算法的正确性。 这里使用的教材是《算法导论》第二版 用课本的“活动选择问题”来阐述如何理解贪心算法证明与
算法-贪心法
10-08 2997
贪心法是把一个复杂问题分解为一系列较为简单的局部最优选择，每一步选择都是对当前解的一个扩展，直到获得问题的完整解。贪心法的典型应用是求解最优化问题，而且对许多问题都能得到整体最优解，即使不能得到整体最优解，通常也是最优解的很好近似。 概述 贪心法的设计思路 贪心法目光短浅，并不是从整体最优考虑，它所做出的选择只是在某种意义上的局部最优，这种局部最优选择并不总能获得整体最优解，但通常能获得近似最优解。 用贪心法求解的问题一般有两个最重要的性质：最优子结构性质和贪心选择性质。 1）最优子结构性质：当一个问题的最
贪心算法学习笔记
qq_43157227的博客
09-23 212
贪心算法算法学习，贪心算法的定义以及例子，动态规划与贪心算法区别
从零开始学贪心算法
热门推荐
houjingyi的博客
05-08 30万+
本文在写作过程中参考了大量资料，不能一一列举，还请见谅。 贪心算法的定义： 贪心算法是指在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，只做出在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。 解题的一般步骤是： 1.建立数学模
noip历年真题题解.pdf
09-28
《NOIP历年真题题解.pdf》是一本关于NOIP（全国青少年信息学奥林匹克竞赛）历年真题的解析书籍。这本书的目的是帮助学生更好地理解和掌握NOIP竞赛中的题目，并提供对解题思路的详细解释和讲解。 这本书一般会包含多个年份的NOIP真题，并针对每道题目提供详细的分析和解答过程。通过阅读这本书，学生可以了解到不同年份的试题在类型和难度上的变化，有助于他们对竞赛题目的理解和应对能力的提高。 《NOIP历年真题题解.pdf》通常会按照题目的类型或者年份进行组织和分类。比如，可以将编程题、算法题、数据结构题等进行分组，有助于学生对不同类型题目的习题训练和技巧掌握。 这本书的编写一般由经验丰富的NOIP竞赛选手或者教育机构的教师共同完成。他们会根据自己的经验和理解，结合真题的特点和考察点，给出详细的题目解析。解析中包括对算法思路的讲解、代码实现的示范、以及对常见错误和易错点的指导。 总之，如果你对NOIP竞赛感兴趣，想提高自己的编程和算法能力，阅读《NOIP历年真题题解.pdf》是一个不错的选择。通过学习和掌握这些真题的解析，你可以更好地应对竞赛中的各种类型题目，并提升自己的竞赛水平。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值