DreamChaserYx的专栏

为了练习kmp谢了kmp版本，但是渣的不行，就不贴了，贴个最基本的吧。

关键是搞清楚，one hundred million这样的结构表达的是1 * 100 * 1000000， 而one million one hundred这样的结构表达的是1000000 + 100，也就是说，数量级大的在数量级小的之前的时候，其实是一个加法关系。而小的在前的时候，则是乘法关系。#include#include#include#includeusing namespa

本来以为是个奇怪的题，后来发现只是逐个匹配就好了。#include#includeusing namespace std;int main(){ string s, pat; int i,j; int ls, lp; while (cin >> pat >> s){ ls = s.length(); lp = pat.length(); for (i = 0, j

已知灯的情况。枚举第一行开关的情况。我们知道这么一种现象：上一行的灯可以由下一行的开关控制达到完全关闭的状态。更进一步的我们确定这么一种现象：如果知道（1）第n行灯的情况，（2）第n-1行开关的状态，（3）第n行开关的状态。那么，如果想要让第n行的灯全部关闭，第n+1行的开关的状态是确定的。特殊的，第一行只需要知道本行的灯的情况和本行开关的状态。所以，只需要枚举第一行开关的情况，然

代码写的比较烂，有时间再看看别人代码，重写一个好了。#include#include#include#include#includeusing namespace std;bool compare(char c, char c_in_stack){ if (c == '*' || c == '/'){ if (c_in_stack == '+' || c_in_stack =

从N进制，转为M进制，当然，题目要求不高，所以边角工作没有做，超出十进制以后的转换因为没有定义相关的符号表示，所以会出错。#includeusing namespace std;int main(){ int N,M; string ns, ms; int ni[1010], mi[1010]; int ti, ri, p, q, pm; cin >> ns; int i;

f参数一个栈内元素数量，一个带入栈元素数量。#includeusing namespace std;int f(int i, int j){ if (j == 0){ return 1; } if (i != 0 && j != 0){ return f(i + 1, j - 1) + f(i - 1, j); } else if (i == 0 && j != 0){

队列和栈来回倒腾。思路是比较典型的思路，现转成逆波兰表达式（运用栈），然后输入到队列，然后计算值（运用栈）。#include#include#include#includeusing namespace std;bool opcmp(char op1, char op2){ if (op1 == '+' || op1 == '-'){ if (op2 == '*' ||

运用kmp中的next数组。前缀中如果有周期的话，一定满足，next[i] % (i - next[i]) == 0.满足这个条件时：记字符串s的第i位之前的子串为p，其前缀字符串位为p.pre，后缀字符串为p.suf，以p（i，j）表示p的从i位到j - 1的字串。则i就是p的长度，next[i] 就是p.pre和p.suf的长度.首先知道，p.pre（0，i - next[i]

代码写的比较乱，凑合看吧。#include#include#include#includeusing namespace std;class node{public: int num; node *left; node *right;public: node(int n = 0){ num = n; left = NULL; right = NULL; }}

题目太简单。知道二叉树长什么样就能做。用数组存二叉树。#includeusing namespace std;struct _node{ int tag; int left; int right; _node(int n = 0){ tag = n; left = -1; right = -1; } _node& operator=(const _node& t

重建和遍历重建的时候，我把*看作了叶节点，但是不让其作为父节点。其他节点则可以是父节点，也可以是叶节点。#include#include#includeusing namespace std;struct _node{ char data; int hierachy; _node* left; _node* right; _node(){ data = 0; hi

自己做了一遍堆#include#includeusing namespace std;templateclass Heap{ T* root; int current_size, max_size;public: Heap():root(0), current_size(0), max_size(0){}; int parent(int cur) const{ ret

这一次用了STL#include#includeusing namespace std;struct _node{ int weight; _node* left; _node* right; _node():weight(0), left(NULL), right(NULL){}; friend bool operator>(_node a, _node b){ if (

重建#include#include#includeusing namespace std;struct _node{ char data; _node *left, *right; _node():data(0), left(NULL), right(NULL){};};void build_tree(_node *root, string &preOrders, s

