常用算法-基本算法

汉诺塔（递归）：

汉诺塔的算法就3个步骤：

第一，把a上的n-1个盘通过c移动到b。

第二，把a上的最下面的盘移到c。

第三，因为n-1个盘全在b上了，所以把b当做a重复以上步骤就好了。

#include <stdio.h>
#include <stdlib.h>

void move (char x,char y)
{
    printf("%c-->%c\n",x,y);
}

void hanoit(int n,char one,char two,char three)
{
    if(n==1)
        move(one,three);//当n只有1个的时候直接从a移动到c
    else
    {
        hanoit(n-1,one,three,two);//第n-1个要从a通过c移动到b
        move(one,three);
        hanoit(n-1,two,one,three); //n-1个移动过来之后b变开始盘，b通过a移动到c
}
int main()
{
    int m;
    printf("请输入你要移动的盘子数： ");
    scanf("%d",&m);
    printf("移动%d个盘子的步骤如下\n",m);
    hanoit(m,'A','B','C');
    system("pause");
    return 0;
} 

最大子段和（动态规划）：

动态规划法与分治法的不同之处在于分解后的子问题是相互不独立的。如果使用分治法去解这类问题，分解得到的子问题数目会很多，有些子问题会被重复计算多次。如果可以保存已经解决过的子问题的解，需要时再找出已经求解的答案，这样就免去大量的重复计算。

最大子段和的子段序列中不应该包含有零或负数，可以将序列的各子段的和记录到一个子段和的数组中，然后比较子段和数组中的元素从而得到最大子段和。

int max_sum(int a[],int n,int *best_i,int *best_j)
{
    int i,j;
    int this_sum[100];
    int sum[100];
    int max=0;
    this_sum[0]=0;
    sum[0]=0;
    *best_j=0;
    *best_i=0;
    
    i=1;
    for(j=1;j<=n;++j)
    {
        if(this_sum[j-1]>=0)
            this_sum[j]=this_sum[j-1]+a[j];
        else 
        {
            this_sum[j]=a[j];
            i=j;
        }
        
        if(this_sum[j]<= sum[j-1])
            sum[j]=sum[j-1];
        else
        {
            sum[j]=this_sum[j];
            *best_i=i;
            *best_j=j;
            max=sum[j];
        }
    } 
    return max;
}
int main()
{
    int i,j,n,a[100],t;
    printf("请输入数列的个数（<99）:\n");
    scanf("%d",&n);
    printf("请输入数列元素：\n");
    for(i=1;i<=n;++i)
    {   
        printf("第%d个：",i);
        scanf("%d",&a[i]);
    }
    i=j=1;
    t=max_sum(a,n,&i,&j);
    printf("最大子段和是： %d\n",t);
    printf("子段起点： %d\n",i);
    printf("子段终点： %d\n",j);
    system("PAUSE");
    return 0; 
} 

贪心算法：