复旦大学2020考研机试题-编程能力摸底试题（A-E）

A.斗牛

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

现在给定T组数据，每组数据包含五个0~9范围内的整数，分别求这T组数据中五个整数的权值。

【输入格式】

第一行一个整数T(1<=T<=1000)，表示数据组数。

接下来T行，每行5个0~9的整数，表示一组数据。

【输出格式】

输出T行，每行一个整数，表示每组数据中五个整数的权值。

【样例输入】

1 0 0 1 0

1 0 0 8 6

3 4 5 6 7

4 5 6 7 8

【样例输出】

-1

思路：

在5个数里找3个，因为\(C^5_3 = 10\) ,加上 \(T= 1000\)，暴力也是可以解决的，DFS剪枝也是ok

//暴力解法

#include<bits/stdc++.h>

using namespace std;

int a[6];

int main() {

    //freopen("in.txt", "r", stdin);

    int t; cin >> t;

    while (t--) {

        int sum = 0;

        for (int i = 1; i <= 5; ++i)cin >> a[i], sum += a[i];

        bool flag = true;

        for (int i = 1; i <= 5 && flag; ++i)

            for (int j = i + 1; j <= 5 && flag; ++j)

                for (int k = j + 1; k <= 5 && flag; ++k) {

                    int tmp = a[i] + a[j] + a[k];

                    if (tmp % 10 == 0) {

                        flag = false;

                        sum = (sum - tmp) % 10;

                    }

                }

        if (flag)cout << -1 << endl;

        else cout << sum << endl;

    }

}

//DFS + 剪枝

#include<bits/stdc++.h>

using namespace std;

int num[6], all, ans;

bool vis[6], flag;

void dfs(int now, int start) {

    if (flag)  return;

    if (now == 3) {

        int temp1 = 0, temp2 = 0;

        for (int i = 1; i <= 5; i++)

            if (vis[i]) temp1 += num[i];

            else

                temp2 += num[i];

        if (temp1 % 10 == 0)

            flag = true, ans = temp2 % 10;

        return;

    }

    for (int i = start; i <= 5; i++) {

        if (vis[i]) continue;

        vis[i] = true;

        dfs(now + 1, i + 1);

        vis[i] = false;

    }

}

int main() {

	 //freopen("in.txt", "r", stdin);

    int t;

    scanf("%d", &t);

    while (t--) {

        memset(vis, 0, sizeof(vis));

        ans = -1;

        flag = false;

        for (int i = 1; i <= 5; i++) scanf("%d", &num[i]), all += num[i];

        dfs(0, 1);

        printf("%d\n", ans);

    }

}

B. 打地鼠

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

【输入格式】

第一行两个整数\(n,d(1<=n<=10^5,0<=d<=10^9)\)，分别表示整数个数和相邻整数差的下界。

第二行n个整数a1,a2,...,an\((1<=ai<=10^9,1<=i<=n)\)，表示给定的n个整数。

【输出格式】

仅一行一个整数，表示答案。

【样例输入】

6 2

1 4 2 8 5 7

【样例输出】

贪心，排序以后做一次差值为d的上升子序列即可

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 1e5 + 100;

int a[N], dp[N];

int main() {

	//freopen("in.txt", "r", stdin);

	ll n, d;

	cin >> n >> d;

	int sum = 0;

	for (int i = 0; i < n; ++i)cin >> a[i];

	sort(a, a + n);

	for (int i = 0; i < n; ++i) {

		dp[i] = 1;

		for (int j = 0; j < i; ++j) {

			if (a[i] - a[j] >= d)

				dp[i] = max(dp[i], dp[j] + 1);

		}

		sum = max(sum, dp[i]);

	}

	cout << sum << endl;

}

C.排队打饭

下课了，有n位同学陆续赶到食堂进行排队打饭，其中第i位同学的到达时间为ai，打饭耗时为ti，等待时间上限为bi，即如果其在第ai+bi秒的时刻仍然没有轮到他开始打饭，那么他将离开打饭队列另寻吃饭的地。问每位同学的开始打饭时间，或者指出其提前离开了队伍（如果这样则输出-1）。

【输入格式】

第一行一个整数n(1<=n<=10^5)，表示来打饭的同学数量。

接下来n ，每行三个整数ai,ti,bi(1<=ai,ti,bi<=10^9,1<=i<=n)，分别表每位同学的到达时间、打

饭耗时、等待时间上限。

保证a1<a2<...<an

【输出格式】

n个整数，表示每位同学的开始打饭时间或者-1（如果该同学提前离开了队伍）。

