2010年06月_fengyu0556

原创 POJ_1088_滑雪

#include<stdio.h>#include<string.h>int hgt[105][105],f[105][105];int di[4][2]={-1,0,1,0,0,-1,0,1};int r,c,max;int out(int p,int q){ if(p<1||p>r||q<1||q>c) return 1; return 0;}int dfs(int p,int q){ int i,num; if(f[p][q]!=1)

2010-06-30 21:53:00 426

原创 HDOJ_1026_Ignatius and the Princess I

///WA两次：第一次未清空队列. 第二次没有考虑到倒数第二步在打怪的情况，缺少少输出。 ////广搜，输出最佳路径///广搜:与以前做的题的情况有点不同，不能根据有没有访问过这一点而决定是否///放弃这个点，即使以前已经访问过，但是还是需要将其考虑，因为以前访问得到的时间///不能保证是最小的，在第二次访问的时候就需要判断时间，若后一次时间少，更新访问到///这一点的最小时间即sc[i][j]中保存的值，并且将这一点再次入栈，若后一次时间多就可以//放弃这个点了。/

2010-06-30 18:56:00 1123 1

原创 POJ_1050_To the Max

///经典的DP问题，将二维转化为一维，即一个序列的连续之和最大///先枚举i,j，i为起始行，j为终止行，将从i到j的行对应元素相加，这样得到一行元素//求此序列中的最大连续和，如此，便可以得到最大的子矩阵之和。 #include<stdio.h>#include<string.h>long temp[102];long f[102];long max;int map[102][102],n;int main(){ //freopen("maxsum

2010-06-29 01:38:00 404

原创 POJ_1157_LITTLE SHOP OF FLOWERS

///Dp#include<stdio.h>#include<string.h>//fv数组保存的是题目中的输入数据，ans[i][j]表示i个花束用j个花瓶装的最大值，显然j>=i;///状态转移方程为ans[i][j]=max{ans[i-1][i-1],ans[i-1][i],//ans[i-1][i+1],……，ans[i-1][j-1]}+fv[i][j];//从状态转移方程可以看出，其实只需要2个v长度的数组就可以，利用循环数组，而输入数据也//可以做到输

2010-06-28 19:49:00 354

原创 POJ_1631_Bridging signals

////观察序列，要使信号不冲突，则必须要使序列递增，因此可以转化为最长递增子序列，DP，但是因为p///最大可以取39999，数据量较大，所以选择O(nlogn)算法 #include<stdio.h>long map[40005];int main(){ int cas; scanf("%d",&cas); while(cas--) { long p,i,temp,top=0; map[0]=-1; scanf("%d",&p);

2010-06-28 16:25:00 395

原创 POJ_1659_Frogs' Neighborhood

///贪心,但是测试数据中有n=10的数据，与题目有出入 /*对于一个给定的度序列，看能不能形成一个简单无向图。Havel算法的思想简单的说如下：(1)对序列从大到小进行排序。(2)设最大的度数为t,把最大的度数置0,然后把最大度数后(不包括自己)的t个度数分别减1(意思就是把度数最大的点与后几个点进行连接)(3)如果序列中出现了负数,证明无法构成。如果序列全部变为0,证明能构成,跳出循环.前两点不出现，就跳回第一步！*/ #include<stdio.h>#

2010-06-28 14:15:00 761

原创 POJ_1887_Testing the CATCHER

///最长递减子序列，这里使用的是nlogn算法，有点像栈，当元素小于栈顶元素就///将其存入栈顶，若大于栈顶元素，就从当前栈中用二分查找法查找第一个大于///元素，然后在其后插入当前元素。栈的最大深度即为最长递减子序列的长度。 #include<stdio.h>int num[32770];int main(){ int k=1; while(1) { int top=0,t; num[0]=32770; while(scanf("%d",

2010-06-28 00:29:00 368

原创 POJ_3356_AGTC

///编辑距离问题，经典的DP,下面注释部分是从网上搜到的，感觉思路比较清晰 //用动态规划方法计算Levenshtein距离 /*for i from 1 to m for j from 1 to n { //计算替换操作的代价，如果两个字符相同，则替换操作代价为0，否则为1 if s = t[j] then cost := 0 　　else cost := 1 //d[i,j]的Levenshtein距离，可以有 d[i, j] := minimum(d[i-

2010-06-27 21:24:00 504

