NIOP 膜你题

时间  2019-11-07
标签 niop 繁體版
原文   原文链接

NOIp膜你题   Day1html

duliu 出题人：ZAY   ios

1.大美江湖
(mzq.cpp/c)c++

【题目背景】函数

细雪飘落长街，枫叶红透又一年
不仅为故友流连，其实我也恋长安
听门外足音慢，依稀见旧时容颜
故事几经悲欢，结局都与你有关
——银临《大美江湖》优化


【问题描述】spa

扶苏听着《大美江湖》，在剑三里控制着他的人物炮姐来到了长安。
长安城中有一个任务，须要扶苏进入地下的机关道，机关道是一个n×m 的矩形地
图，里面有一些怪物和药水。扶苏操控着炮姐在机关道中游荡。有些时候他但愿问问你
他的角色有多少攻击力、防护力以及丢失了多少血量。
具体的，在输入文件中会给出一个n×m 的矩形地图，地图中第i 行第j 列的字符
Ci,j 表明机关道中第 i 行第 j 列的元素是什么。具体的，Ci,j € { ‘ . ’ ,  ‘R’ , ‘Q’ , ‘Y’ , ‘M’ }。
其中，
一、字符 . 表明此处能够经过，且无其余元素
二、字符  R 表明此处为生命药水，能够减小炮姐10 点丢失的血量HP
三、字符  Q 表明此处为力量药水，能够增长炮姐5 点攻击力ST
四、字符  Y 表明此处为防护药水，能够增长炮姐5 点防护力DE
五、字符  M 表明此处为怪物，炮姐会损失相应血量code


每只怪物都有三个参数来描述他们的属性，分别是血量HPenemy，攻击力STenemy，防
御力DEenemy。且全部怪物的属性都相同。
一旦走到怪物格，遭遇战将开始。扶苏必定会打死怪物，怪物对炮姐形成的伤害为htm

其中 max(a,b) 表明取a和b的最大值；的值为不小于x的最小整数；下标为blog

enemy 的参数表明怪物的参数，下标为my 的参数表明炮姐的参数
你会收到q 次操做，每次操做要么是一次查询，要么是一次移动。
对于移动，你会再得到一个数字参数，这个参数只多是1/2/3/4 其中的一个，表明
炮姐向地图的左/右/上/下移动。排序

 

【输入格式】
  输入文件名为mzq.in。
  输入文件中有且仅有一组数据，第一行为两个正整数n 和m,表明地图的大小
  下面n 行，每行m 个字符，描述机关道的地图
  下面一行有三个正整数，分别表明HPenemy，STenemy，DEenemy
  下面一行有两个整数x, y，表明炮姐初始在第x 行第y 列出发。若是出发点有怪物，不发生战斗，若是有道具，不会将其捡拾。

  下面一行给出两个正整数，表明炮姐初始的ST 和DE。
  下面一行给出一个整数q，表明操做个数
  如下q行，每行首先有一个数字，若是是 1，则表明一次查询。不然数字必定是 2，
  表明炮姐的一次移动，一个空格后会给出一个数字，做为移动的参数。


【输出格式】
  输出文件名为mzq.out。
  对于每一个查询，输出一行三个用空格隔开的整数，表明炮姐损失的血量HP，当前的攻击力ST，以及当前的防护力DE

 

 

【题解】

这道题就是一道大模拟  那你为何拿不了满分

可是你不能轻敌   出题人过于强大我能怎么办

 

 注意：
1.下标是从 line1 lie1开始的，也就是你读入的时候要注意

2.在你捡拾药水的时候，若是人物损失的生命值低于10，就会降至0

   捡药水，我怎么知道捡哪一个药水 可是你的小伙伴们都知道

   这个固然是在捡生命药水的时候啦  我考试的时候认为是建捡个药水都要这样

3.要动态维护那个小怪兽的伤害值，计算的时候注意最好不要直接用STL里面的 ceil（上取整函数），手写一个就行了

   至于为啥不要直接调用ceil  点这里吧

 

【代码】

这个重测了一遍  A啦  

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
#include<bits/stdc++.h>

using namespace std;

int n,m;
char ju[101][101];
int hpm,stm,dem;
int sx,sy;
int hpp=0,stp,dep;
int q,flag,mp,xie;

