复旦机试题

2021

一

题目描述：给定一颗二叉树，树的每个节点的值为一个正整数。如果从根节点到节点 N 的路径上不存在比节点 N 的值大的节点，那么节点 N 被认为是树上的关键节点。求树上所有的关键节点的个数。请写出程序，并解释解题思路。

输入：

3,1,4,3,null,1,5

输出：4（图中蓝色节点是关键节点）

#include<string>
#include<iostream>
#include<cstdlib>
#include<vector>
using namespace std;

void dfs(vector<int> node,int maxnode,int n,int &ans){//maxnode记录当前路径上的最大值
    if(n>=node.size()||node[n]==-1)
        return;
    maxnode=max(maxnode,node[n]);
    if(maxnode==node[n])//当前结点为路径上的最大值，即为关键结点
        ans++;
    dfs(node,maxnode,n*2,ans);//访问左子树
    dfs(node,maxnode,n*2+1,ans);//访问右子树
    return;
}
int main(){
    vector<int> node;//树的数组表示
    node.push_back(-1);//数的结点从下标为1开始
    string s;
    cin>>s;
    s+=',';//尾部加，避免边缘处理
    int i=0,j=0;
    while(j<s.size()){
        if(s[j]==','){
            string temp=s.substr(i,j-i);//分割字符串
            if(temp=="null")
                node.push_back(-1);//null在数组中用-1表示
            else
                node.push_back(stoi(temp));
            i=j+1;
        }
        j++;
    }
    int ans=0;
    dfs(node,-1,1,ans);//初始时使结点最大值为-1
    cout<<ans;
}

二

题目描述：训练场上有一个台阶，总共有 n 级。一个运动员可以跳 1 级，也可以跳 2 级。求运动员有多少种跳法。请写出程序，并解释解题思路。

#include<iostream>
#include<vector>
using namespace std;
int main(){
    int n;
    cin>>n;
    vector<int> dp(n+1,0);
    dp[1]=1;
    dp[2]=2;
    for(int i=3;i<=n;i++)
        dp[i]=dp[i-1]+dp[i-2];
    cout<<dp[n];
}

三

题目描述：给定一个非负整数序列x1,x2,…,xn,可以给每一个整数取负数或者取原值，求有多少种取法使得这些整数的和等于期望值E。请写出程序，并解释解题思路。
输入：非负数整数序列为1，1，1，1，1，期望值E为3
输出：5
样例解释：5 种取法分别为：

-1+1+1+1+1 = 3
1-1+1+1+1 = 3
1+1-1+1+1 = 3
1+1+1-1+1 = 3
1+1+1+1-1 = 3

#include<iostream>
#include<vector>
#include<string>
#include<map>
using namespace std;
int main(){
    string s;
    getline(cin, s);
    s+=',';
    int n,sum=0;//sum为所有输入数之和
    cin>>n;
    vector<int> data;
    int num=0,i=0;
    while(i<s.size()){//处理输入，将数据存入data
        if(s[i]>='0'&&s[i]<='9')
            num=num*10+s[i]-'0';
        else if(s[i]==','&&num!=0){
            data.push_back(num);
            sum+=num;
            num=0;
        }
        i++;
    }
    vector<map<int,int>> dp(data.size());//dp中所有初始值为0

    dp[0][data[0]]=1;
    dp[0][-data[0]]=1;//data[0]只能取正负，分别其所求的期望值只有一种情况
    for(int i=1;i<data.size();i++){
        for(int j=-sum;j<=sum;j++){
            dp[i][j]=dp[i-1][j-data[i]]+dp[i-1][j+data[i]];
        }
    }
    cout<<dp[data.size()-1][n];

}

2020

D.⼆叉搜索树

给定⼀个 1~n 的排列 P，即⻓度为 n，且 1~n 中所有数字都恰好出现⼀次的序列。现在按顺序将排列 中的元素⼀⼀插⼊到初始为空的⼆叉搜索树中（左⼩右⼤），问最后每个节点的⽗亲节点的元素是什 么。特别地，根节点的⽗亲节点元素视为 0。
【输⼊格式】
第⼀⾏⼀个整数 n (1<=n<=10^5)，表⽰排列 P 中的元素个数。 第⼆⾏ n 个整数 p1, p2, …, pn (1<=pi<=n, 1<=i<=n)，表⽰给定的排列。
【输出格式】
⼀⾏ n 个整数，其中第 i 个整数 ai 表⽰元素 i 对应节点的⽗亲节点的元素。特别地，根节点的⽗亲节 点元素视为 0。
【样例输⼊】
5
2 3 5 1 4
【样例输出】
2 0 2 5 3
【样例解释】
最后建出来的⼆叉搜索树如下：

