PAT Grade --A1044 Shopping in Mars

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:

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).
Cut before 5 or after 6, and take off the diamonds from the position 4 to 6 (with values 5+4+6=15).
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:

Output Specification:

For each test case, print i-j in a line for each pair of i $\leq j such that$

If there is no solution, output i-j for pairs of i $\leq j such that$

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

[Title] Italy

A sequence of numbers with a given number S, and obtains all the consecutive sequences in the digital value of the sequence S (small scale interval left first output point, the left end of the same small dot to the right end of the output). Without such a sequence, and obtains a value just greater than the sub-sequence S (i.e. subsequence and all values greater than the S value closest and S). Suppose a sequence of indices from the beginning.

. 1 #include <the iostream>
 2 #include <Vector>
 . 3  the using  namespace STD;
 . 4  // violent solution, complexity is O (N), did not pass the test, times out 
. 5  int N, M;
 . 6 Vector < int > value, SUM ;
 . 7 Vector <pair < int , int >> RES, MINRES; // RES stored value is equal to exactly cut the payment value, min is the minimum value stored cut 
. 8  void Way1 ()
 . 9  {
 10      int MINV = M;
 . 11      for ( int = I . 1 ; I <= N; ++ I)
 12 is     {
13         int s = 0;
14         for (int j = i; j <= N; ++j)
15         {
16             s += value[j];
17             if (s < M)continue;
18             else if (s == M)
19                 res.push_back(make_pair(i, j));
20             else if (s > M)
21             {
22                 if (minV == (s - M))
23                     minRes.push_back(make_pair(i, j));
24                 the else  IF (MINV> (S - M))
 25                  {
 26 is                      MINV = S - M;
 27                      minRes.clear ();
 28                      minRes.push_back (the make_pair (I, J));
 29                  }
 30              }
 31 is              BREAK ;
 32          }
 33 is      }    
 34  }
 35  // second method using dichotomy 
36  int upper_bound, ( int L, int & Temps)
 37 [  {
 38 is      int left = L, right = N, mid;
39     while (left < right)
40     {
41         mid = (left + right) / 2;
42         if (sum[mid]-sum[L-1] >= M)
43             right = mid;
44         else
45             left = mid + 1;
46     }
47     tempS = sum[right] - sum[L - 1];
48     return right;
49 }
50 
51 void Way2()
52 {
53     int minV = sum[N], tempS;
54     for (int i = 1; i <= N; ++i)//左端
55     {
56         int j = upper_bound(i, tempS);
57         if (tempS >minV)continue;
58         else if (tempS >= M)
59         {
60             if (tempS < minV)
61             {
62                 res.clear();
63                 minV = tempS;
64             }
65             res.push_back(make_pair(i, j));
66         }
67     }
68 }
69 
70 int main()
71 {
72     cin >> N >> M;
73     value.resize(N + 1);
74     sum.resize(N + 1);
75     for (int i = 1; i <= N; ++i)
76     {
77         cin >> value[i];
78         sum[i] = sum[i - 1] + value[i];
79     }
80     Way2();
81     if (res.size() > 0)
82         for (auto a : res)
83             cout << a.first << "-" << a.second << endl;
84     else
85         for (auto a : minRes)
86             cout << a.first << "-" << a.second << endl;
87     return 0;
88 }