这道题是说给你一个最大8*8的矩阵，每次你可以交换两行或两列，让它的行优先遍历的字典序最小。。
实际上很简单，前天我钻研了楼教主的部分搜索的论文，这道题目实际上部分搜索就可以了，只要列的排列顺序确定了，行只要排个序就可以了。。
那么效率就是(n!*n^2*logn)对付这题n=8足够了。。
晕。。真的不能再搞编程了。。还有1个星期就要数学竞赛了天啊。。神啊。保佑我吧囧。。
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
#define tr(i,x) for(typeof(x.begin()) i=x.begin();i!=x.end();i++)
#define all(x) x.begin(),x.end()
const int inf=~0U>>1;
using namespace std;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vi::iterator vit;
class MatrixGame {
public:
vector <string> getMinimal(vector <string>);
};
int n,m;
vector<string> tmp,M,ans;
bool used[10]={0};
void dfs(int p)
{
if(p==m)
{
vector<string> t=tmp;
sort(all(t));
ans=min(ans,t);
return;
}
rep(i,m)if(!used[i])
{
used[i]=true;
rep(j,n) tmp[j][p]=M[j][i];
dfs(p+1);
used[i]=false;
}
}
vector <string> MatrixGame::getMinimal(vector <string> _M) {
ans=M=_M;
n=M.size();m=M[0].size();
tmp.resize(n);rep(i,n)tmp[i].resize(m);dfs(0);
return ans;
}

//Powered by [KawigiEdit] 2.0!

晕。。这道题目其实不算太难。当时脑子小了囧。。
只要dp就可以了。实际上由于黑色的最多只有8个，那么状态就是（usedRow，usedCol，LeftRow,LeftCol）.其中最后一个没必要储存，是有前三个唯一确定的。。
首先把黑色的全往左上角扔。。那么左上角的“黑块”最多只有8*8大小。
usedRow就是黑块的row的占用情况，usedCol就是黑块的Col占用的情况，LeftRow就剩下的没被占用的白色Row，LeftCol也一样，然后Dp就可以了囧。。最恶心的是如果边界情况就是没有任何后继的话答案应该是1，但不能根据答案是否为0判断，因为它也可能恰好是10000000007的倍数额啊囧。。好吧code太ugly了囧。。
手机买了居然是山寨的晕死。。现在高仿太多了囧。。
Code：
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
#define tr(i,x) for(typeof(x.begin()) i=x.begin();i!=x.end();i++)
#define all(x) x.begin(),x.end()
const int inf=~0U>>1;
using namespace std;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vi::iterator vit;
typedef long long ll;
typedef unsigned long long ull;

class DrawingBlackCrosses {
public:
int count(vector <string>);
};
const int maxn=20;
const ll mod=1000000007;
bool a[maxn][maxn];
int bn,bm,n,m;
ll Dp[maxn+1][1<<8][1<<8];
bool S[maxn+1][1<<8][1<<8]={0};
ll dfs(int ur,int uc,int ln,int lm)
{
ll&x=Dp[ln][ur][uc];
if(S[ln][ur][uc]) return x;
S[ln][ur][uc]=true;x=0;bool ok=false;
rep(i,bn)rep(j,bm)if((ur&(1<<i))==0&&(uc&(1<<j))==0&&!a[i][j])
x+=dfs(ur^(1<<i),uc^(1<<j),ln,lm),x%=mod,ok=true;
if(lm>0)rep(i,bn)if((ur&(1<<i))==0) x+=dfs(ur^(1<<i),uc,ln,lm-1)*lm,x%=mod,ok=true;
if(ln>0)rep(i,bm)if((uc&(1<<i))==0)x+=dfs(ur,uc^(1<<i),ln-1,lm)*ln,x%=mod,ok=true;
if(ln>0&&lm>0)x+=dfs(ur,uc,ln-1,lm-1)*ln*lm,x%=mod,ok=true;
if(!ok)x=1;
return x;
}
int DrawingBlackCrosses::count(vector <string> field) {
vector<string>T(all(field)),A;
sort(all(T));
reverse(all(T));
rep(i,T[0].size())
{
string a="";
rep(j,T.size())
{
a+=T[j][i];
}
A.pb(a);
}
sort(all(A));
reverse(all(A));bn=bm=0;n=A.size();m=A[0].size();
rep(i,n)rep(j,m)
{
a[i][j]=A[i][j]==’B’;
if(a[i][j]) bn>?=i+1,bm>?=j+1;
}
return dfs(0,0,n-bn,m-bm);
}

    晕。。这次的比赛真诡异。。250分说白了就是给你一个10位整数改变最少的数位把他变成因子数为奇数的数。。因子数为奇数那么所有素因子的幂数都是偶数，就是平方数额，暴力枚举平方数就行了囧。。这道题目在VIJOS上好像有类似的啊，就是那个什么关路灯的。。本质是差不多的囧。。
