算法第三章上机实践报告

一、上机题目解析

实践题目：

7-1 数字三角形

#include<iostream>
using namespace std;


int main(){
    int n;//n为三角形的行数
    cin >> n;
    int a[n][n],b[n][n];
    for(int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            cin >> a[i][j];
        }
    }
    //先将b数组全部置为0 
    for(int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            b[i][j] = 0;
        }
    }
    //再将a数组的最后一行复制到b数组中 
    for(int l=0;l<=n-1;l++){
        b[n-1][l] = a[n-1][l];
    }
    //给b数组填表，将max加到a数组的对应层 
    for(int p=n-1;p>0;p--){
        for(int q=0;q<p;q++){
            if((a[p-1][q]+b[p][q]) > (a[p-1][q] + b[p][q+1]))
                    b[p-1][q] = a[p-1][q] + b[p][q];
            else b[p-1][q] = a[p-1][q] + b[p][q+1];            
        }
    } 
    
    cout << b[0][0];
    return 0;
} 

#include<iostream>
using namespace std;

int main(){
    int n;
    cin >> n;//三角形有n行 
    int a[n][n];
    for(int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            cin >> a[i][j];
            }
    } 

    for(int p = n-1;p > 0;p--){
        for(int q = 0;q < p;q++){
            if((a[p][q] + a[p-1][q]) > (a[p][q+1]+a[p-1][q]))
                    a[p-1][q] = a[p][q] + a[p-1][q] ;
            else a[p-1][q] = a[p][q+1]+a[p-1][q];
        }
    }
    cout << a[0][0];
    return 0;
}

算法描述：

①对于给出的数字三角形，我们是根据自底向上顺序来计算的

②递推公式

b[i-1][j] = max(a[i][j]，a[i][j+1])+a[i-1][j]

时间复杂度：

T（n）= 3O(n²）+O（n）=O（n²）因为在主要在填表过程中需要有两层for循环

空间复杂度：申请了一个b数组 S(n)=O（n）

7-2 最大子段和

 

 参考：

算法设计与分析_中国大学MOOC(慕课)  https://www.icourse163.org/learn/PKU-1002525003?tid=1002695005#/learn/content?type=detail&id=1003858255

/*给出一个长度为n的序列A1、A2、A3、...、An，
求最大连续和。即找到1<=i<=j<=n,使得Ai+Ai+1+...+Aj最大*/ 
#include<iostream>
using namespace std;

/*穷举法（暴力）*/
int maxsum(int* a,int l,int r){
    int pi =0,pj=0;
    int max = a[l];
    for(int i=l;i <=r;i++){
        for(int j=i;j<=r;j++){
            int sum =0;
            for(int k=i;k<=j;k++){
                sum+=a[k];
            }
            if(sum>max){
                max = sum;
                pi = i;
                pj = j;
            }
        }
    }
    return max;
}

int main(){
    int n;
    cin >>n;
    int a[n];
    for(int i=0;i<n;i++){
        cin >> a[i];
    }
    cout  << maxsum(a,0,n-1);
    return 0; 
}

暴力穷举法：时间复杂度O（n³）

#include<iostream>
using namespace std;

int getMaxNum(int a,int b,int c){
    if (a > b&&a > c){
        return a;
    }
    if (b > a&&b > c){
        return b;
    }
    return c;
}
int maxSumRec(int data[], int left, int right){
    if (right - left == 1){
        //如果当前序列只有一个元素
        return data[left];
    }
    int center = (left + right) / 2;//计算当前序列的分裂点
    int maxLeftSum = maxSumRec(data,left,center);
    int maxRightSum = maxSumRec(data,center,right);
    //计算左边界最大子序列和
    int leftBonderSum = 0;
    int maxLeftBonderSum = data[center-1];
    for (int i = center - 1; i >= left; i--){
        leftBonderSum += data[i];
        if (maxLeftBonderSum < leftBonderSum){
            maxLeftBonderSum = leftBonderSum;
        }
    }
    //计算右边界最大子序列和
    int rightBonderSum = 0;
    int maxRightBonderSum = data[center];
    for (int i = center; i < right; i++){
        rightBonderSum += data[i];
        if (maxRightBonderSum < rightBonderSum){
            maxRightBonderSum = rightBonderSum;
        }
    }
    //返回当前序列最大子序列和
    return getMaxNum(maxLeftBonderSum + maxRightBonderSum, maxLeftSum, maxRightSum);
}

int main(){
    int n;
    cin >> n;
    int a[100];
    for(int i=0;i<n;i++){
        cin >> a[i];
    } 
    cout << maxSumRec(a,0,n-1);
    return 0; 
}

时间复杂度

T(n)=2T(n/2)+O(n)=2T(n/4)+O(n)+O(n)=2T(n/8)+O(n)+O(n)+O(n)=O（nlogn）

#include<iostream>
using namespace std;

int MAX(int a[],int b[],int n,int max){
    //数组b存放每个子段和 
    int sum=0;
    //边界条件 令b[0]=a[0]  
    for(int i=0;i<n;i++){
        if(i==0){
            b[i] = a[i];
            max =b[i];
        }
    //如果前一个数b[i-1]<0 则数组b中的下一个数就不需要加上前一个数 反之则需要加上      
        else{
            if(b[i-1]<0)
                b[i] = a[i];
            else
                b[i] = b[i-1] + a[i];
            if(b[i]>max)
                max = b[i];    
        }
        //计算负数的个数 
        if(a[i] < 0) sum++;
    }
    if(sum == n) return 0;//如果全为负数 则返回0 
    else return max;
} 

int main(){
    int n;
    cin >> n;
    int a[1000];
    for(int i=0;i<n;i++){
        cin >> a[i];
    }
    int b[1000];
    int max=0;
    max = MAX(a,b,n,max);
    cout << max;
    return 0;
}

时间复杂度： 

用动态规划的方法

由于只有一个For循环 因此时间复杂度为O（n）

空间复杂度：申请了一个b数组 空间复杂度为O（n）

 7-3 编辑距离问题 

 

 

#include<iostream>
#include<cstdio>
using namespace std;

string A,B;
int Distance[4001][4001];

int main(){

    cin >> A >> B; 
    //假设一个字符串为空字符串，则他们两个之间的编辑距离就是另一个字符串的长度 
    for(int i=1;i<=A.size();i++){
        Distance[i][0] = i;
    }    
    for(int i=1;i<= B.size();i++){
        Distance[0][i] = i; 
    }    
    for(int i=1;i<=A.size();i++){
        for(int j=1;j<= B.size();j++){
            //因为数组没有经过初始化 所以默认所有元素都是0，也就是说如果两个字符串的对应字符相等，则他们之间的编辑距离为默认值0，不用改变 
        if(A[i-1] == B[j-1]) Distance[i][j] = Distance[i-1][j-1];
        else{//如果字符串中对应的字符不相等则，比较 上面和左边的数的大小 取小 然后再跟斜对角线的比较 
            Distance[i][j] = Distance[i-1][j] < Distance[i][j-1] ? Distance[i-1][j] : Distance[i][j-1];            
            Distance[i][j] = Distance[i][j] < Distance[i-1][j-1] ? Distance[i][j] : Distance[i-1][j-1];
            Distance[i][j]++;    
            }
        }
    }
    cout << Distance[A.size()][B.size()];
    return 0; 
} 

 

 

时间复杂度：T（n）=O(n²)+2O（n）=O (n) 主要在填表过程中，用了两个for循环

空间复杂度：S（n）=O (n²)申请了b[n][n]这个二维数组

二、心得体会

这次上机我和我的搭档没有上次那么顺利，上次我们还没下课就已经写完三道题，这次我们一直卡在第二道题那

1.在课上我们成功做出第一道题，但我们并没有用到填表的方法，

#include<iostream>
using namespace std;

int main(){
    int n;
    cin >> n;//三角形有n行 
    int a[n][n];
    for(int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            cin >> a[i][j];
            }
    } 

    for(int p = n-1;p > 0;p--){
        for(int q = 0;q < p;q++){
            if((a[p][q] + a[p-1][q]) > (a[p][q+1]+a[p-1][q]))
                    a[p-1][q] = a[p][q] + a[p-1][q] ;
            else a[p-1][q] = a[p][q+1]+a[p-1][q];
        }
    }
    cout << a[0][0];
    return 0;
}

