[N诺] 复旦大学历年上机题解

1、n阶Hanoi塔问题

(n阶Hanoi塔问题）假设有三个分别命名为A、B、C的塔座，在塔座A上插有n(n<20)个直径大小各不相同、依小到大编号为1，2，…，n的圆盘。现要求将A轴上的n个圆盘移至塔座C上并仍按同样顺序叠排，圆盘移动时必须遵循下列规则： 1）每次只能移动一个圆盘； 2）圆盘可以插在A、B、C中的任一塔座上； 3）任何时刻都不能将一个较大的圆盘压在较小的圆盘之上。 请通过编程来打印出移动的步骤。

#include<bits/stdc++.h>
using namespace std;

int cnt = 0;

void pprint(char A,char B){
    printf("%c-->%c   ", A, B);
    cnt++;
    if(cnt%5==0){
        printf("\n");
    }
}

void hanoi(char A,char B,char T,int n){  // 起点A，终点B，中间量T
    if(n==1){
        pprint(A,B);
    }else{
        hanoi(A,T,B,n-1); // 把上面的n-1个圆盘从A移动到T 借助B
        hanoi(A,B,T,1); // 把最大的圆盘从A移动到目标柱B
        hanoi(T,B,A,n-1); // 将剩下的在中间量T（现在视作起始柱）通过起点A（现在视为中间量柱）移动到终点B
    }
}


int main() {
    int n;
    while(cin>>n && n!=0 ){
        hanoi('A','C','B',n); // 起点A，终点B，中间量T
        printf("\n"); // 新一次游戏也要换行
        cnt = 0; // 计数器置为0
    }
}

2、求众数

众数就是一个序列中出现次数最多的数字。 如果不唯一，则输出小的那个值。

此题需要模拟哈希表。 

#include<bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    int count[100000] = {0};
    for(int i=0;i<n;i++){
        int num;
        cin >> num;
        count[num]++;
    }
    int ret;
    int max = -1;
    for(int j = 0;j<100000;j++){
        if(count[j]>max){
            max = count[j];
            ret = j;
        }
        else if(count[j]==max && j<ret){
            ret = j;
        }
    }
    cout<<ret;
}

区别于用数组模拟哈希表统计字母次数，数字的多可能性带来了浪费空间，为了避免此现象，改用为map<int,int> count;进行存储。

#include<bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    int ret; // 众数值
    int max = -1; // 众数次数
    map<int,int> count;

    for(int i=0;i<n;i++){
        int num;
        cin >> num;
        count[num]++;
        if(count[num]>max){
            max = count[num];
            ret = num;
        }else if(count[num]==max && num<ret){
            ret = num;
        }
    }
    cout<<ret;
}

3.连续最大子序列

给定一个数字序列A1,A2…An，求i,j(1<=i<=j<=n)，使得Ai+…+Aj最大，输出这个最大和。

#include<bits/stdc++.h>
using namespace std;

int main() {
    int n;
    int num;
    int pos = 0;
    cin >> n;
    int len = n;
    int dp[n];
    while(n--){
        cin>>num;
        dp[pos] = num;
        pos++;
    }

    int i;
    for(i=1;i<len;i++){
        dp[i] = max(dp[i-1]+dp[i],dp[i]);
    }

    int res = *max_element(dp, dp+len);
    cout << res;
}

4.字符串编辑距离

问题描述：给定两个字符串A和B，求字符串A至少经过多少步字符操作变成字符串B。

我们先以一个例子分析，比如eat变成tea。对于第一个字符，e != a，所以要想让这两个字符相等，有三种可以选择的办法

• 修改字符，将e直接变成a，需要走1步。
• 插入字符，在e的前面插入a，也需要走1步。
• 删除字符，将e删除，然后比较后面的与a，也需要走1步。

#include<bits/stdc++.h>
using namespace std;
int dp[1001][1001]={0}; //长度为i的s1,转化为长度为j的s2，共需要多少步

int main(){
    string s1,s2;
    cin>>s1>>s2;
    int len1 = s1.size();
    int len2 = s2.size();

    // i=0时，只能对s1进行插入操作
    for(int j = 1;j<=len2;j++){
        dp[0][j] = dp[0][j-1] + 1;
    }
    // j=0时，只能对s2进行删除操作
    for(int i = 1;i<=len1;i++){
        dp[i][0] = dp[i-1][0] + 1;
    }
    for(int i = 1;i<=len1;i++){
        for(int j = 1;j<=len2;j++){
            if(s1[i-1]==s2[j-1]){
                dp[i][j] = dp[i-1][j-1];
            }else{
                dp[i][j] = min(min(dp[i-1][j-1],dp[i][j-1]),dp[i-1][j])+1;
            }
        }
    }
    cout<<dp[len1][len2];
}

