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行，每行一个整数，表示每组数据中五个整数的权值。
【样例输入】
4
1 0 0 1 0
1 0 0 8 6
3 4 5 6 7
4 5 6 7 8
【样例输出】
2
-1
-1
0
思路：
在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
", 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
【样例输出】
3
贪心，排序以后做一次差值为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（如果该同学提前离开了队伍）。
【样例输 】
4
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。
【样例输入】
5
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中的元素。
【输出格式】
仅一行一个整数，表示答案。
【样例输入 】
6
1 4 2 8 5 7
【样例输出】
11
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))之和为：
权值第 部分((B_j-B_j+1)^2(1<=j<n))之和为：
所以总权值为(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
",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);
}
}