【6.20校内test】

时间 2019-11-29

标签 6.20校内test 繁體版

原文原文链接

反正考的不是很好吧，赶脚炸了啊qwqhtml

而后这两天一直在忙一些神奇的事情，因此没有整理完node

手动@water_liftios

T1：大美江湖：c++

【题目背景】ide

细雪飘落长街，枫叶红透又一年函数

不仅为故友流连，其实我也恋长安优化

听门外足音慢，依稀见旧时容颜this

故事几经悲欢，结局都与你有关spa

——银临《大美江湖》【问题描述】code

扶苏听着《大美江湖》，在剑三里控制着他的人物炮姐来到了长安。

长安城中有一个任务，须要扶苏进入地下的机关道，机关道是一个 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 表明此处为怪物，炮姐会损失相应血量

每只怪物都有三个参数来描述他们的属性，分别是血量 HP_enemy，攻击力 ST_enemy，防御力 DE_enemy。且全部怪物的属性都相同。

一旦走到怪物格，遭遇战将开始。扶苏必定会打死怪物，怪物对炮姐形成的伤害为：

（忍不住说这个数据有点水，我看错括号代码锅掉了竟然还A了qwq）

其中 max(a,b) 表明取 a 和 b 的最大值；的值为不小于 x 的最小整数；下标为 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】

5 5

MMMMM

RRRRR

QQQQQ

YYYYY

.....

5 5 5

5 1

10 10

2 3

2 2

【输出样例#1】

0 10 15

1 15 15

2 15 15

注意：若是屡次进入同一个格子，格子上的药水能够重复拾取，小怪会重复出现

注意：若是在拾取药水的时候人物损失的生命值低于10，则会将损失的生命值降至0

SOLUTION：

这道题其实只要直接模拟就好啦，而后注意到一些细节，注意动态维护伤害就好啦

而后其实本身的代码出锅了，因此各位大兄弟看看代码就好啦。

对了还有ceil不要随便用：点这里吧

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

using namespace std;

inline int read(){
    int ans=0;
    char last=' ',ch=getchar();
    while(ch<'0'||ch>'9') last=ch,ch=getchar();
    while(ch>='0'&&ch<='9') ans=ans*10+ch-'0',ch=getchar();
    if(last=='-') ans=-ans;
    return ans;
}

int n,m,hp,st,de,sh,x,y,stm,dem,q,cz,hps,yd;
int dx[5]={0,0,0,-1,1};
int dy[5]={0,-1,1,0,0};
char a[101][101];

int sx(){
    int f=max(1,stm-de);
    int g=hp/f;
    if(hp%f!=0) g++;
    int z=max(1,g);
    int a=max(1,st-dem);
    int y=z*a;
    return y;
}

//%%%zay 
 
int main(){
    freopen("mzq.in","r",stdin);
    freopen("mzq.out","w",stdout);
    n=read();m=read();
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++)
            a[i][j]=getchar();
        getchar();
    }
    hp=read();st=read();de=read();
    x=read();y=read();
    stm=read();dem=read();
    q=read();
    for(int i=1;i<=q;i++){
        cz=read();
        if(cz==1)
            cout<<hps<<" "<<stm<<" "<<dem<<endl;
        else {
            yd=read();
            x+=dx[yd];
            y+=dy[yd];
            if(a[x][y]=='M'){
                hps+=sx();
            }
            if(a[x][y]=='R'){
                if(hps<10) hps=0;
                else hps-=10;
            }
            if(a[x][y]=='Q'){
                stm+=5;
            }
            if(a[x][y]=='Y'){
                dem+=5;
            }
            if(a[x][y]=='.'){
                continue;
            }
        }
    }
    return 0;
}

出锅的 Code

#include <cmath>
#include <cstdio>
#include <algorithm>

const int maxn = 110;

char mp[maxn][maxn];

int n, m, px, py, q;

struct Character {
  int HP, ST, DE;
  int ehp, est, ede;

  void print() {
    printf("%d %d %d\n", this->HP, this->ST, this->DE);
  }

  void fight() {
    int x = int(ceil(1.0 * ehp / std::max(1, ST - ede)));
    this->HP += std::max(1, x * std::max(1, est - DE));
  }

  void update(const char x) {
    switch (x) {
      case 'R': {
        this->HP = std::max(0, this->HP - 10);
        break;
      }
      case 'Q': {
        this->ST += 5;
        break;
      }
      case 'Y': {
        this->DE += 5;
        break;
      }
      case 'M': {
        fight();
        break;
      }
    }
  }
};
Character my;

