Baudelaire is Programmer

1.Snail Trail

DFS，Snail的移动路线可以分为一个个线段，每个线段成为DFS的一个阶段，当Snail在一个方向上运动受阻时枚举转向的方向并进入下一阶段。开始时由于我重复搜索运动受阻时的点导致无限重复“撞墙”结果爆栈了，看来在写递归函数时还有很多细节需要注意。

/*
ID: huilong1
LANG: C++
TASK: snail
*/
#include<iostream>
#include<fstream>
#include<stdlib.h>
using namespace std;

ifstream fin;
ofstream fout;
int N,B;
char map[121][121];
int direct[4][2]={
	{0,1},{0,-1},{1,0},{-1,0}
};

int dfs(int x,int y){
	int maxlen=0;
	for(int k=0;k<4;k++){
		int len=0;
		int i,j;
		i=x;
		j=y;
		while(1){
			int nx,ny;
			nx=i+direct[k][0];
			ny=j+direct[k][1];
			if(nx>=N||nx<0||ny>=N||ny<0||map[nx][ny]=='#'){
				if(len==0)break;//防止重复“撞墙”造成的爆栈
				int futurlen=dfs(i,j);
				if(len+futurlen>maxlen)maxlen=futurlen+len;
				break;
			}
			if(map[nx][ny]=='-'){
				if(len>maxlen)maxlen=len;
				break;
			}
			i=nx;
			j=ny;
			map[i][j]='-';
			len++;
		}
		if(len==0)continue;//这句很重要，防止消除痕迹时形成死循环
		int ii=x+direct[k][0],jj=y+direct[k][1];
		//回溯，消除痕迹
		while(!(ii==i&&jj==j)){
			map[ii][jj]='.';
			ii+=direct[k][0];
			jj+=direct[k][1];
		}
		map[i][j]='.';
	}
	return maxlen;
}

int main(){
	fin.open("snail.in");
	fout.open("snail.out");
	fin>>N>>B;
	for(int i=0;i<N;i++)for(int j=0;j<N;j++)map[i][j]='.';
	for(int i=0;i<B;i++){
		char x;
		int y;
		fin>>x>>y;
		map[(int)(x-'A')][y-1]='#';
	}
	map[0][0]='-';
	fout<<dfs(0,0)+1<<endl;
	return 0;
}

2.Electric Fences

题目对精度要求不高，可以把平面坐标扩大10倍，这样就只需搜索0=<x<=1000和0<=y<=1000范围内的整点，但是搜索所有点还是会超时。首先试验了一下模拟退火算法（Simulated annealing），结果由于对“温度”和随机变化的过程把握不好，导致得到次优解并且波动很大，最终放弃并试了一个不太严谨的方法：先按步长为10搜索所有整点，找到其中的最优点，然后在最优点x和y方向上+-10的范围内提高精度按步长1搜索最优解。

3.Visconsin Square

时限是5秒，简单的DFS就可以过。

模拟退火（Simulated annealing）算法：

以下内容出自heaad的博客

/*
 *  J(y)：在状态y时的评价函数值
 *  Y(i)：表示当前状态
 *  Y(i+1)：表示新的状态
 *  r： 用于控制降温的快慢
 *  T： 系统的温度，系统初始应该要处于一个高温的状态
 *  T_min ：温度的下限，若温度T达到T_min，则停止搜索
*/
while( T > T_min )
{
　　dE = J( Y(i+1) ) - J( Y(i) ) ;  

　　if ( dE >= 0 )  //表达移动后得到更优解，则总是接受移动
        Y(i+1) = Y(i) ;  //接受从Y(i)到Y(i+1)的移动
　　else
　　{
    // 函数exp( dE/T )的取值范围是(0,1) ，dE/T越大，则exp( dE/T )也
        if ( exp( dE/T ) > random( 0 , 1 ) )
            Y(i+1) = Y(i) ;  //接受从Y(i)到Y(i+1)的移动
　　}
　　T = r * T ;  //降温退火 ，0<r<1 。r越大，降温越慢；r越小，降温越快
　　/*
　　* 若r过大，则搜索到全局最优解的可能会较高，但搜索的过程也就较长。若r过小，则搜索的过程会很快，但最终可能会达到一个局部最优值
　　*/
　　i ++ ;
}