500分我沙茶的要死推不出公式直接Dp囧。。现在想出公式了囧。。真是太菜了。。
最后一题神牛题啊。。半点思路都没有晕。。先想是不是跟匹配有关系发现没关系，然后想容斥原理，还是没办法，然后想Dp，根本Dp不了。只好撞墙囧。。
Cha的时候我脑子小了。。一个也没cha成囧。。
最后第99名晕。。

[SCOI2003]字符串折叠

Time Limit:10000MS  Memory Limit:165536K
Total Submit:21 Accepted:15
Case Time Limit:1000MS

Description

折叠的定义如下：
1. 一个字符串可以看成它自身的折叠。记作S  S
2. X(S)是X(X>1)个S连接在一起的串的折叠。记作X(S)  SSSS…S(X个S)。
3. 如果A  A’, BB’，则AB  A’B’
例如，因为3(A) = AAA, 2(B) = BB，所以3(A)C2(B)  AAACBB，而2(3(A)C)2(B)AAACAAACBB
给一个字符串，求它的最短折叠。例如AAAAAAAAAABABABCCD的最短折叠为：9(A)3(AB)CCD。

Input

仅一行，即字符串S，长度保证不超过100。

Output

仅一行，即最短的折叠长度。

Sample Input

NEERCYESYESYESNEERCYESYESYES

Sample Output

14

Hint

一个最短的折叠为：2(NEERC3(YES))

Source
晕。。SCOI这种类型的题目怎么这么多囧。。这道题差不多吧，也是Dp，比压缩还简单，就不说了。。
另外<?=这个操作符很NB。。
Code：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstring>
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
using namespace std;
const int inf=~0U>>1,maxl=120;
char M[maxl];
bool S[maxl][maxl]={0};
int Dp[maxl][maxl];
bool Match(int p,int Len,int s)
{
if(Len%s)return false;
rep(i,Len) if(M[p+i]!=M[p+i%s]) return false;
return true;
}
int Cost(int x)
{
if(x<10) return 1;
return 1+Cost(x/10);
}
int dfs(int l,int r)
{
int&x=Dp[l][r];if(S[l][r]) return x;
S[l][r]=true;int Len=r-l+1;x=Len;if(Len==1) return x;
for(int k=l;k<r;k++)x<?=dfs(l,k)+dfs(k+1,r);
for(int k=1;k<Len;k++)if(Match(l,Len,k))x<?=dfs(l,l+k-1)+2+Cost(Len/k);
return x;
}
int main()
{
//freopen("in","r",stdin);
cin>>M;
cout<<dfs(0,strlen(M)-1)<<endl;
}

[SCOI2007]压缩

Time Limit:1000MS  Memory Limit:165536K
Total Submit:18 Accepted:10

Description

给一个由小写字母组成的字符串，我们可以用一种简单的方法来压缩其中的重复信息。压缩后的字符串除了小写字母外还可以（但不必）包含大写字母R与M，其中 M标记重复串的开始，R重复从上一个M（如果当前位置左边没有M，则从串的开始算起）开始的解压结果（称为缓冲串）。
bcdcdcdcd可以压缩为bMcdRR，下面是解压缩的过程：

另一个例子是abcabcdabcabcdxyxyz可以被压缩为abcRdRMxyRz。

Input

