Zonal Computing Olympiad 2014, 30 Nov 2013

In IPL 2025, the amount that each player is paid varies from match to match.  The match fee depends on the quality of opposition, the venue etc.

The match fees for each match in the new season have been announced in advance.  Each team has to enforce a mandatory rotation policy so that no player ever plays three matches in a row during the season.

Nikhil is the captain and chooses the team for each match. He wants to allocate a playing schedule for himself to maximize his earnings through match fees during the season.  

-----Input format-----
Line 1: A single integer N, the number of games in the IPL season.
Line 2: N non-negative integers, where the integer in
position i represents the fee for match i.

-----Output format-----
The output consists of a single non-negative integer, the
maximum amount of money that Nikhil can earn during this IPL
season. 

-----Sample Input 1-----
5 
10 3 5 7 3 

-----Sample Output 1-----
23

(Explanation: 10+3+7+3)

-----Sample Input 2-----
8
3 2 3 2 3 5 1 3

-----Sample Output 2-----
17

(Explanation: 3+3+3+5+3)

-----Test data-----
There is only one subtask worth 100 marks.  In all inputs:

• 1 ≤ N ≤ 2×105
• The fee for each match is between 0 and 104, inclusive.

-----Live evaluation data-----
There are 12 test inputs on the server during the exam.

Difficulty: UNKNOWN_DIFFICULTY

Starter code:

Solutions:
n = int(input())
l = list(map(int, input().split()))
temp = []
for item in l:
	temp.append(item)
if n <= 3:
	print(sum(temp))
else:
	for i in range(3, n):
		temp[i] = l[i] + min(temp[i - 1], temp[i - 2], temp[i - 3])
	res = sum(l) - min(temp[n - 1], temp[n - 2], temp[n - 3])
	print(res)


n = int(input())
arr = [int(x) for x in input().split()]

def solve(i, k):
	if i < 0:
		return 0
	ans = 0
	if dp[i][k] != None:
		return dp[i][k]
	if k == 2:
		ans = max(ans, solve(i - 1, k))
		ans = max(ans, solve(i - 1, k - 1) + arr[i])
	elif k == 1:
		ans = max(ans, solve(i - 1, k - 1) + arr[i])
		ans = max(ans, solve(i - 1, 2))
	else:
		ans = max(ans, solve(i - 1, 2))
	dp[i][k] = ans
	return ans
dp = [[None, None, None] for x in range(n)]
for i in range(n):
	solve(i, 2)
print(dp[-1][-1])


n = int(input())
arr = list(map(int, input().split()))
dp = [0] * (n + 1)
dp[0] = 0
dp[1] = arr[0]
dp[2] = arr[0] + arr[1]
dp[3] = max(arr[2] + arr[0], arr[1] + arr[2], dp[-1])
for i in range(4, n + 1):
	dp[i] = max(dp[i - 1], arr[i - 1] + dp[i - 2], arr[i - 1] + arr[i - 2] + dp[i - 3])
print(dp[-1])


t = int(input())
arr = input().split()
sum = []
i = 0
while i < len(arr):
	if i == 0:
		sum.append(int(arr[0]))
	elif i == 1:
		sum.append(int(arr[0]) + int(arr[1]))
	elif i == 2:
		sum.append(max(sum[i - 2] + int(arr[i]), sum[i - 1], int(arr[2]) + int(arr[1])))
	else:
		sum.append(max(max(sum[i - 1], sum[i - 2] + int(arr[i])), int(arr[i]) + int(arr[i - 1]) + sum[i - 3]))
	i = i + 1
print(sum[t - 1])


N = int(input())
Ps = list(map(int, input().strip().split(' ')))
sum = [0 for i in range(N)]
if N > 0:
	sum[0] = Ps[0]
if N > 1:
	sum[1] = Ps[0] + Ps[1]
if N > 2:
	sum[2] = max(Ps[0] + Ps[2], max(sum[1], Ps[1] + Ps[2]))