1 的⽗亲为 2，2 为根结点，所以⽗亲为 0，3 的⽗亲为 2，4 的⽗亲为 5，5 的⽗亲为 3。

#include<iostream>
using namespace std;
struct node{
    int val;
    node *lchild,*rchild;
    node(int n){
        val=n;
        lchild=nullptr;
        rchild=nullptr;
    }
};
void AddNode(node *root,int n){
    if(root->val>n){
        if(root->lchild==nullptr){
            root->lchild=new node(n);
            return;
        }
        else
            AddNode(root->lchild,n);
    }
    else{
        if(root->rchild==nullptr){
            root->rchild=new node(n);
            return;
        }
        else
            AddNode(root->rchild,n);
    }
    return;
}
void dfs(node *root,int ans[],int pre){
    if(root==nullptr)
        return;
    int num=root->val;
    ans[num-1]=pre;
    dfs(root->lchild,ans,num);
    dfs(root->rchild,ans,num);
}
int main(){
    int n;
    int ans[n];
    cin>>n;
    int a[n];
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    node *root=new node(a[0]);
    for(int i=1;i<n;i++){
        AddNode(root,a[i]);
    }
    dfs(root,ans,0);
    for(int i=0;i<n;i++){
        cout<<ans[i]<<" ";
    }
    cout<<endl;
}

E.序列

给定⼀个⻓为 n 的序列 A，其中序列中的元素都是 0~9 之间的整数，对于⼀个⻓度同样为 n 整数序列 B，定义其权值为 |A_i-B_i| (1<=i<=n) 之和加上 (B_j-B_j+1)^2 (1<=j<n) 之和。求所有⻓为 n 的整数序 列中，权值最⼩的序列的权值是多少。
【输⼊格式】
第⼀⾏⼀个整数 n (1<=n<=10^5)，表⽰序列 A 的⻓度。 第⼆⾏ n 个整数 a1, a2, …, an (0<=ai<=9, 1<=i<=n)，表⽰序列 A 中的元素。
【输出格式】
仅⼀⾏⼀个整数，表⽰答案。
【样例输⼊】
6
1 4 2 8 5 7
【样例输出】
11
【解释】
A 数组是 [1 4 2 8 5 7] B 数组可以是 [3 4 4 5 5 6]。 权值为 |A_i - B_i| (1<=i<=n) 之和加上 (B_j - B_j+1)^2 (1<= j <n) 之和。 权值第⼀部分|A_i - B_i| (1<=i<=n)之和为： |1 - 3| + |4 - 4| + |2 - 4| + |8 - 5| + |5 - 5| + |7 - 6| = 2 + 0 + 2 + 3 + 0 + 1 = 8 权值第⼆部分(B_j - B_j+1)^2 (1<= j <n) 之和为： (3 - 4)^2 + (4 - 4)^2 + (4 - 5)^2 + (5 - 5)^2 + (5 - 6)^2 = 1 + 0 + 1 + 0 + 1 = 3 所以总权值为 8 + 3 = 11。

#include<iostream>
#include<vector>
using namespace std;
int main(){
    int n;
    cin>>n;
    int a[n];
    for(int i=0;i<n;i++)
        cin>>a[i];
    vector<vector<int>> dp(n,vector<int>(10,INT_MAX));//dp[i][j]表示位置i为j时，0-i的最小权值
    for(int i=0;i<10;i++)
        dp[0][i]=abs(i-a[0]);//对于第一行，只有相差的值
    for(int i=1;i<n;i++){
        for(int j=0;j<10;j++){
            for(int k=0;k<10;k++){//计算第i个位置为j，前一个位置为k时的权值，遍历求的最小权值
                int num=dp[i-1][k]+abs(j-a[i])+(j-k)*(j-k);
                dp[i][j]=min(dp[i][j],num);
            }
        }
    }
    int ans=INT_MAX;
    for(int i=0;i<10;i++)//遍历位置n-1的权值求得最小
        ans=min(dp[n-1][i],ans);
    cout<<ans;
}