2015百度之星初赛1 序列变换

序列变换

Accepts: 720

Submissions: 3074

Time Limit: 4000/2000 MS (Java/Others)

Memory Limit: 32768/32768 K (Java/Others)

Problem Description

给定序列A={A1,A2,...,An}, 要求改变序列A中的某些元素,形成一个严格单调的序列B(严格单调的定义为:Bi<Bi+1,1≤i<N)。

我们定义从序列A到序列B变换的代价为cost(A,B)=max(|Ai?Bi|)(1≤i≤N)。

请求出满足条件的最小代价。

注意,每个元素在变换前后都是整数。

Input

第一行为测试的组数T(1≤T≤10).

对于每一组: 第一行为序列A的长度N(1≤N≤105),第二行包含N个数,A1,A2,...,An. 序列A中的每个元素的值是正整数且不超过106。

Output

对于每一个测试样例,输出两行:

第一行输出:"Case #i:"。i代表第 i 组测试数据。

第二行输出一个正整数,代表满足条件的最小代价。

Sample Input

2
2
1 10
3
2 5 4

Sample Output

Case #1:
0
Case #2:
1

来源: <http://bestcoder.hdu.edu.cn/contests/contest_showproblem.php?cid=600&pid=1003>

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstdio>
  4. #include<cmath>
  5. using namespace std;
  6. int n;
  7. int nums[100010], numsc[100010];
  8. int main() {
  9. int T;
  10. cin >> T;
  11. for(int nq = 0; nq != T; ++nq) {
  12. printf("Case #%d:\n", nq+1);
  13. cin >> n;
  14. for(int i = 0; i != n; ++i) {
  15. // cin >> nums[i];
  16. scanf("%d", &nums[i]);
  17. }
  18. int beginK = -1, endK = 5000000, midK;
  19. bool can;
  20. while(endK - beginK > 1) {
  21. midK = (beginK + endK) / 2;
  22. for(int i = 0; i != n; ++i) {
  23. numsc[i] = nums[i];
  24. }
  25. numsc[0] -= midK;
  26. can = true;//当前K可行
  27. for(int i = 1; i != n; ++i) {
  28. if(numsc[i] > numsc[i-1]) {
  29. if(numsc[i] - numsc[i-1] > midK) {
  30. numsc[i] -= midK;
  31. }
  32. else {
  33. numsc[i] = numsc[i-1] + 1;
  34. }
  35. }
  36. else if(midK < numsc[i-1] - numsc[i] + 1) {
  37. beginK = midK;
  38. can = false;//当前K不可行
  39. break;
  40. }else {
  41. numsc[i] = numsc[i-1] + 1;
  42. }
  43. }
  44. if(can) endK = midK;
  45. }
  46. cout << endK << endl;
  47. }
  48. return 0;
  49. }

二分答案

来自为知笔记(Wiz)

时间: 2024-10-05 22:05:42

2015百度之星初赛1 序列变换的相关文章

LIS 2015百度之星初赛2 HDOJ 5256 序列变换

题目传送门 1 /* 2 LIS(非严格):首先我想到了LIS,然而总觉得有点不对:每个数先减去它的下标,防止下面的情况发生:(转载) 3 加入序列是1,2,2,2,3,这样求上升子序列是3,也就是要修改2个,但是中间的两个2,变化范围又不能超过(1,3) 4 那么这样求的也就不对,但是减掉之后,相当于给中间重复的数留下了修改的空间 5 解释下为什么可以减而保持正确性:因为题目所求时严格递增,假设是2,3, 4,那么变成1, 1, 1,所以在LIS里非严格递增就可以了 6 这也是为什么要在upp

二分搜索 2015百度之星初赛1 1003 序列变换

题目传送门 1 /* 2 二分搜索:在0-1e6的范围找到最小的max (ai - bi),也就是使得p + 1 <= a[i] + c or a[i] - c 3 比赛时以为是贪心,榨干智商也想不出来:( 4 */ 5 #include <cstdio> 6 #include <algorithm> 7 #include <cstring> 8 #include <cmath> 9 #include <iostream> 10 using

