ipsc乱做。。其实是在浪费时间

强剧透警告(你们为什么要看这个呢，不如去看booklet)

2014 C

所有元素按照第一次出现的顺序保留即可。因为一次copy可以拆成很多次长度为1的copy，相当于我们可以每次选一个字符并在它后面插入一个相同字符。

2014 F easy

下了五个小时(也许只有三个小时?)终于从mit那里下到一个pi的前$10^9$位。。这么些数据的话计算机正好也还可以处理。。就这么多了

https://pan.baidu.com/s/1bpsQbqZ 下载这个文件

然后提出所有排列。。爆搜。。事实上只需要$\pi$的前几十万位就够了，花两个小时下载就是作死

然后就做出easy了。。hard不会优化啊。。

2014 I

用了20分钟，还好。。其中哈夫曼树写错了一次，淦

问题等价于，每个点有一个字符串，根一定是空串，任意一个点的所有儿子的字符串互相没有前缀关系。最小化\sigma(i的字符串长度*i的子树大小)

对每个点把儿子按子树大小排序做哈夫曼就好。

2014 J

花了1h17min做出这个题 不满意。。本来可以更快的(何况easy我以前做过一次)

easy:

1. 经典求法。good
2. 从$(0,0)$走$n$步走到$(k,n-k)$，里面显然只能往右、上，所以good
3. 这相当于从$n-step$中拿出$i$个数，从$step$中拿出$k-i$个数，与$step$是多少无关，所以good
4. 枚举最后取的一个数是谁，good
5. 枚举最后取的一个数是谁，可惜只枚举到了20，bad
6. 实际上就是枚举长度为$N$的01串中有多少个串恰有$K$个$1$。虽然s的范围是$16^{n}$但是真正有用的bit数只有$\frac{1}{4}$。good
7. 第一层递归就是无穷。$n$增大，$k$不变，永远不可能到达终止条件$k=0\text{ or }n=k$。bad
8. $\frac{n!}{k!(n-k)!}$。good
9. 这是个抽样算法。。随机选$8^n$个长度为$n$的01串然后检验是否恰有$k$个$1$。可惜是个随机算法，$n=6,k=4$时就萎了。bad
10. $n=3,k=1$的时候萎掉。bad
11. 这是由$\binom{n}{k}$推到$\binom{n}{k+1}$的那个公式，可以由阶乘展开式推出。good

hard

先把所有点都看一遍

第7个点很可疑，而且不会在可接受时间内结束，先不管

其他的点都对拍一下(因为第一个点是floyd所以肯定是对的)，得到答案为

1. good
   普通floyd
2. good
   堆+dijkstra
3. good
   手写栈爆搜
4. good
   每次搜中间点，两边分治搞这个算法的空间复杂度是$O(\text{polylog }n)$的哦
5. not good (5 6 [(1, 0, 664), (2, 1, 698), (3, 1, 578), (4, 2, 27), (1, 4, 421), (3, 2, 890)] 3 4)
   not ones (5 5 [(1, 0, 1), (2, 1, 1), (3, 2, 1), (4, 0, 1), (4, 3, 1)] 3 0)
   跟dijkstra很像。。加了一个break。。然后把某dist改成了w，可以看做写萎了
6. good
   就是floyd中$f_{i,j}=f_{i,k}+f_{k,j}$改成了$f_{i,j}=f_{k,i}+f_{j,k}$。。不知道为什么是对的
7. 本来写的是bad，但是交了一发wa了之后觉得$2^{749}$好像比$100^{100}$多了好多数量级那就写一个good吧。。感觉不太可能是ones
8. not good (2 1 [(1, 0, 151)] 1 0)
   not ones (2 1 [(1, 0, 1)] 1 0)
   是个bellman-ford。。但是range(N-2)令人不明觉厉啊，写萎了吗?
9. good
   第6个程序改了一下。。答案跟第6个程序相同(要么都是good，要么都是ones，要么都是bad)
10. not good (4 4 [(1, 0, 942), (2, 1, 490), (3, 2, 704), (0, 3, 239)] 2 0)
    ones
    是个普通bfs啊
