xtq的专栏

又是一道不小心发现的水题验证哥德巴赫猜想，打个素数表就过了，要求差最大， 那就从最小开始找嘛，c  250ms#include int prime[1000001];void getprime(){ int i=0,j=0,tmp; for(i=2;i10000011;++i) { for(j=2;ji;++j) { tmp=i*j; if(tmp>1

大水题，自己弄个Strcmp就行了#include int Strcmp(char *src,char *key){ int i=0,j=0,ans=-1; for(;src[i];++i) { if(src[i]==key[0]) { for(j=1;key[j];++j) { if(src[i+j]!=key[j]) { bre

第一次做线段树的题目，之前看过一点线段树的内容，自以为懂了，结果一提交TLE后来上网看了知道了延迟更新，终于1600msA了顺便说一下延迟更新问题，如果我们仔细观察线段树的更新操作，其实更新是o(L*lgN)级别的因为要更新到叶子为止但是其实更新并不需要更新到叶子节点，只需要搜索到等大的区间时在此区间上做个标记即可，复杂度为o（lgN），比如更新[1,5]这个区间，只需要在[1,5]区

一道很明显的哈夫曼树题看discuz有人不知道为什么是哈夫曼树，这里稍微证明一下题目说砍木板，收费等于要砍的木板的长度，要求费用最少其实这里有点跟贪心的策略相同，总是要砍这些长度的，所以先把“长的”（不一定是单条长的，可以是合起来长的）先砍掉，这样很明显优于把“长的”留在后面砍的情况（因为那个长度至少要被收费两次）现在回想一下哈夫曼树的结构，不知道哈夫曼树的请看：http://ba

基础LCS，就是求LCS，用dp来解简单说一下LCS：设两个字符串s1，s2，对于中间任意两个字符s1[i]跟s2[j]，有两种可能1,s1[i] == s2[j]，那么s1[i]必然是s1[1.....i]跟s2[1......j]的最长公共子串的最后一位，也就是s1[1......i-1]跟s2[1.....j-1]最长公共子串长度+1，理由是如果不是，那么s1[1.....i]跟

二维dp题，开一个m*n的数组对应每分钟的每个疲劳状态因为我们的Bessie是一休息就一直休息到完全恢复，所以只有当每分钟疲劳度为0的情况是要去所有可能值中的最大值意外，其他情况都只能是上一分钟疲劳度-1时的值+本分钟能跑的距离。而且有两个限制，一是疲劳度不能超过M，二是最后疲劳度为0，这反而让我们程序更简单了每分钟疲劳度为0是前M分钟当中dp[i-j][j]的最大值，因为这些状态都可

就是一个全排列的变种，其实还有优化的方法，但是太烦了，直接暴力搜了#include #define MAX 1030int check[MAX],order[MAX],n,k;int dfs(int begin,int now){ int i=0; if(n == now) { if(0 == --k) { for(i=0;in;++i) { pr

冲着题号去做的，结果是大水题，就是从小到大输出奇数组，然后从大到小输出偶数组最近想着流水线就不想用if了，n-1-(n&1)是唯一可说的一点了吧#include int main(){ int T=1,i=0,n; char data[15][26]; while(scanf("%d\n",&n) && n) { for(i=0;in;++i) { gets

做一件首饰需要若干珠宝，但是买一种珠宝需要付10个珠宝的手续费，如果我们用更好的珠宝来代替，顾客当然没有意见，所以意思就是通过买更好的珠宝来降低手续费一道很基础的DP题，但是很容易写成贪心，第一次写的时候我以为写的是DP，结果一化简发现是贪心，还是对DP的理解不够下面来证明贪心是错误的：我们有3种珠宝，a,b,c，价格是pa,pb,pc，满足pa假设贪心得出(a+10)*p

基础dp，排序后对每个人dp即可状态转移方程是dp[n]=max{dp[i]+porperty[n]}(Time[n]-Time[i]>=ABS(S[n]-S[i]))就是对之前的每一个可能让N进的人，去中间最大值#include #include struct gangster{ int T; int P; int S;}gangsters[110];

字典长度已知，直接开个结构体数组存单词，顺便保存单词长度，搜索的时候可以迅速检测不需要的单词，然后开一个30的数组保存每个单词出现的个数最后要对字典排序（当时没看题忘排序了，WA了一次）#include #include #include struct words{ char word[101]; int length; int check[30];}dict

