xiaomajiyue-CSDN博客

转载 http://blog.csdn.net/xxxluozhen/article/details/5027234

关于CExtStatusControlBar控件

2012-10-30 11:57:36 458

转载博弈入门

这几天脑子被门挤了，想搞搞博弈论。今天就从0开始，先转载别人的文章，了解一些常见的模型点击打开链接

2012-09-04 18:48:23 339

原创 ubuntu 10.04 apt-get proxy

不知道用什么标题，索性把我要描述的问题的关键字拿出来，希望给大家一点帮助。 http://blog.csdn.net/xiaoweibeibei/article/details/6257315 以上链接，可以说作者基本说清楚了这个问题。我这里补充几点，即我设置时碰到的问题。 1，作者是虚拟机安装的ubuntu，不用虚拟机也是可以的。 2，apt.conf 文件里写的东西，很多文章中都有提到

2012-06-26 12:38:23 1144 1

复习kruskal算法，外带字符串的二分，qsort的使用，并查集的基本应用。#include #include #include #include #define N 200 using namespace std; struct edge { int a,b; double dist; }e[N*N]; char h[N][25]; int set[N]; int cmp(const void *a,const void *b) { edge *p1=(edge *)

2011-04-13 13:20:00 488

原创线段树小结

本来想写些文字，最后还是觉得线段树标记太灵活了，直接贴点模板算了http://blog.csdn.net/xiaomajiyue/archive/2011/03/04/6222924.aspxhttp://blog.csdn.net/xiaomajiyue/archive/2011/03/05/6225871.aspxhttp://blog.csdn.net/xiaomajiyue/archive/2011/04/12/6317156.aspxhttp://blog.csdn.net/xiaomajiyue

2011-04-12 14:40:00 370

原创 poj 2528 Mayor's posters

线段树+离散化 线段树的更新操作相同于涂颜色那题，线段树的查询操作则比涂颜色那题简单，因为查询的是整条线段而不是某一段。 离散化说白了，就是一个排序+二分，也许我的理解还尚不成熟，等以后题目做多了再来讨论 #include<iostream> #include<cstdlib> #include<cstring> using namespace std; #define N 10005 struct node { int l,r,bj,c; }st

2011-04-12 09:06:00 80

原创 poj 2549 Sumsets

hash应用。 a+b+c=d,各个值都是不等的，用四个循环肯定超时，所以把c移到右边，则变成两个两重循环。把数存于s[]数组中。因为这些数比较大，所以把取模作为hash函数,关键值就是abs(s[i]+s[j])%N,并把i与j存于res数组中，hash表中存放的是res数组的下标。判断成立的条件：h=res[ptr->index].i k=res[ptr->index].j s[h]+s[k]==s[i]-s[j]&&i!=h&&

2011-04-07 21:25:00 631

原创 poj 1971 Parallelogram Counting

这题本想用hash，从MLE变到 RE，最后停留在 TLE，关键值就是中点坐标的和，用链表来解决关键值相同的情况（碰撞）；最后猥琐的排序过了。 #include<iostream> using namespace std; #include<cstdlib> struct Point { int x,y; }; Point p[1005],mp[500005]; int cmp(const void *a,const void *b) { Point *p1=(

2011-04-07 19:09:00 627

原创 hash 小结