5.a与b得到c

给出a,b,c（3个整数），判断a,b能否通过+-*/得到c，ab可以交换位置，可以输出YES，不可以则输出NO.

#include<bits/stdc++.h>
using namespace std;

bool cal(int a,int b,int c){
    bool ret = false;
    if(a+b==c || a-b==c || a*b == c){
        ret = true;
    }
    else if(b!=0 && a*1.0/b == c){  // 避免8/3==2
        ret = true;
    }
    return ret;
}

int main(){
    int a,b,c;
    cin >> a >> b >> c;
    if(cal(a,b,c)||cal(b,a,c)){
        cout << "YES";
    }else{
        cout << "NO";
    }
}

6.集合交并

输入两个集合，分别求其交集和并集中元素的个数，每个集合中可能存在相同的元素，而最终的交集和并集中应该不存在。

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n,m;
    cin>>m>>n;
    int num;
    map<int,int> a;
    map<int,int> b;

    int jiao = 0;
    int bing = 0;

    for(int i =0;i<m;i++){
        cin >> num;
        a[num]=1;
    }

    bing = a.size();
    for(int i =0;i<n;i++){
        cin >> num;
        if(b[num]!=1){
            b[num]=1;
            if(a[num]==1){
                jiao++;
            }else{
                bing++;
            }
        }
    }
    cout<<jiao<<" "<<bing;
}

map<int int>在对某个key未指定value时，默认value为0.

找交集的简单方法：

	int count = 0;
	for (auto iter = A.begin(); iter != A.end(); iter++) {
		if (B.find(*iter)!=B.end()) {
			count++;
		}
	}
    // auto的原理就是根据后面的值，来自己推测前面的类型是什么；

7.骨牌

有2*n 的地板，用1*2和 2*1 的骨牌进行铺地板。问共有多少种情况。结果对 999983 取余，1<=n<=10000

斐波那契数列的变体

#include<bits/stdc++.h>
using namespace std;
int dominoes(int n){
    int ret;
    if(n==1){
        ret = 1;
    }else if(n==2){
        ret = 2;
    }else{
        ret = (dominoes(n-1)+dominoes(n-2))%999983;
    }
    return ret;
}

int main(){
    int n;
    cin >> n;
    cout << dominoes(n);
}

递归的解法超时

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n;
    cin >> n;
	int dp[n+1];
	dp[1] = 1;
	dp[2] = 2;
	for(int i = 3;i<=n;i++){
		dp[i] = (dp[i-1]+dp[i-2])%999983;
	}
    cout << dp[n];
}

8.长方形中的正方形

给出长方形的长和宽，每次从长方形里撕去最大的正方形，输出最后能得到多少正方形

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n,m;
    cin >> n >> m;
    // 终止条件：剩余部分就是一个正方形
    int ret = 0;
    while(n!=m){
        if(n<m){
            swap(n,m);
        }
        n = n - m;
        ret++;
    }
    cout << ret+1;
}

C++ 自带了swap函数

9.约数求和

输入一个数n，输出前n个数的约数的和。

#include<bits/stdc++.h>
using namespace std;

int Divisor_sum(int x){
    int sum = 0;
    for(int i = 1;i<=x;i++){
        if(x%i==0)
            sum = sum + i;
    }
    return sum;
}

int main(){
    int x;
    cin >> x;
    int sum = 0;
    for(int i = 1;i<=x;i++){
        sum = sum + Divisor_sum(i);
    }
    cout << sum;
}

上述写法超时，故进行优化

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

 当输入为x时，1到x所有因数合计共有i的个数是(x/i);（如有1的个数是7,2的个数是3）

#include<bits/stdc++.h>
using namespace std;

int main()
{
    int x;
    cin>>x;
    long long sum=0;
    for(int i=1;i<=x;i++)
    {
        sum+=i*(x/i);
    }
    cout<<sum;
    return 0;
}

10.解一元一次方程

解方程，给定一个字符串，代表一个一元一次方程。如果有解求解，输出格式“x=数字“，如果解的个数无穷，输出 “infinite solutions”。如果没有解输出“no solution”，字符串长度不超过 256 。

参考答案：

Code (noobdream.com)

#include<bits/stdc++.h>
using namespace std;