输入仅一行，包含待压缩字符串，仅包含小写字母，长度为n。

Output

输出仅一行，即压缩后字符串的最短长度。

Sample Input

bcdcdcdcdxcdcdcdcd

Sample Output

12

Hint

在第一个例子中，解为aaaRa，在第二个例子中，解为bMcdRRxMcdRR。
【限制】
50%的数据满足：1<=n<=20
100%的数据满足：1<=n<=50
100%的数据满足：1<=n<=50

Source
其实是蛮简单的一道题啊，就是Dp啊，但是各种东西太纠结了。。我WA了N次。。。

晕死，状态定义就是（l,r,t）表示l到r的字串，t表示中间能否放M。。关键就是如果后面放了R的话中间就不能放M了晕死。。WA了这么多次，不想活了囧。。
Code：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstring>
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
using namespace std;
const int inf=~0U>>1,maxl=100;
char M[maxl];
bool S[maxl][maxl][2]={0};
int Dp[maxl][maxl][2];
bool Match(int p,int Len,int s)
{
if(Len%s)return false;
rep(i,Len)if(M[p+i]!=M[p+i%s])return false;
return true;
}
inline int Update(int&x,int c){x=min(x,c);}
int dfs(int l,int r,bool t)
{
int&x=Dp[l][r][t];if(S[l][r][t]) return x;
S[l][r][t]=true;int Len=r-l+1;x=Len;
if(Len==1)return x;
if(t)for(int k=l;k<r;k++)Update(x,dfs(l,k,1)+1+dfs(k+1,r,1));
for(int k=l;k<r;k++)Update(x,dfs(l,k,t)+r-k);
if(Len%2==0&&Match(l,Len,Len/2)) Update(x,dfs(l,l+Len/2-1,0)+1);
return x;
}
int main()
{
//freopen("in","r",stdin);
cin>>M;
cout<<dfs(0,strlen(M)-1,1)<<endl;
}

[HAOI2008]圆上的整点

Time Limit:10000MS  Memory Limit:165536K
Total Submit:68 Accepted:22
Case Time Limit:1000MS

Description

求一个给定的圆(x^2+y^2=r^2)，在圆周上有多少个点的坐标是整数。

Input

r

Output

整点个数

Sample Input

4

Sample Output

4

Hint

n<=2000 000 000

Source
额，我去查了查勾股数的生成方法，发现是这个样子的，
（n，m）=1,(n^2-m^2)^2+(2mn)^2=(n^2+m^2)^2。。同时三项全部乘个啥就可以推到所有数，所以首先枚举r/（n,m），再枚举n和m，再用个set去重就OK了。。
Code：

#include<iostream>
#include<set>
#include<utility>
using namespace std;
long long r,n,m;
typedef pair<int,int> ii;
set<ii> S;
int Cal(int d)
{
long long r=::r/d;
n=1,m=1;while(m*m<r)m++;
while(n<m)
{
while(n<m&&n*n+m*m>r)m–;
if(n>=m)break;
if(n*n+m*m==r){int a=m*m-n*n,b=2*m*n;S.insert(ii(a*d,b*d));S.insert(ii(b*d,a*d));}
n++;
}
}
int main()
{
cin>>r;int d;
for(d=1;d*d<r;d++)if(r%d==0) Cal(r/d)+Cal(d);
if(d*d==r)Cal(d);
cout<<S.size()*4+4<<endl;
}

[HAOI2008]玩具取名

Time Limit:10000MS  Memory Limit:165536K
Total Submit:45 Accepted:34
Case Time Limit:1000MS

Description

某人有一套玩具，并想法给玩具命名。首先他选择WING四个字母中的任意一个字母作为玩具的基本名字。然后他会根据自己的喜好，将名字中任意一个 字母用“WING”中任意两个字母代替，使得自己的名字能够扩充得很长。
现在，他想请你猜猜某一个很长的名字，最初可能是由哪几个字母变形过来的。

Input