11. not good (5 10 [(1, 0, 138), (2, 0, 99), (3, 0, 9), (4, 1, 114), (1, 3, 942), (4, 0, 928), (3, 2, 593), (4, 3, 533), (1, 2, 563), (4, 2, 974)] 3 1)
    not ones (5 10 [(1, 0, 1), (2, 1, 1), (3, 0, 1), (4, 1, 1), (4, 2, 1), (0, 4, 1), (1, 3, 1), (3, 2, 1), (2, 0, 1), (3, 4, 1)] 3 1)(死在完全图手上。。我也是醉了)
    看不懂。。反正拍死了
12. not good (5 9 [(1, 0, 871), (2, 0, 1000), (3, 2, 301), (4, 2, 450), (3, 1, 969), (1, 4, 8), (4, 3, 406), (3, 0, 273), (2, 1, 930)] 1 0)
    ones
    floyd改(把顺序k,i,j变成i,j,k，新手最容易犯的错误)，为什么是ones?
    upd：拍死了。。是个毛ones
    (9 11 [(1, 0, 1), (2, 1, 1), (3, 1, 1), (4, 0, 1), (5, 4, 1), (6, 4, 1), (7, 5, 1), (8, 5, 1), (8, 7, 1), (1, 6, 1), (8, 6, 1)] 7 2)
13. good
    dijkstra，加了一个“碰到end就直接退出”
14. not good (4 6 [(1, 0, 873), (2, 1, 502), (3, 2, 299), (2, 0, 456), (3, 1, 643), (0, 3, 586)] 3 0)
    not ones (3 3 [(1, 0, 1), (2, 1, 1), (2, 0, 1)] 0 2)(同死在完全图手上)
    同bfs。。只是visited的标记时间晚了，后面的权值可能覆盖前面更优的权值所以连ones都不是了
15. good
    把dijkstra的一个地方的dist打成了w。。这是对的?

上面括号括起来的五元组就是拍死的数据，格式为(N,M,edge_list,s,t)，可直接用于python。

2014 K

这题花了窝4个小时。。鈤。。窝python码力太差

其实窝看过booklet。。把需要的信息都搞到就好

询问有

• Pokemon which evolves from/into <>
• Pokemon with number #<>
• Chemical element with the symbol <>
• Chemical element with atomic number <>
• First/Last name of US President in <>(year)
• First/Last name of next US President after <>
• First/Last name of previous US President before <>
• Color with RGB values <>

红色是hard专属问题。。

hard里面还加了一个表达式求值，python大法好。。

pokemon https://en.wikipedia.org/wiki/List_of_Pok%C3%A9mon

chemical element https://en.wikipedia.org/wiki/Chemical_element

US president http://www.presidentsusa.net/presvplist.html

color http://cloford.com/resources/colours/500col.htm

这题坑点不少。。easy只有一个坑点就是铝有两个名字

hard坑点：

• Eevee可以进化成Vaporeon,Jolteon,Flareon,Espeon,Umbreon,Leafeon,Glaceon
• 铝是Aluminium。。美国人喊它Aluminum
• 铯是Caesium。。或Cesium
• 某些年里有两个总统上任(大选年里)。。某些年里有三个，不知道为什么
• 乔治布什是George W. Bush。。也是George H. Bush,George W. H. Bush,George H. W. Bush辣鸡总统毁我青春
• Grover Cleveland不连续地上任了两次。。所以他后面那个总统是谁呢。。辣鸡总统毁我青春
• 好像辣鸡总统Bush也不连续地上任了两次
• cyan=aqua，green=lime

程序做的肯定有错。。如果程序发现哪里错了就别填，人类再把#都填掉就好。

2014 L easy

花了老子15分钟听

01001000 01100101 01101100 01101100 01101111 00100001 00100000 01000001 01110011 00100000 01111001 01101111 01110101 01110010 00100000 01100001 01101110 01110011 01110111 01100101 01110010 00101100 00100000 01110011 01110101 01100010 01101101 01101001 01110100 00100000 01110100 01101000 01100101 00100000 01101100 01100001 01110010 01100111 01100101 01110011 01110100 00100000 01110000 01110010 01101001 01101101 01100101 00100000 01100110 01100001 01100011 01110100 01101111 01110010 00100000 01101111 01100110 00100000 01110100 01101000 01100101 00100000 01100110 01101111 01101100 01101100 01101111 01110111 01101001 01101110 01100111 00100000 01101110 01110101 01101101 01100010 01100101 01110010 00111010 ?99(11:40)        01010111 01100101 00100000 01110111 01101001 01110011 01101000 00100000 01111001 01101111 01110101 00100000 01100111 01101111 01101111 01100100 00100000 01101100 01110101 01100011 01101011 00100001 