int main()
{
    string str;
    cin >> str;
    int a = 0, b = 0;   //系数、常数
    int sym = 1, flag = 1; //sym表示数字之前的符号，flag表示等号的左右（初始值为1，表示在左面）
    int i = 0;   //访问字符串的下标
    while(i < str.size()) {
        if (str[i] == '=') {
            sym = 1;
            flag = -1;
        }
        else if(str[i] == '+'){
            sym = 1;
        }
        else if(str[i] == '-'){
            sym = -1;
        }
        else{
            int t = 0;      //暂存遇到的数字值
            while(i < str.size() && str[i] >= '0' && str[i] <= '9'){    //遇到数字，计算数值
                t = 10 * t + (str[i] - '0');
                ++i;
            }
            if(i >= str.size()){ // 最后一位是数字
                b = b - t * sym;
                break;
            }
            if(str[i] == 'x' && t == 0){    //如果x之前的系数为正负1时，要单独判断，因为此时t=0
                a = a + sym * flag;
            }
            else if(str[i] == 'x'){     //处理系数
                a = a + t * sym * flag;
            }
            else{                       //处理常数
                b += t * sym * flag;
                continue;
            }
        }
        i++;
    }
    if(a == 0 && b == 0){
        printf("infinite solutions\n");
    }
    else if(a != 0 && b % a == 0){
        printf("x=%d\n", -b/a);
    }
    else{
        printf("no solution\n");
    }
}

 11.相隔天数

输入日期格式：YYYYMMDD，求与20190205相隔天数。

#include<bits/stdc++.h>
using namespace std;
int dt[2][12] = {{31,28,31,30,31,30,31,31,30,31,30,31},
                 {31,29,31,30,31,30,31,31,30,31,30,31}};

int isleapyear(int year){
    if((year%4==0 && year%100!=0)||year%400 == 0){
        return 1;
    }else{
        return 0;
    }
}

int main()
{
   string date;
   cin >> date;
   string year = date.substr(0,4);
   string month = date.substr(4,2);
   string day = date.substr(6,2);

   // 20190205
   long long day1 = 0,day2 = 0;
   for(int i=1;i<2019;i++){
       if(isleapyear(i)){
           day1 = day1 + 366;
       }else{
           day1 = day1 + 365;
       }
   }
   day1 = day1 + 31 + 5;

   for(int i=1;i<stoi(year);i++){
       if(isleapyear(i)){
           day2 = day2 + 366;
       }else{
           day2 = day2 + 365;
       }
   }
    if(isleapyear(stoi(year))){
        day2 = day2 + stoi(day);
        for(int i = 0;i<(stoi(month))-1;i++){
            day2 = day2 + dt[1][i];
        }
    }else{
        day2 = day2 + stoi(day);
        for(int i = 0;i<(stoi(month))-1;i++){
            day2 = day2 + dt[0][i];
        }
    }

    cout << abs(day2 - day1);
}

注意字符串转整形函数stoi，在此篇博文有详细的总结；

C/C++字符(char/string)与整型(int)的相互转换——PAT常用知识点（三）__Pooooooocky的博客-CSDN博客_c字符转换https://blog.csdn.net/BBBling/article/details/115540073

12.求交点

求线段交点，输入两组线段端点，求其交点，若无交点或无穷个交点输出一句"Parallel or coincident"，输出交点保留两位小数。

#include <iostream>
using namespace std;

int main(){
    double x1,x2,x3,x4;
    double y1,y2,y3,y4;
    cin>>x1>>y1>>x2>>y2>>x3>>y3>>x4>>y4;
    double k1=(y2-y1)/(x2-x1),k2=(y4-y3)/(x4-x3);
    if(k1==k2) cout<<"Parallel or coincident"<<endl;
    else{
        double b1=y1-k1*x1,b2=y3-k2*x3;
        double x=(b2-b1)/(k1-k2);
        double y=k1*x+b1;
        printf("%.2f %.2f",x,y);
    }
    return 0;
}

13.期望值

给定一个非负整数序列x 1 , x 2 , ⋯   , x n，可以给每一个整数取负数或者取原值，求有多少种取法使得这些整数的和等于期望值E。请写出程序，并解释解题思路。

01背包问题的变体

解题思路详见如下链接：

一道算法题，求用背包问题解决_博问_博客园 (cnblogs.com)

1、如果将等式左边的负值移到右边，等式两边仍然相等。等式左边的值加上等式右边的值等于非负序列的和加上期望的值。那么就可以有一个结论，如果非负序列的和+期望不是偶数的话，就一定没有符合题意的取法。（如果为奇数，那么我们无法将其平均分配为两个整数部分）显然，如果期望值大于非负序列的和，也没有符合题意得取法。

2、（非负序列的和+期望）/ 2 = 左值 = 右值  等于每个取法中 取原值的和。

3、如果令（非负序列的和+期望）/ 2 = k,那么就可以转化为：将体积为k的01背包装满，有几种装法。其中如果不选择某个物品，实际上相当于某个整数取了负值。