第一行四个整数W、I、N、G。表示每一个字母能由几种两个字母所替代。
接下来W行，每行两个字母,表示W可以用这两个字母替代。
接下来I行，每行两个字母,表示I可以用这两个字母替代。
接下来N行，每行两个字母,表示N可以用这两个字母替代。
接下来G行，每行两个字母,表示G可以用这两个字母替代。
最后一行一个长度不超过Len的字符串。表示这个玩具的名字。

Output

一行字符串，该名字可能由哪些字母变形而得到。（按照WING的顺序输出）
如果给的名字不能由任何一个字母变形而得到则输出“The name is wrong!”

Sample Input

1 1 1 1
II
WW
WW
IG
IIII

Sample Output

IN

Hint

W可以变成II所以IIII可以缩成WW
IN均能变成WW所以WW又可以缩成I或者N
所以最终答案应该按照“WING”的顺序输出IN

[数据范围]
30%数据满足Len<=20，W、I、N、G<=6
100%数据满足Len<=200，W、I、N、G<=16

Source
水题啊。。直接Dp就可以了，Check（l，r，a）表示第l个到第r能否用第a个字母扩充出来
Code：
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstring>
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
using namespace std;
const int inf=~0U>>1,maxl=200+1;
int Map[256],D[4],L[4][16],R[4][16];
char Name[10]="WING";
char str[maxl];
bool S[maxl][maxl][4]={0};
bool Dp[maxl][maxl][4];
bool Check(int l,int r,int a)
{
bool&x=Dp[l][r][a];
if(S[l][r][a]) return x;
S[l][r][a]=true;
if(l==r) return x=(str[l]==Name[a]);
for(int k=l;k<r;k++)
rep(i,D[a]) if(Check(l,k,L[a][i])&&Check(k+1,r,R[a][i])) return x=true;
return x=false;
}
int main()
{
//freopen("in","r",stdin);
Map[‘W’]=0;Map[‘I’]=1;Map[‘N’]=2;Map[‘G’]=3;
rep(i,4)cin>>D[i];char l,r;
rep(i,4)rep(j,D[i]) cin>>l>>r,L[i][j]=Map[l],R[i][j]=Map[r];
cin>>str;int len=strlen(str);bool c=false;
rep(i,4)if(Check(0,len-1,i))cout<<Name[i],c=true;
if(!c)cout<<"The name is wrong!";
}

SCOI2007]蜥蜴

Time Limit:1000MS  Memory Limit:165536K
Total Submit:44 Accepted:29

Description

在一个r行c列的网格地图中有一些高度不同的石柱，一些石柱上站着一些蜥蜴，你的任务是让尽量多的蜥蜴逃到边界外。
每行每列中相邻石柱的距离为1，蜥蜴的跳跃距离是d，即蜥蜴可以跳到平面距离不超过d的任何一个石柱上。石柱都不稳定，每次当蜥蜴跳跃时，所离开 的石柱高度减1（如果仍然落在地图内部，则到达的石柱高度不变），如果该石柱原来高度为1，则蜥蜴离开后消失。以后其他蜥蜴不能落脚。任何时刻不能有两只 蜥蜴在同一个石柱上。

Input

输入第一行为三个整数r，c，d，即地图的规模与最大跳跃距离。以下r行为石竹的初始状态，0表示没有石柱，1~3表示石柱的初始高度。以下r行为蜥蜴位 置，“L”表示蜥蜴，“.”表示没有蜥蜴。

Output

输出仅一行，包含一个整数，即无法逃离的蜥蜴总数的最小值。

Sample Input

5 8 2
00000000
02000000
00321100
02000000
00000000
……..
……..
..LLLL..
……..
……..

Sample Output

1

Hint

100%的数据满足：1<=r, c<=20, 1<=d<=3

Source