猜测这是某个文本的ascii码 解码是这样的

Hello! As your answer, submit the largest prime factor of the following number: !@#$% We wish you good luck!

欺负非英语国家选手。。把数字读的飞快的。。

然后听出来!@#$%=947012399吧。。twelve thousand那里卡了很久不知道有没有这种说法→_→

2012 B

直播

easy的话随便交一些东西上去spj会给你提示，照着提示修改你的答案就可以了。

hard的话有一个badness的值，我先交了一个233333上去显示为68，然后

首先几次提交是确认badness值的计算方式：每一位之差的平方和。(因为改变一位对总badness的增量是奇数)

后面开始确定每一位的值。

最后把正解交上去就好。

2012 D

这题是神代码题。。

总之用python把代码都读进来就可以像sql一样进行查询啦！很容易写出easy的代码，每个问题一行。

hard的话我也写了，但是都是好几行才能写出来的。。

但是这题根本没法调啊，hard错了5次不知道错在哪了，所以没调了。。(注：关于保留几位小数的问题，我手动改了)

把程序挂出来算了。。easy的程序可能不全

import time
from numpy import *
fm = open("d-members.txt", "r")
members = []
for j in fm.readlines() :
	a, b, c = j.split(' ')
	c = int(c[:-1])
	members += [{"tis":a,"name":b,"age":c}]
fm.close()

fm = open("d-messages.txt", "r")
messages = []
ssss = {}
for j in fm.readlines() :
	a, b, c, d = j.split(' ')
	b = time.gmtime(int(b) + 7200)
	messages += [{"tis":a,"time":b,"subp":c,"stat":d[:-1]}]
	ssss[(a, b.tm_year, b.tm_mon, b.tm_mday, b.tm_hour, b.tm_min, b.tm_sec, c)] = d[:-1]
fm.close()

fm = open("d-problems.txt", "r")
problems = []
for j in fm.readlines() :
	a, b, c = j.split(' ')
	a = int(a)
	problems += [{"year":a,"task":b,"author":c[:-1]}]
fm.close()

fm = open("d-submissions.txt", "r")
submissions = []
for j in fm.readlines() :
	a, b, c, d, e, f = j.split(' ')
	a = time.strptime(a + " " + b, "%Y-%m-%d %H:%M:%S")
	e = int(e)
	b = ssss[(c, a.tm_year, a.tm_mon, a.tm_mday, a.tm_hour, a.tm_min, a.tm_sec, d)]
	submissions += [{"time":a,"tis":c,"subp":d,"size":e,"hash":f[:-1],"stat":b}]
	#time?
fm.close()

fm = open("d-teams.txt", "r")
teams = []
for j in fm.readlines() :
	a, b, c, d, e = j.split(' ')
	teams += [{"tis":a,"name":b,"country":c,"inst":d,"div":e[:-1]}]
fm.close()

YEARS = [2009, 2010, 2011]
def avg(x) : return 1.0 * sum(x) / len(x)
#for i in YEARS : print i, sum([1 for s in submissions if s["time"].tm_year == i])
#for c in unique([b["country"] for b in teams]) : print c,sum([1 for d in teams if d["country"] == c])
#def C(I) : return sum([1 for i in teams if i["inst"] == I])
#print 1.0 * len(members) / len(teams)
#print avg([m["age"] for m in members if m["age"]>0 and m["tis"] in [t["tis"] for t in teams if t["div"] == "open"]])
#print avg([m["age"] for m in members if m["age"]>0 and m["tis"] in [t["tis"] for t in teams if t["div"] == "secondary"]])
#for i in YEARS:
#	for j in unique([p["task"] for p in problems if p["year"] == i]) : print i, j, sum([1 for x in problems if x["task"] == j and x["year"] == i])


#hard
'''
for i in YEARS :
	for j in list("ABCDEFGHIJKLM") :
		if i != 2011 or j != 'M' :
			print i, j + "1", len(unique([h["hash"] for h in submissions if h["subp"] == j + "1" and h["stat"] == "OK" and h["time"].tm_year == i]))
			print i, j + "2", len(unique([h["hash"] for h in submissions if h["subp"] == j + "2" and h["stat"] == "OK" and h["time"].tm_year == i]))
'''

