高效算法的奥秘
A. 我想问下Fibonacci数列的下面这段c++高效算法的理解
(1)只要n+1就够
(2)memset(t,0,(n+2)*4); 此句将t数值各元素全部清零，x≥2时 t[x]初始值全为0
t[x]!=0 表示已经计算过 ，可直接返回
t[x]==0 表示没有计算过，需要调递推过程
(3)本段程序算仅能计算前40个Fibonacci数，因为第40个Fibonacci已超过了C++整数能表示的范围。
B. 数据结构 设计高效算法问题
// 要求是删除顺序表中在范围[x, y]内的元素。
// 按常规思路，每删除一个顺序表元素，则要将其后的元素整体前移一个位置。这种算法用到了双重for循环，时间复杂度为O(n^2)。
// 以下的算法只用到了单重for循环，时间复杂度为O(n)。原理是把所有不在范围[x, y]内的元素依次保存到顺序表的前部，而不处理本来要删除的、在范围[x, y]内的元素。当把所有不需要删除的元素都保存到了顺序表前部，只需要重新设置一下顺序表的长度为“前部”的最大下标+1，就模拟了删除操作。
void fun(SqList *&L, ElemType x)
{
// i为循环计数器。
// j为不需要删除的元素个数，初始化为0。
int i, j = 0;
// 依次遍历顺序表的每个元素
for (i = 0; i < L->length; ++i)
{
// 只处理不需要删除的元素，即不属于区间[x, y]的元素
if (!(L->data[i] >= x && L->data[i] <= y))
{
// 每找到一个不需要删除的元素，就把该元素保存到下标j的位置。
L->data[j] = L->data[i];
// 随后令j自增1。之前j代表的是处理后的顺序表的最大下标，现在j代表的是处理后的顺序表的长度。由于下标从0开始，所以长度永远比最大下标大1。
++j;
}
}
// 设置顺序表的长度为j，这样以后遍历顺序表只能访问前j个元素。即使下标j之后可能还存在属于[x, y]的元素，但是不会访问到它们，自然相当于“删除”了。
L->length = j;
}
C. 数据结构:设计一个高效算法，将顺序表中的所有元素逆置，要求算法空间复杂度为O(1)。
设计一个高效算法，将顺序表中的所有元素逆置，要求算法空间复杂度为O(1)扫描顺序表L的前半部分元素L.data[i] (0<=i<L.length/2)，将其与后半部分的对应元素L.data[L.length-1-i]进行交换即可。
顺序表的存储只要确定了起始位置，表中任一元素的地址都通过下列公式得到：LOC（ai）=LOC（a1）+（i-1）*L 1≤i≤n 其中，L是元素占用存储单元的长度。
(3)高效算法的奥秘扩展阅读：
数据的物理结构是数据结构在计算机中的表示，它包括数据元素的机内表示和关系的机内表示。由于具体实现的方法有顺序、链接、索引、散列等多种。
数据元素的机内用二进制位（bit）的位串表示数据元素。当数据元素有若干个数据项组成时，位串中与各个数据项对应的子位串称为数据域（data field）。
D. 求跳舞毯的高效算法
#include<iostream>
using namespace std;
long double two[1000],one[1000];
long double SumCount(int a,int b,int n)
{
if(a==b)
{
if(n==0)
return 1;
else if (n==1)
return 0;
else
{
if(two[n-1]==0)
{
two[n-1]=SumCount(a,(a+1)%3,n-1);
}
return 2*two[n-1];
}
}
else
{
if(n==0)
return 0;
else if(n==1 )
return 1;
else
{
if(two[n-1]==0)
two[n-1]=SumCount(a,(3-a-b),n-1);
if(one[n-1]==0)
one[n-1]=SumCount(a,a,n-1);
}
return two[n-1]+one[n-1];
}
}
void main()
{
int n;
re: cout<<"输入一个正整数："<<endl;
cin>>n;
if(n<0 || n>1000)
{
cout<<"输入不合法！"<<endl;
goto re;
}
for(int i=1 ;i<1000;i++)
{
two[i]=0;
one[i]=0;
}
cout<<"路径个数为："<<SumCount(0,0,n)<<endl;
}
E. 斐波那契数列任意项 高效算法的思路是什么前两项相加
如果是求第n项斐波那契的话：
时间复杂度为O(1)，你说高不高。
F. C语言编程（高效算法）：3的1000次幂
需要用高精度，写起来会比较繁
至于高效，可以先计算
3^2,3^4,3^8,3^16,3^32,3^64...3^1024
2^1000 = 3^8 * 3^32 * 3^64 * 3^128 * 3^256 * 3^512
G. 高分重赏：求一个高效算法：已知n个数，取其中的m个数（m<=n），要求：m个数的两两间隔大于等于t，
这个给定的n个数的范围有限制吗？还有t。如果100个数两两之间间隔都大于t的话，一样会爆啊。。
H. 斐波那契数列任意项 高效算法的思路是什么
递归速度很慢的原因是：
每个函数占用一个栈，开辟栈是要时间的。
减少栈的开辟。
少用递归算法。
反其道而为之。
I. 如何设计一个高效算法，找到第一次重复出现的字符
定义字符串类的映射map类，建立map类对象。通过循环读入字符串到映射对象，遍历映射对象的迭代器，统计字符串出现次数，输出字符串和出现次数。给你个例子吧：
#include <iostream>#include <fstream>#include <map>#include <string>using namespace std ;int main ( int argc, char* argv [ ] ) { typedef map < string , int > WordMap ; // 定义特定的字符串映射类型 typedef WordMap :: iterator wmIter ; // 定义该类型的迭代器 const char* fname = "city.txt" ; // 缺省文件名串 if ( argc > 1 ) fname = argv [ 1 ] ; // 读入命令行的第一个参数，作为文件名路径串 ifstream in ( fname ) ; // 打开文件输入流 if ( ! in ) { // 如果打开错误，则显示提示信息后退出 cout << " Open file " << fname << " error ! " << endl ; system("pause"); return 1 ; } WordMap wordmap ; // 定义单词映射对象 string word ; // 定义单词字符串对象 while ( in >> word ) wordmap [ word ] ++ ; // 从文件中读入单词 // 遍历容器，显示输出计数大于等于2的单词和计数 for ( wmIter w = wordmap . begin ( ) ; w != wordmap . end ( ) ; w ++ ) if ( w->second >= 2 ) cout << w->first << " : " << w->second << endl ; system("pause"); return 0 ;}