hdu5248 序列变换

百度之星的题。其实最简单的方法是二分答案，我竟然没想到，直接去想O(n)的去了，最后导致滚粗。。。

题意就是给一个数列，要求把它处理成递增序列。

首先我想到了O(n^2)的算法，然后再优化成O(n)过的。

n^2的做法是，弄一个尾指针e，从后往前扫，一旦发现a[e-1]>=a[e]，说明a[e]之后的所有数都需要加一个数tmp了。

确定这个tmp的简单方法是直接看a[e-1]。比如1 3 4 2 10 2 3 5 8 9这个序列，当a[e]=2时，通过a[e-1]发现a[e]及之后的数都至少需要加上tmp=5

而对于a[e]之前的数，a[0]必然减去tmp，之后一直到a[e-1]的每一个数都分情况讨论，确定是加上[-tmp,tmp]之间的哪一个数。比如上面这个例子，第一轮处理后的数列应该是

-4 6 7 8 9 7 (8 10 13 14) 括号之后的数是不用实际算出来的，标在这里是方便理解。

每一轮处理是O(n)，最多有n轮，所以复杂度是O(n^2）

在这个过程中可以发现存在许多冗余计算。

换一个例子，对于10 9 8 7 6 5 4 3 2 1，a[e]=1时第一轮处理之后是9 10 9 8 7 6 5 4 3 2，第二轮处理之后是8 9 10 9 8 7 6 5 4 3，第三轮处理之后是7 8 9 10 9 8 7 6 5 4……

发现前面也不用全都处理。

于是再引入一个头指针s，同时，在确定tmp时，不仅看a[e-1]，还看一看a[s]，得到最大的tmp，例如10 9 8 7 6 5 4 3 2 1，当a[e]=1时，通过a[s]=10可以知道tmp至少是9，于是这一轮这后数列成了1 2 3 4 5 6 7 8 9 10。每一轮要么e前移一位，要么s后移一位，所以最多还是n轮。更进一步，对a[s+1]...a[e-1]的处理不必每一轮都进行，处理a[s]时，只需要看a[s+1]，并标记，省掉这里O(n)的循环。于是整个算法就变成了O(n)了。

当然，因为我做题的时候是在n^2算法的基础上改的，改一会儿就提交一次，还没等我完全改成O(n)的算法(没有去掉那个O(n)的处理过程)，就已经过了。所以下面的代码仅供参考。

/*
 * Author    : ben
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <functional>
#include <numeric>
#include <cctype>
using namespace std;
typec get_int() {
    typec res = 0, ch;
    while (!((ch = getchar()) >= '0' && ch <= '9')) {
        if (ch == EOF)
            return -1;
    }
    res = ch - '0';
    while ((ch = getchar()) >= '0' && ch <= '9')
        res = res * 10 + (ch - '0');
    return res;
}
const int MAXN = 100010;
int data[MAXN];

int main() {
    int T, N;
    T = get_int();
    for (int t = 1; t <= T; t++) {
        N = get_int();
        for (int i = 0; i < N; i++) {
            data[i] = get_int();
        }
        int ans = 0, tmp, last = N - 1, start = 0, tmp2;
        while (last > start) {
            if (data[last] - data[last - 1] > 0) {
                last--;
                continue;
            }
            tmp = ceil((data[last - 1] - data[last] + 1) / 2.0);
            tmp2 = ceil((data[start] - data[last] + last - start) / 2.0);
            tmp = tmp > tmp2 ? tmp : tmp2;
            ans += tmp;
            data[last] += tmp;
            data[start] -= tmp;
            for (int i = start + 1; i < last; i++) {
                if (data[i] - tmp > data[i - 1]) {
                    data[i] -= tmp;
                } else     if (data[i] + tmp > data[i - 1]) {
                    data[i] = data[i - 1] + 1;
                } else {
                    data[i] += tmp;
                }
            }
        }
        printf("Case #%d:\n%d\n", t, ans);
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/moonbay/p/4540993.html