四. 使用模拟退火算法解决旅行商问题

1.Fencing the Cows

二维凸包（Convex Hulls）问题。

以下是usaco training上的教程：

• Find a point which will be within the convex hull:【注1】
• Calculate the angle that each point makes with the x axis (within the range 0 to 360 degrees)【注2】
• Sort the points based on this angle
• Add the first two points
• For every other point except the last point
• Make it the next point in the convex hull
• Check to see if the angle it forms with the previous two points is greater than 180 degrees. As long as the angle formed with the last two points is greater than 180 degrees, remove the previous point【注3】
• To add the last point
• Perform the deletion above,
• Check to see if the angle the last point forms with the previous point and the first point is greater than 180 degrees or if the angle formed with the last point and the first two points is greater than 180 degrees.【注4】
• If the first case is true, remove the last point, and continue checking with the next-to-last point.
• If the second case is true, remove the first point and continue checking.
• Stop when neither case is true.
• The adding of the points is linear time, as is the calculation of the angles. Thus, the run-time is dominated by the time of the sort, so gift-wrapping runs in O(nlogn) time, which is provably optimal.

【注1】：

计算点集的中点（可以简单地取所有点在x和y方向上的均值）。此点必在凸包内。

【注2】：

计算各个点与中点的连线与x轴的夹角（在0到2pi之间），这个可以使用C语言math.h库函数中的atan2(double y,double x)来实现，不过注意atan2的值域是(-pi,pi]，需要进一步将其映射到[0,2pi)区间内。此外注意atan2(0,0)==0，所以我们可以放心地将其应用到中点和点集中某点重合的情况。

【注3】：

检查逆时针连续的三点是否形成“右转”的角，如果“右转”就把“转角”的点删除，否则会出现一个凹多边形。注意删除一个“转角”之后还要要不断检查之前的点，直到该删除的点全部删除为止。

【注4】：

到此为止从第一个点逆时针转到最后一个点的所有“转角”都成为左转的角了，但是当我们把最后一个点和第一个点相连时，这两个点处的“转角”还可能是“右转”的。为了排除这种情况我们要不断检查第一个和最后一个点，如果“右转”就删除，直到它们全部“左转”为止。

怎样判断是否“右转”：

设有逆时针方向连续的三点(x1,y1),(x2,y2),(x3,y3)，首先取两向量<x2-x1,y2-y1>(记为<p1,q1>)和<x3-x2,y3-y2>(记为<p2,q2>)，当两向量的向量积的z分量小于0时（即p1q2-p2q1<0）就形成了所谓的“右转”关系。

2.Starry Night

可以简单地应用floodfill来找出所有星座。比较星座是否相同时有些麻烦，因为涉及到平移、旋转、翻转等操作，我是通过修改比对星座时的遍历顺序来实现的，这样最多一共需要比对八种遍历方式下两星座图是否重合。

3.Musical Themes

用一个时间复杂度是O(L*N²)的算法过了。其中N是音符的数量，L是需要比对的Themes的平均长度，由于这个L难以预料，所以多少有点侥幸。思路如下：

用dp[i]表示前i个音符中themes的最大长度，用note数组表示所有的音符，则有

dp[i]={

    dp[i-1]+1(if note[i-dp[i-1]]...note[i]这个序列或其变调形式

              可以在note[0]...note[i-dp[i-1]-1]范围内找到);

    dp[i-1](if not)

}

注意dp[i]比dp[i-1]大1当且仅当note[i]加入后可以与前dp[i-1]个音符形成一个新theme。

usaco的官方题解给出了一个O(N²)的算法，更充分地利用了每一步的计算结果：

Let theme(i,j) be the length of the longest theme which occurs starting at both note i and j. 