int sun()
{
    int a=max(1,stm-dep);
    int b=max(1,stp-dem);
    int p=hpm/b;
    if(hpm%b) p++;
    int k=p*a;
    return max(1,k);
}

int main()
{
    freopen("mzq.in","r",stdin);
    freopen("mzq.out","w",stdout);

    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
      scanf("%s",ju[i]+1);

    scanf("%d%d%d",&hpm,&stm,&dem);
    scanf("%d%d",&sx,&sy);
    scanf("%d%d",&stp,&dep);
    scanf("%d",&q);
    
    for(int i=1;i<=q;i++)
    {
        scanf("%d",&flag);
        if(flag==1) printf("%d %d %d\n",hpp,stp,dep);
        else 
        {
            scanf("%d",&mp);
            if(mp==1) sy--;
            if(mp==2) sy++;
            if(mp==3) sx--;
            if(mp==4) sx++;
            
            if(ju[sx][sy]=='R')
            {
                if(hpp<10) hpp=0;
                else hpp-=10;
            }
            if(ju[sx][sy]=='Q') stp+=5;
            if(ju[sx][sy]=='Y') dep+=5;
            if(ju[sx][sy]=='M') 
            {
                xie=sun();
                hpp+=xie;
            }
        }
        
    }
    
    
    return 0;
}

 

 

PS:洛谷

P5006 空间复杂度

 请不要像我同样傻fufu的直接把这个题代码交上去

看题！！

 

 

 

2.腐草为萤
(dzy.cpp/c)

【题目背景】

纤弱的淤泥中妖冶
颓废在季夏第三月
最幼嫩的新叶连凋零都不屑
何须生离死别
——银临《腐草为萤》

【问题描述】

扶苏给了你一棵树，这棵树上长满了幼嫩的新叶，咱们约定这棵树的根是1，每一个节
点都表明树上的一个叶子。
若是你不知道什么叫树，你能够认为树是一个边数比节点个数少1 的无向连通图。
咱们若是约定节点u 是树T 的根，则能够定义一个节点v 到根的路径为该无向图上u, v
两个节点之间的简单路径上的节点集合(包括路径的两个端点)。能够证实，这样的简单路
径只有一条。
咱们定义节点x 是节点y 的祖先(x ≠ y)，当且仅当x 在y 到根的路径上。

如今扶苏想在这棵树上选定一个集合，将其称之为幼嫩集合，来比较集合中的节点
哪一个最幼嫩。注意到一旦集合中存在两个节点u, v，使得u 是v 的祖先，那么必定v 要比
u 更幼嫩，由于v 是在u 的枝丫上生长出来的，那么这样的集合就是没有意义的。也就是
说，扶苏所选择的集合必定知足要求“对于任意集合中的元素对(u, v)，u 不是v 的祖先”。

扶苏其实对这些节点哪一个最幼嫩并不感兴趣，也对他能选出多少集合不感兴趣，因
为这些都是为了问你下面的问题而创造出的题目背景。
扶苏给每一个节点都定义了一个权值，具体的，咱们会给出一个参数T，规定 i 号节点
的权值为 iT。
咱们定义一个幼嫩集合幼嫩指数为集合内节点的权值和。如今扶苏想请问你，对于
他全部可能选出的集合，这些集合的幼嫩指数之和是多少。
为了不答案过大，请你输出答案对 109 + 7取模的结果。

【输入格式】
输入文件名为dzy.in。
输入文件中有且仅有一组数据，第一行为两个正整数n 和T,节点个数和权值参数。
下面n-1 行，每行有两个正整数u, v，表明树上有一条边链接节点u 和节点v。


【输出格式】
输出文件名为dzy.out。
输出一行一个正整数，表明答案对 109 +7取模的结果。

【样例1 解释】
一共有10 个集合，分别为
 {1}  ,  {2}  ,  {3}  ,  {4}  ,  {5}  ,  {2,5}  ,  {3,4}  ,   {3,5}  ,  {3,4,5}  ,  {4,5}
因为T=0，全部节点的权值都为1，因此幼嫩指数之和即为集合元素个数和，
共16个。

 

 

 

【题解】

1.爆搜，枚举全部可能的集合，而后计算答案。
   因为每一个点只有选进集合或不选两种可能，因此一共有2n 个集合，而后能够O(n) 的去检验集合是否合法，顺便统计答案。因而总复杂度O(2n×n)。

 2.DP

