软设-算法

学习整理自B站视频：zst_2001

回溯法

类似于走迷宫，每条路都会试一遍，走不通就返回原点重新出发走另一条路

N皇后问题

解决判断：
①只要两个坐标之间的列都相同，说明处于同一列不符合条件
②只要两个坐标之间行的差和列的差的绝对值都相同，说明处于同一斜线不符合条件
同一行的条件不会出现，因为一行只会放一个

非递归求解N皇后

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define N 4

/*
    N皇后问题  非递归求解
*/

int q[N + 1]; // 存储皇后的列号

int check(int j) {  // 判断第j个皇后是否合法
    int i;
    for(i = 1; i < j; i++){
        if(q[i] == q[j] || abs(i-j) == abs(q[i]-q[j])) {  // 判断是否在同一列 或 同一斜线
            return 0;
        }
    }
    return 1;
}

void queen() {  // 求解N皇后
    int i;
    for(i = 1; i <= N; i ++ ){  // 默认无位置存放
        q[i] = 0;
    }

    int answer = 0; // 解决方案个数

    int j = 1; // 第j个皇后
    while(j >= 1){
        q[j] = q[j] + 1;    // 第j个皇后向后一列摆放

        while(q[j] <= N && !check(j)) {  // 第j个皇后存放的位置不合法
            q[j] = q[j] + 1;    // 不合法就往后一列位置摆放 
        }

        if (q[j] <= N){     // 第j个皇后找到合法的摆放位置
            if(j == N){ //   筛选成功
                answer ++;
                printf("第%d个方案：",answer);
                for(i = 1;i <= N; i ++) {
                    printf("%d ",q[i]);
                }
                printf("\n");
            }
            else { // 筛选下一行
                j ++;
            }
        }
        else {  // 本列超出位置，筛选失败,进行回溯
            q[j] = 0;
            j --;
        }

        
    }
}

int main() {
    queen();
    system("pause");    // 防止运行后自动退出，需要头文件#include<stdlib.h>
    return 0;
}

递归求解N皇后

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define N 4

/*
    N皇后问题  递归求解
*/

int answer = 0;
int q[N + 1]; // 存储皇后的列号

int check(int j) {  // 判断第j个皇后是否合法
    int i;
    for(i = 1; i < j; i++){
        if(q[i] == q[j] || abs(i-j) == abs(q[i]-q[j])) {  // 判断是否在同一列 或 同一斜线
            return 0;
        }
    }
    return 1;
}

int queen(int j) {
    int i;
    for(i = 1; i <= N; i++){
        q[j] = i;
        
        if (check(j))   // 第j个皇后摆放到合适的位置
        {
            if (j == N) // 找到一组正确的解
            {
                answer++;
                printf("第%d个方案：",answer);
                for (i = 1; i <= N; i++)
                {
                    printf("%d ",q[i]);
                }
                printf("\n");
            }
            else{   // 递归摆放下一行
                queen(j+1);
            }
        }
    }
}


int main() {
    queen(1);
    system("pause");    // 防止运行后自动退出，需要头文件#include<stdlib.h>
    return 0;
}

分治法

递归

分治的基本思想

归并排序

#include <stdio.h>
#include <sched.h>

void Merge(int A[], int p, int q, int r) {
    int i, j, k;

    int L[50], R[50];
    int n1 = q - p + 1, n2 = r - q;
    for (i = 0; i < n1; i ++ ) {
        L[i] = A[p + i];
    }

    for (j = 0; j < n2; j ++ ) {
        R[j] = A[q + j + 1];
    }

    L[n1] = INT_MAX;
    R[n2] = INT_MAX;

    i = 0;
    j = 0;
    for (k = p; k < r + 1; k ++ ) {
        if (L[i] < R[j]) {
            A[k] = L[i];
            i ++ ;
        } else {
            A[k] = R[j];
            j ++ ;
        }
    }
}

