算法设计思想

程序=数据结构+算法+程序设计语言

项目=程序+项目管理+质量控制+代码规范

    首先根据输入输出数据设计数据结构，再次设计相应的算法，最后使用某种编程语言。数据结构是算法实现的基础，算法依赖数据结构快速实现，二者相辅相承。

1.递推思想

  顺推法

    假设有一对兔子，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔子都不死，那么一年以后可以繁殖多少对兔子？即斐波那契数列。

    使用顺推法计算，F(n)=F(n-1)+F(n-2)。最后F(n-1)/F(n)=>0.618即黄金分割比。

     逆推法

    例如：假设父亲为小龙一次性存入大学的生活费，只容许其每个月初取出1000供下个月使用，考虑月利息为0.71%，且银行在每月最后一天才计算利息计入本金。问开学时应该存多少钱。思想：

       第48个月，月初时，账户剩余F(48)=1000
         第47个月，月初时，账户剩余F(47)=(1000/(1+0.0071))+1000=F(48)/(1+0.0071)+1000
         第46个月，月初时，账户剩余F(46)=F(47)/(1+0.0071)+1000
         ............

    使用逆推，最终得到F(1)

2.穷举思想

   满足2个条件：

        ⑴ 候选答案可数
        ⑵ 候选答案有确定的集合（便于使用条件判断语句和循环语句）

   例如：任意输入A,B,C,D,E，遍历加减乘除运算符，使“A( )B( )C( )D( )E =F”等式成立。思想：设定left,rigtht保存临时结果。left保存上次运算的结构，即下次运算的左侧，right保存下次将参加运算的数据，即下次运算的右侧内容。倘若为乘或除，直接运算right，倘若为加减，保存当前运算符，然后检查下一个运算符。若下一运算符为乘除，直接计算j结果保存至right，反之，计算left=left+flag*right。Operator[i]=0-4分别表示加减乘除。代码如下：

#include"iostream"
using namespace std;
void print(int num[5],int Operator[4],int answer)//输出某个解决方案
{
	int i=0;
	char index[4]={'+','-','*','/'};
	cout<<num[0];
	while(i<4)
	  {cout<<index[Operator[i]];cout<<num[i+1];i++;}
	cout<<"="<<answer<<endl;
}
void findSolution(int num[5],int answer)//嵌套循环遍历所有的解决方案
{
	int count=0;//计算器
	int flag;//1=+，-1=-
	int Operator[4];
	double left,right;//切记此处一定定义为double

	//嵌套遍历
	for(Operator[0]=0;Operator[0]<4;Operator[0]++) 
		if(Operator[0]<3||num[1]!=0) //当为除的时候，运算数不为0
		  for(Operator[1]=0;Operator[1]<4;Operator[1]++)
			if(Operator[1]<3||num[2]!=0)
			  for(Operator[2]=0;Operator[2]<4;Operator[2]++)
				if(Operator[2]<3||num[3]!=0)							
				 for(Operator[3]=0;Operator[3]<4;Operator[3]++)
					if(Operator[3]<3||num[4]!=0)
					  {left=0;right=num[0];flag=1;
						for(int i=0;i<4;i++)
						{
							switch(Operator[i])
							{
							    case 0:
									 left=left+flag*right;//运算的是当前符号之前2个数
									 right=num[i+1];
									 flag=1;//保存当前符号
									 break;
								case 1:
									left=left+flag*right;//运算的是当前符号的前2个数
									right=num[i+1];
									flag=-1;//保存当前符号，在后序操作有优先运算符的时候起作用
									break;
								case 2:
									right=right*num[i+1];
									break;
								case 3:
									 right=right/num[i+1];
									 break;
							}
						}
					    if(left+flag*right==answer)
					          {count++;cout<<count<<":";print(num,Operator,answer);}
	               }
	if(count)
	     cout<<"总共有"<<count<<"种方案"<<endl;
	else
	     cout<<"无有效解决方案，请重新输入"<<endl;
}
int _tmain(int argc, _TCHAR* argv[])
{
    cout<<"输入6个数，最后一个数为目标结果"<<endl;
    int num[5],answer;
    for(int i=0;i<5;i++) cin>>num[i];
    cin>>answer;
    findSolution(num,answer);
    return 0;
}

3.递归思想

      使用递归算法应该注意：

       ⑴必须有明确的递归结束条件即递归出口
       ⑵递归显得简洁但是运行效率低，主要反映在占存储空间
       ⑶递归过程中次数过多可能导致栈溢出（系统将每一次递归调用的返回点、局部变量等存入系统的栈中，      

   例如：10进制转换为任意进制。

