小马的博客

//这是一道贪心题，也是一道想法题，想法到位就做的出来//#includeint main(){    long long s,d;    while(scanf("%lld%lld",&s,&d)!=EOF)    {        if((4*s-d)0)        {            printf("%lld\n",10*s-2*d);   

//呜呜，原来杭电不能用__gcd//我的代码本来只有几行，这下怎来这么多，而且非常笨，哎原本代码：#include#includeusing namespace std;int main(){ int m,n; while(scanf("%d%d",&m,&n)!=EOF) { int t=__gcd(m*n,m+n);

AC代码：#include#include#include#includeusing namespace std;#define N 100010int cur;struct node{ int ans; int next[10]; void init() { ans=0; memset(next,-1

//以后对于string就用cin和cout输入输出搞定//AC代码：#include#include#includeusing namespace std;#includemapstring,string>M;int main(){ char a[30]; char b[15]; char c[15]; char d[15]; w

#include#includestring.h>#include#include#include#includeusing namespace std;//****************************************************************// Miller_Rabin 算法进行素数测试//速度快，而且可以判断 <2^63的数/

//花了一上午时间做这道题，还是没想出来咋做。。。，看了别人的博客后，才知道，原来是这样做的。先以每个岛为圆心划圆，记录其与X轴的交点，分别记为去去q[i].x,q[i].y，让后在以左交点排序。让后在扫描一遍，接下来就是纯数学了//#include#includestruct node{    double a;    double b;} q[10000];in

//首先将10000内的素数筛出来(约1000个），(p1,p2,p3)枚举三元组前两个p1,p2，可知若存在p3满足条件，必有p3=n−p1−p2，故令t=n−p1−p2。若t为不小于p2的素数，则t满足p3的条件。则答案加一。代码：#include#include#define max 10005int prime[max];int isprime[max];int

//注意，节点有很多，数组开到100w最好，否则其他可能会runtime//AC代码：#include#include#include#includeusing namespace std;int m,n;int cur=1;#define N 1000000struct node{ int ans; int next[35]; void in

#include#define max 100000int a[max];int main(){    int x;    scanf("%d",&x);    while(x--)    {        long long n;        scanf("%lld",&n);        int cnt=0;        int flag=

//哎，怎么说呢，第一次的时候看别人的模板做出来的，觉得没得意思，后来自己又写了一遍，提交总是WA，然后又修改，问别人，终于发现自己的错误所在，原来我还没用并操作，就进行判断，活该错误，看来以后要多多思考，多多检查，这样自己才会进步。代码：#include#define max 1000005int p[max];int rank[max];int a[max];int b[ma

//这道题，自己在没学DFS的时候就在做，只不过那时只是把代码背到而已，根本没理解意思，现在自己再做，发现并不是那么难，一个简单的DFS就做出来了//：当你能力提高了后，你就会发现，以前的难题，现在就是一个水题，希望以此鼓励自己坚持下去，体会AC的快感//代码：#include#include#define max 25int prime[max];int isprime[ma

1087: 三角形Time Limit: 1 Sec  Memory Limit: 128 MBSubmit: 72  Solved: 40[Submit][Status][BBS]Description7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 (图一) 图一表示一个5行的数字三角形。假设给定一个n行数字

//一个简单地DP搞定//核心：（动态转移方程）d[i]=max(d[i],d[i-1]+d[i]);代码：#include#includeusing namespace std;#define N 100005int a[N];int b[N];int main(){ int x; scanf("%d",&x); int k=1; i

//今天开始学DP。此题是求最长公共子序列。分析：先找出动态转移方程：if(a[i-1]==b[j-1]),可得，dp[i][j]=dp[i-1][j-1]+1;否则：dp[i][j]=max(dp[i-1][j],dp[i][j-1]);动态规划的题，找出动态转移方程是关键，一遇到，就要学会分析；代码：#include#includeusing namespace std;

//我承认此题是一道超级水题，但是我WA了N次，此题很坑，需谨慎，要考虑，初始化要注意，另外，a[i]的值可能大于max.，所以，要开大一点的数组来初始化。//AC代码：#include#include#includeusing namespace std;#define max 500005#define MAX 8000005int a[max];int vis[MA

//给了你动态转移方程，直接敲就是了。不过，要用开一个数组DP【】，储存每步累加值，节约时间。//AC代码：#include#include#define max 50int dp[max][max][max];int w(int a,int b,int c){ if(a0||b0||c0) { return 1; } if(a

//这个题就是一个斐波那鍥数列，首先我的思路是先写出前N（1-5）内，然后发现规律，写出方程a[i]=a[i-1]+a[i-2];//AC代码：#include#define max 46int a[max];int main(){ int i; a[1]=2; a[2]=3; for(i=3;i46;i++) { a[i

代码：#include#includetypedef struct LNode{    int data;    struct LNode *next;}LNode,*LinkList;LinkList InitList(){    LinkList pHead;    pHead=(LinkList )malloc(sizeof(LNode)); 

简单代码：#include#define max 1000int p[max];int n,m,t;int search(int k){    if(p[k]!=k)    {        p[k]=search(p[k]);    }    return p[k];}int bing(int x,int y){    int x1=s