Note that if note[i+1]-note[i]==note[j+1]-note[j], than theme(i,j)=1+theme(i+1,j+1). Otherwise, theme(i,j)=1.

Thus, we order the search in such a way that theme(i,j) is tested immediately after theme(i+1,j+1), keeping track of the length of the current theme, as well as the length of the longest theme found so far.

#include <fstream.h>

int     n;
int     note[5000];

int 
main () {
    ifstream filein ("theme.in");
    filein >> n;
    for (int i = 0; i < n; ++i) 
	filein >> note[i];
    filein.close ();

    int     longest = 1;

    for (int i = 1; i < n; ++i) {
	int     length = 1;
	for (int j = n - i - 1 - 1; j >= 0; --j) {
	    if (note[j] - note[j + 1] == note[j + i] - note[j + i + 1]) {
		++length;
		if (length > i) 
		    length = i;
		if (longest < length)
		    longest = length;
	    }
	    else {
		length = 1;
	    }
	}
    }

    ofstream fileout ("theme.out");
    fileout << ((longest >= 5) ? longest : 0) << endl;
    fileout.close ();

    exit (0);
}

 1.Shuttle Puzzle
本来以为是个什么神搜索，原来是个找规律构造题。本来枚举量不算大，不过我没想到判重的好方法，不判重又怕超时，所以还是copy了题解的规律。就这样水过了。

2.Pollutant Control
求边数最少的最小割，如果有多个方案，输出边的输入顺序最小的那个。把每个边的容量Ci修改为Ci*1001+1，因为边数最大为1000，这样求出最大流tot之后tot/1001就是原图的最小割，tot mod 1001就是最小割的边数，这样同时保证了最小割有最小边数。然后按输入顺序枚举每条边，如果移除这条边（Ci）后求得的最大流totnew满足tot-totnew=Ci，则输出这条边，然后在此基础上继续枚举删边求最大流的过程。

3.Frame Up
全拓扑排序。

allTopSort(G){
    if(图G为空){
        输出缓存
        return
    }
    for(G中每个入度为零结点v){
        将v放入缓存
        从G中删除v及其出边，更新相连的结点的入度
        allTopSort(G)
        恢复v及其出边
    }
}

1.Drainage Ditches
基础的最大流问题，基本步骤是找增广路径，更新残余网络，直到搜索不到增广路径。

2.The Perfect Stall
最大二分匹配，可以使用hungary算法

bool find(int c){
    for(int j=0;j<M;j++){
        if(!graph[c][j]||inpath[j])continue;//如果没有边相连或者j被搜索过则略过
        inpath[j]=true;//把j放到增广路径上，true表示j已经被搜索过
        if(pair[j]==-1||find(pair[j])){
            pair[j]=c;//更新匹配关系
            return true;
        }
        //inpath[j]=false; 加上这句会超时，其实这里并不用回溯
        //因为inpath标识了从j出发能否找到增广路径
    }
    return false;
}
void hungary(){
    for(int i=0;i<N;i++){
        //i必定还没有被匹配
        for(int j=0;j<M;j++)inpath[j]=false;
        if(find(i))match++;
    }
}

3.Job Processing
各种借鉴。
用贪心算法分别求出A机器集合和B机器集合单阶段各自的最优解。为求得整体最优解，把A机器处理的工件的时间线和B机器处理的工件的时间线相接。
此图来自usaco官方题解：


4.Cowcycles
枚举量看似很大，实际上可以水过，注意防止重复计算。
算方差可以用公式D[X]=E[X^2]-E[X]^2
枚举代码有些臃肿：

