A.斗牛ios
给定五个0~9范围内的整数a1,a2,a3,a4,a5。若是能从五个整数中选出三个而且这三个整数的和为10的倍数（包括0），那么这五个整数的权值即为剩下两个没被选出来的整数的和对10取余的结果，显然若是有多个三元组满 和是10的倍数，剩下两个数之和对10取余的结果都是相同的；若是选不出这样三个整数，则这五个整数的权值为-1。数组
如今给定T组数据，每组数据包含五个0~9范围内的整数，分别求这T组数据中五个整数的权值。函数
【输入格式】ui
第一行一个整数T(1<=T<=1000)，表示数据组数。spa
接下来T行，每行5个0~9的整数，表示一组数据。code
【输出格式】排序
输出T行，每行一个整数，表示每组数据中五个整数的权值。队列
【样例输入】string
4it
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个，C53也就10种，实在不行暴力也能够，固然也能够用dfs
找到那就剪枝退出。
代码：
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int num[6],all,ans;
bool vis[6];
bool finding;
void dfs(int now,int start);
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
memset(vis,0,sizeof(vis));
ans=-1;
finding=false;
for(int i=1;i<=5;i++) scanf("%d",&num[i]),all+=num[i];
dfs(0,1);
printf("%d\n",ans);
}
}
void dfs(int now,int start)
{
if(finding)
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)
finding=true,ans=temp2%10;
return ;
}
for(int i=start;i<=5;i++)
{
if(vis[i]) continue;
else
{
vis[i]=true;
dfs(now+1,i+1);
vis[i]=false;
}
}
}
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 <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> object;
int main()
{
int n,d,ans,now,num;
while(scanf("%d%d",&n,&d)!=EOF)
{
object.clear();
now=0;
ans=1;
for(int i=0;i<n;i++)
scanf("%d",&num),object.push_back(num);
sort(object.begin(),object.end());
for(int i=1;i<object.size();i++)
{
if(object[i]-object[now]>=d)
ans++,now=i;
}
printf("%d\n",ans);
}
}
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 <iostream>
#include <cstdio>
using namespace std;
const int maxn=1e5+100;
int a[maxn],b[maxn],c[maxn];
int main()
{
int n,time;
while(scanf("%d",&n)!=EOF)
{
for(int i=1;i<=n;i++)
scanf("%d%d%d",&a[i],&b[i],&c[i]),c[i]=a[i]+c[i];
time=a[1];
for(int i=1;i<=n;i++)
{
if(i!=1)
printf(" ");
if(time>c[i]) printf("-1");
else
{
printf("%d",max(time,a[i]));
time=max(time,a[i])+b[i];
}
}
printf("\n");
}
return 0;
}
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
一开始直接建树，等到5点左右系统恢复提交tle，才想起n=1e5退化成链的时候就成O(n^2)了
后来换了个区间最值查询的方法，我用的线段树，写完的时候都不能提交了（也不知道可否ac），不过期间复杂度O(n*logn)应该差很少了
大体方法是这样的好比 5个点，2，3，5，1，4，从左往右循环，遇到2了，而后查询值为1到（2-1）的这些节点里面第一个出现的点，这里是1，那么father[1]=2,而后标记vis[1]=true;而且更新线段树，time[1]=INF，再查询(2+1)到5这里找出来是3，那么father[3]=1,而后标记vis[3]=true;接下来i=2，节点值是3，因为i点和找出来的左右节点都找出来了，因此都标记vis和更新。查询1到2 （由于节点值1和2都已经标记了，因此节点值3没有左子树），接下来找（4-5）返回了5，由于5出如今4前面，
因而father[5]=3,而后标记3和5（更新vis和更新线段树），而后i=3，值为5，查询1到4，这里1,2,3都标记过了只有4，因此father[4]=5,再查询6到5（固然是没有的，因此结点值5没有右子树），到此为止，全部点都标记了，循环后面也不会更新father了。
这个代码有误的话欢迎指出！
代码：
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=1e5+100;
int time[maxn];
int num[maxn];
const int INF=0x3f3f3f3f;
struct Segtree
{
int val;
};
Segtree tree[maxn*5];
bool vis[maxn];
int father[maxn];
void build(int root,int l,int r);
void update(int root,int l,int r,int index,int val);
int query(int root,int l,int r,int ql,int qr);
int main()
{
int n;
time[0]=INF;
while(scanf("%d",&n)!=EOF)
{
for(int i=1;i<=n;i++) scanf("%d",&num[i]),time[num[i]]=i;
build(1,1,n);
memset(vis,0,sizeof(vis));
memset(father,0,sizeof(father));
for(int i=1;i<=n;i++)
{
vis[num[i]]=true;
int now1=query(1,1,n,1,num[i]-1);
int now2=query(1,1,n,num[i]+1,n);
if(now1&&!vis[now1])
father[now1]=num[i],update(1,1,n,now1,INF),vis[now1]=true;
if(now2&&!vis[now2])
father[now2]=num[i],update(1,1,n,now2,INF),vis[now2]=true;
update(1,1,n,num[i],INF);
}
for(int i=1;i<=n;i++)
{
if(i!=1) printf(" ");
printf("%d",father[i]);
}
printf("\n");
}
return 0;
}
void build(int root,int l,int r)
{
if(l==r)
tree[root].val=l;
else
{
int mid=(l+r)/2;
build(root*2,l,mid);
build(root*2+1,mid+1,r);
tree[root].val=time[tree[root*2].val]<time[tree[root*2+1].val]?tree[root*2].val:tree[root*2+1].val;
}
}
int query(int root,int l,int r,int ql,int qr)
{
if(qr<l||ql>r)
return 0;
if(ql<=l&&qr>=r)
return tree[root].val;
int mid=(l+r)/2;
int now1=query(root*2,l,mid,ql,qr);
int now2=query(root*2+1,mid+1,r,ql,qr);
return time[now1]<time[now2]?now1:now2;
}
void update(int root,int l,int r,int index,int val)
{
if(l==r)
time[tree[root].val]=val;
else
{
int mid=(l+r)/2;
if(index<=mid)
update(root*2,l,mid,index,val);
else
update(root*2+1,mid+1,r,index,val);
tree[root].val=time[tree[root*2].val]<time[tree[root*2+1].val]?tree[root*2].val:tree[root*2+1].val;
}
}
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)之和为：
|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);
}
}
题不算很难，细节很重要！