冰上游鱼

本来都是没什么很难的技术的东西，但是时间长不写这样的，还是应该总结一下。筛选法生成质数表（素数表）的基本思想如下：假设有一个数组存放整数2 ~ N，如下所示：2 3 4 5 6 7 8 9 10 11 12 13第一遍筛选去掉所有2的倍数，第二遍筛选去掉所有3的倍数，。。。第sqrt(N)遍筛选去掉所有sqrt(N)-1的倍数。不考虑内存访问的时间问题，纯粹考虑时间复杂度，

不知道这道题有什么难点，通过率竟然会 贴上代码：#include#include#include#define HaabMonth 19#define HaabYear 365#define TzolkinMonth 20#define TzolkinYear 260char *Haab[]={"pop", "no", "zip", "zotz", "tzec", "

/* * ===================================================================================== * * Filename: 2479.cpp * * Description: * * Version: 1.0 * Created: 2011年

网络最大流问题。 其实想法很直观，就是找一条流的路径，然后取这条路径上的最大流量，然后更新约束条件，然后再找这样的路径。。。直到没有能继续的路径。 找路径的方法使用的是广度优先搜索。 ps:最近在练习c语言，c语言虽然用起来比c++墨迹，各种注意事项，但是运行速度上跟c++的确不在一个量级上。15ms AC,源代码：/* * =======================

今天不不知道中了什么邪了，这道曾经写过的马步图问题竟然，用树的深度优先遍历去做（用栈结构+回溯），花了半天也没写对。在纸上写，感觉想明白了就在电脑上敲，敲完总也运行不出想要的结果。整地头晕脑胀地，决定先放着，换一种方法。用递归实现。（也很周折，有个字母敲错了，提交了好几次，后来才发现）。啊啊啊啊，哥要疯了！好郁闷啊。等哥那天状态好了，一定写个启发式搜索的马步图出来。啊啊啊啊，哥要疯

这道题用并查集效率很高。#include#include#includeusing namespace std;int n,m;int students[30000];int find(int f){ int p=f; while(p!=0&&students[p]>=0) p=students[p]; while(p!=0&&students[f]>=0) { in

这道题和1011十分类似。只要把所有木棒分为4份即可。#include#include#include#includeusing namespace std;int n;const int NUM=20;bool visited[NUM];int stick[NUM];int des_len;int cmp(const void* a,const void *b){

这道题以前做过，没做出来。今儿参考别人的做了，感觉这种“动态标记”（自己给这个方法起的名字）的方法挺好的。#include#include#include#includeusing namespace std;int n;const int NUM=64;bool visited[NUM];int stick[NUM];int des_len;int cmp(const v

先把问题转化为差分约束系统，然后把差分约束系统转化为满足条件的图，然后对图求最大（或者最小）路径。 Dijkstral和Bell-man Ford是求单源最大最小路径的方法。但是效率并不高。 spfa(shortest path fast algorithm)算法效率较高。因为，对于那些距离没变化的点v，以后也不可能通过v来使别的点u的路径发生变化。所以用一种记录的方式记录变化的点，没有变

这道题如果把测试数据做得强大的话，估计很难有人做好。但是数据比较小，蛮力法即可解决。郁闷的是，敲的时候忽略了一个“=”号，白白浪费了几次submit. poj3080代码：#include#include#includeusing namespace std;#define NotFound 4294967295string data[10];int m;//const

这道题的题意很明显，给定一大堆图边的关系，判断这个图是否为一棵树。我的算法是：1，判断图是否为空图，如果是空的，则为空树。（空树也是树）。2，找root判断这个图是否为一棵树。root应唯一。不唯一则不是树。3，建立临界表。4，从root开始层次遍历，如果遍历过程中有指向已经被访问过的点的指针，则不是树。5，层次遍历后，如果仍有未被访问过的顶点，则说明图不是连通的，也不不会

拿到这道题之后，很快就会把它转化为 ax+by=d的求解问题（a,b,d已知，求x,y)。这个问题如何求解呢。  我一开始用穷举。很显然，会TLE. 然后，看了别人的解题方法。原来这就是传说中的扩展的欧几里得问题。 用欧几里得求两个数的最大公约数大家都会。但是这个扩展的欧几里得就不那么好理解了。 在网上找的对扩展的欧几里得的理解：扩展欧几里德算法理解（By ruiqi）欧几

这是一道基本的动态规划题，可惜我连一个正确的dp方法都没想出来。惭愧。一直认为DP是几种编程思想里最难掌握的，“状态转移式子”很难总结出来。DP真的应该多练一练。这道题的两个思路：思路1：设min[i][j]表示字符串str[i~j]转化为对称串所需添加的最小字符数，则当str[i]==str[j]时，min[i][j]=min[i+1][j-1];否则，min[i][j]=1

一开始就没有深刻理解，认为要做的事儿是：   设时间为p1,p2,...pn.则需要从  p1,p2,p3...pn; 2*p1,2*p2,2*p3...2*pn;... K*p1,K*p2,..K*pn；中找到最小的前K个。   这样的话最坏情况有10^7个数据，辛辛苦苦用了set ,qsort,priority_queue等方法均超时。   实在受不了了，看了一下别人的思路，是

看了很长时间二分图的匹配，没怎么理解，带权重的就更不用说了。  但是既然看了这题，先给刷过吧。  粘的别人的模板，过了，心里很不爽，有空一定要好好读读《算法导论》的这个章节。#include#include#include #define MAXN 110#define inf 1000000000#define _clr(x) memset(x,0xff,sizeof(in

昨晚看了一篇关于暴雪三重hash算法的文章，有意实践一下。  以前做字符串hash的时候想到过用另一个hash_key去区别同位置的字符串（用strcmp来比较两个字符串是否相等真的好慢），但是因为理论上不可能有hash_key可以唯一的让一个string区别与另一个string,所以一直认为这么做不可行。一直用开地址链表的方法做hash.  看完暴雪三重hash这个文章之后，感觉只要选择

树状数组详解  通过这道题，我对树状数组的理解：  树状数组通过一种类似与二叉树的结构，使得任意连续段的求和操作的时间复杂度为O(log(N)).但是付出的代价是，对某一个元素做修改的时候的时间复杂度不再是O(1),而是O(log(N)).  一般数组求某一连续段的和的时间复杂度为O(N),而树状数组为O(log(N)). 因此，树状数组适合于，需要大量经常计算某连续段的和的情

这道题，咋一看，似乎非常简单。开个数组记录每个小格子的位置是被谁占用了即可。但是注意到， 1 i  然后想到用链表表示每一段：每一次插入的时候就更改一下链表，最后统计链表中的不同的poster的个数。但是这种效率是O(n^2),而且需要大量对链表的操作，时间效率也不高。 后来想到，把所有的li,ri排个序，然后就会大大压缩表示数组的长度，效率将会提高到O(n^2), n=10000.

终于考试完了，又可以学习啦！poj1363，这道题是数据结构与算法中的经典问题，给定一组进栈顺序，问栈有多少种出去的顺序，而这个题是选择题中常考“下列出栈顺序中不合法的是？”。拿到之后最直接的思路就是模拟进出栈，代码AC了，但是时间为94ms。感觉不应该啊，这么简单的题，必定有更高效的算法。可是怎么更高效呢？/* * ===========================

读完这道题，就有一种不妙的感觉。因为编写这种处理格子的问题，或者说处理不规则数据的问题，我写的代码从来都是总体思路也对，但是一大堆bug,结果不对。很痛苦。  硬着头皮写一写这个题，果然是很蛋疼。  哎，这种处理不规则数据的题最是考验清晰的思维能力和编程的内功。可怜自己思维也不够清晰，编程内功也不行，只要一超过100行，就bug一大堆。苦恼。  粘上未完成的代码，哪天闲了（或许再也不）

第一次用这种所谓的随机化算法。   随机化算法，就是靠大量的随机产生可能的组合，然后找出最优结果。这与用穷举产生每一种可能的组合，然后找最优结果没什么本质区别。   随机化算法的弊端很明显，随机次数太少的话找不到最优解，随机次数太多的话时间又不划算。而且不保证能找到最优解。 对于精确度要求不高的实际问题倒是有一些应用价值。   对于这道题，我把随机次数分别设为2000，20000，20

#include#include#includeusing namespace std;string dict[10000];string word;int n=0;void solve(){ for(int i=0;i<n;i++) { if(dict[i]==word) { cout<<word<<" is corre

#include#include#include#include#includeusing namespace std;const unsigned int MAX=2147483647;int Num=100000;int* len;unsigned int *sum;int input;void init(){ len[0]=0; sum[0]=0; char

这道题看到第一眼，我想到的是很复杂的类似与求求九宫格的算法。可是想了一会发现每次交换只能减少一个逆序，而且必定能减少一个逆序。  问题就一下子转换为求逆序个数了。想明白这个，代码就很容易了。 poj1804 代码：#include#includeusing namespace std;const int NUM=1005;int data[NUM];int main()

这道题是正宗的凸包问题。 依然用Graham Scan算法。只是这个最短距离并不是凸包的周长，而是凸包的周长加上各段的弧长。弧长怎么求呢？ 自认为数学学地好的我，上来就自做聪明地根据叉乘中得到的sin(theta)值求theta，然后theta*L,然后再相加。显地很牛逼。提交好几次都不过，后来看别人的代码，人家直接在最后加一个2*PI*L. 各个theta的和是PI啊！ poj

这道题的题意太明显了，求最小生成树。先面关于图的数字说明，这个图最适合用kruscal来求最小生成树。poj 1251 Jungle Roads 代码：#include#include#include#includeusing namespace std;int parent[26];int n;//vertex numint edge_num;struct Edge{

Pseudo-Code: Graham Scan Algorithm   Input: a set of pointsS = {P = (P.x,P.y)}    Select the rightmost lowest point P0 in S.    Sort S angularly about P0 as a center.

#include#include#includeusing namespace std;const int gray=1;const int white=0;const int black=2;const int v_num=1000;const int start=0;int graph[v_num][v_num];int color[v_num];int Time;in

最近学算法学到并查集，感觉挺简单的。于是乎在poj里找相关的题目练练手，一做就懵了。即便知道这道题是用到什么数据结构去做，可是把一个实际问题抽象转化为学过的数据结构与算法的过程也还挺难的。然后参考别人的解题报告写出来了poj1182题。       总结并查集的用法如下：       一般来说，给定的问题都不可能像书本上的例子那样，直接让你求一些元素的并集，而是给定一些元素，其中某些元素发

这道题就是所谓的“关灯问题”。在《算法设计与分析基础》课后习题中见过。 乍一看，最容易想到用16个（0、1）变量列一个线性方程组（16维的），然后高斯消去求解。但是感觉高斯消去法写起来太累人。又想别的方法。出现在脑袋里的是暴力法，由于只有2^16个解，所以暴力是可以解决的。然后又想到用一个int型数据的低16位表示棋盘，然后对棋盘进行位运算操作效率较高。discuss里有很多所谓的官方测试数据

poj 1018这道题数据处理量比较大，用的时候应避免动态经常申请内存，排序用qsort速度较好。#include#include#include#include#include#includeusing namespace std; struct DEV{ int B; int p; int id; friend int cmp(const void

稳定婚姻问题，虽然简单，但是挺有意思的。poj3487中要注意，这道题中的字母并不是一定要从a开始连续的，注意哦。#include#include#include#includeusing namespace std;char male[26];char female[26];int n;int T;int maleprefer[26][26];int femalepr

这道题是一个多重背包问题。 以前只是用二维数组，带记忆的递归做过01背包问题，做这个多重背包问题很费劲。 要想明白，一维数组如何能记录最优解，要想明白如何把多重背包问题转化为01问题。直接把不同个数的同一种物品看作一种物品的方法，会使得物品太多，解的效率很低。 网上有很多效率高的方法，一种是把多重背包，按二进制数分成不同的物品，从而减少物品个数。也就是把n个相同的物品，转换为log

第一时间想到把n二进制拆分。0ms通过的代码： #includestruct Matrix22{ int d11; int d12; int d21; int d22; Matrix22 operator =(Matrix22 a) { d11=a.d11; d12=a.d12; d21=a.d21; d22=a.d22; } Matrix2

这个题一开是自己的思路是把所有数字排序之后再分治（分为大小差值最小的两份）。  看了别人的解题报告之后，发现，这个题可以像哈夫曼那样自下向上去做。比用分治（自上向下）简单。  用的是G++编译器，注意不能用__int64而只能用long long int。#include#include#includeusing namespace std;int main(){

#include#include#include#include#includeusing namespace std;string change(string s){ string output=""; int len=s.length(); int count[10]={}; for(int i=0;i<len;i++) { count[s[i]-'0']++;

#include#include#include#include#includeusing namespace std;const int PRIME=999983;int clockwise[12];int countclockwise[12];class Node{ public: int arms[6]; Node *next; bool operato

poj1789代码：#include#include#includeusing namespace std;const int MAX=99999;int N;int dis[2001][2001];char data[2001][8];int distance( char *str1, char *str2){ int d=0; for(int i=0;i<7;i++)

#include#include#include#include#includeusing namespace std;int map(char ch){ switch(ch) { case 'A': case 'B': case 'C': return 2; case 'D': case 'E': case 'F': return 3;

令B={ A A}        {O E}那么B^k={A    A+A^2+A^3...A^K}               {O    E}代码：#includeconst int NUM=60;int n,k,m;struct Matrix{ int data[NUM][NUM]; Matrix operator =(Matrix a) { f