2.16学习总结

 爆搜+剪枝优化

#include <stdio.h>
#include <math.h>

#define eps 1e-10
#define maxn 55

int n, m, x, y, ans = 0;
double k;

// 深度优先搜索函数
void dfs(int i, int j, double sum) {
    // 如果当前和已经超过目标值，剪枝返回
    if (sum > eps + k) {
        return;
    }
    // 如果当前和加上后续最小可能和都小于目标值，剪枝返回
    if (sum + (n - i) * 1.0 / (j + 1) + eps < k) {
        return;
    }
    // 如果当前和加上后续最大可能和都大于目标值，剪枝返回
    if ((sum + (n - i) * 1.0 / m) > k + eps) {
        return;
    }
    // 当已经选取了 n 个数时
    if (i == n) {
        // 判断当前和与目标值的差值的绝对值是否小于误差范围
        if (fabs(sum - k) <= eps) {
            ans++;
        }
        return;
    }
    // 选择当前数（即 j + 1）
    dfs(i + 1, j + 1, sum + 1.0 / (j + 1));
    // 不选择当前数
    dfs(i, j + 1, sum);
}

int main() {
    // 读取输入的 n, m, x, y
    scanf("%d %d %d %d", &n, &m, &x, &y);
    // 计算目标值
    k = (double)x / y;
    // 调用 dfs 函数，初始阶段 0，选到 0（从 1 开始选），和为 0
    dfs(0, 0, 0.0);
    // 输出满足条件的组合数量
    printf("%d", ans);
    return 0;
}

 

#include <stdio.h>
#include <stdbool.h>

#define MAXN 25

int n;
int north[MAXN], west[MAXN];  // 存储北墙和西墙箭靶上的箭的数目
bool visited[MAXN][MAXN];     // 标记方格是否已经访问过
int path[MAXN * MAXN];        // 存储路径
int pathLen = 0;              // 路径长度

// 判断是否可以移动到 (x, y) 方格
bool canMove(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < n && !visited[x][y];
}

// 检查箭靶数量是否合法
bool isLegal(int x, int y) {
    return north[y] > 0 && west[x] > 0;
}

bool dfs(int x, int y) {
    visited[x][y] = true;
    path[pathLen++] = x * n + y;
    north[y]--;
    west[x]--;

    if (x == n - 1 && y == n - 1) 
    {
        for (int i = 0; i < n; i++)
        {
            if (north[i] != 0 || west[i] != 0)
            {
                visited[x][y] = false;
                pathLen--;
                north[y]++;
                west[x]++;
                return false;
            }
        }
        return true;
    }

    int dx[] = { -1, 1, 0, 0 };
    int dy[] = { 0, 0, -1, 1 };
    for (int i = 0; i < 4; i++)
    {
        int newX = x + dx[i];
        int newY = y + dy[i];
        if (canMove(newX, newY) && isLegal(newX, newY))
        {
            if (dfs(newX, newY)) 
            {
                return true;
            }
        }
    }

    visited[x][y] = false;
    pathLen--;
    north[y]++;
    west[x]++;
    return false;
}

int main() 
{
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
        scanf("%d", &north[i]);
    for (int i = 0; i < n; i++)
        scanf("%d", &west[i]);

    dfs(0, 0);

    for (int i = 0; i < pathLen; i++)
    {
        if (i > 0)
        {
            printf(" ");
        }
        printf("%d", path[i]);
    }

    return 0;
}

 

#include <stdio.h>
#include <string.h>

#define MAXN 30

// 根据前序和中序遍历输出后序遍历结果
void getPostorder(char* inorder, char* preorder, int inStart, int inEnd, int* preIndex) {
    if (inStart > inEnd) return;

    // 从前序遍历中取出当前根节点
    char root = preorder[*preIndex];
    (*preIndex)++;

    // 在中序遍历中找到根节点的位置
    int inIndex;
    for (inIndex = inStart; inIndex <= inEnd; inIndex++) {
        if (inorder[inIndex] == root) break;
    }

    // 递归处理左子树
    getPostorder(inorder, preorder, inStart, inIndex - 1, preIndex);
    // 递归处理右子树
    getPostorder(inorder, preorder, inIndex + 1, inEnd, preIndex);
    // 输出根节点
    printf("%c", root);
}

int main() {
    char inorder[MAXN], preorder[MAXN];
    scanf("%s", inorder);
    scanf("%s", preorder);

    int len = strlen(inorder);
    int preIndex = 0;

    // 调用函数获取后序遍历结果
    getPostorder(inorder, preorder, 0, len - 1, &preIndex);

    return 0;
}