for i in range(3, N):
	sum[i] = max(sum[i - 2] + Ps[i], max(sum[i - 1], sum[i - 3] + Ps[i - 1] + Ps[i]))
print(sum.pop())


n = int(input())
ipl = list(map(int, input().split()))
dp = list()
for i in range(1, n + 1):
	dp.append(0)
if n == 1:
	print(ipl[0])
elif n == 2:
	print(ipl[0] + ipl[1])
elif n == 3:
	print(max(ipl[0] + ipl[1], max(ipl[0] + ipl[2], ipl[1] + ipl[2])))
else:
	summ = 0
	for i in range(0, n):
		summ += ipl[i]
	dp[0] = ipl[0]
	dp[1] = ipl[1]
	dp[2] = ipl[2]
	for i in range(3, n):
		dp[i] = ipl[i] + min(dp[i - 1], min(dp[i - 2], dp[i - 3]))
	print(summ - min(dp[n - 1], min(dp[n - 2], dp[n - 3])))


N = int(input())
matches = list(map(int, input().split()))
games = matches[:3]
for i in range(3, N):
	games.append(min(games[i - 1], games[i - 2], games[i - 3]) + matches[i])
print(sum(matches) - min(games[-1], games[-2], games[-3]))


N = int(input().strip())
incomes = []
total_sum = 0
for i in input().strip().split(' '):
	incomes.append(int(i))
	total_sum += int(i)
stored_values = incomes[:3]
for i in range(3, N):
	stored_values.append(incomes[i] + min(stored_values[-1], stored_values[-2], stored_values[-3]))
print(total_sum - min(stored_values[-1], stored_values[-2], stored_values[-3]))


import sys
import bisect
input = sys.stdin.readline
n = int(input())
l = input().split()
li = [int(i) for i in l]
if n <= 2:
	print(sum(li))
	return
dp = [0 for i in range(n)]
dp[0] = li[0]
dp[1] = li[0] + li[1]
dp[2] = max(dp[1], li[2] + dp[0], li[1] + li[2])
for i in range(3, n):
	dp[i] = max(dp[i - 1], li[i] + dp[i - 2], li[i - 1] + li[i] + dp[i - 3])
print(dp[n - 1])


n = int(input())
lis = list(map(int, input().split()))
dp = [0] * n
dp[0] = lis[0]
dp[1] = lis[1]
dp[2] = lis[2]
if n < 3:
	print(sum(lis))
	return
for i in range(3, len(lis)):
	dp[i] = min(dp[i - 1], dp[i - 2], dp[i - 3])
	dp[i] += lis[i]
print(sum(lis) - min(dp[n - 1], dp[n - 2], dp[n - 3]))


dp = [-1] * int(1000000.0)

def solve(a, d):
	if d < 0:
		return 0
	if d == 0:
		return a[0]
	if d == 1:
		return a[0] + a[1]
	if dp[d] != -1:
		return dp[d]
	dp[d] = max(solve(a, d - 1), solve(a, d - 2) + a[d], solve(a, d - 3) + a[d] + a[d - 1])
	return dp[d]

def main():
	from sys import stdin, stdout, setrecursionlimit
	setrecursionlimit(int(1000000.0))
	rl = stdin.readline
	n = int(rl())
	a = [int(x) for x in rl().split()]
	if n < 3:
		stdout.write(str(sum(a)))
		return
	stdout.write(str(solve(a, n - 1)))
main()


no = int(input())
alls = list(input().split())
dp = [0] * (no + 1)
if no == 1:
	dp[1] = alls[0]
	print(dp[1])
elif no == 2:
	dp[2] = int(alls[1]) + int(alls[0])
	print(dp[2])
elif no >= 3:
	dp[1] = int(alls[0])
	dp[2] = int(alls[1]) + int(alls[0])
	a = int(alls[0]) + int(alls[1])
	b = int(alls[1]) + int(alls[2])
	c = int(alls[0]) + int(alls[2])
	dp[3] = max(a, b, c)
	for x in range(4, no + 1):
		d = int(dp[x - 2]) + int(alls[x - 1])
		e = int(dp[x - 1])
		f = int(dp[x - 3] + int(alls[x - 2]) + int(alls[x - 1]))
		dp[x] = max(d, e, f)
	print(dp[no])


