Minimum Sum 完善划分树

原创 2012年03月25日 01:51:11

Minimum Sum

Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1152    Accepted Submission(s): 263


Problem Description
You are given N positive integers, denoted as x0, x1 ... xN-1. Then give you some intervals [l, r]. For each interval, you need to find a number x to make  as small as possible!

Input
The first line is an integer T (T <= 10), indicating the number of test cases. For each test case, an integer N (1 <= N <= 100,000) comes first. Then comes N positive integers x (1 <= x <= 1,000, 000,000) in the next line. Finally, comes an integer Q (1 <= Q <= 100,000), indicting there are Q queries. Each query consists of two integers l, r (0 <= l <= r < N), meaning the interval you should deal with.


Output
For the k-th test case, first output “Case #k:” in a separate line. Then output Q lines, each line is the minimum value of  . Output a blank line after every test case.
 

Sample Input
2 5 3 6 2 2 4 2 1 4 0 2 2 7 7 2 0 1 1 1
 

Sample Output
Case #1: 6 4 Case #2: 0 0
 

Author
standy
 

Source

这个不同于POJ的Kth Number,比它要注意的几点是:
1、它的数值序列式允许重复的,因此需要解决
2、需要统计和

解题思路:这一题很久一前就见过,不过不会做。因为当时不会划分树,我们可以很容易的看出找到中位数,在统计中位数两边的和即可
这里我们统计总和和一边的和,拿总的减去一边便是另一边。这里我颠覆来原来看似简洁的写法,原来那个边界考虑的很多,容易糊涂
这里为了简单改写为另一种写法,就是行布朗当的把从一开始的所有和均统计出来,我们从一开始,0号元素为0,那么就不会影响结果。
所有区间的统计均是末减初(前提是先序遍历,你懂得),这样统计某一区间时,直接减即可。
第一种写法代码:

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int MAX = 100002;
const int MAX_depth = 32;
int val[MAX_depth][MAX];
int a[MAX_depth][MAX];
long long sum[MAX_depth][MAX];
int s[MAX];


void Build(int l, int r, int depth) {
    if (l == r) {
        sum[depth][l] = val[depth][l];
        return;
    }
    int mid = (l + r) / 2;
    int same = mid - l + 1;
    for (int i = l; i <= r; i++) {
        if (val[depth][i] < s[mid]) {
            same--;
        }
    }
    int lc = l;
    int rc = mid + 1;
    for (int i = l; i <= r; i++) {
        if (i == l) {
            sum[depth][i] = val[depth][i];
        } else {
            sum[depth][i] = sum[depth][i - 1] + val[depth][i];
        }


        if ((val[depth][i] < s[mid]) || (val[depth][i] == s[mid] && same > 0)) {
            if (val[depth][i] == s[mid]) same--;
            if (i == l) {
                a[depth][i] = 1;
            } else {
                a[depth][i] = a[depth][i - 1] + 1;
            }
            val[depth + 1][lc++] = val[depth][i];
        } else {
            if (i == l) {
                a[depth][i] = 0;
            } else {
                a[depth][i] = a[depth][i - 1];
            }
            val[depth + 1][rc++] = val[depth][i];
        }
    }
    Build(l, mid, depth + 1);
    Build(mid + 1, r, depth + 1);
}

long long total;
int pre_same;

int Search(int s, int e, int l, int r, int k, int depth) {
    if (l == r) {
        return val[depth][l];
    }
    int mid = (l + r) / 2;
    int So = a[depth][s - 1];
    if (s == l) {
        So = 0;
    }
    int x = a[depth][e] - So;
    if (x >= k) {
        return Search(l + So, l + a[depth][e] - 1, l, mid, k, depth + 1);
    } else {
        pre_same += x;
        if (a[depth][e] > 0) {
            total += sum[depth + 1][l + a[depth][e] - 1];
            if (So > 0) {
                total -= sum[depth + 1][l + So - 1];
            }
        }
        return Search(mid + 1 + s - l - So, mid + 1 + e - l - a[depth][e], mid + 1, r, k - x, depth + 1);
    }
}

int main() {
    int n, m;
    int T;
    scanf("%d", &T);
    for (int k1 = 1; k1 <= T; k1++) {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &val[0][i]);
            s[i] = val[0][i];
        }

        sort(s + 1, s + n + 1);
        Build(1, n, 0);
        int s, e;
        scanf("%d", &m);
        printf("Case #%d:\n", k1);
        for (int i = 0; i < m; i++) {
            scanf("%d%d", &s, &e);
            s++, e++;
            int k = (e - s + 2) / 2;
            total = 0;
            pre_same = 0;
            long long x = Search(s, e, 1, n, k, 0);
            long long All = sum[0][e];
            if (s > 1) {
                All -= sum[0][s - 1];
            }
            long long result = pre_same * x - total + All - total - (e - s + 1 -pre_same) * x;
           cout<<result<<endl;
        }
        printf("\n");
    }
    return 0;
}

第二种写法:
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAX_depth = 33;
const int MAX = 100010;
int to_left[MAX_depth][MAX];
int val[MAX_depth][MAX];
long long sum[MAX_depth][MAX];
int s[MAX];
long long sum1[MAX];