但是我们其实是用来填表的思想的

后来下课后 我改进了一下 改成了用填表的方法

#include<iostream>
using namespace std;


int main(){
    int n;//n为三角形的行数
    cin >> n;
    int a[n][n],b[n][n];
    for(int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            cin >> a[i][j];
        }
    }
    //先将b数组全部置为0 
    for(int i=0;i<n;i++){
        for(int j=0;j<=i;j++){
            b[i][j] = 0;
        }
    }
    //再将a数组的最后一行复制到b数组中 
    for(int l=0;l<=n-1;l++){
        b[n-1][l] = a[n-1][l];
    }
    //给b数组填表，将max加到a数组的对应层 
    for(int p=n-1;p>0;p--){
        for(int q=0;q<p;q++){
            if((a[p-1][q]+b[p][q]) > (a[p-1][q] + b[p][q+1]))
                    b[p-1][q] = a[p-1][q] + b[p][q];
            else b[p-1][q] = a[p-1][q] + b[p][q+1];            
        }
    } 
    
    cout << b[0][0];
    return 0;
} 

2.对于第二道题，我们刚开始一直在思考 如何使得算出的两个正数之间的序列和

后来我回来上网查了一下 并在慕课看到类似的题，我发现了这个也是用填表法，其实老师在将第二章分治法的时候也用了分治法做了一遍 ，这次用填表法，是将每个子段和存到另外一个数组，这样可以，递归调用，如果该原数组的数为负数 则不加进子段和 这样一层层的求出

3.第三题 的确让我很懵逼，虽然也是用填表法做 ，但我有些不理解，为什么要在上 左 斜对角这三个元素中去最小值呢？希望老师上课可以详细的讲一下

上机体会：

我发现算法越来越难，这次上机 我和我的搭档一起解题的时候，总是希望用老师将的算法知识 方法解，但是总有重重困难，而且动态规划也蛮复杂的，的确要认真的体会领悟，多看几遍题，多想，然后把不会的题一定要理解。