学步园

不说了，感觉自己就是智硬。

A. Calculating Function（淼）

while True:
	try:
		n = input()
		if(n % 2 == 0):
			print (n / 2)
		else:
			print ((n - 1) / 2) - n
	except EOFError:
		break

B. OR in Matrix （暴力）
给定一种矩阵运算，Bij = Ai1 | Ai2 | ... | Aim | A1j | A2j | ... | Anj

现在给出B矩阵，求A，如果不存在这样的A输出No

（抱歉，Python竟然也写了这么多行。。）

while True:
	try:
		flag = 0
		m, n = map(int, raw_input().strip().split())
		B = [[] for i in range(m)]
		A = [[1 for i in range(n)] for j in range(m)]
		C = [[0 for i in range(n)] for j in range(m)]
		for i in range(m):
			B[i] = map(int, raw_input().strip().split())
		for i in range(m):
			for j in range(n):
				if B[i][j] > 1:
					flag = 1
					break
				if B[i][j] == 0:
					for k in range(m):
						A[k][j] = 0
					for k in range(n):
						A[i][k] = 0
			if flag == 1:
				break
		if flag != 1:
			for i in range(m):
				for j in range(n):
					for k in range(m):
						if A[k][j] == 1:
							C[i][j] = 1
					for k in range(n):
						if A[i][k] == 1:
							C[i][j] = 1
			for i in range(m):
				for j in range(n):
					if(C[i][j] != B[i][j]):
						flag = 1
						break
				if flag == 1:
					break
		if flag == 1:
			print 'NO'
		else:
			print 'YES'
			for i in range(m):
				for j in range(n):
					print A[i][j],
				print ''
	except EOFError:
		break

C. Palindrome Transformation （模拟）

给定一个字符串，告诉光标初始位置在第几个字符上，可以左右移动变幻位置，移动光标。
光标所在的位置的字符可以通过上下键改变，如A往上是B，往下是Z，按照字母表的顺序。
光标如果在最左端还往左移，则下一次出现的位置是最右端。
问总共最少要经过多少次上下左右移动，使得初始字符串变为一个回文字符串。

赛中还以为是dp，逗比了。。

修改左边的字符和修改右边对称位置的字符的代价是同样的，于是可以只修改某一边。然后看初始位置离哪边近就可以了。。

def cnt(l, r):
	d = abs(ord(s[l]) - ord(s[r]))
	return min(d, 26 - d)
	
n, p = map(int, raw_input().strip().split())
s = raw_input()

mid = int((n - 1)/ 2) + 1
p = int(min(p - 1, n - p))
minp = 1e6
maxp = -1
ans = 0
flag = 0

for i in range(mid):
	d = cnt(i, n - 1 - i)
	if d != 0:
		flag = 1
		minp = min(minp, i)
		maxp = max(maxp, i)
		ans += d
if flag == 1:
	ans += int(min(abs(p - minp), abs(p - maxp)) + maxp - minp)
print ans 

D. Valid Sets（据说是树形DP）
给一张联通图，n个点，n-1条边。每个点都有自己的权值。现在求图的某种子集有多少个。
子集要符合的条件：首先不是空集，然后其中任何两个点的最短路径都在这个子集中。
最后这个子集中权值最大的点比权值最小的点，他们权值相差不能超过d。

E. LIS of Sequence（没看。。不想做。。懒）