//用pick(F1,F2,R1,R2,F,R)表示在[F1,F2]区间选取F个数，在[R1,R2]区间选取R个数
void pick(int f1,int f2,int r1,int r2,int f,int r){
    int i,j;
    if(f==0&&r==0){
        calcul();
        return;
    }
    if(f*r!=0){
        for(i=f1;i<=f2-f+1;i++){
            for(j=r1;j<=r2-r+1;j++){
                seqf[F-f]=i;
                seqr[R-r]=j;
                pick(i+1,f2,j+1,r2,f-1,r-1);
            }
        }
    }
    else if(f==0){
        for(j=r1;j<=r2-r+1;j++){
            seqr[R-r]=j;
            pick(f1,f2,j+1,r2,f,r-1);
        }
    }
    else if(r==0){
        for(i=f1;i<=f2-f+1;i++){
            seqf[F-f]=i;
            pick(i+1,f2,r1,r2,f-1,r);
        }
    }
    return;
}

Beef McNuggets
数论，动态规划。

确定一个数c能否由a1,a2,a3...,an线性组合而成等效于求一次不定方程
a1*x1+a2*x2+...+an*xn=c ( x1,x2,...,xn>=0 ) (方程A)
是否有解。

裴蜀定理：裴蜀等式ax+by=m(a,b>0)有解当且仅当m是a b的最大公约数gcd(a,b)的倍数。

若gcd(a,b)>1 则方程对于无限个m无解。

若gcd(a,b)=1。当a,b>1时，如果要求x y非负数，m取某些值时无解，比如m=1时。那么是否只有有限个m无解呢？答案是肯定的：
设a,b互质，x0,y0是此方程的特解。其通解可以表示为x=x0+[b/gcd(a,b)]*t , y=y0+[a/gcd(a,b)]*t (t为任意整数)。
令x>=0且y>=0，得-x0/b<=t<=y/a，显然y0/a+x0/b>1时存在t满足此不等式，也即方程有解。令y0/a+x0/b>1，有a*x0+b*y0=m>ab。
可见当m大于ab时方程必有解。

把此结论推广到方程A可知：当gcd(a1,a2,...,an)=1时，有有限个c无解，也就是说我们可以求出一个最大的不能被表示的c；否则有无限个c无解。

确定一个数能否被表示出来可以简单地应用动态规划，如果连续出现256个数字可以被表示出来，那么之后所有数字均可以被表示出来，此时可以停止动态规划。

USACO题解中第二种方法认为数据中必有两个数字互质，所以可以只搜索256*256-2*256以内的数字能否被表示（因为“Given two relatively prime numbers N and M, the largest number that you cannot make is NM - M - N”）。

这个方法对于USACO的数据是正确的，因为这些数据只要有一个大于零的解，都有其中两个数字互质的情况出现。但是显然某些情况下n个数互质，但是两两不互质，比如21 35 15。所以我认为这个方法是有漏洞的。

Fence Rails

搜索，需要精心剪枝。

迭代加深搜索（IDDFS: Iterative deepening depth-first search）：控制搜索层数的DFS，即首先允许深度优先搜索K层搜索树，若没有发现可行解，再加大搜索层数（如K+1）重复搜索。

“一般来说，如果目标结点离根结点远，需要遍历整棵树，可以考虑使用深度优先搜索；如果目标离根结点近，或求最小步数，则考虑广度优先搜索或迭代加深搜索；若广度优先搜索存在空间不够的问题，则考虑使用迭代加深搜索。”（本段来源于：http://wenku.baidu.com/view/ce41b54669eae009581bec4a.html）

首先对rails从小到大进行排序，确定所给的boards能否切出n个rails实际上等效于确定所给的boards能否切出排序后的前n个rails。为此我们使用IDDFS，先确定一个搜索深度（即上述的n），再深搜每个rail对应的board，搜索到第一个可行的切割方式时就返回。

搜索时先搜索较大的rail，这样可以让搜索树比较“瘦”（相对于先搜索较小的rail），也就是说树基部的分支较少。

显然这时搜索的时间很大程度上取决于搜到可行解之前我们探索了多少失败的方式，如果能剪掉这些“失败树枝”就好了。所以我们需要提前预知必然的失败并且果断停止在这些“失败树枝”上继续搜索。设boards总长度是B，rails总长度是R，搜索过程中的边角料（不能再切出其他rail）的总长度为W，当B-R<W时可以剪枝。

