/*模拟题，做的比较有感觉以前不太擅长做模拟题，因为总是模拟中找公式，所以往往会复杂很多①处，原来想直接用公式求出下一步坐标，结果太麻烦。后来直接用一个for()循环实现，简单很多*/#include int N;void fgo(int &d, int &x, int &y, int s){ int i; switch(d) { case

/*第一次使用集合set这一类问题思路：对这2*n个元素进行排序，排序时候需要注意一点，如果h、w都相等时候，第二类需要排到前面。然后贪心，历遍所有元素，如果是第二类元素，进入集合；是第一类元素，则从堆中找出符合条件的w最大的元素，然后移除集合。推荐：③的使用*/#include #include #include using namespace std;const int

/*/*超时。题意：输出m个子序列和的最大值思路：动态规划 + 滑动数组d[m][j] = max(d[m][j - 1] + e[j], max(d[m - 1][k] + e[j]) | k ∈ [m -1, j)).表示前j个序列分割成m组，最大序列和因为状态方程中只用到d[m]和d[m - 1]两个状态，所以只需要一个二维数组即可。优化：至于max(d[m - 1][k

/*汉罗塔问题，要用到一个公式：假设N个盘子都在A上，那么搬到B上则需要2^N - 1次。dfs(B, pos)的作用是：将前面pos个盘子全部搬到B上所需要多少次。这样，dfs(B, pos) = dfs(C, pos - 1) + pow(2.0, pos - 1) - 1 + 1;即，先将pos - 1个盘子都放在C处，然后将最后剩余一个盘子放在B上，再将C上面的盘子都放回B处。d

//原来做这道题，使用刘汝佳书上的方法实现，动态规划来做，很经典的一道题#include const int nMax = 100007;struct Node{ int l, r; int sum; Node(){} Node(int l, int r, int sum):l(l), r(r), sum(sum){}}node[nMax];int main(){

/*一道很基础的Trie树的问题过了，不过200ms，使用静态数组实现可能效果更好一些*/#include #include #include #include using namespace std;const int SonNum = 27;int T, N;struct Trie{ Trie *next[SonNum]; int num; Trie() {

/*题意：组成一个环，要求至少包含两个相同字符串，求至少向给出字符串后面添加的字符数题解：根据KMP求出循环元，最小循环元t = len - next[len]。然后问题就很容易解决了。做完这道题，感触更深一些了，这个公式对任何字符串都适用。*/#include using namespace std;const int nMax = 100010;int T;char s[

/*AC思路：使用sum[i]存储前i个序列之和，队列中存储区间内出现过最小序列和，这样只需要sum[i]前去最小序列和即可。*/#include using namespace std;const int nMax = 100010;const int INF = 0x7fffffff;int A[nMax];int sum[2 * nMax];//这里需要增倍struct Q

/*题意："I"表示输入数据，"Q"表示输出第k大数据题解：优先队列，从大到小，队列中只需要k个元素。每次输出最小的即可我用小顶堆实现，如果插入元素比tree[1]小，则直接舍掉。否则，更新。*/#include using namespace std;const int nMax = 1000010;int tree[nMax];int n, k;void build(

/*线段树这道题做完以后，收获很大，学到了线段树的另一种应用：如果需要对某个区间内所有元素进行同样操作，则只需要对线段树上对应区间进行操作即可。统计每个气球被涂次数，只需要匹配到线段树的对应的区间即可，不需要统计到叶子节点。否则会超时，在最后统计结果的时候则需要搜索到叶子节点。即：①处的作用*/#include using namespace std;const int nM

/*标准的线段树模板*/#include using namespace std;const int nMax = 200010;struct Node{ int l, r; int max; Node(){} Node(int l, int r, int max):l(l), r(r), max(max){}}node[nMax * 4];int A[nMax];i

/*题意：从S到D，能否在T时刻到达主要使用奇偶剪枝主要收获：①奇偶剪枝②尽量减少scanf("%c", &c);的使用*/#include #include #include using namespace std;const int nMax = 8;char map[nMax][nMax];int visit[nMax][nMax];int n, m, t;

/*状态转移方程：d[i][j] = min(d[i][j - 1], d[i - 1][j - 2] + (A[j] - A[j - 1]) * (A[j] - A[j - 1]))d[i][j]:表示前j个物品搬运i次最小的疲劳度*/#include #include using namespace std;const int nMax = 2002;const int I