void mov(const int x);

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", mp[i] + 1);
  }
  scanf("%d%d%d", &my.ehp, &my.est, &my.ede);
  scanf("%d%d", &px, &py);
  scanf("%d%d", &my.ST, &my.DE);
  scanf("%d", &q);
  int x;
  while (q--) {
      
    scanf("%d", &x);
    if (x == 1) {
      my.print();
    } else {
      x = 0;
      scanf("%d", &x);
      mov(x);
    }
  }
  return 0;
}

void mov(const int x) {
  switch (x) {
    case 1: {
      --py;
      break;
    }
    case 2: {
      ++py;
      break;
    }
    case 3: {
      --px;
      break;
    }
    case 4: {
      ++px;
      break;
    }
    default: {
      puts("I AK IOI");
      break;
    }
  };
  my.update(mp[px][py]);
}

STD Code

而后T2：腐草为萤

【题目背景】

纤弱的淤泥中妖冶

颓废在季夏第三月

最幼嫩的新叶连凋零都不屑

何须生离死别

——银临《腐草为萤》

【问题描述】

扶苏给了你一棵树，这棵树上长满了幼嫩的新叶，咱们约定这棵树的根是 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 号节点的权值为 i ^T。

咱们定义一个幼嫩集合幼嫩指数为集合内节点的权值和。如今扶苏想请问你，对于他全部可能选出的集合，这些集合的幼嫩指数之和是多少。

为了不答案过大，请你输出答案对 10 7 9  取模的结果。

【输入格式】

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

【输出格式】

输出文件名为 dzy.out。输出一行一个正整数，表明答案对 10 7 9  取模的结果。

【输入样例】

5 0

1 2

2 3

2 4

1 5

【输出样例】

而后是SOLUTION：

子任务 1：

只有一个点，因此只有 {1} 这一种集合，因而答案为 1。

子任务二、3：

爆搜，枚举全部可能的集合，而后计算答案。（然鹅我菜到并不会爆搜qwq）

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

子任务四、5：

考虑 DP。设 f_u 是以 u 为根的子树的答案。

first.若是 u 没有孩子，那么 f_u = u^T。

second.若是 u 只有一个孩子 v，那么要么选 u 不选 u 的子孙，要么不选 u。不选 u 的答案即为 f_v，选 u 的答案即为 u ^T。两种状况加起来就是 f_u。

third.若是 u 有两个孩子 x,y。考虑要么选 u，要么只选 x 的子树内的元素，要么只选 y 的子树内的元素，要么既选 x 内的元素又选 y 内的元素但不选 u。前三种状况的答案易得。如今考虑第四种状况的答案。设 s 是 x 子树内的某个集合。考虑不管 y 的子树内怎么选，再加上 s 都是合法的，由于 y 和 x 之间没有祖前后代关系且 s 在 x 以内。设 g_u 是以 u 为根能选择的集合个数，那么一共有 g_y 个集合选择 s 之后依旧合法，设 s 的权值和为 w_s，因而 s 的贡献即为 w_s×g_y。因为 fx 为 x 子树内全部可能集合的权值和，因此能够发现 Σ ws= fx 。因而 x 子树内的集合对答案的总贡献是 fx×gy。同理，y 子树内的集合对答案的贡献是 fy×gy。因而 fu=fy×gx+fx×gy+fx+fy+u^T。gu=gx×gy+gx+gy+1。时间复杂度O(n)。

子任务六、7：

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

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

（因此其实难写的是代码）

#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];
}

偷偷放上std

而后关于读入优化：

1e4 cin
1e5 scanf
1e6 getchar（也就是日常写的快读）
1e7 fread
1e8及以上 emm，再见！

T3：锦鲤抄

【题目背景】

你在尘世中展转了千百年

却只让我看你最后一眼

火光描摹容颜燃尽了时间

别留我一人，形单影只

凋零在梦境里面。

——银临&云の泣《锦鲤抄》

【问题描述】

这首歌的文案讲述了这样一个故事：

在一个兵荒马乱的年代，有一位画师叫浅溪，很是喜欢画锦鲤。战火烧到了泰安，他的邻居都惊慌逃命，只有他不舍得池中锦鲤没有离开。这天晚上庭院失火，池中的锦鲤化妖，用生命护住了画师的平安。

