codeforce 227D Naughty Stone Piles (贪心+递归+递推)
Description There are n piles of stones of sizes a1, a2, …, an lying on the table in front of you.
During one move you can take one pile and add it to the other. As you add pile i to pile j, the size of pile j increases by the current size of pile i, and pile i stops existing. The cost of the adding operation equals the size of the added pile.
Your task is to determine the minimum cost at which you can gather all stones in one pile.
To add some challenge, the stone piles built up conspiracy and decided that each pile will let you add to it not more than k times (after that it can only be added to another pile).
Moreover, the piles decided to puzzle you completely and told you q variants (not necessarily distinct) of what k might equal.
Your task is to find the minimum cost for each of q variants.
Input The first line contains integer n (1 ≤ n ≤ 105) — the number of stone piles. The second line contains n space-separated integers: a1, a2, …, an (1 ≤ ai ≤ 109) — the initial sizes of the stone piles.
The third line contains integer q (1 ≤ q ≤ 105) — the number of queries. The last line contains q space-separated integers k1, k2, …, kq (1 ≤ ki ≤ 105) — the values of number k for distinct queries. Note that numbers ki can repeat.
Output Print q whitespace-separated integers — the answers to the queries in the order, in which the queries are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples input 5 2 3 4 1 1 2 2 3 output 9 8 Note In the first sample one way to get the optimal answer goes like this: we add in turns the 4-th and the 5-th piles to the 2-nd one; then we add the 1-st pile to the 3-rd one; we add the 2-nd pile to the 3-rd one. The first two operations cost 1 each; the third one costs 2, the fourth one costs 5 (the size of the 2-nd pile after the first two operations is not 3, it already is 5).
In the second sample you can add the 2-nd pile to the 3-rd one (the operations costs 3); then the 1-st one to the 3-th one (the cost is 2); then the 5-th one to the 4-th one (the costs is 1); and at last, the 4-th one to the 3-rd one (the cost is 2).
这道题的题意是合并石子,给你n堆石子,每堆石子最多选取K堆石子合并到这堆石子,合并一堆石子代价是石子的数量。 首先我们先排序,排序后的石子数量是a[1] a[2]……a[n],对于每一堆合并之后最后一次合并必然所有堆合到堆代价为sum(石子总数-a[i]) 当i==n时,代价最小。在讨论前n-1堆和并的问题,前n-1和并的代价最小是分成K堆加到第n堆最小,则对于前n-1堆就要分成k堆,对于K堆的每一堆又要分成K堆最小,不断递归据可以得到最终结果,但是递归之后容易超时,容易爆栈,改写为递推,那么对于前K堆合并的代价是sum[n-1],那么对于K堆的K堆合并的sum[n-1-k],对于K堆的K堆的K堆合并的代价就是sum[n-1-k*k],当这个值小于1的时候,就没有石子可以合并了,于是可以写出代码
#include <bits/stdc++.h>
using namespace std;
const int MAX=999990;
long long int a[MAX] = {0};
long long int sum[MAX] = {0};
long long int m, q,x,y;
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
sort(a+1, a+n+1);
for(int i=1;i<=n;i++) a[i] += a[i-1];//前缀和
cin>>m;
while(m--)
{
cin>>q;
if(q>=n) cout<<a[n-1]<<' ';
else{
x = n - 1;
y = q;
if(sum[q]==0) //如果重复出现就不用计算了,不然会超时
while(x>=1)
{
sum[q] += a[x];
x -=y;
y *= q;
}
cout<<sum[q]<<' ';
}
}
return 0;
}
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法