/*题意:求子矩阵的最大和题解：这一类型的题，关键在压缩，将矩阵压缩为一维数组，然后转变为求最大字段和*/#include using namespace std;const int nMax = 107;const int INF = 0x7fffffff;//int d[nMax][nMax][nMax];int N;int map[nMax][nMax];int s

判重哈希表解决：#include using namespace std;const int nMax = 15;const int INF = 10007;int t, n;int A[nMax];int flag;int hash[INF][15];int head[INF];//int head[], next[];//int ans[nMax];//int l

/*题意：输入字符串长度N和字符串S，要求输出所有字符串S前k个字母组成的序列A为循环序列时，循环序列的个数Ak，k从小到大一次输出。KMP解决，可以将算法时间复杂度缩小为O(N)，然后找规律即可。KMP算法可将字符串匹配算法时间复杂度从O(N*M)缩小到O(N+M)*/#include const int nMax = 1000007;char S[nMax];int ne

/*题意：环状字符串，输出最小表示数和最大表示数，和出现的次数题解：最小表示法 + KMP利用最小表示法求出最小表示数和最大表示数然后利用KMP求出字符串的最小循环节*/#include using namespace std;const int nMax = 1000010;char S[nMax];int next[nMax];int solve1(int len

//判重 + 剪枝，状态压缩做会超时，需要做一些优化#include #include #include using namespace std;const int nMax = 17;int N;int A[nMax];int SUM;void swap(__int64 &a, __int64 &b){ __int64 temp = a; a = b; b = te

/*参考：http://nightelf.sinaapp.com/2012/hdu-4276.html鬼吹灯问题题意：每个坟墓都有一些珠宝，从一个坟墓到另一个坟墓需要耗费掉一定的时间，问从1到N，在规定时间T内，最多可以得到珠宝数思路：最短路+树形DP，找出从1到N的最短路，因为任何两点间只有一条路，所以最短路中所有边都为必走的边。所以从1到N的路径，都为最短路，然后加上从最短路中某些个

/*这道题才真正接触到区间DP的思想d[i][j]：表示从第i个到到第j个人的最小值，那么第i个人可以是第一个出，也可以是最后一个出，假设是第k个出，则区间可分为[i + 1, i + 1 + k - 1 - 1]，d[i + k, j]前者肯定是在k之前出，后者在k之后，于是转换为区间DP问题其中需要对后者做一下处理，加上(k - 1) * (sum[j] - s[i + k - 1])

/*内存超了，这道题原来不想做，后来打算只要把数据过了就行结果内存超了，状态压缩，具体思路参见：http://acmicpc.info/archives/915*/#include #include const int INF = 4100;int d1[4096][16][64], d2[4100][16][64];char S[4100], a[4][70];int can

成都赛区：1001：线段树1002：最大流1003：1004：矩阵相乘1005：最大流1006：区间DP1007：1008：DP1009：贪心1010：

/*具体思路参见：http://hi.baidu.com/dispossessed/item/320544233e27109b9c63d1a6将每组数据转换为区间以后，然后按照x从小到大排序，便可以用DP来做。注意不符合条件的排除，①处的作用*/#include #include #include const int nMax = 507;int d[nMax];int N;

/*最大流问题拆点：增加超级源点和汇点，源点于食物相连，边的权值为食物最大量；饮料与汇点相连，变得权值为饮料的最大量；将人拆分成两个，一个与食物相连，一个与饮料相连，权值可以为1也可以为INF，无影响。将拆分后的两个节点相连，边的权值为1*/#include #include const int nMax = 2007;const int INF = 0x3fffffff;i

/*拆点：将每一个节点拆为a,a1，边的权值给节点的最小消耗，如果节点a、b之间原来有边相连，则a1,b和b1,a之间连接两条边，权值为INF。于是转换为最大流问题新收获：我原来打算用vector存储邻接表，最后发现反向遍无法处理。终于明白了②、③处的用法，目的方便对反向遍进行运算。异或使两边对应起来*///dinic实现#include #include #include

/*首先对问题进行转换，将数据分别用数组做存储，按h大小进行排序，然后从小到大进行询问操作，每次操作之前，首先将第一个数组中h值比这个值小或等于的入队，于是问题转换为线段树问题*/#include #include #include using namespace std;const int nMax = 100007;struct Tree{ int l, r;

/*贪心：s2 - w1 > s1 - w2*/#include #include const int nMax = 100007;struct Node{ int wi, si;}node[nMax];int N;int cmp(const void *a, const void *b){ Node *pa = (Node *) a; Node *pb = (Nod