'''
R = [b for a, b in sorted([(-i["size"], i["tis"]) for i in submissions])[:20]]
for i in unique([j["name"] for j in teams if j["tis"] in R]) : print i
'''

'''
M = {}
for i in range(len(submissions)) :
	if submissions[i]["stat"] == "OK" :
		j = i + 1
		while j < len(submissions) :
			if time.mktime(submissions[j]["time"]) - time.mktime(submissions[i]["time"]) > 60 : break
			if submissions[j]["stat"] == "OK" :
				if submissions[j]["subp"] == submissions[i]["subp"] :
					T1 = submissions[i]["tis"]; T2 = submissions[j]["tis"]
					if T1 > T2 : T1, T2 = T2, T1
					M.setdefault((T1, T2), 0)
					M[(T1, T2)] += 1
			j += 1
s = 0
for i in M :
	if M[i] >= 4 : s = s + 1
print s
'''

'''
M = {}
N = {}
for i in submissions :
	c = (i["time"].tm_year, i["subp"][0])
	N.setdefault(c, 0)
	N[c] += 1
	if i["stat"] == "OK" :
		M.setdefault(c, 0)
		M[c] += 1
Q = {}
R = {}
for i in problems :
	a = i["author"]
	Q.setdefault(a, 0)
	R.setdefault(a, 0)
	Q[a] += M[(i["year"], i["task"])]
	R[a] += N[(i["year"], i["task"])]

S = []
for i in unique([p["author"] for p in problems]) : S.append((-1.0 * Q[i] / R[i], i))
for i, j in sorted(S) : print j, round(-i, 3)
'''


'''
s = {}
t = {}
u = {}
for i in submissions :
	x = (i["tis"], i["subp"])
	u.setdefault(x, 0)
	if i["stat"] == "OK" :
		o = i["time"]
		a = 60 * (o.tm_hour - 12) + o.tm_min
		penalty = a + u[x] * (10 if i["subp"][1] == '1' else 20)
		c = (i["time"].tm_year, i["subp"])
		s.setdefault(c, 0)
		s[c] += penalty
		t.setdefault(c, 0)
		t[c] += 1
	else :
		u[x] += 1
q = []
for i, j in sorted(s) : print i, j, round(1.0 * s[(i, j)] / t[(i, j)], 2)
'''

'''
happiness = {}
tt = {}
ans = {}
for i in members :
	tt.setdefault(i["tis"], [])
	tt[i["tis"]] += [i["name"][0]]
for i in submissions :
	if i["stat"] == "OK" :
		x = (i["subp"][0], i["time"].tm_year)
		happiness.setdefault(x, 0)
		happiness[x] += sum([1 for c in tt[i["tis"]] if c == i["subp"][0]])
for i in problems :
	ans.setdefault(i["author"], 0)
	ans[i["author"]] += happiness[(i["task"], i["year"])]
for i in sorted(ans) : print i, ans[i]
'''

2010 F

首先，如果想卡掉A，那么必须使用比较小的数，我们可以放两个1和一大堆大数就可以卡掉A了。

然后要卡掉B，需要找出三个一定不会用的数。我们可以放三个数1,2,4，然后其他数都是8的倍数。

如果要卡掉A和B，那么可以放1,2,4,8,8和$n-5\ge 15$个比较大的8的倍数。

然后这样是可以卡掉D的。因为假设答案是$h+8$，即较大的$n-5$个数可以拼出$2h$也可以用两种方法拼出$h$。那么所有数显然可以拼出$2h+22=2h+2+4+8+8$，也可以用两种方法拼出$h+11=1+2+8+h$，这样D的答案至少是$h+11$。

最后就是C了。。事实上C是最好卡的程序，对拍就可以把C干掉了。

如果要同时卡掉所有程序，设$a$是卡掉C的一组数据(数组)，将$a$的每个元素乘以$24$然后插入$1,2,4,8,8$即可。

首先这组数据能卡掉A,B,D。然后考虑C的过程，因为$1+2+4+8+8<24$所以容易发现这就等价于用C运行$a$的结果，反正是错的。

就做完啦。

2012 F

一个子集是公平的当且仅当其中存在一个公平硬币

