图灵机仿真 和 递归函数仿真系统 与 0/1背包问题 c++

图灵机仿真系统

1. 功能：
   • 仿真有限状态自动机及其状态转移过程。
   • 仿真纸带及读写头的读、写操作。
2. 要求：
   • 演示给定输入时二分搜索算法在仿真系统中的动态执行过程。
   • 给出正确结果。
   • 计数所使用的纸带空间和步数。

递归函数仿真系统

1. 功能：
   • 仿真递归函数的调用过程。
   • 仿真Stack及Push、POP操作。
2. 要求：
   • 演示给定输入时二分搜索算法在仿真系统中的动态执行过程。
   • 给出正确结果。
   • 计数所使用的纸带空间、栈的空间以及步数。

两种仿真系统的性能对比分析

1. 任务：
   • 给定一个0/1背包问题。
2. 要求：
   • 在图灵机仿真系统中：
     • 采用动态规划和分支限界求解。
   • 在递归函数仿真系统中：
     • 采用备忘录和回溯求解。

总结

• 对两个仿真系统进行开发和测试，包括图灵机仿真系统和递归函数仿真系统。
• 演示二分搜索算法在这两个系统中的执行过程，并进行纸带空间、步数、栈空间等资源使用情况的计数。
• 对比分析两种仿真系统在解决0/1背包问题时采用不同算法的性能差异。

//1. 图灵机仿真系统
//功能要求：
//仿真有限状态自动机及其状态转移过程。
//仿真纸带及读写头的读、写操作。
//演示给定输入时二分搜索算法的动态执行过程，计数纸带空间和步数。
// 
// 
//2. 递归函数仿真系统
//功能要求：
//仿真递归函数的调用过程。
//仿真栈及push、pop操作。
//演示给定输入时二分搜索算法的动态执行过程，计数栈空间和步数。

#include "TuringMachine.h"
#include "RecursiveFunctionSimulator.h"

#include <vector>
#include <iostream>

int turingMachineTest() {
    // 创建图灵机对象
    TuringMachine tm;

    // 设置要搜索的数组和搜索值
    std::vector<int> arr = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 };
    int searchValue = 13;
    tm.setArray(arr, searchValue);

    // 添加状态转移规则
    tm.addTransition(State::Start, ' ', State::Compare, ' ', 'R');
    tm.addTransition(State::Compare, ' ', State::Compare, ' ', 'R');
    tm.addTransition(State::Compare, ' ', State::Found, ' ', ' ');
    tm.addTransition(State::Compare, ' ', State::NotFound, ' ', ' ');

    // 运行图灵机
    tm.run();

    return 0;
}

int recursiveFunctionSimulatorTest() {
    // 创建递归函数仿真器对象
    RecursiveFunctionSimulator simulator;

    // 准备要搜索的数组和目标值
    std::vector<int> arr = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 };
    int target = 13;
    int low = 0;
    int high = arr.size() - 1;

    // 模拟二分搜索的递归调用过程
    int result = simulator.binarySearch(arr, low, high, target);

    // 输出搜索结果
    if (result != -1) {
        std::cout << "Found target " << target << " at index " << result << std::endl;
    }
    else {
        std::cout << "Target " << target << " not found in the array." << std::endl;
    }

    // 输出仿真结果
    std::cout << "Maximum stack space used: " << simulator.getStackSpace() << std::endl;
    std::cout << "Total steps: " << simulator.getSteps() << std::endl;

    return 0;
}

int main()
{
    std::cout << "------ turing Machine Test ------ " << std::endl;

    turingMachineTest();

    std::cout << "------ recursive Function Simulator Test ------ " << std::endl;

    recursiveFunctionSimulatorTest();
}

#include "RecursiveFunctionSimulator.h"
#include "TuringMachine.h"
#include <vector>
#include <iostream>

int main() {

     number of items: 5
    //std::vector<int> weights = { 2, 2, 3, 4, 5 };
    //std::vector<int> values = { 3, 4, 5, 8, 10 };
    //int capacity = 10;


    // 输入背包问题的数据
    int n;
    std::cout << "Enter the number of items: "; 
    std::cin >> n;

    std::vector<int> weights(n);
    std::vector<int> values(n);

    std::cout << "Enter weights of items: ";
    for (int i = 0; i < n; ++i) {
        std::cin >> weights[i];
    }

    std::cout << "Enter values of items: ";
    for (int i = 0; i < n; ++i) {
        std::cin >> values[i];
    }

    int capacity;
    std::cout << "Enter the capacity of the knapsack: ";
    std::cin >> capacity;

    // 使用图灵机仿真系统运行动态规划解法
    TuringMachine tm;
    tm.addTransition(State::Init, 'I', State::Compute, 'C', 'R');
    tm.addTransition(State::Compute, 'C', State::FinalState, 'F', 'R');

    tm.runDynamicProgramming(capacity, weights, values);
    std::cout << "Dynamic Programming Steps: " << tm.getSteps() << std::endl;

    // 使用图灵机仿真系统运行分支限界法解法
    tm.runBranchAndBound(capacity, weights, values);
    std::cout << "Branch and Bound Steps: " << tm.getSteps() << std::endl;

    // 使用递归函数仿真系统运行备忘录解法
    RecursiveFunctionSimulator rfs_memo;
    int max_value_memo = rfs_memo.solveKnapsackMemoization(capacity, weights, values, weights.size() - 1);
    std::cout << "Memoization Maximum value = " << max_value_memo << std::endl;
    std::cout << "Memoization Steps: " << rfs_memo.getSteps() << std::endl;
    std::cout << "Memoization Stack space: " << rfs_memo.getStackSpace() << std::endl;

    // 使用递归函数仿真系统运行回溯法解法
    RecursiveFunctionSimulator rfs_backtracking;
    int max_value_backtracking = rfs_backtracking.solveKnapsackBacktracking(capacity, weights, values, weights.size() - 1);
    std::cout << "Backtracking Maximum value = " << max_value_backtracking << std::endl;
    std::cout << "Backtracking Steps: " << rfs_backtracking.getSteps() << std::endl;
    std::cout << "Backtracking Stack space: " << rfs_backtracking.getStackSpace() << std::endl;

    return 0;
}

+ WhatIsLivingFor