description: Alice and Bob are playing a game on a matrix, consisting of 2 rows and m columns. The cell in the i-th row in the j-th column contains a_{i, j} coins in it.
  
  Initially, both Alice and Bob are standing in a cell (1, 1). They are going to perform a sequence of moves to reach a cell (2, m).
  
  The possible moves are: 
  
    * Move right — from some cell (x, y) to (x, y + 1); 
    * Move down — from some cell (x, y) to (x + 1, y). 
  
  
  
  First, Alice makes all her moves until she reaches (2, m). She collects the coins in all cells she visit (including the starting cell).
  
  When Alice finishes, Bob starts his journey. He also performs the moves to reach (2, m) and collects the coins in all cells that he visited, but Alice didn't.
  
  The score of the game is the total number of coins Bob collects.
  
  Alice wants to minimize the score. Bob wants to maximize the score. What will the score of the game be if both players play optimally?
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of testcases.
  
  Then the descriptions of t testcases follow.
  
  The first line of the testcase contains a single integer m (1 ≤ m ≤ 10^5) — the number of columns of the matrix.
  
  The i-th of the next 2 lines contain m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^4) — the number of coins in the cell in the i-th row in the j-th column of the matrix.
  
  The sum of m over all testcases doesn't exceed 10^5.
  
  Output
  
  For each testcase print a single integer — the score of the game if both players play optimally.
  
  Example
  
  Input
  
  
  3
  3
  1 3 7
  3 5 1
  3
  1 3 9
  3 5 1
  1
  4
  7
  
  
  Output
  
  
  7
  8
  0
  
  Note
  
  The paths for the testcases are shown on the following pictures. Alice's path is depicted in red and Bob's path is depicted in blue.
  
  <image>