for i in range(int(raw_input())) :
	raw_input()
	T = int(raw_input())
	print (2 ** T) - (2 ** sum([1 for x in raw_input().split(' ') if x != '0.500000']))

2011 K

日。。每次随机选一个可以翻的点翻掉。所有数据都有解。

easy的话尝100次就可以出解。hard的话两次就好了(笑)。

booklet上的正解是。。贪心?位运算?(既然是提答你为什么不出大点。。只出2000的话$O(n^3)$分分钟艹掉吧)

2011 G

可持久化四分树。。

四分树这种数据结构很容易持久化吧。。跟线段树一样。。

说什么四分树复杂度不对的，这可是提交答案题!四分树复杂度好像是$O(\sqrt{N})$的吧。。跑10min出解应该没问题。

2013 A

贪心

这个硬币系统是可以贪心的。。

2013 B

easy：直接dp，设$i$分成$x$和$y$，那么$f_i=f_x+f_y+xy$。

hard：把上面那个dp改一下就可以打出暴力了。找规律发现是$\binom{n-1}{2}$。

2013 C

easy :

long long t(long long n) {
    long long z=n;
    for (long long a=2; a<n; ++a) if (t(a)>=a) if (n%a==0) { z/=t(a); z*=t(a)-1; }
    return std::min(z+1,n);
}

那个t函数中的z就是欧拉函数。。

for (long long i=0; i<z; ++i) std::rotate( A.begin(), A.begin()+1, A.end() );

把z模A.size()就是了。

然后飞快地跑出来一个CHANGE 1607055075 TO 853225920

前面的数组中真的有一个1607055075，把它改成853225920

继续跑，跑出来CHANGE 853225920 TO 646197696

继续搞。。。搞到最后那个数变成147456，跑出答案为MATTER。

hard：

int g(long long b) {
    for (long long i=0;;++i) { 
        char c = i<145 ? foo[i] : "HeHeHe"[i%6];
        int x = c - 65 - 6*(c>90);
        for (int j=0; j+x%2<2; ++j) for (int q=0; q<2; ++q) if (!b--) return ((22724580)>>(2*((x>>(2*j+1))&(3+12*(x%2)))+1-q))&1;
    }
}

首先优化g函数。。打表发现$b>441$的时候答案都是$1$。然后重新写就得到这个

char o[4444] = "00000001101101000000001111101011011011111001000101101111010001001000101011011010001001000101110001010001001111101000101011111000000001010101000000011111111110001111111100000100001100101010100010111010101101101100011100100011111111101001010010110101110000001001000010000100111111111000101010100100000001010100010111101111101100101101000001000101001101011001101000101001101101111101000101011110101001101111101011010101101000000001011100101001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
int g(long long b){if (b > 444) return 1; else return o[b] - '0';}

然后就不会做了。。

看了看booklet发现main里面那个随机数生成器并没有什么卵用，答案是把这个串分成$21\times 21$的矩阵：

000000011011010000000
011111010110110111110
010001011011110100010
010001010110110100010
010001011100010100010
011111010001010111110
000000010101010000000
111111111100011111111
000001000011001010101
000101110101011011011
000111001000111111111
010010100101101011100
000010010000100001001
111111110001010101001
000000010101000101111
011111011001011010000
010001010011010110011
010001010011011011111
010001010111101010011
011111010110101011010
000000010111001010011

发现它是一个二维码，扫一扫就好

不过怎么搞出二维码呢?matrix67的博客里有一个C++画图的程序，改一改得到二维码的ppm图像，用ubuntu图像查看器强转为bmp

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#define DIM 21
#define DM1 (DIM-1)

int N = 21;
FILE *fp;
void write(char G[44][44], const char *fn){
  fp = fopen(fn, "wb");
  fprintf(fp, "P6\n%d %d\n255\n", DIM, DIM);
  static unsigned char color[3];
  for (int i = 1; i <= N; i++)
    for (int j = 1; j <= N; j++){
      if (G[i][j] == '0') color[0] = 0;
      else color[0] = 255;
      color[2] = color[1] = color[0];
      fwrite(color, 1, 3, fp);
    }
}

char G[44][44];
int main(){
  freopen("qrcode", "r", stdin);
  for (int i = 1; i <= 21; i++)
    scanf("%s", G[i] + 1);
  write(G, "qrasdouashfo.ppm");
  return 0;
}