hash思想：将某个对象对应到一个关键值，然后根据关键值归类，将该对象的数组下标放在哈希表中，以后查找时，可以通过关键值实现高效查找。不同的对象可能对应相同的关键值，通过链表解决碰撞。 推荐的题目：poj1840 poj2002 贴一下模板（poj2002） struct Point { int x,y; }; Point p[1005]; struct Hash { int index; Hash *next; }; Hash *ys[N

2011-04-06 22:26:00 413

原创 poj 1080 Human Gene Functions

dp[i][j]记录a的前i个字符与 b的前j个字符进行匹配得到的最大值。dp[i][j] 由dp[i-1][j], dp[i][j-1],dp[i-1][j-1]三种情况得来。第一种情况：a的前i-1个字符与b的前j个字符匹配得到的最大值，再加上a[i]与‘-’的匹配情况；第二第三种情况类似。 果然是LCS的思想

2011-04-06 12:43:00 354

原创 LCS && LIS

LIS的子问题：dp[i]记录以a[i]为终点的最长上升子序列的长度 dp[1]=1; for(i=2;i<=n;i++) { temp=0; for(j=1;j<i;j++) if(a[i]>a[j]&&dp[j]>temp) temp=dp[j]; dp[i]=temp+1; } LCS的子问题：dp[i][j]记录以i结尾的s1与以j结尾的s2的最长公共子序列的长度 n1=strlen(s1+1); n2=s

2011-04-06 09:56:00 451

原创 poj 1159 Palindrome

拿到这题前，知道是最长公共子序列。看了之后，发现，只要求一下原串与反串的最长公共子序列就可以了。自己也讲不出个所以然，discuss里讲的挺好的 http://poj.org/showmessage?message_id=95237

2011-04-06 08:52:00 345

原创 poj 3176 Cow Bowling

数塔问题，最最简单的DP了吧#include #define N 355 int a[N][N],dp[N][N]; int mymax(int c,int d) { return c>d?c:d; } int main() { int n,i,j; scanf("%d",&n); for(i=1;i=1;i--) for(j=1;j

2011-04-04 21:07:00 335

原创 poj 1976 A Mini Locomotive

b[i]=a[i]+a[i+1]+......a[i+m-1]; dp[i][j]表示用j个火车头装前i个b，最后输出dp[n-m+1][3]; 则b[i]装或者不装，不装则dp[i-1][j],装则dp[i-m][j-1]+b[i]; #include<iostream> #define N 50005 using namespace std; int dp[N][4],sum[N],a[N]; int mymax(int c,int d) { re

2011-04-04 19:47:00 664

原创 poj 1260 Pearls

dp[i]记录到i为止的最小花费，对于第i个种类，也许1~i都用策略i，或者2~i用策略i。。。。k~i用策略i(k>=1&&k<i)，换句话说，就是前k个知道最小花费，k+1~i用策略i， dp[k]+(sum[i]-sum[k]+10)*p[i](k>=0&&k<i); #include<iostream> #define N 105 #define inf 1000000000 using namespace std; int p[N],dp[N],sum[N]

2011-04-04 12:27:00 397

原创 poj 1836 Alignment

好不容易想到从左往右求一次LIS，再从右往左求一次LIS，然后就不断wa，看了discuss，才知道并不是总是相邻的相加 #include<iostream> using namespace std; #define N 1005 double p[N]; int lef[N],rig[N]; int main() { int n,i,temp,j; scanf("%d",&n); for(i=1;i<=n;i++) scanf("%lf",p+i);

2011-04-03 19:52:00 313

原创 poj 1837 Balance

dp[i][j]记录前i个砝码平衡度为j的方法数。假如已经知道了前i个砝码所有的平衡度的方法数，则就可以求出前i+1个砝码的所有平衡度的方法数，dp[i][j+p[k]*w[i]+4000]+=dp[i-1][j+4000]，最后的答案是dp[n][4000];#include using namespace std; #define N 8000 int dp[25][N],w[25],p[25]; int main() { int c,g,i,j,k; scanf("%d%d",&c,

2011-04-03 14:24:00 279

原创 poj 3267 The Cow Lexicon

用dp[i]记录msg中从0到i的最少要删除的字符数。每扫描一个字符s[i],dp[i]最多为 dp[i-1]+1，然后对于每一个单词，从i往前找，如果找到，min{dp[j]+i-j-len[k],dp[i]} 如果没有找到，还是dp[i]。 #include<iostream> #include<cstring> using namespace std; char w[605][30],s[305]; int dp[305],len[605]; int

2011-04-03 14:12:00 310

原创并查集算法小结

并查集的题目还是比较明显的。 一类是并查集的基本应用，用到了基本的合并与查找，hdu1198 1811 poj2524 1611 另一类是以“食物链”为代表的并查集的高级应用，用到了相对关系，路径压缩时相对关系的递归变化，poj1182 1703 2492 1988 贴上最基本的并查集模板： int find(int x) { int r=x,i,j; while(r!=set[r]) r=set[r];

2011-04-01 22:43:00 1643

原创 hdu 1811 Rank of Tetris

并查集的题目，再加个拓扑排序。 一开始总是wa，我那个犯2的错误：用gets读入，却忽略了如果那些数字大于9的情况。 #include<iostream> #include<queue> using namespace std; #define N 10005 #define M 20005 struct edge { int ver; edge *next; }; queue<int>que; edge *g[N]; int deg[N],se

2011-04-01 20:43:00 665

原创 hdu 1829 A Bug's Life

过了几个月，再来做这题，以前在poj做过。 属于同一个集合的生物，则关系确定。而这些关系都是相对于根节点的。rank[x]=0,代表set[x]与x同性，rank[x]=1代表set[x]与x异性。 若x，y属于同一个集合，若rank[x]==rank[y]则报错，若rank[x]!=rank[y]则不处理 若x，y不属于同一个集合，则合并两个集合，只要修改set[ry],rank[ry]; 在每次的查找过程中，递归的修改x到rx路径上的点的set和ran

2011-04-01 14:42:00 1129 1

原创 hdu 1198 Farm Irrigation

网上说是并查集的题目，bfs就过了，不过其中也有并查集的感觉。每次以一个点为起点搜索，搜到的都属于一个集合，用了几次bfs，就是有几个集合。 #include<iostream> #include<queue> using namespace std; int g[11][4]={{1,0,0,1},{1,1,0,0},{0,0,1,1},{0,1,1,0},{1,0,1,0}, {0,1,0,1},{1,1,0,1},{1,0,1,1},{0,1,1,1},{1,1,1,0}

2011-04-01 14:33:00 403

原创 kmp算法总结

正如matrix67大神说的，kmp算法没有讲的必要。而我觉得kmp是一种工具，只要知道会用就可以，比如poj 3461，要想好好理解，可以看matrix67的文章。kmp的预处理函数还是有一些用处的，poj1961 2406 2752都用到了。 贴一下kmp算法的模板： void preprocess(int m) { p[1]=0; int j=0,i; for(i=2;i<=m;i++) { while(j>0&&b[j+1]!=b[i])

2011-03-31 19:05:00 316

原创 poj 1961 Period

kmp算法的应用，看了matrix67的博客，懂了六七成，不过还是得花时间去理解。 http://www.matrix67.com/blog/archives/115 #include<iostream> using namespace std; #define N 1000005 int p[N]; char a[N]; void preprocess(int m) { p[1]=0; int j=0,i; for(i=2;i<=m;i++) {

2011-03-31 08:28:00 263

原创 poj 3621 Sightseeing Cows

最短路的变形，二分加SPFA。看了别人的解题思路，才知道是那么回事，哎，路漫漫其修远兮，吾将上下而求索。#include #include using namespace std; #define N 1005 #define inf 100000000.0 #define doc 0.000001 struct edge { int v,d; edge *next; }; edge *g[N]; bool use[N]; int fun[N],cnt[N]; double

2011-03-27 14:15:00 351

原创最短路算法总结

1：dijkstra算法基于priority_queue的dijkstra算法，适用于边权值非负。每一次queue.top(),是从V-S中取小的u，并加入S中。并以这个点为基础，对新的V-S中的点进行松弛，只要产生dist的改变，该v点必入优先队列，从而产生一个现象：一个点在优先队列中的次数可能不止一次，但每次出队列的必是最小值，且该点加入S，那么接下来如果该点再出队列，只要continue。将dist[N]扩展到dist[N][2],use[2]扩展到use[N][2]，0代表最短路，1代表次短路，则就

2011-03-26 15:25:00 312

原创 zju 1298 Domino Effect

解题思路：用dijkstra求出最短路径，找到其中的最大值ans，那些走过的边上的牌不用考虑，肯定比ans小，再枚举没有走过的边，最后倒下的是dist[a]+dist[b]+d/2。注意点，当n==1时，ans为0，我在这里wa了五六次吧 #include<iostream> #include<cstdio> #include<queue> #include<cstdlib> #include<cstring> using namespace std; #define N

2011-03-26 15:03:00 318

原创 poj 1850 Code

简单数学题 #include<iostream> #include<cstring> using namespace std; int C(int a,int b) { if(b==0) return 1; else return C(a-1,b-1)*a/b; } int main() { char s[15],str[15]; int len,i,ans=0,j; bool flag=true; scanf("%s",s); l

2011-03-25 14:20:00 238

原创 poj 1942 Paths on a Grid

求组合数 下面的博客写了好几种方法 http://hi.baidu.com/peacefulby/blog/item/3a4b4dc9409c5b1f7f3e6fc2.html #include<iostream> using namespace std; __int64 C(__int64 a,__int64 b) { if(b==0) return 1; else if(b==1) return a; else r

2011-03-25 09:38:00 564

原创 poj 3255 Roadblocks

求次短路。水过 #include<iostream> #include<queue> using namespace std; #define N 5005 #define inf 100000000 struct node { int dist,v; bool flag; }; struct cmp{ bool operator()(node a,node b){ return a.dist>b.dist; } }; priority_que

2011-03-25 09:36:00 359

原创 zju 3162 To Go or Not to Go

数论，与poj 3252差不多，数学题挺麻烦的，要认真再认真 #include<iostream> #include<cstdio> using namespace std; int c[31][31],binary[31]; int len; void init(int x) { int tx=1; len=0; while(tx<=x) { len++; tx=tx<<1; } for(int i=len;i>=1;i--) {

2011-03-23 20:06:00 325

原创 poj 3252 Round Numbers

下面的文章写得相当好。 http://jay23jack.blog.163.com/blog/static/317951942009127105939814/ 虽然实现不一样，但是思路借鉴了他的。写起来挺烦的，好像自己在运算一样。 #include<iostream> using namespace std; int c[35][35]; int binary[35],len; void init(int x) { int i,j; len=0;

2011-03-23 18:51:00 324

原创 poj 1579 Function Run Fun

记忆化搜索。 题目把递归式都给我们了，我们只要把中途算出的结果记录下来 #include<iostream> using namespace std; int dp[25][25][25]; int dfs(int a,int b,int c) { if(a<=0||b<=0||c<=0) return 1; if(dp[a][b][c]!=-1) return dp[a][b][c]; else { if(a<b&&b<c)

2011-03-23 10:52:00 258

原创 poj 1088 滑雪

求最长下降子序列 记忆化搜索，每次求以(i,j)为起点的最长下降子序列，并且记录下来。然后遍历dp。 #include<iostream> using namespace std; #define N 105 int map[N][N],dp[N][N]; int dir[4][2]={{-1,0},{0,1},{1,0},{0,-1}}; int row,col; int dfs(int r,int c) { if(dp[r][c]>0) retur

2011-03-23 10:27:00 283

原创 poj 1887 Testing the CATCHER

DP基础，我也只会做做基础题。求最长下降子序列，就是红皮书上的最长上升子序列，一开始开了1000的数组，re了，开了10000就过了 #include<iostream> using namespace std; #define N 10000 int a[N],r[N]; int main() { int t,c,i,j,temp,ca=0; while(1) { t=1; ca++; scanf("%d",&c); if(c==-1)

2011-03-23 08:53:00 268

原创 poj 2449 Remmarguts' Date

网上都说这是A*算法+dijkstra，下面谈谈我的一些看法。 我一开始单单用dijkstra，思路是这样的，当前点进行扩展时，每条路所连的点（也有可能是，相同的点，但不同的路）都入队列，这样就相当于把所有的状态都记录了下来，只要搜索到目标节点并且是第k次搜索到，那么搜索结束，这样就有一个问题，就是MLE，因为状态是指数级增长的。 那么就换网上的主流方法。用dijkstra求各个点到目标节点的最短路径，方法简单，建图时反向，源点是题目给出的目标节点。这个dist[i]

2011-03-20 11:16:00 526

空空如也

空空如也