原创 POJ_2192_Zipper

////DP,用二维数组来存储每一个状态的结果。ans[i][j]表示s1的前i个字符和s2的前j个字符是否///能组合成merge的前i+j个字符的序列状态，若能则为true，否则为false。///状态转移方程为:ans[i][j]={1|ans[i][j-1]&&merge[i+j]==s2[j],ans[i-1][j]&&merge[i+j]==s1[i]}/// 否则为false。而ans[0][j]表示s1为空串的情况，同理可知ans[i][0]的意义.///通过本题

2010-06-27 17:42:00 362

原创 POJ_1017_Packets

///贪心，先装大的箱子，后装小的箱子，在6*6中我是用剩余面积表示是否还能再装入箱子，装6,5,4,都不会///有什么问题，但是装3*3时会对结果有影响,因此轮到装3*3时要特别考虑对2*2的影响，当然对1*1没///多少影响 #include<stdio.h>int packets[7];int main(){ while(1) { int i,end=0; for(i=1;i<7;i++) { scanf("%d",&packets

2010-06-27 13:51:00 613

原创 HDOJ_1009_FatMouse' Trade

很简单的一道贪心题，但是做的却很杯具。。 #include<stdio.h>#include<string.h>int m,n;int jf[1005][2];double f[1005],ans;int main(){ while(scanf("%d%d",&m,&n)==2) { if(m==-1&&n==-1) break; int i,j; for(i=1;i<=n;i++) {

2010-06-26 08:40:00 404

原创 POJ_1080_Human Gene Functions

本题也是一道很经典的DP，状态转移方程为： ans[i][j]=max{ans[i-1][j-1]+score[str2[i]][str1[j]],ans[i-1][j]+score[str2[i]][-],ans[i][j-1]+score[-][str1[j]]} 其中的str1[i]等均指的是字符所在的位置。 num[0][i]和num[i][0]的情况： Null A G T<b

2010-06-26 01:36:00 288

原创 HDOJ_1257_最少拦截系统

///贪心算法///从第一个开始，若高度小于最大高度就将其打掉，这样炮弹能打的最大高度就变为前一个导弹的高度了，如此下去///第一套系统就能打这么多，剩下的便重新启用一套系统，如第一套一样计算，直至所有炮弹均打掉#include<stdio.h>#include<string.h> int h[30005];bool f[30005];int main(){ int n; while(scanf("%d",&n)!=EOF) { int i;

2010-06-25 16:11:00 1062

原创 HDOJ_1051_Wooden Sticks

////当排序之后就与最小拦截系统类似了，运用贪心算法 #include<stdio.h>#include<stdlib.h>#include<string.h>typedef struct node{ int l,w;}wood;wood s[5005];bool f[5005];int num;int cmp_l(const void* _a,const void* _b){ wood *a=(wood *)_a; wood *b=(w

2010-06-25 16:01:00 469

原创 POJ_1159_Palindrome

/////与1458和2250 本质是一样的，但是这题因为数据量大，直接用二维数组会超内存，所以需要用////到LCS改进的方法即动态数组来存储。因num[i][j]只与num[i-1][j-1]和num[i-1][j],num[i][j-1]////有关，这样便能够实现动态数组。////求最少插入字符数，将其反串与本身求最长公共子串，则子串必为回文，而剩下的字符必须要等待///插入字符与之配对才行。 #include<stdio.h>#include<string.h>

2010-06-25 11:43:00 384

原创 POJ_2250_Compromise

与1458类似，但是要构造出最长子序列。经典的DP问题 #include<stdio.h>#include<string.h>char te1[105][35],te2[105][35];int f[105][105];int num[105][105];int record[105],k;int LCS(int p,int q){ int i,j; if(p<1||q<1) return 0; if(f[p][q

2010-06-24 17:32:00 409

原创 POJ_1458_Common Subsequence

#include<stdio.h>#include<string.h>char p[500],q[500];int num[500][500];int main(){ while(scanf("%s%s",p,q)!=EOF) { int len1=strlen(p),len2=strlen(q); int i,j; for(i=0;i<len1;i++) num[0][i]=0; for(i=0;i<len2;i++) num[

2010-06-24 13:21:00 475

原创 POJ_1953_World Cup Noise