n = int(input())
a = list(map(int, input().split()))
dp = [[0] * 3 for i in range(n + 1)]
for i in range(1, n + 1):
	dp[i][0] = max(dp[i - 1])
	for j in range(1, 3):
		dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + a[i - 1])
print(max(dp[-1]))


n = int(input())
array = list(map(int, input().split()))
appo2 = sum(array)
for i in range(3, n):
	array[i] += min([array[i - 1], array[i - 2], array[i - 3]])
appo = min([array[-1], array[-2], array[-3]])
print(appo2 - appo)


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import random
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

	def In():
		return map(int, stdin.readline().split())

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		n = I()
		l = list(In())
		dp = [[0, 0] for x in range(n)]
		if n == 1:
			print(l[0])
		elif n == 2:
			print(sum(l))
		else:
			dp[2][0] = l[2] + l[1]
			dp[2][1] = l[2] + l[0]
			ma = max(dp[1][0], dp[1][1])
			dp[1][1] = l[1]
			dp[1][0] = l[1] + l[0]
			for i in range(3, n):
				dp[i][0] = l[i] + dp[i - 1][1]
				ma = max(dp[i - 2][0], dp[i - 2][1], ma)
				dp[i][1] = ma + l[i]
			ma = 0
			for i in range(n):
				ma = max(dp[i][0], ma, dp[i][1])
			print(ma)
	except:
		pass
M = 998244353
P = 1000000007

def __starting_point():
	for _ in range(1):
		main()
__starting_point()


n = int(input())
l = list(map(int, input().split()))
if n <= 2:
	print(sum(l))
else:
	ml = [l[0], l[0] + l[1], max(l[0] + l[1], l[1] + l[2], l[0] + l[2])]
	for i in range(3, n):
		new = max(ml[i - 1], l[i] + ml[i - 2], l[i] + l[i - 1] + ml[i - 3])
		ml.append(new)
	print(ml[-1])


from sys import stdin, stdout
for _ in range(1):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	con0 = con1 = con2 = 0
	con1 = a[0]
	for i in range(1, n):
		(con0, con1, con2) = (max(con0, con1, con2), a[i] + con0, a[i] + con1)
	print(max(con0, con1, con2))


from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(10 ** 6)

def fn(pos, consecutive):
	if pos >= n:
		return 0
	if (pos, consecutive) in dp:
		return dp[pos, consecutive]
	take_cur = 0
	if consecutive + 1 < 3:
		take_cur = a[pos] + fn(pos + 1, consecutive + 1)
	dp[pos, consecutive] = max(take_cur, fn(pos + 1, 0))
	return dp[pos, consecutive]
for _ in range(1):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	dp = {}
	print(fn(0, 0))


import sys
read = lambda : sys.stdin.readline().strip()
n = int(read())
nums = list(map(int, read().split()))
dp = [0] * n
dp[0] = nums[0]
dp[1] = nums[1]
dp[2] = nums[2]
s = sum(nums)
for i in range(3, n):
	dp[i] = min(dp[i - 1], dp[i - 2], dp[i - 3]) + nums[i]
print(s - min(dp[-1], dp[-2], dp[-3]))


N = int(input())
list1 = list(map(int, input().split()))
nextint = [0 for i in range(N)]
notnext = [0 for i in range(N)]
notnext[-1] = list1[-1]
nextint[-1] = list1[-1]
notnext[-2] = list1[-2]
nextint[-2] = list1[-2] + list1[-1]
for j in range(len(list1) - 3, -1, -1):
	nextint[j] = max(list1[j] + notnext[j + 1], nextint[j + 1])
	notnext[j] = list1[j] + max(nextint[j + 2], notnext[j + 2])
print(max(nextint[0], notnext[0]))