PAT A1044 Shopping in Mars (25 分) 二分

题目大意：给出一个正数序列，在当中找到满足这样条件的连续子串：子串的和大于等于给定值。输出具有最小的和的子串的开始和结束位置的下标(从1开始计)，如果这样的子串有两个以上，按照开始位置从小到大，输出所有子串的开始和结束位置。

一开始直接暴力遍历所有子串，并维护最小的子串和。但这样还是有两个测试点超时，开始位置肯定是需要遍历序列的每个元素的，那么减少耗时的主要方法就是如何查找结束位置，问题就转换为：固定开始位置，找到结束位置，使得这个子串的和是从开始位置到整个序列结尾的最小的大于等于M的数。应该是用二分来查找，这样就首先要在输入时，记录每个位置相对于位置1的子串和，那么从位置 i 到 位置 j 的和可以表示为 sumFromFirst[ j ] - sumFromFirst [ i - 1 ]. 之后就是遍历 i, 用二分查找 j。但这里还有一个问题，找到的 j 并不一定是 和等于 M的位置，如果和不能等于M，需要输出大于M的最小值的位置。所以这里用一个数组，来存储二分过程中所有和大于等于M的位置，那么要求的应当是最后一个加入数组的元素，无论最后的和是等于M还是大于M。遍历 i 的同时，维护最小的子串和。最后输出。

AC代码：

#include <vector>
#include <cstdio>
#include <map>

using namespace std;

void search(vector<int> &sumFromFirst, int left, int right, int M, int i, vector<int> &upperBound)
{
    if(left > right) return;
    int mid = (left + right) / 2;
    if(sumFromFirst[mid] - sumFromFirst[i - 1] == M)
    {
        upperBound.push_back(mid);
        return;
    }
    else if(sumFromFirst[mid] - sumFromFirst[i - 1] > M)
    {
        upperBound.push_back(mid);
        search(sumFromFirst, left, mid-1, M, i, upperBound);
    }
    else search(sumFromFirst, mid+1, right, M, i, upperBound);
}

int main()
{
    int minPayment = 0x7FFFFFFF;
    int N, M;
    scanf("%d%d", &N, &M);
    vector<int> sumFromFirst(N + 1);
    map<int, vector<pair<int, int>>> mp;
    for (int i = 1; i <= N; ++i)
    {
        int tmp;
        scanf("%d", &tmp);
        if(i == 1) sumFromFirst[i] = tmp;
        else sumFromFirst[i] = sumFromFirst[i-1] + tmp;
    }
    for (int i = 1; i <= N; ++i)
    {
        vector<int> upperBound;
        search(sumFromFirst, i, N, M, i, upperBound);
        if(upperBound.size() > 0)
        {
            int j = upperBound[upperBound.size() - 1];
            int sum = sumFromFirst[j] - sumFromFirst[i-1];
            if(sum < minPayment)
            {
                minPayment = sum;
                mp[minPayment].push_back(make_pair(i, j));
            }
            else if(sum == minPayment)
                mp[minPayment].push_back(make_pair(i, j));
        }
    }
    for (int i = 0; i < mp[minPayment].size(); ++i)
    {
        printf("%d-%d\n", mp[minPayment][i].first, mp[minPayment][i].second);
    }
    return 0;
}

思路更简洁的解法：固定开始位置，寻找结束位置使得这一段的总和大于等于M且最小，显然在右端点左移的过程中得到的和是不断减小的，每次得到的和大于等于M时更新可能的最小和，那么当退出二分查找函数时得到的和就是固定开始位置能得到的大于等于M的最小和：

#include <bits/stdc++.h>

using namespace std;

int findSolution(int start, int M, vector<int> &sumFromFirst, int &end)
{
    int left = start, right = sumFromFirst.size() - 1;
    int minSum = sumFromFirst[start] - sumFromFirst[start - 1];
    while(left <= right)
    {
        int mid = left + (right - left) / 2;
        int sum = sumFromFirst[mid] - sumFromFirst[start - 1];
        if(sum == M)
        {
            minSum = M;
            end = mid;
            break;
        }
        else if(sum > M)
        {
            minSum = sum;
            end = mid;
            right = mid - 1;
        }
        else left = mid + 1;
    }
    return minSum;
}

int main()
{
    int N, M;
    scanf("%d%d", &N, &M);
    vector<int> sumFromFirst(N+1, 0);
    for (int i = 1; i <= N; ++i)
    {
        int value;
        scanf("%d", &value);
        sumFromFirst[i] = sumFromFirst[i-1] + value;
    }
    int minSum = INT_MAX;
    vector<pair<int, int>> ret;
    for (int i = 1; i <= N; ++i)
    {
        int end = i;
        int tempMinSum = findSolution(i, M, sumFromFirst, end);
        if(tempMinSum >= M && tempMinSum < minSum)
        {
            minSum = tempMinSum;
            ret.clear();
            ret.push_back(make_pair(i, end));
        }
        else if(tempMinSum == minSum)
        {
            ret.push_back(make_pair(i, end));
        }
    }
    for (int i = 0; i < ret.size(); ++i)
    {
        printf("%d-%d\n", ret[i].first, ret[i].second);
    }
    return 0;
}

因为sumFromFrist[index] - sumFromFirst[left-1]返回的就是 [left, index] 这一段的总和，应当大于等于M，因此可以固定 left， 使用 lower_bound函数寻找 sumFromFirst数组中满足大于等于 M + sumFromFirst[left - 1] 的第一个元素的位置。

#include<cstdio>
#include<iostream>
#include<vector>
#include<map>
#include<queue>
#include<set>
#include<string>
#include<algorithm>
#include<climits>
#pragma warning(disable : 4996)

using namespace std;

int minSum = INT_MAX, N, M;;
set<pair<int, int>> solution;
vector<int> sumFromZero;
void findSolution(int start)
{
	int index = lower_bound(sumFromZero.begin(), sumFromZero.end(), M + sumFromZero[start - 1]) - sumFromZero.begin();
	if (index > N) return;
	int sum = sumFromZero[index] - sumFromZero[start - 1];
	if (minSum > sum && sum >= M)
	{
		minSum = sum;
		solution.clear();
		solution.insert(make_pair(start, index));
	}
	else if (minSum == sum && sum >= M)
		solution.insert(make_pair(start, index));
}

int main()
{
	scanf("%d%d", &N, &M);
	sumFromZero = vector<int>(N + 1, 0);
	for (int i = 1; i <= N; i++)
	{
		int val;
		scanf("%d", &val);
		sumFromZero[i] = sumFromZero[i - 1] + val;
	}
	for (int i = 1; i <= N; i++)
	{
		findSolution(i);
	}
	for (auto it = solution.begin(); it != solution.end(); it++)
	{
		printf("%d-%d\n", it->first, it->second);
	}
	system("pause");
	return 0;
}