////简单DP,ans[i]=(ans[i-1][0]+ans[i-1][1]+ans[i-1][1]) #include<stdio.h>long ans[45][2];int main(){ int cas; scanf("%d",&cas); int num,k,i; ans[1][0]=ans[1][1]=1; for(i=2;i<45;i++) { ans[i][0]=ans[i-1][0]+ans[i-1][1]; ans[i][

2010-06-24 10:17:00 279

原创 POJ_2081_Recaman's Sequence

///打表，注意f数组的大小 #include<stdio.h>#include<string.h>bool f[3020000];int ans[500005];long k;int main(){ memset(f,0,sizeof(f)); ans[0]=0; long i; for(i=1;i<=500000;i++) { if(ans[i-1]>i&&f[ans[i-1]-i]==false) { ans[i]=ans

2010-06-24 01:00:00 304

原创 POJ_1579_Function Run Fun

///使用递推的方法,简单的DP，但是思想很重要 #include<stdio.h>long ans[21][21][21];int main(){ int a,b,c; int i,j,k; for(i=0;i<21;i++) { for(j=0;j<21;j++) { ans[0][i][j]=1; ans[i][0][j]=1; ans[i][j][0]=1; } } for(i=1;i<21;i++)

2010-06-24 00:19:00 280

原创 POJ_1163_The Triangle

///简单DP#include<stdio.h>#include<string.h>int n;int triangle[105][105];int sum[105][105];int main(){ while(scanf("%d",&n)==1) { int i,j; memset(triangle,0,sizeof(triangle)); for(i=1;i<=n;i++) { for(j=1;j<=i;j++)

2010-06-23 22:14:00 375

原创 POJ_3083_Children of the Candy Corn

///BFS+模拟，模拟有点麻烦#include<stdio.h>#include<string.h>#include<queue>using namespace std;queue<int> q;int w,h;char map[45][45];int dl[4][2]={{0,-1},{-1,0},{0,1},{1,0}};int vis[45][45];int dire,k;///指向当前移动方向。 int left(int a,int b,in

2010-06-23 15:32:00 457

原创 POJ_3009_Curling 2.0

///使用DFS+回溯法，当然也可以用BFS，但是那样的话可能要把每个状态下的map都要和位置///坐标一样入栈，占用的空间肯定要大于使用DFS不少。改天用下BFS试试。///题目倒不难，关键还是读懂题意，并且构思好程序的流程同时还要注意下程序中的细节，///当程序运行达不到预期结果时，要快速找到程序的出错点。///程序可能有点乱，主要是dfs中的那几个分支也就是方向的代码有点类似，占用了很大篇幅 #include<stdio.h>#include<string.h>

2010-06-23 03:48:00 421

原创 POJ_2251_Dungeon Master

////三维迷宫求最短路径，BFS，三维的状态空间 ///提交WA两次，一次忘记将栈清空，一次忘记把本地测试的语句删掉 #include<stdio.h> #include<string.h> #include<queue> using namespace std; char dungeon[35][35][35]; int f[35][35][35]; int dr[6][3]={{1,0,0},{-1,0,0},{0,1,0},{0,-1,0},{0,0,1

2010-06-22 12:42:00 290

原创 POJ_3087_Shuffle'm Up

////简单模拟 #include<stdio.h>#include<string.h>char ans[205][205];char s1[105],s2[105],target[205];int len;int statics(){ int i,j; int times=0; for(i=0;;i++) { int k=0; for(j=0;j<len;j++) { ans[i][k++]=s2[j]; ans[i

2010-06-21 20:24:00 281

原创 POJ_3414_Pots

//////BFS,二维状态空间，并且需要打印出得到目标状态的路径. //////使用DFS搜索路径，BFS查找最短路径长度 //////主要考虑每个节点有六种可能即分支，广度搜索，直到有一只pot中剩有目标数量的水/////停止，若最后f[][]中c行或c列中所有值均为0,即没有变化,则说明,由a和b不能"扩展"////到c所在的节点，答案就是impossible。 #include<stdio.h>#include<string.h>#include<queue>

2010-06-21 14:30:00 376

原创 POJ_3126_Prime Path

///BFS,因为每次只是变换一个数位，这样就有四种选择，相当于一个四叉树，而在每一分支里///又可以分成最多十支，vis数组保存最后得到的结果。若vis[k]为-1,则说明没有变换到目标///的方法，否则为目标值。程序中也利用了vis数组来判断重复。写出分析重点，好好体味一下///BFS题目的特点。////可以进行适当的剪枝，也可以不用STL中的queue，因为它实在是太慢了 #include<stdio.h>#include<string.h>#includ