设  fu 是以  u 为根的子树的答案。

（1）若是 u 没有孩子，那么 fu = uT

（2）若是 u 只有一个孩子 v，那么要么选 u 不选 u 的子孙，要么不选 u。

         不选u的答案即为 fv，选 u 的答案即为uT。两种状况加起来就是 fu。

（3）若是 u 有两个孩子 x  ,  y 。考虑要么选  u，要么只选  x 的子树内的元素，要么只选  y 的子树内的元素，要么既选 x 内的元素又选 y 内的元素但不选 u。
         前三种状况的答案易得。如今考虑第四种状况的答案。

         设s 是x 子树内的某个集合。考虑不管  y 的子树内怎么选，再加上 s 都是合法的，由于 y 和  x 之间没有祖前后代关系且 s 在 x 以内。

        设 gu 是以 u 为根能选择的集合个数，那么一共有 gy 个集合选择s 之后依旧合法
        设  s 的权值和为 ws，因而 s 的贡献即为 ws×gy。因为fx 为x 子树内全部可能集合的权值和，因此能够发现

        因而 x 子树内的集合对答案的总贡献是 fx×gy。
        同理，y 子树内的集合对答案的贡献是fy×gx。


        因而  fu = fy × gx + fx × gy + fx + fy + uT。 gu = gx × gy + gx + gy + 1。时间复杂度O(n)

 

        Ps：咱们说说这个gu是怎么来的：

               对于任意的不一样子树，交叉合并一下总会出现新的符合要求的集合

               gu=( fx+1 )( fy+1 ) .... ( fn+1 )      //（）里边表示选该集合或者不选

               化简一下就是上面的啦

 

        考虑在遍历子节点的时候，已经遍历了一些子节点，如今新加入了一个子节点。
        因为新加入一个子节点与以前遍历的子节点没有祖前后代关系，因而能够以前遍历过得子树当作一棵子树，而后问题就又变成了上面所说。

        须要注意的是因为读入规模达到了106左右，须要普通的读入优化。

 

【代码】

#include <cstdio>

typedef long long int ll;

const int maxn = 1000005;
const int MOD = 1000000007;

template <typename T>
inline void qr(T &x) {
  char ch;
  do { ch = getchar(); } while ((ch > '9') || (ch < '0'));
  do { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar(); } while ((ch >= '0') && (ch <= '9'));
}

int n, T;
int MU[maxn], frog[maxn], gorf[maxn];
bool vis[maxn];

struct Edge {
  int v;
  Edge *nxt;

  Edge(const int _v, Edge *h) : v(_v), nxt(h) {}
};
Edge *hd[maxn];

void dfs(const int u);

int main() {
  freopen("dzy.in", "r", stdin);
  freopen("dzy.out", "w", stdout);
  qr(n); qr(T);
  if (T) {
    for (int i = 1; i <= n; ++i) {
      MU[i] = i;
    }
  } else {
    for (int i = 1; i <= n; ++i) {
      MU[i] = 1;
    }
  }
  for (int i = 1, u, v; i < n; ++i) {
    u = v = 0; qr(u); qr(v);
    hd[u] = new Edge(v, hd[u]);
    hd[v] = new Edge(u, hd[v]);
  }
  dfs(1);
  printf("%d\n", frog[1] % MOD);
  return 0;
}

void dfs(const int u) {
  vis[u] = true;
  for (auto e = hd[u]; e; e = e->nxt) if (!vis[e->v]) {
    int v = e->v;
    dfs(v);
    frog[u] = (frog[u] * (gorf[v] + 1ll) % MOD) + (frog[v] * (gorf[u] + 1ll) % MOD);
    gorf[u] = (gorf[u] + gorf[v] + (1ll * gorf[u] * gorf[v])) % MOD;
  }
  frog[u] = (frog[u] + MU[u]) % MOD;
  ++gorf[u];
}

 

 

 

 

3.锦鲤抄
(zay.cpp/c)

【题目背景】
你在尘世中展转了千百年
却只让我看你最后一眼
火光描摹容颜燃尽了时间
别留我一人，形单影只
凋零在梦境里面。
——银临&云の泣《锦鲤抄》

 

【问题描述】

