(PTA) L2-011-L2-015

L2-012 关于堆的判断由于没有得到AC代码（1，3测试点错误）,这里先不做展示，等后续复盘的时候进行补充。

L2-011 玩转二叉树

给定一棵二叉树的中序遍历和前序遍历，请你先将树做个镜面反转，再输出反转后的层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其中序遍历序列。第三行给出其前序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树反转后的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

复制代码

7
1 2 3 4 5 6 7
4 1 3 2 6 5 7

输出样例：

复制代码

4 6 1 7 5 3 2

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
int n;
int pre[100];
int mid[100];
struct tree{
    int l,r;
    int data;
};
struct tree t[100];
void createTree(int midL,int midR,int preL,int preR){
    int root=preL;//根节点的位置（所有下标位置以先序遍历位置为主）
    t[root].data=pre[root];
    int midRoot=0;
    for(int i=midL;i<=midR;i++){
        if(mid[i]==pre[root]){
            midRoot=i;  //记录中序遍历中的根节点位置
            break;
        }
    }
    int lenL=midRoot-midL;
    int lenR=midR-midRoot;
    if(lenL>0){
        t[root].l=preL+1;
        createTree(midL,midRoot-1,preL+1,preL+lenL);
    }
    else t[root].l=-1;
    if(lenR>0){
        t[root].r=preL+lenL+1;
        createTree(midRoot+1,midR,preL+lenL+1,preR);
    }
    else t[root].r=-1;
}
vector<int> v;
void ceng(int root){
    queue<int> q;
    q.push(root);
    while(!q.empty()){
        int pos=q.front();
        v.push_back(t[pos].data);
        q.pop();
        if(t[pos].r!=-1) q.push(t[pos].r);
        if(t[pos].l!=-1) q.push(t[pos].l);
    }
}
signed main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>mid[i];
    for(int i=1;i<=n;i++) cin>>pre[i];
    createTree(1,n,1,n);
    ceng(1);
    for(int i=0;i<v.size();i++){
        cout<<v[i];
        if(i!=v.size()-1) cout<<' ';
    }
}

L2-013 红色警报

战争中保持各个城市间的连通性非常重要。本题要求你编写一个报警程序，当失去一个城市导致国家被分裂为多个无法连通的区域时，就发出红色警报。注意：若该国本来就不完全连通，是分裂的k个区域，而失去一个城市并不改变其他城市之间的连通性，则不要发出警报。

输入格式：

输入在第一行给出两个整数N（0 < N ≤ 500）和M（≤ 5000），分别为城市个数（于是默认城市从0到N-1编号）和连接两城市的通路条数。随后M行，每行给出一条通路所连接的两个城市的编号，其间以1个空格分隔。在城市信息之后给出被攻占的信息，即一个正整数K和随后的K个被攻占的城市的编号。

注意：输入保证给出的被攻占的城市编号都是合法的且无重复，但并不保证给出的通路没有重复。

输出格式：

对每个被攻占的城市，如果它会改变整个国家的连通性，则输出Red Alert: City k is lost!，其中k是该城市的编号；否则只输出City k is lost.即可。如果该国失去了最后一个城市，则增加一行输出Game Over.。

输入样例：

复制代码

输出样例：

复制代码