#include#includeusing namespace std;int main(){ int N; int a, b, c, d; scanf("%d", &N); for (a = 3; a <= N; a ++){ for (b = 2; b < a; b ++){ for (c = b; c <= a; c++){ for (d = c; d <

枚举三个数字的和#includeusing namespace std;int main(){ int n; scanf("%d", &n); int i, j, k; int b; for (b = 3 * n, i = n, j = n, k = n; b >= 0; b--, i = n, j = n, k = n) for (i = min(b, n); i >= 0

#include#includeusing namespace std;int main(){ int a[110][110] = { }; int n; cin >> n; int i, j, k; int tm; int sum = 0; int current; int N; N = n; while (N--) { for (i = 0; i < n;

原理就是：先把行方向上的处理完了，再处理列方向，然后删除的行和列作一个标记，我标记到每行没列的第109个位置，但是代码效率不知道为什么稍微有点低，在改改说不定。还有方法就删除一行，把整个数组往前挪一位。#include#includeusing namespace std;int main(){ int a[110][110] = { }; int n; cin >> n;

题目很简单，其实主要是为了练习结构式的语言，用冒泡，中间写好排序的函数就可以。

#include#includeusing namespace std;bool match(char[],char[]);int main(){ char s[30]= {}; char p[30] = {}; cin.getline(p,30); cin.getline(s,30); if (match(s,p)) cout<<"matched"; else c

很简单，读入整个字符串，然后根据#include#includeusing namespace std;int main(){ char s[600] = {}; cin.getline(s,600); int l = strlen(s); int start = 0 ,end; int max = 0; char c[100] = {}; for (int i = 0

#include#includeusing namespace std;int main(){ char s[110][55] = { }; int i, j; int n; n = 0; char ts[110] = { }; while (cin >> ts) { for (i = 0; i < n; i++) { if (!strcmp(ts, s[i

思路很简单，其中用了一个新手不会用的函数，cin.putback()，各位

这个用了普通的循环，数据量不是很大的话效率还是不错的，如果数据比较大的话，

这个其实用循环或者栈写很简单而且很容易懂。而且其实就是括号匹配。这里用递归写，递归写相对来说麻烦一点，思路如下：用函数bg表示递归函数，该函数的作用是找到其参数n位置上的左括号所对应的右括号，然后弹出完成该层函数的递归。每一层都需要完成这样的任务，接下来就详细说说怎么完成这个任务。假设我们进入了c[n]所对应的左括号的递归，现在，设m处是c[n]所对应的右括号所在的位置。那么在...

#include#includeusing namespace std;int pp(int);char c[300] ={ };int l;int main(){ while (cin.getline(c, 120)) { cout<<c<<endl; l = strlen(c); int i; for (i = 0; i < l; i++) if

#include#includeusing namespace std;void hannuo(int,char,char,char);int main(){ int n; cin>>n; char a,b,c; cin>>a>>b>>c; hannuo(n,a,b,c); return 0;}void hannuo(int n, char a,char b,cha

用了kmp算法，为了巩固一下吧，其实可以很简单的，只要

#includeusing namespace std;void bi(int, int, bool);int main(){ int n; while (cin >> n) { if (n >= 0) bi(n, 32, 1); else bi(~n, 32, 0); cout << endl; } return 0;}void bi(int n

#includeusing namespace std;int main(){ int n, m, c; cin >> n >> m; struct monkey{ int num; monkey* next; }; monkey *p = NULL,*mk = new monkey; int i; p = mk; for (i = 1; i <= n; i ++)

数组模拟链表#include#includeusing namespace std;int main(){ int n; int a[505][3] = {}; cin >> n; int e, p; int tail, listtail; int idx, pidx; while(n --){ memset(a, -1, sizeof(a)); tail = 1

平面最近点对问题，经典分治问题。按照点的x坐标排序做预处理。点集合s按照x坐标平分为l，r两组点，分别得到每组组内点的最小距离dl和dr，d = min(dl,dr)，然后记横坐标距分割线距离小于d的点集为r，计算r内点与点的距离，与d比较，得到s内点的最小距离。细节再与计算r内点与点的距离。再从l组和r组得到分治结果后，对l和r内的点对y进行归并排序（复杂度为n），并筛查出属于r的点，这个排序后...