这首歌的文案讲述了这样一个故事：
在一个兵荒马乱的年代，有一位画师叫浅溪，很是喜欢画锦鲤。战火烧到了泰
安，他的邻居都惊慌逃命，只有他不舍得池中锦鲤没有离开。这天晚上庭院失火，
池中的锦鲤化妖，用生命护住了画师的平安。
注意：因为本题题面涉及到文案故事，在下方提供了便于理解的另外一题面版本。
扶苏被画师和锦鲤的故事深深地打动了。为了能让锦鲤和画师继续生活在一块儿，他
决定回到着火的庭院中灭掉大火。
画师的庭院能够抽象成一个有向图，每一个点表明着一个着火的位置。为了量化火势
的大小，扶苏给每一个点一个火力值，火力值越大，表明这个点的火势越强。风助火势，
火借风力，对于每个着火点，都有可能由于大风使得火扩散到其余点。有向图的每条
边<u,v> 表明大火是从点u 扩散到点v 的。须要注意的是一个点可能会扩散到不少
点，也多是由不少点的大火一块儿扩散成的。为了避免由于灭掉火源让画师发现有人在帮
他灭火，在任意时刻，扶苏不能灭掉任何一个不被任何点所扩散的点的火。一个点的火
被灭掉后，所表明该点的火扩散的全部边将消失。须要说明的是，虽然边消失了，可是
该点扩散到的全部点属性除入度之外都不会改变，更不会消失。
由于穿越的时间有限，扶苏只能灭掉最多k 个点的火。忙着写题面的扶苏没有时间
算出他最多能扑灭多少火力值，因而他把这个问题交给了你。

 

说人话：
      给你一张有向图，每一个点有一个点权。你能够任意选择一个有入度的点，得到它的点权并把它和它的出边从图上删去。任意时刻不能选择没有入度的点。最多能选择k 个点，求最多能得到多少点权。

 

【输入格式】
      输入文件名为zay.in。
      输入文件中有且仅有一组数据，第一行为三个正整数n,m,k，表明有向图的点数、边数以及最多选择的点数。
      第二行有n 个整数，第i 个整数表明节点i 的火力值(点权)
      下面m 行，每行两个正整数u,v，表明大火是从u 扩散到v 的，即有向图的边。

 

【输出格式】
      输出文件名为zay.out。
      输出一行一个正整数，表明答案。

 

 

 【题解】

子任务3：
      给出的是一个DAG 。

      考虑对于一个DAG 来讲，一个良好的的性质就是在拓扑序后面的点不管如何变化都没法影响到前面的点。这个题也同样。对于任意一个不出现原图中自己入度为0 的点的序列，只要按照拓扑序选点，就必定能取遍序列中全部的点。

     因而发现这张图上入度不为0的点事实上均可以被选择。因而咱们把全部入度不为0的点排一下序，求前k个就能够了。

     时间复杂度O(nlogn)

 

子任务四、5：
     考虑DAG的状况放到普通有向图上会发生什么。
     有了子任务3 的提示，咱们能够考虑把整个图缩点，将其变成一个DAG来作。

    QUS：何为缩点？就是把一个环缩成一个点，由于环里的点均可以相互到达

     对于一个DAG，显然能够经过子任务3 调整顺序的方式使得每一个强连通份量的选择状况除选点个数之外互不影响。故下面只讨论一个强连通份量内部的状况。

     一个强连通份量显然能够看做是一棵外向树加上不少边获得的。


     一棵外向树的定义：一个外向树的任意一个节点要么为叶节点，要么它与孩子间的全部边都是由它指向孩子。

     一棵外向树显然是一个DAG 。

     按照以前对DAG 上状况的说明，显然咱们能够选择除了根节点之外的任意节点。

     由于一个强连通份量内部是互相连通的，因而咱们不妨钦定一个点为根。
     对于一个没有入度的强连通份量，咱们不妨钦定点权最小的点为根。这样显然选择的是最优的。
     对于一个有入度的强连通份量，咱们不妨钦定那个有入度的点为根。这样在选择到只剩根节点的时候，由于根节点有入度，因此根节点是能够被选择的。因而这个强连通份量能够被所有选择。这显然是最优的。


     这样综合上述讨论，有入度的强连通份量能够随便选，没有入度的强连通份量去掉最小的点权的点。剩下贪心取前k 个就能够了。

      进行一次tarjan的复杂度是O(n+m)，选前k 个点能够排序一下。这样总复杂度O(m+nlogn)  
      注意到复杂度瓶颈在排序上，考虑咱们只须要前k 大而不须要具体前k 个之间的大小关系，因而使用std::nth_element()函数能够将复杂度降至O(n+m)。

      注意，输入规模到了107 级别，须要fread 来实现读入优化。