board最大长度是128，但是rail总数会达到1023之多，可见长度重复的rails有很多，要避免因此产生的重复搜索，比如rail1=rail2=5，那么搜索rail2时只需从rail1对应的board开始。

Fence Loops
水搜索，简单地使用dfs就可以秒杀所有数据。实际上求图中最小环的正统方法是枚举环上的一条边然后求最短路径，不过输入数据是边的邻接信息，而最短路径算法是基于结点的邻接矩阵或者邻接表的，需要重构一下。构造邻接矩阵时可以保留所有篱笆的端点（即使它们会重合），这样最多200个结点，发现两结点重合就将距离置为0。

Cryptcowgraphy
搜索加剪枝。
两个剪枝：
（1）判断C O W字符之间的片段是否是明文的子串，不是就剪枝。
（2）判断第一个和最后一个加密用字符是不是分别为C和W，不是就剪枝。
防止重复搜索相同状态：
如果搜索到的C O W，它的CO或者OW区间内包含上次使用的C O W，就剪枝；比如本次搜索到的COW用红色表示，上次使用的COW用黑色表示，以下情况需要剪枝：CCOWOW 或 COCOWW 。这是因为先应用黑色COW和先应用红色COW效果相同。
使用以上剪枝还不够，为了配合第2个剪枝，我将搜索顺序设定为先搜索跨度较大的COW再搜索跨度较小的COW。至此AC。
 