4、那么只需要将01背包问题的状态转移方程中的max ，变为sum即可。即dp[i][j] = d[i-1][j] +dp[i-1][j-num[i]] ,其中 dp[i-1][j]表示不装，也就是选择了负值，dp[i-1][j-num[i]] 表示装，也就是选择了原值。
5、在经过滚动数组优化，状态转移方程就变成了dp[j]=dp[j]+dp[j-num[i]].

#include<bits/stdc++.h>
using namespace std;

const int mod = 1e9 + 7;

int main()
{
    int n,E;
    cin >> n;

    long long int a[n+1];

    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    cin >> E;

    int sum = 0;
    for (int i = 1; i <= n; i++) {
        sum = sum + a[i];
    }
    int cap = (E + sum) / 2; // 原值和 01背包问题中的背包总容量

    if ((E + sum) % 2 != 0) { // 无解
        cout << 0;
    }else{
        long long int dp[cap+1];
        memset(dp,0,sizeof dp);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = cap; j >= a[i]; j--) {
                dp[j] = dp[j] + dp[j - a[i]];
                dp[j] = dp[j] % mod;//取模
            }
        }
        cout << dp[cap] << endl;
    }
}

long long int的取值范围非常大。

14.斗牛

给定五个 0~9 范围内的整数 a1, a2, a3, a4, a5。如果能从五个整数中选出三个并且这三个整数的和为10 的倍数（包括 0），那么这五个整数的权值即为剩下两个没被选出来的整数的和对 10 取余的结果，显然如果有多个三元组满足和是 10 的倍数，剩下两个数之和对 10 取余的结果都是相同的；如果选不出这样三个整数，则这五个整数的权值为 -1。
现在给定 T 组数据，每组数据包含五个 0~9 范围内的整数，分别求这 T 组数据中五个整数的权值。

#include<bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    vector<int> answer;
    while(n--){
        int sum = 0;
        vector<int> a;
        int num;
        int flag = 0;
        for(int i = 0;i<5;i++){
            cin >> num;
            a.push_back(num);
        }
        for(int i = 0;i<5;i++){
            for(int j = 0;j<5;j++){
                for(int k = 0;k<5;k++){
                    if(i!=j && j!=k && i!=k && (a[i]+a[j]+a[k])%10==0){
                        flag = 1;
                        for(int p = 0;p<5;p++){
                            if(p==i || p==j || p==k){
                                continue;
                            }
                            sum = sum + a[p];
                        }
                        goto label;
                    }
                }
            }
        }
        label:
        if(flag==0)
            sum = -1;
        answer.push_back(sum%10);
    }
    for(int i = 0;i<answer.size();i++){
        cout<<answer[i]<<endl;
    }
}

由于要跳出多重循环，我在这里使用的是goto语句，好的解答方式是将其写成一个函数，然后用return跳出。

15.跳台阶

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

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n;
    cin >> n;
    int dp[n+1];
    memset(dp,0,sizeof dp);
    dp[0] = 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];
}

16.打地鼠

给定 n 个整数 a1, a2, …, an 和⼀个 d，你需要选出若⼲个整数，使得将这些整数从小到大排好序之后，任意两个相邻的数之差都不⼩于给定的 d，问最多能选多少个数出来。

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n, d;
    cin >> n >> d;
    int data[n];
    for (int i = 0; i < n; i++){
        cin >> data[i];
    }
    sort(data,data+n); // 如果定义了一个vector 则为sort(data.begin(),data.end())
    int num = 0;
    if (n < 2) {	//只有一个整数
        cout << num << endl;
        return 0;
    }
    for (int i = 0, j = 1; j < n;j++) {
        if (data[j] - data[i] >= d) {
            num++;
            i = j;
        }
    }
    if (num == 0)	cout << num << endl;	//没有符合条件的数
    else  cout << num + 1 << endl;	//由于每次只将较小的数加入结果集，因此最后还需将最后的大数加入结果集
    return 0;
}

17.二叉树个数

求N个结点能够组成的二叉树的个数。 1<=n<=20

#include<bits/stdc++.h>
using namespace std;

long long f(int n)
{
	if(n==0) return 1;
	else
		return f(n-1)*(4*n-2)/(n+1);
}
int main()
{
	int m;
	cin>>m;
	cout<<f(m)<<endl;
}

卡特兰数：

Catalan数—求解n个节点能组成的二叉树个数问题_猫小时候的博客-CSDN博客https://blog.csdn.net/onever_say_love/article/details/4942063118.给定一颗二叉树，树的每个节点的值为一个正整数。如果从根节点到节点 N 的路径上不存在比节点 N 的值大的节点，那么节点 N 被认为是树上的关键节点。求树上所有的关键节点的个数。请写出程序，并解释解题思路。

输入：3,1,4,3,null,1,5

输出：4