City 1 is lost.
City 2 is lost.
Red Alert: City 0 is lost!
City 4 is lost.
City 3 is lost.
Game Over.

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
//可以利用Tarjan判断割点，每次删除后就重新判断一次
//删除一个割点后只需要重新判断这个割点的所有的邻点
//Tarjan判断割点的时间复杂度为O(n+m)
int n,m;
vector<int> g[510];//构造图
int dfn[510];
int low[510];
int temp=0;
bool cut[510];
bool bx[510];      //顶点的被攻占情况
void tarjan(int u,int fa){
    cut[u]=false;//重新访问时直接赋不是割点，重新进行判断
    dfn[u]=low[u]=++temp;
    int child=0;//记录根节点的子树个数
    for(int v:g[u]){
        if(bx[v]) continue; //说明节点被删除了
        if(dfn[v]==0){
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(u==fa) child++;
            else if(dfn[u]<=low[v]) cut[u]=true;
        }
        else if(v!=fa){
            //说明是后向边
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(child>=2) cut[u]=true;
}

signed main(){
    cin>>n>>m;
    while(m--){
        int u,v;
        cin>>u>>v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    for(int i=0;i<n;i++){
        if(dfn[i]==0){
            tarjan(i,i);
        }
    }
    int k;
    cin>>k;
  for(int i=1;i<=k;i++){
        int x;
        cin>>x;
        bx[x]=true;
        if(!cut[x]){
            cout<<"City "<<x<<" is lost."<<endl;
        }
      else{
          memset(dfn,0,sizeof(dfn));
          memset(low,0,sizeof(low));
          cout<<"Red Alert: City "<<x<<" is lost!"<<endl;
          for(int u:g[x]){
              if(!bx[u]&&dfn[u]==0){
                  tarjan(u,u);
              }
          }
      }
      if(i==n) cout<<"Game Over."<<endl;
    }
}

L2-014 列车调度

火车站的列车调度铁轨的结构如下图所示。

两端分别是一条入口（Entrance）轨道和一条出口（Exit）轨道，它们之间有N条平行的轨道。每趟列车从入口可以选择任意一条轨道进入，最后从出口离开。在图中有9趟列车，在入口处按照{8，4，2，5，3，9，1，6，7}的顺序排队等待进入。如果要求它们必须按序号递减的顺序从出口离开，则至少需要多少条平行铁轨用于调度？

输入格式：

输入第一行给出一个整数N (2 ≤ N ≤105)，下一行给出从1到N的整数序号的一个重排列。数字间以空格分隔。

输出格式：

在一行中输出可以将输入的列车按序号递减的顺序调离所需要的最少的铁轨条数。

输入样例：

复制代码

9
8 4 2 5 3 9 1 6 7

输出样例：

复制代码

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
//计算序列中有多少条有序队列
int n;
int x;
//二分查找
//lower_bound(v.begin(),v.end(),val) 第一个大于等于val的位置
//如果找不到，返回v.end()
//upper_bound(v.begin(),v.end(),val) 第一个大于val的位置
//如果找不到，返回v.end()
//找到第一个大于的队列
//已知，v总是被维护成一个有序队列
int cnt=0;
int v[100100];

signed main(){
    cin>>n;
    while(n--){
        cin>>x;
        auto it=upper_bound(v+1,v+cnt+1,x);
        if(it==v+cnt+1) v[++cnt]=x;
        else *it=x;
    }
    cout<<cnt<<endl;
}

L2-015 互评成绩

学生互评作业的简单规则是这样定的：每个人的作业会被k个同学评审，得到k个成绩。系统需要去掉一个最高分和一个最低分，将剩下的分数取平均，就得到这个学生的最后成绩。本题就要求你编写这个互评系统的算分模块。

输入格式：

输入第一行给出3个正整数N（3 < N ≤104，学生总数）、k（3 ≤ k ≤ 10，每份作业的评审数）、M（≤ 20，需要输出的学生数）。随后N行，每行给出一份作业得到的k个评审成绩（在区间[0, 100]内），其间以空格分隔。

输出格式：

按非递减顺序输出最后得分最高的M个成绩，保留小数点后3位。分数间有1个空格，行首尾不得有多余空格。

输入样例：

复制代码

6 5 3
88 90 85 99 60
67 60 80 76 70
90 93 96 99 99
78 65 77 70 72
88 88 88 88 88
55 55 55 55 55

输出样例：

复制代码

87.667 88.000 96.000

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
int n,m,k;
double c[10010];
signed main(){
cin>>n>>k>>m;
    for(int i=1;i<=n;i++){
        double maxc=-1,minc=101;
        double sum=0;
        double x;
        for(int j=1;j<=k;j++){
            cin>>x;
            sum+=x;
            maxc=max(maxc,x);
            minc=min(minc,x);
        }
        c[i]=(sum-maxc-minc)/(k-2);
    }
    sort(c+1,c+n+1);
    while(m--){
        cout<<fixed<<setprecision(3)<<c[n-m];
        if(m>0) cout<<' ';
    }
    
    //sum/k-1
}