然后这个网站上面扫码。。我谷歌到的各种扫码网站中只有这个可以用。。

扫码结果是

88767->7123398

把变量bar改成7123398解码出来是FOOTBALL。。

2013 F

easy傻逼题，给你练习交互方式的。。就是每次把目标等分成3份ABC，取两份(A,B)进行称量。称量的话用一次提交称量50次，取返回结果最多的为结果(比如返回了25个R表明右边的盘子重一些)。有几种情况：

• 相等。那么fake一定在剩下一块中；
• 第一次不相等。再花一次称量A,C，如果相等那么fake在B中，否则fake在A中，且可以得出fake是轻是重。
• 其他不相等：根据fake与正常硬币的轻重关系可以确定fake在A中还是在B中。

正好5次称量一次guess。

hard我看过题解。。大概就是说150次guess都是纯随机生成的，然后只有500种可能的情况(fake是哪枚硬币+轻重)，枚举每种情况看哪种满足了最多的条件就是答案。

球正确性证明!QAQ

2013 H

easy：网页源代码中有

hard：

booklet大法好

世界上有一种东西叫做HTTP request header(也许是这么叫的)。。这里面有一些东西。。比如说文件类型(所以有的php程序输出的是网页源代码，有的输出的是图像，有的输出的是zip)。。还有H2的答案。

听说chrome很容易看header?反正我用的是ff

ff：F12(查看源码)-点击“网络”-F5(刷新)-点击“h.html”-右下角有文件头。不知道不同版本的ff是不是差不多呢。我的是Mozilla Firefox 47.0。

H2的信息是，一个蓝色妖怪想吃chocolate

那就喂给它一个cookie，名称不重要，内容是chocolate。ff上添加cookie需要附加组件，这个很好用。

接下来刷新页面，H2的妖怪说“很好吃。。你还要回答我的问题”，然后是一个简单的加法

但是怎么把答案传给服务器呢。。

于是booklet大法好。。需要用到curl命令，大概就是

curl -I https://ipsc.ksp.sk/2013/real/problems/h.html -H "H2-Answer:867"

然后就得到答案了。

curl url 表示显示url的源代码，-I表示只显示header，-H表示传一个header过去。

2013 I easy

一张图片的相邻像素一般差距都不会很大。

对于一个$1\sim 32$的排列$p$和一张图片$pic$($32\times 32$的灰度数组)我们定义其权值为：$\sum_{i=1}^{31}\sum_{j=1}^{32}|pic_{j,p_i}-pic_{j,p_{i+1}}|$

对于一个排列$p$我们定义它的权值为遍历所有图片其权值之和。

求权值最小的排列。。。就是个tsp问题啦，退火啥的就好

然后用c2中打印二维码的程序把所有图像都打印出来即可。图像还是比较清晰的

j

这题程序写萎了好几次。。不服

可以用0-255中的一个数表示一个三输入布尔函数。我们要验证$x$是不是universal的，需要写一个$F(x,a,b,c)$表示三个函数$a,b,c$作为输入端喂给$x$之后输出端是谁。然后把总是返回第一个变量、第二个、第三个的函数(0xf0,0xcc,0xaa)放入队列，每次从队列中取出三个函数用$F$合成一下放入队列。到最后如果队列中有全部$256$种函数那么$x$就是universal的，否则不是。

k

膝盖之题?orz

easy：$f_i=f_{i-1}+f_{i-2}$，$g_i=g_{i-1}+g_{i-2}+g_{i-3}+g_{i-4}$，然后$f_ng_n$就是答案

hard：可以看做两个人一起走，wyh2000只能跨1,2，wyh2001只能跨1~4，wyh2001只能踩wyh2000踩过的阶梯，wyh2001每跨长度为$k$的一步，wyh2000想跨完这一步有$fib_k$种可能，所以就是$f_i=f_{i-1}+2f_{i-2}+3f_{i-3}+5f_{i-4}$。

L

easy是我手玩的

hard是ymdragon神犇做的

hard都是3-sat问题，而且数据在data.js里面，所以写一个程序抽象出3-sat问题，再从网上找一个求3-sat可行解的程序，最后通过手玩(一个多小时)把游戏都玩通就好。

2016 S

呵呵

2016 U

一副讨论题的样子，坑在这里(万一不准备填了呢

坑：(希望去做的题)填不上的

2013 I2

2016 U

2013 G