Pku 2711 Leapin’ Lizards
有点水的网络流，直接拆点构图就可以了。。
Code：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstring>
#include<cmath>
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
using namespace std;
typedef pair<int,int> ii;
const int inf=~0U>>1,maxn=20,maxv=maxn*maxn*2+2;
int n,m;
inline int In(int i,int j){return (i*m+j)*2;}
inline int Out(int i,int j){return In(i,j)+1;}
struct Edge
{
int t,c;
Edge*next,*op;
Edge(int _t,int _c,Edge*_next):t(_t),c(_c),next(_next){}
}*E[maxv]={0};
int h[maxv],vh[maxv],vs,vt,v;
void InsEdge(int s,int t,int c)
{
E[s]=new Edge(t,c,E[s]);
E[t]=new Edge(s,0,E[t]);
E[s]->op=E[t];E[t]->op=E[s];
}
int aug(int no,int m)
{
if(no==vt) return m;
int l=m;
for(Edge*i=E[no];i;i=i->next)if(i->c&&h[no]==h[i->t]+1)
{
int d=aug(i->t,min(i->c,l));
l-=d,i->c-=d,i->op->c+=d;
if(l==0||h[vs]>=v)return m-l;
}
int minh=v;
for(Edge*i=E[no];i;i=i->next)if(i->c&&h[i->t]+1<minh)
minh=h[i->t]+1;
if(–vh[h[no]]==0) h[vs]=v;vh[h[no]=minh]++;
return m-l;
}
int CalFlow()
{
memset(h,0,sizeof(h));
memset(vh,0,sizeof(vh));
vh[0]=v;
int flow=0;while(h[vs]<v)flow+=aug(vs,inf);
return flow;
}
inline int Dist(ii a,ii b){return abs(a.first-b.first)+abs(a.second-b.second);}
inline int DistToExit(int x,int y){return min(x+1,min(n-x,min(y+1,m-y)));}
int main()
{
//freopen("in","r",stdin);
int x,d,a=0;char c;cin>>n>>m>>d;v=n*m*2+2;vs=v-1;vt=vs-1;
rep(i,n)rep(j,m){cin>>c;x=c-‘0’;if(x)InsEdge(In(i,j),Out(i,j),x);}
rep(i,n)rep(j,m){cin>>c;if(c==’L’) InsEdge(vs,In(i,j),1),a++;}
rep(i,n)rep(j,m)rep(a,n)rep(b,m)if(Dist(ii(i,j),ii(a,b))<=d) InsEdge(Out(i,j),In(a,b),inf);
rep(i,n)rep(j,m)if(DistToExit(i,j)<=d) InsEdge(Out(i,j),vt,inf);
cout<<a-CalFlow()<<endl;
}

[SCOI2008]着色方案

Time Limit:10000MS  Memory Limit:165536K
Total Submit:20 Accepted:16
Case Time Limit:1000MS

Description

有n个木块排成一行，从左到右依次编号为1~n。你有k种颜色的油漆，其中第i种颜色的油漆足够涂ci个木块。所有油漆刚好足够涂满所有木块，即 c1+c2+…+ck=n。相邻两个木块涂相同色显得很难看，所以你希望统计任意两个相邻木块颜色不同的着色方案。

Input

第一行为一个正整数k，第二行包含k个整数c1, c2, … , ck。

Output

输出一个整数，即方案总数模1,000,000,007的结果。

Sample Input

3
1 2 3

Sample Output

10

Hint

【样例2】
Input
5
2 2 2 2 2
Output
39480
【样例3】
Input
10
1 1 2 2 3 3 4 4 5 5
Output
85937576
数据规模】
50%的数据满足：1 <= k <= 5, 1 <= ci <= 3
100%的数据满足：1 <= k <= 15, 1 <= ci <= 5

