PAT 1044 Shopping in Mars (25分)

Shopping in Mars is quite a different experience. The Mars people pay by chained diamonds. Each diamond has a value (in Mars dollars M$). When making the payment, the chain can be cut at any position for only once and some of the diamonds are taken off the chain one by one. Once a diamond is off the chain, it cannot be taken back. For example, if we have a chain of 8 diamonds with values M$3, 2, 1, 5, 4, 6, 8, 7, and we must pay M$15. We may have 3 options:

1. Cut the chain between 4 and 6, and take off the diamonds from the position 1 to 5 (with values 3+2+1+5+4=15).
2. Cut before 5 or after 6, and take off the diamonds from the position 4 to 6 (with values 5+4+6=15).
3. Cut before 8, and take off the diamonds from the position 7 to 8 (with values 8+7=15).

Now given the chain of diamond values and the amount that a customer has to pay, you are supposed to list all the paying options for the customer.

If it is impossible to pay the exact amount, you must suggest solutions with minimum lost.

Input Specification:

Each input file contains one test case. For each case, the first line contains 2 numbers: N (≤10​5​​), the total number of diamonds on the chain, and M (≤10​8​​), the amount that the customer has to pay. Then the next line contains N positive numbers D​1​​⋯D​N​​ (D​i​​≤10​3​​ for all i=1,⋯,N) which are the values of the diamonds. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print i-j in a line for each pair of i ≤ j such that Di + ... + Dj = M. Note that if there are more than one solution, all the solutions must be printed in increasing order of i.

If there is no solution, output i-j for pairs of i ≤ j such that Di + ... + Dj >M with (Di + ... + Dj −M) minimized. Again all the solutions must be printed in increasing order of i.

It is guaranteed that the total value of diamonds is sufficient to pay the given amount.

Sample Input 1:

16 15
3 2 1 5 4 6 8 7 16 10 15 11 9 12 14 13

Sample Output 1:

1-5
4-6
7-8
11-11

Sample Input 2:

5 13
2 4 5 7 9

Sample Output 2:

2-4
4-5

 

题目大意：给定n个整数，让你在n个整数之间进行划分，使划分出的整数的和为m（从第i个数到第j个数），按i从递增的顺序输出每一种划分情况（格式为i-j），若不能无论如何划分出的整数的和也不为m，那么则输出整数和大于m并最接近m的那个整数和的划分。

 

分析：使用前缀和存储数据，这样可以省去循环求和所用时间。

前缀和指的是一个数组的某项下标之前(包括此项元素)的所有数组元素的和。

设前缀和数组为sum,那么第j+1 ~~ i个元素的和为sum[i]-sum[j+1]，只需要判断sum[i]-sum[j+1]能否等于m即可

大体思路就是两层循环，外层循环控制i，内层循环控制j，枚举sum[i]-sum[j+1]即可。

由于最后要求是按i递增的顺序输出，那么每次枚举的时候，j不需要第一个元素开始找，只需要接着上次的位置找，也就是说j在整个过程中从0到了n，外层循环i从1到了n，因此时间复杂度为n+n，若每次j从0开始找，那么最差情况时间复杂度是n^2，这样测试点3会超时.

 

#include<bits/stdc++.h>
using namespace std;

int main()
{
    long long sum[100010];
    int n,m,x,i,j;
    cin>>n>>m;
    sum[0]=0;
    int f=0;
    long long minn=0x3f3f3f3f;
    j=0;
    for(i=1; i<=n; i++)
    {
        scanf("%d",&x);
        if(i==1)
        {
            sum[i]=x;
        }
        else
        {
            sum[i]=sum[i-1]+x;
        }
        /*这里退出循环意味着sum[i]-sum[j],那么i++后sum[i]增大了，sum[i]-sum[1....j-1]均会大            
          于m，所以只需要判断当前sum[i]-sum[j]是否大于m即可
        */
        while(sum[i]-sum[j]>m)   
        {
            minn=min(minn,sum[i]-sum[j]);
            j++;
        }
        if(sum[i]-sum[j]==m)
        {
            f=1;
            printf("%d-%d\n",j+1,i);
        }
    }
    if(f==0)
    {
        j=0;
        for(i=1; i<=n; i++)
        {
            
            while(sum[i]-sum[j]>minn)
            {
                j++;
            }
            if(sum[i]-sum[j]==minn)
            {
                printf("%d-%d\n",j+1,i);
            }
        }
    }


}