void MergeSort(int A[], int p, int r) {
    int q;
    if (p < r) {
        q = (p + r) / 2;
        MergeSort(A, p, q);
        MergeSort(A, q + 1, r);

        Merge(A, p, q, r);
    }
}

int main() {
    int A[] = {4, 1, 3, 6, 8, 5, 2, 9};
    MergeSort(A, 0, 7);

    int i;
    for (i = 0; i < 8; i ++ ) {
        printf("%d ", A[i]);
    }

    return 0;
}

最大字段和问题

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

int MaxSubSum(int *Array, int left, int right) {
    int sum = 0;
    int i;

    if (left == right) {
        if (Array[left] > 0)
            sum = Array[left];
        else
            sum = 0;
    } else {
        int center = (left + right) / 2;
        int leftSum = MaxSubSum(Array, left, center);
        int rightSum = MaxSubSum(Array, center + 1, right);

        int s1 = 0;
        int lefts = 0;
        for (i = center; i >= left; i -- ) {
            lefts += Array[i];
            if (lefts > s1)
                s1 = lefts;
        }

        int s2 = 0;
        int rights = 0;
        for (i = center + 1; i <= right; i ++ ) {
            rights += Array[i];
            if (rights > s2)
                s2 = rights;
        }

        sum = s1 + s2;

        if (sum < leftSum)
            sum = leftSum;

        if (sum < rightSum)
            sum = rightSum;
    }

    return sum;
}

int main() {
    int *Array = (int *) malloc(6 * sizeof(int));
    Array[0] = -2;
    Array[1] = 11;
    Array[2] = -4;
    Array[3] = 13;
    Array[4] = -5;
    Array[5] = -2;

    int result = MaxSubSum(Array, 0, 5);
    printf("%d", result);

    return 0;
}

动态规划法

分治法和动态规划法一样，会把待求解问题分解成若干个子问题，先求解子问题，再从子问题的解得到原问题的解。但是，若用分治法，其分解的子问题往往不是独立的，相同的子问题会被求解多次，以至于最后解决原问题要耗费指数级时间。而使用动态规划的话，会用一个表来记录所有已解决的子问题的答案，等到用到的时候直接从表里取即可，节省了时间。

0-1背包问题

这里的子问题看作：从前 i 个物品中选，背包容量为 j 时的最优解

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

#define N 4     // 物品数量
#define W 5     // 背包容量

int max(int a, int b){
    return a>b?a:b;
}

int main(){

    int v[] = {0, 2, 4, 5, 6};  // 物品价值数组
    int w[] = {0, 1, 2, 3, 4};  // 物品重量数组

    int f[N + 1][W + 1] = {};   // 子问题解数组

    int i, j;
    for(i = 1;i <= N; i++){
        for(j = 1; j <= W; j++){
            // 默认不选第i个物品
            f[i][j] = f[i - 1][j];  // 不选第i个物品 --》等于从第i-1个物品中选，背包容量为 j 时的最大值
            if(j >= w[i]){  // 选第i个物品的前提条件
                // 等于 不选第i个物品 和 选第i个物品 两者的较大值
                f[i][j] = max(f[i][j], v[i] + f[i - 1][j - w[i]]);
            }
        }
    }
    printf("%d\n", f[N][W]);
    for(i = 0;i <= N; i++){
        for(j = 0; j <= W; j++){
            printf("%d ",f[i][j]);
        }
        printf("\n");
    }
    system("pause");    // 防止运行后自动退出，需要头文件#include<stdlib.h>
    return 0;
}

矩阵连乘问题

时间复杂度：O(n3)
空间复杂度：O(n2)

最长公共子序列

穷举法的时间复杂度为：O(n2n)
动态规划的时间复杂度为：O(n2)

贪心法

部分背包问题

#include <stdio.h>

#define N 5 // 物品数量
#define W 10 // 背包容量

int v_temp[N + 1], w_temp[N + 1]; // 物品价值数组 和 物品重量数组的临时数组
double vw_temp[N + 1]; // 物品单位重量价值数组的临时数组

double answer[N + 1]; // 解方案数组