/*明白了思想,其实没必要每段都算,其实是给自己制造麻烦,累加即可*/
void Build(int left, int right, int depth) {
    if (left == right)return;
    int mid = (left + right) >> 1;
    int same = mid - left + 1;
    for (int i = left; i <= right; i++) {
        if (val[depth][i] < s[mid]) {
            same--;
        }
    }
    int lc = left, rc = mid + 1;
    for (int i = left; i <= right; i++) {
        if ((val[depth][i] < s[mid]) || (val[depth][i] == s[mid] && same > 0)) {
            if (val[depth][i] == s[mid])same--;
            val[depth + 1][lc++] = val[depth][i];
            to_left[depth][i] = to_left[depth][i - 1] + 1;
            sum[depth][i] = sum[depth][i - 1] + val[depth][i];
        } else {
            val[depth + 1][rc++] = val[depth][i];
            to_left[depth][i] = to_left[depth][i - 1];
            sum[depth][i] = sum[depth][i - 1];
        }
    }
    Build(left, mid, depth + 1);
    Build(mid + 1, right, depth + 1);
}


long long left_sum;
int lnum;

int Search(int start, int end, int left, int right, int k, int depth) {
    if (left == right) return val[depth][left];
    int mid = (left + right) >> 1;
    int s = to_left[depth][start - 1] - to_left[depth][left - 1];
    int e = to_left[depth][end] - to_left[depth][left - 1];
    int x = to_left[depth][end] - to_left[depth][start - 1];
    int rs = start - left - s; /*[left,start-1]*/
    int re = end - left + 1 - e; /*[left,end]*/
    if (x >= k) {
        return Search(left + s, left + e - 1, left, mid, k, depth + 1);
    } else {
        lnum += x;
        left_sum += sum[depth][end] - sum[depth][start - 1];
        return Search(mid + 1 + rs, mid + 1 + re - 1, mid + 1, right, k - x, depth + 1);
    }
}

int main() {
    int n, m;
    int T;
    while (scanf("%d", &T) != EOF) {
        for (int cas = 1; cas <= T; cas++) {
            scanf("%d", &n);
            for (int i = 0; i < 33; i++) {
                sum[i][0] = 0;
                to_left[i][0] = 0;
            }
            sum1[0] = 0;
            for (int i = 1; i <= n; i++) {
                scanf("%d", &val[0][i]);
                s[i] = val[0][i];
                sum1[i] = sum1[i - 1] + s[i];
            }
            sort(s + 1, s + n + 1);
            Build(1, n, 0);
            scanf("%d", &m);
            printf("Case #%d:\n", cas);
            int s, e;
            for (int i = 0; i < m; i++) {
                scanf("%d%d", &s, &e);
                s++;
                e++;
                lnum = 0;
                left_sum = 0;
                int k = (e - s) / 2 + 1;
                long long x = Search(s, e, 1, n, k, 0);
                long long all = sum1[e] - sum1[s - 1];
                long long res = lnum * x - left_sum + all - left_sum - (e - s + 1 - lnum) * x;
                cout<<res<<endl;
            }
            printf("\n");
        }
    }
    return 0;
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

hdu 3473 Minimum Sum 划分树的应用

题意: 问l,r区间 取任意整数x , 问 ∑|X-xi| 的最小值 做法:很明显 这个X是中位数。 中位数想到划分树,然后在划分树 建树的时候,把进左子树的数计算一个前缀和,然后在查询的时候,...

hdu 3473 Minimum Sum(划分树应用)

Minimum Sum Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) T...

【划分树】 HDU 3473 Minimum Sum 中位数

点击打开链接 题意:在给出有N个数的数列 然后Q个询问 询问  [ L,R ]    要那个公式的值最小 显然是这个区间的中位数嘛 然后就要处理出 小于中位数的数的和 大于中位数的数的和 对于划分树来...

hdu 3473 Minimum Sum 划分树

http://acm.hdu.edu.cn/showproblem.php?pid=3473 题意:给定一个数组,有Q次的询问,每次询问的格式为(l,r),表示寻找一个x,使得的值最小。N 思路:...

hdu 3473 Minimum Sum(划分树)

题意:给你n个数,m个查询,对于每个查询,问在区间[a,b]内找到一个数x,使得最小。 同样是划分树,只是多记录了一个sum域,表示进入左子树的数的和。 如果不懂划分树:http://blog.c...

HDU 3473 Minimum Sum 划分树

题目大意:给定一个序列,每次询问给出一个区间,我们需要选择一个数,这个数到区间内所有数的距离之和最小,求最小和 由绝对值不等式可得 当我们选择的这个数是中位数的时候距离和最小 于是这题就转换成了区间...

hdu 3473 Minimum Sum(划分树-sum操作)

划分树。只是考虑求当前区间大于第k值的值得和,和小于第k值的和。显然可以在查询的时候直接搞出来。sum[d][i]表示第d层子区间l,r种l-i的和。写错了一个下标,检查了半辈子。。。 #includ...

hdu 3473 Minimum Sum 再来一波划分树,对划分树累觉不爱。

Problem Description You are given N positive integers, denoted as x0, x1 ... xN-1. Then give you som...

HDU 3473 Minimum Sum 划分树

题目:http://acm.hdu.edu.cn/showproblem.php?pid=3473 题意:给定一个数组,给定一些区间,找到一个数,使区间内的每个数减去这个数的绝对值的和最小 ...

划分树讲解

  • 2015-04-13 22:30
  • 607KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)