总是在想,如果我能坚持2年,会是怎样?

本文谈到的Promise是指javascript环境下的Promise，然而Promise这个功能在若干语言中均有实现，我本次会在Nodejs服务端环境下进行学习和理解。Promise是为了解决日趋复杂的异步程序设计而出现的，简单的异步例如：发起一个ajax请求来获取数据，之后渲染DOM。然而现实世界并没有这么简单，我们极有可能需要同时发起多个ajax请求并等待它们全部返回，在获得

在开发CMS（内容管理系统）系统时，一般都会用到一个侧边栏或者顶部的二级或者三级菜单，当点击或者鼠标悬浮时，菜单能够随之展开或收起。本文纯粹为了练习一下react，因此我会在react环境下实现这么一个小组件：它假设了菜单数据来自于网络请求，并且仅实现无限分级菜单的核心功能（父子关系，展开与收起），至于样式则不是关注的重点。分析&设计既然要实现一个动态生成的无限分级菜单，最

黄豆tvPHP爬虫机器学习搜索

http://www.cnblogs.com/leoo2sk/archive/2011/07/10/mysql-index.htmlhttp://tech.idv2.com/2008/07/31/memcached-005/http://www.mysqlops.com/2011/09/10/innodb-primary.htmlhttp://blog.csdn.net/joylnwa

#include #include #include #include #include #include #include #include #include using namespace std;struct Kmeans{ vector> >

/* Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved. This software is provided 'as-is', without any express or imp

http://www.cnblogs.com/chengmo/archive/2010/10/11/1847772.htmlhttp://dev.mysql.com/doc/refman/5.1/zh/index.htmlhttp://database.51cto.com

#include <windows.h> //windows程序设计必须要包含的头文件#include <string.h>#include <stdio.h>#include "resource.h" //资源文件//////////////////////////////////////响应函数//////////////////////////////////////////////////////////LRESULT CALLBACK WndProc (HWND,

#include <Winsock2.h>#include <stdio.h>#pragma comment(lib,"ws2_32.lib")int main(){ //加载套接字库 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested=MAKEWORD( 1 , 1 ); err=WSAStartup(wVersionRequested,&wsaData)

#include <Winsock2.h>#include <stdio.h>#include <windows.h>#pragma comment(lib,"ws2_32.lib")int main(){ //加载套接字库 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested=MAKEWORD( 1 , 1 ); err=WSAStartup(wVers

BOOL CChatDlg::InitSocket(void){ if(INVALID_SOCKET==(m_socket=socket(AF_INET,SOCK_DGRAM,0))) { MessageBox(TEXT("套接字创建失败!")); return FALSE; } SOCKADDR_IN addrSock; addrSock.sin_family=AF_INET; addrSock.sin_port=htons(6000); addrS

#include <Winsock2.h>#include <stdio.h>int main(){ //////////////////////////////////////////// //设置选择WinSock协议 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD( 1, 1 ); err = WSAStartup( wVer

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct){ if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1; if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY |

void CAsdfView::OnRButtonUp (UINT nFlags, CPoint point) { // TODO: Add your message handler code here and/or call default CMenu menu; menu.LoadMenu(IDR_MENU1); CMenu *subMenu=menu.GetSubMenu(0); CPoint pt(point); ClientToScreen(&pt);

void CBtn::OnMouseMove(UINT nFlags, CPoint point) { // TODO: Add your message handler code here and/or call default ShowWindow(SW_HIDE); m_pBtn->ShowWindow(SW_SHOW); CButton::OnMouseMove(nFlags, point);} BOOL CProp1::OnSetActive

void CMyboleView::OnDialog() { // TODO: Add your command handler code here if(m_dlg.GetSafeHwnd()==NULL) { m_dlg.Create(IDD_DIALOG1,this); } m_dlg.ShowWindow(SW_SHOWNORMAL);}这是响应一个菜单消息,生成一个对话框并显示出来. 对话框对象为View类成员变量.
 <br /

#include <windows.h>#include <stdio.h>LRESULT CALLBACK WinSunProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam );int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,

#include <stdio.h>int partition(int *A,int p,int r){ int x=A[r]; int i=p-1; for(int j=p;j<=r-1;j++) { if(A[j]<=x) { i=i+1; int t=A[i]; A[i]=A[j]; A[j]=t; } } A[r]=A[i+1]; A[i+1]=x; return i+1;}void

#include <iostream>#include <set>#include <vector>using namespace std;/* Graph input*/const int SIZE = 1000;int u[SIZE],v[SIZE],m;set<int> vis;vector<int> cover;typedef struct node{ node() { v=-

#include <stdio.h>#include <stdlib.h>#include <math.h>#include <string.h>#include <algorithm>/*********************************/* π的一个近似值* 其他一些常量/*********************************/const double PI = 3.1415926535898;const int SI

#include <stdio.h>const int M = 1000;int input[M][M];int row[M];int col[M];int m,n;void dpCol(int r){ int c=input[r][n-1],d=0; int i; for(i=n-2;i>=0;--i) { int a=input[r][i]+d,b=c; d=c; c = a > b ? a:b; } ro

#include <stdio.h>/*********************************/* 差分系统的约束图* 由于bellman算法只需要边的信息* 所以只存边的相关信息就可以了/*********************************/const int MAXN = 10000;int u[MAXN],v[MAXN],w[MAXN];int dist[MAXN];int n,m;/*******

#include <stdio.h>#include <string.h>const int MAXN = 10000;/*********************************/* 图G的邻接表表示/*********************************/int first1[MAXN];int next1[MAXN];int u1[MAXN],v1[MAXN];/************************

#include <stdio.h>#include <string.h>/*********************************/* KMP算法* 预处理时间：O(m), 运行时间O(n)* 改进了状态机算法的预处理时间* 依旧利用后缀最前前缀原理* 理解有限自动机后理解此算法/*********************************/const int MAXN=10000;char T[MAXN],P

#include <cstdio>#include <algorithm>#include <cstring>using namespace std;/*********************************/* 有限自动机 字符串匹配算法* 预处理时间：* O(m^3 * numOf(charactors in string)* 匹配时间：* O(n)* 关键：构造状态变迁函数,复杂度较高，思想一流/******

#include <stdio.h>#include <string.h>/*********************************/* n:文本串T长度* m:模式串P长度* h:d^(m-1)* d:进制基数(这里采用26进制)* t[s]:对应位移s的文本串T子串的d进制表示* p:模式串P的d进制表示* q:对d进制整数模q,q是素数(越大越容易排出非法位移s,但是过大会导致模运算溢出,这里取13)/***

#include <iostream>#include <queue>#include <time.h>#include <windows.h>using namespace std;const int need = 3125010; //足够10000 * 10000 个位const int col=10000;unsigned int G[need],isV[need]; //图G , 访问标记isVint n,k;int cnt;

#include <iostream>#include <queue>using namespace std;/*********************************/* 最小割最大流算法* 可以在求得最大流的同时获取最小割集S,T* 邻接矩阵存储各类信息/*********************************/#define INF 1000000const int MAXN=1000;int cap[MAXN][MAXN

#include <iostream>#include <queue>using namespace std;/*********************************/* 最小割最大流算法* 可以在求得最大流的同时获取最小割集S,T* 邻接矩阵存储各类信息/*********************************/#define INF 1000000const int MAXN=1000;int cap[MAXN][MAXN

#include <iostream>#include <queue>using namespace std;const int MAXN=100;/*********************************/* SPFA算法需要的空间分配/*********************************/queue<int> q;bool inq[MAXN];/*********************************/*

#include <iostream>#include <queue>using namespace std;const int MAXN =1000000;int u[MAXN];int v[MAXN];int w[MAXN];int d[MAXN];int first[MAXN];int next[MAXN];bool done[MAXN];typedef pair<int,int> pii;priority_queue<p

#include #include const int MAXN=10000;int u[MAXN]; //边的起点int v[MAXN]; //边的终点int w[MAXN]; //边的权值int r[MAXN]; //间接排序int p[MAXN]; //并查集int n; //顶点的数量int m; //边的数量int cmp(const void *a,const void *b){ int *p=(int*)a; int *q=(in

#include <iostream>using namespace std;const int MAXN = 1000;int lch[MAXN],rch[MAXN];char op[MAXN];char input[MAXN];int nc=0;/*********************************/* 递归构造表达式树* 每次找括号外的+ - * /* 优先+ - 划分， 其次* /划分* 原则

#include <iostream>#include <vector>#include <algorithm>using namespace std;/*********************************/* 可以动态变化的邻接矩阵* G[i]表示顶点i的邻接点/*********************************/const int MAXN=100;vector<int> G[MAXN]; //无根树int l[M

#include using namespace std;const int MAXSIZE=100000;char str[MAXSIZE];char out[MAXSIZE];int l[26];int len;int num;int g(int n){ int ret=1; for(int i=1;i

#include <iostream>#include <cmath>#include <cstring>using namespace std;/*********************************/* gcd(int a,int b)* 原名：欧几里得算法* 辗转相除法求最大公约数* 无所谓a,b大小次序./*********************************/int gcd(int a,int

#include <iostream>using namespace std;#define MAX 1000000const int NUM = 20;int G[NUM][NUM];int n;int d[1<<NUM];int ret(){ d[0]=0; for(int ss=1;ss<(1<<n);++ss) { int i,j; d[ss]=MAX; //表示不可能

#include <iostream>using namespace std;int input[10000];int n;int minS[10000];int s[10000];int main(){ scanf("%d",&n); int i; s[0]=0; for(i=1;i<=n;++i) { scanf("%d",&input[i]); s[i]=s[i-1]+

#include <stdio.h>#include <string.h>#include <stdlib.h>typedef int State[9];const int MAXSTATE=1000000; //状态数不会超过这个,9!种State st[MAXSTATE],goal; //状态数组, 目标状态int dist[MAXSTATE]; // 已走步数int fa[MAXSTATE]; // 前趋状态/*移动方向*/const int d

#include <stdio.h>#include <stdlib.h>#define MAX 10000000int a,b; //a<bint final[100];int temp[100];int n;int find=0;void score(int x,int y,int m){ if(m==n) { if(y%x==0&&y>x*temp[m-1]) { te

#include <stdlib.h>#include <stdio.h>#include <string.h>#define MIN -10000000typedef struct{ int edge[100][100]; int vex;}Graph;int permu[100]; //结点排列次序int bPermu[100]; //最佳排列int appear[100]; //使用标记int rank[100]; /

#include <stdio.h>#include <math.h>#include <stdlib.h>#include <string.h>int input[20];int tOut[20];int app[20];int tApp[20];int n;int cmp(const void *a,const void *b){ int *c=(int*)a; int *d=(int*)b; if(*c==*d) { r

#include <stdlib.h>#include <stdio.h>#define LOWEST -1000000int row,col,map[1000][200],dp[1000][200];int direc[4][2]={{0,1},{-1,0},{0,-1},{1,0}};int main(){ int i,j,result=LOWEST,tmp; scanf("%d%d",&row,&col); for(i=0;i<row

#include <stdlib.h>#include <stdio.h>#include <string.h>#include <math.h>const int N=100005;const double MAX= 10e100,eps=0.00001; //mark!struct Point{ double x,y; int index;};Point a[N],b[N],c[N];double closest(Point *

#include <iostream>#include <queue>#include <vector>#include <stack>using namespace std;//点结构体typedef struct{ int x,y;}Point;//左下角点PoPoint leftBotm;//极角比较函数int leftTurn(Point p1,Point p2,Point p3) //p1:next-top, p2:top

#include <iostream>using namespace std;typedef struct{ int x,y;}Point;//判断线段端点在直线的哪一侧.int direction(Point p1,Point p2,Point p3){ return (p2.x-p1.x)*(p3.y-p1.y)-(p3.x-p1.x)*(p2.y-p1.y);}//判断与直线共线的点是否在线段上bool onSegment(Poi

#include #include #include using namespace std;struct Trie{ int flag; struct Trie* next[26]; void init() { memset(next,0,sizeof(next)); flag=0; }}trie[10000];int k=1;struct Trie *root=&trie[0];void insert(string &s

#include "stdafx.h"#include <windows.h>#include <windowsx.h>#include "Resource.h"#include "MainDlg.h"/* 数据库头文件*/#include <sql.h>#include <sqlext.h>#include <sqltypes.h>/* 宏定义*/#define LOGIN_TIMEOUT 30#define MAXBU

#include #include using namespace std; //SPFA()使用#define MAX 100000 //const int numV=5; //SPFA记录是否已访问 bool inQueue[numV]; //路径前驱结点数组int preV[numV];//路径上最小残流int preF[numV];//顶点到源的最小耗费int cost[nu

#include <stdio.h> #include <string.h> #define MAX 102 long n,n1,match; long adjl[MAX][MAX]; long mat[MAX]; bool used[MAX]; FILE *fi,*fo; void readfile() { fi=fopen("flyer.in","r");

#include #include using namespace std;//BFS()用#define MAX 100000//包括源点(0),汇点(5),所有点在内,一共6个点,算法导论405页的图.const int numV=6; //广搜记录是否已访问bool visited[numV];//流网络struct{ int c; //容量 int f; //流}flowNet[numV][numV]; //广搜Info

描述 一个正整数,如果它能被7整除,或者它的十进制表示法中某个位数上的数字为7,则称其为与7相关的数.现求所有小于等于n(n输入 输入为一行,正整数n,(n输出 输出小于等于n的与7无关的正整数的平方和 样例输入 21样例输出 2336 #include #include int main(){ int sum[100]; int tot

#include #include typedef struct{ int x,y;}Part;int main(){ int n; Part source; Part *obj; scanf("%d",&n); scanf("%d%d",&source.x,&source.y); obj=(Pa

#include #include int maxSum[20][100][20];int num[20];int getMaxSum(int n,int sum){ sum/=2; int k=n/2; for(int i=0;i<=sum;++i) { maxSum[n+1][i][0]=0;

 2010年华为软件设计大赛试卷类别：软件C++语言 高级   编程题（共3题，第1题20分，第2题30分，第3题50分。请上机编写程序，按题目要求提交文件。[详见考试说明]本试题采用自动测试用例进行评分，测试用例不对考生公开，凡不满足提交要求导致不能编译或用例不通过，不予评分）。 1. 逆序输出问题描述： 输入一个字符串，将其逆序后输出。 

#include #include #define Siz 3#define Min -10000int minHeap[3]={Min};void updateHeap(int x){ if(x>minHeap[0]) { minHeap[0]=x; int p=0; while(p<3)

#include using namespace std;//Trie Node structurestruct TrieNode{ bool isStr; char word[20]; //模拟拼音输入法 TrieNode* next[26]; TrieNode() { isStr=false;

#include #include #define No -1struct Graph{ int **edge; int numV;};void Floyd_Warshall(Graph &g,bool **t){ for(int i=0;i<g.numV;++i) { for(int j=0;j<g.n

#include #include #define MAX 9999struct E{ int weight; bool flag;};struct Graph{ E **edge; int numV;};struct Least{ int dist; int pre;};int *path;bool *v

#include #include #include //假设生成....100之间的个随机数#define One 0x00000001int cmp(const void *a,const void *b){ int *aa=(int *)a; int *bb=(int *)b; if(*aa<*bb) { return -1; }

防卫导弹时限：1000ms 内存限制：10000K  总时限：3000ms描述：一种新型的防卫导弹可截击多个攻击导弹。它可以向前飞行，也可以用很快的速度向下飞行，可以毫无损伤地截击进攻导弹，但不可以向后或向上飞行。但有一个缺点，尽管它发射时可以达到任意高度，但它只能截击比它上次截击导弹时所处高度低或者高度相同的导弹。现对这种新型防卫导弹进行测试，在每一次测试中，发射一系列的测试导弹（这些导弹发

电子老鼠闯迷宫时限：1000ms 内存限制：10000K  总时限：3000ms描述：有一只电子老鼠被困在如下图所示的迷宫中。这是一个12*12单元的正方形迷宫，黑色部分表示建筑物，白色部分是路。电子老鼠可以在路上向上、下、左、右行走，每一步走一个格子。现给定一个起点S和一个终点T，求出电子老鼠最少要几步从起点走到终点。输入：本题包含一个测例。在测例的第一行有四个由空格分隔的整

#include #include using namespace std;#define ONE32 0x00000001unsigned int flag[100]={0};// 字符串标记数组int pos=0;int main(){ while(true) { string str; cin>>str; unsigned int

#include #include #include #include struct Node{ Node *pLeft; Node *pRight; char ch;};char str1[100];char str2[100];int findRoot(int m,int n,int rootCh){ for(int i=m;

直接把基础思想讲出来了,问题是:一个整数数组,除了1个数外,其他数都是成对出现的.例如: 2 2 1 3 3 ,1是独立出现的数字. 问题就是找出这个独立出现的数字是什么?方法是对所有整数异或运算，例如2^2^1^3^3, 因为相同的数异或后为0,所以成对的数字都异或后都为0.又由于0^n=n，所以所有整数异或后的结果就是这个单独的数字, 这个例子最后一步是0^1=1,所以1是

#include #includeusing namespace std;int busyTime=10;int idleTime=busyTime;int main(){ while(true) { __int64 startTime=GetTickCount(); while(GetTickCount()-startTime<=idleTim

#include using namespace std;#define MIN -99999void print(int **path,int space[],int v,int i,int n){ if(i==n+1) { return; } cout<<path[v][i]<<endl; print(path,space,v-path[v][

#include using namespace std;typedef unsigned int Bit32; //能表示42亿+的无符号整数const Bit32 maxLen=125000001; //数组长度,0-40亿const Bit32 thirtytwo=32;void createArray(Bit32 *&arr){ arr=new B

一个整数除以2相当于把二进制串右移1位,这个很明显....因为本来是20+21+22+23+24这么一个整数，你一旦除以2，相当于给整体提出一个2, 就相当于原来的二进制串右移一位. 判断一个1.........N内,有多少能被m整除的个数，等于N/m....... 还有, 判断一个数是否是奇数,根据第1位是0是1就可以了 判断一个数是2的方幂,n>0 && (n&(n

题目描述:给定一个长度N数组,取N-1个数作乘积,找出最大值. 算法一:  枚举每一个不在N-1内的数,分别计算剩余N-1个数的乘积, 由于有N种情况,没种情况遍历计算乘积,所以n2. 算法二：假设第i位不在N-1内,那么需要左边的乘积乘以右边的乘积.       为了优化时间,做预处理,先算出i位左边的乘积与右边的乘积. 这个过程需要2 *n的时间，是线性的。 计算Max

#include using namespace std;#define byte unsigned char#define FULL 255byte getLeft(byte num){ return num>>4;}void setLeft(byte &num,byte left){ num=num&(FULL>>4)|(left<<4);

public class Count1Integer { /** * @param args */ public long count1Integer(int n){ long count=0; int lowerNum=0; int higherNum=0; int currNum=0; int factor=1; while(n/fa

public class CountPos { public int countPos(int []array){ int length=array.length; int sum=0; for(int i=0;i<length;++i){ int count=array[i]-1; if(count!=0){ for(int j=0;j<i;++j){

#include #include #include using namespace std;#define Len 4//连连看矩阵长与宽#define White -1//格子无图案#define Black -11 //有图案#define Line_Connect 99//可以直线连通或者可以从源直线连通#define Line_Un_Connect 9

#include using namespace std;int sum[100][100];int sanjiao[100][100];int edge;void dp(){ for(int i=0;i<edge;++i) { sum[edge-1][i]=sanjiao[edge-1][i]; } for(int i=edge-2;i>

#include #include using namespace std;#define LEN 1000int l1,l2;string str1,str2;int dist[LEN][LEN];int edit(){ for(int i=0;i<=l1;++i) { dist[i][0]=i; //str1扫描到i,str2扫描结束,

 #include #include #include using namespace std;//方向向量int direc[4][2]={{0,1},{-1,0},{0,-1},{1,0}};//封闭,开放列表标记enum Flag{ SEAL, OPEN, UNVISITED};//===========最小堆节点类==

#include #include using namespace std;#define KEPT true#define DELETED falseint main(){ //筛法求素数,输入范围: n int range; cin>>range; //挑选小于n的奇数记录入数组,因为偶数一定不是素数,下标cnt的元素对应奇数2*cnt+1,并初

最近一直在弄图, 学着学着就发现疑问慢慢变多,大家看一下耳熟能详的深搜和广搜基础: 广搜: 如果从A到B存在路径，则广搜一定能找到从A到B的一条最短路径, 这是毋庸置疑的.....让我理解这个应用,就好像有向图的传递封包一样,就是找到一条从A到B的最短路径(边最少). 深搜: 如果有A到B的路径,那么深搜能找出所有从A到B的路径,这应该是深搜的特点吧.....  大

#include #include #include #include using namespace std;typedef struct{ int x; int y;}Direc;//横向x，纵向y，右正，下正Direc direc[8]={{1,-2},{-1,-2},{-2,-1},{-2,1},{-1,2},{1,2},{2,1},{2,-

#include #include #include #include using namespace std;int main(){ priority_queue ,greater> heap; int max,min; //用几个数据测试一下 for(int i=1;i<=10;++i) { heap.push(i); } wh

#include using namespace std;#define LEN 20000#define NO_POSTER -2 //无海报#define MIX_POSTER -1 //混合(间断)海报#define NO_FLAG 0//线段树的静态表示,左边界,右边界,标志域,结点对应海报编号,海报能否看见的标记数组,结点数量,最终能看见的海报数量int

#include using namespace std;#define MAX 16000int left_child[MAX],right_child[MAX],left_bound[MAX],right_bound[MAX],seat[MAX],bj[MAX];int node=0,res[MAX],num;void clear(int index){ s

#include #include #include #include using namespace std;class Double_Hash_List{public: inline Double_Hash_List(int list_size=97):_list_length(list_size),_list_size(0) { _hash_li

#include using namespace std;#define MAX 16000int left_child[MAX],right_child[MAX],left_bound[MAX],right_bound[MAX],color[MAX],bj[MAX];int node=0,res[MAX],temp;void clear(int index){

#include #include using namespace std;class Union_Find_Sets{public: inline Union_Find_Sets() {} void make_set(int n); int find_set(int n); void union_set(int x,int y); int coun

#include #include using namespace std;class Union_Find_Sets{public: inline Union_Find_Sets() {} void make_set(int n); int find_set(int n); void union_set(int x,int y); int coun

#include using namespace std;int wall[10000001]={0}; //开个10000001的数组标记每个byte贴的哪一张海报,只用1...10000000int *flag;//动态开个海报数量的数组用来标记哪张海报没被覆盖int n; //n张海报int sum=0;int main(){ cin>>n;

#include #include #include using namespace std;string s;//主串string t;//模式串vector next;//next函数值vector nextval;//next修正函数值void get_next(){ int i=1; int j=0; next[1]=0; w

#include #include #include using namespace std;//1,2.....9 一共9个数分成3组, 形成3个3位数,比值为1:2:3 列出所有情况int main(){ char s[20]; char ch; string str; int j; for(int i=123;i<=321;++i)

#include using namespace std;//100块,买100只鸡,大:3块1只,小:1块3只,中2块一只int main(){ for(int max=0;max<=100;++max) { for(int min=0;min<=100;++min) { if((100-max-min)>=0&&(100-max-min)%3==

/*题目：多边形游戏作者：梁栋版本：VS2008状态转移式：min(max)_sum[i][j] ，表示从i数逆时针数j个的链条合并的最小或者最大值方法： 从i到i+j-1中找一个运算符断开，会有两种情况.情况一： 运算符为 +， 则整个链条的最大或者最小值等于两个子链条的最大或者最小值的和情况二： 运算符为 *, 则整个链条的最大或者最小值等于两个子链条的最

#include #include #include using namespace std;int main(){ vector candy; string command; int n,m; void respond(char,int,int,int,vector &); cin>>n>>m; while(n!=0&&m!=0) {

问题描述所谓回文，就是像"acbca"或者"12966921"这样的字符串，左右对称。现在的问题是，假如给你"abaqbaa"这样的字符串，你可以对它添加一些字符，得到"aabaqqabaa"变成回文，一共加了3个字符。问对于随意给的一字字符串，你最少要加多少个字符才能使它变成回文？对于刚刚的"abaqbaa"，其实可以只加2个字符变成"aabaqabaa"就成为回文了，2就是这个字符串的最少添加

Hanoi塔的问题题目描述：Hanoi塔的问题相信大家很熟悉了：有三根针上放了一些圆盘，半径各不相同，大的不能放在小的上面，每次只能移动一个，要把它们全部移到第三根针上输入：多组测试数据，每组两行。第一行是n(1第一个数表示最大的盘在第几根针上，第二个数表示次大的盘在第几根针上，第n个数表示最小的盘在第几根针上，输入的n为0的时候结束输出：全部移动到第三根针上所需要的最少步数样例输入：311133

#include using namespace std;void main(){ int n; cin>>n; double i=1; double j=1; double sum=0; double temp; while(n>=1) { sum+=i/j; temp=i; i=i+j; j=temp; --n;

#include using namespace std;void main(){ int a; int b; int c; for(a=0;a<=9;a++) { for(b=0;b<=9;b++) { for(c=0;c<=9;c++) { if(a*100+b*10+c*1==a*a*a+b*b*b+c*c*c)

#include #include using namespace std;char a1[100];char b1[100];string a;string b;int l1;int l2;void print(){ cin.getline(a1,sizeof(a1));//** a=a1; cin.getline(b1,s

#include #include using namespace std;void print(int n){ if(n==2) { cout<<n<<"是质数"<<endl; return; } else { int k=(int)sqrt((double)n); for(int i=2;i<=k;i++) { if