2016年中国大学生程序设计竞赛（杭州） A ArcSoft's Office Rearrangement（贪心）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5933
ArcSoft’s Office Rearrangement

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 288 Accepted Submission(s): 134

Problem Description
ArcSoft, Inc. is a leading global professional computer photography and computer vision technology company.

There are N working blocks in ArcSoft company, which form a straight line. The CEO of ArcSoft thinks that every block should have equal number of employees, so he wants to re-arrange the current blocks into K new blocks by the following two operations:

• merge two neighbor blocks into a new block, and the new block’s size is the sum of two old blocks’.
• split one block into two new blocks, and you can assign the size of each block, but the sum should be equal to the old block.

Now the CEO wants to know the minimum operations to re-arrange current blocks into K block with equal size, please help him.

Input
First line contains an integer T, which indicates the number of test cases.

Every test case begins with one line which two integers N and K, which is the number of old blocks and new blocks.

The second line contains N numbers a1, a2, ⋯, aN, indicating the size of current blocks.

Limits
1≤T≤100
1≤N≤105
1≤K≤105
1≤ai≤105

Output
For every test case, you should output ‘Case #x: y’, where x indicates the case number and counts from 1 and y is the minimum operations.

If the CEO can’t re-arrange K new blocks with equal size, y equals -1.

Sample Input
3
1 3
14
3 1
2 3 4
3 6
1 2 3

Sample Output
Case #1: -1
Case #2: 2
Case #3: 3

【题目大意】
每块石头都有一定的重量，现给你n块石头，问你最少要经过多少次操作可以把他们可以合为k块石头，如果不能合成k块石头，输出-1。
对石头的处理规则：
合并石块只能合并相邻的石块，分裂石块的话只能把它分为相邻的两块。
合并后石块的重量为他们的和。

【思路分析】先判断n块石头的总重量是不是k的倍数，假如是k的倍数的话，然后判断每一个石块对（sum/k）取余取多少次，假如能整除的话是分裂几次，不能整除的话是分裂几次，然后把剩余重量的石块给下一个石块，最后便可求出最小操作次数。
【AC代码】

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long

LL a[100005];
int main()
{
    int n,t,iCase=0;
    LL k;
    scanf("%d",&t);
    while(t--)
    {
        LL sum=0;
        scanf("%d%lld",&n,&k);
        for(int i=1; i<=n; i++)
        {
            scanf("%I64d",&a[i]);
            sum+=a[i];
        }
        printf("Case #%d: ",++iCase);
        LL ss=sum/k;//用int的话会爆掉数据
        int re=0;
        if(sum%k==0)
        {
            for(int i=1; i<=n; i++)
            {
                if(a[i]==ss)
                    continue;
                if(a[i]<ss)
                {
                    a[i+1]+=a[i];
                    re++;
                }
                else
                {

                    if(a[i]%ss==0)//能整除的情况
                    {
                        re+=(a[i]/ss-1);
                    }
                    else//不能整除的情况
                    {
                        re+=a[i]/ss;
                        a[i+1]+=(a[i]%ss);
                        re++;
                    }
                }
            }
            printf("%d\n",re);
        }
        else
        {
            printf("-1\n");
        }
    }
    return 0;
}