/*
ID: huilong1
LANG: C++
TASK: fence4
*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define ESP 1e-4
FILE *fin,*fout;

typedef struct{
	double x;
	double y;
}Point;

typedef struct{
	Point a;
	Point b;
}Seg;

typedef struct{
	double x;
	double y;
	double z;
}Vector;

int N;
Seg fence[201];
Point obser;
Point corner[201];
Seg visible[201];
int numsee;

//判断是否是相邻的篱笆 
bool neighbor(int i,int j){
	if(i==0&&j==N-1||i==N-1&&j==0)return true;
	int abs=i-j;
	if(abs<0)abs=-abs;
	if(abs==1)return true;
	return false;
}

//获得中点
Point getmiddle(Point a,Point b){
	Point m;
	m.x=(a.x+b.x)/2;
	m.y=(a.y+b.y)/2;
	return m;
}

//算点积
double dotpro(Vector a,Vector b){
	return a.x*b.x+a.y*b.y+a.z*b.z;
}

//算叉积
Vector crosspro(Vector a,Vector b){
	Vector t;
	t.x=a.y*b.z-a.z*b.y;
	t.y=a.z*b.x-a.x*b.z;
	t.z=a.x*b.y-a.y*b.x;
	return t;
} 

//获得两点决定的向量
Vector getvector(Point a,Point b){
	Vector t;
	t.x=b.x-a.x;
	t.y=b.y-a.y;
	t.z=0;
	return t;
} 

//判断线段是否交叉
bool cross(Seg p,Seg q){
	Vector pv=getvector(p.a,p.b);
	Vector qv=getvector(q.a,q.b);
	Vector paqa=getvector(p.a,q.a);
	Vector paqb=getvector(p.a,q.b);
	Vector pbqa=getvector(p.b,q.a);
	Vector pbqb=getvector(p.b,q.b);
	Vector qapa=getvector(q.a,p.a);
	Vector qapb=getvector(q.a,p.b);
	//判断两线段是否共线
	Vector v1=crosspro(pv,paqa);
	Vector v2=crosspro(pv,paqb);
	if(v1.z==v2.z&&v1.z==0){//共线 
		if(dotpro(paqa,paqb)>0&&dotpro(pbqa,pbqb)>0)return false;
		else return true;
	}
	//不共线 
	if(dotpro(v1,v2)>0)return false;
	if(dotpro(crosspro(qv,qapa),crosspro(qv,qapb))>0)return false;
	return true;
} 

//判断是否能看到点
int seepoint(Point p,int ind){
	Seg view;
	view.a=obser;
	view.b=p;
	for(int i=0;i<N;i++){
		if(i==ind)continue;
		if(cross(view,fence[i]))return i;
	}
	return -1;
} 

//判断线段是否收缩为一个点 
bool ispoint(Seg s){
	Point a=s.a;
	Point b=s.b;
	if((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)<ESP)return true;
	return false;
}

//判断是否可见 
bool cansee(Seg s,int ind){
	if(ispoint(s))return false;
	Point a=s.a;
	Point b=s.b;
	Point mid=getmiddle(a,b);
	int sta,stb,stmid;
	sta=seepoint(a,ind);
	stb=seepoint(b,ind);
	stmid=seepoint(mid,ind);
	if(sta==stb&&sta>=0)return false;
	if(sta<0||stb<0||stmid<0)return true;
	Seg t;
	t.a=a,t.b=mid;
	if(cansee(t,ind))return true;
	t.a=mid,t.b=b;
	if(cansee(t,ind))return true;
	return false;
} 

int main(){
	fin=fopen("fence4.in","r");
	fout=fopen("fence4.out","w");
	fscanf(fin,"%d",&N);
	fscanf(fin,"%lf %lf",&obser.x,&obser.y);
	for(int i=0;i<N;i++){
		fscanf(fin,"%lf %lf",&corner[i].x,&corner[i].y);
	}
	
	//按顺序生成篱笆 
	for(int i=0;i<=N-2;i++){
		fence[i].a=corner[i];
		fence[i].b=corner[i+1];
	}
	fence[N-1].a=corner[0];
	fence[N-1].b=corner[N-1];
	
	//判断篱笆合法性 （不相邻的不能相交） 
	for(int i=0;i<N;i++){
		for(int j=0;j<i-1;j++){
			if(!neighbor(i,j)&&cross(fence[i],fence[j])){
				//printf("%d %d\n",i,j);
				//system("pause");
				fprintf(fout,"NOFENCE\n");
				return 0;
			}
		}
	}
	
	//为了按顺序输出 调整篱笆顺序 
	Seg t=fence[N-1];
	fence[N-1]=fence[N-2];
	fence[N-2]=t;
	
	for(int i=0;i<N;i++){
		if(cansee(fence[i],i)){
			visible[numsee]=fence[i];
			numsee++;
		}
	}
	fprintf(fout,"%d\n",numsee);
	for(int i=0;i<numsee;i++){
		fprintf(fout,"%.0lf %.0lf %.0lf %.0lf\n",visible[i].a.x,visible[i].a.y,visible[i].b.x,visible[i].b.y);
	}
	//system("pause");
	return 0;
}

/*
ID: huilong1
LANG: C++
TASK: heritage
*/
#include<stdio.h>
#include<stdlib.h>

FILE *fin,*fout;
char in[26];
int hashin[26];
char pre[26];
int num;

void showpost(int prebeg,int preend,int inbeg,int inend){
	if(prebeg>preend)return;
	showpost(prebeg+1,
	         prebeg+hashin[pre[prebeg]-'A']-inbeg,
			 inbeg,
			 hashin[pre[prebeg]-'A']-1);
	showpost(prebeg+hashin[pre[prebeg]-'A']-inbeg+1,
             prebeg+hashin[pre[prebeg]-'A']-inbeg+inend-hashin[pre[prebeg]-'A'],
			 hashin[pre[prebeg]-'A']+1,
			 inend);
	fprintf(fout,"%c",pre[prebeg]);
	return;
}

int main(){
	fin=fopen("heritage.in","r");
	fout=fopen("heritage.out","w");
	while(fscanf(fin,"%c",&in[num])&&in[num]!='\n'){
		hashin[in[num]-'A']=num;
		num++;
	}
	int i;
	for(i=0;i<num;i++)fscanf(fin,"%c",&pre[i]);
	showpost(0,num-1,0,num-1);
	fprintf(fout,"\n");
	//system("pause");
	return 0;
}

观察线段的二分法

以下出自（http://www.cppblog.com/jericho/archive/2011/01/19/138837.html）