/*线段树很强大，这个应该也属于区间处理、多次查询的问题，所以要用到线段树解决。sum[]分别表示区间内%5余数之和，cnt表示区间内总个数首先离散化，然后建立线段树（让线段树中l,r与A[]数组相对应起来），然后添加和删除元素即可*/#include #include #include const __int64 nMax = 100007;__int64 N;struc

/*类似fib数列，矩阵相乘，取模，所以肯定会出现循环节，不知道为什么一定是从0、1开始循环的*///求循环节#include #include const __int64 M = 222222224;using namespace std;__int64 a[4], b[4];int main(){ set se; __int64 i; __int64 f1 = 1

#include #include #include using namespace std;const int nMax = 55;int N;char map[nMax][nMax];int ans;//int vis[nMax][nMax];int checklr(int x, int y){ if(map[x][y] == '#' && map[x][y

/*显然这道题应该用线段树来做，区间更新、多次查找，然而线段树中状态比较多，需要用多个线段树来表示这些状态。原来线段树中c[][]为一个二维数组，c[k][u]，其中k表示余数，u表示a%k，这样共有55种情况，不过最后内存超，然后用一维表示，通过。思路：(i - a) % k == 0 可以等效于 i % k == a % k*/#include #include const i

/*A一道题，真心觉得不容易，各种情况要考虑。不过是一道经典DP问题首先这道题，是一道最短编辑路径问题，很久以前做过这类问题，一直没做了，所以看到这道题时候根本没有往DP方面想。d[i][j]表示，母串ss[i]得到子串s[j]的最小编辑次数，并且i与前面的操作相连。然后这道题，可以出现环，具体处理将母串复制一遍添加到后面。但是同一个字母不能用多次，所以需要分情况处理。比如母串：abcd

//这么一个水题，当时居然没有做，模拟就行#include #include using namespace std;int main(){ int N; while(scanf("%d", &N) != EOF) { int a; int i, j, k; stack sta; for(i = 0; i < N; ++ i) { scanf("%d",

/*最基础的KMP算法题，只是把字符改为了数字*/#include const int mMax = 10007;const int nMax = 1000007;int N, M;int a[nMax],b[mMax];int next[mMax];void init(){ scanf("%d %d", &N, &M); int i; for(i = 0; i < N;

/*ACAC自动机问题参考：http://www.cppblog.com/mythit/archive/2009/04/21/80633.html*/#include using namespace std;const int nMax = 1000100;const int mMax = 60;const int Max = 26;struct Node{ Node

/*题意：输入一个字符串，首先进行转换，对应位置变为该位置逆时针到下一个位置需要的变化次数，如果是最后一个则下一个位置为第一个。s[i] = s[i + 1] - s[i];如果s[i]为负，则加上8最小表示法*/#include using namespace std;const int nMax = 300010;char s[nMax];int ans[nMax];

/*题意：喜欢或者讨厌同一只猫和狗的人不能同时留下题解：将观众分成两组，左边是喜欢猫的，右边是喜欢狗的，如果存在冲突，则在这两个观众之间加一条边，于是问题转换成求最大独立集问题。*/#include using namespace std;const int nMax = 505;struct Node{ char str1[10]; char str2[10];}cat[

/*题意：输入n,m，分别表示路口数和街道数。街道单向通行，伞兵落在某路口上，可以通过街道到达下一个路口，求至少降落几个伞兵就可访问完所有的路口。解答：最小路径覆盖问题：在一个有向图中，使用最少的路径访问完所有的节点。最小路径覆盖 = 顶点数 - 最大匹配数有向图G（V,E），将V中每个顶点vi分成vi'与vi''，如果存在一条vi到vj的边，那么就在二分图中连接一条vi'与vj''的边

/*题意：n个同学，一些男女同学会有缘分成为情侣，格式ni:(m) n1 n2 n3表示同学ni有缘与n1,n2,n3成为情侣，求集合中不存在有缘成为情侣的同学的最大同学数。题解：独立集：图的顶点集的子集，其中任意两点不相邻最大独立集 = 顶点数 - 最大匹配数由于本题是从整个点集搜索，并不是将点集分开成（A）（B)，（1->2）(2->1)对称存在，所以相当于搜索了两遍。因此真正最大匹

/*基础的二分图最大匹配问题*/#include using namespace std;const int nMax = 505;int map[nMax][nMax];//存储男女匹配模式int link[nMax];//与第i个女生相匹配的男生int useif[nMax];//是否被访问int K, M, N;bool can(int t){ for(int