获得最多的奖金

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {

    /**
     * 双指针思想:
     * 左右指针遍历数组找左边数组的和和右边数组的和比较来移动指针
     * 1.相等则保存当前值，左指针右移，右指针左移动
     * 2.左边和 > 右边和  右指针左移
     * 3.左边和 < 右边和  左指针右移
     */
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(bf.readLine());
        String[] line2 = bf.readLine().split(" ");
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = Integer.parseInt(line2[i]);
        }
        int left = 0, right = n - 1;
        long left_sum = nums[left], right_sum = nums[right], max_sum = 0;
        while (left < right) {
            if (left_sum == right_sum){
                max_sum = left_sum;
                left_sum += nums[++left];
                right_sum += nums[--right];
            }else if (left_sum > right_sum){
                right_sum += nums[--right];
            }else {
                left_sum += nums[++left];
            }
        }
        System.out.println(max_sum);
    }
}

import sys
n=int(sys.stdin.readline().strip())
arr=list(map(int,sys.stdin.readline().split()))
left,right=0,n-1
lsum,rsum=arr[0],arr[-1]
res=0
while left<right:
    if lsum<rsum:
        left+=1
        lsum+=arr[left]
    if lsum>rsum:
        right-=1
        rsum+=arr[right]
    if lsum==rsum:
        res=lsum
        left+=1
        right-=1
        lsum+=arr[left]
        rsum+=arr[right]
print(res)

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    int number;
    cin>>number;
    vector<int> vect;
    while(number--)
    {
        int temp=0;
        cin>>temp;
        vect.push_back(temp);
    }
        long long sum_right=0;
        long long sum_left=0;
        int left=0;
        int right=vect.size()-1;
        long long result;
        while(left<=right)
        {
            if(sum_right==sum_left&&left!=right)
            {
                sum_left+=vect[left];
                sum_right+=vect[right];
                left++;
                right--;
            }
            else if(sum_left>sum_right)
            {
                sum_right+=vect[right];
                right--;
            }
            else
            {
                sum_left+=vect[left];
                left++;
            }
            if(sum_right==sum_left)
            {
                result=sum_right;
            }
        }
    cout<<result<<endl;
    return 0;
}

/*
从左右两端共进。
若当前左端大于右端，右端前进一个。
若当前左端小于右端，左端前进一个。
如当前左端等于右端，左右两端都前进一个。
然后再判断左右两端和是否相等，若相等则更新答案。
左端坐标大于右端坐标时，跳出循环。
O(n)。
细节处理：需要用long类型。
当走到中间只剩一个数时，左右两端相等，不能再同时前进了。
*/
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }
        long ans = 0;
        int left = 0;
        int right = n - 1;
        long sumLeft = 0;
        long sumRight = 0;
        while (left <= right) {
            if (sumLeft == sumRight && left != right) {
                sumLeft += arr[left];
                sumRight += arr[right];
                left++;
                right--;
            } else if (sumLeft > sumRight) {
                sumRight += arr[right];
                right--;
            } else {
                sumLeft += arr[left];
                left++;
            }
            if (sumLeft == sumRight) {
                ans = sumLeft;
            }
        }
        System.out.println(ans);
    }
}