Agri-Net

最小生成树问题。应用Prim算法或Kruskal算法。

/*
ID: huilong1
LANG: C++
TASK: agrinet
*/
#include<stdio.h>
#include<stdlib.h>

int N;
FILE *fin,*fout;
int map[100][100];
int dist[100];
bool had[100];

int main(){
	fin=fopen("agrinet.in","r");
	fout=fopen("agrinet.out","w");
	fscanf(fin,"%d",&N);
	int i,j;
	for(i=0;i<N;i++)
		for(j=0;j<N;j++)
			fscanf(fin,"%d",&map[i][j]);
	for(i=0;i<N;i++)dist[i]=map[0][i];
	had[0]=true;
	int res=0;
	for(i=1;i<N;i++){
		int min=0x7fffffff;
		int pmin;
		for(j=1;j<N;j++){
			if(!had[j]&&min>dist[j]){
				min=dist[j];
				pmin=j;
			}
		}
		res+=min;
		had[pmin]=true;
		for(j=1;j<N;j++){
			if(had[j])continue;
			if(map[pmin][j]<dist[j])
				dist[j]=map[pmin][j];
		}
	}
	fprintf(fout,"%d\n",res);
	//system("pause");
	return 0;
}

Score Inflation

动态规划，完全背包问题（参见《背包九讲》）。状态转移方程:

dp[n][m]=max{dp[n][m-time(n)]+score(n); dp[n-1][m]}

/*
ID: huilong1
LANG: C++
TASK: inflate
*/
#include<stdio.h>
#include<stdlib.h>

FILE *fin,*fout;
int dp[10001];
int score[10001];
int time[10001];
int N,M;

int main(){
	int i,j;
	fin=fopen("inflate.in","r");
	fout=fopen("inflate.out","w");
	fscanf(fin,"%d %d",&M,&N);
	for(i=1;i<=N;i++)
		fscanf(fin,"%d %d",&score[i],&time[i]);
	for(j=0;j<=M;j++)dp[j]=0;
	for(i=1;i<=N;i++)
		for(j=1;j<=M;j++){
			if(j-time[i]>=0&&dp[j-time[i]]+score[i]>dp[j])
				dp[j]=dp[j-time[i]]+score[i];
		}
	fprintf(fout,"%d\n",dp[M]);
	//system("pause");
	return 0;
}

Humble Numbers

策略是按顺序生成所有Humble Numbers。因为一个humble number必定可由另一个较小humble number乘以S集合中的某素数来生成，我们求第n个humble number时只须用素数试乘然后找出比第n-1个humble number大的那些结果中最小的。参考关键词：二分查找，记录位置。

Shaping Regions

矩形切割问题。

/*
ID: huilong1
LANG: C++
TASK: rect1
*/
#include<stdio.h>
#include<stdlib.h>

FILE *fin,*fout;
int A,B,N;

typedef struct{
	int ll[2];
	int ur[2];
	int c;
	bool exist;
}Rect;

Rect q[100000];
int tail;
int sum[2501];