// 归并排序
void merge_sort(int v[], int w[], double vw[], int l, int r) {
    if (l >= r) return;

    int mid = l + r >> 1;
    merge_sort(v, w, vw, l, mid), merge_sort(v, w, vw, mid + 1, r);

    int i = l, j = mid + 1, k = 1;
    while (i <= mid && j <= r)
    {
        if (vw[i] >= vw[j]) { // 按照 物品单位重量价值数组 从大到小的顺序排序
            vw_temp[k] = vw[i];
            v_temp[k] = v[i];
            w_temp[k] = w[i];

            k ++ , i ++ ;
        } else {
            vw_temp[k] = vw[j];
            v_temp[k] = v[j];
            w_temp[k] = w[j];

            k ++ , j ++ ;
        }
    }

    while (i <= mid) {
        vw_temp[k] = vw[i];
        v_temp[k] = v[i];
        w_temp[k] = w[i];

        k ++ , i ++ ;
    }

    while (j <= r) {
        vw_temp[k] = vw[j];
        v_temp[k] = v[j];
        w_temp[k] = w[j];
        k ++ , j ++ ;
    }

    for (i = l, j = 1; i <= r; i ++ , j ++ ) {
        vw[i] = vw_temp[j];
        v[i] = v_temp[j];
        w[i] = w_temp[j];
    }
}

// 显示物品价值、重量、单位重量价值数组
void show(int v[], int w[], double vw[]) {
    int i;

    printf("物品价值数组：");
    for (i =  1; i <= N; i ++ ) printf("%d ", v[i]);
    printf("\n");

    printf("物品重量数组：");
    for (i =  1; i <= N; i ++ ) printf("%d ", w[i]);
    printf("\n");

    printf("物品单位重量价值数组：");
    for (i =  1; i <= N; i ++ ) printf("%.1lf ", vw[i]);
    printf("\n");
}

// 求解部分背包问题最优解
double Max_Value(int v[], int w[], double vw[]) {
    double result = 0.0;

    int i;
    int W_temp = W;
    for (i = 1; i <= N; i ++ ) {
        if (W_temp >= w[i]) { // 当前背包容量 大于等于 物品重量 就直接全部装入到背包中
            answer[i] = 1.0;

            result = result + v[i];

            W_temp = W_temp - w[i];
        } else { // 当前背包容量 小于 物品重量 就应该将该物品的一部分装入到背包中
            break;
        }
    }

    if (W_temp > 0 && i <= N) { // 当前背包还有剩余容量 并且 还有可选的物品
        answer[i] = (double) W_temp / w[i];

        result = result + W_temp * vw[i];
        // result = result + (double) W_temp / w[i] * v[i];
    }

    return result;
}

int main() {
    int v[] = {0, 6, 3, 5, 4, 6}; // 物品价值数组
    int w[] = {0, 2, 2, 6, 5, 4}; // 物品重量数组

    double vw[N + 1]; // 物品单位重量价值数组

    int i;
    // 初始化 物品单位重量价值数组
    for (i = 1; i <= N; i ++ ) vw[i] = (double) v[i] / w[i];

    printf("排序前：\n");
    show(v, w, vw);

    merge_sort(v, w, vw, 1, N);

    printf("排序后：\n");
    show(v, w, vw);

    double result = Max_Value(v, w, vw);
    printf("\nresult = %.2lf\n", result);
    printf("\n");

    printf("解方案结果：");
    for (i = 1; i <= N; i ++ ) printf("%.1lf ", answer[i]);

    return 0;
}

时间复杂度为：O（nlgn），即归并排序的时间复杂度为主

例题

总结

回溯法：深度优先的方式搜索
分治法：原问题分解为若干子问题，分别求解子问题，再合并起来继续求解原问题
动态规划：问题具有最优子结构，而且求解过程中子问题被重复求解
贪心法：局部最优，不能保证全局最优解，可以得到近似最优解

区分动态规划法和贪心法

区分回溯法和分支限界法

回溯法：深度优先
分支限界法：广度优先