solution: 
  #DaRk DeveLopeR
  import sys
  
  
  #taking input as string 
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
  mod = 10**9+7; Mod = 998244353; INF = float('inf')
  #______________________________________________________________________________________________________
  import math
  from bisect import *
  from heapq import *
  from collections import defaultdict as dd
  from collections import OrderedDict as odict
  from collections import Counter as cc
  from collections import deque
  from itertools import groupby
  sys.setrecursionlimit(20*20*20*20+10) #this is must for dfs
  
  
  
  def solve():
  
  	n=takein()
  
  	mat=[[-1]*n for i in range(2)]
  	# print(mat)
  
  	for i in range(2):
  
  		arr=takeiar()
  		index=0
  
  		for j in arr:
  			mat[i][index]=j
  			# print(index)
  			index+=1
  			# print(index)
  	if n==1:
  		print(0)
  		return 
  	if n==2:
  		print(min(mat[0][1],mat[1][0]))
  		return 
  	sum=0
  	for i in range(1,n):
  
  		sum+=mat[0][i]
  	ans=sum
  	temp=0
  
  	for i in range(1,n-1):
  
  		temp+=mat[1][i-1]
  		sum-=mat[0][i]
  		# print(temp)
  		temp1=max(temp,sum)
  		ans=min(temp1,ans)
  	ans=min(ans,temp+mat[1][i])
  
  	print(ans)
  	return 
  
  	
  
  
  
  
  def main():
      global tt
      if not ONLINE_JUDGE:
          sys.stdin = open("input.txt","r")
          sys.stdout = open("output.txt","w")
      t = 1
      t = takein()
      #t = 1
      for tt in range(1,t + 1):
          solve()
      if not ONLINE_JUDGE:
          print("Time Elapsed :",time.time() - start_time,"seconds")
          sys.stdout.close()
  
  #---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
  def takein():
      return (int(sys.stdin.readline().rstrip("\r\n")))
  
  
  # input the string
  
  def takesr():
      return (sys.stdin.readline().rstrip("\r\n"))
  
  
  # input int array
  def takeiar():
      return (list(map(int, sys.stdin.readline().rstrip("\r\n").split())))
  
  
  # input string array
  def takesar():
      return (list(map(str, sys.stdin.readline().rstrip("\r\n").split())))
  
  
  # innut values for the diffrent variables
  def takeivr():
      return (map(int, sys.stdin.readline().rstrip("\r\n").split()))
  
  
  def takesvr():
      return (map(str, sys.stdin.readline().rstrip("\r\n").split()))
  
   
   
  #------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
  
  
  
  def ispalindrome(s):
  
  	return s==s[::-1]
   
  def invert(bit_s):
  
  
  	  
  	# convert binary string 
  	# into integer
  	temp = int(bit_s, 2)
  	  
  	# applying Ex-or operator
  	# b/w 10 and 31
  	inverse_s = temp ^ (2 ** (len(bit_s) + 1) - 1)
  	  
  	# convert the integer result 
  	# into binary result and then 
  	# slicing of the '0b1' 
  	# binary indicator
  	rslt = bin(inverse_s)[3 : ]
  
  	return str(rslt) 	  
  
  def counter(a):
      q = [0] * max(a)
      for i in range(len(a)):
          q[a[i] - 1] = q[a[i] - 1] + 1
      return(q)
   
  def counter_elements(a):
      q = dict()
      for i in range(len(a)):
          if a[i] not in q:
              q[a[i]] = 0
          q[a[i]] = q[a[i]] + 1
      return(q)
   
  def string_counter(a):
      q = [0] * 26
      for i in range(len(a)):
          q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
      return(q)
   
  def factorial(n,m = 1000000007):
      q = 1
      for i in range(n):
          q = (q * (i + 1)) % m
      return(q)
   
  def factors(n):
      q = []
      for i in range(1,int(n ** 0.5) + 1):
          if n % i == 0: q.append(i); q.append(n // i)
      return(list(sorted(list(set(q)))))
   
  def prime_factors(n):
      q = []
      while n % 2 == 0: q.append(2); n = n // 2
      for i in range(3,int(n ** 0.5) + 1,2):
          while n % i == 0: q.append(i); n = n // i
      if n > 2: q.append(n)
      return(list(sorted(q)))
   
  def transpose(a):
      n,m = len(a),len(a[0])
      b = [[0] * n for i in range(m)]
      for i in range(m): 
          for j in range(n): 
              b[i][j] = a[j][i]
      return(b)
   
  def power_two(x):
      return (x and (not(x & (x - 1))))
   
  def ceil(a, b):
      return -(-a // b)
  
  
  
  def seive(n):
  	a = [1]
  	prime = [True for i in range(n+1)] 
  	p = 2
  	while (p * p <= n): 
  	    if (prime[p] == True): 
  	        for i in range(p ** 2,n + 1, p): 
  	            prime[i] = False
  	    p = p + 1
  	for p in range(2,n + 1): 
  	    if prime[p]: 
  	        a.append(p)
  	return(a)
  
   
  def pref(li):
      pref_sum = [0]
      for i in li:
          pref_sum.append(pref_sum[-1]+i)
      return pref_sum
   
  def kadane(x):  # maximum sum contiguous subarray
      sum_so_far = 0
      current_sum = 0
      for i in x:
          current_sum += i
          if current_sum < 0:
              current_sum = 0
          else:
              sum_so_far = max(sum_so_far, current_sum)
      return sum_so_far
  
  def binary_search(li, val):
      # print(lb, ub, li)
      ans = -1
      lb = 0
      ub = len(li)-1
      while (lb <= ub):
          mid = (lb+ub) // 2
          # print('mid is',mid, li[mid])
          if li[mid] > val:
              ub = mid-1
          elif val > li[mid]:
              lb = mid+1
          else:
              ans = mid  # return index
              break
      return ans
  
  
   
  def upper_bound(li, num):
      answer = -1
      start = 0
      end = len(li)-1
   
      while (start <= end):
          middle = (end+start) // 2
   
          if li[middle] <= num:
              answer = middle
              start = middle+1
   
          else:
              end = middle-1
      return answer  # max index where x is not greater than num
  
  
  def lower_bound(li, num):
      answer = -1
      start = 0
      end = len(li)-1
   
      while (start <= end):
          middle = (end+start) // 2
          if li[middle] >= num:
              answer = middle
              end = middle-1
          else:
              start = middle+1
      return answer  # min index where x is not less than num
  #-----------------------------------------------------------------------#
  ONLINE_JUDGE = __debug__
  if ONLINE_JUDGE:
      input = sys.stdin.readline
      
  main()