Source
这题一看就知道是要Dp的，而且状态很麻烦，好在c最大只有5，所以可以用一个6维数组表示
，就是第i个表示当前还有i个的颜色还有几个，还要一个Last表示最后一个是哪个颜色。然后用
Hash表存储状态就可以了。。unsigned long long中的-1就是最大值。。
Code：
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstring>
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
using namespace std;
const int inf=~0U>>1,c=6,seed=17,mod=1000000007,size=17771;
typedef unsigned long long ull;
int n;
struct State
{
int Num,Last;
State(){memset(Num,0,sizeof(Num));}
ull HashCode() const
{
ull ret=0;
rep(i,c) ret*=seed,ret+=Num[i];
ret*=seed;return ret+=Last;
}
State Next()
{
State s=*this;
s.Num[Last]–;s.Num[Last-1]++;return s;
}
bool Legal(){return Num[Last]>0&&Last>0;}
void operator=(const State&o)
{
memcpy(Num,o.Num,sizeof(Num));
Last=o.Last;
}
};
struct Hash
{
struct Node
{
ull key,Count;
Node*next;
Node(ull _key,Node*_next):key(_key),next(_next),Count(-1){}
}*H[size];
Hash(){memset(H,0,sizeof(H));}
ull& Find(const State&a)
{
ull code=a.HashCode(),h=code%size;
for(Node*i=H[h];i;i=i->next)if(i->key==code) return i->Count;
return H[h]=new Node(code,H[h]),H[h]->Count;
}
}H;
ull dfs(State S,int Left)
{
ull&x=H.Find(S);if(x!=-1) return x;
if(!S.Legal()) return x=0;
if(Left==1) return x=1;
x=0;
State NewS=S.Next();
for(int i=1;i<c;i++)
{
NewS.Last=i;
if(i!=S.Last&&S.Num[i])
{
x+=S.Num[i]*dfs(NewS,Left-1);
x%=mod;
}
if(i==S.Last&&S.Num[i]>1)
{
x+=(S.Num[i]-1)*dfs(NewS,Left-1);
x%=mod;
}
}
return x;
}
int main()
{
//freopen("in","r",stdin);
State now;ull ans=0;
int n,x,s=0;cin>>n;rep(i,n) cin>>x,now.Num[x]++,s+=x;
rep(i,c) now.Last=i,ans+=now.Num[i]*dfs(now,s),ans%=mod;
cout<<ans<<endl;
}

       好吧我开学一个月了才写开学感言确实有点晕。。
OK，开学一个月了，感觉跟鬼一样，话说我们这里已经中考考完了，然后我这个CLJ进了LJ班晕，实际上也没什么，男女比例3：1也没什么，班里帅哥还真是多，我这样下去要变BL了天哪。。。开学了还是无聊，有时候还能见到原来的同学，好吧我觉得也就这样了，我越来越觉得人生来就孤独了，没什么要紧的，没心没肺啊没心没肺。
文化节我们班MS悲剧了，不过压根就没人鸟这事，文化节越来越像作秀，不是跳脱衣舞就是抛绣球还有拜堂成亲的，好吧附近两个班欺负我们班没有女生都在抛绣球晕，我受捕鸟了就溜掉了。换票？居然有人问我要不要换票，我特蔑视地看了她一眼囧。。
还有什么辩论赛，初中辩论的时候我就觉得很火，辩论经典文学通俗化利大于弊否？这件事有什么利弊的，不过是分个档次而已，通俗了说白了实际上就叫儿童文学了，不过没人逼你去看儿童文学，给儿童看看也是好事。我当时想去骂的，不过有点懒得，就去机房上机了。。
那个整个下午的什么狗屁京剧我都想吐了，京剧都成什么样子了，天哪，杂技+武功？看不下去。。看了一下午的电子书。。晚上的节目倒不错，尤其是那个雷雨，雷到我了。。曹禺老先生一定有恋母情节。。
昨天就去春游了晕，春游？好古老。青春青春，青年人发春？我太老了发不了春了，只能发疯，在西溪湿地逛了一圈特无聊，玩了玩沼泽探险小游戏晕。中午之后还有人风筝DIY的小游戏，我弄了半天最后火了把耳机线放在后面结果居然飞起来了真强。。。其他也没什么好玩的，东西死贵也就罢了，连个卖风筝，卖水枪的都没有晕。。
额，谈恋爱？说到底就是看人家长的漂亮晕，我早就不相信爱情了。。
最后说说编程什么的，我愈发感觉我原来的风格都可以去死了，程序说白了就是不要错，错了就0分，时间空间关系都不大，所以写起来也就是要方便调试，方便修正，我原来华丽花哨的编法真是垃圾，现在我init之类的函数都懒得写了，没意义。最近在刻苦钻间gdb，调试真的很重要，很多时候可以节省大量的时间。我NOIP就是栽在这上面了。