void Convert(vector<int> &ans,int number,int n)
{
        if(!number) return;
	else
	   {ans.push_back(number%n);
	   Convert(ans,number/n,n);}
}

4.分治思想

           分治算法和递归算法常常是紧密结合使用的。将一个问题分成几个子问题，然后将几个子问题的答案合并起来就是上一级的答案。一般具有以下特征的问题，可用分治法解答：

       ⑴可以分解成若干小的问题
       ⑵当分界到某种规模时，极易求解
       ⑶合并子问题的解可以得到求解问题的解
       ⑷子问题之间的解相互独立

   例如：在《算法导论》第三版的40页提到这样的问题，重新解释该问题，即为求解某个一维矩阵中，相加值最大的子矩阵。这里使用分治法基于以下策略思考。谭若在矩阵中设立标号mid。那么这个子矩阵要么完全在mid之前或者之后，要么横跨mid，每一级分治中，都寻找这样的3个子数组然后比较大小进行决策。代码如下：

#include"iostream"
#include"cmath"
using namespace std;

typedef struct submax
{int low,high,maxsum;}SubArray;

SubArray FindCrossingMax(int data[],int length,int low,int middle,int high)//寻找跨越middle的最大子数组
{
    int present_left_sum=data[middle],left_max=data[middle];//寻找最大左子数组
	int left_label=middle;
	for(int j=middle-1;j>=low;j--)
	 {present_left_sum+=data[j];
	   if(left_max<present_left_sum)
	     {left_max=present_left_sum;left_label=j;}}

    int present_right_sum=data[middle+1],right_max=data[middle+1];//寻找最大右子数组
    int right_label=middle+1;
    for(int j=middle+2;j<=high;j++)
	{present_right_sum+=data[j];
	if(right_max<present_right_sum)
	{right_max=present_right_sum;right_label=j;}}
	
    SubArray max={left_label,right_label,left_max+right_max};//跨越最大子数组=左子数组(含mid)+最大右子数组(含mid+1)
	return max;
}
SubArray FindMaxSubArray(int data[],int length,int low,int high)//寻找最大子数组
{
	if(high==low)
		{SubArray max={low,high,data[low]};return max;}
	else
		{int mid=floor(((double)high+low)/2);
	        SubArray leftmax=FindMaxSubArray(data,length,low,mid);//寻找最大左(相对middle)子数组
		SubArray rightmax=FindMaxSubArray(data,length,mid+1,high);//寻找最大右(相对middle)子数组
		SubArray crossingmax=FindCrossingMax(data,length,low,mid,high);//寻找跨越middle的最大子数组
		  
		  if(leftmax.maxsum>=rightmax.maxsum&&leftmax.maxsum>=crossingmax.maxsum)
			  return leftmax;
		  else if(rightmax.maxsum>=leftmax.maxsum&&rightmax.maxsum>=crossingmax.maxsum)
			  return rightmax;
		  else
			 return crossingmax;
	    }
}

SubArray FindMaxSubArray(int data[],int length)//非递归法计算最大子数组
{
	int max=data[0];
	int low=0,high=0;//初始化
	for(int i=1;i<length;i++)
	    {int present_sum=data[i],present_max=data[i];
	     int label=i;
		  for(int j=i-1;j>-1;j--)
		      {present_sum+=data[j];
			   if(present_max<present_sum)
			      {present_max=present_sum;label=j;}}
		  if(present_max>max)
		       {max=present_max;low=label;high=i;}  
	     }
	SubArray maxarray={low,high,max};
	return maxarray;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int  data[]={13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7};
	SubArray max=FindMaxSubArray(data,sizeof(data)/sizeof(int),0,sizeof(data)/sizeof(int)-1);//分治法
	SubArray max=FindMaxSubArray(data,sizeof(data)/sizeof(int));//非分治法
	for(int i=max.low;i<=max.high;i++)
	  cout<<data[i]<<" ";

	return 0;
}

5.贪婪思想

      解为局部最优解。但对大部分问题，该解基本上近似整体最优解。贪婪算法基于当前初始解，采取逐步逼近的策略，不需要回溯。该算法存在以下问题：

      ⑴不能保证解最优
      ⑵不能用来求最大最小解问题
      ⑶只能满足某些约束条件可行解的范围。

    一般实现策略如下：

      解初始化；
      while(尚未达到可行解总目标)
         求可行解的一个解元素；
      所有元素组成一个初始解；

    

6.试探思想

7.模拟思想