ihe 1110310415 linyiming QQ：545931195

首先对于两点(x1,y1),(x2,y2)二维的曼哈顿距离为|x1-x2|+|y1-y2|将绝对值去掉，再将同一点的坐标归于一处可得四种情况:1.x1-x2+y1-y2->(x1+y1)-(x2+y2)2.x2-x1+y1-y2->(-x1+y1)-(-x2+y2)3.x1-x2+y2-y1->(x1-y1)-(x2-y2)4.x2-x1+y2-y1->(-x1-y1)-(-x2-y2)

/*这个题的简单比较容易想到。在两个剪枝的情况下。进行DFS。三个参数分别是num表示目前已经组成的边数，len为当前的边的边长，s为枚举木棒的起点。边枚举的顺序从大到小。*/#include #include #include #include using namespace std;int n,size;bool vis[21];int a[21];bool dfs(i

#include #include int map[21][21];int move[4][2]= {{1,0},{-1,0},{0,1},{0,-1}};int row,col,ans;bool ret;void dfs(int x,int y,int step){ if(step>10) return ; for(int i=0; i<4; i++) {

/*就是对每一个点作一遍DFS，进行联通块的搜索。*/#include #include char map[101][101];bool vis[101][101];int n,m,ans;int move[8][2]={{1,0},{1,1},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1}};void dfs(int x,int y){

/*挺好的一道DFS。有几个trick。一个就是方向向量的顺序，不需要遍历每一个起始点，则需要按字母第一关键字，数字第二关键字进行向量方向的安排。然后就是图的行列问题。p行去列，实际上存图的时候是x<=q &&y<=p，这个细节要注意。*/#include #include bool vis[30][30];int ansx[1001];int ansy[1001];int p

/*DFS+回溯。*/#include #include int n,k,ans;char map[9][9];bool vis[100];bool x[9],y[9];void dfs(int sum,int col){ if(sum>=k) { ans++; return ; } if(col>n) retur

#include #include #include #include using namespace std;const int maxn=1001;struct edge{ int to,next;} e[10005];struct word{ char s[25];} word[maxn];bool vis[maxn],used[27];int he

/*首先考虑一个没有成环的序列，从1 2 3 4 ... n 转移成 n ... 3 2 1的状态需要 n*(n-1)/2.即可以这样考虑，把1转移到最后端需要相邻调换n-1次，再把2转移到1右端需要n-2次。一次类推，总次数为1+2+3+...+n-1=n*(n-1)/2.现在再考虑成环的情况，即可以在中间选一个点，将环拆成两条链，自然是取中点，即N/2,*/#include int

/*怎么说呢。看了两份报告，算是规律吧。10可以分解成2*5，也就是说N！末尾有多少个0就可以分解成多少个5.。特别的，25可以分解成两个5,125可以分解成3个5.所以写法如下。*/#include int main(){ int t,n; scanf("%d",&t); while(t--) { scanf("%d",&n);

/*题意自己看。思路是先找出每个字符对应矩形框的的边界，即四个角的值。然后排个序。对每个字符对应的矩型框，扫描在矩形框上和该字符不相同的字符，然后在这两个字符之间连一条边，更新后一个字符的入度，有个需要注意的地方就是对每一个字符的矩形框上的不同字符，若出现好几次，则只更新一次入度，这个可以用一个bool数组来判重。然后图统计好之后就开始拓扑排序。因为要按字典序输出多组解。所有采用D

/*一直对深搜中的回溯不是很理解。用这个题来加深一下吧。先用下hash，在排序。对于不在拓扑排序中出现的点，在统计中的入度也为0，如案例1中的g，这样在深搜的过程中按照字典序进行排列即可。*/#include #include #include #include #include using namespace std;char a[21];int b[21],in[21

#include int main(){ double n,k; while(scanf("%lf%lf",&n,&k)==2) { if(n==0&&k==0) break; double ans=1; if(2*k>n) k=n-k;//注意优化 while(k>=1)//分子是n*n-1*...*n-