基础DP题，就是求最长递增序列状态转移方程是dp[n]=max{dp[i]初始值设为1其他没什么陷阱了吧#include int main(){ int n=0,i=0,max=0,j=0; int dp[1001],data[1001]; scanf("%d",&n); for(i=0;i1001;++i) { dp[i]=1; } for(i=0;

一道好题，利用堆求前N小和题目给出m个长度为n数组，每个数组抽一个数字的和的前n小算法描述：sort(all data)build_heap for data[0][0]+data[1][0], data[0][0]+data[1][1]......for(i from 1 to end)       for(j from 0 to end)

打个表就过了#include int main(){ int i=0,T=0,N; int data[310]; data[0]=0; data[1]=1; for(i=2;i302;++i) { data[i]=i+data[i-1]; } for(i=1;i302;++i) { data[i]=i*data[i+1]+data[i-1]; } scan

求组合数的题，利用组合数公式kCn=(n-k)Cn化简然后利用log法求值就行了TLE的注意下下面几组数据200000 200000200000 199999200000 1就OK了#include #include int main(){ int n,k,i; double sum; while(scanf("%d %d",&n,&k) && n)

跟四则混合运算一个算法建两个栈，一个保存操作符，一个保存操作数根据操作符的优先级给操作符编号，最低优先级的数字最大（也可以反过来，随便玩），然后当操作符入栈的时候，如果栈顶数字比他大，则执行栈顶操作符直到栈为空或栈顶小于等于入栈操作符。最后别忘了完结的时候执行完栈内操作符。#include void execute(char mode,char *stack,int *po

这题没卡暴力，其实应该是有排序后o（N）的算法的，不过o(N^2)暴力可过，就没什么好说的了，不过900+的暴力，如果数据加强一点就卡住暴力了还有就是结果要用long long或者__int64，而且还有一点就是库里的abs比inline的还快，看来很好的优化过了#include #include int main(void){ int N; int cows[10010]

输入两个数字的组合表示这两个人同信仰，问最后又多少种信仰太明显的并查集，没什么好说的了，只是这题压缩路径会效率很差，因为并的操作是大多，不压缩路径对于并操作来说更快压缩路径后并的操作要遍历数组，效率就低多了初始时设信仰数为总人数，每一次并的操作信仰数减一，就能得到最后信仰总数。压缩路径3657MS，不压缩282MS不压缩路径算法：#include int s

直接模拟就行了，小心点，没什么好说的了#include char territory[120][120];char check[200][200];int x=0,y=0;int change(const char sourse, const char data){ switch(sourse) { case 'P': if('S'==data) {

当时都准备回家了，一撇看见日本题，果断切了再走明显的不能再明显的MST，就注意一下重叠的情况，重叠就设成0，输出注意是小数点后3位，稠密图用prim，0ms切掉了#include #include double data[101][101]={0};double prim(int N){ double way[101],max; char check[101];

读入每个单词，然后建字典树，最后dfs一下读出每个单词的个数/总数即可注意单词可以含有空格，所以建树的时候要从空格开始开一个30的指针数组就可以了最后提一点，因为poj时间关键所以没有释放内存，对于实际编程这是相当糟糕的。#include #include #include struct node{ struct node *al[100]; int sum;};i

用pow开根号就行了，然后判断一下A和A+1那个更近，真是良心的大水题#include #include int main(){ int B,N; double a; int A=0; while(scanf("%d %d",&B,&N)&&B+N) { a=pow(B,1.0/N); A=a; if(2*B-pow((double)A,N)-pow((

不小心发现的水题水题的关键就是刷效率了，发现我自己写的itoa，竟然比printf还好效率相当好啊下面代码gcc 16ms#define MAX 10000char data[MAX+1];char ans[MAX+1];void change(int x,int *index){ char tmp[MAX+1]; int i=0; while(x>0)

看discuz里有人用spfa做的，这题没想通怎么用spfa，再怎么一次spfa觉得不行啊，多次spfa不会超时么我是用的bfs搜的，自己写的堆，效率一般这题有环，重边，所以邻接矩阵是不行的，我用的是数组模拟邻接表没加优化，188ms过的#include #define MAX 10001#define INF 115struct node{ int d; int

一个将26个字母用数字编码的题，问你有多少可能性从右往左扫描，用一个数组记录每一位有多少种可能，递推公式是if '0'==a[i] :                  a[i]=0elseif '1'==a[i]||'2'==a[i]&&'7'>a[i-1] :                 a[i]=a[i-1]+a[i-2]else

记忆化搜索，说得好听点结合了DP和DFS的高级算法，其实就是暴力枚举，只是记录了中间过程，减少了重复搜索的时间。类似思想可见于求斐波那契数列，不过斐波那契数列有更高效的lgN的算法，利用矩阵乘法。但是对于大量查询还是O(N)的记忆化递推更快方法就是开一个100*100的数组记录每个点的最长距离，初始值为-1表示未知，dfs的时候若该点未搜索，就递归搜索，若已有值，就从数组中读取这个

直接模拟即可，因为最大周期已知，所以可以直接开数组检测周期然后就是取出每一位，如果都一样，就输出，不一样就输出‘？’#include #include unsigned int ans[65537];unsigned char check[65537];int main(void){ unsigned int A,B,C,S; unsigned int count

大水题，直接高精度模拟就行了，还是高精度加法，不过这个格式java反而读取花的时间更多吧#include #define MAX 1000010char sum[MAX],a[MAX],b[MAX];int main(void){ int N; int i=0; scanf("%d",&N); getchar(); for(i=1;iN;++i) { a[

大水题，1000个数，用个数组模拟就行，O(n*d)的复杂度，d#include int data[10010]={0};int sum(int num){ int ans=0; while(num>0) { ans+=num%10; num/=10; } return ans;}int main(){ int i=0; for(i=1;i10001;++

建图的时候反过来，把行星当边，把物品当节点就明显发现是单源最短路，而且要记录路径下面给出三种解法，bfs，dijkstra，spfa，其实后两种是一回事，而且效率没有bfs来得高bfs我用入队时检查，理论上是提高了效率bfs记录路径的时候，可以开个结构体队列代替int队列，结构体内一个index指向把他推入队列的那个节点的index，然后一串拉出来就行了，可以证明bfs入队次数不多于总