代码：#include#include#define MaxSize 1000typedef struct{    int *elem;    int Length;}SqList;int InitList(SqList *L){    L->elem=(int *)malloc(sizeof(int)*MaxSize);    if(!L->ele

代码：#include#include#define MaxSize 1000typedef struct Stack{    int *data;    int top;}Stack;int InitStack(Stack *s){    s->data=(int *)malloc(sizeof(int)*MaxSize);    if(!s->d

代码:#include#define Max 1000000int a[Max];void quicksoft(int a[],int left,int right){    int i,j,temp;    i=left;    j=right;    temp=a[left];    if(left>=right)        return; 

#include#include#define MaxSize 1000typedef struct queue{    int *data;    int front;    int last;}Queue;int InitQueue(Queue *q){    q->data=(int *)malloc(sizeof(int)*MaxSize);

//我采用的是DFS，还没想出用DP怎么做，暂时就用DFS进行。首先，从每个点开始，往下搜就行了。代码：#include#include#includeusing namespace std;#define N 105int a[N][N];int dp[N][N];int vis[N][N];int dir[4][2]={{0,1},{1,0},{0,-1},

//错了N次，结果看人家的讨论，结果才知道要用short int 定义DP【】【】数组，因为动态规划紧缺内存。设s[1]……s[n]表示字符串1至n位，i为左标，j为右标 ，则i从n递减，j从i开始递增。 dp[i][j]表示i和j之间至少需要插入多少个字符才能对称,我们最终需要得到的值是dp[1][n]. 则 if(s[i]==s[j])     dp[i][j]=dp[i+1]

代码：#include#include#include#include#define MaxSize 10000struct StackOp{    char op[MaxSize];    int top;} stackop;struct StackNum{    double num[MaxSize];    int top;} st

代码：#include#include#define max 100000int A[max];int T[max];void Merage(int* A,int x,int y,int* T){    if(y-x>1)    {        int p,q,m,i,j;        m=x+(y-x)/2;        p=x;   

代码：（很快的哟。。。。。）#include#define max 1000000int A[max];int bserach(int A[],int x,int y,int t){    while(x    {        int m;        m=x+(y-x)/2;        if(A[m]==t)        {       

AC代码：这题目是经典的DP题目，也可叫作LIS（Longest Increasing Subsequence）最长上升子序列 或者 最长不下降子序列。很基础的题目。但是注意的是此题用传统的n^2算法会超时。 A.O(n^2)算法分析如下：（a[1]...a[n] 存的都是输入的数）1、对于a[n]来说，由于它是最后一个数，所以当从a[n]开始查找时，只存在

//这道题刚开始不会做，还是看别人的代码会的，下来再研究研究//AC代码：#include#include#includeusing namespace std;#define N 150#define M 1000char a[N][N];char b[N][N];char c[M];int dp[N][N];int L1,L2;void dfs(int x,i

//因为学校断网，当时没做，才去做，居然发现是水题//AC代码：#include#includeusing namespace std;int main(){ int n,m,p,q; int x; scanf("%d",&x); while(x--) { scanf("%d%d%d%d",&n,&m,&p,&q);

//题意：给你两个字符串，叫你求出最少操作次数，使两个字符串相同；//思路：找出字符串中最长公共子串，用max(Len1,Len2)-dp[Len1][Len2]求最长公共子串：if(a[i-1]==a[j-1],dp[i][j]=dp[i-1][j-1]+1;else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);AC代码：#include#inc

#includeint main(){    int n,m;    while(scanf("%d%d",&n,&m)!=EOF)    {        int i;        int s=0;        for(i=2;i        {            s=(s+m)%i;        }        printf("%d

//直接暴力打表飘过，值得注意的就是1也是P-number.AC代码：#include#include#define max 1005int isprime[max];int prime[max];int vis[max];void Init(){ int i,j,cnt=0; memset(vis,0,sizeof(vis)); memset(i

//我刚开始以为好难，其实就是一个DFS，必须记录走过的路径。用一个vis[max][max],数组标记走没走过，走过就是1，没走过就是0.这是关键。AC代码：#include#include#define N 1005char a[N];char b[N];char c[N];int vis[N][N];int ok;int L;void dfs(int x,int

代码：#include#include#includeusing namespace std;#define N 1005int a[N];int main(){ int m,n; while(scanf("%d%d",&m,&n)!=EOF) { int i,j; memset(a,0,sizeof(a));

//取对数比较就好了log(ab)=b∗log(a),注意会有精度误差AC代码：#include#include#includeusing namespace std;#includeint main(){ double a,b,c,d; while(scanf("%lf%lf%lf%lf",&a,&b,&c,&d)!=EOF) {

//sum=2*n+m(n代表人数，m代表数组中有多少个1）代码：#include#define max 35int a[max][max];int n;int main(){ while(scanf("%d",&n)!=EOF) { int i,j; int m=0; for(i=0;in;i++)

//题目大意：求一个数变成另一个数需要几步？给你的操作有pre+1,pre-1，pre*2.//我们可以把这个问题转换成最短路问题，利用BFS进行。AC代码：#include#include#define max 100005int n,k;int vis[max];struct node{ int x,step;} queue[max];void bf

//其实就是求最大素因子//AC代码：#include#includeusing namespace std;int main(){ int n; while(scanf("%d",&n)!=EOF) { if(n==1) { printf("0\n"); continue;