【样例输】

1 3 3

2 2 2

3 9 1

4 3 2

【样例输出】

1 4 -1 6

思路：

模拟题

因为输入就是ai<a(i+1)所以都不需要排序了，直接模拟顺序处理，记录当前时间time

如果time大于这个同学最后等待时间那就输出-1，否则取time和他到达食堂时间的最大值。

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 1e5 + 100;

struct node {

	ll a, t, b;

	ll tag;

}p[N];

bool cmp(node a, node b) {

	return a.a < b.a;

}

int main() {

	//freopen("in.txt", "r", stdin);

	int n; cin >> n;

	for (int i = 0; i < n; ++i)

		cin >> p[i].a >> p[i].t >> p[i].b;

	sort(p, p + n, cmp);

	int time = p[0].a;//记录时间戳

	for (int i = 0; i < n; ++i) {

		if (time > p[i].a + p[i].b) {

			p[i].tag = -1;

			continue;

		}

		p[i].tag = time;

		time += p[i].t;

	}

	for (int i = 0; i < n; ++i)

		cout << p[i].tag << " ";

	cout << endl;

}

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。

【样例输入】

2 3 5 1 4

【样例输出】

2 0 2 5 3

思路：

第一反应是可以手动建一个二叉树去做，但n=1e5退化成链的时候就成\(O(n^2)\)了。改用map(表示层数）和fa数组（表示父节点的数组）去模拟

#include<bits/stdc++.h>

using namespace std;

const int N = 1e5 + 100;

int fa[N];

int main() {

	//freopen("in.txt", "r", stdin);

	int n, mx = 0;//mx用于保存当前最大的结点

	cin >> n;

	map<int, int>mp;//mp保存的是元素i所在的层数

	mp[0] = 0; fa[0] = -1;

	map<int, int>::iterator it, it1;

	for (int i = 0, t; i < n; ++i) {

		cin >> t;

		if (t > mx) {

			fa[t] = mx;

			mp[t] = mp.rbegin()->second + 1;

			mx = t;

		}

		else {

			it = mp.upper_bound(t);//找到比t大的位置

			it1 = it--;

			if (it->second > it1->second) {

				fa[t] = it->first;

				mp[t] = it->second + 1;

			}

			else {

				fa[t] = it1->first;

				mp[t] = it1->second + 1;

			}

		}

	}

	for (int i = 1; i <= n; i++) {

		if (i == 1) cout << fa[i];

		else cout << " " << fa[i];

	}

}

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中的元素。

【输出格式】

仅一行一个整数，表示答案。

【样例输入】

1 4 2 8 5 7

【样例输出】

A数组是 \([142857]\)

B数组可以是\([344556]\)。

权值为\(|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。\)

思路：

对于b数组每个值的选取对答案的贡献是什么？？其实只有前

一个把，因为贡献只不过是加上它和它前一个值的差值的平方，和它和A数组对应位置的

差值绝对值，所以咱们就维护一个now数组,now[i]表示的是当前结束的B的这个

位置值为i，那么更新就需要前一个位置的0-9种情况取最优，那么复杂度就是

\(O(10*10*n)\)，n=1e5,那么差不多1秒内了

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

int tp1[10][10],tp2[10][10];

int now[10],now_temp[10];  //目前结尾为i的最小函数值，复杂度O(n*10*10)约等于1e7，差不多一秒

const int INF=0x3f3f3f3f;

void init();

int main()

{

    int n,num;

    init();

    while(scanf("%d",&n)!=EOF)

    {

        memset(now,0,sizeof(now));

        for(int i=0;i<n;i++)

        {

            scanf("%d",&num);

            for(int j=0;j<10;j++)

            {

                int temp=INF;

                for(int k=0;k<10;k++)

                {

                    int tp;

                    if(i)

                        tp=now[k]+tp1[j][num]+tp2[j][k];

                    else

                        tp=now[k]+tp1[j][num];

                    if(tp<temp) temp=tp;

                }

                now_temp[j]=temp;

            }

            for(int i=0;i<10;i++) now[i]=now_temp[i];

        }

        int ans=INF;

        for(int i=0;i<10;i++)

            ans=min(ans,now[i]);

        printf("%d\n",ans);

    }

    return 0;

}

void init()

{

    for(int i=0;i<10;i++)

    for(int j=0;j<10;j++)

    {

        tp1[i][j]=i<j?(j-i):(i-j);

        tp2[i][j]=(i-j)*(i-j);

    }

}