数学 2015百度之星初赛2 HDOJ 5255 魔法因子

题目传送门 1 /* 2 数学:不会写,学习一下这种解题方式:) 3 思路:设符合条件的数的最高位是h,最低位是l,中间不变的部分为mid,由题意可得到下面的公式(这里对X乘上1e6用a表示,b表示1e6) 4 (h*power+l+mid)*a = (l*power+h+mid)*b 5 可推得:mid = ((h*power+l) * a - (l*power+h) * b) / (a - b); 6 所以可以枚举h,l然后求mid,注意mid的最低位一定是0,因为留出最低位加l或者h 7

二分查找 2015百度之星初赛1 1001 超级赛亚ACMer

题目传送门 1 /* 2 二分找到不大于m的最大的数,记做p,只要a[p] + k <= a[p+1]就继续 3 注意:特判一下当没有比m小的数的情况:) 4 */ 5 #include <cstdio> 6 #include <cstring> 7 #include <cmath> 8 #include <algorithm> 9 using namespace std; 10 11 typedef long long ll; 12 13 const

BFS 2015百度之星初赛2 HDOJ 5254 棋盘占领

题目传送门 1 /* 2 BFS:先把1的入队,每个1和它相邻的组合后看看能不能使0变1,若有则添加入队,change函数返回改变了多少个0 3 注意:结果还要加上原来占领的 4 */ 5 #include <cstdio> 6 #include <algorithm> 7 #include <cstring> 8 #include <cmath> 9 #include <vector> 10 #include <queue> 11

Kruskal 2015百度之星初赛2 HDOJ 5253 连接的管道

题目传送门 1 /* 2 最小生成树(Kruskal):以权值为头,带入两个端点,自然的排序;感觉结构体的并查集很好看 3 注意:题目老头要的是两个农田的高度差,中文水平不好,题意理解成和平均值的高度差! 4 */ 5 #include <cstdio> 6 #include <algorithm> 7 #include <cstring> 8 #include <cmath> 9 #include <vector> 10 #include &l

2015 百度之星初赛 1 2 2015ACM/ICPC亚洲区上海站 codeforces 851

A - 超级赛亚ACMer HDU - 5246 n m k m >=max( a[i] ); m < min(a[i]); 先判断掉 然后就可以找到最接近的 比m小的一个数 往上涨 看是否能行 O(n) #include<stdio.h> #include<string.h> #include<algorithm> #include<string> #include<iostream> #include<math.h>

2015百度之星初赛2 1005 序列变换(LIS变形)

LIS(非严格):首先我想到了LIS,然而总觉得有点不对:每个数先减去它的下标,防止下面的情况发生:(转载) 3 加入序列是1,2,2,2,3,这样求上升子序列是3,也就是要修改2个,但是中间的两个2,变化范围又不能超过(1,3) 4 那么这样求的也就不对,但是减掉之后,相当于给中间重复的数留下了修改的空间 5 解释下为什么可以减而保持正确性:因为题目所求时严格递增,假设是2,3, 4,那么变成1, 1, 1,所以在LIS里非严格递增就可以了 6 这也是为什么要在upper_bound的位置插入

2015百度之星初赛1 1003(二分)

 Problem Description 给定序列A={A 1 ,A 2 ,...,A n } , 要求改变序列A中的某些元素,形成一个严格单调的序列B(严格单调的定义为:B i <B i+1 ,1≤i<N ). 我们定义从序列A到序列B变换的代价为cost(A,B)=max(|A i ?B i |)(1≤i≤N) . 请求出满足条件的最小代价. 注意,每个元素在变换前后都是整数. Input 第一行为测试的组数T(1≤T≤10) . 对于每一组: 第一行为序列A的长度N(1≤N≤10 5