import java.util.*;
public class Main{
    //思路：
    //1.定义左指针跟右指针，分别指向第一个红包和最后一个红包
    //2.左指针指向数据和 > 右指针指向数据和，左指针++；
    //3.左指针指向数据和 < 右指针指向数据和，右指针--；
    //4.左指针指向数据和 = 右指针指向数据和，左指针++，右指针--；
    //约束条件是左指针 < 右指针。
    //需要注意的是所有求和的值都要设为long型，会超过int最大范围。
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();//红包个数
        int[] d = new int[n];//每个红包奖金数额
        for(int i = 0; i < n; i++){
            d[i] = sc.nextInt();
        }
        int left = 0;
        long leftSum = d[left];
        int right = n - 1;
        long rightSum = d[right];
        long max = 0;
        while(left < right){
            if(leftSum < rightSum){
                left++;
                leftSum += d[left];
            }
            if(leftSum > rightSum){
                right--;
                rightSum += d[right];
            }
            if(leftSum == rightSum){
                max = leftSum;
                left++;
                right--;
                leftSum += d[left];
                rightSum += d[right];
            }
        }
        System.out.println(max);
    }
}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] d = new int[n];
        for (int i = 0; i < n; i++) {
            d[i] = sc.nextInt();
        }
        if (n == 1) {
            System.out.println(0);
            return;
        }
        int i = 0, j = n-1;
        long sum1 = d[0];
        long sum2 = d[j];
        long res = 0;
        while (i < j) {
            if (sum1 == sum2) {
                res = sum1;
                i++;
                j--;
                if (i < j) {
                    sum1 += d[i];
                    sum2 += d[j]; 
                } 
            } else if (sum1 < sum2) {
                i++;
                if (i < j) sum1 += d[i];
            } else {
                j--;
                if (i < j) sum2 += d[j];
            }

        }
        System.out.println(res);
    }
}

a,b = int(input()),list(map(int,input().split()))
p,q,s,t = 0,a - 1,0,0
while p - 1 < q + 1:
    if s < t:
        p,s = p + 1,s + b[p]
    elif s > t:
        q,t = q - 1,t + b[q]
    else:
        p,q,r,s,t = p + 1,q - 1,s,s + b[p],t + b[q]
print(r)

// 这题就是贪心算法
// 算法复杂度O(n)，额外的O(n)的空间复杂度
// 第一次输入的时候， 用一个数组把累计金额算出来，并且存入sumArray 这个辅助数组
// 第二次遍历的时候，就可以算出尾部的累计值。
// 然后用个result 记录 head <= tail 这个过程中头部和尾部累加相等的值。
// 其实不需要比大小， 累加正整数肯定是最新的最大。

#include<iostream>
#include<vector>
using namespace std;

int main(){
    int numCount = 0;
    int head = 0;
    long long sumTail = 0;
    long long result = 0;
    vector<int> array;
    cin >> numCount;
    vector<long long> sumArray(numCount,0);
    int tail = numCount - 1;
    if (numCount < 2){
        cout<< 0 << endl;
        return 0;
    }
    int tmp = 0;
    for (int i = 0; i != numCount; i++) {
        cin >> tmp;
        array.push_back(tmp);
        if (i >= 1) sumArray[i] = sumArray[i-1] + tmp;
        else sumArray[i] = tmp;
    }
    sumTail = array[tail];
    while(head <= tail){
        if (sumArray[head] < sumTail) {
            head ++;
        } else if (sumArray[head] == sumTail) {
            result = sumArray[head];
            head++;
        } else {
            tail --;
            sumTail += array[tail];
        }
    }
    cout<< result << endl;
    return 0;

}

#include<bits/stdc++.h>
using namespace std;
/*先求出总和的数组，然后求出平均数,从总和数组开始位置逐个和平均数比较，确定i、j位置,
 * left为0~i总和，right为j~n-1总和，用双指针i、j从中间往两边走，循环直到left=right为止*/
int main(){
    long n,arr[200000],sum[200000],left=0,right=0;
    cin>>n>>arr[0];
    sum[0]=arr[0];
    for(long i=1;i<n;i++){
        cin>>arr[i];
        sum[i]=sum[i-1]+arr[i]; //最右边为总和
    }
    long i,j,avg=sum[n-1]/2;
    for(int k=0;k<n;k++)
        if(sum[k]>avg&&k>0){
            j=k;    //j~n-1范围
            i=k-1;  //0~i范围
            break;
        }
    left=sum[i];    //左边总和
    right=sum[n-1]-sum[i];  //右边总和
    while(left!=right&&i>=0&&j<n) {  //直到相等就退出
        if(left>right&&i>=0)
            left-=arr[i--];
        if(right>left&&j<n)
            right-=arr[j++];
    }
    cout<<left;
    return 0;
}

//双指针，两边同时开始计算总和，哪边比另外一边小就往前走一步，直到两边一样就更新最大值


#include <iostream>
#include<set>
#include<map>
#include<vector>
#include<algorithm>
#include<math.h>
//#include<

