【发布时间】：2013-06-18 13:56:29
【问题描述】：
我正在努力解决这个问题：
小女孩有一个包含 n 个元素的数组（数组的元素从 1 开始索引）。
此外，还有“q”个查询，每个查询由一对整数li, ri (1 ≤ li ≤ ri ≤ n)定义。您需要为每个查询找到索引从 li 到 ri 的数组元素的总和。
小女孩觉得这个问题很无聊。她决定在回复查询之前重新排序数组元素，以使查询回复的总和尽可能大。你的任务是找出这个最大和的值。
输入：
第一行包含两个以空格分隔的整数 n (1 ≤ n ≤ 10^5) 和 q (1 ≤ q ≤ 10^5) — 数组中元素的数量和查询的数量。
下一行包含 n 个以空格分隔的整数 ai (1 ≤ ai ≤ 10^5) — 数组元素。
以下 q 行中的每一行都包含两个以空格分隔的整数 li 和 ri (1 ≤ li ≤ ri ≤ n) — 第 i 个查询。
输出：
在一行中打印一个整数——数组元素重新排序后查询回复的最大总和。
Sample testcases:
input:
3 3
5 3 2
1 2
2 3
1 3
output
25
input
5 3
5 2 4 1 3
1 5
2 3
2 3
output
33
我了解段树，所以我通过段树应用了惰性传播方法。
我的努力代码：
#include <iostream>
#include <string>
#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>
#include <set>
#include <list>
#include <cmath>
#include <stack>
using namespace std;
#define scan(x) scanf("%d",&x)
#define print(x) printf("%d ",x)
#define println(x) printf("%d\n",x)
#define For(i,a,j,k) for (i = a; i < j; i+= k)
#define For_back(i,a,j,k) for (i = j; i >= a; i-= k)
#define SET(a,x) memset(a,x,sizeof(a))
#define mod 1000000007
#define inf 0x7fffffff
#define Max 2000000
typedef pair<int,int> pii;
typedef pair<pii,int> piii;
long long int tree[3*Max];
long long int lazy[3*Max];
void update(int node,int a,int b,int i,int j,long long int value)
{
if (lazy[node]!= 0)
{
tree[node] += lazy[node];
if (a != b)
{
lazy[2*node] += lazy[node];
lazy[2*node+1] += lazy[node];
}
lazy[node] = 0;
}
if (a > b || a > j || b < i)
return;
if (a >= i && b <= j)
{
tree[node] += value;
if (a != b)
{
lazy[2*node] += value;
lazy[2*node+1] += value;
}
return;
}
int mid = (a+b)/2;
update(2*node,a,mid,i,j,value);
update(2*node+1,mid+1,b,i,j,value);
tree[node] = (tree[2*node]+tree[2*node+1]);
}
long long int query(int node,int a,int b,int i,int j)
{
if (a> b || a > j || b < i) return 0;
if (lazy[node] != 0)
{
tree[node] += lazy[node];
if (a != b)
{
lazy[2*node] += lazy[node];
lazy[2*node+1] += lazy[node];
}
lazy[node] = 0;
}
if (a >= i && b <= j)
return tree[node];
int mid = (a+b)/2;
long long int q1 = query(2*node,a,mid,i,j);
long long int q2 = query(2*node+1,mid+1,b,i,j);
return ((q1+q2));
}
int main()
{
SET(lazy,0);
SET(tree,0);
int n,m;
cin >> n >> m;
int i,j;
int arr[n];
For(i,0,n,1)
{
cin >> arr[i];
}
sort(arr,arr+n);
For(i,0,m,1)
{
long long int num1,num2;
cin >> num1 >> num2;
update(1,0,n-1,num1-1,num2-1,1);
}
long long int my[n];
For(i,0,n,1)
{
long long int number = query(1,0,n-1,i,i);
my[i] = number;
}
sort(my,my+n);
long long int sum = 0;
For_back(i,0,n-1,1){
sum += my[i]*arr[i];
}
cout << sum << endl;
return 0;
}
我的方法很简单，就像使用段树所说的那样，最后打印答案。
我的问题是有没有更简单的算法呢？还是我应该优化我的段树代码？
【问题讨论】：
-
这个问题在codereview.stackexchange.com上可能更好。
-
看起来像是一场编码竞赛挑战/问题。
-
这不是代码审查，而是算法问题。我觉得完全可以接受。
-
“更快”更简单还是“更少代码”更简单？
-
是的。我不是要代码！我只是要求一个出色的算法。
标签： c++ algorithm data-structures segment-tree