int main(){
	fin=fopen("rect1.in","r");
	fout=fopen("rect1.out","w");
	fscanf(fin,"%d %d %d",&A,&B,&N);
	tail=0;
	q[0].c=1;
	q[0].ll[0]=0;
	q[0].ll[1]=0;
	q[0].ur[0]=A;
	q[0].ur[1]=B;
	q[0].exist=true;
	int i,j;
	int ll[2],ur[2],c;
	for(i=0;i<N;i++){
		fscanf(fin,"%d %d %d %d %d",
			&ll[0],&ll[1],&ur[0],&ur[1],&c);
		int newtail=tail;
		for(j=0;j<=tail;j++){
			if(!q[j].exist)continue;
			if(ll[0]>q[j].ur[0]||q[j].ll[0]>ur[0])continue;
			if(ll[1]>q[j].ur[1]||q[j].ll[1]>ur[1])continue;
			int x1,x2;
			int y1,y2;
			x1=ll[0]>q[j].ll[0]?ll[0]:q[j].ll[0];
			x2=ur[0]<q[j].ur[0]?ur[0]:q[j].ur[0];
			y1=ll[1]>q[j].ll[1]?ll[1]:q[j].ll[1];
			y2=ur[1]<q[j].ur[1]?ur[1]:q[j].ur[1];
			if(q[j].ll[0]<x1){
				newtail++;
				q[newtail].exist=true;
				q[newtail].c=q[j].c;
				q[newtail].ll[0]=q[j].ll[0];
				q[newtail].ll[1]=q[j].ll[1];
				q[newtail].ur[0]=x1;
				q[newtail].ur[1]=q[j].ur[1];
			}
			if(q[j].ur[0]>x2){
				newtail++;
				q[newtail].exist=true;
				q[newtail].c=q[j].c;
				q[newtail].ll[0]=x2;
				q[newtail].ll[1]=q[j].ll[1];
				q[newtail].ur[0]=q[j].ur[0];
				q[newtail].ur[1]=q[j].ur[1];
			}
			if(q[j].ll[1]<y1){
				newtail++;
				q[newtail].exist=true;
				q[newtail].c=q[j].c;
				q[newtail].ll[0]=x1;
				q[newtail].ll[1]=q[j].ll[1];
				q[newtail].ur[0]=x2;
				q[newtail].ur[1]=y1;
			}
			if(q[j].ur[1]>y2){
				newtail++;
				q[newtail].exist=true;
				q[newtail].c=q[j].c;
				q[newtail].ll[0]=x1;
				q[newtail].ll[1]=y2;
				q[newtail].ur[0]=x2;
				q[newtail].ur[1]=q[j].ur[1];
			}
			q[j].exist=false;
		}
		newtail++;
		q[newtail].exist=true;
		q[newtail].c=c;
		q[newtail].ll[0]=ll[0];
		q[newtail].ll[1]=ll[1];
		q[newtail].ur[0]=ur[0];
		q[newtail].ur[1]=ur[1];
		tail=newtail;
	}
	for(i=0;i<=tail;i++)
		if(q[i].exist)
			sum[q[i].c]+=(q[i].ur[0]-q[i].ll[0])*(q[i].ur[1]-q[i].ll[1]);
	for(i=1;i<=2500;i++)
		if(sum[i]>0)
			fprintf(fout,"%d %d\n",i,sum[i]);
	return 0;
}

Contact

从01序列中抓取每种长度的片段按二进制求值，哈希到一个数组进行统计。

Stamps

类似完全背包问题，但是对物品总数量有限制。

用dp[n][x]表示前n个面值的邮票凑成x最少要用多少张。

状态转移方程：

dp[n][x]=min{dp[n][x-value(n)]+1; dp[n-1][x]}

/*
ID: huilong1
LANG: C++
TASK: stamps
*/
#include<stdio.h>
#include<stdlib.h>

#define IMPOSSIBLE (201)

FILE *fin,*fout;
int N,K;
int value[51];
unsigned char dp[2000001];

int main(){
	fin=fopen("stamps.in","r");
	fout=fopen("stamps.out","w");
	fscanf(fin,"%d %d",&K,&N);
	int i;
	for(i=1;i<=N;i++)fscanf(fin,"%d",&value[i]);
	dp[0]=0;
	for(i=1;i<=2000000;i++)dp[i]=IMPOSSIBLE;
	int j;
	for(i=1;i<=N;i++)
		for(j=1;j<=2000000;j++)
			if(j-value[i]>=0&&dp[j-value[i]]!=IMPOSSIBLE)
				if(dp[j-value[i]]+1<dp[j]){
					dp[j]=dp[j-value[i]]+1;
					if(dp[j]>K)dp[j]=IMPOSSIBLE;
				}
	for(i=1;i<=2000000;i++)
		if(dp[i]==IMPOSSIBLE)break;
	fprintf(fout,"%d\n",i-1);
	//system("pause");
	return 0;
}

矩形切割

以下出自薛矛神牛的讲义：