/*注意在查询的时候要将标记下方。*/#include #include #define maxn 100001int c[maxn<<2];bool color[31];int lazy[maxn<<2];void swap(int &a,int &b){ int temp; temp=a; a=b; b=temp;}void build(in

树状数组其统计量的变化，可以动态删除区间，更新区间，更新节点，区间统计，单点求值。大部分题的代码在博客中有。利用对和的二分，可以快速的求解第K大。主要注重问题的转化和应用。1.hoj 2275 Number sequence 利用树状数组来统计个数，左边比他小的元素的个数，顺序将元素的个数更新为1，统计右边比他大的元素个数，可以逆序更新，取和求统计个数是动态过程。2.Ultra-Quic

数组a[x]的含义是个数为x的组有多少个。利用树状数组更新a，合并，则原先个数所在的集合-1.新形成的几何集合.#include #include const int maxn=200010;int c[maxn+1],f[maxn+1],a[maxn+1];inline int lowbit(int x){ return x&(-x);}void updat

#include #include const int maxn=1001;int c[maxn][maxn];inline int lowbit(int x){ return x&(-x);}int sum(int x,int y){ int ans=0; for(int i=x; i>0; i-=lowbit(i)) for(int j=

#include #include const int maxn=1050;int c[maxn][maxn];inline int lowbit(int x){ return x&(-x);}void update(int x,int y,int p){ for(int i=x; i<maxn; i+=lowbit(i)) for(int j=y;

#include #include const int maxn=101;int c[maxn][maxn];inline int lowbit(int x){ return x&(-x);}void update(int x,int y){ for(int i=x; i<=maxn; i+=lowbit(i)) for(int j=y; j<=ma

123

#include #include int c[32001];int s[15001];inline int lowbit(int x){ return x&(-x);}void update(int p,int d){ for(int i=p; i<=32001; i+=lowbit(i)) c[i]+=d;}int sum(int x){

#include #include #include #include using namespace std;const int maxn=500001;int c[maxn],n,m;struct NUM{ int id,num;} a[maxn];int cmp1(NUM a,NUM b){ return a.num<b.num;}int cmp2(

#include #include #include using namespace std;const int maxn=100005;int c[maxn+1];struct point{ int s,e,ans,id;} p[maxn+1];inline int lowbit(int x){ return x&(-x);}void update(int

#include #include #include using namespace std;const int maxn=1005;long long c[maxn+1];struct point{ int x,y;} p[1000005];inline int lowbit(int x){ return x&(-x);}void update(int x

#include #include struct edge{ int to,next,w;};int n,m,t,h;edge q[40001<<1],rq[401];//q存的是原数组，rq存的是询问数组。int head[40001],head1[40001],dis[40001],f[40001];//dis表示当前节点到跟节点的距离。bool vis[40001];

/*题意就是至少加多少条边，使得任意两点间至少有两条不同的路。求双连通分量。然后统计叶子个数，即入度为1的点的个数，然后ans=(num+1)/2.在求双连通分量的过程中low值相等的是在同一个分量里。不需要用stack来进行保存。*/#include #include #include using namespace std;const int maxm=10001;cons

/*本来是稍有复杂的数学题。第一次用快速幂取模果断超时，最后将表打出，找规律。水过之，代码很短。*/#include int main(){ int a,b; while(scanf("%d%d",&a,&b)==2) { int ans=0; int sum=0; if(a%2==0) {

/*根据题意。如果该点是不可见的。则必定经过整数点。也就是非互质。相反，如果是可见的，那么必定是互质的。则题目转为求1-n内的互质点对数。即为求1-ai(i:1-n)内的欧拉函数值。可现在1-n的范围内用递推打表生成欧拉函数值。*/#include const int maxn=1001;int phi[maxn];void get_phi()//获取1-maxn范围内的欧拉函数表{

/*这种思路是在网上借鉴的。很好。速度也非常快。自己实现了一遍。在poj上181MS。主要是分别一起点和终点为源点作两次spfa。然后次短路必定是dist[u]+w+rdist[v]。枚举边。u,v,为边的两个端点，w为边的权值。这个值需要满足的条件是 >dist[n]，然后再最小值。*/#include #include #include #include using nam