using namespace std;

int main()
{
    int num ;
    cin>>num;
    vector<unsigned long long>num_vec(num);
    for(int i = 0;i<num;i++)
    {
        cin>>num_vec[i];
    }

    unsigned long long left = 0,right=num-1,ans_left = 0,ans_right = 0;
    unsigned long long left_sum = num_vec[left];
    unsigned long long right_sum = num_vec[right];
    unsigned long long res = 0;

    while(left<right)
    {
        if(left_sum == right_sum)
        {
            res = left_sum;
            left++;
            right--;
            if(left<right)
            {
                right_sum += num_vec[right];
                left_sum += num_vec[left];
            }
        }else if(left_sum > right_sum){
            right--;
            right_sum += num_vec[right];
        }else{
            left++;
            left_sum += num_vec[left];
        }
    }
    cout<<res<<endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <climits>
using namespace std;
int main() {
    int n;
    cin >> n;
    vector<int> nums(n);
    long  f2l = 0 , l2f = 0;
    for (int i = 0; i < n; ++i) {
        cin >> nums[i];
    }
    int l = 0, r = n - 1;
    f2l = nums[l];
    l2f = nums[r];
    long  ans = 0;
    while (l < r){
        if(f2l == l2f && f2l > ans) {
            ans = f2l;
            l ++;
            f2l += nums[l];
        }
        if(f2l < l2f) {
            l ++;
            f2l += nums[l];
        }
        else if (l2f < f2l) {
            r--;
            l2f += nums[r];
        }
    }
    cout << ans;
    return 0;
}

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

int main(){
    int n;
    while(cin>>n){
        ll d[n], Max=0, left=0, right=0;
        for(int i=0;i<n;i++)
            cin>>d[i];
        for(int l=-1,r=n;l<r;){
            if(left == right){
                Max = max(Max, left);
                l++;
                left += d[l];
                r--;
                right += d[r];
            }else if(left < right){
                l++;
                left += d[l];
            }else{
                r--;
                right += d[r];
            }
        }
        cout<<Max<<endl;
    }

    return 0;
}

"""
i从前往后求和，j从后往前求和，
当求和相等更新ans，并继续遍历
更新求和小的一侧，直到i>=j停止
ans即为所求
"""
import sys

if __name__ == "__main__":
    # sys.stdin = open('input.txt', 'r')
    n = int(input().strip())
    d = list(map(int, input().strip().split()))
    ans = 0
    i, j, sum_i, sum_j = -1, n, 0, 0
    while i < j:
        if sum_i == sum_j:
            ans = sum_i
            i += 1
            j -= 1
            sum_i += d[i]
            sum_j += d[j]
        elif sum_i > sum_j:
            j -= 1
            sum_j += d[j]
        else:
            i += 1
            sum_i += d[i]
    print(ans)

	

双指针算法

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 2e5 + 10;
int n;
int d[N];

int main() {
    cin >> n;
    for(int i = 0; i < n; i++) scanf("%d", &d[i]);
    LL res = 0;
    LL sum1 = 0;
    LL sum2 = 0;
    for(int i = 0, j = n - 1; i < j;) {
        sum1 += d[i];
        sum2 += d[j];
        if(sum1 < sum2) {
            i++;
            sum2 -= d[j];
        }
        else if(sum1 > sum2) {
            j--;
            sum1 -= d[i];
        }
        else {
            res = sum1;
            i++;
            j--;
        }
    }
    cout << res << endl;
    return 0;
}

while True:
    try:
        n = int(input())
        lis = list(map(int,input().split(' ')))
        Money_gain = 0

        right = n-1
        left = 0

        sum1 = lis[left]
        sum2 = lis[right]

        while left < right:
            if sum1 == sum2:
                Money_gain = max(Money_gain,sum1)
                left += 1
                right -= 1
                sum1 += lis[left]
                sum2 += lis[right]
            elif sum1 > sum2 :
                right -= 1
                sum2 += lis[right]
            else:
                left += 1
                sum1 += lis[left] 
        print(Money_gain)     
    except:
        break