【代码】

#include <cstdio>
#include <algorithm>
#include <functional>
#ifdef ONLINE_JUDGE
#define freopen(a, b, c)
#endif

typedef long long int ll;

namespace IPT {
  const int L = 1000000;
  char buf[L], *front=buf, *end=buf;
  char GetChar() {
    if (front == end) {
      end = buf + fread(front = buf, 1, L, stdin);
      if (front == end) return -1;
    }
    return *(front++);
  }
}

template <typename T>
inline void qr(T &x) {
  char ch = IPT::GetChar(), lst = ' ';
  while ((ch > '9') || (ch < '0')) lst = ch, ch=IPT::GetChar();
  while ((ch >= '0') && (ch <= '9')) x = (x << 1) + (x << 3) + (ch ^ 48), ch = IPT::GetChar();
  if (lst == '-') x = -x;
}

const int maxn = 1000006;

struct Edge {
  int v;
  Edge *nxt;

  Edge(const int _v, Edge *h) : v(_v), nxt(h) {}
};
Edge *hd[maxn];

int n, m, k, vistime, top, scnt;
int MU[maxn], dfn[maxn], low[maxn], stack[maxn], belong[maxn], minv[maxn];
bool instack[maxn], haveind[maxn];

void tarjan(const int u);

int main() {
  freopen("zay.in", "r", stdin);
  freopen("zay.out", "w", stdout);
  qr(n); qr(m); qr(k); MU[0] = 2333;
  for (int i = 1; i <= n; ++i) qr(MU[i]);
  for (int i = 1, u, v; i <= m; ++i) {
    u = v = 0; qr(u); qr(v);
    hd[u] = new Edge(v, hd[u]);
  }
  for (int i = 1; i <= n; ++i) if (!dfn[i]) {
    tarjan(i);
  }
  for (int u = 1; u <= n; ++u) {
    for (auto e = hd[u]; e; e = e->nxt) if (belong[u] != belong[e->v]) {
      haveind[belong[e->v]] = true;
    }
  }
  for (int i = 1; i <= scnt; ++i) if (!haveind[i]) {
    MU[minv[i]] = 0;
  }
  std::nth_element(MU + 1, MU + 1 + k, MU + 1 + n, std::greater<int>());
  int ans = 0;
  for (int i = 1; i <= k; ++i) {
    ans += MU[i];
  }
  printf("%d\n", ans);
  return 0;
}

void tarjan(const int u) {
  dfn[u] = low[u] = ++vistime;
  instack[stack[++top] = u] = true;
  for (auto e = hd[u]; e; e = e->nxt) {
    int v = e->v;
    if (!dfn[v]) {
      tarjan(v);
      low[u] = std::min(low[u], low[v]);
    } else if (instack[v]) {
      low[u] = std::min(low[u], dfn[v]);
    }
  }
  if (dfn[u] == low[u]) {
    int v, &_mv = minv[++scnt];
    do {
      instack[v = stack[top--]] = false;
      belong[v] = scnt;
      if (MU[v] < MU[_mv]) _mv = v;
    } while (v != u);
  }
}

 

 

 

 

【扩充知识】

1.读入数据时应该用什么？想用什么用什么

    固然要参考一下数据范围：
（1）1e4   cin

（2）1e5   scanf

（3）1e6   getchar

（4）1e7   fread

（5）1e8及以上    请把出题人从窗户里扔出去

 

 2.何为暴力？

     前辈云：暴力出奇迹，打表拿省一。

    暴力分为两类：

（1）模拟：题目要求你干什么，你就干什么

（2）搜：DFS啊BFS 啊能搜就搜出来

 

3.何为fread？

   一个板子

 

4.何为tarjan？

  也是一个板子

  超赞（我还没看完）

 

5.给泥萌看个树：

    

 

 

 

 THE END

   好难鸭

   但这仅仅是DAY1

   深深地感觉到了NOIp对个人敌意

   

   WelcomeToNOIp2019!!!!!

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程