/*题意就是给了你m个电器，n个插头，tt个转换器，以及自己增加一个虚拟的源点和汇点。将转换器和插头相连的边置为无穷大。其余的边长度都置为1.该模板中n表示图中节点的总数。最后要记得修改。还有一点需要注意的就是转换不是只有样例中给出的'X，可能有无数个，无数种类型。在这里借鉴了一种网上map的写法。很简介。下面这个网址给了一张图很详细。一看便知http://www.cnblogs.com/lo

/*题意中给出多个节点和多个发电站与消费站。可以建一个虚拟的源点和虚拟的汇点，将所有的发电站和源点连一条边，将所有的消费占和汇点连一条边。然后利用网络流建图即可。下面是SAP算法。*/#include #include #include #define SETZR(a) memset(a,0,sizeof(a))using namespace std;const int MAXM =

/*无向图的最小环问题： 无向图的最小环的求法不可能和有向图的求法一样， 因为在有向图中i 到j 和 j 到i 算是一个环，但在无向图中不是一个环，如果直接用flody算法将会出错， 有向图的环可以为2个顶点，而无向图的环至少要三个顶点； 所以为了求无向图的最小环， 我们采用的原理是：　枚举最大环中的连接点，更新环的权重；比普通Floyd多出来的部分,主要利用到的原理是当处理到k时,所有以

/*题意比较晦涩，大致就是求一个图缩点后出度为0的点的个数。*/#include #include #include #include using namespace std;vector e[5010];int dfn[5001];int low[5001];int stack[5001];bool instack[5001];int belong[5001];int

/*经典的dij统计路的数量的好题！增加一维表示最短和次短两个状态。0表示最短，1表示次短。邻接表和邻接阵结合使用。加快速度。在统计数量的部分有详细的注释。*/#include #include const int maxm=10001;const int maxn=1001;const int inf=1<<30;struct edge{ int from,to,nex

#include #include struct edge{ int next,to;} e[10001];int dfn[101];int low[101];int head[101];int ans[101];int n,tot,root=1,num;void add(int a,int b){ e[tot].to=b; e[tot].next=h

/*题意是在一些有洞的棋盘上用一个1x2的方形条将棋盘完全填满。可以对不是洞的每一个点找和他相邻的点，如果他相邻的点也不是洞的话，就画一条边。然后获取标号。实际上就是一个将一个点拆分成两个点的想法。将||可能||，可能匹配的点都连一条！！*/#include #include #include #include using namespace std;int map[40][40];

#include #include #define mm 500bool fuck[mm];int wokao[mm][100];long long ca[mm][mm];int p[100];int main(){ int t=0,x,n; memset(fuck,0,sizeof(fuck)); fuck[0]=fuck[1]=0; for(in

#include int phi(int n){ int rea=n; for(int i=2;i*i<=n;i++) if(n%i==0) { rea=rea-rea/i; do n/=i; while(n%i==0); } if(n>1) rea=rea-rea/n;

/*floyd的妙用啊。和倍增的思想有点类似。对哈希后的图矩阵作N次floyd后，图中任意两点的值表示两点之间路的条数。如果c[k][k]!=0，则说明k是环上一点。*/#include #include #include using namespace std;int map[31][31];int main(){ int n,a,b,t; int ca=0;

/*题意是求一个离终点最近的点使得去掉该点之后起点到终点不连通。*//*对于距离最近，可以终点为源点作spfa，预处理出从终点到其余各点的最短路径，这里有些细节要注意，一个是松弛时应用map[i][x]的松弛的条件，而非map[x][i]，因为题意是有向图且路径方向是从起点到终点，然后直接相邻的两个点边权处理为1.最后是用深搜判断两点是否连通。*/#include #include

#include #include const int mod=10000;int A[3][3],ans[3][3];void mul(int a[][3],int b[][3]){ int tmp[3][3]; for(int i=1; i<=2; i++) for(int j=1; j<=2; j++) { t