注意：因为本题题面涉及到文案故事，在下方提供了便于理解的另外一题面版本。

扶苏被画师和锦鲤的故事深深地打动了。为了能让锦鲤和画师继续生活在一块儿，他决定回到着火的庭院中灭掉大火。

画师的庭院能够抽象成一个有向图，每一个点表明着一个着火的位置。为了量化火势的大小，扶苏给每一个点一个火力值，火力值越大，表明这个点的火势越强。风助火势，火借风力，对于每个着火点，都有可能由于大风使得火扩散到其余点。有向图的每条边 <u,v> 表明大火是从点 u 扩散到点 v 的。须要注意的是一个点可能会扩散到不少点，也多是由不少点的大火一块儿扩散成的。为了避免由于灭掉火源让画师发现有人在帮他灭火，在任意时刻，扶苏不能灭掉任何一个不被任何点所扩散的点的火。一个点的火被灭掉后，所表明该点的火扩散的全部边将消失。须要说明的是，虽然边消失了，可是该点扩散到的全部点属性除入度之外都不会改变，更不会消失。

由于穿越的时间有限，扶苏只能灭掉最多 k 个点的火。忙着写题面的扶苏没有时间算出他最多能扑灭多少火力值，因而他把这个问题交给了你。

便于理解的题面版本：

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

【输入格式】

输入文件名为 zay.in。

输入文件中有且仅有一组数据，第一行为三个正整数 n,m,k，表明有向图的点数、边数以及最多选择的点数。

第二行有 n 个整数，第 i 个整数表明节点 i 的火力值(点权)

下面 m 行，每行两个正整数 u,v，表明大火是从 u 扩散到 v 的，即有向图的边。

【输出格式】

输出文件名为 zay.out。

输出一行一个正整数，表明答案。

【输入样例】

7 7 3

10 2 8 4 9 5 7

1 2

1 3

1 4

2 5

3 6

3 7

4 7

【输出样例】

SOLUTION：

子任务 1：

点权都是0，因而不管怎么选答案都是 0，输出 0 便可。

子任务 2：

爆搜，枚举全部可能的顺序，而后计算答案。

因为保证了数据随机，能够在搜索的过程当中进行剪枝，效率很高。

(不会写qwq）

子任务 3：

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

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

#include<bits/stdc++.h>

using namespace std;

inline int read(){
    int ans=0;
    char last=' ',ch=getchar();
    while(ch<'0'||ch>'9') last=ch,ch=getchar();
    while(ch>='0'&&ch<='9') ans=ans*10+ch-'0',ch=getchar();
    if(last=='-') ans=-ans;
    return ans;
}

struct node{
    int next,to;
}edge[500005];

bool cmp(int x,int y){
    return x>y;
}

int head[500005],du[500005],a[500005];

int n,m,k,cnt,u,v,ans;

void add(int from,int to){
    edge[++cnt].next=head[from];
    edge[cnt].to=to;
    head[from]=cnt;
    
}

int main(){
    n=read();m=read();k=read();
    for(int i=1;i<=n;i++)
      a[i]=read();
    for(int i=1;i<=m;i++){
        u=read();v=read();
        add(u,v);
        du[v]++;
    }
    for(int i=1;i<=n;i++) if(!du[i]) a[i]=0;
    sort(a+1,a+n+1,cmp);
    for(int i=1;i<=k;i++)
      ans+=a[i];
    cout<<ans<<endl;
}

30pts Code

子任务四、5：

考虑DAG的状况放到普通有向图上会发生什么。

有了子任务 3 的提示，咱们能够考虑把整个图缩点，将其变成一个DAG来作。

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

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

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

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

由于一个强连通份量内部是互相连通的，因而咱们不妨钦定一个点为根。

对于一个没有入度的强连通份量，咱们不妨钦定点权最小的点为根。这样显然选择的是最优的。

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

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

进行一次 tarjan的复杂度是 O(n+m)，选前 k 个点能够排序一下。这样总复杂度 O(m+nlogn)，指望得分 35 分。注意到复杂度瓶颈在排序上，考虑咱们只须要前 k 大而不须要具体前 k 个之间的大小关系，因而使用 std::nth_element()函数可以将复杂度降至 O(n+m)。指望得分 40 分。注意，输入规模到了 10 7 级别，须要 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);
  }
}

STD++

而后关于tarjan：【here】

而后关于写的很走心的题解：

【here】

而后关于TARJAN：

它就是一个板子
看YY（最后）

end-