2010-06-20 20:48:00 340

原创 POJ_1426_Find The Multiple

////运用DFS解决，深搜每一位，最多100位，搜每一位时算出当前数MODn的余数，留作下次使用///强烈提醒自己提交code时注意删去不必要的代码行，因为这WA了一次 #include<stdio.h>#include<string.h>char s[105];int n,ends;int dfs(int k,int remain){ int t=remain,i; if(ends) return 0; if(k>99) return 0;

2010-06-20 15:12:00 342

原创 POJ_3278_Catch That Cow

////广度搜索BFS///使用数组实现循环队列，注意front和rear。另外有可能出现数组开的比较小的情况，那样///会导致数据还没有处理就被刷掉的情况，因此要开的"足够大”。用for循环实现从三个///方向搜索。用vist数组保存访问情况，已经访问的就不需要再访问。当n大于k时，只能够///不断的向左做减一搜索，所以次数为n-k。 #include<stdio.h>#include<string.h>#define MAX 50000bool vist[

2010-06-19 20:03:00 366

原创 POJ_2488_A Knight's Journey

///DFS，回溯 ///因为要是字典序输出，所以1.搜索起点时必须从第一列开始，而且要从上到下 2.搜索骑士的///下一步时要注意顺序，设当前点为(x，y),则搜索顺序应该为(x-1,y-2),(x+1,y-2),(x-2,y-1)///,(x+2,y-1),(x-2,y+1),(x+2,y+1),(x-1,y+2),(x+1,y+2) ///3.如果能有任意一点可以possible，他就可以到达（1，1），所以从（1，1）出发就不应///该会impossible#in

2010-06-19 16:34:00 324

原创 POJ_1321_棋盘问题

///简单DFS #include<stdio.h>#include<string.h>int map[10][10],n,k;////map保存地图 long num;///保存最后结果 int f[10];///存储每次放棋子的列号 ////判断要放棋子的列是否已经有棋子 int exist(int t,int k) { int i; for(i=1;i<t;i++) { if(f[i]==k) return 1; } retu

2010-06-19 12:55:00 258

原创牛人对KMP的理解

相当精辟的讲解！以前看算法书没搞懂，今天看了一遍就受益匪浅！ 来源：(http://blog.sina.com.cn/s/blog_5cf979410100h54g.html) - 牛人对KMP的理解［转］_琥珀_新浪博客 我们从一个普通的串的模式匹配算法开始讲起，这样你才能更深入的了解KMP算法及其优点。 咱们先来看看普通的串的模式匹配算法是怎么进行比较的 主串（S） a b a b c a b c a c b a b 子串（T

2010-06-15 03:47:00 376

原创 POJ_1107_W's Cipher

///置换群,比1026要简单很多#include<stdio.h>#include<string.h>char s[85],r[85];int f[85],a[3],num[3],len;int rotate(int c,int k){ int i,t=0; i=c; while(t!=k) { i++; if(i>len-1) i=0; if(f[i]==f[c]) t++; } r[i]=s[c]; retu

2010-06-14 07:18:00 449

原创 POJ_1102_LC-Display

//简单模拟#include<stdio.h>#include<string.h>int s;int black(int k){ int i; for(i=0;i<k;i++) printf(" "); return 0;}int heng(int k){ int i; for(i=0;i<k;i++) printf("-"); return 0;}char n[10];int print(){ int i,j,

2010-06-14 04:17:00 348

原创 POJ_1026_Cipher

刚开始感觉很一般的一道题，没想到做起来竟然很蹉跎，肯定不能暴力解密，因为转换次数有可能很大，所以极有可能会TLE，分析题目：可以将序列分成一个个组或者说是集合，这个集合中的元素通过解密后还是在这个集合中，好像是置换群的概念，以后好好学习一下。若一个集合元素个数为m，则在这个集合中的元素都是以m为循环的。刚开始是想求出所有组元素个数的最小公倍数，然后一起处理，可是这个数有可能非常的大，所以就将各个组分别处理。下面有两种处理方法：1。将全部元素分别处理 2.将一个组中的元素同时处理方法2的效果还

2010-06-13 23:35:00 694

c函数速查

空空如也